/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)
914
934
            # The byte_arrays option is not supported yet on
915
935
            # signatures other than "ay".
916
936
            if prop._dbus_signature != "ay":
917
 
                raise ValueError
 
937
                raise ValueError("Byte arrays not supported for non-"
 
938
                                 "'ay' signature {0!r}"
 
939
                                 .format(prop._dbus_signature))
918
940
            value = dbus.ByteArray(b''.join(chr(byte)
919
941
                                            for byte in value))
920
942
        prop(value)
1078
1100
                interface_names.add(alt_interface)
1079
1101
                # Is this a D-Bus signal?
1080
1102
                if getattr(attribute, "_dbus_is_signal", False):
1081
 
                    # Extract the original non-method function by
1082
 
                    # black magic
 
1103
                    # Extract the original non-method undecorated
 
1104
                    # function by black magic
1083
1105
                    nonmethod_func = (dict(
1084
1106
                            zip(attribute.func_code.co_freevars,
1085
1107
                                attribute.__closure__))["func"]
1683
1705
            logger.debug("Protocol version: %r", line)
1684
1706
            try:
1685
1707
                if int(line.strip().split()[0]) > 1:
1686
 
                    raise RuntimeError
 
1708
                    raise RuntimeError(line)
1687
1709
            except (ValueError, IndexError, RuntimeError) as error:
1688
1710
                logger.error("Unknown protocol version: %s", error)
1689
1711
                return
1896
1918
    
1897
1919
    def add_pipe(self, parent_pipe, proc):
1898
1920
        """Dummy function; override as necessary"""
1899
 
        raise NotImplementedError
 
1921
        raise NotImplementedError()
1900
1922
 
1901
1923
 
1902
1924
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1978
2000
                if self.address_family == socket.AF_INET6:
1979
2001
                    any_address = "::" # in6addr_any
1980
2002
                else:
1981
 
                    any_address = socket.INADDR_ANY
 
2003
                    any_address = "0.0.0.0" # INADDR_ANY
1982
2004
                self.server_address = (any_address,
1983
2005
                                       self.server_address[1])
1984
2006
            elif not self.server_address[1]:
2239
2261
            else:
2240
2262
                raise ValueError("Unknown suffix {0!r}"
2241
2263
                                 .format(suffix))
2242
 
        except (ValueError, IndexError) as e:
 
2264
        except IndexError as e:
2243
2265
            raise ValueError(*(e.args))
2244
2266
        timevalue += delta
2245
2267
    return timevalue
2289
2311
                        help="Run self-test")
2290
2312
    parser.add_argument("--debug", action="store_true",
2291
2313
                        help="Debug mode; run in foreground and log"
2292
 
                        " to terminal")
 
2314
                        " to terminal", default=None)
2293
2315
    parser.add_argument("--debuglevel", metavar="LEVEL",
2294
2316
                        help="Debug level for stdout output")
2295
2317
    parser.add_argument("--priority", help="GnuTLS"
2302
2324
                        " files")
2303
2325
    parser.add_argument("--no-dbus", action="store_false",
2304
2326
                        dest="use_dbus", help="Do not provide D-Bus"
2305
 
                        " system bus interface")
 
2327
                        " system bus interface", default=None)
2306
2328
    parser.add_argument("--no-ipv6", action="store_false",
2307
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2329
                        dest="use_ipv6", help="Do not use IPv6",
 
2330
                        default=None)
2308
2331
    parser.add_argument("--no-restore", action="store_false",
2309
2332
                        dest="restore", help="Do not restore stored"
2310
 
                        " state")
 
2333
                        " state", default=None)
2311
2334
    parser.add_argument("--socket", type=int,
2312
2335
                        help="Specify a file descriptor to a network"
2313
2336
                        " socket to use instead of creating one")
2314
2337
    parser.add_argument("--statedir", metavar="DIR",
2315
2338
                        help="Directory to save/restore state in")
2316
2339
    parser.add_argument("--foreground", action="store_true",
2317
 
                        help="Run in foreground")
 
2340
                        help="Run in foreground", default=None)
2318
2341
    
2319
2342
    options = parser.parse_args()
2320
2343
    
2321
2344
    if options.check:
2322
2345
        import doctest
2323
 
        doctest.testmod()
2324
 
        sys.exit()
 
2346
        fail_count, test_count = doctest.testmod()
 
2347
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2325
2348
    
2326
2349
    # Default values for config file for server-global settings
2327
2350
    server_defaults = { "interface": "",
2329
2352
                        "port": "",
2330
2353
                        "debug": "False",
2331
2354
                        "priority":
2332
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2355
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2333
2356
                        "servicename": "Mandos",
2334
2357
                        "use_dbus": "True",
2335
2358
                        "use_ipv6": "True",
2379
2402
    for option in server_settings.keys():
2380
2403
        if type(server_settings[option]) is str:
2381
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])
2382
2409
    # Debug implies foreground
2383
2410
    if server_settings["debug"]:
2384
2411
        server_settings["foreground"] = True
2432
2459
                              socketfd=(server_settings["socket"]
2433
2460
                                        or None))
2434
2461
    if not foreground:
2435
 
        pidfilename = "/var/run/mandos.pid"
 
2462
        pidfilename = "/run/mandos.pid"
 
2463
        if not os.path.isdir("/run/."):
 
2464
            pidfilename = "/var/run/mandos.pid"
2436
2465
        pidfile = None
2437
2466
        try:
2438
2467
            pidfile = open(pidfilename, "w")
2455
2484
        os.setuid(uid)
2456
2485
    except OSError as error:
2457
2486
        if error.errno != errno.EPERM:
2458
 
            raise error
 
2487
            raise
2459
2488
    
2460
2489
    if debug:
2461
2490
        # Enable all possible GnuTLS debugging
2524
2553
    old_client_settings = {}
2525
2554
    clients_data = {}
2526
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
    
2527
2564
    # Get client data and settings from last running state.
2528
2565
    if server_settings["restore"]:
2529
2566
        try:
2545
2582
    
2546
2583
    with PGPEngine() as pgp:
2547
2584
        for client_name, client in clients_data.iteritems():
 
2585
            # Skip removed clients
 
2586
            if client_name not in client_settings:
 
2587
                continue
 
2588
            
2548
2589
            # Decide which value to use after restoring saved state.
2549
2590
            # We have three different values: Old config file,
2550
2591
            # new config file, and saved state.
2612
2653
    # Create all client objects
2613
2654
    for client_name, client in clients_data.iteritems():
2614
2655
        tcp_server.clients[client_name] = client_class(
2615
 
            name = client_name, settings = client)
 
2656
            name = client_name, settings = client,
 
2657
            server_settings = server_settings)
2616
2658
    
2617
2659
    if not tcp_server.clients:
2618
2660
        logger.warning("No clients defined")
2701
2743
        service.cleanup()
2702
2744
        
2703
2745
        multiprocessing.active_children()
 
2746
        wnull.close()
2704
2747
        if not (tcp_server.clients or client_settings):
2705
2748
            return
2706
2749
        
2718
2761
                # A list of attributes that can not be pickled
2719
2762
                # + secret.
2720
2763
                exclude = set(("bus", "changedstate", "secret",
2721
 
                               "checker"))
 
2764
                               "checker", "server_settings"))
2722
2765
                for name, typ in (inspect.getmembers
2723
2766
                                  (dbus.service.Object)):
2724
2767
                    exclude.add(name)
2752
2795
            else:
2753
2796
                logger.warning("Could not save persistent state:",
2754
2797
                               exc_info=e)
2755
 
                raise e
 
2798
                raise
2756
2799
        
2757
2800
        # Delete all clients, and settings from config
2758
2801
        while tcp_server.clients: