/mandos/trunk : revision 451

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

# This program is free software: you can redistribute it and/or modify

18

# it under the terms of the GNU General Public License as published by

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

63

64

65

import dbus

65

66

import dbus.service

80

81

SO_BINDTODEVICE = None

81

82

83

version = "1.0.14"

84

version = "1.2"

84

85

86

#logger = logging.getLogger(u'mandos')

85

87

logger = logging.Logger(u'mandos')

86

88

syslogger = (logging.handlers.SysLogHandler

87

89

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

155

157

u" after %i retries, exiting.",

156

158

self.rename_count)

157

159

raise AvahiServiceError(u"Too many renames")

158

self.name = self.server.GetAlternativeServiceName(self.name)

160

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

159

161

logger.info(u"Changing Zeroconf service name to %r ...",

160

unicode(self.name))

162

self.name)

161

163

syslogger.setFormatter(logging.Formatter

162

164

(u'Mandos (%s) [%%(process)d]:'

163

165

u' %%(levelname)s: %%(message)s'

164

166

% self.name))

165

167

self.remove()

166

self.add()

168

try:

169

self.add()

170

except dbus.exceptions.DBusException, error:

171

logger.critical(u"DBusException: %s", error)

172

self.cleanup()

173

os._exit(1)

167

174

self.rename_count += 1

168

175

def remove(self):

169

176

"""Derived from the Avahi example code"""

192

199

self.group.Commit()

193

200

def entry_group_state_changed(self, state, error):

194

201

"""Derived from the Avahi example code"""

195

logger.debug(u"Avahi state change: %i", state)

202

logger.debug(u"Avahi entry group state change: %i", state)

196

203

197

204

if state == avahi.ENTRY_GROUP_ESTABLISHED:

198

205

logger.debug(u"Zeroconf service established.")

211

218

self.group = None

212

219

def server_state_changed(self, state):

213

220

"""Derived from the Avahi example code"""

221

logger.debug(u"Avahi server state change: %i", state)

214

222

if state == avahi.SERVER_COLLISION:

215

223

logger.error(u"Zeroconf server name collision")

216

224

self.remove()

232

240

"""A representation of a client host served by this server.

233

241

234

242

Attributes:

235

name: string; from the config file, used in log messages and

236

D-Bus identifiers

243

_approved: bool(); 'None' if not yet approved/disapproved

244

approval_delay: datetime.timedelta(); Time to wait for approval

245

approval_duration: datetime.timedelta(); Duration of one approval

246

checker: subprocess.Popen(); a running checker process used

247

to see if the client lives.

248

'None' if no process is running.

249

checker_callback_tag: a gobject event source tag, or None

250

checker_command: string; External command which is run to check

251

if client lives. %() expansions are done at

252

runtime with vars(self) as dict, so that for

253

instance %(name)s can be used in the command.

254

checker_initiator_tag: a gobject event source tag, or None

255

created: datetime.datetime(); (UTC) object creation

256

current_checker_command: string; current running checker_command

257

disable_hook: If set, called by disable() as disable_hook(self)

258

disable_initiator_tag: a gobject event source tag, or None

259

enabled: bool()

237

260

fingerprint: string (40 or 32 hexadecimal digits); used to

238

261

uniquely identify the client

239

secret: bytestring; sent verbatim (over TLS) to client

240

262

host: string; available for use by the checker command

241

created: datetime.datetime(); (UTC) object creation

263

interval: datetime.timedelta(); How often to start a new checker

264

last_approval_request: datetime.datetime(); (UTC) or None

265

last_checked_ok: datetime.datetime(); (UTC) or None

242

266

last_enabled: datetime.datetime(); (UTC)

243

enabled: bool()

244

last_checked_ok: datetime.datetime(); (UTC) or None

267

name: string; from the config file, used in log messages and

268

D-Bus identifiers

269

secret: bytestring; sent verbatim (over TLS) to client

245

270

timeout: datetime.timedelta(); How long from last_checked_ok

246

271

until this client is disabled

247

interval: datetime.timedelta(); How often to start a new checker

248

disable_hook: If set, called by disable() as disable_hook(self)

249

checker: subprocess.Popen(); a running checker process used

250

to see if the client lives.

251

'None' if no process is running.

252

checker_initiator_tag: a gobject event source tag, or None

253

disable_initiator_tag: - '' -

254

checker_callback_tag: - '' -

255

checker_command: string; External command which is run to check if

256

client lives. %() expansions are done at

257

runtime with vars(self) as dict, so that for

258

instance %(name)s can be used in the command.

259

current_checker_command: string; current running checker_command

260

changesignal: File descriptor; written to on object change

261

_reset: File descriptor; for flushing changesignal

262

delay: datetime.timedelta(); how long to wait for approval/secret

263

approved: bool(); None if not yet approved/disapproved

272

runtime_expansions: Allowed attributes for runtime expansion.

264

273

"""

265

274

275

runtime_expansions = (u"approval_delay", u"approval_duration",

276

u"created", u"enabled", u"fingerprint",

277

u"host", u"interval", u"last_checked_ok",

278

u"last_enabled", u"name", u"timeout")

279

266

280

@staticmethod

267

281

def _timedelta_to_milliseconds(td):

268

282

"Convert a datetime.timedelta() to milliseconds"

277

291

def interval_milliseconds(self):

278

292

"Return the 'interval' attribute in milliseconds"

279

293

return self._timedelta_to_milliseconds(self.interval)

294

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

280

297

281

298

def __init__(self, name = None, disable_hook=None, config=None):

282

299

