To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 348
- compare with another revision
- download diff
- download tarball
- view history from revision 348
- Committer: Teddy Hogeborn
- Date: 2016-06-23 19:49:21 UTC
- mfrom: (237.7.408 trunk)
- Revision ID: teddy@recompile.se-20160623194921-5bgaecm8us764lnb
Merge from trunk
added
removed
mandos
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
#
5
#
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".
12
#
12
#
13
13
# Everything else is
14
14
# Copyright © 2008-2016 Teddy Hogeborn
15
15
# Copyright © 2008-2016 Björn Påhlsson
16
#
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
19
19
# the Free Software Foundation, either version 3 of the License, or
23
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
24
24
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25
25
# GNU General Public License for more details.
26
#
26
#
27
27
# You should have received a copy of the GNU General Public License
28
28
# along with this program. If not, see
29
29
# <http://www.gnu.org/licenses/>.
30
#
30
#
31
31
# Contact the authors at <mandos@recompile.se>.
32
#
32
#
33
33
34
34
from __future__ import (division, absolute_import, print_function,
35
35
unicode_literals)
114
114
if sys.version_info.major == 2:
115
115
str = unicode
116
116
117
version = "1.7.13"
117
version = "1.7.9"
118
118
stored_state_file = "clients.pickle"
119
119
120
120
logger = logging.getLogger()
124
124
if_nametoindex = ctypes.cdll.LoadLibrary(
125
125
ctypes.util.find_library("c")).if_nametoindex
126
126
except (OSError, AttributeError):
127
127
128
128
def if_nametoindex(interface):
129
129
"Get an interface index the hard way, i.e. using fcntl()"
130
130
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
153
153
154
154
def initlogger(debug, level=logging.WARNING):
155
155
"""init logger and add loglevel"""
156
156
157
157
global syslogger
158
158
syslogger = (logging.handlers.SysLogHandler(
159
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
160
address="/dev/log"))
159
facility = logging.handlers.SysLogHandler.LOG_DAEMON,
160
address = "/dev/log"))
161
161
syslogger.setFormatter(logging.Formatter
162
162
('Mandos [%(process)d]: %(levelname)s:'
163
163
' %(message)s'))
164
164
logger.addHandler(syslogger)
165
165
166
166
if debug:
167
167
console = logging.StreamHandler()
168
168
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
180
180
181
181
class PGPEngine(object):
182
182
"""A simple class for OpenPGP symmetric encryption & decryption"""
183
183
184
184
def __init__(self):
185
185
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
186
186
self.gpg = "gpg"
201
201
# Only GPG version 1 has the --no-use-agent option.
202
202
if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
203
203
self.gnupgargs.append("--no-use-agent")
204
204
205
205
def __enter__(self):
206
206
return self
207
207
208
208
def __exit__(self, exc_type, exc_value, traceback):
209
209
self._cleanup()
210
210
return False
211
211
212
212
def __del__(self):
213
213
self._cleanup()
214
214
215
215
def _cleanup(self):
216
216
if self.tempdir is not None:
217
217
# Delete contents of tempdir
218
218
for root, dirs, files in os.walk(self.tempdir,
219
topdown=False):
219
topdown = False):
220
220
for filename in files:
221
221
os.remove(os.path.join(root, filename))
222
222
for dirname in dirs:
224
224
# Remove tempdir
225
225
os.rmdir(self.tempdir)
226
226
self.tempdir = None
227
227
228
228
def password_encode(self, password):
229
229
# Passphrase can not be empty and can not contain newlines or
230
230
# NUL bytes. So we prefix it and hex encode it.
235
235
.replace(b"\n", b"\\n")
236
236
.replace(b"\0", b"\\x00"))
237
237
return encoded
238
238
239
239
def encrypt(self, data, password):
240
240
passphrase = self.password_encode(password)
241
241
with tempfile.NamedTemporaryFile(
246
246
'--passphrase-file',
247
247
passfile.name]
248
248
+ self.gnupgargs,
249
stdin=subprocess.PIPE,
250
stdout=subprocess.PIPE,
251
stderr=subprocess.PIPE)
252
ciphertext, err = proc.communicate(input=data)
249
stdin = subprocess.PIPE,
250
stdout = subprocess.PIPE,
251
stderr = subprocess.PIPE)
252
ciphertext, err = proc.communicate(input = data)
253
253
if proc.returncode != 0:
254
254
raise PGPError(err)
255
255
return ciphertext
256
256
257
257
def decrypt(self, data, password):
258
258
passphrase = self.password_encode(password)
259
259
with tempfile.NamedTemporaryFile(
260
dir=self.tempdir) as passfile:
260
dir = self.tempdir) as passfile:
261
261
passfile.write(passphrase)
262
262
passfile.flush()
263
263
proc = subprocess.Popen([self.gpg, '--decrypt',
264
264
'--passphrase-file',
265
265
passfile.name]
266
266
+ self.gnupgargs,
267
stdin=subprocess.PIPE,
268
stdout=subprocess.PIPE,
269
stderr=subprocess.PIPE)
270
decrypted_plaintext, err = proc.communicate(input=data)
267
stdin = subprocess.PIPE,
268
stdout = subprocess.PIPE,
269
stderr = subprocess.PIPE)
270
decrypted_plaintext, err = proc.communicate(input = data)
271
271
if proc.returncode != 0:
272
272
raise PGPError(err)
273
273
return decrypted_plaintext
274
274
275
276
275
# Pretend that we have an Avahi module
277
276
class Avahi(object):
278
277
"""This isn't so much a class as it is a module-like namespace.
279
278
It is instantiated once, and simulates having an Avahi module."""
280
IF_UNSPEC = -1 # avahi-common/address.h
281
PROTO_UNSPEC = -1 # avahi-common/address.h
282
PROTO_INET = 0 # avahi-common/address.h
283
PROTO_INET6 = 1 # avahi-common/address.h
279
IF_UNSPEC = -1 # avahi-common/address.h
280
PROTO_UNSPEC = -1 # avahi-common/address.h
281
PROTO_INET = 0 # avahi-common/address.h
282
PROTO_INET6 = 1 # avahi-common/address.h
284
283
DBUS_NAME = "org.freedesktop.Avahi"
285
284
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
286
285
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
287
286
DBUS_PATH_SERVER = "/"
288
289
287
def string_array_to_txt_array(self, t):
290
288
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
291
289
for s in t), signature="ay")
292
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
293
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
294
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
295
SERVER_INVALID = 0 # avahi-common/defs.h
296
SERVER_REGISTERING = 1 # avahi-common/defs.h
297
SERVER_RUNNING = 2 # avahi-common/defs.h
298
SERVER_COLLISION = 3 # avahi-common/defs.h
299
SERVER_FAILURE = 4 # avahi-common/defs.h
290
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
291
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
292
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
293
SERVER_INVALID = 0 # avahi-common/defs.h
294
SERVER_REGISTERING = 1 # avahi-common/defs.h
295
SERVER_RUNNING = 2 # avahi-common/defs.h
296
SERVER_COLLISION = 3 # avahi-common/defs.h
297
SERVER_FAILURE = 4 # avahi-common/defs.h
300
298
avahi = Avahi()
301
299
302
303
300
class AvahiError(Exception):
304
301
def __init__(self, value, *args, **kwargs):
305
302
self.value = value
317
314
318
315
class AvahiService(object):
319
316
"""An Avahi (Zeroconf) service.
320
317
321
318
Attributes:
322
319
interface: integer; avahi.IF_UNSPEC or an interface index.
323
320
Used to optionally bind to the specified interface.
335
332
server: D-Bus Server
336
333
bus: dbus.SystemBus()
337
334
"""
338
335
339
336
def __init__(self,
340
interface=avahi.IF_UNSPEC,
341
name=None,
342
servicetype=None,
343
port=None,
344
TXT=None,
345
domain="",
346
host="",
347
max_renames=32768,
348
protocol=avahi.PROTO_UNSPEC,
349
bus=None):
337
interface = avahi.IF_UNSPEC,
338
name = None,
339
servicetype = None,
340
port = None,
341
TXT = None,
342
domain = "",
343
host = "",
344
max_renames = 32768,
345
protocol = avahi.PROTO_UNSPEC,
346
bus = None):
350
347
self.interface = interface
351
348
self.name = name
352
349
self.type = servicetype
361
358
self.server = None
362
359
self.bus = bus
363
360
self.entry_group_state_changed_match = None
364
361
365
362
def rename(self, remove=True):
366
363
"""Derived from the Avahi example code"""
367
364
if self.rename_count >= self.max_renames:
387
384
logger.critical("D-Bus Exception", exc_info=error)
388
385
self.cleanup()
389
386
os._exit(1)
390
387
391
388
def remove(self):
392
389
"""Derived from the Avahi example code"""
393
390
if self.entry_group_state_changed_match is not None:
395
392
self.entry_group_state_changed_match = None
396
393
if self.group is not None:
397
394
self.group.Reset()
398
395
399
396
def add(self):
400
397
"""Derived from the Avahi example code"""
401
398
self.remove()
418
415
dbus.UInt16(self.port),
419
416
avahi.string_array_to_txt_array(self.TXT))
420
417
self.group.Commit()
421
418
422
419
def entry_group_state_changed(self, state, error):
423
420
"""Derived from the Avahi example code"""
424
421
logger.debug("Avahi entry group state change: %i", state)
425
422
426
423
if state == avahi.ENTRY_GROUP_ESTABLISHED:
427
424
logger.debug("Zeroconf service established.")
428
425
elif state == avahi.ENTRY_GROUP_COLLISION:
432
429
logger.critical("Avahi: Error in group state changed %s",
433
430
str(error))
434
431
raise AvahiGroupError("State changed: {!s}".format(error))
435
432
436
433
def cleanup(self):
437
434
"""Derived from the Avahi example code"""
438
435
if self.group is not None:
443
440
pass
444
441
self.group = None
445
442
self.remove()
446
443
447
444
def server_state_changed(self, state, error=None):
448
445
"""Derived from the Avahi example code"""
449
446
logger.debug("Avahi server state change: %i", state)
478
475
logger.debug("Unknown state: %r", state)
479
476
else:
480
477
logger.debug("Unknown state: %r: %r", state, error)
481
478
482
479
def activate(self):
483
480
"""Derived from the Avahi example code"""
484
481
if self.server is None:
501
498
.format(self.name)))
502
499
return ret
503
500
504
505
501
# Pretend that we have a GnuTLS module
506
502
class GnuTLS(object):
507
503
"""This isn't so much a class as it is a module-like namespace.
508
504
It is instantiated once, and simulates having a GnuTLS module."""
509
510
library = ctypes.util.find_library("gnutls")
511
if library is None:
512
library = ctypes.util.find_library("gnutls-deb0")
513
_library = ctypes.cdll.LoadLibrary(library)
514
del library
505
506
_library = ctypes.cdll.LoadLibrary(
507
ctypes.util.find_library("gnutls"))
515
508
_need_version = b"3.3.0"
516
517
509
def __init__(self):
518
510
# Need to use class name "GnuTLS" here, since this method is
519
511
# called before the assignment to the "gnutls" global variable
521
513
if GnuTLS.check_version(self._need_version) is None:
522
514
raise GnuTLS.Error("Needs GnuTLS {} or later"
523
515
.format(self._need_version))
524
516
525
517
# Unless otherwise indicated, the constants and types below are
526
518
# all from the gnutls/gnutls.h C header file.
527
519
528
520
# Constants
529
521
E_SUCCESS = 0
530
522
E_INTERRUPTED = -52
535
527
CRD_CERTIFICATE = 1
536
528
E_NO_CERTIFICATE_FOUND = -49
537
529
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
538
530
539
531
# Types
540
532
class session_int(ctypes.Structure):
541
533
_fields_ = []
542
534
session_t = ctypes.POINTER(session_int)
543
544
535
class certificate_credentials_st(ctypes.Structure):
545
536
_fields_ = []
546
537
certificate_credentials_t = ctypes.POINTER(
547
538
certificate_credentials_st)
548
539
certificate_type_t = ctypes.c_int
549
550
540
class datum_t(ctypes.Structure):
551
541
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
552
542
('size', ctypes.c_uint)]
553
554
543
class openpgp_crt_int(ctypes.Structure):
555
544
_fields_ = []
556
545
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
557
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
546
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
558
547
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
559
548
credentials_type_t = ctypes.c_int
560
549
transport_ptr_t = ctypes.c_void_p
561
550
close_request_t = ctypes.c_int
562
551
563
552
# Exceptions
564
553
class Error(Exception):
565
554
# We need to use the class name "GnuTLS" here, since this
566
555
# exception might be raised from within GnuTLS.__init__,
567
556
# which is called before the assignment to the "gnutls"
568
557
# global variable has happened.
569
def __init__(self, message=None, code=None, args=()):
558
def __init__(self, message = None, code = None, args=()):
570
559
# Default usage is by a message string, but if a return
571
560
# code is passed, convert it to a string with
572
561
# gnutls.strerror()
575
564
message = GnuTLS.strerror(code)
576
565
return super(GnuTLS.Error, self).__init__(
577
566
message, *args)
578
567
579
568
class CertificateSecurityError(Error):
580
569
pass
581
570
582
571
# Classes
583
572
class Credentials(object):
584
573
def __init__(self):
586
575
gnutls.certificate_allocate_credentials(
587
576
ctypes.byref(self._c_object))
588
577
self.type = gnutls.CRD_CERTIFICATE
589
578
590
579
def __del__(self):
591
580
gnutls.certificate_free_credentials(self._c_object)
592
581
593
582
class ClientSession(object):
594
def __init__(self, socket, credentials=None):
583
def __init__(self, socket, credentials = None):
595
584
self._c_object = gnutls.session_t()
596
585
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
597
586
gnutls.set_default_priority(self._c_object)
605
594
ctypes.cast(credentials._c_object,
606
595
ctypes.c_void_p))
607
596
self.credentials = credentials
608
597
609
598
def __del__(self):
610
599
gnutls.deinit(self._c_object)
611
600
612
601
def handshake(self):
613
602
return gnutls.handshake(self._c_object)
614
603
615
604
def send(self, data):
616
605
data = bytes(data)
617
606
data_len = len(data)
619
608
data_len -= gnutls.record_send(self._c_object,
620
609
data[-data_len:],
621
610
data_len)
622
611
623
612
def bye(self):
624
613
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
625
614
626
615
# Error handling functions
627
616
def _error_code(result):
628
617
"""A function to raise exceptions on errors, suitable
630
619
if result >= 0:
631
620
return result
632
621
if result == gnutls.E_NO_CERTIFICATE_FOUND:
633
raise gnutls.CertificateSecurityError(code=result)
634
raise gnutls.Error(code=result)
635
622
raise gnutls.CertificateSecurityError(code = result)
623
raise gnutls.Error(code = result)
624
636
625
def _retry_on_error(result, func, arguments):
637
626
"""A function to retry on some errors, suitable
638
627
for the 'errcheck' attribute on ctypes functions"""
641
630
return _error_code(result)
642
631
result = func(*arguments)
643
632
return result
644
633
645
634
# Unless otherwise indicated, the function declarations below are
646
635
# all from the gnutls/gnutls.h C header file.
647
636
648
637
# Functions
649
638
priority_set_direct = _library.gnutls_priority_set_direct
650
639
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
651
640
ctypes.POINTER(ctypes.c_char_p)]
652
641
priority_set_direct.restype = _error_code
653
642
654
643
init = _library.gnutls_init
655
644
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
656
645
init.restype = _error_code
657
646
658
647
set_default_priority = _library.gnutls_set_default_priority
659
648
set_default_priority.argtypes = [session_t]
660
649
set_default_priority.restype = _error_code
661
650
662
651
record_send = _library.gnutls_record_send
663
652
record_send.argtypes = [session_t, ctypes.c_void_p,
664
653
ctypes.c_size_t]
665
654
record_send.restype = ctypes.c_ssize_t
666
655
record_send.errcheck = _retry_on_error
667
656
668
657
certificate_allocate_credentials = (
669
658
_library.gnutls_certificate_allocate_credentials)
670
659
certificate_allocate_credentials.argtypes = [
671
660
ctypes.POINTER(certificate_credentials_t)]
672
661
certificate_allocate_credentials.restype = _error_code
673
662
674
663
certificate_free_credentials = (
675
664
_library.gnutls_certificate_free_credentials)
676
certificate_free_credentials.argtypes = [
677
certificate_credentials_t]
665
certificate_free_credentials.argtypes = [certificate_credentials_t]
678
666
certificate_free_credentials.restype = None
679
667
680
668
handshake_set_private_extensions = (
681
669
_library.gnutls_handshake_set_private_extensions)
682
670
handshake_set_private_extensions.argtypes = [session_t,
683
671
ctypes.c_int]
684
672
handshake_set_private_extensions.restype = None
685
673
686
674
credentials_set = _library.gnutls_credentials_set
687
675
credentials_set.argtypes = [session_t, credentials_type_t,
688
676
ctypes.c_void_p]
689
677
credentials_set.restype = _error_code
690
678
691
679
strerror = _library.gnutls_strerror
692
680
strerror.argtypes = [ctypes.c_int]
693
681
strerror.restype = ctypes.c_char_p
694
682
695
683
certificate_type_get = _library.gnutls_certificate_type_get
696
684
certificate_type_get.argtypes = [session_t]
697
685
certificate_type_get.restype = _error_code
698
686
699
687
certificate_get_peers = _library.gnutls_certificate_get_peers
700
688
certificate_get_peers.argtypes = [session_t,
701
689
ctypes.POINTER(ctypes.c_uint)]
702
690
certificate_get_peers.restype = ctypes.POINTER(datum_t)
703
691
704
692
global_set_log_level = _library.gnutls_global_set_log_level
705
693
global_set_log_level.argtypes = [ctypes.c_int]
706
694
global_set_log_level.restype = None
707
695
708
696
global_set_log_function = _library.gnutls_global_set_log_function
709
697
global_set_log_function.argtypes = [log_func]
710
698
global_set_log_function.restype = None
711
699
712
700
deinit = _library.gnutls_deinit
713
701
deinit.argtypes = [session_t]
714
702
deinit.restype = None
715
703
716
704
handshake = _library.gnutls_handshake
717
705
handshake.argtypes = [session_t]
718
706
handshake.restype = _error_code
719
707
handshake.errcheck = _retry_on_error
720
708
721
709
transport_set_ptr = _library.gnutls_transport_set_ptr
722
710
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
723
711
transport_set_ptr.restype = None
724
712
725
713
bye = _library.gnutls_bye
726
714
bye.argtypes = [session_t, close_request_t]
727
715
bye.restype = _error_code
728
716
bye.errcheck = _retry_on_error
729
717
730
718
check_version = _library.gnutls_check_version
731
719
check_version.argtypes = [ctypes.c_char_p]
732
720
check_version.restype = ctypes.c_char_p
733
721
734
722
# All the function declarations below are from gnutls/openpgp.h
735
723
736
724
openpgp_crt_init = _library.gnutls_openpgp_crt_init
737
725
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
738
726
openpgp_crt_init.restype = _error_code
739
727
740
728
openpgp_crt_import = _library.gnutls_openpgp_crt_import
741
729
openpgp_crt_import.argtypes = [openpgp_crt_t,
742
730
ctypes.POINTER(datum_t),
743
731
openpgp_crt_fmt_t]
744
732
openpgp_crt_import.restype = _error_code
745
733
746
734
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
747
735
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
748
736
ctypes.POINTER(ctypes.c_uint)]
749
737
openpgp_crt_verify_self.restype = _error_code
750
738
751
739
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
752
740
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
753
741
openpgp_crt_deinit.restype = None
754
742
755
743
openpgp_crt_get_fingerprint = (
756
744
_library.gnutls_openpgp_crt_get_fingerprint)
757
745
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
759
747
ctypes.POINTER(
760
748
ctypes.c_size_t)]
761
749
openpgp_crt_get_fingerprint.restype = _error_code
762
750
763
751
# Remove non-public functions
764
752
del _error_code, _retry_on_error
765
753
# Create the global "gnutls" object, simulating a module
766
754
gnutls = GnuTLS()
767
755
768
769
756
def call_pipe(connection, # : multiprocessing.Connection
770
757
func, *args, **kwargs):
771
758
"""This function is meant to be called by multiprocessing.Process
772
759
773
760
This function runs func(*args, **kwargs), and writes the resulting
774
761
return value on the provided multiprocessing.Connection.
775
762
"""
776
763
connection.send(func(*args, **kwargs))
777
764
connection.close()
778
765
779
780
766
class Client(object):
781
767
"""A representation of a client host served by this server.
782
768
783
769
Attributes:
784
770
approved: bool(); 'None' if not yet approved/disapproved
785
771
approval_delay: datetime.timedelta(); Time to wait for approval
822
808
disabled, or None
823
809
server_settings: The server_settings dict from main()
824
810
"""
825
811
826
812
runtime_expansions = ("approval_delay", "approval_duration",
827
813
"created", "enabled", "expires",
828
814
"fingerprint", "host", "interval",
839
825
"approved_by_default": "True",
840
826
"enabled": "True",
841
827
}
842
828
843
829
@staticmethod
844
830
def config_parser(config):
845
831
"""Construct a new dict of client settings of this form:
852
838
for client_name in config.sections():
853
839
section = dict(config.items(client_name))
854
840
client = settings[client_name] = {}
855
841
856
842
client["host"] = section["host"]
857
843
# Reformat values from string types to Python types
858
844
client["approved_by_default"] = config.getboolean(
859
845
client_name, "approved_by_default")
860
846
client["enabled"] = config.getboolean(client_name,
861
847
"enabled")
862
848
863
849
# Uppercase and remove spaces from fingerprint for later
864
850
# comparison purposes with return value from the
865
851
# fingerprint() function
889
875
client["last_approval_request"] = None
890
876
client["last_checked_ok"] = None
891
877
client["last_checker_status"] = -2
892
878
893
879
return settings
894
895
def __init__(self, settings, name=None, server_settings=None):
880
881
def __init__(self, settings, name = None, server_settings=None):
896
882
self.name = name
897
883
if server_settings is None:
898
884
server_settings = {}
900
886
# adding all client settings
901
887
for setting, value in settings.items():
902
888
setattr(self, setting, value)
903
889
904
890
if self.enabled:
905
891
if not hasattr(self, "last_enabled"):
906
892
self.last_enabled = datetime.datetime.utcnow()
910
896
else:
911
897
self.last_enabled = None
912
898
self.expires = None
913
899
914
900
logger.debug("Creating client %r", self.name)
915
901
logger.debug(" Fingerprint: %s", self.fingerprint)
916
902
self.created = settings.get("created",
917
903
datetime.datetime.utcnow())
918
904
919
905
# attributes specific for this server instance
920
906
self.checker = None
921
907
self.checker_initiator_tag = None
930
916
for attr in self.__dict__.keys()
931
917
if not attr.startswith("_")]
932
918
self.client_structure.append("client_structure")
933
919
934
920
for name, t in inspect.getmembers(
935
921
type(self), lambda obj: isinstance(obj, property)):
936
922
if not name.startswith("_"):
937
923
self.client_structure.append(name)
938
924
939
925
# Send notice to process children that client state has changed
940
926
def send_changedstate(self):
941
927
with self.changedstate:
942
928
self.changedstate.notify_all()
943
929
944
930
def enable(self):
945
931
"""Start this client's checker and timeout hooks"""
946
932
if getattr(self, "enabled", False):
951
937
self.last_enabled = datetime.datetime.utcnow()
952
938
self.init_checker()
953
939
self.send_changedstate()
954
940
955
941
def disable(self, quiet=True):
956
942
"""Disable this client."""
957
943
if not getattr(self, "enabled", False):
971
957
self.send_changedstate()
972
958
# Do not run this again if called by a GLib.timeout_add
973
959
return False
974
960
975
961
def __del__(self):
976
962
self.disable()
977
963
978
964
def init_checker(self):
979
965
# Schedule a new checker to be started an 'interval' from now,
980
966
# and every interval from then on.
990
976
int(self.timeout.total_seconds() * 1000), self.disable)
991
977
# Also start a new checker *right now*.
992
978
self.start_checker()
993
979
994
980
def checker_callback(self, source, condition, connection,
995
981
command):
996
982
"""The checker has completed, so take appropriate actions."""
999
985
# Read return code from connection (see call_pipe)
1000
986
returncode = connection.recv()
1001
987
connection.close()
1002
988
1003
989
if returncode >= 0:
1004
990
self.last_checker_status = returncode
1005
991
self.last_checker_signal = None
1015
1001
logger.warning("Checker for %(name)s crashed?",
1016
1002
vars(self))
1017
1003
return False
1018
1004
1019
1005
def checked_ok(self):
1020
1006
"""Assert that the client has been seen, alive and well."""
1021
1007
self.last_checked_ok = datetime.datetime.utcnow()
1022
1008
self.last_checker_status = 0
1023
1009
self.last_checker_signal = None
1024
1010
self.bump_timeout()
1025
1011
1026
1012
def bump_timeout(self, timeout=None):
1027
1013
"""Bump up the timeout for this client."""
1028
1014
if timeout is None:
1034
1020
self.disable_initiator_tag = GLib.timeout_add(
1035
1021
int(timeout.total_seconds() * 1000), self.disable)
1036
1022
self.expires = datetime.datetime.utcnow() + timeout
1037
1023
1038
1024
def need_approval(self):
1039
1025
self.last_approval_request = datetime.datetime.utcnow()
1040
1026
1041
1027
def start_checker(self):
1042
1028
"""Start a new checker subprocess if one is not running.
1043
1029
1044
1030
If a checker already exists, leave it running and do
1045
1031
nothing."""
1046
1032
# The reason for not killing a running checker is that if we
1051
1037
# checkers alone, the checker would have to take more time
1052
1038
# than 'timeout' for the client to be disabled, which is as it
1053
1039
# should be.
1054
1040
1055
1041
if self.checker is not None and not self.checker.is_alive():
1056
1042
logger.warning("Checker was not alive; joining")
1057
1043
self.checker.join()
1061
1047
# Escape attributes for the shell
1062
1048
escaped_attrs = {
1063
1049
attr: re.escape(str(getattr(self, attr)))
1064
for attr in self.runtime_expansions}
1050
for attr in self.runtime_expansions }
1065
1051
try:
1066
1052
command = self.checker_command % escaped_attrs
1067
1053
except TypeError as error:
1079
1065
# The exception is when not debugging but nevertheless
1080
1066
# running in the foreground; use the previously
1081
1067
# created wnull.
1082
popen_args = {"close_fds": True,
1083
"shell": True,
1084
"cwd": "/"}
1068
popen_args = { "close_fds": True,
1069
"shell": True,
1070
"cwd": "/" }
1085
1071
if (not self.server_settings["debug"]
1086
1072
and self.server_settings["foreground"]):
1087
1073
popen_args.update({"stdout": wnull,
1088
"stderr": wnull})
1089
pipe = multiprocessing.Pipe(duplex=False)
1074
"stderr": wnull })
1075
pipe = multiprocessing.Pipe(duplex = False)
1090
1076
self.checker = multiprocessing.Process(
1091
target=call_pipe,
1092
args=(pipe[1], subprocess.call, command),
1093
kwargs=popen_args)
1077
target = call_pipe,
1078
args = (pipe[1], subprocess.call, command),
1079
kwargs = popen_args)
1094
1080
self.checker.start()
1095
1081
self.checker_callback_tag = GLib.io_add_watch(
1096
1082
pipe[0].fileno(), GLib.IO_IN,
1097
1083
self.checker_callback, pipe[0], command)
1098
1084
# Re-run this periodically if run by GLib.timeout_add
1099
1085
return True
1100
1086
1101
1087
def stop_checker(self):
1102
1088
"""Force the checker process, if any, to stop."""
1103
1089
if self.checker_callback_tag:
1116
1102
byte_arrays=False):
1117
1103
"""Decorators for marking methods of a DBusObjectWithProperties to
1118
1104
become properties on the D-Bus.
1119
1105
1120
1106
The decorated method will be called with no arguments by "Get"
1121
1107
and with one argument by "Set".
1122
1108
1123
1109
The parameters, where they are supported, are the same as
1124
1110
dbus.service.method, except there is only "signature", since the
1125
1111
type from Get() and the type sent to Set() is the same.
1129
1115
if byte_arrays and signature != "ay":
1130
1116
raise ValueError("Byte arrays not supported for non-'ay'"
1131
1117
" signature {!r}".format(signature))
1132
1118
1133
1119
def decorator(func):
1134
1120
func._dbus_is_property = True
1135
1121
func._dbus_interface = dbus_interface
1138
1124
func._dbus_name = func.__name__
1139
1125
if func._dbus_name.endswith("_dbus_property"):
1140
1126
func._dbus_name = func._dbus_name[:-14]
1141
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1127
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1142
1128
return func
1143
1129
1144
1130
return decorator
1145
1131
1146
1132
1147
1133
def dbus_interface_annotations(dbus_interface):
1148
1134
"""Decorator for marking functions returning interface annotations
1149
1135
1150
1136
Usage:
1151
1137
1152
1138
@dbus_interface_annotations("org.example.Interface")
1153
1139
def _foo(self): # Function name does not matter
1154
1140
return {"org.freedesktop.DBus.Deprecated": "true",
1155
1141
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1156
1142
"false"}
1157
1143
"""
1158
1144
1159
1145
def decorator(func):
1160
1146
func._dbus_is_interface = True
1161
1147
func._dbus_interface = dbus_interface
1162
1148
func._dbus_name = dbus_interface
1163
1149
return func
1164
1150
1165
1151
return decorator
1166
1152
1167
1153
1168
1154
def dbus_annotations(annotations):
1169
1155
"""Decorator to annotate D-Bus methods, signals or properties
1170
1156
Usage:
1171
1157
1172
1158
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1173
1159
"org.freedesktop.DBus.Property."
1174
1160
"EmitsChangedSignal": "false"})
1176
1162
access="r")
1177
1163
def Property_dbus_property(self):
1178
1164
return dbus.Boolean(False)
1179
1165
1180
1166
See also the DBusObjectWithAnnotations class.
1181
1167
"""
1182
1168
1183
1169
def decorator(func):
1184
1170
func._dbus_annotations = annotations
1185
1171
return func
1186
1172
1187
1173
return decorator
1188
1174
1189
1175
1207
1193
1208
1194
class DBusObjectWithAnnotations(dbus.service.Object):
1209
1195
"""A D-Bus object with annotations.
1210
1196
1211
1197
Classes inheriting from this can use the dbus_annotations
1212
1198
decorator to add annotations to methods or signals.
1213
1199
"""
1214
1200
1215
1201
@staticmethod
1216
1202
def _is_dbus_thing(thing):
1217
1203
"""Returns a function testing if an attribute is a D-Bus thing
1218
1204
1219
1205
If called like _is_dbus_thing("method") it returns a function
1220
1206
suitable for use as predicate to inspect.getmembers().
1221
1207
"""
1222
1208
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1223
1209
False)
1224
1210
1225
1211
def _get_all_dbus_things(self, thing):
1226
1212
"""Returns a generator of (name, attribute) pairs
1227
1213
"""
1230
1216
for cls in self.__class__.__mro__
1231
1217
for name, athing in
1232
1218
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1233
1219
1234
1220
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1235
out_signature="s",
1236
path_keyword='object_path',
1237
connection_keyword='connection')
1221
out_signature = "s",
1222
path_keyword = 'object_path',
1223
connection_keyword = 'connection')
1238
1224
def Introspect(self, object_path, connection):
1239
1225
"""Overloading of standard D-Bus method.
1240
1226
1241
1227
Inserts annotation tags on methods and signals.
1242
1228
"""
1243
1229
xmlstring = dbus.service.Object.Introspect(self, object_path,
1244
1230
connection)
1245
1231
try:
1246
1232
document = xml.dom.minidom.parseString(xmlstring)
1247
1233
1248
1234
for if_tag in document.getElementsByTagName("interface"):
1249
1235
# Add annotation tags
1250
1236
for typ in ("method", "signal"):
1277
1263
if_tag.appendChild(ann_tag)
1278
1264
# Fix argument name for the Introspect method itself
1279
1265
if (if_tag.getAttribute("name")
1280
== dbus.INTROSPECTABLE_IFACE):
1266
== dbus.INTROSPECTABLE_IFACE):
1281
1267
for cn in if_tag.getElementsByTagName("method"):
1282
1268
if cn.getAttribute("name") == "Introspect":
1283
1269
for arg in cn.getElementsByTagName("arg"):
1296
1282
1297
1283
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1298
1284
"""A D-Bus object with properties.
1299
1285
1300
1286
Classes inheriting from this can use the dbus_service_property
1301
1287
decorator to expose methods as D-Bus properties. It exposes the
1302
1288
standard Get(), Set(), and GetAll() methods on the D-Bus.
1303
1289
"""
1304
1290
1305
1291
def _get_dbus_property(self, interface_name, property_name):
1306
1292
"""Returns a bound method if one exists which is a D-Bus
1307
1293
property with the specified name and interface.
1312
1298
if (value._dbus_name == property_name
1313
1299
and value._dbus_interface == interface_name):
1314
1300
return value.__get__(self)
1315
1301
1316
1302
# No such property
1317
1303
raise DBusPropertyNotFound("{}:{}.{}".format(
1318
1304
self.dbus_object_path, interface_name, property_name))
1319
1305
1320
1306
@classmethod
1321
1307
def _get_all_interface_names(cls):
1322
1308
"""Get a sequence of all interfaces supported by an object"""
1325
1311
for x in (inspect.getmro(cls))
1326
1312
for attr in dir(x))
1327
1313
if name is not None)
1328
1314
1329
1315
@dbus.service.method(dbus.PROPERTIES_IFACE,
1330
1316
in_signature="ss",
1331
1317
out_signature="v")
1339
1325
if not hasattr(value, "variant_level"):
1340
1326
return value
1341
1327
return type(value)(value, variant_level=value.variant_level+1)
1342
1328
1343
1329
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
1344
1330
def Set(self, interface_name, property_name, value):
1345
1331
"""Standard D-Bus property Set() method, see D-Bus standard.
1357
1343
value = dbus.ByteArray(b''.join(chr(byte)
1358
1344
for byte in value))
1359
1345
prop(value)
1360
1346
1361
1347
@dbus.service.method(dbus.PROPERTIES_IFACE,
1362
1348
in_signature="s",
1363
1349
out_signature="a{sv}")
1364
1350
def GetAll(self, interface_name):
1365
1351
"""Standard D-Bus property GetAll() method, see D-Bus
1366
1352
standard.
1367
1353
1368
1354
Note: Will not include properties with access="write".
1369
1355
"""
1370
1356
properties = {}
1381
1367
properties[name] = value
1382
1368
continue
1383
1369
properties[name] = type(value)(
1384
value, variant_level=value.variant_level + 1)
1370
value, variant_level = value.variant_level + 1)
1385
1371
return dbus.Dictionary(properties, signature="sv")
1386
1372
1387
1373
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1388
1374
def PropertiesChanged(self, interface_name, changed_properties,
1389
1375
invalidated_properties):
1391
1377
standard.
1392
1378
"""
1393
1379
pass
1394
1380
1395
1381
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1396
1382
out_signature="s",
1397
1383
path_keyword='object_path',
1398
1384
connection_keyword='connection')
1399
1385
def Introspect(self, object_path, connection):
1400
1386
"""Overloading of standard D-Bus method.
1401
1387
1402
1388
Inserts property tags and interface annotation tags.
1403
1389
"""
1404
1390
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1406
1392
connection)
1407
1393
try:
1408
1394
document = xml.dom.minidom.parseString(xmlstring)
1409
1395
1410
1396
def make_tag(document, name, prop):
1411
1397
e = document.createElement("property")
1412
1398
e.setAttribute("name", name)
1413
1399
e.setAttribute("type", prop._dbus_signature)
1414
1400
e.setAttribute("access", prop._dbus_access)
1415
1401
return e
1416
1402
1417
1403
for if_tag in document.getElementsByTagName("interface"):
1418
1404
# Add property tags
1419
1405
for tag in (make_tag(document, name, prop)
1466
1452
except AttributeError:
1467
1453
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1468
1454
1469
1470
1455
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1471
1456
"""A D-Bus object with an ObjectManager.
1472
1457
1473
1458
Classes inheriting from this exposes the standard
1474
1459
GetManagedObjects call and the InterfacesAdded and
1475
1460
InterfacesRemoved signals on the standard
1476
1461
"org.freedesktop.DBus.ObjectManager" interface.
1477
1462
1478
1463
Note: No signals are sent automatically; they must be sent
1479
1464
manually.
1480
1465
"""
1481
1466
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1482
out_signature="a{oa{sa{sv}}}")
1467
out_signature = "a{oa{sa{sv}}}")
1483
1468
def GetManagedObjects(self):
1484
1469
"""This function must be overridden"""
1485
1470
raise NotImplementedError()
1486
1471
1487
1472
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1488
signature="oa{sa{sv}}")
1473
signature = "oa{sa{sv}}")
1489
1474
def InterfacesAdded(self, object_path, interfaces_and_properties):
1490
1475
pass
1491
1492
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1476
1477
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1493
1478
def InterfacesRemoved(self, object_path, interfaces):
1494
1479
pass
1495
1480
1496
1481
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1497
out_signature="s",
1498
path_keyword='object_path',
1499
connection_keyword='connection')
1482
out_signature = "s",
1483
path_keyword = 'object_path',
1484
connection_keyword = 'connection')
1500
1485
def Introspect(self, object_path, connection):
1501
1486
"""Overloading of standard D-Bus method.
1502
1487
1503
1488
Override return argument name of GetManagedObjects to be
1504
1489
"objpath_interfaces_and_properties"
1505
1490
"""
1508
1493
connection)
1509
1494
try:
1510
1495
document = xml.dom.minidom.parseString(xmlstring)
1511
1496
1512
1497
for if_tag in document.getElementsByTagName("interface"):
1513
1498
# Fix argument name for the GetManagedObjects method
1514
1499
if (if_tag.getAttribute("name")
1515
== dbus.OBJECT_MANAGER_IFACE):
1500
== dbus.OBJECT_MANAGER_IFACE):
1516
1501
for cn in if_tag.getElementsByTagName("method"):
1517
1502
if (cn.getAttribute("name")
1518
1503
== "GetManagedObjects"):
1528
1513
except (AttributeError, xml.dom.DOMException,
1529
1514
xml.parsers.expat.ExpatError) as error:
1530
1515
logger.error("Failed to override Introspection method",
1531
exc_info=error)
1516
exc_info = error)
1532
1517
return xmlstring
1533
1518
1534
1535
1519
def datetime_to_dbus(dt, variant_level=0):
1536
1520
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1537
1521
if dt is None:
1538
return dbus.String("", variant_level=variant_level)
1522
return dbus.String("", variant_level = variant_level)
1539
1523
return dbus.String(dt.isoformat(), variant_level=variant_level)
1540
1524
1541
1525
1544
1528
dbus.service.Object, it will add alternate D-Bus attributes with
1545
1529
interface names according to the "alt_interface_names" mapping.
1546
1530
Usage:
1547
1531
1548
1532
@alternate_dbus_interfaces({"org.example.Interface":
1549
1533
"net.example.AlternateInterface"})
1550
1534
class SampleDBusObject(dbus.service.Object):
1551
1535
@dbus.service.method("org.example.Interface")
1552
1536
def SampleDBusMethod():
1553
1537
pass
1554
1538
1555
1539
The above "SampleDBusMethod" on "SampleDBusObject" will be
1556
1540
reachable via two interfaces: "org.example.Interface" and
1557
1541
"net.example.AlternateInterface", the latter of which will have
1558
1542
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1559
1543
"true", unless "deprecate" is passed with a False value.
1560
1544
1561
1545
This works for methods and signals, and also for D-Bus properties
1562
1546
(from DBusObjectWithProperties) and interfaces (from the
1563
1547
dbus_interface_annotations decorator).
1564
1548
"""
1565
1549
1566
1550
def wrapper(cls):
1567
1551
for orig_interface_name, alt_interface_name in (
1568
1552
alt_interface_names.items()):
1608
1592
attribute._dbus_annotations)
1609
1593
except AttributeError:
1610
1594
pass
1611
1612
1595
# Define a creator of a function to call both the
1613
1596
# original and alternate functions, so both the
1614
1597
# original and alternate signals gets sent when
1617
1600
"""This function is a scope container to pass
1618
1601
func1 and func2 to the "call_both" function
1619
1602
outside of its arguments"""
1620
1603
1621
1604
@functools.wraps(func2)
1622
1605
def call_both(*args, **kwargs):
1623
1606
"""This function will emit two D-Bus
1624
1607
signals by calling func1 and func2"""
1625
1608
func1(*args, **kwargs)
1626
1609
func2(*args, **kwargs)
1627
# Make wrapper function look like a D-Bus
1628
# signal
1610
# Make wrapper function look like a D-Bus signal
1629
1611
for name, attr in inspect.getmembers(func2):
1630
1612
if name.startswith("_dbus_"):
1631
1613
setattr(call_both, name, attr)
1632
1614
1633
1615
return call_both
1634
1616
# Create the "call_both" function and add it to
1635
1617
# the class
1681
1663
(copy_function(attribute)))
1682
1664
if deprecate:
1683
1665
# Deprecate all alternate interfaces
1684
iname = "_AlternateDBusNames_interface_annotation{}"
1666
iname="_AlternateDBusNames_interface_annotation{}"
1685
1667
for interface_name in interface_names:
1686
1668
1687
1669
@dbus_interface_annotations(interface_name)
1688
1670
def func(self):
1689
return {"org.freedesktop.DBus.Deprecated":
1690
"true"}
1671
return { "org.freedesktop.DBus.Deprecated":
1672
"true" }
1691
1673
# Find an unused name
1692
1674
for aname in (iname.format(i)
1693
1675
for i in itertools.count()):
1704
1686
cls = type("{}Alternate".format(cls.__name__),
1705
1687
(cls, ), attr)
1706
1688
return cls
1707
1689
1708
1690
return wrapper
1709
1691
1710
1692
1712
1694
"se.bsnet.fukt.Mandos"})
1713
1695
class ClientDBus(Client, DBusObjectWithProperties):
1714
1696
"""A Client class using D-Bus
1715
1697
1716
1698
Attributes:
1717
1699
dbus_object_path: dbus.ObjectPath
1718
1700
bus: dbus.SystemBus()
1719
1701
"""
1720
1702
1721
1703
runtime_expansions = (Client.runtime_expansions
1722
1704
+ ("dbus_object_path", ))
1723
1705
1724
1706
_interface = "se.recompile.Mandos.Client"
1725
1707
1726
1708
# dbus.service.Object doesn't use super(), so we can't either.
1727
1728
def __init__(self, bus=None, *args, **kwargs):
1709
1710
def __init__(self, bus = None, *args, **kwargs):
1729
1711
self.bus = bus
1730
1712
Client.__init__(self, *args, **kwargs)
1731
1713
# Only now, when this client is initialized, can it show up on
1737
1719
"/clients/" + client_object_name)
1738
1720
DBusObjectWithProperties.__init__(self, self.bus,
1739
1721
self.dbus_object_path)
1740
1722
1741
1723
def notifychangeproperty(transform_func, dbus_name,
1742
1724
type_func=lambda x: x,
1743
1725
variant_level=1,
1745
1727
_interface=_interface):
1746
1728
""" Modify a variable so that it's a property which announces
1747
1729
its changes to DBus.
1748
1730
1749
1731
transform_fun: Function that takes a value and a variant_level
1750
1732
and transforms it to a D-Bus type.
1751
1733
dbus_name: D-Bus name of the variable
1754
1736
variant_level: D-Bus variant level. Default: 1
1755
1737
"""
1756
1738
attrname = "_{}".format(dbus_name)
1757
1739
1758
1740
def setter(self, value):
1759
1741
if hasattr(self, "dbus_object_path"):
1760
1742
if (not hasattr(self, attrname) or
1767
1749
else:
1768
1750
dbus_value = transform_func(
1769
1751
type_func(value),
1770
variant_level=variant_level)
1752
variant_level = variant_level)
1771
1753
self.PropertyChanged(dbus.String(dbus_name),
1772
1754
dbus_value)
1773
1755
self.PropertiesChanged(
1774
1756
_interface,
1775
dbus.Dictionary({dbus.String(dbus_name):
1776
dbus_value}),
1757
dbus.Dictionary({ dbus.String(dbus_name):
1758
dbus_value }),
1777
1759
dbus.Array())
1778
1760
setattr(self, attrname, value)
1779
1761
1780
1762
return property(lambda self: getattr(self, attrname), setter)
1781
1763
1782
1764
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1783
1765
approvals_pending = notifychangeproperty(dbus.Boolean,
1784
1766
"ApprovalPending",
1785
type_func=bool)
1767
type_func = bool)
1786
1768
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1787
1769
last_enabled = notifychangeproperty(datetime_to_dbus,
1788
1770
"LastEnabled")
1789
1771
checker = notifychangeproperty(
1790
1772
dbus.Boolean, "CheckerRunning",
1791
type_func=lambda checker: checker is not None)
1773
type_func = lambda checker: checker is not None)
1792
1774
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1793
1775
"LastCheckedOK")
1794
1776
last_checker_status = notifychangeproperty(dbus.Int16,
1799
1781
"ApprovedByDefault")
1800
1782
approval_delay = notifychangeproperty(
1801
1783
dbus.UInt64, "ApprovalDelay",
1802
type_func=lambda td: td.total_seconds() * 1000)
1784
type_func = lambda td: td.total_seconds() * 1000)
1803
1785
approval_duration = notifychangeproperty(
1804
1786
dbus.UInt64, "ApprovalDuration",
1805
type_func=lambda td: td.total_seconds() * 1000)
1787
type_func = lambda td: td.total_seconds() * 1000)
1806
1788
host = notifychangeproperty(dbus.String, "Host")
1807
1789
timeout = notifychangeproperty(
1808
1790
dbus.UInt64, "Timeout",
1809
type_func=lambda td: td.total_seconds() * 1000)
1791
type_func = lambda td: td.total_seconds() * 1000)
1810
1792
extended_timeout = notifychangeproperty(
1811
1793
dbus.UInt64, "ExtendedTimeout",
1812
type_func=lambda td: td.total_seconds() * 1000)
1794
type_func = lambda td: td.total_seconds() * 1000)
1813
1795
interval = notifychangeproperty(
1814
1796
dbus.UInt64, "Interval",
1815
type_func=lambda td: td.total_seconds() * 1000)
1797
type_func = lambda td: td.total_seconds() * 1000)
1816
1798
checker_command = notifychangeproperty(dbus.String, "Checker")
1817
1799
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1818
1800
invalidate_only=True)
1819
1801
1820
1802
del notifychangeproperty
1821
1803
1822
1804
def __del__(self, *args, **kwargs):
1823
1805
try:
1824
1806
self.remove_from_connection()
1827
1809
if hasattr(DBusObjectWithProperties, "__del__"):
1828
1810
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1829
1811
Client.__del__(self, *args, **kwargs)
1830
1812
1831
1813
def checker_callback(self, source, condition,
1832
1814
connection, command, *args, **kwargs):
1833
1815
ret = Client.checker_callback(self, source, condition,
1849
1831
| self.last_checker_signal),
1850
1832
dbus.String(command))
1851
1833
return ret
1852
1834
1853
1835
def start_checker(self, *args, **kwargs):
1854
1836
old_checker_pid = getattr(self.checker, "pid", None)
1855
1837
r = Client.start_checker(self, *args, **kwargs)
1859
1841
# Emit D-Bus signal
1860
1842
self.CheckerStarted(self.current_checker_command)
1861
1843
return r
1862
1844
1863
1845
def _reset_approved(self):
1864
1846
self.approved = None
1865
1847
return False
1866
1848
1867
1849
def approve(self, value=True):
1868
1850
self.approved = value
1869
1851
GLib.timeout_add(int(self.approval_duration.total_seconds()
1870
1852
* 1000), self._reset_approved)
1871
1853
self.send_changedstate()
1872
1873
# D-Bus methods, signals & properties
1874
1875
# Interfaces
1876
1877
# Signals
1878
1854
1855
## D-Bus methods, signals & properties
1856
1857
## Interfaces
1858
1859
## Signals
1860
1879
1861
# CheckerCompleted - signal
1880
1862
@dbus.service.signal(_interface, signature="nxs")
1881
1863
def CheckerCompleted(self, exitcode, waitstatus, command):
1882
1864
"D-Bus signal"
1883
1865
pass
1884
1866
1885
1867
# CheckerStarted - signal
1886
1868
@dbus.service.signal(_interface, signature="s")
1887
1869
def CheckerStarted(self, command):
1888
1870
"D-Bus signal"
1889
1871
pass
1890
1872
1891
1873
# PropertyChanged - signal
1892
1874
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1893
1875
@dbus.service.signal(_interface, signature="sv")
1894
1876
def PropertyChanged(self, property, value):
1895
1877
"D-Bus signal"
1896
1878
pass
1897
1879
1898
1880
# GotSecret - signal
1899
1881
@dbus.service.signal(_interface)
1900
1882
def GotSecret(self):
1903
1885
server to mandos-client
1904
1886
"""
1905
1887
pass
1906
1888
1907
1889
# Rejected - signal
1908
1890
@dbus.service.signal(_interface, signature="s")
1909
1891
def Rejected(self, reason):
1910
1892
"D-Bus signal"
1911
1893
pass
1912
1894
1913
1895
# NeedApproval - signal
1914
1896
@dbus.service.signal(_interface, signature="tb")
1915
1897
def NeedApproval(self, timeout, default):
1916
1898
"D-Bus signal"
1917
1899
return self.need_approval()
1918
1919
# Methods
1920
1900
1901
## Methods
1902
1921
1903
# Approve - method
1922
1904
@dbus.service.method(_interface, in_signature="b")
1923
1905
def Approve(self, value):
1924
1906
self.approve(value)
1925
1907
1926
1908
# CheckedOK - method
1927
1909
@dbus.service.method(_interface)
1928
1910
def CheckedOK(self):
1929
1911
self.checked_ok()
1930
1912
1931
1913
# Enable - method
1932
1914
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1933
1915
@dbus.service.method(_interface)
1934
1916
def Enable(self):
1935
1917
"D-Bus method"
1936
1918
self.enable()
1937
1919
1938
1920
# StartChecker - method
1939
1921
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1940
1922
@dbus.service.method(_interface)
1941
1923
def StartChecker(self):
1942
1924
"D-Bus method"
1943
1925
self.start_checker()
1944
1926
1945
1927
# Disable - method
1946
1928
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1947
1929
@dbus.service.method(_interface)
1948
1930
def Disable(self):
1949
1931
"D-Bus method"
1950
1932
self.disable()
1951
1933
1952
1934
# StopChecker - method
1953
1935
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1954
1936
@dbus.service.method(_interface)
1955
1937
def StopChecker(self):
1956
1938
self.stop_checker()
1957
1958
# Properties
1959
1939
1940
## Properties
1941
1960
1942
# ApprovalPending - property
1961
1943
@dbus_service_property(_interface, signature="b", access="read")
1962
1944
def ApprovalPending_dbus_property(self):
1963
1945
return dbus.Boolean(bool(self.approvals_pending))
1964
1946
1965
1947
# ApprovedByDefault - property
1966
1948
@dbus_service_property(_interface,
1967
1949
signature="b",
1970
1952
if value is None: # get
1971
1953
return dbus.Boolean(self.approved_by_default)
1972
1954
self.approved_by_default = bool(value)
1973
1955
1974
1956
# ApprovalDelay - property
1975
1957
@dbus_service_property(_interface,
1976
1958
signature="t",
1980
1962
return dbus.UInt64(self.approval_delay.total_seconds()
1981
1963
* 1000)
1982
1964
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1983
1965
1984
1966
# ApprovalDuration - property
1985
1967
@dbus_service_property(_interface,
1986
1968
signature="t",
1990
1972
return dbus.UInt64(self.approval_duration.total_seconds()
1991
1973
* 1000)
1992
1974
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1993
1975
1994
1976
# Name - property
1995
1977
@dbus_annotations(
1996
1978
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1997
1979
@dbus_service_property(_interface, signature="s", access="read")
1998
1980
def Name_dbus_property(self):
1999
1981
return dbus.String(self.name)
2000
1982
2001
1983
# Fingerprint - property
2002
1984
@dbus_annotations(
2003
1985
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2004
1986
@dbus_service_property(_interface, signature="s", access="read")
2005
1987
def Fingerprint_dbus_property(self):
2006
1988
return dbus.String(self.fingerprint)
2007
1989
2008
1990
# Host - property
2009
1991
@dbus_service_property(_interface,
2010
1992
signature="s",
2013
1995
if value is None: # get
2014
1996
return dbus.String(self.host)
2015
1997
self.host = str(value)
2016
1998
2017
1999
# Created - property
2018
2000
@dbus_annotations(
2019
2001
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2020
2002
@dbus_service_property(_interface, signature="s", access="read")
2021
2003
def Created_dbus_property(self):
2022
2004
return datetime_to_dbus(self.created)
2023
2005
2024
2006
# LastEnabled - property
2025
2007
@dbus_service_property(_interface, signature="s", access="read")
2026
2008
def LastEnabled_dbus_property(self):
2027
2009
return datetime_to_dbus(self.last_enabled)
2028
2010
2029
2011
# Enabled - property
2030
2012
@dbus_service_property(_interface,
2031
2013
signature="b",
2037
2019
self.enable()
2038
2020
else:
2039
2021
self.disable()
2040
2022
2041
2023
# LastCheckedOK - property
2042
2024
@dbus_service_property(_interface,
2043
2025
signature="s",
2047
2029
self.checked_ok()
2048
2030
return
2049
2031
return datetime_to_dbus(self.last_checked_ok)
2050
2032
2051
2033
# LastCheckerStatus - property
2052
2034
@dbus_service_property(_interface, signature="n", access="read")
2053
2035
def LastCheckerStatus_dbus_property(self):
2054
2036
return dbus.Int16(self.last_checker_status)
2055
2037
2056
2038
# Expires - property
2057
2039
@dbus_service_property(_interface, signature="s", access="read")
2058
2040
def Expires_dbus_property(self):
2059
2041
return datetime_to_dbus(self.expires)
2060
2042
2061
2043
# LastApprovalRequest - property
2062
2044
@dbus_service_property(_interface, signature="s", access="read")
2063
2045
def LastApprovalRequest_dbus_property(self):
2064
2046
return datetime_to_dbus(self.last_approval_request)
2065
2047
2066
2048
# Timeout - property
2067
2049
@dbus_service_property(_interface,
2068
2050
signature="t",
2087
2069
self.disable_initiator_tag = GLib.timeout_add(
2088
2070
int((self.expires - now).total_seconds() * 1000),
2089
2071
self.disable)
2090
2072
2091
2073
# ExtendedTimeout - property
2092
2074
@dbus_service_property(_interface,
2093
2075
signature="t",
2097
2079
return dbus.UInt64(self.extended_timeout.total_seconds()
2098
2080
* 1000)
2099
2081
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2100
2082
2101
2083
# Interval - property
2102
2084
@dbus_service_property(_interface,
2103
2085
signature="t",
2113
2095
GLib.source_remove(self.checker_initiator_tag)
2114
2096
self.checker_initiator_tag = GLib.timeout_add(
2115
2097
value, self.start_checker)
2116
self.start_checker() # Start one now, too
2117
2098
self.start_checker() # Start one now, too
2099
2118
2100
# Checker - property
2119
2101
@dbus_service_property(_interface,
2120
2102
signature="s",
2123
2105
if value is None: # get
2124
2106
return dbus.String(self.checker_command)
2125
2107
self.checker_command = str(value)
2126
2108
2127
2109
# CheckerRunning - property
2128
2110
@dbus_service_property(_interface,
2129
2111
signature="b",
2135
2117
self.start_checker()
2136
2118
else:
2137
2119
self.stop_checker()
2138
2120
2139
2121
# ObjectPath - property
2140
2122
@dbus_annotations(
2141
2123
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2142
2124
"org.freedesktop.DBus.Deprecated": "true"})
2143
2125
@dbus_service_property(_interface, signature="o", access="read")
2144
2126
def ObjectPath_dbus_property(self):
2145
return self.dbus_object_path # is already a dbus.ObjectPath
2146
2127
return self.dbus_object_path # is already a dbus.ObjectPath
2128
2147
2129
# Secret = property
2148
2130
@dbus_annotations(
2149
2131
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2154
2136
byte_arrays=True)
2155
2137
def Secret_dbus_property(self, value):
2156
2138
self.secret = bytes(value)
2157
2139
2158
2140
del _interface
2159
2141
2160
2142
2164
2146
self._pipe.send(('init', fpr, address))
2165
2147
if not self._pipe.recv():
2166
2148
raise KeyError(fpr)
2167
2149
2168
2150
def __getattribute__(self, name):
2169
2151
if name == '_pipe':
2170
2152
return super(ProxyClient, self).__getattribute__(name)
2173
2155
if data[0] == 'data':
2174
2156
return data[1]
2175
2157
if data[0] == 'function':
2176
2158
2177
2159
def func(*args, **kwargs):
2178
2160
self._pipe.send(('funcall', name, args, kwargs))
2179
2161
return self._pipe.recv()[1]
2180
2162
2181
2163
return func
2182
2164
2183
2165
def __setattr__(self, name, value):
2184
2166
if name == '_pipe':
2185
2167
return super(ProxyClient, self).__setattr__(name, value)
2188
2170
2189
2171
class ClientHandler(socketserver.BaseRequestHandler, object):
2190
2172
"""A class to handle client connections.
2191
2173
2192
2174
Instantiated once for each connection to handle it.
2193
2175
Note: This will run in its own forked process."""
2194
2176
2195
2177
def handle(self):
2196
2178
with contextlib.closing(self.server.child_pipe) as child_pipe:
2197
2179
logger.info("TCP connection from: %s",
2198
2180
str(self.client_address))
2199
2181
logger.debug("Pipe FD: %d",
2200
2182
self.server.child_pipe.fileno())
2201
2183
2202
2184
session = gnutls.ClientSession(self.request)
2203
2204
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2205
# "+AES-256-CBC", "+SHA1",
2206
# "+COMP-NULL", "+CTYPE-OPENPGP",
2207
# "+DHE-DSS"))
2185
2186
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2187
# "+AES-256-CBC", "+SHA1",
2188
# "+COMP-NULL", "+CTYPE-OPENPGP",
2189
# "+DHE-DSS"))
2208
2190
# Use a fallback default, since this MUST be set.
2209
2191
priority = self.server.gnutls_priority
2210
2192
if priority is None:
2212
2194
gnutls.priority_set_direct(session._c_object,
2213
2195
priority.encode("utf-8"),
2214
2196
None)
2215
2197
2216
2198
# Start communication using the Mandos protocol
2217
2199
# Get protocol number
2218
2200
line = self.request.makefile().readline()
2223
2205
except (ValueError, IndexError, RuntimeError) as error:
2224
2206
logger.error("Unknown protocol version: %s", error)
2225
2207
return
2226
2208
2227
2209
# Start GnuTLS connection
2228
2210
try:
2229
2211
session.handshake()
2233
2215
# established. Just abandon the request.
2234
2216
return
2235
2217
logger.debug("Handshake succeeded")
2236
2218
2237
2219
approval_required = False
2238
2220
try:
2239
2221
try:
2243
2225
logger.warning("Bad certificate: %s", error)
2244
2226
return
2245
2227
logger.debug("Fingerprint: %s", fpr)
2246
2228
2247
2229
try:
2248
2230
client = ProxyClient(child_pipe, fpr,
2249
2231
self.client_address)
2250
2232
except KeyError:
2251
2233
return
2252
2234
2253
2235
if client.approval_delay:
2254
2236
delay = client.approval_delay
2255
2237
client.approvals_pending += 1
2256
2238
approval_required = True
2257
2239
2258
2240
while True:
2259
2241
if not client.enabled:
2260
2242
logger.info("Client %s is disabled",
2263
2245
# Emit D-Bus signal
2264
2246
client.Rejected("Disabled")
2265
2247
return
2266
2248
2267
2249
if client.approved or not client.approval_delay:
2268
# We are approved or approval is disabled
2250
#We are approved or approval is disabled
2269
2251
break
2270
2252
elif client.approved is None:
2271
2253
logger.info("Client %s needs approval",
2282
2264
# Emit D-Bus signal
2283
2265
client.Rejected("Denied")
2284
2266
return
2285
2286
# wait until timeout or approved
2267
2268
#wait until timeout or approved
2287
2269
time = datetime.datetime.now()
2288
2270
client.changedstate.acquire()
2289
2271
client.changedstate.wait(delay.total_seconds())
2302
2284
break
2303
2285
else:
2304
2286
delay -= time2 - time
2305
2287
2306
2288
try:
2307
2289
session.send(client.secret)
2308
2290
except gnutls.Error as error:
2309
2291
logger.warning("gnutls send failed",
2310
exc_info=error)
2292
exc_info = error)
2311
2293
return
2312
2294
2313
2295
logger.info("Sending secret to %s", client.name)
2314
2296
# bump the timeout using extended_timeout
2315
2297
client.bump_timeout(client.extended_timeout)
2316
2298
if self.server.use_dbus:
2317
2299
# Emit D-Bus signal
2318
2300
client.GotSecret()
2319
2301
2320
2302
finally:
2321
2303
if approval_required:
2322
2304
client.approvals_pending -= 1
2325
2307
except gnutls.Error as error:
2326
2308
logger.warning("GnuTLS bye failed",
2327
2309
exc_info=error)
2328
2310
2329
2311
@staticmethod
2330
2312
def peer_certificate(session):
2331
2313
"Return the peer's OpenPGP certificate as a bytestring"
2343
2325
return None
2344
2326
cert = cert_list[0]
2345
2327
return ctypes.string_at(cert.data, cert.size)
2346
2328
2347
2329
@staticmethod
2348
2330
def fingerprint(openpgp):
2349
2331
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2382
2364
2383
2365
class MultiprocessingMixIn(object):
2384
2366
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2385
2367
2386
2368
def sub_process_main(self, request, address):
2387
2369
try:
2388
2370
self.finish_request(request, address)
2389
2371
except Exception:
2390
2372
self.handle_error(request, address)
2391
2373
self.close_request(request)
2392
2374
2393
2375
def process_request(self, request, address):
2394
2376
"""Start a new process to process the request."""
2395
proc = multiprocessing.Process(target=self.sub_process_main,
2396
args=(request, address))
2377
proc = multiprocessing.Process(target = self.sub_process_main,
2378
args = (request, address))
2397
2379
proc.start()
2398
2380
return proc
2399
2381
2400
2382
2401
2383
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2402
2384
""" adds a pipe to the MixIn """
2403
2385
2404
2386
def process_request(self, request, client_address):
2405
2387
"""Overrides and wraps the original process_request().
2406
2388
2407
2389
This function creates a new pipe in self.pipe
2408
2390
"""
2409
2391
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2410
2392
2411
2393
proc = MultiprocessingMixIn.process_request(self, request,
2412
2394
client_address)
2413
2395
self.child_pipe.close()
2414
2396
self.add_pipe(parent_pipe, proc)
2415
2397
2416
2398
def add_pipe(self, parent_pipe, proc):
2417
2399
"""Dummy function; override as necessary"""
2418
2400
raise NotImplementedError()
2421
2403
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2422
2404
socketserver.TCPServer, object):
2423
2405
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2424
2406
2425
2407
Attributes:
2426
2408
enabled: Boolean; whether this server is activated yet
2427
2409
interface: None or a network interface name (string)
2428
2410
use_ipv6: Boolean; to use IPv6 or not
2429
2411
"""
2430
2412
2431
2413
def __init__(self, server_address, RequestHandlerClass,
2432
2414
interface=None,
2433
2415
use_ipv6=True,
2443
2425
self.socketfd = socketfd
2444
2426
# Save the original socket.socket() function
2445
2427
self.socket_socket = socket.socket
2446
2447
2428
# To implement --socket, we monkey patch socket.socket.
2448
#
2429
#
2449
2430
# (When socketserver.TCPServer is a new-style class, we
2450
2431
# could make self.socket into a property instead of monkey
2451
2432
# patching socket.socket.)
2452
#
2433
#
2453
2434
# Create a one-time-only replacement for socket.socket()
2454
2435
@functools.wraps(socket.socket)
2455
2436
def socket_wrapper(*args, **kwargs):
2467
2448
# socket_wrapper(), if socketfd was set.
2468
2449
socketserver.TCPServer.__init__(self, server_address,
2469
2450
RequestHandlerClass)
2470
2451
2471
2452
def server_bind(self):
2472
2453
"""This overrides the normal server_bind() function
2473
2454
to bind to an interface if one was specified, and also NOT to
2500
2481
if self.server_address[0] or self.server_address[1]:
2501
2482
if not self.server_address[0]:
2502
2483
if self.address_family == socket.AF_INET6:
2503
any_address = "::" # in6addr_any
2484
any_address = "::" # in6addr_any
2504
2485
else:
2505
any_address = "0.0.0.0" # INADDR_ANY
2486
any_address = "0.0.0.0" # INADDR_ANY
2506
2487
self.server_address = (any_address,
2507
2488
self.server_address[1])
2508
2489
elif not self.server_address[1]:
2518
2499
2519
2500
class MandosServer(IPv6_TCPServer):
2520
2501
"""Mandos server.
2521
2502
2522
2503
Attributes:
2523
2504
clients: set of Client objects
2524
2505
gnutls_priority GnuTLS priority string
2525
2506
use_dbus: Boolean; to emit D-Bus signals or not
2526
2507
2527
2508
Assumes a GLib.MainLoop event loop.
2528
2509
"""
2529
2510
2530
2511
def __init__(self, server_address, RequestHandlerClass,
2531
2512
interface=None,
2532
2513
use_ipv6=True,
2542
2523
self.gnutls_priority = gnutls_priority
2543
2524
IPv6_TCPServer.__init__(self, server_address,
2544
2525
RequestHandlerClass,
2545
interface=interface,
2546
use_ipv6=use_ipv6,
2547
socketfd=socketfd)
2548
2526
interface = interface,
2527
use_ipv6 = use_ipv6,
2528
socketfd = socketfd)
2529
2549
2530
def server_activate(self):
2550
2531
if self.enabled:
2551
2532
return socketserver.TCPServer.server_activate(self)
2552
2533
2553
2534
def enable(self):
2554
2535
self.enabled = True
2555
2536
2556
2537
def add_pipe(self, parent_pipe, proc):
2557
2538
# Call "handle_ipc" for both data and EOF events
2558
2539
GLib.io_add_watch(
2559
2540
parent_pipe.fileno(),
2560
2541
GLib.IO_IN | GLib.IO_HUP,
2561
2542
functools.partial(self.handle_ipc,
2562
parent_pipe=parent_pipe,
2563
proc=proc))
2564
2543
parent_pipe = parent_pipe,
2544
proc = proc))
2545
2565
2546
def handle_ipc(self, source, condition,
2566
2547
parent_pipe=None,
2567
proc=None,
2548
proc = None,
2568
2549
client_object=None):
2569
2550
# error, or the other end of multiprocessing.Pipe has closed
2570
2551
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2571
2552
# Wait for other process to exit
2572
2553
proc.join()
2573
2554
return False
2574
2555
2575
2556
# Read a request from the child
2576
2557
request = parent_pipe.recv()
2577
2558
command = request[0]
2578
2559
2579
2560
if command == 'init':
2580
2561
fpr = request[1]
2581
2562
address = request[2]
2582
2563
2583
2564
for c in self.clients.values():
2584
2565
if c.fingerprint == fpr:
2585
2566
client = c
2593
2574
address[0])
2594
2575
parent_pipe.send(False)
2595
2576
return False
2596
2577
2597
2578
GLib.io_add_watch(
2598
2579
parent_pipe.fileno(),
2599
2580
GLib.IO_IN | GLib.IO_HUP,
2600
2581
functools.partial(self.handle_ipc,
2601
parent_pipe=parent_pipe,
2602
proc=proc,
2603
client_object=client))
2582
parent_pipe = parent_pipe,
2583
proc = proc,
2584
client_object = client))
2604
2585
parent_pipe.send(True)
2605
2586
# remove the old hook in favor of the new above hook on
2606
2587
# same fileno
2609
2590
funcname = request[1]
2610
2591
args = request[2]
2611
2592
kwargs = request[3]
2612
2593
2613
2594
parent_pipe.send(('data', getattr(client_object,
2614
2595
funcname)(*args,
2615
2596
**kwargs)))
2616
2597
2617
2598
if command == 'getattr':
2618
2599
attrname = request[1]
2619
2600
if isinstance(client_object.__getattribute__(attrname),
2622
2603
else:
2623
2604
parent_pipe.send((
2624
2605
'data', client_object.__getattribute__(attrname)))
2625
2606
2626
2607
if command == 'setattr':
2627
2608
attrname = request[1]
2628
2609
value = request[2]
2629
2610
setattr(client_object, attrname, value)
2630
2611
2631
2612
return True
2632
2613
2633
2614
2634
2615
def rfc3339_duration_to_delta(duration):
2635
2616
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2636
2617
2637
2618
>>> rfc3339_duration_to_delta("P7D")
2638
2619
datetime.timedelta(7)
2639
2620
>>> rfc3339_duration_to_delta("PT60S")
2649
2630
>>> rfc3339_duration_to_delta("P1DT3M20S")
2650
2631
datetime.timedelta(1, 200)
2651
2632
"""
2652
2633
2653
2634
# Parsing an RFC 3339 duration with regular expressions is not
2654
2635
# possible - there would have to be multiple places for the same
2655
2636
# values, like seconds. The current code, while more esoteric, is
2656
2637
# cleaner without depending on a parsing library. If Python had a
2657
2638
# built-in library for parsing we would use it, but we'd like to
2658
2639
# avoid excessive use of external libraries.
2659
2640
2660
2641
# New type for defining tokens, syntax, and semantics all-in-one
2661
2642
Token = collections.namedtuple("Token", (
2662
2643
"regexp", # To match token; if "value" is not None, must have
2695
2676
frozenset((token_year, token_month,
2696
2677
token_day, token_time,
2697
2678
token_week)))
2698
# Define starting values:
2699
# Value so far
2700
value = datetime.timedelta()
2679
# Define starting values
2680
value = datetime.timedelta() # Value so far
2701
2681
found_token = None
2702
# Following valid tokens
2703
followers = frozenset((token_duration, ))
2704
# String left to parse
2705
s = duration
2682
followers = frozenset((token_duration, )) # Following valid tokens
2683
s = duration # String left to parse
2706
2684
# Loop until end token is found
2707
2685
while found_token is not token_end:
2708
2686
# Search for any currently valid tokens
2732
2710
2733
2711
def string_to_delta(interval):
2734
2712
"""Parse a string and return a datetime.timedelta
2735
2713
2736
2714
>>> string_to_delta('7d')
2737
2715
datetime.timedelta(7)
2738
2716
>>> string_to_delta('60s')
2746
2724
>>> string_to_delta('5m 30s')
2747
2725
datetime.timedelta(0, 330)
2748
2726
"""
2749
2727
2750
2728
try:
2751
2729
return rfc3339_duration_to_delta(interval)
2752
2730
except ValueError:
2753
2731
pass
2754
2732
2755
2733
timevalue = datetime.timedelta(0)
2756
2734
for s in interval.split():
2757
2735
try:
2775
2753
return timevalue
2776
2754
2777
2755
2778
def daemon(nochdir=False, noclose=False):
2756
def daemon(nochdir = False, noclose = False):
2779
2757
"""See daemon(3). Standard BSD Unix function.
2780
2758
2781
2759
This should really exist as os.daemon, but it doesn't (yet)."""
2782
2760
if os.fork():
2783
2761
sys.exit()
2801
2779
2802
2780
2803
2781
def main():
2804
2782
2805
2783
##################################################################
2806
2784
# Parsing of options, both command line and config file
2807
2785
2808
2786
parser = argparse.ArgumentParser()
2809
2787
parser.add_argument("-v", "--version", action="version",
2810
version="%(prog)s {}".format(version),
2788
version = "%(prog)s {}".format(version),
2811
2789
help="show version number and exit")
2812
2790
parser.add_argument("-i", "--interface", metavar="IF",
2813
2791
help="Bind to interface IF")
2849
2827
parser.add_argument("--no-zeroconf", action="store_false",
2850
2828
dest="zeroconf", help="Do not use Zeroconf",
2851
2829
default=None)
2852
2830
2853
2831
options = parser.parse_args()
2854
2832
2855
2833
if options.check:
2856
2834
import doctest
2857
2835
fail_count, test_count = doctest.testmod()
2858
2836
sys.exit(os.EX_OK if fail_count == 0 else 1)
2859
2837
2860
2838
# Default values for config file for server-global settings
2861
server_defaults = {"interface": "",
2862
"address": "",
2863
"port": "",
2864
"debug": "False",
2865
"priority":
2866
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2867
":+SIGN-DSA-SHA256",
2868
"servicename": "Mandos",
2869
"use_dbus": "True",
2870
"use_ipv6": "True",
2871
"debuglevel": "",
2872
"restore": "True",
2873
"socket": "",
2874
"statedir": "/var/lib/mandos",
2875
"foreground": "False",
2876
"zeroconf": "True",
2877
}
2878
2839
server_defaults = { "interface": "",
2840
"address": "",
2841
"port": "",
2842
"debug": "False",
2843
"priority":
2844
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2845
":+SIGN-DSA-SHA256",
2846
"servicename": "Mandos",
2847
"use_dbus": "True",
2848
"use_ipv6": "True",
2849
"debuglevel": "",
2850
"restore": "True",
2851
"socket": "",
2852
"statedir": "/var/lib/mandos",
2853
"foreground": "False",
2854
"zeroconf": "True",
2855
}
2856
2879
2857
# Parse config file for server-global settings
2880
2858
server_config = configparser.SafeConfigParser(server_defaults)
2881
2859
del server_defaults
2899
2877
server_settings["socket"] = os.dup(server_settings
2900
2878
["socket"])
2901
2879
del server_config
2902
2880
2903
2881
# Override the settings from the config file with command line
2904
2882
# options, if set.
2905
2883
for option in ("interface", "address", "port", "debug",
2923
2901
if server_settings["debug"]:
2924
2902
server_settings["foreground"] = True
2925
2903
# Now we have our good server settings in "server_settings"
2926
2904
2927
2905
##################################################################
2928
2906
2929
2907
if (not server_settings["zeroconf"]
2930
2908
and not (server_settings["port"]
2931
2909
or server_settings["socket"] != "")):
2932
2910
parser.error("Needs port or socket to work without Zeroconf")
2933
2911
2934
2912
# For convenience
2935
2913
debug = server_settings["debug"]
2936
2914
debuglevel = server_settings["debuglevel"]
2940
2918
stored_state_file)
2941
2919
foreground = server_settings["foreground"]
2942
2920
zeroconf = server_settings["zeroconf"]
2943
2921
2944
2922
if debug:
2945
2923
initlogger(debug, logging.DEBUG)
2946
2924
else:
2949
2927
else:
2950
2928
level = getattr(logging, debuglevel.upper())
2951
2929
initlogger(debug, level)
2952
2930
2953
2931
if server_settings["servicename"] != "Mandos":
2954
2932
syslogger.setFormatter(
2955
2933
logging.Formatter('Mandos ({}) [%(process)d]:'
2956
2934
' %(levelname)s: %(message)s'.format(
2957
2935
server_settings["servicename"])))
2958
2936
2959
2937
# Parse config file with clients
2960
2938
client_config = configparser.SafeConfigParser(Client
2961
2939
.client_defaults)
2962
2940
client_config.read(os.path.join(server_settings["configdir"],
2963
2941
"clients.conf"))
2964
2942
2965
2943
global mandos_dbus_service
2966
2944
mandos_dbus_service = None
2967
2945
2968
2946
socketfd = None
2969
2947
if server_settings["socket"] != "":
2970
2948
socketfd = server_settings["socket"]
2986
2964
except IOError as e:
2987
2965
logger.error("Could not open file %r", pidfilename,
2988
2966
exc_info=e)
2989
2967
2990
2968
for name, group in (("_mandos", "_mandos"),
2991
2969
("mandos", "mandos"),
2992
2970
("nobody", "nogroup")):
3010
2988
.format(uid, gid, os.strerror(error.errno)))
3011
2989
if error.errno != errno.EPERM:
3012
2990
raise
3013
2991
3014
2992
if debug:
3015
2993
# Enable all possible GnuTLS debugging
3016
2994
3017
2995
# "Use a log level over 10 to enable all debugging options."
3018
2996
# - GnuTLS manual
3019
2997
gnutls.global_set_log_level(11)
3020
2998
3021
2999
@gnutls.log_func
3022
3000
def debug_gnutls(level, string):
3023
3001
logger.debug("GnuTLS: %s", string[:-1])
3024
3002
3025
3003
gnutls.global_set_log_function(debug_gnutls)
3026
3004
3027
3005
# Redirect stdin so all checkers get /dev/null
3028
3006
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3029
3007
os.dup2(null, sys.stdin.fileno())
3030
3008
if null > 2:
3031
3009
os.close(null)
3032
3010
3033
3011
# Need to fork before connecting to D-Bus
3034
3012
if not foreground:
3035
3013
# Close all input and output, do double fork, etc.
3036
3014
daemon()
3037
3015
3038
3016
# multiprocessing will use threads, so before we use GLib we need
3039
3017
# to inform GLib that threads will be used.
3040
3018
GLib.threads_init()
3041
3019
3042
3020
global main_loop
3043
3021
# From the Avahi example code
3044
3022
DBusGMainLoop(set_as_default=True)
3061
3039
if zeroconf:
3062
3040
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3063
3041
service = AvahiServiceToSyslog(
3064
name=server_settings["servicename"],
3065
servicetype="_mandos._tcp",
3066
protocol=protocol,
3067
bus=bus)
3042
name = server_settings["servicename"],
3043
servicetype = "_mandos._tcp",
3044
protocol = protocol,
3045
bus = bus)
3068
3046
if server_settings["interface"]:
3069
3047
service.interface = if_nametoindex(
3070
3048
server_settings["interface"].encode("utf-8"))
3071
3049
3072
3050
global multiprocessing_manager
3073
3051
multiprocessing_manager = multiprocessing.Manager()
3074
3052
3075
3053
client_class = Client
3076
3054
if use_dbus:
3077
client_class = functools.partial(ClientDBus, bus=bus)
3078
3055
client_class = functools.partial(ClientDBus, bus = bus)
3056
3079
3057
client_settings = Client.config_parser(client_config)
3080
3058
old_client_settings = {}
3081
3059
clients_data = {}
3082
3060
3083
3061
# This is used to redirect stdout and stderr for checker processes
3084
3062
global wnull
3085
wnull = open(os.devnull, "w") # A writable /dev/null
3063
wnull = open(os.devnull, "w") # A writable /dev/null
3086
3064
# Only used if server is running in foreground but not in debug
3087
3065
# mode
3088
3066
if debug or not foreground:
3089
3067
wnull.close()
3090
3068
3091
3069
# Get client data and settings from last running state.
3092
3070
if server_settings["restore"]:
3093
3071
try:
3094
3072
with open(stored_state_path, "rb") as stored_state:
3095
if sys.version_info.major == 2:
3073
if sys.version_info.major == 2:
3096
3074
clients_data, old_client_settings = pickle.load(
3097
3075
stored_state)
3098
3076
else:
3099
3077
bytes_clients_data, bytes_old_client_settings = (
3100
pickle.load(stored_state, encoding="bytes"))
3101
# Fix bytes to strings
3102
# clients_data
3078
pickle.load(stored_state, encoding = "bytes"))
3079
### Fix bytes to strings
3080
## clients_data
3103
3081
# .keys()
3104
clients_data = {(key.decode("utf-8")
3105
if isinstance(key, bytes)
3106
else key): value
3107
for key, value in
3108
bytes_clients_data.items()}
3082
clients_data = { (key.decode("utf-8")
3083
if isinstance(key, bytes)
3084
else key): value
3085
for key, value in
3086
bytes_clients_data.items() }
3109
3087
del bytes_clients_data
3110
3088
for key in clients_data:
3111
value = {(k.decode("utf-8")
3112
if isinstance(k, bytes) else k): v
3113
for k, v in
3114
clients_data[key].items()}
3089
value = { (k.decode("utf-8")
3090
if isinstance(k, bytes) else k): v
3091
for k, v in
3092
clients_data[key].items() }
3115
3093
clients_data[key] = value
3116
3094
# .client_structure
3117
3095
value["client_structure"] = [
3118
3096
(s.decode("utf-8")
3119
3097
if isinstance(s, bytes)
3120
3098
else s) for s in
3121
value["client_structure"]]
3099
value["client_structure"] ]
3122
3100
# .name & .host
3123
3101
for k in ("name", "host"):
3124
3102
if isinstance(value[k], bytes):
3125
3103
value[k] = value[k].decode("utf-8")
3126
# old_client_settings
3104
## old_client_settings
3127
3105
# .keys()
3128
3106
old_client_settings = {
3129
3107
(key.decode("utf-8")
3130
3108
if isinstance(key, bytes)
3131
3109
else key): value
3132
3110
for key, value in
3133
bytes_old_client_settings.items()}
3111
bytes_old_client_settings.items() }
3134
3112
del bytes_old_client_settings
3135
3113
# .host
3136
3114
for value in old_client_settings.values():
3150
3128
logger.warning("Could not load persistent state: "
3151
3129
"EOFError:",
3152
3130
exc_info=e)
3153
3131
3154
3132
with PGPEngine() as pgp:
3155
3133
for client_name, client in clients_data.items():
3156
3134
# Skip removed clients
3157
3135
if client_name not in client_settings:
3158
3136
continue
3159
3137
3160
3138
# Decide which value to use after restoring saved state.
3161
3139
# We have three different values: Old config file,
3162
3140
# new config file, and saved state.
3173
3151
client[name] = value
3174
3152
except KeyError:
3175
3153
pass
3176
3154
3177
3155
# Clients who has passed its expire date can still be
3178
3156
# enabled if its last checker was successful. A Client
3179
3157
# whose checker succeeded before we stored its state is
3212
3190
client_name))
3213
3191
client["secret"] = (client_settings[client_name]
3214
3192
["secret"])
3215
3193
3216
3194
# Add/remove clients based on new changes made to config
3217
3195
for client_name in (set(old_client_settings)
3218
3196
- set(client_settings)):
3220
3198
for client_name in (set(client_settings)
3221
3199
- set(old_client_settings)):
3222
3200
clients_data[client_name] = client_settings[client_name]
3223
3201
3224
3202
# Create all client objects
3225
3203
for client_name, client in clients_data.items():
3226
3204
tcp_server.clients[client_name] = client_class(
3227
name=client_name,
3228
settings=client,
3229
server_settings=server_settings)
3230
3205
name = client_name,
3206
settings = client,
3207
server_settings = server_settings)
3208
3231
3209
if not tcp_server.clients:
3232
3210
logger.warning("No clients defined")
3233
3211
3234
3212
if not foreground:
3235
3213
if pidfile is not None:
3236
3214
pid = os.getpid()
3242
3220
pidfilename, pid)
3243
3221
del pidfile
3244
3222
del pidfilename
3245
3223
3246
3224
for termsig in (signal.SIGHUP, signal.SIGTERM):
3247
3225
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3248
3226
lambda: main_loop.quit() and False)
3249
3227
3250
3228
if use_dbus:
3251
3229
3252
3230
@alternate_dbus_interfaces(
3253
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3231
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3254
3232
class MandosDBusService(DBusObjectWithObjectManager):
3255
3233
"""A D-Bus proxy object"""
3256
3234
3257
3235
def __init__(self):
3258
3236
dbus.service.Object.__init__(self, bus, "/")
3259
3237
3260
3238
_interface = "se.recompile.Mandos"
3261
3239
3262
3240
@dbus.service.signal(_interface, signature="o")
3263
3241
def ClientAdded(self, objpath):
3264
3242
"D-Bus signal"
3265
3243
pass
3266
3244
3267
3245
@dbus.service.signal(_interface, signature="ss")
3268
3246
def ClientNotFound(self, fingerprint, address):
3269
3247
"D-Bus signal"
3270
3248
pass
3271
3249
3272
3250
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3273
3251
"true"})
3274
3252
@dbus.service.signal(_interface, signature="os")
3275
3253
def ClientRemoved(self, objpath, name):
3276
3254
"D-Bus signal"
3277
3255
pass
3278
3256
3279
3257
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3280
3258
"true"})
3281
3259
@dbus.service.method(_interface, out_signature="ao")
3283
3261
"D-Bus method"
3284
3262
return dbus.Array(c.dbus_object_path for c in
3285
3263
tcp_server.clients.values())
3286
3264
3287
3265
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3288
3266
"true"})
3289
3267
@dbus.service.method(_interface,
3291
3269
def GetAllClientsWithProperties(self):
3292
3270
"D-Bus method"
3293
3271
return dbus.Dictionary(
3294
{c.dbus_object_path: c.GetAll(
3272
{ c.dbus_object_path: c.GetAll(
3295
3273
"se.recompile.Mandos.Client")
3296
for c in tcp_server.clients.values()},
3274
for c in tcp_server.clients.values() },
3297
3275
signature="oa{sv}")
3298
3276
3299
3277
@dbus.service.method(_interface, in_signature="o")
3300
3278
def RemoveClient(self, object_path):
3301
3279
"D-Bus method"
3309
3287
self.client_removed_signal(c)
3310
3288
return
3311
3289
raise KeyError(object_path)
3312
3290
3313
3291
del _interface
3314
3292
3315
3293
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3316
out_signature="a{oa{sa{sv}}}")
3294
out_signature = "a{oa{sa{sv}}}")
3317
3295
def GetManagedObjects(self):
3318
3296
"""D-Bus method"""
3319
3297
return dbus.Dictionary(
3320
{client.dbus_object_path:
3321
dbus.Dictionary(
3322
{interface: client.GetAll(interface)
3323
for interface in
3324
client._get_all_interface_names()})
3325
for client in tcp_server.clients.values()})
3326
3298
{ client.dbus_object_path:
3299
dbus.Dictionary(
3300
{ interface: client.GetAll(interface)
3301
for interface in
3302
client._get_all_interface_names()})
3303
for client in tcp_server.clients.values()})
3304
3327
3305
def client_added_signal(self, client):
3328
3306
"""Send the new standard signal and the old signal"""
3329
3307
if use_dbus:
3331
3309
self.InterfacesAdded(
3332
3310
client.dbus_object_path,
3333
3311
dbus.Dictionary(
3334
{interface: client.GetAll(interface)
3335
for interface in
3336
client._get_all_interface_names()}))
3312
{ interface: client.GetAll(interface)
3313
for interface in
3314
client._get_all_interface_names()}))
3337
3315
# Old signal
3338
3316
self.ClientAdded(client.dbus_object_path)
3339
3317
3340
3318
def client_removed_signal(self, client):
3341
3319
"""Send the new standard signal and the old signal"""
3342
3320
if use_dbus:
3347
3325
# Old signal
3348
3326
self.ClientRemoved(client.dbus_object_path,
3349
3327
client.name)
3350
3328
3351
3329
mandos_dbus_service = MandosDBusService()
3352
3330
3353
3331
# Save modules to variables to exempt the modules from being
3354
3332
# unloaded before the function registered with atexit() is run.
3355
3333
mp = multiprocessing
3356
3334
wn = wnull
3357
3358
3335
def cleanup():
3359
3336
"Cleanup function; run on exit"
3360
3337
if zeroconf:
3361
3338
service.cleanup()
3362
3339
3363
3340
mp.active_children()
3364
3341
wn.close()
3365
3342
if not (tcp_server.clients or client_settings):
3366
3343
return
3367
3344
3368
3345
# Store client before exiting. Secrets are encrypted with key
3369
3346
# based on what config file has. If config file is
3370
3347
# removed/edited, old secret will thus be unrecovable.
3375
3352
client.encrypted_secret = pgp.encrypt(client.secret,
3376
3353
key)
3377
3354
client_dict = {}
3378
3355
3379
3356
# A list of attributes that can not be pickled
3380
3357
# + secret.
3381
exclude = {"bus", "changedstate", "secret",
3382
"checker", "server_settings"}
3358
exclude = { "bus", "changedstate", "secret",
3359
"checker", "server_settings" }
3383
3360
for name, typ in inspect.getmembers(dbus.service
3384
3361
.Object):
3385
3362
exclude.add(name)
3386
3363
3387
3364
client_dict["encrypted_secret"] = (client
3388
3365
.encrypted_secret)
3389
3366
for attr in client.client_structure:
3390
3367
if attr not in exclude:
3391
3368
client_dict[attr] = getattr(client, attr)
3392
3369
3393
3370
clients[client.name] = client_dict
3394
3371
del client_settings[client.name]["secret"]
3395
3372
3396
3373
try:
3397
3374
with tempfile.NamedTemporaryFile(
3398
3375
mode='wb',
3401
3378
dir=os.path.dirname(stored_state_path),
3402
3379
delete=False) as stored_state:
3403
3380
pickle.dump((clients, client_settings), stored_state,
3404
protocol=2)
3381
protocol = 2)
3405
3382
tempname = stored_state.name
3406
3383
os.rename(tempname, stored_state_path)
3407
3384
except (IOError, OSError) as e:
3417
3394
logger.warning("Could not save persistent state:",
3418
3395
exc_info=e)
3419
3396
raise
3420
3397
3421
3398
# Delete all clients, and settings from config
3422
3399
while tcp_server.clients:
3423
3400
name, client = tcp_server.clients.popitem()
3429
3406
if use_dbus:
3430
3407
mandos_dbus_service.client_removed_signal(client)
3431
3408
client_settings.clear()
3432
3409
3433
3410
atexit.register(cleanup)
3434
3411
3435
3412
for client in tcp_server.clients.values():
3436
3413
if use_dbus:
3437
3414
# Emit D-Bus signal for adding
3439
3416
# Need to initiate checking of clients
3440
3417
if client.enabled:
3441
3418
client.init_checker()
3442
3419
3443
3420
tcp_server.enable()
3444
3421
tcp_server.server_activate()
3445
3422
3446
3423
# Find out what port we got
3447
3424
if zeroconf:
3448
3425
service.port = tcp_server.socket.getsockname()[1]
3453
3430
else: # IPv4
3454
3431
logger.info("Now listening on address %r, port %d",
3455
3432
*tcp_server.socket.getsockname())
3456
3457
# service.interface = tcp_server.socket.getsockname()[3]
3458
3433
3434
#service.interface = tcp_server.socket.getsockname()[3]
3435
3459
3436
try:
3460
3437
if zeroconf:
3461
3438
# From the Avahi example code
3466
3443
cleanup()
3467
3444
sys.exit(1)
3468
3445
# End of Avahi example code
3469
3446
3470
3447
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3471
3448
lambda *args, **kwargs:
3472
3449
(tcp_server.handle_request
3473
3450
(*args[2:], **kwargs) or True))
3474
3451
3475
3452
logger.debug("Starting main loop")
3476
3453
main_loop.run()
3477
3454
except AvahiError as error:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0