/mandos/trunk : revision 405

55

import logging

56

import logging.handlers

57

import pwd

58

import contextlib

58

from contextlib import closing

59

import struct

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

64

62

65

63

import dbus

66

64

import dbus.service

83

81

84

82

version = "1.0.14"

85

83

86

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

87

84

logger = logging.Logger(u'mandos')

88

85

syslogger = (logging.handlers.SysLogHandler

89

86

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

157

154

u" after %i retries, exiting.",

158

155

self.rename_count)

159

156

raise AvahiServiceError(u"Too many renames")

160

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

157

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

161

158

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

162

self.name)

159

unicode(self.name))

163

160

syslogger.setFormatter(logging.Formatter

164

161

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

165

162

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

166

163

% self.name))

167

164

self.remove()

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)

165

self.add()

174

166

self.rename_count += 1

175

167

def remove(self):

176

168

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

199

191

self.group.Commit()

200

192

def entry_group_state_changed(self, state, error):

201

193

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

202

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

194

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

203

195

204

196

if state == avahi.ENTRY_GROUP_ESTABLISHED:

205

197

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

218

210

self.group = None

219

211

def server_state_changed(self, state):

220

212

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

221

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

222

213

if state == avahi.SERVER_COLLISION:

223

214

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

224

215

self.remove()

240

231

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

241

232

242

233

Attributes:

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

234

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

235

D-Bus identifiers

236

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

237

uniquely identify the client

238

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

239

host: string; available for use by the checker command

240

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

241

last_enabled: datetime.datetime(); (UTC)

242

enabled: bool()

243

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

244

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

245

until this client is invalid

246

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

247

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

246

248

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

247

249

to see if the client lives.

248

250

'None' if no process is running.

251

checker_initiator_tag: a gobject event source tag, or None

252

disable_initiator_tag: - '' -

249

253

checker_callback_tag: - '' -

250

checker_command: string; External command which is run to check

251

if client lives. %() expansions are done at

254

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

255

client lives. %() expansions are done at

252

256

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

253

257

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

258

current_checker_command: string; current running checker_command

257

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

258

disable_initiator_tag: - '' -

259

enabled: bool()

260

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

261

uniquely identify the client

262

host: string; available for use by the checker command

263

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

264

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

265

last_enabled: datetime.datetime(); (UTC)

266

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

267

D-Bus identifiers

268

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

269

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

270

until this client is disabled

271

runtime_expansions: Allowed attributes for runtime expansion.

272

259

"""

273

260

274

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

275

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

276

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

277

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

278

279

261

@staticmethod

280

262

def _timedelta_to_milliseconds(td):

281

263

"Convert a datetime.timedelta() to milliseconds"

290

272

def interval_milliseconds(self):

291

273

"Return the 'interval' attribute in milliseconds"

292

274

return self._timedelta_to_milliseconds(self.interval)

293

294

def approval_delay_milliseconds(self):

295

return self._timedelta_to_milliseconds(self.approval_delay)

296

275

297

276

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

298

277

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

311

290

if u"secret" in config:

312

291

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

313

292

elif u"secfile" in config:

314

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

315

(config[u"secfile"])),

316

"rb") as secfile:

293

with closing(open(os.path.expanduser

294

(os.path.expandvars

295

(config[u"secfile"])),

296

"rb")) as secfile:

317

297

self.secret = secfile.read()

318

298

else:

319

299

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

333

313

self.checker_command = config[u"checker"]

334

314

self.current_checker_command = None

335

315

self.last_connect = None

336

self._approved = None

337

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

338

True)

339

self.approvals_pending = 0

340

self.approval_delay = string_to_delta(

341

config[u"approval_delay"])

342

self.approval_duration = string_to_delta(

343

config[u"approval_duration"])

344

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

345

316

346

def send_changedstate(self):

347

self.changedstate.acquire()

348

self.changedstate.notify_all()

349

self.changedstate.release()

350

351

317

def enable(self):

352

318

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

353

319

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

354

320

# Already enabled

355

321

return

356

self.send_changedstate()

357

322

self.last_enabled = datetime.datetime.utcnow()

358

323

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

359

324

# and every interval from then on.

373

338

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

374

339

return False

375

340

if not quiet:

376

self.send_changedstate()

377

if not quiet:

378

341

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

379

342

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

380

343

gobject.source_remove(self.disable_initiator_tag)

433

396

# client would inevitably timeout, since no checker would get

434

397

# a chance to run to completion. If we instead leave running

435

398

# checkers alone, the checker would have to take more time

436

# than 'timeout' for the client to be disabled, which is as it

437

# should be.

399

# than 'timeout' for the client to be declared invalid, which

400

# is as it should be.

438

401

439

402

# If a checker exists, make sure it is not a zombie

440

403

try:

456

419

command = self.checker_command % self.host

457

420

except TypeError:

458

421

# Escape attributes for the shell

459

escaped_attrs = dict(

460

(attr,

461

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

462

errors=

463

u'replace')))

464

for attr in

465

self.runtime_expansions)

466

422

escaped_attrs = dict((key,

423

re.escape(unicode(str(val),

424

errors=

425

u'replace')))

426

for key, val in

427

vars(self).iteritems())

467

428

try:

468

429

command = self.checker_command % escaped_attrs

469

430

except TypeError, error:

514

475

if error.errno != errno.ESRCH: # No such process

515

476

raise

516

477

self.checker = None

478

479

def still_valid(self):

480

"""Has the timeout not yet passed for this client?"""

481

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

482

return False

483

now = datetime.datetime.utcnow()

484

if self.last_checked_ok is None:

485

return now < (self.created + self.timeout)

486

else:

487

return now < (self.last_checked_ok + self.timeout)

488

517

489

518

490

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

519

491

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

527

499

dbus.service.method, except there is only "signature", since the

528

500

type from Get() and the type sent to Set() is the same.

529

501

"""

