/mandos/trunk : revision 24.1.159

55

import logging

56

import logging.handlers

57

import pwd

58

from contextlib import closing

58

import contextlib

59

import struct

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

62

64

63

65

import dbus

64

66

import dbus.service

79

81

SO_BINDTODEVICE = None

80

82

81

83

82

version = "1.0.12"

84

version = "1.0.14"

83

85

86

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

84

87

logger = logging.Logger(u'mandos')

85

88

syslogger = (logging.handlers.SysLogHandler

86

89

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

154

157

u" after %i retries, exiting.",

155

158

self.rename_count)

156

159

raise AvahiServiceError(u"Too many renames")

157

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

160

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

158

161

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

159

unicode(self.name))

162

self.name)

160

163

syslogger.setFormatter(logging.Formatter

161

164

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

162

165

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

191

194

self.group.Commit()

192

195

def entry_group_state_changed(self, state, error):

193

196

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

194

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

197

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

195

198

196

199

if state == avahi.ENTRY_GROUP_ESTABLISHED:

197

200

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

210

213

self.group = None

211

214

def server_state_changed(self, state):

212

215

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

216

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

213

217

if state == avahi.SERVER_COLLISION:

214

218

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

215

219

self.remove()

242

246

enabled: bool()

243

247

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

244

248

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

245

until this client is invalid

249

until this client is disabled

246

250

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

247

251

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

248

252

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

256

260

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

257

261

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

258

262

current_checker_command: string; current running checker_command

263

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

264

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

265

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

259

266

"""

260

267

261

268

@staticmethod

272

279

def interval_milliseconds(self):

273

280

"Return the 'interval' attribute in milliseconds"

274

281

return self._timedelta_to_milliseconds(self.interval)

282

283

def approved_delay_milliseconds(self):

284

return self._timedelta_to_milliseconds(self.approved_delay)

275

285

276

286

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

277

287

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

290

300

if u"secret" in config:

291

301

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

292

302

elif u"secfile" in config:

293

with closing(open(os.path.expanduser

294

(os.path.expandvars

295

(config[u"secfile"])),

296

"rb")) as secfile:

303

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

304

(config[u"secfile"])),

305

"rb") as secfile:

297

306

self.secret = secfile.read()

298

307

else:

299

308

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

313

322

self.checker_command = config[u"checker"]

314

323

self.current_checker_command = None

315

324

self.last_connect = None

325

self._approved = None

326

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

327

True)

328

self.approvals_pending = 0

329

self.approved_delay = string_to_delta(

330

config[u"approved_delay"])

331

self.approved_duration = string_to_delta(

332

config[u"approved_duration"])

333

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

316

334

335

def send_changedstate(self):

336

self.changedstate.acquire()

337

self.changedstate.notify_all()

338

self.changedstate.release()

339

317

340

def enable(self):

318

341

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

319

342

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

320

343

# Already enabled

321

344

return

345

self.send_changedstate()

322

346

self.last_enabled = datetime.datetime.utcnow()

323

347

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

324

348

# and every interval from then on.

325

349

self.checker_initiator_tag = (gobject.timeout_add

326

350

(self.interval_milliseconds(),

327

351

self.start_checker))

328

# Also start a new checker *right now*.

329

self.start_checker()

330

352

# Schedule a disable() when 'timeout' has passed

331

353

self.disable_initiator_tag = (gobject.timeout_add

332

354

(self.timeout_milliseconds(),

333

355

self.disable))

334

356

self.enabled = True

357

# Also start a new checker *right now*.

358

self.start_checker()

335

359

336

def disable(self):

360

def disable(self, quiet=True):

337

361

"""Disable this client."""

338

362

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

339

363

return False

340

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

364

if not quiet:

365

self.send_changedstate()

366

if not quiet:

367

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

341

368

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

342

369

gobject.source_remove(self.disable_initiator_tag)

343

370

self.disable_initiator_tag = None

395

422

# client would inevitably timeout, since no checker would get

396

423

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

397

424

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

398

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

399

# is as it should be.

425

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

426

# should be.

400

427

401

428

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

402

429

try:

467

494

logger.debug(u"Stopping checker for %(name)s", vars(self))

468

495

try:

469

496

os.kill(self.checker.pid, signal.SIGTERM)

470

#os.sleep(0.5)

497

#time.sleep(0.5)

471

498

#if self.checker.poll() is None:

472

499

# os.kill(self.checker.pid, signal.SIGKILL)

473

500

except OSError, error:

474

501

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

475

502

raise

476

503

self.checker = None

477

478

def still_valid(self):

479

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

480

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

481

return False

482

now = datetime.datetime.utcnow()

483

if self.last_checked_ok is None:

484

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

485

else:

486

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

487

488

504

489

505

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

490

506

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

498

514

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

499

515

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

500

516

"""

517

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

518

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

519

if byte_arrays and signature != u"ay":

520

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

521

u" signature %r" % signature)

