/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: 2013-10-26 19:05:21 UTC
  • Revision ID: teddy@recompile.se-20131026190521-giagilisbyciox2h
Fall back to /var/run for pidfile if /run is not a directory.

This is for old (possibly non-Debian) systems which have not migrated
from /var/run to /run yet.

* init.d-mandos (PIDFILE): Fall back to /var/run/mandos.pid if /run is
                           not a directory.
* mandos (pidfilename): - '' -
* mandos.xml (FILES): Document fallback to /var/run/mandos.pid if /run
                      is not a directory.

Reported-by: Nathanael D. Noblet <nathanael@gnat.ca>
Suggested-by: Nathanael D. Noblet <nathanael@gnat.ca>

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-2013 Teddy Hogeborn
 
15
# Copyright © 2008-2013 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.2"
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)
711
721
                # in normal mode, that is already done by daemon(),
712
722
                # and in debug mode we don't want to.  (Stdin is
713
723
                # always replaced by /dev/null.)
 
724
                # The exception is when not debugging but nevertheless
 
725
                # running in the foreground; use the previously
 
726
                # created wnull.
 
727
                popen_args = {}
 
728
                if (not self.server_settings["debug"]
 
729
                    and self.server_settings["foreground"]):
 
730
                    popen_args.update({"stdout": wnull,
 
731
                                       "stderr": wnull })
714
732
                self.checker = subprocess.Popen(command,
715
733
                                                close_fds=True,
716
 
                                                shell=True, cwd="/")
 
734
                                                shell=True, cwd="/",
 
735
                                                **popen_args)
717
736
            except OSError as error:
718
737
                logger.error("Failed to start subprocess",
719
738
                             exc_info=error)
 
739
                return True
720
740
            self.checker_callback_tag = (gobject.child_watch_add
721
741
                                         (self.checker.pid,
722
742
                                          self.checker_callback,
723
743
                                          data=command))
724
744
            # The checker may have completed before the gobject
725
745
            # watch was added.  Check for this.
726
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
746
            try:
 
747
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
748
            except OSError as error:
 
749
                if error.errno == errno.ECHILD:
 
750
                    # This should never happen
 
751
                    logger.error("Child process vanished",
 
752
                                 exc_info=error)
 
753
                    return True
 
754
                raise
727
755
            if pid:
728
756
                gobject.source_remove(self.checker_callback_tag)
729
757
                self.checker_callback(pid, status, command)
1069
1097
                interface_names.add(alt_interface)
1070
1098
                # Is this a D-Bus signal?
1071
1099
                if getattr(attribute, "_dbus_is_signal", False):
1072
 
                    # Extract the original non-method function by
1073
 
                    # black magic
 
1100
                    # Extract the original non-method undecorated
 
1101
                    # function by black magic
1074
1102
                    nonmethod_func = (dict(
1075
1103
                            zip(attribute.func_code.co_freevars,
1076
1104
                                attribute.__closure__))["func"]
1969
1997
                if self.address_family == socket.AF_INET6:
1970
1998
                    any_address = "::" # in6addr_any
1971
1999
                else:
1972
 
                    any_address = socket.INADDR_ANY
 
2000
                    any_address = "0.0.0.0" # INADDR_ANY
1973
2001
                self.server_address = (any_address,
1974
2002
                                       self.server_address[1])
1975
2003
            elif not self.server_address[1]:
2280
2308
                        help="Run self-test")
2281
2309
    parser.add_argument("--debug", action="store_true",
2282
2310
                        help="Debug mode; run in foreground and log"
2283
 
                        " to terminal")
 
2311
                        " to terminal", default=None)
2284
2312
    parser.add_argument("--debuglevel", metavar="LEVEL",
2285
2313
                        help="Debug level for stdout output")
2286
2314
    parser.add_argument("--priority", help="GnuTLS"
2293
2321
                        " files")
2294
2322
    parser.add_argument("--no-dbus", action="store_false",
2295
2323
                        dest="use_dbus", help="Do not provide D-Bus"
2296
 
                        " system bus interface")
 
2324
                        " system bus interface", default=None)
2297
2325
    parser.add_argument("--no-ipv6", action="store_false",
2298
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2326
                        dest="use_ipv6", help="Do not use IPv6",
 
2327
                        default=None)
2299
2328
    parser.add_argument("--no-restore", action="store_false",
2300
2329
                        dest="restore", help="Do not restore stored"
2301
 
                        " state")
 
2330
                        " state", default=None)
2302
2331
    parser.add_argument("--socket", type=int,
2303
2332
                        help="Specify a file descriptor to a network"
2304
2333
                        " socket to use instead of creating one")
2305
2334
    parser.add_argument("--statedir", metavar="DIR",
2306
2335
                        help="Directory to save/restore state in")
2307
2336
    parser.add_argument("--foreground", action="store_true",
2308
 
                        help="Run in foreground")
 
2337
                        help="Run in foreground", default=None)
2309
2338
    
2310
2339
    options = parser.parse_args()
2311
2340
    
2320
2349
                        "port": "",
2321
2350
                        "debug": "False",
2322
2351
                        "priority":
2323
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2352
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2324
2353
                        "servicename": "Mandos",
2325
2354
                        "use_dbus": "True",
2326
2355
                        "use_ipv6": "True",
2370
2399
    for option in server_settings.keys():
2371
2400
        if type(server_settings[option]) is str:
2372
2401
            server_settings[option] = unicode(server_settings[option])
 
2402
    # Force all boolean options to be boolean
 
2403
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2404
                   "foreground"):
 
2405
        server_settings[option] = bool(server_settings[option])
2373
2406
    # Debug implies foreground
2374
2407
    if server_settings["debug"]:
2375
2408
        server_settings["foreground"] = True
2423
2456
                              socketfd=(server_settings["socket"]
2424
2457
                                        or None))
2425
2458
    if not foreground:
2426
 
        pidfilename = "/var/run/mandos.pid"
 
2459
        pidfilename = "/run/mandos.pid"
 
2460
        if not os.path.isdir("/run/."):
 
2461
            pidfilename = "/var/run/mandos.pid"
2427
2462
        pidfile = None
2428
2463
        try:
2429
2464
            pidfile = open(pidfilename, "w")
2515
2550
    old_client_settings = {}
2516
2551
    clients_data = {}
2517
2552
    
 
2553
    # This is used to redirect stdout and stderr for checker processes
 
2554
    global wnull
 
2555
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2556
    # Only used if server is running in foreground but not in debug
 
2557
    # mode
 
2558
    if debug or not foreground:
 
2559
        wnull.close()
 
2560
    
2518
2561
    # Get client data and settings from last running state.
2519
2562
    if server_settings["restore"]:
2520
2563
        try:
2536
2579
    
2537
2580
    with PGPEngine() as pgp:
2538
2581
        for client_name, client in clients_data.iteritems():
 
2582
            # Skip removed clients
 
2583
            if client_name not in client_settings:
 
2584
                continue
 
2585
            
2539
2586
            # Decide which value to use after restoring saved state.
2540
2587
            # We have three different values: Old config file,
2541
2588
            # new config file, and saved state.
2603
2650
    # Create all client objects
2604
2651
    for client_name, client in clients_data.iteritems():
2605
2652
        tcp_server.clients[client_name] = client_class(
2606
 
            name = client_name, settings = client)
 
2653
            name = client_name, settings = client,
 
2654
            server_settings = server_settings)
2607
2655
    
2608
2656
    if not tcp_server.clients:
2609
2657
        logger.warning("No clients defined")
2692
2740
        service.cleanup()
2693
2741
        
2694
2742
        multiprocessing.active_children()
 
2743
        wnull.close()
2695
2744
        if not (tcp_server.clients or client_settings):
2696
2745
            return
2697
2746
        
2709
2758
                # A list of attributes that can not be pickled
2710
2759
                # + secret.
2711
2760
                exclude = set(("bus", "changedstate", "secret",
2712
 
                               "checker"))
 
2761
                               "checker", "server_settings"))
2713
2762
                for name, typ in (inspect.getmembers
2714
2763
                                  (dbus.service.Object)):
2715
2764
                    exclude.add(name)