/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

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

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

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

Show diffs side-by-side

added added

removed removed

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