501

522

def decorator(func):

502

523

func._dbus_is_property = True

503

524

func._dbus_interface = dbus_interface

589

610

if prop._dbus_access == u"read":

590

611

raise DBusPropertyAccessException(property_name)

591

612

if prop._dbus_get_args_options[u"byte_arrays"]:

613

# The byte_arrays option is not supported yet on

614

# signatures other than "ay".

615

if prop._dbus_signature != u"ay":

616

raise ValueError

592

617

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

593

618

for byte in value))

594

619

prop(value)

676

701

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

677

702

678

703

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

704

self._approvals_pending = 0

679

705

self.bus = bus

680

706

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

681

707

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

685

711

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

686

712

DBusObjectWithProperties.__init__(self, self.bus,

687

713

self.dbus_object_path)

714

715

def _get_approvals_pending(self):

716

return self._approvals_pending

717

def _set_approvals_pending(self, value):

718

old_value = self._approvals_pending

719

self._approvals_pending = value

720

bval = bool(value)

721

if (hasattr(self, "dbus_object_path")

722

and bval is not bool(old_value)):

723

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

724

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

725

dbus_bool)

726

727

approvals_pending = property(_get_approvals_pending,

728

_set_approvals_pending)

729

del _get_approvals_pending, _set_approvals_pending

688

730

689

731

@staticmethod

690

732

def _datetime_to_dbus(dt, variant_level=0):

705

747

variant_level=1))

706

748

return r

707

749

708

def disable(self, signal = True):

750

def disable(self, quiet = False):

709

751

oldstate = getattr(self, u"enabled", False)

710

r = Client.disable(self)

711

if signal and oldstate != self.enabled:

752

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

753

if not quiet and oldstate != self.enabled:

712

754

# Emit D-Bus signal

713

755

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

714

756

dbus.Boolean(False, variant_level=1))

779

821

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

780

822

dbus.Boolean(False, variant_level=1))

781

823

return r

782

783

## D-Bus methods & signals

824

825

def _reset_approved(self):

826

self._approved = None

827

return False

828

829

def approve(self, value=True):

830

self.send_changedstate()

831

self._approved = value

832

gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration),

833

self._reset_approved)

834

835

836

## D-Bus methods, signals & properties

784

837

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

785

838

786

# CheckedOK - method

787

@dbus.service.method(_interface)

788

def CheckedOK(self):

789

return self.checked_ok()

839

## Signals

790

840

791

841

# CheckerCompleted - signal

792

842

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

809

859

# GotSecret - signal

810

860

@dbus.service.signal(_interface)

811

861

def GotSecret(self):

812

"D-Bus signal"

862

"""D-Bus signal

863

Is sent after a successful transfer of secret from the Mandos

864

server to mandos-client

865

"""

813

866

pass

814

867

815

868

# Rejected - signal

816

@dbus.service.signal(_interface)

817

def Rejected(self):

818

"D-Bus signal"

819

pass

869

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

870

def Rejected(self, reason):

871

"D-Bus signal"

872

pass

873

874

# NeedApproval - signal

875

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

876

def NeedApproval(self, timeout, default):

877

"D-Bus signal"

