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