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