/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2016-03-17 20:40:55 UTC
  • Revision ID: teddy@recompile.se-20160317204055-bhsh5xsidq7w5cxu
Client: Fix plymouth agent; broken since 1.7.2.

Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2.  This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.

* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
  allocating new_argv.  Also tolerate a zero-length argv.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#!/usr/bin/python
2
 
# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
3
 
#
 
2
# -*- mode: python; coding: utf-8 -*-
 
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-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
 
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
21
19
# the Free Software Foundation, either version 3 of the License, or
22
20
# (at your option) any later version.
23
21
#
24
 
#     Mandos is distributed in the hope that it will be useful, but
25
 
#     WITHOUT ANY WARRANTY; without even the implied warranty of
 
22
#     This program is distributed in the hope that it will be useful,
 
23
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
26
24
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27
25
#     GNU General Public License for more details.
28
 
#
 
26
29
27
# You should have received a copy of the GNU General Public License
30
 
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
31
 
#
 
28
# along with this program.  If not, see
 
29
# <http://www.gnu.org/licenses/>.
 
30
32
31
# Contact the authors at <mandos@recompile.se>.
33
 
#
 
32
34
33
 
35
34
from __future__ import (division, absolute_import, print_function,
36
35
                        unicode_literals)
77
76
import itertools
78
77
import collections
79
78
import codecs
80
 
import unittest
81
79
 
82
80
import dbus
83
81
import dbus.service
84
 
import gi
85
82
from gi.repository import GLib
86
83
from dbus.mainloop.glib import DBusGMainLoop
87
84
import ctypes
89
86
import xml.dom.minidom
90
87
import inspect
91
88
 
92
 
if sys.version_info.major == 2:
93
 
    __metaclass__ = type
94
 
 
95
 
# Show warnings by default
96
 
if not sys.warnoptions:
97
 
    import warnings
98
 
    warnings.simplefilter("default")
99
 
 
100
 
# Try to find the value of SO_BINDTODEVICE:
101
89
try:
102
 
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
103
 
    # newer, and it is also the most natural place for it:
104
90
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
105
91
except AttributeError:
106
92
    try:
107
 
        # This is where SO_BINDTODEVICE was up to and including Python
108
 
        # 2.6, and also 3.2:
109
93
        from IN import SO_BINDTODEVICE
110
94
    except ImportError:
111
 
        # In Python 2.7 it seems to have been removed entirely.
112
 
        # Try running the C preprocessor:
113
 
        try:
114
 
            cc = subprocess.Popen(["cc", "--language=c", "-E",
115
 
                                   "/dev/stdin"],
116
 
                                  stdin=subprocess.PIPE,
117
 
                                  stdout=subprocess.PIPE)
118
 
            stdout = cc.communicate(
119
 
                "#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
120
 
            SO_BINDTODEVICE = int(stdout.splitlines()[-1])
121
 
        except (OSError, ValueError, IndexError):
122
 
            # No value found
123
 
            SO_BINDTODEVICE = None
 
95
        SO_BINDTODEVICE = None
124
96
 
125
97
if sys.version_info.major == 2:
126
98
    str = unicode
127
99
 
128
 
if sys.version_info < (3, 2):
129
 
    configparser.Configparser = configparser.SafeConfigParser
130
 
 
131
 
version = "1.8.8"
 
100
version = "1.7.6"
132
101
stored_state_file = "clients.pickle"
133
102
 
134
103
logger = logging.getLogger()
135
 
logging.captureWarnings(True)   # Show warnings via the logging system
136
104
syslogger = None
137
105
 
138
106
try:
139
107
    if_nametoindex = ctypes.cdll.LoadLibrary(
140
108
        ctypes.util.find_library("c")).if_nametoindex
141
109
except (OSError, AttributeError):
142
 
 
 
110
    
143
111
    def if_nametoindex(interface):
144
112
        "Get an interface index the hard way, i.e. using fcntl()"
145
113
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
168
136
 
169
137
def initlogger(debug, level=logging.WARNING):
170
138
    """init logger and add loglevel"""
171
 
 
 
139
    
172
140
    global syslogger
173
141
    syslogger = (logging.handlers.SysLogHandler(
174
 
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
175
 
        address="/dev/log"))
 
142
        facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
143
        address = "/dev/log"))
176
144
    syslogger.setFormatter(logging.Formatter
177
145
                           ('Mandos [%(process)d]: %(levelname)s:'
178
146
                            ' %(message)s'))
179
147
    logger.addHandler(syslogger)
180
 
 
 
148
    
181
149
    if debug:
182
150
        console = logging.StreamHandler()
183
151
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
193
161
    pass
194
162
 
195
163
 
196
 
class PGPEngine:
 
164
class PGPEngine(object):
197
165
    """A simple class for OpenPGP symmetric encryption & decryption"""
198
 
 
 
166
    
199
167
    def __init__(self):
200
168
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
201
169
        self.gpg = "gpg"
212
180
        self.gnupgargs = ['--batch',
213
181
                          '--homedir', self.tempdir,
214
182
                          '--force-mdc',
215
 
                          '--quiet']
216
 
        # Only GPG version 1 has the --no-use-agent option.
217
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
218
 
            self.gnupgargs.append("--no-use-agent")
219
 
 
 
183
                          '--quiet',
 
184
                          '--no-use-agent']
 
185
    
220
186
    def __enter__(self):
221
187
        return self
222
 
 
 
188
    
223
189
    def __exit__(self, exc_type, exc_value, traceback):
224
190
        self._cleanup()
225
191
        return False
226
 
 
 
192
    
227
193
    def __del__(self):
228
194
        self._cleanup()
229
 
 
 
195
    
230
196
    def _cleanup(self):
231
197
        if self.tempdir is not None:
232
198
            # Delete contents of tempdir
233
199
            for root, dirs, files in os.walk(self.tempdir,
234
 
                                             topdown=False):
 
200
                                             topdown = False):
235
201
                for filename in files:
236
202
                    os.remove(os.path.join(root, filename))
237
203
                for dirname in dirs:
239
205
            # Remove tempdir
240
206
            os.rmdir(self.tempdir)
241
207
            self.tempdir = None
242
 
 
 
208
    
243
209
    def password_encode(self, password):
244
210
        # Passphrase can not be empty and can not contain newlines or
245
211
        # NUL bytes.  So we prefix it and hex encode it.
250
216
                       .replace(b"\n", b"\\n")
251
217
                       .replace(b"\0", b"\\x00"))
252
218
        return encoded
253
 
 
 
219
    
254
220
    def encrypt(self, data, password):
255
221
        passphrase = self.password_encode(password)
256
222
        with tempfile.NamedTemporaryFile(
261
227
                                     '--passphrase-file',
262
228
                                     passfile.name]
263
229
                                    + self.gnupgargs,
264
 
                                    stdin=subprocess.PIPE,
265
 
                                    stdout=subprocess.PIPE,
266
 
                                    stderr=subprocess.PIPE)
267
 
            ciphertext, err = proc.communicate(input=data)
 
230
                                    stdin = subprocess.PIPE,
 
231
                                    stdout = subprocess.PIPE,
 
232
                                    stderr = subprocess.PIPE)
 
233
            ciphertext, err = proc.communicate(input = data)
268
234
        if proc.returncode != 0:
269
235
            raise PGPError(err)
270
236
        return ciphertext
271
 
 
 
237
    
272
238
    def decrypt(self, data, password):
273
239
        passphrase = self.password_encode(password)
274
240
        with tempfile.NamedTemporaryFile(
275
 
                dir=self.tempdir) as passfile:
 
241
                dir = self.tempdir) as passfile:
276
242
            passfile.write(passphrase)
277
243
            passfile.flush()
278
244
            proc = subprocess.Popen([self.gpg, '--decrypt',
279
245
                                     '--passphrase-file',
280
246
                                     passfile.name]
281
247
                                    + self.gnupgargs,
282
 
                                    stdin=subprocess.PIPE,
283
 
                                    stdout=subprocess.PIPE,
284
 
                                    stderr=subprocess.PIPE)
285
 
            decrypted_plaintext, err = proc.communicate(input=data)
 
248
                                    stdin = subprocess.PIPE,
 
249
                                    stdout = subprocess.PIPE,
 
250
                                    stderr = subprocess.PIPE)
 
251
            decrypted_plaintext, err = proc.communicate(input = data)
286
252
        if proc.returncode != 0:
287
253
            raise PGPError(err)
288
254
        return decrypted_plaintext
289
255
 
290
 
 
291
256
# Pretend that we have an Avahi module
292
 
class avahi:
293
 
    """This isn't so much a class as it is a module-like namespace."""
294
 
    IF_UNSPEC = -1               # avahi-common/address.h
295
 
    PROTO_UNSPEC = -1            # avahi-common/address.h
296
 
    PROTO_INET = 0               # avahi-common/address.h
297
 
    PROTO_INET6 = 1              # avahi-common/address.h
 
257
class Avahi(object):
 
258
    """This isn't so much a class as it is a module-like namespace.
 
259
    It is instantiated once, and simulates having an Avahi module."""
 
260
    IF_UNSPEC = -1              # avahi-common/address.h
 
261
    PROTO_UNSPEC = -1           # avahi-common/address.h
 
262
    PROTO_INET = 0              # avahi-common/address.h
 
263
    PROTO_INET6 = 1             # avahi-common/address.h
298
264
    DBUS_NAME = "org.freedesktop.Avahi"
299
265
    DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
300
266
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
301
267
    DBUS_PATH_SERVER = "/"
302
 
 
303
 
    @staticmethod
304
 
    def string_array_to_txt_array(t):
 
268
    def string_array_to_txt_array(self, t):
305
269
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
306
270
                           for s in t), signature="ay")
307
 
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
308
 
    ENTRY_GROUP_COLLISION = 3    # avahi-common/defs.h
309
 
    ENTRY_GROUP_FAILURE = 4      # avahi-common/defs.h
310
 
    SERVER_INVALID = 0           # avahi-common/defs.h
311
 
    SERVER_REGISTERING = 1       # avahi-common/defs.h
312
 
    SERVER_RUNNING = 2           # avahi-common/defs.h
313
 
    SERVER_COLLISION = 3         # avahi-common/defs.h
314
 
    SERVER_FAILURE = 4           # avahi-common/defs.h
315
 
 
 
271
    ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
 
272
    ENTRY_GROUP_COLLISION = 3   # avahi-common/defs.h
 
273
    ENTRY_GROUP_FAILURE = 4     # avahi-common/defs.h
 
274
    SERVER_INVALID = 0          # avahi-common/defs.h
 
275
    SERVER_REGISTERING = 1      # avahi-common/defs.h
 
276
    SERVER_RUNNING = 2          # avahi-common/defs.h
 
277
    SERVER_COLLISION = 3        # avahi-common/defs.h
 
278
    SERVER_FAILURE = 4          # avahi-common/defs.h
 
279
avahi = Avahi()
316
280
 
317
281
class AvahiError(Exception):
318
282
    def __init__(self, value, *args, **kwargs):
329
293
    pass
330
294
 
331
295
 
332
 
class AvahiService:
 
296
class AvahiService(object):
333
297
    """An Avahi (Zeroconf) service.
334
 
 
 
298
    
335
299
    Attributes:
336
300
    interface: integer; avahi.IF_UNSPEC or an interface index.
337
301
               Used to optionally bind to the specified interface.
349
313
    server: D-Bus Server
350
314
    bus: dbus.SystemBus()
351
315
    """
352
 
 
 
316
    
353
317
    def __init__(self,
354
 
                 interface=avahi.IF_UNSPEC,
355
 
                 name=None,
356
 
                 servicetype=None,
357
 
                 port=None,
358
 
                 TXT=None,
359
 
                 domain="",
360
 
                 host="",
361
 
                 max_renames=32768,
362
 
                 protocol=avahi.PROTO_UNSPEC,
363
 
                 bus=None):
 
318
                 interface = avahi.IF_UNSPEC,
 
319
                 name = None,
 
320
                 servicetype = None,
 
321
                 port = None,
 
322
                 TXT = None,
 
323
                 domain = "",
 
324
                 host = "",
 
325
                 max_renames = 32768,
 
326
                 protocol = avahi.PROTO_UNSPEC,
 
327
                 bus = None):
364
328
        self.interface = interface
365
329
        self.name = name
366
330
        self.type = servicetype
375
339
        self.server = None
376
340
        self.bus = bus
377
341
        self.entry_group_state_changed_match = None
378
 
 
 
342
    
379
343
    def rename(self, remove=True):
380
344
        """Derived from the Avahi example code"""
381
345
        if self.rename_count >= self.max_renames:
401
365
                logger.critical("D-Bus Exception", exc_info=error)
402
366
                self.cleanup()
403
367
                os._exit(1)
404
 
 
 
368
    
405
369
    def remove(self):
406
370
        """Derived from the Avahi example code"""
407
371
        if self.entry_group_state_changed_match is not None:
409
373
            self.entry_group_state_changed_match = None
410
374
        if self.group is not None:
411
375
            self.group.Reset()
412
 
 
 
376
    
413
377
    def add(self):
414
378
        """Derived from the Avahi example code"""
415
379
        self.remove()
432
396
            dbus.UInt16(self.port),
433
397
            avahi.string_array_to_txt_array(self.TXT))
434
398
        self.group.Commit()
435
 
 
 
399
    
436
400
    def entry_group_state_changed(self, state, error):
437
401
        """Derived from the Avahi example code"""
438
402
        logger.debug("Avahi entry group state change: %i", state)
439
 
 
 
403
        
440
404
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
441
405
            logger.debug("Zeroconf service established.")
442
406
        elif state == avahi.ENTRY_GROUP_COLLISION:
446
410
            logger.critical("Avahi: Error in group state changed %s",
447
411
                            str(error))
448
412
            raise AvahiGroupError("State changed: {!s}".format(error))
449
 
 
 
413
    
450
414
    def cleanup(self):
451
415
        """Derived from the Avahi example code"""
452
416
        if self.group is not None:
457
421
                pass
458
422
            self.group = None
459
423
        self.remove()
460
 
 
 
424
    
461
425
    def server_state_changed(self, state, error=None):
462
426
        """Derived from the Avahi example code"""
463
427
        logger.debug("Avahi server state change: %i", state)
492
456
                logger.debug("Unknown state: %r", state)
493
457
            else:
494
458
                logger.debug("Unknown state: %r: %r", state, error)
495
 
 
 
459
    
496
460
    def activate(self):
497
461
        """Derived from the Avahi example code"""
498
462
        if self.server is None:
509
473
class AvahiServiceToSyslog(AvahiService):
510
474
    def rename(self, *args, **kwargs):
511
475
        """Add the new name to the syslog messages"""
512
 
        ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
 
476
        ret = AvahiService.rename(self, *args, **kwargs)
513
477
        syslogger.setFormatter(logging.Formatter(
514
478
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
515
479
            .format(self.name)))
516
480
        return ret
517
481
 
518
 
 
519
482
# Pretend that we have a GnuTLS module
520
 
class gnutls:
521
 
    """This isn't so much a class as it is a module-like namespace."""
522
 
 
523
 
    library = ctypes.util.find_library("gnutls")
524
 
    if library is None:
525
 
        library = ctypes.util.find_library("gnutls-deb0")
526
 
    _library = ctypes.cdll.LoadLibrary(library)
527
 
    del library
528
 
 
 
483
class GnuTLS(object):
 
484
    """This isn't so much a class as it is a module-like namespace.
 
485
    It is instantiated once, and simulates having a GnuTLS module."""
 
486
    
 
487
    _library = ctypes.cdll.LoadLibrary(
 
488
        ctypes.util.find_library("gnutls"))
 
489
    _need_version = b"3.3.0"
 
490
    def __init__(self):
 
491
        # Need to use class name "GnuTLS" here, since this method is
 
492
        # called before the assignment to the "gnutls" global variable
 
493
        # happens.
 
494
        if GnuTLS.check_version(self._need_version) is None:
 
