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 742
- compare with another revision
- download diff
- download tarball
- view history from revision 742
- Committer: Teddy Hogeborn
- Date: 2015-03-10 18:03:38 UTC
- Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.
If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default. The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.
There is a "PFS" priority string specifier, but we can't use it because:
1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
enables a lot more algorithms than "SECURE256".
2. It is only available since GnuTLS 3.2.4.
Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.
If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default. The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.
There is a "PFS" priority string specifier, but we can't use it because:
1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
enables a lot more algorithms than "SECURE256".
2. It is only available since GnuTLS 3.2.4.
Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.
- files added:
- debian/mandos-client.examples
- debian/upstream
- 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
version = "1.4.1"
91
if sys.version_info.major == 2:
92
str = unicode
93
94
version = "1.6.9"
89
95
stored_state_file = "clients.pickle"
90
96
91
97
logger = logging.getLogger()
92
syslogger = (logging.handlers.SysLogHandler
93
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
address = str("/dev/log")))
98
syslogger = None
95
99
96
100
try:
97
101
if_nametoindex = (ctypes.cdll.LoadLibrary
103
107
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
104
108
with contextlib.closing(socket.socket()) as s:
105
109
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
106
struct.pack(str("16s16x"),
107
interface))
108
interface_index = struct.unpack(str("I"),
109
ifreq[16:20])[0]
110
struct.pack(b"16s16x", interface))
111
interface_index = struct.unpack("I", ifreq[16:20])[0]
110
112
return interface_index
111
113
112
114
113
def initlogger(level=logging.WARNING):
115
def initlogger(debug, level=logging.WARNING):
114
116
"""init logger and add loglevel"""
115
117
118
global syslogger
119
syslogger = (logging.handlers.SysLogHandler
120
(facility =
121
logging.handlers.SysLogHandler.LOG_DAEMON,
122
address = "/dev/log"))
116
123
syslogger.setFormatter(logging.Formatter
117
124
('Mandos [%(process)d]: %(levelname)s:'
118
125
' %(message)s'))
119
126
logger.addHandler(syslogger)
120
127
121
console = logging.StreamHandler()
122
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
123
' [%(process)d]:'
124
' %(levelname)s:'
125
' %(message)s'))
126
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)
127
135
logger.setLevel(level)
128
136
129
137
135
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 PGPError(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 PGPError(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
262
def rename(self):
277
278
def rename(self, remove=True):
263
279
"""Derived from the Avahi example code"""
264
280
if self.rename_count >= self.max_renames:
265
281
logger.critical("No suitable Zeroconf service name found"
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))
287
self.rename_count += 1
271
288
logger.info("Changing Zeroconf service name to %r ...",
272
289
self.name)
273
self.remove()
290
if remove:
291
self.remove()
274
292
try:
275
293
self.add()
276
294
except dbus.exceptions.DBusException as error:
277
logger.critical("DBusException: %s", error)
278
self.cleanup()
279
os._exit(1)
280
self.rename_count += 1
295
if (error.get_dbus_name()
296
== "org.freedesktop.Avahi.CollisionError"):
297
logger.info("Local Zeroconf service name collision.")
298
return self.rename(remove=False)
299
else:
300
logger.critical("D-Bus Exception", exc_info=error)
301
self.cleanup()
302
os._exit(1)
303
281
304
def remove(self):
282
305
"""Derived from the Avahi example code"""
283
306
if self.entry_group_state_changed_match is not None:
285
308
self.entry_group_state_changed_match = None
286
309
if self.group is not None:
287
310
self.group.Reset()
311
288
312
def add(self):
289
313
"""Derived from the Avahi example code"""
290
314
self.remove()
307
331
dbus.UInt16(self.port),
308
332
avahi.string_array_to_txt_array(self.TXT))
309
333
self.group.Commit()
334
310
335
def entry_group_state_changed(self, state, error):
311
336
"""Derived from the Avahi example code"""
312
337
logger.debug("Avahi entry group state change: %i", state)
318
343
self.rename()
319
344
elif state == avahi.ENTRY_GROUP_FAILURE:
320
345
logger.critical("Avahi: Error in group state changed %s",
321
unicode(error))
322
raise AvahiGroupError("State changed: %s"
323
% unicode(error))
346
str(error))
347
raise AvahiGroupError("State changed: {!s}"
348
.format(error))
349
324
350
def cleanup(self):
325
351
"""Derived from the Avahi example code"""
326
352
if self.group is not None:
331
357
pass
332
358
self.group = None
333
359
self.remove()
360
334
361
def server_state_changed(self, state, error=None):
335
362
"""Derived from the Avahi example code"""
336
363
logger.debug("Avahi server state change: %i", state)
355
382
logger.debug("Unknown state: %r", state)
356
383
else:
357
384
logger.debug("Unknown state: %r: %r", state, error)
385
358
386
def activate(self):
359
387
"""Derived from the Avahi example code"""
360
388
if self.server is None:
367
395
self.server_state_changed)
368
396
self.server_state_changed(self.server.GetState())
369
397
398
370
399
class AvahiServiceToSyslog(AvahiService):
371
def rename(self):
400
def rename(self, *args, **kwargs):
372
401
"""Add the new name to the syslog messages"""
373
ret = AvahiService.rename(self)
402
ret = AvahiService.rename(self, *args, **kwargs)
374
403
syslogger.setFormatter(logging.Formatter
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
377
% self.name))
404
('Mandos ({}) [%(process)d]:'
405
' %(levelname)s: %(message)s'
406
.format(self.name)))
378
407
return ret
379
408
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
409
386
410
class Client(object):
387
411
"""A representation of a client host served by this server.
388
412
413
437
last_checked_ok: datetime.datetime(); (UTC) or None
414
438
last_checker_status: integer between 0 and 255 reflecting exit
415
439
status of last checker. -1 reflects crashed
416
checker, or None.
440
checker, -2 means no checker completed yet.
417
441
last_enabled: datetime.datetime(); (UTC) or None
418
442
name: string; from the config file, used in log messages and
419
443
D-Bus identifiers
420
444
secret: bytestring; sent verbatim (over TLS) to client
421
445
timeout: datetime.timedelta(); How long from last_checked_ok
422
446
until this client is disabled
423
extended_timeout: extra long timeout when password has been sent
447
extended_timeout: extra long timeout when secret has been sent
424
448
runtime_expansions: Allowed attributes for runtime expansion.
425
449
expires: datetime.datetime(); time (UTC) when a client will be
426
450
disabled, or None
451
server_settings: The server_settings dict from main()
427
452
"""
428
453
429
454
runtime_expansions = ("approval_delay", "approval_duration",
430
"created", "enabled", "fingerprint",
431
"host", "interval", "last_checked_ok",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
432
458
"last_enabled", "name", "timeout")
433
client_defaults = { "timeout": "5m",
434
"extended_timeout": "15m",
435
"interval": "2m",
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
461
"interval": "PT2M",
436
462
"checker": "fping -q -- %%(host)s",
437
463
"host": "",
438
"approval_delay": "0s",
439
"approval_duration": "1s",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
440
466
"approved_by_default": "True",
441
467
"enabled": "True",
442
468
}
443
469
444
def timeout_milliseconds(self):
445
"Return the 'timeout' attribute in milliseconds"
446
return timedelta_to_milliseconds(self.timeout)
447
448
def extended_timeout_milliseconds(self):
449
"Return the 'extended_timeout' attribute in milliseconds"
450
return timedelta_to_milliseconds(self.extended_timeout)
451
452
def interval_milliseconds(self):
453
"Return the 'interval' attribute in milliseconds"
454
return timedelta_to_milliseconds(self.interval)
455
456
def approval_delay_milliseconds(self):
457
return timedelta_to_milliseconds(self.approval_delay)
458
459
470
@staticmethod
460
471
def config_parser(config):
461
""" Construct a new dict of client settings of this form:
472
"""Construct a new dict of client settings of this form:
462
473
{ client_name: {setting_name: value, ...}, ...}
463
with exceptions for any special settings as defined above"""
474
with exceptions for any special settings as defined above.
475
NOTE: Must be a pure function. Must return the same result
476
value given the same arguments.
477
"""
464
478
settings = {}
465
479
for client_name in config.sections():
466
480
section = dict(config.items(client_name))
470
484
# Reformat values from string types to Python types
471
485
client["approved_by_default"] = config.getboolean(
472
486
client_name, "approved_by_default")
473
client["enabled"] = config.getboolean(client_name, "enabled")
487
client["enabled"] = config.getboolean(client_name,
488
"enabled")
474
489
490
# Uppercase and remove spaces from fingerprint for later
491
# comparison purposes with return value from the
492
# fingerprint() function
475
493
client["fingerprint"] = (section["fingerprint"].upper()
476
494
.replace(" ", ""))
477
495
if "secret" in section:
482
500
"rb") as secfile:
483
501
client["secret"] = secfile.read()
484
502
else:
485
raise TypeError("No secret or secfile for section %s"
486
% section)
503
raise TypeError("No secret or secfile for section {}"
504
.format(section))
487
505
client["timeout"] = string_to_delta(section["timeout"])
488
506
client["extended_timeout"] = string_to_delta(
489
507
section["extended_timeout"])
495
513
client["checker_command"] = section["checker"]
496
514
client["last_approval_request"] = None
497
515
client["last_checked_ok"] = None
498
client["last_checker_status"] = None
499
if client["enabled"]:
500
client["last_enabled"] = datetime.datetime.utcnow()
501
client["expires"] = (datetime.datetime.utcnow()
502
+ client["timeout"])
503
else:
504
client["last_enabled"] = None
505
client["expires"] = None
506
516
client["last_checker_status"] = -2
517
507
518
return settings
508
509
510
def __init__(self, settings, name = None):
511
"""Note: the 'checker' key in 'config' sets the
512
'checker_command' attribute and *not* the 'checker'
513
attribute."""
519
520
def __init__(self, settings, name = None, server_settings=None):
514
521
self.name = name
522
if server_settings is None:
523
server_settings = {}
524
self.server_settings = server_settings
515
525
# adding all client settings
516
for setting, value in settings.iteritems():
526
for setting, value in settings.items():
517
527
setattr(self, setting, value)
518
528
529
if self.enabled:
530
if not hasattr(self, "last_enabled"):
531
self.last_enabled = datetime.datetime.utcnow()
532
if not hasattr(self, "expires"):
533
self.expires = (datetime.datetime.utcnow()
534
+ self.timeout)
535
else:
536
self.last_enabled = None
537
self.expires = None
538
519
539
logger.debug("Creating client %r", self.name)
520
# Uppercase and remove spaces from fingerprint for later
521
# comparison purposes with return value from the fingerprint()
522
# function
523
540
logger.debug(" Fingerprint: %s", self.fingerprint)
524
self.created = settings.get("created", datetime.datetime.utcnow())
525
541
self.created = settings.get("created",
542
datetime.datetime.utcnow())
543
526
544
# attributes specific for this server instance
527
545
self.checker = None
528
546
self.checker_initiator_tag = None
556
574
if getattr(self, "enabled", False):
557
575
# Already enabled
558
576
return
559
self.send_changedstate()
560
577
self.expires = datetime.datetime.utcnow() + self.timeout
561
578
self.enabled = True
562
579
self.last_enabled = datetime.datetime.utcnow()
563
580
self.init_checker()
581
self.send_changedstate()
564
582
565
583
def disable(self, quiet=True):
566
584
"""Disable this client."""
567
585
if not getattr(self, "enabled", False):
568
586
return False
569
587
if not quiet:
570
self.send_changedstate()
571
if not quiet:
572
588
logger.info("Disabling client %s", self.name)
573
if getattr(self, "disable_initiator_tag", False):
589
if getattr(self, "disable_initiator_tag", None) is not None:
574
590
gobject.source_remove(self.disable_initiator_tag)
575
591
self.disable_initiator_tag = None
576
592
self.expires = None
577
if getattr(self, "checker_initiator_tag", False):
593
if getattr(self, "checker_initiator_tag", None) is not None:
578
594
gobject.source_remove(self.checker_initiator_tag)
579
595
self.checker_initiator_tag = None
580
596
self.stop_checker()
581
597
self.enabled = False
598
if not quiet:
599
self.send_changedstate()
582
600
# Do not run this again if called by a gobject.timeout_add
583
601
return False
584
602
588
606
def init_checker(self):
589
607
# Schedule a new checker to be started an 'interval' from now,
590
608
# and every interval from then on.
609
if self.checker_initiator_tag is not None:
610
gobject.source_remove(self.checker_initiator_tag)
591
611
self.checker_initiator_tag = (gobject.timeout_add
592
(self.interval_milliseconds(),
612
(int(self.interval
613
.total_seconds() * 1000),
593
614
self.start_checker))
594
615
# Schedule a disable() when 'timeout' has passed
616
if self.disable_initiator_tag is not None:
617
gobject.source_remove(self.disable_initiator_tag)
595
618
self.disable_initiator_tag = (gobject.timeout_add
596
(self.timeout_milliseconds(),
597
self.disable))
619
(int(self.timeout
620
.total_seconds() * 1000),
621
self.disable))
598
622
# Also start a new checker *right now*.
599
623
self.start_checker()
600
624
616
640
logger.warning("Checker for %(name)s crashed?",
617
641
vars(self))
618
642
619
def checked_ok(self, timeout=None):
620
"""Bump up the timeout for this client.
621
622
This should only be called when the client has been seen,
623
alive and well.
624
"""
643
def checked_ok(self):
644
"""Assert that the client has been seen, alive and well."""
645
self.last_checked_ok = datetime.datetime.utcnow()
646
self.last_checker_status = 0
647
self.bump_timeout()
648
649
def bump_timeout(self, timeout=None):
650
"""Bump up the timeout for this client."""
625
651
if timeout is None:
626
652
timeout = self.timeout
627
self.last_checked_ok = datetime.datetime.utcnow()
628
653
if self.disable_initiator_tag is not None:
629
654
gobject.source_remove(self.disable_initiator_tag)
655
self.disable_initiator_tag = None
630
656
if getattr(self, "enabled", False):
631
657
self.disable_initiator_tag = (gobject.timeout_add
632
(timedelta_to_milliseconds
633
(timeout), self.disable))
658
(int(timeout.total_seconds()
659
* 1000), self.disable))
634
660
self.expires = datetime.datetime.utcnow() + timeout
635
661
636
662
def need_approval(self):
642
668
If a checker already exists, leave it running and do
643
669
nothing."""
644
670
# The reason for not killing a running checker is that if we
645
# did that, then if a checker (for some reason) started
646
# running slowly and taking more than 'interval' time, the
647
# client would inevitably timeout, since no checker would get
648
# a chance to run to completion. If we instead leave running
671
# did that, and if a checker (for some reason) started running
672
# slowly and taking more than 'interval' time, then the client
673
# would inevitably timeout, since no checker would get a
674
# chance to run to completion. If we instead leave running
649
675
# checkers alone, the checker would have to take more time
650
676
# than 'timeout' for the client to be disabled, which is as it
651
677
# should be.
653
679
# If a checker exists, make sure it is not a zombie
654
680
try:
655
681
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
656
except (AttributeError, OSError) as error:
657
if (isinstance(error, OSError)
658
and error.errno != errno.ECHILD):
659
raise error
682
except AttributeError:
683
pass
684
except OSError as error:
685
if error.errno != errno.ECHILD:
686
raise
660
687
else:
661
688
if pid:
662
689
logger.warning("Checker was a zombie")
665
692
self.current_checker_command)
666
693
# Start a new checker if needed
667
694
if self.checker is None:
695
# Escape attributes for the shell
696
escaped_attrs = { attr:
697
re.escape(str(getattr(self, attr)))
698
for attr in self.runtime_expansions }
668
699
try:
669
# In case checker_command has exactly one % operator
670
command = self.checker_command % self.host
671
except TypeError:
672
# Escape attributes for the shell
673
escaped_attrs = dict(
674
(attr,
675
re.escape(unicode(str(getattr(self, attr, "")),
676
errors=
677
'replace')))
678
for attr in
679
self.runtime_expansions)
680
681
try:
682
command = self.checker_command % escaped_attrs
683
except TypeError as error:
684
logger.error('Could not format string "%s":'
685
' %s', self.checker_command, error)
686
return True # Try again later
700
command = self.checker_command % escaped_attrs
701
except TypeError as error:
702
logger.error('Could not format string "%s"',
703
self.checker_command, exc_info=error)
704
return True # Try again later
687
705
self.current_checker_command = command
688
706
try:
689
707
logger.info("Starting checker %r for %s",
692
710
# in normal mode, that is already done by daemon(),
693
711
# and in debug mode we don't want to. (Stdin is
694
712
# always replaced by /dev/null.)
713
# The exception is when not debugging but nevertheless
714
# running in the foreground; use the previously
715
# created wnull.
716
popen_args = {}
717
if (not self.server_settings["debug"]
718
and self.server_settings["foreground"]):
719
popen_args.update({"stdout": wnull,
720
"stderr": wnull })
695
721
self.checker = subprocess.Popen(command,
696
722
close_fds=True,
697
shell=True, cwd="/")
698
self.checker_callback_tag = (gobject.child_watch_add
699
(self.checker.pid,
700
self.checker_callback,
701
data=command))
702
# The checker may have completed before the gobject
703
# watch was added. Check for this.
723
shell=True, cwd="/",
724
**popen_args)
725
except OSError as error:
726
logger.error("Failed to start subprocess",
727
exc_info=error)
728
return True
729
self.checker_callback_tag = (gobject.child_watch_add
730
(self.checker.pid,
731
self.checker_callback,
732
data=command))
733
# The checker may have completed before the gobject
734
# watch was added. Check for this.
735
try:
704
736
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
705
if pid:
706
gobject.source_remove(self.checker_callback_tag)
707
self.checker_callback(pid, status, command)
708
737
except OSError as error:
709
logger.error("Failed to start subprocess: %s",
710
error)
738
if error.errno == errno.ECHILD:
739
# This should never happen
740
logger.error("Child process vanished",
741
exc_info=error)
742
return True
743
raise
744
if pid:
745
gobject.source_remove(self.checker_callback_tag)
746
self.checker_callback(pid, status, command)
711
747
# Re-run this periodically if run by gobject.timeout_add
712
748
return True
713
749
720
756
return
721
757
logger.debug("Stopping checker for %(name)s", vars(self))
722
758
try:
723
os.kill(self.checker.pid, signal.SIGTERM)
759
self.checker.terminate()
724
760
#time.sleep(0.5)
725
761
#if self.checker.poll() is None:
726
# os.kill(self.checker.pid, signal.SIGKILL)
762
# self.checker.kill()
727
763
except OSError as error:
728
764
if error.errno != errno.ESRCH: # No such process
729
765
raise
746
782
# "Set" method, so we fail early here:
747
783
if byte_arrays and signature != "ay":
748
784
raise ValueError("Byte arrays not supported for non-'ay'"
749
" signature %r" % signature)
785
" signature {!r}".format(signature))
750
786
def decorator(func):
751
787
func._dbus_is_property = True
752
788
func._dbus_interface = dbus_interface
760
796
return decorator
761
797
762
798
799
def dbus_interface_annotations(dbus_interface):
800
"""Decorator for marking functions returning interface annotations
801
802
Usage:
803
804
@dbus_interface_annotations("org.example.Interface")
805
def _foo(self): # Function name does not matter
806
return {"org.freedesktop.DBus.Deprecated": "true",
807
"org.freedesktop.DBus.Property.EmitsChangedSignal":
808
"false"}
809
"""
810
def decorator(func):
811
func._dbus_is_interface = True
812
func._dbus_interface = dbus_interface
813
func._dbus_name = dbus_interface
814
return func
815
return decorator
816
817
818
def dbus_annotations(annotations):
819
"""Decorator to annotate D-Bus methods, signals or properties
820
Usage:
821
822
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
823
"org.freedesktop.DBus.Property."
824
"EmitsChangedSignal": "false"})
825
@dbus_service_property("org.example.Interface", signature="b",
826
access="r")
827
def Property_dbus_property(self):
828
return dbus.Boolean(False)
829
"""
830
def decorator(func):
831
func._dbus_annotations = annotations
832
return func
833
return decorator
834
835
763
836
class DBusPropertyException(dbus.exceptions.DBusException):
764
837
"""A base class for D-Bus property-related exceptions
765
838
"""
766
def __unicode__(self):
767
return unicode(str(self))
768
839
pass
769
840
770
841
class DBusPropertyAccessException(DBusPropertyException):
771
842
"""A property's access permissions disallows an operation.
788
859
"""
789
860
790
861
@staticmethod
791
def _is_dbus_property(obj):
792
return getattr(obj, "_dbus_is_property", False)
862
def _is_dbus_thing(thing):
863
"""Returns a function testing if an attribute is a D-Bus thing
864
865
If called like _is_dbus_thing("method") it returns a function
866
suitable for use as predicate to inspect.getmembers().
867
"""
868
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
869
False)
793
870
794
def _get_all_dbus_properties(self):
871
def _get_all_dbus_things(self, thing):
795
872
"""Returns a generator of (name, attribute) pairs
796
873
"""
797
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
874
return ((getattr(athing.__get__(self), "_dbus_name",
875
name),
876
athing.__get__(self))
798
877
for cls in self.__class__.__mro__
799
for name, prop in
800
inspect.getmembers(cls, self._is_dbus_property))
878
for name, athing in
879
inspect.getmembers(cls,
880
self._is_dbus_thing(thing)))
801
881
802
882
def _get_dbus_property(self, interface_name, property_name):
803
883
"""Returns a bound method if one exists which is a D-Bus
805
885
"""
806
886
for cls in self.__class__.__mro__:
807
887
for name, value in (inspect.getmembers
808
(cls, self._is_dbus_property)):
888
(cls,
889
self._is_dbus_thing("property"))):
809
890
if (value._dbus_name == property_name
810
891
and value._dbus_interface == interface_name):
811
892
return value.__get__(self)
839
920
# The byte_arrays option is not supported yet on
840
921
# signatures other than "ay".
841
922
if prop._dbus_signature != "ay":
842
raise ValueError
843
value = dbus.ByteArray(''.join(unichr(byte)
844
for byte in value))
923
raise ValueError("Byte arrays not supported for non-"
924
"'ay' signature {!r}"
925
.format(prop._dbus_signature))
926
value = dbus.ByteArray(b''.join(chr(byte)
927
for byte in value))
845
928
prop(value)
846
929
847
930
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
853
936
Note: Will not include properties with access="write".
854
937
"""
855
938
properties = {}
856
for name, prop in self._get_all_dbus_properties():
939
for name, prop in self._get_all_dbus_things("property"):
857
940
if (interface_name
858
941
and interface_name != prop._dbus_interface):
859
942
# Interface non-empty but did not match
869
952
value.variant_level+1)
870
953
return dbus.Dictionary(properties, signature="sv")
871
954
955
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
956
def PropertiesChanged(self, interface_name, changed_properties,
957
invalidated_properties):
958
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
959
standard.
960
"""
961
pass
962
872
963
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
873
964
out_signature="s",
874
965
path_keyword='object_path',
875
966
connection_keyword='connection')
876
967
def Introspect(self, object_path, connection):
877
"""Standard D-Bus method, overloaded to insert property tags.
968
"""Overloading of standard D-Bus method.
969
970
Inserts property tags and interface annotation tags.
878
971
"""
879
972
xmlstring = dbus.service.Object.Introspect(self, object_path,
880
973
connection)
887
980
e.setAttribute("access", prop._dbus_access)
888
981
return e
889
982
for if_tag in document.getElementsByTagName("interface"):
983
# Add property tags
890
984
for tag in (make_tag(document, name, prop)
891
985
for name, prop
892
in self._get_all_dbus_properties()
986
in self._get_all_dbus_things("property")
893
987
if prop._dbus_interface
894
988
== if_tag.getAttribute("name")):
895
989
if_tag.appendChild(tag)
990
# Add annotation tags
991
for typ in ("method", "signal", "property"):
992
for tag in if_tag.getElementsByTagName(typ):
993
annots = dict()
994
for name, prop in (self.
995
_get_all_dbus_things(typ)):
996
if (name == tag.getAttribute("name")
997
and prop._dbus_interface
998
== if_tag.getAttribute("name")):
999
annots.update(getattr
1000
(prop,
1001
"_dbus_annotations",
1002
{}))
1003
for name, value in annots.items():
1004
ann_tag = document.createElement(
1005
"annotation")
1006
ann_tag.setAttribute("name", name)
1007
ann_tag.setAttribute("value", value)
1008
tag.appendChild(ann_tag)
1009
# Add interface annotation tags
1010
for annotation, value in dict(
1011
itertools.chain.from_iterable(
1012
annotations().items()
1013
for name, annotations in
1014
self._get_all_dbus_things("interface")
1015
if name == if_tag.getAttribute("name")
1016
)).items():
1017
ann_tag = document.createElement("annotation")
1018
ann_tag.setAttribute("name", annotation)
1019
ann_tag.setAttribute("value", value)
1020
if_tag.appendChild(ann_tag)
896
1021
# Add the names to the return values for the
897
1022
# "org.freedesktop.DBus.Properties" methods
898
1023
if (if_tag.getAttribute("name")
913
1038
except (AttributeError, xml.dom.DOMException,
914
1039
xml.parsers.expat.ExpatError) as error:
915
1040
logger.error("Failed to override Introspection method",
916
error)
1041
exc_info=error)
917
1042
return xmlstring
918
1043
919
1044
920
def datetime_to_dbus (dt, variant_level=0):
1045
def datetime_to_dbus(dt, variant_level=0):
921
1046
"""Convert a UTC datetime.datetime() to a D-Bus type."""
922
1047
if dt is None:
923
1048
return dbus.String("", variant_level = variant_level)
925
1050
variant_level=variant_level)
926
1051
927
1052
928
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
929
.__metaclass__):
930
"""Applied to an empty subclass of a D-Bus object, this metaclass
931
will add additional D-Bus attributes matching a certain pattern.
1053
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1054
"""A class decorator; applied to a subclass of
1055
dbus.service.Object, it will add alternate D-Bus attributes with
1056
interface names according to the "alt_interface_names" mapping.
1057
Usage:
1058
1059
@alternate_dbus_interfaces({"org.example.Interface":
1060
"net.example.AlternateInterface"})
1061
class SampleDBusObject(dbus.service.Object):
1062
@dbus.service.method("org.example.Interface")
1063
def SampleDBusMethod():
1064
pass
1065
1066
The above "SampleDBusMethod" on "SampleDBusObject" will be
1067
reachable via two interfaces: "org.example.Interface" and
1068
"net.example.AlternateInterface", the latter of which will have
1069
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1070
"true", unless "deprecate" is passed with a False value.
1071
1072
This works for methods and signals, and also for D-Bus properties
1073
(from DBusObjectWithProperties) and interfaces (from the
1074
dbus_interface_annotations decorator).
932
1075
"""
933
def __new__(mcs, name, bases, attr):
934
# Go through all the base classes which could have D-Bus
935
# methods, signals, or properties in them
936
for base in (b for b in bases
937
if issubclass(b, dbus.service.Object)):
938
# Go though all attributes of the base class
939
for attrname, attribute in inspect.getmembers(base):
1076
def wrapper(cls):
1077
for orig_interface_name, alt_interface_name in (
1078
alt_interface_names.items()):
1079
attr = {}
1080
interface_names = set()
1081
# Go though all attributes of the class
1082
for attrname, attribute in inspect.getmembers(cls):
940
1083
# Ignore non-D-Bus attributes, and D-Bus attributes
941
1084
# with the wrong interface name
942
1085
if (not hasattr(attribute, "_dbus_interface")
943
1086
or not attribute._dbus_interface
944
.startswith("se.recompile.Mandos")):
1087
.startswith(orig_interface_name)):
945
1088
continue
946
1089
# Create an alternate D-Bus interface name based on
947
1090
# the current name
948
1091
alt_interface = (attribute._dbus_interface
949
.replace("se.recompile.Mandos",
950
"se.bsnet.fukt.Mandos"))
1092
.replace(orig_interface_name,
1093
alt_interface_name))
1094
interface_names.add(alt_interface)
951
1095
# Is this a D-Bus signal?
952
1096
if getattr(attribute, "_dbus_is_signal", False):
953
# Extract the original non-method function by
954
# black magic
1097
# Extract the original non-method undecorated
1098
# function by black magic
955
1099
nonmethod_func = (dict(
956
1100
zip(attribute.func_code.co_freevars,
957
1101
attribute.__closure__))["func"]
968
1112
nonmethod_func.func_name,
969
1113
nonmethod_func.func_defaults,
970
1114
nonmethod_func.func_closure)))
1115
# Copy annotations, if any
1116
try:
1117
new_function._dbus_annotations = (
1118
dict(attribute._dbus_annotations))
1119
except AttributeError:
1120
pass
971
1121
# Define a creator of a function to call both the
972
# old and new functions, so both the old and new
973
# signals gets sent when the function is called
1122
# original and alternate functions, so both the
1123
# original and alternate signals gets sent when
1124
# the function is called
974
1125
def fixscope(func1, func2):
975
1126
"""This function is a scope container to pass
976
1127
func1 and func2 to the "call_both" function
983
1134
return call_both
984
1135
# Create the "call_both" function and add it to
985
1136
# the class
986
attr[attrname] = fixscope(attribute,
987
new_function)
1137
attr[attrname] = fixscope(attribute, new_function)
988
1138
# Is this a D-Bus method?
989
1139
elif getattr(attribute, "_dbus_is_method", False):
990
1140
# Create a new, but exactly alike, function
1001
1151
attribute.func_name,
1002
1152
attribute.func_defaults,
1003
1153
attribute.func_closure)))
1154
# Copy annotations, if any
1155
try:
1156
attr[attrname]._dbus_annotations = (
1157
dict(attribute._dbus_annotations))
1158
except AttributeError:
1159
pass
1004
1160
# Is this a D-Bus property?
1005
1161
elif getattr(attribute, "_dbus_is_property", False):
1006
1162
# Create a new, but exactly alike, function
1020
1176
attribute.func_name,
1021
1177
attribute.func_defaults,
1022
1178
attribute.func_closure)))
1023
return type.__new__(mcs, name, bases, attr)
1024
1025
1179
# Copy annotations, if any
1180
try:
1181
attr[attrname]._dbus_annotations = (
1182
dict(attribute._dbus_annotations))
1183
except AttributeError:
1184
pass
1185
# Is this a D-Bus interface?
1186
elif getattr(attribute, "_dbus_is_interface", False):
1187
# Create a new, but exactly alike, function
1188
# object. Decorate it to be a new D-Bus interface
1189
# with the alternate D-Bus interface name. Add it
1190
# to the class.
1191
attr[attrname] = (dbus_interface_annotations
1192
(alt_interface)
1193
(types.FunctionType
1194
(attribute.func_code,
1195
attribute.func_globals,
1196
attribute.func_name,
1197
attribute.func_defaults,
1198
attribute.func_closure)))
1199
if deprecate:
1200
# Deprecate all alternate interfaces
1201
iname="_AlternateDBusNames_interface_annotation{}"
1202
for interface_name in interface_names:
1203
@dbus_interface_annotations(interface_name)
1204
def func(self):
1205
return { "org.freedesktop.DBus.Deprecated":
1206
"true" }
1207
# Find an unused name
1208
for aname in (iname.format(i)
1209
for i in itertools.count()):
1210
if aname not in attr:
1211
attr[aname] = func
1212
break
1213
if interface_names:
1214
# Replace the class with a new subclass of it with
1215
# methods, signals, etc. as created above.
1216
cls = type(b"{}Alternate".format(cls.__name__),
1217
(cls,), attr)
1218
return cls
1219
return wrapper
1220
1221
1222
@alternate_dbus_interfaces({"se.recompile.Mandos":
1223
"se.bsnet.fukt.Mandos"})
1026
1224
class ClientDBus(Client, DBusObjectWithProperties):
1027
1225
"""A Client class using D-Bus
1028
1226
1034
1232
runtime_expansions = (Client.runtime_expansions
1035
1233
+ ("dbus_object_path",))
1036
1234
1235
_interface = "se.recompile.Mandos.Client"
1236
1037
1237
# dbus.service.Object doesn't use super(), so we can't either.
1038
1238
1039
1239
def __init__(self, bus = None, *args, **kwargs):
1040
1240
self.bus = bus
1041
1241
Client.__init__(self, *args, **kwargs)
1042
self._approvals_pending = 0
1043
1044
self._approvals_pending = 0
1045
1242
# Only now, when this client is initialized, can it show up on
1046
1243
# the D-Bus
1047
client_object_name = unicode(self.name).translate(
1244
client_object_name = str(self.name).translate(
1048
1245
{ord("."): ord("_"),
1049
1246
ord("-"): ord("_")})
1050
1247
self.dbus_object_path = (dbus.ObjectPath
1051
1248
("/clients/" + client_object_name))
1052
1249
DBusObjectWithProperties.__init__(self, self.bus,
1053
1250
self.dbus_object_path)
1054
1251
1055
1252
def notifychangeproperty(transform_func,
1056
1253
dbus_name, type_func=lambda x: x,
1057
variant_level=1):
1254
variant_level=1, invalidate_only=False,
1255
_interface=_interface):
1058
1256
""" Modify a variable so that it's a property which announces
1059
1257
its changes to DBus.
1060
1258
1065
1263
to the D-Bus. Default: no transform
1066
1264
variant_level: D-Bus variant level. Default: 1
1067
1265
"""
1068
attrname = "_{0}".format(dbus_name)
1266
attrname = "_{}".format(dbus_name)
1069
1267
def setter(self, value):
1070
1268
if hasattr(self, "dbus_object_path"):
1071
1269
if (not hasattr(self, attrname) or
1072
1270
type_func(getattr(self, attrname, None))
1073
1271
!= type_func(value)):
1074
dbus_value = transform_func(type_func(value),
1075
variant_level
1076
=variant_level)
1077
self.PropertyChanged(dbus.String(dbus_name),
1078
dbus_value)
1272
if invalidate_only:
1273
self.PropertiesChanged(_interface,
1274
dbus.Dictionary(),
1275
dbus.Array
1276
((dbus_name,)))
1277
else:
1278
dbus_value = transform_func(type_func(value),
1279
variant_level
1280
=variant_level)
1281
self.PropertyChanged(dbus.String(dbus_name),
1282
dbus_value)
1283
self.PropertiesChanged(_interface,
1284
dbus.Dictionary({
1285
dbus.String(dbus_name):
1286
dbus_value }), dbus.Array())
1079
1287
setattr(self, attrname, value)
1080
1288
1081
1289
return property(lambda self: getattr(self, attrname), setter)
1082
1290
1083
1084
1291
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1085
1292
approvals_pending = notifychangeproperty(dbus.Boolean,
1086
1293
"ApprovalPending",
1093
1300
checker is not None)
1094
1301
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1095
1302
"LastCheckedOK")
1303
last_checker_status = notifychangeproperty(dbus.Int16,
1304
"LastCheckerStatus")
1096
1305
last_approval_request = notifychangeproperty(
1097
1306
datetime_to_dbus, "LastApprovalRequest")
1098
1307
approved_by_default = notifychangeproperty(dbus.Boolean,
1100
1309
approval_delay = notifychangeproperty(dbus.UInt64,
1101
1310
"ApprovalDelay",
1102
1311
type_func =
1103
timedelta_to_milliseconds)
1312
lambda td: td.total_seconds()
1313
* 1000)
1104
1314
approval_duration = notifychangeproperty(
1105
1315
dbus.UInt64, "ApprovalDuration",
1106
type_func = timedelta_to_milliseconds)
1316
type_func = lambda td: td.total_seconds() * 1000)
1107
1317
host = notifychangeproperty(dbus.String, "Host")
1108
1318
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1109
type_func =
1110
timedelta_to_milliseconds)
1319
type_func = lambda td:
1320
td.total_seconds() * 1000)
1111
1321
extended_timeout = notifychangeproperty(
1112
1322
dbus.UInt64, "ExtendedTimeout",
1113
type_func = timedelta_to_milliseconds)
1323
type_func = lambda td: td.total_seconds() * 1000)
1114
1324
interval = notifychangeproperty(dbus.UInt64,
1115
1325
"Interval",
1116
1326
type_func =
1117
timedelta_to_milliseconds)
1327
lambda td: td.total_seconds()
1328
* 1000)
1118
1329
checker_command = notifychangeproperty(dbus.String, "Checker")
1330
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1331
invalidate_only=True)
1119
1332
1120
1333
del notifychangeproperty
1121
1334
1148
1361
*args, **kwargs)
1149
1362
1150
1363
def start_checker(self, *args, **kwargs):
1151
old_checker = self.checker
1152
if self.checker is not None:
1153
old_checker_pid = self.checker.pid
1154
else:
1155
old_checker_pid = None
1364
old_checker_pid = getattr(self.checker, "pid", None)
1156
1365
r = Client.start_checker(self, *args, **kwargs)
1157
1366
# Only if new checker process was started
1158
1367
if (self.checker is not None
1166
1375
return False
1167
1376
1168
1377
def approve(self, value=True):
1169
self.send_changedstate()
1170
1378
self.approved = value
1171
gobject.timeout_add(timedelta_to_milliseconds
1172
(self.approval_duration),
1173
self._reset_approved)
1174
1379
gobject.timeout_add(int(self.approval_duration.total_seconds()
1380
* 1000), self._reset_approved)
1381
self.send_changedstate()
1175
1382
1176
1383
## D-Bus methods, signals & properties
1177
_interface = "se.recompile.Mandos.Client"
1384
1385
## Interfaces
1178
1386
1179
1387
## Signals
1180
1388
1191
1399
pass
1192
1400
1193
1401
# PropertyChanged - signal
1402
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1194
1403
@dbus.service.signal(_interface, signature="sv")
1195
1404
def PropertyChanged(self, property, value):
1196
1405
"D-Bus signal"
1217
1426
"D-Bus signal"
1218
1427
return self.need_approval()
1219
1428
1220
# NeRwequest - signal
1221
@dbus.service.signal(_interface, signature="s")
1222
def NewRequest(self, ip):
1223
"""D-Bus signal
1224
Is sent after a client request a password.
1225
"""
1226
pass
1227
1228
1429
## Methods
1229
1430
1230
1431
# Approve - method
1280
1481
access="readwrite")
1281
1482
def ApprovalDelay_dbus_property(self, value=None):
1282
1483
if value is None: # get
1283
return dbus.UInt64(self.approval_delay_milliseconds())
1484
return dbus.UInt64(self.approval_delay.total_seconds()
1485
* 1000)
1284
1486
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1285
1487
1286
1488
# ApprovalDuration - property
1288
1490
access="readwrite")
1289
1491
def ApprovalDuration_dbus_property(self, value=None):
1290
1492
if value is None: # get
1291
return dbus.UInt64(timedelta_to_milliseconds(
1292
self.approval_duration))
1493
return dbus.UInt64(self.approval_duration.total_seconds()
1494
* 1000)
1293
1495
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1294
1496
1295
1497
# Name - property
1308
1510
def Host_dbus_property(self, value=None):
1309
1511
if value is None: # get
1310
1512
return dbus.String(self.host)
1311
self.host = unicode(value)
1513
self.host = str(value)
1312
1514
1313
1515
# Created - property
1314
1516
@dbus_service_property(_interface, signature="s", access="read")
1340
1542
return
1341
1543
return datetime_to_dbus(self.last_checked_ok)
1342
1544
1545
# LastCheckerStatus - property
1546
@dbus_service_property(_interface, signature="n",
1547
access="read")
1548
def LastCheckerStatus_dbus_property(self):
1549
return dbus.Int16(self.last_checker_status)
1550
1343
1551
# Expires - property
1344
1552
@dbus_service_property(_interface, signature="s", access="read")
1345
1553
def Expires_dbus_property(self):
1355
1563
access="readwrite")
1356
1564
def Timeout_dbus_property(self, value=None):
1357
1565
if value is None: # get
1358
return dbus.UInt64(self.timeout_milliseconds())
1566
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1567
old_timeout = self.timeout
1359
1568
self.timeout = datetime.timedelta(0, 0, 0, value)
1360
if getattr(self, "disable_initiator_tag", None) is None:
1361
return
1362
# Reschedule timeout
1363
gobject.source_remove(self.disable_initiator_tag)
1364
self.disable_initiator_tag = None
1365
self.expires = None
1366
time_to_die = timedelta_to_milliseconds((self
1367
.last_checked_ok
1368
+ self.timeout)
1369
- datetime.datetime
1370
.utcnow())
1371
if time_to_die <= 0:
1372
# The timeout has passed
1373
self.disable()
1374
else:
1375
self.expires = (datetime.datetime.utcnow()
1376
+ datetime.timedelta(milliseconds =
1377
time_to_die))
1378
self.disable_initiator_tag = (gobject.timeout_add
1379
(time_to_die, self.disable))
1569
# Reschedule disabling
1570
if self.enabled:
1571
now = datetime.datetime.utcnow()
1572
self.expires += self.timeout - old_timeout
1573
if self.expires <= now:
1574
# The timeout has passed
1575
self.disable()
1576
else:
1577
if (getattr(self, "disable_initiator_tag", None)
1578
is None):
1579
return
1580
gobject.source_remove(self.disable_initiator_tag)
1581
self.disable_initiator_tag = (
1582
gobject.timeout_add(
1583
int((self.expires - now).total_seconds()
1584
* 1000), self.disable))
1380
1585
1381
1586
# ExtendedTimeout - property
1382
1587
@dbus_service_property(_interface, signature="t",
1383
1588
access="readwrite")
1384
1589
def ExtendedTimeout_dbus_property(self, value=None):
1385
1590
if value is None: # get
1386
return dbus.UInt64(self.extended_timeout_milliseconds())
1591
return dbus.UInt64(self.extended_timeout.total_seconds()
1592
* 1000)
1387
1593
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1388
1594
1389
1595
# Interval - property
1391
1597
access="readwrite")
1392
1598
def Interval_dbus_property(self, value=None):
1393
1599
if value is None: # get
1394
return dbus.UInt64(self.interval_milliseconds())
1600
return dbus.UInt64(self.interval.total_seconds() * 1000)
1395
1601
self.interval = datetime.timedelta(0, 0, 0, value)
1396
1602
if getattr(self, "checker_initiator_tag", None) is None:
1397
1603
return
1408
1614
def Checker_dbus_property(self, value=None):
1409
1615
if value is None: # get
1410
1616
return dbus.String(self.checker_command)
1411
self.checker_command = unicode(value)
1617
self.checker_command = str(value)
1412
1618
1413
1619
# CheckerRunning - property
1414
1620
@dbus_service_property(_interface, signature="b",
1430
1636
@dbus_service_property(_interface, signature="ay",
1431
1637
access="write", byte_arrays=True)
1432
1638
def Secret_dbus_property(self, value):
1433
self.secret = str(value)
1639
self.secret = bytes(value)
1434
1640
1435
1641
del _interface
1436
1642
1461
1667
self._pipe.send(('setattr', name, value))
1462
1668
1463
1669
1464
class ClientDBusTransitional(ClientDBus):
1465
__metaclass__ = AlternateDBusNamesMetaclass
1466
1467
1468
1670
class ClientHandler(socketserver.BaseRequestHandler, object):
1469
1671
"""A class to handle client connections.
1470
1672
1474
1676
def handle(self):
1475
1677
with contextlib.closing(self.server.child_pipe) as child_pipe:
1476
1678
logger.info("TCP connection from: %s",
1477
unicode(self.client_address))
1679
str(self.client_address))
1478
1680
logger.debug("Pipe FD: %d",
1479
1681
self.server.child_pipe.fileno())
1480
1682
1506
1708
logger.debug("Protocol version: %r", line)
1507
1709
try:
1508
1710
if int(line.strip().split()[0]) > 1:
1509
raise RuntimeError
1711
raise RuntimeError(line)
1510
1712
except (ValueError, IndexError, RuntimeError) as error:
1511
1713
logger.error("Unknown protocol version: %s", error)
1512
1714
return
1538
1740
except KeyError:
1539
1741
return
1540
1742
1541
if self.server.use_dbus:
1542
# Emit D-Bus signal
1543
client.NewRequest(str(self.client_address))
1544
1545
1743
if client.approval_delay:
1546
1744
delay = client.approval_delay
1547
1745
client.approvals_pending += 1
1565
1763
if self.server.use_dbus:
1566
1764
# Emit D-Bus signal
1567
1765
client.NeedApproval(
1568
client.approval_delay_milliseconds(),
1569
client.approved_by_default)
1766
client.approval_delay.total_seconds()
1767
* 1000, client.approved_by_default)
1570
1768
else:
1571
1769
logger.warning("Client %s was not approved",
1572
1770
client.name)
1578
1776
#wait until timeout or approved
1579
1777
time = datetime.datetime.now()
1580
1778
client.changedstate.acquire()
1581
(client.changedstate.wait
1582
(float(client.timedelta_to_milliseconds(delay)
1583
/ 1000)))
1779
client.changedstate.wait(delay.total_seconds())
1584
1780
client.changedstate.release()
1585
1781
time2 = datetime.datetime.now()
1586
1782
if (time2 - time) >= delay:
1602
1798
try:
1603
1799
sent = session.send(client.secret[sent_size:])
1604
1800
except gnutls.errors.GNUTLSError as error:
1605
logger.warning("gnutls send failed")
1801
logger.warning("gnutls send failed",
1802
exc_info=error)
1606
1803
return
1607
1804
logger.debug("Sent: %d, remaining: %d",
1608
1805
sent, len(client.secret)
1611
1808
1612
1809
logger.info("Sending secret to %s", client.name)
1613
1810
# bump the timeout using extended_timeout
1614
client.checked_ok(client.extended_timeout)
1811
client.bump_timeout(client.extended_timeout)
1615
1812
if self.server.use_dbus:
1616
1813
# Emit D-Bus signal
1617
1814
client.GotSecret()
1622
1819
try:
1623
1820
session.bye()
1624
1821
except gnutls.errors.GNUTLSError as error:
1625
logger.warning("GnuTLS bye failed")
1822
logger.warning("GnuTLS bye failed",
1823
exc_info=error)
1626
1824
1627
1825
@staticmethod
1628
1826
def peer_certificate(session):
1700
1898
def process_request(self, request, address):
1701
1899
"""Start a new process to process the request."""
1702
1900
proc = multiprocessing.Process(target = self.sub_process_main,
1703
args = (request,
1704
address))
1901
args = (request, address))
1705
1902
proc.start()
1706
1903
return proc
1707
1904
1722
1919
1723
1920
def add_pipe(self, parent_pipe, proc):
1724
1921
"""Dummy function; override as necessary"""
1725
raise NotImplementedError
1922
raise NotImplementedError()
1726
1923
1727
1924
1728
1925
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1735
1932
use_ipv6: Boolean; to use IPv6 or not
1736
1933
"""
1737
1934
def __init__(self, server_address, RequestHandlerClass,
1738
interface=None, use_ipv6=True):
1935
interface=None, use_ipv6=True, socketfd=None):
1936
"""If socketfd is set, use that file descriptor instead of
1937
creating a new one with socket.socket().
1938
"""
1739
1939
self.interface = interface
1740
1940
if use_ipv6:
1741
1941
self.address_family = socket.AF_INET6
1942
if socketfd is not None:
1943
# Save the file descriptor
1944
self.socketfd = socketfd
1945
# Save the original socket.socket() function
1946
self.socket_socket = socket.socket
1947
# To implement --socket, we monkey patch socket.socket.
1948
#
1949
# (When socketserver.TCPServer is a new-style class, we
1950
# could make self.socket into a property instead of monkey
1951
# patching socket.socket.)
1952
#
1953
# Create a one-time-only replacement for socket.socket()
1954
@functools.wraps(socket.socket)
1955
def socket_wrapper(*args, **kwargs):
1956
# Restore original function so subsequent calls are
1957
# not affected.
1958
socket.socket = self.socket_socket
1959
del self.socket_socket
1960
# This time only, return a new socket object from the
1961
# saved file descriptor.
1962
return socket.fromfd(self.socketfd, *args, **kwargs)
1963
# Replace socket.socket() function with wrapper
1964
socket.socket = socket_wrapper
1965
# The socketserver.TCPServer.__init__ will call
1966
# socket.socket(), which might be our replacement,
1967
# socket_wrapper(), if socketfd was set.
1742
1968
socketserver.TCPServer.__init__(self, server_address,
1743
1969
RequestHandlerClass)
1970
1744
1971
def server_bind(self):
1745
1972
"""This overrides the normal server_bind() function
1746
1973
to bind to an interface if one was specified, and also NOT to
1754
1981
try:
1755
1982
self.socket.setsockopt(socket.SOL_SOCKET,
1756
1983
SO_BINDTODEVICE,
1757
str(self.interface
1758
+ '\0'))
1984
(self.interface + "\0")
1985
.encode("utf-8"))
1759
1986
except socket.error as error:
1760
if error[0] == errno.EPERM:
1761
logger.error("No permission to"
1762
" bind to interface %s",
1763
self.interface)
1764
elif error[0] == errno.ENOPROTOOPT:
1987
if error.errno == errno.EPERM:
1988
logger.error("No permission to bind to"
1989
" interface %s", self.interface)
1990
elif error.errno == errno.ENOPROTOOPT:
1765
1991
logger.error("SO_BINDTODEVICE not available;"
1766
1992
" cannot bind to interface %s",
1767
1993
self.interface)
1994
elif error.errno == errno.ENODEV:
1995
logger.error("Interface %s does not exist,"
1996
" cannot bind", self.interface)
1768
1997
else:
1769
1998
raise
1770
1999
# Only bind(2) the socket if we really need to.
1773
2002
if self.address_family == socket.AF_INET6:
1774
2003
any_address = "::" # in6addr_any
1775
2004
else:
1776
any_address = socket.INADDR_ANY
2005
any_address = "0.0.0.0" # INADDR_ANY
1777
2006
self.server_address = (any_address,
1778
2007
self.server_address[1])
1779
2008
elif not self.server_address[1]:
1800
2029
"""
1801
2030
def __init__(self, server_address, RequestHandlerClass,
1802
2031
interface=None, use_ipv6=True, clients=None,
1803
gnutls_priority=None, use_dbus=True):
2032
gnutls_priority=None, use_dbus=True, socketfd=None):
1804
2033
self.enabled = False
1805
2034
self.clients = clients
1806
2035
if self.clients is None:
1810
2039
IPv6_TCPServer.__init__(self, server_address,
1811
2040
RequestHandlerClass,
1812
2041
interface = interface,
1813
use_ipv6 = use_ipv6)
2042
use_ipv6 = use_ipv6,
2043
socketfd = socketfd)
1814
2044
def server_activate(self):
1815
2045
if self.enabled:
1816
2046
return socketserver.TCPServer.server_activate(self)
1829
2059
1830
2060
def handle_ipc(self, source, condition, parent_pipe=None,
1831
2061
proc = None, client_object=None):
1832
condition_names = {
1833
gobject.IO_IN: "IN", # There is data to read.
1834
gobject.IO_OUT: "OUT", # Data can be written (without
1835
# blocking).
1836
gobject.IO_PRI: "PRI", # There is urgent data to read.
1837
gobject.IO_ERR: "ERR", # Error condition.
1838
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1839
# broken, usually for pipes and
1840
# sockets).
1841
}
1842
conditions_string = ' | '.join(name
1843
for cond, name in
1844
condition_names.iteritems()
1845
if cond & condition)
1846
2062
# error, or the other end of multiprocessing.Pipe has closed
1847
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2063
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1848
2064
# Wait for other process to exit
1849
2065
proc.join()
1850
2066
return False
1908
2124
return True
1909
2125
1910
2126
2127
def rfc3339_duration_to_delta(duration):
2128
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2129
2130
>>> rfc3339_duration_to_delta("P7D")
2131
datetime.timedelta(7)
2132
>>> rfc3339_duration_to_delta("PT60S")
2133
datetime.timedelta(0, 60)
2134
>>> rfc3339_duration_to_delta("PT60M")
2135
datetime.timedelta(0, 3600)
2136
>>> rfc3339_duration_to_delta("PT24H")
2137
datetime.timedelta(1)
2138
>>> rfc3339_duration_to_delta("P1W")
2139
datetime.timedelta(7)
2140
>>> rfc3339_duration_to_delta("PT5M30S")
2141
datetime.timedelta(0, 330)
2142
>>> rfc3339_duration_to_delta("P1DT3M20S")
2143
datetime.timedelta(1, 200)
2144
"""
2145
2146
# Parsing an RFC 3339 duration with regular expressions is not
2147
# possible - there would have to be multiple places for the same
2148
# values, like seconds. The current code, while more esoteric, is
2149
# cleaner without depending on a parsing library. If Python had a
2150
# built-in library for parsing we would use it, but we'd like to
2151
# avoid excessive use of external libraries.
2152
2153
# New type for defining tokens, syntax, and semantics all-in-one
2154
Token = collections.namedtuple("Token",
2155
("regexp", # To match token; if
2156
# "value" is not None,
2157
# must have a "group"
2158
# containing digits
2159
"value", # datetime.timedelta or
2160
# None
2161
"followers")) # Tokens valid after
2162
# this token
2163
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2164
# the "duration" ABNF definition in RFC 3339, Appendix A.
2165
token_end = Token(re.compile(r"$"), None, frozenset())
2166
token_second = Token(re.compile(r"(\d+)S"),
2167
datetime.timedelta(seconds=1),
2168
frozenset((token_end,)))
2169
token_minute = Token(re.compile(r"(\d+)M"),
2170
datetime.timedelta(minutes=1),
2171
frozenset((token_second, token_end)))
2172
token_hour = Token(re.compile(r"(\d+)H"),
2173
datetime.timedelta(hours=1),
2174
frozenset((token_minute, token_end)))
2175
token_time = Token(re.compile(r"T"),
2176
None,
2177
frozenset((token_hour, token_minute,
2178
token_second)))
2179
token_day = Token(re.compile(r"(\d+)D"),
2180
datetime.timedelta(days=1),
2181
frozenset((token_time, token_end)))
2182
token_month = Token(re.compile(r"(\d+)M"),
2183
datetime.timedelta(weeks=4),
2184
frozenset((token_day, token_end)))
2185
token_year = Token(re.compile(r"(\d+)Y"),
2186
datetime.timedelta(weeks=52),
2187
frozenset((token_month, token_end)))
2188
token_week = Token(re.compile(r"(\d+)W"),
2189
datetime.timedelta(weeks=1),
2190
frozenset((token_end,)))
2191
token_duration = Token(re.compile(r"P"), None,
2192
frozenset((token_year, token_month,
2193
token_day, token_time,
2194
token_week)))
2195
# Define starting values
2196
value = datetime.timedelta() # Value so far
2197
found_token = None
2198
followers = frozenset((token_duration,)) # Following valid tokens
2199
s = duration # String left to parse
2200
# Loop until end token is found
2201
while found_token is not token_end:
2202
# Search for any currently valid tokens
2203
for token in followers:
2204
match = token.regexp.match(s)
2205
if match is not None:
2206
# Token found
2207
if token.value is not None:
2208
# Value found, parse digits
2209
factor = int(match.group(1), 10)
2210
# Add to value so far
2211
value += factor * token.value
2212
# Strip token from string
2213
s = token.regexp.sub("", s, 1)
2214
# Go to found token
2215
found_token = token
2216
# Set valid next tokens
2217
followers = found_token.followers
2218
break
2219
else:
2220
# No currently valid tokens were found
2221
raise ValueError("Invalid RFC 3339 duration")
2222
# End token found
2223
return value
2224
2225
1911
2226
def string_to_delta(interval):
1912
2227
"""Parse a string and return a datetime.timedelta
1913
2228
1924
2239
>>> string_to_delta('5m 30s')
1925
2240
datetime.timedelta(0, 330)
1926
2241
"""
2242
2243
try:
2244
return rfc3339_duration_to_delta(interval)
2245
except ValueError:
2246
pass
2247
1927
2248
timevalue = datetime.timedelta(0)
1928
2249
for s in interval.split():
1929
2250
try:
1930
suffix = unicode(s[-1])
2251
suffix = s[-1]
1931
2252
value = int(s[:-1])
1932
2253
if suffix == "d":
1933
2254
delta = datetime.timedelta(value)
1940
2261
elif suffix == "w":
1941
2262
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1942
2263
else:
1943
raise ValueError("Unknown suffix %r" % suffix)
1944
except (ValueError, IndexError) as e:
2264
raise ValueError("Unknown suffix {!r}"
2265
.format(suffix))
2266
except IndexError as e:
1945
2267
raise ValueError(*(e.args))
1946
2268
timevalue += delta
1947
2269
return timevalue
1960
2282
sys.exit()
1961
2283
if not noclose:
1962
2284
# Close all standard open file descriptors
1963
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2285
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1964
2286
if not stat.S_ISCHR(os.fstat(null).st_mode):
1965
raise OSError(errno.ENODEV,
1966
"%s not a character device"
1967
% os.path.devnull)
2287
raise OSError(errno.ENODEV, "{} not a character device"
2288
.format(os.devnull))
1968
2289
os.dup2(null, sys.stdin.fileno())
1969
2290
os.dup2(null, sys.stdout.fileno())
1970
2291
os.dup2(null, sys.stderr.fileno())
1979
2300
1980
2301
parser = argparse.ArgumentParser()
1981
2302
parser.add_argument("-v", "--version", action="version",
1982
version = "%%(prog)s %s" % version,
2303
version = "%(prog)s {}".format(version),
1983
2304
help="show version number and exit")
1984
2305
parser.add_argument("-i", "--interface", metavar="IF",
1985
2306
help="Bind to interface IF")
1991
2312
help="Run self-test")
1992
2313
parser.add_argument("--debug", action="store_true",
1993
2314
help="Debug mode; run in foreground and log"
1994
" to terminal")
2315
" to terminal", default=None)
1995
2316
parser.add_argument("--debuglevel", metavar="LEVEL",
1996
2317
help="Debug level for stdout output")
1997
2318
parser.add_argument("--priority", help="GnuTLS"
2004
2325
" files")
2005
2326
parser.add_argument("--no-dbus", action="store_false",
2006
2327
dest="use_dbus", help="Do not provide D-Bus"
2007
" system bus interface")
2328
" system bus interface", default=None)
2008
2329
parser.add_argument("--no-ipv6", action="store_false",
2009
dest="use_ipv6", help="Do not use IPv6")
2330
dest="use_ipv6", help="Do not use IPv6",
2331
default=None)
2010
2332
parser.add_argument("--no-restore", action="store_false",
2011
2333
dest="restore", help="Do not restore stored"
2012
" state")
2334
" state", default=None)
2335
parser.add_argument("--socket", type=int,
2336
help="Specify a file descriptor to a network"
2337
" socket to use instead of creating one")
2013
2338
parser.add_argument("--statedir", metavar="DIR",
2014
2339
help="Directory to save/restore state in")
2340
parser.add_argument("--foreground", action="store_true",
2341
help="Run in foreground", default=None)
2342
parser.add_argument("--no-zeroconf", action="store_false",
2343
dest="zeroconf", help="Do not use Zeroconf",
2344
default=None)
2015
2345
2016
2346
options = parser.parse_args()
2017
2347
2018
2348
if options.check:
2019
2349
import doctest
2020
doctest.testmod()
2021
sys.exit()
2350
fail_count, test_count = doctest.testmod()
2351
sys.exit(os.EX_OK if fail_count == 0 else 1)
2022
2352
2023
2353
# Default values for config file for server-global settings
2024
2354
server_defaults = { "interface": "",
2026
2356
"port": "",
2027
2357
"debug": "False",
2028
2358
"priority":
2029
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2359
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2360
":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2030
2361
"servicename": "Mandos",
2031
2362
"use_dbus": "True",
2032
2363
"use_ipv6": "True",
2033
2364
"debuglevel": "",
2034
2365
"restore": "True",
2035
"statedir": "/var/lib/mandos"
2366
"socket": "",
2367
"statedir": "/var/lib/mandos",
2368
"foreground": "False",
2369
"zeroconf": "True",
2036
2370
}
2037
2371
2038
2372
# Parse config file for server-global settings
2043
2377
# Convert the SafeConfigParser object to a dict
2044
2378
server_settings = server_config.defaults()
2045
2379
# Use the appropriate methods on the non-string config options
2046
for option in ("debug", "use_dbus", "use_ipv6"):
2380
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2047
2381
server_settings[option] = server_config.getboolean("DEFAULT",
2048
2382
option)
2049
2383
if server_settings["port"]:
2050
2384
server_settings["port"] = server_config.getint("DEFAULT",
2051
2385
"port")
2386
if server_settings["socket"]:
2387
server_settings["socket"] = server_config.getint("DEFAULT",
2388
"socket")
2389
# Later, stdin will, and stdout and stderr might, be dup'ed
2390
# over with an opened os.devnull. But we don't want this to
2391
# happen with a supplied network socket.
2392
if 0 <= server_settings["socket"] <= 2:
2393
server_settings["socket"] = os.dup(server_settings
2394
["socket"])
2052
2395
del server_config
2053
2396
2054
2397
# Override the settings from the config file with command line
2056
2399
for option in ("interface", "address", "port", "debug",
2057
2400
"priority", "servicename", "configdir",
2058
2401
"use_dbus", "use_ipv6", "debuglevel", "restore",
2059
"statedir"):
2402
"statedir", "socket", "foreground", "zeroconf"):
2060
2403
value = getattr(options, option)
2061
2404
if value is not None:
2062
2405
server_settings[option] = value
2063
2406
del options
2064
2407
# Force all strings to be unicode
2065
2408
for option in server_settings.keys():
2066
if type(server_settings[option]) is str:
2067
server_settings[option] = unicode(server_settings[option])
2409
if isinstance(server_settings[option], bytes):
2410
server_settings[option] = (server_settings[option]
2411
.decode("utf-8"))
2412
# Force all boolean options to be boolean
2413
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2414
"foreground", "zeroconf"):
2415
server_settings[option] = bool(server_settings[option])
2416
# Debug implies foreground
2417
if server_settings["debug"]:
2418
server_settings["foreground"] = True
2068
2419
# Now we have our good server settings in "server_settings"
2069
2420
2070
2421
##################################################################
2071
2422
2423
if (not server_settings["zeroconf"] and
2424
not (server_settings["port"]
2425
or server_settings["socket"] != "")):
2426
parser.error("Needs port or socket to work without"
2427
" Zeroconf")
2428
2072
2429
# For convenience
2073
2430
debug = server_settings["debug"]
2074
2431
debuglevel = server_settings["debuglevel"]
2076
2433
use_ipv6 = server_settings["use_ipv6"]
2077
2434
stored_state_path = os.path.join(server_settings["statedir"],
2078
2435
stored_state_file)
2436
foreground = server_settings["foreground"]
2437
zeroconf = server_settings["zeroconf"]
2079
2438
2080
2439
if debug:
2081
initlogger(logging.DEBUG)
2440
initlogger(debug, logging.DEBUG)
2082
2441
else:
2083
2442
if not debuglevel:
2084
initlogger()
2443
initlogger(debug)
2085
2444
else:
2086
2445
level = getattr(logging, debuglevel.upper())
2087
initlogger(level)
2446
initlogger(debug, level)
2088
2447
2089
2448
if server_settings["servicename"] != "Mandos":
2090
2449
syslogger.setFormatter(logging.Formatter
2091
('Mandos (%s) [%%(process)d]:'
2092
' %%(levelname)s: %%(message)s'
2093
% server_settings["servicename"]))
2450
('Mandos ({}) [%(process)d]:'
2451
' %(levelname)s: %(message)s'
2452
.format(server_settings
2453
["servicename"])))
2094
2454
2095
2455
# Parse config file with clients
2096
client_config = configparser.SafeConfigParser(Client.client_defaults)
2456
client_config = configparser.SafeConfigParser(Client
2457
.client_defaults)
2097
2458
client_config.read(os.path.join(server_settings["configdir"],
2098
2459
"clients.conf"))
2099
2460
2100
2461
global mandos_dbus_service
2101
2462
mandos_dbus_service = None
2102
2463
2464
socketfd = None
2465
if server_settings["socket"] != "":
2466
socketfd = server_settings["socket"]
2103
2467
tcp_server = MandosServer((server_settings["address"],
2104
2468
server_settings["port"]),
2105
2469
ClientHandler,
2108
2472
use_ipv6=use_ipv6,
2109
2473
gnutls_priority=
2110
2474
server_settings["priority"],
2111
use_dbus=use_dbus)
2112
if not debug:
2113
pidfilename = "/var/run/mandos.pid"
2475
use_dbus=use_dbus,
2476
socketfd=socketfd)
2477
if not foreground:
2478
pidfilename = "/run/mandos.pid"
2479
if not os.path.isdir("/run/."):
2480
pidfilename = "/var/run/mandos.pid"
2481
pidfile = None
2114
2482
try:
2115
2483
pidfile = open(pidfilename, "w")
2116
except IOError:
2117
logger.error("Could not open file %r", pidfilename)
2484
except IOError as e:
2485
logger.error("Could not open file %r", pidfilename,
2486
exc_info=e)
2118
2487
2119
try:
2120
uid = pwd.getpwnam("_mandos").pw_uid
2121
gid = pwd.getpwnam("_mandos").pw_gid
2122
except KeyError:
2488
for name in ("_mandos", "mandos", "nobody"):
2123
2489
try:
2124
uid = pwd.getpwnam("mandos").pw_uid
2125
gid = pwd.getpwnam("mandos").pw_gid
2490
uid = pwd.getpwnam(name).pw_uid
2491
gid = pwd.getpwnam(name).pw_gid
2492
break
2126
2493
except KeyError:
2127
try:
2128
uid = pwd.getpwnam("nobody").pw_uid
2129
gid = pwd.getpwnam("nobody").pw_gid
2130
except KeyError:
2131
uid = 65534
2132
gid = 65534
2494
continue
2495
else:
2496
uid = 65534
2497
gid = 65534
2133
2498
try:
2134
2499
os.setgid(gid)
2135
2500
os.setuid(uid)
2136
2501
except OSError as error:
2137
if error[0] != errno.EPERM:
2138
raise error
2502
if error.errno != errno.EPERM:
2503
raise
2139
2504
2140
2505
if debug:
2141
2506
# Enable all possible GnuTLS debugging
2152
2517
.gnutls_global_set_log_function(debug_gnutls))
2153
2518
2154
2519
# Redirect stdin so all checkers get /dev/null
2155
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2520
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2156
2521
os.dup2(null, sys.stdin.fileno())
2157
2522
if null > 2:
2158
2523
os.close(null)
2159
else:
2160
# No console logging
2161
logger.removeHandler(console)
2162
2524
2163
2525
# Need to fork before connecting to D-Bus
2164
if not debug:
2526
if not foreground:
2165
2527
# Close all input and output, do double fork, etc.
2166
2528
daemon()
2167
2529
2530
# multiprocessing will use threads, so before we use gobject we
2531
# need to inform gobject that threads will be used.
2168
2532
gobject.threads_init()
2169
2533
2170
2534
global main_loop
2171
2535
# From the Avahi example code
2172
DBusGMainLoop(set_as_default=True )
2536
DBusGMainLoop(set_as_default=True)
2173
2537
main_loop = gobject.MainLoop()
2174
2538
bus = dbus.SystemBus()
2175
2539
# End of Avahi example code
2181
2545
("se.bsnet.fukt.Mandos", bus,
2182
2546
do_not_queue=True))
2183
2547
except dbus.exceptions.NameExistsException as e:
2184
logger.error(unicode(e) + ", disabling D-Bus")
2548
logger.error("Disabling D-Bus:", exc_info=e)
2185
2549
use_dbus = False
2186
2550
server_settings["use_dbus"] = False
2187
2551
tcp_server.use_dbus = False
2188
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2189
service = AvahiServiceToSyslog(name =
2190
server_settings["servicename"],
2191
servicetype = "_mandos._tcp",
2192
protocol = protocol, bus = bus)
2193
if server_settings["interface"]:
2194
service.interface = (if_nametoindex
2195
(str(server_settings["interface"])))
2552
if zeroconf:
2553
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2554
service = AvahiServiceToSyslog(name =
2555
server_settings["servicename"],
2556
servicetype = "_mandos._tcp",
2557
protocol = protocol, bus = bus)
2558
if server_settings["interface"]:
2559
service.interface = (if_nametoindex
2560
(server_settings["interface"]
2561
.encode("utf-8")))
2196
2562
2197
2563
global multiprocessing_manager
2198
2564
multiprocessing_manager = multiprocessing.Manager()
2199
2565
2200
2566
client_class = Client
2201
2567
if use_dbus:
2202
client_class = functools.partial(ClientDBusTransitional,
2203
bus = bus)
2568
client_class = functools.partial(ClientDBus, bus = bus)
2204
2569
2205
2570
client_settings = Client.config_parser(client_config)
2206
2571
old_client_settings = {}
2207
2572
clients_data = {}
2208
2573
2574
# This is used to redirect stdout and stderr for checker processes
2575
global wnull
2576
wnull = open(os.devnull, "w") # A writable /dev/null
2577
# Only used if server is running in foreground but not in debug
2578
# mode
2579
if debug or not foreground:
2580
wnull.close()
2581
2209
2582
# Get client data and settings from last running state.
2210
2583
if server_settings["restore"]:
2211
2584
try:
2214
2587
(stored_state))
2215
2588
os.remove(stored_state_path)
2216
2589
except IOError as e:
2217
logger.warning("Could not load persistent state: {0}"
2218
.format(e))
2219
if e.errno != errno.ENOENT:
2590
if e.errno == errno.ENOENT:
2591
logger.warning("Could not load persistent state: {}"
2592
.format(os.strerror(e.errno)))
2593
else:
2594
logger.critical("Could not load persistent state:",
2595
exc_info=e)
2220
2596
raise
2597
except EOFError as e:
2598
logger.warning("Could not load persistent state: "
2599
"EOFError:", exc_info=e)
2221
2600
2222
2601
with PGPEngine() as pgp:
2223
for client_name, client in clients_data.iteritems():
2602
for client_name, client in clients_data.items():
2603
# Skip removed clients
2604
if client_name not in client_settings:
2605
continue
2606
2224
2607
# Decide which value to use after restoring saved state.
2225
2608
# We have three different values: Old config file,
2226
2609
# new config file, and saved state.
2240
2623
2241
2624
# Clients who has passed its expire date can still be
2242
2625
# enabled if its last checker was successful. Clients
2243
# whose checker failed before we stored its state is
2244
# assumed to have failed all checkers during downtime.
2626
# whose checker succeeded before we stored its state is
2627
# assumed to have successfully run all checkers during
2628
# downtime.
2245
2629
if client["enabled"]:
2246
2630
if datetime.datetime.utcnow() >= client["expires"]:
2247
2631
if not client["last_checked_ok"]:
2248
2632
logger.warning(
2249
"disabling client {0} - Client never "
2250
"performed a successfull checker"
2251
.format(client["name"]))
2633
"disabling client {} - Client never "
2634
"performed a successful checker"
2635
.format(client_name))
2252
2636
client["enabled"] = False
2253
2637
elif client["last_checker_status"] != 0:
2254
2638
logger.warning(
2255
"disabling client {0} - Client "
2256
"last checker failed with error code {1}"
2257
.format(client["name"],
2639
"disabling client {} - Client last"
2640
" checker failed with error code {}"
2641
.format(client_name,
2258
2642
client["last_checker_status"]))
2259
2643
client["enabled"] = False
2260
2644
else:
2261
2645
client["expires"] = (datetime.datetime
2262
2646
.utcnow()
2263
2647
+ client["timeout"])
2264
2648
logger.debug("Last checker succeeded,"
2649
" keeping {} enabled"
2650
.format(client_name))
2265
2651
try:
2266
2652
client["secret"] = (
2267
2653
pgp.decrypt(client["encrypted_secret"],
2269
2655
["secret"]))
2270
2656
except PGPError:
2271
2657
# If decryption fails, we use secret from new settings
2272
logger.debug("Failed to decrypt {0} old secret"
2658
logger.debug("Failed to decrypt {} old secret"
2273
2659
.format(client_name))
2274
2660
client["secret"] = (
2275
2661
client_settings[client_name]["secret"])
2276
2277
2662
2278
2663
# Add/remove clients based on new changes made to config
2279
for client_name in set(old_client_settings) - set(client_settings):
2664
for client_name in (set(old_client_settings)
2665
- set(client_settings)):
2280
2666
del clients_data[client_name]
2281
for client_name in set(client_settings) - set(old_client_settings):
2667
for client_name in (set(client_settings)
2668
- set(old_client_settings)):
2282
2669
clients_data[client_name] = client_settings[client_name]
2283
2284
# Create clients all clients
2285
for client_name, client in clients_data.iteritems():
2670
2671
# Create all client objects
2672
for client_name, client in clients_data.items():
2286
2673
tcp_server.clients[client_name] = client_class(
2287
name = client_name, settings = client)
2674
name = client_name, settings = client,
2675
server_settings = server_settings)
2288
2676
2289
2677
if not tcp_server.clients:
2290
2678
logger.warning("No clients defined")
2291
2292
if not debug:
2293
try:
2294
with pidfile:
2295
pid = os.getpid()
2296
pidfile.write(str(pid) + "\n".encode("utf-8"))
2297
del pidfile
2298
except IOError:
2299
logger.error("Could not write to file %r with PID %d",
2300
pidfilename, pid)
2301
except NameError:
2302
# "pidfile" was never created
2303
pass
2679
2680
if not foreground:
2681
if pidfile is not None:
2682
try:
2683
with pidfile:
2684
pid = os.getpid()
2685
pidfile.write("{}\n".format(pid).encode("utf-8"))
2686
except IOError:
2687
logger.error("Could not write to file %r with PID %d",
2688
pidfilename, pid)
2689
del pidfile
2304
2690
del pidfilename
2305
signal.signal(signal.SIGINT, signal.SIG_IGN)
2306
2691
2307
2692
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2308
2693
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2309
2694
2310
2695
if use_dbus:
2311
class MandosDBusService(dbus.service.Object):
2696
@alternate_dbus_interfaces({"se.recompile.Mandos":
2697
"se.bsnet.fukt.Mandos"})
2698
class MandosDBusService(DBusObjectWithProperties):
2312
2699
"""A D-Bus proxy object"""
2313
2700
def __init__(self):
2314
2701
dbus.service.Object.__init__(self, bus, "/")
2315
2702
_interface = "se.recompile.Mandos"
2316
2703
2704
@dbus_interface_annotations(_interface)
2705
def _foo(self):
2706
return { "org.freedesktop.DBus.Property"
2707
".EmitsChangedSignal":
2708
"false"}
2709
2317
2710
@dbus.service.signal(_interface, signature="o")
2318
2711
def ClientAdded(self, objpath):
2319
2712
"D-Bus signal"
2341
2734
def GetAllClientsWithProperties(self):
2342
2735
"D-Bus method"
2343
2736
return dbus.Dictionary(
2344
((c.dbus_object_path, c.GetAll(""))
2345
for c in tcp_server.clients.itervalues()),
2737
{ c.dbus_object_path: c.GetAll("")
2738
for c in tcp_server.clients.itervalues() },
2346
2739
signature="oa{sv}")
2347
2740
2348
2741
@dbus.service.method(_interface, in_signature="o")
2361
2754
2362
2755
del _interface
2363
2756
2364
class MandosDBusServiceTransitional(MandosDBusService):
2365
__metaclass__ = AlternateDBusNamesMetaclass
2366
mandos_dbus_service = MandosDBusServiceTransitional()
2757
mandos_dbus_service = MandosDBusService()
2367
2758
2368
2759
def cleanup():
2369
2760
"Cleanup function; run on exit"
2370
service.cleanup()
2761
if zeroconf:
2762
service.cleanup()
2371
2763
2372
2764
multiprocessing.active_children()
2765
wnull.close()
2373
2766
if not (tcp_server.clients or client_settings):
2374
2767
return
2375
2768
2386
2779
2387
2780
# A list of attributes that can not be pickled
2388
2781
# + secret.
2389
exclude = set(("bus", "changedstate", "secret",
2390
"checker"))
2782
exclude = { "bus", "changedstate", "secret",
2783
"checker", "server_settings" }
2391
2784
for name, typ in (inspect.getmembers
2392
2785
(dbus.service.Object)):
2393
2786
exclude.add(name)
2402
2795
del client_settings[client.name]["secret"]
2403
2796
2404
2797
try:
2405
with os.fdopen(os.open(stored_state_path,
2406
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2407
0600), "wb") as stored_state:
2798
with (tempfile.NamedTemporaryFile
2799
(mode='wb', suffix=".pickle", prefix='clients-',
2800
dir=os.path.dirname(stored_state_path),
2801
delete=False)) as stored_state:
2408
2802
pickle.dump((clients, client_settings), stored_state)
2803
tempname=stored_state.name
2804
os.rename(tempname, stored_state_path)
2409
2805
except (IOError, OSError) as e:
2410
logger.warning("Could not save persistent state: {0}"
2411
.format(e))
2412
if e.errno not in (errno.ENOENT, errno.EACCES):
2806
if not debug:
2807
try:
2808
os.remove(tempname)
2809
except NameError:
2810
pass
2811
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2812
logger.warning("Could not save persistent state: {}"
2813
.format(os.strerror(e.errno)))
2814
else:
2815
logger.warning("Could not save persistent state:",
2816
exc_info=e)
2413
2817
raise
2414
2818
2415
2819
# Delete all clients, and settings from config
2440
2844
tcp_server.server_activate()
2441
2845
2442
2846
# Find out what port we got
2443
service.port = tcp_server.socket.getsockname()[1]
2847
if zeroconf:
2848
service.port = tcp_server.socket.getsockname()[1]
2444
2849
if use_ipv6:
2445
2850
logger.info("Now listening on address %r, port %d,"
2446
" flowinfo %d, scope_id %d"
2447
% tcp_server.socket.getsockname())
2851
" flowinfo %d, scope_id %d",
2852
*tcp_server.socket.getsockname())
2448
2853
else: # IPv4
2449
logger.info("Now listening on address %r, port %d"
2450
% tcp_server.socket.getsockname())
2854
logger.info("Now listening on address %r, port %d",
2855
*tcp_server.socket.getsockname())
2451
2856
2452
2857
#service.interface = tcp_server.socket.getsockname()[3]
2453
2858
2454
2859
try:
2455
# From the Avahi example code
2456
try:
2457
service.activate()
2458
except dbus.exceptions.DBusException as error:
2459
logger.critical("DBusException: %s", error)
2460
cleanup()
2461
sys.exit(1)
2462
# End of Avahi example code
2860
if zeroconf:
2861
# From the Avahi example code
2862
try:
2863
service.activate()
2864
except dbus.exceptions.DBusException as error:
2865
logger.critical("D-Bus Exception", exc_info=error)
2866
cleanup()
2867
sys.exit(1)
2868
# End of Avahi example code
2463
2869
2464
2870
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2465
2871
lambda *args, **kwargs:
2469
2875
logger.debug("Starting main loop")
2470
2876
main_loop.run()
2471
2877
except AvahiError as error:
2472
logger.critical("AvahiError: %s", error)
2878
logger.critical("Avahi Error", exc_info=error)
2473
2879
cleanup()
2474
2880
sys.exit(1)
2475
2881
except KeyboardInterrupt:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0