/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-02-16 02:42:42 UTC
  • Revision ID: teddy@recompile.se-20140216024242-9wiw1nkxgt7ohovj
Fix running of self-tests.

* debian/control (Build-Depends): Add Python dependencies to
                                  successfully run self-tests.
* debian/copyright: GPLv3 now has its own license file - use it.
* debian/watch: Set PGP signature URL.
* mandos (main): Bug fix: When running self-tests, set exit code.
* mandos-ctl (main): Cosmetic fix; use os.EX_OK instead of plain 0.

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