63
import cPickle as pickle
70
import cPickle as pickle
64
73
import multiprocessing
67
82
import dbus.service
83
from gi.repository import GLib
70
84
from dbus.mainloop.glib import DBusGMainLoop
73
87
import xml.dom.minidom
90
# Try to find the value of SO_BINDTODEVICE:
92
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
93
# newer, and it is also the most natural place for it:
77
94
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
78
95
except AttributeError:
97
# This is where SO_BINDTODEVICE was up to and including Python
80
99
from IN import SO_BINDTODEVICE
81
100
except ImportError:
82
SO_BINDTODEVICE = None
87
#logger = logging.getLogger('mandos')
88
logger = logging.Logger('mandos')
89
syslogger = (logging.handlers.SysLogHandler
90
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
91
address = str("/dev/log")))
92
syslogger.setFormatter(logging.Formatter
93
('Mandos [%(process)d]: %(levelname)s:'
95
logger.addHandler(syslogger)
97
console = logging.StreamHandler()
98
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
101
logger.addHandler(console)
101
# In Python 2.7 it seems to have been removed entirely.
102
# Try running the C preprocessor:
104
cc = subprocess.Popen(["cc", "--language=c", "-E",
106
stdin=subprocess.PIPE,
107
stdout=subprocess.PIPE)
108
stdout = cc.communicate(
109
"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
110
SO_BINDTODEVICE = int(stdout.splitlines()[-1])
111
except (OSError, ValueError, IndexError):
113
SO_BINDTODEVICE = None
115
if sys.version_info.major == 2:
119
stored_state_file = "clients.pickle"
121
logger = logging.getLogger()
125
if_nametoindex = ctypes.cdll.LoadLibrary(
126
ctypes.util.find_library("c")).if_nametoindex
127
except (OSError, AttributeError):
129
def if_nametoindex(interface):
130
"Get an interface index the hard way, i.e. using fcntl()"
131
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
132
with contextlib.closing(socket.socket()) as s:
133
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
134
struct.pack(b"16s16x", interface))
135
interface_index = struct.unpack("I", ifreq[16:20])[0]
136
return interface_index
139
def copy_function(func):
140
"""Make a copy of a function"""
141
if sys.version_info.major == 2:
142
return types.FunctionType(func.func_code,
148
return types.FunctionType(func.__code__,
155
def initlogger(debug, level=logging.WARNING):
156
"""init logger and add loglevel"""
159
syslogger = (logging.handlers.SysLogHandler(
160
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
162
syslogger.setFormatter(logging.Formatter
163
('Mandos [%(process)d]: %(levelname)s:'
165
logger.addHandler(syslogger)
168
console = logging.StreamHandler()
169
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
173
logger.addHandler(console)
174
logger.setLevel(level)
177
class PGPError(Exception):
178
"""Exception if encryption/decryption fails"""
182
class PGPEngine(object):
183
"""A simple class for OpenPGP symmetric encryption & decryption"""
186
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
189
output = subprocess.check_output(["gpgconf"])
190
for line in output.splitlines():
191
name, text, path = line.split(b":")
196
if e.errno != errno.ENOENT:
198
self.gnupgargs = ['--batch',
199
'--homedir', self.tempdir,
202
# Only GPG version 1 has the --no-use-agent option.
203
if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
204
self.gnupgargs.append("--no-use-agent")
209
def __exit__(self, exc_type, exc_value, traceback):
217
if self.tempdir is not None:
218
# Delete contents of tempdir
219
for root, dirs, files in os.walk(self.tempdir,
221
for filename in files:
222
os.remove(os.path.join(root, filename))
224
os.rmdir(os.path.join(root, dirname))
226
os.rmdir(self.tempdir)
229
def password_encode(self, password):
230
# Passphrase can not be empty and can not contain newlines or
231
# NUL bytes. So we prefix it and hex encode it.
232
encoded = b"mandos" + binascii.hexlify(password)
233
if len(encoded) > 2048:
234
# GnuPG can't handle long passwords, so encode differently
235
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
236
.replace(b"\n", b"\\n")
237
.replace(b"\0", b"\\x00"))
240
def encrypt(self, data, password):
241
passphrase = self.password_encode(password)
242
with tempfile.NamedTemporaryFile(
243
dir=self.tempdir) as passfile:
244
passfile.write(passphrase)
246
proc = subprocess.Popen([self.gpg, '--symmetric',
250
stdin=subprocess.PIPE,
251
stdout=subprocess.PIPE,
252
stderr=subprocess.PIPE)
253
ciphertext, err = proc.communicate(input=data)
254
if proc.returncode != 0:
258
def decrypt(self, data, password):
259
passphrase = self.password_encode(password)
260
with tempfile.NamedTemporaryFile(
261
dir=self.tempdir) as passfile:
262
passfile.write(passphrase)
264
proc = subprocess.Popen([self.gpg, '--decrypt',
268
stdin=subprocess.PIPE,
269
stdout=subprocess.PIPE,
270
stderr=subprocess.PIPE)
271
decrypted_plaintext, err = proc.communicate(input=data)
272
if proc.returncode != 0:
274
return decrypted_plaintext
277
# Pretend that we have an Avahi module
279
"""This isn't so much a class as it is a module-like namespace."""
280
IF_UNSPEC = -1 # avahi-common/address.h
281
PROTO_UNSPEC = -1 # avahi-common/address.h
282
PROTO_INET = 0 # avahi-common/address.h
283
PROTO_INET6 = 1 # avahi-common/address.h
284
DBUS_NAME = "org.freedesktop.Avahi"
285
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
286
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
287
DBUS_PATH_SERVER = "/"
290
def string_array_to_txt_array(t):
291
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
292
for s in t), signature="ay")
293
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
294
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
295
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
296
SERVER_INVALID = 0 # avahi-common/defs.h
297
SERVER_REGISTERING = 1 # avahi-common/defs.h
298
SERVER_RUNNING = 2 # avahi-common/defs.h
299
SERVER_COLLISION = 3 # avahi-common/defs.h
300
SERVER_FAILURE = 4 # avahi-common/defs.h
103
303
class AvahiError(Exception):
104
304
def __init__(self, value, *args, **kwargs):
105
305
self.value = value
106
super(AvahiError, self).__init__(value, *args, **kwargs)
107
def __unicode__(self):
108
return unicode(repr(self.value))
306
return super(AvahiError, self).__init__(value, *args,
110
310
class AvahiServiceError(AvahiError):
113
314
class AvahiGroupError(AvahiError):
117
318
class AvahiService(object):
118
319
"""An Avahi (Zeroconf) service.
121
322
interface: integer; avahi.IF_UNSPEC or an interface index.
122
323
Used to optionally bind to the specified interface.
123
324
name: string; Example: 'Mandos'
124
325
type: string; Example: '_mandos._tcp'.
125
See <http://www.dns-sd.org/ServiceTypes.html>
326
See <https://www.iana.org/assignments/service-names-port-numbers>
126
327
port: integer; what port to announce
127
328
TXT: list of strings; TXT record for the service
128
329
domain: string; Domain to publish on, default to .local if empty.
260
488
follow_name_owner_changes=True),
261
489
avahi.DBUS_INTERFACE_SERVER)
262
490
self.server.connect_to_signal("StateChanged",
263
self.server_state_changed)
491
self.server_state_changed)
264
492
self.server_state_changed(self.server.GetState())
495
class AvahiServiceToSyslog(AvahiService):
496
def rename(self, *args, **kwargs):
497
"""Add the new name to the syslog messages"""
498
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
499
syslogger.setFormatter(logging.Formatter(
500
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
505
# Pretend that we have a GnuTLS module
506
class gnutls(object):
507
"""This isn't so much a class as it is a module-like namespace."""
509
library = ctypes.util.find_library("gnutls")
511
library = ctypes.util.find_library("gnutls-deb0")
512
_library = ctypes.cdll.LoadLibrary(library)
515
# Unless otherwise indicated, the constants and types below are
516
# all from the gnutls/gnutls.h C header file.
527
E_NO_CERTIFICATE_FOUND = -49
532
KEYID_USE_SHA256 = 1 # gnutls/x509.h
533
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
536
class session_int(ctypes.Structure):
538
session_t = ctypes.POINTER(session_int)
540
class certificate_credentials_st(ctypes.Structure):
542
certificate_credentials_t = ctypes.POINTER(
543
certificate_credentials_st)
544
certificate_type_t = ctypes.c_int
546
class datum_t(ctypes.Structure):
547
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
548
('size', ctypes.c_uint)]
550
class openpgp_crt_int(ctypes.Structure):
552
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
553
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
554
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
555
credentials_type_t = ctypes.c_int
556
transport_ptr_t = ctypes.c_void_p
557
close_request_t = ctypes.c_int
560
class Error(Exception):
561
def __init__(self, message=None, code=None, args=()):
562
# Default usage is by a message string, but if a return
563
# code is passed, convert it to a string with
566
if message is None and code is not None:
567
message = gnutls.strerror(code)
568
return super(gnutls.Error, self).__init__(
571
class CertificateSecurityError(Error):
575
class Credentials(object):
577
self._c_object = gnutls.certificate_credentials_t()
578
gnutls.certificate_allocate_credentials(
579
ctypes.byref(self._c_object))
580
self.type = gnutls.CRD_CERTIFICATE
583
gnutls.certificate_free_credentials(self._c_object)
585
class ClientSession(object):
586
def __init__(self, socket, credentials=None):
587
self._c_object = gnutls.session_t()
588
gnutls_flags = gnutls.CLIENT
589
if gnutls.check_version(b"3.5.6"):
590
gnutls_flags |= gnutls.NO_TICKETS
592
gnutls_flags |= gnutls.ENABLE_RAWPK
593
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
595
gnutls.set_default_priority(self._c_object)
596
gnutls.transport_set_ptr(self._c_object, socket.fileno())
597
gnutls.handshake_set_private_extensions(self._c_object,
600
if credentials is None:
601
credentials = gnutls.Credentials()
602
gnutls.credentials_set(self._c_object, credentials.type,
603
ctypes.cast(credentials._c_object,
605
self.credentials = credentials
608
gnutls.deinit(self._c_object)
611
return gnutls.handshake(self._c_object)
613
def send(self, data):
617
data_len -= gnutls.record_send(self._c_object,
622
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
624
# Error handling functions
625
def _error_code(result):
626
"""A function to raise exceptions on errors, suitable
627
for the 'restype' attribute on ctypes functions"""
630
if result == gnutls.E_NO_CERTIFICATE_FOUND:
631
raise gnutls.CertificateSecurityError(code=result)
632
raise gnutls.Error(code=result)
634
def _retry_on_error(result, func, arguments):
635
"""A function to retry on some errors, suitable
636
for the 'errcheck' attribute on ctypes functions"""
638
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
639
return _error_code(result)
640
result = func(*arguments)
643
# Unless otherwise indicated, the function declarations below are
644
# all from the gnutls/gnutls.h C header file.
647
priority_set_direct = _library.gnutls_priority_set_direct
648
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
649
ctypes.POINTER(ctypes.c_char_p)]
650
priority_set_direct.restype = _error_code
652
init = _library.gnutls_init
653
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
654
init.restype = _error_code
656
set_default_priority = _library.gnutls_set_default_priority
657
set_default_priority.argtypes = [session_t]
658
set_default_priority.restype = _error_code
660
record_send = _library.gnutls_record_send
661
record_send.argtypes = [session_t, ctypes.c_void_p,
663
record_send.restype = ctypes.c_ssize_t
664
record_send.errcheck = _retry_on_error
666
certificate_allocate_credentials = (
667
_library.gnutls_certificate_allocate_credentials)
668
certificate_allocate_credentials.argtypes = [
669
ctypes.POINTER(certificate_credentials_t)]
670
certificate_allocate_credentials.restype = _error_code
672
certificate_free_credentials = (
673
_library.gnutls_certificate_free_credentials)
674
certificate_free_credentials.argtypes = [
675
certificate_credentials_t]
676
certificate_free_credentials.restype = None
678
handshake_set_private_extensions = (
679
_library.gnutls_handshake_set_private_extensions)
680
handshake_set_private_extensions.argtypes = [session_t,
682
handshake_set_private_extensions.restype = None
684
credentials_set = _library.gnutls_credentials_set
685
credentials_set.argtypes = [session_t, credentials_type_t,
687
credentials_set.restype = _error_code
689
strerror = _library.gnutls_strerror
690
strerror.argtypes = [ctypes.c_int]
691
strerror.restype = ctypes.c_char_p
693
certificate_type_get = _library.gnutls_certificate_type_get
694
certificate_type_get.argtypes = [session_t]
695
certificate_type_get.restype = _error_code
697
certificate_get_peers = _library.gnutls_certificate_get_peers
698
certificate_get_peers.argtypes = [session_t,
699
ctypes.POINTER(ctypes.c_uint)]
700
certificate_get_peers.restype = ctypes.POINTER(datum_t)
702
global_set_log_level = _library.gnutls_global_set_log_level
703
global_set_log_level.argtypes = [ctypes.c_int]
704
global_set_log_level.restype = None
706
global_set_log_function = _library.gnutls_global_set_log_function
707
global_set_log_function.argtypes = [log_func]
708
global_set_log_function.restype = None
710
deinit = _library.gnutls_deinit
711
deinit.argtypes = [session_t]
712
deinit.restype = None
714
handshake = _library.gnutls_handshake
715
handshake.argtypes = [session_t]
716
handshake.restype = _error_code
717
handshake.errcheck = _retry_on_error
719
transport_set_ptr = _library.gnutls_transport_set_ptr
720
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
721
transport_set_ptr.restype = None
723
bye = _library.gnutls_bye
724
bye.argtypes = [session_t, close_request_t]
725
bye.restype = _error_code
726
bye.errcheck = _retry_on_error
728
check_version = _library.gnutls_check_version
729
check_version.argtypes = [ctypes.c_char_p]
730
check_version.restype = ctypes.c_char_p
732
_need_version = b"3.3.0"
733
if check_version(_need_version) is None:
734
raise self.Error("Needs GnuTLS {} or later"
735
.format(_need_version))
737
_tls_rawpk_version = b"3.6.6"
738
has_rawpk = bool(check_version(_tls_rawpk_version))
742
class pubkey_st(ctypes.Structure):
744
pubkey_t = ctypes.POINTER(pubkey_st)
746
x509_crt_fmt_t = ctypes.c_int
748
# All the function declarations below are from gnutls/abstract.h
749
pubkey_init = _library.gnutls_pubkey_init
750
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
751
pubkey_init.restype = _error_code
753
pubkey_import = _library.gnutls_pubkey_import
754
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
756
pubkey_import.restype = _error_code
758
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
759
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
760
ctypes.POINTER(ctypes.c_ubyte),
761
ctypes.POINTER(ctypes.c_size_t)]
762
pubkey_get_key_id.restype = _error_code
764
pubkey_deinit = _library.gnutls_pubkey_deinit
765
pubkey_deinit.argtypes = [pubkey_t]
766
pubkey_deinit.restype = None
768
# All the function declarations below are from gnutls/openpgp.h
770
openpgp_crt_init = _library.gnutls_openpgp_crt_init
771
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
772
openpgp_crt_init.restype = _error_code
774
openpgp_crt_import = _library.gnutls_openpgp_crt_import
775
openpgp_crt_import.argtypes = [openpgp_crt_t,
776
ctypes.POINTER(datum_t),
778
openpgp_crt_import.restype = _error_code
780
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
781
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
782
ctypes.POINTER(ctypes.c_uint)]
783
openpgp_crt_verify_self.restype = _error_code
785
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
786
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
787
openpgp_crt_deinit.restype = None
789
openpgp_crt_get_fingerprint = (
790
_library.gnutls_openpgp_crt_get_fingerprint)
791
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
795
openpgp_crt_get_fingerprint.restype = _error_code
797
if check_version(b"3.6.4"):
798
certificate_type_get2 = _library.gnutls_certificate_type_get2
799
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
800
certificate_type_get2.restype = _error_code
802
# Remove non-public functions
803
del _error_code, _retry_on_error
806
def call_pipe(connection, # : multiprocessing.Connection
807
func, *args, **kwargs):
808
"""This function is meant to be called by multiprocessing.Process
810
This function runs func(*args, **kwargs), and writes the resulting
811
return value on the provided multiprocessing.Connection.
813
connection.send(func(*args, **kwargs))
267
817
class Client(object):
268
818
"""A representation of a client host served by this server.
271
_approved: bool(); 'None' if not yet approved/disapproved
821
approved: bool(); 'None' if not yet approved/disapproved
272
822
approval_delay: datetime.timedelta(); Time to wait for approval
273
823
approval_duration: datetime.timedelta(); Duration of one approval
274
checker: subprocess.Popen(); a running checker process used
275
to see if the client lives.
276
'None' if no process is running.
277
checker_callback_tag: a gobject event source tag, or None
824
checker: multiprocessing.Process(); a running checker process used
825
to see if the client lives. 'None' if no process is
827
checker_callback_tag: a GLib event source tag, or None
278
828
checker_command: string; External command which is run to check
279
829
if client lives. %() expansions are done at
280
830
runtime with vars(self) as dict, so that for
281
831
instance %(name)s can be used in the command.
282
checker_initiator_tag: a gobject event source tag, or None
832
checker_initiator_tag: a GLib event source tag, or None
283
833
created: datetime.datetime(); (UTC) object creation
834
client_structure: Object describing what attributes a client has
835
and is used for storing the client at exit
284
836
current_checker_command: string; current running checker_command
285
disable_hook: If set, called by disable() as disable_hook(self)
286
disable_initiator_tag: a gobject event source tag, or None
837
disable_initiator_tag: a GLib event source tag, or None
288
839
fingerprint: string (40 or 32 hexadecimal digits); used to
289
uniquely identify the client
840
uniquely identify an OpenPGP client
841
key_id: string (64 hexadecimal digits); used to uniquely identify
842
a client using raw public keys
290
843
host: string; available for use by the checker command
291
844
interval: datetime.timedelta(); How often to start a new checker
292
845
last_approval_request: datetime.datetime(); (UTC) or None
293
846
last_checked_ok: datetime.datetime(); (UTC) or None
294
last_enabled: datetime.datetime(); (UTC)
847
last_checker_status: integer between 0 and 255 reflecting exit
848
status of last checker. -1 reflects crashed
849
checker, -2 means no checker completed yet.
850
last_checker_signal: The signal which killed the last checker, if
851
last_checker_status is -1
852
last_enabled: datetime.datetime(); (UTC) or None
295
853
name: string; from the config file, used in log messages and
296
854
D-Bus identifiers
297
855
secret: bytestring; sent verbatim (over TLS) to client
298
856
timeout: datetime.timedelta(); How long from last_checked_ok
299
857
until this client is disabled
858
extended_timeout: extra long timeout when secret has been sent
300
859
runtime_expansions: Allowed attributes for runtime expansion.
860
expires: datetime.datetime(); time (UTC) when a client will be
862
server_settings: The server_settings dict from main()
303
865
runtime_expansions = ("approval_delay", "approval_duration",
304
"created", "enabled", "fingerprint",
305
"host", "interval", "last_checked_ok",
866
"created", "enabled", "expires", "key_id",
867
"fingerprint", "host", "interval",
868
"last_approval_request", "last_checked_ok",
306
869
"last_enabled", "name", "timeout")
872
"extended_timeout": "PT15M",
874
"checker": "fping -q -- %%(host)s",
876
"approval_delay": "PT0S",
877
"approval_duration": "PT1S",
878
"approved_by_default": "True",
309
def _timedelta_to_milliseconds(td):
310
"Convert a datetime.timedelta() to milliseconds"
311
return ((td.days * 24 * 60 * 60 * 1000)
312
+ (td.seconds * 1000)
313
+ (td.microseconds // 1000))
315
def timeout_milliseconds(self):
316
"Return the 'timeout' attribute in milliseconds"
317
return self._timedelta_to_milliseconds(self.timeout)
319
def interval_milliseconds(self):
320
"Return the 'interval' attribute in milliseconds"
321
return self._timedelta_to_milliseconds(self.interval)
323
def approval_delay_milliseconds(self):
324
return self._timedelta_to_milliseconds(self.approval_delay)
326
def __init__(self, name = None, disable_hook=None, config=None):
327
"""Note: the 'checker' key in 'config' sets the
328
'checker_command' attribute and *not* the 'checker'
883
def config_parser(config):
884
"""Construct a new dict of client settings of this form:
885
{ client_name: {setting_name: value, ...}, ...}
886
with exceptions for any special settings as defined above.
887
NOTE: Must be a pure function. Must return the same result
888
value given the same arguments.
891
for client_name in config.sections():
892
section = dict(config.items(client_name))
893
client = settings[client_name] = {}
895
client["host"] = section["host"]
896
# Reformat values from string types to Python types
897
client["approved_by_default"] = config.getboolean(
898
client_name, "approved_by_default")
899
client["enabled"] = config.getboolean(client_name,
902
# Uppercase and remove spaces from key_id and fingerprint
903
# for later comparison purposes with return value from the
904
# key_id() and fingerprint() functions
905
client["key_id"] = (section.get("key_id", "").upper()
907
client["fingerprint"] = (section["fingerprint"].upper()
909
if "secret" in section:
910
client["secret"] = codecs.decode(section["secret"]
913
elif "secfile" in section:
914
with open(os.path.expanduser(os.path.expandvars
915
(section["secfile"])),
917
client["secret"] = secfile.read()
919
raise TypeError("No secret or secfile for section {}"
921
client["timeout"] = string_to_delta(section["timeout"])
922
client["extended_timeout"] = string_to_delta(
923
section["extended_timeout"])
924
client["interval"] = string_to_delta(section["interval"])
925
client["approval_delay"] = string_to_delta(
926
section["approval_delay"])
927
client["approval_duration"] = string_to_delta(
928
section["approval_duration"])
929
client["checker_command"] = section["checker"]
930
client["last_approval_request"] = None
931
client["last_checked_ok"] = None
932
client["last_checker_status"] = -2
936
def __init__(self, settings, name=None, server_settings=None):
938
if server_settings is None:
940
self.server_settings = server_settings
941
# adding all client settings
942
for setting, value in settings.items():
943
setattr(self, setting, value)
946
if not hasattr(self, "last_enabled"):
947
self.last_enabled = datetime.datetime.utcnow()
948
if not hasattr(self, "expires"):
949
self.expires = (datetime.datetime.utcnow()
952
self.last_enabled = None
333
955
logger.debug("Creating client %r", self.name)
334
# Uppercase and remove spaces from fingerprint for later
335
# comparison purposes with return value from the fingerprint()
337
self.fingerprint = (config["fingerprint"].upper()
956
logger.debug(" Key ID: %s", self.key_id)
339
957
logger.debug(" Fingerprint: %s", self.fingerprint)
340
if "secret" in config:
341
self.secret = config["secret"].decode("base64")
342
elif "secfile" in config:
343
with open(os.path.expanduser(os.path.expandvars
344
(config["secfile"])),
346
self.secret = secfile.read()
348
raise TypeError("No secret or secfile for client %s"
350
self.host = config.get("host", "")
351
self.created = datetime.datetime.utcnow()
353
self.last_approval_request = None
354
self.last_enabled = None
355
self.last_checked_ok = None
356
self.timeout = string_to_delta(config["timeout"])
357
self.interval = string_to_delta(config["interval"])
358
self.disable_hook = disable_hook
958
self.created = settings.get("created",
959
datetime.datetime.utcnow())
961
# attributes specific for this server instance
359
962
self.checker = None
360
963
self.checker_initiator_tag = None
361
964
self.disable_initiator_tag = None
362
965
self.checker_callback_tag = None
363
self.checker_command = config["checker"]
364
966
self.current_checker_command = None
365
self.last_connect = None
366
self._approved = None
367
self.approved_by_default = config.get("approved_by_default",
369
968
self.approvals_pending = 0
370
self.approval_delay = string_to_delta(
371
config["approval_delay"])
372
self.approval_duration = string_to_delta(
373
config["approval_duration"])
374
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
969
self.changedstate = multiprocessing_manager.Condition(
970
multiprocessing_manager.Lock())
971
self.client_structure = [attr
972
for attr in self.__dict__.keys()
973
if not attr.startswith("_")]
974
self.client_structure.append("client_structure")
976
for name, t in inspect.getmembers(
977
type(self), lambda obj: isinstance(obj, property)):
978
if not name.startswith("_"):
979
self.client_structure.append(name)
981
# Send notice to process children that client state has changed
376
982
def send_changedstate(self):
377
self.changedstate.acquire()
378
self.changedstate.notify_all()
379
self.changedstate.release()
983
with self.changedstate:
984
self.changedstate.notify_all()
381
986
def enable(self):
382
987
"""Start this client's checker and timeout hooks"""
383
988
if getattr(self, "enabled", False):
384
989
# Already enabled
386
self.send_changedstate()
991
self.expires = datetime.datetime.utcnow() + self.timeout
387
993
self.last_enabled = datetime.datetime.utcnow()
388
# Schedule a new checker to be started an 'interval' from now,
389
# and every interval from then on.
390
self.checker_initiator_tag = (gobject.timeout_add
391
(self.interval_milliseconds(),
393
# Schedule a disable() when 'timeout' has passed
394
self.disable_initiator_tag = (gobject.timeout_add
395
(self.timeout_milliseconds(),
398
# Also start a new checker *right now*.
995
self.send_changedstate()
401
997
def disable(self, quiet=True):
402
998
"""Disable this client."""
403
999
if not getattr(self, "enabled", False):
406
self.send_changedstate()
408
1002
logger.info("Disabling client %s", self.name)
409
if getattr(self, "disable_initiator_tag", False):
410
gobject.source_remove(self.disable_initiator_tag)
1003
if getattr(self, "disable_initiator_tag", None) is not None:
1004
GLib.source_remove(self.disable_initiator_tag)
411
1005
self.disable_initiator_tag = None
412
if getattr(self, "checker_initiator_tag", False):
413
gobject.source_remove(self.checker_initiator_tag)
1007
if getattr(self, "checker_initiator_tag", None) is not None:
1008
GLib.source_remove(self.checker_initiator_tag)
414
1009
self.checker_initiator_tag = None
415
1010
self.stop_checker()
416
if self.disable_hook:
417
self.disable_hook(self)
418
1011
self.enabled = False
419
# Do not run this again if called by a gobject.timeout_add
1013
self.send_changedstate()
1014
# Do not run this again if called by a GLib.timeout_add
422
1017
def __del__(self):
423
self.disable_hook = None
426
def checker_callback(self, pid, condition, command):
1020
def init_checker(self):
1021
# Schedule a new checker to be started an 'interval' from now,
1022
# and every interval from then on.
1023
if self.checker_initiator_tag is not None:
1024
GLib.source_remove(self.checker_initiator_tag)
1025
self.checker_initiator_tag = GLib.timeout_add(
1026
int(self.interval.total_seconds() * 1000),
1028
# Schedule a disable() when 'timeout' has passed
1029
if self.disable_initiator_tag is not None:
1030
GLib.source_remove(self.disable_initiator_tag)
1031
self.disable_initiator_tag = GLib.timeout_add(
1032
int(self.timeout.total_seconds() * 1000), self.disable)
1033
# Also start a new checker *right now*.
1034
self.start_checker()
1036
def checker_callback(self, source, condition, connection,
427
1038
"""The checker has completed, so take appropriate actions."""
1039
# Read return code from connection (see call_pipe)
1040
returncode = connection.recv()
428
1043
self.checker_callback_tag = None
429
1044
self.checker = None
430
if os.WIFEXITED(condition):
431
exitstatus = os.WEXITSTATUS(condition)
1047
self.last_checker_status = returncode
1048
self.last_checker_signal = None
1049
if self.last_checker_status == 0:
433
1050
logger.info("Checker for %(name)s succeeded",
435
1052
self.checked_ok()
437
logger.info("Checker for %(name)s failed",
1054
logger.info("Checker for %(name)s failed", vars(self))
1056
self.last_checker_status = -1
1057
self.last_checker_signal = -returncode
440
1058
logger.warning("Checker for %(name)s crashed?",
443
1062
def checked_ok(self):
444
"""Bump up the timeout for this client.
446
This should only be called when the client has been seen,
1063
"""Assert that the client has been seen, alive and well."""
449
1064
self.last_checked_ok = datetime.datetime.utcnow()
450
gobject.source_remove(self.disable_initiator_tag)
451
self.disable_initiator_tag = (gobject.timeout_add
452
(self.timeout_milliseconds(),
1065
self.last_checker_status = 0
1066
self.last_checker_signal = None
1069
def bump_timeout(self, timeout=None):
1070
"""Bump up the timeout for this client."""
1072
timeout = self.timeout
1073
if self.disable_initiator_tag is not None:
1074
GLib.source_remove(self.disable_initiator_tag)
1075
self.disable_initiator_tag = None
1076
if getattr(self, "enabled", False):
1077
self.disable_initiator_tag = GLib.timeout_add(
1078
int(timeout.total_seconds() * 1000), self.disable)
1079
self.expires = datetime.datetime.utcnow() + timeout
455
1081
def need_approval(self):
456
1082
self.last_approval_request = datetime.datetime.utcnow()
458
1084
def start_checker(self):
459
1085
"""Start a new checker subprocess if one is not running.
461
1087
If a checker already exists, leave it running and do
463
1089
# The reason for not killing a running checker is that if we
464
# did that, then if a checker (for some reason) started
465
# running slowly and taking more than 'interval' time, the
466
# client would inevitably timeout, since no checker would get
467
# a chance to run to completion. If we instead leave running
1090
# did that, and if a checker (for some reason) started running
1091
# slowly and taking more than 'interval' time, then the client
1092
# would inevitably timeout, since no checker would get a
1093
# chance to run to completion. If we instead leave running
468
1094
# checkers alone, the checker would have to take more time
469
1095
# than 'timeout' for the client to be disabled, which is as it
472
# If a checker exists, make sure it is not a zombie
474
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
475
except (AttributeError, OSError) as error:
476
if (isinstance(error, OSError)
477
and error.errno != errno.ECHILD):
481
logger.warning("Checker was a zombie")
482
gobject.source_remove(self.checker_callback_tag)
483
self.checker_callback(pid, status,
484
self.current_checker_command)
1098
if self.checker is not None and not self.checker.is_alive():
1099
logger.warning("Checker was not alive; joining")
485
1102
# Start a new checker if needed
486
1103
if self.checker is None:
1104
# Escape attributes for the shell
1106
attr: re.escape(str(getattr(self, attr)))
1107
for attr in self.runtime_expansions}
488
# In case checker_command has exactly one % operator
489
command = self.checker_command % self.host
491
# Escape attributes for the shell
492
escaped_attrs = dict(
494
re.escape(unicode(str(getattr(self, attr, "")),
498
self.runtime_expansions)
501
command = self.checker_command % escaped_attrs
502
except TypeError as error:
503
logger.error('Could not format string "%s":'
504
' %s', self.checker_command, error)
505
return True # Try again later
1109
command = self.checker_command % escaped_attrs
1110
except TypeError as error:
1111
logger.error('Could not format string "%s"',
1112
self.checker_command,
1114
return True # Try again later
506
1115
self.current_checker_command = command
508
logger.info("Starting checker %r for %s",
510
# We don't need to redirect stdout and stderr, since
511
# in normal mode, that is already done by daemon(),
512
# and in debug mode we don't want to. (Stdin is
513
# always replaced by /dev/null.)
514
self.checker = subprocess.Popen(command,
517
self.checker_callback_tag = (gobject.child_watch_add
519
self.checker_callback,
521
# The checker may have completed before the gobject
522
# watch was added. Check for this.
523
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
525
gobject.source_remove(self.checker_callback_tag)
526
self.checker_callback(pid, status, command)
527
except OSError as error:
528
logger.error("Failed to start subprocess: %s",
530
# Re-run this periodically if run by gobject.timeout_add
1116
logger.info("Starting checker %r for %s", command,
1118
# We don't need to redirect stdout and stderr, since
1119
# in normal mode, that is already done by daemon(),
1120
# and in debug mode we don't want to. (Stdin is
1121
# always replaced by /dev/null.)
1122
# The exception is when not debugging but nevertheless
1123
# running in the foreground; use the previously
1125
popen_args = {"close_fds": True,
1128
if (not self.server_settings["debug"]
1129
and self.server_settings["foreground"]):
1130
popen_args.update({"stdout": wnull,
1132
pipe = multiprocessing.Pipe(duplex=False)
1133
self.checker = multiprocessing.Process(
1135
args=(pipe[1], subprocess.call, command),
1137
self.checker.start()
1138
self.checker_callback_tag = GLib.io_add_watch(
1139
pipe[0].fileno(), GLib.IO_IN,
1140
self.checker_callback, pipe[0], command)
1141
# Re-run this periodically if run by GLib.timeout_add
533
1144
def stop_checker(self):
534
1145
"""Force the checker process, if any, to stop."""
535
1146
if self.checker_callback_tag:
536
gobject.source_remove(self.checker_callback_tag)
1147
GLib.source_remove(self.checker_callback_tag)
537
1148
self.checker_callback_tag = None
538
1149
if getattr(self, "checker", None) is None:
540
1151
logger.debug("Stopping checker for %(name)s", vars(self))
542
os.kill(self.checker.pid, signal.SIGTERM)
544
#if self.checker.poll() is None:
545
# os.kill(self.checker.pid, signal.SIGKILL)
546
except OSError as error:
547
if error.errno != errno.ESRCH: # No such process
1152
self.checker.terminate()
549
1153
self.checker = None
551
def dbus_service_property(dbus_interface, signature="v",
552
access="readwrite", byte_arrays=False):
1156
def dbus_service_property(dbus_interface,
553
1160
"""Decorators for marking methods of a DBusObjectWithProperties to
554
1161
become properties on the D-Bus.
556
1163
The decorated method will be called with no arguments by "Get"
557
1164
and with one argument by "Set".
559
1166
The parameters, where they are supported, are the same as
560
1167
dbus.service.method, except there is only "signature", since the
561
1168
type from Get() and the type sent to Set() is the same.
733
1501
except (AttributeError, xml.dom.DOMException,
734
1502
xml.parsers.expat.ExpatError) as error:
735
1503
logger.error("Failed to override Introspection method",
1509
dbus.OBJECT_MANAGER_IFACE
1510
except AttributeError:
1511
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1514
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1515
"""A D-Bus object with an ObjectManager.
1517
Classes inheriting from this exposes the standard
1518
GetManagedObjects call and the InterfacesAdded and
1519
InterfacesRemoved signals on the standard
1520
"org.freedesktop.DBus.ObjectManager" interface.
1522
Note: No signals are sent automatically; they must be sent
1525
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1526
out_signature="a{oa{sa{sv}}}")
1527
def GetManagedObjects(self):
1528
"""This function must be overridden"""
1529
raise NotImplementedError()
1531
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1532
signature="oa{sa{sv}}")
1533
def InterfacesAdded(self, object_path, interfaces_and_properties):
1536
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1537
def InterfacesRemoved(self, object_path, interfaces):
1540
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1542
path_keyword='object_path',
1543
connection_keyword='connection')
1544
def Introspect(self, object_path, connection):
1545
"""Overloading of standard D-Bus method.
1547
Override return argument name of GetManagedObjects to be
1548
"objpath_interfaces_and_properties"
1550
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1554
document = xml.dom.minidom.parseString(xmlstring)
1556
for if_tag in document.getElementsByTagName("interface"):
1557
# Fix argument name for the GetManagedObjects method
1558
if (if_tag.getAttribute("name")
1559
== dbus.OBJECT_MANAGER_IFACE):
1560
for cn in if_tag.getElementsByTagName("method"):
1561
if (cn.getAttribute("name")
1562
== "GetManagedObjects"):
1563
for arg in cn.getElementsByTagName("arg"):
1564
if (arg.getAttribute("direction")
1568
"objpath_interfaces"
1570
xmlstring = document.toxml("utf-8")
1572
except (AttributeError, xml.dom.DOMException,
1573
xml.parsers.expat.ExpatError) as error:
1574
logger.error("Failed to override Introspection method",
1579
def datetime_to_dbus(dt, variant_level=0):
1580
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1582
return dbus.String("", variant_level=variant_level)
1583
return dbus.String(dt.isoformat(), variant_level=variant_level)
1586
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1587
"""A class decorator; applied to a subclass of
1588
dbus.service.Object, it will add alternate D-Bus attributes with
1589
interface names according to the "alt_interface_names" mapping.
1592
@alternate_dbus_interfaces({"org.example.Interface":
1593
"net.example.AlternateInterface"})
1594
class SampleDBusObject(dbus.service.Object):
1595
@dbus.service.method("org.example.Interface")
1596
def SampleDBusMethod():
1599
The above "SampleDBusMethod" on "SampleDBusObject" will be
1600
reachable via two interfaces: "org.example.Interface" and
1601
"net.example.AlternateInterface", the latter of which will have
1602
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1603
"true", unless "deprecate" is passed with a False value.
1605
This works for methods and signals, and also for D-Bus properties
1606
(from DBusObjectWithProperties) and interfaces (from the
1607
dbus_interface_annotations decorator).
1611
for orig_interface_name, alt_interface_name in (
1612
alt_interface_names.items()):
1614
interface_names = set()
1615
# Go though all attributes of the class
1616
for attrname, attribute in inspect.getmembers(cls):
1617
# Ignore non-D-Bus attributes, and D-Bus attributes
1618
# with the wrong interface name
1619
if (not hasattr(attribute, "_dbus_interface")
1620
or not attribute._dbus_interface.startswith(
1621
orig_interface_name)):
1623
# Create an alternate D-Bus interface name based on
1625
alt_interface = attribute._dbus_interface.replace(
1626
orig_interface_name, alt_interface_name)
1627
interface_names.add(alt_interface)
1628
# Is this a D-Bus signal?
1629
if getattr(attribute, "_dbus_is_signal", False):
1630
# Extract the original non-method undecorated
1631
# function by black magic
1632
if sys.version_info.major == 2:
1633
nonmethod_func = (dict(
1634
zip(attribute.func_code.co_freevars,
1635
attribute.__closure__))
1636
["func"].cell_contents)
1638
nonmethod_func = (dict(
1639
zip(attribute.__code__.co_freevars,
1640
attribute.__closure__))
1641
["func"].cell_contents)
1642
# Create a new, but exactly alike, function
1643
# object, and decorate it to be a new D-Bus signal
1644
# with the alternate D-Bus interface name
1645
new_function = copy_function(nonmethod_func)
1646
new_function = (dbus.service.signal(
1648
attribute._dbus_signature)(new_function))
1649
# Copy annotations, if any
1651
new_function._dbus_annotations = dict(
1652
attribute._dbus_annotations)
1653
except AttributeError:
1656
# Define a creator of a function to call both the
1657
# original and alternate functions, so both the
1658
# original and alternate signals gets sent when
1659
# the function is called
1660
def fixscope(func1, func2):
1661
"""This function is a scope container to pass
1662
func1 and func2 to the "call_both" function
1663
outside of its arguments"""
1665
@functools.wraps(func2)
1666
def call_both(*args, **kwargs):
1667
"""This function will emit two D-Bus
1668
signals by calling func1 and func2"""
1669
func1(*args, **kwargs)
1670
func2(*args, **kwargs)
1671
# Make wrapper function look like a D-Bus
1673
for name, attr in inspect.getmembers(func2):
1674
if name.startswith("_dbus_"):
1675
setattr(call_both, name, attr)
1678
# Create the "call_both" function and add it to
1680
attr[attrname] = fixscope(attribute, new_function)
1681
# Is this a D-Bus method?
1682
elif getattr(attribute, "_dbus_is_method", False):
1683
# Create a new, but exactly alike, function
1684
# object. Decorate it to be a new D-Bus method
1685
# with the alternate D-Bus interface name. Add it
1688
dbus.service.method(
1690
attribute._dbus_in_signature,
1691
attribute._dbus_out_signature)
1692
(copy_function(attribute)))
1693
# Copy annotations, if any
1695
attr[attrname]._dbus_annotations = dict(
1696
attribute._dbus_annotations)
1697
except AttributeError:
1699
# Is this a D-Bus property?
1700
elif getattr(attribute, "_dbus_is_property", False):
1701
# Create a new, but exactly alike, function
1702
# object, and decorate it to be a new D-Bus
1703
# property with the alternate D-Bus interface
1704
# name. Add it to the class.
1705
attr[attrname] = (dbus_service_property(
1706
alt_interface, attribute._dbus_signature,
1707
attribute._dbus_access,
1708
attribute._dbus_get_args_options
1710
(copy_function(attribute)))
1711
# Copy annotations, if any
1713
attr[attrname]._dbus_annotations = dict(
1714
attribute._dbus_annotations)
1715
except AttributeError:
1717
# Is this a D-Bus interface?
1718
elif getattr(attribute, "_dbus_is_interface", False):
1719
# Create a new, but exactly alike, function
1720
# object. Decorate it to be a new D-Bus interface
1721
# with the alternate D-Bus interface name. Add it
1724
dbus_interface_annotations(alt_interface)
1725
(copy_function(attribute)))
1727
# Deprecate all alternate interfaces
1728
iname = "_AlternateDBusNames_interface_annotation{}"
1729
for interface_name in interface_names:
1731
@dbus_interface_annotations(interface_name)
1733
return {"org.freedesktop.DBus.Deprecated":
1735
# Find an unused name
1736
for aname in (iname.format(i)
1737
for i in itertools.count()):
1738
if aname not in attr:
1742
# Replace the class with a new subclass of it with
1743
# methods, signals, etc. as created above.
1744
if sys.version_info.major == 2:
1745
cls = type(b"{}Alternate".format(cls.__name__),
1748
cls = type("{}Alternate".format(cls.__name__),
1755
@alternate_dbus_interfaces({"se.recompile.Mandos":
1756
"se.bsnet.fukt.Mandos"})
740
1757
class ClientDBus(Client, DBusObjectWithProperties):
741
1758
"""A Client class using D-Bus
744
1761
dbus_object_path: dbus.ObjectPath
745
1762
bus: dbus.SystemBus()
748
1765
runtime_expansions = (Client.runtime_expansions
749
+ ("dbus_object_path",))
1766
+ ("dbus_object_path", ))
1768
_interface = "se.recompile.Mandos.Client"
751
1770
# dbus.service.Object doesn't use super(), so we can't either.
753
def __init__(self, bus = None, *args, **kwargs):
754
self._approvals_pending = 0
1772
def __init__(self, bus=None, *args, **kwargs):
756
1774
Client.__init__(self, *args, **kwargs)
757
1775
# Only now, when this client is initialized, can it show up on
759
client_object_name = unicode(self.name).translate(
1777
client_object_name = str(self.name).translate(
760
1778
{ord("."): ord("_"),
761
1779
ord("-"): ord("_")})
762
self.dbus_object_path = (dbus.ObjectPath
763
("/clients/" + client_object_name))
1780
self.dbus_object_path = dbus.ObjectPath(
1781
"/clients/" + client_object_name)
764
1782
DBusObjectWithProperties.__init__(self, self.bus,
765
1783
self.dbus_object_path)
767
def _get_approvals_pending(self):
768
return self._approvals_pending
769
def _set_approvals_pending(self, value):
770
old_value = self._approvals_pending
771
self._approvals_pending = value
773
if (hasattr(self, "dbus_object_path")
774
and bval is not bool(old_value)):
775
dbus_bool = dbus.Boolean(bval, variant_level=1)
776
self.PropertyChanged(dbus.String("ApprovalPending"),
779
approvals_pending = property(_get_approvals_pending,
780
_set_approvals_pending)
781
del _get_approvals_pending, _set_approvals_pending
784
def _datetime_to_dbus(dt, variant_level=0):
785
"""Convert a UTC datetime.datetime() to a D-Bus type."""
786
return dbus.String(dt.isoformat(),
787
variant_level=variant_level)
790
oldstate = getattr(self, "enabled", False)
791
r = Client.enable(self)
792
if oldstate != self.enabled:
794
self.PropertyChanged(dbus.String("Enabled"),
795
dbus.Boolean(True, variant_level=1))
796
self.PropertyChanged(
797
dbus.String("LastEnabled"),
798
self._datetime_to_dbus(self.last_enabled,
802
def disable(self, quiet = False):
803
oldstate = getattr(self, "enabled", False)
804
r = Client.disable(self, quiet=quiet)
805
if not quiet and oldstate != self.enabled:
807
self.PropertyChanged(dbus.String("Enabled"),
808
dbus.Boolean(False, variant_level=1))
1785
def notifychangeproperty(transform_func, dbus_name,
1786
type_func=lambda x: x,
1788
invalidate_only=False,
1789
_interface=_interface):
1790
""" Modify a variable so that it's a property which announces
1791
its changes to DBus.
1793
transform_fun: Function that takes a value and a variant_level
1794
and transforms it to a D-Bus type.
1795
dbus_name: D-Bus name of the variable
1796
type_func: Function that transform the value before sending it
1797
to the D-Bus. Default: no transform
1798
variant_level: D-Bus variant level. Default: 1
1800
attrname = "_{}".format(dbus_name)
1802
def setter(self, value):
1803
if hasattr(self, "dbus_object_path"):
1804
if (not hasattr(self, attrname) or
1805
type_func(getattr(self, attrname, None))
1806
!= type_func(value)):
1808
self.PropertiesChanged(
1809
_interface, dbus.Dictionary(),
1810
dbus.Array((dbus_name, )))
1812
dbus_value = transform_func(
1814
variant_level=variant_level)
1815
self.PropertyChanged(dbus.String(dbus_name),
1817
self.PropertiesChanged(
1819
dbus.Dictionary({dbus.String(dbus_name):
1822
setattr(self, attrname, value)
1824
return property(lambda self: getattr(self, attrname), setter)
1826
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1827
approvals_pending = notifychangeproperty(dbus.Boolean,
1830
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1831
last_enabled = notifychangeproperty(datetime_to_dbus,
1833
checker = notifychangeproperty(
1834
dbus.Boolean, "CheckerRunning",
1835
type_func=lambda checker: checker is not None)
1836
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1838
last_checker_status = notifychangeproperty(dbus.Int16,
1839
"LastCheckerStatus")
1840
last_approval_request = notifychangeproperty(
1841
datetime_to_dbus, "LastApprovalRequest")
1842
approved_by_default = notifychangeproperty(dbus.Boolean,
1843
"ApprovedByDefault")
1844
approval_delay = notifychangeproperty(
1845
dbus.UInt64, "ApprovalDelay",
1846
type_func=lambda td: td.total_seconds() * 1000)
1847
approval_duration = notifychangeproperty(
1848
dbus.UInt64, "ApprovalDuration",
1849
type_func=lambda td: td.total_seconds() * 1000)
1850
host = notifychangeproperty(dbus.String, "Host")
1851
timeout = notifychangeproperty(
1852
dbus.UInt64, "Timeout",
1853
type_func=lambda td: td.total_seconds() * 1000)
1854
extended_timeout = notifychangeproperty(
1855
dbus.UInt64, "ExtendedTimeout",
1856
type_func=lambda td: td.total_seconds() * 1000)
1857
interval = notifychangeproperty(
1858
dbus.UInt64, "Interval",
1859
type_func=lambda td: td.total_seconds() * 1000)
1860
checker_command = notifychangeproperty(dbus.String, "Checker")
1861
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1862
invalidate_only=True)
1864
del notifychangeproperty
811
1866
def __del__(self, *args, **kwargs):
813
1868
self.remove_from_connection()
1316
2367
delay -= time2 - time
1319
while sent_size < len(client.secret):
1321
sent = session.send(client.secret[sent_size:])
1322
except gnutls.errors.GNUTLSError as error:
1323
logger.warning("gnutls send failed")
1325
logger.debug("Sent: %d, remaining: %d",
1326
sent, len(client.secret)
1327
- (sent_size + sent))
2370
session.send(client.secret)
2371
except gnutls.Error as error:
2372
logger.warning("gnutls send failed",
1330
2376
logger.info("Sending secret to %s", client.name)
1331
# bump the timeout as if seen
2377
# bump the timeout using extended_timeout
2378
client.bump_timeout(client.extended_timeout)
1333
2379
if self.server.use_dbus:
1334
2380
# Emit D-Bus signal
1335
2381
client.GotSecret()
1338
2384
if approval_required:
1339
2385
client.approvals_pending -= 1
1342
except gnutls.errors.GNUTLSError as error:
1343
logger.warning("GnuTLS bye failed")
2388
except gnutls.Error as error:
2389
logger.warning("GnuTLS bye failed",
1346
2393
def peer_certificate(session):
1347
"Return the peer's OpenPGP certificate as a bytestring"
1348
# If not an OpenPGP certificate...
1349
if (gnutls.library.functions
1350
.gnutls_certificate_type_get(session._c_object)
1351
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1352
# ...do the normal thing
1353
return session.peer_certificate
2394
"Return the peer's certificate as a bytestring"
2396
cert_type = gnutls.certificate_type_get2(session._c_object,
2398
except AttributeError:
2399
cert_type = gnutls.certificate_type_get(session._c_object)
2400
if gnutls.has_rawpk:
2401
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2403
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2404
# If not a valid certificate type...
2405
if cert_type not in valid_cert_types:
2406
logger.info("Cert type %r not in %r", cert_type,
2408
# ...return invalid data
1354
2410
list_size = ctypes.c_uint(1)
1355
cert_list = (gnutls.library.functions
1356
.gnutls_certificate_get_peers
2411
cert_list = (gnutls.certificate_get_peers
1357
2412
(session._c_object, ctypes.byref(list_size)))
1358
2413
if not bool(cert_list) and list_size.value != 0:
1359
raise gnutls.errors.GNUTLSError("error getting peer"
2414
raise gnutls.Error("error getting peer certificate")
1361
2415
if list_size.value == 0:
1363
2417
cert = cert_list[0]
1364
2418
return ctypes.string_at(cert.data, cert.size)
2421
def key_id(certificate):
2422
"Convert a certificate bytestring to a hexdigit key ID"
2423
# New GnuTLS "datum" with the public key
2424
datum = gnutls.datum_t(
2425
ctypes.cast(ctypes.c_char_p(certificate),
2426
ctypes.POINTER(ctypes.c_ubyte)),
2427
ctypes.c_uint(len(certificate)))
2428
# XXX all these need to be created in the gnutls "module"
2429
# New empty GnuTLS certificate
2430
pubkey = gnutls.pubkey_t()
2431
gnutls.pubkey_init(ctypes.byref(pubkey))
2432
# Import the raw public key into the certificate
2433
gnutls.pubkey_import(pubkey,
2434
ctypes.byref(datum),
2435
gnutls.X509_FMT_DER)
2436
# New buffer for the key ID
2437
buf = ctypes.create_string_buffer(32)
2438
buf_len = ctypes.c_size_t(len(buf))
2439
# Get the key ID from the raw public key into the buffer
2440
gnutls.pubkey_get_key_id(pubkey,
2441
gnutls.KEYID_USE_SHA256,
2442
ctypes.cast(ctypes.byref(buf),
2443
ctypes.POINTER(ctypes.c_ubyte)),
2444
ctypes.byref(buf_len))
2445
# Deinit the certificate
2446
gnutls.pubkey_deinit(pubkey)
2448
# Convert the buffer to a Python bytestring
2449
key_id = ctypes.string_at(buf, buf_len.value)
2450
# Convert the bytestring to hexadecimal notation
2451
hex_key_id = binascii.hexlify(key_id).upper()
1367
2455
def fingerprint(openpgp):
1368
2456
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1369
2457
# New GnuTLS "datum" with the OpenPGP public key
1370
datum = (gnutls.library.types
1371
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1374
ctypes.c_uint(len(openpgp))))
2458
datum = gnutls.datum_t(
2459
ctypes.cast(ctypes.c_char_p(openpgp),
2460
ctypes.POINTER(ctypes.c_ubyte)),
2461
ctypes.c_uint(len(openpgp)))
1375
2462
# New empty GnuTLS certificate
1376
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1377
(gnutls.library.functions
1378
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2463
crt = gnutls.openpgp_crt_t()
2464
gnutls.openpgp_crt_init(ctypes.byref(crt))
1379
2465
# Import the OpenPGP public key into the certificate
1380
(gnutls.library.functions
1381
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1382
gnutls.library.constants
1383
.GNUTLS_OPENPGP_FMT_RAW))
2466
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2467
gnutls.OPENPGP_FMT_RAW)
1384
2468
# Verify the self signature in the key
1385
2469
crtverify = ctypes.c_uint()
1386
(gnutls.library.functions
1387
.gnutls_openpgp_crt_verify_self(crt, 0,
1388
ctypes.byref(crtverify)))
2470
gnutls.openpgp_crt_verify_self(crt, 0,
2471
ctypes.byref(crtverify))
1389
2472
if crtverify.value != 0:
1390
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1391
raise (gnutls.errors.CertificateSecurityError
2473
gnutls.openpgp_crt_deinit(crt)
2474
raise gnutls.CertificateSecurityError(code
1393
2476
# New buffer for the fingerprint
1394
2477
buf = ctypes.create_string_buffer(20)
1395
2478
buf_len = ctypes.c_size_t()
1396
2479
# Get the fingerprint from the certificate into the buffer
1397
(gnutls.library.functions
1398
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1399
ctypes.byref(buf_len)))
2480
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2481
ctypes.byref(buf_len))
1400
2482
# Deinit the certificate
1401
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2483
gnutls.openpgp_crt_deinit(crt)
1402
2484
# Convert the buffer to a Python bytestring
1403
2485
fpr = ctypes.string_at(buf, buf_len.value)
1404
2486
# Convert the bytestring to hexadecimal notation
1405
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
2487
hex_fpr = binascii.hexlify(fpr).upper()
1409
2491
class MultiprocessingMixIn(object):
1410
2492
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1411
2494
def sub_process_main(self, request, address):
1413
2496
self.finish_request(request, address)
1415
2498
self.handle_error(request, address)
1416
2499
self.close_request(request)
1418
2501
def process_request(self, request, address):
1419
2502
"""Start a new process to process the request."""
1420
multiprocessing.Process(target = self.sub_process_main,
1421
args = (request, address)).start()
2503
proc = multiprocessing.Process(target=self.sub_process_main,
2504
args=(request, address))
1423
2509
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1424
2510
""" adds a pipe to the MixIn """
1425
2512
def process_request(self, request, client_address):
1426
2513
"""Overrides and wraps the original process_request().
1428
2515
This function creates a new pipe in self.pipe
1430
2517
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1432
super(MultiprocessingMixInWithPipe,
1433
self).process_request(request, client_address)
2519
proc = MultiprocessingMixIn.process_request(self, request,
1434
2521
self.child_pipe.close()
1435
self.add_pipe(parent_pipe)
2522
self.add_pipe(parent_pipe, proc)
1437
def add_pipe(self, parent_pipe):
2524
def add_pipe(self, parent_pipe, proc):
1438
2525
"""Dummy function; override as necessary"""
1439
raise NotImplementedError
2526
raise NotImplementedError()
1441
2529
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1442
2530
socketserver.TCPServer, object):
1443
2531
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1446
2534
enabled: Boolean; whether this server is activated yet
1447
2535
interface: None or a network interface name (string)
1448
2536
use_ipv6: Boolean; to use IPv6 or not
1450
2539
def __init__(self, server_address, RequestHandlerClass,
1451
interface=None, use_ipv6=True):
2543
"""If socketfd is set, use that file descriptor instead of
2544
creating a new one with socket.socket().
1452
2546
self.interface = interface
1454
2548
self.address_family = socket.AF_INET6
2549
if socketfd is not None:
2550
# Save the file descriptor
2551
self.socketfd = socketfd
2552
# Save the original socket.socket() function
2553
self.socket_socket = socket.socket
2555
# To implement --socket, we monkey patch socket.socket.
2557
# (When socketserver.TCPServer is a new-style class, we
2558
# could make self.socket into a property instead of monkey
2559
# patching socket.socket.)
2561
# Create a one-time-only replacement for socket.socket()
2562
@functools.wraps(socket.socket)
2563
def socket_wrapper(*args, **kwargs):
2564
# Restore original function so subsequent calls are
2566
socket.socket = self.socket_socket
2567
del self.socket_socket
2568
# This time only, return a new socket object from the
2569
# saved file descriptor.
2570
return socket.fromfd(self.socketfd, *args, **kwargs)
2571
# Replace socket.socket() function with wrapper
2572
socket.socket = socket_wrapper
2573
# The socketserver.TCPServer.__init__ will call
2574
# socket.socket(), which might be our replacement,
2575
# socket_wrapper(), if socketfd was set.
1455
2576
socketserver.TCPServer.__init__(self, server_address,
1456
2577
RequestHandlerClass)
1457
2579
def server_bind(self):
1458
2580
"""This overrides the normal server_bind() function
1459
2581
to bind to an interface if one was specified, and also NOT to
1460
2582
bind to an address or port if they were not specified."""
2583
global SO_BINDTODEVICE
1461
2584
if self.interface is not None:
1462
2585
if SO_BINDTODEVICE is None:
1463
logger.error("SO_BINDTODEVICE does not exist;"
1464
" cannot bind to interface %s",
1468
self.socket.setsockopt(socket.SOL_SOCKET,
1472
except socket.error as error:
1473
if error[0] == errno.EPERM:
1474
logger.error("No permission to"
1475
" bind to interface %s",
1477
elif error[0] == errno.ENOPROTOOPT:
1478
logger.error("SO_BINDTODEVICE not available;"
1479
" cannot bind to interface %s",
2586
# Fall back to a hard-coded value which seems to be
2588
logger.warning("SO_BINDTODEVICE not found, trying 25")
2589
SO_BINDTODEVICE = 25
2591
self.socket.setsockopt(
2592
socket.SOL_SOCKET, SO_BINDTODEVICE,
2593
(self.interface + "\0").encode("utf-8"))
2594
except socket.error as error:
2595
if error.errno == errno.EPERM:
2596
logger.error("No permission to bind to"
2597
" interface %s", self.interface)
2598
elif error.errno == errno.ENOPROTOOPT:
2599
logger.error("SO_BINDTODEVICE not available;"
2600
" cannot bind to interface %s",
2602
elif error.errno == errno.ENODEV:
2603
logger.error("Interface %s does not exist,"
2604
" cannot bind", self.interface)
1483
2607
# Only bind(2) the socket if we really need to.
1484
2608
if self.server_address[0] or self.server_address[1]:
2609
if self.server_address[1]:
2610
self.allow_reuse_address = True
1485
2611
if not self.server_address[0]:
1486
2612
if self.address_family == socket.AF_INET6:
1487
any_address = "::" # in6addr_any
2613
any_address = "::" # in6addr_any
1489
any_address = socket.INADDR_ANY
2615
any_address = "0.0.0.0" # INADDR_ANY
1490
2616
self.server_address = (any_address,
1491
2617
self.server_address[1])
1492
2618
elif not self.server_address[1]:
1493
self.server_address = (self.server_address[0],
2619
self.server_address = (self.server_address[0], 0)
1495
2620
# if self.interface:
1496
2621
# self.server_address = (self.server_address[0],
1728
2949
parser.add_argument("--no-dbus", action="store_false",
1729
2950
dest="use_dbus", help="Do not provide D-Bus"
1730
" system bus interface")
2951
" system bus interface", default=None)
1731
2952
parser.add_argument("--no-ipv6", action="store_false",
1732
dest="use_ipv6", help="Do not use IPv6")
2953
dest="use_ipv6", help="Do not use IPv6",
2955
parser.add_argument("--no-restore", action="store_false",
2956
dest="restore", help="Do not restore stored"
2957
" state", default=None)
2958
parser.add_argument("--socket", type=int,
2959
help="Specify a file descriptor to a network"
2960
" socket to use instead of creating one")
2961
parser.add_argument("--statedir", metavar="DIR",
2962
help="Directory to save/restore state in")
2963
parser.add_argument("--foreground", action="store_true",
2964
help="Run in foreground", default=None)
2965
parser.add_argument("--no-zeroconf", action="store_false",
2966
dest="zeroconf", help="Do not use Zeroconf",
1733
2969
options = parser.parse_args()
1735
2971
if options.check:
2973
fail_count, test_count = doctest.testmod()
2974
sys.exit(os.EX_OK if fail_count == 0 else 1)
1740
2976
# Default values for config file for server-global settings
1741
server_defaults = { "interface": "",
1746
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1747
"servicename": "Mandos",
2977
if gnutls.has_rawpk:
2978
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2979
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2981
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2982
":+SIGN-DSA-SHA256")
2983
server_defaults = {"interface": "",
2987
"priority": priority,
2988
"servicename": "Mandos",
2994
"statedir": "/var/lib/mandos",
2995
"foreground": "False",
1753
3000
# Parse config file for server-global settings
1754
3001
server_config = configparser.SafeConfigParser(server_defaults)
1755
3002
del server_defaults
1756
server_config.read(os.path.join(options.configdir,
3003
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1758
3004
# Convert the SafeConfigParser object to a dict
1759
3005
server_settings = server_config.defaults()
1760
3006
# Use the appropriate methods on the non-string config options
1761
for option in ("debug", "use_dbus", "use_ipv6"):
3007
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3008
"foreground", "zeroconf"):
1762
3009
server_settings[option] = server_config.getboolean("DEFAULT",
1764
3011
if server_settings["port"]:
1765
3012
server_settings["port"] = server_config.getint("DEFAULT",
3014
if server_settings["socket"]:
3015
server_settings["socket"] = server_config.getint("DEFAULT",
3017
# Later, stdin will, and stdout and stderr might, be dup'ed
3018
# over with an opened os.devnull. But we don't want this to
3019
# happen with a supplied network socket.
3020
if 0 <= server_settings["socket"] <= 2:
3021
server_settings["socket"] = os.dup(server_settings
1767
3023
del server_config
1769
3025
# Override the settings from the config file with command line
1770
3026
# options, if set.
1771
3027
for option in ("interface", "address", "port", "debug",
1772
"priority", "servicename", "configdir",
1773
"use_dbus", "use_ipv6", "debuglevel"):
3028
"priority", "servicename", "configdir", "use_dbus",
3029
"use_ipv6", "debuglevel", "restore", "statedir",
3030
"socket", "foreground", "zeroconf"):
1774
3031
value = getattr(options, option)
1775
3032
if value is not None:
1776
3033
server_settings[option] = value
1778
3035
# Force all strings to be unicode
1779
3036
for option in server_settings.keys():
1780
if type(server_settings[option]) is str:
1781
server_settings[option] = unicode(server_settings[option])
3037
if isinstance(server_settings[option], bytes):
3038
server_settings[option] = (server_settings[option]
3040
# Force all boolean options to be boolean
3041
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3042
"foreground", "zeroconf"):
3043
server_settings[option] = bool(server_settings[option])
3044
# Debug implies foreground
3045
if server_settings["debug"]:
3046
server_settings["foreground"] = True
1782
3047
# Now we have our good server settings in "server_settings"
1784
3049
##################################################################
3051
if (not server_settings["zeroconf"]
3052
and not (server_settings["port"]
3053
or server_settings["socket"] != "")):
3054
parser.error("Needs port or socket to work without Zeroconf")
1786
3056
# For convenience
1787
3057
debug = server_settings["debug"]
1788
3058
debuglevel = server_settings["debuglevel"]
1789
3059
use_dbus = server_settings["use_dbus"]
1790
3060
use_ipv6 = server_settings["use_ipv6"]
3061
stored_state_path = os.path.join(server_settings["statedir"],
3063
foreground = server_settings["foreground"]
3064
zeroconf = server_settings["zeroconf"]
3067
initlogger(debug, logging.DEBUG)
3072
level = getattr(logging, debuglevel.upper())
3073
initlogger(debug, level)
1792
3075
if server_settings["servicename"] != "Mandos":
1793
syslogger.setFormatter(logging.Formatter
1794
('Mandos (%s) [%%(process)d]:'
1795
' %%(levelname)s: %%(message)s'
1796
% server_settings["servicename"]))
3076
syslogger.setFormatter(
3077
logging.Formatter('Mandos ({}) [%(process)d]:'
3078
' %(levelname)s: %(message)s'.format(
3079
server_settings["servicename"])))
1798
3081
# Parse config file with clients
1799
client_defaults = { "timeout": "1h",
1801
"checker": "fping -q -- %%(host)s",
1803
"approval_delay": "0s",
1804
"approval_duration": "1s",
1806
client_config = configparser.SafeConfigParser(client_defaults)
3082
client_config = configparser.SafeConfigParser(Client
1807
3084
client_config.read(os.path.join(server_settings["configdir"],
1808
3085
"clients.conf"))
1810
3087
global mandos_dbus_service
1811
3088
mandos_dbus_service = None
1813
tcp_server = MandosServer((server_settings["address"],
1814
server_settings["port"]),
1816
interface=(server_settings["interface"]
1820
server_settings["priority"],
1823
pidfilename = "/var/run/mandos.pid"
1825
pidfile = open(pidfilename, "w")
1827
logger.error("Could not open file %r", pidfilename)
1830
uid = pwd.getpwnam("_mandos").pw_uid
1831
gid = pwd.getpwnam("_mandos").pw_gid
1834
uid = pwd.getpwnam("mandos").pw_uid
1835
gid = pwd.getpwnam("mandos").pw_gid
3091
if server_settings["socket"] != "":
3092
socketfd = server_settings["socket"]
3093
tcp_server = MandosServer(
3094
(server_settings["address"], server_settings["port"]),
3096
interface=(server_settings["interface"] or None),
3098
gnutls_priority=server_settings["priority"],
3102
pidfilename = "/run/mandos.pid"
3103
if not os.path.isdir("/run/."):
3104
pidfilename = "/var/run/mandos.pid"
3107
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3108
except IOError as e:
3109
logger.error("Could not open file %r", pidfilename,
3112
for name, group in (("_mandos", "_mandos"),
3113
("mandos", "mandos"),
3114
("nobody", "nogroup")):
3116
uid = pwd.getpwnam(name).pw_uid
3117
gid = pwd.getpwnam(group).pw_gid
1836
3119
except KeyError:
1838
uid = pwd.getpwnam("nobody").pw_uid
1839
gid = pwd.getpwnam("nobody").pw_gid
3128
logger.debug("Did setuid/setgid to {}:{}".format(uid,
1846
3130
except OSError as error:
1847
if error[0] != errno.EPERM:
1850
if not debug and not debuglevel:
1851
syslogger.setLevel(logging.WARNING)
1852
console.setLevel(logging.WARNING)
1854
level = getattr(logging, debuglevel.upper())
1855
syslogger.setLevel(level)
1856
console.setLevel(level)
3131
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3132
.format(uid, gid, os.strerror(error.errno)))
3133
if error.errno != errno.EPERM:
1859
3137
# Enable all possible GnuTLS debugging
1861
3139
# "Use a log level over 10 to enable all debugging options."
1862
3140
# - GnuTLS manual
1863
gnutls.library.functions.gnutls_global_set_log_level(11)
1865
@gnutls.library.types.gnutls_log_func
3141
gnutls.global_set_log_level(11)
1866
3144
def debug_gnutls(level, string):
1867
3145
logger.debug("GnuTLS: %s", string[:-1])
1869
(gnutls.library.functions
1870
.gnutls_global_set_log_function(debug_gnutls))
3147
gnutls.global_set_log_function(debug_gnutls)
1872
3149
# Redirect stdin so all checkers get /dev/null
1873
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
3150
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1874
3151
os.dup2(null, sys.stdin.fileno())
1878
# No console logging
1879
logger.removeHandler(console)
1881
3155
# Need to fork before connecting to D-Bus
1883
3157
# Close all input and output, do double fork, etc.
3160
# multiprocessing will use threads, so before we use GLib we need
3161
# to inform GLib that threads will be used.
1886
3164
global main_loop
1887
3165
# From the Avahi example code
1888
DBusGMainLoop(set_as_default=True )
1889
main_loop = gobject.MainLoop()
3166
DBusGMainLoop(set_as_default=True)
3167
main_loop = GLib.MainLoop()
1890
3168
bus = dbus.SystemBus()
1891
3169
# End of Avahi example code
1894
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1895
bus, do_not_queue=True)
1896
except dbus.exceptions.NameExistsException as e:
1897
logger.error(unicode(e) + ", disabling D-Bus")
3172
bus_name = dbus.service.BusName("se.recompile.Mandos",
3175
old_bus_name = dbus.service.BusName(
3176
"se.bsnet.fukt.Mandos", bus,
3178
except dbus.exceptions.DBusException as e:
3179
logger.error("Disabling D-Bus:", exc_info=e)
1898
3180
use_dbus = False
1899
3181
server_settings["use_dbus"] = False
1900
3182
tcp_server.use_dbus = False
1901
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1902
service = AvahiService(name = server_settings["servicename"],
1903
servicetype = "_mandos._tcp",
1904
protocol = protocol, bus = bus)
1905
if server_settings["interface"]:
1906
service.interface = (if_nametoindex
1907
(str(server_settings["interface"])))
3184
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3185
service = AvahiServiceToSyslog(
3186
name=server_settings["servicename"],
3187
servicetype="_mandos._tcp",
3190
if server_settings["interface"]:
3191
service.interface = if_nametoindex(
3192
server_settings["interface"].encode("utf-8"))
1909
3194
global multiprocessing_manager
1910
3195
multiprocessing_manager = multiprocessing.Manager()
1912
3197
client_class = Client
1914
client_class = functools.partial(ClientDBus, bus = bus)
1915
def client_config_items(config, section):
1916
special_settings = {
1917
"approved_by_default":
1918
lambda: config.getboolean(section,
1919
"approved_by_default"),
1921
for name, value in config.items(section):
3199
client_class = functools.partial(ClientDBus, bus=bus)
3201
client_settings = Client.config_parser(client_config)
3202
old_client_settings = {}
3205
# This is used to redirect stdout and stderr for checker processes
3207
wnull = open(os.devnull, "w") # A writable /dev/null
3208
# Only used if server is running in foreground but not in debug
3210
if debug or not foreground:
3213
# Get client data and settings from last running state.
3214
if server_settings["restore"]:
3216
with open(stored_state_path, "rb") as stored_state:
3217
if sys.version_info.major == 2:
3218
clients_data, old_client_settings = pickle.load(
3221
bytes_clients_data, bytes_old_client_settings = (
3222
pickle.load(stored_state, encoding="bytes"))
3223
# Fix bytes to strings
3226
clients_data = {(key.decode("utf-8")
3227
if isinstance(key, bytes)
3230
bytes_clients_data.items()}
3231
del bytes_clients_data
3232
for key in clients_data:
3233
value = {(k.decode("utf-8")
3234
if isinstance(k, bytes) else k): v
3236
clients_data[key].items()}
3237
clients_data[key] = value
3239
value["client_structure"] = [
3241
if isinstance(s, bytes)
3243
value["client_structure"]]
3245
for k in ("name", "host"):
3246
if isinstance(value[k], bytes):
3247
value[k] = value[k].decode("utf-8")
3248
if "key_id" not in value:
3249
value["key_id"] = ""
3250
elif "fingerprint" not in value:
3251
value["fingerprint"] = ""
3252
# old_client_settings
3254
old_client_settings = {
3255
(key.decode("utf-8")
3256
if isinstance(key, bytes)
3259
bytes_old_client_settings.items()}
3260
del bytes_old_client_settings
3262
for value in old_client_settings.values():
3263
if isinstance(value["host"], bytes):
3264
value["host"] = (value["host"]
3266
os.remove(stored_state_path)
3267
except IOError as e:
3268
if e.errno == errno.ENOENT:
3269
logger.warning("Could not load persistent state:"
3270
" {}".format(os.strerror(e.errno)))
3272
logger.critical("Could not load persistent state:",
3275
except EOFError as e:
3276
logger.warning("Could not load persistent state: "
3280
with PGPEngine() as pgp:
3281
for client_name, client in clients_data.items():
3282
# Skip removed clients
3283
if client_name not in client_settings:
3286
# Decide which value to use after restoring saved state.
3287
# We have three different values: Old config file,
3288
# new config file, and saved state.
3289
# New config value takes precedence if it differs from old
3290
# config value, otherwise use saved state.
3291
for name, value in client_settings[client_name].items():
3293
# For each value in new config, check if it
3294
# differs from the old config value (Except for
3295
# the "secret" attribute)
3296
if (name != "secret"
3298
old_client_settings[client_name][name])):
3299
client[name] = value
3303
# Clients who has passed its expire date can still be
3304
# enabled if its last checker was successful. A Client
3305
# whose checker succeeded before we stored its state is
3306
# assumed to have successfully run all checkers during
3308
if client["enabled"]:
3309
if datetime.datetime.utcnow() >= client["expires"]:
3310
if not client["last_checked_ok"]:
3312
"disabling client {} - Client never "
3313
"performed a successful checker".format(
3315
client["enabled"] = False
3316
elif client["last_checker_status"] != 0:
3318
"disabling client {} - Client last"
3319
" checker failed with error code"
3322
client["last_checker_status"]))
3323
client["enabled"] = False
3325
client["expires"] = (
3326
datetime.datetime.utcnow()
3327
+ client["timeout"])
3328
logger.debug("Last checker succeeded,"
3329
" keeping {} enabled".format(
1923
yield (name, special_settings[name]())
1927
tcp_server.clients.update(set(
1928
client_class(name = section,
1929
config= dict(client_config_items(
1930
client_config, section)))
1931
for section in client_config.sections()))
3332
client["secret"] = pgp.decrypt(
3333
client["encrypted_secret"],
3334
client_settings[client_name]["secret"])
3336
# If decryption fails, we use secret from new settings
3337
logger.debug("Failed to decrypt {} old secret".format(
3339
client["secret"] = (client_settings[client_name]
3342
# Add/remove clients based on new changes made to config
3343
for client_name in (set(old_client_settings)
3344
- set(client_settings)):
3345
del clients_data[client_name]
3346
for client_name in (set(client_settings)
3347
- set(old_client_settings)):
3348
clients_data[client_name] = client_settings[client_name]
3350
# Create all client objects
3351
for client_name, client in clients_data.items():
3352
tcp_server.clients[client_name] = client_class(
3355
server_settings=server_settings)
1932
3357
if not tcp_server.clients:
1933
3358
logger.warning("No clients defined")
1939
pidfile.write(str(pid) + "\n".encode("utf-8"))
1942
logger.error("Could not write to file %r with PID %d",
1945
# "pidfile" was never created
3361
if pidfile is not None:
3365
print(pid, file=pidfile)
3367
logger.error("Could not write to file %r with PID %d",
1947
3370
del pidfilename
1949
signal.signal(signal.SIGINT, signal.SIG_IGN)
1951
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1952
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3372
for termsig in (signal.SIGHUP, signal.SIGTERM):
3373
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3374
lambda: main_loop.quit() and False)
1955
class MandosDBusService(dbus.service.Object):
3378
@alternate_dbus_interfaces(
3379
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3380
class MandosDBusService(DBusObjectWithObjectManager):
1956
3381
"""A D-Bus proxy object"""
1957
3383
def __init__(self):
1958
3384
dbus.service.Object.__init__(self, bus, "/")
1959
_interface = "se.bsnet.fukt.Mandos"
3386
_interface = "se.recompile.Mandos"
1961
3388
@dbus.service.signal(_interface, signature="o")
1962
3389
def ClientAdded(self, objpath):
1966
3393
@dbus.service.signal(_interface, signature="ss")
1967
def ClientNotFound(self, fingerprint, address):
3394
def ClientNotFound(self, key_id, address):
3398
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
1971
3400
@dbus.service.signal(_interface, signature="os")
1972
3401
def ClientRemoved(self, objpath, name):
3405
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
1976
3407
@dbus.service.method(_interface, out_signature="ao")
1977
3408
def GetAllClients(self):
1979
return dbus.Array(c.dbus_object_path
1980
for c in tcp_server.clients)
3410
return dbus.Array(c.dbus_object_path for c in
3411
tcp_server.clients.values())
3413
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
1982
3415
@dbus.service.method(_interface,
1983
3416
out_signature="a{oa{sv}}")
1984
3417
def GetAllClientsWithProperties(self):
1986
3419
return dbus.Dictionary(
1987
((c.dbus_object_path, c.GetAll(""))
1988
for c in tcp_server.clients),
3420
{c.dbus_object_path: c.GetAll(
3421
"se.recompile.Mandos.Client")
3422
for c in tcp_server.clients.values()},
1989
3423
signature="oa{sv}")
1991
3425
@dbus.service.method(_interface, in_signature="o")
1992
3426
def RemoveClient(self, object_path):
1994
for c in tcp_server.clients:
3428
for c in tcp_server.clients.values():
1995
3429
if c.dbus_object_path == object_path:
1996
tcp_server.clients.remove(c)
3430
del tcp_server.clients[c.name]
1997
3431
c.remove_from_connection()
1998
# Don't signal anything except ClientRemoved
3432
# Don't signal the disabling
1999
3433
c.disable(quiet=True)
2001
self.ClientRemoved(object_path, c.name)
3434
# Emit D-Bus signal for removal
3435
self.client_removed_signal(c)
2003
3437
raise KeyError(object_path)
3441
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3442
out_signature="a{oa{sa{sv}}}")
3443
def GetManagedObjects(self):
3445
return dbus.Dictionary(
3446
{client.dbus_object_path:
3448
{interface: client.GetAll(interface)
3450
client._get_all_interface_names()})
3451
for client in tcp_server.clients.values()})
3453
def client_added_signal(self, client):
3454
"""Send the new standard signal and the old signal"""
3456
# New standard signal
3457
self.InterfacesAdded(
3458
client.dbus_object_path,
3460
{interface: client.GetAll(interface)
3462
client._get_all_interface_names()}))
3464
self.ClientAdded(client.dbus_object_path)
3466
def client_removed_signal(self, client):
3467
"""Send the new standard signal and the old signal"""
3469
# New standard signal
3470
self.InterfacesRemoved(
3471
client.dbus_object_path,
3472
client._get_all_interface_names())
3474
self.ClientRemoved(client.dbus_object_path,
2007
3477
mandos_dbus_service = MandosDBusService()
3479
# Save modules to variables to exempt the modules from being
3480
# unloaded before the function registered with atexit() is run.
3481
mp = multiprocessing
2010
3485
"Cleanup function; run on exit"
3489
mp.active_children()
3491
if not (tcp_server.clients or client_settings):
3494
# Store client before exiting. Secrets are encrypted with key
3495
# based on what config file has. If config file is
3496
# removed/edited, old secret will thus be unrecovable.
3498
with PGPEngine() as pgp:
3499
for client in tcp_server.clients.values():
3500
key = client_settings[client.name]["secret"]
3501
client.encrypted_secret = pgp.encrypt(client.secret,
3505
# A list of attributes that can not be pickled
3507
exclude = {"bus", "changedstate", "secret",
3508
"checker", "server_settings"}
3509
for name, typ in inspect.getmembers(dbus.service
3513
client_dict["encrypted_secret"] = (client
3515
for attr in client.client_structure:
3516
if attr not in exclude:
3517
client_dict[attr] = getattr(client, attr)
3519
clients[client.name] = client_dict
3520
del client_settings[client.name]["secret"]
3523
with tempfile.NamedTemporaryFile(
3527
dir=os.path.dirname(stored_state_path),
3528
delete=False) as stored_state:
3529
pickle.dump((clients, client_settings), stored_state,
3531
tempname = stored_state.name
3532
os.rename(tempname, stored_state_path)
3533
except (IOError, OSError) as e:
3539
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3540
logger.warning("Could not save persistent state: {}"
3541
.format(os.strerror(e.errno)))
3543
logger.warning("Could not save persistent state:",
3547
# Delete all clients, and settings from config
2013
3548
while tcp_server.clients:
2014
client = tcp_server.clients.pop()
3549
name, client = tcp_server.clients.popitem()
2016
3551
client.remove_from_connection()
2017
client.disable_hook = None
2018
# Don't signal anything except ClientRemoved
3552
# Don't signal the disabling
2019
3553
client.disable(quiet=True)
3554
# Emit D-Bus signal for removal
2022
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
3556
mandos_dbus_service.client_removed_signal(client)
3557
client_settings.clear()
2025
3559
atexit.register(cleanup)
2027
for client in tcp_server.clients:
3561
for client in tcp_server.clients.values():
2030
mandos_dbus_service.ClientAdded(client.dbus_object_path)
3563
# Emit D-Bus signal for adding
3564
mandos_dbus_service.client_added_signal(client)
3565
# Need to initiate checking of clients
3567
client.init_checker()
2033
3569
tcp_server.enable()
2034
3570
tcp_server.server_activate()
2036
3572
# Find out what port we got
2037
service.port = tcp_server.socket.getsockname()[1]
3574
service.port = tcp_server.socket.getsockname()[1]
2039
3576
logger.info("Now listening on address %r, port %d,"
2040
" flowinfo %d, scope_id %d"
2041
% tcp_server.socket.getsockname())
3577
" flowinfo %d, scope_id %d",
3578
*tcp_server.socket.getsockname())
2043
logger.info("Now listening on address %r, port %d"
2044
% tcp_server.socket.getsockname())
2046
#service.interface = tcp_server.socket.getsockname()[3]
3580
logger.info("Now listening on address %r, port %d",
3581
*tcp_server.socket.getsockname())
3583
# service.interface = tcp_server.socket.getsockname()[3]
2049
# From the Avahi example code
2052
except dbus.exceptions.DBusException as error:
2053
logger.critical("DBusException: %s", error)
2056
# End of Avahi example code
2058
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2059
lambda *args, **kwargs:
2060
(tcp_server.handle_request
2061
(*args[2:], **kwargs) or True))
3587
# From the Avahi example code
3590
except dbus.exceptions.DBusException as error:
3591
logger.critical("D-Bus Exception", exc_info=error)
3594
# End of Avahi example code
3596
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3597
lambda *args, **kwargs:
3598
(tcp_server.handle_request
3599
(*args[2:], **kwargs) or True))
2063
3601
logger.debug("Starting main loop")
2064
3602
main_loop.run()
2065
3603
except AvahiError as error:
2066
logger.critical("AvahiError: %s", error)
3604
logger.critical("Avahi Error", exc_info=error)
2069
3607
except KeyboardInterrupt: