/mandos/trunk : revision 416.1.2

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

import select

64

65

import dbus

66

import dbus.service

81

SO_BINDTODEVICE = None

82

83

84

version = "1.2"

84

version = "1.0.14"

85

86

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

87

86

logger = logging.Logger(u'mandos')

88

87

syslogger = (logging.handlers.SysLogHandler

89

88

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

157

156

u" after %i retries, exiting.",

158

157

self.rename_count)

159

158

raise AvahiServiceError(u"Too many renames")

160

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

159

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

161

160

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

162

self.name)

161

unicode(self.name))

163

162

syslogger.setFormatter(logging.Formatter

164

163

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

165

164

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

166

165

% self.name))

167

166

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)

167

self.add()

174

168

self.rename_count += 1

175

169

def remove(self):

176

170

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

199

193

self.group.Commit()

200

194

def entry_group_state_changed(self, state, error):

201

195

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

202

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

196

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

203

197

204

198

if state == avahi.ENTRY_GROUP_ESTABLISHED:

205

199

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

218

212

self.group = None

219

213

def server_state_changed(self, state):

220

214

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

221

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

222

215

if state == avahi.SERVER_COLLISION:

223

216

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

224

217

self.remove()

240

233

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

241

234

242

235

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

236

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

237

D-Bus identifiers

238

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

239

uniquely identify the client

240

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

241

host: string; available for use by the checker command

242

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

243

last_enabled: datetime.datetime(); (UTC)

244

enabled: bool()

245

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

246

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

247

until this client is disabled

248

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

249

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

246

250

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

247

251

to see if the client lives.

248

252

'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

253

checker_initiator_tag: a gobject event source tag, or None

254

disable_initiator_tag: - '' -

255

checker_callback_tag: - '' -

256

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

257

client lives. %() expansions are done at

252

258

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

253

259

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

260

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

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_approval_request: datetime.datetime(); (UTC) or None

265

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

266

last_enabled: datetime.datetime(); (UTC)

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

270

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

271

until this client is disabled

272

runtime_expansions: Allowed attributes for runtime expansion.

273

261

"""

274

262

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

280

263

@staticmethod

281

264

def _timedelta_to_milliseconds(td):

282

265

"Convert a datetime.timedelta() to milliseconds"

291

274

def interval_milliseconds(self):

292

275

"Return the 'interval' attribute in milliseconds"

293

276

return self._timedelta_to_milliseconds(self.interval)

294

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

297

277

298

278

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

299

279

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

322

302

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

323

303

self.created = datetime.datetime.utcnow()

324

304

self.enabled = False

325

self.last_approval_request = None

326

305

self.last_enabled = None

327

306

self.last_checked_ok = None

328

307

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

335

314

self.checker_command = config[u"checker"]

336

315

self.current_checker_command = None

337

316

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

347

317

348

def send_changedstate(self):

349

self.changedstate.acquire()

350

self.changedstate.notify_all()

351

self.changedstate.release()

352

353

318

def enable(self):

354

319

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

355

320

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

356

321

# Already enabled

357

322

return

358

self.send_changedstate()

359

323

self.last_enabled = datetime.datetime.utcnow()

360

324

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

361

325

# and every interval from then on.

375

339

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

376

340

return False

377

341

if not quiet:

378

self.send_changedstate()

379

if not quiet:

380

342

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

381

343

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

382

344

gobject.source_remove(self.disable_initiator_tag)

424

386

(self.timeout_milliseconds(),

425

387

self.disable))

426

388

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

430

389

def start_checker(self):

431

390

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

432

391

461

420

command = self.checker_command % self.host

462

421

except TypeError:

463

422

# Escape attributes for the shell

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

423

escaped_attrs = dict((key,

424

re.escape(unicode(str(val),

425

errors=

426

u'replace')))

427

for key, val in

428

vars(self).iteritems())

472

429

try:

473

430

command = self.checker_command % escaped_attrs

474

431

except TypeError, error:

520

477

raise

521

478

self.checker = None

522

479

480

523

481

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

524

482

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

525

483

"""Decorators for marking methods of a DBusObjectWithProperties to

716

674

dbus_object_path: dbus.ObjectPath

717

675

bus: dbus.SystemBus()

718

676

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

723

677

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

724

678

725

679

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

726

self._approvals_pending = 0

727

680

self.bus = bus

728

681

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

729

682

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

730

683

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

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

733

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

734

684

self.dbus_object_path = (dbus.ObjectPath

735

(u"/clients/" + client_object_name))