530

# Encoding deeply encoded byte arrays is not supported yet by the

531

# "Set" method, so we fail early here:

532

if byte_arrays and signature != u"ay":

533

raise ValueError(u"Byte arrays not supported for non-'ay'"

534

u" signature %r" % signature)

535

502

def decorator(func):

536

503

func._dbus_is_property = True

537

504

func._dbus_interface = dbus_interface

623

590

if prop._dbus_access == u"read":

624

591

raise DBusPropertyAccessException(property_name)

625

592

if prop._dbus_get_args_options[u"byte_arrays"]:

626

# The byte_arrays option is not supported yet on

627

# signatures other than "ay".

628

if prop._dbus_signature != u"ay":

629

raise ValueError

630

593

value = dbus.ByteArray(''.join(unichr(byte)

631

594

for byte in value))

632

595

prop(value)

711

674

dbus_object_path: dbus.ObjectPath

712

675

bus: dbus.SystemBus()

713

676

"""

714

715

runtime_expansions = (Client.runtime_expansions

716

+ (u"dbus_object_path",))

717

718

677

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

719

678

720

679

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

721

self._approvals_pending = 0

722

680

self.bus = bus

723

681

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

724

682

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

725

683

# the D-Bus

726

client_object_name = unicode(self.name).translate(

727

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

728

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

729

684

self.dbus_object_path = (dbus.ObjectPath

730

(u"/clients/" + client_object_name))

685

(u"/clients/"

686

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

731

687

DBusObjectWithProperties.__init__(self, self.bus,

732

688

self.dbus_object_path)

733

734

def _get_approvals_pending(self):

735

return self._approvals_pending

736

def _set_approvals_pending(self, value):

737

old_value = self._approvals_pending

738

self._approvals_pending = value

739

bval = bool(value)

740

if (hasattr(self, "dbus_object_path")

741

and bval is not bool(old_value)):

742

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

743

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

744

dbus_bool)

745

746

approvals_pending = property(_get_approvals_pending,

747

_set_approvals_pending)

748

del _get_approvals_pending, _set_approvals_pending

749

689

750

690

@staticmethod

751

691

def _datetime_to_dbus(dt, variant_level=0):

758

698

r = Client.enable(self)

759

699

if oldstate != self.enabled:

760

700

# Emit D-Bus signals

761

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

701

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

762

702

dbus.Boolean(True, variant_level=1))

763

703

self.PropertyChanged(

764

dbus.String(u"LastEnabled"),

704

dbus.String(u"last_enabled"),

765

705

self._datetime_to_dbus(self.last_enabled,

766

706

variant_level=1))

767

707

return r

771

711

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

772

712

if not quiet and oldstate != self.enabled:

773

713

# Emit D-Bus signal

774

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

714

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

775

715

dbus.Boolean(False, variant_level=1))

776

716

return r

777

717

789

729

self.checker_callback_tag = None

790

730

self.checker = None

791

731

# Emit D-Bus signal

792

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

732

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

793

733

dbus.Boolean(False, variant_level=1))

794

734

if os.WIFEXITED(condition):

795

735

exitstatus = os.WEXITSTATUS(condition)

810

750

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

811

751

# Emit D-Bus signal

812

752

self.PropertyChanged(

813

dbus.String(u"LastCheckedOK"),

753

dbus.String(u"last_checked_ok"),

814

754

(self._datetime_to_dbus(self.last_checked_ok,

815

755

variant_level=1)))

816

756

return r

828

768

# Emit D-Bus signal

829

769

self.CheckerStarted(self.current_checker_command)

830

770

self.PropertyChanged(

831

dbus.String(u"CheckerRunning"),

771

dbus.String(u"checker_running"),

832

772

dbus.Boolean(True, variant_level=1))

833

773

return r

834

774

837

777

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

838

778

if (old_checker is not None

839

779

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

840

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

780

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

841

781

dbus.Boolean(False, variant_level=1))

842

782

return r

843

844

def _reset_approved(self):

845

self._approved = None

846

return False

847

848

def approve(self, value=True):

849

self.send_changedstate()

850

self._approved = value

851

gobject.timeout_add(self._timedelta_to_milliseconds

852

(self.approval_duration),

853

self._reset_approved)

854

855

856

## D-Bus methods, signals & properties

783

784

## D-Bus methods & signals

857

785

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

858

786

859

## Signals

787

# CheckedOK - method

788

@dbus.service.method(_interface)

789

def CheckedOK(self):

790

return self.checked_ok()

860

791

861

792

# CheckerCompleted - signal

862

793

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

879

810

# GotSecret - signal

880

811

@dbus.service.signal(_interface)

881

812

def GotSecret(self):

882

"""D-Bus signal

883

Is sent after a successful transfer of secret from the Mandos

884

server to mandos-client

885

"""

813

"D-Bus signal"

886

814

pass

887

815

888

816

# Rejected - signal

889

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

890

def Rejected(self, reason):

891

"D-Bus signal"

892

pass

893

894

# NeedApproval - signal

895

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

896

def NeedApproval(self, timeout, default):

897

"D-Bus signal"

898

pass

899

900

## Methods

901

902

# Approve - method

903

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

904

def Approve(self, value):

905

self.approve(value)

906

907

# CheckedOK - method

908

@dbus.service.method(_interface)

909

def CheckedOK(self):

910

return self.checked_ok()

817

@dbus.service.signal(_interface)

818

def Rejected(self):

819

"D-Bus signal"

820

pass

911

821

912

822

# Enable - method

913

823

@dbus.service.method(_interface)

932

842

def StopChecker(self):

933

843

self.stop_checker()

934

844

935

## Properties

936

937

# ApprovalPending - property

938

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

939

def ApprovalPending_dbus_property(self):

940

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

941

942

# ApprovedByDefault - property

943

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

944

access=u"readwrite")

945

def ApprovedByDefault_dbus_property(self, value=None):

946

if value is None: # get

947

return dbus.Boolean(self.approved_by_default)

948

self.approved_by_default = bool(value)

949

# Emit D-Bus signal

950

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

951

dbus.Boolean(value, variant_level=1))

952

953

# ApprovalDelay - property

954

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

955

access=u"readwrite")

956

def ApprovalDelay_dbus_property(self, value=None):

957

if value is None: # get

958

return dbus.UInt64(self.approval_delay_milliseconds())

959

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

960

# Emit D-Bus signal

961

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

962

dbus.UInt64(value, variant_level=1))

963

964

# ApprovalDuration - property

965

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

966

access=u"readwrite")

967

def ApprovalDuration_dbus_property(self, value=None):

968

if value is None: # get

969

return dbus.UInt64(self._timedelta_to_milliseconds(

970

self.approval_duration))

971

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

972

# Emit D-Bus signal

973

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

974

dbus.UInt64(value, variant_level=1))

975

976

# Name - property

845

# name - property

977

846

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

978

def Name_dbus_property(self):

847

def name_dbus_property(self):

979

848

return dbus.String(self.name)

980

849

981

# Fingerprint - property

850

# fingerprint - property

982

851

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

983

def Fingerprint_dbus_property(self):

852

def fingerprint_dbus_property(self):

984

853

return dbus.String(self.fingerprint)

985

854

986

# Host - property

855

# host - property

987

856

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

988

857

access=u"readwrite")

989

def Host_dbus_property(self, value=None):

858

def host_dbus_property(self, value=None):

990

859

if value is None: # get

991

860

return dbus.String(self.host)

992

861

self.host = value

993

862

# Emit D-Bus signal

994

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

863

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

995

864

dbus.String(value, variant_level=1))

996

865

997

# Created - property

866

# created - property

998

867

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

999

def Created_dbus_property(self):

868

def created_dbus_property(self):

1000

869

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

1001

870

1002

# LastEnabled - property

871

# last_enabled - property

1003

872

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

1004

def LastEnabled_dbus_property(self):

873

def last_enabled_dbus_property(self):

1005

874

if self.last_enabled is None:

1006

875

return dbus.String(u"")

1007

876

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

1008

877

1009

# Enabled - property

878

# enabled - property

1010

879

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

1011

880

access=u"readwrite")

1012

def Enabled_dbus_property(self, value=None):

881

def enabled_dbus_property(self, value=None):

1013

882

if value is None: # get

1014

883

return dbus.Boolean(self.enabled)

1015

884

if value:

1017

886

else:

1018

887

self.disable()

1019

888

1020

# LastCheckedOK - property

889

# last_checked_ok - property

1021

890

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

1022

891

access=u"readwrite")

1023

def LastCheckedOK_dbus_property(self, value=None):

892

def last_checked_ok_dbus_property(self, value=None):

1024

893

if value is not None:

1025

894

self.checked_ok()

1026

895

return

1029

898

return dbus.String(self._datetime_to_dbus(self

1030

899

.last_checked_ok))

1031

900

1032

# Timeout - property

901

# timeout - property

1033

902

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

1034

903

access=u"readwrite")

1035

def Timeout_dbus_property(self, value=None):

904

def timeout_dbus_property(self, value=None):

1036

905

if value is None: # get

1037

906

return dbus.UInt64(self.timeout_milliseconds())

1038

907

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

1039

908

# Emit D-Bus signal

1040

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

909

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

1041

910

dbus.UInt64(value, variant_level=1))

1042

911

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

1043

912

return

1057

926

self.disable_initiator_tag = (gobject.timeout_add

1058

927

(time_to_die, self.disable))

1059

928

1060

# Interval - property

929

# interval - property

1061

930

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

1062

931

access=u"readwrite")

1063

def Interval_dbus_property(self, value=None):

932

def interval_dbus_property(self, value=None):

1064

933

if value is None: # get

1065

934

return dbus.UInt64(self.interval_milliseconds())

1066

935

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

1067

936

# Emit D-Bus signal

1068

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

937

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

1069

938

dbus.UInt64(value, variant_level=1))

1070

939

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

1071

940

return

1075

944

(value, self.start_checker))

1076

945

self.start_checker() # Start one now, too

1077

946

1078

# Checker - property

947

# checker - property

1079

948

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

1080

949

access=u"readwrite")

1081

def Checker_dbus_property(self, value=None):

950

def checker_dbus_property(self, value=None):

1082

951

if value is None: # get

1083

952

return dbus.String(self.checker_command)

1084

953

self.checker_command = value

1085

954

# Emit D-Bus signal

1086

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

955

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

1087

956

dbus.String(self.checker_command,

1088

957

variant_level=1))

1089

958

1090

# CheckerRunning - property

959

# checker_running - property

1091

960

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

1092

961

access=u"readwrite")

1093

def CheckerRunning_dbus_property(self, value=None):

962

def checker_running_dbus_property(self, value=None):

1094

963

if value is None: # get

1095

964

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

1096

965

if value:

1098

967

else:

1099

968

self.stop_checker()

1100

969

1101

# ObjectPath - property

970

# object_path - property

1102

971

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

1103

def ObjectPath_dbus_property(self):

972

def object_path_dbus_property(self):

1104

973

return self.dbus_object_path # is already a dbus.ObjectPath

1105

974

1106

# Secret = property

975

# secret = property

1107

976

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

1108

977

access=u"write", byte_arrays=True)

1109

def Secret_dbus_property(self, value):

978

def secret_dbus_property(self, value):

1110

979

self.secret = str(value)

1111

980

1112

981

del _interface

1113

982

1114

983

1115

class ProxyClient(object):

1116

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

1117

self._pipe = child_pipe

1118

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

1119

if not self._pipe.recv():

1120

raise KeyError()

1121

1122

def __getattribute__(self, name):

1123

if(name == '_pipe'):

1124

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

1125

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

1126

data = self._pipe.recv()

1127

if data[0] == 'data':

1128

return data[1]

1129

if data[0] == 'function':

1130

def func(*args, **kwargs):

1131

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

1132

return self._pipe.recv()[1]

1133

return func

1134

1135

def __setattr__(self, name, value):

1136

if(name == '_pipe'):

1137

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

1138

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

1139

1140

1141

984

class ClientHandler(socketserver.BaseRequestHandler, object):

1142

985

"""A class to handle client connections.

