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
- browse files at revision 742
- compare with another revision
- download diff
- download tarball
- view history from revision 742
- Committer: Teddy Hogeborn
- Date: 2015-03-10 18:03:38 UTC
- Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.
If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default. The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.
There is a "PFS" priority string specifier, but we can't use it because:
1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
enables a lot more algorithms than "SECURE256".
2. It is only available since GnuTLS 3.2.4.
Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.
If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default. The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.
There is a "PFS" priority string specifier, but we can't use it because:
1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
enables a lot more algorithms than "SECURE256".
2. It is only available since GnuTLS 3.2.4.
Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.
- files added:
- debian/mandos-client.examples
- debian/upstream
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
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
34
34
from __future__ import (division, absolute_import, print_function,
35
35
unicode_literals)
36
36
37
from future_builtins import *
38
37
39
import SocketServer as socketserver
38
40
import socket
39
41
import argparse
65
67
import types
66
68
import binascii
67
69
import tempfile
70
import itertools
71
import collections
68
72
69
73
import dbus
70
74
import dbus.service
75
79
import ctypes.util
76
80
import xml.dom.minidom
77
81
import inspect
78
import GnuPGInterface
79
82
80
83
try:
81
84
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
85
88
except ImportError:
86
89
SO_BINDTODEVICE = None
87
90
88
version = "1.5.1"
91
if sys.version_info.major == 2:
92
str = unicode
93
94
version = "1.6.9"
89
95
stored_state_file = "clients.pickle"
90
96
91
97
logger = logging.getLogger()
92
syslogger = (logging.handlers.SysLogHandler
93
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
address = str("/dev/log")))
98
syslogger = None
95
99
96
100
try:
97
101
if_nametoindex = (ctypes.cdll.LoadLibrary
103
107
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
104
108
with contextlib.closing(socket.socket()) as s:
105
109
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
106
struct.pack(str("16s16x"),
107
interface))
108
interface_index = struct.unpack(str("I"),
109
ifreq[16:20])[0]
110
struct.pack(b"16s16x", interface))
111
interface_index = struct.unpack("I", ifreq[16:20])[0]
110
112
return interface_index
111
113
112
114
113
115
def initlogger(debug, level=logging.WARNING):
114
116
"""init logger and add loglevel"""
115
117
118
global syslogger
119
syslogger = (logging.handlers.SysLogHandler
120
(facility =
121
logging.handlers.SysLogHandler.LOG_DAEMON,
122
address = "/dev/log"))
116
123
syslogger.setFormatter(logging.Formatter
117
124
('Mandos [%(process)d]: %(levelname)s:'
118
125
' %(message)s'))
136
143
class PGPEngine(object):
137
144
"""A simple class for OpenPGP symmetric encryption & decryption"""
138
145
def __init__(self):
139
self.gnupg = GnuPGInterface.GnuPG()
140
146
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
141
self.gnupg = GnuPGInterface.GnuPG()
142
self.gnupg.options.meta_interactive = False
143
self.gnupg.options.homedir = self.tempdir
144
self.gnupg.options.extra_args.extend(['--force-mdc',
145
'--quiet',
146
'--no-use-agent'])
147
self.gnupgargs = ['--batch',
148
'--home', self.tempdir,
149
'--force-mdc',
150
'--quiet',
151
'--no-use-agent']
147
152
148
153
def __enter__(self):
149
154
return self
150
155
151
def __exit__ (self, exc_type, exc_value, traceback):
156
def __exit__(self, exc_type, exc_value, traceback):
152
157
self._cleanup()
153
158
return False
154
159
171
176
def password_encode(self, password):
172
177
# Passphrase can not be empty and can not contain newlines or
173
178
# NUL bytes. So we prefix it and hex encode it.
174
return b"mandos" + binascii.hexlify(password)
179
encoded = b"mandos" + binascii.hexlify(password)
180
if len(encoded) > 2048:
181
# GnuPG can't handle long passwords, so encode differently
182
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
183
.replace(b"\n", b"\\n")
184
.replace(b"\0", b"\\x00"))
185
return encoded
175
186
176
187
def encrypt(self, data, password):
177
self.gnupg.passphrase = self.password_encode(password)
178
with open(os.devnull) as devnull:
179
try:
180
proc = self.gnupg.run(['--symmetric'],
181
create_fhs=['stdin', 'stdout'],
182
attach_fhs={'stderr': devnull})
183
with contextlib.closing(proc.handles['stdin']) as f:
184
f.write(data)
185
with contextlib.closing(proc.handles['stdout']) as f:
186
ciphertext = f.read()
187
proc.wait()
188
except IOError as e:
189
raise PGPError(e)
190
self.gnupg.passphrase = None
188
passphrase = self.password_encode(password)
189
with tempfile.NamedTemporaryFile(dir=self.tempdir
190
) as passfile:
191
passfile.write(passphrase)
192
passfile.flush()
193
proc = subprocess.Popen(['gpg', '--symmetric',
194
'--passphrase-file',
195
passfile.name]
196
+ self.gnupgargs,
197
stdin = subprocess.PIPE,
198
stdout = subprocess.PIPE,
199
stderr = subprocess.PIPE)
200
ciphertext, err = proc.communicate(input = data)
201
if proc.returncode != 0:
202
raise PGPError(err)
191
203
return ciphertext
192
204
193
205
def decrypt(self, data, password):
194
self.gnupg.passphrase = self.password_encode(password)
195
with open(os.devnull) as devnull:
196
try:
197
proc = self.gnupg.run(['--decrypt'],
198
create_fhs=['stdin', 'stdout'],
199
attach_fhs={'stderr': devnull})
200
with contextlib.closing(proc.handles['stdin'] ) as f:
201
f.write(data)
202
with contextlib.closing(proc.handles['stdout']) as f:
203
decrypted_plaintext = f.read()
204
proc.wait()
205
except IOError as e:
206
raise PGPError(e)
207
self.gnupg.passphrase = None
206
passphrase = self.password_encode(password)
207
with tempfile.NamedTemporaryFile(dir = self.tempdir
208
) as passfile:
209
passfile.write(passphrase)
210
passfile.flush()
211
proc = subprocess.Popen(['gpg', '--decrypt',
212
'--passphrase-file',
213
passfile.name]
214
+ self.gnupgargs,
215
stdin = subprocess.PIPE,
216
stdout = subprocess.PIPE,
217
stderr = subprocess.PIPE)
218
decrypted_plaintext, err = proc.communicate(input
219
= data)
220
if proc.returncode != 0:
221
raise PGPError(err)
208
222
return decrypted_plaintext
209
223
210
224
211
212
225
class AvahiError(Exception):
213
226
def __init__(self, value, *args, **kwargs):
214
227
self.value = value
215
super(AvahiError, self).__init__(value, *args, **kwargs)
216
def __unicode__(self):
217
return unicode(repr(self.value))
228
return super(AvahiError, self).__init__(value, *args,
229
**kwargs)
218
230
219
231
class AvahiServiceError(AvahiError):
220
232
pass
231
243
Used to optionally bind to the specified interface.
232
244
name: string; Example: 'Mandos'
233
245
type: string; Example: '_mandos._tcp'.
234
See <http://www.dns-sd.org/ServiceTypes.html>
246
See <https://www.iana.org/assignments/service-names-port-numbers>
235
247
port: integer; what port to announce
236
248
TXT: list of strings; TXT record for the service
237
249
domain: string; Domain to publish on, default to .local if empty.
243
255
server: D-Bus Server
244
256
bus: dbus.SystemBus()
245
257
"""
258
246
259
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
247
260
servicetype = None, port = None, TXT = None,
248
261
domain = "", host = "", max_renames = 32768,
261
274
self.server = None
262
275
self.bus = bus
263
276
self.entry_group_state_changed_match = None
264
def rename(self):
277
278
def rename(self, remove=True):
265
279
"""Derived from the Avahi example code"""
266
280
if self.rename_count >= self.max_renames:
267
281
logger.critical("No suitable Zeroconf service name found"
268
282
" after %i retries, exiting.",
269
283
self.rename_count)
270
284
raise AvahiServiceError("Too many renames")
271
self.name = unicode(self.server
272
.GetAlternativeServiceName(self.name))
285
self.name = str(self.server
286
.GetAlternativeServiceName(self.name))
287
self.rename_count += 1
273
288
logger.info("Changing Zeroconf service name to %r ...",
274
289
self.name)
275
self.remove()
290
if remove:
291
self.remove()
276
292
try:
277
293
self.add()
278
294
except dbus.exceptions.DBusException as error:
279
logger.critical("DBusException: %s", error)
280
self.cleanup()
281
os._exit(1)
282
self.rename_count += 1
295
if (error.get_dbus_name()
296
== "org.freedesktop.Avahi.CollisionError"):
297
logger.info("Local Zeroconf service name collision.")
298
return self.rename(remove=False)
299
else:
300
logger.critical("D-Bus Exception", exc_info=error)
301
self.cleanup()
302
os._exit(1)
303
283
304
def remove(self):
284
305
"""Derived from the Avahi example code"""
285
306
if self.entry_group_state_changed_match is not None:
287
308
self.entry_group_state_changed_match = None
288
309
if self.group is not None:
289
310
self.group.Reset()
311
290
312
def add(self):
291
313
"""Derived from the Avahi example code"""
292
314
self.remove()
309
331
dbus.UInt16(self.port),
310
332
avahi.string_array_to_txt_array(self.TXT))
311
333
self.group.Commit()
334
312
335
def entry_group_state_changed(self, state, error):
313
336
"""Derived from the Avahi example code"""
314
337
logger.debug("Avahi entry group state change: %i", state)
320
343
self.rename()
321
344
elif state == avahi.ENTRY_GROUP_FAILURE:
322
345
logger.critical("Avahi: Error in group state changed %s",
323
unicode(error))
324
raise AvahiGroupError("State changed: %s"
325
% unicode(error))
346
str(error))
347
raise AvahiGroupError("State changed: {!s}"
348
.format(error))
349
326
350
def cleanup(self):
327
351
"""Derived from the Avahi example code"""
328
352
if self.group is not None:
333
357
pass
334
358
self.group = None
335
359
self.remove()
360
336
361
def server_state_changed(self, state, error=None):
337
362
"""Derived from the Avahi example code"""
338
363
logger.debug("Avahi server state change: %i", state)
357
382
logger.debug("Unknown state: %r", state)
358
383
else:
359
384
logger.debug("Unknown state: %r: %r", state, error)
385
360
386
def activate(self):
361
387
"""Derived from the Avahi example code"""
362
388
if self.server is None:
369
395
self.server_state_changed)
370
396
self.server_state_changed(self.server.GetState())
371
397
398
372
399
class AvahiServiceToSyslog(AvahiService):
373
def rename(self):
400
def rename(self, *args, **kwargs):
374
401
"""Add the new name to the syslog messages"""
375
ret = AvahiService.rename(self)
402
ret = AvahiService.rename(self, *args, **kwargs)
376
403
syslogger.setFormatter(logging.Formatter
377
('Mandos (%s) [%%(process)d]:'
378
' %%(levelname)s: %%(message)s'
379
% self.name))
404
('Mandos ({}) [%(process)d]:'
405
' %(levelname)s: %(message)s'
406
.format(self.name)))
380
407
return ret
381
408
382
def timedelta_to_milliseconds(td):
383
"Convert a datetime.timedelta() to milliseconds"
384
return ((td.days * 24 * 60 * 60 * 1000)
385
+ (td.seconds * 1000)
386
+ (td.microseconds // 1000))
387
409
388
410
class Client(object):
389
411
"""A representation of a client host served by this server.
390
412
415
437
last_checked_ok: datetime.datetime(); (UTC) or None
416
438
last_checker_status: integer between 0 and 255 reflecting exit
417
439
status of last checker. -1 reflects crashed
418
checker, or None.
440
checker, -2 means no checker completed yet.
419
441
last_enabled: datetime.datetime(); (UTC) or None
420
442
name: string; from the config file, used in log messages and
421
443
D-Bus identifiers
426
448
runtime_expansions: Allowed attributes for runtime expansion.
427
449
expires: datetime.datetime(); time (UTC) when a client will be
428
450
disabled, or None
451
server_settings: The server_settings dict from main()
429
452
"""
430
453
431
454
runtime_expansions = ("approval_delay", "approval_duration",
432
"created", "enabled", "fingerprint",
433
"host", "interval", "last_checked_ok",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
434
458
"last_enabled", "name", "timeout")
435
client_defaults = { "timeout": "5m",
436
"extended_timeout": "15m",
437
"interval": "2m",
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
461
"interval": "PT2M",
438
462
"checker": "fping -q -- %%(host)s",
439
463
"host": "",
440
"approval_delay": "0s",
441
"approval_duration": "1s",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
442
466
"approved_by_default": "True",
443
467
"enabled": "True",
444
468
}
445
469
446
def timeout_milliseconds(self):
447
"Return the 'timeout' attribute in milliseconds"
448
return timedelta_to_milliseconds(self.timeout)
449
450
def extended_timeout_milliseconds(self):
451
"Return the 'extended_timeout' attribute in milliseconds"
452
return timedelta_to_milliseconds(self.extended_timeout)
453
454
def interval_milliseconds(self):
455
"Return the 'interval' attribute in milliseconds"
456
return timedelta_to_milliseconds(self.interval)
457
458
def approval_delay_milliseconds(self):
459
return timedelta_to_milliseconds(self.approval_delay)
460
461
470
@staticmethod
462
471
def config_parser(config):
463
472
"""Construct a new dict of client settings of this form:
478
487
client["enabled"] = config.getboolean(client_name,
479
488
"enabled")
480
489
490
# Uppercase and remove spaces from fingerprint for later
491
# comparison purposes with return value from the
492
# fingerprint() function
481
493
client["fingerprint"] = (section["fingerprint"].upper()
482
494
.replace(" ", ""))
483
495
if "secret" in section:
488
500
"rb") as secfile:
489
501
client["secret"] = secfile.read()
490
502
else:
491
raise TypeError("No secret or secfile for section %s"
492
% section)
503
raise TypeError("No secret or secfile for section {}"
504
.format(section))
493
505
client["timeout"] = string_to_delta(section["timeout"])
494
506
client["extended_timeout"] = string_to_delta(
495
507
section["extended_timeout"])
501
513
client["checker_command"] = section["checker"]
502
514
client["last_approval_request"] = None
503
515
client["last_checked_ok"] = None
504
client["last_checker_status"] = None
516
client["last_checker_status"] = -2
505
517
506
518
return settings
507
508
509
def __init__(self, settings, name = None):
510
"""Note: the 'checker' key in 'config' sets the
511
'checker_command' attribute and *not* the 'checker'
512
attribute."""
519
520
def __init__(self, settings, name = None, server_settings=None):
513
521
self.name = name
522
if server_settings is None:
523
server_settings = {}
524
self.server_settings = server_settings
514
525
# adding all client settings
515
for setting, value in settings.iteritems():
526
for setting, value in settings.items():
516
527
setattr(self, setting, value)
517
528
518
529
if self.enabled:
524
535
else:
525
536
self.last_enabled = None
526
537
self.expires = None
527
538
528
539
logger.debug("Creating client %r", self.name)
529
# Uppercase and remove spaces from fingerprint for later
530
# comparison purposes with return value from the fingerprint()
531
# function
532
540
logger.debug(" Fingerprint: %s", self.fingerprint)
533
541
self.created = settings.get("created",
534
542
datetime.datetime.utcnow())
535
543
536
544
# attributes specific for this server instance
537
545
self.checker = None
538
546
self.checker_initiator_tag = None
566
574
if getattr(self, "enabled", False):
567
575
# Already enabled
568
576
return
569
self.send_changedstate()
570
577
self.expires = datetime.datetime.utcnow() + self.timeout
571
578
self.enabled = True
572
579
self.last_enabled = datetime.datetime.utcnow()
573
580
self.init_checker()
581
self.send_changedstate()
574
582
575
583
def disable(self, quiet=True):
576
584
"""Disable this client."""
577
585
if not getattr(self, "enabled", False):
578
586
return False
579
587
if not quiet:
580
self.send_changedstate()
581
if not quiet:
582
588
logger.info("Disabling client %s", self.name)
583
if getattr(self, "disable_initiator_tag", False):
589
if getattr(self, "disable_initiator_tag", None) is not None:
584
590
gobject.source_remove(self.disable_initiator_tag)
585
591
self.disable_initiator_tag = None
586
592
self.expires = None
587
if getattr(self, "checker_initiator_tag", False):
593
if getattr(self, "checker_initiator_tag", None) is not None:
588
594
gobject.source_remove(self.checker_initiator_tag)
589
595
self.checker_initiator_tag = None
590
596
self.stop_checker()
591
597
self.enabled = False
598
if not quiet:
599
self.send_changedstate()
592
600
# Do not run this again if called by a gobject.timeout_add
593
601
return False
594
602
598
606
def init_checker(self):
599
607
# Schedule a new checker to be started an 'interval' from now,
600
608
# and every interval from then on.
609
if self.checker_initiator_tag is not None:
610
gobject.source_remove(self.checker_initiator_tag)
601
611
self.checker_initiator_tag = (gobject.timeout_add
602
(self.interval_milliseconds(),
612
(int(self.interval
613
.total_seconds() * 1000),
603
614
self.start_checker))
604
615
# Schedule a disable() when 'timeout' has passed
616
if self.disable_initiator_tag is not None:
617
gobject.source_remove(self.disable_initiator_tag)
605
618
self.disable_initiator_tag = (gobject.timeout_add
606
(self.timeout_milliseconds(),
607
self.disable))
619
(int(self.timeout
620
.total_seconds() * 1000),
621
self.disable))
608
622
# Also start a new checker *right now*.
609
623
self.start_checker()
610
624
626
640
logger.warning("Checker for %(name)s crashed?",
627
641
vars(self))
628
642
629
def checked_ok(self, timeout=None):
630
"""Bump up the timeout for this client.
631
632
This should only be called when the client has been seen,
633
alive and well.
634
"""
643
def checked_ok(self):
644
"""Assert that the client has been seen, alive and well."""
645
self.last_checked_ok = datetime.datetime.utcnow()
646
self.last_checker_status = 0
647
self.bump_timeout()
648
649
def bump_timeout(self, timeout=None):
650
"""Bump up the timeout for this client."""
635
651
if timeout is None:
636
652
timeout = self.timeout
637
self.last_checked_ok = datetime.datetime.utcnow()
638
653
if self.disable_initiator_tag is not None:
639
654
gobject.source_remove(self.disable_initiator_tag)
655
self.disable_initiator_tag = None
640
656
if getattr(self, "enabled", False):
641
657
self.disable_initiator_tag = (gobject.timeout_add
642
(timedelta_to_milliseconds
643
(timeout), self.disable))
658
(int(timeout.total_seconds()
659
* 1000), self.disable))
644
660
self.expires = datetime.datetime.utcnow() + timeout
645
661
646
662
def need_approval(self):
652
668
If a checker already exists, leave it running and do
653
669
nothing."""
654
670
# The reason for not killing a running checker is that if we
655
# did that, then if a checker (for some reason) started
656
# running slowly and taking more than 'interval' time, the
657
# client would inevitably timeout, since no checker would get
658
# a chance to run to completion. If we instead leave running
671
# did that, and if a checker (for some reason) started running
672
# slowly and taking more than 'interval' time, then the client
673
# would inevitably timeout, since no checker would get a
674
# chance to run to completion. If we instead leave running
659
675
# checkers alone, the checker would have to take more time
660
676
# than 'timeout' for the client to be disabled, which is as it
661
677
# should be.
663
679
# If a checker exists, make sure it is not a zombie
664
680
try:
665
681
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
666
except (AttributeError, OSError) as error:
667
if (isinstance(error, OSError)
668
and error.errno != errno.ECHILD):
669
raise error
682
except AttributeError:
683
pass
684
except OSError as error:
685
if error.errno != errno.ECHILD:
686
raise
670
687
else:
671
688
if pid:
672
689
logger.warning("Checker was a zombie")
675
692
self.current_checker_command)
676
693
# Start a new checker if needed
677
694
if self.checker is None:
695
# Escape attributes for the shell
696
escaped_attrs = { attr:
697
re.escape(str(getattr(self, attr)))
698
for attr in self.runtime_expansions }
678
699
try:
679
# In case checker_command has exactly one % operator
680
command = self.checker_command % self.host
681
except TypeError:
682
# Escape attributes for the shell
683
escaped_attrs = dict(
684
(attr,
685
re.escape(unicode(str(getattr(self, attr, "")),
686
errors=
687
'replace')))
688
for attr in
689
self.runtime_expansions)
690
691
try:
692
command = self.checker_command % escaped_attrs
693
except TypeError as error:
694
logger.error('Could not format string "%s":'
695
' %s', self.checker_command, error)
696
return True # Try again later
700
command = self.checker_command % escaped_attrs
701
except TypeError as error:
702
logger.error('Could not format string "%s"',
703
self.checker_command, exc_info=error)
704
return True # Try again later
697
705
self.current_checker_command = command
698
706
try:
699
707
logger.info("Starting checker %r for %s",
702
710
# in normal mode, that is already done by daemon(),
703
711
# and in debug mode we don't want to. (Stdin is
704
712
# always replaced by /dev/null.)
713
# The exception is when not debugging but nevertheless
714
# running in the foreground; use the previously
715
# created wnull.
716
popen_args = {}
717
if (not self.server_settings["debug"]
718
and self.server_settings["foreground"]):
719
popen_args.update({"stdout": wnull,
720
"stderr": wnull })
705
721
self.checker = subprocess.Popen(command,
706
722
close_fds=True,
707
shell=True, cwd="/")
708
self.checker_callback_tag = (gobject.child_watch_add
709
(self.checker.pid,
710
self.checker_callback,
711
data=command))
712
# The checker may have completed before the gobject
713
# watch was added. Check for this.
723
shell=True, cwd="/",
724
**popen_args)
725
except OSError as error:
726
logger.error("Failed to start subprocess",
727
exc_info=error)
728
return True
729
self.checker_callback_tag = (gobject.child_watch_add
730
(self.checker.pid,
731
self.checker_callback,
732
data=command))
733
# The checker may have completed before the gobject
734
# watch was added. Check for this.
735
try:
714
736
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
715
if pid:
716
gobject.source_remove(self.checker_callback_tag)
717
self.checker_callback(pid, status, command)
718
737
except OSError as error:
719
logger.error("Failed to start subprocess: %s",
720
error)
738
if error.errno == errno.ECHILD:
739
# This should never happen
740
logger.error("Child process vanished",
741
exc_info=error)
742
return True
743
raise
744
if pid:
745
gobject.source_remove(self.checker_callback_tag)
746
self.checker_callback(pid, status, command)
721
747
# Re-run this periodically if run by gobject.timeout_add
722
748
return True
723
749
730
756
return
731
757
logger.debug("Stopping checker for %(name)s", vars(self))
732
758
try:
733
os.kill(self.checker.pid, signal.SIGTERM)
759
self.checker.terminate()
734
760
#time.sleep(0.5)
735
761
#if self.checker.poll() is None:
736
# os.kill(self.checker.pid, signal.SIGKILL)
762
# self.checker.kill()
737
763
except OSError as error:
738
764
if error.errno != errno.ESRCH: # No such process
739
765
raise
756
782
# "Set" method, so we fail early here:
757
783
if byte_arrays and signature != "ay":
758
784
raise ValueError("Byte arrays not supported for non-'ay'"
759
" signature %r" % signature)
785
" signature {!r}".format(signature))
760
786
def decorator(func):
761
787
func._dbus_is_property = True
762
788
func._dbus_interface = dbus_interface
770
796
return decorator
771
797
772
798
799
def dbus_interface_annotations(dbus_interface):
800
"""Decorator for marking functions returning interface annotations
801
802
Usage:
803
804
@dbus_interface_annotations("org.example.Interface")
805
def _foo(self): # Function name does not matter
806
return {"org.freedesktop.DBus.Deprecated": "true",
807
"org.freedesktop.DBus.Property.EmitsChangedSignal":
808
"false"}
809
"""
810
def decorator(func):
811
func._dbus_is_interface = True
812
func._dbus_interface = dbus_interface
813
func._dbus_name = dbus_interface
814
return func
815
return decorator
816
817
818
def dbus_annotations(annotations):
819
"""Decorator to annotate D-Bus methods, signals or properties
820
Usage:
821
822
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
823
"org.freedesktop.DBus.Property."
824
"EmitsChangedSignal": "false"})
825
@dbus_service_property("org.example.Interface", signature="b",
826
access="r")
827
def Property_dbus_property(self):
828
return dbus.Boolean(False)
829
"""
830
def decorator(func):
831
func._dbus_annotations = annotations
832
return func
833
return decorator
834
835
773
836
class DBusPropertyException(dbus.exceptions.DBusException):
774
837
"""A base class for D-Bus property-related exceptions
775
838
"""
776
def __unicode__(self):
777
return unicode(str(self))
778
839
pass
779
840
780
841
class DBusPropertyAccessException(DBusPropertyException):
781
842
"""A property's access permissions disallows an operation.
798
859
"""
799
860
800
861
@staticmethod
801
def _is_dbus_property(obj):
802
return getattr(obj, "_dbus_is_property", False)
862
def _is_dbus_thing(thing):
863
"""Returns a function testing if an attribute is a D-Bus thing
864
865
If called like _is_dbus_thing("method") it returns a function
866
suitable for use as predicate to inspect.getmembers().
867
"""
868
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
869
False)
803
870
804
def _get_all_dbus_properties(self):
871
def _get_all_dbus_things(self, thing):
805
872
"""Returns a generator of (name, attribute) pairs
806
873
"""
807
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
874
return ((getattr(athing.__get__(self), "_dbus_name",
875
name),
876
athing.__get__(self))
808
877
for cls in self.__class__.__mro__
809
for name, prop in
810
inspect.getmembers(cls, self._is_dbus_property))
878
for name, athing in
879
inspect.getmembers(cls,
880
self._is_dbus_thing(thing)))
811
881
812
882
def _get_dbus_property(self, interface_name, property_name):
813
883
"""Returns a bound method if one exists which is a D-Bus
815
885
"""
816
886
for cls in self.__class__.__mro__:
817
887
for name, value in (inspect.getmembers
818
(cls, self._is_dbus_property)):
888
(cls,
889
self._is_dbus_thing("property"))):
819
890
if (value._dbus_name == property_name
820
891
and value._dbus_interface == interface_name):
821
892
return value.__get__(self)
849
920
# The byte_arrays option is not supported yet on
850
921
# signatures other than "ay".
851
922
if prop._dbus_signature != "ay":
852
raise ValueError
923
raise ValueError("Byte arrays not supported for non-"
924
"'ay' signature {!r}"
925
.format(prop._dbus_signature))
853
926
value = dbus.ByteArray(b''.join(chr(byte)
854
927
for byte in value))
855
928
prop(value)
863
936
Note: Will not include properties with access="write".
864
937
"""
865
938
properties = {}
866
for name, prop in self._get_all_dbus_properties():
939
for name, prop in self._get_all_dbus_things("property"):
867
940
if (interface_name
868
941
and interface_name != prop._dbus_interface):
869
942
# Interface non-empty but did not match
879
952
value.variant_level+1)
880
953
return dbus.Dictionary(properties, signature="sv")
881
954
955
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
956
def PropertiesChanged(self, interface_name, changed_properties,
957
invalidated_properties):
958
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
959
standard.
960
"""
961
pass
962
882
963
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
883
964
out_signature="s",
884
965
path_keyword='object_path',
885
966
connection_keyword='connection')
886
967
def Introspect(self, object_path, connection):
887
"""Standard D-Bus method, overloaded to insert property tags.
968
"""Overloading of standard D-Bus method.
969
970
Inserts property tags and interface annotation tags.
888
971
"""
889
972
xmlstring = dbus.service.Object.Introspect(self, object_path,
890
973
connection)
897
980
e.setAttribute("access", prop._dbus_access)
898
981
return e
899
982
for if_tag in document.getElementsByTagName("interface"):
983
# Add property tags
900
984
for tag in (make_tag(document, name, prop)
901
985
for name, prop
902
in self._get_all_dbus_properties()
986
in self._get_all_dbus_things("property")
903
987
if prop._dbus_interface
904
988
== if_tag.getAttribute("name")):
905
989
if_tag.appendChild(tag)
990
# Add annotation tags
991
for typ in ("method", "signal", "property"):
992
for tag in if_tag.getElementsByTagName(typ):
993
annots = dict()
994
for name, prop in (self.
995
_get_all_dbus_things(typ)):
996
if (name == tag.getAttribute("name")
997
and prop._dbus_interface
998
== if_tag.getAttribute("name")):
999
annots.update(getattr
1000
(prop,
1001
"_dbus_annotations",
1002
{}))
1003
for name, value in annots.items():
1004
ann_tag = document.createElement(
1005
"annotation")
1006
ann_tag.setAttribute("name", name)
1007
ann_tag.setAttribute("value", value)
1008
tag.appendChild(ann_tag)
1009
# Add interface annotation tags
1010
for annotation, value in dict(
1011
itertools.chain.from_iterable(
1012
annotations().items()
1013
for name, annotations in
1014
self._get_all_dbus_things("interface")
1015
if name == if_tag.getAttribute("name")
1016
)).items():
1017
ann_tag = document.createElement("annotation")
1018
ann_tag.setAttribute("name", annotation)
1019
ann_tag.setAttribute("value", value)
1020
if_tag.appendChild(ann_tag)
906
1021
# Add the names to the return values for the
907
1022
# "org.freedesktop.DBus.Properties" methods
908
1023
if (if_tag.getAttribute("name")
923
1038
except (AttributeError, xml.dom.DOMException,
924
1039
xml.parsers.expat.ExpatError) as error:
925
1040
logger.error("Failed to override Introspection method",
926
error)
1041
exc_info=error)
927
1042
return xmlstring
928
1043
929
1044
930
def datetime_to_dbus (dt, variant_level=0):
1045
def datetime_to_dbus(dt, variant_level=0):
931
1046
"""Convert a UTC datetime.datetime() to a D-Bus type."""
932
1047
if dt is None:
933
1048
return dbus.String("", variant_level = variant_level)
935
1050
variant_level=variant_level)
936
1051
937
1052
938
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
939
.__metaclass__):
940
"""Applied to an empty subclass of a D-Bus object, this metaclass
941
will add additional D-Bus attributes matching a certain pattern.
1053
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1054
"""A class decorator; applied to a subclass of
1055
dbus.service.Object, it will add alternate D-Bus attributes with
1056
interface names according to the "alt_interface_names" mapping.
1057
Usage:
1058
1059
@alternate_dbus_interfaces({"org.example.Interface":
1060
"net.example.AlternateInterface"})
1061
class SampleDBusObject(dbus.service.Object):
1062
@dbus.service.method("org.example.Interface")
1063
def SampleDBusMethod():
1064
pass
1065
1066
The above "SampleDBusMethod" on "SampleDBusObject" will be
1067
reachable via two interfaces: "org.example.Interface" and
1068
"net.example.AlternateInterface", the latter of which will have
1069
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1070
"true", unless "deprecate" is passed with a False value.
1071
1072
This works for methods and signals, and also for D-Bus properties
1073
(from DBusObjectWithProperties) and interfaces (from the
1074
dbus_interface_annotations decorator).
942
1075
"""
943
def __new__(mcs, name, bases, attr):
944
# Go through all the base classes which could have D-Bus
945
# methods, signals, or properties in them
946
for base in (b for b in bases
947
if issubclass(b, dbus.service.Object)):
948
# Go though all attributes of the base class
949
for attrname, attribute in inspect.getmembers(base):
1076
def wrapper(cls):
1077
for orig_interface_name, alt_interface_name in (
1078
alt_interface_names.items()):
1079
attr = {}
1080
interface_names = set()
1081
# Go though all attributes of the class
1082
for attrname, attribute in inspect.getmembers(cls):
950
1083
# Ignore non-D-Bus attributes, and D-Bus attributes
951
1084
# with the wrong interface name
952
1085
if (not hasattr(attribute, "_dbus_interface")
953
1086
or not attribute._dbus_interface
954
.startswith("se.recompile.Mandos")):
1087
.startswith(orig_interface_name)):
955
1088
continue
956
1089
# Create an alternate D-Bus interface name based on
957
1090
# the current name
958
1091
alt_interface = (attribute._dbus_interface
959
.replace("se.recompile.Mandos",
960
"se.bsnet.fukt.Mandos"))
1092
.replace(orig_interface_name,
1093
alt_interface_name))
1094
interface_names.add(alt_interface)
961
1095
# Is this a D-Bus signal?
962
1096
if getattr(attribute, "_dbus_is_signal", False):
963
# Extract the original non-method function by
964
# black magic
1097
# Extract the original non-method undecorated
1098
# function by black magic
965
1099
nonmethod_func = (dict(
966
1100
zip(attribute.func_code.co_freevars,
967
1101
attribute.__closure__))["func"]
978
1112
nonmethod_func.func_name,
979
1113
nonmethod_func.func_defaults,
980
1114
nonmethod_func.func_closure)))
1115
# Copy annotations, if any
1116
try:
1117
new_function._dbus_annotations = (
1118
dict(attribute._dbus_annotations))
1119
except AttributeError:
1120
pass
981
1121
# Define a creator of a function to call both the
982
# old and new functions, so both the old and new
983
# signals gets sent when the function is called
1122
# original and alternate functions, so both the
1123
# original and alternate signals gets sent when
1124
# the function is called
984
1125
def fixscope(func1, func2):
985
1126
"""This function is a scope container to pass
986
1127
func1 and func2 to the "call_both" function
993
1134
return call_both
994
1135
# Create the "call_both" function and add it to
995
1136
# the class
996
attr[attrname] = fixscope(attribute,
997
new_function)
1137
attr[attrname] = fixscope(attribute, new_function)
998
1138
# Is this a D-Bus method?
999
1139
elif getattr(attribute, "_dbus_is_method", False):
1000
1140
# Create a new, but exactly alike, function
1011
1151
attribute.func_name,
1012
1152
attribute.func_defaults,
1013
1153
attribute.func_closure)))
1154
# Copy annotations, if any
1155
try:
1156
attr[attrname]._dbus_annotations = (
1157
dict(attribute._dbus_annotations))
1158
except AttributeError:
1159
pass
1014
1160
# Is this a D-Bus property?
1015
1161
elif getattr(attribute, "_dbus_is_property", False):
1016
1162
# Create a new, but exactly alike, function
1030
1176
attribute.func_name,
1031
1177
attribute.func_defaults,
1032
1178
attribute.func_closure)))
1033
return type.__new__(mcs, name, bases, attr)
1034
1035
1179
# Copy annotations, if any
1180
try:
1181
attr[attrname]._dbus_annotations = (
1182
dict(attribute._dbus_annotations))
1183
except AttributeError:
1184
pass
1185
# Is this a D-Bus interface?
1186
elif getattr(attribute, "_dbus_is_interface", False):
1187
# Create a new, but exactly alike, function
1188
# object. Decorate it to be a new D-Bus interface
1189
# with the alternate D-Bus interface name. Add it
1190
# to the class.
1191
attr[attrname] = (dbus_interface_annotations
1192
(alt_interface)
1193
(types.FunctionType
1194
(attribute.func_code,
1195
attribute.func_globals,
1196
attribute.func_name,
1197
attribute.func_defaults,
1198
attribute.func_closure)))
1199
if deprecate:
1200
# Deprecate all alternate interfaces
1201
iname="_AlternateDBusNames_interface_annotation{}"
1202
for interface_name in interface_names:
1203
@dbus_interface_annotations(interface_name)
1204
def func(self):
1205
return { "org.freedesktop.DBus.Deprecated":
1206
"true" }
1207
# Find an unused name
1208
for aname in (iname.format(i)
1209
for i in itertools.count()):
1210
if aname not in attr:
1211
attr[aname] = func
1212
break
1213
if interface_names:
1214
# Replace the class with a new subclass of it with
1215
# methods, signals, etc. as created above.
1216
cls = type(b"{}Alternate".format(cls.__name__),
1217
(cls,), attr)
1218
return cls
1219
return wrapper
1220
1221
1222
@alternate_dbus_interfaces({"se.recompile.Mandos":
1223
"se.bsnet.fukt.Mandos"})
1036
1224
class ClientDBus(Client, DBusObjectWithProperties):
1037
1225
"""A Client class using D-Bus
1038
1226
1044
1232
runtime_expansions = (Client.runtime_expansions
1045
1233
+ ("dbus_object_path",))
1046
1234
1235
_interface = "se.recompile.Mandos.Client"
1236
1047
1237
# dbus.service.Object doesn't use super(), so we can't either.
1048
1238
1049
1239
def __init__(self, bus = None, *args, **kwargs):
1051
1241
Client.__init__(self, *args, **kwargs)
1052
1242
# Only now, when this client is initialized, can it show up on
1053
1243
# the D-Bus
1054
client_object_name = unicode(self.name).translate(
1244
client_object_name = str(self.name).translate(
1055
1245
{ord("."): ord("_"),
1056
1246
ord("-"): ord("_")})
1057
1247
self.dbus_object_path = (dbus.ObjectPath
1058
1248
("/clients/" + client_object_name))
1059
1249
DBusObjectWithProperties.__init__(self, self.bus,
1060
1250
self.dbus_object_path)
1061
1251
1062
1252
def notifychangeproperty(transform_func,
1063
1253
dbus_name, type_func=lambda x: x,
1064
variant_level=1):
1254
variant_level=1, invalidate_only=False,
1255
_interface=_interface):
1065
1256
""" Modify a variable so that it's a property which announces
1066
1257
its changes to DBus.
1067
1258
1072
1263
to the D-Bus. Default: no transform
1073
1264
variant_level: D-Bus variant level. Default: 1
1074
1265
"""
1075
attrname = "_{0}".format(dbus_name)
1266
attrname = "_{}".format(dbus_name)
1076
1267
def setter(self, value):
1077
1268
if hasattr(self, "dbus_object_path"):
1078
1269
if (not hasattr(self, attrname) or
1079
1270
type_func(getattr(self, attrname, None))
1080
1271
!= type_func(value)):
1081
dbus_value = transform_func(type_func(value),
1082
variant_level
1083
=variant_level)
1084
self.PropertyChanged(dbus.String(dbus_name),
1085
dbus_value)
1272
if invalidate_only:
1273
self.PropertiesChanged(_interface,
1274
dbus.Dictionary(),
1275
dbus.Array
1276
((dbus_name,)))
1277
else:
1278
dbus_value = transform_func(type_func(value),
1279
variant_level
1280
=variant_level)
1281
self.PropertyChanged(dbus.String(dbus_name),
1282
dbus_value)
1283
self.PropertiesChanged(_interface,
1284
dbus.Dictionary({
1285
dbus.String(dbus_name):
1286
dbus_value }), dbus.Array())
1086
1287
setattr(self, attrname, value)
1087
1288
1088
1289
return property(lambda self: getattr(self, attrname), setter)
1089
1290
1090
1091
1291
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1092
1292
approvals_pending = notifychangeproperty(dbus.Boolean,
1093
1293
"ApprovalPending",
1100
1300
checker is not None)
1101
1301
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1102
1302
"LastCheckedOK")
1303
last_checker_status = notifychangeproperty(dbus.Int16,
1304
"LastCheckerStatus")
1103
1305
last_approval_request = notifychangeproperty(
1104
1306
datetime_to_dbus, "LastApprovalRequest")
1105
1307
approved_by_default = notifychangeproperty(dbus.Boolean,
1107
1309
approval_delay = notifychangeproperty(dbus.UInt64,
1108
1310
"ApprovalDelay",
1109
1311
type_func =
1110
timedelta_to_milliseconds)
1312
lambda td: td.total_seconds()
1313
* 1000)
1111
1314
approval_duration = notifychangeproperty(
1112
1315
dbus.UInt64, "ApprovalDuration",
1113
type_func = timedelta_to_milliseconds)
1316
type_func = lambda td: td.total_seconds() * 1000)
1114
1317
host = notifychangeproperty(dbus.String, "Host")
1115
1318
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1116
type_func =
1117
timedelta_to_milliseconds)
1319
type_func = lambda td:
1320
td.total_seconds() * 1000)
1118
1321
extended_timeout = notifychangeproperty(
1119
1322
dbus.UInt64, "ExtendedTimeout",
1120
type_func = timedelta_to_milliseconds)
1323
type_func = lambda td: td.total_seconds() * 1000)
1121
1324
interval = notifychangeproperty(dbus.UInt64,
1122
1325
"Interval",
1123
1326
type_func =
1124
timedelta_to_milliseconds)
1327
lambda td: td.total_seconds()
1328
* 1000)
1125
1329
checker_command = notifychangeproperty(dbus.String, "Checker")
1330
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1331
invalidate_only=True)
1126
1332
1127
1333
del notifychangeproperty
1128
1334
1155
1361
*args, **kwargs)
1156
1362
1157
1363
def start_checker(self, *args, **kwargs):
1158
old_checker = self.checker
1159
if self.checker is not None:
1160
old_checker_pid = self.checker.pid
1161
else:
1162
old_checker_pid = None
1364
old_checker_pid = getattr(self.checker, "pid", None)
1163
1365
r = Client.start_checker(self, *args, **kwargs)
1164
1366
# Only if new checker process was started
1165
1367
if (self.checker is not None
1173
1375
return False
1174
1376
1175
1377
def approve(self, value=True):
1176
self.send_changedstate()
1177
1378
self.approved = value
1178
gobject.timeout_add(timedelta_to_milliseconds
1179
(self.approval_duration),
1180
self._reset_approved)
1181
1379
gobject.timeout_add(int(self.approval_duration.total_seconds()
1380
* 1000), self._reset_approved)
1381
self.send_changedstate()
1182
1382
1183
1383
## D-Bus methods, signals & properties
1184
_interface = "se.recompile.Mandos.Client"
1384
1385
## Interfaces
1185
1386
1186
1387
## Signals
1187
1388
1198
1399
pass
1199
1400
1200
1401
# PropertyChanged - signal
1402
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1201
1403
@dbus.service.signal(_interface, signature="sv")
1202
1404
def PropertyChanged(self, property, value):
1203
1405
"D-Bus signal"
1279
1481
access="readwrite")
1280
1482
def ApprovalDelay_dbus_property(self, value=None):
1281
1483
if value is None: # get
1282
return dbus.UInt64(self.approval_delay_milliseconds())
1484
return dbus.UInt64(self.approval_delay.total_seconds()
1485
* 1000)
1283
1486
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1284
1487
1285
1488
# ApprovalDuration - property
1287
1490
access="readwrite")
1288
1491
def ApprovalDuration_dbus_property(self, value=None):
1289
1492
if value is None: # get
1290
return dbus.UInt64(timedelta_to_milliseconds(
1291
self.approval_duration))
1493
return dbus.UInt64(self.approval_duration.total_seconds()
1494
* 1000)
1292
1495
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1293
1496
1294
1497
# Name - property
1307
1510
def Host_dbus_property(self, value=None):
1308
1511
if value is None: # get
1309
1512
return dbus.String(self.host)
1310
self.host = unicode(value)
1513
self.host = str(value)
1311
1514
1312
1515
# Created - property
1313
1516
@dbus_service_property(_interface, signature="s", access="read")
1339
1542
return
1340
1543
return datetime_to_dbus(self.last_checked_ok)
1341
1544
1545
# LastCheckerStatus - property
1546
@dbus_service_property(_interface, signature="n",
1547
access="read")
1548
def LastCheckerStatus_dbus_property(self):
1549
return dbus.Int16(self.last_checker_status)
1550
1342
1551
# Expires - property
1343
1552
@dbus_service_property(_interface, signature="s", access="read")
1344
1553
def Expires_dbus_property(self):
1354
1563
access="readwrite")
1355
1564
def Timeout_dbus_property(self, value=None):
1356
1565
if value is None: # get
1357
return dbus.UInt64(self.timeout_milliseconds())
1566
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1567
old_timeout = self.timeout
1358
1568
self.timeout = datetime.timedelta(0, 0, 0, value)
1359
# Reschedule timeout
1569
# Reschedule disabling
1360
1570
if self.enabled:
1361
1571
now = datetime.datetime.utcnow()
1362
time_to_die = timedelta_to_milliseconds(
1363
(self.last_checked_ok + self.timeout) - now)
1364
if time_to_die <= 0:
1572
self.expires += self.timeout - old_timeout
1573
if self.expires <= now:
1365
1574
# The timeout has passed
1366
1575
self.disable()
1367
1576
else:
1368
self.expires = (now +
1369
datetime.timedelta(milliseconds =
1370
time_to_die))
1371
1577
if (getattr(self, "disable_initiator_tag", None)
1372
1578
is None):
1373
1579
return
1374
1580
gobject.source_remove(self.disable_initiator_tag)
1375
self.disable_initiator_tag = (gobject.timeout_add
1376
(time_to_die,
1377
self.disable))
1581
self.disable_initiator_tag = (
1582
gobject.timeout_add(
1583
int((self.expires - now).total_seconds()
1584
* 1000), self.disable))
1378
1585
1379
1586
# ExtendedTimeout - property
1380
1587
@dbus_service_property(_interface, signature="t",
1381
1588
access="readwrite")
1382
1589
def ExtendedTimeout_dbus_property(self, value=None):
1383
1590
if value is None: # get
1384
return dbus.UInt64(self.extended_timeout_milliseconds())
1591
return dbus.UInt64(self.extended_timeout.total_seconds()
1592
* 1000)
1385
1593
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1386
1594
1387
1595
# Interval - property
1389
1597
access="readwrite")
1390
1598
def Interval_dbus_property(self, value=None):
1391
1599
if value is None: # get
1392
return dbus.UInt64(self.interval_milliseconds())
1600
return dbus.UInt64(self.interval.total_seconds() * 1000)
1393
1601
self.interval = datetime.timedelta(0, 0, 0, value)
1394
1602
if getattr(self, "checker_initiator_tag", None) is None:
1395
1603
return
1406
1614
def Checker_dbus_property(self, value=None):
1407
1615
if value is None: # get
1408
1616
return dbus.String(self.checker_command)
1409
self.checker_command = unicode(value)
1617
self.checker_command = str(value)
1410
1618
1411
1619
# CheckerRunning - property
1412
1620
@dbus_service_property(_interface, signature="b",
1428
1636
@dbus_service_property(_interface, signature="ay",
1429
1637
access="write", byte_arrays=True)
1430
1638
def Secret_dbus_property(self, value):
1431
self.secret = str(value)
1639
self.secret = bytes(value)
1432
1640
1433
1641
del _interface
1434
1642
1459
1667
self._pipe.send(('setattr', name, value))
1460
1668
1461
1669
1462
class ClientDBusTransitional(ClientDBus):
1463
__metaclass__ = AlternateDBusNamesMetaclass
1464
1465
1466
1670
class ClientHandler(socketserver.BaseRequestHandler, object):
1467
1671
"""A class to handle client connections.
1468
1672
1472
1676
def handle(self):
1473
1677
with contextlib.closing(self.server.child_pipe) as child_pipe:
1474
1678
logger.info("TCP connection from: %s",
1475
unicode(self.client_address))
1679
str(self.client_address))
1476
1680
logger.debug("Pipe FD: %d",
1477
1681
self.server.child_pipe.fileno())
1478
1682
1504
1708
logger.debug("Protocol version: %r", line)
1505
1709
try:
1506
1710
if int(line.strip().split()[0]) > 1:
1507
raise RuntimeError
1711
raise RuntimeError(line)
1508
1712
except (ValueError, IndexError, RuntimeError) as error:
1509
1713
logger.error("Unknown protocol version: %s", error)
1510
1714
return
1559
1763
if self.server.use_dbus:
1560
1764
# Emit D-Bus signal
1561
1765
client.NeedApproval(
1562
client.approval_delay_milliseconds(),
1563
client.approved_by_default)
1766
client.approval_delay.total_seconds()
1767
* 1000, client.approved_by_default)
1564
1768
else:
1565
1769
logger.warning("Client %s was not approved",
1566
1770
client.name)
1572
1776
#wait until timeout or approved
1573
1777
time = datetime.datetime.now()
1574
1778
client.changedstate.acquire()
1575
(client.changedstate.wait
1576
(float(client.timedelta_to_milliseconds(delay)
1577
/ 1000)))
1779
client.changedstate.wait(delay.total_seconds())
1578
1780
client.changedstate.release()
1579
1781
time2 = datetime.datetime.now()
1580
1782
if (time2 - time) >= delay:
1596
1798
try:
1597
1799
sent = session.send(client.secret[sent_size:])
1598
1800
except gnutls.errors.GNUTLSError as error:
1599
logger.warning("gnutls send failed")
1801
logger.warning("gnutls send failed",
1802
exc_info=error)
1600
1803
return
1601
1804
logger.debug("Sent: %d, remaining: %d",
1602
1805
sent, len(client.secret)
1605
1808
1606
1809
logger.info("Sending secret to %s", client.name)
1607
1810
# bump the timeout using extended_timeout
1608
client.checked_ok(client.extended_timeout)
1811
client.bump_timeout(client.extended_timeout)
1609
1812
if self.server.use_dbus:
1610
1813
# Emit D-Bus signal
1611
1814
client.GotSecret()
1616
1819
try:
1617
1820
session.bye()
1618
1821
except gnutls.errors.GNUTLSError as error:
1619
logger.warning("GnuTLS bye failed")
1822
logger.warning("GnuTLS bye failed",
1823
exc_info=error)
1620
1824
1621
1825
@staticmethod
1622
1826
def peer_certificate(session):
1694
1898
def process_request(self, request, address):
1695
1899
"""Start a new process to process the request."""
1696
1900
proc = multiprocessing.Process(target = self.sub_process_main,
1697
args = (request,
1698
address))
1901
args = (request, address))
1699
1902
proc.start()
1700
1903
return proc
1701
1904
1716
1919
1717
1920
def add_pipe(self, parent_pipe, proc):
1718
1921
"""Dummy function; override as necessary"""
1719
raise NotImplementedError
1922
raise NotImplementedError()
1720
1923
1721
1924
1722
1925
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1729
1932
use_ipv6: Boolean; to use IPv6 or not
1730
1933
"""
1731
1934
def __init__(self, server_address, RequestHandlerClass,
1732
interface=None, use_ipv6=True):
1935
interface=None, use_ipv6=True, socketfd=None):
1936
"""If socketfd is set, use that file descriptor instead of
1937
creating a new one with socket.socket().
1938
"""
1733
1939
self.interface = interface
1734
1940
if use_ipv6:
1735
1941
self.address_family = socket.AF_INET6
1942
if socketfd is not None:
1943
# Save the file descriptor
1944
self.socketfd = socketfd
1945
# Save the original socket.socket() function
1946
self.socket_socket = socket.socket
1947
# To implement --socket, we monkey patch socket.socket.
1948
#
1949
# (When socketserver.TCPServer is a new-style class, we
1950
# could make self.socket into a property instead of monkey
1951
# patching socket.socket.)
1952
#
1953
# Create a one-time-only replacement for socket.socket()
1954
@functools.wraps(socket.socket)
1955
def socket_wrapper(*args, **kwargs):
1956
# Restore original function so subsequent calls are
1957
# not affected.
1958
socket.socket = self.socket_socket
1959
del self.socket_socket
1960
# This time only, return a new socket object from the
1961
# saved file descriptor.
1962
return socket.fromfd(self.socketfd, *args, **kwargs)
1963
# Replace socket.socket() function with wrapper
1964
socket.socket = socket_wrapper
1965
# The socketserver.TCPServer.__init__ will call
1966
# socket.socket(), which might be our replacement,
1967
# socket_wrapper(), if socketfd was set.
1736
1968
socketserver.TCPServer.__init__(self, server_address,
1737
1969
RequestHandlerClass)
1970
1738
1971
def server_bind(self):
1739
1972
"""This overrides the normal server_bind() function
1740
1973
to bind to an interface if one was specified, and also NOT to
1748
1981
try:
1749
1982
self.socket.setsockopt(socket.SOL_SOCKET,
1750
1983
SO_BINDTODEVICE,
1751
str(self.interface
1752
+ '\0'))
1984
(self.interface + "\0")
1985
.encode("utf-8"))
1753
1986
except socket.error as error:
1754
if error[0] == errno.EPERM:
1755
logger.error("No permission to"
1756
" bind to interface %s",
1757
self.interface)
1758
elif error[0] == errno.ENOPROTOOPT:
1987
if error.errno == errno.EPERM:
1988
logger.error("No permission to bind to"
1989
" interface %s", self.interface)
1990
elif error.errno == errno.ENOPROTOOPT:
1759
1991
logger.error("SO_BINDTODEVICE not available;"
1760
1992
" cannot bind to interface %s",
1761
1993
self.interface)
1994
elif error.errno == errno.ENODEV:
1995
logger.error("Interface %s does not exist,"
1996
" cannot bind", self.interface)
1762
1997
else:
1763
1998
raise
1764
1999
# Only bind(2) the socket if we really need to.
1767
2002
if self.address_family == socket.AF_INET6:
1768
2003
any_address = "::" # in6addr_any
1769
2004
else:
1770
any_address = socket.INADDR_ANY
2005
any_address = "0.0.0.0" # INADDR_ANY
1771
2006
self.server_address = (any_address,
1772
2007
self.server_address[1])
1773
2008
elif not self.server_address[1]:
1794
2029
"""
1795
2030
def __init__(self, server_address, RequestHandlerClass,
1796
2031
interface=None, use_ipv6=True, clients=None,
1797
gnutls_priority=None, use_dbus=True):
2032
gnutls_priority=None, use_dbus=True, socketfd=None):
1798
2033
self.enabled = False
1799
2034
self.clients = clients
1800
2035
if self.clients is None:
1804
2039
IPv6_TCPServer.__init__(self, server_address,
1805
2040
RequestHandlerClass,
1806
2041
interface = interface,
1807
use_ipv6 = use_ipv6)
2042
use_ipv6 = use_ipv6,
2043
socketfd = socketfd)
1808
2044
def server_activate(self):
1809
2045
if self.enabled:
1810
2046
return socketserver.TCPServer.server_activate(self)
1823
2059
1824
2060
def handle_ipc(self, source, condition, parent_pipe=None,
1825
2061
proc = None, client_object=None):
1826
condition_names = {
1827
gobject.IO_IN: "IN", # There is data to read.
1828
gobject.IO_OUT: "OUT", # Data can be written (without
1829
# blocking).
1830
gobject.IO_PRI: "PRI", # There is urgent data to read.
1831
gobject.IO_ERR: "ERR", # Error condition.
1832
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1833
# broken, usually for pipes and
1834
# sockets).
1835
}
1836
conditions_string = ' | '.join(name
1837
for cond, name in
1838
condition_names.iteritems()
1839
if cond & condition)
1840
2062
# error, or the other end of multiprocessing.Pipe has closed
1841
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2063
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1842
2064
# Wait for other process to exit
1843
2065
proc.join()
1844
2066
return False
1902
2124
return True
1903
2125
1904
2126
2127
def rfc3339_duration_to_delta(duration):
2128
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2129
2130
>>> rfc3339_duration_to_delta("P7D")
2131
datetime.timedelta(7)
2132
>>> rfc3339_duration_to_delta("PT60S")
2133
datetime.timedelta(0, 60)
2134
>>> rfc3339_duration_to_delta("PT60M")
2135
datetime.timedelta(0, 3600)
2136
>>> rfc3339_duration_to_delta("PT24H")
2137
datetime.timedelta(1)
2138
>>> rfc3339_duration_to_delta("P1W")
2139
datetime.timedelta(7)
2140
>>> rfc3339_duration_to_delta("PT5M30S")
2141
datetime.timedelta(0, 330)
2142
>>> rfc3339_duration_to_delta("P1DT3M20S")
2143
datetime.timedelta(1, 200)
2144
"""
2145
2146
# Parsing an RFC 3339 duration with regular expressions is not
2147
# possible - there would have to be multiple places for the same
2148
# values, like seconds. The current code, while more esoteric, is
2149
# cleaner without depending on a parsing library. If Python had a
2150
# built-in library for parsing we would use it, but we'd like to
2151
# avoid excessive use of external libraries.
2152
2153
# New type for defining tokens, syntax, and semantics all-in-one
2154
Token = collections.namedtuple("Token",
2155
("regexp", # To match token; if
2156
# "value" is not None,
2157
# must have a "group"
2158
# containing digits
2159
"value", # datetime.timedelta or
2160
# None
2161
"followers")) # Tokens valid after
2162
# this token
2163
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2164
# the "duration" ABNF definition in RFC 3339, Appendix A.
2165
token_end = Token(re.compile(r"$"), None, frozenset())
2166
token_second = Token(re.compile(r"(\d+)S"),
2167
datetime.timedelta(seconds=1),
2168
frozenset((token_end,)))
2169
token_minute = Token(re.compile(r"(\d+)M"),
2170
datetime.timedelta(minutes=1),
2171
frozenset((token_second, token_end)))
2172
token_hour = Token(re.compile(r"(\d+)H"),
2173
datetime.timedelta(hours=1),
2174
frozenset((token_minute, token_end)))
2175
token_time = Token(re.compile(r"T"),
2176
None,
2177
frozenset((token_hour, token_minute,
2178
token_second)))
2179
token_day = Token(re.compile(r"(\d+)D"),
2180
datetime.timedelta(days=1),
2181
frozenset((token_time, token_end)))
2182
token_month = Token(re.compile(r"(\d+)M"),
2183
datetime.timedelta(weeks=4),
2184
frozenset((token_day, token_end)))
2185
token_year = Token(re.compile(r"(\d+)Y"),
2186
datetime.timedelta(weeks=52),
2187
frozenset((token_month, token_end)))
2188
token_week = Token(re.compile(r"(\d+)W"),
2189
datetime.timedelta(weeks=1),
2190
frozenset((token_end,)))
2191
token_duration = Token(re.compile(r"P"), None,
2192
frozenset((token_year, token_month,
2193
token_day, token_time,
2194
token_week)))
2195
# Define starting values
2196
value = datetime.timedelta() # Value so far
2197
found_token = None
2198
followers = frozenset((token_duration,)) # Following valid tokens
2199
s = duration # String left to parse
2200
# Loop until end token is found
2201
while found_token is not token_end:
2202
# Search for any currently valid tokens
2203
for token in followers:
2204
match = token.regexp.match(s)
2205
if match is not None:
2206
# Token found
2207
if token.value is not None:
2208
# Value found, parse digits
2209
factor = int(match.group(1), 10)
2210
# Add to value so far
2211
value += factor * token.value
2212
# Strip token from string
2213
s = token.regexp.sub("", s, 1)
2214
# Go to found token
2215
found_token = token
2216
# Set valid next tokens
2217
followers = found_token.followers
2218
break
2219
else:
2220
# No currently valid tokens were found
2221
raise ValueError("Invalid RFC 3339 duration")
2222
# End token found
2223
return value
2224
2225
1905
2226
def string_to_delta(interval):
1906
2227
"""Parse a string and return a datetime.timedelta
1907
2228
1918
2239
>>> string_to_delta('5m 30s')
1919
2240
datetime.timedelta(0, 330)
1920
2241
"""
2242
2243
try:
2244
return rfc3339_duration_to_delta(interval)
2245
except ValueError:
2246
pass
2247
1921
2248
timevalue = datetime.timedelta(0)
1922
2249
for s in interval.split():
1923
2250
try:
1924
suffix = unicode(s[-1])
2251
suffix = s[-1]
1925
2252
value = int(s[:-1])
1926
2253
if suffix == "d":
1927
2254
delta = datetime.timedelta(value)
1934
2261
elif suffix == "w":
1935
2262
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1936
2263
else:
1937
raise ValueError("Unknown suffix %r" % suffix)
1938
except (ValueError, IndexError) as e:
2264
raise ValueError("Unknown suffix {!r}"
2265
.format(suffix))
2266
except IndexError as e:
1939
2267
raise ValueError(*(e.args))
1940
2268
timevalue += delta
1941
2269
return timevalue
1954
2282
sys.exit()
1955
2283
if not noclose:
1956
2284
# Close all standard open file descriptors
1957
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2285
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1958
2286
if not stat.S_ISCHR(os.fstat(null).st_mode):
1959
raise OSError(errno.ENODEV,
1960
"%s not a character device"
1961
% os.path.devnull)
2287
raise OSError(errno.ENODEV, "{} not a character device"
2288
.format(os.devnull))
1962
2289
os.dup2(null, sys.stdin.fileno())
1963
2290
os.dup2(null, sys.stdout.fileno())
1964
2291
os.dup2(null, sys.stderr.fileno())
1973
2300
1974
2301
parser = argparse.ArgumentParser()
1975
2302
parser.add_argument("-v", "--version", action="version",
1976
version = "%%(prog)s %s" % version,
2303
version = "%(prog)s {}".format(version),
1977
2304
help="show version number and exit")
1978
2305
parser.add_argument("-i", "--interface", metavar="IF",
1979
2306
help="Bind to interface IF")
1985
2312
help="Run self-test")
1986
2313
parser.add_argument("--debug", action="store_true",
1987
2314
help="Debug mode; run in foreground and log"
1988
" to terminal")
2315
" to terminal", default=None)
1989
2316
parser.add_argument("--debuglevel", metavar="LEVEL",
1990
2317
help="Debug level for stdout output")
1991
2318
parser.add_argument("--priority", help="GnuTLS"
1998
2325
" files")
1999
2326
parser.add_argument("--no-dbus", action="store_false",
2000
2327
dest="use_dbus", help="Do not provide D-Bus"
2001
" system bus interface")
2328
" system bus interface", default=None)
2002
2329
parser.add_argument("--no-ipv6", action="store_false",
2003
dest="use_ipv6", help="Do not use IPv6")
2330
dest="use_ipv6", help="Do not use IPv6",
2331
default=None)
2004
2332
parser.add_argument("--no-restore", action="store_false",
2005
2333
dest="restore", help="Do not restore stored"
2006
" state")
2334
" state", default=None)
2335
parser.add_argument("--socket", type=int,
2336
help="Specify a file descriptor to a network"
2337
" socket to use instead of creating one")
2007
2338
parser.add_argument("--statedir", metavar="DIR",
2008
2339
help="Directory to save/restore state in")
2340
parser.add_argument("--foreground", action="store_true",
2341
help="Run in foreground", default=None)
2342
parser.add_argument("--no-zeroconf", action="store_false",
2343
dest="zeroconf", help="Do not use Zeroconf",
2344
default=None)
2009
2345
2010
2346
options = parser.parse_args()
2011
2347
2012
2348
if options.check:
2013
2349
import doctest
2014
doctest.testmod()
2015
sys.exit()
2350
fail_count, test_count = doctest.testmod()
2351
sys.exit(os.EX_OK if fail_count == 0 else 1)
2016
2352
2017
2353
# Default values for config file for server-global settings
2018
2354
server_defaults = { "interface": "",
2020
2356
"port": "",
2021
2357
"debug": "False",
2022
2358
"priority":
2023
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2359
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2360
":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2024
2361
"servicename": "Mandos",
2025
2362
"use_dbus": "True",
2026
2363
"use_ipv6": "True",
2027
2364
"debuglevel": "",
2028
2365
"restore": "True",
2029
"statedir": "/var/lib/mandos"
2366
"socket": "",
2367
"statedir": "/var/lib/mandos",
2368
"foreground": "False",
2369
"zeroconf": "True",
2030
2370
}
2031
2371
2032
2372
# Parse config file for server-global settings
2037
2377
# Convert the SafeConfigParser object to a dict
2038
2378
server_settings = server_config.defaults()
2039
2379
# Use the appropriate methods on the non-string config options
2040
for option in ("debug", "use_dbus", "use_ipv6"):
2380
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2041
2381
server_settings[option] = server_config.getboolean("DEFAULT",
2042
2382
option)
2043
2383
if server_settings["port"]:
2044
2384
server_settings["port"] = server_config.getint("DEFAULT",
2045
2385
"port")
2386
if server_settings["socket"]:
2387
server_settings["socket"] = server_config.getint("DEFAULT",
2388
"socket")
2389
# Later, stdin will, and stdout and stderr might, be dup'ed
2390
# over with an opened os.devnull. But we don't want this to
2391
# happen with a supplied network socket.
2392
if 0 <= server_settings["socket"] <= 2:
2393
server_settings["socket"] = os.dup(server_settings
2394
["socket"])
2046
2395
del server_config
2047
2396
2048
2397
# Override the settings from the config file with command line
2050
2399
for option in ("interface", "address", "port", "debug",
2051
2400
"priority", "servicename", "configdir",
2052
2401
"use_dbus", "use_ipv6", "debuglevel", "restore",
2053
"statedir"):
2402
"statedir", "socket", "foreground", "zeroconf"):
2054
2403
value = getattr(options, option)
2055
2404
if value is not None:
2056
2405
server_settings[option] = value
2057
2406
del options
2058
2407
# Force all strings to be unicode
2059
2408
for option in server_settings.keys():
2060
if type(server_settings[option]) is str:
2061
server_settings[option] = unicode(server_settings[option])
2409
if isinstance(server_settings[option], bytes):
2410
server_settings[option] = (server_settings[option]
2411
.decode("utf-8"))
2412
# Force all boolean options to be boolean
2413
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2414
"foreground", "zeroconf"):
2415
server_settings[option] = bool(server_settings[option])
2416
# Debug implies foreground
2417
if server_settings["debug"]:
2418
server_settings["foreground"] = True
2062
2419
# Now we have our good server settings in "server_settings"
2063
2420
2064
2421
##################################################################
2065
2422
2423
if (not server_settings["zeroconf"] and
2424
not (server_settings["port"]
2425
or server_settings["socket"] != "")):
2426
parser.error("Needs port or socket to work without"
2427
" Zeroconf")
2428
2066
2429
# For convenience
2067
2430
debug = server_settings["debug"]
2068
2431
debuglevel = server_settings["debuglevel"]
2070
2433
use_ipv6 = server_settings["use_ipv6"]
2071
2434
stored_state_path = os.path.join(server_settings["statedir"],
2072
2435
stored_state_file)
2436
foreground = server_settings["foreground"]
2437
zeroconf = server_settings["zeroconf"]
2073
2438
2074
2439
if debug:
2075
2440
initlogger(debug, logging.DEBUG)
2082
2447
2083
2448
if server_settings["servicename"] != "Mandos":
2084
2449
syslogger.setFormatter(logging.Formatter
2085
('Mandos (%s) [%%(process)d]:'
2086
' %%(levelname)s: %%(message)s'
2087
% server_settings["servicename"]))
2450
('Mandos ({}) [%(process)d]:'
2451
' %(levelname)s: %(message)s'
2452
.format(server_settings
2453
["servicename"])))
2088
2454
2089
2455
# Parse config file with clients
2090
2456
client_config = configparser.SafeConfigParser(Client
2095
2461
global mandos_dbus_service
2096
2462
mandos_dbus_service = None
2097
2463
2464
socketfd = None
2465
if server_settings["socket"] != "":
2466
socketfd = server_settings["socket"]
2098
2467
tcp_server = MandosServer((server_settings["address"],
2099
2468
server_settings["port"]),
2100
2469
ClientHandler,
2103
2472
use_ipv6=use_ipv6,
2104
2473
gnutls_priority=
2105
2474
server_settings["priority"],
2106
use_dbus=use_dbus)
2107
if not debug:
2108
pidfilename = "/var/run/mandos.pid"
2475
use_dbus=use_dbus,
2476
socketfd=socketfd)
2477
if not foreground:
2478
pidfilename = "/run/mandos.pid"
2479
if not os.path.isdir("/run/."):
2480
pidfilename = "/var/run/mandos.pid"
2481
pidfile = None
2109
2482
try:
2110
2483
pidfile = open(pidfilename, "w")
2111
except IOError:
2112
logger.error("Could not open file %r", pidfilename)
2484
except IOError as e:
2485
logger.error("Could not open file %r", pidfilename,
2486
exc_info=e)
2113
2487
2114
try:
2115
uid = pwd.getpwnam("_mandos").pw_uid
2116
gid = pwd.getpwnam("_mandos").pw_gid
2117
except KeyError:
2488
for name in ("_mandos", "mandos", "nobody"):
2118
2489
try:
2119
uid = pwd.getpwnam("mandos").pw_uid
2120
gid = pwd.getpwnam("mandos").pw_gid
2490
uid = pwd.getpwnam(name).pw_uid
2491
gid = pwd.getpwnam(name).pw_gid
2492
break
2121
2493
except KeyError:
2122
try:
2123
uid = pwd.getpwnam("nobody").pw_uid
2124
gid = pwd.getpwnam("nobody").pw_gid
2125
except KeyError:
2126
uid = 65534
2127
gid = 65534
2494
continue
2495
else:
2496
uid = 65534
2497
gid = 65534
2128
2498
try:
2129
2499
os.setgid(gid)
2130
2500
os.setuid(uid)
2131
2501
except OSError as error:
2132
if error[0] != errno.EPERM:
2133
raise error
2502
if error.errno != errno.EPERM:
2503
raise
2134
2504
2135
2505
if debug:
2136
2506
# Enable all possible GnuTLS debugging
2147
2517
.gnutls_global_set_log_function(debug_gnutls))
2148
2518
2149
2519
# Redirect stdin so all checkers get /dev/null
2150
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2520
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2151
2521
os.dup2(null, sys.stdin.fileno())
2152
2522
if null > 2:
2153
2523
os.close(null)
2154
2524
2155
2525
# Need to fork before connecting to D-Bus
2156
if not debug:
2526
if not foreground:
2157
2527
# Close all input and output, do double fork, etc.
2158
2528
daemon()
2159
2529
2530
# multiprocessing will use threads, so before we use gobject we
2531
# need to inform gobject that threads will be used.
2160
2532
gobject.threads_init()
2161
2533
2162
2534
global main_loop
2163
2535
# From the Avahi example code
2164
DBusGMainLoop(set_as_default=True )
2536
DBusGMainLoop(set_as_default=True)
2165
2537
main_loop = gobject.MainLoop()
2166
2538
bus = dbus.SystemBus()
2167
2539
# End of Avahi example code
2173
2545
("se.bsnet.fukt.Mandos", bus,
2174
2546
do_not_queue=True))
2175
2547
except dbus.exceptions.NameExistsException as e:
2176
logger.error(unicode(e) + ", disabling D-Bus")
2548
logger.error("Disabling D-Bus:", exc_info=e)
2177
2549
use_dbus = False
2178
2550
server_settings["use_dbus"] = False
2179
2551
tcp_server.use_dbus = False
2180
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2181
service = AvahiServiceToSyslog(name =
2182
server_settings["servicename"],
2183
servicetype = "_mandos._tcp",
2184
protocol = protocol, bus = bus)
2185
if server_settings["interface"]:
2186
service.interface = (if_nametoindex
2187
(str(server_settings["interface"])))
2552
if zeroconf:
2553
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2554
service = AvahiServiceToSyslog(name =
2555
server_settings["servicename"],
2556
servicetype = "_mandos._tcp",
2557
protocol = protocol, bus = bus)
2558
if server_settings["interface"]:
2559
service.interface = (if_nametoindex
2560
(server_settings["interface"]
2561
.encode("utf-8")))
2188
2562
2189
2563
global multiprocessing_manager
2190
2564
multiprocessing_manager = multiprocessing.Manager()
2191
2565
2192
2566
client_class = Client
2193
2567
if use_dbus:
2194
client_class = functools.partial(ClientDBusTransitional,
2195
bus = bus)
2568
client_class = functools.partial(ClientDBus, bus = bus)
2196
2569
2197
2570
client_settings = Client.config_parser(client_config)
2198
2571
old_client_settings = {}
2199
2572
clients_data = {}
2200
2573
2574
# This is used to redirect stdout and stderr for checker processes
2575
global wnull
2576
wnull = open(os.devnull, "w") # A writable /dev/null
2577
# Only used if server is running in foreground but not in debug
2578
# mode
2579
if debug or not foreground:
2580
wnull.close()
2581
2201
2582
# Get client data and settings from last running state.
2202
2583
if server_settings["restore"]:
2203
2584
try:
2206
2587
(stored_state))
2207
2588
os.remove(stored_state_path)
2208
2589
except IOError as e:
2209
logger.warning("Could not load persistent state: {0}"
2210
.format(e))
2211
if e.errno != errno.ENOENT:
2590
if e.errno == errno.ENOENT:
2591
logger.warning("Could not load persistent state: {}"
2592
.format(os.strerror(e.errno)))
2593
else:
2594
logger.critical("Could not load persistent state:",
2595
exc_info=e)
2212
2596
raise
2213
2597
except EOFError as e:
2214
2598
logger.warning("Could not load persistent state: "
2215
"EOFError: {0}".format(e))
2599
"EOFError:", exc_info=e)
2216
2600
2217
2601
with PGPEngine() as pgp:
2218
for client_name, client in clients_data.iteritems():
2602
for client_name, client in clients_data.items():
2603
# Skip removed clients
2604
if client_name not in client_settings:
2605
continue
2606
2219
2607
# Decide which value to use after restoring saved state.
2220
2608
# We have three different values: Old config file,
2221
2609
# new config file, and saved state.
2242
2630
if datetime.datetime.utcnow() >= client["expires"]:
2243
2631
if not client["last_checked_ok"]:
2244
2632
logger.warning(
2245
"disabling client {0} - Client never "
2633
"disabling client {} - Client never "
2246
2634
"performed a successful checker"
2247
2635
.format(client_name))
2248
2636
client["enabled"] = False
2249
2637
elif client["last_checker_status"] != 0:
2250
2638
logger.warning(
2251
"disabling client {0} - Client "
2252
"last checker failed with error code {1}"
2639
"disabling client {} - Client last"
2640
" checker failed with error code {}"
2253
2641
.format(client_name,
2254
2642
client["last_checker_status"]))
2255
2643
client["enabled"] = False
2258
2646
.utcnow()
2259
2647
+ client["timeout"])
2260
2648
logger.debug("Last checker succeeded,"
2261
" keeping {0} enabled"
2649
" keeping {} enabled"
2262
2650
.format(client_name))
2263
2651
try:
2264
2652
client["secret"] = (
2267
2655
["secret"]))
2268
2656
except PGPError:
2269
2657
# If decryption fails, we use secret from new settings
2270
logger.debug("Failed to decrypt {0} old secret"
2658
logger.debug("Failed to decrypt {} old secret"
2271
2659
.format(client_name))
2272
2660
client["secret"] = (
2273
2661
client_settings[client_name]["secret"])
2274
2275
2662
2276
2663
# Add/remove clients based on new changes made to config
2277
2664
for client_name in (set(old_client_settings)
2280
2667
for client_name in (set(client_settings)
2281
2668
- set(old_client_settings)):
2282
2669
clients_data[client_name] = client_settings[client_name]
2283
2670
2284
2671
# Create all client objects
2285
for client_name, client in clients_data.iteritems():
2672
for client_name, client in clients_data.items():
2286
2673
tcp_server.clients[client_name] = client_class(
2287
name = client_name, settings = client)
2674
name = client_name, settings = client,
2675
server_settings = server_settings)
2288
2676
2289
2677
if not tcp_server.clients:
2290
2678
logger.warning("No clients defined")
2291
2292
if not debug:
2293
try:
2294
with pidfile:
2295
pid = os.getpid()
2296
pidfile.write(str(pid) + "\n".encode("utf-8"))
2297
del pidfile
2298
except IOError:
2299
logger.error("Could not write to file %r with PID %d",
2300
pidfilename, pid)
2301
except NameError:
2302
# "pidfile" was never created
2303
pass
2679
2680
if not foreground:
2681
if pidfile is not None:
2682
try:
2683
with pidfile:
2684
pid = os.getpid()
2685
pidfile.write("{}\n".format(pid).encode("utf-8"))
2686
except IOError:
2687
logger.error("Could not write to file %r with PID %d",
2688
pidfilename, pid)
2689
del pidfile
2304
2690
del pidfilename
2305
signal.signal(signal.SIGINT, signal.SIG_IGN)
2306
2691
2307
2692
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2308
2693
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2309
2694
2310
2695
if use_dbus:
2311
class MandosDBusService(dbus.service.Object):
2696
@alternate_dbus_interfaces({"se.recompile.Mandos":
2697
"se.bsnet.fukt.Mandos"})
2698
class MandosDBusService(DBusObjectWithProperties):
2312
2699
"""A D-Bus proxy object"""
2313
2700
def __init__(self):
2314
2701
dbus.service.Object.__init__(self, bus, "/")
2315
2702
_interface = "se.recompile.Mandos"
2316
2703
2704
@dbus_interface_annotations(_interface)
2705
def _foo(self):
2706
return { "org.freedesktop.DBus.Property"
2707
".EmitsChangedSignal":
2708
"false"}
2709
2317
2710
@dbus.service.signal(_interface, signature="o")
2318
2711
def ClientAdded(self, objpath):
2319
2712
"D-Bus signal"
2341
2734
def GetAllClientsWithProperties(self):
2342
2735
"D-Bus method"
2343
2736
return dbus.Dictionary(
2344
((c.dbus_object_path, c.GetAll(""))
2345
for c in tcp_server.clients.itervalues()),
2737
{ c.dbus_object_path: c.GetAll("")
2738
for c in tcp_server.clients.itervalues() },
2346
2739
signature="oa{sv}")
2347
2740
2348
2741
@dbus.service.method(_interface, in_signature="o")
2361
2754
2362
2755
del _interface
2363
2756
2364
class MandosDBusServiceTransitional(MandosDBusService):
2365
__metaclass__ = AlternateDBusNamesMetaclass
2366
mandos_dbus_service = MandosDBusServiceTransitional()
2757
mandos_dbus_service = MandosDBusService()
2367
2758
2368
2759
def cleanup():
2369
2760
"Cleanup function; run on exit"
2370
service.cleanup()
2761
if zeroconf:
2762
service.cleanup()
2371
2763
2372
2764
multiprocessing.active_children()
2765
wnull.close()
2373
2766
if not (tcp_server.clients or client_settings):
2374
2767
return
2375
2768
2386
2779
2387
2780
# A list of attributes that can not be pickled
2388
2781
# + secret.
2389
exclude = set(("bus", "changedstate", "secret",
2390
"checker"))
2782
exclude = { "bus", "changedstate", "secret",
2783
"checker", "server_settings" }
2391
2784
for name, typ in (inspect.getmembers
2392
2785
(dbus.service.Object)):
2393
2786
exclude.add(name)
2402
2795
del client_settings[client.name]["secret"]
2403
2796
2404
2797
try:
2405
tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2406
prefix="clients-",
2407
dir=os.path.dirname
2408
(stored_state_path))
2409
with os.fdopen(tempfd, "wb") as stored_state:
2798
with (tempfile.NamedTemporaryFile
2799
(mode='wb', suffix=".pickle", prefix='clients-',
2800
dir=os.path.dirname(stored_state_path),
2801
delete=False)) as stored_state:
2410
2802
pickle.dump((clients, client_settings), stored_state)
2803
tempname=stored_state.name
2411
2804
os.rename(tempname, stored_state_path)
2412
2805
except (IOError, OSError) as e:
2413
logger.warning("Could not save persistent state: {0}"
2414
.format(e))
2415
2806
if not debug:
2416
2807
try:
2417
2808
os.remove(tempname)
2418
2809
except NameError:
2419
2810
pass
2420
if e.errno not in set((errno.ENOENT, errno.EACCES,
2421
errno.EEXIST)):
2422
raise e
2811
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2812
logger.warning("Could not save persistent state: {}"
2813
.format(os.strerror(e.errno)))
2814
else:
2815
logger.warning("Could not save persistent state:",
2816
exc_info=e)
2817
raise
2423
2818
2424
2819
# Delete all clients, and settings from config
2425
2820
while tcp_server.clients:
2449
2844
tcp_server.server_activate()
2450
2845
2451
2846
# Find out what port we got
2452
service.port = tcp_server.socket.getsockname()[1]
2847
if zeroconf:
2848
service.port = tcp_server.socket.getsockname()[1]
2453
2849
if use_ipv6:
2454
2850
logger.info("Now listening on address %r, port %d,"
2455
" flowinfo %d, scope_id %d"
2456
% tcp_server.socket.getsockname())
2851
" flowinfo %d, scope_id %d",
2852
*tcp_server.socket.getsockname())
2457
2853
else: # IPv4
2458
logger.info("Now listening on address %r, port %d"
2459
% tcp_server.socket.getsockname())
2854
logger.info("Now listening on address %r, port %d",
2855
*tcp_server.socket.getsockname())
2460
2856
2461
2857
#service.interface = tcp_server.socket.getsockname()[3]
2462
2858
2463
2859
try:
2464
# From the Avahi example code
2465
try:
2466
service.activate()
2467
except dbus.exceptions.DBusException as error:
2468
logger.critical("DBusException: %s", error)
2469
cleanup()
2470
sys.exit(1)
2471
# End of Avahi example code
2860
if zeroconf:
2861
# From the Avahi example code
2862
try:
2863
service.activate()
2864
except dbus.exceptions.DBusException as error:
2865
logger.critical("D-Bus Exception", exc_info=error)
2866
cleanup()
2867
sys.exit(1)
2868
# End of Avahi example code
2472
2869
2473
2870
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2474
2871
lambda *args, **kwargs:
2478
2875
logger.debug("Starting main loop")
2479
2876
main_loop.run()
2480
2877
except AvahiError as error:
2481
logger.critical("AvahiError: %s", error)
2878
logger.critical("Avahi Error", exc_info=error)
2482
2879
cleanup()
2483
2880
sys.exit(1)
2484
2881
except KeyboardInterrupt:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0