To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 1273
- compare with another revision
- download diff
- download tarball
- view history from revision 1273
- Committer: Teddy Hogeborn
- Date: 2023-02-11 06:46:26 UTC
- Revision ID: teddy@recompile.se-20230211064626-2aqhtdd46jbif6h6
Really enable FORTIFY_SOURCE=3
Use -DFORTIFY_SOURCE=3 by appending it to CPPFLAGS directly instead of
adding it indirectly to CFLAGS.
* Makefile (FORTIFY): Remove "-D_FORTIFY_SOURCE=3".
(Fortify section/CPPFLAGS): New; append "-D_FORTIFY_SOURCE=3".
(FEATURES): Remove. Contents moved to CPPFLAGS.
(CPPFLAGS): New; append "-D_FILE_OFFSET_BITS=64".
(CFLAGS): Do not use "$(FEATURES)".
Use -DFORTIFY_SOURCE=3 by appending it to CPPFLAGS directly instead of
adding it indirectly to CFLAGS.
* Makefile (FORTIFY): Remove "-D_FORTIFY_SOURCE=3".
(Fortify section/CPPFLAGS): New; append "-D_FORTIFY_SOURCE=3".
(FEATURES): Remove. Contents moved to CPPFLAGS.
(CPPFLAGS): New; append "-D_FILE_OFFSET_BITS=64".
(CFLAGS): Do not use "$(FEATURES)".
- files added:
- debian/po/es.po
- files modified:
- Makefile
added
removed
mandos
1
1
#!/usr/bin/python3 -bI
2
# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
2
# -*- coding: utf-8; lexical-binding: t -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
5
#
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2020 Teddy Hogeborn
15
# Copyright © 2008-2020 Björn Påhlsson
14
# Copyright © 2008-2022 Teddy Hogeborn
15
# Copyright © 2008-2022 Björn Påhlsson
16
16
#
17
17
# This file is part of Mandos.
18
18
#
31
31
#
32
32
# Contact the authors at <mandos@recompile.se>.
33
33
#
34
35
34
from __future__ import (division, absolute_import, print_function,
36
35
unicode_literals)
37
36
40
39
except ImportError:
41
40
pass
42
41
42
import sys
43
import unittest
44
import argparse
45
import logging
46
import os
43
47
try:
44
48
import SocketServer as socketserver
45
49
except ImportError:
46
50
import socketserver
47
51
import socket
48
import argparse
49
52
import datetime
50
53
import errno
51
54
try:
52
55
import ConfigParser as configparser
53
56
except ImportError:
54
57
import configparser
55
import sys
56
58
import re
57
import os
58
59
import signal
59
60
import subprocess
60
61
import atexit
61
62
import stat
62
import logging
63
63
import logging.handlers
64
64
import pwd
65
65
import contextlib
77
77
import itertools
78
78
import collections
79
79
import codecs
80
import unittest
81
80
import random
82
81
import shlex
83
82
94
93
if sys.version_info.major == 2:
95
94
__metaclass__ = type
96
95
str = unicode
96
input = raw_input
97
97
98
98
# Add collections.abc.Callable if it does not exist
99
99
try:
143
143
if sys.version_info < (3, 2):
144
144
configparser.Configparser = configparser.SafeConfigParser
145
145
146
version = "1.8.14"
146
version = "1.8.16"
147
147
stored_state_file = "clients.pickle"
148
148
149
logger = logging.getLogger()
149
log = logging.getLogger(os.path.basename(sys.argv[0]))
150
150
logging.captureWarnings(True) # Show warnings via the logging system
151
151
syslogger = None
152
152
189
189
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
190
190
address="/dev/log"))
191
191
syslogger.setFormatter(logging.Formatter
192
('Mandos [%(process)d]: %(levelname)s:'
193
' %(message)s'))
194
logger.addHandler(syslogger)
192
("Mandos [%(process)d]: %(levelname)s:"
193
" %(message)s"))
194
log.addHandler(syslogger)
195
195
196
196
if debug:
197
197
console = logging.StreamHandler()
198
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
199
' [%(process)d]:'
200
' %(levelname)s:'
201
' %(message)s'))
202
logger.addHandler(console)
203
logger.setLevel(level)
198
console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
199
" [%(process)d]:"
200
" %(levelname)s:"
201
" %(message)s"))
202
log.addHandler(console)
203
log.setLevel(level)
204
204
205
205
206
206
class PGPError(Exception):
224
224
except OSError as e:
225
225
if e.errno != errno.ENOENT:
226
226
raise
227
self.gnupgargs = ['--batch',
228
'--homedir', self.tempdir,
229
'--force-mdc',
230
'--quiet']
227
self.gnupgargs = ["--batch",
228
"--homedir", self.tempdir,
229
"--force-mdc",
230
"--quiet"]
231
231
# Only GPG version 1 has the --no-use-agent option.
232
232
if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
233
233
self.gnupgargs.append("--no-use-agent")
272
272
dir=self.tempdir) as passfile:
273
273
passfile.write(passphrase)
274
274
passfile.flush()
275
proc = subprocess.Popen([self.gpg, '--symmetric',
276
'--passphrase-file',
275
proc = subprocess.Popen([self.gpg, "--symmetric",
276
"--passphrase-file",
277
277
passfile.name]
278
278
+ self.gnupgargs,
279
279
stdin=subprocess.PIPE,
290
290
dir=self.tempdir) as passfile:
291
291
passfile.write(passphrase)
292
292
passfile.flush()
293
proc = subprocess.Popen([self.gpg, '--decrypt',
294
'--passphrase-file',
293
proc = subprocess.Popen([self.gpg, "--decrypt",
294
"--passphrase-file",
295
295
passfile.name]
296
296
+ self.gnupgargs,
297
297
stdin=subprocess.PIPE,
350
350
Attributes:
351
351
interface: integer; avahi.IF_UNSPEC or an interface index.
352
352
Used to optionally bind to the specified interface.
353
name: string; Example: 'Mandos'
354
type: string; Example: '_mandos._tcp'.
353
name: string; Example: "Mandos"
354
type: string; Example: "_mandos._tcp".
355
355
See <https://www.iana.org/assignments/service-names-port-numbers>
356
356
port: integer; what port to announce
357
357
TXT: list of strings; TXT record for the service
394
394
def rename(self, remove=True):
395
395
"""Derived from the Avahi example code"""
396
396
if self.rename_count >= self.max_renames:
397
logger.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
399
self.rename_count)
397
log.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
399
self.rename_count)
400
400
raise AvahiServiceError("Too many renames")
401
401
self.name = str(
402
402
self.server.GetAlternativeServiceName(self.name))
403
403
self.rename_count += 1
404
logger.info("Changing Zeroconf service name to %r ...",
405
self.name)
404
log.info("Changing Zeroconf service name to %r ...",
405
self.name)
406
406
if remove:
407
407
self.remove()
408
408
try:
410
410
except dbus.exceptions.DBusException as error:
411
411
if (error.get_dbus_name()
412
412
== "org.freedesktop.Avahi.CollisionError"):
413
logger.info("Local Zeroconf service name collision.")
413
log.info("Local Zeroconf service name collision.")
414
414
return self.rename(remove=False)
415
415
else:
416
logger.critical("D-Bus Exception", exc_info=error)
416
log.critical("D-Bus Exception", exc_info=error)
417
417
self.cleanup()
418
418
os._exit(1)
419
419
435
435
avahi.DBUS_INTERFACE_ENTRY_GROUP)
436
436
self.entry_group_state_changed_match = (
437
437
self.group.connect_to_signal(
438
'StateChanged', self.entry_group_state_changed))
439
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
440
self.name, self.type)
438
"StateChanged", self.entry_group_state_changed))
439
log.debug("Adding Zeroconf service '%s' of type '%s' ...",
440
self.name, self.type)
441
441
self.group.AddService(
442
442
self.interface,
443
443
self.protocol,
450
450
451
451
def entry_group_state_changed(self, state, error):
452
452
"""Derived from the Avahi example code"""
453
logger.debug("Avahi entry group state change: %i", state)
453
log.debug("Avahi entry group state change: %i", state)
454
454
455
455
if state == avahi.ENTRY_GROUP_ESTABLISHED:
456
logger.debug("Zeroconf service established.")
456
log.debug("Zeroconf service established.")
457
457
elif state == avahi.ENTRY_GROUP_COLLISION:
458
logger.info("Zeroconf service name collision.")
458
log.info("Zeroconf service name collision.")
459
459
self.rename()
460
460
elif state == avahi.ENTRY_GROUP_FAILURE:
461
logger.critical("Avahi: Error in group state changed %s",
462
str(error))
461
log.critical("Avahi: Error in group state changed %s",
462
str(error))
463
463
raise AvahiGroupError("State changed: {!s}".format(error))
464
464
465
465
def cleanup(self):
475
475
476
476
def server_state_changed(self, state, error=None):
477
477
"""Derived from the Avahi example code"""
478
logger.debug("Avahi server state change: %i", state)
478
log.debug("Avahi server state change: %i", state)
479
479
bad_states = {
480
480
avahi.SERVER_INVALID: "Zeroconf server invalid",
481
481
avahi.SERVER_REGISTERING: None,
485
485
if state in bad_states:
486
486
if bad_states[state] is not None:
487
487
if error is None:
488
logger.error(bad_states[state])
488
log.error(bad_states[state])
489
489
else:
490
logger.error(bad_states[state] + ": %r", error)
490
log.error(bad_states[state] + ": %r", error)
491
491
self.cleanup()
492
492
elif state == avahi.SERVER_RUNNING:
493
493
try:
495
495
except dbus.exceptions.DBusException as error:
496
496
if (error.get_dbus_name()
497
497
== "org.freedesktop.Avahi.CollisionError"):
498
logger.info("Local Zeroconf service name"
499
" collision.")
498
log.info("Local Zeroconf service name collision.")
500
499
return self.rename(remove=False)
501
500
else:
502
logger.critical("D-Bus Exception", exc_info=error)
501
log.critical("D-Bus Exception", exc_info=error)
503
502
self.cleanup()
504
503
os._exit(1)
505
504
else:
506
505
if error is None:
507
logger.debug("Unknown state: %r", state)
506
log.debug("Unknown state: %r", state)
508
507
else:
509
logger.debug("Unknown state: %r: %r", state, error)
508
log.debug("Unknown state: %r: %r", state, error)
510
509
511
510
def activate(self):
512
511
"""Derived from the Avahi example code"""
527
526
ret = super(AvahiServiceToSyslog, self).rename(*args,
528
527
**kwargs)
529
528
syslogger.setFormatter(logging.Formatter(
530
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
529
"Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
531
530
.format(self.name)))
532
531
return ret
533
532
563
562
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
564
563
565
564
# Types
566
class session_int(ctypes.Structure):
565
class _session_int(ctypes.Structure):
567
566
_fields_ = []
568
session_t = ctypes.POINTER(session_int)
567
session_t = ctypes.POINTER(_session_int)
569
568
570
569
class certificate_credentials_st(ctypes.Structure):
571
570
_fields_ = []
574
573
certificate_type_t = ctypes.c_int
575
574
576
575
class datum_t(ctypes.Structure):
577
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
578
('size', ctypes.c_uint)]
576
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
577
("size", ctypes.c_uint)]
579
578
580
class openpgp_crt_int(ctypes.Structure):
579
class _openpgp_crt_int(ctypes.Structure):
581
580
_fields_ = []
582
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
581
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
583
582
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
584
583
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
585
584
credentials_type_t = ctypes.c_int
594
593
# gnutls.strerror()
595
594
self.code = code
596
595
if message is None and code is not None:
597
message = gnutls.strerror(code)
596
message = gnutls.strerror(code).decode(
597
"utf-8", errors="replace")
598
598
return super(gnutls.Error, self).__init__(
599
599
message, *args)
600
600
601
601
class CertificateSecurityError(Error):
602
602
pass
603
603
604
class PointerTo:
605
def __init__(self, cls):
606
self.cls = cls
607
608
def from_param(self, obj):
609
if not isinstance(obj, self.cls):
610
raise TypeError("Not of type {}: {!r}"
611
.format(self.cls.__name__, obj))
612
return ctypes.byref(obj.from_param(obj))
613
614
class CastToVoidPointer:
615
def __init__(self, cls):
616
self.cls = cls
617
618
def from_param(self, obj):
619
if not isinstance(obj, self.cls):
620
raise TypeError("Not of type {}: {!r}"
621
.format(self.cls.__name__, obj))
622
return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
623
624
class With_from_param:
625
@classmethod
626
def from_param(cls, obj):
627
return obj._as_parameter_
628
604
629
# Classes
605
class Credentials:
630
class Credentials(With_from_param):
606
631
def __init__(self):
607
self._c_object = gnutls.certificate_credentials_t()
608
gnutls.certificate_allocate_credentials(
609
ctypes.byref(self._c_object))
632
self._as_parameter_ = gnutls.certificate_credentials_t()
633
gnutls.certificate_allocate_credentials(self)
610
634
self.type = gnutls.CRD_CERTIFICATE
611
635
612
636
def __del__(self):
613
gnutls.certificate_free_credentials(self._c_object)
637
gnutls.certificate_free_credentials(self)
614
638
615
class ClientSession:
639
class ClientSession(With_from_param):
616
640
def __init__(self, socket, credentials=None):
617
self._c_object = gnutls.session_t()
641
self._as_parameter_ = gnutls.session_t()
618
642
gnutls_flags = gnutls.CLIENT
619
643
if gnutls.check_version(b"3.5.6"):
620
644
gnutls_flags |= gnutls.NO_TICKETS
621
645
if gnutls.has_rawpk:
622
646
gnutls_flags |= gnutls.ENABLE_RAWPK
623
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
647
gnutls.init(self, gnutls_flags)
624
648
del gnutls_flags
625
gnutls.set_default_priority(self._c_object)
626
gnutls.transport_set_ptr(self._c_object, socket.fileno())
627
gnutls.handshake_set_private_extensions(self._c_object,
628
True)
649
gnutls.set_default_priority(self)
650
gnutls.transport_set_ptr(self, socket.fileno())
651
gnutls.handshake_set_private_extensions(self, True)
629
652
self.socket = socket
630
653
if credentials is None:
631
654
credentials = gnutls.Credentials()
632
gnutls.credentials_set(self._c_object, credentials.type,
633
ctypes.cast(credentials._c_object,
634
ctypes.c_void_p))
655
gnutls.credentials_set(self, credentials.type,
656
credentials)
635
657
self.credentials = credentials
636
658
637
659
def __del__(self):
638
gnutls.deinit(self._c_object)
660
gnutls.deinit(self)
639
661
640
662
def handshake(self):
641
return gnutls.handshake(self._c_object)
663
return gnutls.handshake(self)
642
664
643
665
def send(self, data):
644
666
data = bytes(data)
645
667
data_len = len(data)
646
668
while data_len > 0:
647
data_len -= gnutls.record_send(self._c_object,
648
data[-data_len:],
669
data_len -= gnutls.record_send(self, data[-data_len:],
649
670
data_len)
650
671
651
672
def bye(self):
652
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
673
return gnutls.bye(self, gnutls.SHUT_RDWR)
653
674
654
675
# Error handling functions
655
676
def _error_code(result):
656
677
"""A function to raise exceptions on errors, suitable
657
for the 'restype' attribute on ctypes functions"""
658
if result >= 0:
678
for the "restype" attribute on ctypes functions"""
679
if result >= gnutls.E_SUCCESS:
659
680
return result
660
681
if result == gnutls.E_NO_CERTIFICATE_FOUND:
661
682
raise gnutls.CertificateSecurityError(code=result)
664
685
def _retry_on_error(result, func, arguments,
665
686
_error_code=_error_code):
666
687
"""A function to retry on some errors, suitable
667
for the 'errcheck' attribute on ctypes functions"""
668
while result < 0:
688
for the "errcheck" attribute on ctypes functions"""
689
while result < gnutls.E_SUCCESS:
669
690
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
670
691
return _error_code(result)
671
692
result = func(*arguments)
676
697
677
698
# Functions
678
699
priority_set_direct = _library.gnutls_priority_set_direct
679
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
700
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
680
701
ctypes.POINTER(ctypes.c_char_p)]
681
702
priority_set_direct.restype = _error_code
682
703
683
704
init = _library.gnutls_init
684
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
705
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
685
706
init.restype = _error_code
686
707
687
708
set_default_priority = _library.gnutls_set_default_priority
688
set_default_priority.argtypes = [session_t]
709
set_default_priority.argtypes = [ClientSession]
689
710
set_default_priority.restype = _error_code
690
711
691
712
record_send = _library.gnutls_record_send
692
record_send.argtypes = [session_t, ctypes.c_void_p,
713
record_send.argtypes = [ClientSession, ctypes.c_void_p,
693
714
ctypes.c_size_t]
694
715
record_send.restype = ctypes.c_ssize_t
695
716
record_send.errcheck = _retry_on_error
697
718
certificate_allocate_credentials = (
698
719
_library.gnutls_certificate_allocate_credentials)
699
720
certificate_allocate_credentials.argtypes = [
700
ctypes.POINTER(certificate_credentials_t)]
721
PointerTo(Credentials)]
701
722
certificate_allocate_credentials.restype = _error_code
702
723
703
724
certificate_free_credentials = (
704
725
_library.gnutls_certificate_free_credentials)
705
certificate_free_credentials.argtypes = [
706
certificate_credentials_t]
726
certificate_free_credentials.argtypes = [Credentials]
707
727
certificate_free_credentials.restype = None
708
728
709
729
handshake_set_private_extensions = (
710
730
_library.gnutls_handshake_set_private_extensions)
711
handshake_set_private_extensions.argtypes = [session_t,
731
handshake_set_private_extensions.argtypes = [ClientSession,
712
732
ctypes.c_int]
713
733
handshake_set_private_extensions.restype = None
714
734
715
735
credentials_set = _library.gnutls_credentials_set
716
credentials_set.argtypes = [session_t, credentials_type_t,
717
ctypes.c_void_p]
736
credentials_set.argtypes = [ClientSession, credentials_type_t,
737
CastToVoidPointer(Credentials)]
718
738
credentials_set.restype = _error_code
719
739
720
740
strerror = _library.gnutls_strerror
722
742
strerror.restype = ctypes.c_char_p
723
743
724
744
certificate_type_get = _library.gnutls_certificate_type_get
725
certificate_type_get.argtypes = [session_t]
745
certificate_type_get.argtypes = [ClientSession]
726
746
certificate_type_get.restype = _error_code
727
747
728
748
certificate_get_peers = _library.gnutls_certificate_get_peers
729
certificate_get_peers.argtypes = [session_t,
749
certificate_get_peers.argtypes = [ClientSession,
730
750
ctypes.POINTER(ctypes.c_uint)]
731
751
certificate_get_peers.restype = ctypes.POINTER(datum_t)
732
752
739
759
global_set_log_function.restype = None
740
760
741
761
deinit = _library.gnutls_deinit
742
deinit.argtypes = [session_t]
762
deinit.argtypes = [ClientSession]
743
763
deinit.restype = None
744
764
745
765
handshake = _library.gnutls_handshake
746
handshake.argtypes = [session_t]
747
handshake.restype = _error_code
766
handshake.argtypes = [ClientSession]
767
handshake.restype = ctypes.c_int
748
768
handshake.errcheck = _retry_on_error
749
769
750
770
transport_set_ptr = _library.gnutls_transport_set_ptr
751
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
771
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
752
772
transport_set_ptr.restype = None
753
773
754
774
bye = _library.gnutls_bye
755
bye.argtypes = [session_t, close_request_t]
756
bye.restype = _error_code
775
bye.argtypes = [ClientSession, close_request_t]
776
bye.restype = ctypes.c_int
757
777
bye.errcheck = _retry_on_error
758
778
759
779
check_version = _library.gnutls_check_version
833
853
834
854
if check_version(b"3.6.4"):
835
855
certificate_type_get2 = _library.gnutls_certificate_type_get2
836
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
856
certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
837
857
certificate_type_get2.restype = _error_code
838
858
839
859
# Remove non-public functions
855
875
"""A representation of a client host served by this server.
856
876
857
877
Attributes:
858
approved: bool(); 'None' if not yet approved/disapproved
878
approved: bool(); None if not yet approved/disapproved
859
879
approval_delay: datetime.timedelta(); Time to wait for approval
860
880
approval_duration: datetime.timedelta(); Duration of one approval
861
881
checker: multiprocessing.Process(); a running checker process used
862
to see if the client lives. 'None' if no process is
882
to see if the client lives. None if no process is
863
883
running.
864
884
checker_callback_tag: a GLib event source tag, or None
865
885
checker_command: string; External command which is run to check
989
1009
self.last_enabled = None
990
1010
self.expires = None
991
1011
992
logger.debug("Creating client %r", self.name)
993
logger.debug(" Key ID: %s", self.key_id)
994
logger.debug(" Fingerprint: %s", self.fingerprint)
1012
log.debug("Creating client %r", self.name)
1013
log.debug(" Key ID: %s", self.key_id)
1014
log.debug(" Fingerprint: %s", self.fingerprint)
995
1015
self.created = settings.get("created",
996
1016
datetime.datetime.utcnow())
997
1017
1025
1045
if getattr(self, "enabled", False):
1026
1046
# Already enabled
1027
1047
return
1028
self.expires = datetime.datetime.utcnow() + self.timeout
1029
1048
self.enabled = True
1030
1049
self.last_enabled = datetime.datetime.utcnow()
1031
1050
self.init_checker()
1036
1055
if not getattr(self, "enabled", False):
1037
1056
return False
1038
1057
if not quiet:
1039
logger.info("Disabling client %s", self.name)
1058
log.info("Disabling client %s", self.name)
1040
1059
if getattr(self, "disable_initiator_tag", None) is not None:
1041
1060
GLib.source_remove(self.disable_initiator_tag)
1042
1061
self.disable_initiator_tag = None
1054
1073
def __del__(self):
1055
1074
self.disable()
1056
1075
1057
def init_checker(self):
1058
# Schedule a new checker to be started an 'interval' from now,
1059
# and every interval from then on.
1076
def init_checker(self, randomize_start=False):
1077
# Schedule a new checker to be started a randomly selected
1078
# time (a fraction of 'interval') from now. This spreads out
1079
# the startup of checkers over time when the server is
1080
# started.
1060
1081
if self.checker_initiator_tag is not None:
1061
1082
GLib.source_remove(self.checker_initiator_tag)
1083
interval_milliseconds = int(self.interval.total_seconds()
1084
* 1000)
1085
if randomize_start:
1086
delay_milliseconds = random.randrange(
1087
interval_milliseconds + 1)
1088
else:
1089
delay_milliseconds = interval_milliseconds
1062
1090
self.checker_initiator_tag = GLib.timeout_add(
1063
random.randrange(int(self.interval.total_seconds() * 1000
1064
+ 1)),
1065
self.start_checker)
1066
# Schedule a disable() when 'timeout' has passed
1091
delay_milliseconds, self.start_checker, randomize_start)
1092
delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
1093
# A checker might take up to an 'interval' of time, so we can
1094
# expire at the soonest one interval after a checker was
1095
# started. Since the initial checker is delayed, the expire
1096
# time might have to be extended.
1097
now = datetime.datetime.utcnow()
1098
self.expires = now + delay + self.interval
1099
# Schedule a disable() at expire time
1067
1100
if self.disable_initiator_tag is not None:
1068
1101
GLib.source_remove(self.disable_initiator_tag)
1069
1102
self.disable_initiator_tag = GLib.timeout_add(
1070
int(self.timeout.total_seconds() * 1000), self.disable)
1071
# Also start a new checker *right now*.
1072
self.start_checker()
1103
int((self.expires - now).total_seconds() * 1000),
1104
self.disable)
1073
1105
1074
1106
def checker_callback(self, source, condition, connection,
1075
1107
command):
1086
1118
self.last_checker_status = returncode
1087
1119
self.last_checker_signal = None
1088
1120
if self.last_checker_status == 0:
1089
logger.info("Checker for %(name)s succeeded",
1090
vars(self))
1121
log.info("Checker for %(name)s succeeded", vars(self))
1091
1122
self.checked_ok()
1092
1123
else:
1093
logger.info("Checker for %(name)s failed", vars(self))
1124
log.info("Checker for %(name)s failed", vars(self))
1094
1125
else:
1095
1126
self.last_checker_status = -1
1096
1127
self.last_checker_signal = -returncode
1097
logger.warning("Checker for %(name)s crashed?",
1098
vars(self))
1128
log.warning("Checker for %(name)s crashed?", vars(self))
1099
1129
return False
1100
1130
1101
1131
def checked_ok(self):
1120
1150
def need_approval(self):
1121
1151
self.last_approval_request = datetime.datetime.utcnow()
1122
1152
1123
def start_checker(self):
1153
def start_checker(self, start_was_randomized=False):
1124
1154
"""Start a new checker subprocess if one is not running.
1125
1155
1126
1156
If a checker already exists, leave it running and do
1135
1165
# should be.
1136
1166
1137
1167
if self.checker is not None and not self.checker.is_alive():
1138
logger.warning("Checker was not alive; joining")
1168
log.warning("Checker was not alive; joining")
1139
1169
self.checker.join()
1140
1170
self.checker = None
1141
1171
# Start a new checker if needed
1147
1177
try:
1148
1178
command = self.checker_command % escaped_attrs
1149
1179
except TypeError as error:
1150
logger.error('Could not format string "%s"',
1151
self.checker_command,
1152
exc_info=error)
1180
log.error('Could not format string "%s"',
1181
self.checker_command, exc_info=error)
1153
1182
return True # Try again later
1154
1183
self.current_checker_command = command
1155
logger.info("Starting checker %r for %s", command,
1156
self.name)
1184
log.info("Starting checker %r for %s", command, self.name)
1157
1185
# We don't need to redirect stdout and stderr, since
1158
1186
# in normal mode, that is already done by daemon(),
1159
1187
# and in debug mode we don't want to. (Stdin is
1178
1206
GLib.IOChannel.unix_new(pipe[0].fileno()),
1179
1207
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1180
1208
self.checker_callback, pipe[0], command)
1209
if start_was_randomized:
1210
# We were started after a random delay; Schedule a new
1211
# checker to be started an 'interval' from now, and every
1212
# interval from then on.
1213
now = datetime.datetime.utcnow()
1214
self.checker_initiator_tag = GLib.timeout_add(
1215
int(self.interval.total_seconds() * 1000),
1216
self.start_checker)
1217
self.expires = max(self.expires, now + self.interval)
1218
# Don't start a new checker again after same random delay
1219
return False
1181
1220
# Re-run this periodically if run by GLib.timeout_add
1182
1221
return True
1183
1222
1188
1227
self.checker_callback_tag = None
1189
1228
if getattr(self, "checker", None) is None:
1190
1229
return
1191
logger.debug("Stopping checker for %(name)s", vars(self))
1230
log.debug("Stopping checker for %(name)s", vars(self))
1192
1231
self.checker.terminate()
1193
1232
self.checker = None
1194
1233
1221
1260
func._dbus_name = func.__name__
1222
1261
if func._dbus_name.endswith("_dbus_property"):
1223
1262
func._dbus_name = func._dbus_name[:-14]
1224
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1263
func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1225
1264
return func
1226
1265
1227
1266
return decorator
1316
1355
1317
1356
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1318
1357
out_signature="s",
1319
path_keyword='object_path',
1320
connection_keyword='connection')
1358
path_keyword="object_path",
1359
connection_keyword="connection")
1321
1360
def Introspect(self, object_path, connection):
1322
1361
"""Overloading of standard D-Bus method.
1323
1362
1372
1411
document.unlink()
1373
1412
except (AttributeError, xml.dom.DOMException,
1374
1413
xml.parsers.expat.ExpatError) as error:
1375
logger.error("Failed to override Introspection method",
1376
exc_info=error)
1414
log.error("Failed to override Introspection method",
1415
exc_info=error)
1377
1416
return xmlstring
1378
1417
1379
1418
1476
1515
1477
1516
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1478
1517
out_signature="s",
1479
path_keyword='object_path',
1480
connection_keyword='connection')
1518
path_keyword="object_path",
1519
connection_keyword="connection")
1481
1520
def Introspect(self, object_path, connection):
1482
1521
"""Overloading of standard D-Bus method.
1483
1522
1539
1578
document.unlink()
1540
1579
except (AttributeError, xml.dom.DOMException,
1541
1580
xml.parsers.expat.ExpatError) as error:
1542
logger.error("Failed to override Introspection method",
1543
exc_info=error)
1581
log.error("Failed to override Introspection method",
1582
exc_info=error)
1544
1583
return xmlstring
1545
1584
1546
1585
1578
1617
1579
1618
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1580
1619
out_signature="s",
1581
path_keyword='object_path',
1582
connection_keyword='connection')
1620
path_keyword="object_path",
1621
connection_keyword="connection")
1583
1622
def Introspect(self, object_path, connection):
1584
1623
"""Overloading of standard D-Bus method.
1585
1624
1610
1649
document.unlink()
1611
1650
except (AttributeError, xml.dom.DOMException,
1612
1651
xml.parsers.expat.ExpatError) as error:
1613
logger.error("Failed to override Introspection method",
1614
exc_info=error)
1652
log.error("Failed to override Introspection method",
1653
exc_info=error)
1615
1654
return xmlstring
1616
1655
1617
1656
2251
2290
class ProxyClient:
2252
2291
def __init__(self, child_pipe, key_id, fpr, address):
2253
2292
self._pipe = child_pipe
2254
self._pipe.send(('init', key_id, fpr, address))
2293
self._pipe.send(("init", key_id, fpr, address))
2255
2294
if not self._pipe.recv():
2256
2295
raise KeyError(key_id or fpr)
2257
2296
2258
2297
def __getattribute__(self, name):
2259
if name == '_pipe':
2298
if name == "_pipe":
2260
2299
return super(ProxyClient, self).__getattribute__(name)
2261
self._pipe.send(('getattr', name))
2300
self._pipe.send(("getattr", name))
2262
2301
data = self._pipe.recv()
2263
if data[0] == 'data':
2302
if data[0] == "data":
2264
2303
return data[1]
2265
if data[0] == 'function':
2304
if data[0] == "function":
2266
2305
2267
2306
def func(*args, **kwargs):
2268
self._pipe.send(('funcall', name, args, kwargs))
2307
self._pipe.send(("funcall", name, args, kwargs))
2269
2308
return self._pipe.recv()[1]
2270
2309
2271
2310
return func
2272
2311
2273
2312
def __setattr__(self, name, value):
2274
if name == '_pipe':
2313
if name == "_pipe":
2275
2314
return super(ProxyClient, self).__setattr__(name, value)
2276
self._pipe.send(('setattr', name, value))
2315
self._pipe.send(("setattr", name, value))
2277
2316
2278
2317
2279
2318
class ClientHandler(socketserver.BaseRequestHandler, object):
2284
2323
2285
2324
def handle(self):
2286
2325
with contextlib.closing(self.server.child_pipe) as child_pipe:
2287
logger.info("TCP connection from: %s",
2288
str(self.client_address))
2289
logger.debug("Pipe FD: %d",
2290
self.server.child_pipe.fileno())
2326
log.info("TCP connection from: %s",
2327
str(self.client_address))
2328
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2291
2329
2292
2330
session = gnutls.ClientSession(self.request)
2293
2331
2294
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2332
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2295
2333
# "+AES-256-CBC", "+SHA1",
2296
2334
# "+COMP-NULL", "+CTYPE-OPENPGP",
2297
2335
# "+DHE-DSS"))
2299
2337
priority = self.server.gnutls_priority
2300
2338
if priority is None:
2301
2339
priority = "NORMAL"
2302
gnutls.priority_set_direct(session._c_object,
2303
priority.encode("utf-8"),
2304
None)
2340
gnutls.priority_set_direct(session,
2341
priority.encode("utf-8"), None)
2305
2342
2306
2343
# Start communication using the Mandos protocol
2307
2344
# Get protocol number
2308
2345
line = self.request.makefile().readline()
2309
logger.debug("Protocol version: %r", line)
2346
log.debug("Protocol version: %r", line)
2310
2347
try:
2311
2348
if int(line.strip().split()[0]) > 1:
2312
2349
raise RuntimeError(line)
2313
2350
except (ValueError, IndexError, RuntimeError) as error:
2314
logger.error("Unknown protocol version: %s", error)
2351
log.error("Unknown protocol version: %s", error)
2315
2352
return
2316
2353
2317
2354
# Start GnuTLS connection
2318
2355
try:
2319
2356
session.handshake()
2320
2357
except gnutls.Error as error:
2321
logger.warning("Handshake failed: %s", error)
2358
log.warning("Handshake failed: %s", error)
2322
2359
# Do not run session.bye() here: the session is not
2323
2360
# established. Just abandon the request.
2324
2361
return
2325
logger.debug("Handshake succeeded")
2362
log.debug("Handshake succeeded")
2326
2363
2327
2364
approval_required = False
2328
2365
try:
2332
2369
key_id = self.key_id(
2333
2370
self.peer_certificate(session))
2334
2371
except (TypeError, gnutls.Error) as error:
2335
logger.warning("Bad certificate: %s", error)
2372
log.warning("Bad certificate: %s", error)
2336
2373
return
2337
logger.debug("Key ID: %s", key_id)
2374
log.debug("Key ID: %s",
2375
key_id.decode("utf-8",
2376
errors="replace"))
2338
2377
2339
2378
else:
2340
2379
key_id = b""
2342
2381
fpr = self.fingerprint(
2343
2382
self.peer_certificate(session))
2344
2383
except (TypeError, gnutls.Error) as error:
2345
logger.warning("Bad certificate: %s", error)
2384
log.warning("Bad certificate: %s", error)
2346
2385
return
2347
logger.debug("Fingerprint: %s", fpr)
2386
log.debug("Fingerprint: %s", fpr)
2348
2387
2349
2388
try:
2350
2389
client = ProxyClient(child_pipe, key_id, fpr,
2359
2398
2360
2399
while True:
2361
2400
if not client.enabled:
2362
logger.info("Client %s is disabled",
2363
client.name)
2401
log.info("Client %s is disabled", client.name)
2364
2402
if self.server.use_dbus:
2365
2403
# Emit D-Bus signal
2366
2404
client.Rejected("Disabled")
2370
2408
# We are approved or approval is disabled
2371
2409
break
2372
2410
elif client.approved is None:
2373
logger.info("Client %s needs approval",
2374
client.name)
2411
log.info("Client %s needs approval",
2412
client.name)
2375
2413
if self.server.use_dbus:
2376
2414
# Emit D-Bus signal
2377
2415
client.NeedApproval(
2378
2416
client.approval_delay.total_seconds()
2379
2417
* 1000, client.approved_by_default)
2380
2418
else:
2381
logger.warning("Client %s was not approved",
2382
client.name)
2419
log.warning("Client %s was not approved",
2420
client.name)
2383
2421
if self.server.use_dbus:
2384
2422
# Emit D-Bus signal
2385
2423
client.Rejected("Denied")
2393
2431
time2 = datetime.datetime.now()
2394
2432
if (time2 - time) >= delay:
2395
2433
if not client.approved_by_default:
2396
logger.warning("Client %s timed out while"
2397
" waiting for approval",
2398
client.name)
2434
log.warning("Client %s timed out while"
2435
" waiting for approval",
2436
client.name)
2399
2437
if self.server.use_dbus:
2400
2438
# Emit D-Bus signal
2401
2439
client.Rejected("Approval timed out")
2408
2446
try:
2409
2447
session.send(client.secret)
2410
2448
except gnutls.Error as error:
2411
logger.warning("gnutls send failed",
2412
exc_info=error)
2449
log.warning("gnutls send failed", exc_info=error)
2413
2450
return
2414
2451
2415
logger.info("Sending secret to %s", client.name)
2452
log.info("Sending secret to %s", client.name)
2416
2453
# bump the timeout using extended_timeout
2417
2454
client.bump_timeout(client.extended_timeout)
2418
2455
if self.server.use_dbus:
2425
2462
try:
2426
2463
session.bye()
2427
2464
except gnutls.Error as error:
2428
logger.warning("GnuTLS bye failed",
2429
exc_info=error)
2465
log.warning("GnuTLS bye failed", exc_info=error)
2430
2466
2431
2467
@staticmethod
2432
2468
def peer_certificate(session):
2433
2469
"Return the peer's certificate as a bytestring"
2434
2470
try:
2435
cert_type = gnutls.certificate_type_get2(session._c_object,
2436
gnutls.CTYPE_PEERS)
2471
cert_type = gnutls.certificate_type_get2(
2472
session, gnutls.CTYPE_PEERS)
2437
2473
except AttributeError:
2438
cert_type = gnutls.certificate_type_get(session._c_object)
2474
cert_type = gnutls.certificate_type_get(session)
2439
2475
if gnutls.has_rawpk:
2440
2476
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2441
2477
else:
2442
2478
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2443
2479
# If not a valid certificate type...
2444
2480
if cert_type not in valid_cert_types:
2445
logger.info("Cert type %r not in %r", cert_type,
2446
valid_cert_types)
2481
log.info("Cert type %r not in %r", cert_type,
2482
valid_cert_types)
2447
2483
# ...return invalid data
2448
2484
return b""
2449
2485
list_size = ctypes.c_uint(1)
2450
2486
cert_list = (gnutls.certificate_get_peers
2451
(session._c_object, ctypes.byref(list_size)))
2487
(session, ctypes.byref(list_size)))
2452
2488
if not bool(cert_list) and list_size.value != 0:
2453
2489
raise gnutls.Error("error getting peer certificate")
2454
2490
if list_size.value == 0:
2568
2604
2569
2605
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2570
2606
socketserver.TCPServer):
2571
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2607
"""IPv6-capable TCP server. Accepts None as address and/or port
2572
2608
2573
2609
Attributes:
2574
2610
enabled: Boolean; whether this server is activated yet
2625
2661
if SO_BINDTODEVICE is None:
2626
2662
# Fall back to a hard-coded value which seems to be
2627
2663
# common enough.
2628
logger.warning("SO_BINDTODEVICE not found, trying 25")
2664
log.warning("SO_BINDTODEVICE not found, trying 25")
2629
2665
SO_BINDTODEVICE = 25
2630
2666
try:
2631
2667
self.socket.setsockopt(
2633
2669
(self.interface + "\0").encode("utf-8"))
2634
2670
except socket.error as error:
2635
2671
if error.errno == errno.EPERM:
2636
logger.error("No permission to bind to"
2637
" interface %s", self.interface)
2672
log.error("No permission to bind to interface %s",
2673
self.interface)
2638
2674
elif error.errno == errno.ENOPROTOOPT:
2639
logger.error("SO_BINDTODEVICE not available;"
2640
" cannot bind to interface %s",
2641
self.interface)
2675
log.error("SO_BINDTODEVICE not available; cannot"
2676
" bind to interface %s", self.interface)
2642
2677
elif error.errno == errno.ENODEV:
2643
logger.error("Interface %s does not exist,"
2644
" cannot bind", self.interface)
2678
log.error("Interface %s does not exist, cannot"
2679
" bind", self.interface)
2645
2680
else:
2646
2681
raise
2647
2682
# Only bind(2) the socket if we really need to.
2726
2761
request = parent_pipe.recv()
2727
2762
command = request[0]
2728
2763
2729
if command == 'init':
2764
if command == "init":
2730
2765
key_id = request[1].decode("ascii")
2731
2766
fpr = request[2].decode("ascii")
2732
2767
address = request[3]
2742
2777
client = c
2743
2778
break
2744
2779
else:
2745
logger.info("Client not found for key ID: %s, address"
2746
": %s", key_id or fpr, address)
2780
log.info("Client not found for key ID: %s, address:"
2781
" %s", key_id or fpr, address)
2747
2782
if self.use_dbus:
2748
2783
# Emit D-Bus signal
2749
2784
mandos_dbus_service.ClientNotFound(key_id or fpr,
2762
2797
# remove the old hook in favor of the new above hook on
2763
2798
# same fileno
2764
2799
return False
2765
if command == 'funcall':
2800
if command == "funcall":
2766
2801
funcname = request[1]
2767
2802
args = request[2]
2768
2803
kwargs = request[3]
2769
2804
2770
parent_pipe.send(('data', getattr(client_object,
2805
parent_pipe.send(("data", getattr(client_object,
2771
2806
funcname)(*args,
2772
2807
**kwargs)))
2773
2808
2774
if command == 'getattr':
2809
if command == "getattr":
2775
2810
attrname = request[1]
2776
2811
if isinstance(client_object.__getattribute__(attrname),
2777
2812
collections.abc.Callable):
2778
parent_pipe.send(('function', ))
2813
parent_pipe.send(("function", ))
2779
2814
else:
2780
2815
parent_pipe.send((
2781
'data', client_object.__getattribute__(attrname)))
2816
"data", client_object.__getattribute__(attrname)))
2782
2817
2783
if command == 'setattr':
2818
if command == "setattr":
2784
2819
attrname = request[1]
2785
2820
value = request[2]
2786
2821
setattr(client_object, attrname, value)
2892
2927
def string_to_delta(interval):
2893
2928
"""Parse a string and return a datetime.timedelta
2894
2929
2895
>>> string_to_delta('7d') == datetime.timedelta(7)
2896
True
2897
>>> string_to_delta('60s') == datetime.timedelta(0, 60)
2898
True
2899
>>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2900
True
2901
>>> string_to_delta('24h') == datetime.timedelta(1)
2902
True
2903
>>> string_to_delta('1w') == datetime.timedelta(7)
2904
True
2905
>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
2930
>>> string_to_delta("7d") == datetime.timedelta(7)
2931
True
2932
>>> string_to_delta("60s") == datetime.timedelta(0, 60)
2933
True
2934
>>> string_to_delta("60m") == datetime.timedelta(0, 3600)
2935
True
2936
>>> string_to_delta("24h") == datetime.timedelta(1)
2937
True
2938
>>> string_to_delta("1w") == datetime.timedelta(7)
2939
True
2940
>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
2906
2941
True
2907
2942
"""
2908
2943
3112
3147
3113
3148
if server_settings["servicename"] != "Mandos":
3114
3149
syslogger.setFormatter(
3115
logging.Formatter('Mandos ({}) [%(process)d]:'
3116
' %(levelname)s: %(message)s'.format(
3150
logging.Formatter("Mandos ({}) [%(process)d]:"
3151
" %(levelname)s: %(message)s".format(
3117
3152
server_settings["servicename"])))
3118
3153
3119
3154
# Parse config file with clients
3143
3178
try:
3144
3179
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3145
3180
except IOError as e:
3146
logger.error("Could not open file %r", pidfilename,
3147
exc_info=e)
3181
log.error("Could not open file %r", pidfilename,
3182
exc_info=e)
3148
3183
3149
3184
for name, group in (("_mandos", "_mandos"),
3150
3185
("mandos", "mandos"),
3161
3196
try:
3162
3197
os.setgid(gid)
3163
3198
os.setuid(uid)
3164
if debug:
3165
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3166
gid))
3199
log.debug("Did setuid/setgid to %s:%s", uid, gid)
3167
3200
except OSError as error:
3168
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3169
.format(uid, gid, os.strerror(error.errno)))
3201
log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
3202
os.strerror(error.errno))
3170
3203
if error.errno != errno.EPERM:
3171
3204
raise
3172
3205
3179
3212
3180
3213
@gnutls.log_func
3181
3214
def debug_gnutls(level, string):
3182
logger.debug("GnuTLS: %s", string[:-1])
3215
log.debug("GnuTLS: %s",
3216
string[:-1].decode("utf-8", errors="replace"))
3183
3217
3184
3218
gnutls.global_set_log_function(debug_gnutls)
3185
3219
3214
3248
"se.bsnet.fukt.Mandos", bus,
3215
3249
do_not_queue=True)
3216
3250
except dbus.exceptions.DBusException as e:
3217
logger.error("Disabling D-Bus:", exc_info=e)
3251
log.error("Disabling D-Bus:", exc_info=e)
3218
3252
use_dbus = False
3219
3253
server_settings["use_dbus"] = False
3220
3254
tcp_server.use_dbus = False
3305
3339
os.remove(stored_state_path)
3306
3340
except IOError as e:
3307
3341
if e.errno == errno.ENOENT:
3308
logger.warning("Could not load persistent state:"
3309
" {}".format(os.strerror(e.errno)))
3342
log.warning("Could not load persistent state:"
3343
" %s", os.strerror(e.errno))
3310
3344
else:
3311
logger.critical("Could not load persistent state:",
3312
exc_info=e)
3345
log.critical("Could not load persistent state:",
3346
exc_info=e)
3313
3347
raise
3314
3348
except EOFError as e:
3315
logger.warning("Could not load persistent state: "
3316
"EOFError:",
3317
exc_info=e)
3349
log.warning("Could not load persistent state: EOFError:",
3350
exc_info=e)
3318
3351
3319
3352
with PGPEngine() as pgp:
3320
3353
for client_name, client in clients_data.items():
3347
3380
if client["enabled"]:
3348
3381
if datetime.datetime.utcnow() >= client["expires"]:
3349
3382
if not client["last_checked_ok"]:
3350
logger.warning(
3351
"disabling client {} - Client never "
3352
"performed a successful checker".format(
3353
client_name))
3383
log.warning("disabling client %s - Client"
3384
" never performed a successful"
3385
" checker", client_name)
3354
3386
client["enabled"] = False
3355
3387
elif client["last_checker_status"] != 0:
3356
logger.warning(
3357
"disabling client {} - Client last"
3358
" checker failed with error code"
3359
" {}".format(
3360
client_name,
3361
client["last_checker_status"]))
3388
log.warning("disabling client %s - Client"
3389
" last checker failed with error"
3390
" code %s", client_name,
3391
client["last_checker_status"])
3362
3392
client["enabled"] = False
3363
3393
else:
3364
3394
client["expires"] = (
3365
3395
datetime.datetime.utcnow()
3366
3396
+ client["timeout"])
3367
logger.debug("Last checker succeeded,"
3368
" keeping {} enabled".format(
3369
client_name))
3397
log.debug("Last checker succeeded, keeping %s"
3398
" enabled", client_name)
3370
3399
try:
3371
3400
client["secret"] = pgp.decrypt(
3372
3401
client["encrypted_secret"],
3373
3402
client_settings[client_name]["secret"])
3374
3403
except PGPError:
3375
3404
# If decryption fails, we use secret from new settings
3376
logger.debug("Failed to decrypt {} old secret".format(
3377
client_name))
3405
log.debug("Failed to decrypt %s old secret",
3406
client_name)
3378
3407
client["secret"] = (client_settings[client_name]
3379
3408
["secret"])
3380
3409
3394
3423
server_settings=server_settings)
3395
3424
3396
3425
if not tcp_server.clients:
3397
logger.warning("No clients defined")
3426
log.warning("No clients defined")
3398
3427
3399
3428
if not foreground:
3400
3429
if pidfile is not None:
3403
3432
with pidfile:
3404
3433
print(pid, file=pidfile)
3405
3434
except IOError:
3406
logger.error("Could not write to file %r with PID %d",
3407
pidfilename, pid)
3435
log.error("Could not write to file %r with PID %d",
3436
pidfilename, pid)
3408
3437
del pidfile
3409
3438
del pidfilename
3410
3439
3560
3589
3561
3590
try:
3562
3591
with tempfile.NamedTemporaryFile(
3563
mode='wb',
3592
mode="wb",
3564
3593
suffix=".pickle",
3565
prefix='clients-',
3594
prefix="clients-",
3566
3595
dir=os.path.dirname(stored_state_path),
3567
3596
delete=False) as stored_state:
3568
3597
pickle.dump((clients, client_settings), stored_state,
3576
3605
except NameError:
3577
3606
pass
3578
3607
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3579
logger.warning("Could not save persistent state: {}"
3580
.format(os.strerror(e.errno)))
3608
log.warning("Could not save persistent state: %s",
3609
os.strerror(e.errno))
3581
3610
else:
3582
logger.warning("Could not save persistent state:",
3583
exc_info=e)
3611
log.warning("Could not save persistent state:",
3612
exc_info=e)
3584
3613
raise
3585
3614
3586
3615
# Delete all clients, and settings from config
3603
3632
mandos_dbus_service.client_added_signal(client)
3604
3633
# Need to initiate checking of clients
3605
3634
if client.enabled:
3606
client.init_checker()
3635
client.init_checker(randomize_start=True)
3607
3636
3608
3637
tcp_server.enable()
3609
3638
tcp_server.server_activate()
3612
3641
if zeroconf:
3613
3642
service.port = tcp_server.socket.getsockname()[1]
3614
3643
if use_ipv6:
3615
logger.info("Now listening on address %r, port %d,"
3616
" flowinfo %d, scope_id %d",
3617
*tcp_server.socket.getsockname())
3644
log.info("Now listening on address %r, port %d, flowinfo %d,"
3645
" scope_id %d", *tcp_server.socket.getsockname())
3618
3646
else: # IPv4
3619
logger.info("Now listening on address %r, port %d",
3620
*tcp_server.socket.getsockname())
3647
log.info("Now listening on address %r, port %d",
3648
*tcp_server.socket.getsockname())
3621
3649
3622
3650
# service.interface = tcp_server.socket.getsockname()[3]
3623
3651
3627
3655
try:
3628
3656
service.activate()
3629
3657
except dbus.exceptions.DBusException as error:
3630
logger.critical("D-Bus Exception", exc_info=error)
3658
log.critical("D-Bus Exception", exc_info=error)
3631
3659
cleanup()
3632
3660
sys.exit(1)
3633
3661
# End of Avahi example code
3638
3666
lambda *args, **kwargs: (tcp_server.handle_request
3639
3667
(*args[2:], **kwargs) or True))
3640
3668
3641
logger.debug("Starting main loop")
3669
log.debug("Starting main loop")
3642
3670
main_loop.run()
3643
3671
except AvahiError as error:
3644
logger.critical("Avahi Error", exc_info=error)
3672
log.critical("Avahi Error", exc_info=error)
3645
3673
cleanup()
3646
3674
sys.exit(1)
3647
3675
except KeyboardInterrupt:
3648
3676
if debug:
3649
3677
print("", file=sys.stderr)
3650
logger.debug("Server received KeyboardInterrupt")
3651
logger.debug("Server exiting")
3678
log.debug("Server received KeyboardInterrupt")
3679
log.debug("Server exiting")
3652
3680
# Must run before the D-Bus bus name gets deregistered
3653
3681
cleanup()
3654
3682
3655
3683
3656
def should_only_run_tests():
3684
def parse_test_args():
3685
# type: () -> argparse.Namespace
3657
3686
parser = argparse.ArgumentParser(add_help=False)
3658
parser.add_argument("--check", action='store_true')
3687
parser.add_argument("--check", action="store_true")
3688
parser.add_argument("--prefix", )
3659
3689
args, unknown_args = parser.parse_known_args()
3660
run_tests = args.check
3661
if run_tests:
3662
# Remove --check argument from sys.argv
3690
if args.check:
3691
# Remove test options from sys.argv
3663
3692
sys.argv[1:] = unknown_args
3664
return run_tests
3693
return args
3665
3694
3666
3695
# Add all tests from doctest strings
3667
3696
def load_tests(loader, tests, none):
3669
3698
tests.addTests(doctest.DocTestSuite())
3670
3699
return tests
3671
3700
3672
if __name__ == '__main__':
3701
if __name__ == "__main__":
3702
options = parse_test_args()
3673
3703
try:
3674
if should_only_run_tests():
3675
# Call using ./mandos --check [--verbose]
3676
unittest.main()
3704
if options.check:
3705
extra_test_prefix = options.prefix
3706
if extra_test_prefix is not None:
3707
if not (unittest.main(argv=[""], exit=False)
3708
.result.wasSuccessful()):
3709
sys.exit(1)
3710
class ExtraTestLoader(unittest.TestLoader):
3711
testMethodPrefix = extra_test_prefix
3712
# Call using ./scriptname --test [--verbose]
3713
unittest.main(argv=[""], testLoader=ExtraTestLoader())
3714
else:
3715
unittest.main(argv=[""])
3677
3716
else:
3678
3717
main()
3679
3718
finally:
3680
3719
logging.shutdown()
3720
3721
# Local Variables:
3722
# run-tests:
3723
# (lambda (&optional extra)
3724
# (if (not (funcall run-tests-in-test-buffer default-directory
3725
# extra))
3726
# (funcall show-test-buffer-in-test-window)
3727
# (funcall remove-test-window)
3728
# (if extra (message "Extra tests run successfully!"))))
3729
# run-tests-in-test-buffer:
3730
# (lambda (dir &optional extra)
3731
# (with-current-buffer (get-buffer-create "*Test*")
3732
# (setq buffer-read-only nil
3733
# default-directory dir)
3734
# (erase-buffer)
3735
# (compilation-mode))
3736
# (let ((process-result
3737
# (let ((inhibit-read-only t))
3738
# (process-file-shell-command
3739
# (funcall get-command-line extra) nil "*Test*"))))
3740
# (and (numberp process-result)
3741
# (= process-result 0))))
3742
# get-command-line:
3743
# (lambda (&optional extra)
3744
# (let ((quoted-script
3745
# (shell-quote-argument (funcall get-script-name))))
3746
# (format
3747
# (concat "%s --check" (if extra " --prefix=atest" ""))
3748
# quoted-script)))
3749
# get-script-name:
3750
# (lambda ()
3751
# (if (fboundp 'file-local-name)
3752
# (file-local-name (buffer-file-name))
3753
# (or (file-remote-p (buffer-file-name) 'localname)
3754
# (buffer-file-name))))
3755
# remove-test-window:
3756
# (lambda ()
3757
# (let ((test-window (get-buffer-window "*Test*")))
3758
# (if test-window (delete-window test-window))))
3759
# show-test-buffer-in-test-window:
3760
# (lambda ()
3761
# (when (not (get-buffer-window-list "*Test*"))
3762
# (setq next-error-last-buffer (get-buffer "*Test*"))
3763
# (let* ((side (if (>= (window-width) 146) 'right 'bottom))
3764
# (display-buffer-overriding-action
3765
# `((display-buffer-in-side-window) (side . ,side)
3766
# (window-height . fit-window-to-buffer)
3767
# (window-width . fit-window-to-buffer))))
3768
# (display-buffer "*Test*"))))
3769
# eval:
3770
# (progn
3771
# (let* ((run-extra-tests (lambda () (interactive)
3772
# (funcall run-tests t)))
3773
# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
3774
# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c
3775
# (setq minor-mode-overriding-map-alist
3776
# (cons `(run-tests . ,outer-keymap)
3777
# minor-mode-overriding-map-alist)))
3778
# (add-hook 'after-save-hook run-tests 90 t))
3779
# End:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0