/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 at recompile
  • Date: 2020-07-04 11:58:52 UTC
  • Revision ID: teddy@recompile.se-20200704115852-oquhnmng3zom4ldl
Update copyright year

* DBUS-API: Update copyright year to 2020
* debian/copyright: - '' -
* dracut-module/ask-password-mandos.service: - '' -
* dracut-module/password-agent.c: - '' -
* mandos: - '' -
* mandos-ctl: - '' -
* plugin-runner.c: - '' -
* plugins.d/mandos-client.c: - '' -
* plugins.d/plymouth.c: - '' -
* mandos-to-cryptroot-unlock: Update copyright year to 2019.

Show diffs side-by-side

added added

removed removed

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