/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-03-10 18:03:38 UTC
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python
 
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
13
13
# Everything else is
14
 
# Copyright © 2008-2012 Teddy Hogeborn
15
 
# Copyright © 2008-2012 Björn Påhlsson
 
14
# Copyright © 2008-2014 Teddy Hogeborn
 
15
# Copyright © 2008-2014 Björn Påhlsson
16
16
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
 
37
from future_builtins import *
 
38
 
37
39
import SocketServer as socketserver
38
40
import socket
39
41
import argparse
65
67
import types
66
68
import binascii
67
69
import tempfile
 
70
import itertools
 
71
import collections
68
72
 
69
73
import dbus
70
74
import dbus.service
75
79
import ctypes.util
76
80
import xml.dom.minidom
77
81
import inspect
78
 
import GnuPGInterface
79
82
 
80
83
try:
81
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
85
88
    except ImportError:
86
89
        SO_BINDTODEVICE = None
87
90
 
88
 
version = "1.5.3"
 
91
if sys.version_info.major == 2:
 
92
    str = unicode
 
93
 
 
94
version = "1.6.9"
89
95
stored_state_file = "clients.pickle"
90
96
 
91
97
logger = logging.getLogger()
92
 
syslogger = (logging.handlers.SysLogHandler
93
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
 
              address = str("/dev/log")))
 
98
syslogger = None
95
99
 
96
100
try:
97
101
    if_nametoindex = (ctypes.cdll.LoadLibrary
103
107
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
104
108
        with contextlib.closing(socket.socket()) as s:
105
109
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
106
 
                                struct.pack(str("16s16x"),
107
 
                                            interface))
108
 
        interface_index = struct.unpack(str("I"),
109
 
                                        ifreq[16:20])[0]
 
110
                                struct.pack(b"16s16x", interface))
 
111
        interface_index = struct.unpack("I", ifreq[16:20])[0]
110
112
        return interface_index
111
113
 
112
114
 
113
115
def initlogger(debug, level=logging.WARNING):
114
116
    """init logger and add loglevel"""
115
117
    
 
118
    global syslogger
 
119
    syslogger = (logging.handlers.SysLogHandler
 
120
                 (facility =
 
121
                  logging.handlers.SysLogHandler.LOG_DAEMON,
 
122
                  address = "/dev/log"))
116
123
    syslogger.setFormatter(logging.Formatter
117
124
                           ('Mandos [%(process)d]: %(levelname)s:'
118
125
                            ' %(message)s'))
136
143
class PGPEngine(object):
137
144
    """A simple class for OpenPGP symmetric encryption & decryption"""
138
145
    def __init__(self):
139
 
        self.gnupg = GnuPGInterface.GnuPG()
140
146
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
141
 
        self.gnupg = GnuPGInterface.GnuPG()
142
 
        self.gnupg.options.meta_interactive = False
143
 
        self.gnupg.options.homedir = self.tempdir
144
 
        self.gnupg.options.extra_args.extend(['--force-mdc',
145
 
                                              '--quiet',
146
 
                                              '--no-use-agent'])
 
147
        self.gnupgargs = ['--batch',
 
148
                          '--home', self.tempdir,
 
149
                          '--force-mdc',
 
150
                          '--quiet',
 
151
                          '--no-use-agent']
147
152
    
148
153
    def __enter__(self):
149
154
        return self
150
155
    
151
 
    def __exit__ (self, exc_type, exc_value, traceback):
 
156
    def __exit__(self, exc_type, exc_value, traceback):
152
157
        self._cleanup()
153
158
        return False
154
159
    
171
176
    def password_encode(self, password):
172
177
        # Passphrase can not be empty and can not contain newlines or
173
178
        # NUL bytes.  So we prefix it and hex encode it.
174
 
        return b"mandos" + binascii.hexlify(password)
 
179
        encoded = b"mandos" + binascii.hexlify(password)
 
180
        if len(encoded) > 2048:
 
181
            # GnuPG can't handle long passwords, so encode differently
 
182
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
183
                       .replace(b"\n", b"\\n")
 
184
                       .replace(b"\0", b"\\x00"))
 
185
        return encoded
175
186
    
176
187
    def encrypt(self, data, password):
177
 
        self.gnupg.passphrase = self.password_encode(password)
178
 
        with open(os.devnull) as devnull:
179
 
            try:
180
 
                proc = self.gnupg.run(['--symmetric'],
181
 
                                      create_fhs=['stdin', 'stdout'],
182
 
                                      attach_fhs={'stderr': devnull})
183
 
                with contextlib.closing(proc.handles['stdin']) as f:
184
 
                    f.write(data)
185
 
                with contextlib.closing(proc.handles['stdout']) as f:
186
 
                    ciphertext = f.read()
187
 
                proc.wait()
188
 
            except IOError as e:
189
 
                raise PGPError(e)
190
 
        self.gnupg.passphrase = None
 
188
        passphrase = self.password_encode(password)
 
189
        with tempfile.NamedTemporaryFile(dir=self.tempdir
 
190
                                         ) as passfile:
 
191
            passfile.write(passphrase)
 
192
            passfile.flush()
 
193
            proc = subprocess.Popen(['gpg', '--symmetric',
 
194
                                     '--passphrase-file',
 
195
                                     passfile.name]
 
196
                                    + self.gnupgargs,
 
197
                                    stdin = subprocess.PIPE,
 
198
                                    stdout = subprocess.PIPE,
 
199
                                    stderr = subprocess.PIPE)
 
200
            ciphertext, err = proc.communicate(input = data)
 
201
        if proc.returncode != 0:
 
202
            raise PGPError(err)
191
203
        return ciphertext
192
204
    
193
205
    def decrypt(self, data, password):
194
 
        self.gnupg.passphrase = self.password_encode(password)
195
 
        with open(os.devnull) as devnull:
196
 
            try:
197
 
                proc = self.gnupg.run(['--decrypt'],
198
 
                                      create_fhs=['stdin', 'stdout'],
199
 
                                      attach_fhs={'stderr': devnull})
200
 
                with contextlib.closing(proc.handles['stdin'] ) as f:
201
 
                    f.write(data)
202
 
                with contextlib.closing(proc.handles['stdout']) as f:
203
 
                    decrypted_plaintext = f.read()
204
 
                proc.wait()
205
 
            except IOError as e:
206
 
                raise PGPError(e)
207
 
        self.gnupg.passphrase = None
 
206
        passphrase = self.password_encode(password)
 
207
        with tempfile.NamedTemporaryFile(dir = self.tempdir
 
208
                                         ) as passfile:
 
209
            passfile.write(passphrase)
 
210
            passfile.flush()
 
211
            proc = subprocess.Popen(['gpg', '--decrypt',
 
212
                                     '--passphrase-file',
 
213
                                     passfile.name]
 
214
                                    + self.gnupgargs,
 
215
                                    stdin = subprocess.PIPE,
 
216
                                    stdout = subprocess.PIPE,
 
217
                                    stderr = subprocess.PIPE)
 
218
            decrypted_plaintext, err = proc.communicate(input
 
219
                                                        = data)
 
220
        if proc.returncode != 0:
 
221
            raise PGPError(err)
208
222
        return decrypted_plaintext
209
223
 
210
224
 
211
 
 
212
225
class AvahiError(Exception):
213
226
    def __init__(self, value, *args, **kwargs):
214
227
        self.value = value
215
 
        super(AvahiError, self).__init__(value, *args, **kwargs)
216
 
    def __unicode__(self):
217
 
        return unicode(repr(self.value))
 
228
        return super(AvahiError, self).__init__(value, *args,
 
229
                                                **kwargs)
218
230
 
219
231
class AvahiServiceError(AvahiError):
220
232
    pass
231
243
               Used to optionally bind to the specified interface.
232
244
    name: string; Example: 'Mandos'
233
245
    type: string; Example: '_mandos._tcp'.
234
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
246
     See <https://www.iana.org/assignments/service-names-port-numbers>
235
247
    port: integer; what port to announce
236
248
    TXT: list of strings; TXT record for the service
237
249
    domain: string; Domain to publish on, default to .local if empty.
243
255
    server: D-Bus Server
244
256
    bus: dbus.SystemBus()
245
257
    """
 
258
    
246
259
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
247
260
                 servicetype = None, port = None, TXT = None,
248
261
                 domain = "", host = "", max_renames = 32768,
261
274
        self.server = None
262
275
        self.bus = bus
263
276
        self.entry_group_state_changed_match = None
264
 
    def rename(self):
 
277
    
 
278
    def rename(self, remove=True):
265
279
        """Derived from the Avahi example code"""
266
280
        if self.rename_count >= self.max_renames:
267
281
            logger.critical("No suitable Zeroconf service name found"
268
282
                            " after %i retries, exiting.",
269
283
                            self.rename_count)
270
284
            raise AvahiServiceError("Too many renames")
271
 
        self.name = unicode(self.server
272
 
                            .GetAlternativeServiceName(self.name))
 
285
        self.name = str(self.server
 
286
                        .GetAlternativeServiceName(self.name))
 
287
        self.rename_count += 1
273
288
        logger.info("Changing Zeroconf service name to %r ...",
274
289
                    self.name)
275
 
        self.remove()
 
290
        if remove:
 
291
            self.remove()
276
292
        try:
277
293
            self.add()
278
294
        except dbus.exceptions.DBusException as error:
279
 
            logger.critical("DBusException: %s", error)
280
 
            self.cleanup()
281
 
            os._exit(1)
282
 
        self.rename_count += 1
 
295
            if (error.get_dbus_name()
 
296
                == "org.freedesktop.Avahi.CollisionError"):
 
297
                logger.info("Local Zeroconf service name collision.")
 
298
                return self.rename(remove=False)
 
299
            else:
 
300
                logger.critical("D-Bus Exception", exc_info=error)
 
301
                self.cleanup()
 
302
                os._exit(1)
 
303
    
283
304
    def remove(self):
284
305
        """Derived from the Avahi example code"""
285
306
        if self.entry_group_state_changed_match is not None:
287
308
            self.entry_group_state_changed_match = None
288
309
        if self.group is not None:
289
310
            self.group.Reset()
 
311
    
290
312
    def add(self):
291
313
        """Derived from the Avahi example code"""
292
314
        self.remove()
309
331
            dbus.UInt16(self.port),
310
332
            avahi.string_array_to_txt_array(self.TXT))
311
333
        self.group.Commit()
 
334
    
312
335
    def entry_group_state_changed(self, state, error):
313
336
        """Derived from the Avahi example code"""
314
337
        logger.debug("Avahi entry group state change: %i", state)
320
343
            self.rename()
321
344
        elif state == avahi.ENTRY_GROUP_FAILURE:
322
345
            logger.critical("Avahi: Error in group state changed %s",
323
 
                            unicode(error))
324
 
            raise AvahiGroupError("State changed: %s"
325
 
                                  % unicode(error))
 
346
                            str(error))
 
347
            raise AvahiGroupError("State changed: {!s}"
 
348
                                  .format(error))
 
349
    
326
350
    def cleanup(self):
327
351
        """Derived from the Avahi example code"""
328
352
        if self.group is not None:
333
357
                pass
334
358
            self.group = None
335
359
        self.remove()
 
360
    
336
361
    def server_state_changed(self, state, error=None):
337
362
        """Derived from the Avahi example code"""
338
363
        logger.debug("Avahi server state change: %i", state)
357
382
                logger.debug("Unknown state: %r", state)
358
383
            else:
359
384
                logger.debug("Unknown state: %r: %r", state, error)
 
385
    
360
386
    def activate(self):
361
387
        """Derived from the Avahi example code"""
362
388
        if self.server is None:
369
395
                                 self.server_state_changed)
370
396
        self.server_state_changed(self.server.GetState())
371
397
 
 
398
 
372
399
class AvahiServiceToSyslog(AvahiService):
373
 
    def rename(self):
 
400
    def rename(self, *args, **kwargs):
374
401
        """Add the new name to the syslog messages"""
375
 
        ret = AvahiService.rename(self)
 
402
        ret = AvahiService.rename(self, *args, **kwargs)
376
403
        syslogger.setFormatter(logging.Formatter
377
 
                               ('Mandos (%s) [%%(process)d]:'
378
 
                                ' %%(levelname)s: %%(message)s'
379
 
                                % self.name))
 
404
                               ('Mandos ({}) [%(process)d]:'
 
405
                                ' %(levelname)s: %(message)s'
 
406
                                .format(self.name)))
380
407
        return ret
381
408
 
382
 
def timedelta_to_milliseconds(td):
383
 
    "Convert a datetime.timedelta() to milliseconds"
384
 
    return ((td.days * 24 * 60 * 60 * 1000)
385
 
            + (td.seconds * 1000)
386
 
            + (td.microseconds // 1000))
387
 
        
 
409
 
388
410
class Client(object):
389
411
    """A representation of a client host served by this server.
390
412
    
426
448
    runtime_expansions: Allowed attributes for runtime expansion.
427
449
    expires:    datetime.datetime(); time (UTC) when a client will be
428
450
                disabled, or None
 
451
    server_settings: The server_settings dict from main()
429
452
    """
430
453
    
431
454
    runtime_expansions = ("approval_delay", "approval_duration",
432
 
                          "created", "enabled", "fingerprint",
433
 
                          "host", "interval", "last_checked_ok",
 
455
                          "created", "enabled", "expires",
 
456
                          "fingerprint", "host", "interval",
 
457
                          "last_approval_request", "last_checked_ok",
434
458
                          "last_enabled", "name", "timeout")
435
 
    client_defaults = { "timeout": "5m",
436
 
                        "extended_timeout": "15m",
437
 
                        "interval": "2m",
 
459
    client_defaults = { "timeout": "PT5M",
 
460
                        "extended_timeout": "PT15M",
 
461
                        "interval": "PT2M",
438
462
                        "checker": "fping -q -- %%(host)s",
439
463
                        "host": "",
440
 
                        "approval_delay": "0s",
441
 
                        "approval_duration": "1s",
 
464
                        "approval_delay": "PT0S",
 
465
                        "approval_duration": "PT1S",
442
466
                        "approved_by_default": "True",
443
467
                        "enabled": "True",
444
468
                        }
445
469
    
446
 
    def timeout_milliseconds(self):
447
 
        "Return the 'timeout' attribute in milliseconds"
448
 
        return timedelta_to_milliseconds(self.timeout)
449
 
    
450
 
    def extended_timeout_milliseconds(self):
451
 
        "Return the 'extended_timeout' attribute in milliseconds"
452
 
        return timedelta_to_milliseconds(self.extended_timeout)
453
 
    
454
 
    def interval_milliseconds(self):
455
 
        "Return the 'interval' attribute in milliseconds"
456
 
        return timedelta_to_milliseconds(self.interval)
457
 
    
458
 
    def approval_delay_milliseconds(self):
459
 
        return timedelta_to_milliseconds(self.approval_delay)
460
 
 
461
470
    @staticmethod
462
471
    def config_parser(config):
463
472
        """Construct a new dict of client settings of this form:
478
487
            client["enabled"] = config.getboolean(client_name,
479
488
                                                  "enabled")
480
489
            
 
490
            # Uppercase and remove spaces from fingerprint for later
 
491
            # comparison purposes with return value from the
 
492
            # fingerprint() function
481
493
            client["fingerprint"] = (section["fingerprint"].upper()
482
494
                                     .replace(" ", ""))
483
495
            if "secret" in section:
488
500
                          "rb") as secfile:
489
501
                    client["secret"] = secfile.read()
490
502
            else:
491
 
                raise TypeError("No secret or secfile for section %s"
492
 
                                % section)
 
503
                raise TypeError("No secret or secfile for section {}"
 
504
                                .format(section))
493
505
            client["timeout"] = string_to_delta(section["timeout"])
494
506
            client["extended_timeout"] = string_to_delta(
495
507
                section["extended_timeout"])
504
516
            client["last_checker_status"] = -2
505
517
        
506
518
        return settings
507
 
        
508
 
        
509
 
    def __init__(self, settings, name = None):
510
 
        """Note: the 'checker' key in 'config' sets the
511
 
        'checker_command' attribute and *not* the 'checker'
512
 
        attribute."""
 
519
    
 
520
    def __init__(self, settings, name = None, server_settings=None):
513
521
        self.name = name
 
522
        if server_settings is None:
 
523
            server_settings = {}
 
524
        self.server_settings = server_settings
514
525
        # adding all client settings
515
 
        for setting, value in settings.iteritems():
 
526
        for setting, value in settings.items():
516
527
            setattr(self, setting, value)
517
528
        
518
529
        if self.enabled:
524
535
        else:
525
536
            self.last_enabled = None
526
537
            self.expires = None
527
 
       
 
538
        
528
539
        logger.debug("Creating client %r", self.name)
529
 
        # Uppercase and remove spaces from fingerprint for later
530
 
        # comparison purposes with return value from the fingerprint()
531
 
        # function
532
540
        logger.debug("  Fingerprint: %s", self.fingerprint)
533
541
        self.created = settings.get("created",
534
542
                                    datetime.datetime.utcnow())
535
 
 
 
543
        
536
544
        # attributes specific for this server instance
537
545
        self.checker = None
538
546
        self.checker_initiator_tag = None
566
574
        if getattr(self, "enabled", False):
567
575
            # Already enabled
568
576
            return
569
 
        self.send_changedstate()
570
577
        self.expires = datetime.datetime.utcnow() + self.timeout
571
578
        self.enabled = True
572
579
        self.last_enabled = datetime.datetime.utcnow()
573
580
        self.init_checker()
 
581
        self.send_changedstate()
574
582
    
575
583
    def disable(self, quiet=True):
576
584
        """Disable this client."""
577
585
        if not getattr(self, "enabled", False):
578
586
            return False
579
587
        if not quiet:
580
 
            self.send_changedstate()
581
 
        if not quiet:
582
588
            logger.info("Disabling client %s", self.name)
583
 
        if getattr(self, "disable_initiator_tag", False):
 
589
        if getattr(self, "disable_initiator_tag", None) is not None:
584
590
            gobject.source_remove(self.disable_initiator_tag)
585
591
            self.disable_initiator_tag = None
586
592
        self.expires = None
587
 
        if getattr(self, "checker_initiator_tag", False):
 
593
        if getattr(self, "checker_initiator_tag", None) is not None:
588
594
            gobject.source_remove(self.checker_initiator_tag)
589
595
            self.checker_initiator_tag = None
590
596
        self.stop_checker()
591
597
        self.enabled = False
 
598
        if not quiet:
 
599
            self.send_changedstate()
592
600
        # Do not run this again if called by a gobject.timeout_add
593
601
        return False
594
602
    
598
606
    def init_checker(self):
599
607
        # Schedule a new checker to be started an 'interval' from now,
600
608
        # and every interval from then on.
 
609
        if self.checker_initiator_tag is not None:
 
610
            gobject.source_remove(self.checker_initiator_tag)
601
611
        self.checker_initiator_tag = (gobject.timeout_add
602
 
                                      (self.interval_milliseconds(),
 
612
                                      (int(self.interval
 
613
                                           .total_seconds() * 1000),
603
614
                                       self.start_checker))
604
615
        # Schedule a disable() when 'timeout' has passed
 
616
        if self.disable_initiator_tag is not None:
 
617
            gobject.source_remove(self.disable_initiator_tag)
605
618
        self.disable_initiator_tag = (gobject.timeout_add
606
 
                                   (self.timeout_milliseconds(),
607
 
                                    self.disable))
 
619
                                      (int(self.timeout
 
620
                                           .total_seconds() * 1000),
 
621
                                       self.disable))
608
622
        # Also start a new checker *right now*.
609
623
        self.start_checker()
610
624
    
638
652
            timeout = self.timeout
639
653
        if self.disable_initiator_tag is not None:
640
654
            gobject.source_remove(self.disable_initiator_tag)
 
655
            self.disable_initiator_tag = None
641
656
        if getattr(self, "enabled", False):
642
657
            self.disable_initiator_tag = (gobject.timeout_add
643
 
                                          (timedelta_to_milliseconds
644
 
                                           (timeout), self.disable))
 
658
                                          (int(timeout.total_seconds()
 
659
                                               * 1000), self.disable))
645
660
            self.expires = datetime.datetime.utcnow() + timeout
646
661
    
647
662
    def need_approval(self):
653
668
        If a checker already exists, leave it running and do
654
669
        nothing."""
655
670
        # The reason for not killing a running checker is that if we
656
 
        # did that, then if a checker (for some reason) started
657
 
        # running slowly and taking more than 'interval' time, the
658
 
        # client would inevitably timeout, since no checker would get
659
 
        # a chance to run to completion.  If we instead leave running
 
671
        # did that, and if a checker (for some reason) started running
 
672
        # slowly and taking more than 'interval' time, then the client
 
673
        # would inevitably timeout, since no checker would get a
 
674
        # chance to run to completion.  If we instead leave running
660
675
        # checkers alone, the checker would have to take more time
661
676
        # than 'timeout' for the client to be disabled, which is as it
662
677
        # should be.
664
679
        # If a checker exists, make sure it is not a zombie
665
680
        try:
666
681
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
667
 
        except (AttributeError, OSError) as error:
668
 
            if (isinstance(error, OSError)
669
 
                and error.errno != errno.ECHILD):
670
 
                raise error
 
682
        except AttributeError:
 
683
            pass
 
684
        except OSError as error:
 
685
            if error.errno != errno.ECHILD:
 
686
                raise
671
687
        else:
672
688
            if pid:
673
689
                logger.warning("Checker was a zombie")
676
692
                                      self.current_checker_command)
677
693
        # Start a new checker if needed
678
694
        if self.checker is None:
 
695
            # Escape attributes for the shell
 
696
            escaped_attrs = { attr:
 
697
                                  re.escape(str(getattr(self, attr)))
 
698
                              for attr in self.runtime_expansions }
679
699
            try:
680
 
                # In case checker_command has exactly one % operator
681
 
                command = self.checker_command % self.host
682
 
            except TypeError:
683
 
                # Escape attributes for the shell
684
 
                escaped_attrs = dict(
685
 
                    (attr,
686
 
                     re.escape(unicode(str(getattr(self, attr, "")),
687
 
                                       errors=
688
 
                                       'replace')))
689
 
                    for attr in
690
 
                    self.runtime_expansions)
691
 
                
692
 
                try:
693
 
                    command = self.checker_command % escaped_attrs
694
 
                except TypeError as error:
695
 
                    logger.error('Could not format string "%s":'
696
 
                                 ' %s', self.checker_command, error)
697
 
                    return True # Try again later
 
700
                command = self.checker_command % escaped_attrs
 
701
            except TypeError as error:
 
702
                logger.error('Could not format string "%s"',
 
703
                             self.checker_command, exc_info=error)
 
704
                return True # Try again later
698
705
            self.current_checker_command = command
699
706
            try:
700
707
                logger.info("Starting checker %r for %s",
703
710
                # in normal mode, that is already done by daemon(),
704
711
                # and in debug mode we don't want to.  (Stdin is
705
712
                # always replaced by /dev/null.)
 
713
                # The exception is when not debugging but nevertheless
 
714
                # running in the foreground; use the previously
 
715
                # created wnull.
 
716
                popen_args = {}
 
717
                if (not self.server_settings["debug"]
 
718
                    and self.server_settings["foreground"]):
 
719
                    popen_args.update({"stdout": wnull,
 
720
                                       "stderr": wnull })
706
721
                self.checker = subprocess.Popen(command,
707
722
                                                close_fds=True,
708
 
                                                shell=True, cwd="/")
709
 
                self.checker_callback_tag = (gobject.child_watch_add
710
 
                                             (self.checker.pid,
711
 
                                              self.checker_callback,
712
 
                                              data=command))
713
 
                # The checker may have completed before the gobject
714
 
                # watch was added.  Check for this.
 
723
                                                shell=True, cwd="/",
 
724
                                                **popen_args)
 
725
            except OSError as error:
 
726
                logger.error("Failed to start subprocess",
 
727
                             exc_info=error)
 
728
                return True
 
729
            self.checker_callback_tag = (gobject.child_watch_add
 
730
                                         (self.checker.pid,
 
731
                                          self.checker_callback,
 
732
                                          data=command))
 
733
            # The checker may have completed before the gobject
 
734
            # watch was added.  Check for this.
 
735
            try:
715
736
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
716
 
                if pid:
717
 
                    gobject.source_remove(self.checker_callback_tag)
718
 
                    self.checker_callback(pid, status, command)
719
737
            except OSError as error:
720
 
                logger.error("Failed to start subprocess: %s",
721
 
                             error)
 
738
                if error.errno == errno.ECHILD:
 
739
                    # This should never happen
 
740
                    logger.error("Child process vanished",
 
741
                                 exc_info=error)
 
742
                    return True
 
743
                raise
 
744
            if pid:
 
745
                gobject.source_remove(self.checker_callback_tag)
 
746
                self.checker_callback(pid, status, command)
722
747
        # Re-run this periodically if run by gobject.timeout_add
723
748
        return True
724
749
    
731
756
            return
732
757
        logger.debug("Stopping checker for %(name)s", vars(self))
733
758
        try:
734
 
            os.kill(self.checker.pid, signal.SIGTERM)
 
759
            self.checker.terminate()
735
760
            #time.sleep(0.5)
736
761
            #if self.checker.poll() is None:
737
 
            #    os.kill(self.checker.pid, signal.SIGKILL)
 
762
            #    self.checker.kill()
738
763
        except OSError as error:
739
764
            if error.errno != errno.ESRCH: # No such process
740
765
                raise
757
782
    # "Set" method, so we fail early here:
758
783
    if byte_arrays and signature != "ay":
759
784
        raise ValueError("Byte arrays not supported for non-'ay'"
760
 
                         " signature %r" % signature)
 
785
                         " signature {!r}".format(signature))
761
786
    def decorator(func):
762
787
        func._dbus_is_property = True
763
788
        func._dbus_interface = dbus_interface
771
796
    return decorator
772
797
 
773
798
 
 
799
def dbus_interface_annotations(dbus_interface):
 
800
    """Decorator for marking functions returning interface annotations
 
801
    
 
802
    Usage:
 
803
    
 
804
    @dbus_interface_annotations("org.example.Interface")
 
805
    def _foo(self):  # Function name does not matter
 
806
        return {"org.freedesktop.DBus.Deprecated": "true",
 
807
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
808
                    "false"}
 
809
    """
 
810
    def decorator(func):
 
811
        func._dbus_is_interface = True
 
812
        func._dbus_interface = dbus_interface
 
813
        func._dbus_name = dbus_interface
 
814
        return func
 
815
    return decorator
 
816
 
 
817
 
 
818
def dbus_annotations(annotations):
 
819
    """Decorator to annotate D-Bus methods, signals or properties
 
820
    Usage:
 
821
    
 
822
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
 
823
                       "org.freedesktop.DBus.Property."
 
824
                       "EmitsChangedSignal": "false"})
 
825
    @dbus_service_property("org.example.Interface", signature="b",
 
826
                           access="r")
 
827
    def Property_dbus_property(self):
 
828
        return dbus.Boolean(False)
 
829
    """
 
830
    def decorator(func):
 
831
        func._dbus_annotations = annotations
 
832
        return func
 
833
    return decorator
 
834
 
 
835
 
774
836
class DBusPropertyException(dbus.exceptions.DBusException):
775
837
    """A base class for D-Bus property-related exceptions
776
838
    """
777
 
    def __unicode__(self):
778
 
        return unicode(str(self))
779
 
 
 
839
    pass
780
840
 
781
841
class DBusPropertyAccessException(DBusPropertyException):
782
842
    """A property's access permissions disallows an operation.
799
859
    """
800
860
    
801
861
    @staticmethod
802
 
    def _is_dbus_property(obj):
803
 
        return getattr(obj, "_dbus_is_property", False)
 
862
    def _is_dbus_thing(thing):
 
863
        """Returns a function testing if an attribute is a D-Bus thing
 
864
        
 
865
        If called like _is_dbus_thing("method") it returns a function
 
866
        suitable for use as predicate to inspect.getmembers().
 
867
        """
 
868
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
 
869
                                   False)
804
870
    
805
 
    def _get_all_dbus_properties(self):
 
871
    def _get_all_dbus_things(self, thing):
806
872
        """Returns a generator of (name, attribute) pairs
807
873
        """
808
 
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
 
874
        return ((getattr(athing.__get__(self), "_dbus_name",
 
875
                         name),
 
876
                 athing.__get__(self))
809
877
                for cls in self.__class__.__mro__
810
 
                for name, prop in
811
 
                inspect.getmembers(cls, self._is_dbus_property))
 
878
                for name, athing in
 
879
                inspect.getmembers(cls,
 
880
                                   self._is_dbus_thing(thing)))
812
881
    
813
882
    def _get_dbus_property(self, interface_name, property_name):
814
883
        """Returns a bound method if one exists which is a D-Bus
816
885
        """
817
886
        for cls in  self.__class__.__mro__:
818
887
            for name, value in (inspect.getmembers
819
 
                                (cls, self._is_dbus_property)):
 
888
                                (cls,
 
889
                                 self._is_dbus_thing("property"))):
820
890
                if (value._dbus_name == property_name
821
891
                    and value._dbus_interface == interface_name):
822
892
                    return value.__get__(self)
850
920
            # The byte_arrays option is not supported yet on
851
921
            # signatures other than "ay".
852
922
            if prop._dbus_signature != "ay":
853
 
                raise ValueError
 
923
                raise ValueError("Byte arrays not supported for non-"
 
924
                                 "'ay' signature {!r}"
 
925
                                 .format(prop._dbus_signature))
854
926
            value = dbus.ByteArray(b''.join(chr(byte)
855
927
                                            for byte in value))
856
928
        prop(value)
864
936
        Note: Will not include properties with access="write".
865
937
        """
866
938
        properties = {}
867
 
        for name, prop in self._get_all_dbus_properties():
 
939
        for name, prop in self._get_all_dbus_things("property"):
868
940
            if (interface_name
869
941
                and interface_name != prop._dbus_interface):
870
942
                # Interface non-empty but did not match
880
952
                                           value.variant_level+1)
881
953
        return dbus.Dictionary(properties, signature="sv")
882
954
    
 
955
    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
 
956
    def PropertiesChanged(self, interface_name, changed_properties,
 
957
                          invalidated_properties):
 
958
        """Standard D-Bus PropertiesChanged() signal, see D-Bus
 
959
        standard.
 
960
        """
 
961
        pass
 
962
    
883
963
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
884
964
                         out_signature="s",
885
965
                         path_keyword='object_path',
886
966
                         connection_keyword='connection')
887
967
    def Introspect(self, object_path, connection):
888
 
        """Standard D-Bus method, overloaded to insert property tags.
 
968
        """Overloading of standard D-Bus method.
 
969
        
 
970
        Inserts property tags and interface annotation tags.
889
971
        """
890
972
        xmlstring = dbus.service.Object.Introspect(self, object_path,
891
973
                                                   connection)
898
980
                e.setAttribute("access", prop._dbus_access)
899
981
                return e
900
982
            for if_tag in document.getElementsByTagName("interface"):
 
983
                # Add property tags
901
984
                for tag in (make_tag(document, name, prop)
902
985
                            for name, prop
903
 
                            in self._get_all_dbus_properties()
 
986
                            in self._get_all_dbus_things("property")
904
987
                            if prop._dbus_interface
905
988
                            == if_tag.getAttribute("name")):
906
989
                    if_tag.appendChild(tag)
 
990
                # Add annotation tags
 
991
                for typ in ("method", "signal", "property"):
 
992
                    for tag in if_tag.getElementsByTagName(typ):
 
993
                        annots = dict()
 
994
                        for name, prop in (self.
 
995
                                           _get_all_dbus_things(typ)):
 
996
                            if (name == tag.getAttribute("name")
 
997
                                and prop._dbus_interface
 
998
                                == if_tag.getAttribute("name")):
 
999
                                annots.update(getattr
 
1000
                                              (prop,
 
1001
                                               "_dbus_annotations",
 
1002
                                               {}))
 
1003
                        for name, value in annots.items():
 
1004
                            ann_tag = document.createElement(
 
1005
                                "annotation")
 
1006
                            ann_tag.setAttribute("name", name)
 
1007
                            ann_tag.setAttribute("value", value)
 
1008
                            tag.appendChild(ann_tag)
 
1009
                # Add interface annotation tags
 
1010
                for annotation, value in dict(
 
1011
                    itertools.chain.from_iterable(
 
1012
                        annotations().items()
 
1013
                        for name, annotations in
 
1014
                        self._get_all_dbus_things("interface")
 
1015
                        if name == if_tag.getAttribute("name")
 
1016
                        )).items():
 
1017
                    ann_tag = document.createElement("annotation")
 
1018
                    ann_tag.setAttribute("name", annotation)
 
1019
                    ann_tag.setAttribute("value", value)
 
1020
                    if_tag.appendChild(ann_tag)
907
1021
                # Add the names to the return values for the
908
1022
                # "org.freedesktop.DBus.Properties" methods
909
1023
                if (if_tag.getAttribute("name")
924
1038
        except (AttributeError, xml.dom.DOMException,
925
1039
                xml.parsers.expat.ExpatError) as error:
926
1040
            logger.error("Failed to override Introspection method",
927
 
                         error)
 
1041
                         exc_info=error)
928
1042
        return xmlstring
929
1043
 
930
1044
 
931
 
def datetime_to_dbus (dt, variant_level=0):
 
1045
def datetime_to_dbus(dt, variant_level=0):
932
1046
    """Convert a UTC datetime.datetime() to a D-Bus type."""
933
1047
    if dt is None:
934
1048
        return dbus.String("", variant_level = variant_level)
936
1050
                       variant_level=variant_level)
937
1051
 
938
1052
 
939
 
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
940
 
                                  .__metaclass__):
941
 
    """Applied to an empty subclass of a D-Bus object, this metaclass
942
 
    will add additional D-Bus attributes matching a certain pattern.
 
