2
# -*- mode: python; coding: utf-8 -*-
2
# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
4
4
# Mandos server - give out binary blobs to connecting clients.
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
9
# methods "add", "remove", "server_state_changed",
10
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
11
# "AvahiService" class, and some lines in "main".
13
13
# Everything else is
14
# Copyright © 2008-2015 Teddy Hogeborn
15
# Copyright © 2008-2015 Björn Påhlsson
17
# This program is free software: you can redistribute it and/or modify
18
# it under the terms of the GNU General Public License as published by
14
# Copyright © 2008-2019 Teddy Hogeborn
15
# Copyright © 2008-2019 Björn Påhlsson
17
# This file is part of Mandos.
19
# Mandos is free software: you can redistribute it and/or modify it
20
# under the terms of the GNU General Public License as published by
19
21
# the Free Software Foundation, either version 3 of the License, or
20
22
# (at your option) any later version.
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
24
# Mandos is distributed in the hope that it will be useful, but
25
# WITHOUT ANY WARRANTY; without even the implied warranty of
24
26
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25
27
# GNU General Public License for more details.
27
29
# You should have received a copy of the GNU General Public License
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
30
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
31
32
# Contact the authors at <mandos@recompile.se>.
34
35
from __future__ import (division, absolute_import, print_function,
37
from future_builtins import *
39
from future_builtins import *
40
44
import SocketServer as socketserver
190
248
.replace(b"\n", b"\\n")
191
249
.replace(b"\0", b"\\x00"))
194
252
def encrypt(self, data, password):
195
253
passphrase = self.password_encode(password)
196
254
with tempfile.NamedTemporaryFile(
197
255
dir=self.tempdir) as passfile:
198
256
passfile.write(passphrase)
200
proc = subprocess.Popen(['gpg', '--symmetric',
258
proc = subprocess.Popen([self.gpg, '--symmetric',
201
259
'--passphrase-file',
203
261
+ self.gnupgargs,
204
stdin = subprocess.PIPE,
205
stdout = subprocess.PIPE,
206
stderr = subprocess.PIPE)
207
ciphertext, err = proc.communicate(input = data)
262
stdin=subprocess.PIPE,
263
stdout=subprocess.PIPE,
264
stderr=subprocess.PIPE)
265
ciphertext, err = proc.communicate(input=data)
208
266
if proc.returncode != 0:
209
267
raise PGPError(err)
210
268
return ciphertext
212
270
def decrypt(self, data, password):
213
271
passphrase = self.password_encode(password)
214
272
with tempfile.NamedTemporaryFile(
215
dir = self.tempdir) as passfile:
273
dir=self.tempdir) as passfile:
216
274
passfile.write(passphrase)
218
proc = subprocess.Popen(['gpg', '--decrypt',
276
proc = subprocess.Popen([self.gpg, '--decrypt',
219
277
'--passphrase-file',
221
279
+ self.gnupgargs,
222
stdin = subprocess.PIPE,
223
stdout = subprocess.PIPE,
224
stderr = subprocess.PIPE)
225
decrypted_plaintext, err = proc.communicate(input = data)
280
stdin=subprocess.PIPE,
281
stdout=subprocess.PIPE,
282
stderr=subprocess.PIPE)
283
decrypted_plaintext, err = proc.communicate(input=data)
226
284
if proc.returncode != 0:
227
285
raise PGPError(err)
228
286
return decrypted_plaintext
289
# Pretend that we have an Avahi module
291
"""This isn't so much a class as it is a module-like namespace."""
292
IF_UNSPEC = -1 # avahi-common/address.h
293
PROTO_UNSPEC = -1 # avahi-common/address.h
294
PROTO_INET = 0 # avahi-common/address.h
295
PROTO_INET6 = 1 # avahi-common/address.h
296
DBUS_NAME = "org.freedesktop.Avahi"
297
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
298
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
299
DBUS_PATH_SERVER = "/"
302
def string_array_to_txt_array(t):
303
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
304
for s in t), signature="ay")
305
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
306
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
307
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
308
SERVER_INVALID = 0 # avahi-common/defs.h
309
SERVER_REGISTERING = 1 # avahi-common/defs.h
310
SERVER_RUNNING = 2 # avahi-common/defs.h
311
SERVER_COLLISION = 3 # avahi-common/defs.h
312
SERVER_FAILURE = 4 # avahi-common/defs.h
231
315
class AvahiError(Exception):
232
316
def __init__(self, value, *args, **kwargs):
233
317
self.value = value
423
507
class AvahiServiceToSyslog(AvahiService):
424
508
def rename(self, *args, **kwargs):
425
509
"""Add the new name to the syslog messages"""
426
ret = AvahiService.rename(self, *args, **kwargs)
510
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
427
511
syslogger.setFormatter(logging.Formatter(
428
512
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
429
513
.format(self.name)))
432
517
# Pretend that we have a GnuTLS module
433
class GnuTLS(object):
434
"""This isn't so much a class as it is a module-like namespace.
435
It is instantiated once, and simulates having a GnuTLS module."""
437
_library = ctypes.cdll.LoadLibrary(
438
ctypes.util.find_library("gnutls"))
439
_need_version = "3.3.0"
441
# Need to use class name "GnuTLS" here, since this method is
442
# called before the assignment to the "gnutls" global variable
444
if GnuTLS.check_version(self._need_version) is None:
445
raise GnuTLS.Error("Needs GnuTLS {} or later"
446
.format(self._need_version))
519
"""This isn't so much a class as it is a module-like namespace."""
521
library = ctypes.util.find_library("gnutls")
523
library = ctypes.util.find_library("gnutls-deb0")
524
_library = ctypes.cdll.LoadLibrary(library)
448
527
# Unless otherwise indicated, the constants and types below are
449
528
# all from the gnutls/gnutls.h C header file.
456
538
CRD_CERTIFICATE = 1
457
539
E_NO_CERTIFICATE_FOUND = -49
544
KEYID_USE_SHA256 = 1 # gnutls/x509.h
458
545
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
461
548
class session_int(ctypes.Structure):
463
550
session_t = ctypes.POINTER(session_int)
464
552
class certificate_credentials_st(ctypes.Structure):
466
554
certificate_credentials_t = ctypes.POINTER(
467
555
certificate_credentials_st)
468
556
certificate_type_t = ctypes.c_int
469
558
class datum_t(ctypes.Structure):
470
559
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
471
560
('size', ctypes.c_uint)]
472
562
class openpgp_crt_int(ctypes.Structure):
474
564
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
475
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
565
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
476
566
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
477
credentials_type_t = ctypes.c_int #
567
credentials_type_t = ctypes.c_int
478
568
transport_ptr_t = ctypes.c_void_p
479
569
close_request_t = ctypes.c_int
482
572
class Error(Exception):
483
# We need to use the class name "GnuTLS" here, since this
484
# exception might be raised from within GnuTLS.__init__,
485
# which is called before the assignment to the "gnutls"
486
# global variable happens.
487
def __init__(self, message = None, code = None, args=()):
573
def __init__(self, message=None, code=None, args=()):
488
574
# Default usage is by a message string, but if a return
489
575
# code is passed, convert it to a string with
490
576
# gnutls.strerror()
491
578
if message is None and code is not None:
492
message = GnuTLS.strerror(code)
493
return super(GnuTLS.Error, self).__init__(
579
message = gnutls.strerror(code)
580
return super(gnutls.Error, self).__init__(
496
583
class CertificateSecurityError(Error):
500
class Credentials(object):
501
588
def __init__(self):
502
589
self._c_object = gnutls.certificate_credentials_t()
503
590
gnutls.certificate_allocate_credentials(
504
591
ctypes.byref(self._c_object))
505
592
self.type = gnutls.CRD_CERTIFICATE
507
594
def __del__(self):
508
595
gnutls.certificate_free_credentials(self._c_object)
510
class ClientSession(object):
511
def __init__(self, socket, credentials = None):
598
def __init__(self, socket, credentials=None):
512
599
self._c_object = gnutls.session_t()
513
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
600
gnutls_flags = gnutls.CLIENT
601
if gnutls.check_version(b"3.5.6"):
602
gnutls_flags |= gnutls.NO_TICKETS
604
gnutls_flags |= gnutls.ENABLE_RAWPK
605
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
514
607
gnutls.set_default_priority(self._c_object)
515
608
gnutls.transport_set_ptr(self._c_object, socket.fileno())
516
609
gnutls.handshake_set_private_extensions(self._c_object,
522
615
ctypes.cast(credentials._c_object,
523
616
ctypes.c_void_p))
524
617
self.credentials = credentials
526
619
def __del__(self):
527
620
gnutls.deinit(self._c_object)
529
622
def handshake(self):
530
623
return gnutls.handshake(self._c_object)
532
625
def send(self, data):
533
626
data = bytes(data)
536
return gnutls.record_send(self._c_object, data, len(data))
629
data_len -= gnutls.record_send(self._c_object,
539
634
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
541
# Error handling function
636
# Error handling functions
542
637
def _error_code(result):
543
638
"""A function to raise exceptions on errors, suitable
544
639
for the 'restype' attribute on ctypes functions"""
547
642
if result == gnutls.E_NO_CERTIFICATE_FOUND:
548
raise gnutls.CertificateSecurityError(code = result)
549
raise gnutls.Error(code = result)
643
raise gnutls.CertificateSecurityError(code=result)
644
raise gnutls.Error(code=result)
646
def _retry_on_error(result, func, arguments):
647
"""A function to retry on some errors, suitable
648
for the 'errcheck' attribute on ctypes functions"""
650
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
651
return _error_code(result)
652
result = func(*arguments)
551
655
# Unless otherwise indicated, the function declarations below are
552
656
# all from the gnutls/gnutls.h C header file.
555
659
priority_set_direct = _library.gnutls_priority_set_direct
556
660
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
557
661
ctypes.POINTER(ctypes.c_char_p)]
558
662
priority_set_direct.restype = _error_code
560
664
init = _library.gnutls_init
561
665
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
562
666
init.restype = _error_code
564
668
set_default_priority = _library.gnutls_set_default_priority
565
669
set_default_priority.argtypes = [session_t]
566
670
set_default_priority.restype = _error_code
568
672
record_send = _library.gnutls_record_send
569
673
record_send.argtypes = [session_t, ctypes.c_void_p,
571
675
record_send.restype = ctypes.c_ssize_t
676
record_send.errcheck = _retry_on_error
573
678
certificate_allocate_credentials = (
574
679
_library.gnutls_certificate_allocate_credentials)
575
680
certificate_allocate_credentials.argtypes = [
576
681
ctypes.POINTER(certificate_credentials_t)]
577
682
certificate_allocate_credentials.restype = _error_code
579
684
certificate_free_credentials = (
580
685
_library.gnutls_certificate_free_credentials)
581
certificate_free_credentials.argtypes = [certificate_credentials_t]
686
certificate_free_credentials.argtypes = [
687
certificate_credentials_t]
582
688
certificate_free_credentials.restype = None
584
690
handshake_set_private_extensions = (
585
691
_library.gnutls_handshake_set_private_extensions)
586
692
handshake_set_private_extensions.argtypes = [session_t,
588
694
handshake_set_private_extensions.restype = None
590
696
credentials_set = _library.gnutls_credentials_set
591
697
credentials_set.argtypes = [session_t, credentials_type_t,
593
699
credentials_set.restype = _error_code
595
701
strerror = _library.gnutls_strerror
596
702
strerror.argtypes = [ctypes.c_int]
597
703
strerror.restype = ctypes.c_char_p
599
705
certificate_type_get = _library.gnutls_certificate_type_get
600
706
certificate_type_get.argtypes = [session_t]
601
707
certificate_type_get.restype = _error_code
603
709
certificate_get_peers = _library.gnutls_certificate_get_peers
604
710
certificate_get_peers.argtypes = [session_t,
605
711
ctypes.POINTER(ctypes.c_uint)]
606
712
certificate_get_peers.restype = ctypes.POINTER(datum_t)
608
714
global_set_log_level = _library.gnutls_global_set_log_level
609
715
global_set_log_level.argtypes = [ctypes.c_int]
610
716
global_set_log_level.restype = None
612
718
global_set_log_function = _library.gnutls_global_set_log_function
613
719
global_set_log_function.argtypes = [log_func]
614
720
global_set_log_function.restype = None
616
722
deinit = _library.gnutls_deinit
617
723
deinit.argtypes = [session_t]
618
724
deinit.restype = None
620
726
handshake = _library.gnutls_handshake
621
727
handshake.argtypes = [session_t]
622
728
handshake.restype = _error_code
729
handshake.errcheck = _retry_on_error
624
731
transport_set_ptr = _library.gnutls_transport_set_ptr
625
732
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
626
733
transport_set_ptr.restype = None
628
735
bye = _library.gnutls_bye
629
736
bye.argtypes = [session_t, close_request_t]
630
737
bye.restype = _error_code
738
bye.errcheck = _retry_on_error
632
740
check_version = _library.gnutls_check_version
633
741
check_version.argtypes = [ctypes.c_char_p]
634
742
check_version.restype = ctypes.c_char_p
636
# All the function declarations below are from gnutls/openpgp.h
638
openpgp_crt_init = _library.gnutls_openpgp_crt_init
639
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
640
openpgp_crt_init.restype = _error_code
642
openpgp_crt_import = _library.gnutls_openpgp_crt_import
643
openpgp_crt_import.argtypes = [openpgp_crt_t,
644
ctypes.POINTER(datum_t),
646
openpgp_crt_import.restype = _error_code
648
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
649
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
650
ctypes.POINTER(ctypes.c_uint)]
651
openpgp_crt_verify_self.restype = _error_code
653
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
654
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
655
openpgp_crt_deinit.restype = None
657
openpgp_crt_get_fingerprint = (
658
_library.gnutls_openpgp_crt_get_fingerprint)
659
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
663
openpgp_crt_get_fingerprint.restype = _error_code
665
# Remove non-public function
667
# Create the global "gnutls" object, simulating a module
744
_need_version = b"3.3.0"
745
if check_version(_need_version) is None:
746
raise self.Error("Needs GnuTLS {} or later"
747
.format(_need_version))
749
_tls_rawpk_version = b"3.6.6"
750
has_rawpk = bool(check_version(_tls_rawpk_version))
754
class pubkey_st(ctypes.Structure):
756
pubkey_t = ctypes.POINTER(pubkey_st)
758
x509_crt_fmt_t = ctypes.c_int
760
# All the function declarations below are from gnutls/abstract.h
761
pubkey_init = _library.gnutls_pubkey_init
762
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
763
pubkey_init.restype = _error_code
765
pubkey_import = _library.gnutls_pubkey_import
766
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
768
pubkey_import.restype = _error_code
770
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
771
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
772
ctypes.POINTER(ctypes.c_ubyte),
773
ctypes.POINTER(ctypes.c_size_t)]
774
pubkey_get_key_id.restype = _error_code
776
pubkey_deinit = _library.gnutls_pubkey_deinit
777
pubkey_deinit.argtypes = [pubkey_t]
778
pubkey_deinit.restype = None
780
# All the function declarations below are from gnutls/openpgp.h
782
openpgp_crt_init = _library.gnutls_openpgp_crt_init
783
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
784
openpgp_crt_init.restype = _error_code
786
openpgp_crt_import = _library.gnutls_openpgp_crt_import
787
openpgp_crt_import.argtypes = [openpgp_crt_t,
788
ctypes.POINTER(datum_t),
790
openpgp_crt_import.restype = _error_code
792
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
793
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
794
ctypes.POINTER(ctypes.c_uint)]
795
openpgp_crt_verify_self.restype = _error_code
797
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
798
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
799
openpgp_crt_deinit.restype = None
801
openpgp_crt_get_fingerprint = (
802
_library.gnutls_openpgp_crt_get_fingerprint)
803
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
807
openpgp_crt_get_fingerprint.restype = _error_code
809
if check_version(b"3.6.4"):
810
certificate_type_get2 = _library.gnutls_certificate_type_get2
811
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
812
certificate_type_get2.restype = _error_code
814
# Remove non-public functions
815
del _error_code, _retry_on_error
670
818
def call_pipe(connection, # : multiprocessing.Connection
671
819
func, *args, **kwargs):
672
820
"""This function is meant to be called by multiprocessing.Process
674
822
This function runs func(*args, **kwargs), and writes the resulting
675
823
return value on the provided multiprocessing.Connection.
677
825
connection.send(func(*args, **kwargs))
678
826
connection.close()
680
class Client(object):
681
830
"""A representation of a client host served by this server.
684
833
approved: bool(); 'None' if not yet approved/disapproved
685
834
approval_delay: datetime.timedelta(); Time to wait for approval
686
835
approval_duration: datetime.timedelta(); Duration of one approval
687
checker: subprocess.Popen(); a running checker process used
688
to see if the client lives.
689
'None' if no process is running.
690
checker_callback_tag: a gobject event source tag, or None
836
checker: multiprocessing.Process(); a running checker process used
837
to see if the client lives. 'None' if no process is
839
checker_callback_tag: a GLib event source tag, or None
691
840
checker_command: string; External command which is run to check
692
841
if client lives. %() expansions are done at
693
842
runtime with vars(self) as dict, so that for
694
843
instance %(name)s can be used in the command.
695
checker_initiator_tag: a gobject event source tag, or None
844
checker_initiator_tag: a GLib event source tag, or None
696
845
created: datetime.datetime(); (UTC) object creation
697
846
client_structure: Object describing what attributes a client has
698
847
and is used for storing the client at exit
699
848
current_checker_command: string; current running checker_command
700
disable_initiator_tag: a gobject event source tag, or None
849
disable_initiator_tag: a GLib event source tag, or None
702
851
fingerprint: string (40 or 32 hexadecimal digits); used to
703
uniquely identify the client
852
uniquely identify an OpenPGP client
853
key_id: string (64 hexadecimal digits); used to uniquely identify
854
a client using raw public keys
704
855
host: string; available for use by the checker command
705
856
interval: datetime.timedelta(); How often to start a new checker
706
857
last_approval_request: datetime.datetime(); (UTC) or None
858
1014
logger.info("Disabling client %s", self.name)
859
1015
if getattr(self, "disable_initiator_tag", None) is not None:
860
gobject.source_remove(self.disable_initiator_tag)
1016
GLib.source_remove(self.disable_initiator_tag)
861
1017
self.disable_initiator_tag = None
862
1018
self.expires = None
863
1019
if getattr(self, "checker_initiator_tag", None) is not None:
864
gobject.source_remove(self.checker_initiator_tag)
1020
GLib.source_remove(self.checker_initiator_tag)
865
1021
self.checker_initiator_tag = None
866
1022
self.stop_checker()
867
1023
self.enabled = False
869
1025
self.send_changedstate()
870
# Do not run this again if called by a gobject.timeout_add
1026
# Do not run this again if called by a GLib.timeout_add
873
1029
def __del__(self):
876
1032
def init_checker(self):
877
1033
# Schedule a new checker to be started an 'interval' from now,
878
1034
# and every interval from then on.
879
1035
if self.checker_initiator_tag is not None:
880
gobject.source_remove(self.checker_initiator_tag)
881
self.checker_initiator_tag = gobject.timeout_add(
1036
GLib.source_remove(self.checker_initiator_tag)
1037
self.checker_initiator_tag = GLib.timeout_add(
882
1038
int(self.interval.total_seconds() * 1000),
883
1039
self.start_checker)
884
1040
# Schedule a disable() when 'timeout' has passed
885
1041
if self.disable_initiator_tag is not None:
886
gobject.source_remove(self.disable_initiator_tag)
887
self.disable_initiator_tag = gobject.timeout_add(
1042
GLib.source_remove(self.disable_initiator_tag)
1043
self.disable_initiator_tag = GLib.timeout_add(
888
1044
int(self.timeout.total_seconds() * 1000), self.disable)
889
1045
# Also start a new checker *right now*.
890
1046
self.start_checker()
892
1048
def checker_callback(self, source, condition, connection,
894
1050
"""The checker has completed, so take appropriate actions."""
895
self.checker_callback_tag = None
897
1051
# Read return code from connection (see call_pipe)
898
1052
returncode = connection.recv()
899
1053
connection.close()
1054
if self.checker is not None:
1056
self.checker_callback_tag = None
901
1059
if returncode >= 0:
902
1060
self.last_checker_status = returncode
903
1061
self.last_checker_signal = None
2301
class MultiprocessingMixIn(object):
2504
class MultiprocessingMixIn:
2302
2505
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2304
2507
def sub_process_main(self, request, address):
2306
2509
self.finish_request(request, address)
2307
2510
except Exception:
2308
2511
self.handle_error(request, address)
2309
2512
self.close_request(request)
2311
2514
def process_request(self, request, address):
2312
2515
"""Start a new process to process the request."""
2313
proc = multiprocessing.Process(target = self.sub_process_main,
2314
args = (request, address))
2516
proc = multiprocessing.Process(target=self.sub_process_main,
2517
args=(request, address))
2319
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2522
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2320
2523
""" adds a pipe to the MixIn """
2322
2525
def process_request(self, request, client_address):
2323
2526
"""Overrides and wraps the original process_request().
2325
2528
This function creates a new pipe in self.pipe
2327
2530
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2329
2532
proc = MultiprocessingMixIn.process_request(self, request,
2330
2533
client_address)
2331
2534
self.child_pipe.close()
2332
2535
self.add_pipe(parent_pipe, proc)
2334
2537
def add_pipe(self, parent_pipe, proc):
2335
2538
"""Dummy function; override as necessary"""
2336
2539
raise NotImplementedError()
2339
2542
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2340
socketserver.TCPServer, object):
2543
socketserver.TCPServer):
2341
2544
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2344
2547
enabled: Boolean; whether this server is activated yet
2345
2548
interface: None or a network interface name (string)
2346
2549
use_ipv6: Boolean; to use IPv6 or not
2349
2552
def __init__(self, server_address, RequestHandlerClass,
2350
2553
interface=None,
2384
2588
# socket_wrapper(), if socketfd was set.
2385
2589
socketserver.TCPServer.__init__(self, server_address,
2386
2590
RequestHandlerClass)
2388
2592
def server_bind(self):
2389
2593
"""This overrides the normal server_bind() function
2390
2594
to bind to an interface if one was specified, and also NOT to
2391
2595
bind to an address or port if they were not specified."""
2596
global SO_BINDTODEVICE
2392
2597
if self.interface is not None:
2393
2598
if SO_BINDTODEVICE is None:
2394
logger.error("SO_BINDTODEVICE does not exist;"
2395
" cannot bind to interface %s",
2399
self.socket.setsockopt(
2400
socket.SOL_SOCKET, SO_BINDTODEVICE,
2401
(self.interface + "\0").encode("utf-8"))
2402
except socket.error as error:
2403
if error.errno == errno.EPERM:
2404
logger.error("No permission to bind to"
2405
" interface %s", self.interface)
2406
elif error.errno == errno.ENOPROTOOPT:
2407
logger.error("SO_BINDTODEVICE not available;"
2408
" cannot bind to interface %s",
2410
elif error.errno == errno.ENODEV:
2411
logger.error("Interface %s does not exist,"
2412
" cannot bind", self.interface)
2599
# Fall back to a hard-coded value which seems to be
2601
logger.warning("SO_BINDTODEVICE not found, trying 25")
2602
SO_BINDTODEVICE = 25
2604
self.socket.setsockopt(
2605
socket.SOL_SOCKET, SO_BINDTODEVICE,
2606
(self.interface + "\0").encode("utf-8"))
2607
except socket.error as error:
2608
if error.errno == errno.EPERM:
2609
logger.error("No permission to bind to"
2610
" interface %s", self.interface)
2611
elif error.errno == errno.ENOPROTOOPT:
2612
logger.error("SO_BINDTODEVICE not available;"
2613
" cannot bind to interface %s",
2615
elif error.errno == errno.ENODEV:
2616
logger.error("Interface %s does not exist,"
2617
" cannot bind", self.interface)
2415
2620
# Only bind(2) the socket if we really need to.
2416
2621
if self.server_address[0] or self.server_address[1]:
2622
if self.server_address[1]:
2623
self.allow_reuse_address = True
2417
2624
if not self.server_address[0]:
2418
2625
if self.address_family == socket.AF_INET6:
2419
any_address = "::" # in6addr_any
2626
any_address = "::" # in6addr_any
2421
any_address = "0.0.0.0" # INADDR_ANY
2628
any_address = "0.0.0.0" # INADDR_ANY
2422
2629
self.server_address = (any_address,
2423
2630
self.server_address[1])
2424
2631
elif not self.server_address[1]:
2458
2665
self.gnutls_priority = gnutls_priority
2459
2666
IPv6_TCPServer.__init__(self, server_address,
2460
2667
RequestHandlerClass,
2461
interface = interface,
2462
use_ipv6 = use_ipv6,
2463
socketfd = socketfd)
2668
interface=interface,
2465
2672
def server_activate(self):
2466
2673
if self.enabled:
2467
2674
return socketserver.TCPServer.server_activate(self)
2469
2676
def enable(self):
2470
2677
self.enabled = True
2472
2679
def add_pipe(self, parent_pipe, proc):
2473
2680
# Call "handle_ipc" for both data and EOF events
2474
gobject.io_add_watch(
2475
parent_pipe.fileno(),
2476
gobject.IO_IN | gobject.IO_HUP,
2682
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2683
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2477
2684
functools.partial(self.handle_ipc,
2478
parent_pipe = parent_pipe,
2685
parent_pipe=parent_pipe,
2481
2688
def handle_ipc(self, source, condition,
2482
2689
parent_pipe=None,
2484
2691
client_object=None):
2485
2692
# error, or the other end of multiprocessing.Pipe has closed
2486
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2693
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2487
2694
# Wait for other process to exit
2491
2698
# Read a request from the child
2492
2699
request = parent_pipe.recv()
2493
2700
command = request[0]
2495
2702
if command == 'init':
2497
address = request[2]
2499
for c in self.clients.itervalues():
2500
if c.fingerprint == fpr:
2703
key_id = request[1].decode("ascii")
2704
fpr = request[2].decode("ascii")
2705
address = request[3]
2707
for c in self.clients.values():
2708
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2710
if key_id and c.key_id == key_id:
2713
if fpr and c.fingerprint == fpr:
2504
logger.info("Client not found for fingerprint: %s, ad"
2505
"dress: %s", fpr, address)
2717
logger.info("Client not found for key ID: %s, address"
2718
": %s", key_id or fpr, address)
2506
2719
if self.use_dbus:
2507
2720
# Emit D-Bus signal
2508
mandos_dbus_service.ClientNotFound(fpr,
2721
mandos_dbus_service.ClientNotFound(key_id or fpr,
2510
2723
parent_pipe.send(False)
2513
gobject.io_add_watch(
2514
parent_pipe.fileno(),
2515
gobject.IO_IN | gobject.IO_HUP,
2727
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2728
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2516
2729
functools.partial(self.handle_ipc,
2517
parent_pipe = parent_pipe,
2519
client_object = client))
2730
parent_pipe=parent_pipe,
2732
client_object=client))
2520
2733
parent_pipe.send(True)
2521
2734
# remove the old hook in favor of the new above hook on
2539
2752
parent_pipe.send((
2540
2753
'data', client_object.__getattribute__(attrname)))
2542
2755
if command == 'setattr':
2543
2756
attrname = request[1]
2544
2757
value = request[2]
2545
2758
setattr(client_object, attrname, value)
2550
2763
def rfc3339_duration_to_delta(duration):
2551
2764
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2553
>>> rfc3339_duration_to_delta("P7D")
2554
datetime.timedelta(7)
2555
>>> rfc3339_duration_to_delta("PT60S")
2556
datetime.timedelta(0, 60)
2557
>>> rfc3339_duration_to_delta("PT60M")
2558
datetime.timedelta(0, 3600)
2559
>>> rfc3339_duration_to_delta("PT24H")
2560
datetime.timedelta(1)
2561
>>> rfc3339_duration_to_delta("P1W")
2562
datetime.timedelta(7)
2563
>>> rfc3339_duration_to_delta("PT5M30S")
2564
datetime.timedelta(0, 330)
2565
>>> rfc3339_duration_to_delta("P1DT3M20S")
2566
datetime.timedelta(1, 200)
2766
>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
2768
>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
2770
>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
2772
>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
2774
>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
2776
>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
2778
>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
2569
2782
# Parsing an RFC 3339 duration with regular expressions is not
2570
2783
# possible - there would have to be multiple places for the same
2571
2784
# values, like seconds. The current code, while more esoteric, is
2572
2785
# cleaner without depending on a parsing library. If Python had a
2573
2786
# built-in library for parsing we would use it, but we'd like to
2574
2787
# avoid excessive use of external libraries.
2576
2789
# New type for defining tokens, syntax, and semantics all-in-one
2577
2790
Token = collections.namedtuple("Token", (
2578
2791
"regexp", # To match token; if "value" is not None, must have
2968
3192
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2969
3193
service = AvahiServiceToSyslog(
2970
name = server_settings["servicename"],
2971
servicetype = "_mandos._tcp",
2972
protocol = protocol,
3194
name=server_settings["servicename"],
3195
servicetype="_mandos._tcp",
2974
3198
if server_settings["interface"]:
2975
3199
service.interface = if_nametoindex(
2976
3200
server_settings["interface"].encode("utf-8"))
2978
3202
global multiprocessing_manager
2979
3203
multiprocessing_manager = multiprocessing.Manager()
2981
3205
client_class = Client
2983
client_class = functools.partial(ClientDBus, bus = bus)
3207
client_class = functools.partial(ClientDBus, bus=bus)
2985
3209
client_settings = Client.config_parser(client_config)
2986
3210
old_client_settings = {}
2987
3211
clients_data = {}
2989
3213
# This is used to redirect stdout and stderr for checker processes
2991
wnull = open(os.devnull, "w") # A writable /dev/null
3215
wnull = open(os.devnull, "w") # A writable /dev/null
2992
3216
# Only used if server is running in foreground but not in debug
2994
3218
if debug or not foreground:
2997
3221
# Get client data and settings from last running state.
2998
3222
if server_settings["restore"]:
3000
3224
with open(stored_state_path, "rb") as stored_state:
3001
clients_data, old_client_settings = pickle.load(
3225
if sys.version_info.major == 2:
3226
clients_data, old_client_settings = pickle.load(
3229
bytes_clients_data, bytes_old_client_settings = (
3230
pickle.load(stored_state, encoding="bytes"))
3231
# Fix bytes to strings
3234
clients_data = {(key.decode("utf-8")
3235
if isinstance(key, bytes)
3238
bytes_clients_data.items()}
3239
del bytes_clients_data
3240
for key in clients_data:
3241
value = {(k.decode("utf-8")
3242
if isinstance(k, bytes) else k): v
3244
clients_data[key].items()}
3245
clients_data[key] = value
3247
value["client_structure"] = [
3249
if isinstance(s, bytes)
3251
value["client_structure"]]
3252
# .name, .host, and .checker_command
3253
for k in ("name", "host", "checker_command"):
3254
if isinstance(value[k], bytes):
3255
value[k] = value[k].decode("utf-8")
3256
if "key_id" not in value:
3257
value["key_id"] = ""
3258
elif "fingerprint" not in value:
3259
value["fingerprint"] = ""
3260
# old_client_settings
3262
old_client_settings = {
3263
(key.decode("utf-8")
3264
if isinstance(key, bytes)
3267
bytes_old_client_settings.items()}
3268
del bytes_old_client_settings
3269
# .host and .checker_command
3270
for value in old_client_settings.values():
3271
for attribute in ("host", "checker_command"):
3272
if isinstance(value[attribute], bytes):
3273
value[attribute] = (value[attribute]
3003
3275
os.remove(stored_state_path)
3004
3276
except IOError as e:
3005
3277
if e.errno == errno.ENOENT: