250
196
.replace(b"\n", b"\\n")
251
197
.replace(b"\0", b"\\x00"))
254
200
def encrypt(self, data, password):
255
201
passphrase = self.password_encode(password)
256
202
with tempfile.NamedTemporaryFile(
257
203
dir=self.tempdir) as passfile:
258
204
passfile.write(passphrase)
260
proc = subprocess.Popen([self.gpg, '--symmetric',
206
proc = subprocess.Popen(['gpg', '--symmetric',
261
207
'--passphrase-file',
263
209
+ self.gnupgargs,
264
stdin=subprocess.PIPE,
265
stdout=subprocess.PIPE,
266
stderr=subprocess.PIPE)
267
ciphertext, err = proc.communicate(input=data)
210
stdin = subprocess.PIPE,
211
stdout = subprocess.PIPE,
212
stderr = subprocess.PIPE)
213
ciphertext, err = proc.communicate(input = data)
268
214
if proc.returncode != 0:
269
215
raise PGPError(err)
270
216
return ciphertext
272
218
def decrypt(self, data, password):
273
219
passphrase = self.password_encode(password)
274
220
with tempfile.NamedTemporaryFile(
275
dir=self.tempdir) as passfile:
221
dir = self.tempdir) as passfile:
276
222
passfile.write(passphrase)
278
proc = subprocess.Popen([self.gpg, '--decrypt',
224
proc = subprocess.Popen(['gpg', '--decrypt',
279
225
'--passphrase-file',
281
227
+ self.gnupgargs,
282
stdin=subprocess.PIPE,
283
stdout=subprocess.PIPE,
284
stderr=subprocess.PIPE)
285
decrypted_plaintext, err = proc.communicate(input=data)
228
stdin = subprocess.PIPE,
229
stdout = subprocess.PIPE,
230
stderr = subprocess.PIPE)
231
decrypted_plaintext, err = proc.communicate(input = data)
286
232
if proc.returncode != 0:
287
233
raise PGPError(err)
288
234
return decrypted_plaintext
291
# Pretend that we have an Avahi module
293
"""This isn't so much a class as it is a module-like namespace."""
294
IF_UNSPEC = -1 # avahi-common/address.h
295
PROTO_UNSPEC = -1 # avahi-common/address.h
296
PROTO_INET = 0 # avahi-common/address.h
297
PROTO_INET6 = 1 # avahi-common/address.h
298
DBUS_NAME = "org.freedesktop.Avahi"
299
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
300
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
301
DBUS_PATH_SERVER = "/"
304
def string_array_to_txt_array(t):
305
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
306
for s in t), signature="ay")
307
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
308
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
309
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
310
SERVER_INVALID = 0 # avahi-common/defs.h
311
SERVER_REGISTERING = 1 # avahi-common/defs.h
312
SERVER_RUNNING = 2 # avahi-common/defs.h
313
SERVER_COLLISION = 3 # avahi-common/defs.h
314
SERVER_FAILURE = 4 # avahi-common/defs.h
317
237
class AvahiError(Exception):
318
238
def __init__(self, value, *args, **kwargs):
319
239
self.value = value
509
429
class AvahiServiceToSyslog(AvahiService):
510
430
def rename(self, *args, **kwargs):
511
431
"""Add the new name to the syslog messages"""
512
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
432
ret = AvahiService.rename(self, *args, **kwargs)
513
433
syslogger.setFormatter(logging.Formatter(
514
434
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
515
435
.format(self.name)))
519
# Pretend that we have a GnuTLS module
521
"""This isn't so much a class as it is a module-like namespace."""
523
library = ctypes.util.find_library("gnutls")
525
library = ctypes.util.find_library("gnutls-deb0")
526
_library = ctypes.cdll.LoadLibrary(library)
529
# Unless otherwise indicated, the constants and types below are
530
# all from the gnutls/gnutls.h C header file.
541
E_NO_CERTIFICATE_FOUND = -49
546
KEYID_USE_SHA256 = 1 # gnutls/x509.h
547
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
550
class session_int(ctypes.Structure):
552
session_t = ctypes.POINTER(session_int)
554
class certificate_credentials_st(ctypes.Structure):
556
certificate_credentials_t = ctypes.POINTER(
557
certificate_credentials_st)
558
certificate_type_t = ctypes.c_int
560
class datum_t(ctypes.Structure):
561
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
562
('size', ctypes.c_uint)]
564
class openpgp_crt_int(ctypes.Structure):
566
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
567
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
568
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
569
credentials_type_t = ctypes.c_int
570
transport_ptr_t = ctypes.c_void_p
571
close_request_t = ctypes.c_int
574
class Error(Exception):
575
def __init__(self, message=None, code=None, args=()):
576
# Default usage is by a message string, but if a return
577
# code is passed, convert it to a string with
580
if message is None and code is not None:
581
message = gnutls.strerror(code)
582
return super(gnutls.Error, self).__init__(
585
class CertificateSecurityError(Error):
591
self._c_object = gnutls.certificate_credentials_t()
592
gnutls.certificate_allocate_credentials(
593
ctypes.byref(self._c_object))
594
self.type = gnutls.CRD_CERTIFICATE
597
gnutls.certificate_free_credentials(self._c_object)
600
def __init__(self, socket, credentials=None):
601
self._c_object = gnutls.session_t()
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)
609
gnutls.set_default_priority(self._c_object)
610
gnutls.transport_set_ptr(self._c_object, socket.fileno())
611
gnutls.handshake_set_private_extensions(self._c_object,
614
if credentials is None:
615
credentials = gnutls.Credentials()
616
gnutls.credentials_set(self._c_object, credentials.type,
617
ctypes.cast(credentials._c_object,
619
self.credentials = credentials
622
gnutls.deinit(self._c_object)
625
return gnutls.handshake(self._c_object)
627
def send(self, data):
631
data_len -= gnutls.record_send(self._c_object,
636
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
638
# Error handling functions
639
def _error_code(result):
640
"""A function to raise exceptions on errors, suitable
641
for the 'restype' attribute on ctypes functions"""
644
if result == gnutls.E_NO_CERTIFICATE_FOUND:
645
raise gnutls.CertificateSecurityError(code=result)
646
raise gnutls.Error(code=result)
648
def _retry_on_error(result, func, arguments):
649
"""A function to retry on some errors, suitable
650
for the 'errcheck' attribute on ctypes functions"""
652
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
653
return _error_code(result)
654
result = func(*arguments)
657
# Unless otherwise indicated, the function declarations below are
658
# all from the gnutls/gnutls.h C header file.
661
priority_set_direct = _library.gnutls_priority_set_direct
662
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
663
ctypes.POINTER(ctypes.c_char_p)]
664
priority_set_direct.restype = _error_code
666
init = _library.gnutls_init
667
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
668
init.restype = _error_code
670
set_default_priority = _library.gnutls_set_default_priority
671
set_default_priority.argtypes = [session_t]
672
set_default_priority.restype = _error_code
674
record_send = _library.gnutls_record_send
675
record_send.argtypes = [session_t, ctypes.c_void_p,
677
record_send.restype = ctypes.c_ssize_t
678
record_send.errcheck = _retry_on_error
680
certificate_allocate_credentials = (
681
_library.gnutls_certificate_allocate_credentials)
682
certificate_allocate_credentials.argtypes = [
683
ctypes.POINTER(certificate_credentials_t)]
684
certificate_allocate_credentials.restype = _error_code
686
certificate_free_credentials = (
687
_library.gnutls_certificate_free_credentials)
688
certificate_free_credentials.argtypes = [
689
certificate_credentials_t]
690
certificate_free_credentials.restype = None
692
handshake_set_private_extensions = (
693
_library.gnutls_handshake_set_private_extensions)
694
handshake_set_private_extensions.argtypes = [session_t,
696
handshake_set_private_extensions.restype = None
698
credentials_set = _library.gnutls_credentials_set
699
credentials_set.argtypes = [session_t, credentials_type_t,
701
credentials_set.restype = _error_code
703
strerror = _library.gnutls_strerror
704
strerror.argtypes = [ctypes.c_int]
705
strerror.restype = ctypes.c_char_p
707
certificate_type_get = _library.gnutls_certificate_type_get
708
certificate_type_get.argtypes = [session_t]
709
certificate_type_get.restype = _error_code
711
certificate_get_peers = _library.gnutls_certificate_get_peers
712
certificate_get_peers.argtypes = [session_t,
713
ctypes.POINTER(ctypes.c_uint)]
714
certificate_get_peers.restype = ctypes.POINTER(datum_t)
716
global_set_log_level = _library.gnutls_global_set_log_level
717
global_set_log_level.argtypes = [ctypes.c_int]
718
global_set_log_level.restype = None
720
global_set_log_function = _library.gnutls_global_set_log_function
721
global_set_log_function.argtypes = [log_func]
722
global_set_log_function.restype = None
724
deinit = _library.gnutls_deinit
725
deinit.argtypes = [session_t]
726
deinit.restype = None
728
handshake = _library.gnutls_handshake
729
handshake.argtypes = [session_t]
730
handshake.restype = _error_code
731
handshake.errcheck = _retry_on_error
733
transport_set_ptr = _library.gnutls_transport_set_ptr
734
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
735
transport_set_ptr.restype = None
737
bye = _library.gnutls_bye
738
bye.argtypes = [session_t, close_request_t]
739
bye.restype = _error_code
740
bye.errcheck = _retry_on_error
742
check_version = _library.gnutls_check_version
743
check_version.argtypes = [ctypes.c_char_p]
744
check_version.restype = ctypes.c_char_p
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
816
# Remove non-public functions
817
del _error_code, _retry_on_error
820
438
def call_pipe(connection, # : multiprocessing.Connection
821
439
func, *args, **kwargs):
822
440
"""This function is meant to be called by multiprocessing.Process
824
442
This function runs func(*args, **kwargs), and writes the resulting
825
443
return value on the provided multiprocessing.Connection.
827
445
connection.send(func(*args, **kwargs))
828
446
connection.close()
448
class Client(object):
832
449
"""A representation of a client host served by this server.
835
452
approved: bool(); 'None' if not yet approved/disapproved
836
453
approval_delay: datetime.timedelta(); Time to wait for approval
837
454
approval_duration: datetime.timedelta(); Duration of one approval
838
checker: multiprocessing.Process(); a running checker process used
839
to see if the client lives. 'None' if no process is
841
checker_callback_tag: a GLib event source tag, or None
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
842
459
checker_command: string; External command which is run to check
843
460
if client lives. %() expansions are done at
844
461
runtime with vars(self) as dict, so that for
845
462
instance %(name)s can be used in the command.
846
checker_initiator_tag: a GLib event source tag, or None
463
checker_initiator_tag: a gobject event source tag, or None
847
464
created: datetime.datetime(); (UTC) object creation
848
465
client_structure: Object describing what attributes a client has
849
466
and is used for storing the client at exit
850
467
current_checker_command: string; current running checker_command
851
disable_initiator_tag: a GLib event source tag, or None
468
disable_initiator_tag: a gobject event source tag, or None
853
470
fingerprint: string (40 or 32 hexadecimal digits); used to
854
uniquely identify an OpenPGP client
855
key_id: string (64 hexadecimal digits); used to uniquely identify
856
a client using raw public keys
471
uniquely identify the client
857
472
host: string; available for use by the checker command
858
473
interval: datetime.timedelta(); How often to start a new checker
859
474
last_approval_request: datetime.datetime(); (UTC) or None
1287
895
for cls in self.__class__.__mro__
1288
896
for name, athing in
1289
897
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1291
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1293
path_keyword='object_path',
1294
connection_keyword='connection')
1295
def Introspect(self, object_path, connection):
1296
"""Overloading of standard D-Bus method.
1298
Inserts annotation tags on methods and signals.
1300
xmlstring = dbus.service.Object.Introspect(self, object_path,
1303
document = xml.dom.minidom.parseString(xmlstring)
1305
for if_tag in document.getElementsByTagName("interface"):
1306
# Add annotation tags
1307
for typ in ("method", "signal"):
1308
for tag in if_tag.getElementsByTagName(typ):
1310
for name, prop in (self.
1311
_get_all_dbus_things(typ)):
1312
if (name == tag.getAttribute("name")
1313
and prop._dbus_interface
1314
== if_tag.getAttribute("name")):
1315
annots.update(getattr(
1316
prop, "_dbus_annotations", {}))
1317
for name, value in annots.items():
1318
ann_tag = document.createElement(
1320
ann_tag.setAttribute("name", name)
1321
ann_tag.setAttribute("value", value)
1322
tag.appendChild(ann_tag)
1323
# Add interface annotation tags
1324
for annotation, value in dict(
1325
itertools.chain.from_iterable(
1326
annotations().items()
1327
for name, annotations
1328
in self._get_all_dbus_things("interface")
1329
if name == if_tag.getAttribute("name")
1331
ann_tag = document.createElement("annotation")
1332
ann_tag.setAttribute("name", annotation)
1333
ann_tag.setAttribute("value", value)
1334
if_tag.appendChild(ann_tag)
1335
# Fix argument name for the Introspect method itself
1336
if (if_tag.getAttribute("name")
1337
== dbus.INTROSPECTABLE_IFACE):
1338
for cn in if_tag.getElementsByTagName("method"):
1339
if cn.getAttribute("name") == "Introspect":
1340
for arg in cn.getElementsByTagName("arg"):
1341
if (arg.getAttribute("direction")
1343
arg.setAttribute("name",
1345
xmlstring = document.toxml("utf-8")
1347
except (AttributeError, xml.dom.DOMException,
1348
xml.parsers.expat.ExpatError) as error:
1349
logger.error("Failed to override Introspection method",
1354
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1355
"""A D-Bus object with properties.
1357
Classes inheriting from this can use the dbus_service_property
1358
decorator to expose methods as D-Bus properties. It exposes the
1359
standard Get(), Set(), and GetAll() methods on the D-Bus.
1362
899
def _get_dbus_property(self, interface_name, property_name):
1363
900
"""Returns a bound method if one exists which is a D-Bus
1364
901
property with the specified name and interface.
1519
1059
return xmlstring
1523
dbus.OBJECT_MANAGER_IFACE
1524
except AttributeError:
1525
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1528
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1529
"""A D-Bus object with an ObjectManager.
1531
Classes inheriting from this exposes the standard
1532
GetManagedObjects call and the InterfacesAdded and
1533
InterfacesRemoved signals on the standard
1534
"org.freedesktop.DBus.ObjectManager" interface.
1536
Note: No signals are sent automatically; they must be sent
1539
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1540
out_signature="a{oa{sa{sv}}}")
1541
def GetManagedObjects(self):
1542
"""This function must be overridden"""
1543
raise NotImplementedError()
1545
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1546
signature="oa{sa{sv}}")
1547
def InterfacesAdded(self, object_path, interfaces_and_properties):
1550
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1551
def InterfacesRemoved(self, object_path, interfaces):
1554
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1556
path_keyword='object_path',
1557
connection_keyword='connection')
1558
def Introspect(self, object_path, connection):
1559
"""Overloading of standard D-Bus method.
1561
Override return argument name of GetManagedObjects to be
1562
"objpath_interfaces_and_properties"
1564
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1568
document = xml.dom.minidom.parseString(xmlstring)
1570
for if_tag in document.getElementsByTagName("interface"):
1571
# Fix argument name for the GetManagedObjects method
1572
if (if_tag.getAttribute("name")
1573
== dbus.OBJECT_MANAGER_IFACE):
1574
for cn in if_tag.getElementsByTagName("method"):
1575
if (cn.getAttribute("name")
1576
== "GetManagedObjects"):
1577
for arg in cn.getElementsByTagName("arg"):
1578
if (arg.getAttribute("direction")
1582
"objpath_interfaces"
1584
xmlstring = document.toxml("utf-8")
1586
except (AttributeError, xml.dom.DOMException,
1587
xml.parsers.expat.ExpatError) as error:
1588
logger.error("Failed to override Introspection method",
1593
1062
def datetime_to_dbus(dt, variant_level=0):
1594
1063
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1596
return dbus.String("", variant_level=variant_level)
1065
return dbus.String("", variant_level = variant_level)
1597
1066
return dbus.String(dt.isoformat(), variant_level=variant_level)
2381
1830
delay -= time2 - time
2384
session.send(client.secret)
2385
except gnutls.Error as error:
2386
logger.warning("gnutls send failed",
1833
while sent_size < len(client.secret):
1835
sent = session.send(client.secret[sent_size:])
1836
except gnutls.errors.GNUTLSError as error:
1837
logger.warning("gnutls send failed",
1840
logger.debug("Sent: %d, remaining: %d", sent,
1841
len(client.secret) - (sent_size
2390
1845
logger.info("Sending secret to %s", client.name)
2391
1846
# bump the timeout using extended_timeout
2392
1847
client.bump_timeout(client.extended_timeout)
2393
1848
if self.server.use_dbus:
2394
1849
# Emit D-Bus signal
2395
1850
client.GotSecret()
2398
1853
if approval_required:
2399
1854
client.approvals_pending -= 1
2402
except gnutls.Error as error:
1857
except gnutls.errors.GNUTLSError as error:
2403
1858
logger.warning("GnuTLS bye failed",
2404
1859
exc_info=error)
2407
1862
def peer_certificate(session):
2408
"Return the peer's certificate as a bytestring"
2410
cert_type = gnutls.certificate_type_get2(session._c_object,
2412
except AttributeError:
2413
cert_type = gnutls.certificate_type_get(session._c_object)
2414
if gnutls.has_rawpk:
2415
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2417
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2418
# If not a valid certificate type...
2419
if cert_type not in valid_cert_types:
2420
logger.info("Cert type %r not in %r", cert_type,
2422
# ...return invalid data
1863
"Return the peer's OpenPGP certificate as a bytestring"
1864
# If not an OpenPGP certificate...
1865
if (gnutls.library.functions.gnutls_certificate_type_get(
1867
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1868
# ...do the normal thing
1869
return session.peer_certificate
2424
1870
list_size = ctypes.c_uint(1)
2425
cert_list = (gnutls.certificate_get_peers
1871
cert_list = (gnutls.library.functions
1872
.gnutls_certificate_get_peers
2426
1873
(session._c_object, ctypes.byref(list_size)))
2427
1874
if not bool(cert_list) and list_size.value != 0:
2428
raise gnutls.Error("error getting peer certificate")
1875
raise gnutls.errors.GNUTLSError("error getting peer"
2429
1877
if list_size.value == 0:
2431
1879
cert = cert_list[0]
2432
1880
return ctypes.string_at(cert.data, cert.size)
2435
def key_id(certificate):
2436
"Convert a certificate bytestring to a hexdigit key ID"
2437
# New GnuTLS "datum" with the public key
2438
datum = gnutls.datum_t(
2439
ctypes.cast(ctypes.c_char_p(certificate),
2440
ctypes.POINTER(ctypes.c_ubyte)),
2441
ctypes.c_uint(len(certificate)))
2442
# XXX all these need to be created in the gnutls "module"
2443
# New empty GnuTLS certificate
2444
pubkey = gnutls.pubkey_t()
2445
gnutls.pubkey_init(ctypes.byref(pubkey))
2446
# Import the raw public key into the certificate
2447
gnutls.pubkey_import(pubkey,
2448
ctypes.byref(datum),
2449
gnutls.X509_FMT_DER)
2450
# New buffer for the key ID
2451
buf = ctypes.create_string_buffer(32)
2452
buf_len = ctypes.c_size_t(len(buf))
2453
# Get the key ID from the raw public key into the buffer
2454
gnutls.pubkey_get_key_id(pubkey,
2455
gnutls.KEYID_USE_SHA256,
2456
ctypes.cast(ctypes.byref(buf),
2457
ctypes.POINTER(ctypes.c_ubyte)),
2458
ctypes.byref(buf_len))
2459
# Deinit the certificate
2460
gnutls.pubkey_deinit(pubkey)
2462
# Convert the buffer to a Python bytestring
2463
key_id = ctypes.string_at(buf, buf_len.value)
2464
# Convert the bytestring to hexadecimal notation
2465
hex_key_id = binascii.hexlify(key_id).upper()
2469
1883
def fingerprint(openpgp):
2470
1884
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2471
1885
# New GnuTLS "datum" with the OpenPGP public key
2472
datum = gnutls.datum_t(
1886
datum = gnutls.library.types.gnutls_datum_t(
2473
1887
ctypes.cast(ctypes.c_char_p(openpgp),
2474
1888
ctypes.POINTER(ctypes.c_ubyte)),
2475
1889
ctypes.c_uint(len(openpgp)))
2476
1890
# New empty GnuTLS certificate
2477
crt = gnutls.openpgp_crt_t()
2478
gnutls.openpgp_crt_init(ctypes.byref(crt))
1891
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1892
gnutls.library.functions.gnutls_openpgp_crt_init(
2479
1894
# Import the OpenPGP public key into the certificate
2480
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2481
gnutls.OPENPGP_FMT_RAW)
1895
gnutls.library.functions.gnutls_openpgp_crt_import(
1896
crt, ctypes.byref(datum),
1897
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
2482
1898
# Verify the self signature in the key
2483
1899
crtverify = ctypes.c_uint()
2484
gnutls.openpgp_crt_verify_self(crt, 0,
2485
ctypes.byref(crtverify))
1900
gnutls.library.functions.gnutls_openpgp_crt_verify_self(
1901
crt, 0, ctypes.byref(crtverify))
2486
1902
if crtverify.value != 0:
2487
gnutls.openpgp_crt_deinit(crt)
2488
raise gnutls.CertificateSecurityError(code
1903
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1904
raise gnutls.errors.CertificateSecurityError(
2490
1906
# New buffer for the fingerprint
2491
1907
buf = ctypes.create_string_buffer(20)
2492
1908
buf_len = ctypes.c_size_t()
2493
1909
# Get the fingerprint from the certificate into the buffer
2494
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2495
ctypes.byref(buf_len))
1910
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(
1911
crt, ctypes.byref(buf), ctypes.byref(buf_len))
2496
1912
# Deinit the certificate
2497
gnutls.openpgp_crt_deinit(crt)
1913
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2498
1914
# Convert the buffer to a Python bytestring
2499
1915
fpr = ctypes.string_at(buf, buf_len.value)
2500
1916
# Convert the bytestring to hexadecimal notation
2589
2004
# socket_wrapper(), if socketfd was set.
2590
2005
socketserver.TCPServer.__init__(self, server_address,
2591
2006
RequestHandlerClass)
2593
2008
def server_bind(self):
2594
2009
"""This overrides the normal server_bind() function
2595
2010
to bind to an interface if one was specified, and also NOT to
2596
2011
bind to an address or port if they were not specified."""
2597
global SO_BINDTODEVICE
2598
2012
if self.interface is not None:
2599
2013
if SO_BINDTODEVICE is None:
2600
# Fall back to a hard-coded value which seems to be
2602
logger.warning("SO_BINDTODEVICE not found, trying 25")
2603
SO_BINDTODEVICE = 25
2605
self.socket.setsockopt(
2606
socket.SOL_SOCKET, SO_BINDTODEVICE,
2607
(self.interface + "\0").encode("utf-8"))
2608
except socket.error as error:
2609
if error.errno == errno.EPERM:
2610
logger.error("No permission to bind to"
2611
" interface %s", self.interface)
2612
elif error.errno == errno.ENOPROTOOPT:
2613
logger.error("SO_BINDTODEVICE not available;"
2614
" cannot bind to interface %s",
2616
elif error.errno == errno.ENODEV:
2617
logger.error("Interface %s does not exist,"
2618
" cannot bind", self.interface)
2014
logger.error("SO_BINDTODEVICE does not exist;"
2015
" cannot bind to interface %s",
2019
self.socket.setsockopt(
2020
socket.SOL_SOCKET, SO_BINDTODEVICE,
2021
(self.interface + "\0").encode("utf-8"))
2022
except socket.error as error:
2023
if error.errno == errno.EPERM:
2024
logger.error("No permission to bind to"
2025
" interface %s", self.interface)
2026
elif error.errno == errno.ENOPROTOOPT:
2027
logger.error("SO_BINDTODEVICE not available;"
2028
" cannot bind to interface %s",
2030
elif error.errno == errno.ENODEV:
2031
logger.error("Interface %s does not exist,"
2032
" cannot bind", self.interface)
2621
2035
# Only bind(2) the socket if we really need to.
2622
2036
if self.server_address[0] or self.server_address[1]:
2623
if self.server_address[1]:
2624
self.allow_reuse_address = True
2625
2037
if not self.server_address[0]:
2626
2038
if self.address_family == socket.AF_INET6:
2627
any_address = "::" # in6addr_any
2039
any_address = "::" # in6addr_any
2629
any_address = "0.0.0.0" # INADDR_ANY
2041
any_address = "0.0.0.0" # INADDR_ANY
2630
2042
self.server_address = (any_address,
2631
2043
self.server_address[1])
2632
2044
elif not self.server_address[1]:
3193
2589
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3194
2590
service = AvahiServiceToSyslog(
3195
name=server_settings["servicename"],
3196
servicetype="_mandos._tcp",
2591
name = server_settings["servicename"],
2592
servicetype = "_mandos._tcp",
2593
protocol = protocol,
3199
2595
if server_settings["interface"]:
3200
2596
service.interface = if_nametoindex(
3201
2597
server_settings["interface"].encode("utf-8"))
3203
2599
global multiprocessing_manager
3204
2600
multiprocessing_manager = multiprocessing.Manager()
3206
2602
client_class = Client
3208
client_class = functools.partial(ClientDBus, bus=bus)
2604
client_class = functools.partial(ClientDBus, bus = bus)
3210
2606
client_settings = Client.config_parser(client_config)
3211
2607
old_client_settings = {}
3212
2608
clients_data = {}
3214
2610
# This is used to redirect stdout and stderr for checker processes
3216
wnull = open(os.devnull, "w") # A writable /dev/null
2612
wnull = open(os.devnull, "w") # A writable /dev/null
3217
2613
# Only used if server is running in foreground but not in debug
3219
2615
if debug or not foreground:
3222
2618
# Get client data and settings from last running state.
3223
2619
if server_settings["restore"]:
3225
2621
with open(stored_state_path, "rb") as stored_state:
3226
if sys.version_info.major == 2:
3227
clients_data, old_client_settings = pickle.load(
3230
bytes_clients_data, bytes_old_client_settings = (
3231
pickle.load(stored_state, encoding="bytes"))
3232
# Fix bytes to strings
3235
clients_data = {(key.decode("utf-8")
3236
if isinstance(key, bytes)
3239
bytes_clients_data.items()}
3240
del bytes_clients_data
3241
for key in clients_data:
3242
value = {(k.decode("utf-8")
3243
if isinstance(k, bytes) else k): v
3245
clients_data[key].items()}
3246
clients_data[key] = value
3248
value["client_structure"] = [
3250
if isinstance(s, bytes)
3252
value["client_structure"]]
3254
for k in ("name", "host"):
3255
if isinstance(value[k], bytes):
3256
value[k] = value[k].decode("utf-8")
3257
if "key_id" not in value:
3258
value["key_id"] = ""
3259
elif "fingerprint" not in value:
3260
value["fingerprint"] = ""
3261
# old_client_settings
3263
old_client_settings = {
3264
(key.decode("utf-8")
3265
if isinstance(key, bytes)
3268
bytes_old_client_settings.items()}
3269
del bytes_old_client_settings
3271
for value in old_client_settings.values():
3272
if isinstance(value["host"], bytes):
3273
value["host"] = (value["host"]
2622
clients_data, old_client_settings = pickle.load(
3275
2624
os.remove(stored_state_path)
3276
2625
except IOError as e:
3277
2626
if e.errno == errno.ENOENT:
3377
2726
pidfilename, pid)
3379
2728
del pidfilename
3381
for termsig in (signal.SIGHUP, signal.SIGTERM):
3382
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3383
lambda: main_loop.quit() and False)
2730
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2731
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3387
2735
@alternate_dbus_interfaces(
3388
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3389
class MandosDBusService(DBusObjectWithObjectManager):
2736
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
2737
class MandosDBusService(DBusObjectWithProperties):
3390
2738
"""A D-Bus proxy object"""
3392
2740
def __init__(self):
3393
2741
dbus.service.Object.__init__(self, bus, "/")
3395
2743
_interface = "se.recompile.Mandos"
2745
@dbus_interface_annotations(_interface)
2748
"org.freedesktop.DBus.Property.EmitsChangedSignal":
3397
2751
@dbus.service.signal(_interface, signature="o")
3398
2752
def ClientAdded(self, objpath):
3402
2756
@dbus.service.signal(_interface, signature="ss")
3403
def ClientNotFound(self, key_id, address):
2757
def ClientNotFound(self, fingerprint, address):
3407
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3409
2761
@dbus.service.signal(_interface, signature="os")
3410
2762
def ClientRemoved(self, objpath, name):
3414
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3416
2766
@dbus.service.method(_interface, out_signature="ao")
3417
2767
def GetAllClients(self):
3419
2769
return dbus.Array(c.dbus_object_path for c in
3420
tcp_server.clients.values())
3422
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
2770
tcp_server.clients.itervalues())
3424
2772
@dbus.service.method(_interface,
3425
2773
out_signature="a{oa{sv}}")
3426
2774
def GetAllClientsWithProperties(self):
3428
2776
return dbus.Dictionary(
3429
{c.dbus_object_path: c.GetAll(
3430
"se.recompile.Mandos.Client")
3431
for c in tcp_server.clients.values()},
2777
{ c.dbus_object_path: c.GetAll("")
2778
for c in tcp_server.clients.itervalues() },
3432
2779
signature="oa{sv}")
3434
2781
@dbus.service.method(_interface, in_signature="o")
3435
2782
def RemoveClient(self, object_path):
3437
for c in tcp_server.clients.values():
2784
for c in tcp_server.clients.itervalues():
3438
2785
if c.dbus_object_path == object_path:
3439
2786
del tcp_server.clients[c.name]
3440
2787
c.remove_from_connection()
3441
# Don't signal the disabling
2788
# Don't signal anything except ClientRemoved
3442
2789
c.disable(quiet=True)
3443
# Emit D-Bus signal for removal
3444
self.client_removed_signal(c)
2791
self.ClientRemoved(object_path, c.name)
3446
2793
raise KeyError(object_path)
3450
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3451
out_signature="a{oa{sa{sv}}}")
3452
def GetManagedObjects(self):
3454
return dbus.Dictionary(
3455
{client.dbus_object_path:
3457
{interface: client.GetAll(interface)
3459
client._get_all_interface_names()})
3460
for client in tcp_server.clients.values()})
3462
def client_added_signal(self, client):
3463
"""Send the new standard signal and the old signal"""
3465
# New standard signal
3466
self.InterfacesAdded(
3467
client.dbus_object_path,
3469
{interface: client.GetAll(interface)
3471
client._get_all_interface_names()}))
3473
self.ClientAdded(client.dbus_object_path)
3475
def client_removed_signal(self, client):
3476
"""Send the new standard signal and the old signal"""
3478
# New standard signal
3479
self.InterfacesRemoved(
3480
client.dbus_object_path,
3481
client._get_all_interface_names())
3483
self.ClientRemoved(client.dbus_object_path,
3486
2797
mandos_dbus_service = MandosDBusService()
3488
# Save modules to variables to exempt the modules from being
3489
# unloaded before the function registered with atexit() is run.
3490
mp = multiprocessing
3494
2800
"Cleanup function; run on exit"
3496
2802
service.cleanup()
3498
mp.active_children()
2804
multiprocessing.active_children()
3500
2806
if not (tcp_server.clients or client_settings):
3503
2809
# Store client before exiting. Secrets are encrypted with key
3504
2810
# based on what config file has. If config file is
3505
2811
# removed/edited, old secret will thus be unrecovable.
3507
2813
with PGPEngine() as pgp:
3508
for client in tcp_server.clients.values():
2814
for client in tcp_server.clients.itervalues():
3509
2815
key = client_settings[client.name]["secret"]
3510
2816
client.encrypted_secret = pgp.encrypt(client.secret,
3512
2818
client_dict = {}
3514
2820
# A list of attributes that can not be pickled
3516
exclude = {"bus", "changedstate", "secret",
3517
"checker", "server_settings"}
2822
exclude = { "bus", "changedstate", "secret",
2823
"checker", "server_settings" }
3518
2824
for name, typ in inspect.getmembers(dbus.service
3520
2826
exclude.add(name)
3522
2828
client_dict["encrypted_secret"] = (client
3523
2829
.encrypted_secret)
3524
2830
for attr in client.client_structure:
3525
2831
if attr not in exclude:
3526
2832
client_dict[attr] = getattr(client, attr)
3528
2834
clients[client.name] = client_dict
3529
2835
del client_settings[client.name]["secret"]
3532
2838
with tempfile.NamedTemporaryFile(