495
            raise GnuTLS.Error("Needs GnuTLS {} or later"
 
496
                               .format(self._need_version))
 
497
    
529
498
    # Unless otherwise indicated, the constants and types below are
530
499
    # all from the gnutls/gnutls.h C header file.
531
 
 
 
500
    
532
501
    # Constants
533
502
    E_SUCCESS = 0
534
503
    E_INTERRUPTED = -52
535
504
    E_AGAIN = -28
536
505
    CRT_OPENPGP = 2
537
 
    CRT_RAWPK = 3
538
506
    CLIENT = 2
539
507
    SHUT_RDWR = 0
540
508
    CRD_CERTIFICATE = 1
541
509
    E_NO_CERTIFICATE_FOUND = -49
542
 
    X509_FMT_DER = 0
543
 
    NO_TICKETS = 1<<10
544
 
    ENABLE_RAWPK = 1<<18
545
 
    CTYPE_PEERS = 3
546
 
    KEYID_USE_SHA256 = 1        # gnutls/x509.h
547
510
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
548
 
 
 
511
    
549
512
    # Types
550
513
    class session_int(ctypes.Structure):
551
514
        _fields_ = []
552
515
    session_t = ctypes.POINTER(session_int)
553
 
 
554
516
    class certificate_credentials_st(ctypes.Structure):
555
517
        _fields_ = []
556
518
    certificate_credentials_t = ctypes.POINTER(
557
519
        certificate_credentials_st)
558
520
    certificate_type_t = ctypes.c_int
559
 
 
560
521
    class datum_t(ctypes.Structure):
561
522
        _fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
562
523
                    ('size', ctypes.c_uint)]
563
 
 
564
524
    class openpgp_crt_int(ctypes.Structure):
565
525
        _fields_ = []
566
526
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
567
 
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
 
527
    openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
568
528
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
569
529
    credentials_type_t = ctypes.c_int
570
530
    transport_ptr_t = ctypes.c_void_p
571
531
    close_request_t = ctypes.c_int
572
 
 
 
532
    
573
533
    # Exceptions
574
534
    class Error(Exception):
575
 
        def __init__(self, message=None, code=None, args=()):
 
535
        # We need to use the class name "GnuTLS" here, since this
 
536
        # exception might be raised from within GnuTLS.__init__,
 
537
        # which is called before the assignment to the "gnutls"
 
538
        # global variable has happened.
 
539
        def __init__(self, message = None, code = None, args=()):
576
540
            # Default usage is by a message string, but if a return
577
541
            # code is passed, convert it to a string with
578
542
            # gnutls.strerror()
579
543
            self.code = code
580
544
            if message is None and code is not None:
581
 
                message = gnutls.strerror(code)
582
 
            return super(gnutls.Error, self).__init__(
 
545
                message = GnuTLS.strerror(code)
 
546
            return super(GnuTLS.Error, self).__init__(
583
547
                message, *args)
584
 
 
 
548
    
585
549
    class CertificateSecurityError(Error):
586
550
        pass
587
 
 
 
551
    
588
552
    # Classes
589
 
    class Credentials:
 
553
    class Credentials(object):
590
554
        def __init__(self):
591
555
            self._c_object = gnutls.certificate_credentials_t()
592
556
            gnutls.certificate_allocate_credentials(
593
557
                ctypes.byref(self._c_object))
594
558
            self.type = gnutls.CRD_CERTIFICATE
595
 
 
 
559
        
596
560
        def __del__(self):
597
561
            gnutls.certificate_free_credentials(self._c_object)
598
 
 
599
 
    class ClientSession:
600
 
        def __init__(self, socket, credentials=None):
 
562
    
 
563
    class ClientSession(object):
 
564
        def __init__(self, socket, credentials = None):
601
565
            self._c_object = gnutls.session_t()
602
 
            gnutls_flags = gnutls.CLIENT
603
 
            if gnutls.check_version(b"3.5.6"):
604
 
                gnutls_flags |= gnutls.NO_TICKETS
605
 
            if gnutls.has_rawpk:
606
 
                gnutls_flags |= gnutls.ENABLE_RAWPK
607
 
            gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
608
 
            del gnutls_flags
 
566
            gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
609
567
            gnutls.set_default_priority(self._c_object)
610
568
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
611
569
            gnutls.handshake_set_private_extensions(self._c_object,
617
575
                                   ctypes.cast(credentials._c_object,
618
576
                                               ctypes.c_void_p))
619
577
            self.credentials = credentials
620
 
 
 
578
        
621
579
        def __del__(self):
622
580
            gnutls.deinit(self._c_object)
623
 
 
 
581
        
624
582
        def handshake(self):
625
583
            return gnutls.handshake(self._c_object)
626
 
 
 
584
        
627
585
        def send(self, data):
628
586
            data = bytes(data)
629
587
            data_len = len(data)
631
589
                data_len -= gnutls.record_send(self._c_object,
632
590
                                               data[-data_len:],
633
591
                                               data_len)
634
 
 
 
592
        
635
593
        def bye(self):
636
594
            return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
637
 
 
 
595
    
638
596
    # Error handling functions
639
597
    def _error_code(result):
640
598
        """A function to raise exceptions on errors, suitable
642
600
        if result >= 0:
643
601
            return result
644
602
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
645
 
            raise gnutls.CertificateSecurityError(code=result)
646
 
        raise gnutls.Error(code=result)
647
 
 
 
603
            raise gnutls.CertificateSecurityError(code = result)
 
604
        raise gnutls.Error(code = result)
 
605
    
648
606
    def _retry_on_error(result, func, arguments):
649
607
        """A function to retry on some errors, suitable
650
608
        for the 'errcheck' attribute on ctypes functions"""
653
611
                return _error_code(result)
654
612
            result = func(*arguments)
655
613
        return result
656
 
 
 
614
    
657
615
    # Unless otherwise indicated, the function declarations below are
658
616
    # all from the gnutls/gnutls.h C header file.
659
 
 
 
617
    
660
618
    # Functions
661
619
    priority_set_direct = _library.gnutls_priority_set_direct
662
620
    priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
663
621
                                    ctypes.POINTER(ctypes.c_char_p)]
664
622
    priority_set_direct.restype = _error_code
665
 
 
 
623
    
666
624
    init = _library.gnutls_init
667
625
    init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
668
626
    init.restype = _error_code
669
 
 
 
627
    
670
628
    set_default_priority = _library.gnutls_set_default_priority
671
629
    set_default_priority.argtypes = [session_t]
672
630
    set_default_priority.restype = _error_code
673
 
 
 
631
    
674
632
    record_send = _library.gnutls_record_send
675
633
    record_send.argtypes = [session_t, ctypes.c_void_p,
676
634
                            ctypes.c_size_t]
677
635
    record_send.restype = ctypes.c_ssize_t
678
636
    record_send.errcheck = _retry_on_error
679
 
 
 
637
    
680
638
    certificate_allocate_credentials = (
681
639
        _library.gnutls_certificate_allocate_credentials)
682
640
    certificate_allocate_credentials.argtypes = [
683
641
        ctypes.POINTER(certificate_credentials_t)]
684
642
    certificate_allocate_credentials.restype = _error_code
685
 
 
 
643
    
686
644
    certificate_free_credentials = (
687
645
        _library.gnutls_certificate_free_credentials)
688
 
    certificate_free_credentials.argtypes = [
689
 
        certificate_credentials_t]
 
646
    certificate_free_credentials.argtypes = [certificate_credentials_t]
690
647
    certificate_free_credentials.restype = None
691
 
 
 
648
    
692
649
    handshake_set_private_extensions = (
693
650
        _library.gnutls_handshake_set_private_extensions)
694
651
    handshake_set_private_extensions.argtypes = [session_t,
695
652
                                                 ctypes.c_int]
696
653
    handshake_set_private_extensions.restype = None
697
 
 
 
654
    
698
655
    credentials_set = _library.gnutls_credentials_set
699
656
    credentials_set.argtypes = [session_t, credentials_type_t,
700
657
                                ctypes.c_void_p]
701
658
    credentials_set.restype = _error_code
702
 
 
 
659
    
703
660
    strerror = _library.gnutls_strerror
704
661
    strerror.argtypes = [ctypes.c_int]
705
662
    strerror.restype = ctypes.c_char_p
706
 
 
 
663
    
707
664
    certificate_type_get = _library.gnutls_certificate_type_get
708
665
    certificate_type_get.argtypes = [session_t]
709
666
    certificate_type_get.restype = _error_code
710
 
 
 
667
    
711
668
    certificate_get_peers = _library.gnutls_certificate_get_peers
712
669
    certificate_get_peers.argtypes = [session_t,
713
670
                                      ctypes.POINTER(ctypes.c_uint)]
714
671
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
715
 
 
 
672
    
716
673
    global_set_log_level = _library.gnutls_global_set_log_level
717
674
    global_set_log_level.argtypes = [ctypes.c_int]
718
675
    global_set_log_level.restype = None
719
 
 
 
676
    
720
677
    global_set_log_function = _library.gnutls_global_set_log_function
721
678
    global_set_log_function.argtypes = [log_func]
722
679
    global_set_log_function.restype = None
723
 
 
 
680
    
724
681
    deinit = _library.gnutls_deinit
725
682
    deinit.argtypes = [session_t]
726
683
    deinit.restype = None
727
 
 
 
684
    
728
685
    handshake = _library.gnutls_handshake
729
686
    handshake.argtypes = [session_t]
730
687
    handshake.restype = _error_code
731
688
    handshake.errcheck = _retry_on_error
732
 
 
 
689
    
733
690
    transport_set_ptr = _library.gnutls_transport_set_ptr
734
691
    transport_set_ptr.argtypes = [session_t, transport_ptr_t]
735
692
    transport_set_ptr.restype = None
736
 
 
 
693
    
737
694
    bye = _library.gnutls_bye
738
695
    bye.argtypes = [session_t, close_request_t]
739
696
    bye.restype = _error_code
740
697
    bye.errcheck = _retry_on_error
741
 
 
 
698
    
742
699
    check_version = _library.gnutls_check_version
743
700
    check_version.argtypes = [ctypes.c_char_p]
744
701
    check_version.restype = ctypes.c_char_p
745
 
 
746
 
    _need_version = b"3.3.0"
747
 
    if check_version(_need_version) is None:
748
 
        raise self.Error("Needs GnuTLS {} or later"
749
 
                         .format(_need_version))
750
 
 
751
 
    _tls_rawpk_version = b"3.6.6"
752
 
    has_rawpk = bool(check_version(_tls_rawpk_version))
753
 
 
754
 
    if has_rawpk:
755
 
        # Types
756
 
        class pubkey_st(ctypes.Structure):
757
 
            _fields = []
758
 
        pubkey_t = ctypes.POINTER(pubkey_st)
759
 
 
760
 
        x509_crt_fmt_t = ctypes.c_int
761
 
 
762
 
        # All the function declarations below are from gnutls/abstract.h
763
 
        pubkey_init = _library.gnutls_pubkey_init
764
 
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
765
 
        pubkey_init.restype = _error_code
766
 
 
767
 
        pubkey_import = _library.gnutls_pubkey_import
768
 
        pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
769
 
                                  x509_crt_fmt_t]
770
 
        pubkey_import.restype = _error_code
771
 
 
772
 
        pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
773
 
        pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
774
 
                                      ctypes.POINTER(ctypes.c_ubyte),
775
 
                                      ctypes.POINTER(ctypes.c_size_t)]
776
 
        pubkey_get_key_id.restype = _error_code
777
 
 
778
 
        pubkey_deinit = _library.gnutls_pubkey_deinit
779
 
        pubkey_deinit.argtypes = [pubkey_t]
780
 
        pubkey_deinit.restype = None
781
 
    else:
782
 
        # All the function declarations below are from gnutls/openpgp.h
783
 
 
784
 
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
785
 
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
786
 
        openpgp_crt_init.restype = _error_code
787
 
 
788
 
        openpgp_crt_import = _library.gnutls_openpgp_crt_import
789
 
        openpgp_crt_import.argtypes = [openpgp_crt_t,
790
 
                                       ctypes.POINTER(datum_t),
791
 
                                       openpgp_crt_fmt_t]
792
 
        openpgp_crt_import.restype = _error_code
793
 
 
794
 
        openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
795
 
        openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
796
 
                                            ctypes.POINTER(ctypes.c_uint)]
797
 
        openpgp_crt_verify_self.restype = _error_code
798
 
 
799
 
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
800
 
        openpgp_crt_deinit.argtypes = [openpgp_crt_t]
801
 
        openpgp_crt_deinit.restype = None
802
 
 
803
 
        openpgp_crt_get_fingerprint = (
804
 
            _library.gnutls_openpgp_crt_get_fingerprint)
805
 
        openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
806
 
                                                ctypes.c_void_p,
807
 
                                                ctypes.POINTER(
808
 
                                                    ctypes.c_size_t)]
809
 
        openpgp_crt_get_fingerprint.restype = _error_code
810
 
 
811
 
    if check_version(b"3.6.4"):
812
 
        certificate_type_get2 = _library.gnutls_certificate_type_get2
813
 
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
814
 
        certificate_type_get2.restype = _error_code
815
 
 
 
702
    
 
703
    # All the function declarations below are from gnutls/openpgp.h
 
704
    
 
705
    openpgp_crt_init = _library.gnutls_openpgp_crt_init
 
706
    openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
 
707
    openpgp_crt_init.restype = _error_code
 
708
    
 
709
    openpgp_crt_import = _library.gnutls_openpgp_crt_import
 
710
    openpgp_crt_import.argtypes = [openpgp_crt_t,
 
711
                                   ctypes.POINTER(datum_t),
 
712
                                   openpgp_crt_fmt_t]
 
713
    openpgp_crt_import.restype = _error_code
 
714
    
 
715
    openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
 
716
    openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
 
717
                                        ctypes.POINTER(ctypes.c_uint)]
 
718
    openpgp_crt_verify_self.restype = _error_code
 
719
    
 
720
    openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
 
721
    openpgp_crt_deinit.argtypes = [openpgp_crt_t]
 
722
    openpgp_crt_deinit.restype = None
 
723
    
 
724
    openpgp_crt_get_fingerprint = (
 
725
        _library.gnutls_openpgp_crt_get_fingerprint)
 
726
    openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
 
727
                                            ctypes.c_void_p,
 
728
                                            ctypes.POINTER(
 
729
                                                ctypes.c_size_t)]
 
730
    openpgp_crt_get_fingerprint.restype = _error_code
 
731
    
816
732
    # Remove non-public functions
817
733
    del _error_code, _retry_on_error
818
 
 
 
734
# Create the global "gnutls" object, simulating a module
 
735
gnutls = GnuTLS()
819
736
 
820
737
def call_pipe(connection,       # : multiprocessing.Connection
821
738
              func, *args, **kwargs):
822
739
    """This function is meant to be called by multiprocessing.Process
823
 
 
 
740
    
824
741
    This function runs func(*args, **kwargs), and writes the resulting
825
742
    return value on the provided multiprocessing.Connection.
826
743
    """
827
744
    connection.send(func(*args, **kwargs))
828
745
    connection.close()
829
746
 
830
 
 
831
 
class Client:
 
747
class Client(object):
832
748
    """A representation of a client host served by this server.
833
 
 
 
749
    
834
750
    Attributes:
835
751
    approved:   bool(); 'None' if not yet approved/disapproved
836
752
    approval_delay: datetime.timedelta(); Time to wait for approval
837
753
    approval_duration: datetime.timedelta(); Duration of one approval
838
 
    checker: multiprocessing.Process(); a running checker process used
839
 
             to see if the client lives. 'None' if no process is
840
 
             running.
 
754
    checker:    subprocess.Popen(); a running checker process used
 
755
                                    to see if the client lives.
 
756
                                    'None' if no process is running.
841
757
    checker_callback_tag: a GLib event source tag, or None
842
758
    checker_command: string; External command which is run to check
843
759
                     if client lives.  %() expansions are done at
851
767
    disable_initiator_tag: a GLib event source tag, or None
852
768
    enabled:    bool()
853
769
    fingerprint: string (40 or 32 hexadecimal digits); used to
854
 
                 uniquely identify an OpenPGP client
855
 
    key_id: string (64 hexadecimal digits); used to uniquely identify
856
 
            a client using raw public keys
 
770
                 uniquely identify the client
857
771
    host:       string; available for use by the checker command
858
772
    interval:   datetime.timedelta(); How often to start a new checker
859
773
    last_approval_request: datetime.datetime(); (UTC) or None
875
789
                disabled, or None
876
790
    server_settings: The server_settings dict from main()
877
791
    """
878
 
 
 
792
    
879
793
    runtime_expansions = ("approval_delay", "approval_duration",
880
 
                          "created", "enabled", "expires", "key_id",
 
794
                          "created", "enabled", "expires",
881
795
                          "fingerprint", "host", "interval",
882
796
                          "last_approval_request", "last_checked_ok",
883
797
                          "last_enabled", "name", "timeout")
892
806
        "approved_by_default": "True",
893
807
        "enabled": "True",
894
808
    }
895
 
 
 
809
    
896
810
    @staticmethod
897
811
    def config_parser(config):
898
812
        """Construct a new dict of client settings of this form:
905
819
        for client_name in config.sections():
906
820
            section = dict(config.items(client_name))
907
821
            client = settings[client_name] = {}
908
 
 
 
822
            
909
823
            client["host"] = section["host"]
910
824
            # Reformat values from string types to Python types
911
825
            client["approved_by_default"] = config.getboolean(
912
826
                client_name, "approved_by_default")
913
827
            client["enabled"] = config.getboolean(client_name,
914
828
                                                  "enabled")
915
 
 
916
 
            # Uppercase and remove spaces from key_id and fingerprint
917
 
            # for later comparison purposes with return value from the
918
 
            # key_id() and fingerprint() functions
919
 
            client["key_id"] = (section.get("key_id", "").upper()
920
 
                                .replace(" ", ""))
 
829
            
 
830
            # Uppercase and remove spaces from fingerprint for later
 
831
            # comparison purposes with return value from the
 
832
            # fingerprint() function
921
833
            client["fingerprint"] = (section["fingerprint"].upper()
922
834
                                     .replace(" ", ""))
923
835
            if "secret" in section:
944
856
            client["last_approval_request"] = None
945
857
            client["last_checked_ok"] = None
946
858
            client["last_checker_status"] = -2
947
 
 
 
859
        
948
860
        return settings
949
 
 
950
 
    def __init__(self, settings, name=None, server_settings=None):
 
861
    
 
862
    def __init__(self, settings, name = None, server_settings=None):
951
863
        self.name = name
952
864
        if server_settings is None:
953
865
            server_settings = {}
955
867
        # adding all client settings
956
868
        for setting, value in settings.items():
957
869
            setattr(self, setting, value)
958
 
 
 
870
        
959
871
        if self.enabled:
960
872
            if not hasattr(self, "last_enabled"):
961
873
                self.last_enabled = datetime.datetime.utcnow()
965
877
        else:
966
878
            self.last_enabled = None
967
879
            self.expires = None
968
 
 
 
880
        
969
881
        logger.debug("Creating client %r", self.name)
970
 
        logger.debug("  Key ID: %s", self.key_id)
971
882
        logger.debug("  Fingerprint: %s", self.fingerprint)
972
883
        self.created = settings.get("created",
973
884
                                    datetime.datetime.utcnow())
974
 
 
 
885
        
975
886
        # attributes specific for this server instance
976
887
        self.checker = None
977
888
        self.checker_initiator_tag = None
986
897
                                 for attr in self.__dict__.keys()
987
898
                                 if not attr.startswith("_")]
988
899
        self.client_structure.append("client_structure")
989
 
 
 
900
        
990
901
        for name, t in inspect.getmembers(
991
902
                type(self), lambda obj: isinstance(obj, property)):
992
903
            if not name.startswith("_"):
993
904
                self.client_structure.append(name)
994
 
 
 
905
    
995
906
    # Send notice to process children that client state has changed
996
907
    def send_changedstate(self):
997
908
        with self.changedstate:
998
909
            self.changedstate.notify_all()
999
 
 
 
910
    
1000
911
    def enable(self):
1001
912
        """Start this client's checker and timeout hooks"""
1002
913
        if getattr(self, "enabled", False):
1007
918
        self.last_enabled = datetime.datetime.utcnow()
1008
919
        self.init_checker()
1009
920
        self.send_changedstate()
1010
 
 
 
921
    
1011
922
    def disable(self, quiet=True):
1012
923
        """Disable this client."""
1013
924
        if not getattr(self, "enabled", False):
1027
938
            self.send_changedstate()
1028
939
        # Do not run this again if called by a GLib.timeout_add
1029
940
        return False
1030
 
 
 
941
    
1031
942
    def __del__(self):
1032
943
        self.disable()
1033
 
 
 
944
    
1034
945
    def init_checker(self):
1035
946
        # Schedule a new checker to be started an 'interval' from now,
1036
947
        # and every interval from then on.
1046
957
            int(self.timeout.total_seconds() * 1000), self.disable)
1047
958
        # Also start a new checker *right now*.
1048
959
        self.start_checker()
1049
 
 
 
960
    
1050
961
    def checker_callback(self, source, condition, connection,
1051
962
                         command):
1052
963
        """The checker has completed, so take appropriate actions."""
 
964
        self.checker_callback_tag = None
 
965
        self.checker = None
1053
966
        # Read return code from connection (see call_pipe)
1054
967
        returncode = connection.recv()
1055
968
        connection.close()
1056
 
        self.checker.join()
1057
 
        self.checker_callback_tag = None
1058
 
        self.checker = None
1059
 
 
 
969
        
1060
970
        if returncode >= 0:
1061
971
            self.last_checker_status = returncode
1062
972
            self.last_checker_signal = None
1072
982
            logger.warning("Checker for %(name)s crashed?",
1073
983
                           vars(self))
1074
984
        return False
1075
 
 
 
985
    
1076
986
    def checked_ok(self):
1077
987
        """Assert that the client has been seen, alive and well."""
1078
988
        self.last_checked_ok = datetime.datetime.utcnow()
1079
989
        self.last_checker_status = 0
1080
990
        self.last_checker_signal = None
1081
991
        self.bump_timeout()
1082
 
 
 
992
    
1083
993
    def bump_timeout(self, timeout=None):
1084
994
        """Bump up the timeout for this client."""
1085
995
        if timeout is None:
1091
1001
            self.disable_initiator_tag = GLib.timeout_add(
1092
1002
                int(timeout.total_seconds() * 1000), self.disable)
1093
1003
            self.expires = datetime.datetime.utcnow() + timeout
1094
 
 
 
1004
    
1095
1005
    def need_approval(self):
1096
1006
        self.last_approval_request = datetime.datetime.utcnow()
1097
 
 
 
1007
    
1098
1008
    def start_checker(self):
1099
1009
        """Start a new checker subprocess if one is not running.
1100
 
 
 
1010
        
1101
1011
        If a checker already exists, leave it running and do
1102
1012
        nothing."""
1103
1013
        # The reason for not killing a running checker is that if we
1108
1018
        # checkers alone, the checker would have to take more time
1109
1019
        # than 'timeout' for the client to be disabled, which is as it
1110
1020
        # should be.
1111
 
 
 
1021
        
1112
1022
        if self.checker is not None and not self.checker.is_alive():
1113
1023
            logger.warning("Checker was not alive; joining")
1114
1024
            self.checker.join()
1118
1028
            # Escape attributes for the shell
1119
1029
            escaped_attrs = {
1120
1030
                attr: re.escape(str(getattr(self, attr)))
1121
 
                for attr in self.runtime_expansions}
 
1031
                for attr in self.runtime_expansions }
1122
1032
            try:
1123
1033
                command = self.checker_command % escaped_attrs
1124
1034
            except TypeError as error:
1136
1046
            # The exception is when not debugging but nevertheless
1137
1047
            # running in the foreground; use the previously
1138
1048
            # created wnull.
1139
 
            popen_args = {"close_fds": True,
1140
 
                          "shell": True,
1141
 
                          "cwd": "/"}
 
1049
            popen_args = { "close_fds": True,
 
1050
                           "shell": True,
 
1051
                           "cwd": "/" }
1142
1052
            if (not self.server_settings["debug"]
1143
1053
                and self.server_settings["foreground"]):
1144
1054
                popen_args.update({"stdout": wnull,
1145
 
                                   "stderr": wnull})
1146
 
            pipe = multiprocessing.Pipe(duplex=False)
 
1055
                                   "stderr": wnull })
 
1056
            pipe = multiprocessing.Pipe(duplex = False)
1147
1057
            self.checker = multiprocessing.Process(
1148
 
                target=call_pipe,
1149
 
                args=(pipe[1], subprocess.call, command),
1150
 
                kwargs=popen_args)
 
1058
                target = call_pipe,
 
1059
                args = (pipe[1], subprocess.call, command),
 
1060
                kwargs = popen_args)
1151
1061
            self.checker.start()
1152
1062
            self.checker_callback_tag = GLib.io_add_watch(
1153
 
                GLib.IOChannel.unix_new(pipe[0].fileno()),
1154
 
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
1063
                pipe[0].fileno(), GLib.IO_IN,
1155
1064
                self.checker_callback, pipe[0], command)
1156
1065
        # Re-run this periodically if run by GLib.timeout_add
1157
1066
        return True
1158
 
 
 
1067
    
1159
1068
    def stop_checker(self):
1160
1069
        """Force the checker process, if any, to stop."""
1161
1070
        if self.checker_callback_tag:
1174
1083
                          byte_arrays=False):
1175
1084
    """Decorators for marking methods of a DBusObjectWithProperties to
1176
1085
    become properties on the D-Bus.
1177
 
 
 
1086
    
1178
1087
    The decorated method will be called with no arguments by "Get"
1179
1088
    and with one argument by "Set".
1180
 
 
 
1089
    
1181
1090
    The parameters, where they are supported, are the same as
1182
1091
    dbus.service.method, except there is only "signature", since the
1183
1092
    type from Get() and the type sent to Set() is the same.
1187
1096
    if byte_arrays and signature != "ay":
1188
1097
        raise ValueError("Byte arrays not supported for non-'ay'"
1189
1098
                         " signature {!r}".format(signature))
1190
 
 
 
1099
    
1191
1100
    def decorator(func):
1192
1101
        func._dbus_is_property = True
1193
1102
        func._dbus_interface = dbus_interface
1196
1105
        func._dbus_name = func.__name__
1197
1106
        if func._dbus_name.endswith("_dbus_property"):
1198
1107
            func._dbus_name = func._dbus_name[:-14]
1199
 
        func._dbus_get_args_options = {'byte_arrays': byte_arrays}
 
1108
        func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1200
1109
        return func
1201
 
 
 
1110
    
1202
1111
    return decorator
1203
1112
 
1204
1113
 
1205
1114
def dbus_interface_annotations(dbus_interface):
1206
1115
    """Decorator for marking functions returning interface annotations
1207
 
 
 
1116
    
1208
1117
    Usage:
1209
 
 
 
1118
    
1210
1119
    @dbus_interface_annotations("org.example.Interface")
1211
1120
    def _foo(self):  # Function name does not matter
1212
1121
        return {"org.freedesktop.DBus.Deprecated": "true",
1213
1122
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
1214
1123
                    "false"}
1215
1124
    """
1216
 
 
 
1125
    
1217
1126
    def decorator(func):
1218
1127
        func._dbus_is_interface = True
1219
1128
        func._dbus_interface = dbus_interface
1220
1129
        func._dbus_name = dbus_interface
1221
1130
        return func
1222
 
 
 
1131
    
1223
1132
    return decorator
1224
1133
 
1225
1134
 
1226
1135
def dbus_annotations(annotations):
1227
1136
    """Decorator to annotate D-Bus methods, signals or properties
1228
1137
    Usage:
1229
 
 
 
1138
    
1230
1139
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1231
1140
                       "org.freedesktop.DBus.Property."
1232
1141
                       "EmitsChangedSignal": "false"})
1234
1143
                           access="r")
1235
1144
    def Property_dbus_property(self):
1236
1145
        return dbus.Boolean(False)
1237
 
 
 
1146
    
1238
1147
    See also the DBusObjectWithAnnotations class.
1239
1148
    """
1240
 
 
 
1149
    
1241
1150
    def decorator(func):
1242
1151
        func._dbus_annotations = annotations
1243
1152
        return func
1244
 
 
 
1153
    
1245
1154
    return decorator
1246
1155
 
1247
1156
 
1265
1174
 
1266
1175
class DBusObjectWithAnnotations(dbus.service.Object):
1267
1176
    """A D-Bus object with annotations.
1268
 
 
 
1177
    
1269
1178
    Classes inheriting from this can use the dbus_annotations
1270
1179
    decorator to add annotations to methods or signals.
1271
1180
    """
1272
 
 
 
1181
    
1273
1182
    @staticmethod
1274
1183
    def _is_dbus_thing(thing):
1275
1184
        """Returns a function testing if an attribute is a D-Bus thing
1276
 
 
 
1185
        
1277
1186
        If called like _is_dbus_thing("method") it returns a function
1278
1187
        suitable for use as predicate to inspect.getmembers().
1279
1188
        """
1280
1189
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1281
1190
                                   False)
1282
 
 
 
1191
    
1283
1192
    def _get_all_dbus_things(self, thing):
1284
1193
        """Returns a generator of (name, attribute) pairs
1285
1194
        """
1288
1197
                for cls in self.__class__.__mro__
1289
1198
                for name, athing in
1290
1199
                inspect.getmembers(cls, self._is_dbus_thing(thing)))
1291
 
 
 
1200
    
1292
1201
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1293
 
                         out_signature="s",
1294
 
                         path_keyword='object_path',
1295
 
                         connection_keyword='connection')
 
1202
                         out_signature = "s",
 
1203
                         path_keyword = 'object_path',
 
1204
                         connection_keyword = 'connection')
1296
1205
    def Introspect(self, object_path, connection):
1297
1206
        """Overloading of standard D-Bus method.
1298
 
 
 
1207
        
1299
1208
        Inserts annotation tags on methods and signals.
1300
1209
        """
1301
1210
        xmlstring = dbus.service.Object.Introspect(self, object_path,
1302
1211
                                                   connection)
1303
1212
        try:
1304
1213
            document = xml.dom.minidom.parseString(xmlstring)
1305
 
 
 
1214
            
1306
1215
            for if_tag in document.getElementsByTagName("interface"):
1307
1216
                # Add annotation tags
1308
1217
                for typ in ("method", "signal"):
1335
1244
                    if_tag.appendChild(ann_tag)
1336
1245
                # Fix argument name for the Introspect method itself
1337
1246
                if (if_tag.getAttribute("name")
1338
 
                    == dbus.INTROSPECTABLE_IFACE):
 
1247
                                == dbus.INTROSPECTABLE_IFACE):
1339
1248
                    for cn in if_tag.getElementsByTagName("method"):
1340
1249
                        if cn.getAttribute("name") == "Introspect":
1341
1250
                            for arg in cn.getElementsByTagName("arg"):
1354
1263
 
1355
1264
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1356
1265
    """A D-Bus object with properties.
1357
 
 
 
1266
    
1358
1267
    Classes inheriting from this can use the dbus_service_property
1359
1268
    decorator to expose methods as D-Bus properties.  It exposes the
1360
1269
    standard Get(), Set(), and GetAll() methods on the D-Bus.
1361
1270
    """
1362
 
 
 
1271
    
1363
1272
    def _get_dbus_property(self, interface_name, property_name):
1364
1273
        """Returns a bound method if one exists which is a D-Bus
1365
1274
        property with the specified name and interface.
1370
1279
                if (value._dbus_name == property_name
1371
1280
                    and value._dbus_interface == interface_name):
1372
1281
                    return value.__get__(self)
1373
 
 
 
1282
        
1374
1283
        # No such property
1375
1284
        raise DBusPropertyNotFound("{}:{}.{}".format(
1376
1285
            self.dbus_object_path, interface_name, property_name))
1377
 
 
 
1286
    
1378
1287
    @classmethod
1379
1288
    def _get_all_interface_names(cls):
1380
1289
        """Get a sequence of all interfaces supported by an object"""
1383
1292
                                     for x in (inspect.getmro(cls))
1384
1293
                                     for attr in dir(x))
1385
1294
                if name is not None)
1386
 
 
 
1295
    
1387
1296
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1388
1297
                         in_signature="ss",
1389
1298
                         out_signature="v")
1397
1306
        if not hasattr(value, "variant_level"):
1398
1307
            return value
1399
1308
        return type(value)(value, variant_level=value.variant_level+1)
1400
 
 
 
1309
    
1401
1310
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
1402
1311
    def Set(self, interface_name, property_name, value):
1403
1312
        """Standard D-Bus property Set() method, see D-Bus standard.
1415
1324
            value = dbus.ByteArray(b''.join(chr(byte)
1416
1325
                                            for byte in value))
1417
1326
        prop(value)
1418
 
 
 
1327
    
1419
1328
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1420
1329
                         in_signature="s",
1421
1330
                         out_signature="a{sv}")
1422
1331
    def GetAll(self, interface_name):
1423
1332
        """Standard D-Bus property GetAll() method, see D-Bus
1424
1333
        standard.
1425
 
 
 
1334
        
1426
1335
        Note: Will not include properties with access="write".
1427
1336
        """
1428
1337
        properties = {}
1439
1348
                properties[name] = value
1440
1349
                continue
1441
1350
            properties[name] = type(value)(
1442
 
                value, variant_level=value.variant_level + 1)
 
1351
                value, variant_level = value.variant_level + 1)
1443
1352
        return dbus.Dictionary(properties, signature="sv")
1444
 
 
 
1353
    
1445
1354
    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1446
1355
    def PropertiesChanged(self, interface_name, changed_properties,
1447
1356
                          invalidated_properties):
1449
1358
        standard.
1450
1359
        """
1451
1360
        pass
1452
 
 
 
1361
    
1453
1362
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1454
1363
                         out_signature="s",
1455
1364
                         path_keyword='object_path',
1456
1365
                         connection_keyword='connection')
1457
1366
    def Introspect(self, object_path, connection):
1458
1367
        """Overloading of standard D-Bus method.
1459
 
 
 
1368
        
1460
1369
        Inserts property tags and interface annotation tags.
1461
1370
        """
1462
1371
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
1464
1373
                                                         connection)
1465
1374
        try:
1466
1375
            document = xml.dom.minidom.parseString(xmlstring)
1467
 
 
 
1376
            
1468
1377
            def make_tag(document, name, prop):
1469
1378
                e = document.createElement("property")
1470
1379
                e.setAttribute("name", name)
1471
1380
                e.setAttribute("type", prop._dbus_signature)
1472
1381
                e.setAttribute("access", prop._dbus_access)
1473
1382
                return e
1474
 
 
 
1383
            
1475
1384
            for if_tag in document.getElementsByTagName("interface"):
1476
1385
                # Add property tags
1477
1386
                for tag in (make_tag(document, name, prop)
1519
1428
                         exc_info=error)
1520
1429
        return xmlstring
1521
1430
 
1522
 
 
1523
1431
try:
1524
1432
    dbus.OBJECT_MANAGER_IFACE
1525
1433
except AttributeError:
1526
1434
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1527
1435
 
1528
 
 
1529
1436
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1530
1437
    """A D-Bus object with an ObjectManager.
1531
 
 
 
1438
    
1532
1439
    Classes inheriting from this exposes the standard
1533
1440
    GetManagedObjects call and the InterfacesAdded and
1534
1441
    InterfacesRemoved signals on the standard
1535
1442
    "org.freedesktop.DBus.ObjectManager" interface.
1536
 
 
 
1443
    
1537
1444
    Note: No signals are sent automatically; they must be sent
1538
1445
    manually.
1539
1446
    """
1540
1447
    @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1541
 
                         out_signature="a{oa{sa{sv}}}")
 
1448
                         out_signature = "a{oa{sa{sv}}}")
1542
1449
    def GetManagedObjects(self):
1543
1450
        """This function must be overridden"""
1544
1451
        raise NotImplementedError()
1545
 
 
 
1452
    
1546
1453
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1547
 
                         signature="oa{sa{sv}}")
 
1454
                         signature = "oa{sa{sv}}")
1548
1455
    def InterfacesAdded(self, object_path, interfaces_and_properties):
1549
1456
        pass
1550
 
 
1551
 
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
 
1457
    
 
1458
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1552
1459
    def InterfacesRemoved(self, object_path, interfaces):
1553
1460
        pass
1554
 
 
 
1461
    
1555
1462
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1556
 
                         out_signature="s",
1557
 
                         path_keyword='object_path',
1558
 
                         connection_keyword='connection')
 
1463
                         out_signature = "s",
 
1464
                         path_keyword = 'object_path',
 
1465
                         connection_keyword = 'connection')
1559
1466
    def Introspect(self, object_path, connection):
1560
1467
        """Overloading of standard D-Bus method.
1561
 
 
 
1468
        
1562
1469
        Override return argument name of GetManagedObjects to be
1563
1470
        "objpath_interfaces_and_properties"
1564
1471
        """
1567
1474
                                                         connection)
1568
1475
        try:
1569
1476
            document = xml.dom.minidom.parseString(xmlstring)
1570
 
 
 
1477
            
1571
1478
            for if_tag in document.getElementsByTagName("interface"):
1572
1479
                # Fix argument name for the GetManagedObjects method
1573
1480
                if (if_tag.getAttribute("name")
1574
 
                    == dbus.OBJECT_MANAGER_IFACE):
 
1481
                                == dbus.OBJECT_MANAGER_IFACE):
1575
1482
                    for cn in if_tag.getElementsByTagName("method"):
1576
1483
                        if (cn.getAttribute("name")
1577
1484
                            == "GetManagedObjects"):
1587
1494
        except (AttributeError, xml.dom.DOMException,
1588
1495
                xml.parsers.expat.ExpatError) as error:
1589
1496
            logger.error("Failed to override Introspection method",
1590
 
                         exc_info=error)
 
1497
                         exc_info = error)
1591
1498
        return xmlstring
1592
1499
 
1593
 
 
1594
1500
def datetime_to_dbus(dt, variant_level=0):
1595
1501
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1596
1502
    if dt is None:
1597
 
        return dbus.String("", variant_level=variant_level)
 
1503
        return dbus.String("", variant_level = variant_level)
1598
1504
    return dbus.String(dt.isoformat(), variant_level=variant_level)
1599
1505
 
1600
1506
 
1603
1509
    dbus.service.Object, it will add alternate D-Bus attributes with
1604
1510
    interface names according to the "alt_interface_names" mapping.
1605
1511
    Usage:
1606
 
 
 
1512
    
1607
1513
    @alternate_dbus_interfaces({"org.example.Interface":
1608
1514
                                    "net.example.AlternateInterface"})
1609
1515
    class SampleDBusObject(dbus.service.Object):
1610
1516
        @dbus.service.method("org.example.Interface")
1611
1517
        def SampleDBusMethod():
1612
1518
            pass
1613
 
 
 
1519
    
1614
1520
    The above "SampleDBusMethod" on "SampleDBusObject" will be
1615
1521
    reachable via two interfaces: "org.example.Interface" and
1616
1522
    "net.example.AlternateInterface", the latter of which will have
1617
1523
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1618
1524
    "true", unless "deprecate" is passed with a False value.
1619
 
 
 
1525
    
1620
1526
    This works for methods and signals, and also for D-Bus properties
1621
1527
    (from DBusObjectWithProperties) and interfaces (from the
1622
1528
    dbus_interface_annotations decorator).
1623
1529
    """
1624
 
 
 
1530
    
1625
1531
    def wrapper(cls):
1626
1532
        for orig_interface_name, alt_interface_name in (
1627
1533
                alt_interface_names.items()):
1667
1573
                            attribute._dbus_annotations)
1668
1574
                    except AttributeError:
1669
1575
                        pass
1670
 
 
1671
1576
                    # Define a creator of a function to call both the
1672
1577
                    # original and alternate functions, so both the
1673
1578
                    # original and alternate signals gets sent when
1676
1581
                        """This function is a scope container to pass
1677
1582
                        func1 and func2 to the "call_both" function
1678
1583
                        outside of its arguments"""
1679
 
 
 
1584
                        
1680
1585
                        @functools.wraps(func2)
1681
1586
                        def call_both(*args, **kwargs):
1682
1587
                            """This function will emit two D-Bus
1683
1588
                            signals by calling func1 and func2"""
1684
1589
                            func1(*args, **kwargs)
1685
1590
                            func2(*args, **kwargs)
1686
 
                        # Make wrapper function look like a D-Bus
1687
 
                        # signal
 
1591
                        # Make wrapper function look like a D-Bus signal
1688
1592
                        for name, attr in inspect.getmembers(func2):
1689
1593
                            if name.startswith("_dbus_"):
1690
1594
                                setattr(call_both, name, attr)
1691
 
 
 
1595
                        
1692
1596
                        return call_both
1693
1597
                    # Create the "call_both" function and add it to
1694
1598
                    # the class
1740
1644
                        (copy_function(attribute)))
1741
1645
            if deprecate:
1742
1646
                # Deprecate all alternate interfaces
1743
 
                iname = "_AlternateDBusNames_interface_annotation{}"
 
1647
                iname="_AlternateDBusNames_interface_annotation{}"
1744
1648
                for interface_name in interface_names:
1745
 
 
 
1649
                    
1746
1650
                    @dbus_interface_annotations(interface_name)
1747
1651
                    def func(self):
1748
 
                        return {"org.freedesktop.DBus.Deprecated":
1749
 
                                "true"}
 
1652
                        return { "org.freedesktop.DBus.Deprecated":
 
1653
                                 "true" }
1750
1654
                    # Find an unused name
1751
1655
                    for aname in (iname.format(i)
1752
1656
                                  for i in itertools.count()):
1763
1667
                    cls = type("{}Alternate".format(cls.__name__),
1764
1668
                               (cls, ), attr)
1765
1669
        return cls
1766
 
 
 
1670
    
1767
1671
    return wrapper
1768
1672
 
1769
1673
 
1771
1675
                            "se.bsnet.fukt.Mandos"})
1772
1676
class ClientDBus(Client, DBusObjectWithProperties):
1773
1677
    """A Client class using D-Bus
1774
 
 
 
1678
    
1775
1679
    Attributes:
1776
1680
    dbus_object_path: dbus.ObjectPath
1777
1681
    bus: dbus.SystemBus()
1778
1682
    """
1779
 
 
 
1683
    
1780
1684
    runtime_expansions = (Client.runtime_expansions
1781
1685
                          + ("dbus_object_path", ))
1782
 
 
 
1686
    
1783
1687
    _interface = "se.recompile.Mandos.Client"
1784
 
 
 
1688
    
1785
1689
    # dbus.service.Object doesn't use super(), so we can't either.
1786
 
 
1787
 
    def __init__(self, bus=None, *args, **kwargs):
 
1690
    
 
1691
    def __init__(self, bus = None, *args, **kwargs):
1788
1692
        self.bus = bus
1789
1693
        Client.__init__(self, *args, **kwargs)
1790
1694
        # Only now, when this client is initialized, can it show up on
1796
1700
            "/clients/" + client_object_name)
1797
1701
        DBusObjectWithProperties.__init__(self, self.bus,
1798
1702
                                          self.dbus_object_path)
1799
 
 
 
1703
    
1800
1704
    def notifychangeproperty(transform_func, dbus_name,
1801
1705
                             type_func=lambda x: x,
1802
1706
                             variant_level=1,
1804
1708
                             _interface=_interface):
1805
1709
        """ Modify a variable so that it's a property which announces
1806
1710
        its changes to DBus.
1807
 
 
 
1711
        
1808
1712
        transform_fun: Function that takes a value and a variant_level
1809
1713
                       and transforms it to a D-Bus type.
1810
1714
        dbus_name: D-Bus name of the variable
1813
1717
        variant_level: D-Bus variant level.  Default: 1
1814
1718
        """
1815
1719
        attrname = "_{}".format(dbus_name)
1816
 
 
 
1720
        
1817
1721
        def setter(self, value):
1818
1722
            if hasattr(self, "dbus_object_path"):
1819
1723
                if (not hasattr(self, attrname) or
1826
1730
                    else:
1827
1731
                        dbus_value = transform_func(
1828
1732
                            type_func(value),
1829
 
                            variant_level=variant_level)
 
1733
                            variant_level = variant_level)
1830
1734
                        self.PropertyChanged(dbus.String(dbus_name),
1831
1735
                                             dbus_value)
1832
1736
                        self.PropertiesChanged(
1833
1737
                            _interface,
1834
 
                            dbus.Dictionary({dbus.String(dbus_name):
1835
 
                                             dbus_value}),
 
1738
                            dbus.Dictionary({ dbus.String(dbus_name):
 
1739
                                              dbus_value }),
1836
1740
                            dbus.Array())
1837
1741
            setattr(self, attrname, value)
1838
 
 
 
1742
        
1839
1743
        return property(lambda self: getattr(self, attrname), setter)
1840
 
 
 
1744
    
1841
1745
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1842
1746
    approvals_pending = notifychangeproperty(dbus.Boolean,
1843
1747
                                             "ApprovalPending",
1844
 
                                             type_func=bool)
 
1748
                                             type_func = bool)
1845
1749
    enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1846
1750
    last_enabled = notifychangeproperty(datetime_to_dbus,
1847
1751
                                        "LastEnabled")
1848
1752
    checker = notifychangeproperty(
1849
1753
        dbus.Boolean, "CheckerRunning",
1850
 
        type_func=lambda checker: checker is not None)
 
1754
        type_func = lambda checker: checker is not None)
1851
1755
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
1852
1756
                                           "LastCheckedOK")
1853
1757
    last_checker_status = notifychangeproperty(dbus.Int16,
1858
1762
                                               "ApprovedByDefault")
1859
1763
    approval_delay = notifychangeproperty(
1860
1764
        dbus.UInt64, "ApprovalDelay",
1861
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1765
        type_func = lambda td: td.total_seconds() * 1000)
1862
1766
    approval_duration = notifychangeproperty(
1863
1767
        dbus.UInt64, "ApprovalDuration",
1864
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1768
        type_func = lambda td: td.total_seconds() * 1000)
1865
1769
    host = notifychangeproperty(dbus.String, "Host")
1866
1770
    timeout = notifychangeproperty(
1867
1771
        dbus.UInt64, "Timeout",
1868
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1772
        type_func = lambda td: td.total_seconds() * 1000)
1869
1773
    extended_timeout = notifychangeproperty(
1870
1774
        dbus.UInt64, "ExtendedTimeout",
1871
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1775
        type_func = lambda td: td.total_seconds() * 1000)
1872
1776
    interval = notifychangeproperty(
1873
1777
        dbus.UInt64, "Interval",
1874
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1778
        type_func = lambda td: td.total_seconds() * 1000)
1875
1779
    checker_command = notifychangeproperty(dbus.String, "Checker")
1876
1780
    secret = notifychangeproperty(dbus.ByteArray, "Secret",
1877
1781
                                  invalidate_only=True)
1878
 
 
 
1782
    
1879
1783
    del notifychangeproperty
1880
 
 
 
1784
    
1881
1785
    def __del__(self, *args, **kwargs):
1882
1786
        try:
1883
1787
            self.remove_from_connection()
1886
1790
        if hasattr(DBusObjectWithProperties, "__del__"):
1887
1791
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
1888
1792
        Client.__del__(self, *args, **kwargs)
1889
 
 
 
1793
    
1890
1794
    def checker_callback(self, source, condition,
1891
1795
                         connection, command, *args, **kwargs):
1892
1796
        ret = Client.checker_callback(self, source, condition,
1908
1812
                                      | self.last_checker_signal),
1909
1813
                                  dbus.String(command))
1910
1814
        return ret
1911
 
 
 
1815
    
1912
1816
    def start_checker(self, *args, **kwargs):
1913
1817
        old_checker_pid = getattr(self.checker, "pid", None)
1914
1818
        r = Client.start_checker(self, *args, **kwargs)
1918
1822
            # Emit D-Bus signal
1919
1823
            self.CheckerStarted(self.current_checker_command)
1920
1824
        return r
1921
 
 
 
1825
    
1922
1826
    def _reset_approved(self):
1923
1827
        self.approved = None
1924
1828
        return False
1925
 
 
 
1829
    
1926
1830
    def approve(self, value=True):
1927
1831
        self.approved = value
1928
1832
        GLib.timeout_add(int(self.approval_duration.total_seconds()
1929
1833
                             * 1000), self._reset_approved)
1930
1834
        self.send_changedstate()
1931
 
 
1932
 
    #  D-Bus methods, signals & properties
1933
 
 
1934
 
    #  Interfaces
1935
 
 
1936
 
    #  Signals
1937
 
 
 
1835
    
 
1836
    ## D-Bus methods, signals & properties
 
1837
    
 
1838
    ## Interfaces
 
1839
    
 
1840
    ## Signals
 
1841
    
1938
1842
    # CheckerCompleted - signal
1939
1843
    @dbus.service.signal(_interface, signature="nxs")
1940
1844
    def CheckerCompleted(self, exitcode, waitstatus, command):
1941
1845
        "D-Bus signal"
1942
1846
        pass
1943
 
 
 
1847
    
1944
1848
    # CheckerStarted - signal
1945
1849
    @dbus.service.signal(_interface, signature="s")
1946
1850
    def CheckerStarted(self, command):
1947
1851
        "D-Bus signal"
1948
1852
        pass
1949
 
 
 
1853
    
1950
1854
    # PropertyChanged - signal
1951
1855
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1952
1856
    @dbus.service.signal(_interface, signature="sv")
1953
1857
    def PropertyChanged(self, property, value):
1954
1858
        "D-Bus signal"
1955
1859
        pass
1956
 
 
 
1860
    
1957
1861
    # GotSecret - signal
1958
1862
    @dbus.service.signal(_interface)
1959
1863
    def GotSecret(self):
1962
1866
        server to mandos-client
1963
1867
        """
1964
1868
        pass
1965
 
 
 
1869
    
1966
1870
    # Rejected - signal
1967
1871
    @dbus.service.signal(_interface, signature="s")
1968
1872
    def Rejected(self, reason):
1969
1873
        "D-Bus signal"
1970
1874
        pass
1971
 
 
 
1875
    
1972
1876
    # NeedApproval - signal
1973
1877
    @dbus.service.signal(_interface, signature="tb")
1974
1878
    def NeedApproval(self, timeout, default):
1975
1879
        "D-Bus signal"
1976
1880
        return self.need_approval()
1977
 
 
1978
 
    #  Methods
1979
 
 
 
1881
    
 
1882
    ## Methods
 
1883
    
1980
1884
    # Approve - method
1981
1885
    @dbus.service.method(_interface, in_signature="b")
1982
1886
    def Approve(self, value):
1983
1887
        self.approve(value)
1984
 
 
 
1888
    
1985
1889
    # CheckedOK - method
1986
1890
    @dbus.service.method(_interface)
1987
1891
    def CheckedOK(self):
1988
1892
        self.checked_ok()
1989
 
 
 
1893
    
1990
1894
    # Enable - method
1991
1895
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1992
1896
    @dbus.service.method(_interface)
1993
1897
    def Enable(self):
1994
1898
        "D-Bus method"
1995
1899
        self.enable()
1996
 
 
 
1900
    
1997
1901
    # StartChecker - method
1998
1902
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1999
1903
    @dbus.service.method(_interface)
2000
1904
    def StartChecker(self):
2001
1905
        "D-Bus method"
2002
1906
        self.start_checker()
2003
 
 
 
1907
    
2004
1908
    # Disable - method
2005
1909
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2006
1910
    @dbus.service.method(_interface)
2007
1911
    def Disable(self):
2008
1912
        "D-Bus method"
2009
1913
        self.disable()
2010
 
 
 
1914
    
2011
1915
    # StopChecker - method
2012
1916
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2013
1917
    @dbus.service.method(_interface)
2014
1918
    def StopChecker(self):
2015
1919
        self.stop_checker()
2016
 
 
2017
 
    #  Properties
2018
 
 
 
1920
    
 
1921
    ## Properties
 
1922
    
2019
1923
    # ApprovalPending - property
2020
1924
    @dbus_service_property(_interface, signature="b", access="read")
2021
1925
    def ApprovalPending_dbus_property(self):
2022
1926
        return dbus.Boolean(bool(self.approvals_pending))
2023
 
 
 
1927
    
2024
1928
    # ApprovedByDefault - property
