269
124
self.rename_count = 0
270
125
self.max_renames = max_renames
271
self.protocol = protocol
272
self.group = None # our entry group
275
self.entry_group_state_changed_match = None
277
126
def rename(self):
278
127
"""Derived from the Avahi example code"""
279
128
if self.rename_count >= self.max_renames:
280
logger.critical("No suitable Zeroconf service name found"
281
" after %i retries, exiting.",
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
282
131
self.rename_count)
283
raise AvahiServiceError("Too many renames")
284
self.name = unicode(self.server
285
.GetAlternativeServiceName(self.name))
286
logger.info("Changing Zeroconf service name to %r ...",
132
raise AvahiServiceError(u"Too many renames")
133
self.name = server.GetAlternativeServiceName(self.name)
134
logger.info(u"Changing Zeroconf service name to %r ...",
136
syslogger.setFormatter(logging.Formatter
137
('Mandos (%s): %%(levelname)s:'
138
' %%(message)s' % self.name))
291
except dbus.exceptions.DBusException as error:
292
logger.critical("D-Bus Exception", exc_info=error)
295
141
self.rename_count += 1
297
142
def remove(self):
298
143
"""Derived from the Avahi example code"""
299
if self.entry_group_state_changed_match is not None:
300
self.entry_group_state_changed_match.remove()
301
self.entry_group_state_changed_match = None
302
if self.group is not None:
144
if group is not None:
306
147
"""Derived from the Avahi example code"""
308
if self.group is None:
309
self.group = dbus.Interface(
310
self.bus.get_object(avahi.DBUS_NAME,
311
self.server.EntryGroupNew()),
312
avahi.DBUS_INTERFACE_ENTRY_GROUP)
313
self.entry_group_state_changed_match = (
314
self.group.connect_to_signal(
315
'StateChanged', self.entry_group_state_changed))
316
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
317
self.name, self.type)
318
self.group.AddService(
321
dbus.UInt32(0), # flags
322
self.name, self.type,
323
self.domain, self.host,
324
dbus.UInt16(self.port),
325
avahi.string_array_to_txt_array(self.TXT))
328
def entry_group_state_changed(self, state, error):
329
"""Derived from the Avahi example code"""
330
logger.debug("Avahi entry group state change: %i", state)
332
if state == avahi.ENTRY_GROUP_ESTABLISHED:
333
logger.debug("Zeroconf service established.")
334
elif state == avahi.ENTRY_GROUP_COLLISION:
335
logger.info("Zeroconf service name collision.")
337
elif state == avahi.ENTRY_GROUP_FAILURE:
338
logger.critical("Avahi: Error in group state changed %s",
340
raise AvahiGroupError("State changed: {0!s}"
344
"""Derived from the Avahi example code"""
345
if self.group is not None:
348
except (dbus.exceptions.UnknownMethodException,
349
dbus.exceptions.DBusException):
354
def server_state_changed(self, state, error=None):
355
"""Derived from the Avahi example code"""
356
logger.debug("Avahi server state change: %i", state)
357
bad_states = { avahi.SERVER_INVALID:
358
"Zeroconf server invalid",
359
avahi.SERVER_REGISTERING: None,
360
avahi.SERVER_COLLISION:
361
"Zeroconf server name collision",
362
avahi.SERVER_FAILURE:
363
"Zeroconf server failure" }
364
if state in bad_states:
365
if bad_states[state] is not None:
367
logger.error(bad_states[state])
369
logger.error(bad_states[state] + ": %r", error)
371
elif state == avahi.SERVER_RUNNING:
375
logger.debug("Unknown state: %r", state)
377
logger.debug("Unknown state: %r: %r", state, error)
380
"""Derived from the Avahi example code"""
381
if self.server is None:
382
self.server = dbus.Interface(
383
self.bus.get_object(avahi.DBUS_NAME,
384
avahi.DBUS_PATH_SERVER,
385
follow_name_owner_changes=True),
386
avahi.DBUS_INTERFACE_SERVER)
387
self.server.connect_to_signal("StateChanged",
388
self.server_state_changed)
389
self.server_state_changed(self.server.GetState())
392
class AvahiServiceToSyslog(AvahiService):
394
"""Add the new name to the syslog messages"""
395
ret = AvahiService.rename(self)
396
syslogger.setFormatter(logging.Formatter
397
('Mandos ({0}) [%(process)d]:'
398
' %(levelname)s: %(message)s'
403
def timedelta_to_milliseconds(td):
404
"Convert a datetime.timedelta() to milliseconds"
405
return ((td.days * 24 * 60 * 60 * 1000)
406
+ (td.seconds * 1000)
407
+ (td.microseconds // 1000))
410
class Client(object):
150
group = dbus.Interface(bus.get_object
152
server.EntryGroupNew()),
153
avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
group.connect_to_signal('StateChanged',
155
entry_group_state_changed)
156
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
157
service.name, service.type)
159
self.interface, # interface
160
avahi.PROTO_INET6, # protocol
161
dbus.UInt32(0), # flags
162
self.name, self.type,
163
self.domain, self.host,
164
dbus.UInt16(self.port),
165
avahi.string_array_to_txt_array(self.TXT))
168
# From the Avahi example code:
169
group = None # our entry group
170
# End of Avahi example code
173
def _datetime_to_dbus(dt, variant_level=0):
174
"""Convert a UTC datetime.datetime() to a D-Bus type."""
175
return dbus.String(dt.isoformat(), variant_level=variant_level)
178
class Client(dbus.service.Object):
411
179
"""A representation of a client host served by this server.
414
approved: bool(); 'None' if not yet approved/disapproved
415
approval_delay: datetime.timedelta(); Time to wait for approval
416
approval_duration: datetime.timedelta(); Duration of one approval
181
name: string; from the config file, used in log messages
182
fingerprint: string (40 or 32 hexadecimal digits); used to
183
uniquely identify the client
184
secret: bytestring; sent verbatim (over TLS) to client
185
host: string; available for use by the checker command
186
created: datetime.datetime(); (UTC) object creation
187
last_enabled: datetime.datetime(); (UTC)
189
last_checked_ok: datetime.datetime(); (UTC) or None
190
timeout: datetime.timedelta(); How long from last_checked_ok
191
until this client is invalid
192
interval: datetime.timedelta(); How often to start a new checker
193
disable_hook: If set, called by disable() as disable_hook(self)
417
194
checker: subprocess.Popen(); a running checker process used
418
195
to see if the client lives.
419
196
'None' if no process is running.
420
checker_callback_tag: a gobject event source tag, or None
421
checker_command: string; External command which is run to check
422
if client lives. %() expansions are done at
197
checker_initiator_tag: a gobject event source tag, or None
198
disable_initiator_tag: - '' -
199
checker_callback_tag: - '' -
200
checker_command: string; External command which is run to check if
201
client lives. %() expansions are done at
423
202
runtime with vars(self) as dict, so that for
424
203
instance %(name)s can be used in the command.
425
checker_initiator_tag: a gobject event source tag, or None
426
created: datetime.datetime(); (UTC) object creation
427
client_structure: Object describing what attributes a client has
428
and is used for storing the client at exit
429
current_checker_command: string; current running checker_command
430
disable_initiator_tag: a gobject event source tag, or None
432
fingerprint: string (40 or 32 hexadecimal digits); used to
433
uniquely identify the client
434
host: string; available for use by the checker command
435
interval: datetime.timedelta(); How often to start a new checker
436
last_approval_request: datetime.datetime(); (UTC) or None
437
last_checked_ok: datetime.datetime(); (UTC) or None
438
last_checker_status: integer between 0 and 255 reflecting exit
439
status of last checker. -1 reflects crashed
440
checker, -2 means no checker completed yet.
441
last_enabled: datetime.datetime(); (UTC) or None
442
name: string; from the config file, used in log messages and
444
secret: bytestring; sent verbatim (over TLS) to client
445
timeout: datetime.timedelta(); How long from last_checked_ok
446
until this client is disabled
447
extended_timeout: extra long timeout when secret has been sent
448
runtime_expansions: Allowed attributes for runtime expansion.
449
expires: datetime.datetime(); time (UTC) when a client will be
451
server_settings: The server_settings dict from main()
204
use_dbus: bool(); Whether to provide D-Bus interface and signals
205
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
454
runtime_expansions = ("approval_delay", "approval_duration",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
458
"last_enabled", "name", "timeout")
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
462
"checker": "fping -q -- %%(host)s",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
466
"approved_by_default": "True",
470
207
def timeout_milliseconds(self):
471
208
"Return the 'timeout' attribute in milliseconds"
472
return timedelta_to_milliseconds(self.timeout)
474
def extended_timeout_milliseconds(self):
475
"Return the 'extended_timeout' attribute in milliseconds"
476
return timedelta_to_milliseconds(self.extended_timeout)
209
return ((self.timeout.days * 24 * 60 * 60 * 1000)
210
+ (self.timeout.seconds * 1000)
211
+ (self.timeout.microseconds // 1000))
478
213
def interval_milliseconds(self):
479
214
"Return the 'interval' attribute in milliseconds"
480
return timedelta_to_milliseconds(self.interval)
482
def approval_delay_milliseconds(self):
483
return timedelta_to_milliseconds(self.approval_delay)
486
def config_parser(config):
487
"""Construct a new dict of client settings of this form:
488
{ client_name: {setting_name: value, ...}, ...}
489
with exceptions for any special settings as defined above.
490
NOTE: Must be a pure function. Must return the same result
491
value given the same arguments.
494
for client_name in config.sections():
495
section = dict(config.items(client_name))
496
client = settings[client_name] = {}
498
client["host"] = section["host"]
499
# Reformat values from string types to Python types
500
client["approved_by_default"] = config.getboolean(
501
client_name, "approved_by_default")
502
client["enabled"] = config.getboolean(client_name,
505
client["fingerprint"] = (section["fingerprint"].upper()
507
if "secret" in section:
508
client["secret"] = section["secret"].decode("base64")
509
elif "secfile" in section:
510
with open(os.path.expanduser(os.path.expandvars
511
(section["secfile"])),
513
client["secret"] = secfile.read()
515
raise TypeError("No secret or secfile for section {0}"
517
client["timeout"] = string_to_delta(section["timeout"])
518
client["extended_timeout"] = string_to_delta(
519
section["extended_timeout"])
520
client["interval"] = string_to_delta(section["interval"])
521
client["approval_delay"] = string_to_delta(
522
section["approval_delay"])
523
client["approval_duration"] = string_to_delta(
524
section["approval_duration"])
525
client["checker_command"] = section["checker"]
526
client["last_approval_request"] = None
527
client["last_checked_ok"] = None
528
client["last_checker_status"] = -2
532
def __init__(self, settings, name = None, server_settings=None):
215
return ((self.interval.days * 24 * 60 * 60 * 1000)
216
+ (self.interval.seconds * 1000)
217
+ (self.interval.microseconds // 1000))
219
def __init__(self, name = None, disable_hook=None, config=None,
221
"""Note: the 'checker' key in 'config' sets the
222
'checker_command' attribute and *not* the 'checker'
534
if server_settings is None:
536
self.server_settings = server_settings
537
# adding all client settings
538
for setting, value in settings.iteritems():
539
setattr(self, setting, value)
542
if not hasattr(self, "last_enabled"):
543
self.last_enabled = datetime.datetime.utcnow()
544
if not hasattr(self, "expires"):
545
self.expires = (datetime.datetime.utcnow()
548
self.last_enabled = None
551
logger.debug("Creating client %r", self.name)
227
logger.debug(u"Creating client %r", self.name)
228
self.use_dbus = use_dbus
230
self.dbus_object_path = (dbus.ObjectPath
232
+ self.name.replace(".", "_")))
233
dbus.service.Object.__init__(self, bus,
234
self.dbus_object_path)
552
235
# Uppercase and remove spaces from fingerprint for later
553
236
# comparison purposes with return value from the fingerprint()
555
logger.debug(" Fingerprint: %s", self.fingerprint)
556
self.created = settings.get("created",
557
datetime.datetime.utcnow())
559
# attributes specific for this server instance
238
self.fingerprint = (config["fingerprint"].upper()
240
logger.debug(u" Fingerprint: %s", self.fingerprint)
241
if "secret" in config:
242
self.secret = config["secret"].decode(u"base64")
243
elif "secfile" in config:
244
with closing(open(os.path.expanduser
246
(config["secfile"])))) as secfile:
247
self.secret = secfile.read()
249
raise TypeError(u"No secret or secfile for client %s"
251
self.host = config.get("host", "")
252
self.created = datetime.datetime.utcnow()
254
self.last_enabled = None
255
self.last_checked_ok = None
256
self.timeout = string_to_delta(config["timeout"])
257
self.interval = string_to_delta(config["interval"])
258
self.disable_hook = disable_hook
560
259
self.checker = None
561
260
self.checker_initiator_tag = None
562
261
self.disable_initiator_tag = None
563
262
self.checker_callback_tag = None
564
self.current_checker_command = None
566
self.approvals_pending = 0
567
self.changedstate = (multiprocessing_manager
568
.Condition(multiprocessing_manager
570
self.client_structure = [attr for attr in
571
self.__dict__.iterkeys()
572
if not attr.startswith("_")]
573
self.client_structure.append("client_structure")
575
for name, t in inspect.getmembers(type(self),
579
if not name.startswith("_"):
580
self.client_structure.append(name)
582
# Send notice to process children that client state has changed
583
def send_changedstate(self):
584
with self.changedstate:
585
self.changedstate.notify_all()
263
self.checker_command = config["checker"]
587
265
def enable(self):
588
266
"""Start this client's checker and timeout hooks"""
589
if getattr(self, "enabled", False):
592
self.expires = datetime.datetime.utcnow() + self.timeout
594
267
self.last_enabled = datetime.datetime.utcnow()
596
self.send_changedstate()
598
def disable(self, quiet=True):
599
"""Disable this client."""
600
if not getattr(self, "enabled", False):
603
logger.info("Disabling client %s", self.name)
604
if getattr(self, "disable_initiator_tag", None) is not None:
605
gobject.source_remove(self.disable_initiator_tag)
606
self.disable_initiator_tag = None
608
if getattr(self, "checker_initiator_tag", None) is not None:
609
gobject.source_remove(self.checker_initiator_tag)
610
self.checker_initiator_tag = None
614
self.send_changedstate()
615
# Do not run this again if called by a gobject.timeout_add
621
def init_checker(self):
622
268
# Schedule a new checker to be started an 'interval' from now,
623
269
# and every interval from then on.
624
if self.checker_initiator_tag is not None:
625
gobject.source_remove(self.checker_initiator_tag)
626
270
self.checker_initiator_tag = (gobject.timeout_add
627
271
(self.interval_milliseconds(),
628
272
self.start_checker))
273
# Also start a new checker *right now*.
629
275
# Schedule a disable() when 'timeout' has passed
630
if self.disable_initiator_tag is not None:
631
gobject.source_remove(self.disable_initiator_tag)
632
276
self.disable_initiator_tag = (gobject.timeout_add
633
277
(self.timeout_milliseconds(),
635
# Also start a new checker *right now*.
282
self.PropertyChanged(dbus.String(u"enabled"),
283
dbus.Boolean(True, variant_level=1))
284
self.PropertyChanged(dbus.String(u"last_enabled"),
285
(_datetime_to_dbus(self.last_enabled,
289
"""Disable this client."""
290
if not getattr(self, "enabled", False):
292
logger.info(u"Disabling client %s", self.name)
293
if getattr(self, "disable_initiator_tag", False):
294
gobject.source_remove(self.disable_initiator_tag)
295
self.disable_initiator_tag = None
296
if getattr(self, "checker_initiator_tag", False):
297
gobject.source_remove(self.checker_initiator_tag)
298
self.checker_initiator_tag = None
300
if self.disable_hook:
301
self.disable_hook(self)
305
self.PropertyChanged(dbus.String(u"enabled"),
306
dbus.Boolean(False, variant_level=1))
307
# Do not run this again if called by a gobject.timeout_add
311
self.disable_hook = None
638
314
def checker_callback(self, pid, condition, command):
639
315
"""The checker has completed, so take appropriate actions."""
640
316
self.checker_callback_tag = None
641
317
self.checker = None
642
if os.WIFEXITED(condition):
643
self.last_checker_status = os.WEXITSTATUS(condition)
644
if self.last_checker_status == 0:
645
logger.info("Checker for %(name)s succeeded",
649
logger.info("Checker for %(name)s failed",
652
self.last_checker_status = -1
653
logger.warning("Checker for %(name)s crashed?",
320
self.PropertyChanged(dbus.String(u"checker_running"),
321
dbus.Boolean(False, variant_level=1))
322
if (os.WIFEXITED(condition)
323
and (os.WEXITSTATUS(condition) == 0)):
324
logger.info(u"Checker for %(name)s succeeded",
328
self.CheckerCompleted(dbus.Boolean(True),
329
dbus.UInt16(condition),
330
dbus.String(command))
332
elif not os.WIFEXITED(condition):
333
logger.warning(u"Checker for %(name)s crashed?",
337
self.CheckerCompleted(dbus.Boolean(False),
338
dbus.UInt16(condition),
339
dbus.String(command))
341
logger.info(u"Checker for %(name)s failed",
345
self.CheckerCompleted(dbus.Boolean(False),
346
dbus.UInt16(condition),
347
dbus.String(command))
656
def checked_ok(self):
657
"""Assert that the client has been seen, alive and well."""
349
def bump_timeout(self):
350
"""Bump up the timeout for this client.
351
This should only be called when the client has been seen,
658
354
self.last_checked_ok = datetime.datetime.utcnow()
659
self.last_checker_status = 0
662
def bump_timeout(self, timeout=None):
663
"""Bump up the timeout for this client."""
665
timeout = self.timeout
666
if self.disable_initiator_tag is not None:
667
gobject.source_remove(self.disable_initiator_tag)
668
self.disable_initiator_tag = None
669
if getattr(self, "enabled", False):
670
self.disable_initiator_tag = (gobject.timeout_add
671
(timedelta_to_milliseconds
672
(timeout), self.disable))
673
self.expires = datetime.datetime.utcnow() + timeout
675
def need_approval(self):
676
self.last_approval_request = datetime.datetime.utcnow()
355
gobject.source_remove(self.disable_initiator_tag)
356
self.disable_initiator_tag = (gobject.timeout_add
357
(self.timeout_milliseconds(),
361
self.PropertyChanged(
362
dbus.String(u"last_checked_ok"),
363
(_datetime_to_dbus(self.last_checked_ok,
678
366
def start_checker(self):
679
367
"""Start a new checker subprocess if one is not running.
681
368
If a checker already exists, leave it running and do
683
370
# The reason for not killing a running checker is that if we
684
# did that, and if a checker (for some reason) started running
685
# slowly and taking more than 'interval' time, then the client
686
# would inevitably timeout, since no checker would get a
687
# chance to run to completion. If we instead leave running
371
# did that, then if a checker (for some reason) started
372
# running slowly and taking more than 'interval' time, the
373
# client would inevitably timeout, since no checker would get
374
# a chance to run to completion. If we instead leave running
688
375
# checkers alone, the checker would have to take more time
689
# than 'timeout' for the client to be disabled, which is as it
692
# If a checker exists, make sure it is not a zombie
694
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
695
except AttributeError:
697
except OSError as error:
698
if error.errno != errno.ECHILD:
702
logger.warning("Checker was a zombie")
703
gobject.source_remove(self.checker_callback_tag)
704
self.checker_callback(pid, status,
705
self.current_checker_command)
706
# Start a new checker if needed
376
# than 'timeout' for the client to be declared invalid, which
377
# is as it should be.
707
378
if self.checker is None:
708
# Escape attributes for the shell
709
escaped_attrs = dict(
710
(attr, re.escape(unicode(getattr(self, attr))))
712
self.runtime_expansions)
714
command = self.checker_command % escaped_attrs
715
except TypeError as error:
716
logger.error('Could not format string "%s"',
717
self.checker_command, exc_info=error)
718
return True # Try again later
719
self.current_checker_command = command
721
logger.info("Starting checker %r for %s",
380
# In case checker_command has exactly one % operator
381
command = self.checker_command % self.host
383
# Escape attributes for the shell
384
escaped_attrs = dict((key, re.escape(str(val)))
386
vars(self).iteritems())
388
command = self.checker_command % escaped_attrs
389
except TypeError, error:
390
logger.error(u'Could not format string "%s":'
391
u' %s', self.checker_command, error)
392
return True # Try again later
394
logger.info(u"Starting checker %r for %s",
722
395
command, self.name)
723
396
# We don't need to redirect stdout and stderr, since
724
397
# in normal mode, that is already done by daemon(),
725
398
# and in debug mode we don't want to. (Stdin is
726
399
# always replaced by /dev/null.)
727
# The exception is when not debugging but nevertheless
728
# running in the foreground; use the previously
731
if (not self.server_settings["debug"]
732
and self.server_settings["foreground"]):
733
popen_args.update({"stdout": wnull,
735
400
self.checker = subprocess.Popen(command,
739
except OSError as error:
740
logger.error("Failed to start subprocess",
743
self.checker_callback_tag = (gobject.child_watch_add
745
self.checker_callback,
747
# The checker may have completed before the gobject
748
# watch was added. Check for this.
750
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
751
except OSError as error:
752
if error.errno == errno.ECHILD:
753
# This should never happen
754
logger.error("Child process vanished",
759
gobject.source_remove(self.checker_callback_tag)
760
self.checker_callback(pid, status, command)
405
self.CheckerStarted(command)
406
self.PropertyChanged(
407
dbus.String("checker_running"),
408
dbus.Boolean(True, variant_level=1))
409
self.checker_callback_tag = (gobject.child_watch_add
411
self.checker_callback,
413
except OSError, error:
414
logger.error(u"Failed to start subprocess: %s",
761
416
# Re-run this periodically if run by gobject.timeout_add
768
423
self.checker_callback_tag = None
769
424
if getattr(self, "checker", None) is None:
771
logger.debug("Stopping checker for %(name)s", vars(self))
426
logger.debug(u"Stopping checker for %(name)s", vars(self))
773
self.checker.terminate()
428
os.kill(self.checker.pid, signal.SIGTERM)
775
430
#if self.checker.poll() is None:
776
# self.checker.kill()
777
except OSError as error:
431
# os.kill(self.checker.pid, signal.SIGKILL)
432
except OSError, error:
778
433
if error.errno != errno.ESRCH: # No such process
780
435
self.checker = None
783
def dbus_service_property(dbus_interface, signature="v",
784
access="readwrite", byte_arrays=False):
785
"""Decorators for marking methods of a DBusObjectWithProperties to
786
become properties on the D-Bus.
788
The decorated method will be called with no arguments by "Get"
789
and with one argument by "Set".
791
The parameters, where they are supported, are the same as
792
dbus.service.method, except there is only "signature", since the
793
type from Get() and the type sent to Set() is the same.
795
# Encoding deeply encoded byte arrays is not supported yet by the
796
# "Set" method, so we fail early here:
797
if byte_arrays and signature != "ay":
798
raise ValueError("Byte arrays not supported for non-'ay'"
799
" signature {0!r}".format(signature))
801
func._dbus_is_property = True
802
func._dbus_interface = dbus_interface
803
func._dbus_signature = signature
804
func._dbus_access = access
805
func._dbus_name = func.__name__
806
if func._dbus_name.endswith("_dbus_property"):
807
func._dbus_name = func._dbus_name[:-14]
808
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
813
def dbus_interface_annotations(dbus_interface):
814
"""Decorator for marking functions returning interface annotations
818
@dbus_interface_annotations("org.example.Interface")
819
def _foo(self): # Function name does not matter
820
return {"org.freedesktop.DBus.Deprecated": "true",
821
"org.freedesktop.DBus.Property.EmitsChangedSignal":
825
func._dbus_is_interface = True
826
func._dbus_interface = dbus_interface
827
func._dbus_name = dbus_interface
832
def dbus_annotations(annotations):
833
"""Decorator to annotate D-Bus methods, signals or properties
836
@dbus_service_property("org.example.Interface", signature="b",
838
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
839
"org.freedesktop.DBus.Property."
840
"EmitsChangedSignal": "false"})
841
def Property_dbus_property(self):
842
return dbus.Boolean(False)
845
func._dbus_annotations = annotations
850
class DBusPropertyException(dbus.exceptions.DBusException):
851
"""A base class for D-Bus property-related exceptions
853
def __unicode__(self):
854
return unicode(str(self))
857
class DBusPropertyAccessException(DBusPropertyException):
858
"""A property's access permissions disallows an operation.
863
class DBusPropertyNotFound(DBusPropertyException):
864
"""An attempt was made to access a non-existing property.
869
class DBusObjectWithProperties(dbus.service.Object):
870
"""A D-Bus object with properties.
872
Classes inheriting from this can use the dbus_service_property
873
decorator to expose methods as D-Bus properties. It exposes the
874
standard Get(), Set(), and GetAll() methods on the D-Bus.
878
def _is_dbus_thing(thing):
879
"""Returns a function testing if an attribute is a D-Bus thing
881
If called like _is_dbus_thing("method") it returns a function
882
suitable for use as predicate to inspect.getmembers().
884
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
887
def _get_all_dbus_things(self, thing):
888
"""Returns a generator of (name, attribute) pairs
890
return ((getattr(athing.__get__(self), "_dbus_name",
892
athing.__get__(self))
893
for cls in self.__class__.__mro__
895
inspect.getmembers(cls,
896
self._is_dbus_thing(thing)))
898
def _get_dbus_property(self, interface_name, property_name):
899
"""Returns a bound method if one exists which is a D-Bus
900
property with the specified name and interface.
902
for cls in self.__class__.__mro__:
903
for name, value in (inspect.getmembers
905
self._is_dbus_thing("property"))):
906
if (value._dbus_name == property_name
907
and value._dbus_interface == interface_name):
908
return value.__get__(self)
911
raise DBusPropertyNotFound(self.dbus_object_path + ":"
912
+ interface_name + "."
915
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
917
def Get(self, interface_name, property_name):
918
"""Standard D-Bus property Get() method, see D-Bus standard.
920
prop = self._get_dbus_property(interface_name, property_name)
921
if prop._dbus_access == "write":
922
raise DBusPropertyAccessException(property_name)
924
if not hasattr(value, "variant_level"):
926
return type(value)(value, variant_level=value.variant_level+1)
928
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
929
def Set(self, interface_name, property_name, value):
930
"""Standard D-Bus property Set() method, see D-Bus standard.
932
prop = self._get_dbus_property(interface_name, property_name)
933
if prop._dbus_access == "read":
934
raise DBusPropertyAccessException(property_name)
935
if prop._dbus_get_args_options["byte_arrays"]:
936
# The byte_arrays option is not supported yet on
937
# signatures other than "ay".
938
if prop._dbus_signature != "ay":
939
raise ValueError("Byte arrays not supported for non-"
940
"'ay' signature {0!r}"
941
.format(prop._dbus_signature))
942
value = dbus.ByteArray(b''.join(chr(byte)
946
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
947
out_signature="a{sv}")
948
def GetAll(self, interface_name):
949
"""Standard D-Bus property GetAll() method, see D-Bus
952
Note: Will not include properties with access="write".
955
for name, prop in self._get_all_dbus_things("property"):
957
and interface_name != prop._dbus_interface):
958
# Interface non-empty but did not match
960
# Ignore write-only properties
961
if prop._dbus_access == "write":
964
if not hasattr(value, "variant_level"):
965
properties[name] = value
967
properties[name] = type(value)(value, variant_level=
968
value.variant_level+1)
969
return dbus.Dictionary(properties, signature="sv")
971
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
973
path_keyword='object_path',
974
connection_keyword='connection')
975
def Introspect(self, object_path, connection):
976
"""Overloading of standard D-Bus method.
978
Inserts property tags and interface annotation tags.
980
xmlstring = dbus.service.Object.Introspect(self, object_path,
983
document = xml.dom.minidom.parseString(xmlstring)
984
def make_tag(document, name, prop):
985
e = document.createElement("property")
986
e.setAttribute("name", name)
987
e.setAttribute("type", prop._dbus_signature)
988
e.setAttribute("access", prop._dbus_access)
990
for if_tag in document.getElementsByTagName("interface"):
992
for tag in (make_tag(document, name, prop)
994
in self._get_all_dbus_things("property")
995
if prop._dbus_interface
996
== if_tag.getAttribute("name")):
997
if_tag.appendChild(tag)
998
# Add annotation tags
999
for typ in ("method", "signal", "property"):
1000
for tag in if_tag.getElementsByTagName(typ):
1002
for name, prop in (self.
1003
_get_all_dbus_things(typ)):
1004
if (name == tag.getAttribute("name")
1005
and prop._dbus_interface
1006
== if_tag.getAttribute("name")):
1007
annots.update(getattr
1009
"_dbus_annotations",
1011
for name, value in annots.iteritems():
1012
ann_tag = document.createElement(
1014
ann_tag.setAttribute("name", name)
1015
ann_tag.setAttribute("value", value)
1016
tag.appendChild(ann_tag)
1017
# Add interface annotation tags
1018
for annotation, value in dict(
1019
itertools.chain.from_iterable(
1020
annotations().iteritems()
1021
for name, annotations in
1022
self._get_all_dbus_things("interface")
1023
if name == if_tag.getAttribute("name")
1025
ann_tag = document.createElement("annotation")
1026
ann_tag.setAttribute("name", annotation)
1027
ann_tag.setAttribute("value", value)
1028
if_tag.appendChild(ann_tag)
1029
# Add the names to the return values for the
1030
# "org.freedesktop.DBus.Properties" methods
1031
if (if_tag.getAttribute("name")
1032
== "org.freedesktop.DBus.Properties"):
1033
for cn in if_tag.getElementsByTagName("method"):
1034
if cn.getAttribute("name") == "Get":
1035
for arg in cn.getElementsByTagName("arg"):
1036
if (arg.getAttribute("direction")
1038
arg.setAttribute("name", "value")
1039
elif cn.getAttribute("name") == "GetAll":
1040
for arg in cn.getElementsByTagName("arg"):
1041
if (arg.getAttribute("direction")
1043
arg.setAttribute("name", "props")
1044
xmlstring = document.toxml("utf-8")
1046
except (AttributeError, xml.dom.DOMException,
1047
xml.parsers.expat.ExpatError) as error:
1048
logger.error("Failed to override Introspection method",
1053
def datetime_to_dbus(dt, variant_level=0):
1054
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1056
return dbus.String("", variant_level = variant_level)
1057
return dbus.String(dt.isoformat(),
1058
variant_level=variant_level)
1061
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1062
"""A class decorator; applied to a subclass of
1063
dbus.service.Object, it will add alternate D-Bus attributes with
1064
interface names according to the "alt_interface_names" mapping.
1067
@alternate_dbus_interfaces({"org.example.Interface":
1068
"net.example.AlternateInterface"})
1069
class SampleDBusObject(dbus.service.Object):
1070
@dbus.service.method("org.example.Interface")
1071
def SampleDBusMethod():
1074
The above "SampleDBusMethod" on "SampleDBusObject" will be
1075
reachable via two interfaces: "org.example.Interface" and
1076
"net.example.AlternateInterface", the latter of which will have
1077
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1078
"true", unless "deprecate" is passed with a False value.
1080
This works for methods and signals, and also for D-Bus properties
1081
(from DBusObjectWithProperties) and interfaces (from the
1082
dbus_interface_annotations decorator).
1085
for orig_interface_name, alt_interface_name in (
1086
alt_interface_names.iteritems()):
1088
interface_names = set()
1089
# Go though all attributes of the class
1090
for attrname, attribute in inspect.getmembers(cls):
1091
# Ignore non-D-Bus attributes, and D-Bus attributes
1092
# with the wrong interface name
1093
if (not hasattr(attribute, "_dbus_interface")
1094
or not attribute._dbus_interface
1095
.startswith(orig_interface_name)):
1097
# Create an alternate D-Bus interface name based on
1099
alt_interface = (attribute._dbus_interface
1100
.replace(orig_interface_name,
1101
alt_interface_name))
1102
interface_names.add(alt_interface)
1103
# Is this a D-Bus signal?
1104
if getattr(attribute, "_dbus_is_signal", False):
1105
# Extract the original non-method undecorated
1106
# function by black magic
1107
nonmethod_func = (dict(
1108
zip(attribute.func_code.co_freevars,
1109
attribute.__closure__))["func"]
1111
# Create a new, but exactly alike, function
1112
# object, and decorate it to be a new D-Bus signal
1113
# with the alternate D-Bus interface name
1114
new_function = (dbus.service.signal
1116
attribute._dbus_signature)
1117
(types.FunctionType(
1118
nonmethod_func.func_code,
1119
nonmethod_func.func_globals,
1120
nonmethod_func.func_name,
1121
nonmethod_func.func_defaults,
1122
nonmethod_func.func_closure)))
1123
# Copy annotations, if any
1125
new_function._dbus_annotations = (
1126
dict(attribute._dbus_annotations))
1127
except AttributeError:
1129
# Define a creator of a function to call both the
1130
# original and alternate functions, so both the
1131
# original and alternate signals gets sent when
1132
# the function is called
1133
def fixscope(func1, func2):
1134
"""This function is a scope container to pass
1135
func1 and func2 to the "call_both" function
1136
outside of its arguments"""
1137
def call_both(*args, **kwargs):
1138
"""This function will emit two D-Bus
1139
signals by calling func1 and func2"""
1140
func1(*args, **kwargs)
1141
func2(*args, **kwargs)
1143
# Create the "call_both" function and add it to
1145
attr[attrname] = fixscope(attribute, new_function)
1146
# Is this a D-Bus method?
1147
elif getattr(attribute, "_dbus_is_method", False):
1148
# Create a new, but exactly alike, function
1149
# object. Decorate it to be a new D-Bus method
1150
# with the alternate D-Bus interface name. Add it
1152
attr[attrname] = (dbus.service.method
1154
attribute._dbus_in_signature,
1155
attribute._dbus_out_signature)
1157
(attribute.func_code,
1158
attribute.func_globals,
1159
attribute.func_name,
1160
attribute.func_defaults,
1161
attribute.func_closure)))
1162
# Copy annotations, if any
1164
attr[attrname]._dbus_annotations = (
1165
dict(attribute._dbus_annotations))
1166
except AttributeError:
1168
# Is this a D-Bus property?
1169
elif getattr(attribute, "_dbus_is_property", False):
1170
# Create a new, but exactly alike, function
1171
# object, and decorate it to be a new D-Bus
1172
# property with the alternate D-Bus interface
1173
# name. Add it to the class.
1174
attr[attrname] = (dbus_service_property
1176
attribute._dbus_signature,
1177
attribute._dbus_access,
1179
._dbus_get_args_options
1182
(attribute.func_code,
1183
attribute.func_globals,
1184
attribute.func_name,
1185
attribute.func_defaults,
1186
attribute.func_closure)))
1187
# Copy annotations, if any
1189
attr[attrname]._dbus_annotations = (
1190
dict(attribute._dbus_annotations))
1191
except AttributeError:
1193
# Is this a D-Bus interface?
1194
elif getattr(attribute, "_dbus_is_interface", False):
1195
# Create a new, but exactly alike, function
1196
# object. Decorate it to be a new D-Bus interface
1197
# with the alternate D-Bus interface name. Add it
1199
attr[attrname] = (dbus_interface_annotations
1202
(attribute.func_code,
1203
attribute.func_globals,
1204
attribute.func_name,
1205
attribute.func_defaults,
1206
attribute.func_closure)))
1208
# Deprecate all alternate interfaces
1209
iname="_AlternateDBusNames_interface_annotation{0}"
1210
for interface_name in interface_names:
1211
@dbus_interface_annotations(interface_name)
1213
return { "org.freedesktop.DBus.Deprecated":
1215
# Find an unused name
1216
for aname in (iname.format(i)
1217
for i in itertools.count()):
1218
if aname not in attr:
1222
# Replace the class with a new subclass of it with
1223
# methods, signals, etc. as created above.
1224
cls = type(b"{0}Alternate".format(cls.__name__),
1230
@alternate_dbus_interfaces({"se.recompile.Mandos":
1231
"se.bsnet.fukt.Mandos"})
1232
class ClientDBus(Client, DBusObjectWithProperties):
1233
"""A Client class using D-Bus
1236
dbus_object_path: dbus.ObjectPath
1237
bus: dbus.SystemBus()
1240
runtime_expansions = (Client.runtime_expansions
1241
+ ("dbus_object_path",))
1243
# dbus.service.Object doesn't use super(), so we can't either.
1245
def __init__(self, bus = None, *args, **kwargs):
1247
Client.__init__(self, *args, **kwargs)
1248
# Only now, when this client is initialized, can it show up on
1250
client_object_name = unicode(self.name).translate(
1251
{ord("."): ord("_"),
1252
ord("-"): ord("_")})
1253
self.dbus_object_path = (dbus.ObjectPath
1254
("/clients/" + client_object_name))
1255
DBusObjectWithProperties.__init__(self, self.bus,
1256
self.dbus_object_path)
1258
def notifychangeproperty(transform_func,
1259
dbus_name, type_func=lambda x: x,
1261
""" Modify a variable so that it's a property which announces
1262
its changes to DBus.
1264
transform_fun: Function that takes a value and a variant_level
1265
and transforms it to a D-Bus type.
1266
dbus_name: D-Bus name of the variable
1267
type_func: Function that transform the value before sending it
1268
to the D-Bus. Default: no transform
1269
variant_level: D-Bus variant level. Default: 1
1271
attrname = "_{0}".format(dbus_name)
1272
def setter(self, value):
1273
if hasattr(self, "dbus_object_path"):
1274
if (not hasattr(self, attrname) or
1275
type_func(getattr(self, attrname, None))
1276
!= type_func(value)):
1277
dbus_value = transform_func(type_func(value),
1280
self.PropertyChanged(dbus.String(dbus_name),
1282
setattr(self, attrname, value)
1284
return property(lambda self: getattr(self, attrname), setter)
1286
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1287
approvals_pending = notifychangeproperty(dbus.Boolean,
1290
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1291
last_enabled = notifychangeproperty(datetime_to_dbus,
1293
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1294
type_func = lambda checker:
1295
checker is not None)
1296
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1298
last_checker_status = notifychangeproperty(dbus.Int16,
1299
"LastCheckerStatus")
1300
last_approval_request = notifychangeproperty(
1301
datetime_to_dbus, "LastApprovalRequest")
1302
approved_by_default = notifychangeproperty(dbus.Boolean,
1303
"ApprovedByDefault")
1304
approval_delay = notifychangeproperty(dbus.UInt64,
1307
timedelta_to_milliseconds)
1308
approval_duration = notifychangeproperty(
1309
dbus.UInt64, "ApprovalDuration",
1310
type_func = timedelta_to_milliseconds)
1311
host = notifychangeproperty(dbus.String, "Host")
1312
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1314
timedelta_to_milliseconds)
1315
extended_timeout = notifychangeproperty(
1316
dbus.UInt64, "ExtendedTimeout",
1317
type_func = timedelta_to_milliseconds)
1318
interval = notifychangeproperty(dbus.UInt64,
1321
timedelta_to_milliseconds)
1322
checker_command = notifychangeproperty(dbus.String, "Checker")
1324
del notifychangeproperty
1326
def __del__(self, *args, **kwargs):
1328
self.remove_from_connection()
1331
if hasattr(DBusObjectWithProperties, "__del__"):
1332
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1333
Client.__del__(self, *args, **kwargs)
1335
def checker_callback(self, pid, condition, command,
1337
self.checker_callback_tag = None
1339
if os.WIFEXITED(condition):
1340
exitstatus = os.WEXITSTATUS(condition)
1342
self.CheckerCompleted(dbus.Int16(exitstatus),
1343
dbus.Int64(condition),
1344
dbus.String(command))
437
self.PropertyChanged(dbus.String(u"checker_running"),
438
dbus.Boolean(False, variant_level=1))
440
def still_valid(self):
441
"""Has the timeout not yet passed for this client?"""
442
if not getattr(self, "enabled", False):
444
now = datetime.datetime.utcnow()
445
if self.last_checked_ok is None:
446
return now < (self.created + self.timeout)
1347
self.CheckerCompleted(dbus.Int16(-1),
1348
dbus.Int64(condition),
1349
dbus.String(command))
1351
return Client.checker_callback(self, pid, condition, command,
1354
def start_checker(self, *args, **kwargs):
1355
old_checker_pid = getattr(self.checker, "pid", None)
1356
r = Client.start_checker(self, *args, **kwargs)
1357
# Only if new checker process was started
1358
if (self.checker is not None
1359
and old_checker_pid != self.checker.pid):
1361
self.CheckerStarted(self.current_checker_command)
1364
def _reset_approved(self):
1365
self.approved = None
1368
def approve(self, value=True):
1369
self.approved = value
1370
gobject.timeout_add(timedelta_to_milliseconds
1371
(self.approval_duration),
1372
self._reset_approved)
1373
self.send_changedstate()
1375
## D-Bus methods, signals & properties
1376
_interface = "se.recompile.Mandos.Client"
1380
@dbus_interface_annotations(_interface)
1382
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
448
return now < (self.last_checked_ok + self.timeout)
450
## D-Bus methods & signals
451
_interface = u"org.mandos_system.Mandos.Client"
453
# BumpTimeout - method
454
BumpTimeout = dbus.service.method(_interface)(bump_timeout)
455
BumpTimeout.__name__ = "BumpTimeout"
1387
457
# CheckerCompleted - signal
1388
@dbus.service.signal(_interface, signature="nxs")
1389
def CheckerCompleted(self, exitcode, waitstatus, command):
458
@dbus.service.signal(_interface, signature="bqs")
459
def CheckerCompleted(self, success, condition, command):
1456
579
# StopChecker - method
1457
@dbus.service.method(_interface)
1458
def StopChecker(self):
1463
# ApprovalPending - property
1464
@dbus_service_property(_interface, signature="b", access="read")
1465
def ApprovalPending_dbus_property(self):
1466
return dbus.Boolean(bool(self.approvals_pending))
1468
# ApprovedByDefault - property
1469
@dbus_service_property(_interface, signature="b",
1471
def ApprovedByDefault_dbus_property(self, value=None):
1472
if value is None: # get
1473
return dbus.Boolean(self.approved_by_default)
1474
self.approved_by_default = bool(value)
1476
# ApprovalDelay - property
1477
@dbus_service_property(_interface, signature="t",
1479
def ApprovalDelay_dbus_property(self, value=None):
1480
if value is None: # get
1481
return dbus.UInt64(self.approval_delay_milliseconds())
1482
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1484
# ApprovalDuration - property
1485
@dbus_service_property(_interface, signature="t",
1487
def ApprovalDuration_dbus_property(self, value=None):
1488
if value is None: # get
1489
return dbus.UInt64(timedelta_to_milliseconds(
1490
self.approval_duration))
1491
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1494
@dbus_service_property(_interface, signature="s", access="read")
1495
def Name_dbus_property(self):
1496
return dbus.String(self.name)
1498
# Fingerprint - property
1499
@dbus_service_property(_interface, signature="s", access="read")
1500
def Fingerprint_dbus_property(self):
1501
return dbus.String(self.fingerprint)
1504
@dbus_service_property(_interface, signature="s",
1506
def Host_dbus_property(self, value=None):
1507
if value is None: # get
1508
return dbus.String(self.host)
1509
self.host = unicode(value)
1511
# Created - property
1512
@dbus_service_property(_interface, signature="s", access="read")
1513
def Created_dbus_property(self):
1514
return datetime_to_dbus(self.created)
1516
# LastEnabled - property
1517
@dbus_service_property(_interface, signature="s", access="read")
1518
def LastEnabled_dbus_property(self):
1519
return datetime_to_dbus(self.last_enabled)
1521
# Enabled - property
1522
@dbus_service_property(_interface, signature="b",
1524
def Enabled_dbus_property(self, value=None):
1525
if value is None: # get
1526
return dbus.Boolean(self.enabled)
1532
# LastCheckedOK - property
1533
@dbus_service_property(_interface, signature="s",
1535
def LastCheckedOK_dbus_property(self, value=None):
1536
if value is not None:
1539
return datetime_to_dbus(self.last_checked_ok)
1541
# LastCheckerStatus - property
1542
@dbus_service_property(_interface, signature="n",
1544
def LastCheckerStatus_dbus_property(self):
1545
return dbus.Int16(self.last_checker_status)
1547
# Expires - property
1548
@dbus_service_property(_interface, signature="s", access="read")
1549
def Expires_dbus_property(self):
1550
return datetime_to_dbus(self.expires)
1552
# LastApprovalRequest - property
1553
@dbus_service_property(_interface, signature="s", access="read")
1554
def LastApprovalRequest_dbus_property(self):
1555
return datetime_to_dbus(self.last_approval_request)
1557
# Timeout - property
1558
@dbus_service_property(_interface, signature="t",
1560
def Timeout_dbus_property(self, value=None):
1561
if value is None: # get
1562
return dbus.UInt64(self.timeout_milliseconds())
1563
old_timeout = self.timeout
1564
self.timeout = datetime.timedelta(0, 0, 0, value)
1565
# Reschedule disabling
1567
now = datetime.datetime.utcnow()
1568
self.expires += self.timeout - old_timeout
1569
if self.expires <= now:
1570
# The timeout has passed
1573
if (getattr(self, "disable_initiator_tag", None)
1576
gobject.source_remove(self.disable_initiator_tag)
1577
self.disable_initiator_tag = (
1578
gobject.timeout_add(
1579
timedelta_to_milliseconds(self.expires - now),
1582
# ExtendedTimeout - property
1583
@dbus_service_property(_interface, signature="t",
1585
def ExtendedTimeout_dbus_property(self, value=None):
1586
if value is None: # get
1587
return dbus.UInt64(self.extended_timeout_milliseconds())
1588
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1590
# Interval - property
1591
@dbus_service_property(_interface, signature="t",
1593
def Interval_dbus_property(self, value=None):
1594
if value is None: # get
1595
return dbus.UInt64(self.interval_milliseconds())
1596
self.interval = datetime.timedelta(0, 0, 0, value)
1597
if getattr(self, "checker_initiator_tag", None) is None:
1600
# Reschedule checker run
1601
gobject.source_remove(self.checker_initiator_tag)
1602
self.checker_initiator_tag = (gobject.timeout_add
1603
(value, self.start_checker))
1604
self.start_checker() # Start one now, too
1606
# Checker - property
1607
@dbus_service_property(_interface, signature="s",
1609
def Checker_dbus_property(self, value=None):
1610
if value is None: # get
1611
return dbus.String(self.checker_command)
1612
self.checker_command = unicode(value)
1614
# CheckerRunning - property
1615
@dbus_service_property(_interface, signature="b",
1617
def CheckerRunning_dbus_property(self, value=None):
1618
if value is None: # get
1619
return dbus.Boolean(self.checker is not None)
1621
self.start_checker()
1625
# ObjectPath - property
1626
@dbus_service_property(_interface, signature="o", access="read")
1627
def ObjectPath_dbus_property(self):
1628
return self.dbus_object_path # is already a dbus.ObjectPath
1631
@dbus_service_property(_interface, signature="ay",
1632
access="write", byte_arrays=True)
1633
def Secret_dbus_property(self, value):
1634
self.secret = str(value)
580
StopChecker = dbus.service.method(_interface)(stop_checker)
581
StopChecker.__name__ = "StopChecker"
1639
class ProxyClient(object):
1640
def __init__(self, child_pipe, fpr, address):
1641
self._pipe = child_pipe
1642
self._pipe.send(('init', fpr, address))
1643
if not self._pipe.recv():
1646
def __getattribute__(self, name):
1648
return super(ProxyClient, self).__getattribute__(name)
1649
self._pipe.send(('getattr', name))
1650
data = self._pipe.recv()
1651
if data[0] == 'data':
1653
if data[0] == 'function':
1654
def func(*args, **kwargs):
1655
self._pipe.send(('funcall', name, args, kwargs))
1656
return self._pipe.recv()[1]
1659
def __setattr__(self, name, value):
1661
return super(ProxyClient, self).__setattr__(name, value)
1662
self._pipe.send(('setattr', name, value))
1665
class ClientHandler(socketserver.BaseRequestHandler, object):
1666
"""A class to handle client connections.
1668
Instantiated once for each connection to handle it.
586
def peer_certificate(session):
587
"Return the peer's OpenPGP certificate as a bytestring"
588
# If not an OpenPGP certificate...
589
if (gnutls.library.functions
590
.gnutls_certificate_type_get(session._c_object)
591
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
592
# ...do the normal thing
593
return session.peer_certificate
594
list_size = ctypes.c_uint()
595
cert_list = (gnutls.library.functions
596
.gnutls_certificate_get_peers
597
(session._c_object, ctypes.byref(list_size)))
598
if list_size.value == 0:
601
return ctypes.string_at(cert.data, cert.size)
604
def fingerprint(openpgp):
605
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
606
# New GnuTLS "datum" with the OpenPGP public key
607
datum = (gnutls.library.types
608
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
611
ctypes.c_uint(len(openpgp))))
612
# New empty GnuTLS certificate
613
crt = gnutls.library.types.gnutls_openpgp_crt_t()
614
(gnutls.library.functions
615
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
616
# Import the OpenPGP public key into the certificate
617
(gnutls.library.functions
618
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
619
gnutls.library.constants
620
.GNUTLS_OPENPGP_FMT_RAW))
621
# Verify the self signature in the key
622
crtverify = ctypes.c_uint()
623
(gnutls.library.functions
624
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
625
if crtverify.value != 0:
626
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
627
raise gnutls.errors.CertificateSecurityError("Verify failed")
628
# New buffer for the fingerprint
629
buf = ctypes.create_string_buffer(20)
630
buf_len = ctypes.c_size_t()
631
# Get the fingerprint from the certificate into the buffer
632
(gnutls.library.functions
633
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
634
ctypes.byref(buf_len)))
635
# Deinit the certificate
636
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
637
# Convert the buffer to a Python bytestring
638
fpr = ctypes.string_at(buf, buf_len.value)
639
# Convert the bytestring to hexadecimal notation
640
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
644
class TCP_handler(SocketServer.BaseRequestHandler, object):
645
"""A TCP request handler class.
646
Instantiated by IPv6_TCPServer for each request to handle it.
1669
647
Note: This will run in its own forked process."""
1671
649
def handle(self):
1672
with contextlib.closing(self.server.child_pipe) as child_pipe:
1673
logger.info("TCP connection from: %s",
1674
unicode(self.client_address))
1675
logger.debug("Pipe FD: %d",
1676
self.server.child_pipe.fileno())
1678
session = (gnutls.connection
1679
.ClientSession(self.request,
1681
.X509Credentials()))
1683
# Note: gnutls.connection.X509Credentials is really a
1684
# generic GnuTLS certificate credentials object so long as
1685
# no X.509 keys are added to it. Therefore, we can use it
1686
# here despite using OpenPGP certificates.
1688
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1689
# "+AES-256-CBC", "+SHA1",
1690
# "+COMP-NULL", "+CTYPE-OPENPGP",
1692
# Use a fallback default, since this MUST be set.
1693
priority = self.server.gnutls_priority
1694
if priority is None:
1696
(gnutls.library.functions
1697
.gnutls_priority_set_direct(session._c_object,
1700
# Start communication using the Mandos protocol
1701
# Get protocol number
1702
line = self.request.makefile().readline()
1703
logger.debug("Protocol version: %r", line)
1705
if int(line.strip().split()[0]) > 1:
1706
raise RuntimeError(line)
1707
except (ValueError, IndexError, RuntimeError) as error:
1708
logger.error("Unknown protocol version: %s", error)
1711
# Start GnuTLS connection
1714
except gnutls.errors.GNUTLSError as error:
1715
logger.warning("Handshake failed: %s", error)
1716
# Do not run session.bye() here: the session is not
1717
# established. Just abandon the request.
1719
logger.debug("Handshake succeeded")
1721
approval_required = False
1724
fpr = self.fingerprint(self.peer_certificate
1727
gnutls.errors.GNUTLSError) as error:
1728
logger.warning("Bad certificate: %s", error)
1730
logger.debug("Fingerprint: %s", fpr)
1733
client = ProxyClient(child_pipe, fpr,
1734
self.client_address)
1738
if client.approval_delay:
1739
delay = client.approval_delay
1740
client.approvals_pending += 1
1741
approval_required = True
1744
if not client.enabled:
1745
logger.info("Client %s is disabled",
1747
if self.server.use_dbus:
1749
client.Rejected("Disabled")
1752
if client.approved or not client.approval_delay:
1753
#We are approved or approval is disabled
1755
elif client.approved is None:
1756
logger.info("Client %s needs approval",
1758
if self.server.use_dbus:
1760
client.NeedApproval(
1761
client.approval_delay_milliseconds(),
1762
client.approved_by_default)
1764
logger.warning("Client %s was not approved",
1766
if self.server.use_dbus:
1768
client.Rejected("Denied")
1771
#wait until timeout or approved
1772
time = datetime.datetime.now()
1773
client.changedstate.acquire()
1774
client.changedstate.wait(
1775
float(timedelta_to_milliseconds(delay)
1777
client.changedstate.release()
1778
time2 = datetime.datetime.now()
1779
if (time2 - time) >= delay:
1780
if not client.approved_by_default:
1781
logger.warning("Client %s timed out while"
1782
" waiting for approval",
1784
if self.server.use_dbus:
1786
client.Rejected("Approval timed out")
1791
delay -= time2 - time
1794
while sent_size < len(client.secret):
1796
sent = session.send(client.secret[sent_size:])
1797
except gnutls.errors.GNUTLSError as error:
1798
logger.warning("gnutls send failed",
1801
logger.debug("Sent: %d, remaining: %d",
1802
sent, len(client.secret)
1803
- (sent_size + sent))
1806
logger.info("Sending secret to %s", client.name)
1807
# bump the timeout using extended_timeout
1808
client.bump_timeout(client.extended_timeout)
1809
if self.server.use_dbus:
1814
if approval_required:
1815
client.approvals_pending -= 1
1818
except gnutls.errors.GNUTLSError as error:
1819
logger.warning("GnuTLS bye failed",
1823
def peer_certificate(session):
1824
"Return the peer's OpenPGP certificate as a bytestring"
1825
# If not an OpenPGP certificate...
1826
if (gnutls.library.functions
1827
.gnutls_certificate_type_get(session._c_object)
1828
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1829
# ...do the normal thing
1830
return session.peer_certificate
1831
list_size = ctypes.c_uint(1)
1832
cert_list = (gnutls.library.functions
1833
.gnutls_certificate_get_peers
1834
(session._c_object, ctypes.byref(list_size)))
1835
if not bool(cert_list) and list_size.value != 0:
1836
raise gnutls.errors.GNUTLSError("error getting peer"
1838
if list_size.value == 0:
1841
return ctypes.string_at(cert.data, cert.size)
1844
def fingerprint(openpgp):
1845
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1846
# New GnuTLS "datum" with the OpenPGP public key
1847
datum = (gnutls.library.types
1848
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1851
ctypes.c_uint(len(openpgp))))
1852
# New empty GnuTLS certificate
1853
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1854
(gnutls.library.functions
1855
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1856
# Import the OpenPGP public key into the certificate
1857
(gnutls.library.functions
1858
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1859
gnutls.library.constants
1860
.GNUTLS_OPENPGP_FMT_RAW))
1861
# Verify the self signature in the key
1862
crtverify = ctypes.c_uint()
1863
(gnutls.library.functions
1864
.gnutls_openpgp_crt_verify_self(crt, 0,
1865
ctypes.byref(crtverify)))
1866
if crtverify.value != 0:
1867
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1868
raise (gnutls.errors.CertificateSecurityError
1870
# New buffer for the fingerprint
1871
buf = ctypes.create_string_buffer(20)
1872
buf_len = ctypes.c_size_t()
1873
# Get the fingerprint from the certificate into the buffer
1874
(gnutls.library.functions
1875
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1876
ctypes.byref(buf_len)))
1877
# Deinit the certificate
1878
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1879
# Convert the buffer to a Python bytestring
1880
fpr = ctypes.string_at(buf, buf_len.value)
1881
# Convert the bytestring to hexadecimal notation
1882
hex_fpr = binascii.hexlify(fpr).upper()
1886
class MultiprocessingMixIn(object):
1887
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1888
def sub_process_main(self, request, address):
1890
self.finish_request(request, address)
1892
self.handle_error(request, address)
1893
self.close_request(request)
1895
def process_request(self, request, address):
1896
"""Start a new process to process the request."""
1897
proc = multiprocessing.Process(target = self.sub_process_main,
1898
args = (request, address))
1903
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1904
""" adds a pipe to the MixIn """
1905
def process_request(self, request, client_address):
1906
"""Overrides and wraps the original process_request().
1908
This function creates a new pipe in self.pipe
1910
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1912
proc = MultiprocessingMixIn.process_request(self, request,
1914
self.child_pipe.close()
1915
self.add_pipe(parent_pipe, proc)
1917
def add_pipe(self, parent_pipe, proc):
1918
"""Dummy function; override as necessary"""
1919
raise NotImplementedError()
1922
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1923
socketserver.TCPServer, object):
1924
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
650
logger.info(u"TCP connection from: %s",
651
unicode(self.client_address))
652
session = (gnutls.connection
653
.ClientSession(self.request,
657
line = self.request.makefile().readline()
658
logger.debug(u"Protocol version: %r", line)
660
if int(line.strip().split()[0]) > 1:
662
except (ValueError, IndexError, RuntimeError), error:
663
logger.error(u"Unknown protocol version: %s", error)
666
# Note: gnutls.connection.X509Credentials is really a generic
667
# GnuTLS certificate credentials object so long as no X.509
668
# keys are added to it. Therefore, we can use it here despite
669
# using OpenPGP certificates.
671
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
672
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
674
# Use a fallback default, since this MUST be set.
675
priority = self.server.settings.get("priority", "NORMAL")
676
(gnutls.library.functions
677
.gnutls_priority_set_direct(session._c_object,
682
except gnutls.errors.GNUTLSError, error:
683
logger.warning(u"Handshake failed: %s", error)
684
# Do not run session.bye() here: the session is not
685
# established. Just abandon the request.
688
fpr = fingerprint(peer_certificate(session))
689
except (TypeError, gnutls.errors.GNUTLSError), error:
690
logger.warning(u"Bad certificate: %s", error)
693
logger.debug(u"Fingerprint: %s", fpr)
694
for c in self.server.clients:
695
if c.fingerprint == fpr:
699
logger.warning(u"Client not found for fingerprint: %s",
703
# Have to check if client.still_valid(), since it is possible
704
# that the client timed out while establishing the GnuTLS
706
if not client.still_valid():
707
logger.warning(u"Client %(name)s is invalid",
711
## This won't work here, since we're in a fork.
712
# client.bump_timeout()
714
while sent_size < len(client.secret):
715
sent = session.send(client.secret[sent_size:])
716
logger.debug(u"Sent: %d, remaining: %d",
717
sent, len(client.secret)
718
- (sent_size + sent))
723
class IPv6_TCPServer(SocketServer.ForkingMixIn,
724
SocketServer.TCPServer, object):
725
"""IPv6 TCP server. Accepts 'None' as address and/or port.
727
settings: Server settings
728
clients: Set() of Client objects
1927
729
enabled: Boolean; whether this server is activated yet
1928
interface: None or a network interface name (string)
1929
use_ipv6: Boolean; to use IPv6 or not
1931
def __init__(self, server_address, RequestHandlerClass,
1932
interface=None, use_ipv6=True, socketfd=None):
1933
"""If socketfd is set, use that file descriptor instead of
1934
creating a new one with socket.socket().
1936
self.interface = interface
1938
self.address_family = socket.AF_INET6
1939
if socketfd is not None:
1940
# Save the file descriptor
1941
self.socketfd = socketfd
1942
# Save the original socket.socket() function
1943
self.socket_socket = socket.socket
1944
# To implement --socket, we monkey patch socket.socket.
1946
# (When socketserver.TCPServer is a new-style class, we
1947
# could make self.socket into a property instead of monkey
1948
# patching socket.socket.)
1950
# Create a one-time-only replacement for socket.socket()
1951
@functools.wraps(socket.socket)
1952
def socket_wrapper(*args, **kwargs):
1953
# Restore original function so subsequent calls are
1955
socket.socket = self.socket_socket
1956
del self.socket_socket
1957
# This time only, return a new socket object from the
1958
# saved file descriptor.
1959
return socket.fromfd(self.socketfd, *args, **kwargs)
1960
# Replace socket.socket() function with wrapper
1961
socket.socket = socket_wrapper
1962
# The socketserver.TCPServer.__init__ will call
1963
# socket.socket(), which might be our replacement,
1964
# socket_wrapper(), if socketfd was set.
1965
socketserver.TCPServer.__init__(self, server_address,
1966
RequestHandlerClass)
731
address_family = socket.AF_INET6
732
def __init__(self, *args, **kwargs):
733
if "settings" in kwargs:
734
self.settings = kwargs["settings"]
735
del kwargs["settings"]
736
if "clients" in kwargs:
737
self.clients = kwargs["clients"]
738
del kwargs["clients"]
740
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
1968
741
def server_bind(self):
1969
742
"""This overrides the normal server_bind() function
1970
743
to bind to an interface if one was specified, and also NOT to
1971
744
bind to an address or port if they were not specified."""
1972
if self.interface is not None:
1973
if SO_BINDTODEVICE is None:
1974
logger.error("SO_BINDTODEVICE does not exist;"
1975
" cannot bind to interface %s",
1979
self.socket.setsockopt(socket.SOL_SOCKET,
1981
str(self.interface + '\0'))
1982
except socket.error as error:
1983
if error.errno == errno.EPERM:
1984
logger.error("No permission to bind to"
1985
" interface %s", self.interface)
1986
elif error.errno == errno.ENOPROTOOPT:
1987
logger.error("SO_BINDTODEVICE not available;"
1988
" cannot bind to interface %s",
1990
elif error.errno == errno.ENODEV:
1991
logger.error("Interface %s does not exist,"
1992
" cannot bind", self.interface)
745
if self.settings["interface"]:
746
# 25 is from /usr/include/asm-i486/socket.h
747
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
749
self.socket.setsockopt(socket.SOL_SOCKET,
751
self.settings["interface"])
752
except socket.error, error:
753
if error[0] == errno.EPERM:
754
logger.error(u"No permission to"
755
u" bind to interface %s",
756
self.settings["interface"])
1995
759
# Only bind(2) the socket if we really need to.
1996
760
if self.server_address[0] or self.server_address[1]:
1997
761
if not self.server_address[0]:
1998
if self.address_family == socket.AF_INET6:
1999
any_address = "::" # in6addr_any
2001
any_address = "0.0.0.0" # INADDR_ANY
2002
self.server_address = (any_address,
763
self.server_address = (in6addr_any,
2003
764
self.server_address[1])
2004
765
elif not self.server_address[1]:
2005
766
self.server_address = (self.server_address[0],
2007
# if self.interface:
768
# if self.settings["interface"]:
2008
769
# self.server_address = (self.server_address[0],
2011
772
# if_nametoindex
2013
return socketserver.TCPServer.server_bind(self)
2016
class MandosServer(IPv6_TCPServer):
2020
clients: set of Client objects
2021
gnutls_priority GnuTLS priority string
2022
use_dbus: Boolean; to emit D-Bus signals or not
2024
Assumes a gobject.MainLoop event loop.
2026
def __init__(self, server_address, RequestHandlerClass,
2027
interface=None, use_ipv6=True, clients=None,
2028
gnutls_priority=None, use_dbus=True, socketfd=None):
2029
self.enabled = False
2030
self.clients = clients
2031
if self.clients is None:
2033
self.use_dbus = use_dbus
2034
self.gnutls_priority = gnutls_priority
2035
IPv6_TCPServer.__init__(self, server_address,
2036
RequestHandlerClass,
2037
interface = interface,
2038
use_ipv6 = use_ipv6,
2039
socketfd = socketfd)
775
return super(IPv6_TCPServer, self).server_bind()
2040
776
def server_activate(self):
2041
777
if self.enabled:
2042
return socketserver.TCPServer.server_activate(self)
778
return super(IPv6_TCPServer, self).server_activate()
2044
779
def enable(self):
2045
780
self.enabled = True
2047
def add_pipe(self, parent_pipe, proc):
2048
# Call "handle_ipc" for both data and EOF events
2049
gobject.io_add_watch(parent_pipe.fileno(),
2050
gobject.IO_IN | gobject.IO_HUP,
2051
functools.partial(self.handle_ipc,
2056
def handle_ipc(self, source, condition, parent_pipe=None,
2057
proc = None, client_object=None):
2058
# error, or the other end of multiprocessing.Pipe has closed
2059
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2060
# Wait for other process to exit
2064
# Read a request from the child
2065
request = parent_pipe.recv()
2066
command = request[0]
2068
if command == 'init':
2070
address = request[2]
2072
for c in self.clients.itervalues():
2073
if c.fingerprint == fpr:
2077
logger.info("Client not found for fingerprint: %s, ad"
2078
"dress: %s", fpr, address)
2081
mandos_dbus_service.ClientNotFound(fpr,
2083
parent_pipe.send(False)
2086
gobject.io_add_watch(parent_pipe.fileno(),
2087
gobject.IO_IN | gobject.IO_HUP,
2088
functools.partial(self.handle_ipc,
2094
parent_pipe.send(True)
2095
# remove the old hook in favor of the new above hook on
2098
if command == 'funcall':
2099
funcname = request[1]
2103
parent_pipe.send(('data', getattr(client_object,
2107
if command == 'getattr':
2108
attrname = request[1]
2109
if callable(client_object.__getattribute__(attrname)):
2110
parent_pipe.send(('function',))
2112
parent_pipe.send(('data', client_object
2113
.__getattribute__(attrname)))
2115
if command == 'setattr':
2116
attrname = request[1]
2118
setattr(client_object, attrname, value)
2123
def rfc3339_duration_to_delta(duration):
2124
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2126
>>> rfc3339_duration_to_delta("P7D")
2127
datetime.timedelta(7)
2128
>>> rfc3339_duration_to_delta("PT60S")
2129
datetime.timedelta(0, 60)
2130
>>> rfc3339_duration_to_delta("PT60M")
2131
datetime.timedelta(0, 3600)
2132
>>> rfc3339_duration_to_delta("PT24H")
2133
datetime.timedelta(1)
2134
>>> rfc3339_duration_to_delta("P1W")
2135
datetime.timedelta(7)
2136
>>> rfc3339_duration_to_delta("PT5M30S")
2137
datetime.timedelta(0, 330)
2138
>>> rfc3339_duration_to_delta("P1DT3M20S")
2139
datetime.timedelta(1, 200)
2142
# Parsing an RFC 3339 duration with regular expressions is not
2143
# possible - there would have to be multiple places for the same
2144
# values, like seconds. The current code, while more esoteric, is
2145
# cleaner without depending on a parsing library. If Python had a
2146
# built-in library for parsing we would use it, but we'd like to
2147
# avoid excessive use of external libraries.
2149
# New type for defining tokens, syntax, and semantics all-in-one
2150
Token = collections.namedtuple("Token",
2151
("regexp", # To match token; if
2152
# "value" is not None,
2153
# must have a "group"
2155
"value", # datetime.timedelta or
2157
"followers")) # Tokens valid after
2159
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2160
# the "duration" ABNF definition in RFC 3339, Appendix A.
2161
token_end = Token(re.compile(r"$"), None, frozenset())
2162
token_second = Token(re.compile(r"(\d+)S"),
2163
datetime.timedelta(seconds=1),
2164
frozenset((token_end,)))
2165
token_minute = Token(re.compile(r"(\d+)M"),
2166
datetime.timedelta(minutes=1),
2167
frozenset((token_second, token_end)))
2168
token_hour = Token(re.compile(r"(\d+)H"),
2169
datetime.timedelta(hours=1),
2170
frozenset((token_minute, token_end)))
2171
token_time = Token(re.compile(r"T"),
2173
frozenset((token_hour, token_minute,
2175
token_day = Token(re.compile(r"(\d+)D"),
2176
datetime.timedelta(days=1),
2177
frozenset((token_time, token_end)))
2178
token_month = Token(re.compile(r"(\d+)M"),
2179
datetime.timedelta(weeks=4),
2180
frozenset((token_day, token_end)))
2181
token_year = Token(re.compile(r"(\d+)Y"),
2182
datetime.timedelta(weeks=52),
2183
frozenset((token_month, token_end)))
2184
token_week = Token(re.compile(r"(\d+)W"),
2185
datetime.timedelta(weeks=1),
2186
frozenset((token_end,)))
2187
token_duration = Token(re.compile(r"P"), None,
2188
frozenset((token_year, token_month,
2189
token_day, token_time,
2191
# Define starting values
2192
value = datetime.timedelta() # Value so far
2194
followers = frozenset(token_duration,) # Following valid tokens
2195
s = duration # String left to parse
2196
# Loop until end token is found
2197
while found_token is not token_end:
2198
# Search for any currently valid tokens
2199
for token in followers:
2200
match = token.regexp.match(s)
2201
if match is not None:
2203
if token.value is not None:
2204
# Value found, parse digits
2205
factor = int(match.group(1), 10)
2206
# Add to value so far
2207
value += factor * token.value
2208
# Strip token from string
2209
s = token.regexp.sub("", s, 1)
2212
# Set valid next tokens
2213
followers = found_token.followers
2216
# No currently valid tokens were found
2217
raise ValueError("Invalid RFC 3339 duration")
2222
783
def string_to_delta(interval):
2223
784
"""Parse a string and return a datetime.timedelta
2225
786
>>> string_to_delta('7d')
2226
787
datetime.timedelta(7)
2227
788
>>> string_to_delta('60s')
2351
927
"debug": "False",
2353
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
929
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2354
930
"servicename": "Mandos",
2355
931
"use_dbus": "True",
2360
"statedir": "/var/lib/mandos",
2361
"foreground": "False",
2364
934
# Parse config file for server-global settings
2365
server_config = configparser.SafeConfigParser(server_defaults)
935
server_config = ConfigParser.SafeConfigParser(server_defaults)
2366
936
del server_defaults
2367
server_config.read(os.path.join(options.configdir,
937
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2369
938
# Convert the SafeConfigParser object to a dict
2370
939
server_settings = server_config.defaults()
2371
# Use the appropriate methods on the non-string config options
2372
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2373
server_settings[option] = server_config.getboolean("DEFAULT",
2375
if server_settings["port"]:
2376
server_settings["port"] = server_config.getint("DEFAULT",
2378
if server_settings["socket"]:
2379
server_settings["socket"] = server_config.getint("DEFAULT",
2381
# Later, stdin will, and stdout and stderr might, be dup'ed
2382
# over with an opened os.devnull. But we don't want this to
2383
# happen with a supplied network socket.
2384
if 0 <= server_settings["socket"] <= 2:
2385
server_settings["socket"] = os.dup(server_settings
940
# Use getboolean on the boolean config options
941
server_settings["debug"] = (server_config.getboolean
942
("DEFAULT", "debug"))
943
server_settings["use_dbus"] = (server_config.getboolean
944
("DEFAULT", "use_dbus"))
2387
945
del server_config
2389
947
# Override the settings from the config file with command line
2390
948
# options, if set.
2391
949
for option in ("interface", "address", "port", "debug",
2392
950
"priority", "servicename", "configdir",
2393
"use_dbus", "use_ipv6", "debuglevel", "restore",
2394
"statedir", "socket", "foreground"):
2395
952
value = getattr(options, option)
2396
953
if value is not None:
2397
954
server_settings[option] = value
2399
# Force all strings to be unicode
2400
for option in server_settings.keys():
2401
if type(server_settings[option]) is str:
2402
server_settings[option] = unicode(server_settings[option])
2403
# Force all boolean options to be boolean
2404
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2406
server_settings[option] = bool(server_settings[option])
2407
# Debug implies foreground
2408
if server_settings["debug"]:
2409
server_settings["foreground"] = True
2410
956
# Now we have our good server settings in "server_settings"
2412
##################################################################
2414
958
# For convenience
2415
959
debug = server_settings["debug"]
2416
debuglevel = server_settings["debuglevel"]
2417
960
use_dbus = server_settings["use_dbus"]
2418
use_ipv6 = server_settings["use_ipv6"]
2419
stored_state_path = os.path.join(server_settings["statedir"],
2421
foreground = server_settings["foreground"]
2424
initlogger(debug, logging.DEBUG)
2429
level = getattr(logging, debuglevel.upper())
2430
initlogger(debug, level)
963
syslogger.setLevel(logging.WARNING)
964
console.setLevel(logging.WARNING)
2432
966
if server_settings["servicename"] != "Mandos":
2433
967
syslogger.setFormatter(logging.Formatter
2434
('Mandos ({0}) [%(process)d]:'
2435
' %(levelname)s: %(message)s'
2436
.format(server_settings
968
('Mandos (%s): %%(levelname)s:'
970
% server_settings["servicename"]))
2439
972
# Parse config file with clients
2440
client_config = configparser.SafeConfigParser(Client
973
client_defaults = { "timeout": "1h",
975
"checker": "fping -q -- %%(host)s",
978
client_config = ConfigParser.SafeConfigParser(client_defaults)
2442
979
client_config.read(os.path.join(server_settings["configdir"],
2443
980
"clients.conf"))
2445
global mandos_dbus_service
2446
mandos_dbus_service = None
2448
tcp_server = MandosServer((server_settings["address"],
2449
server_settings["port"]),
2451
interface=(server_settings["interface"]
2455
server_settings["priority"],
2457
socketfd=(server_settings["socket"]
2460
pidfilename = "/run/mandos.pid"
2461
if not os.path.isdir("/run/."):
2462
pidfilename = "/var/run/mandos.pid"
2465
pidfile = open(pidfilename, "w")
2466
except IOError as e:
2467
logger.error("Could not open file %r", pidfilename,
2470
for name in ("_mandos", "mandos", "nobody"):
2472
uid = pwd.getpwnam(name).pw_uid
2473
gid = pwd.getpwnam(name).pw_gid
983
tcp_server = IPv6_TCPServer((server_settings["address"],
984
server_settings["port"]),
986
settings=server_settings,
988
pidfilename = "/var/run/mandos.pid"
990
pidfile = open(pidfilename, "w")
991
except IOError, error:
992
logger.error("Could not open file %r", pidfilename)
995
uid = pwd.getpwnam("_mandos").pw_uid
998
uid = pwd.getpwnam("mandos").pw_uid
1001
uid = pwd.getpwnam("nobody").pw_uid
1005
gid = pwd.getpwnam("_mandos").pw_gid
1008
gid = pwd.getpwnam("mandos").pw_gid
1011
gid = pwd.getpwnam("nogroup").pw_gid
2483
except OSError as error:
2484
if error.errno != errno.EPERM:
2488
# Enable all possible GnuTLS debugging
2490
# "Use a log level over 10 to enable all debugging options."
2492
gnutls.library.functions.gnutls_global_set_log_level(11)
2494
@gnutls.library.types.gnutls_log_func
2495
def debug_gnutls(level, string):
2496
logger.debug("GnuTLS: %s", string[:-1])
2498
(gnutls.library.functions
2499
.gnutls_global_set_log_function(debug_gnutls))
2501
# Redirect stdin so all checkers get /dev/null
2502
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2503
os.dup2(null, sys.stdin.fileno())
2507
# Need to fork before connecting to D-Bus
2509
# Close all input and output, do double fork, etc.
2512
# multiprocessing will use threads, so before we use gobject we
2513
# need to inform gobject that threads will be used.
2514
gobject.threads_init()
1017
except OSError, error:
1018
if error[0] != errno.EPERM:
1022
service = AvahiService(name = server_settings["servicename"],
1023
servicetype = "_mandos._tcp", )
1024
if server_settings["interface"]:
1025
service.interface = (if_nametoindex
1026
(server_settings["interface"]))
2516
1028
global main_loop
2517
1031
# From the Avahi example code
2518
DBusGMainLoop(set_as_default=True)
1032
DBusGMainLoop(set_as_default=True )
2519
1033
main_loop = gobject.MainLoop()
2520
1034
bus = dbus.SystemBus()
1035
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1036
avahi.DBUS_PATH_SERVER),
1037
avahi.DBUS_INTERFACE_SERVER)
2521
1038
# End of Avahi example code
2524
bus_name = dbus.service.BusName("se.recompile.Mandos",
2525
bus, do_not_queue=True)
2526
old_bus_name = (dbus.service.BusName
2527
("se.bsnet.fukt.Mandos", bus,
2529
except dbus.exceptions.NameExistsException as e:
2530
logger.error("Disabling D-Bus:", exc_info=e)
2532
server_settings["use_dbus"] = False
2533
tcp_server.use_dbus = False
2534
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2535
service = AvahiServiceToSyslog(name =
2536
server_settings["servicename"],
2537
servicetype = "_mandos._tcp",
2538
protocol = protocol, bus = bus)
2539
if server_settings["interface"]:
2540
service.interface = (if_nametoindex
2541
(str(server_settings["interface"])))
2543
global multiprocessing_manager
2544
multiprocessing_manager = multiprocessing.Manager()
2546
client_class = Client
2548
client_class = functools.partial(ClientDBus, bus = bus)
2550
client_settings = Client.config_parser(client_config)
2551
old_client_settings = {}
2554
# This is used to redirect stdout and stderr for checker processes
2556
wnull = open(os.devnull, "w") # A writable /dev/null
2557
# Only used if server is running in foreground but not in debug
2559
if debug or not foreground:
2562
# Get client data and settings from last running state.
2563
if server_settings["restore"]:
2565
with open(stored_state_path, "rb") as stored_state:
2566
clients_data, old_client_settings = (pickle.load
2568
os.remove(stored_state_path)
2569
except IOError as e:
2570
if e.errno == errno.ENOENT:
2571
logger.warning("Could not load persistent state: {0}"
2572
.format(os.strerror(e.errno)))
2574
logger.critical("Could not load persistent state:",
2577
except EOFError as e:
2578
logger.warning("Could not load persistent state: "
2579
"EOFError:", exc_info=e)
2581
with PGPEngine() as pgp:
2582
for client_name, client in clients_data.iteritems():
2583
# Skip removed clients
2584
if client_name not in client_settings:
2587
# Decide which value to use after restoring saved state.
2588
# We have three different values: Old config file,
2589
# new config file, and saved state.
2590
# New config value takes precedence if it differs from old
2591
# config value, otherwise use saved state.
2592
for name, value in client_settings[client_name].items():
2594
# For each value in new config, check if it
2595
# differs from the old config value (Except for
2596
# the "secret" attribute)
2597
if (name != "secret" and
2598
value != old_client_settings[client_name]
2600
client[name] = value
2604
# Clients who has passed its expire date can still be
2605
# enabled if its last checker was successful. Clients
2606
# whose checker succeeded before we stored its state is
2607
# assumed to have successfully run all checkers during
2609
if client["enabled"]:
2610
if datetime.datetime.utcnow() >= client["expires"]:
2611
if not client["last_checked_ok"]:
2613
"disabling client {0} - Client never "
2614
"performed a successful checker"
2615
.format(client_name))
2616
client["enabled"] = False
2617
elif client["last_checker_status"] != 0:
2619
"disabling client {0} - Client "
2620
"last checker failed with error code {1}"
2621
.format(client_name,
2622
client["last_checker_status"]))
2623
client["enabled"] = False
2625
client["expires"] = (datetime.datetime
2627
+ client["timeout"])
2628
logger.debug("Last checker succeeded,"
2629
" keeping {0} enabled"
2630
.format(client_name))
2632
client["secret"] = (
2633
pgp.decrypt(client["encrypted_secret"],
2634
client_settings[client_name]
2637
# If decryption fails, we use secret from new settings
2638
logger.debug("Failed to decrypt {0} old secret"
2639
.format(client_name))
2640
client["secret"] = (
2641
client_settings[client_name]["secret"])
2643
# Add/remove clients based on new changes made to config
2644
for client_name in (set(old_client_settings)
2645
- set(client_settings)):
2646
del clients_data[client_name]
2647
for client_name in (set(client_settings)
2648
- set(old_client_settings)):
2649
clients_data[client_name] = client_settings[client_name]
2651
# Create all client objects
2652
for client_name, client in clients_data.iteritems():
2653
tcp_server.clients[client_name] = client_class(
2654
name = client_name, settings = client,
2655
server_settings = server_settings)
2657
if not tcp_server.clients:
2658
logger.warning("No clients defined")
2661
if pidfile is not None:
2665
pidfile.write(str(pid) + "\n".encode("utf-8"))
2667
logger.error("Could not write to file %r with PID %d",
1040
bus_name = dbus.service.BusName(u"org.mandos-system.Mandos",
1043
clients.update(Set(Client(name = section,
1045
= dict(client_config.items(section)),
1046
use_dbus = use_dbus)
1047
for section in client_config.sections()))
1049
logger.warning(u"No clients defined")
1052
# Redirect stdin so all checkers get /dev/null
1053
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1054
os.dup2(null, sys.stdin.fileno())
1058
# No console logging
1059
logger.removeHandler(console)
1060
# Close all input and output, do double fork, etc.
1065
pidfile.write(str(pid) + "\n")
1069
logger.error(u"Could not write to file %r with PID %d",
1072
# "pidfile" was never created
1077
"Cleanup function; run on exit"
1079
# From the Avahi example code
1080
if not group is None:
1083
# End of Avahi example code
1086
client = clients.pop()
1087
client.disable_hook = None
1090
atexit.register(cleanup)
1093
signal.signal(signal.SIGINT, signal.SIG_IGN)
2672
1094
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2673
1095
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2676
@alternate_dbus_interfaces({"se.recompile.Mandos":
2677
"se.bsnet.fukt.Mandos"})
2678
class MandosDBusService(DBusObjectWithProperties):
1098
class MandosServer(dbus.service.Object):
2679
1099
"""A D-Bus proxy object"""
2680
1100
def __init__(self):
2681
dbus.service.Object.__init__(self, bus, "/")
2682
_interface = "se.recompile.Mandos"
2684
@dbus_interface_annotations(_interface)
2686
return { "org.freedesktop.DBus.Property"
2687
".EmitsChangedSignal":
1101
dbus.service.Object.__init__(self, bus,
1103
_interface = u"org.mandos_system.Mandos"
1105
@dbus.service.signal(_interface, signature="oa{sv}")
1106
def ClientAdded(self, objpath, properties):
2690
1110
@dbus.service.signal(_interface, signature="o")
2691
def ClientAdded(self, objpath):
2695
@dbus.service.signal(_interface, signature="ss")
2696
def ClientNotFound(self, fingerprint, address):
2700
@dbus.service.signal(_interface, signature="os")
2701
def ClientRemoved(self, objpath, name):
1111
def ClientRemoved(self, objpath):
2705
1115
@dbus.service.method(_interface, out_signature="ao")
2706
1116
def GetAllClients(self):
2708
return dbus.Array(c.dbus_object_path
2710
tcp_server.clients.itervalues())
2712
@dbus.service.method(_interface,
2713
out_signature="a{oa{sv}}")
1117
return dbus.Array(c.dbus_object_path for c in clients)
1119
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
2714
1120
def GetAllClientsWithProperties(self):
2716
1121
return dbus.Dictionary(
2717
((c.dbus_object_path, c.GetAll(""))
2718
for c in tcp_server.clients.itervalues()),
1122
((c.dbus_object_path, c.GetAllProperties())
2719
1124
signature="oa{sv}")
2721
1126
@dbus.service.method(_interface, in_signature="o")
2722
1127
def RemoveClient(self, object_path):
2724
for c in tcp_server.clients.itervalues():
2725
1129
if c.dbus_object_path == object_path:
2726
del tcp_server.clients[c.name]
2727
c.remove_from_connection()
2728
1131
# Don't signal anything except ClientRemoved
2729
c.disable(quiet=True)
2730
1134
# Emit D-Bus signal
2731
self.ClientRemoved(object_path, c.name)
1135
self.ClientRemoved(object_path)
2733
raise KeyError(object_path)
1138
@dbus.service.method(_interface)
2737
mandos_dbus_service = MandosDBusService()
2740
"Cleanup function; run on exit"
2743
multiprocessing.active_children()
2745
if not (tcp_server.clients or client_settings):
2748
# Store client before exiting. Secrets are encrypted with key
2749
# based on what config file has. If config file is
2750
# removed/edited, old secret will thus be unrecovable.
2752
with PGPEngine() as pgp:
2753
for client in tcp_server.clients.itervalues():
2754
key = client_settings[client.name]["secret"]
2755
client.encrypted_secret = pgp.encrypt(client.secret,
2759
# A list of attributes that can not be pickled
2761
exclude = set(("bus", "changedstate", "secret",
2762
"checker", "server_settings"))
2763
for name, typ in (inspect.getmembers
2764
(dbus.service.Object)):
2767
client_dict["encrypted_secret"] = (client
2769
for attr in client.client_structure:
2770
if attr not in exclude:
2771
client_dict[attr] = getattr(client, attr)
2773
clients[client.name] = client_dict
2774
del client_settings[client.name]["secret"]
2777
with (tempfile.NamedTemporaryFile
2778
(mode='wb', suffix=".pickle", prefix='clients-',
2779
dir=os.path.dirname(stored_state_path),
2780
delete=False)) as stored_state:
2781
pickle.dump((clients, client_settings), stored_state)
2782
tempname=stored_state.name
2783
os.rename(tempname, stored_state_path)
2784
except (IOError, OSError) as e:
2790
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2791
logger.warning("Could not save persistent state: {0}"
2792
.format(os.strerror(e.errno)))
2794
logger.warning("Could not save persistent state:",
2798
# Delete all clients, and settings from config
2799
while tcp_server.clients:
2800
name, client = tcp_server.clients.popitem()
2802
client.remove_from_connection()
2803
# Don't signal anything except ClientRemoved
2804
client.disable(quiet=True)
2807
mandos_dbus_service.ClientRemoved(client
2810
client_settings.clear()
2812
atexit.register(cleanup)
2814
for client in tcp_server.clients.itervalues():
1144
mandos_server = MandosServer()
1146
for client in clients:
2816
1148
# Emit D-Bus signal
2817
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2818
# Need to initiate checking of clients
2820
client.init_checker()
1149
mandos_server.ClientAdded(client.dbus_object_path,
1150
client.GetAllProperties())
2822
1153
tcp_server.enable()
2823
1154
tcp_server.server_activate()
2825
1156
# Find out what port we got
2826
1157
service.port = tcp_server.socket.getsockname()[1]
2828
logger.info("Now listening on address %r, port %d,"
2829
" flowinfo %d, scope_id %d",
2830
*tcp_server.socket.getsockname())
2832
logger.info("Now listening on address %r, port %d",
2833
*tcp_server.socket.getsockname())
1158
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1159
u" scope_id %d" % tcp_server.socket.getsockname())
2835
1161
#service.interface = tcp_server.socket.getsockname()[3]
2838
1164
# From the Avahi example code
1165
server.connect_to_signal("StateChanged", server_state_changed)
2841
except dbus.exceptions.DBusException as error:
2842
logger.critical("D-Bus Exception", exc_info=error)
1167
server_state_changed(server.GetState())
1168
except dbus.exceptions.DBusException, error:
1169
logger.critical(u"DBusException: %s", error)
2845
1171
# End of Avahi example code