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 316
- compare with another revision
- download diff
- download tarball
- view history from revision 316
- Committer: Teddy Hogeborn
- Date: 2014-06-06 02:29:14 UTC
- Revision ID: teddy@recompile.se-20140606022914-qc2q0bg0rtus8s2g
Tags: version-1.6.5-3
* debian/changelog (1.6.5-3): New entry.
- files added:
- debian/upstream
- 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-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.5"
93
92
stored_state_file = "clients.pickle"
94
93
95
94
logger = logging.getLogger()
96
syslogger = (logging.handlers.SysLogHandler
97
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
98
address = str("/dev/log")))
95
syslogger = None
99
96
100
97
try:
101
98
if_nametoindex = (ctypes.cdll.LoadLibrary
117
114
def initlogger(debug, level=logging.WARNING):
118
115
"""init logger and add loglevel"""
119
116
117
syslogger = (logging.handlers.SysLogHandler
118
(facility =
119
logging.handlers.SysLogHandler.LOG_DAEMON,
120
address = str("/dev/log")))
120
121
syslogger.setFormatter(logging.Formatter
121
122
('Mandos [%(process)d]: %(levelname)s:'
122
123
' %(message)s'))
140
141
class PGPEngine(object):
141
142
"""A simple class for OpenPGP symmetric encryption & decryption"""
142
143
def __init__(self):
143
self.gnupg = GnuPGInterface.GnuPG()
144
144
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'])
145
self.gnupgargs = ['--batch',
146
'--home', self.tempdir,
147
'--force-mdc',
148
'--quiet',
149
'--no-use-agent']
151
150
152
151
def __enter__(self):
153
152
return self
175
174
def password_encode(self, password):
176
175
# Passphrase can not be empty and can not contain newlines or
177
176
# NUL bytes. So we prefix it and hex encode it.
178
return b"mandos" + binascii.hexlify(password)
177
encoded = b"mandos" + binascii.hexlify(password)
178
if len(encoded) > 2048:
179
# GnuPG can't handle long passwords, so encode differently
180
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
181
.replace(b"\n", b"\\n")
182
.replace(b"\0", b"\\x00"))
183
return encoded
179
184
180
185
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
186
passphrase = self.password_encode(password)
187
with tempfile.NamedTemporaryFile(dir=self.tempdir
188
) as passfile:
189
passfile.write(passphrase)
190
passfile.flush()
191
proc = subprocess.Popen(['gpg', '--symmetric',
192
'--passphrase-file',
193
passfile.name]
194
+ self.gnupgargs,
195
stdin = subprocess.PIPE,
196
stdout = subprocess.PIPE,
197
stderr = subprocess.PIPE)
198
ciphertext, err = proc.communicate(input = data)
199
if proc.returncode != 0:
200
raise PGPError(err)
195
201
return ciphertext
196
202
197
203
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
204
passphrase = self.password_encode(password)
205
with tempfile.NamedTemporaryFile(dir = self.tempdir
206
) as passfile:
207
passfile.write(passphrase)
208
passfile.flush()
209
proc = subprocess.Popen(['gpg', '--decrypt',
210
'--passphrase-file',
211
passfile.name]
212
+ self.gnupgargs,
213
stdin = subprocess.PIPE,
214
stdout = subprocess.PIPE,
215
stderr = subprocess.PIPE)
216
decrypted_plaintext, err = proc.communicate(input
217
= data)
218
if proc.returncode != 0:
219
raise PGPError(err)
212
220
return decrypted_plaintext
213
221
214
222
234
242
Used to optionally bind to the specified interface.
235
243
name: string; Example: 'Mandos'
236
244
type: string; Example: '_mandos._tcp'.
237
See <http://www.dns-sd.org/ServiceTypes.html>
245
See <https://www.iana.org/assignments/service-names-port-numbers>
238
246
port: integer; what port to announce
239
247
TXT: list of strings; TXT record for the service
240
248
domain: string; Domain to publish on, default to .local if empty.
440
448
runtime_expansions: Allowed attributes for runtime expansion.
441
449
expires: datetime.datetime(); time (UTC) when a client will be
442
450
disabled, or None
451
server_settings: The server_settings dict from main()
443
452
"""
444
453
445
454
runtime_expansions = ("approval_delay", "approval_duration",
520
529
521
530
return settings
522
531
523
def __init__(self, settings, name = None):
532
def __init__(self, settings, name = None, server_settings=None):
524
533
self.name = name
534
if server_settings is None:
535
server_settings = {}
536
self.server_settings = server_settings
525
537
# adding all client settings
526
538
for setting, value in settings.iteritems():
527
539
setattr(self, setting, value)
680
692
# If a checker exists, make sure it is not a zombie
681
693
try:
682
694
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
695
except AttributeError:
696
pass
697
except OSError as error:
698
if error.errno != errno.ECHILD:
699
raise
687
700
else:
688
701
if pid:
689
702
logger.warning("Checker was a zombie")
711
724
# in normal mode, that is already done by daemon(),
712
725
# and in debug mode we don't want to. (Stdin is
713
726
# always replaced by /dev/null.)
727
# The exception is when not debugging but nevertheless
728
# running in the foreground; use the previously
729
# created wnull.
730
popen_args = {}
731
if (not self.server_settings["debug"]
732
and self.server_settings["foreground"]):
733
popen_args.update({"stdout": wnull,
734
"stderr": wnull })
714
735
self.checker = subprocess.Popen(command,
715
736
close_fds=True,
716
shell=True, cwd="/")
737
shell=True, cwd="/",
738
**popen_args)
717
739
except OSError as error:
718
740
logger.error("Failed to start subprocess",
719
741
exc_info=error)
914
936
# The byte_arrays option is not supported yet on
915
937
# signatures other than "ay".
916
938
if prop._dbus_signature != "ay":
917
raise ValueError
939
raise ValueError("Byte arrays not supported for non-"
940
"'ay' signature {0!r}"
941
.format(prop._dbus_signature))
918
942
value = dbus.ByteArray(b''.join(chr(byte)
919
943
for byte in value))
920
944
prop(value)
1078
1102
interface_names.add(alt_interface)
1079
1103
# Is this a D-Bus signal?
1080
1104
if getattr(attribute, "_dbus_is_signal", False):
1081
# Extract the original non-method function by
1082
# black magic
1105
# Extract the original non-method undecorated
1106
# function by black magic
1083
1107
nonmethod_func = (dict(
1084
1108
zip(attribute.func_code.co_freevars,
1085
1109
attribute.__closure__))["func"]
1328
1352
*args, **kwargs)
1329
1353
1330
1354
def start_checker(self, *args, **kwargs):
1331
old_checker = self.checker
1332
if self.checker is not None:
1333
old_checker_pid = self.checker.pid
1334
else:
1335
old_checker_pid = None
1355
old_checker_pid = getattr(self.checker, "pid", None)
1336
1356
r = Client.start_checker(self, *args, **kwargs)
1337
1357
# Only if new checker process was started
1338
1358
if (self.checker is not None
1683
1703
logger.debug("Protocol version: %r", line)
1684
1704
try:
1685
1705
if int(line.strip().split()[0]) > 1:
1686
raise RuntimeError
1706
raise RuntimeError(line)
1687
1707
except (ValueError, IndexError, RuntimeError) as error:
1688
1708
logger.error("Unknown protocol version: %s", error)
1689
1709
return
1896
1916
1897
1917
def add_pipe(self, parent_pipe, proc):
1898
1918
"""Dummy function; override as necessary"""
1899
raise NotImplementedError
1919
raise NotImplementedError()
1900
1920
1901
1921
1902
1922
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1978
1998
if self.address_family == socket.AF_INET6:
1979
1999
any_address = "::" # in6addr_any
1980
2000
else:
1981
any_address = socket.INADDR_ANY
2001
any_address = "0.0.0.0" # INADDR_ANY
1982
2002
self.server_address = (any_address,
1983
2003
self.server_address[1])
1984
2004
elif not self.server_address[1]:
2239
2259
else:
2240
2260
raise ValueError("Unknown suffix {0!r}"
2241
2261
.format(suffix))
2242
except (ValueError, IndexError) as e:
2262
except IndexError as e:
2243
2263
raise ValueError(*(e.args))
2244
2264
timevalue += delta
2245
2265
return timevalue
2289
2309
help="Run self-test")
2290
2310
parser.add_argument("--debug", action="store_true",
2291
2311
help="Debug mode; run in foreground and log"
2292
" to terminal")
2312
" to terminal", default=None)
2293
2313
parser.add_argument("--debuglevel", metavar="LEVEL",
2294
2314
help="Debug level for stdout output")
2295
2315
parser.add_argument("--priority", help="GnuTLS"
2302
2322
" files")
2303
2323
parser.add_argument("--no-dbus", action="store_false",
2304
2324
dest="use_dbus", help="Do not provide D-Bus"
2305
" system bus interface")
2325
" system bus interface", default=None)
2306
2326
parser.add_argument("--no-ipv6", action="store_false",
2307
dest="use_ipv6", help="Do not use IPv6")
2327
dest="use_ipv6", help="Do not use IPv6",
2328
default=None)
2308
2329
parser.add_argument("--no-restore", action="store_false",
2309
2330
dest="restore", help="Do not restore stored"
2310
" state")
2331
" state", default=None)
2311
2332
parser.add_argument("--socket", type=int,
2312
2333
help="Specify a file descriptor to a network"
2313
2334
" socket to use instead of creating one")
2314
2335
parser.add_argument("--statedir", metavar="DIR",
2315
2336
help="Directory to save/restore state in")
2316
2337
parser.add_argument("--foreground", action="store_true",
2317
help="Run in foreground")
2338
help="Run in foreground", default=None)
2318
2339
2319
2340
options = parser.parse_args()
2320
2341
2321
2342
if options.check:
2322
2343
import doctest
2323
doctest.testmod()
2324
sys.exit()
2344
fail_count, test_count = doctest.testmod()
2345
sys.exit(os.EX_OK if fail_count == 0 else 1)
2325
2346
2326
2347
# Default values for config file for server-global settings
2327
2348
server_defaults = { "interface": "",
2329
2350
"port": "",
2330
2351
"debug": "False",
2331
2352
"priority":
2332
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2353
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2333
2354
"servicename": "Mandos",
2334
2355
"use_dbus": "True",
2335
2356
"use_ipv6": "True",
2379
2400
for option in server_settings.keys():
2380
2401
if type(server_settings[option]) is str:
2381
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])
2382
2407
# Debug implies foreground
2383
2408
if server_settings["debug"]:
2384
2409
server_settings["foreground"] = True
2432
2457
socketfd=(server_settings["socket"]
2433
2458
or None))
2434
2459
if not foreground:
2435
pidfilename = "/var/run/mandos.pid"
2460
pidfilename = "/run/mandos.pid"
2461
if not os.path.isdir("/run/."):
2462
pidfilename = "/var/run/mandos.pid"
2436
2463
pidfile = None
2437
2464
try:
2438
2465
pidfile = open(pidfilename, "w")
2455
2482
os.setuid(uid)
2456
2483
except OSError as error:
2457
2484
if error.errno != errno.EPERM:
2458
raise error
2485
raise
2459
2486
2460
2487
if debug:
2461
2488
# Enable all possible GnuTLS debugging
2524
2551
old_client_settings = {}
2525
2552
clients_data = {}
2526
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
2527
2562
# Get client data and settings from last running state.
2528
2563
if server_settings["restore"]:
2529
2564
try:
2545
2580
2546
2581
with PGPEngine() as pgp:
2547
2582
for client_name, client in clients_data.iteritems():
2583
# Skip removed clients
2584
if client_name not in client_settings:
2585
continue
2586
2548
2587
# Decide which value to use after restoring saved state.
2549
2588
# We have three different values: Old config file,
2550
2589
# new config file, and saved state.
2612
2651
# Create all client objects
2613
2652
for client_name, client in clients_data.iteritems():
2614
2653
tcp_server.clients[client_name] = client_class(
2615
name = client_name, settings = client)
2654
name = client_name, settings = client,
2655
server_settings = server_settings)
2616
2656
2617
2657
if not tcp_server.clients:
2618
2658
logger.warning("No clients defined")
2701
2741
service.cleanup()
2702
2742
2703
2743
multiprocessing.active_children()
2744
wnull.close()
2704
2745
if not (tcp_server.clients or client_settings):
2705
2746
return
2706
2747
2718
2759
# A list of attributes that can not be pickled
2719
2760
# + secret.
2720
2761
exclude = set(("bus", "changedstate", "secret",
2721
"checker"))
2762
"checker", "server_settings"))
2722
2763
for name, typ in (inspect.getmembers
2723
2764
(dbus.service.Object)):
2724
2765
exclude.add(name)
2752
2793
else:
2753
2794
logger.warning("Could not save persistent state:",
2754
2795
exc_info=e)
2755
raise e
2796
raise
2756
2797
2757
2798
# Delete all clients, and settings from config
2758
2799
while tcp_server.clients:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0