To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 342
- compare with another revision
- download diff
- download tarball
- view history from revision 342
- Committer: Teddy Hogeborn
- Date: 2009-04-17 08:26:17 UTC
- Revision ID: teddy@fukt.bsnet.se-20090417082617-eltetak5lzjyz55o
* initramfs-tools-hook: Bug fix: Add "--userid" and "--groupid" to
start of "plugin-runner.conf" file instead of
appending, to allow any preexisting options to
override.
* plugin-runner.conf: Improved wording.
start of "plugin-runner.conf" file instead of
appending, to allow any preexisting options to
override.
* plugin-runner.conf: Improved wording.
- files removed:
- DBUS-API
- debian/source
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
31
31
# Contact the authors at <mandos@fukt.bsnet.se>.
32
32
#
33
33
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
34
from __future__ import division, with_statement, absolute_import
36
35
37
36
import SocketServer as socketserver
38
37
import socket
39
import argparse
38
import optparse
40
39
import datetime
41
40
import errno
42
41
import gnutls.crypto
56
55
import logging
57
56
import logging.handlers
58
57
import pwd
59
import contextlib
58
from contextlib import closing
60
59
import struct
61
60
import fcntl
62
61
import functools
63
import cPickle as pickle
64
import multiprocessing
65
import types
66
62
67
63
import dbus
68
64
import dbus.service
71
67
from dbus.mainloop.glib import DBusGMainLoop
72
68
import ctypes
73
69
import ctypes.util
74
import xml.dom.minidom
75
import inspect
76
70
77
71
try:
78
72
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
83
77
SO_BINDTODEVICE = None
84
78
85
79
86
version = "1.3.1"
80
version = "1.0.8"
87
81
88
#logger = logging.getLogger('mandos')
89
logger = logging.Logger('mandos')
82
logger = logging.Logger(u'mandos')
90
83
syslogger = (logging.handlers.SysLogHandler
91
84
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
92
address = str("/dev/log")))
85
address = "/dev/log"))
93
86
syslogger.setFormatter(logging.Formatter
94
('Mandos [%(process)d]: %(levelname)s:'
95
' %(message)s'))
87
(u'Mandos [%(process)d]: %(levelname)s:'
88
u' %(message)s'))
96
89
logger.addHandler(syslogger)
97
90
98
91
console = logging.StreamHandler()
99
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
100
' %(levelname)s:'
101
' %(message)s'))
92
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
93
u' %(levelname)s:'
94
u' %(message)s'))
102
95
logger.addHandler(console)
103
96
104
97
class AvahiError(Exception):
121
114
Attributes:
122
115
interface: integer; avahi.IF_UNSPEC or an interface index.
123
116
Used to optionally bind to the specified interface.
124
name: string; Example: 'Mandos'
125
type: string; Example: '_mandos._tcp'.
117
name: string; Example: u'Mandos'
118
type: string; Example: u'_mandos._tcp'.
126
119
See <http://www.dns-sd.org/ServiceTypes.html>
127
120
port: integer; what port to announce
128
121
TXT: list of strings; TXT record for the service
137
130
"""
138
131
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
139
132
servicetype = None, port = None, TXT = None,
140
domain = "", host = "", max_renames = 32768,
133
domain = u"", host = u"", max_renames = 32768,
141
134
protocol = avahi.PROTO_UNSPEC, bus = None):
142
135
self.interface = interface
143
136
self.name = name
152
145
self.group = None # our entry group
153
146
self.server = None
154
147
self.bus = bus
155
self.entry_group_state_changed_match = None
156
148
def rename(self):
157
149
"""Derived from the Avahi example code"""
158
150
if self.rename_count >= self.max_renames:
159
logger.critical("No suitable Zeroconf service name found"
160
" after %i retries, exiting.",
151
logger.critical(u"No suitable Zeroconf service name found"
152
u" after %i retries, exiting.",
161
153
self.rename_count)
162
raise AvahiServiceError("Too many renames")
163
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
164
logger.info("Changing Zeroconf service name to %r ...",
165
self.name)
154
raise AvahiServiceError(u"Too many renames")
155
self.name = self.server.GetAlternativeServiceName(self.name)
156
logger.info(u"Changing Zeroconf service name to %r ...",
157
unicode(self.name))
166
158
syslogger.setFormatter(logging.Formatter
167
('Mandos (%s) [%%(process)d]:'
168
' %%(levelname)s: %%(message)s'
159
(u'Mandos (%s) [%%(process)d]:'
160
u' %%(levelname)s: %%(message)s'
169
161
% self.name))
170
162
self.remove()
171
try:
172
self.add()
173
except dbus.exceptions.DBusException as error:
174
logger.critical("DBusException: %s", error)
175
self.cleanup()
176
os._exit(1)
163
self.add()
177
164
self.rename_count += 1
178
165
def remove(self):
179
166
"""Derived from the Avahi example code"""
180
if self.entry_group_state_changed_match is not None:
181
self.entry_group_state_changed_match.remove()
182
self.entry_group_state_changed_match = None
183
167
if self.group is not None:
184
168
self.group.Reset()
185
169
def add(self):
186
170
"""Derived from the Avahi example code"""
187
self.remove()
188
171
if self.group is None:
189
172
self.group = dbus.Interface(
190
173
self.bus.get_object(avahi.DBUS_NAME,
191
174
self.server.EntryGroupNew()),
192
175
avahi.DBUS_INTERFACE_ENTRY_GROUP)
193
self.entry_group_state_changed_match = (
194
self.group.connect_to_signal(
195
'StateChanged', self .entry_group_state_changed))
196
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
176
self.group.connect_to_signal('StateChanged',
177
self.entry_group_state_changed)
178
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
197
179
self.name, self.type)
198
180
self.group.AddService(
199
181
self.interface,
206
188
self.group.Commit()
207
189
def entry_group_state_changed(self, state, error):
208
190
"""Derived from the Avahi example code"""
209
logger.debug("Avahi entry group state change: %i", state)
191
logger.debug(u"Avahi state change: %i", state)
210
192
211
193
if state == avahi.ENTRY_GROUP_ESTABLISHED:
212
logger.debug("Zeroconf service established.")
194
logger.debug(u"Zeroconf service established.")
213
195
elif state == avahi.ENTRY_GROUP_COLLISION:
214
logger.info("Zeroconf service name collision.")
196
logger.warning(u"Zeroconf service name collision.")
215
197
self.rename()
216
198
elif state == avahi.ENTRY_GROUP_FAILURE:
217
logger.critical("Avahi: Error in group state changed %s",
199
logger.critical(u"Avahi: Error in group state changed %s",
218
200
unicode(error))
219
raise AvahiGroupError("State changed: %s"
201
raise AvahiGroupError(u"State changed: %s"
220
202
% unicode(error))
221
203
def cleanup(self):
222
204
"""Derived from the Avahi example code"""
223
205
if self.group is not None:
224
try:
225
self.group.Free()
226
except (dbus.exceptions.UnknownMethodException,
227
dbus.exceptions.DBusException) as e:
228
pass
206
self.group.Free()
229
207
self.group = None
230
self.remove()
231
def server_state_changed(self, state, error=None):
208
def server_state_changed(self, state):
232
209
"""Derived from the Avahi example code"""
233
logger.debug("Avahi server state change: %i", state)
234
bad_states = { avahi.SERVER_INVALID:
235
"Zeroconf server invalid",
236
avahi.SERVER_REGISTERING: None,
237
avahi.SERVER_COLLISION:
238
"Zeroconf server name collision",
239
avahi.SERVER_FAILURE:
240
"Zeroconf server failure" }
241
if state in bad_states:
242
if bad_states[state] is not None:
243
if error is None:
244
logger.error(bad_states[state])
245
else:
246
logger.error(bad_states[state] + ": %r", error)
247
self.cleanup()
210
if state == avahi.SERVER_COLLISION:
211
logger.error(u"Zeroconf server name collision")
212
self.remove()
248
213
elif state == avahi.SERVER_RUNNING:
249
214
self.add()
250
else:
251
if error is None:
252
logger.debug("Unknown state: %r", state)
253
else:
254
logger.debug("Unknown state: %r: %r", state, error)
255
215
def activate(self):
256
216
"""Derived from the Avahi example code"""
257
217
if self.server is None:
258
218
self.server = dbus.Interface(
259
219
self.bus.get_object(avahi.DBUS_NAME,
260
avahi.DBUS_PATH_SERVER,
261
follow_name_owner_changes=True),
220
avahi.DBUS_PATH_SERVER),
262
221
avahi.DBUS_INTERFACE_SERVER)
263
self.server.connect_to_signal("StateChanged",
222
self.server.connect_to_signal(u"StateChanged",
264
223
self.server_state_changed)
265
224
self.server_state_changed(self.server.GetState())
266
225
267
226
268
def _timedelta_to_milliseconds(td):
269
"Convert a datetime.timedelta() to milliseconds"
270
return ((td.days * 24 * 60 * 60 * 1000)
271
+ (td.seconds * 1000)
272
+ (td.microseconds // 1000))
273
274
227
class Client(object):
275
228
"""A representation of a client host served by this server.
276
229
277
230
Attributes:
278
_approved: bool(); 'None' if not yet approved/disapproved
279
approval_delay: datetime.timedelta(); Time to wait for approval
280
approval_duration: datetime.timedelta(); Duration of one approval
231
name: string; from the config file, used in log messages and
232
D-Bus identifiers
233
fingerprint: string (40 or 32 hexadecimal digits); used to
234
uniquely identify the client
235
secret: bytestring; sent verbatim (over TLS) to client
236
host: string; available for use by the checker command
237
created: datetime.datetime(); (UTC) object creation
238
last_enabled: datetime.datetime(); (UTC)
239
enabled: bool()
240
last_checked_ok: datetime.datetime(); (UTC) or None
241
timeout: datetime.timedelta(); How long from last_checked_ok
242
until this client is invalid
243
interval: datetime.timedelta(); How often to start a new checker
244
disable_hook: If set, called by disable() as disable_hook(self)
281
245
checker: subprocess.Popen(); a running checker process used
282
246
to see if the client lives.
283
247
'None' if no process is running.
284
checker_callback_tag: a gobject event source tag, or None
285
checker_command: string; External command which is run to check
286
if client lives. %() expansions are done at
248
checker_initiator_tag: a gobject event source tag, or None
249
disable_initiator_tag: - '' -
250
checker_callback_tag: - '' -
251
checker_command: string; External command which is run to check if
252
client lives. %() expansions are done at
287
253
runtime with vars(self) as dict, so that for
288
254
instance %(name)s can be used in the command.
289
checker_initiator_tag: a gobject event source tag, or None
290
created: datetime.datetime(); (UTC) object creation
291
255
current_checker_command: string; current running checker_command
292
disable_hook: If set, called by disable() as disable_hook(self)
293
disable_initiator_tag: a gobject event source tag, or None
294
enabled: bool()
295
fingerprint: string (40 or 32 hexadecimal digits); used to
296
uniquely identify the client
297
host: string; available for use by the checker command
298
interval: datetime.timedelta(); How often to start a new checker
299
last_approval_request: datetime.datetime(); (UTC) or None
300
last_checked_ok: datetime.datetime(); (UTC) or None
301
last_enabled: datetime.datetime(); (UTC)
302
name: string; from the config file, used in log messages and
303
D-Bus identifiers
304
secret: bytestring; sent verbatim (over TLS) to client
305
timeout: datetime.timedelta(); How long from last_checked_ok
306
until this client is disabled
307
extended_timeout: extra long timeout when password has been sent
308
runtime_expansions: Allowed attributes for runtime expansion.
309
expires: datetime.datetime(); time (UTC) when a client will be
310
disabled, or None
311
256
"""
312
257
313
runtime_expansions = ("approval_delay", "approval_duration",
314
"created", "enabled", "fingerprint",
315
"host", "interval", "last_checked_ok",
316
"last_enabled", "name", "timeout")
258
@staticmethod
259
def _datetime_to_milliseconds(dt):
260
"Convert a datetime.datetime() to milliseconds"
261
return ((dt.days * 24 * 60 * 60 * 1000)
262
+ (dt.seconds * 1000)
263
+ (dt.microseconds // 1000))
317
264
318
265
def timeout_milliseconds(self):
319
266
"Return the 'timeout' attribute in milliseconds"
320
return _timedelta_to_milliseconds(self.timeout)
321
322
def extended_timeout_milliseconds(self):
323
"Return the 'extended_timeout' attribute in milliseconds"
324
return _timedelta_to_milliseconds(self.extended_timeout)
267
return self._datetime_to_milliseconds(self.timeout)
325
268
326
269
def interval_milliseconds(self):
327
270
"Return the 'interval' attribute in milliseconds"
328
return _timedelta_to_milliseconds(self.interval)
329
330
def approval_delay_milliseconds(self):
331
return _timedelta_to_milliseconds(self.approval_delay)
271
return self._datetime_to_milliseconds(self.interval)
332
272
333
273
def __init__(self, name = None, disable_hook=None, config=None):
334
274
"""Note: the 'checker' key in 'config' sets the
337
277
self.name = name
338
278
if config is None:
339
279
config = {}
340
logger.debug("Creating client %r", self.name)
280
logger.debug(u"Creating client %r", self.name)
341
281
# Uppercase and remove spaces from fingerprint for later
342
282
# comparison purposes with return value from the fingerprint()
343
283
# function
344
self.fingerprint = (config["fingerprint"].upper()
345
.replace(" ", ""))
346
logger.debug(" Fingerprint: %s", self.fingerprint)
347
if "secret" in config:
348
self.secret = config["secret"].decode("base64")
349
elif "secfile" in config:
350
with open(os.path.expanduser(os.path.expandvars
351
(config["secfile"])),
352
"rb") as secfile:
284
self.fingerprint = (config[u"fingerprint"].upper()
285
.replace(u" ", u""))
286
logger.debug(u" Fingerprint: %s", self.fingerprint)
287
if u"secret" in config:
288
self.secret = config[u"secret"].decode(u"base64")
289
elif u"secfile" in config:
290
with closing(open(os.path.expanduser
291
(os.path.expandvars
292
(config[u"secfile"])))) as secfile:
353
293
self.secret = secfile.read()
354
294
else:
355
raise TypeError("No secret or secfile for client %s"
295
raise TypeError(u"No secret or secfile for client %s"
356
296
% self.name)
357
self.host = config.get("host", "")
297
self.host = config.get(u"host", u"")
358
298
self.created = datetime.datetime.utcnow()
359
299
self.enabled = False
360
self.last_approval_request = None
361
300
self.last_enabled = None
362
301
self.last_checked_ok = None
363
self.timeout = string_to_delta(config["timeout"])
364
self.extended_timeout = string_to_delta(config["extended_timeout"])
365
self.interval = string_to_delta(config["interval"])
302
self.timeout = string_to_delta(config[u"timeout"])
303
self.interval = string_to_delta(config[u"interval"])
366
304
self.disable_hook = disable_hook
367
305
self.checker = None
368
306
self.checker_initiator_tag = None
369
307
self.disable_initiator_tag = None
370
self.expires = None
371
308
self.checker_callback_tag = None
372
self.checker_command = config["checker"]
309
self.checker_command = config[u"checker"]
373
310
self.current_checker_command = None
374
311
self.last_connect = None
375
self._approved = None
376
self.approved_by_default = config.get("approved_by_default",
377
True)
378
self.approvals_pending = 0
379
self.approval_delay = string_to_delta(
380
config["approval_delay"])
381
self.approval_duration = string_to_delta(
382
config["approval_duration"])
383
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
384
312
385
def send_changedstate(self):
386
self.changedstate.acquire()
387
self.changedstate.notify_all()
388
self.changedstate.release()
389
390
313
def enable(self):
391
314
"""Start this client's checker and timeout hooks"""
392
if getattr(self, "enabled", False):
315
if getattr(self, u"enabled", False):
393
316
# Already enabled
394
317
return
395
self.send_changedstate()
318
self.last_enabled = datetime.datetime.utcnow()
396
319
# Schedule a new checker to be started an 'interval' from now,
397
320
# and every interval from then on.
398
321
self.checker_initiator_tag = (gobject.timeout_add
399
322
(self.interval_milliseconds(),
400
323
self.start_checker))
324
# Also start a new checker *right now*.
325
self.start_checker()
401
326
# Schedule a disable() when 'timeout' has passed
402
self.expires = datetime.datetime.utcnow() + self.timeout
403
327
self.disable_initiator_tag = (gobject.timeout_add
404
328
(self.timeout_milliseconds(),
405
329
self.disable))
406
330
self.enabled = True
407
self.last_enabled = datetime.datetime.utcnow()
408
# Also start a new checker *right now*.
409
self.start_checker()
410
331
411
def disable(self, quiet=True):
332
def disable(self):
412
333
"""Disable this client."""
413
334
if not getattr(self, "enabled", False):
414
335
return False
415
if not quiet:
416
self.send_changedstate()
417
if not quiet:
418
logger.info("Disabling client %s", self.name)
419
if getattr(self, "disable_initiator_tag", False):
336
logger.info(u"Disabling client %s", self.name)
337
if getattr(self, u"disable_initiator_tag", False):
420
338
gobject.source_remove(self.disable_initiator_tag)
421
339
self.disable_initiator_tag = None
422
self.expires = None
423
if getattr(self, "checker_initiator_tag", False):
340
if getattr(self, u"checker_initiator_tag", False):
424
341
gobject.source_remove(self.checker_initiator_tag)
425
342
self.checker_initiator_tag = None
426
343
self.stop_checker()
441
358
if os.WIFEXITED(condition):
442
359
exitstatus = os.WEXITSTATUS(condition)
443
360
if exitstatus == 0:
444
logger.info("Checker for %(name)s succeeded",
361
logger.info(u"Checker for %(name)s succeeded",
445
362
vars(self))
446
363
self.checked_ok()
447
364
else:
448
logger.info("Checker for %(name)s failed",
365
logger.info(u"Checker for %(name)s failed",
449
366
vars(self))
450
367
else:
451
logger.warning("Checker for %(name)s crashed?",
368
logger.warning(u"Checker for %(name)s crashed?",
452
369
vars(self))
453
370
454
def checked_ok(self, timeout=None):
371
def checked_ok(self):
455
372
"""Bump up the timeout for this client.
456
373
457
374
This should only be called when the client has been seen,
458
375
alive and well.
459
376
"""
460
if timeout is None:
461
timeout = self.timeout
462
377
self.last_checked_ok = datetime.datetime.utcnow()
463
378
gobject.source_remove(self.disable_initiator_tag)
464
self.expires = datetime.datetime.utcnow() + timeout
465
379
self.disable_initiator_tag = (gobject.timeout_add
466
(_timedelta_to_milliseconds(timeout),
380
(self.timeout_milliseconds(),
467
381
self.disable))
468
382
469
def need_approval(self):
470
self.last_approval_request = datetime.datetime.utcnow()
471
472
383
def start_checker(self):
473
384
"""Start a new checker subprocess if one is not running.
474
385
480
391
# client would inevitably timeout, since no checker would get
481
392
# a chance to run to completion. If we instead leave running
482
393
# checkers alone, the checker would have to take more time
483
# than 'timeout' for the client to be disabled, which is as it
484
# should be.
394
# than 'timeout' for the client to be declared invalid, which
395
# is as it should be.
485
396
486
397
# If a checker exists, make sure it is not a zombie
487
try:
398
if self.checker is not None:
488
399
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
489
except (AttributeError, OSError) as error:
490
if (isinstance(error, OSError)
491
and error.errno != errno.ECHILD):
492
raise error
493
else:
494
400
if pid:
495
logger.warning("Checker was a zombie")
401
logger.warning(u"Checker was a zombie")
496
402
gobject.source_remove(self.checker_callback_tag)
497
403
self.checker_callback(pid, status,
498
404
self.current_checker_command)
503
409
command = self.checker_command % self.host
504
410
except TypeError:
505
411
# Escape attributes for the shell
506
escaped_attrs = dict(
507
(attr,
508
re.escape(unicode(str(getattr(self, attr, "")),
509
errors=
510
'replace')))
511
for attr in
512
self.runtime_expansions)
513
412
escaped_attrs = dict((key,
413
re.escape(unicode(str(val),
414
errors=
415
u'replace')))
416
for key, val in
417
vars(self).iteritems())
514
418
try:
515
419
command = self.checker_command % escaped_attrs
516
except TypeError as error:
517
logger.error('Could not format string "%s":'
518
' %s', self.checker_command, error)
420
except TypeError, error:
421
logger.error(u'Could not format string "%s":'
422
u' %s', self.checker_command, error)
519
423
return True # Try again later
520
424
self.current_checker_command = command
521
425
try:
522
logger.info("Starting checker %r for %s",
426
logger.info(u"Starting checker %r for %s",
523
427
command, self.name)
524
428
# We don't need to redirect stdout and stderr, since
525
429
# in normal mode, that is already done by daemon(),
527
431
# always replaced by /dev/null.)
528
432
self.checker = subprocess.Popen(command,
529
433
close_fds=True,
530
shell=True, cwd="/")
434
shell=True, cwd=u"/")
531
435
self.checker_callback_tag = (gobject.child_watch_add
532
436
(self.checker.pid,
533
437
self.checker_callback,
538
442
if pid:
539
443
gobject.source_remove(self.checker_callback_tag)
540
444
self.checker_callback(pid, status, command)
541
except OSError as error:
542
logger.error("Failed to start subprocess: %s",
445
except OSError, error:
446
logger.error(u"Failed to start subprocess: %s",
543
447
error)
544
448
# Re-run this periodically if run by gobject.timeout_add
545
449
return True
549
453
if self.checker_callback_tag:
550
454
gobject.source_remove(self.checker_callback_tag)
551
455
self.checker_callback_tag = None
552
if getattr(self, "checker", None) is None:
456
if getattr(self, u"checker", None) is None:
553
457
return
554
logger.debug("Stopping checker for %(name)s", vars(self))
458
logger.debug(u"Stopping checker for %(name)s", vars(self))
555
459
try:
556
460
os.kill(self.checker.pid, signal.SIGTERM)
557
#time.sleep(0.5)
461
#os.sleep(0.5)
558
462
#if self.checker.poll() is None:
559
463
# os.kill(self.checker.pid, signal.SIGKILL)
560
except OSError as error:
464
except OSError, error:
561
465
if error.errno != errno.ESRCH: # No such process
562
466
raise
563
467
self.checker = None
564
565
566
def dbus_service_property(dbus_interface, signature="v",
567
access="readwrite", byte_arrays=False):
568
"""Decorators for marking methods of a DBusObjectWithProperties to
569
become properties on the D-Bus.
570
571
The decorated method will be called with no arguments by "Get"
572
and with one argument by "Set".
573
574
The parameters, where they are supported, are the same as
575
dbus.service.method, except there is only "signature", since the
576
type from Get() and the type sent to Set() is the same.
577
"""
578
# Encoding deeply encoded byte arrays is not supported yet by the
579
# "Set" method, so we fail early here:
580
if byte_arrays and signature != "ay":
581
raise ValueError("Byte arrays not supported for non-'ay'"
582
" signature %r" % signature)
583
def decorator(func):
584
func._dbus_is_property = True
585
func._dbus_interface = dbus_interface
586
func._dbus_signature = signature
587
func._dbus_access = access
588
func._dbus_name = func.__name__
589
if func._dbus_name.endswith("_dbus_property"):
590
func._dbus_name = func._dbus_name[:-14]
591
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
592
return func
593
return decorator
594
595
596
class DBusPropertyException(dbus.exceptions.DBusException):
597
"""A base class for D-Bus property-related exceptions
598
"""
599
def __unicode__(self):
600
return unicode(str(self))
601
602
603
class DBusPropertyAccessException(DBusPropertyException):
604
"""A property's access permissions disallows an operation.
605
"""
606
pass
607
608
609
class DBusPropertyNotFound(DBusPropertyException):
610
"""An attempt was made to access a non-existing property.
611
"""
612
pass
613
614
615
class DBusObjectWithProperties(dbus.service.Object):
616
"""A D-Bus object with properties.
617
618
Classes inheriting from this can use the dbus_service_property
619
decorator to expose methods as D-Bus properties. It exposes the
620
standard Get(), Set(), and GetAll() methods on the D-Bus.
621
"""
622
623
@staticmethod
624
def _is_dbus_property(obj):
625
return getattr(obj, "_dbus_is_property", False)
626
627
def _get_all_dbus_properties(self):
628
"""Returns a generator of (name, attribute) pairs
629
"""
630
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
631
for cls in self.__class__.__mro__
632
for name, prop in inspect.getmembers(cls, self._is_dbus_property))
633
634
def _get_dbus_property(self, interface_name, property_name):
635
"""Returns a bound method if one exists which is a D-Bus
636
property with the specified name and interface.
637
"""
638
for cls in self.__class__.__mro__:
639
for name, value in inspect.getmembers(cls, self._is_dbus_property):
640
if value._dbus_name == property_name and value._dbus_interface == interface_name:
641
return value.__get__(self)
642
643
# No such property
644
raise DBusPropertyNotFound(self.dbus_object_path + ":"
645
+ interface_name + "."
646
+ property_name)
647
648
649
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
650
out_signature="v")
651
def Get(self, interface_name, property_name):
652
"""Standard D-Bus property Get() method, see D-Bus standard.
653
"""
654
prop = self._get_dbus_property(interface_name, property_name)
655
if prop._dbus_access == "write":
656
raise DBusPropertyAccessException(property_name)
657
value = prop()
658
if not hasattr(value, "variant_level"):
659
return value
660
return type(value)(value, variant_level=value.variant_level+1)
661
662
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
663
def Set(self, interface_name, property_name, value):
664
"""Standard D-Bus property Set() method, see D-Bus standard.
665
"""
666
prop = self._get_dbus_property(interface_name, property_name)
667
if prop._dbus_access == "read":
668
raise DBusPropertyAccessException(property_name)
669
if prop._dbus_get_args_options["byte_arrays"]:
670
# The byte_arrays option is not supported yet on
671
# signatures other than "ay".
672
if prop._dbus_signature != "ay":
673
raise ValueError
674
value = dbus.ByteArray(''.join(unichr(byte)
675
for byte in value))
676
prop(value)
677
678
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
679
out_signature="a{sv}")
680
def GetAll(self, interface_name):
681
"""Standard D-Bus property GetAll() method, see D-Bus
682
standard.
683
684
Note: Will not include properties with access="write".
685
"""
686
all = {}
687
for name, prop in self._get_all_dbus_properties():
688
if (interface_name
689
and interface_name != prop._dbus_interface):
690
# Interface non-empty but did not match
691
continue
692
# Ignore write-only properties
693
if prop._dbus_access == "write":
694
continue
695
value = prop()
696
if not hasattr(value, "variant_level"):
697
all[name] = value
698
continue
699
all[name] = type(value)(value, variant_level=
700
value.variant_level+1)
701
return dbus.Dictionary(all, signature="sv")
702
703
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
704
out_signature="s",
705
path_keyword='object_path',
706
connection_keyword='connection')
707
def Introspect(self, object_path, connection):
708
"""Standard D-Bus method, overloaded to insert property tags.
709
"""
710
xmlstring = dbus.service.Object.Introspect(self, object_path,
711
connection)
712
try:
713
document = xml.dom.minidom.parseString(xmlstring)
714
def make_tag(document, name, prop):
715
e = document.createElement("property")
716
e.setAttribute("name", name)
717
e.setAttribute("type", prop._dbus_signature)
718
e.setAttribute("access", prop._dbus_access)
719
return e
720
for if_tag in document.getElementsByTagName("interface"):
721
for tag in (make_tag(document, name, prop)
722
for name, prop
723
in self._get_all_dbus_properties()
724
if prop._dbus_interface
725
== if_tag.getAttribute("name")):
726
if_tag.appendChild(tag)
727
# Add the names to the return values for the
728
# "org.freedesktop.DBus.Properties" methods
729
if (if_tag.getAttribute("name")
730
== "org.freedesktop.DBus.Properties"):
731
for cn in if_tag.getElementsByTagName("method"):
732
if cn.getAttribute("name") == "Get":
733
for arg in cn.getElementsByTagName("arg"):
734
if (arg.getAttribute("direction")
735
== "out"):
736
arg.setAttribute("name", "value")
737
elif cn.getAttribute("name") == "GetAll":
738
for arg in cn.getElementsByTagName("arg"):
739
if (arg.getAttribute("direction")
740
== "out"):
741
arg.setAttribute("name", "props")
742
xmlstring = document.toxml("utf-8")
743
document.unlink()
744
except (AttributeError, xml.dom.DOMException,
745
xml.parsers.expat.ExpatError) as error:
746
logger.error("Failed to override Introspection method",
747
error)
748
return xmlstring
749
750
751
def datetime_to_dbus (dt, variant_level=0):
752
"""Convert a UTC datetime.datetime() to a D-Bus type."""
753
if dt is None:
754
return dbus.String("", variant_level = variant_level)
755
return dbus.String(dt.isoformat(),
756
variant_level=variant_level)
757
758
class transitional_dbus_metaclass(DBusObjectWithProperties.__metaclass__):
759
def __new__(mcs, name, bases, attr):
760
for attrname, old_dbusobj in inspect.getmembers(bases[0]):
761
new_interface = getattr(old_dbusobj, "_dbus_interface", "").replace("se.bsnet.fukt.", "se.recompile.")
762
if (getattr(old_dbusobj, "_dbus_is_signal", False)
763
and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):
764
unwrappedfunc = dict(zip(old_dbusobj.func_code.co_freevars,
765
old_dbusobj.__closure__))["func"].cell_contents
766
newfunc = types.FunctionType(unwrappedfunc.func_code,
767
unwrappedfunc.func_globals,
768
unwrappedfunc.func_name,
769
unwrappedfunc.func_defaults,
770
unwrappedfunc.func_closure)
771
new_dbusfunc = dbus.service.signal(
772
new_interface, old_dbusobj._dbus_signature)(newfunc)
773
attr["_transitional_" + attrname] = new_dbusfunc
774
775
def fixscope(func1, func2):
776
def newcall(*args, **kwargs):
777
func1(*args, **kwargs)
778
func2(*args, **kwargs)
779
return newcall
780
781
attr[attrname] = fixscope(old_dbusobj, new_dbusfunc)
782
783
elif (getattr(old_dbusobj, "_dbus_is_method", False)
784
and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):
785
new_dbusfunc = (dbus.service.method
786
(new_interface,
787
old_dbusobj._dbus_in_signature,
788
old_dbusobj._dbus_out_signature)
789
(types.FunctionType
790
(old_dbusobj.func_code,
791
old_dbusobj.func_globals,
792
old_dbusobj.func_name,
793
old_dbusobj.func_defaults,
794
old_dbusobj.func_closure)))
795
796
attr[attrname] = new_dbusfunc
797
elif (getattr(old_dbusobj, "_dbus_is_property", False)
798
and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):
799
new_dbusfunc = (dbus_service_property
800
(new_interface,
801
old_dbusobj._dbus_signature,
802
old_dbusobj._dbus_access,
803
old_dbusobj._dbus_get_args_options["byte_arrays"])
804
(types.FunctionType
805
(old_dbusobj.func_code,
806
old_dbusobj.func_globals,
807
old_dbusobj.func_name,
808
old_dbusobj.func_defaults,
809
old_dbusobj.func_closure)))
810
811
attr[attrname] = new_dbusfunc
812
return type.__new__(mcs, name, bases, attr)
813
814
class ClientDBus(Client, DBusObjectWithProperties):
468
469
def still_valid(self):
470
"""Has the timeout not yet passed for this client?"""
471
if not getattr(self, u"enabled", False):
472
return False
473
now = datetime.datetime.utcnow()
474
if self.last_checked_ok is None:
475
return now < (self.created + self.timeout)
476
else:
477
return now < (self.last_checked_ok + self.timeout)
478
479
480
class ClientDBus(Client, dbus.service.Object):
815
481
"""A Client class using D-Bus
816
482
817
483
Attributes:
818
484
dbus_object_path: dbus.ObjectPath
819
485
bus: dbus.SystemBus()
820
486
"""
821
822
runtime_expansions = (Client.runtime_expansions
823
+ ("dbus_object_path",))
824
825
487
# dbus.service.Object doesn't use super(), so we can't either.
826
488
827
489
def __init__(self, bus = None, *args, **kwargs):
828
self._approvals_pending = 0
829
490
self.bus = bus
830
491
Client.__init__(self, *args, **kwargs)
831
492
# Only now, when this client is initialized, can it show up on
832
493
# the D-Bus
833
client_object_name = unicode(self.name).translate(
834
{ord("."): ord("_"),
835
ord("-"): ord("_")})
836
494
self.dbus_object_path = (dbus.ObjectPath
837
("/clients/" + client_object_name))
838
DBusObjectWithProperties.__init__(self, self.bus,
839
self.dbus_object_path)
840
841
def notifychangeproperty(transform_func,
842
dbus_name, type_func=lambda x: x,
843
variant_level=1):
844
""" Modify a variable so that its a property that announce its
845
changes to DBus.
846
transform_fun: Function that takes a value and transform it to
847
DBus type.
848
dbus_name: DBus name of the variable
849
type_func: Function that transform the value before sending it
850
to DBus
851
variant_level: DBus variant level. default: 1
852
"""
853
real_value = [None,]
854
def setter(self, value):
855
old_value = real_value[0]
856
real_value[0] = value
857
if hasattr(self, "dbus_object_path"):
858
if type_func(old_value) != type_func(real_value[0]):
859
dbus_value = transform_func(type_func(real_value[0]),
860
variant_level)
861
self.PropertyChanged(dbus.String(dbus_name),
862
dbus_value)
863
864
return property(lambda self: real_value[0], setter)
865
866
867
expires = notifychangeproperty(datetime_to_dbus, "Expires")
868
approvals_pending = notifychangeproperty(dbus.Boolean,
869
"ApprovalPending",
870
type_func = bool)
871
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
872
last_enabled = notifychangeproperty(datetime_to_dbus,
873
"LastEnabled")
874
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
875
type_func = lambda checker: checker is not None)
876
last_checked_ok = notifychangeproperty(datetime_to_dbus,
877
"LastCheckedOK")
878
last_approval_request = notifychangeproperty(datetime_to_dbus,
879
"LastApprovalRequest")
880
approved_by_default = notifychangeproperty(dbus.Boolean,
881
"ApprovedByDefault")
882
approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",
883
type_func = _timedelta_to_milliseconds)
884
approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",
885
type_func = _timedelta_to_milliseconds)
886
host = notifychangeproperty(dbus.String, "Host")
887
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
888
type_func = _timedelta_to_milliseconds)
889
extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",
890
type_func = _timedelta_to_milliseconds)
891
interval = notifychangeproperty(dbus.UInt16, "Interval",
892
type_func = _timedelta_to_milliseconds)
893
checker_command = notifychangeproperty(dbus.String, "Checker")
894
895
del notifychangeproperty
495
(u"/clients/"
496
+ self.name.replace(u".", u"_")))
497
dbus.service.Object.__init__(self, self.bus,
498
self.dbus_object_path)
499
500
@staticmethod
501
def _datetime_to_dbus(dt, variant_level=0):
502
"""Convert a UTC datetime.datetime() to a D-Bus type."""
503
return dbus.String(dt.isoformat(),
504
variant_level=variant_level)
505
506
def enable(self):
507
oldstate = getattr(self, u"enabled", False)
508
r = Client.enable(self)
509
if oldstate != self.enabled:
510
# Emit D-Bus signals
511
self.PropertyChanged(dbus.String(u"enabled"),
512
dbus.Boolean(True, variant_level=1))
513
self.PropertyChanged(
514
dbus.String(u"last_enabled"),
515
self._datetime_to_dbus(self.last_enabled,
516
variant_level=1))
517
return r
518
519
def disable(self, signal = True):
520
oldstate = getattr(self, u"enabled", False)
521
r = Client.disable(self)
522
if signal and oldstate != self.enabled:
523
# Emit D-Bus signal
524
self.PropertyChanged(dbus.String(u"enabled"),
525
dbus.Boolean(False, variant_level=1))
526
return r
896
527
897
528
def __del__(self, *args, **kwargs):
898
529
try:
899
530
self.remove_from_connection()
900
531
except LookupError:
901
532
pass
902
if hasattr(DBusObjectWithProperties, "__del__"):
903
DBusObjectWithProperties.__del__(self, *args, **kwargs)
533
if hasattr(dbus.service.Object, u"__del__"):
534
dbus.service.Object.__del__(self, *args, **kwargs)
904
535
Client.__del__(self, *args, **kwargs)
905
536
906
537
def checker_callback(self, pid, condition, command,
907
538
*args, **kwargs):
908
539
self.checker_callback_tag = None
909
540
self.checker = None
541
# Emit D-Bus signal
542
self.PropertyChanged(dbus.String(u"checker_running"),
543
dbus.Boolean(False, variant_level=1))
910
544
if os.WIFEXITED(condition):
911
545
exitstatus = os.WEXITSTATUS(condition)
912
546
# Emit D-Bus signal
922
556
return Client.checker_callback(self, pid, condition, command,
923
557
*args, **kwargs)
924
558
559
def checked_ok(self, *args, **kwargs):
560
r = Client.checked_ok(self, *args, **kwargs)
561
# Emit D-Bus signal
562
self.PropertyChanged(
563
dbus.String(u"last_checked_ok"),
564
(self._datetime_to_dbus(self.last_checked_ok,
565
variant_level=1)))
566
return r
567
925
568
def start_checker(self, *args, **kwargs):
926
569
old_checker = self.checker
927
570
if self.checker is not None:
934
577
and old_checker_pid != self.checker.pid):
935
578
# Emit D-Bus signal
936
579
self.CheckerStarted(self.current_checker_command)
937
return r
938
939
def _reset_approved(self):
940
self._approved = None
941
return False
942
943
def approve(self, value=True):
944
self.send_changedstate()
945
self._approved = value
946
gobject.timeout_add(_timedelta_to_milliseconds
947
(self.approval_duration),
948
self._reset_approved)
949
950
951
## D-Bus methods, signals & properties
952
_interface = "se.bsnet.fukt.Mandos.Client"
953
954
## Signals
580
self.PropertyChanged(
581
dbus.String(u"checker_running"),
582
dbus.Boolean(True, variant_level=1))
583
return r
584
585
def stop_checker(self, *args, **kwargs):
586
old_checker = getattr(self, u"checker", None)
587
r = Client.stop_checker(self, *args, **kwargs)
588
if (old_checker is not None
589
and getattr(self, u"checker", None) is None):
590
self.PropertyChanged(dbus.String(u"checker_running"),
591
dbus.Boolean(False, variant_level=1))
592
return r
593
594
## D-Bus methods & signals
595
_interface = u"se.bsnet.fukt.Mandos.Client"
596
597
# CheckedOK - method
598
@dbus.service.method(_interface)
599
def CheckedOK(self):
600
return self.checked_ok()
955
601
956
602
# CheckerCompleted - signal
957
@dbus.service.signal(_interface, signature="nxs")
603
@dbus.service.signal(_interface, signature=u"nxs")
958
604
def CheckerCompleted(self, exitcode, waitstatus, command):
959
605
"D-Bus signal"
960
606
pass
961
607
962
608
# CheckerStarted - signal
963
@dbus.service.signal(_interface, signature="s")
609
@dbus.service.signal(_interface, signature=u"s")
964
610
def CheckerStarted(self, command):
965
611
"D-Bus signal"
966
612
pass
967
613
614
# GetAllProperties - method
615
@dbus.service.method(_interface, out_signature=u"a{sv}")
616
def GetAllProperties(self):
617
"D-Bus method"
618
return dbus.Dictionary({
619
dbus.String(u"name"):
620
dbus.String(self.name, variant_level=1),
621
dbus.String(u"fingerprint"):
622
dbus.String(self.fingerprint, variant_level=1),
623
dbus.String(u"host"):
624
dbus.String(self.host, variant_level=1),
625
dbus.String(u"created"):
626
self._datetime_to_dbus(self.created,
627
variant_level=1),
628
dbus.String(u"last_enabled"):
629
(self._datetime_to_dbus(self.last_enabled,
630
variant_level=1)
631
if self.last_enabled is not None
632
else dbus.Boolean(False, variant_level=1)),
633
dbus.String(u"enabled"):
634
dbus.Boolean(self.enabled, variant_level=1),
635
dbus.String(u"last_checked_ok"):
636
(self._datetime_to_dbus(self.last_checked_ok,
637
variant_level=1)
638
if self.last_checked_ok is not None
639
else dbus.Boolean (False, variant_level=1)),
640
dbus.String(u"timeout"):
641
dbus.UInt64(self.timeout_milliseconds(),
642
variant_level=1),
643
dbus.String(u"interval"):
644
dbus.UInt64(self.interval_milliseconds(),
645
variant_level=1),
646
dbus.String(u"checker"):
647
dbus.String(self.checker_command,
648
variant_level=1),
649
dbus.String(u"checker_running"):
650
dbus.Boolean(self.checker is not None,
651
variant_level=1),
652
dbus.String(u"object_path"):
653
dbus.ObjectPath(self.dbus_object_path,
654
variant_level=1)
655
}, signature=u"sv")
656
657
# IsStillValid - method
658
@dbus.service.method(_interface, out_signature=u"b")
659
def IsStillValid(self):
660
return self.still_valid()
661
968
662
# PropertyChanged - signal
969
@dbus.service.signal(_interface, signature="sv")
663
@dbus.service.signal(_interface, signature=u"sv")
970
664
def PropertyChanged(self, property, value):
971
665
"D-Bus signal"
972
666
pass
973
667
974
# GotSecret - signal
668
# ReceivedSecret - signal
975
669
@dbus.service.signal(_interface)
976
def GotSecret(self):
977
"""D-Bus signal
978
Is sent after a successful transfer of secret from the Mandos
979
server to mandos-client
980
"""
670
def ReceivedSecret(self):
671
"D-Bus signal"
981
672
pass
982
673
983
674
# Rejected - signal
984
@dbus.service.signal(_interface, signature="s")
985
def Rejected(self, reason):
675
@dbus.service.signal(_interface)
676
def Rejected(self):
986
677
"D-Bus signal"
987
678
pass
988
679
989
# NeedApproval - signal
990
@dbus.service.signal(_interface, signature="tb")
991
def NeedApproval(self, timeout, default):
992
"D-Bus signal"
993
return self.need_approval()
994
995
## Methods
996
997
# Approve - method
998
@dbus.service.method(_interface, in_signature="b")
999
def Approve(self, value):
1000
self.approve(value)
1001
1002
# CheckedOK - method
1003
@dbus.service.method(_interface)
1004
def CheckedOK(self):
1005
self.checked_ok()
680
# SetChecker - method
681
@dbus.service.method(_interface, in_signature=u"s")
682
def SetChecker(self, checker):
683
"D-Bus setter method"
684
self.checker_command = checker
685
# Emit D-Bus signal
686
self.PropertyChanged(dbus.String(u"checker"),
687
dbus.String(self.checker_command,
688
variant_level=1))
689
690
# SetHost - method
691
@dbus.service.method(_interface, in_signature=u"s")
692
def SetHost(self, host):
693
"D-Bus setter method"
694
self.host = host
695
# Emit D-Bus signal
696
self.PropertyChanged(dbus.String(u"host"),
697
dbus.String(self.host, variant_level=1))
698
699
# SetInterval - method
700
@dbus.service.method(_interface, in_signature=u"t")
701
def SetInterval(self, milliseconds):
702
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
703
# Emit D-Bus signal
704
self.PropertyChanged(dbus.String(u"interval"),
705
(dbus.UInt64(self.interval_milliseconds(),
706
variant_level=1)))
707
708
# SetSecret - method
709
@dbus.service.method(_interface, in_signature=u"ay",
710
byte_arrays=True)
711
def SetSecret(self, secret):
712
"D-Bus setter method"
713
self.secret = str(secret)
714
715
# SetTimeout - method
716
@dbus.service.method(_interface, in_signature=u"t")
717
def SetTimeout(self, milliseconds):
718
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
719
# Emit D-Bus signal
720
self.PropertyChanged(dbus.String(u"timeout"),
721
(dbus.UInt64(self.timeout_milliseconds(),
722
variant_level=1)))
1006
723
1007
724
# Enable - method
1008
725
@dbus.service.method(_interface)
1027
744
def StopChecker(self):
1028
745
self.stop_checker()
1029
746
1030
## Properties
1031
1032
# ApprovalPending - property
1033
@dbus_service_property(_interface, signature="b", access="read")
1034
def ApprovalPending_dbus_property(self):
1035
return dbus.Boolean(bool(self.approvals_pending))
1036
1037
# ApprovedByDefault - property
1038
@dbus_service_property(_interface, signature="b",
1039
access="readwrite")
1040
def ApprovedByDefault_dbus_property(self, value=None):
1041
if value is None: # get
1042
return dbus.Boolean(self.approved_by_default)
1043
self.approved_by_default = bool(value)
1044
1045
# ApprovalDelay - property
1046
@dbus_service_property(_interface, signature="t",
1047
access="readwrite")
1048
def ApprovalDelay_dbus_property(self, value=None):
1049
if value is None: # get
1050
return dbus.UInt64(self.approval_delay_milliseconds())
1051
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1052
1053
# ApprovalDuration - property
1054
@dbus_service_property(_interface, signature="t",
1055
access="readwrite")
1056
def ApprovalDuration_dbus_property(self, value=None):
1057
if value is None: # get
1058
return dbus.UInt64(_timedelta_to_milliseconds(
1059
self.approval_duration))
1060
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1061
1062
# Name - property
1063
@dbus_service_property(_interface, signature="s", access="read")
1064
def Name_dbus_property(self):
1065
return dbus.String(self.name)
1066
1067
# Fingerprint - property
1068
@dbus_service_property(_interface, signature="s", access="read")
1069
def Fingerprint_dbus_property(self):
1070
return dbus.String(self.fingerprint)
1071
1072
# Host - property
1073
@dbus_service_property(_interface, signature="s",
1074
access="readwrite")
1075
def Host_dbus_property(self, value=None):
1076
if value is None: # get
1077
return dbus.String(self.host)
1078
self.host = value
1079
1080
# Created - property
1081
@dbus_service_property(_interface, signature="s", access="read")
1082
def Created_dbus_property(self):
1083
return dbus.String(datetime_to_dbus(self.created))
1084
1085
# LastEnabled - property
1086
@dbus_service_property(_interface, signature="s", access="read")
1087
def LastEnabled_dbus_property(self):
1088
return datetime_to_dbus(self.last_enabled)
1089
1090
# Enabled - property
1091
@dbus_service_property(_interface, signature="b",
1092
access="readwrite")
1093
def Enabled_dbus_property(self, value=None):
1094
if value is None: # get
1095
return dbus.Boolean(self.enabled)
1096
if value:
1097
self.enable()
1098
else:
1099
self.disable()
1100
1101
# LastCheckedOK - property
1102
@dbus_service_property(_interface, signature="s",
1103
access="readwrite")
1104
def LastCheckedOK_dbus_property(self, value=None):
1105
if value is not None:
1106
self.checked_ok()
1107
return
1108
return datetime_to_dbus(self.last_checked_ok)
1109
1110
# Expires - property
1111
@dbus_service_property(_interface, signature="s", access="read")
1112
def Expires_dbus_property(self):
1113
return datetime_to_dbus(self.expires)
1114
1115
# LastApprovalRequest - property
1116
@dbus_service_property(_interface, signature="s", access="read")
1117
def LastApprovalRequest_dbus_property(self):
1118
return datetime_to_dbus(self.last_approval_request)
1119
1120
# Timeout - property
1121
@dbus_service_property(_interface, signature="t",
1122
access="readwrite")
1123
def Timeout_dbus_property(self, value=None):
1124
if value is None: # get
1125
return dbus.UInt64(self.timeout_milliseconds())
1126
self.timeout = datetime.timedelta(0, 0, 0, value)
1127
if getattr(self, "disable_initiator_tag", None) is None:
1128
return
1129
# Reschedule timeout
1130
gobject.source_remove(self.disable_initiator_tag)
1131
self.disable_initiator_tag = None
1132
self.expires = None
1133
time_to_die = (self.
1134
_timedelta_to_milliseconds((self
1135
.last_checked_ok
1136
+ self.timeout)
1137
- datetime.datetime
1138
.utcnow()))
1139
if time_to_die <= 0:
1140
# The timeout has passed
1141
self.disable()
1142
else:
1143
self.expires = (datetime.datetime.utcnow()
1144
+ datetime.timedelta(milliseconds = time_to_die))
1145
self.disable_initiator_tag = (gobject.timeout_add
1146
(time_to_die, self.disable))
1147
1148
# ExtendedTimeout - property
1149
@dbus_service_property(_interface, signature="t",
1150
access="readwrite")
1151
def ExtendedTimeout_dbus_property(self, value=None):
1152
if value is None: # get
1153
return dbus.UInt64(self.extended_timeout_milliseconds())
1154
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1155
1156
# Interval - property
1157
@dbus_service_property(_interface, signature="t",
1158
access="readwrite")
1159
def Interval_dbus_property(self, value=None):
1160
if value is None: # get
1161
return dbus.UInt64(self.interval_milliseconds())
1162
self.interval = datetime.timedelta(0, 0, 0, value)
1163
if getattr(self, "checker_initiator_tag", None) is None:
1164
return
1165
# Reschedule checker run
1166
gobject.source_remove(self.checker_initiator_tag)
1167
self.checker_initiator_tag = (gobject.timeout_add
1168
(value, self.start_checker))
1169
self.start_checker() # Start one now, too
1170
1171
# Checker - property
1172
@dbus_service_property(_interface, signature="s",
1173
access="readwrite")
1174
def Checker_dbus_property(self, value=None):
1175
if value is None: # get
1176
return dbus.String(self.checker_command)
1177
self.checker_command = value
1178
1179
# CheckerRunning - property
1180
@dbus_service_property(_interface, signature="b",
1181
access="readwrite")
1182
def CheckerRunning_dbus_property(self, value=None):
1183
if value is None: # get
1184
return dbus.Boolean(self.checker is not None)
1185
if value:
1186
self.start_checker()
1187
else:
1188
self.stop_checker()
1189
1190
# ObjectPath - property
1191
@dbus_service_property(_interface, signature="o", access="read")
1192
def ObjectPath_dbus_property(self):
1193
return self.dbus_object_path # is already a dbus.ObjectPath
1194
1195
# Secret = property
1196
@dbus_service_property(_interface, signature="ay",
1197
access="write", byte_arrays=True)
1198
def Secret_dbus_property(self, value):
1199
self.secret = str(value)
1200
1201
747
del _interface
1202
748
1203
749
1204
class ProxyClient(object):
1205
def __init__(self, child_pipe, fpr, address):
1206
self._pipe = child_pipe
1207
self._pipe.send(('init', fpr, address))
1208
if not self._pipe.recv():
1209
raise KeyError()
1210
1211
def __getattribute__(self, name):
1212
if(name == '_pipe'):
1213
return super(ProxyClient, self).__getattribute__(name)
1214
self._pipe.send(('getattr', name))
1215
data = self._pipe.recv()
1216
if data[0] == 'data':
1217
return data[1]
1218
if data[0] == 'function':
1219
def func(*args, **kwargs):
1220
self._pipe.send(('funcall', name, args, kwargs))
1221
return self._pipe.recv()[1]
1222
return func
1223
1224
def __setattr__(self, name, value):
1225
if(name == '_pipe'):
1226
return super(ProxyClient, self).__setattr__(name, value)
1227
self._pipe.send(('setattr', name, value))
1228
1229
class ClientDBusTransitional(ClientDBus):
1230
__metaclass__ = transitional_dbus_metaclass
1231
1232
750
class ClientHandler(socketserver.BaseRequestHandler, object):
1233
751
"""A class to handle client connections.
1234
752
1236
754
Note: This will run in its own forked process."""
1237
755
1238
756
def handle(self):
1239
with contextlib.closing(self.server.child_pipe) as child_pipe:
1240
logger.info("TCP connection from: %s",
1241
unicode(self.client_address))
1242
logger.debug("Pipe FD: %d",
1243
self.server.child_pipe.fileno())
1244
757
logger.info(u"TCP connection from: %s",
758
unicode(self.client_address))
759
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
760
# Open IPC pipe to parent process
761
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1245
762
session = (gnutls.connection
1246
763
.ClientSession(self.request,
1247
764
gnutls.connection
1248
765
.X509Credentials()))
1249
766
767
line = self.request.makefile().readline()
768
logger.debug(u"Protocol version: %r", line)
769
try:
770
if int(line.strip().split()[0]) > 1:
771
raise RuntimeError
772
except (ValueError, IndexError, RuntimeError), error:
773
logger.error(u"Unknown protocol version: %s", error)
774
return
775
1250
776
# Note: gnutls.connection.X509Credentials is really a
1251
777
# generic GnuTLS certificate credentials object so long as
1252
778
# no X.509 keys are added to it. Therefore, we can use it
1253
779
# here despite using OpenPGP certificates.
1254
780
1255
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1256
# "+AES-256-CBC", "+SHA1",
1257
# "+COMP-NULL", "+CTYPE-OPENPGP",
1258
# "+DHE-DSS"))
781
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
782
# u"+AES-256-CBC", u"+SHA1",
783
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
784
# u"+DHE-DSS"))
1259
785
# Use a fallback default, since this MUST be set.
1260
786
priority = self.server.gnutls_priority
1261
787
if priority is None:
1262
priority = "NORMAL"
788
priority = u"NORMAL"
1263
789
(gnutls.library.functions
1264
790
.gnutls_priority_set_direct(session._c_object,
1265
791
priority, None))
1266
792
1267
# Start communication using the Mandos protocol
1268
# Get protocol number
1269
line = self.request.makefile().readline()
1270
logger.debug("Protocol version: %r", line)
1271
try:
1272
if int(line.strip().split()[0]) > 1:
1273
raise RuntimeError
1274
except (ValueError, IndexError, RuntimeError) as error:
1275
logger.error("Unknown protocol version: %s", error)
1276
return
1277
1278
# Start GnuTLS connection
1279
793
try:
1280
794
session.handshake()
1281
except gnutls.errors.GNUTLSError as error:
1282
logger.warning("Handshake failed: %s", error)
795
except gnutls.errors.GNUTLSError, error:
796
logger.warning(u"Handshake failed: %s", error)
1283
797
# Do not run session.bye() here: the session is not
1284
798
# established. Just abandon the request.
1285
799
return
1286
logger.debug("Handshake succeeded")
1287
1288
approval_required = False
800
logger.debug(u"Handshake succeeded")
1289
801
try:
1290
try:
1291
fpr = self.fingerprint(self.peer_certificate
1292
(session))
1293
except (TypeError,
1294
gnutls.errors.GNUTLSError) as error:
1295
logger.warning("Bad certificate: %s", error)
1296
return
1297
logger.debug("Fingerprint: %s", fpr)
1298
1299
try:
1300
client = ProxyClient(child_pipe, fpr,
1301
self.client_address)
1302
except KeyError:
1303
return
1304
1305
if client.approval_delay:
1306
delay = client.approval_delay
1307
client.approvals_pending += 1
1308
approval_required = True
1309
1310
while True:
1311
if not client.enabled:
1312
logger.info("Client %s is disabled",
1313
client.name)
1314
if self.server.use_dbus:
1315
# Emit D-Bus signal
1316
client.Rejected("Disabled")
1317
return
1318
1319
if client._approved or not client.approval_delay:
1320
#We are approved or approval is disabled
1321
break
1322
elif client._approved is None:
1323
logger.info("Client %s needs approval",
1324
client.name)
1325
if self.server.use_dbus:
1326
# Emit D-Bus signal
1327
client.NeedApproval(
1328
client.approval_delay_milliseconds(),
1329
client.approved_by_default)
1330
else:
1331
logger.warning("Client %s was not approved",
1332
client.name)
1333
if self.server.use_dbus:
1334
# Emit D-Bus signal
1335
client.Rejected("Denied")
1336
return
1337
1338
#wait until timeout or approved
1339
#x = float(client._timedelta_to_milliseconds(delay))
1340
time = datetime.datetime.now()
1341
client.changedstate.acquire()
1342
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1343
client.changedstate.release()
1344
time2 = datetime.datetime.now()
1345
if (time2 - time) >= delay:
1346
if not client.approved_by_default:
1347
logger.warning("Client %s timed out while"
1348
" waiting for approval",
1349
client.name)
1350
if self.server.use_dbus:
1351
# Emit D-Bus signal
1352
client.Rejected("Approval timed out")
1353
return
1354
else:
1355
break
1356
else:
1357
delay -= time2 - time
1358
1359
sent_size = 0
1360
while sent_size < len(client.secret):
1361
try:
1362
sent = session.send(client.secret[sent_size:])
1363
except gnutls.errors.GNUTLSError as error:
1364
logger.warning("gnutls send failed")
1365
return
1366
logger.debug("Sent: %d, remaining: %d",
1367
sent, len(client.secret)
1368
- (sent_size + sent))
1369
sent_size += sent
1370
1371
logger.info("Sending secret to %s", client.name)
1372
# bump the timeout as if seen
1373
client.checked_ok(client.extended_timeout)
1374
if self.server.use_dbus:
1375
# Emit D-Bus signal
1376
client.GotSecret()
802
fpr = self.fingerprint(self.peer_certificate(session))
803
except (TypeError, gnutls.errors.GNUTLSError), error:
804
logger.warning(u"Bad certificate: %s", error)
805
session.bye()
806
return
807
logger.debug(u"Fingerprint: %s", fpr)
1377
808
1378
finally:
1379
if approval_required:
1380
client.approvals_pending -= 1
1381
try:
1382
session.bye()
1383
except gnutls.errors.GNUTLSError as error:
1384
logger.warning("GnuTLS bye failed")
809
for c in self.server.clients:
810
if c.fingerprint == fpr:
811
client = c
812
break
813
else:
814
ipc.write(u"NOTFOUND %s\n" % fpr)
815
session.bye()
816
return
817
# Have to check if client.still_valid(), since it is
818
# possible that the client timed out while establishing
819
# the GnuTLS session.
820
if not client.still_valid():
821
ipc.write(u"INVALID %s\n" % client.name)
822
session.bye()
823
return
824
ipc.write(u"SENDING %s\n" % client.name)
825
sent_size = 0
826
while sent_size < len(client.secret):
827
sent = session.send(client.secret[sent_size:])
828
logger.debug(u"Sent: %d, remaining: %d",
829
sent, len(client.secret)
830
- (sent_size + sent))
831
sent_size += sent
832
session.bye()
1385
833
1386
834
@staticmethod
1387
835
def peer_certificate(session):
1397
845
.gnutls_certificate_get_peers
1398
846
(session._c_object, ctypes.byref(list_size)))
1399
847
if not bool(cert_list) and list_size.value != 0:
1400
raise gnutls.errors.GNUTLSError("error getting peer"
1401
" certificate")
848
raise gnutls.errors.GNUTLSError(u"error getting peer"
849
u" certificate")
1402
850
if list_size.value == 0:
1403
851
return None
1404
852
cert = cert_list[0]
1430
878
if crtverify.value != 0:
1431
879
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1432
880
raise (gnutls.errors.CertificateSecurityError
1433
("Verify failed"))
881
(u"Verify failed"))
1434
882
# New buffer for the fingerprint
1435
883
buf = ctypes.create_string_buffer(20)
1436
884
buf_len = ctypes.c_size_t()
1443
891
# Convert the buffer to a Python bytestring
1444
892
fpr = ctypes.string_at(buf, buf_len.value)
1445
893
# Convert the bytestring to hexadecimal notation
1446
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
894
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1447
895
return hex_fpr
1448
896
1449
897
1450
class MultiprocessingMixIn(object):
1451
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1452
def sub_process_main(self, request, address):
1453
try:
1454
self.finish_request(request, address)
1455
except:
1456
self.handle_error(request, address)
1457
self.close_request(request)
1458
1459
def process_request(self, request, address):
1460
"""Start a new process to process the request."""
1461
multiprocessing.Process(target = self.sub_process_main,
1462
args = (request, address)).start()
1463
1464
1465
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1466
""" adds a pipe to the MixIn """
898
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
899
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
1467
900
def process_request(self, request, client_address):
1468
901
"""Overrides and wraps the original process_request().
1469
902
1470
This function creates a new pipe in self.pipe
903
This function creates a new pipe in self.pipe
1471
904
"""
1472
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1473
1474
super(MultiprocessingMixInWithPipe,
905
self.pipe = os.pipe()
906
super(ForkingMixInWithPipe,
1475
907
self).process_request(request, client_address)
1476
self.child_pipe.close()
1477
self.add_pipe(parent_pipe)
1478
1479
def add_pipe(self, parent_pipe):
908
os.close(self.pipe[1]) # close write end
909
self.add_pipe(self.pipe[0])
910
def add_pipe(self, pipe):
1480
911
"""Dummy function; override as necessary"""
1481
raise NotImplementedError
1482
1483
1484
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
912
os.close(pipe)
913
914
915
class IPv6_TCPServer(ForkingMixInWithPipe,
1485
916
socketserver.TCPServer, object):
1486
917
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1487
918
1503
934
bind to an address or port if they were not specified."""
1504
935
if self.interface is not None:
1505
936
if SO_BINDTODEVICE is None:
1506
logger.error("SO_BINDTODEVICE does not exist;"
1507
" cannot bind to interface %s",
937
logger.error(u"SO_BINDTODEVICE does not exist;"
938
u" cannot bind to interface %s",
1508
939
self.interface)
1509
940
else:
1510
941
try:
1511
942
self.socket.setsockopt(socket.SOL_SOCKET,
1512
943
SO_BINDTODEVICE,
1513
944
str(self.interface
1514
+ '\0'))
1515
except socket.error as error:
945
+ u'\0'))
946
except socket.error, error:
1516
947
if error[0] == errno.EPERM:
1517
logger.error("No permission to"
1518
" bind to interface %s",
948
logger.error(u"No permission to"
949
u" bind to interface %s",
1519
950
self.interface)
1520
951
elif error[0] == errno.ENOPROTOOPT:
1521
logger.error("SO_BINDTODEVICE not available;"
1522
" cannot bind to interface %s",
952
logger.error(u"SO_BINDTODEVICE not available;"
953
u" cannot bind to interface %s",
1523
954
self.interface)
1524
955
else:
1525
956
raise
1527
958
if self.server_address[0] or self.server_address[1]:
1528
959
if not self.server_address[0]:
1529
960
if self.address_family == socket.AF_INET6:
1530
any_address = "::" # in6addr_any
961
any_address = u"::" # in6addr_any
1531
962
else:
1532
963
any_address = socket.INADDR_ANY
1533
964
self.server_address = (any_address,
1551
982
clients: set of Client objects
1552
983
gnutls_priority GnuTLS priority string
1553
984
use_dbus: Boolean; to emit D-Bus signals or not
985
clients: set of Client objects
986
gnutls_priority GnuTLS priority string
987
use_dbus: Boolean; to emit D-Bus signals or not
1554
988
1555
989
Assumes a gobject.MainLoop event loop.
1556
990
"""
1572
1006
return socketserver.TCPServer.server_activate(self)
1573
1007
def enable(self):
1574
1008
self.enabled = True
1575
def add_pipe(self, parent_pipe):
1009
def add_pipe(self, pipe):
1576
1010
# Call "handle_ipc" for both data and EOF events
1577
gobject.io_add_watch(parent_pipe.fileno(),
1578
gobject.IO_IN | gobject.IO_HUP,
1579
functools.partial(self.handle_ipc,
1580
parent_pipe = parent_pipe))
1581
1582
def handle_ipc(self, source, condition, parent_pipe=None,
1583
client_object=None):
1011
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1012
self.handle_ipc)
1013
def handle_ipc(self, source, condition, file_objects={}):
1584
1014
condition_names = {
1585
gobject.IO_IN: "IN", # There is data to read.
1586
gobject.IO_OUT: "OUT", # Data can be written (without
1015
gobject.IO_IN: u"IN", # There is data to read.
1016
gobject.IO_OUT: u"OUT", # Data can be written (without
1587
1017
# blocking).
1588
gobject.IO_PRI: "PRI", # There is urgent data to read.
1589
gobject.IO_ERR: "ERR", # Error condition.
1590
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1018
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1019
gobject.IO_ERR: u"ERR", # Error condition.
1020
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1591
1021
# broken, usually for pipes and
1592
1022
# sockets).
1593
1023
}
1595
1025
for cond, name in
1596
1026
condition_names.iteritems()
1597
1027
if cond & condition)
1598
# error or the other end of multiprocessing.Pipe has closed
1599
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1600
return False
1601
1602
# Read a request from the child
1603
request = parent_pipe.recv()
1604
command = request[0]
1605
1606
if command == 'init':
1607
fpr = request[1]
1608
address = request[2]
1609
1610
for c in self.clients:
1611
if c.fingerprint == fpr:
1612
client = c
1613
break
1614
else:
1615
logger.info("Client not found for fingerprint: %s, ad"
1616
"dress: %s", fpr, address)
1617
if self.use_dbus:
1618
# Emit D-Bus signal
1619
mandos_dbus_service.ClientNotFound(fpr, address[0])
1620
parent_pipe.send(False)
1621
return False
1622
1623
gobject.io_add_watch(parent_pipe.fileno(),
1624
gobject.IO_IN | gobject.IO_HUP,
1625
functools.partial(self.handle_ipc,
1626
parent_pipe = parent_pipe,
1627
client_object = client))
1628
parent_pipe.send(True)
1629
# remove the old hook in favor of the new above hook on same fileno
1630
return False
1631
if command == 'funcall':
1632
funcname = request[1]
1633
args = request[2]
1634
kwargs = request[3]
1635
1636
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1637
1638
if command == 'getattr':
1639
attrname = request[1]
1640
if callable(client_object.__getattribute__(attrname)):
1641
parent_pipe.send(('function',))
1642
else:
1643
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1644
1645
if command == 'setattr':
1646
attrname = request[1]
1647
value = request[2]
1648
setattr(client_object, attrname, value)
1649
1028
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1029
conditions_string)
1030
1031
# Turn the pipe file descriptor into a Python file object
1032
if source not in file_objects:
1033
file_objects[source] = os.fdopen(source, u"r", 1)
1034
1035
# Read a line from the file object
1036
cmdline = file_objects[source].readline()
1037
if not cmdline: # Empty line means end of file
1038
# close the IPC pipe
1039
file_objects[source].close()
1040
del file_objects[source]
1041
1042
# Stop calling this function
1043
return False
1044
1045
logger.debug(u"IPC command: %r", cmdline)
1046
1047
# Parse and act on command
1048
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1049
1050
if cmd == u"NOTFOUND":
1051
logger.warning(u"Client not found for fingerprint: %s",
1052
args)
1053
if self.use_dbus:
1054
# Emit D-Bus signal
1055
mandos_dbus_service.ClientNotFound(args)
1056
elif cmd == u"INVALID":
1057
for client in self.clients:
1058
if client.name == args:
1059
logger.warning(u"Client %s is invalid", args)
1060
if self.use_dbus:
1061
# Emit D-Bus signal
1062
client.Rejected()
1063
break
1064
else:
1065
logger.error(u"Unknown client %s is invalid", args)
1066
elif cmd == u"SENDING":
1067
for client in self.clients:
1068
if client.name == args:
1069
logger.info(u"Sending secret to %s", client.name)
1070
client.checked_ok()
1071
if self.use_dbus:
1072
# Emit D-Bus signal
1073
client.ReceivedSecret()
1074
break
1075
else:
1076
logger.error(u"Sending secret to unknown client %s",
1077
args)
1078
else:
1079
logger.error(u"Unknown IPC command: %r", cmdline)
1080
1081
# Keep calling this function
1650
1082
return True
1651
1083
1652
1084
1653
1085
def string_to_delta(interval):
1654
1086
"""Parse a string and return a datetime.timedelta
1655
1087
1656
>>> string_to_delta('7d')
1088
>>> string_to_delta(u'7d')
1657
1089
datetime.timedelta(7)
1658
>>> string_to_delta('60s')
1090
>>> string_to_delta(u'60s')
1659
1091
datetime.timedelta(0, 60)
1660
>>> string_to_delta('60m')
1092
>>> string_to_delta(u'60m')
1661
1093
datetime.timedelta(0, 3600)
1662
>>> string_to_delta('24h')
1094
>>> string_to_delta(u'24h')
1663
1095
datetime.timedelta(1)
1664
>>> string_to_delta('1w')
1096
>>> string_to_delta(u'1w')
1665
1097
datetime.timedelta(7)
1666
>>> string_to_delta('5m 30s')
1098
>>> string_to_delta(u'5m 30s')
1667
1099
datetime.timedelta(0, 330)
1668
1100
"""
1669
1101
timevalue = datetime.timedelta(0)
1671
1103
try:
1672
1104
suffix = unicode(s[-1])
1673
1105
value = int(s[:-1])
1674
if suffix == "d":
1106
if suffix == u"d":
1675
1107
delta = datetime.timedelta(value)
1676
elif suffix == "s":
1108
elif suffix == u"s":
1677
1109
delta = datetime.timedelta(0, value)
1678
elif suffix == "m":
1110
elif suffix == u"m":
1679
1111
delta = datetime.timedelta(0, 0, 0, 0, value)
1680
elif suffix == "h":
1112
elif suffix == u"h":
1681
1113
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1682
elif suffix == "w":
1114
elif suffix == u"w":
1683
1115
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1684
1116
else:
1685
raise ValueError("Unknown suffix %r" % suffix)
1686
except (ValueError, IndexError) as e:
1687
raise ValueError(*(e.args))
1117
raise ValueError
1118
except (ValueError, IndexError):
1119
raise ValueError
1688
1120
timevalue += delta
1689
1121
return timevalue
1690
1122
1696
1128
global if_nametoindex
1697
1129
try:
1698
1130
if_nametoindex = (ctypes.cdll.LoadLibrary
1699
(ctypes.util.find_library("c"))
1131
(ctypes.util.find_library(u"c"))
1700
1132
.if_nametoindex)
1701
1133
except (OSError, AttributeError):
1702
logger.warning("Doing if_nametoindex the hard way")
1134
logger.warning(u"Doing if_nametoindex the hard way")
1703
1135
def if_nametoindex(interface):
1704
1136
"Get an interface index the hard way, i.e. using fcntl()"
1705
1137
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1706
with contextlib.closing(socket.socket()) as s:
1138
with closing(socket.socket()) as s:
1707
1139
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1708
struct.pack(str("16s16x"),
1140
struct.pack(str(u"16s16x"),
1709
1141
interface))
1710
interface_index = struct.unpack(str("I"),
1142
interface_index = struct.unpack(str(u"I"),
1711
1143
ifreq[16:20])[0]
1712
1144
return interface_index
1713
1145
return if_nametoindex(interface)
1721
1153
sys.exit()
1722
1154
os.setsid()
1723
1155
if not nochdir:
1724
os.chdir("/")
1156
os.chdir(u"/")
1725
1157
if os.fork():
1726
1158
sys.exit()
1727
1159
if not noclose:
1729
1161
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1730
1162
if not stat.S_ISCHR(os.fstat(null).st_mode):
1731
1163
raise OSError(errno.ENODEV,
1732
"%s not a character device"
1733
% os.path.devnull)
1164
u"/dev/null not a character device")
1734
1165
os.dup2(null, sys.stdin.fileno())
1735
1166
os.dup2(null, sys.stdout.fileno())
1736
1167
os.dup2(null, sys.stderr.fileno())
1740
1171
1741
1172
def main():
1742
1173
1743
##################################################################
1174
######################################################################
1744
1175
# Parsing of options, both command line and config file
1745
1176
1746
parser = argparse.ArgumentParser()
1747
parser.add_argument("-v", "--version", action="version",
1748
version = "%%(prog)s %s" % version,
1749
help="show version number and exit")
1750
parser.add_argument("-i", "--interface", metavar="IF",
1751
help="Bind to interface IF")
1752
parser.add_argument("-a", "--address",
1753
help="Address to listen for requests on")
1754
parser.add_argument("-p", "--port", type=int,
1755
help="Port number to receive requests on")
1756
parser.add_argument("--check", action="store_true",
1757
help="Run self-test")
1758
parser.add_argument("--debug", action="store_true",
1759
help="Debug mode; run in foreground and log"
1760
" to terminal")
1761
parser.add_argument("--debuglevel", metavar="LEVEL",
1762
help="Debug level for stdout output")
1763
parser.add_argument("--priority", help="GnuTLS"
1764
" priority string (see GnuTLS documentation)")
1765
parser.add_argument("--servicename",
1766
metavar="NAME", help="Zeroconf service name")
1767
parser.add_argument("--configdir",
1768
default="/etc/mandos", metavar="DIR",
1769
help="Directory to search for configuration"
1770
" files")
1771
parser.add_argument("--no-dbus", action="store_false",
1772
dest="use_dbus", help="Do not provide D-Bus"
1773
" system bus interface")
1774
parser.add_argument("--no-ipv6", action="store_false",
1775
dest="use_ipv6", help="Do not use IPv6")
1776
options = parser.parse_args()
1177
parser = optparse.OptionParser(version = "%%prog %s" % version)
1178
parser.add_option("-i", u"--interface", type=u"string",
1179
metavar="IF", help=u"Bind to interface IF")
1180
parser.add_option("-a", u"--address", type=u"string",
1181
help=u"Address to listen for requests on")
1182
parser.add_option("-p", u"--port", type=u"int",
1183
help=u"Port number to receive requests on")
1184
parser.add_option("--check", action=u"store_true",
1185
help=u"Run self-test")
1186
parser.add_option("--debug", action=u"store_true",
1187
help=u"Debug mode; run in foreground and log to"
1188
u" terminal")
1189
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1190
u" priority string (see GnuTLS documentation)")
1191
parser.add_option("--servicename", type=u"string",
1192
metavar=u"NAME", help=u"Zeroconf service name")
1193
parser.add_option("--configdir", type=u"string",
1194
default=u"/etc/mandos", metavar=u"DIR",
1195
help=u"Directory to search for configuration"
1196
u" files")
1197
parser.add_option("--no-dbus", action=u"store_false",
1198
dest=u"use_dbus", help=u"Do not provide D-Bus"
1199
u" system bus interface")
1200
parser.add_option("--no-ipv6", action=u"store_false",
1201
dest=u"use_ipv6", help=u"Do not use IPv6")
1202
options = parser.parse_args()[0]
1777
1203
1778
1204
if options.check:
1779
1205
import doctest
1781
1207
sys.exit()
1782
1208
1783
1209
# Default values for config file for server-global settings
1784
server_defaults = { "interface": "",
1785
"address": "",
1786
"port": "",
1787
"debug": "False",
1788
"priority":
1789
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1790
"servicename": "Mandos",
1791
"use_dbus": "True",
1792
"use_ipv6": "True",
1793
"debuglevel": "",
1210
server_defaults = { u"interface": u"",
1211
u"address": u"",
1212
u"port": u"",
1213
u"debug": u"False",
1214
u"priority":
1215
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1216
u"servicename": u"Mandos",
1217
u"use_dbus": u"True",
1218
u"use_ipv6": u"True",
1794
1219
}
1795
1220
1796
1221
# Parse config file for server-global settings
1797
1222
server_config = configparser.SafeConfigParser(server_defaults)
1798
1223
del server_defaults
1799
1224
server_config.read(os.path.join(options.configdir,
1800
"mandos.conf"))
1225
u"mandos.conf"))
1801
1226
# Convert the SafeConfigParser object to a dict
1802
1227
server_settings = server_config.defaults()
1803
1228
# Use the appropriate methods on the non-string config options
1804
for option in ("debug", "use_dbus", "use_ipv6"):
1805
server_settings[option] = server_config.getboolean("DEFAULT",
1229
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1230
server_settings[option] = server_config.getboolean(u"DEFAULT",
1806
1231
option)
1807
1232
if server_settings["port"]:
1808
server_settings["port"] = server_config.getint("DEFAULT",
1809
"port")
1233
server_settings["port"] = server_config.getint(u"DEFAULT",
1234
u"port")
1810
1235
del server_config
1811
1236
1812
1237
# Override the settings from the config file with command line
1813
1238
# options, if set.
1814
for option in ("interface", "address", "port", "debug",
1815
"priority", "servicename", "configdir",
1816
"use_dbus", "use_ipv6", "debuglevel"):
1239
for option in (u"interface", u"address", u"port", u"debug",
1240
u"priority", u"servicename", u"configdir",
1241
u"use_dbus", u"use_ipv6"):
1817
1242
value = getattr(options, option)
1818
1243
if value is not None:
1819
1244
server_settings[option] = value
1827
1252
##################################################################
1828
1253
1829
1254
# For convenience
1830
debug = server_settings["debug"]
1831
debuglevel = server_settings["debuglevel"]
1832
use_dbus = server_settings["use_dbus"]
1833
use_ipv6 = server_settings["use_ipv6"]
1834
1835
if server_settings["servicename"] != "Mandos":
1255
debug = server_settings[u"debug"]
1256
use_dbus = server_settings[u"use_dbus"]
1257
use_ipv6 = server_settings[u"use_ipv6"]
1258
1259
if not debug:
1260
syslogger.setLevel(logging.WARNING)
1261
console.setLevel(logging.WARNING)
1262
1263
if server_settings[u"servicename"] != u"Mandos":
1836
1264
syslogger.setFormatter(logging.Formatter
1837
('Mandos (%s) [%%(process)d]:'
1838
' %%(levelname)s: %%(message)s'
1839
% server_settings["servicename"]))
1265
(u'Mandos (%s) [%%(process)d]:'
1266
u' %%(levelname)s: %%(message)s'
1267
% server_settings[u"servicename"]))
1840
1268
1841
1269
# Parse config file with clients
1842
client_defaults = { "timeout": "5m",
1843
"extended_timeout": "15m",
1844
"interval": "2m",
1845
"checker": "fping -q -- %%(host)s",
1846
"host": "",
1847
"approval_delay": "0s",
1848
"approval_duration": "1s",
1270
client_defaults = { u"timeout": u"1h",
1271
u"interval": u"5m",
1272
u"checker": u"fping -q -- %%(host)s",
1273
u"host": u"",
1849
1274
}
1850
1275
client_config = configparser.SafeConfigParser(client_defaults)
1851
client_config.read(os.path.join(server_settings["configdir"],
1852
"clients.conf"))
1276
client_config.read(os.path.join(server_settings[u"configdir"],
1277
u"clients.conf"))
1853
1278
1854
1279
global mandos_dbus_service
1855
1280
mandos_dbus_service = None
1856
1281
1857
tcp_server = MandosServer((server_settings["address"],
1858
server_settings["port"]),
1282
tcp_server = MandosServer((server_settings[u"address"],
1283
server_settings[u"port"]),
1859
1284
ClientHandler,
1860
interface=(server_settings["interface"]
1861
or None),
1285
interface=server_settings[u"interface"],
1862
1286
use_ipv6=use_ipv6,
1863
1287
gnutls_priority=
1864
server_settings["priority"],
1288
server_settings[u"priority"],
1865
1289
use_dbus=use_dbus)
1866
if not debug:
1867
pidfilename = "/var/run/mandos.pid"
1868
try:
1869
pidfile = open(pidfilename, "w")
1870
except IOError:
1871
logger.error("Could not open file %r", pidfilename)
1290
pidfilename = u"/var/run/mandos.pid"
1291
try:
1292
pidfile = open(pidfilename, u"w")
1293
except IOError:
1294
logger.error(u"Could not open file %r", pidfilename)
1872
1295
1873
1296
try:
1874
uid = pwd.getpwnam("_mandos").pw_uid
1875
gid = pwd.getpwnam("_mandos").pw_gid
1297
uid = pwd.getpwnam(u"_mandos").pw_uid
1298
gid = pwd.getpwnam(u"_mandos").pw_gid
1876
1299
except KeyError:
1877
1300
try:
1878
uid = pwd.getpwnam("mandos").pw_uid
1879
gid = pwd.getpwnam("mandos").pw_gid
1301
uid = pwd.getpwnam(u"mandos").pw_uid
1302
gid = pwd.getpwnam(u"mandos").pw_gid
1880
1303
except KeyError:
1881
1304
try:
1882
uid = pwd.getpwnam("nobody").pw_uid
1883
gid = pwd.getpwnam("nobody").pw_gid
1305
uid = pwd.getpwnam(u"nobody").pw_uid
1306
gid = pwd.getpwnam(u"nobody").pw_gid
1884
1307
except KeyError:
1885
1308
uid = 65534
1886
1309
gid = 65534
1887
1310
try:
1888
1311
os.setgid(gid)
1889
1312
os.setuid(uid)
1890
except OSError as error:
1313
except OSError, error:
1891
1314
if error[0] != errno.EPERM:
1892
1315
raise error
1893
1316
1894
if not debug and not debuglevel:
1895
syslogger.setLevel(logging.WARNING)
1896
console.setLevel(logging.WARNING)
1897
if debuglevel:
1898
level = getattr(logging, debuglevel.upper())
1899
syslogger.setLevel(level)
1900
console.setLevel(level)
1901
1317
# Enable all possible GnuTLS debugging
1902
1318
if debug:
1903
# Enable all possible GnuTLS debugging
1904
1905
1319
# "Use a log level over 10 to enable all debugging options."
1906
1320
# - GnuTLS manual
1907
1321
gnutls.library.functions.gnutls_global_set_log_level(11)
1908
1322
1909
1323
@gnutls.library.types.gnutls_log_func
1910
1324
def debug_gnutls(level, string):
1911
logger.debug("GnuTLS: %s", string[:-1])
1325
logger.debug(u"GnuTLS: %s", string[:-1])
1912
1326
1913
1327
(gnutls.library.functions
1914
1328
.gnutls_global_set_log_function(debug_gnutls))
1915
1916
# Redirect stdin so all checkers get /dev/null
1917
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1918
os.dup2(null, sys.stdin.fileno())
1919
if null > 2:
1920
os.close(null)
1921
else:
1922
# No console logging
1923
logger.removeHandler(console)
1924
1925
# Need to fork before connecting to D-Bus
1926
if not debug:
1927
# Close all input and output, do double fork, etc.
1928
daemon()
1929
1329
1930
1330
global main_loop
1931
1331
# From the Avahi example code
1934
1334
bus = dbus.SystemBus()
1935
1335
# End of Avahi example code
1936
1336
if use_dbus:
1937
try:
1938
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1939
bus, do_not_queue=True)
1940
bus_name2 = dbus.service.BusName("se.recompile.Mandos",
1941
bus, do_not_queue=True)
1942
except dbus.exceptions.NameExistsException as e:
1943
logger.error(unicode(e) + ", disabling D-Bus")
1944
use_dbus = False
1945
server_settings["use_dbus"] = False
1946
tcp_server.use_dbus = False
1337
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1947
1338
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1948
service = AvahiService(name = server_settings["servicename"],
1949
servicetype = "_mandos._tcp",
1339
service = AvahiService(name = server_settings[u"servicename"],
1340
servicetype = u"_mandos._tcp",
1950
1341
protocol = protocol, bus = bus)
1951
1342
if server_settings["interface"]:
1952
1343
service.interface = (if_nametoindex
1953
(str(server_settings["interface"])))
1954
1955
global multiprocessing_manager
1956
multiprocessing_manager = multiprocessing.Manager()
1344
(str(server_settings[u"interface"])))
1957
1345
1958
1346
client_class = Client
1959
1347
if use_dbus:
1960
client_class = functools.partial(ClientDBusTransitional, bus = bus)
1961
def client_config_items(config, section):
1962
special_settings = {
1963
"approved_by_default":
1964
lambda: config.getboolean(section,
1965
"approved_by_default"),
1966
}
1967
for name, value in config.items(section):
1968
try:
1969
yield (name, special_settings[name]())
1970
except KeyError:
1971
yield (name, value)
1972
1348
client_class = functools.partial(ClientDBus, bus = bus)
1973
1349
tcp_server.clients.update(set(
1974
1350
client_class(name = section,
1975
config= dict(client_config_items(
1976
client_config, section)))
1351
config= dict(client_config.items(section)))
1977
1352
for section in client_config.sections()))
1978
1353
if not tcp_server.clients:
1979
logger.warning("No clients defined")
1354
logger.warning(u"No clients defined")
1355
1356
if debug:
1357
# Redirect stdin so all checkers get /dev/null
1358
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1359
os.dup2(null, sys.stdin.fileno())
1360
if null > 2:
1361
os.close(null)
1362
else:
1363
# No console logging
1364
logger.removeHandler(console)
1365
# Close all input and output, do double fork, etc.
1366
daemon()
1367
1368
try:
1369
with closing(pidfile):
1370
pid = os.getpid()
1371
pidfile.write(str(pid) + "\n")
1372
del pidfile
1373
except IOError:
1374
logger.error(u"Could not write to file %r with PID %d",
1375
pidfilename, pid)
1376
except NameError:
1377
# "pidfile" was never created
1378
pass
1379
del pidfilename
1380
1381
def cleanup():
1382
"Cleanup function; run on exit"
1383
service.cleanup()
1980
1384
1385
while tcp_server.clients:
1386
client = tcp_server.clients.pop()
1387
client.disable_hook = None
1388
client.disable()
1389
1390
atexit.register(cleanup)
1391
1981
1392
if not debug:
1982
try:
1983
with pidfile:
1984
pid = os.getpid()
1985
pidfile.write(str(pid) + "\n".encode("utf-8"))
1986
del pidfile
1987
except IOError:
1988
logger.error("Could not write to file %r with PID %d",
1989
pidfilename, pid)
1990
except NameError:
1991
# "pidfile" was never created
1992
pass
1993
del pidfilename
1994
1995
1393
signal.signal(signal.SIGINT, signal.SIG_IGN)
1996
1997
1394
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1998
1395
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1999
1396
2001
1398
class MandosDBusService(dbus.service.Object):
2002
1399
"""A D-Bus proxy object"""
2003
1400
def __init__(self):
2004
dbus.service.Object.__init__(self, bus, "/")
2005
_interface = "se.bsnet.fukt.Mandos"
2006
2007
@dbus.service.signal(_interface, signature="o")
2008
def ClientAdded(self, objpath):
2009
"D-Bus signal"
2010
pass
2011
2012
@dbus.service.signal(_interface, signature="ss")
2013
def ClientNotFound(self, fingerprint, address):
2014
"D-Bus signal"
2015
pass
2016
2017
@dbus.service.signal(_interface, signature="os")
1401
dbus.service.Object.__init__(self, bus, u"/")
1402
_interface = u"se.bsnet.fukt.Mandos"
1403
1404
@dbus.service.signal(_interface, signature=u"oa{sv}")
1405
def ClientAdded(self, objpath, properties):
1406
"D-Bus signal"
1407
pass
1408
1409
@dbus.service.signal(_interface, signature=u"s")
1410
def ClientNotFound(self, fingerprint):
1411
"D-Bus signal"
1412
pass
1413
1414
@dbus.service.signal(_interface, signature=u"os")
2018
1415
def ClientRemoved(self, objpath, name):
2019
1416
"D-Bus signal"
2020
1417
pass
2021
1418
2022
@dbus.service.method(_interface, out_signature="ao")
1419
@dbus.service.method(_interface, out_signature=u"ao")
2023
1420
def GetAllClients(self):
2024
1421
"D-Bus method"
2025
1422
return dbus.Array(c.dbus_object_path
2026
1423
for c in tcp_server.clients)
2027
1424
2028
1425
@dbus.service.method(_interface,
2029
out_signature="a{oa{sv}}")
1426
out_signature=u"a{oa{sv}}")
2030
1427
def GetAllClientsWithProperties(self):
2031
1428
"D-Bus method"
2032
1429
return dbus.Dictionary(
2033
((c.dbus_object_path, c.GetAll(""))
1430
((c.dbus_object_path, c.GetAllProperties())
2034
1431
for c in tcp_server.clients),
2035
signature="oa{sv}")
1432
signature=u"oa{sv}")
2036
1433
2037
@dbus.service.method(_interface, in_signature="o")
1434
@dbus.service.method(_interface, in_signature=u"o")
2038
1435
def RemoveClient(self, object_path):
2039
1436
"D-Bus method"
2040
1437
for c in tcp_server.clients:
2042
1439
tcp_server.clients.remove(c)
2043
1440
c.remove_from_connection()
2044
1441
# Don't signal anything except ClientRemoved
2045
c.disable(quiet=True)
1442
c.disable(signal=False)
2046
1443
# Emit D-Bus signal
2047
1444
self.ClientRemoved(object_path, c.name)
2048
1445
return
2049
raise KeyError(object_path)
1446
raise KeyError
2050
1447
2051
1448
del _interface
2052
1449
2053
class MandosDBusServiceTransitional(MandosDBusService):
2054
__metaclass__ = transitional_dbus_metaclass
2055
mandos_dbus_service = MandosDBusServiceTransitional()
2056
2057
def cleanup():
2058
"Cleanup function; run on exit"
2059
service.cleanup()
2060
2061
while tcp_server.clients:
2062
client = tcp_server.clients.pop()
2063
if use_dbus:
2064
client.remove_from_connection()
2065
client.disable_hook = None
2066
# Don't signal anything except ClientRemoved
2067
client.disable(quiet=True)
2068
if use_dbus:
2069
# Emit D-Bus signal
2070
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
2071
client.name)
2072
2073
atexit.register(cleanup)
1450
mandos_dbus_service = MandosDBusService()
2074
1451
2075
1452
for client in tcp_server.clients:
2076
1453
if use_dbus:
2077
1454
# Emit D-Bus signal
2078
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1455
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1456
client.GetAllProperties())
2079
1457
client.enable()
2080
1458
2081
1459
tcp_server.enable()
2084
1462
# Find out what port we got
2085
1463
service.port = tcp_server.socket.getsockname()[1]
2086
1464
if use_ipv6:
2087
logger.info("Now listening on address %r, port %d,"
1465
logger.info(u"Now listening on address %r, port %d,"
2088
1466
" flowinfo %d, scope_id %d"
2089
1467
% tcp_server.socket.getsockname())
2090
1468
else: # IPv4
2091
logger.info("Now listening on address %r, port %d"
1469
logger.info(u"Now listening on address %r, port %d"
2092
1470
% tcp_server.socket.getsockname())
2093
1471
2094
1472
#service.interface = tcp_server.socket.getsockname()[3]
2097
1475
# From the Avahi example code
2098
1476
try:
2099
1477
service.activate()
2100
except dbus.exceptions.DBusException as error:
2101
logger.critical("DBusException: %s", error)
2102
cleanup()
1478
except dbus.exceptions.DBusException, error:
1479
logger.critical(u"DBusException: %s", error)
2103
1480
sys.exit(1)
2104
1481
# End of Avahi example code
2105
1482
2108
1485
(tcp_server.handle_request
2109
1486
(*args[2:], **kwargs) or True))
2110
1487
2111
logger.debug("Starting main loop")
1488
logger.debug(u"Starting main loop")
2112
1489
main_loop.run()
2113
except AvahiError as error:
2114
logger.critical("AvahiError: %s", error)
2115
cleanup()
1490
except AvahiError, error:
1491
logger.critical(u"AvahiError: %s", error)
2116
1492
sys.exit(1)
2117
1493
except KeyboardInterrupt:
2118
1494
if debug:
2119
print("", file=sys.stderr)
2120
logger.debug("Server received KeyboardInterrupt")
2121
logger.debug("Server exiting")
2122
# Must run before the D-Bus bus name gets deregistered
2123
cleanup()
2124
1495
print >> sys.stderr
1496
logger.debug(u"Server received KeyboardInterrupt")
1497
logger.debug(u"Server exiting")
2125
1498
2126
1499
if __name__ == '__main__':
2127
1500
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0