/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-03-01 09:39:25 UTC
  • Revision ID: teddy@recompile.se-20140301093925-0x6nwf21f0zljk6e
* debian/copyright: Change year to "2014".
* mandos-ctl: - '' -
* mandos-monitor: - '' -
* plugins.d/mandos-client.xml: - '' -

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
79
79
import ctypes.util
80
80
import xml.dom.minidom
81
81
import inspect
82
 
import GnuPGInterface
83
82
 
84
83
try:
85
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
89
88
    except ImportError:
90
89
        SO_BINDTODEVICE = None
91
90
 
92
 
version = "1.6.0"
 
91
version = "1.6.4"
93
92
stored_state_file = "clients.pickle"
94
93
 
95
94
logger = logging.getLogger()
96
 
syslogger = (logging.handlers.SysLogHandler
97
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
98
 
              address = str("/dev/log")))
 
95
syslogger = None
99
96
 
100
97
try:
101
98
    if_nametoindex = (ctypes.cdll.LoadLibrary
117
114
def initlogger(debug, level=logging.WARNING):
118
115
    """init logger and add loglevel"""
119
116
    
 
117
    syslogger = (logging.handlers.SysLogHandler
 
118
                 (facility =
 
119
                  logging.handlers.SysLogHandler.LOG_DAEMON,
 
120
                  address = str("/dev/log")))
120
121
    syslogger.setFormatter(logging.Formatter
121
122
                           ('Mandos [%(process)d]: %(levelname)s:'
122
123
                            ' %(message)s'))
140
141
class PGPEngine(object):
141
142
    """A simple class for OpenPGP symmetric encryption & decryption"""
142
143
    def __init__(self):
143
 
        self.gnupg = GnuPGInterface.GnuPG()
144
144
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
145
 
        self.gnupg = GnuPGInterface.GnuPG()
146
 
        self.gnupg.options.meta_interactive = False
147
 
        self.gnupg.options.homedir = self.tempdir
148
 
        self.gnupg.options.extra_args.extend(['--force-mdc',
149
 
                                              '--quiet',
150
 
                                              '--no-use-agent'])
 
145
        self.gnupgargs = ['--batch',
 
146
                          '--home', self.tempdir,
 
147
                          '--force-mdc',
 
148
                          '--quiet',
 
149
                          '--no-use-agent']
151
150
    
152
151
    def __enter__(self):
153
152
        return self
175
174
    def password_encode(self, password):
176
175
        # Passphrase can not be empty and can not contain newlines or
177
176
        # NUL bytes.  So we prefix it and hex encode it.
178
 
        return b"mandos" + binascii.hexlify(password)
 
177
        encoded = b"mandos" + binascii.hexlify(password)
 
178
        if len(encoded) > 2048:
 
179
            # GnuPG can't handle long passwords, so encode differently
 
180
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
181
                       .replace(b"\n", b"\\n")
 
182
                       .replace(b"\0", b"\\x00"))
 
183
        return encoded
179
184
    
180
185
    def encrypt(self, data, password):
181
 
        self.gnupg.passphrase = self.password_encode(password)
182
 
        with open(os.devnull, "w") as devnull:
183
 
            try:
184
 
                proc = self.gnupg.run(['--symmetric'],
185
 
                                      create_fhs=['stdin', 'stdout'],
186
 
                                      attach_fhs={'stderr': devnull})
187
 
                with contextlib.closing(proc.handles['stdin']) as f:
188
 
                    f.write(data)
189
 
                with contextlib.closing(proc.handles['stdout']) as f:
190
 
                    ciphertext = f.read()
191
 
                proc.wait()
192
 
            except IOError as e:
193
 
                raise PGPError(e)
194
 
        self.gnupg.passphrase = None
 
186
        passphrase = self.password_encode(password)
 
187
        with tempfile.NamedTemporaryFile(dir=self.tempdir
 
188
                                         ) as passfile:
 
189
            passfile.write(passphrase)
 
190
            passfile.flush()
 
191
            proc = subprocess.Popen(['gpg', '--symmetric',
 
192
                                     '--passphrase-file',
 
193
                                     passfile.name]
 
194
                                    + self.gnupgargs,
 
195
                                    stdin = subprocess.PIPE,
 
196
                                    stdout = subprocess.PIPE,
 
197
                                    stderr = subprocess.PIPE)
 
198
            ciphertext, err = proc.communicate(input = data)
 
199
        if proc.returncode != 0:
 
200
            raise PGPError(err)
195
201
        return ciphertext
196
202
    
197
203
    def decrypt(self, data, password):
198
 
        self.gnupg.passphrase = self.password_encode(password)
199
 
        with open(os.devnull, "w") as devnull:
200
 
            try:
201
 
                proc = self.gnupg.run(['--decrypt'],
202
 
                                      create_fhs=['stdin', 'stdout'],
203
 
                                      attach_fhs={'stderr': devnull})
204
 
                with contextlib.closing(proc.handles['stdin']) as f:
205
 
                    f.write(data)
206
 
                with contextlib.closing(proc.handles['stdout']) as f:
207
 
                    decrypted_plaintext = f.read()
208
 
                proc.wait()
209
 
            except IOError as e:
210
 
                raise PGPError(e)
211
 
        self.gnupg.passphrase = None
 
204
        passphrase = self.password_encode(password)
 
205
        with tempfile.NamedTemporaryFile(dir = self.tempdir
 
206
                                         ) as passfile:
 
207
            passfile.write(passphrase)
 
208
            passfile.flush()
 
209
            proc = subprocess.Popen(['gpg', '--decrypt',
 
210
                                     '--passphrase-file',
 
211
                                     passfile.name]
 
212
                                    + self.gnupgargs,
 
213
                                    stdin = subprocess.PIPE,
 
214
                                    stdout = subprocess.PIPE,
 
215
                                    stderr = subprocess.PIPE)
 
216
            decrypted_plaintext, err = proc.communicate(input
 
217
                                                        = data)
 
218
        if proc.returncode != 0:
 
219
            raise PGPError(err)
212
220
        return decrypted_plaintext
213
221
 
214
222
 
234
242
               Used to optionally bind to the specified interface.
235
243
    name: string; Example: 'Mandos'
236
244
    type: string; Example: '_mandos._tcp'.
237
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
245
     See <https://www.iana.org/assignments/service-names-port-numbers>
238
246
    port: integer; what port to announce
239
247
    TXT: list of strings; TXT record for the service
240
248
    domain: string; Domain to publish on, default to .local if empty.
440
448
    runtime_expansions: Allowed attributes for runtime expansion.
441
449
    expires:    datetime.datetime(); time (UTC) when a client will be
442
450
                disabled, or None
 
451
    server_settings: The server_settings dict from main()
443
452
    """
444
453
    
445
454
    runtime_expansions = ("approval_delay", "approval_duration",
520
529
        
521
530
        return settings
522
531
    
523
 
    def __init__(self, settings, name = None):
 
532
    def __init__(self, settings, name = None, server_settings=None):
524
533
        self.name = name
 
534
        if server_settings is None:
 
535
            server_settings = {}
 
536
        self.server_settings = server_settings
525
537
        # adding all client settings
526
538
        for setting, value in settings.iteritems():
527
539
            setattr(self, setting, value)
680
692
        # If a checker exists, make sure it is not a zombie
681
693
        try:
682
694
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
683
 
        except (AttributeError, OSError) as error:
684
 
            if (isinstance(error, OSError)
685
 
                and error.errno != errno.ECHILD):
686
 
                raise error
 
695
        except AttributeError:
 
696
            pass
 
697
        except OSError as error:
 
698
            if error.errno != errno.ECHILD:
 
699
                raise
687
700
        else:
688
701
            if pid:
689
702
                logger.warning("Checker was a zombie")
711
724
                # in normal mode, that is already done by daemon(),
712
725
                # and in debug mode we don't want to.  (Stdin is
713
726
                # always replaced by /dev/null.)
 
727
                # The exception is when not debugging but nevertheless
 
728
                # running in the foreground; use the previously
 
729
                # created wnull.
 
730
                popen_args = {}
 
731
                if (not self.server_settings["debug"]
 
732
                    and self.server_settings["foreground"]):
 
733
                    popen_args.update({"stdout": wnull,
 
734
                                       "stderr": wnull })
714
735
                self.checker = subprocess.Popen(command,
715
736
                                                close_fds=True,
716
 
                                                shell=True, cwd="/")
 
737
                                                shell=True, cwd="/",
 
738
                                                **popen_args)
717
739
            except OSError as error:
718
740
                logger.error("Failed to start subprocess",
719
741
                             exc_info=error)
 
742
                return True
720
743
            self.checker_callback_tag = (gobject.child_watch_add
721
744
                                         (self.checker.pid,
722
745
                                          self.checker_callback,
723
746
                                          data=command))
724
747
            # The checker may have completed before the gobject
725
748
            # watch was added.  Check for this.
726
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
749
            try:
 
750
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
751
            except OSError as error:
 
752
                if error.errno == errno.ECHILD:
 
753
                    # This should never happen
 
754
                    logger.error("Child process vanished",
 
755
                                 exc_info=error)
 
756
                    return True
 
757
                raise
727
758
            if pid:
728
759
                gobject.source_remove(self.checker_callback_tag)
729
760
                self.checker_callback(pid, status, command)
905
936
            # The byte_arrays option is not supported yet on
906
937
            # signatures other than "ay".
907
938
            if prop._dbus_signature != "ay":
908
 
                raise ValueError
 
939
                raise ValueError("Byte arrays not supported for non-"
 
940
                                 "'ay' signature {0!r}"
 
941
                                 .format(prop._dbus_signature))
909
942
            value = dbus.ByteArray(b''.join(chr(byte)
910
943
                                            for byte in value))
911
944
        prop(value)
1069
1102
                interface_names.add(alt_interface)
1070
1103
                # Is this a D-Bus signal?
1071
1104
                if getattr(attribute, "_dbus_is_signal", False):
1072
 
                    # Extract the original non-method function by
1073
 
                    # black magic
 
1105
                    # Extract the original non-method undecorated
 
1106
                    # function by black magic
1074
1107
                    nonmethod_func = (dict(
1075
1108
                            zip(attribute.func_code.co_freevars,
1076
1109
                                attribute.__closure__))["func"]
1319
1352
                                       *args, **kwargs)
1320
1353
    
1321
1354
    def start_checker(self, *args, **kwargs):
1322
 
        old_checker = self.checker
1323
 
        if self.checker is not None:
1324
 
            old_checker_pid = self.checker.pid
1325
 
        else:
1326
 
            old_checker_pid = None
 
1355
        old_checker_pid = getattr(self.checker, "pid", None)
1327
1356
        r = Client.start_checker(self, *args, **kwargs)
1328
1357
        # Only if new checker process was started
1329
1358
        if (self.checker is not None
1674
1703
            logger.debug("Protocol version: %r", line)
1675
1704
            try:
1676
1705
                if int(line.strip().split()[0]) > 1:
1677
 
                    raise RuntimeError
 
1706
                    raise RuntimeError(line)
1678
1707
            except (ValueError, IndexError, RuntimeError) as error:
1679
1708
                logger.error("Unknown protocol version: %s", error)
1680
1709
                return
1887
1916
    
1888
1917
    def add_pipe(self, parent_pipe, proc):
1889
1918
        """Dummy function; override as necessary"""
1890
 
        raise NotImplementedError
 
1919
        raise NotImplementedError()
1891
1920
 
1892
1921
 
1893
1922
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1969
1998
                if self.address_family == socket.AF_INET6:
1970
1999
                    any_address = "::" # in6addr_any
1971
2000
                else:
1972
 
                    any_address = socket.INADDR_ANY
 
2001
                    any_address = "0.0.0.0" # INADDR_ANY
1973
2002
                self.server_address = (any_address,
1974
2003
                                       self.server_address[1])
1975
2004
            elif not self.server_address[1]:
2230
2259
            else:
2231
2260
                raise ValueError("Unknown suffix {0!r}"
2232
2261
                                 .format(suffix))
2233
 
        except (ValueError, IndexError) as e:
 
2262
        except IndexError as e:
2234
2263
            raise ValueError(*(e.args))
2235
2264
        timevalue += delta
2236
2265
    return timevalue
2280
2309
                        help="Run self-test")
2281
2310
    parser.add_argument("--debug", action="store_true",
2282
2311
                        help="Debug mode; run in foreground and log"
2283
 
                        " to terminal")
 
2312
                        " to terminal", default=None)
2284
2313
    parser.add_argument("--debuglevel", metavar="LEVEL",
2285
2314
                        help="Debug level for stdout output")
2286
2315
    parser.add_argument("--priority", help="GnuTLS"
2293
2322
                        " files")
2294
2323
    parser.add_argument("--no-dbus", action="store_false",
2295
2324
                        dest="use_dbus", help="Do not provide D-Bus"
2296
 
                        " system bus interface")
 
2325
                        " system bus interface", default=None)
2297
2326
    parser.add_argument("--no-ipv6", action="store_false",
2298
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2327
                        dest="use_ipv6", help="Do not use IPv6",
 
2328
                        default=None)
2299
2329
    parser.add_argument("--no-restore", action="store_false",
2300
2330
                        dest="restore", help="Do not restore stored"
2301
 
                        " state")
 
2331
                        " state", default=None)
2302
2332
    parser.add_argument("--socket", type=int,
2303
2333
                        help="Specify a file descriptor to a network"
2304
2334
                        " socket to use instead of creating one")
2305
2335
    parser.add_argument("--statedir", metavar="DIR",
2306
2336
                        help="Directory to save/restore state in")
2307
2337
    parser.add_argument("--foreground", action="store_true",
2308
 
                        help="Run in foreground")
 
2338
                        help="Run in foreground", default=None)
2309
2339
    
2310
2340
    options = parser.parse_args()
2311
2341
    
2312
2342
    if options.check:
2313
2343
        import doctest
2314
 
        doctest.testmod()
2315
 
        sys.exit()
 
2344
        fail_count, test_count = doctest.testmod()
 
2345
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2316
2346
    
2317
2347
    # Default values for config file for server-global settings
2318
2348
    server_defaults = { "interface": "",
2320
2350
                        "port": "",
2321
2351
                        "debug": "False",
2322
2352
                        "priority":
2323
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2353
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2324
2354
                        "servicename": "Mandos",
2325
2355
                        "use_dbus": "True",
2326
2356
                        "use_ipv6": "True",
2370
2400
    for option in server_settings.keys():
2371
2401
        if type(server_settings[option]) is str:
2372
2402
            server_settings[option] = unicode(server_settings[option])
 
2403
    # Force all boolean options to be boolean
 
2404
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2405
                   "foreground"):
 
2406
        server_settings[option] = bool(server_settings[option])
2373
2407
    # Debug implies foreground
2374
2408
    if server_settings["debug"]:
2375
2409
        server_settings["foreground"] = True
2423
2457
                              socketfd=(server_settings["socket"]
2424
2458
                                        or None))
2425
2459
    if not foreground:
2426
 
        pidfilename = "/var/run/mandos.pid"
 
2460
        pidfilename = "/run/mandos.pid"
 
2461
        if not os.path.isdir("/run/."):
 
2462
            pidfilename = "/var/run/mandos.pid"
2427
2463
        pidfile = None
2428
2464
        try:
2429
2465
            pidfile = open(pidfilename, "w")
2446
2482
        os.setuid(uid)
2447
2483
    except OSError as error:
2448
2484
        if error.errno != errno.EPERM:
2449
 
            raise error
 
2485
            raise
2450
2486
    
2451
2487
    if debug:
2452
2488
        # Enable all possible GnuTLS debugging
2515
2551
    old_client_settings = {}
2516
2552
    clients_data = {}
2517
2553
    
 
2554
    # This is used to redirect stdout and stderr for checker processes
 
2555
    global wnull
 
2556
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2557
    # Only used if server is running in foreground but not in debug
 
2558
    # mode
 
2559
    if debug or not foreground:
 
2560
        wnull.close()
 
2561
    
2518
2562
    # Get client data and settings from last running state.
2519
2563
    if server_settings["restore"]:
2520
2564
        try:
2536
2580
    
2537
2581
    with PGPEngine() as pgp:
2538
2582
        for client_name, client in clients_data.iteritems():
 
2583
            # Skip removed clients
 
2584
            if client_name not in client_settings:
 
2585
                continue
 
2586
            
2539
2587
            # Decide which value to use after restoring saved state.
2540
2588
            # We have three different values: Old config file,
2541
2589
            # new config file, and saved state.
2603
2651
    # Create all client objects
2604
2652
    for client_name, client in clients_data.iteritems():
2605
2653
        tcp_server.clients[client_name] = client_class(
2606
 
            name = client_name, settings = client)
 
2654
            name = client_name, settings = client,
 
2655
            server_settings = server_settings)
2607
2656
    
2608
2657
    if not tcp_server.clients:
2609
2658
        logger.warning("No clients defined")
2692
2741
        service.cleanup()
2693
2742
        
2694
2743
        multiprocessing.active_children()
 
2744
        wnull.close()
2695
2745
        if not (tcp_server.clients or client_settings):
2696
2746
            return
2697
2747
        
2709
2759
                # A list of attributes that can not be pickled
2710
2760
                # + secret.
2711
2761
                exclude = set(("bus", "changedstate", "secret",
2712
 
                               "checker"))
 
2762
                               "checker", "server_settings"))
2713
2763
                for name, typ in (inspect.getmembers
2714
2764
                                  (dbus.service.Object)):
2715
2765
                    exclude.add(name)
2743
2793
            else:
2744
2794
                logger.warning("Could not save persistent state:",
2745
2795
                               exc_info=e)
2746
 
                raise e
 
2796
                raise
2747
2797
        
2748
2798
        # Delete all clients, and settings from config
2749
2799
        while tcp_server.clients: