291
124
self.rename_count = 0
292
125
self.max_renames = max_renames
293
self.protocol = protocol
294
self.group = None # our entry group
297
self.entry_group_state_changed_match = None
299
def rename(self, remove=True):
300
127
"""Derived from the Avahi example code"""
301
128
if self.rename_count >= self.max_renames:
302
logger.critical("No suitable Zeroconf service name found"
303
" after %i retries, exiting.",
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
304
131
self.rename_count)
305
132
raise AvahiServiceError("Too many renames")
307
self.server.GetAlternativeServiceName(self.name))
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))
308
141
self.rename_count += 1
309
logger.info("Changing Zeroconf service name to %r ...",
315
except dbus.exceptions.DBusException as error:
316
if (error.get_dbus_name()
317
== "org.freedesktop.Avahi.CollisionError"):
318
logger.info("Local Zeroconf service name collision.")
319
return self.rename(remove=False)
321
logger.critical("D-Bus Exception", exc_info=error)
325
142
def remove(self):
326
143
"""Derived from the Avahi example code"""
327
if self.entry_group_state_changed_match is not None:
328
self.entry_group_state_changed_match.remove()
329
self.entry_group_state_changed_match = None
330
if self.group is not None:
144
if group is not None:
334
147
"""Derived from the Avahi example code"""
336
if self.group is None:
337
self.group = dbus.Interface(
338
self.bus.get_object(avahi.DBUS_NAME,
339
self.server.EntryGroupNew()),
340
avahi.DBUS_INTERFACE_ENTRY_GROUP)
341
self.entry_group_state_changed_match = (
342
self.group.connect_to_signal(
343
'StateChanged', self.entry_group_state_changed))
344
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
345
self.name, self.type)
346
self.group.AddService(
349
dbus.UInt32(0), # flags
350
self.name, self.type,
351
self.domain, self.host,
352
dbus.UInt16(self.port),
353
avahi.string_array_to_txt_array(self.TXT))
356
def entry_group_state_changed(self, state, error):
357
"""Derived from the Avahi example code"""
358
logger.debug("Avahi entry group state change: %i", state)
360
if state == avahi.ENTRY_GROUP_ESTABLISHED:
361
logger.debug("Zeroconf service established.")
362
elif state == avahi.ENTRY_GROUP_COLLISION:
363
logger.info("Zeroconf service name collision.")
365
elif state == avahi.ENTRY_GROUP_FAILURE:
366
logger.critical("Avahi: Error in group state changed %s",
368
raise AvahiGroupError("State changed: {!s}".format(error))
371
"""Derived from the Avahi example code"""
372
if self.group is not None:
375
except (dbus.exceptions.UnknownMethodException,
376
dbus.exceptions.DBusException):
381
def server_state_changed(self, state, error=None):
382
"""Derived from the Avahi example code"""
383
logger.debug("Avahi server state change: %i", state)
385
avahi.SERVER_INVALID: "Zeroconf server invalid",
386
avahi.SERVER_REGISTERING: None,
387
avahi.SERVER_COLLISION: "Zeroconf server name collision",
388
avahi.SERVER_FAILURE: "Zeroconf server failure",
390
if state in bad_states:
391
if bad_states[state] is not None:
393
logger.error(bad_states[state])
395
logger.error(bad_states[state] + ": %r", error)
397
elif state == avahi.SERVER_RUNNING:
400
except dbus.exceptions.DBusException as error:
401
if (error.get_dbus_name()
402
== "org.freedesktop.Avahi.CollisionError"):
403
logger.info("Local Zeroconf service name"
405
return self.rename(remove=False)
407
logger.critical("D-Bus Exception", exc_info=error)
412
logger.debug("Unknown state: %r", state)
414
logger.debug("Unknown state: %r: %r", state, error)
417
"""Derived from the Avahi example code"""
418
if self.server is None:
419
self.server = dbus.Interface(
420
self.bus.get_object(avahi.DBUS_NAME,
421
avahi.DBUS_PATH_SERVER,
422
follow_name_owner_changes=True),
423
avahi.DBUS_INTERFACE_SERVER)
424
self.server.connect_to_signal("StateChanged",
425
self.server_state_changed)
426
self.server_state_changed(self.server.GetState())
429
class AvahiServiceToSyslog(AvahiService):
430
def rename(self, *args, **kwargs):
431
"""Add the new name to the syslog messages"""
432
ret = AvahiService.rename(self, *args, **kwargs)
433
syslogger.setFormatter(logging.Formatter(
434
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
438
def call_pipe(connection, # : multiprocessing.Connection
439
func, *args, **kwargs):
440
"""This function is meant to be called by multiprocessing.Process
442
This function runs func(*args, **kwargs), and writes the resulting
443
return value on the provided multiprocessing.Connection.
445
connection.send(func(*args, **kwargs))
448
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):
449
179
"""A representation of a client host served by this server.
452
approved: bool(); 'None' if not yet approved/disapproved
453
approval_delay: datetime.timedelta(); Time to wait for approval
454
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)
455
194
checker: subprocess.Popen(); a running checker process used
456
195
to see if the client lives.
457
196
'None' if no process is running.
458
checker_callback_tag: a gobject event source tag, or None
459
checker_command: string; External command which is run to check
460
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
461
202
runtime with vars(self) as dict, so that for
462
203
instance %(name)s can be used in the command.
463
checker_initiator_tag: a gobject event source tag, or None
464
created: datetime.datetime(); (UTC) object creation
465
client_structure: Object describing what attributes a client has
466
and is used for storing the client at exit
467
current_checker_command: string; current running checker_command
468
disable_initiator_tag: a gobject event source tag, or None
470
fingerprint: string (40 or 32 hexadecimal digits); used to
471
uniquely identify the client
472
host: string; available for use by the checker command
473
interval: datetime.timedelta(); How often to start a new checker
474
last_approval_request: datetime.datetime(); (UTC) or None
475
last_checked_ok: datetime.datetime(); (UTC) or None
476
last_checker_status: integer between 0 and 255 reflecting exit
477
status of last checker. -1 reflects crashed
478
checker, -2 means no checker completed yet.
479
last_checker_signal: The signal which killed the last checker, if
480
last_checker_status is -1
481
last_enabled: datetime.datetime(); (UTC) or None
482
name: string; from the config file, used in log messages and
484
secret: bytestring; sent verbatim (over TLS) to client
485
timeout: datetime.timedelta(); How long from last_checked_ok
486
until this client is disabled
487
extended_timeout: extra long timeout when secret has been sent
488
runtime_expansions: Allowed attributes for runtime expansion.
489
expires: datetime.datetime(); time (UTC) when a client will be
491
server_settings: The server_settings dict from main()
204
dbus_object_path: dbus.ObjectPath
206
_timeout: Real variable for 'timeout'
207
_interval: Real variable for 'interval'
208
_timeout_milliseconds: Used when calling gobject.timeout_add()
209
_interval_milliseconds: - '' -
494
runtime_expansions = ("approval_delay", "approval_duration",
495
"created", "enabled", "expires",
496
"fingerprint", "host", "interval",
497
"last_approval_request", "last_checked_ok",
498
"last_enabled", "name", "timeout")
501
"extended_timeout": "PT15M",
503
"checker": "fping -q -- %%(host)s",
505
"approval_delay": "PT0S",
506
"approval_duration": "PT1S",
507
"approved_by_default": "True",
512
def config_parser(config):
513
"""Construct a new dict of client settings of this form:
514
{ client_name: {setting_name: value, ...}, ...}
515
with exceptions for any special settings as defined above.
516
NOTE: Must be a pure function. Must return the same result
517
value given the same arguments.
520
for client_name in config.sections():
521
section = dict(config.items(client_name))
522
client = settings[client_name] = {}
524
client["host"] = section["host"]
525
# Reformat values from string types to Python types
526
client["approved_by_default"] = config.getboolean(
527
client_name, "approved_by_default")
528
client["enabled"] = config.getboolean(client_name,
531
# Uppercase and remove spaces from fingerprint for later
532
# comparison purposes with return value from the
533
# fingerprint() function
534
client["fingerprint"] = (section["fingerprint"].upper()
536
if "secret" in section:
537
client["secret"] = section["secret"].decode("base64")
538
elif "secfile" in section:
539
with open(os.path.expanduser(os.path.expandvars
540
(section["secfile"])),
542
client["secret"] = secfile.read()
544
raise TypeError("No secret or secfile for section {}"
546
client["timeout"] = string_to_delta(section["timeout"])
547
client["extended_timeout"] = string_to_delta(
548
section["extended_timeout"])
549
client["interval"] = string_to_delta(section["interval"])
550
client["approval_delay"] = string_to_delta(
551
section["approval_delay"])
552
client["approval_duration"] = string_to_delta(
553
section["approval_duration"])
554
client["checker_command"] = section["checker"]
555
client["last_approval_request"] = None
556
client["last_checked_ok"] = None
557
client["last_checker_status"] = -2
561
def __init__(self, settings, name = None, server_settings=None):
211
def _set_timeout(self, timeout):
212
"Setter function for the 'timeout' attribute"
213
self._timeout = timeout
214
self._timeout_milliseconds = ((self.timeout.days
215
* 24 * 60 * 60 * 1000)
216
+ (self.timeout.seconds * 1000)
217
+ (self.timeout.microseconds
220
self.PropertyChanged(dbus.String(u"timeout"),
221
(dbus.UInt64(self._timeout_milliseconds,
223
timeout = property(lambda self: self._timeout, _set_timeout)
226
def _set_interval(self, interval):
227
"Setter function for the 'interval' attribute"
228
self._interval = interval
229
self._interval_milliseconds = ((self.interval.days
230
* 24 * 60 * 60 * 1000)
231
+ (self.interval.seconds
233
+ (self.interval.microseconds
236
self.PropertyChanged(dbus.String(u"interval"),
237
(dbus.UInt64(self._interval_milliseconds,
239
interval = property(lambda self: self._interval, _set_interval)
242
def __init__(self, name = None, disable_hook=None, config=None):
243
"""Note: the 'checker' key in 'config' sets the
244
'checker_command' attribute and *not* the 'checker'
246
self.dbus_object_path = (dbus.ObjectPath
248
+ name.replace(".", "_")))
249
dbus.service.Object.__init__(self, bus,
250
self.dbus_object_path)
563
if server_settings is None:
565
self.server_settings = server_settings
566
# adding all client settings
567
for setting, value in settings.items():
568
setattr(self, setting, value)
571
if not hasattr(self, "last_enabled"):
572
self.last_enabled = datetime.datetime.utcnow()
573
if not hasattr(self, "expires"):
574
self.expires = (datetime.datetime.utcnow()
254
logger.debug(u"Creating client %r", self.name)
255
# Uppercase and remove spaces from fingerprint for later
256
# comparison purposes with return value from the fingerprint()
258
self.fingerprint = (config["fingerprint"].upper()
260
logger.debug(u" Fingerprint: %s", self.fingerprint)
261
if "secret" in config:
262
self.secret = config["secret"].decode(u"base64")
263
elif "secfile" in config:
264
with closing(open(os.path.expanduser
266
(config["secfile"])))) as secfile:
267
self.secret = secfile.read()
577
self.last_enabled = None
580
logger.debug("Creating client %r", self.name)
581
logger.debug(" Fingerprint: %s", self.fingerprint)
582
self.created = settings.get("created",
583
datetime.datetime.utcnow())
585
# attributes specific for this server instance
269
raise TypeError(u"No secret or secfile for client %s"
271
self.host = config.get("host", "")
272
self.created = datetime.datetime.utcnow()
274
self.last_enabled = None
275
self.last_checked_ok = None
276
self.timeout = string_to_delta(config["timeout"])
277
self.interval = string_to_delta(config["interval"])
278
self.disable_hook = disable_hook
586
279
self.checker = None
587
280
self.checker_initiator_tag = None
588
281
self.disable_initiator_tag = None
589
282
self.checker_callback_tag = None
590
self.current_checker_command = None
592
self.approvals_pending = 0
593
self.changedstate = multiprocessing_manager.Condition(
594
multiprocessing_manager.Lock())
595
self.client_structure = [attr
596
for attr in self.__dict__.iterkeys()
597
if not attr.startswith("_")]
598
self.client_structure.append("client_structure")
600
for name, t in inspect.getmembers(
601
type(self), lambda obj: isinstance(obj, property)):
602
if not name.startswith("_"):
603
self.client_structure.append(name)
605
# Send notice to process children that client state has changed
606
def send_changedstate(self):
607
with self.changedstate:
608
self.changedstate.notify_all()
283
self.checker_command = config["checker"]
610
285
def enable(self):
611
286
"""Start this client's checker and timeout hooks"""
612
if getattr(self, "enabled", False):
615
self.expires = datetime.datetime.utcnow() + self.timeout
617
287
self.last_enabled = datetime.datetime.utcnow()
619
self.send_changedstate()
288
# Schedule a new checker to be started an 'interval' from now,
289
# and every interval from then on.
290
self.checker_initiator_tag = (gobject.timeout_add
291
(self._interval_milliseconds,
293
# Also start a new checker *right now*.
295
# Schedule a disable() when 'timeout' has passed
296
self.disable_initiator_tag = (gobject.timeout_add
297
(self._timeout_milliseconds,
301
self.PropertyChanged(dbus.String(u"enabled"),
302
dbus.Boolean(True, variant_level=1))
303
self.PropertyChanged(dbus.String(u"last_enabled"),
304
(_datetime_to_dbus(self.last_enabled,
621
def disable(self, quiet=True):
622
308
"""Disable this client."""
623
309
if not getattr(self, "enabled", False):
626
logger.info("Disabling client %s", self.name)
627
if getattr(self, "disable_initiator_tag", None) is not None:
311
logger.info(u"Disabling client %s", self.name)
312
if getattr(self, "disable_initiator_tag", False):
628
313
gobject.source_remove(self.disable_initiator_tag)
629
314
self.disable_initiator_tag = None
631
if getattr(self, "checker_initiator_tag", None) is not None:
315
if getattr(self, "checker_initiator_tag", False):
632
316
gobject.source_remove(self.checker_initiator_tag)
633
317
self.checker_initiator_tag = None
634
318
self.stop_checker()
319
if self.disable_hook:
320
self.disable_hook(self)
635
321
self.enabled = False
637
self.send_changedstate()
323
self.PropertyChanged(dbus.String(u"enabled"),
324
dbus.Boolean(False, variant_level=1))
638
325
# Do not run this again if called by a gobject.timeout_add
641
328
def __del__(self):
329
self.disable_hook = None
644
def init_checker(self):
645
# Schedule a new checker to be started an 'interval' from now,
646
# and every interval from then on.
647
if self.checker_initiator_tag is not None:
648
gobject.source_remove(self.checker_initiator_tag)
649
self.checker_initiator_tag = gobject.timeout_add(
650
int(self.interval.total_seconds() * 1000),
652
# Schedule a disable() when 'timeout' has passed
653
if self.disable_initiator_tag is not None:
654
gobject.source_remove(self.disable_initiator_tag)
655
self.disable_initiator_tag = gobject.timeout_add(
656
int(self.timeout.total_seconds() * 1000), self.disable)
657
# Also start a new checker *right now*.
660
def checker_callback(self, source, condition, connection,
332
def checker_callback(self, pid, condition, command):
662
333
"""The checker has completed, so take appropriate actions."""
663
334
self.checker_callback_tag = None
664
335
self.checker = None
665
# Read return code from connection (see call_pipe)
666
returncode = connection.recv()
670
self.last_checker_status = returncode
671
self.last_checker_signal = None
672
if self.last_checker_status == 0:
673
logger.info("Checker for %(name)s succeeded",
677
logger.info("Checker for %(name)s failed", vars(self))
679
self.last_checker_status = -1
680
self.last_checker_signal = -returncode
681
logger.warning("Checker for %(name)s crashed?",
337
self.PropertyChanged(dbus.String(u"checker_running"),
338
dbus.Boolean(False, variant_level=1))
339
if (os.WIFEXITED(condition)
340
and (os.WEXITSTATUS(condition) == 0)):
341
logger.info(u"Checker for %(name)s succeeded",
344
self.CheckerCompleted(dbus.Boolean(True),
345
dbus.UInt16(condition),
346
dbus.String(command))
348
elif not os.WIFEXITED(condition):
349
logger.warning(u"Checker for %(name)s crashed?",
352
self.CheckerCompleted(dbus.Boolean(False),
353
dbus.UInt16(condition),
354
dbus.String(command))
356
logger.info(u"Checker for %(name)s failed",
359
self.CheckerCompleted(dbus.Boolean(False),
360
dbus.UInt16(condition),
361
dbus.String(command))
685
def checked_ok(self):
686
"""Assert that the client has been seen, alive and well."""
363
def bump_timeout(self):
364
"""Bump up the timeout for this client.
365
This should only be called when the client has been seen,
687
368
self.last_checked_ok = datetime.datetime.utcnow()
688
self.last_checker_status = 0
689
self.last_checker_signal = None
692
def bump_timeout(self, timeout=None):
693
"""Bump up the timeout for this client."""
695
timeout = self.timeout
696
if self.disable_initiator_tag is not None:
697
gobject.source_remove(self.disable_initiator_tag)
698
self.disable_initiator_tag = None
699
if getattr(self, "enabled", False):
700
self.disable_initiator_tag = gobject.timeout_add(
701
int(timeout.total_seconds() * 1000), self.disable)
702
self.expires = datetime.datetime.utcnow() + timeout
704
def need_approval(self):
705
self.last_approval_request = datetime.datetime.utcnow()
369
gobject.source_remove(self.disable_initiator_tag)
370
self.disable_initiator_tag = (gobject.timeout_add
371
(self._timeout_milliseconds,
373
self.PropertyChanged(dbus.String(u"last_checked_ok"),
374
(_datetime_to_dbus(self.last_checked_ok,
707
377
def start_checker(self):
708
378
"""Start a new checker subprocess if one is not running.
710
379
If a checker already exists, leave it running and do
712
381
# The reason for not killing a running checker is that if we
713
# did that, and if a checker (for some reason) started running
714
# slowly and taking more than 'interval' time, then the client
715
# would inevitably timeout, since no checker would get a
716
# chance to run to completion. If we instead leave running
382
# did that, then if a checker (for some reason) started
383
# running slowly and taking more than 'interval' time, the
384
# client would inevitably timeout, since no checker would get
385
# a chance to run to completion. If we instead leave running
717
386
# checkers alone, the checker would have to take more time
718
# than 'timeout' for the client to be disabled, which is as it
721
if self.checker is not None and not self.checker.is_alive():
722
logger.warning("Checker was not alive; joining")
725
# Start a new checker if needed
387
# than 'timeout' for the client to be declared invalid, which
388
# is as it should be.
726
389
if self.checker is None:
727
# Escape attributes for the shell
729
attr: re.escape(str(getattr(self, attr)))
730
for attr in self.runtime_expansions }
732
command = self.checker_command % escaped_attrs
733
except TypeError as error:
734
logger.error('Could not format string "%s"',
735
self.checker_command,
737
return True # Try again later
738
self.current_checker_command = command
739
logger.info("Starting checker %r for %s", command,
741
# We don't need to redirect stdout and stderr, since
742
# in normal mode, that is already done by daemon(),
743
# and in debug mode we don't want to. (Stdin is
744
# always replaced by /dev/null.)
745
# The exception is when not debugging but nevertheless
746
# running in the foreground; use the previously
748
popen_args = { "close_fds": True,
751
if (not self.server_settings["debug"]
752
and self.server_settings["foreground"]):
753
popen_args.update({"stdout": wnull,
755
pipe = multiprocessing.Pipe(duplex = False)
756
self.checker = multiprocessing.Process(
758
args = (pipe[1], subprocess.call, command),
761
self.checker_callback_tag = gobject.io_add_watch(
762
pipe[0].fileno(), gobject.IO_IN,
763
self.checker_callback, pipe[0], command)
391
# In case checker_command has exactly one % operator
392
command = self.checker_command % self.host
394
# Escape attributes for the shell
395
escaped_attrs = dict((key, re.escape(str(val)))
397
vars(self).iteritems())
399
command = self.checker_command % escaped_attrs
400
except TypeError, error:
401
logger.error(u'Could not format string "%s":'
402
u' %s', self.checker_command, error)
403
return True # Try again later
405
logger.info(u"Starting checker %r for %s",
407
# We don't need to redirect stdout and stderr, since
408
# in normal mode, that is already done by daemon(),
409
# and in debug mode we don't want to. (Stdin is
410
# always replaced by /dev/null.)
411
self.checker = subprocess.Popen(command,
415
self.CheckerStarted(command)
416
self.PropertyChanged(dbus.String("checker_running"),
417
dbus.Boolean(True, variant_level=1))
418
self.checker_callback_tag = (gobject.child_watch_add
420
self.checker_callback,
422
except OSError, error:
423
logger.error(u"Failed to start subprocess: %s",
764
425
# Re-run this periodically if run by gobject.timeout_add
771
432
self.checker_callback_tag = None
772
433
if getattr(self, "checker", None) is None:
774
logger.debug("Stopping checker for %(name)s", vars(self))
775
self.checker.terminate()
435
logger.debug(u"Stopping checker for %(name)s", vars(self))
437
os.kill(self.checker.pid, signal.SIGTERM)
439
#if self.checker.poll() is None:
440
# os.kill(self.checker.pid, signal.SIGKILL)
441
except OSError, error:
442
if error.errno != errno.ESRCH: # No such process
776
444
self.checker = None
779
def dbus_service_property(dbus_interface,
783
"""Decorators for marking methods of a DBusObjectWithProperties to
784
become properties on the D-Bus.
786
The decorated method will be called with no arguments by "Get"
787
and with one argument by "Set".
789
The parameters, where they are supported, are the same as
790
dbus.service.method, except there is only "signature", since the
791
type from Get() and the type sent to Set() is the same.
793
# Encoding deeply encoded byte arrays is not supported yet by the
794
# "Set" method, so we fail early here:
795
if byte_arrays and signature != "ay":
796
raise ValueError("Byte arrays not supported for non-'ay'"
797
" signature {!r}".format(signature))
800
func._dbus_is_property = True
801
func._dbus_interface = dbus_interface
802
func._dbus_signature = signature
803
func._dbus_access = access
804
func._dbus_name = func.__name__
805
if func._dbus_name.endswith("_dbus_property"):
806
func._dbus_name = func._dbus_name[:-14]
807
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":
826
func._dbus_is_interface = True
827
func._dbus_interface = dbus_interface
828
func._dbus_name = dbus_interface
834
def dbus_annotations(annotations):
835
"""Decorator to annotate D-Bus methods, signals or properties
838
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
839
"org.freedesktop.DBus.Property."
840
"EmitsChangedSignal": "false"})
841
@dbus_service_property("org.example.Interface", signature="b",
843
def Property_dbus_property(self):
844
return dbus.Boolean(False)
848
func._dbus_annotations = annotations
854
class DBusPropertyException(dbus.exceptions.DBusException):
855
"""A base class for D-Bus property-related exceptions
860
class DBusPropertyAccessException(DBusPropertyException):
861
"""A property's access permissions disallows an operation.
866
class DBusPropertyNotFound(DBusPropertyException):
867
"""An attempt was made to access a non-existing property.
872
class DBusObjectWithProperties(dbus.service.Object):
873
"""A D-Bus object with properties.
875
Classes inheriting from this can use the dbus_service_property
876
decorator to expose methods as D-Bus properties. It exposes the
877
standard Get(), Set(), and GetAll() methods on the D-Bus.
881
def _is_dbus_thing(thing):
882
"""Returns a function testing if an attribute is a D-Bus thing
884
If called like _is_dbus_thing("method") it returns a function
885
suitable for use as predicate to inspect.getmembers().
887
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
890
def _get_all_dbus_things(self, thing):
891
"""Returns a generator of (name, attribute) pairs
893
return ((getattr(athing.__get__(self), "_dbus_name", name),
894
athing.__get__(self))
895
for cls in self.__class__.__mro__
897
inspect.getmembers(cls, self._is_dbus_thing(thing)))
899
def _get_dbus_property(self, interface_name, property_name):
900
"""Returns a bound method if one exists which is a D-Bus
901
property with the specified name and interface.
903
for cls in self.__class__.__mro__:
904
for name, value in inspect.getmembers(
905
cls, 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("{}:{}.{}".format(
912
self.dbus_object_path, interface_name, property_name))
914
@dbus.service.method(dbus.PROPERTIES_IFACE,
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 {!r}"
941
.format(prop._dbus_signature))
942
value = dbus.ByteArray(b''.join(chr(byte)
946
@dbus.service.method(dbus.PROPERTIES_IFACE,
948
out_signature="a{sv}")
949
def GetAll(self, interface_name):
950
"""Standard D-Bus property GetAll() method, see D-Bus
953
Note: Will not include properties with access="write".
956
for name, prop in self._get_all_dbus_things("property"):
958
and interface_name != prop._dbus_interface):
959
# Interface non-empty but did not match
961
# Ignore write-only properties
962
if prop._dbus_access == "write":
965
if not hasattr(value, "variant_level"):
966
properties[name] = value
968
properties[name] = type(value)(
969
value, variant_level = value.variant_level + 1)
970
return dbus.Dictionary(properties, signature="sv")
972
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
973
def PropertiesChanged(self, interface_name, changed_properties,
974
invalidated_properties):
975
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
980
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
982
path_keyword='object_path',
983
connection_keyword='connection')
984
def Introspect(self, object_path, connection):
985
"""Overloading of standard D-Bus method.
987
Inserts property tags and interface annotation tags.
989
xmlstring = dbus.service.Object.Introspect(self, object_path,
992
document = xml.dom.minidom.parseString(xmlstring)
994
def make_tag(document, name, prop):
995
e = document.createElement("property")
996
e.setAttribute("name", name)
997
e.setAttribute("type", prop._dbus_signature)
998
e.setAttribute("access", prop._dbus_access)
1001
for if_tag in document.getElementsByTagName("interface"):
1003
for tag in (make_tag(document, name, prop)
1005
in self._get_all_dbus_things("property")
1006
if prop._dbus_interface
1007
== if_tag.getAttribute("name")):
1008
if_tag.appendChild(tag)
1009
# Add annotation tags
1010
for typ in ("method", "signal", "property"):
1011
for tag in if_tag.getElementsByTagName(typ):
1013
for name, prop in (self.
1014
_get_all_dbus_things(typ)):
1015
if (name == tag.getAttribute("name")
1016
and prop._dbus_interface
1017
== if_tag.getAttribute("name")):
1018
annots.update(getattr(
1019
prop, "_dbus_annotations", {}))
1020
for name, value in annots.items():
1021
ann_tag = document.createElement(
1023
ann_tag.setAttribute("name", name)
1024
ann_tag.setAttribute("value", value)
1025
tag.appendChild(ann_tag)
1026
# Add interface annotation tags
1027
for annotation, value in dict(
1028
itertools.chain.from_iterable(
1029
annotations().items()
1030
for name, annotations
1031
in self._get_all_dbus_things("interface")
1032
if name == if_tag.getAttribute("name")
1034
ann_tag = document.createElement("annotation")
1035
ann_tag.setAttribute("name", annotation)
1036
ann_tag.setAttribute("value", value)
1037
if_tag.appendChild(ann_tag)
1038
# Add the names to the return values for the
1039
# "org.freedesktop.DBus.Properties" methods
1040
if (if_tag.getAttribute("name")
1041
== "org.freedesktop.DBus.Properties"):
1042
for cn in if_tag.getElementsByTagName("method"):
1043
if cn.getAttribute("name") == "Get":
1044
for arg in cn.getElementsByTagName("arg"):
1045
if (arg.getAttribute("direction")
1047
arg.setAttribute("name", "value")
1048
elif cn.getAttribute("name") == "GetAll":
1049
for arg in cn.getElementsByTagName("arg"):
1050
if (arg.getAttribute("direction")
1052
arg.setAttribute("name", "props")
1053
xmlstring = document.toxml("utf-8")
1055
except (AttributeError, xml.dom.DOMException,
1056
xml.parsers.expat.ExpatError) as error:
1057
logger.error("Failed to override Introspection method",
1062
def datetime_to_dbus(dt, variant_level=0):
1063
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1065
return dbus.String("", variant_level = variant_level)
1066
return dbus.String(dt.isoformat(), variant_level=variant_level)
1069
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1070
"""A class decorator; applied to a subclass of
1071
dbus.service.Object, it will add alternate D-Bus attributes with
1072
interface names according to the "alt_interface_names" mapping.
1075
@alternate_dbus_interfaces({"org.example.Interface":
1076
"net.example.AlternateInterface"})
1077
class SampleDBusObject(dbus.service.Object):
1078
@dbus.service.method("org.example.Interface")
1079
def SampleDBusMethod():
1082
The above "SampleDBusMethod" on "SampleDBusObject" will be
1083
reachable via two interfaces: "org.example.Interface" and
1084
"net.example.AlternateInterface", the latter of which will have
1085
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1086
"true", unless "deprecate" is passed with a False value.
1088
This works for methods and signals, and also for D-Bus properties
1089
(from DBusObjectWithProperties) and interfaces (from the
1090
dbus_interface_annotations decorator).
1094
for orig_interface_name, alt_interface_name in (
1095
alt_interface_names.items()):
1097
interface_names = set()
1098
# Go though all attributes of the class
1099
for attrname, attribute in inspect.getmembers(cls):
1100
# Ignore non-D-Bus attributes, and D-Bus attributes
1101
# with the wrong interface name
1102
if (not hasattr(attribute, "_dbus_interface")
1103
or not attribute._dbus_interface.startswith(
1104
orig_interface_name)):
1106
# Create an alternate D-Bus interface name based on
1108
alt_interface = attribute._dbus_interface.replace(
1109
orig_interface_name, alt_interface_name)
1110
interface_names.add(alt_interface)
1111
# Is this a D-Bus signal?
1112
if getattr(attribute, "_dbus_is_signal", False):
1113
if sys.version_info.major == 2:
1114
# Extract the original non-method undecorated
1115
# function by black magic
1116
nonmethod_func = (dict(
1117
zip(attribute.func_code.co_freevars,
1118
attribute.__closure__))
1119
["func"].cell_contents)
1121
nonmethod_func = attribute
1122
# Create a new, but exactly alike, function
1123
# object, and decorate it to be a new D-Bus signal
1124
# with the alternate D-Bus interface name
1125
if sys.version_info.major == 2:
1126
new_function = types.FunctionType(
1127
nonmethod_func.func_code,
1128
nonmethod_func.func_globals,
1129
nonmethod_func.func_name,
1130
nonmethod_func.func_defaults,
1131
nonmethod_func.func_closure)
1133
new_function = types.FunctionType(
1134
nonmethod_func.__code__,
1135
nonmethod_func.__globals__,
1136
nonmethod_func.__name__,
1137
nonmethod_func.__defaults__,
1138
nonmethod_func.__closure__)
1139
new_function = (dbus.service.signal(
1141
attribute._dbus_signature)(new_function))
1142
# Copy annotations, if any
1144
new_function._dbus_annotations = dict(
1145
attribute._dbus_annotations)
1146
except AttributeError:
1148
# Define a creator of a function to call both the
1149
# original and alternate functions, so both the
1150
# original and alternate signals gets sent when
1151
# the function is called
1152
def fixscope(func1, func2):
1153
"""This function is a scope container to pass
1154
func1 and func2 to the "call_both" function
1155
outside of its arguments"""
1157
def call_both(*args, **kwargs):
1158
"""This function will emit two D-Bus
1159
signals by calling func1 and func2"""
1160
func1(*args, **kwargs)
1161
func2(*args, **kwargs)
1164
# Create the "call_both" function and add it to
1166
attr[attrname] = fixscope(attribute, new_function)
1167
# Is this a D-Bus method?
1168
elif getattr(attribute, "_dbus_is_method", False):
1169
# Create a new, but exactly alike, function
1170
# object. Decorate it to be a new D-Bus method
1171
# with the alternate D-Bus interface name. Add it
1174
dbus.service.method(
1176
attribute._dbus_in_signature,
1177
attribute._dbus_out_signature)
1178
(types.FunctionType(attribute.func_code,
1179
attribute.func_globals,
1180
attribute.func_name,
1181
attribute.func_defaults,
1182
attribute.func_closure)))
1183
# Copy annotations, if any
1185
attr[attrname]._dbus_annotations = dict(
1186
attribute._dbus_annotations)
1187
except AttributeError:
1189
# Is this a D-Bus property?
1190
elif getattr(attribute, "_dbus_is_property", False):
1191
# Create a new, but exactly alike, function
1192
# object, and decorate it to be a new D-Bus
1193
# property with the alternate D-Bus interface
1194
# name. Add it to the class.
1195
attr[attrname] = (dbus_service_property(
1196
alt_interface, attribute._dbus_signature,
1197
attribute._dbus_access,
1198
attribute._dbus_get_args_options
1200
(types.FunctionType(
1201
attribute.func_code,
1202
attribute.func_globals,
1203
attribute.func_name,
1204
attribute.func_defaults,
1205
attribute.func_closure)))
1206
# Copy annotations, if any
1208
attr[attrname]._dbus_annotations = dict(
1209
attribute._dbus_annotations)
1210
except AttributeError:
1212
# Is this a D-Bus interface?
1213
elif getattr(attribute, "_dbus_is_interface", False):
1214
# Create a new, but exactly alike, function
1215
# object. Decorate it to be a new D-Bus interface
1216
# with the alternate D-Bus interface name. Add it
1219
dbus_interface_annotations(alt_interface)
1220
(types.FunctionType(attribute.func_code,
1221
attribute.func_globals,
1222
attribute.func_name,
1223
attribute.func_defaults,
1224
attribute.func_closure)))
1226
# Deprecate all alternate interfaces
1227
iname="_AlternateDBusNames_interface_annotation{}"
1228
for interface_name in interface_names:
1230
@dbus_interface_annotations(interface_name)
1232
return { "org.freedesktop.DBus.Deprecated":
1234
# Find an unused name
1235
for aname in (iname.format(i)
1236
for i in itertools.count()):
1237
if aname not in attr:
1241
# Replace the class with a new subclass of it with
1242
# methods, signals, etc. as created above.
1243
cls = type(b"{}Alternate".format(cls.__name__),
1250
@alternate_dbus_interfaces({"se.recompile.Mandos":
1251
"se.bsnet.fukt.Mandos"})
1252
class ClientDBus(Client, DBusObjectWithProperties):
1253
"""A Client class using D-Bus
1256
dbus_object_path: dbus.ObjectPath
1257
bus: dbus.SystemBus()
1260
runtime_expansions = (Client.runtime_expansions
1261
+ ("dbus_object_path", ))
1263
_interface = "se.recompile.Mandos.Client"
1265
# dbus.service.Object doesn't use super(), so we can't either.
1267
def __init__(self, bus = None, *args, **kwargs):
1269
Client.__init__(self, *args, **kwargs)
1270
# Only now, when this client is initialized, can it show up on
1272
client_object_name = str(self.name).translate(
1273
{ord("."): ord("_"),
1274
ord("-"): ord("_")})
1275
self.dbus_object_path = dbus.ObjectPath(
1276
"/clients/" + client_object_name)
1277
DBusObjectWithProperties.__init__(self, self.bus,
1278
self.dbus_object_path)
1280
def notifychangeproperty(transform_func, dbus_name,
1281
type_func=lambda x: x,
1283
invalidate_only=False,
1284
_interface=_interface):
1285
""" Modify a variable so that it's a property which announces
1286
its changes to DBus.
1288
transform_fun: Function that takes a value and a variant_level
1289
and transforms it to a D-Bus type.
1290
dbus_name: D-Bus name of the variable
1291
type_func: Function that transform the value before sending it
1292
to the D-Bus. Default: no transform
1293
variant_level: D-Bus variant level. Default: 1
1295
attrname = "_{}".format(dbus_name)
1297
def setter(self, value):
1298
if hasattr(self, "dbus_object_path"):
1299
if (not hasattr(self, attrname) or
1300
type_func(getattr(self, attrname, None))
1301
!= type_func(value)):
1303
self.PropertiesChanged(
1304
_interface, dbus.Dictionary(),
1305
dbus.Array((dbus_name, )))
1307
dbus_value = transform_func(
1309
variant_level = variant_level)
1310
self.PropertyChanged(dbus.String(dbus_name),
1312
self.PropertiesChanged(
1314
dbus.Dictionary({ dbus.String(dbus_name):
1317
setattr(self, attrname, value)
1319
return property(lambda self: getattr(self, attrname), setter)
1321
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1322
approvals_pending = notifychangeproperty(dbus.Boolean,
1325
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1326
last_enabled = notifychangeproperty(datetime_to_dbus,
1328
checker = notifychangeproperty(
1329
dbus.Boolean, "CheckerRunning",
1330
type_func = lambda checker: checker is not None)
1331
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1333
last_checker_status = notifychangeproperty(dbus.Int16,
1334
"LastCheckerStatus")
1335
last_approval_request = notifychangeproperty(
1336
datetime_to_dbus, "LastApprovalRequest")
1337
approved_by_default = notifychangeproperty(dbus.Boolean,
1338
"ApprovedByDefault")
1339
approval_delay = notifychangeproperty(
1340
dbus.UInt64, "ApprovalDelay",
1341
type_func = lambda td: td.total_seconds() * 1000)
1342
approval_duration = notifychangeproperty(
1343
dbus.UInt64, "ApprovalDuration",
1344
type_func = lambda td: td.total_seconds() * 1000)
1345
host = notifychangeproperty(dbus.String, "Host")
1346
timeout = notifychangeproperty(
1347
dbus.UInt64, "Timeout",
1348
type_func = lambda td: td.total_seconds() * 1000)
1349
extended_timeout = notifychangeproperty(
1350
dbus.UInt64, "ExtendedTimeout",
1351
type_func = lambda td: td.total_seconds() * 1000)
1352
interval = notifychangeproperty(
1353
dbus.UInt64, "Interval",
1354
type_func = lambda td: td.total_seconds() * 1000)
1355
checker_command = notifychangeproperty(dbus.String, "Checker")
1356
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1357
invalidate_only=True)
1359
del notifychangeproperty
1361
def __del__(self, *args, **kwargs):
1363
self.remove_from_connection()
1366
if hasattr(DBusObjectWithProperties, "__del__"):
1367
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1368
Client.__del__(self, *args, **kwargs)
1370
def checker_callback(self, source, condition,
1371
connection, command, *args, **kwargs):
1372
ret = Client.checker_callback(self, source, condition,
1373
connection, command, *args,
1375
exitstatus = self.last_checker_status
1378
self.CheckerCompleted(dbus.Int16(exitstatus),
1380
dbus.String(command))
445
self.PropertyChanged(dbus.String(u"checker_running"),
446
dbus.Boolean(False, variant_level=1))
448
def still_valid(self):
449
"""Has the timeout not yet passed for this client?"""
450
if not getattr(self, "enabled", False):
452
now = datetime.datetime.utcnow()
453
if self.last_checked_ok is None:
454
return now < (self.created + self.timeout)
1383
self.CheckerCompleted(dbus.Int16(-1),
1385
self.last_checker_signal),
1386
dbus.String(command))
1389
def start_checker(self, *args, **kwargs):
1390
old_checker_pid = getattr(self.checker, "pid", None)
1391
r = Client.start_checker(self, *args, **kwargs)
1392
# Only if new checker process was started
1393
if (self.checker is not None
1394
and old_checker_pid != self.checker.pid):
1396
self.CheckerStarted(self.current_checker_command)
1399
def _reset_approved(self):
1400
self.approved = None
1403
def approve(self, value=True):
1404
self.approved = value
1405
gobject.timeout_add(int(self.approval_duration.total_seconds()
1406
* 1000), self._reset_approved)
1407
self.send_changedstate()
1409
## D-Bus methods, signals & properties
456
return now < (self.last_checked_ok + self.timeout)
458
## D-Bus methods & signals
459
_interface = u"org.mandos_system.Mandos.Client"
461
# BumpTimeout - method
462
BumpTimeout = dbus.service.method(_interface)(bump_timeout)
463
BumpTimeout.__name__ = "BumpTimeout"
1415
465
# CheckerCompleted - signal
1416
@dbus.service.signal(_interface, signature="nxs")
1417
def CheckerCompleted(self, exitcode, waitstatus, command):
466
@dbus.service.signal(_interface, signature="bqs")
467
def CheckerCompleted(self, success, condition, command):
1485
572
# StopChecker - method
1486
@dbus.service.method(_interface)
1487
def StopChecker(self):
1492
# ApprovalPending - property
1493
@dbus_service_property(_interface, signature="b", access="read")
1494
def ApprovalPending_dbus_property(self):
1495
return dbus.Boolean(bool(self.approvals_pending))
1497
# ApprovedByDefault - property
1498
@dbus_service_property(_interface,
1501
def ApprovedByDefault_dbus_property(self, value=None):
1502
if value is None: # get
1503
return dbus.Boolean(self.approved_by_default)
1504
self.approved_by_default = bool(value)
1506
# ApprovalDelay - property
1507
@dbus_service_property(_interface,
1510
def ApprovalDelay_dbus_property(self, value=None):
1511
if value is None: # get
1512
return dbus.UInt64(self.approval_delay.total_seconds()
1514
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1516
# ApprovalDuration - property
1517
@dbus_service_property(_interface,
1520
def ApprovalDuration_dbus_property(self, value=None):
1521
if value is None: # get
1522
return dbus.UInt64(self.approval_duration.total_seconds()
1524
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1527
@dbus_service_property(_interface, signature="s", access="read")
1528
def Name_dbus_property(self):
1529
return dbus.String(self.name)
1531
# Fingerprint - property
1532
@dbus_service_property(_interface, signature="s", access="read")
1533
def Fingerprint_dbus_property(self):
1534
return dbus.String(self.fingerprint)
1537
@dbus_service_property(_interface,
1540
def Host_dbus_property(self, value=None):
1541
if value is None: # get
1542
return dbus.String(self.host)
1543
self.host = str(value)
1545
# Created - property
1546
@dbus_service_property(_interface, signature="s", access="read")
1547
def Created_dbus_property(self):
1548
return datetime_to_dbus(self.created)
1550
# LastEnabled - property
1551
@dbus_service_property(_interface, signature="s", access="read")
1552
def LastEnabled_dbus_property(self):
1553
return datetime_to_dbus(self.last_enabled)
1555
# Enabled - property
1556
@dbus_service_property(_interface,
1559
def Enabled_dbus_property(self, value=None):
1560
if value is None: # get
1561
return dbus.Boolean(self.enabled)
1567
# LastCheckedOK - property
1568
@dbus_service_property(_interface,
1571
def LastCheckedOK_dbus_property(self, value=None):
1572
if value is not None:
1575
return datetime_to_dbus(self.last_checked_ok)
1577
# LastCheckerStatus - property
1578
@dbus_service_property(_interface, signature="n", access="read")
1579
def LastCheckerStatus_dbus_property(self):
1580
return dbus.Int16(self.last_checker_status)
1582
# Expires - property
1583
@dbus_service_property(_interface, signature="s", access="read")
1584
def Expires_dbus_property(self):
1585
return datetime_to_dbus(self.expires)
1587
# LastApprovalRequest - property
1588
@dbus_service_property(_interface, signature="s", access="read")
1589
def LastApprovalRequest_dbus_property(self):
1590
return datetime_to_dbus(self.last_approval_request)
1592
# Timeout - property
1593
@dbus_service_property(_interface,
1596
def Timeout_dbus_property(self, value=None):
1597
if value is None: # get
1598
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1599
old_timeout = self.timeout
1600
self.timeout = datetime.timedelta(0, 0, 0, value)
1601
# Reschedule disabling
1603
now = datetime.datetime.utcnow()
1604
self.expires += self.timeout - old_timeout
1605
if self.expires <= now:
1606
# The timeout has passed
1609
if (getattr(self, "disable_initiator_tag", None)
1612
gobject.source_remove(self.disable_initiator_tag)
1613
self.disable_initiator_tag = gobject.timeout_add(
1614
int((self.expires - now).total_seconds() * 1000),
1617
# ExtendedTimeout - property
1618
@dbus_service_property(_interface,
1621
def ExtendedTimeout_dbus_property(self, value=None):
1622
if value is None: # get
1623
return dbus.UInt64(self.extended_timeout.total_seconds()
1625
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1627
# Interval - property
1628
@dbus_service_property(_interface,
1631
def Interval_dbus_property(self, value=None):
1632
if value is None: # get
1633
return dbus.UInt64(self.interval.total_seconds() * 1000)
1634
self.interval = datetime.timedelta(0, 0, 0, value)
1635
if getattr(self, "checker_initiator_tag", None) is None:
1638
# Reschedule checker run
1639
gobject.source_remove(self.checker_initiator_tag)
1640
self.checker_initiator_tag = gobject.timeout_add(
1641
value, self.start_checker)
1642
self.start_checker() # Start one now, too
1644
# Checker - property
1645
@dbus_service_property(_interface,
1648
def Checker_dbus_property(self, value=None):
1649
if value is None: # get
1650
return dbus.String(self.checker_command)
1651
self.checker_command = str(value)
1653
# CheckerRunning - property
1654
@dbus_service_property(_interface,
1657
def CheckerRunning_dbus_property(self, value=None):
1658
if value is None: # get
1659
return dbus.Boolean(self.checker is not None)
1661
self.start_checker()
1665
# ObjectPath - property
1666
@dbus_service_property(_interface, signature="o", access="read")
1667
def ObjectPath_dbus_property(self):
1668
return self.dbus_object_path # is already a dbus.ObjectPath
1671
@dbus_service_property(_interface,
1675
def Secret_dbus_property(self, value):
1676
self.secret = bytes(value)
573
StopChecker = dbus.service.method(_interface)(stop_checker)
574
StopChecker.__name__ = "StopChecker"
1681
class ProxyClient(object):
1682
def __init__(self, child_pipe, fpr, address):
1683
self._pipe = child_pipe
1684
self._pipe.send(('init', fpr, address))
1685
if not self._pipe.recv():
1688
def __getattribute__(self, name):
1690
return super(ProxyClient, self).__getattribute__(name)
1691
self._pipe.send(('getattr', name))
1692
data = self._pipe.recv()
1693
if data[0] == 'data':
1695
if data[0] == 'function':
1697
def func(*args, **kwargs):
1698
self._pipe.send(('funcall', name, args, kwargs))
1699
return self._pipe.recv()[1]
1703
def __setattr__(self, name, value):
1705
return super(ProxyClient, self).__setattr__(name, value)
1706
self._pipe.send(('setattr', name, value))
1709
class ClientHandler(socketserver.BaseRequestHandler, object):
1710
"""A class to handle client connections.
1712
Instantiated once for each connection to handle it.
579
def peer_certificate(session):
580
"Return the peer's OpenPGP certificate as a bytestring"
581
# If not an OpenPGP certificate...
582
if (gnutls.library.functions
583
.gnutls_certificate_type_get(session._c_object)
584
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
585
# ...do the normal thing
586
return session.peer_certificate
587
list_size = ctypes.c_uint()
588
cert_list = (gnutls.library.functions
589
.gnutls_certificate_get_peers
590
(session._c_object, ctypes.byref(list_size)))
591
if list_size.value == 0:
594
return ctypes.string_at(cert.data, cert.size)
597
def fingerprint(openpgp):
598
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
599
# New GnuTLS "datum" with the OpenPGP public key
600
datum = (gnutls.library.types
601
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
604
ctypes.c_uint(len(openpgp))))
605
# New empty GnuTLS certificate
606
crt = gnutls.library.types.gnutls_openpgp_crt_t()
607
(gnutls.library.functions
608
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
609
# Import the OpenPGP public key into the certificate
610
(gnutls.library.functions
611
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
612
gnutls.library.constants
613
.GNUTLS_OPENPGP_FMT_RAW))
614
# Verify the self signature in the key
615
crtverify = ctypes.c_uint()
616
(gnutls.library.functions
617
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
618
if crtverify.value != 0:
619
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
620
raise gnutls.errors.CertificateSecurityError("Verify failed")
621
# New buffer for the fingerprint
622
buf = ctypes.create_string_buffer(20)
623
buf_len = ctypes.c_size_t()
624
# Get the fingerprint from the certificate into the buffer
625
(gnutls.library.functions
626
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
627
ctypes.byref(buf_len)))
628
# Deinit the certificate
629
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
630
# Convert the buffer to a Python bytestring
631
fpr = ctypes.string_at(buf, buf_len.value)
632
# Convert the bytestring to hexadecimal notation
633
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
637
class TCP_handler(SocketServer.BaseRequestHandler, object):
638
"""A TCP request handler class.
639
Instantiated by IPv6_TCPServer for each request to handle it.
1713
640
Note: This will run in its own forked process."""
1715
642
def handle(self):
1716
with contextlib.closing(self.server.child_pipe) as child_pipe:
1717
logger.info("TCP connection from: %s",
1718
str(self.client_address))
1719
logger.debug("Pipe FD: %d",
1720
self.server.child_pipe.fileno())
1722
session = gnutls.connection.ClientSession(
1723
self.request, gnutls.connection .X509Credentials())
1725
# Note: gnutls.connection.X509Credentials is really a
1726
# generic GnuTLS certificate credentials object so long as
1727
# no X.509 keys are added to it. Therefore, we can use it
1728
# here despite using OpenPGP certificates.
1730
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1731
# "+AES-256-CBC", "+SHA1",
1732
# "+COMP-NULL", "+CTYPE-OPENPGP",
1734
# Use a fallback default, since this MUST be set.
1735
priority = self.server.gnutls_priority
1736
if priority is None:
1738
gnutls.library.functions.gnutls_priority_set_direct(
1739
session._c_object, priority, None)
1741
# Start communication using the Mandos protocol
1742
# Get protocol number
1743
line = self.request.makefile().readline()
1744
logger.debug("Protocol version: %r", line)
1746
if int(line.strip().split()[0]) > 1:
1747
raise RuntimeError(line)
1748
except (ValueError, IndexError, RuntimeError) as error:
1749
logger.error("Unknown protocol version: %s", error)
1752
# Start GnuTLS connection
1755
except gnutls.errors.GNUTLSError as error:
1756
logger.warning("Handshake failed: %s", error)
1757
# Do not run session.bye() here: the session is not
1758
# established. Just abandon the request.
1760
logger.debug("Handshake succeeded")
1762
approval_required = False
1765
fpr = self.fingerprint(
1766
self.peer_certificate(session))
1768
gnutls.errors.GNUTLSError) as error:
1769
logger.warning("Bad certificate: %s", error)
1771
logger.debug("Fingerprint: %s", fpr)
1774
client = ProxyClient(child_pipe, fpr,
1775
self.client_address)
1779
if client.approval_delay:
1780
delay = client.approval_delay
1781
client.approvals_pending += 1
1782
approval_required = True
1785
if not client.enabled:
1786
logger.info("Client %s is disabled",
1788
if self.server.use_dbus:
1790
client.Rejected("Disabled")
1793
if client.approved or not client.approval_delay:
1794
#We are approved or approval is disabled
1796
elif client.approved is None:
1797
logger.info("Client %s needs approval",
1799
if self.server.use_dbus:
1801
client.NeedApproval(
1802
client.approval_delay.total_seconds()
1803
* 1000, client.approved_by_default)
1805
logger.warning("Client %s was not approved",
1807
if self.server.use_dbus:
1809
client.Rejected("Denied")
1812
#wait until timeout or approved
1813
time = datetime.datetime.now()
1814
client.changedstate.acquire()
1815
client.changedstate.wait(delay.total_seconds())
1816
client.changedstate.release()
1817
time2 = datetime.datetime.now()
1818
if (time2 - time) >= delay:
1819
if not client.approved_by_default:
1820
logger.warning("Client %s timed out while"
1821
" waiting for approval",
1823
if self.server.use_dbus:
1825
client.Rejected("Approval timed out")
1830
delay -= time2 - time
1833
while sent_size < len(client.secret):
1835
sent = session.send(client.secret[sent_size:])
1836
except gnutls.errors.GNUTLSError as error:
1837
logger.warning("gnutls send failed",
1840
logger.debug("Sent: %d, remaining: %d", sent,
1841
len(client.secret) - (sent_size
1845
logger.info("Sending secret to %s", client.name)
1846
# bump the timeout using extended_timeout
1847
client.bump_timeout(client.extended_timeout)
1848
if self.server.use_dbus:
1853
if approval_required:
1854
client.approvals_pending -= 1
1857
except gnutls.errors.GNUTLSError as error:
1858
logger.warning("GnuTLS bye failed",
1862
def peer_certificate(session):
1863
"Return the peer's OpenPGP certificate as a bytestring"
1864
# If not an OpenPGP certificate...
1865
if (gnutls.library.functions.gnutls_certificate_type_get(
1867
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1868
# ...do the normal thing
1869
return session.peer_certificate
1870
list_size = ctypes.c_uint(1)
1871
cert_list = (gnutls.library.functions
1872
.gnutls_certificate_get_peers
1873
(session._c_object, ctypes.byref(list_size)))
1874
if not bool(cert_list) and list_size.value != 0:
1875
raise gnutls.errors.GNUTLSError("error getting peer"
1877
if list_size.value == 0:
1880
return ctypes.string_at(cert.data, cert.size)
1883
def fingerprint(openpgp):
1884
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1885
# New GnuTLS "datum" with the OpenPGP public key
1886
datum = gnutls.library.types.gnutls_datum_t(
1887
ctypes.cast(ctypes.c_char_p(openpgp),
1888
ctypes.POINTER(ctypes.c_ubyte)),
1889
ctypes.c_uint(len(openpgp)))
1890
# New empty GnuTLS certificate
1891
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1892
gnutls.library.functions.gnutls_openpgp_crt_init(
1894
# Import the OpenPGP public key into the certificate
1895
gnutls.library.functions.gnutls_openpgp_crt_import(
1896
crt, ctypes.byref(datum),
1897
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
1898
# Verify the self signature in the key
1899
crtverify = ctypes.c_uint()
1900
gnutls.library.functions.gnutls_openpgp_crt_verify_self(
1901
crt, 0, ctypes.byref(crtverify))
1902
if crtverify.value != 0:
1903
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1904
raise gnutls.errors.CertificateSecurityError(
1906
# New buffer for the fingerprint
1907
buf = ctypes.create_string_buffer(20)
1908
buf_len = ctypes.c_size_t()
1909
# Get the fingerprint from the certificate into the buffer
1910
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(
1911
crt, ctypes.byref(buf), ctypes.byref(buf_len))
1912
# Deinit the certificate
1913
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1914
# Convert the buffer to a Python bytestring
1915
fpr = ctypes.string_at(buf, buf_len.value)
1916
# Convert the bytestring to hexadecimal notation
1917
hex_fpr = binascii.hexlify(fpr).upper()
1921
class MultiprocessingMixIn(object):
1922
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1924
def sub_process_main(self, request, address):
1926
self.finish_request(request, address)
1928
self.handle_error(request, address)
1929
self.close_request(request)
1931
def process_request(self, request, address):
1932
"""Start a new process to process the request."""
1933
proc = multiprocessing.Process(target = self.sub_process_main,
1934
args = (request, address))
1939
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1940
""" adds a pipe to the MixIn """
1942
def process_request(self, request, client_address):
1943
"""Overrides and wraps the original process_request().
1945
This function creates a new pipe in self.pipe
1947
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1949
proc = MultiprocessingMixIn.process_request(self, request,
1951
self.child_pipe.close()
1952
self.add_pipe(parent_pipe, proc)
1954
def add_pipe(self, parent_pipe, proc):
1955
"""Dummy function; override as necessary"""
1956
raise NotImplementedError()
1959
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1960
socketserver.TCPServer, object):
1961
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
643
logger.info(u"TCP connection from: %s",
644
unicode(self.client_address))
645
session = (gnutls.connection
646
.ClientSession(self.request,
650
line = self.request.makefile().readline()
651
logger.debug(u"Protocol version: %r", line)
653
if int(line.strip().split()[0]) > 1:
655
except (ValueError, IndexError, RuntimeError), error:
656
logger.error(u"Unknown protocol version: %s", error)
659
# Note: gnutls.connection.X509Credentials is really a generic
660
# GnuTLS certificate credentials object so long as no X.509
661
# keys are added to it. Therefore, we can use it here despite
662
# using OpenPGP certificates.
664
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
665
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
667
# Use a fallback default, since this MUST be set.
668
priority = self.server.settings.get("priority", "NORMAL")
669
(gnutls.library.functions
670
.gnutls_priority_set_direct(session._c_object,
675
except gnutls.errors.GNUTLSError, error:
676
logger.warning(u"Handshake failed: %s", error)
677
# Do not run session.bye() here: the session is not
678
# established. Just abandon the request.
681
fpr = fingerprint(peer_certificate(session))
682
except (TypeError, gnutls.errors.GNUTLSError), error:
683
logger.warning(u"Bad certificate: %s", error)
686
logger.debug(u"Fingerprint: %s", fpr)
687
for c in self.server.clients:
688
if c.fingerprint == fpr:
692
logger.warning(u"Client not found for fingerprint: %s",
696
# Have to check if client.still_valid(), since it is possible
697
# that the client timed out while establishing the GnuTLS
699
if not client.still_valid():
700
logger.warning(u"Client %(name)s is invalid",
704
## This won't work here, since we're in a fork.
705
# client.bump_timeout()
707
while sent_size < len(client.secret):
708
sent = session.send(client.secret[sent_size:])
709
logger.debug(u"Sent: %d, remaining: %d",
710
sent, len(client.secret)
711
- (sent_size + sent))
716
class IPv6_TCPServer(SocketServer.ForkingMixIn,
717
SocketServer.TCPServer, object):
718
"""IPv6 TCP server. Accepts 'None' as address and/or port.
720
settings: Server settings
721
clients: Set() of Client objects
1964
722
enabled: Boolean; whether this server is activated yet
1965
interface: None or a network interface name (string)
1966
use_ipv6: Boolean; to use IPv6 or not
1969
def __init__(self, server_address, RequestHandlerClass,
1973
"""If socketfd is set, use that file descriptor instead of
1974
creating a new one with socket.socket().
1976
self.interface = interface
1978
self.address_family = socket.AF_INET6
1979
if socketfd is not None:
1980
# Save the file descriptor
1981
self.socketfd = socketfd
1982
# Save the original socket.socket() function
1983
self.socket_socket = socket.socket
1984
# To implement --socket, we monkey patch socket.socket.
1986
# (When socketserver.TCPServer is a new-style class, we
1987
# could make self.socket into a property instead of monkey
1988
# patching socket.socket.)
1990
# Create a one-time-only replacement for socket.socket()
1991
@functools.wraps(socket.socket)
1992
def socket_wrapper(*args, **kwargs):
1993
# Restore original function so subsequent calls are
1995
socket.socket = self.socket_socket
1996
del self.socket_socket
1997
# This time only, return a new socket object from the
1998
# saved file descriptor.
1999
return socket.fromfd(self.socketfd, *args, **kwargs)
2000
# Replace socket.socket() function with wrapper
2001
socket.socket = socket_wrapper
2002
# The socketserver.TCPServer.__init__ will call
2003
# socket.socket(), which might be our replacement,
2004
# socket_wrapper(), if socketfd was set.
2005
socketserver.TCPServer.__init__(self, server_address,
2006
RequestHandlerClass)
724
address_family = socket.AF_INET6
725
def __init__(self, *args, **kwargs):
726
if "settings" in kwargs:
727
self.settings = kwargs["settings"]
728
del kwargs["settings"]
729
if "clients" in kwargs:
730
self.clients = kwargs["clients"]
731
del kwargs["clients"]
733
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
2008
734
def server_bind(self):
2009
735
"""This overrides the normal server_bind() function
2010
736
to bind to an interface if one was specified, and also NOT to
2011
737
bind to an address or port if they were not specified."""
2012
if self.interface is not None:
2013
if SO_BINDTODEVICE is None:
2014
logger.error("SO_BINDTODEVICE does not exist;"
2015
" cannot bind to interface %s",
2019
self.socket.setsockopt(
2020
socket.SOL_SOCKET, SO_BINDTODEVICE,
2021
(self.interface + "\0").encode("utf-8"))
2022
except socket.error as error:
2023
if error.errno == errno.EPERM:
2024
logger.error("No permission to bind to"
2025
" interface %s", self.interface)
2026
elif error.errno == errno.ENOPROTOOPT:
2027
logger.error("SO_BINDTODEVICE not available;"
2028
" cannot bind to interface %s",
2030
elif error.errno == errno.ENODEV:
2031
logger.error("Interface %s does not exist,"
2032
" cannot bind", self.interface)
738
if self.settings["interface"]:
739
# 25 is from /usr/include/asm-i486/socket.h
740
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
742
self.socket.setsockopt(socket.SOL_SOCKET,
744
self.settings["interface"])
745
except socket.error, error:
746
if error[0] == errno.EPERM:
747
logger.error(u"No permission to"
748
u" bind to interface %s",
749
self.settings["interface"])
2035
752
# Only bind(2) the socket if we really need to.
2036
753
if self.server_address[0] or self.server_address[1]:
2037
754
if not self.server_address[0]:
2038
if self.address_family == socket.AF_INET6:
2039
any_address = "::" # in6addr_any
2041
any_address = "0.0.0.0" # INADDR_ANY
2042
self.server_address = (any_address,
756
self.server_address = (in6addr_any,
2043
757
self.server_address[1])
2044
758
elif not self.server_address[1]:
2045
self.server_address = (self.server_address[0], 0)
2046
# if self.interface:
759
self.server_address = (self.server_address[0],
761
# if self.settings["interface"]:
2047
762
# self.server_address = (self.server_address[0],
2050
765
# if_nametoindex
2052
return socketserver.TCPServer.server_bind(self)
2055
class MandosServer(IPv6_TCPServer):
2059
clients: set of Client objects
2060
gnutls_priority GnuTLS priority string
2061
use_dbus: Boolean; to emit D-Bus signals or not
2063
Assumes a gobject.MainLoop event loop.
2066
def __init__(self, server_address, RequestHandlerClass,
2070
gnutls_priority=None,
2073
self.enabled = False
2074
self.clients = clients
2075
if self.clients is None:
2077
self.use_dbus = use_dbus
2078
self.gnutls_priority = gnutls_priority
2079
IPv6_TCPServer.__init__(self, server_address,
2080
RequestHandlerClass,
2081
interface = interface,
2082
use_ipv6 = use_ipv6,
2083
socketfd = socketfd)
768
return super(IPv6_TCPServer, self).server_bind()
2085
769
def server_activate(self):
2086
770
if self.enabled:
2087
return socketserver.TCPServer.server_activate(self)
771
return super(IPv6_TCPServer, self).server_activate()
2089
772
def enable(self):
2090
773
self.enabled = True
2092
def add_pipe(self, parent_pipe, proc):
2093
# Call "handle_ipc" for both data and EOF events
2094
gobject.io_add_watch(
2095
parent_pipe.fileno(),
2096
gobject.IO_IN | gobject.IO_HUP,
2097
functools.partial(self.handle_ipc,
2098
parent_pipe = parent_pipe,
2101
def handle_ipc(self, source, condition,
2104
client_object=None):
2105
# error, or the other end of multiprocessing.Pipe has closed
2106
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2107
# Wait for other process to exit
2111
# Read a request from the child
2112
request = parent_pipe.recv()
2113
command = request[0]
2115
if command == 'init':
2117
address = request[2]
2119
for c in self.clients.itervalues():
2120
if c.fingerprint == fpr:
2124
logger.info("Client not found for fingerprint: %s, ad"
2125
"dress: %s", fpr, address)
2128
mandos_dbus_service.ClientNotFound(fpr,
2130
parent_pipe.send(False)
2133
gobject.io_add_watch(
2134
parent_pipe.fileno(),
2135
gobject.IO_IN | gobject.IO_HUP,
2136
functools.partial(self.handle_ipc,
2137
parent_pipe = parent_pipe,
2139
client_object = client))
2140
parent_pipe.send(True)
2141
# remove the old hook in favor of the new above hook on
2144
if command == 'funcall':
2145
funcname = request[1]
2149
parent_pipe.send(('data', getattr(client_object,
2153
if command == 'getattr':
2154
attrname = request[1]
2155
if isinstance(client_object.__getattribute__(attrname),
2156
collections.Callable):
2157
parent_pipe.send(('function', ))
2160
'data', client_object.__getattribute__(attrname)))
2162
if command == 'setattr':
2163
attrname = request[1]
2165
setattr(client_object, attrname, value)
2170
def rfc3339_duration_to_delta(duration):
2171
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2173
>>> rfc3339_duration_to_delta("P7D")
2174
datetime.timedelta(7)
2175
>>> rfc3339_duration_to_delta("PT60S")
2176
datetime.timedelta(0, 60)
2177
>>> rfc3339_duration_to_delta("PT60M")
2178
datetime.timedelta(0, 3600)
2179
>>> rfc3339_duration_to_delta("PT24H")
2180
datetime.timedelta(1)
2181
>>> rfc3339_duration_to_delta("P1W")
2182
datetime.timedelta(7)
2183
>>> rfc3339_duration_to_delta("PT5M30S")
2184
datetime.timedelta(0, 330)
2185
>>> rfc3339_duration_to_delta("P1DT3M20S")
2186
datetime.timedelta(1, 200)
2189
# Parsing an RFC 3339 duration with regular expressions is not
2190
# possible - there would have to be multiple places for the same
2191
# values, like seconds. The current code, while more esoteric, is
2192
# cleaner without depending on a parsing library. If Python had a
2193
# built-in library for parsing we would use it, but we'd like to
2194
# avoid excessive use of external libraries.
2196
# New type for defining tokens, syntax, and semantics all-in-one
2197
Token = collections.namedtuple("Token", (
2198
"regexp", # To match token; if "value" is not None, must have
2199
# a "group" containing digits
2200
"value", # datetime.timedelta or None
2201
"followers")) # Tokens valid after this token
2202
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2203
# the "duration" ABNF definition in RFC 3339, Appendix A.
2204
token_end = Token(re.compile(r"$"), None, frozenset())
2205
token_second = Token(re.compile(r"(\d+)S"),
2206
datetime.timedelta(seconds=1),
2207
frozenset((token_end, )))
2208
token_minute = Token(re.compile(r"(\d+)M"),
2209
datetime.timedelta(minutes=1),
2210
frozenset((token_second, token_end)))
2211
token_hour = Token(re.compile(r"(\d+)H"),
2212
datetime.timedelta(hours=1),
2213
frozenset((token_minute, token_end)))
2214
token_time = Token(re.compile(r"T"),
2216
frozenset((token_hour, token_minute,
2218
token_day = Token(re.compile(r"(\d+)D"),
2219
datetime.timedelta(days=1),
2220
frozenset((token_time, token_end)))
2221
token_month = Token(re.compile(r"(\d+)M"),
2222
datetime.timedelta(weeks=4),
2223
frozenset((token_day, token_end)))
2224
token_year = Token(re.compile(r"(\d+)Y"),
2225
datetime.timedelta(weeks=52),
2226
frozenset((token_month, token_end)))
2227
token_week = Token(re.compile(r"(\d+)W"),
2228
datetime.timedelta(weeks=1),
2229
frozenset((token_end, )))
2230
token_duration = Token(re.compile(r"P"), None,
2231
frozenset((token_year, token_month,
2232
token_day, token_time,
2234
# Define starting values
2235
value = datetime.timedelta() # Value so far
2237
followers = frozenset((token_duration, )) # Following valid tokens
2238
s = duration # String left to parse
2239
# Loop until end token is found
2240
while found_token is not token_end:
2241
# Search for any currently valid tokens
2242
for token in followers:
2243
match = token.regexp.match(s)
2244
if match is not None:
2246
if token.value is not None:
2247
# Value found, parse digits
2248
factor = int(match.group(1), 10)
2249
# Add to value so far
2250
value += factor * token.value
2251
# Strip token from string
2252
s = token.regexp.sub("", s, 1)
2255
# Set valid next tokens
2256
followers = found_token.followers
2259
# No currently valid tokens were found
2260
raise ValueError("Invalid RFC 3339 duration: {!r}"
2266
776
def string_to_delta(interval):
2267
777
"""Parse a string and return a datetime.timedelta
2269
779
>>> string_to_delta('7d')
2270
780
datetime.timedelta(7)
2271
781
>>> string_to_delta('60s')
2397
916
"debug": "False",
2399
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2400
":+SIGN-DSA-SHA256",
918
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2401
919
"servicename": "Mandos",
2407
"statedir": "/var/lib/mandos",
2408
"foreground": "False",
2412
922
# Parse config file for server-global settings
2413
server_config = configparser.SafeConfigParser(server_defaults)
923
server_config = ConfigParser.SafeConfigParser(server_defaults)
2414
924
del server_defaults
2415
925
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2416
926
# Convert the SafeConfigParser object to a dict
2417
927
server_settings = server_config.defaults()
2418
# Use the appropriate methods on the non-string config options
2419
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2420
server_settings[option] = server_config.getboolean("DEFAULT",
2422
if server_settings["port"]:
2423
server_settings["port"] = server_config.getint("DEFAULT",
2425
if server_settings["socket"]:
2426
server_settings["socket"] = server_config.getint("DEFAULT",
2428
# Later, stdin will, and stdout and stderr might, be dup'ed
2429
# over with an opened os.devnull. But we don't want this to
2430
# happen with a supplied network socket.
2431
if 0 <= server_settings["socket"] <= 2:
2432
server_settings["socket"] = os.dup(server_settings
928
# Use getboolean on the boolean config option
929
server_settings["debug"] = (server_config.getboolean
930
("DEFAULT", "debug"))
2434
931
del server_config
2436
933
# Override the settings from the config file with command line
2437
934
# options, if set.
2438
935
for option in ("interface", "address", "port", "debug",
2439
"priority", "servicename", "configdir", "use_dbus",
2440
"use_ipv6", "debuglevel", "restore", "statedir",
2441
"socket", "foreground", "zeroconf"):
936
"priority", "servicename", "configdir"):
2442
937
value = getattr(options, option)
2443
938
if value is not None:
2444
939
server_settings[option] = value
2446
# Force all strings to be unicode
2447
for option in server_settings.keys():
2448
if isinstance(server_settings[option], bytes):
2449
server_settings[option] = (server_settings[option]
2451
# Force all boolean options to be boolean
2452
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2453
"foreground", "zeroconf"):
2454
server_settings[option] = bool(server_settings[option])
2455
# Debug implies foreground
2456
if server_settings["debug"]:
2457
server_settings["foreground"] = True
2458
941
# Now we have our good server settings in "server_settings"
2460
##################################################################
2462
if (not server_settings["zeroconf"]
2463
and not (server_settings["port"]
2464
or server_settings["socket"] != "")):
2465
parser.error("Needs port or socket to work without Zeroconf")
2468
943
debug = server_settings["debug"]
2469
debuglevel = server_settings["debuglevel"]
2470
use_dbus = server_settings["use_dbus"]
2471
use_ipv6 = server_settings["use_ipv6"]
2472
stored_state_path = os.path.join(server_settings["statedir"],
2474
foreground = server_settings["foreground"]
2475
zeroconf = server_settings["zeroconf"]
2478
initlogger(debug, logging.DEBUG)
2483
level = getattr(logging, debuglevel.upper())
2484
initlogger(debug, level)
946
syslogger.setLevel(logging.WARNING)
947
console.setLevel(logging.WARNING)
2486
949
if server_settings["servicename"] != "Mandos":
2487
syslogger.setFormatter(
2488
logging.Formatter('Mandos ({}) [%(process)d]:'
2489
' %(levelname)s: %(message)s'.format(
2490
server_settings["servicename"])))
950
syslogger.setFormatter(logging.Formatter
951
('Mandos (%s): %%(levelname)s:'
953
% server_settings["servicename"]))
2492
955
# Parse config file with clients
2493
client_config = configparser.SafeConfigParser(Client
956
client_defaults = { "timeout": "1h",
958
"checker": "fping -q -- %(host)s",
961
client_config = ConfigParser.SafeConfigParser(client_defaults)
2495
962
client_config.read(os.path.join(server_settings["configdir"],
2496
963
"clients.conf"))
2498
global mandos_dbus_service
2499
mandos_dbus_service = None
2502
if server_settings["socket"] != "":
2503
socketfd = server_settings["socket"]
2504
tcp_server = MandosServer(
2505
(server_settings["address"], server_settings["port"]),
2507
interface=(server_settings["interface"] or None),
2509
gnutls_priority=server_settings["priority"],
2513
pidfilename = "/run/mandos.pid"
2514
if not os.path.isdir("/run/."):
2515
pidfilename = "/var/run/mandos.pid"
2518
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
2519
except IOError as e:
2520
logger.error("Could not open file %r", pidfilename,
2523
for name in ("_mandos", "mandos", "nobody"):
2525
uid = pwd.getpwnam(name).pw_uid
2526
gid = pwd.getpwnam(name).pw_gid
966
tcp_server = IPv6_TCPServer((server_settings["address"],
967
server_settings["port"]),
969
settings=server_settings,
971
pidfilename = "/var/run/mandos.pid"
973
pidfile = open(pidfilename, "w")
974
except IOError, error:
975
logger.error("Could not open file %r", pidfilename)
978
uid = pwd.getpwnam("_mandos").pw_uid
981
uid = pwd.getpwnam("mandos").pw_uid
984
uid = pwd.getpwnam("nobody").pw_uid
988
gid = pwd.getpwnam("_mandos").pw_gid
991
gid = pwd.getpwnam("mandos").pw_gid
994
gid = pwd.getpwnam("nogroup").pw_gid
2536
except OSError as error:
2537
if error.errno != errno.EPERM:
2541
# Enable all possible GnuTLS debugging
2543
# "Use a log level over 10 to enable all debugging options."
2545
gnutls.library.functions.gnutls_global_set_log_level(11)
2547
@gnutls.library.types.gnutls_log_func
2548
def debug_gnutls(level, string):
2549
logger.debug("GnuTLS: %s", string[:-1])
2551
gnutls.library.functions.gnutls_global_set_log_function(
2554
# Redirect stdin so all checkers get /dev/null
2555
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2556
os.dup2(null, sys.stdin.fileno())
2560
# Need to fork before connecting to D-Bus
2562
# Close all input and output, do double fork, etc.
2565
# multiprocessing will use threads, so before we use gobject we
2566
# need to inform gobject that threads will be used.
2567
gobject.threads_init()
1000
except OSError, error:
1001
if error[0] != errno.EPERM:
1005
service = AvahiService(name = server_settings["servicename"],
1006
servicetype = "_mandos._tcp", )
1007
if server_settings["interface"]:
1008
service.interface = (if_nametoindex
1009
(server_settings["interface"]))
2569
1011
global main_loop
2570
1014
# From the Avahi example code
2571
DBusGMainLoop(set_as_default=True)
1015
DBusGMainLoop(set_as_default=True )
2572
1016
main_loop = gobject.MainLoop()
2573
1017
bus = dbus.SystemBus()
1018
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1019
avahi.DBUS_PATH_SERVER),
1020
avahi.DBUS_INTERFACE_SERVER)
2574
1021
# End of Avahi example code
2577
bus_name = dbus.service.BusName("se.recompile.Mandos",
2580
old_bus_name = dbus.service.BusName(
2581
"se.bsnet.fukt.Mandos", bus,
2583
except dbus.exceptions.DBusException as e:
2584
logger.error("Disabling D-Bus:", exc_info=e)
2586
server_settings["use_dbus"] = False
2587
tcp_server.use_dbus = False
2589
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2590
service = AvahiServiceToSyslog(
2591
name = server_settings["servicename"],
2592
servicetype = "_mandos._tcp",
2593
protocol = protocol,
2595
if server_settings["interface"]:
2596
service.interface = if_nametoindex(
2597
server_settings["interface"].encode("utf-8"))
2599
global multiprocessing_manager
2600
multiprocessing_manager = multiprocessing.Manager()
2602
client_class = Client
2604
client_class = functools.partial(ClientDBus, bus = bus)
2606
client_settings = Client.config_parser(client_config)
2607
old_client_settings = {}
2610
# This is used to redirect stdout and stderr for checker processes
2612
wnull = open(os.devnull, "w") # A writable /dev/null
2613
# Only used if server is running in foreground but not in debug
2615
if debug or not foreground:
2618
# Get client data and settings from last running state.
2619
if server_settings["restore"]:
2621
with open(stored_state_path, "rb") as stored_state:
2622
clients_data, old_client_settings = pickle.load(
2624
os.remove(stored_state_path)
2625
except IOError as e:
2626
if e.errno == errno.ENOENT:
2627
logger.warning("Could not load persistent state:"
2628
" {}".format(os.strerror(e.errno)))
2630
logger.critical("Could not load persistent state:",
2633
except EOFError as e:
2634
logger.warning("Could not load persistent state: "
2638
with PGPEngine() as pgp:
2639
for client_name, client in clients_data.items():
2640
# Skip removed clients
2641
if client_name not in client_settings:
2644
# Decide which value to use after restoring saved state.
2645
# We have three different values: Old config file,
2646
# new config file, and saved state.
2647
# New config value takes precedence if it differs from old
2648
# config value, otherwise use saved state.
2649
for name, value in client_settings[client_name].items():
2651
# For each value in new config, check if it
2652
# differs from the old config value (Except for
2653
# the "secret" attribute)
2654
if (name != "secret"
2656
old_client_settings[client_name][name])):
2657
client[name] = value
2661
# Clients who has passed its expire date can still be
2662
# enabled if its last checker was successful. A Client
2663
# whose checker succeeded before we stored its state is
2664
# assumed to have successfully run all checkers during
2666
if client["enabled"]:
2667
if datetime.datetime.utcnow() >= client["expires"]:
2668
if not client["last_checked_ok"]:
2670
"disabling client {} - Client never "
2671
"performed a successful checker".format(
2673
client["enabled"] = False
2674
elif client["last_checker_status"] != 0:
2676
"disabling client {} - Client last"
2677
" checker failed with error code"
2680
client["last_checker_status"]))
2681
client["enabled"] = False
2683
client["expires"] = (
2684
datetime.datetime.utcnow()
2685
+ client["timeout"])
2686
logger.debug("Last checker succeeded,"
2687
" keeping {} enabled".format(
2690
client["secret"] = pgp.decrypt(
2691
client["encrypted_secret"],
2692
client_settings[client_name]["secret"])
2694
# If decryption fails, we use secret from new settings
2695
logger.debug("Failed to decrypt {} old secret".format(
2697
client["secret"] = (client_settings[client_name]
2700
# Add/remove clients based on new changes made to config
2701
for client_name in (set(old_client_settings)
2702
- set(client_settings)):
2703
del clients_data[client_name]
2704
for client_name in (set(client_settings)
2705
- set(old_client_settings)):
2706
clients_data[client_name] = client_settings[client_name]
2708
# Create all client objects
2709
for client_name, client in clients_data.items():
2710
tcp_server.clients[client_name] = client_class(
2713
server_settings = server_settings)
2715
if not tcp_server.clients:
2716
logger.warning("No clients defined")
2719
if pidfile is not None:
2723
print(pid, file=pidfile)
2725
logger.error("Could not write to file %r with PID %d",
1022
bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)
1024
clients.update(Set(Client(name = section,
1026
= dict(client_config.items(section)))
1027
for section in client_config.sections()))
1029
logger.critical(u"No clients defined")
1033
# Redirect stdin so all checkers get /dev/null
1034
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1035
os.dup2(null, sys.stdin.fileno())
1039
# No console logging
1040
logger.removeHandler(console)
1041
# Close all input and output, do double fork, etc.
1046
pidfile.write(str(pid) + "\n")
2730
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2731
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2735
@alternate_dbus_interfaces(
2736
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
2737
class MandosDBusService(DBusObjectWithProperties):
2738
"""A D-Bus proxy object"""
2741
dbus.service.Object.__init__(self, bus, "/")
2743
_interface = "se.recompile.Mandos"
2745
@dbus_interface_annotations(_interface)
2748
"org.freedesktop.DBus.Property.EmitsChangedSignal":
2751
@dbus.service.signal(_interface, signature="o")
2752
def ClientAdded(self, objpath):
2756
@dbus.service.signal(_interface, signature="ss")
2757
def ClientNotFound(self, fingerprint, address):
2761
@dbus.service.signal(_interface, signature="os")
2762
def ClientRemoved(self, objpath, name):
2766
@dbus.service.method(_interface, out_signature="ao")
2767
def GetAllClients(self):
2769
return dbus.Array(c.dbus_object_path for c in
2770
tcp_server.clients.itervalues())
2772
@dbus.service.method(_interface,
2773
out_signature="a{oa{sv}}")
2774
def GetAllClientsWithProperties(self):
2776
return dbus.Dictionary(
2777
{ c.dbus_object_path: c.GetAll("")
2778
for c in tcp_server.clients.itervalues() },
2781
@dbus.service.method(_interface, in_signature="o")
2782
def RemoveClient(self, object_path):
2784
for c in tcp_server.clients.itervalues():
2785
if c.dbus_object_path == object_path:
2786
del tcp_server.clients[c.name]
2787
c.remove_from_connection()
2788
# Don't signal anything except ClientRemoved
2789
c.disable(quiet=True)
2791
self.ClientRemoved(object_path, c.name)
2793
raise KeyError(object_path)
2797
mandos_dbus_service = MandosDBusService()
1050
logger.error(u"Could not write to file %r with PID %d",
1053
# "pidfile" was never created
2800
1058
"Cleanup function; run on exit"
2804
multiprocessing.active_children()
2806
if not (tcp_server.clients or client_settings):
2809
# Store client before exiting. Secrets are encrypted with key
2810
# based on what config file has. If config file is
2811
# removed/edited, old secret will thus be unrecovable.
2813
with PGPEngine() as pgp:
2814
for client in tcp_server.clients.itervalues():
2815
key = client_settings[client.name]["secret"]
2816
client.encrypted_secret = pgp.encrypt(client.secret,
2820
# A list of attributes that can not be pickled
2822
exclude = { "bus", "changedstate", "secret",
2823
"checker", "server_settings" }
2824
for name, typ in inspect.getmembers(dbus.service
2828
client_dict["encrypted_secret"] = (client
2830
for attr in client.client_structure:
2831
if attr not in exclude:
2832
client_dict[attr] = getattr(client, attr)
2834
clients[client.name] = client_dict
2835
del client_settings[client.name]["secret"]
2838
with tempfile.NamedTemporaryFile(
2842
dir=os.path.dirname(stored_state_path),
2843
delete=False) as stored_state:
2844
pickle.dump((clients, client_settings), stored_state)
2845
tempname = stored_state.name
2846
os.rename(tempname, stored_state_path)
2847
except (IOError, OSError) as e:
2853
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2854
logger.warning("Could not save persistent state: {}"
2855
.format(os.strerror(e.errno)))
2857
logger.warning("Could not save persistent state:",
2861
# Delete all clients, and settings from config
2862
while tcp_server.clients:
2863
name, client = tcp_server.clients.popitem()
2865
client.remove_from_connection()
2866
# Don't signal anything except ClientRemoved
2867
client.disable(quiet=True)
2870
mandos_dbus_service.ClientRemoved(
2871
client.dbus_object_path, client.name)
2872
client_settings.clear()
1060
# From the Avahi example code
1061
if not group is None:
1064
# End of Avahi example code
1067
client = clients.pop()
1068
client.disable_hook = None
2874
1071
atexit.register(cleanup)
2876
for client in tcp_server.clients.itervalues():
2879
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2880
# Need to initiate checking of clients
2882
client.init_checker()
1074
signal.signal(signal.SIGINT, signal.SIG_IGN)
1075
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1076
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1078
class MandosServer(dbus.service.Object):
1079
"""A D-Bus proxy object"""
1081
dbus.service.Object.__init__(self, bus,
1083
_interface = u"org.mandos_system.Mandos"
1085
@dbus.service.signal(_interface, signature="oa{sv}")
1086
def ClientAdded(self, objpath, properties):
1090
@dbus.service.signal(_interface, signature="o")
1091
def ClientRemoved(self, objpath):
1095
@dbus.service.method(_interface, out_signature="ao")
1096
def GetAllClients(self):
1097
return dbus.Array(c.dbus_object_path for c in clients)
1099
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1100
def GetAllClientsWithProperties(self):
1101
return dbus.Dictionary(
1102
((c.dbus_object_path, c.GetAllProperties())
1106
@dbus.service.method(_interface, in_signature="o")
1107
def RemoveClient(self, object_path):
1109
if c.dbus_object_path == object_path:
1117
mandos_server = MandosServer()
1119
for client in clients:
1121
mandos_server.ClientAdded(client.dbus_object_path,
1122
client.GetAllProperties())
2884
1125
tcp_server.enable()
2885
1126
tcp_server.server_activate()
2887
1128
# Find out what port we got
2889
service.port = tcp_server.socket.getsockname()[1]
2891
logger.info("Now listening on address %r, port %d,"
2892
" flowinfo %d, scope_id %d",
2893
*tcp_server.socket.getsockname())
2895
logger.info("Now listening on address %r, port %d",
2896
*tcp_server.socket.getsockname())
1129
service.port = tcp_server.socket.getsockname()[1]
1130
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1131
u" scope_id %d" % tcp_server.socket.getsockname())
2898
1133
#service.interface = tcp_server.socket.getsockname()[3]
2902
# From the Avahi example code
2905
except dbus.exceptions.DBusException as error:
2906
logger.critical("D-Bus Exception", exc_info=error)
2909
# End of Avahi example code
1136
# From the Avahi example code
1137
server.connect_to_signal("StateChanged", server_state_changed)
1139
server_state_changed(server.GetState())
1140
except dbus.exceptions.DBusException, error:
1141
logger.critical(u"DBusException: %s", error)
1143
# End of Avahi example code
2911
1145
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2912
1146
lambda *args, **kwargs:
2913
1147
(tcp_server.handle_request
2914
1148
(*args[2:], **kwargs) or True))
2916
logger.debug("Starting main loop")
1150
logger.debug(u"Starting main loop")
2917
1151
main_loop.run()
2918
except AvahiError as error:
2919
logger.critical("Avahi Error", exc_info=error)
1152
except AvahiError, error:
1153
logger.critical(u"AvahiError: %s" + unicode(error))
2922
1155
except KeyboardInterrupt:
2924
print("", file=sys.stderr)
2925
logger.debug("Server received KeyboardInterrupt")
2926
logger.debug("Server exiting")
2927
# Must run before the D-Bus bus name gets deregistered
2931
1159
if __name__ == '__main__':