2025
1929
    @dbus_service_property(_interface,
2026
1930
                           signature="b",
2029
1933
        if value is None:       # get
2030
1934
            return dbus.Boolean(self.approved_by_default)
2031
1935
        self.approved_by_default = bool(value)
2032
 
 
 
1936
    
2033
1937
    # ApprovalDelay - property
2034
1938
    @dbus_service_property(_interface,
2035
1939
                           signature="t",
2039
1943
            return dbus.UInt64(self.approval_delay.total_seconds()
2040
1944
                               * 1000)
2041
1945
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
2042
 
 
 
1946
    
2043
1947
    # ApprovalDuration - property
2044
1948
    @dbus_service_property(_interface,
2045
1949
                           signature="t",
2049
1953
            return dbus.UInt64(self.approval_duration.total_seconds()
2050
1954
                               * 1000)
2051
1955
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
2052
 
 
 
1956
    
2053
1957
    # Name - property
2054
1958
    @dbus_annotations(
2055
1959
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2056
1960
    @dbus_service_property(_interface, signature="s", access="read")
2057
1961
    def Name_dbus_property(self):
2058
1962
        return dbus.String(self.name)
2059
 
 
2060
 
    # KeyID - property
2061
 
    @dbus_annotations(
2062
 
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2063
 
    @dbus_service_property(_interface, signature="s", access="read")
2064
 
    def KeyID_dbus_property(self):
2065
 
        return dbus.String(self.key_id)
2066
 
 
 
1963
    
2067
1964
    # Fingerprint - property
2068
1965
    @dbus_annotations(
2069
1966
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2070
1967
    @dbus_service_property(_interface, signature="s", access="read")
2071
1968
    def Fingerprint_dbus_property(self):
2072
1969
        return dbus.String(self.fingerprint)
2073
 
 
 
1970
    
2074
1971
    # Host - property
2075
1972
    @dbus_service_property(_interface,
2076
1973
                           signature="s",
2079
1976
        if value is None:       # get
2080
1977
            return dbus.String(self.host)
2081
1978
        self.host = str(value)
2082
 
 
 
1979
    
2083
1980
    # Created - property
2084
1981
    @dbus_annotations(
2085
1982
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2086
1983
    @dbus_service_property(_interface, signature="s", access="read")
2087
1984
    def Created_dbus_property(self):
2088
1985
        return datetime_to_dbus(self.created)
2089
 
 
 
1986
    
2090
1987
    # LastEnabled - property
2091
1988
    @dbus_service_property(_interface, signature="s", access="read")
2092
1989
    def LastEnabled_dbus_property(self):
2093
1990
        return datetime_to_dbus(self.last_enabled)
2094
 
 
 
1991
    
2095
1992
    # Enabled - property
2096
1993
    @dbus_service_property(_interface,
2097
1994
                           signature="b",
2103
2000
            self.enable()
2104
2001
        else:
2105
2002
            self.disable()
2106
 
 
 
2003
    
2107
2004
    # LastCheckedOK - property
2108
2005
    @dbus_service_property(_interface,
2109
2006
                           signature="s",
2113
2010
            self.checked_ok()
2114
2011
            return
2115
2012
        return datetime_to_dbus(self.last_checked_ok)
2116
 
 
 
2013
    
2117
2014
    # LastCheckerStatus - property
2118
2015
    @dbus_service_property(_interface, signature="n", access="read")
2119
2016
    def LastCheckerStatus_dbus_property(self):
2120
2017
        return dbus.Int16(self.last_checker_status)
2121
 
 
 
2018
    
2122
2019
    # Expires - property
2123
2020
    @dbus_service_property(_interface, signature="s", access="read")
2124
2021
    def Expires_dbus_property(self):
2125
2022
        return datetime_to_dbus(self.expires)
2126
 
 
 
2023
    
2127
2024
    # LastApprovalRequest - property
2128
2025
    @dbus_service_property(_interface, signature="s", access="read")
2129
2026
    def LastApprovalRequest_dbus_property(self):
2130
2027
        return datetime_to_dbus(self.last_approval_request)
2131
 
 
 
2028
    
2132
2029
    # Timeout - property
2133
2030
    @dbus_service_property(_interface,
2134
2031
                           signature="t",
2153
2050
                self.disable_initiator_tag = GLib.timeout_add(
2154
2051
                    int((self.expires - now).total_seconds() * 1000),
2155
2052
                    self.disable)
2156
 
 
 
2053
    
2157
2054
    # ExtendedTimeout - property
2158
2055
    @dbus_service_property(_interface,
2159
2056
                           signature="t",
2163
2060
            return dbus.UInt64(self.extended_timeout.total_seconds()
2164
2061
                               * 1000)
2165
2062
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2166
 
 
 
2063
    
2167
2064
    # Interval - property
2168
2065
    @dbus_service_property(_interface,
2169
2066
                           signature="t",
2179
2076
            GLib.source_remove(self.checker_initiator_tag)
2180
2077
            self.checker_initiator_tag = GLib.timeout_add(
2181
2078
                value, self.start_checker)
2182
 
            self.start_checker()  # Start one now, too
2183
 
 
 
2079
            self.start_checker() # Start one now, too
 
2080
    
2184
2081
    # Checker - property
2185
2082
    @dbus_service_property(_interface,
2186
2083
                           signature="s",
2189
2086
        if value is None:       # get
2190
2087
            return dbus.String(self.checker_command)
2191
2088
        self.checker_command = str(value)
2192
 
 
 
2089
    
2193
2090
    # CheckerRunning - property
2194
2091
    @dbus_service_property(_interface,
2195
2092
                           signature="b",
2201
2098
            self.start_checker()
2202
2099
        else:
2203
2100
            self.stop_checker()
2204
 
 
 
2101
    
2205
2102
    # ObjectPath - property
2206
2103
    @dbus_annotations(
2207
2104
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2208
2105
         "org.freedesktop.DBus.Deprecated": "true"})
2209
2106
    @dbus_service_property(_interface, signature="o", access="read")
2210
2107
    def ObjectPath_dbus_property(self):
2211
 
        return self.dbus_object_path  # is already a dbus.ObjectPath
2212
 
 
 
2108
        return self.dbus_object_path # is already a dbus.ObjectPath
 
2109
    
2213
2110
    # Secret = property
2214
2111
    @dbus_annotations(
2215
2112
        {"org.freedesktop.DBus.Property.EmitsChangedSignal":
2220
2117
                           byte_arrays=True)
2221
2118
    def Secret_dbus_property(self, value):
2222
2119
        self.secret = bytes(value)
2223
 
 
 
2120
    
2224
2121
    del _interface
2225
2122
 
2226
2123
 
2227
 
class ProxyClient:
2228
 
    def __init__(self, child_pipe, key_id, fpr, address):
 
2124
class ProxyClient(object):
 
2125
    def __init__(self, child_pipe, fpr, address):
2229
2126
        self._pipe = child_pipe
2230
 
        self._pipe.send(('init', key_id, fpr, address))
 
2127
        self._pipe.send(('init', fpr, address))
2231
2128
        if not self._pipe.recv():
2232
 
            raise KeyError(key_id or fpr)
2233
 
 
 
2129
            raise KeyError(fpr)
 
2130
    
2234
2131
    def __getattribute__(self, name):
2235
2132
        if name == '_pipe':
2236
2133
            return super(ProxyClient, self).__getattribute__(name)
2239
2136
        if data[0] == 'data':
2240
2137
            return data[1]
2241
2138
        if data[0] == 'function':
2242
 
 
 
2139
            
2243
2140
            def func(*args, **kwargs):
2244
2141
                self._pipe.send(('funcall', name, args, kwargs))
2245
2142
                return self._pipe.recv()[1]
2246
 
 
 
2143
            
2247
2144
            return func
2248
 
 
 
2145
    
2249
2146
    def __setattr__(self, name, value):
2250
2147
        if name == '_pipe':
2251
2148
            return super(ProxyClient, self).__setattr__(name, value)
2254
2151
 
2255
2152
class ClientHandler(socketserver.BaseRequestHandler, object):
2256
2153
    """A class to handle client connections.
2257
 
 
 
2154
    
2258
2155
    Instantiated once for each connection to handle it.
2259
2156
    Note: This will run in its own forked process."""
2260
 
 
 
2157
    
2261
2158
    def handle(self):
2262
2159
        with contextlib.closing(self.server.child_pipe) as child_pipe:
2263
2160
            logger.info("TCP connection from: %s",
2264
2161
                        str(self.client_address))
2265
2162
            logger.debug("Pipe FD: %d",
2266
2163
                         self.server.child_pipe.fileno())
2267
 
 
 
2164
            
2268
2165
            session = gnutls.ClientSession(self.request)
2269
 
 
2270
 
            # priority = ':'.join(("NONE", "+VERS-TLS1.1",
2271
 
            #                       "+AES-256-CBC", "+SHA1",
2272
 
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
2273
 
            #                       "+DHE-DSS"))
 
2166
            
 
2167
            #priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
2168
            #                      "+AES-256-CBC", "+SHA1",
 
2169
            #                      "+COMP-NULL", "+CTYPE-OPENPGP",
 
2170
            #                      "+DHE-DSS"))
2274
2171
            # Use a fallback default, since this MUST be set.
2275
2172
            priority = self.server.gnutls_priority
2276
2173
            if priority is None:
2277
2174
                priority = "NORMAL"
2278
 
            gnutls.priority_set_direct(session._c_object,
2279
 
                                       priority.encode("utf-8"),
 
2175
            gnutls.priority_set_direct(session._c_object, priority,
2280
2176
                                       None)
2281
 
 
 
2177
            
2282
2178
            # Start communication using the Mandos protocol
2283
2179
            # Get protocol number
2284
2180
            line = self.request.makefile().readline()
2289
2185
            except (ValueError, IndexError, RuntimeError) as error:
2290
2186
                logger.error("Unknown protocol version: %s", error)
2291
2187
                return
2292
 
 
 
2188
            
2293
2189
            # Start GnuTLS connection
2294
2190
            try:
2295
2191
                session.handshake()
2299
2195
                # established.  Just abandon the request.
2300
2196
                return
2301
2197
            logger.debug("Handshake succeeded")
2302
 
 
 
2198
            
2303
2199
            approval_required = False
2304
2200
            try:
2305
 
                if gnutls.has_rawpk:
2306
 
                    fpr = b""
2307
 
                    try:
2308
 
                        key_id = self.key_id(
2309
 
                            self.peer_certificate(session))
2310
 
                    except (TypeError, gnutls.Error) as error:
2311
 
                        logger.warning("Bad certificate: %s", error)
2312
 
                        return
2313
 
                    logger.debug("Key ID: %s", key_id)
2314
 
 
2315
 
                else:
2316
 
                    key_id = b""
2317
 
                    try:
2318
 
                        fpr = self.fingerprint(
2319
 
                            self.peer_certificate(session))
2320
 
                    except (TypeError, gnutls.Error) as error:
2321
 
                        logger.warning("Bad certificate: %s", error)
2322
 
                        return
2323
 
                    logger.debug("Fingerprint: %s", fpr)
2324
 
 
2325
 
                try:
2326
 
                    client = ProxyClient(child_pipe, key_id, fpr,
 
2201
                try:
 
2202
                    fpr = self.fingerprint(
 
2203
                        self.peer_certificate(session))
 
2204
                except (TypeError, gnutls.Error) as error:
 
2205
                    logger.warning("Bad certificate: %s", error)
 
2206
                    return
 
2207
                logger.debug("Fingerprint: %s", fpr)
 
2208
                
 
2209
                try:
 
2210
                    client = ProxyClient(child_pipe, fpr,
2327
2211
                                         self.client_address)
2328
2212
                except KeyError:
2329
2213
                    return
2330
 
 
 
2214
                
2331
2215
                if client.approval_delay:
2332
2216
                    delay = client.approval_delay
2333
2217
                    client.approvals_pending += 1
2334
2218
                    approval_required = True
2335
 
 
 
2219
                
2336
2220
                while True:
2337
2221
                    if not client.enabled:
2338
2222
                        logger.info("Client %s is disabled",
2341
2225
                            # Emit D-Bus signal
2342
2226
                            client.Rejected("Disabled")
2343
2227
                        return
2344
 
 
 
2228
                    
2345
2229
                    if client.approved or not client.approval_delay:
2346
 
                        # We are approved or approval is disabled
 
2230
                        #We are approved or approval is disabled
2347
2231
                        break
2348
2232
                    elif client.approved is None:
2349
2233
                        logger.info("Client %s needs approval",
2360
2244
                            # Emit D-Bus signal
2361
2245
                            client.Rejected("Denied")
2362
2246
                        return
2363
 
 
2364
 
                    # wait until timeout or approved
 
2247
                    
 
2248
                    #wait until timeout or approved
2365
2249
                    time = datetime.datetime.now()
2366
2250
                    client.changedstate.acquire()
2367
2251
                    client.changedstate.wait(delay.total_seconds())
2380
2264
                            break
2381
2265
                    else:
2382
2266
                        delay -= time2 - time
2383
 
 
 
2267
                
2384
2268
                try:
2385
2269
                    session.send(client.secret)
2386
2270
                except gnutls.Error as error:
2387
2271
                    logger.warning("gnutls send failed",
2388
 
                                   exc_info=error)
 
2272
                                   exc_info = error)
2389
2273
                    return
2390
 
 
 
2274
                
2391
2275
                logger.info("Sending secret to %s", client.name)
2392
2276
                # bump the timeout using extended_timeout
2393
2277
                client.bump_timeout(client.extended_timeout)
2394
2278
                if self.server.use_dbus:
2395
2279
                    # Emit D-Bus signal
2396
2280
                    client.GotSecret()
2397
 
 
 
2281
            
2398
2282
            finally:
2399
2283
                if approval_required:
2400
2284
                    client.approvals_pending -= 1
2403
2287
                except gnutls.Error as error:
2404
2288
                    logger.warning("GnuTLS bye failed",
2405
2289
                                   exc_info=error)
2406
 
 
 
2290
    
2407
2291
    @staticmethod
2408
2292
    def peer_certificate(session):
2409
 
        "Return the peer's certificate as a bytestring"
2410
 
        try:
2411
 
            cert_type = gnutls.certificate_type_get2(session._c_object,
2412
 
                                                     gnutls.CTYPE_PEERS)
2413
 
        except AttributeError:
2414
 
            cert_type = gnutls.certificate_type_get(session._c_object)
2415
 
        if gnutls.has_rawpk:
2416
 
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2417
 
        else:
2418
 
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2419
 
        # If not a valid certificate type...
2420
 
        if cert_type not in valid_cert_types:
2421
 
            logger.info("Cert type %r not in %r", cert_type,
2422
 
                        valid_cert_types)
 
2293
        "Return the peer's OpenPGP certificate as a bytestring"
 
2294
        # If not an OpenPGP certificate...
 
2295
        if (gnutls.certificate_type_get(session._c_object)
 
2296
            != gnutls.CRT_OPENPGP):
2423
2297
            # ...return invalid data
2424
2298
            return b""
2425
2299
        list_size = ctypes.c_uint(1)
2431
2305
            return None
2432
2306
        cert = cert_list[0]
2433
2307
        return ctypes.string_at(cert.data, cert.size)
2434
 
 
2435
 
    @staticmethod
2436
 
    def key_id(certificate):
2437
 
        "Convert a certificate bytestring to a hexdigit key ID"
2438
 
        # New GnuTLS "datum" with the public key
2439
 
        datum = gnutls.datum_t(
2440
 
            ctypes.cast(ctypes.c_char_p(certificate),
2441
 
                        ctypes.POINTER(ctypes.c_ubyte)),
2442
 
            ctypes.c_uint(len(certificate)))
2443
 
        # XXX all these need to be created in the gnutls "module"
2444
 
        # New empty GnuTLS certificate
2445
 
        pubkey = gnutls.pubkey_t()
2446
 
        gnutls.pubkey_init(ctypes.byref(pubkey))
2447
 
        # Import the raw public key into the certificate
2448
 
        gnutls.pubkey_import(pubkey,
2449
 
                             ctypes.byref(datum),
2450
 
                             gnutls.X509_FMT_DER)
2451
 
        # New buffer for the key ID
2452
 
        buf = ctypes.create_string_buffer(32)
2453
 
        buf_len = ctypes.c_size_t(len(buf))
2454
 
        # Get the key ID from the raw public key into the buffer
2455
 
        gnutls.pubkey_get_key_id(pubkey,
2456
 
                                 gnutls.KEYID_USE_SHA256,
2457
 
                                 ctypes.cast(ctypes.byref(buf),
2458
 
                                             ctypes.POINTER(ctypes.c_ubyte)),
2459
 
                                 ctypes.byref(buf_len))
2460
 
        # Deinit the certificate
2461
 
        gnutls.pubkey_deinit(pubkey)
2462
 
 
2463
 
        # Convert the buffer to a Python bytestring
2464
 
        key_id = ctypes.string_at(buf, buf_len.value)
2465
 
        # Convert the bytestring to hexadecimal notation
2466
 
        hex_key_id = binascii.hexlify(key_id).upper()
2467
 
        return hex_key_id
2468
 
 
 
2308
    
2469
2309
    @staticmethod
2470
2310
    def fingerprint(openpgp):
2471
2311
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
2486
2326
                                       ctypes.byref(crtverify))
2487
2327
        if crtverify.value != 0:
2488
2328
            gnutls.openpgp_crt_deinit(crt)
2489
 
            raise gnutls.CertificateSecurityError(code
2490
 
                                                  =crtverify.value)
 
2329
            raise gnutls.CertificateSecurityError("Verify failed")
2491
2330
        # New buffer for the fingerprint
2492
2331
        buf = ctypes.create_string_buffer(20)
2493
2332
        buf_len = ctypes.c_size_t()
2503
2342
        return hex_fpr
2504
2343
 
2505
2344
 
2506
 
class MultiprocessingMixIn:
 
2345
class MultiprocessingMixIn(object):
2507
2346
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2508
 
 
 
2347
    
2509
2348
    def sub_process_main(self, request, address):
2510
2349
        try:
2511
2350
            self.finish_request(request, address)
2512
2351
        except Exception:
2513
2352
            self.handle_error(request, address)
2514
2353
        self.close_request(request)
2515
 
 
 
2354
    
2516
2355
    def process_request(self, request, address):
2517
2356
        """Start a new process to process the request."""
2518
 
        proc = multiprocessing.Process(target=self.sub_process_main,
2519
 
                                       args=(request, address))
 
2357
        proc = multiprocessing.Process(target = self.sub_process_main,
 
2358
                                       args = (request, address))
2520
2359
        proc.start()
2521
2360
        return proc
2522
2361
 
2523
2362
 
2524
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
 
2363
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2525
2364
    """ adds a pipe to the MixIn """
2526
 
 
 
2365
    
2527
2366
    def process_request(self, request, client_address):
2528
2367
        """Overrides and wraps the original process_request().
2529
 
 
 
2368
        
2530
2369
        This function creates a new pipe in self.pipe
2531
2370
        """
2532
2371
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
2533
 
 
 
2372
        
2534
2373
        proc = MultiprocessingMixIn.process_request(self, request,
2535
2374
                                                    client_address)
2536
2375
        self.child_pipe.close()
2537
2376
        self.add_pipe(parent_pipe, proc)
2538
 
 
 
2377
    
2539
2378
    def add_pipe(self, parent_pipe, proc):
2540
2379
        """Dummy function; override as necessary"""
2541
2380
        raise NotImplementedError()
2542
2381
 
2543
2382
 
2544
2383
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2545
 
                     socketserver.TCPServer):
 
2384
                     socketserver.TCPServer, object):
2546
2385
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2547
 
 
 
2386
    
2548
2387
    Attributes:
2549
2388
        enabled:        Boolean; whether this server is activated yet
2550
2389
        interface:      None or a network interface name (string)
2551
2390
        use_ipv6:       Boolean; to use IPv6 or not
2552
2391
    """
2553
 
 
 
2392
    
2554
2393
    def __init__(self, server_address, RequestHandlerClass,
2555
2394
                 interface=None,
2556
2395
                 use_ipv6=True,
2566
2405
            self.socketfd = socketfd
2567
2406
            # Save the original socket.socket() function
2568
2407
            self.socket_socket = socket.socket
2569
 
 
2570
2408
            # To implement --socket, we monkey patch socket.socket.
2571
 
            #
 
2409
            # 
2572
2410
            # (When socketserver.TCPServer is a new-style class, we
2573
2411
            # could make self.socket into a property instead of monkey
2574
2412
            # patching socket.socket.)
2575
 
            #
 
2413
            # 
2576
2414
            # Create a one-time-only replacement for socket.socket()
2577
2415
            @functools.wraps(socket.socket)
2578
2416
            def socket_wrapper(*args, **kwargs):
2590
2428
        # socket_wrapper(), if socketfd was set.
2591
2429
        socketserver.TCPServer.__init__(self, server_address,
2592
2430
                                        RequestHandlerClass)
2593
 
 
 
2431
    
2594
2432
    def server_bind(self):
2595
2433
        """This overrides the normal server_bind() function
2596
2434
        to bind to an interface if one was specified, and also NOT to
2597
2435
        bind to an address or port if they were not specified."""
2598
 
        global SO_BINDTODEVICE
2599
2436
        if self.interface is not None:
2600
2437
            if SO_BINDTODEVICE is None:
2601
 
                # Fall back to a hard-coded value which seems to be
2602
 
                # common enough.
2603
 
                logger.warning("SO_BINDTODEVICE not found, trying 25")
2604
 
                SO_BINDTODEVICE = 25
2605
 
            try:
2606
 
                self.socket.setsockopt(
2607
 
                    socket.SOL_SOCKET, SO_BINDTODEVICE,
2608
 
                    (self.interface + "\0").encode("utf-8"))
2609
 
            except socket.error as error:
2610
 
                if error.errno == errno.EPERM:
2611
 
                    logger.error("No permission to bind to"
2612
 
                                 " interface %s", self.interface)
2613
 
                elif error.errno == errno.ENOPROTOOPT:
2614
 
                    logger.error("SO_BINDTODEVICE not available;"
2615
 
                                 " cannot bind to interface %s",
2616
 
                                 self.interface)
2617
 
                elif error.errno == errno.ENODEV:
2618
 
                    logger.error("Interface %s does not exist,"
2619
 
                                 " cannot bind", self.interface)
2620
 
                else:
2621
 
                    raise
 
2438
                logger.error("SO_BINDTODEVICE does not exist;"
 
2439
                             " cannot bind to interface %s",
 
2440
                             self.interface)
 
2441
            else:
 
2442
                try:
 
2443
                    self.socket.setsockopt(
 
2444
                        socket.SOL_SOCKET, SO_BINDTODEVICE,
 
2445
                        (self.interface + "\0").encode("utf-8"))
 
2446
                except socket.error as error:
 
2447
                    if error.errno == errno.EPERM:
 
2448
                        logger.error("No permission to bind to"
 
2449
                                     " interface %s", self.interface)
 
2450
                    elif error.errno == errno.ENOPROTOOPT:
 
2451
                        logger.error("SO_BINDTODEVICE not available;"
 
2452
                                     " cannot bind to interface %s",
 
2453
                                     self.interface)
 
2454
                    elif error.errno == errno.ENODEV:
 
2455
                        logger.error("Interface %s does not exist,"
 
2456
                                     " cannot bind", self.interface)
 
2457
                    else:
 
2458
                        raise
2622
2459
        # Only bind(2) the socket if we really need to.
2623
2460
        if self.server_address[0] or self.server_address[1]:
2624
 
            if self.server_address[1]:
2625
 
                self.allow_reuse_address = True
2626
2461
            if not self.server_address[0]:
2627
2462
                if self.address_family == socket.AF_INET6:
2628
 
                    any_address = "::"  # in6addr_any
 
2463
                    any_address = "::" # in6addr_any
2629
2464
                else:
2630
 
                    any_address = "0.0.0.0"  # INADDR_ANY
 
2465
                    any_address = "0.0.0.0" # INADDR_ANY
2631
2466
                self.server_address = (any_address,
2632
2467
                                       self.server_address[1])
2633
2468
            elif not self.server_address[1]:
2643
2478
 
2644
2479
class MandosServer(IPv6_TCPServer):
2645
2480
    """Mandos server.
2646
 
 
 
2481
    
2647
2482
    Attributes:
2648
2483
        clients:        set of Client objects
2649
2484
        gnutls_priority GnuTLS priority string
2650
2485
        use_dbus:       Boolean; to emit D-Bus signals or not
2651
 
 
 
2486
    
2652
2487
    Assumes a GLib.MainLoop event loop.
2653
2488
    """
2654
 
 
 
2489
    
2655
2490
    def __init__(self, server_address, RequestHandlerClass,
2656
2491
                 interface=None,
2657
2492
                 use_ipv6=True,
2667
2502
        self.gnutls_priority = gnutls_priority
2668
2503
        IPv6_TCPServer.__init__(self, server_address,
2669
2504
                                RequestHandlerClass,
2670
 
                                interface=interface,
2671
 
                                use_ipv6=use_ipv6,
2672
 
                                socketfd=socketfd)
2673
 
 
 
2505
                                interface = interface,
 
2506
                                use_ipv6 = use_ipv6,
 
2507
                                socketfd = socketfd)
 
2508
    
2674
2509
    def server_activate(self):
2675
2510
        if self.enabled:
2676
2511
            return socketserver.TCPServer.server_activate(self)
2677
 
 
 
2512
    
2678
2513
    def enable(self):
2679
2514
        self.enabled = True
2680
 
 
 
2515
    
2681
2516
    def add_pipe(self, parent_pipe, proc):
2682
2517
        # Call "handle_ipc" for both data and EOF events
2683
2518
        GLib.io_add_watch(
2684
 
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
2685
 
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2519
            parent_pipe.fileno(),
 
2520
            GLib.IO_IN | GLib.IO_HUP,
2686
2521
            functools.partial(self.handle_ipc,
2687
 
                              parent_pipe=parent_pipe,
2688
 
                              proc=proc))
2689
 
 
 
2522
                              parent_pipe = parent_pipe,
 
2523
                              proc = proc))
 
2524
    
2690
2525
    def handle_ipc(self, source, condition,
2691
2526
                   parent_pipe=None,
2692
 
                   proc=None,
 
2527
                   proc = None,
2693
2528
                   client_object=None):
2694
2529
        # error, or the other end of multiprocessing.Pipe has closed
2695
2530
        if condition & (GLib.IO_ERR | GLib.IO_HUP):
2696
2531
            # Wait for other process to exit
2697
2532
            proc.join()
2698
2533
            return False
2699
 
 
 
2534
        
2700
2535
        # Read a request from the child
2701
2536
        request = parent_pipe.recv()
2702
2537
        command = request[0]
2703
 
 
 
2538
        
2704
2539
        if command == 'init':
2705
 
            key_id = request[1].decode("ascii")
2706
 
            fpr = request[2].decode("ascii")
2707
 
            address = request[3]
2708
 
 
 
2540
            fpr = request[1]
 
2541
            address = request[2]
 
2542
            
2709
2543
            for c in self.clients.values():
2710
 
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2711
 
                    continue
2712
 
                if key_id and c.key_id == key_id:
2713
 
                    client = c
2714
 
                    break
2715
 
                if fpr and c.fingerprint == fpr:
 
2544
                if c.fingerprint == fpr:
2716
2545
                    client = c
2717
2546
                    break
2718
2547
            else:
2719
 
                logger.info("Client not found for key ID: %s, address"
2720
 
                            ": %s", key_id or fpr, address)
 
2548
                logger.info("Client not found for fingerprint: %s, ad"
 
2549
                            "dress: %s", fpr, address)
2721
2550
                if self.use_dbus:
2722
2551
                    # Emit D-Bus signal
2723
 
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
 
2552
                    mandos_dbus_service.ClientNotFound(fpr,
2724
2553
                                                       address[0])
2725
2554
                parent_pipe.send(False)
2726
2555
                return False
2727
 
 
 
2556
            
2728
2557
            GLib.io_add_watch(
2729
 
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
2730
 
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2558
                parent_pipe.fileno(),
 
2559
                GLib.IO_IN | GLib.IO_HUP,
2731
2560
                functools.partial(self.handle_ipc,
2732
 
                                  parent_pipe=parent_pipe,
2733
 
                                  proc=proc,
2734
 
                                  client_object=client))
 
2561
                                  parent_pipe = parent_pipe,
 
2562
                                  proc = proc,
 
2563
                                  client_object = client))
2735
2564
            parent_pipe.send(True)
2736
2565
            # remove the old hook in favor of the new above hook on
2737
2566
            # same fileno
2740
2569
            funcname = request[1]
2741
2570
            args = request[2]
2742
2571
            kwargs = request[3]
2743
 
 
 
2572
            
2744
2573
            parent_pipe.send(('data', getattr(client_object,
2745
2574
                                              funcname)(*args,
2746
2575
                                                        **kwargs)))
2747
 
 
 
2576
        
2748
2577
        if command == 'getattr':
2749
2578
            attrname = request[1]
2750
2579
            if isinstance(client_object.__getattribute__(attrname),
2753
2582
            else:
2754
2583
                parent_pipe.send((
2755
2584
                    'data', client_object.__getattribute__(attrname)))
2756
 
 
 
2585
        
2757
2586
        if command == 'setattr':
2758
2587
            attrname = request[1]
2759
2588
            value = request[2]
2760
2589
            setattr(client_object, attrname, value)
2761
 
 
 
2590
        
2762
2591
        return True
2763
2592
 
2764
2593
 
2765
2594
def rfc3339_duration_to_delta(duration):
2766
2595
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2767
 
 
 
2596
    
2768
2597
    >>> rfc3339_duration_to_delta("P7D")
2769
2598
    datetime.timedelta(7)
2770
2599
    >>> rfc3339_duration_to_delta("PT60S")
2780
2609
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2781
2610
    datetime.timedelta(1, 200)
2782
2611
    """
2783
 
 
 
2612
    
2784
2613
    # Parsing an RFC 3339 duration with regular expressions is not
2785
2614
    # possible - there would have to be multiple places for the same
2786
2615
    # values, like seconds.  The current code, while more esoteric, is
2787
2616
    # cleaner without depending on a parsing library.  If Python had a
2788
2617
    # built-in library for parsing we would use it, but we'd like to
2789
2618
    # avoid excessive use of external libraries.
2790
 
 
 
2619
    
2791
2620
    # New type for defining tokens, syntax, and semantics all-in-one
2792
2621
    Token = collections.namedtuple("Token", (
2793
2622
        "regexp",  # To match token; if "value" is not None, must have
2826
2655
                           frozenset((token_year, token_month,
2827
2656
                                      token_day, token_time,
2828
2657
                                      token_week)))
2829
 
    # Define starting values:
2830
 
    # Value so far
2831
 
    value = datetime.timedelta()
 
2658
    # Define starting values
 
2659
    value = datetime.timedelta() # Value so far
2832
2660
    found_token = None
2833
 
    # Following valid tokens
2834
 
    followers = frozenset((token_duration, ))
2835
 
    # String left to parse
2836
 
    s = duration
 
2661
    followers = frozenset((token_duration, )) # Following valid tokens
 
2662
    s = duration                # String left to parse
2837
2663
    # Loop until end token is found
2838
2664
    while found_token is not token_end:
2839
2665
        # Search for any currently valid tokens
2863
2689
 
2864
2690
def string_to_delta(interval):
2865
2691
    """Parse a string and return a datetime.timedelta
2866
 
 
 
2692
    
2867
2693
    >>> string_to_delta('7d')
2868
2694
    datetime.timedelta(7)
2869
2695
    >>> string_to_delta('60s')
2877
2703
    >>> string_to_delta('5m 30s')
2878
2704
    datetime.timedelta(0, 330)
2879
2705
    """
2880
 
 
 
2706
    
2881
2707
    try:
2882
2708
        return rfc3339_duration_to_delta(interval)
2883
2709
    except ValueError:
2884
2710
        pass
2885
 
 
 
2711
    
2886
2712
    timevalue = datetime.timedelta(0)
2887
2713
    for s in interval.split():
2888
2714
        try:
2906
2732
    return timevalue
2907
2733
 
2908
2734
 
2909
 
def daemon(nochdir=False, noclose=False):
 
2735
def daemon(nochdir = False, noclose = False):
2910
2736
    """See daemon(3).  Standard BSD Unix function.
2911
 
 
 
2737
    
2912
2738
    This should really exist as os.daemon, but it doesn't (yet)."""
2913
2739
    if os.fork():
2914
2740
        sys.exit()
2932
2758
 
2933
2759
 
2934
2760
def main():
2935
 
 
 
2761
    
2936
2762
    ##################################################################
2937
2763
    # Parsing of options, both command line and config file
2938
 
 
 
2764
    
2939
2765
    parser = argparse.ArgumentParser()
2940
2766
    parser.add_argument("-v", "--version", action="version",
2941
 
                        version="%(prog)s {}".format(version),
 
2767
                        version = "%(prog)s {}".format(version),
2942
2768
                        help="show version number and exit")
2943
2769
    parser.add_argument("-i", "--interface", metavar="IF",
2944
2770
                        help="Bind to interface IF")
2980
2806
    parser.add_argument("--no-zeroconf", action="store_false",
2981
2807
                        dest="zeroconf", help="Do not use Zeroconf",
2982
2808
                        default=None)
2983
 
 
 
2809
    
2984
2810
    options = parser.parse_args()
2985
 
 
 
2811
    
 
2812
    if options.check:
 
2813
        import doctest
 
2814
        fail_count, test_count = doctest.testmod()
 
2815
        sys.exit(os.EX_OK if fail_count == 0 else 1)
 
2816
    
2986
2817
    # Default values for config file for server-global settings
2987
 
    if gnutls.has_rawpk:
2988
 
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2989
 
                    ":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2990
 
    else:
2991
 
        priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2992
 
                    ":+SIGN-DSA-SHA256")
2993
 
    server_defaults = {"interface": "",
2994
 
                       "address": "",
2995
 
                       "port": "",
2996
 
                       "debug": "False",
2997
 
                       "priority": priority,
2998
 
                       "servicename": "Mandos",
2999
 
                       "use_dbus": "True",
3000
 
                       "use_ipv6": "True",
3001
 
                       "debuglevel": "",
3002
 
                       "restore": "True",
3003
 
                       "socket": "",
3004
 
                       "statedir": "/var/lib/mandos",
3005
 
                       "foreground": "False",
3006
 
                       "zeroconf": "True",
3007
 
                       }
3008
 
    del priority
3009
 
 
 
2818
    server_defaults = { "interface": "",
 
2819
                        "address": "",
 
2820
                        "port": "",
 
2821
                        "debug": "False",
 
2822
                        "priority":
 
2823
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
2824
                        ":+SIGN-DSA-SHA256",
 
2825
                        "servicename": "Mandos",
 
2826
                        "use_dbus": "True",
 
2827
                        "use_ipv6": "True",
 
2828
                        "debuglevel": "",
 
2829
                        "restore": "True",
 
2830
                        "socket": "",
 
2831
                        "statedir": "/var/lib/mandos",
 
2832
                        "foreground": "False",
 
2833
                        "zeroconf": "True",
 
2834
                    }
 
2835
    
3010
2836
    # Parse config file for server-global settings
3011
 
    server_config = configparser.ConfigParser(server_defaults)
 
2837
    server_config = configparser.SafeConfigParser(server_defaults)
3012
2838
    del server_defaults
3013
2839
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3014
 
    # Convert the ConfigParser object to a dict
 
2840
    # Convert the SafeConfigParser object to a dict
3015
2841
    server_settings = server_config.defaults()
3016
2842
    # Use the appropriate methods on the non-string config options
3017
 
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3018
 
                   "foreground", "zeroconf"):
 
2843
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
3019
2844
        server_settings[option] = server_config.getboolean("DEFAULT",
3020
2845
                                                           option)
3021
2846
    if server_settings["port"]:
3031
2856
            server_settings["socket"] = os.dup(server_settings
3032
2857
                                               ["socket"])
3033
2858
    del server_config
3034
 
 
 
2859
    
3035
2860
    # Override the settings from the config file with command line
3036
2861
    # options, if set.
3037
2862
    for option in ("interface", "address", "port", "debug",
3055
2880
    if server_settings["debug"]:
3056
2881
        server_settings["foreground"] = True
3057
2882
    # Now we have our good server settings in "server_settings"
3058
 
 
 
2883
    
3059
2884
    ##################################################################
3060
 
 
 
2885
    
3061
2886
    if (not server_settings["zeroconf"]
3062
2887
        and not (server_settings["port"]
3063
2888
                 or server_settings["socket"] != "")):
3064
2889
        parser.error("Needs port or socket to work without Zeroconf")
3065
 
 
 
2890
    
3066
2891
    # For convenience
3067
2892
    debug = server_settings["debug"]
3068
2893
    debuglevel = server_settings["debuglevel"]
3072
2897
                                     stored_state_file)
3073
2898
    foreground = server_settings["foreground"]
3074
2899
    zeroconf = server_settings["zeroconf"]
3075
 
 
 
2900
    
3076
2901
    if debug:
3077
2902
        initlogger(debug, logging.DEBUG)
3078
2903
    else:
3081
2906
        else:
3082
2907
            level = getattr(logging, debuglevel.upper())
3083
2908
            initlogger(debug, level)
3084
 
 
 
2909
    
3085
2910
    if server_settings["servicename"] != "Mandos":
3086
2911
        syslogger.setFormatter(
3087
2912
            logging.Formatter('Mandos ({}) [%(process)d]:'
3088
2913
                              ' %(levelname)s: %(message)s'.format(
3089
2914
                                  server_settings["servicename"])))
3090
 
 
 
2915
    
3091
2916
    # Parse config file with clients
3092
 
    client_config = configparser.ConfigParser(Client.client_defaults)
 
2917
    client_config = configparser.SafeConfigParser(Client
 
2918
                                                  .client_defaults)
3093
2919
    client_config.read(os.path.join(server_settings["configdir"],
3094
2920
                                    "clients.conf"))
3095
 
 
 
2921
    
3096
2922
    global mandos_dbus_service
3097
2923
    mandos_dbus_service = None
3098
 
 
 
2924
    
3099
2925
    socketfd = None
3100
2926
    if server_settings["socket"] != "":
3101
2927
        socketfd = server_settings["socket"]
3117
2943
        except IOError as e:
3118
2944
            logger.error("Could not open file %r", pidfilename,
3119
2945
                         exc_info=e)
3120
 
 
 
2946
    
3121
2947
    for name, group in (("_mandos", "_mandos"),
3122
2948
                        ("mandos", "mandos"),
3123
2949
                        ("nobody", "nogroup")):
3141
2967
                       .format(uid, gid, os.strerror(error.errno)))
3142
2968
        if error.errno != errno.EPERM:
3143
2969
            raise
3144
 
 
 
2970
    
3145
2971
    if debug:
3146
2972
        # Enable all possible GnuTLS debugging
3147
 
 
 
2973
        
3148
2974
        # "Use a log level over 10 to enable all debugging options."
3149
2975
        # - GnuTLS manual
3150
2976
        gnutls.global_set_log_level(11)
3151
 
 
 
2977
        
3152
2978
        @gnutls.log_func
3153
2979
        def debug_gnutls(level, string):
3154
2980
            logger.debug("GnuTLS: %s", string[:-1])
3155
 
 
 
2981
        
3156
2982
        gnutls.global_set_log_function(debug_gnutls)
3157
 
 
 
2983
        
3158
2984
        # Redirect stdin so all checkers get /dev/null
3159
2985
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3160
2986
        os.dup2(null, sys.stdin.fileno())
3161
2987
        if null > 2:
3162
2988
            os.close(null)
3163
 
 
 
2989
    
3164
2990
    # Need to fork before connecting to D-Bus
3165
2991
    if not foreground:
3166
2992
        # Close all input and output, do double fork, etc.
3167
2993
        daemon()
3168
 
 
3169
 
    if gi.version_info < (3, 10, 2):
3170
 
        # multiprocessing will use threads, so before we use GLib we
3171
 
        # need to inform GLib that threads will be used.
3172
 
        GLib.threads_init()
3173
 
 
 
2994
    
 
2995
    # multiprocessing will use threads, so before we use GLib we need
 
2996
    # to inform GLib that threads will be used.
 
2997
    GLib.threads_init()
 
2998
    
3174
2999
    global main_loop
3175
3000
    # From the Avahi example code
3176
3001
    DBusGMainLoop(set_as_default=True)
3193
3018
    if zeroconf:
3194
3019
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3195
3020
        service = AvahiServiceToSyslog(
3196
 
            name=server_settings["servicename"],
3197
 
            servicetype="_mandos._tcp",
3198
 
            protocol=protocol,
3199
 
            bus=bus)
 
3021
            name = server_settings["servicename"],
 
3022
            servicetype = "_mandos._tcp",
 
3023
            protocol = protocol,
 
3024
            bus = bus)
3200
3025
        if server_settings["interface"]:
3201
3026
            service.interface = if_nametoindex(
3202
3027
                server_settings["interface"].encode("utf-8"))
3203
 
 
 
3028
    
3204
3029
    global multiprocessing_manager
3205
3030
    multiprocessing_manager = multiprocessing.Manager()
3206
 
 
 
3031
    
3207
3032
    client_class = Client
3208
3033
    if use_dbus:
3209
 
        client_class = functools.partial(ClientDBus, bus=bus)
3210
 
 
 
3034
        client_class = functools.partial(ClientDBus, bus = bus)
 
3035
    
3211
3036
    client_settings = Client.config_parser(client_config)
3212
3037
    old_client_settings = {}
3213
3038
    clients_data = {}
3214
 
 
 
3039
    
3215
3040
    # This is used to redirect stdout and stderr for checker processes
3216
3041
    global wnull
3217
 
    wnull = open(os.devnull, "w")  # A writable /dev/null
 
3042
    wnull = open(os.devnull, "w") # A writable /dev/null
3218
3043
    # Only used if server is running in foreground but not in debug
3219
3044
    # mode
3220
3045
    if debug or not foreground:
3221
3046
        wnull.close()
3222
 
 
 
3047
    
3223
3048
    # Get client data and settings from last running state.
3224
3049
    if server_settings["restore"]:
3225
3050
        try:
3226
3051
            with open(stored_state_path, "rb") as stored_state:
3227
 
                if sys.version_info.major == 2:
 
3052
                if sys.version_info.major == 2:                
3228
3053
                    clients_data, old_client_settings = pickle.load(
3229
3054
                        stored_state)
3230
3055
                else:
3231
3056
                    bytes_clients_data, bytes_old_client_settings = (
3232
 
                        pickle.load(stored_state, encoding="bytes"))
3233
 
                    #   Fix bytes to strings
3234
 
                    #  clients_data
 
3057
                        pickle.load(stored_state, encoding = "bytes"))
 
3058
                    ### Fix bytes to strings
 
3059
                    ## clients_data
3235
3060
                    # .keys()
3236
 
                    clients_data = {(key.decode("utf-8")
3237
 
                                     if isinstance(key, bytes)
3238
 
                                     else key): value
3239
 
                                    for key, value in
3240
 
                                    bytes_clients_data.items()}
 
3061
                    clients_data = { (key.decode("utf-8")
 
3062
                                      if isinstance(key, bytes)
 
3063
                                      else key): value
 
3064
                                     for key, value in
 
3065
                                     bytes_clients_data.items() }
3241
3066
                    del bytes_clients_data
3242
3067
                    for key in clients_data:
3243
 
                        value = {(k.decode("utf-8")
3244
 
                                  if isinstance(k, bytes) else k): v
3245
 
                                 for k, v in
3246
 
                                 clients_data[key].items()}
 
3068
                        value = { (k.decode("utf-8")
 
3069
                                   if isinstance(k, bytes) else k): v
 
3070
                                  for k, v in
 
3071
                                  clients_data[key].items() }
3247
3072
                        clients_data[key] = value
3248
3073
                        # .client_structure
3249
3074
                        value["client_structure"] = [
3250
3075
                            (s.decode("utf-8")
3251
3076
                             if isinstance(s, bytes)
3252
3077
                             else s) for s in
3253
 
                            value["client_structure"]]
 
3078
                            value["client_structure"] ]
3254
3079
                        # .name & .host
3255
3080
                        for k in ("name", "host"):
3256
3081
                            if isinstance(value[k], bytes):
3257
3082
                                value[k] = value[k].decode("utf-8")
3258
 
                        if "key_id" not in value:
3259
 
                            value["key_id"] = ""
3260
 
                        elif "fingerprint" not in value:
3261
 
                            value["fingerprint"] = ""
3262
 
                    #  old_client_settings
 
3083
                    ## old_client_settings
3263
3084
                    # .keys()
3264
3085
                    old_client_settings = {
3265
3086
                        (key.decode("utf-8")
3266
3087
                         if isinstance(key, bytes)
3267
3088
                         else key): value
3268
3089
                        for key, value in
3269
 
                        bytes_old_client_settings.items()}
 
3090
                        bytes_old_client_settings.items() }
3270
3091
                    del bytes_old_client_settings
3271
3092
                    # .host
3272
3093
                    for value in old_client_settings.values():
3286
3107
            logger.warning("Could not load persistent state: "
3287
3108
                           "EOFError:",
3288
3109
                           exc_info=e)
3289
 
 
 
3110
    
3290
3111
    with PGPEngine() as pgp:
3291
3112
        for client_name, client in clients_data.items():
3292
3113
            # Skip removed clients
3293
3114
            if client_name not in client_settings:
3294
3115
                continue
3295
 
 
 
3116
            
3296
3117
            # Decide which value to use after restoring saved state.
3297
3118
            # We have three different values: Old config file,
3298
3119
            # new config file, and saved state.
3309
3130
                        client[name] = value
3310
3131
                except KeyError:
3311
3132
                    pass
3312
 
 
 
3133
            
3313
3134
            # Clients who has passed its expire date can still be
3314
3135
            # enabled if its last checker was successful.  A Client
3315
3136
            # whose checker succeeded before we stored its state is
3348
3169
                    client_name))
3349
3170
                client["secret"] = (client_settings[client_name]
3350
3171
                                    ["secret"])
3351
 
 
 
3172
    
3352
3173
    # Add/remove clients based on new changes made to config
3353
3174
    for client_name in (set(old_client_settings)
3354
3175
                        - set(client_settings)):
3356
3177
    for client_name in (set(client_settings)
3357
3178
                        - set(old_client_settings)):
3358
3179
        clients_data[client_name] = client_settings[client_name]
3359
 
 
 
3180
    
3360
3181
    # Create all client objects
3361
3182
    for client_name, client in clients_data.items():
3362
3183
        tcp_server.clients[client_name] = client_class(
3363
 
            name=client_name,
3364
 
            settings=client,
3365
 
            server_settings=server_settings)
3366
 
 
 
3184
            name = client_name,
 
3185
            settings = client,
 
3186
            server_settings = server_settings)
 
3187
    
3367
3188
    if not tcp_server.clients:
3368
3189
        logger.warning("No clients defined")
3369
 
 
 
3190
    
3370
3191
    if not foreground:
3371
3192
        if pidfile is not None:
3372
3193
            pid = os.getpid()
3378
3199
                             pidfilename, pid)
3379
3200
        del pidfile
3380
3201
        del pidfilename
3381
 
 
 
3202
    
3382
3203
    for termsig in (signal.SIGHUP, signal.SIGTERM):
3383
3204
        GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3384
3205
                             lambda: main_loop.quit() and False)
3385
 
 
 
3206
    
3386
3207
    if use_dbus:
3387
 
 
 
3208
        
3388
3209
        @alternate_dbus_interfaces(
3389
 
            {"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
 
3210
            { "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3390
3211
        class MandosDBusService(DBusObjectWithObjectManager):
3391
3212
            """A D-Bus proxy object"""
3392
 
 
 
3213
            
3393
3214
            def __init__(self):
3394
3215
                dbus.service.Object.__init__(self, bus, "/")
3395
 
 
 
3216
            
3396
3217
            _interface = "se.recompile.Mandos"
3397
 
 
 
3218
            
3398
3219
            @dbus.service.signal(_interface, signature="o")
3399
3220
            def ClientAdded(self, objpath):
3400
3221
                "D-Bus signal"
3401
3222
                pass
3402
 
 
 
3223
            
3403
3224
            @dbus.service.signal(_interface, signature="ss")
3404
 
            def ClientNotFound(self, key_id, address):
 
3225
            def ClientNotFound(self, fingerprint, address):
3405
3226
                "D-Bus signal"
3406
3227
                pass
3407
 
 
 
3228
            
3408
3229
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
3409
3230
                               "true"})
3410
3231
            @dbus.service.signal(_interface, signature="os")
3411
3232
            def ClientRemoved(self, objpath, name):
3412
3233
                "D-Bus signal"
3413
3234
                pass
3414
 
 
 
3235
            
3415
3236
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
3416
3237
                               "true"})
3417
3238
            @dbus.service.method(_interface, out_signature="ao")
3419
3240
                "D-Bus method"
3420
3241
                return dbus.Array(c.dbus_object_path for c in
3421
3242
                                  tcp_server.clients.values())
3422
 
 
 
3243
            
3423
3244
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
3424
3245
                               "true"})
3425
3246
            @dbus.service.method(_interface,
3427
3248
            def GetAllClientsWithProperties(self):
3428
3249
                "D-Bus method"
3429
3250
                return dbus.Dictionary(
3430
 
                    {c.dbus_object_path: c.GetAll(
 
3251
                    { c.dbus_object_path: c.GetAll(
3431
3252
                        "se.recompile.Mandos.Client")
3432
 
                     for c in tcp_server.clients.values()},
 
3253
                      for c in tcp_server.clients.values() },
3433
3254
                    signature="oa{sv}")
3434
 
 
 
3255
            
3435
3256
            @dbus.service.method(_interface, in_signature="o")
3436
3257
            def RemoveClient(self, object_path):
3437
3258
                "D-Bus method"
3445
3266
                        self.client_removed_signal(c)
3446
3267
                        return
3447
3268
                raise KeyError(object_path)
3448
 
 
 
3269
            
3449
3270
            del _interface
3450
 
 
 
3271
            
3451
3272
            @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3452
 
                                 out_signature="a{oa{sa{sv}}}")
 
3273
                                 out_signature = "a{oa{sa{sv}}}")
3453
3274
            def GetManagedObjects(self):
3454
3275
                """D-Bus method"""
3455
3276
                return dbus.Dictionary(
3456
 
                    {client.dbus_object_path:
3457
 
                     dbus.Dictionary(
3458
 
                         {interface: client.GetAll(interface)
3459
 
                          for interface in
3460
 
                          client._get_all_interface_names()})
3461
 
                     for client in tcp_server.clients.values()})
3462
 
 
 
3277
                    { client.dbus_object_path:
 
3278
                      dbus.Dictionary(
 
3279
                          { interface: client.GetAll(interface)
 
3280
                            for interface in
 
3281
                                 client._get_all_interface_names()})
 
3282
                      for client in tcp_server.clients.values()})
 
