2
# -*- coding: utf-8; lexical-binding: t -*-
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos server - give out binary blobs to connecting clients.
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
9
# methods "add", "remove", "server_state_changed",
10
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
11
# "AvahiService" class, and some lines in "main".
13
13
# Everything else is
14
# Copyright © 2008-2022 Teddy Hogeborn
15
# Copyright © 2008-2022 Björn Påhlsson
17
# This file is part of Mandos.
19
# Mandos is free software: you can redistribute it and/or modify it
20
# under the terms of the GNU General Public License as published by
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
17
# This program is free software: you can redistribute it and/or modify
18
# it under the terms of the GNU General Public License as published by
21
19
# the Free Software Foundation, either version 3 of the License, or
22
20
# (at your option) any later version.
24
# Mandos is distributed in the hope that it will be useful, but
25
# WITHOUT ANY WARRANTY; without even the implied warranty of
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
26
24
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27
25
# GNU General Public License for more details.
29
27
# You should have received a copy of the GNU General Public License
30
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
32
# Contact the authors at <mandos@recompile.se>.
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
31
# Contact the authors at <mandos@fukt.bsnet.se>.
34
34
from __future__ import (division, absolute_import, print_function,
38
from future_builtins import *
37
import SocketServer as socketserver
48
import SocketServer as socketserver
55
import ConfigParser as configparser
43
import gnutls.connection
45
import gnutls.library.functions
46
import gnutls.library.constants
47
import gnutls.library.types
48
import ConfigParser as configparser
63
57
import logging.handlers
70
import cPickle as pickle
63
import cPickle as pickle
73
64
import multiprocessing
84
67
import dbus.service
86
from gi.repository import GLib
87
70
from dbus.mainloop.glib import DBusGMainLoop
90
73
import xml.dom.minidom
93
if sys.version_info.major == 2:
98
# Add collections.abc.Callable if it does not exist
100
collections.abc.Callable
101
except AttributeError:
103
Callable = collections.Callable
104
collections.abc = abc
107
# Add shlex.quote if it does not exist
110
except AttributeError:
111
shlex.quote = re.escape
113
# Show warnings by default
114
if not sys.warnoptions:
116
warnings.simplefilter("default")
118
# Try to find the value of SO_BINDTODEVICE:
120
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
121
# newer, and it is also the most natural place for it:
122
77
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
123
78
except AttributeError:
125
# This is where SO_BINDTODEVICE was up to and including Python
127
80
from IN import SO_BINDTODEVICE
128
81
except ImportError:
129
# In Python 2.7 it seems to have been removed entirely.
130
# Try running the C preprocessor:
132
cc = subprocess.Popen(["cc", "--language=c", "-E",
134
stdin=subprocess.PIPE,
135
stdout=subprocess.PIPE)
136
stdout = cc.communicate(
137
"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
138
SO_BINDTODEVICE = int(stdout.splitlines()[-1])
139
except (OSError, ValueError, IndexError):
141
SO_BINDTODEVICE = None
143
if sys.version_info < (3, 2):
144
configparser.Configparser = configparser.SafeConfigParser
147
stored_state_file = "clients.pickle"
149
log = logging.getLogger(os.path.basename(sys.argv[0]))
150
logging.captureWarnings(True) # Show warnings via the logging system
154
if_nametoindex = ctypes.cdll.LoadLibrary(
155
ctypes.util.find_library("c")).if_nametoindex
156
except (OSError, AttributeError):
158
def if_nametoindex(interface):
159
"Get an interface index the hard way, i.e. using fcntl()"
160
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
161
with contextlib.closing(socket.socket()) as s:
162
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
163
struct.pack(b"16s16x", interface))
164
interface_index = struct.unpack("I", ifreq[16:20])[0]
165
return interface_index
168
def copy_function(func):
169
"""Make a copy of a function"""
170
if sys.version_info.major == 2:
171
return types.FunctionType(func.func_code,
177
return types.FunctionType(func.__code__,
184
def initlogger(debug, level=logging.WARNING):
185
"""init logger and add loglevel"""
188
syslogger = (logging.handlers.SysLogHandler(
189
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
191
syslogger.setFormatter(logging.Formatter
192
("Mandos [%(process)d]: %(levelname)s:"
194
log.addHandler(syslogger)
197
console = logging.StreamHandler()
198
console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
202
log.addHandler(console)
206
class PGPError(Exception):
207
"""Exception if encryption/decryption fails"""
212
"""A simple class for OpenPGP symmetric encryption & decryption"""
215
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
218
output = subprocess.check_output(["gpgconf"])
219
for line in output.splitlines():
220
name, text, path = line.split(b":")
225
if e.errno != errno.ENOENT:
227
self.gnupgargs = ["--batch",
228
"--homedir", self.tempdir,
231
# Only GPG version 1 has the --no-use-agent option.
232
if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
233
self.gnupgargs.append("--no-use-agent")
238
def __exit__(self, exc_type, exc_value, traceback):
246
if self.tempdir is not None:
247
# Delete contents of tempdir
248
for root, dirs, files in os.walk(self.tempdir,
250
for filename in files:
251
os.remove(os.path.join(root, filename))
253
os.rmdir(os.path.join(root, dirname))
255
os.rmdir(self.tempdir)
258
def password_encode(self, password):
259
# Passphrase can not be empty and can not contain newlines or
260
# NUL bytes. So we prefix it and hex encode it.
261
encoded = b"mandos" + binascii.hexlify(password)
262
if len(encoded) > 2048:
263
# GnuPG can't handle long passwords, so encode differently
264
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
265
.replace(b"\n", b"\\n")
266
.replace(b"\0", b"\\x00"))
269
def encrypt(self, data, password):
270
passphrase = self.password_encode(password)
271
with tempfile.NamedTemporaryFile(
272
dir=self.tempdir) as passfile:
273
passfile.write(passphrase)
275
proc = subprocess.Popen([self.gpg, "--symmetric",
279
stdin=subprocess.PIPE,
280
stdout=subprocess.PIPE,
281
stderr=subprocess.PIPE)
282
ciphertext, err = proc.communicate(input=data)
283
if proc.returncode != 0:
287
def decrypt(self, data, password):
288
passphrase = self.password_encode(password)
289
with tempfile.NamedTemporaryFile(
290
dir=self.tempdir) as passfile:
291
passfile.write(passphrase)
293
proc = subprocess.Popen([self.gpg, "--decrypt",
297
stdin=subprocess.PIPE,
298
stdout=subprocess.PIPE,
299
stderr=subprocess.PIPE)
300
decrypted_plaintext, err = proc.communicate(input=data)
301
if proc.returncode != 0:
303
return decrypted_plaintext
306
# Pretend that we have an Avahi module
308
"""This isn't so much a class as it is a module-like namespace."""
309
IF_UNSPEC = -1 # avahi-common/address.h
310
PROTO_UNSPEC = -1 # avahi-common/address.h
311
PROTO_INET = 0 # avahi-common/address.h
312
PROTO_INET6 = 1 # avahi-common/address.h
313
DBUS_NAME = "org.freedesktop.Avahi"
314
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
315
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
316
DBUS_PATH_SERVER = "/"
319
def string_array_to_txt_array(t):
320
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
321
for s in t), signature="ay")
322
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
323
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
324
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
325
SERVER_INVALID = 0 # avahi-common/defs.h
326
SERVER_REGISTERING = 1 # avahi-common/defs.h
327
SERVER_RUNNING = 2 # avahi-common/defs.h
328
SERVER_COLLISION = 3 # avahi-common/defs.h
329
SERVER_FAILURE = 4 # avahi-common/defs.h
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)
332
103
class AvahiError(Exception):
333
104
def __init__(self, value, *args, **kwargs):
334
105
self.value = value
335
return super(AvahiError, self).__init__(value, *args,
106
super(AvahiError, self).__init__(value, *args, **kwargs)
107
def __unicode__(self):
108
return unicode(repr(self.value))
339
110
class AvahiServiceError(AvahiError):
343
113
class AvahiGroupError(AvahiError):
117
class AvahiService(object):
348
118
"""An Avahi (Zeroconf) service.
351
121
interface: integer; avahi.IF_UNSPEC or an interface index.
352
122
Used to optionally bind to the specified interface.
353
name: string; Example: "Mandos"
354
type: string; Example: "_mandos._tcp".
355
See <https://www.iana.org/assignments/service-names-port-numbers>
123
name: string; Example: 'Mandos'
124
type: string; Example: '_mandos._tcp'.
125
See <http://www.dns-sd.org/ServiceTypes.html>
356
126
port: integer; what port to announce
357
127
TXT: list of strings; TXT record for the service
358
128
domain: string; Domain to publish on, default to .local if empty.
516
260
follow_name_owner_changes=True),
517
261
avahi.DBUS_INTERFACE_SERVER)
518
262
self.server.connect_to_signal("StateChanged",
519
self.server_state_changed)
263
self.server_state_changed)
520
264
self.server_state_changed(self.server.GetState())
523
class AvahiServiceToSyslog(AvahiService):
524
def rename(self, *args, **kwargs):
525
"""Add the new name to the syslog messages"""
526
ret = super(AvahiServiceToSyslog, self).rename(*args,
528
syslogger.setFormatter(logging.Formatter(
529
"Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
534
# Pretend that we have a GnuTLS module
536
"""This isn't so much a class as it is a module-like namespace."""
538
library = ctypes.util.find_library("gnutls")
540
library = ctypes.util.find_library("gnutls-deb0")
541
_library = ctypes.cdll.LoadLibrary(library)
544
# Unless otherwise indicated, the constants and types below are
545
# all from the gnutls/gnutls.h C header file.
556
E_NO_CERTIFICATE_FOUND = -49
561
KEYID_USE_SHA256 = 1 # gnutls/x509.h
562
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
565
class _session_int(ctypes.Structure):
567
session_t = ctypes.POINTER(_session_int)
569
class certificate_credentials_st(ctypes.Structure):
571
certificate_credentials_t = ctypes.POINTER(
572
certificate_credentials_st)
573
certificate_type_t = ctypes.c_int
575
class datum_t(ctypes.Structure):
576
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
577
("size", ctypes.c_uint)]
579
class _openpgp_crt_int(ctypes.Structure):
581
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
582
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
583
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
584
credentials_type_t = ctypes.c_int
585
transport_ptr_t = ctypes.c_void_p
586
close_request_t = ctypes.c_int
589
class Error(Exception):
590
def __init__(self, message=None, code=None, args=()):
591
# Default usage is by a message string, but if a return
592
# code is passed, convert it to a string with
595
if message is None and code is not None:
596
message = gnutls.strerror(code).decode(
597
"utf-8", errors="replace")
598
return super(gnutls.Error, self).__init__(
601
class CertificateSecurityError(Error):
605
def __init__(self, cls):
608
def from_param(self, obj):
609
if not isinstance(obj, self.cls):
610
raise TypeError("Not of type {}: {!r}"
611
.format(self.cls.__name__, obj))
612
return ctypes.byref(obj.from_param(obj))
614
class CastToVoidPointer:
615
def __init__(self, cls):
618
def from_param(self, obj):
619
if not isinstance(obj, self.cls):
620
raise TypeError("Not of type {}: {!r}"
621
.format(self.cls.__name__, obj))
622
return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
624
class With_from_param:
626
def from_param(cls, obj):
627
return obj._as_parameter_
630
class Credentials(With_from_param):
632
self._as_parameter_ = gnutls.certificate_credentials_t()
633
gnutls.certificate_allocate_credentials(self)
634
self.type = gnutls.CRD_CERTIFICATE
637
gnutls.certificate_free_credentials(self)
639
class ClientSession(With_from_param):
640
def __init__(self, socket, credentials=None):
641
self._as_parameter_ = gnutls.session_t()
642
gnutls_flags = gnutls.CLIENT
643
if gnutls.check_version(b"3.5.6"):
644
gnutls_flags |= gnutls.NO_TICKETS
646
gnutls_flags |= gnutls.ENABLE_RAWPK
647
gnutls.init(self, gnutls_flags)
649
gnutls.set_default_priority(self)
650
gnutls.transport_set_ptr(self, socket.fileno())
651
gnutls.handshake_set_private_extensions(self, True)
653
if credentials is None:
654
credentials = gnutls.Credentials()
655
gnutls.credentials_set(self, credentials.type,
657
self.credentials = credentials
663
return gnutls.handshake(self)
665
def send(self, data):
669
data_len -= gnutls.record_send(self, data[-data_len:],
673
return gnutls.bye(self, gnutls.SHUT_RDWR)
675
# Error handling functions
676
def _error_code(result):
677
"""A function to raise exceptions on errors, suitable
678
for the "restype" attribute on ctypes functions"""
679
if result >= gnutls.E_SUCCESS:
681
if result == gnutls.E_NO_CERTIFICATE_FOUND:
682
raise gnutls.CertificateSecurityError(code=result)
683
raise gnutls.Error(code=result)
685
def _retry_on_error(result, func, arguments,
686
_error_code=_error_code):
687
"""A function to retry on some errors, suitable
688
for the "errcheck" attribute on ctypes functions"""
689
while result < gnutls.E_SUCCESS:
690
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
691
return _error_code(result)
692
result = func(*arguments)
695
# Unless otherwise indicated, the function declarations below are
696
# all from the gnutls/gnutls.h C header file.
699
priority_set_direct = _library.gnutls_priority_set_direct
700
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
701
ctypes.POINTER(ctypes.c_char_p)]
702
priority_set_direct.restype = _error_code
704
init = _library.gnutls_init
705
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
706
init.restype = _error_code
708
set_default_priority = _library.gnutls_set_default_priority
709
set_default_priority.argtypes = [ClientSession]
710
set_default_priority.restype = _error_code
712
record_send = _library.gnutls_record_send
713
record_send.argtypes = [ClientSession, ctypes.c_void_p,
715
record_send.restype = ctypes.c_ssize_t
716
record_send.errcheck = _retry_on_error
718
certificate_allocate_credentials = (
719
_library.gnutls_certificate_allocate_credentials)
720
certificate_allocate_credentials.argtypes = [
721
PointerTo(Credentials)]
722
certificate_allocate_credentials.restype = _error_code
724
certificate_free_credentials = (
725
_library.gnutls_certificate_free_credentials)
726
certificate_free_credentials.argtypes = [Credentials]
727
certificate_free_credentials.restype = None
729
handshake_set_private_extensions = (
730
_library.gnutls_handshake_set_private_extensions)
731
handshake_set_private_extensions.argtypes = [ClientSession,
733
handshake_set_private_extensions.restype = None
735
credentials_set = _library.gnutls_credentials_set
736
credentials_set.argtypes = [ClientSession, credentials_type_t,
737
CastToVoidPointer(Credentials)]
738
credentials_set.restype = _error_code
740
strerror = _library.gnutls_strerror
741
strerror.argtypes = [ctypes.c_int]
742
strerror.restype = ctypes.c_char_p
744
certificate_type_get = _library.gnutls_certificate_type_get
745
certificate_type_get.argtypes = [ClientSession]
746
certificate_type_get.restype = _error_code
748
certificate_get_peers = _library.gnutls_certificate_get_peers
749
certificate_get_peers.argtypes = [ClientSession,
750
ctypes.POINTER(ctypes.c_uint)]
751
certificate_get_peers.restype = ctypes.POINTER(datum_t)
753
global_set_log_level = _library.gnutls_global_set_log_level
754
global_set_log_level.argtypes = [ctypes.c_int]
755
global_set_log_level.restype = None
757
global_set_log_function = _library.gnutls_global_set_log_function
758
global_set_log_function.argtypes = [log_func]
759
global_set_log_function.restype = None
761
deinit = _library.gnutls_deinit
762
deinit.argtypes = [ClientSession]
763
deinit.restype = None
765
handshake = _library.gnutls_handshake
766
handshake.argtypes = [ClientSession]
767
handshake.restype = ctypes.c_int
768
handshake.errcheck = _retry_on_error
770
transport_set_ptr = _library.gnutls_transport_set_ptr
771
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
772
transport_set_ptr.restype = None
774
bye = _library.gnutls_bye
775
bye.argtypes = [ClientSession, close_request_t]
776
bye.restype = ctypes.c_int
777
bye.errcheck = _retry_on_error
779
check_version = _library.gnutls_check_version
780
check_version.argtypes = [ctypes.c_char_p]
781
check_version.restype = ctypes.c_char_p
783
_need_version = b"3.3.0"
784
if check_version(_need_version) is None:
785
raise self.Error("Needs GnuTLS {} or later"
786
.format(_need_version))
788
_tls_rawpk_version = b"3.6.6"
789
has_rawpk = bool(check_version(_tls_rawpk_version))
793
class pubkey_st(ctypes.Structure):
795
pubkey_t = ctypes.POINTER(pubkey_st)
797
x509_crt_fmt_t = ctypes.c_int
799
# All the function declarations below are from
801
pubkey_init = _library.gnutls_pubkey_init
802
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
803
pubkey_init.restype = _error_code
805
pubkey_import = _library.gnutls_pubkey_import
806
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
808
pubkey_import.restype = _error_code
810
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
811
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
812
ctypes.POINTER(ctypes.c_ubyte),
813
ctypes.POINTER(ctypes.c_size_t)]
814
pubkey_get_key_id.restype = _error_code
816
pubkey_deinit = _library.gnutls_pubkey_deinit
817
pubkey_deinit.argtypes = [pubkey_t]
818
pubkey_deinit.restype = None
820
# All the function declarations below are from
823
openpgp_crt_init = _library.gnutls_openpgp_crt_init
824
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
825
openpgp_crt_init.restype = _error_code
827
openpgp_crt_import = _library.gnutls_openpgp_crt_import
828
openpgp_crt_import.argtypes = [openpgp_crt_t,
829
ctypes.POINTER(datum_t),
831
openpgp_crt_import.restype = _error_code
833
openpgp_crt_verify_self = \
834
_library.gnutls_openpgp_crt_verify_self
835
openpgp_crt_verify_self.argtypes = [
838
ctypes.POINTER(ctypes.c_uint),
840
openpgp_crt_verify_self.restype = _error_code
842
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
843
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
844
openpgp_crt_deinit.restype = None
846
openpgp_crt_get_fingerprint = (
847
_library.gnutls_openpgp_crt_get_fingerprint)
848
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
852
openpgp_crt_get_fingerprint.restype = _error_code
854
if check_version(b"3.6.4"):
855
certificate_type_get2 = _library.gnutls_certificate_type_get2
856
certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
857
certificate_type_get2.restype = _error_code
859
# Remove non-public functions
860
del _error_code, _retry_on_error
863
def call_pipe(connection, # : multiprocessing.Connection
864
func, *args, **kwargs):
865
"""This function is meant to be called by multiprocessing.Process
867
This function runs func(*args, **kwargs), and writes the resulting
868
return value on the provided multiprocessing.Connection.
870
connection.send(func(*args, **kwargs))
267
class Client(object):
875
268
"""A representation of a client host served by this server.
878
approved: bool(); None if not yet approved/disapproved
271
_approved: bool(); 'None' if not yet approved/disapproved
879
272
approval_delay: datetime.timedelta(); Time to wait for approval
880
273
approval_duration: datetime.timedelta(); Duration of one approval
881
checker: multiprocessing.Process(); a running checker process used
882
to see if the client lives. None if no process is
884
checker_callback_tag: a GLib event source tag, or None
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
885
278
checker_command: string; External command which is run to check
886
279
if client lives. %() expansions are done at
887
280
runtime with vars(self) as dict, so that for
888
281
instance %(name)s can be used in the command.
889
checker_initiator_tag: a GLib event source tag, or None
282
checker_initiator_tag: a gobject event source tag, or None
890
283
created: datetime.datetime(); (UTC) object creation
891
client_structure: Object describing what attributes a client has
892
and is used for storing the client at exit
893
284
current_checker_command: string; current running checker_command
894
disable_initiator_tag: a GLib event source tag, or None
285
disable_hook: If set, called by disable() as disable_hook(self)
286
disable_initiator_tag: a gobject event source tag, or None
896
288
fingerprint: string (40 or 32 hexadecimal digits); used to
897
uniquely identify an OpenPGP client
898
key_id: string (64 hexadecimal digits); used to uniquely identify
899
a client using raw public keys
289
uniquely identify the client
900
290
host: string; available for use by the checker command
901
291
interval: datetime.timedelta(); How often to start a new checker
902
292
last_approval_request: datetime.datetime(); (UTC) or None
903
293
last_checked_ok: datetime.datetime(); (UTC) or None
904
last_checker_status: integer between 0 and 255 reflecting exit
905
status of last checker. -1 reflects crashed
906
checker, -2 means no checker completed yet.
907
last_checker_signal: The signal which killed the last checker, if
908
last_checker_status is -1
909
last_enabled: datetime.datetime(); (UTC) or None
294
last_enabled: datetime.datetime(); (UTC)
910
295
name: string; from the config file, used in log messages and
911
296
D-Bus identifiers
912
297
secret: bytestring; sent verbatim (over TLS) to client
913
298
timeout: datetime.timedelta(); How long from last_checked_ok
914
299
until this client is disabled
915
extended_timeout: extra long timeout when secret has been sent
300
extended_timeout: extra long timeout when password has been sent
916
301
runtime_expansions: Allowed attributes for runtime expansion.
917
302
expires: datetime.datetime(); time (UTC) when a client will be
918
303
disabled, or None
919
server_settings: The server_settings dict from main()
922
306
runtime_expansions = ("approval_delay", "approval_duration",
923
"created", "enabled", "expires", "key_id",
924
"fingerprint", "host", "interval",
925
"last_approval_request", "last_checked_ok",
307
"created", "enabled", "fingerprint",
308
"host", "interval", "last_checked_ok",
926
309
"last_enabled", "name", "timeout")
929
"extended_timeout": "PT15M",
931
"checker": "fping -q -- %%(host)s",
933
"approval_delay": "PT0S",
934
"approval_duration": "PT1S",
935
"approved_by_default": "True",
940
def config_parser(config):
941
"""Construct a new dict of client settings of this form:
942
{ client_name: {setting_name: value, ...}, ...}
943
with exceptions for any special settings as defined above.
944
NOTE: Must be a pure function. Must return the same result
945
value given the same arguments.
948
for client_name in config.sections():
949
section = dict(config.items(client_name))
950
client = settings[client_name] = {}
952
client["host"] = section["host"]
953
# Reformat values from string types to Python types
954
client["approved_by_default"] = config.getboolean(
955
client_name, "approved_by_default")
956
client["enabled"] = config.getboolean(client_name,
959
# Uppercase and remove spaces from key_id and fingerprint
960
# for later comparison purposes with return value from the
961
# key_id() and fingerprint() functions
962
client["key_id"] = (section.get("key_id", "").upper()
964
client["fingerprint"] = (section.get("fingerprint",
967
if not (client["key_id"] or client["fingerprint"]):
968
log.error("Skipping client %s without key_id or"
969
" fingerprint", client_name)
970
del settings[client_name]
972
if "secret" in section:
973
client["secret"] = codecs.decode(section["secret"]
976
elif "secfile" in section:
977
with open(os.path.expanduser(os.path.expandvars
978
(section["secfile"])),
980
client["secret"] = secfile.read()
982
raise TypeError("No secret or secfile for section {}"
984
client["timeout"] = string_to_delta(section["timeout"])
985
client["extended_timeout"] = string_to_delta(
986
section["extended_timeout"])
987
client["interval"] = string_to_delta(section["interval"])
988
client["approval_delay"] = string_to_delta(
989
section["approval_delay"])
990
client["approval_duration"] = string_to_delta(
991
section["approval_duration"])
992
client["checker_command"] = section["checker"]
993
client["last_approval_request"] = None
994
client["last_checked_ok"] = None
995
client["last_checker_status"] = -2
999
def __init__(self, settings, name=None, server_settings=None):
312
def _timedelta_to_milliseconds(td):
313
"Convert a datetime.timedelta() to milliseconds"
314
return ((td.days * 24 * 60 * 60 * 1000)
315
+ (td.seconds * 1000)
316
+ (td.microseconds // 1000))
318
def timeout_milliseconds(self):
319
"Return the 'timeout' attribute in milliseconds"
320
return self._timedelta_to_milliseconds(self.timeout)
322
def extended_timeout_milliseconds(self):
323
"Return the 'extended_timeout' attribute in milliseconds"
324
return self._timedelta_to_milliseconds(self.extended_timeout)
326
def interval_milliseconds(self):
327
"Return the 'interval' attribute in milliseconds"
328
return self._timedelta_to_milliseconds(self.interval)
330
def approval_delay_milliseconds(self):
331
return self._timedelta_to_milliseconds(self.approval_delay)
333
def __init__(self, name = None, disable_hook=None, config=None):
334
"""Note: the 'checker' key in 'config' sets the
335
'checker_command' attribute and *not* the 'checker'
1000
337
self.name = name
1001
if server_settings is None:
1002
server_settings = {}
1003
self.server_settings = server_settings
1004
# adding all client settings
1005
for setting, value in settings.items():
1006
setattr(self, setting, value)
1009
if not hasattr(self, "last_enabled"):
1010
self.last_enabled = datetime.datetime.utcnow()
1011
if not hasattr(self, "expires"):
1012
self.expires = (datetime.datetime.utcnow()
340
logger.debug("Creating client %r", self.name)
341
# Uppercase and remove spaces from fingerprint for later
342
# comparison purposes with return value from the fingerprint()
344
self.fingerprint = (config["fingerprint"].upper()
346
logger.debug(" Fingerprint: %s", self.fingerprint)
347
if "secret" in config:
348
self.secret = config["secret"].decode("base64")
349
elif "secfile" in config:
350
with open(os.path.expanduser(os.path.expandvars
351
(config["secfile"])),
353
self.secret = secfile.read()
1015
self.last_enabled = None
1018
log.debug("Creating client %r", self.name)
1019
log.debug(" Key ID: %s", self.key_id)
1020
log.debug(" Fingerprint: %s", self.fingerprint)
1021
self.created = settings.get("created",
1022
datetime.datetime.utcnow())
1024
# attributes specific for this server instance
355
raise TypeError("No secret or secfile for client %s"
357
self.host = config.get("host", "")
358
self.created = datetime.datetime.utcnow()
360
self.last_approval_request = None
361
self.last_enabled = None
362
self.last_checked_ok = None
363
self.timeout = string_to_delta(config["timeout"])
364
self.extended_timeout = string_to_delta(config["extended_timeout"])
365
self.interval = string_to_delta(config["interval"])
366
self.disable_hook = disable_hook
1025
367
self.checker = None
1026
368
self.checker_initiator_tag = None
1027
369
self.disable_initiator_tag = None
1028
371
self.checker_callback_tag = None
372
self.checker_command = config["checker"]
1029
373
self.current_checker_command = None
1030
self.approved = None
374
self.last_connect = None
375
self._approved = None
376
self.approved_by_default = config.get("approved_by_default",
1031
378
self.approvals_pending = 0
1032
self.changedstate = multiprocessing_manager.Condition(
1033
multiprocessing_manager.Lock())
1034
self.client_structure = [attr
1035
for attr in self.__dict__.keys()
1036
if not attr.startswith("_")]
1037
self.client_structure.append("client_structure")
1039
for name, t in inspect.getmembers(
1040
type(self), lambda obj: isinstance(obj, property)):
1041
if not name.startswith("_"):
1042
self.client_structure.append(name)
1044
# Send notice to process children that client state has changed
379
self.approval_delay = string_to_delta(
380
config["approval_delay"])
381
self.approval_duration = string_to_delta(
382
config["approval_duration"])
383
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
1045
385
def send_changedstate(self):
1046
with self.changedstate:
1047
self.changedstate.notify_all()
386
self.changedstate.acquire()
387
self.changedstate.notify_all()
388
self.changedstate.release()
1049
390
def enable(self):
1050
391
"""Start this client's checker and timeout hooks"""
1051
392
if getattr(self, "enabled", False):
1052
393
# Already enabled
395
self.send_changedstate()
1055
396
self.last_enabled = datetime.datetime.utcnow()
1057
self.send_changedstate()
397
# Schedule a new checker to be started an 'interval' from now,
398
# and every interval from then on.
399
self.checker_initiator_tag = (gobject.timeout_add
400
(self.interval_milliseconds(),
402
# Schedule a disable() when 'timeout' has passed
403
self.expires = datetime.datetime.utcnow() + self.timeout
404
self.disable_initiator_tag = (gobject.timeout_add
405
(self.timeout_milliseconds(),
408
# Also start a new checker *right now*.
1059
411
def disable(self, quiet=True):
1060
412
"""Disable this client."""
1061
413
if not getattr(self, "enabled", False):
1064
log.info("Disabling client %s", self.name)
1065
if getattr(self, "disable_initiator_tag", None) is not None:
1066
GLib.source_remove(self.disable_initiator_tag)
416
self.send_changedstate()
418
logger.info("Disabling client %s", self.name)
419
if getattr(self, "disable_initiator_tag", False):
420
gobject.source_remove(self.disable_initiator_tag)
1067
421
self.disable_initiator_tag = None
1068
422
self.expires = None
1069
if getattr(self, "checker_initiator_tag", None) is not None:
1070
GLib.source_remove(self.checker_initiator_tag)
423
if getattr(self, "checker_initiator_tag", False):
424
gobject.source_remove(self.checker_initiator_tag)
1071
425
self.checker_initiator_tag = None
1072
426
self.stop_checker()
427
if self.disable_hook:
428
self.disable_hook(self)
1073
429
self.enabled = False
1075
self.send_changedstate()
1076
# Do not run this again if called by a GLib.timeout_add
430
# Do not run this again if called by a gobject.timeout_add
1079
433
def __del__(self):
434
self.disable_hook = None
1082
def init_checker(self, randomize_start=False):
1083
# Schedule a new checker to be started a randomly selected
1084
# time (a fraction of 'interval') from now. This spreads out
1085
# the startup of checkers over time when the server is
1087
if self.checker_initiator_tag is not None:
1088
GLib.source_remove(self.checker_initiator_tag)
1089
interval_milliseconds = int(self.interval.total_seconds()
1092
delay_milliseconds = random.randrange(
1093
interval_milliseconds + 1)
1095
delay_milliseconds = interval_milliseconds
1096
self.checker_initiator_tag = GLib.timeout_add(
1097
delay_milliseconds, self.start_checker, randomize_start)
1098
delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
1099
# A checker might take up to an 'interval' of time, so we can
1100
# expire at the soonest one interval after a checker was
1101
# started. Since the initial checker is delayed, the expire
1102
# time might have to be extended.
1103
now = datetime.datetime.utcnow()
1104
self.expires = now + delay + self.interval
1105
# Schedule a disable() at expire time
1106
if self.disable_initiator_tag is not None:
1107
GLib.source_remove(self.disable_initiator_tag)
1108
self.disable_initiator_tag = GLib.timeout_add(
1109
int((self.expires - now).total_seconds() * 1000),
1112
def checker_callback(self, source, condition, connection,
437
def checker_callback(self, pid, condition, command):
1114
438
"""The checker has completed, so take appropriate actions."""
1115
# Read return code from connection (see call_pipe)
1116
returncode = connection.recv()
1118
if self.checker is not None:
1120
439
self.checker_callback_tag = None
1121
440
self.checker = None
1124
self.last_checker_status = returncode
1125
self.last_checker_signal = None
1126
if self.last_checker_status == 0:
1127
log.info("Checker for %(name)s succeeded", vars(self))
441
if os.WIFEXITED(condition):
442
exitstatus = os.WEXITSTATUS(condition)
444
logger.info("Checker for %(name)s succeeded",
1128
446
self.checked_ok()
1130
log.info("Checker for %(name)s failed", vars(self))
448
logger.info("Checker for %(name)s failed",
1132
self.last_checker_status = -1
1133
self.last_checker_signal = -returncode
1134
log.warning("Checker for %(name)s crashed?", vars(self))
1137
def checked_ok(self):
1138
"""Assert that the client has been seen, alive and well."""
1139
self.last_checked_ok = datetime.datetime.utcnow()
1140
self.last_checker_status = 0
1141
self.last_checker_signal = None
1144
def bump_timeout(self, timeout=None):
1145
"""Bump up the timeout for this client."""
451
logger.warning("Checker for %(name)s crashed?",
454
def checked_ok(self, timeout=None):
455
"""Bump up the timeout for this client.
457
This should only be called when the client has been seen,
1146
460
if timeout is None:
1147
461
timeout = self.timeout
1148
if self.disable_initiator_tag is not None:
1149
GLib.source_remove(self.disable_initiator_tag)
1150
self.disable_initiator_tag = None
1151
if getattr(self, "enabled", False):
1152
self.disable_initiator_tag = GLib.timeout_add(
1153
int(timeout.total_seconds() * 1000), self.disable)
1154
self.expires = datetime.datetime.utcnow() + timeout
462
self.last_checked_ok = datetime.datetime.utcnow()
463
gobject.source_remove(self.disable_initiator_tag)
464
self.expires = datetime.datetime.utcnow() + timeout
465
self.disable_initiator_tag = (gobject.timeout_add
466
(self._timedelta_to_milliseconds(timeout),
1156
469
def need_approval(self):
1157
470
self.last_approval_request = datetime.datetime.utcnow()
1159
def start_checker(self, start_was_randomized=False):
472
def start_checker(self):
1160
473
"""Start a new checker subprocess if one is not running.
1162
475
If a checker already exists, leave it running and do
1164
477
# The reason for not killing a running checker is that if we
1165
# did that, and if a checker (for some reason) started running
1166
# slowly and taking more than 'interval' time, then the client
1167
# would inevitably timeout, since no checker would get a
1168
# chance to run to completion. If we instead leave running
478
# did that, then if a checker (for some reason) started
479
# running slowly and taking more than 'interval' time, the
480
# client would inevitably timeout, since no checker would get
481
# a chance to run to completion. If we instead leave running
1169
482
# checkers alone, the checker would have to take more time
1170
483
# than 'timeout' for the client to be disabled, which is as it
1173
if self.checker is not None and not self.checker.is_alive():
1174
log.warning("Checker was not alive; joining")
486
# If a checker exists, make sure it is not a zombie
488
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
489
except (AttributeError, OSError) as error:
490
if (isinstance(error, OSError)
491
and error.errno != errno.ECHILD):
495
logger.warning("Checker was a zombie")
496
gobject.source_remove(self.checker_callback_tag)
497
self.checker_callback(pid, status,
498
self.current_checker_command)
1177
499
# Start a new checker if needed
1178
500
if self.checker is None:
1179
# Escape attributes for the shell
1181
attr: shlex.quote(str(getattr(self, attr)))
1182
for attr in self.runtime_expansions}
1184
command = self.checker_command % escaped_attrs
1185
except TypeError as error:
1186
log.error('Could not format string "%s"',
1187
self.checker_command, exc_info=error)
1188
return True # Try again later
502
# In case checker_command has exactly one % operator
503
command = self.checker_command % self.host
505
# Escape attributes for the shell
506
escaped_attrs = dict(
508
re.escape(unicode(str(getattr(self, attr, "")),
512
self.runtime_expansions)
515
command = self.checker_command % escaped_attrs
516
except TypeError as error:
517
logger.error('Could not format string "%s":'
518
' %s', self.checker_command, error)
519
return True # Try again later
1189
520
self.current_checker_command = command
1190
log.info("Starting checker %r for %s", command, self.name)
1191
# We don't need to redirect stdout and stderr, since
1192
# in normal mode, that is already done by daemon(),
1193
# and in debug mode we don't want to. (Stdin is
1194
# always replaced by /dev/null.)
1195
# The exception is when not debugging but nevertheless
1196
# running in the foreground; use the previously
1198
popen_args = {"close_fds": True,
1201
if (not self.server_settings["debug"]
1202
and self.server_settings["foreground"]):
1203
popen_args.update({"stdout": wnull,
1205
pipe = multiprocessing.Pipe(duplex=False)
1206
self.checker = multiprocessing.Process(
1208
args=(pipe[1], subprocess.call, command),
1210
self.checker.start()
1211
self.checker_callback_tag = GLib.io_add_watch(
1212
GLib.IOChannel.unix_new(pipe[0].fileno()),
1213
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1214
self.checker_callback, pipe[0], command)
1215
if start_was_randomized:
1216
# We were started after a random delay; Schedule a new
1217
# checker to be started an 'interval' from now, and every
1218
# interval from then on.
1219
now = datetime.datetime.utcnow()
1220
self.checker_initiator_tag = GLib.timeout_add(
1221
int(self.interval.total_seconds() * 1000),
1223
self.expires = max(self.expires, now + self.interval)
1224
# Don't start a new checker again after same random delay
1226
# Re-run this periodically if run by GLib.timeout_add
522
logger.info("Starting checker %r for %s",
524
# We don't need to redirect stdout and stderr, since
525
# in normal mode, that is already done by daemon(),
526
# and in debug mode we don't want to. (Stdin is
527
# always replaced by /dev/null.)
528
self.checker = subprocess.Popen(command,
531
self.checker_callback_tag = (gobject.child_watch_add
533
self.checker_callback,
535
# The checker may have completed before the gobject
536
# watch was added. Check for this.
537
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
539
gobject.source_remove(self.checker_callback_tag)
540
self.checker_callback(pid, status, command)
541
except OSError as error:
542
logger.error("Failed to start subprocess: %s",
544
# Re-run this periodically if run by gobject.timeout_add
1229
547
def stop_checker(self):
1230
548
"""Force the checker process, if any, to stop."""
1231
549
if self.checker_callback_tag:
1232
GLib.source_remove(self.checker_callback_tag)
550
gobject.source_remove(self.checker_callback_tag)
1233
551
self.checker_callback_tag = None
1234
552
if getattr(self, "checker", None) is None:
1236
log.debug("Stopping checker for %(name)s", vars(self))
1237
self.checker.terminate()
554
logger.debug("Stopping checker for %(name)s", vars(self))
556
os.kill(self.checker.pid, signal.SIGTERM)
558
#if self.checker.poll() is None:
559
# os.kill(self.checker.pid, signal.SIGKILL)
560
except OSError as error:
561
if error.errno != errno.ESRCH: # No such process
1238
563
self.checker = None
1241
def dbus_service_property(dbus_interface,
565
def dbus_service_property(dbus_interface, signature="v",
566
access="readwrite", byte_arrays=False):
1245
567
"""Decorators for marking methods of a DBusObjectWithProperties to
1246
568
become properties on the D-Bus.
1248
570
The decorated method will be called with no arguments by "Get"
1249
571
and with one argument by "Set".
1251
573
The parameters, where they are supported, are the same as
1252
574
dbus.service.method, except there is only "signature", since the
1253
575
type from Get() and the type sent to Set() is the same.
1584
746
document.unlink()
1585
747
except (AttributeError, xml.dom.DOMException,
1586
748
xml.parsers.expat.ExpatError) as error:
1587
log.error("Failed to override Introspection method",
1593
dbus.OBJECT_MANAGER_IFACE
1594
except AttributeError:
1595
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1598
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1599
"""A D-Bus object with an ObjectManager.
1601
Classes inheriting from this exposes the standard
1602
GetManagedObjects call and the InterfacesAdded and
1603
InterfacesRemoved signals on the standard
1604
"org.freedesktop.DBus.ObjectManager" interface.
1606
Note: No signals are sent automatically; they must be sent
1609
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1610
out_signature="a{oa{sa{sv}}}")
1611
def GetManagedObjects(self):
1612
"""This function must be overridden"""
1613
raise NotImplementedError()
1615
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1616
signature="oa{sa{sv}}")
1617
def InterfacesAdded(self, object_path, interfaces_and_properties):
1620
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1621
def InterfacesRemoved(self, object_path, interfaces):
1624
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1626
path_keyword="object_path",
1627
connection_keyword="connection")
1628
def Introspect(self, object_path, connection):
1629
"""Overloading of standard D-Bus method.
1631
Override return argument name of GetManagedObjects to be
1632
"objpath_interfaces_and_properties"
1634
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1638
document = xml.dom.minidom.parseString(xmlstring)
1640
for if_tag in document.getElementsByTagName("interface"):
1641
# Fix argument name for the GetManagedObjects method
1642
if (if_tag.getAttribute("name")
1643
== dbus.OBJECT_MANAGER_IFACE):
1644
for cn in if_tag.getElementsByTagName("method"):
1645
if (cn.getAttribute("name")
1646
== "GetManagedObjects"):
1647
for arg in cn.getElementsByTagName("arg"):
1648
if (arg.getAttribute("direction")
1652
"objpath_interfaces"
1654
xmlstring = document.toxml("utf-8")
1656
except (AttributeError, xml.dom.DOMException,
1657
xml.parsers.expat.ExpatError) as error:
1658
log.error("Failed to override Introspection method",
1663
def datetime_to_dbus(dt, variant_level=0):
1664
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1666
return dbus.String("", variant_level=variant_level)
1667
return dbus.String(dt.isoformat(), variant_level=variant_level)
1670
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1671
"""A class decorator; applied to a subclass of
1672
dbus.service.Object, it will add alternate D-Bus attributes with
1673
interface names according to the "alt_interface_names" mapping.
1676
@alternate_dbus_interfaces({"org.example.Interface":
1677
"net.example.AlternateInterface"})
1678
class SampleDBusObject(dbus.service.Object):
1679
@dbus.service.method("org.example.Interface")
1680
def SampleDBusMethod():
1683
The above "SampleDBusMethod" on "SampleDBusObject" will be
1684
reachable via two interfaces: "org.example.Interface" and
1685
"net.example.AlternateInterface", the latter of which will have
1686
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1687
"true", unless "deprecate" is passed with a False value.
1689
This works for methods and signals, and also for D-Bus properties
1690
(from DBusObjectWithProperties) and interfaces (from the
1691
dbus_interface_annotations decorator).
1695
for orig_interface_name, alt_interface_name in (
1696
alt_interface_names.items()):
1698
interface_names = set()
1699
# Go though all attributes of the class
1700
for attrname, attribute in inspect.getmembers(cls):
1701
# Ignore non-D-Bus attributes, and D-Bus attributes
1702
# with the wrong interface name
1703
if (not hasattr(attribute, "_dbus_interface")
1704
or not attribute._dbus_interface.startswith(
1705
orig_interface_name)):
1707
# Create an alternate D-Bus interface name based on
1709
alt_interface = attribute._dbus_interface.replace(
1710
orig_interface_name, alt_interface_name)
1711
interface_names.add(alt_interface)
1712
# Is this a D-Bus signal?
1713
if getattr(attribute, "_dbus_is_signal", False):
1714
# Extract the original non-method undecorated
1715
# function by black magic
1716
if sys.version_info.major == 2:
1717
nonmethod_func = (dict(
1718
zip(attribute.func_code.co_freevars,
1719
attribute.__closure__))
1720
["func"].cell_contents)
1722
nonmethod_func = (dict(
1723
zip(attribute.__code__.co_freevars,
1724
attribute.__closure__))
1725
["func"].cell_contents)
1726
# Create a new, but exactly alike, function
1727
# object, and decorate it to be a new D-Bus signal
1728
# with the alternate D-Bus interface name
1729
new_function = copy_function(nonmethod_func)
1730
new_function = (dbus.service.signal(
1732
attribute._dbus_signature)(new_function))
1733
# Copy annotations, if any
1735
new_function._dbus_annotations = dict(
1736
attribute._dbus_annotations)
1737
except AttributeError:
1740
# Define a creator of a function to call both the
1741
# original and alternate functions, so both the
1742
# original and alternate signals gets sent when
1743
# the function is called
1744
def fixscope(func1, func2):
1745
"""This function is a scope container to pass
1746
func1 and func2 to the "call_both" function
1747
outside of its arguments"""
1749
@functools.wraps(func2)
1750
def call_both(*args, **kwargs):
1751
"""This function will emit two D-Bus
1752
signals by calling func1 and func2"""
1753
func1(*args, **kwargs)
1754
func2(*args, **kwargs)
1755
# Make wrapper function look like a D-Bus
1757
for name, attr in inspect.getmembers(func2):
1758
if name.startswith("_dbus_"):
1759
setattr(call_both, name, attr)
1762
# Create the "call_both" function and add it to
1764
attr[attrname] = fixscope(attribute, new_function)
1765
# Is this a D-Bus method?
1766
elif getattr(attribute, "_dbus_is_method", False):
1767
# Create a new, but exactly alike, function
1768
# object. Decorate it to be a new D-Bus method
1769
# with the alternate D-Bus interface name. Add it
1772
dbus.service.method(
1774
attribute._dbus_in_signature,
1775
attribute._dbus_out_signature)
1776
(copy_function(attribute)))
1777
# Copy annotations, if any
1779
attr[attrname]._dbus_annotations = dict(
1780
attribute._dbus_annotations)
1781
except AttributeError:
1783
# Is this a D-Bus property?
1784
elif getattr(attribute, "_dbus_is_property", False):
1785
# Create a new, but exactly alike, function
1786
# object, and decorate it to be a new D-Bus
1787
# property with the alternate D-Bus interface
1788
# name. Add it to the class.
1789
attr[attrname] = (dbus_service_property(
1790
alt_interface, attribute._dbus_signature,
1791
attribute._dbus_access,
1792
attribute._dbus_get_args_options
1794
(copy_function(attribute)))
1795
# Copy annotations, if any
1797
attr[attrname]._dbus_annotations = dict(
1798
attribute._dbus_annotations)
1799
except AttributeError:
1801
# Is this a D-Bus interface?
1802
elif getattr(attribute, "_dbus_is_interface", False):
1803
# Create a new, but exactly alike, function
1804
# object. Decorate it to be a new D-Bus interface
1805
# with the alternate D-Bus interface name. Add it
1808
dbus_interface_annotations(alt_interface)
1809
(copy_function(attribute)))
1811
# Deprecate all alternate interfaces
1812
iname = "_AlternateDBusNames_interface_annotation{}"
1813
for interface_name in interface_names:
1815
@dbus_interface_annotations(interface_name)
1817
return {"org.freedesktop.DBus.Deprecated":
1819
# Find an unused name
1820
for aname in (iname.format(i)
1821
for i in itertools.count()):
1822
if aname not in attr:
1826
# Replace the class with a new subclass of it with
1827
# methods, signals, etc. as created above.
1828
if sys.version_info.major == 2:
1829
cls = type(b"{}Alternate".format(cls.__name__),
1832
cls = type("{}Alternate".format(cls.__name__),
1839
@alternate_dbus_interfaces({"se.recompile.Mandos":
1840
"se.bsnet.fukt.Mandos"})
749
logger.error("Failed to override Introspection method",
1841
754
class ClientDBus(Client, DBusObjectWithProperties):
1842
755
"""A Client class using D-Bus
1845
758
dbus_object_path: dbus.ObjectPath
1846
759
bus: dbus.SystemBus()
1849
762
runtime_expansions = (Client.runtime_expansions
1850
+ ("dbus_object_path", ))
1852
_interface = "se.recompile.Mandos.Client"
763
+ ("dbus_object_path",))
1854
765
# dbus.service.Object doesn't use super(), so we can't either.
1856
def __init__(self, bus=None, *args, **kwargs):
767
def __init__(self, bus = None, *args, **kwargs):
768
self._approvals_pending = 0
1858
770
Client.__init__(self, *args, **kwargs)
1859
771
# Only now, when this client is initialized, can it show up on
1861
client_object_name = str(self.name).translate(
773
client_object_name = unicode(self.name).translate(
1862
774
{ord("."): ord("_"),
1863
775
ord("-"): ord("_")})
1864
self.dbus_object_path = dbus.ObjectPath(
1865
"/clients/" + client_object_name)
776
self.dbus_object_path = (dbus.ObjectPath
777
("/clients/" + client_object_name))
1866
778
DBusObjectWithProperties.__init__(self, self.bus,
1867
779
self.dbus_object_path)
1869
def notifychangeproperty(transform_func, dbus_name,
1870
type_func=lambda x: x,
1872
invalidate_only=False,
1873
_interface=_interface):
1874
""" Modify a variable so that it's a property which announces
1875
its changes to DBus.
1877
transform_fun: Function that takes a value and a variant_level
1878
and transforms it to a D-Bus type.
1879
dbus_name: D-Bus name of the variable
1880
type_func: Function that transform the value before sending it
1881
to the D-Bus. Default: no transform
1882
variant_level: D-Bus variant level. Default: 1
1884
attrname = "_{}".format(dbus_name)
1886
def setter(self, value):
1887
if hasattr(self, "dbus_object_path"):
1888
if (not hasattr(self, attrname) or
1889
type_func(getattr(self, attrname, None))
1890
!= type_func(value)):
1892
self.PropertiesChanged(
1893
_interface, dbus.Dictionary(),
1894
dbus.Array((dbus_name, )))
1896
dbus_value = transform_func(
1898
variant_level=variant_level)
1899
self.PropertyChanged(dbus.String(dbus_name),
1901
self.PropertiesChanged(
1903
dbus.Dictionary({dbus.String(dbus_name):
1906
setattr(self, attrname, value)
1908
return property(lambda self: getattr(self, attrname), setter)
1910
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1911
approvals_pending = notifychangeproperty(dbus.Boolean,
1914
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1915
last_enabled = notifychangeproperty(datetime_to_dbus,
1917
checker = notifychangeproperty(
1918
dbus.Boolean, "CheckerRunning",
1919
type_func=lambda checker: checker is not None)
1920
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1922
last_checker_status = notifychangeproperty(dbus.Int16,
1923
"LastCheckerStatus")
1924
last_approval_request = notifychangeproperty(
1925
datetime_to_dbus, "LastApprovalRequest")
1926
approved_by_default = notifychangeproperty(dbus.Boolean,
1927
"ApprovedByDefault")
1928
approval_delay = notifychangeproperty(
1929
dbus.UInt64, "ApprovalDelay",
1930
type_func=lambda td: td.total_seconds() * 1000)
1931
approval_duration = notifychangeproperty(
1932
dbus.UInt64, "ApprovalDuration",
1933
type_func=lambda td: td.total_seconds() * 1000)
1934
host = notifychangeproperty(dbus.String, "Host")
1935
timeout = notifychangeproperty(
1936
dbus.UInt64, "Timeout",
1937
type_func=lambda td: td.total_seconds() * 1000)
1938
extended_timeout = notifychangeproperty(
1939
dbus.UInt64, "ExtendedTimeout",
1940
type_func=lambda td: td.total_seconds() * 1000)
1941
interval = notifychangeproperty(
1942
dbus.UInt64, "Interval",
1943
type_func=lambda td: td.total_seconds() * 1000)
1944
checker_command = notifychangeproperty(dbus.String, "Checker")
1945
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1946
invalidate_only=True)
1948
del notifychangeproperty
780
def _set_expires(self, value):
781
old_value = getattr(self, "_expires", None)
782
self._expires = value
783
if hasattr(self, "dbus_object_path") and old_value != value:
784
dbus_time = (self._datetime_to_dbus(self._expires,
786
self.PropertyChanged(dbus.String("Expires"),
788
expires = property(lambda self: self._expires, _set_expires)
791
def _get_approvals_pending(self):
792
return self._approvals_pending
793
def _set_approvals_pending(self, value):
794
old_value = self._approvals_pending
795
self._approvals_pending = value
797
if (hasattr(self, "dbus_object_path")
798
and bval is not bool(old_value)):
799
dbus_bool = dbus.Boolean(bval, variant_level=1)
800
self.PropertyChanged(dbus.String("ApprovalPending"),
803
approvals_pending = property(_get_approvals_pending,
804
_set_approvals_pending)
805
del _get_approvals_pending, _set_approvals_pending
808
def _datetime_to_dbus(dt, variant_level=0):
809
"""Convert a UTC datetime.datetime() to a D-Bus type."""
811
return dbus.String("", variant_level = variant_level)
812
return dbus.String(dt.isoformat(),
813
variant_level=variant_level)
816
oldstate = getattr(self, "enabled", False)
817
r = Client.enable(self)
818
if oldstate != self.enabled:
820
self.PropertyChanged(dbus.String("Enabled"),
821
dbus.Boolean(True, variant_level=1))
822
self.PropertyChanged(
823
dbus.String("LastEnabled"),
824
self._datetime_to_dbus(self.last_enabled,
828
def disable(self, quiet = False):
829
oldstate = getattr(self, "enabled", False)
830
r = Client.disable(self, quiet=quiet)
831
if not quiet and oldstate != self.enabled:
833
self.PropertyChanged(dbus.String("Enabled"),
834
dbus.Boolean(False, variant_level=1))
1950
837
def __del__(self, *args, **kwargs):
1952
839
self.remove_from_connection()
2270
1199
self.start_checker()
2272
1201
self.stop_checker()
2274
1203
# ObjectPath - property
2276
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2277
"org.freedesktop.DBus.Deprecated": "true"})
2278
1204
@dbus_service_property(_interface, signature="o", access="read")
2279
1205
def ObjectPath_dbus_property(self):
2280
return self.dbus_object_path # is already a dbus.ObjectPath
1206
return self.dbus_object_path # is already a dbus.ObjectPath
2282
1208
# Secret = property
2284
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2286
@dbus_service_property(_interface,
1209
@dbus_service_property(_interface, signature="ay",
1210
access="write", byte_arrays=True)
2290
1211
def Secret_dbus_property(self, value):
2291
self.secret = bytes(value)
1212
self.secret = str(value)
2297
def __init__(self, child_pipe, key_id, fpr, address):
1217
class ProxyClient(object):
1218
def __init__(self, child_pipe, fpr, address):
2298
1219
self._pipe = child_pipe
2299
self._pipe.send(("init", key_id, fpr, address))
1220
self._pipe.send(('init', fpr, address))
2300
1221
if not self._pipe.recv():
2301
raise KeyError(key_id or fpr)
2303
1224
def __getattribute__(self, name):
1225
if(name == '_pipe'):
2305
1226
return super(ProxyClient, self).__getattribute__(name)
2306
self._pipe.send(("getattr", name))
1227
self._pipe.send(('getattr', name))
2307
1228
data = self._pipe.recv()
2308
if data[0] == "data":
1229
if data[0] == 'data':
2310
if data[0] == "function":
1231
if data[0] == 'function':
2312
1232
def func(*args, **kwargs):
2313
self._pipe.send(("funcall", name, args, kwargs))
1233
self._pipe.send(('funcall', name, args, kwargs))
2314
1234
return self._pipe.recv()[1]
2318
1237
def __setattr__(self, name, value):
1238
if(name == '_pipe'):
2320
1239
return super(ProxyClient, self).__setattr__(name, value)
2321
self._pipe.send(("setattr", name, value))
1240
self._pipe.send(('setattr', name, value))
2324
1243
class ClientHandler(socketserver.BaseRequestHandler, object):
2325
1244
"""A class to handle client connections.
2327
1246
Instantiated once for each connection to handle it.
2328
1247
Note: This will run in its own forked process."""
2330
1249
def handle(self):
2331
1250
with contextlib.closing(self.server.child_pipe) as child_pipe:
2332
log.info("TCP connection from: %s",
2333
str(self.client_address))
2334
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2336
session = gnutls.ClientSession(self.request)
2338
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2339
# "+AES-256-CBC", "+SHA1",
2340
# "+COMP-NULL", "+CTYPE-OPENPGP",
1251
logger.info("TCP connection from: %s",
1252
unicode(self.client_address))
1253
logger.debug("Pipe FD: %d",
1254
self.server.child_pipe.fileno())
1256
session = (gnutls.connection
1257
.ClientSession(self.request,
1259
.X509Credentials()))
1261
# Note: gnutls.connection.X509Credentials is really a
1262
# generic GnuTLS certificate credentials object so long as
1263
# no X.509 keys are added to it. Therefore, we can use it
1264
# here despite using OpenPGP certificates.
1266
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1267
# "+AES-256-CBC", "+SHA1",
1268
# "+COMP-NULL", "+CTYPE-OPENPGP",
2342
1270
# Use a fallback default, since this MUST be set.
2343
1271
priority = self.server.gnutls_priority
2344
1272
if priority is None:
2345
1273
priority = "NORMAL"
2346
gnutls.priority_set_direct(session,
2347
priority.encode("utf-8"), None)
1274
(gnutls.library.functions
1275
.gnutls_priority_set_direct(session._c_object,
2349
1278
# Start communication using the Mandos protocol
2350
1279
# Get protocol number
2351
1280
line = self.request.makefile().readline()
2352
log.debug("Protocol version: %r", line)
1281
logger.debug("Protocol version: %r", line)
2354
1283
if int(line.strip().split()[0]) > 1:
2355
raise RuntimeError(line)
2356
1285
except (ValueError, IndexError, RuntimeError) as error:
2357
log.error("Unknown protocol version: %s", error)
1286
logger.error("Unknown protocol version: %s", error)
2360
1289
# Start GnuTLS connection
2362
1291
session.handshake()
2363
except gnutls.Error as error:
2364
log.warning("Handshake failed: %s", error)
1292
except gnutls.errors.GNUTLSError as error:
1293
logger.warning("Handshake failed: %s", error)
2365
1294
# Do not run session.bye() here: the session is not
2366
1295
# established. Just abandon the request.
2368
log.debug("Handshake succeeded")
1297
logger.debug("Handshake succeeded")
2370
1299
approval_required = False
2372
if gnutls.has_rawpk:
2375
key_id = self.key_id(
2376
self.peer_certificate(session))
2377
except (TypeError, gnutls.Error) as error:
2378
log.warning("Bad certificate: %s", error)
2380
log.debug("Key ID: %s",
2381
key_id.decode("utf-8",
2387
fpr = self.fingerprint(
2388
self.peer_certificate(session))
2389
except (TypeError, gnutls.Error) as error:
2390
log.warning("Bad certificate: %s", error)
2392
log.debug("Fingerprint: %s", fpr)
2395
client = ProxyClient(child_pipe, key_id, fpr,
1302
fpr = self.fingerprint(self.peer_certificate
1305
gnutls.errors.GNUTLSError) as error:
1306
logger.warning("Bad certificate: %s", error)
1308
logger.debug("Fingerprint: %s", fpr)
1311
client = ProxyClient(child_pipe, fpr,
2396
1312
self.client_address)
2397
1313
except KeyError:
2400
1316
if client.approval_delay:
2401
1317
delay = client.approval_delay
2402
1318
client.approvals_pending += 1
2403
1319
approval_required = True
2406
1322
if not client.enabled:
2407
log.info("Client %s is disabled", client.name)
1323
logger.info("Client %s is disabled",
2408
1325
if self.server.use_dbus:
2409
1326
# Emit D-Bus signal
2410
client.Rejected("Disabled")
1327
client.Rejected("Disabled")
2413
if client.approved or not client.approval_delay:
2414
# We are approved or approval is disabled
1330
if client._approved or not client.approval_delay:
1331
#We are approved or approval is disabled
2416
elif client.approved is None:
2417
log.info("Client %s needs approval",
1333
elif client._approved is None:
1334
logger.info("Client %s needs approval",
2419
1336
if self.server.use_dbus:
2420
1337
# Emit D-Bus signal
2421
1338
client.NeedApproval(
2422
client.approval_delay.total_seconds()
2423
* 1000, client.approved_by_default)
1339
client.approval_delay_milliseconds(),
1340
client.approved_by_default)
2425
log.warning("Client %s was not approved",
1342
logger.warning("Client %s was not approved",
2427
1344
if self.server.use_dbus:
2428
1345
# Emit D-Bus signal
2429
1346
client.Rejected("Denied")
2432
# wait until timeout or approved
1349
#wait until timeout or approved
1350
#x = float(client._timedelta_to_milliseconds(delay))
2433
1351
time = datetime.datetime.now()
2434
1352
client.changedstate.acquire()
2435
client.changedstate.wait(delay.total_seconds())
1353
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
2436
1354
client.changedstate.release()
2437
1355
time2 = datetime.datetime.now()
2438
1356
if (time2 - time) >= delay:
2439
1357
if not client.approved_by_default:
2440
log.warning("Client %s timed out while"
2441
" waiting for approval",
1358
logger.warning("Client %s timed out while"
1359
" waiting for approval",
2443
1361
if self.server.use_dbus:
2444
1362
# Emit D-Bus signal
2445
1363
client.Rejected("Approval timed out")
2450
1368
delay -= time2 - time
2453
session.send(client.secret)
2454
except gnutls.Error as error:
2455
log.warning("gnutls send failed", exc_info=error)
2458
log.info("Sending secret to %s", client.name)
2459
# bump the timeout using extended_timeout
2460
client.bump_timeout(client.extended_timeout)
1371
while sent_size < len(client.secret):
1373
sent = session.send(client.secret[sent_size:])
1374
except gnutls.errors.GNUTLSError as error:
1375
logger.warning("gnutls send failed")
1377
logger.debug("Sent: %d, remaining: %d",
1378
sent, len(client.secret)
1379
- (sent_size + sent))
1382
logger.info("Sending secret to %s", client.name)
1383
# bump the timeout as if seen
1384
client.checked_ok(client.extended_timeout)
2461
1385
if self.server.use_dbus:
2462
1386
# Emit D-Bus signal
2463
1387
client.GotSecret()
2466
1390
if approval_required:
2467
1391
client.approvals_pending -= 1
2470
except gnutls.Error as error:
2471
log.warning("GnuTLS bye failed", exc_info=error)
1394
except gnutls.errors.GNUTLSError as error:
1395
logger.warning("GnuTLS bye failed")
2474
1398
def peer_certificate(session):
2475
"Return the peer's certificate as a bytestring"
2477
cert_type = gnutls.certificate_type_get2(
2478
session, gnutls.CTYPE_PEERS)
2479
except AttributeError:
2480
cert_type = gnutls.certificate_type_get(session)
2481
if gnutls.has_rawpk:
2482
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2484
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2485
# If not a valid certificate type...
2486
if cert_type not in valid_cert_types:
2487
log.info("Cert type %r not in %r", cert_type,
2489
# ...return invalid data
1399
"Return the peer's OpenPGP certificate as a bytestring"
1400
# If not an OpenPGP certificate...
1401
if (gnutls.library.functions
1402
.gnutls_certificate_type_get(session._c_object)
1403
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1404
# ...do the normal thing
1405
return session.peer_certificate
2491
1406
list_size = ctypes.c_uint(1)
2492
cert_list = (gnutls.certificate_get_peers
2493
(session, ctypes.byref(list_size)))
1407
cert_list = (gnutls.library.functions
1408
.gnutls_certificate_get_peers
1409
(session._c_object, ctypes.byref(list_size)))
2494
1410
if not bool(cert_list) and list_size.value != 0:
2495
raise gnutls.Error("error getting peer certificate")
1411
raise gnutls.errors.GNUTLSError("error getting peer"
2496
1413
if list_size.value == 0:
2498
1415
cert = cert_list[0]
2499
1416
return ctypes.string_at(cert.data, cert.size)
2502
def key_id(certificate):
2503
"Convert a certificate bytestring to a hexdigit key ID"
2504
# New GnuTLS "datum" with the public key
2505
datum = gnutls.datum_t(
2506
ctypes.cast(ctypes.c_char_p(certificate),
2507
ctypes.POINTER(ctypes.c_ubyte)),
2508
ctypes.c_uint(len(certificate)))
2509
# XXX all these need to be created in the gnutls "module"
2510
# New empty GnuTLS certificate
2511
pubkey = gnutls.pubkey_t()
2512
gnutls.pubkey_init(ctypes.byref(pubkey))
2513
# Import the raw public key into the certificate
2514
gnutls.pubkey_import(pubkey,
2515
ctypes.byref(datum),
2516
gnutls.X509_FMT_DER)
2517
# New buffer for the key ID
2518
buf = ctypes.create_string_buffer(32)
2519
buf_len = ctypes.c_size_t(len(buf))
2520
# Get the key ID from the raw public key into the buffer
2521
gnutls.pubkey_get_key_id(
2523
gnutls.KEYID_USE_SHA256,
2524
ctypes.cast(ctypes.byref(buf),
2525
ctypes.POINTER(ctypes.c_ubyte)),
2526
ctypes.byref(buf_len))
2527
# Deinit the certificate
2528
gnutls.pubkey_deinit(pubkey)
2530
# Convert the buffer to a Python bytestring
2531
key_id = ctypes.string_at(buf, buf_len.value)
2532
# Convert the bytestring to hexadecimal notation
2533
hex_key_id = binascii.hexlify(key_id).upper()
2537
1419
def fingerprint(openpgp):
2538
1420
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2539
1421
# New GnuTLS "datum" with the OpenPGP public key
2540
datum = gnutls.datum_t(
2541
ctypes.cast(ctypes.c_char_p(openpgp),
2542
ctypes.POINTER(ctypes.c_ubyte)),
2543
ctypes.c_uint(len(openpgp)))
1422
datum = (gnutls.library.types
1423
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1426
ctypes.c_uint(len(openpgp))))
2544
1427
# New empty GnuTLS certificate
2545
crt = gnutls.openpgp_crt_t()
2546
gnutls.openpgp_crt_init(ctypes.byref(crt))
1428
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1429
(gnutls.library.functions
1430
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2547
1431
# Import the OpenPGP public key into the certificate
2548
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2549
gnutls.OPENPGP_FMT_RAW)
1432
(gnutls.library.functions
1433
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1434
gnutls.library.constants
1435
.GNUTLS_OPENPGP_FMT_RAW))
2550
1436
# Verify the self signature in the key
2551
1437
crtverify = ctypes.c_uint()
2552
gnutls.openpgp_crt_verify_self(crt, 0,
2553
ctypes.byref(crtverify))
1438
(gnutls.library.functions
1439
.gnutls_openpgp_crt_verify_self(crt, 0,
1440
ctypes.byref(crtverify)))
2554
1441
if crtverify.value != 0:
2555
gnutls.openpgp_crt_deinit(crt)
2556
raise gnutls.CertificateSecurityError(code
1442
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1443
raise (gnutls.errors.CertificateSecurityError
2558
1445
# New buffer for the fingerprint
2559
1446
buf = ctypes.create_string_buffer(20)
2560
1447
buf_len = ctypes.c_size_t()
2561
1448
# Get the fingerprint from the certificate into the buffer
2562
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2563
ctypes.byref(buf_len))
1449
(gnutls.library.functions
1450
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1451
ctypes.byref(buf_len)))
2564
1452
# Deinit the certificate
2565
gnutls.openpgp_crt_deinit(crt)
1453
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2566
1454
# Convert the buffer to a Python bytestring
2567
1455
fpr = ctypes.string_at(buf, buf_len.value)
2568
1456
# Convert the bytestring to hexadecimal notation
2569
hex_fpr = binascii.hexlify(fpr).upper()
1457
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
2573
class MultiprocessingMixIn:
1461
class MultiprocessingMixIn(object):
2574
1462
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2576
1463
def sub_process_main(self, request, address):
2578
1465
self.finish_request(request, address)
2580
1467
self.handle_error(request, address)
2581
1468
self.close_request(request)
2583
1470
def process_request(self, request, address):
2584
1471
"""Start a new process to process the request."""
2585
proc = multiprocessing.Process(target=self.sub_process_main,
2586
args=(request, address))
2591
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
1472
multiprocessing.Process(target = self.sub_process_main,
1473
args = (request, address)).start()
1475
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2592
1476
""" adds a pipe to the MixIn """
2594
1477
def process_request(self, request, client_address):
2595
1478
"""Overrides and wraps the original process_request().
2597
1480
This function creates a new pipe in self.pipe
2599
1482
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2601
proc = MultiprocessingMixIn.process_request(self, request,
1484
super(MultiprocessingMixInWithPipe,
1485
self).process_request(request, client_address)
2603
1486
self.child_pipe.close()
2604
self.add_pipe(parent_pipe, proc)
1487
self.add_pipe(parent_pipe)
2606
def add_pipe(self, parent_pipe, proc):
1489
def add_pipe(self, parent_pipe):
2607
1490
"""Dummy function; override as necessary"""
2608
raise NotImplementedError()
1491
raise NotImplementedError
2611
1493
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2612
socketserver.TCPServer):
2613
"""IPv6-capable TCP server. Accepts None as address and/or port
1494
socketserver.TCPServer, object):
1495
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2616
1498
enabled: Boolean; whether this server is activated yet
2617
1499
interface: None or a network interface name (string)
2618
1500
use_ipv6: Boolean; to use IPv6 or not
2621
1502
def __init__(self, server_address, RequestHandlerClass,
2625
"""If socketfd is set, use that file descriptor instead of
2626
creating a new one with socket.socket().
1503
interface=None, use_ipv6=True):
2628
1504
self.interface = interface
2630
1506
self.address_family = socket.AF_INET6
2631
if socketfd is not None:
2632
# Save the file descriptor
2633
self.socketfd = socketfd
2634
# Save the original socket.socket() function
2635
self.socket_socket = socket.socket
2637
# To implement --socket, we monkey patch socket.socket.
2639
# (When socketserver.TCPServer is a new-style class, we
2640
# could make self.socket into a property instead of monkey
2641
# patching socket.socket.)
2643
# Create a one-time-only replacement for socket.socket()
2644
@functools.wraps(socket.socket)
2645
def socket_wrapper(*args, **kwargs):
2646
# Restore original function so subsequent calls are
2648
socket.socket = self.socket_socket
2649
del self.socket_socket
2650
# This time only, return a new socket object from the
2651
# saved file descriptor.
2652
return socket.fromfd(self.socketfd, *args, **kwargs)
2653
# Replace socket.socket() function with wrapper
2654
socket.socket = socket_wrapper
2655
# The socketserver.TCPServer.__init__ will call
2656
# socket.socket(), which might be our replacement,
2657
# socket_wrapper(), if socketfd was set.
2658
1507
socketserver.TCPServer.__init__(self, server_address,
2659
1508
RequestHandlerClass)
2661
1509
def server_bind(self):
2662
1510
"""This overrides the normal server_bind() function
2663
1511
to bind to an interface if one was specified, and also NOT to
2664
1512
bind to an address or port if they were not specified."""
2665
global SO_BINDTODEVICE
2666
1513
if self.interface is not None:
2667
1514
if SO_BINDTODEVICE is None:
2668
# Fall back to a hard-coded value which seems to be
2670
log.warning("SO_BINDTODEVICE not found, trying 25")
2671
SO_BINDTODEVICE = 25
2673
self.socket.setsockopt(
2674
socket.SOL_SOCKET, SO_BINDTODEVICE,
2675
(self.interface + "\0").encode("utf-8"))
2676
except socket.error as error:
2677
if error.errno == errno.EPERM:
2678
log.error("No permission to bind to interface %s",
2680
elif error.errno == errno.ENOPROTOOPT:
2681
log.error("SO_BINDTODEVICE not available; cannot"
2682
" bind to interface %s", self.interface)
2683
elif error.errno == errno.ENODEV:
2684
log.error("Interface %s does not exist, cannot"
2685
" bind", self.interface)
1515
logger.error("SO_BINDTODEVICE does not exist;"
1516
" cannot bind to interface %s",
1520
self.socket.setsockopt(socket.SOL_SOCKET,
1524
except socket.error as error:
1525
if error[0] == errno.EPERM:
1526
logger.error("No permission to"
1527
" bind to interface %s",
1529
elif error[0] == errno.ENOPROTOOPT:
1530
logger.error("SO_BINDTODEVICE not available;"
1531
" cannot bind to interface %s",
2688
1535
# Only bind(2) the socket if we really need to.
2689
1536
if self.server_address[0] or self.server_address[1]:
2690
if self.server_address[1]:
2691
self.allow_reuse_address = True
2692
1537
if not self.server_address[0]:
2693
1538
if self.address_family == socket.AF_INET6:
2694
any_address = "::" # in6addr_any
1539
any_address = "::" # in6addr_any
2696
any_address = "0.0.0.0" # INADDR_ANY
1541
any_address = socket.INADDR_ANY
2697
1542
self.server_address = (any_address,
2698
1543
self.server_address[1])
2699
1544
elif not self.server_address[1]:
2700
self.server_address = (self.server_address[0], 0)
1545
self.server_address = (self.server_address[0],
2701
1547
# if self.interface:
2702
1548
# self.server_address = (self.server_address[0],
3033
1780
parser.add_argument("--no-dbus", action="store_false",
3034
1781
dest="use_dbus", help="Do not provide D-Bus"
3035
" system bus interface", default=None)
1782
" system bus interface")
3036
1783
parser.add_argument("--no-ipv6", action="store_false",
3037
dest="use_ipv6", help="Do not use IPv6",
3039
parser.add_argument("--no-restore", action="store_false",
3040
dest="restore", help="Do not restore stored"
3041
" state", default=None)
3042
parser.add_argument("--socket", type=int,
3043
help="Specify a file descriptor to a network"
3044
" socket to use instead of creating one")
3045
parser.add_argument("--statedir", metavar="DIR",
3046
help="Directory to save/restore state in")
3047
parser.add_argument("--foreground", action="store_true",
3048
help="Run in foreground", default=None)
3049
parser.add_argument("--no-zeroconf", action="store_false",
3050
dest="zeroconf", help="Do not use Zeroconf",
1784
dest="use_ipv6", help="Do not use IPv6")
3053
1785
options = parser.parse_args()
3055
1792
# Default values for config file for server-global settings
3056
if gnutls.has_rawpk:
3057
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3058
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
3060
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
3061
":+SIGN-DSA-SHA256")
3062
server_defaults = {"interface": "",
3066
"priority": priority,
3067
"servicename": "Mandos",
3073
"statedir": "/var/lib/mandos",
3074
"foreground": "False",
1793
server_defaults = { "interface": "",
1798
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1799
"servicename": "Mandos",
3079
1805
# Parse config file for server-global settings
3080
server_config = configparser.ConfigParser(server_defaults)
1806
server_config = configparser.SafeConfigParser(server_defaults)
3081
1807
del server_defaults
3082
server_config.read(os.path.join(options.configdir, "mandos.conf"))
3083
# Convert the ConfigParser object to a dict
1808
server_config.read(os.path.join(options.configdir,
1810
# Convert the SafeConfigParser object to a dict
3084
1811
server_settings = server_config.defaults()
3085
1812
# Use the appropriate methods on the non-string config options
3086
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3087
"foreground", "zeroconf"):
1813
for option in ("debug", "use_dbus", "use_ipv6"):
3088
1814
server_settings[option] = server_config.getboolean("DEFAULT",
3090
1816
if server_settings["port"]:
3091
1817
server_settings["port"] = server_config.getint("DEFAULT",
3093
if server_settings["socket"]:
3094
server_settings["socket"] = server_config.getint("DEFAULT",
3096
# Later, stdin will, and stdout and stderr might, be dup'ed
3097
# over with an opened os.devnull. But we don't want this to
3098
# happen with a supplied network socket.
3099
if 0 <= server_settings["socket"] <= 2:
3100
server_settings["socket"] = os.dup(server_settings
3102
1819
del server_config
3104
1821
# Override the settings from the config file with command line
3105
1822
# options, if set.
3106
1823
for option in ("interface", "address", "port", "debug",
3107
"priority", "servicename", "configdir", "use_dbus",
3108
"use_ipv6", "debuglevel", "restore", "statedir",
3109
"socket", "foreground", "zeroconf"):
1824
"priority", "servicename", "configdir",
1825
"use_dbus", "use_ipv6", "debuglevel"):
3110
1826
value = getattr(options, option)
3111
1827
if value is not None:
3112
1828
server_settings[option] = value
3114
1830
# Force all strings to be unicode
3115
1831
for option in server_settings.keys():
3116
if isinstance(server_settings[option], bytes):
3117
server_settings[option] = (server_settings[option]
3119
# Force all boolean options to be boolean
3120
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3121
"foreground", "zeroconf"):
3122
server_settings[option] = bool(server_settings[option])
3123
# Debug implies foreground
3124
if server_settings["debug"]:
3125
server_settings["foreground"] = True
1832
if type(server_settings[option]) is str:
1833
server_settings[option] = unicode(server_settings[option])
3126
1834
# Now we have our good server settings in "server_settings"
3128
1836
##################################################################
3130
if (not server_settings["zeroconf"]
3131
and not (server_settings["port"]
3132
or server_settings["socket"] != "")):
3133
parser.error("Needs port or socket to work without Zeroconf")
3135
1838
# For convenience
3136
1839
debug = server_settings["debug"]
3137
1840
debuglevel = server_settings["debuglevel"]
3138
1841
use_dbus = server_settings["use_dbus"]
3139
1842
use_ipv6 = server_settings["use_ipv6"]
3140
stored_state_path = os.path.join(server_settings["statedir"],
3142
foreground = server_settings["foreground"]
3143
zeroconf = server_settings["zeroconf"]
3146
initlogger(debug, logging.DEBUG)
3151
level = getattr(logging, debuglevel.upper())
3152
initlogger(debug, level)
3154
1844
if server_settings["servicename"] != "Mandos":
3155
syslogger.setFormatter(
3156
logging.Formatter("Mandos ({}) [%(process)d]:"
3157
" %(levelname)s: %(message)s".format(
3158
server_settings["servicename"])))
1845
syslogger.setFormatter(logging.Formatter
1846
('Mandos (%s) [%%(process)d]:'
1847
' %%(levelname)s: %%(message)s'
1848
% server_settings["servicename"]))
3160
1850
# Parse config file with clients
3161
client_config = configparser.ConfigParser(Client.client_defaults)
1851
client_defaults = { "timeout": "5m",
1852
"extended_timeout": "15m",
1854
"checker": "fping -q -- %%(host)s",
1856
"approval_delay": "0s",
1857
"approval_duration": "1s",
1859
client_config = configparser.SafeConfigParser(client_defaults)
3162
1860
client_config.read(os.path.join(server_settings["configdir"],
3163
1861
"clients.conf"))
3165
1863
global mandos_dbus_service
3166
1864
mandos_dbus_service = None
3169
if server_settings["socket"] != "":
3170
socketfd = server_settings["socket"]
3171
tcp_server = MandosServer(
3172
(server_settings["address"], server_settings["port"]),
3174
interface=(server_settings["interface"] or None),
3176
gnutls_priority=server_settings["priority"],
3180
pidfilename = "/run/mandos.pid"
3181
if not os.path.isdir("/run/."):
3182
pidfilename = "/var/run/mandos.pid"
3185
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3186
except IOError as e:
3187
log.error("Could not open file %r", pidfilename,
3190
for name, group in (("_mandos", "_mandos"),
3191
("mandos", "mandos"),
3192
("nobody", "nogroup")):
3194
uid = pwd.getpwnam(name).pw_uid
3195
gid = pwd.getpwnam(group).pw_gid
1866
tcp_server = MandosServer((server_settings["address"],
1867
server_settings["port"]),
1869
interface=(server_settings["interface"]
1873
server_settings["priority"],
1876
pidfilename = "/var/run/mandos.pid"
1878
pidfile = open(pidfilename, "w")
1880
logger.error("Could not open file %r", pidfilename)
1883
uid = pwd.getpwnam("_mandos").pw_uid
1884
gid = pwd.getpwnam("_mandos").pw_gid
1887
uid = pwd.getpwnam("mandos").pw_uid
1888
gid = pwd.getpwnam("mandos").pw_gid
3197
1889
except KeyError:
1891
uid = pwd.getpwnam("nobody").pw_uid
1892
gid = pwd.getpwnam("nobody").pw_gid
3205
log.debug("Did setuid/setgid to %s:%s", uid, gid)
3206
1899
except OSError as error:
3207
log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
3208
os.strerror(error.errno))
3209
if error.errno != errno.EPERM:
1900
if error[0] != errno.EPERM:
1903
if not debug and not debuglevel:
1904
syslogger.setLevel(logging.WARNING)
1905
console.setLevel(logging.WARNING)
1907
level = getattr(logging, debuglevel.upper())
1908
syslogger.setLevel(level)
1909
console.setLevel(level)
3213
1912
# Enable all possible GnuTLS debugging
3215
1914
# "Use a log level over 10 to enable all debugging options."
3216
1915
# - GnuTLS manual
3217
gnutls.global_set_log_level(11)
1916
gnutls.library.functions.gnutls_global_set_log_level(11)
1918
@gnutls.library.types.gnutls_log_func
3220
1919
def debug_gnutls(level, string):
3221
log.debug("GnuTLS: %s",
3222
string[:-1].decode("utf-8", errors="replace"))
3224
gnutls.global_set_log_function(debug_gnutls)
1920
logger.debug("GnuTLS: %s", string[:-1])
1922
(gnutls.library.functions
1923
.gnutls_global_set_log_function(debug_gnutls))
3226
1925
# Redirect stdin so all checkers get /dev/null
3227
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1926
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
3228
1927
os.dup2(null, sys.stdin.fileno())
1931
# No console logging
1932
logger.removeHandler(console)
3232
1934
# Need to fork before connecting to D-Bus
3234
1936
# Close all input and output, do double fork, etc.
3237
if gi.version_info < (3, 10, 2):
3238
# multiprocessing will use threads, so before we use GLib we
3239
# need to inform GLib that threads will be used.
3242
1939
global main_loop
3243
1940
# From the Avahi example code
3244
DBusGMainLoop(set_as_default=True)
3245
main_loop = GLib.MainLoop()
3246
if use_dbus or zeroconf:
3247
bus = dbus.SystemBus()
1941
DBusGMainLoop(set_as_default=True )
1942
main_loop = gobject.MainLoop()
1943
bus = dbus.SystemBus()
3248
1944
# End of Avahi example code
3251
bus_name = dbus.service.BusName("se.recompile.Mandos",
3254
old_bus_name = dbus.service.BusName(
3255
"se.bsnet.fukt.Mandos", bus,
3257
except dbus.exceptions.DBusException as e:
3258
log.error("Disabling D-Bus:", exc_info=e)
1947
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1948
bus, do_not_queue=True)
1949
except dbus.exceptions.NameExistsException as e:
1950
logger.error(unicode(e) + ", disabling D-Bus")
3259
1951
use_dbus = False
3260
1952
server_settings["use_dbus"] = False
3261
1953
tcp_server.use_dbus = False
3263
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3264
service = AvahiServiceToSyslog(
3265
name=server_settings["servicename"],
3266
servicetype="_mandos._tcp",
3269
if server_settings["interface"]:
3270
service.interface = if_nametoindex(
3271
server_settings["interface"].encode("utf-8"))
1954
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1955
service = AvahiService(name = server_settings["servicename"],
1956
servicetype = "_mandos._tcp",
1957
protocol = protocol, bus = bus)
1958
if server_settings["interface"]:
1959
service.interface = (if_nametoindex
1960
(str(server_settings["interface"])))
3273
1962
global multiprocessing_manager
3274
1963
multiprocessing_manager = multiprocessing.Manager()
3276
1965
client_class = Client
3278
client_class = functools.partial(ClientDBus, bus=bus)
3280
client_settings = Client.config_parser(client_config)
3281
old_client_settings = {}
3284
# This is used to redirect stdout and stderr for checker processes
3286
wnull = open(os.devnull, "w") # A writable /dev/null
3287
# Only used if server is running in foreground but not in debug
3289
if debug or not foreground:
3292
# Get client data and settings from last running state.
3293
if server_settings["restore"]:
3295
with open(stored_state_path, "rb") as stored_state:
3296
if sys.version_info.major == 2:
3297
clients_data, old_client_settings = pickle.load(
3300
bytes_clients_data, bytes_old_client_settings = (
3301
pickle.load(stored_state, encoding="bytes"))
3302
# Fix bytes to strings
3305
clients_data = {(key.decode("utf-8")
3306
if isinstance(key, bytes)
3309
bytes_clients_data.items()}
3310
del bytes_clients_data
3311
for key in clients_data:
3312
value = {(k.decode("utf-8")
3313
if isinstance(k, bytes) else k): v
3315
clients_data[key].items()}
3316
clients_data[key] = value
3318
value["client_structure"] = [
3320
if isinstance(s, bytes)
3322
value["client_structure"]]
3323
# .name, .host, and .checker_command
3324
for k in ("name", "host", "checker_command"):
3325
if isinstance(value[k], bytes):
3326
value[k] = value[k].decode("utf-8")
3327
if "key_id" not in value:
3328
value["key_id"] = ""
3329
elif "fingerprint" not in value:
3330
value["fingerprint"] = ""
3331
# old_client_settings
3333
old_client_settings = {
3334
(key.decode("utf-8")
3335
if isinstance(key, bytes)
3338
bytes_old_client_settings.items()}
3339
del bytes_old_client_settings
3340
# .host and .checker_command
3341
for value in old_client_settings.values():
3342
for attribute in ("host", "checker_command"):
3343
if isinstance(value[attribute], bytes):
3344
value[attribute] = (value[attribute]
3346
os.remove(stored_state_path)
3347
except IOError as e:
3348
if e.errno == errno.ENOENT:
3349
log.warning("Could not load persistent state:"
3350
" %s", os.strerror(e.errno))
3352
log.critical("Could not load persistent state:",
3355
except EOFError as e:
3356
log.warning("Could not load persistent state: EOFError:",
3359
with PGPEngine() as pgp:
3360
for client_name, client in clients_data.items():
3361
# Skip removed clients
3362
if client_name not in client_settings:
3365
# Decide which value to use after restoring saved state.
3366
# We have three different values: Old config file,
3367
# new config file, and saved state.
3368
# New config value takes precedence if it differs from old
3369
# config value, otherwise use saved state.
3370
for name, value in client_settings[client_name].items():
3372
# For each value in new config, check if it
3373
# differs from the old config value (Except for
3374
# the "secret" attribute)
3375
if (name != "secret"
3377
old_client_settings[client_name][name])):
3378
client[name] = value
3382
# Clients who has passed its expire date can still be
3383
# enabled if its last checker was successful. A Client
3384
# whose checker succeeded before we stored its state is
3385
# assumed to have successfully run all checkers during
3387
if client["enabled"]:
3388
if datetime.datetime.utcnow() >= client["expires"]:
3389
if not client["last_checked_ok"]:
3390
log.warning("disabling client %s - Client"
3391
" never performed a successful"
3392
" checker", client_name)
3393
client["enabled"] = False
3394
elif client["last_checker_status"] != 0:
3395
log.warning("disabling client %s - Client"
3396
" last checker failed with error"
3397
" code %s", client_name,
3398
client["last_checker_status"])
3399
client["enabled"] = False
3401
client["expires"] = (
3402
datetime.datetime.utcnow()
3403
+ client["timeout"])
3404
log.debug("Last checker succeeded, keeping %s"
3405
" enabled", client_name)
1967
client_class = functools.partial(ClientDBus, bus = bus)
1968
def client_config_items(config, section):
1969
special_settings = {
1970
"approved_by_default":
1971
lambda: config.getboolean(section,
1972
"approved_by_default"),
1974
for name, value in config.items(section):
3407
client["secret"] = pgp.decrypt(
3408
client["encrypted_secret"],
3409
client_settings[client_name]["secret"])
3411
# If decryption fails, we use secret from new settings
3412
log.debug("Failed to decrypt %s old secret",
3414
client["secret"] = (client_settings[client_name]
3417
# Add/remove clients based on new changes made to config
3418
for client_name in (set(old_client_settings)
3419
- set(client_settings)):
3420
del clients_data[client_name]
3421
for client_name in (set(client_settings)
3422
- set(old_client_settings)):
3423
clients_data[client_name] = client_settings[client_name]
3425
# Create all client objects
3426
for client_name, client in clients_data.items():
3427
tcp_server.clients[client_name] = client_class(
3430
server_settings=server_settings)
1976
yield (name, special_settings[name]())
1980
tcp_server.clients.update(set(
1981
client_class(name = section,
1982
config= dict(client_config_items(
1983
client_config, section)))
1984
for section in client_config.sections()))
3432
1985
if not tcp_server.clients:
3433
log.warning("No clients defined")
3436
if pidfile is not None:
3440
print(pid, file=pidfile)
3442
log.error("Could not write to file %r with PID %d",
1986
logger.warning("No clients defined")
1992
pidfile.write(str(pid) + "\n".encode("utf-8"))
1995
logger.error("Could not write to file %r with PID %d",
1998
# "pidfile" was never created
3445
2000
del pidfilename
3447
for termsig in (signal.SIGHUP, signal.SIGTERM):
3448
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3449
lambda: main_loop.quit() and False)
2002
signal.signal(signal.SIGINT, signal.SIG_IGN)
2004
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2005
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3453
@alternate_dbus_interfaces(
3454
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3455
class MandosDBusService(DBusObjectWithObjectManager):
2008
class MandosDBusService(dbus.service.Object):
3456
2009
"""A D-Bus proxy object"""
3458
2010
def __init__(self):
3459
2011
dbus.service.Object.__init__(self, bus, "/")
3461
_interface = "se.recompile.Mandos"
2012
_interface = "se.bsnet.fukt.Mandos"
3463
2014
@dbus.service.signal(_interface, signature="o")
3464
2015
def ClientAdded(self, objpath):
3468
2019
@dbus.service.signal(_interface, signature="ss")
3469
def ClientNotFound(self, key_id, address):
2020
def ClientNotFound(self, fingerprint, address):
3473
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3475
2024
@dbus.service.signal(_interface, signature="os")
3476
2025
def ClientRemoved(self, objpath, name):
3480
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3482
2029
@dbus.service.method(_interface, out_signature="ao")
3483
2030
def GetAllClients(self):
3485
return dbus.Array(c.dbus_object_path for c in
3486
tcp_server.clients.values())
3488
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2032
return dbus.Array(c.dbus_object_path
2033
for c in tcp_server.clients)
3490
2035
@dbus.service.method(_interface,
3491
2036
out_signature="a{oa{sv}}")
3492
2037
def GetAllClientsWithProperties(self):
3494
2039
return dbus.Dictionary(
3495
{c.dbus_object_path: c.GetAll(
3496
"se.recompile.Mandos.Client")
3497
for c in tcp_server.clients.values()},
2040
((c.dbus_object_path, c.GetAll(""))
2041
for c in tcp_server.clients),
3498
2042
signature="oa{sv}")
3500
2044
@dbus.service.method(_interface, in_signature="o")
3501
2045
def RemoveClient(self, object_path):
3503
for c in tcp_server.clients.values():
2047
for c in tcp_server.clients:
3504
2048
if c.dbus_object_path == object_path:
3505
del tcp_server.clients[c.name]
2049
tcp_server.clients.remove(c)
3506
2050
c.remove_from_connection()
3507
# Don't signal the disabling
2051
# Don't signal anything except ClientRemoved
3508
2052
c.disable(quiet=True)
3509
# Emit D-Bus signal for removal
3510
self.client_removed_signal(c)
2054
self.ClientRemoved(object_path, c.name)
3512
2056
raise KeyError(object_path)
3516
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3517
out_signature="a{oa{sa{sv}}}")
3518
def GetManagedObjects(self):
3520
return dbus.Dictionary(
3521
{client.dbus_object_path:
3523
{interface: client.GetAll(interface)
3525
client._get_all_interface_names()})
3526
for client in tcp_server.clients.values()})
3528
def client_added_signal(self, client):
3529
"""Send the new standard signal and the old signal"""
3531
# New standard signal
3532
self.InterfacesAdded(
3533
client.dbus_object_path,
3535
{interface: client.GetAll(interface)
3537
client._get_all_interface_names()}))
3539
self.ClientAdded(client.dbus_object_path)
3541
def client_removed_signal(self, client):
3542
"""Send the new standard signal and the old signal"""
3544
# New standard signal
3545
self.InterfacesRemoved(
3546
client.dbus_object_path,
3547
client._get_all_interface_names())
3549
self.ClientRemoved(client.dbus_object_path,
3552
2060
mandos_dbus_service = MandosDBusService()
3554
# Save modules to variables to exempt the modules from being
3555
# unloaded before the function registered with atexit() is run.
3556
mp = multiprocessing
3560
2063
"Cleanup function; run on exit"
3564
mp.active_children()
3566
if not (tcp_server.clients or client_settings):
3569
# Store client before exiting. Secrets are encrypted with key
3570
# based on what config file has. If config file is
3571
# removed/edited, old secret will thus be unrecovable.
3573
with PGPEngine() as pgp:
3574
for client in tcp_server.clients.values():
3575
key = client_settings[client.name]["secret"]
3576
client.encrypted_secret = pgp.encrypt(client.secret,
3580
# A list of attributes that can not be pickled
3582
exclude = {"bus", "changedstate", "secret",
3583
"checker", "server_settings"}
3584
for name, typ in inspect.getmembers(dbus.service
3588
client_dict["encrypted_secret"] = (client
3590
for attr in client.client_structure:
3591
if attr not in exclude:
3592
client_dict[attr] = getattr(client, attr)
3594
clients[client.name] = client_dict
3595
del client_settings[client.name]["secret"]
3598
with tempfile.NamedTemporaryFile(
3602
dir=os.path.dirname(stored_state_path),
3603
delete=False) as stored_state:
3604
pickle.dump((clients, client_settings), stored_state,
3606
tempname = stored_state.name
3607
os.rename(tempname, stored_state_path)
3608
except (IOError, OSError) as e:
3614
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3615
log.warning("Could not save persistent state: %s",
3616
os.strerror(e.errno))
3618
log.warning("Could not save persistent state:",
3622
# Delete all clients, and settings from config
3623
2066
while tcp_server.clients:
3624
name, client = tcp_server.clients.popitem()
2067
client = tcp_server.clients.pop()
3626
2069
client.remove_from_connection()
3627
# Don't signal the disabling
2070
client.disable_hook = None
2071
# Don't signal anything except ClientRemoved
3628
2072
client.disable(quiet=True)
3629
# Emit D-Bus signal for removal
3631
mandos_dbus_service.client_removed_signal(client)
3632
client_settings.clear()
2075
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
3634
2078
atexit.register(cleanup)
3636
for client in tcp_server.clients.values():
2080
for client in tcp_server.clients:
3638
# Emit D-Bus signal for adding
3639
mandos_dbus_service.client_added_signal(client)
3640
# Need to initiate checking of clients
3642
client.init_checker(randomize_start=True)
2083
mandos_dbus_service.ClientAdded(client.dbus_object_path)
3644
2086
tcp_server.enable()
3645
2087
tcp_server.server_activate()
3647
2089
# Find out what port we got
3649
service.port = tcp_server.socket.getsockname()[1]
2090
service.port = tcp_server.socket.getsockname()[1]
3651
log.info("Now listening on address %r, port %d, flowinfo %d,"
3652
" scope_id %d", *tcp_server.socket.getsockname())
2092
logger.info("Now listening on address %r, port %d,"
2093
" flowinfo %d, scope_id %d"
2094
% tcp_server.socket.getsockname())
3654
log.info("Now listening on address %r, port %d",
3655
*tcp_server.socket.getsockname())
3657
# service.interface = tcp_server.socket.getsockname()[3]
2096
logger.info("Now listening on address %r, port %d"
2097
% tcp_server.socket.getsockname())
2099
#service.interface = tcp_server.socket.getsockname()[3]
3661
# From the Avahi example code
3664
except dbus.exceptions.DBusException as error:
3665
log.critical("D-Bus Exception", exc_info=error)
3668
# End of Avahi example code
3671
GLib.IOChannel.unix_new(tcp_server.fileno()),
3672
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3673
lambda *args, **kwargs: (tcp_server.handle_request
3674
(*args[2:], **kwargs) or True))
3676
log.debug("Starting main loop")
2102
# From the Avahi example code
2105
except dbus.exceptions.DBusException as error:
2106
logger.critical("DBusException: %s", error)
2109
# End of Avahi example code
2111
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2112
lambda *args, **kwargs:
2113
(tcp_server.handle_request
2114
(*args[2:], **kwargs) or True))
2116
logger.debug("Starting main loop")
3677
2117
main_loop.run()
3678
2118
except AvahiError as error:
3679
log.critical("Avahi Error", exc_info=error)
2119
logger.critical("AvahiError: %s", error)
3682
2122
except KeyboardInterrupt:
3684
2124
print("", file=sys.stderr)
3685
log.debug("Server received KeyboardInterrupt")
3686
log.debug("Server exiting")
2125
logger.debug("Server received KeyboardInterrupt")
2126
logger.debug("Server exiting")
3687
2127
# Must run before the D-Bus bus name gets deregistered
3691
def parse_test_args():
3692
# type: () -> argparse.Namespace
3693
parser = argparse.ArgumentParser(add_help=False)
3694
parser.add_argument("--check", action="store_true")
3695
parser.add_argument("--prefix", )
3696
args, unknown_args = parser.parse_known_args()
3698
# Remove test options from sys.argv
3699
sys.argv[1:] = unknown_args
3702
# Add all tests from doctest strings
3703
def load_tests(loader, tests, none):
3705
tests.addTests(doctest.DocTestSuite())
3708
if __name__ == "__main__":
3709
options = parse_test_args()
3712
extra_test_prefix = options.prefix
3713
if extra_test_prefix is not None:
3714
if not (unittest.main(argv=[""], exit=False)
3715
.result.wasSuccessful()):
3717
class ExtraTestLoader(unittest.TestLoader):
3718
testMethodPrefix = extra_test_prefix
3719
# Call using ./scriptname --test [--verbose]
3720
unittest.main(argv=[""], testLoader=ExtraTestLoader())
3722
unittest.main(argv=[""])
3730
# (lambda (&optional extra)
3731
# (if (not (funcall run-tests-in-test-buffer default-directory
3733
# (funcall show-test-buffer-in-test-window)
3734
# (funcall remove-test-window)
3735
# (if extra (message "Extra tests run successfully!"))))
3736
# run-tests-in-test-buffer:
3737
# (lambda (dir &optional extra)
3738
# (with-current-buffer (get-buffer-create "*Test*")
3739
# (setq buffer-read-only nil
3740
# default-directory dir)
3742
# (compilation-mode))
3743
# (let ((process-result
3744
# (let ((inhibit-read-only t))
3745
# (process-file-shell-command
3746
# (funcall get-command-line extra) nil "*Test*"))))
3747
# (and (numberp process-result)
3748
# (= process-result 0))))
3750
# (lambda (&optional extra)
3751
# (let ((quoted-script
3752
# (shell-quote-argument (funcall get-script-name))))
3754
# (concat "%s --check" (if extra " --prefix=atest" ""))
3758
# (if (fboundp 'file-local-name)
3759
# (file-local-name (buffer-file-name))
3760
# (or (file-remote-p (buffer-file-name) 'localname)
3761
# (buffer-file-name))))
3762
# remove-test-window:
3764
# (let ((test-window (get-buffer-window "*Test*")))
3765
# (if test-window (delete-window test-window))))
3766
# show-test-buffer-in-test-window:
3768
# (when (not (get-buffer-window-list "*Test*"))
3769
# (setq next-error-last-buffer (get-buffer "*Test*"))
3770
# (let* ((side (if (>= (window-width) 146) 'right 'bottom))
3771
# (display-buffer-overriding-action
3772
# `((display-buffer-in-side-window) (side . ,side)
3773
# (window-height . fit-window-to-buffer)
3774
# (window-width . fit-window-to-buffer))))
3775
# (display-buffer "*Test*"))))
3778
# (let* ((run-extra-tests (lambda () (interactive)
3779
# (funcall run-tests t)))
3780
# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
3781
# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c
3782
# (setq minor-mode-overriding-map-alist
3783
# (cons `(run-tests . ,outer-keymap)
3784
# minor-mode-overriding-map-alist)))
3785
# (add-hook 'after-save-hook run-tests 90 t))
2130
if __name__ == '__main__':