/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)
1078
1097
                interface_names.add(alt_interface)
1079
1098
                # Is this a D-Bus signal?
1080
1099
                if getattr(attribute, "_dbus_is_signal", False):
1081
 
                    # Extract the original non-method function by
1082
 
                    # black magic
 
1100
                    # Extract the original non-method undecorated
 
1101
                    # function by black magic
1083
1102
                    nonmethod_func = (dict(
1084
1103
                            zip(attribute.func_code.co_freevars,
1085
1104
                                attribute.__closure__))["func"]
1978
1997
                if self.address_family == socket.AF_INET6:
1979
1998
                    any_address = "::" # in6addr_any
1980
1999
                else:
1981
 
                    any_address = socket.INADDR_ANY
 
2000
                    any_address = "0.0.0.0" # INADDR_ANY
1982
2001
                self.server_address = (any_address,
1983
2002
                                       self.server_address[1])
1984
2003
            elif not self.server_address[1]:
2289
2308
                        help="Run self-test")
2290
2309
    parser.add_argument("--debug", action="store_true",
2291
2310
                        help="Debug mode; run in foreground and log"
2292
 
                        " to terminal")
 
2311
                        " to terminal", default=None)
2293
2312
    parser.add_argument("--debuglevel", metavar="LEVEL",
2294
2313
                        help="Debug level for stdout output")
2295
2314
    parser.add_argument("--priority", help="GnuTLS"
2302
2321
                        " files")
2303
2322
    parser.add_argument("--no-dbus", action="store_false",
2304
2323
                        dest="use_dbus", help="Do not provide D-Bus"
2305
 
                        " system bus interface")
 
2324
                        " system bus interface", default=None)
2306
2325
    parser.add_argument("--no-ipv6", action="store_false",
2307
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2326
                        dest="use_ipv6", help="Do not use IPv6",
 
2327
                        default=None)
2308
2328
    parser.add_argument("--no-restore", action="store_false",
2309
2329
                        dest="restore", help="Do not restore stored"
2310
 
                        " state")
 
2330
                        " state", default=None)
2311
2331
    parser.add_argument("--socket", type=int,
2312
2332
                        help="Specify a file descriptor to a network"
2313
2333
                        " socket to use instead of creating one")
2314
2334
    parser.add_argument("--statedir", metavar="DIR",
2315
2335
                        help="Directory to save/restore state in")
2316
2336
    parser.add_argument("--foreground", action="store_true",
2317
 
                        help="Run in foreground")
 
2337
                        help="Run in foreground", default=None)
2318
2338
    
2319
2339
    options = parser.parse_args()
2320
2340
    
2329
2349
                        "port": "",
2330
2350
                        "debug": "False",
2331
2351
                        "priority":
2332
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2352
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2333
2353
                        "servicename": "Mandos",
2334
2354
                        "use_dbus": "True",
2335
2355
                        "use_ipv6": "True",
2379
2399
    for option in server_settings.keys():
2380
2400
        if type(server_settings[option]) is str:
2381
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])
2382
2406
    # Debug implies foreground
2383
2407
    if server_settings["debug"]:
2384
2408
        server_settings["foreground"] = True
2432
2456
                              socketfd=(server_settings["socket"]
2433
2457
                                        or None))
2434
2458
    if not foreground:
2435
 
        pidfilename = "/var/run/mandos.pid"
 
2459
        pidfilename = "/run/mandos.pid"
 
2460
        if not os.path.isdir("/run/."):
 
2461
            pidfilename = "/var/run/mandos.pid"
2436
2462
        pidfile = None
2437
2463
        try:
2438
2464
            pidfile = open(pidfilename, "w")
2524
2550
    old_client_settings = {}
2525
2551
    clients_data = {}
2526
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
    
2527
2561
    # Get client data and settings from last running state.
2528
2562
    if server_settings["restore"]:
2529
2563
        try:
2545
2579
    
2546
2580
    with PGPEngine() as pgp:
2547
2581
        for client_name, client in clients_data.iteritems():
 
2582
            # Skip removed clients
 
2583
            if client_name not in client_settings:
 
2584
                continue
 
2585
            
2548
2586
            # Decide which value to use after restoring saved state.
2549
2587
            # We have three different values: Old config file,
2550
2588
            # new config file, and saved state.
2612
2650
    # Create all client objects
2613
2651
    for client_name, client in clients_data.iteritems():
2614
2652
        tcp_server.clients[client_name] = client_class(
2615
 
            name = client_name, settings = client)
 
2653
            name = client_name, settings = client,
 
2654
            server_settings = server_settings)
2616
2655
    
2617
2656
    if not tcp_server.clients:
2618
2657
        logger.warning("No clients defined")
2701
2740
        service.cleanup()
2702
2741
        
2703
2742
        multiprocessing.active_children()
 
2743
        wnull.close()
2704
2744
        if not (tcp_server.clients or client_settings):
2705
2745
            return
2706
2746
        
2718
2758
                # A list of attributes that can not be pickled
2719
2759
                # + secret.
2720
2760
                exclude = set(("bus", "changedstate", "secret",
2721
 
                               "checker"))
 
2761
                               "checker", "server_settings"))
2722
2762
                for name, typ in (inspect.getmembers
2723
2763
                                  (dbus.service.Object)):
2724
2764
                    exclude.add(name)