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(self, *args,
495
ret = AvahiService.rename(self, *args, **kwargs)
501
496
syslogger.setFormatter(logging.Formatter(
502
497
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
503
498
.format(self.name)))
507
501
# Pretend that we have a GnuTLS module
508
502
class GnuTLS(object):
509
503
"""This isn't so much a class as it is a module-like namespace.
510
504
It is instantiated once, and simulates having a GnuTLS module."""
512
library = ctypes.util.find_library("gnutls")
514
library = ctypes.util.find_library("gnutls-deb0")
515
_library = ctypes.cdll.LoadLibrary(library)
506
_library = ctypes.cdll.LoadLibrary(
507
ctypes.util.find_library("gnutls"))
517
508
_need_version = b"3.3.0"
519
509
def __init__(self):
520
# Need to use "self" here, since this method is called before
521
# the assignment to the "gnutls" global variable happens.
522
if self.check_version(self._need_version) is None:
523
raise self.Error("Needs GnuTLS {} or later"
524
.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))
526
517
# Unless otherwise indicated, the constants and types below are
527
518
# all from the gnutls/gnutls.h C header file.
531
522
E_INTERRUPTED = -52
536
527
CRD_CERTIFICATE = 1
537
528
E_NO_CERTIFICATE_FOUND = -49
538
529
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
541
532
class session_int(ctypes.Structure):
543
534
session_t = ctypes.POINTER(session_int)
545
535
class certificate_credentials_st(ctypes.Structure):
547
537
certificate_credentials_t = ctypes.POINTER(
548
538
certificate_credentials_st)
549
539
certificate_type_t = ctypes.c_int
551
540
class datum_t(ctypes.Structure):
552
541
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
553
542
('size', ctypes.c_uint)]
555
543
class openpgp_crt_int(ctypes.Structure):
557
545
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
558
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
546
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
559
547
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
560
548
credentials_type_t = ctypes.c_int
561
549
transport_ptr_t = ctypes.c_void_p
562
550
close_request_t = ctypes.c_int
565
553
class Error(Exception):
566
554
# We need to use the class name "GnuTLS" here, since this
567
555
# exception might be raised from within GnuTLS.__init__,
568
556
# which is called before the assignment to the "gnutls"
569
557
# global variable has happened.
570
def __init__(self, message=None, code=None, args=()):
558
def __init__(self, message = None, code = None, args=()):
571
559
# Default usage is by a message string, but if a return
572
560
# code is passed, convert it to a string with
573
561
# gnutls.strerror()
642
630
return _error_code(result)
643
631
result = func(*arguments)
646
634
# Unless otherwise indicated, the function declarations below are
647
635
# all from the gnutls/gnutls.h C header file.
650
638
priority_set_direct = _library.gnutls_priority_set_direct
651
639
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
652
640
ctypes.POINTER(ctypes.c_char_p)]
653
641
priority_set_direct.restype = _error_code
655
643
init = _library.gnutls_init
656
644
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
657
645
init.restype = _error_code
659
647
set_default_priority = _library.gnutls_set_default_priority
660
648
set_default_priority.argtypes = [session_t]
661
649
set_default_priority.restype = _error_code
663
651
record_send = _library.gnutls_record_send
664
652
record_send.argtypes = [session_t, ctypes.c_void_p,
666
654
record_send.restype = ctypes.c_ssize_t
667
655
record_send.errcheck = _retry_on_error
669
657
certificate_allocate_credentials = (
670
658
_library.gnutls_certificate_allocate_credentials)
671
659
certificate_allocate_credentials.argtypes = [
672
660
ctypes.POINTER(certificate_credentials_t)]
673
661
certificate_allocate_credentials.restype = _error_code
675
663
certificate_free_credentials = (
676
664
_library.gnutls_certificate_free_credentials)
677
certificate_free_credentials.argtypes = [
678
certificate_credentials_t]
665
certificate_free_credentials.argtypes = [certificate_credentials_t]
679
666
certificate_free_credentials.restype = None
681
668
handshake_set_private_extensions = (
682
669
_library.gnutls_handshake_set_private_extensions)
683
670
handshake_set_private_extensions.argtypes = [session_t,
685
672
handshake_set_private_extensions.restype = None
687
674
credentials_set = _library.gnutls_credentials_set
688
675
credentials_set.argtypes = [session_t, credentials_type_t,
690
677
credentials_set.restype = _error_code
692
679
strerror = _library.gnutls_strerror
693
680
strerror.argtypes = [ctypes.c_int]
694
681
strerror.restype = ctypes.c_char_p
696
683
certificate_type_get = _library.gnutls_certificate_type_get
697
684
certificate_type_get.argtypes = [session_t]
698
685
certificate_type_get.restype = _error_code
700
687
certificate_get_peers = _library.gnutls_certificate_get_peers
701
688
certificate_get_peers.argtypes = [session_t,
702
689
ctypes.POINTER(ctypes.c_uint)]
703
690
certificate_get_peers.restype = ctypes.POINTER(datum_t)
705
692
global_set_log_level = _library.gnutls_global_set_log_level
706
693
global_set_log_level.argtypes = [ctypes.c_int]
707
694
global_set_log_level.restype = None
709
696
global_set_log_function = _library.gnutls_global_set_log_function
710
697
global_set_log_function.argtypes = [log_func]
711
698
global_set_log_function.restype = None
713
700
deinit = _library.gnutls_deinit
714
701
deinit.argtypes = [session_t]
715
702
deinit.restype = None
717
704
handshake = _library.gnutls_handshake
718
705
handshake.argtypes = [session_t]
719
706
handshake.restype = _error_code
720
707
handshake.errcheck = _retry_on_error
722
709
transport_set_ptr = _library.gnutls_transport_set_ptr
723
710
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
724
711
transport_set_ptr.restype = None
726
713
bye = _library.gnutls_bye
727
714
bye.argtypes = [session_t, close_request_t]
728
715
bye.restype = _error_code
729
716
bye.errcheck = _retry_on_error
731
718
check_version = _library.gnutls_check_version
732
719
check_version.argtypes = [ctypes.c_char_p]
733
720
check_version.restype = ctypes.c_char_p
735
722
# All the function declarations below are from gnutls/openpgp.h
737
724
openpgp_crt_init = _library.gnutls_openpgp_crt_init
738
725
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
739
726
openpgp_crt_init.restype = _error_code
741
728
openpgp_crt_import = _library.gnutls_openpgp_crt_import
742
729
openpgp_crt_import.argtypes = [openpgp_crt_t,
743
730
ctypes.POINTER(datum_t),
744
731
openpgp_crt_fmt_t]
745
732
openpgp_crt_import.restype = _error_code
747
734
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
748
735
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
749
736
ctypes.POINTER(ctypes.c_uint)]
750
737
openpgp_crt_verify_self.restype = _error_code
752
739
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
753
740
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
754
741
openpgp_crt_deinit.restype = None
756
743
openpgp_crt_get_fingerprint = (
757
744
_library.gnutls_openpgp_crt_get_fingerprint)
758
745
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
1080
1065
# The exception is when not debugging but nevertheless
1081
1066
# running in the foreground; use the previously
1082
1067
# created wnull.
1083
popen_args = {"close_fds": True,
1068
popen_args = { "close_fds": True,
1086
1071
if (not self.server_settings["debug"]
1087
1072
and self.server_settings["foreground"]):
1088
1073
popen_args.update({"stdout": wnull,
1090
pipe = multiprocessing.Pipe(duplex=False)
1075
pipe = multiprocessing.Pipe(duplex = False)
1091
1076
self.checker = multiprocessing.Process(
1093
args=(pipe[1], subprocess.call, command),
1078
args = (pipe[1], subprocess.call, command),
1079
kwargs = popen_args)
1095
1080
self.checker.start()
1096
1081
self.checker_callback_tag = GLib.io_add_watch(
1097
1082
pipe[0].fileno(), GLib.IO_IN,
1098
1083
self.checker_callback, pipe[0], command)
1099
1084
# Re-run this periodically if run by GLib.timeout_add
1102
1087
def stop_checker(self):
1103
1088
"""Force the checker process, if any, to stop."""
1104
1089
if self.checker_callback_tag:
1139
1124
func._dbus_name = func.__name__
1140
1125
if func._dbus_name.endswith("_dbus_property"):
1141
1126
func._dbus_name = func._dbus_name[:-14]
1142
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1127
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1145
1130
return decorator
1148
1133
def dbus_interface_annotations(dbus_interface):
1149
1134
"""Decorator for marking functions returning interface annotations
1153
1138
@dbus_interface_annotations("org.example.Interface")
1154
1139
def _foo(self): # Function name does not matter
1155
1140
return {"org.freedesktop.DBus.Deprecated": "true",
1156
1141
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1160
1145
def decorator(func):
1161
1146
func._dbus_is_interface = True
1162
1147
func._dbus_interface = dbus_interface
1163
1148
func._dbus_name = dbus_interface
1166
1151
return decorator
1169
1154
def dbus_annotations(annotations):
1170
1155
"""Decorator to annotate D-Bus methods, signals or properties
1173
1158
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1174
1159
"org.freedesktop.DBus.Property."
1175
1160
"EmitsChangedSignal": "false"})
1231
1216
for cls in self.__class__.__mro__
1232
1217
for name, athing in
1233
1218
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1235
1220
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1237
path_keyword='object_path',
1238
connection_keyword='connection')
1221
out_signature = "s",
1222
path_keyword = 'object_path',
1223
connection_keyword = 'connection')
1239
1224
def Introspect(self, object_path, connection):
1240
1225
"""Overloading of standard D-Bus method.
1242
1227
Inserts annotation tags on methods and signals.
1244
1229
xmlstring = dbus.service.Object.Introspect(self, object_path,
1247
1232
document = xml.dom.minidom.parseString(xmlstring)
1249
1234
for if_tag in document.getElementsByTagName("interface"):
1250
1235
# Add annotation tags
1251
1236
for typ in ("method", "signal"):
1462
1447
exc_info=error)
1463
1448
return xmlstring
1467
1451
dbus.OBJECT_MANAGER_IFACE
1468
1452
except AttributeError:
1469
1453
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1472
1455
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1473
1456
"""A D-Bus object with an ObjectManager.
1475
1458
Classes inheriting from this exposes the standard
1476
1459
GetManagedObjects call and the InterfacesAdded and
1477
1460
InterfacesRemoved signals on the standard
1478
1461
"org.freedesktop.DBus.ObjectManager" interface.
1480
1463
Note: No signals are sent automatically; they must be sent
1483
1466
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1484
out_signature="a{oa{sa{sv}}}")
1467
out_signature = "a{oa{sa{sv}}}")
1485
1468
def GetManagedObjects(self):
1486
1469
"""This function must be overridden"""
1487
1470
raise NotImplementedError()
1489
1472
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1490
signature="oa{sa{sv}}")
1473
signature = "oa{sa{sv}}")
1491
1474
def InterfacesAdded(self, object_path, interfaces_and_properties):
1494
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1477
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1495
1478
def InterfacesRemoved(self, object_path, interfaces):
1498
1481
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1500
path_keyword='object_path',
1501
connection_keyword='connection')
1482
out_signature = "s",
1483
path_keyword = 'object_path',
1484
connection_keyword = 'connection')
1502
1485
def Introspect(self, object_path, connection):
1503
1486
"""Overloading of standard D-Bus method.
1505
1488
Override return argument name of GetManagedObjects to be
1506
1489
"objpath_interfaces_and_properties"
1546
1528
dbus.service.Object, it will add alternate D-Bus attributes with
1547
1529
interface names according to the "alt_interface_names" mapping.
1550
1532
@alternate_dbus_interfaces({"org.example.Interface":
1551
1533
"net.example.AlternateInterface"})
1552
1534
class SampleDBusObject(dbus.service.Object):
1553
1535
@dbus.service.method("org.example.Interface")
1554
1536
def SampleDBusMethod():
1557
1539
The above "SampleDBusMethod" on "SampleDBusObject" will be
1558
1540
reachable via two interfaces: "org.example.Interface" and
1559
1541
"net.example.AlternateInterface", the latter of which will have
1560
1542
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1561
1543
"true", unless "deprecate" is passed with a False value.
1563
1545
This works for methods and signals, and also for D-Bus properties
1564
1546
(from DBusObjectWithProperties) and interfaces (from the
1565
1547
dbus_interface_annotations decorator).
1568
1550
def wrapper(cls):
1569
1551
for orig_interface_name, alt_interface_name in (
1570
1552
alt_interface_names.items()):
1714
1694
"se.bsnet.fukt.Mandos"})
1715
1695
class ClientDBus(Client, DBusObjectWithProperties):
1716
1696
"""A Client class using D-Bus
1719
1699
dbus_object_path: dbus.ObjectPath
1720
1700
bus: dbus.SystemBus()
1723
1703
runtime_expansions = (Client.runtime_expansions
1724
1704
+ ("dbus_object_path", ))
1726
1706
_interface = "se.recompile.Mandos.Client"
1728
1708
# dbus.service.Object doesn't use super(), so we can't either.
1730
def __init__(self, bus=None, *args, **kwargs):
1710
def __init__(self, bus = None, *args, **kwargs):
1732
1712
Client.__init__(self, *args, **kwargs)
1733
1713
# Only now, when this client is initialized, can it show up on
1770
1750
dbus_value = transform_func(
1771
1751
type_func(value),
1772
variant_level=variant_level)
1752
variant_level = variant_level)
1773
1753
self.PropertyChanged(dbus.String(dbus_name),
1775
1755
self.PropertiesChanged(
1777
dbus.Dictionary({dbus.String(dbus_name):
1757
dbus.Dictionary({ dbus.String(dbus_name):
1780
1760
setattr(self, attrname, value)
1782
1762
return property(lambda self: getattr(self, attrname), setter)
1784
1764
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1785
1765
approvals_pending = notifychangeproperty(dbus.Boolean,
1786
1766
"ApprovalPending",
1788
1768
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1789
1769
last_enabled = notifychangeproperty(datetime_to_dbus,
1791
1771
checker = notifychangeproperty(
1792
1772
dbus.Boolean, "CheckerRunning",
1793
type_func=lambda checker: checker is not None)
1773
type_func = lambda checker: checker is not None)
1794
1774
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1795
1775
"LastCheckedOK")
1796
1776
last_checker_status = notifychangeproperty(dbus.Int16,
1801
1781
"ApprovedByDefault")
1802
1782
approval_delay = notifychangeproperty(
1803
1783
dbus.UInt64, "ApprovalDelay",
1804
type_func=lambda td: td.total_seconds() * 1000)
1784
type_func = lambda td: td.total_seconds() * 1000)
1805
1785
approval_duration = notifychangeproperty(
1806
1786
dbus.UInt64, "ApprovalDuration",
1807
type_func=lambda td: td.total_seconds() * 1000)
1787
type_func = lambda td: td.total_seconds() * 1000)
1808
1788
host = notifychangeproperty(dbus.String, "Host")
1809
1789
timeout = notifychangeproperty(
1810
1790
dbus.UInt64, "Timeout",
1811
type_func=lambda td: td.total_seconds() * 1000)
1791
type_func = lambda td: td.total_seconds() * 1000)
1812
1792
extended_timeout = notifychangeproperty(
1813
1793
dbus.UInt64, "ExtendedTimeout",
1814
type_func=lambda td: td.total_seconds() * 1000)
1794
type_func = lambda td: td.total_seconds() * 1000)
1815
1795
interval = notifychangeproperty(
1816
1796
dbus.UInt64, "Interval",
1817
type_func=lambda td: td.total_seconds() * 1000)
1797
type_func = lambda td: td.total_seconds() * 1000)
1818
1798
checker_command = notifychangeproperty(dbus.String, "Checker")
1819
1799
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1820
1800
invalidate_only=True)
1822
1802
del notifychangeproperty
1824
1804
def __del__(self, *args, **kwargs):
1826
1806
self.remove_from_connection()
1861
1841
# Emit D-Bus signal
1862
1842
self.CheckerStarted(self.current_checker_command)
1865
1845
def _reset_approved(self):
1866
1846
self.approved = None
1869
1849
def approve(self, value=True):
1870
1850
self.approved = value
1871
1851
GLib.timeout_add(int(self.approval_duration.total_seconds()
1872
1852
* 1000), self._reset_approved)
1873
1853
self.send_changedstate()
1875
# D-Bus methods, signals & properties
1855
## D-Bus methods, signals & properties
1881
1861
# CheckerCompleted - signal
1882
1862
@dbus.service.signal(_interface, signature="nxs")
1883
1863
def CheckerCompleted(self, exitcode, waitstatus, command):
1887
1867
# CheckerStarted - signal
1888
1868
@dbus.service.signal(_interface, signature="s")
1889
1869
def CheckerStarted(self, command):
1893
1873
# PropertyChanged - signal
1894
1874
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1895
1875
@dbus.service.signal(_interface, signature="sv")
1896
1876
def PropertyChanged(self, property, value):
1900
1880
# GotSecret - signal
1901
1881
@dbus.service.signal(_interface)
1902
1882
def GotSecret(self):
1905
1885
server to mandos-client
1909
1889
# Rejected - signal
1910
1890
@dbus.service.signal(_interface, signature="s")
1911
1891
def Rejected(self, reason):
1915
1895
# NeedApproval - signal
1916
1896
@dbus.service.signal(_interface, signature="tb")
1917
1897
def NeedApproval(self, timeout, default):
1919
1899
return self.need_approval()
1923
1903
# Approve - method
1924
1904
@dbus.service.method(_interface, in_signature="b")
1925
1905
def Approve(self, value):
1926
1906
self.approve(value)
1928
1908
# CheckedOK - method
1929
1909
@dbus.service.method(_interface)
1930
1910
def CheckedOK(self):
1931
1911
self.checked_ok()
1933
1913
# Enable - method
1934
1914
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1935
1915
@dbus.service.method(_interface)
1936
1916
def Enable(self):
1940
1920
# StartChecker - method
1941
1921
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1942
1922
@dbus.service.method(_interface)
1943
1923
def StartChecker(self):
1945
1925
self.start_checker()
1947
1927
# Disable - method
1948
1928
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1949
1929
@dbus.service.method(_interface)
1950
1930
def Disable(self):
1954
1934
# StopChecker - method
1955
1935
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1956
1936
@dbus.service.method(_interface)
1957
1937
def StopChecker(self):
1958
1938
self.stop_checker()
1962
1942
# ApprovalPending - property
1963
1943
@dbus_service_property(_interface, signature="b", access="read")
1964
1944
def ApprovalPending_dbus_property(self):
1965
1945
return dbus.Boolean(bool(self.approvals_pending))
1967
1947
# ApprovedByDefault - property
1968
1948
@dbus_service_property(_interface,
2049
2029
self.checked_ok()
2051
2031
return datetime_to_dbus(self.last_checked_ok)
2053
2033
# LastCheckerStatus - property
2054
2034
@dbus_service_property(_interface, signature="n", access="read")
2055
2035
def LastCheckerStatus_dbus_property(self):
2056
2036
return dbus.Int16(self.last_checker_status)
2058
2038
# Expires - property
2059
2039
@dbus_service_property(_interface, signature="s", access="read")
2060
2040
def Expires_dbus_property(self):
2061
2041
return datetime_to_dbus(self.expires)
2063
2043
# LastApprovalRequest - property
2064
2044
@dbus_service_property(_interface, signature="s", access="read")
2065
2045
def LastApprovalRequest_dbus_property(self):
2066
2046
return datetime_to_dbus(self.last_approval_request)
2068
2048
# Timeout - property
2069
2049
@dbus_service_property(_interface,
2191
2171
class ClientHandler(socketserver.BaseRequestHandler, object):
2192
2172
"""A class to handle client connections.
2194
2174
Instantiated once for each connection to handle it.
2195
2175
Note: This will run in its own forked process."""
2197
2177
def handle(self):
2198
2178
with contextlib.closing(self.server.child_pipe) as child_pipe:
2199
2179
logger.info("TCP connection from: %s",
2200
2180
str(self.client_address))
2201
2181
logger.debug("Pipe FD: %d",
2202
2182
self.server.child_pipe.fileno())
2204
2184
session = gnutls.ClientSession(self.request)
2206
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2207
# "+AES-256-CBC", "+SHA1",
2208
# "+COMP-NULL", "+CTYPE-OPENPGP",
2186
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2187
# "+AES-256-CBC", "+SHA1",
2188
# "+COMP-NULL", "+CTYPE-OPENPGP",
2210
2190
# Use a fallback default, since this MUST be set.
2211
2191
priority = self.server.gnutls_priority
2212
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
2523
self.gnutls_priority = gnutls_priority
2545
2524
IPv6_TCPServer.__init__(self, server_address,
2546
2525
RequestHandlerClass,
2547
interface=interface,
2526
interface = interface,
2527
use_ipv6 = use_ipv6,
2528
socketfd = socketfd)
2551
2530
def server_activate(self):
2552
2531
if self.enabled:
2553
2532
return socketserver.TCPServer.server_activate(self)
2555
2534
def enable(self):
2556
2535
self.enabled = True
2558
2537
def add_pipe(self, parent_pipe, proc):
2559
2538
# Call "handle_ipc" for both data and EOF events
2560
2539
GLib.io_add_watch(
2561
2540
parent_pipe.fileno(),
2562
2541
GLib.IO_IN | GLib.IO_HUP,
2563
2542
functools.partial(self.handle_ipc,
2564
parent_pipe=parent_pipe,
2543
parent_pipe = parent_pipe,
2567
2546
def handle_ipc(self, source, condition,
2568
2547
parent_pipe=None,
2570
2549
client_object=None):
2571
2550
# error, or the other end of multiprocessing.Pipe has closed
2572
2551
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2573
2552
# Wait for other process to exit
2577
2556
# Read a request from the child
2578
2557
request = parent_pipe.recv()
2579
2558
command = request[0]
2581
2560
if command == 'init':
2582
fpr = request[1].decode("ascii")
2583
2562
address = request[2]
2585
2564
for c in self.clients.values():
2586
2565
if c.fingerprint == fpr:
2651
2630
>>> rfc3339_duration_to_delta("P1DT3M20S")
2652
2631
datetime.timedelta(1, 200)
2655
2634
# Parsing an RFC 3339 duration with regular expressions is not
2656
2635
# possible - there would have to be multiple places for the same
2657
2636
# values, like seconds. The current code, while more esoteric, is
2658
2637
# cleaner without depending on a parsing library. If Python had a
2659
2638
# built-in library for parsing we would use it, but we'd like to
2660
2639
# avoid excessive use of external libraries.
2662
2641
# New type for defining tokens, syntax, and semantics all-in-one
2663
2642
Token = collections.namedtuple("Token", (
2664
2643
"regexp", # To match token; if "value" is not None, must have
2851
2827
parser.add_argument("--no-zeroconf", action="store_false",
2852
2828
dest="zeroconf", help="Do not use Zeroconf",
2855
2831
options = parser.parse_args()
2857
2833
if options.check:
2859
2835
fail_count, test_count = doctest.testmod()
2860
2836
sys.exit(os.EX_OK if fail_count == 0 else 1)
2862
2838
# 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",
2839
server_defaults = { "interface": "",
2844
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2845
":+SIGN-DSA-SHA256",
2846
"servicename": "Mandos",
2852
"statedir": "/var/lib/mandos",
2853
"foreground": "False",
2881
2857
# Parse config file for server-global settings
2882
2858
server_config = configparser.SafeConfigParser(server_defaults)
2883
2859
del server_defaults
3013
2988
.format(uid, gid, os.strerror(error.errno)))
3014
2989
if error.errno != errno.EPERM:
3018
2993
# Enable all possible GnuTLS debugging
3020
2995
# "Use a log level over 10 to enable all debugging options."
3021
2996
# - GnuTLS manual
3022
2997
gnutls.global_set_log_level(11)
3024
2999
@gnutls.log_func
3025
3000
def debug_gnutls(level, string):
3026
3001
logger.debug("GnuTLS: %s", string[:-1])
3028
3003
gnutls.global_set_log_function(debug_gnutls)
3030
3005
# Redirect stdin so all checkers get /dev/null
3031
3006
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3032
3007
os.dup2(null, sys.stdin.fileno())
3036
3011
# Need to fork before connecting to D-Bus
3037
3012
if not foreground:
3038
3013
# Close all input and output, do double fork, etc.
3041
3016
# multiprocessing will use threads, so before we use GLib we need
3042
3017
# to inform GLib that threads will be used.
3043
3018
GLib.threads_init()
3045
3020
global main_loop
3046
3021
# From the Avahi example code
3047
3022
DBusGMainLoop(set_as_default=True)
3065
3040
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3066
3041
service = AvahiServiceToSyslog(
3067
name=server_settings["servicename"],
3068
servicetype="_mandos._tcp",
3042
name = server_settings["servicename"],
3043
servicetype = "_mandos._tcp",
3044
protocol = protocol,
3071
3046
if server_settings["interface"]:
3072
3047
service.interface = if_nametoindex(
3073
3048
server_settings["interface"].encode("utf-8"))
3075
3050
global multiprocessing_manager
3076
3051
multiprocessing_manager = multiprocessing.Manager()
3078
3053
client_class = Client
3080
client_class = functools.partial(ClientDBus, bus=bus)
3055
client_class = functools.partial(ClientDBus, bus = bus)
3082
3057
client_settings = Client.config_parser(client_config)
3083
3058
old_client_settings = {}
3084
3059
clients_data = {}
3086
3061
# This is used to redirect stdout and stderr for checker processes
3088
wnull = open(os.devnull, "w") # A writable /dev/null
3063
wnull = open(os.devnull, "w") # A writable /dev/null
3089
3064
# Only used if server is running in foreground but not in debug
3091
3066
if debug or not foreground:
3094
3069
# Get client data and settings from last running state.
3095
3070
if server_settings["restore"]:
3097
3072
with open(stored_state_path, "rb") as stored_state:
3098
if sys.version_info.major == 2:
3073
if sys.version_info.major == 2:
3099
3074
clients_data, old_client_settings = pickle.load(
3102
3077
bytes_clients_data, bytes_old_client_settings = (
3103
pickle.load(stored_state, encoding="bytes"))
3104
# Fix bytes to strings
3078
pickle.load(stored_state, encoding = "bytes"))
3079
### Fix bytes to strings
3107
clients_data = {(key.decode("utf-8")
3108
if isinstance(key, bytes)
3111
bytes_clients_data.items()}
3082
clients_data = { (key.decode("utf-8")
3083
if isinstance(key, bytes)
3086
bytes_clients_data.items() }
3112
3087
del bytes_clients_data
3113
3088
for key in clients_data:
3114
value = {(k.decode("utf-8")
3115
if isinstance(k, bytes) else k): v
3117
clients_data[key].items()}
3089
value = { (k.decode("utf-8")
3090
if isinstance(k, bytes) else k): v
3092
clients_data[key].items() }
3118
3093
clients_data[key] = value
3119
3094
# .client_structure
3120
3095
value["client_structure"] = [
3121
3096
(s.decode("utf-8")
3122
3097
if isinstance(s, bytes)
3123
3098
else s) for s in
3124
value["client_structure"]]
3099
value["client_structure"] ]
3125
3100
# .name & .host
3126
3101
for k in ("name", "host"):
3127
3102
if isinstance(value[k], bytes):
3128
3103
value[k] = value[k].decode("utf-8")
3129
# old_client_settings
3104
## old_client_settings
3131
3106
old_client_settings = {
3132
3107
(key.decode("utf-8")
3133
3108
if isinstance(key, bytes)
3134
3109
else key): value
3135
3110
for key, value in
3136
bytes_old_client_settings.items()}
3111
bytes_old_client_settings.items() }
3137
3112
del bytes_old_client_settings
3139
3114
for value in old_client_settings.values():
3245
3220
pidfilename, pid)
3247
3222
del pidfilename
3249
3224
for termsig in (signal.SIGHUP, signal.SIGTERM):
3250
3225
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3251
3226
lambda: main_loop.quit() and False)
3255
3230
@alternate_dbus_interfaces(
3256
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3231
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3257
3232
class MandosDBusService(DBusObjectWithObjectManager):
3258
3233
"""A D-Bus proxy object"""
3260
3235
def __init__(self):
3261
3236
dbus.service.Object.__init__(self, bus, "/")
3263
3238
_interface = "se.recompile.Mandos"
3265
3240
@dbus.service.signal(_interface, signature="o")
3266
3241
def ClientAdded(self, objpath):
3270
3245
@dbus.service.signal(_interface, signature="ss")
3271
3246
def ClientNotFound(self, fingerprint, address):
3275
3250
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3277
3252
@dbus.service.signal(_interface, signature="os")
3278
3253
def ClientRemoved(self, objpath, name):
3282
3257
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3284
3259
@dbus.service.method(_interface, out_signature="ao")
3312
3287
self.client_removed_signal(c)
3314
3289
raise KeyError(object_path)
3318
3293
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3319
out_signature="a{oa{sa{sv}}}")
3294
out_signature = "a{oa{sa{sv}}}")
3320
3295
def GetManagedObjects(self):
3321
3296
"""D-Bus method"""
3322
3297
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()})
3298
{ client.dbus_object_path:
3300
{ interface: client.GetAll(interface)
3302
client._get_all_interface_names()})
3303
for client in tcp_server.clients.values()})
3330
3305
def client_added_signal(self, client):
3331
3306
"""Send the new standard signal and the old signal"""
3378
3352
client.encrypted_secret = pgp.encrypt(client.secret,
3380
3354
client_dict = {}
3382
3356
# A list of attributes that can not be pickled
3384
exclude = {"bus", "changedstate", "secret",
3385
"checker", "server_settings"}
3358
exclude = { "bus", "changedstate", "secret",
3359
"checker", "server_settings" }
3386
3360
for name, typ in inspect.getmembers(dbus.service
3388
3362
exclude.add(name)
3390
3364
client_dict["encrypted_secret"] = (client
3391
3365
.encrypted_secret)
3392
3366
for attr in client.client_structure:
3393
3367
if attr not in exclude:
3394
3368
client_dict[attr] = getattr(client, attr)
3396
3370
clients[client.name] = client_dict
3397
3371
del client_settings[client.name]["secret"]
3400
3374
with tempfile.NamedTemporaryFile(