45
44
import gnutls.library.functions
46
45
import gnutls.library.constants
47
46
import gnutls.library.types
48
import ConfigParser as configparser
57
57
import logging.handlers
63
import cPickle as pickle
64
import multiprocessing
74
62
from dbus.mainloop.glib import DBusGMainLoop
77
import xml.dom.minidom
82
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
83
except AttributeError:
85
from IN import SO_BINDTODEVICE
87
SO_BINDTODEVICE = None
90
stored_state_file = "clients.pickle"
92
logger = logging.getLogger()
93
syslogger = (logging.handlers.SysLogHandler
94
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
95
address = str("/dev/log")))
98
if_nametoindex = (ctypes.cdll.LoadLibrary
99
(ctypes.util.find_library("c"))
101
except (OSError, AttributeError):
102
def if_nametoindex(interface):
103
"Get an interface index the hard way, i.e. using fcntl()"
104
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
105
with contextlib.closing(socket.socket()) as s:
106
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
107
struct.pack(str("16s16x"),
109
interface_index = struct.unpack(str("I"),
111
return interface_index
114
def initlogger(debug, level=logging.WARNING):
115
"""init logger and add loglevel"""
117
syslogger.setFormatter(logging.Formatter
118
('Mandos [%(process)d]: %(levelname)s:'
120
logger.addHandler(syslogger)
123
console = logging.StreamHandler()
124
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
128
logger.addHandler(console)
129
logger.setLevel(level)
132
class PGPError(Exception):
133
"""Exception if encryption/decryption fails"""
137
class PGPEngine(object):
138
"""A simple class for OpenPGP symmetric encryption & decryption"""
140
self.gnupg = GnuPGInterface.GnuPG()
141
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
142
self.gnupg = GnuPGInterface.GnuPG()
143
self.gnupg.options.meta_interactive = False
144
self.gnupg.options.homedir = self.tempdir
145
self.gnupg.options.extra_args.extend(['--force-mdc',
152
def __exit__ (self, exc_type, exc_value, traceback):
160
if self.tempdir is not None:
161
# Delete contents of tempdir
162
for root, dirs, files in os.walk(self.tempdir,
164
for filename in files:
165
os.remove(os.path.join(root, filename))
167
os.rmdir(os.path.join(root, dirname))
169
os.rmdir(self.tempdir)
172
def password_encode(self, password):
173
# Passphrase can not be empty and can not contain newlines or
174
# NUL bytes. So we prefix it and hex encode it.
175
return b"mandos" + binascii.hexlify(password)
177
def encrypt(self, data, password):
178
self.gnupg.passphrase = self.password_encode(password)
179
with open(os.devnull, "w") as devnull:
181
proc = self.gnupg.run(['--symmetric'],
182
create_fhs=['stdin', 'stdout'],
183
attach_fhs={'stderr': devnull})
184
with contextlib.closing(proc.handles['stdin']) as f:
186
with contextlib.closing(proc.handles['stdout']) as f:
187
ciphertext = f.read()
191
self.gnupg.passphrase = None
194
def decrypt(self, data, password):
195
self.gnupg.passphrase = self.password_encode(password)
196
with open(os.devnull, "w") as devnull:
198
proc = self.gnupg.run(['--decrypt'],
199
create_fhs=['stdin', 'stdout'],
200
attach_fhs={'stderr': devnull})
201
with contextlib.closing(proc.handles['stdin']) as f:
203
with contextlib.closing(proc.handles['stdout']) as f:
204
decrypted_plaintext = f.read()
208
self.gnupg.passphrase = None
209
return decrypted_plaintext
213
class AvahiError(Exception):
214
def __init__(self, value, *args, **kwargs):
216
super(AvahiError, self).__init__(value, *args, **kwargs)
217
def __unicode__(self):
218
return unicode(repr(self.value))
220
class AvahiServiceError(AvahiError):
223
class AvahiGroupError(AvahiError):
227
class AvahiService(object):
228
"""An Avahi (Zeroconf) service.
231
interface: integer; avahi.IF_UNSPEC or an interface index.
232
Used to optionally bind to the specified interface.
233
name: string; Example: 'Mandos'
234
type: string; Example: '_mandos._tcp'.
235
See <http://www.dns-sd.org/ServiceTypes.html>
236
port: integer; what port to announce
237
TXT: list of strings; TXT record for the service
238
domain: string; Domain to publish on, default to .local if empty.
239
host: string; Host to publish records for, default is localhost
240
max_renames: integer; maximum number of renames
241
rename_count: integer; counter so we only rename after collisions
242
a sensible number of times
243
group: D-Bus Entry Group
245
bus: dbus.SystemBus()
247
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
248
servicetype = None, port = None, TXT = None,
249
domain = "", host = "", max_renames = 32768,
250
protocol = avahi.PROTO_UNSPEC, bus = None):
251
self.interface = interface
253
self.type = servicetype
255
self.TXT = TXT if TXT is not None else []
258
self.rename_count = 0
259
self.max_renames = max_renames
260
self.protocol = protocol
261
self.group = None # our entry group
264
self.entry_group_state_changed_match = None
266
"""Derived from the Avahi example code"""
267
if self.rename_count >= self.max_renames:
268
logger.critical("No suitable Zeroconf service name found"
269
" after %i retries, exiting.",
271
raise AvahiServiceError("Too many renames")
272
self.name = unicode(self.server
273
.GetAlternativeServiceName(self.name))
274
logger.info("Changing Zeroconf service name to %r ...",
279
except dbus.exceptions.DBusException as error:
280
logger.critical("DBusException: %s", error)
283
self.rename_count += 1
285
"""Derived from the Avahi example code"""
286
if self.entry_group_state_changed_match is not None:
287
self.entry_group_state_changed_match.remove()
288
self.entry_group_state_changed_match = None
289
if self.group is not None:
292
"""Derived from the Avahi example code"""
294
if self.group is None:
295
self.group = dbus.Interface(
296
self.bus.get_object(avahi.DBUS_NAME,
297
self.server.EntryGroupNew()),
298
avahi.DBUS_INTERFACE_ENTRY_GROUP)
299
self.entry_group_state_changed_match = (
300
self.group.connect_to_signal(
301
'StateChanged', self.entry_group_state_changed))
302
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
303
self.name, self.type)
304
self.group.AddService(
307
dbus.UInt32(0), # flags
308
self.name, self.type,
309
self.domain, self.host,
310
dbus.UInt16(self.port),
311
avahi.string_array_to_txt_array(self.TXT))
313
def entry_group_state_changed(self, state, error):
314
"""Derived from the Avahi example code"""
315
logger.debug("Avahi entry group state change: %i", state)
317
if state == avahi.ENTRY_GROUP_ESTABLISHED:
318
logger.debug("Zeroconf service established.")
319
elif state == avahi.ENTRY_GROUP_COLLISION:
320
logger.info("Zeroconf service name collision.")
322
elif state == avahi.ENTRY_GROUP_FAILURE:
323
logger.critical("Avahi: Error in group state changed %s",
325
raise AvahiGroupError("State changed: %s"
328
"""Derived from the Avahi example code"""
329
if self.group is not None:
332
except (dbus.exceptions.UnknownMethodException,
333
dbus.exceptions.DBusException):
337
def server_state_changed(self, state, error=None):
338
"""Derived from the Avahi example code"""
339
logger.debug("Avahi server state change: %i", state)
340
bad_states = { avahi.SERVER_INVALID:
341
"Zeroconf server invalid",
342
avahi.SERVER_REGISTERING: None,
343
avahi.SERVER_COLLISION:
344
"Zeroconf server name collision",
345
avahi.SERVER_FAILURE:
346
"Zeroconf server failure" }
347
if state in bad_states:
348
if bad_states[state] is not None:
350
logger.error(bad_states[state])
352
logger.error(bad_states[state] + ": %r", error)
354
elif state == avahi.SERVER_RUNNING:
358
logger.debug("Unknown state: %r", state)
360
logger.debug("Unknown state: %r: %r", state, error)
362
"""Derived from the Avahi example code"""
363
if self.server is None:
364
self.server = dbus.Interface(
365
self.bus.get_object(avahi.DBUS_NAME,
366
avahi.DBUS_PATH_SERVER,
367
follow_name_owner_changes=True),
368
avahi.DBUS_INTERFACE_SERVER)
369
self.server.connect_to_signal("StateChanged",
370
self.server_state_changed)
371
self.server_state_changed(self.server.GetState())
373
class AvahiServiceToSyslog(AvahiService):
375
"""Add the new name to the syslog messages"""
376
ret = AvahiService.rename(self)
377
syslogger.setFormatter(logging.Formatter
378
('Mandos (%s) [%%(process)d]:'
379
' %%(levelname)s: %%(message)s'
383
def timedelta_to_milliseconds(td):
384
"Convert a datetime.timedelta() to milliseconds"
385
return ((td.days * 24 * 60 * 60 * 1000)
386
+ (td.seconds * 1000)
387
+ (td.microseconds // 1000))
65
# Brief description of the operation of this program:
67
# This server announces itself as a Zeroconf service. Connecting
68
# clients use the TLS protocol, with the unusual quirk that this
69
# server program acts as a TLS "client" while the connecting clients
70
# acts as a TLS "server". The clients (acting as a TLS "server") must
71
# supply an OpenPGP certificate, and the fingerprint of this
72
# certificate is used by this server to look up (in a list read from a
73
# file at start time) which binary blob to give the client. No other
74
# authentication or authorization is done by this server.
77
logger = logging.Logger('mandos')
78
syslogger = logging.handlers.SysLogHandler\
79
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
80
syslogger.setFormatter(logging.Formatter\
81
('%(levelname)s: %(message)s'))
82
logger.addHandler(syslogger)
85
# This variable is used to optionally bind to a specified interface.
86
# It is a global variable to fit in with the other variables from the
88
serviceInterface = avahi.IF_UNSPEC
89
# From the Avahi example code:
90
serviceName = "Mandos"
91
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
92
servicePort = None # Not known at startup
93
serviceTXT = [] # TXT record for the service
94
domain = "" # Domain to publish on, default to .local
95
host = "" # Host to publish records for, default to localhost
96
group = None #our entry group
97
rename_count = 12 # Counter so we only rename after collisions a
98
# sensible number of times
99
# End of Avahi example code
389
102
class Client(object):
390
103
"""A representation of a client host served by this server.
393
approved: bool(); 'None' if not yet approved/disapproved
394
approval_delay: datetime.timedelta(); Time to wait for approval
395
approval_duration: datetime.timedelta(); Duration of one approval
396
checker: subprocess.Popen(); a running checker process used
397
to see if the client lives.
398
'None' if no process is running.
399
checker_callback_tag: a gobject event source tag, or None
400
checker_command: string; External command which is run to check
401
if client lives. %() expansions are done at
105
name: string; from the config file, used in log messages
106
fingerprint: string (40 or 32 hexadecimal digits); used to
107
uniquely identify the client
108
secret: bytestring; sent verbatim (over TLS) to client
109
fqdn: string (FQDN); available for use by the checker command
110
created: datetime.datetime()
111
last_seen: datetime.datetime() or None if not yet seen
112
timeout: datetime.timedelta(); How long from last_seen until
113
this client is invalid
114
interval: datetime.timedelta(); How often to start a new checker
115
stop_hook: If set, called by stop() as stop_hook(self)
116
checker: subprocess.Popen(); a running checker process used
117
to see if the client lives.
118
Is None if no process is running.
119
checker_initiator_tag: a gobject event source tag, or None
120
stop_initiator_tag: - '' -
121
checker_callback_tag: - '' -
122
checker_command: string; External command which is run to check if
123
client lives. %()s expansions are done at
402
124
runtime with vars(self) as dict, so that for
403
125
instance %(name)s can be used in the command.
404
checker_initiator_tag: a gobject event source tag, or None
405
created: datetime.datetime(); (UTC) object creation
406
client_structure: Object describing what attributes a client has
407
and is used for storing the client at exit
408
current_checker_command: string; current running checker_command
409
disable_initiator_tag: a gobject event source tag, or None
411
fingerprint: string (40 or 32 hexadecimal digits); used to
412
uniquely identify the client
413
host: string; available for use by the checker command
414
interval: datetime.timedelta(); How often to start a new checker
415
last_approval_request: datetime.datetime(); (UTC) or None
416
last_checked_ok: datetime.datetime(); (UTC) or None
417
last_checker_status: integer between 0 and 255 reflecting exit
418
status of last checker. -1 reflects crashed
419
checker, -2 means no checker completed yet.
420
last_enabled: datetime.datetime(); (UTC) or None
421
name: string; from the config file, used in log messages and
423
secret: bytestring; sent verbatim (over TLS) to client
424
timeout: datetime.timedelta(); How long from last_checked_ok
425
until this client is disabled
426
extended_timeout: extra long timeout when secret has been sent
427
runtime_expansions: Allowed attributes for runtime expansion.
428
expires: datetime.datetime(); time (UTC) when a client will be
127
_timeout: Real variable for 'timeout'
128
_interval: Real variable for 'interval'
129
_timeout_milliseconds: Used by gobject.timeout_add()
130
_interval_milliseconds: - '' -
432
runtime_expansions = ("approval_delay", "approval_duration",
433
"created", "enabled", "fingerprint",
434
"host", "interval", "last_checked_ok",
435
"last_enabled", "name", "timeout")
436
client_defaults = { "timeout": "5m",
437
"extended_timeout": "15m",
439
"checker": "fping -q -- %%(host)s",
441
"approval_delay": "0s",
442
"approval_duration": "1s",
443
"approved_by_default": "True",
447
def timeout_milliseconds(self):
448
"Return the 'timeout' attribute in milliseconds"
449
return timedelta_to_milliseconds(self.timeout)
451
def extended_timeout_milliseconds(self):
452
"Return the 'extended_timeout' attribute in milliseconds"
453
return timedelta_to_milliseconds(self.extended_timeout)
455
def interval_milliseconds(self):
456
"Return the 'interval' attribute in milliseconds"
457
return timedelta_to_milliseconds(self.interval)
459
def approval_delay_milliseconds(self):
460
return timedelta_to_milliseconds(self.approval_delay)
463
def config_parser(config):
464
"""Construct a new dict of client settings of this form:
465
{ client_name: {setting_name: value, ...}, ...}
466
with exceptions for any special settings as defined above.
467
NOTE: Must be a pure function. Must return the same result
468
value given the same arguments.
471
for client_name in config.sections():
472
section = dict(config.items(client_name))
473
client = settings[client_name] = {}
475
client["host"] = section["host"]
476
# Reformat values from string types to Python types
477
client["approved_by_default"] = config.getboolean(
478
client_name, "approved_by_default")
479
client["enabled"] = config.getboolean(client_name,
482
client["fingerprint"] = (section["fingerprint"].upper()
484
if "secret" in section:
485
client["secret"] = section["secret"].decode("base64")
486
elif "secfile" in section:
487
with open(os.path.expanduser(os.path.expandvars
488
(section["secfile"])),
490
client["secret"] = secfile.read()
492
raise TypeError("No secret or secfile for section %s"
494
client["timeout"] = string_to_delta(section["timeout"])
495
client["extended_timeout"] = string_to_delta(
496
section["extended_timeout"])
497
client["interval"] = string_to_delta(section["interval"])
498
client["approval_delay"] = string_to_delta(
499
section["approval_delay"])
500
client["approval_duration"] = string_to_delta(
501
section["approval_duration"])
502
client["checker_command"] = section["checker"]
503
client["last_approval_request"] = None
504
client["last_checked_ok"] = None
505
client["last_checker_status"] = -2
510
def __init__(self, settings, name = None):
511
"""Note: the 'checker' key in 'config' sets the
512
'checker_command' attribute and *not* the 'checker'
132
def _set_timeout(self, timeout):
133
"Setter function for 'timeout' attribute"
134
self._timeout = timeout
135
self._timeout_milliseconds = ((self.timeout.days
136
* 24 * 60 * 60 * 1000)
137
+ (self.timeout.seconds * 1000)
138
+ (self.timeout.microseconds
140
timeout = property(lambda self: self._timeout,
143
def _set_interval(self, interval):
144
"Setter function for 'interval' attribute"
145
self._interval = interval
146
self._interval_milliseconds = ((self.interval.days
147
* 24 * 60 * 60 * 1000)
148
+ (self.interval.seconds
150
+ (self.interval.microseconds
152
interval = property(lambda self: self._interval,
155
def __init__(self, name=None, options=None, stop_hook=None,
156
fingerprint=None, secret=None, secfile=None,
157
fqdn=None, timeout=None, interval=-1, checker=None):
158
"""Note: the 'checker' argument sets the 'checker_command'
159
attribute and not the 'checker' attribute.."""
515
# adding all client settings
516
for setting, value in settings.iteritems():
517
setattr(self, setting, value)
520
if not hasattr(self, "last_enabled"):
521
self.last_enabled = datetime.datetime.utcnow()
522
if not hasattr(self, "expires"):
523
self.expires = (datetime.datetime.utcnow()
526
self.last_enabled = None
529
logger.debug("Creating client %r", self.name)
530
# Uppercase and remove spaces from fingerprint for later
531
# comparison purposes with return value from the fingerprint()
533
logger.debug(" Fingerprint: %s", self.fingerprint)
534
self.created = settings.get("created",
535
datetime.datetime.utcnow())
537
# attributes specific for this server instance
161
# Uppercase and remove spaces from fingerprint
162
# for later comparison purposes with return value of
163
# the fingerprint() function
164
self.fingerprint = fingerprint.upper().replace(u" ", u"")
166
self.secret = secret.decode(u"base64")
169
self.secret = sf.read()
172
raise RuntimeError(u"No secret or secfile for client %s"
174
self.fqdn = fqdn # string
175
self.created = datetime.datetime.now()
176
self.last_seen = None
178
self.timeout = options.timeout
180
self.timeout = string_to_delta(timeout)
182
self.interval = options.interval
184
self.interval = string_to_delta(interval)
185
self.stop_hook = stop_hook
538
186
self.checker = None
539
187
self.checker_initiator_tag = None
540
self.disable_initiator_tag = None
188
self.stop_initiator_tag = None
541
189
self.checker_callback_tag = None
542
self.current_checker_command = None
544
self.approvals_pending = 0
545
self.changedstate = (multiprocessing_manager
546
.Condition(multiprocessing_manager
548
self.client_structure = [attr for attr in
549
self.__dict__.iterkeys()
550
if not attr.startswith("_")]
551
self.client_structure.append("client_structure")
553
for name, t in inspect.getmembers(type(self),
557
if not name.startswith("_"):
558
self.client_structure.append(name)
560
# Send notice to process children that client state has changed
561
def send_changedstate(self):
562
with self.changedstate:
563
self.changedstate.notify_all()
190
self.check_command = checker
566
192
"""Start this client's checker and timeout hooks"""
567
if getattr(self, "enabled", False):
570
self.send_changedstate()
571
self.expires = datetime.datetime.utcnow() + self.timeout
573
self.last_enabled = datetime.datetime.utcnow()
576
def disable(self, quiet=True):
577
"""Disable this client."""
578
if not getattr(self, "enabled", False):
581
self.send_changedstate()
583
logger.info("Disabling client %s", self.name)
584
if getattr(self, "disable_initiator_tag", False):
585
gobject.source_remove(self.disable_initiator_tag)
586
self.disable_initiator_tag = None
588
if getattr(self, "checker_initiator_tag", False):
589
gobject.source_remove(self.checker_initiator_tag)
590
self.checker_initiator_tag = None
593
# Do not run this again if called by a gobject.timeout_add
599
def init_checker(self):
600
193
# Schedule a new checker to be started an 'interval' from now,
601
194
# and every interval from then on.
602
self.checker_initiator_tag = (gobject.timeout_add
603
(self.interval_milliseconds(),
605
# Schedule a disable() when 'timeout' has passed
606
self.disable_initiator_tag = (gobject.timeout_add
607
(self.timeout_milliseconds(),
195
self.checker_initiator_tag = gobject.timeout_add\
196
(self._interval_milliseconds,
609
198
# Also start a new checker *right now*.
610
199
self.start_checker()
612
def checker_callback(self, pid, condition, command):
200
# Schedule a stop() when 'timeout' has passed
201
self.stop_initiator_tag = gobject.timeout_add\
202
(self._timeout_milliseconds,
206
The possibility that this client might be restarted is left
207
open, but not currently used."""
208
# If this client doesn't have a secret, it is already stopped.
210
logger.debug(u"Stopping client %s", self.name)
214
if hasattr(self, "stop_initiator_tag") \
215
and self.stop_initiator_tag:
216
gobject.source_remove(self.stop_initiator_tag)
217
self.stop_initiator_tag = None
218
if hasattr(self, "checker_initiator_tag") \
219
and self.checker_initiator_tag:
220
gobject.source_remove(self.checker_initiator_tag)
221
self.checker_initiator_tag = None
225
# Do not run this again if called by a gobject.timeout_add
228
self.stop_hook = None
230
def checker_callback(self, pid, condition):
613
231
"""The checker has completed, so take appropriate actions."""
232
now = datetime.datetime.now()
614
233
self.checker_callback_tag = None
615
234
self.checker = None
616
if os.WIFEXITED(condition):
617
self.last_checker_status = os.WEXITSTATUS(condition)
618
if self.last_checker_status == 0:
619
logger.info("Checker for %(name)s succeeded",
623
logger.info("Checker for %(name)s failed",
626
self.last_checker_status = -1
627
logger.warning("Checker for %(name)s crashed?",
235
if os.WIFEXITED(condition) \
236
and (os.WEXITSTATUS(condition) == 0):
237
logger.debug(u"Checker for %(name)s succeeded",
240
gobject.source_remove(self.stop_initiator_tag)
241
self.stop_initiator_tag = gobject.timeout_add\
242
(self._timeout_milliseconds,
244
elif not os.WIFEXITED(condition):
245
logger.warning(u"Checker for %(name)s crashed?",
630
def checked_ok(self):
631
"""Assert that the client has been seen, alive and well."""
632
self.last_checked_ok = datetime.datetime.utcnow()
633
self.last_checker_status = 0
636
def bump_timeout(self, timeout=None):
637
"""Bump up the timeout for this client."""
639
timeout = self.timeout
640
if self.disable_initiator_tag is not None:
641
gobject.source_remove(self.disable_initiator_tag)
642
if getattr(self, "enabled", False):
643
self.disable_initiator_tag = (gobject.timeout_add
644
(timedelta_to_milliseconds
645
(timeout), self.disable))
646
self.expires = datetime.datetime.utcnow() + timeout
648
def need_approval(self):
649
self.last_approval_request = datetime.datetime.utcnow()
248
logger.debug(u"Checker for %(name)s failed",
651
250
def start_checker(self):
652
251
"""Start a new checker subprocess if one is not running.
654
252
If a checker already exists, leave it running and do
656
254
# The reason for not killing a running checker is that if we
659
257
# client would inevitably timeout, since no checker would get
660
258
# a chance to run to completion. If we instead leave running
661
259
# checkers alone, the checker would have to take more time
662
# than 'timeout' for the client to be disabled, which is as it
665
# If a checker exists, make sure it is not a zombie
667
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
668
except (AttributeError, OSError) as error:
669
if (isinstance(error, OSError)
670
and error.errno != errno.ECHILD):
674
logger.warning("Checker was a zombie")
675
gobject.source_remove(self.checker_callback_tag)
676
self.checker_callback(pid, status,
677
self.current_checker_command)
678
# Start a new checker if needed
260
# than 'timeout' for the client to be declared invalid, which
261
# is as it should be.
679
262
if self.checker is None:
681
# In case checker_command has exactly one % operator
682
command = self.checker_command % self.host
264
command = self.check_command % self.fqdn
683
265
except TypeError:
684
# Escape attributes for the shell
685
escaped_attrs = dict(
687
re.escape(unicode(str(getattr(self, attr, "")),
691
self.runtime_expansions)
266
escaped_attrs = dict((key, re.escape(str(val)))
268
vars(self).iteritems())
694
command = self.checker_command % escaped_attrs
695
except TypeError as error:
696
logger.error('Could not format string "%s":'
697
' %s', self.checker_command, error)
270
command = self.check_command % escaped_attrs
271
except TypeError, error:
272
logger.critical(u'Could not format string "%s":'
273
u' %s', self.check_command, error)
698
274
return True # Try again later
699
self.current_checker_command = command
701
logger.info("Starting checker %r for %s",
703
# We don't need to redirect stdout and stderr, since
704
# in normal mode, that is already done by daemon(),
705
# and in debug mode we don't want to. (Stdin is
706
# always replaced by /dev/null.)
707
self.checker = subprocess.Popen(command,
710
self.checker_callback_tag = (gobject.child_watch_add
712
self.checker_callback,
714
# The checker may have completed before the gobject
715
# watch was added. Check for this.
716
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
718
gobject.source_remove(self.checker_callback_tag)
719
self.checker_callback(pid, status, command)
720
except OSError as error:
721
logger.error("Failed to start subprocess: %s",
276
logger.debug(u"Starting checker %r for %s",
278
self.checker = subprocess.\
280
close_fds=True, shell=True,
282
self.checker_callback_tag = gobject.child_watch_add\
284
self.checker_callback)
285
except subprocess.OSError, error:
286
logger.error(u"Failed to start subprocess: %s",
723
288
# Re-run this periodically if run by gobject.timeout_add
726
290
def stop_checker(self):
727
291
"""Force the checker process, if any, to stop."""
728
292
if self.checker_callback_tag:
729
293
gobject.source_remove(self.checker_callback_tag)
730
294
self.checker_callback_tag = None
731
if getattr(self, "checker", None) is None:
295
if not hasattr(self, "checker") or self.checker is None:
733
297
logger.debug("Stopping checker for %(name)s", vars(self))
735
299
os.kill(self.checker.pid, signal.SIGTERM)
737
301
#if self.checker.poll() is None:
738
302
# os.kill(self.checker.pid, signal.SIGKILL)
739
except OSError as error:
740
if error.errno != errno.ESRCH: # No such process
303
except OSError, error:
304
if error.errno != errno.ESRCH:
742
306
self.checker = None
745
def dbus_service_property(dbus_interface, signature="v",
746
access="readwrite", byte_arrays=False):
747
"""Decorators for marking methods of a DBusObjectWithProperties to
748
become properties on the D-Bus.
750
The decorated method will be called with no arguments by "Get"
751
and with one argument by "Set".
753
The parameters, where they are supported, are the same as
754
dbus.service.method, except there is only "signature", since the
755
type from Get() and the type sent to Set() is the same.
757
# Encoding deeply encoded byte arrays is not supported yet by the
758
# "Set" method, so we fail early here:
759
if byte_arrays and signature != "ay":
760
raise ValueError("Byte arrays not supported for non-'ay'"
761
" signature %r" % signature)
763
func._dbus_is_property = True
764
func._dbus_interface = dbus_interface
765
func._dbus_signature = signature
766
func._dbus_access = access
767
func._dbus_name = func.__name__
768
if func._dbus_name.endswith("_dbus_property"):
769
func._dbus_name = func._dbus_name[:-14]
770
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
775
def dbus_interface_annotations(dbus_interface):
776
"""Decorator for marking functions returning interface annotations.
780
@dbus_interface_annotations("org.example.Interface")
781
def _foo(self): # Function name does not matter
782
return {"org.freedesktop.DBus.Deprecated": "true",
783
"org.freedesktop.DBus.Property.EmitsChangedSignal":
787
func._dbus_is_interface = True
788
func._dbus_interface = dbus_interface
789
func._dbus_name = dbus_interface
794
class DBusPropertyException(dbus.exceptions.DBusException):
795
"""A base class for D-Bus property-related exceptions
797
def __unicode__(self):
798
return unicode(str(self))
801
class DBusPropertyAccessException(DBusPropertyException):
802
"""A property's access permissions disallows an operation.
807
class DBusPropertyNotFound(DBusPropertyException):
808
"""An attempt was made to access a non-existing property.
813
class DBusObjectWithProperties(dbus.service.Object):
814
"""A D-Bus object with properties.
816
Classes inheriting from this can use the dbus_service_property
817
decorator to expose methods as D-Bus properties. It exposes the
818
standard Get(), Set(), and GetAll() methods on the D-Bus.
822
def _is_dbus_thing(thing):
823
"""Returns a function testing if an attribute is a D-Bus thing
825
If called like _is_dbus_thing("method") it returns a function
826
suitable for use as predicate to inspect.getmembers().
828
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
831
def _get_all_dbus_things(self, thing):
832
"""Returns a generator of (name, attribute) pairs
834
return ((athing.__get__(self)._dbus_name,
835
athing.__get__(self))
836
for cls in self.__class__.__mro__
838
inspect.getmembers(cls,
839
self._is_dbus_thing(thing)))
841
def _get_dbus_property(self, interface_name, property_name):
842
"""Returns a bound method if one exists which is a D-Bus
843
property with the specified name and interface.
845
for cls in self.__class__.__mro__:
846
for name, value in (inspect.getmembers
848
self._is_dbus_thing("property"))):
849
if (value._dbus_name == property_name
850
and value._dbus_interface == interface_name):
851
return value.__get__(self)
854
raise DBusPropertyNotFound(self.dbus_object_path + ":"
855
+ interface_name + "."
858
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
860
def Get(self, interface_name, property_name):
861
"""Standard D-Bus property Get() method, see D-Bus standard.
863
prop = self._get_dbus_property(interface_name, property_name)
864
if prop._dbus_access == "write":
865
raise DBusPropertyAccessException(property_name)
867
if not hasattr(value, "variant_level"):
869
return type(value)(value, variant_level=value.variant_level+1)
871
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
872
def Set(self, interface_name, property_name, value):
873
"""Standard D-Bus property Set() method, see D-Bus standard.
875
prop = self._get_dbus_property(interface_name, property_name)
876
if prop._dbus_access == "read":
877
raise DBusPropertyAccessException(property_name)
878
if prop._dbus_get_args_options["byte_arrays"]:
879
# The byte_arrays option is not supported yet on
880
# signatures other than "ay".
881
if prop._dbus_signature != "ay":
883
value = dbus.ByteArray(b''.join(chr(byte)
887
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
888
out_signature="a{sv}")
889
def GetAll(self, interface_name):
890
"""Standard D-Bus property GetAll() method, see D-Bus
893
Note: Will not include properties with access="write".
896
for name, prop in self._get_all_dbus_things("property"):
898
and interface_name != prop._dbus_interface):
899
# Interface non-empty but did not match
901
# Ignore write-only properties
902
if prop._dbus_access == "write":
905
if not hasattr(value, "variant_level"):
906
properties[name] = value
908
properties[name] = type(value)(value, variant_level=
909
value.variant_level+1)
910
return dbus.Dictionary(properties, signature="sv")
912
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
914
path_keyword='object_path',
915
connection_keyword='connection')
916
def Introspect(self, object_path, connection):
917
"""Overloading of standard D-Bus method.
919
Inserts property tags and interface annotation tags.
921
xmlstring = dbus.service.Object.Introspect(self, object_path,
924
document = xml.dom.minidom.parseString(xmlstring)
925
def make_tag(document, name, prop):
926
e = document.createElement("property")
927
e.setAttribute("name", name)
928
e.setAttribute("type", prop._dbus_signature)
929
e.setAttribute("access", prop._dbus_access)
931
for if_tag in document.getElementsByTagName("interface"):
933
for tag in (make_tag(document, name, prop)
935
in self._get_all_dbus_things("property")
936
if prop._dbus_interface
937
== if_tag.getAttribute("name")):
938
if_tag.appendChild(tag)
939
# Add interface annotation tags
940
for annotation, value in dict(
942
*(annotations().iteritems()
943
for name, annotations in
944
self._get_all_dbus_things("interface")
945
if name == if_tag.getAttribute("name")
947
attr_tag = document.createElement("annotation")
948
attr_tag.setAttribute("name", annotation)
949
attr_tag.setAttribute("value", value)
950
if_tag.appendChild(attr_tag)
951
# Add the names to the return values for the
952
# "org.freedesktop.DBus.Properties" methods
953
if (if_tag.getAttribute("name")
954
== "org.freedesktop.DBus.Properties"):
955
for cn in if_tag.getElementsByTagName("method"):
956
if cn.getAttribute("name") == "Get":
957
for arg in cn.getElementsByTagName("arg"):
958
if (arg.getAttribute("direction")
960
arg.setAttribute("name", "value")
961
elif cn.getAttribute("name") == "GetAll":
962
for arg in cn.getElementsByTagName("arg"):
963
if (arg.getAttribute("direction")
965
arg.setAttribute("name", "props")
966
xmlstring = document.toxml("utf-8")
968
except (AttributeError, xml.dom.DOMException,
969
xml.parsers.expat.ExpatError) as error:
970
logger.error("Failed to override Introspection method",
975
def datetime_to_dbus (dt, variant_level=0):
976
"""Convert a UTC datetime.datetime() to a D-Bus type."""
978
return dbus.String("", variant_level = variant_level)
979
return dbus.String(dt.isoformat(),
980
variant_level=variant_level)
983
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
985
"""Applied to an empty subclass of a D-Bus object, this metaclass
986
will add additional D-Bus attributes matching a certain pattern.
988
def __new__(mcs, name, bases, attr):
989
# Go through all the base classes which could have D-Bus
990
# methods, signals, or properties in them
991
old_interface_names = []
992
for base in (b for b in bases
993
if issubclass(b, dbus.service.Object)):
994
# Go though all attributes of the base class
995
for attrname, attribute in inspect.getmembers(base):
996
# Ignore non-D-Bus attributes, and D-Bus attributes
997
# with the wrong interface name
998
if (not hasattr(attribute, "_dbus_interface")
999
or not attribute._dbus_interface
1000
.startswith("se.recompile.Mandos")):
1002
# Create an alternate D-Bus interface name based on
1004
alt_interface = (attribute._dbus_interface
1005
.replace("se.recompile.Mandos",
1006
"se.bsnet.fukt.Mandos"))
1007
if alt_interface != attribute._dbus_interface:
1008
old_interface_names.append(alt_interface)
1009
# Is this a D-Bus signal?
1010
if getattr(attribute, "_dbus_is_signal", False):
1011
# Extract the original non-method function by
1013
nonmethod_func = (dict(
1014
zip(attribute.func_code.co_freevars,
1015
attribute.__closure__))["func"]
1017
# Create a new, but exactly alike, function
1018
# object, and decorate it to be a new D-Bus signal
1019
# with the alternate D-Bus interface name
1020
new_function = (dbus.service.signal
1022
attribute._dbus_signature)
1023
(types.FunctionType(
1024
nonmethod_func.func_code,
1025
nonmethod_func.func_globals,
1026
nonmethod_func.func_name,
1027
nonmethod_func.func_defaults,
1028
nonmethod_func.func_closure)))
1029
# Define a creator of a function to call both the
1030
# old and new functions, so both the old and new
1031
# signals gets sent when the function is called
1032
def fixscope(func1, func2):
1033
"""This function is a scope container to pass
1034
func1 and func2 to the "call_both" function
1035
outside of its arguments"""
1036
def call_both(*args, **kwargs):
1037
"""This function will emit two D-Bus
1038
signals by calling func1 and func2"""
1039
func1(*args, **kwargs)
1040
func2(*args, **kwargs)
1042
# Create the "call_both" function and add it to
1044
attr[attrname] = fixscope(attribute,
1046
# Is this a D-Bus method?
1047
elif getattr(attribute, "_dbus_is_method", False):
1048
# Create a new, but exactly alike, function
1049
# object. Decorate it to be a new D-Bus method
1050
# with the alternate D-Bus interface name. Add it
1052
attr[attrname] = (dbus.service.method
1054
attribute._dbus_in_signature,
1055
attribute._dbus_out_signature)
1057
(attribute.func_code,
1058
attribute.func_globals,
1059
attribute.func_name,
1060
attribute.func_defaults,
1061
attribute.func_closure)))
1062
# Is this a D-Bus property?
1063
elif getattr(attribute, "_dbus_is_property", False):
1064
# Create a new, but exactly alike, function
1065
# object, and decorate it to be a new D-Bus
1066
# property with the alternate D-Bus interface
1067
# name. Add it to the class.
1068
attr[attrname] = (dbus_service_property
1070
attribute._dbus_signature,
1071
attribute._dbus_access,
1073
._dbus_get_args_options
1076
(attribute.func_code,
1077
attribute.func_globals,
1078
attribute.func_name,
1079
attribute.func_defaults,
1080
attribute.func_closure)))
1081
# Is this a D-Bus interface?
1082
elif getattr(attribute, "_dbus_is_interface", False):
1083
# Create a new, but exactly alike, function
1084
# object. Decorate it to be a new D-Bus interface
1085
# with the alternate D-Bus interface name. Add it
1087
attr[attrname] = (dbus_interface_annotations
1090
(attribute.func_code,
1091
attribute.func_globals,
1092
attribute.func_name,
1093
attribute.func_defaults,
1094
attribute.func_closure)))
1095
# Deprecate all old interfaces
1096
basename="_AlternateDBusNamesMetaclass_interface_annotation{0}"
1097
for old_interface_name in old_interface_names:
1098
@dbus_interface_annotations(old_interface_name)
1100
return { "org.freedesktop.DBus.Deprecated": "true" }
1101
# Find an unused name
1102
for aname in (basename.format(i) for i in
1104
if aname not in attr:
1107
return type.__new__(mcs, name, bases, attr)
1110
class ClientDBus(Client, DBusObjectWithProperties):
1111
"""A Client class using D-Bus
1114
dbus_object_path: dbus.ObjectPath
1115
bus: dbus.SystemBus()
1118
runtime_expansions = (Client.runtime_expansions
1119
+ ("dbus_object_path",))
1121
# dbus.service.Object doesn't use super(), so we can't either.
1123
def __init__(self, bus = None, *args, **kwargs):
1125
Client.__init__(self, *args, **kwargs)
1126
# Only now, when this client is initialized, can it show up on
1128
client_object_name = unicode(self.name).translate(
1129
{ord("."): ord("_"),
1130
ord("-"): ord("_")})
1131
self.dbus_object_path = (dbus.ObjectPath
1132
("/clients/" + client_object_name))
1133
DBusObjectWithProperties.__init__(self, self.bus,
1134
self.dbus_object_path)
1136
def notifychangeproperty(transform_func,
1137
dbus_name, type_func=lambda x: x,
1139
""" Modify a variable so that it's a property which announces
1140
its changes to DBus.
1142
transform_fun: Function that takes a value and a variant_level
1143
and transforms it to a D-Bus type.
1144
dbus_name: D-Bus name of the variable
1145
type_func: Function that transform the value before sending it
1146
to the D-Bus. Default: no transform
1147
variant_level: D-Bus variant level. Default: 1
1149
attrname = "_{0}".format(dbus_name)
1150
def setter(self, value):
1151
if hasattr(self, "dbus_object_path"):
1152
if (not hasattr(self, attrname) or
1153
type_func(getattr(self, attrname, None))
1154
!= type_func(value)):
1155
dbus_value = transform_func(type_func(value),
1158
self.PropertyChanged(dbus.String(dbus_name),
1160
setattr(self, attrname, value)
1162
return property(lambda self: getattr(self, attrname), setter)
1165
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1166
approvals_pending = notifychangeproperty(dbus.Boolean,
1169
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1170
last_enabled = notifychangeproperty(datetime_to_dbus,
1172
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1173
type_func = lambda checker:
1174
checker is not None)
1175
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1177
last_checker_status = notifychangeproperty(dbus.Int16,
1178
"LastCheckerStatus")
1179
last_approval_request = notifychangeproperty(
1180
datetime_to_dbus, "LastApprovalRequest")
1181
approved_by_default = notifychangeproperty(dbus.Boolean,
1182
"ApprovedByDefault")
1183
approval_delay = notifychangeproperty(dbus.UInt64,
1186
timedelta_to_milliseconds)
1187
approval_duration = notifychangeproperty(
1188
dbus.UInt64, "ApprovalDuration",
1189
type_func = timedelta_to_milliseconds)
1190
host = notifychangeproperty(dbus.String, "Host")
1191
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1193
timedelta_to_milliseconds)
1194
extended_timeout = notifychangeproperty(
1195
dbus.UInt64, "ExtendedTimeout",
1196
type_func = timedelta_to_milliseconds)
1197
interval = notifychangeproperty(dbus.UInt64,
1200
timedelta_to_milliseconds)
1201
checker_command = notifychangeproperty(dbus.String, "Checker")
1203
del notifychangeproperty
1205
def __del__(self, *args, **kwargs):
1207
self.remove_from_connection()
1210
if hasattr(DBusObjectWithProperties, "__del__"):
1211
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1212
Client.__del__(self, *args, **kwargs)
1214
def checker_callback(self, pid, condition, command,
1216
self.checker_callback_tag = None
1218
if os.WIFEXITED(condition):
1219
exitstatus = os.WEXITSTATUS(condition)
1221
self.CheckerCompleted(dbus.Int16(exitstatus),
1222
dbus.Int64(condition),
1223
dbus.String(command))
1226
self.CheckerCompleted(dbus.Int16(-1),
1227
dbus.Int64(condition),
1228
dbus.String(command))
1230
return Client.checker_callback(self, pid, condition, command,
1233
def start_checker(self, *args, **kwargs):
1234
old_checker = self.checker
1235
if self.checker is not None:
1236
old_checker_pid = self.checker.pid
1238
old_checker_pid = None
1239
r = Client.start_checker(self, *args, **kwargs)
1240
# Only if new checker process was started
1241
if (self.checker is not None
1242
and old_checker_pid != self.checker.pid):
1244
self.CheckerStarted(self.current_checker_command)
1247
def _reset_approved(self):
1248
self.approved = None
1251
def approve(self, value=True):
1252
self.send_changedstate()
1253
self.approved = value
1254
gobject.timeout_add(timedelta_to_milliseconds
1255
(self.approval_duration),
1256
self._reset_approved)
1259
## D-Bus methods, signals & properties
1260
_interface = "se.recompile.Mandos.Client"
1264
@dbus_interface_annotations(_interface)
1266
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1271
# CheckerCompleted - signal
1272
@dbus.service.signal(_interface, signature="nxs")
1273
def CheckerCompleted(self, exitcode, waitstatus, command):
1277
# CheckerStarted - signal
1278
@dbus.service.signal(_interface, signature="s")
1279
def CheckerStarted(self, command):
1283
# PropertyChanged - signal
1284
@dbus.service.signal(_interface, signature="sv")
1285
def PropertyChanged(self, property, value):
1289
# GotSecret - signal
1290
@dbus.service.signal(_interface)
1291
def GotSecret(self):
1293
Is sent after a successful transfer of secret from the Mandos
1294
server to mandos-client
1299
@dbus.service.signal(_interface, signature="s")
1300
def Rejected(self, reason):
1304
# NeedApproval - signal
1305
@dbus.service.signal(_interface, signature="tb")
1306
def NeedApproval(self, timeout, default):
1308
return self.need_approval()
1313
@dbus.service.method(_interface, in_signature="b")
1314
def Approve(self, value):
1317
# CheckedOK - method
1318
@dbus.service.method(_interface)
1319
def CheckedOK(self):
1323
@dbus.service.method(_interface)
1328
# StartChecker - method
1329
@dbus.service.method(_interface)
1330
def StartChecker(self):
1332
self.start_checker()
1335
@dbus.service.method(_interface)
1340
# StopChecker - method
1341
@dbus.service.method(_interface)
1342
def StopChecker(self):
1347
# ApprovalPending - property
1348
@dbus_service_property(_interface, signature="b", access="read")
1349
def ApprovalPending_dbus_property(self):
1350
return dbus.Boolean(bool(self.approvals_pending))
1352
# ApprovedByDefault - property
1353
@dbus_service_property(_interface, signature="b",
1355
def ApprovedByDefault_dbus_property(self, value=None):
1356
if value is None: # get
1357
return dbus.Boolean(self.approved_by_default)
1358
self.approved_by_default = bool(value)
1360
# ApprovalDelay - property
1361
@dbus_service_property(_interface, signature="t",
1363
def ApprovalDelay_dbus_property(self, value=None):
1364
if value is None: # get
1365
return dbus.UInt64(self.approval_delay_milliseconds())
1366
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1368
# ApprovalDuration - property
1369
@dbus_service_property(_interface, signature="t",
1371
def ApprovalDuration_dbus_property(self, value=None):
1372
if value is None: # get
1373
return dbus.UInt64(timedelta_to_milliseconds(
1374
self.approval_duration))
1375
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1378
@dbus_service_property(_interface, signature="s", access="read")
1379
def Name_dbus_property(self):
1380
return dbus.String(self.name)
1382
# Fingerprint - property
1383
@dbus_service_property(_interface, signature="s", access="read")
1384
def Fingerprint_dbus_property(self):
1385
return dbus.String(self.fingerprint)
1388
@dbus_service_property(_interface, signature="s",
1390
def Host_dbus_property(self, value=None):
1391
if value is None: # get
1392
return dbus.String(self.host)
1393
self.host = unicode(value)
1395
# Created - property
1396
@dbus_service_property(_interface, signature="s", access="read")
1397
def Created_dbus_property(self):
1398
return datetime_to_dbus(self.created)
1400
# LastEnabled - property
1401
@dbus_service_property(_interface, signature="s", access="read")
1402
def LastEnabled_dbus_property(self):
1403
return datetime_to_dbus(self.last_enabled)
1405
# Enabled - property
1406
@dbus_service_property(_interface, signature="b",
1408
def Enabled_dbus_property(self, value=None):
1409
if value is None: # get
1410
return dbus.Boolean(self.enabled)
1416
# LastCheckedOK - property
1417
@dbus_service_property(_interface, signature="s",
1419
def LastCheckedOK_dbus_property(self, value=None):
1420
if value is not None:
1423
return datetime_to_dbus(self.last_checked_ok)
1425
# LastCheckerStatus - property
1426
@dbus_service_property(_interface, signature="n",
1428
def LastCheckerStatus_dbus_property(self):
1429
return dbus.Int16(self.last_checker_status)
1431
# Expires - property
1432
@dbus_service_property(_interface, signature="s", access="read")
1433
def Expires_dbus_property(self):
1434
return datetime_to_dbus(self.expires)
1436
# LastApprovalRequest - property
1437
@dbus_service_property(_interface, signature="s", access="read")
1438
def LastApprovalRequest_dbus_property(self):
1439
return datetime_to_dbus(self.last_approval_request)
1441
# Timeout - property
1442
@dbus_service_property(_interface, signature="t",
1444
def Timeout_dbus_property(self, value=None):
1445
if value is None: # get
1446
return dbus.UInt64(self.timeout_milliseconds())
1447
self.timeout = datetime.timedelta(0, 0, 0, value)
1448
# Reschedule timeout
1450
now = datetime.datetime.utcnow()
1451
time_to_die = timedelta_to_milliseconds(
1452
(self.last_checked_ok + self.timeout) - now)
1453
if time_to_die <= 0:
1454
# The timeout has passed
1457
self.expires = (now +
1458
datetime.timedelta(milliseconds =
1460
if (getattr(self, "disable_initiator_tag", None)
1463
gobject.source_remove(self.disable_initiator_tag)
1464
self.disable_initiator_tag = (gobject.timeout_add
1468
# ExtendedTimeout - property
1469
@dbus_service_property(_interface, signature="t",
1471
def ExtendedTimeout_dbus_property(self, value=None):
1472
if value is None: # get
1473
return dbus.UInt64(self.extended_timeout_milliseconds())
1474
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1476
# Interval - property
1477
@dbus_service_property(_interface, signature="t",
1479
def Interval_dbus_property(self, value=None):
1480
if value is None: # get
1481
return dbus.UInt64(self.interval_milliseconds())
1482
self.interval = datetime.timedelta(0, 0, 0, value)
1483
if getattr(self, "checker_initiator_tag", None) is None:
1486
# Reschedule checker run
1487
gobject.source_remove(self.checker_initiator_tag)
1488
self.checker_initiator_tag = (gobject.timeout_add
1489
(value, self.start_checker))
1490
self.start_checker() # Start one now, too
1492
# Checker - property
1493
@dbus_service_property(_interface, signature="s",
1495
def Checker_dbus_property(self, value=None):
1496
if value is None: # get
1497
return dbus.String(self.checker_command)
1498
self.checker_command = unicode(value)
1500
# CheckerRunning - property
1501
@dbus_service_property(_interface, signature="b",
1503
def CheckerRunning_dbus_property(self, value=None):
1504
if value is None: # get
1505
return dbus.Boolean(self.checker is not None)
1507
self.start_checker()
1511
# ObjectPath - property
1512
@dbus_service_property(_interface, signature="o", access="read")
1513
def ObjectPath_dbus_property(self):
1514
return self.dbus_object_path # is already a dbus.ObjectPath
1517
@dbus_service_property(_interface, signature="ay",
1518
access="write", byte_arrays=True)
1519
def Secret_dbus_property(self, value):
1520
self.secret = str(value)
1525
class ProxyClient(object):
1526
def __init__(self, child_pipe, fpr, address):
1527
self._pipe = child_pipe
1528
self._pipe.send(('init', fpr, address))
1529
if not self._pipe.recv():
1532
def __getattribute__(self, name):
1534
return super(ProxyClient, self).__getattribute__(name)
1535
self._pipe.send(('getattr', name))
1536
data = self._pipe.recv()
1537
if data[0] == 'data':
1539
if data[0] == 'function':
1540
def func(*args, **kwargs):
1541
self._pipe.send(('funcall', name, args, kwargs))
1542
return self._pipe.recv()[1]
1545
def __setattr__(self, name, value):
1547
return super(ProxyClient, self).__setattr__(name, value)
1548
self._pipe.send(('setattr', name, value))
1551
class ClientDBusTransitional(ClientDBus):
1552
__metaclass__ = AlternateDBusNamesMetaclass
1555
class ClientHandler(socketserver.BaseRequestHandler, object):
1556
"""A class to handle client connections.
1558
Instantiated once for each connection to handle it.
307
def still_valid(self, now=None):
308
"""Has the timeout not yet passed for this client?"""
310
now = datetime.datetime.now()
311
if self.last_seen is None:
312
return now < (self.created + self.timeout)
314
return now < (self.last_seen + self.timeout)
317
def peer_certificate(session):
318
"Return the peer's OpenPGP certificate as a bytestring"
319
# If not an OpenPGP certificate...
320
if gnutls.library.functions.gnutls_certificate_type_get\
321
(session._c_object) \
322
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
323
# ...do the normal thing
324
return session.peer_certificate
325
list_size = ctypes.c_uint()
326
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
327
(session._c_object, ctypes.byref(list_size))
328
if list_size.value == 0:
331
return ctypes.string_at(cert.data, cert.size)
334
def fingerprint(openpgp):
335
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
336
# New empty GnuTLS certificate
337
crt = gnutls.library.types.gnutls_openpgp_crt_t()
338
gnutls.library.functions.gnutls_openpgp_crt_init\
340
# New GnuTLS "datum" with the OpenPGP public key
341
datum = gnutls.library.types.gnutls_datum_t\
342
(ctypes.cast(ctypes.c_char_p(openpgp),
343
ctypes.POINTER(ctypes.c_ubyte)),
344
ctypes.c_uint(len(openpgp)))
345
# Import the OpenPGP public key into the certificate
346
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
349
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
350
# New buffer for the fingerprint
351
buffer = ctypes.create_string_buffer(20)
352
buffer_length = ctypes.c_size_t()
353
# Get the fingerprint from the certificate into the buffer
354
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
355
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
356
# Deinit the certificate
357
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
358
# Convert the buffer to a Python bytestring
359
fpr = ctypes.string_at(buffer, buffer_length.value)
360
# Convert the bytestring to hexadecimal notation
361
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
365
class tcp_handler(SocketServer.BaseRequestHandler, object):
366
"""A TCP request handler class.
367
Instantiated by IPv6_TCPServer for each request to handle it.
1559
368
Note: This will run in its own forked process."""
1561
370
def handle(self):
1562
with contextlib.closing(self.server.child_pipe) as child_pipe:
1563
logger.info("TCP connection from: %s",
1564
unicode(self.client_address))
1565
logger.debug("Pipe FD: %d",
1566
self.server.child_pipe.fileno())
1568
session = (gnutls.connection
1569
.ClientSession(self.request,
1571
.X509Credentials()))
1573
# Note: gnutls.connection.X509Credentials is really a
1574
# generic GnuTLS certificate credentials object so long as
1575
# no X.509 keys are added to it. Therefore, we can use it
1576
# here despite using OpenPGP certificates.
1578
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1579
# "+AES-256-CBC", "+SHA1",
1580
# "+COMP-NULL", "+CTYPE-OPENPGP",
1582
# Use a fallback default, since this MUST be set.
1583
priority = self.server.gnutls_priority
1584
if priority is None:
1586
(gnutls.library.functions
1587
.gnutls_priority_set_direct(session._c_object,
1590
# Start communication using the Mandos protocol
1591
# Get protocol number
1592
line = self.request.makefile().readline()
1593
logger.debug("Protocol version: %r", line)
1595
if int(line.strip().split()[0]) > 1:
1597
except (ValueError, IndexError, RuntimeError) as error:
1598
logger.error("Unknown protocol version: %s", error)
1601
# Start GnuTLS connection
1604
except gnutls.errors.GNUTLSError as error:
1605
logger.warning("Handshake failed: %s", error)
1606
# Do not run session.bye() here: the session is not
1607
# established. Just abandon the request.
1609
logger.debug("Handshake succeeded")
1611
approval_required = False
1614
fpr = self.fingerprint(self.peer_certificate
1617
gnutls.errors.GNUTLSError) as error:
1618
logger.warning("Bad certificate: %s", error)
1620
logger.debug("Fingerprint: %s", fpr)
1623
client = ProxyClient(child_pipe, fpr,
1624
self.client_address)
1628
if client.approval_delay:
1629
delay = client.approval_delay
1630
client.approvals_pending += 1
1631
approval_required = True
1634
if not client.enabled:
1635
logger.info("Client %s is disabled",
1637
if self.server.use_dbus:
1639
client.Rejected("Disabled")
1642
if client.approved or not client.approval_delay:
1643
#We are approved or approval is disabled
1645
elif client.approved is None:
1646
logger.info("Client %s needs approval",
1648
if self.server.use_dbus:
1650
client.NeedApproval(
1651
client.approval_delay_milliseconds(),
1652
client.approved_by_default)
1654
logger.warning("Client %s was not approved",
1656
if self.server.use_dbus:
1658
client.Rejected("Denied")
1661
#wait until timeout or approved
1662
time = datetime.datetime.now()
1663
client.changedstate.acquire()
1664
(client.changedstate.wait
1665
(float(client.timedelta_to_milliseconds(delay)
1667
client.changedstate.release()
1668
time2 = datetime.datetime.now()
1669
if (time2 - time) >= delay:
1670
if not client.approved_by_default:
1671
logger.warning("Client %s timed out while"
1672
" waiting for approval",
1674
if self.server.use_dbus:
1676
client.Rejected("Approval timed out")
1681
delay -= time2 - time
1684
while sent_size < len(client.secret):
1686
sent = session.send(client.secret[sent_size:])
1687
except gnutls.errors.GNUTLSError as error:
1688
logger.warning("gnutls send failed")
1690
logger.debug("Sent: %d, remaining: %d",
1691
sent, len(client.secret)
1692
- (sent_size + sent))
1695
logger.info("Sending secret to %s", client.name)
1696
# bump the timeout using extended_timeout
1697
client.bump_timeout(client.extended_timeout)
1698
if self.server.use_dbus:
1703
if approval_required:
1704
client.approvals_pending -= 1
1707
except gnutls.errors.GNUTLSError as error:
1708
logger.warning("GnuTLS bye failed")
1711
def peer_certificate(session):
1712
"Return the peer's OpenPGP certificate as a bytestring"
1713
# If not an OpenPGP certificate...
1714
if (gnutls.library.functions
1715
.gnutls_certificate_type_get(session._c_object)
1716
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1717
# ...do the normal thing
1718
return session.peer_certificate
1719
list_size = ctypes.c_uint(1)
1720
cert_list = (gnutls.library.functions
1721
.gnutls_certificate_get_peers
1722
(session._c_object, ctypes.byref(list_size)))
1723
if not bool(cert_list) and list_size.value != 0:
1724
raise gnutls.errors.GNUTLSError("error getting peer"
1726
if list_size.value == 0:
1729
return ctypes.string_at(cert.data, cert.size)
1732
def fingerprint(openpgp):
1733
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1734
# New GnuTLS "datum" with the OpenPGP public key
1735
datum = (gnutls.library.types
1736
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1739
ctypes.c_uint(len(openpgp))))
1740
# New empty GnuTLS certificate
1741
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1742
(gnutls.library.functions
1743
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1744
# Import the OpenPGP public key into the certificate
1745
(gnutls.library.functions
1746
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1747
gnutls.library.constants
1748
.GNUTLS_OPENPGP_FMT_RAW))
1749
# Verify the self signature in the key
1750
crtverify = ctypes.c_uint()
1751
(gnutls.library.functions
1752
.gnutls_openpgp_crt_verify_self(crt, 0,
1753
ctypes.byref(crtverify)))
1754
if crtverify.value != 0:
1755
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1756
raise (gnutls.errors.CertificateSecurityError
1758
# New buffer for the fingerprint
1759
buf = ctypes.create_string_buffer(20)
1760
buf_len = ctypes.c_size_t()
1761
# Get the fingerprint from the certificate into the buffer
1762
(gnutls.library.functions
1763
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1764
ctypes.byref(buf_len)))
1765
# Deinit the certificate
1766
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1767
# Convert the buffer to a Python bytestring
1768
fpr = ctypes.string_at(buf, buf_len.value)
1769
# Convert the bytestring to hexadecimal notation
1770
hex_fpr = binascii.hexlify(fpr).upper()
1774
class MultiprocessingMixIn(object):
1775
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1776
def sub_process_main(self, request, address):
1778
self.finish_request(request, address)
1780
self.handle_error(request, address)
1781
self.close_request(request)
1783
def process_request(self, request, address):
1784
"""Start a new process to process the request."""
1785
proc = multiprocessing.Process(target = self.sub_process_main,
1792
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1793
""" adds a pipe to the MixIn """
1794
def process_request(self, request, client_address):
1795
"""Overrides and wraps the original process_request().
1797
This function creates a new pipe in self.pipe
1799
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1801
proc = MultiprocessingMixIn.process_request(self, request,
1803
self.child_pipe.close()
1804
self.add_pipe(parent_pipe, proc)
1806
def add_pipe(self, parent_pipe, proc):
1807
"""Dummy function; override as necessary"""
1808
raise NotImplementedError
1811
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1812
socketserver.TCPServer, object):
1813
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
371
logger.debug(u"TCP connection from: %s",
372
unicode(self.client_address))
373
session = gnutls.connection.ClientSession(self.request,
377
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
378
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
380
priority = "SECURE256"
382
gnutls.library.functions.gnutls_priority_set_direct\
383
(session._c_object, priority, None);
387
except gnutls.errors.GNUTLSError, error:
388
logger.debug(u"Handshake failed: %s", error)
389
# Do not run session.bye() here: the session is not
390
# established. Just abandon the request.
393
fpr = fingerprint(peer_certificate(session))
394
except (TypeError, gnutls.errors.GNUTLSError), error:
395
logger.debug(u"Bad certificate: %s", error)
398
logger.debug(u"Fingerprint: %s", fpr)
400
for c in self.server.clients:
401
if c.fingerprint == fpr:
404
# Have to check if client.still_valid(), since it is possible
405
# that the client timed out while establishing the GnuTLS
407
if (not client) or (not client.still_valid()):
409
logger.debug(u"Client %(name)s is invalid",
412
logger.debug(u"Client not found for fingerprint: %s",
417
while sent_size < len(client.secret):
418
sent = session.send(client.secret[sent_size:])
419
logger.debug(u"Sent: %d, remaining: %d",
420
sent, len(client.secret)
421
- (sent_size + sent))
426
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
427
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1816
enabled: Boolean; whether this server is activated yet
1817
interface: None or a network interface name (string)
1818
use_ipv6: Boolean; to use IPv6 or not
429
options: Command line options
430
clients: Set() of Client objects
1820
def __init__(self, server_address, RequestHandlerClass,
1821
interface=None, use_ipv6=True):
1822
self.interface = interface
1824
self.address_family = socket.AF_INET6
1825
socketserver.TCPServer.__init__(self, server_address,
1826
RequestHandlerClass)
432
address_family = socket.AF_INET6
433
def __init__(self, *args, **kwargs):
434
if "options" in kwargs:
435
self.options = kwargs["options"]
436
del kwargs["options"]
437
if "clients" in kwargs:
438
self.clients = kwargs["clients"]
439
del kwargs["clients"]
440
return super(type(self), self).__init__(*args, **kwargs)
1827
441
def server_bind(self):
1828
442
"""This overrides the normal server_bind() function
1829
443
to bind to an interface if one was specified, and also NOT to
1830
444
bind to an address or port if they were not specified."""
1831
if self.interface is not None:
1832
if SO_BINDTODEVICE is None:
1833
logger.error("SO_BINDTODEVICE does not exist;"
1834
" cannot bind to interface %s",
1838
self.socket.setsockopt(socket.SOL_SOCKET,
1842
except socket.error as error:
1843
if error[0] == errno.EPERM:
1844
logger.error("No permission to"
1845
" bind to interface %s",
1847
elif error[0] == errno.ENOPROTOOPT:
1848
logger.error("SO_BINDTODEVICE not available;"
1849
" cannot bind to interface %s",
445
if self.options.interface:
446
if not hasattr(socket, "SO_BINDTODEVICE"):
447
# From /usr/include/asm-i486/socket.h
448
socket.SO_BINDTODEVICE = 25
450
self.socket.setsockopt(socket.SOL_SOCKET,
451
socket.SO_BINDTODEVICE,
452
self.options.interface)
453
except socket.error, error:
454
if error[0] == errno.EPERM:
455
logger.warning(u"No permission to"
456
u" bind to interface %s",
457
self.options.interface)
1853
460
# Only bind(2) the socket if we really need to.
1854
461
if self.server_address[0] or self.server_address[1]:
1855
462
if not self.server_address[0]:
1856
if self.address_family == socket.AF_INET6:
1857
any_address = "::" # in6addr_any
1859
any_address = socket.INADDR_ANY
1860
self.server_address = (any_address,
464
self.server_address = (in6addr_any,
1861
465
self.server_address[1])
1862
elif not self.server_address[1]:
466
elif self.server_address[1] is None:
1863
467
self.server_address = (self.server_address[0],
1865
# if self.interface:
1866
# self.server_address = (self.server_address[0],
1871
return socketserver.TCPServer.server_bind(self)
1874
class MandosServer(IPv6_TCPServer):
1878
clients: set of Client objects
1879
gnutls_priority GnuTLS priority string
1880
use_dbus: Boolean; to emit D-Bus signals or not
1882
Assumes a gobject.MainLoop event loop.
1884
def __init__(self, server_address, RequestHandlerClass,
1885
interface=None, use_ipv6=True, clients=None,
1886
gnutls_priority=None, use_dbus=True):
1887
self.enabled = False
1888
self.clients = clients
1889
if self.clients is None:
1891
self.use_dbus = use_dbus
1892
self.gnutls_priority = gnutls_priority
1893
IPv6_TCPServer.__init__(self, server_address,
1894
RequestHandlerClass,
1895
interface = interface,
1896
use_ipv6 = use_ipv6)
1897
def server_activate(self):
1899
return socketserver.TCPServer.server_activate(self)
1904
def add_pipe(self, parent_pipe, proc):
1905
# Call "handle_ipc" for both data and EOF events
1906
gobject.io_add_watch(parent_pipe.fileno(),
1907
gobject.IO_IN | gobject.IO_HUP,
1908
functools.partial(self.handle_ipc,
1913
def handle_ipc(self, source, condition, parent_pipe=None,
1914
proc = None, client_object=None):
1916
gobject.IO_IN: "IN", # There is data to read.
1917
gobject.IO_OUT: "OUT", # Data can be written (without
1919
gobject.IO_PRI: "PRI", # There is urgent data to read.
1920
gobject.IO_ERR: "ERR", # Error condition.
1921
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1922
# broken, usually for pipes and
1925
conditions_string = ' | '.join(name
1927
condition_names.iteritems()
1928
if cond & condition)
1929
# error, or the other end of multiprocessing.Pipe has closed
1930
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1931
# Wait for other process to exit
1935
# Read a request from the child
1936
request = parent_pipe.recv()
1937
command = request[0]
1939
if command == 'init':
1941
address = request[2]
1943
for c in self.clients.itervalues():
1944
if c.fingerprint == fpr:
1948
logger.info("Client not found for fingerprint: %s, ad"
1949
"dress: %s", fpr, address)
1952
mandos_dbus_service.ClientNotFound(fpr,
1954
parent_pipe.send(False)
1957
gobject.io_add_watch(parent_pipe.fileno(),
1958
gobject.IO_IN | gobject.IO_HUP,
1959
functools.partial(self.handle_ipc,
1965
parent_pipe.send(True)
1966
# remove the old hook in favor of the new above hook on
1969
if command == 'funcall':
1970
funcname = request[1]
1974
parent_pipe.send(('data', getattr(client_object,
1978
if command == 'getattr':
1979
attrname = request[1]
1980
if callable(client_object.__getattribute__(attrname)):
1981
parent_pipe.send(('function',))
1983
parent_pipe.send(('data', client_object
1984
.__getattribute__(attrname)))
1986
if command == 'setattr':
1987
attrname = request[1]
1989
setattr(client_object, attrname, value)
469
return super(type(self), self).server_bind()
1994
472
def string_to_delta(interval):
1995
473
"""Parse a string and return a datetime.timedelta
1997
475
>>> string_to_delta('7d')
1998
476
datetime.timedelta(7)
1999
477
>>> string_to_delta('60s')
616
def killme(status = 0):
617
logger.debug("Stopping server with exit status %d", status)
619
if main_loop_started:
2060
##################################################################
2061
# Parsing of options, both command line and config file
2063
parser = argparse.ArgumentParser()
2064
parser.add_argument("-v", "--version", action="version",
2065
version = "%%(prog)s %s" % version,
2066
help="show version number and exit")
2067
parser.add_argument("-i", "--interface", metavar="IF",
2068
help="Bind to interface IF")
2069
parser.add_argument("-a", "--address",
2070
help="Address to listen for requests on")
2071
parser.add_argument("-p", "--port", type=int,
2072
help="Port number to receive requests on")
2073
parser.add_argument("--check", action="store_true",
2074
help="Run self-test")
2075
parser.add_argument("--debug", action="store_true",
2076
help="Debug mode; run in foreground and log"
2078
parser.add_argument("--debuglevel", metavar="LEVEL",
2079
help="Debug level for stdout output")
2080
parser.add_argument("--priority", help="GnuTLS"
2081
" priority string (see GnuTLS documentation)")
2082
parser.add_argument("--servicename",
2083
metavar="NAME", help="Zeroconf service name")
2084
parser.add_argument("--configdir",
2085
default="/etc/mandos", metavar="DIR",
2086
help="Directory to search for configuration"
2088
parser.add_argument("--no-dbus", action="store_false",
2089
dest="use_dbus", help="Do not provide D-Bus"
2090
" system bus interface")
2091
parser.add_argument("--no-ipv6", action="store_false",
2092
dest="use_ipv6", help="Do not use IPv6")
2093
parser.add_argument("--no-restore", action="store_false",
2094
dest="restore", help="Do not restore stored"
2096
parser.add_argument("--statedir", metavar="DIR",
2097
help="Directory to save/restore state in")
2099
options = parser.parse_args()
628
global main_loop_started
629
main_loop_started = False
631
parser = OptionParser()
632
parser.add_option("-i", "--interface", type="string",
633
default=None, metavar="IF",
634
help="Bind to interface IF")
635
parser.add_option("-a", "--address", type="string", default=None,
636
help="Address to listen for requests on")
637
parser.add_option("-p", "--port", type="int", default=None,
638
help="Port number to receive requests on")
639
parser.add_option("--timeout", type="string", # Parsed later
641
help="Amount of downtime allowed for clients")
642
parser.add_option("--interval", type="string", # Parsed later
644
help="How often to check that a client is up")
645
parser.add_option("--check", action="store_true", default=False,
646
help="Run self-test")
647
parser.add_option("--debug", action="store_true", default=False,
649
(options, args) = parser.parse_args()
2101
651
if options.check:
2103
653
doctest.testmod()
2106
# Default values for config file for server-global settings
2107
server_defaults = { "interface": "",
2112
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2113
"servicename": "Mandos",
2118
"statedir": "/var/lib/mandos"
2121
# Parse config file for server-global settings
2122
server_config = configparser.SafeConfigParser(server_defaults)
2124
server_config.read(os.path.join(options.configdir,
2126
# Convert the SafeConfigParser object to a dict
2127
server_settings = server_config.defaults()
2128
# Use the appropriate methods on the non-string config options
2129
for option in ("debug", "use_dbus", "use_ipv6"):
2130
server_settings[option] = server_config.getboolean("DEFAULT",
2132
if server_settings["port"]:
2133
server_settings["port"] = server_config.getint("DEFAULT",
2137
# Override the settings from the config file with command line
2139
for option in ("interface", "address", "port", "debug",
2140
"priority", "servicename", "configdir",
2141
"use_dbus", "use_ipv6", "debuglevel", "restore",
2143
value = getattr(options, option)
2144
if value is not None:
2145
server_settings[option] = value
2147
# Force all strings to be unicode
2148
for option in server_settings.keys():
2149
if type(server_settings[option]) is str:
2150
server_settings[option] = unicode(server_settings[option])
2151
# Now we have our good server settings in "server_settings"
2153
##################################################################
2156
debug = server_settings["debug"]
2157
debuglevel = server_settings["debuglevel"]
2158
use_dbus = server_settings["use_dbus"]
2159
use_ipv6 = server_settings["use_ipv6"]
2160
stored_state_path = os.path.join(server_settings["statedir"],
2164
initlogger(debug, logging.DEBUG)
2169
level = getattr(logging, debuglevel.upper())
2170
initlogger(debug, level)
2172
if server_settings["servicename"] != "Mandos":
2173
syslogger.setFormatter(logging.Formatter
2174
('Mandos (%s) [%%(process)d]:'
2175
' %%(levelname)s: %%(message)s'
2176
% server_settings["servicename"]))
2178
# Parse config file with clients
2179
client_config = configparser.SafeConfigParser(Client
2181
client_config.read(os.path.join(server_settings["configdir"],
2184
global mandos_dbus_service
2185
mandos_dbus_service = None
2187
tcp_server = MandosServer((server_settings["address"],
2188
server_settings["port"]),
2190
interface=(server_settings["interface"]
2194
server_settings["priority"],
2197
pidfilename = "/var/run/mandos.pid"
2199
pidfile = open(pidfilename, "w")
2201
logger.error("Could not open file %r", pidfilename)
2204
uid = pwd.getpwnam("_mandos").pw_uid
2205
gid = pwd.getpwnam("_mandos").pw_gid
2208
uid = pwd.getpwnam("mandos").pw_uid
2209
gid = pwd.getpwnam("mandos").pw_gid
2212
uid = pwd.getpwnam("nobody").pw_uid
2213
gid = pwd.getpwnam("nobody").pw_gid
2220
except OSError as error:
2221
if error[0] != errno.EPERM:
2225
# Enable all possible GnuTLS debugging
2227
# "Use a log level over 10 to enable all debugging options."
2229
gnutls.library.functions.gnutls_global_set_log_level(11)
2231
@gnutls.library.types.gnutls_log_func
2232
def debug_gnutls(level, string):
2233
logger.debug("GnuTLS: %s", string[:-1])
2235
(gnutls.library.functions
2236
.gnutls_global_set_log_function(debug_gnutls))
2238
# Redirect stdin so all checkers get /dev/null
2239
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2240
os.dup2(null, sys.stdin.fileno())
2244
# Need to fork before connecting to D-Bus
2246
# Close all input and output, do double fork, etc.
2249
gobject.threads_init()
656
# Parse the time arguments
658
options.timeout = string_to_delta(options.timeout)
660
parser.error("option --timeout: Unparseable time")
662
options.interval = string_to_delta(options.interval)
664
parser.error("option --interval: Unparseable time")
667
defaults = { "checker": "fping -q -- %%(fqdn)s" }
668
client_config = ConfigParser.SafeConfigParser(defaults)
669
#client_config.readfp(open("global.conf"), "global.conf")
670
client_config.read("mandos-clients.conf")
2251
672
global main_loop
2252
675
# From the Avahi example code
2253
DBusGMainLoop(set_as_default=True)
676
DBusGMainLoop(set_as_default=True )
2254
677
main_loop = gobject.MainLoop()
2255
678
bus = dbus.SystemBus()
679
server = dbus.Interface(
680
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
681
avahi.DBUS_INTERFACE_SERVER )
2256
682
# End of Avahi example code
2259
bus_name = dbus.service.BusName("se.recompile.Mandos",
2260
bus, do_not_queue=True)
2261
old_bus_name = (dbus.service.BusName
2262
("se.bsnet.fukt.Mandos", bus,
2264
except dbus.exceptions.NameExistsException as e:
2265
logger.error(unicode(e) + ", disabling D-Bus")
2267
server_settings["use_dbus"] = False
2268
tcp_server.use_dbus = False
2269
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2270
service = AvahiServiceToSyslog(name =
2271
server_settings["servicename"],
2272
servicetype = "_mandos._tcp",
2273
protocol = protocol, bus = bus)
2274
if server_settings["interface"]:
2275
service.interface = (if_nametoindex
2276
(str(server_settings["interface"])))
2278
global multiprocessing_manager
2279
multiprocessing_manager = multiprocessing.Manager()
2281
client_class = Client
2283
client_class = functools.partial(ClientDBusTransitional,
2286
client_settings = Client.config_parser(client_config)
2287
old_client_settings = {}
2290
# Get client data and settings from last running state.
2291
if server_settings["restore"]:
2293
with open(stored_state_path, "rb") as stored_state:
2294
clients_data, old_client_settings = (pickle.load
2296
os.remove(stored_state_path)
2297
except IOError as e:
2298
logger.warning("Could not load persistent state: {0}"
2300
if e.errno != errno.ENOENT:
2302
except EOFError as e:
2303
logger.warning("Could not load persistent state: "
2304
"EOFError: {0}".format(e))
2306
with PGPEngine() as pgp:
2307
for client_name, client in clients_data.iteritems():
2308
# Decide which value to use after restoring saved state.
2309
# We have three different values: Old config file,
2310
# new config file, and saved state.
2311
# New config value takes precedence if it differs from old
2312
# config value, otherwise use saved state.
2313
for name, value in client_settings[client_name].items():
2315
# For each value in new config, check if it
2316
# differs from the old config value (Except for
2317
# the "secret" attribute)
2318
if (name != "secret" and
2319
value != old_client_settings[client_name]
2321
client[name] = value
2325
# Clients who has passed its expire date can still be
2326
# enabled if its last checker was successful. Clients
2327
# whose checker succeeded before we stored its state is
2328
# assumed to have successfully run all checkers during
2330
if client["enabled"]:
2331
if datetime.datetime.utcnow() >= client["expires"]:
2332
if not client["last_checked_ok"]:
2334
"disabling client {0} - Client never "
2335
"performed a successful checker"
2336
.format(client_name))
2337
client["enabled"] = False
2338
elif client["last_checker_status"] != 0:
2340
"disabling client {0} - Client "
2341
"last checker failed with error code {1}"
2342
.format(client_name,
2343
client["last_checker_status"]))
2344
client["enabled"] = False
2346
client["expires"] = (datetime.datetime
2348
+ client["timeout"])
2349
logger.debug("Last checker succeeded,"
2350
" keeping {0} enabled"
2351
.format(client_name))
2353
client["secret"] = (
2354
pgp.decrypt(client["encrypted_secret"],
2355
client_settings[client_name]
2358
# If decryption fails, we use secret from new settings
2359
logger.debug("Failed to decrypt {0} old secret"
2360
.format(client_name))
2361
client["secret"] = (
2362
client_settings[client_name]["secret"])
2365
# Add/remove clients based on new changes made to config
2366
for client_name in (set(old_client_settings)
2367
- set(client_settings)):
2368
del clients_data[client_name]
2369
for client_name in (set(client_settings)
2370
- set(old_client_settings)):
2371
clients_data[client_name] = client_settings[client_name]
2373
# Create all client objects
2374
for client_name, client in clients_data.iteritems():
2375
tcp_server.clients[client_name] = client_class(
2376
name = client_name, settings = client)
2378
if not tcp_server.clients:
2379
logger.warning("No clients defined")
684
debug = options.debug
687
console = logging.StreamHandler()
688
# console.setLevel(logging.DEBUG)
689
console.setFormatter(logging.Formatter\
690
('%(levelname)s: %(message)s'))
691
logger.addHandler(console)
695
def remove_from_clients(client):
696
clients.remove(client)
698
logger.debug(u"No clients left, exiting")
701
clients.update(Set(Client(name=section, options=options,
702
stop_hook = remove_from_clients,
703
**(dict(client_config\
705
for section in client_config.sections()))
2385
pidfile.write(str(pid) + "\n".encode("utf-8"))
2388
logger.error("Could not write to file %r with PID %d",
2391
# "pidfile" was never created
2394
signal.signal(signal.SIGINT, signal.SIG_IGN)
2396
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2397
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2400
class MandosDBusService(DBusObjectWithProperties):
2401
"""A D-Bus proxy object"""
2403
dbus.service.Object.__init__(self, bus, "/")
2404
_interface = "se.recompile.Mandos"
2406
@dbus_interface_annotations(_interface)
2408
return { "org.freedesktop.DBus.Property"
2409
".EmitsChangedSignal":
2412
@dbus.service.signal(_interface, signature="o")
2413
def ClientAdded(self, objpath):
2417
@dbus.service.signal(_interface, signature="ss")
2418
def ClientNotFound(self, fingerprint, address):
2422
@dbus.service.signal(_interface, signature="os")
2423
def ClientRemoved(self, objpath, name):
2427
@dbus.service.method(_interface, out_signature="ao")
2428
def GetAllClients(self):
2430
return dbus.Array(c.dbus_object_path
2432
tcp_server.clients.itervalues())
2434
@dbus.service.method(_interface,
2435
out_signature="a{oa{sv}}")
2436
def GetAllClientsWithProperties(self):
2438
return dbus.Dictionary(
2439
((c.dbus_object_path, c.GetAll(""))
2440
for c in tcp_server.clients.itervalues()),
2443
@dbus.service.method(_interface, in_signature="o")
2444
def RemoveClient(self, object_path):
2446
for c in tcp_server.clients.itervalues():
2447
if c.dbus_object_path == object_path:
2448
del tcp_server.clients[c.name]
2449
c.remove_from_connection()
2450
# Don't signal anything except ClientRemoved
2451
c.disable(quiet=True)
2453
self.ClientRemoved(object_path, c.name)
2455
raise KeyError(object_path)
2459
class MandosDBusServiceTransitional(MandosDBusService):
2460
__metaclass__ = AlternateDBusNamesMetaclass
2461
mandos_dbus_service = MandosDBusServiceTransitional()
2464
711
"Cleanup function; run on exit"
2467
multiprocessing.active_children()
2468
if not (tcp_server.clients or client_settings):
2471
# Store client before exiting. Secrets are encrypted with key
2472
# based on what config file has. If config file is
2473
# removed/edited, old secret will thus be unrecovable.
2475
with PGPEngine() as pgp:
2476
for client in tcp_server.clients.itervalues():
2477
key = client_settings[client.name]["secret"]
2478
client.encrypted_secret = pgp.encrypt(client.secret,
2482
# A list of attributes that can not be pickled
2484
exclude = set(("bus", "changedstate", "secret",
2486
for name, typ in (inspect.getmembers
2487
(dbus.service.Object)):
2490
client_dict["encrypted_secret"] = (client
2492
for attr in client.client_structure:
2493
if attr not in exclude:
2494
client_dict[attr] = getattr(client, attr)
2496
clients[client.name] = client_dict
2497
del client_settings[client.name]["secret"]
2500
tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2503
(stored_state_path))
2504
with os.fdopen(tempfd, "wb") as stored_state:
2505
pickle.dump((clients, client_settings), stored_state)
2506
os.rename(tempname, stored_state_path)
2507
except (IOError, OSError) as e:
2508
logger.warning("Could not save persistent state: {0}"
2515
if e.errno not in set((errno.ENOENT, errno.EACCES,
2519
# Delete all clients, and settings from config
2520
while tcp_server.clients:
2521
name, client = tcp_server.clients.popitem()
2523
client.remove_from_connection()
2524
# Don't signal anything except ClientRemoved
2525
client.disable(quiet=True)
2528
mandos_dbus_service.ClientRemoved(client
2531
client_settings.clear()
2533
atexit.register(cleanup)
2535
for client in tcp_server.clients.itervalues():
2538
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2539
# Need to initiate checking of clients
2541
client.init_checker()
2544
tcp_server.server_activate()
2546
# Find out what port we got
2547
service.port = tcp_server.socket.getsockname()[1]
2549
logger.info("Now listening on address %r, port %d,"
2550
" flowinfo %d, scope_id %d"
2551
% tcp_server.socket.getsockname())
2553
logger.info("Now listening on address %r, port %d"
2554
% tcp_server.socket.getsockname())
2556
#service.interface = tcp_server.socket.getsockname()[3]
2559
713
# From the Avahi example code
2562
except dbus.exceptions.DBusException as error:
2563
logger.critical("DBusException: %s", error)
714
if not group is None:
2566
717
# End of Avahi example code
2568
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2569
lambda *args, **kwargs:
2570
(tcp_server.handle_request
2571
(*args[2:], **kwargs) or True))
720
client = clients.pop()
721
client.stop_hook = None
724
atexit.register(cleanup)
727
signal.signal(signal.SIGINT, signal.SIG_IGN)
728
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
729
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
731
for client in clients:
734
tcp_server = IPv6_TCPServer((options.address, options.port),
738
# Find out what random port we got
740
servicePort = tcp_server.socket.getsockname()[1]
741
logger.debug(u"Now listening on port %d", servicePort)
743
if options.interface is not None:
744
global serviceInterface
745
serviceInterface = if_nametoindex(options.interface)
747
# From the Avahi example code
748
server.connect_to_signal("StateChanged", server_state_changed)
750
server_state_changed(server.GetState())
751
except dbus.exceptions.DBusException, error:
752
logger.critical(u"DBusException: %s", error)
754
# End of Avahi example code
756
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
757
lambda *args, **kwargs:
758
tcp_server.handle_request(*args[2:],
2573
761
logger.debug("Starting main loop")
762
main_loop_started = True
2575
except AvahiError as error:
2576
logger.critical("AvahiError: %s", error)
2579
764
except KeyboardInterrupt:
2581
print("", file=sys.stderr)
2582
logger.debug("Server received KeyboardInterrupt")
2583
logger.debug("Server exiting")
2584
# Must run before the D-Bus bus name gets deregistered
2587
770
if __name__ == '__main__':