264
99
max_renames: integer; maximum number of renames
265
100
rename_count: integer; counter so we only rename after collisions
266
101
a sensible number of times
267
group: D-Bus Entry Group
269
bus: dbus.SystemBus()
273
interface = avahi.IF_UNSPEC,
281
protocol = avahi.PROTO_UNSPEC,
103
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
104
type = None, port = None, TXT = None, domain = "",
105
host = "", max_renames = 12):
283
106
self.interface = interface
285
self.type = servicetype
287
self.TXT = TXT if TXT is not None else []
288
114
self.domain = domain
290
116
self.rename_count = 0
291
self.max_renames = max_renames
292
self.protocol = protocol
293
self.group = None # our entry group
296
self.entry_group_state_changed_match = None
298
def rename(self, remove=True):
299
118
"""Derived from the Avahi example code"""
300
119
if self.rename_count >= self.max_renames:
301
logger.critical("No suitable Zeroconf service name found"
302
" after %i retries, exiting.",
120
logger.critical(u"No suitable service name found after %i"
121
u" retries, exiting.", rename_count)
304
122
raise AvahiServiceError("Too many renames")
306
self.server.GetAlternativeServiceName(self.name))
123
name = server.GetAlternativeServiceName(name)
124
logger.error(u"Changing name to %r ...", name)
307
127
self.rename_count += 1
308
logger.info("Changing Zeroconf service name to %r ...",
314
except dbus.exceptions.DBusException as error:
315
if (error.get_dbus_name()
316
== "org.freedesktop.Avahi.CollisionError"):
317
logger.info("Local Zeroconf service name collision.")
318
return self.rename(remove=False)
320
logger.critical("D-Bus Exception", exc_info=error)
324
128
def remove(self):
325
129
"""Derived from the Avahi example code"""
326
if self.entry_group_state_changed_match is not None:
327
self.entry_group_state_changed_match.remove()
328
self.entry_group_state_changed_match = None
329
if self.group is not None:
130
if group is not None:
333
133
"""Derived from the Avahi example code"""
335
if self.group is None:
336
self.group = dbus.Interface(
337
self.bus.get_object(avahi.DBUS_NAME,
338
self.server.EntryGroupNew()),
339
avahi.DBUS_INTERFACE_ENTRY_GROUP)
340
self.entry_group_state_changed_match = (
341
self.group.connect_to_signal(
342
'StateChanged', self.entry_group_state_changed))
343
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
344
self.name, self.type)
345
self.group.AddService(
348
dbus.UInt32(0), # flags
349
self.name, self.type,
350
self.domain, self.host,
351
dbus.UInt16(self.port),
352
avahi.string_array_to_txt_array(self.TXT))
355
def entry_group_state_changed(self, state, error):
356
"""Derived from the Avahi example code"""
357
logger.debug("Avahi entry group state change: %i", state)
359
if state == avahi.ENTRY_GROUP_ESTABLISHED:
360
logger.debug("Zeroconf service established.")
361
elif state == avahi.ENTRY_GROUP_COLLISION:
362
logger.info("Zeroconf service name collision.")
364
elif state == avahi.ENTRY_GROUP_FAILURE:
365
logger.critical("Avahi: Error in group state changed %s",
367
raise AvahiGroupError("State changed: {!s}".format(error))
370
"""Derived from the Avahi example code"""
371
if self.group is not None:
374
except (dbus.exceptions.UnknownMethodException,
375
dbus.exceptions.DBusException):
380
def server_state_changed(self, state, error=None):
381
"""Derived from the Avahi example code"""
382
logger.debug("Avahi server state change: %i", state)
384
avahi.SERVER_INVALID: "Zeroconf server invalid",
385
avahi.SERVER_REGISTERING: None,
386
avahi.SERVER_COLLISION: "Zeroconf server name collision",
387
avahi.SERVER_FAILURE: "Zeroconf server failure",
389
if state in bad_states:
390
if bad_states[state] is not None:
392
logger.error(bad_states[state])
394
logger.error(bad_states[state] + ": %r", error)
396
elif state == avahi.SERVER_RUNNING:
400
logger.debug("Unknown state: %r", state)
402
logger.debug("Unknown state: %r: %r", state, error)
405
"""Derived from the Avahi example code"""
406
if self.server is None:
407
self.server = dbus.Interface(
408
self.bus.get_object(avahi.DBUS_NAME,
409
avahi.DBUS_PATH_SERVER,
410
follow_name_owner_changes=True),
411
avahi.DBUS_INTERFACE_SERVER)
412
self.server.connect_to_signal("StateChanged",
413
self.server_state_changed)
414
self.server_state_changed(self.server.GetState())
417
class AvahiServiceToSyslog(AvahiService):
418
def rename(self, *args, **kwargs):
419
"""Add the new name to the syslog messages"""
420
ret = AvahiService.rename(self, *args, **kwargs)
421
syslogger.setFormatter(logging.Formatter(
422
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
136
group = dbus.Interface\
137
(bus.get_object(avahi.DBUS_NAME,
138
server.EntryGroupNew()),
139
avahi.DBUS_INTERFACE_ENTRY_GROUP)
140
group.connect_to_signal('StateChanged',
141
entry_group_state_changed)
142
logger.debug(u"Adding service '%s' of type '%s' ...",
143
service.name, service.type)
145
self.interface, # interface
146
avahi.PROTO_INET6, # protocol
147
dbus.UInt32(0), # flags
148
self.name, self.type,
149
self.domain, self.host,
150
dbus.UInt16(self.port),
151
avahi.string_array_to_txt_array(self.TXT))
154
# From the Avahi example code:
155
group = None # our entry group
156
# End of Avahi example code
427
159
class Client(object):
428
160
"""A representation of a client host served by this server.
431
approved: bool(); 'None' if not yet approved/disapproved
432
approval_delay: datetime.timedelta(); Time to wait for approval
433
approval_duration: datetime.timedelta(); Duration of one approval
434
checker: subprocess.Popen(); a running checker process used
435
to see if the client lives.
436
'None' if no process is running.
437
checker_callback_tag: a gobject event source tag, or None
438
checker_command: string; External command which is run to check
439
if client lives. %() expansions are done at
162
name: string; from the config file, used in log messages
163
fingerprint: string (40 or 32 hexadecimal digits); used to
164
uniquely identify the client
165
secret: bytestring; sent verbatim (over TLS) to client
166
fqdn: string (FQDN); available for use by the checker command
167
created: datetime.datetime(); object creation, not client host
168
last_checked_ok: datetime.datetime() or None if not yet checked OK
169
timeout: datetime.timedelta(); How long from last_checked_ok
170
until this client is invalid
171
interval: datetime.timedelta(); How often to start a new checker
172
stop_hook: If set, called by stop() as stop_hook(self)
173
checker: subprocess.Popen(); a running checker process used
174
to see if the client lives.
175
'None' if no process is running.
176
checker_initiator_tag: a gobject event source tag, or None
177
stop_initiator_tag: - '' -
178
checker_callback_tag: - '' -
179
checker_command: string; External command which is run to check if
180
client lives. %() expansions are done at
440
181
runtime with vars(self) as dict, so that for
441
182
instance %(name)s can be used in the command.
442
checker_initiator_tag: a gobject event source tag, or None
443
created: datetime.datetime(); (UTC) object creation
444
client_structure: Object describing what attributes a client has
445
and is used for storing the client at exit
446
current_checker_command: string; current running checker_command
447
disable_initiator_tag: a gobject event source tag, or None
449
fingerprint: string (40 or 32 hexadecimal digits); used to
450
uniquely identify the client
451
host: string; available for use by the checker command
452
interval: datetime.timedelta(); How often to start a new checker
453
last_approval_request: datetime.datetime(); (UTC) or None
454
last_checked_ok: datetime.datetime(); (UTC) or None
455
last_checker_status: integer between 0 and 255 reflecting exit
456
status of last checker. -1 reflects crashed
457
checker, -2 means no checker completed yet.
458
last_enabled: datetime.datetime(); (UTC) or None
459
name: string; from the config file, used in log messages and
461
secret: bytestring; sent verbatim (over TLS) to client
462
timeout: datetime.timedelta(); How long from last_checked_ok
463
until this client is disabled
464
extended_timeout: extra long timeout when secret has been sent
465
runtime_expansions: Allowed attributes for runtime expansion.
466
expires: datetime.datetime(); time (UTC) when a client will be
468
server_settings: The server_settings dict from main()
184
_timeout: Real variable for 'timeout'
185
_interval: Real variable for 'interval'
186
_timeout_milliseconds: Used when calling gobject.timeout_add()
187
_interval_milliseconds: - '' -
471
runtime_expansions = ("approval_delay", "approval_duration",
472
"created", "enabled", "expires",
473
"fingerprint", "host", "interval",
474
"last_approval_request", "last_checked_ok",
475
"last_enabled", "name", "timeout")
478
"extended_timeout": "PT15M",
480
"checker": "fping -q -- %%(host)s",
482
"approval_delay": "PT0S",
483
"approval_duration": "PT1S",
484
"approved_by_default": "True",
489
def config_parser(config):
490
"""Construct a new dict of client settings of this form:
491
{ client_name: {setting_name: value, ...}, ...}
492
with exceptions for any special settings as defined above.
493
NOTE: Must be a pure function. Must return the same result
494
value given the same arguments.
497
for client_name in config.sections():
498
section = dict(config.items(client_name))
499
client = settings[client_name] = {}
501
client["host"] = section["host"]
502
# Reformat values from string types to Python types
503
client["approved_by_default"] = config.getboolean(
504
client_name, "approved_by_default")
505
client["enabled"] = config.getboolean(client_name,
508
# Uppercase and remove spaces from fingerprint for later
509
# comparison purposes with return value from the
510
# fingerprint() function
511
client["fingerprint"] = (section["fingerprint"].upper()
513
if "secret" in section:
514
client["secret"] = section["secret"].decode("base64")
515
elif "secfile" in section:
516
with open(os.path.expanduser(os.path.expandvars
517
(section["secfile"])),
519
client["secret"] = secfile.read()
521
raise TypeError("No secret or secfile for section {}"
523
client["timeout"] = string_to_delta(section["timeout"])
524
client["extended_timeout"] = string_to_delta(
525
section["extended_timeout"])
526
client["interval"] = string_to_delta(section["interval"])
527
client["approval_delay"] = string_to_delta(
528
section["approval_delay"])
529
client["approval_duration"] = string_to_delta(
530
section["approval_duration"])
531
client["checker_command"] = section["checker"]
532
client["last_approval_request"] = None
533
client["last_checked_ok"] = None
534
client["last_checker_status"] = -2
538
def __init__(self, settings, name = None, server_settings=None):
189
def _set_timeout(self, timeout):
190
"Setter function for 'timeout' attribute"
191
self._timeout = timeout
192
self._timeout_milliseconds = ((self.timeout.days
193
* 24 * 60 * 60 * 1000)
194
+ (self.timeout.seconds * 1000)
195
+ (self.timeout.microseconds
197
timeout = property(lambda self: self._timeout,
200
def _set_interval(self, interval):
201
"Setter function for 'interval' attribute"
202
self._interval = interval
203
self._interval_milliseconds = ((self.interval.days
204
* 24 * 60 * 60 * 1000)
205
+ (self.interval.seconds
207
+ (self.interval.microseconds
209
interval = property(lambda self: self._interval,
212
def __init__(self, name = None, stop_hook=None, config={}):
213
"""Note: the 'checker' key in 'config' sets the
214
'checker_command' attribute and *not* the 'checker'
540
if server_settings is None:
542
self.server_settings = server_settings
543
# adding all client settings
544
for setting, value in settings.items():
545
setattr(self, setting, value)
548
if not hasattr(self, "last_enabled"):
549
self.last_enabled = datetime.datetime.utcnow()
550
if not hasattr(self, "expires"):
551
self.expires = (datetime.datetime.utcnow()
217
logger.debug(u"Creating client %r", self.name)
218
# Uppercase and remove spaces from fingerprint for later
219
# comparison purposes with return value from the fingerprint()
221
self.fingerprint = config["fingerprint"].upper()\
223
logger.debug(u" Fingerprint: %s", self.fingerprint)
224
if "secret" in config:
225
self.secret = config["secret"].decode(u"base64")
226
elif "secfile" in config:
227
sf = open(config["secfile"])
228
self.secret = sf.read()
554
self.last_enabled = None
557
logger.debug("Creating client %r", self.name)
558
logger.debug(" Fingerprint: %s", self.fingerprint)
559
self.created = settings.get("created",
560
datetime.datetime.utcnow())
562
# attributes specific for this server instance
231
raise TypeError(u"No secret or secfile for client %s"
233
self.fqdn = config.get("fqdn", "")
234
self.created = datetime.datetime.now()
235
self.last_checked_ok = None
236
self.timeout = string_to_delta(config["timeout"])
237
self.interval = string_to_delta(config["interval"])
238
self.stop_hook = stop_hook
563
239
self.checker = None
564
240
self.checker_initiator_tag = None
565
self.disable_initiator_tag = None
241
self.stop_initiator_tag = None
566
242
self.checker_callback_tag = None
567
self.current_checker_command = None
569
self.approvals_pending = 0
570
self.changedstate = multiprocessing_manager.Condition(
571
multiprocessing_manager.Lock())
572
self.client_structure = [attr
573
for attr in self.__dict__.iterkeys()
574
if not attr.startswith("_")]
575
self.client_structure.append("client_structure")
577
for name, t in inspect.getmembers(
578
type(self), lambda obj: isinstance(obj, property)):
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()
243
self.check_command = config["checker"]
588
245
"""Start this client's checker and timeout hooks"""
589
if getattr(self, "enabled", False):
592
self.expires = datetime.datetime.utcnow() + self.timeout
594
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
246
# Schedule a new checker to be started an 'interval' from now,
623
247
# and every interval from then on.
624
if self.checker_initiator_tag is not None:
625
gobject.source_remove(self.checker_initiator_tag)
626
self.checker_initiator_tag = gobject.timeout_add(
627
int(self.interval.total_seconds() * 1000),
629
# 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
self.disable_initiator_tag = gobject.timeout_add(
633
int(self.timeout.total_seconds() * 1000), self.disable)
248
self.checker_initiator_tag = gobject.timeout_add\
249
(self._interval_milliseconds,
634
251
# Also start a new checker *right now*.
635
252
self.start_checker()
637
def checker_callback(self, pid, condition, command):
253
# Schedule a stop() when 'timeout' has passed
254
self.stop_initiator_tag = gobject.timeout_add\
255
(self._timeout_milliseconds,
259
The possibility that a client might be restarted is left open,
260
but not currently used."""
261
# If this client doesn't have a secret, it is already stopped.
263
logger.info(u"Stopping client %s", self.name)
267
if getattr(self, "stop_initiator_tag", False):
268
gobject.source_remove(self.stop_initiator_tag)
269
self.stop_initiator_tag = None
270
if getattr(self, "checker_initiator_tag", False):
271
gobject.source_remove(self.checker_initiator_tag)
272
self.checker_initiator_tag = None
276
# Do not run this again if called by a gobject.timeout_add
279
self.stop_hook = None
281
def checker_callback(self, pid, condition):
638
282
"""The checker has completed, so take appropriate actions."""
283
now = datetime.datetime.now()
639
284
self.checker_callback_tag = None
640
285
self.checker = None
641
if os.WIFEXITED(condition):
642
self.last_checker_status = os.WEXITSTATUS(condition)
643
if self.last_checker_status == 0:
644
logger.info("Checker for %(name)s succeeded",
648
logger.info("Checker for %(name)s failed", vars(self))
650
self.last_checker_status = -1
651
logger.warning("Checker for %(name)s crashed?",
286
if os.WIFEXITED(condition) \
287
and (os.WEXITSTATUS(condition) == 0):
288
logger.info(u"Checker for %(name)s succeeded",
290
self.last_checked_ok = now
291
gobject.source_remove(self.stop_initiator_tag)
292
self.stop_initiator_tag = gobject.timeout_add\
293
(self._timeout_milliseconds,
295
elif not os.WIFEXITED(condition):
296
logger.warning(u"Checker for %(name)s crashed?",
654
def checked_ok(self):
655
"""Assert that the client has been seen, alive and well."""
656
self.last_checked_ok = datetime.datetime.utcnow()
657
self.last_checker_status = 0
660
def bump_timeout(self, timeout=None):
661
"""Bump up the timeout for this client."""
663
timeout = self.timeout
664
if self.disable_initiator_tag is not None:
665
gobject.source_remove(self.disable_initiator_tag)
666
self.disable_initiator_tag = None
667
if getattr(self, "enabled", False):
668
self.disable_initiator_tag = gobject.timeout_add(
669
int(timeout.total_seconds() * 1000), self.disable)
670
self.expires = datetime.datetime.utcnow() + timeout
672
def need_approval(self):
673
self.last_approval_request = datetime.datetime.utcnow()
299
logger.info(u"Checker for %(name)s failed",
675
301
def start_checker(self):
676
302
"""Start a new checker subprocess if one is not running.
678
303
If a checker already exists, leave it running and do
680
305
# The reason for not killing a running checker is that if we
681
# did that, and if a checker (for some reason) started running
682
# slowly and taking more than 'interval' time, then the client
683
# would inevitably timeout, since no checker would get a
684
# chance to run to completion. If we instead leave running
306
# did that, then if a checker (for some reason) started
307
# running slowly and taking more than 'interval' time, the
308
# client would inevitably timeout, since no checker would get
309
# a chance to run to completion. If we instead leave running
685
310
# checkers alone, the checker would have to take more time
686
# than 'timeout' for the client to be disabled, which is as it
689
# If a checker exists, make sure it is not a zombie
691
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
692
except AttributeError:
694
except OSError as error:
695
if error.errno != errno.ECHILD:
699
logger.warning("Checker was a zombie")
700
gobject.source_remove(self.checker_callback_tag)
701
self.checker_callback(pid, status,
702
self.current_checker_command)
703
# Start a new checker if needed
311
# than 'timeout' for the client to be declared invalid, which
312
# is as it should be.
704
313
if self.checker is None:
705
# Escape attributes for the shell
707
attr: re.escape(str(getattr(self, attr)))
708
for attr in self.runtime_expansions }
710
command = self.checker_command % escaped_attrs
711
except TypeError as error:
712
logger.error('Could not format string "%s"',
713
self.checker_command,
715
return True # Try again later
716
self.current_checker_command = command
718
logger.info("Starting checker %r for %s", command,
720
# We don't need to redirect stdout and stderr, since
721
# in normal mode, that is already done by daemon(),
722
# and in debug mode we don't want to. (Stdin is
723
# always replaced by /dev/null.)
724
# The exception is when not debugging but nevertheless
725
# running in the foreground; use the previously
728
if (not self.server_settings["debug"]
729
and self.server_settings["foreground"]):
730
popen_args.update({"stdout": wnull,
315
# In case check_command has exactly one % operator
316
command = self.check_command % self.fqdn
318
# Escape attributes for the shell
319
escaped_attrs = dict((key, re.escape(str(val)))
321
vars(self).iteritems())
323
command = self.check_command % escaped_attrs
324
except TypeError, error:
325
logger.error(u'Could not format string "%s":'
326
u' %s', self.check_command, error)
327
return True # Try again later
329
logger.info(u"Starting checker %r for %s",
732
331
self.checker = subprocess.Popen(command,
737
except OSError as error:
738
logger.error("Failed to start subprocess",
741
self.checker_callback_tag = gobject.child_watch_add(
742
self.checker.pid, self.checker_callback, data=command)
743
# The checker may have completed before the gobject
744
# watch was added. Check for this.
746
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
747
except OSError as error:
748
if error.errno == errno.ECHILD:
749
# This should never happen
750
logger.error("Child process vanished",
755
gobject.source_remove(self.checker_callback_tag)
756
self.checker_callback(pid, status, command)
334
self.checker_callback_tag = gobject.child_watch_add\
336
self.checker_callback)
337
except subprocess.OSError, error:
338
logger.error(u"Failed to start subprocess: %s",
757
340
# Re-run this periodically if run by gobject.timeout_add
760
342
def stop_checker(self):
761
343
"""Force the checker process, if any, to stop."""
762
344
if self.checker_callback_tag:
767
349
logger.debug("Stopping checker for %(name)s", vars(self))
769
self.checker.terminate()
351
os.kill(self.checker.pid, signal.SIGTERM)
771
353
#if self.checker.poll() is None:
772
# self.checker.kill()
773
except OSError as error:
354
# os.kill(self.checker.pid, signal.SIGKILL)
355
except OSError, error:
774
356
if error.errno != errno.ESRCH: # No such process
776
358
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
# Extract the original non-method undecorated
1114
# function by black magic
1115
nonmethod_func = (dict(
1116
zip(attribute.func_code.co_freevars,
1117
attribute.__closure__))
1118
["func"].cell_contents)
1119
# Create a new, but exactly alike, function
1120
# object, and decorate it to be a new D-Bus signal
1121
# with the alternate D-Bus interface name
1122
new_function = (dbus.service.signal(
1123
alt_interface, attribute._dbus_signature)
1124
(types.FunctionType(
1125
nonmethod_func.func_code,
1126
nonmethod_func.func_globals,
1127
nonmethod_func.func_name,
1128
nonmethod_func.func_defaults,
1129
nonmethod_func.func_closure)))
1130
# Copy annotations, if any
1132
new_function._dbus_annotations = dict(
1133
attribute._dbus_annotations)
1134
except AttributeError:
1136
# Define a creator of a function to call both the
1137
# original and alternate functions, so both the
1138
# original and alternate signals gets sent when
1139
# the function is called
1140
def fixscope(func1, func2):
1141
"""This function is a scope container to pass
1142
func1 and func2 to the "call_both" function
1143
outside of its arguments"""
1145
def call_both(*args, **kwargs):
1146
"""This function will emit two D-Bus
1147
signals by calling func1 and func2"""
1148
func1(*args, **kwargs)
1149
func2(*args, **kwargs)
1152
# Create the "call_both" function and add it to
1154
attr[attrname] = fixscope(attribute, new_function)
1155
# Is this a D-Bus method?
1156
elif getattr(attribute, "_dbus_is_method", False):
1157
# Create a new, but exactly alike, function
1158
# object. Decorate it to be a new D-Bus method
1159
# with the alternate D-Bus interface name. Add it
1162
dbus.service.method(
1164
attribute._dbus_in_signature,
1165
attribute._dbus_out_signature)
1166
(types.FunctionType(attribute.func_code,
1167
attribute.func_globals,
1168
attribute.func_name,
1169
attribute.func_defaults,
1170
attribute.func_closure)))
1171
# Copy annotations, if any
1173
attr[attrname]._dbus_annotations = dict(
1174
attribute._dbus_annotations)
1175
except AttributeError:
1177
# Is this a D-Bus property?
1178
elif getattr(attribute, "_dbus_is_property", False):
1179
# Create a new, but exactly alike, function
1180
# object, and decorate it to be a new D-Bus
1181
# property with the alternate D-Bus interface
1182
# name. Add it to the class.
1183
attr[attrname] = (dbus_service_property(
1184
alt_interface, attribute._dbus_signature,
1185
attribute._dbus_access,
1186
attribute._dbus_get_args_options
1188
(types.FunctionType(
1189
attribute.func_code,
1190
attribute.func_globals,
1191
attribute.func_name,
1192
attribute.func_defaults,
1193
attribute.func_closure)))
1194
# Copy annotations, if any
1196
attr[attrname]._dbus_annotations = dict(
1197
attribute._dbus_annotations)
1198
except AttributeError:
1200
# Is this a D-Bus interface?
1201
elif getattr(attribute, "_dbus_is_interface", False):
1202
# Create a new, but exactly alike, function
1203
# object. Decorate it to be a new D-Bus interface
1204
# with the alternate D-Bus interface name. Add it
1207
dbus_interface_annotations(alt_interface)
1208
(types.FunctionType(attribute.func_code,
1209
attribute.func_globals,
1210
attribute.func_name,
1211
attribute.func_defaults,
1212
attribute.func_closure)))
1214
# Deprecate all alternate interfaces
1215
iname="_AlternateDBusNames_interface_annotation{}"
1216
for interface_name in interface_names:
1218
@dbus_interface_annotations(interface_name)
1220
return { "org.freedesktop.DBus.Deprecated":
1222
# Find an unused name
1223
for aname in (iname.format(i)
1224
for i in itertools.count()):
1225
if aname not in attr:
1229
# Replace the class with a new subclass of it with
1230
# methods, signals, etc. as created above.
1231
cls = type(b"{}Alternate".format(cls.__name__),
1238
@alternate_dbus_interfaces({"se.recompile.Mandos":
1239
"se.bsnet.fukt.Mandos"})
1240
class ClientDBus(Client, DBusObjectWithProperties):
1241
"""A Client class using D-Bus
1244
dbus_object_path: dbus.ObjectPath
1245
bus: dbus.SystemBus()
1248
runtime_expansions = (Client.runtime_expansions
1249
+ ("dbus_object_path", ))
1251
_interface = "se.recompile.Mandos.Client"
1253
# dbus.service.Object doesn't use super(), so we can't either.
1255
def __init__(self, bus = None, *args, **kwargs):
1257
Client.__init__(self, *args, **kwargs)
1258
# Only now, when this client is initialized, can it show up on
1260
client_object_name = str(self.name).translate(
1261
{ord("."): ord("_"),
1262
ord("-"): ord("_")})
1263
self.dbus_object_path = dbus.ObjectPath(
1264
"/clients/" + client_object_name)
1265
DBusObjectWithProperties.__init__(self, self.bus,
1266
self.dbus_object_path)
1268
def notifychangeproperty(transform_func, dbus_name,
1269
type_func=lambda x: x,
1271
invalidate_only=False,
1272
_interface=_interface):
1273
""" Modify a variable so that it's a property which announces
1274
its changes to DBus.
1276
transform_fun: Function that takes a value and a variant_level
1277
and transforms it to a D-Bus type.
1278
dbus_name: D-Bus name of the variable
1279
type_func: Function that transform the value before sending it
1280
to the D-Bus. Default: no transform
1281
variant_level: D-Bus variant level. Default: 1
1283
attrname = "_{}".format(dbus_name)
1285
def setter(self, value):
1286
if hasattr(self, "dbus_object_path"):
1287
if (not hasattr(self, attrname) or
1288
type_func(getattr(self, attrname, None))
1289
!= type_func(value)):
1291
self.PropertiesChanged(
1292
_interface, dbus.Dictionary(),
1293
dbus.Array((dbus_name, )))
1295
dbus_value = transform_func(
1297
variant_level = variant_level)
1298
self.PropertyChanged(dbus.String(dbus_name),
1300
self.PropertiesChanged(
1302
dbus.Dictionary({ dbus.String(dbus_name):
1305
setattr(self, attrname, value)
1307
return property(lambda self: getattr(self, attrname), setter)
1309
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1310
approvals_pending = notifychangeproperty(dbus.Boolean,
1313
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1314
last_enabled = notifychangeproperty(datetime_to_dbus,
1316
checker = notifychangeproperty(
1317
dbus.Boolean, "CheckerRunning",
1318
type_func = lambda checker: checker is not None)
1319
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1321
last_checker_status = notifychangeproperty(dbus.Int16,
1322
"LastCheckerStatus")
1323
last_approval_request = notifychangeproperty(
1324
datetime_to_dbus, "LastApprovalRequest")
1325
approved_by_default = notifychangeproperty(dbus.Boolean,
1326
"ApprovedByDefault")
1327
approval_delay = notifychangeproperty(
1328
dbus.UInt64, "ApprovalDelay",
1329
type_func = lambda td: td.total_seconds() * 1000)
1330
approval_duration = notifychangeproperty(
1331
dbus.UInt64, "ApprovalDuration",
1332
type_func = lambda td: td.total_seconds() * 1000)
1333
host = notifychangeproperty(dbus.String, "Host")
1334
timeout = notifychangeproperty(
1335
dbus.UInt64, "Timeout",
1336
type_func = lambda td: td.total_seconds() * 1000)
1337
extended_timeout = notifychangeproperty(
1338
dbus.UInt64, "ExtendedTimeout",
1339
type_func = lambda td: td.total_seconds() * 1000)
1340
interval = notifychangeproperty(
1341
dbus.UInt64, "Interval",
1342
type_func = lambda td: td.total_seconds() * 1000)
1343
checker_command = notifychangeproperty(dbus.String, "Checker")
1344
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1345
invalidate_only=True)
1347
del notifychangeproperty
1349
def __del__(self, *args, **kwargs):
1351
self.remove_from_connection()
1354
if hasattr(DBusObjectWithProperties, "__del__"):
1355
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1356
Client.__del__(self, *args, **kwargs)
1358
def checker_callback(self, pid, condition, command,
1360
self.checker_callback_tag = None
1362
if os.WIFEXITED(condition):
1363
exitstatus = os.WEXITSTATUS(condition)
1365
self.CheckerCompleted(dbus.Int16(exitstatus),
1366
dbus.Int64(condition),
1367
dbus.String(command))
1370
self.CheckerCompleted(dbus.Int16(-1),
1371
dbus.Int64(condition),
1372
dbus.String(command))
1374
return Client.checker_callback(self, pid, condition, command,
1377
def start_checker(self, *args, **kwargs):
1378
old_checker_pid = getattr(self.checker, "pid", None)
1379
r = Client.start_checker(self, *args, **kwargs)
1380
# Only if new checker process was started
1381
if (self.checker is not None
1382
and old_checker_pid != self.checker.pid):
1384
self.CheckerStarted(self.current_checker_command)
1387
def _reset_approved(self):
1388
self.approved = None
1391
def approve(self, value=True):
1392
self.approved = value
1393
gobject.timeout_add(int(self.approval_duration.total_seconds()
1394
* 1000), self._reset_approved)
1395
self.send_changedstate()
1397
## D-Bus methods, signals & properties
1403
# CheckerCompleted - signal
1404
@dbus.service.signal(_interface, signature="nxs")
1405
def CheckerCompleted(self, exitcode, waitstatus, command):
1409
# CheckerStarted - signal
1410
@dbus.service.signal(_interface, signature="s")
1411
def CheckerStarted(self, command):
1415
# PropertyChanged - signal
1416
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1417
@dbus.service.signal(_interface, signature="sv")
1418
def PropertyChanged(self, property, value):
1422
# GotSecret - signal
1423
@dbus.service.signal(_interface)
1424
def GotSecret(self):
1426
Is sent after a successful transfer of secret from the Mandos
1427
server to mandos-client
1432
@dbus.service.signal(_interface, signature="s")
1433
def Rejected(self, reason):
1437
# NeedApproval - signal
1438
@dbus.service.signal(_interface, signature="tb")
1439
def NeedApproval(self, timeout, default):
1441
return self.need_approval()
1446
@dbus.service.method(_interface, in_signature="b")
1447
def Approve(self, value):
1450
# CheckedOK - method
1451
@dbus.service.method(_interface)
1452
def CheckedOK(self):
1456
@dbus.service.method(_interface)
1461
# StartChecker - method
1462
@dbus.service.method(_interface)
1463
def StartChecker(self):
1465
self.start_checker()
1468
@dbus.service.method(_interface)
1473
# StopChecker - method
1474
@dbus.service.method(_interface)
1475
def StopChecker(self):
1480
# ApprovalPending - property
1481
@dbus_service_property(_interface, signature="b", access="read")
1482
def ApprovalPending_dbus_property(self):
1483
return dbus.Boolean(bool(self.approvals_pending))
1485
# ApprovedByDefault - property
1486
@dbus_service_property(_interface,
1489
def ApprovedByDefault_dbus_property(self, value=None):
1490
if value is None: # get
1491
return dbus.Boolean(self.approved_by_default)
1492
self.approved_by_default = bool(value)
1494
# ApprovalDelay - property
1495
@dbus_service_property(_interface,
1498
def ApprovalDelay_dbus_property(self, value=None):
1499
if value is None: # get
1500
return dbus.UInt64(self.approval_delay.total_seconds()
1502
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1504
# ApprovalDuration - property
1505
@dbus_service_property(_interface,
1508
def ApprovalDuration_dbus_property(self, value=None):
1509
if value is None: # get
1510
return dbus.UInt64(self.approval_duration.total_seconds()
1512
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1515
@dbus_service_property(_interface, signature="s", access="read")
1516
def Name_dbus_property(self):
1517
return dbus.String(self.name)
1519
# Fingerprint - property
1520
@dbus_service_property(_interface, signature="s", access="read")
1521
def Fingerprint_dbus_property(self):
1522
return dbus.String(self.fingerprint)
1525
@dbus_service_property(_interface,
1528
def Host_dbus_property(self, value=None):
1529
if value is None: # get
1530
return dbus.String(self.host)
1531
self.host = str(value)
1533
# Created - property
1534
@dbus_service_property(_interface, signature="s", access="read")
1535
def Created_dbus_property(self):
1536
return datetime_to_dbus(self.created)
1538
# LastEnabled - property
1539
@dbus_service_property(_interface, signature="s", access="read")
1540
def LastEnabled_dbus_property(self):
1541
return datetime_to_dbus(self.last_enabled)
1543
# Enabled - property
1544
@dbus_service_property(_interface,
1547
def Enabled_dbus_property(self, value=None):
1548
if value is None: # get
1549
return dbus.Boolean(self.enabled)
1555
# LastCheckedOK - property
1556
@dbus_service_property(_interface,
1559
def LastCheckedOK_dbus_property(self, value=None):
1560
if value is not None:
1563
return datetime_to_dbus(self.last_checked_ok)
1565
# LastCheckerStatus - property
1566
@dbus_service_property(_interface, signature="n", access="read")
1567
def LastCheckerStatus_dbus_property(self):
1568
return dbus.Int16(self.last_checker_status)
1570
# Expires - property
1571
@dbus_service_property(_interface, signature="s", access="read")
1572
def Expires_dbus_property(self):
1573
return datetime_to_dbus(self.expires)
1575
# LastApprovalRequest - property
1576
@dbus_service_property(_interface, signature="s", access="read")
1577
def LastApprovalRequest_dbus_property(self):
1578
return datetime_to_dbus(self.last_approval_request)
1580
# Timeout - property
1581
@dbus_service_property(_interface,
1584
def Timeout_dbus_property(self, value=None):
1585
if value is None: # get
1586
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1587
old_timeout = self.timeout
1588
self.timeout = datetime.timedelta(0, 0, 0, value)
1589
# Reschedule disabling
1591
now = datetime.datetime.utcnow()
1592
self.expires += self.timeout - old_timeout
1593
if self.expires <= now:
1594
# The timeout has passed
1597
if (getattr(self, "disable_initiator_tag", None)
1600
gobject.source_remove(self.disable_initiator_tag)
1601
self.disable_initiator_tag = gobject.timeout_add(
1602
int((self.expires - now).total_seconds() * 1000),
1605
# ExtendedTimeout - property
1606
@dbus_service_property(_interface,
1609
def ExtendedTimeout_dbus_property(self, value=None):
1610
if value is None: # get
1611
return dbus.UInt64(self.extended_timeout.total_seconds()
1613
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1615
# Interval - property
1616
@dbus_service_property(_interface,
1619
def Interval_dbus_property(self, value=None):
1620
if value is None: # get
1621
return dbus.UInt64(self.interval.total_seconds() * 1000)
1622
self.interval = datetime.timedelta(0, 0, 0, value)
1623
if getattr(self, "checker_initiator_tag", None) is None:
1626
# Reschedule checker run
1627
gobject.source_remove(self.checker_initiator_tag)
1628
self.checker_initiator_tag = gobject.timeout_add(
1629
value, self.start_checker)
1630
self.start_checker() # Start one now, too
1632
# Checker - property
1633
@dbus_service_property(_interface,
1636
def Checker_dbus_property(self, value=None):
1637
if value is None: # get
1638
return dbus.String(self.checker_command)
1639
self.checker_command = str(value)
1641
# CheckerRunning - property
1642
@dbus_service_property(_interface,
1645
def CheckerRunning_dbus_property(self, value=None):
1646
if value is None: # get
1647
return dbus.Boolean(self.checker is not None)
1649
self.start_checker()
1653
# ObjectPath - property
1654
@dbus_service_property(_interface, signature="o", access="read")
1655
def ObjectPath_dbus_property(self):
1656
return self.dbus_object_path # is already a dbus.ObjectPath
1659
@dbus_service_property(_interface,
1663
def Secret_dbus_property(self, value):
1664
self.secret = bytes(value)
1669
class ProxyClient(object):
1670
def __init__(self, child_pipe, fpr, address):
1671
self._pipe = child_pipe
1672
self._pipe.send(('init', fpr, address))
1673
if not self._pipe.recv():
1676
def __getattribute__(self, name):
1678
return super(ProxyClient, self).__getattribute__(name)
1679
self._pipe.send(('getattr', name))
1680
data = self._pipe.recv()
1681
if data[0] == 'data':
1683
if data[0] == 'function':
1685
def func(*args, **kwargs):
1686
self._pipe.send(('funcall', name, args, kwargs))
1687
return self._pipe.recv()[1]
1691
def __setattr__(self, name, value):
1693
return super(ProxyClient, self).__setattr__(name, value)
1694
self._pipe.send(('setattr', name, value))
1697
class ClientHandler(socketserver.BaseRequestHandler, object):
1698
"""A class to handle client connections.
1700
Instantiated once for each connection to handle it.
359
def still_valid(self):
360
"""Has the timeout not yet passed for this client?"""
361
now = datetime.datetime.now()
362
if self.last_checked_ok is None:
363
return now < (self.created + self.timeout)
365
return now < (self.last_checked_ok + self.timeout)
368
def peer_certificate(session):
369
"Return the peer's OpenPGP certificate as a bytestring"
370
# If not an OpenPGP certificate...
371
if gnutls.library.functions.gnutls_certificate_type_get\
372
(session._c_object) \
373
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
374
# ...do the normal thing
375
return session.peer_certificate
376
list_size = ctypes.c_uint()
377
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
378
(session._c_object, ctypes.byref(list_size))
379
if list_size.value == 0:
382
return ctypes.string_at(cert.data, cert.size)
385
def fingerprint(openpgp):
386
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
387
# New GnuTLS "datum" with the OpenPGP public key
388
datum = gnutls.library.types.gnutls_datum_t\
389
(ctypes.cast(ctypes.c_char_p(openpgp),
390
ctypes.POINTER(ctypes.c_ubyte)),
391
ctypes.c_uint(len(openpgp)))
392
# New empty GnuTLS certificate
393
crt = gnutls.library.types.gnutls_openpgp_crt_t()
394
gnutls.library.functions.gnutls_openpgp_crt_init\
396
# Import the OpenPGP public key into the certificate
397
gnutls.library.functions.gnutls_openpgp_crt_import\
398
(crt, ctypes.byref(datum),
399
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
400
# New buffer for the fingerprint
401
buffer = ctypes.create_string_buffer(20)
402
buffer_length = ctypes.c_size_t()
403
# Get the fingerprint from the certificate into the buffer
404
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
405
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
406
# Deinit the certificate
407
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
408
# Convert the buffer to a Python bytestring
409
fpr = ctypes.string_at(buffer, buffer_length.value)
410
# Convert the bytestring to hexadecimal notation
411
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
415
class tcp_handler(SocketServer.BaseRequestHandler, object):
416
"""A TCP request handler class.
417
Instantiated by IPv6_TCPServer for each request to handle it.
1701
418
Note: This will run in its own forked process."""
1703
420
def handle(self):
1704
with contextlib.closing(self.server.child_pipe) as child_pipe:
1705
logger.info("TCP connection from: %s",
1706
str(self.client_address))
1707
logger.debug("Pipe FD: %d",
1708
self.server.child_pipe.fileno())
1710
session = gnutls.connection.ClientSession(
1711
self.request, gnutls.connection .X509Credentials())
1713
# Note: gnutls.connection.X509Credentials is really a
1714
# generic GnuTLS certificate credentials object so long as
1715
# no X.509 keys are added to it. Therefore, we can use it
1716
# here despite using OpenPGP certificates.
1718
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1719
# "+AES-256-CBC", "+SHA1",
1720
# "+COMP-NULL", "+CTYPE-OPENPGP",
1722
# Use a fallback default, since this MUST be set.
1723
priority = self.server.gnutls_priority
1724
if priority is None:
1726
gnutls.library.functions.gnutls_priority_set_direct(
1727
session._c_object, priority, None)
1729
# Start communication using the Mandos protocol
1730
# Get protocol number
1731
line = self.request.makefile().readline()
1732
logger.debug("Protocol version: %r", line)
1734
if int(line.strip().split()[0]) > 1:
1735
raise RuntimeError(line)
1736
except (ValueError, IndexError, RuntimeError) as error:
1737
logger.error("Unknown protocol version: %s", error)
1740
# Start GnuTLS connection
1743
except gnutls.errors.GNUTLSError as error:
1744
logger.warning("Handshake failed: %s", error)
1745
# Do not run session.bye() here: the session is not
1746
# established. Just abandon the request.
1748
logger.debug("Handshake succeeded")
1750
approval_required = False
1753
fpr = self.fingerprint(
1754
self.peer_certificate(session))
1756
gnutls.errors.GNUTLSError) as error:
1757
logger.warning("Bad certificate: %s", error)
1759
logger.debug("Fingerprint: %s", fpr)
1762
client = ProxyClient(child_pipe, fpr,
1763
self.client_address)
1767
if client.approval_delay:
1768
delay = client.approval_delay
1769
client.approvals_pending += 1
1770
approval_required = True
1773
if not client.enabled:
1774
logger.info("Client %s is disabled",
1776
if self.server.use_dbus:
1778
client.Rejected("Disabled")
1781
if client.approved or not client.approval_delay:
1782
#We are approved or approval is disabled
1784
elif client.approved is None:
1785
logger.info("Client %s needs approval",
1787
if self.server.use_dbus:
1789
client.NeedApproval(
1790
client.approval_delay.total_seconds()
1791
* 1000, client.approved_by_default)
1793
logger.warning("Client %s was not approved",
1795
if self.server.use_dbus:
1797
client.Rejected("Denied")
1800
#wait until timeout or approved
1801
time = datetime.datetime.now()
1802
client.changedstate.acquire()
1803
client.changedstate.wait(delay.total_seconds())
1804
client.changedstate.release()
1805
time2 = datetime.datetime.now()
1806
if (time2 - time) >= delay:
1807
if not client.approved_by_default:
1808
logger.warning("Client %s timed out while"
1809
" waiting for approval",
1811
if self.server.use_dbus:
1813
client.Rejected("Approval timed out")
1818
delay -= time2 - time
1821
while sent_size < len(client.secret):
1823
sent = session.send(client.secret[sent_size:])
1824
except gnutls.errors.GNUTLSError as error:
1825
logger.warning("gnutls send failed",
1828
logger.debug("Sent: %d, remaining: %d", sent,
1829
len(client.secret) - (sent_size
1833
logger.info("Sending secret to %s", client.name)
1834
# bump the timeout using extended_timeout
1835
client.bump_timeout(client.extended_timeout)
1836
if self.server.use_dbus:
1841
if approval_required:
1842
client.approvals_pending -= 1
1845
except gnutls.errors.GNUTLSError as error:
1846
logger.warning("GnuTLS bye failed",
1850
def peer_certificate(session):
1851
"Return the peer's OpenPGP certificate as a bytestring"
1852
# If not an OpenPGP certificate...
1853
if (gnutls.library.functions.gnutls_certificate_type_get(
1855
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1856
# ...do the normal thing
1857
return session.peer_certificate
1858
list_size = ctypes.c_uint(1)
1859
cert_list = (gnutls.library.functions
1860
.gnutls_certificate_get_peers
1861
(session._c_object, ctypes.byref(list_size)))
1862
if not bool(cert_list) and list_size.value != 0:
1863
raise gnutls.errors.GNUTLSError("error getting peer"
1865
if list_size.value == 0:
1868
return ctypes.string_at(cert.data, cert.size)
1871
def fingerprint(openpgp):
1872
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1873
# New GnuTLS "datum" with the OpenPGP public key
1874
datum = gnutls.library.types.gnutls_datum_t(
1875
ctypes.cast(ctypes.c_char_p(openpgp),
1876
ctypes.POINTER(ctypes.c_ubyte)),
1877
ctypes.c_uint(len(openpgp)))
1878
# New empty GnuTLS certificate
1879
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1880
gnutls.library.functions.gnutls_openpgp_crt_init(
1882
# Import the OpenPGP public key into the certificate
1883
gnutls.library.functions.gnutls_openpgp_crt_import(
1884
crt, ctypes.byref(datum),
1885
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
1886
# Verify the self signature in the key
1887
crtverify = ctypes.c_uint()
1888
gnutls.library.functions.gnutls_openpgp_crt_verify_self(
1889
crt, 0, ctypes.byref(crtverify))
1890
if crtverify.value != 0:
1891
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1892
raise gnutls.errors.CertificateSecurityError(
1894
# New buffer for the fingerprint
1895
buf = ctypes.create_string_buffer(20)
1896
buf_len = ctypes.c_size_t()
1897
# Get the fingerprint from the certificate into the buffer
1898
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(
1899
crt, ctypes.byref(buf), ctypes.byref(buf_len))
1900
# Deinit the certificate
1901
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1902
# Convert the buffer to a Python bytestring
1903
fpr = ctypes.string_at(buf, buf_len.value)
1904
# Convert the bytestring to hexadecimal notation
1905
hex_fpr = binascii.hexlify(fpr).upper()
1909
class MultiprocessingMixIn(object):
1910
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1912
def sub_process_main(self, request, address):
1914
self.finish_request(request, address)
1916
self.handle_error(request, address)
1917
self.close_request(request)
1919
def process_request(self, request, address):
1920
"""Start a new process to process the request."""
1921
proc = multiprocessing.Process(target = self.sub_process_main,
1922
args = (request, address))
1927
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1928
""" adds a pipe to the MixIn """
1930
def process_request(self, request, client_address):
1931
"""Overrides and wraps the original process_request().
1933
This function creates a new pipe in self.pipe
1935
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1937
proc = MultiprocessingMixIn.process_request(self, request,
1939
self.child_pipe.close()
1940
self.add_pipe(parent_pipe, proc)
1942
def add_pipe(self, parent_pipe, proc):
1943
"""Dummy function; override as necessary"""
1944
raise NotImplementedError()
1947
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1948
socketserver.TCPServer, object):
1949
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
421
logger.info(u"TCP connection from: %s",
422
unicode(self.client_address))
423
session = gnutls.connection.ClientSession\
424
(self.request, gnutls.connection.X509Credentials())
426
line = self.request.makefile().readline()
427
logger.debug(u"Protocol version: %r", line)
429
if int(line.strip().split()[0]) > 1:
431
except (ValueError, IndexError, RuntimeError), error:
432
logger.error(u"Unknown protocol version: %s", error)
435
# Note: gnutls.connection.X509Credentials is really a generic
436
# GnuTLS certificate credentials object so long as no X.509
437
# keys are added to it. Therefore, we can use it here despite
438
# using OpenPGP certificates.
440
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
441
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
443
priority = "NORMAL" # Fallback default, since this
445
if self.server.settings["priority"]:
446
priority = self.server.settings["priority"]
447
gnutls.library.functions.gnutls_priority_set_direct\
448
(session._c_object, priority, None);
452
except gnutls.errors.GNUTLSError, error:
453
logger.warning(u"Handshake failed: %s", error)
454
# Do not run session.bye() here: the session is not
455
# established. Just abandon the request.
458
fpr = fingerprint(peer_certificate(session))
459
except (TypeError, gnutls.errors.GNUTLSError), error:
460
logger.warning(u"Bad certificate: %s", error)
463
logger.debug(u"Fingerprint: %s", fpr)
465
for c in self.server.clients:
466
if c.fingerprint == fpr:
470
logger.warning(u"Client not found for fingerprint: %s",
474
# Have to check if client.still_valid(), since it is possible
475
# that the client timed out while establishing the GnuTLS
477
if not client.still_valid():
478
logger.warning(u"Client %(name)s is invalid",
483
while sent_size < len(client.secret):
484
sent = session.send(client.secret[sent_size:])
485
logger.debug(u"Sent: %d, remaining: %d",
486
sent, len(client.secret)
487
- (sent_size + sent))
492
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
493
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1952
enabled: Boolean; whether this server is activated yet
1953
interface: None or a network interface name (string)
1954
use_ipv6: Boolean; to use IPv6 or not
495
settings: Server settings
496
clients: Set() of Client objects
1957
def __init__(self, server_address, RequestHandlerClass,
1961
"""If socketfd is set, use that file descriptor instead of
1962
creating a new one with socket.socket().
1964
self.interface = interface
1966
self.address_family = socket.AF_INET6
1967
if socketfd is not None:
1968
# Save the file descriptor
1969
self.socketfd = socketfd
1970
# Save the original socket.socket() function
1971
self.socket_socket = socket.socket
1972
# To implement --socket, we monkey patch socket.socket.
1974
# (When socketserver.TCPServer is a new-style class, we
1975
# could make self.socket into a property instead of monkey
1976
# patching socket.socket.)
1978
# Create a one-time-only replacement for socket.socket()
1979
@functools.wraps(socket.socket)
1980
def socket_wrapper(*args, **kwargs):
1981
# Restore original function so subsequent calls are
1983
socket.socket = self.socket_socket
1984
del self.socket_socket
1985
# This time only, return a new socket object from the
1986
# saved file descriptor.
1987
return socket.fromfd(self.socketfd, *args, **kwargs)
1988
# Replace socket.socket() function with wrapper
1989
socket.socket = socket_wrapper
1990
# The socketserver.TCPServer.__init__ will call
1991
# socket.socket(), which might be our replacement,
1992
# socket_wrapper(), if socketfd was set.
1993
socketserver.TCPServer.__init__(self, server_address,
1994
RequestHandlerClass)
498
address_family = socket.AF_INET6
499
def __init__(self, *args, **kwargs):
500
if "settings" in kwargs:
501
self.settings = kwargs["settings"]
502
del kwargs["settings"]
503
if "clients" in kwargs:
504
self.clients = kwargs["clients"]
505
del kwargs["clients"]
506
return super(type(self), self).__init__(*args, **kwargs)
1996
507
def server_bind(self):
1997
508
"""This overrides the normal server_bind() function
1998
509
to bind to an interface if one was specified, and also NOT to
1999
510
bind to an address or port if they were not specified."""
2000
if self.interface is not None:
2001
if SO_BINDTODEVICE is None:
2002
logger.error("SO_BINDTODEVICE does not exist;"
2003
" cannot bind to interface %s",
2007
self.socket.setsockopt(
2008
socket.SOL_SOCKET, SO_BINDTODEVICE,
2009
(self.interface + "\0").encode("utf-8"))
2010
except socket.error as error:
2011
if error.errno == errno.EPERM:
2012
logger.error("No permission to bind to"
2013
" interface %s", self.interface)
2014
elif error.errno == errno.ENOPROTOOPT:
2015
logger.error("SO_BINDTODEVICE not available;"
2016
" cannot bind to interface %s",
2018
elif error.errno == errno.ENODEV:
2019
logger.error("Interface %s does not exist,"
2020
" cannot bind", self.interface)
511
if self.settings["interface"]:
512
# 25 is from /usr/include/asm-i486/socket.h
513
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
515
self.socket.setsockopt(socket.SOL_SOCKET,
517
self.settings["interface"])
518
except socket.error, error:
519
if error[0] == errno.EPERM:
520
logger.error(u"No permission to"
521
u" bind to interface %s",
522
self.settings["interface"])
2023
525
# Only bind(2) the socket if we really need to.
2024
526
if self.server_address[0] or self.server_address[1]:
2025
527
if not self.server_address[0]:
2026
if self.address_family == socket.AF_INET6:
2027
any_address = "::" # in6addr_any
2029
any_address = "0.0.0.0" # INADDR_ANY
2030
self.server_address = (any_address,
529
self.server_address = (in6addr_any,
2031
530
self.server_address[1])
2032
elif not self.server_address[1]:
2033
self.server_address = (self.server_address[0], 0)
2034
# if self.interface:
2035
# self.server_address = (self.server_address[0],
2040
return socketserver.TCPServer.server_bind(self)
2043
class MandosServer(IPv6_TCPServer):
2047
clients: set of Client objects
2048
gnutls_priority GnuTLS priority string
2049
use_dbus: Boolean; to emit D-Bus signals or not
2051
Assumes a gobject.MainLoop event loop.
2054
def __init__(self, server_address, RequestHandlerClass,
2058
gnutls_priority=None,
2061
self.enabled = False
2062
self.clients = clients
2063
if self.clients is None:
2065
self.use_dbus = use_dbus
2066
self.gnutls_priority = gnutls_priority
2067
IPv6_TCPServer.__init__(self, server_address,
2068
RequestHandlerClass,
2069
interface = interface,
2070
use_ipv6 = use_ipv6,
2071
socketfd = socketfd)
2073
def server_activate(self):
2075
return socketserver.TCPServer.server_activate(self)
2080
def add_pipe(self, parent_pipe, proc):
2081
# Call "handle_ipc" for both data and EOF events
2082
gobject.io_add_watch(
2083
parent_pipe.fileno(),
2084
gobject.IO_IN | gobject.IO_HUP,
2085
functools.partial(self.handle_ipc,
2086
parent_pipe = parent_pipe,
2089
def handle_ipc(self, source, condition,
2092
client_object=None):
2093
# error, or the other end of multiprocessing.Pipe has closed
2094
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2095
# Wait for other process to exit
2099
# Read a request from the child
2100
request = parent_pipe.recv()
2101
command = request[0]
2103
if command == 'init':
2105
address = request[2]
2107
for c in self.clients.itervalues():
2108
if c.fingerprint == fpr:
2112
logger.info("Client not found for fingerprint: %s, ad"
2113
"dress: %s", fpr, address)
2116
mandos_dbus_service.ClientNotFound(fpr,
2118
parent_pipe.send(False)
2121
gobject.io_add_watch(
2122
parent_pipe.fileno(),
2123
gobject.IO_IN | gobject.IO_HUP,
2124
functools.partial(self.handle_ipc,
2125
parent_pipe = parent_pipe,
2127
client_object = client))
2128
parent_pipe.send(True)
2129
# remove the old hook in favor of the new above hook on
2132
if command == 'funcall':
2133
funcname = request[1]
2137
parent_pipe.send(('data', getattr(client_object,
2141
if command == 'getattr':
2142
attrname = request[1]
2143
if callable(client_object.__getattribute__(attrname)):
2144
parent_pipe.send(('function', ))
2147
'data', client_object.__getattribute__(attrname)))
2149
if command == 'setattr':
2150
attrname = request[1]
2152
setattr(client_object, attrname, value)
2157
def rfc3339_duration_to_delta(duration):
2158
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2160
>>> rfc3339_duration_to_delta("P7D")
2161
datetime.timedelta(7)
2162
>>> rfc3339_duration_to_delta("PT60S")
2163
datetime.timedelta(0, 60)
2164
>>> rfc3339_duration_to_delta("PT60M")
2165
datetime.timedelta(0, 3600)
2166
>>> rfc3339_duration_to_delta("PT24H")
2167
datetime.timedelta(1)
2168
>>> rfc3339_duration_to_delta("P1W")
2169
datetime.timedelta(7)
2170
>>> rfc3339_duration_to_delta("PT5M30S")
2171
datetime.timedelta(0, 330)
2172
>>> rfc3339_duration_to_delta("P1DT3M20S")
2173
datetime.timedelta(1, 200)
2176
# Parsing an RFC 3339 duration with regular expressions is not
2177
# possible - there would have to be multiple places for the same
2178
# values, like seconds. The current code, while more esoteric, is
2179
# cleaner without depending on a parsing library. If Python had a
2180
# built-in library for parsing we would use it, but we'd like to
2181
# avoid excessive use of external libraries.
2183
# New type for defining tokens, syntax, and semantics all-in-one
2184
Token = collections.namedtuple("Token",
2185
("regexp", # To match token; if
2186
# "value" is not None,
2187
# must have a "group"
2189
"value", # datetime.timedelta or
2191
"followers")) # Tokens valid after
2193
Token = collections.namedtuple("Token", (
2194
"regexp", # To match token; if "value" is not None, must have
2195
# a "group" containing digits
2196
"value", # datetime.timedelta or None
2197
"followers")) # Tokens valid after this token
2198
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2199
# the "duration" ABNF definition in RFC 3339, Appendix A.
2200
token_end = Token(re.compile(r"$"), None, frozenset())
2201
token_second = Token(re.compile(r"(\d+)S"),
2202
datetime.timedelta(seconds=1),
2203
frozenset((token_end, )))
2204
token_minute = Token(re.compile(r"(\d+)M"),
2205
datetime.timedelta(minutes=1),
2206
frozenset((token_second, token_end)))
2207
token_hour = Token(re.compile(r"(\d+)H"),
2208
datetime.timedelta(hours=1),
2209
frozenset((token_minute, token_end)))
2210
token_time = Token(re.compile(r"T"),
2212
frozenset((token_hour, token_minute,
2214
token_day = Token(re.compile(r"(\d+)D"),
2215
datetime.timedelta(days=1),
2216
frozenset((token_time, token_end)))
2217
token_month = Token(re.compile(r"(\d+)M"),
2218
datetime.timedelta(weeks=4),
2219
frozenset((token_day, token_end)))
2220
token_year = Token(re.compile(r"(\d+)Y"),
2221
datetime.timedelta(weeks=52),
2222
frozenset((token_month, token_end)))
2223
token_week = Token(re.compile(r"(\d+)W"),
2224
datetime.timedelta(weeks=1),
2225
frozenset((token_end, )))
2226
token_duration = Token(re.compile(r"P"), None,
2227
frozenset((token_year, token_month,
2228
token_day, token_time,
2230
# Define starting values
2231
value = datetime.timedelta() # Value so far
2233
followers = frozenset((token_duration,)) # Following valid tokens
2234
s = duration # String left to parse
2235
# Loop until end token is found
2236
while found_token is not token_end:
2237
# Search for any currently valid tokens
2238
for token in followers:
2239
match = token.regexp.match(s)
2240
if match is not None:
2242
if token.value is not None:
2243
# Value found, parse digits
2244
factor = int(match.group(1), 10)
2245
# Add to value so far
2246
value += factor * token.value
2247
# Strip token from string
2248
s = token.regexp.sub("", s, 1)
2251
# Set valid next tokens
2252
followers = found_token.followers
2255
# No currently valid tokens were found
2256
raise ValueError("Invalid RFC 3339 duration")
531
elif self.server_address[1] is None:
532
self.server_address = (self.server_address[0],
534
return super(type(self), self).server_bind()
2261
537
def string_to_delta(interval):
2262
538
"""Parse a string and return a datetime.timedelta
2264
540
>>> string_to_delta('7d')
2265
541
datetime.timedelta(7)
2266
542
>>> string_to_delta('60s')
2392
677
"debug": "False",
2394
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2395
":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
679
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2396
680
"servicename": "Mandos",
2402
"statedir": "/var/lib/mandos",
2403
"foreground": "False",
2407
683
# Parse config file for server-global settings
2408
server_config = configparser.SafeConfigParser(server_defaults)
684
server_config = ConfigParser.SafeConfigParser(server_defaults)
2409
685
del server_defaults
2410
686
server_config.read(os.path.join(options.configdir, "mandos.conf"))
687
server_section = "server"
2411
688
# Convert the SafeConfigParser object to a dict
2412
server_settings = server_config.defaults()
2413
# Use the appropriate methods on the non-string config options
2414
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2415
server_settings[option] = server_config.getboolean("DEFAULT",
2417
if server_settings["port"]:
2418
server_settings["port"] = server_config.getint("DEFAULT",
2420
if server_settings["socket"]:
2421
server_settings["socket"] = server_config.getint("DEFAULT",
2423
# Later, stdin will, and stdout and stderr might, be dup'ed
2424
# over with an opened os.devnull. But we don't want this to
2425
# happen with a supplied network socket.
2426
if 0 <= server_settings["socket"] <= 2:
2427
server_settings["socket"] = os.dup(server_settings
689
server_settings = dict(server_config.items(server_section))
690
# Use getboolean on the boolean config option
691
server_settings["debug"] = server_config.getboolean\
692
(server_section, "debug")
2429
693
del server_config
2431
695
# Override the settings from the config file with command line
2432
696
# options, if set.
2433
697
for option in ("interface", "address", "port", "debug",
2434
"priority", "servicename", "configdir", "use_dbus",
2435
"use_ipv6", "debuglevel", "restore", "statedir",
2436
"socket", "foreground", "zeroconf"):
698
"priority", "servicename", "configdir"):
2437
699
value = getattr(options, option)
2438
700
if value is not None:
2439
701
server_settings[option] = value
2441
# Force all strings to be unicode
2442
for option in server_settings.keys():
2443
if isinstance(server_settings[option], bytes):
2444
server_settings[option] = (server_settings[option]
2446
# Force all boolean options to be boolean
2447
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2448
"foreground", "zeroconf"):
2449
server_settings[option] = bool(server_settings[option])
2450
# Debug implies foreground
2451
if server_settings["debug"]:
2452
server_settings["foreground"] = True
2453
703
# Now we have our good server settings in "server_settings"
2455
##################################################################
2457
if (not server_settings["zeroconf"]
2458
and not (server_settings["port"]
2459
or server_settings["socket"] != "")):
2460
parser.error("Needs port or socket to work without Zeroconf")
2463
debug = server_settings["debug"]
2464
debuglevel = server_settings["debuglevel"]
2465
use_dbus = server_settings["use_dbus"]
2466
use_ipv6 = server_settings["use_ipv6"]
2467
stored_state_path = os.path.join(server_settings["statedir"],
2469
foreground = server_settings["foreground"]
2470
zeroconf = server_settings["zeroconf"]
2473
initlogger(debug, logging.DEBUG)
2478
level = getattr(logging, debuglevel.upper())
2479
initlogger(debug, level)
2481
if server_settings["servicename"] != "Mandos":
2482
syslogger.setFormatter(
2483
logging.Formatter('Mandos ({}) [%(process)d]:'
2484
' %(levelname)s: %(message)s'.format(
2485
server_settings["servicename"])))
2487
705
# Parse config file with clients
2488
client_config = configparser.SafeConfigParser(Client
706
client_defaults = { "timeout": "1h",
708
"checker": "fping -q -- %%(fqdn)s",
710
client_config = ConfigParser.SafeConfigParser(client_defaults)
2490
711
client_config.read(os.path.join(server_settings["configdir"],
2491
712
"clients.conf"))
2493
global mandos_dbus_service
2494
mandos_dbus_service = None
2497
if server_settings["socket"] != "":
2498
socketfd = server_settings["socket"]
2499
tcp_server = MandosServer(
2500
(server_settings["address"], server_settings["port"]),
2502
interface=(server_settings["interface"] or None),
2504
gnutls_priority=server_settings["priority"],
2508
pidfilename = "/run/mandos.pid"
2509
if not os.path.isdir("/run/."):
2510
pidfilename = "/var/run/mandos.pid"
2513
pidfile = open(pidfilename, "w")
2514
except IOError as e:
2515
logger.error("Could not open file %r", pidfilename,
2518
for name in ("_mandos", "mandos", "nobody"):
2520
uid = pwd.getpwnam(name).pw_uid
2521
gid = pwd.getpwnam(name).pw_gid
2531
except OSError as error:
2532
if error.errno != errno.EPERM:
2536
# Enable all possible GnuTLS debugging
2538
# "Use a log level over 10 to enable all debugging options."
2540
gnutls.library.functions.gnutls_global_set_log_level(11)
2542
@gnutls.library.types.gnutls_log_func
2543
def debug_gnutls(level, string):
2544
logger.debug("GnuTLS: %s", string[:-1])
2546
gnutls.library.functions.gnutls_global_set_log_function(
2549
# Redirect stdin so all checkers get /dev/null
2550
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2551
os.dup2(null, sys.stdin.fileno())
2555
# Need to fork before connecting to D-Bus
2557
# Close all input and output, do double fork, etc.
2560
# multiprocessing will use threads, so before we use gobject we
2561
# need to inform gobject that threads will be used.
2562
gobject.threads_init()
715
service = AvahiService(name = server_settings["servicename"],
716
type = "_mandos._tcp", );
717
if server_settings["interface"]:
718
service.interface = if_nametoindex(server_settings["interface"])
2564
720
global main_loop
2565
723
# From the Avahi example code
2566
DBusGMainLoop(set_as_default=True)
724
DBusGMainLoop(set_as_default=True )
2567
725
main_loop = gobject.MainLoop()
2568
726
bus = dbus.SystemBus()
727
server = dbus.Interface(
728
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
729
avahi.DBUS_INTERFACE_SERVER )
2569
730
# End of Avahi example code
2572
bus_name = dbus.service.BusName("se.recompile.Mandos",
2575
old_bus_name = dbus.service.BusName(
2576
"se.bsnet.fukt.Mandos", bus,
2578
except dbus.exceptions.NameExistsException as e:
2579
logger.error("Disabling D-Bus:", exc_info=e)
2581
server_settings["use_dbus"] = False
2582
tcp_server.use_dbus = False
2584
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2585
service = AvahiServiceToSyslog(
2586
name = server_settings["servicename"],
2587
servicetype = "_mandos._tcp",
2588
protocol = protocol,
2590
if server_settings["interface"]:
2591
service.interface = if_nametoindex(
2592
server_settings["interface"].encode("utf-8"))
2594
global multiprocessing_manager
2595
multiprocessing_manager = multiprocessing.Manager()
2597
client_class = Client
2599
client_class = functools.partial(ClientDBus, bus = bus)
2601
client_settings = Client.config_parser(client_config)
2602
old_client_settings = {}
2605
# This is used to redirect stdout and stderr for checker processes
2607
wnull = open(os.devnull, "w") # A writable /dev/null
2608
# Only used if server is running in foreground but not in debug
2610
if debug or not foreground:
2613
# Get client data and settings from last running state.
2614
if server_settings["restore"]:
2616
with open(stored_state_path, "rb") as stored_state:
2617
clients_data, old_client_settings = pickle.load(
2619
os.remove(stored_state_path)
2620
except IOError as e:
2621
if e.errno == errno.ENOENT:
2622
logger.warning("Could not load persistent state:"
2623
" {}".format(os.strerror(e.errno)))
2625
logger.critical("Could not load persistent state:",
2628
except EOFError as e:
2629
logger.warning("Could not load persistent state: "
2633
with PGPEngine() as pgp:
2634
for client_name, client in clients_data.items():
2635
# Skip removed clients
2636
if client_name not in client_settings:
2639
# Decide which value to use after restoring saved state.
2640
# We have three different values: Old config file,
2641
# new config file, and saved state.
2642
# New config value takes precedence if it differs from old
2643
# config value, otherwise use saved state.
2644
for name, value in client_settings[client_name].items():
2646
# For each value in new config, check if it
2647
# differs from the old config value (Except for
2648
# the "secret" attribute)
2649
if (name != "secret"
2651
old_client_settings[client_name][name])):
2652
client[name] = value
2656
# Clients who has passed its expire date can still be
2657
# enabled if its last checker was successful. Clients
2658
# whose checker succeeded before we stored its state is
2659
# assumed to have successfully run all checkers during
2661
if client["enabled"]:
2662
if datetime.datetime.utcnow() >= client["expires"]:
2663
if not client["last_checked_ok"]:
2665
"disabling client {} - Client never "
2666
"performed a successful checker".format(
2668
client["enabled"] = False
2669
elif client["last_checker_status"] != 0:
2671
"disabling client {} - Client last"
2672
" checker failed with error code"
2675
client["last_checker_status"]))
2676
client["enabled"] = False
2678
client["expires"] = (
2679
datetime.datetime.utcnow()
2680
+ client["timeout"])
2681
logger.debug("Last checker succeeded,"
2682
" keeping {} enabled".format(
2685
client["secret"] = pgp.decrypt(
2686
client["encrypted_secret"],
2687
client_settings[client_name]["secret"])
2689
# If decryption fails, we use secret from new settings
2690
logger.debug("Failed to decrypt {} old secret".format(
2692
client["secret"] = (client_settings[client_name]
2695
# Add/remove clients based on new changes made to config
2696
for client_name in (set(old_client_settings)
2697
- set(client_settings)):
2698
del clients_data[client_name]
2699
for client_name in (set(client_settings)
2700
- set(old_client_settings)):
2701
clients_data[client_name] = client_settings[client_name]
2703
# Create all client objects
2704
for client_name, client in clients_data.items():
2705
tcp_server.clients[client_name] = client_class(
2708
server_settings = server_settings)
2710
if not tcp_server.clients:
2711
logger.warning("No clients defined")
2714
if pidfile is not None:
2718
pidfile.write("{}\n".format(pid).encode("utf-8"))
2720
logger.error("Could not write to file %r with PID %d",
2725
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2726
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2730
@alternate_dbus_interfaces(
2731
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
2732
class MandosDBusService(DBusObjectWithProperties):
2733
"""A D-Bus proxy object"""
2736
dbus.service.Object.__init__(self, bus, "/")
2738
_interface = "se.recompile.Mandos"
2740
@dbus_interface_annotations(_interface)
2743
"org.freedesktop.DBus.Property.EmitsChangedSignal":
2746
@dbus.service.signal(_interface, signature="o")
2747
def ClientAdded(self, objpath):
2751
@dbus.service.signal(_interface, signature="ss")
2752
def ClientNotFound(self, fingerprint, address):
2756
@dbus.service.signal(_interface, signature="os")
2757
def ClientRemoved(self, objpath, name):
2761
@dbus.service.method(_interface, out_signature="ao")
2762
def GetAllClients(self):
2764
return dbus.Array(c.dbus_object_path for c in
2765
tcp_server.clients.itervalues())
2767
@dbus.service.method(_interface,
2768
out_signature="a{oa{sv}}")
2769
def GetAllClientsWithProperties(self):
2771
return dbus.Dictionary(
2772
{ c.dbus_object_path: c.GetAll("")
2773
for c in tcp_server.clients.itervalues() },
2776
@dbus.service.method(_interface, in_signature="o")
2777
def RemoveClient(self, object_path):
2779
for c in tcp_server.clients.itervalues():
2780
if c.dbus_object_path == object_path:
2781
del tcp_server.clients[c.name]
2782
c.remove_from_connection()
2783
# Don't signal anything except ClientRemoved
2784
c.disable(quiet=True)
2786
self.ClientRemoved(object_path, c.name)
2788
raise KeyError(object_path)
2792
mandos_dbus_service = MandosDBusService()
732
debug = server_settings["debug"]
735
console = logging.StreamHandler()
736
# console.setLevel(logging.DEBUG)
737
console.setFormatter(logging.Formatter\
738
('%(levelname)s: %(message)s'))
739
logger.addHandler(console)
743
def remove_from_clients(client):
744
clients.remove(client)
746
logger.critical(u"No clients left, exiting")
749
clients.update(Set(Client(name = section,
750
stop_hook = remove_from_clients,
752
= dict(client_config.items(section)))
753
for section in client_config.sections()))
2795
759
"Cleanup function; run on exit"
2799
multiprocessing.active_children()
2801
if not (tcp_server.clients or client_settings):
2804
# Store client before exiting. Secrets are encrypted with key
2805
# based on what config file has. If config file is
2806
# removed/edited, old secret will thus be unrecovable.
2808
with PGPEngine() as pgp:
2809
for client in tcp_server.clients.itervalues():
2810
key = client_settings[client.name]["secret"]
2811
client.encrypted_secret = pgp.encrypt(client.secret,
2815
# A list of attributes that can not be pickled
2817
exclude = { "bus", "changedstate", "secret",
2818
"checker", "server_settings" }
2819
for name, typ in inspect.getmembers(dbus.service
2823
client_dict["encrypted_secret"] = (client
2825
for attr in client.client_structure:
2826
if attr not in exclude:
2827
client_dict[attr] = getattr(client, attr)
2829
clients[client.name] = client_dict
2830
del client_settings[client.name]["secret"]
2833
with tempfile.NamedTemporaryFile(
2837
dir=os.path.dirname(stored_state_path),
2838
delete=False) as stored_state:
2839
pickle.dump((clients, client_settings), stored_state)
2840
tempname = stored_state.name
2841
os.rename(tempname, stored_state_path)
2842
except (IOError, OSError) as e:
2848
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2849
logger.warning("Could not save persistent state: {}"
2850
.format(os.strerror(e.errno)))
2852
logger.warning("Could not save persistent state:",
2856
# Delete all clients, and settings from config
2857
while tcp_server.clients:
2858
name, client = tcp_server.clients.popitem()
2860
client.remove_from_connection()
2861
# Don't signal anything except ClientRemoved
2862
client.disable(quiet=True)
2865
mandos_dbus_service.ClientRemoved(
2866
client.dbus_object_path, client.name)
2867
client_settings.clear()
761
# From the Avahi example code
762
if not group is None:
765
# End of Avahi example code
768
client = clients.pop()
769
client.stop_hook = None
2869
772
atexit.register(cleanup)
2871
for client in tcp_server.clients.itervalues():
2874
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2875
# Need to initiate checking of clients
2877
client.init_checker()
2880
tcp_server.server_activate()
775
signal.signal(signal.SIGINT, signal.SIG_IGN)
776
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
777
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
779
for client in clients:
782
tcp_server = IPv6_TCPServer((server_settings["address"],
783
server_settings["port"]),
785
settings=server_settings,
2882
787
# Find out what port we got
2884
service.port = tcp_server.socket.getsockname()[1]
2886
logger.info("Now listening on address %r, port %d,"
2887
" flowinfo %d, scope_id %d",
2888
*tcp_server.socket.getsockname())
2890
logger.info("Now listening on address %r, port %d",
2891
*tcp_server.socket.getsockname())
788
service.port = tcp_server.socket.getsockname()[1]
789
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
790
u" scope_id %d" % tcp_server.socket.getsockname())
2893
792
#service.interface = tcp_server.socket.getsockname()[3]
2897
# From the Avahi example code
2900
except dbus.exceptions.DBusException as error:
2901
logger.critical("D-Bus Exception", exc_info=error)
2904
# End of Avahi example code
795
# From the Avahi example code
796
server.connect_to_signal("StateChanged", server_state_changed)
798
server_state_changed(server.GetState())
799
except dbus.exceptions.DBusException, error:
800
logger.critical(u"DBusException: %s", error)
802
# End of Avahi example code
2906
804
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2907
805
lambda *args, **kwargs:
2908
(tcp_server.handle_request
2909
(*args[2:], **kwargs) or True))
806
tcp_server.handle_request\
807
(*args[2:], **kwargs) or True)
2911
809
logger.debug("Starting main loop")
810
main_loop_started = True
2913
except AvahiError as error:
2914
logger.critical("Avahi Error", exc_info=error)
812
except AvahiError, error:
813
logger.critical(u"AvahiError: %s" + unicode(error))
2917
815
except KeyboardInterrupt:
2919
print("", file=sys.stderr)
2920
logger.debug("Server received KeyboardInterrupt")
2921
logger.debug("Server exiting")
2922
# Must run before the D-Bus bus name gets deregistered
2926
819
if __name__ == '__main__':