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 549
- compare with another revision
- download diff
- download tarball
- view history from revision 549
- Committer: teddy at recompile
- Date: 2012-01-01 17:38:33 UTC
- Revision ID: teddy@recompile.se-20120101173833-ai39bif1w0ftuyyh
* Makefile (install-server): Add intro(8mandos) man page.
* network-hooks.d/bridge: Add copyright info and year.
* network-hooks.d/openvpn: - '' -
* network-hooks.d/wireless: - '' -
* network-hooks.d/bridge: Add copyright info and year.
* network-hooks.d/openvpn: - '' -
* network-hooks.d/wireless: - '' -
- files removed:
- debian/mandos-client.examples
- debian/upstream
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python2.7
1
#!/usr/bin/python
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-2014 Teddy Hogeborn
15
# Copyright © 2008-2014 Björn Påhlsson
14
# Copyright © 2008-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 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
39
37
import SocketServer as socketserver
40
38
import socket
41
39
import argparse
67
65
import types
68
66
import binascii
69
67
import tempfile
70
import itertools
71
import collections
72
68
73
69
import dbus
74
70
import dbus.service
79
75
import ctypes.util
80
76
import xml.dom.minidom
81
77
import inspect
78
import GnuPGInterface
82
79
83
80
try:
84
81
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
85
except ImportError:
89
86
SO_BINDTODEVICE = None
90
87
91
if sys.version_info.major == 2:
92
str = unicode
93
94
version = "1.6.8"
88
version = "1.5.0"
95
89
stored_state_file = "clients.pickle"
96
90
97
91
logger = logging.getLogger()
98
syslogger = None
92
syslogger = (logging.handlers.SysLogHandler
93
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
address = str("/dev/log")))
99
95
100
96
try:
101
97
if_nametoindex = (ctypes.cdll.LoadLibrary
107
103
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
108
104
with contextlib.closing(socket.socket()) as s:
109
105
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
110
struct.pack(b"16s16x", interface))
111
interface_index = struct.unpack("I", ifreq[16:20])[0]
106
struct.pack(str("16s16x"),
107
interface))
108
interface_index = struct.unpack(str("I"),
109
ifreq[16:20])[0]
112
110
return interface_index
113
111
114
112
115
113
def initlogger(debug, level=logging.WARNING):
116
114
"""init logger and add loglevel"""
117
115
118
global syslogger
119
syslogger = (logging.handlers.SysLogHandler
120
(facility =
121
logging.handlers.SysLogHandler.LOG_DAEMON,
122
address = "/dev/log"))
123
116
syslogger.setFormatter(logging.Formatter
124
117
('Mandos [%(process)d]: %(levelname)s:'
125
118
' %(message)s'))
143
136
class PGPEngine(object):
144
137
"""A simple class for OpenPGP symmetric encryption & decryption"""
145
138
def __init__(self):
139
self.gnupg = GnuPGInterface.GnuPG()
146
140
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
147
self.gnupgargs = ['--batch',
148
'--home', self.tempdir,
149
'--force-mdc',
150
'--quiet',
151
'--no-use-agent']
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'])
152
147
153
148
def __enter__(self):
154
149
return self
155
150
156
def __exit__(self, exc_type, exc_value, traceback):
151
def __exit__ (self, exc_type, exc_value, traceback):
157
152
self._cleanup()
158
153
return False
159
154
176
171
def password_encode(self, password):
177
172
# Passphrase can not be empty and can not contain newlines or
178
173
# NUL bytes. So we prefix it and hex encode it.
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
174
return b"mandos" + binascii.hexlify(password)
186
175
187
176
def encrypt(self, data, password):
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)
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
203
191
return ciphertext
204
192
205
193
def decrypt(self, data, password):
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)
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
222
208
return decrypted_plaintext
223
209
224
210
211
225
212
class AvahiError(Exception):
226
213
def __init__(self, value, *args, **kwargs):
227
214
self.value = value
228
return super(AvahiError, self).__init__(value, *args,
229
**kwargs)
215
super(AvahiError, self).__init__(value, *args, **kwargs)
216
def __unicode__(self):
217
return unicode(repr(self.value))
230
218
231
219
class AvahiServiceError(AvahiError):
232
220
pass
243
231
Used to optionally bind to the specified interface.
244
232
name: string; Example: 'Mandos'
245
233
type: string; Example: '_mandos._tcp'.
246
See <https://www.iana.org/assignments/service-names-port-numbers>
234
See <http://www.dns-sd.org/ServiceTypes.html>
247
235
port: integer; what port to announce
248
236
TXT: list of strings; TXT record for the service
249
237
domain: string; Domain to publish on, default to .local if empty.
255
243
server: D-Bus Server
256
244
bus: dbus.SystemBus()
257
245
"""
258
259
246
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
260
247
servicetype = None, port = None, TXT = None,
261
248
domain = "", host = "", max_renames = 32768,
274
261
self.server = None
275
262
self.bus = bus
276
263
self.entry_group_state_changed_match = None
277
278
264
def rename(self):
279
265
"""Derived from the Avahi example code"""
280
266
if self.rename_count >= self.max_renames:
282
268
" after %i retries, exiting.",
283
269
self.rename_count)
284
270
raise AvahiServiceError("Too many renames")
285
self.name = str(self.server
286
.GetAlternativeServiceName(self.name))
271
self.name = unicode(self.server
272
.GetAlternativeServiceName(self.name))
287
273
logger.info("Changing Zeroconf service name to %r ...",
288
274
self.name)
289
275
self.remove()
290
276
try:
291
277
self.add()
292
278
except dbus.exceptions.DBusException as error:
293
logger.critical("D-Bus Exception", exc_info=error)
279
logger.critical("DBusException: %s", error)
294
280
self.cleanup()
295
281
os._exit(1)
296
282
self.rename_count += 1
297
298
283
def remove(self):
299
284
"""Derived from the Avahi example code"""
300
285
if self.entry_group_state_changed_match is not None:
302
287
self.entry_group_state_changed_match = None
303
288
if self.group is not None:
304
289
self.group.Reset()
305
306
290
def add(self):
307
291
"""Derived from the Avahi example code"""
308
292
self.remove()
325
309
dbus.UInt16(self.port),
326
310
avahi.string_array_to_txt_array(self.TXT))
327
311
self.group.Commit()
328
329
312
def entry_group_state_changed(self, state, error):
330
313
"""Derived from the Avahi example code"""
331
314
logger.debug("Avahi entry group state change: %i", state)
337
320
self.rename()
338
321
elif state == avahi.ENTRY_GROUP_FAILURE:
339
322
logger.critical("Avahi: Error in group state changed %s",
340
str(error))
341
raise AvahiGroupError("State changed: {!s}"
342
.format(error))
343
323
unicode(error))
324
raise AvahiGroupError("State changed: %s"
325
% unicode(error))
344
326
def cleanup(self):
345
327
"""Derived from the Avahi example code"""
346
328
if self.group is not None:
351
333
pass
352
334
self.group = None
353
335
self.remove()
354
355
336
def server_state_changed(self, state, error=None):
356
337
"""Derived from the Avahi example code"""
357
338
logger.debug("Avahi server state change: %i", state)
376
357
logger.debug("Unknown state: %r", state)
377
358
else:
378
359
logger.debug("Unknown state: %r: %r", state, error)
379
380
360
def activate(self):
381
361
"""Derived from the Avahi example code"""
382
362
if self.server is None:
389
369
self.server_state_changed)
390
370
self.server_state_changed(self.server.GetState())
391
371
392
393
372
class AvahiServiceToSyslog(AvahiService):
394
373
def rename(self):
395
374
"""Add the new name to the syslog messages"""
396
375
ret = AvahiService.rename(self)
397
376
syslogger.setFormatter(logging.Formatter
398
('Mandos ({}) [%(process)d]:'
399
' %(levelname)s: %(message)s'
400
.format(self.name)))
377
('Mandos (%s) [%%(process)d]:'
378
' %%(levelname)s: %%(message)s'
379
% self.name))
401
380
return ret
402
381
403
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
404
388
class Client(object):
405
389
"""A representation of a client host served by this server.
406
390
431
415
last_checked_ok: datetime.datetime(); (UTC) or None
432
416
last_checker_status: integer between 0 and 255 reflecting exit
433
417
status of last checker. -1 reflects crashed
434
checker, -2 means no checker completed yet.
418
checker, or None.
435
419
last_enabled: datetime.datetime(); (UTC) or None
436
420
name: string; from the config file, used in log messages and
437
421
D-Bus identifiers
438
422
secret: bytestring; sent verbatim (over TLS) to client
439
423
timeout: datetime.timedelta(); How long from last_checked_ok
440
424
until this client is disabled
441
extended_timeout: extra long timeout when secret has been sent
425
extended_timeout: extra long timeout when password has been sent
442
426
runtime_expansions: Allowed attributes for runtime expansion.
443
427
expires: datetime.datetime(); time (UTC) when a client will be
444
428
disabled, or None
445
server_settings: The server_settings dict from main()
446
429
"""
447
430
448
431
runtime_expansions = ("approval_delay", "approval_duration",
449
"created", "enabled", "expires",
450
"fingerprint", "host", "interval",
451
"last_approval_request", "last_checked_ok",
432
"created", "enabled", "fingerprint",
433
"host", "interval", "last_checked_ok",
452
434
"last_enabled", "name", "timeout")
453
client_defaults = { "timeout": "PT5M",
454
"extended_timeout": "PT15M",
455
"interval": "PT2M",
435
client_defaults = { "timeout": "5m",
436
"extended_timeout": "15m",
437
"interval": "2m",
456
438
"checker": "fping -q -- %%(host)s",
457
439
"host": "",
458
"approval_delay": "PT0S",
459
"approval_duration": "PT1S",
440
"approval_delay": "0s",
441
"approval_duration": "1s",
460
442
"approved_by_default": "True",
461
443
"enabled": "True",
462
444
}
463
445
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
464
461
@staticmethod
465
462
def config_parser(config):
466
463
"""Construct a new dict of client settings of this form:
491
488
"rb") as secfile:
492
489
client["secret"] = secfile.read()
493
490
else:
494
raise TypeError("No secret or secfile for section {}"
495
.format(section))
491
raise TypeError("No secret or secfile for section %s"
492
% section)
496
493
client["timeout"] = string_to_delta(section["timeout"])
497
494
client["extended_timeout"] = string_to_delta(
498
495
section["extended_timeout"])
504
501
client["checker_command"] = section["checker"]
505
502
client["last_approval_request"] = None
506
503
client["last_checked_ok"] = None
507
client["last_checker_status"] = -2
504
client["last_checker_status"] = None
508
505
509
506
return settings
510
511
def __init__(self, settings, name = None, server_settings=None):
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."""
512
513
self.name = name
513
if server_settings is None:
514
server_settings = {}
515
self.server_settings = server_settings
516
514
# adding all client settings
517
for setting, value in settings.items():
515
for setting, value in settings.iteritems():
518
516
setattr(self, setting, value)
519
517
520
518
if self.enabled:
526
524
else:
527
525
self.last_enabled = None
528
526
self.expires = None
529
527
530
528
logger.debug("Creating client %r", self.name)
531
529
# Uppercase and remove spaces from fingerprint for later
532
530
# comparison purposes with return value from the fingerprint()
534
532
logger.debug(" Fingerprint: %s", self.fingerprint)
535
533
self.created = settings.get("created",
536
534
datetime.datetime.utcnow())
537
535
538
536
# attributes specific for this server instance
539
537
self.checker = None
540
538
self.checker_initiator_tag = None
568
566
if getattr(self, "enabled", False):
569
567
# Already enabled
570
568
return
569
self.send_changedstate()
571
570
self.expires = datetime.datetime.utcnow() + self.timeout
572
571
self.enabled = True
573
572
self.last_enabled = datetime.datetime.utcnow()
574
573
self.init_checker()
575
self.send_changedstate()
576
574
577
575
def disable(self, quiet=True):
578
576
"""Disable this client."""
579
577
if not getattr(self, "enabled", False):
580
578
return False
581
579
if not quiet:
580
self.send_changedstate()
581
if not quiet:
582
582
logger.info("Disabling client %s", self.name)
583
if getattr(self, "disable_initiator_tag", None) is not None:
583
if getattr(self, "disable_initiator_tag", False):
584
584
gobject.source_remove(self.disable_initiator_tag)
585
585
self.disable_initiator_tag = None
586
586
self.expires = None
587
if getattr(self, "checker_initiator_tag", None) is not None:
587
if getattr(self, "checker_initiator_tag", False):
588
588
gobject.source_remove(self.checker_initiator_tag)
589
589
self.checker_initiator_tag = None
590
590
self.stop_checker()
591
591
self.enabled = False
592
if not quiet:
593
self.send_changedstate()
594
592
# Do not run this again if called by a gobject.timeout_add
595
593
return False
596
594
600
598
def init_checker(self):
601
599
# Schedule a new checker to be started an 'interval' from now,
602
600
# and every interval from then on.
603
if self.checker_initiator_tag is not None:
604
gobject.source_remove(self.checker_initiator_tag)
605
601
self.checker_initiator_tag = (gobject.timeout_add
606
(int(self.interval
607
.total_seconds() * 1000),
602
(self.interval_milliseconds(),
608
603
self.start_checker))
609
604
# Schedule a disable() when 'timeout' has passed
610
if self.disable_initiator_tag is not None:
611
gobject.source_remove(self.disable_initiator_tag)
612
605
self.disable_initiator_tag = (gobject.timeout_add
613
(int(self.timeout
614
.total_seconds() * 1000),
615
self.disable))
606
(self.timeout_milliseconds(),
607
self.disable))
616
608
# Also start a new checker *right now*.
617
609
self.start_checker()
618
610
634
626
logger.warning("Checker for %(name)s crashed?",
635
627
vars(self))
636
628
637
def checked_ok(self):
638
"""Assert that the client has been seen, alive and well."""
639
self.last_checked_ok = datetime.datetime.utcnow()
640
self.last_checker_status = 0
641
self.bump_timeout()
642
643
def bump_timeout(self, timeout=None):
644
"""Bump up the timeout for this client."""
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
"""
645
635
if timeout is None:
646
636
timeout = self.timeout
637
self.last_checked_ok = datetime.datetime.utcnow()
647
638
if self.disable_initiator_tag is not None:
648
639
gobject.source_remove(self.disable_initiator_tag)
649
self.disable_initiator_tag = None
650
640
if getattr(self, "enabled", False):
651
641
self.disable_initiator_tag = (gobject.timeout_add
652
(int(timeout.total_seconds()
653
* 1000), self.disable))
642
(timedelta_to_milliseconds
643
(timeout), self.disable))
654
644
self.expires = datetime.datetime.utcnow() + timeout
655
645
656
646
def need_approval(self):
662
652
If a checker already exists, leave it running and do
663
653
nothing."""
664
654
# The reason for not killing a running checker is that if we
665
# did that, and if a checker (for some reason) started running
666
# slowly and taking more than 'interval' time, then the client
667
# would inevitably timeout, since no checker would get a
668
# chance to run to completion. If we instead leave running
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
669
659
# checkers alone, the checker would have to take more time
670
660
# than 'timeout' for the client to be disabled, which is as it
671
661
# should be.
673
663
# If a checker exists, make sure it is not a zombie
674
664
try:
675
665
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
676
except AttributeError:
677
pass
678
except OSError as error:
679
if error.errno != errno.ECHILD:
680
raise
666
except (AttributeError, OSError) as error:
667
if (isinstance(error, OSError)
668
and error.errno != errno.ECHILD):
669
raise error
681
670
else:
682
671
if pid:
683
672
logger.warning("Checker was a zombie")
686
675
self.current_checker_command)
687
676
# Start a new checker if needed
688
677
if self.checker is None:
689
# Escape attributes for the shell
690
escaped_attrs = { attr:
691
re.escape(str(getattr(self, attr)))
692
for attr in self.runtime_expansions }
693
678
try:
694
command = self.checker_command % escaped_attrs
695
except TypeError as error:
696
logger.error('Could not format string "%s"',
697
self.checker_command, exc_info=error)
698
return True # Try again later
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
699
697
self.current_checker_command = command
700
698
try:
701
699
logger.info("Starting checker %r for %s",
704
702
# in normal mode, that is already done by daemon(),
705
703
# and in debug mode we don't want to. (Stdin is
706
704
# always replaced by /dev/null.)
707
# The exception is when not debugging but nevertheless
708
# running in the foreground; use the previously
709
# created wnull.
710
popen_args = {}
711
if (not self.server_settings["debug"]
712
and self.server_settings["foreground"]):
713
popen_args.update({"stdout": wnull,
714
"stderr": wnull })
715
705
self.checker = subprocess.Popen(command,
716
706
close_fds=True,
717
shell=True, cwd="/",
718
**popen_args)
719
except OSError as error:
720
logger.error("Failed to start subprocess",
721
exc_info=error)
722
return True
723
self.checker_callback_tag = (gobject.child_watch_add
724
(self.checker.pid,
725
self.checker_callback,
726
data=command))
727
# The checker may have completed before the gobject
728
# watch was added. Check for this.
729
try:
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.
730
714
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)
731
718
except OSError as error:
732
if error.errno == errno.ECHILD:
733
# This should never happen
734
logger.error("Child process vanished",
735
exc_info=error)
736
return True
737
raise
738
if pid:
739
gobject.source_remove(self.checker_callback_tag)
740
self.checker_callback(pid, status, command)
719
logger.error("Failed to start subprocess: %s",
720
error)
741
721
# Re-run this periodically if run by gobject.timeout_add
742
722
return True
743
723
750
730
return
751
731
logger.debug("Stopping checker for %(name)s", vars(self))
752
732
try:
753
self.checker.terminate()
733
os.kill(self.checker.pid, signal.SIGTERM)
754
734
#time.sleep(0.5)
755
735
#if self.checker.poll() is None:
756
# self.checker.kill()
736
# os.kill(self.checker.pid, signal.SIGKILL)
757
737
except OSError as error:
758
738
if error.errno != errno.ESRCH: # No such process
759
739
raise
776
756
# "Set" method, so we fail early here:
777
757
if byte_arrays and signature != "ay":
778
758
raise ValueError("Byte arrays not supported for non-'ay'"
779
" signature {!r}".format(signature))
759
" signature %r" % signature)
780
760
def decorator(func):
781
761
func._dbus_is_property = True
782
762
func._dbus_interface = dbus_interface
790
770
return decorator
791
771
792
772
793
def dbus_interface_annotations(dbus_interface):
794
"""Decorator for marking functions returning interface annotations
795
796
Usage:
797
798
@dbus_interface_annotations("org.example.Interface")
799
def _foo(self): # Function name does not matter
800
return {"org.freedesktop.DBus.Deprecated": "true",
801
"org.freedesktop.DBus.Property.EmitsChangedSignal":
802
"false"}
803
"""
804
def decorator(func):
805
func._dbus_is_interface = True
806
func._dbus_interface = dbus_interface
807
func._dbus_name = dbus_interface
808
return func
809
return decorator
810
811
812
def dbus_annotations(annotations):
813
"""Decorator to annotate D-Bus methods, signals or properties
814
Usage:
815
816
@dbus_service_property("org.example.Interface", signature="b",
817
access="r")
818
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
819
"org.freedesktop.DBus.Property."
820
"EmitsChangedSignal": "false"})
821
def Property_dbus_property(self):
822
return dbus.Boolean(False)
823
"""
824
def decorator(func):
825
func._dbus_annotations = annotations
826
return func
827
return decorator
828
829
830
773
class DBusPropertyException(dbus.exceptions.DBusException):
831
774
"""A base class for D-Bus property-related exceptions
832
775
"""
833
pass
776
def __unicode__(self):
777
return unicode(str(self))
778
834
779
835
780
class DBusPropertyAccessException(DBusPropertyException):
836
781
"""A property's access permissions disallows an operation.
853
798
"""
854
799
855
800
@staticmethod
856
def _is_dbus_thing(thing):
857
"""Returns a function testing if an attribute is a D-Bus thing
858
859
If called like _is_dbus_thing("method") it returns a function
860
suitable for use as predicate to inspect.getmembers().
861
"""
862
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
863
False)
801
def _is_dbus_property(obj):
802
return getattr(obj, "_dbus_is_property", False)
864
803
865
def _get_all_dbus_things(self, thing):
804
def _get_all_dbus_properties(self):
866
805
"""Returns a generator of (name, attribute) pairs
867
806
"""
868
return ((getattr(athing.__get__(self), "_dbus_name",
869
name),
870
athing.__get__(self))
807
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
871
808
for cls in self.__class__.__mro__
872
for name, athing in
873
inspect.getmembers(cls,
874
self._is_dbus_thing(thing)))
809
for name, prop in
810
inspect.getmembers(cls, self._is_dbus_property))
875
811
876
812
def _get_dbus_property(self, interface_name, property_name):
877
813
"""Returns a bound method if one exists which is a D-Bus
879
815
"""
880
816
for cls in self.__class__.__mro__:
881
817
for name, value in (inspect.getmembers
882
(cls,
883
self._is_dbus_thing("property"))):
818
(cls, self._is_dbus_property)):
884
819
if (value._dbus_name == property_name
885
820
and value._dbus_interface == interface_name):
886
821
return value.__get__(self)
914
849
# The byte_arrays option is not supported yet on
915
850
# signatures other than "ay".
916
851
if prop._dbus_signature != "ay":
917
raise ValueError("Byte arrays not supported for non-"
918
"'ay' signature {!r}"
919
.format(prop._dbus_signature))
852
raise ValueError
920
853
value = dbus.ByteArray(b''.join(chr(byte)
921
854
for byte in value))
922
855
prop(value)
930
863
Note: Will not include properties with access="write".
931
864
"""
932
865
properties = {}
933
for name, prop in self._get_all_dbus_things("property"):
866
for name, prop in self._get_all_dbus_properties():
934
867
if (interface_name
935
868
and interface_name != prop._dbus_interface):
936
869
# Interface non-empty but did not match
951
884
path_keyword='object_path',
952
885
connection_keyword='connection')
953
886
def Introspect(self, object_path, connection):
954
"""Overloading of standard D-Bus method.
955
956
Inserts property tags and interface annotation tags.
887
"""Standard D-Bus method, overloaded to insert property tags.
957
888
"""
958
889
xmlstring = dbus.service.Object.Introspect(self, object_path,
959
890
connection)
966
897
e.setAttribute("access", prop._dbus_access)
967
898
return e
968
899
for if_tag in document.getElementsByTagName("interface"):
969
# Add property tags
970
900
for tag in (make_tag(document, name, prop)
971
901
for name, prop
972
in self._get_all_dbus_things("property")
902
in self._get_all_dbus_properties()
973
903
if prop._dbus_interface
974
904
== if_tag.getAttribute("name")):
975
905
if_tag.appendChild(tag)
976
# Add annotation tags
977
for typ in ("method", "signal", "property"):
978
for tag in if_tag.getElementsByTagName(typ):
979
annots = dict()
980
for name, prop in (self.
981
_get_all_dbus_things(typ)):
982
if (name == tag.getAttribute("name")
983
and prop._dbus_interface
984
== if_tag.getAttribute("name")):
985
annots.update(getattr
986
(prop,
987
"_dbus_annotations",
988
{}))
989
for name, value in annots.items():
990
ann_tag = document.createElement(
991
"annotation")
992
ann_tag.setAttribute("name", name)
993
ann_tag.setAttribute("value", value)
994
tag.appendChild(ann_tag)
995
# Add interface annotation tags
996
for annotation, value in dict(
997
itertools.chain.from_iterable(
998
annotations().items()
999
for name, annotations in
1000
self._get_all_dbus_things("interface")
1001
if name == if_tag.getAttribute("name")
1002
)).items():
1003
ann_tag = document.createElement("annotation")
1004
ann_tag.setAttribute("name", annotation)
1005
ann_tag.setAttribute("value", value)
1006
if_tag.appendChild(ann_tag)
1007
906
# Add the names to the return values for the
1008
907
# "org.freedesktop.DBus.Properties" methods
1009
908
if (if_tag.getAttribute("name")
1024
923
except (AttributeError, xml.dom.DOMException,
1025
924
xml.parsers.expat.ExpatError) as error:
1026
925
logger.error("Failed to override Introspection method",
1027
exc_info=error)
926
error)
1028
927
return xmlstring
1029
928
1030
929
1031
def datetime_to_dbus(dt, variant_level=0):
930
def datetime_to_dbus (dt, variant_level=0):
1032
931
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1033
932
if dt is None:
1034
933
return dbus.String("", variant_level = variant_level)
1036
935
variant_level=variant_level)
1037
936
1038
937
1039
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1040
"""A class decorator; applied to a subclass of
1041
dbus.service.Object, it will add alternate D-Bus attributes with
1042
interface names according to the "alt_interface_names" mapping.
1043
Usage:
1044
1045
@alternate_dbus_interfaces({"org.example.Interface":
1046
"net.example.AlternateInterface"})
1047
class SampleDBusObject(dbus.service.Object):
1048
@dbus.service.method("org.example.Interface")
1049
def SampleDBusMethod():
1050
pass
1051
1052
The above "SampleDBusMethod" on "SampleDBusObject" will be
1053
reachable via two interfaces: "org.example.Interface" and
1054
"net.example.AlternateInterface", the latter of which will have
1055
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1056
"true", unless "deprecate" is passed with a False value.
1057
1058
This works for methods and signals, and also for D-Bus properties
1059
(from DBusObjectWithProperties) and interfaces (from the
1060
dbus_interface_annotations decorator).
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.
1061
942
"""
1062
def wrapper(cls):
1063
for orig_interface_name, alt_interface_name in (
1064
alt_interface_names.items()):
1065
attr = {}
1066
interface_names = set()
1067
# Go though all attributes of the class
1068
for attrname, attribute in inspect.getmembers(cls):
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):
1069
950
# Ignore non-D-Bus attributes, and D-Bus attributes
1070
951
# with the wrong interface name
1071
952
if (not hasattr(attribute, "_dbus_interface")
1072
953
or not attribute._dbus_interface
1073
.startswith(orig_interface_name)):
954
.startswith("se.recompile.Mandos")):
1074
955
continue
1075
956
# Create an alternate D-Bus interface name based on
1076
957
# the current name
1077
958
alt_interface = (attribute._dbus_interface
1078
.replace(orig_interface_name,
1079
alt_interface_name))
1080
interface_names.add(alt_interface)
959
.replace("se.recompile.Mandos",
960
"se.bsnet.fukt.Mandos"))
1081
961
# Is this a D-Bus signal?
1082
962
if getattr(attribute, "_dbus_is_signal", False):
1083
# Extract the original non-method undecorated
1084
# function by black magic
963
# Extract the original non-method function by
964
# black magic
1085
965
nonmethod_func = (dict(
1086
966
zip(attribute.func_code.co_freevars,
1087
967
attribute.__closure__))["func"]
1098
978
nonmethod_func.func_name,
1099
979
nonmethod_func.func_defaults,
1100
980
nonmethod_func.func_closure)))
1101
# Copy annotations, if any
1102
try:
1103
new_function._dbus_annotations = (
1104
dict(attribute._dbus_annotations))
1105
except AttributeError:
1106
pass
1107
981
# Define a creator of a function to call both the
1108
# original and alternate functions, so both the
1109
# original and alternate signals gets sent when
1110
# the function is called
982
# old and new functions, so both the old and new
983
# signals gets sent when the function is called
1111
984
def fixscope(func1, func2):
1112
985
"""This function is a scope container to pass
1113
986
func1 and func2 to the "call_both" function
1120
993
return call_both
1121
994
# Create the "call_both" function and add it to
1122
995
# the class
1123
attr[attrname] = fixscope(attribute, new_function)
996
attr[attrname] = fixscope(attribute,
997
new_function)
1124
998
# Is this a D-Bus method?
1125
999
elif getattr(attribute, "_dbus_is_method", False):
1126
1000
# Create a new, but exactly alike, function
1137
1011
attribute.func_name,
1138
1012
attribute.func_defaults,
1139
1013
attribute.func_closure)))
1140
# Copy annotations, if any
1141
try:
1142
attr[attrname]._dbus_annotations = (
1143
dict(attribute._dbus_annotations))
1144
except AttributeError:
1145
pass
1146
1014
# Is this a D-Bus property?
1147
1015
elif getattr(attribute, "_dbus_is_property", False):
1148
1016
# Create a new, but exactly alike, function
1162
1030
attribute.func_name,
1163
1031
attribute.func_defaults,
1164
1032
attribute.func_closure)))
1165
# Copy annotations, if any
1166
try:
1167
attr[attrname]._dbus_annotations = (
1168
dict(attribute._dbus_annotations))
1169
except AttributeError:
1170
pass
1171
# Is this a D-Bus interface?
1172
elif getattr(attribute, "_dbus_is_interface", False):
1173
# Create a new, but exactly alike, function
1174
# object. Decorate it to be a new D-Bus interface
1175
# with the alternate D-Bus interface name. Add it
1176
# to the class.
1177
attr[attrname] = (dbus_interface_annotations
1178
(alt_interface)
1179
(types.FunctionType
1180
(attribute.func_code,
1181
attribute.func_globals,
1182
attribute.func_name,
1183
attribute.func_defaults,
1184
attribute.func_closure)))
1185
if deprecate:
1186
# Deprecate all alternate interfaces
1187
iname="_AlternateDBusNames_interface_annotation{}"
1188
for interface_name in interface_names:
1189
@dbus_interface_annotations(interface_name)
1190
def func(self):
1191
return { "org.freedesktop.DBus.Deprecated":
1192
"true" }
1193
# Find an unused name
1194
for aname in (iname.format(i)
1195
for i in itertools.count()):
1196
if aname not in attr:
1197
attr[aname] = func
1198
break
1199
if interface_names:
1200
# Replace the class with a new subclass of it with
1201
# methods, signals, etc. as created above.
1202
cls = type(b"{}Alternate".format(cls.__name__),
1203
(cls,), attr)
1204
return cls
1205
return wrapper
1206
1207
1208
@alternate_dbus_interfaces({"se.recompile.Mandos":
1209
"se.bsnet.fukt.Mandos"})
1033
return type.__new__(mcs, name, bases, attr)
1034
1035
1210
1036
class ClientDBus(Client, DBusObjectWithProperties):
1211
1037
"""A Client class using D-Bus
1212
1038
1223
1049
def __init__(self, bus = None, *args, **kwargs):
1224
1050
self.bus = bus
1225
1051
Client.__init__(self, *args, **kwargs)
1052
self._approvals_pending = 0
1053
1054
self._approvals_pending = 0
1226
1055
# Only now, when this client is initialized, can it show up on
1227
1056
# the D-Bus
1228
client_object_name = str(self.name).translate(
1057
client_object_name = unicode(self.name).translate(
1229
1058
{ord("."): ord("_"),
1230
1059
ord("-"): ord("_")})
1231
1060
self.dbus_object_path = (dbus.ObjectPath
1232
1061
("/clients/" + client_object_name))
1233
1062
DBusObjectWithProperties.__init__(self, self.bus,
1234
1063
self.dbus_object_path)
1235
1064
1236
1065
def notifychangeproperty(transform_func,
1237
1066
dbus_name, type_func=lambda x: x,
1238
1067
variant_level=1):
1246
1075
to the D-Bus. Default: no transform
1247
1076
variant_level: D-Bus variant level. Default: 1
1248
1077
"""
1249
attrname = "_{}".format(dbus_name)
1078
attrname = "_{0}".format(dbus_name)
1250
1079
def setter(self, value):
1251
1080
if hasattr(self, "dbus_object_path"):
1252
1081
if (not hasattr(self, attrname) or
1261
1090
1262
1091
return property(lambda self: getattr(self, attrname), setter)
1263
1092
1093
1264
1094
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1265
1095
approvals_pending = notifychangeproperty(dbus.Boolean,
1266
1096
"ApprovalPending",
1273
1103
checker is not None)
1274
1104
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1275
1105
"LastCheckedOK")
1276
last_checker_status = notifychangeproperty(dbus.Int16,
1277
"LastCheckerStatus")
1278
1106
last_approval_request = notifychangeproperty(
1279
1107
datetime_to_dbus, "LastApprovalRequest")
1280
1108
approved_by_default = notifychangeproperty(dbus.Boolean,
1282
1110
approval_delay = notifychangeproperty(dbus.UInt64,
1283
1111
"ApprovalDelay",
1284
1112
type_func =
1285
lambda td: td.total_seconds()
1286
* 1000)
1113
timedelta_to_milliseconds)
1287
1114
approval_duration = notifychangeproperty(
1288
1115
dbus.UInt64, "ApprovalDuration",
1289
type_func = lambda td: td.total_seconds() * 1000)
1116
type_func = timedelta_to_milliseconds)
1290
1117
host = notifychangeproperty(dbus.String, "Host")
1291
1118
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1292
type_func = lambda td:
1293
td.total_seconds() * 1000)
1119
type_func =
1120
timedelta_to_milliseconds)
1294
1121
extended_timeout = notifychangeproperty(
1295
1122
dbus.UInt64, "ExtendedTimeout",
1296
type_func = lambda td: td.total_seconds() * 1000)
1123
type_func = timedelta_to_milliseconds)
1297
1124
interval = notifychangeproperty(dbus.UInt64,
1298
1125
"Interval",
1299
1126
type_func =
1300
lambda td: td.total_seconds()
1301
* 1000)
1127
timedelta_to_milliseconds)
1302
1128
checker_command = notifychangeproperty(dbus.String, "Checker")
1303
1129
1304
1130
del notifychangeproperty
1332
1158
*args, **kwargs)
1333
1159
1334
1160
def start_checker(self, *args, **kwargs):
1335
old_checker_pid = getattr(self.checker, "pid", None)
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
1336
1166
r = Client.start_checker(self, *args, **kwargs)
1337
1167
# Only if new checker process was started
1338
1168
if (self.checker is not None
1346
1176
return False
1347
1177
1348
1178
def approve(self, value=True):
1179
self.send_changedstate()
1349
1180
self.approved = value
1350
gobject.timeout_add(int(self.approval_duration.total_seconds()
1351
* 1000), self._reset_approved)
1352
self.send_changedstate()
1181
gobject.timeout_add(timedelta_to_milliseconds
1182
(self.approval_duration),
1183
self._reset_approved)
1184
1353
1185
1354
1186
## D-Bus methods, signals & properties
1355
1187
_interface = "se.recompile.Mandos.Client"
1356
1188
1357
## Interfaces
1358
1359
@dbus_interface_annotations(_interface)
1360
def _foo(self):
1361
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1362
"false"}
1363
1364
1189
## Signals
1365
1190
1366
1191
# CheckerCompleted - signal
1402
1227
"D-Bus signal"
1403
1228
return self.need_approval()
1404
1229
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
1405
1238
## Methods
1406
1239
1407
1240
# Approve - method
1457
1290
access="readwrite")
1458
1291
def ApprovalDelay_dbus_property(self, value=None):
1459
1292
if value is None: # get
1460
return dbus.UInt64(self.approval_delay.total_seconds()
1461
* 1000)
1293
return dbus.UInt64(self.approval_delay_milliseconds())
1462
1294
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1463
1295
1464
1296
# ApprovalDuration - property
1466
1298
access="readwrite")
1467
1299
def ApprovalDuration_dbus_property(self, value=None):
1468
1300
if value is None: # get
1469
return dbus.UInt64(self.approval_duration.total_seconds()
1470
* 1000)
1301
return dbus.UInt64(timedelta_to_milliseconds(
1302
self.approval_duration))
1471
1303
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1472
1304
1473
1305
# Name - property
1486
1318
def Host_dbus_property(self, value=None):
1487
1319
if value is None: # get
1488
1320
return dbus.String(self.host)
1489
self.host = str(value)
1321
self.host = unicode(value)
1490
1322
1491
1323
# Created - property
1492
1324
@dbus_service_property(_interface, signature="s", access="read")
1518
1350
return
1519
1351
return datetime_to_dbus(self.last_checked_ok)
1520
1352
1521
# LastCheckerStatus - property
1522
@dbus_service_property(_interface, signature="n",
1523
access="read")
1524
def LastCheckerStatus_dbus_property(self):
1525
return dbus.Int16(self.last_checker_status)
1526
1527
1353
# Expires - property
1528
1354
@dbus_service_property(_interface, signature="s", access="read")
1529
1355
def Expires_dbus_property(self):
1539
1365
access="readwrite")
1540
1366
def Timeout_dbus_property(self, value=None):
1541
1367
if value is None: # get
1542
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1543
old_timeout = self.timeout
1368
return dbus.UInt64(self.timeout_milliseconds())
1544
1369
self.timeout = datetime.timedelta(0, 0, 0, value)
1545
# Reschedule disabling
1370
# Reschedule timeout
1546
1371
if self.enabled:
1547
1372
now = datetime.datetime.utcnow()
1548
self.expires += self.timeout - old_timeout
1549
if self.expires <= now:
1373
time_to_die = timedelta_to_milliseconds(
1374
(self.last_checked_ok + self.timeout) - now)
1375
if time_to_die <= 0:
1550
1376
# The timeout has passed
1551
1377
self.disable()
1552
1378
else:
1379
self.expires = (now +
1380
datetime.timedelta(milliseconds =
1381
time_to_die))
1553
1382
if (getattr(self, "disable_initiator_tag", None)
1554
1383
is None):
1555
1384
return
1556
1385
gobject.source_remove(self.disable_initiator_tag)
1557
self.disable_initiator_tag = (
1558
gobject.timeout_add(
1559
int((self.expires - now).total_seconds()
1560
* 1000), self.disable))
1386
self.disable_initiator_tag = (gobject.timeout_add
1387
(time_to_die,
1388
self.disable))
1561
1389
1562
1390
# ExtendedTimeout - property
1563
1391
@dbus_service_property(_interface, signature="t",
1564
1392
access="readwrite")
1565
1393
def ExtendedTimeout_dbus_property(self, value=None):
1566
1394
if value is None: # get
1567
return dbus.UInt64(self.extended_timeout.total_seconds()
1568
* 1000)
1395
return dbus.UInt64(self.extended_timeout_milliseconds())
1569
1396
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1570
1397
1571
1398
# Interval - property
1573
1400
access="readwrite")
1574
1401
def Interval_dbus_property(self, value=None):
1575
1402
if value is None: # get
1576
return dbus.UInt64(self.interval.total_seconds() * 1000)
1403
return dbus.UInt64(self.interval_milliseconds())
1577
1404
self.interval = datetime.timedelta(0, 0, 0, value)
1578
1405
if getattr(self, "checker_initiator_tag", None) is None:
1579
1406
return
1590
1417
def Checker_dbus_property(self, value=None):
1591
1418
if value is None: # get
1592
1419
return dbus.String(self.checker_command)
1593
self.checker_command = str(value)
1420
self.checker_command = unicode(value)
1594
1421
1595
1422
# CheckerRunning - property
1596
1423
@dbus_service_property(_interface, signature="b",
1612
1439
@dbus_service_property(_interface, signature="ay",
1613
1440
access="write", byte_arrays=True)
1614
1441
def Secret_dbus_property(self, value):
1615
self.secret = bytes(value)
1442
self.secret = str(value)
1616
1443
1617
1444
del _interface
1618
1445
1643
1470
self._pipe.send(('setattr', name, value))
1644
1471
1645
1472
1473
class ClientDBusTransitional(ClientDBus):
1474
__metaclass__ = AlternateDBusNamesMetaclass
1475
1476
1646
1477
class ClientHandler(socketserver.BaseRequestHandler, object):
1647
1478
"""A class to handle client connections.
1648
1479
1652
1483
def handle(self):
1653
1484
with contextlib.closing(self.server.child_pipe) as child_pipe:
1654
1485
logger.info("TCP connection from: %s",
1655
str(self.client_address))
1486
unicode(self.client_address))
1656
1487
logger.debug("Pipe FD: %d",
1657
1488
self.server.child_pipe.fileno())
1658
1489
1684
1515
logger.debug("Protocol version: %r", line)
1685
1516
try:
1686
1517
if int(line.strip().split()[0]) > 1:
1687
raise RuntimeError(line)
1518
raise RuntimeError
1688
1519
except (ValueError, IndexError, RuntimeError) as error:
1689
1520
logger.error("Unknown protocol version: %s", error)
1690
1521
return
1716
1547
except KeyError:
1717
1548
return
1718
1549
1550
if self.server.use_dbus:
1551
# Emit D-Bus signal
1552
client.NewRequest(str(self.client_address))
1553
1719
1554
if client.approval_delay:
1720
1555
delay = client.approval_delay
1721
1556
client.approvals_pending += 1
1739
1574
if self.server.use_dbus:
1740
1575
# Emit D-Bus signal
1741
1576
client.NeedApproval(
1742
client.approval_delay.total_seconds()
1743
* 1000, client.approved_by_default)
1577
client.approval_delay_milliseconds(),
1578
client.approved_by_default)
1744
1579
else:
1745
1580
logger.warning("Client %s was not approved",
1746
1581
client.name)
1752
1587
#wait until timeout or approved
1753
1588
time = datetime.datetime.now()
1754
1589
client.changedstate.acquire()
1755
client.changedstate.wait(delay.total_seconds())
1590
(client.changedstate.wait
1591
(float(client.timedelta_to_milliseconds(delay)
1592
/ 1000)))
1756
1593
client.changedstate.release()
1757
1594
time2 = datetime.datetime.now()
1758
1595
if (time2 - time) >= delay:
1774
1611
try:
1775
1612
sent = session.send(client.secret[sent_size:])
1776
1613
except gnutls.errors.GNUTLSError as error:
1777
logger.warning("gnutls send failed",
1778
exc_info=error)
1614
logger.warning("gnutls send failed")
1779
1615
return
1780
1616
logger.debug("Sent: %d, remaining: %d",
1781
1617
sent, len(client.secret)
1784
1620
1785
1621
logger.info("Sending secret to %s", client.name)
1786
1622
# bump the timeout using extended_timeout
1787
client.bump_timeout(client.extended_timeout)
1623
client.checked_ok(client.extended_timeout)
1788
1624
if self.server.use_dbus:
1789
1625
# Emit D-Bus signal
1790
1626
client.GotSecret()
1795
1631
try:
1796
1632
session.bye()
1797
1633
except gnutls.errors.GNUTLSError as error:
1798
logger.warning("GnuTLS bye failed",
1799
exc_info=error)
1634
logger.warning("GnuTLS bye failed")
1800
1635
1801
1636
@staticmethod
1802
1637
def peer_certificate(session):
1874
1709
def process_request(self, request, address):
1875
1710
"""Start a new process to process the request."""
1876
1711
proc = multiprocessing.Process(target = self.sub_process_main,
1877
args = (request, address))
1712
args = (request,
1713
address))
1878
1714
proc.start()
1879
1715
return proc
1880
1716
1895
1731
1896
1732
def add_pipe(self, parent_pipe, proc):
1897
1733
"""Dummy function; override as necessary"""
1898
raise NotImplementedError()
1734
raise NotImplementedError
1899
1735
1900
1736
1901
1737
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1908
1744
use_ipv6: Boolean; to use IPv6 or not
1909
1745
"""
1910
1746
def __init__(self, server_address, RequestHandlerClass,
1911
interface=None, use_ipv6=True, socketfd=None):
1912
"""If socketfd is set, use that file descriptor instead of
1913
creating a new one with socket.socket().
1914
"""
1747
interface=None, use_ipv6=True):
1915
1748
self.interface = interface
1916
1749
if use_ipv6:
1917
1750
self.address_family = socket.AF_INET6
1918
if socketfd is not None:
1919
# Save the file descriptor
1920
self.socketfd = socketfd
1921
# Save the original socket.socket() function
1922
self.socket_socket = socket.socket
1923
# To implement --socket, we monkey patch socket.socket.
1924
#
1925
# (When socketserver.TCPServer is a new-style class, we
1926
# could make self.socket into a property instead of monkey
1927
# patching socket.socket.)
1928
#
1929
# Create a one-time-only replacement for socket.socket()
1930
@functools.wraps(socket.socket)
1931
def socket_wrapper(*args, **kwargs):
1932
# Restore original function so subsequent calls are
1933
# not affected.
1934
socket.socket = self.socket_socket
1935
del self.socket_socket
1936
# This time only, return a new socket object from the
1937
# saved file descriptor.
1938
return socket.fromfd(self.socketfd, *args, **kwargs)
1939
# Replace socket.socket() function with wrapper
1940
socket.socket = socket_wrapper
1941
# The socketserver.TCPServer.__init__ will call
1942
# socket.socket(), which might be our replacement,
1943
# socket_wrapper(), if socketfd was set.
1944
1751
socketserver.TCPServer.__init__(self, server_address,
1945
1752
RequestHandlerClass)
1946
1947
1753
def server_bind(self):
1948
1754
"""This overrides the normal server_bind() function
1949
1755
to bind to an interface if one was specified, and also NOT to
1957
1763
try:
1958
1764
self.socket.setsockopt(socket.SOL_SOCKET,
1959
1765
SO_BINDTODEVICE,
1960
(self.interface + "\0")
1961
.encode("utf-8"))
1766
str(self.interface
1767
+ '\0'))
1962
1768
except socket.error as error:
1963
if error.errno == errno.EPERM:
1964
logger.error("No permission to bind to"
1965
" interface %s", self.interface)
1966
elif error.errno == errno.ENOPROTOOPT:
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:
1967
1774
logger.error("SO_BINDTODEVICE not available;"
1968
1775
" cannot bind to interface %s",
1969
1776
self.interface)
1970
elif error.errno == errno.ENODEV:
1971
logger.error("Interface %s does not exist,"
1972
" cannot bind", self.interface)
1973
1777
else:
1974
1778
raise
1975
1779
# Only bind(2) the socket if we really need to.
1978
1782
if self.address_family == socket.AF_INET6:
1979
1783
any_address = "::" # in6addr_any
1980
1784
else:
1981
any_address = "0.0.0.0" # INADDR_ANY
1785
any_address = socket.INADDR_ANY
1982
1786
self.server_address = (any_address,
1983
1787
self.server_address[1])
1984
1788
elif not self.server_address[1]:
2005
1809
"""
2006
1810
def __init__(self, server_address, RequestHandlerClass,
2007
1811
interface=None, use_ipv6=True, clients=None,
2008
gnutls_priority=None, use_dbus=True, socketfd=None):
1812
gnutls_priority=None, use_dbus=True):
2009
1813
self.enabled = False
2010
1814
self.clients = clients
2011
1815
if self.clients is None:
2015
1819
IPv6_TCPServer.__init__(self, server_address,
2016
1820
RequestHandlerClass,
2017
1821
interface = interface,
2018
use_ipv6 = use_ipv6,
2019
socketfd = socketfd)
1822
use_ipv6 = use_ipv6)
2020
1823
def server_activate(self):
2021
1824
if self.enabled:
2022
1825
return socketserver.TCPServer.server_activate(self)
2035
1838
2036
1839
def handle_ipc(self, source, condition, parent_pipe=None,
2037
1840
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)
2038
1855
# error, or the other end of multiprocessing.Pipe has closed
2039
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1856
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2040
1857
# Wait for other process to exit
2041
1858
proc.join()
2042
1859
return False
2100
1917
return True
2101
1918
2102
1919
2103
def rfc3339_duration_to_delta(duration):
2104
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2105
2106
>>> rfc3339_duration_to_delta("P7D")
2107
datetime.timedelta(7)
2108
>>> rfc3339_duration_to_delta("PT60S")
2109
datetime.timedelta(0, 60)
2110
>>> rfc3339_duration_to_delta("PT60M")
2111
datetime.timedelta(0, 3600)
2112
>>> rfc3339_duration_to_delta("PT24H")
2113
datetime.timedelta(1)
2114
>>> rfc3339_duration_to_delta("P1W")
2115
datetime.timedelta(7)
2116
>>> rfc3339_duration_to_delta("PT5M30S")
2117
datetime.timedelta(0, 330)
2118
>>> rfc3339_duration_to_delta("P1DT3M20S")
2119
datetime.timedelta(1, 200)
2120
"""
2121
2122
# Parsing an RFC 3339 duration with regular expressions is not
2123
# possible - there would have to be multiple places for the same
2124
# values, like seconds. The current code, while more esoteric, is
2125
# cleaner without depending on a parsing library. If Python had a
2126
# built-in library for parsing we would use it, but we'd like to
2127
# avoid excessive use of external libraries.
2128
2129
# New type for defining tokens, syntax, and semantics all-in-one
2130
Token = collections.namedtuple("Token",
2131
("regexp", # To match token; if
2132
# "value" is not None,
2133
# must have a "group"
2134
# containing digits
2135
"value", # datetime.timedelta or
2136
# None
2137
"followers")) # Tokens valid after
2138
# this token
2139
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2140
# the "duration" ABNF definition in RFC 3339, Appendix A.
2141
token_end = Token(re.compile(r"$"), None, frozenset())
2142
token_second = Token(re.compile(r"(\d+)S"),
2143
datetime.timedelta(seconds=1),
2144
frozenset((token_end,)))
2145
token_minute = Token(re.compile(r"(\d+)M"),
2146
datetime.timedelta(minutes=1),
2147
frozenset((token_second, token_end)))
2148
token_hour = Token(re.compile(r"(\d+)H"),
2149
datetime.timedelta(hours=1),
2150
frozenset((token_minute, token_end)))
2151
token_time = Token(re.compile(r"T"),
2152
None,
2153
frozenset((token_hour, token_minute,
2154
token_second)))
2155
token_day = Token(re.compile(r"(\d+)D"),
2156
datetime.timedelta(days=1),
2157
frozenset((token_time, token_end)))
2158
token_month = Token(re.compile(r"(\d+)M"),
2159
datetime.timedelta(weeks=4),
2160
frozenset((token_day, token_end)))
2161
token_year = Token(re.compile(r"(\d+)Y"),
2162
datetime.timedelta(weeks=52),
2163
frozenset((token_month, token_end)))
2164
token_week = Token(re.compile(r"(\d+)W"),
2165
datetime.timedelta(weeks=1),
2166
frozenset((token_end,)))
2167
token_duration = Token(re.compile(r"P"), None,
2168
frozenset((token_year, token_month,
2169
token_day, token_time,
2170
token_week)))
2171
# Define starting values
2172
value = datetime.timedelta() # Value so far
2173
found_token = None
2174
followers = frozenset((token_duration,)) # Following valid tokens
2175
s = duration # String left to parse
2176
# Loop until end token is found
2177
while found_token is not token_end:
2178
# Search for any currently valid tokens
2179
for token in followers:
2180
match = token.regexp.match(s)
2181
if match is not None:
2182
# Token found
2183
if token.value is not None:
2184
# Value found, parse digits
2185
factor = int(match.group(1), 10)
2186
# Add to value so far
2187
value += factor * token.value
2188
# Strip token from string
2189
s = token.regexp.sub("", s, 1)
2190
# Go to found token
2191
found_token = token
2192
# Set valid next tokens
2193
followers = found_token.followers
2194
break
2195
else:
2196
# No currently valid tokens were found
2197
raise ValueError("Invalid RFC 3339 duration")
2198
# End token found
2199
return value
2200
2201
2202
1920
def string_to_delta(interval):
2203
1921
"""Parse a string and return a datetime.timedelta
2204
1922
2215
1933
>>> string_to_delta('5m 30s')
2216
1934
datetime.timedelta(0, 330)
2217
1935
"""
2218
2219
try:
2220
return rfc3339_duration_to_delta(interval)
2221
except ValueError:
2222
pass
2223
2224
1936
timevalue = datetime.timedelta(0)
2225
1937
for s in interval.split():
2226
1938
try:
2227
suffix = s[-1]
1939
suffix = unicode(s[-1])
2228
1940
value = int(s[:-1])
2229
1941
if suffix == "d":
2230
1942
delta = datetime.timedelta(value)
2237
1949
elif suffix == "w":
2238
1950
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2239
1951
else:
2240
raise ValueError("Unknown suffix {!r}"
2241
.format(suffix))
2242
except IndexError as e:
1952
raise ValueError("Unknown suffix %r" % suffix)
1953
except (ValueError, IndexError) as e:
2243
1954
raise ValueError(*(e.args))
2244
1955
timevalue += delta
2245
1956
return timevalue
2258
1969
sys.exit()
2259
1970
if not noclose:
2260
1971
# Close all standard open file descriptors
2261
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1972
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2262
1973
if not stat.S_ISCHR(os.fstat(null).st_mode):
2263
raise OSError(errno.ENODEV, "{} not a character device"
2264
.format(os.devnull))
1974
raise OSError(errno.ENODEV,
1975
"%s not a character device"
1976
% os.path.devnull)
2265
1977
os.dup2(null, sys.stdin.fileno())
2266
1978
os.dup2(null, sys.stdout.fileno())
2267
1979
os.dup2(null, sys.stderr.fileno())
2276
1988
2277
1989
parser = argparse.ArgumentParser()
2278
1990
parser.add_argument("-v", "--version", action="version",
2279
version = "%(prog)s {}".format(version),
1991
version = "%%(prog)s %s" % version,
2280
1992
help="show version number and exit")
2281
1993
parser.add_argument("-i", "--interface", metavar="IF",
2282
1994
help="Bind to interface IF")
2288
2000
help="Run self-test")
2289
2001
parser.add_argument("--debug", action="store_true",
2290
2002
help="Debug mode; run in foreground and log"
2291
" to terminal", default=None)
2003
" to terminal")
2292
2004
parser.add_argument("--debuglevel", metavar="LEVEL",
2293
2005
help="Debug level for stdout output")
2294
2006
parser.add_argument("--priority", help="GnuTLS"
2301
2013
" files")
2302
2014
parser.add_argument("--no-dbus", action="store_false",
2303
2015
dest="use_dbus", help="Do not provide D-Bus"
2304
" system bus interface", default=None)
2016
" system bus interface")
2305
2017
parser.add_argument("--no-ipv6", action="store_false",
2306
dest="use_ipv6", help="Do not use IPv6",
2307
default=None)
2018
dest="use_ipv6", help="Do not use IPv6")
2308
2019
parser.add_argument("--no-restore", action="store_false",
2309
2020
dest="restore", help="Do not restore stored"
2310
" state", default=None)
2311
parser.add_argument("--socket", type=int,
2312
help="Specify a file descriptor to a network"
2313
" socket to use instead of creating one")
2021
" state")
2314
2022
parser.add_argument("--statedir", metavar="DIR",
2315
2023
help="Directory to save/restore state in")
2316
parser.add_argument("--foreground", action="store_true",
2317
help="Run in foreground", default=None)
2318
parser.add_argument("--no-zeroconf", action="store_false",
2319
dest="zeroconf", help="Do not use Zeroconf",
2320
default=None)
2321
2024
2322
2025
options = parser.parse_args()
2323
2026
2324
2027
if options.check:
2325
2028
import doctest
2326
fail_count, test_count = doctest.testmod()
2327
sys.exit(os.EX_OK if fail_count == 0 else 1)
2029
doctest.testmod()
2030
sys.exit()
2328
2031
2329
2032
# Default values for config file for server-global settings
2330
2033
server_defaults = { "interface": "",
2332
2035
"port": "",
2333
2036
"debug": "False",
2334
2037
"priority":
2335
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2038
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2336
2039
"servicename": "Mandos",
2337
2040
"use_dbus": "True",
2338
2041
"use_ipv6": "True",
2339
2042
"debuglevel": "",
2340
2043
"restore": "True",
2341
"socket": "",
2342
"statedir": "/var/lib/mandos",
2343
"foreground": "False",
2344
"zeroconf": "True",
2044
"statedir": "/var/lib/mandos"
2345
2045
}
2346
2046
2347
2047
# Parse config file for server-global settings
2352
2052
# Convert the SafeConfigParser object to a dict
2353
2053
server_settings = server_config.defaults()
2354
2054
# Use the appropriate methods on the non-string config options
2355
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2055
for option in ("debug", "use_dbus", "use_ipv6"):
2356
2056
server_settings[option] = server_config.getboolean("DEFAULT",
2357
2057
option)
2358
2058
if server_settings["port"]:
2359
2059
server_settings["port"] = server_config.getint("DEFAULT",
2360
2060
"port")
2361
if server_settings["socket"]:
2362
server_settings["socket"] = server_config.getint("DEFAULT",
2363
"socket")
2364
# Later, stdin will, and stdout and stderr might, be dup'ed
2365
# over with an opened os.devnull. But we don't want this to
2366
# happen with a supplied network socket.
2367
if 0 <= server_settings["socket"] <= 2:
2368
server_settings["socket"] = os.dup(server_settings
2369
["socket"])
2370
2061
del server_config
2371
2062
2372
2063
# Override the settings from the config file with command line
2374
2065
for option in ("interface", "address", "port", "debug",
2375
2066
"priority", "servicename", "configdir",
2376
2067
"use_dbus", "use_ipv6", "debuglevel", "restore",
2377
"statedir", "socket", "foreground", "zeroconf"):
2068
"statedir"):
2378
2069
value = getattr(options, option)
2379
2070
if value is not None:
2380
2071
server_settings[option] = value
2381
2072
del options
2382
2073
# Force all strings to be unicode
2383
2074
for option in server_settings.keys():
2384
if isinstance(server_settings[option], bytes):
2385
server_settings[option] = (server_settings[option]
2386
.decode("utf-8"))
2387
# Force all boolean options to be boolean
2388
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2389
"foreground", "zeroconf"):
2390
server_settings[option] = bool(server_settings[option])
2391
# Debug implies foreground
2392
if server_settings["debug"]:
2393
server_settings["foreground"] = True
2075
if type(server_settings[option]) is str:
2076
server_settings[option] = unicode(server_settings[option])
2394
2077
# Now we have our good server settings in "server_settings"
2395
2078
2396
2079
##################################################################
2397
2080
2398
if (not server_settings["zeroconf"] and
2399
not (server_settings["port"]
2400
or server_settings["socket"] != "")):
2401
parser.error("Needs port or socket to work without"
2402
" Zeroconf")
2403
2404
2081
# For convenience
2405
2082
debug = server_settings["debug"]
2406
2083
debuglevel = server_settings["debuglevel"]
2408
2085
use_ipv6 = server_settings["use_ipv6"]
2409
2086
stored_state_path = os.path.join(server_settings["statedir"],
2410
2087
stored_state_file)
2411
foreground = server_settings["foreground"]
2412
zeroconf = server_settings["zeroconf"]
2413
2088
2414
2089
if debug:
2415
2090
initlogger(debug, logging.DEBUG)
2422
2097
2423
2098
if server_settings["servicename"] != "Mandos":
2424
2099
syslogger.setFormatter(logging.Formatter
2425
('Mandos ({}) [%(process)d]:'
2426
' %(levelname)s: %(message)s'
2427
.format(server_settings
2428
["servicename"])))
2100
('Mandos (%s) [%%(process)d]:'
2101
' %%(levelname)s: %%(message)s'
2102
% server_settings["servicename"]))
2429
2103
2430
2104
# Parse config file with clients
2431
2105
client_config = configparser.SafeConfigParser(Client
2436
2110
global mandos_dbus_service
2437
2111
mandos_dbus_service = None
2438
2112
2439
socketfd = None
2440
if server_settings["socket"] != "":
2441
socketfd = server_settings["socket"]
2442
2113
tcp_server = MandosServer((server_settings["address"],
2443
2114
server_settings["port"]),
2444
2115
ClientHandler,
2447
2118
use_ipv6=use_ipv6,
2448
2119
gnutls_priority=
2449
2120
server_settings["priority"],
2450
use_dbus=use_dbus,
2451
socketfd=socketfd)
2452
if not foreground:
2453
pidfilename = "/run/mandos.pid"
2454
if not os.path.isdir("/run/."):
2455
pidfilename = "/var/run/mandos.pid"
2456
pidfile = None
2121
use_dbus=use_dbus)
2122
if not debug:
2123
pidfilename = "/var/run/mandos.pid"
2457
2124
try:
2458
2125
pidfile = open(pidfilename, "w")
2459
except IOError as e:
2460
logger.error("Could not open file %r", pidfilename,
2461
exc_info=e)
2126
except IOError:
2127
logger.error("Could not open file %r", pidfilename)
2462
2128
2463
for name in ("_mandos", "mandos", "nobody"):
2129
try:
2130
uid = pwd.getpwnam("_mandos").pw_uid
2131
gid = pwd.getpwnam("_mandos").pw_gid
2132
except KeyError:
2464
2133
try:
2465
uid = pwd.getpwnam(name).pw_uid
2466
gid = pwd.getpwnam(name).pw_gid
2467
break
2134
uid = pwd.getpwnam("mandos").pw_uid
2135
gid = pwd.getpwnam("mandos").pw_gid
2468
2136
except KeyError:
2469
continue
2470
else:
2471
uid = 65534
2472
gid = 65534
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
2473
2143
try:
2474
2144
os.setgid(gid)
2475
2145
os.setuid(uid)
2476
2146
except OSError as error:
2477
if error.errno != errno.EPERM:
2478
raise
2147
if error[0] != errno.EPERM:
2148
raise error
2479
2149
2480
2150
if debug:
2481
2151
# Enable all possible GnuTLS debugging
2492
2162
.gnutls_global_set_log_function(debug_gnutls))
2493
2163
2494
2164
# Redirect stdin so all checkers get /dev/null
2495
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2165
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2496
2166
os.dup2(null, sys.stdin.fileno())
2497
2167
if null > 2:
2498
2168
os.close(null)
2499
2169
2500
2170
# Need to fork before connecting to D-Bus
2501
if not foreground:
2171
if not debug:
2502
2172
# Close all input and output, do double fork, etc.
2503
2173
daemon()
2504
2174
2505
# multiprocessing will use threads, so before we use gobject we
2506
# need to inform gobject that threads will be used.
2507
2175
gobject.threads_init()
2508
2176
2509
2177
global main_loop
2510
2178
# From the Avahi example code
2511
DBusGMainLoop(set_as_default=True)
2179
DBusGMainLoop(set_as_default=True )
2512
2180
main_loop = gobject.MainLoop()
2513
2181
bus = dbus.SystemBus()
2514
2182
# End of Avahi example code
2520
2188
("se.bsnet.fukt.Mandos", bus,
2521
2189
do_not_queue=True))
2522
2190
except dbus.exceptions.NameExistsException as e:
2523
logger.error("Disabling D-Bus:", exc_info=e)
2191
logger.error(unicode(e) + ", disabling D-Bus")
2524
2192
use_dbus = False
2525
2193
server_settings["use_dbus"] = False
2526
2194
tcp_server.use_dbus = False
2527
if zeroconf:
2528
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2529
service = AvahiServiceToSyslog(name =
2530
server_settings["servicename"],
2531
servicetype = "_mandos._tcp",
2532
protocol = protocol, bus = bus)
2533
if server_settings["interface"]:
2534
service.interface = (if_nametoindex
2535
(server_settings["interface"]
2536
.encode("utf-8")))
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"])))
2537
2203
2538
2204
global multiprocessing_manager
2539
2205
multiprocessing_manager = multiprocessing.Manager()
2540
2206
2541
2207
client_class = Client
2542
2208
if use_dbus:
2543
client_class = functools.partial(ClientDBus, bus = bus)
2209
client_class = functools.partial(ClientDBusTransitional,
2210
bus = bus)
2544
2211
2545
2212
client_settings = Client.config_parser(client_config)
2546
2213
old_client_settings = {}
2547
2214
clients_data = {}
2548
2215
2549
# This is used to redirect stdout and stderr for checker processes
2550
global wnull
2551
wnull = open(os.devnull, "w") # A writable /dev/null
2552
# Only used if server is running in foreground but not in debug
2553
# mode
2554
if debug or not foreground:
2555
wnull.close()
2556
2557
2216
# Get client data and settings from last running state.
2558
2217
if server_settings["restore"]:
2559
2218
try:
2562
2221
(stored_state))
2563
2222
os.remove(stored_state_path)
2564
2223
except IOError as e:
2565
if e.errno == errno.ENOENT:
2566
logger.warning("Could not load persistent state: {}"
2567
.format(os.strerror(e.errno)))
2568
else:
2569
logger.critical("Could not load persistent state:",
2570
exc_info=e)
2224
logger.warning("Could not load persistent state: {0}"
2225
.format(e))
2226
if e.errno != errno.ENOENT:
2571
2227
raise
2572
2228
except EOFError as e:
2573
2229
logger.warning("Could not load persistent state: "
2574
"EOFError:", exc_info=e)
2230
"EOFError: {0}".format(e))
2575
2231
2576
2232
with PGPEngine() as pgp:
2577
for client_name, client in clients_data.items():
2578
# Skip removed clients
2579
if client_name not in client_settings:
2580
continue
2581
2233
for client_name, client in clients_data.iteritems():
2582
2234
# Decide which value to use after restoring saved state.
2583
2235
# We have three different values: Old config file,
2584
2236
# new config file, and saved state.
2598
2250
2599
2251
# Clients who has passed its expire date can still be
2600
2252
# enabled if its last checker was successful. Clients
2601
# whose checker succeeded before we stored its state is
2602
# assumed to have successfully run all checkers during
2603
# downtime.
2253
# whose checker failed before we stored its state is
2254
# assumed to have failed all checkers during downtime.
2604
2255
if client["enabled"]:
2605
2256
if datetime.datetime.utcnow() >= client["expires"]:
2606
2257
if not client["last_checked_ok"]:
2607
2258
logger.warning(
2608
"disabling client {} - Client never "
2609
"performed a successful checker"
2610
.format(client_name))
2259
"disabling client {0} - Client never "
2260
"performed a successfull checker"
2261
.format(client["name"]))
2611
2262
client["enabled"] = False
2612
2263
elif client["last_checker_status"] != 0:
2613
2264
logger.warning(
2614
"disabling client {} - Client last"
2615
" checker failed with error code {}"
2616
.format(client_name,
2265
"disabling client {0} - Client "
2266
"last checker failed with error code {1}"
2267
.format(client["name"],
2617
2268
client["last_checker_status"]))
2618
2269
client["enabled"] = False
2619
2270
else:
2621
2272
.utcnow()
2622
2273
+ client["timeout"])
2623
2274
logger.debug("Last checker succeeded,"
2624
" keeping {} enabled"
2625
.format(client_name))
2275
" keeping {0} enabled"
2276
.format(client["name"]))
2626
2277
try:
2627
2278
client["secret"] = (
2628
2279
pgp.decrypt(client["encrypted_secret"],
2630
2281
["secret"]))
2631
2282
except PGPError:
2632
2283
# If decryption fails, we use secret from new settings
2633
logger.debug("Failed to decrypt {} old secret"
2284
logger.debug("Failed to decrypt {0} old secret"
2634
2285
.format(client_name))
2635
2286
client["secret"] = (
2636
2287
client_settings[client_name]["secret"])
2288
2637
2289
2638
2290
# Add/remove clients based on new changes made to config
2639
2291
for client_name in (set(old_client_settings)
2642
2294
for client_name in (set(client_settings)
2643
2295
- set(old_client_settings)):
2644
2296
clients_data[client_name] = client_settings[client_name]
2645
2646
# Create all client objects
2647
for client_name, client in clients_data.items():
2297
2298
# Create clients all clients
2299
for client_name, client in clients_data.iteritems():
2648
2300
tcp_server.clients[client_name] = client_class(
2649
name = client_name, settings = client,
2650
server_settings = server_settings)
2301
name = client_name, settings = client)
2651
2302
2652
2303
if not tcp_server.clients:
2653
2304
logger.warning("No clients defined")
2654
2655
if not foreground:
2656
if pidfile is not None:
2657
try:
2658
with pidfile:
2659
pid = os.getpid()
2660
pidfile.write("{}\n".format(pid).encode("utf-8"))
2661
except IOError:
2662
logger.error("Could not write to file %r with PID %d",
2663
pidfilename, pid)
2664
del pidfile
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
2665
2318
del pidfilename
2319
signal.signal(signal.SIGINT, signal.SIG_IGN)
2666
2320
2667
2321
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2668
2322
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2669
2323
2670
2324
if use_dbus:
2671
@alternate_dbus_interfaces({"se.recompile.Mandos":
2672
"se.bsnet.fukt.Mandos"})
2673
class MandosDBusService(DBusObjectWithProperties):
2325
class MandosDBusService(dbus.service.Object):
2674
2326
"""A D-Bus proxy object"""
2675
2327
def __init__(self):
2676
2328
dbus.service.Object.__init__(self, bus, "/")
2677
2329
_interface = "se.recompile.Mandos"
2678
2330
2679
@dbus_interface_annotations(_interface)
2680
def _foo(self):
2681
return { "org.freedesktop.DBus.Property"
2682
".EmitsChangedSignal":
2683
"false"}
2684
2685
2331
@dbus.service.signal(_interface, signature="o")
2686
2332
def ClientAdded(self, objpath):
2687
2333
"D-Bus signal"
2729
2375
2730
2376
del _interface
2731
2377
2732
mandos_dbus_service = MandosDBusService()
2378
class MandosDBusServiceTransitional(MandosDBusService):
2379
__metaclass__ = AlternateDBusNamesMetaclass
2380
mandos_dbus_service = MandosDBusServiceTransitional()
2733
2381
2734
2382
def cleanup():
2735
2383
"Cleanup function; run on exit"
2736
if zeroconf:
2737
service.cleanup()
2384
service.cleanup()
2738
2385
2739
2386
multiprocessing.active_children()
2740
wnull.close()
2741
2387
if not (tcp_server.clients or client_settings):
2742
2388
return
2743
2389
2754
2400
2755
2401
# A list of attributes that can not be pickled
2756
2402
# + secret.
2757
exclude = { "bus", "changedstate", "secret",
2758
"checker", "server_settings" }
2403
exclude = set(("bus", "changedstate", "secret",
2404
"checker"))
2759
2405
for name, typ in (inspect.getmembers
2760
2406
(dbus.service.Object)):
2761
2407
exclude.add(name)
2770
2416
del client_settings[client.name]["secret"]
2771
2417
2772
2418
try:
2773
with (tempfile.NamedTemporaryFile
2774
(mode='wb', suffix=".pickle", prefix='clients-',
2775
dir=os.path.dirname(stored_state_path),
2776
delete=False)) as stored_state:
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:
2777
2424
pickle.dump((clients, client_settings), stored_state)
2778
tempname=stored_state.name
2779
2425
os.rename(tempname, stored_state_path)
2780
2426
except (IOError, OSError) as e:
2427
logger.warning("Could not save persistent state: {0}"
2428
.format(e))
2781
2429
if not debug:
2782
2430
try:
2783
2431
os.remove(tempname)
2784
2432
except NameError:
2785
2433
pass
2786
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2787
logger.warning("Could not save persistent state: {}"
2788
.format(os.strerror(e.errno)))
2789
else:
2790
logger.warning("Could not save persistent state:",
2791
exc_info=e)
2792
raise
2434
if e.errno not in set((errno.ENOENT, errno.EACCES,
2435
errno.EEXIST)):
2436
raise e
2793
2437
2794
2438
# Delete all clients, and settings from config
2795
2439
while tcp_server.clients:
2819
2463
tcp_server.server_activate()
2820
2464
2821
2465
# Find out what port we got
2822
if zeroconf:
2823
service.port = tcp_server.socket.getsockname()[1]
2466
service.port = tcp_server.socket.getsockname()[1]
2824
2467
if use_ipv6:
2825
2468
logger.info("Now listening on address %r, port %d,"
2826
" flowinfo %d, scope_id %d",
2827
*tcp_server.socket.getsockname())
2469
" flowinfo %d, scope_id %d"
2470
% tcp_server.socket.getsockname())
2828
2471
else: # IPv4
2829
logger.info("Now listening on address %r, port %d",
2830
*tcp_server.socket.getsockname())
2472
logger.info("Now listening on address %r, port %d"
2473
% tcp_server.socket.getsockname())
2831
2474
2832
2475
#service.interface = tcp_server.socket.getsockname()[3]
2833
2476
2834
2477
try:
2835
if zeroconf:
2836
# From the Avahi example code
2837
try:
2838
service.activate()
2839
except dbus.exceptions.DBusException as error:
2840
logger.critical("D-Bus Exception", exc_info=error)
2841
cleanup()
2842
sys.exit(1)
2843
# End of Avahi example code
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
2844
2486
2845
2487
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2846
2488
lambda *args, **kwargs:
2850
2492
logger.debug("Starting main loop")
2851
2493
main_loop.run()
2852
2494
except AvahiError as error:
2853
logger.critical("Avahi Error", exc_info=error)
2495
logger.critical("AvahiError: %s", error)
2854
2496
cleanup()
2855
2497
sys.exit(1)
2856
2498
except KeyboardInterrupt:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0