1143

986

1145

988

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

1146

989

1147

990

def handle(self):

1148

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

1149

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

1150

unicode(self.client_address))

1151

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

1152

self.server.child_pipe.fileno())

1153

991

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

992

unicode(self.client_address))

993

logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])

994

# Open IPC pipe to parent process

995

with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:

1154

996

session = (gnutls.connection

1155

997

.ClientSession(self.request,

1156

998

gnutls.connection

1157

999

.X509Credentials()))

1158

1000

1001

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

1002

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

1003

try:

1004

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

1005

raise RuntimeError

1006

except (ValueError, IndexError, RuntimeError), error:

1007

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

1008

return

1009

1159

1010

# Note: gnutls.connection.X509Credentials is really a

1160

1011

# generic GnuTLS certificate credentials object so long as

1161

1012

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

1162

1013

# here despite using OpenPGP certificates.

1163

1014

1164

1015

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

1165

1016

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

1166

1017

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

1172

1023

(gnutls.library.functions

1173

1024

.gnutls_priority_set_direct(session._c_object,

1174

1025

priority, None))

1175

1176

# Start communication using the Mandos protocol

1177

# Get protocol number

1178

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

1179

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

1180

try:

1181

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

1182

raise RuntimeError

1183

except (ValueError, IndexError, RuntimeError), error:

1184

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

1185

return

1186

1187

# Start GnuTLS connection

1026

1188

1027

try:

1189

1028

session.handshake()

1190

1029

except gnutls.errors.GNUTLSError, error:

1193

1032

# established. Just abandon the request.

1194

1033

return

1195

1034

logger.debug(u"Handshake succeeded")

1196

1197

approval_required = False

1198

1035

try:

1199

try:

1200

fpr = self.fingerprint(self.peer_certificate

1201

(session))

1202

except (TypeError, gnutls.errors.GNUTLSError), error:

1203

logger.warning(u"Bad certificate: %s", error)

1204

return

1205

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

1206

1207

try:

1208

client = ProxyClient(child_pipe, fpr,

1209

self.client_address)

1210

except KeyError:

1211

return

1212

1213

if client.approval_delay:

1214

delay = client.approval_delay

1215

client.approvals_pending += 1

1216

approval_required = True

1217

1218

while True:

1219

if not client.enabled:

1220

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

1221

client.name)

1222

if self.server.use_dbus:

1223

# Emit D-Bus signal

1224

client.Rejected("Disabled")

1225

return

1226

1227

if client._approved or not client.approval_delay:

1228

#We are approved or approval is disabled

1229

break

1230

elif client._approved is None:

1231

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

1232

client.name)

1233

if self.server.use_dbus:

1234

# Emit D-Bus signal

1235

client.NeedApproval(

1236

client.approval_delay_milliseconds(),

1237

client.approved_by_default)

1238

else:

1239

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

1240

client.name)

1241

if self.server.use_dbus:

1242

# Emit D-Bus signal

1243

client.Rejected("Denied")

1244

return

1245

1246

#wait until timeout or approved

1247

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

1248

time = datetime.datetime.now()

1249

client.changedstate.acquire()

1250

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

1251

client.changedstate.release()

1252

time2 = datetime.datetime.now()

1253

if (time2 - time) >= delay:

1254

if not client.approved_by_default:

1255

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

1256

" waiting for approval",

1257

client.name)

1258

if self.server.use_dbus:

1259

# Emit D-Bus signal

1260

client.Rejected("Approval timed out")

1261

return

1262

else:

1263

break

1264

else:

1265

delay -= time2 - time

1266

1267

sent_size = 0

1268

while sent_size < len(client.secret):

1269

try:

1270

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

1271

except (gnutls.errors.GNUTLSError), error:

1272

logger.warning("gnutls send failed")

1273

return

