80
88
except ImportError:
81
89
SO_BINDTODEVICE = None
86
logger = logging.Logger(u'mandos')
87
syslogger = (logging.handlers.SysLogHandler
88
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
89
address = "/dev/log"))
90
syslogger.setFormatter(logging.Formatter
91
(u'Mandos [%(process)d]: %(levelname)s:'
93
logger.addHandler(syslogger)
95
console = logging.StreamHandler()
96
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
99
logger.addHandler(console)
91
if sys.version_info.major == 2:
95
stored_state_file = "clients.pickle"
97
logger = logging.getLogger()
101
if_nametoindex = (ctypes.cdll.LoadLibrary
102
(ctypes.util.find_library("c"))
104
except (OSError, AttributeError):
105
def if_nametoindex(interface):
106
"Get an interface index the hard way, i.e. using fcntl()"
107
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
108
with contextlib.closing(socket.socket()) as s:
109
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
110
struct.pack(b"16s16x", interface))
111
interface_index = struct.unpack("I", ifreq[16:20])[0]
112
return interface_index
115
def initlogger(debug, level=logging.WARNING):
116
"""init logger and add loglevel"""
119
syslogger = (logging.handlers.SysLogHandler
121
logging.handlers.SysLogHandler.LOG_DAEMON,
122
address = "/dev/log"))
123
syslogger.setFormatter(logging.Formatter
124
('Mandos [%(process)d]: %(levelname)s:'
126
logger.addHandler(syslogger)
129
console = logging.StreamHandler()
130
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
134
logger.addHandler(console)
135
logger.setLevel(level)
138
class PGPError(Exception):
139
"""Exception if encryption/decryption fails"""
143
class PGPEngine(object):
144
"""A simple class for OpenPGP symmetric encryption & decryption"""
146
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
147
self.gnupgargs = ['--batch',
148
'--home', self.tempdir,
156
def __exit__(self, exc_type, exc_value, traceback):
164
if self.tempdir is not None:
165
# Delete contents of tempdir
166
for root, dirs, files in os.walk(self.tempdir,
168
for filename in files:
169
os.remove(os.path.join(root, filename))
171
os.rmdir(os.path.join(root, dirname))
173
os.rmdir(self.tempdir)
176
def password_encode(self, password):
177
# Passphrase can not be empty and can not contain newlines or
178
# NUL bytes. So we prefix it and hex encode it.
179
encoded = b"mandos" + binascii.hexlify(password)
180
if len(encoded) > 2048:
181
# GnuPG can't handle long passwords, so encode differently
182
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
183
.replace(b"\n", b"\\n")
184
.replace(b"\0", b"\\x00"))
187
def encrypt(self, data, password):
188
passphrase = self.password_encode(password)
189
with tempfile.NamedTemporaryFile(dir=self.tempdir
191
passfile.write(passphrase)
193
proc = subprocess.Popen(['gpg', '--symmetric',
197
stdin = subprocess.PIPE,
198
stdout = subprocess.PIPE,
199
stderr = subprocess.PIPE)
200
ciphertext, err = proc.communicate(input = data)
201
if proc.returncode != 0:
205
def decrypt(self, data, password):
206
passphrase = self.password_encode(password)
207
with tempfile.NamedTemporaryFile(dir = self.tempdir
209
passfile.write(passphrase)
211
proc = subprocess.Popen(['gpg', '--decrypt',
215
stdin = subprocess.PIPE,
216
stdout = subprocess.PIPE,
217
stderr = subprocess.PIPE)
218
decrypted_plaintext, err = proc.communicate(input
220
if proc.returncode != 0:
222
return decrypted_plaintext
101
225
class AvahiError(Exception):
102
226
def __init__(self, value, *args, **kwargs):
103
227
self.value = value
104
super(AvahiError, self).__init__(value, *args, **kwargs)
105
def __unicode__(self):
106
return unicode(repr(self.value))
228
return super(AvahiError, self).__init__(value, *args,
108
231
class AvahiServiceError(AvahiError):
191
331
dbus.UInt16(self.port),
192
332
avahi.string_array_to_txt_array(self.TXT))
193
333
self.group.Commit()
194
335
def entry_group_state_changed(self, state, error):
195
336
"""Derived from the Avahi example code"""
196
logger.debug(u"Avahi state change: %i", state)
337
logger.debug("Avahi entry group state change: %i", state)
198
339
if state == avahi.ENTRY_GROUP_ESTABLISHED:
199
logger.debug(u"Zeroconf service established.")
340
logger.debug("Zeroconf service established.")
200
341
elif state == avahi.ENTRY_GROUP_COLLISION:
201
logger.warning(u"Zeroconf service name collision.")
342
logger.info("Zeroconf service name collision.")
203
344
elif state == avahi.ENTRY_GROUP_FAILURE:
204
logger.critical(u"Avahi: Error in group state changed %s",
206
raise AvahiGroupError(u"State changed: %s"
345
logger.critical("Avahi: Error in group state changed %s",
347
raise AvahiGroupError("State changed: {!s}"
208
350
def cleanup(self):
209
351
"""Derived from the Avahi example code"""
210
352
if self.group is not None:
355
except (dbus.exceptions.UnknownMethodException,
356
dbus.exceptions.DBusException):
212
358
self.group = None
213
def server_state_changed(self, state):
361
def server_state_changed(self, state, error=None):
214
362
"""Derived from the Avahi example code"""
215
if state == avahi.SERVER_COLLISION:
216
logger.error(u"Zeroconf server name collision")
363
logger.debug("Avahi server state change: %i", state)
364
bad_states = { avahi.SERVER_INVALID:
365
"Zeroconf server invalid",
366
avahi.SERVER_REGISTERING: None,
367
avahi.SERVER_COLLISION:
368
"Zeroconf server name collision",
369
avahi.SERVER_FAILURE:
370
"Zeroconf server failure" }
371
if state in bad_states:
372
if bad_states[state] is not None:
374
logger.error(bad_states[state])
376
logger.error(bad_states[state] + ": %r", error)
218
378
elif state == avahi.SERVER_RUNNING:
382
logger.debug("Unknown state: %r", state)
384
logger.debug("Unknown state: %r: %r", state, error)
220
386
def activate(self):
221
387
"""Derived from the Avahi example code"""
222
388
if self.server is None:
223
389
self.server = dbus.Interface(
224
390
self.bus.get_object(avahi.DBUS_NAME,
225
avahi.DBUS_PATH_SERVER),
391
avahi.DBUS_PATH_SERVER,
392
follow_name_owner_changes=True),
226
393
avahi.DBUS_INTERFACE_SERVER)
227
self.server.connect_to_signal(u"StateChanged",
394
self.server.connect_to_signal("StateChanged",
228
395
self.server_state_changed)
229
396
self.server_state_changed(self.server.GetState())
399
class AvahiServiceToSyslog(AvahiService):
400
def rename(self, *args, **kwargs):
401
"""Add the new name to the syslog messages"""
402
ret = AvahiService.rename(self, *args, **kwargs)
403
syslogger.setFormatter(logging.Formatter
404
('Mandos ({}) [%(process)d]:'
405
' %(levelname)s: %(message)s'
232
410
class Client(object):
233
411
"""A representation of a client host served by this server.
236
name: string; from the config file, used in log messages and
414
approved: bool(); 'None' if not yet approved/disapproved
415
approval_delay: datetime.timedelta(); Time to wait for approval
416
approval_duration: datetime.timedelta(); Duration of one approval
417
checker: subprocess.Popen(); a running checker process used
418
to see if the client lives.
419
'None' if no process is running.
420
checker_callback_tag: a gobject event source tag, or None
421
checker_command: string; External command which is run to check
422
if client lives. %() expansions are done at
423
runtime with vars(self) as dict, so that for
424
instance %(name)s can be used in the command.
425
checker_initiator_tag: a gobject event source tag, or None
426
created: datetime.datetime(); (UTC) object creation
427
client_structure: Object describing what attributes a client has
428
and is used for storing the client at exit
429
current_checker_command: string; current running checker_command
430
disable_initiator_tag: a gobject event source tag, or None
238
432
fingerprint: string (40 or 32 hexadecimal digits); used to
239
433
uniquely identify the client
240
secret: bytestring; sent verbatim (over TLS) to client
241
434
host: string; available for use by the checker command
242
created: datetime.datetime(); (UTC) object creation
243
last_enabled: datetime.datetime(); (UTC)
435
interval: datetime.timedelta(); How often to start a new checker
436
last_approval_request: datetime.datetime(); (UTC) or None
245
437
last_checked_ok: datetime.datetime(); (UTC) or None
438
last_checker_status: integer between 0 and 255 reflecting exit
439
status of last checker. -1 reflects crashed
440
checker, -2 means no checker completed yet.
441
last_enabled: datetime.datetime(); (UTC) or None
442
name: string; from the config file, used in log messages and
444
secret: bytestring; sent verbatim (over TLS) to client
246
445
timeout: datetime.timedelta(); How long from last_checked_ok
247
446
until this client is disabled
248
interval: datetime.timedelta(); How often to start a new checker
249
disable_hook: If set, called by disable() as disable_hook(self)
250
checker: subprocess.Popen(); a running checker process used
251
to see if the client lives.
252
'None' if no process is running.
253
checker_initiator_tag: a gobject event source tag, or None
254
disable_initiator_tag: - '' -
255
checker_callback_tag: - '' -
256
checker_command: string; External command which is run to check if
257
client lives. %() expansions are done at
258
runtime with vars(self) as dict, so that for
259
instance %(name)s can be used in the command.
260
current_checker_command: string; current running checker_command
447
extended_timeout: extra long timeout when secret has been sent
448
runtime_expansions: Allowed attributes for runtime expansion.
449
expires: datetime.datetime(); time (UTC) when a client will be
451
server_settings: The server_settings dict from main()
454
runtime_expansions = ("approval_delay", "approval_duration",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
458
"last_enabled", "name", "timeout")
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
462
"checker": "fping -q -- %%(host)s",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
466
"approved_by_default": "True",
264
def _timedelta_to_milliseconds(td):
265
"Convert a datetime.timedelta() to milliseconds"
266
return ((td.days * 24 * 60 * 60 * 1000)
267
+ (td.seconds * 1000)
268
+ (td.microseconds // 1000))
270
def timeout_milliseconds(self):
271
"Return the 'timeout' attribute in milliseconds"
272
return self._timedelta_to_milliseconds(self.timeout)
274
def interval_milliseconds(self):
275
"Return the 'interval' attribute in milliseconds"
276
return self._timedelta_to_milliseconds(self.interval)
278
def __init__(self, name = None, disable_hook=None, config=None):
279
"""Note: the 'checker' key in 'config' sets the
280
'checker_command' attribute and *not* the 'checker'
471
def config_parser(config):
472
"""Construct a new dict of client settings of this form:
473
{ client_name: {setting_name: value, ...}, ...}
474
with exceptions for any special settings as defined above.
475
NOTE: Must be a pure function. Must return the same result
476
value given the same arguments.
479
for client_name in config.sections():
480
section = dict(config.items(client_name))
481
client = settings[client_name] = {}
483
client["host"] = section["host"]
484
# Reformat values from string types to Python types
485
client["approved_by_default"] = config.getboolean(
486
client_name, "approved_by_default")
487
client["enabled"] = config.getboolean(client_name,
490
client["fingerprint"] = (section["fingerprint"].upper()
492
if "secret" in section:
493
client["secret"] = section["secret"].decode("base64")
494
elif "secfile" in section:
495
with open(os.path.expanduser(os.path.expandvars
496
(section["secfile"])),
498
client["secret"] = secfile.read()
500
raise TypeError("No secret or secfile for section {}"
502
client["timeout"] = string_to_delta(section["timeout"])
503
client["extended_timeout"] = string_to_delta(
504
section["extended_timeout"])
505
client["interval"] = string_to_delta(section["interval"])
506
client["approval_delay"] = string_to_delta(
507
section["approval_delay"])
508
client["approval_duration"] = string_to_delta(
509
section["approval_duration"])
510
client["checker_command"] = section["checker"]
511
client["last_approval_request"] = None
512
client["last_checked_ok"] = None
513
client["last_checker_status"] = -2
517
def __init__(self, settings, name = None, server_settings=None):
285
logger.debug(u"Creating client %r", self.name)
519
if server_settings is None:
521
self.server_settings = server_settings
522
# adding all client settings
523
for setting, value in settings.items():
524
setattr(self, setting, value)
527
if not hasattr(self, "last_enabled"):
528
self.last_enabled = datetime.datetime.utcnow()
529
if not hasattr(self, "expires"):
530
self.expires = (datetime.datetime.utcnow()
533
self.last_enabled = None
536
logger.debug("Creating client %r", self.name)
286
537
# Uppercase and remove spaces from fingerprint for later
287
538
# comparison purposes with return value from the fingerprint()
289
self.fingerprint = (config[u"fingerprint"].upper()
291
logger.debug(u" Fingerprint: %s", self.fingerprint)
292
if u"secret" in config:
293
self.secret = config[u"secret"].decode(u"base64")
294
elif u"secfile" in config:
295
with open(os.path.expanduser(os.path.expandvars
296
(config[u"secfile"])),
298
self.secret = secfile.read()
300
raise TypeError(u"No secret or secfile for client %s"
302
self.host = config.get(u"host", u"")
303
self.created = datetime.datetime.utcnow()
305
self.last_enabled = None
306
self.last_checked_ok = None
307
self.timeout = string_to_delta(config[u"timeout"])
308
self.interval = string_to_delta(config[u"interval"])
309
self.disable_hook = disable_hook
540
logger.debug(" Fingerprint: %s", self.fingerprint)
541
self.created = settings.get("created",
542
datetime.datetime.utcnow())
544
# attributes specific for this server instance
310
545
self.checker = None
311
546
self.checker_initiator_tag = None
312
547
self.disable_initiator_tag = None
313
548
self.checker_callback_tag = None
314
self.checker_command = config[u"checker"]
315
549
self.current_checker_command = None
316
self.last_connect = None
551
self.approvals_pending = 0
552
self.changedstate = (multiprocessing_manager
553
.Condition(multiprocessing_manager
555
self.client_structure = [attr for attr in
556
self.__dict__.iterkeys()
557
if not attr.startswith("_")]
558
self.client_structure.append("client_structure")
560
for name, t in inspect.getmembers(type(self),
564
if not name.startswith("_"):
565
self.client_structure.append(name)
567
# Send notice to process children that client state has changed
568
def send_changedstate(self):
569
with self.changedstate:
570
self.changedstate.notify_all()
318
572
def enable(self):
319
573
"""Start this client's checker and timeout hooks"""
320
if getattr(self, u"enabled", False):
574
if getattr(self, "enabled", False):
321
575
# Already enabled
577
self.expires = datetime.datetime.utcnow() + self.timeout
323
579
self.last_enabled = datetime.datetime.utcnow()
581
self.send_changedstate()
583
def disable(self, quiet=True):
584
"""Disable this client."""
585
if not getattr(self, "enabled", False):
588
logger.info("Disabling client %s", self.name)
589
if getattr(self, "disable_initiator_tag", None) is not None:
590
gobject.source_remove(self.disable_initiator_tag)
591
self.disable_initiator_tag = None
593
if getattr(self, "checker_initiator_tag", None) is not None:
594
gobject.source_remove(self.checker_initiator_tag)
595
self.checker_initiator_tag = None
599
self.send_changedstate()
600
# Do not run this again if called by a gobject.timeout_add
606
def init_checker(self):
324
607
# Schedule a new checker to be started an 'interval' from now,
325
608
# and every interval from then on.
609
if self.checker_initiator_tag is not None:
610
gobject.source_remove(self.checker_initiator_tag)
326
611
self.checker_initiator_tag = (gobject.timeout_add
327
(self.interval_milliseconds(),
613
.total_seconds() * 1000),
328
614
self.start_checker))
329
615
# Schedule a disable() when 'timeout' has passed
616
if self.disable_initiator_tag is not None:
617
gobject.source_remove(self.disable_initiator_tag)
330
618
self.disable_initiator_tag = (gobject.timeout_add
331
(self.timeout_milliseconds(),
620
.total_seconds() * 1000),
334
622
# Also start a new checker *right now*.
335
623
self.start_checker()
337
def disable(self, quiet=True):
338
"""Disable this client."""
339
if not getattr(self, "enabled", False):
342
logger.info(u"Disabling client %s", self.name)
343
if getattr(self, u"disable_initiator_tag", False):
344
gobject.source_remove(self.disable_initiator_tag)
345
self.disable_initiator_tag = None
346
if getattr(self, u"checker_initiator_tag", False):
347
gobject.source_remove(self.checker_initiator_tag)
348
self.checker_initiator_tag = None
350
if self.disable_hook:
351
self.disable_hook(self)
353
# Do not run this again if called by a gobject.timeout_add
357
self.disable_hook = None
360
625
def checker_callback(self, pid, condition, command):
361
626
"""The checker has completed, so take appropriate actions."""
362
627
self.checker_callback_tag = None
363
628
self.checker = None
364
629
if os.WIFEXITED(condition):
365
exitstatus = os.WEXITSTATUS(condition)
367
logger.info(u"Checker for %(name)s succeeded",
630
self.last_checker_status = os.WEXITSTATUS(condition)
631
if self.last_checker_status == 0:
632
logger.info("Checker for %(name)s succeeded",
369
634
self.checked_ok()
371
logger.info(u"Checker for %(name)s failed",
636
logger.info("Checker for %(name)s failed",
374
logger.warning(u"Checker for %(name)s crashed?",
639
self.last_checker_status = -1
640
logger.warning("Checker for %(name)s crashed?",
377
643
def checked_ok(self):
378
"""Bump up the timeout for this client.
380
This should only be called when the client has been seen,
644
"""Assert that the client has been seen, alive and well."""
383
645
self.last_checked_ok = datetime.datetime.utcnow()
384
gobject.source_remove(self.disable_initiator_tag)
385
self.disable_initiator_tag = (gobject.timeout_add
386
(self.timeout_milliseconds(),
646
self.last_checker_status = 0
649
def bump_timeout(self, timeout=None):
650
"""Bump up the timeout for this client."""
652
timeout = self.timeout
653
if self.disable_initiator_tag is not None:
654
gobject.source_remove(self.disable_initiator_tag)
655
self.disable_initiator_tag = None
656
if getattr(self, "enabled", False):
657
self.disable_initiator_tag = (gobject.timeout_add
658
(int(timeout.total_seconds()
659
* 1000), self.disable))
660
self.expires = datetime.datetime.utcnow() + timeout
662
def need_approval(self):
663
self.last_approval_request = datetime.datetime.utcnow()
389
665
def start_checker(self):
390
666
"""Start a new checker subprocess if one is not running.
530
853
class DBusObjectWithProperties(dbus.service.Object):
531
854
"""A D-Bus object with properties.
533
856
Classes inheriting from this can use the dbus_service_property
534
857
decorator to expose methods as D-Bus properties. It exposes the
535
858
standard Get(), Set(), and GetAll() methods on the D-Bus.
539
def _is_dbus_property(obj):
540
return getattr(obj, u"_dbus_is_property", False)
862
def _is_dbus_thing(thing):
863
"""Returns a function testing if an attribute is a D-Bus thing
865
If called like _is_dbus_thing("method") it returns a function
866
suitable for use as predicate to inspect.getmembers().
868
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
542
def _get_all_dbus_properties(self):
871
def _get_all_dbus_things(self, thing):
543
872
"""Returns a generator of (name, attribute) pairs
545
return ((prop._dbus_name, prop)
547
inspect.getmembers(self, self._is_dbus_property))
874
return ((getattr(athing.__get__(self), "_dbus_name",
876
athing.__get__(self))
877
for cls in self.__class__.__mro__
879
inspect.getmembers(cls,
880
self._is_dbus_thing(thing)))
549
882
def _get_dbus_property(self, interface_name, property_name):
550
883
"""Returns a bound method if one exists which is a D-Bus
551
884
property with the specified name and interface.
553
for name in (property_name,
554
property_name + u"_dbus_property"):
555
prop = getattr(self, name, None)
557
or not self._is_dbus_property(prop)
558
or prop._dbus_name != property_name
559
or (interface_name and prop._dbus_interface
560
and interface_name != prop._dbus_interface)):
886
for cls in self.__class__.__mro__:
887
for name, value in (inspect.getmembers
889
self._is_dbus_thing("property"))):
890
if (value._dbus_name == property_name
891
and value._dbus_interface == interface_name):
892
return value.__get__(self)
563
894
# No such property
564
raise DBusPropertyNotFound(self.dbus_object_path + u":"
565
+ interface_name + u"."
895
raise DBusPropertyNotFound(self.dbus_object_path + ":"
896
+ interface_name + "."
568
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
899
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
570
901
def Get(self, interface_name, property_name):
571
902
"""Standard D-Bus property Get() method, see D-Bus standard.
573
904
prop = self._get_dbus_property(interface_name, property_name)
574
if prop._dbus_access == u"write":
905
if prop._dbus_access == "write":
575
906
raise DBusPropertyAccessException(property_name)
577
if not hasattr(value, u"variant_level"):
908
if not hasattr(value, "variant_level"):
579
910
return type(value)(value, variant_level=value.variant_level+1)
581
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
912
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
582
913
def Set(self, interface_name, property_name, value):
583
914
"""Standard D-Bus property Set() method, see D-Bus standard.
585
916
prop = self._get_dbus_property(interface_name, property_name)
586
if prop._dbus_access == u"read":
917
if prop._dbus_access == "read":
587
918
raise DBusPropertyAccessException(property_name)
588
if prop._dbus_get_args_options[u"byte_arrays"]:
919
if prop._dbus_get_args_options["byte_arrays"]:
589
920
# The byte_arrays option is not supported yet on
590
921
# signatures other than "ay".
591
if prop._dbus_signature != u"ay":
593
value = dbus.ByteArray(''.join(unichr(byte)
922
if prop._dbus_signature != "ay":
923
raise ValueError("Byte arrays not supported for non-"
924
"'ay' signature {!r}"
925
.format(prop._dbus_signature))
926
value = dbus.ByteArray(b''.join(chr(byte)
597
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
598
out_signature=u"a{sv}")
930
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
931
out_signature="a{sv}")
599
932
def GetAll(self, interface_name):
600
933
"""Standard D-Bus property GetAll() method, see D-Bus
603
936
Note: Will not include properties with access="write".
606
for name, prop in self._get_all_dbus_properties():
939
for name, prop in self._get_all_dbus_things("property"):
607
940
if (interface_name
608
941
and interface_name != prop._dbus_interface):
609
942
# Interface non-empty but did not match
611
944
# Ignore write-only properties
612
if prop._dbus_access == u"write":
945
if prop._dbus_access == "write":
615
if not hasattr(value, u"variant_level"):
948
if not hasattr(value, "variant_level"):
949
properties[name] = value
618
all[name] = type(value)(value, variant_level=
619
value.variant_level+1)
620
return dbus.Dictionary(all, signature=u"sv")
951
properties[name] = type(value)(value, variant_level=
952
value.variant_level+1)
953
return dbus.Dictionary(properties, signature="sv")
955
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
956
def PropertiesChanged(self, interface_name, changed_properties,
957
invalidated_properties):
958
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
622
963
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
624
965
path_keyword='object_path',
625
966
connection_keyword='connection')
626
967
def Introspect(self, object_path, connection):
627
"""Standard D-Bus method, overloaded to insert property tags.
968
"""Overloading of standard D-Bus method.
970
Inserts property tags and interface annotation tags.
629
972
xmlstring = dbus.service.Object.Introspect(self, object_path,
632
975
document = xml.dom.minidom.parseString(xmlstring)
633
976
def make_tag(document, name, prop):
634
e = document.createElement(u"property")
635
e.setAttribute(u"name", name)
636
e.setAttribute(u"type", prop._dbus_signature)
637
e.setAttribute(u"access", prop._dbus_access)
977
e = document.createElement("property")
978
e.setAttribute("name", name)
979
e.setAttribute("type", prop._dbus_signature)
980
e.setAttribute("access", prop._dbus_access)
639
for if_tag in document.getElementsByTagName(u"interface"):
982
for if_tag in document.getElementsByTagName("interface"):
640
984
for tag in (make_tag(document, name, prop)
642
in self._get_all_dbus_properties()
986
in self._get_all_dbus_things("property")
643
987
if prop._dbus_interface
644
== if_tag.getAttribute(u"name")):
988
== if_tag.getAttribute("name")):
645
989
if_tag.appendChild(tag)
990
# Add annotation tags
991
for typ in ("method", "signal", "property"):
992
for tag in if_tag.getElementsByTagName(typ):
994
for name, prop in (self.
995
_get_all_dbus_things(typ)):
996
if (name == tag.getAttribute("name")
997
and prop._dbus_interface
998
== if_tag.getAttribute("name")):
999
annots.update(getattr
1001
"_dbus_annotations",
1003
for name, value in annots.items():
1004
ann_tag = document.createElement(
1006
ann_tag.setAttribute("name", name)
1007
ann_tag.setAttribute("value", value)
1008
tag.appendChild(ann_tag)
1009
# Add interface annotation tags
1010
for annotation, value in dict(
1011
itertools.chain.from_iterable(
1012
annotations().items()
1013
for name, annotations in
1014
self._get_all_dbus_things("interface")
1015
if name == if_tag.getAttribute("name")
1017
ann_tag = document.createElement("annotation")
1018
ann_tag.setAttribute("name", annotation)
1019
ann_tag.setAttribute("value", value)
1020
if_tag.appendChild(ann_tag)
646
1021
# Add the names to the return values for the
647
1022
# "org.freedesktop.DBus.Properties" methods
648
if (if_tag.getAttribute(u"name")
649
== u"org.freedesktop.DBus.Properties"):
650
for cn in if_tag.getElementsByTagName(u"method"):
651
if cn.getAttribute(u"name") == u"Get":
652
for arg in cn.getElementsByTagName(u"arg"):
653
if (arg.getAttribute(u"direction")
655
arg.setAttribute(u"name", u"value")
656
elif cn.getAttribute(u"name") == u"GetAll":
657
for arg in cn.getElementsByTagName(u"arg"):
658
if (arg.getAttribute(u"direction")
660
arg.setAttribute(u"name", u"props")
661
xmlstring = document.toxml(u"utf-8")
1023
if (if_tag.getAttribute("name")
1024
== "org.freedesktop.DBus.Properties"):
1025
for cn in if_tag.getElementsByTagName("method"):
1026
if cn.getAttribute("name") == "Get":
1027
for arg in cn.getElementsByTagName("arg"):
1028
if (arg.getAttribute("direction")
1030
arg.setAttribute("name", "value")
1031
elif cn.getAttribute("name") == "GetAll":
1032
for arg in cn.getElementsByTagName("arg"):
1033
if (arg.getAttribute("direction")
1035
arg.setAttribute("name", "props")
1036
xmlstring = document.toxml("utf-8")
662
1037
document.unlink()
663
1038
except (AttributeError, xml.dom.DOMException,
664
xml.parsers.expat.ExpatError), error:
665
logger.error(u"Failed to override Introspection method",
1039
xml.parsers.expat.ExpatError) as error:
1040
logger.error("Failed to override Introspection method",
667
1042
return xmlstring
1045
def datetime_to_dbus(dt, variant_level=0):
1046
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1048
return dbus.String("", variant_level = variant_level)
1049
return dbus.String(dt.isoformat(),
1050
variant_level=variant_level)
1053
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1054
"""A class decorator; applied to a subclass of
1055
dbus.service.Object, it will add alternate D-Bus attributes with
1056
interface names according to the "alt_interface_names" mapping.
1059
@alternate_dbus_interfaces({"org.example.Interface":
1060
"net.example.AlternateInterface"})
1061
class SampleDBusObject(dbus.service.Object):
1062
@dbus.service.method("org.example.Interface")
1063
def SampleDBusMethod():
1066
The above "SampleDBusMethod" on "SampleDBusObject" will be
1067
reachable via two interfaces: "org.example.Interface" and
1068
"net.example.AlternateInterface", the latter of which will have
1069
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1070
"true", unless "deprecate" is passed with a False value.
1072
This works for methods and signals, and also for D-Bus properties
1073
(from DBusObjectWithProperties) and interfaces (from the
1074
dbus_interface_annotations decorator).
1077
for orig_interface_name, alt_interface_name in (
1078
alt_interface_names.items()):
1080
interface_names = set()
1081
# Go though all attributes of the class
1082
for attrname, attribute in inspect.getmembers(cls):
1083
# Ignore non-D-Bus attributes, and D-Bus attributes
1084
# with the wrong interface name
1085
if (not hasattr(attribute, "_dbus_interface")
1086
or not attribute._dbus_interface
1087
.startswith(orig_interface_name)):
1089
# Create an alternate D-Bus interface name based on
1091
alt_interface = (attribute._dbus_interface
1092
.replace(orig_interface_name,
1093
alt_interface_name))
1094
interface_names.add(alt_interface)
1095
# Is this a D-Bus signal?
1096
if getattr(attribute, "_dbus_is_signal", False):
1097
# Extract the original non-method undecorated
1098
# function by black magic
1099
nonmethod_func = (dict(
1100
zip(attribute.func_code.co_freevars,
1101
attribute.__closure__))["func"]
1103
# Create a new, but exactly alike, function
1104
# object, and decorate it to be a new D-Bus signal
1105
# with the alternate D-Bus interface name
1106
new_function = (dbus.service.signal
1108
attribute._dbus_signature)
1109
(types.FunctionType(
1110
nonmethod_func.func_code,
1111
nonmethod_func.func_globals,
1112
nonmethod_func.func_name,
1113
nonmethod_func.func_defaults,
1114
nonmethod_func.func_closure)))
1115
# Copy annotations, if any
1117
new_function._dbus_annotations = (
1118
dict(attribute._dbus_annotations))
1119
except AttributeError:
1121
# Define a creator of a function to call both the
1122
# original and alternate functions, so both the
1123
# original and alternate signals gets sent when
1124
# the function is called
1125
def fixscope(func1, func2):
1126
"""This function is a scope container to pass
1127
func1 and func2 to the "call_both" function
1128
outside of its arguments"""
1129
def call_both(*args, **kwargs):
1130
"""This function will emit two D-Bus
1131
signals by calling func1 and func2"""
1132
func1(*args, **kwargs)
1133
func2(*args, **kwargs)
1135
# Create the "call_both" function and add it to
1137
attr[attrname] = fixscope(attribute, new_function)
1138
# Is this a D-Bus method?
1139
elif getattr(attribute, "_dbus_is_method", False):
1140
# Create a new, but exactly alike, function
1141
# object. Decorate it to be a new D-Bus method
1142
# with the alternate D-Bus interface name. Add it
1144
attr[attrname] = (dbus.service.method
1146
attribute._dbus_in_signature,
1147
attribute._dbus_out_signature)
1149
(attribute.func_code,
1150
attribute.func_globals,
1151
attribute.func_name,
1152
attribute.func_defaults,
1153
attribute.func_closure)))
1154
# Copy annotations, if any
1156
attr[attrname]._dbus_annotations = (
1157
dict(attribute._dbus_annotations))
1158
except AttributeError:
1160
# Is this a D-Bus property?
1161
elif getattr(attribute, "_dbus_is_property", False):
1162
# Create a new, but exactly alike, function
1163
# object, and decorate it to be a new D-Bus
1164
# property with the alternate D-Bus interface
1165
# name. Add it to the class.
1166
attr[attrname] = (dbus_service_property
1168
attribute._dbus_signature,
1169
attribute._dbus_access,
1171
._dbus_get_args_options
1174
(attribute.func_code,
1175
attribute.func_globals,
1176
attribute.func_name,
1177
attribute.func_defaults,
1178
attribute.func_closure)))
1179
# Copy annotations, if any
1181
attr[attrname]._dbus_annotations = (
1182
dict(attribute._dbus_annotations))
1183
except AttributeError:
1185
# Is this a D-Bus interface?
1186
elif getattr(attribute, "_dbus_is_interface", False):
1187
# Create a new, but exactly alike, function
1188
# object. Decorate it to be a new D-Bus interface
1189
# with the alternate D-Bus interface name. Add it
1191
attr[attrname] = (dbus_interface_annotations
1194
(attribute.func_code,
1195
attribute.func_globals,
1196
attribute.func_name,
1197
attribute.func_defaults,
1198
attribute.func_closure)))
1200
# Deprecate all alternate interfaces
1201
iname="_AlternateDBusNames_interface_annotation{}"
1202
for interface_name in interface_names:
1203
@dbus_interface_annotations(interface_name)
1205
return { "org.freedesktop.DBus.Deprecated":
1207
# Find an unused name
1208
for aname in (iname.format(i)
1209
for i in itertools.count()):
1210
if aname not in attr:
1214
# Replace the class with a new subclass of it with
1215
# methods, signals, etc. as created above.
1216
cls = type(b"{}Alternate".format(cls.__name__),
1222
@alternate_dbus_interfaces({"se.recompile.Mandos":
1223
"se.bsnet.fukt.Mandos"})
670
1224
class ClientDBus(Client, DBusObjectWithProperties):
671
1225
"""A Client class using D-Bus
681
1241
Client.__init__(self, *args, **kwargs)
682
1242
# Only now, when this client is initialized, can it show up on
1244
client_object_name = str(self.name).translate(
1245
{ord("."): ord("_"),
1246
ord("-"): ord("_")})
684
1247
self.dbus_object_path = (dbus.ObjectPath
686
+ self.name.replace(u".", u"_")))
1248
("/clients/" + client_object_name))
687
1249
DBusObjectWithProperties.__init__(self, self.bus,
688
1250
self.dbus_object_path)
691
def _datetime_to_dbus(dt, variant_level=0):
692
"""Convert a UTC datetime.datetime() to a D-Bus type."""
693
return dbus.String(dt.isoformat(),
694
variant_level=variant_level)
697
oldstate = getattr(self, u"enabled", False)
698
r = Client.enable(self)
699
if oldstate != self.enabled:
701
self.PropertyChanged(dbus.String(u"enabled"),
702
dbus.Boolean(True, variant_level=1))
703
self.PropertyChanged(
704
dbus.String(u"last_enabled"),
705
self._datetime_to_dbus(self.last_enabled,
709
def disable(self, quiet = False):
710
oldstate = getattr(self, u"enabled", False)
711
r = Client.disable(self, quiet=quiet)
712
if not quiet and oldstate != self.enabled:
714
self.PropertyChanged(dbus.String(u"enabled"),
715
dbus.Boolean(False, variant_level=1))
1252
def notifychangeproperty(transform_func,
1253
dbus_name, type_func=lambda x: x,
1254
variant_level=1, invalidate_only=False,
1255
_interface=_interface):
1256
""" Modify a variable so that it's a property which announces
1257
its changes to DBus.
1259
transform_fun: Function that takes a value and a variant_level
1260
and transforms it to a D-Bus type.
1261
dbus_name: D-Bus name of the variable
1262
type_func: Function that transform the value before sending it
1263
to the D-Bus. Default: no transform
1264
variant_level: D-Bus variant level. Default: 1
1266
attrname = "_{}".format(dbus_name)
1267
def setter(self, value):
1268
if hasattr(self, "dbus_object_path"):
1269
if (not hasattr(self, attrname) or
1270
type_func(getattr(self, attrname, None))
1271
!= type_func(value)):
1273
self.PropertiesChanged(_interface,
1278
dbus_value = transform_func(type_func(value),
1281
self.PropertyChanged(dbus.String(dbus_name),
1283
self.PropertiesChanged(_interface,
1285
dbus.String(dbus_name):
1286
dbus_value }), dbus.Array())
1287
setattr(self, attrname, value)
1289
return property(lambda self: getattr(self, attrname), setter)
1291
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1292
approvals_pending = notifychangeproperty(dbus.Boolean,
1295
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1296
last_enabled = notifychangeproperty(datetime_to_dbus,
1298
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1299
type_func = lambda checker:
1300
checker is not None)
1301
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1303
last_checker_status = notifychangeproperty(dbus.Int16,
1304
"LastCheckerStatus")
1305
last_approval_request = notifychangeproperty(
1306
datetime_to_dbus, "LastApprovalRequest")
1307
approved_by_default = notifychangeproperty(dbus.Boolean,
1308
"ApprovedByDefault")
1309
approval_delay = notifychangeproperty(dbus.UInt64,
1312
lambda td: td.total_seconds()
1314
approval_duration = notifychangeproperty(
1315
dbus.UInt64, "ApprovalDuration",
1316
type_func = lambda td: td.total_seconds() * 1000)
1317
host = notifychangeproperty(dbus.String, "Host")
1318
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1319
type_func = lambda td:
1320
td.total_seconds() * 1000)
1321
extended_timeout = notifychangeproperty(
1322
dbus.UInt64, "ExtendedTimeout",
1323
type_func = lambda td: td.total_seconds() * 1000)
1324
interval = notifychangeproperty(dbus.UInt64,
1327
lambda td: td.total_seconds()
1329
checker_command = notifychangeproperty(dbus.String, "Checker")
1330
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1331
invalidate_only=True)
1333
del notifychangeproperty
718
1335
def __del__(self, *args, **kwargs):
720
1337
self.remove_from_connection()
721
1338
except LookupError:
723
if hasattr(DBusObjectWithProperties, u"__del__"):
1340
if hasattr(DBusObjectWithProperties, "__del__"):
724
1341
DBusObjectWithProperties.__del__(self, *args, **kwargs)
725
1342
Client.__del__(self, *args, **kwargs)
895
# last_checked_ok - property
896
@dbus_service_property(_interface, signature=u"s",
898
def last_checked_ok_dbus_property(self, value=None):
1536
# LastCheckedOK - property
1537
@dbus_service_property(_interface, signature="s",
1539
def LastCheckedOK_dbus_property(self, value=None):
899
1540
if value is not None:
900
1541
self.checked_ok()
902
if self.last_checked_ok is None:
903
return dbus.String(u"")
904
return dbus.String(self._datetime_to_dbus(self
908
@dbus_service_property(_interface, signature=u"t",
910
def timeout_dbus_property(self, value=None):
1543
return datetime_to_dbus(self.last_checked_ok)
1545
# LastCheckerStatus - property
1546
@dbus_service_property(_interface, signature="n",
1548
def LastCheckerStatus_dbus_property(self):
1549
return dbus.Int16(self.last_checker_status)
1551
# Expires - property
1552
@dbus_service_property(_interface, signature="s", access="read")
1553
def Expires_dbus_property(self):
1554
return datetime_to_dbus(self.expires)
1556
# LastApprovalRequest - property
1557
@dbus_service_property(_interface, signature="s", access="read")
1558
def LastApprovalRequest_dbus_property(self):
1559
return datetime_to_dbus(self.last_approval_request)
1561
# Timeout - property
1562
@dbus_service_property(_interface, signature="t",
1564
def Timeout_dbus_property(self, value=None):
911
1565
if value is None: # get
912
return dbus.UInt64(self.timeout_milliseconds())
1566
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1567
old_timeout = self.timeout
913
1568
self.timeout = datetime.timedelta(0, 0, 0, value)
915
self.PropertyChanged(dbus.String(u"timeout"),
916
dbus.UInt64(value, variant_level=1))
917
if getattr(self, u"disable_initiator_tag", None) is None:
920
gobject.source_remove(self.disable_initiator_tag)
921
self.disable_initiator_tag = None
923
_timedelta_to_milliseconds((self
929
# The timeout has passed
932
self.disable_initiator_tag = (gobject.timeout_add
933
(time_to_die, self.disable))
935
# interval - property
936
@dbus_service_property(_interface, signature=u"t",
938
def interval_dbus_property(self, value=None):
939
if value is None: # get
940
return dbus.UInt64(self.interval_milliseconds())
1569
# Reschedule disabling
1571
now = datetime.datetime.utcnow()
1572
self.expires += self.timeout - old_timeout
1573
if self.expires <= now:
1574
# The timeout has passed
1577
if (getattr(self, "disable_initiator_tag", None)
1580
gobject.source_remove(self.disable_initiator_tag)
1581
self.disable_initiator_tag = (
1582
gobject.timeout_add(
1583
int((self.expires - now).total_seconds()
1584
* 1000), self.disable))
1586
# ExtendedTimeout - property
1587
@dbus_service_property(_interface, signature="t",
1589
def ExtendedTimeout_dbus_property(self, value=None):
1590
if value is None: # get
1591
return dbus.UInt64(self.extended_timeout.total_seconds()
1593
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1595
# Interval - property
1596
@dbus_service_property(_interface, signature="t",
1598
def Interval_dbus_property(self, value=None):
1599
if value is None: # get
1600
return dbus.UInt64(self.interval.total_seconds() * 1000)
941
1601
self.interval = datetime.timedelta(0, 0, 0, value)
943
self.PropertyChanged(dbus.String(u"interval"),
944
dbus.UInt64(value, variant_level=1))
945
if getattr(self, u"checker_initiator_tag", None) is None:
1602
if getattr(self, "checker_initiator_tag", None) is None:
947
# Reschedule checker run
948
gobject.source_remove(self.checker_initiator_tag)
949
self.checker_initiator_tag = (gobject.timeout_add
950
(value, self.start_checker))
951
self.start_checker() # Start one now, too
954
@dbus_service_property(_interface, signature=u"s",
956
def checker_dbus_property(self, value=None):
1605
# Reschedule checker run
1606
gobject.source_remove(self.checker_initiator_tag)
1607
self.checker_initiator_tag = (gobject.timeout_add
1608
(value, self.start_checker))
1609
self.start_checker() # Start one now, too
1611
# Checker - property
1612
@dbus_service_property(_interface, signature="s",
1614
def Checker_dbus_property(self, value=None):
957
1615
if value is None: # get
958
1616
return dbus.String(self.checker_command)
959
self.checker_command = value
961
self.PropertyChanged(dbus.String(u"checker"),
962
dbus.String(self.checker_command,
1617
self.checker_command = str(value)
965
# checker_running - property
966
@dbus_service_property(_interface, signature=u"b",
968
def checker_running_dbus_property(self, value=None):
1619
# CheckerRunning - property
1620
@dbus_service_property(_interface, signature="b",
1622
def CheckerRunning_dbus_property(self, value=None):
969
1623
if value is None: # get
970
1624
return dbus.Boolean(self.checker is not None)
1027
1705
# Start communication using the Mandos protocol
1028
1706
# Get protocol number
1029
1707
line = self.request.makefile().readline()
1030
logger.debug(u"Protocol version: %r", line)
1708
logger.debug("Protocol version: %r", line)
1032
1710
if int(line.strip().split()[0]) > 1:
1034
except (ValueError, IndexError, RuntimeError), error:
1035
logger.error(u"Unknown protocol version: %s", error)
1711
raise RuntimeError(line)
1712
except (ValueError, IndexError, RuntimeError) as error:
1713
logger.error("Unknown protocol version: %s", error)
1038
1716
# Start GnuTLS connection
1040
1718
session.handshake()
1041
except gnutls.errors.GNUTLSError, error:
1042
logger.warning(u"Handshake failed: %s", error)
1719
except gnutls.errors.GNUTLSError as error:
1720
logger.warning("Handshake failed: %s", error)
1043
1721
# Do not run session.bye() here: the session is not
1044
1722
# established. Just abandon the request.
1046
logger.debug(u"Handshake succeeded")
1724
logger.debug("Handshake succeeded")
1726
approval_required = False
1049
1729
fpr = self.fingerprint(self.peer_certificate
1051
except (TypeError, gnutls.errors.GNUTLSError), error:
1052
logger.warning(u"Bad certificate: %s", error)
1054
logger.debug(u"Fingerprint: %s", fpr)
1056
for c in self.server.clients:
1057
if c.fingerprint == fpr:
1732
gnutls.errors.GNUTLSError) as error:
1733
logger.warning("Bad certificate: %s", error)
1735
logger.debug("Fingerprint: %s", fpr)
1738
client = ProxyClient(child_pipe, fpr,
1739
self.client_address)
1743
if client.approval_delay:
1744
delay = client.approval_delay
1745
client.approvals_pending += 1
1746
approval_required = True
1749
if not client.enabled:
1750
logger.info("Client %s is disabled",
1752
if self.server.use_dbus:
1754
client.Rejected("Disabled")
1757
if client.approved or not client.approval_delay:
1758
#We are approved or approval is disabled
1061
ipc.write(u"NOTFOUND %s %s\n"
1062
% (fpr, unicode(self.client_address)))
1065
class ClientProxy(object):
1066
"""Client proxy object. Not for calling methods."""
1067
def __init__(self, client):
1068
self.client = client
1069
def __getattr__(self, name):
1070
if name.startswith("ipc_"):
1072
ipc.write("%s %s\n" % (name[4:].upper(),
1075
if not hasattr(self.client, name):
1076
raise AttributeError
1077
ipc.write(u"GETATTR %s %s\n"
1078
% (name, self.client.fingerprint))
1079
return pickle.load(ipc_return)
1080
clientproxy = ClientProxy(client)
1081
# Have to check if client.enabled, since it is
1082
# possible that the client was disabled since the
1083
# GnuTLS session was established.
1084
if not clientproxy.enabled:
1085
clientproxy.ipc_disabled()
1088
clientproxy.ipc_sending()
1760
elif client.approved is None:
1761
logger.info("Client %s needs approval",
1763
if self.server.use_dbus:
1765
client.NeedApproval(
1766
client.approval_delay.total_seconds()
1767
* 1000, client.approved_by_default)
1769
logger.warning("Client %s was not approved",
1771
if self.server.use_dbus:
1773
client.Rejected("Denied")
1776
#wait until timeout or approved
1777
time = datetime.datetime.now()
1778
client.changedstate.acquire()
1779
client.changedstate.wait(delay.total_seconds())
1780
client.changedstate.release()
1781
time2 = datetime.datetime.now()
1782
if (time2 - time) >= delay:
1783
if not client.approved_by_default:
1784
logger.warning("Client %s timed out while"
1785
" waiting for approval",
1787
if self.server.use_dbus:
1789
client.Rejected("Approval timed out")
1794
delay -= time2 - time
1090
1797
while sent_size < len(client.secret):
1091
sent = session.send(client.secret[sent_size:])
1092
logger.debug(u"Sent: %d, remaining: %d",
1799
sent = session.send(client.secret[sent_size:])
1800
except gnutls.errors.GNUTLSError as error:
1801
logger.warning("gnutls send failed",
1804
logger.debug("Sent: %d, remaining: %d",
1093
1805
sent, len(client.secret)
1094
1806
- (sent_size + sent))
1095
1807
sent_size += sent
1809
logger.info("Sending secret to %s", client.name)
1810
# bump the timeout using extended_timeout
1811
client.bump_timeout(client.extended_timeout)
1812
if self.server.use_dbus:
1817
if approval_required:
1818
client.approvals_pending -= 1
1821
except gnutls.errors.GNUTLSError as error:
1822
logger.warning("GnuTLS bye failed",
1100
1826
def peer_certificate(session):
1259
2030
def __init__(self, server_address, RequestHandlerClass,
1260
2031
interface=None, use_ipv6=True, clients=None,
1261
gnutls_priority=None, use_dbus=True):
2032
gnutls_priority=None, use_dbus=True, socketfd=None):
1262
2033
self.enabled = False
1263
2034
self.clients = clients
1264
2035
if self.clients is None:
1265
self.clients = set()
1266
2037
self.use_dbus = use_dbus
1267
2038
self.gnutls_priority = gnutls_priority
1268
2039
IPv6_TCPServer.__init__(self, server_address,
1269
2040
RequestHandlerClass,
1270
2041
interface = interface,
1271
use_ipv6 = use_ipv6)
2042
use_ipv6 = use_ipv6,
2043
socketfd = socketfd)
1272
2044
def server_activate(self):
1273
2045
if self.enabled:
1274
2046
return socketserver.TCPServer.server_activate(self)
1275
2048
def enable(self):
1276
2049
self.enabled = True
1277
def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):
2051
def add_pipe(self, parent_pipe, proc):
1278
2052
# Call "handle_ipc" for both data and EOF events
1279
gobject.io_add_watch(child_pipe_fd.fileno(),
2053
gobject.io_add_watch(parent_pipe.fileno(),
1280
2054
gobject.IO_IN | gobject.IO_HUP,
1281
2055
functools.partial(self.handle_ipc,
1282
reply = parent_pipe_fd,
1283
sender= child_pipe_fd))
1284
def handle_ipc(self, source, condition, reply=None, sender=None):
1286
gobject.IO_IN: u"IN", # There is data to read.
1287
gobject.IO_OUT: u"OUT", # Data can be written (without
1289
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1290
gobject.IO_ERR: u"ERR", # Error condition.
1291
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1292
# broken, usually for pipes and
1295
conditions_string = ' | '.join(name
1297
condition_names.iteritems()
1298
if cond & condition)
1299
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1302
# Read a line from the file object
1303
cmdline = sender.readline()
1304
if not cmdline: # Empty line means end of file
1305
# close the IPC pipes
1309
# Stop calling this function
1312
logger.debug(u"IPC command: %r", cmdline)
1314
# Parse and act on command
1315
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1317
if cmd == u"NOTFOUND":
1318
fpr, address = args.split(None, 1)
1319
logger.warning(u"Client not found for fingerprint: %s, ad"
1320
u"dress: %s", fpr, address)
1323
mandos_dbus_service.ClientNotFound(fpr, address)
1324
elif cmd == u"DISABLED":
1325
for client in self.clients:
1326
if client.name == args:
1327
logger.warning(u"Client %s is disabled", args)
1333
logger.error(u"Unknown client %s is disabled", args)
1334
elif cmd == u"SENDING":
1335
for client in self.clients:
1336
if client.name == args:
1337
logger.info(u"Sending secret to %s", client.name)
1344
logger.error(u"Sending secret to unknown client %s",
1346
elif cmd == u"GETATTR":
1347
attr_name, fpr = args.split(None, 1)
1348
for client in self.clients:
1349
if client.fingerprint == fpr:
1350
attr_value = getattr(client, attr_name, None)
1351
logger.debug("IPC reply: %r", attr_value)
1352
pickle.dump(attr_value, reply)
1355
logger.error(u"Client %s on address %s requesting "
1356
u"attribute %s not found", fpr, address,
1358
pickle.dump(None, reply)
2060
def handle_ipc(self, source, condition, parent_pipe=None,
2061
proc = None, client_object=None):
2062
# error, or the other end of multiprocessing.Pipe has closed
2063
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2064
# Wait for other process to exit
2068
# Read a request from the child
2069
request = parent_pipe.recv()
2070
command = request[0]
2072
if command == 'init':
2074
address = request[2]
2076
for c in self.clients.itervalues():
2077
if c.fingerprint == fpr:
2081
logger.info("Client not found for fingerprint: %s, ad"
2082
"dress: %s", fpr, address)
2085
mandos_dbus_service.ClientNotFound(fpr,
2087
parent_pipe.send(False)
2090
gobject.io_add_watch(parent_pipe.fileno(),
2091
gobject.IO_IN | gobject.IO_HUP,
2092
functools.partial(self.handle_ipc,
2098
parent_pipe.send(True)
2099
# remove the old hook in favor of the new above hook on
2102
if command == 'funcall':
2103
funcname = request[1]
2107
parent_pipe.send(('data', getattr(client_object,
2111
if command == 'getattr':
2112
attrname = request[1]
2113
if callable(client_object.__getattribute__(attrname)):
2114
parent_pipe.send(('function',))
2116
parent_pipe.send(('data', client_object
2117
.__getattribute__(attrname)))
2119
if command == 'setattr':
2120
attrname = request[1]
2122
setattr(client_object, attrname, value)
2127
def rfc3339_duration_to_delta(duration):
2128
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2130
>>> rfc3339_duration_to_delta("P7D")
2131
datetime.timedelta(7)
2132
>>> rfc3339_duration_to_delta("PT60S")
2133
datetime.timedelta(0, 60)
2134
>>> rfc3339_duration_to_delta("PT60M")
2135
datetime.timedelta(0, 3600)
2136
>>> rfc3339_duration_to_delta("PT24H")
2137
datetime.timedelta(1)
2138
>>> rfc3339_duration_to_delta("P1W")
2139
datetime.timedelta(7)
2140
>>> rfc3339_duration_to_delta("PT5M30S")
2141
datetime.timedelta(0, 330)
2142
>>> rfc3339_duration_to_delta("P1DT3M20S")
2143
datetime.timedelta(1, 200)
2146
# Parsing an RFC 3339 duration with regular expressions is not
2147
# possible - there would have to be multiple places for the same
2148
# values, like seconds. The current code, while more esoteric, is
2149
# cleaner without depending on a parsing library. If Python had a
2150
# built-in library for parsing we would use it, but we'd like to
2151
# avoid excessive use of external libraries.
2153
# New type for defining tokens, syntax, and semantics all-in-one
2154
Token = collections.namedtuple("Token",
2155
("regexp", # To match token; if
2156
# "value" is not None,
2157
# must have a "group"
2159
"value", # datetime.timedelta or
2161
"followers")) # Tokens valid after
2163
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2164
# the "duration" ABNF definition in RFC 3339, Appendix A.
2165
token_end = Token(re.compile(r"$"), None, frozenset())
2166
token_second = Token(re.compile(r"(\d+)S"),
2167
datetime.timedelta(seconds=1),
2168
frozenset((token_end,)))
2169
token_minute = Token(re.compile(r"(\d+)M"),
2170
datetime.timedelta(minutes=1),
2171
frozenset((token_second, token_end)))
2172
token_hour = Token(re.compile(r"(\d+)H"),
2173
datetime.timedelta(hours=1),
2174
frozenset((token_minute, token_end)))
2175
token_time = Token(re.compile(r"T"),
2177
frozenset((token_hour, token_minute,
2179
token_day = Token(re.compile(r"(\d+)D"),
2180
datetime.timedelta(days=1),
2181
frozenset((token_time, token_end)))
2182
token_month = Token(re.compile(r"(\d+)M"),
2183
datetime.timedelta(weeks=4),
2184
frozenset((token_day, token_end)))
2185
token_year = Token(re.compile(r"(\d+)Y"),
2186
datetime.timedelta(weeks=52),
2187
frozenset((token_month, token_end)))
2188
token_week = Token(re.compile(r"(\d+)W"),
2189
datetime.timedelta(weeks=1),
2190
frozenset((token_end,)))
2191
token_duration = Token(re.compile(r"P"), None,
2192
frozenset((token_year, token_month,
2193
token_day, token_time,
2195
# Define starting values
2196
value = datetime.timedelta() # Value so far
2198
followers = frozenset((token_duration,)) # Following valid tokens
2199
s = duration # String left to parse
2200
# Loop until end token is found
2201
while found_token is not token_end:
2202
# Search for any currently valid tokens
2203
for token in followers:
2204
match = token.regexp.match(s)
2205
if match is not None:
2207
if token.value is not None:
2208
# Value found, parse digits
2209
factor = int(match.group(1), 10)
2210
# Add to value so far
2211
value += factor * token.value
2212
# Strip token from string
2213
s = token.regexp.sub("", s, 1)
2216
# Set valid next tokens
2217
followers = found_token.followers
1360
logger.error(u"Unknown IPC command: %r", cmdline)
1362
# Keep calling this function
2220
# No currently valid tokens were found
2221
raise ValueError("Invalid RFC 3339 duration")
1366
2226
def string_to_delta(interval):
1367
2227
"""Parse a string and return a datetime.timedelta
1369
>>> string_to_delta(u'7d')
2229
>>> string_to_delta('7d')
1370
2230
datetime.timedelta(7)
1371
>>> string_to_delta(u'60s')
2231
>>> string_to_delta('60s')
1372
2232
datetime.timedelta(0, 60)
1373
>>> string_to_delta(u'60m')
2233
>>> string_to_delta('60m')
1374
2234
datetime.timedelta(0, 3600)
1375
>>> string_to_delta(u'24h')
2235
>>> string_to_delta('24h')
1376
2236
datetime.timedelta(1)
1377
>>> string_to_delta(u'1w')
2237
>>> string_to_delta('1w')
1378
2238
datetime.timedelta(7)
1379
>>> string_to_delta(u'5m 30s')
2239
>>> string_to_delta('5m 30s')
1380
2240
datetime.timedelta(0, 330)
2244
return rfc3339_duration_to_delta(interval)
1382
2248
timevalue = datetime.timedelta(0)
1383
2249
for s in interval.split():
1385
suffix = unicode(s[-1])
1386
2252
value = int(s[:-1])
1388
2254
delta = datetime.timedelta(value)
1389
elif suffix == u"s":
1390
2256
delta = datetime.timedelta(0, value)
1391
elif suffix == u"m":
1392
2258
delta = datetime.timedelta(0, 0, 0, 0, value)
1393
elif suffix == u"h":
1394
2260
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1395
elif suffix == u"w":
1396
2262
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1398
raise ValueError(u"Unknown suffix %r" % suffix)
1399
except (ValueError, IndexError), e:
1400
raise ValueError(e.message)
2264
raise ValueError("Unknown suffix {!r}"
2266
except IndexError as e:
2267
raise ValueError(*(e.args))
1401
2268
timevalue += delta
1402
2269
return timevalue
1405
def if_nametoindex(interface):
1406
"""Call the C function if_nametoindex(), or equivalent
1408
Note: This function cannot accept a unicode string."""
1409
global if_nametoindex
1411
if_nametoindex = (ctypes.cdll.LoadLibrary
1412
(ctypes.util.find_library(u"c"))
1414
except (OSError, AttributeError):
1415
logger.warning(u"Doing if_nametoindex the hard way")
1416
def if_nametoindex(interface):
1417
"Get an interface index the hard way, i.e. using fcntl()"
1418
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1419
with contextlib.closing(socket.socket()) as s:
1420
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1421
struct.pack(str(u"16s16x"),
1423
interface_index = struct.unpack(str(u"I"),
1425
return interface_index
1426
return if_nametoindex(interface)
1429
2272
def daemon(nochdir = False, noclose = False):
1430
2273
"""See daemon(3). Standard BSD Unix function.
1456
2298
##################################################################
1457
2299
# Parsing of options, both command line and config file
1459
parser = optparse.OptionParser(version = "%%prog %s" % version)
1460
parser.add_option("-i", u"--interface", type=u"string",
1461
metavar="IF", help=u"Bind to interface IF")
1462
parser.add_option("-a", u"--address", type=u"string",
1463
help=u"Address to listen for requests on")
1464
parser.add_option("-p", u"--port", type=u"int",
1465
help=u"Port number to receive requests on")
1466
parser.add_option("--check", action=u"store_true",
1467
help=u"Run self-test")
1468
parser.add_option("--debug", action=u"store_true",
1469
help=u"Debug mode; run in foreground and log to"
1471
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1472
u" priority string (see GnuTLS documentation)")
1473
parser.add_option("--servicename", type=u"string",
1474
metavar=u"NAME", help=u"Zeroconf service name")
1475
parser.add_option("--configdir", type=u"string",
1476
default=u"/etc/mandos", metavar=u"DIR",
1477
help=u"Directory to search for configuration"
1479
parser.add_option("--no-dbus", action=u"store_false",
1480
dest=u"use_dbus", help=u"Do not provide D-Bus"
1481
u" system bus interface")
1482
parser.add_option("--no-ipv6", action=u"store_false",
1483
dest=u"use_ipv6", help=u"Do not use IPv6")
1484
options = parser.parse_args()[0]
2301
parser = argparse.ArgumentParser()
2302
parser.add_argument("-v", "--version", action="version",
2303
version = "%(prog)s {}".format(version),
2304
help="show version number and exit")
2305
parser.add_argument("-i", "--interface", metavar="IF",
2306
help="Bind to interface IF")
2307
parser.add_argument("-a", "--address",
2308
help="Address to listen for requests on")
2309
parser.add_argument("-p", "--port", type=int,
2310
help="Port number to receive requests on")
2311
parser.add_argument("--check", action="store_true",
2312
help="Run self-test")
2313
parser.add_argument("--debug", action="store_true",
2314
help="Debug mode; run in foreground and log"
2315
" to terminal", default=None)
2316
parser.add_argument("--debuglevel", metavar="LEVEL",
2317
help="Debug level for stdout output")
2318
parser.add_argument("--priority", help="GnuTLS"
2319
" priority string (see GnuTLS documentation)")
2320
parser.add_argument("--servicename",
2321
metavar="NAME", help="Zeroconf service name")
2322
parser.add_argument("--configdir",
2323
default="/etc/mandos", metavar="DIR",
2324
help="Directory to search for configuration"
2326
parser.add_argument("--no-dbus", action="store_false",
2327
dest="use_dbus", help="Do not provide D-Bus"
2328
" system bus interface", default=None)
2329
parser.add_argument("--no-ipv6", action="store_false",
2330
dest="use_ipv6", help="Do not use IPv6",
2332
parser.add_argument("--no-restore", action="store_false",
2333
dest="restore", help="Do not restore stored"
2334
" state", default=None)
2335
parser.add_argument("--socket", type=int,
2336
help="Specify a file descriptor to a network"
2337
" socket to use instead of creating one")
2338
parser.add_argument("--statedir", metavar="DIR",
2339
help="Directory to save/restore state in")
2340
parser.add_argument("--foreground", action="store_true",
2341
help="Run in foreground", default=None)
2342
parser.add_argument("--no-zeroconf", action="store_false",
2343
dest="zeroconf", help="Do not use Zeroconf",
2346
options = parser.parse_args()
1486
2348
if options.check:
2350
fail_count, test_count = doctest.testmod()
2351
sys.exit(os.EX_OK if fail_count == 0 else 1)
1491
2353
# Default values for config file for server-global settings
1492
server_defaults = { u"interface": u"",
1497
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1498
u"servicename": u"Mandos",
1499
u"use_dbus": u"True",
1500
u"use_ipv6": u"True",
2354
server_defaults = { "interface": "",
2359
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2360
"servicename": "Mandos",
2366
"statedir": "/var/lib/mandos",
2367
"foreground": "False",
1503
2371
# Parse config file for server-global settings
1504
2372
server_config = configparser.SafeConfigParser(server_defaults)
1505
2373
del server_defaults
1506
2374
server_config.read(os.path.join(options.configdir,
1508
2376
# Convert the SafeConfigParser object to a dict
1509
2377
server_settings = server_config.defaults()
1510
2378
# Use the appropriate methods on the non-string config options
1511
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1512
server_settings[option] = server_config.getboolean(u"DEFAULT",
2379
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2380
server_settings[option] = server_config.getboolean("DEFAULT",
1514
2382
if server_settings["port"]:
1515
server_settings["port"] = server_config.getint(u"DEFAULT",
2383
server_settings["port"] = server_config.getint("DEFAULT",
2385
if server_settings["socket"]:
2386
server_settings["socket"] = server_config.getint("DEFAULT",
2388
# Later, stdin will, and stdout and stderr might, be dup'ed
2389
# over with an opened os.devnull. But we don't want this to
2390
# happen with a supplied network socket.
2391
if 0 <= server_settings["socket"] <= 2:
2392
server_settings["socket"] = os.dup(server_settings
1517
2394
del server_config
1519
2396
# Override the settings from the config file with command line
1520
2397
# options, if set.
1521
for option in (u"interface", u"address", u"port", u"debug",
1522
u"priority", u"servicename", u"configdir",
1523
u"use_dbus", u"use_ipv6"):
2398
for option in ("interface", "address", "port", "debug",
2399
"priority", "servicename", "configdir",
2400
"use_dbus", "use_ipv6", "debuglevel", "restore",
2401
"statedir", "socket", "foreground", "zeroconf"):
1524
2402
value = getattr(options, option)
1525
2403
if value is not None:
1526
2404
server_settings[option] = value
1528
2406
# Force all strings to be unicode
1529
2407
for option in server_settings.keys():
1530
if type(server_settings[option]) is str:
1531
server_settings[option] = unicode(server_settings[option])
2408
if isinstance(server_settings[option], bytes):
2409
server_settings[option] = (server_settings[option]
2411
# Force all boolean options to be boolean
2412
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2413
"foreground", "zeroconf"):
2414
server_settings[option] = bool(server_settings[option])
2415
# Debug implies foreground
2416
if server_settings["debug"]:
2417
server_settings["foreground"] = True
1532
2418
# Now we have our good server settings in "server_settings"
1534
2420
##################################################################
2422
if (not server_settings["zeroconf"] and
2423
not (server_settings["port"]
2424
or server_settings["socket"] != "")):
2425
parser.error("Needs port or socket to work without"
1536
2428
# For convenience
1537
debug = server_settings[u"debug"]
1538
use_dbus = server_settings[u"use_dbus"]
1539
use_ipv6 = server_settings[u"use_ipv6"]
1542
syslogger.setLevel(logging.WARNING)
1543
console.setLevel(logging.WARNING)
1545
if server_settings[u"servicename"] != u"Mandos":
2429
debug = server_settings["debug"]
2430
debuglevel = server_settings["debuglevel"]
2431
use_dbus = server_settings["use_dbus"]
2432
use_ipv6 = server_settings["use_ipv6"]
2433
stored_state_path = os.path.join(server_settings["statedir"],
2435
foreground = server_settings["foreground"]
2436
zeroconf = server_settings["zeroconf"]
2439
initlogger(debug, logging.DEBUG)
2444
level = getattr(logging, debuglevel.upper())
2445
initlogger(debug, level)
2447
if server_settings["servicename"] != "Mandos":
1546
2448
syslogger.setFormatter(logging.Formatter
1547
(u'Mandos (%s) [%%(process)d]:'
1548
u' %%(levelname)s: %%(message)s'
1549
% server_settings[u"servicename"]))
2449
('Mandos ({}) [%(process)d]:'
2450
' %(levelname)s: %(message)s'
2451
.format(server_settings
1551
2454
# Parse config file with clients
1552
client_defaults = { u"timeout": u"1h",
1554
u"checker": u"fping -q -- %%(host)s",
1557
client_config = configparser.SafeConfigParser(client_defaults)
1558
client_config.read(os.path.join(server_settings[u"configdir"],
2455
client_config = configparser.SafeConfigParser(Client
2457
client_config.read(os.path.join(server_settings["configdir"],
1561
2460
global mandos_dbus_service
1562
2461
mandos_dbus_service = None
1564
tcp_server = MandosServer((server_settings[u"address"],
1565
server_settings[u"port"]),
2464
if server_settings["socket"] != "":
2465
socketfd = server_settings["socket"]
2466
tcp_server = MandosServer((server_settings["address"],
2467
server_settings["port"]),
1567
interface=server_settings[u"interface"],
2469
interface=(server_settings["interface"]
1568
2471
use_ipv6=use_ipv6,
1569
2472
gnutls_priority=
1570
server_settings[u"priority"],
1572
pidfilename = u"/var/run/mandos.pid"
1574
pidfile = open(pidfilename, u"w")
1576
logger.error(u"Could not open file %r", pidfilename)
2473
server_settings["priority"],
2477
pidfilename = "/run/mandos.pid"
2478
if not os.path.isdir("/run/."):
2479
pidfilename = "/var/run/mandos.pid"
2482
pidfile = open(pidfilename, "w")
2483
except IOError as e:
2484
logger.error("Could not open file %r", pidfilename,
1579
uid = pwd.getpwnam(u"_mandos").pw_uid
1580
gid = pwd.getpwnam(u"_mandos").pw_gid
2487
for name in ("_mandos", "mandos", "nobody"):
1583
uid = pwd.getpwnam(u"mandos").pw_uid
1584
gid = pwd.getpwnam(u"mandos").pw_gid
2489
uid = pwd.getpwnam(name).pw_uid
2490
gid = pwd.getpwnam(name).pw_gid
1585
2492
except KeyError:
1587
uid = pwd.getpwnam(u"nobody").pw_uid
1588
gid = pwd.getpwnam(u"nobody").pw_gid
1595
except OSError, error:
1596
if error[0] != errno.EPERM:
2500
except OSError as error:
2501
if error.errno != errno.EPERM:
1599
# Enable all possible GnuTLS debugging
2505
# Enable all possible GnuTLS debugging
1601
2507
# "Use a log level over 10 to enable all debugging options."
1602
2508
# - GnuTLS manual
1603
2509
gnutls.library.functions.gnutls_global_set_log_level(11)
1605
2511
@gnutls.library.types.gnutls_log_func
1606
2512
def debug_gnutls(level, string):
1607
logger.debug(u"GnuTLS: %s", string[:-1])
2513
logger.debug("GnuTLS: %s", string[:-1])
1609
2515
(gnutls.library.functions
1610
2516
.gnutls_global_set_log_function(debug_gnutls))
2518
# Redirect stdin so all checkers get /dev/null
2519
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2520
os.dup2(null, sys.stdin.fileno())
2524
# Need to fork before connecting to D-Bus
2526
# Close all input and output, do double fork, etc.
2529
# multiprocessing will use threads, so before we use gobject we
2530
# need to inform gobject that threads will be used.
2531
gobject.threads_init()
1612
2533
global main_loop
1613
2534
# From the Avahi example code
1614
DBusGMainLoop(set_as_default=True )
2535
DBusGMainLoop(set_as_default=True)
1615
2536
main_loop = gobject.MainLoop()
1616
2537
bus = dbus.SystemBus()
1617
2538
# End of Avahi example code
1620
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
2541
bus_name = dbus.service.BusName("se.recompile.Mandos",
1621
2542
bus, do_not_queue=True)
1622
except dbus.exceptions.NameExistsException, e:
1623
logger.error(unicode(e) + u", disabling D-Bus")
2543
old_bus_name = (dbus.service.BusName
2544
("se.bsnet.fukt.Mandos", bus,
2546
except dbus.exceptions.NameExistsException as e:
2547
logger.error("Disabling D-Bus:", exc_info=e)
1624
2548
use_dbus = False
1625
server_settings[u"use_dbus"] = False
2549
server_settings["use_dbus"] = False
1626
2550
tcp_server.use_dbus = False
1627
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1628
service = AvahiService(name = server_settings[u"servicename"],
1629
servicetype = u"_mandos._tcp",
1630
protocol = protocol, bus = bus)
1631
if server_settings["interface"]:
1632
service.interface = (if_nametoindex
1633
(str(server_settings[u"interface"])))
2552
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2553
service = AvahiServiceToSyslog(name =
2554
server_settings["servicename"],
2555
servicetype = "_mandos._tcp",
2556
protocol = protocol, bus = bus)
2557
if server_settings["interface"]:
2558
service.interface = (if_nametoindex
2559
(server_settings["interface"]
2562
global multiprocessing_manager
2563
multiprocessing_manager = multiprocessing.Manager()
1635
2565
client_class = Client
1637
2567
client_class = functools.partial(ClientDBus, bus = bus)
1638
tcp_server.clients.update(set(
1639
client_class(name = section,
1640
config= dict(client_config.items(section)))
1641
for section in client_config.sections()))
2569
client_settings = Client.config_parser(client_config)
2570
old_client_settings = {}
2573
# This is used to redirect stdout and stderr for checker processes
2575
wnull = open(os.devnull, "w") # A writable /dev/null
2576
# Only used if server is running in foreground but not in debug
2578
if debug or not foreground:
2581
# Get client data and settings from last running state.
2582
if server_settings["restore"]:
2584
with open(stored_state_path, "rb") as stored_state:
2585
clients_data, old_client_settings = (pickle.load
2587
os.remove(stored_state_path)
2588
except IOError as e:
2589
if e.errno == errno.ENOENT:
2590
logger.warning("Could not load persistent state: {}"
2591
.format(os.strerror(e.errno)))
2593
logger.critical("Could not load persistent state:",
2596
except EOFError as e:
2597
logger.warning("Could not load persistent state: "
2598
"EOFError:", exc_info=e)
2600
with PGPEngine() as pgp:
2601
for client_name, client in clients_data.items():
2602
# Skip removed clients
2603
if client_name not in client_settings:
2606
# Decide which value to use after restoring saved state.
2607
# We have three different values: Old config file,
2608
# new config file, and saved state.
2609
# New config value takes precedence if it differs from old
2610
# config value, otherwise use saved state.
2611
for name, value in client_settings[client_name].items():
2613
# For each value in new config, check if it
2614
# differs from the old config value (Except for
2615
# the "secret" attribute)
2616
if (name != "secret" and
2617
value != old_client_settings[client_name]
2619
client[name] = value
2623
# Clients who has passed its expire date can still be
2624
# enabled if its last checker was successful. Clients
2625
# whose checker succeeded before we stored its state is
2626
# assumed to have successfully run all checkers during
2628
if client["enabled"]:
2629
if datetime.datetime.utcnow() >= client["expires"]:
2630
if not client["last_checked_ok"]:
2632
"disabling client {} - Client never "
2633
"performed a successful checker"
2634
.format(client_name))
2635
client["enabled"] = False
2636
elif client["last_checker_status"] != 0:
2638
"disabling client {} - Client last"
2639
" checker failed with error code {}"
2640
.format(client_name,
2641
client["last_checker_status"]))
2642
client["enabled"] = False
2644
client["expires"] = (datetime.datetime
2646
+ client["timeout"])
2647
logger.debug("Last checker succeeded,"
2648
" keeping {} enabled"
2649
.format(client_name))
2651
client["secret"] = (
2652
pgp.decrypt(client["encrypted_secret"],
2653
client_settings[client_name]
2656
# If decryption fails, we use secret from new settings
2657
logger.debug("Failed to decrypt {} old secret"
2658
.format(client_name))
2659
client["secret"] = (
2660
client_settings[client_name]["secret"])
2662
# Add/remove clients based on new changes made to config
2663
for client_name in (set(old_client_settings)
2664
- set(client_settings)):
2665
del clients_data[client_name]
2666
for client_name in (set(client_settings)
2667
- set(old_client_settings)):
2668
clients_data[client_name] = client_settings[client_name]
2670
# Create all client objects
2671
for client_name, client in clients_data.items():
2672
tcp_server.clients[client_name] = client_class(
2673
name = client_name, settings = client,
2674
server_settings = server_settings)
1642
2676
if not tcp_server.clients:
1643
logger.warning(u"No clients defined")
1646
# Redirect stdin so all checkers get /dev/null
1647
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1648
os.dup2(null, sys.stdin.fileno())
1652
# No console logging
1653
logger.removeHandler(console)
1654
# Close all input and output, do double fork, etc.
1660
pidfile.write(str(pid) + "\n")
2677
logger.warning("No clients defined")
2680
if pidfile is not None:
2684
pidfile.write("{}\n".format(pid).encode("utf-8"))
2686
logger.error("Could not write to file %r with PID %d",
1663
logger.error(u"Could not write to file %r with PID %d",
1666
# "pidfile" was never created
1671
signal.signal(signal.SIGINT, signal.SIG_IGN)
1672
2691
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1673
2692
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1676
class MandosDBusService(dbus.service.Object):
2695
@alternate_dbus_interfaces({"se.recompile.Mandos":
2696
"se.bsnet.fukt.Mandos"})
2697
class MandosDBusService(DBusObjectWithProperties):
1677
2698
"""A D-Bus proxy object"""
1678
2699
def __init__(self):
1679
dbus.service.Object.__init__(self, bus, u"/")
1680
_interface = u"se.bsnet.fukt.Mandos"
1682
@dbus.service.signal(_interface, signature=u"o")
2700
dbus.service.Object.__init__(self, bus, "/")
2701
_interface = "se.recompile.Mandos"
2703
@dbus_interface_annotations(_interface)
2705
return { "org.freedesktop.DBus.Property"
2706
".EmitsChangedSignal":
2709
@dbus.service.signal(_interface, signature="o")
1683
2710
def ClientAdded(self, objpath):
1687
@dbus.service.signal(_interface, signature=u"ss")
2714
@dbus.service.signal(_interface, signature="ss")
1688
2715
def ClientNotFound(self, fingerprint, address):
1692
@dbus.service.signal(_interface, signature=u"os")
2719
@dbus.service.signal(_interface, signature="os")
1693
2720
def ClientRemoved(self, objpath, name):
1697
@dbus.service.method(_interface, out_signature=u"ao")
2724
@dbus.service.method(_interface, out_signature="ao")
1698
2725
def GetAllClients(self):
1700
2727
return dbus.Array(c.dbus_object_path
1701
for c in tcp_server.clients)
2729
tcp_server.clients.itervalues())
1703
2731
@dbus.service.method(_interface,
1704
out_signature=u"a{oa{sv}}")
2732
out_signature="a{oa{sv}}")
1705
2733
def GetAllClientsWithProperties(self):
1707
2735
return dbus.Dictionary(
1708
((c.dbus_object_path, c.GetAll(u""))
1709
for c in tcp_server.clients),
1710
signature=u"oa{sv}")
2736
{ c.dbus_object_path: c.GetAll("")
2737
for c in tcp_server.clients.itervalues() },
1712
@dbus.service.method(_interface, in_signature=u"o")
2740
@dbus.service.method(_interface, in_signature="o")
1713
2741
def RemoveClient(self, object_path):
1715
for c in tcp_server.clients:
2743
for c in tcp_server.clients.itervalues():
1716
2744
if c.dbus_object_path == object_path:
1717
tcp_server.clients.remove(c)
2745
del tcp_server.clients[c.name]
1718
2746
c.remove_from_connection()
1719
2747
# Don't signal anything except ClientRemoved
1720
2748
c.disable(quiet=True)
1731
2759
"Cleanup function; run on exit"
2763
multiprocessing.active_children()
2765
if not (tcp_server.clients or client_settings):
2768
# Store client before exiting. Secrets are encrypted with key
2769
# based on what config file has. If config file is
2770
# removed/edited, old secret will thus be unrecovable.
2772
with PGPEngine() as pgp:
2773
for client in tcp_server.clients.itervalues():
2774
key = client_settings[client.name]["secret"]
2775
client.encrypted_secret = pgp.encrypt(client.secret,
2779
# A list of attributes that can not be pickled
2781
exclude = { "bus", "changedstate", "secret",
2782
"checker", "server_settings" }
2783
for name, typ in (inspect.getmembers
2784
(dbus.service.Object)):
2787
client_dict["encrypted_secret"] = (client
2789
for attr in client.client_structure:
2790
if attr not in exclude:
2791
client_dict[attr] = getattr(client, attr)
2793
clients[client.name] = client_dict
2794
del client_settings[client.name]["secret"]
2797
with (tempfile.NamedTemporaryFile
2798
(mode='wb', suffix=".pickle", prefix='clients-',
2799
dir=os.path.dirname(stored_state_path),
2800
delete=False)) as stored_state:
2801
pickle.dump((clients, client_settings), stored_state)
2802
tempname=stored_state.name
2803
os.rename(tempname, stored_state_path)
2804
except (IOError, OSError) as e:
2810
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2811
logger.warning("Could not save persistent state: {}"
2812
.format(os.strerror(e.errno)))
2814
logger.warning("Could not save persistent state:",
2818
# Delete all clients, and settings from config
1734
2819
while tcp_server.clients:
1735
client = tcp_server.clients.pop()
2820
name, client = tcp_server.clients.popitem()
1737
2822
client.remove_from_connection()
1738
client.disable_hook = None
1739
2823
# Don't signal anything except ClientRemoved
1740
2824
client.disable(quiet=True)
1742
2826
# Emit D-Bus signal
1743
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
2827
mandos_dbus_service.ClientRemoved(client
2830
client_settings.clear()
1746
2832
atexit.register(cleanup)
1748
for client in tcp_server.clients:
2834
for client in tcp_server.clients.itervalues():
1750
2836
# Emit D-Bus signal
1751
2837
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2838
# Need to initiate checking of clients
2840
client.init_checker()
1754
2842
tcp_server.enable()
1755
2843
tcp_server.server_activate()
1757
2845
# Find out what port we got
1758
service.port = tcp_server.socket.getsockname()[1]
2847
service.port = tcp_server.socket.getsockname()[1]
1760
logger.info(u"Now listening on address %r, port %d,"
1761
" flowinfo %d, scope_id %d"
1762
% tcp_server.socket.getsockname())
2849
logger.info("Now listening on address %r, port %d,"
2850
" flowinfo %d, scope_id %d",
2851
*tcp_server.socket.getsockname())
1764
logger.info(u"Now listening on address %r, port %d"
1765
% tcp_server.socket.getsockname())
2853
logger.info("Now listening on address %r, port %d",
2854
*tcp_server.socket.getsockname())
1767
2856
#service.interface = tcp_server.socket.getsockname()[3]
1770
# From the Avahi example code
1773
except dbus.exceptions.DBusException, error:
1774
logger.critical(u"DBusException: %s", error)
1777
# End of Avahi example code
2860
# From the Avahi example code
2863
except dbus.exceptions.DBusException as error:
2864
logger.critical("D-Bus Exception", exc_info=error)
2867
# End of Avahi example code
1779
2869
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1780
2870
lambda *args, **kwargs:
1781
2871
(tcp_server.handle_request
1782
2872
(*args[2:], **kwargs) or True))
1784
logger.debug(u"Starting main loop")
2874
logger.debug("Starting main loop")
1785
2875
main_loop.run()
1786
except AvahiError, error:
1787
logger.critical(u"AvahiError: %s", error)
2876
except AvahiError as error:
2877
logger.critical("Avahi Error", exc_info=error)
1790
2880
except KeyboardInterrupt:
1793
logger.debug(u"Server received KeyboardInterrupt")
1794
logger.debug(u"Server exiting")
2882
print("", file=sys.stderr)
2883
logger.debug("Server received KeyboardInterrupt")
2884
logger.debug("Server exiting")
1795
2885
# Must run before the D-Bus bus name gets deregistered