685

(u"/clients/"

686

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

736

687

DBusObjectWithProperties.__init__(self, self.bus,

737

688

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

754

689

755

690

@staticmethod

756

691

def _datetime_to_dbus(dt, variant_level=0):

763

698

r = Client.enable(self)

764

699

if oldstate != self.enabled:

765

700

# Emit D-Bus signals

766

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

701

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

767

702

dbus.Boolean(True, variant_level=1))

768

703

self.PropertyChanged(

769

dbus.String(u"LastEnabled"),

704

dbus.String(u"last_enabled"),

770

705

self._datetime_to_dbus(self.last_enabled,

771

706

variant_level=1))

772

707

return r

776

711

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

777

712

if not quiet and oldstate != self.enabled:

778

713

# Emit D-Bus signal

779

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

714

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

780

715

dbus.Boolean(False, variant_level=1))

781

716

return r

782

717

794

729

self.checker_callback_tag = None

795

730

self.checker = None

796

731

# Emit D-Bus signal

797

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

732

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

798

733

dbus.Boolean(False, variant_level=1))

799

734

if os.WIFEXITED(condition):

800

735

exitstatus = os.WEXITSTATUS(condition)

815

750

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

816

751

# Emit D-Bus signal

817

752

self.PropertyChanged(

818

dbus.String(u"LastCheckedOK"),

753

dbus.String(u"last_checked_ok"),

819

754

(self._datetime_to_dbus(self.last_checked_ok,

820

755

variant_level=1)))

821

756

return r

822

757

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

832

758

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

833

759

old_checker = self.checker

834

760

if self.checker is not None:

842

768

# Emit D-Bus signal

843

769

self.CheckerStarted(self.current_checker_command)

844

770

self.PropertyChanged(

845

dbus.String(u"CheckerRunning"),

771

dbus.String(u"checker_running"),

846

772

dbus.Boolean(True, variant_level=1))

847

773

return r

848

774

851

777

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

852

778

if (old_checker is not None

853

779

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

854

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

780

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

855

781

dbus.Boolean(False, variant_level=1))

856

782

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

869

783

870

784

## D-Bus methods, signals & properties

871

785

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

893

807

# GotSecret - signal

894

808

@dbus.service.signal(_interface)

895

809

def GotSecret(self):

896

"""D-Bus signal

897

Is sent after a successful transfer of secret from the Mandos

898

server to mandos-client

899

"""

810

"D-Bus signal"

900

811

pass

901

812

902

813

# Rejected - signal

903

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

904

def Rejected(self, reason):

814

@dbus.service.signal(_interface)

815

def Rejected(self):

905

816

"D-Bus signal"

906

817

pass

907

818

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

914

819

## Methods

915

820

916

# Approve - method

917

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

918

def Approve(self, value):

919

self.approve(value)

920

921

821

# CheckedOK - method

922

822

@dbus.service.method(_interface)

923

823

def CheckedOK(self):

948

848

949

849

## Properties

950

850

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

851

# name - property

991

852

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

992

def Name_dbus_property(self):

853

def name_dbus_property(self):

993

854

return dbus.String(self.name)

994

855

995

# Fingerprint - property

856

# fingerprint - property

996

857

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

997

def Fingerprint_dbus_property(self):

858

def fingerprint_dbus_property(self):

998

859

return dbus.String(self.fingerprint)

999

860

1000

# Host - property

861

# host - property

1001

862

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

1002

863

access=u"readwrite")

1003

def Host_dbus_property(self, value=None):

864

def host_dbus_property(self, value=None):

1004

865

if value is None: # get

1005

866

return dbus.String(self.host)

1006

867

self.host = value

1007

868

# Emit D-Bus signal

1008

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

869

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

1009

870

dbus.String(value, variant_level=1))

1010

871

1011

# Created - property

872

# created - property

1012

873

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

1013

def Created_dbus_property(self):

874

def created_dbus_property(self):

1014

875

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

1015

876

1016

# LastEnabled - property

877

# last_enabled - property

1017

878

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

1018

def LastEnabled_dbus_property(self):

879

def last_enabled_dbus_property(self):

1019

880

if self.last_enabled is None:

1020

881

return dbus.String(u"")

1021

882

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

1022

883

1023

# Enabled - property

884

# enabled - property

1024

885

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

1025

886

access=u"readwrite")

1026

def Enabled_dbus_property(self, value=None):

887

def enabled_dbus_property(self, value=None):

1027

888

if value is None: # get

1028

889

return dbus.Boolean(self.enabled)

