To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 237.7.195
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.195
- Committer: Teddy Hogeborn
- Date: 2013-12-31 16:02:18 UTC
- mto: (237.7.272 trunk)
- mto: This revision was merged to the branch mainline in revision 307.
- Revision ID: teddy@recompile.se-20131231160218-plmmb0o0iifkd5l2
Specify BusName in systemd service file.
* mandos.service (BusName): Uncommented.
* mandos.service (BusName): Uncommented.
- files added:
- debian/mandos-client.examples
- files modified:
- INSTALL
added
removed
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
68
68
import binascii
69
69
import tempfile
70
70
import itertools
71
import collections
71
72
72
73
import dbus
73
74
import dbus.service
78
79
import ctypes.util
79
80
import xml.dom.minidom
80
81
import inspect
81
import GnuPGInterface
82
82
83
83
try:
84
84
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
88
except ImportError:
89
89
SO_BINDTODEVICE = None
90
90
91
version = "1.5.4"
91
version = "1.6.2"
92
92
stored_state_file = "clients.pickle"
93
93
94
94
logger = logging.getLogger()
139
139
class PGPEngine(object):
140
140
"""A simple class for OpenPGP symmetric encryption & decryption"""
141
141
def __init__(self):
142
self.gnupg = GnuPGInterface.GnuPG()
143
142
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
144
self.gnupg = GnuPGInterface.GnuPG()
145
self.gnupg.options.meta_interactive = False
146
self.gnupg.options.homedir = self.tempdir
147
self.gnupg.options.extra_args.extend(['--force-mdc',
148
'--quiet',
149
'--no-use-agent'])
143
self.gnupgargs = ['--batch',
144
'--home', self.tempdir,
145
'--force-mdc',
146
'--quiet',
147
'--no-use-agent']
150
148
151
149
def __enter__(self):
152
150
return self
174
172
def password_encode(self, password):
175
173
# Passphrase can not be empty and can not contain newlines or
176
174
# NUL bytes. So we prefix it and hex encode it.
177
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
178
182
179
183
def encrypt(self, data, password):
180
self.gnupg.passphrase = self.password_encode(password)
181
with open(os.devnull, "w") as devnull:
182
try:
183
proc = self.gnupg.run(['--symmetric'],
184
create_fhs=['stdin', 'stdout'],
185
attach_fhs={'stderr': devnull})
186
with contextlib.closing(proc.handles['stdin']) as f:
187
f.write(data)
188
with contextlib.closing(proc.handles['stdout']) as f:
189
ciphertext = f.read()
190
proc.wait()
191
except IOError as e:
192
raise PGPError(e)
193
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)
194
199
return ciphertext
195
200
196
201
def decrypt(self, data, password):
197
self.gnupg.passphrase = self.password_encode(password)
198
with open(os.devnull, "w") as devnull:
199
try:
200
proc = self.gnupg.run(['--decrypt'],
201
create_fhs=['stdin', 'stdout'],
202
attach_fhs={'stderr': devnull})
203
with contextlib.closing(proc.handles['stdin']) as f:
204
f.write(data)
205
with contextlib.closing(proc.handles['stdout']) as f:
206
decrypted_plaintext = f.read()
207
proc.wait()
208
except IOError as e:
209
raise PGPError(e)
210
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)
211
218
return decrypted_plaintext
212
219
213
220
233
240
Used to optionally bind to the specified interface.
234
241
name: string; Example: 'Mandos'
235
242
type: string; Example: '_mandos._tcp'.
236
See <http://www.dns-sd.org/ServiceTypes.html>
243
See <https://www.iana.org/assignments/service-names-port-numbers>
237
244
port: integer; what port to announce
238
245
TXT: list of strings; TXT record for the service
239
246
domain: string; Domain to publish on, default to .local if empty.
439
446
runtime_expansions: Allowed attributes for runtime expansion.
440
447
expires: datetime.datetime(); time (UTC) when a client will be
441
448
disabled, or None
449
server_settings: The server_settings dict from main()
442
450
"""
443
451
444
452
runtime_expansions = ("approval_delay", "approval_duration",
446
454
"fingerprint", "host", "interval",
447
455
"last_approval_request", "last_checked_ok",
448
456
"last_enabled", "name", "timeout")
449
client_defaults = { "timeout": "5m",
450
"extended_timeout": "15m",
451
"interval": "2m",
457
client_defaults = { "timeout": "PT5M",
458
"extended_timeout": "PT15M",
459
"interval": "PT2M",
452
460
"checker": "fping -q -- %%(host)s",
453
461
"host": "",
454
"approval_delay": "0s",
455
"approval_duration": "1s",
462
"approval_delay": "PT0S",
463
"approval_duration": "PT1S",
456
464
"approved_by_default": "True",
457
465
"enabled": "True",
458
466
}
519
527
520
528
return settings
521
529
522
def __init__(self, settings, name = None):
530
def __init__(self, settings, name = None, server_settings=None):
523
531
self.name = name
532
if server_settings is None:
533
server_settings = {}
534
self.server_settings = server_settings
524
535
# adding all client settings
525
536
for setting, value in settings.iteritems():
526
537
setattr(self, setting, value)
679
690
# If a checker exists, make sure it is not a zombie
680
691
try:
681
692
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
682
except (AttributeError, OSError) as error:
683
if (isinstance(error, OSError)
684
and error.errno != errno.ECHILD):
685
raise error
693
except AttributeError:
694
pass
695
except OSError as error:
696
if error.errno != errno.ECHILD:
697
raise
686
698
else:
687
699
if pid:
688
700
logger.warning("Checker was a zombie")
710
722
# in normal mode, that is already done by daemon(),
711
723
# and in debug mode we don't want to. (Stdin is
712
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 })
713
733
self.checker = subprocess.Popen(command,
714
734
close_fds=True,
715
shell=True, cwd="/")
735
shell=True, cwd="/",
736
**popen_args)
716
737
except OSError as error:
717
738
logger.error("Failed to start subprocess",
718
739
exc_info=error)
740
return True
719
741
self.checker_callback_tag = (gobject.child_watch_add
720
742
(self.checker.pid,
721
743
self.checker_callback,
722
744
data=command))
723
745
# The checker may have completed before the gobject
724
746
# watch was added. Check for this.
725
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
726
756
if pid:
727
757
gobject.source_remove(self.checker_callback_tag)
728
758
self.checker_callback(pid, status, command)
1068
1098
interface_names.add(alt_interface)
1069
1099
# Is this a D-Bus signal?
1070
1100
if getattr(attribute, "_dbus_is_signal", False):
1071
# Extract the original non-method function by
1072
# black magic
1101
# Extract the original non-method undecorated
1102
# function by black magic
1073
1103
nonmethod_func = (dict(
1074
1104
zip(attribute.func_code.co_freevars,
1075
1105
attribute.__closure__))["func"]
1673
1703
logger.debug("Protocol version: %r", line)
1674
1704
try:
1675
1705
if int(line.strip().split()[0]) > 1:
1676
raise RuntimeError
1706
raise RuntimeError(line)
1677
1707
except (ValueError, IndexError, RuntimeError) as error:
1678
1708
logger.error("Unknown protocol version: %s", error)
1679
1709
return
1886
1916
1887
1917
def add_pipe(self, parent_pipe, proc):
1888
1918
"""Dummy function; override as necessary"""
1889
raise NotImplementedError
1919
raise NotImplementedError()
1890
1920
1891
1921
1892
1922
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1948
1978
try:
1949
1979
self.socket.setsockopt(socket.SOL_SOCKET,
1950
1980
SO_BINDTODEVICE,
1951
str(self.interface
1952
+ '\0'))
1981
str(self.interface + '\0'))
1953
1982
except socket.error as error:
1954
1983
if error.errno == errno.EPERM:
1955
logger.error("No permission to"
1956
" bind to interface %s",
1957
self.interface)
1984
logger.error("No permission to bind to"
1985
" interface %s", self.interface)
1958
1986
elif error.errno == errno.ENOPROTOOPT:
1959
1987
logger.error("SO_BINDTODEVICE not available;"
1960
1988
" cannot bind to interface %s",
1961
1989
self.interface)
1962
1990
elif error.errno == errno.ENODEV:
1963
logger.error("Interface %s does not"
1964
" exist, cannot bind",
1965
self.interface)
1991
logger.error("Interface %s does not exist,"
1992
" cannot bind", self.interface)
1966
1993
else:
1967
1994
raise
1968
1995
# Only bind(2) the socket if we really need to.
1971
1998
if self.address_family == socket.AF_INET6:
1972
1999
any_address = "::" # in6addr_any
1973
2000
else:
1974
any_address = socket.INADDR_ANY
2001
any_address = "0.0.0.0" # INADDR_ANY
1975
2002
self.server_address = (any_address,
1976
2003
self.server_address[1])
1977
2004
elif not self.server_address[1]:
2093
2120
return True
2094
2121
2095
2122
2123
def rfc3339_duration_to_delta(duration):
2124
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2125
2126
>>> rfc3339_duration_to_delta("P7D")
2127
datetime.timedelta(7)
2128
>>> rfc3339_duration_to_delta("PT60S")
2129
datetime.timedelta(0, 60)
2130
>>> rfc3339_duration_to_delta("PT60M")
2131
datetime.timedelta(0, 3600)
2132
>>> rfc3339_duration_to_delta("PT24H")
2133
datetime.timedelta(1)
2134
>>> rfc3339_duration_to_delta("P1W")
2135
datetime.timedelta(7)
2136
>>> rfc3339_duration_to_delta("PT5M30S")
2137
datetime.timedelta(0, 330)
2138
>>> rfc3339_duration_to_delta("P1DT3M20S")
2139
datetime.timedelta(1, 200)
2140
"""
2141
2142
# Parsing an RFC 3339 duration with regular expressions is not
2143
# possible - there would have to be multiple places for the same
2144
# values, like seconds. The current code, while more esoteric, is
2145
# cleaner without depending on a parsing library. If Python had a
2146
# built-in library for parsing we would use it, but we'd like to
2147
# avoid excessive use of external libraries.
2148
2149
# New type for defining tokens, syntax, and semantics all-in-one
2150
Token = collections.namedtuple("Token",
2151
("regexp", # To match token; if
2152
# "value" is not None,
2153
# must have a "group"
2154
# containing digits
2155
"value", # datetime.timedelta or
2156
# None
2157
"followers")) # Tokens valid after
2158
# this token
2159
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2160
# the "duration" ABNF definition in RFC 3339, Appendix A.
2161
token_end = Token(re.compile(r"$"), None, frozenset())
2162
token_second = Token(re.compile(r"(\d+)S"),
2163
datetime.timedelta(seconds=1),
2164
frozenset((token_end,)))
2165
token_minute = Token(re.compile(r"(\d+)M"),
2166
datetime.timedelta(minutes=1),
2167
frozenset((token_second, token_end)))
2168
token_hour = Token(re.compile(r"(\d+)H"),
2169
datetime.timedelta(hours=1),
2170
frozenset((token_minute, token_end)))
2171
token_time = Token(re.compile(r"T"),
2172
None,
2173
frozenset((token_hour, token_minute,
2174
token_second)))
2175
token_day = Token(re.compile(r"(\d+)D"),
2176
datetime.timedelta(days=1),
2177
frozenset((token_time, token_end)))
2178
token_month = Token(re.compile(r"(\d+)M"),
2179
datetime.timedelta(weeks=4),
2180
frozenset((token_day, token_end)))
2181
token_year = Token(re.compile(r"(\d+)Y"),
2182
datetime.timedelta(weeks=52),
2183
frozenset((token_month, token_end)))
2184
token_week = Token(re.compile(r"(\d+)W"),
2185
datetime.timedelta(weeks=1),
2186
frozenset((token_end,)))
2187
token_duration = Token(re.compile(r"P"), None,
2188
frozenset((token_year, token_month,
2189
token_day, token_time,
2190
token_week))),
2191
# Define starting values
2192
value = datetime.timedelta() # Value so far
2193
found_token = None
2194
followers = frozenset(token_duration,) # Following valid tokens
2195
s = duration # String left to parse
2196
# Loop until end token is found
2197
while found_token is not token_end:
2198
# Search for any currently valid tokens
2199
for token in followers:
2200
match = token.regexp.match(s)
2201
if match is not None:
2202
# Token found
2203
if token.value is not None:
2204
# Value found, parse digits
2205
factor = int(match.group(1), 10)
2206
# Add to value so far
2207
value += factor * token.value
2208
# Strip token from string
2209
s = token.regexp.sub("", s, 1)
2210
# Go to found token
2211
found_token = token
2212
# Set valid next tokens
2213
followers = found_token.followers
2214
break
2215
else:
2216
# No currently valid tokens were found
2217
raise ValueError("Invalid RFC 3339 duration")
2218
# End token found
2219
return value
2220
2221
2096
2222
def string_to_delta(interval):
2097
2223
"""Parse a string and return a datetime.timedelta
2098
2224
2109
2235
>>> string_to_delta('5m 30s')
2110
2236
datetime.timedelta(0, 330)
2111
2237
"""
2238
2239
try:
2240
return rfc3339_duration_to_delta(interval)
2241
except ValueError:
2242
pass
2243
2112
2244
timevalue = datetime.timedelta(0)
2113
2245
for s in interval.split():
2114
2246
try:
2127
2259
else:
2128
2260
raise ValueError("Unknown suffix {0!r}"
2129
2261
.format(suffix))
2130
except (ValueError, IndexError) as e:
2262
except IndexError as e:
2131
2263
raise ValueError(*(e.args))
2132
2264
timevalue += delta
2133
2265
return timevalue
2177
2309
help="Run self-test")
2178
2310
parser.add_argument("--debug", action="store_true",
2179
2311
help="Debug mode; run in foreground and log"
2180
" to terminal")
2312
" to terminal", default=None)
2181
2313
parser.add_argument("--debuglevel", metavar="LEVEL",
2182
2314
help="Debug level for stdout output")
2183
2315
parser.add_argument("--priority", help="GnuTLS"
2190
2322
" files")
2191
2323
parser.add_argument("--no-dbus", action="store_false",
2192
2324
dest="use_dbus", help="Do not provide D-Bus"
2193
" system bus interface")
2325
" system bus interface", default=None)
2194
2326
parser.add_argument("--no-ipv6", action="store_false",
2195
dest="use_ipv6", help="Do not use IPv6")
2327
dest="use_ipv6", help="Do not use IPv6",
2328
default=None)
2196
2329
parser.add_argument("--no-restore", action="store_false",
2197
2330
dest="restore", help="Do not restore stored"
2198
" state")
2331
" state", default=None)
2199
2332
parser.add_argument("--socket", type=int,
2200
2333
help="Specify a file descriptor to a network"
2201
2334
" socket to use instead of creating one")
2202
2335
parser.add_argument("--statedir", metavar="DIR",
2203
2336
help="Directory to save/restore state in")
2337
parser.add_argument("--foreground", action="store_true",
2338
help="Run in foreground", default=None)
2204
2339
2205
2340
options = parser.parse_args()
2206
2341
2215
2350
"port": "",
2216
2351
"debug": "False",
2217
2352
"priority":
2218
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2353
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2219
2354
"servicename": "Mandos",
2220
2355
"use_dbus": "True",
2221
2356
"use_ipv6": "True",
2222
2357
"debuglevel": "",
2223
2358
"restore": "True",
2224
2359
"socket": "",
2225
"statedir": "/var/lib/mandos"
2360
"statedir": "/var/lib/mandos",
2361
"foreground": "False",
2226
2362
}
2227
2363
2228
2364
# Parse config file for server-global settings
2233
2369
# Convert the SafeConfigParser object to a dict
2234
2370
server_settings = server_config.defaults()
2235
2371
# Use the appropriate methods on the non-string config options
2236
for option in ("debug", "use_dbus", "use_ipv6"):
2372
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2237
2373
server_settings[option] = server_config.getboolean("DEFAULT",
2238
2374
option)
2239
2375
if server_settings["port"]:
2255
2391
for option in ("interface", "address", "port", "debug",
2256
2392
"priority", "servicename", "configdir",
2257
2393
"use_dbus", "use_ipv6", "debuglevel", "restore",
2258
"statedir", "socket"):
2394
"statedir", "socket", "foreground"):
2259
2395
value = getattr(options, option)
2260
2396
if value is not None:
2261
2397
server_settings[option] = value
2264
2400
for option in server_settings.keys():
2265
2401
if type(server_settings[option]) is str:
2266
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])
2407
# Debug implies foreground
2408
if server_settings["debug"]:
2409
server_settings["foreground"] = True
2267
2410
# Now we have our good server settings in "server_settings"
2268
2411
2269
2412
##################################################################
2275
2418
use_ipv6 = server_settings["use_ipv6"]
2276
2419
stored_state_path = os.path.join(server_settings["statedir"],
2277
2420
stored_state_file)
2421
foreground = server_settings["foreground"]
2278
2422
2279
2423
if debug:
2280
2424
initlogger(debug, logging.DEBUG)
2312
2456
use_dbus=use_dbus,
2313
2457
socketfd=(server_settings["socket"]
2314
2458
or None))
2315
if not debug:
2316
pidfilename = "/var/run/mandos.pid"
2459
if not foreground:
2460
pidfilename = "/run/mandos.pid"
2461
if not os.path.isdir("/run/."):
2462
pidfilename = "/var/run/mandos.pid"
2463
pidfile = None
2317
2464
try:
2318
2465
pidfile = open(pidfilename, "w")
2319
2466
except IOError as e:
2335
2482
os.setuid(uid)
2336
2483
except OSError as error:
2337
2484
if error.errno != errno.EPERM:
2338
raise error
2485
raise
2339
2486
2340
2487
if debug:
2341
2488
# Enable all possible GnuTLS debugging
2358
2505
os.close(null)
2359
2506
2360
2507
# Need to fork before connecting to D-Bus
2361
if not debug:
2508
if not foreground:
2362
2509
# Close all input and output, do double fork, etc.
2363
2510
daemon()
2364
2511
2404
2551
old_client_settings = {}
2405
2552
clients_data = {}
2406
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
2407
2562
# Get client data and settings from last running state.
2408
2563
if server_settings["restore"]:
2409
2564
try:
2425
2580
2426
2581
with PGPEngine() as pgp:
2427
2582
for client_name, client in clients_data.iteritems():
2583
# Skip removed clients
2584
if client_name not in client_settings:
2585
continue
2586
2428
2587
# Decide which value to use after restoring saved state.
2429
2588
# We have three different values: Old config file,
2430
2589
# new config file, and saved state.
2492
2651
# Create all client objects
2493
2652
for client_name, client in clients_data.iteritems():
2494
2653
tcp_server.clients[client_name] = client_class(
2495
name = client_name, settings = client)
2654
name = client_name, settings = client,
2655
server_settings = server_settings)
2496
2656
2497
2657
if not tcp_server.clients:
2498
2658
logger.warning("No clients defined")
2499
2659
2500
if not debug:
2501
try:
2502
with pidfile:
2503
pid = os.getpid()
2504
pidfile.write(str(pid) + "\n".encode("utf-8"))
2505
del pidfile
2506
except IOError:
2507
logger.error("Could not write to file %r with PID %d",
2508
pidfilename, pid)
2509
except NameError:
2510
# "pidfile" was never created
2511
pass
2660
if not foreground:
2661
if pidfile is not None:
2662
try:
2663
with pidfile:
2664
pid = os.getpid()
2665
pidfile.write(str(pid) + "\n".encode("utf-8"))
2666
except IOError:
2667
logger.error("Could not write to file %r with PID %d",
2668
pidfilename, pid)
2669
del pidfile
2512
2670
del pidfilename
2513
2671
2514
2672
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2583
2741
service.cleanup()
2584
2742
2585
2743
multiprocessing.active_children()
2744
wnull.close()
2586
2745
if not (tcp_server.clients or client_settings):
2587
2746
return
2588
2747
2600
2759
# A list of attributes that can not be pickled
2601
2760
# + secret.
2602
2761
exclude = set(("bus", "changedstate", "secret",
2603
"checker"))
2762
"checker", "server_settings"))
2604
2763
for name, typ in (inspect.getmembers
2605
2764
(dbus.service.Object)):
2606
2765
exclude.add(name)
2634
2793
else:
2635
2794
logger.warning("Could not save persistent state:",
2636
2795
exc_info=e)
2637
raise e
2796
raise
2638
2797
2639
2798
# Delete all clients, and settings from config
2640
2799
while tcp_server.clients:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0