"""Note: the 'checker' key in 'config' sets the

293

310

.replace(u" ", u""))

294

311

logger.debug(u" Fingerprint: %s", self.fingerprint)

295

312

if u"secret" in config:

296

self._secret = config[u"secret"].decode(u"base64")

313

self.secret = config[u"secret"].decode(u"base64")

297

314

elif u"secfile" in config:

298

315

with open(os.path.expanduser(os.path.expandvars

299

316

(config[u"secfile"])),

300

317

"rb") as secfile:

301

self._secret = secfile.read()

318

self.secret = secfile.read()

302

319

else:

303

#XXX Need to allow secret on demand!

304

320

raise TypeError(u"No secret or secfile for client %s"

305

321

% self.name)

306

322

self.host = config.get(u"host", u"")

307

323

self.created = datetime.datetime.utcnow()

308

324

self.enabled = False

325

self.last_approval_request = None

309

326

self.last_enabled = None

310

327

self.last_checked_ok = None

311

328

self.timeout = string_to_delta(config[u"timeout"])

318

335

self.checker_command = config[u"checker"]

319

336

self.current_checker_command = None

320

337

self.last_connect = None

321

self.changesignal, self._reset = os.pipe()

322

self._approved = None #XXX should be based on configfile

323

self.delay = 10; #XXX Should be based on configfile

324

325

def setsecret(self, value):

326

self._secret = value

327

os.write(self.changesignal, "\0")

328

os.read(self._reset, 1)

329

330

secret = property(lambda self: self._secret, setsecret)

331

del setsecret

338

self._approved = None

339

self.approved_by_default = config.get(u"approved_by_default",

340

True)

341

self.approvals_pending = 0

342

self.approval_delay = string_to_delta(

343

config[u"approval_delay"])

344

self.approval_duration = string_to_delta(

345

config[u"approval_duration"])

346

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

332

347

333

def setapproved(self, value):

334

self._approved = value

335

os.write(self.changesignal, "\0")

336

os.read(self._reset, 1)

337

338

approved = property(lambda self: self._approved, setapproved)

339

del setapproved

340

348

def send_changedstate(self):

349

self.changedstate.acquire()

350

self.changedstate.notify_all()

351

self.changedstate.release()

352

341

353

def enable(self):

342

354

"""Start this client's checker and timeout hooks"""

343

355

if getattr(self, u"enabled", False):

344

356

# Already enabled

345

357

return

358

self.send_changedstate()

346

359

self.last_enabled = datetime.datetime.utcnow()

347

360

# Schedule a new checker to be started an 'interval' from now,

348

361

# and every interval from then on.

362

375

if not getattr(self, "enabled", False):

363

376

return False

364

377

if not quiet:

378

self.send_changedstate()

379

if not quiet:

365

380

logger.info(u"Disabling client %s", self.name)

366

381

if getattr(self, u"disable_initiator_tag", False):

367

382

gobject.source_remove(self.disable_initiator_tag)

409

424

(self.timeout_milliseconds(),

410

425

self.disable))

411

426

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

412

430

def start_checker(self):

413

431

"""Start a new checker subprocess if one is not running.

414

432

443

461

command = self.checker_command % self.host

444

462

except TypeError:

445

463

# Escape attributes for the shell

446

escaped_attrs = dict((key,

447

re.escape(unicode(str(val),

448

errors=

449

u'replace')))

450

for key, val in

451

vars(self).iteritems())

464

escaped_attrs = dict(

465

(attr,

466

re.escape(unicode(str(getattr(self, attr, u"")),

467

errors=

468

u'replace')))

469

for attr in

470

self.runtime_expansions)

471

452

472

try:

453

473

command = self.checker_command % escaped_attrs

454

474

except TypeError, error:

500

520

raise

501

521

self.checker = None

502

522

503

504

523

def dbus_service_property(dbus_interface, signature=u"v",

505

524

access=u"readwrite", byte_arrays=False):

506

525

"""Decorators for marking methods of a DBusObjectWithProperties to

697

716

dbus_object_path: dbus.ObjectPath

698

717

bus: dbus.SystemBus()

699

718

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

700

723

# dbus.service.Object doesn't use super(), so we can't either.

701

724

702

725

def __init__(self, bus = None, *args, **kwargs):

726

self._approvals_pending = 0

703

727

self.bus = bus

704

728

Client.__init__(self, *args, **kwargs)

705

729

# Only now, when this client is initialized, can it show up on

706

730

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

{ord(u"."): ord(u"_"),

733

ord(u"-"): ord(u"_")})

707

734

self.dbus_object_path = (dbus.ObjectPath

708

(u"/clients/"

709

+ self.name.replace(u".", u"_")))

735

(u"/clients/" + client_object_name))

710

736

DBusObjectWithProperties.__init__(self, self.bus,

711

737

self.dbus_object_path)

738

739

def _get_approvals_pending(self):

740

return self._approvals_pending

741

def _set_approvals_pending(self, value):

742

old_value = self._approvals_pending

743

self._approvals_pending = value

744

bval = bool(value)

745

if (hasattr(self, "dbus_object_path")

746

and bval is not bool(old_value)):

747

dbus_bool = dbus.Boolean(bval, variant_level=1)

748

self.PropertyChanged(dbus.String(u"ApprovalPending"),

749

dbus_bool)

750

751

approvals_pending = property(_get_approvals_pending,

752

_set_approvals_pending)

753

del _get_approvals_pending, _set_approvals_pending

712

754

713

755

@staticmethod

714

756

def _datetime_to_dbus(dt, variant_level=0):

721

763

r = Client.enable(self)

722

764

if oldstate != self.enabled:

723

765

# Emit D-Bus signals

724