1029

890

if value:

1031

892

else:

1032

893

self.disable()

1033

894

1034

# LastCheckedOK - property

895

# last_checked_ok - property

1035

896

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

1036

897

access=u"readwrite")

1037

def LastCheckedOK_dbus_property(self, value=None):

898

def last_checked_ok_dbus_property(self, value=None):

1038

899

if value is not None:

1039

900

self.checked_ok()

1040

901

return

1043

904

return dbus.String(self._datetime_to_dbus(self

1044

905

.last_checked_ok))

1045

906

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

907

# timeout - property

1056

908

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

1057

909

access=u"readwrite")

1058

def Timeout_dbus_property(self, value=None):

910

def timeout_dbus_property(self, value=None):

1059

911

if value is None: # get

1060

912

return dbus.UInt64(self.timeout_milliseconds())

1061

913

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

1062

914

# Emit D-Bus signal

1063

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

915

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

1064

916

dbus.UInt64(value, variant_level=1))

1065

917

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

1066

918

return

1080

932

self.disable_initiator_tag = (gobject.timeout_add

1081

933

(time_to_die, self.disable))

1082

934

1083

# Interval - property

935

# interval - property

1084

936

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

1085

937

access=u"readwrite")

1086

def Interval_dbus_property(self, value=None):

938

def interval_dbus_property(self, value=None):

1087

939

if value is None: # get

1088

940

return dbus.UInt64(self.interval_milliseconds())

1089

941

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

1090

942

# Emit D-Bus signal

1091

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

943

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

1092

944

dbus.UInt64(value, variant_level=1))

1093

945

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

1094

946

return

1098

950

(value, self.start_checker))

1099

951

self.start_checker() # Start one now, too

1100

952

1101

# Checker - property

953

# checker - property

1102

954

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

1103

955

access=u"readwrite")

1104

def Checker_dbus_property(self, value=None):

956

def checker_dbus_property(self, value=None):

1105

957

if value is None: # get

1106

958

return dbus.String(self.checker_command)

1107

959

self.checker_command = value

1108

960

# Emit D-Bus signal

1109

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

961

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

1110

962

dbus.String(self.checker_command,

1111

963

variant_level=1))

1112

964

1113

# CheckerRunning - property

965

# checker_running - property

1114

966

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

1115

967

access=u"readwrite")

1116

def CheckerRunning_dbus_property(self, value=None):

968

def checker_running_dbus_property(self, value=None):

1117

969

if value is None: # get

1118

970

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

1119

971

if value:

1121

973

else:

1122

974

self.stop_checker()

1123

975

1124

# ObjectPath - property

976

# object_path - property

1125

977

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

1126

def ObjectPath_dbus_property(self):

978

def object_path_dbus_property(self):

1127

979

return self.dbus_object_path # is already a dbus.ObjectPath

1128

980

1129

# Secret = property

981

# secret = property

1130

982

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

1131

983

access=u"write", byte_arrays=True)

1132

def Secret_dbus_property(self, value):

984

def secret_dbus_property(self, value):

1133

985

self.secret = str(value)

1134

986

1135

987

del _interface

1136

988

1137

989

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

1164

990

class ClientHandler(socketserver.BaseRequestHandler, object):

1165

991

