/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2018-02-06 20:03:50 UTC
  • Revision ID: teddy@recompile.se-20180206200350-jzvorueb731xkph3
Update Debian Debhelper compatibility version.

* (debian/compat): Change to "10".

Show diffs side-by-side

added added

removed removed

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