/mandos/trunk : revision 456

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 select

63

import multiprocessing

64

65

import dbus

66

import dbus.service

81

SO_BINDTODEVICE = None

82

83

84

version = "1.0.14"

84

version = "1.2.1"

85

86

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

86

87

logger = logging.Logger(u'mandos')

87

88

syslogger = (logging.handlers.SysLogHandler

88

89

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

156

157

u" after %i retries, exiting.",

157

158

self.rename_count)

158

159

raise AvahiServiceError(u"Too many renames")

159

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

160

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

160

161

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

161

unicode(self.name))

162

self.name)

162

163

syslogger.setFormatter(logging.Formatter

163

164

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

164

165

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

165

166

% self.name))

166

167

self.remove()

167

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)

168

174

self.rename_count += 1

169

175

def remove(self):

170

176

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

234

240

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

235

241

236

242

Attributes:

237

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

238

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()

239

260

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

240

261

uniquely identify the client

241

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

242

262

host: string; available for use by the checker command

243

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

244

266

last_enabled: datetime.datetime(); (UTC)

245

enabled: bool()

246

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

247

270

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

248

271

until this client is disabled

249

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

250

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

251

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

252

to see if the client lives.

253

'None' if no process is running.

254

checker_initiator_tag: a gobject event source tag, or None

255

disable_initiator_tag: - '' -

256

checker_callback_tag: - '' -

257

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

258

client lives. %() expansions are done at

259

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

260

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

261

current_checker_command: string; current running checker_command

272

runtime_expansions: Allowed attributes for runtime expansion.

262

273

"""

263

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

264

280

@staticmethod

265

281

def _timedelta_to_milliseconds(td):

266

282

"Convert a datetime.timedelta() to milliseconds"

275

291

def interval_milliseconds(self):

276

292

"Return the 'interval' attribute in milliseconds"

277

293

return self._timedelta_to_milliseconds(self.interval)

294

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

278

297

279

298

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

280

299

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

303

322

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

304

323

self.created = datetime.datetime.utcnow()

305

324

self.enabled = False

325

self.last_approval_request = None

306

326

self.last_enabled = None

307

327

self.last_checked_ok = None

308

328

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

315

335

self.checker_command = config[u"checker"]

316

336

self.current_checker_command = None

317

337

self.last_connect = None

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())

318

347

348

def send_changedstate(self):

349

self.changedstate.acquire()

350

self.changedstate.notify_all()

351

self.changedstate.release()

352

319

353

def enable(self):

320

354

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

321

355

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

322

356

# Already enabled

323

357

return

358

self.send_changedstate()

324

359

self.last_enabled = datetime.datetime.utcnow()

325

360

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

326

361

# and every interval from then on.

340

375

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

341

376

return False

342

377

if not quiet:

378

self.send_changedstate()

379

if not quiet:

343

380

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

344

381

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

345

382

gobject.source_remove(self.disable_initiator_tag)

387

424

(self.timeout_milliseconds(),

388

425

self.disable))

389

426

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

390

430

def start_checker(self):

391

431

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

392

432

421

461

command = self.checker_command % self.host

422

462

except TypeError:

423

463

# Escape attributes for the shell

424

escaped_attrs = dict((key,

425

re.escape(unicode(str(val),

426

errors=

427

u'replace')))

428

for key, val in

429

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

430

472

try:

431

473

command = self.checker_command % escaped_attrs

432

474

except TypeError, error:

478

520

raise

479

521

self.checker = None

480

522

481

482

523

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

483

524

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

484

525

"""Decorators for marking methods of a DBusObjectWithProperties to

675

716

dbus_object_path: dbus.ObjectPath

676

717

bus: dbus.SystemBus()

677

718

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

678

723

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

679

724

680

725

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

726

self._approvals_pending = 0

681

727

self.bus = bus

682

728

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

683

729

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

684

730

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

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

733

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

685

734

self.dbus_object_path = (dbus.ObjectPath

686

(u"/clients/"

687

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

735

(u"/clients/" + client_object_name))

688

736

DBusObjectWithProperties.__init__(self, self.bus,

689

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

690

754

691

755

@staticmethod

692

756

def _datetime_to_dbus(dt, variant_level=0):

699

763

r = Client.enable(self)

700

764

if oldstate != self.enabled:

701

765

# Emit D-Bus signals

702

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

766

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

703

767

dbus.Boolean(True, variant_level=1))

704

768

self.PropertyChanged(

705

dbus.String(u"last_enabled"),

769

dbus.String(u"LastEnabled"),

706

770

self._datetime_to_dbus(self.last_enabled,

707

771

variant_level=1))

708

772

return r

712

776

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

713

777

if not quiet and oldstate != self.enabled:

714

778

# Emit D-Bus signal

715

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

779

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

716

780

dbus.Boolean(False, variant_level=1))

