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 11
- compare with another revision
- download diff
- download tarball
- view history from revision 11
- Committer: Teddy Hogeborn
- Date: 2008-06-30 01:43:39 UTC
- Revision ID: teddy@fukt.bsnet.se-20080630014339-rsuztydpl2w5ml83
* server.py: Rewritten to use Zeroconf (mDNS/DNS-SD) in place of the
old broadcast-UDP-to-port-49001 method.
old broadcast-UDP-to-port-49001 method.
- 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
2
32
3
from __future__ import division
33
4
40
11
import gnutls.crypto
41
12
import gnutls.connection
42
13
import gnutls.errors
43
import gnutls.library.functions
44
import gnutls.library.constants
45
import gnutls.library.types
46
14
import ConfigParser
47
15
import sys
48
16
import re
50
18
import signal
51
19
from sets import Set
52
20
import subprocess
53
import atexit
54
import stat
55
import logging
56
import logging.handlers
57
21
58
22
import dbus
59
23
import gobject
60
24
import avahi
61
25
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
26
27
# This variable is used to optionally bind to a specified
28
# interface.
29
serviceInterface = avahi.IF_UNSPEC
30
# It is a global variable to fit in with the rest of the
31
# variables from the Avahi server example code:
32
serviceName = "Mandos"
33
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
34
servicePort = None # Not known at startup
35
serviceTXT = [] # TXT record for the service
36
domain = "" # Domain to publish on, default to .local
37
host = "" # Host to publish records for, default to localhost
38
group = None #our entry group
39
rename_count = 12 # Counter so we only rename after collisions a
40
# sensible number of times
168
41
# End of Avahi example code
169
42
170
43
171
44
class Client(object):
172
45
"""A representation of a client host served by this server.
173
46
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
47
password: string
48
fqdn: string, FQDN (used by the checker)
49
created: datetime.datetime()
50
last_seen: datetime.datetime() or None if not yet seen
51
timeout: datetime.timedelta(); How long from last_seen until
52
this client is invalid
183
53
interval: datetime.timedelta(); How often to start a new checker
54
timeout_milliseconds: Used by gobject.timeout_add()
55
interval_milliseconds: - '' -
184
56
stop_hook: If set, called by stop() as stop_hook(self)
185
57
checker: subprocess.Popen(); a running checker process used
186
58
to see if the client lives.
187
'None' if no process is running.
59
Is None if no process is running.
188
60
checker_initiator_tag: a gobject event source tag, or None
189
61
stop_initiator_tag: - '' -
190
62
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
63
"""
201
def _set_timeout(self, timeout):
202
"Setter function for 'timeout' attribute"
203
self._timeout = timeout
204
self._timeout_milliseconds = ((self.timeout.days
64
def __init__(self, name=None, options=None, stop_hook=None,
65
dn=None, password=None, passfile=None, fqdn=None,
66
timeout=None, interval=-1):
67
self.name = name
68
self.dn = dn
69
if password:
70
self.password = password
71
elif passfile:
72
self.password = open(passfile).readall()
73
else:
74
raise RuntimeError(u"No Password or Passfile for client %s"
75
% self.name)
76
self.fqdn = fqdn # string
77
self.created = datetime.datetime.now()
78
self.last_seen = None
79
if timeout is None:
80
timeout = options.timeout
81
self.timeout = timeout
82
self.timeout_milliseconds = ((self.timeout.days
83
* 24 * 60 * 60 * 1000)
84
+ (self.timeout.seconds * 1000)
85
+ (self.timeout.microseconds
86
// 1000))
87
if interval == -1:
88
interval = options.interval
89
else:
90
interval = string_to_delta(interval)
91
self.interval = interval
92
self.interval_milliseconds = ((self.interval.days
205
93
* 24 * 60 * 60 * 1000)
206
+ (self.timeout.seconds * 1000)
207
+ (self.timeout.microseconds
94
+ (self.interval.seconds * 1000)
95
+ (self.interval.microseconds
208
96
// 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.."""
229
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()
242
else:
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.fqdn = fqdn
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
97
self.stop_hook = stop_hook
251
98
self.checker = None
252
99
self.checker_initiator_tag = None
253
100
self.stop_initiator_tag = None
254
101
self.checker_callback_tag = None
255
self.check_command = checker
256
102
def start(self):
257
"""Start this client's checker and timeout hooks"""
103
"""Start this clients checker and timeout hooks"""
258
104
# Schedule a new checker to be started an 'interval' from now,
259
105
# and every interval from then on.
260
self.checker_initiator_tag = gobject.timeout_add\
261
(self._interval_milliseconds,
262
self.start_checker)
106
self.checker_initiator_tag = gobject.\
107
timeout_add(self.interval_milliseconds,
108
self.start_checker)
263
109
# Also start a new checker *right now*.
264
110
self.start_checker()
265
111
# Schedule a stop() when 'timeout' has passed
266
self.stop_initiator_tag = gobject.timeout_add\
267
(self._timeout_milliseconds,
268
self.stop)
112
self.stop_initiator_tag = gobject.\
113
timeout_add(self.timeout_milliseconds,
114
self.stop)
269
115
def stop(self):
270
116
"""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):
117
The possibility that this client might be restarted is left
118
open, but not currently used."""
119
# print "Stopping client", self.name
120
self.password = None
121
if self.stop_initiator_tag:
280
122
gobject.source_remove(self.stop_initiator_tag)
281
123
self.stop_initiator_tag = None
282
if getattr(self, "checker_initiator_tag", False):
124
if self.checker_initiator_tag:
283
125
gobject.source_remove(self.checker_initiator_tag)
284
126
self.checker_initiator_tag = None
285
127
self.stop_checker()
288
130
# Do not run this again if called by a gobject.timeout_add
289
131
return False
290
132
def __del__(self):
291
self.stop_hook = None
292
self.stop()
133
# Some code duplication here and in stop()
134
if hasattr(self, "stop_initiator_tag") \
135
and self.stop_initiator_tag:
136
gobject.source_remove(self.stop_initiator_tag)
137
self.stop_initiator_tag = None
138
if hasattr(self, "checker_initiator_tag") \
139
and self.checker_initiator_tag:
140
gobject.source_remove(self.checker_initiator_tag)
141
self.checker_initiator_tag = None
142
self.stop_checker()
293
143
def checker_callback(self, pid, condition):
294
144
"""The checker has completed, so take appropriate actions."""
295
145
now = datetime.datetime.now()
296
self.checker_callback_tag = None
297
self.checker = None
298
146
if os.WIFEXITED(condition) \
299
147
and (os.WEXITSTATUS(condition) == 0):
300
logger.debug(u"Checker for %(name)s succeeded",
301
vars(self))
302
self.last_checked_ok = now
148
#print "Checker for %(name)s succeeded" % vars(self)
149
self.last_seen = now
303
150
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))
151
self.stop_initiator_tag = gobject.\
152
timeout_add(self.timeout_milliseconds,
153
self.stop)
154
#else:
155
# if not os.WIFEXITED(condition):
156
# print "Checker for %(name)s crashed?" % vars(self)
157
# else:
158
# print "Checker for %(name)s failed" % vars(self)
159
self.checker = None
160
self.checker_callback_tag = None
313
161
def start_checker(self):
314
162
"""Start a new checker subprocess if one is not running.
315
163
If a checker already exists, leave it running and do
316
164
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
165
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)
166
#print "Starting checker for", self.name
167
try:
168
self.checker = subprocess.\
169
Popen("sleep 1; fping -q -- %s"
170
% re.escape(self.fqdn),
171
stdout=subprocess.PIPE,
172
close_fds=True, shell=True,
173
cwd="/")
174
self.checker_callback_tag = gobject.\
175
child_watch_add(self.checker.pid,
176
self.\
177
checker_callback)
349
178
except subprocess.OSError, error:
350
logger.error(u"Failed to start subprocess: %s",
351
error)
179
sys.stderr.write(u"Failed to start subprocess: %s\n"
180
% error)
352
181
# Re-run this periodically if run by gobject.timeout_add
353
182
return True
354
183
def stop_checker(self):
355
184
"""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:
185
if not hasattr(self, "checker") or self.checker is None:
360
186
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
187
gobject.source_remove(self.checker_callback_tag)
188
self.checker_callback_tag = None
189
os.kill(self.checker.pid, signal.SIGTERM)
190
if self.checker.poll() is None:
191
os.kill(self.checker.pid, signal.SIGKILL)
370
192
self.checker = None
371
def still_valid(self):
193
def still_valid(self, now=None):
372
194
"""Has the timeout not yet passed for this client?"""
373
now = datetime.datetime.now()
374
if self.last_checked_ok is None:
195
if now is None:
196
now = datetime.datetime.now()
197
if self.last_seen is None:
375
198
return now < (self.created + self.timeout)
376
199
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
200
return now < (self.last_seen + self.timeout)
426
201
427
202
428
203
class tcp_handler(SocketServer.BaseRequestHandler, object):
429
204
"""A TCP request handler class.
430
205
Instantiated by IPv6_TCPServer for each request to handle it.
431
206
Note: This will run in its own forked process."""
432
433
207
def handle(self):
434
logger.debug(u"TCP connection from: %s",
435
unicode(self.client_address))
436
437
line = self.request.makefile().readline()
438
logger.debug(u"Protocol version: %r", line)
439
try:
440
if int(line.strip().split()[0]) > 1:
441
raise RuntimeError
442
except (ValueError, IndexError, RuntimeError), error:
443
logger.error(u"Unknown protocol version: %s", error)
444
return
445
446
session = gnutls.connection.ClientSession\
447
(self.request, gnutls.connection.X509Credentials())
448
# Note: gnutls.connection.X509Credentials is really a generic
449
# GnuTLS certificate credentials object so long as no X.509
450
# keys are added to it. Therefore, we can use it here despite
451
# using OpenPGP certificates.
452
453
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
454
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
455
# "+DHE-DSS"))
456
priority = "NORMAL" # Fallback default, since this
457
# MUST be set.
458
if self.server.settings["priority"]:
459
priority = self.server.settings["priority"]
460
gnutls.library.functions.gnutls_priority_set_direct\
461
(session._c_object, priority, None);
462
208
#print u"TCP request came"
209
#print u"Request:", self.request
210
#print u"Client Address:", self.client_address
211
#print u"Server:", self.server
212
session = gnutls.connection.ServerSession(self.request,
213
self.server\
214
.credentials)
463
215
try:
464
216
session.handshake()
465
217
except gnutls.errors.GNUTLSError, error:
466
logger.debug(u"Handshake failed: %s", error)
218
#sys.stderr.write(u"Handshake failed: %s\n" % error)
467
219
# Do not run session.bye() here: the session is not
468
220
# established. Just abandon the request.
469
221
return
222
#if session.peer_certificate:
223
# print "DN:", session.peer_certificate.subject
470
224
try:
471
fpr = fingerprint(peer_certificate(session))
472
except (TypeError, gnutls.errors.GNUTLSError), error:
473
logger.debug(u"Bad certificate: %s", error)
225
session.verify_peer()
226
except gnutls.errors.CertificateError, error:
227
#sys.stderr.write(u"Verify failed: %s\n" % error)
474
228
session.bye()
475
229
return
476
logger.debug(u"Fingerprint: %s", fpr)
477
230
client = None
478
for c in self.server.clients:
479
if c.fingerprint == fpr:
231
for c in clients:
232
if c.dn == session.peer_certificate.subject:
480
233
client = c
481
234
break
482
if not client:
483
logger.debug(u"Client not found for fingerprint: %s", fpr)
484
session.bye()
485
return
486
235
# Have to check if client.still_valid(), since it is possible
487
236
# that the client timed out while establishing the GnuTLS
488
237
# session.
489
if not client.still_valid():
490
logger.debug(u"Client %(name)s is invalid", vars(client))
491
session.bye()
492
return
493
sent_size = 0
494
while sent_size < len(client.secret):
495
sent = session.send(client.secret[sent_size:])
496
logger.debug(u"Sent: %d, remaining: %d",
497
sent, len(client.secret)
498
- (sent_size + sent))
499
sent_size += sent
238
if client and client.still_valid():
239
session.send(client.password)
240
else:
241
#if client:
242
# sys.stderr.write(u"Client %(name)s is invalid\n"
243
# % vars(client))
244
#else:
245
# sys.stderr.write(u"Client not found for DN: %s\n"
246
# % session.peer_certificate.subject)
247
#session.send("gazonk")
248
pass
500
249
session.bye()
501
250
502
251
503
252
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
504
253
"""IPv6 TCP server. Accepts 'None' as address and/or port.
505
254
Attributes:
506
settings: Server settings
255
options: Command line options
507
256
clients: Set() of Client objects
257
credentials: GnuTLS X.509 credentials
508
258
"""
509
259
address_family = socket.AF_INET6
510
260
def __init__(self, *args, **kwargs):
511
if "settings" in kwargs:
512
self.settings = kwargs["settings"]
513
del kwargs["settings"]
261
if "options" in kwargs:
262
self.options = kwargs["options"]
263
del kwargs["options"]
514
264
if "clients" in kwargs:
515
265
self.clients = kwargs["clients"]
516
266
del kwargs["clients"]
267
if "credentials" in kwargs:
268
self.credentials = kwargs["credentials"]
269
del kwargs["credentials"]
517
270
return super(type(self), self).__init__(*args, **kwargs)
518
271
def server_bind(self):
519
272
"""This overrides the normal server_bind() function
520
273
to bind to an interface if one was specified, and also NOT to
521
274
bind to an address or port if they were not specified."""
522
if self.settings["interface"]:
523
# 25 is from /usr/include/asm-i486/socket.h
524
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
275
if self.options.interface:
276
if not hasattr(socket, "SO_BINDTODEVICE"):
277
# From /usr/include/asm-i486/socket.h
278
socket.SO_BINDTODEVICE = 25
525
279
try:
526
280
self.socket.setsockopt(socket.SOL_SOCKET,
527
SO_BINDTODEVICE,
528
self.settings["interface"])
281
socket.SO_BINDTODEVICE,
282
self.options.interface)
529
283
except socket.error, error:
530
284
if error[0] == errno.EPERM:
531
logger.warning(u"No permission to"
532
u" bind to interface %s",
533
self.settings["interface"])
285
sys.stderr.write(u"Warning: No permission to bind to interface %s\n"
286
% self.options.interface)
534
287
else:
535
288
raise error
536
289
# Only bind(2) the socket if we really need to.
579
332
return delta
580
333
581
334
335
def add_service():
336
"""From the Avahi server example code"""
337
global group, serviceName, serviceType, servicePort, serviceTXT, \
338
domain, host
339
if group is None:
340
group = dbus.Interface(
341
bus.get_object( avahi.DBUS_NAME,
342
server.EntryGroupNew()),
343
avahi.DBUS_INTERFACE_ENTRY_GROUP)
344
group.connect_to_signal('StateChanged',
345
entry_group_state_changed)
346
347
# print "Adding service '%s' of type '%s' ..." % (serviceName,
348
# serviceType)
349
350
group.AddService(
351
serviceInterface, # interface
352
avahi.PROTO_INET6, # protocol
353
dbus.UInt32(0), # flags
354
serviceName, serviceType,
355
domain, host,
356
dbus.UInt16(servicePort),
357
avahi.string_array_to_txt_array(serviceTXT))
358
group.Commit()
359
360
361
def remove_service():
362
"""From the Avahi server example code"""
363
global group
364
365
if not group is None:
366
group.Reset()
367
368
582
369
def server_state_changed(state):
583
"""Derived from the Avahi example code"""
370
"""From the Avahi server example code"""
584
371
if state == avahi.SERVER_COLLISION:
585
logger.warning(u"Server name collision")
586
service.remove()
372
print "WARNING: Server name collision"
373
remove_service()
587
374
elif state == avahi.SERVER_RUNNING:
588
service.add()
375
add_service()
589
376
590
377
591
378
def entry_group_state_changed(state, error):
592
"""Derived from the Avahi example code"""
593
logger.debug(u"state change: %i", state)
379
"""From the Avahi server example code"""
380
global serviceName, server, rename_count
381
382
# print "state change: %i" % state
594
383
595
384
if state == avahi.ENTRY_GROUP_ESTABLISHED:
596
logger.debug(u"Service established.")
385
pass
386
# print "Service established."
597
387
elif state == avahi.ENTRY_GROUP_COLLISION:
598
logger.warning(u"Service name collision.")
599
service.rename()
388
389
rename_count = rename_count - 1
390
if rename_count > 0:
391
name = server.GetAlternativeServiceName(name)
392
print "WARNING: Service name collision, changing name to '%s' ..." % name
393
remove_service()
394
add_service()
395
396
else:
397
print "ERROR: No suitable service name found after %i retries, exiting." % n_rename
398
main_loop.quit()
600
399
elif state == avahi.ENTRY_GROUP_FAILURE:
601
logger.critical(u"Error in group state changed %s",
602
unicode(error))
603
raise AvahiGroupError("State changed: %s", str(error))
400
print "Error in group state changed", error
401
main_loop.quit()
402
return
403
604
404
605
405
def if_nametoindex(interface):
606
"""Call the C function if_nametoindex(), or equivalent"""
607
global if_nametoindex
406
"""Call the C function if_nametoindex()"""
608
407
try:
609
if "ctypes.util" not in sys.modules:
610
import ctypes.util
611
if_nametoindex = ctypes.cdll.LoadLibrary\
612
(ctypes.util.find_library("c")).if_nametoindex
613
except (OSError, AttributeError):
408
if "ctypes" not in sys.modules:
409
import ctypes
410
libc = ctypes.cdll.LoadLibrary("libc.so.6")
411
return libc.if_nametoindex(interface)
412
except (ImportError, OSError, AttributeError):
614
413
if "struct" not in sys.modules:
615
414
import struct
616
415
if "fcntl" not in sys.modules:
617
416
import fcntl
618
def if_nametoindex(interface):
619
"Get an interface index the hard way, i.e. using fcntl()"
620
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
621
s = socket.socket()
622
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
623
struct.pack("16s16x", interface))
624
s.close()
625
interface_index = struct.unpack("I", ifreq[16:20])[0]
626
return interface_index
627
return if_nametoindex(interface)
628
629
630
def daemon(nochdir, noclose):
631
"""See daemon(3). Standard BSD Unix function.
632
This should really exist as os.daemon, but it doesn't (yet)."""
633
if os.fork():
634
sys.exit()
635
os.setsid()
636
if not nochdir:
637
os.chdir("/")
638
if not noclose:
639
# Close all standard open file descriptors
640
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
641
if not stat.S_ISCHR(os.fstat(null).st_mode):
642
raise OSError(errno.ENODEV,
643
"/dev/null not a character device")
644
os.dup2(null, sys.stdin.fileno())
645
os.dup2(null, sys.stdout.fileno())
646
os.dup2(null, sys.stderr.fileno())
647
if null > 2:
648
os.close(null)
649
650
651
def main():
652
global main_loop_started
653
main_loop_started = False
654
417
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
418
s = socket.socket()
419
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
420
struct.pack("16s16x", interface))
421
s.close()
422
interface_index = struct.unpack("I", ifreq[16:20])[0]
423
return interface_index
424
425
426
if __name__ == '__main__':
655
427
parser = OptionParser()
656
428
parser.add_option("-i", "--interface", type="string",
657
metavar="IF", help="Bind to interface IF")
658
parser.add_option("-a", "--address", type="string",
659
help="Address to listen for requests on")
660
parser.add_option("-p", "--port", type="int",
429
default=None, metavar="IF",
430
help="Bind to interface IF")
431
parser.add_option("--cert", type="string", default="cert.pem",
432
metavar="FILE",
433
help="Public key certificate PEM file to use")
434
parser.add_option("--key", type="string", default="key.pem",
435
metavar="FILE",
436
help="Private key PEM file to use")
437
parser.add_option("--ca", type="string", default="ca.pem",
438
metavar="FILE",
439
help="Certificate Authority certificate PEM file to use")
440
parser.add_option("--crl", type="string", default="crl.pem",
441
metavar="FILE",
442
help="Certificate Revokation List PEM file to use")
443
parser.add_option("-p", "--port", type="int", default=None,
661
444
help="Port number to receive requests on")
445
parser.add_option("--timeout", type="string", # Parsed later
446
default="1h",
447
help="Amount of downtime allowed for clients")
448
parser.add_option("--interval", type="string", # Parsed later
449
default="5m",
450
help="How often to check that a client is up")
662
451
parser.add_option("--check", action="store_true", default=False,
663
452
help="Run self-test")
664
parser.add_option("--debug", action="store_true", default=False,
665
help="Debug mode; run in foreground and log to"
666
" terminal")
667
parser.add_option("--priority", type="string", help="GnuTLS"
668
" priority string (see GnuTLS documentation)")
669
parser.add_option("--servicename", type="string", metavar="NAME",
670
help="Zeroconf service name")
671
parser.add_option("--configdir", type="string",
672
default="/etc/mandos", metavar="DIR",
673
help="Directory to search for configuration"
674
" files")
675
453
(options, args) = parser.parse_args()
676
454
677
455
if options.check:
679
457
doctest.testmod()
680
458
sys.exit()
681
459
682
# Default values for config file for server-global settings
683
server_defaults = { "interface": "",
684
"address": "",
685
"port": "",
686
"debug": "False",
687
"priority":
688
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
689
"servicename": "Mandos",
690
}
691
692
# Parse config file for server-global settings
693
server_config = ConfigParser.SafeConfigParser(server_defaults)
694
del server_defaults
695
server_config.read(os.path.join(options.configdir, "server.conf"))
696
server_section = "server"
697
# Convert the SafeConfigParser object to a dict
698
server_settings = dict(server_config.items(server_section))
699
# Use getboolean on the boolean config option
700
server_settings["debug"] = server_config.getboolean\
701
(server_section, "debug")
702
del server_config
703
704
# Override the settings from the config file with command line
705
# options, if set.
706
for option in ("interface", "address", "port", "debug",
707
"priority", "servicename", "configdir"):
708
value = getattr(options, option)
709
if value is not None:
710
server_settings[option] = value
711
del options
712
# Now we have our good server settings in "server_settings"
713
714
# Parse config file with clients
715
client_defaults = { "timeout": "1h",
716
"interval": "5m",
717
"checker": "fping -q -- %%(fqdn)s",
718
}
719
client_config = ConfigParser.SafeConfigParser(client_defaults)
720
client_config.read(os.path.join(server_settings["configdir"],
721
"clients.conf"))
722
723
global service
724
service = AvahiService(name = server_settings["servicename"],
725
type = "_mandos._tcp", );
726
if server_settings["interface"]:
727
service.interface = if_nametoindex(server_settings["interface"])
728
729
global main_loop
730
global bus
731
global server
732
# From the Avahi example code
460
# Parse the time arguments
461
try:
462
options.timeout = string_to_delta(options.timeout)
463
except ValueError:
464
parser.error("option --timeout: Unparseable time")
465
try:
466
options.interval = string_to_delta(options.interval)
467
except ValueError:
468
parser.error("option --interval: Unparseable time")
469
470
cert = gnutls.crypto.X509Certificate(open(options.cert).read())
471
key = gnutls.crypto.X509PrivateKey(open(options.key).read())
472
ca = gnutls.crypto.X509Certificate(open(options.ca).read())
473
crl = gnutls.crypto.X509CRL(open(options.crl).read())
474
cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])
475
476
# Parse config file
477
defaults = {}
478
client_config = ConfigParser.SafeConfigParser(defaults)
479
#client_config.readfp(open("secrets.conf"), "secrets.conf")
480
client_config.read("mandos-clients.conf")
481
482
# From the Avahi server example code
733
483
DBusGMainLoop(set_as_default=True )
734
484
main_loop = gobject.MainLoop()
735
485
bus = dbus.SystemBus()
738
488
avahi.DBUS_INTERFACE_SERVER )
739
489
# End of Avahi example code
740
490
741
debug = server_settings["debug"]
742
743
if debug:
744
console = logging.StreamHandler()
745
# console.setLevel(logging.DEBUG)
746
console.setFormatter(logging.Formatter\
747
('%(levelname)s: %(message)s'))
748
logger.addHandler(console)
749
del console
750
751
491
clients = Set()
752
492
def remove_from_clients(client):
753
493
clients.remove(client)
754
494
if not clients:
755
logger.debug(u"No clients left, exiting")
756
sys.exit()
495
print "No clients left, exiting"
496
main_loop.quit()
757
497
758
clients.update(Set(Client(name=section,
498
clients.update(Set(Client(name=section, options=options,
759
499
stop_hook = remove_from_clients,
760
500
**(dict(client_config\
761
501
.items(section))))
762
502
for section in client_config.sections()))
763
764
if not debug:
765
daemon(False, False)
766
767
def cleanup():
768
"Cleanup function; run on exit"
769
global group
770
# From the Avahi example code
771
if not group is None:
772
group.Free()
773
group = None
774
# End of Avahi example code
775
776
while clients:
777
client = clients.pop()
778
client.stop_hook = None
779
client.stop()
780
781
atexit.register(cleanup)
782
783
if not debug:
784
signal.signal(signal.SIGINT, signal.SIG_IGN)
785
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
786
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
787
788
503
for client in clients:
789
504
client.start()
790
505
791
tcp_server = IPv6_TCPServer((server_settings["address"],
792
server_settings["port"]),
506
tcp_server = IPv6_TCPServer((None, options.port),
793
507
tcp_handler,
794
settings=server_settings,
795
clients=clients)
796
# Find out what port we got
797
service.port = tcp_server.socket.getsockname()[1]
798
logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
799
u" scope_id %d" % tcp_server.socket.getsockname())
800
801
#service.interface = tcp_server.socket.getsockname()[3]
802
508
options=options,
509
clients=clients,
510
credentials=cred)
511
# Find out what random port we got
512
servicePort = tcp_server.socket.getsockname()[1]
513
#sys.stderr.write("Now listening on port %d\n" % servicePort)
514
515
if options.interface is not None:
516
serviceInterface = if_nametoindex(options.interface)
517
518
# From the Avahi server example code
519
server.connect_to_signal("StateChanged", server_state_changed)
520
server_state_changed(server.GetState())
521
# End of Avahi example code
522
523
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
524
lambda *args, **kwargs:
525
tcp_server.handle_request(*args[2:],
526
**kwargs) or True)
803
527
try:
804
# From the Avahi example code
805
server.connect_to_signal("StateChanged", server_state_changed)
806
try:
807
server_state_changed(server.GetState())
808
except dbus.exceptions.DBusException, error:
809
logger.critical(u"DBusException: %s", error)
810
sys.exit(1)
811
# End of Avahi example code
812
813
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
814
lambda *args, **kwargs:
815
tcp_server.handle_request\
816
(*args[2:], **kwargs) or True)
817
818
logger.debug("Starting main loop")
819
main_loop_started = True
820
528
main_loop.run()
821
except AvahiError, error:
822
logger.critical(u"AvahiError: %s" + unicode(error))
823
sys.exit(1)
824
529
except KeyboardInterrupt:
825
if debug:
826
print
530
print
531
532
# Cleanup here
827
533
828
if __name__ == '__main__':
829
main()
534
# From the Avahi server example code
535
if not group is None:
536
group.Free()
537
# End of Avahi example code
538
539
for client in clients:
540
client.stop_hook = None
541
client.stop()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0