878

pass

879

880

## Methods

881

882

# Approve - method

883

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

884

def Approve(self, value):

885

self.approve(value)

886

887

# CheckedOK - method

888

@dbus.service.method(_interface)

889

def CheckedOK(self):

890

return self.checked_ok()

820

891

821

892

# Enable - method

822

893

@dbus.service.method(_interface)

841

912

def StopChecker(self):

842

913

self.stop_checker()

843

914

915

## Properties

916

917

# approved_pending - property

918

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

919

def approved_pending_dbus_property(self):

920

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

921

922

# approved_by_default - property

923

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

924

access=u"readwrite")

925

def approved_by_default_dbus_property(self):

926

return dbus.Boolean(self.approved_by_default)

927

928

# approved_delay - property

929

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

930

access=u"readwrite")

931

def approved_delay_dbus_property(self):

932

return dbus.UInt64(self.approved_delay_milliseconds())

933

934

# approved_duration - property

935

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

936

access=u"readwrite")

937

def approved_duration_dbus_property(self):

938

return dbus.UInt64(self._timedelta_to_milliseconds(

939

self.approved_duration))

940

844

941

# name - property

845

942

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

846

943

def name_dbus_property(self):

980

1077

del _interface

981

1078

982

1079

1080

class ProxyClient(object):

1081

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

1082

self._pipe = child_pipe

1083

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

1084

if not self._pipe.recv():

1085

raise KeyError()

1086

1087

def __getattribute__(self, name):

1088

if(name == '_pipe'):

1089

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

1090

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

1091

data = self._pipe.recv()

1092

if data[0] == 'data':

1093

return data[1]

1094

if data[0] == 'function':

1095

def func(*args, **kwargs):

1096

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

1097

return self._pipe.recv()[1]

1098

return func

1099

1100

def __setattr__(self, name, value):

1101

if(name == '_pipe'):

1102

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

1103

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

1104

1105

983

1106

class ClientHandler(socketserver.BaseRequestHandler, object):

984

1107

