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