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