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 1091
- compare with another revision
- download diff
- download tarball
- view history from revision 1091
- Committer: Teddy Hogeborn
- Date: 2019-03-30 07:09:35 UTC
- Revision ID: teddy@recompile.se-20190330070935-mo98cdxyfj8r2ukp
mandos-ctl: Fix grammar.
- files removed:
- debian/mandos.maintscript
- debian/tests
- dracut-module
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python3 -bI
2
# -*- coding: utf-8; lexical-binding: t -*-
1
#!/usr/bin/python
2
# -*- mode: python; 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 random
81
import shlex
82
80
83
81
import dbus
84
82
import dbus.service
85
import gi
86
83
from gi.repository import GLib
87
84
from dbus.mainloop.glib import DBusGMainLoop
88
85
import ctypes
90
87
import xml.dom.minidom
91
88
import inspect
92
89
93
if sys.version_info.major == 2:
94
__metaclass__ = type
95
str = unicode
96
input = raw_input
97
98
# Add collections.abc.Callable if it does not exist
99
try:
100
collections.abc.Callable
101
except AttributeError:
102
class abc:
103
Callable = collections.Callable
104
collections.abc = abc
105
del abc
106
107
# Add shlex.quote if it does not exist
108
try:
109
shlex.quote
110
except AttributeError:
111
shlex.quote = re.escape
112
113
# Add os.set_inheritable if it does not exist
114
try:
115
os.set_inheritable
116
except AttributeError:
117
def set_inheritable(fd, inheritable):
118
flags = fcntl.fcntl(fd, fcntl.F_GETFD)
119
if inheritable and ((flags & fcntl.FD_CLOEXEC) != 0):
120
fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~fcntl.FD_CLOEXEC)
121
elif (not inheritable) and ((flags & fcntl.FD_CLOEXEC) == 0):
122
fcntl.fcntl(fd, fcntl.F_SETFL, flags | fcntl.FD_CLOEXEC)
123
os.set_inheritable = set_inheritable
124
del set_inheritable
125
126
# Show warnings by default
127
if not sys.warnoptions:
128
import warnings
129
warnings.simplefilter("default")
130
131
90
# Try to find the value of SO_BINDTODEVICE:
132
91
try:
133
92
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
153
112
# No value found
154
113
SO_BINDTODEVICE = None
155
114
156
if sys.version_info < (3, 2):
157
configparser.Configparser = configparser.SafeConfigParser
115
if sys.version_info.major == 2:
116
str = unicode
158
117
159
version = "1.8.17"
118
version = "1.8.3"
160
119
stored_state_file = "clients.pickle"
161
120
162
log = logging.getLogger(os.path.basename(sys.argv[0]))
163
logging.captureWarnings(True) # Show warnings via the logging system
121
logger = logging.getLogger()
164
122
syslogger = None
165
123
166
124
try:
202
160
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
203
161
address="/dev/log"))
204
162
syslogger.setFormatter(logging.Formatter
205
("Mandos [%(process)d]: %(levelname)s:"
206
" %(message)s"))
207
log.addHandler(syslogger)
163
('Mandos [%(process)d]: %(levelname)s:'
164
' %(message)s'))
165
logger.addHandler(syslogger)
208
166
209
167
if debug:
210
168
console = logging.StreamHandler()
211
console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
212
" [%(process)d]:"
213
" %(levelname)s:"
214
" %(message)s"))
215
log.addHandler(console)
216
log.setLevel(level)
169
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
170
' [%(process)d]:'
171
' %(levelname)s:'
172
' %(message)s'))
173
logger.addHandler(console)
174
logger.setLevel(level)
217
175
218
176
219
177
class PGPError(Exception):
221
179
pass
222
180
223
181
224
class PGPEngine:
182
class PGPEngine(object):
225
183
"""A simple class for OpenPGP symmetric encryption & decryption"""
226
184
227
185
def __init__(self):
231
189
output = subprocess.check_output(["gpgconf"])
232
190
for line in output.splitlines():
233
191
name, text, path = line.split(b":")
234
if name == b"gpg":
192
if name == "gpg":
235
193
self.gpg = path
236
194
break
237
195
except OSError as e:
238
196
if e.errno != errno.ENOENT:
239
197
raise
240
self.gnupgargs = ["--batch",
241
"--homedir", self.tempdir,
242
"--force-mdc",
243
"--quiet"]
198
self.gnupgargs = ['--batch',
199
'--homedir', self.tempdir,
200
'--force-mdc',
201
'--quiet']
244
202
# Only GPG version 1 has the --no-use-agent option.
245
if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
203
if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
246
204
self.gnupgargs.append("--no-use-agent")
247
205
248
206
def __enter__(self):
285
243
dir=self.tempdir) as passfile:
286
244
passfile.write(passphrase)
287
245
passfile.flush()
288
proc = subprocess.Popen([self.gpg, "--symmetric",
289
"--passphrase-file",
246
proc = subprocess.Popen([self.gpg, '--symmetric',
247
'--passphrase-file',
290
248
passfile.name]
291
249
+ self.gnupgargs,
292
250
stdin=subprocess.PIPE,
303
261
dir=self.tempdir) as passfile:
304
262
passfile.write(passphrase)
305
263
passfile.flush()
306
proc = subprocess.Popen([self.gpg, "--decrypt",
307
"--passphrase-file",
264
proc = subprocess.Popen([self.gpg, '--decrypt',
265
'--passphrase-file',
308
266
passfile.name]
309
267
+ self.gnupgargs,
310
268
stdin=subprocess.PIPE,
317
275
318
276
319
277
# Pretend that we have an Avahi module
320
class avahi:
278
class avahi(object):
321
279
"""This isn't so much a class as it is a module-like namespace."""
322
280
IF_UNSPEC = -1 # avahi-common/address.h
323
281
PROTO_UNSPEC = -1 # avahi-common/address.h
357
315
pass
358
316
359
317
360
class AvahiService:
318
class AvahiService(object):
361
319
"""An Avahi (Zeroconf) service.
362
320
363
321
Attributes:
364
322
interface: integer; avahi.IF_UNSPEC or an interface index.
365
323
Used to optionally bind to the specified interface.
366
name: string; Example: "Mandos"
367
type: string; Example: "_mandos._tcp".
324
name: string; Example: 'Mandos'
325
type: string; Example: '_mandos._tcp'.
368
326
See <https://www.iana.org/assignments/service-names-port-numbers>
369
327
port: integer; what port to announce
370
328
TXT: list of strings; TXT record for the service
407
365
def rename(self, remove=True):
408
366
"""Derived from the Avahi example code"""
409
367
if self.rename_count >= self.max_renames:
410
log.critical("No suitable Zeroconf service name found"
411
" after %i retries, exiting.",
412
self.rename_count)
368
logger.critical("No suitable Zeroconf service name found"
369
" after %i retries, exiting.",
370
self.rename_count)
413
371
raise AvahiServiceError("Too many renames")
414
372
self.name = str(
415
373
self.server.GetAlternativeServiceName(self.name))
416
374
self.rename_count += 1
417
log.info("Changing Zeroconf service name to %r ...",
418
self.name)
375
logger.info("Changing Zeroconf service name to %r ...",
376
self.name)
419
377
if remove:
420
378
self.remove()
421
379
try:
423
381
except dbus.exceptions.DBusException as error:
424
382
if (error.get_dbus_name()
425
383
== "org.freedesktop.Avahi.CollisionError"):
426
log.info("Local Zeroconf service name collision.")
384
logger.info("Local Zeroconf service name collision.")
427
385
return self.rename(remove=False)
428
386
else:
429
log.critical("D-Bus Exception", exc_info=error)
387
logger.critical("D-Bus Exception", exc_info=error)
430
388
self.cleanup()
431
389
os._exit(1)
432
390
448
406
avahi.DBUS_INTERFACE_ENTRY_GROUP)
449
407
self.entry_group_state_changed_match = (
450
408
self.group.connect_to_signal(
451
"StateChanged", self.entry_group_state_changed))
452
log.debug("Adding Zeroconf service '%s' of type '%s' ...",
453
self.name, self.type)
409
'StateChanged', self.entry_group_state_changed))
410
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
411
self.name, self.type)
454
412
self.group.AddService(
455
413
self.interface,
456
414
self.protocol,
463
421
464
422
def entry_group_state_changed(self, state, error):
465
423
"""Derived from the Avahi example code"""
466
log.debug("Avahi entry group state change: %i", state)
424
logger.debug("Avahi entry group state change: %i", state)
467
425
468
426
if state == avahi.ENTRY_GROUP_ESTABLISHED:
469
log.debug("Zeroconf service established.")
427
logger.debug("Zeroconf service established.")
470
428
elif state == avahi.ENTRY_GROUP_COLLISION:
471
log.info("Zeroconf service name collision.")
429
logger.info("Zeroconf service name collision.")
472
430
self.rename()
473
431
elif state == avahi.ENTRY_GROUP_FAILURE:
474
log.critical("Avahi: Error in group state changed %s",
475
str(error))
432
logger.critical("Avahi: Error in group state changed %s",
433
str(error))
476
434
raise AvahiGroupError("State changed: {!s}".format(error))
477
435
478
436
def cleanup(self):
488
446
489
447
def server_state_changed(self, state, error=None):
490
448
"""Derived from the Avahi example code"""
491
log.debug("Avahi server state change: %i", state)
449
logger.debug("Avahi server state change: %i", state)
492
450
bad_states = {
493
451
avahi.SERVER_INVALID: "Zeroconf server invalid",
494
452
avahi.SERVER_REGISTERING: None,
498
456
if state in bad_states:
499
457
if bad_states[state] is not None:
500
458
if error is None:
501
log.error(bad_states[state])
459
logger.error(bad_states[state])
502
460
else:
503
log.error(bad_states[state] + ": %r", error)
461
logger.error(bad_states[state] + ": %r", error)
504
462
self.cleanup()
505
463
elif state == avahi.SERVER_RUNNING:
506
464
try:
508
466
except dbus.exceptions.DBusException as error:
509
467
if (error.get_dbus_name()
510
468
== "org.freedesktop.Avahi.CollisionError"):
511
log.info("Local Zeroconf service name collision.")
469
logger.info("Local Zeroconf service name"
470
" collision.")
512
471
return self.rename(remove=False)
513
472
else:
514
log.critical("D-Bus Exception", exc_info=error)
473
logger.critical("D-Bus Exception", exc_info=error)
515
474
self.cleanup()
516
475
os._exit(1)
517
476
else:
518
477
if error is None:
519
log.debug("Unknown state: %r", state)
478
logger.debug("Unknown state: %r", state)
520
479
else:
521
log.debug("Unknown state: %r: %r", state, error)
480
logger.debug("Unknown state: %r: %r", state, error)
522
481
523
482
def activate(self):
524
483
"""Derived from the Avahi example code"""
536
495
class AvahiServiceToSyslog(AvahiService):
537
496
def rename(self, *args, **kwargs):
538
497
"""Add the new name to the syslog messages"""
539
ret = super(AvahiServiceToSyslog, self).rename(*args,
540
**kwargs)
498
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
541
499
syslogger.setFormatter(logging.Formatter(
542
"Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
500
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
543
501
.format(self.name)))
544
502
return ret
545
503
546
504
547
505
# Pretend that we have a GnuTLS module
548
class gnutls:
506
class gnutls(object):
549
507
"""This isn't so much a class as it is a module-like namespace."""
550
508
551
509
library = ctypes.util.find_library("gnutls")
575
533
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
576
534
577
535
# Types
578
class _session_int(ctypes.Structure):
536
class session_int(ctypes.Structure):
579
537
_fields_ = []
580
session_t = ctypes.POINTER(_session_int)
538
session_t = ctypes.POINTER(session_int)
581
539
582
540
class certificate_credentials_st(ctypes.Structure):
583
541
_fields_ = []
586
544
certificate_type_t = ctypes.c_int
587
545
588
546
class datum_t(ctypes.Structure):
589
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
590
("size", ctypes.c_uint)]
547
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
548
('size', ctypes.c_uint)]
591
549
592
class _openpgp_crt_int(ctypes.Structure):
550
class openpgp_crt_int(ctypes.Structure):
593
551
_fields_ = []
594
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
552
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
595
553
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
596
554
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
597
555
credentials_type_t = ctypes.c_int
606
564
# gnutls.strerror()
607
565
self.code = code
608
566
if message is None and code is not None:
609
message = gnutls.strerror(code).decode(
610
"utf-8", errors="replace")
567
message = gnutls.strerror(code)
611
568
return super(gnutls.Error, self).__init__(
612
569
message, *args)
613
570
614
571
class CertificateSecurityError(Error):
615
572
pass
616
573
617
class PointerTo:
618
def __init__(self, cls):
619
self.cls = cls
620
621
def from_param(self, obj):
622
if not isinstance(obj, self.cls):
623
raise TypeError("Not of type {}: {!r}"
624
.format(self.cls.__name__, obj))
625
return ctypes.byref(obj.from_param(obj))
626
627
class CastToVoidPointer:
628
def __init__(self, cls):
629
self.cls = cls
630
631
def from_param(self, obj):
632
if not isinstance(obj, self.cls):
633
raise TypeError("Not of type {}: {!r}"
634
.format(self.cls.__name__, obj))
635
return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
636
637
class With_from_param:
638
@classmethod
639
def from_param(cls, obj):
640
return obj._as_parameter_
641
642
574
# Classes
643
class Credentials(With_from_param):
575
class Credentials(object):
644
576
def __init__(self):
645
self._as_parameter_ = gnutls.certificate_credentials_t()
646
gnutls.certificate_allocate_credentials(self)
577
self._c_object = gnutls.certificate_credentials_t()
578
gnutls.certificate_allocate_credentials(
579
ctypes.byref(self._c_object))
647
580
self.type = gnutls.CRD_CERTIFICATE
648
581
649
582
def __del__(self):
650
gnutls.certificate_free_credentials(self)
583
gnutls.certificate_free_credentials(self._c_object)
651
584
652
class ClientSession(With_from_param):
585
class ClientSession(object):
653
586
def __init__(self, socket, credentials=None):
654
self._as_parameter_ = gnutls.session_t()
587
self._c_object = gnutls.session_t()
655
588
gnutls_flags = gnutls.CLIENT
656
if gnutls.check_version(b"3.5.6"):
589
if gnutls.check_version("3.5.6"):
657
590
gnutls_flags |= gnutls.NO_TICKETS
658
591
if gnutls.has_rawpk:
659
592
gnutls_flags |= gnutls.ENABLE_RAWPK
660
gnutls.init(self, gnutls_flags)
593
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
661
594
del gnutls_flags
662
gnutls.set_default_priority(self)
663
gnutls.transport_set_ptr(self, socket.fileno())
664
gnutls.handshake_set_private_extensions(self, True)
595
gnutls.set_default_priority(self._c_object)
596
gnutls.transport_set_ptr(self._c_object, socket.fileno())
597
gnutls.handshake_set_private_extensions(self._c_object,
598
True)
665
599
self.socket = socket
666
600
if credentials is None:
667
601
credentials = gnutls.Credentials()
668
gnutls.credentials_set(self, credentials.type,
669
credentials)
602
gnutls.credentials_set(self._c_object, credentials.type,
603
ctypes.cast(credentials._c_object,
604
ctypes.c_void_p))
670
605
self.credentials = credentials
671
606
672
607
def __del__(self):
673
gnutls.deinit(self)
608
gnutls.deinit(self._c_object)
674
609
675
610
def handshake(self):
676
return gnutls.handshake(self)
611
return gnutls.handshake(self._c_object)
677
612
678
613
def send(self, data):
679
614
data = bytes(data)
680
615
data_len = len(data)
681
616
while data_len > 0:
682
data_len -= gnutls.record_send(self, data[-data_len:],
617
data_len -= gnutls.record_send(self._c_object,
618
data[-data_len:],
683
619
data_len)
684
620
685
621
def bye(self):
686
return gnutls.bye(self, gnutls.SHUT_RDWR)
622
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
687
623
688
624
# Error handling functions
689
625
def _error_code(result):
690
626
"""A function to raise exceptions on errors, suitable
691
for the "restype" attribute on ctypes functions"""
692
if result >= gnutls.E_SUCCESS:
627
for the 'restype' attribute on ctypes functions"""
628
if result >= 0:
693
629
return result
694
630
if result == gnutls.E_NO_CERTIFICATE_FOUND:
695
631
raise gnutls.CertificateSecurityError(code=result)
696
632
raise gnutls.Error(code=result)
697
633
698
def _retry_on_error(result, func, arguments,
699
_error_code=_error_code):
634
def _retry_on_error(result, func, arguments):
700
635
"""A function to retry on some errors, suitable
701
for the "errcheck" attribute on ctypes functions"""
702
while result < gnutls.E_SUCCESS:
636
for the 'errcheck' attribute on ctypes functions"""
637
while result < 0:
703
638
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
704
639
return _error_code(result)
705
640
result = func(*arguments)
710
645
711
646
# Functions
712
647
priority_set_direct = _library.gnutls_priority_set_direct
713
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
648
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
714
649
ctypes.POINTER(ctypes.c_char_p)]
715
650
priority_set_direct.restype = _error_code
716
651
717
652
init = _library.gnutls_init
718
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
653
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
719
654
init.restype = _error_code
720
655
721
656
set_default_priority = _library.gnutls_set_default_priority
722
set_default_priority.argtypes = [ClientSession]
657
set_default_priority.argtypes = [session_t]
723
658
set_default_priority.restype = _error_code
724
659
725
660
record_send = _library.gnutls_record_send
726
record_send.argtypes = [ClientSession, ctypes.c_void_p,
661
record_send.argtypes = [session_t, ctypes.c_void_p,
727
662
ctypes.c_size_t]
728
663
record_send.restype = ctypes.c_ssize_t
729
664
record_send.errcheck = _retry_on_error
731
666
certificate_allocate_credentials = (
732
667
_library.gnutls_certificate_allocate_credentials)
733
668
certificate_allocate_credentials.argtypes = [
734
PointerTo(Credentials)]
669
ctypes.POINTER(certificate_credentials_t)]
735
670
certificate_allocate_credentials.restype = _error_code
736
671
737
672
certificate_free_credentials = (
738
673
_library.gnutls_certificate_free_credentials)
739
certificate_free_credentials.argtypes = [Credentials]
674
certificate_free_credentials.argtypes = [
675
certificate_credentials_t]
740
676
certificate_free_credentials.restype = None
741
677
742
678
handshake_set_private_extensions = (
743
679
_library.gnutls_handshake_set_private_extensions)
744
handshake_set_private_extensions.argtypes = [ClientSession,
680
handshake_set_private_extensions.argtypes = [session_t,
745
681
ctypes.c_int]
746
682
handshake_set_private_extensions.restype = None
747
683
748
684
credentials_set = _library.gnutls_credentials_set
749
credentials_set.argtypes = [ClientSession, credentials_type_t,
750
CastToVoidPointer(Credentials)]
685
credentials_set.argtypes = [session_t, credentials_type_t,
686
ctypes.c_void_p]
751
687
credentials_set.restype = _error_code
752
688
753
689
strerror = _library.gnutls_strerror
755
691
strerror.restype = ctypes.c_char_p
756
692
757
693
certificate_type_get = _library.gnutls_certificate_type_get
758
certificate_type_get.argtypes = [ClientSession]
694
certificate_type_get.argtypes = [session_t]
759
695
certificate_type_get.restype = _error_code
760
696
761
697
certificate_get_peers = _library.gnutls_certificate_get_peers
762
certificate_get_peers.argtypes = [ClientSession,
698
certificate_get_peers.argtypes = [session_t,
763
699
ctypes.POINTER(ctypes.c_uint)]
764
700
certificate_get_peers.restype = ctypes.POINTER(datum_t)
765
701
772
708
global_set_log_function.restype = None
773
709
774
710
deinit = _library.gnutls_deinit
775
deinit.argtypes = [ClientSession]
711
deinit.argtypes = [session_t]
776
712
deinit.restype = None
777
713
778
714
handshake = _library.gnutls_handshake
779
handshake.argtypes = [ClientSession]
780
handshake.restype = ctypes.c_int
715
handshake.argtypes = [session_t]
716
handshake.restype = _error_code
781
717
handshake.errcheck = _retry_on_error
782
718
783
719
transport_set_ptr = _library.gnutls_transport_set_ptr
784
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
720
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
785
721
transport_set_ptr.restype = None
786
722
787
723
bye = _library.gnutls_bye
788
bye.argtypes = [ClientSession, close_request_t]
789
bye.restype = ctypes.c_int
724
bye.argtypes = [session_t, close_request_t]
725
bye.restype = _error_code
790
726
bye.errcheck = _retry_on_error
791
727
792
728
check_version = _library.gnutls_check_version
809
745
810
746
x509_crt_fmt_t = ctypes.c_int
811
747
812
# All the function declarations below are from
813
# gnutls/abstract.h
748
# All the function declarations below are from gnutls/abstract.h
814
749
pubkey_init = _library.gnutls_pubkey_init
815
750
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
816
751
pubkey_init.restype = _error_code
830
765
pubkey_deinit.argtypes = [pubkey_t]
831
766
pubkey_deinit.restype = None
832
767
else:
833
# All the function declarations below are from
834
# gnutls/openpgp.h
768
# All the function declarations below are from gnutls/openpgp.h
835
769
836
770
openpgp_crt_init = _library.gnutls_openpgp_crt_init
837
771
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
843
777
openpgp_crt_fmt_t]
844
778
openpgp_crt_import.restype = _error_code
845
779
846
openpgp_crt_verify_self = \
847
_library.gnutls_openpgp_crt_verify_self
848
openpgp_crt_verify_self.argtypes = [
849
openpgp_crt_t,
850
ctypes.c_uint,
851
ctypes.POINTER(ctypes.c_uint),
852
]
780
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
781
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
782
ctypes.POINTER(ctypes.c_uint)]
853
783
openpgp_crt_verify_self.restype = _error_code
854
784
855
785
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
864
794
ctypes.c_size_t)]
865
795
openpgp_crt_get_fingerprint.restype = _error_code
866
796
867
if check_version(b"3.6.4"):
797
if check_version("3.6.4"):
868
798
certificate_type_get2 = _library.gnutls_certificate_type_get2
869
certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
799
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
870
800
certificate_type_get2.restype = _error_code
871
801
872
802
# Remove non-public functions
884
814
connection.close()
885
815
886
816
887
class Client:
817
class Client(object):
888
818
"""A representation of a client host served by this server.
889
819
890
820
Attributes:
891
approved: bool(); None if not yet approved/disapproved
821
approved: bool(); 'None' if not yet approved/disapproved
892
822
approval_delay: datetime.timedelta(); Time to wait for approval
893
823
approval_duration: datetime.timedelta(); Duration of one approval
894
checker: multiprocessing.Process(); a running checker process used
895
to see if the client lives. None if no process is
896
running.
824
checker: subprocess.Popen(); a running checker process used
825
to see if the client lives.
826
'None' if no process is running.
897
827
checker_callback_tag: a GLib event source tag, or None
898
828
checker_command: string; External command which is run to check
899
829
if client lives. %() expansions are done at
974
904
# key_id() and fingerprint() functions
975
905
client["key_id"] = (section.get("key_id", "").upper()
976
906
.replace(" ", ""))
977
client["fingerprint"] = (section.get("fingerprint",
978
"").upper()
907
client["fingerprint"] = (section["fingerprint"].upper()
979
908
.replace(" ", ""))
980
if not (client["key_id"] or client["fingerprint"]):
981
log.error("Skipping client %s without key_id or"
982
" fingerprint", client_name)
983
del settings[client_name]
984
continue
985
909
if "secret" in section:
986
910
client["secret"] = codecs.decode(section["secret"]
987
911
.encode("utf-8"),
1028
952
self.last_enabled = None
1029
953
self.expires = None
1030
954
1031
log.debug("Creating client %r", self.name)
1032
log.debug(" Key ID: %s", self.key_id)
1033
log.debug(" Fingerprint: %s", self.fingerprint)
955
logger.debug("Creating client %r", self.name)
956
logger.debug(" Key ID: %s", self.key_id)
957
logger.debug(" Fingerprint: %s", self.fingerprint)
1034
958
self.created = settings.get("created",
1035
959
datetime.datetime.utcnow())
1036
960
1064
988
if getattr(self, "enabled", False):
1065
989
# Already enabled
1066
990
return
991
self.expires = datetime.datetime.utcnow() + self.timeout
1067
992
self.enabled = True
1068
993
self.last_enabled = datetime.datetime.utcnow()
1069
994
self.init_checker()
1074
999
if not getattr(self, "enabled", False):
1075
1000
return False
1076
1001
if not quiet:
1077
log.info("Disabling client %s", self.name)
1002
logger.info("Disabling client %s", self.name)
1078
1003
if getattr(self, "disable_initiator_tag", None) is not None:
1079
1004
GLib.source_remove(self.disable_initiator_tag)
1080
1005
self.disable_initiator_tag = None
1092
1017
def __del__(self):
1093
1018
self.disable()
1094
1019
1095
def init_checker(self, randomize_start=False):
1096
# Schedule a new checker to be started a randomly selected
1097
# time (a fraction of 'interval') from now. This spreads out
1098
# the startup of checkers over time when the server is
1099
# started.
1020
def init_checker(self):
1021
# Schedule a new checker to be started an 'interval' from now,
1022
# and every interval from then on.
1100
1023
if self.checker_initiator_tag is not None:
1101
1024
GLib.source_remove(self.checker_initiator_tag)
1102
interval_milliseconds = int(self.interval.total_seconds()
1103
* 1000)
1104
if randomize_start:
1105
delay_milliseconds = random.randrange(
1106
interval_milliseconds + 1)
1107
else:
1108
delay_milliseconds = interval_milliseconds
1109
1025
self.checker_initiator_tag = GLib.timeout_add(
1110
delay_milliseconds, self.start_checker, randomize_start)
1111
delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
1112
# A checker might take up to an 'interval' of time, so we can
1113
# expire at the soonest one interval after a checker was
1114
# started. Since the initial checker is delayed, the expire
1115
# time might have to be extended.
1116
now = datetime.datetime.utcnow()
1117
self.expires = now + delay + self.interval
1118
# Schedule a disable() at expire time
1026
int(self.interval.total_seconds() * 1000),
1027
self.start_checker)
1028
# Schedule a disable() when 'timeout' has passed
1119
1029
if self.disable_initiator_tag is not None:
1120
1030
GLib.source_remove(self.disable_initiator_tag)
1121
1031
self.disable_initiator_tag = GLib.timeout_add(
1122
int((self.expires - now).total_seconds() * 1000),
1123
self.disable)
1032
int(self.timeout.total_seconds() * 1000), self.disable)
1033
# Also start a new checker *right now*.
1034
self.start_checker()
1124
1035
1125
1036
def checker_callback(self, source, condition, connection,
1126
1037
command):
1127
1038
"""The checker has completed, so take appropriate actions."""
1039
self.checker_callback_tag = None
1040
self.checker = None
1128
1041
# Read return code from connection (see call_pipe)
1129
1042
returncode = connection.recv()
1130
1043
connection.close()
1131
if self.checker is not None:
1132
self.checker.join()
1133
self.checker_callback_tag = None
1134
self.checker = None
1135
1044
1136
1045
if returncode >= 0:
1137
1046
self.last_checker_status = returncode
1138
1047
self.last_checker_signal = None
1139
1048
if self.last_checker_status == 0:
1140
log.info("Checker for %(name)s succeeded", vars(self))
1049
logger.info("Checker for %(name)s succeeded",
1050
vars(self))
1141
1051
self.checked_ok()
1142
1052
else:
1143
log.info("Checker for %(name)s failed", vars(self))
1053
logger.info("Checker for %(name)s failed", vars(self))
1144
1054
else:
1145
1055
self.last_checker_status = -1
1146
1056
self.last_checker_signal = -returncode
1147
log.warning("Checker for %(name)s crashed?", vars(self))
1057
logger.warning("Checker for %(name)s crashed?",
1058
vars(self))
1148
1059
return False
1149
1060
1150
1061
def checked_ok(self):
1169
1080
def need_approval(self):
1170
1081
self.last_approval_request = datetime.datetime.utcnow()
1171
1082
1172
def start_checker(self, start_was_randomized=False):
1083
def start_checker(self):
1173
1084
"""Start a new checker subprocess if one is not running.
1174
1085
1175
1086
If a checker already exists, leave it running and do
1184
1095
# should be.
1185
1096
1186
1097
if self.checker is not None and not self.checker.is_alive():
1187
log.warning("Checker was not alive; joining")
1098
logger.warning("Checker was not alive; joining")
1188
1099
self.checker.join()
1189
1100
self.checker = None
1190
1101
# Start a new checker if needed
1191
1102
if self.checker is None:
1192
1103
# Escape attributes for the shell
1193
1104
escaped_attrs = {
1194
attr: shlex.quote(str(getattr(self, attr)))
1105
attr: re.escape(str(getattr(self, attr)))
1195
1106
for attr in self.runtime_expansions}
1196
1107
try:
1197
1108
command = self.checker_command % escaped_attrs
1198
1109
except TypeError as error:
1199
log.error('Could not format string "%s"',
1200
self.checker_command, exc_info=error)
1110
logger.error('Could not format string "%s"',
1111
self.checker_command,
1112
exc_info=error)
1201
1113
return True # Try again later
1202
1114
self.current_checker_command = command
1203
log.info("Starting checker %r for %s", command, self.name)
1115
logger.info("Starting checker %r for %s", command,
1116
self.name)
1204
1117
# We don't need to redirect stdout and stderr, since
1205
1118
# in normal mode, that is already done by daemon(),
1206
1119
# and in debug mode we don't want to. (Stdin is
1222
1135
kwargs=popen_args)
1223
1136
self.checker.start()
1224
1137
self.checker_callback_tag = GLib.io_add_watch(
1225
GLib.IOChannel.unix_new(pipe[0].fileno()),
1226
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1138
pipe[0].fileno(), GLib.IO_IN,
1227
1139
self.checker_callback, pipe[0], command)
1228
if start_was_randomized:
1229
# We were started after a random delay; Schedule a new
1230
# checker to be started an 'interval' from now, and every
1231
# interval from then on.
1232
now = datetime.datetime.utcnow()
1233
self.checker_initiator_tag = GLib.timeout_add(
1234
int(self.interval.total_seconds() * 1000),
1235
self.start_checker)
1236
self.expires = max(self.expires, now + self.interval)
1237
# Don't start a new checker again after same random delay
1238
return False
1239
1140
# Re-run this periodically if run by GLib.timeout_add
1240
1141
return True
1241
1142
1246
1147
self.checker_callback_tag = None
1247
1148
if getattr(self, "checker", None) is None:
1248
1149
return
1249
log.debug("Stopping checker for %(name)s", vars(self))
1150
logger.debug("Stopping checker for %(name)s", vars(self))
1250
1151
self.checker.terminate()
1251
1152
self.checker = None
1252
1153
1279
1180
func._dbus_name = func.__name__
1280
1181
if func._dbus_name.endswith("_dbus_property"):
1281
1182
func._dbus_name = func._dbus_name[:-14]
1282
func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1183
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1283
1184
return func
1284
1185
1285
1186
return decorator
1374
1275
1375
1276
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1376
1277
out_signature="s",
1377
path_keyword="object_path",
1378
connection_keyword="connection")
1278
path_keyword='object_path',
1279
connection_keyword='connection')
1379
1280
def Introspect(self, object_path, connection):
1380
1281
"""Overloading of standard D-Bus method.
1381
1282
1430
1331
document.unlink()
1431
1332
except (AttributeError, xml.dom.DOMException,
1432
1333
xml.parsers.expat.ExpatError) as error:
1433
log.error("Failed to override Introspection method",
1434
exc_info=error)
1334
logger.error("Failed to override Introspection method",
1335
exc_info=error)
1435
1336
return xmlstring
1436
1337
1437
1338
1495
1396
raise ValueError("Byte arrays not supported for non-"
1496
1397
"'ay' signature {!r}"
1497
1398
.format(prop._dbus_signature))
1498
value = dbus.ByteArray(bytes(value))
1399
value = dbus.ByteArray(b''.join(chr(byte)
1400
for byte in value))
1499
1401
prop(value)
1500
1402
1501
1403
@dbus.service.method(dbus.PROPERTIES_IFACE,
1534
1436
1535
1437
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1536
1438
out_signature="s",
1537
path_keyword="object_path",
1538
connection_keyword="connection")
1439
path_keyword='object_path',
1440
connection_keyword='connection')
1539
1441
def Introspect(self, object_path, connection):
1540
1442
"""Overloading of standard D-Bus method.
1541
1443
1597
1499
document.unlink()
1598
1500
except (AttributeError, xml.dom.DOMException,
1599
1501
xml.parsers.expat.ExpatError) as error:
1600
log.error("Failed to override Introspection method",
1601
exc_info=error)
1502
logger.error("Failed to override Introspection method",
1503
exc_info=error)
1602
1504
return xmlstring
1603
1505
1604
1506
1636
1538
1637
1539
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1638
1540
out_signature="s",
1639
path_keyword="object_path",
1640
connection_keyword="connection")
1541
path_keyword='object_path',
1542
connection_keyword='connection')
1641
1543
def Introspect(self, object_path, connection):
1642
1544
"""Overloading of standard D-Bus method.
1643
1545
1668
1570
document.unlink()
1669
1571
except (AttributeError, xml.dom.DOMException,
1670
1572
xml.parsers.expat.ExpatError) as error:
1671
log.error("Failed to override Introspection method",
1672
exc_info=error)
1573
logger.error("Failed to override Introspection method",
1574
exc_info=error)
1673
1575
return xmlstring
1674
1576
1675
1577
2306
2208
del _interface
2307
2209
2308
2210
2309
class ProxyClient:
2211
class ProxyClient(object):
2310
2212
def __init__(self, child_pipe, key_id, fpr, address):
2311
2213
self._pipe = child_pipe
2312
self._pipe.send(("init", key_id, fpr, address))
2214
self._pipe.send(('init', key_id, fpr, address))
2313
2215
if not self._pipe.recv():
2314
2216
raise KeyError(key_id or fpr)
2315
2217
2316
2218
def __getattribute__(self, name):
2317
if name == "_pipe":
2219
if name == '_pipe':
2318
2220
return super(ProxyClient, self).__getattribute__(name)
2319
self._pipe.send(("getattr", name))
2221
self._pipe.send(('getattr', name))
2320
2222
data = self._pipe.recv()
2321
if data[0] == "data":
2223
if data[0] == 'data':
2322
2224
return data[1]
2323
if data[0] == "function":
2225
if data[0] == 'function':
2324
2226
2325
2227
def func(*args, **kwargs):
2326
self._pipe.send(("funcall", name, args, kwargs))
2228
self._pipe.send(('funcall', name, args, kwargs))
2327
2229
return self._pipe.recv()[1]
2328
2230
2329
2231
return func
2330
2232
2331
2233
def __setattr__(self, name, value):
2332
if name == "_pipe":
2234
if name == '_pipe':
2333
2235
return super(ProxyClient, self).__setattr__(name, value)
2334
self._pipe.send(("setattr", name, value))
2236
self._pipe.send(('setattr', name, value))
2335
2237
2336
2238
2337
2239
class ClientHandler(socketserver.BaseRequestHandler, object):
2342
2244
2343
2245
def handle(self):
2344
2246
with contextlib.closing(self.server.child_pipe) as child_pipe:
2345
log.info("TCP connection from: %s",
2346
str(self.client_address))
2347
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2247
logger.info("TCP connection from: %s",
2248
str(self.client_address))
2249
logger.debug("Pipe FD: %d",
2250
self.server.child_pipe.fileno())
2348
2251
2349
2252
session = gnutls.ClientSession(self.request)
2350
2253
2351
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2254
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2352
2255
# "+AES-256-CBC", "+SHA1",
2353
2256
# "+COMP-NULL", "+CTYPE-OPENPGP",
2354
2257
# "+DHE-DSS"))
2356
2259
priority = self.server.gnutls_priority
2357
2260
if priority is None:
2358
2261
priority = "NORMAL"
2359
gnutls.priority_set_direct(session,
2360
priority.encode("utf-8"), None)
2262
gnutls.priority_set_direct(session._c_object,
2263
priority.encode("utf-8"),
2264
None)
2361
2265
2362
2266
# Start communication using the Mandos protocol
2363
2267
# Get protocol number
2364
2268
line = self.request.makefile().readline()
2365
log.debug("Protocol version: %r", line)
2269
logger.debug("Protocol version: %r", line)
2366
2270
try:
2367
2271
if int(line.strip().split()[0]) > 1:
2368
2272
raise RuntimeError(line)
2369
2273
except (ValueError, IndexError, RuntimeError) as error:
2370
log.error("Unknown protocol version: %s", error)
2274
logger.error("Unknown protocol version: %s", error)
2371
2275
return
2372
2276
2373
2277
# Start GnuTLS connection
2374
2278
try:
2375
2279
session.handshake()
2376
2280
except gnutls.Error as error:
2377
log.warning("Handshake failed: %s", error)
2281
logger.warning("Handshake failed: %s", error)
2378
2282
# Do not run session.bye() here: the session is not
2379
2283
# established. Just abandon the request.
2380
2284
return
2381
log.debug("Handshake succeeded")
2285
logger.debug("Handshake succeeded")
2382
2286
2383
2287
approval_required = False
2384
2288
try:
2385
2289
if gnutls.has_rawpk:
2386
fpr = b""
2290
fpr = ""
2387
2291
try:
2388
2292
key_id = self.key_id(
2389
2293
self.peer_certificate(session))
2390
2294
except (TypeError, gnutls.Error) as error:
2391
log.warning("Bad certificate: %s", error)
2295
logger.warning("Bad certificate: %s", error)
2392
2296
return
2393
log.debug("Key ID: %s",
2394
key_id.decode("utf-8",
2395
errors="replace"))
2297
logger.debug("Key ID: %s", key_id)
2396
2298
2397
2299
else:
2398
key_id = b""
2300
key_id = ""
2399
2301
try:
2400
2302
fpr = self.fingerprint(
2401
2303
self.peer_certificate(session))
2402
2304
except (TypeError, gnutls.Error) as error:
2403
log.warning("Bad certificate: %s", error)
2305
logger.warning("Bad certificate: %s", error)
2404
2306
return
2405
log.debug("Fingerprint: %s", fpr)
2307
logger.debug("Fingerprint: %s", fpr)
2406
2308
2407
2309
try:
2408
2310
client = ProxyClient(child_pipe, key_id, fpr,
2417
2319
2418
2320
while True:
2419
2321
if not client.enabled:
2420
log.info("Client %s is disabled", client.name)
2322
logger.info("Client %s is disabled",
2323
client.name)
2421
2324
if self.server.use_dbus:
2422
2325
# Emit D-Bus signal
2423
2326
client.Rejected("Disabled")
2427
2330
# We are approved or approval is disabled
2428
2331
break
2429
2332
elif client.approved is None:
2430
log.info("Client %s needs approval",
2431
client.name)
2333
logger.info("Client %s needs approval",
2334
client.name)
2432
2335
if self.server.use_dbus:
2433
2336
# Emit D-Bus signal
2434
2337
client.NeedApproval(
2435
2338
client.approval_delay.total_seconds()
2436
2339
* 1000, client.approved_by_default)
2437
2340
else:
2438
log.warning("Client %s was not approved",
2439
client.name)
2341
logger.warning("Client %s was not approved",
2342
client.name)
2440
2343
if self.server.use_dbus:
2441
2344
# Emit D-Bus signal
2442
2345
client.Rejected("Denied")
2450
2353
time2 = datetime.datetime.now()
2451
2354
if (time2 - time) >= delay:
2452
2355
if not client.approved_by_default:
2453
log.warning("Client %s timed out while"
2454
" waiting for approval",
2455
client.name)
2356
logger.warning("Client %s timed out while"
2357
" waiting for approval",
2358
client.name)
2456
2359
if self.server.use_dbus:
2457
2360
# Emit D-Bus signal
2458
2361
client.Rejected("Approval timed out")
2465
2368
try:
2466
2369
session.send(client.secret)
2467
2370
except gnutls.Error as error:
2468
log.warning("gnutls send failed", exc_info=error)
2371
logger.warning("gnutls send failed",
2372
exc_info=error)
2469
2373
return
2470
2374
2471
log.info("Sending secret to %s", client.name)
2375
logger.info("Sending secret to %s", client.name)
2472
2376
# bump the timeout using extended_timeout
2473
2377
client.bump_timeout(client.extended_timeout)
2474
2378
if self.server.use_dbus:
2481
2385
try:
2482
2386
session.bye()
2483
2387
except gnutls.Error as error:
2484
log.warning("GnuTLS bye failed", exc_info=error)
2388
logger.warning("GnuTLS bye failed",
2389
exc_info=error)
2485
2390
2486
2391
@staticmethod
2487
2392
def peer_certificate(session):
2488
2393
"Return the peer's certificate as a bytestring"
2489
2394
try:
2490
cert_type = gnutls.certificate_type_get2(
2491
session, gnutls.CTYPE_PEERS)
2395
cert_type = gnutls.certificate_type_get2(session._c_object,
2396
gnutls.CTYPE_PEERS)
2492
2397
except AttributeError:
2493
cert_type = gnutls.certificate_type_get(session)
2398
cert_type = gnutls.certificate_type_get(session._c_object)
2494
2399
if gnutls.has_rawpk:
2495
2400
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2496
2401
else:
2497
2402
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2498
2403
# If not a valid certificate type...
2499
2404
if cert_type not in valid_cert_types:
2500
log.info("Cert type %r not in %r", cert_type,
2501
valid_cert_types)
2405
logger.info("Cert type %r not in %r", cert_type,
2406
valid_cert_types)
2502
2407
# ...return invalid data
2503
2408
return b""
2504
2409
list_size = ctypes.c_uint(1)
2505
2410
cert_list = (gnutls.certificate_get_peers
2506
(session, ctypes.byref(list_size)))
2411
(session._c_object, ctypes.byref(list_size)))
2507
2412
if not bool(cert_list) and list_size.value != 0:
2508
2413
raise gnutls.Error("error getting peer certificate")
2509
2414
if list_size.value == 0:
2531
2436
buf = ctypes.create_string_buffer(32)
2532
2437
buf_len = ctypes.c_size_t(len(buf))
2533
2438
# Get the key ID from the raw public key into the buffer
2534
gnutls.pubkey_get_key_id(
2535
pubkey,
2536
gnutls.KEYID_USE_SHA256,
2537
ctypes.cast(ctypes.byref(buf),
2538
ctypes.POINTER(ctypes.c_ubyte)),
2539
ctypes.byref(buf_len))
2439
gnutls.pubkey_get_key_id(pubkey,
2440
gnutls.KEYID_USE_SHA256,
2441
ctypes.cast(ctypes.byref(buf),
2442
ctypes.POINTER(ctypes.c_ubyte)),
2443
ctypes.byref(buf_len))
2540
2444
# Deinit the certificate
2541
2445
gnutls.pubkey_deinit(pubkey)
2542
2446
2583
2487
return hex_fpr
2584
2488
2585
2489
2586
class MultiprocessingMixIn:
2490
class MultiprocessingMixIn(object):
2587
2491
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2588
2492
2589
2493
def sub_process_main(self, request, address):
2601
2505
return proc
2602
2506
2603
2507
2604
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2508
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2605
2509
""" adds a pipe to the MixIn """
2606
2510
2607
2511
def process_request(self, request, client_address):
2622
2526
2623
2527
2624
2528
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2625
socketserver.TCPServer):
2626
"""IPv6-capable TCP server. Accepts None as address and/or port
2529
socketserver.TCPServer, object):
2530
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2627
2531
2628
2532
Attributes:
2629
2533
enabled: Boolean; whether this server is activated yet
2680
2584
if SO_BINDTODEVICE is None:
2681
2585
# Fall back to a hard-coded value which seems to be
2682
2586
# common enough.
2683
log.warning("SO_BINDTODEVICE not found, trying 25")
2587
logger.warning("SO_BINDTODEVICE not found, trying 25")
2684
2588
SO_BINDTODEVICE = 25
2685
2589
try:
2686
2590
self.socket.setsockopt(
2688
2592
(self.interface + "\0").encode("utf-8"))
2689
2593
except socket.error as error:
2690
2594
if error.errno == errno.EPERM:
2691
log.error("No permission to bind to interface %s",
2692
self.interface)
2595
logger.error("No permission to bind to"
2596
" interface %s", self.interface)
2693
2597
elif error.errno == errno.ENOPROTOOPT:
2694
log.error("SO_BINDTODEVICE not available; cannot"
2695
" bind to interface %s", self.interface)
2598
logger.error("SO_BINDTODEVICE not available;"
2599
" cannot bind to interface %s",
2600
self.interface)
2696
2601
elif error.errno == errno.ENODEV:
2697
log.error("Interface %s does not exist, cannot"
2698
" bind", self.interface)
2602
logger.error("Interface %s does not exist,"
2603
" cannot bind", self.interface)
2699
2604
else:
2700
2605
raise
2701
2606
# Only bind(2) the socket if we really need to.
2702
2607
if self.server_address[0] or self.server_address[1]:
2703
if self.server_address[1]:
2704
self.allow_reuse_address = True
2705
2608
if not self.server_address[0]:
2706
2609
if self.address_family == socket.AF_INET6:
2707
2610
any_address = "::" # in6addr_any
2760
2663
def add_pipe(self, parent_pipe, proc):
2761
2664
# Call "handle_ipc" for both data and EOF events
2762
2665
GLib.io_add_watch(
2763
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2764
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2666
parent_pipe.fileno(),
2667
GLib.IO_IN | GLib.IO_HUP,
2765
2668
functools.partial(self.handle_ipc,
2766
2669
parent_pipe=parent_pipe,
2767
2670
proc=proc))
2780
2683
request = parent_pipe.recv()
2781
2684
command = request[0]
2782
2685
2783
if command == "init":
2686
if command == 'init':
2784
2687
key_id = request[1].decode("ascii")
2785
2688
fpr = request[2].decode("ascii")
2786
2689
address = request[3]
2787
2690
2788
2691
for c in self.clients.values():
2789
if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
2790
"27AE41E4649B934CA495991B7852B855"):
2692
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2791
2693
continue
2792
2694
if key_id and c.key_id == key_id:
2793
2695
client = c
2796
2698
client = c
2797
2699
break
2798
2700
else:
2799
log.info("Client not found for key ID: %s, address:"
2800
" %s", key_id or fpr, address)
2701
logger.info("Client not found for key ID: %s, address"
2702
": %s", key_id or fpr, address)
2801
2703
if self.use_dbus:
2802
2704
# Emit D-Bus signal
2803
2705
mandos_dbus_service.ClientNotFound(key_id or fpr,
2806
2708
return False
2807
2709
2808
2710
GLib.io_add_watch(
2809
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2810
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2711
parent_pipe.fileno(),
2712
GLib.IO_IN | GLib.IO_HUP,
2811
2713
functools.partial(self.handle_ipc,
2812
2714
parent_pipe=parent_pipe,
2813
2715
proc=proc,
2816
2718
# remove the old hook in favor of the new above hook on
2817
2719
# same fileno
2818
2720
return False
2819
if command == "funcall":
2721
if command == 'funcall':
2820
2722
funcname = request[1]
2821
2723
args = request[2]
2822
2724
kwargs = request[3]
2823
2725
2824
parent_pipe.send(("data", getattr(client_object,
2726
parent_pipe.send(('data', getattr(client_object,
2825
2727
funcname)(*args,
2826
2728
**kwargs)))
2827
2729
2828
if command == "getattr":
2730
if command == 'getattr':
2829
2731
attrname = request[1]
2830
2732
if isinstance(client_object.__getattribute__(attrname),
2831
collections.abc.Callable):
2832
parent_pipe.send(("function", ))
2733
collections.Callable):
2734
parent_pipe.send(('function', ))
2833
2735
else:
2834
2736
parent_pipe.send((
2835
"data", client_object.__getattribute__(attrname)))
2737
'data', client_object.__getattribute__(attrname)))
2836
2738
2837
if command == "setattr":
2739
if command == 'setattr':
2838
2740
attrname = request[1]
2839
2741
value = request[2]
2840
2742
setattr(client_object, attrname, value)
2845
2747
def rfc3339_duration_to_delta(duration):
2846
2748
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2847
2749
2848
>>> timedelta = datetime.timedelta
2849
>>> rfc3339_duration_to_delta("P7D") == timedelta(7)
2850
True
2851
>>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
2852
True
2853
>>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
2854
True
2855
>>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
2856
True
2857
>>> rfc3339_duration_to_delta("P1W") == timedelta(7)
2858
True
2859
>>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
2860
True
2861
>>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
2862
True
2863
>>> del timedelta
2750
>>> rfc3339_duration_to_delta("P7D")
2751
datetime.timedelta(7)
2752
>>> rfc3339_duration_to_delta("PT60S")
2753
datetime.timedelta(0, 60)
2754
>>> rfc3339_duration_to_delta("PT60M")
2755
datetime.timedelta(0, 3600)
2756
>>> rfc3339_duration_to_delta("PT24H")
2757
datetime.timedelta(1)
2758
>>> rfc3339_duration_to_delta("P1W")
2759
datetime.timedelta(7)
2760
>>> rfc3339_duration_to_delta("PT5M30S")
2761
datetime.timedelta(0, 330)
2762
>>> rfc3339_duration_to_delta("P1DT3M20S")
2763
datetime.timedelta(1, 200)
2864
2764
"""
2865
2765
2866
2766
# Parsing an RFC 3339 duration with regular expressions is not
2946
2846
def string_to_delta(interval):
2947
2847
"""Parse a string and return a datetime.timedelta
2948
2848
2949
>>> string_to_delta("7d") == datetime.timedelta(7)
2950
True
2951
>>> string_to_delta("60s") == datetime.timedelta(0, 60)
2952
True
2953
>>> string_to_delta("60m") == datetime.timedelta(0, 3600)
2954
True
2955
>>> string_to_delta("24h") == datetime.timedelta(1)
2956
True
2957
>>> string_to_delta("1w") == datetime.timedelta(7)
2958
True
2959
>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
2960
True
2849
>>> string_to_delta('7d')
2850
datetime.timedelta(7)
2851
>>> string_to_delta('60s')
2852
datetime.timedelta(0, 60)
2853
>>> string_to_delta('60m')
2854
datetime.timedelta(0, 3600)
2855
>>> string_to_delta('24h')
2856
datetime.timedelta(1)
2857
>>> string_to_delta('1w')
2858
datetime.timedelta(7)
2859
>>> string_to_delta('5m 30s')
2860
datetime.timedelta(0, 330)
2961
2861
"""
2962
2862
2963
2863
try:
3065
2965
3066
2966
options = parser.parse_args()
3067
2967
2968
if options.check:
2969
import doctest
2970
fail_count, test_count = doctest.testmod()
2971
sys.exit(os.EX_OK if fail_count == 0 else 1)
2972
3068
2973
# Default values for config file for server-global settings
3069
2974
if gnutls.has_rawpk:
3070
2975
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3090
2995
del priority
3091
2996
3092
2997
# Parse config file for server-global settings
3093
server_config = configparser.ConfigParser(server_defaults)
2998
server_config = configparser.SafeConfigParser(server_defaults)
3094
2999
del server_defaults
3095
3000
server_config.read(os.path.join(options.configdir, "mandos.conf"))
3096
# Convert the ConfigParser object to a dict
3001
# Convert the SafeConfigParser object to a dict
3097
3002
server_settings = server_config.defaults()
3098
3003
# Use the appropriate methods on the non-string config options
3099
3004
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3109
3014
# Later, stdin will, and stdout and stderr might, be dup'ed
3110
3015
# over with an opened os.devnull. But we don't want this to
3111
3016
# happen with a supplied network socket.
3112
while 0 <= server_settings["socket"] <= 2:
3017
if 0 <= server_settings["socket"] <= 2:
3113
3018
server_settings["socket"] = os.dup(server_settings
3114
3019
["socket"])
3115
os.set_inheritable(server_settings["socket"], False)
3116
3020
del server_config
3117
3021
3118
3022
# Override the settings from the config file with command line
3167
3071
3168
3072
if server_settings["servicename"] != "Mandos":
3169
3073
syslogger.setFormatter(
3170
logging.Formatter("Mandos ({}) [%(process)d]:"
3171
" %(levelname)s: %(message)s".format(
3074
logging.Formatter('Mandos ({}) [%(process)d]:'
3075
' %(levelname)s: %(message)s'.format(
3172
3076
server_settings["servicename"])))
3173
3077
3174
3078
# Parse config file with clients
3175
client_config = configparser.ConfigParser(Client.client_defaults)
3079
client_config = configparser.SafeConfigParser(Client
3080
.client_defaults)
3176
3081
client_config.read(os.path.join(server_settings["configdir"],
3177
3082
"clients.conf"))
3178
3083
3198
3103
try:
3199
3104
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3200
3105
except IOError as e:
3201
log.error("Could not open file %r", pidfilename,
3202
exc_info=e)
3106
logger.error("Could not open file %r", pidfilename,
3107
exc_info=e)
3203
3108
3204
3109
for name, group in (("_mandos", "_mandos"),
3205
3110
("mandos", "mandos"),
3216
3121
try:
3217
3122
os.setgid(gid)
3218
3123
os.setuid(uid)
3219
log.debug("Did setuid/setgid to %s:%s", uid, gid)
3124
if debug:
3125
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3126
gid))
3220
3127
except OSError as error:
3221
log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
3222
os.strerror(error.errno))
3128
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3129
.format(uid, gid, os.strerror(error.errno)))
3223
3130
if error.errno != errno.EPERM:
3224
3131
raise
3225
3132
3232
3139
3233
3140
@gnutls.log_func
3234
3141
def debug_gnutls(level, string):
3235
log.debug("GnuTLS: %s",
3236
string[:-1].decode("utf-8", errors="replace"))
3142
logger.debug("GnuTLS: %s", string[:-1])
3237
3143
3238
3144
gnutls.global_set_log_function(debug_gnutls)
3239
3145
3248
3154
# Close all input and output, do double fork, etc.
3249
3155
daemon()
3250
3156
3251
if gi.version_info < (3, 10, 2):
3252
# multiprocessing will use threads, so before we use GLib we
3253
# need to inform GLib that threads will be used.
3254
GLib.threads_init()
3157
# multiprocessing will use threads, so before we use GLib we need
3158
# to inform GLib that threads will be used.
3159
GLib.threads_init()
3255
3160
3256
3161
global main_loop
3257
3162
# From the Avahi example code
3258
3163
DBusGMainLoop(set_as_default=True)
3259
3164
main_loop = GLib.MainLoop()
3260
if use_dbus or zeroconf:
3261
bus = dbus.SystemBus()
3165
bus = dbus.SystemBus()
3262
3166
# End of Avahi example code
3263
3167
if use_dbus:
3264
3168
try:
3269
3173
"se.bsnet.fukt.Mandos", bus,
3270
3174
do_not_queue=True)
3271
3175
except dbus.exceptions.DBusException as e:
3272
log.error("Disabling D-Bus:", exc_info=e)
3176
logger.error("Disabling D-Bus:", exc_info=e)
3273
3177
use_dbus = False
3274
3178
server_settings["use_dbus"] = False
3275
3179
tcp_server.use_dbus = False
3334
3238
if isinstance(s, bytes)
3335
3239
else s) for s in
3336
3240
value["client_structure"]]
3337
# .name, .host, and .checker_command
3338
for k in ("name", "host", "checker_command"):
3241
# .name & .host
3242
for k in ("name", "host"):
3339
3243
if isinstance(value[k], bytes):
3340
3244
value[k] = value[k].decode("utf-8")
3341
if "key_id" not in value:
3245
if not value.has_key("key_id"):
3342
3246
value["key_id"] = ""
3343
elif "fingerprint" not in value:
3247
elif not value.has_key("fingerprint"):
3344
3248
value["fingerprint"] = ""
3345
3249
# old_client_settings
3346
3250
# .keys()
3351
3255
for key, value in
3352
3256
bytes_old_client_settings.items()}
3353
3257
del bytes_old_client_settings
3354
# .host and .checker_command
3258
# .host
3355
3259
for value in old_client_settings.values():
3356
for attribute in ("host", "checker_command"):
3357
if isinstance(value[attribute], bytes):
3358
value[attribute] = (value[attribute]
3359
.decode("utf-8"))
3260
if isinstance(value["host"], bytes):
3261
value["host"] = (value["host"]
3262
.decode("utf-8"))
3360
3263
os.remove(stored_state_path)
3361
3264
except IOError as e:
3362
3265
if e.errno == errno.ENOENT:
3363
log.warning("Could not load persistent state:"
3364
" %s", os.strerror(e.errno))
3266
logger.warning("Could not load persistent state:"
3267
" {}".format(os.strerror(e.errno)))
3365
3268
else:
3366
log.critical("Could not load persistent state:",
3367
exc_info=e)
3269
logger.critical("Could not load persistent state:",
3270
exc_info=e)
3368
3271
raise
3369
3272
except EOFError as e:
3370
log.warning("Could not load persistent state: EOFError:",
3371
exc_info=e)
3273
logger.warning("Could not load persistent state: "
3274
"EOFError:",
3275
exc_info=e)
3372
3276
3373
3277
with PGPEngine() as pgp:
3374
3278
for client_name, client in clients_data.items():
3401
3305
if client["enabled"]:
3402
3306
if datetime.datetime.utcnow() >= client["expires"]:
3403
3307
if not client["last_checked_ok"]:
3404
log.warning("disabling client %s - Client"
3405
" never performed a successful"
3406
" checker", client_name)
3308
logger.warning(
3309
"disabling client {} - Client never "
3310
"performed a successful checker".format(
3311
client_name))
3407
3312
client["enabled"] = False
3408
3313
elif client["last_checker_status"] != 0:
3409
log.warning("disabling client %s - Client"
3410
" last checker failed with error"
3411
" code %s", client_name,
3412
client["last_checker_status"])
3314
logger.warning(
3315
"disabling client {} - Client last"
3316
" checker failed with error code"
3317
" {}".format(
3318
client_name,
3319
client["last_checker_status"]))
3413
3320
client["enabled"] = False
3414
3321
else:
3415
3322
client["expires"] = (
3416
3323
datetime.datetime.utcnow()
3417
3324
+ client["timeout"])
3418
log.debug("Last checker succeeded, keeping %s"
3419
" enabled", client_name)
3325
logger.debug("Last checker succeeded,"
3326
" keeping {} enabled".format(
3327
client_name))
3420
3328
try:
3421
3329
client["secret"] = pgp.decrypt(
3422
3330
client["encrypted_secret"],
3423
3331
client_settings[client_name]["secret"])
3424
3332
except PGPError:
3425
3333
# If decryption fails, we use secret from new settings
3426
log.debug("Failed to decrypt %s old secret",
3427
client_name)
3334
logger.debug("Failed to decrypt {} old secret".format(
3335
client_name))
3428
3336
client["secret"] = (client_settings[client_name]
3429
3337
["secret"])
3430
3338
3444
3352
server_settings=server_settings)
3445
3353
3446
3354
if not tcp_server.clients:
3447
log.warning("No clients defined")
3355
logger.warning("No clients defined")
3448
3356
3449
3357
if not foreground:
3450
3358
if pidfile is not None:
3453
3361
with pidfile:
3454
3362
print(pid, file=pidfile)
3455
3363
except IOError:
3456
log.error("Could not write to file %r with PID %d",
3457
pidfilename, pid)
3364
logger.error("Could not write to file %r with PID %d",
3365
pidfilename, pid)
3458
3366
del pidfile
3459
3367
del pidfilename
3460
3368
3610
3518
3611
3519
try:
3612
3520
with tempfile.NamedTemporaryFile(
3613
mode="wb",
3521
mode='wb',
3614
3522
suffix=".pickle",
3615
prefix="clients-",
3523
prefix='clients-',
3616
3524
dir=os.path.dirname(stored_state_path),
3617
3525
delete=False) as stored_state:
3618
3526
pickle.dump((clients, client_settings), stored_state,
3626
3534
except NameError:
3627
3535
pass
3628
3536
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3629
log.warning("Could not save persistent state: %s",
3630
os.strerror(e.errno))
3537
logger.warning("Could not save persistent state: {}"
3538
.format(os.strerror(e.errno)))
3631
3539
else:
3632
log.warning("Could not save persistent state:",
3633
exc_info=e)
3540
logger.warning("Could not save persistent state:",
3541
exc_info=e)
3634
3542
raise
3635
3543
3636
3544
# Delete all clients, and settings from config
3653
3561
mandos_dbus_service.client_added_signal(client)
3654
3562
# Need to initiate checking of clients
3655
3563
if client.enabled:
3656
client.init_checker(randomize_start=True)
3564
client.init_checker()
3657
3565
3658
3566
tcp_server.enable()
3659
3567
tcp_server.server_activate()
3662
3570
if zeroconf:
3663
3571
service.port = tcp_server.socket.getsockname()[1]
3664
3572
if use_ipv6:
3665
log.info("Now listening on address %r, port %d, flowinfo %d,"
3666
" scope_id %d", *tcp_server.socket.getsockname())
3573
logger.info("Now listening on address %r, port %d,"
3574
" flowinfo %d, scope_id %d",
3575
*tcp_server.socket.getsockname())
3667
3576
else: # IPv4
3668
log.info("Now listening on address %r, port %d",
3669
*tcp_server.socket.getsockname())
3577
logger.info("Now listening on address %r, port %d",
3578
*tcp_server.socket.getsockname())
3670
3579
3671
3580
# service.interface = tcp_server.socket.getsockname()[3]
3672
3581
3676
3585
try:
3677
3586
service.activate()
3678
3587
except dbus.exceptions.DBusException as error:
3679
log.critical("D-Bus Exception", exc_info=error)
3588
logger.critical("D-Bus Exception", exc_info=error)
3680
3589
cleanup()
3681
3590
sys.exit(1)
3682
3591
# End of Avahi example code
3683
3592
3684
GLib.io_add_watch(
3685
GLib.IOChannel.unix_new(tcp_server.fileno()),
3686
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3687
lambda *args, **kwargs: (tcp_server.handle_request
3688
(*args[2:], **kwargs) or True))
3593
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3594
lambda *args, **kwargs:
3595
(tcp_server.handle_request
3596
(*args[2:], **kwargs) or True))
3689
3597
3690
log.debug("Starting main loop")
3598
logger.debug("Starting main loop")
3691
3599
main_loop.run()
3692
3600
except AvahiError as error:
3693
log.critical("Avahi Error", exc_info=error)
3601
logger.critical("Avahi Error", exc_info=error)
3694
3602
cleanup()
3695
3603
sys.exit(1)
3696
3604
except KeyboardInterrupt:
3697
3605
if debug:
3698
3606
print("", file=sys.stderr)
3699
log.debug("Server received KeyboardInterrupt")
3700
log.debug("Server exiting")
3607
logger.debug("Server received KeyboardInterrupt")
3608
logger.debug("Server exiting")
3701
3609
# Must run before the D-Bus bus name gets deregistered
3702
3610
cleanup()
3703
3611
3704
3705
def parse_test_args():
3706
# type: () -> argparse.Namespace
3707
parser = argparse.ArgumentParser(add_help=False)
3708
parser.add_argument("--check", action="store_true")
3709
parser.add_argument("--prefix", )
3710
args, unknown_args = parser.parse_known_args()
3711
if args.check:
3712
# Remove test options from sys.argv
3713
sys.argv[1:] = unknown_args
3714
return args
3715
3716
# Add all tests from doctest strings
3717
def load_tests(loader, tests, none):
3718
import doctest
3719
tests.addTests(doctest.DocTestSuite())
3720
return tests
3721
3722
if __name__ == "__main__":
3723
options = parse_test_args()
3724
try:
3725
if options.check:
3726
extra_test_prefix = options.prefix
3727
if extra_test_prefix is not None:
3728
if not (unittest.main(argv=[""], exit=False)
3729
.result.wasSuccessful()):
3730
sys.exit(1)
3731
class ExtraTestLoader(unittest.TestLoader):
3732
testMethodPrefix = extra_test_prefix
3733
# Call using ./scriptname --test [--verbose]
3734
unittest.main(argv=[""], testLoader=ExtraTestLoader())
3735
else:
3736
unittest.main(argv=[""])
3737
else:
3738
main()
3739
finally:
3740
logging.shutdown()
3741
3742
# Local Variables:
3743
# run-tests:
3744
# (lambda (&optional extra)
3745
# (if (not (funcall run-tests-in-test-buffer default-directory
3746
# extra))
3747
# (funcall show-test-buffer-in-test-window)
3748
# (funcall remove-test-window)
3749
# (if extra (message "Extra tests run successfully!"))))
3750
# run-tests-in-test-buffer:
3751
# (lambda (dir &optional extra)
3752
# (with-current-buffer (get-buffer-create "*Test*")
3753
# (setq buffer-read-only nil
3754
# default-directory dir)
3755
# (erase-buffer)
3756
# (compilation-mode))
3757
# (let ((process-result
3758
# (let ((inhibit-read-only t))
3759
# (process-file-shell-command
3760
# (funcall get-command-line extra) nil "*Test*"))))
3761
# (and (numberp process-result)
3762
# (= process-result 0))))
3763
# get-command-line:
3764
# (lambda (&optional extra)
3765
# (let ((quoted-script
3766
# (shell-quote-argument (funcall get-script-name))))
3767
# (format
3768
# (concat "%s --check" (if extra " --prefix=atest" ""))
3769
# quoted-script)))
3770
# get-script-name:
3771
# (lambda ()
3772
# (if (fboundp 'file-local-name)
3773
# (file-local-name (buffer-file-name))
3774
# (or (file-remote-p (buffer-file-name) 'localname)
3775
# (buffer-file-name))))
3776
# remove-test-window:
3777
# (lambda ()
3778
# (let ((test-window (get-buffer-window "*Test*")))
3779
# (if test-window (delete-window test-window))))
3780
# show-test-buffer-in-test-window:
3781
# (lambda ()
3782
# (when (not (get-buffer-window-list "*Test*"))
3783
# (setq next-error-last-buffer (get-buffer "*Test*"))
3784
# (let* ((side (if (>= (window-width) 146) 'right 'bottom))
3785
# (display-buffer-overriding-action
3786
# `((display-buffer-in-side-window) (side . ,side)
3787
# (window-height . fit-window-to-buffer)
3788
# (window-width . fit-window-to-buffer))))
3789
# (display-buffer "*Test*"))))
3790
# eval:
3791
# (progn
3792
# (let* ((run-extra-tests (lambda () (interactive)
3793
# (funcall run-tests t)))
3794
# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
3795
# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c
3796
# (setq minor-mode-overriding-map-alist
3797
# (cons `(run-tests . ,outer-keymap)
3798
# minor-mode-overriding-map-alist)))
3799
# (add-hook 'after-save-hook run-tests 90 t))
3800
# End:
3612
3613
if __name__ == '__main__':
3614
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0