/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2016-03-23 07:11:22 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 343.
  • Revision ID: teddy@recompile.se-20160323071122-55srtjdizr21rr7f
Use HTTPS in home page links

Since we have a real certificate now, change all links to the home
page to use HTTPS.

* README: Use HTTPS in home page links
* debian/control (Source: mandos/Homepage): - '' -
* debian/copyright (Source): - '' -
* intro.xml (SEE ALSO): - '' -
* mandos.lsm (Primary-site): - '' -

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