/mandos/trunk : revision 416.1.2

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

83

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.

253

checker_initiator_tag: a gobject event source tag, or None

254

disable_initiator_tag: - '' -

249

255

checker_callback_tag: - '' -

250

checker_command: string; External command which is run to check

251

if client lives. %() expansions are done at

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

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

261

"""

273

262

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

263

@staticmethod

280

264

def _timedelta_to_milliseconds(td):

281

265

"Convert a datetime.timedelta() to milliseconds"

290

274

def interval_milliseconds(self):

291

275

"Return the 'interval' attribute in milliseconds"

292

276

return self._timedelta_to_milliseconds(self.interval)

293

294

def approval_delay_milliseconds(self):

295

return self._timedelta_to_milliseconds(self.approval_delay)

296

277

297

278

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

298

279

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

333

314

self.checker_command = config[u"checker"]

334

315

self.current_checker_command = None

335

316

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

317

346

def send_changedstate(self):

347

self.changedstate.acquire()

348

self.changedstate.notify_all()

349

self.changedstate.release()

350

351

318

def enable(self):

352

319

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

353

320

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

354

321

# Already enabled

355

322

return

356

self.send_changedstate()

357

323

self.last_enabled = datetime.datetime.utcnow()

358

324

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

359

325

# and every interval from then on.

373

339

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

374

340

return False

375

341

if not quiet:

376

self.send_changedstate()

377

if not quiet:

378

342

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

379

343

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

380

344

gobject.source_remove(self.disable_initiator_tag)

456

420

command = self.checker_command % self.host

457

421

except TypeError:

458

422

# 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

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

467

429

try:

468

430

command = self.checker_command % escaped_attrs

469

431

except TypeError, error:

515

477

raise

516

478

self.checker = None

517

479

480

518

481

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

519

482

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

520

483

"""Decorators for marking methods of a DBusObjectWithProperties to

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

783

856

784

## D-Bus methods, signals & properties

857

785

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

879

807

# GotSecret - signal

880

808

@dbus.service.signal(_interface)

881

809

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

