To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to server.py
- browse files at revision 42
- compare with another revision
- download diff
- download tarball
- view history from revision 42
- Committer: Teddy Hogeborn
- Date: 2008-08-04 16:05:01 UTC
- mfrom: (24.1.15 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080804160501-woej7nf8amgrbc2e
* plugins.d/mandosclient.c (start_mandos_communication): Change "to"
to be a union. All users changed.
to be a union. All users changed.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- files renamed:
- plugin-runner.c => plugbasedclient.c
- plugins.d/mandos-client.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos.conf => server.conf
- mandos => server.py
- files modified:
- Makefile
added
removed
server.py
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
# following functions: "AvahiService.add", "AvahiService.remove",
10
# "server_state_changed", "entry_group_state_changed", and some lines
11
# 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
# Brief description of the operation of this program:
65
#
66
# This server announces itself as a Zeroconf service. Connecting
67
# clients use the TLS protocol, with the unusual quirk that this
68
# server program acts as a TLS "client" while a connecting client acts
69
# as a TLS "server". The client (acting as a TLS "server") must
70
# supply an OpenPGP certificate, and the fingerprint of this
71
# certificate is used by this server to look up (in a list read from a
72
# file at start time) which binary blob to give the client. No other
73
# authentication or authorization is done by this server.
74
75
76
logger = logging.Logger('mandos')
77
syslogger = logging.handlers.SysLogHandler\
78
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
79
syslogger.setFormatter(logging.Formatter\
80
('%(levelname)s: %(message)s'))
93
81
logger.addHandler(syslogger)
82
del syslogger
94
83
95
console = logging.StreamHandler()
96
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
97
u' %(levelname)s:'
98
u' %(message)s'))
99
logger.addHandler(console)
100
84
101
85
class AvahiError(Exception):
102
def __init__(self, value, *args, **kwargs):
86
def __init__(self, value):
103
87
self.value = value
104
super(AvahiError, self).__init__(value, *args, **kwargs)
105
def __unicode__(self):
106
return unicode(repr(self.value))
88
def __str__(self):
89
return repr(self.value)
107
90
108
91
class AvahiServiceError(AvahiError):
109
92
pass
113
96
114
97
115
98
class AvahiService(object):
116
"""An Avahi (Zeroconf) service.
117
118
Attributes:
99
"""
119
100
interface: integer; avahi.IF_UNSPEC or an interface index.
120
101
Used to optionally bind to the specified interface.
121
name: string; Example: u'Mandos'
122
type: string; Example: u'_mandos._tcp'.
123
See <http://www.dns-sd.org/ServiceTypes.html>
124
port: integer; what port to announce
125
TXT: list of strings; TXT record for the service
126
domain: string; Domain to publish on, default to .local if empty.
127
host: string; Host to publish records for, default is localhost
128
max_renames: integer; maximum number of renames
129
rename_count: integer; counter so we only rename after collisions
130
a sensible number of times
131
group: D-Bus Entry Group
132
server: D-Bus Server
133
bus: dbus.SystemBus()
102
name = string; Example: "Mandos"
103
type = string; Example: "_mandos._tcp".
104
See <http://www.dns-sd.org/ServiceTypes.html>
105
port = integer; what port to announce
106
TXT = list of strings; TXT record for the service
107
domain = string; Domain to publish on, default to .local if empty.
108
host = string; Host to publish records for, default to localhost
109
if empty.
110
max_renames = integer; maximum number of renames
111
rename_count = integer; counter so we only rename after collisions
112
a sensible number of times
134
113
"""
135
114
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):
115
type = None, port = None, TXT = None, domain = "",
116
host = "", max_renames = 12):
117
"""An Avahi (Zeroconf) service. """
139
118
self.interface = interface
140
119
self.name = name
141
self.type = servicetype
120
self.type = type
142
121
self.port = port
143
self.TXT = TXT if TXT is not None else []
122
if TXT is None:
123
self.TXT = []
124
else:
125
self.TXT = TXT
144
126
self.domain = domain
145
127
self.host = host
146
128
self.rename_count = 0
147
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
129
def rename(self):
153
130
"""Derived from the Avahi example code"""
154
131
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))
132
logger.critical(u"No suitable service name found after %i"
133
u" retries, exiting.", rename_count)
134
raise AvahiServiceError("Too many renames")
135
name = server.GetAlternativeServiceName(name)
136
logger.notice(u"Changing name to %r ...", name)
166
137
self.remove()
167
138
self.add()
168
139
self.rename_count += 1
169
140
def remove(self):
170
141
"""Derived from the Avahi example code"""
171
if self.group is not None:
172
self.group.Reset()
142
if group is not None:
143
group.Reset()
173
144
def add(self):
174
145
"""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())
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)
154
logger.debug(u"Adding service '%s' of type '%s' ...",
155
service.name, service.type)
156
group.AddService(
157
self.interface, # interface
158
avahi.PROTO_INET6, # protocol
159
dbus.UInt32(0), # flags
160
self.name, self.type,
161
self.domain, self.host,
162
dbus.UInt16(self.port),
163
avahi.string_array_to_txt_array(self.TXT))
164
group.Commit()
165
166
# From the Avahi example code:
167
group = None # our entry group
168
# End of Avahi example code
230
169
231
170
232
171
class Client(object):
233
172
"""A representation of a client host served by this server.
234
235
173
Attributes:
236
name: string; from the config file, used in log messages and
237
D-Bus identifiers
174
name: string; from the config file, used in log messages
238
175
fingerprint: string (40 or 32 hexadecimal digits); used to
239
176
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.
177
secret: bytestring; sent verbatim (over TLS) to client
178
fqdn: string (FQDN); 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.
253
188
checker_initiator_tag: a gobject event source tag, or None
254
disable_initiator_tag: - '' -
189
stop_initiator_tag: - '' -
255
190
checker_callback_tag: - '' -
256
191
checker_command: string; External command which is run to check if
257
192
client lives. %() expansions are done at
258
193
runtime with vars(self) as dict, so that for
259
194
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
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: - '' -
264
200
"""
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):
285
"""Note: the 'checker' key in 'config' sets the
286
'checker_command' attribute and *not* the 'checker'
287
attribute."""
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, fingerprint=None,
225
secret=None, secfile=None, fqdn=None, timeout=None,
226
interval=-1, checker=None):
227
"""Note: the 'checker' argument sets the 'checker_command'
228
attribute and not the 'checker' attribute.."""
288
229
self.name = name
289
if config is None:
290
config = {}
291
230
logger.debug(u"Creating client %r", self.name)
292
# Uppercase and remove spaces from fingerprint for later
293
# comparison purposes with return value from the fingerprint()
294
# function
295
self.fingerprint = (config[u"fingerprint"].upper()
296
.replace(u" ", u""))
231
# Uppercase and remove spaces from fingerprint
232
# for later comparison purposes with return value of
233
# the fingerprint() function
234
self.fingerprint = fingerprint.upper().replace(u" ", u"")
297
235
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()
236
if secret:
237
self.secret = secret.decode(u"base64")
238
elif secfile:
239
sf = open(secfile)
240
self.secret = sf.read()
241
sf.close()
305
242
else:
306
#XXX Need to allow secret on demand!
307
243
raise TypeError(u"No secret or secfile for client %s"
308
244
% 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
245
self.fqdn = fqdn
246
self.created = datetime.datetime.now()
313
247
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
248
self.timeout = string_to_delta(timeout)
249
self.interval = string_to_delta(interval)
250
self.stop_hook = stop_hook
317
251
self.checker = None
318
252
self.checker_initiator_tag = None
319
self.disable_initiator_tag = None
253
self.stop_initiator_tag = None
320
254
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):
255
self.check_command = checker
256
def start(self):
340
257
"""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
258
# Schedule a new checker to be started an 'interval' from now,
347
259
# 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
260
self.checker_initiator_tag = gobject.timeout_add\
261
(self._interval_milliseconds,
262
self.start_checker)
356
263
# Also start a new checker *right now*.
357
264
self.start_checker()
358
359
def disable(self, quiet=True):
360
"""Disable this client."""
361
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 self.secret:
275
logger.debug(u"Stopping client %s", self.name)
276
self.secret = None
277
else:
362
278
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):
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):
371
283
gobject.source_remove(self.checker_initiator_tag)
372
284
self.checker_initiator_tag = None
373
285
self.stop_checker()
374
if self.disable_hook:
375
self.disable_hook(self)
376
self.enabled = False
286
if self.stop_hook:
287
self.stop_hook(self)
377
288
# Do not run this again if called by a gobject.timeout_add
378
289
return False
379
380
290
def __del__(self):
381
self.disable_hook = None
382
self.disable()
383
384
def checker_callback(self, pid, condition, command):
291
self.stop_hook = None
292
self.stop()
293
def checker_callback(self, pid, condition):
385
294
"""The checker has completed, so take appropriate actions."""
295
now = datetime.datetime.now()
386
296
self.checker_callback_tag = None
387
297
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:
298
if os.WIFEXITED(condition) \
299
and (os.WEXITSTATUS(condition) == 0):
300
logger.debug(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):
398
308
logger.warning(u"Checker for %(name)s crashed?",
399
309
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
310
else:
311
logger.debug(u"Checker for %(name)s failed",
312
vars(self))
413
313
def start_checker(self):
414
314
"""Start a new checker subprocess if one is not running.
415
416
315
If a checker already exists, leave it running and do
417
316
nothing."""
418
317
# The reason for not killing a running checker is that if we
421
320
# client would inevitably timeout, since no checker would get
422
321
# a chance to run to completion. If we instead leave running
423
322
# 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
323
# than 'timeout' for the client to be declared invalid, which
324
# is as it should be.
441
325
if self.checker is None:
442
326
try:
443
# In case checker_command has exactly one % operator
444
command = self.checker_command % self.host
327
# In case check_command has exactly one % operator
328
command = self.check_command % self.fqdn
445
329
except TypeError:
446
330
# Escape attributes for the shell
447
escaped_attrs = dict((key,
448
re.escape(unicode(str(val),
449
errors=
450
u'replace')))
331
escaped_attrs = dict((key, re.escape(str(val)))
451
332
for key, val in
452
333
vars(self).iteritems())
453
334
try:
454
command = self.checker_command % escaped_attrs
335
command = self.check_command % escaped_attrs
455
336
except TypeError, error:
456
337
logger.error(u'Could not format string "%s":'
457
u' %s', self.checker_command, error)
338
u' %s', self.check_command, error)
458
339
return True # Try again later
459
self.current_checker_command = command
460
340
try:
461
logger.info(u"Starting checker %r for %s",
462
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.)
341
logger.debug(u"Starting checker %r for %s",
342
command, self.name)
467
343
self.checker = subprocess.Popen(command,
468
344
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:
345
shell=True, cwd="/")
346
self.checker_callback_tag = gobject.child_watch_add\
347
(self.checker.pid,
348
self.checker_callback)
349
except subprocess.OSError, error:
481
350
logger.error(u"Failed to start subprocess: %s",
482
351
error)
483
352
# Re-run this periodically if run by gobject.timeout_add
484
353
return True
485
486
354
def stop_checker(self):
487
355
"""Force the checker process, if any, to stop."""
488
356
if self.checker_callback_tag:
489
357
gobject.source_remove(self.checker_callback_tag)
490
358
self.checker_callback_tag = None
491
if getattr(self, u"checker", None) is None:
359
if getattr(self, "checker", None) is None:
492
360
return
493
logger.debug(u"Stopping checker for %(name)s", vars(self))
361
logger.debug("Stopping checker for %(name)s", vars(self))
494
362
try:
495
363
os.kill(self.checker.pid, signal.SIGTERM)
496
#time.sleep(0.5)
364
#os.sleep(0.5)
497
365
#if self.checker.poll() is None:
498
366
# os.kill(self.checker.pid, signal.SIGKILL)
499
367
except OSError, error:
500
368
if error.errno != errno.ESRCH: # No such process
501
369
raise
502
370
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
371
def still_valid(self):
372
"""Has the timeout not yet passed for this client?"""
373
now = datetime.datetime.now()
973
374
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.
375
return now < (self.created + self.timeout)
376
else:
377
return now < (self.last_checked_ok + self.timeout)
378
379
380
def peer_certificate(session):
381
"Return the peer's OpenPGP certificate as a bytestring"
382
# If not an OpenPGP certificate...
383
if gnutls.library.functions.gnutls_certificate_type_get\
384
(session._c_object) \
385
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
386
# ...do the normal thing
387
return session.peer_certificate
388
list_size = ctypes.c_uint()
389
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
390
(session._c_object, ctypes.byref(list_size))
391
if list_size.value == 0:
392
return None
393
cert = cert_list[0]
394
return ctypes.string_at(cert.data, cert.size)
395
396
397
def fingerprint(openpgp):
398
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
399
# New empty GnuTLS certificate
400
crt = gnutls.library.types.gnutls_openpgp_crt_t()
401
gnutls.library.functions.gnutls_openpgp_crt_init\
402
(ctypes.byref(crt))
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
# Import the OpenPGP public key into the certificate
409
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
410
(crt,
411
ctypes.byref(datum),
412
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
# New buffer for the fingerprint
414
buffer = ctypes.create_string_buffer(20)
415
buffer_length = ctypes.c_size_t()
416
# Get the fingerprint from the certificate into the buffer
417
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
418
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
419
# Deinit the certificate
420
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
421
# Convert the buffer to a Python bytestring
422
fpr = ctypes.string_at(buffer, buffer_length.value)
423
# Convert the bytestring to hexadecimal notation
424
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
425
return hex_fpr
426
427
428
class tcp_handler(SocketServer.BaseRequestHandler, object):
429
"""A TCP request handler class.
430
Instantiated by IPv6_TCPServer for each request to handle it.
1091
431
Note: This will run in its own forked process."""
1092
432
1093
433
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
434
logger.debug(u"TCP connection from: %s",
435
unicode(self.client_address))
436
session = gnutls.connection.ClientSession\
437
(self.request, gnutls.connection.X509Credentials())
438
439
line = self.request.makefile().readline()
440
logger.debug(u"Protocol version: %r", line)
441
try:
442
if int(line.strip().split()[0]) > 1:
443
raise RuntimeError
444
except (ValueError, IndexError, RuntimeError), error:
445
logger.error(u"Unknown protocol version: %s", error)
446
return
447
448
# Note: gnutls.connection.X509Credentials is really a generic
449
# GnuTLS certificate credentials object so long as no X.509
450
# keys are added to it. Therefore, we can use it here despite
451
# using OpenPGP certificates.
452
453
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
454
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
455
# "+DHE-DSS"))
456
priority = "NORMAL" # Fallback default, since this
457
# MUST be set.
458
if self.server.settings["priority"]:
459
priority = self.server.settings["priority"]
460
gnutls.library.functions.gnutls_priority_set_direct\
461
(session._c_object, priority, None);
462
463
try:
464
session.handshake()
465
except gnutls.errors.GNUTLSError, error:
466
logger.debug(u"Handshake failed: %s", error)
467
# Do not run session.bye() here: the session is not
468
# established. Just abandon the request.
469
return
470
try:
471
fpr = fingerprint(peer_certificate(session))
472
except (TypeError, gnutls.errors.GNUTLSError), error:
473
logger.debug(u"Bad certificate: %s", error)
474
session.bye()
475
return
476
logger.debug(u"Fingerprint: %s", fpr)
477
client = None
478
for c in self.server.clients:
479
if c.fingerprint == fpr:
480
client = c
481
break
482
if not client:
483
logger.debug(u"Client not found for fingerprint: %s", fpr)
484
session.bye()
485
return
486
# Have to check if client.still_valid(), since it is possible
487
# that the client timed out while establishing the GnuTLS
488
# session.
489
if not client.still_valid():
490
logger.debug(u"Client %(name)s is invalid", vars(client))
491
session.bye()
492
return
493
sent_size = 0
494
while sent_size < len(client.secret):
495
sent = session.send(client.secret[sent_size:])
496
logger.debug(u"Sent: %d, remaining: %d",
497
sent, len(client.secret)
498
- (sent_size + sent))
499
sent_size += sent
500
session.bye()
501
502
503
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
504
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1334
505
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
506
settings: Server settings
507
clients: Set() of Client objects
1338
508
"""
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)
509
address_family = socket.AF_INET6
510
def __init__(self, *args, **kwargs):
511
if "settings" in kwargs:
512
self.settings = kwargs["settings"]
513
del kwargs["settings"]
514
if "clients" in kwargs:
515
self.clients = kwargs["clients"]
516
del kwargs["clients"]
517
return super(type(self), self).__init__(*args, **kwargs)
1346
518
def server_bind(self):
1347
519
"""This overrides the normal server_bind() function
1348
520
to bind to an interface if one was specified, and also NOT to
1349
521
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
522
if self.settings["interface"]:
523
# 25 is from /usr/include/asm-i486/socket.h
524
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
525
try:
526
self.socket.setsockopt(socket.SOL_SOCKET,
527
SO_BINDTODEVICE,
528
self.settings["interface"])
529
except socket.error, error:
530
if error[0] == errno.EPERM:
531
logger.warning(u"No permission to"
532
u" bind to interface %s",
533
self.settings["interface"])
534
else:
535
raise error
1372
536
# Only bind(2) the socket if we really need to.
1373
537
if self.server_address[0] or self.server_address[1]:
1374
538
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,
539
in6addr_any = "::"
540
self.server_address = (in6addr_any,
1380
541
self.server_address[1])
1381
elif not self.server_address[1]:
542
elif self.server_address[1] is None:
1382
543
self.server_address = (self.server_address[0],
1383
544
0)
1384
# if self.interface:
1385
# self.server_address = (self.server_address[0],
1386
# 0, # port
1387
# 0, # flowinfo
1388
# 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
545
return super(type(self), self).server_bind()
1501
546
1502
547
1503
548
def string_to_delta(interval):
1504
549
"""Parse a string and return a datetime.timedelta
1505
1506
>>> string_to_delta(u'7d')
550
551
>>> string_to_delta('7d')
1507
552
datetime.timedelta(7)
1508
>>> string_to_delta(u'60s')
553
>>> string_to_delta('60s')
1509
554
datetime.timedelta(0, 60)
1510
>>> string_to_delta(u'60m')
555
>>> string_to_delta('60m')
1511
556
datetime.timedelta(0, 3600)
1512
>>> string_to_delta(u'24h')
557
>>> string_to_delta('24h')
1513
558
datetime.timedelta(1)
1514
559
>>> string_to_delta(u'1w')
1515
560
datetime.timedelta(7)
1516
>>> string_to_delta(u'5m 30s')
1517
datetime.timedelta(0, 330)
1518
561
"""
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
562
try:
563
suffix=unicode(interval[-1])
564
value=int(interval[:-1])
565
if suffix == u"d":
566
delta = datetime.timedelta(value)
567
elif suffix == u"s":
568
delta = datetime.timedelta(0, value)
569
elif suffix == u"m":
570
delta = datetime.timedelta(0, 0, 0, 0, value)
571
elif suffix == u"h":
572
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
573
elif suffix == u"w":
574
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
575
else:
576
raise ValueError
577
except (ValueError, IndexError):
578
raise ValueError
579
return delta
580
581
582
def server_state_changed(state):
583
"""Derived from the Avahi example code"""
584
if state == avahi.SERVER_COLLISION:
585
logger.warning(u"Server name collision")
586
service.remove()
587
elif state == avahi.SERVER_RUNNING:
588
service.add()
589
590
591
def entry_group_state_changed(state, error):
592
"""Derived from the Avahi example code"""
593
logger.debug(u"state change: %i", state)
594
595
if state == avahi.ENTRY_GROUP_ESTABLISHED:
596
logger.debug(u"Service established.")
597
elif state == avahi.ENTRY_GROUP_COLLISION:
598
logger.warning(u"Service name collision.")
599
service.rename()
600
elif state == avahi.ENTRY_GROUP_FAILURE:
601
logger.critical(u"Error in group state changed %s",
602
unicode(error))
603
raise AvahiGroupError("State changed: %s", str(error))
1541
604
1542
605
def if_nametoindex(interface):
1543
"""Call the C function if_nametoindex(), or equivalent
1544
1545
Note: This function cannot accept a unicode string."""
606
"""Call the C function if_nametoindex(), or equivalent"""
1546
607
global if_nametoindex
1547
608
try:
1548
if_nametoindex = (ctypes.cdll.LoadLibrary
1549
(ctypes.util.find_library(u"c"))
1550
.if_nametoindex)
609
if "ctypes.util" not in sys.modules:
610
import ctypes.util
611
if_nametoindex = ctypes.cdll.LoadLibrary\
612
(ctypes.util.find_library("c")).if_nametoindex
1551
613
except (OSError, AttributeError):
1552
logger.warning(u"Doing if_nametoindex the hard way")
614
if "struct" not in sys.modules:
615
import struct
616
if "fcntl" not in sys.modules:
617
import fcntl
1553
618
def if_nametoindex(interface):
1554
619
"Get an interface index the hard way, i.e. using fcntl()"
1555
620
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]
621
s = socket.socket()
622
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
623
struct.pack("16s16x", interface))
624
s.close()
625
interface_index = struct.unpack("I", ifreq[16:20])[0]
1562
626
return interface_index
1563
627
return if_nametoindex(interface)
1564
628
1565
629
1566
def daemon(nochdir = False, noclose = False):
630
def daemon(nochdir, noclose):
1567
631
"""See daemon(3). Standard BSD Unix function.
1568
1569
632
This should really exist as os.daemon, but it doesn't (yet)."""
1570
633
if os.fork():
1571
634
sys.exit()
1572
635
os.setsid()
1573
636
if not nochdir:
1574
os.chdir(u"/")
1575
if os.fork():
1576
sys.exit()
637
os.chdir("/")
1577
638
if not noclose:
1578
639
# Close all standard open file descriptors
1579
640
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1580
641
if not stat.S_ISCHR(os.fstat(null).st_mode):
1581
642
raise OSError(errno.ENODEV,
1582
u"%s not a character device"
1583
% os.path.devnull)
643
"/dev/null not a character device")
1584
644
os.dup2(null, sys.stdin.fileno())
1585
645
os.dup2(null, sys.stdout.fileno())
1586
646
os.dup2(null, sys.stderr.fileno())
1589
649
1590
650
1591
651
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]
652
global main_loop_started
653
main_loop_started = False
654
655
parser = OptionParser()
656
parser.add_option("-i", "--interface", type="string",
657
metavar="IF", help="Bind to interface IF")
658
parser.add_option("-a", "--address", type="string",
659
help="Address to listen for requests on")
660
parser.add_option("-p", "--port", type="int",
661
help="Port number to receive requests on")
662
parser.add_option("--check", action="store_true", default=False,
663
help="Run self-test")
664
parser.add_option("--debug", action="store_true", default=False,
665
help="Debug mode; run in foreground and log to"
666
" terminal")
667
parser.add_option("--priority", type="string", help="GnuTLS"
668
" priority string (see GnuTLS documentation)")
669
parser.add_option("--servicename", type="string", metavar="NAME",
670
help="Zeroconf service name")
671
parser.add_option("--configdir", type="string",
672
default="/etc/mandos", metavar="DIR",
673
help="Directory to search for configuration"
674
" files")
675
(options, args) = parser.parse_args()
1622
676
1623
677
if options.check:
1624
678
import doctest
1626
680
sys.exit()
1627
681
1628
682
# 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",
683
server_defaults = { "interface": "",
684
"address": "",
685
"port": "",
686
"debug": "False",
687
"priority":
688
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
689
"servicename": "Mandos",
1638
690
}
1639
691
1640
692
# Parse config file for server-global settings
1641
server_config = configparser.SafeConfigParser(server_defaults)
693
server_config = ConfigParser.SafeConfigParser(server_defaults)
1642
694
del server_defaults
1643
server_config.read(os.path.join(options.configdir,
1644
u"mandos.conf"))
695
server_config.read(os.path.join(options.configdir, "server.conf"))
696
server_section = "server"
1645
697
# 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")
698
server_settings = dict(server_config.items(server_section))
699
# Use getboolean on the boolean config option
700
server_settings["debug"] = server_config.getboolean\
701
(server_section, "debug")
1654
702
del server_config
1655
703
1656
704
# Override the settings from the config file with command line
1657
705
# 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"):
706
for option in ("interface", "address", "port", "debug",
707
"priority", "servicename", "configdir"):
1661
708
value = getattr(options, option)
1662
709
if value is not None:
1663
710
server_settings[option] = value
1664
711
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
712
# Now we have our good server settings in "server_settings"
1670
713
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"]
1677
1678
if not debug:
1679
syslogger.setLevel(logging.WARNING)
1680
console.setLevel(logging.WARNING)
1681
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"]))
1687
1688
714
# 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",
715
client_defaults = { "timeout": "1h",
716
"interval": "5m",
717
"checker": "fping -q -- %%(fqdn)s",
1695
718
}
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))
719
client_config = ConfigParser.SafeConfigParser(client_defaults)
720
client_config.read(os.path.join(server_settings["configdir"],
721
"clients.conf"))
722
723
global service
724
service = AvahiService(name = server_settings["servicename"],
725
type = "_mandos._tcp", );
726
if server_settings["interface"]:
727
service.interface = if_nametoindex(server_settings["interface"])
1750
728
1751
729
global main_loop
730
global bus
731
global server
1752
732
# From the Avahi example code
1753
733
DBusGMainLoop(set_as_default=True )
1754
734
main_loop = gobject.MainLoop()
1755
735
bus = dbus.SystemBus()
736
server = dbus.Interface(
737
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
738
avahi.DBUS_INTERFACE_SERVER )
1756
739
# 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")
740
741
debug = server_settings["debug"]
1799
742
1800
743
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
1808
logger.removeHandler(console)
1809
# Close all input and output, do double fork, etc.
1810
daemon()
1811
1812
try:
1813
with pidfile:
1814
pid = os.getpid()
1815
pidfile.write(str(pid) + "\n")
1816
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
744
console = logging.StreamHandler()
745
# console.setLevel(logging.DEBUG)
746
console.setFormatter(logging.Formatter\
747
('%(levelname)s: %(message)s'))
748
logger.addHandler(console)
749
del console
750
751
clients = Set()
752
def remove_from_clients(client):
753
clients.remove(client)
754
if not clients:
755
logger.debug(u"No clients left, exiting")
756
sys.exit()
757
758
clients.update(Set(Client(name=section,
759
stop_hook = remove_from_clients,
760
**(dict(client_config\
761
.items(section))))
762
for section in client_config.sections()))
763
764
if not debug:
765
daemon(False, False)
766
767
def cleanup():
768
"Cleanup function; run on exit"
769
global group
770
# From the Avahi example code
771
if not group is None:
772
group.Free()
773
group = None
774
# End of Avahi example code
775
776
while clients:
777
client = clients.pop()
778
client.stop_hook = None
779
client.stop()
780
781
atexit.register(cleanup)
1824
782
1825
783
if not debug:
1826
784
signal.signal(signal.SIGINT, signal.SIG_IGN)
1827
785
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1828
786
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1829
787
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
788
for client in clients:
789
client.start()
790
791
tcp_server = IPv6_TCPServer((server_settings["address"],
792
server_settings["port"]),
793
tcp_handler,
794
settings=server_settings,
795
clients=clients)
1912
796
# Find out what port we got
1913
797
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())
798
logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
799
u" scope_id %d" % tcp_server.socket.getsockname())
1921
800
1922
801
#service.interface = tcp_server.socket.getsockname()[3]
1923
802
1924
803
try:
1925
804
# From the Avahi example code
805
server.connect_to_signal("StateChanged", server_state_changed)
1926
806
try:
1927
service.activate()
807
server_state_changed(server.GetState())
1928
808
except dbus.exceptions.DBusException, error:
1929
809
logger.critical(u"DBusException: %s", error)
1930
cleanup()
1931
810
sys.exit(1)
1932
811
# End of Avahi example code
1933
812
1934
813
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1935
814
lambda *args, **kwargs:
1936
(tcp_server.handle_request
1937
(*args[2:], **kwargs) or True))
815
tcp_server.handle_request\
816
(*args[2:], **kwargs) or True)
1938
817
1939
logger.debug(u"Starting main loop")
818
logger.debug("Starting main loop")
819
main_loop_started = True
1940
820
main_loop.run()
1941
821
except AvahiError, error:
1942
logger.critical(u"AvahiError: %s", error)
1943
cleanup()
822
logger.critical(u"AvahiError: %s" + unicode(error))
1944
823
sys.exit(1)
1945
824
except KeyboardInterrupt:
1946
825
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()
826
print
1952
827
1953
828
if __name__ == '__main__':
1954
829
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0