1274

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

1275

sent, len(client.secret)

1276

- (sent_size + sent))

1277

sent_size += sent

1278

1279

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

1280

# bump the timeout as if seen

1281

client.checked_ok()

1282

if self.server.use_dbus:

1283

# Emit D-Bus signal

1284

client.GotSecret()

1036

fpr = self.fingerprint(self.peer_certificate(session))

1037

except (TypeError, gnutls.errors.GNUTLSError), error:

1038

logger.warning(u"Bad certificate: %s", error)

1039

session.bye()

1040

return

1041

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

1285

1042

1286

finally:

1287

if approval_required:

1288

client.approvals_pending -= 1

1289

try:

1290

session.bye()

1291

except (gnutls.errors.GNUTLSError), error:

1292

logger.warning("GnuTLS bye failed")

1043

for c in self.server.clients:

1044

if c.fingerprint == fpr:

1045

client = c

1046

break

1047

else:

1048

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

1049

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

1050

session.bye()

1051

return

1052

# Have to check if client.still_valid(), since it is

1053

# possible that the client timed out while establishing

1054

# the GnuTLS session.

1055

if not client.still_valid():

1056

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

1057

session.bye()

1058

return

1059

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

1060

sent_size = 0

1061

while sent_size < len(client.secret):

1062

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

1063

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

1064

sent, len(client.secret)

1065

- (sent_size + sent))

1066

sent_size += sent

1067

session.bye()

1293

1068

1294

1069

@staticmethod

1295

1070

def peer_certificate(session):

1355

1130

return hex_fpr

1356

1131

1357

1132

1358

class MultiprocessingMixIn(object):

1359

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

1360

def sub_process_main(self, request, address):

1361

try:

1362

self.finish_request(request, address)

1363

except:

1364

self.handle_error(request, address)

1365

self.close_request(request)

1366

1367

def process_request(self, request, address):

1368

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

1369