self.PropertyChanged(dbus.String(u"enabled"),

766

self.PropertyChanged(dbus.String(u"Enabled"),

725

767

dbus.Boolean(True, variant_level=1))

726

768

self.PropertyChanged(

727

dbus.String(u"last_enabled"),

769

dbus.String(u"LastEnabled"),

728

770

self._datetime_to_dbus(self.last_enabled,

729

771

variant_level=1))

730

772

return r

734

776

r = Client.disable(self, quiet=quiet)

735

777

if not quiet and oldstate != self.enabled:

736

778

# Emit D-Bus signal

737

self.PropertyChanged(dbus.String(u"enabled"),

779

self.PropertyChanged(dbus.String(u"Enabled"),

738

780

dbus.Boolean(False, variant_level=1))

739

781

return r

740

782

752

794

self.checker_callback_tag = None

753

795

self.checker = None

754

796

# Emit D-Bus signal

755

self.PropertyChanged(dbus.String(u"checker_running"),

797

self.PropertyChanged(dbus.String(u"CheckerRunning"),

756

798

dbus.Boolean(False, variant_level=1))

757

799

if os.WIFEXITED(condition):

758

800

exitstatus = os.WEXITSTATUS(condition)

773

815

r = Client.checked_ok(self, *args, **kwargs)

774

816

# Emit D-Bus signal

775

817

self.PropertyChanged(

776

dbus.String(u"last_checked_ok"),

818

dbus.String(u"LastCheckedOK"),

777

819

(self._datetime_to_dbus(self.last_checked_ok,

778

820

variant_level=1)))

779

821

return r

780

822

823

def need_approval(self, *args, **kwargs):

824

r = Client.need_approval(self, *args, **kwargs)

825

# Emit D-Bus signal

826

self.PropertyChanged(

827

dbus.String(u"LastApprovalRequest"),

828

(self._datetime_to_dbus(self.last_approval_request,

829

variant_level=1)))

830

return r

831

781

832

def start_checker(self, *args, **kwargs):

782

833

old_checker = self.checker

783

834

if self.checker is not None:

791

842

# Emit D-Bus signal

792

843

self.CheckerStarted(self.current_checker_command)

793

844

self.PropertyChanged(

794

dbus.String(u"checker_running"),

845

dbus.String(u"CheckerRunning"),

795

846

dbus.Boolean(True, variant_level=1))

796

847

return r

797

848

800

851

r = Client.stop_checker(self, *args, **kwargs)

801

852

if (old_checker is not None

802

853

and getattr(self, u"checker", None) is None):

803

self.PropertyChanged(dbus.String(u"checker_running"),

854

self.PropertyChanged(dbus.String(u"CheckerRunning"),

804

855

dbus.Boolean(False, variant_level=1))

805

856

return r

857

858

def _reset_approved(self):

859

self._approved = None

860

return False

861

862

def approve(self, value=True):

863

self.send_changedstate()

864

self._approved = value

865

gobject.timeout_add(self._timedelta_to_milliseconds

866

(self.approval_duration),

867

self._reset_approved)

868

806

869

807

870

## D-Bus methods, signals & properties

808

871

_interface = u"se.bsnet.fukt.Mandos.Client"

830

893

# GotSecret - signal

831

894

@dbus.service.signal(_interface)

832

895

def GotSecret(self):

833

"D-Bus signal"

896

"""D-Bus signal

897

Is sent after a successful transfer of secret from the Mandos

898

server to mandos-client

899

"""

834

900

pass

835

901

836

902

# Rejected - signal

837

@dbus.service.signal(_interface)

838

def Rejected(self):

903

@dbus.service.signal(_interface, signature=u"s")

904

def Rejected(self, reason):

839

905

"D-Bus signal"

840

906

pass

841

907

908

# NeedApproval - signal

909

@dbus.service.signal(_interface, signature=u"tb")

910

def NeedApproval(self, timeout, default):

911

"D-Bus signal"

912

return self.need_approval()

913

842

914

## Methods

843

915

916

# Approve - method

917

@dbus.service.method(_interface, in_signature=u"b")

918

def Approve(self, value):

919

self.approve(value)

920

844

921

# CheckedOK - method

845

922

@dbus.service.method(_interface)

846

923

def CheckedOK(self):

871

948

872

949

## Properties

873

950

874

# name - property

951

# ApprovalPending - property

952

@dbus_service_property(_interface, signature=u"b", access=u"read")

953

def ApprovalPending_dbus_property(self):

954

return dbus.Boolean(bool(self.approvals_pending))

955

956

# ApprovedByDefault - property

957

@dbus_service_property(_interface, signature=u"b",

958

access=u"readwrite")

959

def ApprovedByDefault_dbus_property(self, value=None):

960

if value is None: # get

961

return dbus.Boolean(self.approved_by_default)

962

self.approved_by_default = bool(value)

963

# Emit D-Bus signal

964

self.PropertyChanged(dbus.String(u"ApprovedByDefault"),

965

dbus.Boolean(value, variant_level=1))

966

967

# ApprovalDelay - property

968

@dbus_service_property(_interface, signature=u"t",

969

access=u"readwrite")

970

def ApprovalDelay_dbus_property(self, value=None):

971

if value is None: # get

972

return dbus.UInt64(self.approval_delay_milliseconds())

973

self.approval_delay = datetime.timedelta(0, 0, 0, value)

974

# Emit D-Bus signal

975

self.PropertyChanged(dbus.String(u"ApprovalDelay"),

976

dbus.UInt64(value, variant_level=1))

977

978

# ApprovalDuration - property

979

@dbus_service_property(_interface, signature=u"t",

980

access=u"readwrite")

981

def ApprovalDuration_dbus_property(self, value=None):

982

if value is None: # get

983

return dbus.UInt64(self._timedelta_to_milliseconds(

984

self.approval_duration))

985

self.approval_duration = datetime.timedelta(0, 0, 0, value)

986

# Emit D-Bus signal

987

self.PropertyChanged(dbus.String(u"ApprovalDuration"),

988

dbus.UInt64(value, variant_level=1))

989

990

# Name - property

875

991

@dbus_service_property(_interface, signature=u"s", access=u"read")

876

def name_dbus_property(self):

992

def Name_dbus_property(self):

877

993

return dbus.String(self.name)

878

994

879

# fingerprint - property

995

# Fingerprint - property

880

996

@dbus_service_property(_interface, signature=u"s", access=u"read")

881

def fingerprint_dbus_property(self):

997

def Fingerprint_dbus_property(self):

882

998

return dbus.String(self.fingerprint)

883

999

884

# host - property

1000

# Host - property

885

1001

@dbus_service_property(_interface, signature=u"s",

886

1002

access=u"readwrite")

887

def host_dbus_property(self, value=None):

1003

def Host_dbus_property(self, value=None):

888

1004

if value is None: # get

889

1005

return dbus.String(self.host)

890

1006

self.host = value

891

1007

# Emit D-Bus signal

892

self.PropertyChanged(dbus.String(u"host"),

1008

self.PropertyChanged(dbus.String(u"Host"),

893

1009

dbus.String(value, variant_level=1))

894

1010

895

# created - property

1011

# Created - property

896

1012

@dbus_service_property(_interface, signature=u"s", access=u"read")

897

def created_dbus_property(self):

1013

def Created_dbus_property(self):

898

1014

return dbus.String(self._datetime_to_dbus(self.created))

899

1015

900

# last_enabled - property

1016

# LastEnabled - property

901

1017

@dbus_service_property(_interface, signature=u"s", access=u"read")

902

def last_enabled_dbus_property(self):

1018

def LastEnabled_dbus_property(self):

903

1019

if self.last_enabled is None:

904

1020

return dbus.String(u"")

905

1021

return dbus.String(self._datetime_to_dbus(self.last_enabled))

906

1022

907

# enabled - property

1023

# Enabled - property

908

1024

@dbus_service_property(_interface, signature=u"b",

909

1025

access=u"readwrite")

910

def enabled_dbus_property(self, value=None):

1026

def Enabled_dbus_property(self, value=None):

911

1027

if value is None: # get

912

1028

return dbus.Boolean(self.enabled)

913

1029

if value:

915

1031

else:

916

1032

self.disable()

917

1033

918

# last_checked_ok - property

1034

# LastCheckedOK - property

919

1035

@dbus_service_property(_interface, signature=u"s",

920

1036

access=u"readwrite")

921

def last_checked_ok_dbus_property(self, value=None):

1037

def LastCheckedOK_dbus_property(self, value=None):

922

1038

if value is not None:

923

1039

self.checked_ok()

924

1040

return

927

1043

return dbus.String(self._datetime_to_dbus(self

928

1044

.last_checked_ok))

929

1045

930

# timeout - property

1046

# LastApprovalRequest - property

1047

@dbus_service_property(_interface, signature=u"s", access=u"read")

1048

def LastApprovalRequest_dbus_property(self):

1049

if self.last_approval_request is None:

1050

return dbus.String(u"")

1051

return dbus.String(self.

1052

_datetime_to_dbus(self

1053

.last_approval_request))

1054

1055

# Timeout - property

931

1056

@dbus_service_property(_interface, signature=u"t",

932

1057

access=u"readwrite")

933

def timeout_dbus_property(self, value=None):

1058

def Timeout_dbus_property(self, value=None):

934

1059

if value is None: # get

935

1060

return dbus.UInt64(self.timeout_milliseconds())

936

1061

self.timeout = datetime.timedelta(0, 0, 0, value)

937

1062

# Emit D-Bus signal

938

self.PropertyChanged(dbus.String(u"timeout"),

1063

self.PropertyChanged(dbus.String(u"Timeout"),

939

1064

dbus.UInt64(value, variant_level=1))

940

1065

if getattr(self, u"disable_initiator_tag", None) is None:

941

1066

return

955

1080

self.disable_initiator_tag = (gobject.timeout_add

956

1081

(time_to_die, self.disable))

957

1082

958

# interval - property

1083

# Interval - property

959

1084

@dbus_service_property(_interface, signature=u"t",

960

1085

access=u"readwrite")

961

def interval_dbus_property(self, value=None):

1086

def Interval_dbus_property(self, value=None):

962

1087

if value is None: # get

963

1088

return dbus.UInt64(self.interval_milliseconds())

964

1089

self.interval = datetime.timedelta(0, 0, 0, value)

965

1090

# Emit D-Bus signal

966

self.PropertyChanged(dbus.String(u"interval"),

1091

self.PropertyChanged(dbus.String(u"Interval"),

967

1092

dbus.UInt64(value, variant_level=1))

968

1093

if getattr(self, u"checker_initiator_tag", None) is None:

969

1094

return

973

1098

(value, self.start_checker))

974

1099

self.start_checker() # Start one now, too

975

1100

976

# checker - property

1101

# Checker - property

977

1102

@dbus_service_property(_interface, signature=u"s",

978

1103

access=u"readwrite")

979

def checker_dbus_property(self, value=None):

1104

def Checker_dbus_property(self, value=None):

980

1105

if value is None: # get

981

1106

return dbus.String(self.checker_command)

982

1107

self.checker_command = value

983

1108

# Emit D-Bus signal

984

self.PropertyChanged(dbus.String(u"checker"),

1109

self.PropertyChanged(dbus.String(u"Checker"),

985

1110

dbus.String(self.checker_command,

986

1111

variant_level=1))

987

1112

988

# checker_running - property

1113

# CheckerRunning - property

989

1114

@dbus_service_property(_interface, signature=u"b",

990

1115

access=u"readwrite")

991

def checker_running_dbus_property(self, value=None):

1116

def CheckerRunning_dbus_property(self, value=None):

992

1117

if value is None: # get

993

1118

return dbus.Boolean(self.checker is not None)

994

1119

if value:

996

1121

else:

997

1122

self.stop_checker()

998

1123

999

# object_path - property

1124

# ObjectPath - property

1000

1125

@dbus_service_property(_interface, signature=u"o", access=u"read")

1001

def object_path_dbus_property(self):

1126

def ObjectPath_dbus_property(self):

1002

1127

return self.dbus_object_path # is already a dbus.ObjectPath

1003

1128

1004

# secret = property

1129

# Secret = property

1005

1130

@dbus_service_property(_interface, signature=u"ay",

1006

1131

access=u"write", byte_arrays=True)

1007

def secret_dbus_property(self, value):

1132

def Secret_dbus_property(self, value):

1008

1133

self.secret = str(value)

1009

1134

1010

1135

del _interface

1011

1136

1012

1137

1138

class ProxyClient(object):

1139

def __init__(self, child_pipe, fpr, address):

1140

self._pipe = child_pipe

1141

self._pipe.send(('init', fpr, address))

1142

if not self._pipe.recv():

1143

raise KeyError()

1144

1145

def __getattribute__(self, name):

1146

if(name == '_pipe'):

1147

return super(ProxyClient, self).__getattribute__(name)

1148

self._pipe.send(('getattr', name))

1149

data = self._pipe.recv()

1150

if data[0] == 'data':

1151

return data[1]

1152

if data[0] == 'function':

1153

def func(*args, **kwargs):

1154

self._pipe.send(('funcall', name, args, kwargs))

1155

return self._pipe.recv()[1]

1156

return func

1157

1158

def __setattr__(self, name, value):

1159

if(name == '_pipe'):

1160

return super(ProxyClient, self).__setattr__(name, value)

1161

self._pipe.send(('setattr', name, value))

1162

1163

1013

1164

class ClientHandler(socketserver.BaseRequestHandler, object):

1014

1165

"""A class to handle client connections.

1015

1166

1017

1168

Note: This will run in its own forked process."""

1018

1169

1019

1170

def handle(self):

1020

logger.info(u"TCP connection from: %s",

1021

unicode(self.client_address))

1022

logger.debug(u"IPC Pipe FD: %d",

1023

self.server.child_pipe[1].fileno())

1024

# Open IPC pipe to parent process

1025

with contextlib.nested(self.server.child_pipe[1],

1026

self.server.parent_pipe[0]

1027

) as (ipc, ipc_return):

1171

with contextlib.closing(self.server.child_pipe) as child_pipe:

1172

logger.info(u"TCP connection from: %s",

1173

unicode(self.client_address))

1174

logger.debug(u"Pipe FD: %d",

1175

self.server.child_pipe.fileno())

1176

1028

1177

session = (gnutls.connection

1029

1178

.ClientSession(self.request,

1030

1179

gnutls.connection

1031

1180

.X509Credentials()))

1032

1033

line = self.request.makefile().readline()

1034

logger.debug(u"Protocol version: %r", line)

1035

try:

1036

if int(line.strip().split()[0]) > 1:

1037

raise RuntimeError

1038

except (ValueError, IndexError, RuntimeError), error:

1039

logger.error(u"Unknown protocol version: %s", error)

1040

return

1041

1181

1042

1182

# Note: gnutls.connection.X509Credentials is really a

1043

1183

# generic GnuTLS certificate credentials object so long as

1044

1184

# no X.509 keys are added to it. Therefore, we can use it

1045

1185

# here despite using OpenPGP certificates.

1046

1186

1047

1187

#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",

1048

1188

# u"+AES-256-CBC", u"+SHA1",

1049

1189

# u"+COMP-NULL", u"+CTYPE-OPENPGP",

1055

1195

(gnutls.library.functions

1056

1196

.gnutls_priority_set_direct(session._c_object,

1057

1197

priority, None))

1058

1198

1199

# Start communication using the Mandos protocol

1200

# Get protocol number

1201

line = self.request.makefile().readline()

1202

logger.debug(u"Protocol version: %r", line)

1203

try:

1204

if int(line.strip().split()[0]) > 1:

1205

raise RuntimeError

1206

except (ValueError, IndexError, RuntimeError), error:

1207

logger.error(u"Unknown protocol version: %s", error)

1208

return

1209

1210

# Start GnuTLS connection

1059

1211

try:

1060

1212

session.handshake()

1061

1213

except gnutls.errors.GNUTLSError, error:

1064

1216

# established. Just abandon the request.

1065

1217

return

1066

1218

logger.debug(u"Handshake succeeded")

1219

1220

approval_required = False

1067

1221

try:

1068

1222

try:

1069

1223

fpr = self.fingerprint(self.peer_certificate

1073

1227

return

1074

1228

logger.debug(u"Fingerprint: %s", fpr)

1075

1229

1076

for c in self.server.clients:

1077

if c.fingerprint == fpr:

1078

client = c

1079

break

1080

else:

1081

ipc.write(u"NOTFOUND %s %s\n"

1082

% (fpr, unicode(self.client_address)))

1230

try:

1231

client = ProxyClient(child_pipe, fpr,

1232

self.client_address)

1233

except KeyError:

1083

1234

return

1084

1085

class proxyclient(object):

1086

def __getattribute__(self, name):

1087

ipc.write(u"GETATTR %s %s\n" % name, client.fpr)

1088

return pickle.load(ipc_reply)

1089

p = proxyclient(client)

1090

1235

1236

if client.approval_delay:

1237

delay = client.approval_delay

1238

client.approvals_pending += 1

1239

approval_required = True

1240

1091

1241

while True:

1092

if not p.client.enabled:

1093

icp.write("DISABLED %s\n" % client.fpr)

1094

return

1095

if p.client.approved == False:

1096

icp.write("Disaproved")

1242

if not client.enabled:

1243

logger.warning(u"Client %s is disabled",

1244

client.name)

1245

if self.server.use_dbus:

1246

# Emit D-Bus signal

1247

client.Rejected("Disabled")

1097

1248

return

1098

1249

1099

if not p.client.secret:

1100

icp.write("No password")

1101

elif not p.client.approved:

1102

icp.write("Need approval"):

1103

else:

1104

#We have a password and are approved

1250

if client._approved or not client.approval_delay:

1251

#We are approved or approval is disabled

1105

1252

break

1106

i, o, e = select(p.changesignal, (), (), client.delay)

1107

if not i:

1108

icp.write("Timeout passed")

1253

elif client._approved is None:

1254

logger.info(u"Client %s needs approval",

1255

client.name)

1256

if self.server.use_dbus:

1257

# Emit D-Bus signal

1258

client.NeedApproval(

1259

client.approval_delay_milliseconds(),

1260

client.approved_by_default)

1261

else:

1262

logger.warning(u"Client %s was not approved",

1263

client.name)

1264

if self.server.use_dbus:

1265

# Emit D-Bus signal

1266

client.Rejected("Denied")

1109

1267

return

1110

1268

1111

ipc.write(u"SENDING %s\n" % client.name)

1269

#wait until timeout or approved

1270

#x = float(client._timedelta_to_milliseconds(delay))

1271

time = datetime.datetime.now()

1272

client.changedstate.acquire()

1273

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1274

client.changedstate.release()

1275

time2 = datetime.datetime.now()

1276

if (time2 - time) >= delay:

1277

if not client.approved_by_default:

1278

logger.warning("Client %s timed out while"

1279

" waiting for approval",

1280

client.name)

1281

if self.server.use_dbus:

1282

# Emit D-Bus signal

1283

client.Rejected("Approval timed out")

1284

return

1285

else:

1286

break

1287

else:

1288

delay -= time2 - time

1289

1112

1290

sent_size = 0

1113

1291

while sent_size < len(client.secret):

1114

sent = session.send(client.secret[sent_size:])

1292

try:

1293

sent = session.send(client.secret[sent_size:])

1294

except (gnutls.errors.GNUTLSError), error:

1295

logger.warning("gnutls send failed")

1296

return

1115

1297

logger.debug(u"Sent: %d, remaining: %d",

1116

1298

sent, len(client.secret)

1117

1299

- (sent_size + sent))

1118

1300

sent_size += sent

1301

1302

logger.info(u"Sending secret to %s", client.name)

1303

# bump the timeout as if seen

1304

client.checked_ok()

1305

if self.server.use_dbus:

1306

# Emit D-Bus signal

1307

client.GotSecret()

1308

1119

1309

finally:

1120

session.bye()

1310

if approval_required:

1311

client.approvals_pending -= 1

1312

try:

1313

session.bye()

1314

except (gnutls.errors.GNUTLSError), error:

1315

logger.warning("GnuTLS bye failed")

1121

1316

1122

1317

@staticmethod

1123

1318

def peer_certificate(session):

1183

1378

return hex_fpr

1184

1379

1185

1380

1186

class ForkingMixInWithPipes(socketserver.ForkingMixIn, object):

1187

"""Like socketserver.ForkingMixIn, but also pass a pipe pair."""

1381

class MultiprocessingMixIn(object):

1382

"""Like socketserver.ThreadingMixIn, but with multiprocessing"""

1383

def sub_process_main(self, request, address):

1384

try:

1385

self.finish_request(request, address)

1386

except:

1387

self.handle_error(request, address)

1388

self.close_request(request)

1389

1390

def process_request(self, request, address):

1391

"""Start a new process to process the request."""

1392

multiprocessing.Process(target = self.sub_process_main,

1393

args = (request, address)).start()

1394

1395

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1396

""" adds a pipe to the MixIn """

1188

1397

def process_request(self, request, client_address):

1189

1398

"""Overrides and wraps the original process_request().

1190

1399

1191

1400

This function creates a new pipe in self.pipe

1192

1401

"""

1193

# Child writes to child_pipe

1194

self.child_pipe = map(os.fdopen, os.pipe(), u"rw", (1, 0))

1195

# Parent writes to parent_pipe

1196

self.parent_pipe = map(os.fdopen, os.pipe(), u"rw", (1, 0))

1197

super(ForkingMixInWithPipes,

1402

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1403

1404

super(MultiprocessingMixInWithPipe,

1198

1405

self).process_request(request, client_address)

1199

# Close unused ends for parent

1200

self.parent_pipe[0].close() # close read end

1201

self.child_pipe[1].close() # close write end

1202

self.add_pipe_fds(self.child_pipe[0], self.parent_pipe[1])

1203

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1406

self.child_pipe.close()

1407

self.add_pipe(parent_pipe)

1408

1409

def add_pipe(self, parent_pipe):

1204

1410

"""Dummy function; override as necessary"""

1205

child_pipe_fd.close()

1206

parent_pipe_fd.close()

1207

1208

1209

class IPv6_TCPServer(ForkingMixInWithPipes,

1411

pass

1412

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1210

1414

socketserver.TCPServer, object):

1211

1415

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

1212

1416

1297

1501

return socketserver.TCPServer.server_activate(self)

1298

1502

def enable(self):

1299

1503

self.enabled = True

1300

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1504

def add_pipe(self, parent_pipe):

1301

1505

# Call "handle_ipc" for both data and EOF events

1302

gobject.io_add_watch(child_pipe_fd.fileno(),

1506

gobject.io_add_watch(parent_pipe.fileno(),

1303

1507

gobject.IO_IN | gobject.IO_HUP,

1304

1508

functools.partial(self.handle_ipc,

1305

reply = parent_pipe_fd,

1306

sender= child_pipe_fd))

1307

def handle_ipc(self, source, condition, reply=None, sender=None):

1509

parent_pipe = parent_pipe))

1510

1511

def handle_ipc(self, source, condition, parent_pipe=None,

1512

client_object=None):

1308

1513

condition_names = {

1309

1514

gobject.IO_IN: u"IN", # There is data to read.

1310

1515

gobject.IO_OUT: u"OUT", # Data can be written (without

1319

1524

for cond, name in

1320

1525

condition_names.iteritems()

1321

1526

if cond & condition)

1322

logger.debug(u"Handling IPC: FD = %d, condition = %s", source,

1323

conditions_string)

1324

1325

# Read a line from the file object

1326

cmdline = sender.readline()

1327

if not cmdline: # Empty line means end of file

1328

# close the IPC pipes

1329

sender.close()

1330

reply.close()

1331

1332

# Stop calling this function

1333

return False

1334

1335

logger.debug(u"IPC command: %r", cmdline)

1336

1337

# Parse and act on command

1338

cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)

1339

1340

if cmd == u"NOTFOUND":

1341

fpr, address = args.split(None, 1)

1342

logger.warning(u"Client not found for fingerprint: %s, ad"

1343

u"dress: %s", fpr, address)

1344

if self.use_dbus:

1345

# Emit D-Bus signal

1346

mandos_dbus_service.ClientNotFound(fpr, address)

1347

elif cmd == u"DISABLED":

1348

for client in self.clients:

1349

if client.name == args:

1350

logger.warning(u"Client %s is disabled", args)

1351

if self.use_dbus:

1352

# Emit D-Bus signal

1353

client.Rejected()

1354

break

1355

else:

1356

logger.error(u"Unknown client %s is disabled", args)

1357

elif cmd == u"SENDING":

1358

for client in self.clients:

1359

if client.name == args:

1360

logger.info(u"Sending secret to %s", client.name)

1361

client.checked_ok()

1362

if self.use_dbus:

1363

# Emit D-Bus signal

1364

client.GotSecret()

1365

break

1366

else:

1367

logger.error(u"Sending secret to unknown client %s",

1368

args)

1369

elif cmd == u"GETATTR":

1370

attr_name, fpr = args.split(None, 1)

1371

for client in self.clients:

1372

if client.fingerprint == fpr:

1373

attr_value = getattr(client, attr_name, None)

1374

logger.debug("IPC reply: %r", attr_value)

1375

pickle.dump(attr_value, reply)

1376

break

1377

else:

1378

logger.error(u"Client %s on address %s requesting "

1379

u"attribute %s not found", fpr, address,

1380

attr_name)

1381

pickle.dump(None, reply)

1382

else:

1383

logger.error(u"Unknown IPC command: %r", cmdline)

1384

1385

# Keep calling this function

1527

# error or the other end of multiprocessing.Pipe has closed

1528

if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):

1529

return False

1530

1531

# Read a request from the child

1532

request = parent_pipe.recv()

1533

command = request[0]

1534

1535

if command == 'init':

1536

fpr = request[1]

1537

address = request[2]

1538

1539

for c in self.clients:

1540

if c.fingerprint == fpr:

1541

client = c

1542

break

1543

else:

1544

logger.warning(u"Client not found for fingerprint: %s, ad"

1545

u"dress: %s", fpr, address)

1546

if self.use_dbus:

1547

# Emit D-Bus signal

1548

mandos_dbus_service.ClientNotFound(fpr, address[0])

1549

parent_pipe.send(False)

1550

return False

1551

1552

gobject.io_add_watch(parent_pipe.fileno(),

1553

gobject.IO_IN | gobject.IO_HUP,

1554

functools.partial(self.handle_ipc,

1555

parent_pipe = parent_pipe,

1556

client_object = client))

1557

parent_pipe.send(True)

1558

# remove the old hook in favor of the new above hook on same fileno

1559

return False

1560

if command == 'funcall':

1561

funcname = request[1]

1562

args = request[2]

1563

kwargs = request[3]

1564

1565

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1566

1567

if command == 'getattr':

1568

attrname = request[1]

1569

if callable(client_object.__getattribute__(attrname)):

1570

parent_pipe.send(('function',))

1571

else:

1572

parent_pipe.send(('data', client_object.__getattribute__(attrname)))

1573

1574

if command == 'setattr':

1575

attrname = request[1]

1576

value = request[2]

1577

setattr(client_object, attrname, value)

1578

1386

1579

return True

1387

1580

1388

1581

1491

1684

parser.add_option("--debug", action=u"store_true",

1492

1685

help=u"Debug mode; run in foreground and log to"

1493

1686

u" terminal")

1687

parser.add_option("--debuglevel", type=u"string", metavar="LEVEL",

1688

help=u"Debug level for stdout output")

1494

1689

parser.add_option("--priority", type=u"string", help=u"GnuTLS"

1495

1690

u" priority string (see GnuTLS documentation)")

1496

1691

parser.add_option("--servicename", type=u"string",

1521

1716

u"servicename": u"Mandos",

1522

1717

u"use_dbus": u"True",

1523

1718

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1524

1720

}

1525

1721

1526

1722

# Parse config file for server-global settings

1543

1739

# options, if set.

1544

1740

for option in (u"interface", u"address", u"port", u"debug",

1545

1741

u"priority", u"servicename", u"configdir",

1546

u"use_dbus", u"use_ipv6"):

1742

u"use_dbus", u"use_ipv6", u"debuglevel"):

1547

1743

value = getattr(options, option)

1548

1744

if value is not None:

1549

1745

server_settings[option] = value

1558

1754

1559

1755

# For convenience

1560

1756

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1561

1758

use_dbus = server_settings[u"use_dbus"]

1562

1759

use_ipv6 = server_settings[u"use_ipv6"]

1563

1564

if not debug:

1565

syslogger.setLevel(logging.WARNING)

1566

console.setLevel(logging.WARNING)

1567

1760

1568

1761

if server_settings[u"servicename"] != u"Mandos":

1569

1762

syslogger.setFormatter(logging.Formatter

1570

1763

(u'Mandos (%s) [%%(process)d]:'

1576

1769

u"interval": u"5m",

1577

1770

u"checker": u"fping -q -- %%(host)s",

1578

1771

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1579

1774

}

1580

1775

client_config = configparser.SafeConfigParser(client_defaults)

1581

1776

client_config.read(os.path.join(server_settings[u"configdir"],

1587

1782

tcp_server = MandosServer((server_settings[u"address"],

1588

1783

server_settings[u"port"]),

1589

1784

ClientHandler,

1590

interface=server_settings[u"interface"],

1785

interface=(server_settings[u"interface"]

1786

or None),

1591

1787

use_ipv6=use_ipv6,

1592

1788

gnutls_priority=

1593

1789

server_settings[u"priority"],

1594

1790

use_dbus=use_dbus)

1595

pidfilename = u"/var/run/mandos.pid"

1596

try:

1597

pidfile = open(pidfilename, u"w")

1598

except IOError:

1599

logger.error(u"Could not open file %r", pidfilename)

1791

if not debug:

1792

pidfilename = u"/var/run/mandos.pid"

1793

try:

1794

pidfile = open(pidfilename, u"w")

1795

except IOError:

1796

logger.error(u"Could not open file %r", pidfilename)

1600

1797

1601

1798

try:

1602

1799

uid = pwd.getpwnam(u"_mandos").pw_uid

1619

1816

if error[0] != errno.EPERM:

1620

1817

raise error

1621

1818

1622

# Enable all possible GnuTLS debugging

1819

if not debug and not debuglevel:

1820

syslogger.setLevel(logging.WARNING)

1821

console.setLevel(logging.WARNING)

1822

if debuglevel:

1823

level = getattr(logging, debuglevel.upper())

1824

syslogger.setLevel(level)

1825

console.setLevel(level)

1826

1623

1827

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1624

1830

# "Use a log level over 10 to enable all debugging options."

1625

1831

# - GnuTLS manual

1626

1832

gnutls.library.functions.gnutls_global_set_log_level(11)

1631

1837

1632

1838

(gnutls.library.functions

1633

1839

.gnutls_global_set_log_function(debug_gnutls))

1840

1841

# Redirect stdin so all checkers get /dev/null

1842

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

1843

os.dup2(null, sys.stdin.fileno())

1844

if null > 2:

1845

os.close(null)

1846

else:

1847

# No console logging

1848

logger.removeHandler(console)

1849

1634

1850

1635

1851

global main_loop

1636

1852

# From the Avahi example code

1654

1870

if server_settings["interface"]:

1655

1871

service.interface = (if_nametoindex

1656

1872

(str(server_settings[u"interface"])))

1873

1874

if not debug:

1875

# Close all input and output, do double fork, etc.

1876

daemon()

1877

1878

global multiprocessing_manager

1879

multiprocessing_manager = multiprocessing.Manager()

1657

1880

1658

1881

client_class = Client

1659

1882

if use_dbus:

1660

1883

client_class = functools.partial(ClientDBus, bus = bus)

1884

def client_config_items(config, section):

1885

special_settings = {

1886

"approved_by_default":

1887

lambda: config.getboolean(section,

1888

"approved_by_default"),

1889

}

1890

for name, value in config.items(section):

1891

try:

1892

yield (name, special_settings[name]())

1893

except KeyError:

1894

yield (name, value)

1895

1661

1896

tcp_server.clients.update(set(

1662

1897

client_class(name = section,

1663

config= dict(client_config.items(section)))

1898

config= dict(client_config_items(

1899

client_config, section)))

1664

1900

for section in client_config.sections()))

1665

1901

if not tcp_server.clients:

1666

1902

logger.warning(u"No clients defined")

1667

1668

if debug:

1669

# Redirect stdin so all checkers get /dev/null

1670

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

1671

os.dup2(null, sys.stdin.fileno())

1672

if null > 2:

1673

os.close(null)

1674

else:

1675

# No console logging

1676

logger.removeHandler(console)

1677

# Close all input and output, do double fork, etc.

1678

daemon()

1679

1680

try:

1681

with pidfile:

1682

pid = os.getpid()

1683

pidfile.write(str(pid) + "\n")

1684

del pidfile

1685

except IOError:

1686

logger.error(u"Could not write to file %r with PID %d",

1687

pidfilename, pid)

1688

except NameError:

1689

# "pidfile" was never created

1690

pass

1691

del pidfilename

1692

1903

1693

1904

if not debug:

1905

try:

1906

with pidfile:

1907

pid = os.getpid()

1908

pidfile.write(str(pid) + "\n")

1909

del pidfile

1910

except IOError:

1911

logger.error(u"Could not write to file %r with PID %d",

1912

pidfilename, pid)

1913

except NameError:

1914

# "pidfile" was never created

1915

pass

1916

del pidfilename

1917

1694

1918

signal.signal(signal.SIGINT, signal.SIG_IGN)

1919

1695

1920

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

1696

1921

signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())

1697

1922