2
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos server - give out binary blobs to connecting clients.
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
9
# methods "add", "remove", "server_state_changed",
10
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
11
# "AvahiService" class, and some lines in "main".
13
13
# Everything else is
14
# Copyright © 2008-2016 Teddy Hogeborn
15
# Copyright © 2008-2016 Björn Påhlsson
14
# Copyright © 2008-2017 Teddy Hogeborn
15
# Copyright © 2008-2017 Björn Påhlsson
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
19
19
# the Free Software Foundation, either version 3 of the License, or
86
86
import xml.dom.minidom
89
# Try to find the value of SO_BINDTODEVICE:
91
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
92
# newer, and it is also the most natural place for it:
90
93
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
91
94
except AttributeError:
96
# This is where SO_BINDTODEVICE was up to and including Python
93
98
from IN import SO_BINDTODEVICE
94
99
except ImportError:
95
SO_BINDTODEVICE = None
100
# In Python 2.7 it seems to have been removed entirely.
101
# Try running the C preprocessor:
103
cc = subprocess.Popen(["cc", "--language=c", "-E",
105
stdin=subprocess.PIPE,
106
stdout=subprocess.PIPE)
107
stdout = cc.communicate(
108
"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
109
SO_BINDTODEVICE = int(stdout.splitlines()[-1])
110
except (OSError, ValueError, IndexError):
112
SO_BINDTODEVICE = None
97
114
if sys.version_info.major == 2:
101
118
stored_state_file = "clients.pickle"
103
120
logger = logging.getLogger()
227
246
'--passphrase-file',
229
248
+ self.gnupgargs,
230
stdin = subprocess.PIPE,
231
stdout = subprocess.PIPE,
232
stderr = subprocess.PIPE)
233
ciphertext, err = proc.communicate(input = data)
249
stdin=subprocess.PIPE,
250
stdout=subprocess.PIPE,
251
stderr=subprocess.PIPE)
252
ciphertext, err = proc.communicate(input=data)
234
253
if proc.returncode != 0:
235
254
raise PGPError(err)
236
255
return ciphertext
238
257
def decrypt(self, data, password):
239
258
passphrase = self.password_encode(password)
240
259
with tempfile.NamedTemporaryFile(
241
dir = self.tempdir) as passfile:
260
dir=self.tempdir) as passfile:
242
261
passfile.write(passphrase)
244
263
proc = subprocess.Popen([self.gpg, '--decrypt',
245
264
'--passphrase-file',
247
266
+ self.gnupgargs,
248
stdin = subprocess.PIPE,
249
stdout = subprocess.PIPE,
250
stderr = subprocess.PIPE)
251
decrypted_plaintext, err = proc.communicate(input = data)
267
stdin=subprocess.PIPE,
268
stdout=subprocess.PIPE,
269
stderr=subprocess.PIPE)
270
decrypted_plaintext, err = proc.communicate(input=data)
252
271
if proc.returncode != 0:
253
272
raise PGPError(err)
254
273
return decrypted_plaintext
256
276
# Pretend that we have an Avahi module
257
277
class Avahi(object):
258
278
"""This isn't so much a class as it is a module-like namespace.
259
279
It is instantiated once, and simulates having an Avahi module."""
260
IF_UNSPEC = -1 # avahi-common/address.h
261
PROTO_UNSPEC = -1 # avahi-common/address.h
262
PROTO_INET = 0 # avahi-common/address.h
263
PROTO_INET6 = 1 # avahi-common/address.h
280
IF_UNSPEC = -1 # avahi-common/address.h
281
PROTO_UNSPEC = -1 # avahi-common/address.h
282
PROTO_INET = 0 # avahi-common/address.h
283
PROTO_INET6 = 1 # avahi-common/address.h
264
284
DBUS_NAME = "org.freedesktop.Avahi"
265
285
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
266
286
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
267
287
DBUS_PATH_SERVER = "/"
268
289
def string_array_to_txt_array(self, t):
269
290
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
270
291
for s in t), signature="ay")
271
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
272
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
273
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
274
SERVER_INVALID = 0 # avahi-common/defs.h
275
SERVER_REGISTERING = 1 # avahi-common/defs.h
276
SERVER_RUNNING = 2 # avahi-common/defs.h
277
SERVER_COLLISION = 3 # avahi-common/defs.h
278
SERVER_FAILURE = 4 # avahi-common/defs.h
292
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
293
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
294
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
295
SERVER_INVALID = 0 # avahi-common/defs.h
296
SERVER_REGISTERING = 1 # avahi-common/defs.h
297
SERVER_RUNNING = 2 # avahi-common/defs.h
298
SERVER_COLLISION = 3 # avahi-common/defs.h
299
SERVER_FAILURE = 4 # avahi-common/defs.h
281
303
class AvahiError(Exception):
282
304
def __init__(self, value, *args, **kwargs):
283
305
self.value = value
479
501
.format(self.name)))
482
505
# Pretend that we have a GnuTLS module
483
506
class GnuTLS(object):
484
507
"""This isn't so much a class as it is a module-like namespace.
485
508
It is instantiated once, and simulates having a GnuTLS module."""
487
_library = ctypes.cdll.LoadLibrary(
488
ctypes.util.find_library("gnutls"))
510
library = ctypes.util.find_library("gnutls")
512
library = ctypes.util.find_library("gnutls-deb0")
513
_library = ctypes.cdll.LoadLibrary(library)
489
515
_need_version = b"3.3.0"
490
517
def __init__(self):
491
# Need to use class name "GnuTLS" here, since this method is
492
# called before the assignment to the "gnutls" global variable
494
if GnuTLS.check_version(self._need_version) is None:
495
raise GnuTLS.Error("Needs GnuTLS {} or later"
496
.format(self._need_version))
518
# Need to use "self" here, since this method is called before
519
# the assignment to the "gnutls" global variable happens.
520
if self.check_version(self._need_version) is None:
521
raise self.Error("Needs GnuTLS {} or later"
522
.format(self._need_version))
498
524
# Unless otherwise indicated, the constants and types below are
499
525
# all from the gnutls/gnutls.h C header file.
503
529
E_INTERRUPTED = -52
508
534
CRD_CERTIFICATE = 1
509
535
E_NO_CERTIFICATE_FOUND = -49
510
536
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
513
539
class session_int(ctypes.Structure):
515
541
session_t = ctypes.POINTER(session_int)
516
543
class certificate_credentials_st(ctypes.Structure):
518
545
certificate_credentials_t = ctypes.POINTER(
519
546
certificate_credentials_st)
520
547
certificate_type_t = ctypes.c_int
521
549
class datum_t(ctypes.Structure):
522
550
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
523
551
('size', ctypes.c_uint)]
524
553
class openpgp_crt_int(ctypes.Structure):
526
555
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
527
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
556
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
528
557
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
529
558
credentials_type_t = ctypes.c_int
530
559
transport_ptr_t = ctypes.c_void_p
531
560
close_request_t = ctypes.c_int
534
563
class Error(Exception):
535
564
# We need to use the class name "GnuTLS" here, since this
536
565
# exception might be raised from within GnuTLS.__init__,
537
566
# which is called before the assignment to the "gnutls"
538
567
# global variable has happened.
539
def __init__(self, message = None, code = None, args=()):
568
def __init__(self, message=None, code=None, args=()):
540
569
# Default usage is by a message string, but if a return
541
570
# code is passed, convert it to a string with
542
571
# gnutls.strerror()
611
640
return _error_code(result)
612
641
result = func(*arguments)
615
644
# Unless otherwise indicated, the function declarations below are
616
645
# all from the gnutls/gnutls.h C header file.
619
648
priority_set_direct = _library.gnutls_priority_set_direct
620
649
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
621
650
ctypes.POINTER(ctypes.c_char_p)]
622
651
priority_set_direct.restype = _error_code
624
653
init = _library.gnutls_init
625
654
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
626
655
init.restype = _error_code
628
657
set_default_priority = _library.gnutls_set_default_priority
629
658
set_default_priority.argtypes = [session_t]
630
659
set_default_priority.restype = _error_code
632
661
record_send = _library.gnutls_record_send
633
662
record_send.argtypes = [session_t, ctypes.c_void_p,
635
664
record_send.restype = ctypes.c_ssize_t
636
665
record_send.errcheck = _retry_on_error
638
667
certificate_allocate_credentials = (
639
668
_library.gnutls_certificate_allocate_credentials)
640
669
certificate_allocate_credentials.argtypes = [
641
670
ctypes.POINTER(certificate_credentials_t)]
642
671
certificate_allocate_credentials.restype = _error_code
644
673
certificate_free_credentials = (
645
674
_library.gnutls_certificate_free_credentials)
646
certificate_free_credentials.argtypes = [certificate_credentials_t]
675
certificate_free_credentials.argtypes = [
676
certificate_credentials_t]
647
677
certificate_free_credentials.restype = None
649
679
handshake_set_private_extensions = (
650
680
_library.gnutls_handshake_set_private_extensions)
651
681
handshake_set_private_extensions.argtypes = [session_t,
653
683
handshake_set_private_extensions.restype = None
655
685
credentials_set = _library.gnutls_credentials_set
656
686
credentials_set.argtypes = [session_t, credentials_type_t,
658
688
credentials_set.restype = _error_code
660
690
strerror = _library.gnutls_strerror
661
691
strerror.argtypes = [ctypes.c_int]
662
692
strerror.restype = ctypes.c_char_p
664
694
certificate_type_get = _library.gnutls_certificate_type_get
665
695
certificate_type_get.argtypes = [session_t]
666
696
certificate_type_get.restype = _error_code
668
698
certificate_get_peers = _library.gnutls_certificate_get_peers
669
699
certificate_get_peers.argtypes = [session_t,
670
700
ctypes.POINTER(ctypes.c_uint)]
671
701
certificate_get_peers.restype = ctypes.POINTER(datum_t)
673
703
global_set_log_level = _library.gnutls_global_set_log_level
674
704
global_set_log_level.argtypes = [ctypes.c_int]
675
705
global_set_log_level.restype = None
677
707
global_set_log_function = _library.gnutls_global_set_log_function
678
708
global_set_log_function.argtypes = [log_func]
679
709
global_set_log_function.restype = None
681
711
deinit = _library.gnutls_deinit
682
712
deinit.argtypes = [session_t]
683
713
deinit.restype = None
685
715
handshake = _library.gnutls_handshake
686
716
handshake.argtypes = [session_t]
687
717
handshake.restype = _error_code
688
718
handshake.errcheck = _retry_on_error
690
720
transport_set_ptr = _library.gnutls_transport_set_ptr
691
721
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
692
722
transport_set_ptr.restype = None
694
724
bye = _library.gnutls_bye
695
725
bye.argtypes = [session_t, close_request_t]
696
726
bye.restype = _error_code
697
727
bye.errcheck = _retry_on_error
699
729
check_version = _library.gnutls_check_version
700
730
check_version.argtypes = [ctypes.c_char_p]
701
731
check_version.restype = ctypes.c_char_p
703
733
# All the function declarations below are from gnutls/openpgp.h
705
735
openpgp_crt_init = _library.gnutls_openpgp_crt_init
706
736
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
707
737
openpgp_crt_init.restype = _error_code
709
739
openpgp_crt_import = _library.gnutls_openpgp_crt_import
710
740
openpgp_crt_import.argtypes = [openpgp_crt_t,
711
741
ctypes.POINTER(datum_t),
712
742
openpgp_crt_fmt_t]
713
743
openpgp_crt_import.restype = _error_code
715
745
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
716
746
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
717
747
ctypes.POINTER(ctypes.c_uint)]
718
748
openpgp_crt_verify_self.restype = _error_code
720
750
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
721
751
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
722
752
openpgp_crt_deinit.restype = None
724
754
openpgp_crt_get_fingerprint = (
725
755
_library.gnutls_openpgp_crt_get_fingerprint)
726
756
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
1046
1078
# The exception is when not debugging but nevertheless
1047
1079
# running in the foreground; use the previously
1048
1080
# created wnull.
1049
popen_args = { "close_fds": True,
1081
popen_args = {"close_fds": True,
1052
1084
if (not self.server_settings["debug"]
1053
1085
and self.server_settings["foreground"]):
1054
1086
popen_args.update({"stdout": wnull,
1056
pipe = multiprocessing.Pipe(duplex = False)
1088
pipe = multiprocessing.Pipe(duplex=False)
1057
1089
self.checker = multiprocessing.Process(
1059
args = (pipe[1], subprocess.call, command),
1060
kwargs = popen_args)
1091
args=(pipe[1], subprocess.call, command),
1061
1093
self.checker.start()
1062
1094
self.checker_callback_tag = GLib.io_add_watch(
1063
1095
pipe[0].fileno(), GLib.IO_IN,
1064
1096
self.checker_callback, pipe[0], command)
1065
1097
# Re-run this periodically if run by GLib.timeout_add
1068
1100
def stop_checker(self):
1069
1101
"""Force the checker process, if any, to stop."""
1070
1102
if self.checker_callback_tag:
1105
1137
func._dbus_name = func.__name__
1106
1138
if func._dbus_name.endswith("_dbus_property"):
1107
1139
func._dbus_name = func._dbus_name[:-14]
1108
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1140
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1111
1143
return decorator
1114
1146
def dbus_interface_annotations(dbus_interface):
1115
1147
"""Decorator for marking functions returning interface annotations
1119
1151
@dbus_interface_annotations("org.example.Interface")
1120
1152
def _foo(self): # Function name does not matter
1121
1153
return {"org.freedesktop.DBus.Deprecated": "true",
1122
1154
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1126
1158
def decorator(func):
1127
1159
func._dbus_is_interface = True
1128
1160
func._dbus_interface = dbus_interface
1129
1161
func._dbus_name = dbus_interface
1132
1164
return decorator
1135
1167
def dbus_annotations(annotations):
1136
1168
"""Decorator to annotate D-Bus methods, signals or properties
1139
1171
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1140
1172
"org.freedesktop.DBus.Property."
1141
1173
"EmitsChangedSignal": "false"})
1197
1229
for cls in self.__class__.__mro__
1198
1230
for name, athing in
1199
1231
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1201
1233
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1202
out_signature = "s",
1203
path_keyword = 'object_path',
1204
connection_keyword = 'connection')
1235
path_keyword='object_path',
1236
connection_keyword='connection')
1205
1237
def Introspect(self, object_path, connection):
1206
1238
"""Overloading of standard D-Bus method.
1208
1240
Inserts annotation tags on methods and signals.
1210
1242
xmlstring = dbus.service.Object.Introspect(self, object_path,
1213
1245
document = xml.dom.minidom.parseString(xmlstring)
1215
1247
for if_tag in document.getElementsByTagName("interface"):
1216
1248
# Add annotation tags
1217
1249
for typ in ("method", "signal"):
1428
1460
exc_info=error)
1429
1461
return xmlstring
1432
1465
dbus.OBJECT_MANAGER_IFACE
1433
1466
except AttributeError:
1434
1467
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1436
1470
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1437
1471
"""A D-Bus object with an ObjectManager.
1439
1473
Classes inheriting from this exposes the standard
1440
1474
GetManagedObjects call and the InterfacesAdded and
1441
1475
InterfacesRemoved signals on the standard
1442
1476
"org.freedesktop.DBus.ObjectManager" interface.
1444
1478
Note: No signals are sent automatically; they must be sent
1447
1481
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1448
out_signature = "a{oa{sa{sv}}}")
1482
out_signature="a{oa{sa{sv}}}")
1449
1483
def GetManagedObjects(self):
1450
1484
"""This function must be overridden"""
1451
1485
raise NotImplementedError()
1453
1487
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1454
signature = "oa{sa{sv}}")
1488
signature="oa{sa{sv}}")
1455
1489
def InterfacesAdded(self, object_path, interfaces_and_properties):
1458
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1492
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1459
1493
def InterfacesRemoved(self, object_path, interfaces):
1462
1496
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1463
out_signature = "s",
1464
path_keyword = 'object_path',
1465
connection_keyword = 'connection')
1498
path_keyword='object_path',
1499
connection_keyword='connection')
1466
1500
def Introspect(self, object_path, connection):
1467
1501
"""Overloading of standard D-Bus method.
1469
1503
Override return argument name of GetManagedObjects to be
1470
1504
"objpath_interfaces_and_properties"
1509
1544
dbus.service.Object, it will add alternate D-Bus attributes with
1510
1545
interface names according to the "alt_interface_names" mapping.
1513
1548
@alternate_dbus_interfaces({"org.example.Interface":
1514
1549
"net.example.AlternateInterface"})
1515
1550
class SampleDBusObject(dbus.service.Object):
1516
1551
@dbus.service.method("org.example.Interface")
1517
1552
def SampleDBusMethod():
1520
1555
The above "SampleDBusMethod" on "SampleDBusObject" will be
1521
1556
reachable via two interfaces: "org.example.Interface" and
1522
1557
"net.example.AlternateInterface", the latter of which will have
1523
1558
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1524
1559
"true", unless "deprecate" is passed with a False value.
1526
1561
This works for methods and signals, and also for D-Bus properties
1527
1562
(from DBusObjectWithProperties) and interfaces (from the
1528
1563
dbus_interface_annotations decorator).
1531
1566
def wrapper(cls):
1532
1567
for orig_interface_name, alt_interface_name in (
1533
1568
alt_interface_names.items()):
1675
1712
"se.bsnet.fukt.Mandos"})
1676
1713
class ClientDBus(Client, DBusObjectWithProperties):
1677
1714
"""A Client class using D-Bus
1680
1717
dbus_object_path: dbus.ObjectPath
1681
1718
bus: dbus.SystemBus()
1684
1721
runtime_expansions = (Client.runtime_expansions
1685
1722
+ ("dbus_object_path", ))
1687
1724
_interface = "se.recompile.Mandos.Client"
1689
1726
# dbus.service.Object doesn't use super(), so we can't either.
1691
def __init__(self, bus = None, *args, **kwargs):
1728
def __init__(self, bus=None, *args, **kwargs):
1693
1730
Client.__init__(self, *args, **kwargs)
1694
1731
# Only now, when this client is initialized, can it show up on
1731
1768
dbus_value = transform_func(
1732
1769
type_func(value),
1733
variant_level = variant_level)
1770
variant_level=variant_level)
1734
1771
self.PropertyChanged(dbus.String(dbus_name),
1736
1773
self.PropertiesChanged(
1738
dbus.Dictionary({ dbus.String(dbus_name):
1775
dbus.Dictionary({dbus.String(dbus_name):
1741
1778
setattr(self, attrname, value)
1743
1780
return property(lambda self: getattr(self, attrname), setter)
1745
1782
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1746
1783
approvals_pending = notifychangeproperty(dbus.Boolean,
1747
1784
"ApprovalPending",
1749
1786
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1750
1787
last_enabled = notifychangeproperty(datetime_to_dbus,
1752
1789
checker = notifychangeproperty(
1753
1790
dbus.Boolean, "CheckerRunning",
1754
type_func = lambda checker: checker is not None)
1791
type_func=lambda checker: checker is not None)
1755
1792
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1756
1793
"LastCheckedOK")
1757
1794
last_checker_status = notifychangeproperty(dbus.Int16,
1762
1799
"ApprovedByDefault")
1763
1800
approval_delay = notifychangeproperty(
1764
1801
dbus.UInt64, "ApprovalDelay",
1765
type_func = lambda td: td.total_seconds() * 1000)
1802
type_func=lambda td: td.total_seconds() * 1000)
1766
1803
approval_duration = notifychangeproperty(
1767
1804
dbus.UInt64, "ApprovalDuration",
1768
type_func = lambda td: td.total_seconds() * 1000)
1805
type_func=lambda td: td.total_seconds() * 1000)
1769
1806
host = notifychangeproperty(dbus.String, "Host")
1770
1807
timeout = notifychangeproperty(
1771
1808
dbus.UInt64, "Timeout",
1772
type_func = lambda td: td.total_seconds() * 1000)
1809
type_func=lambda td: td.total_seconds() * 1000)
1773
1810
extended_timeout = notifychangeproperty(
1774
1811
dbus.UInt64, "ExtendedTimeout",
1775
type_func = lambda td: td.total_seconds() * 1000)
1812
type_func=lambda td: td.total_seconds() * 1000)
1776
1813
interval = notifychangeproperty(
1777
1814
dbus.UInt64, "Interval",
1778
type_func = lambda td: td.total_seconds() * 1000)
1815
type_func=lambda td: td.total_seconds() * 1000)
1779
1816
checker_command = notifychangeproperty(dbus.String, "Checker")
1780
1817
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1781
1818
invalidate_only=True)
1783
1820
del notifychangeproperty
1785
1822
def __del__(self, *args, **kwargs):
1787
1824
self.remove_from_connection()
1822
1859
# Emit D-Bus signal
1823
1860
self.CheckerStarted(self.current_checker_command)
1826
1863
def _reset_approved(self):
1827
1864
self.approved = None
1830
1867
def approve(self, value=True):
1831
1868
self.approved = value
1832
1869
GLib.timeout_add(int(self.approval_duration.total_seconds()
1833
1870
* 1000), self._reset_approved)
1834
1871
self.send_changedstate()
1836
## D-Bus methods, signals & properties
1873
# D-Bus methods, signals & properties
1842
1879
# CheckerCompleted - signal
1843
1880
@dbus.service.signal(_interface, signature="nxs")
1844
1881
def CheckerCompleted(self, exitcode, waitstatus, command):
1848
1885
# CheckerStarted - signal
1849
1886
@dbus.service.signal(_interface, signature="s")
1850
1887
def CheckerStarted(self, command):
1854
1891
# PropertyChanged - signal
1855
1892
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1856
1893
@dbus.service.signal(_interface, signature="sv")
1857
1894
def PropertyChanged(self, property, value):
1861
1898
# GotSecret - signal
1862
1899
@dbus.service.signal(_interface)
1863
1900
def GotSecret(self):
1866
1903
server to mandos-client
1870
1907
# Rejected - signal
1871
1908
@dbus.service.signal(_interface, signature="s")
1872
1909
def Rejected(self, reason):
1876
1913
# NeedApproval - signal
1877
1914
@dbus.service.signal(_interface, signature="tb")
1878
1915
def NeedApproval(self, timeout, default):
1880
1917
return self.need_approval()
1884
1921
# Approve - method
1885
1922
@dbus.service.method(_interface, in_signature="b")
1886
1923
def Approve(self, value):
1887
1924
self.approve(value)
1889
1926
# CheckedOK - method
1890
1927
@dbus.service.method(_interface)
1891
1928
def CheckedOK(self):
1892
1929
self.checked_ok()
1894
1931
# Enable - method
1895
1932
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1896
1933
@dbus.service.method(_interface)
1897
1934
def Enable(self):
1901
1938
# StartChecker - method
1902
1939
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1903
1940
@dbus.service.method(_interface)
1904
1941
def StartChecker(self):
1906
1943
self.start_checker()
1908
1945
# Disable - method
1909
1946
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1910
1947
@dbus.service.method(_interface)
1911
1948
def Disable(self):
1915
1952
# StopChecker - method
1916
1953
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1917
1954
@dbus.service.method(_interface)
1918
1955
def StopChecker(self):
1919
1956
self.stop_checker()
1923
1960
# ApprovalPending - property
1924
1961
@dbus_service_property(_interface, signature="b", access="read")
1925
1962
def ApprovalPending_dbus_property(self):
1926
1963
return dbus.Boolean(bool(self.approvals_pending))
1928
1965
# ApprovedByDefault - property
1929
1966
@dbus_service_property(_interface,
2010
2047
self.checked_ok()
2012
2049
return datetime_to_dbus(self.last_checked_ok)
2014
2051
# LastCheckerStatus - property
2015
2052
@dbus_service_property(_interface, signature="n", access="read")
2016
2053
def LastCheckerStatus_dbus_property(self):
2017
2054
return dbus.Int16(self.last_checker_status)
2019
2056
# Expires - property
2020
2057
@dbus_service_property(_interface, signature="s", access="read")
2021
2058
def Expires_dbus_property(self):
2022
2059
return datetime_to_dbus(self.expires)
2024
2061
# LastApprovalRequest - property
2025
2062
@dbus_service_property(_interface, signature="s", access="read")
2026
2063
def LastApprovalRequest_dbus_property(self):
2027
2064
return datetime_to_dbus(self.last_approval_request)
2029
2066
# Timeout - property
2030
2067
@dbus_service_property(_interface,
2152
2189
class ClientHandler(socketserver.BaseRequestHandler, object):
2153
2190
"""A class to handle client connections.
2155
2192
Instantiated once for each connection to handle it.
2156
2193
Note: This will run in its own forked process."""
2158
2195
def handle(self):
2159
2196
with contextlib.closing(self.server.child_pipe) as child_pipe:
2160
2197
logger.info("TCP connection from: %s",
2161
2198
str(self.client_address))
2162
2199
logger.debug("Pipe FD: %d",
2163
2200
self.server.child_pipe.fileno())
2165
2202
session = gnutls.ClientSession(self.request)
2167
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2168
# "+AES-256-CBC", "+SHA1",
2169
# "+COMP-NULL", "+CTYPE-OPENPGP",
2204
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2205
# "+AES-256-CBC", "+SHA1",
2206
# "+COMP-NULL", "+CTYPE-OPENPGP",
2171
2208
# Use a fallback default, since this MUST be set.
2172
2209
priority = self.server.gnutls_priority
2173
2210
if priority is None:
2174
2211
priority = "NORMAL"
2175
gnutls.priority_set_direct(session._c_object, priority,
2212
gnutls.priority_set_direct(session._c_object,
2213
priority.encode("utf-8"),
2178
2216
# Start communication using the Mandos protocol
2179
2217
# Get protocol number
2180
2218
line = self.request.makefile().readline()
2345
2383
class MultiprocessingMixIn(object):
2346
2384
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2348
2386
def sub_process_main(self, request, address):
2350
2388
self.finish_request(request, address)
2351
2389
except Exception:
2352
2390
self.handle_error(request, address)
2353
2391
self.close_request(request)
2355
2393
def process_request(self, request, address):
2356
2394
"""Start a new process to process the request."""
2357
proc = multiprocessing.Process(target = self.sub_process_main,
2358
args = (request, address))
2395
proc = multiprocessing.Process(target=self.sub_process_main,
2396
args=(request, address))
2363
2401
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2364
2402
""" adds a pipe to the MixIn """
2366
2404
def process_request(self, request, client_address):
2367
2405
"""Overrides and wraps the original process_request().
2369
2407
This function creates a new pipe in self.pipe
2371
2409
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2373
2411
proc = MultiprocessingMixIn.process_request(self, request,
2374
2412
client_address)
2375
2413
self.child_pipe.close()
2376
2414
self.add_pipe(parent_pipe, proc)
2378
2416
def add_pipe(self, parent_pipe, proc):
2379
2417
"""Dummy function; override as necessary"""
2380
2418
raise NotImplementedError()
2428
2467
# socket_wrapper(), if socketfd was set.
2429
2468
socketserver.TCPServer.__init__(self, server_address,
2430
2469
RequestHandlerClass)
2432
2471
def server_bind(self):
2433
2472
"""This overrides the normal server_bind() function
2434
2473
to bind to an interface if one was specified, and also NOT to
2435
2474
bind to an address or port if they were not specified."""
2475
global SO_BINDTODEVICE
2436
2476
if self.interface is not None:
2437
2477
if SO_BINDTODEVICE is None:
2438
logger.error("SO_BINDTODEVICE does not exist;"
2439
" cannot bind to interface %s",
2443
self.socket.setsockopt(
2444
socket.SOL_SOCKET, SO_BINDTODEVICE,
2445
(self.interface + "\0").encode("utf-8"))
2446
except socket.error as error:
2447
if error.errno == errno.EPERM:
2448
logger.error("No permission to bind to"
2449
" interface %s", self.interface)
2450
elif error.errno == errno.ENOPROTOOPT:
2451
logger.error("SO_BINDTODEVICE not available;"
2452
" cannot bind to interface %s",
2454
elif error.errno == errno.ENODEV:
2455
logger.error("Interface %s does not exist,"
2456
" cannot bind", self.interface)
2478
# Fall back to a hard-coded value which seems to be
2480
logger.warning("SO_BINDTODEVICE not found, trying 25")
2481
SO_BINDTODEVICE = 25
2483
self.socket.setsockopt(
2484
socket.SOL_SOCKET, SO_BINDTODEVICE,
2485
(self.interface + "\0").encode("utf-8"))
2486
except socket.error as error:
2487
if error.errno == errno.EPERM:
2488
logger.error("No permission to bind to"
2489
" interface %s", self.interface)
2490
elif error.errno == errno.ENOPROTOOPT:
2491
logger.error("SO_BINDTODEVICE not available;"
2492
" cannot bind to interface %s",
2494
elif error.errno == errno.ENODEV:
2495
logger.error("Interface %s does not exist,"
2496
" cannot bind", self.interface)
2459
2499
# Only bind(2) the socket if we really need to.
2460
2500
if self.server_address[0] or self.server_address[1]:
2461
2501
if not self.server_address[0]:
2462
2502
if self.address_family == socket.AF_INET6:
2463
any_address = "::" # in6addr_any
2503
any_address = "::" # in6addr_any
2465
any_address = "0.0.0.0" # INADDR_ANY
2505
any_address = "0.0.0.0" # INADDR_ANY
2466
2506
self.server_address = (any_address,
2467
2507
self.server_address[1])
2468
2508
elif not self.server_address[1]:
2502
2542
self.gnutls_priority = gnutls_priority
2503
2543
IPv6_TCPServer.__init__(self, server_address,
2504
2544
RequestHandlerClass,
2505
interface = interface,
2506
use_ipv6 = use_ipv6,
2507
socketfd = socketfd)
2545
interface=interface,
2509
2549
def server_activate(self):
2510
2550
if self.enabled:
2511
2551
return socketserver.TCPServer.server_activate(self)
2513
2553
def enable(self):
2514
2554
self.enabled = True
2516
2556
def add_pipe(self, parent_pipe, proc):
2517
2557
# Call "handle_ipc" for both data and EOF events
2518
2558
GLib.io_add_watch(
2519
2559
parent_pipe.fileno(),
2520
2560
GLib.IO_IN | GLib.IO_HUP,
2521
2561
functools.partial(self.handle_ipc,
2522
parent_pipe = parent_pipe,
2562
parent_pipe=parent_pipe,
2525
2565
def handle_ipc(self, source, condition,
2526
2566
parent_pipe=None,
2528
2568
client_object=None):
2529
2569
# error, or the other end of multiprocessing.Pipe has closed
2530
2570
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2531
2571
# Wait for other process to exit
2535
2575
# Read a request from the child
2536
2576
request = parent_pipe.recv()
2537
2577
command = request[0]
2539
2579
if command == 'init':
2540
2580
fpr = request[1]
2541
2581
address = request[2]
2543
2583
for c in self.clients.values():
2544
2584
if c.fingerprint == fpr:
2609
2649
>>> rfc3339_duration_to_delta("P1DT3M20S")
2610
2650
datetime.timedelta(1, 200)
2613
2653
# Parsing an RFC 3339 duration with regular expressions is not
2614
2654
# possible - there would have to be multiple places for the same
2615
2655
# values, like seconds. The current code, while more esoteric, is
2616
2656
# cleaner without depending on a parsing library. If Python had a
2617
2657
# built-in library for parsing we would use it, but we'd like to
2618
2658
# avoid excessive use of external libraries.
2620
2660
# New type for defining tokens, syntax, and semantics all-in-one
2621
2661
Token = collections.namedtuple("Token", (
2622
2662
"regexp", # To match token; if "value" is not None, must have
2806
2849
parser.add_argument("--no-zeroconf", action="store_false",
2807
2850
dest="zeroconf", help="Do not use Zeroconf",
2810
2853
options = parser.parse_args()
2812
2855
if options.check:
2814
2857
fail_count, test_count = doctest.testmod()
2815
2858
sys.exit(os.EX_OK if fail_count == 0 else 1)
2817
2860
# Default values for config file for server-global settings
2818
server_defaults = { "interface": "",
2823
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2824
":+SIGN-DSA-SHA256",
2825
"servicename": "Mandos",
2831
"statedir": "/var/lib/mandos",
2832
"foreground": "False",
2861
server_defaults = {"interface": "",
2866
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2867
":+SIGN-DSA-SHA256",
2868
"servicename": "Mandos",
2874
"statedir": "/var/lib/mandos",
2875
"foreground": "False",
2836
2879
# Parse config file for server-global settings
2837
2880
server_config = configparser.SafeConfigParser(server_defaults)
2838
2881
del server_defaults
2967
3011
.format(uid, gid, os.strerror(error.errno)))
2968
3012
if error.errno != errno.EPERM:
2972
3016
# Enable all possible GnuTLS debugging
2974
3018
# "Use a log level over 10 to enable all debugging options."
2975
3019
# - GnuTLS manual
2976
3020
gnutls.global_set_log_level(11)
2978
3022
@gnutls.log_func
2979
3023
def debug_gnutls(level, string):
2980
3024
logger.debug("GnuTLS: %s", string[:-1])
2982
3026
gnutls.global_set_log_function(debug_gnutls)
2984
3028
# Redirect stdin so all checkers get /dev/null
2985
3029
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2986
3030
os.dup2(null, sys.stdin.fileno())
2990
3034
# Need to fork before connecting to D-Bus
2991
3035
if not foreground:
2992
3036
# Close all input and output, do double fork, etc.
2995
3039
# multiprocessing will use threads, so before we use GLib we need
2996
3040
# to inform GLib that threads will be used.
2997
3041
GLib.threads_init()
2999
3043
global main_loop
3000
3044
# From the Avahi example code
3001
3045
DBusGMainLoop(set_as_default=True)
3019
3063
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3020
3064
service = AvahiServiceToSyslog(
3021
name = server_settings["servicename"],
3022
servicetype = "_mandos._tcp",
3023
protocol = protocol,
3065
name=server_settings["servicename"],
3066
servicetype="_mandos._tcp",
3025
3069
if server_settings["interface"]:
3026
3070
service.interface = if_nametoindex(
3027
3071
server_settings["interface"].encode("utf-8"))
3029
3073
global multiprocessing_manager
3030
3074
multiprocessing_manager = multiprocessing.Manager()
3032
3076
client_class = Client
3034
client_class = functools.partial(ClientDBus, bus = bus)
3078
client_class = functools.partial(ClientDBus, bus=bus)
3036
3080
client_settings = Client.config_parser(client_config)
3037
3081
old_client_settings = {}
3038
3082
clients_data = {}
3040
3084
# This is used to redirect stdout and stderr for checker processes
3042
wnull = open(os.devnull, "w") # A writable /dev/null
3086
wnull = open(os.devnull, "w") # A writable /dev/null
3043
3087
# Only used if server is running in foreground but not in debug
3045
3089
if debug or not foreground:
3048
3092
# Get client data and settings from last running state.
3049
3093
if server_settings["restore"]:
3051
3095
with open(stored_state_path, "rb") as stored_state:
3052
if sys.version_info.major == 2:
3096
if sys.version_info.major == 2:
3053
3097
clients_data, old_client_settings = pickle.load(
3056
3100
bytes_clients_data, bytes_old_client_settings = (
3057
pickle.load(stored_state, encoding = "bytes"))
3058
### Fix bytes to strings
3101
pickle.load(stored_state, encoding="bytes"))
3102
# Fix bytes to strings
3061
clients_data = { (key.decode("utf-8")
3062
if isinstance(key, bytes)
3065
bytes_clients_data.items() }
3105
clients_data = {(key.decode("utf-8")
3106
if isinstance(key, bytes)
3109
bytes_clients_data.items()}
3066
3110
del bytes_clients_data
3067
3111
for key in clients_data:
3068
value = { (k.decode("utf-8")
3069
if isinstance(k, bytes) else k): v
3071
clients_data[key].items() }
3112
value = {(k.decode("utf-8")
3113
if isinstance(k, bytes) else k): v
3115
clients_data[key].items()}
3072
3116
clients_data[key] = value
3073
3117
# .client_structure
3074
3118
value["client_structure"] = [
3075
3119
(s.decode("utf-8")
3076
3120
if isinstance(s, bytes)
3077
3121
else s) for s in
3078
value["client_structure"] ]
3122
value["client_structure"]]
3079
3123
# .name & .host
3080
3124
for k in ("name", "host"):
3081
3125
if isinstance(value[k], bytes):
3082
3126
value[k] = value[k].decode("utf-8")
3083
## old_client_settings
3127
# old_client_settings
3085
3129
old_client_settings = {
3086
3130
(key.decode("utf-8")
3087
3131
if isinstance(key, bytes)
3088
3132
else key): value
3089
3133
for key, value in
3090
bytes_old_client_settings.items() }
3134
bytes_old_client_settings.items()}
3091
3135
del bytes_old_client_settings
3093
3137
for value in old_client_settings.values():
3199
3243
pidfilename, pid)
3201
3245
del pidfilename
3203
3247
for termsig in (signal.SIGHUP, signal.SIGTERM):
3204
3248
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3205
3249
lambda: main_loop.quit() and False)
3209
3253
@alternate_dbus_interfaces(
3210
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3254
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3211
3255
class MandosDBusService(DBusObjectWithObjectManager):
3212
3256
"""A D-Bus proxy object"""
3214
3258
def __init__(self):
3215
3259
dbus.service.Object.__init__(self, bus, "/")
3217
3261
_interface = "se.recompile.Mandos"
3219
3263
@dbus.service.signal(_interface, signature="o")
3220
3264
def ClientAdded(self, objpath):
3224
3268
@dbus.service.signal(_interface, signature="ss")
3225
3269
def ClientNotFound(self, fingerprint, address):
3229
3273
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3231
3275
@dbus.service.signal(_interface, signature="os")
3232
3276
def ClientRemoved(self, objpath, name):
3236
3280
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3238
3282
@dbus.service.method(_interface, out_signature="ao")
3266
3310
self.client_removed_signal(c)
3268
3312
raise KeyError(object_path)
3272
3316
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3273
out_signature = "a{oa{sa{sv}}}")
3317
out_signature="a{oa{sa{sv}}}")
3274
3318
def GetManagedObjects(self):
3275
3319
"""D-Bus method"""
3276
3320
return dbus.Dictionary(
3277
{ client.dbus_object_path:
3279
{ interface: client.GetAll(interface)
3281
client._get_all_interface_names()})
3282
for client in tcp_server.clients.values()})
3321
{client.dbus_object_path:
3323
{interface: client.GetAll(interface)
3325
client._get_all_interface_names()})
3326
for client in tcp_server.clients.values()})
3284
3328
def client_added_signal(self, client):
3285
3329
"""Send the new standard signal and the old signal"""
3327
3376
client.encrypted_secret = pgp.encrypt(client.secret,
3329
3378
client_dict = {}
3331
3380
# A list of attributes that can not be pickled
3333
exclude = { "bus", "changedstate", "secret",
3334
"checker", "server_settings" }
3382
exclude = {"bus", "changedstate", "secret",
3383
"checker", "server_settings"}
3335
3384
for name, typ in inspect.getmembers(dbus.service
3337
3386
exclude.add(name)
3339
3388
client_dict["encrypted_secret"] = (client
3340
3389
.encrypted_secret)
3341
3390
for attr in client.client_structure:
3342
3391
if attr not in exclude:
3343
3392
client_dict[attr] = getattr(client, attr)
3345
3394
clients[client.name] = client_dict
3346
3395
del client_settings[client.name]["secret"]
3349
3398
with tempfile.NamedTemporaryFile(