multiprocessing.Process(target = self.sub_process_main,

1370

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

1371

1372

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1373

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

1133

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

1134

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

1374

1135

def process_request(self, request, client_address):

1375

1136

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

1376

1137

1377

1138

This function creates a new pipe in self.pipe

1378

1139

"""

1379

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1380

1381

super(MultiprocessingMixInWithPipe,

1140

self.pipe = os.pipe()

1141

super(ForkingMixInWithPipe,

1382

1142

self).process_request(request, client_address)

1383

self.child_pipe.close()

1384

self.add_pipe(parent_pipe)

1385

1386

def add_pipe(self, parent_pipe):

1143

os.close(self.pipe[1]) # close write end

1144

self.add_pipe(self.pipe[0])

1145

def add_pipe(self, pipe):

1387

1146

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

1388

pass

1389

1390

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1147

os.close(pipe)

1148

1149

1150

class IPv6_TCPServer(ForkingMixInWithPipe,

1391

1151

socketserver.TCPServer, object):

1392

1152

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

1393

1153

1478

1238

return socketserver.TCPServer.server_activate(self)

1479

1239

def enable(self):

1480

1240

self.enabled = True

1481

def add_pipe(self, parent_pipe):

1241

def add_pipe(self, pipe):

1482

1242

# Call "handle_ipc" for both data and EOF events

1483

gobject.io_add_watch(parent_pipe.fileno(),

1484

gobject.IO_IN | gobject.IO_HUP,

1485

functools.partial(self.handle_ipc,

1486

parent_pipe = parent_pipe))

1487

1488

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

1489

client_object=None):

1243

gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,

1244

self.handle_ipc)

1245

def handle_ipc(self, source, condition, file_objects={}):

1490

1246

condition_names = {

1491

1247

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

1492

1248

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

1501

1257

for cond, name in

1502

1258

condition_names.iteritems()

1503

1259

if cond & condition)

1504

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

1505

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

1506

return False

1507

1508

# Read a request from the child

1509

request = parent_pipe.recv()

1510

command = request[0]

1511

1512

if command == 'init':

1513

fpr = request[1]

1514

address = request[2]

1515

1516

for c in self.clients:

1517

if c.fingerprint == fpr:

1518

client = c

1519

break

1520

else:

1521

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

1522

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

1523

if self.use_dbus:

1524

# Emit D-Bus signal

1525

mandos_dbus_service.ClientNotFound(fpr, address[0])

1526

parent_pipe.send(False)

1527

return False

1528

1529

gobject.io_add_watch(parent_pipe.fileno(),

1530

gobject.IO_IN | gobject.IO_HUP,

1531

functools.partial(self.handle_ipc,

1532

parent_pipe = parent_pipe,

1533

client_object = client))

1534

parent_pipe.send(True)

1535

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

1536

return False

1537

if command == 'funcall':

1538

funcname = request[1]

1539

args = request[2]

1540

kwargs = request[3]

1541

1542

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

1543

1544

if command == 'getattr':

1545

attrname = request[1]

1546

if callable(client_object.__getattribute__(attrname)):

1547

parent_pipe.send(('function',))

1548

else:

1549

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

1550

1551

if command == 'setattr':

1552

attrname = request[1]

1553

value = request[2]

1554

setattr(client_object, attrname, value)

1555

1260

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

1261

conditions_string)

1262

1263

# Turn the pipe file descriptor into a Python file object

1264

if source not in file_objects:

1265

file_objects[source] = os.fdopen(source, u"r", 1)

1266

1267

# Read a line from the file object

1268

cmdline = file_objects[source].readline()

1269

if not cmdline: # Empty line means end of file

1270

# close the IPC pipe

1271

file_objects[source].close()

1272

del file_objects[source]

1273

1274

# Stop calling this function

1275

return False

1276

1277

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

1278

1279

# Parse and act on command

1280

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

1281

1282

if cmd == u"NOTFOUND":

1283

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

1284

args)

1285

if self.use_dbus:

1286

# Emit D-Bus signal

1287

mandos_dbus_service.ClientNotFound(args)

1288

elif cmd == u"INVALID":

1289

for client in self.clients:

1290

if client.name == args:

1291

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

1292

if self.use_dbus:

1293

# Emit D-Bus signal

1294

client.Rejected()

1295

break

1296

else:

1297

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

1298

elif cmd == u"SENDING":

1299

for client in self.clients:

1300

if client.name == args:

1301

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

1302

client.checked_ok()

1303

if self.use_dbus:

1304

# Emit D-Bus signal

1305

client.GotSecret()

1306

break

1307

else:

1308

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

1309

args)

1310

else:

1311

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

1312

1313

# Keep calling this function

1556

1314

return True

1557

1315

1558

1316

1609

1367

def if_nametoindex(interface):

1610

1368

"Get an interface index the hard way, i.e. using fcntl()"

1611

1369

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

1612

with contextlib.closing(socket.socket()) as s:

1370

with closing(socket.socket()) as s:

1613

1371

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1614

1372

struct.pack(str(u"16s16x"),

1615

1373

interface))

1661

1419

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

1662

1420

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

1663

1421

u" terminal")

1664

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

1665

help=u"Debug level for stdout output")

1666

1422

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

1667

1423

u" priority string (see GnuTLS documentation)")

1668

1424

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

1693

1449

u"servicename": u"Mandos",

1694

1450

u"use_dbus": u"True",

1695

1451

u"use_ipv6": u"True",

1696

u"debuglevel": u"",

1697

1452

}

1698

1453

1699

1454

# Parse config file for server-global settings

1716

1471

# options, if set.

1717

1472

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

1718

1473

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

1719

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

1474

u"use_dbus", u"use_ipv6"):

1720

1475

value = getattr(options, option)

1721

1476

if value is not None:

1722

1477

server_settings[option] = value

1731

1486

1732

1487

# For convenience

1733

1488

debug = server_settings[u"debug"]

1734

debuglevel = server_settings[u"debuglevel"]

1735

1489

use_dbus = server_settings[u"use_dbus"]

1736

1490

use_ipv6 = server_settings[u"use_ipv6"]

1737

1491

1492

if not debug:

1493

syslogger.setLevel(logging.WARNING)

1494

console.setLevel(logging.WARNING)

1495

1738

1496

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

1739

1497

syslogger.setFormatter(logging.Formatter

1740

1498

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

1746

1504

u"interval": u"5m",

1747

1505

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

1748

1506

u"host": u"",

1749

u"approval_delay": u"0s",

1750

u"approval_duration": u"1s",

1751

1507

}

1752

1508

client_config = configparser.SafeConfigParser(client_defaults)

1753

1509

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

1759

1515

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

1760

1516

server_settings[u"port"]),

1761

1517

ClientHandler,

1762

interface=(server_settings[u"interface"]

1763

or None),

1518

interface=server_settings[u"interface"],

1764

1519

use_ipv6=use_ipv6,

1765

1520

gnutls_priority=

1766

1521

server_settings[u"priority"],

1767

1522

use_dbus=use_dbus)

1768

if not debug:

1769

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

1770

try:

1771

pidfile = open(pidfilename, u"w")

1772

except IOError:

1773

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

1523

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

1524

try:

1525

pidfile = open(pidfilename, u"w")

1526

except IOError:

1527

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

1774

1528

1775

1529

try:

1776

1530

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

1793

1547

if error[0] != errno.EPERM:

1794

1548

raise error

1795

1549

1796

if not debug and not debuglevel:

1797

syslogger.setLevel(logging.WARNING)

1798

console.setLevel(logging.WARNING)

1799

if debuglevel:

1800

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

1801

syslogger.setLevel(level)

1802

console.setLevel(level)

1803

1550

# Enable all possible GnuTLS debugging

1804

1551

if debug:

1805

# Enable all possible GnuTLS debugging

1806

1807

1552

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

1808

1553

# - GnuTLS manual

1809

1554

gnutls.library.functions.gnutls_global_set_log_level(11)

1814

1559

1815

1560

(gnutls.library.functions

1816

1561

.gnutls_global_set_log_function(debug_gnutls))

1817

1818

# Redirect stdin so all checkers get /dev/null

1819

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

1820

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

1821

if null > 2:

1822

os.close(null)

1823

else:

1824

# No console logging

1825

logger.removeHandler(console)

1826

1827

1562

1828

1563

global main_loop

1829

1564

# From the Avahi example code

1847

1582

if server_settings["interface"]:

1848

1583

service.interface = (if_nametoindex

1849

1584

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

1850

1851

if not debug:

1852

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

1853

daemon()

1854

1855

global multiprocessing_manager

1856

multiprocessing_manager = multiprocessing.Manager()

1857

1585

1858

1586

client_class = Client

1859

1587

if use_dbus:

1860

1588

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

1861

def client_config_items(config, section):

1862

special_settings = {

1863

"approved_by_default":

1864

lambda: config.getboolean(section,

1865

"approved_by_default"),

1866

}

1867

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

1868

try:

1869

yield (name, special_settings[name]())

1870

except KeyError:

1871

yield (name, value)

1872

1873

1589

tcp_server.clients.update(set(

1874

1590

client_class(name = section,

1875

config= dict(client_config_items(

1876

client_config, section)))

1591

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

1877

1592

for section in client_config.sections()))

1878

1593

if not tcp_server.clients:

1879

1594

logger.warning(u"No clients defined")

1880

1595

1596

if debug:

1597

# Redirect stdin so all checkers get /dev/null

1598

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

1599

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

1600

if null > 2:

1601

os.close(null)

1602

else:

1603

# No console logging

1604

logger.removeHandler(console)

1605

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

1606

daemon()

1607

1608

try:

1609

with closing(pidfile):

1610

pid = os.getpid()

1611

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

1612

del pidfile

1613

except IOError:

1614

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

1615

pidfilename, pid)

1616

except NameError:

1617

# "pidfile" was never created

1618

pass

1619

del pidfilename

1620

1881

1621

if not debug:

1882

try:

1883

with pidfile:

1884

pid = os.getpid()

1885

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

1886

del pidfile

1887

except IOError:

1888

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

1889

pidfilename, pid)

1890

except NameError:

1891

# "pidfile" was never created

1892

pass

1893

del pidfilename

1894

1895

1622

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

1896

1897

1623

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

1898

1624

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

1899

1625

1904

1630

dbus.service.Object.__init__(self, bus, u"/")

1905

1631

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

1906

1632

1907

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

1908

def ClientAdded(self, objpath):

1633

@dbus.service.signal(_interface, signature=u"oa{sv}")

1634

def ClientAdded(self, objpath, properties):

1909

1635

"D-Bus signal"

1910

1636

pass

1911

1637

1912

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

1913

def ClientNotFound(self, fingerprint, address):

1638

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

1639

def ClientNotFound(self, fingerprint):

1914

1640

"D-Bus signal"

1915

1641

pass

1916

1642

1973

1699

for client in tcp_server.clients:

1974

1700

if use_dbus:

1975

1701

# Emit D-Bus signal

1976

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1702

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1703

client.GetAll(u""))

1977

1704

client.enable()

1978

1705

1979

1706

tcp_server.enable()