To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 742
- compare with another revision
- download diff
- download tarball
- view history from revision 742
- Committer: Teddy Hogeborn
- Date: 2015-03-10 18:03:38 UTC
- Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.
If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default. The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.
There is a "PFS" priority string specifier, but we can't use it because:
1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
enables a lot more algorithms than "SECURE256".
2. It is only available since GnuTLS 3.2.4.
Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.
If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default. The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.
There is a "PFS" priority string specifier, but we can't use it because:
1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
enables a lot more algorithms than "SECURE256".
2. It is only available since GnuTLS 3.2.4.
Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.
- files added:
- debian/mandos-client.examples
- debian/upstream
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 Björn Påhlsson
14
# Copyright © 2008-2014 Teddy Hogeborn
15
# Copyright © 2008-2014 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
68
68
import binascii
69
69
import tempfile
70
70
import itertools
71
import collections
71
72
72
73
import dbus
73
74
import dbus.service
78
79
import ctypes.util
79
80
import xml.dom.minidom
80
81
import inspect
81
import GnuPGInterface
82
82
83
83
try:
84
84
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
88
except ImportError:
89
89
SO_BINDTODEVICE = None
90
90
91
version = "1.5.3"
91
if sys.version_info.major == 2:
92
str = unicode
93
94
version = "1.6.9"
92
95
stored_state_file = "clients.pickle"
93
96
94
97
logger = logging.getLogger()
95
syslogger = (logging.handlers.SysLogHandler
96
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
97
address = str("/dev/log")))
98
syslogger = None
98
99
99
100
try:
100
101
if_nametoindex = (ctypes.cdll.LoadLibrary
106
107
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
107
108
with contextlib.closing(socket.socket()) as s:
108
109
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
109
struct.pack(str("16s16x"),
110
interface))
111
interface_index = struct.unpack(str("I"),
112
ifreq[16:20])[0]
110
struct.pack(b"16s16x", interface))
111
interface_index = struct.unpack("I", ifreq[16:20])[0]
113
112
return interface_index
114
113
115
114
116
115
def initlogger(debug, level=logging.WARNING):
117
116
"""init logger and add loglevel"""
118
117
118
global syslogger
119
syslogger = (logging.handlers.SysLogHandler
120
(facility =
121
logging.handlers.SysLogHandler.LOG_DAEMON,
122
address = "/dev/log"))
119
123
syslogger.setFormatter(logging.Formatter
120
124
('Mandos [%(process)d]: %(levelname)s:'
121
125
' %(message)s'))
139
143
class PGPEngine(object):
140
144
"""A simple class for OpenPGP symmetric encryption & decryption"""
141
145
def __init__(self):
142
self.gnupg = GnuPGInterface.GnuPG()
143
146
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
144
self.gnupg = GnuPGInterface.GnuPG()
145
self.gnupg.options.meta_interactive = False
146
self.gnupg.options.homedir = self.tempdir
147
self.gnupg.options.extra_args.extend(['--force-mdc',
148
'--quiet',
149
'--no-use-agent'])
147
self.gnupgargs = ['--batch',
148
'--home', self.tempdir,
149
'--force-mdc',
150
'--quiet',
151
'--no-use-agent']
150
152
151
153
def __enter__(self):
152
154
return self
153
155
154
def __exit__ (self, exc_type, exc_value, traceback):
156
def __exit__(self, exc_type, exc_value, traceback):
155
157
self._cleanup()
156
158
return False
157
159
174
176
def password_encode(self, password):
175
177
# Passphrase can not be empty and can not contain newlines or
176
178
# NUL bytes. So we prefix it and hex encode it.
177
return b"mandos" + binascii.hexlify(password)
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"))
185
return encoded
178
186
179
187
def encrypt(self, data, password):
180
self.gnupg.passphrase = self.password_encode(password)
181
with open(os.devnull, "w") as devnull:
182
try:
183
proc = self.gnupg.run(['--symmetric'],
184
create_fhs=['stdin', 'stdout'],
185
attach_fhs={'stderr': devnull})
186
with contextlib.closing(proc.handles['stdin']) as f:
187
f.write(data)
188
with contextlib.closing(proc.handles['stdout']) as f:
189
ciphertext = f.read()
190
proc.wait()
191
except IOError as e:
192
raise PGPError(e)
193
self.gnupg.passphrase = None
188
passphrase = self.password_encode(password)
189
with tempfile.NamedTemporaryFile(dir=self.tempdir
190
) as passfile:
191
passfile.write(passphrase)
192
passfile.flush()
193
proc = subprocess.Popen(['gpg', '--symmetric',
194
'--passphrase-file',
195
passfile.name]
196
+ self.gnupgargs,
197
stdin = subprocess.PIPE,
198
stdout = subprocess.PIPE,
199
stderr = subprocess.PIPE)
200
ciphertext, err = proc.communicate(input = data)
201
if proc.returncode != 0:
202
raise PGPError(err)
194
203
return ciphertext
195
204
196
205
def decrypt(self, data, password):
197
self.gnupg.passphrase = self.password_encode(password)
198
with open(os.devnull, "w") as devnull:
199
try:
200
proc = self.gnupg.run(['--decrypt'],
201
create_fhs=['stdin', 'stdout'],
202
attach_fhs={'stderr': devnull})
203
with contextlib.closing(proc.handles['stdin']) as f:
204
f.write(data)
205
with contextlib.closing(proc.handles['stdout']) as f:
206
decrypted_plaintext = f.read()
207
proc.wait()
208
except IOError as e:
209
raise PGPError(e)
210
self.gnupg.passphrase = None
206
passphrase = self.password_encode(password)
207
with tempfile.NamedTemporaryFile(dir = self.tempdir
208
) as passfile:
209
passfile.write(passphrase)
210
passfile.flush()
211
proc = subprocess.Popen(['gpg', '--decrypt',
212
'--passphrase-file',
213
passfile.name]
214
+ self.gnupgargs,
215
stdin = subprocess.PIPE,
216
stdout = subprocess.PIPE,
217
stderr = subprocess.PIPE)
218
decrypted_plaintext, err = proc.communicate(input
219
= data)
220
if proc.returncode != 0:
221
raise PGPError(err)
211
222
return decrypted_plaintext
212
223
213
224
214
225
class AvahiError(Exception):
215
226
def __init__(self, value, *args, **kwargs):
216
227
self.value = value
217
super(AvahiError, self).__init__(value, *args, **kwargs)
218
def __unicode__(self):
219
return unicode(repr(self.value))
228
return super(AvahiError, self).__init__(value, *args,
229
**kwargs)
220
230
221
231
class AvahiServiceError(AvahiError):
222
232
pass
233
243
Used to optionally bind to the specified interface.
234
244
name: string; Example: 'Mandos'
235
245
type: string; Example: '_mandos._tcp'.
236
See <http://www.dns-sd.org/ServiceTypes.html>
246
See <https://www.iana.org/assignments/service-names-port-numbers>
237
247
port: integer; what port to announce
238
248
TXT: list of strings; TXT record for the service
239
249
domain: string; Domain to publish on, default to .local if empty.
265
275
self.bus = bus
266
276
self.entry_group_state_changed_match = None
267
277
268
def rename(self):
278
def rename(self, remove=True):
269
279
"""Derived from the Avahi example code"""
270
280
if self.rename_count >= self.max_renames:
271
281
logger.critical("No suitable Zeroconf service name found"
272
282
" after %i retries, exiting.",
273
283
self.rename_count)
274
284
raise AvahiServiceError("Too many renames")
275
self.name = unicode(self.server
276
.GetAlternativeServiceName(self.name))
285
self.name = str(self.server
286
.GetAlternativeServiceName(self.name))
287
self.rename_count += 1
277
288
logger.info("Changing Zeroconf service name to %r ...",
278
289
self.name)
279
self.remove()
290
if remove:
291
self.remove()
280
292
try:
281
293
self.add()
282
294
except dbus.exceptions.DBusException as error:
283
logger.critical("D-Bus Exception", exc_info=error)
284
self.cleanup()
285
os._exit(1)
286
self.rename_count += 1
295
if (error.get_dbus_name()
296
== "org.freedesktop.Avahi.CollisionError"):
297
logger.info("Local Zeroconf service name collision.")
298
return self.rename(remove=False)
299
else:
300
logger.critical("D-Bus Exception", exc_info=error)
301
self.cleanup()
302
os._exit(1)
287
303
288
304
def remove(self):
289
305
"""Derived from the Avahi example code"""
327
343
self.rename()
328
344
elif state == avahi.ENTRY_GROUP_FAILURE:
329
345
logger.critical("Avahi: Error in group state changed %s",
330
unicode(error))
331
raise AvahiGroupError("State changed: {0!s}"
346
str(error))
347
raise AvahiGroupError("State changed: {!s}"
332
348
.format(error))
333
349
334
350
def cleanup(self):
379
395
self.server_state_changed)
380
396
self.server_state_changed(self.server.GetState())
381
397
398
382
399
class AvahiServiceToSyslog(AvahiService):
383
def rename(self):
400
def rename(self, *args, **kwargs):
384
401
"""Add the new name to the syslog messages"""
385
ret = AvahiService.rename(self)
402
ret = AvahiService.rename(self, *args, **kwargs)
386
403
syslogger.setFormatter(logging.Formatter
387
('Mandos ({0}) [%(process)d]:'
404
('Mandos ({}) [%(process)d]:'
388
405
' %(levelname)s: %(message)s'
389
406
.format(self.name)))
390
407
return ret
391
408
392
def timedelta_to_milliseconds(td):
393
"Convert a datetime.timedelta() to milliseconds"
394
return ((td.days * 24 * 60 * 60 * 1000)
395
+ (td.seconds * 1000)
396
+ (td.microseconds // 1000))
397
409
398
410
class Client(object):
399
411
"""A representation of a client host served by this server.
436
448
runtime_expansions: Allowed attributes for runtime expansion.
437
449
expires: datetime.datetime(); time (UTC) when a client will be
438
450
disabled, or None
451
server_settings: The server_settings dict from main()
439
452
"""
440
453
441
454
runtime_expansions = ("approval_delay", "approval_duration",
442
"created", "enabled", "fingerprint",
443
"host", "interval", "last_checked_ok",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
444
458
"last_enabled", "name", "timeout")
445
client_defaults = { "timeout": "5m",
446
"extended_timeout": "15m",
447
"interval": "2m",
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
461
"interval": "PT2M",
448
462
"checker": "fping -q -- %%(host)s",
449
463
"host": "",
450
"approval_delay": "0s",
451
"approval_duration": "1s",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
452
466
"approved_by_default": "True",
453
467
"enabled": "True",
454
468
}
455
469
456
def timeout_milliseconds(self):
457
"Return the 'timeout' attribute in milliseconds"
458
return timedelta_to_milliseconds(self.timeout)
459
460
def extended_timeout_milliseconds(self):
461
"Return the 'extended_timeout' attribute in milliseconds"
462
return timedelta_to_milliseconds(self.extended_timeout)
463
464
def interval_milliseconds(self):
465
"Return the 'interval' attribute in milliseconds"
466
return timedelta_to_milliseconds(self.interval)
467
468
def approval_delay_milliseconds(self):
469
return timedelta_to_milliseconds(self.approval_delay)
470
471
470
@staticmethod
472
471
def config_parser(config):
473
472
"""Construct a new dict of client settings of this form:
488
487
client["enabled"] = config.getboolean(client_name,
489
488
"enabled")
490
489
490
# Uppercase and remove spaces from fingerprint for later
491
# comparison purposes with return value from the
492
# fingerprint() function
491
493
client["fingerprint"] = (section["fingerprint"].upper()
492
494
.replace(" ", ""))
493
495
if "secret" in section:
498
500
"rb") as secfile:
499
501
client["secret"] = secfile.read()
500
502
else:
501
raise TypeError("No secret or secfile for section {0}"
503
raise TypeError("No secret or secfile for section {}"
502
504
.format(section))
503
505
client["timeout"] = string_to_delta(section["timeout"])
504
506
client["extended_timeout"] = string_to_delta(
515
517
516
518
return settings
517
519
518
def __init__(self, settings, name = None):
520
def __init__(self, settings, name = None, server_settings=None):
519
521
self.name = name
522
if server_settings is None:
523
server_settings = {}
524
self.server_settings = server_settings
520
525
# adding all client settings
521
for setting, value in settings.iteritems():
526
for setting, value in settings.items():
522
527
setattr(self, setting, value)
523
528
524
529
if self.enabled:
532
537
self.expires = None
533
538
534
539
logger.debug("Creating client %r", self.name)
535
# Uppercase and remove spaces from fingerprint for later
536
# comparison purposes with return value from the fingerprint()
537
# function
538
540
logger.debug(" Fingerprint: %s", self.fingerprint)
539
541
self.created = settings.get("created",
540
542
datetime.datetime.utcnow())
607
609
if self.checker_initiator_tag is not None:
608
610
gobject.source_remove(self.checker_initiator_tag)
609
611
self.checker_initiator_tag = (gobject.timeout_add
610
(self.interval_milliseconds(),
612
(int(self.interval
613
.total_seconds() * 1000),
611
614
self.start_checker))
612
615
# Schedule a disable() when 'timeout' has passed
613
616
if self.disable_initiator_tag is not None:
614
617
gobject.source_remove(self.disable_initiator_tag)
615
618
self.disable_initiator_tag = (gobject.timeout_add
616
(self.timeout_milliseconds(),
617
self.disable))
619
(int(self.timeout
620
.total_seconds() * 1000),
621
self.disable))
618
622
# Also start a new checker *right now*.
619
623
self.start_checker()
620
624
651
655
self.disable_initiator_tag = None
652
656
if getattr(self, "enabled", False):
653
657
self.disable_initiator_tag = (gobject.timeout_add
654
(timedelta_to_milliseconds
655
(timeout), self.disable))
658
(int(timeout.total_seconds()
659
* 1000), self.disable))
656
660
self.expires = datetime.datetime.utcnow() + timeout
657
661
658
662
def need_approval(self):
675
679
# If a checker exists, make sure it is not a zombie
676
680
try:
677
681
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
678
except (AttributeError, OSError) as error:
679
if (isinstance(error, OSError)
680
and error.errno != errno.ECHILD):
681
raise error
682
except AttributeError:
683
pass
684
except OSError as error:
685
if error.errno != errno.ECHILD:
686
raise
682
687
else:
683
688
if pid:
684
689
logger.warning("Checker was a zombie")
687
692
self.current_checker_command)
688
693
# Start a new checker if needed
689
694
if self.checker is None:
695
# Escape attributes for the shell
696
escaped_attrs = { attr:
697
re.escape(str(getattr(self, attr)))
698
for attr in self.runtime_expansions }
690
699
try:
691
# In case checker_command has exactly one % operator
692
command = self.checker_command % self.host
693
except TypeError:
694
# Escape attributes for the shell
695
escaped_attrs = dict(
696
(attr,
697
re.escape(unicode(str(getattr(self, attr, "")),
698
errors=
699
'replace')))
700
for attr in
701
self.runtime_expansions)
702
703
try:
704
command = self.checker_command % escaped_attrs
705
except TypeError as error:
706
logger.error('Could not format string "%s"',
707
self.checker_command, exc_info=error)
708
return True # Try again later
700
command = self.checker_command % escaped_attrs
701
except TypeError as error:
702
logger.error('Could not format string "%s"',
703
self.checker_command, exc_info=error)
704
return True # Try again later
709
705
self.current_checker_command = command
710
706
try:
711
707
logger.info("Starting checker %r for %s",
714
710
# in normal mode, that is already done by daemon(),
715
711
# and in debug mode we don't want to. (Stdin is
716
712
# always replaced by /dev/null.)
713
# The exception is when not debugging but nevertheless
714
# running in the foreground; use the previously
715
# created wnull.
716
popen_args = {}
717
if (not self.server_settings["debug"]
718
and self.server_settings["foreground"]):
719
popen_args.update({"stdout": wnull,
720
"stderr": wnull })
717
721
self.checker = subprocess.Popen(command,
718
722
close_fds=True,
719
shell=True, cwd="/")
720
self.checker_callback_tag = (gobject.child_watch_add
721
(self.checker.pid,
722
self.checker_callback,
723
data=command))
724
# The checker may have completed before the gobject
725
# watch was added. Check for this.
726
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
727
if pid:
728
gobject.source_remove(self.checker_callback_tag)
729
self.checker_callback(pid, status, command)
723
shell=True, cwd="/",
724
**popen_args)
730
725
except OSError as error:
731
726
logger.error("Failed to start subprocess",
732
727
exc_info=error)
728
return True
729
self.checker_callback_tag = (gobject.child_watch_add
730
(self.checker.pid,
731
self.checker_callback,
732
data=command))
733
# The checker may have completed before the gobject
734
# watch was added. Check for this.
735
try:
736
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
737
except OSError as error:
738
if error.errno == errno.ECHILD:
739
# This should never happen
740
logger.error("Child process vanished",
741
exc_info=error)
742
return True
743
raise
744
if pid:
745
gobject.source_remove(self.checker_callback_tag)
746
self.checker_callback(pid, status, command)
733
747
# Re-run this periodically if run by gobject.timeout_add
734
748
return True
735
749
768
782
# "Set" method, so we fail early here:
769
783
if byte_arrays and signature != "ay":
770
784
raise ValueError("Byte arrays not supported for non-'ay'"
771
" signature {0!r}".format(signature))
785
" signature {!r}".format(signature))
772
786
def decorator(func):
773
787
func._dbus_is_property = True
774
788
func._dbus_interface = dbus_interface
805
819
"""Decorator to annotate D-Bus methods, signals or properties
806
820
Usage:
807
821
822
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
823
"org.freedesktop.DBus.Property."
824
"EmitsChangedSignal": "false"})
808
825
@dbus_service_property("org.example.Interface", signature="b",
809
826
access="r")
810
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
811
"org.freedesktop.DBus.Property."
812
"EmitsChangedSignal": "false"})
813
827
def Property_dbus_property(self):
814
828
return dbus.Boolean(False)
815
829
"""
822
836
class DBusPropertyException(dbus.exceptions.DBusException):
823
837
"""A base class for D-Bus property-related exceptions
824
838
"""
825
def __unicode__(self):
826
return unicode(str(self))
827
839
pass
828
840
829
841
class DBusPropertyAccessException(DBusPropertyException):
830
842
"""A property's access permissions disallows an operation.
853
865
If called like _is_dbus_thing("method") it returns a function
854
866
suitable for use as predicate to inspect.getmembers().
855
867
"""
856
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
868
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
857
869
False)
858
870
859
871
def _get_all_dbus_things(self, thing):
908
920
# The byte_arrays option is not supported yet on
909
921
# signatures other than "ay".
910
922
if prop._dbus_signature != "ay":
911
raise ValueError
923
raise ValueError("Byte arrays not supported for non-"
924
"'ay' signature {!r}"
925
.format(prop._dbus_signature))
912
926
value = dbus.ByteArray(b''.join(chr(byte)
913
927
for byte in value))
914
928
prop(value)
938
952
value.variant_level+1)
939
953
return dbus.Dictionary(properties, signature="sv")
940
954
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
959
standard.
960
"""
961
pass
962
941
963
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
942
964
out_signature="s",
943
965
path_keyword='object_path',
978
1000
(prop,
979
1001
"_dbus_annotations",
980
1002
{}))
981
for name, value in annots.iteritems():
1003
for name, value in annots.items():
982
1004
ann_tag = document.createElement(
983
1005
"annotation")
984
1006
ann_tag.setAttribute("name", name)
987
1009
# Add interface annotation tags
988
1010
for annotation, value in dict(
989
1011
itertools.chain.from_iterable(
990
annotations().iteritems()
1012
annotations().items()
991
1013
for name, annotations in
992
1014
self._get_all_dbus_things("interface")
993
1015
if name == if_tag.getAttribute("name")
994
)).iteritems():
1016
)).items():
995
1017
ann_tag = document.createElement("annotation")
996
1018
ann_tag.setAttribute("name", annotation)
997
1019
ann_tag.setAttribute("value", value)
1020
1042
return xmlstring
1021
1043
1022
1044
1023
def datetime_to_dbus (dt, variant_level=0):
1045
def datetime_to_dbus(dt, variant_level=0):
1024
1046
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1025
1047
if dt is None:
1026
1048
return dbus.String("", variant_level = variant_level)
1034
1056
interface names according to the "alt_interface_names" mapping.
1035
1057
Usage:
1036
1058
1037
@alternate_dbus_names({"org.example.Interface":
1038
"net.example.AlternateInterface"})
1059
@alternate_dbus_interfaces({"org.example.Interface":
1060
"net.example.AlternateInterface"})
1039
1061
class SampleDBusObject(dbus.service.Object):
1040
1062
@dbus.service.method("org.example.Interface")
1041
1063
def SampleDBusMethod():
1053
1075
"""
1054
1076
def wrapper(cls):
1055
1077
for orig_interface_name, alt_interface_name in (
1056
alt_interface_names.iteritems()):
1078
alt_interface_names.items()):
1057
1079
attr = {}
1058
1080
interface_names = set()
1059
1081
# Go though all attributes of the class
1072
1094
interface_names.add(alt_interface)
1073
1095
# Is this a D-Bus signal?
1074
1096
if getattr(attribute, "_dbus_is_signal", False):
1075
# Extract the original non-method function by
1076
# black magic
1097
# Extract the original non-method undecorated
1098
# function by black magic
1077
1099
nonmethod_func = (dict(
1078
1100
zip(attribute.func_code.co_freevars,
1079
1101
attribute.__closure__))["func"]
1176
1198
attribute.func_closure)))
1177
1199
if deprecate:
1178
1200
# Deprecate all alternate interfaces
1179
iname="_AlternateDBusNames_interface_annotation{0}"
1201
iname="_AlternateDBusNames_interface_annotation{}"
1180
1202
for interface_name in interface_names:
1181
1203
@dbus_interface_annotations(interface_name)
1182
1204
def func(self):
1191
1213
if interface_names:
1192
1214
# Replace the class with a new subclass of it with
1193
1215
# methods, signals, etc. as created above.
1194
cls = type(b"{0}Alternate".format(cls.__name__),
1216
cls = type(b"{}Alternate".format(cls.__name__),
1195
1217
(cls,), attr)
1196
1218
return cls
1197
1219
return wrapper
1210
1232
runtime_expansions = (Client.runtime_expansions
1211
1233
+ ("dbus_object_path",))
1212
1234
1235
_interface = "se.recompile.Mandos.Client"
1236
1213
1237
# dbus.service.Object doesn't use super(), so we can't either.
1214
1238
1215
1239
def __init__(self, bus = None, *args, **kwargs):
1217
1241
Client.__init__(self, *args, **kwargs)
1218
1242
# Only now, when this client is initialized, can it show up on
1219
1243
# the D-Bus
1220
client_object_name = unicode(self.name).translate(
1244
client_object_name = str(self.name).translate(
1221
1245
{ord("."): ord("_"),
1222
1246
ord("-"): ord("_")})
1223
1247
self.dbus_object_path = (dbus.ObjectPath
1227
1251
1228
1252
def notifychangeproperty(transform_func,
1229
1253
dbus_name, type_func=lambda x: x,
1230
variant_level=1):
1254
variant_level=1, invalidate_only=False,
1255
_interface=_interface):
1231
1256
""" Modify a variable so that it's a property which announces
1232
1257
its changes to DBus.
1233
1258
1238
1263
to the D-Bus. Default: no transform
1239
1264
variant_level: D-Bus variant level. Default: 1
1240
1265
"""
1241
attrname = "_{0}".format(dbus_name)
1266
attrname = "_{}".format(dbus_name)
1242
1267
def setter(self, value):
1243
1268
if hasattr(self, "dbus_object_path"):
1244
1269
if (not hasattr(self, attrname) or
1245
1270
type_func(getattr(self, attrname, None))
1246
1271
!= type_func(value)):
1247
dbus_value = transform_func(type_func(value),
1248
variant_level
1249
=variant_level)
1250
self.PropertyChanged(dbus.String(dbus_name),
1251
dbus_value)
1272
if invalidate_only:
1273
self.PropertiesChanged(_interface,
1274
dbus.Dictionary(),
1275
dbus.Array
1276
((dbus_name,)))
1277
else:
1278
dbus_value = transform_func(type_func(value),
1279
variant_level
1280
=variant_level)
1281
self.PropertyChanged(dbus.String(dbus_name),
1282
dbus_value)
1283
self.PropertiesChanged(_interface,
1284
dbus.Dictionary({
1285
dbus.String(dbus_name):
1286
dbus_value }), dbus.Array())
1252
1287
setattr(self, attrname, value)
1253
1288
1254
1289
return property(lambda self: getattr(self, attrname), setter)
1274
1309
approval_delay = notifychangeproperty(dbus.UInt64,
1275
1310
"ApprovalDelay",
1276
1311
type_func =
1277
timedelta_to_milliseconds)
1312
lambda td: td.total_seconds()
1313
* 1000)
1278
1314
approval_duration = notifychangeproperty(
1279
1315
dbus.UInt64, "ApprovalDuration",
1280
type_func = timedelta_to_milliseconds)
1316
type_func = lambda td: td.total_seconds() * 1000)
1281
1317
host = notifychangeproperty(dbus.String, "Host")
1282
1318
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1283
type_func =
1284
timedelta_to_milliseconds)
1319
type_func = lambda td:
1320
td.total_seconds() * 1000)
1285
1321
extended_timeout = notifychangeproperty(
1286
1322
dbus.UInt64, "ExtendedTimeout",
1287
type_func = timedelta_to_milliseconds)
1323
type_func = lambda td: td.total_seconds() * 1000)
1288
1324
interval = notifychangeproperty(dbus.UInt64,
1289
1325
"Interval",
1290
1326
type_func =
1291
timedelta_to_milliseconds)
1327
lambda td: td.total_seconds()
1328
* 1000)
1292
1329
checker_command = notifychangeproperty(dbus.String, "Checker")
1330
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1331
invalidate_only=True)
1293
1332
1294
1333
del notifychangeproperty
1295
1334
1322
1361
*args, **kwargs)
1323
1362
1324
1363
def start_checker(self, *args, **kwargs):
1325
old_checker = self.checker
1326
if self.checker is not None:
1327
old_checker_pid = self.checker.pid
1328
else:
1329
old_checker_pid = None
1364
old_checker_pid = getattr(self.checker, "pid", None)
1330
1365
r = Client.start_checker(self, *args, **kwargs)
1331
1366
# Only if new checker process was started
1332
1367
if (self.checker is not None
1341
1376
1342
1377
def approve(self, value=True):
1343
1378
self.approved = value
1344
gobject.timeout_add(timedelta_to_milliseconds
1345
(self.approval_duration),
1346
self._reset_approved)
1379
gobject.timeout_add(int(self.approval_duration.total_seconds()
1380
* 1000), self._reset_approved)
1347
1381
self.send_changedstate()
1348
1382
1349
1383
## D-Bus methods, signals & properties
1350
_interface = "se.recompile.Mandos.Client"
1351
1384
1352
1385
## Interfaces
1353
1386
1354
@dbus_interface_annotations(_interface)
1355
def _foo(self):
1356
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1357
"false"}
1358
1359
1387
## Signals
1360
1388
1361
1389
# CheckerCompleted - signal
1371
1399
pass
1372
1400
1373
1401
# PropertyChanged - signal
1402
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1374
1403
@dbus.service.signal(_interface, signature="sv")
1375
1404
def PropertyChanged(self, property, value):
1376
1405
"D-Bus signal"
1452
1481
access="readwrite")
1453
1482
def ApprovalDelay_dbus_property(self, value=None):
1454
1483
if value is None: # get
1455
return dbus.UInt64(self.approval_delay_milliseconds())
1484
return dbus.UInt64(self.approval_delay.total_seconds()
1485
* 1000)
1456
1486
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1457
1487
1458
1488
# ApprovalDuration - property
1460
1490
access="readwrite")
1461
1491
def ApprovalDuration_dbus_property(self, value=None):
1462
1492
if value is None: # get
1463
return dbus.UInt64(timedelta_to_milliseconds(
1464
self.approval_duration))
1493
return dbus.UInt64(self.approval_duration.total_seconds()
1494
* 1000)
1465
1495
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1466
1496
1467
1497
# Name - property
1480
1510
def Host_dbus_property(self, value=None):
1481
1511
if value is None: # get
1482
1512
return dbus.String(self.host)
1483
self.host = unicode(value)
1513
self.host = str(value)
1484
1514
1485
1515
# Created - property
1486
1516
@dbus_service_property(_interface, signature="s", access="read")
1533
1563
access="readwrite")
1534
1564
def Timeout_dbus_property(self, value=None):
1535
1565
if value is None: # get
1536
return dbus.UInt64(self.timeout_milliseconds())
1566
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1537
1567
old_timeout = self.timeout
1538
1568
self.timeout = datetime.timedelta(0, 0, 0, value)
1539
1569
# Reschedule disabling
1550
1580
gobject.source_remove(self.disable_initiator_tag)
1551
1581
self.disable_initiator_tag = (
1552
1582
gobject.timeout_add(
1553
timedelta_to_milliseconds(self.expires - now),
1554
self.disable))
1583
int((self.expires - now).total_seconds()
1584
* 1000), self.disable))
1555
1585
1556
1586
# ExtendedTimeout - property
1557
1587
@dbus_service_property(_interface, signature="t",
1558
1588
access="readwrite")
1559
1589
def ExtendedTimeout_dbus_property(self, value=None):
1560
1590
if value is None: # get
1561
return dbus.UInt64(self.extended_timeout_milliseconds())
1591
return dbus.UInt64(self.extended_timeout.total_seconds()
1592
* 1000)
1562
1593
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1563
1594
1564
1595
# Interval - property
1566
1597
access="readwrite")
1567
1598
def Interval_dbus_property(self, value=None):
1568
1599
if value is None: # get
1569
return dbus.UInt64(self.interval_milliseconds())
1600
return dbus.UInt64(self.interval.total_seconds() * 1000)
1570
1601
self.interval = datetime.timedelta(0, 0, 0, value)
1571
1602
if getattr(self, "checker_initiator_tag", None) is None:
1572
1603
return
1583
1614
def Checker_dbus_property(self, value=None):
1584
1615
if value is None: # get
1585
1616
return dbus.String(self.checker_command)
1586
self.checker_command = unicode(value)
1617
self.checker_command = str(value)
1587
1618
1588
1619
# CheckerRunning - property
1589
1620
@dbus_service_property(_interface, signature="b",
1605
1636
@dbus_service_property(_interface, signature="ay",
1606
1637
access="write", byte_arrays=True)
1607
1638
def Secret_dbus_property(self, value):
1608
self.secret = str(value)
1639
self.secret = bytes(value)
1609
1640
1610
1641
del _interface
1611
1642
1645
1676
def handle(self):
1646
1677
with contextlib.closing(self.server.child_pipe) as child_pipe:
1647
1678
logger.info("TCP connection from: %s",
1648
unicode(self.client_address))
1679
str(self.client_address))
1649
1680
logger.debug("Pipe FD: %d",
1650
1681
self.server.child_pipe.fileno())
1651
1682
1677
1708
logger.debug("Protocol version: %r", line)
1678
1709
try:
1679
1710
if int(line.strip().split()[0]) > 1:
1680
raise RuntimeError
1711
raise RuntimeError(line)
1681
1712
except (ValueError, IndexError, RuntimeError) as error:
1682
1713
logger.error("Unknown protocol version: %s", error)
1683
1714
return
1732
1763
if self.server.use_dbus:
1733
1764
# Emit D-Bus signal
1734
1765
client.NeedApproval(
1735
client.approval_delay_milliseconds(),
1736
client.approved_by_default)
1766
client.approval_delay.total_seconds()
1767
* 1000, client.approved_by_default)
1737
1768
else:
1738
1769
logger.warning("Client %s was not approved",
1739
1770
client.name)
1745
1776
#wait until timeout or approved
1746
1777
time = datetime.datetime.now()
1747
1778
client.changedstate.acquire()
1748
client.changedstate.wait(
1749
float(timedelta_to_milliseconds(delay)
1750
/ 1000))
1779
client.changedstate.wait(delay.total_seconds())
1751
1780
client.changedstate.release()
1752
1781
time2 = datetime.datetime.now()
1753
1782
if (time2 - time) >= delay:
1890
1919
1891
1920
def add_pipe(self, parent_pipe, proc):
1892
1921
"""Dummy function; override as necessary"""
1893
raise NotImplementedError
1922
raise NotImplementedError()
1894
1923
1895
1924
1896
1925
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1903
1932
use_ipv6: Boolean; to use IPv6 or not
1904
1933
"""
1905
1934
def __init__(self, server_address, RequestHandlerClass,
1906
interface=None, use_ipv6=True):
1935
interface=None, use_ipv6=True, socketfd=None):
1936
"""If socketfd is set, use that file descriptor instead of
1937
creating a new one with socket.socket().
1938
"""
1907
1939
self.interface = interface
1908
1940
if use_ipv6:
1909
1941
self.address_family = socket.AF_INET6
1942
if socketfd is not None:
1943
# Save the file descriptor
1944
self.socketfd = socketfd
1945
# Save the original socket.socket() function
1946
self.socket_socket = socket.socket
1947
# To implement --socket, we monkey patch socket.socket.
1948
#
1949
# (When socketserver.TCPServer is a new-style class, we
1950
# could make self.socket into a property instead of monkey
1951
# patching socket.socket.)
1952
#
1953
# Create a one-time-only replacement for socket.socket()
1954
@functools.wraps(socket.socket)
1955
def socket_wrapper(*args, **kwargs):
1956
# Restore original function so subsequent calls are
1957
# not affected.
1958
socket.socket = self.socket_socket
1959
del self.socket_socket
1960
# This time only, return a new socket object from the
1961
# saved file descriptor.
1962
return socket.fromfd(self.socketfd, *args, **kwargs)
1963
# Replace socket.socket() function with wrapper
1964
socket.socket = socket_wrapper
1965
# The socketserver.TCPServer.__init__ will call
1966
# socket.socket(), which might be our replacement,
1967
# socket_wrapper(), if socketfd was set.
1910
1968
socketserver.TCPServer.__init__(self, server_address,
1911
1969
RequestHandlerClass)
1970
1912
1971
def server_bind(self):
1913
1972
"""This overrides the normal server_bind() function
1914
1973
to bind to an interface if one was specified, and also NOT to
1922
1981
try:
1923
1982
self.socket.setsockopt(socket.SOL_SOCKET,
1924
1983
SO_BINDTODEVICE,
1925
str(self.interface
1926
+ '\0'))
1984
(self.interface + "\0")
1985
.encode("utf-8"))
1927
1986
except socket.error as error:
1928
if error[0] == errno.EPERM:
1929
logger.error("No permission to"
1930
" bind to interface %s",
1931
self.interface)
1932
elif error[0] == errno.ENOPROTOOPT:
1987
if error.errno == errno.EPERM:
1988
logger.error("No permission to bind to"
1989
" interface %s", self.interface)
1990
elif error.errno == errno.ENOPROTOOPT:
1933
1991
logger.error("SO_BINDTODEVICE not available;"
1934
1992
" cannot bind to interface %s",
1935
1993
self.interface)
1994
elif error.errno == errno.ENODEV:
1995
logger.error("Interface %s does not exist,"
1996
" cannot bind", self.interface)
1936
1997
else:
1937
1998
raise
1938
1999
# Only bind(2) the socket if we really need to.
1941
2002
if self.address_family == socket.AF_INET6:
1942
2003
any_address = "::" # in6addr_any
1943
2004
else:
1944
any_address = socket.INADDR_ANY
2005
any_address = "0.0.0.0" # INADDR_ANY
1945
2006
self.server_address = (any_address,
1946
2007
self.server_address[1])
1947
2008
elif not self.server_address[1]:
1968
2029
"""
1969
2030
def __init__(self, server_address, RequestHandlerClass,
1970
2031
interface=None, use_ipv6=True, clients=None,
1971
gnutls_priority=None, use_dbus=True):
2032
gnutls_priority=None, use_dbus=True, socketfd=None):
1972
2033
self.enabled = False
1973
2034
self.clients = clients
1974
2035
if self.clients is None:
1978
2039
IPv6_TCPServer.__init__(self, server_address,
1979
2040
RequestHandlerClass,
1980
2041
interface = interface,
1981
use_ipv6 = use_ipv6)
2042
use_ipv6 = use_ipv6,
2043
socketfd = socketfd)
1982
2044
def server_activate(self):
1983
2045
if self.enabled:
1984
2046
return socketserver.TCPServer.server_activate(self)
2062
2124
return True
2063
2125
2064
2126
2127
def rfc3339_duration_to_delta(duration):
2128
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2129
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)
2144
"""
2145
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.
2152
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"
2158
# containing digits
2159
"value", # datetime.timedelta or
2160
# None
2161
"followers")) # Tokens valid after
2162
# this token
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"),
2176
None,
2177
frozenset((token_hour, token_minute,
2178
token_second)))
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,
2194
token_week)))
2195
# Define starting values
2196
value = datetime.timedelta() # Value so far
2197
found_token = None
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:
2206
# Token found
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)
2214
# Go to found token
2215
found_token = token
2216
# Set valid next tokens
2217
followers = found_token.followers
2218
break
2219
else:
2220
# No currently valid tokens were found
2221
raise ValueError("Invalid RFC 3339 duration")
2222
# End token found
2223
return value
2224
2225
2065
2226
def string_to_delta(interval):
2066
2227
"""Parse a string and return a datetime.timedelta
2067
2228
2078
2239
>>> string_to_delta('5m 30s')
2079
2240
datetime.timedelta(0, 330)
2080
2241
"""
2242
2243
try:
2244
return rfc3339_duration_to_delta(interval)
2245
except ValueError:
2246
pass
2247
2081
2248
timevalue = datetime.timedelta(0)
2082
2249
for s in interval.split():
2083
2250
try:
2084
suffix = unicode(s[-1])
2251
suffix = s[-1]
2085
2252
value = int(s[:-1])
2086
2253
if suffix == "d":
2087
2254
delta = datetime.timedelta(value)
2094
2261
elif suffix == "w":
2095
2262
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2096
2263
else:
2097
raise ValueError("Unknown suffix {0!r}"
2264
raise ValueError("Unknown suffix {!r}"
2098
2265
.format(suffix))
2099
except (ValueError, IndexError) as e:
2266
except IndexError as e:
2100
2267
raise ValueError(*(e.args))
2101
2268
timevalue += delta
2102
2269
return timevalue
2117
2284
# Close all standard open file descriptors
2118
2285
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2119
2286
if not stat.S_ISCHR(os.fstat(null).st_mode):
2120
raise OSError(errno.ENODEV,
2121
"{0} not a character device"
2287
raise OSError(errno.ENODEV, "{} not a character device"
2122
2288
.format(os.devnull))
2123
2289
os.dup2(null, sys.stdin.fileno())
2124
2290
os.dup2(null, sys.stdout.fileno())
2134
2300
2135
2301
parser = argparse.ArgumentParser()
2136
2302
parser.add_argument("-v", "--version", action="version",
2137
version = "%(prog)s {0}".format(version),
2303
version = "%(prog)s {}".format(version),
2138
2304
help="show version number and exit")
2139
2305
parser.add_argument("-i", "--interface", metavar="IF",
2140
2306
help="Bind to interface IF")
2146
2312
help="Run self-test")
2147
2313
parser.add_argument("--debug", action="store_true",
2148
2314
help="Debug mode; run in foreground and log"
2149
" to terminal")
2315
" to terminal", default=None)
2150
2316
parser.add_argument("--debuglevel", metavar="LEVEL",
2151
2317
help="Debug level for stdout output")
2152
2318
parser.add_argument("--priority", help="GnuTLS"
2159
2325
" files")
2160
2326
parser.add_argument("--no-dbus", action="store_false",
2161
2327
dest="use_dbus", help="Do not provide D-Bus"
2162
" system bus interface")
2328
" system bus interface", default=None)
2163
2329
parser.add_argument("--no-ipv6", action="store_false",
2164
dest="use_ipv6", help="Do not use IPv6")
2330
dest="use_ipv6", help="Do not use IPv6",
2331
default=None)
2165
2332
parser.add_argument("--no-restore", action="store_false",
2166
2333
dest="restore", help="Do not restore stored"
2167
" state")
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")
2168
2338
parser.add_argument("--statedir", metavar="DIR",
2169
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",
2344
default=None)
2170
2345
2171
2346
options = parser.parse_args()
2172
2347
2173
2348
if options.check:
2174
2349
import doctest
2175
doctest.testmod()
2176
sys.exit()
2350
fail_count, test_count = doctest.testmod()
2351
sys.exit(os.EX_OK if fail_count == 0 else 1)
2177
2352
2178
2353
# Default values for config file for server-global settings
2179
2354
server_defaults = { "interface": "",
2181
2356
"port": "",
2182
2357
"debug": "False",
2183
2358
"priority":
2184
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2359
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2360
":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2185
2361
"servicename": "Mandos",
2186
2362
"use_dbus": "True",
2187
2363
"use_ipv6": "True",
2188
2364
"debuglevel": "",
2189
2365
"restore": "True",
2190
"statedir": "/var/lib/mandos"
2366
"socket": "",
2367
"statedir": "/var/lib/mandos",
2368
"foreground": "False",
2369
"zeroconf": "True",
2191
2370
}
2192
2371
2193
2372
# Parse config file for server-global settings
2198
2377
# Convert the SafeConfigParser object to a dict
2199
2378
server_settings = server_config.defaults()
2200
2379
# Use the appropriate methods on the non-string config options
2201
for option in ("debug", "use_dbus", "use_ipv6"):
2380
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2202
2381
server_settings[option] = server_config.getboolean("DEFAULT",
2203
2382
option)
2204
2383
if server_settings["port"]:
2205
2384
server_settings["port"] = server_config.getint("DEFAULT",
2206
2385
"port")
2386
if server_settings["socket"]:
2387
server_settings["socket"] = server_config.getint("DEFAULT",
2388
"socket")
2389
# Later, stdin will, and stdout and stderr might, be dup'ed
2390
# over with an opened os.devnull. But we don't want this to
2391
# happen with a supplied network socket.
2392
if 0 <= server_settings["socket"] <= 2:
2393
server_settings["socket"] = os.dup(server_settings
2394
["socket"])
2207
2395
del server_config
2208
2396
2209
2397
# Override the settings from the config file with command line
2211
2399
for option in ("interface", "address", "port", "debug",
2212
2400
"priority", "servicename", "configdir",
2213
2401
"use_dbus", "use_ipv6", "debuglevel", "restore",
2214
"statedir"):
2402
"statedir", "socket", "foreground", "zeroconf"):
2215
2403
value = getattr(options, option)
2216
2404
if value is not None:
2217
2405
server_settings[option] = value
2218
2406
del options
2219
2407
# Force all strings to be unicode
2220
2408
for option in server_settings.keys():
2221
if type(server_settings[option]) is str:
2222
server_settings[option] = unicode(server_settings[option])
2409
if isinstance(server_settings[option], bytes):
2410
server_settings[option] = (server_settings[option]
2411
.decode("utf-8"))
2412
# Force all boolean options to be boolean
2413
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2414
"foreground", "zeroconf"):
2415
server_settings[option] = bool(server_settings[option])
2416
# Debug implies foreground
2417
if server_settings["debug"]:
2418
server_settings["foreground"] = True
2223
2419
# Now we have our good server settings in "server_settings"
2224
2420
2225
2421
##################################################################
2226
2422
2423
if (not server_settings["zeroconf"] and
2424
not (server_settings["port"]
2425
or server_settings["socket"] != "")):
2426
parser.error("Needs port or socket to work without"
2427
" Zeroconf")
2428
2227
2429
# For convenience
2228
2430
debug = server_settings["debug"]
2229
2431
debuglevel = server_settings["debuglevel"]
2231
2433
use_ipv6 = server_settings["use_ipv6"]
2232
2434
stored_state_path = os.path.join(server_settings["statedir"],
2233
2435
stored_state_file)
2436
foreground = server_settings["foreground"]
2437
zeroconf = server_settings["zeroconf"]
2234
2438
2235
2439
if debug:
2236
2440
initlogger(debug, logging.DEBUG)
2243
2447
2244
2448
if server_settings["servicename"] != "Mandos":
2245
2449
syslogger.setFormatter(logging.Formatter
2246
('Mandos ({0}) [%(process)d]:'
2450
('Mandos ({}) [%(process)d]:'
2247
2451
' %(levelname)s: %(message)s'
2248
2452
.format(server_settings
2249
2453
["servicename"])))
2257
2461
global mandos_dbus_service
2258
2462
mandos_dbus_service = None
2259
2463
2464
socketfd = None
2465
if server_settings["socket"] != "":
2466
socketfd = server_settings["socket"]
2260
2467
tcp_server = MandosServer((server_settings["address"],
2261
2468
server_settings["port"]),
2262
2469
ClientHandler,
2265
2472
use_ipv6=use_ipv6,
2266
2473
gnutls_priority=
2267
2474
server_settings["priority"],
2268
use_dbus=use_dbus)
2269
if not debug:
2270
pidfilename = "/var/run/mandos.pid"
2475
use_dbus=use_dbus,
2476
socketfd=socketfd)
2477
if not foreground:
2478
pidfilename = "/run/mandos.pid"
2479
if not os.path.isdir("/run/."):
2480
pidfilename = "/var/run/mandos.pid"
2481
pidfile = None
2271
2482
try:
2272
2483
pidfile = open(pidfilename, "w")
2273
2484
except IOError as e:
2288
2499
os.setgid(gid)
2289
2500
os.setuid(uid)
2290
2501
except OSError as error:
2291
if error[0] != errno.EPERM:
2292
raise error
2502
if error.errno != errno.EPERM:
2503
raise
2293
2504
2294
2505
if debug:
2295
2506
# Enable all possible GnuTLS debugging
2312
2523
os.close(null)
2313
2524
2314
2525
# Need to fork before connecting to D-Bus
2315
if not debug:
2526
if not foreground:
2316
2527
# Close all input and output, do double fork, etc.
2317
2528
daemon()
2318
2529
2530
# multiprocessing will use threads, so before we use gobject we
2531
# need to inform gobject that threads will be used.
2319
2532
gobject.threads_init()
2320
2533
2321
2534
global main_loop
2336
2549
use_dbus = False
2337
2550
server_settings["use_dbus"] = False
2338
2551
tcp_server.use_dbus = False
2339
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2340
service = AvahiServiceToSyslog(name =
2341
server_settings["servicename"],
2342
servicetype = "_mandos._tcp",
2343
protocol = protocol, bus = bus)
2344
if server_settings["interface"]:
2345
service.interface = (if_nametoindex
2346
(str(server_settings["interface"])))
2552
if zeroconf:
2553
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2554
service = AvahiServiceToSyslog(name =
2555
server_settings["servicename"],
2556
servicetype = "_mandos._tcp",
2557
protocol = protocol, bus = bus)
2558
if server_settings["interface"]:
2559
service.interface = (if_nametoindex
2560
(server_settings["interface"]
2561
.encode("utf-8")))
2347
2562
2348
2563
global multiprocessing_manager
2349
2564
multiprocessing_manager = multiprocessing.Manager()
2356
2571
old_client_settings = {}
2357
2572
clients_data = {}
2358
2573
2574
# This is used to redirect stdout and stderr for checker processes
2575
global wnull
2576
wnull = open(os.devnull, "w") # A writable /dev/null
2577
# Only used if server is running in foreground but not in debug
2578
# mode
2579
if debug or not foreground:
2580
wnull.close()
2581
2359
2582
# Get client data and settings from last running state.
2360
2583
if server_settings["restore"]:
2361
2584
try:
2365
2588
os.remove(stored_state_path)
2366
2589
except IOError as e:
2367
2590
if e.errno == errno.ENOENT:
2368
logger.warning("Could not load persistent state: {0}"
2591
logger.warning("Could not load persistent state: {}"
2369
2592
.format(os.strerror(e.errno)))
2370
2593
else:
2371
2594
logger.critical("Could not load persistent state:",
2376
2599
"EOFError:", exc_info=e)
2377
2600
2378
2601
with PGPEngine() as pgp:
2379
for client_name, client in clients_data.iteritems():
2602
for client_name, client in clients_data.items():
2603
# Skip removed clients
2604
if client_name not in client_settings:
2605
continue
2606
2380
2607
# Decide which value to use after restoring saved state.
2381
2608
# We have three different values: Old config file,
2382
2609
# new config file, and saved state.
2403
2630
if datetime.datetime.utcnow() >= client["expires"]:
2404
2631
if not client["last_checked_ok"]:
2405
2632
logger.warning(
2406
"disabling client {0} - Client never "
2633
"disabling client {} - Client never "
2407
2634
"performed a successful checker"
2408
2635
.format(client_name))
2409
2636
client["enabled"] = False
2410
2637
elif client["last_checker_status"] != 0:
2411
2638
logger.warning(
2412
"disabling client {0} - Client "
2413
"last checker failed with error code {1}"
2639
"disabling client {} - Client last"
2640
" checker failed with error code {}"
2414
2641
.format(client_name,
2415
2642
client["last_checker_status"]))
2416
2643
client["enabled"] = False
2419
2646
.utcnow()
2420
2647
+ client["timeout"])
2421
2648
logger.debug("Last checker succeeded,"
2422
" keeping {0} enabled"
2649
" keeping {} enabled"
2423
2650
.format(client_name))
2424
2651
try:
2425
2652
client["secret"] = (
2428
2655
["secret"]))
2429
2656
except PGPError:
2430
2657
# If decryption fails, we use secret from new settings
2431
logger.debug("Failed to decrypt {0} old secret"
2658
logger.debug("Failed to decrypt {} old secret"
2432
2659
.format(client_name))
2433
2660
client["secret"] = (
2434
2661
client_settings[client_name]["secret"])
2442
2669
clients_data[client_name] = client_settings[client_name]
2443
2670
2444
2671
# Create all client objects
2445
for client_name, client in clients_data.iteritems():
2672
for client_name, client in clients_data.items():
2446
2673
tcp_server.clients[client_name] = client_class(
2447
name = client_name, settings = client)
2674
name = client_name, settings = client,
2675
server_settings = server_settings)
2448
2676
2449
2677
if not tcp_server.clients:
2450
2678
logger.warning("No clients defined")
2451
2679
2452
if not debug:
2453
try:
2454
with pidfile:
2455
pid = os.getpid()
2456
pidfile.write(str(pid) + "\n".encode("utf-8"))
2457
del pidfile
2458
except IOError:
2459
logger.error("Could not write to file %r with PID %d",
2460
pidfilename, pid)
2461
except NameError:
2462
# "pidfile" was never created
2463
pass
2680
if not foreground:
2681
if pidfile is not None:
2682
try:
2683
with pidfile:
2684
pid = os.getpid()
2685
pidfile.write("{}\n".format(pid).encode("utf-8"))
2686
except IOError:
2687
logger.error("Could not write to file %r with PID %d",
2688
pidfilename, pid)
2689
del pidfile
2464
2690
del pidfilename
2465
signal.signal(signal.SIGINT, signal.SIG_IGN)
2466
2691
2467
2692
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2468
2693
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2509
2734
def GetAllClientsWithProperties(self):
2510
2735
"D-Bus method"
2511
2736
return dbus.Dictionary(
2512
((c.dbus_object_path, c.GetAll(""))
2513
for c in tcp_server.clients.itervalues()),
2737
{ c.dbus_object_path: c.GetAll("")
2738
for c in tcp_server.clients.itervalues() },
2514
2739
signature="oa{sv}")
2515
2740
2516
2741
@dbus.service.method(_interface, in_signature="o")
2533
2758
2534
2759
def cleanup():
2535
2760
"Cleanup function; run on exit"
2536
service.cleanup()
2761
if zeroconf:
2762
service.cleanup()
2537
2763
2538
2764
multiprocessing.active_children()
2765
wnull.close()
2539
2766
if not (tcp_server.clients or client_settings):
2540
2767
return
2541
2768
2552
2779
2553
2780
# A list of attributes that can not be pickled
2554
2781
# + secret.
2555
exclude = set(("bus", "changedstate", "secret",
2556
"checker"))
2782
exclude = { "bus", "changedstate", "secret",
2783
"checker", "server_settings" }
2557
2784
for name, typ in (inspect.getmembers
2558
2785
(dbus.service.Object)):
2559
2786
exclude.add(name)
2582
2809
except NameError:
2583
2810
pass
2584
2811
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2585
logger.warning("Could not save persistent state: {0}"
2812
logger.warning("Could not save persistent state: {}"
2586
2813
.format(os.strerror(e.errno)))
2587
2814
else:
2588
2815
logger.warning("Could not save persistent state:",
2589
2816
exc_info=e)
2590
raise e
2817
raise
2591
2818
2592
2819
# Delete all clients, and settings from config
2593
2820
while tcp_server.clients:
2617
2844
tcp_server.server_activate()
2618
2845
2619
2846
# Find out what port we got
2620
service.port = tcp_server.socket.getsockname()[1]
2847
if zeroconf:
2848
service.port = tcp_server.socket.getsockname()[1]
2621
2849
if use_ipv6:
2622
2850
logger.info("Now listening on address %r, port %d,"
2623
2851
" flowinfo %d, scope_id %d",
2629
2857
#service.interface = tcp_server.socket.getsockname()[3]
2630
2858
2631
2859
try:
2632
# From the Avahi example code
2633
try:
2634
service.activate()
2635
except dbus.exceptions.DBusException as error:
2636
logger.critical("D-Bus Exception", exc_info=error)
2637
cleanup()
2638
sys.exit(1)
2639
# End of Avahi example code
2860
if zeroconf:
2861
# From the Avahi example code
2862
try:
2863
service.activate()
2864
except dbus.exceptions.DBusException as error:
2865
logger.critical("D-Bus Exception", exc_info=error)
2866
cleanup()
2867
sys.exit(1)
2868
# End of Avahi example code
2640
2869
2641
2870
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2642
2871
lambda *args, **kwargs:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0