/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: 2014-07-14 21:41:08 UTC
  • Revision ID: teddy@recompile.se-20140714214108-awg7u6gaiy7d40dz
mandos-monitor: New "verbose" mode to see less important log messages.

* mandos-monitor (MandosClientWidget.__init__): Log client creation.
  (MandosClientWidget.checker_completed): Log a successful checker.
  (MandosClientWidget.checker_started): Log starting of a checker.
  (UserInterface.__init__): New optional "log_level" argument.
  (UserInterface.log_message, UserInterface.log_message_raw): Take
                                                              optional
                                                              "level"
                                                              arg.
  (UserInterface.toggle_log_display): Log visibility change.
  (UserInterface.change_log_display): Log wrap mode change.
  (UserInterface.process_input): Show new "v" key in help message and
                                 process "v" key if pressed.
* mandos-monitor.xml (KEYS): Document new "v" key.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
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
68
68
import binascii
69
69
import tempfile
70
70
import itertools
 
71
import collections
71
72
 
72
73
import dbus
73
74
import dbus.service
78
79
import ctypes.util
79
80
import xml.dom.minidom
80
81
import inspect
81
 
import GnuPGInterface
82
82
 
83
83
try:
84
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
88
    except ImportError:
89
89
        SO_BINDTODEVICE = None
90
90
 
91
 
version = "1.5.3"
 
91
version = "1.6.6"
92
92
stored_state_file = "clients.pickle"
93
93
 
94
94
logger = logging.getLogger()
95
 
syslogger = (logging.handlers.SysLogHandler
96
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
97
 
              address = str("/dev/log")))
 
95
syslogger = None
98
96
 
99
97
try:
100
98
    if_nametoindex = (ctypes.cdll.LoadLibrary
116
114
def initlogger(debug, level=logging.WARNING):
117
115
    """init logger and add loglevel"""
118
116
    
 
117
    global syslogger
 
118
    syslogger = (logging.handlers.SysLogHandler
 
119
                 (facility =
 
120
                  logging.handlers.SysLogHandler.LOG_DAEMON,
 
121
                  address = str("/dev/log")))
119
122
    syslogger.setFormatter(logging.Formatter
120
123
                           ('Mandos [%(process)d]: %(levelname)s:'
121
124
                            ' %(message)s'))
139
142
class PGPEngine(object):
140
143
    """A simple class for OpenPGP symmetric encryption & decryption"""
141
144
    def __init__(self):
142
 
        self.gnupg = GnuPGInterface.GnuPG()
143
145
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
144
 
        self.gnupg = GnuPGInterface.GnuPG()
145
 
        self.gnupg.options.meta_interactive = False
146
 
        self.gnupg.options.homedir = self.tempdir
147
 
        self.gnupg.options.extra_args.extend(['--force-mdc',
148
 
                                              '--quiet',
149
 
                                              '--no-use-agent'])
 
146
        self.gnupgargs = ['--batch',
 
147
                          '--home', self.tempdir,
 
148
                          '--force-mdc',
 
149
                          '--quiet',
 
150
                          '--no-use-agent']
150
151
    
151
152
    def __enter__(self):
152
153
        return self
153
154
    
154
 
    def __exit__ (self, exc_type, exc_value, traceback):
 
155
    def __exit__(self, exc_type, exc_value, traceback):
155
156
        self._cleanup()
156
157
        return False
157
158
    
174
175
    def password_encode(self, password):
175
176
        # Passphrase can not be empty and can not contain newlines or
176
177
        # NUL bytes.  So we prefix it and hex encode it.
177
 
        return b"mandos" + binascii.hexlify(password)
 
178
        encoded = b"mandos" + binascii.hexlify(password)
 
179
        if len(encoded) > 2048:
 
180
            # GnuPG can't handle long passwords, so encode differently
 
181
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
182
                       .replace(b"\n", b"\\n")
 
183
                       .replace(b"\0", b"\\x00"))
 
184
        return encoded
178
185
    
179
186
    def encrypt(self, data, password):
180
 
        self.gnupg.passphrase = self.password_encode(password)
181
 
        with open(os.devnull, "w") as devnull:
182
 
            try:
183
 
                proc = self.gnupg.run(['--symmetric'],
184
 
                                      create_fhs=['stdin', 'stdout'],
185
 
                                      attach_fhs={'stderr': devnull})
186
 
                with contextlib.closing(proc.handles['stdin']) as f:
187
 
                    f.write(data)
188
 
                with contextlib.closing(proc.handles['stdout']) as f:
189
 
                    ciphertext = f.read()
190
 
                proc.wait()
191
 
            except IOError as e:
192
 
                raise PGPError(e)
193
 
        self.gnupg.passphrase = None
 
187
        passphrase = self.password_encode(password)
 
188
        with tempfile.NamedTemporaryFile(dir=self.tempdir
 
189
                                         ) as passfile:
 
190
            passfile.write(passphrase)
 
191
            passfile.flush()
 
192
            proc = subprocess.Popen(['gpg', '--symmetric',
 
193
                                     '--passphrase-file',
 
194
                                     passfile.name]
 
195
                                    + self.gnupgargs,
 
196
                                    stdin = subprocess.PIPE,
 
197
                                    stdout = subprocess.PIPE,
 
198
                                    stderr = subprocess.PIPE)
 
199
            ciphertext, err = proc.communicate(input = data)
 
200
        if proc.returncode != 0:
 
201
            raise PGPError(err)
194
202
        return ciphertext
195
203
    
196
204
    def decrypt(self, data, password):
197
 
        self.gnupg.passphrase = self.password_encode(password)
198
 
        with open(os.devnull, "w") as devnull:
199
 
            try:
200
 
                proc = self.gnupg.run(['--decrypt'],
201
 
                                      create_fhs=['stdin', 'stdout'],
202
 
                                      attach_fhs={'stderr': devnull})
203
 
                with contextlib.closing(proc.handles['stdin']) as f:
204
 
                    f.write(data)
205
 
                with contextlib.closing(proc.handles['stdout']) as f:
206
 
                    decrypted_plaintext = f.read()
207
 
                proc.wait()
208
 
            except IOError as e:
209
 
                raise PGPError(e)
210
 
        self.gnupg.passphrase = None
 
205
        passphrase = self.password_encode(password)
 
206
        with tempfile.NamedTemporaryFile(dir = self.tempdir
 
207
                                         ) as passfile:
 
208
            passfile.write(passphrase)
 
209
            passfile.flush()
 
210
            proc = subprocess.Popen(['gpg', '--decrypt',
 
211
                                     '--passphrase-file',
 
212
                                     passfile.name]
 
213
                                    + self.gnupgargs,
 
214
                                    stdin = subprocess.PIPE,
 
215
                                    stdout = subprocess.PIPE,
 
216
                                    stderr = subprocess.PIPE)
 
217
            decrypted_plaintext, err = proc.communicate(input
 
218
                                                        = data)
 
219
        if proc.returncode != 0:
 
220
            raise PGPError(err)
211
221
        return decrypted_plaintext
212
222
 
213
223
 
233
243
               Used to optionally bind to the specified interface.
234
244
    name: string; Example: 'Mandos'
235
245
    type: string; Example: '_mandos._tcp'.
236
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
246
     See <https://www.iana.org/assignments/service-names-port-numbers>
237
247
    port: integer; what port to announce
238
248
    TXT: list of strings; TXT record for the service
239
249
    domain: string; Domain to publish on, default to .local if empty.
379
389
                                 self.server_state_changed)
380
390
        self.server_state_changed(self.server.GetState())
381
391
 
 
392
 
382
393
class AvahiServiceToSyslog(AvahiService):
383
394
    def rename(self):
384
395
        """Add the new name to the syslog messages"""
389
400
                                .format(self.name)))
390
401
        return ret
391
402
 
 
403
 
392
404
def timedelta_to_milliseconds(td):
393
405
    "Convert a datetime.timedelta() to milliseconds"
394
406
    return ((td.days * 24 * 60 * 60 * 1000)
395
407
            + (td.seconds * 1000)
396
408
            + (td.microseconds // 1000))
397
409
 
 
410
 
398
411
class Client(object):
399
412
    """A representation of a client host served by this server.
400
413
    
436
449
    runtime_expansions: Allowed attributes for runtime expansion.
437
450
    expires:    datetime.datetime(); time (UTC) when a client will be
438
451
                disabled, or None
 
452
    server_settings: The server_settings dict from main()
439
453
    """
440
454
    
441
455
    runtime_expansions = ("approval_delay", "approval_duration",
442
 
                          "created", "enabled", "fingerprint",
443
 
                          "host", "interval", "last_checked_ok",
 
456
                          "created", "enabled", "expires",
 
457
                          "fingerprint", "host", "interval",
 
458
                          "last_approval_request", "last_checked_ok",
444
459
                          "last_enabled", "name", "timeout")
445
 
    client_defaults = { "timeout": "5m",
446
 
                        "extended_timeout": "15m",
447
 
                        "interval": "2m",
 
460
    client_defaults = { "timeout": "PT5M",
 
461
                        "extended_timeout": "PT15M",
 
462
                        "interval": "PT2M",
448
463
                        "checker": "fping -q -- %%(host)s",
449
464
                        "host": "",
450
 
                        "approval_delay": "0s",
451
 
                        "approval_duration": "1s",
 
465
                        "approval_delay": "PT0S",
 
466
                        "approval_duration": "PT1S",
452
467
                        "approved_by_default": "True",
453
468
                        "enabled": "True",
454
469
                        }
515
530
        
516
531
        return settings
517
532
    
518
 
    def __init__(self, settings, name = None):
 
533
    def __init__(self, settings, name = None, server_settings=None):
519
534
        self.name = name
 
535
        if server_settings is None:
 
536
            server_settings = {}
 
537
        self.server_settings = server_settings
520
538
        # adding all client settings
521
539
        for setting, value in settings.iteritems():
522
540
            setattr(self, setting, value)
572
590
        if getattr(self, "enabled", False):
573
591
            # Already enabled
574
592
            return
575
 
        self.send_changedstate()
576
593
        self.expires = datetime.datetime.utcnow() + self.timeout
577
594
        self.enabled = True
578
595
        self.last_enabled = datetime.datetime.utcnow()
579
596
        self.init_checker()
 
597
        self.send_changedstate()
580
598
    
581
599
    def disable(self, quiet=True):
582
600
        """Disable this client."""
583
601
        if not getattr(self, "enabled", False):
584
602
            return False
585
603
        if not quiet:
586
 
            self.send_changedstate()
587
 
        if not quiet:
588
604
            logger.info("Disabling client %s", self.name)
589
 
        if getattr(self, "disable_initiator_tag", False):
 
605
        if getattr(self, "disable_initiator_tag", None) is not None:
590
606
            gobject.source_remove(self.disable_initiator_tag)
591
607
            self.disable_initiator_tag = None
592
608
        self.expires = None
593
 
        if getattr(self, "checker_initiator_tag", False):
 
609
        if getattr(self, "checker_initiator_tag", None) is not None:
594
610
            gobject.source_remove(self.checker_initiator_tag)
595
611
            self.checker_initiator_tag = None
596
612
        self.stop_checker()
597
613
        self.enabled = False
 
614
        if not quiet:
 
615
            self.send_changedstate()
598
616
        # Do not run this again if called by a gobject.timeout_add
599
617
        return False
600
618
    
604
622
    def init_checker(self):
605
623
        # Schedule a new checker to be started an 'interval' from now,
606
624
        # and every interval from then on.
 
625
        if self.checker_initiator_tag is not None:
 
626
            gobject.source_remove(self.checker_initiator_tag)
607
627
        self.checker_initiator_tag = (gobject.timeout_add
608
628
                                      (self.interval_milliseconds(),
609
629
                                       self.start_checker))
610
630
        # Schedule a disable() when 'timeout' has passed
 
631
        if self.disable_initiator_tag is not None:
 
632
            gobject.source_remove(self.disable_initiator_tag)
611
633
        self.disable_initiator_tag = (gobject.timeout_add
612
634
                                   (self.timeout_milliseconds(),
613
635
                                    self.disable))
644
666
            timeout = self.timeout
645
667
        if self.disable_initiator_tag is not None:
646
668
            gobject.source_remove(self.disable_initiator_tag)
 
669
            self.disable_initiator_tag = None
647
670
        if getattr(self, "enabled", False):
648
671
            self.disable_initiator_tag = (gobject.timeout_add
649
672
                                          (timedelta_to_milliseconds
670
693
        # If a checker exists, make sure it is not a zombie
671
694
        try:
672
695
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
673
 
        except (AttributeError, OSError) as error:
674
 
            if (isinstance(error, OSError)
675
 
                and error.errno != errno.ECHILD):
676
 
                raise error
 
696
        except AttributeError:
 
697
            pass
 
698
        except OSError as error:
 
699
            if error.errno != errno.ECHILD:
 
700
                raise
677
701
        else:
678
702
            if pid:
679
703
                logger.warning("Checker was a zombie")
682
706
                                      self.current_checker_command)
683
707
        # Start a new checker if needed
684
708
        if self.checker is None:
 
709
            # Escape attributes for the shell
 
710
            escaped_attrs = dict(
 
711
                (attr, re.escape(unicode(getattr(self, attr))))
 
712
                for attr in
 
713
                self.runtime_expansions)
685
714
            try:
686
 
                # In case checker_command has exactly one % operator
687
 
                command = self.checker_command % self.host
688
 
            except TypeError:
689
 
                # Escape attributes for the shell
690
 
                escaped_attrs = dict(
691
 
                    (attr,
692
 
                     re.escape(unicode(str(getattr(self, attr, "")),
693
 
                                       errors=
694
 
                                       'replace')))
695
 
                    for attr in
696
 
                    self.runtime_expansions)
697
 
                
698
 
                try:
699
 
                    command = self.checker_command % escaped_attrs
700
 
                except TypeError as error:
701
 
                    logger.error('Could not format string "%s"',
702
 
                                 self.checker_command, exc_info=error)
703
 
                    return True # Try again later
 
715
                command = self.checker_command % escaped_attrs
 
716
            except TypeError as error:
 
717
                logger.error('Could not format string "%s"',
 
718
                             self.checker_command, exc_info=error)
 
719
                return True # Try again later
704
720
            self.current_checker_command = command
705
721
            try:
706
722
                logger.info("Starting checker %r for %s",
709
725
                # in normal mode, that is already done by daemon(),
710
726
                # and in debug mode we don't want to.  (Stdin is
711
727
                # always replaced by /dev/null.)
 
728
                # The exception is when not debugging but nevertheless
 
729
                # running in the foreground; use the previously
 
730
                # created wnull.
 
731
                popen_args = {}
 
732
                if (not self.server_settings["debug"]
 
733
                    and self.server_settings["foreground"]):
 
734
                    popen_args.update({"stdout": wnull,
 
735
                                       "stderr": wnull })
712
736
                self.checker = subprocess.Popen(command,
713
737
                                                close_fds=True,
714
 
                                                shell=True, cwd="/")
715
 
                self.checker_callback_tag = (gobject.child_watch_add
716
 
                                             (self.checker.pid,
717
 
                                              self.checker_callback,
718
 
                                              data=command))
719
 
                # The checker may have completed before the gobject
720
 
                # watch was added.  Check for this.
721
 
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
722
 
                if pid:
723
 
                    gobject.source_remove(self.checker_callback_tag)
724
 
                    self.checker_callback(pid, status, command)
 
738
                                                shell=True, cwd="/",
 
739
                                                **popen_args)
725
740
            except OSError as error:
726
741
                logger.error("Failed to start subprocess",
727
742
                             exc_info=error)
 
743
                return True
 
744
            self.checker_callback_tag = (gobject.child_watch_add
 
745
                                         (self.checker.pid,
 
746
                                          self.checker_callback,
 
747
                                          data=command))
 
748
            # The checker may have completed before the gobject
 
749
            # watch was added.  Check for this.
 
750
            try:
 
751
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
752
            except OSError as error:
 
753
                if error.errno == errno.ECHILD:
 
754
                    # This should never happen
 
755
                    logger.error("Child process vanished",
 
756
                                 exc_info=error)
 
757
                    return True
 
758
                raise
 
759
            if pid:
 
760
                gobject.source_remove(self.checker_callback_tag)
 
761
                self.checker_callback(pid, status, command)
728
762
        # Re-run this periodically if run by gobject.timeout_add
729
763
        return True
730
764
    
903
937
            # The byte_arrays option is not supported yet on
904
938
            # signatures other than "ay".
905
939
            if prop._dbus_signature != "ay":
906
 
                raise ValueError
 
940
                raise ValueError("Byte arrays not supported for non-"
 
941
                                 "'ay' signature {0!r}"
 
942
                                 .format(prop._dbus_signature))
907
943
            value = dbus.ByteArray(b''.join(chr(byte)
908
944
                                            for byte in value))
909
945
        prop(value)
1015
1051
        return xmlstring
1016
1052
 
1017
1053
 
1018
 
def datetime_to_dbus (dt, variant_level=0):
 
1054
def datetime_to_dbus(dt, variant_level=0):
1019
1055
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1020
1056
    if dt is None:
1021
1057
        return dbus.String("", variant_level = variant_level)
1029
1065
    interface names according to the "alt_interface_names" mapping.
1030
1066
    Usage:
1031
1067
    
1032
 
    @alternate_dbus_names({"org.example.Interface":
1033
 
                               "net.example.AlternateInterface"})
 
1068
    @alternate_dbus_interfaces({"org.example.Interface":
 
1069
                                    "net.example.AlternateInterface"})
1034
1070
    class SampleDBusObject(dbus.service.Object):
1035
1071
        @dbus.service.method("org.example.Interface")
1036
1072
        def SampleDBusMethod():
1067
1103
                interface_names.add(alt_interface)
1068
1104
                # Is this a D-Bus signal?
1069
1105
                if getattr(attribute, "_dbus_is_signal", False):
1070
 
                    # Extract the original non-method function by
1071
 
                    # black magic
 
1106
                    # Extract the original non-method undecorated
 
1107
                    # function by black magic
1072
1108
                    nonmethod_func = (dict(
1073
1109
                            zip(attribute.func_code.co_freevars,
1074
1110
                                attribute.__closure__))["func"]
1317
1353
                                       *args, **kwargs)
1318
1354
    
1319
1355
    def start_checker(self, *args, **kwargs):
1320
 
        old_checker = self.checker
1321
 
        if self.checker is not None:
1322
 
            old_checker_pid = self.checker.pid
1323
 
        else:
1324
 
            old_checker_pid = None
 
1356
        old_checker_pid = getattr(self.checker, "pid", None)
1325
1357
        r = Client.start_checker(self, *args, **kwargs)
1326
1358
        # Only if new checker process was started
1327
1359
        if (self.checker is not None
1335
1367
        return False
1336
1368
    
1337
1369
    def approve(self, value=True):
1338
 
        self.send_changedstate()
1339
1370
        self.approved = value
1340
1371
        gobject.timeout_add(timedelta_to_milliseconds
1341
1372
                            (self.approval_duration),
1342
1373
                            self._reset_approved)
 
1374
        self.send_changedstate()
1343
1375
    
1344
1376
    ## D-Bus methods, signals & properties
1345
1377
    _interface = "se.recompile.Mandos.Client"
1529
1561
    def Timeout_dbus_property(self, value=None):
1530
1562
        if value is None:       # get
1531
1563
            return dbus.UInt64(self.timeout_milliseconds())
 
1564
        old_timeout = self.timeout
1532
1565
        self.timeout = datetime.timedelta(0, 0, 0, value)
1533
 
        # Reschedule timeout
 
1566
        # Reschedule disabling
1534
1567
        if self.enabled:
1535
1568
            now = datetime.datetime.utcnow()
1536
 
            time_to_die = timedelta_to_milliseconds(
1537
 
                (self.last_checked_ok + self.timeout) - now)
1538
 
            if time_to_die <= 0:
 
1569
            self.expires += self.timeout - old_timeout
 
1570
            if self.expires <= now:
1539
1571
                # The timeout has passed
1540
1572
                self.disable()
1541
1573
            else:
1542
 
                self.expires = (now +
1543
 
                                datetime.timedelta(milliseconds =
1544
 
                                                   time_to_die))
1545
1574
                if (getattr(self, "disable_initiator_tag", None)
1546
1575
                    is None):
1547
1576
                    return
1548
1577
                gobject.source_remove(self.disable_initiator_tag)
1549
 
                self.disable_initiator_tag = (gobject.timeout_add
1550
 
                                              (time_to_die,
1551
 
                                               self.disable))
 
1578
                self.disable_initiator_tag = (
 
1579
                    gobject.timeout_add(
 
1580
                        timedelta_to_milliseconds(self.expires - now),
 
1581
                        self.disable))
1552
1582
    
1553
1583
    # ExtendedTimeout - property
1554
1584
    @dbus_service_property(_interface, signature="t",
1674
1704
            logger.debug("Protocol version: %r", line)
1675
1705
            try:
1676
1706
                if int(line.strip().split()[0]) > 1:
1677
 
                    raise RuntimeError
 
1707
                    raise RuntimeError(line)
1678
1708
            except (ValueError, IndexError, RuntimeError) as error:
1679
1709
                logger.error("Unknown protocol version: %s", error)
1680
1710
                return
1742
1772
                    #wait until timeout or approved
1743
1773
                    time = datetime.datetime.now()
1744
1774
                    client.changedstate.acquire()
1745
 
                    (client.changedstate.wait
1746
 
                     (float(client.timedelta_to_milliseconds(delay)
1747
 
                            / 1000)))
 
1775
                    client.changedstate.wait(
 
1776
                        float(timedelta_to_milliseconds(delay)
 
1777
                              / 1000))
1748
1778
                    client.changedstate.release()
1749
1779
                    time2 = datetime.datetime.now()
1750
1780
                    if (time2 - time) >= delay:
1887
1917
    
1888
1918
    def add_pipe(self, parent_pipe, proc):
1889
1919
        """Dummy function; override as necessary"""
1890
 
        raise NotImplementedError
 
1920
        raise NotImplementedError()
1891
1921
 
1892
1922
 
1893
1923
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1900
1930
        use_ipv6:       Boolean; to use IPv6 or not
1901
1931
    """
1902
1932
    def __init__(self, server_address, RequestHandlerClass,
1903
 
                 interface=None, use_ipv6=True):
 
1933
                 interface=None, use_ipv6=True, socketfd=None):
 
1934
        """If socketfd is set, use that file descriptor instead of
 
1935
        creating a new one with socket.socket().
 
1936
        """
1904
1937
        self.interface = interface
1905
1938
        if use_ipv6:
1906
1939
            self.address_family = socket.AF_INET6
 
1940
        if socketfd is not None:
 
1941
            # Save the file descriptor
 
1942
            self.socketfd = socketfd
 
1943
            # Save the original socket.socket() function
 
1944
            self.socket_socket = socket.socket
 
1945
            # To implement --socket, we monkey patch socket.socket.
 
1946
            # 
 
1947
            # (When socketserver.TCPServer is a new-style class, we
 
1948
            # could make self.socket into a property instead of monkey
 
1949
            # patching socket.socket.)
 
1950
            # 
 
1951
            # Create a one-time-only replacement for socket.socket()
 
1952
            @functools.wraps(socket.socket)
 
1953
            def socket_wrapper(*args, **kwargs):
 
1954
                # Restore original function so subsequent calls are
 
1955
                # not affected.
 
1956
                socket.socket = self.socket_socket
 
1957
                del self.socket_socket
 
1958
                # This time only, return a new socket object from the
 
1959
                # saved file descriptor.
 
1960
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
1961
            # Replace socket.socket() function with wrapper
 
1962
            socket.socket = socket_wrapper
 
1963
        # The socketserver.TCPServer.__init__ will call
 
1964
        # socket.socket(), which might be our replacement,
 
1965
        # socket_wrapper(), if socketfd was set.
1907
1966
        socketserver.TCPServer.__init__(self, server_address,
1908
1967
                                        RequestHandlerClass)
 
1968
    
1909
1969
    def server_bind(self):
1910
1970
        """This overrides the normal server_bind() function
1911
1971
        to bind to an interface if one was specified, and also NOT to
1919
1979
                try:
1920
1980
                    self.socket.setsockopt(socket.SOL_SOCKET,
1921
1981
                                           SO_BINDTODEVICE,
1922
 
                                           str(self.interface
1923
 
                                               + '\0'))
 
1982
                                           str(self.interface + '\0'))
1924
1983
                except socket.error as error:
1925
 
                    if error[0] == errno.EPERM:
1926
 
                        logger.error("No permission to"
1927
 
                                     " bind to interface %s",
1928
 
                                     self.interface)
1929
 
                    elif error[0] == errno.ENOPROTOOPT:
 
1984
                    if error.errno == errno.EPERM:
 
1985
                        logger.error("No permission to bind to"
 
1986
                                     " interface %s", self.interface)
 
1987
                    elif error.errno == errno.ENOPROTOOPT:
1930
1988
                        logger.error("SO_BINDTODEVICE not available;"
1931
1989
                                     " cannot bind to interface %s",
1932
1990
                                     self.interface)
 
1991
                    elif error.errno == errno.ENODEV:
 
1992
                        logger.error("Interface %s does not exist,"
 
1993
                                     " cannot bind", self.interface)
1933
1994
                    else:
1934
1995
                        raise
1935
1996
        # Only bind(2) the socket if we really need to.
1938
1999
                if self.address_family == socket.AF_INET6:
1939
2000
                    any_address = "::" # in6addr_any
1940
2001
                else:
1941
 
                    any_address = socket.INADDR_ANY
 
2002
                    any_address = "0.0.0.0" # INADDR_ANY
1942
2003
                self.server_address = (any_address,
1943
2004
                                       self.server_address[1])
1944
2005
            elif not self.server_address[1]:
1965
2026
    """
1966
2027
    def __init__(self, server_address, RequestHandlerClass,
1967
2028
                 interface=None, use_ipv6=True, clients=None,
1968
 
                 gnutls_priority=None, use_dbus=True):
 
2029
                 gnutls_priority=None, use_dbus=True, socketfd=None):
1969
2030
        self.enabled = False
1970
2031
        self.clients = clients
1971
2032
        if self.clients is None:
1975
2036
        IPv6_TCPServer.__init__(self, server_address,
1976
2037
                                RequestHandlerClass,
1977
2038
                                interface = interface,
1978
 
                                use_ipv6 = use_ipv6)
 
2039
                                use_ipv6 = use_ipv6,
 
2040
                                socketfd = socketfd)
1979
2041
    def server_activate(self):
1980
2042
        if self.enabled:
1981
2043
            return socketserver.TCPServer.server_activate(self)
2059
2121
        return True
2060
2122
 
2061
2123
 
 
2124
def rfc3339_duration_to_delta(duration):
 
2125
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2126
    
 
2127
    >>> rfc3339_duration_to_delta("P7D")
 
2128
    datetime.timedelta(7)
 
2129
    >>> rfc3339_duration_to_delta("PT60S")
 
2130
    datetime.timedelta(0, 60)
 
2131
    >>> rfc3339_duration_to_delta("PT60M")
 
2132
    datetime.timedelta(0, 3600)
 
2133
    >>> rfc3339_duration_to_delta("PT24H")
 
2134
    datetime.timedelta(1)
 
2135
    >>> rfc3339_duration_to_delta("P1W")
 
2136
    datetime.timedelta(7)
 
2137
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2138
    datetime.timedelta(0, 330)
 
2139
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2140
    datetime.timedelta(1, 200)
 
2141
    """
 
2142
    
 
2143
    # Parsing an RFC 3339 duration with regular expressions is not
 
2144
    # possible - there would have to be multiple places for the same
 
2145
    # values, like seconds.  The current code, while more esoteric, is
 
2146
    # cleaner without depending on a parsing library.  If Python had a
 
2147
    # built-in library for parsing we would use it, but we'd like to
 
2148
    # avoid excessive use of external libraries.
 
2149
    
 
2150
    # New type for defining tokens, syntax, and semantics all-in-one
 
2151
    Token = collections.namedtuple("Token",
 
2152
                                   ("regexp", # To match token; if
 
2153
                                              # "value" is not None,
 
2154
                                              # must have a "group"
 
2155
                                              # containing digits
 
2156
                                    "value",  # datetime.timedelta or
 
2157
                                              # None
 
2158
                                    "followers")) # Tokens valid after
 
2159
                                                  # this token
 
2160
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2161
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2162
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2163
    token_second = Token(re.compile(r"(\d+)S"),
 
2164
                         datetime.timedelta(seconds=1),
 
2165
                         frozenset((token_end,)))
 
2166
    token_minute = Token(re.compile(r"(\d+)M"),
 
2167
                         datetime.timedelta(minutes=1),
 
2168
                         frozenset((token_second, token_end)))
 
2169
    token_hour = Token(re.compile(r"(\d+)H"),
 
2170
                       datetime.timedelta(hours=1),
 
2171
                       frozenset((token_minute, token_end)))
 
2172
    token_time = Token(re.compile(r"T"),
 
2173
                       None,
 
2174
                       frozenset((token_hour, token_minute,
 
2175
                                  token_second)))
 
2176
    token_day = Token(re.compile(r"(\d+)D"),
 
2177
                      datetime.timedelta(days=1),
 
2178
                      frozenset((token_time, token_end)))
 
2179
    token_month = Token(re.compile(r"(\d+)M"),
 
2180
                        datetime.timedelta(weeks=4),
 
2181
                        frozenset((token_day, token_end)))
 
2182
    token_year = Token(re.compile(r"(\d+)Y"),
 
2183
                       datetime.timedelta(weeks=52),
 
2184
                       frozenset((token_month, token_end)))
 
2185
    token_week = Token(re.compile(r"(\d+)W"),
 
2186
                       datetime.timedelta(weeks=1),
 
2187
                       frozenset((token_end,)))
 
2188
    token_duration = Token(re.compile(r"P"), None,
 
2189
                           frozenset((token_year, token_month,
 
2190
                                      token_day, token_time,
 
2191
                                      token_week))),
 
2192
    # Define starting values
 
2193
    value = datetime.timedelta() # Value so far
 
2194
    found_token = None
 
2195
    followers = frozenset(token_duration,) # Following valid tokens
 
2196
    s = duration                # String left to parse
 
2197
    # Loop until end token is found
 
2198
    while found_token is not token_end:
 
2199
        # Search for any currently valid tokens
 
2200
        for token in followers:
 
2201
            match = token.regexp.match(s)
 
2202
            if match is not None:
 
2203
                # Token found
 
2204
                if token.value is not None:
 
2205
                    # Value found, parse digits
 
2206
                    factor = int(match.group(1), 10)
 
2207
                    # Add to value so far
 
2208
                    value += factor * token.value
 
2209
                # Strip token from string
 
2210
                s = token.regexp.sub("", s, 1)
 
2211
                # Go to found token
 
2212
                found_token = token
 
2213
                # Set valid next tokens
 
2214
                followers = found_token.followers
 
2215
                break
 
2216
        else:
 
2217
            # No currently valid tokens were found
 
2218
            raise ValueError("Invalid RFC 3339 duration")
 
2219
    # End token found
 
2220
    return value
 
2221
 
 
2222
 
2062
2223
def string_to_delta(interval):
2063
2224
    """Parse a string and return a datetime.timedelta
2064
2225
    
2075
2236
    >>> string_to_delta('5m 30s')
2076
2237
    datetime.timedelta(0, 330)
2077
2238
    """
 
2239
    
 
2240
    try:
 
2241
        return rfc3339_duration_to_delta(interval)
 
2242
    except ValueError:
 
2243
        pass
 
2244
    
2078
2245
    timevalue = datetime.timedelta(0)
2079
2246
    for s in interval.split():
2080
2247
        try:
2093
2260
            else:
2094
2261
                raise ValueError("Unknown suffix {0!r}"
2095
2262
                                 .format(suffix))
2096
 
        except (ValueError, IndexError) as e:
 
2263
        except IndexError as e:
2097
2264
            raise ValueError(*(e.args))
2098
2265
        timevalue += delta
2099
2266
    return timevalue
2143
2310
                        help="Run self-test")
2144
2311
    parser.add_argument("--debug", action="store_true",
2145
2312
                        help="Debug mode; run in foreground and log"
2146
 
                        " to terminal")
 
2313
                        " to terminal", default=None)
2147
2314
    parser.add_argument("--debuglevel", metavar="LEVEL",
2148
2315
                        help="Debug level for stdout output")
2149
2316
    parser.add_argument("--priority", help="GnuTLS"
2156
2323
                        " files")
2157
2324
    parser.add_argument("--no-dbus", action="store_false",
2158
2325
                        dest="use_dbus", help="Do not provide D-Bus"
2159
 
                        " system bus interface")
 
2326
                        " system bus interface", default=None)
2160
2327
    parser.add_argument("--no-ipv6", action="store_false",
2161
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2328
                        dest="use_ipv6", help="Do not use IPv6",
 
2329
                        default=None)
2162
2330
    parser.add_argument("--no-restore", action="store_false",
2163
2331
                        dest="restore", help="Do not restore stored"
2164
 
                        " state")
 
2332
                        " state", default=None)
 
2333
    parser.add_argument("--socket", type=int,
 
2334
                        help="Specify a file descriptor to a network"
 
2335
                        " socket to use instead of creating one")
2165
2336
    parser.add_argument("--statedir", metavar="DIR",
2166
2337
                        help="Directory to save/restore state in")
 
2338
    parser.add_argument("--foreground", action="store_true",
 
2339
                        help="Run in foreground", default=None)
 
2340
    parser.add_argument("--no-zeroconf", action="store_false",
 
2341
                        dest="zeroconf", help="Do not use Zeroconf",
 
2342
                        default=None)
2167
2343
    
2168
2344
    options = parser.parse_args()
2169
2345
    
2170
2346
    if options.check:
2171
2347
        import doctest
2172
 
        doctest.testmod()
2173
 
        sys.exit()
 
2348
        fail_count, test_count = doctest.testmod()
 
2349
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2174
2350
    
2175
2351
    # Default values for config file for server-global settings
2176
2352
    server_defaults = { "interface": "",
2178
2354
                        "port": "",
2179
2355
                        "debug": "False",
2180
2356
                        "priority":
2181
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2357
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2182
2358
                        "servicename": "Mandos",
2183
2359
                        "use_dbus": "True",
2184
2360
                        "use_ipv6": "True",
2185
2361
                        "debuglevel": "",
2186
2362
                        "restore": "True",
2187
 
                        "statedir": "/var/lib/mandos"
 
2363
                        "socket": "",
 
2364
                        "statedir": "/var/lib/mandos",
 
2365
                        "foreground": "False",
 
2366
                        "zeroconf": "True",
2188
2367
                        }
2189
2368
    
2190
2369
    # Parse config file for server-global settings
2195
2374
    # Convert the SafeConfigParser object to a dict
2196
2375
    server_settings = server_config.defaults()
2197
2376
    # Use the appropriate methods on the non-string config options
2198
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2377
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2199
2378
        server_settings[option] = server_config.getboolean("DEFAULT",
2200
2379
                                                           option)
2201
2380
    if server_settings["port"]:
2202
2381
        server_settings["port"] = server_config.getint("DEFAULT",
2203
2382
                                                       "port")
 
2383
    if server_settings["socket"]:
 
2384
        server_settings["socket"] = server_config.getint("DEFAULT",
 
2385
                                                         "socket")
 
2386
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
2387
        # over with an opened os.devnull.  But we don't want this to
 
2388
        # happen with a supplied network socket.
 
2389
        if 0 <= server_settings["socket"] <= 2:
 
2390
            server_settings["socket"] = os.dup(server_settings
 
2391
                                               ["socket"])
2204
2392
    del server_config
2205
2393
    
2206
2394
    # Override the settings from the config file with command line
2208
2396
    for option in ("interface", "address", "port", "debug",
2209
2397
                   "priority", "servicename", "configdir",
2210
2398
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2211
 
                   "statedir"):
 
2399
                   "statedir", "socket", "foreground", "zeroconf"):
2212
2400
        value = getattr(options, option)
2213
2401
        if value is not None:
2214
2402
            server_settings[option] = value
2217
2405
    for option in server_settings.keys():
2218
2406
        if type(server_settings[option]) is str:
2219
2407
            server_settings[option] = unicode(server_settings[option])
 
2408
    # Force all boolean options to be boolean
 
2409
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2410
                   "foreground", "zeroconf"):
 
2411
        server_settings[option] = bool(server_settings[option])
 
2412
    # Debug implies foreground
 
2413
    if server_settings["debug"]:
 
2414
        server_settings["foreground"] = True
2220
2415
    # Now we have our good server settings in "server_settings"
2221
2416
    
2222
2417
    ##################################################################
2223
2418
    
 
2419
    if (not server_settings["zeroconf"] and
 
2420
        not (server_settings["port"]
 
2421
             or server_settings["socket"] != "")):
 
2422
            parser.error("Needs port or socket to work without"
 
2423
                         " Zeroconf")
 
2424
    
2224
2425
    # For convenience
2225
2426
    debug = server_settings["debug"]
2226
2427
    debuglevel = server_settings["debuglevel"]
2228
2429
    use_ipv6 = server_settings["use_ipv6"]
2229
2430
    stored_state_path = os.path.join(server_settings["statedir"],
2230
2431
                                     stored_state_file)
 
2432
    foreground = server_settings["foreground"]
 
2433
    zeroconf = server_settings["zeroconf"]
2231
2434
    
2232
2435
    if debug:
2233
2436
        initlogger(debug, logging.DEBUG)
2254
2457
    global mandos_dbus_service
2255
2458
    mandos_dbus_service = None
2256
2459
    
 
2460
    socketfd = None
 
2461
    if server_settings["socket"] != "":
 
2462
        socketfd = server_settings["socket"]
2257
2463
    tcp_server = MandosServer((server_settings["address"],
2258
2464
                               server_settings["port"]),
2259
2465
                              ClientHandler,
2262
2468
                              use_ipv6=use_ipv6,
2263
2469
                              gnutls_priority=
2264
2470
                              server_settings["priority"],
2265
 
                              use_dbus=use_dbus)
2266
 
    if not debug:
2267
 
        pidfilename = "/var/run/mandos.pid"
 
2471
                              use_dbus=use_dbus,
 
2472
                              socketfd=socketfd)
 
2473
    if not foreground:
 
2474
        pidfilename = "/run/mandos.pid"
 
2475
        if not os.path.isdir("/run/."):
 
2476
            pidfilename = "/var/run/mandos.pid"
 
2477
        pidfile = None
2268
2478
        try:
2269
2479
            pidfile = open(pidfilename, "w")
2270
2480
        except IOError as e:
2285
2495
        os.setgid(gid)
2286
2496
        os.setuid(uid)
2287
2497
    except OSError as error:
2288
 
        if error[0] != errno.EPERM:
2289
 
            raise error
 
2498
        if error.errno != errno.EPERM:
 
2499
            raise
2290
2500
    
2291
2501
    if debug:
2292
2502
        # Enable all possible GnuTLS debugging
2309
2519
            os.close(null)
2310
2520
    
2311
2521
    # Need to fork before connecting to D-Bus
2312
 
    if not debug:
 
2522
    if not foreground:
2313
2523
        # Close all input and output, do double fork, etc.
2314
2524
        daemon()
2315
2525
    
 
2526
    # multiprocessing will use threads, so before we use gobject we
 
2527
    # need to inform gobject that threads will be used.
2316
2528
    gobject.threads_init()
2317
2529
    
2318
2530
    global main_loop
2333
2545
            use_dbus = False
2334
2546
            server_settings["use_dbus"] = False
2335
2547
            tcp_server.use_dbus = False
2336
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2337
 
    service = AvahiServiceToSyslog(name =
2338
 
                                   server_settings["servicename"],
2339
 
                                   servicetype = "_mandos._tcp",
2340
 
                                   protocol = protocol, bus = bus)
2341
 
    if server_settings["interface"]:
2342
 
        service.interface = (if_nametoindex
2343
 
                             (str(server_settings["interface"])))
 
2548
    if zeroconf:
 
2549
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
2550
        service = AvahiServiceToSyslog(name =
 
2551
                                       server_settings["servicename"],
 
2552
                                       servicetype = "_mandos._tcp",
 
2553
                                       protocol = protocol, bus = bus)
 
2554
        if server_settings["interface"]:
 
2555
            service.interface = (if_nametoindex
 
2556
                                 (str(server_settings["interface"])))
2344
2557
    
2345
2558
    global multiprocessing_manager
2346
2559
    multiprocessing_manager = multiprocessing.Manager()
2353
2566
    old_client_settings = {}
2354
2567
    clients_data = {}
2355
2568
    
 
2569
    # This is used to redirect stdout and stderr for checker processes
 
2570
    global wnull
 
2571
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2572
    # Only used if server is running in foreground but not in debug
 
2573
    # mode
 
2574
    if debug or not foreground:
 
2575
        wnull.close()
 
2576
    
2356
2577
    # Get client data and settings from last running state.
2357
2578
    if server_settings["restore"]:
2358
2579
        try:
2374
2595
    
2375
2596
    with PGPEngine() as pgp:
2376
2597
        for client_name, client in clients_data.iteritems():
 
2598
            # Skip removed clients
 
2599
            if client_name not in client_settings:
 
2600
                continue
 
2601
            
2377
2602
            # Decide which value to use after restoring saved state.
2378
2603
            # We have three different values: Old config file,
2379
2604
            # new config file, and saved state.
2441
2666
    # Create all client objects
2442
2667
    for client_name, client in clients_data.iteritems():
2443
2668
        tcp_server.clients[client_name] = client_class(
2444
 
            name = client_name, settings = client)
 
2669
            name = client_name, settings = client,
 
2670
            server_settings = server_settings)
2445
2671
    
2446
2672
    if not tcp_server.clients:
2447
2673
        logger.warning("No clients defined")
2448
2674
    
2449
 
    if not debug:
2450
 
        try:
2451
 
            with pidfile:
2452
 
                pid = os.getpid()
2453
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2454
 
            del pidfile
2455
 
        except IOError:
2456
 
            logger.error("Could not write to file %r with PID %d",
2457
 
                         pidfilename, pid)
2458
 
        except NameError:
2459
 
            # "pidfile" was never created
2460
 
            pass
 
2675
    if not foreground:
 
2676
        if pidfile is not None:
 
2677
            try:
 
2678
                with pidfile:
 
2679
                    pid = os.getpid()
 
2680
                    pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2681
            except IOError:
 
2682
                logger.error("Could not write to file %r with PID %d",
 
2683
                             pidfilename, pid)
 
2684
        del pidfile
2461
2685
        del pidfilename
2462
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2463
2686
    
2464
2687
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2465
2688
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2530
2753
    
2531
2754
    def cleanup():
2532
2755
        "Cleanup function; run on exit"
2533
 
        service.cleanup()
 
2756
        if zeroconf:
 
2757
            service.cleanup()
2534
2758
        
2535
2759
        multiprocessing.active_children()
 
2760
        wnull.close()
2536
2761
        if not (tcp_server.clients or client_settings):
2537
2762
            return
2538
2763
        
2550
2775
                # A list of attributes that can not be pickled
2551
2776
                # + secret.
2552
2777
                exclude = set(("bus", "changedstate", "secret",
2553
 
                               "checker"))
 
2778
                               "checker", "server_settings"))
2554
2779
                for name, typ in (inspect.getmembers
2555
2780
                                  (dbus.service.Object)):
2556
2781
                    exclude.add(name)
2584
2809
            else:
2585
2810
                logger.warning("Could not save persistent state:",
2586
2811
                               exc_info=e)
2587
 
                raise e
 
2812
                raise
2588
2813
        
2589
2814
        # Delete all clients, and settings from config
2590
2815
        while tcp_server.clients:
2614
2839
    tcp_server.server_activate()
2615
2840
    
2616
2841
    # Find out what port we got
2617
 
    service.port = tcp_server.socket.getsockname()[1]
 
2842
    if zeroconf:
 
2843
        service.port = tcp_server.socket.getsockname()[1]
2618
2844
    if use_ipv6:
2619
2845
        logger.info("Now listening on address %r, port %d,"
2620
2846
                    " flowinfo %d, scope_id %d",
2626
2852
    #service.interface = tcp_server.socket.getsockname()[3]
2627
2853
    
2628
2854
    try:
2629
 
        # From the Avahi example code
2630
 
        try:
2631
 
            service.activate()
2632
 
        except dbus.exceptions.DBusException as error:
2633
 
            logger.critical("D-Bus Exception", exc_info=error)
2634
 
            cleanup()
2635
 
            sys.exit(1)
2636
 
        # End of Avahi example code
 
2855
        if zeroconf:
 
2856
            # From the Avahi example code
 
2857
            try:
 
2858
                service.activate()
 
2859
            except dbus.exceptions.DBusException as error:
 
2860
                logger.critical("D-Bus Exception", exc_info=error)
 
2861
                cleanup()
 
2862
                sys.exit(1)
 
2863
            # End of Avahi example code
2637
2864
        
2638
2865
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2639
2866
                             lambda *args, **kwargs: