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