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",
720
self.checker_callback_tag = (gobject.child_watch_add
722
self.checker_callback,
724
# The checker may have completed before the gobject
725
# watch was added. Check for this.
726
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
728
gobject.source_remove(self.checker_callback_tag)
729
self.checker_callback(pid, status, command)
730
# 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
733
1151
def stop_checker(self):
734
1152
"""Force the checker process, if any, to stop."""
735
1153
if self.checker_callback_tag:
736
gobject.source_remove(self.checker_callback_tag)
1154
GLib.source_remove(self.checker_callback_tag)
737
1155
self.checker_callback_tag = None
738
1156
if getattr(self, "checker", None) is None:
740
1158
logger.debug("Stopping checker for %(name)s", vars(self))
742
self.checker.terminate()
744
#if self.checker.poll() is None:
745
# self.checker.kill()
746
except OSError as error:
747
if error.errno != errno.ESRCH: # No such process
1159
self.checker.terminate()
749
1160
self.checker = None
752
def dbus_service_property(dbus_interface, signature="v",
753
access="readwrite", byte_arrays=False):
1163
def dbus_service_property(dbus_interface,
754
1167
"""Decorators for marking methods of a DBusObjectWithProperties to
755
1168
become properties on the D-Bus.
757
1170
The decorated method will be called with no arguments by "Get"
758
1171
and with one argument by "Set".
760
1173
The parameters, where they are supported, are the same as
761
1174
dbus.service.method, except there is only "signature", since the
762
1175
type from Get() and the type sent to Set() is the same.
838
class DBusObjectWithProperties(dbus.service.Object):
839
"""A D-Bus object with properties.
841
Classes inheriting from this can use the dbus_service_property
842
decorator to expose methods as D-Bus properties. It exposes the
843
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.
847
1266
def _is_dbus_thing(thing):
848
1267
"""Returns a function testing if an attribute is a D-Bus thing
850
1269
If called like _is_dbus_thing("method") it returns a function
851
1270
suitable for use as predicate to inspect.getmembers().
853
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
1272
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
856
1275
def _get_all_dbus_things(self, thing):
857
1276
"""Returns a generator of (name, attribute) pairs
859
return ((getattr(athing.__get__(self), "_dbus_name",
1278
return ((getattr(athing.__get__(self), "_dbus_name", name),
861
1279
athing.__get__(self))
862
1280
for cls in self.__class__.__mro__
863
1281
for name, athing in
864
inspect.getmembers(cls,
865
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.
867
1355
def _get_dbus_property(self, interface_name, property_name):
868
1356
"""Returns a bound method if one exists which is a D-Bus
869
1357
property with the specified name and interface.
871
for cls in self.__class__.__mro__:
872
for name, value in (inspect.getmembers
874
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")):
875
1362
if (value._dbus_name == property_name
876
1363
and value._dbus_interface == interface_name):
877
1364
return value.__get__(self)
879
1366
# No such property
880
raise DBusPropertyNotFound(self.dbus_object_path + ":"
881
+ interface_name + "."
884
@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,
885
1381
out_signature="v")
886
1382
def Get(self, interface_name, property_name):
887
1383
"""Standard D-Bus property Get() method, see D-Bus standard.
1017
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",
1020
1586
def datetime_to_dbus(dt, variant_level=0):
1021
1587
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1023
return dbus.String("", variant_level = variant_level)
1024
return dbus.String(dt.isoformat(),
1025
variant_level=variant_level)
1589
return dbus.String("", variant_level=variant_level)
1590
return dbus.String(dt.isoformat(), variant_level=variant_level)
1028
1593
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1381
1954
server to mandos-client
1385
1958
# Rejected - signal
1386
1959
@dbus.service.signal(_interface, signature="s")
1387
1960
def Rejected(self, reason):
1391
1964
# NeedApproval - signal
1392
1965
@dbus.service.signal(_interface, signature="tb")
1393
1966
def NeedApproval(self, timeout, default):
1395
1968
return self.need_approval()
1399
1972
# Approve - method
1400
1973
@dbus.service.method(_interface, in_signature="b")
1401
1974
def Approve(self, value):
1402
1975
self.approve(value)
1404
1977
# CheckedOK - method
1405
1978
@dbus.service.method(_interface)
1406
1979
def CheckedOK(self):
1407
1980
self.checked_ok()
1409
1982
# Enable - method
1983
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1410
1984
@dbus.service.method(_interface)
1411
1985
def Enable(self):
1415
1989
# StartChecker - method
1990
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1416
1991
@dbus.service.method(_interface)
1417
1992
def StartChecker(self):
1419
1994
self.start_checker()
1421
1996
# Disable - method
1997
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1422
1998
@dbus.service.method(_interface)
1423
1999
def Disable(self):
1427
2003
# StopChecker - method
2004
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1428
2005
@dbus.service.method(_interface)
1429
2006
def StopChecker(self):
1430
2007
self.stop_checker()
1434
2011
# ApprovalPending - property
1435
2012
@dbus_service_property(_interface, signature="b", access="read")
1436
2013
def ApprovalPending_dbus_property(self):
1437
2014
return dbus.Boolean(bool(self.approvals_pending))
1439
2016
# ApprovedByDefault - property
1440
@dbus_service_property(_interface, signature="b",
2017
@dbus_service_property(_interface,
1441
2019
access="readwrite")
1442
2020
def ApprovedByDefault_dbus_property(self, value=None):
1443
2021
if value is None: # get
1444
2022
return dbus.Boolean(self.approved_by_default)
1445
2023
self.approved_by_default = bool(value)
1447
2025
# ApprovalDelay - property
1448
@dbus_service_property(_interface, signature="t",
2026
@dbus_service_property(_interface,
1449
2028
access="readwrite")
1450
2029
def ApprovalDelay_dbus_property(self, value=None):
1451
2030
if value is None: # get
1452
return dbus.UInt64(self.approval_delay_milliseconds())
2031
return dbus.UInt64(self.approval_delay.total_seconds()
1453
2033
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1455
2035
# ApprovalDuration - property
1456
@dbus_service_property(_interface, signature="t",
2036
@dbus_service_property(_interface,
1457
2038
access="readwrite")
1458
2039
def ApprovalDuration_dbus_property(self, value=None):
1459
2040
if value is None: # get
1460
return dbus.UInt64(timedelta_to_milliseconds(
1461
self.approval_duration))
2041
return dbus.UInt64(self.approval_duration.total_seconds()
1462
2043
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1464
2045
# Name - property
2047
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1465
2048
@dbus_service_property(_interface, signature="s", access="read")
1466
2049
def Name_dbus_property(self):
1467
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)
1469
2059
# Fingerprint - property
2061
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1470
2062
@dbus_service_property(_interface, signature="s", access="read")
1471
2063
def Fingerprint_dbus_property(self):
1472
2064
return dbus.String(self.fingerprint)
1474
2066
# Host - property
1475
@dbus_service_property(_interface, signature="s",
2067
@dbus_service_property(_interface,
1476
2069
access="readwrite")
1477
2070
def Host_dbus_property(self, value=None):
1478
2071
if value is None: # get
1479
2072
return dbus.String(self.host)
1480
self.host = unicode(value)
2073
self.host = str(value)
1482
2075
# Created - property
2077
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1483
2078
@dbus_service_property(_interface, signature="s", access="read")
1484
2079
def Created_dbus_property(self):
1485
2080
return datetime_to_dbus(self.created)
1487
2082
# LastEnabled - property
1488
2083
@dbus_service_property(_interface, signature="s", access="read")
1489
2084
def LastEnabled_dbus_property(self):
1490
2085
return datetime_to_dbus(self.last_enabled)
1492
2087
# Enabled - property
1493
@dbus_service_property(_interface, signature="b",
2088
@dbus_service_property(_interface,
1494
2090
access="readwrite")
1495
2091
def Enabled_dbus_property(self, value=None):
1496
2092
if value is None: # get
1544
2141
if (getattr(self, "disable_initiator_tag", None)
1547
gobject.source_remove(self.disable_initiator_tag)
1548
self.disable_initiator_tag = (
1549
gobject.timeout_add(
1550
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),
1553
2149
# ExtendedTimeout - property
1554
@dbus_service_property(_interface, signature="t",
2150
@dbus_service_property(_interface,
1555
2152
access="readwrite")
1556
2153
def ExtendedTimeout_dbus_property(self, value=None):
1557
2154
if value is None: # get
1558
return dbus.UInt64(self.extended_timeout_milliseconds())
2155
return dbus.UInt64(self.extended_timeout.total_seconds()
1559
2157
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1561
2159
# Interval - property
1562
@dbus_service_property(_interface, signature="t",
2160
@dbus_service_property(_interface,
1563
2162
access="readwrite")
1564
2163
def Interval_dbus_property(self, value=None):
1565
2164
if value is None: # get
1566
return dbus.UInt64(self.interval_milliseconds())
2165
return dbus.UInt64(self.interval.total_seconds() * 1000)
1567
2166
self.interval = datetime.timedelta(0, 0, 0, value)
1568
2167
if getattr(self, "checker_initiator_tag", None) is None:
1570
2169
if self.enabled:
1571
2170
# Reschedule checker run
1572
gobject.source_remove(self.checker_initiator_tag)
1573
self.checker_initiator_tag = (gobject.timeout_add
1574
(value, self.start_checker))
1575
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
1577
2176
# Checker - property
1578
@dbus_service_property(_interface, signature="s",
2177
@dbus_service_property(_interface,
1579
2179
access="readwrite")
1580
2180
def Checker_dbus_property(self, value=None):
1581
2181
if value is None: # get
1582
2182
return dbus.String(self.checker_command)
1583
self.checker_command = unicode(value)
2183
self.checker_command = str(value)
1585
2185
# CheckerRunning - property
1586
@dbus_service_property(_interface, signature="b",
2186
@dbus_service_property(_interface,
1587
2188
access="readwrite")
1588
2189
def CheckerRunning_dbus_property(self, value=None):
1589
2190
if value is None: # get
1636
2247
class ClientHandler(socketserver.BaseRequestHandler, object):
1637
2248
"""A class to handle client connections.
1639
2250
Instantiated once for each connection to handle it.
1640
2251
Note: This will run in its own forked process."""
1642
2253
def handle(self):
1643
2254
with contextlib.closing(self.server.child_pipe) as child_pipe:
1644
2255
logger.info("TCP connection from: %s",
1645
unicode(self.client_address))
2256
str(self.client_address))
1646
2257
logger.debug("Pipe FD: %d",
1647
2258
self.server.child_pipe.fileno())
1649
session = (gnutls.connection
1650
.ClientSession(self.request,
1652
.X509Credentials()))
1654
# Note: gnutls.connection.X509Credentials is really a
1655
# generic GnuTLS certificate credentials object so long as
1656
# no X.509 keys are added to it. Therefore, we can use it
1657
# here despite using OpenPGP certificates.
1659
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1660
# "+AES-256-CBC", "+SHA1",
1661
# "+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",
1663
2266
# Use a fallback default, since this MUST be set.
1664
2267
priority = self.server.gnutls_priority
1665
2268
if priority is None:
1666
2269
priority = "NORMAL"
1667
(gnutls.library.functions
1668
.gnutls_priority_set_direct(session._c_object,
2270
gnutls.priority_set_direct(session._c_object,
2271
priority.encode("utf-8"),
1671
2274
# Start communication using the Mandos protocol
1672
2275
# Get protocol number
1673
2276
line = self.request.makefile().readline()
1674
2277
logger.debug("Protocol version: %r", line)
1676
2279
if int(line.strip().split()[0]) > 1:
2280
raise RuntimeError(line)
1678
2281
except (ValueError, IndexError, RuntimeError) as error:
1679
2282
logger.error("Unknown protocol version: %s", error)
1682
2285
# Start GnuTLS connection
1684
2287
session.handshake()
1685
except gnutls.errors.GNUTLSError as error:
2288
except gnutls.Error as error:
1686
2289
logger.warning("Handshake failed: %s", error)
1687
2290
# Do not run session.bye() here: the session is not
1688
2291
# established. Just abandon the request.
1690
2293
logger.debug("Handshake succeeded")
1692
2295
approval_required = False
1695
fpr = self.fingerprint(self.peer_certificate
1698
gnutls.errors.GNUTLSError) as error:
1699
logger.warning("Bad certificate: %s", error)
1701
logger.debug("Fingerprint: %s", fpr)
1704
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,
1705
2319
self.client_address)
1706
2320
except KeyError:
1709
2323
if client.approval_delay:
1710
2324
delay = client.approval_delay
1711
2325
client.approvals_pending += 1
1712
2326
approval_required = True
1715
2329
if not client.enabled:
1716
2330
logger.info("Client %s is disabled",
1718
2332
if self.server.use_dbus:
1719
2333
# Emit D-Bus signal
1720
2334
client.Rejected("Disabled")
1723
2337
if client.approved or not client.approval_delay:
1724
#We are approved or approval is disabled
2338
# We are approved or approval is disabled
1726
2340
elif client.approved is None:
1727
2341
logger.info("Client %s needs approval",
1762
2374
delay -= time2 - time
1765
while sent_size < len(client.secret):
1767
sent = session.send(client.secret[sent_size:])
1768
except gnutls.errors.GNUTLSError as error:
1769
logger.warning("gnutls send failed",
1772
logger.debug("Sent: %d, remaining: %d",
1773
sent, len(client.secret)
1774
- (sent_size + sent))
2377
session.send(client.secret)
2378
except gnutls.Error as error:
2379
logger.warning("gnutls send failed",
1777
2383
logger.info("Sending secret to %s", client.name)
1778
2384
# bump the timeout using extended_timeout
1779
2385
client.bump_timeout(client.extended_timeout)
1780
2386
if self.server.use_dbus:
1781
2387
# Emit D-Bus signal
1782
2388
client.GotSecret()
1785
2391
if approval_required:
1786
2392
client.approvals_pending -= 1
1789
except gnutls.errors.GNUTLSError as error:
2395
except gnutls.Error as error:
1790
2396
logger.warning("GnuTLS bye failed",
1791
2397
exc_info=error)
1794
2400
def peer_certificate(session):
1795
"Return the peer's OpenPGP certificate as a bytestring"
1796
# If not an OpenPGP certificate...
1797
if (gnutls.library.functions
1798
.gnutls_certificate_type_get(session._c_object)
1799
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1800
# ...do the normal thing
1801
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
1802
2417
list_size = ctypes.c_uint(1)
1803
cert_list = (gnutls.library.functions
1804
.gnutls_certificate_get_peers
2418
cert_list = (gnutls.certificate_get_peers
1805
2419
(session._c_object, ctypes.byref(list_size)))
1806
2420
if not bool(cert_list) and list_size.value != 0:
1807
raise gnutls.errors.GNUTLSError("error getting peer"
2421
raise gnutls.Error("error getting peer certificate")
1809
2422
if list_size.value == 0:
1811
2424
cert = cert_list[0]
1812
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()
1815
2462
def fingerprint(openpgp):
1816
2463
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1817
2464
# New GnuTLS "datum" with the OpenPGP public key
1818
datum = (gnutls.library.types
1819
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1822
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)))
1823
2469
# New empty GnuTLS certificate
1824
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1825
(gnutls.library.functions
1826
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2470
crt = gnutls.openpgp_crt_t()
2471
gnutls.openpgp_crt_init(ctypes.byref(crt))
1827
2472
# Import the OpenPGP public key into the certificate
1828
(gnutls.library.functions
1829
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1830
gnutls.library.constants
1831
.GNUTLS_OPENPGP_FMT_RAW))
2473
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2474
gnutls.OPENPGP_FMT_RAW)
1832
2475
# Verify the self signature in the key
1833
2476
crtverify = ctypes.c_uint()
1834
(gnutls.library.functions
1835
.gnutls_openpgp_crt_verify_self(crt, 0,
1836
ctypes.byref(crtverify)))
2477
gnutls.openpgp_crt_verify_self(crt, 0,
2478
ctypes.byref(crtverify))
1837
2479
if crtverify.value != 0:
1838
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1839
raise (gnutls.errors.CertificateSecurityError
2480
gnutls.openpgp_crt_deinit(crt)
2481
raise gnutls.CertificateSecurityError(code
1841
2483
# New buffer for the fingerprint
1842
2484
buf = ctypes.create_string_buffer(20)
1843
2485
buf_len = ctypes.c_size_t()
1844
2486
# Get the fingerprint from the certificate into the buffer
1845
(gnutls.library.functions
1846
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1847
ctypes.byref(buf_len)))
2487
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2488
ctypes.byref(buf_len))
1848
2489
# Deinit the certificate
1849
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2490
gnutls.openpgp_crt_deinit(crt)
1850
2491
# Convert the buffer to a Python bytestring
1851
2492
fpr = ctypes.string_at(buf, buf_len.value)
1852
2493
# Convert the bytestring to hexadecimal notation
1935
2582
# socket_wrapper(), if socketfd was set.
1936
2583
socketserver.TCPServer.__init__(self, server_address,
1937
2584
RequestHandlerClass)
1939
2586
def server_bind(self):
1940
2587
"""This overrides the normal server_bind() function
1941
2588
to bind to an interface if one was specified, and also NOT to
1942
2589
bind to an address or port if they were not specified."""
2590
global SO_BINDTODEVICE
1943
2591
if self.interface is not None:
1944
2592
if SO_BINDTODEVICE is None:
1945
logger.error("SO_BINDTODEVICE does not exist;"
1946
" cannot bind to interface %s",
1950
self.socket.setsockopt(socket.SOL_SOCKET,
1952
str(self.interface + '\0'))
1953
except socket.error as error:
1954
if error.errno == errno.EPERM:
1955
logger.error("No permission to bind to"
1956
" interface %s", self.interface)
1957
elif error.errno == errno.ENOPROTOOPT:
1958
logger.error("SO_BINDTODEVICE not available;"
1959
" cannot bind to interface %s",
1961
elif error.errno == errno.ENODEV:
1962
logger.error("Interface %s does not exist,"
1963
" 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)
1966
2614
# Only bind(2) the socket if we really need to.
1967
2615
if self.server_address[0] or self.server_address[1]:
2616
if self.server_address[1]:
2617
self.allow_reuse_address = True
1968
2618
if not self.server_address[0]:
1969
2619
if self.address_family == socket.AF_INET6:
1970
any_address = "::" # in6addr_any
2620
any_address = "::" # in6addr_any
1972
any_address = socket.INADDR_ANY
2622
any_address = "0.0.0.0" # INADDR_ANY
1973
2623
self.server_address = (any_address,
1974
2624
self.server_address[1])
1975
2625
elif not self.server_address[1]:
1976
self.server_address = (self.server_address[0],
2626
self.server_address = (self.server_address[0], 0)
1978
2627
# if self.interface:
1979
2628
# self.server_address = (self.server_address[0],
2005
2659
self.gnutls_priority = gnutls_priority
2006
2660
IPv6_TCPServer.__init__(self, server_address,
2007
2661
RequestHandlerClass,
2008
interface = interface,
2009
use_ipv6 = use_ipv6,
2010
socketfd = socketfd)
2662
interface=interface,
2011
2666
def server_activate(self):
2012
2667
if self.enabled:
2013
2668
return socketserver.TCPServer.server_activate(self)
2015
2670
def enable(self):
2016
2671
self.enabled = True
2018
2673
def add_pipe(self, parent_pipe, proc):
2019
2674
# Call "handle_ipc" for both data and EOF events
2020
gobject.io_add_watch(parent_pipe.fileno(),
2021
gobject.IO_IN | gobject.IO_HUP,
2022
functools.partial(self.handle_ipc,
2027
def handle_ipc(self, source, condition, parent_pipe=None,
2028
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):
2029
2686
# error, or the other end of multiprocessing.Pipe has closed
2030
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2687
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2031
2688
# Wait for other process to exit
2035
2692
# Read a request from the child
2036
2693
request = parent_pipe.recv()
2037
2694
command = request[0]
2039
2696
if command == 'init':
2041
address = request[2]
2043
for c in self.clients.itervalues():
2044
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:
2048
logger.info("Client not found for fingerprint: %s, ad"
2049
"dress: %s", fpr, address)
2711
logger.info("Client not found for key ID: %s, address"
2712
": %s", key_id or fpr, address)
2050
2713
if self.use_dbus:
2051
2714
# Emit D-Bus signal
2052
mandos_dbus_service.ClientNotFound(fpr,
2715
mandos_dbus_service.ClientNotFound(key_id or fpr,
2054
2717
parent_pipe.send(False)
2057
gobject.io_add_watch(parent_pipe.fileno(),
2058
gobject.IO_IN | gobject.IO_HUP,
2059
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))
2065
2727
parent_pipe.send(True)
2066
2728
# remove the old hook in favor of the new above hook on
2294
2956
parser.add_argument("--no-dbus", action="store_false",
2295
2957
dest="use_dbus", help="Do not provide D-Bus"
2296
" system bus interface")
2958
" system bus interface", default=None)
2297
2959
parser.add_argument("--no-ipv6", action="store_false",
2298
dest="use_ipv6", help="Do not use IPv6")
2960
dest="use_ipv6", help="Do not use IPv6",
2299
2962
parser.add_argument("--no-restore", action="store_false",
2300
2963
dest="restore", help="Do not restore stored"
2964
" state", default=None)
2302
2965
parser.add_argument("--socket", type=int,
2303
2966
help="Specify a file descriptor to a network"
2304
2967
" socket to use instead of creating one")
2305
2968
parser.add_argument("--statedir", metavar="DIR",
2306
2969
help="Directory to save/restore state in")
2307
2970
parser.add_argument("--foreground", action="store_true",
2308
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",
2310
2976
options = parser.parse_args()
2312
2978
if options.check:
2980
fail_count, test_count = doctest.testmod()
2981
sys.exit(os.EX_OK if fail_count == 0 else 1)
2317
2983
# Default values for config file for server-global settings
2318
server_defaults = { "interface": "",
2323
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2324
"servicename": "Mandos",
2330
"statedir": "/var/lib/mandos",
2331
"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",
2334
3007
# Parse config file for server-global settings
2335
server_config = configparser.SafeConfigParser(server_defaults)
3008
server_config = configparser.ConfigParser(server_defaults)
2336
3009
del server_defaults
2337
server_config.read(os.path.join(options.configdir,
2339
# 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
2340
3012
server_settings = server_config.defaults()
2341
3013
# Use the appropriate methods on the non-string config options
2342
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
3014
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3015
"foreground", "zeroconf"):
2343
3016
server_settings[option] = server_config.getboolean("DEFAULT",
2345
3018
if server_settings["port"]:
3134
logger.debug("Did setuid/setgid to {}:{}".format(uid,
2447
3136
except OSError as error:
3137
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3138
.format(uid, gid, os.strerror(error.errno)))
2448
3139
if error.errno != errno.EPERM:
2452
3143
# Enable all possible GnuTLS debugging
2454
3145
# "Use a log level over 10 to enable all debugging options."
2455
3146
# - GnuTLS manual
2456
gnutls.library.functions.gnutls_global_set_log_level(11)
2458
@gnutls.library.types.gnutls_log_func
3147
gnutls.global_set_log_level(11)
2459
3150
def debug_gnutls(level, string):
2460
3151
logger.debug("GnuTLS: %s", string[:-1])
2462
(gnutls.library.functions
2463
.gnutls_global_set_log_function(debug_gnutls))
3153
gnutls.global_set_log_function(debug_gnutls)
2465
3155
# Redirect stdin so all checkers get /dev/null
2466
3156
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2467
3157
os.dup2(null, sys.stdin.fileno())
2471
3161
# Need to fork before connecting to D-Bus
2472
3162
if not foreground:
2473
3163
# Close all input and output, do double fork, etc.
2476
# multiprocessing will use threads, so before we use gobject we
2477
# need to inform gobject that threads will be used.
2478
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.
2480
3171
global main_loop
2481
3172
# From the Avahi example code
2482
3173
DBusGMainLoop(set_as_default=True)
2483
main_loop = gobject.MainLoop()
3174
main_loop = GLib.MainLoop()
2484
3175
bus = dbus.SystemBus()
2485
3176
# End of Avahi example code
2488
3179
bus_name = dbus.service.BusName("se.recompile.Mandos",
2489
bus, do_not_queue=True)
2490
old_bus_name = (dbus.service.BusName
2491
("se.bsnet.fukt.Mandos", bus,
2493
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:
2494
3186
logger.error("Disabling D-Bus:", exc_info=e)
2495
3187
use_dbus = False
2496
3188
server_settings["use_dbus"] = False
2497
3189
tcp_server.use_dbus = False
2498
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2499
service = AvahiServiceToSyslog(name =
2500
server_settings["servicename"],
2501
servicetype = "_mandos._tcp",
2502
protocol = protocol, bus = bus)
2503
if server_settings["interface"]:
2504
service.interface = (if_nametoindex
2505
(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"))
2507
3201
global multiprocessing_manager
2508
3202
multiprocessing_manager = multiprocessing.Manager()
2510
3204
client_class = Client
2512
client_class = functools.partial(ClientDBus, bus = bus)
3206
client_class = functools.partial(ClientDBus, bus=bus)
2514
3208
client_settings = Client.config_parser(client_config)
2515
3209
old_client_settings = {}
2516
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:
2518
3220
# Get client data and settings from last running state.
2519
3221
if server_settings["restore"]:
2521
3223
with open(stored_state_path, "rb") as stored_state:
2522
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"]
2524
3273
os.remove(stored_state_path)
2525
3274
except IOError as e:
2526
3275
if e.errno == errno.ENOENT:
2527
logger.warning("Could not load persistent state: {0}"
2528
.format(os.strerror(e.errno)))
3276
logger.warning("Could not load persistent state:"
3277
" {}".format(os.strerror(e.errno)))
2530
3279
logger.critical("Could not load persistent state:",
2533
3282
except EOFError as e:
2534
3283
logger.warning("Could not load persistent state: "
2535
"EOFError:", exc_info=e)
2537
3287
with PGPEngine() as pgp:
2538
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:
2539
3293
# Decide which value to use after restoring saved state.
2540
3294
# We have three different values: Old config file,
2541
3295
# new config file, and saved state.
2599
3353
for client_name in (set(client_settings)
2600
3354
- set(old_client_settings)):
2601
3355
clients_data[client_name] = client_settings[client_name]
2603
3357
# Create all client objects
2604
for client_name, client in clients_data.iteritems():
3358
for client_name, client in clients_data.items():
2605
3359
tcp_server.clients[client_name] = client_class(
2606
name = client_name, settings = client)
3362
server_settings=server_settings)
2608
3364
if not tcp_server.clients:
2609
3365
logger.warning("No clients defined")
2611
3367
if not foreground:
2612
3368
if pidfile is not None:
2616
pidfile.write(str(pid) + "\n".encode("utf-8"))
3372
print(pid, file=pidfile)
2617
3373
except IOError:
2618
3374
logger.error("Could not write to file %r with PID %d",
2619
3375
pidfilename, pid)
2621
3377
del pidfilename
2623
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2624
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)
2627
@alternate_dbus_interfaces({"se.recompile.Mandos":
2628
"se.bsnet.fukt.Mandos"})
2629
class MandosDBusService(DBusObjectWithProperties):
3385
@alternate_dbus_interfaces(
3386
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3387
class MandosDBusService(DBusObjectWithObjectManager):
2630
3388
"""A D-Bus proxy object"""
2631
3390
def __init__(self):
2632
3391
dbus.service.Object.__init__(self, bus, "/")
2633
3393
_interface = "se.recompile.Mandos"
2635
@dbus_interface_annotations(_interface)
2637
return { "org.freedesktop.DBus.Property"
2638
".EmitsChangedSignal":
2641
3395
@dbus.service.signal(_interface, signature="o")
2642
3396
def ClientAdded(self, objpath):
2646
3400
@dbus.service.signal(_interface, signature="ss")
2647
def ClientNotFound(self, fingerprint, address):
3401
def ClientNotFound(self, key_id, address):
3405
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2651
3407
@dbus.service.signal(_interface, signature="os")
2652
3408
def ClientRemoved(self, objpath, name):
3412
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2656
3414
@dbus.service.method(_interface, out_signature="ao")
2657
3415
def GetAllClients(self):
2659
return dbus.Array(c.dbus_object_path
2661
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":
2663
3422
@dbus.service.method(_interface,
2664
3423
out_signature="a{oa{sv}}")
2665
3424
def GetAllClientsWithProperties(self):
2667
3426
return dbus.Dictionary(
2668
((c.dbus_object_path, c.GetAll(""))
2669
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()},
2670
3430
signature="oa{sv}")
2672
3432
@dbus.service.method(_interface, in_signature="o")
2673
3433
def RemoveClient(self, object_path):
2675
for c in tcp_server.clients.itervalues():
3435
for c in tcp_server.clients.values():
2676
3436
if c.dbus_object_path == object_path:
2677
3437
del tcp_server.clients[c.name]
2678
3438
c.remove_from_connection()
2679
# Don't signal anything except ClientRemoved
3439
# Don't signal the disabling
2680
3440
c.disable(quiet=True)
2682
self.ClientRemoved(object_path, c.name)
3441
# Emit D-Bus signal for removal
3442
self.client_removed_signal(c)
2684
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,
2688
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
2691
3492
"Cleanup function; run on exit"
2694
multiprocessing.active_children()
3496
mp.active_children()
2695
3498
if not (tcp_server.clients or client_settings):
2698
3501
# Store client before exiting. Secrets are encrypted with key
2699
3502
# based on what config file has. If config file is
2700
3503
# removed/edited, old secret will thus be unrecovable.
2702
3505
with PGPEngine() as pgp:
2703
for client in tcp_server.clients.itervalues():
3506
for client in tcp_server.clients.values():
2704
3507
key = client_settings[client.name]["secret"]
2705
3508
client.encrypted_secret = pgp.encrypt(client.secret,
2707
3510
client_dict = {}
2709
3512
# A list of attributes that can not be pickled
2711
exclude = set(("bus", "changedstate", "secret",
2713
for name, typ in (inspect.getmembers
2714
(dbus.service.Object)):
3514
exclude = {"bus", "changedstate", "secret",
3515
"checker", "server_settings"}
3516
for name, typ in inspect.getmembers(dbus.service
2715
3518
exclude.add(name)
2717
3520
client_dict["encrypted_secret"] = (client
2718
3521
.encrypted_secret)
2719
3522
for attr in client.client_structure:
2720
3523
if attr not in exclude:
2721
3524
client_dict[attr] = getattr(client, attr)
2723
3526
clients[client.name] = client_dict
2724
3527
del client_settings[client.name]["secret"]
2727
with (tempfile.NamedTemporaryFile
2728
(mode='wb', suffix=".pickle", prefix='clients-',
2729
dir=os.path.dirname(stored_state_path),
2730
delete=False)) as stored_state:
2731
pickle.dump((clients, client_settings), stored_state)
2732
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
2733
3539
os.rename(tempname, stored_state_path)
2734
3540
except (IOError, OSError) as e: