/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2019-04-10 20:33:13 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190410203313-d3ufer20hfws7i3h
Improve language in intro(8mandos) manual page

* intro.xml (INTRODUCTION): Replace "it" with "the data" to fix bad
                            reference, and clarify that it is the
                            client which continues booting.

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