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/upstream
- files modified:
- DBUS-API
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-2013 Teddy Hogeborn
15
# Copyright © 2008-2013 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
88
88
except ImportError:
89
89
SO_BINDTODEVICE = None
90
90
91
version = "1.6.2"
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'))
221
225
class AvahiError(Exception):
222
226
def __init__(self, value, *args, **kwargs):
223
227
self.value = value
224
super(AvahiError, self).__init__(value, *args, **kwargs)
225
def __unicode__(self):
226
return unicode(repr(self.value))
228
return super(AvahiError, self).__init__(value, *args,
229
**kwargs)
227
230
228
231
class AvahiServiceError(AvahiError):
229
232
pass
272
275
self.bus = bus
273
276
self.entry_group_state_changed_match = None
274
277
275
def rename(self):
278
def rename(self, remove=True):
276
279
"""Derived from the Avahi example code"""
277
280
if self.rename_count >= self.max_renames:
278
281
logger.critical("No suitable Zeroconf service name found"
279
282
" after %i retries, exiting.",
280
283
self.rename_count)
281
284
raise AvahiServiceError("Too many renames")
282
self.name = unicode(self.server
283
.GetAlternativeServiceName(self.name))
285
self.name = str(self.server
286
.GetAlternativeServiceName(self.name))
287
self.rename_count += 1
284
288
logger.info("Changing Zeroconf service name to %r ...",
285
289
self.name)
286
self.remove()
290
if remove:
291
self.remove()
287
292
try:
288
293
self.add()
289
294
except dbus.exceptions.DBusException as error:
290
logger.critical("D-Bus Exception", exc_info=error)
291
self.cleanup()
292
os._exit(1)
293
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)
294
303
295
304
def remove(self):
296
305
"""Derived from the Avahi example code"""
334
343
self.rename()
335
344
elif state == avahi.ENTRY_GROUP_FAILURE:
336
345
logger.critical("Avahi: Error in group state changed %s",
337
unicode(error))
338
raise AvahiGroupError("State changed: {0!s}"
346
str(error))
347
raise AvahiGroupError("State changed: {!s}"
339
348
.format(error))
340
349
341
350
def cleanup(self):
388
397
389
398
390
399
class AvahiServiceToSyslog(AvahiService):
391
def rename(self):
400
def rename(self, *args, **kwargs):
392
401
"""Add the new name to the syslog messages"""
393
ret = AvahiService.rename(self)
402
ret = AvahiService.rename(self, *args, **kwargs)
394
403
syslogger.setFormatter(logging.Formatter
395
('Mandos ({0}) [%(process)d]:'
404
('Mandos ({}) [%(process)d]:'
396
405
' %(levelname)s: %(message)s'
397
406
.format(self.name)))
398
407
return ret
399
408
400
409
401
def timedelta_to_milliseconds(td):
402
"Convert a datetime.timedelta() to milliseconds"
403
return ((td.days * 24 * 60 * 60 * 1000)
404
+ (td.seconds * 1000)
405
+ (td.microseconds // 1000))
406
407
408
410
class Client(object):
409
411
"""A representation of a client host served by this server.
410
412
465
467
"enabled": "True",
466
468
}
467
469
468
def timeout_milliseconds(self):
469
"Return the 'timeout' attribute in milliseconds"
470
return timedelta_to_milliseconds(self.timeout)
471
472
def extended_timeout_milliseconds(self):
473
"Return the 'extended_timeout' attribute in milliseconds"
474
return timedelta_to_milliseconds(self.extended_timeout)
475
476
def interval_milliseconds(self):
477
"Return the 'interval' attribute in milliseconds"
478
return timedelta_to_milliseconds(self.interval)
479
480
def approval_delay_milliseconds(self):
481
return timedelta_to_milliseconds(self.approval_delay)
482
483
470
@staticmethod
484
471
def config_parser(config):
485
472
"""Construct a new dict of client settings of this form:
500
487
client["enabled"] = config.getboolean(client_name,
501
488
"enabled")
502
489
490
# Uppercase and remove spaces from fingerprint for later
491
# comparison purposes with return value from the
492
# fingerprint() function
503
493
client["fingerprint"] = (section["fingerprint"].upper()
504
494
.replace(" ", ""))
505
495
if "secret" in section:
510
500
"rb") as secfile:
511
501
client["secret"] = secfile.read()
512
502
else:
513
raise TypeError("No secret or secfile for section {0}"
503
raise TypeError("No secret or secfile for section {}"
514
504
.format(section))
515
505
client["timeout"] = string_to_delta(section["timeout"])
516
506
client["extended_timeout"] = string_to_delta(
533
523
server_settings = {}
534
524
self.server_settings = server_settings
535
525
# adding all client settings
536
for setting, value in settings.iteritems():
526
for setting, value in settings.items():
537
527
setattr(self, setting, value)
538
528
539
529
if self.enabled:
547
537
self.expires = None
548
538
549
539
logger.debug("Creating client %r", self.name)
550
# Uppercase and remove spaces from fingerprint for later
551
# comparison purposes with return value from the fingerprint()
552
# function
553
540
logger.debug(" Fingerprint: %s", self.fingerprint)
554
541
self.created = settings.get("created",
555
542
datetime.datetime.utcnow())
622
609
if self.checker_initiator_tag is not None:
623
610
gobject.source_remove(self.checker_initiator_tag)
624
611
self.checker_initiator_tag = (gobject.timeout_add
625
(self.interval_milliseconds(),
612
(int(self.interval
613
.total_seconds() * 1000),
626
614
self.start_checker))
627
615
# Schedule a disable() when 'timeout' has passed
628
616
if self.disable_initiator_tag is not None:
629
617
gobject.source_remove(self.disable_initiator_tag)
630
618
self.disable_initiator_tag = (gobject.timeout_add
631
(self.timeout_milliseconds(),
632
self.disable))
619
(int(self.timeout
620
.total_seconds() * 1000),
621
self.disable))
633
622
# Also start a new checker *right now*.
634
623
self.start_checker()
635
624
666
655
self.disable_initiator_tag = None
667
656
if getattr(self, "enabled", False):
668
657
self.disable_initiator_tag = (gobject.timeout_add
669
(timedelta_to_milliseconds
670
(timeout), self.disable))
658
(int(timeout.total_seconds()
659
* 1000), self.disable))
671
660
self.expires = datetime.datetime.utcnow() + timeout
672
661
673
662
def need_approval(self):
704
693
# Start a new checker if needed
705
694
if self.checker is None:
706
695
# Escape attributes for the shell
707
escaped_attrs = dict(
708
(attr, re.escape(unicode(getattr(self, attr))))
709
for attr in
710
self.runtime_expansions)
696
escaped_attrs = { attr:
697
re.escape(str(getattr(self, attr)))
698
for attr in self.runtime_expansions }
711
699
try:
712
700
command = self.checker_command % escaped_attrs
713
701
except TypeError as error:
794
782
# "Set" method, so we fail early here:
795
783
if byte_arrays and signature != "ay":
796
784
raise ValueError("Byte arrays not supported for non-'ay'"
797
" signature {0!r}".format(signature))
785
" signature {!r}".format(signature))
798
786
def decorator(func):
799
787
func._dbus_is_property = True
800
788
func._dbus_interface = dbus_interface
831
819
"""Decorator to annotate D-Bus methods, signals or properties
832
820
Usage:
833
821
822
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
823
"org.freedesktop.DBus.Property."
824
"EmitsChangedSignal": "false"})
834
825
@dbus_service_property("org.example.Interface", signature="b",
835
826
access="r")
836
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
837
"org.freedesktop.DBus.Property."
838
"EmitsChangedSignal": "false"})
839
827
def Property_dbus_property(self):
840
828
return dbus.Boolean(False)
841
829
"""
848
836
class DBusPropertyException(dbus.exceptions.DBusException):
849
837
"""A base class for D-Bus property-related exceptions
850
838
"""
851
def __unicode__(self):
852
return unicode(str(self))
853
839
pass
854
840
855
841
class DBusPropertyAccessException(DBusPropertyException):
856
842
"""A property's access permissions disallows an operation.
879
865
If called like _is_dbus_thing("method") it returns a function
880
866
suitable for use as predicate to inspect.getmembers().
881
867
"""
882
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
868
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
883
869
False)
884
870
885
871
def _get_all_dbus_things(self, thing):
934
920
# The byte_arrays option is not supported yet on
935
921
# signatures other than "ay".
936
922
if prop._dbus_signature != "ay":
937
raise ValueError
923
raise ValueError("Byte arrays not supported for non-"
924
"'ay' signature {!r}"
925
.format(prop._dbus_signature))
938
926
value = dbus.ByteArray(b''.join(chr(byte)
939
927
for byte in value))
940
928
prop(value)
964
952
value.variant_level+1)
965
953
return dbus.Dictionary(properties, signature="sv")
966
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
967
963
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
968
964
out_signature="s",
969
965
path_keyword='object_path',
1004
1000
(prop,
1005
1001
"_dbus_annotations",
1006
1002
{}))
1007
for name, value in annots.iteritems():
1003
for name, value in annots.items():
1008
1004
ann_tag = document.createElement(
1009
1005
"annotation")
1010
1006
ann_tag.setAttribute("name", name)
1013
1009
# Add interface annotation tags
1014
1010
for annotation, value in dict(
1015
1011
itertools.chain.from_iterable(
1016
annotations().iteritems()
1012
annotations().items()
1017
1013
for name, annotations in
1018
1014
self._get_all_dbus_things("interface")
1019
1015
if name == if_tag.getAttribute("name")
1020
)).iteritems():
1016
)).items():
1021
1017
ann_tag = document.createElement("annotation")
1022
1018
ann_tag.setAttribute("name", annotation)
1023
1019
ann_tag.setAttribute("value", value)
1079
1075
"""
1080
1076
def wrapper(cls):
1081
1077
for orig_interface_name, alt_interface_name in (
1082
alt_interface_names.iteritems()):
1078
alt_interface_names.items()):
1083
1079
attr = {}
1084
1080
interface_names = set()
1085
1081
# Go though all attributes of the class
1202
1198
attribute.func_closure)))
1203
1199
if deprecate:
1204
1200
# Deprecate all alternate interfaces
1205
iname="_AlternateDBusNames_interface_annotation{0}"
1201
iname="_AlternateDBusNames_interface_annotation{}"
1206
1202
for interface_name in interface_names:
1207
1203
@dbus_interface_annotations(interface_name)
1208
1204
def func(self):
1217
1213
if interface_names:
1218
1214
# Replace the class with a new subclass of it with
1219
1215
# methods, signals, etc. as created above.
1220
cls = type(b"{0}Alternate".format(cls.__name__),
1216
cls = type(b"{}Alternate".format(cls.__name__),
1221
1217
(cls,), attr)
1222
1218
return cls
1223
1219
return wrapper
1236
1232
runtime_expansions = (Client.runtime_expansions
1237
1233
+ ("dbus_object_path",))
1238
1234
1235
_interface = "se.recompile.Mandos.Client"
1236
1239
1237
# dbus.service.Object doesn't use super(), so we can't either.
1240
1238
1241
1239
def __init__(self, bus = None, *args, **kwargs):
1243
1241
Client.__init__(self, *args, **kwargs)
1244
1242
# Only now, when this client is initialized, can it show up on
1245
1243
# the D-Bus
1246
client_object_name = unicode(self.name).translate(
1244
client_object_name = str(self.name).translate(
1247
1245
{ord("."): ord("_"),
1248
1246
ord("-"): ord("_")})
1249
1247
self.dbus_object_path = (dbus.ObjectPath
1253
1251
1254
1252
def notifychangeproperty(transform_func,
1255
1253
dbus_name, type_func=lambda x: x,
1256
variant_level=1):
1254
variant_level=1, invalidate_only=False,
1255
_interface=_interface):
1257
1256
""" Modify a variable so that it's a property which announces
1258
1257
its changes to DBus.
1259
1258
1264
1263
to the D-Bus. Default: no transform
1265
1264
variant_level: D-Bus variant level. Default: 1
1266
1265
"""
1267
attrname = "_{0}".format(dbus_name)
1266
attrname = "_{}".format(dbus_name)
1268
1267
def setter(self, value):
1269
1268
if hasattr(self, "dbus_object_path"):
1270
1269
if (not hasattr(self, attrname) or
1271
1270
type_func(getattr(self, attrname, None))
1272
1271
!= type_func(value)):
1273
dbus_value = transform_func(type_func(value),
1274
variant_level
1275
=variant_level)
1276
self.PropertyChanged(dbus.String(dbus_name),
1277
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())
1278
1287
setattr(self, attrname, value)
1279
1288
1280
1289
return property(lambda self: getattr(self, attrname), setter)
1300
1309
approval_delay = notifychangeproperty(dbus.UInt64,
1301
1310
"ApprovalDelay",
1302
1311
type_func =
1303
timedelta_to_milliseconds)
1312
lambda td: td.total_seconds()
1313
* 1000)
1304
1314
approval_duration = notifychangeproperty(
1305
1315
dbus.UInt64, "ApprovalDuration",
1306
type_func = timedelta_to_milliseconds)
1316
type_func = lambda td: td.total_seconds() * 1000)
1307
1317
host = notifychangeproperty(dbus.String, "Host")
1308
1318
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1309
type_func =
1310
timedelta_to_milliseconds)
1319
type_func = lambda td:
1320
td.total_seconds() * 1000)
1311
1321
extended_timeout = notifychangeproperty(
1312
1322
dbus.UInt64, "ExtendedTimeout",
1313
type_func = timedelta_to_milliseconds)
1323
type_func = lambda td: td.total_seconds() * 1000)
1314
1324
interval = notifychangeproperty(dbus.UInt64,
1315
1325
"Interval",
1316
1326
type_func =
1317
timedelta_to_milliseconds)
1327
lambda td: td.total_seconds()
1328
* 1000)
1318
1329
checker_command = notifychangeproperty(dbus.String, "Checker")
1330
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1331
invalidate_only=True)
1319
1332
1320
1333
del notifychangeproperty
1321
1334
1348
1361
*args, **kwargs)
1349
1362
1350
1363
def start_checker(self, *args, **kwargs):
1351
old_checker = self.checker
1352
if self.checker is not None:
1353
old_checker_pid = self.checker.pid
1354
else:
1355
old_checker_pid = None
1364
old_checker_pid = getattr(self.checker, "pid", None)
1356
1365
r = Client.start_checker(self, *args, **kwargs)
1357
1366
# Only if new checker process was started
1358
1367
if (self.checker is not None
1367
1376
1368
1377
def approve(self, value=True):
1369
1378
self.approved = value
1370
gobject.timeout_add(timedelta_to_milliseconds
1371
(self.approval_duration),
1372
self._reset_approved)
1379
gobject.timeout_add(int(self.approval_duration.total_seconds()
1380
* 1000), self._reset_approved)
1373
1381
self.send_changedstate()
1374
1382
1375
1383
## D-Bus methods, signals & properties
1376
_interface = "se.recompile.Mandos.Client"
1377
1384
1378
1385
## Interfaces
1379
1386
1380
@dbus_interface_annotations(_interface)
1381
def _foo(self):
1382
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1383
"false"}
1384
1385
1387
## Signals
1386
1388
1387
1389
# CheckerCompleted - signal
1397
1399
pass
1398
1400
1399
1401
# PropertyChanged - signal
1402
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1400
1403
@dbus.service.signal(_interface, signature="sv")
1401
1404
def PropertyChanged(self, property, value):
1402
1405
"D-Bus signal"
1478
1481
access="readwrite")
1479
1482
def ApprovalDelay_dbus_property(self, value=None):
1480
1483
if value is None: # get
1481
return dbus.UInt64(self.approval_delay_milliseconds())
1484
return dbus.UInt64(self.approval_delay.total_seconds()
1485
* 1000)
1482
1486
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1483
1487
1484
1488
# ApprovalDuration - property
1486
1490
access="readwrite")
1487
1491
def ApprovalDuration_dbus_property(self, value=None):
1488
1492
if value is None: # get
1489
return dbus.UInt64(timedelta_to_milliseconds(
1490
self.approval_duration))
1493
return dbus.UInt64(self.approval_duration.total_seconds()
1494
* 1000)
1491
1495
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1492
1496
1493
1497
# Name - property
1506
1510
def Host_dbus_property(self, value=None):
1507
1511
if value is None: # get
1508
1512
return dbus.String(self.host)
1509
self.host = unicode(value)
1513
self.host = str(value)
1510
1514
1511
1515
# Created - property
1512
1516
@dbus_service_property(_interface, signature="s", access="read")
1559
1563
access="readwrite")
1560
1564
def Timeout_dbus_property(self, value=None):
1561
1565
if value is None: # get
1562
return dbus.UInt64(self.timeout_milliseconds())
1566
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1563
1567
old_timeout = self.timeout
1564
1568
self.timeout = datetime.timedelta(0, 0, 0, value)
1565
1569
# Reschedule disabling
1576
1580
gobject.source_remove(self.disable_initiator_tag)
1577
1581
self.disable_initiator_tag = (
1578
1582
gobject.timeout_add(
1579
timedelta_to_milliseconds(self.expires - now),
1580
self.disable))
1583
int((self.expires - now).total_seconds()
1584
* 1000), self.disable))
1581
1585
1582
1586
# ExtendedTimeout - property
1583
1587
@dbus_service_property(_interface, signature="t",
1584
1588
access="readwrite")
1585
1589
def ExtendedTimeout_dbus_property(self, value=None):
1586
1590
if value is None: # get
1587
return dbus.UInt64(self.extended_timeout_milliseconds())
1591
return dbus.UInt64(self.extended_timeout.total_seconds()
1592
* 1000)
1588
1593
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1589
1594
1590
1595
# Interval - property
1592
1597
access="readwrite")
1593
1598
def Interval_dbus_property(self, value=None):
1594
1599
if value is None: # get
1595
return dbus.UInt64(self.interval_milliseconds())
1600
return dbus.UInt64(self.interval.total_seconds() * 1000)
1596
1601
self.interval = datetime.timedelta(0, 0, 0, value)
1597
1602
if getattr(self, "checker_initiator_tag", None) is None:
1598
1603
return
1609
1614
def Checker_dbus_property(self, value=None):
1610
1615
if value is None: # get
1611
1616
return dbus.String(self.checker_command)
1612
self.checker_command = unicode(value)
1617
self.checker_command = str(value)
1613
1618
1614
1619
# CheckerRunning - property
1615
1620
@dbus_service_property(_interface, signature="b",
1631
1636
@dbus_service_property(_interface, signature="ay",
1632
1637
access="write", byte_arrays=True)
1633
1638
def Secret_dbus_property(self, value):
1634
self.secret = str(value)
1639
self.secret = bytes(value)
1635
1640
1636
1641
del _interface
1637
1642
1671
1676
def handle(self):
1672
1677
with contextlib.closing(self.server.child_pipe) as child_pipe:
1673
1678
logger.info("TCP connection from: %s",
1674
unicode(self.client_address))
1679
str(self.client_address))
1675
1680
logger.debug("Pipe FD: %d",
1676
1681
self.server.child_pipe.fileno())
1677
1682
1758
1763
if self.server.use_dbus:
1759
1764
# Emit D-Bus signal
1760
1765
client.NeedApproval(
1761
client.approval_delay_milliseconds(),
1762
client.approved_by_default)
1766
client.approval_delay.total_seconds()
1767
* 1000, client.approved_by_default)
1763
1768
else:
1764
1769
logger.warning("Client %s was not approved",
1765
1770
client.name)
1771
1776
#wait until timeout or approved
1772
1777
time = datetime.datetime.now()
1773
1778
client.changedstate.acquire()
1774
client.changedstate.wait(
1775
float(timedelta_to_milliseconds(delay)
1776
/ 1000))
1779
client.changedstate.wait(delay.total_seconds())
1777
1780
client.changedstate.release()
1778
1781
time2 = datetime.datetime.now()
1779
1782
if (time2 - time) >= delay:
1978
1981
try:
1979
1982
self.socket.setsockopt(socket.SOL_SOCKET,
1980
1983
SO_BINDTODEVICE,
1981
str(self.interface + '\0'))
1984
(self.interface + "\0")
1985
.encode("utf-8"))
1982
1986
except socket.error as error:
1983
1987
if error.errno == errno.EPERM:
1984
1988
logger.error("No permission to bind to"
2187
2191
token_duration = Token(re.compile(r"P"), None,
2188
2192
frozenset((token_year, token_month,
2189
2193
token_day, token_time,
2190
token_week))),
2194
token_week)))
2191
2195
# Define starting values
2192
2196
value = datetime.timedelta() # Value so far
2193
2197
found_token = None
2194
followers = frozenset(token_duration,) # Following valid tokens
2198
followers = frozenset((token_duration,)) # Following valid tokens
2195
2199
s = duration # String left to parse
2196
2200
# Loop until end token is found
2197
2201
while found_token is not token_end:
2244
2248
timevalue = datetime.timedelta(0)
2245
2249
for s in interval.split():
2246
2250
try:
2247
suffix = unicode(s[-1])
2251
suffix = s[-1]
2248
2252
value = int(s[:-1])
2249
2253
if suffix == "d":
2250
2254
delta = datetime.timedelta(value)
2257
2261
elif suffix == "w":
2258
2262
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2259
2263
else:
2260
raise ValueError("Unknown suffix {0!r}"
2264
raise ValueError("Unknown suffix {!r}"
2261
2265
.format(suffix))
2262
2266
except IndexError as e:
2263
2267
raise ValueError(*(e.args))
2280
2284
# Close all standard open file descriptors
2281
2285
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2282
2286
if not stat.S_ISCHR(os.fstat(null).st_mode):
2283
raise OSError(errno.ENODEV,
2284
"{0} not a character device"
2287
raise OSError(errno.ENODEV, "{} not a character device"
2285
2288
.format(os.devnull))
2286
2289
os.dup2(null, sys.stdin.fileno())
2287
2290
os.dup2(null, sys.stdout.fileno())
2297
2300
2298
2301
parser = argparse.ArgumentParser()
2299
2302
parser.add_argument("-v", "--version", action="version",
2300
version = "%(prog)s {0}".format(version),
2303
version = "%(prog)s {}".format(version),
2301
2304
help="show version number and exit")
2302
2305
parser.add_argument("-i", "--interface", metavar="IF",
2303
2306
help="Bind to interface IF")
2336
2339
help="Directory to save/restore state in")
2337
2340
parser.add_argument("--foreground", action="store_true",
2338
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)
2339
2345
2340
2346
options = parser.parse_args()
2341
2347
2342
2348
if options.check:
2343
2349
import doctest
2344
doctest.testmod()
2345
sys.exit()
2350
fail_count, test_count = doctest.testmod()
2351
sys.exit(os.EX_OK if fail_count == 0 else 1)
2346
2352
2347
2353
# Default values for config file for server-global settings
2348
2354
server_defaults = { "interface": "",
2350
2356
"port": "",
2351
2357
"debug": "False",
2352
2358
"priority":
2353
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2359
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2360
":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2354
2361
"servicename": "Mandos",
2355
2362
"use_dbus": "True",
2356
2363
"use_ipv6": "True",
2359
2366
"socket": "",
2360
2367
"statedir": "/var/lib/mandos",
2361
2368
"foreground": "False",
2369
"zeroconf": "True",
2362
2370
}
2363
2371
2364
2372
# Parse config file for server-global settings
2391
2399
for option in ("interface", "address", "port", "debug",
2392
2400
"priority", "servicename", "configdir",
2393
2401
"use_dbus", "use_ipv6", "debuglevel", "restore",
2394
"statedir", "socket", "foreground"):
2402
"statedir", "socket", "foreground", "zeroconf"):
2395
2403
value = getattr(options, option)
2396
2404
if value is not None:
2397
2405
server_settings[option] = value
2398
2406
del options
2399
2407
# Force all strings to be unicode
2400
2408
for option in server_settings.keys():
2401
if type(server_settings[option]) is str:
2402
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"))
2403
2412
# Force all boolean options to be boolean
2404
2413
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2405
"foreground"):
2414
"foreground", "zeroconf"):
2406
2415
server_settings[option] = bool(server_settings[option])
2407
2416
# Debug implies foreground
2408
2417
if server_settings["debug"]:
2411
2420
2412
2421
##################################################################
2413
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
2414
2429
# For convenience
2415
2430
debug = server_settings["debug"]
2416
2431
debuglevel = server_settings["debuglevel"]
2419
2434
stored_state_path = os.path.join(server_settings["statedir"],
2420
2435
stored_state_file)
2421
2436
foreground = server_settings["foreground"]
2437
zeroconf = server_settings["zeroconf"]
2422
2438
2423
2439
if debug:
2424
2440
initlogger(debug, logging.DEBUG)
2431
2447
2432
2448
if server_settings["servicename"] != "Mandos":
2433
2449
syslogger.setFormatter(logging.Formatter
2434
('Mandos ({0}) [%(process)d]:'
2450
('Mandos ({}) [%(process)d]:'
2435
2451
' %(levelname)s: %(message)s'
2436
2452
.format(server_settings
2437
2453
["servicename"])))
2445
2461
global mandos_dbus_service
2446
2462
mandos_dbus_service = None
2447
2463
2464
socketfd = None
2465
if server_settings["socket"] != "":
2466
socketfd = server_settings["socket"]
2448
2467
tcp_server = MandosServer((server_settings["address"],
2449
2468
server_settings["port"]),
2450
2469
ClientHandler,
2454
2473
gnutls_priority=
2455
2474
server_settings["priority"],
2456
2475
use_dbus=use_dbus,
2457
socketfd=(server_settings["socket"]
2458
or None))
2476
socketfd=socketfd)
2459
2477
if not foreground:
2460
2478
pidfilename = "/run/mandos.pid"
2461
2479
if not os.path.isdir("/run/."):
2531
2549
use_dbus = False
2532
2550
server_settings["use_dbus"] = False
2533
2551
tcp_server.use_dbus = False
2534
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2535
service = AvahiServiceToSyslog(name =
2536
server_settings["servicename"],
2537
servicetype = "_mandos._tcp",
2538
protocol = protocol, bus = bus)
2539
if server_settings["interface"]:
2540
service.interface = (if_nametoindex
2541
(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")))
2542
2562
2543
2563
global multiprocessing_manager
2544
2564
multiprocessing_manager = multiprocessing.Manager()
2568
2588
os.remove(stored_state_path)
2569
2589
except IOError as e:
2570
2590
if e.errno == errno.ENOENT:
2571
logger.warning("Could not load persistent state: {0}"
2591
logger.warning("Could not load persistent state: {}"
2572
2592
.format(os.strerror(e.errno)))
2573
2593
else:
2574
2594
logger.critical("Could not load persistent state:",
2579
2599
"EOFError:", exc_info=e)
2580
2600
2581
2601
with PGPEngine() as pgp:
2582
for client_name, client in clients_data.iteritems():
2602
for client_name, client in clients_data.items():
2583
2603
# Skip removed clients
2584
2604
if client_name not in client_settings:
2585
2605
continue
2610
2630
if datetime.datetime.utcnow() >= client["expires"]:
2611
2631
if not client["last_checked_ok"]:
2612
2632
logger.warning(
2613
"disabling client {0} - Client never "
2633
"disabling client {} - Client never "
2614
2634
"performed a successful checker"
2615
2635
.format(client_name))
2616
2636
client["enabled"] = False
2617
2637
elif client["last_checker_status"] != 0:
2618
2638
logger.warning(
2619
"disabling client {0} - Client "
2620
"last checker failed with error code {1}"
2639
"disabling client {} - Client last"
2640
" checker failed with error code {}"
2621
2641
.format(client_name,
2622
2642
client["last_checker_status"]))
2623
2643
client["enabled"] = False
2626
2646
.utcnow()
2627
2647
+ client["timeout"])
2628
2648
logger.debug("Last checker succeeded,"
2629
" keeping {0} enabled"
2649
" keeping {} enabled"
2630
2650
.format(client_name))
2631
2651
try:
2632
2652
client["secret"] = (
2635
2655
["secret"]))
2636
2656
except PGPError:
2637
2657
# If decryption fails, we use secret from new settings
2638
logger.debug("Failed to decrypt {0} old secret"
2658
logger.debug("Failed to decrypt {} old secret"
2639
2659
.format(client_name))
2640
2660
client["secret"] = (
2641
2661
client_settings[client_name]["secret"])
2649
2669
clients_data[client_name] = client_settings[client_name]
2650
2670
2651
2671
# Create all client objects
2652
for client_name, client in clients_data.iteritems():
2672
for client_name, client in clients_data.items():
2653
2673
tcp_server.clients[client_name] = client_class(
2654
2674
name = client_name, settings = client,
2655
2675
server_settings = server_settings)
2662
2682
try:
2663
2683
with pidfile:
2664
2684
pid = os.getpid()
2665
pidfile.write(str(pid) + "\n".encode("utf-8"))
2685
pidfile.write("{}\n".format(pid).encode("utf-8"))
2666
2686
except IOError:
2667
2687
logger.error("Could not write to file %r with PID %d",
2668
2688
pidfilename, pid)
2714
2734
def GetAllClientsWithProperties(self):
2715
2735
"D-Bus method"
2716
2736
return dbus.Dictionary(
2717
((c.dbus_object_path, c.GetAll(""))
2718
for c in tcp_server.clients.itervalues()),
2737
{ c.dbus_object_path: c.GetAll("")
2738
for c in tcp_server.clients.itervalues() },
2719
2739
signature="oa{sv}")
2720
2740
2721
2741
@dbus.service.method(_interface, in_signature="o")
2738
2758
2739
2759
def cleanup():
2740
2760
"Cleanup function; run on exit"
2741
service.cleanup()
2761
if zeroconf:
2762
service.cleanup()
2742
2763
2743
2764
multiprocessing.active_children()
2744
2765
wnull.close()
2758
2779
2759
2780
# A list of attributes that can not be pickled
2760
2781
# + secret.
2761
exclude = set(("bus", "changedstate", "secret",
2762
"checker", "server_settings"))
2782
exclude = { "bus", "changedstate", "secret",
2783
"checker", "server_settings" }
2763
2784
for name, typ in (inspect.getmembers
2764
2785
(dbus.service.Object)):
2765
2786
exclude.add(name)
2788
2809
except NameError:
2789
2810
pass
2790
2811
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2791
logger.warning("Could not save persistent state: {0}"
2812
logger.warning("Could not save persistent state: {}"
2792
2813
.format(os.strerror(e.errno)))
2793
2814
else:
2794
2815
logger.warning("Could not save persistent state:",
2823
2844
tcp_server.server_activate()
2824
2845
2825
2846
# Find out what port we got
2826
service.port = tcp_server.socket.getsockname()[1]
2847
if zeroconf:
2848
service.port = tcp_server.socket.getsockname()[1]
2827
2849
if use_ipv6:
2828
2850
logger.info("Now listening on address %r, port %d,"
2829
2851
" flowinfo %d, scope_id %d",
2835
2857
#service.interface = tcp_server.socket.getsockname()[3]
2836
2858
2837
2859
try:
2838
# From the Avahi example code
2839
try:
2840
service.activate()
2841
except dbus.exceptions.DBusException as error:
2842
logger.critical("D-Bus Exception", exc_info=error)
2843
cleanup()
2844
sys.exit(1)
2845
# 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
2846
2869
2847
2870
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2848
2871
lambda *args, **kwargs:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0