126
270
self.rename_count = 0
127
271
self.max_renames = max_renames
128
272
self.protocol = protocol
273
self.group = None # our entry group
276
self.entry_group_state_changed_match = None
129
278
def rename(self):
130
279
"""Derived from the Avahi example code"""
131
280
if self.rename_count >= self.max_renames:
132
logger.critical(u"No suitable Zeroconf service name found"
133
u" after %i retries, exiting.",
281
logger.critical("No suitable Zeroconf service name found"
282
" after %i retries, exiting.",
134
283
self.rename_count)
135
raise AvahiServiceError(u"Too many renames")
136
self.name = server.GetAlternativeServiceName(self.name)
137
logger.info(u"Changing Zeroconf service name to %r ...",
139
syslogger.setFormatter(logging.Formatter
140
('Mandos (%s): %%(levelname)s:'
141
' %%(message)s' % self.name))
284
raise AvahiServiceError("Too many renames")
285
self.name = unicode(self.server
286
.GetAlternativeServiceName(self.name))
287
logger.info("Changing Zeroconf service name to %r ...",
292
except dbus.exceptions.DBusException as error:
293
logger.critical("D-Bus Exception", exc_info=error)
144
296
self.rename_count += 1
145
298
def remove(self):
146
299
"""Derived from the Avahi example code"""
147
if group is not None:
300
if self.entry_group_state_changed_match is not None:
301
self.entry_group_state_changed_match.remove()
302
self.entry_group_state_changed_match = None
303
if self.group is not None:
150
307
"""Derived from the Avahi example code"""
153
group = dbus.Interface(bus.get_object
155
server.EntryGroupNew()),
156
avahi.DBUS_INTERFACE_ENTRY_GROUP)
157
group.connect_to_signal('StateChanged',
158
entry_group_state_changed)
159
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
160
service.name, service.type)
162
self.interface, # interface
163
self.protocol, # protocol
164
dbus.UInt32(0), # flags
165
self.name, self.type,
166
self.domain, self.host,
167
dbus.UInt16(self.port),
168
avahi.string_array_to_txt_array(self.TXT))
171
# From the Avahi example code:
172
group = None # our entry group
173
# End of Avahi example code
176
def _datetime_to_dbus(dt, variant_level=0):
177
"""Convert a UTC datetime.datetime() to a D-Bus type."""
178
return dbus.String(dt.isoformat(), variant_level=variant_level)
181
class Client(dbus.service.Object):
309
if self.group is None:
310
self.group = dbus.Interface(
311
self.bus.get_object(avahi.DBUS_NAME,
312
self.server.EntryGroupNew()),
313
avahi.DBUS_INTERFACE_ENTRY_GROUP)
314
self.entry_group_state_changed_match = (
315
self.group.connect_to_signal(
316
'StateChanged', self.entry_group_state_changed))
317
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
318
self.name, self.type)
319
self.group.AddService(
322
dbus.UInt32(0), # flags
323
self.name, self.type,
324
self.domain, self.host,
325
dbus.UInt16(self.port),
326
avahi.string_array_to_txt_array(self.TXT))
329
def entry_group_state_changed(self, state, error):
330
"""Derived from the Avahi example code"""
331
logger.debug("Avahi entry group state change: %i", state)
333
if state == avahi.ENTRY_GROUP_ESTABLISHED:
334
logger.debug("Zeroconf service established.")
335
elif state == avahi.ENTRY_GROUP_COLLISION:
336
logger.info("Zeroconf service name collision.")
338
elif state == avahi.ENTRY_GROUP_FAILURE:
339
logger.critical("Avahi: Error in group state changed %s",
341
raise AvahiGroupError("State changed: {0!s}"
345
"""Derived from the Avahi example code"""
346
if self.group is not None:
349
except (dbus.exceptions.UnknownMethodException,
350
dbus.exceptions.DBusException):
355
def server_state_changed(self, state, error=None):
356
"""Derived from the Avahi example code"""
357
logger.debug("Avahi server state change: %i", state)
358
bad_states = { avahi.SERVER_INVALID:
359
"Zeroconf server invalid",
360
avahi.SERVER_REGISTERING: None,
361
avahi.SERVER_COLLISION:
362
"Zeroconf server name collision",
363
avahi.SERVER_FAILURE:
364
"Zeroconf server failure" }
365
if state in bad_states:
366
if bad_states[state] is not None:
368
logger.error(bad_states[state])
370
logger.error(bad_states[state] + ": %r", error)
372
elif state == avahi.SERVER_RUNNING:
376
logger.debug("Unknown state: %r", state)
378
logger.debug("Unknown state: %r: %r", state, error)
381
"""Derived from the Avahi example code"""
382
if self.server is None:
383
self.server = dbus.Interface(
384
self.bus.get_object(avahi.DBUS_NAME,
385
avahi.DBUS_PATH_SERVER,
386
follow_name_owner_changes=True),
387
avahi.DBUS_INTERFACE_SERVER)
388
self.server.connect_to_signal("StateChanged",
389
self.server_state_changed)
390
self.server_state_changed(self.server.GetState())
393
class AvahiServiceToSyslog(AvahiService):
395
"""Add the new name to the syslog messages"""
396
ret = AvahiService.rename(self)
397
syslogger.setFormatter(logging.Formatter
398
('Mandos ({0}) [%(process)d]:'
399
' %(levelname)s: %(message)s'
404
def timedelta_to_milliseconds(td):
405
"Convert a datetime.timedelta() to milliseconds"
406
return ((td.days * 24 * 60 * 60 * 1000)
407
+ (td.seconds * 1000)
408
+ (td.microseconds // 1000))
411
class Client(object):
182
412
"""A representation of a client host served by this server.
184
name: string; from the config file, used in log messages and
186
fingerprint: string (40 or 32 hexadecimal digits); used to
187
uniquely identify the client
188
secret: bytestring; sent verbatim (over TLS) to client
189
host: string; available for use by the checker command
190
created: datetime.datetime(); (UTC) object creation
191
last_enabled: datetime.datetime(); (UTC)
193
last_checked_ok: datetime.datetime(); (UTC) or None
194
timeout: datetime.timedelta(); How long from last_checked_ok
195
until this client is invalid
196
interval: datetime.timedelta(); How often to start a new checker
197
disable_hook: If set, called by disable() as disable_hook(self)
415
approved: bool(); 'None' if not yet approved/disapproved
416
approval_delay: datetime.timedelta(); Time to wait for approval
417
approval_duration: datetime.timedelta(); Duration of one approval
198
418
checker: subprocess.Popen(); a running checker process used
199
419
to see if the client lives.
200
420
'None' if no process is running.
201
checker_initiator_tag: a gobject event source tag, or None
202
disable_initiator_tag: - '' -
203
checker_callback_tag: - '' -
204
checker_command: string; External command which is run to check if
205
client lives. %() expansions are done at
421
checker_callback_tag: a gobject event source tag, or None
422
checker_command: string; External command which is run to check
423
if client lives. %() expansions are done at
206
424
runtime with vars(self) as dict, so that for
207
425
instance %(name)s can be used in the command.
426
checker_initiator_tag: a gobject event source tag, or None
427
created: datetime.datetime(); (UTC) object creation
428
client_structure: Object describing what attributes a client has
429
and is used for storing the client at exit
208
430
current_checker_command: string; current running checker_command
209
use_dbus: bool(); Whether to provide D-Bus interface and signals
210
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
431
disable_initiator_tag: a gobject event source tag, or None
433
fingerprint: string (40 or 32 hexadecimal digits); used to
434
uniquely identify the client
435
host: string; available for use by the checker command
436
interval: datetime.timedelta(); How often to start a new checker
437
last_approval_request: datetime.datetime(); (UTC) or None
438
last_checked_ok: datetime.datetime(); (UTC) or None
439
last_checker_status: integer between 0 and 255 reflecting exit
440
status of last checker. -1 reflects crashed
441
checker, -2 means no checker completed yet.
442
last_enabled: datetime.datetime(); (UTC) or None
443
name: string; from the config file, used in log messages and
445
secret: bytestring; sent verbatim (over TLS) to client
446
timeout: datetime.timedelta(); How long from last_checked_ok
447
until this client is disabled
448
extended_timeout: extra long timeout when secret has been sent
449
runtime_expansions: Allowed attributes for runtime expansion.
450
expires: datetime.datetime(); time (UTC) when a client will be
452
server_settings: The server_settings dict from main()
455
runtime_expansions = ("approval_delay", "approval_duration",
456
"created", "enabled", "expires",
457
"fingerprint", "host", "interval",
458
"last_approval_request", "last_checked_ok",
459
"last_enabled", "name", "timeout")
460
client_defaults = { "timeout": "PT5M",
461
"extended_timeout": "PT15M",
463
"checker": "fping -q -- %%(host)s",
465
"approval_delay": "PT0S",
466
"approval_duration": "PT1S",
467
"approved_by_default": "True",
212
471
def timeout_milliseconds(self):
213
472
"Return the 'timeout' attribute in milliseconds"
214
return ((self.timeout.days * 24 * 60 * 60 * 1000)
215
+ (self.timeout.seconds * 1000)
216
+ (self.timeout.microseconds // 1000))
473
return timedelta_to_milliseconds(self.timeout)
475
def extended_timeout_milliseconds(self):
476
"Return the 'extended_timeout' attribute in milliseconds"
477
return timedelta_to_milliseconds(self.extended_timeout)
218
479
def interval_milliseconds(self):
219
480
"Return the 'interval' attribute in milliseconds"
220
return ((self.interval.days * 24 * 60 * 60 * 1000)
221
+ (self.interval.seconds * 1000)
222
+ (self.interval.microseconds // 1000))
224
def __init__(self, name = None, disable_hook=None, config=None,
226
"""Note: the 'checker' key in 'config' sets the
227
'checker_command' attribute and *not* the 'checker'
481
return timedelta_to_milliseconds(self.interval)
483
def approval_delay_milliseconds(self):
484
return timedelta_to_milliseconds(self.approval_delay)
487
def config_parser(config):
488
"""Construct a new dict of client settings of this form:
489
{ client_name: {setting_name: value, ...}, ...}
490
with exceptions for any special settings as defined above.
491
NOTE: Must be a pure function. Must return the same result
492
value given the same arguments.
495
for client_name in config.sections():
496
section = dict(config.items(client_name))
497
client = settings[client_name] = {}
499
client["host"] = section["host"]
500
# Reformat values from string types to Python types
501
client["approved_by_default"] = config.getboolean(
502
client_name, "approved_by_default")
503
client["enabled"] = config.getboolean(client_name,
506
client["fingerprint"] = (section["fingerprint"].upper()
508
if "secret" in section:
509
client["secret"] = section["secret"].decode("base64")
510
elif "secfile" in section:
511
with open(os.path.expanduser(os.path.expandvars
512
(section["secfile"])),
514
client["secret"] = secfile.read()
516
raise TypeError("No secret or secfile for section {0}"
518
client["timeout"] = string_to_delta(section["timeout"])
519
client["extended_timeout"] = string_to_delta(
520
section["extended_timeout"])
521
client["interval"] = string_to_delta(section["interval"])
522
client["approval_delay"] = string_to_delta(
523
section["approval_delay"])
524
client["approval_duration"] = string_to_delta(
525
section["approval_duration"])
526
client["checker_command"] = section["checker"]
527
client["last_approval_request"] = None
528
client["last_checked_ok"] = None
529
client["last_checker_status"] = -2
533
def __init__(self, settings, name = None, server_settings=None):
232
logger.debug(u"Creating client %r", self.name)
233
self.use_dbus = False # During __init__
535
if server_settings is None:
537
self.server_settings = server_settings
538
# adding all client settings
539
for setting, value in settings.iteritems():
540
setattr(self, setting, value)
543
if not hasattr(self, "last_enabled"):
544
self.last_enabled = datetime.datetime.utcnow()
545
if not hasattr(self, "expires"):
546
self.expires = (datetime.datetime.utcnow()
549
self.last_enabled = None
552
logger.debug("Creating client %r", self.name)
234
553
# Uppercase and remove spaces from fingerprint for later
235
554
# comparison purposes with return value from the fingerprint()
237
self.fingerprint = (config["fingerprint"].upper()
239
logger.debug(u" Fingerprint: %s", self.fingerprint)
240
if "secret" in config:
241
self.secret = config["secret"].decode(u"base64")
242
elif "secfile" in config:
243
with closing(open(os.path.expanduser
245
(config["secfile"])))) as secfile:
246
self.secret = secfile.read()
248
raise TypeError(u"No secret or secfile for client %s"
250
self.host = config.get("host", "")
251
self.created = datetime.datetime.utcnow()
253
self.last_enabled = None
254
self.last_checked_ok = None
255
self.timeout = string_to_delta(config["timeout"])
256
self.interval = string_to_delta(config["interval"])
257
self.disable_hook = disable_hook
556
logger.debug(" Fingerprint: %s", self.fingerprint)
557
self.created = settings.get("created",
558
datetime.datetime.utcnow())
560
# attributes specific for this server instance
258
561
self.checker = None
259
562
self.checker_initiator_tag = None
260
563
self.disable_initiator_tag = None
261
564
self.checker_callback_tag = None
262
self.checker_command = config["checker"]
263
565
self.current_checker_command = None
264
self.last_connect = None
265
# Only now, when this client is initialized, can it show up on
267
self.use_dbus = use_dbus
269
self.dbus_object_path = (dbus.ObjectPath
271
+ self.name.replace(".", "_")))
272
dbus.service.Object.__init__(self, bus,
273
self.dbus_object_path)
567
self.approvals_pending = 0
568
self.changedstate = (multiprocessing_manager
569
.Condition(multiprocessing_manager
571
self.client_structure = [attr for attr in
572
self.__dict__.iterkeys()
573
if not attr.startswith("_")]
574
self.client_structure.append("client_structure")
576
for name, t in inspect.getmembers(type(self),
580
if not name.startswith("_"):
581
self.client_structure.append(name)
583
# Send notice to process children that client state has changed
584
def send_changedstate(self):
585
with self.changedstate:
586
self.changedstate.notify_all()
275
588
def enable(self):
276
589
"""Start this client's checker and timeout hooks"""
590
if getattr(self, "enabled", False):
593
self.expires = datetime.datetime.utcnow() + self.timeout
277
595
self.last_enabled = datetime.datetime.utcnow()
597
self.send_changedstate()
599
def disable(self, quiet=True):
600
"""Disable this client."""
601
if not getattr(self, "enabled", False):
604
logger.info("Disabling client %s", self.name)
605
if getattr(self, "disable_initiator_tag", None) is not None:
606
gobject.source_remove(self.disable_initiator_tag)
607
self.disable_initiator_tag = None
609
if getattr(self, "checker_initiator_tag", None) is not None:
610
gobject.source_remove(self.checker_initiator_tag)
611
self.checker_initiator_tag = None
615
self.send_changedstate()
616
# Do not run this again if called by a gobject.timeout_add
622
def init_checker(self):
278
623
# Schedule a new checker to be started an 'interval' from now,
279
624
# and every interval from then on.
625
if self.checker_initiator_tag is not None:
626
gobject.source_remove(self.checker_initiator_tag)
280
627
self.checker_initiator_tag = (gobject.timeout_add
281
628
(self.interval_milliseconds(),
282
629
self.start_checker))
283
# Also start a new checker *right now*.
285
630
# Schedule a disable() when 'timeout' has passed
631
if self.disable_initiator_tag is not None:
632
gobject.source_remove(self.disable_initiator_tag)
286
633
self.disable_initiator_tag = (gobject.timeout_add
287
634
(self.timeout_milliseconds(),
292
self.PropertyChanged(dbus.String(u"enabled"),
293
dbus.Boolean(True, variant_level=1))
294
self.PropertyChanged(dbus.String(u"last_enabled"),
295
(_datetime_to_dbus(self.last_enabled,
299
"""Disable this client."""
300
if not getattr(self, "enabled", False):
302
logger.info(u"Disabling client %s", self.name)
303
if getattr(self, "disable_initiator_tag", False):
304
gobject.source_remove(self.disable_initiator_tag)
305
self.disable_initiator_tag = None
306
if getattr(self, "checker_initiator_tag", False):
307
gobject.source_remove(self.checker_initiator_tag)
308
self.checker_initiator_tag = None
310
if self.disable_hook:
311
self.disable_hook(self)
315
self.PropertyChanged(dbus.String(u"enabled"),
316
dbus.Boolean(False, variant_level=1))
317
# Do not run this again if called by a gobject.timeout_add
321
self.disable_hook = None
636
# Also start a new checker *right now*.
324
639
def checker_callback(self, pid, condition, command):
325
640
"""The checker has completed, so take appropriate actions."""
326
641
self.checker_callback_tag = None
327
642
self.checker = None
330
self.PropertyChanged(dbus.String(u"checker_running"),
331
dbus.Boolean(False, variant_level=1))
332
643
if os.WIFEXITED(condition):
333
exitstatus = os.WEXITSTATUS(condition)
335
logger.info(u"Checker for %(name)s succeeded",
644
self.last_checker_status = os.WEXITSTATUS(condition)
645
if self.last_checker_status == 0:
646
logger.info("Checker for %(name)s succeeded",
337
648
self.checked_ok()
339
logger.info(u"Checker for %(name)s failed",
650
logger.info("Checker for %(name)s failed",
343
self.CheckerCompleted(dbus.Int16(exitstatus),
344
dbus.Int64(condition),
345
dbus.String(command))
347
logger.warning(u"Checker for %(name)s crashed?",
653
self.last_checker_status = -1
654
logger.warning("Checker for %(name)s crashed?",
351
self.CheckerCompleted(dbus.Int16(-1),
352
dbus.Int64(condition),
353
dbus.String(command))
355
657
def checked_ok(self):
356
"""Bump up the timeout for this client.
357
This should only be called when the client has been seen,
658
"""Assert that the client has been seen, alive and well."""
360
659
self.last_checked_ok = datetime.datetime.utcnow()
361
gobject.source_remove(self.disable_initiator_tag)
362
self.disable_initiator_tag = (gobject.timeout_add
363
(self.timeout_milliseconds(),
367
self.PropertyChanged(
368
dbus.String(u"last_checked_ok"),
369
(_datetime_to_dbus(self.last_checked_ok,
660
self.last_checker_status = 0
663
def bump_timeout(self, timeout=None):
664
"""Bump up the timeout for this client."""
666
timeout = self.timeout
667
if self.disable_initiator_tag is not None:
668
gobject.source_remove(self.disable_initiator_tag)
669
self.disable_initiator_tag = None
670
if getattr(self, "enabled", False):
671
self.disable_initiator_tag = (gobject.timeout_add
672
(timedelta_to_milliseconds
673
(timeout), self.disable))
674
self.expires = datetime.datetime.utcnow() + timeout
676
def need_approval(self):
677
self.last_approval_request = datetime.datetime.utcnow()
372
679
def start_checker(self):
373
680
"""Start a new checker subprocess if one is not running.
374
682
If a checker already exists, leave it running and do
376
684
# The reason for not killing a running checker is that if we
377
# did that, then if a checker (for some reason) started
378
# running slowly and taking more than 'interval' time, the
379
# client would inevitably timeout, since no checker would get
380
# a chance to run to completion. If we instead leave running
685
# did that, and if a checker (for some reason) started running
686
# slowly and taking more than 'interval' time, then the client
687
# would inevitably timeout, since no checker would get a
688
# chance to run to completion. If we instead leave running
381
689
# checkers alone, the checker would have to take more time
382
# than 'timeout' for the client to be declared invalid, which
383
# is as it should be.
690
# than 'timeout' for the client to be disabled, which is as it
385
693
# If a checker exists, make sure it is not a zombie
386
if self.checker is not None:
387
695
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
696
except AttributeError:
698
except OSError as error:
699
if error.errno != errno.ECHILD:
389
703
logger.warning("Checker was a zombie")
390
704
gobject.source_remove(self.checker_callback_tag)
446
769
self.checker_callback_tag = None
447
770
if getattr(self, "checker", None) is None:
449
logger.debug(u"Stopping checker for %(name)s", vars(self))
772
logger.debug("Stopping checker for %(name)s", vars(self))
451
os.kill(self.checker.pid, signal.SIGTERM)
774
self.checker.terminate()
453
776
#if self.checker.poll() is None:
454
# os.kill(self.checker.pid, signal.SIGKILL)
455
except OSError, error:
777
# self.checker.kill()
778
except OSError as error:
456
779
if error.errno != errno.ESRCH: # No such process
458
781
self.checker = None
460
self.PropertyChanged(dbus.String(u"checker_running"),
461
dbus.Boolean(False, variant_level=1))
463
def still_valid(self):
464
"""Has the timeout not yet passed for this client?"""
465
if not getattr(self, "enabled", False):
467
now = datetime.datetime.utcnow()
468
if self.last_checked_ok is None:
469
return now < (self.created + self.timeout)
784
def dbus_service_property(dbus_interface, signature="v",
785
access="readwrite", byte_arrays=False):
786
"""Decorators for marking methods of a DBusObjectWithProperties to
787
become properties on the D-Bus.
789
The decorated method will be called with no arguments by "Get"
790
and with one argument by "Set".
792
The parameters, where they are supported, are the same as
793
dbus.service.method, except there is only "signature", since the
794
type from Get() and the type sent to Set() is the same.
796
# Encoding deeply encoded byte arrays is not supported yet by the
797
# "Set" method, so we fail early here:
798
if byte_arrays and signature != "ay":
799
raise ValueError("Byte arrays not supported for non-'ay'"
800
" signature {0!r}".format(signature))
802
func._dbus_is_property = True
803
func._dbus_interface = dbus_interface
804
func._dbus_signature = signature
805
func._dbus_access = access
806
func._dbus_name = func.__name__
807
if func._dbus_name.endswith("_dbus_property"):
808
func._dbus_name = func._dbus_name[:-14]
809
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
814
def dbus_interface_annotations(dbus_interface):
815
"""Decorator for marking functions returning interface annotations
819
@dbus_interface_annotations("org.example.Interface")
820
def _foo(self): # Function name does not matter
821
return {"org.freedesktop.DBus.Deprecated": "true",
822
"org.freedesktop.DBus.Property.EmitsChangedSignal":
826
func._dbus_is_interface = True
827
func._dbus_interface = dbus_interface
828
func._dbus_name = dbus_interface
833
def dbus_annotations(annotations):
834
"""Decorator to annotate D-Bus methods, signals or properties
837
@dbus_service_property("org.example.Interface", signature="b",
839
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
840
"org.freedesktop.DBus.Property."
841
"EmitsChangedSignal": "false"})
842
def Property_dbus_property(self):
843
return dbus.Boolean(False)
846
func._dbus_annotations = annotations
851
class DBusPropertyException(dbus.exceptions.DBusException):
852
"""A base class for D-Bus property-related exceptions
854
def __unicode__(self):
855
return unicode(str(self))
858
class DBusPropertyAccessException(DBusPropertyException):
859
"""A property's access permissions disallows an operation.
864
class DBusPropertyNotFound(DBusPropertyException):
865
"""An attempt was made to access a non-existing property.
870
class DBusObjectWithProperties(dbus.service.Object):
871
"""A D-Bus object with properties.
873
Classes inheriting from this can use the dbus_service_property
874
decorator to expose methods as D-Bus properties. It exposes the
875
standard Get(), Set(), and GetAll() methods on the D-Bus.
879
def _is_dbus_thing(thing):
880
"""Returns a function testing if an attribute is a D-Bus thing
882
If called like _is_dbus_thing("method") it returns a function
883
suitable for use as predicate to inspect.getmembers().
885
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
888
def _get_all_dbus_things(self, thing):
889
"""Returns a generator of (name, attribute) pairs
891
return ((getattr(athing.__get__(self), "_dbus_name",
893
athing.__get__(self))
894
for cls in self.__class__.__mro__
896
inspect.getmembers(cls,
897
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
906
self._is_dbus_thing("property"))):
907
if (value._dbus_name == property_name
908
and value._dbus_interface == interface_name):
909
return value.__get__(self)
912
raise DBusPropertyNotFound(self.dbus_object_path + ":"
913
+ interface_name + "."
916
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
918
def Get(self, interface_name, property_name):
919
"""Standard D-Bus property Get() method, see D-Bus standard.
921
prop = self._get_dbus_property(interface_name, property_name)
922
if prop._dbus_access == "write":
923
raise DBusPropertyAccessException(property_name)
925
if not hasattr(value, "variant_level"):
927
return type(value)(value, variant_level=value.variant_level+1)
929
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
930
def Set(self, interface_name, property_name, value):
931
"""Standard D-Bus property Set() method, see D-Bus standard.
933
prop = self._get_dbus_property(interface_name, property_name)
934
if prop._dbus_access == "read":
935
raise DBusPropertyAccessException(property_name)
936
if prop._dbus_get_args_options["byte_arrays"]:
937
# The byte_arrays option is not supported yet on
938
# signatures other than "ay".
939
if prop._dbus_signature != "ay":
940
raise ValueError("Byte arrays not supported for non-"
941
"'ay' signature {0!r}"
942
.format(prop._dbus_signature))
943
value = dbus.ByteArray(b''.join(chr(byte)
947
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
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)(value, variant_level=
969
value.variant_level+1)
970
return dbus.Dictionary(properties, signature="sv")
972
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
974
path_keyword='object_path',
975
connection_keyword='connection')
976
def Introspect(self, object_path, connection):
977
"""Overloading of standard D-Bus method.
979
Inserts property tags and interface annotation tags.
981
xmlstring = dbus.service.Object.Introspect(self, object_path,
984
document = xml.dom.minidom.parseString(xmlstring)
985
def make_tag(document, name, prop):
986
e = document.createElement("property")
987
e.setAttribute("name", name)
988
e.setAttribute("type", prop._dbus_signature)
989
e.setAttribute("access", prop._dbus_access)
991
for if_tag in document.getElementsByTagName("interface"):
993
for tag in (make_tag(document, name, prop)
995
in self._get_all_dbus_things("property")
996
if prop._dbus_interface
997
== if_tag.getAttribute("name")):
998
if_tag.appendChild(tag)
999
# Add annotation tags
1000
for typ in ("method", "signal", "property"):
1001
for tag in if_tag.getElementsByTagName(typ):
1003
for name, prop in (self.
1004
_get_all_dbus_things(typ)):
1005
if (name == tag.getAttribute("name")
1006
and prop._dbus_interface
1007
== if_tag.getAttribute("name")):
1008
annots.update(getattr
1010
"_dbus_annotations",
1012
for name, value in annots.iteritems():
1013
ann_tag = document.createElement(
1015
ann_tag.setAttribute("name", name)
1016
ann_tag.setAttribute("value", value)
1017
tag.appendChild(ann_tag)
1018
# Add interface annotation tags
1019
for annotation, value in dict(
1020
itertools.chain.from_iterable(
1021
annotations().iteritems()
1022
for name, annotations in
1023
self._get_all_dbus_things("interface")
1024
if name == if_tag.getAttribute("name")
1026
ann_tag = document.createElement("annotation")
1027
ann_tag.setAttribute("name", annotation)
1028
ann_tag.setAttribute("value", value)
1029
if_tag.appendChild(ann_tag)
1030
# Add the names to the return values for the
1031
# "org.freedesktop.DBus.Properties" methods
1032
if (if_tag.getAttribute("name")
1033
== "org.freedesktop.DBus.Properties"):
1034
for cn in if_tag.getElementsByTagName("method"):
1035
if cn.getAttribute("name") == "Get":
1036
for arg in cn.getElementsByTagName("arg"):
1037
if (arg.getAttribute("direction")
1039
arg.setAttribute("name", "value")
1040
elif cn.getAttribute("name") == "GetAll":
1041
for arg in cn.getElementsByTagName("arg"):
1042
if (arg.getAttribute("direction")
1044
arg.setAttribute("name", "props")
1045
xmlstring = document.toxml("utf-8")
1047
except (AttributeError, xml.dom.DOMException,
1048
xml.parsers.expat.ExpatError) as error:
1049
logger.error("Failed to override Introspection method",
1054
def datetime_to_dbus(dt, variant_level=0):
1055
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1057
return dbus.String("", variant_level = variant_level)
1058
return dbus.String(dt.isoformat(),
1059
variant_level=variant_level)
1062
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1063
"""A class decorator; applied to a subclass of
1064
dbus.service.Object, it will add alternate D-Bus attributes with
1065
interface names according to the "alt_interface_names" mapping.
1068
@alternate_dbus_interfaces({"org.example.Interface":
1069
"net.example.AlternateInterface"})
1070
class SampleDBusObject(dbus.service.Object):
1071
@dbus.service.method("org.example.Interface")
1072
def SampleDBusMethod():
1075
The above "SampleDBusMethod" on "SampleDBusObject" will be
1076
reachable via two interfaces: "org.example.Interface" and
1077
"net.example.AlternateInterface", the latter of which will have
1078
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1079
"true", unless "deprecate" is passed with a False value.
1081
This works for methods and signals, and also for D-Bus properties
1082
(from DBusObjectWithProperties) and interfaces (from the
1083
dbus_interface_annotations decorator).
1086
for orig_interface_name, alt_interface_name in (
1087
alt_interface_names.iteritems()):
1089
interface_names = set()
1090
# Go though all attributes of the class
1091
for attrname, attribute in inspect.getmembers(cls):
1092
# Ignore non-D-Bus attributes, and D-Bus attributes
1093
# with the wrong interface name
1094
if (not hasattr(attribute, "_dbus_interface")
1095
or not attribute._dbus_interface
1096
.startswith(orig_interface_name)):
1098
# Create an alternate D-Bus interface name based on
1100
alt_interface = (attribute._dbus_interface
1101
.replace(orig_interface_name,
1102
alt_interface_name))
1103
interface_names.add(alt_interface)
1104
# Is this a D-Bus signal?
1105
if getattr(attribute, "_dbus_is_signal", False):
1106
# Extract the original non-method undecorated
1107
# function by black magic
1108
nonmethod_func = (dict(
1109
zip(attribute.func_code.co_freevars,
1110
attribute.__closure__))["func"]
1112
# Create a new, but exactly alike, function
1113
# object, and decorate it to be a new D-Bus signal
1114
# with the alternate D-Bus interface name
1115
new_function = (dbus.service.signal
1117
attribute._dbus_signature)
1118
(types.FunctionType(
1119
nonmethod_func.func_code,
1120
nonmethod_func.func_globals,
1121
nonmethod_func.func_name,
1122
nonmethod_func.func_defaults,
1123
nonmethod_func.func_closure)))
1124
# Copy annotations, if any
1126
new_function._dbus_annotations = (
1127
dict(attribute._dbus_annotations))
1128
except AttributeError:
1130
# Define a creator of a function to call both the
1131
# original and alternate functions, so both the
1132
# original and alternate signals gets sent when
1133
# the function is called
1134
def fixscope(func1, func2):
1135
"""This function is a scope container to pass
1136
func1 and func2 to the "call_both" function
1137
outside of its arguments"""
1138
def call_both(*args, **kwargs):
1139
"""This function will emit two D-Bus
1140
signals by calling func1 and func2"""
1141
func1(*args, **kwargs)
1142
func2(*args, **kwargs)
1144
# Create the "call_both" function and add it to
1146
attr[attrname] = fixscope(attribute, new_function)
1147
# Is this a D-Bus method?
1148
elif getattr(attribute, "_dbus_is_method", False):
1149
# Create a new, but exactly alike, function
1150
# object. Decorate it to be a new D-Bus method
1151
# with the alternate D-Bus interface name. Add it
1153
attr[attrname] = (dbus.service.method
1155
attribute._dbus_in_signature,
1156
attribute._dbus_out_signature)
1158
(attribute.func_code,
1159
attribute.func_globals,
1160
attribute.func_name,
1161
attribute.func_defaults,
1162
attribute.func_closure)))
1163
# Copy annotations, if any
1165
attr[attrname]._dbus_annotations = (
1166
dict(attribute._dbus_annotations))
1167
except AttributeError:
1169
# Is this a D-Bus property?
1170
elif getattr(attribute, "_dbus_is_property", False):
1171
# Create a new, but exactly alike, function
1172
# object, and decorate it to be a new D-Bus
1173
# property with the alternate D-Bus interface
1174
# name. Add it to the class.
1175
attr[attrname] = (dbus_service_property
1177
attribute._dbus_signature,
1178
attribute._dbus_access,
1180
._dbus_get_args_options
1183
(attribute.func_code,
1184
attribute.func_globals,
1185
attribute.func_name,
1186
attribute.func_defaults,
1187
attribute.func_closure)))
1188
# Copy annotations, if any
1190
attr[attrname]._dbus_annotations = (
1191
dict(attribute._dbus_annotations))
1192
except AttributeError:
1194
# Is this a D-Bus interface?
1195
elif getattr(attribute, "_dbus_is_interface", False):
1196
# Create a new, but exactly alike, function
1197
# object. Decorate it to be a new D-Bus interface
1198
# with the alternate D-Bus interface name. Add it
1200
attr[attrname] = (dbus_interface_annotations
1203
(attribute.func_code,
1204
attribute.func_globals,
1205
attribute.func_name,
1206
attribute.func_defaults,
1207
attribute.func_closure)))
1209
# Deprecate all alternate interfaces
1210
iname="_AlternateDBusNames_interface_annotation{0}"
1211
for interface_name in interface_names:
1212
@dbus_interface_annotations(interface_name)
1214
return { "org.freedesktop.DBus.Deprecated":
1216
# Find an unused name
1217
for aname in (iname.format(i)
1218
for i in itertools.count()):
1219
if aname not in attr:
1223
# Replace the class with a new subclass of it with
1224
# methods, signals, etc. as created above.
1225
cls = type(b"{0}Alternate".format(cls.__name__),
1231
@alternate_dbus_interfaces({"se.recompile.Mandos":
1232
"se.bsnet.fukt.Mandos"})
1233
class ClientDBus(Client, DBusObjectWithProperties):
1234
"""A Client class using D-Bus
1237
dbus_object_path: dbus.ObjectPath
1238
bus: dbus.SystemBus()
1241
runtime_expansions = (Client.runtime_expansions
1242
+ ("dbus_object_path",))
1244
# dbus.service.Object doesn't use super(), so we can't either.
1246
def __init__(self, bus = None, *args, **kwargs):
1248
Client.__init__(self, *args, **kwargs)
1249
# Only now, when this client is initialized, can it show up on
1251
client_object_name = unicode(self.name).translate(
1252
{ord("."): ord("_"),
1253
ord("-"): ord("_")})
1254
self.dbus_object_path = (dbus.ObjectPath
1255
("/clients/" + client_object_name))
1256
DBusObjectWithProperties.__init__(self, self.bus,
1257
self.dbus_object_path)
1259
def notifychangeproperty(transform_func,
1260
dbus_name, type_func=lambda x: x,
1262
""" Modify a variable so that it's a property which announces
1263
its changes to DBus.
1265
transform_fun: Function that takes a value and a variant_level
1266
and transforms it to a D-Bus type.
1267
dbus_name: D-Bus name of the variable
1268
type_func: Function that transform the value before sending it
1269
to the D-Bus. Default: no transform
1270
variant_level: D-Bus variant level. Default: 1
1272
attrname = "_{0}".format(dbus_name)
1273
def setter(self, value):
1274
if hasattr(self, "dbus_object_path"):
1275
if (not hasattr(self, attrname) or
1276
type_func(getattr(self, attrname, None))
1277
!= type_func(value)):
1278
dbus_value = transform_func(type_func(value),
1281
self.PropertyChanged(dbus.String(dbus_name),
1283
setattr(self, attrname, value)
1285
return property(lambda self: getattr(self, attrname), setter)
1287
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1288
approvals_pending = notifychangeproperty(dbus.Boolean,
1291
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1292
last_enabled = notifychangeproperty(datetime_to_dbus,
1294
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1295
type_func = lambda checker:
1296
checker is not None)
1297
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1299
last_checker_status = notifychangeproperty(dbus.Int16,
1300
"LastCheckerStatus")
1301
last_approval_request = notifychangeproperty(
1302
datetime_to_dbus, "LastApprovalRequest")
1303
approved_by_default = notifychangeproperty(dbus.Boolean,
1304
"ApprovedByDefault")
1305
approval_delay = notifychangeproperty(dbus.UInt64,
1308
timedelta_to_milliseconds)
1309
approval_duration = notifychangeproperty(
1310
dbus.UInt64, "ApprovalDuration",
1311
type_func = timedelta_to_milliseconds)
1312
host = notifychangeproperty(dbus.String, "Host")
1313
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1315
timedelta_to_milliseconds)
1316
extended_timeout = notifychangeproperty(
1317
dbus.UInt64, "ExtendedTimeout",
1318
type_func = timedelta_to_milliseconds)
1319
interval = notifychangeproperty(dbus.UInt64,
1322
timedelta_to_milliseconds)
1323
checker_command = notifychangeproperty(dbus.String, "Checker")
1325
del notifychangeproperty
1327
def __del__(self, *args, **kwargs):
1329
self.remove_from_connection()
1332
if hasattr(DBusObjectWithProperties, "__del__"):
1333
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1334
Client.__del__(self, *args, **kwargs)
1336
def checker_callback(self, pid, condition, command,
1338
self.checker_callback_tag = None
1340
if os.WIFEXITED(condition):
1341
exitstatus = os.WEXITSTATUS(condition)
1343
self.CheckerCompleted(dbus.Int16(exitstatus),
1344
dbus.Int64(condition),
1345
dbus.String(command))
471
return now < (self.last_checked_ok + self.timeout)
473
## D-Bus methods & signals
474
_interface = u"se.bsnet.fukt.Mandos.Client"
477
CheckedOK = dbus.service.method(_interface)(checked_ok)
478
CheckedOK.__name__ = "CheckedOK"
1348
self.CheckerCompleted(dbus.Int16(-1),
1349
dbus.Int64(condition),
1350
dbus.String(command))
1352
return Client.checker_callback(self, pid, condition, command,
1355
def start_checker(self, *args, **kwargs):
1356
old_checker_pid = getattr(self.checker, "pid", None)
1357
r = Client.start_checker(self, *args, **kwargs)
1358
# Only if new checker process was started
1359
if (self.checker is not None
1360
and old_checker_pid != self.checker.pid):
1362
self.CheckerStarted(self.current_checker_command)
1365
def _reset_approved(self):
1366
self.approved = None
1369
def approve(self, value=True):
1370
self.approved = value
1371
gobject.timeout_add(timedelta_to_milliseconds
1372
(self.approval_duration),
1373
self._reset_approved)
1374
self.send_changedstate()
1376
## D-Bus methods, signals & properties
1377
_interface = "se.recompile.Mandos.Client"
1381
@dbus_interface_annotations(_interface)
1383
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
480
1388
# CheckerCompleted - signal
481
1389
@dbus.service.signal(_interface, signature="nxs")
605
1457
# StopChecker - method
606
StopChecker = dbus.service.method(_interface)(stop_checker)
607
StopChecker.__name__ = "StopChecker"
1458
@dbus.service.method(_interface)
1459
def StopChecker(self):
1464
# ApprovalPending - property
1465
@dbus_service_property(_interface, signature="b", access="read")
1466
def ApprovalPending_dbus_property(self):
1467
return dbus.Boolean(bool(self.approvals_pending))
1469
# ApprovedByDefault - property
1470
@dbus_service_property(_interface, signature="b",
1472
def ApprovedByDefault_dbus_property(self, value=None):
1473
if value is None: # get
1474
return dbus.Boolean(self.approved_by_default)
1475
self.approved_by_default = bool(value)
1477
# ApprovalDelay - property
1478
@dbus_service_property(_interface, signature="t",
1480
def ApprovalDelay_dbus_property(self, value=None):
1481
if value is None: # get
1482
return dbus.UInt64(self.approval_delay_milliseconds())
1483
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1485
# ApprovalDuration - property
1486
@dbus_service_property(_interface, signature="t",
1488
def ApprovalDuration_dbus_property(self, value=None):
1489
if value is None: # get
1490
return dbus.UInt64(timedelta_to_milliseconds(
1491
self.approval_duration))
1492
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1495
@dbus_service_property(_interface, signature="s", access="read")
1496
def Name_dbus_property(self):
1497
return dbus.String(self.name)
1499
# Fingerprint - property
1500
@dbus_service_property(_interface, signature="s", access="read")
1501
def Fingerprint_dbus_property(self):
1502
return dbus.String(self.fingerprint)
1505
@dbus_service_property(_interface, signature="s",
1507
def Host_dbus_property(self, value=None):
1508
if value is None: # get
1509
return dbus.String(self.host)
1510
self.host = unicode(value)
1512
# Created - property
1513
@dbus_service_property(_interface, signature="s", access="read")
1514
def Created_dbus_property(self):
1515
return datetime_to_dbus(self.created)
1517
# LastEnabled - property
1518
@dbus_service_property(_interface, signature="s", access="read")
1519
def LastEnabled_dbus_property(self):
1520
return datetime_to_dbus(self.last_enabled)
1522
# Enabled - property
1523
@dbus_service_property(_interface, signature="b",
1525
def Enabled_dbus_property(self, value=None):
1526
if value is None: # get
1527
return dbus.Boolean(self.enabled)
1533
# LastCheckedOK - property
1534
@dbus_service_property(_interface, signature="s",
1536
def LastCheckedOK_dbus_property(self, value=None):
1537
if value is not None:
1540
return datetime_to_dbus(self.last_checked_ok)
1542
# LastCheckerStatus - property
1543
@dbus_service_property(_interface, signature="n",
1545
def LastCheckerStatus_dbus_property(self):
1546
return dbus.Int16(self.last_checker_status)
1548
# Expires - property
1549
@dbus_service_property(_interface, signature="s", access="read")
1550
def Expires_dbus_property(self):
1551
return datetime_to_dbus(self.expires)
1553
# LastApprovalRequest - property
1554
@dbus_service_property(_interface, signature="s", access="read")
1555
def LastApprovalRequest_dbus_property(self):
1556
return datetime_to_dbus(self.last_approval_request)
1558
# Timeout - property
1559
@dbus_service_property(_interface, signature="t",
1561
def Timeout_dbus_property(self, value=None):
1562
if value is None: # get
1563
return dbus.UInt64(self.timeout_milliseconds())
1564
old_timeout = self.timeout
1565
self.timeout = datetime.timedelta(0, 0, 0, value)
1566
# Reschedule disabling
1568
now = datetime.datetime.utcnow()
1569
self.expires += self.timeout - old_timeout
1570
if self.expires <= now:
1571
# The timeout has passed
1574
if (getattr(self, "disable_initiator_tag", None)
1577
gobject.source_remove(self.disable_initiator_tag)
1578
self.disable_initiator_tag = (
1579
gobject.timeout_add(
1580
timedelta_to_milliseconds(self.expires - now),
1583
# ExtendedTimeout - property
1584
@dbus_service_property(_interface, signature="t",
1586
def ExtendedTimeout_dbus_property(self, value=None):
1587
if value is None: # get
1588
return dbus.UInt64(self.extended_timeout_milliseconds())
1589
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1591
# Interval - property
1592
@dbus_service_property(_interface, signature="t",
1594
def Interval_dbus_property(self, value=None):
1595
if value is None: # get
1596
return dbus.UInt64(self.interval_milliseconds())
1597
self.interval = datetime.timedelta(0, 0, 0, value)
1598
if getattr(self, "checker_initiator_tag", None) is None:
1601
# Reschedule checker run
1602
gobject.source_remove(self.checker_initiator_tag)
1603
self.checker_initiator_tag = (gobject.timeout_add
1604
(value, self.start_checker))
1605
self.start_checker() # Start one now, too
1607
# Checker - property
1608
@dbus_service_property(_interface, signature="s",
1610
def Checker_dbus_property(self, value=None):
1611
if value is None: # get
1612
return dbus.String(self.checker_command)
1613
self.checker_command = unicode(value)
1615
# CheckerRunning - property
1616
@dbus_service_property(_interface, signature="b",
1618
def CheckerRunning_dbus_property(self, value=None):
1619
if value is None: # get
1620
return dbus.Boolean(self.checker is not None)
1622
self.start_checker()
1626
# ObjectPath - property
1627
@dbus_service_property(_interface, signature="o", access="read")
1628
def ObjectPath_dbus_property(self):
1629
return self.dbus_object_path # is already a dbus.ObjectPath
1632
@dbus_service_property(_interface, signature="ay",
1633
access="write", byte_arrays=True)
1634
def Secret_dbus_property(self, value):
1635
self.secret = str(value)
612
def peer_certificate(session):
613
"Return the peer's OpenPGP certificate as a bytestring"
614
# If not an OpenPGP certificate...
615
if (gnutls.library.functions
616
.gnutls_certificate_type_get(session._c_object)
617
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
618
# ...do the normal thing
619
return session.peer_certificate
620
list_size = ctypes.c_uint(1)
621
cert_list = (gnutls.library.functions
622
.gnutls_certificate_get_peers
623
(session._c_object, ctypes.byref(list_size)))
624
if not bool(cert_list) and list_size.value != 0:
625
raise gnutls.errors.GNUTLSError("error getting peer"
627
if list_size.value == 0:
630
return ctypes.string_at(cert.data, cert.size)
633
def fingerprint(openpgp):
634
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
635
# New GnuTLS "datum" with the OpenPGP public key
636
datum = (gnutls.library.types
637
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
640
ctypes.c_uint(len(openpgp))))
641
# New empty GnuTLS certificate
642
crt = gnutls.library.types.gnutls_openpgp_crt_t()
643
(gnutls.library.functions
644
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
645
# Import the OpenPGP public key into the certificate
646
(gnutls.library.functions
647
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
648
gnutls.library.constants
649
.GNUTLS_OPENPGP_FMT_RAW))
650
# Verify the self signature in the key
651
crtverify = ctypes.c_uint()
652
(gnutls.library.functions
653
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
654
if crtverify.value != 0:
655
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
656
raise gnutls.errors.CertificateSecurityError("Verify failed")
657
# New buffer for the fingerprint
658
buf = ctypes.create_string_buffer(20)
659
buf_len = ctypes.c_size_t()
660
# Get the fingerprint from the certificate into the buffer
661
(gnutls.library.functions
662
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
663
ctypes.byref(buf_len)))
664
# Deinit the certificate
665
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
666
# Convert the buffer to a Python bytestring
667
fpr = ctypes.string_at(buf, buf_len.value)
668
# Convert the bytestring to hexadecimal notation
669
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
673
class TCP_handler(SocketServer.BaseRequestHandler, object):
674
"""A TCP request handler class.
675
Instantiated by IPv6_TCPServer for each request to handle it.
1640
class ProxyClient(object):
1641
def __init__(self, child_pipe, fpr, address):
1642
self._pipe = child_pipe
1643
self._pipe.send(('init', fpr, address))
1644
if not self._pipe.recv():
1647
def __getattribute__(self, name):
1649
return super(ProxyClient, self).__getattribute__(name)
1650
self._pipe.send(('getattr', name))
1651
data = self._pipe.recv()
1652
if data[0] == 'data':
1654
if data[0] == 'function':
1655
def func(*args, **kwargs):
1656
self._pipe.send(('funcall', name, args, kwargs))
1657
return self._pipe.recv()[1]
1660
def __setattr__(self, name, value):
1662
return super(ProxyClient, self).__setattr__(name, value)
1663
self._pipe.send(('setattr', name, value))
1666
class ClientHandler(socketserver.BaseRequestHandler, object):
1667
"""A class to handle client connections.
1669
Instantiated once for each connection to handle it.
676
1670
Note: This will run in its own forked process."""
678
1672
def handle(self):
679
logger.info(u"TCP connection from: %s",
680
unicode(self.client_address))
681
session = (gnutls.connection
682
.ClientSession(self.request,
686
line = self.request.makefile().readline()
687
logger.debug(u"Protocol version: %r", line)
689
if int(line.strip().split()[0]) > 1:
691
except (ValueError, IndexError, RuntimeError), error:
692
logger.error(u"Unknown protocol version: %s", error)
695
# Note: gnutls.connection.X509Credentials is really a generic
696
# GnuTLS certificate credentials object so long as no X.509
697
# keys are added to it. Therefore, we can use it here despite
698
# using OpenPGP certificates.
700
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
701
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
703
# Use a fallback default, since this MUST be set.
704
priority = self.server.settings.get("priority", "NORMAL")
705
(gnutls.library.functions
706
.gnutls_priority_set_direct(session._c_object,
711
except gnutls.errors.GNUTLSError, error:
712
logger.warning(u"Handshake failed: %s", error)
713
# Do not run session.bye() here: the session is not
714
# established. Just abandon the request.
716
logger.debug(u"Handshake succeeded")
718
fpr = fingerprint(peer_certificate(session))
719
except (TypeError, gnutls.errors.GNUTLSError), error:
720
logger.warning(u"Bad certificate: %s", error)
723
logger.debug(u"Fingerprint: %s", fpr)
725
for c in self.server.clients:
726
if c.fingerprint == fpr:
730
logger.warning(u"Client not found for fingerprint: %s",
734
# Have to check if client.still_valid(), since it is possible
735
# that the client timed out while establishing the GnuTLS
737
if not client.still_valid():
738
logger.warning(u"Client %(name)s is invalid",
742
## This won't work here, since we're in a fork.
743
# client.checked_ok()
745
while sent_size < len(client.secret):
746
sent = session.send(client.secret[sent_size:])
747
logger.debug(u"Sent: %d, remaining: %d",
748
sent, len(client.secret)
749
- (sent_size + sent))
754
class IPv6_TCPServer(SocketServer.ForkingMixIn,
755
SocketServer.TCPServer, object):
1673
with contextlib.closing(self.server.child_pipe) as child_pipe:
1674
logger.info("TCP connection from: %s",
1675
unicode(self.client_address))
1676
logger.debug("Pipe FD: %d",
1677
self.server.child_pipe.fileno())
1679
session = (gnutls.connection
1680
.ClientSession(self.request,
1682
.X509Credentials()))
1684
# Note: gnutls.connection.X509Credentials is really a
1685
# generic GnuTLS certificate credentials object so long as
1686
# no X.509 keys are added to it. Therefore, we can use it
1687
# here despite using OpenPGP certificates.
1689
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1690
# "+AES-256-CBC", "+SHA1",
1691
# "+COMP-NULL", "+CTYPE-OPENPGP",
1693
# Use a fallback default, since this MUST be set.
1694
priority = self.server.gnutls_priority
1695
if priority is None:
1697
(gnutls.library.functions
1698
.gnutls_priority_set_direct(session._c_object,
1701
# Start communication using the Mandos protocol
1702
# Get protocol number
1703
line = self.request.makefile().readline()
1704
logger.debug("Protocol version: %r", line)
1706
if int(line.strip().split()[0]) > 1:
1707
raise RuntimeError(line)
1708
except (ValueError, IndexError, RuntimeError) as error:
1709
logger.error("Unknown protocol version: %s", error)
1712
# Start GnuTLS connection
1715
except gnutls.errors.GNUTLSError as error:
1716
logger.warning("Handshake failed: %s", error)
1717
# Do not run session.bye() here: the session is not
1718
# established. Just abandon the request.
1720
logger.debug("Handshake succeeded")
1722
approval_required = False
1725
fpr = self.fingerprint(self.peer_certificate
1728
gnutls.errors.GNUTLSError) as error:
1729
logger.warning("Bad certificate: %s", error)
1731
logger.debug("Fingerprint: %s", fpr)
1734
client = ProxyClient(child_pipe, fpr,
1735
self.client_address)
1739
if client.approval_delay:
1740
delay = client.approval_delay
1741
client.approvals_pending += 1
1742
approval_required = True
1745
if not client.enabled:
1746
logger.info("Client %s is disabled",
1748
if self.server.use_dbus:
1750
client.Rejected("Disabled")
1753
if client.approved or not client.approval_delay:
1754
#We are approved or approval is disabled
1756
elif client.approved is None:
1757
logger.info("Client %s needs approval",
1759
if self.server.use_dbus:
1761
client.NeedApproval(
1762
client.approval_delay_milliseconds(),
1763
client.approved_by_default)
1765
logger.warning("Client %s was not approved",
1767
if self.server.use_dbus:
1769
client.Rejected("Denied")
1772
#wait until timeout or approved
1773
time = datetime.datetime.now()
1774
client.changedstate.acquire()
1775
client.changedstate.wait(
1776
float(timedelta_to_milliseconds(delay)
1778
client.changedstate.release()
1779
time2 = datetime.datetime.now()
1780
if (time2 - time) >= delay:
1781
if not client.approved_by_default:
1782
logger.warning("Client %s timed out while"
1783
" waiting for approval",
1785
if self.server.use_dbus:
1787
client.Rejected("Approval timed out")
1792
delay -= time2 - time
1795
while sent_size < len(client.secret):
1797
sent = session.send(client.secret[sent_size:])
1798
except gnutls.errors.GNUTLSError as error:
1799
logger.warning("gnutls send failed",
1802
logger.debug("Sent: %d, remaining: %d",
1803
sent, len(client.secret)
1804
- (sent_size + sent))
1807
logger.info("Sending secret to %s", client.name)
1808
# bump the timeout using extended_timeout
1809
client.bump_timeout(client.extended_timeout)
1810
if self.server.use_dbus:
1815
if approval_required:
1816
client.approvals_pending -= 1
1819
except gnutls.errors.GNUTLSError as error:
1820
logger.warning("GnuTLS bye failed",
1824
def peer_certificate(session):
1825
"Return the peer's OpenPGP certificate as a bytestring"
1826
# If not an OpenPGP certificate...
1827
if (gnutls.library.functions
1828
.gnutls_certificate_type_get(session._c_object)
1829
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1830
# ...do the normal thing
1831
return session.peer_certificate
1832
list_size = ctypes.c_uint(1)
1833
cert_list = (gnutls.library.functions
1834
.gnutls_certificate_get_peers
1835
(session._c_object, ctypes.byref(list_size)))
1836
if not bool(cert_list) and list_size.value != 0:
1837
raise gnutls.errors.GNUTLSError("error getting peer"
1839
if list_size.value == 0:
1842
return ctypes.string_at(cert.data, cert.size)
1845
def fingerprint(openpgp):
1846
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1847
# New GnuTLS "datum" with the OpenPGP public key
1848
datum = (gnutls.library.types
1849
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1852
ctypes.c_uint(len(openpgp))))
1853
# New empty GnuTLS certificate
1854
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1855
(gnutls.library.functions
1856
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1857
# Import the OpenPGP public key into the certificate
1858
(gnutls.library.functions
1859
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1860
gnutls.library.constants
1861
.GNUTLS_OPENPGP_FMT_RAW))
1862
# Verify the self signature in the key
1863
crtverify = ctypes.c_uint()
1864
(gnutls.library.functions
1865
.gnutls_openpgp_crt_verify_self(crt, 0,
1866
ctypes.byref(crtverify)))
1867
if crtverify.value != 0:
1868
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1869
raise (gnutls.errors.CertificateSecurityError
1871
# New buffer for the fingerprint
1872
buf = ctypes.create_string_buffer(20)
1873
buf_len = ctypes.c_size_t()
1874
# Get the fingerprint from the certificate into the buffer
1875
(gnutls.library.functions
1876
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1877
ctypes.byref(buf_len)))
1878
# Deinit the certificate
1879
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1880
# Convert the buffer to a Python bytestring
1881
fpr = ctypes.string_at(buf, buf_len.value)
1882
# Convert the bytestring to hexadecimal notation
1883
hex_fpr = binascii.hexlify(fpr).upper()
1887
class MultiprocessingMixIn(object):
1888
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1889
def sub_process_main(self, request, address):
1891
self.finish_request(request, address)
1893
self.handle_error(request, address)
1894
self.close_request(request)
1896
def process_request(self, request, address):
1897
"""Start a new process to process the request."""
1898
proc = multiprocessing.Process(target = self.sub_process_main,
1899
args = (request, address))
1904
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1905
""" adds a pipe to the MixIn """
1906
def process_request(self, request, client_address):
1907
"""Overrides and wraps the original process_request().
1909
This function creates a new pipe in self.pipe
1911
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1913
proc = MultiprocessingMixIn.process_request(self, request,
1915
self.child_pipe.close()
1916
self.add_pipe(parent_pipe, proc)
1918
def add_pipe(self, parent_pipe, proc):
1919
"""Dummy function; override as necessary"""
1920
raise NotImplementedError()
1923
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1924
socketserver.TCPServer, object):
756
1925
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
758
settings: Server settings
759
clients: Set() of Client objects
760
1928
enabled: Boolean; whether this server is activated yet
1929
interface: None or a network interface name (string)
1930
use_ipv6: Boolean; to use IPv6 or not
762
address_family = socket.AF_INET6
763
def __init__(self, *args, **kwargs):
764
if "settings" in kwargs:
765
self.settings = kwargs["settings"]
766
del kwargs["settings"]
767
if "clients" in kwargs:
768
self.clients = kwargs["clients"]
769
del kwargs["clients"]
770
if "use_ipv6" in kwargs:
771
if not kwargs["use_ipv6"]:
772
self.address_family = socket.AF_INET
773
del kwargs["use_ipv6"]
775
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
1932
def __init__(self, server_address, RequestHandlerClass,
1933
interface=None, use_ipv6=True, socketfd=None):
1934
"""If socketfd is set, use that file descriptor instead of
1935
creating a new one with socket.socket().
1937
self.interface = interface
1939
self.address_family = socket.AF_INET6
1940
if socketfd is not None:
1941
# Save the file descriptor
1942
self.socketfd = socketfd
1943
# Save the original socket.socket() function
1944
self.socket_socket = socket.socket
1945
# To implement --socket, we monkey patch socket.socket.
1947
# (When socketserver.TCPServer is a new-style class, we
1948
# could make self.socket into a property instead of monkey
1949
# patching socket.socket.)
1951
# Create a one-time-only replacement for socket.socket()
1952
@functools.wraps(socket.socket)
1953
def socket_wrapper(*args, **kwargs):
1954
# Restore original function so subsequent calls are
1956
socket.socket = self.socket_socket
1957
del self.socket_socket
1958
# This time only, return a new socket object from the
1959
# saved file descriptor.
1960
return socket.fromfd(self.socketfd, *args, **kwargs)
1961
# Replace socket.socket() function with wrapper
1962
socket.socket = socket_wrapper
1963
# The socketserver.TCPServer.__init__ will call
1964
# socket.socket(), which might be our replacement,
1965
# socket_wrapper(), if socketfd was set.
1966
socketserver.TCPServer.__init__(self, server_address,
1967
RequestHandlerClass)
776
1969
def server_bind(self):
777
1970
"""This overrides the normal server_bind() function
778
1971
to bind to an interface if one was specified, and also NOT to
779
1972
bind to an address or port if they were not specified."""
780
if self.settings["interface"]:
781
# 25 is from /usr/include/asm-i486/socket.h
782
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
784
self.socket.setsockopt(socket.SOL_SOCKET,
786
self.settings["interface"])
787
except socket.error, error:
788
if error[0] == errno.EPERM:
789
logger.error(u"No permission to"
790
u" bind to interface %s",
791
self.settings["interface"])
1973
if self.interface is not None:
1974
if SO_BINDTODEVICE is None:
1975
logger.error("SO_BINDTODEVICE does not exist;"
1976
" cannot bind to interface %s",
1980
self.socket.setsockopt(socket.SOL_SOCKET,
1982
str(self.interface + '\0'))
1983
except socket.error as error:
1984
if error.errno == errno.EPERM:
1985
logger.error("No permission to bind to"
1986
" interface %s", self.interface)
1987
elif error.errno == errno.ENOPROTOOPT:
1988
logger.error("SO_BINDTODEVICE not available;"
1989
" cannot bind to interface %s",
1991
elif error.errno == errno.ENODEV:
1992
logger.error("Interface %s does not exist,"
1993
" cannot bind", self.interface)
794
1996
# Only bind(2) the socket if we really need to.
795
1997
if self.server_address[0] or self.server_address[1]:
796
1998
if not self.server_address[0]:
797
1999
if self.address_family == socket.AF_INET6:
798
2000
any_address = "::" # in6addr_any
800
any_address = socket.INADDR_ANY
2002
any_address = "0.0.0.0" # INADDR_ANY
801
2003
self.server_address = (any_address,
802
2004
self.server_address[1])
803
2005
elif not self.server_address[1]:
804
2006
self.server_address = (self.server_address[0],
806
# if self.settings["interface"]:
2008
# if self.interface:
807
2009
# self.server_address = (self.server_address[0],
810
2012
# if_nametoindex
813
return super(IPv6_TCPServer, self).server_bind()
2014
return socketserver.TCPServer.server_bind(self)
2017
class MandosServer(IPv6_TCPServer):
2021
clients: set of Client objects
2022
gnutls_priority GnuTLS priority string
2023
use_dbus: Boolean; to emit D-Bus signals or not
2025
Assumes a gobject.MainLoop event loop.
2027
def __init__(self, server_address, RequestHandlerClass,
2028
interface=None, use_ipv6=True, clients=None,
2029
gnutls_priority=None, use_dbus=True, socketfd=None):
2030
self.enabled = False
2031
self.clients = clients
2032
if self.clients is None:
2034
self.use_dbus = use_dbus
2035
self.gnutls_priority = gnutls_priority
2036
IPv6_TCPServer.__init__(self, server_address,
2037
RequestHandlerClass,
2038
interface = interface,
2039
use_ipv6 = use_ipv6,
2040
socketfd = socketfd)
814
2041
def server_activate(self):
815
2042
if self.enabled:
816
return super(IPv6_TCPServer, self).server_activate()
2043
return socketserver.TCPServer.server_activate(self)
817
2045
def enable(self):
818
2046
self.enabled = True
2048
def add_pipe(self, parent_pipe, proc):
2049
# Call "handle_ipc" for both data and EOF events
2050
gobject.io_add_watch(parent_pipe.fileno(),
2051
gobject.IO_IN | gobject.IO_HUP,
2052
functools.partial(self.handle_ipc,
2057
def handle_ipc(self, source, condition, parent_pipe=None,
2058
proc = None, client_object=None):
2059
# error, or the other end of multiprocessing.Pipe has closed
2060
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2061
# Wait for other process to exit
2065
# Read a request from the child
2066
request = parent_pipe.recv()
2067
command = request[0]
2069
if command == 'init':
2071
address = request[2]
2073
for c in self.clients.itervalues():
2074
if c.fingerprint == fpr:
2078
logger.info("Client not found for fingerprint: %s, ad"
2079
"dress: %s", fpr, address)
2082
mandos_dbus_service.ClientNotFound(fpr,
2084
parent_pipe.send(False)
2087
gobject.io_add_watch(parent_pipe.fileno(),
2088
gobject.IO_IN | gobject.IO_HUP,
2089
functools.partial(self.handle_ipc,
2095
parent_pipe.send(True)
2096
# remove the old hook in favor of the new above hook on
2099
if command == 'funcall':
2100
funcname = request[1]
2104
parent_pipe.send(('data', getattr(client_object,
2108
if command == 'getattr':
2109
attrname = request[1]
2110
if callable(client_object.__getattribute__(attrname)):
2111
parent_pipe.send(('function',))
2113
parent_pipe.send(('data', client_object
2114
.__getattribute__(attrname)))
2116
if command == 'setattr':
2117
attrname = request[1]
2119
setattr(client_object, attrname, value)
2124
def rfc3339_duration_to_delta(duration):
2125
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2127
>>> rfc3339_duration_to_delta("P7D")
2128
datetime.timedelta(7)
2129
>>> rfc3339_duration_to_delta("PT60S")
2130
datetime.timedelta(0, 60)
2131
>>> rfc3339_duration_to_delta("PT60M")
2132
datetime.timedelta(0, 3600)
2133
>>> rfc3339_duration_to_delta("PT24H")
2134
datetime.timedelta(1)
2135
>>> rfc3339_duration_to_delta("P1W")
2136
datetime.timedelta(7)
2137
>>> rfc3339_duration_to_delta("PT5M30S")
2138
datetime.timedelta(0, 330)
2139
>>> rfc3339_duration_to_delta("P1DT3M20S")
2140
datetime.timedelta(1, 200)
2143
# Parsing an RFC 3339 duration with regular expressions is not
2144
# possible - there would have to be multiple places for the same
2145
# values, like seconds. The current code, while more esoteric, is
2146
# cleaner without depending on a parsing library. If Python had a
2147
# built-in library for parsing we would use it, but we'd like to
2148
# avoid excessive use of external libraries.
2150
# New type for defining tokens, syntax, and semantics all-in-one
2151
Token = collections.namedtuple("Token",
2152
("regexp", # To match token; if
2153
# "value" is not None,
2154
# must have a "group"
2156
"value", # datetime.timedelta or
2158
"followers")) # Tokens valid after
2160
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2161
# the "duration" ABNF definition in RFC 3339, Appendix A.
2162
token_end = Token(re.compile(r"$"), None, frozenset())
2163
token_second = Token(re.compile(r"(\d+)S"),
2164
datetime.timedelta(seconds=1),
2165
frozenset((token_end,)))
2166
token_minute = Token(re.compile(r"(\d+)M"),
2167
datetime.timedelta(minutes=1),
2168
frozenset((token_second, token_end)))
2169
token_hour = Token(re.compile(r"(\d+)H"),
2170
datetime.timedelta(hours=1),
2171
frozenset((token_minute, token_end)))
2172
token_time = Token(re.compile(r"T"),
2174
frozenset((token_hour, token_minute,
2176
token_day = Token(re.compile(r"(\d+)D"),
2177
datetime.timedelta(days=1),
2178
frozenset((token_time, token_end)))
2179
token_month = Token(re.compile(r"(\d+)M"),
2180
datetime.timedelta(weeks=4),
2181
frozenset((token_day, token_end)))
2182
token_year = Token(re.compile(r"(\d+)Y"),
2183
datetime.timedelta(weeks=52),
2184
frozenset((token_month, token_end)))
2185
token_week = Token(re.compile(r"(\d+)W"),
2186
datetime.timedelta(weeks=1),
2187
frozenset((token_end,)))
2188
token_duration = Token(re.compile(r"P"), None,
2189
frozenset((token_year, token_month,
2190
token_day, token_time,
2192
# Define starting values
2193
value = datetime.timedelta() # Value so far
2195
followers = frozenset((token_duration,)) # Following valid tokens
2196
s = duration # String left to parse
2197
# Loop until end token is found
2198
while found_token is not token_end:
2199
# Search for any currently valid tokens
2200
for token in followers:
2201
match = token.regexp.match(s)
2202
if match is not None:
2204
if token.value is not None:
2205
# Value found, parse digits
2206
factor = int(match.group(1), 10)
2207
# Add to value so far
2208
value += factor * token.value
2209
# Strip token from string
2210
s = token.regexp.sub("", s, 1)
2213
# Set valid next tokens
2214
followers = found_token.followers
2217
# No currently valid tokens were found
2218
raise ValueError("Invalid RFC 3339 duration")
821
2223
def string_to_delta(interval):
966
2355
"debug": "False",
968
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2357
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
969
2358
"servicename": "Mandos",
970
2359
"use_dbus": "True",
971
2360
"use_ipv6": "True",
2364
"statedir": "/var/lib/mandos",
2365
"foreground": "False",
974
2369
# Parse config file for server-global settings
975
server_config = ConfigParser.SafeConfigParser(server_defaults)
2370
server_config = configparser.SafeConfigParser(server_defaults)
976
2371
del server_defaults
977
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2372
server_config.read(os.path.join(options.configdir,
978
2374
# Convert the SafeConfigParser object to a dict
979
2375
server_settings = server_config.defaults()
980
2376
# Use the appropriate methods on the non-string config options
981
server_settings["debug"] = server_config.getboolean("DEFAULT",
983
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
985
server_settings["use_ipv6"] = server_config.getboolean("DEFAULT",
2377
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2378
server_settings[option] = server_config.getboolean("DEFAULT",
987
2380
if server_settings["port"]:
988
2381
server_settings["port"] = server_config.getint("DEFAULT",
2383
if server_settings["socket"]:
2384
server_settings["socket"] = server_config.getint("DEFAULT",
2386
# Later, stdin will, and stdout and stderr might, be dup'ed
2387
# over with an opened os.devnull. But we don't want this to
2388
# happen with a supplied network socket.
2389
if 0 <= server_settings["socket"] <= 2:
2390
server_settings["socket"] = os.dup(server_settings
990
2392
del server_config
992
2394
# Override the settings from the config file with command line
993
2395
# options, if set.
994
2396
for option in ("interface", "address", "port", "debug",
995
2397
"priority", "servicename", "configdir",
996
"use_dbus", "use_ipv6"):
2398
"use_dbus", "use_ipv6", "debuglevel", "restore",
2399
"statedir", "socket", "foreground", "zeroconf"):
997
2400
value = getattr(options, option)
998
2401
if value is not None:
999
2402
server_settings[option] = value
2404
# Force all strings to be unicode
2405
for option in server_settings.keys():
2406
if type(server_settings[option]) is str:
2407
server_settings[option] = unicode(server_settings[option])
2408
# Force all boolean options to be boolean
2409
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2410
"foreground", "zeroconf"):
2411
server_settings[option] = bool(server_settings[option])
2412
# Debug implies foreground
2413
if server_settings["debug"]:
2414
server_settings["foreground"] = True
1001
2415
# Now we have our good server settings in "server_settings"
2417
##################################################################
2419
if (not server_settings["zeroconf"] and
2420
not (server_settings["port"]
2421
or server_settings["socket"] != "")):
2422
parser.error("Needs port or socket to work without"
1003
2425
# For convenience
1004
2426
debug = server_settings["debug"]
2427
debuglevel = server_settings["debuglevel"]
1005
2428
use_dbus = server_settings["use_dbus"]
1006
use_dbus = False # XXX: Not done yet
1007
2429
use_ipv6 = server_settings["use_ipv6"]
2430
stored_state_path = os.path.join(server_settings["statedir"],
2432
foreground = server_settings["foreground"]
2433
zeroconf = server_settings["zeroconf"]
1010
syslogger.setLevel(logging.WARNING)
1011
console.setLevel(logging.WARNING)
2436
initlogger(debug, logging.DEBUG)
2441
level = getattr(logging, debuglevel.upper())
2442
initlogger(debug, level)
1013
2444
if server_settings["servicename"] != "Mandos":
1014
2445
syslogger.setFormatter(logging.Formatter
1015
('Mandos (%s): %%(levelname)s:'
1017
% server_settings["servicename"]))
2446
('Mandos ({0}) [%(process)d]:'
2447
' %(levelname)s: %(message)s'
2448
.format(server_settings
1019
2451
# Parse config file with clients
1020
client_defaults = { "timeout": "1h",
1022
"checker": "fping -q -- %%(host)s",
1025
client_config = ConfigParser.SafeConfigParser(client_defaults)
2452
client_config = configparser.SafeConfigParser(Client
1026
2454
client_config.read(os.path.join(server_settings["configdir"],
1027
2455
"clients.conf"))
1030
tcp_server = IPv6_TCPServer((server_settings["address"],
1031
server_settings["port"]),
1033
settings=server_settings,
1034
clients=clients, use_ipv6=use_ipv6)
1035
pidfilename = "/var/run/mandos.pid"
1037
pidfile = open(pidfilename, "w")
1039
logger.error("Could not open file %r", pidfilename)
1042
uid = pwd.getpwnam("_mandos").pw_uid
1043
gid = pwd.getpwnam("_mandos").pw_gid
1046
uid = pwd.getpwnam("mandos").pw_uid
1047
gid = pwd.getpwnam("mandos").pw_gid
2457
global mandos_dbus_service
2458
mandos_dbus_service = None
2461
if server_settings["socket"] != "":
2462
socketfd = server_settings["socket"]
2463
tcp_server = MandosServer((server_settings["address"],
2464
server_settings["port"]),
2466
interface=(server_settings["interface"]
2470
server_settings["priority"],
2474
pidfilename = "/run/mandos.pid"
2475
if not os.path.isdir("/run/."):
2476
pidfilename = "/var/run/mandos.pid"
2479
pidfile = open(pidfilename, "w")
2480
except IOError as e:
2481
logger.error("Could not open file %r", pidfilename,
2484
for name in ("_mandos", "mandos", "nobody"):
2486
uid = pwd.getpwnam(name).pw_uid
2487
gid = pwd.getpwnam(name).pw_gid
1048
2489
except KeyError:
1050
uid = pwd.getpwnam("nobody").pw_uid
1051
gid = pwd.getpwnam("nogroup").pw_gid
1058
except OSError, error:
1059
if error[0] != errno.EPERM:
2497
except OSError as error:
2498
if error.errno != errno.EPERM:
1062
# Enable all possible GnuTLS debugging
2502
# Enable all possible GnuTLS debugging
1064
2504
# "Use a log level over 10 to enable all debugging options."
1065
2505
# - GnuTLS manual
1066
2506
gnutls.library.functions.gnutls_global_set_log_level(11)
1072
2512
(gnutls.library.functions
1073
2513
.gnutls_global_set_log_function(debug_gnutls))
1076
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1077
service = AvahiService(name = server_settings["servicename"],
1078
servicetype = "_mandos._tcp",
1079
protocol = protocol)
1080
if server_settings["interface"]:
1081
service.interface = (if_nametoindex
1082
(server_settings["interface"]))
2515
# Redirect stdin so all checkers get /dev/null
2516
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2517
os.dup2(null, sys.stdin.fileno())
2521
# Need to fork before connecting to D-Bus
2523
# Close all input and output, do double fork, etc.
2526
# multiprocessing will use threads, so before we use gobject we
2527
# need to inform gobject that threads will be used.
2528
gobject.threads_init()
1084
2530
global main_loop
1087
2531
# From the Avahi example code
1088
DBusGMainLoop(set_as_default=True )
2532
DBusGMainLoop(set_as_default=True)
1089
2533
main_loop = gobject.MainLoop()
1090
2534
bus = dbus.SystemBus()
1091
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1092
avahi.DBUS_PATH_SERVER),
1093
avahi.DBUS_INTERFACE_SERVER)
1094
2535
# End of Avahi example code
1096
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1098
clients.update(Set(Client(name = section,
1100
= dict(client_config.items(section)),
1101
use_dbus = use_dbus)
1102
for section in client_config.sections()))
1104
logger.warning(u"No clients defined")
1107
# Redirect stdin so all checkers get /dev/null
1108
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1109
os.dup2(null, sys.stdin.fileno())
1113
# No console logging
1114
logger.removeHandler(console)
1115
# Close all input and output, do double fork, etc.
1120
pidfile.write(str(pid) + "\n")
2538
bus_name = dbus.service.BusName("se.recompile.Mandos",
2539
bus, do_not_queue=True)
2540
old_bus_name = (dbus.service.BusName
2541
("se.bsnet.fukt.Mandos", bus,
2543
except dbus.exceptions.NameExistsException as e:
2544
logger.error("Disabling D-Bus:", exc_info=e)
2546
server_settings["use_dbus"] = False
2547
tcp_server.use_dbus = False
2549
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2550
service = AvahiServiceToSyslog(name =
2551
server_settings["servicename"],
2552
servicetype = "_mandos._tcp",
2553
protocol = protocol, bus = bus)
2554
if server_settings["interface"]:
2555
service.interface = (if_nametoindex
2556
(str(server_settings["interface"])))
2558
global multiprocessing_manager
2559
multiprocessing_manager = multiprocessing.Manager()
2561
client_class = Client
2563
client_class = functools.partial(ClientDBus, bus = bus)
2565
client_settings = Client.config_parser(client_config)
2566
old_client_settings = {}
2569
# This is used to redirect stdout and stderr for checker processes
2571
wnull = open(os.devnull, "w") # A writable /dev/null
2572
# Only used if server is running in foreground but not in debug
2574
if debug or not foreground:
2577
# Get client data and settings from last running state.
2578
if server_settings["restore"]:
2580
with open(stored_state_path, "rb") as stored_state:
2581
clients_data, old_client_settings = (pickle.load
2583
os.remove(stored_state_path)
2584
except IOError as e:
2585
if e.errno == errno.ENOENT:
2586
logger.warning("Could not load persistent state: {0}"
2587
.format(os.strerror(e.errno)))
2589
logger.critical("Could not load persistent state:",
2592
except EOFError as e:
2593
logger.warning("Could not load persistent state: "
2594
"EOFError:", exc_info=e)
2596
with PGPEngine() as pgp:
2597
for client_name, client in clients_data.iteritems():
2598
# Skip removed clients
2599
if client_name not in client_settings:
2602
# Decide which value to use after restoring saved state.
2603
# We have three different values: Old config file,
2604
# new config file, and saved state.
2605
# New config value takes precedence if it differs from old
2606
# config value, otherwise use saved state.
2607
for name, value in client_settings[client_name].items():
2609
# For each value in new config, check if it
2610
# differs from the old config value (Except for
2611
# the "secret" attribute)
2612
if (name != "secret" and
2613
value != old_client_settings[client_name]
2615
client[name] = value
2619
# Clients who has passed its expire date can still be
2620
# enabled if its last checker was successful. Clients
2621
# whose checker succeeded before we stored its state is
2622
# assumed to have successfully run all checkers during
2624
if client["enabled"]:
2625
if datetime.datetime.utcnow() >= client["expires"]:
2626
if not client["last_checked_ok"]:
2628
"disabling client {0} - Client never "
2629
"performed a successful checker"
2630
.format(client_name))
2631
client["enabled"] = False
2632
elif client["last_checker_status"] != 0:
2634
"disabling client {0} - Client "
2635
"last checker failed with error code {1}"
2636
.format(client_name,
2637
client["last_checker_status"]))
2638
client["enabled"] = False
2640
client["expires"] = (datetime.datetime
2642
+ client["timeout"])
2643
logger.debug("Last checker succeeded,"
2644
" keeping {0} enabled"
2645
.format(client_name))
2647
client["secret"] = (
2648
pgp.decrypt(client["encrypted_secret"],
2649
client_settings[client_name]
2652
# If decryption fails, we use secret from new settings
2653
logger.debug("Failed to decrypt {0} old secret"
2654
.format(client_name))
2655
client["secret"] = (
2656
client_settings[client_name]["secret"])
2658
# Add/remove clients based on new changes made to config
2659
for client_name in (set(old_client_settings)
2660
- set(client_settings)):
2661
del clients_data[client_name]
2662
for client_name in (set(client_settings)
2663
- set(old_client_settings)):
2664
clients_data[client_name] = client_settings[client_name]
2666
# Create all client objects
2667
for client_name, client in clients_data.iteritems():
2668
tcp_server.clients[client_name] = client_class(
2669
name = client_name, settings = client,
2670
server_settings = server_settings)
2672
if not tcp_server.clients:
2673
logger.warning("No clients defined")
2676
if pidfile is not None:
2680
pidfile.write(str(pid) + "\n".encode("utf-8"))
2682
logger.error("Could not write to file %r with PID %d",
1124
logger.error(u"Could not write to file %r with PID %d",
1127
# "pidfile" was never created
1132
"Cleanup function; run on exit"
1134
# From the Avahi example code
1135
if not group is None:
1138
# End of Avahi example code
1141
client = clients.pop()
1142
client.disable_hook = None
1145
atexit.register(cleanup)
1148
signal.signal(signal.SIGINT, signal.SIG_IGN)
1149
2687
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1150
2688
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1153
class MandosServer(dbus.service.Object):
2691
@alternate_dbus_interfaces({"se.recompile.Mandos":
2692
"se.bsnet.fukt.Mandos"})
2693
class MandosDBusService(DBusObjectWithProperties):
1154
2694
"""A D-Bus proxy object"""
1155
2695
def __init__(self):
1156
2696
dbus.service.Object.__init__(self, bus, "/")
1157
_interface = u"se.bsnet.fukt.Mandos"
1159
@dbus.service.signal(_interface, signature="oa{sv}")
1160
def ClientAdded(self, objpath, properties):
2697
_interface = "se.recompile.Mandos"
2699
@dbus_interface_annotations(_interface)
2701
return { "org.freedesktop.DBus.Property"
2702
".EmitsChangedSignal":
2705
@dbus.service.signal(_interface, signature="o")
2706
def ClientAdded(self, objpath):
2710
@dbus.service.signal(_interface, signature="ss")
2711
def ClientNotFound(self, fingerprint, address):