717

781

return r

718

782

730

794

self.checker_callback_tag = None

731

795

self.checker = None

732

796

# Emit D-Bus signal

733

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

797

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

734

798

dbus.Boolean(False, variant_level=1))

735

799

if os.WIFEXITED(condition):

736

800

exitstatus = os.WEXITSTATUS(condition)

751

815

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

752

816

# Emit D-Bus signal

753

817

self.PropertyChanged(

754

dbus.String(u"last_checked_ok"),

818

dbus.String(u"LastCheckedOK"),

755

819

(self._datetime_to_dbus(self.last_checked_ok,

756

820

variant_level=1)))

757

821

return r

758

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

759

832

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

760

833

old_checker = self.checker

761

834

if self.checker is not None:

769

842

# Emit D-Bus signal

770

843

self.CheckerStarted(self.current_checker_command)

771

844

self.PropertyChanged(

772

dbus.String(u"checker_running"),

845

dbus.String(u"CheckerRunning"),

773

846

dbus.Boolean(True, variant_level=1))

774

847

return r

775

848

778

851

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

779

852

if (old_checker is not None

780

853

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

781

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

854

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

782

855

dbus.Boolean(False, variant_level=1))

783

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

784

869

785

870

## D-Bus methods, signals & properties

786

871

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

808

893

# GotSecret - signal

809

894

@dbus.service.signal(_interface)

810

895

def GotSecret(self):

811

"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

