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:
84
98
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
85
99
except AttributeError:
101
# This is where SO_BINDTODEVICE was up to and including Python
87
103
from IN import SO_BINDTODEVICE
88
104
except ImportError:
89
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
92
126
stored_state_file = "clients.pickle"
94
128
logger = logging.getLogger()
98
if_nametoindex = (ctypes.cdll.LoadLibrary
99
(ctypes.util.find_library("c"))
132
if_nametoindex = ctypes.cdll.LoadLibrary(
133
ctypes.util.find_library("c")).if_nametoindex
101
134
except (OSError, AttributeError):
102
136
def if_nametoindex(interface):
103
137
"Get an interface index the hard way, i.e. using fcntl()"
104
138
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
105
139
with contextlib.closing(socket.socket()) as s:
106
140
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
107
struct.pack(str("16s16x"),
109
interface_index = struct.unpack(str("I"),
141
struct.pack(b"16s16x", interface))
142
interface_index = struct.unpack("I", ifreq[16:20])[0]
111
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__,
114
162
def initlogger(debug, level=logging.WARNING):
115
163
"""init logger and add loglevel"""
118
syslogger = (logging.handlers.SysLogHandler
120
logging.handlers.SysLogHandler.LOG_DAEMON,
121
address = str("/dev/log")))
166
syslogger = (logging.handlers.SysLogHandler(
167
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
122
169
syslogger.setFormatter(logging.Formatter
123
170
('Mandos [%(process)d]: %(levelname)s:'
125
172
logger.addHandler(syslogger)
128
175
console = logging.StreamHandler()
129
176
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
182
243
.replace(b"\n", b"\\n")
183
244
.replace(b"\0", b"\\x00"))
186
247
def encrypt(self, data, password):
187
248
passphrase = self.password_encode(password)
188
with tempfile.NamedTemporaryFile(dir=self.tempdir
249
with tempfile.NamedTemporaryFile(
250
dir=self.tempdir) as passfile:
190
251
passfile.write(passphrase)
192
proc = subprocess.Popen(['gpg', '--symmetric',
253
proc = subprocess.Popen([self.gpg, '--symmetric',
193
254
'--passphrase-file',
195
256
+ self.gnupgargs,
196
stdin = subprocess.PIPE,
197
stdout = subprocess.PIPE,
198
stderr = subprocess.PIPE)
199
ciphertext, err = proc.communicate(input = data)
257
stdin=subprocess.PIPE,
258
stdout=subprocess.PIPE,
259
stderr=subprocess.PIPE)
260
ciphertext, err = proc.communicate(input=data)
200
261
if proc.returncode != 0:
201
262
raise PGPError(err)
202
263
return ciphertext
204
265
def decrypt(self, data, password):
205
266
passphrase = self.password_encode(password)
206
with tempfile.NamedTemporaryFile(dir = self.tempdir
267
with tempfile.NamedTemporaryFile(
268
dir=self.tempdir) as passfile:
208
269
passfile.write(passphrase)
210
proc = subprocess.Popen(['gpg', '--decrypt',
271
proc = subprocess.Popen([self.gpg, '--decrypt',
211
272
'--passphrase-file',
213
274
+ self.gnupgargs,
214
stdin = subprocess.PIPE,
215
stdout = subprocess.PIPE,
216
stderr = subprocess.PIPE)
217
decrypted_plaintext, err = proc.communicate(input
275
stdin=subprocess.PIPE,
276
stdout=subprocess.PIPE,
277
stderr=subprocess.PIPE)
278
decrypted_plaintext, err = proc.communicate(input=data)
219
279
if proc.returncode != 0:
220
280
raise PGPError(err)
221
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
224
310
class AvahiError(Exception):
225
311
def __init__(self, value, *args, **kwargs):
226
312
self.value = value
227
super(AvahiError, self).__init__(value, *args, **kwargs)
228
def __unicode__(self):
229
return unicode(repr(self.value))
313
return super(AvahiError, self).__init__(value, *args,
231
317
class AvahiServiceError(AvahiError):
234
321
class AvahiGroupError(AvahiError):
238
class AvahiService(object):
239
326
"""An Avahi (Zeroconf) service.
242
329
interface: integer; avahi.IF_UNSPEC or an interface index.
243
330
Used to optionally bind to the specified interface.
386
495
follow_name_owner_changes=True),
387
496
avahi.DBUS_INTERFACE_SERVER)
388
497
self.server.connect_to_signal("StateChanged",
389
self.server_state_changed)
498
self.server_state_changed)
390
499
self.server_state_changed(self.server.GetState())
393
502
class AvahiServiceToSyslog(AvahiService):
503
def rename(self, *args, **kwargs):
395
504
"""Add the new name to the syslog messages"""
396
ret = AvahiService.rename(self)
397
syslogger.setFormatter(logging.Formatter
398
('Mandos ({0}) [%(process)d]:'
399
' %(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'
404
def timedelta_to_milliseconds(td):
405
"Convert a datetime.timedelta() to milliseconds"
406
return ((td.days * 24 * 60 * 60 * 1000)
407
+ (td.seconds * 1000)
408
+ (td.microseconds // 1000))
411
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))
412
825
"""A representation of a client host served by this server.
415
828
approved: bool(); 'None' if not yet approved/disapproved
416
829
approval_delay: datetime.timedelta(); Time to wait for approval
417
830
approval_duration: datetime.timedelta(); Duration of one approval
418
checker: subprocess.Popen(); a running checker process used
419
to see if the client lives.
420
'None' if no process is running.
421
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
422
835
checker_command: string; External command which is run to check
423
836
if client lives. %() expansions are done at
424
837
runtime with vars(self) as dict, so that for
425
838
instance %(name)s can be used in the command.
426
checker_initiator_tag: a gobject event source tag, or None
839
checker_initiator_tag: a GLib event source tag, or None
427
840
created: datetime.datetime(); (UTC) object creation
428
841
client_structure: Object describing what attributes a client has
429
842
and is used for storing the client at exit
430
843
current_checker_command: string; current running checker_command
431
disable_initiator_tag: a gobject event source tag, or None
844
disable_initiator_tag: a GLib event source tag, or None
433
846
fingerprint: string (40 or 32 hexadecimal digits); used to
434
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
435
850
host: string; available for use by the checker command
436
851
interval: datetime.timedelta(); How often to start a new checker
437
852
last_approval_request: datetime.datetime(); (UTC) or None
604
1009
logger.info("Disabling client %s", self.name)
605
1010
if getattr(self, "disable_initiator_tag", None) is not None:
606
gobject.source_remove(self.disable_initiator_tag)
1011
GLib.source_remove(self.disable_initiator_tag)
607
1012
self.disable_initiator_tag = None
608
1013
self.expires = None
609
1014
if getattr(self, "checker_initiator_tag", None) is not None:
610
gobject.source_remove(self.checker_initiator_tag)
1015
GLib.source_remove(self.checker_initiator_tag)
611
1016
self.checker_initiator_tag = None
612
1017
self.stop_checker()
613
1018
self.enabled = False
615
1020
self.send_changedstate()
616
# 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
619
1024
def __del__(self):
622
1027
def init_checker(self):
623
1028
# Schedule a new checker to be started an 'interval' from now,
624
1029
# and every interval from then on.
625
1030
if self.checker_initiator_tag is not None:
626
gobject.source_remove(self.checker_initiator_tag)
627
self.checker_initiator_tag = (gobject.timeout_add
628
(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),
630
1035
# Schedule a disable() when 'timeout' has passed
631
1036
if self.disable_initiator_tag is not None:
632
gobject.source_remove(self.disable_initiator_tag)
633
self.disable_initiator_tag = (gobject.timeout_add
634
(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)
636
1040
# Also start a new checker *right now*.
637
1041
self.start_checker()
639
def checker_callback(self, pid, condition, command):
1043
def checker_callback(self, source, condition, connection,
640
1045
"""The checker has completed, so take appropriate actions."""
1046
# Read return code from connection (see call_pipe)
1047
returncode = connection.recv()
641
1050
self.checker_callback_tag = None
642
1051
self.checker = None
643
if os.WIFEXITED(condition):
644
self.last_checker_status = os.WEXITSTATUS(condition)
1054
self.last_checker_status = returncode
1055
self.last_checker_signal = None
645
1056
if self.last_checker_status == 0:
646
1057
logger.info("Checker for %(name)s succeeded",
648
1059
self.checked_ok()
650
logger.info("Checker for %(name)s failed",
1061
logger.info("Checker for %(name)s failed", vars(self))
653
1063
self.last_checker_status = -1
1064
self.last_checker_signal = -returncode
654
1065
logger.warning("Checker for %(name)s crashed?",
657
1069
def checked_ok(self):
658
1070
"""Assert that the client has been seen, alive and well."""
659
1071
self.last_checked_ok = datetime.datetime.utcnow()
660
1072
self.last_checker_status = 0
1073
self.last_checker_signal = None
661
1074
self.bump_timeout()
663
1076
def bump_timeout(self, timeout=None):
664
1077
"""Bump up the timeout for this client."""
665
1078
if timeout is None:
666
1079
timeout = self.timeout
667
1080
if self.disable_initiator_tag is not None:
668
gobject.source_remove(self.disable_initiator_tag)
1081
GLib.source_remove(self.disable_initiator_tag)
669
1082
self.disable_initiator_tag = None
670
1083
if getattr(self, "enabled", False):
671
self.disable_initiator_tag = (gobject.timeout_add
672
(timedelta_to_milliseconds
673
(timeout), self.disable))
1084
self.disable_initiator_tag = GLib.timeout_add(
1085
int(timeout.total_seconds() * 1000), self.disable)
674
1086
self.expires = datetime.datetime.utcnow() + timeout
676
1088
def need_approval(self):
677
1089
self.last_approval_request = datetime.datetime.utcnow()
679
1091
def start_checker(self):
680
1092
"""Start a new checker subprocess if one is not running.
682
1094
If a checker already exists, leave it running and do
684
1096
# The reason for not killing a running checker is that if we
689
1101
# checkers alone, the checker would have to take more time
690
1102
# than 'timeout' for the client to be disabled, which is as it
693
# If a checker exists, make sure it is not a zombie
695
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
696
except AttributeError:
698
except OSError as error:
699
if error.errno != errno.ECHILD:
703
logger.warning("Checker was a zombie")
704
gobject.source_remove(self.checker_callback_tag)
705
self.checker_callback(pid, status,
706
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")
707
1109
# Start a new checker if needed
708
1110
if self.checker is None:
709
1111
# Escape attributes for the shell
710
escaped_attrs = dict(
711
(attr, re.escape(unicode(getattr(self, attr))))
713
self.runtime_expansions)
1113
attr: re.escape(str(getattr(self, attr)))
1114
for attr in self.runtime_expansions}
715
1116
command = self.checker_command % escaped_attrs
716
1117
except TypeError as error:
717
1118
logger.error('Could not format string "%s"',
718
self.checker_command, exc_info=error)
719
return True # Try again later
1119
self.checker_command,
1121
return True # Try again later
720
1122
self.current_checker_command = command
722
logger.info("Starting checker %r for %s",
724
# We don't need to redirect stdout and stderr, since
725
# in normal mode, that is already done by daemon(),
726
# and in debug mode we don't want to. (Stdin is
727
# always replaced by /dev/null.)
728
# The exception is when not debugging but nevertheless
729
# running in the foreground; use the previously
732
if (not self.server_settings["debug"]
733
and self.server_settings["foreground"]):
734
popen_args.update({"stdout": wnull,
736
self.checker = subprocess.Popen(command,
740
except OSError as error:
741
logger.error("Failed to start subprocess",
744
self.checker_callback_tag = (gobject.child_watch_add
746
self.checker_callback,
748
# The checker may have completed before the gobject
749
# watch was added. Check for this.
751
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
752
except OSError as error:
753
if error.errno == errno.ECHILD:
754
# This should never happen
755
logger.error("Child process vanished",
760
gobject.source_remove(self.checker_callback_tag)
761
self.checker_callback(pid, status, command)
762
# 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
765
1151
def stop_checker(self):
766
1152
"""Force the checker process, if any, to stop."""
767
1153
if self.checker_callback_tag:
768
gobject.source_remove(self.checker_callback_tag)
1154
GLib.source_remove(self.checker_callback_tag)
769
1155
self.checker_callback_tag = None
770
1156
if getattr(self, "checker", None) is None:
772
1158
logger.debug("Stopping checker for %(name)s", vars(self))
774
self.checker.terminate()
776
#if self.checker.poll() is None:
777
# self.checker.kill()
778
except OSError as error:
779
if error.errno != errno.ESRCH: # No such process
1159
self.checker.terminate()
781
1160
self.checker = None
784
def dbus_service_property(dbus_interface, signature="v",
785
access="readwrite", byte_arrays=False):
1163
def dbus_service_property(dbus_interface,
786
1167
"""Decorators for marking methods of a DBusObjectWithProperties to
787
1168
become properties on the D-Bus.
789
1170
The decorated method will be called with no arguments by "Get"
790
1171
and with one argument by "Set".
792
1173
The parameters, where they are supported, are the same as
793
1174
dbus.service.method, except there is only "signature", since the
794
1175
type from Get() and the type sent to Set() is the same.
870
class DBusObjectWithProperties(dbus.service.Object):
871
"""A D-Bus object with properties.
873
Classes inheriting from this can use the dbus_service_property
874
decorator to expose methods as D-Bus properties. It exposes the
875
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.
879
1266
def _is_dbus_thing(thing):
880
1267
"""Returns a function testing if an attribute is a D-Bus thing
882
1269
If called like _is_dbus_thing("method") it returns a function
883
1270
suitable for use as predicate to inspect.getmembers().
885
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
1272
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
888
1275
def _get_all_dbus_things(self, thing):
889
1276
"""Returns a generator of (name, attribute) pairs
891
return ((getattr(athing.__get__(self), "_dbus_name",
1278
return ((getattr(athing.__get__(self), "_dbus_name", name),
893
1279
athing.__get__(self))
894
1280
for cls in self.__class__.__mro__
895
1281
for name, athing in
896
inspect.getmembers(cls,
897
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.
899
1355
def _get_dbus_property(self, interface_name, property_name):
900
1356
"""Returns a bound method if one exists which is a D-Bus
901
1357
property with the specified name and interface.
903
for cls in self.__class__.__mro__:
904
for name, value in (inspect.getmembers
906
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")):
907
1362
if (value._dbus_name == property_name
908
1363
and value._dbus_interface == interface_name):
909
1364
return value.__get__(self)
911
1366
# No such property
912
raise DBusPropertyNotFound(self.dbus_object_path + ":"
913
+ interface_name + "."
916
@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,
917
1381
out_signature="v")
918
1382
def Get(self, interface_name, property_name):
919
1383
"""Standard D-Bus property Get() method, see D-Bus standard.
1051
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",
1054
1586
def datetime_to_dbus(dt, variant_level=0):
1055
1587
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1057
return dbus.String("", variant_level = variant_level)
1058
return dbus.String(dt.isoformat(),
1059
variant_level=variant_level)
1589
return dbus.String("", variant_level=variant_level)
1590
return dbus.String(dt.isoformat(), variant_level=variant_level)
1062
1593
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1411
1954
server to mandos-client
1415
1958
# Rejected - signal
1416
1959
@dbus.service.signal(_interface, signature="s")
1417
1960
def Rejected(self, reason):
1421
1964
# NeedApproval - signal
1422
1965
@dbus.service.signal(_interface, signature="tb")
1423
1966
def NeedApproval(self, timeout, default):
1425
1968
return self.need_approval()
1429
1972
# Approve - method
1430
1973
@dbus.service.method(_interface, in_signature="b")
1431
1974
def Approve(self, value):
1432
1975
self.approve(value)
1434
1977
# CheckedOK - method
1435
1978
@dbus.service.method(_interface)
1436
1979
def CheckedOK(self):
1437
1980
self.checked_ok()
1439
1982
# Enable - method
1983
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1440
1984
@dbus.service.method(_interface)
1441
1985
def Enable(self):
1445
1989
# StartChecker - method
1990
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1446
1991
@dbus.service.method(_interface)
1447
1992
def StartChecker(self):
1449
1994
self.start_checker()
1451
1996
# Disable - method
1997
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1452
1998
@dbus.service.method(_interface)
1453
1999
def Disable(self):
1457
2003
# StopChecker - method
2004
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1458
2005
@dbus.service.method(_interface)
1459
2006
def StopChecker(self):
1460
2007
self.stop_checker()
1464
2011
# ApprovalPending - property
1465
2012
@dbus_service_property(_interface, signature="b", access="read")
1466
2013
def ApprovalPending_dbus_property(self):
1467
2014
return dbus.Boolean(bool(self.approvals_pending))
1469
2016
# ApprovedByDefault - property
1470
@dbus_service_property(_interface, signature="b",
2017
@dbus_service_property(_interface,
1471
2019
access="readwrite")
1472
2020
def ApprovedByDefault_dbus_property(self, value=None):
1473
2021
if value is None: # get
1474
2022
return dbus.Boolean(self.approved_by_default)
1475
2023
self.approved_by_default = bool(value)
1477
2025
# ApprovalDelay - property
1478
@dbus_service_property(_interface, signature="t",
2026
@dbus_service_property(_interface,
1479
2028
access="readwrite")
1480
2029
def ApprovalDelay_dbus_property(self, value=None):
1481
2030
if value is None: # get
1482
return dbus.UInt64(self.approval_delay_milliseconds())
2031
return dbus.UInt64(self.approval_delay.total_seconds()
1483
2033
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1485
2035
# ApprovalDuration - property
1486
@dbus_service_property(_interface, signature="t",
2036
@dbus_service_property(_interface,
1487
2038
access="readwrite")
1488
2039
def ApprovalDuration_dbus_property(self, value=None):
1489
2040
if value is None: # get
1490
return dbus.UInt64(timedelta_to_milliseconds(
1491
self.approval_duration))
2041
return dbus.UInt64(self.approval_duration.total_seconds()
1492
2043
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1494
2045
# Name - property
2047
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1495
2048
@dbus_service_property(_interface, signature="s", access="read")
1496
2049
def Name_dbus_property(self):
1497
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)
1499
2059
# Fingerprint - property
2061
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1500
2062
@dbus_service_property(_interface, signature="s", access="read")
1501
2063
def Fingerprint_dbus_property(self):
1502
2064
return dbus.String(self.fingerprint)
1504
2066
# Host - property
1505
@dbus_service_property(_interface, signature="s",
2067
@dbus_service_property(_interface,
1506
2069
access="readwrite")
1507
2070
def Host_dbus_property(self, value=None):
1508
2071
if value is None: # get
1509
2072
return dbus.String(self.host)
1510
self.host = unicode(value)
2073
self.host = str(value)
1512
2075
# Created - property
2077
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1513
2078
@dbus_service_property(_interface, signature="s", access="read")
1514
2079
def Created_dbus_property(self):
1515
2080
return datetime_to_dbus(self.created)
1517
2082
# LastEnabled - property
1518
2083
@dbus_service_property(_interface, signature="s", access="read")
1519
2084
def LastEnabled_dbus_property(self):
1520
2085
return datetime_to_dbus(self.last_enabled)
1522
2087
# Enabled - property
1523
@dbus_service_property(_interface, signature="b",
2088
@dbus_service_property(_interface,
1524
2090
access="readwrite")
1525
2091
def Enabled_dbus_property(self, value=None):
1526
2092
if value is None: # get
1574
2141
if (getattr(self, "disable_initiator_tag", None)
1577
gobject.source_remove(self.disable_initiator_tag)
1578
self.disable_initiator_tag = (
1579
gobject.timeout_add(
1580
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),
1583
2149
# ExtendedTimeout - property
1584
@dbus_service_property(_interface, signature="t",
2150
@dbus_service_property(_interface,
1585
2152
access="readwrite")
1586
2153
def ExtendedTimeout_dbus_property(self, value=None):
1587
2154
if value is None: # get
1588
return dbus.UInt64(self.extended_timeout_milliseconds())
2155
return dbus.UInt64(self.extended_timeout.total_seconds()
1589
2157
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1591
2159
# Interval - property
1592
@dbus_service_property(_interface, signature="t",
2160
@dbus_service_property(_interface,
1593
2162
access="readwrite")
1594
2163
def Interval_dbus_property(self, value=None):
1595
2164
if value is None: # get
1596
return dbus.UInt64(self.interval_milliseconds())
2165
return dbus.UInt64(self.interval.total_seconds() * 1000)
1597
2166
self.interval = datetime.timedelta(0, 0, 0, value)
1598
2167
if getattr(self, "checker_initiator_tag", None) is None:
1600
2169
if self.enabled:
1601
2170
# Reschedule checker run
1602
gobject.source_remove(self.checker_initiator_tag)
1603
self.checker_initiator_tag = (gobject.timeout_add
1604
(value, self.start_checker))
1605
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
1607
2176
# Checker - property
1608
@dbus_service_property(_interface, signature="s",
2177
@dbus_service_property(_interface,
1609
2179
access="readwrite")
1610
2180
def Checker_dbus_property(self, value=None):
1611
2181
if value is None: # get
1612
2182
return dbus.String(self.checker_command)
1613
self.checker_command = unicode(value)
2183
self.checker_command = str(value)
1615
2185
# CheckerRunning - property
1616
@dbus_service_property(_interface, signature="b",
2186
@dbus_service_property(_interface,
1617
2188
access="readwrite")
1618
2189
def CheckerRunning_dbus_property(self, value=None):
1619
2190
if value is None: # get
1792
2374
delay -= time2 - time
1795
while sent_size < len(client.secret):
1797
sent = session.send(client.secret[sent_size:])
1798
except gnutls.errors.GNUTLSError as error:
1799
logger.warning("gnutls send failed",
1802
logger.debug("Sent: %d, remaining: %d",
1803
sent, len(client.secret)
1804
- (sent_size + sent))
2377
session.send(client.secret)
2378
except gnutls.Error as error:
2379
logger.warning("gnutls send failed",
1807
2383
logger.info("Sending secret to %s", client.name)
1808
2384
# bump the timeout using extended_timeout
1809
2385
client.bump_timeout(client.extended_timeout)
1810
2386
if self.server.use_dbus:
1811
2387
# Emit D-Bus signal
1812
2388
client.GotSecret()
1815
2391
if approval_required:
1816
2392
client.approvals_pending -= 1
1819
except gnutls.errors.GNUTLSError as error:
2395
except gnutls.Error as error:
1820
2396
logger.warning("GnuTLS bye failed",
1821
2397
exc_info=error)
1824
2400
def peer_certificate(session):
1825
"Return the peer's OpenPGP certificate as a bytestring"
1826
# If not an OpenPGP certificate...
1827
if (gnutls.library.functions
1828
.gnutls_certificate_type_get(session._c_object)
1829
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1830
# ...do the normal thing
1831
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
1832
2417
list_size = ctypes.c_uint(1)
1833
cert_list = (gnutls.library.functions
1834
.gnutls_certificate_get_peers
2418
cert_list = (gnutls.certificate_get_peers
1835
2419
(session._c_object, ctypes.byref(list_size)))
1836
2420
if not bool(cert_list) and list_size.value != 0:
1837
raise gnutls.errors.GNUTLSError("error getting peer"
2421
raise gnutls.Error("error getting peer certificate")
1839
2422
if list_size.value == 0:
1841
2424
cert = cert_list[0]
1842
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()
1845
2462
def fingerprint(openpgp):
1846
2463
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1847
2464
# New GnuTLS "datum" with the OpenPGP public key
1848
datum = (gnutls.library.types
1849
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1852
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)))
1853
2469
# New empty GnuTLS certificate
1854
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1855
(gnutls.library.functions
1856
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2470
crt = gnutls.openpgp_crt_t()
2471
gnutls.openpgp_crt_init(ctypes.byref(crt))
1857
2472
# Import the OpenPGP public key into the certificate
1858
(gnutls.library.functions
1859
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1860
gnutls.library.constants
1861
.GNUTLS_OPENPGP_FMT_RAW))
2473
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2474
gnutls.OPENPGP_FMT_RAW)
1862
2475
# Verify the self signature in the key
1863
2476
crtverify = ctypes.c_uint()
1864
(gnutls.library.functions
1865
.gnutls_openpgp_crt_verify_self(crt, 0,
1866
ctypes.byref(crtverify)))
2477
gnutls.openpgp_crt_verify_self(crt, 0,
2478
ctypes.byref(crtverify))
1867
2479
if crtverify.value != 0:
1868
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1869
raise (gnutls.errors.CertificateSecurityError
2480
gnutls.openpgp_crt_deinit(crt)
2481
raise gnutls.CertificateSecurityError(code
1871
2483
# New buffer for the fingerprint
1872
2484
buf = ctypes.create_string_buffer(20)
1873
2485
buf_len = ctypes.c_size_t()
1874
2486
# Get the fingerprint from the certificate into the buffer
1875
(gnutls.library.functions
1876
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1877
ctypes.byref(buf_len)))
2487
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2488
ctypes.byref(buf_len))
1878
2489
# Deinit the certificate
1879
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2490
gnutls.openpgp_crt_deinit(crt)
1880
2491
# Convert the buffer to a Python bytestring
1881
2492
fpr = ctypes.string_at(buf, buf_len.value)
1882
2493
# Convert the bytestring to hexadecimal notation
1965
2582
# socket_wrapper(), if socketfd was set.
1966
2583
socketserver.TCPServer.__init__(self, server_address,
1967
2584
RequestHandlerClass)
1969
2586
def server_bind(self):
1970
2587
"""This overrides the normal server_bind() function
1971
2588
to bind to an interface if one was specified, and also NOT to
1972
2589
bind to an address or port if they were not specified."""
2590
global SO_BINDTODEVICE
1973
2591
if self.interface is not None:
1974
2592
if SO_BINDTODEVICE is None:
1975
logger.error("SO_BINDTODEVICE does not exist;"
1976
" cannot bind to interface %s",
1980
self.socket.setsockopt(socket.SOL_SOCKET,
1982
str(self.interface + '\0'))
1983
except socket.error as error:
1984
if error.errno == errno.EPERM:
1985
logger.error("No permission to bind to"
1986
" interface %s", self.interface)
1987
elif error.errno == errno.ENOPROTOOPT:
1988
logger.error("SO_BINDTODEVICE not available;"
1989
" cannot bind to interface %s",
1991
elif error.errno == errno.ENODEV:
1992
logger.error("Interface %s does not exist,"
1993
" 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)
1996
2614
# Only bind(2) the socket if we really need to.
1997
2615
if self.server_address[0] or self.server_address[1]:
2616
if self.server_address[1]:
2617
self.allow_reuse_address = True
1998
2618
if not self.server_address[0]:
1999
2619
if self.address_family == socket.AF_INET6:
2000
any_address = "::" # in6addr_any
2620
any_address = "::" # in6addr_any
2002
any_address = "0.0.0.0" # INADDR_ANY
2622
any_address = "0.0.0.0" # INADDR_ANY
2003
2623
self.server_address = (any_address,
2004
2624
self.server_address[1])
2005
2625
elif not self.server_address[1]:
2006
self.server_address = (self.server_address[0],
2626
self.server_address = (self.server_address[0], 0)
2008
2627
# if self.interface:
2009
2628
# self.server_address = (self.server_address[0],
2035
2659
self.gnutls_priority = gnutls_priority
2036
2660
IPv6_TCPServer.__init__(self, server_address,
2037
2661
RequestHandlerClass,
2038
interface = interface,
2039
use_ipv6 = use_ipv6,
2040
socketfd = socketfd)
2662
interface=interface,
2041
2666
def server_activate(self):
2042
2667
if self.enabled:
2043
2668
return socketserver.TCPServer.server_activate(self)
2045
2670
def enable(self):
2046
2671
self.enabled = True
2048
2673
def add_pipe(self, parent_pipe, proc):
2049
2674
# Call "handle_ipc" for both data and EOF events
2050
gobject.io_add_watch(parent_pipe.fileno(),
2051
gobject.IO_IN | gobject.IO_HUP,
2052
functools.partial(self.handle_ipc,
2057
def handle_ipc(self, source, condition, parent_pipe=None,
2058
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):
2059
2686
# error, or the other end of multiprocessing.Pipe has closed
2060
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2687
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2061
2688
# Wait for other process to exit
2065
2692
# Read a request from the child
2066
2693
request = parent_pipe.recv()
2067
2694
command = request[0]
2069
2696
if command == 'init':
2071
address = request[2]
2073
for c in self.clients.itervalues():
2074
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:
2078
logger.info("Client not found for fingerprint: %s, ad"
2079
"dress: %s", fpr, address)
2711
logger.info("Client not found for key ID: %s, address"
2712
": %s", key_id or fpr, address)
2080
2713
if self.use_dbus:
2081
2714
# Emit D-Bus signal
2082
mandos_dbus_service.ClientNotFound(fpr,
2715
mandos_dbus_service.ClientNotFound(key_id or fpr,
2084
2717
parent_pipe.send(False)
2087
gobject.io_add_watch(parent_pipe.fileno(),
2088
gobject.IO_IN | gobject.IO_HUP,
2089
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))
2095
2727
parent_pipe.send(True)
2096
2728
# remove the old hook in favor of the new above hook on
3134
logger.debug("Did setuid/setgid to {}:{}".format(uid,
2484
3136
except OSError as error:
3137
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3138
.format(uid, gid, os.strerror(error.errno)))
2485
3139
if error.errno != errno.EPERM:
2489
3143
# Enable all possible GnuTLS debugging
2491
3145
# "Use a log level over 10 to enable all debugging options."
2492
3146
# - GnuTLS manual
2493
gnutls.library.functions.gnutls_global_set_log_level(11)
2495
@gnutls.library.types.gnutls_log_func
3147
gnutls.global_set_log_level(11)
2496
3150
def debug_gnutls(level, string):
2497
3151
logger.debug("GnuTLS: %s", string[:-1])
2499
(gnutls.library.functions
2500
.gnutls_global_set_log_function(debug_gnutls))
3153
gnutls.global_set_log_function(debug_gnutls)
2502
3155
# Redirect stdin so all checkers get /dev/null
2503
3156
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2504
3157
os.dup2(null, sys.stdin.fileno())
2508
3161
# Need to fork before connecting to D-Bus
2509
3162
if not foreground:
2510
3163
# Close all input and output, do double fork, etc.
2513
# multiprocessing will use threads, so before we use gobject we
2514
# need to inform gobject that threads will be used.
2515
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.
2517
3171
global main_loop
2518
3172
# From the Avahi example code
2519
3173
DBusGMainLoop(set_as_default=True)
2520
main_loop = gobject.MainLoop()
3174
main_loop = GLib.MainLoop()
2521
3175
bus = dbus.SystemBus()
2522
3176
# End of Avahi example code
2525
3179
bus_name = dbus.service.BusName("se.recompile.Mandos",
2526
bus, do_not_queue=True)
2527
old_bus_name = (dbus.service.BusName
2528
("se.bsnet.fukt.Mandos", bus,
2530
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:
2531
3186
logger.error("Disabling D-Bus:", exc_info=e)
2532
3187
use_dbus = False
2533
3188
server_settings["use_dbus"] = False
2534
3189
tcp_server.use_dbus = False
2535
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2536
service = AvahiServiceToSyslog(name =
2537
server_settings["servicename"],
2538
servicetype = "_mandos._tcp",
2539
protocol = protocol, bus = bus)
2540
if server_settings["interface"]:
2541
service.interface = (if_nametoindex
2542
(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"))
2544
3201
global multiprocessing_manager
2545
3202
multiprocessing_manager = multiprocessing.Manager()
2547
3204
client_class = Client
2549
client_class = functools.partial(ClientDBus, bus = bus)
3206
client_class = functools.partial(ClientDBus, bus=bus)
2551
3208
client_settings = Client.config_parser(client_config)
2552
3209
old_client_settings = {}
2553
3210
clients_data = {}
2555
3212
# This is used to redirect stdout and stderr for checker processes
2557
wnull = open(os.devnull, "w") # A writable /dev/null
3214
wnull = open(os.devnull, "w") # A writable /dev/null
2558
3215
# Only used if server is running in foreground but not in debug
2560
3217
if debug or not foreground:
2563
3220
# Get client data and settings from last running state.
2564
3221
if server_settings["restore"]:
2566
3223
with open(stored_state_path, "rb") as stored_state:
2567
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"]
2569
3273
os.remove(stored_state_path)
2570
3274
except IOError as e:
2571
3275
if e.errno == errno.ENOENT:
2572
logger.warning("Could not load persistent state: {0}"
2573
.format(os.strerror(e.errno)))
3276
logger.warning("Could not load persistent state:"
3277
" {}".format(os.strerror(e.errno)))
2575
3279
logger.critical("Could not load persistent state:",
2578
3282
except EOFError as e:
2579
3283
logger.warning("Could not load persistent state: "
2580
"EOFError:", exc_info=e)
2582
3287
with PGPEngine() as pgp:
2583
for client_name, client in clients_data.iteritems():
3288
for client_name, client in clients_data.items():
2584
3289
# Skip removed clients
2585
3290
if client_name not in client_settings:
2588
3293
# Decide which value to use after restoring saved state.
2589
3294
# We have three different values: Old config file,
2590
3295
# new config file, and saved state.
2648
3353
for client_name in (set(client_settings)
2649
3354
- set(old_client_settings)):
2650
3355
clients_data[client_name] = client_settings[client_name]
2652
3357
# Create all client objects
2653
for client_name, client in clients_data.iteritems():
3358
for client_name, client in clients_data.items():
2654
3359
tcp_server.clients[client_name] = client_class(
2655
name = client_name, settings = client,
2656
server_settings = server_settings)
3362
server_settings=server_settings)
2658
3364
if not tcp_server.clients:
2659
3365
logger.warning("No clients defined")
2661
3367
if not foreground:
2662
3368
if pidfile is not None:
2666
pidfile.write(str(pid) + "\n".encode("utf-8"))
3372
print(pid, file=pidfile)
2667
3373
except IOError:
2668
3374
logger.error("Could not write to file %r with PID %d",
2669
3375
pidfilename, pid)
2671
3377
del pidfilename
2673
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2674
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)
2677
@alternate_dbus_interfaces({"se.recompile.Mandos":
2678
"se.bsnet.fukt.Mandos"})
2679
class MandosDBusService(DBusObjectWithProperties):
3385
@alternate_dbus_interfaces(
3386
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3387
class MandosDBusService(DBusObjectWithObjectManager):
2680
3388
"""A D-Bus proxy object"""
2681
3390
def __init__(self):
2682
3391
dbus.service.Object.__init__(self, bus, "/")
2683
3393
_interface = "se.recompile.Mandos"
2685
@dbus_interface_annotations(_interface)
2687
return { "org.freedesktop.DBus.Property"
2688
".EmitsChangedSignal":
2691
3395
@dbus.service.signal(_interface, signature="o")
2692
3396
def ClientAdded(self, objpath):
2696
3400
@dbus.service.signal(_interface, signature="ss")
2697
def ClientNotFound(self, fingerprint, address):
3401
def ClientNotFound(self, key_id, address):
3405
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2701
3407
@dbus.service.signal(_interface, signature="os")
2702
3408
def ClientRemoved(self, objpath, name):
3412
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2706
3414
@dbus.service.method(_interface, out_signature="ao")
2707
3415
def GetAllClients(self):
2709
return dbus.Array(c.dbus_object_path
2711
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":
2713
3422
@dbus.service.method(_interface,
2714
3423
out_signature="a{oa{sv}}")
2715
3424
def GetAllClientsWithProperties(self):
2717
3426
return dbus.Dictionary(
2718
((c.dbus_object_path, c.GetAll(""))
2719
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()},
2720
3430
signature="oa{sv}")
2722
3432
@dbus.service.method(_interface, in_signature="o")
2723
3433
def RemoveClient(self, object_path):
2725
for c in tcp_server.clients.itervalues():
3435
for c in tcp_server.clients.values():
2726
3436
if c.dbus_object_path == object_path:
2727
3437
del tcp_server.clients[c.name]
2728
3438
c.remove_from_connection()
2729
# Don't signal anything except ClientRemoved
3439
# Don't signal the disabling
2730
3440
c.disable(quiet=True)
2732
self.ClientRemoved(object_path, c.name)
3441
# Emit D-Bus signal for removal
3442
self.client_removed_signal(c)
2734
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,
2738
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
2741
3492
"Cleanup function; run on exit"
2744
multiprocessing.active_children()
3496
mp.active_children()
2746
3498
if not (tcp_server.clients or client_settings):
2749
3501
# Store client before exiting. Secrets are encrypted with key
2750
3502
# based on what config file has. If config file is
2751
3503
# removed/edited, old secret will thus be unrecovable.
2753
3505
with PGPEngine() as pgp:
2754
for client in tcp_server.clients.itervalues():
3506
for client in tcp_server.clients.values():
2755
3507
key = client_settings[client.name]["secret"]
2756
3508
client.encrypted_secret = pgp.encrypt(client.secret,
2758
3510
client_dict = {}
2760
3512
# A list of attributes that can not be pickled
2762
exclude = set(("bus", "changedstate", "secret",
2763
"checker", "server_settings"))
2764
for name, typ in (inspect.getmembers
2765
(dbus.service.Object)):
3514
exclude = {"bus", "changedstate", "secret",
3515
"checker", "server_settings"}
3516
for name, typ in inspect.getmembers(dbus.service
2766
3518
exclude.add(name)
2768
3520
client_dict["encrypted_secret"] = (client
2769
3521
.encrypted_secret)
2770
3522
for attr in client.client_structure:
2771
3523
if attr not in exclude:
2772
3524
client_dict[attr] = getattr(client, attr)
2774
3526
clients[client.name] = client_dict
2775
3527
del client_settings[client.name]["secret"]
2778
with (tempfile.NamedTemporaryFile
2779
(mode='wb', suffix=".pickle", prefix='clients-',
2780
dir=os.path.dirname(stored_state_path),
2781
delete=False)) as stored_state:
2782
pickle.dump((clients, client_settings), stored_state)
2783
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
2784
3539
os.rename(tempname, stored_state_path)
2785
3540
except (IOError, OSError) as e: