88
78
except ImportError:
89
79
SO_BINDTODEVICE = None
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
84
logger = logging.Logger(u'mandos')
85
syslogger = (logging.handlers.SysLogHandler
86
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
87
address = "/dev/log"))
88
syslogger.setFormatter(logging.Formatter
89
(u'Mandos [%(process)d]: %(levelname)s:'
91
logger.addHandler(syslogger)
93
console = logging.StreamHandler()
94
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
97
logger.addHandler(console)
225
99
class AvahiError(Exception):
226
100
def __init__(self, value, *args, **kwargs):
227
101
self.value = value
228
return super(AvahiError, self).__init__(value, *args,
102
super(AvahiError, self).__init__(value, *args, **kwargs)
103
def __unicode__(self):
104
return unicode(repr(self.value))
231
106
class AvahiServiceError(AvahiError):
325
189
dbus.UInt16(self.port),
326
190
avahi.string_array_to_txt_array(self.TXT))
327
191
self.group.Commit()
329
192
def entry_group_state_changed(self, state, error):
330
193
"""Derived from the Avahi example code"""
331
logger.debug("Avahi entry group state change: %i", state)
194
logger.debug(u"Avahi state change: %i", state)
333
196
if state == avahi.ENTRY_GROUP_ESTABLISHED:
334
logger.debug("Zeroconf service established.")
197
logger.debug(u"Zeroconf service established.")
335
198
elif state == avahi.ENTRY_GROUP_COLLISION:
336
logger.info("Zeroconf service name collision.")
199
logger.warning(u"Zeroconf service name collision.")
338
201
elif state == avahi.ENTRY_GROUP_FAILURE:
339
logger.critical("Avahi: Error in group state changed %s",
341
raise AvahiGroupError("State changed: {!s}"
202
logger.critical(u"Avahi: Error in group state changed %s",
204
raise AvahiGroupError(u"State changed: %s"
344
206
def cleanup(self):
345
207
"""Derived from the Avahi example code"""
346
208
if self.group is not None:
349
except (dbus.exceptions.UnknownMethodException,
350
dbus.exceptions.DBusException):
352
210
self.group = None
355
def server_state_changed(self, state, error=None):
211
def server_state_changed(self, state):
356
212
"""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)
213
if state == avahi.SERVER_COLLISION:
214
logger.error(u"Zeroconf server name collision")
372
216
elif state == avahi.SERVER_RUNNING:
376
logger.debug("Unknown state: %r", state)
378
logger.debug("Unknown state: %r: %r", state, error)
380
218
def activate(self):
381
219
"""Derived from the Avahi example code"""
382
220
if self.server is None:
383
221
self.server = dbus.Interface(
384
222
self.bus.get_object(avahi.DBUS_NAME,
385
avahi.DBUS_PATH_SERVER,
386
follow_name_owner_changes=True),
223
avahi.DBUS_PATH_SERVER),
387
224
avahi.DBUS_INTERFACE_SERVER)
388
self.server.connect_to_signal("StateChanged",
225
self.server.connect_to_signal(u"StateChanged",
389
226
self.server_state_changed)
390
227
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 ({}) [%(process)d]:'
399
' %(levelname)s: %(message)s'
404
230
class Client(object):
405
231
"""A representation of a client host served by this server.
408
approved: bool(); 'None' if not yet approved/disapproved
409
approval_delay: datetime.timedelta(); Time to wait for approval
410
approval_duration: datetime.timedelta(); Duration of one approval
234
name: string; from the config file, used in log messages and
236
fingerprint: string (40 or 32 hexadecimal digits); used to
237
uniquely identify the client
238
secret: bytestring; sent verbatim (over TLS) to client
239
host: string; available for use by the checker command
240
created: datetime.datetime(); (UTC) object creation
241
last_enabled: datetime.datetime(); (UTC)
243
last_checked_ok: datetime.datetime(); (UTC) or None
244
timeout: datetime.timedelta(); How long from last_checked_ok
245
until this client is invalid
246
interval: datetime.timedelta(); How often to start a new checker
247
disable_hook: If set, called by disable() as disable_hook(self)
411
248
checker: subprocess.Popen(); a running checker process used
412
249
to see if the client lives.
413
250
'None' if no process is running.
414
checker_callback_tag: a gobject event source tag, or None
415
checker_command: string; External command which is run to check
416
if client lives. %() expansions are done at
251
checker_initiator_tag: a gobject event source tag, or None
252
disable_initiator_tag: - '' -
253
checker_callback_tag: - '' -
254
checker_command: string; External command which is run to check if
255
client lives. %() expansions are done at
417
256
runtime with vars(self) as dict, so that for
418
257
instance %(name)s can be used in the command.
419
checker_initiator_tag: a gobject event source tag, or None
420
created: datetime.datetime(); (UTC) object creation
421
client_structure: Object describing what attributes a client has
422
and is used for storing the client at exit
423
258
current_checker_command: string; current running checker_command
424
disable_initiator_tag: a gobject event source tag, or None
426
fingerprint: string (40 or 32 hexadecimal digits); used to
427
uniquely identify the client
428
host: string; available for use by the checker command
429
interval: datetime.timedelta(); How often to start a new checker
430
last_approval_request: datetime.datetime(); (UTC) or None
431
last_checked_ok: datetime.datetime(); (UTC) or None
432
last_checker_status: integer between 0 and 255 reflecting exit
433
status of last checker. -1 reflects crashed
434
checker, -2 means no checker completed yet.
435
last_enabled: datetime.datetime(); (UTC) or None
436
name: string; from the config file, used in log messages and
438
secret: bytestring; sent verbatim (over TLS) to client
439
timeout: datetime.timedelta(); How long from last_checked_ok
440
until this client is disabled
441
extended_timeout: extra long timeout when secret has been sent
442
runtime_expansions: Allowed attributes for runtime expansion.
443
expires: datetime.datetime(); time (UTC) when a client will be
445
server_settings: The server_settings dict from main()
448
runtime_expansions = ("approval_delay", "approval_duration",
449
"created", "enabled", "expires",
450
"fingerprint", "host", "interval",
451
"last_approval_request", "last_checked_ok",
452
"last_enabled", "name", "timeout")
453
client_defaults = { "timeout": "PT5M",
454
"extended_timeout": "PT15M",
456
"checker": "fping -q -- %%(host)s",
458
"approval_delay": "PT0S",
459
"approval_duration": "PT1S",
460
"approved_by_default": "True",
465
def config_parser(config):
466
"""Construct a new dict of client settings of this form:
467
{ client_name: {setting_name: value, ...}, ...}
468
with exceptions for any special settings as defined above.
469
NOTE: Must be a pure function. Must return the same result
470
value given the same arguments.
473
for client_name in config.sections():
474
section = dict(config.items(client_name))
475
client = settings[client_name] = {}
477
client["host"] = section["host"]
478
# Reformat values from string types to Python types
479
client["approved_by_default"] = config.getboolean(
480
client_name, "approved_by_default")
481
client["enabled"] = config.getboolean(client_name,
484
client["fingerprint"] = (section["fingerprint"].upper()
486
if "secret" in section:
487
client["secret"] = section["secret"].decode("base64")
488
elif "secfile" in section:
489
with open(os.path.expanduser(os.path.expandvars
490
(section["secfile"])),
492
client["secret"] = secfile.read()
494
raise TypeError("No secret or secfile for section {}"
496
client["timeout"] = string_to_delta(section["timeout"])
497
client["extended_timeout"] = string_to_delta(
498
section["extended_timeout"])
499
client["interval"] = string_to_delta(section["interval"])
500
client["approval_delay"] = string_to_delta(
501
section["approval_delay"])
502
client["approval_duration"] = string_to_delta(
503
section["approval_duration"])
504
client["checker_command"] = section["checker"]
505
client["last_approval_request"] = None
506
client["last_checked_ok"] = None
507
client["last_checker_status"] = -2
511
def __init__(self, settings, name = None, server_settings=None):
262
def _timedelta_to_milliseconds(td):
263
"Convert a datetime.timedelta() to milliseconds"
264
return ((td.days * 24 * 60 * 60 * 1000)
265
+ (td.seconds * 1000)
266
+ (td.microseconds // 1000))
268
def timeout_milliseconds(self):
269
"Return the 'timeout' attribute in milliseconds"
270
return self._timedelta_to_milliseconds(self.timeout)
272
def interval_milliseconds(self):
273
"Return the 'interval' attribute in milliseconds"
274
return self._timedelta_to_milliseconds(self.interval)
276
def __init__(self, name = None, disable_hook=None, config=None):
277
"""Note: the 'checker' key in 'config' sets the
278
'checker_command' attribute and *not* the 'checker'
513
if server_settings is None:
515
self.server_settings = server_settings
516
# adding all client settings
517
for setting, value in settings.items():
518
setattr(self, setting, value)
521
if not hasattr(self, "last_enabled"):
522
self.last_enabled = datetime.datetime.utcnow()
523
if not hasattr(self, "expires"):
524
self.expires = (datetime.datetime.utcnow()
527
self.last_enabled = None
530
logger.debug("Creating client %r", self.name)
283
logger.debug(u"Creating client %r", self.name)
531
284
# Uppercase and remove spaces from fingerprint for later
532
285
# comparison purposes with return value from the fingerprint()
534
logger.debug(" Fingerprint: %s", self.fingerprint)
535
self.created = settings.get("created",
536
datetime.datetime.utcnow())
538
# attributes specific for this server instance
287
self.fingerprint = (config[u"fingerprint"].upper()
289
logger.debug(u" Fingerprint: %s", self.fingerprint)
290
if u"secret" in config:
291
self.secret = config[u"secret"].decode(u"base64")
292
elif u"secfile" in config:
293
with closing(open(os.path.expanduser
295
(config[u"secfile"])),
297
self.secret = secfile.read()
299
raise TypeError(u"No secret or secfile for client %s"
301
self.host = config.get(u"host", u"")
302
self.created = datetime.datetime.utcnow()
304
self.last_enabled = None
305
self.last_checked_ok = None
306
self.timeout = string_to_delta(config[u"timeout"])
307
self.interval = string_to_delta(config[u"interval"])
308
self.disable_hook = disable_hook
539
309
self.checker = None
540
310
self.checker_initiator_tag = None
541
311
self.disable_initiator_tag = None
542
312
self.checker_callback_tag = None
313
self.checker_command = config[u"checker"]
543
314
self.current_checker_command = None
545
self.approvals_pending = 0
546
self.changedstate = (multiprocessing_manager
547
.Condition(multiprocessing_manager
549
self.client_structure = [attr for attr in
550
self.__dict__.iterkeys()
551
if not attr.startswith("_")]
552
self.client_structure.append("client_structure")
554
for name, t in inspect.getmembers(type(self),
558
if not name.startswith("_"):
559
self.client_structure.append(name)
561
# Send notice to process children that client state has changed
562
def send_changedstate(self):
563
with self.changedstate:
564
self.changedstate.notify_all()
315
self.last_connect = None
566
317
def enable(self):
567
318
"""Start this client's checker and timeout hooks"""
568
if getattr(self, "enabled", False):
319
if getattr(self, u"enabled", False):
569
320
# Already enabled
571
self.expires = datetime.datetime.utcnow() + self.timeout
573
322
self.last_enabled = datetime.datetime.utcnow()
575
self.send_changedstate()
323
# Schedule a new checker to be started an 'interval' from now,
324
# and every interval from then on.
325
self.checker_initiator_tag = (gobject.timeout_add
326
(self.interval_milliseconds(),
328
# Schedule a disable() when 'timeout' has passed
329
self.disable_initiator_tag = (gobject.timeout_add
330
(self.timeout_milliseconds(),
333
# Also start a new checker *right now*.
577
336
def disable(self, quiet=True):
578
337
"""Disable this client."""
579
338
if not getattr(self, "enabled", False):
582
logger.info("Disabling client %s", self.name)
583
if getattr(self, "disable_initiator_tag", None) is not None:
341
logger.info(u"Disabling client %s", self.name)
342
if getattr(self, u"disable_initiator_tag", False):
584
343
gobject.source_remove(self.disable_initiator_tag)
585
344
self.disable_initiator_tag = None
587
if getattr(self, "checker_initiator_tag", None) is not None:
345
if getattr(self, u"checker_initiator_tag", False):
588
346
gobject.source_remove(self.checker_initiator_tag)
589
347
self.checker_initiator_tag = None
590
348
self.stop_checker()
349
if self.disable_hook:
350
self.disable_hook(self)
591
351
self.enabled = False
593
self.send_changedstate()
594
352
# Do not run this again if called by a gobject.timeout_add
597
355
def __del__(self):
356
self.disable_hook = None
600
def init_checker(self):
601
# Schedule a new checker to be started an 'interval' from now,
602
# and every interval from then on.
603
if self.checker_initiator_tag is not None:
604
gobject.source_remove(self.checker_initiator_tag)
605
self.checker_initiator_tag = (gobject.timeout_add
607
.total_seconds() * 1000),
609
# Schedule a disable() when 'timeout' has passed
610
if self.disable_initiator_tag is not None:
611
gobject.source_remove(self.disable_initiator_tag)
612
self.disable_initiator_tag = (gobject.timeout_add
614
.total_seconds() * 1000),
616
# Also start a new checker *right now*.
619
359
def checker_callback(self, pid, condition, command):
620
360
"""The checker has completed, so take appropriate actions."""
621
361
self.checker_callback_tag = None
622
362
self.checker = None
623
363
if os.WIFEXITED(condition):
624
self.last_checker_status = os.WEXITSTATUS(condition)
625
if self.last_checker_status == 0:
626
logger.info("Checker for %(name)s succeeded",
364
exitstatus = os.WEXITSTATUS(condition)
366
logger.info(u"Checker for %(name)s succeeded",
628
368
self.checked_ok()
630
logger.info("Checker for %(name)s failed",
370
logger.info(u"Checker for %(name)s failed",
633
self.last_checker_status = -1
634
logger.warning("Checker for %(name)s crashed?",
373
logger.warning(u"Checker for %(name)s crashed?",
637
376
def checked_ok(self):
638
"""Assert that the client has been seen, alive and well."""
377
"""Bump up the timeout for this client.
379
This should only be called when the client has been seen,
639
382
self.last_checked_ok = datetime.datetime.utcnow()
640
self.last_checker_status = 0
643
def bump_timeout(self, timeout=None):
644
"""Bump up the timeout for this client."""
646
timeout = self.timeout
647
if self.disable_initiator_tag is not None:
648
gobject.source_remove(self.disable_initiator_tag)
649
self.disable_initiator_tag = None
650
if getattr(self, "enabled", False):
651
self.disable_initiator_tag = (gobject.timeout_add
652
(int(timeout.total_seconds()
653
* 1000), self.disable))
654
self.expires = datetime.datetime.utcnow() + timeout
656
def need_approval(self):
657
self.last_approval_request = datetime.datetime.utcnow()
383
gobject.source_remove(self.disable_initiator_tag)
384
self.disable_initiator_tag = (gobject.timeout_add
385
(self.timeout_milliseconds(),
659
388
def start_checker(self):
660
389
"""Start a new checker subprocess if one is not running.
662
391
If a checker already exists, leave it running and do
664
393
# The reason for not killing a running checker is that if we
665
# did that, and if a checker (for some reason) started running
666
# slowly and taking more than 'interval' time, then the client
667
# would inevitably timeout, since no checker would get a
668
# chance to run to completion. If we instead leave running
394
# did that, then if a checker (for some reason) started
395
# running slowly and taking more than 'interval' time, the
396
# client would inevitably timeout, since no checker would get
397
# a chance to run to completion. If we instead leave running
669
398
# checkers alone, the checker would have to take more time
670
# than 'timeout' for the client to be disabled, which is as it
399
# than 'timeout' for the client to be declared invalid, which
400
# is as it should be.
673
402
# If a checker exists, make sure it is not a zombie
675
404
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
676
except AttributeError:
678
except OSError as error:
679
if error.errno != errno.ECHILD:
405
except (AttributeError, OSError), error:
406
if (isinstance(error, OSError)
407
and error.errno != errno.ECHILD):
683
logger.warning("Checker was a zombie")
411
logger.warning(u"Checker was a zombie")
684
412
gobject.source_remove(self.checker_callback_tag)
685
413
self.checker_callback(pid, status,
686
414
self.current_checker_command)
687
415
# Start a new checker if needed
688
416
if self.checker is None:
689
# Escape attributes for the shell
690
escaped_attrs = { attr:
691
re.escape(str(getattr(self, attr)))
692
for attr in self.runtime_expansions }
694
command = self.checker_command % escaped_attrs
695
except TypeError as error:
696
logger.error('Could not format string "%s"',
697
self.checker_command, exc_info=error)
698
return True # Try again later
418
# In case checker_command has exactly one % operator
419
command = self.checker_command % self.host
421
# Escape attributes for the shell
422
escaped_attrs = dict((key,
423
re.escape(unicode(str(val),
427
vars(self).iteritems())
429
command = self.checker_command % escaped_attrs
430
except TypeError, error:
431
logger.error(u'Could not format string "%s":'
432
u' %s', self.checker_command, error)
433
return True # Try again later
699
434
self.current_checker_command = command
701
logger.info("Starting checker %r for %s",
436
logger.info(u"Starting checker %r for %s",
702
437
command, self.name)
703
438
# We don't need to redirect stdout and stderr, since
704
439
# in normal mode, that is already done by daemon(),
705
440
# and in debug mode we don't want to. (Stdin is
706
441
# always replaced by /dev/null.)
707
# The exception is when not debugging but nevertheless
708
# running in the foreground; use the previously
711
if (not self.server_settings["debug"]
712
and self.server_settings["foreground"]):
713
popen_args.update({"stdout": wnull,
715
442
self.checker = subprocess.Popen(command,
719
except OSError as error:
720
logger.error("Failed to start subprocess",
723
self.checker_callback_tag = (gobject.child_watch_add
725
self.checker_callback,
727
# The checker may have completed before the gobject
728
# watch was added. Check for this.
444
shell=True, cwd=u"/")
445
self.checker_callback_tag = (gobject.child_watch_add
447
self.checker_callback,
449
# The checker may have completed before the gobject
450
# watch was added. Check for this.
730
451
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
731
except OSError as error:
732
if error.errno == errno.ECHILD:
733
# This should never happen
734
logger.error("Child process vanished",
739
gobject.source_remove(self.checker_callback_tag)
740
self.checker_callback(pid, status, command)
453
gobject.source_remove(self.checker_callback_tag)
454
self.checker_callback(pid, status, command)
455
except OSError, error:
456
logger.error(u"Failed to start subprocess: %s",
741
458
# Re-run this periodically if run by gobject.timeout_add
847
534
class DBusObjectWithProperties(dbus.service.Object):
848
535
"""A D-Bus object with properties.
850
537
Classes inheriting from this can use the dbus_service_property
851
538
decorator to expose methods as D-Bus properties. It exposes the
852
539
standard Get(), Set(), and GetAll() methods on the D-Bus.
856
def _is_dbus_thing(thing):
857
"""Returns a function testing if an attribute is a D-Bus thing
859
If called like _is_dbus_thing("method") it returns a function
860
suitable for use as predicate to inspect.getmembers().
862
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
543
def _is_dbus_property(obj):
544
return getattr(obj, u"_dbus_is_property", False)
865
def _get_all_dbus_things(self, thing):
546
def _get_all_dbus_properties(self):
866
547
"""Returns a generator of (name, attribute) pairs
868
return ((getattr(athing.__get__(self), "_dbus_name",
870
athing.__get__(self))
871
for cls in self.__class__.__mro__
873
inspect.getmembers(cls,
874
self._is_dbus_thing(thing)))
549
return ((prop._dbus_name, prop)
551
inspect.getmembers(self, self._is_dbus_property))
876
553
def _get_dbus_property(self, interface_name, property_name):
877
554
"""Returns a bound method if one exists which is a D-Bus
878
555
property with the specified name and interface.
880
for cls in self.__class__.__mro__:
881
for name, value in (inspect.getmembers
883
self._is_dbus_thing("property"))):
884
if (value._dbus_name == property_name
885
and value._dbus_interface == interface_name):
886
return value.__get__(self)
557
for name in (property_name,
558
property_name + u"_dbus_property"):
559
prop = getattr(self, name, None)
561
or not self._is_dbus_property(prop)
562
or prop._dbus_name != property_name
563
or (interface_name and prop._dbus_interface
564
and interface_name != prop._dbus_interface)):
888
567
# No such property
889
raise DBusPropertyNotFound(self.dbus_object_path + ":"
890
+ interface_name + "."
568
raise DBusPropertyNotFound(self.dbus_object_path + u":"
569
+ interface_name + u"."
893
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
572
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
895
574
def Get(self, interface_name, property_name):
896
575
"""Standard D-Bus property Get() method, see D-Bus standard.
898
577
prop = self._get_dbus_property(interface_name, property_name)
899
if prop._dbus_access == "write":
578
if prop._dbus_access == u"write":
900
579
raise DBusPropertyAccessException(property_name)
902
if not hasattr(value, "variant_level"):
581
if not hasattr(value, u"variant_level"):
904
583
return type(value)(value, variant_level=value.variant_level+1)
906
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
585
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
907
586
def Set(self, interface_name, property_name, value):
908
587
"""Standard D-Bus property Set() method, see D-Bus standard.
910
589
prop = self._get_dbus_property(interface_name, property_name)
911
if prop._dbus_access == "read":
590
if prop._dbus_access == u"read":
912
591
raise DBusPropertyAccessException(property_name)
913
if prop._dbus_get_args_options["byte_arrays"]:
914
# The byte_arrays option is not supported yet on
915
# signatures other than "ay".
916
if prop._dbus_signature != "ay":
917
raise ValueError("Byte arrays not supported for non-"
918
"'ay' signature {!r}"
919
.format(prop._dbus_signature))
920
value = dbus.ByteArray(b''.join(chr(byte)
592
if prop._dbus_get_args_options[u"byte_arrays"]:
593
value = dbus.ByteArray(''.join(unichr(byte)
924
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
925
out_signature="a{sv}")
597
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
598
out_signature=u"a{sv}")
926
599
def GetAll(self, interface_name):
927
600
"""Standard D-Bus property GetAll() method, see D-Bus
930
603
Note: Will not include properties with access="write".
933
for name, prop in self._get_all_dbus_things("property"):
606
for name, prop in self._get_all_dbus_properties():
934
607
if (interface_name
935
608
and interface_name != prop._dbus_interface):
936
609
# Interface non-empty but did not match
938
611
# Ignore write-only properties
939
if prop._dbus_access == "write":
612
if prop._dbus_access == u"write":
942
if not hasattr(value, "variant_level"):
943
properties[name] = value
615
if not hasattr(value, u"variant_level"):
945
properties[name] = type(value)(value, variant_level=
946
value.variant_level+1)
947
return dbus.Dictionary(properties, signature="sv")
949
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
950
def PropertiesChanged(self, interface_name, changed_properties,
951
invalidated_properties):
952
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
618
all[name] = type(value)(value, variant_level=
619
value.variant_level+1)
620
return dbus.Dictionary(all, signature=u"sv")
957
622
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
959
624
path_keyword='object_path',
960
625
connection_keyword='connection')
961
626
def Introspect(self, object_path, connection):
962
"""Overloading of standard D-Bus method.
964
Inserts property tags and interface annotation tags.
627
"""Standard D-Bus method, overloaded to insert property tags.
966
629
xmlstring = dbus.service.Object.Introspect(self, object_path,
969
632
document = xml.dom.minidom.parseString(xmlstring)
970
633
def make_tag(document, name, prop):
971
e = document.createElement("property")
972
e.setAttribute("name", name)
973
e.setAttribute("type", prop._dbus_signature)
974
e.setAttribute("access", prop._dbus_access)
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)
976
for if_tag in document.getElementsByTagName("interface"):
639
for if_tag in document.getElementsByTagName(u"interface"):
978
640
for tag in (make_tag(document, name, prop)
980
in self._get_all_dbus_things("property")
642
in self._get_all_dbus_properties()
981
643
if prop._dbus_interface
982
== if_tag.getAttribute("name")):
644
== if_tag.getAttribute(u"name")):
983
645
if_tag.appendChild(tag)
984
# Add annotation tags
985
for typ in ("method", "signal", "property"):
986
for tag in if_tag.getElementsByTagName(typ):
988
for name, prop in (self.
989
_get_all_dbus_things(typ)):
990
if (name == tag.getAttribute("name")
991
and prop._dbus_interface
992
== if_tag.getAttribute("name")):
993
annots.update(getattr
997
for name, value in annots.items():
998
ann_tag = document.createElement(
1000
ann_tag.setAttribute("name", name)
1001
ann_tag.setAttribute("value", value)
1002
tag.appendChild(ann_tag)
1003
# Add interface annotation tags
1004
for annotation, value in dict(
1005
itertools.chain.from_iterable(
1006
annotations().items()
1007
for name, annotations in
1008
self._get_all_dbus_things("interface")
1009
if name == if_tag.getAttribute("name")
1011
ann_tag = document.createElement("annotation")
1012
ann_tag.setAttribute("name", annotation)
1013
ann_tag.setAttribute("value", value)
1014
if_tag.appendChild(ann_tag)
1015
646
# Add the names to the return values for the
1016
647
# "org.freedesktop.DBus.Properties" methods
1017
if (if_tag.getAttribute("name")
1018
== "org.freedesktop.DBus.Properties"):
1019
for cn in if_tag.getElementsByTagName("method"):
1020
if cn.getAttribute("name") == "Get":
1021
for arg in cn.getElementsByTagName("arg"):
1022
if (arg.getAttribute("direction")
1024
arg.setAttribute("name", "value")
1025
elif cn.getAttribute("name") == "GetAll":
1026
for arg in cn.getElementsByTagName("arg"):
1027
if (arg.getAttribute("direction")
1029
arg.setAttribute("name", "props")
1030
xmlstring = document.toxml("utf-8")
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")
1031
662
document.unlink()
1032
663
except (AttributeError, xml.dom.DOMException,
1033
xml.parsers.expat.ExpatError) as error:
1034
logger.error("Failed to override Introspection method",
664
xml.parsers.expat.ExpatError), error:
665
logger.error(u"Failed to override Introspection method",
1036
667
return xmlstring
1039
def datetime_to_dbus(dt, variant_level=0):
1040
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1042
return dbus.String("", variant_level = variant_level)
1043
return dbus.String(dt.isoformat(),
1044
variant_level=variant_level)
1047
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1048
"""A class decorator; applied to a subclass of
1049
dbus.service.Object, it will add alternate D-Bus attributes with
1050
interface names according to the "alt_interface_names" mapping.
1053
@alternate_dbus_interfaces({"org.example.Interface":
1054
"net.example.AlternateInterface"})
1055
class SampleDBusObject(dbus.service.Object):
1056
@dbus.service.method("org.example.Interface")
1057
def SampleDBusMethod():
1060
The above "SampleDBusMethod" on "SampleDBusObject" will be
1061
reachable via two interfaces: "org.example.Interface" and
1062
"net.example.AlternateInterface", the latter of which will have
1063
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1064
"true", unless "deprecate" is passed with a False value.
1066
This works for methods and signals, and also for D-Bus properties
1067
(from DBusObjectWithProperties) and interfaces (from the
1068
dbus_interface_annotations decorator).
1071
for orig_interface_name, alt_interface_name in (
1072
alt_interface_names.items()):
1074
interface_names = set()
1075
# Go though all attributes of the class
1076
for attrname, attribute in inspect.getmembers(cls):
1077
# Ignore non-D-Bus attributes, and D-Bus attributes
1078
# with the wrong interface name
1079
if (not hasattr(attribute, "_dbus_interface")
1080
or not attribute._dbus_interface
1081
.startswith(orig_interface_name)):
1083
# Create an alternate D-Bus interface name based on
1085
alt_interface = (attribute._dbus_interface
1086
.replace(orig_interface_name,
1087
alt_interface_name))
1088
interface_names.add(alt_interface)
1089
# Is this a D-Bus signal?
1090
if getattr(attribute, "_dbus_is_signal", False):
1091
# Extract the original non-method undecorated
1092
# function by black magic
1093
nonmethod_func = (dict(
1094
zip(attribute.func_code.co_freevars,
1095
attribute.__closure__))["func"]
1097
# Create a new, but exactly alike, function
1098
# object, and decorate it to be a new D-Bus signal
1099
# with the alternate D-Bus interface name
1100
new_function = (dbus.service.signal
1102
attribute._dbus_signature)
1103
(types.FunctionType(
1104
nonmethod_func.func_code,
1105
nonmethod_func.func_globals,
1106
nonmethod_func.func_name,
1107
nonmethod_func.func_defaults,
1108
nonmethod_func.func_closure)))
1109
# Copy annotations, if any
1111
new_function._dbus_annotations = (
1112
dict(attribute._dbus_annotations))
1113
except AttributeError:
1115
# Define a creator of a function to call both the
1116
# original and alternate functions, so both the
1117
# original and alternate signals gets sent when
1118
# the function is called
1119
def fixscope(func1, func2):
1120
"""This function is a scope container to pass
1121
func1 and func2 to the "call_both" function
1122
outside of its arguments"""
1123
def call_both(*args, **kwargs):
1124
"""This function will emit two D-Bus
1125
signals by calling func1 and func2"""
1126
func1(*args, **kwargs)
1127
func2(*args, **kwargs)
1129
# Create the "call_both" function and add it to
1131
attr[attrname] = fixscope(attribute, new_function)
1132
# Is this a D-Bus method?
1133
elif getattr(attribute, "_dbus_is_method", False):
1134
# Create a new, but exactly alike, function
1135
# object. Decorate it to be a new D-Bus method
1136
# with the alternate D-Bus interface name. Add it
1138
attr[attrname] = (dbus.service.method
1140
attribute._dbus_in_signature,
1141
attribute._dbus_out_signature)
1143
(attribute.func_code,
1144
attribute.func_globals,
1145
attribute.func_name,
1146
attribute.func_defaults,
1147
attribute.func_closure)))
1148
# Copy annotations, if any
1150
attr[attrname]._dbus_annotations = (
1151
dict(attribute._dbus_annotations))
1152
except AttributeError:
1154
# Is this a D-Bus property?
1155
elif getattr(attribute, "_dbus_is_property", False):
1156
# Create a new, but exactly alike, function
1157
# object, and decorate it to be a new D-Bus
1158
# property with the alternate D-Bus interface
1159
# name. Add it to the class.
1160
attr[attrname] = (dbus_service_property
1162
attribute._dbus_signature,
1163
attribute._dbus_access,
1165
._dbus_get_args_options
1168
(attribute.func_code,
1169
attribute.func_globals,
1170
attribute.func_name,
1171
attribute.func_defaults,
1172
attribute.func_closure)))
1173
# Copy annotations, if any
1175
attr[attrname]._dbus_annotations = (
1176
dict(attribute._dbus_annotations))
1177
except AttributeError:
1179
# Is this a D-Bus interface?
1180
elif getattr(attribute, "_dbus_is_interface", False):
1181
# Create a new, but exactly alike, function
1182
# object. Decorate it to be a new D-Bus interface
1183
# with the alternate D-Bus interface name. Add it
1185
attr[attrname] = (dbus_interface_annotations
1188
(attribute.func_code,
1189
attribute.func_globals,
1190
attribute.func_name,
1191
attribute.func_defaults,
1192
attribute.func_closure)))
1194
# Deprecate all alternate interfaces
1195
iname="_AlternateDBusNames_interface_annotation{}"
1196
for interface_name in interface_names:
1197
@dbus_interface_annotations(interface_name)
1199
return { "org.freedesktop.DBus.Deprecated":
1201
# Find an unused name
1202
for aname in (iname.format(i)
1203
for i in itertools.count()):
1204
if aname not in attr:
1208
# Replace the class with a new subclass of it with
1209
# methods, signals, etc. as created above.
1210
cls = type(b"{}Alternate".format(cls.__name__),
1216
@alternate_dbus_interfaces({"se.recompile.Mandos":
1217
"se.bsnet.fukt.Mandos"})
1218
670
class ClientDBus(Client, DBusObjectWithProperties):
1219
671
"""A Client class using D-Bus
1235
681
Client.__init__(self, *args, **kwargs)
1236
682
# Only now, when this client is initialized, can it show up on
1238
client_object_name = str(self.name).translate(
1239
{ord("."): ord("_"),
1240
ord("-"): ord("_")})
1241
684
self.dbus_object_path = (dbus.ObjectPath
1242
("/clients/" + client_object_name))
686
+ self.name.replace(u".", u"_")))
1243
687
DBusObjectWithProperties.__init__(self, self.bus,
1244
688
self.dbus_object_path)
1246
def notifychangeproperty(transform_func,
1247
dbus_name, type_func=lambda x: x,
1248
variant_level=1, invalidate_only=False,
1249
_interface=_interface):
1250
""" Modify a variable so that it's a property which announces
1251
its changes to DBus.
1253
transform_fun: Function that takes a value and a variant_level
1254
and transforms it to a D-Bus type.
1255
dbus_name: D-Bus name of the variable
1256
type_func: Function that transform the value before sending it
1257
to the D-Bus. Default: no transform
1258
variant_level: D-Bus variant level. Default: 1
1260
attrname = "_{}".format(dbus_name)
1261
def setter(self, value):
1262
if hasattr(self, "dbus_object_path"):
1263
if (not hasattr(self, attrname) or
1264
type_func(getattr(self, attrname, None))
1265
!= type_func(value)):
1267
self.PropertiesChanged(_interface,
1272
dbus_value = transform_func(type_func(value),
1275
self.PropertyChanged(dbus.String(dbus_name),
1277
self.PropertiesChanged(_interface,
1279
dbus.String(dbus_name):
1280
dbus_value }), dbus.Array())
1281
setattr(self, attrname, value)
1283
return property(lambda self: getattr(self, attrname), setter)
1285
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1286
approvals_pending = notifychangeproperty(dbus.Boolean,
1289
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1290
last_enabled = notifychangeproperty(datetime_to_dbus,
1292
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1293
type_func = lambda checker:
1294
checker is not None)
1295
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1297
last_checker_status = notifychangeproperty(dbus.Int16,
1298
"LastCheckerStatus")
1299
last_approval_request = notifychangeproperty(
1300
datetime_to_dbus, "LastApprovalRequest")
1301
approved_by_default = notifychangeproperty(dbus.Boolean,
1302
"ApprovedByDefault")
1303
approval_delay = notifychangeproperty(dbus.UInt64,
1306
lambda td: td.total_seconds()
1308
approval_duration = notifychangeproperty(
1309
dbus.UInt64, "ApprovalDuration",
1310
type_func = lambda td: td.total_seconds() * 1000)
1311
host = notifychangeproperty(dbus.String, "Host")
1312
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1313
type_func = lambda td:
1314
td.total_seconds() * 1000)
1315
extended_timeout = notifychangeproperty(
1316
dbus.UInt64, "ExtendedTimeout",
1317
type_func = lambda td: td.total_seconds() * 1000)
1318
interval = notifychangeproperty(dbus.UInt64,
1321
lambda td: td.total_seconds()
1323
checker_command = notifychangeproperty(dbus.String, "Checker")
1324
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1325
invalidate_only=True)
1327
del notifychangeproperty
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))
1329
718
def __del__(self, *args, **kwargs):
1331
720
self.remove_from_connection()
1332
721
except LookupError:
1334
if hasattr(DBusObjectWithProperties, "__del__"):
723
if hasattr(DBusObjectWithProperties, u"__del__"):
1335
724
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1336
725
Client.__del__(self, *args, **kwargs)
1530
# LastCheckedOK - property
1531
@dbus_service_property(_interface, signature="s",
1533
def LastCheckedOK_dbus_property(self, value=None):
889
# last_checked_ok - property
890
@dbus_service_property(_interface, signature=u"s",
892
def last_checked_ok_dbus_property(self, value=None):
1534
893
if value is not None:
1535
894
self.checked_ok()
1537
return datetime_to_dbus(self.last_checked_ok)
1539
# LastCheckerStatus - property
1540
@dbus_service_property(_interface, signature="n",
1542
def LastCheckerStatus_dbus_property(self):
1543
return dbus.Int16(self.last_checker_status)
1545
# Expires - property
1546
@dbus_service_property(_interface, signature="s", access="read")
1547
def Expires_dbus_property(self):
1548
return datetime_to_dbus(self.expires)
1550
# LastApprovalRequest - property
1551
@dbus_service_property(_interface, signature="s", access="read")
1552
def LastApprovalRequest_dbus_property(self):
1553
return datetime_to_dbus(self.last_approval_request)
1555
# Timeout - property
1556
@dbus_service_property(_interface, signature="t",
1558
def Timeout_dbus_property(self, value=None):
896
if self.last_checked_ok is None:
897
return dbus.String(u"")
898
return dbus.String(self._datetime_to_dbus(self
902
@dbus_service_property(_interface, signature=u"t",
904
def timeout_dbus_property(self, value=None):
1559
905
if value is None: # get
1560
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1561
old_timeout = self.timeout
906
return dbus.UInt64(self.timeout_milliseconds())
1562
907
self.timeout = datetime.timedelta(0, 0, 0, value)
1563
# Reschedule disabling
1565
now = datetime.datetime.utcnow()
1566
self.expires += self.timeout - old_timeout
1567
if self.expires <= now:
1568
# The timeout has passed
1571
if (getattr(self, "disable_initiator_tag", None)
1574
gobject.source_remove(self.disable_initiator_tag)
1575
self.disable_initiator_tag = (
1576
gobject.timeout_add(
1577
int((self.expires - now).total_seconds()
1578
* 1000), self.disable))
1580
# ExtendedTimeout - property
1581
@dbus_service_property(_interface, signature="t",
1583
def ExtendedTimeout_dbus_property(self, value=None):
1584
if value is None: # get
1585
return dbus.UInt64(self.extended_timeout.total_seconds()
1587
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1589
# Interval - property
1590
@dbus_service_property(_interface, signature="t",
1592
def Interval_dbus_property(self, value=None):
1593
if value is None: # get
1594
return dbus.UInt64(self.interval.total_seconds() * 1000)
909
self.PropertyChanged(dbus.String(u"timeout"),
910
dbus.UInt64(value, variant_level=1))
911
if getattr(self, u"disable_initiator_tag", None) is None:
914
gobject.source_remove(self.disable_initiator_tag)
915
self.disable_initiator_tag = None
917
_timedelta_to_milliseconds((self
923
# The timeout has passed
926
self.disable_initiator_tag = (gobject.timeout_add
927
(time_to_die, self.disable))
929
# interval - property
930
@dbus_service_property(_interface, signature=u"t",
932
def interval_dbus_property(self, value=None):
933
if value is None: # get
934
return dbus.UInt64(self.interval_milliseconds())
1595
935
self.interval = datetime.timedelta(0, 0, 0, value)
1596
if getattr(self, "checker_initiator_tag", None) is None:
937
self.PropertyChanged(dbus.String(u"interval"),
938
dbus.UInt64(value, variant_level=1))
939
if getattr(self, u"checker_initiator_tag", None) is None:
1599
# Reschedule checker run
1600
gobject.source_remove(self.checker_initiator_tag)
1601
self.checker_initiator_tag = (gobject.timeout_add
1602
(value, self.start_checker))
1603
self.start_checker() # Start one now, too
1605
# Checker - property
1606
@dbus_service_property(_interface, signature="s",
1608
def Checker_dbus_property(self, value=None):
941
# Reschedule checker run
942
gobject.source_remove(self.checker_initiator_tag)
943
self.checker_initiator_tag = (gobject.timeout_add
944
(value, self.start_checker))
945
self.start_checker() # Start one now, too
948
@dbus_service_property(_interface, signature=u"s",
950
def checker_dbus_property(self, value=None):
1609
951
if value is None: # get
1610
952
return dbus.String(self.checker_command)
1611
self.checker_command = str(value)
953
self.checker_command = value
955
self.PropertyChanged(dbus.String(u"checker"),
956
dbus.String(self.checker_command,
1613
# CheckerRunning - property
1614
@dbus_service_property(_interface, signature="b",
1616
def CheckerRunning_dbus_property(self, value=None):
959
# checker_running - property
960
@dbus_service_property(_interface, signature=u"b",
962
def checker_running_dbus_property(self, value=None):
1617
963
if value is None: # get
1618
964
return dbus.Boolean(self.checker is not None)
1668
988
Note: This will run in its own forked process."""
1670
990
def handle(self):
1671
with contextlib.closing(self.server.child_pipe) as child_pipe:
1672
logger.info("TCP connection from: %s",
1673
str(self.client_address))
1674
logger.debug("Pipe FD: %d",
1675
self.server.child_pipe.fileno())
991
logger.info(u"TCP connection from: %s",
992
unicode(self.client_address))
993
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
994
# Open IPC pipe to parent process
995
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1677
996
session = (gnutls.connection
1678
997
.ClientSession(self.request,
1679
998
gnutls.connection
1680
999
.X509Credentials()))
1001
line = self.request.makefile().readline()
1002
logger.debug(u"Protocol version: %r", line)
1004
if int(line.strip().split()[0]) > 1:
1006
except (ValueError, IndexError, RuntimeError), error:
1007
logger.error(u"Unknown protocol version: %s", error)
1682
1010
# Note: gnutls.connection.X509Credentials is really a
1683
1011
# generic GnuTLS certificate credentials object so long as
1684
1012
# no X.509 keys are added to it. Therefore, we can use it
1685
1013
# here despite using OpenPGP certificates.
1687
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1688
# "+AES-256-CBC", "+SHA1",
1689
# "+COMP-NULL", "+CTYPE-OPENPGP",
1015
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1016
# u"+AES-256-CBC", u"+SHA1",
1017
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1691
1019
# Use a fallback default, since this MUST be set.
1692
1020
priority = self.server.gnutls_priority
1693
1021
if priority is None:
1022
priority = u"NORMAL"
1695
1023
(gnutls.library.functions
1696
1024
.gnutls_priority_set_direct(session._c_object,
1697
1025
priority, None))
1699
# Start communication using the Mandos protocol
1700
# Get protocol number
1701
line = self.request.makefile().readline()
1702
logger.debug("Protocol version: %r", line)
1704
if int(line.strip().split()[0]) > 1:
1705
raise RuntimeError(line)
1706
except (ValueError, IndexError, RuntimeError) as error:
1707
logger.error("Unknown protocol version: %s", error)
1710
# Start GnuTLS connection
1712
1028
session.handshake()
1713
except gnutls.errors.GNUTLSError as error:
1714
logger.warning("Handshake failed: %s", error)
1029
except gnutls.errors.GNUTLSError, error:
1030
logger.warning(u"Handshake failed: %s", error)
1715
1031
# Do not run session.bye() here: the session is not
1716
1032
# established. Just abandon the request.
1718
logger.debug("Handshake succeeded")
1720
approval_required = False
1034
logger.debug(u"Handshake succeeded")
1723
fpr = self.fingerprint(self.peer_certificate
1726
gnutls.errors.GNUTLSError) as error:
1727
logger.warning("Bad certificate: %s", error)
1729
logger.debug("Fingerprint: %s", fpr)
1732
client = ProxyClient(child_pipe, fpr,
1733
self.client_address)
1737
if client.approval_delay:
1738
delay = client.approval_delay
1739
client.approvals_pending += 1
1740
approval_required = True
1743
if not client.enabled:
1744
logger.info("Client %s is disabled",
1746
if self.server.use_dbus:
1748
client.Rejected("Disabled")
1751
if client.approved or not client.approval_delay:
1752
#We are approved or approval is disabled
1754
elif client.approved is None:
1755
logger.info("Client %s needs approval",
1757
if self.server.use_dbus:
1759
client.NeedApproval(
1760
client.approval_delay.total_seconds()
1761
* 1000, client.approved_by_default)
1763
logger.warning("Client %s was not approved",
1765
if self.server.use_dbus:
1767
client.Rejected("Denied")
1770
#wait until timeout or approved
1771
time = datetime.datetime.now()
1772
client.changedstate.acquire()
1773
client.changedstate.wait(delay.total_seconds())
1774
client.changedstate.release()
1775
time2 = datetime.datetime.now()
1776
if (time2 - time) >= delay:
1777
if not client.approved_by_default:
1778
logger.warning("Client %s timed out while"
1779
" waiting for approval",
1781
if self.server.use_dbus:
1783
client.Rejected("Approval timed out")
1788
delay -= time2 - time
1791
while sent_size < len(client.secret):
1793
sent = session.send(client.secret[sent_size:])
1794
except gnutls.errors.GNUTLSError as error:
1795
logger.warning("gnutls send failed",
1798
logger.debug("Sent: %d, remaining: %d",
1799
sent, len(client.secret)
1800
- (sent_size + sent))
1803
logger.info("Sending secret to %s", client.name)
1804
# bump the timeout using extended_timeout
1805
client.bump_timeout(client.extended_timeout)
1806
if self.server.use_dbus:
1036
fpr = self.fingerprint(self.peer_certificate(session))
1037
except (TypeError, gnutls.errors.GNUTLSError), error:
1038
logger.warning(u"Bad certificate: %s", error)
1041
logger.debug(u"Fingerprint: %s", fpr)
1811
if approval_required:
1812
client.approvals_pending -= 1
1815
except gnutls.errors.GNUTLSError as error:
1816
logger.warning("GnuTLS bye failed",
1043
for c in self.server.clients:
1044
if c.fingerprint == fpr:
1048
ipc.write(u"NOTFOUND %s %s\n"
1049
% (fpr, unicode(self.client_address)))
1052
# Have to check if client.still_valid(), since it is
1053
# possible that the client timed out while establishing
1054
# the GnuTLS session.
1055
if not client.still_valid():
1056
ipc.write(u"INVALID %s\n" % client.name)
1059
ipc.write(u"SENDING %s\n" % client.name)
1061
while sent_size < len(client.secret):
1062
sent = session.send(client.secret[sent_size:])
1063
logger.debug(u"Sent: %d, remaining: %d",
1064
sent, len(client.secret)
1065
- (sent_size + sent))
1820
1070
def peer_certificate(session):
2024
1223
def __init__(self, server_address, RequestHandlerClass,
2025
1224
interface=None, use_ipv6=True, clients=None,
2026
gnutls_priority=None, use_dbus=True, socketfd=None):
1225
gnutls_priority=None, use_dbus=True):
2027
1226
self.enabled = False
2028
1227
self.clients = clients
2029
1228
if self.clients is None:
1229
self.clients = set()
2031
1230
self.use_dbus = use_dbus
2032
1231
self.gnutls_priority = gnutls_priority
2033
1232
IPv6_TCPServer.__init__(self, server_address,
2034
1233
RequestHandlerClass,
2035
1234
interface = interface,
2036
use_ipv6 = use_ipv6,
2037
socketfd = socketfd)
1235
use_ipv6 = use_ipv6)
2038
1236
def server_activate(self):
2039
1237
if self.enabled:
2040
1238
return socketserver.TCPServer.server_activate(self)
2042
1239
def enable(self):
2043
1240
self.enabled = True
2045
def add_pipe(self, parent_pipe, proc):
1241
def add_pipe(self, pipe):
2046
1242
# Call "handle_ipc" for both data and EOF events
2047
gobject.io_add_watch(parent_pipe.fileno(),
2048
gobject.IO_IN | gobject.IO_HUP,
2049
functools.partial(self.handle_ipc,
2054
def handle_ipc(self, source, condition, parent_pipe=None,
2055
proc = None, client_object=None):
2056
# error, or the other end of multiprocessing.Pipe has closed
2057
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2058
# Wait for other process to exit
2062
# Read a request from the child
2063
request = parent_pipe.recv()
2064
command = request[0]
2066
if command == 'init':
2068
address = request[2]
2070
for c in self.clients.itervalues():
2071
if c.fingerprint == fpr:
2075
logger.info("Client not found for fingerprint: %s, ad"
2076
"dress: %s", fpr, address)
2079
mandos_dbus_service.ClientNotFound(fpr,
2081
parent_pipe.send(False)
2084
gobject.io_add_watch(parent_pipe.fileno(),
2085
gobject.IO_IN | gobject.IO_HUP,
2086
functools.partial(self.handle_ipc,
2092
parent_pipe.send(True)
2093
# remove the old hook in favor of the new above hook on
2096
if command == 'funcall':
2097
funcname = request[1]
2101
parent_pipe.send(('data', getattr(client_object,
2105
if command == 'getattr':
2106
attrname = request[1]
2107
if callable(client_object.__getattribute__(attrname)):
2108
parent_pipe.send(('function',))
2110
parent_pipe.send(('data', client_object
2111
.__getattribute__(attrname)))
2113
if command == 'setattr':
2114
attrname = request[1]
2116
setattr(client_object, attrname, value)
1243
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1245
def handle_ipc(self, source, condition, file_objects={}):
1247
gobject.IO_IN: u"IN", # There is data to read.
1248
gobject.IO_OUT: u"OUT", # Data can be written (without
1250
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1251
gobject.IO_ERR: u"ERR", # Error condition.
1252
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1253
# broken, usually for pipes and
1256
conditions_string = ' | '.join(name
1258
condition_names.iteritems()
1259
if cond & condition)
1260
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1263
# Turn the pipe file descriptor into a Python file object
1264
if source not in file_objects:
1265
file_objects[source] = os.fdopen(source, u"r", 1)
1267
# Read a line from the file object
1268
cmdline = file_objects[source].readline()
1269
if not cmdline: # Empty line means end of file
1270
# close the IPC pipe
1271
file_objects[source].close()
1272
del file_objects[source]
1274
# Stop calling this function
1277
logger.debug(u"IPC command: %r", cmdline)
1279
# Parse and act on command
1280
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1282
if cmd == u"NOTFOUND":
1283
logger.warning(u"Client not found for fingerprint: %s",
1287
mandos_dbus_service.ClientNotFound(args)
1288
elif cmd == u"INVALID":
1289
for client in self.clients:
1290
if client.name == args:
1291
logger.warning(u"Client %s is invalid", args)
1297
logger.error(u"Unknown client %s is invalid", args)
1298
elif cmd == u"SENDING":
1299
for client in self.clients:
1300
if client.name == args:
1301
logger.info(u"Sending secret to %s", client.name)
1308
logger.error(u"Sending secret to unknown client %s",
1311
logger.error(u"Unknown IPC command: %r", cmdline)
1313
# Keep calling this function
2121
def rfc3339_duration_to_delta(duration):
2122
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2124
>>> rfc3339_duration_to_delta("P7D")
2125
datetime.timedelta(7)
2126
>>> rfc3339_duration_to_delta("PT60S")
2127
datetime.timedelta(0, 60)
2128
>>> rfc3339_duration_to_delta("PT60M")
2129
datetime.timedelta(0, 3600)
2130
>>> rfc3339_duration_to_delta("PT24H")
2131
datetime.timedelta(1)
2132
>>> rfc3339_duration_to_delta("P1W")
2133
datetime.timedelta(7)
2134
>>> rfc3339_duration_to_delta("PT5M30S")
2135
datetime.timedelta(0, 330)
2136
>>> rfc3339_duration_to_delta("P1DT3M20S")
2137
datetime.timedelta(1, 200)
2140
# Parsing an RFC 3339 duration with regular expressions is not
2141
# possible - there would have to be multiple places for the same
2142
# values, like seconds. The current code, while more esoteric, is
2143
# cleaner without depending on a parsing library. If Python had a
2144
# built-in library for parsing we would use it, but we'd like to
2145
# avoid excessive use of external libraries.
2147
# New type for defining tokens, syntax, and semantics all-in-one
2148
Token = collections.namedtuple("Token",
2149
("regexp", # To match token; if
2150
# "value" is not None,
2151
# must have a "group"
2153
"value", # datetime.timedelta or
2155
"followers")) # Tokens valid after
2157
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2158
# the "duration" ABNF definition in RFC 3339, Appendix A.
2159
token_end = Token(re.compile(r"$"), None, frozenset())
2160
token_second = Token(re.compile(r"(\d+)S"),
2161
datetime.timedelta(seconds=1),
2162
frozenset((token_end,)))
2163
token_minute = Token(re.compile(r"(\d+)M"),
2164
datetime.timedelta(minutes=1),
2165
frozenset((token_second, token_end)))
2166
token_hour = Token(re.compile(r"(\d+)H"),
2167
datetime.timedelta(hours=1),
2168
frozenset((token_minute, token_end)))
2169
token_time = Token(re.compile(r"T"),
2171
frozenset((token_hour, token_minute,
2173
token_day = Token(re.compile(r"(\d+)D"),
2174
datetime.timedelta(days=1),
2175
frozenset((token_time, token_end)))
2176
token_month = Token(re.compile(r"(\d+)M"),
2177
datetime.timedelta(weeks=4),
2178
frozenset((token_day, token_end)))
2179
token_year = Token(re.compile(r"(\d+)Y"),
2180
datetime.timedelta(weeks=52),
2181
frozenset((token_month, token_end)))
2182
token_week = Token(re.compile(r"(\d+)W"),
2183
datetime.timedelta(weeks=1),
2184
frozenset((token_end,)))
2185
token_duration = Token(re.compile(r"P"), None,
2186
frozenset((token_year, token_month,
2187
token_day, token_time,
2189
# Define starting values
2190
value = datetime.timedelta() # Value so far
2192
followers = frozenset((token_duration,)) # Following valid tokens
2193
s = duration # String left to parse
2194
# Loop until end token is found
2195
while found_token is not token_end:
2196
# Search for any currently valid tokens
2197
for token in followers:
2198
match = token.regexp.match(s)
2199
if match is not None:
2201
if token.value is not None:
2202
# Value found, parse digits
2203
factor = int(match.group(1), 10)
2204
# Add to value so far
2205
value += factor * token.value
2206
# Strip token from string
2207
s = token.regexp.sub("", s, 1)
2210
# Set valid next tokens
2211
followers = found_token.followers
2214
# No currently valid tokens were found
2215
raise ValueError("Invalid RFC 3339 duration")
2220
1317
def string_to_delta(interval):
2221
1318
"""Parse a string and return a datetime.timedelta
2223
>>> string_to_delta('7d')
1320
>>> string_to_delta(u'7d')
2224
1321
datetime.timedelta(7)
2225
>>> string_to_delta('60s')
1322
>>> string_to_delta(u'60s')
2226
1323
datetime.timedelta(0, 60)
2227
>>> string_to_delta('60m')
1324
>>> string_to_delta(u'60m')
2228
1325
datetime.timedelta(0, 3600)
2229
>>> string_to_delta('24h')
1326
>>> string_to_delta(u'24h')
2230
1327
datetime.timedelta(1)
2231
>>> string_to_delta('1w')
1328
>>> string_to_delta(u'1w')
2232
1329
datetime.timedelta(7)
2233
>>> string_to_delta('5m 30s')
1330
>>> string_to_delta(u'5m 30s')
2234
1331
datetime.timedelta(0, 330)
2238
return rfc3339_duration_to_delta(interval)
2242
1333
timevalue = datetime.timedelta(0)
2243
1334
for s in interval.split():
1336
suffix = unicode(s[-1])
2246
1337
value = int(s[:-1])
2248
1339
delta = datetime.timedelta(value)
1340
elif suffix == u"s":
2250
1341
delta = datetime.timedelta(0, value)
1342
elif suffix == u"m":
2252
1343
delta = datetime.timedelta(0, 0, 0, 0, value)
1344
elif suffix == u"h":
2254
1345
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1346
elif suffix == u"w":
2256
1347
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2258
raise ValueError("Unknown suffix {!r}"
2260
except IndexError as e:
2261
raise ValueError(*(e.args))
1349
raise ValueError(u"Unknown suffix %r" % suffix)
1350
except (ValueError, IndexError), e:
1351
raise ValueError(e.message)
2262
1352
timevalue += delta
2263
1353
return timevalue
1356
def if_nametoindex(interface):
1357
"""Call the C function if_nametoindex(), or equivalent
1359
Note: This function cannot accept a unicode string."""
1360
global if_nametoindex
1362
if_nametoindex = (ctypes.cdll.LoadLibrary
1363
(ctypes.util.find_library(u"c"))
1365
except (OSError, AttributeError):
1366
logger.warning(u"Doing if_nametoindex the hard way")
1367
def if_nametoindex(interface):
1368
"Get an interface index the hard way, i.e. using fcntl()"
1369
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1370
with closing(socket.socket()) as s:
1371
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1372
struct.pack(str(u"16s16x"),
1374
interface_index = struct.unpack(str(u"I"),
1376
return interface_index
1377
return if_nametoindex(interface)
2266
1380
def daemon(nochdir = False, noclose = False):
2267
1381
"""See daemon(3). Standard BSD Unix function.
2292
1407
##################################################################
2293
1408
# Parsing of options, both command line and config file
2295
parser = argparse.ArgumentParser()
2296
parser.add_argument("-v", "--version", action="version",
2297
version = "%(prog)s {}".format(version),
2298
help="show version number and exit")
2299
parser.add_argument("-i", "--interface", metavar="IF",
2300
help="Bind to interface IF")
2301
parser.add_argument("-a", "--address",
2302
help="Address to listen for requests on")
2303
parser.add_argument("-p", "--port", type=int,
2304
help="Port number to receive requests on")
2305
parser.add_argument("--check", action="store_true",
2306
help="Run self-test")
2307
parser.add_argument("--debug", action="store_true",
2308
help="Debug mode; run in foreground and log"
2309
" to terminal", default=None)
2310
parser.add_argument("--debuglevel", metavar="LEVEL",
2311
help="Debug level for stdout output")
2312
parser.add_argument("--priority", help="GnuTLS"
2313
" priority string (see GnuTLS documentation)")
2314
parser.add_argument("--servicename",
2315
metavar="NAME", help="Zeroconf service name")
2316
parser.add_argument("--configdir",
2317
default="/etc/mandos", metavar="DIR",
2318
help="Directory to search for configuration"
2320
parser.add_argument("--no-dbus", action="store_false",
2321
dest="use_dbus", help="Do not provide D-Bus"
2322
" system bus interface", default=None)
2323
parser.add_argument("--no-ipv6", action="store_false",
2324
dest="use_ipv6", help="Do not use IPv6",
2326
parser.add_argument("--no-restore", action="store_false",
2327
dest="restore", help="Do not restore stored"
2328
" state", default=None)
2329
parser.add_argument("--socket", type=int,
2330
help="Specify a file descriptor to a network"
2331
" socket to use instead of creating one")
2332
parser.add_argument("--statedir", metavar="DIR",
2333
help="Directory to save/restore state in")
2334
parser.add_argument("--foreground", action="store_true",
2335
help="Run in foreground", default=None)
2336
parser.add_argument("--no-zeroconf", action="store_false",
2337
dest="zeroconf", help="Do not use Zeroconf",
2340
options = parser.parse_args()
1410
parser = optparse.OptionParser(version = "%%prog %s" % version)
1411
parser.add_option("-i", u"--interface", type=u"string",
1412
metavar="IF", help=u"Bind to interface IF")
1413
parser.add_option("-a", u"--address", type=u"string",
1414
help=u"Address to listen for requests on")
1415
parser.add_option("-p", u"--port", type=u"int",
1416
help=u"Port number to receive requests on")
1417
parser.add_option("--check", action=u"store_true",
1418
help=u"Run self-test")
1419
parser.add_option("--debug", action=u"store_true",
1420
help=u"Debug mode; run in foreground and log to"
1422
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1423
u" priority string (see GnuTLS documentation)")
1424
parser.add_option("--servicename", type=u"string",
1425
metavar=u"NAME", help=u"Zeroconf service name")
1426
parser.add_option("--configdir", type=u"string",
1427
default=u"/etc/mandos", metavar=u"DIR",
1428
help=u"Directory to search for configuration"
1430
parser.add_option("--no-dbus", action=u"store_false",
1431
dest=u"use_dbus", help=u"Do not provide D-Bus"
1432
u" system bus interface")
1433
parser.add_option("--no-ipv6", action=u"store_false",
1434
dest=u"use_ipv6", help=u"Do not use IPv6")
1435
options = parser.parse_args()[0]
2342
1437
if options.check:
2344
fail_count, test_count = doctest.testmod()
2345
sys.exit(os.EX_OK if fail_count == 0 else 1)
2347
1442
# Default values for config file for server-global settings
2348
server_defaults = { "interface": "",
2353
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2354
"servicename": "Mandos",
2360
"statedir": "/var/lib/mandos",
2361
"foreground": "False",
1443
server_defaults = { u"interface": u"",
1448
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1449
u"servicename": u"Mandos",
1450
u"use_dbus": u"True",
1451
u"use_ipv6": u"True",
2365
1454
# Parse config file for server-global settings
2366
1455
server_config = configparser.SafeConfigParser(server_defaults)
2367
1456
del server_defaults
2368
1457
server_config.read(os.path.join(options.configdir,
2370
1459
# Convert the SafeConfigParser object to a dict
2371
1460
server_settings = server_config.defaults()
2372
1461
# Use the appropriate methods on the non-string config options
2373
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2374
server_settings[option] = server_config.getboolean("DEFAULT",
1462
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1463
server_settings[option] = server_config.getboolean(u"DEFAULT",
2376
1465
if server_settings["port"]:
2377
server_settings["port"] = server_config.getint("DEFAULT",
2379
if server_settings["socket"]:
2380
server_settings["socket"] = server_config.getint("DEFAULT",
2382
# Later, stdin will, and stdout and stderr might, be dup'ed
2383
# over with an opened os.devnull. But we don't want this to
2384
# happen with a supplied network socket.
2385
if 0 <= server_settings["socket"] <= 2:
2386
server_settings["socket"] = os.dup(server_settings
1466
server_settings["port"] = server_config.getint(u"DEFAULT",
2388
1468
del server_config
2390
1470
# Override the settings from the config file with command line
2391
1471
# options, if set.
2392
for option in ("interface", "address", "port", "debug",
2393
"priority", "servicename", "configdir",
2394
"use_dbus", "use_ipv6", "debuglevel", "restore",
2395
"statedir", "socket", "foreground", "zeroconf"):
1472
for option in (u"interface", u"address", u"port", u"debug",
1473
u"priority", u"servicename", u"configdir",
1474
u"use_dbus", u"use_ipv6"):
2396
1475
value = getattr(options, option)
2397
1476
if value is not None:
2398
1477
server_settings[option] = value
2400
1479
# Force all strings to be unicode
2401
1480
for option in server_settings.keys():
2402
if isinstance(server_settings[option], bytes):
2403
server_settings[option] = (server_settings[option]
2405
# Force all boolean options to be boolean
2406
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2407
"foreground", "zeroconf"):
2408
server_settings[option] = bool(server_settings[option])
2409
# Debug implies foreground
2410
if server_settings["debug"]:
2411
server_settings["foreground"] = True
1481
if type(server_settings[option]) is str:
1482
server_settings[option] = unicode(server_settings[option])
2412
1483
# Now we have our good server settings in "server_settings"
2414
1485
##################################################################
2416
if (not server_settings["zeroconf"] and
2417
not (server_settings["port"]
2418
or server_settings["socket"] != "")):
2419
parser.error("Needs port or socket to work without"
2422
1487
# For convenience
2423
debug = server_settings["debug"]
2424
debuglevel = server_settings["debuglevel"]
2425
use_dbus = server_settings["use_dbus"]
2426
use_ipv6 = server_settings["use_ipv6"]
2427
stored_state_path = os.path.join(server_settings["statedir"],
2429
foreground = server_settings["foreground"]
2430
zeroconf = server_settings["zeroconf"]
2433
initlogger(debug, logging.DEBUG)
2438
level = getattr(logging, debuglevel.upper())
2439
initlogger(debug, level)
2441
if server_settings["servicename"] != "Mandos":
1488
debug = server_settings[u"debug"]
1489
use_dbus = server_settings[u"use_dbus"]
1490
use_ipv6 = server_settings[u"use_ipv6"]
1493
syslogger.setLevel(logging.WARNING)
1494
console.setLevel(logging.WARNING)
1496
if server_settings[u"servicename"] != u"Mandos":
2442
1497
syslogger.setFormatter(logging.Formatter
2443
('Mandos ({}) [%(process)d]:'
2444
' %(levelname)s: %(message)s'
2445
.format(server_settings
1498
(u'Mandos (%s) [%%(process)d]:'
1499
u' %%(levelname)s: %%(message)s'
1500
% server_settings[u"servicename"]))
2448
1502
# Parse config file with clients
2449
client_config = configparser.SafeConfigParser(Client
2451
client_config.read(os.path.join(server_settings["configdir"],
1503
client_defaults = { u"timeout": u"1h",
1505
u"checker": u"fping -q -- %%(host)s",
1508
client_config = configparser.SafeConfigParser(client_defaults)
1509
client_config.read(os.path.join(server_settings[u"configdir"],
2454
1512
global mandos_dbus_service
2455
1513
mandos_dbus_service = None
2458
if server_settings["socket"] != "":
2459
socketfd = server_settings["socket"]
2460
tcp_server = MandosServer((server_settings["address"],
2461
server_settings["port"]),
1515
tcp_server = MandosServer((server_settings[u"address"],
1516
server_settings[u"port"]),
2463
interface=(server_settings["interface"]
1518
interface=server_settings[u"interface"],
2465
1519
use_ipv6=use_ipv6,
2466
1520
gnutls_priority=
2467
server_settings["priority"],
2471
pidfilename = "/run/mandos.pid"
2472
if not os.path.isdir("/run/."):
2473
pidfilename = "/var/run/mandos.pid"
2476
pidfile = open(pidfilename, "w")
2477
except IOError as e:
2478
logger.error("Could not open file %r", pidfilename,
1521
server_settings[u"priority"],
1523
pidfilename = u"/var/run/mandos.pid"
1525
pidfile = open(pidfilename, u"w")
1527
logger.error(u"Could not open file %r", pidfilename)
2481
for name in ("_mandos", "mandos", "nobody"):
1530
uid = pwd.getpwnam(u"_mandos").pw_uid
1531
gid = pwd.getpwnam(u"_mandos").pw_gid
2483
uid = pwd.getpwnam(name).pw_uid
2484
gid = pwd.getpwnam(name).pw_gid
1534
uid = pwd.getpwnam(u"mandos").pw_uid
1535
gid = pwd.getpwnam(u"mandos").pw_gid
2486
1536
except KeyError:
1538
uid = pwd.getpwnam(u"nobody").pw_uid
1539
gid = pwd.getpwnam(u"nobody").pw_gid
2494
except OSError as error:
2495
if error.errno != errno.EPERM:
1546
except OSError, error:
1547
if error[0] != errno.EPERM:
1550
# Enable all possible GnuTLS debugging
2499
# Enable all possible GnuTLS debugging
2501
1552
# "Use a log level over 10 to enable all debugging options."
2502
1553
# - GnuTLS manual
2503
1554
gnutls.library.functions.gnutls_global_set_log_level(11)
2505
1556
@gnutls.library.types.gnutls_log_func
2506
1557
def debug_gnutls(level, string):
2507
logger.debug("GnuTLS: %s", string[:-1])
1558
logger.debug(u"GnuTLS: %s", string[:-1])
2509
1560
(gnutls.library.functions
2510
1561
.gnutls_global_set_log_function(debug_gnutls))
2512
# Redirect stdin so all checkers get /dev/null
2513
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2514
os.dup2(null, sys.stdin.fileno())
2518
# Need to fork before connecting to D-Bus
2520
# Close all input and output, do double fork, etc.
2523
# multiprocessing will use threads, so before we use gobject we
2524
# need to inform gobject that threads will be used.
2525
gobject.threads_init()
2527
1563
global main_loop
2528
1564
# From the Avahi example code
2529
DBusGMainLoop(set_as_default=True)
1565
DBusGMainLoop(set_as_default=True )
2530
1566
main_loop = gobject.MainLoop()
2531
1567
bus = dbus.SystemBus()
2532
1568
# End of Avahi example code
2535
bus_name = dbus.service.BusName("se.recompile.Mandos",
1571
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
2536
1572
bus, do_not_queue=True)
2537
old_bus_name = (dbus.service.BusName
2538
("se.bsnet.fukt.Mandos", bus,
2540
except dbus.exceptions.NameExistsException as e:
2541
logger.error("Disabling D-Bus:", exc_info=e)
1573
except dbus.exceptions.NameExistsException, e:
1574
logger.error(unicode(e) + u", disabling D-Bus")
2542
1575
use_dbus = False
2543
server_settings["use_dbus"] = False
1576
server_settings[u"use_dbus"] = False
2544
1577
tcp_server.use_dbus = False
2546
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2547
service = AvahiServiceToSyslog(name =
2548
server_settings["servicename"],
2549
servicetype = "_mandos._tcp",
2550
protocol = protocol, bus = bus)
2551
if server_settings["interface"]:
2552
service.interface = (if_nametoindex
2553
(server_settings["interface"]
2556
global multiprocessing_manager
2557
multiprocessing_manager = multiprocessing.Manager()
1578
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1579
service = AvahiService(name = server_settings[u"servicename"],
1580
servicetype = u"_mandos._tcp",
1581
protocol = protocol, bus = bus)
1582
if server_settings["interface"]:
1583
service.interface = (if_nametoindex
1584
(str(server_settings[u"interface"])))
2559
1586
client_class = Client
2561
1588
client_class = functools.partial(ClientDBus, bus = bus)
2563
client_settings = Client.config_parser(client_config)
2564
old_client_settings = {}
2567
# This is used to redirect stdout and stderr for checker processes
2569
wnull = open(os.devnull, "w") # A writable /dev/null
2570
# Only used if server is running in foreground but not in debug
2572
if debug or not foreground:
2575
# Get client data and settings from last running state.
2576
if server_settings["restore"]:
2578
with open(stored_state_path, "rb") as stored_state:
2579
clients_data, old_client_settings = (pickle.load
2581
os.remove(stored_state_path)
2582
except IOError as e:
2583
if e.errno == errno.ENOENT:
2584
logger.warning("Could not load persistent state: {}"
2585
.format(os.strerror(e.errno)))
2587
logger.critical("Could not load persistent state:",
2590
except EOFError as e:
2591
logger.warning("Could not load persistent state: "
2592
"EOFError:", exc_info=e)
2594
with PGPEngine() as pgp:
2595
for client_name, client in clients_data.items():
2596
# Skip removed clients
2597
if client_name not in client_settings:
2600
# Decide which value to use after restoring saved state.
2601
# We have three different values: Old config file,
2602
# new config file, and saved state.
2603
# New config value takes precedence if it differs from old
2604
# config value, otherwise use saved state.
2605
for name, value in client_settings[client_name].items():
2607
# For each value in new config, check if it
2608
# differs from the old config value (Except for
2609
# the "secret" attribute)
2610
if (name != "secret" and
2611
value != old_client_settings[client_name]
2613
client[name] = value
2617
# Clients who has passed its expire date can still be
2618
# enabled if its last checker was successful. Clients
2619
# whose checker succeeded before we stored its state is
2620
# assumed to have successfully run all checkers during
2622
if client["enabled"]:
2623
if datetime.datetime.utcnow() >= client["expires"]:
2624
if not client["last_checked_ok"]:
2626
"disabling client {} - Client never "
2627
"performed a successful checker"
2628
.format(client_name))
2629
client["enabled"] = False
2630
elif client["last_checker_status"] != 0:
2632
"disabling client {} - Client last"
2633
" checker failed with error code {}"
2634
.format(client_name,
2635
client["last_checker_status"]))
2636
client["enabled"] = False
2638
client["expires"] = (datetime.datetime
2640
+ client["timeout"])
2641
logger.debug("Last checker succeeded,"
2642
" keeping {} enabled"
2643
.format(client_name))
2645
client["secret"] = (
2646
pgp.decrypt(client["encrypted_secret"],
2647
client_settings[client_name]
2650
# If decryption fails, we use secret from new settings
2651
logger.debug("Failed to decrypt {} old secret"
2652
.format(client_name))
2653
client["secret"] = (
2654
client_settings[client_name]["secret"])
2656
# Add/remove clients based on new changes made to config
2657
for client_name in (set(old_client_settings)
2658
- set(client_settings)):
2659
del clients_data[client_name]
2660
for client_name in (set(client_settings)
2661
- set(old_client_settings)):
2662
clients_data[client_name] = client_settings[client_name]
2664
# Create all client objects
2665
for client_name, client in clients_data.items():
2666
tcp_server.clients[client_name] = client_class(
2667
name = client_name, settings = client,
2668
server_settings = server_settings)
1589
tcp_server.clients.update(set(
1590
client_class(name = section,
1591
config= dict(client_config.items(section)))
1592
for section in client_config.sections()))
2670
1593
if not tcp_server.clients:
2671
logger.warning("No clients defined")
2674
if pidfile is not None:
2678
pidfile.write("{}\n".format(pid).encode("utf-8"))
2680
logger.error("Could not write to file %r with PID %d",
1594
logger.warning(u"No clients defined")
1597
# Redirect stdin so all checkers get /dev/null
1598
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1599
os.dup2(null, sys.stdin.fileno())
1603
# No console logging
1604
logger.removeHandler(console)
1605
# Close all input and output, do double fork, etc.
1609
with closing(pidfile):
1611
pidfile.write(str(pid) + "\n")
1614
logger.error(u"Could not write to file %r with PID %d",
1617
# "pidfile" was never created
1622
signal.signal(signal.SIGINT, signal.SIG_IGN)
2685
1623
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2686
1624
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2689
@alternate_dbus_interfaces({"se.recompile.Mandos":
2690
"se.bsnet.fukt.Mandos"})
2691
class MandosDBusService(DBusObjectWithProperties):
1627
class MandosDBusService(dbus.service.Object):
2692
1628
"""A D-Bus proxy object"""
2693
1629
def __init__(self):
2694
dbus.service.Object.__init__(self, bus, "/")
2695
_interface = "se.recompile.Mandos"
2697
@dbus_interface_annotations(_interface)
2699
return { "org.freedesktop.DBus.Property"
2700
".EmitsChangedSignal":
2703
@dbus.service.signal(_interface, signature="o")
2704
def ClientAdded(self, objpath):
2708
@dbus.service.signal(_interface, signature="ss")
2709
def ClientNotFound(self, fingerprint, address):
2713
@dbus.service.signal(_interface, signature="os")
1630
dbus.service.Object.__init__(self, bus, u"/")
1631
_interface = u"se.bsnet.fukt.Mandos"
1633
@dbus.service.signal(_interface, signature=u"oa{sv}")
1634
def ClientAdded(self, objpath, properties):
1638
@dbus.service.signal(_interface, signature=u"s")
1639
def ClientNotFound(self, fingerprint):
1643
@dbus.service.signal(_interface, signature=u"os")
2714
1644
def ClientRemoved(self, objpath, name):
2718
@dbus.service.method(_interface, out_signature="ao")
1648
@dbus.service.method(_interface, out_signature=u"ao")
2719
1649
def GetAllClients(self):
2721
1651
return dbus.Array(c.dbus_object_path
2723
tcp_server.clients.itervalues())
1652
for c in tcp_server.clients)
2725
1654
@dbus.service.method(_interface,
2726
out_signature="a{oa{sv}}")
1655
out_signature=u"a{oa{sv}}")
2727
1656
def GetAllClientsWithProperties(self):
2729
1658
return dbus.Dictionary(
2730
{ c.dbus_object_path: c.GetAll("")
2731
for c in tcp_server.clients.itervalues() },
1659
((c.dbus_object_path, c.GetAll(u""))
1660
for c in tcp_server.clients),
1661
signature=u"oa{sv}")
2734
@dbus.service.method(_interface, in_signature="o")
1663
@dbus.service.method(_interface, in_signature=u"o")
2735
1664
def RemoveClient(self, object_path):
2737
for c in tcp_server.clients.itervalues():
1666
for c in tcp_server.clients:
2738
1667
if c.dbus_object_path == object_path:
2739
del tcp_server.clients[c.name]
1668
tcp_server.clients.remove(c)
2740
1669
c.remove_from_connection()
2741
1670
# Don't signal anything except ClientRemoved
2742
1671
c.disable(quiet=True)
2753
1682
"Cleanup function; run on exit"
2757
multiprocessing.active_children()
2759
if not (tcp_server.clients or client_settings):
2762
# Store client before exiting. Secrets are encrypted with key
2763
# based on what config file has. If config file is
2764
# removed/edited, old secret will thus be unrecovable.
2766
with PGPEngine() as pgp:
2767
for client in tcp_server.clients.itervalues():
2768
key = client_settings[client.name]["secret"]
2769
client.encrypted_secret = pgp.encrypt(client.secret,
2773
# A list of attributes that can not be pickled
2775
exclude = { "bus", "changedstate", "secret",
2776
"checker", "server_settings" }
2777
for name, typ in (inspect.getmembers
2778
(dbus.service.Object)):
2781
client_dict["encrypted_secret"] = (client
2783
for attr in client.client_structure:
2784
if attr not in exclude:
2785
client_dict[attr] = getattr(client, attr)
2787
clients[client.name] = client_dict
2788
del client_settings[client.name]["secret"]
2791
with (tempfile.NamedTemporaryFile
2792
(mode='wb', suffix=".pickle", prefix='clients-',
2793
dir=os.path.dirname(stored_state_path),
2794
delete=False)) as stored_state:
2795
pickle.dump((clients, client_settings), stored_state)
2796
tempname=stored_state.name
2797
os.rename(tempname, stored_state_path)
2798
except (IOError, OSError) as e:
2804
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2805
logger.warning("Could not save persistent state: {}"
2806
.format(os.strerror(e.errno)))
2808
logger.warning("Could not save persistent state:",
2812
# Delete all clients, and settings from config
2813
1685
while tcp_server.clients:
2814
name, client = tcp_server.clients.popitem()
1686
client = tcp_server.clients.pop()
2816
1688
client.remove_from_connection()
1689
client.disable_hook = None
2817
1690
# Don't signal anything except ClientRemoved
2818
1691
client.disable(quiet=True)
2820
1693
# Emit D-Bus signal
2821
mandos_dbus_service.ClientRemoved(client
1694
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
2824
client_settings.clear()
2826
1697
atexit.register(cleanup)
2828
for client in tcp_server.clients.itervalues():
1699
for client in tcp_server.clients:
2830
1701
# Emit D-Bus signal
2831
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2832
# Need to initiate checking of clients
2834
client.init_checker()
1702
mandos_dbus_service.ClientAdded(client.dbus_object_path,
2836
1706
tcp_server.enable()
2837
1707
tcp_server.server_activate()
2839
1709
# Find out what port we got
2841
service.port = tcp_server.socket.getsockname()[1]
1710
service.port = tcp_server.socket.getsockname()[1]
2843
logger.info("Now listening on address %r, port %d,"
2844
" flowinfo %d, scope_id %d",
2845
*tcp_server.socket.getsockname())
1712
logger.info(u"Now listening on address %r, port %d,"
1713
" flowinfo %d, scope_id %d"
1714
% tcp_server.socket.getsockname())
2847
logger.info("Now listening on address %r, port %d",
2848
*tcp_server.socket.getsockname())
1716
logger.info(u"Now listening on address %r, port %d"
1717
% tcp_server.socket.getsockname())
2850
1719
#service.interface = tcp_server.socket.getsockname()[3]
2854
# From the Avahi example code
2857
except dbus.exceptions.DBusException as error:
2858
logger.critical("D-Bus Exception", exc_info=error)
2861
# End of Avahi example code
1722
# From the Avahi example code
1725
except dbus.exceptions.DBusException, error:
1726
logger.critical(u"DBusException: %s", error)
1729
# End of Avahi example code
2863
1731
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2864
1732
lambda *args, **kwargs:
2865
1733
(tcp_server.handle_request
2866
1734
(*args[2:], **kwargs) or True))
2868
logger.debug("Starting main loop")
1736
logger.debug(u"Starting main loop")
2869
1737
main_loop.run()
2870
except AvahiError as error:
2871
logger.critical("Avahi Error", exc_info=error)
1738
except AvahiError, error:
1739
logger.critical(u"AvahiError: %s", error)
2874
1742
except KeyboardInterrupt:
2876
print("", file=sys.stderr)
2877
logger.debug("Server received KeyboardInterrupt")
2878
logger.debug("Server exiting")
1745
logger.debug(u"Server received KeyboardInterrupt")
1746
logger.debug(u"Server exiting")
2879
1747
# Must run before the D-Bus bus name gets deregistered