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-2018 Teddy Hogeborn
15
# Copyright © 2008-2018 Björn Påhlsson
17
# This file is part of Mandos.
19
# Mandos is free software: you can redistribute it and/or modify it
20
# under the terms of the GNU General Public License as published by
14
# Copyright © 2008-2016 Teddy Hogeborn
15
# Copyright © 2008-2016 Björn Påhlsson
17
# This program is free software: you can redistribute it and/or modify
18
# it under the terms of the GNU General Public License as published by
21
19
# the Free Software Foundation, either version 3 of the License, or
22
20
# (at your option) any later version.
24
# Mandos is distributed in the hope that it will be useful, but
25
# WITHOUT ANY WARRANTY; without even the implied warranty of
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
26
24
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27
25
# GNU General Public License for more details.
29
27
# You should have received a copy of the GNU General Public License
30
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
32
31
# Contact the authors at <mandos@recompile.se>.
35
34
from __future__ import (division, absolute_import, print_function,
247
246
'--passphrase-file',
249
248
+ self.gnupgargs,
250
stdin=subprocess.PIPE,
251
stdout=subprocess.PIPE,
252
stderr=subprocess.PIPE)
253
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)
254
253
if proc.returncode != 0:
255
254
raise PGPError(err)
256
255
return ciphertext
258
257
def decrypt(self, data, password):
259
258
passphrase = self.password_encode(password)
260
259
with tempfile.NamedTemporaryFile(
261
dir=self.tempdir) as passfile:
260
dir = self.tempdir) as passfile:
262
261
passfile.write(passphrase)
264
263
proc = subprocess.Popen([self.gpg, '--decrypt',
265
264
'--passphrase-file',
267
266
+ self.gnupgargs,
268
stdin=subprocess.PIPE,
269
stdout=subprocess.PIPE,
270
stderr=subprocess.PIPE)
271
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)
272
271
if proc.returncode != 0:
273
272
raise PGPError(err)
274
273
return decrypted_plaintext
277
275
# Pretend that we have an Avahi module
278
276
class Avahi(object):
279
277
"""This isn't so much a class as it is a module-like namespace.
280
278
It is instantiated once, and simulates having an Avahi module."""
281
IF_UNSPEC = -1 # avahi-common/address.h
282
PROTO_UNSPEC = -1 # avahi-common/address.h
283
PROTO_INET = 0 # avahi-common/address.h
284
PROTO_INET6 = 1 # avahi-common/address.h
279
IF_UNSPEC = -1 # avahi-common/address.h
280
PROTO_UNSPEC = -1 # avahi-common/address.h
281
PROTO_INET = 0 # avahi-common/address.h
282
PROTO_INET6 = 1 # avahi-common/address.h
285
283
DBUS_NAME = "org.freedesktop.Avahi"
286
284
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
287
285
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
288
286
DBUS_PATH_SERVER = "/"
290
287
def string_array_to_txt_array(self, t):
291
288
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
292
289
for s in t), signature="ay")
293
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
294
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
295
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
296
SERVER_INVALID = 0 # avahi-common/defs.h
297
SERVER_REGISTERING = 1 # avahi-common/defs.h
298
SERVER_RUNNING = 2 # avahi-common/defs.h
299
SERVER_COLLISION = 3 # avahi-common/defs.h
300
SERVER_FAILURE = 4 # avahi-common/defs.h
290
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
291
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
292
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
293
SERVER_INVALID = 0 # avahi-common/defs.h
294
SERVER_REGISTERING = 1 # avahi-common/defs.h
295
SERVER_RUNNING = 2 # avahi-common/defs.h
296
SERVER_COLLISION = 3 # avahi-common/defs.h
297
SERVER_FAILURE = 4 # avahi-common/defs.h
304
300
class AvahiError(Exception):
305
301
def __init__(self, value, *args, **kwargs):
306
302
self.value = value
496
492
class AvahiServiceToSyslog(AvahiService):
497
493
def rename(self, *args, **kwargs):
498
494
"""Add the new name to the syslog messages"""
499
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
495
ret = AvahiService.rename(self, *args, **kwargs)
500
496
syslogger.setFormatter(logging.Formatter(
501
497
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
502
498
.format(self.name)))
506
501
# Pretend that we have a GnuTLS module
507
502
class GnuTLS(object):
508
503
"""This isn't so much a class as it is a module-like namespace.
509
504
It is instantiated once, and simulates having a GnuTLS module."""
511
library = ctypes.util.find_library("gnutls")
513
library = ctypes.util.find_library("gnutls-deb0")
514
_library = ctypes.cdll.LoadLibrary(library)
506
_library = ctypes.cdll.LoadLibrary(
507
ctypes.util.find_library("gnutls"))
516
508
_need_version = b"3.3.0"
518
509
def __init__(self):
519
# Need to use "self" here, since this method is called before
520
# the assignment to the "gnutls" global variable happens.
521
if self.check_version(self._need_version) is None:
522
raise self.Error("Needs GnuTLS {} or later"
523
.format(self._need_version))
510
# Need to use class name "GnuTLS" here, since this method is
511
# called before the assignment to the "gnutls" global variable
513
if GnuTLS.check_version(self._need_version) is None:
514
raise GnuTLS.Error("Needs GnuTLS {} or later"
515
.format(self._need_version))
525
517
# Unless otherwise indicated, the constants and types below are
526
518
# all from the gnutls/gnutls.h C header file.
530
522
E_INTERRUPTED = -52
535
527
CRD_CERTIFICATE = 1
536
528
E_NO_CERTIFICATE_FOUND = -49
537
529
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
540
532
class session_int(ctypes.Structure):
542
534
session_t = ctypes.POINTER(session_int)
544
535
class certificate_credentials_st(ctypes.Structure):
546
537
certificate_credentials_t = ctypes.POINTER(
547
538
certificate_credentials_st)
548
539
certificate_type_t = ctypes.c_int
550
540
class datum_t(ctypes.Structure):
551
541
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
552
542
('size', ctypes.c_uint)]
554
543
class openpgp_crt_int(ctypes.Structure):
556
545
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
557
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
546
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
558
547
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
559
548
credentials_type_t = ctypes.c_int
560
549
transport_ptr_t = ctypes.c_void_p
561
550
close_request_t = ctypes.c_int
564
553
class Error(Exception):
565
554
# We need to use the class name "GnuTLS" here, since this
566
555
# exception might be raised from within GnuTLS.__init__,
567
556
# which is called before the assignment to the "gnutls"
568
557
# global variable has happened.
569
def __init__(self, message=None, code=None, args=()):
558
def __init__(self, message = None, code = None, args=()):
570
559
# Default usage is by a message string, but if a return
571
560
# code is passed, convert it to a string with
572
561
# gnutls.strerror()
641
630
return _error_code(result)
642
631
result = func(*arguments)
645
634
# Unless otherwise indicated, the function declarations below are
646
635
# all from the gnutls/gnutls.h C header file.
649
638
priority_set_direct = _library.gnutls_priority_set_direct
650
639
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
651
640
ctypes.POINTER(ctypes.c_char_p)]
652
641
priority_set_direct.restype = _error_code
654
643
init = _library.gnutls_init
655
644
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
656
645
init.restype = _error_code
658
647
set_default_priority = _library.gnutls_set_default_priority
659
648
set_default_priority.argtypes = [session_t]
660
649
set_default_priority.restype = _error_code
662
651
record_send = _library.gnutls_record_send
663
652
record_send.argtypes = [session_t, ctypes.c_void_p,
665
654
record_send.restype = ctypes.c_ssize_t
666
655
record_send.errcheck = _retry_on_error
668
657
certificate_allocate_credentials = (
669
658
_library.gnutls_certificate_allocate_credentials)
670
659
certificate_allocate_credentials.argtypes = [
671
660
ctypes.POINTER(certificate_credentials_t)]
672
661
certificate_allocate_credentials.restype = _error_code
674
663
certificate_free_credentials = (
675
664
_library.gnutls_certificate_free_credentials)
676
certificate_free_credentials.argtypes = [
677
certificate_credentials_t]
665
certificate_free_credentials.argtypes = [certificate_credentials_t]
678
666
certificate_free_credentials.restype = None
680
668
handshake_set_private_extensions = (
681
669
_library.gnutls_handshake_set_private_extensions)
682
670
handshake_set_private_extensions.argtypes = [session_t,
684
672
handshake_set_private_extensions.restype = None
686
674
credentials_set = _library.gnutls_credentials_set
687
675
credentials_set.argtypes = [session_t, credentials_type_t,
689
677
credentials_set.restype = _error_code
691
679
strerror = _library.gnutls_strerror
692
680
strerror.argtypes = [ctypes.c_int]
693
681
strerror.restype = ctypes.c_char_p
695
683
certificate_type_get = _library.gnutls_certificate_type_get
696
684
certificate_type_get.argtypes = [session_t]
697
685
certificate_type_get.restype = _error_code
699
687
certificate_get_peers = _library.gnutls_certificate_get_peers
700
688
certificate_get_peers.argtypes = [session_t,
701
689
ctypes.POINTER(ctypes.c_uint)]
702
690
certificate_get_peers.restype = ctypes.POINTER(datum_t)
704
692
global_set_log_level = _library.gnutls_global_set_log_level
705
693
global_set_log_level.argtypes = [ctypes.c_int]
706
694
global_set_log_level.restype = None
708
696
global_set_log_function = _library.gnutls_global_set_log_function
709
697
global_set_log_function.argtypes = [log_func]
710
698
global_set_log_function.restype = None
712
700
deinit = _library.gnutls_deinit
713
701
deinit.argtypes = [session_t]
714
702
deinit.restype = None
716
704
handshake = _library.gnutls_handshake
717
705
handshake.argtypes = [session_t]
718
706
handshake.restype = _error_code
719
707
handshake.errcheck = _retry_on_error
721
709
transport_set_ptr = _library.gnutls_transport_set_ptr
722
710
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
723
711
transport_set_ptr.restype = None
725
713
bye = _library.gnutls_bye
726
714
bye.argtypes = [session_t, close_request_t]
727
715
bye.restype = _error_code
728
716
bye.errcheck = _retry_on_error
730
718
check_version = _library.gnutls_check_version
731
719
check_version.argtypes = [ctypes.c_char_p]
732
720
check_version.restype = ctypes.c_char_p
734
722
# All the function declarations below are from gnutls/openpgp.h
736
724
openpgp_crt_init = _library.gnutls_openpgp_crt_init
737
725
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
738
726
openpgp_crt_init.restype = _error_code
740
728
openpgp_crt_import = _library.gnutls_openpgp_crt_import
741
729
openpgp_crt_import.argtypes = [openpgp_crt_t,
742
730
ctypes.POINTER(datum_t),
743
731
openpgp_crt_fmt_t]
744
732
openpgp_crt_import.restype = _error_code
746
734
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
747
735
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
748
736
ctypes.POINTER(ctypes.c_uint)]
749
737
openpgp_crt_verify_self.restype = _error_code
751
739
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
752
740
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
753
741
openpgp_crt_deinit.restype = None
755
743
openpgp_crt_get_fingerprint = (
756
744
_library.gnutls_openpgp_crt_get_fingerprint)
757
745
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
1079
1065
# The exception is when not debugging but nevertheless
1080
1066
# running in the foreground; use the previously
1081
1067
# created wnull.
1082
popen_args = {"close_fds": True,
1068
popen_args = { "close_fds": True,
1085
1071
if (not self.server_settings["debug"]
1086
1072
and self.server_settings["foreground"]):
1087
1073
popen_args.update({"stdout": wnull,
1089
pipe = multiprocessing.Pipe(duplex=False)
1075
pipe = multiprocessing.Pipe(duplex = False)
1090
1076
self.checker = multiprocessing.Process(
1092
args=(pipe[1], subprocess.call, command),
1078
args = (pipe[1], subprocess.call, command),
1079
kwargs = popen_args)
1094
1080
self.checker.start()
1095
1081
self.checker_callback_tag = GLib.io_add_watch(
1096
1082
pipe[0].fileno(), GLib.IO_IN,
1097
1083
self.checker_callback, pipe[0], command)
1098
1084
# Re-run this periodically if run by GLib.timeout_add
1101
1087
def stop_checker(self):
1102
1088
"""Force the checker process, if any, to stop."""
1103
1089
if self.checker_callback_tag:
1138
1124
func._dbus_name = func.__name__
1139
1125
if func._dbus_name.endswith("_dbus_property"):
1140
1126
func._dbus_name = func._dbus_name[:-14]
1141
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1127
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1144
1130
return decorator
1147
1133
def dbus_interface_annotations(dbus_interface):
1148
1134
"""Decorator for marking functions returning interface annotations
1152
1138
@dbus_interface_annotations("org.example.Interface")
1153
1139
def _foo(self): # Function name does not matter
1154
1140
return {"org.freedesktop.DBus.Deprecated": "true",
1155
1141
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1159
1145
def decorator(func):
1160
1146
func._dbus_is_interface = True
1161
1147
func._dbus_interface = dbus_interface
1162
1148
func._dbus_name = dbus_interface
1165
1151
return decorator
1168
1154
def dbus_annotations(annotations):
1169
1155
"""Decorator to annotate D-Bus methods, signals or properties
1172
1158
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1173
1159
"org.freedesktop.DBus.Property."
1174
1160
"EmitsChangedSignal": "false"})
1230
1216
for cls in self.__class__.__mro__
1231
1217
for name, athing in
1232
1218
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1234
1220
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1236
path_keyword='object_path',
1237
connection_keyword='connection')
1221
out_signature = "s",
1222
path_keyword = 'object_path',
1223
connection_keyword = 'connection')
1238
1224
def Introspect(self, object_path, connection):
1239
1225
"""Overloading of standard D-Bus method.
1241
1227
Inserts annotation tags on methods and signals.
1243
1229
xmlstring = dbus.service.Object.Introspect(self, object_path,
1246
1232
document = xml.dom.minidom.parseString(xmlstring)
1248
1234
for if_tag in document.getElementsByTagName("interface"):
1249
1235
# Add annotation tags
1250
1236
for typ in ("method", "signal"):
1461
1447
exc_info=error)
1462
1448
return xmlstring
1466
1451
dbus.OBJECT_MANAGER_IFACE
1467
1452
except AttributeError:
1468
1453
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1471
1455
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1472
1456
"""A D-Bus object with an ObjectManager.
1474
1458
Classes inheriting from this exposes the standard
1475
1459
GetManagedObjects call and the InterfacesAdded and
1476
1460
InterfacesRemoved signals on the standard
1477
1461
"org.freedesktop.DBus.ObjectManager" interface.
1479
1463
Note: No signals are sent automatically; they must be sent
1482
1466
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1483
out_signature="a{oa{sa{sv}}}")
1467
out_signature = "a{oa{sa{sv}}}")
1484
1468
def GetManagedObjects(self):
1485
1469
"""This function must be overridden"""
1486
1470
raise NotImplementedError()
1488
1472
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1489
signature="oa{sa{sv}}")
1473
signature = "oa{sa{sv}}")
1490
1474
def InterfacesAdded(self, object_path, interfaces_and_properties):
1493
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1477
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1494
1478
def InterfacesRemoved(self, object_path, interfaces):
1497
1481
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1499
path_keyword='object_path',
1500
connection_keyword='connection')
1482
out_signature = "s",
1483
path_keyword = 'object_path',
1484
connection_keyword = 'connection')
1501
1485
def Introspect(self, object_path, connection):
1502
1486
"""Overloading of standard D-Bus method.
1504
1488
Override return argument name of GetManagedObjects to be
1505
1489
"objpath_interfaces_and_properties"
1545
1528
dbus.service.Object, it will add alternate D-Bus attributes with
1546
1529
interface names according to the "alt_interface_names" mapping.
1549
1532
@alternate_dbus_interfaces({"org.example.Interface":
1550
1533
"net.example.AlternateInterface"})
1551
1534
class SampleDBusObject(dbus.service.Object):
1552
1535
@dbus.service.method("org.example.Interface")
1553
1536
def SampleDBusMethod():
1556
1539
The above "SampleDBusMethod" on "SampleDBusObject" will be
1557
1540
reachable via two interfaces: "org.example.Interface" and
1558
1541
"net.example.AlternateInterface", the latter of which will have
1559
1542
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1560
1543
"true", unless "deprecate" is passed with a False value.
1562
1545
This works for methods and signals, and also for D-Bus properties
1563
1546
(from DBusObjectWithProperties) and interfaces (from the
1564
1547
dbus_interface_annotations decorator).
1567
1550
def wrapper(cls):
1568
1551
for orig_interface_name, alt_interface_name in (
1569
1552
alt_interface_names.items()):
1713
1694
"se.bsnet.fukt.Mandos"})
1714
1695
class ClientDBus(Client, DBusObjectWithProperties):
1715
1696
"""A Client class using D-Bus
1718
1699
dbus_object_path: dbus.ObjectPath
1719
1700
bus: dbus.SystemBus()
1722
1703
runtime_expansions = (Client.runtime_expansions
1723
1704
+ ("dbus_object_path", ))
1725
1706
_interface = "se.recompile.Mandos.Client"
1727
1708
# dbus.service.Object doesn't use super(), so we can't either.
1729
def __init__(self, bus=None, *args, **kwargs):
1710
def __init__(self, bus = None, *args, **kwargs):
1731
1712
Client.__init__(self, *args, **kwargs)
1732
1713
# Only now, when this client is initialized, can it show up on
1769
1750
dbus_value = transform_func(
1770
1751
type_func(value),
1771
variant_level=variant_level)
1752
variant_level = variant_level)
1772
1753
self.PropertyChanged(dbus.String(dbus_name),
1774
1755
self.PropertiesChanged(
1776
dbus.Dictionary({dbus.String(dbus_name):
1757
dbus.Dictionary({ dbus.String(dbus_name):
1779
1760
setattr(self, attrname, value)
1781
1762
return property(lambda self: getattr(self, attrname), setter)
1783
1764
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1784
1765
approvals_pending = notifychangeproperty(dbus.Boolean,
1785
1766
"ApprovalPending",
1787
1768
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1788
1769
last_enabled = notifychangeproperty(datetime_to_dbus,
1790
1771
checker = notifychangeproperty(
1791
1772
dbus.Boolean, "CheckerRunning",
1792
type_func=lambda checker: checker is not None)
1773
type_func = lambda checker: checker is not None)
1793
1774
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1794
1775
"LastCheckedOK")
1795
1776
last_checker_status = notifychangeproperty(dbus.Int16,
1800
1781
"ApprovedByDefault")
1801
1782
approval_delay = notifychangeproperty(
1802
1783
dbus.UInt64, "ApprovalDelay",
1803
type_func=lambda td: td.total_seconds() * 1000)
1784
type_func = lambda td: td.total_seconds() * 1000)
1804
1785
approval_duration = notifychangeproperty(
1805
1786
dbus.UInt64, "ApprovalDuration",
1806
type_func=lambda td: td.total_seconds() * 1000)
1787
type_func = lambda td: td.total_seconds() * 1000)
1807
1788
host = notifychangeproperty(dbus.String, "Host")
1808
1789
timeout = notifychangeproperty(
1809
1790
dbus.UInt64, "Timeout",
1810
type_func=lambda td: td.total_seconds() * 1000)
1791
type_func = lambda td: td.total_seconds() * 1000)
1811
1792
extended_timeout = notifychangeproperty(
1812
1793
dbus.UInt64, "ExtendedTimeout",
1813
type_func=lambda td: td.total_seconds() * 1000)
1794
type_func = lambda td: td.total_seconds() * 1000)
1814
1795
interval = notifychangeproperty(
1815
1796
dbus.UInt64, "Interval",
1816
type_func=lambda td: td.total_seconds() * 1000)
1797
type_func = lambda td: td.total_seconds() * 1000)
1817
1798
checker_command = notifychangeproperty(dbus.String, "Checker")
1818
1799
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1819
1800
invalidate_only=True)
1821
1802
del notifychangeproperty
1823
1804
def __del__(self, *args, **kwargs):
1825
1806
self.remove_from_connection()
1860
1841
# Emit D-Bus signal
1861
1842
self.CheckerStarted(self.current_checker_command)
1864
1845
def _reset_approved(self):
1865
1846
self.approved = None
1868
1849
def approve(self, value=True):
1869
1850
self.approved = value
1870
1851
GLib.timeout_add(int(self.approval_duration.total_seconds()
1871
1852
* 1000), self._reset_approved)
1872
1853
self.send_changedstate()
1874
# D-Bus methods, signals & properties
1855
## D-Bus methods, signals & properties
1880
1861
# CheckerCompleted - signal
1881
1862
@dbus.service.signal(_interface, signature="nxs")
1882
1863
def CheckerCompleted(self, exitcode, waitstatus, command):
1886
1867
# CheckerStarted - signal
1887
1868
@dbus.service.signal(_interface, signature="s")
1888
1869
def CheckerStarted(self, command):
1892
1873
# PropertyChanged - signal
1893
1874
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1894
1875
@dbus.service.signal(_interface, signature="sv")
1895
1876
def PropertyChanged(self, property, value):
1899
1880
# GotSecret - signal
1900
1881
@dbus.service.signal(_interface)
1901
1882
def GotSecret(self):
1904
1885
server to mandos-client
1908
1889
# Rejected - signal
1909
1890
@dbus.service.signal(_interface, signature="s")
1910
1891
def Rejected(self, reason):
1914
1895
# NeedApproval - signal
1915
1896
@dbus.service.signal(_interface, signature="tb")
1916
1897
def NeedApproval(self, timeout, default):
1918
1899
return self.need_approval()
1922
1903
# Approve - method
1923
1904
@dbus.service.method(_interface, in_signature="b")
1924
1905
def Approve(self, value):
1925
1906
self.approve(value)
1927
1908
# CheckedOK - method
1928
1909
@dbus.service.method(_interface)
1929
1910
def CheckedOK(self):
1930
1911
self.checked_ok()
1932
1913
# Enable - method
1933
1914
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1934
1915
@dbus.service.method(_interface)
1935
1916
def Enable(self):
1939
1920
# StartChecker - method
1940
1921
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1941
1922
@dbus.service.method(_interface)
1942
1923
def StartChecker(self):
1944
1925
self.start_checker()
1946
1927
# Disable - method
1947
1928
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1948
1929
@dbus.service.method(_interface)
1949
1930
def Disable(self):
1953
1934
# StopChecker - method
1954
1935
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1955
1936
@dbus.service.method(_interface)
1956
1937
def StopChecker(self):
1957
1938
self.stop_checker()
1961
1942
# ApprovalPending - property
1962
1943
@dbus_service_property(_interface, signature="b", access="read")
1963
1944
def ApprovalPending_dbus_property(self):
1964
1945
return dbus.Boolean(bool(self.approvals_pending))
1966
1947
# ApprovedByDefault - property
1967
1948
@dbus_service_property(_interface,
2048
2029
self.checked_ok()
2050
2031
return datetime_to_dbus(self.last_checked_ok)
2052
2033
# LastCheckerStatus - property
2053
2034
@dbus_service_property(_interface, signature="n", access="read")
2054
2035
def LastCheckerStatus_dbus_property(self):
2055
2036
return dbus.Int16(self.last_checker_status)
2057
2038
# Expires - property
2058
2039
@dbus_service_property(_interface, signature="s", access="read")
2059
2040
def Expires_dbus_property(self):
2060
2041
return datetime_to_dbus(self.expires)
2062
2043
# LastApprovalRequest - property
2063
2044
@dbus_service_property(_interface, signature="s", access="read")
2064
2045
def LastApprovalRequest_dbus_property(self):
2065
2046
return datetime_to_dbus(self.last_approval_request)
2067
2048
# Timeout - property
2068
2049
@dbus_service_property(_interface,
2190
2171
class ClientHandler(socketserver.BaseRequestHandler, object):
2191
2172
"""A class to handle client connections.
2193
2174
Instantiated once for each connection to handle it.
2194
2175
Note: This will run in its own forked process."""
2196
2177
def handle(self):
2197
2178
with contextlib.closing(self.server.child_pipe) as child_pipe:
2198
2179
logger.info("TCP connection from: %s",
2199
2180
str(self.client_address))
2200
2181
logger.debug("Pipe FD: %d",
2201
2182
self.server.child_pipe.fileno())
2203
2184
session = gnutls.ClientSession(self.request)
2205
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2206
# "+AES-256-CBC", "+SHA1",
2207
# "+COMP-NULL", "+CTYPE-OPENPGP",
2186
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2187
# "+AES-256-CBC", "+SHA1",
2188
# "+COMP-NULL", "+CTYPE-OPENPGP",
2209
2190
# Use a fallback default, since this MUST be set.
2210
2191
priority = self.server.gnutls_priority
2211
2192
if priority is None:
2385
2365
class MultiprocessingMixIn(object):
2386
2366
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2388
2368
def sub_process_main(self, request, address):
2390
2370
self.finish_request(request, address)
2391
2371
except Exception:
2392
2372
self.handle_error(request, address)
2393
2373
self.close_request(request)
2395
2375
def process_request(self, request, address):
2396
2376
"""Start a new process to process the request."""
2397
proc = multiprocessing.Process(target=self.sub_process_main,
2398
args=(request, address))
2377
proc = multiprocessing.Process(target = self.sub_process_main,
2378
args = (request, address))
2403
2383
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2404
2384
""" adds a pipe to the MixIn """
2406
2386
def process_request(self, request, client_address):
2407
2387
"""Overrides and wraps the original process_request().
2409
2389
This function creates a new pipe in self.pipe
2411
2391
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2413
2393
proc = MultiprocessingMixIn.process_request(self, request,
2414
2394
client_address)
2415
2395
self.child_pipe.close()
2416
2396
self.add_pipe(parent_pipe, proc)
2418
2398
def add_pipe(self, parent_pipe, proc):
2419
2399
"""Dummy function; override as necessary"""
2420
2400
raise NotImplementedError()
2544
2522
self.gnutls_priority = gnutls_priority
2545
2523
IPv6_TCPServer.__init__(self, server_address,
2546
2524
RequestHandlerClass,
2547
interface=interface,
2525
interface = interface,
2526
use_ipv6 = use_ipv6,
2527
socketfd = socketfd)
2551
2529
def server_activate(self):
2552
2530
if self.enabled:
2553
2531
return socketserver.TCPServer.server_activate(self)
2555
2533
def enable(self):
2556
2534
self.enabled = True
2558
2536
def add_pipe(self, parent_pipe, proc):
2559
2537
# Call "handle_ipc" for both data and EOF events
2560
2538
GLib.io_add_watch(
2561
2539
parent_pipe.fileno(),
2562
2540
GLib.IO_IN | GLib.IO_HUP,
2563
2541
functools.partial(self.handle_ipc,
2564
parent_pipe=parent_pipe,
2542
parent_pipe = parent_pipe,
2567
2545
def handle_ipc(self, source, condition,
2568
2546
parent_pipe=None,
2570
2548
client_object=None):
2571
2549
# error, or the other end of multiprocessing.Pipe has closed
2572
2550
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2573
2551
# Wait for other process to exit
2577
2555
# Read a request from the child
2578
2556
request = parent_pipe.recv()
2579
2557
command = request[0]
2581
2559
if command == 'init':
2582
fpr = request[1].decode("ascii")
2583
2561
address = request[2]
2585
2563
for c in self.clients.values():
2586
2564
if c.fingerprint == fpr:
2651
2629
>>> rfc3339_duration_to_delta("P1DT3M20S")
2652
2630
datetime.timedelta(1, 200)
2655
2633
# Parsing an RFC 3339 duration with regular expressions is not
2656
2634
# possible - there would have to be multiple places for the same
2657
2635
# values, like seconds. The current code, while more esoteric, is
2658
2636
# cleaner without depending on a parsing library. If Python had a
2659
2637
# built-in library for parsing we would use it, but we'd like to
2660
2638
# avoid excessive use of external libraries.
2662
2640
# New type for defining tokens, syntax, and semantics all-in-one
2663
2641
Token = collections.namedtuple("Token", (
2664
2642
"regexp", # To match token; if "value" is not None, must have
2851
2826
parser.add_argument("--no-zeroconf", action="store_false",
2852
2827
dest="zeroconf", help="Do not use Zeroconf",
2855
2830
options = parser.parse_args()
2857
2832
if options.check:
2859
2834
fail_count, test_count = doctest.testmod()
2860
2835
sys.exit(os.EX_OK if fail_count == 0 else 1)
2862
2837
# Default values for config file for server-global settings
2863
server_defaults = {"interface": "",
2868
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2869
":+SIGN-DSA-SHA256",
2870
"servicename": "Mandos",
2876
"statedir": "/var/lib/mandos",
2877
"foreground": "False",
2838
server_defaults = { "interface": "",
2843
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2844
":+SIGN-DSA-SHA256",
2845
"servicename": "Mandos",
2851
"statedir": "/var/lib/mandos",
2852
"foreground": "False",
2881
2856
# Parse config file for server-global settings
2882
2857
server_config = configparser.SafeConfigParser(server_defaults)
2883
2858
del server_defaults
3013
2987
.format(uid, gid, os.strerror(error.errno)))
3014
2988
if error.errno != errno.EPERM:
3018
2992
# Enable all possible GnuTLS debugging
3020
2994
# "Use a log level over 10 to enable all debugging options."
3021
2995
# - GnuTLS manual
3022
2996
gnutls.global_set_log_level(11)
3024
2998
@gnutls.log_func
3025
2999
def debug_gnutls(level, string):
3026
3000
logger.debug("GnuTLS: %s", string[:-1])
3028
3002
gnutls.global_set_log_function(debug_gnutls)
3030
3004
# Redirect stdin so all checkers get /dev/null
3031
3005
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3032
3006
os.dup2(null, sys.stdin.fileno())
3036
3010
# Need to fork before connecting to D-Bus
3037
3011
if not foreground:
3038
3012
# Close all input and output, do double fork, etc.
3041
3015
# multiprocessing will use threads, so before we use GLib we need
3042
3016
# to inform GLib that threads will be used.
3043
3017
GLib.threads_init()
3045
3019
global main_loop
3046
3020
# From the Avahi example code
3047
3021
DBusGMainLoop(set_as_default=True)
3065
3039
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3066
3040
service = AvahiServiceToSyslog(
3067
name=server_settings["servicename"],
3068
servicetype="_mandos._tcp",
3041
name = server_settings["servicename"],
3042
servicetype = "_mandos._tcp",
3043
protocol = protocol,
3071
3045
if server_settings["interface"]:
3072
3046
service.interface = if_nametoindex(
3073
3047
server_settings["interface"].encode("utf-8"))
3075
3049
global multiprocessing_manager
3076
3050
multiprocessing_manager = multiprocessing.Manager()
3078
3052
client_class = Client
3080
client_class = functools.partial(ClientDBus, bus=bus)
3054
client_class = functools.partial(ClientDBus, bus = bus)
3082
3056
client_settings = Client.config_parser(client_config)
3083
3057
old_client_settings = {}
3084
3058
clients_data = {}
3086
3060
# This is used to redirect stdout and stderr for checker processes
3088
wnull = open(os.devnull, "w") # A writable /dev/null
3062
wnull = open(os.devnull, "w") # A writable /dev/null
3089
3063
# Only used if server is running in foreground but not in debug
3091
3065
if debug or not foreground:
3094
3068
# Get client data and settings from last running state.
3095
3069
if server_settings["restore"]:
3097
3071
with open(stored_state_path, "rb") as stored_state:
3098
if sys.version_info.major == 2:
3072
if sys.version_info.major == 2:
3099
3073
clients_data, old_client_settings = pickle.load(
3102
3076
bytes_clients_data, bytes_old_client_settings = (
3103
pickle.load(stored_state, encoding="bytes"))
3104
# Fix bytes to strings
3077
pickle.load(stored_state, encoding = "bytes"))
3078
### Fix bytes to strings
3107
clients_data = {(key.decode("utf-8")
3108
if isinstance(key, bytes)
3111
bytes_clients_data.items()}
3081
clients_data = { (key.decode("utf-8")
3082
if isinstance(key, bytes)
3085
bytes_clients_data.items() }
3112
3086
del bytes_clients_data
3113
3087
for key in clients_data:
3114
value = {(k.decode("utf-8")
3115
if isinstance(k, bytes) else k): v
3117
clients_data[key].items()}
3088
value = { (k.decode("utf-8")
3089
if isinstance(k, bytes) else k): v
3091
clients_data[key].items() }
3118
3092
clients_data[key] = value
3119
3093
# .client_structure
3120
3094
value["client_structure"] = [
3121
3095
(s.decode("utf-8")
3122
3096
if isinstance(s, bytes)
3123
3097
else s) for s in
3124
value["client_structure"]]
3098
value["client_structure"] ]
3125
3099
# .name & .host
3126
3100
for k in ("name", "host"):
3127
3101
if isinstance(value[k], bytes):
3128
3102
value[k] = value[k].decode("utf-8")
3129
# old_client_settings
3103
## old_client_settings
3131
3105
old_client_settings = {
3132
3106
(key.decode("utf-8")
3133
3107
if isinstance(key, bytes)
3134
3108
else key): value
3135
3109
for key, value in
3136
bytes_old_client_settings.items()}
3110
bytes_old_client_settings.items() }
3137
3111
del bytes_old_client_settings
3139
3113
for value in old_client_settings.values():
3245
3219
pidfilename, pid)
3247
3221
del pidfilename
3249
3223
for termsig in (signal.SIGHUP, signal.SIGTERM):
3250
3224
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3251
3225
lambda: main_loop.quit() and False)
3255
3229
@alternate_dbus_interfaces(
3256
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3230
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3257
3231
class MandosDBusService(DBusObjectWithObjectManager):
3258
3232
"""A D-Bus proxy object"""
3260
3234
def __init__(self):
3261
3235
dbus.service.Object.__init__(self, bus, "/")
3263
3237
_interface = "se.recompile.Mandos"
3265
3239
@dbus.service.signal(_interface, signature="o")
3266
3240
def ClientAdded(self, objpath):
3270
3244
@dbus.service.signal(_interface, signature="ss")
3271
3245
def ClientNotFound(self, fingerprint, address):
3275
3249
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3277
3251
@dbus.service.signal(_interface, signature="os")
3278
3252
def ClientRemoved(self, objpath, name):
3282
3256
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3284
3258
@dbus.service.method(_interface, out_signature="ao")
3312
3286
self.client_removed_signal(c)
3314
3288
raise KeyError(object_path)
3318
3292
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3319
out_signature="a{oa{sa{sv}}}")
3293
out_signature = "a{oa{sa{sv}}}")
3320
3294
def GetManagedObjects(self):
3321
3295
"""D-Bus method"""
3322
3296
return dbus.Dictionary(
3323
{client.dbus_object_path:
3325
{interface: client.GetAll(interface)
3327
client._get_all_interface_names()})
3328
for client in tcp_server.clients.values()})
3297
{ client.dbus_object_path:
3299
{ interface: client.GetAll(interface)
3301
client._get_all_interface_names()})
3302
for client in tcp_server.clients.values()})
3330
3304
def client_added_signal(self, client):
3331
3305
"""Send the new standard signal and the old signal"""
3378
3351
client.encrypted_secret = pgp.encrypt(client.secret,
3380
3353
client_dict = {}
3382
3355
# A list of attributes that can not be pickled
3384
exclude = {"bus", "changedstate", "secret",
3385
"checker", "server_settings"}
3357
exclude = { "bus", "changedstate", "secret",
3358
"checker", "server_settings" }
3386
3359
for name, typ in inspect.getmembers(dbus.service
3388
3361
exclude.add(name)
3390
3363
client_dict["encrypted_secret"] = (client
3391
3364
.encrypted_secret)
3392
3365
for attr in client.client_structure:
3393
3366
if attr not in exclude:
3394
3367
client_dict[attr] = getattr(client, attr)
3396
3369
clients[client.name] = client_dict
3397
3370
del client_settings[client.name]["secret"]
3400
3373
with tempfile.NamedTemporaryFile(