"""A class to handle client connections.

985

1108

987

1110

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

988

1111

989

1112

def handle(self):

990

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

991

unicode(self.client_address))

992

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

993

# Open IPC pipe to parent process

994

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

1113

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

1114

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

1115

unicode(self.client_address))

1116

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

1117

self.server.child_pipe.fileno())

1118

995

1119

session = (gnutls.connection

996

1120

.ClientSession(self.request,

997

1121

gnutls.connection

998

1122

.X509Credentials()))

999

1000

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

1001

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

1002

try:

1003

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

1004

raise RuntimeError

1005

except (ValueError, IndexError, RuntimeError), error:

1006

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

1007

return

1008

1123

1009

1124

# Note: gnutls.connection.X509Credentials is really a

1010

1125

# generic GnuTLS certificate credentials object so long as

1011

1126

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

1012

1127

# here despite using OpenPGP certificates.

1013

1128

1014

1129

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

1015

1130

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

1016

1131

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

1022

1137

(gnutls.library.functions

1023

1138

.gnutls_priority_set_direct(session._c_object,

1024

1139

priority, None))

1025

1140

1141

# Start communication using the Mandos protocol

1142

# Get protocol number

1143

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

1144

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

1145

try:

1146

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

1147

raise RuntimeError

1148

except (ValueError, IndexError, RuntimeError), error:

1149

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

1150

return

1151

1152

# Start GnuTLS connection

1026

1153

try:

1027

1154

session.handshake()

1028

1155

except gnutls.errors.GNUTLSError, error:

1031

1158

# established. Just abandon the request.

1032

1159

return

1033

1160

logger.debug(u"Handshake succeeded")

1161

1162

approval_required = False

1034

1163

try:

1035

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

1036

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

1037

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

1038

session.bye()

1039

return

1040

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

1164

try:

1165

fpr = self.fingerprint(self.peer_certificate

1166

(session))

1167

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

1168

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

1169

return

1170

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

1171

1172

try:

1173

client = ProxyClient(child_pipe, fpr,

1174

self.client_address)

1175

except KeyError:

1176

return

1177

1178

if client.approved_delay:

1179

delay = client.approved_delay

1180

client.approvals_pending += 1

1181

approval_required = True

1182

1183

while True:

1184

if not client.enabled:

1185

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

1186

client.name)

1187

if self.server.use_dbus:

1188

# Emit D-Bus signal

1189

client.Rejected("Disabled")

1190

return

1191

1192

if client._approved or not client.approved_delay:

1193

#We are approved or approval is disabled

1194

break

1195

elif client._approved is None:

1196

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

1197

client.name)

1198

if self.server.use_dbus:

1199

# Emit D-Bus signal

1200

client.NeedApproval(

1201

client.approved_delay_milliseconds(),

1202

client.approved_by_default)

1203

else:

1204

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

1205

client.name)

1206

if self.server.use_dbus:

1207

# Emit D-Bus signal

1208

client.Rejected("Disapproved")

1209

return

1210

1211

#wait until timeout or approved

1212

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

1213

time = datetime.datetime.now()

1214

client.changedstate.acquire()

1215

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

1216

client.changedstate.release()

1217

time2 = datetime.datetime.now()

1218

if (time2 - time) >= delay:

1219

if not client.approved_by_default:

1220

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

1221

" waiting for approval",

1222

client.name)

1223

if self.server.use_dbus:

1224

# Emit D-Bus signal

1225

client.Rejected("Time out")

1226

return

1227

else:

1228

break

1229

else:

1230

delay -= time2 - time

1231

1232

sent_size = 0

1233

while sent_size < len(client.secret):

1234

try:

1235

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

1236

except (gnutls.errors.GNUTLSError), error:

1237

logger.warning("gnutls send failed")

1238

return

1239

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

1240

sent, len(client.secret)

1241

- (sent_size + sent))

1242

sent_size += sent

1243

1244

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

1245

# bump the timeout as if seen

1246

client.checked_ok()

1247

if self.server.use_dbus:

1248

# Emit D-Bus signal

1249

client.GotSecret()

1041

1250

1042

for c in self.server.clients:

1043

if c.fingerprint == fpr:

1044

client = c

1045

break

1046

else:

1047

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

1048

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

1049

session.bye()

1050

return

1051

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

1052

# possible that the client timed out while establishing

1053

# the GnuTLS session.

1054

if not client.still_valid():

1055

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

1056

session.bye()

1057

return

1058

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

1059

sent_size = 0

1060

while sent_size < len(client.secret):

1061

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

1062

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

1063

sent, len(client.secret)

1064

- (sent_size + sent))

1065

sent_size += sent

1066

session.bye()

1251

finally:

1252

if approval_required:

1253

client.approvals_pending -= 1

1254

try:

1255

session.bye()

1256

except (gnutls.errors.GNUTLSError), error:

1257

logger.warning("gnutls bye failed")

1067

1258

1068

1259

@staticmethod

1069

1260

def peer_certificate(session):

1129

1320

return hex_fpr

1130

1321

1131

1322

1132

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

1133

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

1323

class MultiprocessingMixIn(object):

1324

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

1325

def sub_process_main(self, request, address):

1326

try:

1327

self.finish_request(request, address)

1328

except:

1329

self.handle_error(request, address)

1330

self.close_request(request)

1331

1332

def process_request(self, request, address):

1333

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

1334

multiprocessing.Process(target = self.sub_process_main,

1335

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

1336

1337

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1338

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

1134

1339

def process_request(self, request, client_address):

1135

1340

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

1136

1341

1137

1342

This function creates a new pipe in self.pipe

1138

1343

"""

1139

self.pipe = os.pipe()

1140