3283
            
3463
3284
            def client_added_signal(self, client):
3464
3285
                """Send the new standard signal and the old signal"""
3465
3286
                if use_dbus:
3467
3288
                    self.InterfacesAdded(
3468
3289
                        client.dbus_object_path,
3469
3290
                        dbus.Dictionary(
3470
 
                            {interface: client.GetAll(interface)
3471
 
                             for interface in
3472
 
                             client._get_all_interface_names()}))
 
3291
                            { interface: client.GetAll(interface)
 
3292
                              for interface in
 
3293
                              client._get_all_interface_names()}))
3473
3294
                    # Old signal
3474
3295
                    self.ClientAdded(client.dbus_object_path)
3475
 
 
 
3296
            
3476
3297
            def client_removed_signal(self, client):
3477
3298
                """Send the new standard signal and the old signal"""
3478
3299
                if use_dbus:
3483
3304
                    # Old signal
3484
3305
                    self.ClientRemoved(client.dbus_object_path,
3485
3306
                                       client.name)
3486
 
 
 
3307
        
3487
3308
        mandos_dbus_service = MandosDBusService()
3488
 
 
3489
 
    # Save modules to variables to exempt the modules from being
3490
 
    # unloaded before the function registered with atexit() is run.
3491
 
    mp = multiprocessing