"""

810

"D-Bus signal"

886

811

pass

887

812

888

813

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

814

@dbus.service.signal(_interface)

815

def Rejected(self):

897

816

"D-Bus signal"

898

817

pass

899

818

900

819

## Methods

901

902

# Approve - method

903

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

904

def Approve(self, value):

905

self.approve(value)

906

820

907

821

# CheckedOK - method

908

822

@dbus.service.method(_interface)

909

823

def CheckedOK(self):

934

848

935

849

## Properties

936

850

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

851

# name - property

977

852

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

978

def Name_dbus_property(self):

853

def name_dbus_property(self):

979

854

return dbus.String(self.name)

980

855

981

# Fingerprint - property

856

# fingerprint - property

982

857

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

983

def Fingerprint_dbus_property(self):

858

def fingerprint_dbus_property(self):

984

859

return dbus.String(self.fingerprint)

985

860

986

# Host - property

861

# host - property

987

862

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

988

863

access=u"readwrite")

989

def Host_dbus_property(self, value=None):

864

def host_dbus_property(self, value=None):

990

865

if value is None: # get

991

866

return dbus.String(self.host)

992

867

self.host = value

993

868

# Emit D-Bus signal

994

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

869

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

995

870

dbus.String(value, variant_level=1))

996

871

997

# Created - property

872

# created - property

998

873

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

999

def Created_dbus_property(self):

874

def created_dbus_property(self):

1000

875

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

1001

876

1002

# LastEnabled - property

877

# last_enabled - property

1003

878

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

1004

def LastEnabled_dbus_property(self):

879

def last_enabled_dbus_property(self):

1005

880

if self.last_enabled is None:

1006

881

return dbus.String(u"")

1007

882

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

1008

883

1009

# Enabled - property

884

# enabled - property

1010

885

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

1011

886

access=u"readwrite")

1012

def Enabled_dbus_property(self, value=None):

887

def enabled_dbus_property(self, value=None):

1013

888

if value is None: # get

1014

889

return dbus.Boolean(self.enabled)

1015

890

if value:

1017

892

else:

1018

893

self.disable()

1019

894

1020

# LastCheckedOK - property

895

# last_checked_ok - property

1021

896

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

1022

897

access=u"readwrite")

1023

def LastCheckedOK_dbus_property(self, value=None):

898

def last_checked_ok_dbus_property(self, value=None):

1024

899

if value is not None:

1025

900

self.checked_ok()

1026

901

return

1029

904

return dbus.String(self._datetime_to_dbus(self

1030

905

.last_checked_ok))

1031

906

1032

# Timeout - property

907

# timeout - property

1033

908

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

1034

909

access=u"readwrite")

1035

def Timeout_dbus_property(self, value=None):

910

def timeout_dbus_property(self, value=None):

1036

911

if value is None: # get

1037

912

return dbus.UInt64(self.timeout_milliseconds())

1038

913

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

1039

914

# Emit D-Bus signal

1040

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

915

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

1041

916

dbus.UInt64(value, variant_level=1))

1042

917

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

1043

918

return

1057

932

self.disable_initiator_tag = (gobject.timeout_add

1058

933

(time_to_die, self.disable))

1059

934

1060

# Interval - property

935

# interval - property

1061

936

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

1062

937

access=u"readwrite")

1063

def Interval_dbus_property(self, value=None):

938

def interval_dbus_property(self, value=None):

1064

939

if value is None: # get

1065

940

return dbus.UInt64(self.interval_milliseconds())

1066

941

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

1067

942

# Emit D-Bus signal

1068

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

943

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

1069

944

dbus.UInt64(value, variant_level=1))

1070

945

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

1071

946

return

1075

950

(value, self.start_checker))

1076

951

self.start_checker() # Start one now, too

1077

952

1078

# Checker - property

953

# checker - property

1079

954

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

1080

955

access=u"readwrite")

1081

def Checker_dbus_property(self, value=None):

956

def checker_dbus_property(self, value=None):

1082

957

if value is None: # get

1083

958

return dbus.String(self.checker_command)

1084

959

self.checker_command = value

1085

960

# Emit D-Bus signal

1086

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

961

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

1087

962

dbus.String(self.checker_command,

1088

963

variant_level=1))

1089

964

1090

# CheckerRunning - property

965

# checker_running - property

1091

966

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

1092

967

access=u"readwrite")

1093

def CheckerRunning_dbus_property(self, value=None):

968

def checker_running_dbus_property(self, value=None):

1094

969

if value is None: # get

1095

970

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

1096

971

if value:

1098

973

else:

1099

974

self.stop_checker()

1100

975

1101

# ObjectPath - property

976

# object_path - property

1102

977

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

1103

def ObjectPath_dbus_property(self):

978

def object_path_dbus_property(self):

1104

979

return self.dbus_object_path # is already a dbus.ObjectPath

1105

980

1106

# Secret = property

981

# secret = property

1107

982

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

1108

983

access=u"write", byte_arrays=True)

1109

def Secret_dbus_property(self, value):

984

def secret_dbus_property(self, value):

1110

985

self.secret = str(value)

1111

986

1112

987

del _interface

1113

988

1114

989

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

990

class ClientHandler(socketserver.BaseRequestHandler, object):

1142

991

"""A class to handle client connections.

1143

992

1145

994

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

1146

995

1147

996

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

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

1154

1005

session = (gnutls.connection

1155

1006

.ClientSession(self.request,

1156

1007

gnutls.connection

1157

1008

.X509Credentials()))

1158

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

1026

1176

1027

# Start communication using the Mandos protocol

1177

1028

# Get protocol number

1178

1029

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

1183

1034

except (ValueError, IndexError, RuntimeError), error:

1184

1035

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

1185

1036

return

1186

1037

1187

1038

# Start GnuTLS connection

1188

1039

try:

1189

1040

session.handshake()

1193

1044

# established. Just abandon the request.

1194

1045

return

1195

1046

logger.debug(u"Handshake succeeded")

1196

1197

approval_required = False

1198

1047

try:

1199

1048

try:

1200

1049

fpr = self.fingerprint(self.peer_certificate

1204

1053

return

1205

1054

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

1206

1055

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

1056

for c in self.server.clients:

1057

if c.fingerprint == fpr:

1058

client = c

1229

1059

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

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

1267

1089

sent_size = 0

1268

1090

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

1091

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

1274

1092

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

1275

1093

sent, len(client.secret)

1276

1094

- (sent_size + sent))

1277

1095

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

1285

1286

1096

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

1097

session.bye()

1293

1098

1294

1099

@staticmethod

1295

1100

def peer_certificate(session):

1355

1160

return hex_fpr

1356

1161

1357

1162

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

1163

class ForkingMixInWithPipes(socketserver.ForkingMixIn, object):

1164

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

1374

1165

def process_request(self, request, client_address):

1375

1166

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

1376

1167

1377

1168

This function creates a new pipe in self.pipe

1378

1169

"""

1379

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1380

1381

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,

1382

1175

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

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

1387

1181

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

1388

pass

1389

1390

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1182

child_pipe_fd.close()

1183

parent_pipe_fd.close()

1184

1185

1186

class IPv6_TCPServer(ForkingMixInWithPipes,

1391

1187

socketserver.TCPServer, object):

1392

1188

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

1393

1189

1478

1274

return socketserver.TCPServer.server_activate(self)

1479

1275

def enable(self):

1480

1276

self.enabled = True

1481

def add_pipe(self, parent_pipe):

1277

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1482

1278

# Call "handle_ipc" for both data and EOF events

1483

gobject.io_add_watch(parent_pipe.fileno(),

1279

gobject.io_add_watch(child_pipe_fd.fileno(),

1484

1280

gobject.IO_IN | gobject.IO_HUP,

1485

1281

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

1282

reply = parent_pipe_fd,

1283

sender= child_pipe_fd))

1284

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

1490

1285

condition_names = {

1491

1286

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

1492

1287

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

1501

1296

for cond, name in

1502

1297

condition_names.iteritems()

1503

1298

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

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

1556

1363

return True

1557

1364

1558

1365

1661

1468

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

1662

1469

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

1663

1470

u" terminal")

1664

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

1665

help=u"Debug level for stdout output")

1666

1471

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

1667

1472

u" priority string (see GnuTLS documentation)")

1668

1473

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

1693

1498

u"servicename": u"Mandos",

1694

1499

u"use_dbus": u"True",

1695

1500

u"use_ipv6": u"True",

1696

u"debuglevel": u"",

1697

1501

}

1698

1502

1699

1503

# Parse config file for server-global settings

1716

1520

# options, if set.

1717

1521

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

1718

1522

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

1719

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

1523

u"use_dbus", u"use_ipv6"):

1720

1524

value = getattr(options, option)

1721

1525

if value is not None:

1722

1526

server_settings[option] = value

1731

1535

1732

1536

# For convenience

1733

1537

debug = server_settings[u"debug"]

1734

debuglevel = server_settings[u"debuglevel"]

1735

1538

use_dbus = server_settings[u"use_dbus"]

1736

1539

use_ipv6 = server_settings[u"use_ipv6"]

1737

1540

1541

if not debug:

1542

syslogger.setLevel(logging.WARNING)

1543

console.setLevel(logging.WARNING)

1544

1738

1545

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

1739

1546

syslogger.setFormatter(logging.Formatter

1740

1547

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

1746

1553

u"interval": u"5m",

1747

1554

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

1748

1555

u"host": u"",

1749

u"approval_delay": u"0s",

1750

u"approval_duration": u"1s",

1751

1556

}

1752

1557

client_config = configparser.SafeConfigParser(client_defaults)

1753

1558

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

1759

1564

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

1760

1565

server_settings[u"port"]),

1761

1566

ClientHandler,

1762

interface=(server_settings[u"interface"]

1763

or None),

1567

interface=server_settings[u"interface"],

1764

1568

use_ipv6=use_ipv6,

1765

1569

gnutls_priority=

1766

1570

server_settings[u"priority"],

1767

1571

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)

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)

1774

1577

1775

1578

try:

1776

1579

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

1793

1596

if error[0] != errno.EPERM:

1794

1597

raise error

1795

1598

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

1599

# Enable all possible GnuTLS debugging

1804

1600

if debug:

1805

# Enable all possible GnuTLS debugging

1806

1807

1601

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

1808

1602

# - GnuTLS manual

1809

1603

gnutls.library.functions.gnutls_global_set_log_level(11)

1814

1608

1815

1609

(gnutls.library.functions

1816

1610

.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

1611

1828

1612

global main_loop

1829

1613

# From the Avahi example code

1847

1631

if server_settings["interface"]:

1848

1632

service.interface = (if_nametoindex

1849

1633

(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

1634

1858

1635

client_class = Client

1859

1636

if use_dbus:

1860

1637

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

1638

tcp_server.clients.update(set(

1874

1639

client_class(name = section,

1875

config= dict(client_config_items(

1876

client_config, section)))

1640

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

1877

1641

for section in client_config.sections()))

1878

1642

if not tcp_server.clients:

1879

1643

logger.warning(u"No clients defined")

1880

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

1881

1670

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

1671

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

1896

1897

1672

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

1898

1673

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

1899

1674