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 1211
- compare with another revision
- download diff
- download tarball
- view history from revision 1211
- Committer: teddy at recompile
- Date: 2020-03-21 16:23:36 UTC
- Revision ID: teddy@recompile.se-20200321162336-3wdi81k9x65ffyav
Update Debian Policy version to 4.5.0; no other changes necessary.
* debian/control (Standards-Version): Change to "4.5.0".
* debian/control (Standards-Version): Change to "4.5.0".
- files removed:
- debian/po/es.po
- files modified:
- DBUS-API
added
removed
mandos
1
1
#!/usr/bin/python3 -bI
2
# -*- coding: utf-8; lexical-binding: t -*-
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 -*-
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-2022 Teddy Hogeborn
15
# Copyright © 2008-2022 Björn Påhlsson
14
# Copyright © 2008-2019 Teddy Hogeborn
15
# Copyright © 2008-2019 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
34
35
from __future__ import (division, absolute_import, print_function,
35
36
unicode_literals)
36
37
39
40
except ImportError:
40
41
pass
41
42
42
import sys
43
import unittest
44
import argparse
45
import logging
46
import os
47
43
try:
48
44
import SocketServer as socketserver
49
45
except ImportError:
50
46
import socketserver
51
47
import socket
48
import argparse
52
49
import datetime
53
50
import errno
54
51
try:
55
52
import ConfigParser as configparser
56
53
except ImportError:
57
54
import configparser
55
import sys
58
56
import re
57
import os
59
58
import signal
60
59
import subprocess
61
60
import atexit
62
61
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
80
81
import random
81
82
import shlex
82
83
93
94
if sys.version_info.major == 2:
94
95
__metaclass__ = type
95
96
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.16"
146
version = "1.8.9"
147
147
stored_state_file = "clients.pickle"
148
148
149
log = logging.getLogger(os.path.basename(sys.argv[0]))
149
logger = logging.getLogger()
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
log.addHandler(syslogger)
192
('Mandos [%(process)d]: %(levelname)s:'
193
' %(message)s'))
194
logger.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
log.addHandler(console)
203
log.setLevel(level)
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)
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
log.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
399
self.rename_count)
397
logger.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
log.info("Changing Zeroconf service name to %r ...",
405
self.name)
404
logger.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
log.info("Local Zeroconf service name collision.")
413
logger.info("Local Zeroconf service name collision.")
414
414
return self.rename(remove=False)
415
415
else:
416
log.critical("D-Bus Exception", exc_info=error)
416
logger.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
log.debug("Adding Zeroconf service '%s' of type '%s' ...",
440
self.name, self.type)
438
'StateChanged', self.entry_group_state_changed))
439
logger.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
log.debug("Avahi entry group state change: %i", state)
453
logger.debug("Avahi entry group state change: %i", state)
454
454
455
455
if state == avahi.ENTRY_GROUP_ESTABLISHED:
456
log.debug("Zeroconf service established.")
456
logger.debug("Zeroconf service established.")
457
457
elif state == avahi.ENTRY_GROUP_COLLISION:
458
log.info("Zeroconf service name collision.")
458
logger.info("Zeroconf service name collision.")
459
459
self.rename()
460
460
elif state == avahi.ENTRY_GROUP_FAILURE:
461
log.critical("Avahi: Error in group state changed %s",
462
str(error))
461
logger.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
log.debug("Avahi server state change: %i", state)
478
logger.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
log.error(bad_states[state])
488
logger.error(bad_states[state])
489
489
else:
490
log.error(bad_states[state] + ": %r", error)
490
logger.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
log.info("Local Zeroconf service name collision.")
498
logger.info("Local Zeroconf service name"
499
" collision.")
499
500
return self.rename(remove=False)
500
501
else:
501
log.critical("D-Bus Exception", exc_info=error)
502
logger.critical("D-Bus Exception", exc_info=error)
502
503
self.cleanup()
503
504
os._exit(1)
504
505
else:
505
506
if error is None:
506
log.debug("Unknown state: %r", state)
507
logger.debug("Unknown state: %r", state)
507
508
else:
508
log.debug("Unknown state: %r: %r", state, error)
509
logger.debug("Unknown state: %r: %r", state, error)
509
510
510
511
def activate(self):
511
512
"""Derived from the Avahi example code"""
523
524
class AvahiServiceToSyslog(AvahiService):
524
525
def rename(self, *args, **kwargs):
525
526
"""Add the new name to the syslog messages"""
526
ret = super(AvahiServiceToSyslog, self).rename(*args,
527
**kwargs)
527
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
528
528
syslogger.setFormatter(logging.Formatter(
529
"Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
529
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
530
530
.format(self.name)))
531
531
return ret
532
532
562
562
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
563
563
564
564
# Types
565
class _session_int(ctypes.Structure):
565
class session_int(ctypes.Structure):
566
566
_fields_ = []
567
session_t = ctypes.POINTER(_session_int)
567
session_t = ctypes.POINTER(session_int)
568
568
569
569
class certificate_credentials_st(ctypes.Structure):
570
570
_fields_ = []
573
573
certificate_type_t = ctypes.c_int
574
574
575
575
class datum_t(ctypes.Structure):
576
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
577
("size", ctypes.c_uint)]
576
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
577
('size', ctypes.c_uint)]
578
578
579
class _openpgp_crt_int(ctypes.Structure):
579
class openpgp_crt_int(ctypes.Structure):
580
580
_fields_ = []
581
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
581
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
582
582
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
583
583
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
584
584
credentials_type_t = ctypes.c_int
593
593
# gnutls.strerror()
594
594
self.code = code
595
595
if message is None and code is not None:
596
message = gnutls.strerror(code).decode(
597
"utf-8", errors="replace")
596
message = gnutls.strerror(code)
598
597
return super(gnutls.Error, self).__init__(
599
598
message, *args)
600
599
601
600
class CertificateSecurityError(Error):
602
601
pass
603
602
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
629
603
# Classes
630
class Credentials(With_from_param):
604
class Credentials:
631
605
def __init__(self):
632
self._as_parameter_ = gnutls.certificate_credentials_t()
633
gnutls.certificate_allocate_credentials(self)
606
self._c_object = gnutls.certificate_credentials_t()
607
gnutls.certificate_allocate_credentials(
608
ctypes.byref(self._c_object))
634
609
self.type = gnutls.CRD_CERTIFICATE
635
610
636
611
def __del__(self):
637
gnutls.certificate_free_credentials(self)
612
gnutls.certificate_free_credentials(self._c_object)
638
613
639
class ClientSession(With_from_param):
614
class ClientSession:
640
615
def __init__(self, socket, credentials=None):
641
self._as_parameter_ = gnutls.session_t()
616
self._c_object = gnutls.session_t()
642
617
gnutls_flags = gnutls.CLIENT
643
618
if gnutls.check_version(b"3.5.6"):
644
619
gnutls_flags |= gnutls.NO_TICKETS
645
620
if gnutls.has_rawpk:
646
621
gnutls_flags |= gnutls.ENABLE_RAWPK
647
gnutls.init(self, gnutls_flags)
622
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
648
623
del gnutls_flags
649
gnutls.set_default_priority(self)
650
gnutls.transport_set_ptr(self, socket.fileno())
651
gnutls.handshake_set_private_extensions(self, True)
624
gnutls.set_default_priority(self._c_object)
625
gnutls.transport_set_ptr(self._c_object, socket.fileno())
626
gnutls.handshake_set_private_extensions(self._c_object,
627
True)
652
628
self.socket = socket
653
629
if credentials is None:
654
630
credentials = gnutls.Credentials()
655
gnutls.credentials_set(self, credentials.type,
656
credentials)
631
gnutls.credentials_set(self._c_object, credentials.type,
632
ctypes.cast(credentials._c_object,
633
ctypes.c_void_p))
657
634
self.credentials = credentials
658
635
659
636
def __del__(self):
660
gnutls.deinit(self)
637
gnutls.deinit(self._c_object)
661
638
662
639
def handshake(self):
663
return gnutls.handshake(self)
640
return gnutls.handshake(self._c_object)
664
641
665
642
def send(self, data):
666
643
data = bytes(data)
667
644
data_len = len(data)
668
645
while data_len > 0:
669
data_len -= gnutls.record_send(self, data[-data_len:],
646
data_len -= gnutls.record_send(self._c_object,
647
data[-data_len:],
670
648
data_len)
671
649
672
650
def bye(self):
673
return gnutls.bye(self, gnutls.SHUT_RDWR)
651
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
674
652
675
653
# Error handling functions
676
654
def _error_code(result):
677
655
"""A function to raise exceptions on errors, suitable
678
for the "restype" attribute on ctypes functions"""
679
if result >= gnutls.E_SUCCESS:
656
for the 'restype' attribute on ctypes functions"""
657
if result >= 0:
680
658
return result
681
659
if result == gnutls.E_NO_CERTIFICATE_FOUND:
682
660
raise gnutls.CertificateSecurityError(code=result)
683
661
raise gnutls.Error(code=result)
684
662
685
def _retry_on_error(result, func, arguments,
686
_error_code=_error_code):
663
def _retry_on_error(result, func, arguments):
687
664
"""A function to retry on some errors, suitable
688
for the "errcheck" attribute on ctypes functions"""
689
while result < gnutls.E_SUCCESS:
665
for the 'errcheck' attribute on ctypes functions"""
666
while result < 0:
690
667
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
691
668
return _error_code(result)
692
669
result = func(*arguments)
697
674
698
675
# Functions
699
676
priority_set_direct = _library.gnutls_priority_set_direct
700
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
677
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
701
678
ctypes.POINTER(ctypes.c_char_p)]
702
679
priority_set_direct.restype = _error_code
703
680
704
681
init = _library.gnutls_init
705
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
682
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
706
683
init.restype = _error_code
707
684
708
685
set_default_priority = _library.gnutls_set_default_priority
709
set_default_priority.argtypes = [ClientSession]
686
set_default_priority.argtypes = [session_t]
710
687
set_default_priority.restype = _error_code
711
688
712
689
record_send = _library.gnutls_record_send
713
record_send.argtypes = [ClientSession, ctypes.c_void_p,
690
record_send.argtypes = [session_t, ctypes.c_void_p,
714
691
ctypes.c_size_t]
715
692
record_send.restype = ctypes.c_ssize_t
716
693
record_send.errcheck = _retry_on_error
718
695
certificate_allocate_credentials = (
719
696
_library.gnutls_certificate_allocate_credentials)
720
697
certificate_allocate_credentials.argtypes = [
721
PointerTo(Credentials)]
698
ctypes.POINTER(certificate_credentials_t)]
722
699
certificate_allocate_credentials.restype = _error_code
723
700
724
701
certificate_free_credentials = (
725
702
_library.gnutls_certificate_free_credentials)
726
certificate_free_credentials.argtypes = [Credentials]
703
certificate_free_credentials.argtypes = [
704
certificate_credentials_t]
727
705
certificate_free_credentials.restype = None
728
706
729
707
handshake_set_private_extensions = (
730
708
_library.gnutls_handshake_set_private_extensions)
731
handshake_set_private_extensions.argtypes = [ClientSession,
709
handshake_set_private_extensions.argtypes = [session_t,
732
710
ctypes.c_int]
733
711
handshake_set_private_extensions.restype = None
734
712
735
713
credentials_set = _library.gnutls_credentials_set
736
credentials_set.argtypes = [ClientSession, credentials_type_t,
737
CastToVoidPointer(Credentials)]
714
credentials_set.argtypes = [session_t, credentials_type_t,
715
ctypes.c_void_p]
738
716
credentials_set.restype = _error_code
739
717
740
718
strerror = _library.gnutls_strerror
742
720
strerror.restype = ctypes.c_char_p
743
721
744
722
certificate_type_get = _library.gnutls_certificate_type_get
745
certificate_type_get.argtypes = [ClientSession]
723
certificate_type_get.argtypes = [session_t]
746
724
certificate_type_get.restype = _error_code
747
725
748
726
certificate_get_peers = _library.gnutls_certificate_get_peers
749
certificate_get_peers.argtypes = [ClientSession,
727
certificate_get_peers.argtypes = [session_t,
750
728
ctypes.POINTER(ctypes.c_uint)]
751
729
certificate_get_peers.restype = ctypes.POINTER(datum_t)
752
730
759
737
global_set_log_function.restype = None
760
738
761
739
deinit = _library.gnutls_deinit
762
deinit.argtypes = [ClientSession]
740
deinit.argtypes = [session_t]
763
741
deinit.restype = None
764
742
765
743
handshake = _library.gnutls_handshake
766
handshake.argtypes = [ClientSession]
767
handshake.restype = ctypes.c_int
744
handshake.argtypes = [session_t]
745
handshake.restype = _error_code
768
746
handshake.errcheck = _retry_on_error
769
747
770
748
transport_set_ptr = _library.gnutls_transport_set_ptr
771
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
749
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
772
750
transport_set_ptr.restype = None
773
751
774
752
bye = _library.gnutls_bye
775
bye.argtypes = [ClientSession, close_request_t]
776
bye.restype = ctypes.c_int
753
bye.argtypes = [session_t, close_request_t]
754
bye.restype = _error_code
777
755
bye.errcheck = _retry_on_error
778
756
779
757
check_version = _library.gnutls_check_version
796
774
797
775
x509_crt_fmt_t = ctypes.c_int
798
776
799
# All the function declarations below are from
800
# gnutls/abstract.h
777
# All the function declarations below are from gnutls/abstract.h
801
778
pubkey_init = _library.gnutls_pubkey_init
802
779
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
803
780
pubkey_init.restype = _error_code
817
794
pubkey_deinit.argtypes = [pubkey_t]
818
795
pubkey_deinit.restype = None
819
796
else:
820
# All the function declarations below are from
821
# gnutls/openpgp.h
797
# All the function declarations below are from gnutls/openpgp.h
822
798
823
799
openpgp_crt_init = _library.gnutls_openpgp_crt_init
824
800
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
830
806
openpgp_crt_fmt_t]
831
807
openpgp_crt_import.restype = _error_code
832
808
833
openpgp_crt_verify_self = \
834
_library.gnutls_openpgp_crt_verify_self
835
openpgp_crt_verify_self.argtypes = [
836
openpgp_crt_t,
837
ctypes.c_uint,
838
ctypes.POINTER(ctypes.c_uint),
839
]
809
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
810
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
811
ctypes.POINTER(ctypes.c_uint)]
840
812
openpgp_crt_verify_self.restype = _error_code
841
813
842
814
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
853
825
854
826
if check_version(b"3.6.4"):
855
827
certificate_type_get2 = _library.gnutls_certificate_type_get2
856
certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
828
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
857
829
certificate_type_get2.restype = _error_code
858
830
859
831
# Remove non-public functions
875
847
"""A representation of a client host served by this server.
876
848
877
849
Attributes:
878
approved: bool(); None if not yet approved/disapproved
850
approved: bool(); 'None' if not yet approved/disapproved
879
851
approval_delay: datetime.timedelta(); Time to wait for approval
880
852
approval_duration: datetime.timedelta(); Duration of one approval
881
853
checker: multiprocessing.Process(); a running checker process used
882
to see if the client lives. None if no process is
854
to see if the client lives. 'None' if no process is
883
855
running.
884
856
checker_callback_tag: a GLib event source tag, or None
885
857
checker_command: string; External command which is run to check
1009
981
self.last_enabled = None
1010
982
self.expires = None
1011
983
1012
log.debug("Creating client %r", self.name)
1013
log.debug(" Key ID: %s", self.key_id)
1014
log.debug(" Fingerprint: %s", self.fingerprint)
984
logger.debug("Creating client %r", self.name)
985
logger.debug(" Key ID: %s", self.key_id)
986
logger.debug(" Fingerprint: %s", self.fingerprint)
1015
987
self.created = settings.get("created",
1016
988
datetime.datetime.utcnow())
1017
989
1045
1017
if getattr(self, "enabled", False):
1046
1018
# Already enabled
1047
1019
return
1020
self.expires = datetime.datetime.utcnow() + self.timeout
1048
1021
self.enabled = True
1049
1022
self.last_enabled = datetime.datetime.utcnow()
1050
1023
self.init_checker()
1055
1028
if not getattr(self, "enabled", False):
1056
1029
return False
1057
1030
if not quiet:
1058
log.info("Disabling client %s", self.name)
1031
logger.info("Disabling client %s", self.name)
1059
1032
if getattr(self, "disable_initiator_tag", None) is not None:
1060
1033
GLib.source_remove(self.disable_initiator_tag)
1061
1034
self.disable_initiator_tag = None
1073
1046
def __del__(self):
1074
1047
self.disable()
1075
1048
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.
1049
def init_checker(self):
1050
# Schedule a new checker to be started an 'interval' from now,
1051
# and every interval from then on.
1081
1052
if self.checker_initiator_tag is not None:
1082
1053
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
1090
1054
self.checker_initiator_tag = GLib.timeout_add(
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
1055
random.randrange(int(self.interval.total_seconds() * 1000
1056
+ 1)),
1057
self.start_checker)
1058
# Schedule a disable() when 'timeout' has passed
1100
1059
if self.disable_initiator_tag is not None:
1101
1060
GLib.source_remove(self.disable_initiator_tag)
1102
1061
self.disable_initiator_tag = GLib.timeout_add(
1103
int((self.expires - now).total_seconds() * 1000),
1104
self.disable)
1062
int(self.timeout.total_seconds() * 1000), self.disable)
1063
# Also start a new checker *right now*.
1064
self.start_checker()
1105
1065
1106
1066
def checker_callback(self, source, condition, connection,
1107
1067
command):
1118
1078
self.last_checker_status = returncode
1119
1079
self.last_checker_signal = None
1120
1080
if self.last_checker_status == 0:
1121
log.info("Checker for %(name)s succeeded", vars(self))
1081
logger.info("Checker for %(name)s succeeded",
1082
vars(self))
1122
1083
self.checked_ok()
1123
1084
else:
1124
log.info("Checker for %(name)s failed", vars(self))
1085
logger.info("Checker for %(name)s failed", vars(self))
1125
1086
else:
1126
1087
self.last_checker_status = -1
1127
1088
self.last_checker_signal = -returncode
1128
log.warning("Checker for %(name)s crashed?", vars(self))
1089
logger.warning("Checker for %(name)s crashed?",
1090
vars(self))
1129
1091
return False
1130
1092
1131
1093
def checked_ok(self):
1150
1112
def need_approval(self):
1151
1113
self.last_approval_request = datetime.datetime.utcnow()
1152
1114
1153
def start_checker(self, start_was_randomized=False):
1115
def start_checker(self):
1154
1116
"""Start a new checker subprocess if one is not running.
1155
1117
1156
1118
If a checker already exists, leave it running and do
1165
1127
# should be.
1166
1128
1167
1129
if self.checker is not None and not self.checker.is_alive():
1168
log.warning("Checker was not alive; joining")
1130
logger.warning("Checker was not alive; joining")
1169
1131
self.checker.join()
1170
1132
self.checker = None
1171
1133
# Start a new checker if needed
1177
1139
try:
1178
1140
command = self.checker_command % escaped_attrs
1179
1141
except TypeError as error:
1180
log.error('Could not format string "%s"',
1181
self.checker_command, exc_info=error)
1142
logger.error('Could not format string "%s"',
1143
self.checker_command,
1144
exc_info=error)
1182
1145
return True # Try again later
1183
1146
self.current_checker_command = command
1184
log.info("Starting checker %r for %s", command, self.name)
1147
logger.info("Starting checker %r for %s", command,
1148
self.name)
1185
1149
# We don't need to redirect stdout and stderr, since
1186
1150
# in normal mode, that is already done by daemon(),
1187
1151
# and in debug mode we don't want to. (Stdin is
1206
1170
GLib.IOChannel.unix_new(pipe[0].fileno()),
1207
1171
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1208
1172
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
1220
1173
# Re-run this periodically if run by GLib.timeout_add
1221
1174
return True
1222
1175
1227
1180
self.checker_callback_tag = None
1228
1181
if getattr(self, "checker", None) is None:
1229
1182
return
1230
log.debug("Stopping checker for %(name)s", vars(self))
1183
logger.debug("Stopping checker for %(name)s", vars(self))
1231
1184
self.checker.terminate()
1232
1185
self.checker = None
1233
1186
1260
1213
func._dbus_name = func.__name__
1261
1214
if func._dbus_name.endswith("_dbus_property"):
1262
1215
func._dbus_name = func._dbus_name[:-14]
1263
func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1216
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1264
1217
return func
1265
1218
1266
1219
return decorator
1355
1308
1356
1309
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1357
1310
out_signature="s",
1358
path_keyword="object_path",
1359
connection_keyword="connection")
1311
path_keyword='object_path',
1312
connection_keyword='connection')
1360
1313
def Introspect(self, object_path, connection):
1361
1314
"""Overloading of standard D-Bus method.
1362
1315
1411
1364
document.unlink()
1412
1365
except (AttributeError, xml.dom.DOMException,
1413
1366
xml.parsers.expat.ExpatError) as error:
1414
log.error("Failed to override Introspection method",
1415
exc_info=error)
1367
logger.error("Failed to override Introspection method",
1368
exc_info=error)
1416
1369
return xmlstring
1417
1370
1418
1371
1515
1468
1516
1469
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1517
1470
out_signature="s",
1518
path_keyword="object_path",
1519
connection_keyword="connection")
1471
path_keyword='object_path',
1472
connection_keyword='connection')
1520
1473
def Introspect(self, object_path, connection):
1521
1474
"""Overloading of standard D-Bus method.
1522
1475
1578
1531
document.unlink()
1579
1532
except (AttributeError, xml.dom.DOMException,
1580
1533
xml.parsers.expat.ExpatError) as error:
1581
log.error("Failed to override Introspection method",
1582
exc_info=error)
1534
logger.error("Failed to override Introspection method",
1535
exc_info=error)
1583
1536
return xmlstring
1584
1537
1585
1538
1617
1570
1618
1571
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1619
1572
out_signature="s",
1620
path_keyword="object_path",
1621
connection_keyword="connection")
1573
path_keyword='object_path',
1574
connection_keyword='connection')
1622
1575
def Introspect(self, object_path, connection):
1623
1576
"""Overloading of standard D-Bus method.
1624
1577
1649
1602
document.unlink()
1650
1603
except (AttributeError, xml.dom.DOMException,
1651
1604
xml.parsers.expat.ExpatError) as error:
1652
log.error("Failed to override Introspection method",
1653
exc_info=error)
1605
logger.error("Failed to override Introspection method",
1606
exc_info=error)
1654
1607
return xmlstring
1655
1608
1656
1609
2290
2243
class ProxyClient:
2291
2244
def __init__(self, child_pipe, key_id, fpr, address):
2292
2245
self._pipe = child_pipe
2293
self._pipe.send(("init", key_id, fpr, address))
2246
self._pipe.send(('init', key_id, fpr, address))
2294
2247
if not self._pipe.recv():
2295
2248
raise KeyError(key_id or fpr)
2296
2249
2297
2250
def __getattribute__(self, name):
2298
if name == "_pipe":
2251
if name == '_pipe':
2299
2252
return super(ProxyClient, self).__getattribute__(name)
2300
self._pipe.send(("getattr", name))
2253
self._pipe.send(('getattr', name))
2301
2254
data = self._pipe.recv()
2302
if data[0] == "data":
2255
if data[0] == 'data':
2303
2256
return data[1]
2304
if data[0] == "function":
2257
if data[0] == 'function':
2305
2258
2306
2259
def func(*args, **kwargs):
2307
self._pipe.send(("funcall", name, args, kwargs))
2260
self._pipe.send(('funcall', name, args, kwargs))
2308
2261
return self._pipe.recv()[1]
2309
2262
2310
2263
return func
2311
2264
2312
2265
def __setattr__(self, name, value):
2313
if name == "_pipe":
2266
if name == '_pipe':
2314
2267
return super(ProxyClient, self).__setattr__(name, value)
2315
self._pipe.send(("setattr", name, value))
2268
self._pipe.send(('setattr', name, value))
2316
2269
2317
2270
2318
2271
class ClientHandler(socketserver.BaseRequestHandler, object):
2323
2276
2324
2277
def handle(self):
2325
2278
with contextlib.closing(self.server.child_pipe) as child_pipe:
2326
log.info("TCP connection from: %s",
2327
str(self.client_address))
2328
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2279
logger.info("TCP connection from: %s",
2280
str(self.client_address))
2281
logger.debug("Pipe FD: %d",
2282
self.server.child_pipe.fileno())
2329
2283
2330
2284
session = gnutls.ClientSession(self.request)
2331
2285
2332
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2286
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2333
2287
# "+AES-256-CBC", "+SHA1",
2334
2288
# "+COMP-NULL", "+CTYPE-OPENPGP",
2335
2289
# "+DHE-DSS"))
2337
2291
priority = self.server.gnutls_priority
2338
2292
if priority is None:
2339
2293
priority = "NORMAL"
2340
gnutls.priority_set_direct(session,
2341
priority.encode("utf-8"), None)
2294
gnutls.priority_set_direct(session._c_object,
2295
priority.encode("utf-8"),
2296
None)
2342
2297
2343
2298
# Start communication using the Mandos protocol
2344
2299
# Get protocol number
2345
2300
line = self.request.makefile().readline()
2346
log.debug("Protocol version: %r", line)
2301
logger.debug("Protocol version: %r", line)
2347
2302
try:
2348
2303
if int(line.strip().split()[0]) > 1:
2349
2304
raise RuntimeError(line)
2350
2305
except (ValueError, IndexError, RuntimeError) as error:
2351
log.error("Unknown protocol version: %s", error)
2306
logger.error("Unknown protocol version: %s", error)
2352
2307
return
2353
2308
2354
2309
# Start GnuTLS connection
2355
2310
try:
2356
2311
session.handshake()
2357
2312
except gnutls.Error as error:
2358
log.warning("Handshake failed: %s", error)
2313
logger.warning("Handshake failed: %s", error)
2359
2314
# Do not run session.bye() here: the session is not
2360
2315
# established. Just abandon the request.
2361
2316
return
2362
log.debug("Handshake succeeded")
2317
logger.debug("Handshake succeeded")
2363
2318
2364
2319
approval_required = False
2365
2320
try:
2369
2324
key_id = self.key_id(
2370
2325
self.peer_certificate(session))
2371
2326
except (TypeError, gnutls.Error) as error:
2372
log.warning("Bad certificate: %s", error)
2327
logger.warning("Bad certificate: %s", error)
2373
2328
return
2374
log.debug("Key ID: %s",
2375
key_id.decode("utf-8",
2376
errors="replace"))
2329
logger.debug("Key ID: %s", key_id)
2377
2330
2378
2331
else:
2379
2332
key_id = b""
2381
2334
fpr = self.fingerprint(
2382
2335
self.peer_certificate(session))
2383
2336
except (TypeError, gnutls.Error) as error:
2384
log.warning("Bad certificate: %s", error)
2337
logger.warning("Bad certificate: %s", error)
2385
2338
return
2386
log.debug("Fingerprint: %s", fpr)
2339
logger.debug("Fingerprint: %s", fpr)
2387
2340
2388
2341
try:
2389
2342
client = ProxyClient(child_pipe, key_id, fpr,
2398
2351
2399
2352
while True:
2400
2353
if not client.enabled:
2401
log.info("Client %s is disabled", client.name)
2354
logger.info("Client %s is disabled",
2355
client.name)
2402
2356
if self.server.use_dbus:
2403
2357
# Emit D-Bus signal
2404
2358
client.Rejected("Disabled")
2408
2362
# We are approved or approval is disabled
2409
2363
break
2410
2364
elif client.approved is None:
2411
log.info("Client %s needs approval",
2412
client.name)
2365
logger.info("Client %s needs approval",
2366
client.name)
2413
2367
if self.server.use_dbus:
2414
2368
# Emit D-Bus signal
2415
2369
client.NeedApproval(
2416
2370
client.approval_delay.total_seconds()
2417
2371
* 1000, client.approved_by_default)
2418
2372
else:
2419
log.warning("Client %s was not approved",
2420
client.name)
2373
logger.warning("Client %s was not approved",
2374
client.name)
2421
2375
if self.server.use_dbus:
2422
2376
# Emit D-Bus signal
2423
2377
client.Rejected("Denied")
2431
2385
time2 = datetime.datetime.now()
2432
2386
if (time2 - time) >= delay:
2433
2387
if not client.approved_by_default:
2434
log.warning("Client %s timed out while"
2435
" waiting for approval",
2436
client.name)
2388
logger.warning("Client %s timed out while"
2389
" waiting for approval",
2390
client.name)
2437
2391
if self.server.use_dbus:
2438
2392
# Emit D-Bus signal
2439
2393
client.Rejected("Approval timed out")
2446
2400
try:
2447
2401
session.send(client.secret)
2448
2402
except gnutls.Error as error:
2449
log.warning("gnutls send failed", exc_info=error)
2403
logger.warning("gnutls send failed",
2404
exc_info=error)
2450
2405
return
2451
2406
2452
log.info("Sending secret to %s", client.name)
2407
logger.info("Sending secret to %s", client.name)
2453
2408
# bump the timeout using extended_timeout
2454
2409
client.bump_timeout(client.extended_timeout)
2455
2410
if self.server.use_dbus:
2462
2417
try:
2463
2418
session.bye()
2464
2419
except gnutls.Error as error:
2465
log.warning("GnuTLS bye failed", exc_info=error)
2420
logger.warning("GnuTLS bye failed",
2421
exc_info=error)
2466
2422
2467
2423
@staticmethod
2468
2424
def peer_certificate(session):
2469
2425
"Return the peer's certificate as a bytestring"
2470
2426
try:
2471
cert_type = gnutls.certificate_type_get2(
2472
session, gnutls.CTYPE_PEERS)
2427
cert_type = gnutls.certificate_type_get2(session._c_object,
2428
gnutls.CTYPE_PEERS)
2473
2429
except AttributeError:
2474
cert_type = gnutls.certificate_type_get(session)
2430
cert_type = gnutls.certificate_type_get(session._c_object)
2475
2431
if gnutls.has_rawpk:
2476
2432
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2477
2433
else:
2478
2434
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2479
2435
# If not a valid certificate type...
2480
2436
if cert_type not in valid_cert_types:
2481
log.info("Cert type %r not in %r", cert_type,
2482
valid_cert_types)
2437
logger.info("Cert type %r not in %r", cert_type,
2438
valid_cert_types)
2483
2439
# ...return invalid data
2484
2440
return b""
2485
2441
list_size = ctypes.c_uint(1)
2486
2442
cert_list = (gnutls.certificate_get_peers
2487
(session, ctypes.byref(list_size)))
2443
(session._c_object, ctypes.byref(list_size)))
2488
2444
if not bool(cert_list) and list_size.value != 0:
2489
2445
raise gnutls.Error("error getting peer certificate")
2490
2446
if list_size.value == 0:
2512
2468
buf = ctypes.create_string_buffer(32)
2513
2469
buf_len = ctypes.c_size_t(len(buf))
2514
2470
# Get the key ID from the raw public key into the buffer
2515
gnutls.pubkey_get_key_id(
2516
pubkey,
2517
gnutls.KEYID_USE_SHA256,
2518
ctypes.cast(ctypes.byref(buf),
2519
ctypes.POINTER(ctypes.c_ubyte)),
2520
ctypes.byref(buf_len))
2471
gnutls.pubkey_get_key_id(pubkey,
2472
gnutls.KEYID_USE_SHA256,
2473
ctypes.cast(ctypes.byref(buf),
2474
ctypes.POINTER(ctypes.c_ubyte)),
2475
ctypes.byref(buf_len))
2521
2476
# Deinit the certificate
2522
2477
gnutls.pubkey_deinit(pubkey)
2523
2478
2604
2559
2605
2560
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2606
2561
socketserver.TCPServer):
2607
"""IPv6-capable TCP server. Accepts None as address and/or port
2562
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2608
2563
2609
2564
Attributes:
2610
2565
enabled: Boolean; whether this server is activated yet
2661
2616
if SO_BINDTODEVICE is None:
2662
2617
# Fall back to a hard-coded value which seems to be
2663
2618
# common enough.
2664
log.warning("SO_BINDTODEVICE not found, trying 25")
2619
logger.warning("SO_BINDTODEVICE not found, trying 25")
2665
2620
SO_BINDTODEVICE = 25
2666
2621
try:
2667
2622
self.socket.setsockopt(
2669
2624
(self.interface + "\0").encode("utf-8"))
2670
2625
except socket.error as error:
2671
2626
if error.errno == errno.EPERM:
2672
log.error("No permission to bind to interface %s",
2673
self.interface)
2627
logger.error("No permission to bind to"
2628
" interface %s", self.interface)
2674
2629
elif error.errno == errno.ENOPROTOOPT:
2675
log.error("SO_BINDTODEVICE not available; cannot"
2676
" bind to interface %s", self.interface)
2630
logger.error("SO_BINDTODEVICE not available;"
2631
" cannot bind to interface %s",
2632
self.interface)
2677
2633
elif error.errno == errno.ENODEV:
2678
log.error("Interface %s does not exist, cannot"
2679
" bind", self.interface)
2634
logger.error("Interface %s does not exist,"
2635
" cannot bind", self.interface)
2680
2636
else:
2681
2637
raise
2682
2638
# Only bind(2) the socket if we really need to.
2761
2717
request = parent_pipe.recv()
2762
2718
command = request[0]
2763
2719
2764
if command == "init":
2720
if command == 'init':
2765
2721
key_id = request[1].decode("ascii")
2766
2722
fpr = request[2].decode("ascii")
2767
2723
address = request[3]
2768
2724
2769
2725
for c in self.clients.values():
2770
if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
2771
"27AE41E4649B934CA495991B7852B855"):
2726
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2772
2727
continue
2773
2728
if key_id and c.key_id == key_id:
2774
2729
client = c
2777
2732
client = c
2778
2733
break
2779
2734
else:
2780
log.info("Client not found for key ID: %s, address:"
2781
" %s", key_id or fpr, address)
2735
logger.info("Client not found for key ID: %s, address"
2736
": %s", key_id or fpr, address)
2782
2737
if self.use_dbus:
2783
2738
# Emit D-Bus signal
2784
2739
mandos_dbus_service.ClientNotFound(key_id or fpr,
2797
2752
# remove the old hook in favor of the new above hook on
2798
2753
# same fileno
2799
2754
return False
2800
if command == "funcall":
2755
if command == 'funcall':
2801
2756
funcname = request[1]
2802
2757
args = request[2]
2803
2758
kwargs = request[3]
2804
2759
2805
parent_pipe.send(("data", getattr(client_object,
2760
parent_pipe.send(('data', getattr(client_object,
2806
2761
funcname)(*args,
2807
2762
**kwargs)))
2808
2763
2809
if command == "getattr":
2764
if command == 'getattr':
2810
2765
attrname = request[1]
2811
2766
if isinstance(client_object.__getattribute__(attrname),
2812
2767
collections.abc.Callable):
2813
parent_pipe.send(("function", ))
2768
parent_pipe.send(('function', ))
2814
2769
else:
2815
2770
parent_pipe.send((
2816
"data", client_object.__getattribute__(attrname)))
2771
'data', client_object.__getattribute__(attrname)))
2817
2772
2818
if command == "setattr":
2773
if command == 'setattr':
2819
2774
attrname = request[1]
2820
2775
value = request[2]
2821
2776
setattr(client_object, attrname, value)
2826
2781
def rfc3339_duration_to_delta(duration):
2827
2782
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2828
2783
2829
>>> timedelta = datetime.timedelta
2830
>>> rfc3339_duration_to_delta("P7D") == timedelta(7)
2831
True
2832
>>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
2833
True
2834
>>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
2835
True
2836
>>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
2837
True
2838
>>> rfc3339_duration_to_delta("P1W") == timedelta(7)
2839
True
2840
>>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
2841
True
2842
>>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
2843
True
2844
>>> del timedelta
2784
>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
2785
True
2786
>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
2787
True
2788
>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
2789
True
2790
>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
2791
True
2792
>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
2793
True
2794
>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
2795
True
2796
>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
2797
True
2845
2798
"""
2846
2799
2847
2800
# Parsing an RFC 3339 duration with regular expressions is not
2927
2880
def string_to_delta(interval):
2928
2881
"""Parse a string and return a datetime.timedelta
2929
2882
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)
2883
>>> string_to_delta('7d') == datetime.timedelta(7)
2884
True
2885
>>> string_to_delta('60s') == datetime.timedelta(0, 60)
2886
True
2887
>>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2888
True
2889
>>> string_to_delta('24h') == datetime.timedelta(1)
2890
True
2891
>>> string_to_delta('1w') == datetime.timedelta(7)
2892
True
2893
>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
2941
2894
True
2942
2895
"""
2943
2896
3147
3100
3148
3101
if server_settings["servicename"] != "Mandos":
3149
3102
syslogger.setFormatter(
3150
logging.Formatter("Mandos ({}) [%(process)d]:"
3151
" %(levelname)s: %(message)s".format(
3103
logging.Formatter('Mandos ({}) [%(process)d]:'
3104
' %(levelname)s: %(message)s'.format(
3152
3105
server_settings["servicename"])))
3153
3106
3154
3107
# Parse config file with clients
3178
3131
try:
3179
3132
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3180
3133
except IOError as e:
3181
log.error("Could not open file %r", pidfilename,
3182
exc_info=e)
3134
logger.error("Could not open file %r", pidfilename,
3135
exc_info=e)
3183
3136
3184
3137
for name, group in (("_mandos", "_mandos"),
3185
3138
("mandos", "mandos"),
3196
3149
try:
3197
3150
os.setgid(gid)
3198
3151
os.setuid(uid)
3199
log.debug("Did setuid/setgid to %s:%s", uid, gid)
3152
if debug:
3153
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3154
gid))
3200
3155
except OSError as error:
3201
log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
3202
os.strerror(error.errno))
3156
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3157
.format(uid, gid, os.strerror(error.errno)))
3203
3158
if error.errno != errno.EPERM:
3204
3159
raise
3205
3160
3212
3167
3213
3168
@gnutls.log_func
3214
3169
def debug_gnutls(level, string):
3215
log.debug("GnuTLS: %s",
3216
string[:-1].decode("utf-8", errors="replace"))
3170
logger.debug("GnuTLS: %s", string[:-1])
3217
3171
3218
3172
gnutls.global_set_log_function(debug_gnutls)
3219
3173
3248
3202
"se.bsnet.fukt.Mandos", bus,
3249
3203
do_not_queue=True)
3250
3204
except dbus.exceptions.DBusException as e:
3251
log.error("Disabling D-Bus:", exc_info=e)
3205
logger.error("Disabling D-Bus:", exc_info=e)
3252
3206
use_dbus = False
3253
3207
server_settings["use_dbus"] = False
3254
3208
tcp_server.use_dbus = False
3339
3293
os.remove(stored_state_path)
3340
3294
except IOError as e:
3341
3295
if e.errno == errno.ENOENT:
3342
log.warning("Could not load persistent state:"
3343
" %s", os.strerror(e.errno))
3296
logger.warning("Could not load persistent state:"
3297
" {}".format(os.strerror(e.errno)))
3344
3298
else:
3345
log.critical("Could not load persistent state:",
3346
exc_info=e)
3299
logger.critical("Could not load persistent state:",
3300
exc_info=e)
3347
3301
raise
3348
3302
except EOFError as e:
3349
log.warning("Could not load persistent state: EOFError:",
3350
exc_info=e)
3303
logger.warning("Could not load persistent state: "
3304
"EOFError:",
3305
exc_info=e)
3351
3306
3352
3307
with PGPEngine() as pgp:
3353
3308
for client_name, client in clients_data.items():
3380
3335
if client["enabled"]:
3381
3336
if datetime.datetime.utcnow() >= client["expires"]:
3382
3337
if not client["last_checked_ok"]:
3383
log.warning("disabling client %s - Client"
3384
" never performed a successful"
3385
" checker", client_name)
3338
logger.warning(
3339
"disabling client {} - Client never "
3340
"performed a successful checker".format(
3341
client_name))
3386
3342
client["enabled"] = False
3387
3343
elif client["last_checker_status"] != 0:
3388
log.warning("disabling client %s - Client"
3389
" last checker failed with error"
3390
" code %s", client_name,
3391
client["last_checker_status"])
3344
logger.warning(
3345
"disabling client {} - Client last"
3346
" checker failed with error code"
3347
" {}".format(
3348
client_name,
3349
client["last_checker_status"]))
3392
3350
client["enabled"] = False
3393
3351
else:
3394
3352
client["expires"] = (
3395
3353
datetime.datetime.utcnow()
3396
3354
+ client["timeout"])
3397
log.debug("Last checker succeeded, keeping %s"
3398
" enabled", client_name)
3355
logger.debug("Last checker succeeded,"
3356
" keeping {} enabled".format(
3357
client_name))
3399
3358
try:
3400
3359
client["secret"] = pgp.decrypt(
3401
3360
client["encrypted_secret"],
3402
3361
client_settings[client_name]["secret"])
3403
3362
except PGPError:
3404
3363
# If decryption fails, we use secret from new settings
3405
log.debug("Failed to decrypt %s old secret",
3406
client_name)
3364
logger.debug("Failed to decrypt {} old secret".format(
3365
client_name))
3407
3366
client["secret"] = (client_settings[client_name]
3408
3367
["secret"])
3409
3368
3423
3382
server_settings=server_settings)
3424
3383
3425
3384
if not tcp_server.clients:
3426
log.warning("No clients defined")
3385
logger.warning("No clients defined")
3427
3386
3428
3387
if not foreground:
3429
3388
if pidfile is not None:
3432
3391
with pidfile:
3433
3392
print(pid, file=pidfile)
3434
3393
except IOError:
3435
log.error("Could not write to file %r with PID %d",
3436
pidfilename, pid)
3394
logger.error("Could not write to file %r with PID %d",
3395
pidfilename, pid)
3437
3396
del pidfile
3438
3397
del pidfilename
3439
3398
3589
3548
3590
3549
try:
3591
3550
with tempfile.NamedTemporaryFile(
3592
mode="wb",
3551
mode='wb',
3593
3552
suffix=".pickle",
3594
prefix="clients-",
3553
prefix='clients-',
3595
3554
dir=os.path.dirname(stored_state_path),
3596
3555
delete=False) as stored_state:
3597
3556
pickle.dump((clients, client_settings), stored_state,
3605
3564
except NameError:
3606
3565
pass
3607
3566
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3608
log.warning("Could not save persistent state: %s",
3609
os.strerror(e.errno))
3567
logger.warning("Could not save persistent state: {}"
3568
.format(os.strerror(e.errno)))
3610
3569
else:
3611
log.warning("Could not save persistent state:",
3612
exc_info=e)
3570
logger.warning("Could not save persistent state:",
3571
exc_info=e)
3613
3572
raise
3614
3573
3615
3574
# Delete all clients, and settings from config
3632
3591
mandos_dbus_service.client_added_signal(client)
3633
3592
# Need to initiate checking of clients
3634
3593
if client.enabled:
3635
client.init_checker(randomize_start=True)
3594
client.init_checker()
3636
3595
3637
3596
tcp_server.enable()
3638
3597
tcp_server.server_activate()
3641
3600
if zeroconf:
3642
3601
service.port = tcp_server.socket.getsockname()[1]
3643
3602
if use_ipv6:
3644
log.info("Now listening on address %r, port %d, flowinfo %d,"
3645
" scope_id %d", *tcp_server.socket.getsockname())
3603
logger.info("Now listening on address %r, port %d,"
3604
" flowinfo %d, scope_id %d",
3605
*tcp_server.socket.getsockname())
3646
3606
else: # IPv4
3647
log.info("Now listening on address %r, port %d",
3648
*tcp_server.socket.getsockname())
3607
logger.info("Now listening on address %r, port %d",
3608
*tcp_server.socket.getsockname())
3649
3609
3650
3610
# service.interface = tcp_server.socket.getsockname()[3]
3651
3611
3655
3615
try:
3656
3616
service.activate()
3657
3617
except dbus.exceptions.DBusException as error:
3658
log.critical("D-Bus Exception", exc_info=error)
3618
logger.critical("D-Bus Exception", exc_info=error)
3659
3619
cleanup()
3660
3620
sys.exit(1)
3661
3621
# End of Avahi example code
3666
3626
lambda *args, **kwargs: (tcp_server.handle_request
3667
3627
(*args[2:], **kwargs) or True))
3668
3628
3669
log.debug("Starting main loop")
3629
logger.debug("Starting main loop")
3670
3630
main_loop.run()
3671
3631
except AvahiError as error:
3672
log.critical("Avahi Error", exc_info=error)
3632
logger.critical("Avahi Error", exc_info=error)
3673
3633
cleanup()
3674
3634
sys.exit(1)
3675
3635
except KeyboardInterrupt:
3676
3636
if debug:
3677
3637
print("", file=sys.stderr)
3678
log.debug("Server received KeyboardInterrupt")
3679
log.debug("Server exiting")
3638
logger.debug("Server received KeyboardInterrupt")
3639
logger.debug("Server exiting")
3680
3640
# Must run before the D-Bus bus name gets deregistered
3681
3641
cleanup()
3682
3642
3683
3643
3684
def parse_test_args():
3685
# type: () -> argparse.Namespace
3644
def should_only_run_tests():
3686
3645
parser = argparse.ArgumentParser(add_help=False)
3687
parser.add_argument("--check", action="store_true")
3688
parser.add_argument("--prefix", )
3646
parser.add_argument("--check", action='store_true')
3689
3647
args, unknown_args = parser.parse_known_args()
3690
if args.check:
3691
# Remove test options from sys.argv
3648
run_tests = args.check
3649
if run_tests:
3650
# Remove --check argument from sys.argv
3692
3651
sys.argv[1:] = unknown_args
3693
return args
3652
return run_tests
3694
3653
3695
3654
# Add all tests from doctest strings
3696
3655
def load_tests(loader, tests, none):
3698
3657
tests.addTests(doctest.DocTestSuite())
3699
3658
return tests
3700
3659
3701
if __name__ == "__main__":
3702
options = parse_test_args()
3660
if __name__ == '__main__':
3703
3661
try:
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=[""])
3662
if should_only_run_tests():
3663
# Call using ./mandos --check [--verbose]
3664
unittest.main()
3716
3665
else:
3717
3666
main()
3718
3667
finally:
3719
3668
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