506
519
# Pretend that we have a GnuTLS module
507
class GnuTLS(object):
508
"""This isn't so much a class as it is a module-like namespace.
509
It is instantiated once, and simulates having a GnuTLS module."""
521
"""This isn't so much a class as it is a module-like namespace."""
511
523
library = ctypes.util.find_library("gnutls")
512
524
if library is None:
513
525
library = ctypes.util.find_library("gnutls-deb0")
514
526
_library = ctypes.cdll.LoadLibrary(library)
516
_need_version = b"3.3.0"
519
# Need to use "self" here, since this method is called before
520
# the assignment to the "gnutls" global variable happens.
521
if self.check_version(self._need_version) is None:
522
raise self.Error("Needs GnuTLS {} or later"
523
.format(self._need_version))
525
529
# Unless otherwise indicated, the constants and types below are
526
530
# all from the gnutls/gnutls.h C header file.
564
574
class Error(Exception):
565
# We need to use the class name "GnuTLS" here, since this
566
# exception might be raised from within GnuTLS.__init__,
567
# which is called before the assignment to the "gnutls"
568
# global variable has happened.
569
575
def __init__(self, message=None, code=None, args=()):
570
576
# Default usage is by a message string, but if a return
571
577
# code is passed, convert it to a string with
572
578
# gnutls.strerror()
574
580
if message is None and code is not None:
575
message = GnuTLS.strerror(code)
576
return super(GnuTLS.Error, self).__init__(
581
message = gnutls.strerror(code)
582
return super(gnutls.Error, self).__init__(
579
585
class CertificateSecurityError(Error):
583
class Credentials(object):
584
590
def __init__(self):
585
591
self._c_object = gnutls.certificate_credentials_t()
586
592
gnutls.certificate_allocate_credentials(
590
596
def __del__(self):
591
597
gnutls.certificate_free_credentials(self._c_object)
593
class ClientSession(object):
594
600
def __init__(self, socket, credentials=None):
595
601
self._c_object = gnutls.session_t()
596
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
602
gnutls_flags = gnutls.CLIENT
603
if gnutls.check_version(b"3.5.6"):
604
gnutls_flags |= gnutls.NO_TICKETS
606
gnutls_flags |= gnutls.ENABLE_RAWPK
607
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
597
609
gnutls.set_default_priority(self._c_object)
598
610
gnutls.transport_set_ptr(self._c_object, socket.fileno())
599
611
gnutls.handshake_set_private_extensions(self._c_object,
731
743
check_version.argtypes = [ctypes.c_char_p]
732
744
check_version.restype = ctypes.c_char_p
734
# All the function declarations below are from gnutls/openpgp.h
736
openpgp_crt_init = _library.gnutls_openpgp_crt_init
737
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
738
openpgp_crt_init.restype = _error_code
740
openpgp_crt_import = _library.gnutls_openpgp_crt_import
741
openpgp_crt_import.argtypes = [openpgp_crt_t,
742
ctypes.POINTER(datum_t),
744
openpgp_crt_import.restype = _error_code
746
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
747
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
748
ctypes.POINTER(ctypes.c_uint)]
749
openpgp_crt_verify_self.restype = _error_code
751
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
752
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
753
openpgp_crt_deinit.restype = None
755
openpgp_crt_get_fingerprint = (
756
_library.gnutls_openpgp_crt_get_fingerprint)
757
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
761
openpgp_crt_get_fingerprint.restype = _error_code
746
_need_version = b"3.3.0"
747
if check_version(_need_version) is None:
748
raise self.Error("Needs GnuTLS {} or later"
749
.format(_need_version))
751
_tls_rawpk_version = b"3.6.6"
752
has_rawpk = bool(check_version(_tls_rawpk_version))
756
class pubkey_st(ctypes.Structure):
758
pubkey_t = ctypes.POINTER(pubkey_st)
760
x509_crt_fmt_t = ctypes.c_int
762
# All the function declarations below are from gnutls/abstract.h
763
pubkey_init = _library.gnutls_pubkey_init
764
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
765
pubkey_init.restype = _error_code
767
pubkey_import = _library.gnutls_pubkey_import
768
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
770
pubkey_import.restype = _error_code
772
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
773
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
774
ctypes.POINTER(ctypes.c_ubyte),
775
ctypes.POINTER(ctypes.c_size_t)]
776
pubkey_get_key_id.restype = _error_code
778
pubkey_deinit = _library.gnutls_pubkey_deinit
779
pubkey_deinit.argtypes = [pubkey_t]
780
pubkey_deinit.restype = None
782
# All the function declarations below are from gnutls/openpgp.h
784
openpgp_crt_init = _library.gnutls_openpgp_crt_init
785
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
786
openpgp_crt_init.restype = _error_code
788
openpgp_crt_import = _library.gnutls_openpgp_crt_import
789
openpgp_crt_import.argtypes = [openpgp_crt_t,
790
ctypes.POINTER(datum_t),
792
openpgp_crt_import.restype = _error_code
794
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
795
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
796
ctypes.POINTER(ctypes.c_uint)]
797
openpgp_crt_verify_self.restype = _error_code
799
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
800
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
801
openpgp_crt_deinit.restype = None
803
openpgp_crt_get_fingerprint = (
804
_library.gnutls_openpgp_crt_get_fingerprint)
805
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
809
openpgp_crt_get_fingerprint.restype = _error_code
811
if check_version(b"3.6.4"):
812
certificate_type_get2 = _library.gnutls_certificate_type_get2
813
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
814
certificate_type_get2.restype = _error_code
763
816
# Remove non-public functions
764
817
del _error_code, _retry_on_error
765
# Create the global "gnutls" object, simulating a module
769
820
def call_pipe(connection, # : multiprocessing.Connection
777
828
connection.close()
780
class Client(object):
781
832
"""A representation of a client host served by this server.
784
835
approved: bool(); 'None' if not yet approved/disapproved
785
836
approval_delay: datetime.timedelta(); Time to wait for approval
786
837
approval_duration: datetime.timedelta(); Duration of one approval
787
checker: subprocess.Popen(); a running checker process used
788
to see if the client lives.
789
'None' if no process is running.
838
checker: multiprocessing.Process(); a running checker process used
839
to see if the client lives. 'None' if no process is
790
841
checker_callback_tag: a GLib event source tag, or None
791
842
checker_command: string; External command which is run to check
792
843
if client lives. %() expansions are done at
826
879
runtime_expansions = ("approval_delay", "approval_duration",
827
"created", "enabled", "expires",
880
"created", "enabled", "expires", "key_id",
828
881
"fingerprint", "host", "interval",
829
882
"last_approval_request", "last_checked_ok",
830
883
"last_enabled", "name", "timeout")
2162
class ProxyClient(object):
2163
def __init__(self, child_pipe, fpr, address):
2228
def __init__(self, child_pipe, key_id, fpr, address):
2164
2229
self._pipe = child_pipe
2165
self._pipe.send(('init', fpr, address))
2230
self._pipe.send(('init', key_id, fpr, address))
2166
2231
if not self._pipe.recv():
2232
raise KeyError(key_id or fpr)
2169
2234
def __getattribute__(self, name):
2170
2235
if name == '_pipe':
2238
2303
approval_required = False
2241
fpr = self.fingerprint(
2242
self.peer_certificate(session))
2243
except (TypeError, gnutls.Error) as error:
2244
logger.warning("Bad certificate: %s", error)
2246
logger.debug("Fingerprint: %s", fpr)
2249
client = ProxyClient(child_pipe, fpr,
2305
if gnutls.has_rawpk:
2308
key_id = self.key_id(
2309
self.peer_certificate(session))
2310
except (TypeError, gnutls.Error) as error:
2311
logger.warning("Bad certificate: %s", error)
2313
logger.debug("Key ID: %s", key_id)
2318
fpr = self.fingerprint(
2319
self.peer_certificate(session))
2320
except (TypeError, gnutls.Error) as error:
2321
logger.warning("Bad certificate: %s", error)
2323
logger.debug("Fingerprint: %s", fpr)
2326
client = ProxyClient(child_pipe, key_id, fpr,
2250
2327
self.client_address)
2251
2328
except KeyError:
2331
2408
def peer_certificate(session):
2332
"Return the peer's OpenPGP certificate as a bytestring"
2333
# If not an OpenPGP certificate...
2334
if (gnutls.certificate_type_get(session._c_object)
2335
!= gnutls.CRT_OPENPGP):
2409
"Return the peer's certificate as a bytestring"
2411
cert_type = gnutls.certificate_type_get2(session._c_object,
2413
except AttributeError:
2414
cert_type = gnutls.certificate_type_get(session._c_object)
2415
if gnutls.has_rawpk:
2416
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2418
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2419
# If not a valid certificate type...
2420
if cert_type not in valid_cert_types:
2421
logger.info("Cert type %r not in %r", cert_type,
2336
2423
# ...return invalid data
2338
2425
list_size = ctypes.c_uint(1)
2346
2433
return ctypes.string_at(cert.data, cert.size)
2436
def key_id(certificate):
2437
"Convert a certificate bytestring to a hexdigit key ID"
2438
# New GnuTLS "datum" with the public key
2439
datum = gnutls.datum_t(
2440
ctypes.cast(ctypes.c_char_p(certificate),
2441
ctypes.POINTER(ctypes.c_ubyte)),
2442
ctypes.c_uint(len(certificate)))
2443
# XXX all these need to be created in the gnutls "module"
2444
# New empty GnuTLS certificate
2445
pubkey = gnutls.pubkey_t()
2446
gnutls.pubkey_init(ctypes.byref(pubkey))
2447
# Import the raw public key into the certificate
2448
gnutls.pubkey_import(pubkey,
2449
ctypes.byref(datum),
2450
gnutls.X509_FMT_DER)
2451
# New buffer for the key ID
2452
buf = ctypes.create_string_buffer(32)
2453
buf_len = ctypes.c_size_t(len(buf))
2454
# Get the key ID from the raw public key into the buffer
2455
gnutls.pubkey_get_key_id(pubkey,
2456
gnutls.KEYID_USE_SHA256,
2457
ctypes.cast(ctypes.byref(buf),
2458
ctypes.POINTER(ctypes.c_ubyte)),
2459
ctypes.byref(buf_len))
2460
# Deinit the certificate
2461
gnutls.pubkey_deinit(pubkey)
2463
# Convert the buffer to a Python bytestring
2464
key_id = ctypes.string_at(buf, buf_len.value)
2465
# Convert the bytestring to hexadecimal notation
2466
hex_key_id = binascii.hexlify(key_id).upper()
2349
2470
def fingerprint(openpgp):
2350
2471
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2351
2472
# New GnuTLS "datum" with the OpenPGP public key
2579
2702
command = request[0]
2581
2704
if command == 'init':
2582
fpr = request[1].decode("ascii")
2583
address = request[2]
2705
key_id = request[1].decode("ascii")
2706
fpr = request[2].decode("ascii")
2707
address = request[3]
2585
2709
for c in self.clients.values():
2586
if c.fingerprint == fpr:
2710
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2712
if key_id and c.key_id == key_id:
2715
if fpr and c.fingerprint == fpr:
2590
logger.info("Client not found for fingerprint: %s, ad"
2591
"dress: %s", fpr, address)
2719
logger.info("Client not found for key ID: %s, address"
2720
": %s", key_id or fpr, address)
2592
2721
if self.use_dbus:
2593
2722
# Emit D-Bus signal
2594
mandos_dbus_service.ClientNotFound(fpr,
2723
mandos_dbus_service.ClientNotFound(key_id or fpr,
2596
2725
parent_pipe.send(False)
2599
2728
GLib.io_add_watch(
2600
parent_pipe.fileno(),
2601
GLib.IO_IN | GLib.IO_HUP,
2729
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2730
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2602
2731
functools.partial(self.handle_ipc,
2603
2732
parent_pipe=parent_pipe,
2636
2765
def rfc3339_duration_to_delta(duration):
2637
2766
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2639
>>> rfc3339_duration_to_delta("P7D")
2640
datetime.timedelta(7)
2641
>>> rfc3339_duration_to_delta("PT60S")
2642
datetime.timedelta(0, 60)
2643
>>> rfc3339_duration_to_delta("PT60M")
2644
datetime.timedelta(0, 3600)
2645
>>> rfc3339_duration_to_delta("PT24H")
2646
datetime.timedelta(1)
2647
>>> rfc3339_duration_to_delta("P1W")
2648
datetime.timedelta(7)
2649
>>> rfc3339_duration_to_delta("PT5M30S")
2650
datetime.timedelta(0, 330)
2651
>>> rfc3339_duration_to_delta("P1DT3M20S")
2652
datetime.timedelta(1, 200)
2768
>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
2770
>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
2772
>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
2774
>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
2776
>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
2778
>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
2780
>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
2655
2784
# Parsing an RFC 3339 duration with regular expressions is not
2735
2864
def string_to_delta(interval):
2736
2865
"""Parse a string and return a datetime.timedelta
2738
>>> string_to_delta('7d')
2739
datetime.timedelta(7)
2740
>>> string_to_delta('60s')
2741
datetime.timedelta(0, 60)
2742
>>> string_to_delta('60m')
2743
datetime.timedelta(0, 3600)
2744
>>> string_to_delta('24h')
2745
datetime.timedelta(1)
2746
>>> string_to_delta('1w')
2747
datetime.timedelta(7)
2748
>>> string_to_delta('5m 30s')
2749
datetime.timedelta(0, 330)
2867
>>> string_to_delta('7d') == datetime.timedelta(7)
2869
>>> string_to_delta('60s') == datetime.timedelta(0, 60)
2871
>>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2873
>>> string_to_delta('24h') == datetime.timedelta(1)
2875
>>> string_to_delta('1w') == datetime.timedelta(7)
2877
>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
3471
3604
# End of Avahi example code
3473
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3474
lambda *args, **kwargs:
3475
(tcp_server.handle_request
3476
(*args[2:], **kwargs) or True))
3607
GLib.IOChannel.unix_new(tcp_server.fileno()),
3608
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3609
lambda *args, **kwargs: (tcp_server.handle_request
3610
(*args[2:], **kwargs) or True))
3478
3612
logger.debug("Starting main loop")
3479
3613
main_loop.run()
3489
3623
# Must run before the D-Bus bus name gets deregistered
3627
def should_only_run_tests():
3628
parser = argparse.ArgumentParser(add_help=False)
3629
parser.add_argument("--check", action='store_true')
3630
args, unknown_args = parser.parse_known_args()
3631
run_tests = args.check
3633
# Remove --check argument from sys.argv
3634
sys.argv[1:] = unknown_args
3637
# Add all tests from doctest strings
3638
def load_tests(loader, tests, none):
3640
tests.addTests(doctest.DocTestSuite())
3493
3643
if __name__ == '__main__':
3645
if should_only_run_tests():
3646
# Call using ./mandos --check [--verbose]