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