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.0"
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
422
444
secret: bytestring; sent verbatim (over TLS) to client
423
445
timeout: datetime.timedelta(); How long from last_checked_ok
424
446
until this client is disabled
425
extended_timeout: extra long timeout when password has been sent
447
extended_timeout: extra long timeout when secret has been sent
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):
1050
1240
self.bus = bus
1051
1241
Client.__init__(self, *args, **kwargs)
1052
self._approvals_pending = 0
1053
1054
self._approvals_pending = 0
1055
1242
# Only now, when this client is initialized, can it show up on
1056
1243
# the D-Bus
1057
client_object_name = unicode(self.name).translate(
1244
client_object_name = str(self.name).translate(
1058
1245
{ord("."): ord("_"),
1059
1246
ord("-"): ord("_")})
1060
1247
self.dbus_object_path = (dbus.ObjectPath
1061
1248
("/clients/" + client_object_name))
1062
1249
DBusObjectWithProperties.__init__(self, self.bus,
1063
1250
self.dbus_object_path)
1064
1251
1065
1252
def notifychangeproperty(transform_func,
1066
1253
dbus_name, type_func=lambda x: x,
1067
variant_level=1):
1254
variant_level=1, invalidate_only=False,
1255
_interface=_interface):
1068
1256
""" Modify a variable so that it's a property which announces
1069
1257
its changes to DBus.
1070
1258
1075
1263
to the D-Bus. Default: no transform
1076
1264
variant_level: D-Bus variant level. Default: 1
1077
1265
"""
1078
attrname = "_{0}".format(dbus_name)
1266
attrname = "_{}".format(dbus_name)
1079
1267
def setter(self, value):
1080
1268
if hasattr(self, "dbus_object_path"):
1081
1269
if (not hasattr(self, attrname) or
1082
1270
type_func(getattr(self, attrname, None))
1083
1271
!= type_func(value)):
1084
dbus_value = transform_func(type_func(value),
1085
variant_level
1086
=variant_level)
1087
self.PropertyChanged(dbus.String(dbus_name),
1088
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())
1089
1287
setattr(self, attrname, value)
1090
1288
1091
1289
return property(lambda self: getattr(self, attrname), setter)
1092
1290
1093
1094
1291
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1095
1292
approvals_pending = notifychangeproperty(dbus.Boolean,
1096
1293
"ApprovalPending",
1103
1300
checker is not None)
1104
1301
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1105
1302
"LastCheckedOK")
1303
last_checker_status = notifychangeproperty(dbus.Int16,
1304
"LastCheckerStatus")
1106
1305
last_approval_request = notifychangeproperty(
1107
1306
datetime_to_dbus, "LastApprovalRequest")
1108
1307
approved_by_default = notifychangeproperty(dbus.Boolean,
1110
1309
approval_delay = notifychangeproperty(dbus.UInt64,
1111
1310
"ApprovalDelay",
1112
1311
type_func =
1113
timedelta_to_milliseconds)
1312
lambda td: td.total_seconds()
1313
* 1000)
1114
1314
approval_duration = notifychangeproperty(
1115
1315
dbus.UInt64, "ApprovalDuration",
1116
type_func = timedelta_to_milliseconds)
1316
type_func = lambda td: td.total_seconds() * 1000)
1117
1317
host = notifychangeproperty(dbus.String, "Host")
1118
1318
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1119
type_func =
1120
timedelta_to_milliseconds)
1319
type_func = lambda td:
1320
td.total_seconds() * 1000)
1121
1321
extended_timeout = notifychangeproperty(
1122
1322
dbus.UInt64, "ExtendedTimeout",
1123
type_func = timedelta_to_milliseconds)
1323
type_func = lambda td: td.total_seconds() * 1000)
1124
1324
interval = notifychangeproperty(dbus.UInt64,
1125
1325
"Interval",
1126
1326
type_func =
1127
timedelta_to_milliseconds)
1327
lambda td: td.total_seconds()
1328
* 1000)
1128
1329
checker_command = notifychangeproperty(dbus.String, "Checker")
1330
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1331
invalidate_only=True)
1129
1332
1130
1333
del notifychangeproperty
1131
1334
1158
1361
*args, **kwargs)
1159
1362
1160
1363
def start_checker(self, *args, **kwargs):
1161
old_checker = self.checker
1162
if self.checker is not None:
1163
old_checker_pid = self.checker.pid
1164
else:
1165
old_checker_pid = None
1364
old_checker_pid = getattr(self.checker, "pid", None)
1166
1365
r = Client.start_checker(self, *args, **kwargs)
1167
1366
# Only if new checker process was started
1168
1367
if (self.checker is not None
1176
1375
return False
1177
1376
1178
1377
def approve(self, value=True):
1179
self.send_changedstate()
1180
1378
self.approved = value
1181
gobject.timeout_add(timedelta_to_milliseconds
1182
(self.approval_duration),
1183
self._reset_approved)
1184
1379
gobject.timeout_add(int(self.approval_duration.total_seconds()
1380
* 1000), self._reset_approved)
1381
self.send_changedstate()
1185
1382
1186
1383
## D-Bus methods, signals & properties
1187
_interface = "se.recompile.Mandos.Client"
1384
1385
## Interfaces
1188
1386
1189
1387
## Signals
1190
1388
1201
1399
pass
1202
1400
1203
1401
# PropertyChanged - signal
1402
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1204
1403
@dbus.service.signal(_interface, signature="sv")
1205
1404
def PropertyChanged(self, property, value):
1206
1405
"D-Bus signal"
1227
1426
"D-Bus signal"
1228
1427
return self.need_approval()
1229
1428
1230
# NeRwequest - signal
1231
@dbus.service.signal(_interface, signature="s")
1232
def NewRequest(self, ip):
1233
"""D-Bus signal
1234
Is sent after a client request a password.
1235
"""
1236
pass
1237
1238
1429
## Methods
1239
1430
1240
1431
# Approve - method
1290
1481
access="readwrite")
1291
1482
def ApprovalDelay_dbus_property(self, value=None):
1292
1483
if value is None: # get
1293
return dbus.UInt64(self.approval_delay_milliseconds())
1484
return dbus.UInt64(self.approval_delay.total_seconds()
1485
* 1000)
1294
1486
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1295
1487
1296
1488
# ApprovalDuration - property
1298
1490
access="readwrite")
1299
1491
def ApprovalDuration_dbus_property(self, value=None):
1300
1492
if value is None: # get
1301
return dbus.UInt64(timedelta_to_milliseconds(
1302
self.approval_duration))
1493
return dbus.UInt64(self.approval_duration.total_seconds()
1494
* 1000)
1303
1495
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1304
1496
1305
1497
# Name - property
1318
1510
def Host_dbus_property(self, value=None):
1319
1511
if value is None: # get
1320
1512
return dbus.String(self.host)
1321
self.host = unicode(value)
1513
self.host = str(value)
1322
1514
1323
1515
# Created - property
1324
1516
@dbus_service_property(_interface, signature="s", access="read")
1350
1542
return
1351
1543
return datetime_to_dbus(self.last_checked_ok)
1352
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
1353
1551
# Expires - property
1354
1552
@dbus_service_property(_interface, signature="s", access="read")
1355
1553
def Expires_dbus_property(self):
1365
1563
access="readwrite")
1366
1564
def Timeout_dbus_property(self, value=None):
1367
1565
if value is None: # get
1368
return dbus.UInt64(self.timeout_milliseconds())
1566
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1567
old_timeout = self.timeout
1369
1568
self.timeout = datetime.timedelta(0, 0, 0, value)
1370
# Reschedule timeout
1569
# Reschedule disabling
1371
1570
if self.enabled:
1372
1571
now = datetime.datetime.utcnow()
1373
time_to_die = timedelta_to_milliseconds(
1374
(self.last_checked_ok + self.timeout) - now)
1375
if time_to_die <= 0:
1572
self.expires += self.timeout - old_timeout
1573
if self.expires <= now:
1376
1574
# The timeout has passed
1377
1575
self.disable()
1378
1576
else:
1379
self.expires = (now +
1380
datetime.timedelta(milliseconds =
1381
time_to_die))
1382
1577
if (getattr(self, "disable_initiator_tag", None)
1383
1578
is None):
1384
1579
return
1385
1580
gobject.source_remove(self.disable_initiator_tag)
1386
self.disable_initiator_tag = (gobject.timeout_add
1387
(time_to_die,
1388
self.disable))
1581
self.disable_initiator_tag = (
1582
gobject.timeout_add(
1583
int((self.expires - now).total_seconds()
1584
* 1000), self.disable))
1389
1585
1390
1586
# ExtendedTimeout - property
1391
1587
@dbus_service_property(_interface, signature="t",
1392
1588
access="readwrite")
1393
1589
def ExtendedTimeout_dbus_property(self, value=None):
1394
1590
if value is None: # get
1395
return dbus.UInt64(self.extended_timeout_milliseconds())
1591
return dbus.UInt64(self.extended_timeout.total_seconds()
1592
* 1000)
1396
1593
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1397
1594
1398
1595
# Interval - property
1400
1597
access="readwrite")
1401
1598
def Interval_dbus_property(self, value=None):
1402
1599
if value is None: # get
1403
return dbus.UInt64(self.interval_milliseconds())
1600
return dbus.UInt64(self.interval.total_seconds() * 1000)
1404
1601
self.interval = datetime.timedelta(0, 0, 0, value)
1405
1602
if getattr(self, "checker_initiator_tag", None) is None:
1406
1603
return
1417
1614
def Checker_dbus_property(self, value=None):
1418
1615
if value is None: # get
1419
1616
return dbus.String(self.checker_command)
1420
self.checker_command = unicode(value)
1617
self.checker_command = str(value)
1421
1618
1422
1619
# CheckerRunning - property
1423
1620
@dbus_service_property(_interface, signature="b",
1439
1636
@dbus_service_property(_interface, signature="ay",
1440
1637
access="write", byte_arrays=True)
1441
1638
def Secret_dbus_property(self, value):
1442
self.secret = str(value)
1639
self.secret = bytes(value)
1443
1640
1444
1641
del _interface
1445
1642
1470
1667
self._pipe.send(('setattr', name, value))
1471
1668
1472
1669
1473
class ClientDBusTransitional(ClientDBus):
1474
__metaclass__ = AlternateDBusNamesMetaclass
1475
1476
1477
1670
class ClientHandler(socketserver.BaseRequestHandler, object):
1478
1671
"""A class to handle client connections.
1479
1672
1483
1676
def handle(self):
1484
1677
with contextlib.closing(self.server.child_pipe) as child_pipe:
1485
1678
logger.info("TCP connection from: %s",
1486
unicode(self.client_address))
1679
str(self.client_address))
1487
1680
logger.debug("Pipe FD: %d",
1488
1681
self.server.child_pipe.fileno())
1489
1682
1515
1708
logger.debug("Protocol version: %r", line)
1516
1709
try:
1517
1710
if int(line.strip().split()[0]) > 1:
1518
raise RuntimeError
1711
raise RuntimeError(line)
1519
1712
except (ValueError, IndexError, RuntimeError) as error:
1520
1713
logger.error("Unknown protocol version: %s", error)
1521
1714
return
1547
1740
except KeyError:
1548
1741
return
1549
1742
1550
if self.server.use_dbus:
1551
# Emit D-Bus signal
1552
client.NewRequest(str(self.client_address))
1553
1554
1743
if client.approval_delay:
1555
1744
delay = client.approval_delay
1556
1745
client.approvals_pending += 1
1574
1763
if self.server.use_dbus:
1575
1764
# Emit D-Bus signal
1576
1765
client.NeedApproval(
1577
client.approval_delay_milliseconds(),
1578
client.approved_by_default)
1766
client.approval_delay.total_seconds()
1767
* 1000, client.approved_by_default)
1579
1768
else:
1580
1769
logger.warning("Client %s was not approved",
1581
1770
client.name)
1587
1776
#wait until timeout or approved
1588
1777
time = datetime.datetime.now()
1589
1778
client.changedstate.acquire()
1590
(client.changedstate.wait
1591
(float(client.timedelta_to_milliseconds(delay)
1592
/ 1000)))
1779
client.changedstate.wait(delay.total_seconds())
1593
1780
client.changedstate.release()
1594
1781
time2 = datetime.datetime.now()
1595
1782
if (time2 - time) >= delay:
1611
1798
try:
1612
1799
sent = session.send(client.secret[sent_size:])
1613
1800
except gnutls.errors.GNUTLSError as error:
1614
logger.warning("gnutls send failed")
1801
logger.warning("gnutls send failed",
1802
exc_info=error)
1615
1803
return
1616
1804
logger.debug("Sent: %d, remaining: %d",
1617
1805
sent, len(client.secret)
1620
1808
1621
1809
logger.info("Sending secret to %s", client.name)
1622
1810
# bump the timeout using extended_timeout
1623
client.checked_ok(client.extended_timeout)
1811
client.bump_timeout(client.extended_timeout)
1624
1812
if self.server.use_dbus:
1625
1813
# Emit D-Bus signal
1626
1814
client.GotSecret()
1631
1819
try:
1632
1820
session.bye()
1633
1821
except gnutls.errors.GNUTLSError as error:
1634
logger.warning("GnuTLS bye failed")
1822
logger.warning("GnuTLS bye failed",
1823
exc_info=error)
1635
1824
1636
1825
@staticmethod
1637
1826
def peer_certificate(session):
1709
1898
def process_request(self, request, address):
1710
1899
"""Start a new process to process the request."""
1711
1900
proc = multiprocessing.Process(target = self.sub_process_main,
1712
args = (request,
1713
address))
1901
args = (request, address))
1714
1902
proc.start()
1715
1903
return proc
1716
1904
1731
1919
1732
1920
def add_pipe(self, parent_pipe, proc):
1733
1921
"""Dummy function; override as necessary"""
1734
raise NotImplementedError
1922
raise NotImplementedError()
1735
1923
1736
1924
1737
1925
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1744
1932
use_ipv6: Boolean; to use IPv6 or not
1745
1933
"""
1746
1934
def __init__(self, server_address, RequestHandlerClass,
1747
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
"""
1748
1939
self.interface = interface
1749
1940
if use_ipv6:
1750
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.
1751
1968
socketserver.TCPServer.__init__(self, server_address,
1752
1969
RequestHandlerClass)
1970
1753
1971
def server_bind(self):
1754
1972
"""This overrides the normal server_bind() function
1755
1973
to bind to an interface if one was specified, and also NOT to
1763
1981
try:
1764
1982
self.socket.setsockopt(socket.SOL_SOCKET,
1765
1983
SO_BINDTODEVICE,
1766
str(self.interface
1767
+ '\0'))
1984
(self.interface + "\0")
1985
.encode("utf-8"))
1768
1986
except socket.error as error:
1769
if error[0] == errno.EPERM:
1770
logger.error("No permission to"
1771
" bind to interface %s",
1772
self.interface)
1773
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:
1774
1991
logger.error("SO_BINDTODEVICE not available;"
1775
1992
" cannot bind to interface %s",
1776
1993
self.interface)
1994
elif error.errno == errno.ENODEV:
1995
logger.error("Interface %s does not exist,"
1996
" cannot bind", self.interface)
1777
1997
else:
1778
1998
raise
1779
1999
# Only bind(2) the socket if we really need to.
1782
2002
if self.address_family == socket.AF_INET6:
1783
2003
any_address = "::" # in6addr_any
1784
2004
else:
1785
any_address = socket.INADDR_ANY
2005
any_address = "0.0.0.0" # INADDR_ANY
1786
2006
self.server_address = (any_address,
1787
2007
self.server_address[1])
1788
2008
elif not self.server_address[1]:
1809
2029
"""
1810
2030
def __init__(self, server_address, RequestHandlerClass,
1811
2031
interface=None, use_ipv6=True, clients=None,
1812
gnutls_priority=None, use_dbus=True):
2032
gnutls_priority=None, use_dbus=True, socketfd=None):
1813
2033
self.enabled = False
1814
2034
self.clients = clients
1815
2035
if self.clients is None:
1819
2039
IPv6_TCPServer.__init__(self, server_address,
1820
2040
RequestHandlerClass,
1821
2041
interface = interface,
1822
use_ipv6 = use_ipv6)
2042
use_ipv6 = use_ipv6,
2043
socketfd = socketfd)
1823
2044
def server_activate(self):
1824
2045
if self.enabled:
1825
2046
return socketserver.TCPServer.server_activate(self)
1838
2059
1839
2060
def handle_ipc(self, source, condition, parent_pipe=None,
1840
2061
proc = None, client_object=None):
1841
condition_names = {
1842
gobject.IO_IN: "IN", # There is data to read.
1843
gobject.IO_OUT: "OUT", # Data can be written (without
1844
# blocking).
1845
gobject.IO_PRI: "PRI", # There is urgent data to read.
1846
gobject.IO_ERR: "ERR", # Error condition.
1847
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1848
# broken, usually for pipes and
1849
# sockets).
1850
}
1851
conditions_string = ' | '.join(name
1852
for cond, name in
1853
condition_names.iteritems()
1854
if cond & condition)
1855
2062
# error, or the other end of multiprocessing.Pipe has closed
1856
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2063
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1857
2064
# Wait for other process to exit
1858
2065
proc.join()
1859
2066
return False
1917
2124
return True
1918
2125
1919
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
1920
2226
def string_to_delta(interval):
1921
2227
"""Parse a string and return a datetime.timedelta
1922
2228
1933
2239
>>> string_to_delta('5m 30s')
1934
2240
datetime.timedelta(0, 330)
1935
2241
"""
2242
2243
try:
2244
return rfc3339_duration_to_delta(interval)
2245
except ValueError:
2246
pass
2247
1936
2248
timevalue = datetime.timedelta(0)
1937
2249
for s in interval.split():
1938
2250
try:
1939
suffix = unicode(s[-1])
2251
suffix = s[-1]
1940
2252
value = int(s[:-1])
1941
2253
if suffix == "d":
1942
2254
delta = datetime.timedelta(value)
1949
2261
elif suffix == "w":
1950
2262
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1951
2263
else:
1952
raise ValueError("Unknown suffix %r" % suffix)
1953
except (ValueError, IndexError) as e:
2264
raise ValueError("Unknown suffix {!r}"
2265
.format(suffix))
2266
except IndexError as e:
1954
2267
raise ValueError(*(e.args))
1955
2268
timevalue += delta
1956
2269
return timevalue
1969
2282
sys.exit()
1970
2283
if not noclose:
1971
2284
# Close all standard open file descriptors
1972
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2285
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1973
2286
if not stat.S_ISCHR(os.fstat(null).st_mode):
1974
raise OSError(errno.ENODEV,
1975
"%s not a character device"
1976
% os.path.devnull)
2287
raise OSError(errno.ENODEV, "{} not a character device"
2288
.format(os.devnull))
1977
2289
os.dup2(null, sys.stdin.fileno())
1978
2290
os.dup2(null, sys.stdout.fileno())
1979
2291
os.dup2(null, sys.stderr.fileno())
1988
2300
1989
2301
parser = argparse.ArgumentParser()
1990
2302
parser.add_argument("-v", "--version", action="version",
1991
version = "%%(prog)s %s" % version,
2303
version = "%(prog)s {}".format(version),
1992
2304
help="show version number and exit")
1993
2305
parser.add_argument("-i", "--interface", metavar="IF",
1994
2306
help="Bind to interface IF")
2000
2312
help="Run self-test")
2001
2313
parser.add_argument("--debug", action="store_true",
2002
2314
help="Debug mode; run in foreground and log"
2003
" to terminal")
2315
" to terminal", default=None)
2004
2316
parser.add_argument("--debuglevel", metavar="LEVEL",
2005
2317
help="Debug level for stdout output")
2006
2318
parser.add_argument("--priority", help="GnuTLS"
2013
2325
" files")
2014
2326
parser.add_argument("--no-dbus", action="store_false",
2015
2327
dest="use_dbus", help="Do not provide D-Bus"
2016
" system bus interface")
2328
" system bus interface", default=None)
2017
2329
parser.add_argument("--no-ipv6", action="store_false",
2018
dest="use_ipv6", help="Do not use IPv6")
2330
dest="use_ipv6", help="Do not use IPv6",
2331
default=None)
2019
2332
parser.add_argument("--no-restore", action="store_false",
2020
2333
dest="restore", help="Do not restore stored"
2021
" 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")
2022
2338
parser.add_argument("--statedir", metavar="DIR",
2023
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)
2024
2345
2025
2346
options = parser.parse_args()
2026
2347
2027
2348
if options.check:
2028
2349
import doctest
2029
doctest.testmod()
2030
sys.exit()
2350
fail_count, test_count = doctest.testmod()
2351
sys.exit(os.EX_OK if fail_count == 0 else 1)
2031
2352
2032
2353
# Default values for config file for server-global settings
2033
2354
server_defaults = { "interface": "",
2035
2356
"port": "",
2036
2357
"debug": "False",
2037
2358
"priority":
2038
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2359
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2360
":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2039
2361
"servicename": "Mandos",
2040
2362
"use_dbus": "True",
2041
2363
"use_ipv6": "True",
2042
2364
"debuglevel": "",
2043
2365
"restore": "True",
2044
"statedir": "/var/lib/mandos"
2366
"socket": "",
2367
"statedir": "/var/lib/mandos",
2368
"foreground": "False",
2369
"zeroconf": "True",
2045
2370
}
2046
2371
2047
2372
# Parse config file for server-global settings
2052
2377
# Convert the SafeConfigParser object to a dict
2053
2378
server_settings = server_config.defaults()
2054
2379
# Use the appropriate methods on the non-string config options
2055
for option in ("debug", "use_dbus", "use_ipv6"):
2380
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2056
2381
server_settings[option] = server_config.getboolean("DEFAULT",
2057
2382
option)
2058
2383
if server_settings["port"]:
2059
2384
server_settings["port"] = server_config.getint("DEFAULT",
2060
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"])
2061
2395
del server_config
2062
2396
2063
2397
# Override the settings from the config file with command line
2065
2399
for option in ("interface", "address", "port", "debug",
2066
2400
"priority", "servicename", "configdir",
2067
2401
"use_dbus", "use_ipv6", "debuglevel", "restore",
2068
"statedir"):
2402
"statedir", "socket", "foreground", "zeroconf"):
2069
2403
value = getattr(options, option)
2070
2404
if value is not None:
2071
2405
server_settings[option] = value
2072
2406
del options
2073
2407
# Force all strings to be unicode
2074
2408
for option in server_settings.keys():
2075
if type(server_settings[option]) is str:
2076
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
2077
2419
# Now we have our good server settings in "server_settings"
2078
2420
2079
2421
##################################################################
2080
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
2081
2429
# For convenience
2082
2430
debug = server_settings["debug"]
2083
2431
debuglevel = server_settings["debuglevel"]
2085
2433
use_ipv6 = server_settings["use_ipv6"]
2086
2434
stored_state_path = os.path.join(server_settings["statedir"],
2087
2435
stored_state_file)
2436
foreground = server_settings["foreground"]
2437
zeroconf = server_settings["zeroconf"]
2088
2438
2089
2439
if debug:
2090
2440
initlogger(debug, logging.DEBUG)
2097
2447
2098
2448
if server_settings["servicename"] != "Mandos":
2099
2449
syslogger.setFormatter(logging.Formatter
2100
('Mandos (%s) [%%(process)d]:'
2101
' %%(levelname)s: %%(message)s'
2102
% server_settings["servicename"]))
2450
('Mandos ({}) [%(process)d]:'
2451
' %(levelname)s: %(message)s'
2452
.format(server_settings
2453
["servicename"])))
2103
2454
2104
2455
# Parse config file with clients
2105
2456
client_config = configparser.SafeConfigParser(Client
2110
2461
global mandos_dbus_service
2111
2462
mandos_dbus_service = None
2112
2463
2464
socketfd = None
2465
if server_settings["socket"] != "":
2466
socketfd = server_settings["socket"]
2113
2467
tcp_server = MandosServer((server_settings["address"],
2114
2468
server_settings["port"]),
2115
2469
ClientHandler,
2118
2472
use_ipv6=use_ipv6,
2119
2473
gnutls_priority=
2120
2474
server_settings["priority"],
2121
use_dbus=use_dbus)
2122
if not debug:
2123
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
2124
2482
try:
2125
2483
pidfile = open(pidfilename, "w")
2126
except IOError:
2127
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)
2128
2487
2129
try:
2130
uid = pwd.getpwnam("_mandos").pw_uid
2131
gid = pwd.getpwnam("_mandos").pw_gid
2132
except KeyError:
2488
for name in ("_mandos", "mandos", "nobody"):
2133
2489
try:
2134
uid = pwd.getpwnam("mandos").pw_uid
2135
gid = pwd.getpwnam("mandos").pw_gid
2490
uid = pwd.getpwnam(name).pw_uid
2491
gid = pwd.getpwnam(name).pw_gid
2492
break
2136
2493
except KeyError:
2137
try:
2138
uid = pwd.getpwnam("nobody").pw_uid
2139
gid = pwd.getpwnam("nobody").pw_gid
2140
except KeyError:
2141
uid = 65534
2142
gid = 65534
2494
continue
2495
else:
2496
uid = 65534
2497
gid = 65534
2143
2498
try:
2144
2499
os.setgid(gid)
2145
2500
os.setuid(uid)
2146
2501
except OSError as error:
2147
if error[0] != errno.EPERM:
2148
raise error
2502
if error.errno != errno.EPERM:
2503
raise
2149
2504
2150
2505
if debug:
2151
2506
# Enable all possible GnuTLS debugging
2162
2517
.gnutls_global_set_log_function(debug_gnutls))
2163
2518
2164
2519
# Redirect stdin so all checkers get /dev/null
2165
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2520
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2166
2521
os.dup2(null, sys.stdin.fileno())
2167
2522
if null > 2:
2168
2523
os.close(null)
2169
2524
2170
2525
# Need to fork before connecting to D-Bus
2171
if not debug:
2526
if not foreground:
2172
2527
# Close all input and output, do double fork, etc.
2173
2528
daemon()
2174
2529
2530
# multiprocessing will use threads, so before we use gobject we
2531
# need to inform gobject that threads will be used.
2175
2532
gobject.threads_init()
2176
2533
2177
2534
global main_loop
2178
2535
# From the Avahi example code
2179
DBusGMainLoop(set_as_default=True )
2536
DBusGMainLoop(set_as_default=True)
2180
2537
main_loop = gobject.MainLoop()
2181
2538
bus = dbus.SystemBus()
2182
2539
# End of Avahi example code
2188
2545
("se.bsnet.fukt.Mandos", bus,
2189
2546
do_not_queue=True))
2190
2547
except dbus.exceptions.NameExistsException as e:
2191
logger.error(unicode(e) + ", disabling D-Bus")
2548
logger.error("Disabling D-Bus:", exc_info=e)
2192
2549
use_dbus = False
2193
2550
server_settings["use_dbus"] = False
2194
2551
tcp_server.use_dbus = False
2195
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2196
service = AvahiServiceToSyslog(name =
2197
server_settings["servicename"],
2198
servicetype = "_mandos._tcp",
2199
protocol = protocol, bus = bus)
2200
if server_settings["interface"]:
2201
service.interface = (if_nametoindex
2202
(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")))
2203
2562
2204
2563
global multiprocessing_manager
2205
2564
multiprocessing_manager = multiprocessing.Manager()
2206
2565
2207
2566
client_class = Client
2208
2567
if use_dbus:
2209
client_class = functools.partial(ClientDBusTransitional,
2210
bus = bus)
2568
client_class = functools.partial(ClientDBus, bus = bus)
2211
2569
2212
2570
client_settings = Client.config_parser(client_config)
2213
2571
old_client_settings = {}
2214
2572
clients_data = {}
2215
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
2216
2582
# Get client data and settings from last running state.
2217
2583
if server_settings["restore"]:
2218
2584
try:
2221
2587
(stored_state))
2222
2588
os.remove(stored_state_path)
2223
2589
except IOError as e:
2224
logger.warning("Could not load persistent state: {0}"
2225
.format(e))
2226
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)
2227
2596
raise
2228
2597
except EOFError as e:
2229
2598
logger.warning("Could not load persistent state: "
2230
"EOFError: {0}".format(e))
2599
"EOFError:", exc_info=e)
2231
2600
2232
2601
with PGPEngine() as pgp:
2233
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
2234
2607
# Decide which value to use after restoring saved state.
2235
2608
# We have three different values: Old config file,
2236
2609
# new config file, and saved state.
2250
2623
2251
2624
# Clients who has passed its expire date can still be
2252
2625
# enabled if its last checker was successful. Clients
2253
# whose checker failed before we stored its state is
2254
# assumed to have failed all checkers during downtime.
2626
# whose checker succeeded before we stored its state is
2627
# assumed to have successfully run all checkers during
2628
# downtime.
2255
2629
if client["enabled"]:
2256
2630
if datetime.datetime.utcnow() >= client["expires"]:
2257
2631
if not client["last_checked_ok"]:
2258
2632
logger.warning(
2259
"disabling client {0} - Client never "
2260
"performed a successfull checker"
2261
.format(client["name"]))
2633
"disabling client {} - Client never "
2634
"performed a successful checker"
2635
.format(client_name))
2262
2636
client["enabled"] = False
2263
2637
elif client["last_checker_status"] != 0:
2264
2638
logger.warning(
2265
"disabling client {0} - Client "
2266
"last checker failed with error code {1}"
2267
.format(client["name"],
2639
"disabling client {} - Client last"
2640
" checker failed with error code {}"
2641
.format(client_name,
2268
2642
client["last_checker_status"]))
2269
2643
client["enabled"] = False
2270
2644
else:
2272
2646
.utcnow()
2273
2647
+ client["timeout"])
2274
2648
logger.debug("Last checker succeeded,"
2275
" keeping {0} enabled"
2276
.format(client["name"]))
2649
" keeping {} enabled"
2650
.format(client_name))
2277
2651
try:
2278
2652
client["secret"] = (
2279
2653
pgp.decrypt(client["encrypted_secret"],
2281
2655
["secret"]))
2282
2656
except PGPError:
2283
2657
# If decryption fails, we use secret from new settings
2284
logger.debug("Failed to decrypt {0} old secret"
2658
logger.debug("Failed to decrypt {} old secret"
2285
2659
.format(client_name))
2286
2660
client["secret"] = (
2287
2661
client_settings[client_name]["secret"])
2288
2289
2662
2290
2663
# Add/remove clients based on new changes made to config
2291
2664
for client_name in (set(old_client_settings)
2294
2667
for client_name in (set(client_settings)
2295
2668
- set(old_client_settings)):
2296
2669
clients_data[client_name] = client_settings[client_name]
2297
2298
# Create clients all clients
2299
for client_name, client in clients_data.iteritems():
2670
2671
# Create all client objects
2672
for client_name, client in clients_data.items():
2300
2673
tcp_server.clients[client_name] = client_class(
2301
name = client_name, settings = client)
2674
name = client_name, settings = client,
2675
server_settings = server_settings)
2302
2676
2303
2677
if not tcp_server.clients:
2304
2678
logger.warning("No clients defined")
2305
2306
if not debug:
2307
try:
2308
with pidfile:
2309
pid = os.getpid()
2310
pidfile.write(str(pid) + "\n".encode("utf-8"))
2311
del pidfile
2312
except IOError:
2313
logger.error("Could not write to file %r with PID %d",
2314
pidfilename, pid)
2315
except NameError:
2316
# "pidfile" was never created
2317
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
2318
2690
del pidfilename
2319
signal.signal(signal.SIGINT, signal.SIG_IGN)
2320
2691
2321
2692
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2322
2693
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2323
2694
2324
2695
if use_dbus:
2325
class MandosDBusService(dbus.service.Object):
2696
@alternate_dbus_interfaces({"se.recompile.Mandos":
2697
"se.bsnet.fukt.Mandos"})
2698
class MandosDBusService(DBusObjectWithProperties):
2326
2699
"""A D-Bus proxy object"""
2327
2700
def __init__(self):
2328
2701
dbus.service.Object.__init__(self, bus, "/")
2329
2702
_interface = "se.recompile.Mandos"
2330
2703
2704
@dbus_interface_annotations(_interface)
2705
def _foo(self):
2706
return { "org.freedesktop.DBus.Property"
2707
".EmitsChangedSignal":
2708
"false"}
2709
2331
2710
@dbus.service.signal(_interface, signature="o")
2332
2711
def ClientAdded(self, objpath):
2333
2712
"D-Bus signal"
2355
2734
def GetAllClientsWithProperties(self):
2356
2735
"D-Bus method"
2357
2736
return dbus.Dictionary(
2358
((c.dbus_object_path, c.GetAll(""))
2359
for c in tcp_server.clients.itervalues()),
2737
{ c.dbus_object_path: c.GetAll("")
2738
for c in tcp_server.clients.itervalues() },
2360
2739
signature="oa{sv}")
2361
2740
2362
2741
@dbus.service.method(_interface, in_signature="o")
2375
2754
2376
2755
del _interface
2377
2756
2378
class MandosDBusServiceTransitional(MandosDBusService):
2379
__metaclass__ = AlternateDBusNamesMetaclass
2380
mandos_dbus_service = MandosDBusServiceTransitional()
2757
mandos_dbus_service = MandosDBusService()
2381
2758
2382
2759
def cleanup():
2383
2760
"Cleanup function; run on exit"
2384
service.cleanup()
2761
if zeroconf:
2762
service.cleanup()
2385
2763
2386
2764
multiprocessing.active_children()
2765
wnull.close()
2387
2766
if not (tcp_server.clients or client_settings):
2388
2767
return
2389
2768
2400
2779
2401
2780
# A list of attributes that can not be pickled
2402
2781
# + secret.
2403
exclude = set(("bus", "changedstate", "secret",
2404
"checker"))
2782
exclude = { "bus", "changedstate", "secret",
2783
"checker", "server_settings" }
2405
2784
for name, typ in (inspect.getmembers
2406
2785
(dbus.service.Object)):
2407
2786
exclude.add(name)
2416
2795
del client_settings[client.name]["secret"]
2417
2796
2418
2797
try:
2419
tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2420
prefix="clients-",
2421
dir=os.path.dirname
2422
(stored_state_path))
2423
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:
2424
2802
pickle.dump((clients, client_settings), stored_state)
2803
tempname=stored_state.name
2425
2804
os.rename(tempname, stored_state_path)
2426
2805
except (IOError, OSError) as e:
2427
logger.warning("Could not save persistent state: {0}"
2428
.format(e))
2429
2806
if not debug:
2430
2807
try:
2431
2808
os.remove(tempname)
2432
2809
except NameError:
2433
2810
pass
2434
if e.errno not in set((errno.ENOENT, errno.EACCES,
2435
errno.EEXIST)):
2436
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
2437
2818
2438
2819
# Delete all clients, and settings from config
2439
2820
while tcp_server.clients:
2463
2844
tcp_server.server_activate()
2464
2845
2465
2846
# Find out what port we got
2466
service.port = tcp_server.socket.getsockname()[1]
2847
if zeroconf:
2848
service.port = tcp_server.socket.getsockname()[1]
2467
2849
if use_ipv6:
2468
2850
logger.info("Now listening on address %r, port %d,"
2469
" flowinfo %d, scope_id %d"
2470
% tcp_server.socket.getsockname())
2851
" flowinfo %d, scope_id %d",
2852
*tcp_server.socket.getsockname())
2471
2853
else: # IPv4
2472
logger.info("Now listening on address %r, port %d"
2473
% tcp_server.socket.getsockname())
2854
logger.info("Now listening on address %r, port %d",
2855
*tcp_server.socket.getsockname())
2474
2856
2475
2857
#service.interface = tcp_server.socket.getsockname()[3]
2476
2858
2477
2859
try:
2478
# From the Avahi example code
2479
try:
2480
service.activate()
2481
except dbus.exceptions.DBusException as error:
2482
logger.critical("DBusException: %s", error)
2483
cleanup()
2484
sys.exit(1)
2485
# 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
2486
2869
2487
2870
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2488
2871
lambda *args, **kwargs:
2492
2875
logger.debug("Starting main loop")
2493
2876
main_loop.run()
2494
2877
except AvahiError as error:
2495
logger.critical("AvahiError: %s", error)
2878
logger.critical("Avahi Error", exc_info=error)
2496
2879
cleanup()
2497
2880
sys.exit(1)
2498
2881
except KeyboardInterrupt:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0