To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 237.2.134
- compare with another revision
- download diff
- download tarball
- view history from revision 237.2.134
- Committer: Teddy Hogeborn
- Date: 2009-09-17 02:42:49 UTC
- mto: (24.1.142 mandos) (237.12.2 mandos-persistent) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 264.
- Revision ID: teddy@fukt.bsnet.se-20090917024249-y6j76xtzz3i2vptv
* plugins.d/mandos-client.c (init_gnutls_session): Always fail and
return immediately
if interrupted by
signal.
return immediately
if interrupted by
signal.
- files removed:
- DBUS-API
- debian/source
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 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
28
28
# along with this program. If not, see
29
29
# <http://www.gnu.org/licenses/>.
30
30
#
31
# Contact the authors at <mandos@recompile.se>.
31
# Contact the authors at <mandos@fukt.bsnet.se>.
32
32
#
33
33
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
34
from __future__ import division, with_statement, absolute_import
36
35
37
36
import SocketServer as socketserver
38
37
import socket
39
import argparse
38
import optparse
40
39
import datetime
41
40
import errno
42
41
import gnutls.crypto
56
55
import logging
57
56
import logging.handlers
58
57
import pwd
59
import contextlib
58
from contextlib import closing
60
59
import struct
61
60
import fcntl
62
61
import functools
63
import cPickle as pickle
64
import multiprocessing
65
import types
66
import binascii
67
import tempfile
68
62
69
63
import dbus
70
64
import dbus.service
73
67
from dbus.mainloop.glib import DBusGMainLoop
74
68
import ctypes
75
69
import ctypes.util
76
import xml.dom.minidom
77
import inspect
78
import GnuPGInterface
79
70
80
71
try:
81
72
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
86
77
SO_BINDTODEVICE = None
87
78
88
79
89
version = "1.4.1"
90
stored_state_path = "/var/lib/mandos/clients.pickle"
80
version = "1.0.11"
91
81
92
logger = logging.getLogger()
82
logger = logging.Logger(u'mandos')
93
83
syslogger = (logging.handlers.SysLogHandler
94
84
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
95
address = str("/dev/log")))
96
97
try:
98
if_nametoindex = (ctypes.cdll.LoadLibrary
99
(ctypes.util.find_library("c"))
100
.if_nametoindex)
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"),
108
interface))
109
interface_index = struct.unpack(str("I"),
110
ifreq[16:20])[0]
111
return interface_index
112
113
114
def initlogger(level=logging.WARNING):
115
"""init logger and add loglevel"""
116
117
syslogger.setFormatter(logging.Formatter
118
('Mandos [%(process)d]: %(levelname)s:'
119
' %(message)s'))
120
logger.addHandler(syslogger)
121
122
console = logging.StreamHandler()
123
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
124
' [%(process)d]:'
125
' %(levelname)s:'
126
' %(message)s'))
127
logger.addHandler(console)
128
logger.setLevel(level)
129
130
131
class CryptoError(Exception):
132
pass
133
134
135
class Crypto(object):
136
"""A simple class for OpenPGP symmetric encryption & decryption"""
137
def __init__(self):
138
self.gnupg = GnuPGInterface.GnuPG()
139
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
140
self.gnupg = GnuPGInterface.GnuPG()
141
self.gnupg.options.meta_interactive = False
142
self.gnupg.options.homedir = self.tempdir
143
self.gnupg.options.extra_args.extend(['--force-mdc',
144
'--quiet'])
145
146
def __enter__(self):
147
return self
148
149
def __exit__ (self, exc_type, exc_value, traceback):
150
self._cleanup()
151
return False
152
153
def __del__(self):
154
self._cleanup()
155
156
def _cleanup(self):
157
if self.tempdir is not None:
158
# Delete contents of tempdir
159
for root, dirs, files in os.walk(self.tempdir,
160
topdown = False):
161
for filename in files:
162
os.remove(os.path.join(root, filename))
163
for dirname in dirs:
164
os.rmdir(os.path.join(root, dirname))
165
# Remove tempdir
166
os.rmdir(self.tempdir)
167
self.tempdir = None
168
169
def password_encode(self, password):
170
# Passphrase can not be empty and can not contain newlines or
171
# NUL bytes. So we prefix it and hex encode it.
172
return b"mandos" + binascii.hexlify(password)
173
174
def encrypt(self, data, password):
175
self.gnupg.passphrase = self.password_encode(password)
176
with open(os.devnull) as devnull:
177
try:
178
proc = self.gnupg.run(['--symmetric'],
179
create_fhs=['stdin', 'stdout'],
180
attach_fhs={'stderr': devnull})
181
with contextlib.closing(proc.handles['stdin']) as f:
182
f.write(data)
183
with contextlib.closing(proc.handles['stdout']) as f:
184
ciphertext = f.read()
185
proc.wait()
186
except IOError as e:
187
raise CryptoError(e)
188
self.gnupg.passphrase = None
189
return ciphertext
190
191
def decrypt(self, data, password):
192
self.gnupg.passphrase = self.password_encode(password)
193
with open(os.devnull) as devnull:
194
try:
195
proc = self.gnupg.run(['--decrypt'],
196
create_fhs=['stdin', 'stdout'],
197
attach_fhs={'stderr': devnull})
198
with contextlib.closing(proc.handles['stdin'] ) as f:
199
f.write(data)
200
with contextlib.closing(proc.handles['stdout']) as f:
201
decrypted_plaintext = f.read()
202
proc.wait()
203
except IOError as e:
204
raise CryptoError(e)
205
self.gnupg.passphrase = None
206
return decrypted_plaintext
207
208
85
address = "/dev/log"))
86
syslogger.setFormatter(logging.Formatter
87
(u'Mandos [%(process)d]: %(levelname)s:'
88
u' %(message)s'))
89
logger.addHandler(syslogger)
90
91
console = logging.StreamHandler()
92
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
93
u' %(levelname)s:'
94
u' %(message)s'))
95
logger.addHandler(console)
209
96
210
97
class AvahiError(Exception):
211
98
def __init__(self, value, *args, **kwargs):
227
114
Attributes:
228
115
interface: integer; avahi.IF_UNSPEC or an interface index.
229
116
Used to optionally bind to the specified interface.
230
name: string; Example: 'Mandos'
231
type: string; Example: '_mandos._tcp'.
117
name: string; Example: u'Mandos'
118
type: string; Example: u'_mandos._tcp'.
232
119
See <http://www.dns-sd.org/ServiceTypes.html>
233
120
port: integer; what port to announce
234
121
TXT: list of strings; TXT record for the service
243
130
"""
244
131
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
245
132
servicetype = None, port = None, TXT = None,
246
domain = "", host = "", max_renames = 32768,
133
domain = u"", host = u"", max_renames = 32768,
247
134
protocol = avahi.PROTO_UNSPEC, bus = None):
248
135
self.interface = interface
249
136
self.name = name
258
145
self.group = None # our entry group
259
146
self.server = None
260
147
self.bus = bus
261
self.entry_group_state_changed_match = None
262
148
def rename(self):
263
149
"""Derived from the Avahi example code"""
264
150
if self.rename_count >= self.max_renames:
265
logger.critical("No suitable Zeroconf service name found"
266
" after %i retries, exiting.",
151
logger.critical(u"No suitable Zeroconf service name found"
152
u" after %i retries, exiting.",
267
153
self.rename_count)
268
raise AvahiServiceError("Too many renames")
269
self.name = unicode(self.server
270
.GetAlternativeServiceName(self.name))
271
logger.info("Changing Zeroconf service name to %r ...",
272
self.name)
154
raise AvahiServiceError(u"Too many renames")
155
self.name = self.server.GetAlternativeServiceName(self.name)
156
logger.info(u"Changing Zeroconf service name to %r ...",
157
unicode(self.name))
158
syslogger.setFormatter(logging.Formatter
159
(u'Mandos (%s) [%%(process)d]:'
160
u' %%(levelname)s: %%(message)s'
161
% self.name))
273
162
self.remove()
274
try:
275
self.add()
276
except dbus.exceptions.DBusException as error:
277
logger.critical("DBusException: %s", error)
278
self.cleanup()
279
os._exit(1)
163
self.add()
280
164
self.rename_count += 1
281
165
def remove(self):
282
166
"""Derived from the Avahi example code"""
283
if self.entry_group_state_changed_match is not None:
284
self.entry_group_state_changed_match.remove()
285
self.entry_group_state_changed_match = None
286
167
if self.group is not None:
287
168
self.group.Reset()
288
169
def add(self):
289
170
"""Derived from the Avahi example code"""
290
self.remove()
291
171
if self.group is None:
292
172
self.group = dbus.Interface(
293
173
self.bus.get_object(avahi.DBUS_NAME,
294
174
self.server.EntryGroupNew()),
295
175
avahi.DBUS_INTERFACE_ENTRY_GROUP)
296
self.entry_group_state_changed_match = (
297
self.group.connect_to_signal(
298
'StateChanged', self.entry_group_state_changed))
299
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
176
self.group.connect_to_signal('StateChanged',
177
self.entry_group_state_changed)
178
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
300
179
self.name, self.type)
301
180
self.group.AddService(
302
181
self.interface,
309
188
self.group.Commit()
310
189
def entry_group_state_changed(self, state, error):
311
190
"""Derived from the Avahi example code"""
312
logger.debug("Avahi entry group state change: %i", state)
191
logger.debug(u"Avahi state change: %i", state)
313
192
314
193
if state == avahi.ENTRY_GROUP_ESTABLISHED:
315
logger.debug("Zeroconf service established.")
194
logger.debug(u"Zeroconf service established.")
316
195
elif state == avahi.ENTRY_GROUP_COLLISION:
317
logger.info("Zeroconf service name collision.")
196
logger.warning(u"Zeroconf service name collision.")
318
197
self.rename()
319
198
elif state == avahi.ENTRY_GROUP_FAILURE:
320
logger.critical("Avahi: Error in group state changed %s",
199
logger.critical(u"Avahi: Error in group state changed %s",
321
200
unicode(error))
322
raise AvahiGroupError("State changed: %s"
201
raise AvahiGroupError(u"State changed: %s"
323
202
% unicode(error))
324
203
def cleanup(self):
325
204
"""Derived from the Avahi example code"""
326
205
if self.group is not None:
327
try:
328
self.group.Free()
329
except (dbus.exceptions.UnknownMethodException,
330
dbus.exceptions.DBusException):
331
pass
206
self.group.Free()
332
207
self.group = None
333
self.remove()
334
def server_state_changed(self, state, error=None):
208
def server_state_changed(self, state):
335
209
"""Derived from the Avahi example code"""
336
logger.debug("Avahi server state change: %i", state)
337
bad_states = { avahi.SERVER_INVALID:
338
"Zeroconf server invalid",
339
avahi.SERVER_REGISTERING: None,
340
avahi.SERVER_COLLISION:
341
"Zeroconf server name collision",
342
avahi.SERVER_FAILURE:
343
"Zeroconf server failure" }
344
if state in bad_states:
345
if bad_states[state] is not None:
346
if error is None:
347
logger.error(bad_states[state])
348
else:
349
logger.error(bad_states[state] + ": %r", error)
350
self.cleanup()
210
if state == avahi.SERVER_COLLISION:
211
logger.error(u"Zeroconf server name collision")
212
self.remove()
351
213
elif state == avahi.SERVER_RUNNING:
352
214
self.add()
353
else:
354
if error is None:
355
logger.debug("Unknown state: %r", state)
356
else:
357
logger.debug("Unknown state: %r: %r", state, error)
358
215
def activate(self):
359
216
"""Derived from the Avahi example code"""
360
217
if self.server is None:
361
218
self.server = dbus.Interface(
362
219
self.bus.get_object(avahi.DBUS_NAME,
363
avahi.DBUS_PATH_SERVER,
364
follow_name_owner_changes=True),
220
avahi.DBUS_PATH_SERVER),
365
221
avahi.DBUS_INTERFACE_SERVER)
366
self.server.connect_to_signal("StateChanged",
222
self.server.connect_to_signal(u"StateChanged",
367
223
self.server_state_changed)
368
224
self.server_state_changed(self.server.GetState())
369
225
370
class AvahiServiceToSyslog(AvahiService):
371
def rename(self):
372
"""Add the new name to the syslog messages"""
373
ret = AvahiService.rename(self)
374
syslogger.setFormatter(logging.Formatter
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
377
% self.name))
378
return ret
379
226
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
386
227
class Client(object):
387
228
"""A representation of a client host served by this server.
388
229
389
230
Attributes:
390
_approved: bool(); 'None' if not yet approved/disapproved
391
approval_delay: datetime.timedelta(); Time to wait for approval
392
approval_duration: datetime.timedelta(); Duration of one approval
231
name: string; from the config file, used in log messages and
232
D-Bus identifiers
233
fingerprint: string (40 or 32 hexadecimal digits); used to
234
uniquely identify the client
235
secret: bytestring; sent verbatim (over TLS) to client
236
host: string; available for use by the checker command
237
created: datetime.datetime(); (UTC) object creation
238
last_enabled: datetime.datetime(); (UTC)
239
enabled: bool()
240
last_checked_ok: datetime.datetime(); (UTC) or None
241
timeout: datetime.timedelta(); How long from last_checked_ok
242
until this client is invalid
243
interval: datetime.timedelta(); How often to start a new checker
244
disable_hook: If set, called by disable() as disable_hook(self)
393
245
checker: subprocess.Popen(); a running checker process used
394
246
to see if the client lives.
395
247
'None' if no process is running.
396
checker_callback_tag: a gobject event source tag, or None
397
checker_command: string; External command which is run to check
398
if client lives. %() expansions are done at
248
checker_initiator_tag: a gobject event source tag, or None
249
disable_initiator_tag: - '' -
250
checker_callback_tag: - '' -
251
checker_command: string; External command which is run to check if
252
client lives. %() expansions are done at
399
253
runtime with vars(self) as dict, so that for
400
254
instance %(name)s can be used in the command.
401
checker_initiator_tag: a gobject event source tag, or None
402
created: datetime.datetime(); (UTC) object creation
403
client_structure: Object describing what attributes a client has
404
and is used for storing the client at exit
405
255
current_checker_command: string; current running checker_command
406
disable_initiator_tag: a gobject event source tag, or None
407
enabled: bool()
408
fingerprint: string (40 or 32 hexadecimal digits); used to
409
uniquely identify the client
410
host: string; available for use by the checker command
411
interval: datetime.timedelta(); How often to start a new checker
412
last_approval_request: datetime.datetime(); (UTC) or None
413
last_checked_ok: datetime.datetime(); (UTC) or None
414
415
last_checker_status: integer between 0 and 255 reflecting exit
416
status of last checker. -1 reflects crashed
417
checker, or None.
418
last_enabled: datetime.datetime(); (UTC)
419
name: string; from the config file, used in log messages and
420
D-Bus identifiers
421
secret: bytestring; sent verbatim (over TLS) to client
422
timeout: datetime.timedelta(); How long from last_checked_ok
423
until this client is disabled
424
extended_timeout: extra long timeout when password has been sent
425
runtime_expansions: Allowed attributes for runtime expansion.
426
expires: datetime.datetime(); time (UTC) when a client will be
427
disabled, or None
428
256
"""
429
257
430
runtime_expansions = ("approval_delay", "approval_duration",
431
"created", "enabled", "fingerprint",
432
"host", "interval", "last_checked_ok",
433
"last_enabled", "name", "timeout")
258
@staticmethod
259
def _datetime_to_milliseconds(dt):
260
"Convert a datetime.datetime() to milliseconds"
261
return ((dt.days * 24 * 60 * 60 * 1000)
262
+ (dt.seconds * 1000)
263
+ (dt.microseconds // 1000))
434
264
435
265
def timeout_milliseconds(self):
436
266
"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)
267
return self._datetime_to_milliseconds(self.timeout)
442
268
443
269
def interval_milliseconds(self):
444
270
"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):
271
return self._datetime_to_milliseconds(self.interval)
272
273
def __init__(self, name = None, disable_hook=None, config=None):
451
274
"""Note: the 'checker' key in 'config' sets the
452
275
'checker_command' attribute and *not* the 'checker'
453
276
attribute."""
454
277
self.name = name
455
278
if config is None:
456
279
config = {}
457
logger.debug("Creating client %r", self.name)
280
logger.debug(u"Creating client %r", self.name)
458
281
# Uppercase and remove spaces from fingerprint for later
459
282
# comparison purposes with return value from the fingerprint()
460
283
# function
461
self.fingerprint = (config["fingerprint"].upper()
462
.replace(" ", ""))
463
logger.debug(" Fingerprint: %s", self.fingerprint)
464
if "secret" in config:
465
self.secret = config["secret"].decode("base64")
466
elif "secfile" in config:
467
with open(os.path.expanduser(os.path.expandvars
468
(config["secfile"])),
469
"rb") as secfile:
284
self.fingerprint = (config[u"fingerprint"].upper()
285
.replace(u" ", u""))
286
logger.debug(u" Fingerprint: %s", self.fingerprint)
287
if u"secret" in config:
288
self.secret = config[u"secret"].decode(u"base64")
289
elif u"secfile" in config:
290
with closing(open(os.path.expanduser
291
(os.path.expandvars
292
(config[u"secfile"])))) as secfile:
470
293
self.secret = secfile.read()
471
294
else:
472
raise TypeError("No secret or secfile for client %s"
295
raise TypeError(u"No secret or secfile for client %s"
473
296
% self.name)
474
self.host = config.get("host", "")
297
self.host = config.get(u"host", u"")
475
298
self.created = datetime.datetime.utcnow()
476
self.enabled = True
477
self.last_approval_request = None
478
self.last_enabled = datetime.datetime.utcnow()
299
self.enabled = False
300
self.last_enabled = None
479
301
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"])
302
self.timeout = string_to_delta(config[u"timeout"])
303
self.interval = string_to_delta(config[u"interval"])
304
self.disable_hook = disable_hook
485
305
self.checker = None
486
306
self.checker_initiator_tag = None
487
307
self.disable_initiator_tag = None
488
self.expires = datetime.datetime.utcnow() + self.timeout
489
308
self.checker_callback_tag = None
490
self.checker_command = config["checker"]
309
self.checker_command = config[u"checker"]
491
310
self.current_checker_command = None
492
self._approved = None
493
self.approved_by_default = config.get("approved_by_default",
494
True)
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"])
500
self.changedstate = (multiprocessing_manager
501
.Condition(multiprocessing_manager
502
.Lock()))
503
self.client_structure = [attr for attr in
504
self.__dict__.iterkeys()
505
if not attr.startswith("_")]
506
self.client_structure.append("client_structure")
507
508
for name, t in inspect.getmembers(type(self),
509
lambda obj:
510
isinstance(obj,
511
property)):
512
if not name.startswith("_"):
513
self.client_structure.append(name)
514
515
# Send notice to process children that client state has changed
516
def send_changedstate(self):
517
with self.changedstate:
518
self.changedstate.notify_all()
311
self.last_connect = None
519
312
520
313
def enable(self):
521
314
"""Start this client's checker and timeout hooks"""
522
if getattr(self, "enabled", False):
315
if getattr(self, u"enabled", False):
523
316
# Already enabled
524
317
return
525
self.send_changedstate()
526
self.expires = datetime.datetime.utcnow() + self.timeout
527
self.enabled = True
528
318
self.last_enabled = datetime.datetime.utcnow()
529
self.init_checker()
530
531
def disable(self, quiet=True):
532
"""Disable this client."""
533
if not getattr(self, "enabled", False):
534
return False
535
if not quiet:
536
self.send_changedstate()
537
if not quiet:
538
logger.info("Disabling client %s", self.name)
539
if getattr(self, "disable_initiator_tag", False):
540
gobject.source_remove(self.disable_initiator_tag)
541
self.disable_initiator_tag = None
542
self.expires = None
543
if getattr(self, "checker_initiator_tag", False):
544
gobject.source_remove(self.checker_initiator_tag)
545
self.checker_initiator_tag = None
546
self.stop_checker()
547
self.enabled = False
548
# Do not run this again if called by a gobject.timeout_add
549
return False
550
551
def __del__(self):
552
self.disable()
553
554
def init_checker(self):
555
319
# Schedule a new checker to be started an 'interval' from now,
556
320
# and every interval from then on.
557
321
self.checker_initiator_tag = (gobject.timeout_add
558
322
(self.interval_milliseconds(),
559
323
self.start_checker))
324
# Also start a new checker *right now*.
325
self.start_checker()
560
326
# Schedule a disable() when 'timeout' has passed
561
327
self.disable_initiator_tag = (gobject.timeout_add
562
328
(self.timeout_milliseconds(),
563
329
self.disable))
564
# Also start a new checker *right now*.
565
self.start_checker()
330
self.enabled = True
331
332
def disable(self):
333
"""Disable this client."""
334
if not getattr(self, "enabled", False):
335
return False
336
logger.info(u"Disabling client %s", self.name)
337
if getattr(self, u"disable_initiator_tag", False):
338
gobject.source_remove(self.disable_initiator_tag)
339
self.disable_initiator_tag = None
340
if getattr(self, u"checker_initiator_tag", False):
341
gobject.source_remove(self.checker_initiator_tag)
342
self.checker_initiator_tag = None
343
self.stop_checker()
344
if self.disable_hook:
345
self.disable_hook(self)
346
self.enabled = False
347
# Do not run this again if called by a gobject.timeout_add
348
return False
349
350
def __del__(self):
351
self.disable_hook = None
352
self.disable()
566
353
567
354
def checker_callback(self, pid, condition, command):
568
355
"""The checker has completed, so take appropriate actions."""
569
356
self.checker_callback_tag = None
570
357
self.checker = None
571
358
if os.WIFEXITED(condition):
572
self.last_checker_status = os.WEXITSTATUS(condition)
573
if self.last_checker_status == 0:
574
logger.info("Checker for %(name)s succeeded",
359
exitstatus = os.WEXITSTATUS(condition)
360
if exitstatus == 0:
361
logger.info(u"Checker for %(name)s succeeded",
575
362
vars(self))
576
363
self.checked_ok()
577
364
else:
578
logger.info("Checker for %(name)s failed",
365
logger.info(u"Checker for %(name)s failed",
579
366
vars(self))
580
367
else:
581
self.last_checker_status = -1
582
logger.warning("Checker for %(name)s crashed?",
368
logger.warning(u"Checker for %(name)s crashed?",
583
369
vars(self))
584
370
585
def checked_ok(self, timeout=None):
371
def checked_ok(self):
586
372
"""Bump up the timeout for this client.
587
373
588
374
This should only be called when the client has been seen,
589
375
alive and well.
590
376
"""
591
if timeout is None:
592
timeout = self.timeout
593
377
self.last_checked_ok = datetime.datetime.utcnow()
594
if self.disable_initiator_tag is not None:
595
gobject.source_remove(self.disable_initiator_tag)
596
if getattr(self, "enabled", False):
597
self.disable_initiator_tag = (gobject.timeout_add
598
(_timedelta_to_milliseconds
599
(timeout), self.disable))
600
self.expires = datetime.datetime.utcnow() + timeout
601
602
def need_approval(self):
603
self.last_approval_request = datetime.datetime.utcnow()
378
gobject.source_remove(self.disable_initiator_tag)
379
self.disable_initiator_tag = (gobject.timeout_add
380
(self.timeout_milliseconds(),
381
self.disable))
604
382
605
383
def start_checker(self):
606
384
"""Start a new checker subprocess if one is not running.
613
391
# client would inevitably timeout, since no checker would get
614
392
# a chance to run to completion. If we instead leave running
615
393
# checkers alone, the checker would have to take more time
616
# than 'timeout' for the client to be disabled, which is as it
617
# should be.
394
# than 'timeout' for the client to be declared invalid, which
395
# is as it should be.
618
396
619
397
# If a checker exists, make sure it is not a zombie
620
try:
398
if self.checker is not None:
621
399
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
622
except (AttributeError, OSError) as error:
623
if (isinstance(error, OSError)
624
and error.errno != errno.ECHILD):
625
raise error
626
else:
627
400
if pid:
628
logger.warning("Checker was a zombie")
401
logger.warning(u"Checker was a zombie")
629
402
gobject.source_remove(self.checker_callback_tag)
630
403
self.checker_callback(pid, status,
631
404
self.current_checker_command)
636
409
command = self.checker_command % self.host
637
410
except TypeError:
638
411
# 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
412
escaped_attrs = dict((key,
413
re.escape(unicode(str(val),
414
errors=
415
u'replace')))
416
for key, val in
417
vars(self).iteritems())
647
418
try:
648
419
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)
420
except TypeError, error:
421
logger.error(u'Could not format string "%s":'
422
u' %s', self.checker_command, error)
652
423
return True # Try again later
653
424
self.current_checker_command = command
654
425
try:
655
logger.info("Starting checker %r for %s",
426
logger.info(u"Starting checker %r for %s",
656
427
command, self.name)
657
428
# We don't need to redirect stdout and stderr, since
658
429
# in normal mode, that is already done by daemon(),
660
431
# always replaced by /dev/null.)
661
432
self.checker = subprocess.Popen(command,
662
433
close_fds=True,
663
shell=True, cwd="/")
434
shell=True, cwd=u"/")
664
435
self.checker_callback_tag = (gobject.child_watch_add
665
436
(self.checker.pid,
666
437
self.checker_callback,
671
442
if pid:
672
443
gobject.source_remove(self.checker_callback_tag)
673
444
self.checker_callback(pid, status, command)
674
except OSError as error:
675
logger.error("Failed to start subprocess: %s",
445
except OSError, error:
446
logger.error(u"Failed to start subprocess: %s",
676
447
error)
677
448
# Re-run this periodically if run by gobject.timeout_add
678
449
return True
682
453
if self.checker_callback_tag:
683
454
gobject.source_remove(self.checker_callback_tag)
684
455
self.checker_callback_tag = None
685
if getattr(self, "checker", None) is None:
456
if getattr(self, u"checker", None) is None:
686
457
return
687
logger.debug("Stopping checker for %(name)s", vars(self))
458
logger.debug(u"Stopping checker for %(name)s", vars(self))
688
459
try:
689
460
os.kill(self.checker.pid, signal.SIGTERM)
690
#time.sleep(0.5)
461
#os.sleep(0.5)
691
462
#if self.checker.poll() is None:
692
463
# os.kill(self.checker.pid, signal.SIGKILL)
693
except OSError as error:
464
except OSError, error:
694
465
if error.errno != errno.ESRCH: # No such process
695
466
raise
696
467
self.checker = None
697
698
699
def dbus_service_property(dbus_interface, signature="v",
700
access="readwrite", byte_arrays=False):
701
"""Decorators for marking methods of a DBusObjectWithProperties to
702
become properties on the D-Bus.
703
704
The decorated method will be called with no arguments by "Get"
705
and with one argument by "Set".
706
707
The parameters, where they are supported, are the same as
708
dbus.service.method, except there is only "signature", since the
709
type from Get() and the type sent to Set() is the same.
710
"""
711
# Encoding deeply encoded byte arrays is not supported yet by the
712
# "Set" method, so we fail early here:
713
if byte_arrays and signature != "ay":
714
raise ValueError("Byte arrays not supported for non-'ay'"
715
" signature %r" % signature)
716
def decorator(func):
717
func._dbus_is_property = True
718
func._dbus_interface = dbus_interface
719
func._dbus_signature = signature
720
func._dbus_access = access
721
func._dbus_name = func.__name__
722
if func._dbus_name.endswith("_dbus_property"):
723
func._dbus_name = func._dbus_name[:-14]
724
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
725
return func
726
return decorator
727
728
729
class DBusPropertyException(dbus.exceptions.DBusException):
730
"""A base class for D-Bus property-related exceptions
731
"""
732
def __unicode__(self):
733
return unicode(str(self))
734
735
736
class DBusPropertyAccessException(DBusPropertyException):
737
"""A property's access permissions disallows an operation.
738
"""
739
pass
740
741
742
class DBusPropertyNotFound(DBusPropertyException):
743
"""An attempt was made to access a non-existing property.
744
"""
745
pass
746
747
748
class DBusObjectWithProperties(dbus.service.Object):
749
"""A D-Bus object with properties.
750
751
Classes inheriting from this can use the dbus_service_property
752
decorator to expose methods as D-Bus properties. It exposes the
753
standard Get(), Set(), and GetAll() methods on the D-Bus.
754
"""
755
756
@staticmethod
757
def _is_dbus_property(obj):
758
return getattr(obj, "_dbus_is_property", False)
759
760
def _get_all_dbus_properties(self):
761
"""Returns a generator of (name, attribute) pairs
762
"""
763
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
764
for cls in self.__class__.__mro__
765
for name, prop in
766
inspect.getmembers(cls, self._is_dbus_property))
767
768
def _get_dbus_property(self, interface_name, property_name):
769
"""Returns a bound method if one exists which is a D-Bus
770
property with the specified name and interface.
771
"""
772
for cls in self.__class__.__mro__:
773
for name, value in (inspect.getmembers
774
(cls, self._is_dbus_property)):
775
if (value._dbus_name == property_name
776
and value._dbus_interface == interface_name):
777
return value.__get__(self)
778
779
# No such property
780
raise DBusPropertyNotFound(self.dbus_object_path + ":"
781
+ interface_name + "."
782
+ property_name)
783
784
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
785
out_signature="v")
786
def Get(self, interface_name, property_name):
787
"""Standard D-Bus property Get() method, see D-Bus standard.
788
"""
789
prop = self._get_dbus_property(interface_name, property_name)
790
if prop._dbus_access == "write":
791
raise DBusPropertyAccessException(property_name)
792
value = prop()
793
if not hasattr(value, "variant_level"):
794
return value
795
return type(value)(value, variant_level=value.variant_level+1)
796
797
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
798
def Set(self, interface_name, property_name, value):
799
"""Standard D-Bus property Set() method, see D-Bus standard.
800
"""
801
prop = self._get_dbus_property(interface_name, property_name)
802
if prop._dbus_access == "read":
803
raise DBusPropertyAccessException(property_name)
804
if prop._dbus_get_args_options["byte_arrays"]:
805
# The byte_arrays option is not supported yet on
806
# signatures other than "ay".
807
if prop._dbus_signature != "ay":
808
raise ValueError
809
value = dbus.ByteArray(''.join(unichr(byte)
810
for byte in value))
811
prop(value)
812
813
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
814
out_signature="a{sv}")
815
def GetAll(self, interface_name):
816
"""Standard D-Bus property GetAll() method, see D-Bus
817
standard.
818
819
Note: Will not include properties with access="write".
820
"""
821
properties = {}
822
for name, prop in self._get_all_dbus_properties():
823
if (interface_name
824
and interface_name != prop._dbus_interface):
825
# Interface non-empty but did not match
826
continue
827
# Ignore write-only properties
828
if prop._dbus_access == "write":
829
continue
830
value = prop()
831
if not hasattr(value, "variant_level"):
832
properties[name] = value
833
continue
834
properties[name] = type(value)(value, variant_level=
835
value.variant_level+1)
836
return dbus.Dictionary(properties, signature="sv")
837
838
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
839
out_signature="s",
840
path_keyword='object_path',
841
connection_keyword='connection')
842
def Introspect(self, object_path, connection):
843
"""Standard D-Bus method, overloaded to insert property tags.
844
"""
845
xmlstring = dbus.service.Object.Introspect(self, object_path,
846
connection)
847
try:
848
document = xml.dom.minidom.parseString(xmlstring)
849
def make_tag(document, name, prop):
850
e = document.createElement("property")
851
e.setAttribute("name", name)
852
e.setAttribute("type", prop._dbus_signature)
853
e.setAttribute("access", prop._dbus_access)
854
return e
855
for if_tag in document.getElementsByTagName("interface"):
856
for tag in (make_tag(document, name, prop)
857
for name, prop
858
in self._get_all_dbus_properties()
859
if prop._dbus_interface
860
== if_tag.getAttribute("name")):
861
if_tag.appendChild(tag)
862
# Add the names to the return values for the
863
# "org.freedesktop.DBus.Properties" methods
864
if (if_tag.getAttribute("name")
865
== "org.freedesktop.DBus.Properties"):
866
for cn in if_tag.getElementsByTagName("method"):
867
if cn.getAttribute("name") == "Get":
868
for arg in cn.getElementsByTagName("arg"):
869
if (arg.getAttribute("direction")
870
== "out"):
871
arg.setAttribute("name", "value")
872
elif cn.getAttribute("name") == "GetAll":
873
for arg in cn.getElementsByTagName("arg"):
874
if (arg.getAttribute("direction")
875
== "out"):
876
arg.setAttribute("name", "props")
877
xmlstring = document.toxml("utf-8")
878
document.unlink()
879
except (AttributeError, xml.dom.DOMException,
880
xml.parsers.expat.ExpatError) as error:
881
logger.error("Failed to override Introspection method",
882
error)
883
return xmlstring
884
885
886
def datetime_to_dbus (dt, variant_level=0):
887
"""Convert a UTC datetime.datetime() to a D-Bus type."""
888
if dt is None:
889
return dbus.String("", variant_level = variant_level)
890
return dbus.String(dt.isoformat(),
891
variant_level=variant_level)
892
893
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.
898
"""
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):
906
# Ignore non-D-Bus attributes, and D-Bus attributes
907
# with the wrong interface name
908
if (not hasattr(attribute, "_dbus_interface")
909
or not attribute._dbus_interface
910
.startswith("se.recompile.Mandos")):
911
continue
912
# Create an alternate D-Bus interface name based on
913
# the current name
914
alt_interface = (attribute._dbus_interface
915
.replace("se.recompile.Mandos",
916
"se.bsnet.fukt.Mandos"))
917
# Is this a D-Bus signal?
918
if getattr(attribute, "_dbus_is_signal", False):
919
# Extract the original non-method function by
920
# black magic
921
nonmethod_func = (dict(
922
zip(attribute.func_code.co_freevars,
923
attribute.__closure__))["func"]
924
.cell_contents)
925
# Create a new, but exactly alike, function
926
# object, and decorate it to be a new D-Bus signal
927
# with the alternate D-Bus interface name
928
new_function = (dbus.service.signal
929
(alt_interface,
930
attribute._dbus_signature)
931
(types.FunctionType(
932
nonmethod_func.func_code,
933
nonmethod_func.func_globals,
934
nonmethod_func.func_name,
935
nonmethod_func.func_defaults,
936
nonmethod_func.func_closure)))
937
# Define a creator of a function to call both the
938
# old and new functions, so both the old and new
939
# signals gets sent when the function is called
940
def fixscope(func1, func2):
941
"""This function is a scope container to pass
942
func1 and func2 to the "call_both" function
943
outside of its arguments"""
944
def call_both(*args, **kwargs):
945
"""This function will emit two D-Bus
946
signals by calling func1 and func2"""
947
func1(*args, **kwargs)
948
func2(*args, **kwargs)
949
return call_both
950
# Create the "call_both" function and add it to
951
# the class
952
attr[attrname] = fixscope(attribute,
953
new_function)
954
# Is this a D-Bus method?
955
elif getattr(attribute, "_dbus_is_method", False):
956
# Create a new, but exactly alike, function
957
# object. Decorate it to be a new D-Bus method
958
# with the alternate D-Bus interface name. Add it
959
# to the class.
960
attr[attrname] = (dbus.service.method
961
(alt_interface,
962
attribute._dbus_in_signature,
963
attribute._dbus_out_signature)
964
(types.FunctionType
965
(attribute.func_code,
966
attribute.func_globals,
967
attribute.func_name,
968
attribute.func_defaults,
969
attribute.func_closure)))
970
# Is this a D-Bus property?
971
elif getattr(attribute, "_dbus_is_property", False):
972
# Create a new, but exactly alike, function
973
# object, and decorate it to be a new D-Bus
974
# property with the alternate D-Bus interface
975
# name. Add it to the class.
976
attr[attrname] = (dbus_service_property
977
(alt_interface,
978
attribute._dbus_signature,
979
attribute._dbus_access,
980
attribute
981
._dbus_get_args_options
982
["byte_arrays"])
983
(types.FunctionType
984
(attribute.func_code,
985
attribute.func_globals,
986
attribute.func_name,
987
attribute.func_defaults,
988
attribute.func_closure)))
989
return type.__new__(mcs, name, bases, attr)
990
991
992
class ClientDBus(Client, DBusObjectWithProperties):
468
469
def still_valid(self):
470
"""Has the timeout not yet passed for this client?"""
471
if not getattr(self, u"enabled", False):
472
return False
473
now = datetime.datetime.utcnow()
474
if self.last_checked_ok is None:
475
return now < (self.created + self.timeout)
476
else:
477
return now < (self.last_checked_ok + self.timeout)
478
479
480
class ClientDBus(Client, dbus.service.Object):
993
481
"""A Client class using D-Bus
994
482
995
483
Attributes:
996
484
dbus_object_path: dbus.ObjectPath
997
485
bus: dbus.SystemBus()
998
486
"""
999
1000
runtime_expansions = (Client.runtime_expansions
1001
+ ("dbus_object_path",))
1002
1003
487
# dbus.service.Object doesn't use super(), so we can't either.
1004
488
1005
489
def __init__(self, bus = None, *args, **kwargs):
1006
490
self.bus = bus
1007
491
Client.__init__(self, *args, **kwargs)
1008
1009
self._approvals_pending = 0
1010
492
# Only now, when this client is initialized, can it show up on
1011
493
# the D-Bus
1012
client_object_name = unicode(self.name).translate(
1013
{ord("."): ord("_"),
1014
ord("-"): ord("_")})
1015
494
self.dbus_object_path = (dbus.ObjectPath
1016
("/clients/" + client_object_name))
1017
DBusObjectWithProperties.__init__(self, self.bus,
1018
self.dbus_object_path)
1019
1020
def notifychangeproperty(transform_func,
1021
dbus_name, type_func=lambda x: x,
1022
variant_level=1):
1023
""" Modify a variable so that it's a property which announces
1024
its changes to DBus.
1025
1026
transform_fun: Function that takes a value and a variant_level
1027
and transforms it to a D-Bus type.
1028
dbus_name: D-Bus name of the variable
1029
type_func: Function that transform the value before sending it
1030
to the D-Bus. Default: no transform
1031
variant_level: D-Bus variant level. Default: 1
1032
"""
1033
attrname = "_{0}".format(dbus_name)
1034
def setter(self, value):
1035
if hasattr(self, "dbus_object_path"):
1036
if (not hasattr(self, attrname) or
1037
type_func(getattr(self, attrname, None))
1038
!= type_func(value)):
1039
dbus_value = transform_func(type_func(value),
1040
variant_level
1041
=variant_level)
1042
self.PropertyChanged(dbus.String(dbus_name),
1043
dbus_value)
1044
setattr(self, attrname, value)
1045
1046
return property(lambda self: getattr(self, attrname), setter)
1047
1048
1049
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1050
approvals_pending = notifychangeproperty(dbus.Boolean,
1051
"ApprovalPending",
1052
type_func = bool)
1053
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1054
last_enabled = notifychangeproperty(datetime_to_dbus,
1055
"LastEnabled")
1056
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1057
type_func = lambda checker:
1058
checker is not None)
1059
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1060
"LastCheckedOK")
1061
last_approval_request = notifychangeproperty(
1062
datetime_to_dbus, "LastApprovalRequest")
1063
approved_by_default = notifychangeproperty(dbus.Boolean,
1064
"ApprovedByDefault")
1065
approval_delay = notifychangeproperty(dbus.UInt16,
1066
"ApprovalDelay",
1067
type_func =
1068
_timedelta_to_milliseconds)
1069
approval_duration = notifychangeproperty(
1070
dbus.UInt16, "ApprovalDuration",
1071
type_func = _timedelta_to_milliseconds)
1072
host = notifychangeproperty(dbus.String, "Host")
1073
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1074
type_func =
1075
_timedelta_to_milliseconds)
1076
extended_timeout = notifychangeproperty(
1077
dbus.UInt16, "ExtendedTimeout",
1078
type_func = _timedelta_to_milliseconds)
1079
interval = notifychangeproperty(dbus.UInt16,
1080
"Interval",
1081
type_func =
1082
_timedelta_to_milliseconds)
1083
checker_command = notifychangeproperty(dbus.String, "Checker")
1084
1085
del notifychangeproperty
495
(u"/clients/"
496
+ self.name.replace(u".", u"_")))
497
dbus.service.Object.__init__(self, self.bus,
498
self.dbus_object_path)
499
500
@staticmethod
501
def _datetime_to_dbus(dt, variant_level=0):
502
"""Convert a UTC datetime.datetime() to a D-Bus type."""
503
return dbus.String(dt.isoformat(),
504
variant_level=variant_level)
505
506
def enable(self):
507
oldstate = getattr(self, u"enabled", False)
508
r = Client.enable(self)
509
if oldstate != self.enabled:
510
# Emit D-Bus signals
511
self.PropertyChanged(dbus.String(u"enabled"),
512
dbus.Boolean(True, variant_level=1))
513
self.PropertyChanged(
514
dbus.String(u"last_enabled"),
515
self._datetime_to_dbus(self.last_enabled,
516
variant_level=1))
517
return r
518
519
def disable(self, signal = True):
520
oldstate = getattr(self, u"enabled", False)
521
r = Client.disable(self)
522
if signal and oldstate != self.enabled:
523
# Emit D-Bus signal
524
self.PropertyChanged(dbus.String(u"enabled"),
525
dbus.Boolean(False, variant_level=1))
526
return r
1086
527
1087
528
def __del__(self, *args, **kwargs):
1088
529
try:
1089
530
self.remove_from_connection()
1090
531
except LookupError:
1091
532
pass
1092
if hasattr(DBusObjectWithProperties, "__del__"):
1093
DBusObjectWithProperties.__del__(self, *args, **kwargs)
533
if hasattr(dbus.service.Object, u"__del__"):
534
dbus.service.Object.__del__(self, *args, **kwargs)
1094
535
Client.__del__(self, *args, **kwargs)
1095
536
1096
537
def checker_callback(self, pid, condition, command,
1097
538
*args, **kwargs):
1098
539
self.checker_callback_tag = None
1099
540
self.checker = None
541
# Emit D-Bus signal
542
self.PropertyChanged(dbus.String(u"checker_running"),
543
dbus.Boolean(False, variant_level=1))
1100
544
if os.WIFEXITED(condition):
1101
545
exitstatus = os.WEXITSTATUS(condition)
1102
546
# Emit D-Bus signal
1112
556
return Client.checker_callback(self, pid, condition, command,
1113
557
*args, **kwargs)
1114
558
559
def checked_ok(self, *args, **kwargs):
560
r = Client.checked_ok(self, *args, **kwargs)
561
# Emit D-Bus signal
562
self.PropertyChanged(
563
dbus.String(u"last_checked_ok"),
564
(self._datetime_to_dbus(self.last_checked_ok,
565
variant_level=1)))
566
return r
567
1115
568
def start_checker(self, *args, **kwargs):
1116
569
old_checker = self.checker
1117
570
if self.checker is not None:
1124
577
and old_checker_pid != self.checker.pid):
1125
578
# Emit D-Bus signal
1126
579
self.CheckerStarted(self.current_checker_command)
1127
return r
1128
1129
def _reset_approved(self):
1130
self._approved = None
1131
return False
1132
1133
def approve(self, value=True):
1134
self.send_changedstate()
1135
self._approved = value
1136
gobject.timeout_add(_timedelta_to_milliseconds
1137
(self.approval_duration),
1138
self._reset_approved)
1139
1140
1141
## D-Bus methods, signals & properties
1142
_interface = "se.recompile.Mandos.Client"
1143
1144
## Signals
580
self.PropertyChanged(
581
dbus.String(u"checker_running"),
582
dbus.Boolean(True, variant_level=1))
583
return r
584
585
def stop_checker(self, *args, **kwargs):
586
old_checker = getattr(self, u"checker", None)
587
r = Client.stop_checker(self, *args, **kwargs)
588
if (old_checker is not None
589
and getattr(self, u"checker", None) is None):
590
self.PropertyChanged(dbus.String(u"checker_running"),
591
dbus.Boolean(False, variant_level=1))
592
return r
593
594
## D-Bus methods & signals
595
_interface = u"se.bsnet.fukt.Mandos.Client"
596
597
# CheckedOK - method
598
@dbus.service.method(_interface)
599
def CheckedOK(self):
600
return self.checked_ok()
1145
601
1146
602
# CheckerCompleted - signal
1147
@dbus.service.signal(_interface, signature="nxs")
603
@dbus.service.signal(_interface, signature=u"nxs")
1148
604
def CheckerCompleted(self, exitcode, waitstatus, command):
1149
605
"D-Bus signal"
1150
606
pass
1151
607
1152
608
# CheckerStarted - signal
1153
@dbus.service.signal(_interface, signature="s")
609
@dbus.service.signal(_interface, signature=u"s")
1154
610
def CheckerStarted(self, command):
1155
611
"D-Bus signal"
1156
612
pass
1157
613
614
# GetAllProperties - method
615
@dbus.service.method(_interface, out_signature=u"a{sv}")
616
def GetAllProperties(self):
617
"D-Bus method"
618
return dbus.Dictionary({
619
dbus.String(u"name"):
620
dbus.String(self.name, variant_level=1),
621
dbus.String(u"fingerprint"):
622
dbus.String(self.fingerprint, variant_level=1),
623
dbus.String(u"host"):
624
dbus.String(self.host, variant_level=1),
625
dbus.String(u"created"):
626
self._datetime_to_dbus(self.created,
627
variant_level=1),
628
dbus.String(u"last_enabled"):
629
(self._datetime_to_dbus(self.last_enabled,
630
variant_level=1)
631
if self.last_enabled is not None
632
else dbus.Boolean(False, variant_level=1)),
633
dbus.String(u"enabled"):
634
dbus.Boolean(self.enabled, variant_level=1),
635
dbus.String(u"last_checked_ok"):
636
(self._datetime_to_dbus(self.last_checked_ok,
637
variant_level=1)
638
if self.last_checked_ok is not None
639
else dbus.Boolean (False, variant_level=1)),
640
dbus.String(u"timeout"):
641
dbus.UInt64(self.timeout_milliseconds(),
642
variant_level=1),
643
dbus.String(u"interval"):
644
dbus.UInt64(self.interval_milliseconds(),
645
variant_level=1),
646
dbus.String(u"checker"):
647
dbus.String(self.checker_command,
648
variant_level=1),
649
dbus.String(u"checker_running"):
650
dbus.Boolean(self.checker is not None,
651
variant_level=1),
652
dbus.String(u"object_path"):
653
dbus.ObjectPath(self.dbus_object_path,
654
variant_level=1)
655
}, signature=u"sv")
656
657
# IsStillValid - method
658
@dbus.service.method(_interface, out_signature=u"b")
659
def IsStillValid(self):
660
return self.still_valid()
661
1158
662
# PropertyChanged - signal
1159
@dbus.service.signal(_interface, signature="sv")
663
@dbus.service.signal(_interface, signature=u"sv")
1160
664
def PropertyChanged(self, property, value):
1161
665
"D-Bus signal"
1162
666
pass
1163
667
1164
# GotSecret - signal
668
# ReceivedSecret - signal
1165
669
@dbus.service.signal(_interface)
1166
def GotSecret(self):
1167
"""D-Bus signal
1168
Is sent after a successful transfer of secret from the Mandos
1169
server to mandos-client
1170
"""
670
def ReceivedSecret(self):
671
"D-Bus signal"
1171
672
pass
1172
673
1173
674
# Rejected - signal
1174
@dbus.service.signal(_interface, signature="s")
1175
def Rejected(self, reason):
1176
"D-Bus signal"
1177
pass
1178
1179
# NeedApproval - signal
1180
@dbus.service.signal(_interface, signature="tb")
1181
def NeedApproval(self, timeout, default):
1182
"D-Bus signal"
1183
return self.need_approval()
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
1193
## Methods
1194
1195
# Approve - method
1196
@dbus.service.method(_interface, in_signature="b")
1197
def Approve(self, value):
1198
self.approve(value)
1199
1200
# CheckedOK - method
1201
@dbus.service.method(_interface)
1202
def CheckedOK(self):
1203
self.checked_ok()
675
@dbus.service.signal(_interface)
676
def Rejected(self):
677
"D-Bus signal"
678
pass
679
680
# SetChecker - method
681
@dbus.service.method(_interface, in_signature=u"s")
682
def SetChecker(self, checker):
683
"D-Bus setter method"
684
self.checker_command = checker
685
# Emit D-Bus signal
686
self.PropertyChanged(dbus.String(u"checker"),
687
dbus.String(self.checker_command,
688
variant_level=1))
689
690
# SetHost - method
691
@dbus.service.method(_interface, in_signature=u"s")
692
def SetHost(self, host):
693
"D-Bus setter method"
694
self.host = host
695
# Emit D-Bus signal
696
self.PropertyChanged(dbus.String(u"host"),
697
dbus.String(self.host, variant_level=1))
698
699
# SetInterval - method
700
@dbus.service.method(_interface, in_signature=u"t")
701
def SetInterval(self, milliseconds):
702
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
703
# Emit D-Bus signal
704
self.PropertyChanged(dbus.String(u"interval"),
705
(dbus.UInt64(self.interval_milliseconds(),
706
variant_level=1)))
707
708
# SetSecret - method
709
@dbus.service.method(_interface, in_signature=u"ay",
710
byte_arrays=True)
711
def SetSecret(self, secret):
712
"D-Bus setter method"
713
self.secret = str(secret)
714
715
# SetTimeout - method
716
@dbus.service.method(_interface, in_signature=u"t")
717
def SetTimeout(self, milliseconds):
718
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
719
# Emit D-Bus signal
720
self.PropertyChanged(dbus.String(u"timeout"),
721
(dbus.UInt64(self.timeout_milliseconds(),
722
variant_level=1)))
1204
723
1205
724
# Enable - method
1206
725
@dbus.service.method(_interface)
1225
744
def StopChecker(self):
1226
745
self.stop_checker()
1227
746
1228
## Properties
1229
1230
# ApprovalPending - property
1231
@dbus_service_property(_interface, signature="b", access="read")
1232
def ApprovalPending_dbus_property(self):
1233
return dbus.Boolean(bool(self.approvals_pending))
1234
1235
# ApprovedByDefault - property
1236
@dbus_service_property(_interface, signature="b",
1237
access="readwrite")
1238
def ApprovedByDefault_dbus_property(self, value=None):
1239
if value is None: # get
1240
return dbus.Boolean(self.approved_by_default)
1241
self.approved_by_default = bool(value)
1242
1243
# ApprovalDelay - property
1244
@dbus_service_property(_interface, signature="t",
1245
access="readwrite")
1246
def ApprovalDelay_dbus_property(self, value=None):
1247
if value is None: # get
1248
return dbus.UInt64(self.approval_delay_milliseconds())
1249
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1250
1251
# ApprovalDuration - property
1252
@dbus_service_property(_interface, signature="t",
1253
access="readwrite")
1254
def ApprovalDuration_dbus_property(self, value=None):
1255
if value is None: # get
1256
return dbus.UInt64(_timedelta_to_milliseconds(
1257
self.approval_duration))
1258
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1259
1260
# Name - property
1261
@dbus_service_property(_interface, signature="s", access="read")
1262
def Name_dbus_property(self):
1263
return dbus.String(self.name)
1264
1265
# Fingerprint - property
1266
@dbus_service_property(_interface, signature="s", access="read")
1267
def Fingerprint_dbus_property(self):
1268
return dbus.String(self.fingerprint)
1269
1270
# Host - property
1271
@dbus_service_property(_interface, signature="s",
1272
access="readwrite")
1273
def Host_dbus_property(self, value=None):
1274
if value is None: # get
1275
return dbus.String(self.host)
1276
self.host = value
1277
1278
# Created - property
1279
@dbus_service_property(_interface, signature="s", access="read")
1280
def Created_dbus_property(self):
1281
return dbus.String(datetime_to_dbus(self.created))
1282
1283
# LastEnabled - property
1284
@dbus_service_property(_interface, signature="s", access="read")
1285
def LastEnabled_dbus_property(self):
1286
return datetime_to_dbus(self.last_enabled)
1287
1288
# Enabled - property
1289
@dbus_service_property(_interface, signature="b",
1290
access="readwrite")
1291
def Enabled_dbus_property(self, value=None):
1292
if value is None: # get
1293
return dbus.Boolean(self.enabled)
1294
if value:
1295
self.enable()
1296
else:
1297
self.disable()
1298
1299
# LastCheckedOK - property
1300
@dbus_service_property(_interface, signature="s",
1301
access="readwrite")
1302
def LastCheckedOK_dbus_property(self, value=None):
1303
if value is not None:
1304
self.checked_ok()
1305
return
1306
return datetime_to_dbus(self.last_checked_ok)
1307
1308
# Expires - property
1309
@dbus_service_property(_interface, signature="s", access="read")
1310
def Expires_dbus_property(self):
1311
return datetime_to_dbus(self.expires)
1312
1313
# LastApprovalRequest - property
1314
@dbus_service_property(_interface, signature="s", access="read")
1315
def LastApprovalRequest_dbus_property(self):
1316
return datetime_to_dbus(self.last_approval_request)
1317
1318
# Timeout - property
1319
@dbus_service_property(_interface, signature="t",
1320
access="readwrite")
1321
def Timeout_dbus_property(self, value=None):
1322
if value is None: # get
1323
return dbus.UInt64(self.timeout_milliseconds())
1324
self.timeout = datetime.timedelta(0, 0, 0, value)
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))
1345
1346
# ExtendedTimeout - property
1347
@dbus_service_property(_interface, signature="t",
1348
access="readwrite")
1349
def ExtendedTimeout_dbus_property(self, value=None):
1350
if value is None: # get
1351
return dbus.UInt64(self.extended_timeout_milliseconds())
1352
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1353
1354
# Interval - property
1355
@dbus_service_property(_interface, signature="t",
1356
access="readwrite")
1357
def Interval_dbus_property(self, value=None):
1358
if value is None: # get
1359
return dbus.UInt64(self.interval_milliseconds())
1360
self.interval = datetime.timedelta(0, 0, 0, value)
1361
if getattr(self, "checker_initiator_tag", None) is None:
1362
return
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
1368
1369
# Checker - property
1370
@dbus_service_property(_interface, signature="s",
1371
access="readwrite")
1372
def Checker_dbus_property(self, value=None):
1373
if value is None: # get
1374
return dbus.String(self.checker_command)
1375
self.checker_command = value
1376
1377
# CheckerRunning - property
1378
@dbus_service_property(_interface, signature="b",
1379
access="readwrite")
1380
def CheckerRunning_dbus_property(self, value=None):
1381
if value is None: # get
1382
return dbus.Boolean(self.checker is not None)
1383
if value:
1384
self.start_checker()
1385
else:
1386
self.stop_checker()
1387
1388
# ObjectPath - property
1389
@dbus_service_property(_interface, signature="o", access="read")
1390
def ObjectPath_dbus_property(self):
1391
return self.dbus_object_path # is already a dbus.ObjectPath
1392
1393
# Secret = property
1394
@dbus_service_property(_interface, signature="ay",
1395
access="write", byte_arrays=True)
1396
def Secret_dbus_property(self, value):
1397
self.secret = str(value)
1398
1399
747
del _interface
1400
748
1401
749
1402
class ProxyClient(object):
1403
def __init__(self, child_pipe, fpr, address):
1404
self._pipe = child_pipe
1405
self._pipe.send(('init', fpr, address))
1406
if not self._pipe.recv():
1407
raise KeyError()
1408
1409
def __getattribute__(self, name):
1410
if(name == '_pipe'):
1411
return super(ProxyClient, self).__getattribute__(name)
1412
self._pipe.send(('getattr', name))
1413
data = self._pipe.recv()
1414
if data[0] == 'data':
1415
return data[1]
1416
if data[0] == 'function':
1417
def func(*args, **kwargs):
1418
self._pipe.send(('funcall', name, args, kwargs))
1419
return self._pipe.recv()[1]
1420
return func
1421
1422
def __setattr__(self, name, value):
1423
if(name == '_pipe'):
1424
return super(ProxyClient, self).__setattr__(name, value)
1425
self._pipe.send(('setattr', name, value))
1426
1427
1428
class ClientDBusTransitional(ClientDBus):
1429
__metaclass__ = AlternateDBusNamesMetaclass
1430
1431
1432
750
class ClientHandler(socketserver.BaseRequestHandler, object):
1433
751
"""A class to handle client connections.
1434
752
1436
754
Note: This will run in its own forked process."""
1437
755
1438
756
def handle(self):
1439
with contextlib.closing(self.server.child_pipe) as child_pipe:
1440
logger.info("TCP connection from: %s",
1441
unicode(self.client_address))
1442
logger.debug("Pipe FD: %d",
1443
self.server.child_pipe.fileno())
1444
757
logger.info(u"TCP connection from: %s",
758
unicode(self.client_address))
759
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
760
# Open IPC pipe to parent process
761
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1445
762
session = (gnutls.connection
1446
763
.ClientSession(self.request,
1447
764
gnutls.connection
1448
765
.X509Credentials()))
1449
766
767
line = self.request.makefile().readline()
768
logger.debug(u"Protocol version: %r", line)
769
try:
770
if int(line.strip().split()[0]) > 1:
771
raise RuntimeError
772
except (ValueError, IndexError, RuntimeError), error:
773
logger.error(u"Unknown protocol version: %s", error)
774
return
775
1450
776
# Note: gnutls.connection.X509Credentials is really a
1451
777
# generic GnuTLS certificate credentials object so long as
1452
778
# no X.509 keys are added to it. Therefore, we can use it
1453
779
# here despite using OpenPGP certificates.
1454
780
1455
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1456
# "+AES-256-CBC", "+SHA1",
1457
# "+COMP-NULL", "+CTYPE-OPENPGP",
1458
# "+DHE-DSS"))
781
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
782
# u"+AES-256-CBC", u"+SHA1",
783
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
784
# u"+DHE-DSS"))
1459
785
# Use a fallback default, since this MUST be set.
1460
786
priority = self.server.gnutls_priority
1461
787
if priority is None:
1462
priority = "NORMAL"
788
priority = u"NORMAL"
1463
789
(gnutls.library.functions
1464
790
.gnutls_priority_set_direct(session._c_object,
1465
791
priority, None))
1466
792
1467
# Start communication using the Mandos protocol
1468
# Get protocol number
1469
line = self.request.makefile().readline()
1470
logger.debug("Protocol version: %r", line)
1471
try:
1472
if int(line.strip().split()[0]) > 1:
1473
raise RuntimeError
1474
except (ValueError, IndexError, RuntimeError) as error:
1475
logger.error("Unknown protocol version: %s", error)
1476
return
1477
1478
# Start GnuTLS connection
1479
793
try:
1480
794
session.handshake()
1481
except gnutls.errors.GNUTLSError as error:
1482
logger.warning("Handshake failed: %s", error)
795
except gnutls.errors.GNUTLSError, error:
796
logger.warning(u"Handshake failed: %s", error)
1483
797
# Do not run session.bye() here: the session is not
1484
798
# established. Just abandon the request.
1485
799
return
1486
logger.debug("Handshake succeeded")
1487
1488
approval_required = False
800
logger.debug(u"Handshake succeeded")
1489
801
try:
1490
try:
1491
fpr = self.fingerprint(self.peer_certificate
1492
(session))
1493
except (TypeError,
1494
gnutls.errors.GNUTLSError) as error:
1495
logger.warning("Bad certificate: %s", error)
1496
return
1497
logger.debug("Fingerprint: %s", fpr)
1498
if self.server.use_dbus:
1499
# Emit D-Bus signal
1500
client.NewRequest(str(self.client_address))
1501
1502
try:
1503
client = ProxyClient(child_pipe, fpr,
1504
self.client_address)
1505
except KeyError:
1506
return
1507
1508
if client.approval_delay:
1509
delay = client.approval_delay
1510
client.approvals_pending += 1
1511
approval_required = True
1512
1513
while True:
1514
if not client.enabled:
1515
logger.info("Client %s is disabled",
1516
client.name)
1517
if self.server.use_dbus:
1518
# Emit D-Bus signal
1519
client.Rejected("Disabled")
1520
return
1521
1522
if client._approved or not client.approval_delay:
1523
#We are approved or approval is disabled
1524
break
1525
elif client._approved is None:
1526
logger.info("Client %s needs approval",
1527
client.name)
1528
if self.server.use_dbus:
1529
# Emit D-Bus signal
1530
client.NeedApproval(
1531
client.approval_delay_milliseconds(),
1532
client.approved_by_default)
1533
else:
1534
logger.warning("Client %s was not approved",
1535
client.name)
1536
if self.server.use_dbus:
1537
# Emit D-Bus signal
1538
client.Rejected("Denied")
1539
return
1540
1541
#wait until timeout or approved
1542
time = datetime.datetime.now()
1543
client.changedstate.acquire()
1544
(client.changedstate.wait
1545
(float(client._timedelta_to_milliseconds(delay)
1546
/ 1000)))
1547
client.changedstate.release()
1548
time2 = datetime.datetime.now()
1549
if (time2 - time) >= delay:
1550
if not client.approved_by_default:
1551
logger.warning("Client %s timed out while"
1552
" waiting for approval",
1553
client.name)
1554
if self.server.use_dbus:
1555
# Emit D-Bus signal
1556
client.Rejected("Approval timed out")
1557
return
1558
else:
1559
break
1560
else:
1561
delay -= time2 - time
1562
1563
sent_size = 0
1564
while sent_size < len(client.secret):
1565
try:
1566
sent = session.send(client.secret[sent_size:])
1567
except gnutls.errors.GNUTLSError as error:
1568
logger.warning("gnutls send failed")
1569
return
1570
logger.debug("Sent: %d, remaining: %d",
1571
sent, len(client.secret)
1572
- (sent_size + sent))
1573
sent_size += sent
1574
1575
logger.info("Sending secret to %s", client.name)
1576
# bump the timeout using extended_timeout
1577
client.checked_ok(client.extended_timeout)
1578
if self.server.use_dbus:
1579
# Emit D-Bus signal
1580
client.GotSecret()
802
fpr = self.fingerprint(self.peer_certificate(session))
803
except (TypeError, gnutls.errors.GNUTLSError), error:
804
logger.warning(u"Bad certificate: %s", error)
805
session.bye()
806
return
807
logger.debug(u"Fingerprint: %s", fpr)
1581
808
1582
finally:
1583
if approval_required:
1584
client.approvals_pending -= 1
1585
try:
1586
session.bye()
1587
except gnutls.errors.GNUTLSError as error:
1588
logger.warning("GnuTLS bye failed")
809
for c in self.server.clients:
810
if c.fingerprint == fpr:
811
client = c
812
break
813
else:
814
ipc.write(u"NOTFOUND %s %s\n"
815
% (fpr, unicode(self.client_address)))
816
session.bye()
817
return
818
# Have to check if client.still_valid(), since it is
819
# possible that the client timed out while establishing
820
# the GnuTLS session.
821
if not client.still_valid():
822
ipc.write(u"INVALID %s\n" % client.name)
823
session.bye()
824
return
825
ipc.write(u"SENDING %s\n" % client.name)
826
sent_size = 0
827
while sent_size < len(client.secret):
828
sent = session.send(client.secret[sent_size:])
829
logger.debug(u"Sent: %d, remaining: %d",
830
sent, len(client.secret)
831
- (sent_size + sent))
832
sent_size += sent
833
session.bye()
1589
834
1590
835
@staticmethod
1591
836
def peer_certificate(session):
1601
846
.gnutls_certificate_get_peers
1602
847
(session._c_object, ctypes.byref(list_size)))
1603
848
if not bool(cert_list) and list_size.value != 0:
1604
raise gnutls.errors.GNUTLSError("error getting peer"
1605
" certificate")
849
raise gnutls.errors.GNUTLSError(u"error getting peer"
850
u" certificate")
1606
851
if list_size.value == 0:
1607
852
return None
1608
853
cert = cert_list[0]
1634
879
if crtverify.value != 0:
1635
880
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1636
881
raise (gnutls.errors.CertificateSecurityError
1637
("Verify failed"))
882
(u"Verify failed"))
1638
883
# New buffer for the fingerprint
1639
884
buf = ctypes.create_string_buffer(20)
1640
885
buf_len = ctypes.c_size_t()
1647
892
# Convert the buffer to a Python bytestring
1648
893
fpr = ctypes.string_at(buf, buf_len.value)
1649
894
# Convert the bytestring to hexadecimal notation
1650
hex_fpr = binascii.hexlify(fpr).upper()
895
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1651
896
return hex_fpr
1652
897
1653
898
1654
class MultiprocessingMixIn(object):
1655
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1656
def sub_process_main(self, request, address):
1657
try:
1658
self.finish_request(request, address)
1659
except:
1660
self.handle_error(request, address)
1661
self.close_request(request)
1662
1663
def process_request(self, request, address):
1664
"""Start a new process to process the request."""
1665
proc = multiprocessing.Process(target = self.sub_process_main,
1666
args = (request,
1667
address))
1668
proc.start()
1669
return proc
1670
1671
1672
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1673
""" adds a pipe to the MixIn """
899
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
900
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
1674
901
def process_request(self, request, client_address):
1675
902
"""Overrides and wraps the original process_request().
1676
903
1677
904
This function creates a new pipe in self.pipe
1678
905
"""
1679
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1680
1681
proc = MultiprocessingMixIn.process_request(self, request,
1682
client_address)
1683
self.child_pipe.close()
1684
self.add_pipe(parent_pipe, proc)
1685
1686
def add_pipe(self, parent_pipe, proc):
906
self.pipe = os.pipe()
907
super(ForkingMixInWithPipe,
908
self).process_request(request, client_address)
909
os.close(self.pipe[1]) # close write end
910
self.add_pipe(self.pipe[0])
911
def add_pipe(self, pipe):
1687
912
"""Dummy function; override as necessary"""
1688
raise NotImplementedError
1689
1690
1691
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
913
os.close(pipe)
914
915
916
class IPv6_TCPServer(ForkingMixInWithPipe,
1692
917
socketserver.TCPServer, object):
1693
918
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1694
919
1710
935
bind to an address or port if they were not specified."""
1711
936
if self.interface is not None:
1712
937
if SO_BINDTODEVICE is None:
1713
logger.error("SO_BINDTODEVICE does not exist;"
1714
" cannot bind to interface %s",
938
logger.error(u"SO_BINDTODEVICE does not exist;"
939
u" cannot bind to interface %s",
1715
940
self.interface)
1716
941
else:
1717
942
try:
1718
943
self.socket.setsockopt(socket.SOL_SOCKET,
1719
944
SO_BINDTODEVICE,
1720
945
str(self.interface
1721
+ '\0'))
1722
except socket.error as error:
946
+ u'\0'))
947
except socket.error, error:
1723
948
if error[0] == errno.EPERM:
1724
logger.error("No permission to"
1725
" bind to interface %s",
949
logger.error(u"No permission to"
950
u" bind to interface %s",
1726
951
self.interface)
1727
952
elif error[0] == errno.ENOPROTOOPT:
1728
logger.error("SO_BINDTODEVICE not available;"
1729
" cannot bind to interface %s",
953
logger.error(u"SO_BINDTODEVICE not available;"
954
u" cannot bind to interface %s",
1730
955
self.interface)
1731
956
else:
1732
957
raise
1734
959
if self.server_address[0] or self.server_address[1]:
1735
960
if not self.server_address[0]:
1736
961
if self.address_family == socket.AF_INET6:
1737
any_address = "::" # in6addr_any
962
any_address = u"::" # in6addr_any
1738
963
else:
1739
964
any_address = socket.INADDR_ANY
1740
965
self.server_address = (any_address,
1758
983
clients: set of Client objects
1759
984
gnutls_priority GnuTLS priority string
1760
985
use_dbus: Boolean; to emit D-Bus signals or not
986
clients: set of Client objects
987
gnutls_priority GnuTLS priority string
988
use_dbus: Boolean; to emit D-Bus signals or not
1761
989
1762
990
Assumes a gobject.MainLoop event loop.
1763
991
"""
1767
995
self.enabled = False
1768
996
self.clients = clients
1769
997
if self.clients is None:
1770
self.clients = {}
998
self.clients = set()
1771
999
self.use_dbus = use_dbus
1772
1000
self.gnutls_priority = gnutls_priority
1773
1001
IPv6_TCPServer.__init__(self, server_address,
1777
1005
def server_activate(self):
1778
1006
if self.enabled:
1779
1007
return socketserver.TCPServer.server_activate(self)
1780
1781
1008
def enable(self):
1782
1009
self.enabled = True
1783
1784
def add_pipe(self, parent_pipe, proc):
1010
def add_pipe(self, pipe):
1785
1011
# Call "handle_ipc" for both data and EOF events
1786
gobject.io_add_watch(parent_pipe.fileno(),
1787
gobject.IO_IN | gobject.IO_HUP,
1788
functools.partial(self.handle_ipc,
1789
parent_pipe =
1790
parent_pipe,
1791
proc = proc))
1792
1793
def handle_ipc(self, source, condition, parent_pipe=None,
1794
proc = None, client_object=None):
1012
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1013
self.handle_ipc)
1014
def handle_ipc(self, source, condition, file_objects={}):
1795
1015
condition_names = {
1796
gobject.IO_IN: "IN", # There is data to read.
1797
gobject.IO_OUT: "OUT", # Data can be written (without
1016
gobject.IO_IN: u"IN", # There is data to read.
1017
gobject.IO_OUT: u"OUT", # Data can be written (without
1798
1018
# 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
1019
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1020
gobject.IO_ERR: u"ERR", # Error condition.
1021
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1802
1022
# broken, usually for pipes and
1803
1023
# sockets).
1804
1024
}
1806
1026
for cond, name in
1807
1027
condition_names.iteritems()
1808
1028
if cond & condition)
1809
# error, or the other end of multiprocessing.Pipe has closed
1810
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1811
# Wait for other process to exit
1812
proc.join()
1813
return False
1814
1815
# Read a request from the child
1816
request = parent_pipe.recv()
1817
command = request[0]
1818
1819
if command == 'init':
1820
fpr = request[1]
1821
address = request[2]
1822
1823
for c in self.clients.itervalues():
1824
if c.fingerprint == fpr:
1825
client = c
1826
break
1827
else:
1828
logger.info("Client not found for fingerprint: %s, ad"
1829
"dress: %s", fpr, address)
1830
if self.use_dbus:
1831
# Emit D-Bus signal
1832
mandos_dbus_service.ClientNotFound(fpr,
1833
address[0])
1834
parent_pipe.send(False)
1835
return False
1836
1837
gobject.io_add_watch(parent_pipe.fileno(),
1838
gobject.IO_IN | gobject.IO_HUP,
1839
functools.partial(self.handle_ipc,
1840
parent_pipe =
1841
parent_pipe,
1842
proc = proc,
1843
client_object =
1844
client))
1845
parent_pipe.send(True)
1846
# remove the old hook in favor of the new above hook on
1847
# same fileno
1848
return False
1849
if command == 'funcall':
1850
funcname = request[1]
1851
args = request[2]
1852
kwargs = request[3]
1853
1854
parent_pipe.send(('data', getattr(client_object,
1855
funcname)(*args,
1856
**kwargs)))
1857
1858
if command == 'getattr':
1859
attrname = request[1]
1860
if callable(client_object.__getattribute__(attrname)):
1861
parent_pipe.send(('function',))
1862
else:
1863
parent_pipe.send(('data', client_object
1864
.__getattribute__(attrname)))
1865
1866
if command == 'setattr':
1867
attrname = request[1]
1868
value = request[2]
1869
setattr(client_object, attrname, value)
1870
1029
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1030
conditions_string)
1031
1032
# Turn the pipe file descriptor into a Python file object
1033
if source not in file_objects:
1034
file_objects[source] = os.fdopen(source, u"r", 1)
1035
1036
# Read a line from the file object
1037
cmdline = file_objects[source].readline()
1038
if not cmdline: # Empty line means end of file
1039
# close the IPC pipe
1040
file_objects[source].close()
1041
del file_objects[source]
1042
1043
# Stop calling this function
1044
return False
1045
1046
logger.debug(u"IPC command: %r", cmdline)
1047
1048
# Parse and act on command
1049
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1050
1051
if cmd == u"NOTFOUND":
1052
logger.warning(u"Client not found for fingerprint: %s",
1053
args)
1054
if self.use_dbus:
1055
# Emit D-Bus signal
1056
mandos_dbus_service.ClientNotFound(args)
1057
elif cmd == u"INVALID":
1058
for client in self.clients:
1059
if client.name == args:
1060
logger.warning(u"Client %s is invalid", args)
1061
if self.use_dbus:
1062
# Emit D-Bus signal
1063
client.Rejected()
1064
break
1065
else:
1066
logger.error(u"Unknown client %s is invalid", args)
1067
elif cmd == u"SENDING":
1068
for client in self.clients:
1069
if client.name == args:
1070
logger.info(u"Sending secret to %s", client.name)
1071
client.checked_ok()
1072
if self.use_dbus:
1073
# Emit D-Bus signal
1074
client.ReceivedSecret()
1075
break
1076
else:
1077
logger.error(u"Sending secret to unknown client %s",
1078
args)
1079
else:
1080
logger.error(u"Unknown IPC command: %r", cmdline)
1081
1082
# Keep calling this function
1871
1083
return True
1872
1084
1873
1085
1874
1086
def string_to_delta(interval):
1875
1087
"""Parse a string and return a datetime.timedelta
1876
1088
1877
>>> string_to_delta('7d')
1089
>>> string_to_delta(u'7d')
1878
1090
datetime.timedelta(7)
1879
>>> string_to_delta('60s')
1091
>>> string_to_delta(u'60s')
1880
1092
datetime.timedelta(0, 60)
1881
>>> string_to_delta('60m')
1093
>>> string_to_delta(u'60m')
1882
1094
datetime.timedelta(0, 3600)
1883
>>> string_to_delta('24h')
1095
>>> string_to_delta(u'24h')
1884
1096
datetime.timedelta(1)
1885
>>> string_to_delta('1w')
1097
>>> string_to_delta(u'1w')
1886
1098
datetime.timedelta(7)
1887
>>> string_to_delta('5m 30s')
1099
>>> string_to_delta(u'5m 30s')
1888
1100
datetime.timedelta(0, 330)
1889
1101
"""
1890
1102
timevalue = datetime.timedelta(0)
1892
1104
try:
1893
1105
suffix = unicode(s[-1])
1894
1106
value = int(s[:-1])
1895
if suffix == "d":
1107
if suffix == u"d":
1896
1108
delta = datetime.timedelta(value)
1897
elif suffix == "s":
1109
elif suffix == u"s":
1898
1110
delta = datetime.timedelta(0, value)
1899
elif suffix == "m":
1111
elif suffix == u"m":
1900
1112
delta = datetime.timedelta(0, 0, 0, 0, value)
1901
elif suffix == "h":
1113
elif suffix == u"h":
1902
1114
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1903
elif suffix == "w":
1115
elif suffix == u"w":
1904
1116
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1905
1117
else:
1906
raise ValueError("Unknown suffix %r" % suffix)
1907
except (ValueError, IndexError) as e:
1908
raise ValueError(*(e.args))
1118
raise ValueError
1119
except (ValueError, IndexError):
1120
raise ValueError
1909
1121
timevalue += delta
1910
1122
return timevalue
1911
1123
1912
1124
1125
def if_nametoindex(interface):
1126
"""Call the C function if_nametoindex(), or equivalent
1127
1128
Note: This function cannot accept a unicode string."""
1129
global if_nametoindex
1130
try:
1131
if_nametoindex = (ctypes.cdll.LoadLibrary
1132
(ctypes.util.find_library(u"c"))
1133
.if_nametoindex)
1134
except (OSError, AttributeError):
1135
logger.warning(u"Doing if_nametoindex the hard way")
1136
def if_nametoindex(interface):
1137
"Get an interface index the hard way, i.e. using fcntl()"
1138
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1139
with closing(socket.socket()) as s:
1140
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1141
struct.pack(str(u"16s16x"),
1142
interface))
1143
interface_index = struct.unpack(str(u"I"),
1144
ifreq[16:20])[0]
1145
return interface_index
1146
return if_nametoindex(interface)
1147
1148
1913
1149
def daemon(nochdir = False, noclose = False):
1914
1150
"""See daemon(3). Standard BSD Unix function.
1915
1151
1918
1154
sys.exit()
1919
1155
os.setsid()
1920
1156
if not nochdir:
1921
os.chdir("/")
1157
os.chdir(u"/")
1922
1158
if os.fork():
1923
1159
sys.exit()
1924
1160
if not noclose:
1926
1162
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1927
1163
if not stat.S_ISCHR(os.fstat(null).st_mode):
1928
1164
raise OSError(errno.ENODEV,
1929
"%s not a character device"
1930
% os.path.devnull)
1165
u"/dev/null not a character device")
1931
1166
os.dup2(null, sys.stdin.fileno())
1932
1167
os.dup2(null, sys.stdout.fileno())
1933
1168
os.dup2(null, sys.stderr.fileno())
1937
1172
1938
1173
def main():
1939
1174
1940
##################################################################
1175
######################################################################
1941
1176
# Parsing of options, both command line and config file
1942
1177
1943
parser = argparse.ArgumentParser()
1944
parser.add_argument("-v", "--version", action="version",
1945
version = "%%(prog)s %s" % version,
1946
help="show version number and exit")
1947
parser.add_argument("-i", "--interface", metavar="IF",
1948
help="Bind to interface IF")
1949
parser.add_argument("-a", "--address",
1950
help="Address to listen for requests on")
1951
parser.add_argument("-p", "--port", type=int,
1952
help="Port number to receive requests on")
1953
parser.add_argument("--check", action="store_true",
1954
help="Run self-test")
1955
parser.add_argument("--debug", action="store_true",
1956
help="Debug mode; run in foreground and log"
1957
" to terminal")
1958
parser.add_argument("--debuglevel", metavar="LEVEL",
1959
help="Debug level for stdout output")
1960
parser.add_argument("--priority", help="GnuTLS"
1961
" priority string (see GnuTLS documentation)")
1962
parser.add_argument("--servicename",
1963
metavar="NAME", help="Zeroconf service name")
1964
parser.add_argument("--configdir",
1965
default="/etc/mandos", metavar="DIR",
1966
help="Directory to search for configuration"
1967
" files")
1968
parser.add_argument("--no-dbus", action="store_false",
1969
dest="use_dbus", help="Do not provide D-Bus"
1970
" system bus interface")
1971
parser.add_argument("--no-ipv6", action="store_false",
1972
dest="use_ipv6", help="Do not use IPv6")
1973
parser.add_argument("--no-restore", action="store_false",
1974
dest="restore", help="Do not restore stored"
1975
" state", default=True)
1976
1977
options = parser.parse_args()
1178
parser = optparse.OptionParser(version = "%%prog %s" % version)
1179
parser.add_option("-i", u"--interface", type=u"string",
1180
metavar="IF", help=u"Bind to interface IF")
1181
parser.add_option("-a", u"--address", type=u"string",
1182
help=u"Address to listen for requests on")
1183
parser.add_option("-p", u"--port", type=u"int",
1184
help=u"Port number to receive requests on")
1185
parser.add_option("--check", action=u"store_true",
1186
help=u"Run self-test")
1187
parser.add_option("--debug", action=u"store_true",
1188
help=u"Debug mode; run in foreground and log to"
1189
u" terminal")
1190
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1191
u" priority string (see GnuTLS documentation)")
1192
parser.add_option("--servicename", type=u"string",
1193
metavar=u"NAME", help=u"Zeroconf service name")
1194
parser.add_option("--configdir", type=u"string",
1195
default=u"/etc/mandos", metavar=u"DIR",
1196
help=u"Directory to search for configuration"
1197
u" files")
1198
parser.add_option("--no-dbus", action=u"store_false",
1199
dest=u"use_dbus", help=u"Do not provide D-Bus"
1200
u" system bus interface")
1201
parser.add_option("--no-ipv6", action=u"store_false",
1202
dest=u"use_ipv6", help=u"Do not use IPv6")
1203
options = parser.parse_args()[0]
1978
1204
1979
1205
if options.check:
1980
1206
import doctest
1982
1208
sys.exit()
1983
1209
1984
1210
# Default values for config file for server-global settings
1985
server_defaults = { "interface": "",
1986
"address": "",
1987
"port": "",
1988
"debug": "False",
1989
"priority":
1990
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1991
"servicename": "Mandos",
1992
"use_dbus": "True",
1993
"use_ipv6": "True",
1994
"debuglevel": "",
1211
server_defaults = { u"interface": u"",
1212
u"address": u"",
1213
u"port": u"",
1214
u"debug": u"False",
1215
u"priority":
1216
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1217
u"servicename": u"Mandos",
1218
u"use_dbus": u"True",
1219
u"use_ipv6": u"True",
1995
1220
}
1996
1221
1997
1222
# Parse config file for server-global settings
1998
1223
server_config = configparser.SafeConfigParser(server_defaults)
1999
1224
del server_defaults
2000
1225
server_config.read(os.path.join(options.configdir,
2001
"mandos.conf"))
1226
u"mandos.conf"))
2002
1227
# Convert the SafeConfigParser object to a dict
2003
1228
server_settings = server_config.defaults()
2004
1229
# Use the appropriate methods on the non-string config options
2005
for option in ("debug", "use_dbus", "use_ipv6"):
2006
server_settings[option] = server_config.getboolean("DEFAULT",
1230
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1231
server_settings[option] = server_config.getboolean(u"DEFAULT",
2007
1232
option)
2008
1233
if server_settings["port"]:
2009
server_settings["port"] = server_config.getint("DEFAULT",
2010
"port")
1234
server_settings["port"] = server_config.getint(u"DEFAULT",
1235
u"port")
2011
1236
del server_config
2012
1237
2013
1238
# Override the settings from the config file with command line
2014
1239
# options, if set.
2015
for option in ("interface", "address", "port", "debug",
2016
"priority", "servicename", "configdir",
2017
"use_dbus", "use_ipv6", "debuglevel", "restore"):
1240
for option in (u"interface", u"address", u"port", u"debug",
1241
u"priority", u"servicename", u"configdir",
1242
u"use_dbus", u"use_ipv6"):
2018
1243
value = getattr(options, option)
2019
1244
if value is not None:
2020
1245
server_settings[option] = value
2028
1253
##################################################################
2029
1254
2030
1255
# For convenience
2031
debug = server_settings["debug"]
2032
debuglevel = server_settings["debuglevel"]
2033
use_dbus = server_settings["use_dbus"]
2034
use_ipv6 = server_settings["use_ipv6"]
2035
2036
if debug:
2037
initlogger(logging.DEBUG)
2038
else:
2039
if not debuglevel:
2040
initlogger()
2041
else:
2042
level = getattr(logging, debuglevel.upper())
2043
initlogger(level)
2044
2045
if server_settings["servicename"] != "Mandos":
1256
debug = server_settings[u"debug"]
1257
use_dbus = server_settings[u"use_dbus"]
1258
use_ipv6 = server_settings[u"use_ipv6"]
1259
1260
if not debug:
1261
syslogger.setLevel(logging.WARNING)
1262
console.setLevel(logging.WARNING)
1263
1264
if server_settings[u"servicename"] != u"Mandos":
2046
1265
syslogger.setFormatter(logging.Formatter
2047
('Mandos (%s) [%%(process)d]:'
2048
' %%(levelname)s: %%(message)s'
2049
% server_settings["servicename"]))
1266
(u'Mandos (%s) [%%(process)d]:'
1267
u' %%(levelname)s: %%(message)s'
1268
% server_settings[u"servicename"]))
2050
1269
2051
1270
# Parse config file with clients
2052
client_defaults = { "timeout": "5m",
2053
"extended_timeout": "15m",
2054
"interval": "2m",
2055
"checker": "fping -q -- %%(host)s",
2056
"host": "",
2057
"approval_delay": "0s",
2058
"approval_duration": "1s",
1271
client_defaults = { u"timeout": u"1h",
1272
u"interval": u"5m",
1273
u"checker": u"fping -q -- %%(host)s",
1274
u"host": u"",
2059
1275
}
2060
1276
client_config = configparser.SafeConfigParser(client_defaults)
2061
client_config.read(os.path.join(server_settings["configdir"],
2062
"clients.conf"))
1277
client_config.read(os.path.join(server_settings[u"configdir"],
1278
u"clients.conf"))
2063
1279
2064
1280
global mandos_dbus_service
2065
1281
mandos_dbus_service = None
2066
1282
2067
tcp_server = MandosServer((server_settings["address"],
2068
server_settings["port"]),
1283
tcp_server = MandosServer((server_settings[u"address"],
1284
server_settings[u"port"]),
2069
1285
ClientHandler,
2070
interface=(server_settings["interface"]
2071
or None),
1286
interface=server_settings[u"interface"],
2072
1287
use_ipv6=use_ipv6,
2073
1288
gnutls_priority=
2074
server_settings["priority"],
1289
server_settings[u"priority"],
2075
1290
use_dbus=use_dbus)
2076
if not debug:
2077
pidfilename = "/var/run/mandos.pid"
2078
try:
2079
pidfile = open(pidfilename, "w")
2080
except IOError:
2081
logger.error("Could not open file %r", pidfilename)
1291
pidfilename = u"/var/run/mandos.pid"
1292
try:
1293
pidfile = open(pidfilename, u"w")
1294
except IOError:
1295
logger.error(u"Could not open file %r", pidfilename)
2082
1296
2083
1297
try:
2084
uid = pwd.getpwnam("_mandos").pw_uid
2085
gid = pwd.getpwnam("_mandos").pw_gid
1298
uid = pwd.getpwnam(u"_mandos").pw_uid
1299
gid = pwd.getpwnam(u"_mandos").pw_gid
2086
1300
except KeyError:
2087
1301
try:
2088
uid = pwd.getpwnam("mandos").pw_uid
2089
gid = pwd.getpwnam("mandos").pw_gid
1302
uid = pwd.getpwnam(u"mandos").pw_uid
1303
gid = pwd.getpwnam(u"mandos").pw_gid
2090
1304
except KeyError:
2091
1305
try:
2092
uid = pwd.getpwnam("nobody").pw_uid
2093
gid = pwd.getpwnam("nobody").pw_gid
1306
uid = pwd.getpwnam(u"nobody").pw_uid
1307
gid = pwd.getpwnam(u"nobody").pw_gid
2094
1308
except KeyError:
2095
1309
uid = 65534
2096
1310
gid = 65534
2097
1311
try:
2098
1312
os.setgid(gid)
2099
1313
os.setuid(uid)
2100
except OSError as error:
1314
except OSError, error:
2101
1315
if error[0] != errno.EPERM:
2102
1316
raise error
2103
1317
1318
# Enable all possible GnuTLS debugging
2104
1319
if debug:
2105
# Enable all possible GnuTLS debugging
2106
2107
1320
# "Use a log level over 10 to enable all debugging options."
2108
1321
# - GnuTLS manual
2109
1322
gnutls.library.functions.gnutls_global_set_log_level(11)
2110
1323
2111
1324
@gnutls.library.types.gnutls_log_func
2112
1325
def debug_gnutls(level, string):
2113
logger.debug("GnuTLS: %s", string[:-1])
1326
logger.debug(u"GnuTLS: %s", string[:-1])
2114
1327
2115
1328
(gnutls.library.functions
2116
1329
.gnutls_global_set_log_function(debug_gnutls))
2117
2118
# Redirect stdin so all checkers get /dev/null
2119
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2120
os.dup2(null, sys.stdin.fileno())
2121
if null > 2:
2122
os.close(null)
2123
else:
2124
# No console logging
2125
logger.removeHandler(console)
2126
2127
# Need to fork before connecting to D-Bus
2128
if not debug:
2129
# Close all input and output, do double fork, etc.
2130
daemon()
2131
1330
2132
1331
global main_loop
2133
1332
# From the Avahi example code
2136
1335
bus = dbus.SystemBus()
2137
1336
# End of Avahi example code
2138
1337
if use_dbus:
2139
try:
2140
bus_name = dbus.service.BusName("se.recompile.Mandos",
2141
bus, do_not_queue=True)
2142
old_bus_name = (dbus.service.BusName
2143
("se.bsnet.fukt.Mandos", bus,
2144
do_not_queue=True))
2145
except dbus.exceptions.NameExistsException as e:
2146
logger.error(unicode(e) + ", disabling D-Bus")
2147
use_dbus = False
2148
server_settings["use_dbus"] = False
2149
tcp_server.use_dbus = False
1338
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
2150
1339
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2151
service = AvahiServiceToSyslog(name =
2152
server_settings["servicename"],
2153
servicetype = "_mandos._tcp",
2154
protocol = protocol, bus = bus)
1340
service = AvahiService(name = server_settings[u"servicename"],
1341
servicetype = u"_mandos._tcp",
1342
protocol = protocol, bus = bus)
2155
1343
if server_settings["interface"]:
2156
1344
service.interface = (if_nametoindex
2157
(str(server_settings["interface"])))
2158
2159
global multiprocessing_manager
2160
multiprocessing_manager = multiprocessing.Manager()
1345
(str(server_settings[u"interface"])))
2161
1346
2162
1347
client_class = Client
2163
1348
if use_dbus:
2164
client_class = functools.partial(ClientDBusTransitional,
2165
bus = bus)
2166
2167
special_settings = {
2168
# Some settings need to be accessd by special methods;
2169
# booleans need .getboolean(), etc. Here is a list of them:
2170
"approved_by_default":
2171
lambda section:
2172
client_config.getboolean(section, "approved_by_default"),
2173
}
2174
# Construct a new dict of client settings of this form:
2175
# { client_name: {setting_name: value, ...}, ...}
2176
# with exceptions for any special settings as defined above
2177
client_settings = dict((clientname,
2178
dict((setting,
2179
(value
2180
if setting not in special_settings
2181
else special_settings[setting]
2182
(clientname)))
2183
for setting, value in
2184
client_config.items(clientname)))
2185
for clientname in client_config.sections())
2186
2187
old_client_settings = {}
2188
clients_data = []
2189
2190
# Get client data and settings from last running state.
2191
if server_settings["restore"]:
2192
try:
2193
with open(stored_state_path, "rb") as stored_state:
2194
clients_data, old_client_settings = (pickle.load
2195
(stored_state))
2196
os.remove(stored_state_path)
2197
except IOError as e:
2198
logger.warning("Could not load persistent state: {0}"
2199
.format(e))
2200
if e.errno != errno.ENOENT:
2201
raise
2202
2203
with Crypto() as crypt:
2204
for client in clients_data:
2205
client_name = client["name"]
2206
2207
# Decide which value to use after restoring saved state.
2208
# We have three different values: Old config file,
2209
# new config file, and saved state.
2210
# New config value takes precedence if it differs from old
2211
# config value, otherwise use saved state.
2212
for name, value in client_settings[client_name].items():
2213
try:
2214
# For each value in new config, check if it
2215
# differs from the old config value (Except for
2216
# the "secret" attribute)
2217
if (name != "secret" and
2218
value != old_client_settings[client_name]
2219
[name]):
2220
setattr(client, name, value)
2221
except KeyError:
2222
pass
2223
2224
# Clients who has passed its expire date can still be
2225
# enabled if its last checker was sucessful. Clients
2226
# whose checker failed before we stored its state is
2227
# assumed to have failed all checkers during downtime.
2228
if client["enabled"] and client["last_checked_ok"]:
2229
if ((datetime.datetime.utcnow()
2230
- client["last_checked_ok"])
2231
> client["interval"]):
2232
if client["last_checker_status"] != 0:
2233
client["enabled"] = False
2234
else:
2235
client["expires"] = (datetime.datetime
2236
.utcnow()
2237
+ client["timeout"])
2238
2239
client["changedstate"] = (multiprocessing_manager
2240
.Condition
2241
(multiprocessing_manager
2242
.Lock()))
2243
if use_dbus:
2244
new_client = (ClientDBusTransitional.__new__
2245
(ClientDBusTransitional))
2246
tcp_server.clients[client_name] = new_client
2247
new_client.bus = bus
2248
for name, value in client.iteritems():
2249
setattr(new_client, name, value)
2250
client_object_name = unicode(client_name).translate(
2251
{ord("."): ord("_"),
2252
ord("-"): ord("_")})
2253
new_client.dbus_object_path = (dbus.ObjectPath
2254
("/clients/"
2255
+ client_object_name))
2256
DBusObjectWithProperties.__init__(new_client,
2257
new_client.bus,
2258
new_client
2259
.dbus_object_path)
2260
else:
2261
tcp_server.clients[client_name] = (Client.__new__
2262
(Client))
2263
for name, value in client.iteritems():
2264
setattr(tcp_server.clients[client_name],
2265
name, value)
2266
2267
try:
2268
tcp_server.clients[client_name].secret = (
2269
crypt.decrypt(tcp_server.clients[client_name]
2270
.encrypted_secret,
2271
client_settings[client_name]
2272
["secret"]))
2273
except CryptoError:
2274
# If decryption fails, we use secret from new settings
2275
tcp_server.clients[client_name].secret = (
2276
client_settings[client_name]["secret"])
2277
2278
# Create/remove clients based on new changes made to config
2279
for clientname in set(old_client_settings) - set(client_settings):
2280
del tcp_server.clients[clientname]
2281
for clientname in set(client_settings) - set(old_client_settings):
2282
tcp_server.clients[clientname] = (client_class(name
2283
= clientname,
2284
config =
2285
client_settings
2286
[clientname]))
2287
1349
client_class = functools.partial(ClientDBus, bus = bus)
1350
tcp_server.clients.update(set(
1351
client_class(name = section,
1352
config= dict(client_config.items(section)))
1353
for section in client_config.sections()))
2288
1354
if not tcp_server.clients:
2289
logger.warning("No clients defined")
1355
logger.warning(u"No clients defined")
1356
1357
if debug:
1358
# Redirect stdin so all checkers get /dev/null
1359
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1360
os.dup2(null, sys.stdin.fileno())
1361
if null > 2:
1362
os.close(null)
1363
else:
1364
# No console logging
1365
logger.removeHandler(console)
1366
# Close all input and output, do double fork, etc.
1367
daemon()
1368
1369
try:
1370
with closing(pidfile):
1371
pid = os.getpid()
1372
pidfile.write(str(pid) + "\n")
1373
del pidfile
1374
except IOError:
1375
logger.error(u"Could not write to file %r with PID %d",
1376
pidfilename, pid)
1377
except NameError:
1378
# "pidfile" was never created
1379
pass
1380
del pidfilename
1381
1382
def cleanup():
1383
"Cleanup function; run on exit"
1384
service.cleanup()
2290
1385
1386
while tcp_server.clients:
1387
client = tcp_server.clients.pop()
1388
client.disable_hook = None
1389
client.disable()
1390
1391
atexit.register(cleanup)
1392
2291
1393
if not debug:
2292
try:
2293
with pidfile:
2294
pid = os.getpid()
2295
pidfile.write(str(pid) + "\n".encode("utf-8"))
2296
del pidfile
2297
except IOError:
2298
logger.error("Could not write to file %r with PID %d",
2299
pidfilename, pid)
2300
except NameError:
2301
# "pidfile" was never created
2302
pass
2303
del pidfilename
2304
2305
1394
signal.signal(signal.SIGINT, signal.SIG_IGN)
2306
2307
1395
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2308
1396
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2309
1397
2311
1399
class MandosDBusService(dbus.service.Object):
2312
1400
"""A D-Bus proxy object"""
2313
1401
def __init__(self):
2314
dbus.service.Object.__init__(self, bus, "/")
2315
_interface = "se.recompile.Mandos"
2316
2317
@dbus.service.signal(_interface, signature="o")
2318
def ClientAdded(self, objpath):
2319
"D-Bus signal"
2320
pass
2321
2322
@dbus.service.signal(_interface, signature="ss")
2323
def ClientNotFound(self, fingerprint, address):
2324
"D-Bus signal"
2325
pass
2326
2327
@dbus.service.signal(_interface, signature="os")
1402
dbus.service.Object.__init__(self, bus, u"/")
1403
_interface = u"se.bsnet.fukt.Mandos"
1404
1405
@dbus.service.signal(_interface, signature=u"oa{sv}")
1406
def ClientAdded(self, objpath, properties):
1407
"D-Bus signal"
1408
pass
1409
1410
@dbus.service.signal(_interface, signature=u"s")
1411
def ClientNotFound(self, fingerprint):
1412
"D-Bus signal"
1413
pass
1414
1415
@dbus.service.signal(_interface, signature=u"os")
2328
1416
def ClientRemoved(self, objpath, name):
2329
1417
"D-Bus signal"
2330
1418
pass
2331
1419
2332
@dbus.service.method(_interface, out_signature="ao")
1420
@dbus.service.method(_interface, out_signature=u"ao")
2333
1421
def GetAllClients(self):
2334
1422
"D-Bus method"
2335
1423
return dbus.Array(c.dbus_object_path
2336
for c in
2337
tcp_server.clients.itervalues())
1424
for c in tcp_server.clients)
2338
1425
2339
1426
@dbus.service.method(_interface,
2340
out_signature="a{oa{sv}}")
1427
out_signature=u"a{oa{sv}}")
2341
1428
def GetAllClientsWithProperties(self):
2342
1429
"D-Bus method"
2343
1430
return dbus.Dictionary(
2344
((c.dbus_object_path, c.GetAll(""))
2345
for c in tcp_server.clients.itervalues()),
2346
signature="oa{sv}")
1431
((c.dbus_object_path, c.GetAllProperties())
1432
for c in tcp_server.clients),
1433
signature=u"oa{sv}")
2347
1434
2348
@dbus.service.method(_interface, in_signature="o")
1435
@dbus.service.method(_interface, in_signature=u"o")
2349
1436
def RemoveClient(self, object_path):
2350
1437
"D-Bus method"
2351
for c in tcp_server.clients.itervalues():
1438
for c in tcp_server.clients:
2352
1439
if c.dbus_object_path == object_path:
2353
del tcp_server.clients[c.name]
1440
tcp_server.clients.remove(c)
2354
1441
c.remove_from_connection()
2355
1442
# Don't signal anything except ClientRemoved
2356
c.disable(quiet=True)
1443
c.disable(signal=False)
2357
1444
# Emit D-Bus signal
2358
1445
self.ClientRemoved(object_path, c.name)
2359
1446
return
2360
raise KeyError(object_path)
1447
raise KeyError
2361
1448
2362
1449
del _interface
2363
1450
2364
class MandosDBusServiceTransitional(MandosDBusService):
2365
__metaclass__ = AlternateDBusNamesMetaclass
2366
mandos_dbus_service = MandosDBusServiceTransitional()
2367
2368
def cleanup():
2369
"Cleanup function; run on exit"
2370
service.cleanup()
2371
2372
multiprocessing.active_children()
2373
if not (tcp_server.clients or client_settings):
2374
return
2375
2376
# Store client before exiting. Secrets are encrypted with key
2377
# based on what config file has. If config file is
2378
# removed/edited, old secret will thus be unrecovable.
2379
clients = []
2380
with Crypto() as crypt:
2381
for client in tcp_server.clients.itervalues():
2382
key = client_settings[client.name]["secret"]
2383
client.encrypted_secret = crypt.encrypt(client.secret,
2384
key)
2385
client_dict = {}
2386
2387
# A list of attributes that will not be stored when
2388
# shutting down.
2389
exclude = set(("bus", "changedstate", "secret"))
2390
for name, typ in (inspect.getmembers
2391
(dbus.service.Object)):
2392
exclude.add(name)
2393
2394
client_dict["encrypted_secret"] = (client
2395
.encrypted_secret)
2396
for attr in client.client_structure:
2397
if attr not in exclude:
2398
client_dict[attr] = getattr(client, attr)
2399
2400
clients.append(client_dict)
2401
del client_settings[client.name]["secret"]
2402
2403
try:
2404
with os.fdopen(os.open(stored_state_path,
2405
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2406
0600), "wb") as stored_state:
2407
pickle.dump((clients, client_settings), stored_state)
2408
except (IOError, OSError) as e:
2409
logger.warning("Could not save persistent state: {0}"
2410
.format(e))
2411
if e.errno not in (errno.ENOENT, errno.EACCES):
2412
raise
2413
2414
# Delete all clients, and settings from config
2415
while tcp_server.clients:
2416
name, client = tcp_server.clients.popitem()
2417
if use_dbus:
2418
client.remove_from_connection()
2419
# Don't signal anything except ClientRemoved
2420
client.disable(quiet=True)
2421
if use_dbus:
2422
# Emit D-Bus signal
2423
mandos_dbus_service.ClientRemoved(client
2424
.dbus_object_path,
2425
client.name)
2426
client_settings.clear()
2427
2428
atexit.register(cleanup)
2429
2430
for client in tcp_server.clients.itervalues():
1451
mandos_dbus_service = MandosDBusService()
1452
1453
for client in tcp_server.clients:
2431
1454
if use_dbus:
2432
1455
# Emit D-Bus signal
2433
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2434
# Need to initiate checking of clients
2435
if client.enabled:
2436
client.init_checker()
1456
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1457
client.GetAllProperties())
1458
client.enable()
2437
1459
2438
1460
tcp_server.enable()
2439
1461
tcp_server.server_activate()
2441
1463
# Find out what port we got
2442
1464
service.port = tcp_server.socket.getsockname()[1]
2443
1465
if use_ipv6:
2444
logger.info("Now listening on address %r, port %d,"
1466
logger.info(u"Now listening on address %r, port %d,"
2445
1467
" flowinfo %d, scope_id %d"
2446
1468
% tcp_server.socket.getsockname())
2447
1469
else: # IPv4
2448
logger.info("Now listening on address %r, port %d"
1470
logger.info(u"Now listening on address %r, port %d"
2449
1471
% tcp_server.socket.getsockname())
2450
1472
2451
1473
#service.interface = tcp_server.socket.getsockname()[3]
2454
1476
# From the Avahi example code
2455
1477
try:
2456
1478
service.activate()
2457
except dbus.exceptions.DBusException as error:
2458
logger.critical("DBusException: %s", error)
2459
cleanup()
1479
except dbus.exceptions.DBusException, error:
1480
logger.critical(u"DBusException: %s", error)
2460
1481
sys.exit(1)
2461
1482
# End of Avahi example code
2462
1483
2465
1486
(tcp_server.handle_request
2466
1487
(*args[2:], **kwargs) or True))
2467
1488
2468
logger.debug("Starting main loop")
1489
logger.debug(u"Starting main loop")
2469
1490
main_loop.run()
2470
except AvahiError as error:
2471
logger.critical("AvahiError: %s", error)
2472
cleanup()
1491
except AvahiError, error:
1492
logger.critical(u"AvahiError: %s", error)
2473
1493
sys.exit(1)
2474
1494
except KeyboardInterrupt:
2475
1495
if debug:
2476
print("", file=sys.stderr)
2477
logger.debug("Server received KeyboardInterrupt")
2478
logger.debug("Server exiting")
2479
# Must run before the D-Bus bus name gets deregistered
2480
cleanup()
2481
1496
print >> sys.stderr
1497
logger.debug(u"Server received KeyboardInterrupt")
1498
logger.debug(u"Server exiting")
2482
1499
2483
1500
if __name__ == '__main__':
2484
1501
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0