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