1053
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1054
    """A class decorator; applied to a subclass of
 
1055
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1056
    interface names according to the "alt_interface_names" mapping.
 
1057
    Usage:
 
1058
    
 
1059
    @alternate_dbus_interfaces({"org.example.Interface":
 
1060
                                    "net.example.AlternateInterface"})
 
1061
    class SampleDBusObject(dbus.service.Object):
 
1062
        @dbus.service.method("org.example.Interface")
 
1063
        def SampleDBusMethod():
 
1064
            pass
 
1065
    
 
1066
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1067
    reachable via two interfaces: "org.example.Interface" and
 
1068
    "net.example.AlternateInterface", the latter of which will have
 
1069
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1070
    "true", unless "deprecate" is passed with a False value.
 
1071
    
 
1072
    This works for methods and signals, and also for D-Bus properties
 
1073
    (from DBusObjectWithProperties) and interfaces (from the
 
1074
    dbus_interface_annotations decorator).
943
1075
    """
944
 
    def __new__(mcs, name, bases, attr):
945
 
        # Go through all the base classes which could have D-Bus
946
 
        # methods, signals, or properties in them
947
 
        for base in (b for b in bases
948
 
                     if issubclass(b, dbus.service.Object)):
949
 
            # Go though all attributes of the base class
950
 
            for attrname, attribute in inspect.getmembers(base):
 
1076
    def wrapper(cls):
 
1077
        for orig_interface_name, alt_interface_name in (
 
1078
            alt_interface_names.items()):
 
1079
            attr = {}
 
1080
            interface_names = set()
 
1081
            # Go though all attributes of the class
 
1082
            for attrname, attribute in inspect.getmembers(cls):
951
1083
                # Ignore non-D-Bus attributes, and D-Bus attributes
952
1084
                # with the wrong interface name
953
1085
                if (not hasattr(attribute, "_dbus_interface")
954
1086
                    or not attribute._dbus_interface
955
 
                    .startswith("se.recompile.Mandos")):
 
1087
                    .startswith(orig_interface_name)):
956
1088
                    continue
957
1089
                # Create an alternate D-Bus interface name based on
958
1090
                # the current name
959
1091
                alt_interface = (attribute._dbus_interface
960
 
                                 .replace("se.recompile.Mandos",
961
 
                                          "se.bsnet.fukt.Mandos"))
 
1092
                                 .replace(orig_interface_name,
 
1093
                                          alt_interface_name))
 
1094
                interface_names.add(alt_interface)
962
1095
                # Is this a D-Bus signal?
963
1096
                if getattr(attribute, "_dbus_is_signal", False):
964
 
                    # Extract the original non-method function by
965
 
                    # black magic
 
1097
                    # Extract the original non-method undecorated
 
1098
                    # function by black magic
966
1099
                    nonmethod_func = (dict(
967
1100
                            zip(attribute.func_code.co_freevars,
968
1101
                                attribute.__closure__))["func"]
979
1112
                                nonmethod_func.func_name,
980
1113
                                nonmethod_func.func_defaults,
981
1114
                                nonmethod_func.func_closure)))
 
1115
                    # Copy annotations, if any
 
1116
                    try:
 
1117
                        new_function._dbus_annotations = (
 
1118
                            dict(attribute._dbus_annotations))
 
1119
                    except AttributeError:
 
1120
                        pass
982
1121
                    # Define a creator of a function to call both the
983
 
                    # old and new functions, so both the old and new
984
 
                    # signals gets sent when the function is called
 
1122
                    # original and alternate functions, so both the
 
1123
                    # original and alternate signals gets sent when
 
1124
                    # the function is called
985
1125
                    def fixscope(func1, func2):
986
1126
                        """This function is a scope container to pass
987
1127
                        func1 and func2 to the "call_both" function
994
1134
                        return call_both
995
1135
                    # Create the "call_both" function and add it to
996
1136
                    # the class
997
 
                    attr[attrname] = fixscope(attribute,
998
 
                                              new_function)
 
1137
                    attr[attrname] = fixscope(attribute, new_function)
999
1138
                # Is this a D-Bus method?
1000
1139
                elif getattr(attribute, "_dbus_is_method", False):
1001
1140
                    # Create a new, but exactly alike, function
1012
1151
                                        attribute.func_name,
1013
1152
                                        attribute.func_defaults,
1014
1153
                                        attribute.func_closure)))
 
1154
                    # Copy annotations, if any
 
1155
                    try:
 
1156
                        attr[attrname]._dbus_annotations = (
 
1157
                            dict(attribute._dbus_annotations))
 
1158
                    except AttributeError:
 
1159
                        pass
1015
1160
                # Is this a D-Bus property?
1016
1161
                elif getattr(attribute, "_dbus_is_property", False):
1017
1162
                    # Create a new, but exactly alike, function
1031
1176
                                        attribute.func_name,
1032
1177
                                        attribute.func_defaults,
1033
1178
                                        attribute.func_closure)))
1034
 
        return type.__new__(mcs, name, bases, attr)
1035
 
 
1036
 
 
 
1179
                    # Copy annotations, if any
 
1180
                    try:
 
1181
                        attr[attrname]._dbus_annotations = (
 
1182
                            dict(attribute._dbus_annotations))
 
1183
                    except AttributeError:
 
1184
                        pass
 
1185
                # Is this a D-Bus interface?
 
1186
                elif getattr(attribute, "_dbus_is_interface", False):
 
1187
                    # Create a new, but exactly alike, function
 
1188
                    # object.  Decorate it to be a new D-Bus interface
 
1189
                    # with the alternate D-Bus interface name.  Add it
 
1190
                    # to the class.
 
1191
                    attr[attrname] = (dbus_interface_annotations
 
1192
                                      (alt_interface)
 
1193
                                      (types.FunctionType
 
1194
                                       (attribute.func_code,
 
1195
                                        attribute.func_globals,
 
1196
                                        attribute.func_name,
 
1197
                                        attribute.func_defaults,
 
1198
                                        attribute.func_closure)))
 
1199
            if deprecate:
 
1200
                # Deprecate all alternate interfaces
 
1201
                iname="_AlternateDBusNames_interface_annotation{}"
 
1202
                for interface_name in interface_names:
 
1203
                    @dbus_interface_annotations(interface_name)
 
1204
                    def func(self):
 
1205
                        return { "org.freedesktop.DBus.Deprecated":
 
1206
                                     "true" }
 
1207
                    # Find an unused name
 
1208
                    for aname in (iname.format(i)
 
1209
                                  for i in itertools.count()):
 
1210
                        if aname not in attr:
 
1211
                            attr[aname] = func
 
1212
                            break
 
1213
            if interface_names:
 
1214
                # Replace the class with a new subclass of it with
 
1215
                # methods, signals, etc. as created above.
 
1216
                cls = type(b"{}Alternate".format(cls.__name__),
 
1217
                           (cls,), attr)
 
1218
        return cls
 
1219
    return wrapper
 
1220
 
 
1221
 
 
1222
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1223
                                "se.bsnet.fukt.Mandos"})
1037
1224
class ClientDBus(Client, DBusObjectWithProperties):
1038
1225
    """A Client class using D-Bus
1039
1226
    
1045
1232
    runtime_expansions = (Client.runtime_expansions
1046
1233
                          + ("dbus_object_path",))
1047
1234
    
 
1235
    _interface = "se.recompile.Mandos.Client"
 
1236
    
1048
1237
    # dbus.service.Object doesn't use super(), so we can't either.
1049
1238
    
1050
1239
    def __init__(self, bus = None, *args, **kwargs):
1052
1241
        Client.__init__(self, *args, **kwargs)
1053
1242
        # Only now, when this client is initialized, can it show up on
1054
1243
        # the D-Bus
1055
 
        client_object_name = unicode(self.name).translate(
 
1244
        client_object_name = str(self.name).translate(
1056
1245
            {ord("."): ord("_"),
1057
1246
             ord("-"): ord("_")})
1058
1247
        self.dbus_object_path = (dbus.ObjectPath
1059
1248
                                 ("/clients/" + client_object_name))
1060
1249
        DBusObjectWithProperties.__init__(self, self.bus,
1061
1250
                                          self.dbus_object_path)
1062
 
        
 
1251
    
1063
1252
    def notifychangeproperty(transform_func,
1064
1253
                             dbus_name, type_func=lambda x: x,
1065
 
                             variant_level=1):
 
1254
                             variant_level=1, invalidate_only=False,
 
1255
                             _interface=_interface):
1066
1256
        """ Modify a variable so that it's a property which announces
1067
1257
        its changes to DBus.
1068
1258
        
1073
1263
                   to the D-Bus.  Default: no transform
1074
1264
        variant_level: D-Bus variant level.  Default: 1
1075
1265
        """
1076
 
        attrname = "_{0}".format(dbus_name)
 
1266
        attrname = "_{}".format(dbus_name)
1077
1267
        def setter(self, value):
1078
1268
            if hasattr(self, "dbus_object_path"):
1079
1269
                if (not hasattr(self, attrname) or
1080
1270
                    type_func(getattr(self, attrname, None))
1081
1271
                    != type_func(value)):
1082
 
                    dbus_value = transform_func(type_func(value),
1083
 
                                                variant_level
1084
 
                                                =variant_level)
1085
 
                    self.PropertyChanged(dbus.String(dbus_name),
1086
 
                                         dbus_value)
 
1272
                    if invalidate_only:
 
1273
                        self.PropertiesChanged(_interface,
 
1274
                                               dbus.Dictionary(),
 
1275
                                               dbus.Array
 
1276
                                               ((dbus_name,)))
 
1277
                    else:
 
1278
                        dbus_value = transform_func(type_func(value),
 
1279
                                                    variant_level
 
1280
                                                    =variant_level)
 
1281
                        self.PropertyChanged(dbus.String(dbus_name),
 
1282
                                             dbus_value)
 
1283
                        self.PropertiesChanged(_interface,
 
1284
                                               dbus.Dictionary({
 
1285
                                    dbus.String(dbus_name):
 
1286
                                        dbus_value }), dbus.Array())
1087
1287
            setattr(self, attrname, value)
1088
1288
        
1089
1289
        return property(lambda self: getattr(self, attrname), setter)
1090
1290
    
1091
 
    
1092
1291
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1093
1292
    approvals_pending = notifychangeproperty(dbus.Boolean,
1094
1293
                                             "ApprovalPending",
1110
1309
    approval_delay = notifychangeproperty(dbus.UInt64,
1111
1310
                                          "ApprovalDelay",
1112
1311
                                          type_func =
1113
 
                                          timedelta_to_milliseconds)
 
1312
                                          lambda td: td.total_seconds()
 
1313
                                          * 1000)
1114
1314
    approval_duration = notifychangeproperty(
1115
1315
        dbus.UInt64, "ApprovalDuration",
1116
 
        type_func = timedelta_to_milliseconds)
 
1316
        type_func = lambda td: td.total_seconds() * 1000)
1117
1317
    host = notifychangeproperty(dbus.String, "Host")
1118
1318
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1119
 
                                   type_func =
1120
 
                                   timedelta_to_milliseconds)
 
1319
                                   type_func = lambda td:
 
1320
                                       td.total_seconds() * 1000)
1121
1321
    extended_timeout = notifychangeproperty(
1122
1322
        dbus.UInt64, "ExtendedTimeout",
1123
 
        type_func = timedelta_to_milliseconds)
 
1323
        type_func = lambda td: td.total_seconds() * 1000)
1124
1324
    interval = notifychangeproperty(dbus.UInt64,
1125
1325
                                    "Interval",
1126
1326
                                    type_func =
1127
 
                                    timedelta_to_milliseconds)
 
1327
                                    lambda td: td.total_seconds()
 
1328
                                    * 1000)
1128
1329
    checker_command = notifychangeproperty(dbus.String, "Checker")
 
1330
    secret = notifychangeproperty(dbus.ByteArray, "Secret",
 
1331
                                  invalidate_only=True)
1129
1332
    
1130
1333
    del notifychangeproperty
1131
1334
    
1158
1361
                                       *args, **kwargs)
1159
1362
    
1160
1363
    def start_checker(self, *args, **kwargs):
1161
 
        old_checker = self.checker
1162
 
        if self.checker is not None:
1163
 
            old_checker_pid = self.checker.pid
1164
 
        else:
1165
 
            old_checker_pid = None
 
1364
        old_checker_pid = getattr(self.checker, "pid", None)
1166
1365
        r = Client.start_checker(self, *args, **kwargs)
1167
1366
        # Only if new checker process was started
1168
1367
        if (self.checker is not None
1176
1375
        return False
1177
1376
    
1178
1377
    def approve(self, value=True):
1179
 
        self.send_changedstate()
1180
1378
        self.approved = value
1181
 
        gobject.timeout_add(timedelta_to_milliseconds
1182
 
                            (self.approval_duration),
1183
 
                            self._reset_approved)
1184
 
    
 
1379
        gobject.timeout_add(int(self.approval_duration.total_seconds()
 
1380
                                * 1000), self._reset_approved)
 
1381
        self.send_changedstate()
1185
1382
    
1186
1383
    ## D-Bus methods, signals & properties
1187
 
    _interface = "se.recompile.Mandos.Client"
 
1384
    
 
1385
    ## Interfaces
1188
1386
    
1189
1387
    ## Signals
1190
1388
    
1201
1399
        pass
1202
1400
    
1203
1401
    # PropertyChanged - signal
 
1402
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1204
1403
    @dbus.service.signal(_interface, signature="sv")
1205
1404
    def PropertyChanged(self, property, value):
1206
1405
        "D-Bus signal"
1282
1481
                           access="readwrite")
1283
1482
    def ApprovalDelay_dbus_property(self, value=None):
1284
1483
        if value is None:       # get
1285
 
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1484
            return dbus.UInt64(self.approval_delay.total_seconds()
 
1485
                               * 1000)
1286
1486
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
1287
1487
    
1288
1488
    # ApprovalDuration - property
1290
1490
                           access="readwrite")
1291
1491
    def ApprovalDuration_dbus_property(self, value=None):
1292
1492
        if value is None:       # get
1293
 
            return dbus.UInt64(timedelta_to_milliseconds(
1294
 
                    self.approval_duration))
 
1493
            return dbus.UInt64(self.approval_duration.total_seconds()
 
1494
                               * 1000)
1295
1495
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1296
1496
    
1297
1497
    # Name - property
1310
1510
    def Host_dbus_property(self, value=None):
1311
1511
        if value is None:       # get
1312
1512
            return dbus.String(self.host)
1313
 
        self.host = unicode(value)
 
1513
        self.host = str(value)
1314
1514
    
1315
1515
    # Created - property
1316
1516
    @dbus_service_property(_interface, signature="s", access="read")
1363
1563
                           access="readwrite")
1364
1564
    def Timeout_dbus_property(self, value=None):
1365
1565
        if value is None:       # get
1366
 
            return dbus.UInt64(self.timeout_milliseconds())
 
1566
            return dbus.UInt64(self.timeout.total_seconds() * 1000)
 
1567
        old_timeout = self.timeout
1367
1568
        self.timeout = datetime.timedelta(0, 0, 0, value)
1368
 
        # Reschedule timeout
 
1569
        # Reschedule disabling
1369
1570
        if self.enabled:
1370
1571
            now = datetime.datetime.utcnow()
1371
 
            time_to_die = timedelta_to_milliseconds(
1372
 
                (self.last_checked_ok + self.timeout) - now)
1373
 
            if time_to_die <= 0:
 
1572
            self.expires += self.timeout - old_timeout
 
1573
            if self.expires <= now:
1374
1574
                # The timeout has passed
1375
1575
                self.disable()
1376
1576
            else:
1377
 
                self.expires = (now +
1378
 
                                datetime.timedelta(milliseconds =
1379
 
                                                   time_to_die))
1380
1577
                if (getattr(self, "disable_initiator_tag", None)
1381
1578
                    is None):
1382
1579
                    return
1383
1580
                gobject.source_remove(self.disable_initiator_tag)
1384
 
                self.disable_initiator_tag = (gobject.timeout_add
1385
 
                                              (time_to_die,
1386
 
                                               self.disable))
 
1581
                self.disable_initiator_tag = (
 
1582
                    gobject.timeout_add(
 
1583
                        int((self.expires - now).total_seconds()
 
1584
                            * 1000), self.disable))
1387
1585
    
1388
1586
    # ExtendedTimeout - property
1389
1587
    @dbus_service_property(_interface, signature="t",
1390
1588
                           access="readwrite")
1391
1589
    def ExtendedTimeout_dbus_property(self, value=None):
1392
1590
        if value is None:       # get
1393
 
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
1591
            return dbus.UInt64(self.extended_timeout.total_seconds()
 
1592
                               * 1000)
1394
1593
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1395
1594
    
1396
1595
    # Interval - property
1398
1597
                           access="readwrite")
1399
1598
    def Interval_dbus_property(self, value=None):
1400
1599
        if value is None:       # get
1401
 
            return dbus.UInt64(self.interval_milliseconds())
 
1600
            return dbus.UInt64(self.interval.total_seconds() * 1000)
1402
1601
        self.interval = datetime.timedelta(0, 0, 0, value)
1403
1602
        if getattr(self, "checker_initiator_tag", None) is None:
1404
1603
            return
1415
1614
    def Checker_dbus_property(self, value=None):
1416
1615
        if value is None:       # get
1417
1616
            return dbus.String(self.checker_command)
1418
 
        self.checker_command = unicode(value)
 
1617
        self.checker_command = str(value)
1419
1618
    
1420
1619
    # CheckerRunning - property
1421
1620
    @dbus_service_property(_interface, signature="b",
1437
1636
    @dbus_service_property(_interface, signature="ay",
1438
1637
                           access="write", byte_arrays=True)
1439
1638
    def Secret_dbus_property(self, value):
1440
 
        self.secret = str(value)
 
1639
        self.secret = bytes(value)
1441
1640
    
1442
1641
    del _interface
1443
1642
 
1468
1667
        self._pipe.send(('setattr', name, value))
1469
1668
 
1470
1669
 
1471
 
class ClientDBusTransitional(ClientDBus):
1472
 
    __metaclass__ = AlternateDBusNamesMetaclass
1473
 
 
1474
 
 
1475
1670
class ClientHandler(socketserver.BaseRequestHandler, object):
1476
1671
    """A class to handle client connections.
1477
1672
    
1481
1676
    def handle(self):
1482
1677
        with contextlib.closing(self.server.child_pipe) as child_pipe:
1483
1678
            logger.info("TCP connection from: %s",
1484
 
                        unicode(self.client_address))
 
1679
                        str(self.client_address))
1485
1680
            logger.debug("Pipe FD: %d",
1486
1681
                         self.server.child_pipe.fileno())
1487
1682
            
1513
1708
            logger.debug("Protocol version: %r", line)
1514
1709
            try:
1515
1710
                if int(line.strip().split()[0]) > 1:
1516
 
                    raise RuntimeError
 
1711
                    raise RuntimeError(line)
1517
1712
            except (ValueError, IndexError, RuntimeError) as error:
1518
1713
                logger.error("Unknown protocol version: %s", error)
1519
1714
                return
1568
1763
                        if self.server.use_dbus:
1569
1764
                            # Emit D-Bus signal
1570
1765
                            client.NeedApproval(
1571
 
                                client.approval_delay_milliseconds(),
1572
 
                                client.approved_by_default)
 
1766
                                client.approval_delay.total_seconds()
 
1767
                                * 1000, client.approved_by_default)
1573
1768
                    else:
1574
1769
                        logger.warning("Client %s was not approved",
1575
1770
                                       client.name)
1581
1776
                    #wait until timeout or approved
1582
1777
                    time = datetime.datetime.now()
1583
1778
                    client.changedstate.acquire()
1584
 
                    (client.changedstate.wait
1585
 
                     (float(client.timedelta_to_milliseconds(delay)
1586
 
                            / 1000)))
 
1779
                    client.changedstate.wait(delay.total_seconds())
1587
1780
                    client.changedstate.release()
1588
1781
                    time2 = datetime.datetime.now()
1589
1782
                    if (time2 - time) >= delay:
1605
1798
                    try:
1606
1799
                        sent = session.send(client.secret[sent_size:])
1607
1800
                    except gnutls.errors.GNUTLSError as error:
1608
 
                        logger.warning("gnutls send failed")
 
1801
                        logger.warning("gnutls send failed",
 
1802
                                       exc_info=error)
1609
1803
                        return
1610
1804
                    logger.debug("Sent: %d, remaining: %d",
1611
1805
                                 sent, len(client.secret)
1625
1819
                try:
1626
1820
                    session.bye()
1627
1821
                except gnutls.errors.GNUTLSError as error:
1628
 
                    logger.warning("GnuTLS bye failed")
 
1822
                    logger.warning("GnuTLS bye failed",
 
1823
                                   exc_info=error)
1629
1824
    
1630
1825
    @staticmethod
1631
1826
    def peer_certificate(session):
1703
1898
    def process_request(self, request, address):
1704
1899
        """Start a new process to process the request."""
1705
1900
        proc = multiprocessing.Process(target = self.sub_process_main,
1706
 
                                       args = (request,
1707
 
                                               address))
 
1901
                                       args = (request, address))
1708
1902
        proc.start()
1709
1903
        return proc
1710
1904
 
1725
1919
    
1726
1920
    def add_pipe(self, parent_pipe, proc):
1727
1921
        """Dummy function; override as necessary"""
1728
 
        raise NotImplementedError
 
1922
        raise NotImplementedError()
1729
1923
 
1730
1924
 
1731
1925
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1738
1932
        use_ipv6:       Boolean; to use IPv6 or not
1739
1933
    """
1740
1934
    def __init__(self, server_address, RequestHandlerClass,
1741
 
                 interface=None, use_ipv6=True):
 
1935
                 interface=None, use_ipv6=True, socketfd=None):
 
1936
        """If socketfd is set, use that file descriptor instead of
 
1937
        creating a new one with socket.socket().
 
1938
        """
1742
1939
        self.interface = interface
1743
1940
        if use_ipv6:
1744
1941
            self.address_family = socket.AF_INET6
 
1942
        if socketfd is not None:
 
1943
            # Save the file descriptor
 
1944
            self.socketfd = socketfd
 
1945
            # Save the original socket.socket() function
 
1946
            self.socket_socket = socket.socket
 
1947
            # To implement --socket, we monkey patch socket.socket.
 
1948
            # 
 
1949
            # (When socketserver.TCPServer is a new-style class, we
 
1950
            # could make self.socket into a property instead of monkey
 
1951
            # patching socket.socket.)
 
1952
            # 
 
1953
            # Create a one-time-only replacement for socket.socket()
 
1954
            @functools.wraps(socket.socket)
 
1955
            def socket_wrapper(*args, **kwargs):
 
1956
                # Restore original function so subsequent calls are
 
1957
                # not affected.
 
1958
                socket.socket = self.socket_socket
 
1959
                del self.socket_socket
 
1960
                # This time only, return a new socket object from the
 
1961
                # saved file descriptor.
 
1962
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
1963
            # Replace socket.socket() function with wrapper
 
1964
            socket.socket = socket_wrapper
 
1965
        # The socketserver.TCPServer.__init__ will call
 
1966
        # socket.socket(), which might be our replacement,
 
1967
        # socket_wrapper(), if socketfd was set.
1745
1968
        socketserver.TCPServer.__init__(self, server_address,
1746
1969
                                        RequestHandlerClass)
 
1970
    
1747
1971
    def server_bind(self):
1748
1972
        """This overrides the normal server_bind() function
1749
1973
        to bind to an interface if one was specified, and also NOT to
1757
1981
                try:
1758
1982
                    self.socket.setsockopt(socket.SOL_SOCKET,
1759
1983
                                           SO_BINDTODEVICE,
1760
 
                                           str(self.interface
1761
 
                                               + '\0'))
 
1984
                                           (self.interface + "\0")
 
1985
                                           .encode("utf-8"))
1762
1986
                except socket.error as error:
1763
 
                    if error[0] == errno.EPERM:
1764
 
                        logger.error("No permission to"
1765
 
                                     " bind to interface %s",
1766
 
                                     self.interface)
1767
 
                    elif error[0] == errno.ENOPROTOOPT:
 
1987
                    if error.errno == errno.EPERM:
 
1988
                        logger.error("No permission to bind to"
 
1989
                                     " interface %s", self.interface)
 
1990
                    elif error.errno == errno.ENOPROTOOPT:
1768
1991
                        logger.error("SO_BINDTODEVICE not available;"
1769
1992
                                     " cannot bind to interface %s",
1770
1993
                                     self.interface)
 
1994
                    elif error.errno == errno.ENODEV:
 
1995
                        logger.error("Interface %s does not exist,"
 
1996
                                     " cannot bind", self.interface)
1771
1997
                    else:
1772
1998
                        raise
1773
1999
        # Only bind(2) the socket if we really need to.
1776
2002
                if self.address_family == socket.AF_INET6:
1777
2003
                    any_address = "::" # in6addr_any
1778
2004
                else:
1779
 
                    any_address = socket.INADDR_ANY
 
2005
                    any_address = "0.0.0.0" # INADDR_ANY
1780
2006
                self.server_address = (any_address,
1781
2007
                                       self.server_address[1])
1782
2008
            elif not self.server_address[1]:
1803
2029
    """
1804
2030
    def __init__(self, server_address, RequestHandlerClass,
1805
2031
                 interface=None, use_ipv6=True, clients=None,
1806
 
                 gnutls_priority=None, use_dbus=True):
 
2032
                 gnutls_priority=None, use_dbus=True, socketfd=None):
1807
2033
        self.enabled = False
1808
2034
        self.clients = clients
1809
2035
        if self.clients is None:
1813
2039
        IPv6_TCPServer.__init__(self, server_address,
1814
2040
                                RequestHandlerClass,
1815
2041
                                interface = interface,
1816
 
                                use_ipv6 = use_ipv6)
 
2042
                                use_ipv6 = use_ipv6,
 
2043
                                socketfd = socketfd)
1817
2044
    def server_activate(self):
1818
2045
        if self.enabled:
1819
2046
            return socketserver.TCPServer.server_activate(self)
1832
2059
    
1833
2060
    def handle_ipc(self, source, condition, parent_pipe=None,
1834
2061
                   proc = None, client_object=None):
1835
 
        condition_names = {
1836
 
            gobject.IO_IN: "IN",   # There is data to read.
1837
 
            gobject.IO_OUT: "OUT", # Data can be written (without
1838
 
                                    # blocking).
1839
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1840
 
            gobject.IO_ERR: "ERR", # Error condition.
1841
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
1842
 
                                    # broken, usually for pipes and
1843
 
                                    # sockets).
1844
 
            }
1845
 
        conditions_string = ' | '.join(name
1846
 
                                       for cond, name in
1847
 
                                       condition_names.iteritems()
1848
 
                                       if cond & condition)
1849
2062
        # error, or the other end of multiprocessing.Pipe has closed
1850
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
2063
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
1851
2064
            # Wait for other process to exit
1852
2065
            proc.join()
1853
2066
            return False
1911
2124
        return True
1912
2125
 
1913
2126
 
 
2127
def rfc3339_duration_to_delta(duration):
 
2128
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2129
    
 
2130
    >>> rfc3339_duration_to_delta("P7D")
 
2131
    datetime.timedelta(7)
 
2132
    >>> rfc3339_duration_to_delta("PT60S")
 
2133
    datetime.timedelta(0, 60)
 
2134
    >>> rfc3339_duration_to_delta("PT60M")
 
2135
    datetime.timedelta(0, 3600)
 
2136
    >>> rfc3339_duration_to_delta("PT24H")
 
2137
    datetime.timedelta(1)
 
2138
    >>> rfc3339_duration_to_delta("P1W")
 
2139
    datetime.timedelta(7)
 
2140
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2141
    datetime.timedelta(0, 330)
 
2142
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2143
    datetime.timedelta(1, 200)
 
2144
    """
 
2145
    
 
2146
    # Parsing an RFC 3339 duration with regular expressions is not
 
2147
    # possible - there would have to be multiple places for the same
 
2148
    # values, like seconds.  The current code, while more esoteric, is
 
2149
    # cleaner without depending on a parsing library.  If Python had a
 
2150
    # built-in library for parsing we would use it, but we'd like to
 
2151
    # avoid excessive use of external libraries.
 
2152
    
 
2153
    # New type for defining tokens, syntax, and semantics all-in-one
 
2154
    Token = collections.namedtuple("Token",
 
2155
                                   ("regexp", # To match token; if
 
2156
                                              # "value" is not None,
 
2157
                                              # must have a "group"
 
2158
                                              # containing digits
 
2159
                                    "value",  # datetime.timedelta or
 
2160
                                              # None
 
2161
                                    "followers")) # Tokens valid after
 
2162
                                                  # this token
 
2163
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2164
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2165
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2166
    token_second = Token(re.compile(r"(\d+)S"),
 
2167
                         datetime.timedelta(seconds=1),
 
2168
                         frozenset((token_end,)))
 
2169
    token_minute = Token(re.compile(r"(\d+)M"),
 
2170
                         datetime.timedelta(minutes=1),
 
2171
                         frozenset((token_second, token_end)))
 
2172
    token_hour = Token(re.compile(r"(\d+)H"),
 
2173
                       datetime.timedelta(hours=1),
 
2174
                       frozenset((token_minute, token_end)))
 
2175
    token_time = Token(re.compile(r"T"),
 
2176
                       None,
 
2177
                       frozenset((token_hour, token_minute,
 
2178
                                  token_second)))
 
2179
    token_day = Token(re.compile(r"(\d+)D"),
 
2180
                      datetime.timedelta(days=1),
 
2181
                      frozenset((token_time, token_end)))
 
2182
    token_month = Token(re.compile(r"(\d+)M"),
 
2183
                        datetime.timedelta(weeks=4),
 
2184
                        frozenset((token_day, token_end)))
 
2185
    token_year = Token(re.compile(r"(\d+)Y"),
 
2186
                       datetime.timedelta(weeks=52),
 
2187
                       frozenset((token_month, token_end)))
 
2188
    token_week = Token(re.compile(r"(\d+)W"),
 
2189
                       datetime.timedelta(weeks=1),
 
2190
                       frozenset((token_end,)))
 
2191
    token_duration = Token(re.compile(r"P"), None,
 
2192
                           frozenset((token_year, token_month,
 
2193
                                      token_day, token_time,
 
2194
                                      token_week)))
 
2195
    # Define starting values
 
2196
    value = datetime.timedelta() # Value so far
 
2197
    found_token = None
 
2198
    followers = frozenset((token_duration,)) # Following valid tokens
 
2199
    s = duration                # String left to parse
 
2200
    # Loop until end token is found
 
2201
    while found_token is not token_end:
 
2202
        # Search for any currently valid tokens
 
2203
        for token in followers:
 
2204
            match = token.regexp.match(s)
 
2205
            if match is not None:
 
2206
                # Token found
 
2207
                if token.value is not None:
 
2208
                    # Value found, parse digits
 
2209
                    factor = int(match.group(1), 10)
 
2210
                    # Add to value so far
 
2211
                    value += factor * token.value
 
2212
                # Strip token from string
 
2213
                s = token.regexp.sub("", s, 1)
 
2214
                # Go to found token
 
2215
                found_token = token
 
2216
                # Set valid next tokens
 
2217
                followers = found_token.followers
 
2218
                break
 
2219
        else:
 
2220
            # No currently valid tokens were found
 
2221
            raise ValueError("Invalid RFC 3339 duration")
 
2222
    # End token found
 
2223
    return value
 
2224
 
 
2225
 
1914
2226
def string_to_delta(interval):
1915
2227
    """Parse a string and return a datetime.timedelta
1916
2228
    
1927
2239
    >>> string_to_delta('5m 30s')
1928
2240
    datetime.timedelta(0, 330)
1929
2241
    """
 
2242
    
 
2243
    try:
 
2244
        return rfc3339_duration_to_delta(interval)
 
2245
    except ValueError:
 
2246
        pass
 
2247
    
1930
2248
    timevalue = datetime.timedelta(0)
1931
2249
    for s in interval.split():
1932
2250
        try:
1933
 
            suffix = unicode(s[-1])
 
2251
            suffix = s[-1]
1934
2252
            value = int(s[:-1])
1935
2253
            if suffix == "d":
1936
2254
                delta = datetime.timedelta(value)
1943
2261
            elif suffix == "w":
1944
2262
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1945
2263
            else:
1946
 
                raise ValueError("Unknown suffix %r" % suffix)
1947
 
        except (ValueError, IndexError) as e:
 
2264
                raise ValueError("Unknown suffix {!r}"
 
2265
                                 .format(suffix))
 
2266
        except IndexError as e:
1948
2267
            raise ValueError(*(e.args))
1949
2268
        timevalue += delta
1950
2269
    return timevalue
1963
2282
        sys.exit()
1964
2283
    if not noclose:
1965
2284
        # Close all standard open file descriptors
1966
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2285
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1967
2286
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1968
 
            raise OSError(errno.ENODEV,
1969
 
                          "%s not a character device"
1970
 
                          % os.path.devnull)
 
2287
            raise OSError(errno.ENODEV, "{} not a character device"
 
2288
                          .format(os.devnull))
1971
2289
        os.dup2(null, sys.stdin.fileno())
1972
2290
        os.dup2(null, sys.stdout.fileno())
1973
2291
        os.dup2(null, sys.stderr.fileno())
1982
2300
    
1983
2301
    parser = argparse.ArgumentParser()
1984
2302
    parser.add_argument("-v", "--version", action="version",
1985
 
                        version = "%%(prog)s %s" % version,
 
2303
                        version = "%(prog)s {}".format(version),
1986
2304
                        help="show version number and exit")
1987
2305
    parser.add_argument("-i", "--interface", metavar="IF",
1988
2306
                        help="Bind to interface IF")
1994
2312
                        help="Run self-test")
1995
2313
    parser.add_argument("--debug", action="store_true",
1996
2314
                        help="Debug mode; run in foreground and log"
1997
 
                        " to terminal")
 
2315
                        " to terminal", default=None)
1998
2316
    parser.add_argument("--debuglevel", metavar="LEVEL",
1999
2317
                        help="Debug level for stdout output")
2000
2318
    parser.add_argument("--priority", help="GnuTLS"
2007
2325
                        " files")
2008
2326
    parser.add_argument("--no-dbus", action="store_false",
2009
2327
                        dest="use_dbus", help="Do not provide D-Bus"
2010
 
                        " system bus interface")
 
2328
                        " system bus interface", default=None)
2011
2329
    parser.add_argument("--no-ipv6", action="store_false",
2012
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2330
                        dest="use_ipv6", help="Do not use IPv6",
 
2331
                        default=None)
2013
2332
    parser.add_argument("--no-restore", action="store_false",
2014
2333
                        dest="restore", help="Do not restore stored"
2015
 
                        " state")
 
2334
                        " state", default=None)
 
2335
    parser.add_argument("--socket", type=int,
 
2336
                        help="Specify a file descriptor to a network"
 
2337
                        " socket to use instead of creating one")
2016
2338
    parser.add_argument("--statedir", metavar="DIR",
2017
2339
                        help="Directory to save/restore state in")
 
2340
    parser.add_argument("--foreground", action="store_true",
 
2341
                        help="Run in foreground", default=None)
 
2342
    parser.add_argument("--no-zeroconf", action="store_false",
 
2343
                        dest="zeroconf", help="Do not use Zeroconf",
 
2344
                        default=None)
2018
2345
    
2019
2346
    options = parser.parse_args()
2020
2347
    
2021
2348
    if options.check:
2022
2349
        import doctest
2023
 
        doctest.testmod()
2024
 
        sys.exit()
 
2350
        fail_count, test_count = doctest.testmod()
 
2351
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2025
2352
    
2026
2353
    # Default values for config file for server-global settings
2027
2354
    server_defaults = { "interface": "",
2029
2356
                        "port": "",
2030
2357
                        "debug": "False",
2031
2358
                        "priority":
2032
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2359
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
2360
                        ":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2033
2361
                        "servicename": "Mandos",
2034
2362
                        "use_dbus": "True",
2035
2363
                        "use_ipv6": "True",
2036
2364
                        "debuglevel": "",
2037
2365
                        "restore": "True",
2038
 
                        "statedir": "/var/lib/mandos"
 
2366
                        "socket": "",
 
2367
                        "statedir": "/var/lib/mandos",
 
2368
                        "foreground": "False",
 
2369
                        "zeroconf": "True",
2039
2370
                        }
2040
2371
    
2041
2372
    # Parse config file for server-global settings
2046
2377
    # Convert the SafeConfigParser object to a dict
2047
2378
    server_settings = server_config.defaults()
2048
2379
    # Use the appropriate methods on the non-string config options
2049
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2380
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2050
2381
        server_settings[option] = server_config.getboolean("DEFAULT",
2051
2382
                                                           option)
2052
2383
    if server_settings["port"]:
2053
2384
        server_settings["port"] = server_config.getint("DEFAULT",
2054
2385
                                                       "port")
 
2386
    if server_settings["socket"]:
 
2387
        server_settings["socket"] = server_config.getint("DEFAULT",
 
2388
                                                         "socket")
 
2389
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
2390
        # over with an opened os.devnull.  But we don't want this to
 
2391
        # happen with a supplied network socket.
 
2392
        if 0 <= server_settings["socket"] <= 2:
 
2393
            server_settings["socket"] = os.dup(server_settings
 
2394
                                               ["socket"])
2055
2395
    del server_config
2056
2396
    
2057
2397
    # Override the settings from the config file with command line
2059
2399
    for option in ("interface", "address", "port", "debug",
2060
2400
                   "priority", "servicename", "configdir",
2061
2401
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2062
 
                   "statedir"):
 
2402
                   "statedir", "socket", "foreground", "zeroconf"):
2063
2403
        value = getattr(options, option)
2064
2404
        if value is not None:
2065
2405
            server_settings[option] = value
2066
2406
    del options
2067
2407
    # Force all strings to be unicode
2068
2408
    for option in server_settings.keys():
2069
 
        if type(server_settings[option]) is str:
2070
 
            server_settings[option] = unicode(server_settings[option])
 
2409
        if isinstance(server_settings[option], bytes):
 
2410
            server_settings[option] = (server_settings[option]
 
2411
                                       .decode("utf-8"))
 
2412
    # Force all boolean options to be boolean
 
2413
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2414
                   "foreground", "zeroconf"):
 
2415
        server_settings[option] = bool(server_settings[option])
 
2416
    # Debug implies foreground
 
2417
    if server_settings["debug"]:
 
2418
        server_settings["foreground"] = True
2071
2419
    # Now we have our good server settings in "server_settings"
2072
2420
    
2073
2421
    ##################################################################
2074
2422
    
 
2423
    if (not server_settings["zeroconf"] and
 
2424
        not (server_settings["port"]
 
2425
             or server_settings["socket"] != "")):
 
2426
            parser.error("Needs port or socket to work without"
 
2427
                         " Zeroconf")
 
2428
    
2075
2429
    # For convenience
2076
2430
    debug = server_settings["debug"]
2077
2431
    debuglevel = server_settings["debuglevel"]
2079
2433
    use_ipv6 = server_settings["use_ipv6"]
2080
2434
    stored_state_path = os.path.join(server_settings["statedir"],
2081
2435
                                     stored_state_file)
 
2436
    foreground = server_settings["foreground"]
 
2437
    zeroconf = server_settings["zeroconf"]
2082
2438
    
2083
2439
    if debug:
2084
2440
        initlogger(debug, logging.DEBUG)
2091
2447
    
2092
2448
    if server_settings["servicename"] != "Mandos":
2093
2449
        syslogger.setFormatter(logging.Formatter
2094
 
                               ('Mandos (%s) [%%(process)d]:'
2095
 
                                ' %%(levelname)s: %%(message)s'
2096
 
                                % server_settings["servicename"]))
 
2450
                               ('Mandos ({}) [%(process)d]:'
 
2451
                                ' %(levelname)s: %(message)s'
 
2452
                                .format(server_settings
 
2453
                                        ["servicename"])))
2097
2454
    
2098
2455
    # Parse config file with clients
2099
2456
    client_config = configparser.SafeConfigParser(Client
2104
2461
    global mandos_dbus_service
2105
2462
    mandos_dbus_service = None
2106
2463
    
 
2464
    socketfd = None
 
2465
    if server_settings["socket"] != "":
 
2466
        socketfd = server_settings["socket"]
2107
2467
    tcp_server = MandosServer((server_settings["address"],
2108
2468
                               server_settings["port"]),
2109
2469
                              ClientHandler,
2112
2472
                              use_ipv6=use_ipv6,
2113
2473
                              gnutls_priority=
2114
2474
                              server_settings["priority"],
2115
 
                              use_dbus=use_dbus)
2116
 
    if not debug:
2117
 
        pidfilename = "/var/run/mandos.pid"
 
2475
                              use_dbus=use_dbus,
 
2476
                              socketfd=socketfd)
 
2477
    if not foreground:
 
2478
        pidfilename = "/run/mandos.pid"
 
2479
        if not os.path.isdir("/run/."):
 
2480
            pidfilename = "/var/run/mandos.pid"
 
2481
        pidfile = None
2118
2482
        try:
2119
2483
            pidfile = open(pidfilename, "w")
2120
 
        except IOError:
2121
 
            logger.error("Could not open file %r", pidfilename)
 
2484
        except IOError as e:
 
2485
            logger.error("Could not open file %r", pidfilename,
 
2486
                         exc_info=e)
2122
2487
    
2123
 
    try:
2124
 
        uid = pwd.getpwnam("_mandos").pw_uid
2125
 
        gid = pwd.getpwnam("_mandos").pw_gid
2126
 
    except KeyError:
 
2488
    for name in ("_mandos", "mandos", "nobody"):
2127
2489
        try:
2128
 
            uid = pwd.getpwnam("mandos").pw_uid
2129
 
            gid = pwd.getpwnam("mandos").pw_gid
 
2490
            uid = pwd.getpwnam(name).pw_uid
 
2491
            gid = pwd.getpwnam(name).pw_gid
 
2492
            break
2130
2493
        except KeyError:
2131
 
            try:
2132
 
                uid = pwd.getpwnam("nobody").pw_uid
2133
 
                gid = pwd.getpwnam("nobody").pw_gid
2134
 
            except KeyError:
2135
 
                uid = 65534
2136
 
                gid = 65534
 
2494
            continue
 
2495
    else:
 
2496
        uid = 65534
 
2497
        gid = 65534
2137
2498
    try:
2138
2499
        os.setgid(gid)
2139
2500
        os.setuid(uid)
2140
2501
    except OSError as error:
2141
 
        if error[0] != errno.EPERM:
2142
 
            raise error
 
2502
        if error.errno != errno.EPERM:
 
2503
            raise
2143
2504
    
2144
2505
    if debug:
2145
2506
        # Enable all possible GnuTLS debugging
2156
2517
         .gnutls_global_set_log_function(debug_gnutls))
2157
2518
        
2158
2519
        # Redirect stdin so all checkers get /dev/null
2159
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2520
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2160
2521
        os.dup2(null, sys.stdin.fileno())
2161
2522
        if null > 2:
2162
2523
            os.close(null)
2163
2524
    
2164
2525
    # Need to fork before connecting to D-Bus
2165
 
    if not debug:
 
2526
    if not foreground:
2166
2527
        # Close all input and output, do double fork, etc.
2167
2528
        daemon()
2168
2529
    
 
2530
    # multiprocessing will use threads, so before we use gobject we
 
2531
    # need to inform gobject that threads will be used.
2169
2532
    gobject.threads_init()
2170
2533
    
2171
2534
    global main_loop
2172
2535
    # From the Avahi example code
2173
 
    DBusGMainLoop(set_as_default=True )
 
2536
    DBusGMainLoop(set_as_default=True)
2174
2537
    main_loop = gobject.MainLoop()
2175
2538
    bus = dbus.SystemBus()
2176
2539
    # End of Avahi example code
2182
2545
                            ("se.bsnet.fukt.Mandos", bus,
2183
2546
                             do_not_queue=True))
2184
2547
        except dbus.exceptions.NameExistsException as e:
2185
 
            logger.error(unicode(e) + ", disabling D-Bus")
 
2548
            logger.error("Disabling D-Bus:", exc_info=e)
2186
2549
            use_dbus = False
2187
2550
            server_settings["use_dbus"] = False
2188
2551
            tcp_server.use_dbus = False
2189
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2190
 
    service = AvahiServiceToSyslog(name =
2191
 
                                   server_settings["servicename"],
2192
 
                                   servicetype = "_mandos._tcp",
2193
 
                                   protocol = protocol, bus = bus)
2194
 
    if server_settings["interface"]:
2195
 
        service.interface = (if_nametoindex
2196
 
                             (str(server_settings["interface"])))
 
2552
    if zeroconf:
 
2553
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
2554
        service = AvahiServiceToSyslog(name =
 
2555
                                       server_settings["servicename"],
 
2556
                                       servicetype = "_mandos._tcp",
 
2557
                                       protocol = protocol, bus = bus)
 
2558
        if server_settings["interface"]:
 
2559
            service.interface = (if_nametoindex
 
2560
                                 (server_settings["interface"]
 
2561
                                  .encode("utf-8")))
2197
2562
    
2198
2563
    global multiprocessing_manager
2199
2564
    multiprocessing_manager = multiprocessing.Manager()
2200
2565
    
2201
2566
    client_class = Client
2202
2567
    if use_dbus:
2203
 
        client_class = functools.partial(ClientDBusTransitional,
2204
 
                                         bus = bus)
 
2568
        client_class = functools.partial(ClientDBus, bus = bus)
2205
2569
    
2206
2570
    client_settings = Client.config_parser(client_config)
2207
2571
    old_client_settings = {}
2208
2572
    clients_data = {}
2209
2573
    
 
2574
    # This is used to redirect stdout and stderr for checker processes
 
2575
    global wnull
 
2576
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2577
    # Only used if server is running in foreground but not in debug
 
2578
    # mode
 
2579
    if debug or not foreground:
 
2580
        wnull.close()
 
2581
    
2210
2582
    # Get client data and settings from last running state.
2211
2583
    if server_settings["restore"]:
2212
2584
        try:
2215
2587
                                                     (stored_state))
2216
2588
            os.remove(stored_state_path)
2217
2589
        except IOError as e:
2218
 
            logger.warning("Could not load persistent state: {0}"
2219
 
                           .format(e))
2220
 
            if e.errno != errno.ENOENT:
 
2590
            if e.errno == errno.ENOENT:
 
2591
                logger.warning("Could not load persistent state: {}"
 
2592
                                .format(os.strerror(e.errno)))
 
2593
            else:
 
2594
                logger.critical("Could not load persistent state:",
 
2595
                                exc_info=e)
2221
2596
                raise
2222
2597
        except EOFError as e:
2223
2598
            logger.warning("Could not load persistent state: "
2224
 
                           "EOFError: {0}".format(e))
 
2599
                           "EOFError:", exc_info=e)
2225
2600
    
2226
2601
    with PGPEngine() as pgp:
2227
 
        for client_name, client in clients_data.iteritems():
 
2602
        for client_name, client in clients_data.items():
 
2603
            # Skip removed clients
 
2604
            if client_name not in client_settings:
 
2605
                continue
 
2606
            
2228
2607
            # Decide which value to use after restoring saved state.
2229
2608
            # We have three different values: Old config file,
2230
2609
            # new config file, and saved state.
2251
2630
                if datetime.datetime.utcnow() >= client["expires"]:
2252
2631
                    if not client["last_checked_ok"]:
2253
2632
                        logger.warning(
2254
 
                            "disabling client {0} - Client never "
 
2633
                            "disabling client {} - Client never "
2255
2634
                            "performed a successful checker"
2256
2635
                            .format(client_name))
2257
2636
                        client["enabled"] = False
2258
2637
                    elif client["last_checker_status"] != 0:
2259
2638
                        logger.warning(
2260
 
                            "disabling client {0} - Client "
2261
 
                            "last checker failed with error code {1}"
 
2639
                            "disabling client {} - Client last"
 
2640
                            " checker failed with error code {}"
2262
2641
                            .format(client_name,
2263
2642
                                    client["last_checker_status"]))
2264
2643
                        client["enabled"] = False
2267
2646
                                             .utcnow()
2268
2647
                                             + client["timeout"])
2269
2648
                        logger.debug("Last checker succeeded,"
2270
 
                                     " keeping {0} enabled"
 
2649
                                     " keeping {} enabled"
2271
2650
                                     .format(client_name))
2272
2651
            try:
2273
2652
                client["secret"] = (
2276
2655
                                ["secret"]))
2277
2656
            except PGPError:
2278
2657
                # If decryption fails, we use secret from new settings
2279
 
                logger.debug("Failed to decrypt {0} old secret"
 
2658
                logger.debug("Failed to decrypt {} old secret"
2280
2659
                             .format(client_name))
2281
2660
                client["secret"] = (
2282
2661
                    client_settings[client_name]["secret"])
2283
 
 
2284
2662
    
2285
2663
    # Add/remove clients based on new changes made to config
2286
2664
    for client_name in (set(old_client_settings)
2289
2667
    for client_name in (set(client_settings)
2290
2668
                        - set(old_client_settings)):
2291
2669
        clients_data[client_name] = client_settings[client_name]
2292
 
 
 
2670
    
2293
2671
    # Create all client objects
2294
 
    for client_name, client in clients_data.iteritems():
 
2672
    for client_name, client in clients_data.items():
2295
2673
        tcp_server.clients[client_name] = client_class(
2296
 
            name = client_name, settings = client)
 
2674
            name = client_name, settings = client,
 
2675
            server_settings = server_settings)
2297
2676
    
2298
2677
    if not tcp_server.clients:
2299
2678
        logger.warning("No clients defined")
2300
 
        
2301
 
    if not debug:
2302
 
        try:
2303
 
            with pidfile:
2304
 
                pid = os.getpid()
2305
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2306
 
            del pidfile
2307
 
        except IOError:
2308
 
            logger.error("Could not write to file %r with PID %d",
2309
 
                         pidfilename, pid)
2310
 
        except NameError:
2311
 
            # "pidfile" was never created
2312
 
            pass
 
2679
    
 
2680
    if not foreground:
 
2681
        if pidfile is not None:
 
2682
            try:
 
2683
                with pidfile:
 
2684
                    pid = os.getpid()
 
2685
                    pidfile.write("{}\n".format(pid).encode("utf-8"))
 
2686
            except IOError:
 
2687
                logger.error("Could not write to file %r with PID %d",
 
2688
                             pidfilename, pid)
 
2689
        del pidfile
2313
2690
        del pidfilename
2314
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2315
2691
    
2316
2692
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2317
2693
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2318
2694
    
2319
2695
    if use_dbus:
2320
 
        class MandosDBusService(dbus.service.Object):
 
2696
        @alternate_dbus_interfaces({"se.recompile.Mandos":
 
2697
                                        "se.bsnet.fukt.Mandos"})
 
2698
        class MandosDBusService(DBusObjectWithProperties):
2321
2699
            """A D-Bus proxy object"""
2322
2700
            def __init__(self):
2323
2701
                dbus.service.Object.__init__(self, bus, "/")
2324
2702
            _interface = "se.recompile.Mandos"
2325
2703
            
 
2704
            @dbus_interface_annotations(_interface)
 
2705
            def _foo(self):
 
2706
                return { "org.freedesktop.DBus.Property"
 
2707
                         ".EmitsChangedSignal":
 
2708
                             "false"}
 
2709
            
2326
2710
            @dbus.service.signal(_interface, signature="o")
2327
2711
            def ClientAdded(self, objpath):
2328
2712
                "D-Bus signal"
2350
2734
            def GetAllClientsWithProperties(self):
2351
2735
                "D-Bus method"
2352
2736
                return dbus.Dictionary(
2353
 
                    ((c.dbus_object_path, c.GetAll(""))
2354
 
                     for c in tcp_server.clients.itervalues()),
 
2737
                    { c.dbus_object_path: c.GetAll("")
 
2738
                      for c in tcp_server.clients.itervalues() },
2355
2739
                    signature="oa{sv}")
2356
2740
            
2357
2741
            @dbus.service.method(_interface, in_signature="o")
2370
2754
            
2371
2755
            del _interface
2372
2756
        
2373
 
        class MandosDBusServiceTransitional(MandosDBusService):
2374
 
            __metaclass__ = AlternateDBusNamesMetaclass
2375
 
        mandos_dbus_service = MandosDBusServiceTransitional()
 
2757
        mandos_dbus_service = MandosDBusService()
2376
2758
    
2377
2759
    def cleanup():
2378
2760
        "Cleanup function; run on exit"
2379
 
        service.cleanup()
 
2761
        if zeroconf:
 
2762
            service.cleanup()
2380
2763
        
2381
2764
        multiprocessing.active_children()
 
2765
        wnull.close()
2382
2766
        if not (tcp_server.clients or client_settings):
2383
2767
            return
2384
2768
        
2395
2779
                
2396
2780
                # A list of attributes that can not be pickled
2397
2781
                # + secret.
2398
 
                exclude = set(("bus", "changedstate", "secret",
2399
 
                               "checker"))
 
2782
                exclude = { "bus", "changedstate", "secret",
 
2783
                            "checker", "server_settings" }
2400
2784
                for name, typ in (inspect.getmembers
2401
2785
                                  (dbus.service.Object)):
2402
2786
                    exclude.add(name)
2411
2795
                del client_settings[client.name]["secret"]
2412
2796
        
2413
2797
        try:
2414
 
            tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2415
 
                                                prefix="clients-",
2416
 
                                                dir=os.path.dirname
2417
 
                                                (stored_state_path))
2418
 
            with os.fdopen(tempfd, "wb") as stored_state:
 
2798
            with (tempfile.NamedTemporaryFile
 
2799
                  (mode='wb', suffix=".pickle", prefix='clients-',
 
2800
                   dir=os.path.dirname(stored_state_path),
 
2801
                   delete=False)) as stored_state:
2419
2802
                pickle.dump((clients, client_settings), stored_state)
 
2803
                tempname=stored_state.name
2420
2804
            os.rename(tempname, stored_state_path)
2421
2805
        except (IOError, OSError) as e:
2422
 
            logger.warning("Could not save persistent state: {0}"
2423
 
                           .format(e))
2424
2806
            if not debug:
2425
2807
                try:
2426
2808
                    os.remove(tempname)
2427
2809
                except NameError:
2428
2810
                    pass
2429
 
            if e.errno not in set((errno.ENOENT, errno.EACCES,
2430
 
                                   errno.EEXIST)):
2431
 
                raise e
 
2811
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
 
2812
                logger.warning("Could not save persistent state: {}"
 
2813
                               .format(os.strerror(e.errno)))
 
2814
            else:
 
2815
                logger.warning("Could not save persistent state:",
 
2816
                               exc_info=e)
 
2817
                raise
2432
2818
        
2433
2819
        # Delete all clients, and settings from config
2434
2820
        while tcp_server.clients:
2458
2844
    tcp_server.server_activate()
2459
2845
    
2460
2846
    # Find out what port we got
2461
 
    service.port = tcp_server.socket.getsockname()[1]
 
2847
    if zeroconf:
 
2848
        service.port = tcp_server.socket.getsockname()[1]
2462
2849
    if use_ipv6:
2463
2850
        logger.info("Now listening on address %r, port %d,"
2464
 
                    " flowinfo %d, scope_id %d"
2465
 
                    % tcp_server.socket.getsockname())
 
2851
                    " flowinfo %d, scope_id %d",
 
2852
                    *tcp_server.socket.getsockname())
2466
2853
    else:                       # IPv4
2467
 
        logger.info("Now listening on address %r, port %d"
2468
 
                    % tcp_server.socket.getsockname())
 
2854
        logger.info("Now listening on address %r, port %d",
 
2855
                    *tcp_server.socket.getsockname())
2469
2856
    
2470
2857
    #service.interface = tcp_server.socket.getsockname()[3]
2471
2858
    
2472
2859
    try:
2473
 
        # From the Avahi example code
2474
 
        try:
2475
 
            service.activate()
2476
 
        except dbus.exceptions.DBusException as error:
2477
 
            logger.critical("DBusException: %s", error)
2478
 
            cleanup()
2479
 
            sys.exit(1)
2480
 
        # End of Avahi example code
 
2860
        if zeroconf:
 
2861
            # From the Avahi example code
 
2862
            try:
 
2863
                service.activate()
 
2864
            except dbus.exceptions.DBusException as error:
 
2865
                logger.critical("D-Bus Exception", exc_info=error)
 
2866
                cleanup()
 
2867
                sys.exit(1)
 
2868
            # End of Avahi example code
2481
2869
        
2482
2870
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2483
2871
                             lambda *args, **kwargs:
2487
2875
        logger.debug("Starting main loop")
2488
2876
        main_loop.run()
2489
2877
    except AvahiError as error:
2490
 
        logger.critical("AvahiError: %s", error)
 
2878
        logger.critical("Avahi Error", exc_info=error)
2491
2879
        cleanup()
2492
2880
        sys.exit(1)
2493
2881
    except KeyboardInterrupt: