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