"""

812

900

pass

813

901

814

902

# Rejected - signal

815

@dbus.service.signal(_interface)

816

def Rejected(self):

903

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

904

def Rejected(self, reason):

817

905

"D-Bus signal"

818

906

pass

819

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

820

914

## Methods

821

915

916

# Approve - method

917

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

918

def Approve(self, value):

919

self.approve(value)

920

822

921

# CheckedOK - method

823

922

@dbus.service.method(_interface)

824

923

def CheckedOK(self):

849

948

850

949

## Properties

851

950

852

# 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

853

991

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

854

def name_dbus_property(self):

992

def Name_dbus_property(self):

855

993

return dbus.String(self.name)

856

994

857

# fingerprint - property

995

# Fingerprint - property

858

996

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

859

def fingerprint_dbus_property(self):

997

def Fingerprint_dbus_property(self):

860

998

return dbus.String(self.fingerprint)

861

999

862

# host - property

1000

# Host - property

863

1001

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

864

1002

access=u"readwrite")

865

def host_dbus_property(self, value=None):

1003

def Host_dbus_property(self, value=None):

866

1004

if value is None: # get

867

1005

return dbus.String(self.host)

868

1006

self.host = value

869

1007

# Emit D-Bus signal

870

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

1008

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

871

1009

dbus.String(value, variant_level=1))

872

1010

873

# created - property

1011

# Created - property

874

1012

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

875

def created_dbus_property(self):

1013

def Created_dbus_property(self):

876

1014

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

877

1015

878

# last_enabled - property

1016

# LastEnabled - property

879

1017

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

880

def last_enabled_dbus_property(self):

1018

def LastEnabled_dbus_property(self):

881

1019

if self.last_enabled is None:

882

1020

return dbus.String(u"")

883

1021

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

884

1022

885

# enabled - property

1023

# Enabled - property

886

1024

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

887

1025

access=u"readwrite")

888

def enabled_dbus_property(self, value=None):

1026

def Enabled_dbus_property(self, value=None):

889

1027

if value is None: # get

890

1028

return dbus.Boolean(self.enabled)

891

1029

if value:

893

1031

else:

894

1032

self.disable()

895

1033

896

# last_checked_ok - property

1034

# LastCheckedOK - property

897

1035

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

898

1036

access=u"readwrite")

899

def last_checked_ok_dbus_property(self, value=None):

1037

def LastCheckedOK_dbus_property(self, value=None):

900

1038

if value is not None:

901

1039

self.checked_ok()

902

1040

return

905

1043

return dbus.String(self._datetime_to_dbus(self

906

1044

.last_checked_ok))

907

1045

908

# 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

909

1056

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

910

1057

access=u"readwrite")

911

def timeout_dbus_property(self, value=None):

1058

def Timeout_dbus_property(self, value=None):

912

1059

if value is None: # get

913

1060

return dbus.UInt64(self.timeout_milliseconds())

914

1061

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

915

1062

# Emit D-Bus signal

916

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

1063

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

917

1064

dbus.UInt64(value, variant_level=1))

918

1065

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

919

1066

return

933

1080

self.disable_initiator_tag = (gobject.timeout_add

934

1081

(time_to_die, self.disable))

935

1082

936

# interval - property

1083

# Interval - property

937

1084

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

938

1085

access=u"readwrite")

939

def interval_dbus_property(self, value=None):

1086

def Interval_dbus_property(self, value=None):

940

1087

if value is None: # get

941

1088

return dbus.UInt64(self.interval_milliseconds())

942

1089

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

943

1090

# Emit D-Bus signal

944

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

1091

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

945

1092

dbus.UInt64(value, variant_level=1))

946

1093

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

947

1094

return

951

1098

(value, self.start_checker))

952

1099

self.start_checker() # Start one now, too

953

1100

954

# checker - property

1101

# Checker - property

955

1102

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

956

1103

access=u"readwrite")

957

def checker_dbus_property(self, value=None):

1104

def Checker_dbus_property(self, value=None):

958

1105

if value is None: # get

959

1106

return dbus.String(self.checker_command)

960

1107

self.checker_command = value

961

1108

# Emit D-Bus signal

962

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

1109

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

963

1110

dbus.String(self.checker_command,

964

1111

variant_level=1))

965

1112

966

# checker_running - property

1113

# CheckerRunning - property

967

1114

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

968

1115

access=u"readwrite")

969

def checker_running_dbus_property(self, value=None):

1116

def CheckerRunning_dbus_property(self, value=None):

970

1117

if value is None: # get

971

1118

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

972

1119

if value:

974

1121

else:

975

1122

self.stop_checker()

976

1123

977

# object_path - property

1124

# ObjectPath - property

978

1125

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

979

def object_path_dbus_property(self):

1126

def ObjectPath_dbus_property(self):

980

1127

return self.dbus_object_path # is already a dbus.ObjectPath

981

1128

982

# secret = property

1129

# Secret = property

983

1130

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

984

1131

access=u"write", byte_arrays=True)

985

def secret_dbus_property(self, value):

1132

def Secret_dbus_property(self, value):

986

1133

self.secret = str(value)

987

1134

988

1135

del _interface

989

1136

990

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

991

1164

class ClientHandler(socketserver.BaseRequestHandler, object):

992

1165

"""A class to handle client connections.

993

1166

995

1168

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

996

1169

997

1170

def handle(self):

998

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

999

unicode(self.client_address))

1000

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

1001

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

1002

# Open IPC pipe to parent process

1003

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

1004

self.server.parent_pipe[0]

1005

) 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

1006

1177

session = (gnutls.connection

1007

1178

.ClientSession(self.request,

1008

1179

gnutls.connection

1009

1180

.X509Credentials()))

1010

1181

1011

1182

# Note: gnutls.connection.X509Credentials is really a

1012

1183

# generic GnuTLS certificate credentials object so long as

1013

1184

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

1014

1185

# here despite using OpenPGP certificates.

1015

1186

1016

1187

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

1017

1188

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

1018

1189

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

1024

1195

(gnutls.library.functions

1025

1196

.gnutls_priority_set_direct(session._c_object,

1026

1197

priority, None))

1027

1198

1028

1199

# Start communication using the Mandos protocol

1029

1200

# Get protocol number

1030

1201

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

1035

1206

except (ValueError, IndexError, RuntimeError), error:

1036

1207

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

1037

1208

return

1038

1209

1039

1210

# Start GnuTLS connection

1040

1211

try:

1041

1212

session.handshake()

1045

1216

# established. Just abandon the request.

1046

1217

return

1047

1218

logger.debug(u"Handshake succeeded")

1219

1220

approval_required = False

1048

1221

try:

1049

1222

try:

1050

1223