"""A class to handle client connections.

1166

992

1168

994

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

1169

995

1170

996

def handle(self):

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

997

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

998

unicode(self.client_address))

999

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

1000

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

1001

# Open IPC pipe to parent process

1002

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

1003

self.server.parent_pipe[0]

1004

) as (ipc, ipc_return):

1177

1005

session = (gnutls.connection

1178

1006

.ClientSession(self.request,

1179

1007

gnutls.connection

1180

1008

.X509Credentials()))

1181

1009

1182

1010

# Note: gnutls.connection.X509Credentials is really a

1183

1011

# generic GnuTLS certificate credentials object so long as

1184

1012

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

1185

1013

# here despite using OpenPGP certificates.

1186

1014

1187

1015

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

1188

1016

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

1189

1017

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

1195

1023

(gnutls.library.functions

1196

1024

.gnutls_priority_set_direct(session._c_object,

1197

1025

priority, None))

1198

1026

1199

1027

# Start communication using the Mandos protocol

1200

1028

# Get protocol number

1201

1029

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

1206

1034

except (ValueError, IndexError, RuntimeError), error:

1207

1035

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

1208

1036

return

1209

1037

1210

1038

# Start GnuTLS connection

1211

1039

try:

1212

1040

session.handshake()

1216

1044

# established. Just abandon the request.

1217

1045

return

1218

1046

logger.debug(u"Handshake succeeded")

1219

1220

approval_required = False

1221

1047

try:

1222

1048

try:

1223

1049

fpr = self.fingerprint(self.peer_certificate

1227

1053

return

1228

1054

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

1229

1055

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

1056

for c in self.server.clients:

1057

if c.fingerprint == fpr:

1058

client = c

1252

1059

break

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

1060

else:

1061

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

1062

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

1063

return

1064

1065

class ClientProxy(object):

1066

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

1067

def __init__(self, client):

1068

self.client = client

1069

def __getattr__(self, name):

1070

if name.startswith("ipc_"):

1071

def tempfunc():

1072

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

1073

self.client.name))

1074

return tempfunc

1075

if not hasattr(self.client, name):

1076

raise AttributeError

1077

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

1078

% (name, self.client.fingerprint))

1079

return pickle.load(ipc_return)

1080

clientproxy = ClientProxy(client)

1081

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

1082

# possible that the client was disabled since the

1083

# GnuTLS session was established.

1084

if not clientproxy.enabled:

1085

clientproxy.ipc_disabled()

1086

return

1087

1088

clientproxy.ipc_sending()

1290

1089

sent_size = 0

1291

1090

while sent_size < len(client.secret):

1292

try:

1293

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

1294

except (gnutls.errors.GNUTLSError), error:

1295

logger.warning("gnutls send failed")

1296

return

1091

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

1297

1092

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

1298

1093

sent, len(client.secret)

1299

1094

- (sent_size + sent))

1300

1095

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

1309

1096

finally:

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

1097

session.bye()

1316

1098

1317

1099

@staticmethod

1318

1100

def peer_certificate(session):

1378

1160

return hex_fpr

1379

1161

1380

1162

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

1163

class ForkingMixInWithPipes(socketserver.ForkingMixIn, object):

1164

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

1397

1165

def process_request(self, request, client_address):

1398

1166

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

1399

1167

1400

1168

This function creates a new pipe in self.pipe

1401

1169

"""

1402

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1403

1404

super(MultiprocessingMixInWithPipe,

1170

# Child writes to child_pipe

1171

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

1172

# Parent writes to parent_pipe

1173

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

1174

super(ForkingMixInWithPipes,

1405

1175

self).process_request(request, client_address)

1406

self.child_pipe.close()

1407

self.add_pipe(parent_pipe)

1408

1409

def add_pipe(self, parent_pipe):

1176

# Close unused ends for parent

1177

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

1178

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

1179

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

1180

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1410

1181

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

1411

pass

1412

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1182

child_pipe_fd.close()

1183

parent_pipe_fd.close()

1184

1185

1186

class IPv6_TCPServer(ForkingMixInWithPipes,

1414

1187

socketserver.TCPServer, object):

1415

1188

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

1416

1189

1501

1274

return socketserver.TCPServer.server_activate(self)

1502

1275

def enable(self):

1503

1276

self.enabled = True

1504

def add_pipe(self, parent_pipe):

1277

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1505

1278

# Call "handle_ipc" for both data and EOF events

1506

gobject.io_add_watch(parent_pipe.fileno(),

1279

gobject.io_add_watch(child_pipe_fd.fileno(),

1507

1280

gobject.IO_IN | gobject.IO_HUP,

1508

1281

functools.partial(self.handle_ipc,

1509

parent_pipe = parent_pipe))

1510

1511

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

1512

client_object=None):

1282

reply = parent_pipe_fd,

1283

sender= child_pipe_fd))

1284

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

1513

1285

condition_names = {

1514

1286

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

1515

1287

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

1524

1296

for cond, name in

1525

1297

condition_names.iteritems()

1526

1298

if cond & condition)

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

1299

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

1300

conditions_string)

1301

1302

# Read a line from the file object

1303

cmdline = sender.readline()

1304

if not cmdline: # Empty line means end of file

1305

# close the IPC pipes

1306

sender.close()

1307

reply.close()

1308

1309

# Stop calling this function

1310

return False

1311

1312

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

1313

1314

# Parse and act on command

1315

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

1316

1317

if cmd == u"NOTFOUND":

1318

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

1319

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

1320

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

1321

if self.use_dbus:

1322

# Emit D-Bus signal

1323

mandos_dbus_service.ClientNotFound(fpr, address)

1324

elif cmd == u"DISABLED":

1325

for client in self.clients:

1326

if client.name == args:

1327

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

