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