65
import cPickle as pickle
70
import cPickle as pickle
66
73
import multiprocessing
74
82
import dbus.service
84
from gi.repository import GLib
77
85
from dbus.mainloop.glib import DBusGMainLoop
80
88
import xml.dom.minidom
91
if sys.version_info.major == 2:
94
# Try to find the value of SO_BINDTODEVICE:
96
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
97
# newer, and it is also the most natural place for it:
85
98
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
86
99
except AttributeError:
101
# This is where SO_BINDTODEVICE was up to and including Python
88
103
from IN import SO_BINDTODEVICE
89
104
except ImportError:
90
SO_BINDTODEVICE = None
105
# In Python 2.7 it seems to have been removed entirely.
106
# Try running the C preprocessor:
108
cc = subprocess.Popen(["cc", "--language=c", "-E",
110
stdin=subprocess.PIPE,
111
stdout=subprocess.PIPE)
112
stdout = cc.communicate(
113
"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
114
SO_BINDTODEVICE = int(stdout.splitlines()[-1])
115
except (OSError, ValueError, IndexError):
117
SO_BINDTODEVICE = None
119
if sys.version_info.major == 2:
122
if sys.version_info < (3, 2):
123
configparser.Configparser = configparser.SafeConfigParser
93
126
stored_state_file = "clients.pickle"
95
128
logger = logging.getLogger()
96
syslogger = (logging.handlers.SysLogHandler
97
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
98
address = str("/dev/log")))
101
if_nametoindex = (ctypes.cdll.LoadLibrary
102
(ctypes.util.find_library("c"))
132
if_nametoindex = ctypes.cdll.LoadLibrary(
133
ctypes.util.find_library("c")).if_nametoindex
104
134
except (OSError, AttributeError):
105
136
def if_nametoindex(interface):
106
137
"Get an interface index the hard way, i.e. using fcntl()"
107
138
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
108
139
with contextlib.closing(socket.socket()) as s:
109
140
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
110
struct.pack(str("16s16x"),
112
interface_index = struct.unpack(str("I"),
141
struct.pack(b"16s16x", interface))
142
interface_index = struct.unpack("I", ifreq[16:20])[0]
114
143
return interface_index
146
def copy_function(func):
147
"""Make a copy of a function"""
148
if sys.version_info.major == 2:
149
return types.FunctionType(func.func_code,
155
return types.FunctionType(func.__code__,
117
162
def initlogger(debug, level=logging.WARNING):
118
163
"""init logger and add loglevel"""
166
syslogger = (logging.handlers.SysLogHandler(
167
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
120
169
syslogger.setFormatter(logging.Formatter
121
170
('Mandos [%(process)d]: %(levelname)s:'
123
172
logger.addHandler(syslogger)
126
175
console = logging.StreamHandler()
127
176
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
172
233
os.rmdir(self.tempdir)
173
234
self.tempdir = None
175
236
def password_encode(self, password):
176
237
# Passphrase can not be empty and can not contain newlines or
177
238
# NUL bytes. So we prefix it and hex encode it.
178
return b"mandos" + binascii.hexlify(password)
239
encoded = b"mandos" + binascii.hexlify(password)
240
if len(encoded) > 2048:
241
# GnuPG can't handle long passwords, so encode differently
242
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
243
.replace(b"\n", b"\\n")
244
.replace(b"\0", b"\\x00"))
180
247
def encrypt(self, data, password):
181
self.gnupg.passphrase = self.password_encode(password)
182
with open(os.devnull, "w") as devnull:
184
proc = self.gnupg.run(['--symmetric'],
185
create_fhs=['stdin', 'stdout'],
186
attach_fhs={'stderr': devnull})
187
with contextlib.closing(proc.handles['stdin']) as f:
189
with contextlib.closing(proc.handles['stdout']) as f:
190
ciphertext = f.read()
194
self.gnupg.passphrase = None
248
passphrase = self.password_encode(password)
249
with tempfile.NamedTemporaryFile(
250
dir=self.tempdir) as passfile:
251
passfile.write(passphrase)
253
proc = subprocess.Popen([self.gpg, '--symmetric',
257
stdin=subprocess.PIPE,
258
stdout=subprocess.PIPE,
259
stderr=subprocess.PIPE)
260
ciphertext, err = proc.communicate(input=data)
261
if proc.returncode != 0:
195
263
return ciphertext
197
265
def decrypt(self, data, password):
198
self.gnupg.passphrase = self.password_encode(password)
199
with open(os.devnull, "w") as devnull:
201
proc = self.gnupg.run(['--decrypt'],
202
create_fhs=['stdin', 'stdout'],
203
attach_fhs={'stderr': devnull})
204
with contextlib.closing(proc.handles['stdin']) as f:
206
with contextlib.closing(proc.handles['stdout']) as f:
207
decrypted_plaintext = f.read()
211
self.gnupg.passphrase = None
266
passphrase = self.password_encode(password)
267
with tempfile.NamedTemporaryFile(
268
dir=self.tempdir) as passfile:
269
passfile.write(passphrase)
271
proc = subprocess.Popen([self.gpg, '--decrypt',
275
stdin=subprocess.PIPE,
276
stdout=subprocess.PIPE,
277
stderr=subprocess.PIPE)
278
decrypted_plaintext, err = proc.communicate(input=data)
279
if proc.returncode != 0:
212
281
return decrypted_plaintext
284
# Pretend that we have an Avahi module
286
"""This isn't so much a class as it is a module-like namespace."""
287
IF_UNSPEC = -1 # avahi-common/address.h
288
PROTO_UNSPEC = -1 # avahi-common/address.h
289
PROTO_INET = 0 # avahi-common/address.h
290
PROTO_INET6 = 1 # avahi-common/address.h
291
DBUS_NAME = "org.freedesktop.Avahi"
292
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
293
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
294
DBUS_PATH_SERVER = "/"
297
def string_array_to_txt_array(t):
298
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
299
for s in t), signature="ay")
300
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
301
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
302
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
303
SERVER_INVALID = 0 # avahi-common/defs.h
304
SERVER_REGISTERING = 1 # avahi-common/defs.h
305
SERVER_RUNNING = 2 # avahi-common/defs.h
306
SERVER_COLLISION = 3 # avahi-common/defs.h
307
SERVER_FAILURE = 4 # avahi-common/defs.h
215
310
class AvahiError(Exception):
216
311
def __init__(self, value, *args, **kwargs):
217
312
self.value = value
218
super(AvahiError, self).__init__(value, *args, **kwargs)
219
def __unicode__(self):
220
return unicode(repr(self.value))
313
return super(AvahiError, self).__init__(value, *args,
222
317
class AvahiServiceError(AvahiError):
225
321
class AvahiGroupError(AvahiError):
229
class AvahiService(object):
230
326
"""An Avahi (Zeroconf) service.
233
329
interface: integer; avahi.IF_UNSPEC or an interface index.
234
330
Used to optionally bind to the specified interface.
235
331
name: string; Example: 'Mandos'
236
332
type: string; Example: '_mandos._tcp'.
237
See <http://www.dns-sd.org/ServiceTypes.html>
333
See <https://www.iana.org/assignments/service-names-port-numbers>
238
334
port: integer; what port to announce
239
335
TXT: list of strings; TXT record for the service
240
336
domain: string; Domain to publish on, default to .local if empty.
377
495
follow_name_owner_changes=True),
378
496
avahi.DBUS_INTERFACE_SERVER)
379
497
self.server.connect_to_signal("StateChanged",
380
self.server_state_changed)
498
self.server_state_changed)
381
499
self.server_state_changed(self.server.GetState())
384
502
class AvahiServiceToSyslog(AvahiService):
503
def rename(self, *args, **kwargs):
386
504
"""Add the new name to the syslog messages"""
387
ret = AvahiService.rename(self)
388
syslogger.setFormatter(logging.Formatter
389
('Mandos ({0}) [%(process)d]:'
390
' %(levelname)s: %(message)s'
505
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
506
syslogger.setFormatter(logging.Formatter(
507
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
395
def timedelta_to_milliseconds(td):
396
"Convert a datetime.timedelta() to milliseconds"
397
return ((td.days * 24 * 60 * 60 * 1000)
398
+ (td.seconds * 1000)
399
+ (td.microseconds // 1000))
402
class Client(object):
512
# Pretend that we have a GnuTLS module
514
"""This isn't so much a class as it is a module-like namespace."""
516
library = ctypes.util.find_library("gnutls")
518
library = ctypes.util.find_library("gnutls-deb0")
519
_library = ctypes.cdll.LoadLibrary(library)
522
# Unless otherwise indicated, the constants and types below are
523
# all from the gnutls/gnutls.h C header file.
534
E_NO_CERTIFICATE_FOUND = -49
539
KEYID_USE_SHA256 = 1 # gnutls/x509.h
540
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
543
class session_int(ctypes.Structure):
545
session_t = ctypes.POINTER(session_int)
547
class certificate_credentials_st(ctypes.Structure):
549
certificate_credentials_t = ctypes.POINTER(
550
certificate_credentials_st)
551
certificate_type_t = ctypes.c_int
553
class datum_t(ctypes.Structure):
554
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
555
('size', ctypes.c_uint)]
557
class openpgp_crt_int(ctypes.Structure):
559
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
560
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
561
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
562
credentials_type_t = ctypes.c_int
563
transport_ptr_t = ctypes.c_void_p
564
close_request_t = ctypes.c_int
567
class Error(Exception):
568
def __init__(self, message=None, code=None, args=()):
569
# Default usage is by a message string, but if a return
570
# code is passed, convert it to a string with
573
if message is None and code is not None:
574
message = gnutls.strerror(code)
575
return super(gnutls.Error, self).__init__(
578
class CertificateSecurityError(Error):
584
self._c_object = gnutls.certificate_credentials_t()
585
gnutls.certificate_allocate_credentials(
586
ctypes.byref(self._c_object))
587
self.type = gnutls.CRD_CERTIFICATE
590
gnutls.certificate_free_credentials(self._c_object)
593
def __init__(self, socket, credentials=None):
594
self._c_object = gnutls.session_t()
595
gnutls_flags = gnutls.CLIENT
596
if gnutls.check_version(b"3.5.6"):
597
gnutls_flags |= gnutls.NO_TICKETS
599
gnutls_flags |= gnutls.ENABLE_RAWPK
600
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
602
gnutls.set_default_priority(self._c_object)
603
gnutls.transport_set_ptr(self._c_object, socket.fileno())
604
gnutls.handshake_set_private_extensions(self._c_object,
607
if credentials is None:
608
credentials = gnutls.Credentials()
609
gnutls.credentials_set(self._c_object, credentials.type,
610
ctypes.cast(credentials._c_object,
612
self.credentials = credentials
615
gnutls.deinit(self._c_object)
618
return gnutls.handshake(self._c_object)
620
def send(self, data):
624
data_len -= gnutls.record_send(self._c_object,
629
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
631
# Error handling functions
632
def _error_code(result):
633
"""A function to raise exceptions on errors, suitable
634
for the 'restype' attribute on ctypes functions"""
637
if result == gnutls.E_NO_CERTIFICATE_FOUND:
638
raise gnutls.CertificateSecurityError(code=result)
639
raise gnutls.Error(code=result)
641
def _retry_on_error(result, func, arguments):
642
"""A function to retry on some errors, suitable
643
for the 'errcheck' attribute on ctypes functions"""
645
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
646
return _error_code(result)
647
result = func(*arguments)
650
# Unless otherwise indicated, the function declarations below are
651
# all from the gnutls/gnutls.h C header file.
654
priority_set_direct = _library.gnutls_priority_set_direct
655
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
656
ctypes.POINTER(ctypes.c_char_p)]
657
priority_set_direct.restype = _error_code
659
init = _library.gnutls_init
660
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
661
init.restype = _error_code
663
set_default_priority = _library.gnutls_set_default_priority
664
set_default_priority.argtypes = [session_t]
665
set_default_priority.restype = _error_code
667
record_send = _library.gnutls_record_send
668
record_send.argtypes = [session_t, ctypes.c_void_p,
670
record_send.restype = ctypes.c_ssize_t
671
record_send.errcheck = _retry_on_error
673
certificate_allocate_credentials = (
674
_library.gnutls_certificate_allocate_credentials)
675
certificate_allocate_credentials.argtypes = [
676
ctypes.POINTER(certificate_credentials_t)]
677
certificate_allocate_credentials.restype = _error_code
679
certificate_free_credentials = (
680
_library.gnutls_certificate_free_credentials)
681
certificate_free_credentials.argtypes = [
682
certificate_credentials_t]
683
certificate_free_credentials.restype = None
685
handshake_set_private_extensions = (
686
_library.gnutls_handshake_set_private_extensions)
687
handshake_set_private_extensions.argtypes = [session_t,
689
handshake_set_private_extensions.restype = None
691
credentials_set = _library.gnutls_credentials_set
692
credentials_set.argtypes = [session_t, credentials_type_t,
694
credentials_set.restype = _error_code
696
strerror = _library.gnutls_strerror
697
strerror.argtypes = [ctypes.c_int]
698
strerror.restype = ctypes.c_char_p
700
certificate_type_get = _library.gnutls_certificate_type_get
701
certificate_type_get.argtypes = [session_t]
702
certificate_type_get.restype = _error_code
704
certificate_get_peers = _library.gnutls_certificate_get_peers
705
certificate_get_peers.argtypes = [session_t,
706
ctypes.POINTER(ctypes.c_uint)]
707
certificate_get_peers.restype = ctypes.POINTER(datum_t)
709
global_set_log_level = _library.gnutls_global_set_log_level
710
global_set_log_level.argtypes = [ctypes.c_int]
711
global_set_log_level.restype = None
713
global_set_log_function = _library.gnutls_global_set_log_function
714
global_set_log_function.argtypes = [log_func]
715
global_set_log_function.restype = None
717
deinit = _library.gnutls_deinit
718
deinit.argtypes = [session_t]
719
deinit.restype = None
721
handshake = _library.gnutls_handshake
722
handshake.argtypes = [session_t]
723
handshake.restype = _error_code
724
handshake.errcheck = _retry_on_error
726
transport_set_ptr = _library.gnutls_transport_set_ptr
727
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
728
transport_set_ptr.restype = None
730
bye = _library.gnutls_bye
731
bye.argtypes = [session_t, close_request_t]
732
bye.restype = _error_code
733
bye.errcheck = _retry_on_error
735
check_version = _library.gnutls_check_version
736
check_version.argtypes = [ctypes.c_char_p]
737
check_version.restype = ctypes.c_char_p
739
_need_version = b"3.3.0"
740
if check_version(_need_version) is None:
741
raise self.Error("Needs GnuTLS {} or later"
742
.format(_need_version))
744
_tls_rawpk_version = b"3.6.6"
745
has_rawpk = bool(check_version(_tls_rawpk_version))
749
class pubkey_st(ctypes.Structure):
751
pubkey_t = ctypes.POINTER(pubkey_st)
753
x509_crt_fmt_t = ctypes.c_int
755
# All the function declarations below are from gnutls/abstract.h
756
pubkey_init = _library.gnutls_pubkey_init
757
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
758
pubkey_init.restype = _error_code
760
pubkey_import = _library.gnutls_pubkey_import
761
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
763
pubkey_import.restype = _error_code
765
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
766
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
767
ctypes.POINTER(ctypes.c_ubyte),
768
ctypes.POINTER(ctypes.c_size_t)]
769
pubkey_get_key_id.restype = _error_code
771
pubkey_deinit = _library.gnutls_pubkey_deinit
772
pubkey_deinit.argtypes = [pubkey_t]
773
pubkey_deinit.restype = None
775
# All the function declarations below are from gnutls/openpgp.h
777
openpgp_crt_init = _library.gnutls_openpgp_crt_init
778
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
779
openpgp_crt_init.restype = _error_code
781
openpgp_crt_import = _library.gnutls_openpgp_crt_import
782
openpgp_crt_import.argtypes = [openpgp_crt_t,
783
ctypes.POINTER(datum_t),
785
openpgp_crt_import.restype = _error_code
787
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
788
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
789
ctypes.POINTER(ctypes.c_uint)]
790
openpgp_crt_verify_self.restype = _error_code
792
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
793
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
794
openpgp_crt_deinit.restype = None
796
openpgp_crt_get_fingerprint = (
797
_library.gnutls_openpgp_crt_get_fingerprint)
798
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
802
openpgp_crt_get_fingerprint.restype = _error_code
804
if check_version(b"3.6.4"):
805
certificate_type_get2 = _library.gnutls_certificate_type_get2
806
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
807
certificate_type_get2.restype = _error_code
809
# Remove non-public functions
810
del _error_code, _retry_on_error
813
def call_pipe(connection, # : multiprocessing.Connection
814
func, *args, **kwargs):
815
"""This function is meant to be called by multiprocessing.Process
817
This function runs func(*args, **kwargs), and writes the resulting
818
return value on the provided multiprocessing.Connection.
820
connection.send(func(*args, **kwargs))
403
825
"""A representation of a client host served by this server.
406
828
approved: bool(); 'None' if not yet approved/disapproved
407
829
approval_delay: datetime.timedelta(); Time to wait for approval
408
830
approval_duration: datetime.timedelta(); Duration of one approval
409
checker: subprocess.Popen(); a running checker process used
410
to see if the client lives.
411
'None' if no process is running.
412
checker_callback_tag: a gobject event source tag, or None
831
checker: multiprocessing.Process(); a running checker process used
832
to see if the client lives. 'None' if no process is
834
checker_callback_tag: a GLib event source tag, or None
413
835
checker_command: string; External command which is run to check
414
836
if client lives. %() expansions are done at
415
837
runtime with vars(self) as dict, so that for
416
838
instance %(name)s can be used in the command.
417
checker_initiator_tag: a gobject event source tag, or None
839
checker_initiator_tag: a GLib event source tag, or None
418
840
created: datetime.datetime(); (UTC) object creation
419
841
client_structure: Object describing what attributes a client has
420
842
and is used for storing the client at exit
421
843
current_checker_command: string; current running checker_command
422
disable_initiator_tag: a gobject event source tag, or None
844
disable_initiator_tag: a GLib event source tag, or None
424
846
fingerprint: string (40 or 32 hexadecimal digits); used to
425
uniquely identify the client
847
uniquely identify an OpenPGP client
848
key_id: string (64 hexadecimal digits); used to uniquely identify
849
a client using raw public keys
426
850
host: string; available for use by the checker command
427
851
interval: datetime.timedelta(); How often to start a new checker
428
852
last_approval_request: datetime.datetime(); (UTC) or None
591
1009
logger.info("Disabling client %s", self.name)
592
1010
if getattr(self, "disable_initiator_tag", None) is not None:
593
gobject.source_remove(self.disable_initiator_tag)
1011
GLib.source_remove(self.disable_initiator_tag)
594
1012
self.disable_initiator_tag = None
595
1013
self.expires = None
596
1014
if getattr(self, "checker_initiator_tag", None) is not None:
597
gobject.source_remove(self.checker_initiator_tag)
1015
GLib.source_remove(self.checker_initiator_tag)
598
1016
self.checker_initiator_tag = None
599
1017
self.stop_checker()
600
1018
self.enabled = False
602
1020
self.send_changedstate()
603
# Do not run this again if called by a gobject.timeout_add
1021
# Do not run this again if called by a GLib.timeout_add
606
1024
def __del__(self):
609
1027
def init_checker(self):
610
1028
# Schedule a new checker to be started an 'interval' from now,
611
1029
# and every interval from then on.
612
1030
if self.checker_initiator_tag is not None:
613
gobject.source_remove(self.checker_initiator_tag)
614
self.checker_initiator_tag = (gobject.timeout_add
615
(self.interval_milliseconds(),
1031
GLib.source_remove(self.checker_initiator_tag)
1032
self.checker_initiator_tag = GLib.timeout_add(
1033
int(self.interval.total_seconds() * 1000),
617
1035
# Schedule a disable() when 'timeout' has passed
618
1036
if self.disable_initiator_tag is not None:
619
gobject.source_remove(self.disable_initiator_tag)
620
self.disable_initiator_tag = (gobject.timeout_add
621
(self.timeout_milliseconds(),
1037
GLib.source_remove(self.disable_initiator_tag)
1038
self.disable_initiator_tag = GLib.timeout_add(
1039
int(self.timeout.total_seconds() * 1000), self.disable)
623
1040
# Also start a new checker *right now*.
624
1041
self.start_checker()
626
def checker_callback(self, pid, condition, command):
1043
def checker_callback(self, source, condition, connection,
627
1045
"""The checker has completed, so take appropriate actions."""
1046
# Read return code from connection (see call_pipe)
1047
returncode = connection.recv()
628
1050
self.checker_callback_tag = None
629
1051
self.checker = None
630
if os.WIFEXITED(condition):
631
self.last_checker_status = os.WEXITSTATUS(condition)
1054
self.last_checker_status = returncode
1055
self.last_checker_signal = None
632
1056
if self.last_checker_status == 0:
633
1057
logger.info("Checker for %(name)s succeeded",
635
1059
self.checked_ok()
637
logger.info("Checker for %(name)s failed",
1061
logger.info("Checker for %(name)s failed", vars(self))
640
1063
self.last_checker_status = -1
1064
self.last_checker_signal = -returncode
641
1065
logger.warning("Checker for %(name)s crashed?",
644
1069
def checked_ok(self):
645
1070
"""Assert that the client has been seen, alive and well."""
646
1071
self.last_checked_ok = datetime.datetime.utcnow()
647
1072
self.last_checker_status = 0
1073
self.last_checker_signal = None
648
1074
self.bump_timeout()
650
1076
def bump_timeout(self, timeout=None):
651
1077
"""Bump up the timeout for this client."""
652
1078
if timeout is None:
653
1079
timeout = self.timeout
654
1080
if self.disable_initiator_tag is not None:
655
gobject.source_remove(self.disable_initiator_tag)
1081
GLib.source_remove(self.disable_initiator_tag)
656
1082
self.disable_initiator_tag = None
657
1083
if getattr(self, "enabled", False):
658
self.disable_initiator_tag = (gobject.timeout_add
659
(timedelta_to_milliseconds
660
(timeout), self.disable))
1084
self.disable_initiator_tag = GLib.timeout_add(
1085
int(timeout.total_seconds() * 1000), self.disable)
661
1086
self.expires = datetime.datetime.utcnow() + timeout
663
1088
def need_approval(self):
664
1089
self.last_approval_request = datetime.datetime.utcnow()
666
1091
def start_checker(self):
667
1092
"""Start a new checker subprocess if one is not running.
669
1094
If a checker already exists, leave it running and do
671
1096
# The reason for not killing a running checker is that if we
676
1101
# checkers alone, the checker would have to take more time
677
1102
# than 'timeout' for the client to be disabled, which is as it
680
# If a checker exists, make sure it is not a zombie
682
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
683
except (AttributeError, OSError) as error:
684
if (isinstance(error, OSError)
685
and error.errno != errno.ECHILD):
689
logger.warning("Checker was a zombie")
690
gobject.source_remove(self.checker_callback_tag)
691
self.checker_callback(pid, status,
692
self.current_checker_command)
1105
if self.checker is not None and not self.checker.is_alive():
1106
logger.warning("Checker was not alive; joining")
693
1109
# Start a new checker if needed
694
1110
if self.checker is None:
695
1111
# Escape attributes for the shell
696
escaped_attrs = dict(
697
(attr, re.escape(unicode(getattr(self, attr))))
699
self.runtime_expansions)
1113
attr: re.escape(str(getattr(self, attr)))
1114
for attr in self.runtime_expansions}
701
1116
command = self.checker_command % escaped_attrs
702
1117
except TypeError as error:
703
1118
logger.error('Could not format string "%s"',
704
self.checker_command, exc_info=error)
705
return True # Try again later
1119
self.checker_command,
1121
return True # Try again later
706
1122
self.current_checker_command = command
708
logger.info("Starting checker %r for %s",
710
# We don't need to redirect stdout and stderr, since
711
# in normal mode, that is already done by daemon(),
712
# and in debug mode we don't want to. (Stdin is
713
# always replaced by /dev/null.)
714
self.checker = subprocess.Popen(command,
717
except OSError as error:
718
logger.error("Failed to start subprocess",
721
self.checker_callback_tag = (gobject.child_watch_add
723
self.checker_callback,
725
# The checker may have completed before the gobject
726
# watch was added. Check for this.
728
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
729
except OSError as error:
730
if error.errno == errno.ECHILD:
731
logger.error("Child process vanished", exc_info=error)
735
gobject.source_remove(self.checker_callback_tag)
736
self.checker_callback(pid, status, command)
737
# Re-run this periodically if run by gobject.timeout_add
1123
logger.info("Starting checker %r for %s", command,
1125
# We don't need to redirect stdout and stderr, since
1126
# in normal mode, that is already done by daemon(),
1127
# and in debug mode we don't want to. (Stdin is
1128
# always replaced by /dev/null.)
1129
# The exception is when not debugging but nevertheless
1130
# running in the foreground; use the previously
1132
popen_args = {"close_fds": True,
1135
if (not self.server_settings["debug"]
1136
and self.server_settings["foreground"]):
1137
popen_args.update({"stdout": wnull,
1139
pipe = multiprocessing.Pipe(duplex=False)
1140
self.checker = multiprocessing.Process(
1142
args=(pipe[1], subprocess.call, command),
1144
self.checker.start()
1145
self.checker_callback_tag = GLib.io_add_watch(
1146
pipe[0].fileno(), GLib.IO_IN,
1147
self.checker_callback, pipe[0], command)
1148
# Re-run this periodically if run by GLib.timeout_add
740
1151
def stop_checker(self):
741
1152
"""Force the checker process, if any, to stop."""
742
1153
if self.checker_callback_tag:
743
gobject.source_remove(self.checker_callback_tag)
1154
GLib.source_remove(self.checker_callback_tag)
744
1155
self.checker_callback_tag = None
745
1156
if getattr(self, "checker", None) is None:
747
1158
logger.debug("Stopping checker for %(name)s", vars(self))
749
self.checker.terminate()
751
#if self.checker.poll() is None:
752
# self.checker.kill()
753
except OSError as error:
754
if error.errno != errno.ESRCH: # No such process
1159
self.checker.terminate()
756
1160
self.checker = None
759
def dbus_service_property(dbus_interface, signature="v",
760
access="readwrite", byte_arrays=False):
1163
def dbus_service_property(dbus_interface,
761
1167
"""Decorators for marking methods of a DBusObjectWithProperties to
762
1168
become properties on the D-Bus.
764
1170
The decorated method will be called with no arguments by "Get"
765
1171
and with one argument by "Set".
767
1173
The parameters, where they are supported, are the same as
768
1174
dbus.service.method, except there is only "signature", since the
769
1175
type from Get() and the type sent to Set() is the same.
845
class DBusObjectWithProperties(dbus.service.Object):
846
"""A D-Bus object with properties.
848
Classes inheriting from this can use the dbus_service_property
849
decorator to expose methods as D-Bus properties. It exposes the
850
standard Get(), Set(), and GetAll() methods on the D-Bus.
1258
class DBusObjectWithAnnotations(dbus.service.Object):
1259
"""A D-Bus object with annotations.
1261
Classes inheriting from this can use the dbus_annotations
1262
decorator to add annotations to methods or signals.
854
1266
def _is_dbus_thing(thing):
855
1267
"""Returns a function testing if an attribute is a D-Bus thing
857
1269
If called like _is_dbus_thing("method") it returns a function
858
1270
suitable for use as predicate to inspect.getmembers().
860
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
1272
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
863
1275
def _get_all_dbus_things(self, thing):
864
1276
"""Returns a generator of (name, attribute) pairs
866
return ((getattr(athing.__get__(self), "_dbus_name",
1278
return ((getattr(athing.__get__(self), "_dbus_name", name),
868
1279
athing.__get__(self))
869
1280
for cls in self.__class__.__mro__
870
1281
for name, athing in
871
inspect.getmembers(cls,
872
self._is_dbus_thing(thing)))
1282
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1284
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1286
path_keyword='object_path',
1287
connection_keyword='connection')
1288
def Introspect(self, object_path, connection):
1289
"""Overloading of standard D-Bus method.
1291
Inserts annotation tags on methods and signals.
1293
xmlstring = dbus.service.Object.Introspect(self, object_path,
1296
document = xml.dom.minidom.parseString(xmlstring)
1298
for if_tag in document.getElementsByTagName("interface"):
1299
# Add annotation tags
1300
for typ in ("method", "signal"):
1301
for tag in if_tag.getElementsByTagName(typ):
1303
for name, prop in (self.
1304
_get_all_dbus_things(typ)):
1305
if (name == tag.getAttribute("name")
1306
and prop._dbus_interface
1307
== if_tag.getAttribute("name")):
1308
annots.update(getattr(
1309
prop, "_dbus_annotations", {}))
1310
for name, value in annots.items():
1311
ann_tag = document.createElement(
1313
ann_tag.setAttribute("name", name)
1314
ann_tag.setAttribute("value", value)
1315
tag.appendChild(ann_tag)
1316
# Add interface annotation tags
1317
for annotation, value in dict(
1318
itertools.chain.from_iterable(
1319
annotations().items()
1320
for name, annotations
1321
in self._get_all_dbus_things("interface")
1322
if name == if_tag.getAttribute("name")
1324
ann_tag = document.createElement("annotation")
1325
ann_tag.setAttribute("name", annotation)
1326
ann_tag.setAttribute("value", value)
1327
if_tag.appendChild(ann_tag)
1328
# Fix argument name for the Introspect method itself
1329
if (if_tag.getAttribute("name")
1330
== dbus.INTROSPECTABLE_IFACE):
1331
for cn in if_tag.getElementsByTagName("method"):
1332
if cn.getAttribute("name") == "Introspect":
1333
for arg in cn.getElementsByTagName("arg"):
1334
if (arg.getAttribute("direction")
1336
arg.setAttribute("name",
1338
xmlstring = document.toxml("utf-8")
1340
except (AttributeError, xml.dom.DOMException,
1341
xml.parsers.expat.ExpatError) as error:
1342
logger.error("Failed to override Introspection method",
1347
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1348
"""A D-Bus object with properties.
1350
Classes inheriting from this can use the dbus_service_property
1351
decorator to expose methods as D-Bus properties. It exposes the
1352
standard Get(), Set(), and GetAll() methods on the D-Bus.
874
1355
def _get_dbus_property(self, interface_name, property_name):
875
1356
"""Returns a bound method if one exists which is a D-Bus
876
1357
property with the specified name and interface.
878
for cls in self.__class__.__mro__:
879
for name, value in (inspect.getmembers
881
self._is_dbus_thing("property"))):
1359
for cls in self.__class__.__mro__:
1360
for name, value in inspect.getmembers(
1361
cls, self._is_dbus_thing("property")):
882
1362
if (value._dbus_name == property_name
883
1363
and value._dbus_interface == interface_name):
884
1364
return value.__get__(self)
886
1366
# No such property
887
raise DBusPropertyNotFound(self.dbus_object_path + ":"
888
+ interface_name + "."
891
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
1367
raise DBusPropertyNotFound("{}:{}.{}".format(
1368
self.dbus_object_path, interface_name, property_name))
1371
def _get_all_interface_names(cls):
1372
"""Get a sequence of all interfaces supported by an object"""
1373
return (name for name in set(getattr(getattr(x, attr),
1374
"_dbus_interface", None)
1375
for x in (inspect.getmro(cls))
1377
if name is not None)
1379
@dbus.service.method(dbus.PROPERTIES_IFACE,
892
1381
out_signature="v")
893
1382
def Get(self, interface_name, property_name):
894
1383
"""Standard D-Bus property Get() method, see D-Bus standard.
1024
1512
return xmlstring
1516
dbus.OBJECT_MANAGER_IFACE
1517
except AttributeError:
1518
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1521
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1522
"""A D-Bus object with an ObjectManager.
1524
Classes inheriting from this exposes the standard
1525
GetManagedObjects call and the InterfacesAdded and
1526
InterfacesRemoved signals on the standard
1527
"org.freedesktop.DBus.ObjectManager" interface.
1529
Note: No signals are sent automatically; they must be sent
1532
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1533
out_signature="a{oa{sa{sv}}}")
1534
def GetManagedObjects(self):
1535
"""This function must be overridden"""
1536
raise NotImplementedError()
1538
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1539
signature="oa{sa{sv}}")
1540
def InterfacesAdded(self, object_path, interfaces_and_properties):
1543
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1544
def InterfacesRemoved(self, object_path, interfaces):
1547
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1549
path_keyword='object_path',
1550
connection_keyword='connection')
1551
def Introspect(self, object_path, connection):
1552
"""Overloading of standard D-Bus method.
1554
Override return argument name of GetManagedObjects to be
1555
"objpath_interfaces_and_properties"
1557
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1561
document = xml.dom.minidom.parseString(xmlstring)
1563
for if_tag in document.getElementsByTagName("interface"):
1564
# Fix argument name for the GetManagedObjects method
1565
if (if_tag.getAttribute("name")
1566
== dbus.OBJECT_MANAGER_IFACE):
1567
for cn in if_tag.getElementsByTagName("method"):
1568
if (cn.getAttribute("name")
1569
== "GetManagedObjects"):
1570
for arg in cn.getElementsByTagName("arg"):
1571
if (arg.getAttribute("direction")
1575
"objpath_interfaces"
1577
xmlstring = document.toxml("utf-8")
1579
except (AttributeError, xml.dom.DOMException,
1580
xml.parsers.expat.ExpatError) as error:
1581
logger.error("Failed to override Introspection method",
1027
1586
def datetime_to_dbus(dt, variant_level=0):
1028
1587
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1030
return dbus.String("", variant_level = variant_level)
1031
return dbus.String(dt.isoformat(),
1032
variant_level=variant_level)
1589
return dbus.String("", variant_level=variant_level)
1590
return dbus.String(dt.isoformat(), variant_level=variant_level)
1035
1593
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1388
1954
server to mandos-client
1392
1958
# Rejected - signal
1393
1959
@dbus.service.signal(_interface, signature="s")
1394
1960
def Rejected(self, reason):
1398
1964
# NeedApproval - signal
1399
1965
@dbus.service.signal(_interface, signature="tb")
1400
1966
def NeedApproval(self, timeout, default):
1402
1968
return self.need_approval()
1406
1972
# Approve - method
1407
1973
@dbus.service.method(_interface, in_signature="b")
1408
1974
def Approve(self, value):
1409
1975
self.approve(value)
1411
1977
# CheckedOK - method
1412
1978
@dbus.service.method(_interface)
1413
1979
def CheckedOK(self):
1414
1980
self.checked_ok()
1416
1982
# Enable - method
1983
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1417
1984
@dbus.service.method(_interface)
1418
1985
def Enable(self):
1422
1989
# StartChecker - method
1990
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1423
1991
@dbus.service.method(_interface)
1424
1992
def StartChecker(self):
1426
1994
self.start_checker()
1428
1996
# Disable - method
1997
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1429
1998
@dbus.service.method(_interface)
1430
1999
def Disable(self):
1434
2003
# StopChecker - method
2004
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1435
2005
@dbus.service.method(_interface)
1436
2006
def StopChecker(self):
1437
2007
self.stop_checker()
1441
2011
# ApprovalPending - property
1442
2012
@dbus_service_property(_interface, signature="b", access="read")
1443
2013
def ApprovalPending_dbus_property(self):
1444
2014
return dbus.Boolean(bool(self.approvals_pending))
1446
2016
# ApprovedByDefault - property
1447
@dbus_service_property(_interface, signature="b",
2017
@dbus_service_property(_interface,
1448
2019
access="readwrite")
1449
2020
def ApprovedByDefault_dbus_property(self, value=None):
1450
2021
if value is None: # get
1451
2022
return dbus.Boolean(self.approved_by_default)
1452
2023
self.approved_by_default = bool(value)
1454
2025
# ApprovalDelay - property
1455
@dbus_service_property(_interface, signature="t",
2026
@dbus_service_property(_interface,
1456
2028
access="readwrite")
1457
2029
def ApprovalDelay_dbus_property(self, value=None):
1458
2030
if value is None: # get
1459
return dbus.UInt64(self.approval_delay_milliseconds())
2031
return dbus.UInt64(self.approval_delay.total_seconds()
1460
2033
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1462
2035
# ApprovalDuration - property
1463
@dbus_service_property(_interface, signature="t",
2036
@dbus_service_property(_interface,
1464
2038
access="readwrite")
1465
2039
def ApprovalDuration_dbus_property(self, value=None):
1466
2040
if value is None: # get
1467
return dbus.UInt64(timedelta_to_milliseconds(
1468
self.approval_duration))
2041
return dbus.UInt64(self.approval_duration.total_seconds()
1469
2043
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1471
2045
# Name - property
2047
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1472
2048
@dbus_service_property(_interface, signature="s", access="read")
1473
2049
def Name_dbus_property(self):
1474
2050
return dbus.String(self.name)
2054
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2055
@dbus_service_property(_interface, signature="s", access="read")
2056
def KeyID_dbus_property(self):
2057
return dbus.String(self.key_id)
1476
2059
# Fingerprint - property
2061
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1477
2062
@dbus_service_property(_interface, signature="s", access="read")
1478
2063
def Fingerprint_dbus_property(self):
1479
2064
return dbus.String(self.fingerprint)
1481
2066
# Host - property
1482
@dbus_service_property(_interface, signature="s",
2067
@dbus_service_property(_interface,
1483
2069
access="readwrite")
1484
2070
def Host_dbus_property(self, value=None):
1485
2071
if value is None: # get
1486
2072
return dbus.String(self.host)
1487
self.host = unicode(value)
2073
self.host = str(value)
1489
2075
# Created - property
2077
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1490
2078
@dbus_service_property(_interface, signature="s", access="read")
1491
2079
def Created_dbus_property(self):
1492
2080
return datetime_to_dbus(self.created)
1494
2082
# LastEnabled - property
1495
2083
@dbus_service_property(_interface, signature="s", access="read")
1496
2084
def LastEnabled_dbus_property(self):
1497
2085
return datetime_to_dbus(self.last_enabled)
1499
2087
# Enabled - property
1500
@dbus_service_property(_interface, signature="b",
2088
@dbus_service_property(_interface,
1501
2090
access="readwrite")
1502
2091
def Enabled_dbus_property(self, value=None):
1503
2092
if value is None: # get
1551
2141
if (getattr(self, "disable_initiator_tag", None)
1554
gobject.source_remove(self.disable_initiator_tag)
1555
self.disable_initiator_tag = (
1556
gobject.timeout_add(
1557
timedelta_to_milliseconds(self.expires - now),
2144
GLib.source_remove(self.disable_initiator_tag)
2145
self.disable_initiator_tag = GLib.timeout_add(
2146
int((self.expires - now).total_seconds() * 1000),
1560
2149
# ExtendedTimeout - property
1561
@dbus_service_property(_interface, signature="t",
2150
@dbus_service_property(_interface,
1562
2152
access="readwrite")
1563
2153
def ExtendedTimeout_dbus_property(self, value=None):
1564
2154
if value is None: # get
1565
return dbus.UInt64(self.extended_timeout_milliseconds())
2155
return dbus.UInt64(self.extended_timeout.total_seconds()
1566
2157
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1568
2159
# Interval - property
1569
@dbus_service_property(_interface, signature="t",
2160
@dbus_service_property(_interface,
1570
2162
access="readwrite")
1571
2163
def Interval_dbus_property(self, value=None):
1572
2164
if value is None: # get
1573
return dbus.UInt64(self.interval_milliseconds())
2165
return dbus.UInt64(self.interval.total_seconds() * 1000)
1574
2166
self.interval = datetime.timedelta(0, 0, 0, value)
1575
2167
if getattr(self, "checker_initiator_tag", None) is None:
1577
2169
if self.enabled:
1578
2170
# Reschedule checker run
1579
gobject.source_remove(self.checker_initiator_tag)
1580
self.checker_initiator_tag = (gobject.timeout_add
1581
(value, self.start_checker))
1582
self.start_checker() # Start one now, too
2171
GLib.source_remove(self.checker_initiator_tag)
2172
self.checker_initiator_tag = GLib.timeout_add(
2173
value, self.start_checker)
2174
self.start_checker() # Start one now, too
1584
2176
# Checker - property
1585
@dbus_service_property(_interface, signature="s",
2177
@dbus_service_property(_interface,
1586
2179
access="readwrite")
1587
2180
def Checker_dbus_property(self, value=None):
1588
2181
if value is None: # get
1589
2182
return dbus.String(self.checker_command)
1590
self.checker_command = unicode(value)
2183
self.checker_command = str(value)
1592
2185
# CheckerRunning - property
1593
@dbus_service_property(_interface, signature="b",
2186
@dbus_service_property(_interface,
1594
2188
access="readwrite")
1595
2189
def CheckerRunning_dbus_property(self, value=None):
1596
2190
if value is None: # get
1643
2247
class ClientHandler(socketserver.BaseRequestHandler, object):
1644
2248
"""A class to handle client connections.
1646
2250
Instantiated once for each connection to handle it.
1647
2251
Note: This will run in its own forked process."""
1649
2253
def handle(self):
1650
2254
with contextlib.closing(self.server.child_pipe) as child_pipe:
1651
2255
logger.info("TCP connection from: %s",
1652
unicode(self.client_address))
2256
str(self.client_address))
1653
2257
logger.debug("Pipe FD: %d",
1654
2258
self.server.child_pipe.fileno())
1656
session = (gnutls.connection
1657
.ClientSession(self.request,
1659
.X509Credentials()))
1661
# Note: gnutls.connection.X509Credentials is really a
1662
# generic GnuTLS certificate credentials object so long as
1663
# no X.509 keys are added to it. Therefore, we can use it
1664
# here despite using OpenPGP certificates.
1666
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1667
# "+AES-256-CBC", "+SHA1",
1668
# "+COMP-NULL", "+CTYPE-OPENPGP",
2260
session = gnutls.ClientSession(self.request)
2262
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2263
# "+AES-256-CBC", "+SHA1",
2264
# "+COMP-NULL", "+CTYPE-OPENPGP",
1670
2266
# Use a fallback default, since this MUST be set.
1671
2267
priority = self.server.gnutls_priority
1672
2268
if priority is None:
1673
2269
priority = "NORMAL"
1674
(gnutls.library.functions
1675
.gnutls_priority_set_direct(session._c_object,
2270
gnutls.priority_set_direct(session._c_object,
2271
priority.encode("utf-8"),
1678
2274
# Start communication using the Mandos protocol
1679
2275
# Get protocol number
1680
2276
line = self.request.makefile().readline()
1681
2277
logger.debug("Protocol version: %r", line)
1683
2279
if int(line.strip().split()[0]) > 1:
2280
raise RuntimeError(line)
1685
2281
except (ValueError, IndexError, RuntimeError) as error:
1686
2282
logger.error("Unknown protocol version: %s", error)
1689
2285
# Start GnuTLS connection
1691
2287
session.handshake()
1692
except gnutls.errors.GNUTLSError as error:
2288
except gnutls.Error as error:
1693
2289
logger.warning("Handshake failed: %s", error)
1694
2290
# Do not run session.bye() here: the session is not
1695
2291
# established. Just abandon the request.
1697
2293
logger.debug("Handshake succeeded")
1699
2295
approval_required = False
1702
fpr = self.fingerprint(self.peer_certificate
1705
gnutls.errors.GNUTLSError) as error:
1706
logger.warning("Bad certificate: %s", error)
1708
logger.debug("Fingerprint: %s", fpr)
1711
client = ProxyClient(child_pipe, fpr,
2297
if gnutls.has_rawpk:
2300
key_id = self.key_id(
2301
self.peer_certificate(session))
2302
except (TypeError, gnutls.Error) as error:
2303
logger.warning("Bad certificate: %s", error)
2305
logger.debug("Key ID: %s", key_id)
2310
fpr = self.fingerprint(
2311
self.peer_certificate(session))
2312
except (TypeError, gnutls.Error) as error:
2313
logger.warning("Bad certificate: %s", error)
2315
logger.debug("Fingerprint: %s", fpr)
2318
client = ProxyClient(child_pipe, key_id, fpr,
1712
2319
self.client_address)
1713
2320
except KeyError:
1716
2323
if client.approval_delay:
1717
2324
delay = client.approval_delay
1718
2325
client.approvals_pending += 1
1719
2326
approval_required = True
1722
2329
if not client.enabled:
1723
2330
logger.info("Client %s is disabled",
1725
2332
if self.server.use_dbus:
1726
2333
# Emit D-Bus signal
1727
2334
client.Rejected("Disabled")
1730
2337
if client.approved or not client.approval_delay:
1731
#We are approved or approval is disabled
2338
# We are approved or approval is disabled
1733
2340
elif client.approved is None:
1734
2341
logger.info("Client %s needs approval",
1769
2374
delay -= time2 - time
1772
while sent_size < len(client.secret):
1774
sent = session.send(client.secret[sent_size:])
1775
except gnutls.errors.GNUTLSError as error:
1776
logger.warning("gnutls send failed",
1779
logger.debug("Sent: %d, remaining: %d",
1780
sent, len(client.secret)
1781
- (sent_size + sent))
2377
session.send(client.secret)
2378
except gnutls.Error as error:
2379
logger.warning("gnutls send failed",
1784
2383
logger.info("Sending secret to %s", client.name)
1785
2384
# bump the timeout using extended_timeout
1786
2385
client.bump_timeout(client.extended_timeout)
1787
2386
if self.server.use_dbus:
1788
2387
# Emit D-Bus signal
1789
2388
client.GotSecret()
1792
2391
if approval_required:
1793
2392
client.approvals_pending -= 1
1796
except gnutls.errors.GNUTLSError as error:
2395
except gnutls.Error as error:
1797
2396
logger.warning("GnuTLS bye failed",
1798
2397
exc_info=error)
1801
2400
def peer_certificate(session):
1802
"Return the peer's OpenPGP certificate as a bytestring"
1803
# If not an OpenPGP certificate...
1804
if (gnutls.library.functions
1805
.gnutls_certificate_type_get(session._c_object)
1806
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1807
# ...do the normal thing
1808
return session.peer_certificate
2401
"Return the peer's certificate as a bytestring"
2403
cert_type = gnutls.certificate_type_get2(session._c_object,
2405
except AttributeError:
2406
cert_type = gnutls.certificate_type_get(session._c_object)
2407
if gnutls.has_rawpk:
2408
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2410
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2411
# If not a valid certificate type...
2412
if cert_type not in valid_cert_types:
2413
logger.info("Cert type %r not in %r", cert_type,
2415
# ...return invalid data
1809
2417
list_size = ctypes.c_uint(1)
1810
cert_list = (gnutls.library.functions
1811
.gnutls_certificate_get_peers
2418
cert_list = (gnutls.certificate_get_peers
1812
2419
(session._c_object, ctypes.byref(list_size)))
1813
2420
if not bool(cert_list) and list_size.value != 0:
1814
raise gnutls.errors.GNUTLSError("error getting peer"
2421
raise gnutls.Error("error getting peer certificate")
1816
2422
if list_size.value == 0:
1818
2424
cert = cert_list[0]
1819
2425
return ctypes.string_at(cert.data, cert.size)
2428
def key_id(certificate):
2429
"Convert a certificate bytestring to a hexdigit key ID"
2430
# New GnuTLS "datum" with the public key
2431
datum = gnutls.datum_t(
2432
ctypes.cast(ctypes.c_char_p(certificate),
2433
ctypes.POINTER(ctypes.c_ubyte)),
2434
ctypes.c_uint(len(certificate)))
2435
# XXX all these need to be created in the gnutls "module"
2436
# New empty GnuTLS certificate
2437
pubkey = gnutls.pubkey_t()
2438
gnutls.pubkey_init(ctypes.byref(pubkey))
2439
# Import the raw public key into the certificate
2440
gnutls.pubkey_import(pubkey,
2441
ctypes.byref(datum),
2442
gnutls.X509_FMT_DER)
2443
# New buffer for the key ID
2444
buf = ctypes.create_string_buffer(32)
2445
buf_len = ctypes.c_size_t(len(buf))
2446
# Get the key ID from the raw public key into the buffer
2447
gnutls.pubkey_get_key_id(pubkey,
2448
gnutls.KEYID_USE_SHA256,
2449
ctypes.cast(ctypes.byref(buf),
2450
ctypes.POINTER(ctypes.c_ubyte)),
2451
ctypes.byref(buf_len))
2452
# Deinit the certificate
2453
gnutls.pubkey_deinit(pubkey)
2455
# Convert the buffer to a Python bytestring
2456
key_id = ctypes.string_at(buf, buf_len.value)
2457
# Convert the bytestring to hexadecimal notation
2458
hex_key_id = binascii.hexlify(key_id).upper()
1822
2462
def fingerprint(openpgp):
1823
2463
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1824
2464
# New GnuTLS "datum" with the OpenPGP public key
1825
datum = (gnutls.library.types
1826
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1829
ctypes.c_uint(len(openpgp))))
2465
datum = gnutls.datum_t(
2466
ctypes.cast(ctypes.c_char_p(openpgp),
2467
ctypes.POINTER(ctypes.c_ubyte)),
2468
ctypes.c_uint(len(openpgp)))
1830
2469
# New empty GnuTLS certificate
1831
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1832
(gnutls.library.functions
1833
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2470
crt = gnutls.openpgp_crt_t()
2471
gnutls.openpgp_crt_init(ctypes.byref(crt))
1834
2472
# Import the OpenPGP public key into the certificate
1835
(gnutls.library.functions
1836
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1837
gnutls.library.constants
1838
.GNUTLS_OPENPGP_FMT_RAW))
2473
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2474
gnutls.OPENPGP_FMT_RAW)
1839
2475
# Verify the self signature in the key
1840
2476
crtverify = ctypes.c_uint()
1841
(gnutls.library.functions
1842
.gnutls_openpgp_crt_verify_self(crt, 0,
1843
ctypes.byref(crtverify)))
2477
gnutls.openpgp_crt_verify_self(crt, 0,
2478
ctypes.byref(crtverify))
1844
2479
if crtverify.value != 0:
1845
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1846
raise (gnutls.errors.CertificateSecurityError
2480
gnutls.openpgp_crt_deinit(crt)
2481
raise gnutls.CertificateSecurityError(code
1848
2483
# New buffer for the fingerprint
1849
2484
buf = ctypes.create_string_buffer(20)
1850
2485
buf_len = ctypes.c_size_t()
1851
2486
# Get the fingerprint from the certificate into the buffer
1852
(gnutls.library.functions
1853
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1854
ctypes.byref(buf_len)))
2487
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2488
ctypes.byref(buf_len))
1855
2489
# Deinit the certificate
1856
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2490
gnutls.openpgp_crt_deinit(crt)
1857
2491
# Convert the buffer to a Python bytestring
1858
2492
fpr = ctypes.string_at(buf, buf_len.value)
1859
2493
# Convert the bytestring to hexadecimal notation
1942
2582
# socket_wrapper(), if socketfd was set.
1943
2583
socketserver.TCPServer.__init__(self, server_address,
1944
2584
RequestHandlerClass)
1946
2586
def server_bind(self):
1947
2587
"""This overrides the normal server_bind() function
1948
2588
to bind to an interface if one was specified, and also NOT to
1949
2589
bind to an address or port if they were not specified."""
2590
global SO_BINDTODEVICE
1950
2591
if self.interface is not None:
1951
2592
if SO_BINDTODEVICE is None:
1952
logger.error("SO_BINDTODEVICE does not exist;"
1953
" cannot bind to interface %s",
1957
self.socket.setsockopt(socket.SOL_SOCKET,
1959
str(self.interface + '\0'))
1960
except socket.error as error:
1961
if error.errno == errno.EPERM:
1962
logger.error("No permission to bind to"
1963
" interface %s", self.interface)
1964
elif error.errno == errno.ENOPROTOOPT:
1965
logger.error("SO_BINDTODEVICE not available;"
1966
" cannot bind to interface %s",
1968
elif error.errno == errno.ENODEV:
1969
logger.error("Interface %s does not exist,"
1970
" cannot bind", self.interface)
2593
# Fall back to a hard-coded value which seems to be
2595
logger.warning("SO_BINDTODEVICE not found, trying 25")
2596
SO_BINDTODEVICE = 25
2598
self.socket.setsockopt(
2599
socket.SOL_SOCKET, SO_BINDTODEVICE,
2600
(self.interface + "\0").encode("utf-8"))
2601
except socket.error as error:
2602
if error.errno == errno.EPERM:
2603
logger.error("No permission to bind to"
2604
" interface %s", self.interface)
2605
elif error.errno == errno.ENOPROTOOPT:
2606
logger.error("SO_BINDTODEVICE not available;"
2607
" cannot bind to interface %s",
2609
elif error.errno == errno.ENODEV:
2610
logger.error("Interface %s does not exist,"
2611
" cannot bind", self.interface)
1973
2614
# Only bind(2) the socket if we really need to.
1974
2615
if self.server_address[0] or self.server_address[1]:
2616
if self.server_address[1]:
2617
self.allow_reuse_address = True
1975
2618
if not self.server_address[0]:
1976
2619
if self.address_family == socket.AF_INET6:
1977
any_address = "::" # in6addr_any
2620
any_address = "::" # in6addr_any
1979
any_address = socket.INADDR_ANY
2622
any_address = "0.0.0.0" # INADDR_ANY
1980
2623
self.server_address = (any_address,
1981
2624
self.server_address[1])
1982
2625
elif not self.server_address[1]:
1983
self.server_address = (self.server_address[0],
2626
self.server_address = (self.server_address[0], 0)
1985
2627
# if self.interface:
1986
2628
# self.server_address = (self.server_address[0],
2012
2659
self.gnutls_priority = gnutls_priority
2013
2660
IPv6_TCPServer.__init__(self, server_address,
2014
2661
RequestHandlerClass,
2015
interface = interface,
2016
use_ipv6 = use_ipv6,
2017
socketfd = socketfd)
2662
interface=interface,
2018
2666
def server_activate(self):
2019
2667
if self.enabled:
2020
2668
return socketserver.TCPServer.server_activate(self)
2022
2670
def enable(self):
2023
2671
self.enabled = True
2025
2673
def add_pipe(self, parent_pipe, proc):
2026
2674
# Call "handle_ipc" for both data and EOF events
2027
gobject.io_add_watch(parent_pipe.fileno(),
2028
gobject.IO_IN | gobject.IO_HUP,
2029
functools.partial(self.handle_ipc,
2034
def handle_ipc(self, source, condition, parent_pipe=None,
2035
proc = None, client_object=None):
2676
parent_pipe.fileno(),
2677
GLib.IO_IN | GLib.IO_HUP,
2678
functools.partial(self.handle_ipc,
2679
parent_pipe=parent_pipe,
2682
def handle_ipc(self, source, condition,
2685
client_object=None):
2036
2686
# error, or the other end of multiprocessing.Pipe has closed
2037
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2687
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2038
2688
# Wait for other process to exit
2042
2692
# Read a request from the child
2043
2693
request = parent_pipe.recv()
2044
2694
command = request[0]
2046
2696
if command == 'init':
2048
address = request[2]
2050
for c in self.clients.itervalues():
2051
if c.fingerprint == fpr:
2697
key_id = request[1].decode("ascii")
2698
fpr = request[2].decode("ascii")
2699
address = request[3]
2701
for c in self.clients.values():
2702
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2704
if key_id and c.key_id == key_id:
2707
if fpr and c.fingerprint == fpr:
2055
logger.info("Client not found for fingerprint: %s, ad"
2056
"dress: %s", fpr, address)
2711
logger.info("Client not found for key ID: %s, address"
2712
": %s", key_id or fpr, address)
2057
2713
if self.use_dbus:
2058
2714
# Emit D-Bus signal
2059
mandos_dbus_service.ClientNotFound(fpr,
2715
mandos_dbus_service.ClientNotFound(key_id or fpr,
2061
2717
parent_pipe.send(False)
2064
gobject.io_add_watch(parent_pipe.fileno(),
2065
gobject.IO_IN | gobject.IO_HUP,
2066
functools.partial(self.handle_ipc,
2721
parent_pipe.fileno(),
2722
GLib.IO_IN | GLib.IO_HUP,
2723
functools.partial(self.handle_ipc,
2724
parent_pipe=parent_pipe,
2726
client_object=client))
2072
2727
parent_pipe.send(True)
2073
2728
# remove the old hook in favor of the new above hook on
2301
2956
parser.add_argument("--no-dbus", action="store_false",
2302
2957
dest="use_dbus", help="Do not provide D-Bus"
2303
" system bus interface")
2958
" system bus interface", default=None)
2304
2959
parser.add_argument("--no-ipv6", action="store_false",
2305
dest="use_ipv6", help="Do not use IPv6")
2960
dest="use_ipv6", help="Do not use IPv6",
2306
2962
parser.add_argument("--no-restore", action="store_false",
2307
2963
dest="restore", help="Do not restore stored"
2964
" state", default=None)
2309
2965
parser.add_argument("--socket", type=int,
2310
2966
help="Specify a file descriptor to a network"
2311
2967
" socket to use instead of creating one")
2312
2968
parser.add_argument("--statedir", metavar="DIR",
2313
2969
help="Directory to save/restore state in")
2314
2970
parser.add_argument("--foreground", action="store_true",
2315
help="Run in foreground")
2971
help="Run in foreground", default=None)
2972
parser.add_argument("--no-zeroconf", action="store_false",
2973
dest="zeroconf", help="Do not use Zeroconf",
2317
2976
options = parser.parse_args()
2319
2978
if options.check:
2980
fail_count, test_count = doctest.testmod()
2981
sys.exit(os.EX_OK if fail_count == 0 else 1)
2324
2983
# Default values for config file for server-global settings
2325
server_defaults = { "interface": "",
2330
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2331
"servicename": "Mandos",
2337
"statedir": "/var/lib/mandos",
2338
"foreground": "False",
2984
if gnutls.has_rawpk:
2985
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2986
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2988
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2989
":+SIGN-DSA-SHA256")
2990
server_defaults = {"interface": "",
2994
"priority": priority,
2995
"servicename": "Mandos",
3001
"statedir": "/var/lib/mandos",
3002
"foreground": "False",
2341
3007
# Parse config file for server-global settings
2342
server_config = configparser.SafeConfigParser(server_defaults)
3008
server_config = configparser.ConfigParser(server_defaults)
2343
3009
del server_defaults
2344
server_config.read(os.path.join(options.configdir,
2346
# Convert the SafeConfigParser object to a dict
3010
server_config.read(os.path.join(options.configdir, "mandos.conf"))
3011
# Convert the ConfigParser object to a dict
2347
3012
server_settings = server_config.defaults()
2348
3013
# Use the appropriate methods on the non-string config options
2349
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
3014
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3015
"foreground", "zeroconf"):
2350
3016
server_settings[option] = server_config.getboolean("DEFAULT",
2352
3018
if server_settings["port"]:
3134
logger.debug("Did setuid/setgid to {}:{}".format(uid,
2454
3136
except OSError as error:
3137
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3138
.format(uid, gid, os.strerror(error.errno)))
2455
3139
if error.errno != errno.EPERM:
2459
3143
# Enable all possible GnuTLS debugging
2461
3145
# "Use a log level over 10 to enable all debugging options."
2462
3146
# - GnuTLS manual
2463
gnutls.library.functions.gnutls_global_set_log_level(11)
2465
@gnutls.library.types.gnutls_log_func
3147
gnutls.global_set_log_level(11)
2466
3150
def debug_gnutls(level, string):
2467
3151
logger.debug("GnuTLS: %s", string[:-1])
2469
(gnutls.library.functions
2470
.gnutls_global_set_log_function(debug_gnutls))
3153
gnutls.global_set_log_function(debug_gnutls)
2472
3155
# Redirect stdin so all checkers get /dev/null
2473
3156
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2474
3157
os.dup2(null, sys.stdin.fileno())
2478
3161
# Need to fork before connecting to D-Bus
2479
3162
if not foreground:
2480
3163
# Close all input and output, do double fork, etc.
2483
# multiprocessing will use threads, so before we use gobject we
2484
# need to inform gobject that threads will be used.
2485
gobject.threads_init()
3166
if gi.version_info < (3, 10, 2):
3167
# multiprocessing will use threads, so before we use GLib we
3168
# need to inform GLib that threads will be used.
2487
3171
global main_loop
2488
3172
# From the Avahi example code
2489
3173
DBusGMainLoop(set_as_default=True)
2490
main_loop = gobject.MainLoop()
3174
main_loop = GLib.MainLoop()
2491
3175
bus = dbus.SystemBus()
2492
3176
# End of Avahi example code
2495
3179
bus_name = dbus.service.BusName("se.recompile.Mandos",
2496
bus, do_not_queue=True)
2497
old_bus_name = (dbus.service.BusName
2498
("se.bsnet.fukt.Mandos", bus,
2500
except dbus.exceptions.NameExistsException as e:
3182
old_bus_name = dbus.service.BusName(
3183
"se.bsnet.fukt.Mandos", bus,
3185
except dbus.exceptions.DBusException as e:
2501
3186
logger.error("Disabling D-Bus:", exc_info=e)
2502
3187
use_dbus = False
2503
3188
server_settings["use_dbus"] = False
2504
3189
tcp_server.use_dbus = False
2505
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2506
service = AvahiServiceToSyslog(name =
2507
server_settings["servicename"],
2508
servicetype = "_mandos._tcp",
2509
protocol = protocol, bus = bus)
2510
if server_settings["interface"]:
2511
service.interface = (if_nametoindex
2512
(str(server_settings["interface"])))
3191
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3192
service = AvahiServiceToSyslog(
3193
name=server_settings["servicename"],
3194
servicetype="_mandos._tcp",
3197
if server_settings["interface"]:
3198
service.interface = if_nametoindex(
3199
server_settings["interface"].encode("utf-8"))
2514
3201
global multiprocessing_manager
2515
3202
multiprocessing_manager = multiprocessing.Manager()
2517
3204
client_class = Client
2519
client_class = functools.partial(ClientDBus, bus = bus)
3206
client_class = functools.partial(ClientDBus, bus=bus)
2521
3208
client_settings = Client.config_parser(client_config)
2522
3209
old_client_settings = {}
2523
3210
clients_data = {}
3212
# This is used to redirect stdout and stderr for checker processes
3214
wnull = open(os.devnull, "w") # A writable /dev/null
3215
# Only used if server is running in foreground but not in debug
3217
if debug or not foreground:
2525
3220
# Get client data and settings from last running state.
2526
3221
if server_settings["restore"]:
2528
3223
with open(stored_state_path, "rb") as stored_state:
2529
clients_data, old_client_settings = (pickle.load
3224
if sys.version_info.major == 2:
3225
clients_data, old_client_settings = pickle.load(
3228
bytes_clients_data, bytes_old_client_settings = (
3229
pickle.load(stored_state, encoding="bytes"))
3230
# Fix bytes to strings
3233
clients_data = {(key.decode("utf-8")
3234
if isinstance(key, bytes)
3237
bytes_clients_data.items()}
3238
del bytes_clients_data
3239
for key in clients_data:
3240
value = {(k.decode("utf-8")
3241
if isinstance(k, bytes) else k): v
3243
clients_data[key].items()}
3244
clients_data[key] = value
3246
value["client_structure"] = [
3248
if isinstance(s, bytes)
3250
value["client_structure"]]
3252
for k in ("name", "host"):
3253
if isinstance(value[k], bytes):
3254
value[k] = value[k].decode("utf-8")
3255
if "key_id" not in value:
3256
value["key_id"] = ""
3257
elif "fingerprint" not in value:
3258
value["fingerprint"] = ""
3259
# old_client_settings
3261
old_client_settings = {
3262
(key.decode("utf-8")
3263
if isinstance(key, bytes)
3266
bytes_old_client_settings.items()}
3267
del bytes_old_client_settings
3269
for value in old_client_settings.values():
3270
if isinstance(value["host"], bytes):
3271
value["host"] = (value["host"]
2531
3273
os.remove(stored_state_path)
2532
3274
except IOError as e:
2533
3275
if e.errno == errno.ENOENT:
2534
logger.warning("Could not load persistent state: {0}"
2535
.format(os.strerror(e.errno)))
3276
logger.warning("Could not load persistent state:"
3277
" {}".format(os.strerror(e.errno)))
2537
3279
logger.critical("Could not load persistent state:",
2540
3282
except EOFError as e:
2541
3283
logger.warning("Could not load persistent state: "
2542
"EOFError:", exc_info=e)
2544
3287
with PGPEngine() as pgp:
2545
for client_name, client in clients_data.iteritems():
3288
for client_name, client in clients_data.items():
3289
# Skip removed clients
3290
if client_name not in client_settings:
2546
3293
# Decide which value to use after restoring saved state.
2547
3294
# We have three different values: Old config file,
2548
3295
# new config file, and saved state.
2606
3353
for client_name in (set(client_settings)
2607
3354
- set(old_client_settings)):
2608
3355
clients_data[client_name] = client_settings[client_name]
2610
3357
# Create all client objects
2611
for client_name, client in clients_data.iteritems():
3358
for client_name, client in clients_data.items():
2612
3359
tcp_server.clients[client_name] = client_class(
2613
name = client_name, settings = client)
3362
server_settings=server_settings)
2615
3364
if not tcp_server.clients:
2616
3365
logger.warning("No clients defined")
2618
3367
if not foreground:
2619
3368
if pidfile is not None:
2623
pidfile.write(str(pid) + "\n".encode("utf-8"))
3372
print(pid, file=pidfile)
2624
3373
except IOError:
2625
3374
logger.error("Could not write to file %r with PID %d",
2626
3375
pidfilename, pid)
2628
3377
del pidfilename
2630
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2631
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3379
for termsig in (signal.SIGHUP, signal.SIGTERM):
3380
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3381
lambda: main_loop.quit() and False)
2634
@alternate_dbus_interfaces({"se.recompile.Mandos":
2635
"se.bsnet.fukt.Mandos"})
2636
class MandosDBusService(DBusObjectWithProperties):
3385
@alternate_dbus_interfaces(
3386
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3387
class MandosDBusService(DBusObjectWithObjectManager):
2637
3388
"""A D-Bus proxy object"""
2638
3390
def __init__(self):
2639
3391
dbus.service.Object.__init__(self, bus, "/")
2640
3393
_interface = "se.recompile.Mandos"
2642
@dbus_interface_annotations(_interface)
2644
return { "org.freedesktop.DBus.Property"
2645
".EmitsChangedSignal":
2648
3395
@dbus.service.signal(_interface, signature="o")
2649
3396
def ClientAdded(self, objpath):
2653
3400
@dbus.service.signal(_interface, signature="ss")
2654
def ClientNotFound(self, fingerprint, address):
3401
def ClientNotFound(self, key_id, address):
3405
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2658
3407
@dbus.service.signal(_interface, signature="os")
2659
3408
def ClientRemoved(self, objpath, name):
3412
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2663
3414
@dbus.service.method(_interface, out_signature="ao")
2664
3415
def GetAllClients(self):
2666
return dbus.Array(c.dbus_object_path
2668
tcp_server.clients.itervalues())
3417
return dbus.Array(c.dbus_object_path for c in
3418
tcp_server.clients.values())
3420
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2670
3422
@dbus.service.method(_interface,
2671
3423
out_signature="a{oa{sv}}")
2672
3424
def GetAllClientsWithProperties(self):
2674
3426
return dbus.Dictionary(
2675
((c.dbus_object_path, c.GetAll(""))
2676
for c in tcp_server.clients.itervalues()),
3427
{c.dbus_object_path: c.GetAll(
3428
"se.recompile.Mandos.Client")
3429
for c in tcp_server.clients.values()},
2677
3430
signature="oa{sv}")
2679
3432
@dbus.service.method(_interface, in_signature="o")
2680
3433
def RemoveClient(self, object_path):
2682
for c in tcp_server.clients.itervalues():
3435
for c in tcp_server.clients.values():
2683
3436
if c.dbus_object_path == object_path:
2684
3437
del tcp_server.clients[c.name]
2685
3438
c.remove_from_connection()
2686
# Don't signal anything except ClientRemoved
3439
# Don't signal the disabling
2687
3440
c.disable(quiet=True)
2689
self.ClientRemoved(object_path, c.name)
3441
# Emit D-Bus signal for removal
3442
self.client_removed_signal(c)
2691
3444
raise KeyError(object_path)
3448
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3449
out_signature="a{oa{sa{sv}}}")
3450
def GetManagedObjects(self):
3452
return dbus.Dictionary(
3453
{client.dbus_object_path:
3455
{interface: client.GetAll(interface)
3457
client._get_all_interface_names()})
3458
for client in tcp_server.clients.values()})
3460
def client_added_signal(self, client):
3461
"""Send the new standard signal and the old signal"""
3463
# New standard signal
3464
self.InterfacesAdded(
3465
client.dbus_object_path,
3467
{interface: client.GetAll(interface)
3469
client._get_all_interface_names()}))
3471
self.ClientAdded(client.dbus_object_path)
3473
def client_removed_signal(self, client):
3474
"""Send the new standard signal and the old signal"""
3476
# New standard signal
3477
self.InterfacesRemoved(
3478
client.dbus_object_path,
3479
client._get_all_interface_names())
3481
self.ClientRemoved(client.dbus_object_path,
2695
3484
mandos_dbus_service = MandosDBusService()
3486
# Save modules to variables to exempt the modules from being
3487
# unloaded before the function registered with atexit() is run.
3488
mp = multiprocessing
2698
3492
"Cleanup function; run on exit"
2701
multiprocessing.active_children()
3496
mp.active_children()
2702
3498
if not (tcp_server.clients or client_settings):
2705
3501
# Store client before exiting. Secrets are encrypted with key
2706
3502
# based on what config file has. If config file is
2707
3503
# removed/edited, old secret will thus be unrecovable.
2709
3505
with PGPEngine() as pgp:
2710
for client in tcp_server.clients.itervalues():
3506
for client in tcp_server.clients.values():
2711
3507
key = client_settings[client.name]["secret"]
2712
3508
client.encrypted_secret = pgp.encrypt(client.secret,
2714
3510
client_dict = {}
2716
3512
# A list of attributes that can not be pickled
2718
exclude = set(("bus", "changedstate", "secret",
2720
for name, typ in (inspect.getmembers
2721
(dbus.service.Object)):
3514
exclude = {"bus", "changedstate", "secret",
3515
"checker", "server_settings"}
3516
for name, typ in inspect.getmembers(dbus.service
2722
3518
exclude.add(name)
2724
3520
client_dict["encrypted_secret"] = (client
2725
3521
.encrypted_secret)
2726
3522
for attr in client.client_structure:
2727
3523
if attr not in exclude:
2728
3524
client_dict[attr] = getattr(client, attr)
2730
3526
clients[client.name] = client_dict
2731
3527
del client_settings[client.name]["secret"]
2734
with (tempfile.NamedTemporaryFile
2735
(mode='wb', suffix=".pickle", prefix='clients-',
2736
dir=os.path.dirname(stored_state_path),
2737
delete=False)) as stored_state:
2738
pickle.dump((clients, client_settings), stored_state)
2739
tempname=stored_state.name
3530
with tempfile.NamedTemporaryFile(
3534
dir=os.path.dirname(stored_state_path),
3535
delete=False) as stored_state:
3536
pickle.dump((clients, client_settings), stored_state,
3538
tempname = stored_state.name
2740
3539
os.rename(tempname, stored_state_path)
2741
3540
except (IOError, OSError) as e: