196
265
.replace(b"\n", b"\\n")
197
266
.replace(b"\0", b"\\x00"))
200
269
def encrypt(self, data, password):
201
270
passphrase = self.password_encode(password)
202
271
with tempfile.NamedTemporaryFile(
203
272
dir=self.tempdir) as passfile:
204
273
passfile.write(passphrase)
206
proc = subprocess.Popen(['gpg', '--symmetric',
275
proc = subprocess.Popen([self.gpg, "--symmetric",
209
278
+ self.gnupgargs,
210
stdin = subprocess.PIPE,
211
stdout = subprocess.PIPE,
212
stderr = subprocess.PIPE)
213
ciphertext, err = proc.communicate(input = data)
279
stdin=subprocess.PIPE,
280
stdout=subprocess.PIPE,
281
stderr=subprocess.PIPE)
282
ciphertext, err = proc.communicate(input=data)
214
283
if proc.returncode != 0:
215
284
raise PGPError(err)
216
285
return ciphertext
218
287
def decrypt(self, data, password):
219
288
passphrase = self.password_encode(password)
220
289
with tempfile.NamedTemporaryFile(
221
dir = self.tempdir) as passfile:
290
dir=self.tempdir) as passfile:
222
291
passfile.write(passphrase)
224
proc = subprocess.Popen(['gpg', '--decrypt',
293
proc = subprocess.Popen([self.gpg, "--decrypt",
227
296
+ self.gnupgargs,
228
stdin = subprocess.PIPE,
229
stdout = subprocess.PIPE,
230
stderr = subprocess.PIPE)
231
decrypted_plaintext, err = proc.communicate(input = data)
297
stdin=subprocess.PIPE,
298
stdout=subprocess.PIPE,
299
stderr=subprocess.PIPE)
300
decrypted_plaintext, err = proc.communicate(input=data)
232
301
if proc.returncode != 0:
233
302
raise PGPError(err)
234
303
return decrypted_plaintext
306
# Pretend that we have an Avahi module
308
"""This isn't so much a class as it is a module-like namespace."""
309
IF_UNSPEC = -1 # avahi-common/address.h
310
PROTO_UNSPEC = -1 # avahi-common/address.h
311
PROTO_INET = 0 # avahi-common/address.h
312
PROTO_INET6 = 1 # avahi-common/address.h
313
DBUS_NAME = "org.freedesktop.Avahi"
314
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
315
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
316
DBUS_PATH_SERVER = "/"
319
def string_array_to_txt_array(t):
320
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
321
for s in t), signature="ay")
322
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
323
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
324
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
325
SERVER_INVALID = 0 # avahi-common/defs.h
326
SERVER_REGISTERING = 1 # avahi-common/defs.h
327
SERVER_RUNNING = 2 # avahi-common/defs.h
328
SERVER_COLLISION = 3 # avahi-common/defs.h
329
SERVER_FAILURE = 4 # avahi-common/defs.h
237
332
class AvahiError(Exception):
238
333
def __init__(self, value, *args, **kwargs):
239
334
self.value = value
429
524
class AvahiServiceToSyslog(AvahiService):
430
525
def rename(self, *args, **kwargs):
431
526
"""Add the new name to the syslog messages"""
432
ret = AvahiService.rename(self, *args, **kwargs)
527
ret = super(AvahiServiceToSyslog, self).rename(*args,
433
529
syslogger.setFormatter(logging.Formatter(
434
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
530
"Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
435
531
.format(self.name)))
535
# Pretend that we have a GnuTLS module
537
"""This isn't so much a class as it is a module-like namespace."""
539
library = ctypes.util.find_library("gnutls")
541
library = ctypes.util.find_library("gnutls-deb0")
542
_library = ctypes.cdll.LoadLibrary(library)
545
# Unless otherwise indicated, the constants and types below are
546
# all from the gnutls/gnutls.h C header file.
557
E_NO_CERTIFICATE_FOUND = -49
562
KEYID_USE_SHA256 = 1 # gnutls/x509.h
563
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
566
class _session_int(ctypes.Structure):
568
session_t = ctypes.POINTER(_session_int)
570
class certificate_credentials_st(ctypes.Structure):
572
certificate_credentials_t = ctypes.POINTER(
573
certificate_credentials_st)
574
certificate_type_t = ctypes.c_int
576
class datum_t(ctypes.Structure):
577
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
578
("size", ctypes.c_uint)]
580
class _openpgp_crt_int(ctypes.Structure):
582
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
583
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
584
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
585
credentials_type_t = ctypes.c_int
586
transport_ptr_t = ctypes.c_void_p
587
close_request_t = ctypes.c_int
590
class Error(Exception):
591
def __init__(self, message=None, code=None, args=()):
592
# Default usage is by a message string, but if a return
593
# code is passed, convert it to a string with
596
if message is None and code is not None:
597
message = gnutls.strerror(code).decode(
598
"utf-8", errors="replace")
599
return super(gnutls.Error, self).__init__(
602
class CertificateSecurityError(Error):
606
def __init__(self, cls):
609
def from_param(self, obj):
610
if not isinstance(obj, self.cls):
611
raise TypeError("Not of type {}: {!r}"
612
.format(self.cls.__name__, obj))
613
return ctypes.byref(obj.from_param(obj))
615
class CastToVoidPointer:
616
def __init__(self, cls):
619
def from_param(self, obj):
620
if not isinstance(obj, self.cls):
621
raise TypeError("Not of type {}: {!r}"
622
.format(self.cls.__name__, obj))
623
return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
625
class With_from_param:
627
def from_param(cls, obj):
628
return obj._as_parameter_
631
class Credentials(With_from_param):
633
self._as_parameter_ = gnutls.certificate_credentials_t()
634
gnutls.certificate_allocate_credentials(self)
635
self.type = gnutls.CRD_CERTIFICATE
638
gnutls.certificate_free_credentials(self)
640
class ClientSession(With_from_param):
641
def __init__(self, socket, credentials=None):
642
self._as_parameter_ = gnutls.session_t()
643
gnutls_flags = gnutls.CLIENT
644
if gnutls.check_version(b"3.5.6"):
645
gnutls_flags |= gnutls.NO_TICKETS
647
gnutls_flags |= gnutls.ENABLE_RAWPK
648
gnutls.init(self, gnutls_flags)
650
gnutls.set_default_priority(self)
651
gnutls.transport_set_ptr(self, socket.fileno())
652
gnutls.handshake_set_private_extensions(self, True)
654
if credentials is None:
655
credentials = gnutls.Credentials()
656
gnutls.credentials_set(self, credentials.type,
658
self.credentials = credentials
664
return gnutls.handshake(self)
666
def send(self, data):
670
data_len -= gnutls.record_send(self, data[-data_len:],
674
return gnutls.bye(self, gnutls.SHUT_RDWR)
676
# Error handling functions
677
def _error_code(result):
678
"""A function to raise exceptions on errors, suitable
679
for the "restype" attribute on ctypes functions"""
680
if result >= gnutls.E_SUCCESS:
682
if result == gnutls.E_NO_CERTIFICATE_FOUND:
683
raise gnutls.CertificateSecurityError(code=result)
684
raise gnutls.Error(code=result)
686
def _retry_on_error(result, func, arguments,
687
_error_code=_error_code):
688
"""A function to retry on some errors, suitable
689
for the "errcheck" attribute on ctypes functions"""
690
while result < gnutls.E_SUCCESS:
691
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
692
return _error_code(result)
693
result = func(*arguments)
696
# Unless otherwise indicated, the function declarations below are
697
# all from the gnutls/gnutls.h C header file.
700
priority_set_direct = _library.gnutls_priority_set_direct
701
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
702
ctypes.POINTER(ctypes.c_char_p)]
703
priority_set_direct.restype = _error_code
705
init = _library.gnutls_init
706
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
707
init.restype = _error_code
709
set_default_priority = _library.gnutls_set_default_priority
710
set_default_priority.argtypes = [ClientSession]
711
set_default_priority.restype = _error_code
713
record_send = _library.gnutls_record_send
714
record_send.argtypes = [ClientSession, ctypes.c_void_p,
716
record_send.restype = ctypes.c_ssize_t
717
record_send.errcheck = _retry_on_error
719
certificate_allocate_credentials = (
720
_library.gnutls_certificate_allocate_credentials)
721
certificate_allocate_credentials.argtypes = [
722
PointerTo(Credentials)]
723
certificate_allocate_credentials.restype = _error_code
725
certificate_free_credentials = (
726
_library.gnutls_certificate_free_credentials)
727
certificate_free_credentials.argtypes = [Credentials]
728
certificate_free_credentials.restype = None
730
handshake_set_private_extensions = (
731
_library.gnutls_handshake_set_private_extensions)
732
handshake_set_private_extensions.argtypes = [ClientSession,
734
handshake_set_private_extensions.restype = None
736
credentials_set = _library.gnutls_credentials_set
737
credentials_set.argtypes = [ClientSession, credentials_type_t,
738
CastToVoidPointer(Credentials)]
739
credentials_set.restype = _error_code
741
strerror = _library.gnutls_strerror
742
strerror.argtypes = [ctypes.c_int]
743
strerror.restype = ctypes.c_char_p
745
certificate_type_get = _library.gnutls_certificate_type_get
746
certificate_type_get.argtypes = [ClientSession]
747
certificate_type_get.restype = _error_code
749
certificate_get_peers = _library.gnutls_certificate_get_peers
750
certificate_get_peers.argtypes = [ClientSession,
751
ctypes.POINTER(ctypes.c_uint)]
752
certificate_get_peers.restype = ctypes.POINTER(datum_t)
754
global_set_log_level = _library.gnutls_global_set_log_level
755
global_set_log_level.argtypes = [ctypes.c_int]
756
global_set_log_level.restype = None
758
global_set_log_function = _library.gnutls_global_set_log_function
759
global_set_log_function.argtypes = [log_func]
760
global_set_log_function.restype = None
762
deinit = _library.gnutls_deinit
763
deinit.argtypes = [ClientSession]
764
deinit.restype = None
766
handshake = _library.gnutls_handshake
767
handshake.argtypes = [ClientSession]
768
handshake.restype = ctypes.c_int
769
handshake.errcheck = _retry_on_error
771
transport_set_ptr = _library.gnutls_transport_set_ptr
772
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
773
transport_set_ptr.restype = None
775
bye = _library.gnutls_bye
776
bye.argtypes = [ClientSession, close_request_t]
777
bye.restype = ctypes.c_int
778
bye.errcheck = _retry_on_error
780
check_version = _library.gnutls_check_version
781
check_version.argtypes = [ctypes.c_char_p]
782
check_version.restype = ctypes.c_char_p
784
_need_version = b"3.3.0"
785
if check_version(_need_version) is None:
786
raise self.Error("Needs GnuTLS {} or later"
787
.format(_need_version))
789
_tls_rawpk_version = b"3.6.6"
790
has_rawpk = bool(check_version(_tls_rawpk_version))
794
class pubkey_st(ctypes.Structure):
796
pubkey_t = ctypes.POINTER(pubkey_st)
798
x509_crt_fmt_t = ctypes.c_int
800
# All the function declarations below are from
802
pubkey_init = _library.gnutls_pubkey_init
803
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
804
pubkey_init.restype = _error_code
806
pubkey_import = _library.gnutls_pubkey_import
807
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
809
pubkey_import.restype = _error_code
811
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
812
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
813
ctypes.POINTER(ctypes.c_ubyte),
814
ctypes.POINTER(ctypes.c_size_t)]
815
pubkey_get_key_id.restype = _error_code
817
pubkey_deinit = _library.gnutls_pubkey_deinit
818
pubkey_deinit.argtypes = [pubkey_t]
819
pubkey_deinit.restype = None
821
# All the function declarations below are from
824
openpgp_crt_init = _library.gnutls_openpgp_crt_init
825
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
826
openpgp_crt_init.restype = _error_code
828
openpgp_crt_import = _library.gnutls_openpgp_crt_import
829
openpgp_crt_import.argtypes = [openpgp_crt_t,
830
ctypes.POINTER(datum_t),
832
openpgp_crt_import.restype = _error_code
834
openpgp_crt_verify_self = \
835
_library.gnutls_openpgp_crt_verify_self
836
openpgp_crt_verify_self.argtypes = [
839
ctypes.POINTER(ctypes.c_uint),
841
openpgp_crt_verify_self.restype = _error_code
843
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
844
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
845
openpgp_crt_deinit.restype = None
847
openpgp_crt_get_fingerprint = (
848
_library.gnutls_openpgp_crt_get_fingerprint)
849
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
853
openpgp_crt_get_fingerprint.restype = _error_code
855
if check_version(b"3.6.4"):
856
certificate_type_get2 = _library.gnutls_certificate_type_get2
857
certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
858
certificate_type_get2.restype = _error_code
860
# Remove non-public functions
861
del _error_code, _retry_on_error
438
864
def call_pipe(connection, # : multiprocessing.Connection
439
865
func, *args, **kwargs):
440
866
"""This function is meant to be called by multiprocessing.Process
442
868
This function runs func(*args, **kwargs), and writes the resulting
443
869
return value on the provided multiprocessing.Connection.
445
871
connection.send(func(*args, **kwargs))
446
872
connection.close()
448
class Client(object):
449
876
"""A representation of a client host served by this server.
452
approved: bool(); 'None' if not yet approved/disapproved
879
approved: bool(); None if not yet approved/disapproved
453
880
approval_delay: datetime.timedelta(); Time to wait for approval
454
881
approval_duration: datetime.timedelta(); Duration of one approval
455
checker: subprocess.Popen(); a running checker process used
456
to see if the client lives.
457
'None' if no process is running.
458
checker_callback_tag: a gobject event source tag, or None
882
checker: multiprocessing.Process(); a running checker process used
883
to see if the client lives. None if no process is
885
checker_callback_tag: a GLib event source tag, or None
459
886
checker_command: string; External command which is run to check
460
887
if client lives. %() expansions are done at
461
888
runtime with vars(self) as dict, so that for
462
889
instance %(name)s can be used in the command.
463
checker_initiator_tag: a gobject event source tag, or None
890
checker_initiator_tag: a GLib event source tag, or None
464
891
created: datetime.datetime(); (UTC) object creation
465
892
client_structure: Object describing what attributes a client has
466
893
and is used for storing the client at exit
467
894
current_checker_command: string; current running checker_command
468
disable_initiator_tag: a gobject event source tag, or None
895
disable_initiator_tag: a GLib event source tag, or None
470
897
fingerprint: string (40 or 32 hexadecimal digits); used to
471
uniquely identify the client
898
uniquely identify an OpenPGP client
899
key_id: string (64 hexadecimal digits); used to uniquely identify
900
a client using raw public keys
472
901
host: string; available for use by the checker command
473
902
interval: datetime.timedelta(); How often to start a new checker
474
903
last_approval_request: datetime.datetime(); (UTC) or None
1830
2265
byte_arrays=True)
1831
2266
def Secret_dbus_property(self, value):
1832
2267
self.secret = bytes(value)
1837
class ProxyClient(object):
1838
def __init__(self, child_pipe, fpr, address):
2273
def __init__(self, child_pipe, key_id, fpr, address):
1839
2274
self._pipe = child_pipe
1840
self._pipe.send(('init', fpr, address))
2275
self._pipe.send(("init", key_id, fpr, address))
1841
2276
if not self._pipe.recv():
2277
raise KeyError(key_id or fpr)
1844
2279
def __getattribute__(self, name):
1846
2281
return super(ProxyClient, self).__getattribute__(name)
1847
self._pipe.send(('getattr', name))
2282
self._pipe.send(("getattr", name))
1848
2283
data = self._pipe.recv()
1849
if data[0] == 'data':
2284
if data[0] == "data":
1851
if data[0] == 'function':
2286
if data[0] == "function":
1853
2288
def func(*args, **kwargs):
1854
self._pipe.send(('funcall', name, args, kwargs))
2289
self._pipe.send(("funcall", name, args, kwargs))
1855
2290
return self._pipe.recv()[1]
1859
2294
def __setattr__(self, name, value):
1861
2296
return super(ProxyClient, self).__setattr__(name, value)
1862
self._pipe.send(('setattr', name, value))
2297
self._pipe.send(("setattr", name, value))
1865
2300
class ClientHandler(socketserver.BaseRequestHandler, object):
1866
2301
"""A class to handle client connections.
1868
2303
Instantiated once for each connection to handle it.
1869
2304
Note: This will run in its own forked process."""
1871
2306
def handle(self):
1872
2307
with contextlib.closing(self.server.child_pipe) as child_pipe:
1873
2308
logger.info("TCP connection from: %s",
1874
2309
str(self.client_address))
1875
2310
logger.debug("Pipe FD: %d",
1876
2311
self.server.child_pipe.fileno())
1878
session = gnutls.connection.ClientSession(
1879
self.request, gnutls.connection .X509Credentials())
1881
# Note: gnutls.connection.X509Credentials is really a
1882
# generic GnuTLS certificate credentials object so long as
1883
# no X.509 keys are added to it. Therefore, we can use it
1884
# here despite using OpenPGP certificates.
1886
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1887
# "+AES-256-CBC", "+SHA1",
1888
# "+COMP-NULL", "+CTYPE-OPENPGP",
2313
session = gnutls.ClientSession(self.request)
2315
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2316
# "+AES-256-CBC", "+SHA1",
2317
# "+COMP-NULL", "+CTYPE-OPENPGP",
1890
2319
# Use a fallback default, since this MUST be set.
1891
2320
priority = self.server.gnutls_priority
1892
2321
if priority is None:
1893
2322
priority = "NORMAL"
1894
gnutls.library.functions.gnutls_priority_set_direct(
1895
session._c_object, priority, None)
2323
gnutls.priority_set_direct(session,
2324
priority.encode("utf-8"), None)
1897
2326
# Start communication using the Mandos protocol
1898
2327
# Get protocol number
1899
2328
line = self.request.makefile().readline()
1986
2428
delay -= time2 - time
1989
while sent_size < len(client.secret):
1991
sent = session.send(client.secret[sent_size:])
1992
except gnutls.errors.GNUTLSError as error:
1993
logger.warning("gnutls send failed",
1996
logger.debug("Sent: %d, remaining: %d", sent,
1997
len(client.secret) - (sent_size
2431
session.send(client.secret)
2432
except gnutls.Error as error:
2433
logger.warning("gnutls send failed",
2001
2437
logger.info("Sending secret to %s", client.name)
2002
2438
# bump the timeout using extended_timeout
2003
2439
client.bump_timeout(client.extended_timeout)
2004
2440
if self.server.use_dbus:
2005
2441
# Emit D-Bus signal
2006
2442
client.GotSecret()
2009
2445
if approval_required:
2010
2446
client.approvals_pending -= 1
2013
except gnutls.errors.GNUTLSError as error:
2449
except gnutls.Error as error:
2014
2450
logger.warning("GnuTLS bye failed",
2015
2451
exc_info=error)
2018
2454
def peer_certificate(session):
2019
"Return the peer's OpenPGP certificate as a bytestring"
2020
# If not an OpenPGP certificate...
2021
if (gnutls.library.functions.gnutls_certificate_type_get(
2023
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
2024
# ...do the normal thing
2025
return session.peer_certificate
2455
"Return the peer's certificate as a bytestring"
2457
cert_type = gnutls.certificate_type_get2(
2458
session, gnutls.CTYPE_PEERS)
2459
except AttributeError:
2460
cert_type = gnutls.certificate_type_get(session)
2461
if gnutls.has_rawpk:
2462
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2464
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2465
# If not a valid certificate type...
2466
if cert_type not in valid_cert_types:
2467
logger.info("Cert type %r not in %r", cert_type,
2469
# ...return invalid data
2026
2471
list_size = ctypes.c_uint(1)
2027
cert_list = (gnutls.library.functions
2028
.gnutls_certificate_get_peers
2029
(session._c_object, ctypes.byref(list_size)))
2472
cert_list = (gnutls.certificate_get_peers
2473
(session, ctypes.byref(list_size)))
2030
2474
if not bool(cert_list) and list_size.value != 0:
2031
raise gnutls.errors.GNUTLSError("error getting peer"
2475
raise gnutls.Error("error getting peer certificate")
2033
2476
if list_size.value == 0:
2035
2478
cert = cert_list[0]
2036
2479
return ctypes.string_at(cert.data, cert.size)
2482
def key_id(certificate):
2483
"Convert a certificate bytestring to a hexdigit key ID"
2484
# New GnuTLS "datum" with the public key
2485
datum = gnutls.datum_t(
2486
ctypes.cast(ctypes.c_char_p(certificate),
2487
ctypes.POINTER(ctypes.c_ubyte)),
2488
ctypes.c_uint(len(certificate)))
2489
# XXX all these need to be created in the gnutls "module"
2490
# New empty GnuTLS certificate
2491
pubkey = gnutls.pubkey_t()
2492
gnutls.pubkey_init(ctypes.byref(pubkey))
2493
# Import the raw public key into the certificate
2494
gnutls.pubkey_import(pubkey,
2495
ctypes.byref(datum),
2496
gnutls.X509_FMT_DER)
2497
# New buffer for the key ID
2498
buf = ctypes.create_string_buffer(32)
2499
buf_len = ctypes.c_size_t(len(buf))
2500
# Get the key ID from the raw public key into the buffer
2501
gnutls.pubkey_get_key_id(
2503
gnutls.KEYID_USE_SHA256,
2504
ctypes.cast(ctypes.byref(buf),
2505
ctypes.POINTER(ctypes.c_ubyte)),
2506
ctypes.byref(buf_len))
2507
# Deinit the certificate
2508
gnutls.pubkey_deinit(pubkey)
2510
# Convert the buffer to a Python bytestring
2511
key_id = ctypes.string_at(buf, buf_len.value)
2512
# Convert the bytestring to hexadecimal notation
2513
hex_key_id = binascii.hexlify(key_id).upper()
2039
2517
def fingerprint(openpgp):
2040
2518
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2041
2519
# New GnuTLS "datum" with the OpenPGP public key
2042
datum = gnutls.library.types.gnutls_datum_t(
2520
datum = gnutls.datum_t(
2043
2521
ctypes.cast(ctypes.c_char_p(openpgp),
2044
2522
ctypes.POINTER(ctypes.c_ubyte)),
2045
2523
ctypes.c_uint(len(openpgp)))
2046
2524
# New empty GnuTLS certificate
2047
crt = gnutls.library.types.gnutls_openpgp_crt_t()
2048
gnutls.library.functions.gnutls_openpgp_crt_init(
2525
crt = gnutls.openpgp_crt_t()
2526
gnutls.openpgp_crt_init(ctypes.byref(crt))
2050
2527
# Import the OpenPGP public key into the certificate
2051
gnutls.library.functions.gnutls_openpgp_crt_import(
2052
crt, ctypes.byref(datum),
2053
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
2528
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2529
gnutls.OPENPGP_FMT_RAW)
2054
2530
# Verify the self signature in the key
2055
2531
crtverify = ctypes.c_uint()
2056
gnutls.library.functions.gnutls_openpgp_crt_verify_self(
2057
crt, 0, ctypes.byref(crtverify))
2532
gnutls.openpgp_crt_verify_self(crt, 0,
2533
ctypes.byref(crtverify))
2058
2534
if crtverify.value != 0:
2059
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2060
raise gnutls.errors.CertificateSecurityError(
2535
gnutls.openpgp_crt_deinit(crt)
2536
raise gnutls.CertificateSecurityError(code
2062
2538
# New buffer for the fingerprint
2063
2539
buf = ctypes.create_string_buffer(20)
2064
2540
buf_len = ctypes.c_size_t()
2065
2541
# Get the fingerprint from the certificate into the buffer
2066
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(
2067
crt, ctypes.byref(buf), ctypes.byref(buf_len))
2542
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2543
ctypes.byref(buf_len))
2068
2544
# Deinit the certificate
2069
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2545
gnutls.openpgp_crt_deinit(crt)
2070
2546
# Convert the buffer to a Python bytestring
2071
2547
fpr = ctypes.string_at(buf, buf_len.value)
2072
2548
# Convert the bytestring to hexadecimal notation
2160
2637
# socket_wrapper(), if socketfd was set.
2161
2638
socketserver.TCPServer.__init__(self, server_address,
2162
2639
RequestHandlerClass)
2164
2641
def server_bind(self):
2165
2642
"""This overrides the normal server_bind() function
2166
2643
to bind to an interface if one was specified, and also NOT to
2167
2644
bind to an address or port if they were not specified."""
2645
global SO_BINDTODEVICE
2168
2646
if self.interface is not None:
2169
2647
if SO_BINDTODEVICE is None:
2170
logger.error("SO_BINDTODEVICE does not exist;"
2171
" cannot bind to interface %s",
2175
self.socket.setsockopt(
2176
socket.SOL_SOCKET, SO_BINDTODEVICE,
2177
(self.interface + "\0").encode("utf-8"))
2178
except socket.error as error:
2179
if error.errno == errno.EPERM:
2180
logger.error("No permission to bind to"
2181
" interface %s", self.interface)
2182
elif error.errno == errno.ENOPROTOOPT:
2183
logger.error("SO_BINDTODEVICE not available;"
2184
" cannot bind to interface %s",
2186
elif error.errno == errno.ENODEV:
2187
logger.error("Interface %s does not exist,"
2188
" cannot bind", self.interface)
2648
# Fall back to a hard-coded value which seems to be
2650
logger.warning("SO_BINDTODEVICE not found, trying 25")
2651
SO_BINDTODEVICE = 25
2653
self.socket.setsockopt(
2654
socket.SOL_SOCKET, SO_BINDTODEVICE,
2655
(self.interface + "\0").encode("utf-8"))
2656
except socket.error as error:
2657
if error.errno == errno.EPERM:
2658
logger.error("No permission to bind to"
2659
" interface %s", self.interface)
2660
elif error.errno == errno.ENOPROTOOPT:
2661
logger.error("SO_BINDTODEVICE not available;"
2662
" cannot bind to interface %s",
2664
elif error.errno == errno.ENODEV:
2665
logger.error("Interface %s does not exist,"
2666
" cannot bind", self.interface)
2191
2669
# Only bind(2) the socket if we really need to.
2192
2670
if self.server_address[0] or self.server_address[1]:
2671
if self.server_address[1]:
2672
self.allow_reuse_address = True
2193
2673
if not self.server_address[0]:
2194
2674
if self.address_family == socket.AF_INET6:
2195
any_address = "::" # in6addr_any
2675
any_address = "::" # in6addr_any
2197
any_address = "0.0.0.0" # INADDR_ANY
2677
any_address = "0.0.0.0" # INADDR_ANY
2198
2678
self.server_address = (any_address,
2199
2679
self.server_address[1])
2200
2680
elif not self.server_address[1]:
2234
2714
self.gnutls_priority = gnutls_priority
2235
2715
IPv6_TCPServer.__init__(self, server_address,
2236
2716
RequestHandlerClass,
2237
interface = interface,
2238
use_ipv6 = use_ipv6,
2239
socketfd = socketfd)
2717
interface=interface,
2241
2721
def server_activate(self):
2242
2722
if self.enabled:
2243
2723
return socketserver.TCPServer.server_activate(self)
2245
2725
def enable(self):
2246
2726
self.enabled = True
2248
2728
def add_pipe(self, parent_pipe, proc):
2249
2729
# Call "handle_ipc" for both data and EOF events
2250
gobject.io_add_watch(
2251
parent_pipe.fileno(),
2252
gobject.IO_IN | gobject.IO_HUP,
2731
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2732
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2253
2733
functools.partial(self.handle_ipc,
2254
parent_pipe = parent_pipe,
2734
parent_pipe=parent_pipe,
2257
2737
def handle_ipc(self, source, condition,
2258
2738
parent_pipe=None,
2260
2740
client_object=None):
2261
2741
# error, or the other end of multiprocessing.Pipe has closed
2262
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2742
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2263
2743
# Wait for other process to exit
2267
2747
# Read a request from the child
2268
2748
request = parent_pipe.recv()
2269
2749
command = request[0]
2271
if command == 'init':
2273
address = request[2]
2275
for c in self.clients.itervalues():
2276
if c.fingerprint == fpr:
2751
if command == "init":
2752
key_id = request[1].decode("ascii")
2753
fpr = request[2].decode("ascii")
2754
address = request[3]
2756
for c in self.clients.values():
2757
if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
2758
"27AE41E4649B934CA495991B7852B855"):
2760
if key_id and c.key_id == key_id:
2763
if fpr and c.fingerprint == fpr:
2280
logger.info("Client not found for fingerprint: %s, ad"
2281
"dress: %s", fpr, address)
2767
logger.info("Client not found for key ID: %s, address"
2768
": %s", key_id or fpr, address)
2282
2769
if self.use_dbus:
2283
2770
# Emit D-Bus signal
2284
mandos_dbus_service.ClientNotFound(fpr,
2771
mandos_dbus_service.ClientNotFound(key_id or fpr,
2286
2773
parent_pipe.send(False)
2289
gobject.io_add_watch(
2290
parent_pipe.fileno(),
2291
gobject.IO_IN | gobject.IO_HUP,
2777
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2778
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2292
2779
functools.partial(self.handle_ipc,
2293
parent_pipe = parent_pipe,
2295
client_object = client))
2780
parent_pipe=parent_pipe,
2782
client_object=client))
2296
2783
parent_pipe.send(True)
2297
2784
# remove the old hook in favor of the new above hook on
2300
if command == 'funcall':
2787
if command == "funcall":
2301
2788
funcname = request[1]
2302
2789
args = request[2]
2303
2790
kwargs = request[3]
2305
parent_pipe.send(('data', getattr(client_object,
2792
parent_pipe.send(("data", getattr(client_object,
2306
2793
funcname)(*args,
2309
if command == 'getattr':
2796
if command == "getattr":
2310
2797
attrname = request[1]
2311
2798
if isinstance(client_object.__getattribute__(attrname),
2312
collections.Callable):
2313
parent_pipe.send(('function', ))
2799
collections.abc.Callable):
2800
parent_pipe.send(("function", ))
2315
2802
parent_pipe.send((
2316
'data', client_object.__getattribute__(attrname)))
2318
if command == 'setattr':
2803
"data", client_object.__getattribute__(attrname)))
2805
if command == "setattr":
2319
2806
attrname = request[1]
2320
2807
value = request[2]
2321
2808
setattr(client_object, attrname, value)
2326
2813
def rfc3339_duration_to_delta(duration):
2327
2814
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2329
>>> rfc3339_duration_to_delta("P7D")
2330
datetime.timedelta(7)
2331
>>> rfc3339_duration_to_delta("PT60S")
2332
datetime.timedelta(0, 60)
2333
>>> rfc3339_duration_to_delta("PT60M")
2334
datetime.timedelta(0, 3600)
2335
>>> rfc3339_duration_to_delta("PT24H")
2336
datetime.timedelta(1)
2337
>>> rfc3339_duration_to_delta("P1W")
2338
datetime.timedelta(7)
2339
>>> rfc3339_duration_to_delta("PT5M30S")
2340
datetime.timedelta(0, 330)
2341
>>> rfc3339_duration_to_delta("P1DT3M20S")
2342
datetime.timedelta(1, 200)
2816
>>> timedelta = datetime.timedelta
2817
>>> rfc3339_duration_to_delta("P7D") == timedelta(7)
2819
>>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
2821
>>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
2823
>>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
2825
>>> rfc3339_duration_to_delta("P1W") == timedelta(7)
2827
>>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
2829
>>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
2345
2834
# Parsing an RFC 3339 duration with regular expressions is not
2346
2835
# possible - there would have to be multiple places for the same
2347
2836
# values, like seconds. The current code, while more esoteric, is
2348
2837
# cleaner without depending on a parsing library. If Python had a
2349
2838
# built-in library for parsing we would use it, but we'd like to
2350
2839
# avoid excessive use of external libraries.
2352
2841
# New type for defining tokens, syntax, and semantics all-in-one
2353
2842
Token = collections.namedtuple("Token", (
2354
2843
"regexp", # To match token; if "value" is not None, must have
2745
3246
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2746
3247
service = AvahiServiceToSyslog(
2747
name = server_settings["servicename"],
2748
servicetype = "_mandos._tcp",
2749
protocol = protocol,
3248
name=server_settings["servicename"],
3249
servicetype="_mandos._tcp",
2751
3252
if server_settings["interface"]:
2752
3253
service.interface = if_nametoindex(
2753
3254
server_settings["interface"].encode("utf-8"))
2755
3256
global multiprocessing_manager
2756
3257
multiprocessing_manager = multiprocessing.Manager()
2758
3259
client_class = Client
2760
client_class = functools.partial(ClientDBus, bus = bus)
3261
client_class = functools.partial(ClientDBus, bus=bus)
2762
3263
client_settings = Client.config_parser(client_config)
2763
3264
old_client_settings = {}
2764
3265
clients_data = {}
2766
3267
# This is used to redirect stdout and stderr for checker processes
2768
wnull = open(os.devnull, "w") # A writable /dev/null
3269
wnull = open(os.devnull, "w") # A writable /dev/null
2769
3270
# Only used if server is running in foreground but not in debug
2771
3272
if debug or not foreground:
2774
3275
# Get client data and settings from last running state.
2775
3276
if server_settings["restore"]:
2777
3278
with open(stored_state_path, "rb") as stored_state:
2778
clients_data, old_client_settings = pickle.load(
3279
if sys.version_info.major == 2:
3280
clients_data, old_client_settings = pickle.load(
3283
bytes_clients_data, bytes_old_client_settings = (
3284
pickle.load(stored_state, encoding="bytes"))
3285
# Fix bytes to strings
3288
clients_data = {(key.decode("utf-8")
3289
if isinstance(key, bytes)
3292
bytes_clients_data.items()}
3293
del bytes_clients_data
3294
for key in clients_data:
3295
value = {(k.decode("utf-8")
3296
if isinstance(k, bytes) else k): v
3298
clients_data[key].items()}
3299
clients_data[key] = value
3301
value["client_structure"] = [
3303
if isinstance(s, bytes)
3305
value["client_structure"]]
3306
# .name, .host, and .checker_command
3307
for k in ("name", "host", "checker_command"):
3308
if isinstance(value[k], bytes):
3309
value[k] = value[k].decode("utf-8")
3310
if "key_id" not in value:
3311
value["key_id"] = ""
3312
elif "fingerprint" not in value:
3313
value["fingerprint"] = ""
3314
# old_client_settings
3316
old_client_settings = {
3317
(key.decode("utf-8")
3318
if isinstance(key, bytes)
3321
bytes_old_client_settings.items()}
3322
del bytes_old_client_settings
3323
# .host and .checker_command
3324
for value in old_client_settings.values():
3325
for attribute in ("host", "checker_command"):
3326
if isinstance(value[attribute], bytes):
3327
value[attribute] = (value[attribute]
2780
3329
os.remove(stored_state_path)
2781
3330
except IOError as e:
2782
3331
if e.errno == errno.ENOENT: