345
104
max_renames: integer; maximum number of renames
346
105
rename_count: integer; counter so we only rename after collisions
347
106
a sensible number of times
348
group: D-Bus Entry Group
350
bus: dbus.SystemBus()
354
interface=avahi.IF_UNSPEC,
362
protocol=avahi.PROTO_UNSPEC,
108
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
364
111
self.interface = interface
366
self.type = servicetype
368
self.TXT = TXT if TXT is not None else []
369
119
self.domain = domain
371
121
self.rename_count = 0
372
122
self.max_renames = max_renames
373
self.protocol = protocol
374
self.group = None # our entry group
377
self.entry_group_state_changed_match = None
379
def rename(self, remove=True):
380
124
"""Derived from the Avahi example code"""
381
125
if self.rename_count >= self.max_renames:
382
logger.critical("No suitable Zeroconf service name found"
383
" after %i retries, exiting.",
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
385
128
raise AvahiServiceError("Too many renames")
387
self.server.GetAlternativeServiceName(self.name))
129
self.name = server.GetAlternativeServiceName(self.name)
130
logger.info(u"Changing name to %r ...", str(self.name))
131
syslogger.setFormatter(logging.Formatter\
132
('Mandos (%s): %%(levelname)s:'
133
' %%(message)s' % self.name))
388
136
self.rename_count += 1
389
logger.info("Changing Zeroconf service name to %r ...",
395
except dbus.exceptions.DBusException as error:
396
if (error.get_dbus_name()
397
== "org.freedesktop.Avahi.CollisionError"):
398
logger.info("Local Zeroconf service name collision.")
399
return self.rename(remove=False)
401
logger.critical("D-Bus Exception", exc_info=error)
405
137
def remove(self):
406
138
"""Derived from the Avahi example code"""
407
if self.entry_group_state_changed_match is not None:
408
self.entry_group_state_changed_match.remove()
409
self.entry_group_state_changed_match = None
410
if self.group is not None:
139
if group is not None:
414
142
"""Derived from the Avahi example code"""
416
if self.group is None:
417
self.group = dbus.Interface(
418
self.bus.get_object(avahi.DBUS_NAME,
419
self.server.EntryGroupNew()),
420
avahi.DBUS_INTERFACE_ENTRY_GROUP)
421
self.entry_group_state_changed_match = (
422
self.group.connect_to_signal(
423
'StateChanged', self.entry_group_state_changed))
424
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
425
self.name, self.type)
426
self.group.AddService(
429
dbus.UInt32(0), # flags
430
self.name, self.type,
431
self.domain, self.host,
432
dbus.UInt16(self.port),
433
avahi.string_array_to_txt_array(self.TXT))
436
def entry_group_state_changed(self, state, error):
437
"""Derived from the Avahi example code"""
438
logger.debug("Avahi entry group state change: %i", state)
440
if state == avahi.ENTRY_GROUP_ESTABLISHED:
441
logger.debug("Zeroconf service established.")
442
elif state == avahi.ENTRY_GROUP_COLLISION:
443
logger.info("Zeroconf service name collision.")
445
elif state == avahi.ENTRY_GROUP_FAILURE:
446
logger.critical("Avahi: Error in group state changed %s",
448
raise AvahiGroupError("State changed: {!s}".format(error))
451
"""Derived from the Avahi example code"""
452
if self.group is not None:
455
except (dbus.exceptions.UnknownMethodException,
456
dbus.exceptions.DBusException):
461
def server_state_changed(self, state, error=None):
462
"""Derived from the Avahi example code"""
463
logger.debug("Avahi server state change: %i", state)
465
avahi.SERVER_INVALID: "Zeroconf server invalid",
466
avahi.SERVER_REGISTERING: None,
467
avahi.SERVER_COLLISION: "Zeroconf server name collision",
468
avahi.SERVER_FAILURE: "Zeroconf server failure",
470
if state in bad_states:
471
if bad_states[state] is not None:
473
logger.error(bad_states[state])
475
logger.error(bad_states[state] + ": %r", error)
477
elif state == avahi.SERVER_RUNNING:
480
except dbus.exceptions.DBusException as error:
481
if (error.get_dbus_name()
482
== "org.freedesktop.Avahi.CollisionError"):
483
logger.info("Local Zeroconf service name"
485
return self.rename(remove=False)
487
logger.critical("D-Bus Exception", exc_info=error)
492
logger.debug("Unknown state: %r", state)
494
logger.debug("Unknown state: %r: %r", state, error)
497
"""Derived from the Avahi example code"""
498
if self.server is None:
499
self.server = dbus.Interface(
500
self.bus.get_object(avahi.DBUS_NAME,
501
avahi.DBUS_PATH_SERVER,
502
follow_name_owner_changes=True),
503
avahi.DBUS_INTERFACE_SERVER)
504
self.server.connect_to_signal("StateChanged",
505
self.server_state_changed)
506
self.server_state_changed(self.server.GetState())
509
class AvahiServiceToSyslog(AvahiService):
510
def rename(self, *args, **kwargs):
511
"""Add the new name to the syslog messages"""
512
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
513
syslogger.setFormatter(logging.Formatter(
514
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
519
# Pretend that we have a GnuTLS module
521
"""This isn't so much a class as it is a module-like namespace."""
523
library = ctypes.util.find_library("gnutls")
525
library = ctypes.util.find_library("gnutls-deb0")
526
_library = ctypes.cdll.LoadLibrary(library)
529
# Unless otherwise indicated, the constants and types below are
530
# all from the gnutls/gnutls.h C header file.
541
E_NO_CERTIFICATE_FOUND = -49
546
KEYID_USE_SHA256 = 1 # gnutls/x509.h
547
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
550
class session_int(ctypes.Structure):
552
session_t = ctypes.POINTER(session_int)
554
class certificate_credentials_st(ctypes.Structure):
556
certificate_credentials_t = ctypes.POINTER(
557
certificate_credentials_st)
558
certificate_type_t = ctypes.c_int
560
class datum_t(ctypes.Structure):
561
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
562
('size', ctypes.c_uint)]
564
class openpgp_crt_int(ctypes.Structure):
566
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
567
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
568
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
569
credentials_type_t = ctypes.c_int
570
transport_ptr_t = ctypes.c_void_p
571
close_request_t = ctypes.c_int
574
class Error(Exception):
575
def __init__(self, message=None, code=None, args=()):
576
# Default usage is by a message string, but if a return
577
# code is passed, convert it to a string with
580
if message is None and code is not None:
581
message = gnutls.strerror(code)
582
return super(gnutls.Error, self).__init__(
585
class CertificateSecurityError(Error):
591
self._c_object = gnutls.certificate_credentials_t()
592
gnutls.certificate_allocate_credentials(
593
ctypes.byref(self._c_object))
594
self.type = gnutls.CRD_CERTIFICATE
597
gnutls.certificate_free_credentials(self._c_object)
600
def __init__(self, socket, credentials=None):
601
self._c_object = gnutls.session_t()
602
gnutls_flags = gnutls.CLIENT
603
if gnutls.check_version(b"3.5.6"):
604
gnutls_flags |= gnutls.NO_TICKETS
606
gnutls_flags |= gnutls.ENABLE_RAWPK
607
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
609
gnutls.set_default_priority(self._c_object)
610
gnutls.transport_set_ptr(self._c_object, socket.fileno())
611
gnutls.handshake_set_private_extensions(self._c_object,
614
if credentials is None:
615
credentials = gnutls.Credentials()
616
gnutls.credentials_set(self._c_object, credentials.type,
617
ctypes.cast(credentials._c_object,
619
self.credentials = credentials
622
gnutls.deinit(self._c_object)
625
return gnutls.handshake(self._c_object)
627
def send(self, data):
631
data_len -= gnutls.record_send(self._c_object,
636
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
638
# Error handling functions
639
def _error_code(result):
640
"""A function to raise exceptions on errors, suitable
641
for the 'restype' attribute on ctypes functions"""
644
if result == gnutls.E_NO_CERTIFICATE_FOUND:
645
raise gnutls.CertificateSecurityError(code=result)
646
raise gnutls.Error(code=result)
648
def _retry_on_error(result, func, arguments):
649
"""A function to retry on some errors, suitable
650
for the 'errcheck' attribute on ctypes functions"""
652
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
653
return _error_code(result)
654
result = func(*arguments)
657
# Unless otherwise indicated, the function declarations below are
658
# all from the gnutls/gnutls.h C header file.
661
priority_set_direct = _library.gnutls_priority_set_direct
662
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
663
ctypes.POINTER(ctypes.c_char_p)]
664
priority_set_direct.restype = _error_code
666
init = _library.gnutls_init
667
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
668
init.restype = _error_code
670
set_default_priority = _library.gnutls_set_default_priority
671
set_default_priority.argtypes = [session_t]
672
set_default_priority.restype = _error_code
674
record_send = _library.gnutls_record_send
675
record_send.argtypes = [session_t, ctypes.c_void_p,
677
record_send.restype = ctypes.c_ssize_t
678
record_send.errcheck = _retry_on_error
680
certificate_allocate_credentials = (
681
_library.gnutls_certificate_allocate_credentials)
682
certificate_allocate_credentials.argtypes = [
683
ctypes.POINTER(certificate_credentials_t)]
684
certificate_allocate_credentials.restype = _error_code
686
certificate_free_credentials = (
687
_library.gnutls_certificate_free_credentials)
688
certificate_free_credentials.argtypes = [
689
certificate_credentials_t]
690
certificate_free_credentials.restype = None
692
handshake_set_private_extensions = (
693
_library.gnutls_handshake_set_private_extensions)
694
handshake_set_private_extensions.argtypes = [session_t,
696
handshake_set_private_extensions.restype = None
698
credentials_set = _library.gnutls_credentials_set
699
credentials_set.argtypes = [session_t, credentials_type_t,
701
credentials_set.restype = _error_code
703
strerror = _library.gnutls_strerror
704
strerror.argtypes = [ctypes.c_int]
705
strerror.restype = ctypes.c_char_p
707
certificate_type_get = _library.gnutls_certificate_type_get
708
certificate_type_get.argtypes = [session_t]
709
certificate_type_get.restype = _error_code
711
certificate_get_peers = _library.gnutls_certificate_get_peers
712
certificate_get_peers.argtypes = [session_t,
713
ctypes.POINTER(ctypes.c_uint)]
714
certificate_get_peers.restype = ctypes.POINTER(datum_t)
716
global_set_log_level = _library.gnutls_global_set_log_level
717
global_set_log_level.argtypes = [ctypes.c_int]
718
global_set_log_level.restype = None
720
global_set_log_function = _library.gnutls_global_set_log_function
721
global_set_log_function.argtypes = [log_func]
722
global_set_log_function.restype = None
724
deinit = _library.gnutls_deinit
725
deinit.argtypes = [session_t]
726
deinit.restype = None
728
handshake = _library.gnutls_handshake
729
handshake.argtypes = [session_t]
730
handshake.restype = _error_code
731
handshake.errcheck = _retry_on_error
733
transport_set_ptr = _library.gnutls_transport_set_ptr
734
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
735
transport_set_ptr.restype = None
737
bye = _library.gnutls_bye
738
bye.argtypes = [session_t, close_request_t]
739
bye.restype = _error_code
740
bye.errcheck = _retry_on_error
742
check_version = _library.gnutls_check_version
743
check_version.argtypes = [ctypes.c_char_p]
744
check_version.restype = ctypes.c_char_p
746
_need_version = b"3.3.0"
747
if check_version(_need_version) is None:
748
raise self.Error("Needs GnuTLS {} or later"
749
.format(_need_version))
751
_tls_rawpk_version = b"3.6.6"
752
has_rawpk = bool(check_version(_tls_rawpk_version))
756
class pubkey_st(ctypes.Structure):
758
pubkey_t = ctypes.POINTER(pubkey_st)
760
x509_crt_fmt_t = ctypes.c_int
762
# All the function declarations below are from gnutls/abstract.h
763
pubkey_init = _library.gnutls_pubkey_init
764
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
765
pubkey_init.restype = _error_code
767
pubkey_import = _library.gnutls_pubkey_import
768
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
770
pubkey_import.restype = _error_code
772
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
773
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
774
ctypes.POINTER(ctypes.c_ubyte),
775
ctypes.POINTER(ctypes.c_size_t)]
776
pubkey_get_key_id.restype = _error_code
778
pubkey_deinit = _library.gnutls_pubkey_deinit
779
pubkey_deinit.argtypes = [pubkey_t]
780
pubkey_deinit.restype = None
782
# All the function declarations below are from gnutls/openpgp.h
784
openpgp_crt_init = _library.gnutls_openpgp_crt_init
785
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
786
openpgp_crt_init.restype = _error_code
788
openpgp_crt_import = _library.gnutls_openpgp_crt_import
789
openpgp_crt_import.argtypes = [openpgp_crt_t,
790
ctypes.POINTER(datum_t),
792
openpgp_crt_import.restype = _error_code
794
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
795
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
796
ctypes.POINTER(ctypes.c_uint)]
797
openpgp_crt_verify_self.restype = _error_code
799
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
800
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
801
openpgp_crt_deinit.restype = None
803
openpgp_crt_get_fingerprint = (
804
_library.gnutls_openpgp_crt_get_fingerprint)
805
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
809
openpgp_crt_get_fingerprint.restype = _error_code
811
if check_version(b"3.6.4"):
812
certificate_type_get2 = _library.gnutls_certificate_type_get2
813
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
814
certificate_type_get2.restype = _error_code
816
# Remove non-public functions
817
del _error_code, _retry_on_error
820
def call_pipe(connection, # : multiprocessing.Connection
821
func, *args, **kwargs):
822
"""This function is meant to be called by multiprocessing.Process
824
This function runs func(*args, **kwargs), and writes the resulting
825
return value on the provided multiprocessing.Connection.
827
connection.send(func(*args, **kwargs))
145
group = dbus.Interface\
146
(bus.get_object(avahi.DBUS_NAME,
147
server.EntryGroupNew()),
148
avahi.DBUS_INTERFACE_ENTRY_GROUP)
149
group.connect_to_signal('StateChanged',
150
entry_group_state_changed)
151
logger.debug(u"Adding service '%s' of type '%s' ...",
152
service.name, service.type)
154
self.interface, # interface
155
avahi.PROTO_INET6, # protocol
156
dbus.UInt32(0), # flags
157
self.name, self.type,
158
self.domain, self.host,
159
dbus.UInt16(self.port),
160
avahi.string_array_to_txt_array(self.TXT))
163
# From the Avahi example code:
164
group = None # our entry group
165
# End of Avahi example code
168
class Client(object):
832
169
"""A representation of a client host served by this server.
835
approved: bool(); 'None' if not yet approved/disapproved
836
approval_delay: datetime.timedelta(); Time to wait for approval
837
approval_duration: datetime.timedelta(); Duration of one approval
838
checker: multiprocessing.Process(); a running checker process used
839
to see if the client lives. 'None' if no process is
841
checker_callback_tag: a GLib event source tag, or None
842
checker_command: string; External command which is run to check
843
if client lives. %() expansions are done at
171
name: string; from the config file, used in log messages
172
fingerprint: string (40 or 32 hexadecimal digits); used to
173
uniquely identify the client
174
secret: bytestring; sent verbatim (over TLS) to client
175
host: string; available for use by the checker command
176
created: datetime.datetime(); object creation, not client host
177
last_checked_ok: datetime.datetime() or None if not yet checked OK
178
timeout: datetime.timedelta(); How long from last_checked_ok
179
until this client is invalid
180
interval: datetime.timedelta(); How often to start a new checker
181
stop_hook: If set, called by stop() as stop_hook(self)
182
checker: subprocess.Popen(); a running checker process used
183
to see if the client lives.
184
'None' if no process is running.
185
checker_initiator_tag: a gobject event source tag, or None
186
stop_initiator_tag: - '' -
187
checker_callback_tag: - '' -
188
checker_command: string; External command which is run to check if
189
client lives. %() expansions are done at
844
190
runtime with vars(self) as dict, so that for
845
191
instance %(name)s can be used in the command.
846
checker_initiator_tag: a GLib event source tag, or None
847
created: datetime.datetime(); (UTC) object creation
848
client_structure: Object describing what attributes a client has
849
and is used for storing the client at exit
850
current_checker_command: string; current running checker_command
851
disable_initiator_tag: a GLib event source tag, or None
853
fingerprint: string (40 or 32 hexadecimal digits); used to
854
uniquely identify an OpenPGP client
855
key_id: string (64 hexadecimal digits); used to uniquely identify
856
a client using raw public keys
857
host: string; available for use by the checker command
858
interval: datetime.timedelta(); How often to start a new checker
859
last_approval_request: datetime.datetime(); (UTC) or None
860
last_checked_ok: datetime.datetime(); (UTC) or None
861
last_checker_status: integer between 0 and 255 reflecting exit
862
status of last checker. -1 reflects crashed
863
checker, -2 means no checker completed yet.
864
last_checker_signal: The signal which killed the last checker, if
865
last_checker_status is -1
866
last_enabled: datetime.datetime(); (UTC) or None
867
name: string; from the config file, used in log messages and
869
secret: bytestring; sent verbatim (over TLS) to client
870
timeout: datetime.timedelta(); How long from last_checked_ok
871
until this client is disabled
872
extended_timeout: extra long timeout when secret has been sent
873
runtime_expansions: Allowed attributes for runtime expansion.
874
expires: datetime.datetime(); time (UTC) when a client will be
876
server_settings: The server_settings dict from main()
193
_timeout: Real variable for 'timeout'
194
_interval: Real variable for 'interval'
195
_timeout_milliseconds: Used when calling gobject.timeout_add()
196
_interval_milliseconds: - '' -
879
runtime_expansions = ("approval_delay", "approval_duration",
880
"created", "enabled", "expires", "key_id",
881
"fingerprint", "host", "interval",
882
"last_approval_request", "last_checked_ok",
883
"last_enabled", "name", "timeout")
886
"extended_timeout": "PT15M",
888
"checker": "fping -q -- %%(host)s",
890
"approval_delay": "PT0S",
891
"approval_duration": "PT1S",
892
"approved_by_default": "True",
897
def config_parser(config):
898
"""Construct a new dict of client settings of this form:
899
{ client_name: {setting_name: value, ...}, ...}
900
with exceptions for any special settings as defined above.
901
NOTE: Must be a pure function. Must return the same result
902
value given the same arguments.
905
for client_name in config.sections():
906
section = dict(config.items(client_name))
907
client = settings[client_name] = {}
909
client["host"] = section["host"]
910
# Reformat values from string types to Python types
911
client["approved_by_default"] = config.getboolean(
912
client_name, "approved_by_default")
913
client["enabled"] = config.getboolean(client_name,
916
# Uppercase and remove spaces from key_id and fingerprint
917
# for later comparison purposes with return value from the
918
# key_id() and fingerprint() functions
919
client["key_id"] = (section.get("key_id", "").upper()
921
client["fingerprint"] = (section["fingerprint"].upper()
923
if "secret" in section:
924
client["secret"] = codecs.decode(section["secret"]
927
elif "secfile" in section:
928
with open(os.path.expanduser(os.path.expandvars
929
(section["secfile"])),
931
client["secret"] = secfile.read()
933
raise TypeError("No secret or secfile for section {}"
935
client["timeout"] = string_to_delta(section["timeout"])
936
client["extended_timeout"] = string_to_delta(
937
section["extended_timeout"])
938
client["interval"] = string_to_delta(section["interval"])
939
client["approval_delay"] = string_to_delta(
940
section["approval_delay"])
941
client["approval_duration"] = string_to_delta(
942
section["approval_duration"])
943
client["checker_command"] = section["checker"]
944
client["last_approval_request"] = None
945
client["last_checked_ok"] = None
946
client["last_checker_status"] = -2
950
def __init__(self, settings, name=None, server_settings=None):
198
def _set_timeout(self, timeout):
199
"Setter function for 'timeout' attribute"
200
self._timeout = timeout
201
self._timeout_milliseconds = ((self.timeout.days
202
* 24 * 60 * 60 * 1000)
203
+ (self.timeout.seconds * 1000)
204
+ (self.timeout.microseconds
206
timeout = property(lambda self: self._timeout,
209
def _set_interval(self, interval):
210
"Setter function for 'interval' attribute"
211
self._interval = interval
212
self._interval_milliseconds = ((self.interval.days
213
* 24 * 60 * 60 * 1000)
214
+ (self.interval.seconds
216
+ (self.interval.microseconds
218
interval = property(lambda self: self._interval,
221
def __init__(self, name = None, stop_hook=None, config={}):
222
"""Note: the 'checker' key in 'config' sets the
223
'checker_command' attribute and *not* the 'checker'
952
if server_settings is None:
954
self.server_settings = server_settings
955
# adding all client settings
956
for setting, value in settings.items():
957
setattr(self, setting, value)
960
if not hasattr(self, "last_enabled"):
961
self.last_enabled = datetime.datetime.utcnow()
962
if not hasattr(self, "expires"):
963
self.expires = (datetime.datetime.utcnow()
226
logger.debug(u"Creating client %r", self.name)
227
# Uppercase and remove spaces from fingerprint for later
228
# comparison purposes with return value from the fingerprint()
230
self.fingerprint = config["fingerprint"].upper()\
232
logger.debug(u" Fingerprint: %s", self.fingerprint)
233
if "secret" in config:
234
self.secret = config["secret"].decode(u"base64")
235
elif "secfile" in config:
236
sf = open(config["secfile"])
237
self.secret = sf.read()
966
self.last_enabled = None
969
logger.debug("Creating client %r", self.name)
970
logger.debug(" Key ID: %s", self.key_id)
971
logger.debug(" Fingerprint: %s", self.fingerprint)
972
self.created = settings.get("created",
973
datetime.datetime.utcnow())
975
# attributes specific for this server instance
240
raise TypeError(u"No secret or secfile for client %s"
242
self.host = config.get("host", "")
243
self.created = datetime.datetime.now()
244
self.last_checked_ok = None
245
self.timeout = string_to_delta(config["timeout"])
246
self.interval = string_to_delta(config["interval"])
247
self.stop_hook = stop_hook
976
248
self.checker = None
977
249
self.checker_initiator_tag = None
978
self.disable_initiator_tag = None
250
self.stop_initiator_tag = None
979
251
self.checker_callback_tag = None
980
self.current_checker_command = None
982
self.approvals_pending = 0
983
self.changedstate = multiprocessing_manager.Condition(
984
multiprocessing_manager.Lock())
985
self.client_structure = [attr
986
for attr in self.__dict__.keys()
987
if not attr.startswith("_")]
988
self.client_structure.append("client_structure")
990
for name, t in inspect.getmembers(
991
type(self), lambda obj: isinstance(obj, property)):
992
if not name.startswith("_"):
993
self.client_structure.append(name)
995
# Send notice to process children that client state has changed
996
def send_changedstate(self):
997
with self.changedstate:
998
self.changedstate.notify_all()
252
self.check_command = config["checker"]
1001
254
"""Start this client's checker and timeout hooks"""
1002
if getattr(self, "enabled", False):
1005
self.expires = datetime.datetime.utcnow() + self.timeout
1007
self.last_enabled = datetime.datetime.utcnow()
1009
self.send_changedstate()
1011
def disable(self, quiet=True):
1012
"""Disable this client."""
1013
if not getattr(self, "enabled", False):
1016
logger.info("Disabling client %s", self.name)
1017
if getattr(self, "disable_initiator_tag", None) is not None:
1018
GLib.source_remove(self.disable_initiator_tag)
1019
self.disable_initiator_tag = None
1021
if getattr(self, "checker_initiator_tag", None) is not None:
1022
GLib.source_remove(self.checker_initiator_tag)
1023
self.checker_initiator_tag = None
1025
self.enabled = False
1027
self.send_changedstate()
1028
# Do not run this again if called by a GLib.timeout_add
1034
def init_checker(self):
1035
255
# Schedule a new checker to be started an 'interval' from now,
1036
256
# and every interval from then on.
1037
if self.checker_initiator_tag is not None:
1038
GLib.source_remove(self.checker_initiator_tag)
1039
self.checker_initiator_tag = GLib.timeout_add(
1040
int(self.interval.total_seconds() * 1000),
1042
# Schedule a disable() when 'timeout' has passed
1043
if self.disable_initiator_tag is not None:
1044
GLib.source_remove(self.disable_initiator_tag)
1045
self.disable_initiator_tag = GLib.timeout_add(
1046
int(self.timeout.total_seconds() * 1000), self.disable)
257
self.checker_initiator_tag = gobject.timeout_add\
258
(self._interval_milliseconds,
1047
260
# Also start a new checker *right now*.
1048
261
self.start_checker()
1050
def checker_callback(self, source, condition, connection,
262
# Schedule a stop() when 'timeout' has passed
263
self.stop_initiator_tag = gobject.timeout_add\
264
(self._timeout_milliseconds,
268
The possibility that a client might be restarted is left open,
269
but not currently used."""
270
# If this client doesn't have a secret, it is already stopped.
271
if hasattr(self, "secret") and self.secret:
272
logger.info(u"Stopping client %s", self.name)
276
if getattr(self, "stop_initiator_tag", False):
277
gobject.source_remove(self.stop_initiator_tag)
278
self.stop_initiator_tag = None
279
if getattr(self, "checker_initiator_tag", False):
280
gobject.source_remove(self.checker_initiator_tag)
281
self.checker_initiator_tag = None
285
# Do not run this again if called by a gobject.timeout_add
288
self.stop_hook = None
290
def checker_callback(self, pid, condition):
1052
291
"""The checker has completed, so take appropriate actions."""
1053
# Read return code from connection (see call_pipe)
1054
returncode = connection.recv()
292
now = datetime.datetime.now()
1057
293
self.checker_callback_tag = None
1058
294
self.checker = None
1061
self.last_checker_status = returncode
1062
self.last_checker_signal = None
1063
if self.last_checker_status == 0:
1064
logger.info("Checker for %(name)s succeeded",
1068
logger.info("Checker for %(name)s failed", vars(self))
1070
self.last_checker_status = -1
1071
self.last_checker_signal = -returncode
1072
logger.warning("Checker for %(name)s crashed?",
295
if os.WIFEXITED(condition) \
296
and (os.WEXITSTATUS(condition) == 0):
297
logger.info(u"Checker for %(name)s succeeded",
299
self.last_checked_ok = now
300
gobject.source_remove(self.stop_initiator_tag)
301
self.stop_initiator_tag = gobject.timeout_add\
302
(self._timeout_milliseconds,
304
elif not os.WIFEXITED(condition):
305
logger.warning(u"Checker for %(name)s crashed?",
1076
def checked_ok(self):
1077
"""Assert that the client has been seen, alive and well."""
1078
self.last_checked_ok = datetime.datetime.utcnow()
1079
self.last_checker_status = 0
1080
self.last_checker_signal = None
1083
def bump_timeout(self, timeout=None):
1084
"""Bump up the timeout for this client."""
1086
timeout = self.timeout
1087
if self.disable_initiator_tag is not None:
1088
GLib.source_remove(self.disable_initiator_tag)
1089
self.disable_initiator_tag = None
1090
if getattr(self, "enabled", False):
1091
self.disable_initiator_tag = GLib.timeout_add(
1092
int(timeout.total_seconds() * 1000), self.disable)
1093
self.expires = datetime.datetime.utcnow() + timeout
1095
def need_approval(self):
1096
self.last_approval_request = datetime.datetime.utcnow()
308
logger.info(u"Checker for %(name)s failed",
1098
310
def start_checker(self):
1099
311
"""Start a new checker subprocess if one is not running.
1101
312
If a checker already exists, leave it running and do
1103
314
# The reason for not killing a running checker is that if we
1104
# did that, and if a checker (for some reason) started running
1105
# slowly and taking more than 'interval' time, then the client
1106
# would inevitably timeout, since no checker would get a
1107
# chance to run to completion. If we instead leave running
315
# did that, then if a checker (for some reason) started
316
# running slowly and taking more than 'interval' time, the
317
# client would inevitably timeout, since no checker would get
318
# a chance to run to completion. If we instead leave running
1108
319
# checkers alone, the checker would have to take more time
1109
# than 'timeout' for the client to be disabled, which is as it
1112
if self.checker is not None and not self.checker.is_alive():
1113
logger.warning("Checker was not alive; joining")
1116
# Start a new checker if needed
320
# than 'timeout' for the client to be declared invalid, which
321
# is as it should be.
1117
322
if self.checker is None:
1118
# Escape attributes for the shell
1120
attr: re.escape(str(getattr(self, attr)))
1121
for attr in self.runtime_expansions}
1123
command = self.checker_command % escaped_attrs
1124
except TypeError as error:
1125
logger.error('Could not format string "%s"',
1126
self.checker_command,
1128
return True # Try again later
1129
self.current_checker_command = command
1130
logger.info("Starting checker %r for %s", command,
1132
# We don't need to redirect stdout and stderr, since
1133
# in normal mode, that is already done by daemon(),
1134
# and in debug mode we don't want to. (Stdin is
1135
# always replaced by /dev/null.)
1136
# The exception is when not debugging but nevertheless
1137
# running in the foreground; use the previously
1139
popen_args = {"close_fds": True,
1142
if (not self.server_settings["debug"]
1143
and self.server_settings["foreground"]):
1144
popen_args.update({"stdout": wnull,
1146
pipe = multiprocessing.Pipe(duplex=False)
1147
self.checker = multiprocessing.Process(
1149
args=(pipe[1], subprocess.call, command),
1151
self.checker.start()
1152
self.checker_callback_tag = GLib.io_add_watch(
1153
pipe[0].fileno(), GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1154
self.checker_callback, pipe[0], command)
1155
# Re-run this periodically if run by GLib.timeout_add
324
# In case check_command has exactly one % operator
325
command = self.check_command % self.host
327
# Escape attributes for the shell
328
escaped_attrs = dict((key, re.escape(str(val)))
330
vars(self).iteritems())
332
command = self.check_command % escaped_attrs
333
except TypeError, error:
334
logger.error(u'Could not format string "%s":'
335
u' %s', self.check_command, error)
336
return True # Try again later
338
logger.info(u"Starting checker %r for %s",
340
self.checker = subprocess.Popen(command,
343
self.checker_callback_tag = gobject.child_watch_add\
345
self.checker_callback)
346
except subprocess.OSError, error:
347
logger.error(u"Failed to start subprocess: %s",
349
# Re-run this periodically if run by gobject.timeout_add
1158
351
def stop_checker(self):
1159
352
"""Force the checker process, if any, to stop."""
1160
353
if self.checker_callback_tag:
1161
GLib.source_remove(self.checker_callback_tag)
354
gobject.source_remove(self.checker_callback_tag)
1162
355
self.checker_callback_tag = None
1163
356
if getattr(self, "checker", None) is None:
1165
logger.debug("Stopping checker for %(name)s", vars(self))
1166
self.checker.terminate()
358
logger.debug(u"Stopping checker for %(name)s", vars(self))
360
os.kill(self.checker.pid, signal.SIGTERM)
362
#if self.checker.poll() is None:
363
# os.kill(self.checker.pid, signal.SIGKILL)
364
except OSError, error:
365
if error.errno != errno.ESRCH: # No such process
1167
367
self.checker = None
1170
def dbus_service_property(dbus_interface,
1174
"""Decorators for marking methods of a DBusObjectWithProperties to
1175
become properties on the D-Bus.
1177
The decorated method will be called with no arguments by "Get"
1178
and with one argument by "Set".
1180
The parameters, where they are supported, are the same as
1181
dbus.service.method, except there is only "signature", since the
1182
type from Get() and the type sent to Set() is the same.
1184
# Encoding deeply encoded byte arrays is not supported yet by the
1185
# "Set" method, so we fail early here:
1186
if byte_arrays and signature != "ay":
1187
raise ValueError("Byte arrays not supported for non-'ay'"
1188
" signature {!r}".format(signature))
1190
def decorator(func):
1191
func._dbus_is_property = True
1192
func._dbus_interface = dbus_interface
1193
func._dbus_signature = signature
1194
func._dbus_access = access
1195
func._dbus_name = func.__name__
1196
if func._dbus_name.endswith("_dbus_property"):
1197
func._dbus_name = func._dbus_name[:-14]
1198
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1204
def dbus_interface_annotations(dbus_interface):
1205
"""Decorator for marking functions returning interface annotations
1209
@dbus_interface_annotations("org.example.Interface")
1210
def _foo(self): # Function name does not matter
1211
return {"org.freedesktop.DBus.Deprecated": "true",
1212
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1216
def decorator(func):
1217
func._dbus_is_interface = True
1218
func._dbus_interface = dbus_interface
1219
func._dbus_name = dbus_interface
1225
def dbus_annotations(annotations):
1226
"""Decorator to annotate D-Bus methods, signals or properties
1229
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1230
"org.freedesktop.DBus.Property."
1231
"EmitsChangedSignal": "false"})
1232
@dbus_service_property("org.example.Interface", signature="b",
1234
def Property_dbus_property(self):
1235
return dbus.Boolean(False)
1237
See also the DBusObjectWithAnnotations class.
1240
def decorator(func):
1241
func._dbus_annotations = annotations
1247
class DBusPropertyException(dbus.exceptions.DBusException):
1248
"""A base class for D-Bus property-related exceptions
1253
class DBusPropertyAccessException(DBusPropertyException):
1254
"""A property's access permissions disallows an operation.
1259
class DBusPropertyNotFound(DBusPropertyException):
1260
"""An attempt was made to access a non-existing property.
1265
class DBusObjectWithAnnotations(dbus.service.Object):
1266
"""A D-Bus object with annotations.
1268
Classes inheriting from this can use the dbus_annotations
1269
decorator to add annotations to methods or signals.
1273
def _is_dbus_thing(thing):
1274
"""Returns a function testing if an attribute is a D-Bus thing
1276
If called like _is_dbus_thing("method") it returns a function
1277
suitable for use as predicate to inspect.getmembers().
1279
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1282
def _get_all_dbus_things(self, thing):
1283
"""Returns a generator of (name, attribute) pairs
1285
return ((getattr(athing.__get__(self), "_dbus_name", name),
1286
athing.__get__(self))
1287
for cls in self.__class__.__mro__
1289
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1291
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1293
path_keyword='object_path',
1294
connection_keyword='connection')
1295
def Introspect(self, object_path, connection):
1296
"""Overloading of standard D-Bus method.
1298
Inserts annotation tags on methods and signals.
1300
xmlstring = dbus.service.Object.Introspect(self, object_path,
1303
document = xml.dom.minidom.parseString(xmlstring)
1305
for if_tag in document.getElementsByTagName("interface"):
1306
# Add annotation tags
1307
for typ in ("method", "signal"):
1308
for tag in if_tag.getElementsByTagName(typ):
1310
for name, prop in (self.
1311
_get_all_dbus_things(typ)):
1312
if (name == tag.getAttribute("name")
1313
and prop._dbus_interface
1314
== if_tag.getAttribute("name")):
1315
annots.update(getattr(
1316
prop, "_dbus_annotations", {}))
1317
for name, value in annots.items():
1318
ann_tag = document.createElement(
1320
ann_tag.setAttribute("name", name)
1321
ann_tag.setAttribute("value", value)
1322
tag.appendChild(ann_tag)
1323
# Add interface annotation tags
1324
for annotation, value in dict(
1325
itertools.chain.from_iterable(
1326
annotations().items()
1327
for name, annotations
1328
in self._get_all_dbus_things("interface")
1329
if name == if_tag.getAttribute("name")
1331
ann_tag = document.createElement("annotation")
1332
ann_tag.setAttribute("name", annotation)
1333
ann_tag.setAttribute("value", value)
1334
if_tag.appendChild(ann_tag)
1335
# Fix argument name for the Introspect method itself
1336
if (if_tag.getAttribute("name")
1337
== dbus.INTROSPECTABLE_IFACE):
1338
for cn in if_tag.getElementsByTagName("method"):
1339
if cn.getAttribute("name") == "Introspect":
1340
for arg in cn.getElementsByTagName("arg"):
1341
if (arg.getAttribute("direction")
1343
arg.setAttribute("name",
1345
xmlstring = document.toxml("utf-8")
1347
except (AttributeError, xml.dom.DOMException,
1348
xml.parsers.expat.ExpatError) as error:
1349
logger.error("Failed to override Introspection method",
1354
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1355
"""A D-Bus object with properties.
1357
Classes inheriting from this can use the dbus_service_property
1358
decorator to expose methods as D-Bus properties. It exposes the
1359
standard Get(), Set(), and GetAll() methods on the D-Bus.
1362
def _get_dbus_property(self, interface_name, property_name):
1363
"""Returns a bound method if one exists which is a D-Bus
1364
property with the specified name and interface.
1366
for cls in self.__class__.__mro__:
1367
for name, value in inspect.getmembers(
1368
cls, self._is_dbus_thing("property")):
1369
if (value._dbus_name == property_name
1370
and value._dbus_interface == interface_name):
1371
return value.__get__(self)
1374
raise DBusPropertyNotFound("{}:{}.{}".format(
1375
self.dbus_object_path, interface_name, property_name))
1378
def _get_all_interface_names(cls):
1379
"""Get a sequence of all interfaces supported by an object"""
1380
return (name for name in set(getattr(getattr(x, attr),
1381
"_dbus_interface", None)
1382
for x in (inspect.getmro(cls))
1384
if name is not None)
1386
@dbus.service.method(dbus.PROPERTIES_IFACE,
1389
def Get(self, interface_name, property_name):
1390
"""Standard D-Bus property Get() method, see D-Bus standard.
1392
prop = self._get_dbus_property(interface_name, property_name)
1393
if prop._dbus_access == "write":
1394
raise DBusPropertyAccessException(property_name)
1396
if not hasattr(value, "variant_level"):
1398
return type(value)(value, variant_level=value.variant_level+1)
1400
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
1401
def Set(self, interface_name, property_name, value):
1402
"""Standard D-Bus property Set() method, see D-Bus standard.
1404
prop = self._get_dbus_property(interface_name, property_name)
1405
if prop._dbus_access == "read":
1406
raise DBusPropertyAccessException(property_name)
1407
if prop._dbus_get_args_options["byte_arrays"]:
1408
# The byte_arrays option is not supported yet on
1409
# signatures other than "ay".
1410
if prop._dbus_signature != "ay":
1411
raise ValueError("Byte arrays not supported for non-"
1412
"'ay' signature {!r}"
1413
.format(prop._dbus_signature))
1414
value = dbus.ByteArray(b''.join(chr(byte)
1418
@dbus.service.method(dbus.PROPERTIES_IFACE,
1420
out_signature="a{sv}")
1421
def GetAll(self, interface_name):
1422
"""Standard D-Bus property GetAll() method, see D-Bus
1425
Note: Will not include properties with access="write".
1428
for name, prop in self._get_all_dbus_things("property"):
1430
and interface_name != prop._dbus_interface):
1431
# Interface non-empty but did not match
1433
# Ignore write-only properties
1434
if prop._dbus_access == "write":
1437
if not hasattr(value, "variant_level"):
1438
properties[name] = value
1440
properties[name] = type(value)(
1441
value, variant_level=value.variant_level + 1)
1442
return dbus.Dictionary(properties, signature="sv")
1444
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1445
def PropertiesChanged(self, interface_name, changed_properties,
1446
invalidated_properties):
1447
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
1452
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1454
path_keyword='object_path',
1455
connection_keyword='connection')
1456
def Introspect(self, object_path, connection):
1457
"""Overloading of standard D-Bus method.
1459
Inserts property tags and interface annotation tags.
1461
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1465
document = xml.dom.minidom.parseString(xmlstring)
1467
def make_tag(document, name, prop):
1468
e = document.createElement("property")
1469
e.setAttribute("name", name)
1470
e.setAttribute("type", prop._dbus_signature)
1471
e.setAttribute("access", prop._dbus_access)
1474
for if_tag in document.getElementsByTagName("interface"):
1476
for tag in (make_tag(document, name, prop)
1478
in self._get_all_dbus_things("property")
1479
if prop._dbus_interface
1480
== if_tag.getAttribute("name")):
1481
if_tag.appendChild(tag)
1482
# Add annotation tags for properties
1483
for tag in if_tag.getElementsByTagName("property"):
1485
for name, prop in self._get_all_dbus_things(
1487
if (name == tag.getAttribute("name")
1488
and prop._dbus_interface
1489
== if_tag.getAttribute("name")):
1490
annots.update(getattr(
1491
prop, "_dbus_annotations", {}))
1492
for name, value in annots.items():
1493
ann_tag = document.createElement(
1495
ann_tag.setAttribute("name", name)
1496
ann_tag.setAttribute("value", value)
1497
tag.appendChild(ann_tag)
1498
# Add the names to the return values for the
1499
# "org.freedesktop.DBus.Properties" methods
1500
if (if_tag.getAttribute("name")
1501
== "org.freedesktop.DBus.Properties"):
1502
for cn in if_tag.getElementsByTagName("method"):
1503
if cn.getAttribute("name") == "Get":
1504
for arg in cn.getElementsByTagName("arg"):
1505
if (arg.getAttribute("direction")
1507
arg.setAttribute("name", "value")
1508
elif cn.getAttribute("name") == "GetAll":
1509
for arg in cn.getElementsByTagName("arg"):
1510
if (arg.getAttribute("direction")
1512
arg.setAttribute("name", "props")
1513
xmlstring = document.toxml("utf-8")
1515
except (AttributeError, xml.dom.DOMException,
1516
xml.parsers.expat.ExpatError) as error:
1517
logger.error("Failed to override Introspection method",
1523
dbus.OBJECT_MANAGER_IFACE
1524
except AttributeError:
1525
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1528
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1529
"""A D-Bus object with an ObjectManager.
1531
Classes inheriting from this exposes the standard
1532
GetManagedObjects call and the InterfacesAdded and
1533
InterfacesRemoved signals on the standard
1534
"org.freedesktop.DBus.ObjectManager" interface.
1536
Note: No signals are sent automatically; they must be sent
1539
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1540
out_signature="a{oa{sa{sv}}}")
1541
def GetManagedObjects(self):
1542
"""This function must be overridden"""
1543
raise NotImplementedError()
1545
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1546
signature="oa{sa{sv}}")
1547
def InterfacesAdded(self, object_path, interfaces_and_properties):
1550
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1551
def InterfacesRemoved(self, object_path, interfaces):
1554
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1556
path_keyword='object_path',
1557
connection_keyword='connection')
1558
def Introspect(self, object_path, connection):
1559
"""Overloading of standard D-Bus method.
1561
Override return argument name of GetManagedObjects to be
1562
"objpath_interfaces_and_properties"
1564
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1568
document = xml.dom.minidom.parseString(xmlstring)
1570
for if_tag in document.getElementsByTagName("interface"):
1571
# Fix argument name for the GetManagedObjects method
1572
if (if_tag.getAttribute("name")
1573
== dbus.OBJECT_MANAGER_IFACE):
1574
for cn in if_tag.getElementsByTagName("method"):
1575
if (cn.getAttribute("name")
1576
== "GetManagedObjects"):
1577
for arg in cn.getElementsByTagName("arg"):
1578
if (arg.getAttribute("direction")
1582
"objpath_interfaces"
1584
xmlstring = document.toxml("utf-8")
1586
except (AttributeError, xml.dom.DOMException,
1587
xml.parsers.expat.ExpatError) as error:
1588
logger.error("Failed to override Introspection method",
1593
def datetime_to_dbus(dt, variant_level=0):
1594
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1596
return dbus.String("", variant_level=variant_level)
1597
return dbus.String(dt.isoformat(), variant_level=variant_level)
1600
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1601
"""A class decorator; applied to a subclass of
1602
dbus.service.Object, it will add alternate D-Bus attributes with
1603
interface names according to the "alt_interface_names" mapping.
1606
@alternate_dbus_interfaces({"org.example.Interface":
1607
"net.example.AlternateInterface"})
1608
class SampleDBusObject(dbus.service.Object):
1609
@dbus.service.method("org.example.Interface")
1610
def SampleDBusMethod():
1613
The above "SampleDBusMethod" on "SampleDBusObject" will be
1614
reachable via two interfaces: "org.example.Interface" and
1615
"net.example.AlternateInterface", the latter of which will have
1616
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1617
"true", unless "deprecate" is passed with a False value.
1619
This works for methods and signals, and also for D-Bus properties
1620
(from DBusObjectWithProperties) and interfaces (from the
1621
dbus_interface_annotations decorator).
1625
for orig_interface_name, alt_interface_name in (
1626
alt_interface_names.items()):
1628
interface_names = set()
1629
# Go though all attributes of the class
1630
for attrname, attribute in inspect.getmembers(cls):
1631
# Ignore non-D-Bus attributes, and D-Bus attributes
1632
# with the wrong interface name
1633
if (not hasattr(attribute, "_dbus_interface")
1634
or not attribute._dbus_interface.startswith(
1635
orig_interface_name)):
1637
# Create an alternate D-Bus interface name based on
1639
alt_interface = attribute._dbus_interface.replace(
1640
orig_interface_name, alt_interface_name)
1641
interface_names.add(alt_interface)
1642
# Is this a D-Bus signal?
1643
if getattr(attribute, "_dbus_is_signal", False):
1644
# Extract the original non-method undecorated
1645
# function by black magic
1646
if sys.version_info.major == 2:
1647
nonmethod_func = (dict(
1648
zip(attribute.func_code.co_freevars,
1649
attribute.__closure__))
1650
["func"].cell_contents)
1652
nonmethod_func = (dict(
1653
zip(attribute.__code__.co_freevars,
1654
attribute.__closure__))
1655
["func"].cell_contents)
1656
# Create a new, but exactly alike, function
1657
# object, and decorate it to be a new D-Bus signal
1658
# with the alternate D-Bus interface name
1659
new_function = copy_function(nonmethod_func)
1660
new_function = (dbus.service.signal(
1662
attribute._dbus_signature)(new_function))
1663
# Copy annotations, if any
1665
new_function._dbus_annotations = dict(
1666
attribute._dbus_annotations)
1667
except AttributeError:
1670
# Define a creator of a function to call both the
1671
# original and alternate functions, so both the
1672
# original and alternate signals gets sent when
1673
# the function is called
1674
def fixscope(func1, func2):
1675
"""This function is a scope container to pass
1676
func1 and func2 to the "call_both" function
1677
outside of its arguments"""
1679
@functools.wraps(func2)
1680
def call_both(*args, **kwargs):
1681
"""This function will emit two D-Bus
1682
signals by calling func1 and func2"""
1683
func1(*args, **kwargs)
1684
func2(*args, **kwargs)
1685
# Make wrapper function look like a D-Bus
1687
for name, attr in inspect.getmembers(func2):
1688
if name.startswith("_dbus_"):
1689
setattr(call_both, name, attr)
1692
# Create the "call_both" function and add it to
1694
attr[attrname] = fixscope(attribute, new_function)
1695
# Is this a D-Bus method?
1696
elif getattr(attribute, "_dbus_is_method", False):
1697
# Create a new, but exactly alike, function
1698
# object. Decorate it to be a new D-Bus method
1699
# with the alternate D-Bus interface name. Add it
1702
dbus.service.method(
1704
attribute._dbus_in_signature,
1705
attribute._dbus_out_signature)
1706
(copy_function(attribute)))
1707
# Copy annotations, if any
1709
attr[attrname]._dbus_annotations = dict(
1710
attribute._dbus_annotations)
1711
except AttributeError:
1713
# Is this a D-Bus property?
1714
elif getattr(attribute, "_dbus_is_property", False):
1715
# Create a new, but exactly alike, function
1716
# object, and decorate it to be a new D-Bus
1717
# property with the alternate D-Bus interface
1718
# name. Add it to the class.
1719
attr[attrname] = (dbus_service_property(
1720
alt_interface, attribute._dbus_signature,
1721
attribute._dbus_access,
1722
attribute._dbus_get_args_options
1724
(copy_function(attribute)))
1725
# Copy annotations, if any
1727
attr[attrname]._dbus_annotations = dict(
1728
attribute._dbus_annotations)
1729
except AttributeError:
1731
# Is this a D-Bus interface?
1732
elif getattr(attribute, "_dbus_is_interface", False):
1733
# Create a new, but exactly alike, function
1734
# object. Decorate it to be a new D-Bus interface
1735
# with the alternate D-Bus interface name. Add it
1738
dbus_interface_annotations(alt_interface)
1739
(copy_function(attribute)))
1741
# Deprecate all alternate interfaces
1742
iname = "_AlternateDBusNames_interface_annotation{}"
1743
for interface_name in interface_names:
1745
@dbus_interface_annotations(interface_name)
1747
return {"org.freedesktop.DBus.Deprecated":
1749
# Find an unused name
1750
for aname in (iname.format(i)
1751
for i in itertools.count()):
1752
if aname not in attr:
1756
# Replace the class with a new subclass of it with
1757
# methods, signals, etc. as created above.
1758
if sys.version_info.major == 2:
1759
cls = type(b"{}Alternate".format(cls.__name__),
1762
cls = type("{}Alternate".format(cls.__name__),
1769
@alternate_dbus_interfaces({"se.recompile.Mandos":
1770
"se.bsnet.fukt.Mandos"})
1771
class ClientDBus(Client, DBusObjectWithProperties):
1772
"""A Client class using D-Bus
1775
dbus_object_path: dbus.ObjectPath
1776
bus: dbus.SystemBus()
1779
runtime_expansions = (Client.runtime_expansions
1780
+ ("dbus_object_path", ))
1782
_interface = "se.recompile.Mandos.Client"
1784
# dbus.service.Object doesn't use super(), so we can't either.
1786
def __init__(self, bus=None, *args, **kwargs):
1788
Client.__init__(self, *args, **kwargs)
1789
# Only now, when this client is initialized, can it show up on
1791
client_object_name = str(self.name).translate(
1792
{ord("."): ord("_"),
1793
ord("-"): ord("_")})
1794
self.dbus_object_path = dbus.ObjectPath(
1795
"/clients/" + client_object_name)
1796
DBusObjectWithProperties.__init__(self, self.bus,
1797
self.dbus_object_path)
1799
def notifychangeproperty(transform_func, dbus_name,
1800
type_func=lambda x: x,
1802
invalidate_only=False,
1803
_interface=_interface):
1804
""" Modify a variable so that it's a property which announces
1805
its changes to DBus.
1807
transform_fun: Function that takes a value and a variant_level
1808
and transforms it to a D-Bus type.
1809
dbus_name: D-Bus name of the variable
1810
type_func: Function that transform the value before sending it
1811
to the D-Bus. Default: no transform
1812
variant_level: D-Bus variant level. Default: 1
1814
attrname = "_{}".format(dbus_name)
1816
def setter(self, value):
1817
if hasattr(self, "dbus_object_path"):
1818
if (not hasattr(self, attrname) or
1819
type_func(getattr(self, attrname, None))
1820
!= type_func(value)):
1822
self.PropertiesChanged(
1823
_interface, dbus.Dictionary(),
1824
dbus.Array((dbus_name, )))
1826
dbus_value = transform_func(
1828
variant_level=variant_level)
1829
self.PropertyChanged(dbus.String(dbus_name),
1831
self.PropertiesChanged(
1833
dbus.Dictionary({dbus.String(dbus_name):
1836
setattr(self, attrname, value)
1838
return property(lambda self: getattr(self, attrname), setter)
1840
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1841
approvals_pending = notifychangeproperty(dbus.Boolean,
1844
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1845
last_enabled = notifychangeproperty(datetime_to_dbus,
1847
checker = notifychangeproperty(
1848
dbus.Boolean, "CheckerRunning",
1849
type_func=lambda checker: checker is not None)
1850
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1852
last_checker_status = notifychangeproperty(dbus.Int16,
1853
"LastCheckerStatus")
1854
last_approval_request = notifychangeproperty(
1855
datetime_to_dbus, "LastApprovalRequest")
1856
approved_by_default = notifychangeproperty(dbus.Boolean,
1857
"ApprovedByDefault")
1858
approval_delay = notifychangeproperty(
1859
dbus.UInt64, "ApprovalDelay",
1860
type_func=lambda td: td.total_seconds() * 1000)
1861
approval_duration = notifychangeproperty(
1862
dbus.UInt64, "ApprovalDuration",
1863
type_func=lambda td: td.total_seconds() * 1000)
1864
host = notifychangeproperty(dbus.String, "Host")
1865
timeout = notifychangeproperty(
1866
dbus.UInt64, "Timeout",
1867
type_func=lambda td: td.total_seconds() * 1000)
1868
extended_timeout = notifychangeproperty(
1869
dbus.UInt64, "ExtendedTimeout",
1870
type_func=lambda td: td.total_seconds() * 1000)
1871
interval = notifychangeproperty(
1872
dbus.UInt64, "Interval",
1873
type_func=lambda td: td.total_seconds() * 1000)
1874
checker_command = notifychangeproperty(dbus.String, "Checker")
1875
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1876
invalidate_only=True)
1878
del notifychangeproperty
1880
def __del__(self, *args, **kwargs):
1882
self.remove_from_connection()
1885
if hasattr(DBusObjectWithProperties, "__del__"):
1886
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1887
Client.__del__(self, *args, **kwargs)
1889
def checker_callback(self, source, condition,
1890
connection, command, *args, **kwargs):
1891
ret = Client.checker_callback(self, source, condition,
1892
connection, command, *args,
1894
exitstatus = self.last_checker_status
1897
self.CheckerCompleted(dbus.Int16(exitstatus),
1898
# This is specific to GNU libC
1899
dbus.Int64(exitstatus << 8),
1900
dbus.String(command))
1903
self.CheckerCompleted(dbus.Int16(-1),
1905
# This is specific to GNU libC
1907
| self.last_checker_signal),
1908
dbus.String(command))
1911
def start_checker(self, *args, **kwargs):
1912
old_checker_pid = getattr(self.checker, "pid", None)
1913
r = Client.start_checker(self, *args, **kwargs)
1914
# Only if new checker process was started
1915
if (self.checker is not None
1916
and old_checker_pid != self.checker.pid):
1918
self.CheckerStarted(self.current_checker_command)
1921
def _reset_approved(self):
1922
self.approved = None
1925
def approve(self, value=True):
1926
self.approved = value
1927
GLib.timeout_add(int(self.approval_duration.total_seconds()
1928
* 1000), self._reset_approved)
1929
self.send_changedstate()
1931
# D-Bus methods, signals & properties
1937
# CheckerCompleted - signal
1938
@dbus.service.signal(_interface, signature="nxs")
1939
def CheckerCompleted(self, exitcode, waitstatus, command):
1943
# CheckerStarted - signal
1944
@dbus.service.signal(_interface, signature="s")
1945
def CheckerStarted(self, command):
1949
# PropertyChanged - signal
1950
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1951
@dbus.service.signal(_interface, signature="sv")
1952
def PropertyChanged(self, property, value):
1956
# GotSecret - signal
1957
@dbus.service.signal(_interface)
1958
def GotSecret(self):
1960
Is sent after a successful transfer of secret from the Mandos
1961
server to mandos-client
1966
@dbus.service.signal(_interface, signature="s")
1967
def Rejected(self, reason):
1971
# NeedApproval - signal
1972
@dbus.service.signal(_interface, signature="tb")
1973
def NeedApproval(self, timeout, default):
1975
return self.need_approval()
1980
@dbus.service.method(_interface, in_signature="b")
1981
def Approve(self, value):
1984
# CheckedOK - method
1985
@dbus.service.method(_interface)
1986
def CheckedOK(self):
1990
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1991
@dbus.service.method(_interface)
1996
# StartChecker - method
1997
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1998
@dbus.service.method(_interface)
1999
def StartChecker(self):
2001
self.start_checker()
2004
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2005
@dbus.service.method(_interface)
2010
# StopChecker - method
2011
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2012
@dbus.service.method(_interface)
2013
def StopChecker(self):
2018
# ApprovalPending - property
2019
@dbus_service_property(_interface, signature="b", access="read")
2020
def ApprovalPending_dbus_property(self):
2021
return dbus.Boolean(bool(self.approvals_pending))
2023
# ApprovedByDefault - property
2024
@dbus_service_property(_interface,
2027
def ApprovedByDefault_dbus_property(self, value=None):
2028
if value is None: # get
2029
return dbus.Boolean(self.approved_by_default)
2030
self.approved_by_default = bool(value)
2032
# ApprovalDelay - property
2033
@dbus_service_property(_interface,
2036
def ApprovalDelay_dbus_property(self, value=None):
2037
if value is None: # get
2038
return dbus.UInt64(self.approval_delay.total_seconds()
2040
self.approval_delay = datetime.timedelta(0, 0, 0, value)
2042
# ApprovalDuration - property
2043
@dbus_service_property(_interface,
2046
def ApprovalDuration_dbus_property(self, value=None):
2047
if value is None: # get
2048
return dbus.UInt64(self.approval_duration.total_seconds()
2050
self.approval_duration = datetime.timedelta(0, 0, 0, value)
2054
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2055
@dbus_service_property(_interface, signature="s", access="read")
2056
def Name_dbus_property(self):
2057
return dbus.String(self.name)
2061
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2062
@dbus_service_property(_interface, signature="s", access="read")
2063
def KeyID_dbus_property(self):
2064
return dbus.String(self.key_id)
2066
# Fingerprint - property
2068
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2069
@dbus_service_property(_interface, signature="s", access="read")
2070
def Fingerprint_dbus_property(self):
2071
return dbus.String(self.fingerprint)
2074
@dbus_service_property(_interface,
2077
def Host_dbus_property(self, value=None):
2078
if value is None: # get
2079
return dbus.String(self.host)
2080
self.host = str(value)
2082
# Created - property
2084
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2085
@dbus_service_property(_interface, signature="s", access="read")
2086
def Created_dbus_property(self):
2087
return datetime_to_dbus(self.created)
2089
# LastEnabled - property
2090
@dbus_service_property(_interface, signature="s", access="read")
2091
def LastEnabled_dbus_property(self):
2092
return datetime_to_dbus(self.last_enabled)
2094
# Enabled - property
2095
@dbus_service_property(_interface,
2098
def Enabled_dbus_property(self, value=None):
2099
if value is None: # get
2100
return dbus.Boolean(self.enabled)
2106
# LastCheckedOK - property
2107
@dbus_service_property(_interface,
2110
def LastCheckedOK_dbus_property(self, value=None):
2111
if value is not None:
2114
return datetime_to_dbus(self.last_checked_ok)
2116
# LastCheckerStatus - property
2117
@dbus_service_property(_interface, signature="n", access="read")
2118
def LastCheckerStatus_dbus_property(self):
2119
return dbus.Int16(self.last_checker_status)
2121
# Expires - property
2122
@dbus_service_property(_interface, signature="s", access="read")
2123
def Expires_dbus_property(self):
2124
return datetime_to_dbus(self.expires)
2126
# LastApprovalRequest - property
2127
@dbus_service_property(_interface, signature="s", access="read")
2128
def LastApprovalRequest_dbus_property(self):
2129
return datetime_to_dbus(self.last_approval_request)
2131
# Timeout - property
2132
@dbus_service_property(_interface,
2135
def Timeout_dbus_property(self, value=None):
2136
if value is None: # get
2137
return dbus.UInt64(self.timeout.total_seconds() * 1000)
2138
old_timeout = self.timeout
2139
self.timeout = datetime.timedelta(0, 0, 0, value)
2140
# Reschedule disabling
2142
now = datetime.datetime.utcnow()
2143
self.expires += self.timeout - old_timeout
2144
if self.expires <= now:
2145
# The timeout has passed
2148
if (getattr(self, "disable_initiator_tag", None)
2151
GLib.source_remove(self.disable_initiator_tag)
2152
self.disable_initiator_tag = GLib.timeout_add(
2153
int((self.expires - now).total_seconds() * 1000),
2156
# ExtendedTimeout - property
2157
@dbus_service_property(_interface,
2160
def ExtendedTimeout_dbus_property(self, value=None):
2161
if value is None: # get
2162
return dbus.UInt64(self.extended_timeout.total_seconds()
2164
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2166
# Interval - property
2167
@dbus_service_property(_interface,
2170
def Interval_dbus_property(self, value=None):
2171
if value is None: # get
2172
return dbus.UInt64(self.interval.total_seconds() * 1000)
2173
self.interval = datetime.timedelta(0, 0, 0, value)
2174
if getattr(self, "checker_initiator_tag", None) is None:
2177
# Reschedule checker run
2178
GLib.source_remove(self.checker_initiator_tag)
2179
self.checker_initiator_tag = GLib.timeout_add(
2180
value, self.start_checker)
2181
self.start_checker() # Start one now, too
2183
# Checker - property
2184
@dbus_service_property(_interface,
2187
def Checker_dbus_property(self, value=None):
2188
if value is None: # get
2189
return dbus.String(self.checker_command)
2190
self.checker_command = str(value)
2192
# CheckerRunning - property
2193
@dbus_service_property(_interface,
2196
def CheckerRunning_dbus_property(self, value=None):
2197
if value is None: # get
2198
return dbus.Boolean(self.checker is not None)
2200
self.start_checker()
2204
# ObjectPath - property
2206
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2207
"org.freedesktop.DBus.Deprecated": "true"})
2208
@dbus_service_property(_interface, signature="o", access="read")
2209
def ObjectPath_dbus_property(self):
2210
return self.dbus_object_path # is already a dbus.ObjectPath
2214
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2216
@dbus_service_property(_interface,
2220
def Secret_dbus_property(self, value):
2221
self.secret = bytes(value)
2227
def __init__(self, child_pipe, key_id, fpr, address):
2228
self._pipe = child_pipe
2229
self._pipe.send(('init', key_id, fpr, address))
2230
if not self._pipe.recv():
2231
raise KeyError(key_id or fpr)
2233
def __getattribute__(self, name):
2235
return super(ProxyClient, self).__getattribute__(name)
2236
self._pipe.send(('getattr', name))
2237
data = self._pipe.recv()
2238
if data[0] == 'data':
2240
if data[0] == 'function':
2242
def func(*args, **kwargs):
2243
self._pipe.send(('funcall', name, args, kwargs))
2244
return self._pipe.recv()[1]
2248
def __setattr__(self, name, value):
2250
return super(ProxyClient, self).__setattr__(name, value)
2251
self._pipe.send(('setattr', name, value))
2254
class ClientHandler(socketserver.BaseRequestHandler, object):
2255
"""A class to handle client connections.
2257
Instantiated once for each connection to handle it.
368
def still_valid(self):
369
"""Has the timeout not yet passed for this client?"""
370
now = datetime.datetime.now()
371
if self.last_checked_ok is None:
372
return now < (self.created + self.timeout)
374
return now < (self.last_checked_ok + self.timeout)
377
def peer_certificate(session):
378
"Return the peer's OpenPGP certificate as a bytestring"
379
# If not an OpenPGP certificate...
380
if gnutls.library.functions.gnutls_certificate_type_get\
381
(session._c_object) \
382
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
383
# ...do the normal thing
384
return session.peer_certificate
385
list_size = ctypes.c_uint()
386
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
387
(session._c_object, ctypes.byref(list_size))
388
if list_size.value == 0:
391
return ctypes.string_at(cert.data, cert.size)
394
def fingerprint(openpgp):
395
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
396
# New GnuTLS "datum" with the OpenPGP public key
397
datum = gnutls.library.types.gnutls_datum_t\
398
(ctypes.cast(ctypes.c_char_p(openpgp),
399
ctypes.POINTER(ctypes.c_ubyte)),
400
ctypes.c_uint(len(openpgp)))
401
# New empty GnuTLS certificate
402
crt = gnutls.library.types.gnutls_openpgp_crt_t()
403
gnutls.library.functions.gnutls_openpgp_crt_init\
405
# Import the OpenPGP public key into the certificate
406
gnutls.library.functions.gnutls_openpgp_crt_import\
407
(crt, ctypes.byref(datum),
408
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
409
# New buffer for the fingerprint
410
buffer = ctypes.create_string_buffer(20)
411
buffer_length = ctypes.c_size_t()
412
# Get the fingerprint from the certificate into the buffer
413
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
414
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
415
# Deinit the certificate
416
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
417
# Convert the buffer to a Python bytestring
418
fpr = ctypes.string_at(buffer, buffer_length.value)
419
# Convert the bytestring to hexadecimal notation
420
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
424
class tcp_handler(SocketServer.BaseRequestHandler, object):
425
"""A TCP request handler class.
426
Instantiated by IPv6_TCPServer for each request to handle it.
2258
427
Note: This will run in its own forked process."""
2260
429
def handle(self):
2261
with contextlib.closing(self.server.child_pipe) as child_pipe:
2262
logger.info("TCP connection from: %s",
2263
str(self.client_address))
2264
logger.debug("Pipe FD: %d",
2265
self.server.child_pipe.fileno())
2267
session = gnutls.ClientSession(self.request)
2269
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2270
# "+AES-256-CBC", "+SHA1",
2271
# "+COMP-NULL", "+CTYPE-OPENPGP",
2273
# Use a fallback default, since this MUST be set.
2274
priority = self.server.gnutls_priority
2275
if priority is None:
2277
gnutls.priority_set_direct(session._c_object,
2278
priority.encode("utf-8"),
2281
# Start communication using the Mandos protocol
2282
# Get protocol number
2283
line = self.request.makefile().readline()
2284
logger.debug("Protocol version: %r", line)
2286
if int(line.strip().split()[0]) > 1:
2287
raise RuntimeError(line)
2288
except (ValueError, IndexError, RuntimeError) as error:
2289
logger.error("Unknown protocol version: %s", error)
2292
# Start GnuTLS connection
2295
except gnutls.Error as error:
2296
logger.warning("Handshake failed: %s", error)
2297
# Do not run session.bye() here: the session is not
2298
# established. Just abandon the request.
2300
logger.debug("Handshake succeeded")
2302
approval_required = False
2304
if gnutls.has_rawpk:
2307
key_id = self.key_id(
2308
self.peer_certificate(session))
2309
except (TypeError, gnutls.Error) as error:
2310
logger.warning("Bad certificate: %s", error)
2312
logger.debug("Key ID: %s", key_id)
2317
fpr = self.fingerprint(
2318
self.peer_certificate(session))
2319
except (TypeError, gnutls.Error) as error:
2320
logger.warning("Bad certificate: %s", error)
2322
logger.debug("Fingerprint: %s", fpr)
2325
client = ProxyClient(child_pipe, key_id, fpr,
2326
self.client_address)
2330
if client.approval_delay:
2331
delay = client.approval_delay
2332
client.approvals_pending += 1
2333
approval_required = True
2336
if not client.enabled:
2337
logger.info("Client %s is disabled",
2339
if self.server.use_dbus:
2341
client.Rejected("Disabled")
2344
if client.approved or not client.approval_delay:
2345
# We are approved or approval is disabled
2347
elif client.approved is None:
2348
logger.info("Client %s needs approval",
2350
if self.server.use_dbus:
2352
client.NeedApproval(
2353
client.approval_delay.total_seconds()
2354
* 1000, client.approved_by_default)
2356
logger.warning("Client %s was not approved",
2358
if self.server.use_dbus:
2360
client.Rejected("Denied")
2363
# wait until timeout or approved
2364
time = datetime.datetime.now()
2365
client.changedstate.acquire()
2366
client.changedstate.wait(delay.total_seconds())
2367
client.changedstate.release()
2368
time2 = datetime.datetime.now()
2369
if (time2 - time) >= delay:
2370
if not client.approved_by_default:
2371
logger.warning("Client %s timed out while"
2372
" waiting for approval",
2374
if self.server.use_dbus:
2376
client.Rejected("Approval timed out")
2381
delay -= time2 - time
2384
session.send(client.secret)
2385
except gnutls.Error as error:
2386
logger.warning("gnutls send failed",
2390
logger.info("Sending secret to %s", client.name)
2391
# bump the timeout using extended_timeout
2392
client.bump_timeout(client.extended_timeout)
2393
if self.server.use_dbus:
2398
if approval_required:
2399
client.approvals_pending -= 1
2402
except gnutls.Error as error:
2403
logger.warning("GnuTLS bye failed",
2407
def peer_certificate(session):
2408
"Return the peer's certificate as a bytestring"
2410
cert_type = gnutls.certificate_type_get2(session._c_object,
2412
except AttributeError:
2413
cert_type = gnutls.certificate_type_get(session._c_object)
2414
if gnutls.has_rawpk:
2415
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2417
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2418
# If not a valid certificate type...
2419
if cert_type not in valid_cert_types:
2420
logger.info("Cert type %r not in %r", cert_type,
2422
# ...return invalid data
2424
list_size = ctypes.c_uint(1)
2425
cert_list = (gnutls.certificate_get_peers
2426
(session._c_object, ctypes.byref(list_size)))
2427
if not bool(cert_list) and list_size.value != 0:
2428
raise gnutls.Error("error getting peer certificate")
2429
if list_size.value == 0:
2432
return ctypes.string_at(cert.data, cert.size)
2435
def key_id(certificate):
2436
"Convert a certificate bytestring to a hexdigit key ID"
2437
# New GnuTLS "datum" with the public key
2438
datum = gnutls.datum_t(
2439
ctypes.cast(ctypes.c_char_p(certificate),
2440
ctypes.POINTER(ctypes.c_ubyte)),
2441
ctypes.c_uint(len(certificate)))
2442
# XXX all these need to be created in the gnutls "module"
2443
# New empty GnuTLS certificate
2444
pubkey = gnutls.pubkey_t()
2445
gnutls.pubkey_init(ctypes.byref(pubkey))
2446
# Import the raw public key into the certificate
2447
gnutls.pubkey_import(pubkey,
2448
ctypes.byref(datum),
2449
gnutls.X509_FMT_DER)
2450
# New buffer for the key ID
2451
buf = ctypes.create_string_buffer(32)
2452
buf_len = ctypes.c_size_t(len(buf))
2453
# Get the key ID from the raw public key into the buffer
2454
gnutls.pubkey_get_key_id(pubkey,
2455
gnutls.KEYID_USE_SHA256,
2456
ctypes.cast(ctypes.byref(buf),
2457
ctypes.POINTER(ctypes.c_ubyte)),
2458
ctypes.byref(buf_len))
2459
# Deinit the certificate
2460
gnutls.pubkey_deinit(pubkey)
2462
# Convert the buffer to a Python bytestring
2463
key_id = ctypes.string_at(buf, buf_len.value)
2464
# Convert the bytestring to hexadecimal notation
2465
hex_key_id = binascii.hexlify(key_id).upper()
2469
def fingerprint(openpgp):
2470
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2471
# New GnuTLS "datum" with the OpenPGP public key
2472
datum = gnutls.datum_t(
2473
ctypes.cast(ctypes.c_char_p(openpgp),
2474
ctypes.POINTER(ctypes.c_ubyte)),
2475
ctypes.c_uint(len(openpgp)))
2476
# New empty GnuTLS certificate
2477
crt = gnutls.openpgp_crt_t()
2478
gnutls.openpgp_crt_init(ctypes.byref(crt))
2479
# Import the OpenPGP public key into the certificate
2480
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2481
gnutls.OPENPGP_FMT_RAW)
2482
# Verify the self signature in the key
2483
crtverify = ctypes.c_uint()
2484
gnutls.openpgp_crt_verify_self(crt, 0,
2485
ctypes.byref(crtverify))
2486
if crtverify.value != 0:
2487
gnutls.openpgp_crt_deinit(crt)
2488
raise gnutls.CertificateSecurityError(code
2490
# New buffer for the fingerprint
2491
buf = ctypes.create_string_buffer(20)
2492
buf_len = ctypes.c_size_t()
2493
# Get the fingerprint from the certificate into the buffer
2494
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2495
ctypes.byref(buf_len))
2496
# Deinit the certificate
2497
gnutls.openpgp_crt_deinit(crt)
2498
# Convert the buffer to a Python bytestring
2499
fpr = ctypes.string_at(buf, buf_len.value)
2500
# Convert the bytestring to hexadecimal notation
2501
hex_fpr = binascii.hexlify(fpr).upper()
2505
class MultiprocessingMixIn:
2506
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2508
def sub_process_main(self, request, address):
2510
self.finish_request(request, address)
2512
self.handle_error(request, address)
2513
self.close_request(request)
2515
def process_request(self, request, address):
2516
"""Start a new process to process the request."""
2517
proc = multiprocessing.Process(target=self.sub_process_main,
2518
args=(request, address))
2523
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2524
""" adds a pipe to the MixIn """
2526
def process_request(self, request, client_address):
2527
"""Overrides and wraps the original process_request().
2529
This function creates a new pipe in self.pipe
2531
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2533
proc = MultiprocessingMixIn.process_request(self, request,
2535
self.child_pipe.close()
2536
self.add_pipe(parent_pipe, proc)
2538
def add_pipe(self, parent_pipe, proc):
2539
"""Dummy function; override as necessary"""
2540
raise NotImplementedError()
2543
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2544
socketserver.TCPServer):
2545
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
430
logger.info(u"TCP connection from: %s",
431
unicode(self.client_address))
432
session = gnutls.connection.ClientSession\
433
(self.request, gnutls.connection.X509Credentials())
435
line = self.request.makefile().readline()
436
logger.debug(u"Protocol version: %r", line)
438
if int(line.strip().split()[0]) > 1:
440
except (ValueError, IndexError, RuntimeError), error:
441
logger.error(u"Unknown protocol version: %s", error)
444
# Note: gnutls.connection.X509Credentials is really a generic
445
# GnuTLS certificate credentials object so long as no X.509
446
# keys are added to it. Therefore, we can use it here despite
447
# using OpenPGP certificates.
449
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
450
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
452
priority = "NORMAL" # Fallback default, since this
454
if self.server.settings["priority"]:
455
priority = self.server.settings["priority"]
456
gnutls.library.functions.gnutls_priority_set_direct\
457
(session._c_object, priority, None);
461
except gnutls.errors.GNUTLSError, error:
462
logger.warning(u"Handshake failed: %s", error)
463
# Do not run session.bye() here: the session is not
464
# established. Just abandon the request.
467
fpr = fingerprint(peer_certificate(session))
468
except (TypeError, gnutls.errors.GNUTLSError), error:
469
logger.warning(u"Bad certificate: %s", error)
472
logger.debug(u"Fingerprint: %s", fpr)
474
for c in self.server.clients:
475
if c.fingerprint == fpr:
479
logger.warning(u"Client not found for fingerprint: %s",
483
# Have to check if client.still_valid(), since it is possible
484
# that the client timed out while establishing the GnuTLS
486
if not client.still_valid():
487
logger.warning(u"Client %(name)s is invalid",
492
while sent_size < len(client.secret):
493
sent = session.send(client.secret[sent_size:])
494
logger.debug(u"Sent: %d, remaining: %d",
495
sent, len(client.secret)
496
- (sent_size + sent))
501
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
502
"""IPv6 TCP server. Accepts 'None' as address and/or port.
2548
enabled: Boolean; whether this server is activated yet
2549
interface: None or a network interface name (string)
2550
use_ipv6: Boolean; to use IPv6 or not
504
settings: Server settings
505
clients: Set() of Client objects
2553
def __init__(self, server_address, RequestHandlerClass,
2557
"""If socketfd is set, use that file descriptor instead of
2558
creating a new one with socket.socket().
2560
self.interface = interface
2562
self.address_family = socket.AF_INET6
2563
if socketfd is not None:
2564
# Save the file descriptor
2565
self.socketfd = socketfd
2566
# Save the original socket.socket() function
2567
self.socket_socket = socket.socket
2569
# To implement --socket, we monkey patch socket.socket.
2571
# (When socketserver.TCPServer is a new-style class, we
2572
# could make self.socket into a property instead of monkey
2573
# patching socket.socket.)
2575
# Create a one-time-only replacement for socket.socket()
2576
@functools.wraps(socket.socket)
2577
def socket_wrapper(*args, **kwargs):
2578
# Restore original function so subsequent calls are
2580
socket.socket = self.socket_socket
2581
del self.socket_socket
2582
# This time only, return a new socket object from the
2583
# saved file descriptor.
2584
return socket.fromfd(self.socketfd, *args, **kwargs)
2585
# Replace socket.socket() function with wrapper
2586
socket.socket = socket_wrapper
2587
# The socketserver.TCPServer.__init__ will call
2588
# socket.socket(), which might be our replacement,
2589
# socket_wrapper(), if socketfd was set.
2590
socketserver.TCPServer.__init__(self, server_address,
2591
RequestHandlerClass)
507
address_family = socket.AF_INET6
508
def __init__(self, *args, **kwargs):
509
if "settings" in kwargs:
510
self.settings = kwargs["settings"]
511
del kwargs["settings"]
512
if "clients" in kwargs:
513
self.clients = kwargs["clients"]
514
del kwargs["clients"]
515
return super(type(self), self).__init__(*args, **kwargs)
2593
516
def server_bind(self):
2594
517
"""This overrides the normal server_bind() function
2595
518
to bind to an interface if one was specified, and also NOT to
2596
519
bind to an address or port if they were not specified."""
2597
global SO_BINDTODEVICE
2598
if self.interface is not None:
2599
if SO_BINDTODEVICE is None:
2600
# Fall back to a hard-coded value which seems to be
2602
logger.warning("SO_BINDTODEVICE not found, trying 25")
2603
SO_BINDTODEVICE = 25
520
if self.settings["interface"]:
521
# 25 is from /usr/include/asm-i486/socket.h
522
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
2605
self.socket.setsockopt(
2606
socket.SOL_SOCKET, SO_BINDTODEVICE,
2607
(self.interface + "\0").encode("utf-8"))
2608
except socket.error as error:
2609
if error.errno == errno.EPERM:
2610
logger.error("No permission to bind to"
2611
" interface %s", self.interface)
2612
elif error.errno == errno.ENOPROTOOPT:
2613
logger.error("SO_BINDTODEVICE not available;"
2614
" cannot bind to interface %s",
2616
elif error.errno == errno.ENODEV:
2617
logger.error("Interface %s does not exist,"
2618
" cannot bind", self.interface)
524
self.socket.setsockopt(socket.SOL_SOCKET,
526
self.settings["interface"])
527
except socket.error, error:
528
if error[0] == errno.EPERM:
529
logger.error(u"No permission to"
530
u" bind to interface %s",
531
self.settings["interface"])
2621
534
# Only bind(2) the socket if we really need to.
2622
535
if self.server_address[0] or self.server_address[1]:
2623
if self.server_address[1]:
2624
self.allow_reuse_address = True
2625
536
if not self.server_address[0]:
2626
if self.address_family == socket.AF_INET6:
2627
any_address = "::" # in6addr_any
2629
any_address = "0.0.0.0" # INADDR_ANY
2630
self.server_address = (any_address,
538
self.server_address = (in6addr_any,
2631
539
self.server_address[1])
2632
540
elif not self.server_address[1]:
2633
self.server_address = (self.server_address[0], 0)
2634
# if self.interface:
541
self.server_address = (self.server_address[0],
543
# if self.settings["interface"]:
2635
544
# self.server_address = (self.server_address[0],
2638
547
# if_nametoindex
2640
return socketserver.TCPServer.server_bind(self)
2643
class MandosServer(IPv6_TCPServer):
2647
clients: set of Client objects
2648
gnutls_priority GnuTLS priority string
2649
use_dbus: Boolean; to emit D-Bus signals or not
2651
Assumes a GLib.MainLoop event loop.
2654
def __init__(self, server_address, RequestHandlerClass,
2658
gnutls_priority=None,
2661
self.enabled = False
2662
self.clients = clients
2663
if self.clients is None:
2665
self.use_dbus = use_dbus
2666
self.gnutls_priority = gnutls_priority
2667
IPv6_TCPServer.__init__(self, server_address,
2668
RequestHandlerClass,
2669
interface=interface,
2673
def server_activate(self):
2675
return socketserver.TCPServer.server_activate(self)
2680
def add_pipe(self, parent_pipe, proc):
2681
# Call "handle_ipc" for both data and EOF events
2683
parent_pipe.fileno(), GLib.PRIORITY_DEFAULT,
2684
GLib.IO_IN | GLib.IO_HUP,
2685
functools.partial(self.handle_ipc,
2686
parent_pipe=parent_pipe,
2689
def handle_ipc(self, source, condition,
2692
client_object=None):
2693
# error, or the other end of multiprocessing.Pipe has closed
2694
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2695
# Wait for other process to exit
2699
# Read a request from the child
2700
request = parent_pipe.recv()
2701
command = request[0]
2703
if command == 'init':
2704
key_id = request[1].decode("ascii")
2705
fpr = request[2].decode("ascii")
2706
address = request[3]
2708
for c in self.clients.values():
2709
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2711
if key_id and c.key_id == key_id:
2714
if fpr and c.fingerprint == fpr:
2718
logger.info("Client not found for key ID: %s, address"
2719
": %s", key_id or fpr, address)
2722
mandos_dbus_service.ClientNotFound(key_id or fpr,
2724
parent_pipe.send(False)
2728
parent_pipe.fileno(), GLib.PRIORITY_DEFAULT,
2729
GLib.IO_IN | GLib.IO_HUP,
2730
functools.partial(self.handle_ipc,
2731
parent_pipe=parent_pipe,
2733
client_object=client))
2734
parent_pipe.send(True)
2735
# remove the old hook in favor of the new above hook on
2738
if command == 'funcall':
2739
funcname = request[1]
2743
parent_pipe.send(('data', getattr(client_object,
2747
if command == 'getattr':
2748
attrname = request[1]
2749
if isinstance(client_object.__getattribute__(attrname),
2750
collections.Callable):
2751
parent_pipe.send(('function', ))
2754
'data', client_object.__getattribute__(attrname)))
2756
if command == 'setattr':
2757
attrname = request[1]
2759
setattr(client_object, attrname, value)
2764
def rfc3339_duration_to_delta(duration):
2765
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2767
>>> rfc3339_duration_to_delta("P7D")
2768
datetime.timedelta(7)
2769
>>> rfc3339_duration_to_delta("PT60S")
2770
datetime.timedelta(0, 60)
2771
>>> rfc3339_duration_to_delta("PT60M")
2772
datetime.timedelta(0, 3600)
2773
>>> rfc3339_duration_to_delta("PT24H")
2774
datetime.timedelta(1)
2775
>>> rfc3339_duration_to_delta("P1W")
2776
datetime.timedelta(7)
2777
>>> rfc3339_duration_to_delta("PT5M30S")
2778
datetime.timedelta(0, 330)
2779
>>> rfc3339_duration_to_delta("P1DT3M20S")
2780
datetime.timedelta(1, 200)
2783
# Parsing an RFC 3339 duration with regular expressions is not
2784
# possible - there would have to be multiple places for the same
2785
# values, like seconds. The current code, while more esoteric, is
2786
# cleaner without depending on a parsing library. If Python had a
2787
# built-in library for parsing we would use it, but we'd like to
2788
# avoid excessive use of external libraries.
2790
# New type for defining tokens, syntax, and semantics all-in-one
2791
Token = collections.namedtuple("Token", (
2792
"regexp", # To match token; if "value" is not None, must have
2793
# a "group" containing digits
2794
"value", # datetime.timedelta or None
2795
"followers")) # Tokens valid after this token
2796
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2797
# the "duration" ABNF definition in RFC 3339, Appendix A.
2798
token_end = Token(re.compile(r"$"), None, frozenset())
2799
token_second = Token(re.compile(r"(\d+)S"),
2800
datetime.timedelta(seconds=1),
2801
frozenset((token_end, )))
2802
token_minute = Token(re.compile(r"(\d+)M"),
2803
datetime.timedelta(minutes=1),
2804
frozenset((token_second, token_end)))
2805
token_hour = Token(re.compile(r"(\d+)H"),
2806
datetime.timedelta(hours=1),
2807
frozenset((token_minute, token_end)))
2808
token_time = Token(re.compile(r"T"),
2810
frozenset((token_hour, token_minute,
2812
token_day = Token(re.compile(r"(\d+)D"),
2813
datetime.timedelta(days=1),
2814
frozenset((token_time, token_end)))
2815
token_month = Token(re.compile(r"(\d+)M"),
2816
datetime.timedelta(weeks=4),
2817
frozenset((token_day, token_end)))
2818
token_year = Token(re.compile(r"(\d+)Y"),
2819
datetime.timedelta(weeks=52),
2820
frozenset((token_month, token_end)))
2821
token_week = Token(re.compile(r"(\d+)W"),
2822
datetime.timedelta(weeks=1),
2823
frozenset((token_end, )))
2824
token_duration = Token(re.compile(r"P"), None,
2825
frozenset((token_year, token_month,
2826
token_day, token_time,
2828
# Define starting values:
2830
value = datetime.timedelta()
2832
# Following valid tokens
2833
followers = frozenset((token_duration, ))
2834
# String left to parse
2836
# Loop until end token is found
2837
while found_token is not token_end:
2838
# Search for any currently valid tokens
2839
for token in followers:
2840
match = token.regexp.match(s)
2841
if match is not None:
2843
if token.value is not None:
2844
# Value found, parse digits
2845
factor = int(match.group(1), 10)
2846
# Add to value so far
2847
value += factor * token.value
2848
# Strip token from string
2849
s = token.regexp.sub("", s, 1)
2852
# Set valid next tokens
2853
followers = found_token.followers
2856
# No currently valid tokens were found
2857
raise ValueError("Invalid RFC 3339 duration: {!r}"
550
return super(type(self), self).server_bind()
2863
553
def string_to_delta(interval):
2935
##################################################################
2936
# Parsing of options, both command line and config file
2938
parser = argparse.ArgumentParser()
2939
parser.add_argument("-v", "--version", action="version",
2940
version="%(prog)s {}".format(version),
2941
help="show version number and exit")
2942
parser.add_argument("-i", "--interface", metavar="IF",
2943
help="Bind to interface IF")
2944
parser.add_argument("-a", "--address",
2945
help="Address to listen for requests on")
2946
parser.add_argument("-p", "--port", type=int,
2947
help="Port number to receive requests on")
2948
parser.add_argument("--check", action="store_true",
2949
help="Run self-test")
2950
parser.add_argument("--debug", action="store_true",
2951
help="Debug mode; run in foreground and log"
2952
" to terminal", default=None)
2953
parser.add_argument("--debuglevel", metavar="LEVEL",
2954
help="Debug level for stdout output")
2955
parser.add_argument("--priority", help="GnuTLS"
2956
" priority string (see GnuTLS documentation)")
2957
parser.add_argument("--servicename",
2958
metavar="NAME", help="Zeroconf service name")
2959
parser.add_argument("--configdir",
2960
default="/etc/mandos", metavar="DIR",
2961
help="Directory to search for configuration"
2963
parser.add_argument("--no-dbus", action="store_false",
2964
dest="use_dbus", help="Do not provide D-Bus"
2965
" system bus interface", default=None)
2966
parser.add_argument("--no-ipv6", action="store_false",
2967
dest="use_ipv6", help="Do not use IPv6",
2969
parser.add_argument("--no-restore", action="store_false",
2970
dest="restore", help="Do not restore stored"
2971
" state", default=None)
2972
parser.add_argument("--socket", type=int,
2973
help="Specify a file descriptor to a network"
2974
" socket to use instead of creating one")
2975
parser.add_argument("--statedir", metavar="DIR",
2976
help="Directory to save/restore state in")
2977
parser.add_argument("--foreground", action="store_true",
2978
help="Run in foreground", default=None)
2979
parser.add_argument("--no-zeroconf", action="store_false",
2980
dest="zeroconf", help="Do not use Zeroconf",
2983
options = parser.parse_args()
659
global main_loop_started
660
main_loop_started = False
662
parser = OptionParser(version = "%%prog %s" % version)
663
parser.add_option("-i", "--interface", type="string",
664
metavar="IF", help="Bind to interface IF")
665
parser.add_option("-a", "--address", type="string",
666
help="Address to listen for requests on")
667
parser.add_option("-p", "--port", type="int",
668
help="Port number to receive requests on")
669
parser.add_option("--check", action="store_true", default=False,
670
help="Run self-test")
671
parser.add_option("--debug", action="store_true",
672
help="Debug mode; run in foreground and log to"
674
parser.add_option("--priority", type="string", help="GnuTLS"
675
" priority string (see GnuTLS documentation)")
676
parser.add_option("--servicename", type="string", metavar="NAME",
677
help="Zeroconf service name")
678
parser.add_option("--configdir", type="string",
679
default="/etc/mandos", metavar="DIR",
680
help="Directory to search for configuration"
682
(options, args) = parser.parse_args()
2985
689
# Default values for config file for server-global settings
2986
if gnutls.has_rawpk:
2987
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2988
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2990
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2991
":+SIGN-DSA-SHA256")
2992
server_defaults = {"interface": "",
2996
"priority": priority,
2997
"servicename": "Mandos",
3003
"statedir": "/var/lib/mandos",
3004
"foreground": "False",
690
server_defaults = { "interface": "",
695
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
696
"servicename": "Mandos",
3009
699
# Parse config file for server-global settings
3010
server_config = configparser.ConfigParser(server_defaults)
700
server_config = ConfigParser.SafeConfigParser(server_defaults)
3011
701
del server_defaults
3012
702
server_config.read(os.path.join(options.configdir, "mandos.conf"))
3013
# Convert the ConfigParser object to a dict
3014
server_settings = server_config.defaults()
3015
# Use the appropriate methods on the non-string config options
3016
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3017
"foreground", "zeroconf"):
3018
server_settings[option] = server_config.getboolean("DEFAULT",
3020
if server_settings["port"]:
3021
server_settings["port"] = server_config.getint("DEFAULT",
3023
if server_settings["socket"]:
3024
server_settings["socket"] = server_config.getint("DEFAULT",
3026
# Later, stdin will, and stdout and stderr might, be dup'ed
3027
# over with an opened os.devnull. But we don't want this to
3028
# happen with a supplied network socket.
3029
if 0 <= server_settings["socket"] <= 2:
3030
server_settings["socket"] = os.dup(server_settings
703
server_section = "server"
704
# Convert the SafeConfigParser object to a dict
705
server_settings = dict(server_config.items(server_section))
706
# Use getboolean on the boolean config option
707
server_settings["debug"] = server_config.getboolean\
708
(server_section, "debug")
3032
709
del server_config
3034
711
# Override the settings from the config file with command line
3035
712
# options, if set.
3036
713
for option in ("interface", "address", "port", "debug",
3037
"priority", "servicename", "configdir", "use_dbus",
3038
"use_ipv6", "debuglevel", "restore", "statedir",
3039
"socket", "foreground", "zeroconf"):
714
"priority", "servicename", "configdir"):
3040
715
value = getattr(options, option)
3041
716
if value is not None:
3042
717
server_settings[option] = value
3044
# Force all strings to be unicode
3045
for option in server_settings.keys():
3046
if isinstance(server_settings[option], bytes):
3047
server_settings[option] = (server_settings[option]
3049
# Force all boolean options to be boolean
3050
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3051
"foreground", "zeroconf"):
3052
server_settings[option] = bool(server_settings[option])
3053
# Debug implies foreground
3054
if server_settings["debug"]:
3055
server_settings["foreground"] = True
3056
719
# Now we have our good server settings in "server_settings"
3058
##################################################################
3060
if (not server_settings["zeroconf"]
3061
and not (server_settings["port"]
3062
or server_settings["socket"] != "")):
3063
parser.error("Needs port or socket to work without Zeroconf")
3066
721
debug = server_settings["debug"]
3067
debuglevel = server_settings["debuglevel"]
3068
use_dbus = server_settings["use_dbus"]
3069
use_ipv6 = server_settings["use_ipv6"]
3070
stored_state_path = os.path.join(server_settings["statedir"],
3072
foreground = server_settings["foreground"]
3073
zeroconf = server_settings["zeroconf"]
3076
initlogger(debug, logging.DEBUG)
3081
level = getattr(logging, debuglevel.upper())
3082
initlogger(debug, level)
724
syslogger.setLevel(logging.WARNING)
725
console.setLevel(logging.WARNING)
3084
727
if server_settings["servicename"] != "Mandos":
3085
syslogger.setFormatter(
3086
logging.Formatter('Mandos ({}) [%(process)d]:'
3087
' %(levelname)s: %(message)s'.format(
3088
server_settings["servicename"])))
728
syslogger.setFormatter(logging.Formatter\
729
('Mandos (%s): %%(levelname)s:'
731
% server_settings["servicename"]))
3090
733
# Parse config file with clients
3091
client_config = configparser.ConfigParser(Client.client_defaults)
734
client_defaults = { "timeout": "1h",
736
"checker": "fping -q -- %%(host)s",
738
client_config = ConfigParser.SafeConfigParser(client_defaults)
3092
739
client_config.read(os.path.join(server_settings["configdir"],
3093
740
"clients.conf"))
3095
global mandos_dbus_service
3096
mandos_dbus_service = None
3099
if server_settings["socket"] != "":
3100
socketfd = server_settings["socket"]
3101
tcp_server = MandosServer(
3102
(server_settings["address"], server_settings["port"]),
3104
interface=(server_settings["interface"] or None),
3106
gnutls_priority=server_settings["priority"],
3110
pidfilename = "/run/mandos.pid"
3111
if not os.path.isdir("/run/."):
3112
pidfilename = "/var/run/mandos.pid"
3115
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3116
except IOError as e:
3117
logger.error("Could not open file %r", pidfilename,
3120
for name, group in (("_mandos", "_mandos"),
3121
("mandos", "mandos"),
3122
("nobody", "nogroup")):
3124
uid = pwd.getpwnam(name).pw_uid
3125
gid = pwd.getpwnam(group).pw_gid
3136
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3138
except OSError as error:
3139
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3140
.format(uid, gid, os.strerror(error.errno)))
3141
if error.errno != errno.EPERM:
3145
# Enable all possible GnuTLS debugging
3147
# "Use a log level over 10 to enable all debugging options."
3149
gnutls.global_set_log_level(11)
3152
def debug_gnutls(level, string):
3153
logger.debug("GnuTLS: %s", string[:-1])
3155
gnutls.global_set_log_function(debug_gnutls)
3157
# Redirect stdin so all checkers get /dev/null
3158
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3159
os.dup2(null, sys.stdin.fileno())
3163
# Need to fork before connecting to D-Bus
3165
# Close all input and output, do double fork, etc.
3168
if gi.version_info < (3, 10, 2):
3169
# multiprocessing will use threads, so before we use GLib we
3170
# need to inform GLib that threads will be used.
743
service = AvahiService(name = server_settings["servicename"],
744
type = "_mandos._tcp", );
745
if server_settings["interface"]:
746
service.interface = if_nametoindex(server_settings["interface"])
3173
748
global main_loop
3174
751
# From the Avahi example code
3175
DBusGMainLoop(set_as_default=True)
3176
main_loop = GLib.MainLoop()
752
DBusGMainLoop(set_as_default=True )
753
main_loop = gobject.MainLoop()
3177
754
bus = dbus.SystemBus()
755
server = dbus.Interface(
756
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
757
avahi.DBUS_INTERFACE_SERVER )
3178
758
# End of Avahi example code
3181
bus_name = dbus.service.BusName("se.recompile.Mandos",
3184
old_bus_name = dbus.service.BusName(
3185
"se.bsnet.fukt.Mandos", bus,
3187
except dbus.exceptions.DBusException as e:
3188
logger.error("Disabling D-Bus:", exc_info=e)
3190
server_settings["use_dbus"] = False
3191
tcp_server.use_dbus = False
3193
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3194
service = AvahiServiceToSyslog(
3195
name=server_settings["servicename"],
3196
servicetype="_mandos._tcp",
3199
if server_settings["interface"]:
3200
service.interface = if_nametoindex(
3201
server_settings["interface"].encode("utf-8"))
3203
global multiprocessing_manager
3204
multiprocessing_manager = multiprocessing.Manager()
3206
client_class = Client
3208
client_class = functools.partial(ClientDBus, bus=bus)
3210
client_settings = Client.config_parser(client_config)
3211
old_client_settings = {}
3214
# This is used to redirect stdout and stderr for checker processes
3216
wnull = open(os.devnull, "w") # A writable /dev/null
3217
# Only used if server is running in foreground but not in debug
3219
if debug or not foreground:
3222
# Get client data and settings from last running state.
3223
if server_settings["restore"]:
3225
with open(stored_state_path, "rb") as stored_state:
3226
if sys.version_info.major == 2:
3227
clients_data, old_client_settings = pickle.load(
3230
bytes_clients_data, bytes_old_client_settings = (
3231
pickle.load(stored_state, encoding="bytes"))
3232
# Fix bytes to strings
3235
clients_data = {(key.decode("utf-8")
3236
if isinstance(key, bytes)
3239
bytes_clients_data.items()}
3240
del bytes_clients_data
3241
for key in clients_data:
3242
value = {(k.decode("utf-8")
3243
if isinstance(k, bytes) else k): v
3245
clients_data[key].items()}
3246
clients_data[key] = value
3248
value["client_structure"] = [
3250
if isinstance(s, bytes)
3252
value["client_structure"]]
3254
for k in ("name", "host"):
3255
if isinstance(value[k], bytes):
3256
value[k] = value[k].decode("utf-8")
3257
if "key_id" not in value:
3258
value["key_id"] = ""
3259
elif "fingerprint" not in value:
3260
value["fingerprint"] = ""
3261
# old_client_settings
3263
old_client_settings = {
3264
(key.decode("utf-8")
3265
if isinstance(key, bytes)
3268
bytes_old_client_settings.items()}
3269
del bytes_old_client_settings
3271
for value in old_client_settings.values():
3272
if isinstance(value["host"], bytes):
3273
value["host"] = (value["host"]
3275
os.remove(stored_state_path)
3276
except IOError as e:
3277
if e.errno == errno.ENOENT:
3278
logger.warning("Could not load persistent state:"
3279
" {}".format(os.strerror(e.errno)))
3281
logger.critical("Could not load persistent state:",
3284
except EOFError as e:
3285
logger.warning("Could not load persistent state: "
3289
with PGPEngine() as pgp:
3290
for client_name, client in clients_data.items():
3291
# Skip removed clients
3292
if client_name not in client_settings:
3295
# Decide which value to use after restoring saved state.
3296
# We have three different values: Old config file,
3297
# new config file, and saved state.
3298
# New config value takes precedence if it differs from old
3299
# config value, otherwise use saved state.
3300
for name, value in client_settings[client_name].items():
3302
# For each value in new config, check if it
3303
# differs from the old config value (Except for
3304
# the "secret" attribute)
3305
if (name != "secret"
3307
old_client_settings[client_name][name])):
3308
client[name] = value
3312
# Clients who has passed its expire date can still be
3313
# enabled if its last checker was successful. A Client
3314
# whose checker succeeded before we stored its state is
3315
# assumed to have successfully run all checkers during
3317
if client["enabled"]:
3318
if datetime.datetime.utcnow() >= client["expires"]:
3319
if not client["last_checked_ok"]:
3321
"disabling client {} - Client never "
3322
"performed a successful checker".format(
3324
client["enabled"] = False
3325
elif client["last_checker_status"] != 0:
3327
"disabling client {} - Client last"
3328
" checker failed with error code"
3331
client["last_checker_status"]))
3332
client["enabled"] = False
3334
client["expires"] = (
3335
datetime.datetime.utcnow()
3336
+ client["timeout"])
3337
logger.debug("Last checker succeeded,"
3338
" keeping {} enabled".format(
3341
client["secret"] = pgp.decrypt(
3342
client["encrypted_secret"],
3343
client_settings[client_name]["secret"])
3345
# If decryption fails, we use secret from new settings
3346
logger.debug("Failed to decrypt {} old secret".format(
3348
client["secret"] = (client_settings[client_name]
3351
# Add/remove clients based on new changes made to config
3352
for client_name in (set(old_client_settings)
3353
- set(client_settings)):
3354
del clients_data[client_name]
3355
for client_name in (set(client_settings)
3356
- set(old_client_settings)):
3357
clients_data[client_name] = client_settings[client_name]
3359
# Create all client objects
3360
for client_name, client in clients_data.items():
3361
tcp_server.clients[client_name] = client_class(
3364
server_settings=server_settings)
3366
if not tcp_server.clients:
3367
logger.warning("No clients defined")
3370
if pidfile is not None:
3374
print(pid, file=pidfile)
3376
logger.error("Could not write to file %r with PID %d",
761
def remove_from_clients(client):
762
clients.remove(client)
764
logger.critical(u"No clients left, exiting")
767
clients.update(Set(Client(name = section,
768
stop_hook = remove_from_clients,
770
= dict(client_config.items(section)))
771
for section in client_config.sections()))
773
logger.critical(u"No clients defined")
777
logger.removeHandler(console)
780
pidfilename = "/var/run/mandos/mandos.pid"
783
pidfile = open(pidfilename, "w")
784
pidfile.write(str(pid) + "\n")
3381
for termsig in (signal.SIGHUP, signal.SIGTERM):
3382
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3383
lambda: main_loop.quit() and False)
3387
@alternate_dbus_interfaces(
3388
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3389
class MandosDBusService(DBusObjectWithObjectManager):
3390
"""A D-Bus proxy object"""
3393
dbus.service.Object.__init__(self, bus, "/")
3395
_interface = "se.recompile.Mandos"
3397
@dbus.service.signal(_interface, signature="o")
3398
def ClientAdded(self, objpath):
3402
@dbus.service.signal(_interface, signature="ss")
3403
def ClientNotFound(self, key_id, address):
3407
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3409
@dbus.service.signal(_interface, signature="os")
3410
def ClientRemoved(self, objpath, name):
3414
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3416
@dbus.service.method(_interface, out_signature="ao")
3417
def GetAllClients(self):
3419
return dbus.Array(c.dbus_object_path for c in
3420
tcp_server.clients.values())
3422
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3424
@dbus.service.method(_interface,
3425
out_signature="a{oa{sv}}")
3426
def GetAllClientsWithProperties(self):
3428
return dbus.Dictionary(
3429
{c.dbus_object_path: c.GetAll(
3430
"se.recompile.Mandos.Client")
3431
for c in tcp_server.clients.values()},
3434
@dbus.service.method(_interface, in_signature="o")
3435
def RemoveClient(self, object_path):
3437
for c in tcp_server.clients.values():
3438
if c.dbus_object_path == object_path:
3439
del tcp_server.clients[c.name]
3440
c.remove_from_connection()
3441
# Don't signal the disabling
3442
c.disable(quiet=True)
3443
# Emit D-Bus signal for removal
3444
self.client_removed_signal(c)
3446
raise KeyError(object_path)
3450
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3451
out_signature="a{oa{sa{sv}}}")
3452
def GetManagedObjects(self):
3454
return dbus.Dictionary(
3455
{client.dbus_object_path:
3457
{interface: client.GetAll(interface)
3459
client._get_all_interface_names()})
3460
for client in tcp_server.clients.values()})
3462
def client_added_signal(self, client):
3463
"""Send the new standard signal and the old signal"""
3465
# New standard signal
3466
self.InterfacesAdded(
3467
client.dbus_object_path,
3469
{interface: client.GetAll(interface)
3471
client._get_all_interface_names()}))
3473
self.ClientAdded(client.dbus_object_path)
3475
def client_removed_signal(self, client):
3476
"""Send the new standard signal and the old signal"""
3478
# New standard signal
3479
self.InterfacesRemoved(
3480
client.dbus_object_path,
3481
client._get_all_interface_names())
3483
self.ClientRemoved(client.dbus_object_path,
3486
mandos_dbus_service = MandosDBusService()
3488
# Save modules to variables to exempt the modules from being
3489
# unloaded before the function registered with atexit() is run.
3490
mp = multiprocessing
788
logger.error(u"Could not write %s file with PID %d",
789
pidfilename, os.getpid())
3494
792
"Cleanup function; run on exit"
3498
mp.active_children()
3500
if not (tcp_server.clients or client_settings):
3503
# Store client before exiting. Secrets are encrypted with key
3504
# based on what config file has. If config file is
3505
# removed/edited, old secret will thus be unrecovable.
3507
with PGPEngine() as pgp:
3508
for client in tcp_server.clients.values():
3509
key = client_settings[client.name]["secret"]
3510
client.encrypted_secret = pgp.encrypt(client.secret,
3514
# A list of attributes that can not be pickled
3516
exclude = {"bus", "changedstate", "secret",
3517
"checker", "server_settings"}
3518
for name, typ in inspect.getmembers(dbus.service
3522
client_dict["encrypted_secret"] = (client
3524
for attr in client.client_structure:
3525
if attr not in exclude:
3526
client_dict[attr] = getattr(client, attr)
3528
clients[client.name] = client_dict
3529
del client_settings[client.name]["secret"]
3532
with tempfile.NamedTemporaryFile(
3536
dir=os.path.dirname(stored_state_path),
3537
delete=False) as stored_state:
3538
pickle.dump((clients, client_settings), stored_state,
3540
tempname = stored_state.name
3541
os.rename(tempname, stored_state_path)
3542
except (IOError, OSError) as e:
3548
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3549
logger.warning("Could not save persistent state: {}"
3550
.format(os.strerror(e.errno)))
3552
logger.warning("Could not save persistent state:",
3556
# Delete all clients, and settings from config
3557
while tcp_server.clients:
3558
name, client = tcp_server.clients.popitem()
3560
client.remove_from_connection()
3561
# Don't signal the disabling
3562
client.disable(quiet=True)
3563
# Emit D-Bus signal for removal
3565
mandos_dbus_service.client_removed_signal(client)
3566
client_settings.clear()
794
# From the Avahi example code
795
if not group is None:
798
# End of Avahi example code
801
client = clients.pop()
802
client.stop_hook = None
3568
805
atexit.register(cleanup)
3570
for client in tcp_server.clients.values():
3572
# Emit D-Bus signal for adding
3573
mandos_dbus_service.client_added_signal(client)
3574
# Need to initiate checking of clients
3576
client.init_checker()
3579
tcp_server.server_activate()
808
signal.signal(signal.SIGINT, signal.SIG_IGN)
809
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
810
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
812
for client in clients:
815
tcp_server = IPv6_TCPServer((server_settings["address"],
816
server_settings["port"]),
818
settings=server_settings,
3581
820
# Find out what port we got
3583
service.port = tcp_server.socket.getsockname()[1]
3585
logger.info("Now listening on address %r, port %d,"
3586
" flowinfo %d, scope_id %d",
3587
*tcp_server.socket.getsockname())
3589
logger.info("Now listening on address %r, port %d",
3590
*tcp_server.socket.getsockname())
3592
# service.interface = tcp_server.socket.getsockname()[3]
821
service.port = tcp_server.socket.getsockname()[1]
822
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
823
u" scope_id %d" % tcp_server.socket.getsockname())
825
#service.interface = tcp_server.socket.getsockname()[3]
3596
# From the Avahi example code
3599
except dbus.exceptions.DBusException as error:
3600
logger.critical("D-Bus Exception", exc_info=error)
3603
# End of Avahi example code
3605
GLib.io_add_watch(tcp_server.fileno(), GLib.PRIORITY_DEFAULT,
3607
lambda *args, **kwargs:
3608
(tcp_server.handle_request
3609
(*args[2:], **kwargs) or True))
3611
logger.debug("Starting main loop")
828
# From the Avahi example code
829
server.connect_to_signal("StateChanged", server_state_changed)
831
server_state_changed(server.GetState())
832
except dbus.exceptions.DBusException, error:
833
logger.critical(u"DBusException: %s", error)
835
# End of Avahi example code
837
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
838
lambda *args, **kwargs:
839
tcp_server.handle_request\
840
(*args[2:], **kwargs) or True)
842
logger.debug(u"Starting main loop")
843
main_loop_started = True
3613
except AvahiError as error:
3614
logger.critical("Avahi Error", exc_info=error)
845
except AvahiError, error:
846
logger.critical(u"AvahiError: %s" + unicode(error))
3617
848
except KeyboardInterrupt:
3619
print("", file=sys.stderr)
3620
logger.debug("Server received KeyboardInterrupt")
3621
logger.debug("Server exiting")
3622
# Must run before the D-Bus bus name gets deregistered
3626
def should_only_run_tests():
3627
parser = argparse.ArgumentParser(add_help=False)
3628
parser.add_argument("--check", action='store_true')
3629
args, unknown_args = parser.parse_known_args()
3630
run_tests = args.check
3632
# Remove --check argument from sys.argv
3633
sys.argv[1:] = unknown_args
3636
# Add all tests from doctest strings
3637
def load_tests(loader, tests, none):
3639
tests.addTests(doctest.DocTestSuite())
3642
852
if __name__ == '__main__':
3644
if should_only_run_tests():
3645
# Call using ./mandos --check [--verbose]