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 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: Teddy Hogeborn
- Date: 2008-01-30 17:28:18 UTC
- Revision ID: teddy@fukt.bsnet.se-20080130172818-fnrq2xmtg1wa8wo2
* client.cpp (main): Get t_old early since it is used on error exits.
* server.py (Client.checker): New attribute.
(Client.check_action, Client.start_checker, Client.stop_checker,
Client.fileno, Client.next_stop, Client.still_valid,
Client.it_is_time_to_check): New methods.
(Client.handle_request): Alias to "check_action".
(main): Stop all started checkers on exit. Exit cleanly on keyboard
interrupt.
* server.py (Client.checker): New attribute.
(Client.check_action, Client.start_checker, Client.stop_checker,
Client.fileno, Client.next_stop, Client.still_valid,
Client.it_is_time_to_check): New methods.
(Client.handle_request): Alias to "check_action".
(main): Stop all started checkers on exit. Exit cleanly on keyboard
interrupt.
- files added:
- client.cpp
- files removed:
- plugbasedclient.c
- plugins.d
- files renamed:
- clients.conf => mandos-clients.conf
- files modified:
- Makefile
added
removed
server.py
1
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos server - give out binary blobs to connecting clients.
5
#
6
# This program is partly derived from an example program for an Avahi
7
# service publisher, downloaded from
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# following functions: "AvahiService.add", "AvahiService.remove",
10
# "server_state_changed", "entry_group_state_changed", and some lines
11
# in "main".
12
#
13
# Everything else is
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
15
#
16
# This program is free software: you can redistribute it and/or modify
17
# it under the terms of the GNU General Public License as published by
18
# the Free Software Foundation, either version 3 of the License, or
19
# (at your option) any later version.
20
#
21
# This program is distributed in the hope that it will be useful,
22
# but WITHOUT ANY WARRANTY; without even the implied warranty of
23
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24
# GNU General Public License for more details.
25
#
26
# You should have received a copy of the GNU General Public License
27
# along with this program. If not, see <http://www.gnu.org/licenses/>.
28
#
29
# Contact the authors at <mandos@fukt.bsnet.se>.
30
#
31
32
from __future__ import division
33
2
34
3
import SocketServer
35
4
import socket
40
9
import gnutls.crypto
41
10
import gnutls.connection
42
11
import gnutls.errors
43
import gnutls.library.functions
44
import gnutls.library.constants
45
import gnutls.library.types
46
12
import ConfigParser
47
13
import sys
48
14
import re
49
15
import os
50
16
import signal
51
from sets import Set
52
import subprocess
53
import atexit
54
import stat
55
import logging
56
import logging.handlers
57
58
import dbus
59
import gobject
60
import avahi
61
from dbus.mainloop.glib import DBusGMainLoop
62
import ctypes
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'))
81
logger.addHandler(syslogger)
82
del syslogger
83
84
85
class AvahiError(Exception):
86
def __init__(self, value):
87
self.value = value
88
def __str__(self):
89
return repr(self.value)
90
91
class AvahiServiceError(AvahiError):
92
pass
93
94
class AvahiGroupError(AvahiError):
95
pass
96
97
98
class AvahiService(object):
99
"""
100
interface: integer; avahi.IF_UNSPEC or an interface index.
101
Used to optionally bind to the specified interface.
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
113
"""
114
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
type = None, port = None, TXT = None, domain = "",
116
host = "", max_renames = 12):
117
"""An Avahi (Zeroconf) service. """
118
self.interface = interface
119
self.name = name
120
self.type = type
121
self.port = port
122
if TXT is None:
123
self.TXT = []
124
else:
125
self.TXT = TXT
126
self.domain = domain
127
self.host = host
128
self.rename_count = 0
129
def rename(self):
130
"""Derived from the Avahi example code"""
131
if self.rename_count >= self.max_renames:
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)
137
self.remove()
138
self.add()
139
self.rename_count += 1
140
def remove(self):
141
"""Derived from the Avahi example code"""
142
if group is not None:
143
group.Reset()
144
def add(self):
145
"""Derived from the Avahi example code"""
146
global group
147
if group is None:
148
group = dbus.Interface\
149
(bus.get_object(avahi.DBUS_NAME,
150
server.EntryGroupNew()),
151
avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
group.connect_to_signal('StateChanged',
153
entry_group_state_changed)
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
169
170
17
171
18
class Client(object):
172
"""A representation of a client host served by this server.
173
Attributes:
174
name: string; from the config file, used in log messages
175
fingerprint: string (40 or 32 hexadecimal digits); used to
176
uniquely identify the client
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.
188
checker_initiator_tag: a gobject event source tag, or None
189
stop_initiator_tag: - '' -
190
checker_callback_tag: - '' -
191
checker_command: string; External command which is run to check if
192
client lives. %() expansions are done at
193
runtime with vars(self) as dict, so that for
194
instance %(name)s can be used in the command.
195
Private attibutes:
196
_timeout: Real variable for 'timeout'
197
_interval: Real variable for 'interval'
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
199
_interval_milliseconds: - '' -
200
"""
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.."""
19
def __init__(self, name=None, options=None, dn=None,
20
password=None, passfile=None, fqdn=None,
21
timeout=None, interval=-1):
229
22
self.name = name
230
logger.debug(u"Creating client %r", self.name)
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"")
235
logger.debug(u" Fingerprint: %s", self.fingerprint)
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()
23
self.dn = dn
24
if password:
25
self.password = password
26
elif passfile:
27
self.password = open(passfile).readall()
242
28
else:
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.fqdn = fqdn
29
print "No Password or Passfile in client config file"
30
# raise RuntimeError XXX
31
self.password = "gazonk"
32
self.fqdn = fqdn # string
246
33
self.created = datetime.datetime.now()
247
self.last_checked_ok = None
248
self.timeout = string_to_delta(timeout)
249
self.interval = string_to_delta(interval)
250
self.stop_hook = stop_hook
251
self.checker = None
252
self.checker_initiator_tag = None
253
self.stop_initiator_tag = None
254
self.checker_callback_tag = None
255
self.check_command = checker
256
def start(self):
257
"""Start this client's checker and timeout hooks"""
258
# Schedule a new checker to be started an 'interval' from now,
259
# and every interval from then on.
260
self.checker_initiator_tag = gobject.timeout_add\
261
(self._interval_milliseconds,
262
self.start_checker)
263
# Also start a new checker *right now*.
264
self.start_checker()
265
# Schedule a stop() when 'timeout' has passed
266
self.stop_initiator_tag = gobject.timeout_add\
267
(self._timeout_milliseconds,
268
self.stop)
269
def stop(self):
270
"""Stop this client.
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
273
# If this client doesn't have a secret, it is already stopped.
274
if self.secret:
275
logger.debug(u"Stopping client %s", self.name)
276
self.secret = None
277
else:
278
return False
279
if getattr(self, "stop_initiator_tag", False):
280
gobject.source_remove(self.stop_initiator_tag)
281
self.stop_initiator_tag = None
282
if getattr(self, "checker_initiator_tag", False):
283
gobject.source_remove(self.checker_initiator_tag)
284
self.checker_initiator_tag = None
34
self.last_seen = None # datetime.datetime()
35
if timeout is None:
36
timeout = options.timeout
37
self.timeout = timeout # datetime.timedelta()
38
if interval == -1:
39
interval = options.interval
40
self.interval = interval # datetime.timedelta()
41
self.next_check = datetime.datetime.now() # datetime.datetime()
42
self.checker = None # or a subprocess.Popen()
43
def check_action(self, now=None):
44
"""The checker said something and might have completed.
45
Check if is has, and take appropriate actions."""
46
if self.checker.poll() is None:
47
# False alarm, no result yet
48
#self.checker.read()
49
return
50
if now is None:
51
now = datetime.datetime.now()
52
if self.checker.returncode == 0:
53
self.last_seen = now
54
while self.next_check <= now:
55
self.next_check += self.interval
56
handle_request = check_action
57
def start_checker(self):
285
58
self.stop_checker()
286
if self.stop_hook:
287
self.stop_hook(self)
288
# Do not run this again if called by a gobject.timeout_add
289
return False
290
def __del__(self):
291
self.stop_hook = None
292
self.stop()
293
def checker_callback(self, pid, condition):
294
"""The checker has completed, so take appropriate actions."""
295
now = datetime.datetime.now()
296
self.checker_callback_tag = None
59
try:
60
self.checker = subprocess.Popen("sleep 1; fping -q -- %s"
61
% re.escape(self.fqdn),
62
stdout=subprocess.PIPE,
63
close_fds=True,
64
shell=True, cwd="/")
65
except subprocess.OSError, e:
66
print "Failed to start subprocess:", e
67
def stop_checker(self):
68
if self.checker is None:
69
return
70
os.kill(self.checker.pid, signal.SIGTERM)
71
if self.checker.poll() is None:
72
os.kill(self.checker.pid, signal.SIGKILL)
297
73
self.checker = None
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):
308
logger.warning(u"Checker for %(name)s crashed?",
309
vars(self))
310
else:
311
logger.debug(u"Checker for %(name)s failed",
312
vars(self))
313
def start_checker(self):
314
"""Start a new checker subprocess if one is not running.
315
If a checker already exists, leave it running and do
316
nothing."""
317
# The reason for not killing a running checker is that if we
318
# did that, then if a checker (for some reason) started
319
# running slowly and taking more than 'interval' time, the
320
# client would inevitably timeout, since no checker would get
321
# a chance to run to completion. If we instead leave running
322
# checkers alone, the checker would have to take more time
323
# than 'timeout' for the client to be declared invalid, which
324
# is as it should be.
74
__del__ = stop_checker
75
def fileno(self):
325
76
if self.checker is None:
326
try:
327
# In case check_command has exactly one % operator
328
command = self.check_command % self.fqdn
329
except TypeError:
330
# Escape attributes for the shell
331
escaped_attrs = dict((key, re.escape(str(val)))
332
for key, val in
333
vars(self).iteritems())
77
return None
78
return self.checker.stdout.fileno()
79
def next_stop(self):
80
"""The time when something must be done about this client"""
81
return min(self.last_seen + self.timeout, self.next_check)
82
def still_valid(self, now=None):
83
"""Has this client's timeout not passed?"""
84
if now is None:
85
now = datetime.datetime.now()
86
return now < (self.last_seen + timeout)
87
def it_is_time_to_check(self, now=None):
88
if now is None:
89
now = datetime.datetime.now()
90
return self.next_check <= now
91
92
93
class server_metaclass(type):
94
"Common behavior for the UDP and TCP server classes"
95
def __new__(cls, name, bases, attrs):
96
attrs["address_family"] = socket.AF_INET6
97
attrs["allow_reuse_address"] = True
98
def server_bind(self):
99
if self.options.interface:
100
if not hasattr(socket, "SO_BINDTODEVICE"):
101
# From /usr/include/asm-i486/socket.h
102
socket.SO_BINDTODEVICE = 25
334
103
try:
335
command = self.check_command % escaped_attrs
336
except TypeError, error:
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
339
return True # Try again later
340
try:
341
logger.debug(u"Starting checker %r for %s",
342
command, self.name)
343
self.checker = subprocess.Popen(command,
344
close_fds=True,
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:
350
logger.error(u"Failed to start subprocess: %s",
351
error)
352
# Re-run this periodically if run by gobject.timeout_add
353
return True
354
def stop_checker(self):
355
"""Force the checker process, if any, to stop."""
356
if self.checker_callback_tag:
357
gobject.source_remove(self.checker_callback_tag)
358
self.checker_callback_tag = None
359
if getattr(self, "checker", None) is None:
360
return
361
logger.debug("Stopping checker for %(name)s", vars(self))
362
try:
363
os.kill(self.checker.pid, signal.SIGTERM)
364
#os.sleep(0.5)
365
#if self.checker.poll() is None:
366
# os.kill(self.checker.pid, signal.SIGKILL)
367
except OSError, error:
368
if error.errno != errno.ESRCH: # No such process
369
raise
370
self.checker = None
371
def still_valid(self):
372
"""Has the timeout not yet passed for this client?"""
373
now = datetime.datetime.now()
374
if self.last_checked_ok is None:
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
104
self.socket.setsockopt(socket.SOL_SOCKET,
105
socket.SO_BINDTODEVICE,
106
self.options.interface)
107
except socket.error, error:
108
if error[0] == errno.EPERM:
109
print "Warning: No permission to bind to interface", \
110
self.options.interface
111
else:
112
raise error
113
return super(type(self), self).server_bind()
114
attrs["server_bind"] = server_bind
115
def init(self, *args, **kwargs):
116
if "options" in kwargs:
117
self.options = kwargs["options"]
118
del kwargs["options"]
119
if "clients" in kwargs:
120
self.clients = kwargs["clients"]
121
del kwargs["clients"]
122
if "credentials" in kwargs:
123
self.credentials = kwargs["credentials"]
124
del kwargs["credentials"]
125
return super(type(self), self).__init__(*args, **kwargs)
126
attrs["__init__"] = init
127
return type.__new__(cls, name, bases, attrs)
128
129
130
class udp_handler(SocketServer.DatagramRequestHandler, object):
131
def handle(self):
132
self.wfile.write("Polo")
133
print "UDP request answered"
134
135
136
class IPv6_UDPServer(SocketServer.UDPServer, object):
137
__metaclass__ = server_metaclass
138
def verify_request(self, request, client_address):
139
print "UDP request came"
140
return request[0] == "Marco"
426
141
427
142
428
143
class tcp_handler(SocketServer.BaseRequestHandler, object):
429
"""A TCP request handler class.
430
Instantiated by IPv6_TCPServer for each request to handle it.
431
Note: This will run in its own forked process."""
432
433
144
def handle(self):
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
# Note: gnutls.connection.X509Credentials is really a generic
439
# GnuTLS certificate credentials object so long as no X.509
440
# keys are added to it. Therefore, we can use it here despite
441
# using OpenPGP certificates.
442
443
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
444
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
445
# "+DHE-DSS"))
446
priority = "NORMAL" # Fallback default, since this
447
# MUST be set.
448
if self.server.settings["priority"]:
449
priority = self.server.settings["priority"]
450
gnutls.library.functions.gnutls_priority_set_direct\
451
(session._c_object, priority, None);
452
453
try:
454
session.handshake()
455
except gnutls.errors.GNUTLSError, error:
456
logger.debug(u"Handshake failed: %s", error)
457
# Do not run session.bye() here: the session is not
458
# established. Just abandon the request.
459
return
460
try:
461
fpr = fingerprint(peer_certificate(session))
462
except (TypeError, gnutls.errors.GNUTLSError), error:
463
logger.debug(u"Bad certificate: %s", error)
464
session.bye()
465
return
466
logger.debug(u"Fingerprint: %s", fpr)
467
client = None
468
for c in self.server.clients:
469
if c.fingerprint == fpr:
470
client = c
471
break
472
if not client:
473
logger.debug(u"Client not found for fingerprint: %s", fpr)
474
session.bye()
475
return
476
# Have to check if client.still_valid(), since it is possible
477
# that the client timed out while establishing the GnuTLS
478
# session.
479
if not client.still_valid():
480
logger.debug(u"Client %(name)s is invalid", vars(client))
481
session.bye()
482
return
483
sent_size = 0
484
while sent_size < len(client.secret):
485
sent = session.send(client.secret[sent_size:])
486
logger.debug(u"Sent: %d, remaining: %d",
487
sent, len(client.secret)
488
- (sent_size + sent))
489
sent_size += sent
145
print "TCP request came"
146
print "Request:", self.request
147
print "Client Address:", self.client_address
148
print "Server:", self.server
149
session = gnutls.connection.ServerSession(self.request,
150
self.server.credentials)
151
session.handshake()
152
if session.peer_certificate:
153
print "DN:", session.peer_certificate.subject
154
try:
155
session.verify_peer()
156
except gnutls.errors.CertificateError, error:
157
print "Verify failed", error
158
session.bye()
159
return
160
try:
161
session.send(dict((client.dn, client.password)
162
for client in self.server.clients)
163
[session.peer_certificate.subject])
164
except KeyError:
165
session.send("gazonk")
166
# Log maybe? XXX
490
167
session.bye()
491
168
492
169
493
170
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
494
"""IPv6 TCP server. Accepts 'None' as address and/or port.
495
Attributes:
496
settings: Server settings
497
clients: Set() of Client objects
498
"""
499
address_family = socket.AF_INET6
500
def __init__(self, *args, **kwargs):
501
if "settings" in kwargs:
502
self.settings = kwargs["settings"]
503
del kwargs["settings"]
504
if "clients" in kwargs:
505
self.clients = kwargs["clients"]
506
del kwargs["clients"]
507
return super(type(self), self).__init__(*args, **kwargs)
508
def server_bind(self):
509
"""This overrides the normal server_bind() function
510
to bind to an interface if one was specified, and also NOT to
511
bind to an address or port if they were not specified."""
512
if self.settings["interface"]:
513
# 25 is from /usr/include/asm-i486/socket.h
514
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
515
try:
516
self.socket.setsockopt(socket.SOL_SOCKET,
517
SO_BINDTODEVICE,
518
self.settings["interface"])
519
except socket.error, error:
520
if error[0] == errno.EPERM:
521
logger.warning(u"No permission to"
522
u" bind to interface %s",
523
self.settings["interface"])
524
else:
525
raise error
526
# Only bind(2) the socket if we really need to.
527
if self.server_address[0] or self.server_address[1]:
528
if not self.server_address[0]:
529
in6addr_any = "::"
530
self.server_address = (in6addr_any,
531
self.server_address[1])
532
elif self.server_address[1] is None:
533
self.server_address = (self.server_address[0],
534
0)
535
return super(type(self), self).server_bind()
536
171
__metaclass__ = server_metaclass
172
request_queue_size = 1024
173
174
175
in6addr_any = "::"
537
176
538
177
def string_to_delta(interval):
539
178
"""Parse a string and return a datetime.timedelta
569
208
return delta
570
209
571
210
572
def server_state_changed(state):
573
"""Derived from the Avahi example code"""
574
if state == avahi.SERVER_COLLISION:
575
logger.warning(u"Server name collision")
576
service.remove()
577
elif state == avahi.SERVER_RUNNING:
578
service.add()
579
580
581
def entry_group_state_changed(state, error):
582
"""Derived from the Avahi example code"""
583
logger.debug(u"state change: %i", state)
584
585
if state == avahi.ENTRY_GROUP_ESTABLISHED:
586
logger.debug(u"Service established.")
587
elif state == avahi.ENTRY_GROUP_COLLISION:
588
logger.warning(u"Service name collision.")
589
service.rename()
590
elif state == avahi.ENTRY_GROUP_FAILURE:
591
logger.critical(u"Error in group state changed %s",
592
unicode(error))
593
raise AvahiGroupError("State changed: %s", str(error))
594
595
def if_nametoindex(interface, _func=[None]):
596
"""Call the C function if_nametoindex(), or equivalent"""
597
if _func[0] is not None:
598
return _func[0](interface)
599
try:
600
if "ctypes.util" not in sys.modules:
601
import ctypes.util
602
while True:
603
try:
604
libc = ctypes.cdll.LoadLibrary\
605
(ctypes.util.find_library("c"))
606
_func[0] = libc.if_nametoindex
607
return _func[0](interface)
608
except IOError, e:
609
if e != errno.EINTR:
610
raise
611
except (OSError, AttributeError):
612
if "struct" not in sys.modules:
613
import struct
614
if "fcntl" not in sys.modules:
615
import fcntl
616
def the_hard_way(interface):
617
"Get an interface index the hard way, i.e. using fcntl()"
618
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
619
s = socket.socket()
620
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
621
struct.pack("16s16x", interface))
622
s.close()
623
interface_index = struct.unpack("I", ifreq[16:20])[0]
624
return interface_index
625
_func[0] = the_hard_way
626
return _func[0](interface)
627
628
629
def daemon(nochdir, noclose):
630
"""See daemon(3). Standard BSD Unix function.
631
This should really exist as os.daemon, but it doesn't (yet)."""
632
if os.fork():
633
sys.exit()
634
os.setsid()
635
if not nochdir:
636
os.chdir("/")
637
if not noclose:
638
# Close all standard open file descriptors
639
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
640
if not stat.S_ISCHR(os.fstat(null).st_mode):
641
raise OSError(errno.ENODEV,
642
"/dev/null not a character device")
643
os.dup2(null, sys.stdin.fileno())
644
os.dup2(null, sys.stdout.fileno())
645
os.dup2(null, sys.stderr.fileno())
646
if null > 2:
647
os.close(null)
648
649
650
211
def main():
651
global main_loop_started
652
main_loop_started = False
653
654
212
parser = OptionParser()
655
213
parser.add_option("-i", "--interface", type="string",
656
metavar="IF", help="Bind to interface IF")
657
parser.add_option("-a", "--address", type="string",
658
help="Address to listen for requests on")
659
parser.add_option("-p", "--port", type="int",
214
default="eth0", metavar="IF",
215
help="Interface to bind to")
216
parser.add_option("--cert", type="string", default="cert.pem",
217
metavar="FILE",
218
help="Public key certificate to use")
219
parser.add_option("--key", type="string", default="key.pem",
220
metavar="FILE",
221
help="Private key to use")
222
parser.add_option("--ca", type="string", default="ca.pem",
223
metavar="FILE",
224
help="Certificate Authority certificate to use")
225
parser.add_option("--crl", type="string", default="crl.pem",
226
metavar="FILE",
227
help="Certificate Revokation List to use")
228
parser.add_option("-p", "--port", type="int", default=49001,
660
229
help="Port number to receive requests on")
230
parser.add_option("--dh", type="int", metavar="BITS",
231
help="DH group to use")
232
parser.add_option("-t", "--timeout", type="string", # Parsed later
233
default="15m",
234
help="Amount of downtime allowed for clients")
235
parser.add_option("--interval", type="string", # Parsed later
236
default="5m",
237
help="How often to check that a client is up")
661
238
parser.add_option("--check", action="store_true", default=False,
662
239
help="Run self-test")
663
parser.add_option("--debug", action="store_true", default=False,
664
help="Debug mode; run in foreground and log to"
665
" terminal")
666
parser.add_option("--priority", type="string", help="GnuTLS"
667
" priority string (see GnuTLS documentation)")
668
parser.add_option("--servicename", type="string", metavar="NAME",
669
help="Zeroconf service name")
670
parser.add_option("--configdir", type="string",
671
default="/etc/mandos", metavar="DIR",
672
help="Directory to search for configuration"
673
" files")
674
240
(options, args) = parser.parse_args()
675
241
676
242
if options.check:
677
243
import doctest
678
244
doctest.testmod()
679
245
sys.exit()
680
246
681
# Default values for config file for server-global settings
682
server_defaults = { "interface": "",
683
"address": "",
684
"port": "",
685
"debug": "False",
686
"priority":
687
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
688
"servicename": "Mandos",
689
}
690
691
# Parse config file for server-global settings
692
server_config = ConfigParser.SafeConfigParser(server_defaults)
693
del server_defaults
694
server_config.read(os.path.join(options.configdir, "server.conf"))
695
server_section = "server"
696
# Convert the SafeConfigParser object to a dict
697
server_settings = dict(server_config.items(server_section))
698
# Use getboolean on the boolean config option
699
server_settings["debug"] = server_config.getboolean\
700
(server_section, "debug")
701
del server_config
702
703
# Override the settings from the config file with command line
704
# options, if set.
705
for option in ("interface", "address", "port", "debug",
706
"priority", "servicename", "configdir"):
707
value = getattr(options, option)
708
if value is not None:
709
server_settings[option] = value
710
del options
711
# Now we have our good server settings in "server_settings"
712
713
# Parse config file with clients
714
client_defaults = { "timeout": "1h",
715
"interval": "5m",
716
"checker": "fping -q -- %%(fqdn)s",
717
}
718
client_config = ConfigParser.SafeConfigParser(client_defaults)
719
client_config.read(os.path.join(server_settings["configdir"],
720
"clients.conf"))
721
722
global service
723
service = AvahiService(name = server_settings["servicename"],
724
type = "_mandos._tcp", );
725
if server_settings["interface"]:
726
service.interface = if_nametoindex(server_settings["interface"])
727
728
global main_loop
729
global bus
730
global server
731
# From the Avahi example code
732
DBusGMainLoop(set_as_default=True )
733
main_loop = gobject.MainLoop()
734
bus = dbus.SystemBus()
735
server = dbus.Interface(
736
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
737
avahi.DBUS_INTERFACE_SERVER )
738
# End of Avahi example code
739
740
debug = server_settings["debug"]
741
742
if debug:
743
console = logging.StreamHandler()
744
# console.setLevel(logging.DEBUG)
745
console.setFormatter(logging.Formatter\
746
('%(levelname)s: %(message)s'))
747
logger.addHandler(console)
748
del console
749
750
clients = Set()
751
def remove_from_clients(client):
752
clients.remove(client)
753
if not clients:
754
logger.debug(u"No clients left, exiting")
755
sys.exit()
756
757
clients.update(Set(Client(name=section,
758
stop_hook = remove_from_clients,
759
**(dict(client_config\
760
.items(section))))
761
for section in client_config.sections()))
762
763
if not debug:
764
daemon(False, False)
765
766
def cleanup():
767
"Cleanup function; run on exit"
768
global group
769
# From the Avahi example code
770
if not group is None:
771
group.Free()
772
group = None
773
# End of Avahi example code
774
775
while clients:
776
client = clients.pop()
777
client.stop_hook = None
778
client.stop()
779
780
atexit.register(cleanup)
781
782
if not debug:
783
signal.signal(signal.SIGINT, signal.SIG_IGN)
784
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
785
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
786
247
# Parse the time arguments
248
try:
249
options.timeout = string_to_delta(options.timeout)
250
except ValueError:
251
parser.error("option --timeout: Unparseable time")
252
253
try:
254
options.interval = string_to_delta(options.interval)
255
except ValueError:
256
parser.error("option --interval: Unparseable time")
257
258
cert = gnutls.crypto.X509Certificate(open(options.cert).read())
259
key = gnutls.crypto.X509PrivateKey(open(options.key).read())
260
ca = gnutls.crypto.X509Certificate(open(options.ca).read())
261
crl = gnutls.crypto.X509CRL(open(options.crl).read())
262
cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])
263
264
# Parse config file
265
defaults = {}
266
client_config_object = ConfigParser.SafeConfigParser(defaults)
267
client_config_object.read("mandos-clients.conf")
268
clients = [Client(name=section, options=options,
269
**(dict(client_config_object.items(section))))
270
for section in client_config_object.sections()]
271
272
udp_server = IPv6_UDPServer((in6addr_any, options.port),
273
udp_handler,
274
options=options)
275
276
tcp_server = IPv6_TCPServer((in6addr_any, options.port),
277
tcp_handler,
278
options=options,
279
clients=clients,
280
credentials=cred)
281
282
while True:
283
try:
284
input, out, err = select.select((udp_server,
285
tcp_server), (), ())
286
if not input:
287
pass
288
else:
289
for obj in input:
290
obj.handle_request()
291
except KeyboardInterrupt:
292
break
293
294
# Cleanup here
787
295
for client in clients:
788
client.start()
789
790
tcp_server = IPv6_TCPServer((server_settings["address"],
791
server_settings["port"]),
792
tcp_handler,
793
settings=server_settings,
794
clients=clients)
795
# Find out what port we got
796
service.port = tcp_server.socket.getsockname()[1]
797
logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
798
u" scope_id %d" % tcp_server.socket.getsockname())
799
800
#service.interface = tcp_server.socket.getsockname()[3]
801
802
try:
803
# From the Avahi example code
804
server.connect_to_signal("StateChanged", server_state_changed)
805
try:
806
server_state_changed(server.GetState())
807
except dbus.exceptions.DBusException, error:
808
logger.critical(u"DBusException: %s", error)
809
sys.exit(1)
810
# End of Avahi example code
811
812
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
813
lambda *args, **kwargs:
814
tcp_server.handle_request\
815
(*args[2:], **kwargs) or True)
816
817
logger.debug("Starting main loop")
818
main_loop_started = True
819
main_loop.run()
820
except AvahiError, error:
821
logger.critical(u"AvahiError: %s" + unicode(error))
822
sys.exit(1)
823
except KeyboardInterrupt:
824
if debug:
825
print
826
827
if __name__ == '__main__':
296
client.stop_checker()
297
298
299
if __name__ == "__main__":
828
300
main()
301
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0