1328

if self.use_dbus:

1329

# Emit D-Bus signal

1330

client.Rejected()

1331

break

1332

else:

1333

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

1334

elif cmd == u"SENDING":

1335

for client in self.clients:

1336

if client.name == args:

1337

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

1338

client.checked_ok()

1339

if self.use_dbus:

1340

# Emit D-Bus signal

1341

client.GotSecret()

1342

break

1343

else:

1344

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

1345

args)

1346

elif cmd == u"GETATTR":

1347

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

1348

for client in self.clients:

1349

if client.fingerprint == fpr:

1350

attr_value = getattr(client, attr_name, None)

1351

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

1352

pickle.dump(attr_value, reply)

1353

break

1354

else:

1355

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

1356

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

1357

attr_name)

1358

pickle.dump(None, reply)

1359

else:

1360

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

1361

1362

# Keep calling this function

1579

1363

return True

1580

1364

1581

1365

1684

1468

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

1685

1469

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

1686

1470

u" terminal")

1687

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

1688

help=u"Debug level for stdout output")

1689

1471

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

1690

1472

u" priority string (see GnuTLS documentation)")

1691

1473

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

1716

1498

u"servicename": u"Mandos",

1717

1499

u"use_dbus": u"True",

1718

1500

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1720

1501

}

1721

1502

1722

1503

# Parse config file for server-global settings

1739

1520

# options, if set.

1740

1521

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

1741

1522

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

1742

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

1523

u"use_dbus", u"use_ipv6"):

1743

1524

value = getattr(options, option)

1744

1525

if value is not None:

1745

1526

server_settings[option] = value

1754

1535

1755

1536

# For convenience

1756

1537

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1758

1538

use_dbus = server_settings[u"use_dbus"]

1759

1539

use_ipv6 = server_settings[u"use_ipv6"]

1760

1540

1541

if not debug:

1542

syslogger.setLevel(logging.WARNING)

1543

console.setLevel(logging.WARNING)

1544

1761

1545

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

1762

1546

syslogger.setFormatter(logging.Formatter

1763

1547

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

1769

1553

u"interval": u"5m",

1770

1554

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

1771

1555

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1774

1556

}

1775

1557

client_config = configparser.SafeConfigParser(client_defaults)

1776

1558

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

1782

1564

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

1783

1565

server_settings[u"port"]),

1784

1566

ClientHandler,

1785

interface=(server_settings[u"interface"]

1786

or None),

1567

interface=server_settings[u"interface"],

1787

1568

use_ipv6=use_ipv6,

1788

1569

gnutls_priority=

1789

1570

server_settings[u"priority"],

1790

1571

use_dbus=use_dbus)

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)

1572

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

1573

try:

1574

pidfile = open(pidfilename, u"w")

1575

except IOError:

1576

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

1797

1577

1798

1578

try:

1799

1579

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

1816

1596

if error[0] != errno.EPERM:

1817

1597

raise error

1818

1598

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

1599

# Enable all possible GnuTLS debugging

1827

1600

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1830

1601

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

1831

1602

# - GnuTLS manual

1832

1603

gnutls.library.functions.gnutls_global_set_log_level(11)

1837

1608

1838

1609

(gnutls.library.functions

1839

1610

.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

1850

1611

1851

1612

global main_loop

1852

1613

# From the Avahi example code

1870

1631

if server_settings["interface"]:

1871

1632

service.interface = (if_nametoindex

1872

1633

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

1880

1634

1881

1635

client_class = Client

1882

1636

if use_dbus:

1883

1637

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

1896

1638

tcp_server.clients.update(set(

1897

1639

client_class(name = section,

1898

config= dict(client_config_items(

1899

client_config, section)))

1640

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

1900

1641

for section in client_config.sections()))

1901

1642

if not tcp_server.clients:

1902

1643

logger.warning(u"No clients defined")

1903

1644

1645

if debug:

1646

# Redirect stdin so all checkers get /dev/null

1647

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

1648

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

1649

if null > 2:

1650

os.close(null)

1651

else:

1652

# No console logging

1653

logger.removeHandler(console)

1654

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

1655

daemon()

1656

1657

try:

1658

with pidfile:

1659

pid = os.getpid()

1660

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

1661

del pidfile

1662

except IOError:

1663

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

1664

pidfilename, pid)

1665

except NameError:

1666

# "pidfile" was never created

1667

pass

1668

del pidfilename

1669

1904

1670

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

1918

1671

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

1919

1920

1672

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

1921

1673

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

1922

1674