fpr = self.fingerprint(self.peer_certificate

1054

1227

return

1055

1228

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

1056

1229

1057

for c in self.server.clients:

1058

if c.fingerprint == fpr:

1059

client = c

1230

try:

1231

client = ProxyClient(child_pipe, fpr,

1232

self.client_address)

1233

except KeyError:

1234

return

1235

1236

if client.approval_delay:

1237

delay = client.approval_delay

1238

client.approvals_pending += 1

1239

approval_required = True

1240

1241

while True:

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")

1248

return

1249

1250

if client._approved or not client.approval_delay:

1251

#We are approved or approval is disabled

1060

1252

break

1061

else:

1062

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

1063

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

1064

return

1065

1066

class ClientProxy(object):

1067

"""Client proxy object. Not for calling methods."""

1068

def __init__(self, client):

1069

self.client = client

1070

def __getattr__(self, name):

1071

if name.startswith("ipc_"):

1072

def tempfunc():

1073

ipc.write("%s %s\n" % (name[4:].upper(),

1074

self.client.name))

1075

return tempfunc

1076

if not hasattr(self.client, name):

1077

raise AttributeError

1078

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

1079

% (name, self.client.fingerprint))

1080

return pickle.load(ipc_return)

1081

clientproxy = ClientProxy(client)

1082

# Have to check if client.enabled, since it is

1083

# possible that the client was disabled since the

1084

# GnuTLS session was established.

1085

if not clientproxy.enabled:

1086

clientproxy.ipc_disabled()

1087

return

1088

1089

clientproxy.ipc_sending()

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")

1267

return

1268

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

1090

1290

sent_size = 0

1091

1291

while sent_size < len(client.secret):

1092

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

1093

1297

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

1094

1298

sent, len(client.secret)

1095

1299

- (sent_size + sent))

1096

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

1097

1309

finally:

1098

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")

1099

1316

1100

1317

@staticmethod

1101

1318

def peer_certificate(session):

1161

1378

return hex_fpr

1162

1379

1163

1380

1164

class ForkingMixInWithPipes(socketserver.ForkingMixIn, object):

1165

"""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 """

1166

1397

def process_request(self, request, client_address):

1167

1398

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

1168

1399

1169

1400

This function creates a new pipe in self.pipe

1170

1401

"""

1171

# Child writes to child_pipe

1172

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

1173

# Parent writes to parent_pipe

1174

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

1175

super(ForkingMixInWithPipes,

1402

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1403

1404

super(MultiprocessingMixInWithPipe,

1176

1405

self).process_request(request, client_address)

1177

# Close unused ends for parent

1178

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

1179

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

1180

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

1181

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):

1182

1410

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

1183

child_pipe_fd.close()

1184

parent_pipe_fd.close()

1185

1186

1187

class IPv6_TCPServer(ForkingMixInWithPipes,

1411

pass

1412

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1188

1414

socketserver.TCPServer, object):

1189

1415

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

1190

1416

1275

1501

return socketserver.TCPServer.server_activate(self)

1276

1502

def enable(self):

1277

1503

self.enabled = True

1278

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1504

def add_pipe(self, parent_pipe):

1279

1505

# Call "handle_ipc" for both data and EOF events

1280

gobject.io_add_watch(child_pipe_fd.fileno(),

1506

gobject.io_add_watch(parent_pipe.fileno(),

1281

1507

gobject.IO_IN | gobject.IO_HUP,

1282

1508

functools.partial(self.handle_ipc,

1283

reply = parent_pipe_fd,

1284

sender= child_pipe_fd))

1285

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):

1286

1513

condition_names = {

1287

1514

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

1288

1515

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

1297

1524

for cond, name in

1298

1525

condition_names.iteritems()

1299

1526

if cond & condition)

1300

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

1301

conditions_string)

1302

1303

# Read a line from the file object

1304

cmdline = sender.readline()

1305

if not cmdline: # Empty line means end of file

1306

# close the IPC pipes

1307

sender.close()

1308

reply.close()

1309

1310

# Stop calling this function

1311

return False

1312

1313

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

1314

1315

# Parse and act on command

1316

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

1317

1318

if cmd == u"NOTFOUND":

1319

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

1320

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

1321

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

1322

if self.use_dbus:

1323

# Emit D-Bus signal

1324

mandos_dbus_service.ClientNotFound(fpr, address)

1325

elif cmd == u"DISABLED":

1326

for client in self.clients:

1327

if client.name == args:

1328

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

1329

if self.use_dbus:

1330

# Emit D-Bus signal

1331

client.Rejected()

1332

break

1333

else:

1334

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

1335

elif cmd == u"SENDING":

1336

for client in self.clients:

1337

if client.name == args:

1338

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

1339

client.checked_ok()

1340

if self.use_dbus:

1341

# Emit D-Bus signal

1342

client.GotSecret()

1343

break

1344

else:

1345

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

1346

args)

1347

elif cmd == u"GETATTR":

1348

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

1349

for client in self.clients:

1350

if client.fingerprint == fpr:

1351

attr_value = getattr(client, attr_name, None)

1352

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

1353

pickle.dump(attr_value, reply)

1354

break

1355

else:

1356

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

1357

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

1358

attr_name)

1359

pickle.dump(None, reply)

1360

else:

1361

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

1362

1363

# 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

1364

1579

return True

1365

1580

1366

1581

1469

1684

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

1470

1685

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

1471

1686

u" terminal")

1687

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

1688

help=u"Debug level for stdout output")

1472

1689

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

1473

1690

u" priority string (see GnuTLS documentation)")

1474

1691

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

1499

1716

u"servicename": u"Mandos",

1500

1717

u"use_dbus": u"True",

1501

1718

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1502

1720

}

1503

1721

1504

1722

# Parse config file for server-global settings

1521

1739

# options, if set.

1522

1740

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

1523

1741

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

1524

u"use_dbus", u"use_ipv6"):

1742

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

1525

1743

value = getattr(options, option)

1526

1744

if value is not None:

1527

1745

server_settings[option] = value

1536

1754

1537

1755

# For convenience

1538

1756

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1539

1758

use_dbus = server_settings[u"use_dbus"]

1540

1759

use_ipv6 = server_settings[u"use_ipv6"]

1541

1542

if not debug:

1543

syslogger.setLevel(logging.WARNING)

1544

console.setLevel(logging.WARNING)

1545

1760

1546

1761

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

1547

1762

syslogger.setFormatter(logging.Formatter

1548

1763

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

1554

1769

u"interval": u"5m",

1555

1770

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

1556

1771

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1557

1774

}

1558

1775

client_config = configparser.SafeConfigParser(client_defaults)

1559

1776

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

1565

1782

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

1566

1783

server_settings[u"port"]),

1567

1784

ClientHandler,

1568

interface=server_settings[u"interface"],

1785

interface=(server_settings[u"interface"]

1786

or None),

1569

1787

use_ipv6=use_ipv6,

1570

1788

gnutls_priority=

1571

1789

server_settings[u"priority"],

1572

1790

use_dbus=use_dbus)

1573

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

1574

try:

1575

pidfile = open(pidfilename, u"w")

1576

except IOError:

1577

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)

1578

1797

1579

1798

try:

1580

1799

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

1597

1816

if error[0] != errno.EPERM:

1598

1817

raise error

1599

1818

1600

# 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

1601

1827

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1602

1830

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

1603

1831

# - GnuTLS manual

1604

1832

gnutls.library.functions.gnutls_global_set_log_level(11)

1609

1837

1610

1838

(gnutls.library.functions

1611

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

1612

1850

1613

1851

global main_loop

1614

1852

# From the Avahi example code

1632

1870

if server_settings["interface"]:

1633

1871

service.interface = (if_nametoindex

1634

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()

1635

1880

1636

1881

client_class = Client

1637

1882

if use_dbus:

1638

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

1639

1896

tcp_server.clients.update(set(

1640

1897

client_class(name = section,

1641

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

1898

config= dict(client_config_items(

1899

client_config, section)))

1642

1900

for section in client_config.sections()))

1643

1901

if not tcp_server.clients:

1644

1902

logger.warning(u"No clients defined")

1645

1646

if debug:

1647

# Redirect stdin so all checkers get /dev/null

1648

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

1649

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

1650

if null > 2:

1651

os.close(null)

1652

else:

1653

# No console logging

1654

logger.removeHandler(console)

1655

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

1656

daemon()

1657

1658

try:

1659

with pidfile:

1660

pid = os.getpid()

1661

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

1662

del pidfile

1663

except IOError:

1664

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

1665

pidfilename, pid)

1666

except NameError:

1667

# "pidfile" was never created

1668

pass

1669

del pidfilename

1670

1903

1671

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

1672

1918

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

1919

1673

1920

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

1674

1921

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

1675

1922