super(ForkingMixInWithPipe,

1344

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1345

1346

super(MultiprocessingMixInWithPipe,

1141

1347

self).process_request(request, client_address)

1142

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

1143

self.add_pipe(self.pipe[0])

1144

def add_pipe(self, pipe):

1348

self.child_pipe.close()

1349

self.add_pipe(parent_pipe)

1350

1351

def add_pipe(self, parent_pipe):

1145

1352

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

1146

os.close(pipe)

1147

1148

1149

class IPv6_TCPServer(ForkingMixInWithPipe,

1353

pass

1354

1355

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1150

1356

socketserver.TCPServer, object):

1151

1357

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

1152

1358

1237

1443

return socketserver.TCPServer.server_activate(self)

1238

1444

def enable(self):

1239

1445

self.enabled = True

1240

def add_pipe(self, pipe):

1446

def add_pipe(self, parent_pipe):

1241

1447

# Call "handle_ipc" for both data and EOF events

1242

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

1243

self.handle_ipc)

1244

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

1448

gobject.io_add_watch(parent_pipe.fileno(),

1449

gobject.IO_IN | gobject.IO_HUP,

1450

functools.partial(self.handle_ipc,

1451

parent_pipe = parent_pipe))

1452

1453

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

1454

client_object=None):

1245

1455

condition_names = {

1246

1456

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

1247

1457

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

1258

1468

if cond & condition)

1259

1469

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

1260

1470

conditions_string)

1261

1262

# Turn the pipe file descriptor into a Python file object

1263

if source not in file_objects:

1264

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

1265

1266

# Read a line from the file object

1267

cmdline = file_objects[source].readline()

1268

if not cmdline: # Empty line means end of file

1269

# close the IPC pipe

1270

file_objects[source].close()

1271

del file_objects[source]

1272

1273

# Stop calling this function

1274

return False

1275

1276

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

1277

1278

# Parse and act on command

1279

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

1280

1281

if cmd == u"NOTFOUND":

1282

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

1283

args)

1284

if self.use_dbus:

1285

# Emit D-Bus signal

1286

mandos_dbus_service.ClientNotFound(args)

1287

elif cmd == u"INVALID":

1288

for client in self.clients:

1289

if client.name == args:

1290

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

1291

if self.use_dbus:

1292

# Emit D-Bus signal

1293

client.Rejected()

1294

break

1295

else:

1296

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

1297

elif cmd == u"SENDING":

1298

for client in self.clients:

1299

if client.name == args:

1300

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

1301

client.checked_ok()

1302

if self.use_dbus:

1303

# Emit D-Bus signal

1304

client.GotSecret()

1305

break

1306

else:

1307

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

1308

args)

1309

else:

1310

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

1311

1312

# Keep calling this function

1471

1472

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

1473

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

1474

return False

1475

1476

# Read a request from the child

1477

request = parent_pipe.recv()

1478

logger.debug(u"IPC request: %s", repr(request))

1479

command = request[0]

1480

1481

if command == 'init':

1482

fpr = request[1]

1483

address = request[2]

1484

1485

for c in self.clients:

1486

if c.fingerprint == fpr:

1487

client = c

1488

break

1489

else:

1490

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

1491

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

1492

if self.use_dbus:

1493

# Emit D-Bus signal

1494

mandos_dbus_service.ClientNotFound(fpr, address)

1495

parent_pipe.send(False)

1496

return False

1497

1498

gobject.io_add_watch(parent_pipe.fileno(),

1499

gobject.IO_IN | gobject.IO_HUP,

1500

functools.partial(self.handle_ipc,

1501

parent_pipe = parent_pipe,

1502

client_object = client))

1503

parent_pipe.send(True)

1504

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

1505

return False

1506

if command == 'funcall':

1507

funcname = request[1]

1508

args = request[2]

1509

kwargs = request[3]

1510

1511

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

1512

1513

if command == 'getattr':

1514

attrname = request[1]

1515

if callable(client_object.__getattribute__(attrname)):

1516

parent_pipe.send(('function',))

1517

else:

1518

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

1519

1520

if command == 'setattr':

1521

attrname = request[1]

1522

value = request[2]

1523

setattr(client_object, attrname, value)

1524

1313

1525

return True

1314

1526

1315

1527

1345

1557

elif suffix == u"w":

1346

1558

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

1347

1559

else:

1348

raise ValueError

1349

except (ValueError, IndexError):

