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
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1025
"""A class decorator; applied to a subclass of
1026
dbus.service.Object, it will add alternate D-Bus attributes with
1027
interface names according to the "alt_interface_names" mapping.
1028
Usage:
1029
1030
@alternate_dbus_names({"org.example.Interface":
1031
"net.example.AlternateInterface"})
1032
class SampleDBusObject(dbus.service.Object):
1033
@dbus.service.method("org.example.Interface")
1034
def SampleDBusMethod():
1035
pass
1036
1037
The above "SampleDBusMethod" on "SampleDBusObject" will be
1038
reachable via two interfaces: "org.example.Interface" and
1039
"net.example.AlternateInterface", the latter of which will have
1040
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1041
"true", unless "deprecate" is passed with a False value.
1042
1043
This works for methods and signals, and also for D-Bus properties
1044
(from DBusObjectWithProperties) and interfaces (from the
1045
dbus_interface_annotations decorator).
835
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
836
.__metaclass__):
837
"""Applied to an empty subclass of a D-Bus object, this metaclass
838
will add additional D-Bus attributes matching a certain pattern.
1046
839
"""
1047
def wrapper(cls):
1048
for orig_interface_name, alt_interface_name in (
1049
alt_interface_names.iteritems()):
1050
attr = {}
1051
interface_names = set()
1052
# Go though all attributes of the class
1053
for attrname, attribute in inspect.getmembers(cls):
840
def __new__(mcs, name, bases, attr):
841
# Go through all the base classes which could have D-Bus
842
# methods, signals, or properties in them
843
for base in (b for b in bases
844
if issubclass(b, dbus.service.Object)):
845
# Go though all attributes of the base class
846
for attrname, attribute in inspect.getmembers(base):
1054
847
# Ignore non-D-Bus attributes, and D-Bus attributes
1055
848
# with the wrong interface name
1056
849
if (not hasattr(attribute, "_dbus_interface")
1057
850
or not attribute._dbus_interface
1058
.startswith(orig_interface_name)):
851
.startswith("se.recompile.Mandos")):
1059
852
continue
1060
853
# Create an alternate D-Bus interface name based on
1061
854
# the current name
1062
855
alt_interface = (attribute._dbus_interface
1063
.replace(orig_interface_name,
1064
alt_interface_name))
1065
interface_names.add(alt_interface)
856
.replace("se.recompile.Mandos",
857
"se.bsnet.fukt.Mandos"))
1066
858
# Is this a D-Bus signal?
1067
859
if getattr(attribute, "_dbus_is_signal", False):
1068
860
# Extract the original non-method function by
1083
875
nonmethod_func.func_name,
1084
876
nonmethod_func.func_defaults,
1085
877
nonmethod_func.func_closure)))
1086
# Copy annotations, if any
1087
try:
1088
new_function._dbus_annotations = (
1089
dict(attribute._dbus_annotations))
1090
except AttributeError:
1091
pass
1092
878
# Define a creator of a function to call both the
1093
# original and alternate functions, so both the
1094
# original and alternate signals gets sent when
1095
# the function is called
879
# old and new functions, so both the old and new
880
# signals gets sent when the function is called
1096
881
def fixscope(func1, func2):
1097
882
"""This function is a scope container to pass
1098
883
func1 and func2 to the "call_both" function
1105
890
return call_both
1106
891
# Create the "call_both" function and add it to
1107
892
# the class
1108
attr[attrname] = fixscope(attribute, new_function)
893
attr[attrname] = fixscope(attribute,
894
new_function)
1109
895
# Is this a D-Bus method?
1110
896
elif getattr(attribute, "_dbus_is_method", False):
1111
897
# Create a new, but exactly alike, function
1122
908
attribute.func_name,
1123
909
attribute.func_defaults,
1124
910
attribute.func_closure)))
1125
# Copy annotations, if any
1126
try:
1127
attr[attrname]._dbus_annotations = (
1128
dict(attribute._dbus_annotations))
1129
except AttributeError:
1130
pass
1131
911
# Is this a D-Bus property?
1132
912
elif getattr(attribute, "_dbus_is_property", False):
1133
913
# Create a new, but exactly alike, function
1147
927
attribute.func_name,
1148
928
attribute.func_defaults,
1149
929
attribute.func_closure)))
1150
# Copy annotations, if any
1151
try:
1152
attr[attrname]._dbus_annotations = (
1153
dict(attribute._dbus_annotations))
1154
except AttributeError:
1155
pass
1156
# Is this a D-Bus interface?
1157
elif getattr(attribute, "_dbus_is_interface", False):
1158
# Create a new, but exactly alike, function
1159
# object. Decorate it to be a new D-Bus interface
1160
# with the alternate D-Bus interface name. Add it
1161
# to the class.
1162
attr[attrname] = (dbus_interface_annotations
1163
(alt_interface)
1164
(types.FunctionType
1165
(attribute.func_code,
1166
attribute.func_globals,
1167
attribute.func_name,
1168
attribute.func_defaults,
1169
attribute.func_closure)))
1170
if deprecate:
1171
# Deprecate all alternate interfaces
1172
iname="_AlternateDBusNames_interface_annotation{0}"
1173
for interface_name in interface_names:
1174
@dbus_interface_annotations(interface_name)
1175
def func(self):
1176
return { "org.freedesktop.DBus.Deprecated":
1177
"true" }
1178
# Find an unused name
1179
for aname in (iname.format(i)
1180
for i in itertools.count()):
1181
if aname not in attr:
1182
attr[aname] = func
1183
break
1184
if interface_names:
1185
# Replace the class with a new subclass of it with
1186
# methods, signals, etc. as created above.
1187
cls = type(b"{0}Alternate".format(cls.__name__),
1188
(cls,), attr)
1189
return cls
1190
return wrapper
1191
1192
1193
@alternate_dbus_interfaces({"se.recompile.Mandos":
1194
"se.bsnet.fukt.Mandos"})
930
return type.__new__(mcs, name, bases, attr)
931
1195
932
class ClientDBus(Client, DBusObjectWithProperties):
1196
933
"""A Client class using D-Bus
1197
934
1208
945
def __init__(self, bus = None, *args, **kwargs):
1209
946
self.bus = bus
1210
947
Client.__init__(self, *args, **kwargs)
948
949
self._approvals_pending = 0
1211
950
# Only now, when this client is initialized, can it show up on
1212
951
# the D-Bus
1213
952
client_object_name = unicode(self.name).translate(
1217
956
("/clients/" + client_object_name))
1218
957
DBusObjectWithProperties.__init__(self, self.bus,
1219
958
self.dbus_object_path)
1220
959
1221
960
def notifychangeproperty(transform_func,
1222
961
dbus_name, type_func=lambda x: x,
1223
962
variant_level=1):
1224
963
""" Modify a variable so that it's a property which announces
1225
964
its changes to DBus.
1226
965
1227
966
transform_fun: Function that takes a value and a variant_level
1228
967
and transforms it to a D-Bus type.
1229
968
dbus_name: D-Bus name of the variable
1246
985
1247
986
return property(lambda self: getattr(self, attrname), setter)
1248
987
988
1249
989
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1250
990
approvals_pending = notifychangeproperty(dbus.Boolean,
1251
991
"ApprovalPending",
1258
998
checker is not None)
1259
999
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1260
1000
"LastCheckedOK")
1261
last_checker_status = notifychangeproperty(dbus.Int16,
1262
"LastCheckerStatus")
1263
1001
last_approval_request = notifychangeproperty(
1264
1002
datetime_to_dbus, "LastApprovalRequest")
1265
1003
approved_by_default = notifychangeproperty(dbus.Boolean,
1266
1004
"ApprovedByDefault")
1267
approval_delay = notifychangeproperty(dbus.UInt64,
1005
approval_delay = notifychangeproperty(dbus.UInt16,
1268
1006
"ApprovalDelay",
1269
1007
type_func =
1270
timedelta_to_milliseconds)
1008
_timedelta_to_milliseconds)
1271
1009
approval_duration = notifychangeproperty(
1272
dbus.UInt64, "ApprovalDuration",
1273
type_func = timedelta_to_milliseconds)
1010
dbus.UInt16, "ApprovalDuration",
1011
type_func = _timedelta_to_milliseconds)
1274
1012
host = notifychangeproperty(dbus.String, "Host")
1275
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1013
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1276
1014
type_func =
1277
timedelta_to_milliseconds)
1015
_timedelta_to_milliseconds)
1278
1016
extended_timeout = notifychangeproperty(
1279
dbus.UInt64, "ExtendedTimeout",
1280
type_func = timedelta_to_milliseconds)
1281
interval = notifychangeproperty(dbus.UInt64,
1017
dbus.UInt16, "ExtendedTimeout",
1018
type_func = _timedelta_to_milliseconds)
1019
interval = notifychangeproperty(dbus.UInt16,
1282
1020
"Interval",
1283
1021
type_func =
1284
timedelta_to_milliseconds)
1022
_timedelta_to_milliseconds)
1285
1023
checker_command = notifychangeproperty(dbus.String, "Checker")
1286
1024
1287
1025
del notifychangeproperty
1329
1067
return r
1330
1068
1331
1069
def _reset_approved(self):
1332
self.approved = None
1070
self._approved = None
1333
1071
return False
1334
1072
1335
1073
def approve(self, value=True):
1336
1074
self.send_changedstate()
1337
self.approved = value
1338
gobject.timeout_add(timedelta_to_milliseconds
1075
self._approved = value
1076
gobject.timeout_add(_timedelta_to_milliseconds
1339
1077
(self.approval_duration),
1340
1078
self._reset_approved)
1341
1079
1080
1342
1081
## D-Bus methods, signals & properties
1343
1082
_interface = "se.recompile.Mandos.Client"
1344
1083
1345
## Interfaces
1346
1347
@dbus_interface_annotations(_interface)
1348
def _foo(self):
1349
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1350
"false"}
1351
1352
1084
## Signals
1353
1085
1354
1086
# CheckerCompleted - signal
1453
1185
access="readwrite")
1454
1186
def ApprovalDuration_dbus_property(self, value=None):
1455
1187
if value is None: # get
1456
return dbus.UInt64(timedelta_to_milliseconds(
1188
return dbus.UInt64(_timedelta_to_milliseconds(
1457
1189
self.approval_duration))
1458
1190
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1459
1191
1473
1205
def Host_dbus_property(self, value=None):
1474
1206
if value is None: # get
1475
1207
return dbus.String(self.host)
1476
self.host = unicode(value)
1208
self.host = value
1477
1209
1478
1210
# Created - property
1479
1211
@dbus_service_property(_interface, signature="s", access="read")
1480
1212
def Created_dbus_property(self):
1481
return datetime_to_dbus(self.created)
1213
return dbus.String(datetime_to_dbus(self.created))
1482
1214
1483
1215
# LastEnabled - property
1484
1216
@dbus_service_property(_interface, signature="s", access="read")
1505
1237
return
1506
1238
return datetime_to_dbus(self.last_checked_ok)
1507
1239
1508
# LastCheckerStatus - property
1509
@dbus_service_property(_interface, signature="n",
1510
access="read")
1511
def LastCheckerStatus_dbus_property(self):
1512
return dbus.Int16(self.last_checker_status)
1513
1514
1240
# Expires - property
1515
1241
@dbus_service_property(_interface, signature="s", access="read")
1516
1242
def Expires_dbus_property(self):
1528
1254
if value is None: # get
1529
1255
return dbus.UInt64(self.timeout_milliseconds())
1530
1256
self.timeout = datetime.timedelta(0, 0, 0, value)
1257
if getattr(self, "disable_initiator_tag", None) is None:
1258
return
1531
1259
# Reschedule timeout
1532
if self.enabled:
1533
now = datetime.datetime.utcnow()
1534
time_to_die = timedelta_to_milliseconds(
1535
(self.last_checked_ok + self.timeout) - now)
1536
if time_to_die <= 0:
1537
# The timeout has passed
1538
self.disable()
1539
else:
1540
self.expires = (now +
1541
datetime.timedelta(milliseconds =
1542
time_to_die))
1543
if (getattr(self, "disable_initiator_tag", None)
1544
is None):
1545
return
1546
gobject.source_remove(self.disable_initiator_tag)
1547
self.disable_initiator_tag = (gobject.timeout_add
1548
(time_to_die,
1549
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))
1550
1277
1551
1278
# ExtendedTimeout - property
1552
1279
@dbus_service_property(_interface, signature="t",
1565
1292
self.interval = datetime.timedelta(0, 0, 0, value)
1566
1293
if getattr(self, "checker_initiator_tag", None) is None:
1567
1294
return
1568
if self.enabled:
1569
# Reschedule checker run
1570
gobject.source_remove(self.checker_initiator_tag)
1571
self.checker_initiator_tag = (gobject.timeout_add
1572
(value, self.start_checker))
1573
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
1574
1300
1575
1301
# Checker - property
1576
1302
@dbus_service_property(_interface, signature="s",
1578
1304
def Checker_dbus_property(self, value=None):
1579
1305
if value is None: # get
1580
1306
return dbus.String(self.checker_command)
1581
self.checker_command = unicode(value)
1307
self.checker_command = value
1582
1308
1583
1309
# CheckerRunning - property
1584
1310
@dbus_service_property(_interface, signature="b",
1613
1339
raise KeyError()
1614
1340
1615
1341
def __getattribute__(self, name):
1616
if name == '_pipe':
1342
if(name == '_pipe'):
1617
1343
return super(ProxyClient, self).__getattribute__(name)
1618
1344
self._pipe.send(('getattr', name))
1619
1345
data = self._pipe.recv()
1626
1352
return func
1627
1353
1628
1354
def __setattr__(self, name, value):
1629
if name == '_pipe':
1355
if(name == '_pipe'):
1630
1356
return super(ProxyClient, self).__setattr__(name, value)
1631
1357
self._pipe.send(('setattr', name, value))
1632
1358
1359
class ClientDBusTransitional(ClientDBus):
1360
__metaclass__ = AlternateDBusNamesMetaclass
1633
1361
1634
1362
class ClientHandler(socketserver.BaseRequestHandler, object):
1635
1363
"""A class to handle client connections.
1718
1446
client.Rejected("Disabled")
1719
1447
return
1720
1448
1721
if client.approved or not client.approval_delay:
1449
if client._approved or not client.approval_delay:
1722
1450
#We are approved or approval is disabled
1723
1451
break
1724
elif client.approved is None:
1452
elif client._approved is None:
1725
1453
logger.info("Client %s needs approval",
1726
1454
client.name)
1727
1455
if self.server.use_dbus:
1741
1469
time = datetime.datetime.now()
1742
1470
client.changedstate.acquire()
1743
1471
(client.changedstate.wait
1744
(float(client.timedelta_to_milliseconds(delay)
1472
(float(client._timedelta_to_milliseconds(delay)
1745
1473
/ 1000)))
1746
1474
client.changedstate.release()
1747
1475
time2 = datetime.datetime.now()
1764
1492
try:
1765
1493
sent = session.send(client.secret[sent_size:])
1766
1494
except gnutls.errors.GNUTLSError as error:
1767
logger.warning("gnutls send failed",
1768
exc_info=error)
1495
logger.warning("gnutls send failed")
1769
1496
return
1770
1497
logger.debug("Sent: %d, remaining: %d",
1771
1498
sent, len(client.secret)
1774
1501
1775
1502
logger.info("Sending secret to %s", client.name)
1776
1503
# bump the timeout using extended_timeout
1777
client.bump_timeout(client.extended_timeout)
1504
client.checked_ok(client.extended_timeout)
1778
1505
if self.server.use_dbus:
1779
1506
# Emit D-Bus signal
1780
1507
client.GotSecret()
1785
1512
try:
1786
1513
session.bye()
1787
1514
except gnutls.errors.GNUTLSError as error:
1788
logger.warning("GnuTLS bye failed",
1789
exc_info=error)
1515
logger.warning("GnuTLS bye failed")
1790
1516
1791
1517
@staticmethod
1792
1518
def peer_certificate(session):
1848
1574
# Convert the buffer to a Python bytestring
1849
1575
fpr = ctypes.string_at(buf, buf_len.value)
1850
1576
# Convert the bytestring to hexadecimal notation
1851
hex_fpr = binascii.hexlify(fpr).upper()
1577
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1852
1578
return hex_fpr
1853
1579
1854
1580
1857
1583
def sub_process_main(self, request, address):
1858
1584
try:
1859
1585
self.finish_request(request, address)
1860
except Exception:
1586
except:
1861
1587
self.handle_error(request, address)
1862
1588
self.close_request(request)
1863
1589
2104
1830
elif suffix == "w":
2105
1831
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2106
1832
else:
2107
raise ValueError("Unknown suffix {0!r}"
2108
.format(suffix))
1833
raise ValueError("Unknown suffix %r" % suffix)
2109
1834
except (ValueError, IndexError) as e:
2110
1835
raise ValueError(*(e.args))
2111
1836
timevalue += delta
2112
1837
return timevalue
2113
1838
2114
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
2115
1864
def daemon(nochdir = False, noclose = False):
2116
1865
"""See daemon(3). Standard BSD Unix function.
2117
1866
2125
1874
sys.exit()
2126
1875
if not noclose:
2127
1876
# Close all standard open file descriptors
2128
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1877
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2129
1878
if not stat.S_ISCHR(os.fstat(null).st_mode):
2130
1879
raise OSError(errno.ENODEV,
2131
"{0} not a character device"
2132
.format(os.devnull))
1880
"%s not a character device"
1881
% os.path.devnull)
2133
1882
os.dup2(null, sys.stdin.fileno())
2134
1883
os.dup2(null, sys.stdout.fileno())
2135
1884
os.dup2(null, sys.stderr.fileno())
2144
1893
2145
1894
parser = argparse.ArgumentParser()
2146
1895
parser.add_argument("-v", "--version", action="version",
2147
version = "%(prog)s {0}".format(version),
1896
version = "%%(prog)s %s" % version,
2148
1897
help="show version number and exit")
2149
1898
parser.add_argument("-i", "--interface", metavar="IF",
2150
1899
help="Bind to interface IF")
2173
1922
parser.add_argument("--no-ipv6", action="store_false",
2174
1923
dest="use_ipv6", help="Do not use IPv6")
2175
1924
parser.add_argument("--no-restore", action="store_false",
2176
dest="restore", help="Do not restore stored"
2177
" state")
2178
parser.add_argument("--statedir", metavar="DIR",
2179
help="Directory to save/restore state in")
2180
1925
dest="restore", help="Do not restore stored state",
1926
default=True)
1927
2181
1928
options = parser.parse_args()
2182
1929
2183
1930
if options.check:
2196
1943
"use_dbus": "True",
2197
1944
"use_ipv6": "True",
2198
1945
"debuglevel": "",
2199
"restore": "True",
2200
"statedir": "/var/lib/mandos"
2201
1946
}
2202
1947
2203
1948
# Parse config file for server-global settings
2220
1965
# options, if set.
2221
1966
for option in ("interface", "address", "port", "debug",
2222
1967
"priority", "servicename", "configdir",
2223
"use_dbus", "use_ipv6", "debuglevel", "restore",
2224
"statedir"):
1968
"use_dbus", "use_ipv6", "debuglevel", "restore"):
2225
1969
value = getattr(options, option)
2226
1970
if value is not None:
2227
1971
server_settings[option] = value
2239
1983
debuglevel = server_settings["debuglevel"]
2240
1984
use_dbus = server_settings["use_dbus"]
2241
1985
use_ipv6 = server_settings["use_ipv6"]
2242
stored_state_path = os.path.join(server_settings["statedir"],
2243
stored_state_file)
2244
2245
if debug:
2246
initlogger(debug, logging.DEBUG)
2247
else:
2248
if not debuglevel:
2249
initlogger(debug)
2250
else:
2251
level = getattr(logging, debuglevel.upper())
2252
initlogger(debug, level)
2253
1986
2254
1987
if server_settings["servicename"] != "Mandos":
2255
1988
syslogger.setFormatter(logging.Formatter
2256
('Mandos ({0}) [%(process)d]:'
2257
' %(levelname)s: %(message)s'
2258
.format(server_settings
2259
["servicename"])))
1989
('Mandos (%s) [%%(process)d]:'
1990
' %%(levelname)s: %%(message)s'
1991
% server_settings["servicename"]))
2260
1992
2261
1993
# Parse config file with clients
2262
client_config = configparser.SafeConfigParser(Client
2263
.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)
2264
2003
client_config.read(os.path.join(server_settings["configdir"],
2265
2004
"clients.conf"))
2266
2005
2280
2019
pidfilename = "/var/run/mandos.pid"
2281
2020
try:
2282
2021
pidfile = open(pidfilename, "w")
2283
except IOError as e:
2284
logger.error("Could not open file %r", pidfilename,
2285
exc_info=e)
2022
except IOError:
2023
logger.error("Could not open file %r", pidfilename)
2286
2024
2287
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:
2288
2029
try:
2289
uid = pwd.getpwnam(name).pw_uid
2290
gid = pwd.getpwnam(name).pw_gid
2291
break
2030
uid = pwd.getpwnam("mandos").pw_uid
2031
gid = pwd.getpwnam("mandos").pw_gid
2292
2032
except KeyError:
2293
continue
2294
else:
2295
uid = 65534
2296
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
2297
2039
try:
2298
2040
os.setgid(gid)
2299
2041
os.setuid(uid)
2301
2043
if error[0] != errno.EPERM:
2302
2044
raise error
2303
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
2304
2052
if debug:
2053
logger.setLevel(logging.DEBUG)
2305
2054
# Enable all possible GnuTLS debugging
2306
2055
2307
2056
# "Use a log level over 10 to enable all debugging options."
2316
2065
.gnutls_global_set_log_function(debug_gnutls))
2317
2066
2318
2067
# Redirect stdin so all checkers get /dev/null
2319
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2068
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2320
2069
os.dup2(null, sys.stdin.fileno())
2321
2070
if null > 2:
2322
2071
os.close(null)
2072
else:
2073
# No console logging
2074
logger.removeHandler(console)
2323
2075
2324
2076
# Need to fork before connecting to D-Bus
2325
2077
if not debug:
2326
2078
# Close all input and output, do double fork, etc.
2327
2079
daemon()
2328
2080
2329
gobject.threads_init()
2330
2331
2081
global main_loop
2332
2082
# From the Avahi example code
2333
DBusGMainLoop(set_as_default=True)
2083
DBusGMainLoop(set_as_default=True )
2334
2084
main_loop = gobject.MainLoop()
2335
2085
bus = dbus.SystemBus()
2336
2086
# End of Avahi example code
2342
2092
("se.bsnet.fukt.Mandos", bus,
2343
2093
do_not_queue=True))
2344
2094
except dbus.exceptions.NameExistsException as e:
2345
logger.error("Disabling D-Bus:", exc_info=e)
2095
logger.error(unicode(e) + ", disabling D-Bus")
2346
2096
use_dbus = False
2347
2097
server_settings["use_dbus"] = False
2348
2098
tcp_server.use_dbus = False
2360
2110
2361
2111
client_class = Client
2362
2112
if use_dbus:
2363
client_class = functools.partial(ClientDBus, bus = bus)
2364
2365
client_settings = Client.config_parser(client_config)
2113
client_class = functools.partial(ClientDBusTransitional,
2114
bus = bus)
2115
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
2366
2133
old_client_settings = {}
2367
clients_data = {}
2368
2369
# Get client data and settings from last running state.
2134
clients_data = []
2135
2136
# Get client data and settings from last running state.
2370
2137
if server_settings["restore"]:
2371
2138
try:
2372
2139
with open(stored_state_path, "rb") as stored_state:
2373
clients_data, old_client_settings = (pickle.load
2374
(stored_state))
2140
clients_data, old_client_settings = pickle.load(stored_state)
2375
2141
os.remove(stored_state_path)
2376
2142
except IOError as e:
2377
if e.errno == errno.ENOENT:
2378
logger.warning("Could not load persistent state: {0}"
2379
.format(os.strerror(e.errno)))
2380
else:
2381
logger.critical("Could not load persistent state:",
2382
exc_info=e)
2143
logger.warning("Could not load persistant state: {0}".format(e))
2144
if e.errno != errno.ENOENT:
2383
2145
raise
2384
except EOFError as e:
2385
logger.warning("Could not load persistent state: "
2386
"EOFError:", exc_info=e)
2387
2388
with PGPEngine() as pgp:
2389
for client_name, client in clients_data.iteritems():
2390
# Decide which value to use after restoring saved state.
2391
# We have three different values: Old config file,
2392
# new config file, and saved state.
2393
# New config value takes precedence if it differs from old
2394
# config value, otherwise use saved state.
2395
for name, value in client_settings[client_name].items():
2396
try:
2397
# For each value in new config, check if it
2398
# differs from the old config value (Except for
2399
# the "secret" attribute)
2400
if (name != "secret" and
2401
value != old_client_settings[client_name]
2402
[name]):
2403
client[name] = value
2404
except KeyError:
2405
pass
2406
2407
# Clients who has passed its expire date can still be
2408
# enabled if its last checker was successful. Clients
2409
# whose checker succeeded before we stored its state is
2410
# assumed to have successfully run all checkers during
2411
# downtime.
2412
if client["enabled"]:
2413
if datetime.datetime.utcnow() >= client["expires"]:
2414
if not client["last_checked_ok"]:
2415
logger.warning(
2416
"disabling client {0} - Client never "
2417
"performed a successful checker"
2418
.format(client_name))
2419
client["enabled"] = False
2420
elif client["last_checker_status"] != 0:
2421
logger.warning(
2422
"disabling client {0} - Client "
2423
"last checker failed with error code {1}"
2424
.format(client_name,
2425
client["last_checker_status"]))
2426
client["enabled"] = False
2427
else:
2428
client["expires"] = (datetime.datetime
2429
.utcnow()
2430
+ client["timeout"])
2431
logger.debug("Last checker succeeded,"
2432
" keeping {0} enabled"
2433
.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():
2434
2156
try:
2435
client["secret"] = (
2436
pgp.decrypt(client["encrypted_secret"],
2437
client_settings[client_name]
2438
["secret"]))
2439
except PGPError:
2440
# If decryption fails, we use secret from new settings
2441
logger.debug("Failed to decrypt {0} old secret"
2442
.format(client_name))
2443
client["secret"] = (
2444
client_settings[client_name]["secret"])
2445
2446
# Add/remove clients based on new changes made to config
2447
for client_name in (set(old_client_settings)
2448
- set(client_settings)):
2449
del clients_data[client_name]
2450
for client_name in (set(client_settings)
2451
- set(old_client_settings)):
2452
clients_data[client_name] = client_settings[client_name]
2453
2454
# Create all client objects
2455
for client_name, client in clients_data.iteritems():
2456
tcp_server.clients[client_name] = client_class(
2457
name = client_name, settings = client)
2458
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
2459
2211
if not tcp_server.clients:
2460
2212
logger.warning("No clients defined")
2461
2213
2462
2214
if not debug:
2463
2215
try:
2464
2216
with pidfile:
2472
2224
# "pidfile" was never created
2473
2225
pass
2474
2226
del pidfilename
2227
2475
2228
signal.signal(signal.SIGINT, signal.SIG_IGN)
2476
2229
2477
2230
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2478
2231
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2479
2232
2480
2233
if use_dbus:
2481
@alternate_dbus_interfaces({"se.recompile.Mandos":
2482
"se.bsnet.fukt.Mandos"})
2483
class MandosDBusService(DBusObjectWithProperties):
2234
class MandosDBusService(dbus.service.Object):
2484
2235
"""A D-Bus proxy object"""
2485
2236
def __init__(self):
2486
2237
dbus.service.Object.__init__(self, bus, "/")
2487
2238
_interface = "se.recompile.Mandos"
2488
2239
2489
@dbus_interface_annotations(_interface)
2490
def _foo(self):
2491
return { "org.freedesktop.DBus.Property"
2492
".EmitsChangedSignal":
2493
"false"}
2494
2495
2240
@dbus.service.signal(_interface, signature="o")
2496
2241
def ClientAdded(self, objpath):
2497
2242
"D-Bus signal"
2539
2284
2540
2285
del _interface
2541
2286
2542
mandos_dbus_service = MandosDBusService()
2287
class MandosDBusServiceTransitional(MandosDBusService):
2288
__metaclass__ = AlternateDBusNamesMetaclass
2289
mandos_dbus_service = MandosDBusServiceTransitional()
2543
2290
2544
2291
def cleanup():
2545
2292
"Cleanup function; run on exit"
2548
2295
multiprocessing.active_children()
2549
2296
if not (tcp_server.clients or client_settings):
2550
2297
return
2551
2552
# Store client before exiting. Secrets are encrypted with key
2553
# based on what config file has. If config file is
2554
# removed/edited, old secret will thus be unrecovable.
2555
clients = {}
2556
with PGPEngine() as pgp:
2557
for client in tcp_server.clients.itervalues():
2558
key = client_settings[client.name]["secret"]
2559
client.encrypted_secret = pgp.encrypt(client.secret,
2560
key)
2561
client_dict = {}
2562
2563
# A list of attributes that can not be pickled
2564
# + secret.
2565
exclude = set(("bus", "changedstate", "secret",
2566
"checker"))
2567
for name, typ in (inspect.getmembers
2568
(dbus.service.Object)):
2569
exclude.add(name)
2570
2571
client_dict["encrypted_secret"] = (client
2572
.encrypted_secret)
2573
for attr in client.client_structure:
2574
if attr not in exclude:
2575
client_dict[attr] = getattr(client, attr)
2576
2577
clients[client.name] = client_dict
2578
del client_settings[client.name]["secret"]
2579
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
2580
2321
try:
2581
tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2582
prefix="clients-",
2583
dir=os.path.dirname
2584
(stored_state_path))
2585
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:
2586
2323
pickle.dump((clients, client_settings), stored_state)
2587
os.rename(tempname, stored_state_path)
2588
except (IOError, OSError) as e:
2589
if not debug:
2590
try:
2591
os.remove(tempname)
2592
except NameError:
2593
pass
2594
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2595
logger.warning("Could not save persistent state: {0}"
2596
.format(os.strerror(e.errno)))
2597
else:
2598
logger.warning("Could not save persistent state:",
2599
exc_info=e)
2600
raise e
2601
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
2602
2329
# Delete all clients, and settings from config
2603
2330
while tcp_server.clients:
2604
2331
name, client = tcp_server.clients.popitem()
2622
2349
# Need to initiate checking of clients
2623
2350
if client.enabled:
2624
2351
client.init_checker()
2352
2625
2353
2626
2354
tcp_server.enable()
2627
2355
tcp_server.server_activate()
2630
2358
service.port = tcp_server.socket.getsockname()[1]
2631
2359
if use_ipv6:
2632
2360
logger.info("Now listening on address %r, port %d,"
2633
" flowinfo %d, scope_id %d",
2634
*tcp_server.socket.getsockname())
2361
" flowinfo %d, scope_id %d"
2362
% tcp_server.socket.getsockname())
2635
2363
else: # IPv4
2636
logger.info("Now listening on address %r, port %d",
2637
*tcp_server.socket.getsockname())
2364
logger.info("Now listening on address %r, port %d"
2365
% tcp_server.socket.getsockname())
2638
2366
2639
2367
#service.interface = tcp_server.socket.getsockname()[3]
2640
2368
2643
2371
try:
2644
2372
service.activate()
2645
2373
except dbus.exceptions.DBusException as error:
2646
logger.critical("D-Bus Exception", exc_info=error)
2374
logger.critical("DBusException: %s", error)
2647
2375
cleanup()
2648
2376
sys.exit(1)
2649
2377
# End of Avahi example code
2656
2384
logger.debug("Starting main loop")
2657
2385
main_loop.run()
2658
2386
except AvahiError as error:
2659
logger.critical("Avahi Error", exc_info=error)
2387
logger.critical("AvahiError: %s", error)
2660
2388
cleanup()
2661
2389
sys.exit(1)
2662
2390
except KeyboardInterrupt:
2667
2395
# Must run before the D-Bus bus name gets deregistered
2668
2396
cleanup()
2669
2397
2398
2670
2399
if __name__ == '__main__':
2671
2400
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0