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 520
- compare with another revision
- download diff
- download tarball
- view history from revision 520
- Committer: Björn Påhlsson
- Date: 2011-11-09 17:16:03 UTC
- mfrom: (518.1.1 mandos-persistent)
- Revision ID: belorn@fukt.bsnet.se-20111109171603-srz21uoclpldp5ve
merge persistent state
- files removed:
- network-hooks.d
- files modified:
- DBUS-API
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 Björn Påhlsson
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 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
63
63
import cPickle as pickle
64
64
import multiprocessing
65
65
import types
66
import binascii
67
import tempfile
68
import itertools
66
import hashlib
69
67
70
68
import dbus
71
69
import dbus.service
76
74
import ctypes.util
77
75
import xml.dom.minidom
78
76
import inspect
79
import GnuPGInterface
77
import Crypto.Cipher.AES
80
78
81
79
try:
82
80
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
86
84
except ImportError:
87
85
SO_BINDTODEVICE = None
88
86
89
version = "1.5.3"
90
stored_state_file = "clients.pickle"
87
88
version = "1.4.1"
91
89
92
90
logger = logging.getLogger()
91
stored_state_path = "/var/lib/mandos/clients.pickle"
92
93
93
syslogger = (logging.handlers.SysLogHandler
94
94
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
95
95
address = str("/dev/log")))
96
97
try:
98
if_nametoindex = (ctypes.cdll.LoadLibrary
99
(ctypes.util.find_library("c"))
100
.if_nametoindex)
101
except (OSError, AttributeError):
102
def if_nametoindex(interface):
103
"Get an interface index the hard way, i.e. using fcntl()"
104
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
105
with contextlib.closing(socket.socket()) as s:
106
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
107
struct.pack(str("16s16x"),
108
interface))
109
interface_index = struct.unpack(str("I"),
110
ifreq[16:20])[0]
111
return interface_index
112
113
114
def initlogger(debug, level=logging.WARNING):
115
"""init logger and add loglevel"""
116
117
syslogger.setFormatter(logging.Formatter
118
('Mandos [%(process)d]: %(levelname)s:'
119
' %(message)s'))
120
logger.addHandler(syslogger)
121
122
if debug:
123
console = logging.StreamHandler()
124
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
125
' [%(process)d]:'
126
' %(levelname)s:'
127
' %(message)s'))
128
logger.addHandler(console)
129
logger.setLevel(level)
130
131
132
class PGPError(Exception):
133
"""Exception if encryption/decryption fails"""
134
pass
135
136
137
class PGPEngine(object):
138
"""A simple class for OpenPGP symmetric encryption & decryption"""
139
def __init__(self):
140
self.gnupg = GnuPGInterface.GnuPG()
141
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
142
self.gnupg = GnuPGInterface.GnuPG()
143
self.gnupg.options.meta_interactive = False
144
self.gnupg.options.homedir = self.tempdir
145
self.gnupg.options.extra_args.extend(['--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
return b"mandos" + binascii.hexlify(password)
176
177
def encrypt(self, data, password):
178
self.gnupg.passphrase = self.password_encode(password)
179
with open(os.devnull, "w") as devnull:
180
try:
181
proc = self.gnupg.run(['--symmetric'],
182
create_fhs=['stdin', 'stdout'],
183
attach_fhs={'stderr': devnull})
184
with contextlib.closing(proc.handles['stdin']) as f:
185
f.write(data)
186
with contextlib.closing(proc.handles['stdout']) as f:
187
ciphertext = f.read()
188
proc.wait()
189
except IOError as e:
190
raise PGPError(e)
191
self.gnupg.passphrase = None
192
return ciphertext
193
194
def decrypt(self, data, password):
195
self.gnupg.passphrase = self.password_encode(password)
196
with open(os.devnull, "w") as devnull:
197
try:
198
proc = self.gnupg.run(['--decrypt'],
199
create_fhs=['stdin', 'stdout'],
200
attach_fhs={'stderr': devnull})
201
with contextlib.closing(proc.handles['stdin']) as f:
202
f.write(data)
203
with contextlib.closing(proc.handles['stdout']) as f:
204
decrypted_plaintext = f.read()
205
proc.wait()
206
except IOError as e:
207
raise PGPError(e)
208
self.gnupg.passphrase = None
209
return decrypted_plaintext
96
syslogger.setFormatter(logging.Formatter
97
('Mandos [%(process)d]: %(levelname)s:'
98
' %(message)s'))
99
logger.addHandler(syslogger)
100
101
console = logging.StreamHandler()
102
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
103
' [%(process)d]:'
104
' %(levelname)s:'
105
' %(message)s'))
106
logger.addHandler(console)
210
107
211
108
212
109
class AvahiError(Exception):
243
140
server: D-Bus Server
244
141
bus: dbus.SystemBus()
245
142
"""
246
247
143
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
248
144
servicetype = None, port = None, TXT = None,
249
145
domain = "", host = "", max_renames = 32768,
262
158
self.server = None
263
159
self.bus = bus
264
160
self.entry_group_state_changed_match = None
265
266
161
def rename(self):
267
162
"""Derived from the Avahi example code"""
268
163
if self.rename_count >= self.max_renames:
278
173
try:
279
174
self.add()
280
175
except dbus.exceptions.DBusException as error:
281
logger.critical("D-Bus Exception", exc_info=error)
176
logger.critical("DBusException: %s", error)
282
177
self.cleanup()
283
178
os._exit(1)
284
179
self.rename_count += 1
285
286
180
def remove(self):
287
181
"""Derived from the Avahi example code"""
288
182
if self.entry_group_state_changed_match is not None:
290
184
self.entry_group_state_changed_match = None
291
185
if self.group is not None:
292
186
self.group.Reset()
293
294
187
def add(self):
295
188
"""Derived from the Avahi example code"""
296
189
self.remove()
313
206
dbus.UInt16(self.port),
314
207
avahi.string_array_to_txt_array(self.TXT))
315
208
self.group.Commit()
316
317
209
def entry_group_state_changed(self, state, error):
318
210
"""Derived from the Avahi example code"""
319
211
logger.debug("Avahi entry group state change: %i", state)
326
218
elif state == avahi.ENTRY_GROUP_FAILURE:
327
219
logger.critical("Avahi: Error in group state changed %s",
328
220
unicode(error))
329
raise AvahiGroupError("State changed: {0!s}"
330
.format(error))
331
221
raise AvahiGroupError("State changed: %s"
222
% unicode(error))
332
223
def cleanup(self):
333
224
"""Derived from the Avahi example code"""
334
225
if self.group is not None:
335
226
try:
336
227
self.group.Free()
337
228
except (dbus.exceptions.UnknownMethodException,
338
dbus.exceptions.DBusException):
229
dbus.exceptions.DBusException) as e:
339
230
pass
340
231
self.group = None
341
232
self.remove()
342
343
233
def server_state_changed(self, state, error=None):
344
234
"""Derived from the Avahi example code"""
345
235
logger.debug("Avahi server state change: %i", state)
364
254
logger.debug("Unknown state: %r", state)
365
255
else:
366
256
logger.debug("Unknown state: %r: %r", state, error)
367
368
257
def activate(self):
369
258
"""Derived from the Avahi example code"""
370
259
if self.server is None:
382
271
"""Add the new name to the syslog messages"""
383
272
ret = AvahiService.rename(self)
384
273
syslogger.setFormatter(logging.Formatter
385
('Mandos ({0}) [%(process)d]:'
386
' %(levelname)s: %(message)s'
387
.format(self.name)))
274
('Mandos (%s) [%%(process)d]:'
275
' %%(levelname)s: %%(message)s'
276
% self.name))
388
277
return ret
389
278
390
def timedelta_to_milliseconds(td):
279
def _timedelta_to_milliseconds(td):
391
280
"Convert a datetime.timedelta() to milliseconds"
392
281
return ((td.days * 24 * 60 * 60 * 1000)
393
282
+ (td.seconds * 1000)
394
283
+ (td.microseconds // 1000))
395
284
396
285
class Client(object):
397
286
"""A representation of a client host served by this server.
398
287
399
288
Attributes:
400
approved: bool(); 'None' if not yet approved/disapproved
289
_approved: bool(); 'None' if not yet approved/disapproved
401
290
approval_delay: datetime.timedelta(); Time to wait for approval
402
291
approval_duration: datetime.timedelta(); Duration of one approval
403
292
checker: subprocess.Popen(); a running checker process used
421
310
interval: datetime.timedelta(); How often to start a new checker
422
311
last_approval_request: datetime.datetime(); (UTC) or None
423
312
last_checked_ok: datetime.datetime(); (UTC) or None
424
last_checker_status: integer between 0 and 255 reflecting exit
425
status of last checker. -1 reflects crashed
426
checker, -2 means no checker completed yet.
427
last_enabled: datetime.datetime(); (UTC) or None
313
last_checker_status: integer between 0 and 255 reflecting exit status
314
of last checker. -1 reflect crashed checker,
315
or None.
316
last_enabled: datetime.datetime(); (UTC)
428
317
name: string; from the config file, used in log messages and
429
318
D-Bus identifiers
430
319
secret: bytestring; sent verbatim (over TLS) to client
431
320
timeout: datetime.timedelta(); How long from last_checked_ok
432
321
until this client is disabled
433
extended_timeout: extra long timeout when secret has been sent
322
extended_timeout: extra long timeout when password has been sent
434
323
runtime_expansions: Allowed attributes for runtime expansion.
435
324
expires: datetime.datetime(); time (UTC) when a client will be
436
325
disabled, or None
440
329
"created", "enabled", "fingerprint",
441
330
"host", "interval", "last_checked_ok",
442
331
"last_enabled", "name", "timeout")
443
client_defaults = { "timeout": "5m",
444
"extended_timeout": "15m",
445
"interval": "2m",
446
"checker": "fping -q -- %%(host)s",
447
"host": "",
448
"approval_delay": "0s",
449
"approval_duration": "1s",
450
"approved_by_default": "True",
451
"enabled": "True",
452
}
453
332
454
333
def timeout_milliseconds(self):
455
334
"Return the 'timeout' attribute in milliseconds"
456
return timedelta_to_milliseconds(self.timeout)
335
return _timedelta_to_milliseconds(self.timeout)
457
336
458
337
def extended_timeout_milliseconds(self):
459
338
"Return the 'extended_timeout' attribute in milliseconds"
460
return timedelta_to_milliseconds(self.extended_timeout)
339
return _timedelta_to_milliseconds(self.extended_timeout)
461
340
462
341
def interval_milliseconds(self):
463
342
"Return the 'interval' attribute in milliseconds"
464
return timedelta_to_milliseconds(self.interval)
343
return _timedelta_to_milliseconds(self.interval)
465
344
466
345
def approval_delay_milliseconds(self):
467
return timedelta_to_milliseconds(self.approval_delay)
468
469
@staticmethod
470
def config_parser(config):
471
"""Construct a new dict of client settings of this form:
472
{ client_name: {setting_name: value, ...}, ...}
473
with exceptions for any special settings as defined above.
474
NOTE: Must be a pure function. Must return the same result
475
value given the same arguments.
476
"""
477
settings = {}
478
for client_name in config.sections():
479
section = dict(config.items(client_name))
480
client = settings[client_name] = {}
481
482
client["host"] = section["host"]
483
# Reformat values from string types to Python types
484
client["approved_by_default"] = config.getboolean(
485
client_name, "approved_by_default")
486
client["enabled"] = config.getboolean(client_name,
487
"enabled")
488
489
client["fingerprint"] = (section["fingerprint"].upper()
490
.replace(" ", ""))
491
if "secret" in section:
492
client["secret"] = section["secret"].decode("base64")
493
elif "secfile" in section:
494
with open(os.path.expanduser(os.path.expandvars
495
(section["secfile"])),
496
"rb") as secfile:
497
client["secret"] = secfile.read()
498
else:
499
raise TypeError("No secret or secfile for section {0}"
500
.format(section))
501
client["timeout"] = string_to_delta(section["timeout"])
502
client["extended_timeout"] = string_to_delta(
503
section["extended_timeout"])
504
client["interval"] = string_to_delta(section["interval"])
505
client["approval_delay"] = string_to_delta(
506
section["approval_delay"])
507
client["approval_duration"] = string_to_delta(
508
section["approval_duration"])
509
client["checker_command"] = section["checker"]
510
client["last_approval_request"] = None
511
client["last_checked_ok"] = None
512
client["last_checker_status"] = -2
513
514
return settings
515
516
def __init__(self, settings, name = None):
346
return _timedelta_to_milliseconds(self.approval_delay)
347
348
def __init__(self, name = None, config=None):
349
"""Note: the 'checker' key in 'config' sets the
350
'checker_command' attribute and *not* the 'checker'
351
attribute."""
517
352
self.name = name
518
# adding all client settings
519
for setting, value in settings.iteritems():
520
setattr(self, setting, value)
521
522
if self.enabled:
523
if not hasattr(self, "last_enabled"):
524
self.last_enabled = datetime.datetime.utcnow()
525
if not hasattr(self, "expires"):
526
self.expires = (datetime.datetime.utcnow()
527
+ self.timeout)
528
else:
529
self.last_enabled = None
530
self.expires = None
531
353
if config is None:
354
config = {}
532
355
logger.debug("Creating client %r", self.name)
533
356
# Uppercase and remove spaces from fingerprint for later
534
357
# comparison purposes with return value from the fingerprint()
535
358
# function
359
self.fingerprint = (config["fingerprint"].upper()
360
.replace(" ", ""))
536
361
logger.debug(" Fingerprint: %s", self.fingerprint)
537
self.created = settings.get("created",
538
datetime.datetime.utcnow())
539
540
# attributes specific for this server instance
362
if "secret" in config:
363
self.secret = config["secret"].decode("base64")
364
elif "secfile" in config:
365
with open(os.path.expanduser(os.path.expandvars
366
(config["secfile"])),
367
"rb") as secfile:
368
self.secret = secfile.read()
369
else:
370
raise TypeError("No secret or secfile for client %s"
371
% self.name)
372
self.host = config.get("host", "")
373
self.created = datetime.datetime.utcnow()
374
self.enabled = True
375
self.last_approval_request = None
376
self.last_enabled = datetime.datetime.utcnow()
377
self.last_checked_ok = None
378
self.last_checker_status = None
379
self.timeout = string_to_delta(config["timeout"])
380
self.extended_timeout = string_to_delta(config
381
["extended_timeout"])
382
self.interval = string_to_delta(config["interval"])
541
383
self.checker = None
542
384
self.checker_initiator_tag = None
543
385
self.disable_initiator_tag = None
386
self.expires = datetime.datetime.utcnow() + self.timeout
544
387
self.checker_callback_tag = None
388
self.checker_command = config["checker"]
545
389
self.current_checker_command = None
546
self.approved = None
390
self._approved = None
391
self.approved_by_default = config.get("approved_by_default",
392
True)
547
393
self.approvals_pending = 0
394
self.approval_delay = string_to_delta(
395
config["approval_delay"])
396
self.approval_duration = string_to_delta(
397
config["approval_duration"])
548
398
self.changedstate = (multiprocessing_manager
549
399
.Condition(multiprocessing_manager
550
400
.Lock()))
551
self.client_structure = [attr for attr in
552
self.__dict__.iterkeys()
553
if not attr.startswith("_")]
401
self.client_structure = [attr for attr in self.__dict__.iterkeys() if not attr.startswith("_")]
554
402
self.client_structure.append("client_structure")
555
403
404
556
405
for name, t in inspect.getmembers(type(self),
557
lambda obj:
558
isinstance(obj,
559
property)):
406
lambda obj: isinstance(obj, property)):
560
407
if not name.startswith("_"):
561
408
self.client_structure.append(name)
562
409
598
445
599
446
def __del__(self):
600
447
self.disable()
601
448
602
449
def init_checker(self):
603
450
# Schedule a new checker to be started an 'interval' from now,
604
451
# and every interval from then on.
611
458
self.disable))
612
459
# Also start a new checker *right now*.
613
460
self.start_checker()
614
461
462
615
463
def checker_callback(self, pid, condition, command):
616
464
"""The checker has completed, so take appropriate actions."""
617
465
self.checker_callback_tag = None
618
466
self.checker = None
619
467
if os.WIFEXITED(condition):
620
self.last_checker_status = os.WEXITSTATUS(condition)
468
self.last_checker_status = os.WEXITSTATUS(condition)
621
469
if self.last_checker_status == 0:
622
470
logger.info("Checker for %(name)s succeeded",
623
471
vars(self))
630
478
logger.warning("Checker for %(name)s crashed?",
631
479
vars(self))
632
480
633
def checked_ok(self):
634
"""Assert that the client has been seen, alive and well."""
635
self.last_checked_ok = datetime.datetime.utcnow()
636
self.last_checker_status = 0
637
self.bump_timeout()
638
639
def bump_timeout(self, timeout=None):
640
"""Bump up the timeout for this client."""
481
def checked_ok(self, timeout=None):
482
"""Bump up the timeout for this client.
483
484
This should only be called when the client has been seen,
485
alive and well.
486
"""
641
487
if timeout is None:
642
488
timeout = self.timeout
489
self.last_checked_ok = datetime.datetime.utcnow()
643
490
if self.disable_initiator_tag is not None:
644
491
gobject.source_remove(self.disable_initiator_tag)
645
492
if getattr(self, "enabled", False):
646
493
self.disable_initiator_tag = (gobject.timeout_add
647
(timedelta_to_milliseconds
494
(_timedelta_to_milliseconds
648
495
(timeout), self.disable))
649
496
self.expires = datetime.datetime.utcnow() + timeout
650
497
696
543
try:
697
544
command = self.checker_command % escaped_attrs
698
545
except TypeError as error:
699
logger.error('Could not format string "%s"',
700
self.checker_command, exc_info=error)
546
logger.error('Could not format string "%s":'
547
' %s', self.checker_command, error)
701
548
return True # Try again later
702
549
self.current_checker_command = command
703
550
try:
721
568
gobject.source_remove(self.checker_callback_tag)
722
569
self.checker_callback(pid, status, command)
723
570
except OSError as error:
724
logger.error("Failed to start subprocess",
725
exc_info=error)
571
logger.error("Failed to start subprocess: %s",
572
error)
726
573
# Re-run this periodically if run by gobject.timeout_add
727
574
return True
728
575
735
582
return
736
583
logger.debug("Stopping checker for %(name)s", vars(self))
737
584
try:
738
self.checker.terminate()
585
os.kill(self.checker.pid, signal.SIGTERM)
739
586
#time.sleep(0.5)
740
587
#if self.checker.poll() is None:
741
# self.checker.kill()
588
# os.kill(self.checker.pid, signal.SIGKILL)
742
589
except OSError as error:
743
590
if error.errno != errno.ESRCH: # No such process
744
591
raise
745
592
self.checker = None
746
593
594
# Encrypts a client secret and stores it in a varible encrypted_secret
595
def encrypt_secret(self, key):
596
# Encryption-key need to be of a specific size, so we hash inputed key
597
hasheng = hashlib.sha256()
598
hasheng.update(key)
599
encryptionkey = hasheng.digest()
600
601
# Create validation hash so we know at decryption if it was sucessful
602
hasheng = hashlib.sha256()
603
hasheng.update(self.secret)
604
validationhash = hasheng.digest()
605
606
# Encrypt secret
607
iv = os.urandom(Crypto.Cipher.AES.block_size)
608
ciphereng = Crypto.Cipher.AES.new(encryptionkey,
609
Crypto.Cipher.AES.MODE_CFB, iv)
610
ciphertext = ciphereng.encrypt(validationhash+self.secret)
611
self.encrypted_secret = (ciphertext, iv)
612
613
# Decrypt a encrypted client secret
614
def decrypt_secret(self, key):
615
# Decryption-key need to be of a specific size, so we hash inputed key
616
hasheng = hashlib.sha256()
617
hasheng.update(key)
618
encryptionkey = hasheng.digest()
619
620
# Decrypt encrypted secret
621
ciphertext, iv = self.encrypted_secret
622
ciphereng = Crypto.Cipher.AES.new(encryptionkey,
623
Crypto.Cipher.AES.MODE_CFB, iv)
624
plain = ciphereng.decrypt(ciphertext)
625
626
# Validate decrypted secret to know if it was succesful
627
hasheng = hashlib.sha256()
628
validationhash = plain[:hasheng.digest_size]
629
secret = plain[hasheng.digest_size:]
630
hasheng.update(secret)
631
632
# if validation fails, we use key as new secret. Otherwhise, we use
633
# the decrypted secret
634
if hasheng.digest() == validationhash:
635
self.secret = secret
636
else:
637
self.secret = key
638
del self.encrypted_secret
639
747
640
748
641
def dbus_service_property(dbus_interface, signature="v",
749
642
access="readwrite", byte_arrays=False):
761
654
# "Set" method, so we fail early here:
762
655
if byte_arrays and signature != "ay":
763
656
raise ValueError("Byte arrays not supported for non-'ay'"
764
" signature {0!r}".format(signature))
657
" signature %r" % signature)
765
658
def decorator(func):
766
659
func._dbus_is_property = True
767
660
func._dbus_interface = dbus_interface
775
668
return decorator
776
669
777
670
778
def dbus_interface_annotations(dbus_interface):
779
"""Decorator for marking functions returning interface annotations
780
781
Usage:
782
783
@dbus_interface_annotations("org.example.Interface")
784
def _foo(self): # Function name does not matter
785
return {"org.freedesktop.DBus.Deprecated": "true",
786
"org.freedesktop.DBus.Property.EmitsChangedSignal":
787
"false"}
788
"""
789
def decorator(func):
790
func._dbus_is_interface = True
791
func._dbus_interface = dbus_interface
792
func._dbus_name = dbus_interface
793
return func
794
return decorator
795
796
797
def dbus_annotations(annotations):
798
"""Decorator to annotate D-Bus methods, signals or properties
799
Usage:
800
801
@dbus_service_property("org.example.Interface", signature="b",
802
access="r")
803
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
804
"org.freedesktop.DBus.Property."
805
"EmitsChangedSignal": "false"})
806
def Property_dbus_property(self):
807
return dbus.Boolean(False)
808
"""
809
def decorator(func):
810
func._dbus_annotations = annotations
811
return func
812
return decorator
813
814
815
671
class DBusPropertyException(dbus.exceptions.DBusException):
816
672
"""A base class for D-Bus property-related exceptions
817
673
"""
840
696
"""
841
697
842
698
@staticmethod
843
def _is_dbus_thing(thing):
844
"""Returns a function testing if an attribute is a D-Bus thing
845
846
If called like _is_dbus_thing("method") it returns a function
847
suitable for use as predicate to inspect.getmembers().
848
"""
849
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
850
False)
699
def _is_dbus_property(obj):
700
return getattr(obj, "_dbus_is_property", False)
851
701
852
def _get_all_dbus_things(self, thing):
702
def _get_all_dbus_properties(self):
853
703
"""Returns a generator of (name, attribute) pairs
854
704
"""
855
return ((getattr(athing.__get__(self), "_dbus_name",
856
name),
857
athing.__get__(self))
705
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
858
706
for cls in self.__class__.__mro__
859
for name, athing in
860
inspect.getmembers(cls,
861
self._is_dbus_thing(thing)))
707
for name, prop in
708
inspect.getmembers(cls, self._is_dbus_property))
862
709
863
710
def _get_dbus_property(self, interface_name, property_name):
864
711
"""Returns a bound method if one exists which is a D-Bus
866
713
"""
867
714
for cls in self.__class__.__mro__:
868
715
for name, value in (inspect.getmembers
869
(cls,
870
self._is_dbus_thing("property"))):
716
(cls, self._is_dbus_property)):
871
717
if (value._dbus_name == property_name
872
718
and value._dbus_interface == interface_name):
873
719
return value.__get__(self)
902
748
# signatures other than "ay".
903
749
if prop._dbus_signature != "ay":
904
750
raise ValueError
905
value = dbus.ByteArray(b''.join(chr(byte)
906
for byte in value))
751
value = dbus.ByteArray(''.join(unichr(byte)
752
for byte in value))
907
753
prop(value)
908
754
909
755
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
914
760
915
761
Note: Will not include properties with access="write".
916
762
"""
917
properties = {}
918
for name, prop in self._get_all_dbus_things("property"):
763
all = {}
764
for name, prop in self._get_all_dbus_properties():
919
765
if (interface_name
920
766
and interface_name != prop._dbus_interface):
921
767
# Interface non-empty but did not match
925
771
continue
926
772
value = prop()
927
773
if not hasattr(value, "variant_level"):
928
properties[name] = value
774
all[name] = value
929
775
continue
930
properties[name] = type(value)(value, variant_level=
931
value.variant_level+1)
932
return dbus.Dictionary(properties, signature="sv")
776
all[name] = type(value)(value, variant_level=
777
value.variant_level+1)
778
return dbus.Dictionary(all, signature="sv")
933
779
934
780
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
935
781
out_signature="s",
936
782
path_keyword='object_path',
937
783
connection_keyword='connection')
938
784
def Introspect(self, object_path, connection):
939
"""Overloading of standard D-Bus method.
940
941
Inserts property tags and interface annotation tags.
785
"""Standard D-Bus method, overloaded to insert property tags.
942
786
"""
943
787
xmlstring = dbus.service.Object.Introspect(self, object_path,
944
788
connection)
951
795
e.setAttribute("access", prop._dbus_access)
952
796
return e
953
797
for if_tag in document.getElementsByTagName("interface"):
954
# Add property tags
955
798
for tag in (make_tag(document, name, prop)
956
799
for name, prop
957
in self._get_all_dbus_things("property")
800
in self._get_all_dbus_properties()
958
801
if prop._dbus_interface
959
802
== if_tag.getAttribute("name")):
960
803
if_tag.appendChild(tag)
961
# Add annotation tags
962
for typ in ("method", "signal", "property"):
963
for tag in if_tag.getElementsByTagName(typ):
964
annots = dict()
965
for name, prop in (self.
966
_get_all_dbus_things(typ)):
967
if (name == tag.getAttribute("name")
968
and prop._dbus_interface
969
== if_tag.getAttribute("name")):
970
annots.update(getattr
971
(prop,
972
"_dbus_annotations",
973
{}))
974
for name, value in annots.iteritems():
975
ann_tag = document.createElement(
976
"annotation")
977
ann_tag.setAttribute("name", name)
978
ann_tag.setAttribute("value", value)
979
tag.appendChild(ann_tag)
980
# Add interface annotation tags
981
for annotation, value in dict(
982
itertools.chain(
983
*(annotations().iteritems()
984
for name, annotations in
985
self._get_all_dbus_things("interface")
986
if name == if_tag.getAttribute("name")
987
))).iteritems():
988
ann_tag = document.createElement("annotation")
989
ann_tag.setAttribute("name", annotation)
990
ann_tag.setAttribute("value", value)
991
if_tag.appendChild(ann_tag)
992
804
# Add the names to the return values for the
993
805
# "org.freedesktop.DBus.Properties" methods
994
806
if (if_tag.getAttribute("name")
1009
821
except (AttributeError, xml.dom.DOMException,
1010
822
xml.parsers.expat.ExpatError) as error:
1011
823
logger.error("Failed to override Introspection method",
1012
exc_info=error)
824
error)
1013
825
return xmlstring
1014
826
1015
827
1020
832
return dbus.String(dt.isoformat(),
1021
833
variant_level=variant_level)
1022
834
1023
1024
835
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
1025
836
.__metaclass__):
1026
837
"""Applied to an empty subclass of a D-Bus object, this metaclass
1029
840
def __new__(mcs, name, bases, attr):
1030
841
# Go through all the base classes which could have D-Bus
1031
842
# methods, signals, or properties in them
1032
old_interface_names = []
1033
843
for base in (b for b in bases
1034
844
if issubclass(b, dbus.service.Object)):
1035
845
# Go though all attributes of the base class
1045
855
alt_interface = (attribute._dbus_interface
1046
856
.replace("se.recompile.Mandos",
1047
857
"se.bsnet.fukt.Mandos"))
1048
if alt_interface != attribute._dbus_interface:
1049
old_interface_names.append(alt_interface)
1050
858
# Is this a D-Bus signal?
1051
859
if getattr(attribute, "_dbus_is_signal", False):
1052
860
# Extract the original non-method function by
1067
875
nonmethod_func.func_name,
1068
876
nonmethod_func.func_defaults,
1069
877
nonmethod_func.func_closure)))
1070
# Copy annotations, if any
1071
try:
1072
new_function._dbus_annotations = (
1073
dict(attribute._dbus_annotations))
1074
except AttributeError:
1075
pass
1076
878
# Define a creator of a function to call both the
1077
879
# old and new functions, so both the old and new
1078
880
# signals gets sent when the function is called
1106
908
attribute.func_name,
1107
909
attribute.func_defaults,
1108
910
attribute.func_closure)))
1109
# Copy annotations, if any
1110
try:
1111
attr[attrname]._dbus_annotations = (
1112
dict(attribute._dbus_annotations))
1113
except AttributeError:
1114
pass
1115
911
# Is this a D-Bus property?
1116
912
elif getattr(attribute, "_dbus_is_property", False):
1117
913
# Create a new, but exactly alike, function
1131
927
attribute.func_name,
1132
928
attribute.func_defaults,
1133
929
attribute.func_closure)))
1134
# Copy annotations, if any
1135
try:
1136
attr[attrname]._dbus_annotations = (
1137
dict(attribute._dbus_annotations))
1138
except AttributeError:
1139
pass
1140
# Is this a D-Bus interface?
1141
elif getattr(attribute, "_dbus_is_interface", False):
1142
# Create a new, but exactly alike, function
1143
# object. Decorate it to be a new D-Bus interface
1144
# with the alternate D-Bus interface name. Add it
1145
# to the class.
1146
attr[attrname] = (dbus_interface_annotations
1147
(alt_interface)
1148
(types.FunctionType
1149
(attribute.func_code,
1150
attribute.func_globals,
1151
attribute.func_name,
1152
attribute.func_defaults,
1153
attribute.func_closure)))
1154
# Deprecate all old interfaces
1155
iname="_AlternateDBusNamesMetaclass_interface_annotation{0}"
1156
for old_interface_name in old_interface_names:
1157
@dbus_interface_annotations(old_interface_name)
1158
def func(self):
1159
return { "org.freedesktop.DBus.Deprecated": "true" }
1160
# Find an unused name
1161
for aname in (iname.format(i) for i in itertools.count()):
1162
if aname not in attr:
1163
attr[aname] = func
1164
break
1165
930
return type.__new__(mcs, name, bases, attr)
1166
931
1167
1168
932
class ClientDBus(Client, DBusObjectWithProperties):
1169
933
"""A Client class using D-Bus
1170
934
1181
945
def __init__(self, bus = None, *args, **kwargs):
1182
946
self.bus = bus
1183
947
Client.__init__(self, *args, **kwargs)
948
949
self._approvals_pending = 0
1184
950
# Only now, when this client is initialized, can it show up on
1185
951
# the D-Bus
1186
952
client_object_name = unicode(self.name).translate(
1190
956
("/clients/" + client_object_name))
1191
957
DBusObjectWithProperties.__init__(self, self.bus,
1192
958
self.dbus_object_path)
1193
959
1194
960
def notifychangeproperty(transform_func,
1195
961
dbus_name, type_func=lambda x: x,
1196
962
variant_level=1):
1197
963
""" Modify a variable so that it's a property which announces
1198
964
its changes to DBus.
1199
965
1200
966
transform_fun: Function that takes a value and a variant_level
1201
967
and transforms it to a D-Bus type.
1202
968
dbus_name: D-Bus name of the variable
1219
985
1220
986
return property(lambda self: getattr(self, attrname), setter)
1221
987
988
1222
989
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1223
990
approvals_pending = notifychangeproperty(dbus.Boolean,
1224
991
"ApprovalPending",
1231
998
checker is not None)
1232
999
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1233
1000
"LastCheckedOK")
1234
last_checker_status = notifychangeproperty(dbus.Int16,
1235
"LastCheckerStatus")
1236
1001
last_approval_request = notifychangeproperty(
1237
1002
datetime_to_dbus, "LastApprovalRequest")
1238
1003
approved_by_default = notifychangeproperty(dbus.Boolean,
1239
1004
"ApprovedByDefault")
1240
approval_delay = notifychangeproperty(dbus.UInt64,
1005
approval_delay = notifychangeproperty(dbus.UInt16,
1241
1006
"ApprovalDelay",
1242
1007
type_func =
1243
timedelta_to_milliseconds)
1008
_timedelta_to_milliseconds)
1244
1009
approval_duration = notifychangeproperty(
1245
dbus.UInt64, "ApprovalDuration",
1246
type_func = timedelta_to_milliseconds)
1010
dbus.UInt16, "ApprovalDuration",
1011
type_func = _timedelta_to_milliseconds)
1247
1012
host = notifychangeproperty(dbus.String, "Host")
1248
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1013
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1249
1014
type_func =
1250
timedelta_to_milliseconds)
1015
_timedelta_to_milliseconds)
1251
1016
extended_timeout = notifychangeproperty(
1252
dbus.UInt64, "ExtendedTimeout",
1253
type_func = timedelta_to_milliseconds)
1254
interval = notifychangeproperty(dbus.UInt64,
1017
dbus.UInt16, "ExtendedTimeout",
1018
type_func = _timedelta_to_milliseconds)
1019
interval = notifychangeproperty(dbus.UInt16,
1255
1020
"Interval",
1256
1021
type_func =
1257
timedelta_to_milliseconds)
1022
_timedelta_to_milliseconds)
1258
1023
checker_command = notifychangeproperty(dbus.String, "Checker")
1259
1024
1260
1025
del notifychangeproperty
1302
1067
return r
1303
1068
1304
1069
def _reset_approved(self):
1305
self.approved = None
1070
self._approved = None
1306
1071
return False
1307
1072
1308
1073
def approve(self, value=True):
1309
1074
self.send_changedstate()
1310
self.approved = value
1311
gobject.timeout_add(timedelta_to_milliseconds
1075
self._approved = value
1076
gobject.timeout_add(_timedelta_to_milliseconds
1312
1077
(self.approval_duration),
1313
1078
self._reset_approved)
1314
1079
1080
1315
1081
## D-Bus methods, signals & properties
1316
1082
_interface = "se.recompile.Mandos.Client"
1317
1083
1318
## Interfaces
1319
1320
@dbus_interface_annotations(_interface)
1321
def _foo(self):
1322
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1323
"false"}
1324
1325
1084
## Signals
1326
1085
1327
1086
# CheckerCompleted - signal
1426
1185
access="readwrite")
1427
1186
def ApprovalDuration_dbus_property(self, value=None):
1428
1187
if value is None: # get
1429
return dbus.UInt64(timedelta_to_milliseconds(
1188
return dbus.UInt64(_timedelta_to_milliseconds(
1430
1189
self.approval_duration))
1431
1190
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1432
1191
1446
1205
def Host_dbus_property(self, value=None):
1447
1206
if value is None: # get
1448
1207
return dbus.String(self.host)
1449
self.host = unicode(value)
1208
self.host = value
1450
1209
1451
1210
# Created - property
1452
1211
@dbus_service_property(_interface, signature="s", access="read")
1453
1212
def Created_dbus_property(self):
1454
return datetime_to_dbus(self.created)
1213
return dbus.String(datetime_to_dbus(self.created))
1455
1214
1456
1215
# LastEnabled - property
1457
1216
@dbus_service_property(_interface, signature="s", access="read")
1478
1237
return
1479
1238
return datetime_to_dbus(self.last_checked_ok)
1480
1239
1481
# LastCheckerStatus - property
1482
@dbus_service_property(_interface, signature="n",
1483
access="read")
1484
def LastCheckerStatus_dbus_property(self):
1485
return dbus.Int16(self.last_checker_status)
1486
1487
1240
# Expires - property
1488
1241
@dbus_service_property(_interface, signature="s", access="read")
1489
1242
def Expires_dbus_property(self):
1501
1254
if value is None: # get
1502
1255
return dbus.UInt64(self.timeout_milliseconds())
1503
1256
self.timeout = datetime.timedelta(0, 0, 0, value)
1257
if getattr(self, "disable_initiator_tag", None) is None:
1258
return
1504
1259
# Reschedule timeout
1505
if self.enabled:
1506
now = datetime.datetime.utcnow()
1507
time_to_die = timedelta_to_milliseconds(
1508
(self.last_checked_ok + self.timeout) - now)
1509
if time_to_die <= 0:
1510
# The timeout has passed
1511
self.disable()
1512
else:
1513
self.expires = (now +
1514
datetime.timedelta(milliseconds =
1515
time_to_die))
1516
if (getattr(self, "disable_initiator_tag", None)
1517
is None):
1518
return
1519
gobject.source_remove(self.disable_initiator_tag)
1520
self.disable_initiator_tag = (gobject.timeout_add
1521
(time_to_die,
1522
self.disable))
1260
gobject.source_remove(self.disable_initiator_tag)
1261
self.disable_initiator_tag = None
1262
self.expires = None
1263
time_to_die = _timedelta_to_milliseconds((self
1264
.last_checked_ok
1265
+ self.timeout)
1266
- datetime.datetime
1267
.utcnow())
1268
if time_to_die <= 0:
1269
# The timeout has passed
1270
self.disable()
1271
else:
1272
self.expires = (datetime.datetime.utcnow()
1273
+ datetime.timedelta(milliseconds =
1274
time_to_die))
1275
self.disable_initiator_tag = (gobject.timeout_add
1276
(time_to_die, self.disable))
1523
1277
1524
1278
# ExtendedTimeout - property
1525
1279
@dbus_service_property(_interface, signature="t",
1538
1292
self.interval = datetime.timedelta(0, 0, 0, value)
1539
1293
if getattr(self, "checker_initiator_tag", None) is None:
1540
1294
return
1541
if self.enabled:
1542
# Reschedule checker run
1543
gobject.source_remove(self.checker_initiator_tag)
1544
self.checker_initiator_tag = (gobject.timeout_add
1545
(value, self.start_checker))
1546
self.start_checker() # Start one now, too
1295
# Reschedule checker run
1296
gobject.source_remove(self.checker_initiator_tag)
1297
self.checker_initiator_tag = (gobject.timeout_add
1298
(value, self.start_checker))
1299
self.start_checker() # Start one now, too
1547
1300
1548
1301
# Checker - property
1549
1302
@dbus_service_property(_interface, signature="s",
1551
1304
def Checker_dbus_property(self, value=None):
1552
1305
if value is None: # get
1553
1306
return dbus.String(self.checker_command)
1554
self.checker_command = unicode(value)
1307
self.checker_command = value
1555
1308
1556
1309
# CheckerRunning - property
1557
1310
@dbus_service_property(_interface, signature="b",
1586
1339
raise KeyError()
1587
1340
1588
1341
def __getattribute__(self, name):
1589
if name == '_pipe':
1342
if(name == '_pipe'):
1590
1343
return super(ProxyClient, self).__getattribute__(name)
1591
1344
self._pipe.send(('getattr', name))
1592
1345
data = self._pipe.recv()
1599
1352
return func
1600
1353
1601
1354
def __setattr__(self, name, value):
1602
if name == '_pipe':
1355
if(name == '_pipe'):
1603
1356
return super(ProxyClient, self).__setattr__(name, value)
1604
1357
self._pipe.send(('setattr', name, value))
1605
1358
1606
1607
1359
class ClientDBusTransitional(ClientDBus):
1608
1360
__metaclass__ = AlternateDBusNamesMetaclass
1609
1361
1610
1611
1362
class ClientHandler(socketserver.BaseRequestHandler, object):
1612
1363
"""A class to handle client connections.
1613
1364
1695
1446
client.Rejected("Disabled")
1696
1447
return
1697
1448
1698
if client.approved or not client.approval_delay:
1449
if client._approved or not client.approval_delay:
1699
1450
#We are approved or approval is disabled
1700
1451
break
1701
elif client.approved is None:
1452
elif client._approved is None:
1702
1453
logger.info("Client %s needs approval",
1703
1454
client.name)
1704
1455
if self.server.use_dbus:
1718
1469
time = datetime.datetime.now()
1719
1470
client.changedstate.acquire()
1720
1471
(client.changedstate.wait
1721
(float(client.timedelta_to_milliseconds(delay)
1472
(float(client._timedelta_to_milliseconds(delay)
1722
1473
/ 1000)))
1723
1474
client.changedstate.release()
1724
1475
time2 = datetime.datetime.now()
1741
1492
try:
1742
1493
sent = session.send(client.secret[sent_size:])
1743
1494
except gnutls.errors.GNUTLSError as error:
1744
logger.warning("gnutls send failed",
1745
exc_info=error)
1495
logger.warning("gnutls send failed")
1746
1496
return
1747
1497
logger.debug("Sent: %d, remaining: %d",
1748
1498
sent, len(client.secret)
1751
1501
1752
1502
logger.info("Sending secret to %s", client.name)
1753
1503
# bump the timeout using extended_timeout
1754
client.bump_timeout(client.extended_timeout)
1504
client.checked_ok(client.extended_timeout)
1755
1505
if self.server.use_dbus:
1756
1506
# Emit D-Bus signal
1757
1507
client.GotSecret()
1762
1512
try:
1763
1513
session.bye()
1764
1514
except gnutls.errors.GNUTLSError as error:
1765
logger.warning("GnuTLS bye failed",
1766
exc_info=error)
1515
logger.warning("GnuTLS bye failed")
1767
1516
1768
1517
@staticmethod
1769
1518
def peer_certificate(session):
1825
1574
# Convert the buffer to a Python bytestring
1826
1575
fpr = ctypes.string_at(buf, buf_len.value)
1827
1576
# Convert the bytestring to hexadecimal notation
1828
hex_fpr = binascii.hexlify(fpr).upper()
1577
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1829
1578
return hex_fpr
1830
1579
1831
1580
1834
1583
def sub_process_main(self, request, address):
1835
1584
try:
1836
1585
self.finish_request(request, address)
1837
except Exception:
1586
except:
1838
1587
self.handle_error(request, address)
1839
1588
self.close_request(request)
1840
1589
2081
1830
elif suffix == "w":
2082
1831
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2083
1832
else:
2084
raise ValueError("Unknown suffix {0!r}"
2085
.format(suffix))
1833
raise ValueError("Unknown suffix %r" % suffix)
2086
1834
except (ValueError, IndexError) as e:
2087
1835
raise ValueError(*(e.args))
2088
1836
timevalue += delta
2089
1837
return timevalue
2090
1838
2091
1839
1840
def if_nametoindex(interface):
1841
"""Call the C function if_nametoindex(), or equivalent
1842
1843
Note: This function cannot accept a unicode string."""
1844
global if_nametoindex
1845
try:
1846
if_nametoindex = (ctypes.cdll.LoadLibrary
1847
(ctypes.util.find_library("c"))
1848
.if_nametoindex)
1849
except (OSError, AttributeError):
1850
logger.warning("Doing if_nametoindex the hard way")
1851
def if_nametoindex(interface):
1852
"Get an interface index the hard way, i.e. using fcntl()"
1853
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1854
with contextlib.closing(socket.socket()) as s:
1855
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1856
struct.pack(str("16s16x"),
1857
interface))
1858
interface_index = struct.unpack(str("I"),
1859
ifreq[16:20])[0]
1860
return interface_index
1861
return if_nametoindex(interface)
1862
1863
2092
1864
def daemon(nochdir = False, noclose = False):
2093
1865
"""See daemon(3). Standard BSD Unix function.
2094
1866
2102
1874
sys.exit()
2103
1875
if not noclose:
2104
1876
# Close all standard open file descriptors
2105
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1877
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2106
1878
if not stat.S_ISCHR(os.fstat(null).st_mode):
2107
1879
raise OSError(errno.ENODEV,
2108
"{0} not a character device"
2109
.format(os.devnull))
1880
"%s not a character device"
1881
% os.path.devnull)
2110
1882
os.dup2(null, sys.stdin.fileno())
2111
1883
os.dup2(null, sys.stdout.fileno())
2112
1884
os.dup2(null, sys.stderr.fileno())
2121
1893
2122
1894
parser = argparse.ArgumentParser()
2123
1895
parser.add_argument("-v", "--version", action="version",
2124
version = "%(prog)s {0}".format(version),
1896
version = "%%(prog)s %s" % version,
2125
1897
help="show version number and exit")
2126
1898
parser.add_argument("-i", "--interface", metavar="IF",
2127
1899
help="Bind to interface IF")
2150
1922
parser.add_argument("--no-ipv6", action="store_false",
2151
1923
dest="use_ipv6", help="Do not use IPv6")
2152
1924
parser.add_argument("--no-restore", action="store_false",
2153
dest="restore", help="Do not restore stored"
2154
" state")
2155
parser.add_argument("--statedir", metavar="DIR",
2156
help="Directory to save/restore state in")
2157
1925
dest="restore", help="Do not restore stored state",
1926
default=True)
1927
2158
1928
options = parser.parse_args()
2159
1929
2160
1930
if options.check:
2173
1943
"use_dbus": "True",
2174
1944
"use_ipv6": "True",
2175
1945
"debuglevel": "",
2176
"restore": "True",
2177
"statedir": "/var/lib/mandos"
2178
1946
}
2179
1947
2180
1948
# Parse config file for server-global settings
2197
1965
# options, if set.
2198
1966
for option in ("interface", "address", "port", "debug",
2199
1967
"priority", "servicename", "configdir",
2200
"use_dbus", "use_ipv6", "debuglevel", "restore",
2201
"statedir"):
1968
"use_dbus", "use_ipv6", "debuglevel", "restore"):
2202
1969
value = getattr(options, option)
2203
1970
if value is not None:
2204
1971
server_settings[option] = value
2216
1983
debuglevel = server_settings["debuglevel"]
2217
1984
use_dbus = server_settings["use_dbus"]
2218
1985
use_ipv6 = server_settings["use_ipv6"]
2219
stored_state_path = os.path.join(server_settings["statedir"],
2220
stored_state_file)
2221
2222
if debug:
2223
initlogger(debug, logging.DEBUG)
2224
else:
2225
if not debuglevel:
2226
initlogger(debug)
2227
else:
2228
level = getattr(logging, debuglevel.upper())
2229
initlogger(debug, level)
2230
1986
2231
1987
if server_settings["servicename"] != "Mandos":
2232
1988
syslogger.setFormatter(logging.Formatter
2233
('Mandos ({0}) [%(process)d]:'
2234
' %(levelname)s: %(message)s'
2235
.format(server_settings
2236
["servicename"])))
1989
('Mandos (%s) [%%(process)d]:'
1990
' %%(levelname)s: %%(message)s'
1991
% server_settings["servicename"]))
2237
1992
2238
1993
# Parse config file with clients
2239
client_config = configparser.SafeConfigParser(Client
2240
.client_defaults)
1994
client_defaults = { "timeout": "5m",
1995
"extended_timeout": "15m",
1996
"interval": "2m",
1997
"checker": "fping -q -- %%(host)s",
1998
"host": "",
1999
"approval_delay": "0s",
2000
"approval_duration": "1s",
2001
}
2002
client_config = configparser.SafeConfigParser(client_defaults)
2241
2003
client_config.read(os.path.join(server_settings["configdir"],
2242
2004
"clients.conf"))
2243
2005
2257
2019
pidfilename = "/var/run/mandos.pid"
2258
2020
try:
2259
2021
pidfile = open(pidfilename, "w")
2260
except IOError as e:
2261
logger.error("Could not open file %r", pidfilename,
2262
exc_info=e)
2022
except IOError:
2023
logger.error("Could not open file %r", pidfilename)
2263
2024
2264
for name in ("_mandos", "mandos", "nobody"):
2025
try:
2026
uid = pwd.getpwnam("_mandos").pw_uid
2027
gid = pwd.getpwnam("_mandos").pw_gid
2028
except KeyError:
2265
2029
try:
2266
uid = pwd.getpwnam(name).pw_uid
2267
gid = pwd.getpwnam(name).pw_gid
2268
break
2030
uid = pwd.getpwnam("mandos").pw_uid
2031
gid = pwd.getpwnam("mandos").pw_gid
2269
2032
except KeyError:
2270
continue
2271
else:
2272
uid = 65534
2273
gid = 65534
2033
try:
2034
uid = pwd.getpwnam("nobody").pw_uid
2035
gid = pwd.getpwnam("nobody").pw_gid
2036
except KeyError:
2037
uid = 65534
2038
gid = 65534
2274
2039
try:
2275
2040
os.setgid(gid)
2276
2041
os.setuid(uid)
2278
2043
if error[0] != errno.EPERM:
2279
2044
raise error
2280
2045
2046
if not debug and not debuglevel:
2047
logger.setLevel(logging.WARNING)
2048
if debuglevel:
2049
level = getattr(logging, debuglevel.upper())
2050
logger.setLevel(level)
2051
2281
2052
if debug:
2053
logger.setLevel(logging.DEBUG)
2282
2054
# Enable all possible GnuTLS debugging
2283
2055
2284
2056
# "Use a log level over 10 to enable all debugging options."
2293
2065
.gnutls_global_set_log_function(debug_gnutls))
2294
2066
2295
2067
# Redirect stdin so all checkers get /dev/null
2296
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2068
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2297
2069
os.dup2(null, sys.stdin.fileno())
2298
2070
if null > 2:
2299
2071
os.close(null)
2072
else:
2073
# No console logging
2074
logger.removeHandler(console)
2300
2075
2301
2076
# Need to fork before connecting to D-Bus
2302
2077
if not debug:
2303
2078
# Close all input and output, do double fork, etc.
2304
2079
daemon()
2305
2080
2306
gobject.threads_init()
2307
2308
2081
global main_loop
2309
2082
# From the Avahi example code
2310
DBusGMainLoop(set_as_default=True)
2083
DBusGMainLoop(set_as_default=True )
2311
2084
main_loop = gobject.MainLoop()
2312
2085
bus = dbus.SystemBus()
2313
2086
# End of Avahi example code
2319
2092
("se.bsnet.fukt.Mandos", bus,
2320
2093
do_not_queue=True))
2321
2094
except dbus.exceptions.NameExistsException as e:
2322
logger.error("Disabling D-Bus:", exc_info=e)
2095
logger.error(unicode(e) + ", disabling D-Bus")
2323
2096
use_dbus = False
2324
2097
server_settings["use_dbus"] = False
2325
2098
tcp_server.use_dbus = False
2340
2113
client_class = functools.partial(ClientDBusTransitional,
2341
2114
bus = bus)
2342
2115
2343
client_settings = Client.config_parser(client_config)
2116
special_settings = {
2117
# Some settings need to be accessd by special methods;
2118
# booleans need .getboolean(), etc. Here is a list of them:
2119
"approved_by_default":
2120
lambda section:
2121
client_config.getboolean(section, "approved_by_default"),
2122
}
2123
# Construct a new dict of client settings of this form:
2124
# { client_name: {setting_name: value, ...}, ...}
2125
# with exceptions for any special settings as defined above
2126
client_settings = dict((clientname,
2127
dict((setting,
2128
(value if setting not in special_settings
2129
else special_settings[setting](clientname)))
2130
for setting, value in client_config.items(clientname)))
2131
for clientname in client_config.sections())
2132
2344
2133
old_client_settings = {}
2345
clients_data = {}
2346
2347
# Get client data and settings from last running state.
2134
clients_data = []
2135
2136
# Get client data and settings from last running state.
2348
2137
if server_settings["restore"]:
2349
2138
try:
2350
2139
with open(stored_state_path, "rb") as stored_state:
2351
clients_data, old_client_settings = (pickle.load
2352
(stored_state))
2140
clients_data, old_client_settings = pickle.load(stored_state)
2353
2141
os.remove(stored_state_path)
2354
2142
except IOError as e:
2355
if e.errno == errno.ENOENT:
2356
logger.warning("Could not load persistent state: {0}"
2357
.format(os.strerror(e.errno)))
2358
else:
2359
logger.critical("Could not load persistent state:",
2360
exc_info=e)
2143
logger.warning("Could not load persistant state: {0}".format(e))
2144
if e.errno != errno.ENOENT:
2361
2145
raise
2362
except EOFError as e:
2363
logger.warning("Could not load persistent state: "
2364
"EOFError:", exc_info=e)
2365
2366
with PGPEngine() as pgp:
2367
for client_name, client in clients_data.iteritems():
2368
# Decide which value to use after restoring saved state.
2369
# We have three different values: Old config file,
2370
# new config file, and saved state.
2371
# New config value takes precedence if it differs from old
2372
# config value, otherwise use saved state.
2373
for name, value in client_settings[client_name].items():
2374
try:
2375
# For each value in new config, check if it
2376
# differs from the old config value (Except for
2377
# the "secret" attribute)
2378
if (name != "secret" and
2379
value != old_client_settings[client_name]
2380
[name]):
2381
client[name] = value
2382
except KeyError:
2383
pass
2384
2385
# Clients who has passed its expire date can still be
2386
# enabled if its last checker was successful. Clients
2387
# whose checker succeeded before we stored its state is
2388
# assumed to have successfully run all checkers during
2389
# downtime.
2390
if client["enabled"]:
2391
if datetime.datetime.utcnow() >= client["expires"]:
2392
if not client["last_checked_ok"]:
2393
logger.warning(
2394
"disabling client {0} - Client never "
2395
"performed a successful checker"
2396
.format(client_name))
2397
client["enabled"] = False
2398
elif client["last_checker_status"] != 0:
2399
logger.warning(
2400
"disabling client {0} - Client "
2401
"last checker failed with error code {1}"
2402
.format(client_name,
2403
client["last_checker_status"]))
2404
client["enabled"] = False
2405
else:
2406
client["expires"] = (datetime.datetime
2407
.utcnow()
2408
+ client["timeout"])
2409
logger.debug("Last checker succeeded,"
2410
" keeping {0} enabled"
2411
.format(client_name))
2146
2147
for client in clients_data:
2148
client_name = client["name"]
2149
2150
# Decide which value to use after restoring saved state.
2151
# We have three different values: Old config file,
2152
# new config file, and saved state.
2153
# New config value takes precedence if it differs from old
2154
# config value, otherwise use saved state.
2155
for name, value in client_settings[client_name].items():
2412
2156
try:
2413
client["secret"] = (
2414
pgp.decrypt(client["encrypted_secret"],
2415
client_settings[client_name]
2416
["secret"]))
2417
except PGPError:
2418
# If decryption fails, we use secret from new settings
2419
logger.debug("Failed to decrypt {0} old secret"
2420
.format(client_name))
2421
client["secret"] = (
2422
client_settings[client_name]["secret"])
2423
2424
# Add/remove clients based on new changes made to config
2425
for client_name in (set(old_client_settings)
2426
- set(client_settings)):
2427
del clients_data[client_name]
2428
for client_name in (set(client_settings)
2429
- set(old_client_settings)):
2430
clients_data[client_name] = client_settings[client_name]
2431
2432
# Create all client objects
2433
for client_name, client in clients_data.iteritems():
2434
tcp_server.clients[client_name] = client_class(
2435
name = client_name, settings = client)
2436
2157
# For each value in new config, check if it differs
2158
# from the old config value (Except for the "secret"
2159
# attribute)
2160
if name != "secret" and value != old_client_settings[client_name][name]:
2161
setattr(client, name, value)
2162
except KeyError:
2163
pass
2164
2165
# Clients who has passed its expire date, can still be enabled if its
2166
# last checker was sucessful. Clients who checkers failed before we
2167
# stored it state is asumed to had failed checker during downtime.
2168
if client["enabled"] and client["last_checked_ok"]:
2169
if ((datetime.datetime.utcnow() - client["last_checked_ok"])
2170
> client["interval"]):
2171
if client["last_checker_status"] != 0:
2172
client["enabled"] = False
2173
else:
2174
client["expires"] = datetime.datetime.utcnow() + client["timeout"]
2175
2176
client["changedstate"] = (multiprocessing_manager
2177
.Condition(multiprocessing_manager
2178
.Lock()))
2179
if use_dbus:
2180
new_client = ClientDBusTransitional.__new__(ClientDBusTransitional)
2181
tcp_server.clients[client_name] = new_client
2182
new_client.bus = bus
2183
for name, value in client.iteritems():
2184
setattr(new_client, name, value)
2185
client_object_name = unicode(client_name).translate(
2186
{ord("."): ord("_"),
2187
ord("-"): ord("_")})
2188
new_client.dbus_object_path = (dbus.ObjectPath
2189
("/clients/" + client_object_name))
2190
DBusObjectWithProperties.__init__(new_client,
2191
new_client.bus,
2192
new_client.dbus_object_path)
2193
else:
2194
tcp_server.clients[client_name] = Client.__new__(Client)
2195
for name, value in client.iteritems():
2196
setattr(tcp_server.clients[client_name], name, value)
2197
2198
tcp_server.clients[client_name].decrypt_secret(
2199
client_settings[client_name]["secret"])
2200
2201
# Create/remove clients based on new changes made to config
2202
for clientname in set(old_client_settings) - set(client_settings):
2203
del tcp_server.clients[clientname]
2204
for clientname in set(client_settings) - set(old_client_settings):
2205
tcp_server.clients[clientname] = (client_class(name = clientname,
2206
config =
2207
client_settings
2208
[clientname]))
2209
2210
2437
2211
if not tcp_server.clients:
2438
2212
logger.warning("No clients defined")
2439
2213
2440
2214
if not debug:
2441
2215
try:
2442
2216
with pidfile:
2450
2224
# "pidfile" was never created
2451
2225
pass
2452
2226
del pidfilename
2227
2453
2228
signal.signal(signal.SIGINT, signal.SIG_IGN)
2454
2229
2455
2230
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2456
2231
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2457
2232
2458
2233
if use_dbus:
2459
class MandosDBusService(DBusObjectWithProperties):
2234
class MandosDBusService(dbus.service.Object):
2460
2235
"""A D-Bus proxy object"""
2461
2236
def __init__(self):
2462
2237
dbus.service.Object.__init__(self, bus, "/")
2463
2238
_interface = "se.recompile.Mandos"
2464
2239
2465
@dbus_interface_annotations(_interface)
2466
def _foo(self):
2467
return { "org.freedesktop.DBus.Property"
2468
".EmitsChangedSignal":
2469
"false"}
2470
2471
2240
@dbus.service.signal(_interface, signature="o")
2472
2241
def ClientAdded(self, objpath):
2473
2242
"D-Bus signal"
2526
2295
multiprocessing.active_children()
2527
2296
if not (tcp_server.clients or client_settings):
2528
2297
return
2529
2530
# Store client before exiting. Secrets are encrypted with key
2531
# based on what config file has. If config file is
2532
# removed/edited, old secret will thus be unrecovable.
2533
clients = {}
2534
with PGPEngine() as pgp:
2535
for client in tcp_server.clients.itervalues():
2536
key = client_settings[client.name]["secret"]
2537
client.encrypted_secret = pgp.encrypt(client.secret,
2538
key)
2539
client_dict = {}
2540
2541
# A list of attributes that can not be pickled
2542
# + secret.
2543
exclude = set(("bus", "changedstate", "secret",
2544
"checker"))
2545
for name, typ in (inspect.getmembers
2546
(dbus.service.Object)):
2547
exclude.add(name)
2548
2549
client_dict["encrypted_secret"] = (client
2550
.encrypted_secret)
2551
for attr in client.client_structure:
2552
if attr not in exclude:
2553
client_dict[attr] = getattr(client, attr)
2554
2555
clients[client.name] = client_dict
2556
del client_settings[client.name]["secret"]
2557
2298
2299
# Store client before exiting. Secrets are encrypted with key based
2300
# on what config file has. If config file is removed/edited, old
2301
# secret will thus be unrecovable.
2302
clients = []
2303
for client in tcp_server.clients.itervalues():
2304
client.encrypt_secret(client_settings[client.name]["secret"])
2305
2306
client_dict = {}
2307
2308
# A list of attributes that will not be stored when shuting down.
2309
exclude = set(("bus", "changedstate", "secret"))
2310
for name, typ in inspect.getmembers(dbus.service.Object):
2311
exclude.add(name)
2312
2313
client_dict["encrypted_secret"] = client.encrypted_secret
2314
for attr in client.client_structure:
2315
if attr not in exclude:
2316
client_dict[attr] = getattr(client, attr)
2317
2318
clients.append(client_dict)
2319
del client_settings[client.name]["secret"]
2320
2558
2321
try:
2559
tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2560
prefix="clients-",
2561
dir=os.path.dirname
2562
(stored_state_path))
2563
with os.fdopen(tempfd, "wb") as stored_state:
2322
with os.fdopen(os.open(stored_state_path, os.O_CREAT|os.O_WRONLY|os.O_TRUNC, 0600), "wb") as stored_state:
2564
2323
pickle.dump((clients, client_settings), stored_state)
2565
os.rename(tempname, stored_state_path)
2566
except (IOError, OSError) as e:
2567
if not debug:
2568
try:
2569
os.remove(tempname)
2570
except NameError:
2571
pass
2572
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2573
logger.warning("Could not save persistent state: {0}"
2574
.format(os.strerror(e.errno)))
2575
else:
2576
logger.warning("Could not save persistent state:",
2577
exc_info=e)
2578
raise e
2579
2324
except IOError as e:
2325
logger.warning("Could not save persistant state: {0}".format(e))
2326
if e.errno != errno.ENOENT:
2327
raise
2328
2580
2329
# Delete all clients, and settings from config
2581
2330
while tcp_server.clients:
2582
2331
name, client = tcp_server.clients.popitem()
2600
2349
# Need to initiate checking of clients
2601
2350
if client.enabled:
2602
2351
client.init_checker()
2352
2603
2353
2604
2354
tcp_server.enable()
2605
2355
tcp_server.server_activate()
2608
2358
service.port = tcp_server.socket.getsockname()[1]
2609
2359
if use_ipv6:
2610
2360
logger.info("Now listening on address %r, port %d,"
2611
" flowinfo %d, scope_id %d",
2612
*tcp_server.socket.getsockname())
2361
" flowinfo %d, scope_id %d"
2362
% tcp_server.socket.getsockname())
2613
2363
else: # IPv4
2614
logger.info("Now listening on address %r, port %d",
2615
*tcp_server.socket.getsockname())
2364
logger.info("Now listening on address %r, port %d"
2365
% tcp_server.socket.getsockname())
2616
2366
2617
2367
#service.interface = tcp_server.socket.getsockname()[3]
2618
2368
2621
2371
try:
2622
2372
service.activate()
2623
2373
except dbus.exceptions.DBusException as error:
2624
logger.critical("D-Bus Exception", exc_info=error)
2374
logger.critical("DBusException: %s", error)
2625
2375
cleanup()
2626
2376
sys.exit(1)
2627
2377
# End of Avahi example code
2634
2384
logger.debug("Starting main loop")
2635
2385
main_loop.run()
2636
2386
except AvahiError as error:
2637
logger.critical("Avahi Error", exc_info=error)
2387
logger.critical("AvahiError: %s", error)
2638
2388
cleanup()
2639
2389
sys.exit(1)
2640
2390
except KeyboardInterrupt:
2645
2395
# Must run before the D-Bus bus name gets deregistered
2646
2396
cleanup()
2647
2397
2398
2648
2399
if __name__ == '__main__':
2649
2400
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0