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 631
- compare with another revision
- download diff
- download tarball
- view history from revision 631
- Committer: Teddy Hogeborn
- Date: 2013-10-22 19:24:01 UTC
- Revision ID: teddy@recompile.se-20131022192401-op6mwsb7f7gygjyh
* mandos (priority): Bug fix: Add even more magic to make the old
DSA/ELG 2048-bit keys work with GnuTLS.
* mandos-keygen (KEYCOMMENT): Changed default to "".
* mandos-keygen (OPTIONS): Document new default value of "--comment".
* mandos-options.xml (priority): Document new default value.
* mandos.conf (priority): - '' -
DSA/ELG 2048-bit keys work with GnuTLS.
* mandos-keygen (KEYCOMMENT): Changed default to "".
* mandos-keygen (OPTIONS): Document new default value of "--comment".
* mandos-options.xml (priority): Document new default value.
* mandos.conf (priority): - '' -
- files added:
- debian/mandos-client.examples
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008-2013 Teddy Hogeborn
15
# Copyright © 2008-2013 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
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
63
65
import cPickle as pickle
64
66
import multiprocessing
65
67
import types
66
import hashlib
68
import binascii
69
import tempfile
70
import itertools
71
import collections
67
72
68
73
import dbus
69
74
import dbus.service
74
79
import ctypes.util
75
80
import xml.dom.minidom
76
81
import inspect
77
import Crypto.Cipher.AES
78
82
79
83
try:
80
84
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
84
88
except ImportError:
85
89
SO_BINDTODEVICE = None
86
90
87
88
version = "1.4.1"
89
stored_state_path = "/var/lib/mandos/clients.pickle"
91
version = "1.6.1"
92
stored_state_file = "clients.pickle"
90
93
91
94
logger = logging.getLogger()
92
95
syslogger = (logging.handlers.SysLogHandler
110
113
return interface_index
111
114
112
115
113
def initlogger(level=logging.WARNING):
116
def initlogger(debug, level=logging.WARNING):
114
117
"""init logger and add loglevel"""
115
118
116
119
syslogger.setFormatter(logging.Formatter
118
121
' %(message)s'))
119
122
logger.addHandler(syslogger)
120
123
121
console = logging.StreamHandler()
122
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
123
' [%(process)d]:'
124
' %(levelname)s:'
125
' %(message)s'))
126
logger.addHandler(console)
124
if debug:
125
console = logging.StreamHandler()
126
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
127
' [%(process)d]:'
128
' %(levelname)s:'
129
' %(message)s'))
130
logger.addHandler(console)
127
131
logger.setLevel(level)
128
132
129
133
134
class PGPError(Exception):
135
"""Exception if encryption/decryption fails"""
136
pass
137
138
139
class PGPEngine(object):
140
"""A simple class for OpenPGP symmetric encryption & decryption"""
141
def __init__(self):
142
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
143
self.gnupgargs = ['--batch',
144
'--home', self.tempdir,
145
'--force-mdc',
146
'--quiet',
147
'--no-use-agent']
148
149
def __enter__(self):
150
return self
151
152
def __exit__(self, exc_type, exc_value, traceback):
153
self._cleanup()
154
return False
155
156
def __del__(self):
157
self._cleanup()
158
159
def _cleanup(self):
160
if self.tempdir is not None:
161
# Delete contents of tempdir
162
for root, dirs, files in os.walk(self.tempdir,
163
topdown = False):
164
for filename in files:
165
os.remove(os.path.join(root, filename))
166
for dirname in dirs:
167
os.rmdir(os.path.join(root, dirname))
168
# Remove tempdir
169
os.rmdir(self.tempdir)
170
self.tempdir = None
171
172
def password_encode(self, password):
173
# Passphrase can not be empty and can not contain newlines or
174
# NUL bytes. So we prefix it and hex encode it.
175
encoded = b"mandos" + binascii.hexlify(password)
176
if len(encoded) > 2048:
177
# GnuPG can't handle long passwords, so encode differently
178
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
179
.replace(b"\n", b"\\n")
180
.replace(b"\0", b"\\x00"))
181
return encoded
182
183
def encrypt(self, data, password):
184
passphrase = self.password_encode(password)
185
with tempfile.NamedTemporaryFile(dir=self.tempdir
186
) as passfile:
187
passfile.write(passphrase)
188
passfile.flush()
189
proc = subprocess.Popen(['gpg', '--symmetric',
190
'--passphrase-file',
191
passfile.name]
192
+ self.gnupgargs,
193
stdin = subprocess.PIPE,
194
stdout = subprocess.PIPE,
195
stderr = subprocess.PIPE)
196
ciphertext, err = proc.communicate(input = data)
197
if proc.returncode != 0:
198
raise PGPError(err)
199
return ciphertext
200
201
def decrypt(self, data, password):
202
passphrase = self.password_encode(password)
203
with tempfile.NamedTemporaryFile(dir = self.tempdir
204
) as passfile:
205
passfile.write(passphrase)
206
passfile.flush()
207
proc = subprocess.Popen(['gpg', '--decrypt',
208
'--passphrase-file',
209
passfile.name]
210
+ self.gnupgargs,
211
stdin = subprocess.PIPE,
212
stdout = subprocess.PIPE,
213
stderr = subprocess.PIPE)
214
decrypted_plaintext, err = proc.communicate(input
215
= data)
216
if proc.returncode != 0:
217
raise PGPError(err)
218
return decrypted_plaintext
219
220
130
221
class AvahiError(Exception):
131
222
def __init__(self, value, *args, **kwargs):
132
223
self.value = value
149
240
Used to optionally bind to the specified interface.
150
241
name: string; Example: 'Mandos'
151
242
type: string; Example: '_mandos._tcp'.
152
See <http://www.dns-sd.org/ServiceTypes.html>
243
See <https://www.iana.org/assignments/service-names-port-numbers>
153
244
port: integer; what port to announce
154
245
TXT: list of strings; TXT record for the service
155
246
domain: string; Domain to publish on, default to .local if empty.
161
252
server: D-Bus Server
162
253
bus: dbus.SystemBus()
163
254
"""
255
164
256
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
165
257
servicetype = None, port = None, TXT = None,
166
258
domain = "", host = "", max_renames = 32768,
179
271
self.server = None
180
272
self.bus = bus
181
273
self.entry_group_state_changed_match = None
274
182
275
def rename(self):
183
276
"""Derived from the Avahi example code"""
184
277
if self.rename_count >= self.max_renames:
194
287
try:
195
288
self.add()
196
289
except dbus.exceptions.DBusException as error:
197
logger.critical("DBusException: %s", error)
290
logger.critical("D-Bus Exception", exc_info=error)
198
291
self.cleanup()
199
292
os._exit(1)
200
293
self.rename_count += 1
294
201
295
def remove(self):
202
296
"""Derived from the Avahi example code"""
203
297
if self.entry_group_state_changed_match is not None:
205
299
self.entry_group_state_changed_match = None
206
300
if self.group is not None:
207
301
self.group.Reset()
302
208
303
def add(self):
209
304
"""Derived from the Avahi example code"""
210
305
self.remove()
227
322
dbus.UInt16(self.port),
228
323
avahi.string_array_to_txt_array(self.TXT))
229
324
self.group.Commit()
325
230
326
def entry_group_state_changed(self, state, error):
231
327
"""Derived from the Avahi example code"""
232
328
logger.debug("Avahi entry group state change: %i", state)
239
335
elif state == avahi.ENTRY_GROUP_FAILURE:
240
336
logger.critical("Avahi: Error in group state changed %s",
241
337
unicode(error))
242
raise AvahiGroupError("State changed: %s"
243
% unicode(error))
338
raise AvahiGroupError("State changed: {0!s}"
339
.format(error))
340
244
341
def cleanup(self):
245
342
"""Derived from the Avahi example code"""
246
343
if self.group is not None:
251
348
pass
252
349
self.group = None
253
350
self.remove()
351
254
352
def server_state_changed(self, state, error=None):
255
353
"""Derived from the Avahi example code"""
256
354
logger.debug("Avahi server state change: %i", state)
275
373
logger.debug("Unknown state: %r", state)
276
374
else:
277
375
logger.debug("Unknown state: %r: %r", state, error)
376
278
377
def activate(self):
279
378
"""Derived from the Avahi example code"""
280
379
if self.server is None:
287
386
self.server_state_changed)
288
387
self.server_state_changed(self.server.GetState())
289
388
389
290
390
class AvahiServiceToSyslog(AvahiService):
291
391
def rename(self):
292
392
"""Add the new name to the syslog messages"""
293
393
ret = AvahiService.rename(self)
294
394
syslogger.setFormatter(logging.Formatter
295
('Mandos (%s) [%%(process)d]:'
296
' %%(levelname)s: %%(message)s'
297
% self.name))
395
('Mandos ({0}) [%(process)d]:'
396
' %(levelname)s: %(message)s'
397
.format(self.name)))
298
398
return ret
299
399
300
def _timedelta_to_milliseconds(td):
400
401
def timedelta_to_milliseconds(td):
301
402
"Convert a datetime.timedelta() to milliseconds"
302
403
return ((td.days * 24 * 60 * 60 * 1000)
303
404
+ (td.seconds * 1000)
304
405
+ (td.microseconds // 1000))
305
406
407
306
408
class Client(object):
307
409
"""A representation of a client host served by this server.
308
410
309
411
Attributes:
310
_approved: bool(); 'None' if not yet approved/disapproved
412
approved: bool(); 'None' if not yet approved/disapproved
311
413
approval_delay: datetime.timedelta(); Time to wait for approval
312
414
approval_duration: datetime.timedelta(); Duration of one approval
313
415
checker: subprocess.Popen(); a running checker process used
331
433
interval: datetime.timedelta(); How often to start a new checker
332
434
last_approval_request: datetime.datetime(); (UTC) or None
333
435
last_checked_ok: datetime.datetime(); (UTC) or None
334
335
436
last_checker_status: integer between 0 and 255 reflecting exit
336
437
status of last checker. -1 reflects crashed
337
checker, or None.
338
last_enabled: datetime.datetime(); (UTC)
438
checker, -2 means no checker completed yet.
439
last_enabled: datetime.datetime(); (UTC) or None
339
440
name: string; from the config file, used in log messages and
340
441
D-Bus identifiers
341
442
secret: bytestring; sent verbatim (over TLS) to client
342
443
timeout: datetime.timedelta(); How long from last_checked_ok
343
444
until this client is disabled
344
extended_timeout: extra long timeout when password has been sent
445
extended_timeout: extra long timeout when secret has been sent
345
446
runtime_expansions: Allowed attributes for runtime expansion.
346
447
expires: datetime.datetime(); time (UTC) when a client will be
347
448
disabled, or None
449
server_settings: The server_settings dict from main()
348
450
"""
349
451
350
452
runtime_expansions = ("approval_delay", "approval_duration",
351
"created", "enabled", "fingerprint",
352
"host", "interval", "last_checked_ok",
453
"created", "enabled", "expires",
454
"fingerprint", "host", "interval",
455
"last_approval_request", "last_checked_ok",
353
456
"last_enabled", "name", "timeout")
457
client_defaults = { "timeout": "PT5M",
458
"extended_timeout": "PT15M",
459
"interval": "PT2M",
460
"checker": "fping -q -- %%(host)s",
461
"host": "",
462
"approval_delay": "PT0S",
463
"approval_duration": "PT1S",
464
"approved_by_default": "True",
465
"enabled": "True",
466
}
354
467
355
468
def timeout_milliseconds(self):
356
469
"Return the 'timeout' attribute in milliseconds"
357
return _timedelta_to_milliseconds(self.timeout)
470
return timedelta_to_milliseconds(self.timeout)
358
471
359
472
def extended_timeout_milliseconds(self):
360
473
"Return the 'extended_timeout' attribute in milliseconds"
361
return _timedelta_to_milliseconds(self.extended_timeout)
474
return timedelta_to_milliseconds(self.extended_timeout)
362
475
363
476
def interval_milliseconds(self):
364
477
"Return the 'interval' attribute in milliseconds"
365
return _timedelta_to_milliseconds(self.interval)
478
return timedelta_to_milliseconds(self.interval)
366
479
367
480
def approval_delay_milliseconds(self):
368
return _timedelta_to_milliseconds(self.approval_delay)
369
370
def __init__(self, name = None, config=None):
371
"""Note: the 'checker' key in 'config' sets the
372
'checker_command' attribute and *not* the 'checker'
373
attribute."""
481
return timedelta_to_milliseconds(self.approval_delay)
482
483
@staticmethod
484
def config_parser(config):
485
"""Construct a new dict of client settings of this form:
486
{ client_name: {setting_name: value, ...}, ...}
487
with exceptions for any special settings as defined above.
488
NOTE: Must be a pure function. Must return the same result
489
value given the same arguments.
490
"""
491
settings = {}
492
for client_name in config.sections():
493
section = dict(config.items(client_name))
494
client = settings[client_name] = {}
495
496
client["host"] = section["host"]
497
# Reformat values from string types to Python types
498
client["approved_by_default"] = config.getboolean(
499
client_name, "approved_by_default")
500
client["enabled"] = config.getboolean(client_name,
501
"enabled")
502
503
client["fingerprint"] = (section["fingerprint"].upper()
504
.replace(" ", ""))
505
if "secret" in section:
506
client["secret"] = section["secret"].decode("base64")
507
elif "secfile" in section:
508
with open(os.path.expanduser(os.path.expandvars
509
(section["secfile"])),
510
"rb") as secfile:
511
client["secret"] = secfile.read()
512
else:
513
raise TypeError("No secret or secfile for section {0}"
514
.format(section))
515
client["timeout"] = string_to_delta(section["timeout"])
516
client["extended_timeout"] = string_to_delta(
517
section["extended_timeout"])
518
client["interval"] = string_to_delta(section["interval"])
519
client["approval_delay"] = string_to_delta(
520
section["approval_delay"])
521
client["approval_duration"] = string_to_delta(
522
section["approval_duration"])
523
client["checker_command"] = section["checker"]
524
client["last_approval_request"] = None
525
client["last_checked_ok"] = None
526
client["last_checker_status"] = -2
527
528
return settings
529
530
def __init__(self, settings, name = None, server_settings=None):
374
531
self.name = name
375
if config is None:
376
config = {}
532
if server_settings is None:
533
server_settings = {}
534
self.server_settings = server_settings
535
# adding all client settings
536
for setting, value in settings.iteritems():
537
setattr(self, setting, value)
538
539
if self.enabled:
540
if not hasattr(self, "last_enabled"):
541
self.last_enabled = datetime.datetime.utcnow()
542
if not hasattr(self, "expires"):
543
self.expires = (datetime.datetime.utcnow()
544
+ self.timeout)
545
else:
546
self.last_enabled = None
547
self.expires = None
548
377
549
logger.debug("Creating client %r", self.name)
378
550
# Uppercase and remove spaces from fingerprint for later
379
551
# comparison purposes with return value from the fingerprint()
380
552
# function
381
self.fingerprint = (config["fingerprint"].upper()
382
.replace(" ", ""))
383
553
logger.debug(" Fingerprint: %s", self.fingerprint)
384
if "secret" in config:
385
self.secret = config["secret"].decode("base64")
386
elif "secfile" in config:
387
with open(os.path.expanduser(os.path.expandvars
388
(config["secfile"])),
389
"rb") as secfile:
390
self.secret = secfile.read()
391
else:
392
raise TypeError("No secret or secfile for client %s"
393
% self.name)
394
self.host = config.get("host", "")
395
self.created = datetime.datetime.utcnow()
396
self.enabled = True
397
self.last_approval_request = None
398
self.last_enabled = datetime.datetime.utcnow()
399
self.last_checked_ok = None
400
self.last_checker_status = None
401
self.timeout = string_to_delta(config["timeout"])
402
self.extended_timeout = string_to_delta(config
403
["extended_timeout"])
404
self.interval = string_to_delta(config["interval"])
554
self.created = settings.get("created",
555
datetime.datetime.utcnow())
556
557
# attributes specific for this server instance
405
558
self.checker = None
406
559
self.checker_initiator_tag = None
407
560
self.disable_initiator_tag = None
408
self.expires = datetime.datetime.utcnow() + self.timeout
409
561
self.checker_callback_tag = None
410
self.checker_command = config["checker"]
411
562
self.current_checker_command = None
412
self._approved = None
413
self.approved_by_default = config.get("approved_by_default",
414
True)
563
self.approved = None
415
564
self.approvals_pending = 0
416
self.approval_delay = string_to_delta(
417
config["approval_delay"])
418
self.approval_duration = string_to_delta(
419
config["approval_duration"])
420
565
self.changedstate = (multiprocessing_manager
421
566
.Condition(multiprocessing_manager
422
567
.Lock()))
442
587
if getattr(self, "enabled", False):
443
588
# Already enabled
444
589
return
445
self.send_changedstate()
446
590
self.expires = datetime.datetime.utcnow() + self.timeout
447
591
self.enabled = True
448
592
self.last_enabled = datetime.datetime.utcnow()
449
593
self.init_checker()
594
self.send_changedstate()
450
595
451
596
def disable(self, quiet=True):
452
597
"""Disable this client."""
453
598
if not getattr(self, "enabled", False):
454
599
return False
455
600
if not quiet:
456
self.send_changedstate()
457
if not quiet:
458
601
logger.info("Disabling client %s", self.name)
459
if getattr(self, "disable_initiator_tag", False):
602
if getattr(self, "disable_initiator_tag", None) is not None:
460
603
gobject.source_remove(self.disable_initiator_tag)
461
604
self.disable_initiator_tag = None
462
605
self.expires = None
463
if getattr(self, "checker_initiator_tag", False):
606
if getattr(self, "checker_initiator_tag", None) is not None:
464
607
gobject.source_remove(self.checker_initiator_tag)
465
608
self.checker_initiator_tag = None
466
609
self.stop_checker()
467
610
self.enabled = False
611
if not quiet:
612
self.send_changedstate()
468
613
# Do not run this again if called by a gobject.timeout_add
469
614
return False
470
615
474
619
def init_checker(self):
475
620
# Schedule a new checker to be started an 'interval' from now,
476
621
# and every interval from then on.
622
if self.checker_initiator_tag is not None:
623
gobject.source_remove(self.checker_initiator_tag)
477
624
self.checker_initiator_tag = (gobject.timeout_add
478
625
(self.interval_milliseconds(),
479
626
self.start_checker))
480
627
# Schedule a disable() when 'timeout' has passed
628
if self.disable_initiator_tag is not None:
629
gobject.source_remove(self.disable_initiator_tag)
481
630
self.disable_initiator_tag = (gobject.timeout_add
482
631
(self.timeout_milliseconds(),
483
632
self.disable))
489
638
self.checker_callback_tag = None
490
639
self.checker = None
491
640
if os.WIFEXITED(condition):
492
self.last_checker_status = os.WEXITSTATUS(condition)
641
self.last_checker_status = os.WEXITSTATUS(condition)
493
642
if self.last_checker_status == 0:
494
643
logger.info("Checker for %(name)s succeeded",
495
644
vars(self))
502
651
logger.warning("Checker for %(name)s crashed?",
503
652
vars(self))
504
653
505
def checked_ok(self, timeout=None):
506
"""Bump up the timeout for this client.
507
508
This should only be called when the client has been seen,
509
alive and well.
510
"""
654
def checked_ok(self):
655
"""Assert that the client has been seen, alive and well."""
656
self.last_checked_ok = datetime.datetime.utcnow()
657
self.last_checker_status = 0
658
self.bump_timeout()
659
660
def bump_timeout(self, timeout=None):
661
"""Bump up the timeout for this client."""
511
662
if timeout is None:
512
663
timeout = self.timeout
513
self.last_checked_ok = datetime.datetime.utcnow()
514
664
if self.disable_initiator_tag is not None:
515
665
gobject.source_remove(self.disable_initiator_tag)
666
self.disable_initiator_tag = None
516
667
if getattr(self, "enabled", False):
517
668
self.disable_initiator_tag = (gobject.timeout_add
518
(_timedelta_to_milliseconds
669
(timedelta_to_milliseconds
519
670
(timeout), self.disable))
520
671
self.expires = datetime.datetime.utcnow() + timeout
521
672
528
679
If a checker already exists, leave it running and do
529
680
nothing."""
530
681
# The reason for not killing a running checker is that if we
531
# did that, then if a checker (for some reason) started
532
# running slowly and taking more than 'interval' time, the
533
# client would inevitably timeout, since no checker would get
534
# a chance to run to completion. If we instead leave running
682
# did that, and if a checker (for some reason) started running
683
# slowly and taking more than 'interval' time, then the client
684
# would inevitably timeout, since no checker would get a
685
# chance to run to completion. If we instead leave running
535
686
# checkers alone, the checker would have to take more time
536
687
# than 'timeout' for the client to be disabled, which is as it
537
688
# should be.
551
702
self.current_checker_command)
552
703
# Start a new checker if needed
553
704
if self.checker is None:
705
# Escape attributes for the shell
706
escaped_attrs = dict(
707
(attr, re.escape(unicode(getattr(self, attr))))
708
for attr in
709
self.runtime_expansions)
554
710
try:
555
# In case checker_command has exactly one % operator
556
command = self.checker_command % self.host
557
except TypeError:
558
# Escape attributes for the shell
559
escaped_attrs = dict(
560
(attr,
561
re.escape(unicode(str(getattr(self, attr, "")),
562
errors=
563
'replace')))
564
for attr in
565
self.runtime_expansions)
566
567
try:
568
command = self.checker_command % escaped_attrs
569
except TypeError as error:
570
logger.error('Could not format string "%s":'
571
' %s', self.checker_command, error)
572
return True # Try again later
711
command = self.checker_command % escaped_attrs
712
except TypeError as error:
713
logger.error('Could not format string "%s"',
714
self.checker_command, exc_info=error)
715
return True # Try again later
573
716
self.current_checker_command = command
574
717
try:
575
718
logger.info("Starting checker %r for %s",
578
721
# in normal mode, that is already done by daemon(),
579
722
# and in debug mode we don't want to. (Stdin is
580
723
# always replaced by /dev/null.)
724
# The exception is when not debugging but nevertheless
725
# running in the foreground; use the previously
726
# created wnull.
727
popen_args = {}
728
if (not self.server_settings["debug"]
729
and self.server_settings["foreground"]):
730
popen_args.update({"stdout": wnull,
731
"stderr": wnull })
581
732
self.checker = subprocess.Popen(command,
582
733
close_fds=True,
583
shell=True, cwd="/")
584
self.checker_callback_tag = (gobject.child_watch_add
585
(self.checker.pid,
586
self.checker_callback,
587
data=command))
588
# The checker may have completed before the gobject
589
# watch was added. Check for this.
734
shell=True, cwd="/",
735
**popen_args)
736
except OSError as error:
737
logger.error("Failed to start subprocess",
738
exc_info=error)
739
return True
740
self.checker_callback_tag = (gobject.child_watch_add
741
(self.checker.pid,
742
self.checker_callback,
743
data=command))
744
# The checker may have completed before the gobject
745
# watch was added. Check for this.
746
try:
590
747
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
591
if pid:
592
gobject.source_remove(self.checker_callback_tag)
593
self.checker_callback(pid, status, command)
594
748
except OSError as error:
595
logger.error("Failed to start subprocess: %s",
596
error)
749
if error.errno == errno.ECHILD:
750
# This should never happen
751
logger.error("Child process vanished",
752
exc_info=error)
753
return True
754
raise
755
if pid:
756
gobject.source_remove(self.checker_callback_tag)
757
self.checker_callback(pid, status, command)
597
758
# Re-run this periodically if run by gobject.timeout_add
598
759
return True
599
760
606
767
return
607
768
logger.debug("Stopping checker for %(name)s", vars(self))
608
769
try:
609
os.kill(self.checker.pid, signal.SIGTERM)
770
self.checker.terminate()
610
771
#time.sleep(0.5)
611
772
#if self.checker.poll() is None:
612
# os.kill(self.checker.pid, signal.SIGKILL)
773
# self.checker.kill()
613
774
except OSError as error:
614
775
if error.errno != errno.ESRCH: # No such process
615
776
raise
616
777
self.checker = None
617
618
# Encrypts a client secret and stores it in a varible
619
# encrypted_secret
620
def encrypt_secret(self, key):
621
# Encryption-key need to be of a specific size, so we hash
622
# inputed key
623
hasheng = hashlib.sha256()
624
hasheng.update(key)
625
encryptionkey = hasheng.digest()
626
627
# Create validation hash so we know at decryption if it was
628
# sucessful
629
hasheng = hashlib.sha256()
630
hasheng.update(self.secret)
631
validationhash = hasheng.digest()
632
633
# Encrypt secret
634
iv = os.urandom(Crypto.Cipher.AES.block_size)
635
ciphereng = Crypto.Cipher.AES.new(encryptionkey,
636
Crypto.Cipher.AES.MODE_CFB,
637
iv)
638
ciphertext = ciphereng.encrypt(validationhash+self.secret)
639
self.encrypted_secret = (ciphertext, iv)
640
641
# Decrypt a encrypted client secret
642
def decrypt_secret(self, key):
643
# Decryption-key need to be of a specific size, so we hash inputed key
644
hasheng = hashlib.sha256()
645
hasheng.update(key)
646
encryptionkey = hasheng.digest()
647
648
# Decrypt encrypted secret
649
ciphertext, iv = self.encrypted_secret
650
ciphereng = Crypto.Cipher.AES.new(encryptionkey,
651
Crypto.Cipher.AES.MODE_CFB,
652
iv)
653
plain = ciphereng.decrypt(ciphertext)
654
655
# Validate decrypted secret to know if it was succesful
656
hasheng = hashlib.sha256()
657
validationhash = plain[:hasheng.digest_size]
658
secret = plain[hasheng.digest_size:]
659
hasheng.update(secret)
660
661
# if validation fails, we use key as new secret. Otherwhise,
662
# we use the decrypted secret
663
if hasheng.digest() == validationhash:
664
self.secret = secret
665
else:
666
self.secret = key
667
del self.encrypted_secret
668
778
669
779
670
780
def dbus_service_property(dbus_interface, signature="v",
683
793
# "Set" method, so we fail early here:
684
794
if byte_arrays and signature != "ay":
685
795
raise ValueError("Byte arrays not supported for non-'ay'"
686
" signature %r" % signature)
796
" signature {0!r}".format(signature))
687
797
def decorator(func):
688
798
func._dbus_is_property = True
689
799
func._dbus_interface = dbus_interface
697
807
return decorator
698
808
699
809
810
def dbus_interface_annotations(dbus_interface):
811
"""Decorator for marking functions returning interface annotations
812
813
Usage:
814
815
@dbus_interface_annotations("org.example.Interface")
816
def _foo(self): # Function name does not matter
817
return {"org.freedesktop.DBus.Deprecated": "true",
818
"org.freedesktop.DBus.Property.EmitsChangedSignal":
819
"false"}
820
"""
821
def decorator(func):
822
func._dbus_is_interface = True
823
func._dbus_interface = dbus_interface
824
func._dbus_name = dbus_interface
825
return func
826
return decorator
827
828
829
def dbus_annotations(annotations):
830
"""Decorator to annotate D-Bus methods, signals or properties
831
Usage:
832
833
@dbus_service_property("org.example.Interface", signature="b",
834
access="r")
835
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
836
"org.freedesktop.DBus.Property."
837
"EmitsChangedSignal": "false"})
838
def Property_dbus_property(self):
839
return dbus.Boolean(False)
840
"""
841
def decorator(func):
842
func._dbus_annotations = annotations
843
return func
844
return decorator
845
846
700
847
class DBusPropertyException(dbus.exceptions.DBusException):
701
848
"""A base class for D-Bus property-related exceptions
702
849
"""
725
872
"""
726
873
727
874
@staticmethod
728
def _is_dbus_property(obj):
729
return getattr(obj, "_dbus_is_property", False)
875
def _is_dbus_thing(thing):
876
"""Returns a function testing if an attribute is a D-Bus thing
877
878
If called like _is_dbus_thing("method") it returns a function
879
suitable for use as predicate to inspect.getmembers().
880
"""
881
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
882
False)
730
883
731
def _get_all_dbus_properties(self):
884
def _get_all_dbus_things(self, thing):
732
885
"""Returns a generator of (name, attribute) pairs
733
886
"""
734
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
887
return ((getattr(athing.__get__(self), "_dbus_name",
888
name),
889
athing.__get__(self))
735
890
for cls in self.__class__.__mro__
736
for name, prop in
737
inspect.getmembers(cls, self._is_dbus_property))
891
for name, athing in
892
inspect.getmembers(cls,
893
self._is_dbus_thing(thing)))
738
894
739
895
def _get_dbus_property(self, interface_name, property_name):
740
896
"""Returns a bound method if one exists which is a D-Bus
742
898
"""
743
899
for cls in self.__class__.__mro__:
744
900
for name, value in (inspect.getmembers
745
(cls, self._is_dbus_property)):
901
(cls,
902
self._is_dbus_thing("property"))):
746
903
if (value._dbus_name == property_name
747
904
and value._dbus_interface == interface_name):
748
905
return value.__get__(self)
777
934
# signatures other than "ay".
778
935
if prop._dbus_signature != "ay":
779
936
raise ValueError
780
value = dbus.ByteArray(''.join(unichr(byte)
781
for byte in value))
937
value = dbus.ByteArray(b''.join(chr(byte)
938
for byte in value))
782
939
prop(value)
783
940
784
941
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
790
947
Note: Will not include properties with access="write".
791
948
"""
792
949
properties = {}
793
for name, prop in self._get_all_dbus_properties():
950
for name, prop in self._get_all_dbus_things("property"):
794
951
if (interface_name
795
952
and interface_name != prop._dbus_interface):
796
953
# Interface non-empty but did not match
811
968
path_keyword='object_path',
812
969
connection_keyword='connection')
813
970
def Introspect(self, object_path, connection):
814
"""Standard D-Bus method, overloaded to insert property tags.
971
"""Overloading of standard D-Bus method.
972
973
Inserts property tags and interface annotation tags.
815
974
"""
816
975
xmlstring = dbus.service.Object.Introspect(self, object_path,
817
976
connection)
824
983
e.setAttribute("access", prop._dbus_access)
825
984
return e
826
985
for if_tag in document.getElementsByTagName("interface"):
986
# Add property tags
827
987
for tag in (make_tag(document, name, prop)
828
988
for name, prop
829
in self._get_all_dbus_properties()
989
in self._get_all_dbus_things("property")
830
990
if prop._dbus_interface
831
991
== if_tag.getAttribute("name")):
832
992
if_tag.appendChild(tag)
993
# Add annotation tags
994
for typ in ("method", "signal", "property"):
995
for tag in if_tag.getElementsByTagName(typ):
996
annots = dict()
997
for name, prop in (self.
998
_get_all_dbus_things(typ)):
999
if (name == tag.getAttribute("name")
1000
and prop._dbus_interface
1001
== if_tag.getAttribute("name")):
1002
annots.update(getattr
1003
(prop,
1004
"_dbus_annotations",
1005
{}))
1006
for name, value in annots.iteritems():
1007
ann_tag = document.createElement(
1008
"annotation")
1009
ann_tag.setAttribute("name", name)
1010
ann_tag.setAttribute("value", value)
1011
tag.appendChild(ann_tag)
1012
# Add interface annotation tags
1013
for annotation, value in dict(
1014
itertools.chain.from_iterable(
1015
annotations().iteritems()
1016
for name, annotations in
1017
self._get_all_dbus_things("interface")
1018
if name == if_tag.getAttribute("name")
1019
)).iteritems():
1020
ann_tag = document.createElement("annotation")
1021
ann_tag.setAttribute("name", annotation)
1022
ann_tag.setAttribute("value", value)
1023
if_tag.appendChild(ann_tag)
833
1024
# Add the names to the return values for the
834
1025
# "org.freedesktop.DBus.Properties" methods
835
1026
if (if_tag.getAttribute("name")
850
1041
except (AttributeError, xml.dom.DOMException,
851
1042
xml.parsers.expat.ExpatError) as error:
852
1043
logger.error("Failed to override Introspection method",
853
error)
1044
exc_info=error)
854
1045
return xmlstring
855
1046
856
1047
857
def datetime_to_dbus (dt, variant_level=0):
1048
def datetime_to_dbus(dt, variant_level=0):
858
1049
"""Convert a UTC datetime.datetime() to a D-Bus type."""
859
1050
if dt is None:
860
1051
return dbus.String("", variant_level = variant_level)
862
1053
variant_level=variant_level)
863
1054
864
1055
865
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
866
.__metaclass__):
867
"""Applied to an empty subclass of a D-Bus object, this metaclass
868
will add additional D-Bus attributes matching a certain pattern.
1056
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1057
"""A class decorator; applied to a subclass of
1058
dbus.service.Object, it will add alternate D-Bus attributes with
1059
interface names according to the "alt_interface_names" mapping.
1060
Usage:
1061
1062
@alternate_dbus_interfaces({"org.example.Interface":
1063
"net.example.AlternateInterface"})
1064
class SampleDBusObject(dbus.service.Object):
1065
@dbus.service.method("org.example.Interface")
1066
def SampleDBusMethod():
1067
pass
1068
1069
The above "SampleDBusMethod" on "SampleDBusObject" will be
1070
reachable via two interfaces: "org.example.Interface" and
1071
"net.example.AlternateInterface", the latter of which will have
1072
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1073
"true", unless "deprecate" is passed with a False value.
1074
1075
This works for methods and signals, and also for D-Bus properties
1076
(from DBusObjectWithProperties) and interfaces (from the
1077
dbus_interface_annotations decorator).
869
1078
"""
870
def __new__(mcs, name, bases, attr):
871
# Go through all the base classes which could have D-Bus
872
# methods, signals, or properties in them
873
for base in (b for b in bases
874
if issubclass(b, dbus.service.Object)):
875
# Go though all attributes of the base class
876
for attrname, attribute in inspect.getmembers(base):
1079
def wrapper(cls):
1080
for orig_interface_name, alt_interface_name in (
1081
alt_interface_names.iteritems()):
1082
attr = {}
1083
interface_names = set()
1084
# Go though all attributes of the class
1085
for attrname, attribute in inspect.getmembers(cls):
877
1086
# Ignore non-D-Bus attributes, and D-Bus attributes
878
1087
# with the wrong interface name
879
1088
if (not hasattr(attribute, "_dbus_interface")
880
1089
or not attribute._dbus_interface
881
.startswith("se.recompile.Mandos")):
1090
.startswith(orig_interface_name)):
882
1091
continue
883
1092
# Create an alternate D-Bus interface name based on
884
1093
# the current name
885
1094
alt_interface = (attribute._dbus_interface
886
.replace("se.recompile.Mandos",
887
"se.bsnet.fukt.Mandos"))
1095
.replace(orig_interface_name,
1096
alt_interface_name))
1097
interface_names.add(alt_interface)
888
1098
# Is this a D-Bus signal?
889
1099
if getattr(attribute, "_dbus_is_signal", False):
890
# Extract the original non-method function by
891
# black magic
1100
# Extract the original non-method undecorated
1101
# function by black magic
892
1102
nonmethod_func = (dict(
893
1103
zip(attribute.func_code.co_freevars,
894
1104
attribute.__closure__))["func"]
905
1115
nonmethod_func.func_name,
906
1116
nonmethod_func.func_defaults,
907
1117
nonmethod_func.func_closure)))
1118
# Copy annotations, if any
1119
try:
1120
new_function._dbus_annotations = (
1121
dict(attribute._dbus_annotations))
1122
except AttributeError:
1123
pass
908
1124
# Define a creator of a function to call both the
909
# old and new functions, so both the old and new
910
# signals gets sent when the function is called
1125
# original and alternate functions, so both the
1126
# original and alternate signals gets sent when
1127
# the function is called
911
1128
def fixscope(func1, func2):
912
1129
"""This function is a scope container to pass
913
1130
func1 and func2 to the "call_both" function
920
1137
return call_both
921
1138
# Create the "call_both" function and add it to
922
1139
# the class
923
attr[attrname] = fixscope(attribute,
924
new_function)
1140
attr[attrname] = fixscope(attribute, new_function)
925
1141
# Is this a D-Bus method?
926
1142
elif getattr(attribute, "_dbus_is_method", False):
927
1143
# Create a new, but exactly alike, function
938
1154
attribute.func_name,
939
1155
attribute.func_defaults,
940
1156
attribute.func_closure)))
1157
# Copy annotations, if any
1158
try:
1159
attr[attrname]._dbus_annotations = (
1160
dict(attribute._dbus_annotations))
1161
except AttributeError:
1162
pass
941
1163
# Is this a D-Bus property?
942
1164
elif getattr(attribute, "_dbus_is_property", False):
943
1165
# Create a new, but exactly alike, function
957
1179
attribute.func_name,
958
1180
attribute.func_defaults,
959
1181
attribute.func_closure)))
960
return type.__new__(mcs, name, bases, attr)
961
962
1182
# Copy annotations, if any
1183
try:
1184
attr[attrname]._dbus_annotations = (
1185
dict(attribute._dbus_annotations))
1186
except AttributeError:
1187
pass
1188
# Is this a D-Bus interface?
1189
elif getattr(attribute, "_dbus_is_interface", False):
1190
# Create a new, but exactly alike, function
1191
# object. Decorate it to be a new D-Bus interface
1192
# with the alternate D-Bus interface name. Add it
1193
# to the class.
1194
attr[attrname] = (dbus_interface_annotations
1195
(alt_interface)
1196
(types.FunctionType
1197
(attribute.func_code,
1198
attribute.func_globals,
1199
attribute.func_name,
1200
attribute.func_defaults,
1201
attribute.func_closure)))
1202
if deprecate:
1203
# Deprecate all alternate interfaces
1204
iname="_AlternateDBusNames_interface_annotation{0}"
1205
for interface_name in interface_names:
1206
@dbus_interface_annotations(interface_name)
1207
def func(self):
1208
return { "org.freedesktop.DBus.Deprecated":
1209
"true" }
1210
# Find an unused name
1211
for aname in (iname.format(i)
1212
for i in itertools.count()):
1213
if aname not in attr:
1214
attr[aname] = func
1215
break
1216
if interface_names:
1217
# Replace the class with a new subclass of it with
1218
# methods, signals, etc. as created above.
1219
cls = type(b"{0}Alternate".format(cls.__name__),
1220
(cls,), attr)
1221
return cls
1222
return wrapper
1223
1224
1225
@alternate_dbus_interfaces({"se.recompile.Mandos":
1226
"se.bsnet.fukt.Mandos"})
963
1227
class ClientDBus(Client, DBusObjectWithProperties):
964
1228
"""A Client class using D-Bus
965
1229
976
1240
def __init__(self, bus = None, *args, **kwargs):
977
1241
self.bus = bus
978
1242
Client.__init__(self, *args, **kwargs)
979
980
self._approvals_pending = 0
981
1243
# Only now, when this client is initialized, can it show up on
982
1244
# the D-Bus
983
1245
client_object_name = unicode(self.name).translate(
987
1249
("/clients/" + client_object_name))
988
1250
DBusObjectWithProperties.__init__(self, self.bus,
989
1251
self.dbus_object_path)
990
1252
991
1253
def notifychangeproperty(transform_func,
992
1254
dbus_name, type_func=lambda x: x,
993
1255
variant_level=1):
1016
1278
1017
1279
return property(lambda self: getattr(self, attrname), setter)
1018
1280
1019
1020
1281
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1021
1282
approvals_pending = notifychangeproperty(dbus.Boolean,
1022
1283
"ApprovalPending",
1029
1290
checker is not None)
1030
1291
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1031
1292
"LastCheckedOK")
1293
last_checker_status = notifychangeproperty(dbus.Int16,
1294
"LastCheckerStatus")
1032
1295
last_approval_request = notifychangeproperty(
1033
1296
datetime_to_dbus, "LastApprovalRequest")
1034
1297
approved_by_default = notifychangeproperty(dbus.Boolean,
1035
1298
"ApprovedByDefault")
1036
approval_delay = notifychangeproperty(dbus.UInt16,
1299
approval_delay = notifychangeproperty(dbus.UInt64,
1037
1300
"ApprovalDelay",
1038
1301
type_func =
1039
_timedelta_to_milliseconds)
1302
timedelta_to_milliseconds)
1040
1303
approval_duration = notifychangeproperty(
1041
dbus.UInt16, "ApprovalDuration",
1042
type_func = _timedelta_to_milliseconds)
1304
dbus.UInt64, "ApprovalDuration",
1305
type_func = timedelta_to_milliseconds)
1043
1306
host = notifychangeproperty(dbus.String, "Host")
1044
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1307
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1045
1308
type_func =
1046
_timedelta_to_milliseconds)
1309
timedelta_to_milliseconds)
1047
1310
extended_timeout = notifychangeproperty(
1048
dbus.UInt16, "ExtendedTimeout",
1049
type_func = _timedelta_to_milliseconds)
1050
interval = notifychangeproperty(dbus.UInt16,
1311
dbus.UInt64, "ExtendedTimeout",
1312
type_func = timedelta_to_milliseconds)
1313
interval = notifychangeproperty(dbus.UInt64,
1051
1314
"Interval",
1052
1315
type_func =
1053
_timedelta_to_milliseconds)
1316
timedelta_to_milliseconds)
1054
1317
checker_command = notifychangeproperty(dbus.String, "Checker")
1055
1318
1056
1319
del notifychangeproperty
1098
1361
return r
1099
1362
1100
1363
def _reset_approved(self):
1101
self._approved = None
1364
self.approved = None
1102
1365
return False
1103
1366
1104
1367
def approve(self, value=True):
1105
self.send_changedstate()
1106
self._approved = value
1107
gobject.timeout_add(_timedelta_to_milliseconds
1368
self.approved = value
1369
gobject.timeout_add(timedelta_to_milliseconds
1108
1370
(self.approval_duration),
1109
1371
self._reset_approved)
1110
1372
self.send_changedstate()
1111
1373
1112
1374
## D-Bus methods, signals & properties
1113
1375
_interface = "se.recompile.Mandos.Client"
1114
1376
1377
## Interfaces
1378
1379
@dbus_interface_annotations(_interface)
1380
def _foo(self):
1381
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1382
"false"}
1383
1115
1384
## Signals
1116
1385
1117
1386
# CheckerCompleted - signal
1153
1422
"D-Bus signal"
1154
1423
return self.need_approval()
1155
1424
1156
# NeRwequest - signal
1157
@dbus.service.signal(_interface, signature="s")
1158
def NewRequest(self, ip):
1159
"""D-Bus signal
1160
Is sent after a client request a password.
1161
"""
1162
pass
1163
1164
1425
## Methods
1165
1426
1166
1427
# Approve - method
1224
1485
access="readwrite")
1225
1486
def ApprovalDuration_dbus_property(self, value=None):
1226
1487
if value is None: # get
1227
return dbus.UInt64(_timedelta_to_milliseconds(
1488
return dbus.UInt64(timedelta_to_milliseconds(
1228
1489
self.approval_duration))
1229
1490
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1230
1491
1244
1505
def Host_dbus_property(self, value=None):
1245
1506
if value is None: # get
1246
1507
return dbus.String(self.host)
1247
self.host = value
1508
self.host = unicode(value)
1248
1509
1249
1510
# Created - property
1250
1511
@dbus_service_property(_interface, signature="s", access="read")
1251
1512
def Created_dbus_property(self):
1252
return dbus.String(datetime_to_dbus(self.created))
1513
return datetime_to_dbus(self.created)
1253
1514
1254
1515
# LastEnabled - property
1255
1516
@dbus_service_property(_interface, signature="s", access="read")
1276
1537
return
1277
1538
return datetime_to_dbus(self.last_checked_ok)
1278
1539
1540
# LastCheckerStatus - property
1541
@dbus_service_property(_interface, signature="n",
1542
access="read")
1543
def LastCheckerStatus_dbus_property(self):
1544
return dbus.Int16(self.last_checker_status)
1545
1279
1546
# Expires - property
1280
1547
@dbus_service_property(_interface, signature="s", access="read")
1281
1548
def Expires_dbus_property(self):
1292
1559
def Timeout_dbus_property(self, value=None):
1293
1560
if value is None: # get
1294
1561
return dbus.UInt64(self.timeout_milliseconds())
1562
old_timeout = self.timeout
1295
1563
self.timeout = datetime.timedelta(0, 0, 0, value)
1296
if getattr(self, "disable_initiator_tag", None) is None:
1297
return
1298
# Reschedule timeout
1299
gobject.source_remove(self.disable_initiator_tag)
1300
self.disable_initiator_tag = None
1301
self.expires = None
1302
time_to_die = _timedelta_to_milliseconds((self
1303
.last_checked_ok
1304
+ self.timeout)
1305
- datetime.datetime
1306
.utcnow())
1307
if time_to_die <= 0:
1308
# The timeout has passed
1309
self.disable()
1310
else:
1311
self.expires = (datetime.datetime.utcnow()
1312
+ datetime.timedelta(milliseconds =
1313
time_to_die))
1314
self.disable_initiator_tag = (gobject.timeout_add
1315
(time_to_die, self.disable))
1564
# Reschedule disabling
1565
if self.enabled:
1566
now = datetime.datetime.utcnow()
1567
self.expires += self.timeout - old_timeout
1568
if self.expires <= now:
1569
# The timeout has passed
1570
self.disable()
1571
else:
1572
if (getattr(self, "disable_initiator_tag", None)
1573
is None):
1574
return
1575
gobject.source_remove(self.disable_initiator_tag)
1576
self.disable_initiator_tag = (
1577
gobject.timeout_add(
1578
timedelta_to_milliseconds(self.expires - now),
1579
self.disable))
1316
1580
1317
1581
# ExtendedTimeout - property
1318
1582
@dbus_service_property(_interface, signature="t",
1331
1595
self.interval = datetime.timedelta(0, 0, 0, value)
1332
1596
if getattr(self, "checker_initiator_tag", None) is None:
1333
1597
return
1334
# Reschedule checker run
1335
gobject.source_remove(self.checker_initiator_tag)
1336
self.checker_initiator_tag = (gobject.timeout_add
1337
(value, self.start_checker))
1338
self.start_checker() # Start one now, too
1598
if self.enabled:
1599
# Reschedule checker run
1600
gobject.source_remove(self.checker_initiator_tag)
1601
self.checker_initiator_tag = (gobject.timeout_add
1602
(value, self.start_checker))
1603
self.start_checker() # Start one now, too
1339
1604
1340
1605
# Checker - property
1341
1606
@dbus_service_property(_interface, signature="s",
1343
1608
def Checker_dbus_property(self, value=None):
1344
1609
if value is None: # get
1345
1610
return dbus.String(self.checker_command)
1346
self.checker_command = value
1611
self.checker_command = unicode(value)
1347
1612
1348
1613
# CheckerRunning - property
1349
1614
@dbus_service_property(_interface, signature="b",
1378
1643
raise KeyError()
1379
1644
1380
1645
def __getattribute__(self, name):
1381
if(name == '_pipe'):
1646
if name == '_pipe':
1382
1647
return super(ProxyClient, self).__getattribute__(name)
1383
1648
self._pipe.send(('getattr', name))
1384
1649
data = self._pipe.recv()
1391
1656
return func
1392
1657
1393
1658
def __setattr__(self, name, value):
1394
if(name == '_pipe'):
1659
if name == '_pipe':
1395
1660
return super(ProxyClient, self).__setattr__(name, value)
1396
1661
self._pipe.send(('setattr', name, value))
1397
1662
1398
1663
1399
class ClientDBusTransitional(ClientDBus):
1400
__metaclass__ = AlternateDBusNamesMetaclass
1401
1402
1403
1664
class ClientHandler(socketserver.BaseRequestHandler, object):
1404
1665
"""A class to handle client connections.
1405
1666
1466
1727
logger.warning("Bad certificate: %s", error)
1467
1728
return
1468
1729
logger.debug("Fingerprint: %s", fpr)
1469
if self.server.use_dbus:
1470
# Emit D-Bus signal
1471
client.NewRequest(str(self.client_address))
1472
1730
1473
1731
try:
1474
1732
client = ProxyClient(child_pipe, fpr,
1490
1748
client.Rejected("Disabled")
1491
1749
return
1492
1750
1493
if client._approved or not client.approval_delay:
1751
if client.approved or not client.approval_delay:
1494
1752
#We are approved or approval is disabled
1495
1753
break
1496
elif client._approved is None:
1754
elif client.approved is None:
1497
1755
logger.info("Client %s needs approval",
1498
1756
client.name)
1499
1757
if self.server.use_dbus:
1512
1770
#wait until timeout or approved
1513
1771
time = datetime.datetime.now()
1514
1772
client.changedstate.acquire()
1515
(client.changedstate.wait
1516
(float(client._timedelta_to_milliseconds(delay)
1517
/ 1000)))
1773
client.changedstate.wait(
1774
float(timedelta_to_milliseconds(delay)
1775
/ 1000))
1518
1776
client.changedstate.release()
1519
1777
time2 = datetime.datetime.now()
1520
1778
if (time2 - time) >= delay:
1536
1794
try:
1537
1795
sent = session.send(client.secret[sent_size:])
1538
1796
except gnutls.errors.GNUTLSError as error:
1539
logger.warning("gnutls send failed")
1797
logger.warning("gnutls send failed",
1798
exc_info=error)
1540
1799
return
1541
1800
logger.debug("Sent: %d, remaining: %d",
1542
1801
sent, len(client.secret)
1545
1804
1546
1805
logger.info("Sending secret to %s", client.name)
1547
1806
# bump the timeout using extended_timeout
1548
client.checked_ok(client.extended_timeout)
1807
client.bump_timeout(client.extended_timeout)
1549
1808
if self.server.use_dbus:
1550
1809
# Emit D-Bus signal
1551
1810
client.GotSecret()
1556
1815
try:
1557
1816
session.bye()
1558
1817
except gnutls.errors.GNUTLSError as error:
1559
logger.warning("GnuTLS bye failed")
1818
logger.warning("GnuTLS bye failed",
1819
exc_info=error)
1560
1820
1561
1821
@staticmethod
1562
1822
def peer_certificate(session):
1618
1878
# Convert the buffer to a Python bytestring
1619
1879
fpr = ctypes.string_at(buf, buf_len.value)
1620
1880
# Convert the bytestring to hexadecimal notation
1621
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1881
hex_fpr = binascii.hexlify(fpr).upper()
1622
1882
return hex_fpr
1623
1883
1624
1884
1627
1887
def sub_process_main(self, request, address):
1628
1888
try:
1629
1889
self.finish_request(request, address)
1630
except:
1890
except Exception:
1631
1891
self.handle_error(request, address)
1632
1892
self.close_request(request)
1633
1893
1634
1894
def process_request(self, request, address):
1635
1895
"""Start a new process to process the request."""
1636
1896
proc = multiprocessing.Process(target = self.sub_process_main,
1637
args = (request,
1638
address))
1897
args = (request, address))
1639
1898
proc.start()
1640
1899
return proc
1641
1900
1669
1928
use_ipv6: Boolean; to use IPv6 or not
1670
1929
"""
1671
1930
def __init__(self, server_address, RequestHandlerClass,
1672
interface=None, use_ipv6=True):
1931
interface=None, use_ipv6=True, socketfd=None):
1932
"""If socketfd is set, use that file descriptor instead of
1933
creating a new one with socket.socket().
1934
"""
1673
1935
self.interface = interface
1674
1936
if use_ipv6:
1675
1937
self.address_family = socket.AF_INET6
1938
if socketfd is not None:
1939
# Save the file descriptor
1940
self.socketfd = socketfd
1941
# Save the original socket.socket() function
1942
self.socket_socket = socket.socket
1943
# To implement --socket, we monkey patch socket.socket.
1944
#
1945
# (When socketserver.TCPServer is a new-style class, we
1946
# could make self.socket into a property instead of monkey
1947
# patching socket.socket.)
1948
#
1949
# Create a one-time-only replacement for socket.socket()
1950
@functools.wraps(socket.socket)
1951
def socket_wrapper(*args, **kwargs):
1952
# Restore original function so subsequent calls are
1953
# not affected.
1954
socket.socket = self.socket_socket
1955
del self.socket_socket
1956
# This time only, return a new socket object from the
1957
# saved file descriptor.
1958
return socket.fromfd(self.socketfd, *args, **kwargs)
1959
# Replace socket.socket() function with wrapper
1960
socket.socket = socket_wrapper
1961
# The socketserver.TCPServer.__init__ will call
1962
# socket.socket(), which might be our replacement,
1963
# socket_wrapper(), if socketfd was set.
1676
1964
socketserver.TCPServer.__init__(self, server_address,
1677
1965
RequestHandlerClass)
1966
1678
1967
def server_bind(self):
1679
1968
"""This overrides the normal server_bind() function
1680
1969
to bind to an interface if one was specified, and also NOT to
1688
1977
try:
1689
1978
self.socket.setsockopt(socket.SOL_SOCKET,
1690
1979
SO_BINDTODEVICE,
1691
str(self.interface
1692
+ '\0'))
1980
str(self.interface + '\0'))
1693
1981
except socket.error as error:
1694
if error[0] == errno.EPERM:
1695
logger.error("No permission to"
1696
" bind to interface %s",
1697
self.interface)
1698
elif error[0] == errno.ENOPROTOOPT:
1982
if error.errno == errno.EPERM:
1983
logger.error("No permission to bind to"
1984
" interface %s", self.interface)
1985
elif error.errno == errno.ENOPROTOOPT:
1699
1986
logger.error("SO_BINDTODEVICE not available;"
1700
1987
" cannot bind to interface %s",
1701
1988
self.interface)
1989
elif error.errno == errno.ENODEV:
1990
logger.error("Interface %s does not exist,"
1991
" cannot bind", self.interface)
1702
1992
else:
1703
1993
raise
1704
1994
# Only bind(2) the socket if we really need to.
1707
1997
if self.address_family == socket.AF_INET6:
1708
1998
any_address = "::" # in6addr_any
1709
1999
else:
1710
any_address = socket.INADDR_ANY
2000
any_address = "0.0.0.0" # INADDR_ANY
1711
2001
self.server_address = (any_address,
1712
2002
self.server_address[1])
1713
2003
elif not self.server_address[1]:
1734
2024
"""
1735
2025
def __init__(self, server_address, RequestHandlerClass,
1736
2026
interface=None, use_ipv6=True, clients=None,
1737
gnutls_priority=None, use_dbus=True):
2027
gnutls_priority=None, use_dbus=True, socketfd=None):
1738
2028
self.enabled = False
1739
2029
self.clients = clients
1740
2030
if self.clients is None:
1744
2034
IPv6_TCPServer.__init__(self, server_address,
1745
2035
RequestHandlerClass,
1746
2036
interface = interface,
1747
use_ipv6 = use_ipv6)
2037
use_ipv6 = use_ipv6,
2038
socketfd = socketfd)
1748
2039
def server_activate(self):
1749
2040
if self.enabled:
1750
2041
return socketserver.TCPServer.server_activate(self)
1763
2054
1764
2055
def handle_ipc(self, source, condition, parent_pipe=None,
1765
2056
proc = None, client_object=None):
1766
condition_names = {
1767
gobject.IO_IN: "IN", # There is data to read.
1768
gobject.IO_OUT: "OUT", # Data can be written (without
1769
# blocking).
1770
gobject.IO_PRI: "PRI", # There is urgent data to read.
1771
gobject.IO_ERR: "ERR", # Error condition.
1772
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1773
# broken, usually for pipes and
1774
# sockets).
1775
}
1776
conditions_string = ' | '.join(name
1777
for cond, name in
1778
condition_names.iteritems()
1779
if cond & condition)
1780
2057
# error, or the other end of multiprocessing.Pipe has closed
1781
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2058
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1782
2059
# Wait for other process to exit
1783
2060
proc.join()
1784
2061
return False
1842
2119
return True
1843
2120
1844
2121
2122
def rfc3339_duration_to_delta(duration):
2123
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2124
2125
>>> rfc3339_duration_to_delta("P7D")
2126
datetime.timedelta(7)
2127
>>> rfc3339_duration_to_delta("PT60S")
2128
datetime.timedelta(0, 60)
2129
>>> rfc3339_duration_to_delta("PT60M")
2130
datetime.timedelta(0, 3600)
2131
>>> rfc3339_duration_to_delta("PT24H")
2132
datetime.timedelta(1)
2133
>>> rfc3339_duration_to_delta("P1W")
2134
datetime.timedelta(7)
2135
>>> rfc3339_duration_to_delta("PT5M30S")
2136
datetime.timedelta(0, 330)
2137
>>> rfc3339_duration_to_delta("P1DT3M20S")
2138
datetime.timedelta(1, 200)
2139
"""
2140
2141
# Parsing an RFC 3339 duration with regular expressions is not
2142
# possible - there would have to be multiple places for the same
2143
# values, like seconds. The current code, while more esoteric, is
2144
# cleaner without depending on a parsing library. If Python had a
2145
# built-in library for parsing we would use it, but we'd like to
2146
# avoid excessive use of external libraries.
2147
2148
# New type for defining tokens, syntax, and semantics all-in-one
2149
Token = collections.namedtuple("Token",
2150
("regexp", # To match token; if
2151
# "value" is not None,
2152
# must have a "group"
2153
# containing digits
2154
"value", # datetime.timedelta or
2155
# None
2156
"followers")) # Tokens valid after
2157
# this token
2158
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2159
# the "duration" ABNF definition in RFC 3339, Appendix A.
2160
token_end = Token(re.compile(r"$"), None, frozenset())
2161
token_second = Token(re.compile(r"(\d+)S"),
2162
datetime.timedelta(seconds=1),
2163
frozenset((token_end,)))
2164
token_minute = Token(re.compile(r"(\d+)M"),
2165
datetime.timedelta(minutes=1),
2166
frozenset((token_second, token_end)))
2167
token_hour = Token(re.compile(r"(\d+)H"),
2168
datetime.timedelta(hours=1),
2169
frozenset((token_minute, token_end)))
2170
token_time = Token(re.compile(r"T"),
2171
None,
2172
frozenset((token_hour, token_minute,
2173
token_second)))
2174
token_day = Token(re.compile(r"(\d+)D"),
2175
datetime.timedelta(days=1),
2176
frozenset((token_time, token_end)))
2177
token_month = Token(re.compile(r"(\d+)M"),
2178
datetime.timedelta(weeks=4),
2179
frozenset((token_day, token_end)))
2180
token_year = Token(re.compile(r"(\d+)Y"),
2181
datetime.timedelta(weeks=52),
2182
frozenset((token_month, token_end)))
2183
token_week = Token(re.compile(r"(\d+)W"),
2184
datetime.timedelta(weeks=1),
2185
frozenset((token_end,)))
2186
token_duration = Token(re.compile(r"P"), None,
2187
frozenset((token_year, token_month,
2188
token_day, token_time,
2189
token_week))),
2190
# Define starting values
2191
value = datetime.timedelta() # Value so far
2192
found_token = None
2193
followers = frozenset(token_duration,) # Following valid tokens
2194
s = duration # String left to parse
2195
# Loop until end token is found
2196
while found_token is not token_end:
2197
# Search for any currently valid tokens
2198
for token in followers:
2199
match = token.regexp.match(s)
2200
if match is not None:
2201
# Token found
2202
if token.value is not None:
2203
# Value found, parse digits
2204
factor = int(match.group(1), 10)
2205
# Add to value so far
2206
value += factor * token.value
2207
# Strip token from string
2208
s = token.regexp.sub("", s, 1)
2209
# Go to found token
2210
found_token = token
2211
# Set valid next tokens
2212
followers = found_token.followers
2213
break
2214
else:
2215
# No currently valid tokens were found
2216
raise ValueError("Invalid RFC 3339 duration")
2217
# End token found
2218
return value
2219
2220
1845
2221
def string_to_delta(interval):
1846
2222
"""Parse a string and return a datetime.timedelta
1847
2223
1858
2234
>>> string_to_delta('5m 30s')
1859
2235
datetime.timedelta(0, 330)
1860
2236
"""
2237
2238
try:
2239
return rfc3339_duration_to_delta(interval)
2240
except ValueError:
2241
pass
2242
1861
2243
timevalue = datetime.timedelta(0)
1862
2244
for s in interval.split():
1863
2245
try:
1874
2256
elif suffix == "w":
1875
2257
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1876
2258
else:
1877
raise ValueError("Unknown suffix %r" % suffix)
2259
raise ValueError("Unknown suffix {0!r}"
2260
.format(suffix))
1878
2261
except (ValueError, IndexError) as e:
1879
2262
raise ValueError(*(e.args))
1880
2263
timevalue += delta
1894
2277
sys.exit()
1895
2278
if not noclose:
1896
2279
# Close all standard open file descriptors
1897
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2280
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1898
2281
if not stat.S_ISCHR(os.fstat(null).st_mode):
1899
2282
raise OSError(errno.ENODEV,
1900
"%s not a character device"
1901
% os.path.devnull)
2283
"{0} not a character device"
2284
.format(os.devnull))
1902
2285
os.dup2(null, sys.stdin.fileno())
1903
2286
os.dup2(null, sys.stdout.fileno())
1904
2287
os.dup2(null, sys.stderr.fileno())
1913
2296
1914
2297
parser = argparse.ArgumentParser()
1915
2298
parser.add_argument("-v", "--version", action="version",
1916
version = "%%(prog)s %s" % version,
2299
version = "%(prog)s {0}".format(version),
1917
2300
help="show version number and exit")
1918
2301
parser.add_argument("-i", "--interface", metavar="IF",
1919
2302
help="Bind to interface IF")
1925
2308
help="Run self-test")
1926
2309
parser.add_argument("--debug", action="store_true",
1927
2310
help="Debug mode; run in foreground and log"
1928
" to terminal")
2311
" to terminal", default=None)
1929
2312
parser.add_argument("--debuglevel", metavar="LEVEL",
1930
2313
help="Debug level for stdout output")
1931
2314
parser.add_argument("--priority", help="GnuTLS"
1938
2321
" files")
1939
2322
parser.add_argument("--no-dbus", action="store_false",
1940
2323
dest="use_dbus", help="Do not provide D-Bus"
1941
" system bus interface")
2324
" system bus interface", default=None)
1942
2325
parser.add_argument("--no-ipv6", action="store_false",
1943
dest="use_ipv6", help="Do not use IPv6")
2326
dest="use_ipv6", help="Do not use IPv6",
2327
default=None)
1944
2328
parser.add_argument("--no-restore", action="store_false",
1945
2329
dest="restore", help="Do not restore stored"
1946
" state", default=True)
2330
" state", default=None)
2331
parser.add_argument("--socket", type=int,
2332
help="Specify a file descriptor to a network"
2333
" socket to use instead of creating one")
2334
parser.add_argument("--statedir", metavar="DIR",
2335
help="Directory to save/restore state in")
2336
parser.add_argument("--foreground", action="store_true",
2337
help="Run in foreground", default=None)
1947
2338
1948
2339
options = parser.parse_args()
1949
2340
1958
2349
"port": "",
1959
2350
"debug": "False",
1960
2351
"priority":
1961
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2352
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
1962
2353
"servicename": "Mandos",
1963
2354
"use_dbus": "True",
1964
2355
"use_ipv6": "True",
1965
2356
"debuglevel": "",
2357
"restore": "True",
2358
"socket": "",
2359
"statedir": "/var/lib/mandos",
2360
"foreground": "False",
1966
2361
}
1967
2362
1968
2363
# Parse config file for server-global settings
1973
2368
# Convert the SafeConfigParser object to a dict
1974
2369
server_settings = server_config.defaults()
1975
2370
# Use the appropriate methods on the non-string config options
1976
for option in ("debug", "use_dbus", "use_ipv6"):
2371
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
1977
2372
server_settings[option] = server_config.getboolean("DEFAULT",
1978
2373
option)
1979
2374
if server_settings["port"]:
1980
2375
server_settings["port"] = server_config.getint("DEFAULT",
1981
2376
"port")
2377
if server_settings["socket"]:
2378
server_settings["socket"] = server_config.getint("DEFAULT",
2379
"socket")
2380
# Later, stdin will, and stdout and stderr might, be dup'ed
2381
# over with an opened os.devnull. But we don't want this to
2382
# happen with a supplied network socket.
2383
if 0 <= server_settings["socket"] <= 2:
2384
server_settings["socket"] = os.dup(server_settings
2385
["socket"])
1982
2386
del server_config
1983
2387
1984
2388
# Override the settings from the config file with command line
1985
2389
# options, if set.
1986
2390
for option in ("interface", "address", "port", "debug",
1987
2391
"priority", "servicename", "configdir",
1988
"use_dbus", "use_ipv6", "debuglevel", "restore"):
2392
"use_dbus", "use_ipv6", "debuglevel", "restore",
2393
"statedir", "socket", "foreground"):
1989
2394
value = getattr(options, option)
1990
2395
if value is not None:
1991
2396
server_settings[option] = value
1994
2399
for option in server_settings.keys():
1995
2400
if type(server_settings[option]) is str:
1996
2401
server_settings[option] = unicode(server_settings[option])
2402
# Force all boolean options to be boolean
2403
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2404
"foreground"):
2405
server_settings[option] = bool(server_settings[option])
2406
# Debug implies foreground
2407
if server_settings["debug"]:
2408
server_settings["foreground"] = True
1997
2409
# Now we have our good server settings in "server_settings"
1998
2410
1999
2411
##################################################################
2003
2415
debuglevel = server_settings["debuglevel"]
2004
2416
use_dbus = server_settings["use_dbus"]
2005
2417
use_ipv6 = server_settings["use_ipv6"]
2418
stored_state_path = os.path.join(server_settings["statedir"],
2419
stored_state_file)
2420
foreground = server_settings["foreground"]
2006
2421
2007
2422
if debug:
2008
initlogger(logging.DEBUG)
2423
initlogger(debug, logging.DEBUG)
2009
2424
else:
2010
2425
if not debuglevel:
2011
initlogger()
2426
initlogger(debug)
2012
2427
else:
2013
2428
level = getattr(logging, debuglevel.upper())
2014
initlogger(level)
2429
initlogger(debug, level)
2015
2430
2016
2431
if server_settings["servicename"] != "Mandos":
2017
2432
syslogger.setFormatter(logging.Formatter
2018
('Mandos (%s) [%%(process)d]:'
2019
' %%(levelname)s: %%(message)s'
2020
% server_settings["servicename"]))
2433
('Mandos ({0}) [%(process)d]:'
2434
' %(levelname)s: %(message)s'
2435
.format(server_settings
2436
["servicename"])))
2021
2437
2022
2438
# Parse config file with clients
2023
client_defaults = { "timeout": "5m",
2024
"extended_timeout": "15m",
2025
"interval": "2m",
2026
"checker": "fping -q -- %%(host)s",
2027
"host": "",
2028
"approval_delay": "0s",
2029
"approval_duration": "1s",
2030
}
2031
client_config = configparser.SafeConfigParser(client_defaults)
2439
client_config = configparser.SafeConfigParser(Client
2440
.client_defaults)
2032
2441
client_config.read(os.path.join(server_settings["configdir"],
2033
2442
"clients.conf"))
2034
2443
2043
2452
use_ipv6=use_ipv6,
2044
2453
gnutls_priority=
2045
2454
server_settings["priority"],
2046
use_dbus=use_dbus)
2047
if not debug:
2048
pidfilename = "/var/run/mandos.pid"
2455
use_dbus=use_dbus,
2456
socketfd=(server_settings["socket"]
2457
or None))
2458
if not foreground:
2459
pidfilename = "/run/mandos.pid"
2460
pidfile = None
2049
2461
try:
2050
2462
pidfile = open(pidfilename, "w")
2051
except IOError:
2052
logger.error("Could not open file %r", pidfilename)
2463
except IOError as e:
2464
logger.error("Could not open file %r", pidfilename,
2465
exc_info=e)
2053
2466
2054
try:
2055
uid = pwd.getpwnam("_mandos").pw_uid
2056
gid = pwd.getpwnam("_mandos").pw_gid
2057
except KeyError:
2467
for name in ("_mandos", "mandos", "nobody"):
2058
2468
try:
2059
uid = pwd.getpwnam("mandos").pw_uid
2060
gid = pwd.getpwnam("mandos").pw_gid
2469
uid = pwd.getpwnam(name).pw_uid
2470
gid = pwd.getpwnam(name).pw_gid
2471
break
2061
2472
except KeyError:
2062
try:
2063
uid = pwd.getpwnam("nobody").pw_uid
2064
gid = pwd.getpwnam("nobody").pw_gid
2065
except KeyError:
2066
uid = 65534
2067
gid = 65534
2473
continue
2474
else:
2475
uid = 65534
2476
gid = 65534
2068
2477
try:
2069
2478
os.setgid(gid)
2070
2479
os.setuid(uid)
2071
2480
except OSError as error:
2072
if error[0] != errno.EPERM:
2481
if error.errno != errno.EPERM:
2073
2482
raise error
2074
2483
2075
2484
if debug:
2087
2496
.gnutls_global_set_log_function(debug_gnutls))
2088
2497
2089
2498
# Redirect stdin so all checkers get /dev/null
2090
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2499
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2091
2500
os.dup2(null, sys.stdin.fileno())
2092
2501
if null > 2:
2093
2502
os.close(null)
2094
else:
2095
# No console logging
2096
logger.removeHandler(console)
2097
2503
2098
2504
# Need to fork before connecting to D-Bus
2099
if not debug:
2505
if not foreground:
2100
2506
# Close all input and output, do double fork, etc.
2101
2507
daemon()
2102
2508
2509
# multiprocessing will use threads, so before we use gobject we
2510
# need to inform gobject that threads will be used.
2511
gobject.threads_init()
2512
2103
2513
global main_loop
2104
2514
# From the Avahi example code
2105
DBusGMainLoop(set_as_default=True )
2515
DBusGMainLoop(set_as_default=True)
2106
2516
main_loop = gobject.MainLoop()
2107
2517
bus = dbus.SystemBus()
2108
2518
# End of Avahi example code
2114
2524
("se.bsnet.fukt.Mandos", bus,
2115
2525
do_not_queue=True))
2116
2526
except dbus.exceptions.NameExistsException as e:
2117
logger.error(unicode(e) + ", disabling D-Bus")
2527
logger.error("Disabling D-Bus:", exc_info=e)
2118
2528
use_dbus = False
2119
2529
server_settings["use_dbus"] = False
2120
2530
tcp_server.use_dbus = False
2132
2542
2133
2543
client_class = Client
2134
2544
if use_dbus:
2135
client_class = functools.partial(ClientDBusTransitional,
2136
bus = bus)
2137
2138
special_settings = {
2139
# Some settings need to be accessd by special methods;
2140
# booleans need .getboolean(), etc. Here is a list of them:
2141
"approved_by_default":
2142
lambda section:
2143
client_config.getboolean(section, "approved_by_default"),
2144
}
2145
# Construct a new dict of client settings of this form:
2146
# { client_name: {setting_name: value, ...}, ...}
2147
# with exceptions for any special settings as defined above
2148
client_settings = dict((clientname,
2149
dict((setting,
2150
(value
2151
if setting not in special_settings
2152
else special_settings[setting]
2153
(clientname)))
2154
for setting, value in
2155
client_config.items(clientname)))
2156
for clientname in client_config.sections())
2157
2545
client_class = functools.partial(ClientDBus, bus = bus)
2546
2547
client_settings = Client.config_parser(client_config)
2158
2548
old_client_settings = {}
2159
clients_data = []
2549
clients_data = {}
2550
2551
# This is used to redirect stdout and stderr for checker processes
2552
global wnull
2553
wnull = open(os.devnull, "w") # A writable /dev/null
2554
# Only used if server is running in foreground but not in debug
2555
# mode
2556
if debug or not foreground:
2557
wnull.close()
2160
2558
2161
2559
# Get client data and settings from last running state.
2162
2560
if server_settings["restore"]:
2166
2564
(stored_state))
2167
2565
os.remove(stored_state_path)
2168
2566
except IOError as e:
2169
logger.warning("Could not load persistant state: {0}"
2170
.format(e))
2171
if e.errno != errno.ENOENT:
2567
if e.errno == errno.ENOENT:
2568
logger.warning("Could not load persistent state: {0}"
2569
.format(os.strerror(e.errno)))
2570
else:
2571
logger.critical("Could not load persistent state:",
2572
exc_info=e)
2172
2573
raise
2574
except EOFError as e:
2575
logger.warning("Could not load persistent state: "
2576
"EOFError:", exc_info=e)
2173
2577
2174
for client in clients_data:
2175
client_name = client["name"]
2176
2177
# Decide which value to use after restoring saved state.
2178
# We have three different values: Old config file,
2179
# new config file, and saved state.
2180
# New config value takes precedence if it differs from old
2181
# config value, otherwise use saved state.
2182
for name, value in client_settings[client_name].items():
2578
with PGPEngine() as pgp:
2579
for client_name, client in clients_data.iteritems():
2580
# Skip removed clients
2581
if client_name not in client_settings:
2582
continue
2583
2584
# Decide which value to use after restoring saved state.
2585
# We have three different values: Old config file,
2586
# new config file, and saved state.
2587
# New config value takes precedence if it differs from old
2588
# config value, otherwise use saved state.
2589
for name, value in client_settings[client_name].items():
2590
try:
2591
# For each value in new config, check if it
2592
# differs from the old config value (Except for
2593
# the "secret" attribute)
2594
if (name != "secret" and
2595
value != old_client_settings[client_name]
2596
[name]):
2597
client[name] = value
2598
except KeyError:
2599
pass
2600
2601
# Clients who has passed its expire date can still be
2602
# enabled if its last checker was successful. Clients
2603
# whose checker succeeded before we stored its state is
2604
# assumed to have successfully run all checkers during
2605
# downtime.
2606
if client["enabled"]:
2607
if datetime.datetime.utcnow() >= client["expires"]:
2608
if not client["last_checked_ok"]:
2609
logger.warning(
2610
"disabling client {0} - Client never "
2611
"performed a successful checker"
2612
.format(client_name))
2613
client["enabled"] = False
2614
elif client["last_checker_status"] != 0:
2615
logger.warning(
2616
"disabling client {0} - Client "
2617
"last checker failed with error code {1}"
2618
.format(client_name,
2619
client["last_checker_status"]))
2620
client["enabled"] = False
2621
else:
2622
client["expires"] = (datetime.datetime
2623
.utcnow()
2624
+ client["timeout"])
2625
logger.debug("Last checker succeeded,"
2626
" keeping {0} enabled"
2627
.format(client_name))
2183
2628
try:
2184
# For each value in new config, check if it differs
2185
# from the old config value (Except for the "secret"
2186
# attribute)
2187
if (name != "secret" and
2188
value != old_client_settings[client_name][name]):
2189
setattr(client, name, value)
2190
except KeyError:
2191
pass
2192
2193
# Clients who has passed its expire date, can still be enabled
2194
# if its last checker was sucessful. Clients who checkers
2195
# failed before we stored it state is asumed to had failed
2196
# checker during downtime.
2197
if client["enabled"] and client["last_checked_ok"]:
2198
if ((datetime.datetime.utcnow()
2199
- client["last_checked_ok"]) > client["interval"]):
2200
if client["last_checker_status"] != 0:
2201
client["enabled"] = False
2202
else:
2203
client["expires"] = (datetime.datetime.utcnow()
2204
+ client["timeout"])
2205
2206
client["changedstate"] = (multiprocessing_manager
2207
.Condition(multiprocessing_manager
2208
.Lock()))
2209
if use_dbus:
2210
new_client = (ClientDBusTransitional.__new__
2211
(ClientDBusTransitional))
2212
tcp_server.clients[client_name] = new_client
2213
new_client.bus = bus
2214
for name, value in client.iteritems():
2215
setattr(new_client, name, value)
2216
client_object_name = unicode(client_name).translate(
2217
{ord("."): ord("_"),
2218
ord("-"): ord("_")})
2219
new_client.dbus_object_path = (dbus.ObjectPath
2220
("/clients/"
2221
+ client_object_name))
2222
DBusObjectWithProperties.__init__(new_client,
2223
new_client.bus,
2224
new_client
2225
.dbus_object_path)
2226
else:
2227
tcp_server.clients[client_name] = Client.__new__(Client)
2228
for name, value in client.iteritems():
2229
setattr(tcp_server.clients[client_name], name, value)
2230
2231
tcp_server.clients[client_name].decrypt_secret(
2232
client_settings[client_name]["secret"])
2233
2234
# Create/remove clients based on new changes made to config
2235
for clientname in set(old_client_settings) - set(client_settings):
2236
del tcp_server.clients[clientname]
2237
for clientname in set(client_settings) - set(old_client_settings):
2238
tcp_server.clients[clientname] = (client_class(name
2239
= clientname,
2240
config =
2241
client_settings
2242
[clientname]))
2629
client["secret"] = (
2630
pgp.decrypt(client["encrypted_secret"],
2631
client_settings[client_name]
2632
["secret"]))
2633
except PGPError:
2634
# If decryption fails, we use secret from new settings
2635
logger.debug("Failed to decrypt {0} old secret"
2636
.format(client_name))
2637
client["secret"] = (
2638
client_settings[client_name]["secret"])
2639
2640
# Add/remove clients based on new changes made to config
2641
for client_name in (set(old_client_settings)
2642
- set(client_settings)):
2643
del clients_data[client_name]
2644
for client_name in (set(client_settings)
2645
- set(old_client_settings)):
2646
clients_data[client_name] = client_settings[client_name]
2647
2648
# Create all client objects
2649
for client_name, client in clients_data.iteritems():
2650
tcp_server.clients[client_name] = client_class(
2651
name = client_name, settings = client,
2652
server_settings = server_settings)
2243
2653
2244
2654
if not tcp_server.clients:
2245
2655
logger.warning("No clients defined")
2246
2247
if not debug:
2248
try:
2249
with pidfile:
2250
pid = os.getpid()
2251
pidfile.write(str(pid) + "\n".encode("utf-8"))
2252
del pidfile
2253
except IOError:
2254
logger.error("Could not write to file %r with PID %d",
2255
pidfilename, pid)
2256
except NameError:
2257
# "pidfile" was never created
2258
pass
2656
2657
if not foreground:
2658
if pidfile is not None:
2659
try:
2660
with pidfile:
2661
pid = os.getpid()
2662
pidfile.write(str(pid) + "\n".encode("utf-8"))
2663
except IOError:
2664
logger.error("Could not write to file %r with PID %d",
2665
pidfilename, pid)
2666
del pidfile
2259
2667
del pidfilename
2260
2261
signal.signal(signal.SIGINT, signal.SIG_IGN)
2262
2668
2263
2669
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2264
2670
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2265
2671
2266
2672
if use_dbus:
2267
class MandosDBusService(dbus.service.Object):
2673
@alternate_dbus_interfaces({"se.recompile.Mandos":
2674
"se.bsnet.fukt.Mandos"})
2675
class MandosDBusService(DBusObjectWithProperties):
2268
2676
"""A D-Bus proxy object"""
2269
2677
def __init__(self):
2270
2678
dbus.service.Object.__init__(self, bus, "/")
2271
2679
_interface = "se.recompile.Mandos"
2272
2680
2681
@dbus_interface_annotations(_interface)
2682
def _foo(self):
2683
return { "org.freedesktop.DBus.Property"
2684
".EmitsChangedSignal":
2685
"false"}
2686
2273
2687
@dbus.service.signal(_interface, signature="o")
2274
2688
def ClientAdded(self, objpath):
2275
2689
"D-Bus signal"
2317
2731
2318
2732
del _interface
2319
2733
2320
class MandosDBusServiceTransitional(MandosDBusService):
2321
__metaclass__ = AlternateDBusNamesMetaclass
2322
mandos_dbus_service = MandosDBusServiceTransitional()
2734
mandos_dbus_service = MandosDBusService()
2323
2735
2324
2736
def cleanup():
2325
2737
"Cleanup function; run on exit"
2326
2738
service.cleanup()
2327
2739
2328
2740
multiprocessing.active_children()
2741
wnull.close()
2329
2742
if not (tcp_server.clients or client_settings):
2330
2743
return
2331
2744
2332
2745
# Store client before exiting. Secrets are encrypted with key
2333
2746
# based on what config file has. If config file is
2334
2747
# removed/edited, old secret will thus be unrecovable.
2335
clients = []
2336
for client in tcp_server.clients.itervalues():
2337
client.encrypt_secret(client_settings[client.name]
2338
["secret"])
2339
2340
client_dict = {}
2341
2342
# A list of attributes that will not be stored when
2343
# shutting down.
2344
exclude = set(("bus", "changedstate", "secret"))
2345
for name, typ in inspect.getmembers(dbus.service.Object):
2346
exclude.add(name)
2347
2348
client_dict["encrypted_secret"] = client.encrypted_secret
2349
for attr in client.client_structure:
2350
if attr not in exclude:
2351
client_dict[attr] = getattr(client, attr)
2352
2353
clients.append(client_dict)
2354
del client_settings[client.name]["secret"]
2355
2748
clients = {}
2749
with PGPEngine() as pgp:
2750
for client in tcp_server.clients.itervalues():
2751
key = client_settings[client.name]["secret"]
2752
client.encrypted_secret = pgp.encrypt(client.secret,
2753
key)
2754
client_dict = {}
2755
2756
# A list of attributes that can not be pickled
2757
# + secret.
2758
exclude = set(("bus", "changedstate", "secret",
2759
"checker", "server_settings"))
2760
for name, typ in (inspect.getmembers
2761
(dbus.service.Object)):
2762
exclude.add(name)
2763
2764
client_dict["encrypted_secret"] = (client
2765
.encrypted_secret)
2766
for attr in client.client_structure:
2767
if attr not in exclude:
2768
client_dict[attr] = getattr(client, attr)
2769
2770
clients[client.name] = client_dict
2771
del client_settings[client.name]["secret"]
2772
2356
2773
try:
2357
with os.fdopen(os.open(stored_state_path,
2358
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2359
0600), "wb") as stored_state:
2774
with (tempfile.NamedTemporaryFile
2775
(mode='wb', suffix=".pickle", prefix='clients-',
2776
dir=os.path.dirname(stored_state_path),
2777
delete=False)) as stored_state:
2360
2778
pickle.dump((clients, client_settings), stored_state)
2361
except IOError as e:
2362
logger.warning("Could not save persistant state: {0}"
2363
.format(e))
2364
if e.errno != errno.ENOENT:
2365
raise
2779
tempname=stored_state.name
2780
os.rename(tempname, stored_state_path)
2781
except (IOError, OSError) as e:
2782
if not debug:
2783
try:
2784
os.remove(tempname)
2785
except NameError:
2786
pass
2787
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2788
logger.warning("Could not save persistent state: {0}"
2789
.format(os.strerror(e.errno)))
2790
else:
2791
logger.warning("Could not save persistent state:",
2792
exc_info=e)
2793
raise e
2366
2794
2367
2795
# Delete all clients, and settings from config
2368
2796
while tcp_server.clients:
2387
2815
# Need to initiate checking of clients
2388
2816
if client.enabled:
2389
2817
client.init_checker()
2390
2391
2818
2392
2819
tcp_server.enable()
2393
2820
tcp_server.server_activate()
2396
2823
service.port = tcp_server.socket.getsockname()[1]
2397
2824
if use_ipv6:
2398
2825
logger.info("Now listening on address %r, port %d,"
2399
" flowinfo %d, scope_id %d"
2400
% tcp_server.socket.getsockname())
2826
" flowinfo %d, scope_id %d",
2827
*tcp_server.socket.getsockname())
2401
2828
else: # IPv4
2402
logger.info("Now listening on address %r, port %d"
2403
% tcp_server.socket.getsockname())
2829
logger.info("Now listening on address %r, port %d",
2830
*tcp_server.socket.getsockname())
2404
2831
2405
2832
#service.interface = tcp_server.socket.getsockname()[3]
2406
2833
2409
2836
try:
2410
2837
service.activate()
2411
2838
except dbus.exceptions.DBusException as error:
2412
logger.critical("DBusException: %s", error)
2839
logger.critical("D-Bus Exception", exc_info=error)
2413
2840
cleanup()
2414
2841
sys.exit(1)
2415
2842
# End of Avahi example code
2422
2849
logger.debug("Starting main loop")
2423
2850
main_loop.run()
2424
2851
except AvahiError as error:
2425
logger.critical("AvahiError: %s", error)
2852
logger.critical("Avahi Error", exc_info=error)
2426
2853
cleanup()
2427
2854
sys.exit(1)
2428
2855
except KeyboardInterrupt:
2433
2860
# Must run before the D-Bus bus name gets deregistered
2434
2861
cleanup()
2435
2862
2436
2437
2863
if __name__ == '__main__':
2438
2864
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0