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