1350

raise ValueError

1560

raise ValueError(u"Unknown suffix %r" % suffix)

1561

except (ValueError, IndexError), e:

1562

raise ValueError(e.message)

1351

1563

timevalue += delta

1352

1564

return timevalue

1353

1565

1366

1578

def if_nametoindex(interface):

1367

1579

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

1368

1580

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

1369

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

1581

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

1370

1582

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1371

1583

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

1372

1584

interface))

1418

1630

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

1419

1631

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

1420

1632

u" terminal")

1633

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

1634

help=u"Debug level for stdout output")

1421

1635

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

1422

1636

u" priority string (see GnuTLS documentation)")

1423

1637

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

1448

1662

u"servicename": u"Mandos",

1449

1663

u"use_dbus": u"True",

1450

1664

u"use_ipv6": u"True",

1665

u"debuglevel": u"",

1451

1666

}

1452

1667

1453

1668

# Parse config file for server-global settings

1470

1685

# options, if set.

1471

1686

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

1472

1687

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

1473

u"use_dbus", u"use_ipv6"):

1688

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

1474

1689

value = getattr(options, option)

1475

1690

if value is not None:

1476

1691

server_settings[option] = value

1485

1700

1486

1701

# For convenience

1487

1702

debug = server_settings[u"debug"]

1703

debuglevel = server_settings[u"debuglevel"]

1488

1704

use_dbus = server_settings[u"use_dbus"]

1489

1705

use_ipv6 = server_settings[u"use_ipv6"]

1490

1491

if not debug:

1492

syslogger.setLevel(logging.WARNING)

1493

console.setLevel(logging.WARNING)

1494

1706

1495

1707

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

1496

1708

syslogger.setFormatter(logging.Formatter

1497

1709

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

1503

1715

u"interval": u"5m",

1504

1716

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

1505

1717

u"host": u"",

1718

u"approved_delay": u"0s",

1719

u"approved_duration": u"1s",

1506

1720

}

1507

1721

client_config = configparser.SafeConfigParser(client_defaults)

1508

1722

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

1547

1761

raise error

1548

1762

1549

1763

# Enable all possible GnuTLS debugging

1764

1765

1766

if not debug and not debuglevel:

1767

syslogger.setLevel(logging.WARNING)

1768

console.setLevel(logging.WARNING)

1769

if debuglevel:

1770

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

1771

syslogger.setLevel(level)

1772

console.setLevel(level)

1773

1550

1774

if debug:

1551

1775

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

1552

1776

# - GnuTLS manual

1558

1782

1559

1783

(gnutls.library.functions

1560

1784

.gnutls_global_set_log_function(debug_gnutls))

1785

1786

# Redirect stdin so all checkers get /dev/null

1787

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

1788

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

1789

if null > 2:

1790

os.close(null)

1791

else:

1792

# No console logging

1793

logger.removeHandler(console)

1794

1561

1795

1562

1796

global main_loop

1563

1797

# From the Avahi example code

1566

1800

bus = dbus.SystemBus()

1567

1801

# End of Avahi example code

1568

1802

if use_dbus:

1569

bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)

1803

try:

1804

bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",

1805

bus, do_not_queue=True)

1806

except dbus.exceptions.NameExistsException, e:

1807

logger.error(unicode(e) + u", disabling D-Bus")

1808

use_dbus = False

1809

server_settings[u"use_dbus"] = False

1810

tcp_server.use_dbus = False

1570

1811

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1571

1812

service = AvahiService(name = server_settings[u"servicename"],

1572

1813

servicetype = u"_mandos._tcp",

1574

1815

if server_settings["interface"]:

1575

1816

service.interface = (if_nametoindex

1576

1817

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

1818

1819

if not debug:

1820

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

1821

daemon()

1822

1823

global multiprocessing_manager

1824

multiprocessing_manager = multiprocessing.Manager()

1577

1825

1578

1826

client_class = Client

1579

1827

if use_dbus:

1580

1828

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

1829

def client_config_items(config, section):

1830

special_settings = {

1831

"approved_by_default":

1832

lambda: config.getboolean(section,

1833

"approved_by_default"),

1834

}

1835

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

1836

try:

1837

yield (name, special_settings[name]())

1838

except KeyError:

1839

yield (name, value)

1840

1581

1841

tcp_server.clients.update(set(

1582

1842

client_class(name = section,

1583

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

1843

config= dict(client_config_items(

1844

client_config, section)))

1584

1845

for section in client_config.sections()))

1585

1846

if not tcp_server.clients:

1586

1847

logger.warning(u"No clients defined")

1587

1588

if debug:

1589

# Redirect stdin so all checkers get /dev/null

1590

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

1591

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

1592

if null > 2:

1593

os.close(null)

1594

else:

1595

# No console logging

1596

logger.removeHandler(console)

1597

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

1598

daemon()

1599

1848

1600

1849

try:

1601

with closing(pidfile):

1850

with pidfile:

1602

1851

pid = os.getpid()

1603

1852

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

1604

1853

del pidfile

1610

1859

pass

1611

1860

del pidfilename

1612

1861

1613

def cleanup():

1614

"Cleanup function; run on exit"

1615

service.cleanup()

1616

1617

while tcp_server.clients:

1618

client = tcp_server.clients.pop()

1619

client.disable_hook = None

1620

client.disable()

1621

1622

atexit.register(cleanup)

1623

1624

1862

if not debug:

1625

1863

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

1626

1864

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

1633

1871

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

1634

1872

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

1635

1873

1636

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

1637

def ClientAdded(self, objpath, properties):

1874

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

1875

def ClientAdded(self, objpath):

1638

1876

"D-Bus signal"

1639

1877

pass

1640

1878

1641

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

1642

def ClientNotFound(self, fingerprint):

1879

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

1880

def ClientNotFound(self, fingerprint, address):

1643

1881

"D-Bus signal"

1644

1882

pass

1645

1883

1671

1909

tcp_server.clients.remove(c)

1672

1910

c.remove_from_connection()

1673

1911

# Don't signal anything except ClientRemoved

1674

c.disable(signal=False)

1912

c.disable(quiet=True)

1675

1913

# Emit D-Bus signal

1676

1914

self.ClientRemoved(object_path, c.name)

1677

1915

return

1678

raise KeyError

1916

raise KeyError(object_path)

1679

1917

1680

1918

del _interface

1681

1919

1682

1920

mandos_dbus_service = MandosDBusService()

1683

1921

1922

def cleanup():

1923

"Cleanup function; run on exit"

1924

service.cleanup()

1925

1926

while tcp_server.clients:

1927

client = tcp_server.clients.pop()

1928

if use_dbus:

1929

client.remove_from_connection()

1930

client.disable_hook = None

1931

# Don't signal anything except ClientRemoved

1932

client.disable(quiet=True)

1933

if use_dbus:

1934

# Emit D-Bus signal

1935

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

1936

client.name)

1937

1938

atexit.register(cleanup)

1939

1684

1940

for client in tcp_server.clients:

1685

1941

if use_dbus:

1686

1942

# Emit D-Bus signal

1687

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1688

client.GetAll(u""))

1943

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1689

1944

client.enable()

1690

1945

1691

1946

tcp_server.enable()

1709

1964

service.activate()

1710

1965

except dbus.exceptions.DBusException, error:

1711

1966

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

1967

cleanup()

1712

1968

sys.exit(1)

1713

1969

# End of Avahi example code

1714

1970

1721

1977

main_loop.run()

1722

1978

except AvahiError, error:

1723

1979

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

1980

cleanup()

1724

1981

sys.exit(1)

1725

1982

except KeyboardInterrupt:

1726

1983

if debug:

1727

1984

print >> sys.stderr

1728

1985

logger.debug(u"Server received KeyboardInterrupt")

1729

1986

logger.debug(u"Server exiting")

1987

# Must run before the D-Bus bus name gets deregistered

1988

cleanup()

1730

1989

1731

1990

if __name__ == '__main__':

1732

1991

main()