To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 237.2.2
- compare with another revision
- download diff
- download tarball
- view history from revision 237.2.2
- Committer: Teddy Hogeborn
- Date: 2009-01-06 00:58:17 UTC
- mto: (24.1.170 mandos) (237.4.29 release)
- mto: This revision was merged to the branch mainline in revision 271.
- Revision ID: teddy@fukt.bsnet.se-20090106005817-lnxyism0yjkmmlj1
Tags: version-1.0.3-1
* Makefile (version): Changed to "1.0.3".
* NEWS (Version 1.0.3): New entry.
* debian/changelog (1.0.3-1): New entry.
* NEWS (Version 1.0.3): New entry.
* debian/changelog (1.0.3-1): New entry.
- files added:
- debian/mandos-client.config
- files removed:
- dbus-mandos.conf
- files modified:
- INSTALL
added
removed
mandos
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
12
12
#
13
13
# Everything else is
14
14
# Copyright © 2008,2009 Teddy Hogeborn
33
33
34
34
from __future__ import division, with_statement, absolute_import
35
35
36
import SocketServer as socketserver
36
import SocketServer
37
37
import socket
38
38
import optparse
39
39
import datetime
44
44
import gnutls.library.functions
45
45
import gnutls.library.constants
46
46
import gnutls.library.types
47
import ConfigParser as configparser
47
import ConfigParser
48
48
import sys
49
49
import re
50
50
import os
51
51
import signal
52
from sets import Set
52
53
import subprocess
53
54
import atexit
54
55
import stat
55
56
import logging
56
57
import logging.handlers
57
58
import pwd
58
import contextlib
59
import struct
60
import fcntl
61
import functools
62
import cPickle as pickle
63
import multiprocessing
59
from contextlib import closing
64
60
65
61
import dbus
66
62
import dbus.service
69
65
from dbus.mainloop.glib import DBusGMainLoop
70
66
import ctypes
71
67
import ctypes.util
72
import xml.dom.minidom
73
import inspect
74
75
try:
76
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
77
except AttributeError:
78
try:
79
from IN import SO_BINDTODEVICE
80
except ImportError:
81
SO_BINDTODEVICE = None
82
83
84
version = "1.0.14"
85
86
#logger = logging.getLogger(u'mandos')
87
logger = logging.Logger(u'mandos')
68
69
version = "1.0.3"
70
71
logger = logging.Logger('mandos')
88
72
syslogger = (logging.handlers.SysLogHandler
89
73
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
90
74
address = "/dev/log"))
91
75
syslogger.setFormatter(logging.Formatter
92
(u'Mandos [%(process)d]: %(levelname)s:'
93
u' %(message)s'))
76
('Mandos: %(levelname)s: %(message)s'))
94
77
logger.addHandler(syslogger)
95
78
96
79
console = logging.StreamHandler()
97
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
98
u' %(levelname)s:'
99
u' %(message)s'))
80
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
81
' %(message)s'))
100
82
logger.addHandler(console)
101
83
102
84
class AvahiError(Exception):
115
97
116
98
class AvahiService(object):
117
99
"""An Avahi (Zeroconf) service.
118
119
100
Attributes:
120
101
interface: integer; avahi.IF_UNSPEC or an interface index.
121
102
Used to optionally bind to the specified interface.
122
name: string; Example: u'Mandos'
123
type: string; Example: u'_mandos._tcp'.
103
name: string; Example: 'Mandos'
104
type: string; Example: '_mandos._tcp'.
124
105
See <http://www.dns-sd.org/ServiceTypes.html>
125
106
port: integer; what port to announce
126
107
TXT: list of strings; TXT record for the service
129
110
max_renames: integer; maximum number of renames
130
111
rename_count: integer; counter so we only rename after collisions
131
112
a sensible number of times
132
group: D-Bus Entry Group
133
server: D-Bus Server
134
bus: dbus.SystemBus()
135
113
"""
136
114
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
137
115
servicetype = None, port = None, TXT = None,
138
domain = u"", host = u"", max_renames = 32768,
139
protocol = avahi.PROTO_UNSPEC, bus = None):
116
domain = "", host = "", max_renames = 32768):
140
117
self.interface = interface
141
118
self.name = name
142
119
self.type = servicetype
146
123
self.host = host
147
124
self.rename_count = 0
148
125
self.max_renames = max_renames
149
self.protocol = protocol
150
self.group = None # our entry group
151
self.server = None
152
self.bus = bus
153
126
def rename(self):
154
127
"""Derived from the Avahi example code"""
155
128
if self.rename_count >= self.max_renames:
157
130
u" after %i retries, exiting.",
158
131
self.rename_count)
159
132
raise AvahiServiceError(u"Too many renames")
160
self.name = self.server.GetAlternativeServiceName(self.name)
133
self.name = server.GetAlternativeServiceName(self.name)
161
134
logger.info(u"Changing Zeroconf service name to %r ...",
162
unicode(self.name))
135
str(self.name))
163
136
syslogger.setFormatter(logging.Formatter
164
(u'Mandos (%s) [%%(process)d]:'
165
u' %%(levelname)s: %%(message)s'
166
% self.name))
137
('Mandos (%s): %%(levelname)s:'
138
' %%(message)s' % self.name))
167
139
self.remove()
168
140
self.add()
169
141
self.rename_count += 1
170
142
def remove(self):
171
143
"""Derived from the Avahi example code"""
172
if self.group is not None:
173
self.group.Reset()
144
if group is not None:
145
group.Reset()
174
146
def add(self):
175
147
"""Derived from the Avahi example code"""
176
if self.group is None:
177
self.group = dbus.Interface(
178
self.bus.get_object(avahi.DBUS_NAME,
179
self.server.EntryGroupNew()),
180
avahi.DBUS_INTERFACE_ENTRY_GROUP)
181
self.group.connect_to_signal('StateChanged',
182
self
183
.entry_group_state_changed)
148
global group
149
if group is None:
150
group = dbus.Interface(bus.get_object
151
(avahi.DBUS_NAME,
152
server.EntryGroupNew()),
153
avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
group.connect_to_signal('StateChanged',
155
entry_group_state_changed)
184
156
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
185
self.name, self.type)
186
self.group.AddService(
187
self.interface,
188
self.protocol,
189
dbus.UInt32(0), # flags
190
self.name, self.type,
191
self.domain, self.host,
192
dbus.UInt16(self.port),
193
avahi.string_array_to_txt_array(self.TXT))
194
self.group.Commit()
195
def entry_group_state_changed(self, state, error):
196
"""Derived from the Avahi example code"""
197
logger.debug(u"Avahi state change: %i", state)
198
199
if state == avahi.ENTRY_GROUP_ESTABLISHED:
200
logger.debug(u"Zeroconf service established.")
201
elif state == avahi.ENTRY_GROUP_COLLISION:
202
logger.warning(u"Zeroconf service name collision.")
203
self.rename()
204
elif state == avahi.ENTRY_GROUP_FAILURE:
205
logger.critical(u"Avahi: Error in group state changed %s",
206
unicode(error))
207
raise AvahiGroupError(u"State changed: %s"
208
% unicode(error))
209
def cleanup(self):
210
"""Derived from the Avahi example code"""
211
if self.group is not None:
212
self.group.Free()
213
self.group = None
214
def server_state_changed(self, state):
215
"""Derived from the Avahi example code"""
216
if state == avahi.SERVER_COLLISION:
217
logger.error(u"Zeroconf server name collision")
218
self.remove()
219
elif state == avahi.SERVER_RUNNING:
220
self.add()
221
def activate(self):
222
"""Derived from the Avahi example code"""
223
if self.server is None:
224
self.server = dbus.Interface(
225
self.bus.get_object(avahi.DBUS_NAME,
226
avahi.DBUS_PATH_SERVER),
227
avahi.DBUS_INTERFACE_SERVER)
228
self.server.connect_to_signal(u"StateChanged",
229
self.server_state_changed)
230
self.server_state_changed(self.server.GetState())
231
232
233
class Client(object):
157
service.name, service.type)
158
group.AddService(
159
self.interface, # interface
160
avahi.PROTO_INET6, # protocol
161
dbus.UInt32(0), # flags
162
self.name, self.type,
163
self.domain, self.host,
164
dbus.UInt16(self.port),
165
avahi.string_array_to_txt_array(self.TXT))
166
group.Commit()
167
168
# From the Avahi example code:
169
group = None # our entry group
170
# End of Avahi example code
171
172
173
def _datetime_to_dbus(dt, variant_level=0):
174
"""Convert a UTC datetime.datetime() to a D-Bus type."""
175
return dbus.String(dt.isoformat(), variant_level=variant_level)
176
177
178
class Client(dbus.service.Object):
234
179
"""A representation of a client host served by this server.
235
236
180
Attributes:
237
name: string; from the config file, used in log messages and
238
D-Bus identifiers
181
name: string; from the config file, used in log messages
239
182
fingerprint: string (40 or 32 hexadecimal digits); used to
240
183
uniquely identify the client
241
184
secret: bytestring; sent verbatim (over TLS) to client
245
188
enabled: bool()
246
189
last_checked_ok: datetime.datetime(); (UTC) or None
247
190
timeout: datetime.timedelta(); How long from last_checked_ok
248
until this client is disabled
191
until this client is invalid
249
192
interval: datetime.timedelta(); How often to start a new checker
250
193
disable_hook: If set, called by disable() as disable_hook(self)
251
194
checker: subprocess.Popen(); a running checker process used
252
195
to see if the client lives.
253
196
'None' if no process is running.
254
197
checker_initiator_tag: a gobject event source tag, or None
255
disable_initiator_tag: - '' -
198
disable_initiator_tag: - '' -
256
199
checker_callback_tag: - '' -
257
200
checker_command: string; External command which is run to check if
258
201
client lives. %() expansions are done at
259
202
runtime with vars(self) as dict, so that for
260
203
instance %(name)s can be used in the command.
261
current_checker_command: string; current running checker_command
262
approved_delay: datetime.timedelta(); Time to wait for approval
263
_approved: bool(); 'None' if not yet approved/disapproved
264
approved_duration: datetime.timedelta(); Duration of one approval
204
use_dbus: bool(); Whether to provide D-Bus interface and signals
205
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
265
206
"""
266
267
@staticmethod
268
def _timedelta_to_milliseconds(td):
269
"Convert a datetime.timedelta() to milliseconds"
270
return ((td.days * 24 * 60 * 60 * 1000)
271
+ (td.seconds * 1000)
272
+ (td.microseconds // 1000))
273
274
207
def timeout_milliseconds(self):
275
208
"Return the 'timeout' attribute in milliseconds"
276
return self._timedelta_to_milliseconds(self.timeout)
209
return ((self.timeout.days * 24 * 60 * 60 * 1000)
210
+ (self.timeout.seconds * 1000)
211
+ (self.timeout.microseconds // 1000))
277
212
278
213
def interval_milliseconds(self):
279
214
"Return the 'interval' attribute in milliseconds"
280
return self._timedelta_to_milliseconds(self.interval)
281
282
def approved_delay_milliseconds(self):
283
return self._timedelta_to_milliseconds(self.approved_delay)
215
return ((self.interval.days * 24 * 60 * 60 * 1000)
216
+ (self.interval.seconds * 1000)
217
+ (self.interval.microseconds // 1000))
284
218
285
def __init__(self, name = None, disable_hook=None, config=None):
219
def __init__(self, name = None, disable_hook=None, config=None,
220
use_dbus=True):
286
221
"""Note: the 'checker' key in 'config' sets the
287
222
'checker_command' attribute and *not* the 'checker'
288
223
attribute."""
290
225
if config is None:
291
226
config = {}
292
227
logger.debug(u"Creating client %r", self.name)
228
self.use_dbus = use_dbus
229
if self.use_dbus:
230
self.dbus_object_path = (dbus.ObjectPath
231
("/Mandos/clients/"
232
+ self.name.replace(".", "_")))
233
dbus.service.Object.__init__(self, bus,
234
self.dbus_object_path)
293
235
# Uppercase and remove spaces from fingerprint for later
294
236
# comparison purposes with return value from the fingerprint()
295
237
# function
296
self.fingerprint = (config[u"fingerprint"].upper()
238
self.fingerprint = (config["fingerprint"].upper()
297
239
.replace(u" ", u""))
298
240
logger.debug(u" Fingerprint: %s", self.fingerprint)
299
if u"secret" in config:
300
self.secret = config[u"secret"].decode(u"base64")
301
elif u"secfile" in config:
302
with open(os.path.expanduser(os.path.expandvars
303
(config[u"secfile"])),
304
"rb") as secfile:
241
if "secret" in config:
242
self.secret = config["secret"].decode(u"base64")
243
elif "secfile" in config:
244
with closing(open(os.path.expanduser
245
(os.path.expandvars
246
(config["secfile"])))) as secfile:
305
247
self.secret = secfile.read()
306
248
else:
307
#XXX Need to allow secret on demand!
308
249
raise TypeError(u"No secret or secfile for client %s"
309
250
% self.name)
310
self.host = config.get(u"host", u"")
251
self.host = config.get("host", "")
311
252
self.created = datetime.datetime.utcnow()
312
253
self.enabled = False
313
254
self.last_enabled = None
314
255
self.last_checked_ok = None
315
self.timeout = string_to_delta(config[u"timeout"])
316
self.interval = string_to_delta(config[u"interval"])
256
self.timeout = string_to_delta(config["timeout"])
257
self.interval = string_to_delta(config["interval"])
317
258
self.disable_hook = disable_hook
318
259
self.checker = None
319
260
self.checker_initiator_tag = None
320
261
self.disable_initiator_tag = None
321
262
self.checker_callback_tag = None
322
self.checker_command = config[u"checker"]
323
self.current_checker_command = None
324
self.last_connect = None
325
self._approved = None
326
self.approved_by_default = config.get(u"approved_by_default",
327
True)
328
self.approvals_pending = 0
329
self.approved_delay = string_to_delta(
330
config[u"approved_delay"])
331
self.approved_duration = string_to_delta(
332
config[u"approved_duration"])
333
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
263
self.checker_command = config["checker"]
334
264
335
def send_changedstate(self):
336
self.changedstate.acquire()
337
self.changedstate.notify_all()
338
self.changedstate.release()
339
340
265
def enable(self):
341
266
"""Start this client's checker and timeout hooks"""
342
if getattr(self, u"enabled", False):
343
# Already enabled
344
return
345
self.send_changedstate()
346
267
self.last_enabled = datetime.datetime.utcnow()
347
268
# Schedule a new checker to be started an 'interval' from now,
348
269
# and every interval from then on.
349
270
self.checker_initiator_tag = (gobject.timeout_add
350
271
(self.interval_milliseconds(),
351
272
self.start_checker))
273
# Also start a new checker *right now*.
274
self.start_checker()
352
275
# Schedule a disable() when 'timeout' has passed
353
276
self.disable_initiator_tag = (gobject.timeout_add
354
277
(self.timeout_milliseconds(),
355
278
self.disable))
356
279
self.enabled = True
357
# Also start a new checker *right now*.
358
self.start_checker()
280
if self.use_dbus:
281
# Emit D-Bus signals
282
self.PropertyChanged(dbus.String(u"enabled"),
283
dbus.Boolean(True, variant_level=1))
284
self.PropertyChanged(dbus.String(u"last_enabled"),
285
(_datetime_to_dbus(self.last_enabled,
286
variant_level=1)))
359
287
360
def disable(self, quiet=True):
288
def disable(self):
361
289
"""Disable this client."""
362
290
if not getattr(self, "enabled", False):
363
291
return False
364
if not quiet:
365
self.send_changedstate()
366
if not quiet:
367
logger.info(u"Disabling client %s", self.name)
368
if getattr(self, u"disable_initiator_tag", False):
292
logger.info(u"Disabling client %s", self.name)
293
if getattr(self, "disable_initiator_tag", False):
369
294
gobject.source_remove(self.disable_initiator_tag)
370
295
self.disable_initiator_tag = None
371
if getattr(self, u"checker_initiator_tag", False):
296
if getattr(self, "checker_initiator_tag", False):
372
297
gobject.source_remove(self.checker_initiator_tag)
373
298
self.checker_initiator_tag = None
374
299
self.stop_checker()
375
300
if self.disable_hook:
376
301
self.disable_hook(self)
377
302
self.enabled = False
303
if self.use_dbus:
304
# Emit D-Bus signal
305
self.PropertyChanged(dbus.String(u"enabled"),
306
dbus.Boolean(False, variant_level=1))
378
307
# Do not run this again if called by a gobject.timeout_add
379
308
return False
380
309
386
315
"""The checker has completed, so take appropriate actions."""
387
316
self.checker_callback_tag = None
388
317
self.checker = None
389
if os.WIFEXITED(condition):
390
exitstatus = os.WEXITSTATUS(condition)
391
if exitstatus == 0:
392
logger.info(u"Checker for %(name)s succeeded",
393
vars(self))
394
self.checked_ok()
395
else:
396
logger.info(u"Checker for %(name)s failed",
397
vars(self))
398
else:
318
if self.use_dbus:
319
# Emit D-Bus signal
320
self.PropertyChanged(dbus.String(u"checker_running"),
321
dbus.Boolean(False, variant_level=1))
322
if (os.WIFEXITED(condition)
323
and (os.WEXITSTATUS(condition) == 0)):
324
logger.info(u"Checker for %(name)s succeeded",
325
vars(self))
326
if self.use_dbus:
327
# Emit D-Bus signal
328
self.CheckerCompleted(dbus.Boolean(True),
329
dbus.UInt16(condition),
330
dbus.String(command))
331
self.bump_timeout()
332
elif not os.WIFEXITED(condition):
399
333
logger.warning(u"Checker for %(name)s crashed?",
400
334
vars(self))
335
if self.use_dbus:
336
# Emit D-Bus signal
337
self.CheckerCompleted(dbus.Boolean(False),
338
dbus.UInt16(condition),
339
dbus.String(command))
340
else:
341
logger.info(u"Checker for %(name)s failed",
342
vars(self))
343
if self.use_dbus:
344
# Emit D-Bus signal
345
self.CheckerCompleted(dbus.Boolean(False),
346
dbus.UInt16(condition),
347
dbus.String(command))
401
348
402
def checked_ok(self):
349
def bump_timeout(self):
403
350
"""Bump up the timeout for this client.
404
405
351
This should only be called when the client has been seen,
406
352
alive and well.
407
353
"""
410
356
self.disable_initiator_tag = (gobject.timeout_add
411
357
(self.timeout_milliseconds(),
412
358
self.disable))
359
if self.use_dbus:
360
# Emit D-Bus signal
361
self.PropertyChanged(
362
dbus.String(u"last_checked_ok"),
363
(_datetime_to_dbus(self.last_checked_ok,
364
variant_level=1)))
413
365
414
366
def start_checker(self):
415
367
"""Start a new checker subprocess if one is not running.
416
417
368
If a checker already exists, leave it running and do
418
369
nothing."""
419
370
# The reason for not killing a running checker is that if we
422
373
# client would inevitably timeout, since no checker would get
423
374
# a chance to run to completion. If we instead leave running
424
375
# checkers alone, the checker would have to take more time
425
# than 'timeout' for the client to be disabled, which is as it
426
# should be.
427
428
# If a checker exists, make sure it is not a zombie
429
try:
430
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
431
except (AttributeError, OSError), error:
432
if (isinstance(error, OSError)
433
and error.errno != errno.ECHILD):
434
raise error
435
else:
436
if pid:
437
logger.warning(u"Checker was a zombie")
438
gobject.source_remove(self.checker_callback_tag)
439
self.checker_callback(pid, status,
440
self.current_checker_command)
441
# Start a new checker if needed
376
# than 'timeout' for the client to be declared invalid, which
377
# is as it should be.
442
378
if self.checker is None:
443
379
try:
444
380
# In case checker_command has exactly one % operator
445
381
command = self.checker_command % self.host
446
382
except TypeError:
447
383
# Escape attributes for the shell
448
escaped_attrs = dict((key,
449
re.escape(unicode(str(val),
450
errors=
451
u'replace')))
384
escaped_attrs = dict((key, re.escape(str(val)))
452
385
for key, val in
453
386
vars(self).iteritems())
454
387
try:
457
390
logger.error(u'Could not format string "%s":'
458
391
u' %s', self.checker_command, error)
459
392
return True # Try again later
460
self.current_checker_command = command
461
393
try:
462
394
logger.info(u"Starting checker %r for %s",
463
395
command, self.name)
467
399
# always replaced by /dev/null.)
468
400
self.checker = subprocess.Popen(command,
469
401
close_fds=True,
470
shell=True, cwd=u"/")
402
shell=True, cwd="/")
403
if self.use_dbus:
404
# Emit D-Bus signal
405
self.CheckerStarted(command)
406
self.PropertyChanged(
407
dbus.String("checker_running"),
408
dbus.Boolean(True, variant_level=1))
471
409
self.checker_callback_tag = (gobject.child_watch_add
472
410
(self.checker.pid,
473
411
self.checker_callback,
474
412
data=command))
475
# The checker may have completed before the gobject
476
# watch was added. Check for this.
477
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
478
if pid:
479
gobject.source_remove(self.checker_callback_tag)
480
self.checker_callback(pid, status, command)
481
413
except OSError, error:
482
414
logger.error(u"Failed to start subprocess: %s",
483
415
error)
489
421
if self.checker_callback_tag:
490
422
gobject.source_remove(self.checker_callback_tag)
491
423
self.checker_callback_tag = None
492
if getattr(self, u"checker", None) is None:
424
if getattr(self, "checker", None) is None:
493
425
return
494
426
logger.debug(u"Stopping checker for %(name)s", vars(self))
495
427
try:
496
428
os.kill(self.checker.pid, signal.SIGTERM)
497
#time.sleep(0.5)
429
#os.sleep(0.5)
498
430
#if self.checker.poll() is None:
499
431
# os.kill(self.checker.pid, signal.SIGKILL)
500
432
except OSError, error:
501
433
if error.errno != errno.ESRCH: # No such process
502
434
raise
503
435
self.checker = None
504
505
def dbus_service_property(dbus_interface, signature=u"v",
506
access=u"readwrite", byte_arrays=False):
507
"""Decorators for marking methods of a DBusObjectWithProperties to
508
become properties on the D-Bus.
509
510
The decorated method will be called with no arguments by "Get"
511
and with one argument by "Set".
512
513
The parameters, where they are supported, are the same as
514
dbus.service.method, except there is only "signature", since the
515
type from Get() and the type sent to Set() is the same.
516
"""
517
# Encoding deeply encoded byte arrays is not supported yet by the
518
# "Set" method, so we fail early here:
519
if byte_arrays and signature != u"ay":
520
raise ValueError(u"Byte arrays not supported for non-'ay'"
521
u" signature %r" % signature)
522
def decorator(func):
523
func._dbus_is_property = True
524
func._dbus_interface = dbus_interface
525
func._dbus_signature = signature
526
func._dbus_access = access
527
func._dbus_name = func.__name__
528
if func._dbus_name.endswith(u"_dbus_property"):
529
func._dbus_name = func._dbus_name[:-14]
530
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
531
return func
532
return decorator
533
534
535
class DBusPropertyException(dbus.exceptions.DBusException):
536
"""A base class for D-Bus property-related exceptions
537
"""
538
def __unicode__(self):
539
return unicode(str(self))
540
541
542
class DBusPropertyAccessException(DBusPropertyException):
543
"""A property's access permissions disallows an operation.
544
"""
545
pass
546
547
548
class DBusPropertyNotFound(DBusPropertyException):
549
"""An attempt was made to access a non-existing property.
550
"""
551
pass
552
553
554
class DBusObjectWithProperties(dbus.service.Object):
555
"""A D-Bus object with properties.
556
557
Classes inheriting from this can use the dbus_service_property
558
decorator to expose methods as D-Bus properties. It exposes the
559
standard Get(), Set(), and GetAll() methods on the D-Bus.
560
"""
561
562
@staticmethod
563
def _is_dbus_property(obj):
564
return getattr(obj, u"_dbus_is_property", False)
565
566
def _get_all_dbus_properties(self):
567
"""Returns a generator of (name, attribute) pairs
568
"""
569
return ((prop._dbus_name, prop)
570
for name, prop in
571
inspect.getmembers(self, self._is_dbus_property))
572
573
def _get_dbus_property(self, interface_name, property_name):
574
"""Returns a bound method if one exists which is a D-Bus
575
property with the specified name and interface.
576
"""
577
for name in (property_name,
578
property_name + u"_dbus_property"):
579
prop = getattr(self, name, None)
580
if (prop is None
581
or not self._is_dbus_property(prop)
582
or prop._dbus_name != property_name
583
or (interface_name and prop._dbus_interface
584
and interface_name != prop._dbus_interface)):
585
continue
586
return prop
587
# No such property
588
raise DBusPropertyNotFound(self.dbus_object_path + u":"
589
+ interface_name + u"."
590
+ property_name)
591
592
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
593
out_signature=u"v")
594
def Get(self, interface_name, property_name):
595
"""Standard D-Bus property Get() method, see D-Bus standard.
596
"""
597
prop = self._get_dbus_property(interface_name, property_name)
598
if prop._dbus_access == u"write":
599
raise DBusPropertyAccessException(property_name)
600
value = prop()
601
if not hasattr(value, u"variant_level"):
602
return value
603
return type(value)(value, variant_level=value.variant_level+1)
604
605
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
606
def Set(self, interface_name, property_name, value):
607
"""Standard D-Bus property Set() method, see D-Bus standard.
608
"""
609
prop = self._get_dbus_property(interface_name, property_name)
610
if prop._dbus_access == u"read":
611
raise DBusPropertyAccessException(property_name)
612
if prop._dbus_get_args_options[u"byte_arrays"]:
613
# The byte_arrays option is not supported yet on
614
# signatures other than "ay".
615
if prop._dbus_signature != u"ay":
616
raise ValueError
617
value = dbus.ByteArray(''.join(unichr(byte)
618
for byte in value))
619
prop(value)
620
621
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
622
out_signature=u"a{sv}")
623
def GetAll(self, interface_name):
624
"""Standard D-Bus property GetAll() method, see D-Bus
625
standard.
626
627
Note: Will not include properties with access="write".
628
"""
629
all = {}
630
for name, prop in self._get_all_dbus_properties():
631
if (interface_name
632
and interface_name != prop._dbus_interface):
633
# Interface non-empty but did not match
634
continue
635
# Ignore write-only properties
636
if prop._dbus_access == u"write":
637
continue
638
value = prop()
639
if not hasattr(value, u"variant_level"):
640
all[name] = value
641
continue
642
all[name] = type(value)(value, variant_level=
643
value.variant_level+1)
644
return dbus.Dictionary(all, signature=u"sv")
645
646
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
647
out_signature=u"s",
648
path_keyword='object_path',
649
connection_keyword='connection')
650
def Introspect(self, object_path, connection):
651
"""Standard D-Bus method, overloaded to insert property tags.
652
"""
653
xmlstring = dbus.service.Object.Introspect(self, object_path,
654
connection)
655
try:
656
document = xml.dom.minidom.parseString(xmlstring)
657
def make_tag(document, name, prop):
658
e = document.createElement(u"property")
659
e.setAttribute(u"name", name)
660
e.setAttribute(u"type", prop._dbus_signature)
661
e.setAttribute(u"access", prop._dbus_access)
662
return e
663
for if_tag in document.getElementsByTagName(u"interface"):
664
for tag in (make_tag(document, name, prop)
665
for name, prop
666
in self._get_all_dbus_properties()
667
if prop._dbus_interface
668
== if_tag.getAttribute(u"name")):
669
if_tag.appendChild(tag)
670
# Add the names to the return values for the
671
# "org.freedesktop.DBus.Properties" methods
672
if (if_tag.getAttribute(u"name")
673
== u"org.freedesktop.DBus.Properties"):
674
for cn in if_tag.getElementsByTagName(u"method"):
675
if cn.getAttribute(u"name") == u"Get":
676
for arg in cn.getElementsByTagName(u"arg"):
677
if (arg.getAttribute(u"direction")
678
== u"out"):
679
arg.setAttribute(u"name", u"value")
680
elif cn.getAttribute(u"name") == u"GetAll":
681
for arg in cn.getElementsByTagName(u"arg"):
682
if (arg.getAttribute(u"direction")
683
== u"out"):
684
arg.setAttribute(u"name", u"props")
685
xmlstring = document.toxml(u"utf-8")
686
document.unlink()
687
except (AttributeError, xml.dom.DOMException,
688
xml.parsers.expat.ExpatError), error:
689
logger.error(u"Failed to override Introspection method",
690
error)
691
return xmlstring
692
693
694
class ClientDBus(Client, DBusObjectWithProperties):
695
"""A Client class using D-Bus
696
697
Attributes:
698
dbus_object_path: dbus.ObjectPath
699
bus: dbus.SystemBus()
700
"""
701
# dbus.service.Object doesn't use super(), so we can't either.
702
703
def __init__(self, bus = None, *args, **kwargs):
704
self._approvals_pending = 0
705
self.bus = bus
706
Client.__init__(self, *args, **kwargs)
707
# Only now, when this client is initialized, can it show up on
708
# the D-Bus
709
self.dbus_object_path = (dbus.ObjectPath
710
(u"/clients/"
711
+ self.name.replace(u".", u"_")))
712
DBusObjectWithProperties.__init__(self, self.bus,
713
self.dbus_object_path)
714
715
#Could possible return a bool(self._approvals_pending),
716
#but this could mess up approvals_pending += 1 XXX
717
def _get_approvals_pending(self):
718
return self._approvals_pending
719
def _set_approvals_pending(self, value):
720
old_value = self._approvals_pending
721
self._approvals_pending = value
722
bval = bool(value)
723
if (hasattr(self, "dbus_object_path")
724
and bval is not bool(old_value)):
725
dbus_bool = dbus.Boolean(bval, variant_level=1)
726
self.PropertyChanged(dbus.String(u"approved_pending"),
727
dbus_bool)
728
729
approvals_pending = property(_get_approvals_pending,
730
_set_approvals_pending)
731
del _get_approvals_pending, _set_approvals_pending
732
733
@staticmethod
734
def _datetime_to_dbus(dt, variant_level=0):
735
"""Convert a UTC datetime.datetime() to a D-Bus type."""
736
return dbus.String(dt.isoformat(),
737
variant_level=variant_level)
738
739
def enable(self):
740
oldstate = getattr(self, u"enabled", False)
741
r = Client.enable(self)
742
if oldstate != self.enabled:
743
# Emit D-Bus signals
744
self.PropertyChanged(dbus.String(u"enabled"),
745
dbus.Boolean(True, variant_level=1))
746
self.PropertyChanged(
747
dbus.String(u"last_enabled"),
748
self._datetime_to_dbus(self.last_enabled,
749
variant_level=1))
750
return r
751
752
def disable(self, quiet = False):
753
oldstate = getattr(self, u"enabled", False)
754
r = Client.disable(self, quiet=quiet)
755
if not quiet and oldstate != self.enabled:
756
# Emit D-Bus signal
757
self.PropertyChanged(dbus.String(u"enabled"),
758
dbus.Boolean(False, variant_level=1))
759
return r
760
761
def __del__(self, *args, **kwargs):
762
try:
763
self.remove_from_connection()
764
except LookupError:
765
pass
766
if hasattr(DBusObjectWithProperties, u"__del__"):
767
DBusObjectWithProperties.__del__(self, *args, **kwargs)
768
Client.__del__(self, *args, **kwargs)
769
770
def checker_callback(self, pid, condition, command,
771
*args, **kwargs):
772
self.checker_callback_tag = None
773
self.checker = None
774
# Emit D-Bus signal
775
self.PropertyChanged(dbus.String(u"checker_running"),
776
dbus.Boolean(False, variant_level=1))
777
if os.WIFEXITED(condition):
778
exitstatus = os.WEXITSTATUS(condition)
779
# Emit D-Bus signal
780
self.CheckerCompleted(dbus.Int16(exitstatus),
781
dbus.Int64(condition),
782
dbus.String(command))
783
else:
784
# Emit D-Bus signal
785
self.CheckerCompleted(dbus.Int16(-1),
786
dbus.Int64(condition),
787
dbus.String(command))
788
789
return Client.checker_callback(self, pid, condition, command,
790
*args, **kwargs)
791
792
def checked_ok(self, *args, **kwargs):
793
r = Client.checked_ok(self, *args, **kwargs)
794
# Emit D-Bus signal
795
self.PropertyChanged(
796
dbus.String(u"last_checked_ok"),
797
(self._datetime_to_dbus(self.last_checked_ok,
798
variant_level=1)))
799
return r
800
801
def start_checker(self, *args, **kwargs):
802
old_checker = self.checker
803
if self.checker is not None:
804
old_checker_pid = self.checker.pid
805
else:
806
old_checker_pid = None
807
r = Client.start_checker(self, *args, **kwargs)
808
# Only if new checker process was started
809
if (self.checker is not None
810
and old_checker_pid != self.checker.pid):
811
# Emit D-Bus signal
812
self.CheckerStarted(self.current_checker_command)
813
self.PropertyChanged(
814
dbus.String(u"checker_running"),
815
dbus.Boolean(True, variant_level=1))
816
return r
817
818
def stop_checker(self, *args, **kwargs):
819
old_checker = getattr(self, u"checker", None)
820
r = Client.stop_checker(self, *args, **kwargs)
821
if (old_checker is not None
822
and getattr(self, u"checker", None) is None):
436
if self.use_dbus:
823
437
self.PropertyChanged(dbus.String(u"checker_running"),
824
438
dbus.Boolean(False, variant_level=1))
825
return r
826
827
def _reset_approved(self):
828
self._approved = None
829
return False
830
831
def approve(self, value=True):
832
self.send_changedstate()
833
self._approved = value
834
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration),
835
self._reset_approved)
836
837
838
## D-Bus methods, signals & properties
839
_interface = u"se.bsnet.fukt.Mandos.Client"
840
841
## Signals
439
440
def still_valid(self):
441
"""Has the timeout not yet passed for this client?"""
442
if not getattr(self, "enabled", False):
443
return False
444
now = datetime.datetime.utcnow()
445
if self.last_checked_ok is None:
446
return now < (self.created + self.timeout)
447
else:
448
return now < (self.last_checked_ok + self.timeout)
449
450
## D-Bus methods & signals
451
_interface = u"org.mandos_system.Mandos.Client"
452
453
# BumpTimeout - method
454
BumpTimeout = dbus.service.method(_interface)(bump_timeout)
455
BumpTimeout.__name__ = "BumpTimeout"
842
456
843
457
# CheckerCompleted - signal
844
@dbus.service.signal(_interface, signature=u"nxs")
845
def CheckerCompleted(self, exitcode, waitstatus, command):
458
@dbus.service.signal(_interface, signature="bqs")
459
def CheckerCompleted(self, success, condition, command):
846
460
"D-Bus signal"
847
461
pass
848
462
849
463
# CheckerStarted - signal
850
@dbus.service.signal(_interface, signature=u"s")
464
@dbus.service.signal(_interface, signature="s")
851
465
def CheckerStarted(self, command):
852
466
"D-Bus signal"
853
467
pass
854
468
469
# GetAllProperties - method
470
@dbus.service.method(_interface, out_signature="a{sv}")
471
def GetAllProperties(self):
472
"D-Bus method"
473
return dbus.Dictionary({
474
dbus.String("name"):
475
dbus.String(self.name, variant_level=1),
476
dbus.String("fingerprint"):
477
dbus.String(self.fingerprint, variant_level=1),
478
dbus.String("host"):
479
dbus.String(self.host, variant_level=1),
480
dbus.String("created"):
481
_datetime_to_dbus(self.created, variant_level=1),
482
dbus.String("last_enabled"):
483
(_datetime_to_dbus(self.last_enabled,
484
variant_level=1)
485
if self.last_enabled is not None
486
else dbus.Boolean(False, variant_level=1)),
487
dbus.String("enabled"):
488
dbus.Boolean(self.enabled, variant_level=1),
489
dbus.String("last_checked_ok"):
490
(_datetime_to_dbus(self.last_checked_ok,
491
variant_level=1)
492
if self.last_checked_ok is not None
493
else dbus.Boolean (False, variant_level=1)),
494
dbus.String("timeout"):
495
dbus.UInt64(self.timeout_milliseconds(),
496
variant_level=1),
497
dbus.String("interval"):
498
dbus.UInt64(self.interval_milliseconds(),
499
variant_level=1),
500
dbus.String("checker"):
501
dbus.String(self.checker_command,
502
variant_level=1),
503
dbus.String("checker_running"):
504
dbus.Boolean(self.checker is not None,
505
variant_level=1),
506
}, signature="sv")
507
508
# IsStillValid - method
509
IsStillValid = (dbus.service.method(_interface, out_signature="b")
510
(still_valid))
511
IsStillValid.__name__ = "IsStillValid"
512
855
513
# PropertyChanged - signal
856
@dbus.service.signal(_interface, signature=u"sv")
514
@dbus.service.signal(_interface, signature="sv")
857
515
def PropertyChanged(self, property, value):
858
516
"D-Bus signal"
859
517
pass
860
518
861
# GotSecret - signal
862
# XXXTEDDY Is sent after succesfull transfer of secret from mandos-server to mandos-client
863
@dbus.service.signal(_interface)
864
def GotSecret(self):
865
"D-Bus signal"
866
pass
867
868
# Rejected - signal
869
@dbus.service.signal(_interface, signature=u"s")
870
def Rejected(self, reason):
871
"D-Bus signal"
872
pass
873
874
# NeedApproval - signal
875
@dbus.service.signal(_interface, signature=u"db")
876
def NeedApproval(self, timeout, default):
877
"D-Bus signal"
878
pass
879
880
## Methods
881
882
# Approve - method
883
@dbus.service.method(_interface, in_signature=u"b")
884
def Approve(self, value):
885
self.approve(value)
886
887
# CheckedOK - method
888
@dbus.service.method(_interface)
889
def CheckedOK(self):
890
return self.checked_ok()
519
# SetChecker - method
520
@dbus.service.method(_interface, in_signature="s")
521
def SetChecker(self, checker):
522
"D-Bus setter method"
523
self.checker_command = checker
524
# Emit D-Bus signal
525
self.PropertyChanged(dbus.String(u"checker"),
526
dbus.String(self.checker_command,
527
variant_level=1))
528
529
# SetHost - method
530
@dbus.service.method(_interface, in_signature="s")
531
def SetHost(self, host):
532
"D-Bus setter method"
533
self.host = host
534
# Emit D-Bus signal
535
self.PropertyChanged(dbus.String(u"host"),
536
dbus.String(self.host, variant_level=1))
537
538
# SetInterval - method
539
@dbus.service.method(_interface, in_signature="t")
540
def SetInterval(self, milliseconds):
541
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
542
# Emit D-Bus signal
543
self.PropertyChanged(dbus.String(u"interval"),
544
(dbus.UInt64(self.interval_milliseconds(),
545
variant_level=1)))
546
547
# SetSecret - method
548
@dbus.service.method(_interface, in_signature="ay",
549
byte_arrays=True)
550
def SetSecret(self, secret):
551
"D-Bus setter method"
552
self.secret = str(secret)
553
554
# SetTimeout - method
555
@dbus.service.method(_interface, in_signature="t")
556
def SetTimeout(self, milliseconds):
557
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
558
# Emit D-Bus signal
559
self.PropertyChanged(dbus.String(u"timeout"),
560
(dbus.UInt64(self.timeout_milliseconds(),
561
variant_level=1)))
891
562
892
563
# Enable - method
893
@dbus.service.method(_interface)
894
def Enable(self):
895
"D-Bus method"
896
self.enable()
564
Enable = dbus.service.method(_interface)(enable)
565
Enable.__name__ = "Enable"
897
566
898
567
# StartChecker - method
899
568
@dbus.service.method(_interface)
908
577
self.disable()
909
578
910
579
# StopChecker - method
911
@dbus.service.method(_interface)
912
def StopChecker(self):
913
self.stop_checker()
914
915
## Properties
916
917
# approved_pending - property
918
@dbus_service_property(_interface, signature=u"b", access=u"read")
919
def approved_pending_dbus_property(self):
920
return dbus.Boolean(bool(self.approvals_pending))
921
922
# approved_by_default - property
923
@dbus_service_property(_interface, signature=u"b",
924
access=u"readwrite")
925
def approved_by_default_dbus_property(self):
926
return dbus.Boolean(self.approved_by_default)
927
928
# approved_delay - property
929
@dbus_service_property(_interface, signature=u"t",
930
access=u"readwrite")
931
def approved_delay_dbus_property(self):
932
return dbus.UInt64(self.approved_delay_milliseconds())
933
934
# approved_duration - property
935
@dbus_service_property(_interface, signature=u"t",
936
access=u"readwrite")
937
def approved_duration_dbus_property(self):
938
return dbus.UInt64(self._timedelta_to_milliseconds(
939
self.approved_duration))
940
941
# name - property
942
@dbus_service_property(_interface, signature=u"s", access=u"read")
943
def name_dbus_property(self):
944
return dbus.String(self.name)
945
946
# fingerprint - property
947
@dbus_service_property(_interface, signature=u"s", access=u"read")
948
def fingerprint_dbus_property(self):
949
return dbus.String(self.fingerprint)
950
951
# host - property
952
@dbus_service_property(_interface, signature=u"s",
953
access=u"readwrite")
954
def host_dbus_property(self, value=None):
955
if value is None: # get
956
return dbus.String(self.host)
957
self.host = value
958
# Emit D-Bus signal
959
self.PropertyChanged(dbus.String(u"host"),
960
dbus.String(value, variant_level=1))
961
962
# created - property
963
@dbus_service_property(_interface, signature=u"s", access=u"read")
964
def created_dbus_property(self):
965
return dbus.String(self._datetime_to_dbus(self.created))
966
967
# last_enabled - property
968
@dbus_service_property(_interface, signature=u"s", access=u"read")
969
def last_enabled_dbus_property(self):
970
if self.last_enabled is None:
971
return dbus.String(u"")
972
return dbus.String(self._datetime_to_dbus(self.last_enabled))
973
974
# enabled - property
975
@dbus_service_property(_interface, signature=u"b",
976
access=u"readwrite")
977
def enabled_dbus_property(self, value=None):
978
if value is None: # get
979
return dbus.Boolean(self.enabled)
980
if value:
981
self.enable()
982
else:
983
self.disable()
984
985
# last_checked_ok - property
986
@dbus_service_property(_interface, signature=u"s",
987
access=u"readwrite")
988
def last_checked_ok_dbus_property(self, value=None):
989
if value is not None:
990
self.checked_ok()
991
return
992
if self.last_checked_ok is None:
993
return dbus.String(u"")
994
return dbus.String(self._datetime_to_dbus(self
995
.last_checked_ok))
996
997
# timeout - property
998
@dbus_service_property(_interface, signature=u"t",
999
access=u"readwrite")
1000
def timeout_dbus_property(self, value=None):
1001
if value is None: # get
1002
return dbus.UInt64(self.timeout_milliseconds())
1003
self.timeout = datetime.timedelta(0, 0, 0, value)
1004
# Emit D-Bus signal
1005
self.PropertyChanged(dbus.String(u"timeout"),
1006
dbus.UInt64(value, variant_level=1))
1007
if getattr(self, u"disable_initiator_tag", None) is None:
1008
return
1009
# Reschedule timeout
1010
gobject.source_remove(self.disable_initiator_tag)
1011
self.disable_initiator_tag = None
1012
time_to_die = (self.
1013
_timedelta_to_milliseconds((self
1014
.last_checked_ok
1015
+ self.timeout)
1016
- datetime.datetime
1017
.utcnow()))
1018
if time_to_die <= 0:
1019
# The timeout has passed
1020
self.disable()
1021
else:
1022
self.disable_initiator_tag = (gobject.timeout_add
1023
(time_to_die, self.disable))
1024
1025
# interval - property
1026
@dbus_service_property(_interface, signature=u"t",
1027
access=u"readwrite")
1028
def interval_dbus_property(self, value=None):
1029
if value is None: # get
1030
return dbus.UInt64(self.interval_milliseconds())
1031
self.interval = datetime.timedelta(0, 0, 0, value)
1032
# Emit D-Bus signal
1033
self.PropertyChanged(dbus.String(u"interval"),
1034
dbus.UInt64(value, variant_level=1))
1035
if getattr(self, u"checker_initiator_tag", None) is None:
1036
return
1037
# Reschedule checker run
1038
gobject.source_remove(self.checker_initiator_tag)
1039
self.checker_initiator_tag = (gobject.timeout_add
1040
(value, self.start_checker))
1041
self.start_checker() # Start one now, too
1042
1043
# checker - property
1044
@dbus_service_property(_interface, signature=u"s",
1045
access=u"readwrite")
1046
def checker_dbus_property(self, value=None):
1047
if value is None: # get
1048
return dbus.String(self.checker_command)
1049
self.checker_command = value
1050
# Emit D-Bus signal
1051
self.PropertyChanged(dbus.String(u"checker"),
1052
dbus.String(self.checker_command,
1053
variant_level=1))
1054
1055
# checker_running - property
1056
@dbus_service_property(_interface, signature=u"b",
1057
access=u"readwrite")
1058
def checker_running_dbus_property(self, value=None):
1059
if value is None: # get
1060
return dbus.Boolean(self.checker is not None)
1061
if value:
1062
self.start_checker()
1063
else:
1064
self.stop_checker()
1065
1066
# object_path - property
1067
@dbus_service_property(_interface, signature=u"o", access=u"read")
1068
def object_path_dbus_property(self):
1069
return self.dbus_object_path # is already a dbus.ObjectPath
1070
1071
# secret = property
1072
@dbus_service_property(_interface, signature=u"ay",
1073
access=u"write", byte_arrays=True)
1074
def secret_dbus_property(self, value):
1075
self.secret = str(value)
580
StopChecker = dbus.service.method(_interface)(stop_checker)
581
StopChecker.__name__ = "StopChecker"
1076
582
1077
583
del _interface
1078
584
1079
585
1080
class ProxyClient(object):
1081
def __init__(self, child_pipe, fpr, address):
1082
self._pipe = child_pipe
1083
self._pipe.send(('init', fpr, address))
1084
if not self._pipe.recv():
1085
raise KeyError()
1086
1087
def __getattribute__(self, name):
1088
if(name == '_pipe'):
1089
return super(ProxyClient, self).__getattribute__(name)
1090
self._pipe.send(('getattr', name))
1091
data = self._pipe.recv()
1092
if data[0] == 'data':
1093
return data[1]
1094
if data[0] == 'function':
1095
def func(*args, **kwargs):
1096
self._pipe.send(('funcall', name, args, kwargs))
1097
return self._pipe.recv()[1]
1098
return func
1099
1100
def __setattr__(self, name, value):
1101
if(name == '_pipe'):
1102
return super(ProxyClient, self).__setattr__(name, value)
1103
self._pipe.send(('setattr', name, value))
1104
1105
1106
class ClientHandler(socketserver.BaseRequestHandler, object):
1107
"""A class to handle client connections.
1108
1109
Instantiated once for each connection to handle it.
586
def peer_certificate(session):
587
"Return the peer's OpenPGP certificate as a bytestring"
588
# If not an OpenPGP certificate...
589
if (gnutls.library.functions
590
.gnutls_certificate_type_get(session._c_object)
591
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
592
# ...do the normal thing
593
return session.peer_certificate
594
list_size = ctypes.c_uint()
595
cert_list = (gnutls.library.functions
596
.gnutls_certificate_get_peers
597
(session._c_object, ctypes.byref(list_size)))
598
if list_size.value == 0:
599
return None
600
cert = cert_list[0]
601
return ctypes.string_at(cert.data, cert.size)
602
603
604
def fingerprint(openpgp):
605
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
606
# New GnuTLS "datum" with the OpenPGP public key
607
datum = (gnutls.library.types
608
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
609
ctypes.POINTER
610
(ctypes.c_ubyte)),
611
ctypes.c_uint(len(openpgp))))
612
# New empty GnuTLS certificate
613
crt = gnutls.library.types.gnutls_openpgp_crt_t()
614
(gnutls.library.functions
615
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
616
# Import the OpenPGP public key into the certificate
617
(gnutls.library.functions
618
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
619
gnutls.library.constants
620
.GNUTLS_OPENPGP_FMT_RAW))
621
# Verify the self signature in the key
622
crtverify = ctypes.c_uint()
623
(gnutls.library.functions
624
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
625
if crtverify.value != 0:
626
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
627
raise gnutls.errors.CertificateSecurityError("Verify failed")
628
# New buffer for the fingerprint
629
buf = ctypes.create_string_buffer(20)
630
buf_len = ctypes.c_size_t()
631
# Get the fingerprint from the certificate into the buffer
632
(gnutls.library.functions
633
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
634
ctypes.byref(buf_len)))
635
# Deinit the certificate
636
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
637
# Convert the buffer to a Python bytestring
638
fpr = ctypes.string_at(buf, buf_len.value)
639
# Convert the bytestring to hexadecimal notation
640
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
641
return hex_fpr
642
643
644
class TCP_handler(SocketServer.BaseRequestHandler, object):
645
"""A TCP request handler class.
646
Instantiated by IPv6_TCPServer for each request to handle it.
1110
647
Note: This will run in its own forked process."""
1111
648
1112
649
def handle(self):
1113
with contextlib.closing(self.server.child_pipe) as child_pipe:
1114
logger.info(u"TCP connection from: %s",
1115
unicode(self.client_address))
1116
logger.debug(u"Pipe FD: %d",
1117
self.server.child_pipe.fileno())
1118
1119
session = (gnutls.connection
1120
.ClientSession(self.request,
1121
gnutls.connection
1122
.X509Credentials()))
1123
1124
# Note: gnutls.connection.X509Credentials is really a
1125
# generic GnuTLS certificate credentials object so long as
1126
# no X.509 keys are added to it. Therefore, we can use it
1127
# here despite using OpenPGP certificates.
1128
1129
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1130
# u"+AES-256-CBC", u"+SHA1",
1131
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1132
# u"+DHE-DSS"))
1133
# Use a fallback default, since this MUST be set.
1134
priority = self.server.gnutls_priority
1135
if priority is None:
1136
priority = u"NORMAL"
1137
(gnutls.library.functions
1138
.gnutls_priority_set_direct(session._c_object,
1139
priority, None))
1140
1141
# Start communication using the Mandos protocol
1142
# Get protocol number
1143
line = self.request.makefile().readline()
1144
logger.debug(u"Protocol version: %r", line)
1145
try:
1146
if int(line.strip().split()[0]) > 1:
1147
raise RuntimeError
1148
except (ValueError, IndexError, RuntimeError), error:
1149
logger.error(u"Unknown protocol version: %s", error)
1150
return
1151
1152
# Start GnuTLS connection
1153
try:
1154
session.handshake()
1155
except gnutls.errors.GNUTLSError, error:
1156
logger.warning(u"Handshake failed: %s", error)
1157
# Do not run session.bye() here: the session is not
1158
# established. Just abandon the request.
1159
return
1160
logger.debug(u"Handshake succeeded")
1161
1162
approval_required = False
1163
try:
1164
try:
1165
fpr = self.fingerprint(self.peer_certificate
1166
(session))
1167
except (TypeError, gnutls.errors.GNUTLSError), error:
1168
logger.warning(u"Bad certificate: %s", error)
1169
return
1170
logger.debug(u"Fingerprint: %s", fpr)
1171
1172
try:
1173
client = ProxyClient(child_pipe, fpr,
1174
self.client_address)
1175
except KeyError:
1176
return
1177
1178
if client.approved_delay:
1179
delay = client.approved_delay
1180
client.approvals_pending += 1
1181
approval_required = True
1182
1183
while True:
1184
if not client.enabled:
1185
logger.warning(u"Client %s is disabled",
1186
client.name)
1187
if self.server.use_dbus:
1188
# Emit D-Bus signal
1189
client.Rejected("Disabled")
1190
return
1191
1192
if client._approved or not client.approved_delay:
1193
#We are approved or approval is disabled
1194
break
1195
elif client._approved is None:
1196
logger.info(u"Client %s need approval",
1197
client.name)
1198
if self.server.use_dbus:
1199
# Emit D-Bus signal
1200
client.NeedApproval(
1201
client.approved_delay_milliseconds(),
1202
client.approved_by_default)
1203
else:
1204
logger.warning(u"Client %s was not approved",
1205
client.name)
1206
if self.server.use_dbus:
1207
# Emit D-Bus signal
1208
client.Rejected("Disapproved")
1209
return
1210
1211
#wait until timeout or approved
1212
#x = float(client._timedelta_to_milliseconds(delay))
1213
time = datetime.datetime.now()
1214
client.changedstate.acquire()
1215
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1216
client.changedstate.release()
1217
time2 = datetime.datetime.now()
1218
if (time2 - time) >= delay:
1219
if not client.approved_by_default:
1220
logger.warning("Client %s timed out while"
1221
" waiting for approval",
1222
client.name)
1223
if self.server.use_dbus:
1224
# Emit D-Bus signal
1225
client.Rejected("Time out")
1226
return
1227
else:
1228
break
1229
else:
1230
delay -= time2 - time
1231
1232
sent_size = 0
1233
while sent_size < len(client.secret):
1234
# XXX handle session exception
1235
sent = session.send(client.secret[sent_size:])
1236
logger.debug(u"Sent: %d, remaining: %d",
1237
sent, len(client.secret)
1238
- (sent_size + sent))
1239
sent_size += sent
1240
1241
logger.info(u"Sending secret to %s", client.name)
1242
# bump the timeout as if seen
1243
client.checked_ok()
1244
if self.server.use_dbus:
1245
# Emit D-Bus signal
1246
client.GotSecret()
1247
1248
finally:
1249
if approval_required:
1250
client.approvals_pending -= 1
1251
session.bye()
1252
1253
@staticmethod
1254
def peer_certificate(session):
1255
"Return the peer's OpenPGP certificate as a bytestring"
1256
# If not an OpenPGP certificate...
1257
if (gnutls.library.functions
1258
.gnutls_certificate_type_get(session._c_object)
1259
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1260
# ...do the normal thing
1261
return session.peer_certificate
1262
list_size = ctypes.c_uint(1)
1263
cert_list = (gnutls.library.functions
1264
.gnutls_certificate_get_peers
1265
(session._c_object, ctypes.byref(list_size)))
1266
if not bool(cert_list) and list_size.value != 0:
1267
raise gnutls.errors.GNUTLSError(u"error getting peer"
1268
u" certificate")
1269
if list_size.value == 0:
1270
return None
1271
cert = cert_list[0]
1272
return ctypes.string_at(cert.data, cert.size)
1273
1274
@staticmethod
1275
def fingerprint(openpgp):
1276
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1277
# New GnuTLS "datum" with the OpenPGP public key
1278
datum = (gnutls.library.types
1279
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1280
ctypes.POINTER
1281
(ctypes.c_ubyte)),
1282
ctypes.c_uint(len(openpgp))))
1283
# New empty GnuTLS certificate
1284
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1285
(gnutls.library.functions
1286
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1287
# Import the OpenPGP public key into the certificate
1288
(gnutls.library.functions
1289
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1290
gnutls.library.constants
1291
.GNUTLS_OPENPGP_FMT_RAW))
1292
# Verify the self signature in the key
1293
crtverify = ctypes.c_uint()
1294
(gnutls.library.functions
1295
.gnutls_openpgp_crt_verify_self(crt, 0,
1296
ctypes.byref(crtverify)))
1297
if crtverify.value != 0:
1298
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1299
raise (gnutls.errors.CertificateSecurityError
1300
(u"Verify failed"))
1301
# New buffer for the fingerprint
1302
buf = ctypes.create_string_buffer(20)
1303
buf_len = ctypes.c_size_t()
1304
# Get the fingerprint from the certificate into the buffer
1305
(gnutls.library.functions
1306
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1307
ctypes.byref(buf_len)))
1308
# Deinit the certificate
1309
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1310
# Convert the buffer to a Python bytestring
1311
fpr = ctypes.string_at(buf, buf_len.value)
1312
# Convert the bytestring to hexadecimal notation
1313
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1314
return hex_fpr
1315
1316
1317
class MultiprocessingMixIn(object):
1318
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1319
def sub_process_main(self, request, address):
1320
try:
1321
self.finish_request(request, address)
1322
except:
1323
self.handle_error(request, address)
1324
self.close_request(request)
1325
1326
def process_request(self, request, address):
1327
"""Start a new process to process the request."""
1328
multiprocessing.Process(target = self.sub_process_main,
1329
args = (request, address)).start()
1330
1331
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1332
""" adds a pipe to the MixIn """
1333
def process_request(self, request, client_address):
1334
"""Overrides and wraps the original process_request().
1335
1336
This function creates a new pipe in self.pipe
1337
"""
1338
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1339
1340
super(MultiprocessingMixInWithPipe,
1341
self).process_request(request, client_address)
1342
self.child_pipe.close()
1343
self.add_pipe(parent_pipe)
1344
1345
def add_pipe(self, parent_pipe):
1346
"""Dummy function; override as necessary"""
1347
pass
1348
1349
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1350
socketserver.TCPServer, object):
1351
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1352
650
logger.info(u"TCP connection from: %s",
651
unicode(self.client_address))
652
session = (gnutls.connection
653
.ClientSession(self.request,
654
gnutls.connection
655
.X509Credentials()))
656
657
line = self.request.makefile().readline()
658
logger.debug(u"Protocol version: %r", line)
659
try:
660
if int(line.strip().split()[0]) > 1:
661
raise RuntimeError
662
except (ValueError, IndexError, RuntimeError), error:
663
logger.error(u"Unknown protocol version: %s", error)
664
return
665
666
# Note: gnutls.connection.X509Credentials is really a generic
667
# GnuTLS certificate credentials object so long as no X.509
668
# keys are added to it. Therefore, we can use it here despite
669
# using OpenPGP certificates.
670
671
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
672
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
673
# "+DHE-DSS"))
674
# Use a fallback default, since this MUST be set.
675
priority = self.server.settings.get("priority", "NORMAL")
676
(gnutls.library.functions
677
.gnutls_priority_set_direct(session._c_object,
678
priority, None))
679
680
try:
681
session.handshake()
682
except gnutls.errors.GNUTLSError, error:
683
logger.warning(u"Handshake failed: %s", error)
684
# Do not run session.bye() here: the session is not
685
# established. Just abandon the request.
686
return
687
try:
688
fpr = fingerprint(peer_certificate(session))
689
except (TypeError, gnutls.errors.GNUTLSError), error:
690
logger.warning(u"Bad certificate: %s", error)
691
session.bye()
692
return
693
logger.debug(u"Fingerprint: %s", fpr)
694
for c in self.server.clients:
695
if c.fingerprint == fpr:
696
client = c
697
break
698
else:
699
logger.warning(u"Client not found for fingerprint: %s",
700
fpr)
701
session.bye()
702
return
703
# Have to check if client.still_valid(), since it is possible
704
# that the client timed out while establishing the GnuTLS
705
# session.
706
if not client.still_valid():
707
logger.warning(u"Client %(name)s is invalid",
708
vars(client))
709
session.bye()
710
return
711
## This won't work here, since we're in a fork.
712
# client.bump_timeout()
713
sent_size = 0
714
while sent_size < len(client.secret):
715
sent = session.send(client.secret[sent_size:])
716
logger.debug(u"Sent: %d, remaining: %d",
717
sent, len(client.secret)
718
- (sent_size + sent))
719
sent_size += sent
720
session.bye()
721
722
723
class IPv6_TCPServer(SocketServer.ForkingMixIn,
724
SocketServer.TCPServer, object):
725
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1353
726
Attributes:
727
settings: Server settings
728
clients: Set() of Client objects
1354
729
enabled: Boolean; whether this server is activated yet
1355
interface: None or a network interface name (string)
1356
use_ipv6: Boolean; to use IPv6 or not
1357
730
"""
1358
def __init__(self, server_address, RequestHandlerClass,
1359
interface=None, use_ipv6=True):
1360
self.interface = interface
1361
if use_ipv6:
1362
self.address_family = socket.AF_INET6
1363
socketserver.TCPServer.__init__(self, server_address,
1364
RequestHandlerClass)
731
address_family = socket.AF_INET6
732
def __init__(self, *args, **kwargs):
733
if "settings" in kwargs:
734
self.settings = kwargs["settings"]
735
del kwargs["settings"]
736
if "clients" in kwargs:
737
self.clients = kwargs["clients"]
738
del kwargs["clients"]
739
self.enabled = False
740
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
1365
741
def server_bind(self):
1366
742
"""This overrides the normal server_bind() function
1367
743
to bind to an interface if one was specified, and also NOT to
1368
744
bind to an address or port if they were not specified."""
1369
if self.interface is not None:
1370
if SO_BINDTODEVICE is None:
1371
logger.error(u"SO_BINDTODEVICE does not exist;"
1372
u" cannot bind to interface %s",
1373
self.interface)
1374
else:
1375
try:
1376
self.socket.setsockopt(socket.SOL_SOCKET,
1377
SO_BINDTODEVICE,
1378
str(self.interface
1379
+ u'\0'))
1380
except socket.error, error:
1381
if error[0] == errno.EPERM:
1382
logger.error(u"No permission to"
1383
u" bind to interface %s",
1384
self.interface)
1385
elif error[0] == errno.ENOPROTOOPT:
1386
logger.error(u"SO_BINDTODEVICE not available;"
1387
u" cannot bind to interface %s",
1388
self.interface)
1389
else:
1390
raise
745
if self.settings["interface"]:
746
# 25 is from /usr/include/asm-i486/socket.h
747
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
748
try:
749
self.socket.setsockopt(socket.SOL_SOCKET,
750
SO_BINDTODEVICE,
751
self.settings["interface"])
752
except socket.error, error:
753
if error[0] == errno.EPERM:
754
logger.error(u"No permission to"
755
u" bind to interface %s",
756
self.settings["interface"])
757
else:
758
raise error
1391
759
# Only bind(2) the socket if we really need to.
1392
760
if self.server_address[0] or self.server_address[1]:
1393
761
if not self.server_address[0]:
1394
if self.address_family == socket.AF_INET6:
1395
any_address = u"::" # in6addr_any
1396
else:
1397
any_address = socket.INADDR_ANY
1398
self.server_address = (any_address,
762
in6addr_any = "::"
763
self.server_address = (in6addr_any,
1399
764
self.server_address[1])
1400
765
elif not self.server_address[1]:
1401
766
self.server_address = (self.server_address[0],
1402
767
0)
1403
# if self.interface:
768
# if self.settings["interface"]:
1404
769
# self.server_address = (self.server_address[0],
1405
770
# 0, # port
1406
771
# 0, # flowinfo
1407
772
# if_nametoindex
1408
# (self.interface))
1409
return socketserver.TCPServer.server_bind(self)
1410
1411
1412
class MandosServer(IPv6_TCPServer):
1413
"""Mandos server.
1414
1415
Attributes:
1416
clients: set of Client objects
1417
gnutls_priority GnuTLS priority string
1418
use_dbus: Boolean; to emit D-Bus signals or not
1419
1420
Assumes a gobject.MainLoop event loop.
1421
"""
1422
def __init__(self, server_address, RequestHandlerClass,
1423
interface=None, use_ipv6=True, clients=None,
1424
gnutls_priority=None, use_dbus=True):
1425
self.enabled = False
1426
self.clients = clients
1427
if self.clients is None:
1428
self.clients = set()
1429
self.use_dbus = use_dbus
1430
self.gnutls_priority = gnutls_priority
1431
IPv6_TCPServer.__init__(self, server_address,
1432
RequestHandlerClass,
1433
interface = interface,
1434
use_ipv6 = use_ipv6)
773
# (self.settings
774
# ["interface"]))
775
return super(IPv6_TCPServer, self).server_bind()
1435
776
def server_activate(self):
1436
777
if self.enabled:
1437
return socketserver.TCPServer.server_activate(self)
778
return super(IPv6_TCPServer, self).server_activate()
1438
779
def enable(self):
1439
780
self.enabled = True
1440
def add_pipe(self, parent_pipe):
1441
# Call "handle_ipc" for both data and EOF events
1442
gobject.io_add_watch(parent_pipe.fileno(),
1443
gobject.IO_IN | gobject.IO_HUP,
1444
functools.partial(self.handle_ipc,
1445
parent_pipe = parent_pipe))
1446
1447
def handle_ipc(self, source, condition, parent_pipe=None,
1448
client_object=None):
1449
condition_names = {
1450
gobject.IO_IN: u"IN", # There is data to read.
1451
gobject.IO_OUT: u"OUT", # Data can be written (without
1452
# blocking).
1453
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1454
gobject.IO_ERR: u"ERR", # Error condition.
1455
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1456
# broken, usually for pipes and
1457
# sockets).
1458
}
1459
conditions_string = ' | '.join(name
1460
for cond, name in
1461
condition_names.iteritems()
1462
if cond & condition)
1463
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1464
conditions_string)
1465
1466
# XXXTEDDY error or the other end of multiprocessing.Pipe has closed
1467
if condition & gobject.IO_HUP or condition & gobject.IO_ERR:
1468
return False
1469
1470
# Read a request from the child
1471
request = parent_pipe.recv()
1472
logger.debug(u"IPC request: %s", repr(request))
1473
command = request[0]
1474
1475
if command == 'init':
1476
fpr = request[1]
1477
address = request[2]
1478
1479
for c in self.clients:
1480
if c.fingerprint == fpr:
1481
client = c
1482
break
1483
else:
1484
logger.warning(u"Client not found for fingerprint: %s, ad"
1485
u"dress: %s", fpr, address)
1486
if self.use_dbus:
1487
# Emit D-Bus signal
1488
mandos_dbus_service.ClientNotFound(fpr, address)
1489
parent_pipe.send(False)
1490
return False
1491
1492
gobject.io_add_watch(parent_pipe.fileno(),
1493
gobject.IO_IN | gobject.IO_HUP,
1494
functools.partial(self.handle_ipc,
1495
parent_pipe = parent_pipe,
1496
client_object = client))
1497
parent_pipe.send(True)
1498
# remove the old hook in favor of the new above hook on same fileno
1499
return False
1500
if command == 'funcall':
1501
funcname = request[1]
1502
args = request[2]
1503
kwargs = request[3]
1504
1505
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1506
1507
if command == 'getattr':
1508
attrname = request[1]
1509
if callable(client_object.__getattribute__(attrname)):
1510
parent_pipe.send(('function',))
1511
else:
1512
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1513
1514
if command == 'setattr':
1515
attrname = request[1]
1516
value = request[2]
1517
setattr(client_object, attrname, value)
1518
1519
return True
1520
781
1521
782
1522
783
def string_to_delta(interval):
1523
784
"""Parse a string and return a datetime.timedelta
1524
1525
>>> string_to_delta(u'7d')
785
786
>>> string_to_delta('7d')
1526
787
datetime.timedelta(7)
1527
>>> string_to_delta(u'60s')
788
>>> string_to_delta('60s')
1528
789
datetime.timedelta(0, 60)
1529
>>> string_to_delta(u'60m')
790
>>> string_to_delta('60m')
1530
791
datetime.timedelta(0, 3600)
1531
>>> string_to_delta(u'24h')
792
>>> string_to_delta('24h')
1532
793
datetime.timedelta(1)
1533
794
>>> string_to_delta(u'1w')
1534
795
datetime.timedelta(7)
1535
>>> string_to_delta(u'5m 30s')
796
>>> string_to_delta('5m 30s')
1536
797
datetime.timedelta(0, 330)
1537
798
"""
1538
799
timevalue = datetime.timedelta(0)
1551
812
elif suffix == u"w":
1552
813
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1553
814
else:
1554
raise ValueError(u"Unknown suffix %r" % suffix)
1555
except (ValueError, IndexError), e:
1556
raise ValueError(e.message)
815
raise ValueError
816
except (ValueError, IndexError):
817
raise ValueError
1557
818
timevalue += delta
1558
819
return timevalue
1559
820
1560
821
822
def server_state_changed(state):
823
"""Derived from the Avahi example code"""
824
if state == avahi.SERVER_COLLISION:
825
logger.error(u"Zeroconf server name collision")
826
service.remove()
827
elif state == avahi.SERVER_RUNNING:
828
service.add()
829
830
831
def entry_group_state_changed(state, error):
832
"""Derived from the Avahi example code"""
833
logger.debug(u"Avahi state change: %i", state)
834
835
if state == avahi.ENTRY_GROUP_ESTABLISHED:
836
logger.debug(u"Zeroconf service established.")
837
elif state == avahi.ENTRY_GROUP_COLLISION:
838
logger.warning(u"Zeroconf service name collision.")
839
service.rename()
840
elif state == avahi.ENTRY_GROUP_FAILURE:
841
logger.critical(u"Avahi: Error in group state changed %s",
842
unicode(error))
843
raise AvahiGroupError(u"State changed: %s" % unicode(error))
844
1561
845
def if_nametoindex(interface):
1562
"""Call the C function if_nametoindex(), or equivalent
1563
1564
Note: This function cannot accept a unicode string."""
846
"""Call the C function if_nametoindex(), or equivalent"""
1565
847
global if_nametoindex
1566
848
try:
1567
849
if_nametoindex = (ctypes.cdll.LoadLibrary
1568
(ctypes.util.find_library(u"c"))
850
(ctypes.util.find_library("c"))
1569
851
.if_nametoindex)
1570
852
except (OSError, AttributeError):
1571
logger.warning(u"Doing if_nametoindex the hard way")
853
if "struct" not in sys.modules:
854
import struct
855
if "fcntl" not in sys.modules:
856
import fcntl
1572
857
def if_nametoindex(interface):
1573
858
"Get an interface index the hard way, i.e. using fcntl()"
1574
859
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1575
with contextlib.closing(socket.socket()) as s:
860
with closing(socket.socket()) as s:
1576
861
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1577
struct.pack(str(u"16s16x"),
1578
interface))
1579
interface_index = struct.unpack(str(u"I"),
1580
ifreq[16:20])[0]
862
struct.pack("16s16x", interface))
863
interface_index = struct.unpack("I", ifreq[16:20])[0]
1581
864
return interface_index
1582
865
return if_nametoindex(interface)
1583
866
1584
867
1585
868
def daemon(nochdir = False, noclose = False):
1586
869
"""See daemon(3). Standard BSD Unix function.
1587
1588
870
This should really exist as os.daemon, but it doesn't (yet)."""
1589
871
if os.fork():
1590
872
sys.exit()
1591
873
os.setsid()
1592
874
if not nochdir:
1593
os.chdir(u"/")
875
os.chdir("/")
1594
876
if os.fork():
1595
877
sys.exit()
1596
878
if not noclose:
1598
880
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1599
881
if not stat.S_ISCHR(os.fstat(null).st_mode):
1600
882
raise OSError(errno.ENODEV,
1601
u"%s not a character device"
1602
% os.path.devnull)
883
"/dev/null not a character device")
1603
884
os.dup2(null, sys.stdin.fileno())
1604
885
os.dup2(null, sys.stdout.fileno())
1605
886
os.dup2(null, sys.stderr.fileno())
1608
889
1609
890
1610
891
def main():
1611
1612
##################################################################
1613
# Parsing of options, both command line and config file
1614
1615
892
parser = optparse.OptionParser(version = "%%prog %s" % version)
1616
parser.add_option("-i", u"--interface", type=u"string",
1617
metavar="IF", help=u"Bind to interface IF")
1618
parser.add_option("-a", u"--address", type=u"string",
1619
help=u"Address to listen for requests on")
1620
parser.add_option("-p", u"--port", type=u"int",
1621
help=u"Port number to receive requests on")
1622
parser.add_option("--check", action=u"store_true",
1623
help=u"Run self-test")
1624
parser.add_option("--debug", action=u"store_true",
1625
help=u"Debug mode; run in foreground and log to"
1626
u" terminal")
1627
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1628
u" priority string (see GnuTLS documentation)")
1629
parser.add_option("--servicename", type=u"string",
1630
metavar=u"NAME", help=u"Zeroconf service name")
1631
parser.add_option("--configdir", type=u"string",
1632
default=u"/etc/mandos", metavar=u"DIR",
1633
help=u"Directory to search for configuration"
1634
u" files")
1635
parser.add_option("--no-dbus", action=u"store_false",
1636
dest=u"use_dbus", help=u"Do not provide D-Bus"
1637
u" system bus interface")
1638
parser.add_option("--no-ipv6", action=u"store_false",
1639
dest=u"use_ipv6", help=u"Do not use IPv6")
893
parser.add_option("-i", "--interface", type="string",
894
metavar="IF", help="Bind to interface IF")
895
parser.add_option("-a", "--address", type="string",
896
help="Address to listen for requests on")
897
parser.add_option("-p", "--port", type="int",
898
help="Port number to receive requests on")
899
parser.add_option("--check", action="store_true",
900
help="Run self-test")
901
parser.add_option("--debug", action="store_true",
902
help="Debug mode; run in foreground and log to"
903
" terminal")
904
parser.add_option("--priority", type="string", help="GnuTLS"
905
" priority string (see GnuTLS documentation)")
906
parser.add_option("--servicename", type="string", metavar="NAME",
907
help="Zeroconf service name")
908
parser.add_option("--configdir", type="string",
909
default="/etc/mandos", metavar="DIR",
910
help="Directory to search for configuration"
911
" files")
912
parser.add_option("--no-dbus", action="store_false",
913
dest="use_dbus",
914
help=optparse.SUPPRESS_HELP)
1640
915
options = parser.parse_args()[0]
1641
916
1642
917
if options.check:
1645
920
sys.exit()
1646
921
1647
922
# Default values for config file for server-global settings
1648
server_defaults = { u"interface": u"",
1649
u"address": u"",
1650
u"port": u"",
1651
u"debug": u"False",
1652
u"priority":
1653
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1654
u"servicename": u"Mandos",
1655
u"use_dbus": u"True",
1656
u"use_ipv6": u"True",
923
server_defaults = { "interface": "",
924
"address": "",
925
"port": "",
926
"debug": "False",
927
"priority":
928
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
929
"servicename": "Mandos",
930
"use_dbus": "True",
1657
931
}
1658
932
1659
933
# Parse config file for server-global settings
1660
server_config = configparser.SafeConfigParser(server_defaults)
934
server_config = ConfigParser.SafeConfigParser(server_defaults)
1661
935
del server_defaults
1662
server_config.read(os.path.join(options.configdir,
1663
u"mandos.conf"))
936
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1664
937
# Convert the SafeConfigParser object to a dict
1665
938
server_settings = server_config.defaults()
1666
# Use the appropriate methods on the non-string config options
1667
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1668
server_settings[option] = server_config.getboolean(u"DEFAULT",
1669
option)
1670
if server_settings["port"]:
1671
server_settings["port"] = server_config.getint(u"DEFAULT",
1672
u"port")
939
# Use getboolean on the boolean config options
940
server_settings["debug"] = (server_config.getboolean
941
("DEFAULT", "debug"))
942
server_settings["use_dbus"] = (server_config.getboolean
943
("DEFAULT", "use_dbus"))
1673
944
del server_config
1674
945
1675
946
# Override the settings from the config file with command line
1676
947
# options, if set.
1677
for option in (u"interface", u"address", u"port", u"debug",
1678
u"priority", u"servicename", u"configdir",
1679
u"use_dbus", u"use_ipv6"):
948
for option in ("interface", "address", "port", "debug",
949
"priority", "servicename", "configdir",
950
"use_dbus"):
1680
951
value = getattr(options, option)
1681
952
if value is not None:
1682
953
server_settings[option] = value
1683
954
del options
1684
# Force all strings to be unicode
1685
for option in server_settings.keys():
1686
if type(server_settings[option]) is str:
1687
server_settings[option] = unicode(server_settings[option])
1688
955
# Now we have our good server settings in "server_settings"
1689
956
1690
##################################################################
1691
1692
957
# For convenience
1693
debug = server_settings[u"debug"]
1694
use_dbus = server_settings[u"use_dbus"]
1695
use_ipv6 = server_settings[u"use_ipv6"]
958
debug = server_settings["debug"]
959
use_dbus = server_settings["use_dbus"]
960
use_dbus = False
1696
961
1697
962
if not debug:
1698
963
syslogger.setLevel(logging.WARNING)
1699
964
console.setLevel(logging.WARNING)
1700
965
1701
if server_settings[u"servicename"] != u"Mandos":
966
if server_settings["servicename"] != "Mandos":
1702
967
syslogger.setFormatter(logging.Formatter
1703
(u'Mandos (%s) [%%(process)d]:'
1704
u' %%(levelname)s: %%(message)s'
1705
% server_settings[u"servicename"]))
968
('Mandos (%s): %%(levelname)s:'
969
' %%(message)s'
970
% server_settings["servicename"]))
1706
971
1707
972
# Parse config file with clients
1708
client_defaults = { u"timeout": u"1h",
1709
u"interval": u"5m",
1710
u"checker": u"fping -q -- %%(host)s",
1711
u"host": u"",
1712
u"approved_delay": u"0s",
1713
u"approved_duration": u"1s",
973
client_defaults = { "timeout": "1h",
974
"interval": "5m",
975
"checker": "fping -q -- %(host)s",
976
"host": "",
1714
977
}
1715
client_config = configparser.SafeConfigParser(client_defaults)
1716
client_config.read(os.path.join(server_settings[u"configdir"],
1717
u"clients.conf"))
1718
1719
global mandos_dbus_service
1720
mandos_dbus_service = None
1721
1722
tcp_server = MandosServer((server_settings[u"address"],
1723
server_settings[u"port"]),
1724
ClientHandler,
1725
interface=server_settings[u"interface"],
1726
use_ipv6=use_ipv6,
1727
gnutls_priority=
1728
server_settings[u"priority"],
1729
use_dbus=use_dbus)
1730
pidfilename = u"/var/run/mandos.pid"
1731
try:
1732
pidfile = open(pidfilename, u"w")
1733
except IOError:
1734
logger.error(u"Could not open file %r", pidfilename)
1735
1736
try:
1737
uid = pwd.getpwnam(u"_mandos").pw_uid
1738
gid = pwd.getpwnam(u"_mandos").pw_gid
978
client_config = ConfigParser.SafeConfigParser(client_defaults)
979
client_config.read(os.path.join(server_settings["configdir"],
980
"clients.conf"))
981
982
clients = Set()
983
tcp_server = IPv6_TCPServer((server_settings["address"],
984
server_settings["port"]),
985
TCP_handler,
986
settings=server_settings,
987
clients=clients)
988
pidfilename = "/var/run/mandos.pid"
989
try:
990
pidfile = open(pidfilename, "w")
991
except IOError, error:
992
logger.error("Could not open file %r", pidfilename)
993
994
try:
995
uid = pwd.getpwnam("_mandos").pw_uid
1739
996
except KeyError:
1740
997
try:
1741
uid = pwd.getpwnam(u"mandos").pw_uid
1742
gid = pwd.getpwnam(u"mandos").pw_gid
998
uid = pwd.getpwnam("mandos").pw_uid
1743
999
except KeyError:
1744
1000
try:
1745
uid = pwd.getpwnam(u"nobody").pw_uid
1746
gid = pwd.getpwnam(u"nobody").pw_gid
1001
uid = pwd.getpwnam("nobody").pw_uid
1747
1002
except KeyError:
1748
1003
uid = 65534
1004
try:
1005
gid = pwd.getpwnam("_mandos").pw_gid
1006
except KeyError:
1007
try:
1008
gid = pwd.getpwnam("mandos").pw_gid
1009
except KeyError:
1010
try:
1011
gid = pwd.getpwnam("nogroup").pw_gid
1012
except KeyError:
1749
1013
gid = 65534
1750
1014
try:
1015
os.setuid(uid)
1751
1016
os.setgid(gid)
1752
os.setuid(uid)
1753
1017
except OSError, error:
1754
1018
if error[0] != errno.EPERM:
1755
1019
raise error
1756
1020
1757
# Enable all possible GnuTLS debugging
1758
if debug:
1759
# "Use a log level over 10 to enable all debugging options."
1760
# - GnuTLS manual
1761
gnutls.library.functions.gnutls_global_set_log_level(11)
1762
1763
@gnutls.library.types.gnutls_log_func
1764
def debug_gnutls(level, string):
1765
logger.debug(u"GnuTLS: %s", string[:-1])
1766
1767
(gnutls.library.functions
1768
.gnutls_global_set_log_function(debug_gnutls))
1021
global service
1022
service = AvahiService(name = server_settings["servicename"],
1023
servicetype = "_mandos._tcp", )
1024
if server_settings["interface"]:
1025
service.interface = (if_nametoindex
1026
(server_settings["interface"]))
1769
1027
1770
1028
global main_loop
1029
global bus
1030
global server
1771
1031
# From the Avahi example code
1772
1032
DBusGMainLoop(set_as_default=True )
1773
1033
main_loop = gobject.MainLoop()
1774
1034
bus = dbus.SystemBus()
1035
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1036
avahi.DBUS_PATH_SERVER),
1037
avahi.DBUS_INTERFACE_SERVER)
1775
1038
# End of Avahi example code
1776
1039
if use_dbus:
1777
try:
1778
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1779
bus, do_not_queue=True)
1780
except dbus.exceptions.NameExistsException, e:
1781
logger.error(unicode(e) + u", disabling D-Bus")
1782
use_dbus = False
1783
server_settings[u"use_dbus"] = False
1784
tcp_server.use_dbus = False
1785
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1786
service = AvahiService(name = server_settings[u"servicename"],
1787
servicetype = u"_mandos._tcp",
1788
protocol = protocol, bus = bus)
1789
if server_settings["interface"]:
1790
service.interface = (if_nametoindex
1791
(str(server_settings[u"interface"])))
1792
1793
global multiprocessing_manager
1794
multiprocessing_manager = multiprocessing.Manager()
1795
1796
client_class = Client
1797
if use_dbus:
1798
client_class = functools.partial(ClientDBus, bus = bus)
1799
def client_config_items(config, section):
1800
special_settings = {
1801
"approved_by_default":
1802
lambda: config.getboolean(section,
1803
"approved_by_default"),
1804
}
1805
for name, value in config.items(section):
1806
try:
1807
yield (name, special_settings[name]())
1808
except KeyError:
1809
yield (name, value)
1810
1811
tcp_server.clients.update(set(
1812
client_class(name = section,
1813
config= dict(client_config_items(
1814
client_config, section)))
1815
for section in client_config.sections()))
1816
if not tcp_server.clients:
1040
bus_name = dbus.service.BusName(u"org.mandos-system.Mandos",
1041
bus)
1042
1043
clients.update(Set(Client(name = section,
1044
config
1045
= dict(client_config.items(section)),
1046
use_dbus = use_dbus)
1047
for section in client_config.sections()))
1048
if not clients:
1817
1049
logger.warning(u"No clients defined")
1818
1050
1819
1051
if debug:
1829
1061
daemon()
1830
1062
1831
1063
try:
1832
with pidfile:
1833
pid = os.getpid()
1834
pidfile.write(str(pid) + "\n")
1064
pid = os.getpid()
1065
pidfile.write(str(pid) + "\n")
1066
pidfile.close()
1835
1067
del pidfile
1836
1068
except IOError:
1837
1069
logger.error(u"Could not write to file %r with PID %d",
1841
1073
pass
1842
1074
del pidfilename
1843
1075
1076
def cleanup():
1077
"Cleanup function; run on exit"
1078
global group
1079
# From the Avahi example code
1080
if not group is None:
1081
group.Free()
1082
group = None
1083
# End of Avahi example code
1084
1085
while clients:
1086
client = clients.pop()
1087
client.disable_hook = None
1088
client.disable()
1089
1090
atexit.register(cleanup)
1091
1844
1092
if not debug:
1845
1093
signal.signal(signal.SIGINT, signal.SIG_IGN)
1846
1094
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1847
1095
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1848
1096
1849
1097
if use_dbus:
1850
class MandosDBusService(dbus.service.Object):
1098
class MandosServer(dbus.service.Object):
1851
1099
"""A D-Bus proxy object"""
1852
1100
def __init__(self):
1853
dbus.service.Object.__init__(self, bus, u"/")
1854
_interface = u"se.bsnet.fukt.Mandos"
1855
1856
@dbus.service.signal(_interface, signature=u"o")
1857
def ClientAdded(self, objpath):
1858
"D-Bus signal"
1859
pass
1860
1861
@dbus.service.signal(_interface, signature=u"ss")
1862
def ClientNotFound(self, fingerprint, address):
1863
"D-Bus signal"
1864
pass
1865
1866
@dbus.service.signal(_interface, signature=u"os")
1867
def ClientRemoved(self, objpath, name):
1868
"D-Bus signal"
1869
pass
1870
1871
@dbus.service.method(_interface, out_signature=u"ao")
1101
dbus.service.Object.__init__(self, bus,
1102
"/Mandos")
1103
_interface = u"org.mandos_system.Mandos"
1104
1105
@dbus.service.signal(_interface, signature="oa{sv}")
1106
def ClientAdded(self, objpath, properties):
1107
"D-Bus signal"
1108
pass
1109
1110
@dbus.service.signal(_interface, signature="o")
1111
def ClientRemoved(self, objpath):
1112
"D-Bus signal"
1113
pass
1114
1115
@dbus.service.method(_interface, out_signature="ao")
1872
1116
def GetAllClients(self):
1873
"D-Bus method"
1874
return dbus.Array(c.dbus_object_path
1875
for c in tcp_server.clients)
1876
1877
@dbus.service.method(_interface,
1878
out_signature=u"a{oa{sv}}")
1117
return dbus.Array(c.dbus_object_path for c in clients)
1118
1119
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1879
1120
def GetAllClientsWithProperties(self):
1880
"D-Bus method"
1881
1121
return dbus.Dictionary(
1882
((c.dbus_object_path, c.GetAll(u""))
1883
for c in tcp_server.clients),
1884
signature=u"oa{sv}")
1885
1886
@dbus.service.method(_interface, in_signature=u"o")
1122
((c.dbus_object_path, c.GetAllProperties())
1123
for c in clients),
1124
signature="oa{sv}")
1125
1126
@dbus.service.method(_interface, in_signature="o")
1887
1127
def RemoveClient(self, object_path):
1888
"D-Bus method"
1889
for c in tcp_server.clients:
1128
for c in clients:
1890
1129
if c.dbus_object_path == object_path:
1891
tcp_server.clients.remove(c)
1892
c.remove_from_connection()
1130
clients.remove(c)
1893
1131
# Don't signal anything except ClientRemoved
1894
c.disable(quiet=True)
1132
c.use_dbus = False
1133
c.disable()
1895
1134
# Emit D-Bus signal
1896
self.ClientRemoved(object_path, c.name)
1135
self.ClientRemoved(object_path)
1897
1136
return
1898
raise KeyError(object_path)
1899
1137
raise KeyError
1138
@dbus.service.method(_interface)
1139
def Quit(self):
1140
main_loop.quit()
1141
1900
1142
del _interface
1901
1902
mandos_dbus_service = MandosDBusService()
1903
1904
def cleanup():
1905
"Cleanup function; run on exit"
1906
service.cleanup()
1907
1908
while tcp_server.clients:
1909
client = tcp_server.clients.pop()
1910
if use_dbus:
1911
client.remove_from_connection()
1912
client.disable_hook = None
1913
# Don't signal anything except ClientRemoved
1914
client.disable(quiet=True)
1915
if use_dbus:
1916
# Emit D-Bus signal
1917
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
1918
client.name)
1919
1920
atexit.register(cleanup)
1921
1922
for client in tcp_server.clients:
1143
1144
mandos_server = MandosServer()
1145
1146
for client in clients:
1923
1147
if use_dbus:
1924
1148
# Emit D-Bus signal
1925
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1149
mandos_server.ClientAdded(client.dbus_object_path,
1150
client.GetAllProperties())
1926
1151
client.enable()
1927
1152
1928
1153
tcp_server.enable()
1930
1155
1931
1156
# Find out what port we got
1932
1157
service.port = tcp_server.socket.getsockname()[1]
1933
if use_ipv6:
1934
logger.info(u"Now listening on address %r, port %d,"
1935
" flowinfo %d, scope_id %d"
1936
% tcp_server.socket.getsockname())
1937
else: # IPv4
1938
logger.info(u"Now listening on address %r, port %d"
1939
% tcp_server.socket.getsockname())
1158
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1159
u" scope_id %d" % tcp_server.socket.getsockname())
1940
1160
1941
1161
#service.interface = tcp_server.socket.getsockname()[3]
1942
1162
1943
1163
try:
1944
1164
# From the Avahi example code
1165
server.connect_to_signal("StateChanged", server_state_changed)
1945
1166
try:
1946
service.activate()
1167
server_state_changed(server.GetState())
1947
1168
except dbus.exceptions.DBusException, error:
1948
1169
logger.critical(u"DBusException: %s", error)
1949
cleanup()
1950
1170
sys.exit(1)
1951
1171
# End of Avahi example code
1952
1172
1959
1179
main_loop.run()
1960
1180
except AvahiError, error:
1961
1181
logger.critical(u"AvahiError: %s", error)
1962
cleanup()
1963
1182
sys.exit(1)
1964
1183
except KeyboardInterrupt:
1965
1184
if debug:
1966
print >> sys.stderr
1967
logger.debug(u"Server received KeyboardInterrupt")
1968
logger.debug(u"Server exiting")
1969
# Must run before the D-Bus bus name gets deregistered
1970
cleanup()
1185
print
1971
1186
1972
1187
if __name__ == '__main__':
1973
1188
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0