3492
 
    wn = wnull
3493
 
 
 
3309
    
3494
3310
    def cleanup():
3495
3311
        "Cleanup function; run on exit"
3496
3312
        if zeroconf:
3497
3313
            service.cleanup()
3498
 
 
3499
 
        mp.active_children()
3500
 
        wn.close()
 
3314
        
 
3315
        multiprocessing.active_children()
 
3316
        wnull.close()
3501
3317
        if not (tcp_server.clients or client_settings):
3502
3318
            return
3503
 
 
 
3319
        
3504
3320
        # Store client before exiting. Secrets are encrypted with key
3505
3321
        # based on what config file has. If config file is
3506
3322
        # removed/edited, old secret will thus be unrecovable.
3511
3327
                client.encrypted_secret = pgp.encrypt(client.secret,
3512
3328
                                                      key)
3513
3329
                client_dict = {}
3514
 
 
 
3330
                
3515
3331
                # A list of attributes that can not be pickled
3516
3332
                # + secret.
3517
 
                exclude = {"bus", "changedstate", "secret",
3518
 
                           "checker", "server_settings"}
 
3333
                exclude = { "bus", "changedstate", "secret",
 
3334
                            "checker", "server_settings" }
3519
3335
                for name, typ in inspect.getmembers(dbus.service
3520
3336
                                                    .Object):
3521
3337
                    exclude.add(name)
3522
 
 
 
3338
                
3523
3339
                client_dict["encrypted_secret"] = (client
3524
3340
                                                   .encrypted_secret)
3525
3341
                for attr in client.client_structure:
3526
3342
                    if attr not in exclude:
3527
3343
                        client_dict[attr] = getattr(client, attr)
3528
 
 
 
3344
                
3529
3345
                clients[client.name] = client_dict
3530
3346
                del client_settings[client.name]["secret"]
3531
 
 
 
3347
        
3532
3348
        try:
3533
3349
            with tempfile.NamedTemporaryFile(
3534
3350
                    mode='wb',
3537
3353
                    dir=os.path.dirname(stored_state_path),
3538
3354
                    delete=False) as stored_state:
3539
3355
                pickle.dump((clients, client_settings), stored_state,
3540
 
                            protocol=2)
 
3356
                            protocol = 2)
3541
3357
                tempname = stored_state.name
3542
3358
            os.rename(tempname, stored_state_path)
3543
3359
        except (IOError, OSError) as e:
3553
3369
                logger.warning("Could not save persistent state:",
3554
3370
                               exc_info=e)
3555
3371
                raise
3556
 
 
 
3372
        
3557
3373
        # Delete all clients, and settings from config
3558
3374
        while tcp_server.clients:
3559
3375
            name, client = tcp_server.clients.popitem()
3565
3381
            if use_dbus:
3566
3382
                mandos_dbus_service.client_removed_signal(client)
3567
3383
        client_settings.clear()
3568
 
 
 
3384
    
3569
3385
    atexit.register(cleanup)
3570
 
 
 
3386
    
3571
3387
    for client in tcp_server.clients.values():
3572
3388
        if use_dbus:
3573
3389
            # Emit D-Bus signal for adding
3575
3391
        # Need to initiate checking of clients
3576
3392
        if client.enabled:
3577
3393
            client.init_checker()
3578
 
 
 
3394
    
3579
3395
    tcp_server.enable()
3580
3396
    tcp_server.server_activate()
3581
 
 
 
3397
    
3582
3398
    # Find out what port we got
3583
3399
    if zeroconf:
3584
3400
        service.port = tcp_server.socket.getsockname()[1]
3589
3405
    else:                       # IPv4
3590
3406
        logger.info("Now listening on address %r, port %d",
3591
3407
                    *tcp_server.socket.getsockname())
3592
 
 
3593
 
    # service.interface = tcp_server.socket.getsockname()[3]
3594
 
 
 
3408
    
 
3409
    #service.interface = tcp_server.socket.getsockname()[3]
 
3410
    
3595
3411
    try:
3596
3412
        if zeroconf:
3597
3413
            # From the Avahi example code
3602
3418
                cleanup()
3603
3419
                sys.exit(1)
3604
3420
            # End of Avahi example code
3605
 
 
3606
 
        GLib.io_add_watch(
3607
 
            GLib.IOChannel.unix_new(tcp_server.fileno()),
3608
 
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3609
 
            lambda *args, **kwargs: (tcp_server.handle_request
3610
 
                                     (*args[2:], **kwargs) or True))
3611
 
 
 
3421
        
 
3422
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
 
3423
                          lambda *args, **kwargs:
 
3424
                          (tcp_server.handle_request
 
3425
                           (*args[2:], **kwargs) or True))
 
3426
        
3612
3427
        logger.debug("Starting main loop")
3613
3428
        main_loop.run()
3614
3429
    except AvahiError as error:
3623
3438
    # Must run before the D-Bus bus name gets deregistered
3624
3439
    cleanup()
3625
3440
 
3626
 
 
3627
 
def should_only_run_tests():
3628
 
    parser = argparse.ArgumentParser(add_help=False)
3629
 
    parser.add_argument("--check", action='store_true')
3630
 
    args, unknown_args = parser.parse_known_args()
3631
 
    run_tests = args.check
3632
 
    if run_tests:
3633
 
        # Remove --check argument from sys.argv
3634
 
        sys.argv[1:] = unknown_args
3635
 
    return run_tests
3636
 
 
3637
 
# Add all tests from doctest strings
3638
 
def load_tests(loader, tests, none):
3639
 
    import doctest
3640
 
    tests.addTests(doctest.DocTestSuite())
3641
 
    return tests
3642
3441
 
3643
3442
if __name__ == '__main__':
3644
 
    try:
3645
 
        if should_only_run_tests():
3646
 
            # Call using ./mandos --check [--verbose]
3647
 
            unittest.main()
3648
 
        else:
3649
 
            main()
3650
 
    finally:
3651
 
        logging.shutdown()
 
3443
    main()