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 34
- compare with another revision
- download diff
- download tarball
- view history from revision 34
- Committer: Teddy Hogeborn
- Date: 2008-08-01 20:03:03 UTC
- Revision ID: teddy@fukt.bsnet.se-20080801200303-3xjn9gjewg87365i
* plugbasedclient.c (main): Check if plugin dir could be opened. Set
FD_CLOEXEC on the directory, if possible,
and also on both ends of the pipe. Do not
allocate buffer for process in advance.
Free the plugin list. Bug fix: exit if no
plugins found, not if any found. Set
"exitstatus" in many places. Simplify and
un-indent the loop reading process pipes.
Renamed process list iterator to "proc".
Bug fix: retry password write on EINTR.
Free the process list properly, including
the process structs themselves.
FD_CLOEXEC on the directory, if possible,
and also on both ends of the pipe. Do not
allocate buffer for process in advance.
Free the plugin list. Bug fix: exit if no
plugins found, not if any found. Set
"exitstatus" in many places. Simplify and
un-indent the loop reading process pipes.
Renamed process list iterator to "proc".
Bug fix: retry password write on EINTR.
Free the process list properly, including
the process structs themselves.
- files added:
- plugbasedclient.c
- plugins.d
- files removed:
- bad-ca.pem
- files renamed:
- mandos-clients.conf => 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
2
33
3
34
import SocketServer
4
35
import socket
9
40
import gnutls.crypto
10
41
import gnutls.connection
11
42
import gnutls.errors
43
import gnutls.library.functions
44
import gnutls.library.constants
45
import gnutls.library.types
12
46
import ConfigParser
47
import sys
48
import re
49
import os
50
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
13
170
14
171
class Client(object):
15
def __init__(self, name=None, dn=None, password=None,
16
passfile=None, fqdn=None, timeout=None,
17
interval=-1):
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.."""
18
229
self.name = name
19
self.dn = dn
20
if password:
21
self.password = password
22
elif passfile:
23
self.password = open(passfile).readall()
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()
24
242
else:
25
print "No Password or Passfile in client config file"
26
# raise RuntimeError XXX
27
self.password = "gazonk"
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
28
245
self.fqdn = fqdn
29
# self.created = ...
30
self.last_seen = None
31
if timeout is None:
32
timeout = self.server.options.timeout
33
self.timeout = timeout
34
if interval == -1:
35
interval = self.server.options.interval
36
self.interval = interval
37
38
def server_bind(self):
39
if self.options.interface:
40
if not hasattr(socket, "SO_BINDTODEVICE"):
41
# From /usr/include/asm-i486/socket.h
42
socket.SO_BINDTODEVICE = 25
246
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
285
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
297
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.
325
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())
334
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))
43
362
try:
44
self.socket.setsockopt(socket.SOL_SOCKET,
45
socket.SO_BINDTODEVICE,
46
self.options.interface)
47
except socket.error, error:
48
if error[0] == errno.EPERM:
49
print "Warning: Denied permission to bind to interface", \
50
self.options.interface
51
else:
52
raise error
53
return super(type(self), self).server_bind()
54
55
56
def init_with_options(self, *args, **kwargs):
57
if "options" in kwargs:
58
self.options = kwargs["options"]
59
del kwargs["options"]
60
if "clients" in kwargs:
61
self.clients = kwargs["clients"]
62
del kwargs["clients"]
63
if "credentials" in kwargs:
64
self.credentials = kwargs["credentials"]
65
del kwargs["credentials"]
66
return super(type(self), self).__init__(*args, **kwargs)
67
68
69
class udp_handler(SocketServer.DatagramRequestHandler, object):
70
def handle(self):
71
self.wfile.write("Polo")
72
print "UDP request answered"
73
74
75
class IPv6_UDPServer(SocketServer.UDPServer, object):
76
__init__ = init_with_options
77
address_family = socket.AF_INET6
78
allow_reuse_address = True
79
server_bind = server_bind
80
def verify_request(self, request, client_address):
81
print "UDP request came"
82
return request[0] == "Marco"
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
83
426
84
427
85
428
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
86
433
def handle(self):
87
print "TCP request came"
88
print "Request:", self.request
89
print "Client Address:", self.client_address
90
print "Server:", self.server
91
session = gnutls.connection.ServerSession(self.request,
92
self.server.credentials)
93
session.handshake()
94
if session.peer_certificate:
95
print "DN:", session.peer_certificate.subject
96
try:
97
session.verify_peer()
98
except gnutls.errors.CertificateError, error:
99
print "Verify failed", error
100
session.bye()
101
return
102
try:
103
session.send(dict((client.dn, client.password)
104
for client in self.server.clients)
105
[session.peer_certificate.subject])
106
except KeyError:
107
session.send("gazonk")
108
# Log maybe? XXX
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
109
490
session.bye()
110
491
492
111
493
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
112
__init__ = init_with_options
494
"""IPv6 TCP server. Accepts 'None' as address and/or port.
495
Attributes:
496
settings: Server settings
497
clients: Set() of Client objects
498
"""
113
499
address_family = socket.AF_INET6
114
allow_reuse_address = True
115
request_queue_size = 1024
116
server_bind = server_bind
117
118
119
in6addr_any = "::"
120
121
cred = None
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
537
538
def string_to_delta(interval):
539
"""Parse a string and return a datetime.timedelta
540
541
>>> string_to_delta('7d')
542
datetime.timedelta(7)
543
>>> string_to_delta('60s')
544
datetime.timedelta(0, 60)
545
>>> string_to_delta('60m')
546
datetime.timedelta(0, 3600)
547
>>> string_to_delta('24h')
548
datetime.timedelta(1)
549
>>> string_to_delta(u'1w')
550
datetime.timedelta(7)
551
"""
552
try:
553
suffix=unicode(interval[-1])
554
value=int(interval[:-1])
555
if suffix == u"d":
556
delta = datetime.timedelta(value)
557
elif suffix == u"s":
558
delta = datetime.timedelta(0, value)
559
elif suffix == u"m":
560
delta = datetime.timedelta(0, 0, 0, 0, value)
561
elif suffix == u"h":
562
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
563
elif suffix == u"w":
564
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
565
else:
566
raise ValueError
567
except (ValueError, IndexError):
568
raise ValueError
569
return delta
570
571
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
122
649
123
650
def main():
651
global main_loop_started
652
main_loop_started = False
653
124
654
parser = OptionParser()
125
655
parser.add_option("-i", "--interface", type="string",
126
default="eth0", metavar="IF",
127
help="Interface to bind to")
128
parser.add_option("--cert", type="string", default="cert.pem",
129
metavar="FILE",
130
help="Public key certificate to use")
131
parser.add_option("--key", type="string", default="key.pem",
132
metavar="FILE",
133
help="Private key to use")
134
parser.add_option("--ca", type="string", default="ca.pem",
135
metavar="FILE",
136
help="Certificate Authority certificate to use")
137
parser.add_option("--crl", type="string", default="crl.pem",
138
metavar="FILE",
139
help="Certificate Revokation List to use")
140
parser.add_option("-p", "--port", type="int", default=49001,
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",
141
660
help="Port number to receive requests on")
142
parser.add_option("--dh", type="int", metavar="BITS",
143
help="DH group to use")
144
parser.add_option("-t", "--timeout", type="string", # Parsed later
145
default="15m",
146
help="Amount of downtime allowed for clients")
661
parser.add_option("--check", action="store_true", default=False,
662
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")
147
674
(options, args) = parser.parse_args()
148
675
149
# Parse the time argument
150
try:
151
suffix=options.timeout[-1]
152
value=int(options.timeout[:-1])
153
if suffix == "d":
154
options.timeout = datetime.timedelta(value)
155
elif suffix == "s":
156
options.timeout = datetime.timedelta(0, value)
157
elif suffix == "m":
158
options.timeout = datetime.timedelta(0, 0, 0, 0, value)
159
elif suffix == "h":
160
options.timeout = datetime.timedelta(0, 0, 0, 0, 0, value)
161
elif suffix == "w":
162
options.timeout = datetime.timedelta(0, 0, 0, 0, 0, 0,
163
value)
164
else:
165
raise ValueError
166
except (ValueError, IndexError):
167
parser.error("option --timeout: Unparseable time")
168
169
cert = gnutls.crypto.X509Certificate(open(options.cert).read())
170
key = gnutls.crypto.X509PrivateKey(open(options.key).read())
171
ca = gnutls.crypto.X509Certificate(open(options.ca).read())
172
crl = gnutls.crypto.X509CRL(open(options.crl).read())
173
cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])
174
175
# Parse config file
176
defaults = {}
177
client_config_object = ConfigParser.SafeConfigParser(defaults)
178
client_config_object.read("mandos-clients.conf")
179
clients = [Client(name=section,
180
**(dict(client_config_object.items(section))))
181
for section in client_config_object.sections()]
182
183
udp_server = IPv6_UDPServer((in6addr_any, options.port),
184
udp_handler,
185
options=options)
186
187
tcp_server = IPv6_TCPServer((in6addr_any, options.port),
676
if options.check:
677
import doctest
678
doctest.testmod()
679
sys.exit()
680
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
787
for client in clients:
788
client.start()
789
790
tcp_server = IPv6_TCPServer((server_settings["address"],
791
server_settings["port"]),
188
792
tcp_handler,
189
options=options,
190
clients=clients,
191
credentials=cred)
192
193
while True:
194
in_, out, err = select.select((udp_server,
195
tcp_server), (), ())
196
for server in in_:
197
server.handle_request()
198
199
200
if __name__ == "__main__":
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__':
201
828
main()
202
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0