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 13
- compare with another revision
- download diff
- download tarball
- view history from revision 13
- Committer: Björn Påhlsson
- Date: 2008-07-20 02:52:20 UTC
- Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
Avahi instead of udp server discovery
openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server
Pluginbased client handler
rewritten Mandos client
Avahi instead of udp server discovery
openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/mandos-client.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
server.py
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
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
12
#
13
# Everything else is
14
# Copyright © 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
28
# <http://www.gnu.org/licenses/>.
29
#
30
# Contact the authors at <mandos@fukt.bsnet.se>.
31
#
32
2
33
3
from __future__ import division
34
4
35
5
import SocketServer
36
6
import socket
7
import select
37
8
from optparse import OptionParser
38
9
import datetime
39
10
import errno
50
21
import signal
51
22
from sets import Set
52
23
import subprocess
53
import atexit
54
import stat
55
import logging
56
import logging.handlers
57
import pwd
58
24
59
25
import dbus
60
26
import gobject
61
27
import avahi
62
28
from dbus.mainloop.glib import DBusGMainLoop
63
29
import ctypes
64
import ctypes.util
65
66
version = "1.0"
30
31
import logging
32
import logging.handlers
33
34
# logghandler.setFormatter(logging.Formatter('%(levelname)s %(message)s')
67
35
68
36
logger = logging.Logger('mandos')
69
syslogger = logging.handlers.SysLogHandler\
70
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
71
address = "/dev/log")
72
syslogger.setFormatter(logging.Formatter\
73
('Mandos: %(levelname)s: %(message)s'))
74
logger.addHandler(syslogger)
75
76
console = logging.StreamHandler()
77
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
78
' %(message)s'))
79
logger.addHandler(console)
80
81
class AvahiError(Exception):
82
def __init__(self, value):
83
self.value = value
84
super(AvahiError, self).__init__()
85
def __str__(self):
86
return repr(self.value)
87
88
class AvahiServiceError(AvahiError):
89
pass
90
91
class AvahiGroupError(AvahiError):
92
pass
93
94
95
class AvahiService(object):
96
"""An Avahi (Zeroconf) service.
97
Attributes:
98
interface: integer; avahi.IF_UNSPEC or an interface index.
99
Used to optionally bind to the specified interface.
100
name: string; Example: 'Mandos'
101
type: string; Example: '_mandos._tcp'.
102
See <http://www.dns-sd.org/ServiceTypes.html>
103
port: integer; what port to announce
104
TXT: list of strings; TXT record for the service
105
domain: string; Domain to publish on, default to .local if empty.
106
host: string; Host to publish records for, default is localhost
107
max_renames: integer; maximum number of renames
108
rename_count: integer; counter so we only rename after collisions
109
a sensible number of times
110
"""
111
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
112
servicetype = None, port = None, TXT = None, domain = "",
113
host = "", max_renames = 32768):
114
self.interface = interface
115
self.name = name
116
self.type = servicetype
117
self.port = port
118
if TXT is None:
119
self.TXT = []
120
else:
121
self.TXT = TXT
122
self.domain = domain
123
self.host = host
124
self.rename_count = 0
125
self.max_renames = max_renames
126
def rename(self):
127
"""Derived from the Avahi example code"""
128
if self.rename_count >= self.max_renames:
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
131
self.rename_count)
132
raise AvahiServiceError("Too many renames")
133
self.name = server.GetAlternativeServiceName(self.name)
134
logger.info(u"Changing Zeroconf service name to %r ...",
135
str(self.name))
136
syslogger.setFormatter(logging.Formatter\
137
('Mandos (%s): %%(levelname)s:'
138
' %%(message)s' % self.name))
139
self.remove()
140
self.add()
141
self.rename_count += 1
142
def remove(self):
143
"""Derived from the Avahi example code"""
144
if group is not None:
145
group.Reset()
146
def add(self):
147
"""Derived from the Avahi example code"""
148
global group
149
if group is None:
150
group = dbus.Interface\
151
(bus.get_object(avahi.DBUS_NAME,
152
server.EntryGroupNew()),
153
avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
group.connect_to_signal('StateChanged',
155
entry_group_state_changed)
156
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
157
service.name, service.type)
158
group.AddService(
159
self.interface, # interface
160
avahi.PROTO_INET6, # protocol
161
dbus.UInt32(0), # flags
162
self.name, self.type,
163
self.domain, self.host,
164
dbus.UInt16(self.port),
165
avahi.string_array_to_txt_array(self.TXT))
166
group.Commit()
167
168
# From the Avahi example code:
169
group = None # our entry group
37
logger.addHandler(logging.handlers.SysLogHandler(facility = logging.handlers.SysLogHandler.LOG_DAEMON))
38
39
# This variable is used to optionally bind to a specified interface.
40
# It is a global variable to fit in with the other variables from the
41
# Avahi server example code.
42
serviceInterface = avahi.IF_UNSPEC
43
# From the Avahi server example code:
44
serviceName = "Mandos"
45
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
46
servicePort = None # Not known at startup
47
serviceTXT = [] # TXT record for the service
48
domain = "" # Domain to publish on, default to .local
49
host = "" # Host to publish records for, default to localhost
50
group = None #our entry group
51
rename_count = 12 # Counter so we only rename after collisions a
52
# sensible number of times
170
53
# End of Avahi example code
171
54
172
55
177
60
fingerprint: string (40 or 32 hexadecimal digits); used to
178
61
uniquely identify the client
179
62
secret: bytestring; sent verbatim (over TLS) to client
180
host: string; available for use by the checker command
181
created: datetime.datetime(); object creation, not client host
182
last_checked_ok: datetime.datetime() or None if not yet checked OK
183
timeout: datetime.timedelta(); How long from last_checked_ok
184
until this client is invalid
63
fqdn: string (FQDN); available for use by the checker command
64
created: datetime.datetime()
65
last_seen: datetime.datetime() or None if not yet seen
66
timeout: datetime.timedelta(); How long from last_seen until
67
this client is invalid
185
68
interval: datetime.timedelta(); How often to start a new checker
186
69
stop_hook: If set, called by stop() as stop_hook(self)
187
70
checker: subprocess.Popen(); a running checker process used
188
71
to see if the client lives.
189
'None' if no process is running.
72
Is None if no process is running.
190
73
checker_initiator_tag: a gobject event source tag, or None
191
74
stop_initiator_tag: - '' -
192
75
checker_callback_tag: - '' -
193
76
checker_command: string; External command which is run to check if
194
client lives. %() expansions are done at
77
client lives. %()s expansions are done at
195
78
runtime with vars(self) as dict, so that for
196
79
instance %(name)s can be used in the command.
197
80
Private attibutes:
198
81
_timeout: Real variable for 'timeout'
199
82
_interval: Real variable for 'interval'
200
_timeout_milliseconds: Used when calling gobject.timeout_add()
83
_timeout_milliseconds: Used by gobject.timeout_add()
201
84
_interval_milliseconds: - '' -
202
85
"""
203
86
def _set_timeout(self, timeout):
223
106
interval = property(lambda self: self._interval,
224
107
_set_interval)
225
108
del _set_interval
226
def __init__(self, name = None, stop_hook=None, config=None):
227
"""Note: the 'checker' key in 'config' sets the
228
'checker_command' attribute and *not* the 'checker'
229
attribute."""
230
if config is None:
231
config = {}
109
def __init__(self, name=None, options=None, stop_hook=None,
110
fingerprint=None, secret=None, secfile=None, fqdn=None,
111
timeout=None, interval=-1, checker=None):
232
112
self.name = name
233
logger.debug(u"Creating client %r", self.name)
234
# Uppercase and remove spaces from fingerprint for later
235
# comparison purposes with return value from the fingerprint()
236
# function
237
self.fingerprint = config["fingerprint"].upper()\
238
.replace(u" ", u"")
239
logger.debug(u" Fingerprint: %s", self.fingerprint)
240
if "secret" in config:
241
self.secret = config["secret"].decode(u"base64")
242
elif "secfile" in config:
243
secfile = open(config["secfile"])
244
self.secret = secfile.read()
245
secfile.close()
113
# Uppercase and remove spaces from fingerprint
114
# for later comparison purposes with return value of
115
# the fingerprint() function
116
self.fingerprint = fingerprint.upper().replace(u" ", u"")
117
if secret:
118
self.secret = secret.decode(u"base64")
119
elif secfile:
120
sf = open(secfile)
121
self.secret = sf.read()
122
sf.close()
246
123
else:
247
raise TypeError(u"No secret or secfile for client %s"
248
% self.name)
249
self.host = config.get("host", "")
124
raise RuntimeError(u"No secret or secfile for client %s"
125
% self.name)
126
self.fqdn = fqdn # string
250
127
self.created = datetime.datetime.now()
251
self.last_checked_ok = None
252
self.timeout = string_to_delta(config["timeout"])
253
self.interval = string_to_delta(config["interval"])
128
self.last_seen = None
129
if timeout is None:
130
timeout = options.timeout
131
self.timeout = timeout
132
if interval == -1:
133
interval = options.interval
134
else:
135
interval = string_to_delta(interval)
136
self.interval = interval
254
137
self.stop_hook = stop_hook
255
138
self.checker = None
256
139
self.checker_initiator_tag = None
257
140
self.stop_initiator_tag = None
258
141
self.checker_callback_tag = None
259
self.check_command = config["checker"]
142
self.check_command = checker
260
143
def start(self):
261
"""Start this client's checker and timeout hooks"""
144
"""Start this clients checker and timeout hooks"""
262
145
# Schedule a new checker to be started an 'interval' from now,
263
146
# and every interval from then on.
264
147
self.checker_initiator_tag = gobject.timeout_add\
272
155
self.stop)
273
156
def stop(self):
274
157
"""Stop this client.
275
The possibility that a client might be restarted is left open,
276
but not currently used."""
277
# If this client doesn't have a secret, it is already stopped.
278
if hasattr(self, "secret") and self.secret:
279
logger.info(u"Stopping client %s", self.name)
280
self.secret = None
281
else:
282
return False
283
if getattr(self, "stop_initiator_tag", False):
158
The possibility that this client might be restarted is left
159
open, but not currently used."""
160
logger.debug(u"Stopping client %s", self.name)
161
self.secret = None
162
if self.stop_initiator_tag:
284
163
gobject.source_remove(self.stop_initiator_tag)
285
164
self.stop_initiator_tag = None
286
if getattr(self, "checker_initiator_tag", False):
165
if self.checker_initiator_tag:
287
166
gobject.source_remove(self.checker_initiator_tag)
288
167
self.checker_initiator_tag = None
289
168
self.stop_checker()
292
171
# Do not run this again if called by a gobject.timeout_add
293
172
return False
294
173
def __del__(self):
295
self.stop_hook = None
296
self.stop()
174
# Some code duplication here and in stop()
175
if hasattr(self, "stop_initiator_tag") \
176
and self.stop_initiator_tag:
177
gobject.source_remove(self.stop_initiator_tag)
178
self.stop_initiator_tag = None
179
if hasattr(self, "checker_initiator_tag") \
180
and self.checker_initiator_tag:
181
gobject.source_remove(self.checker_initiator_tag)
182
self.checker_initiator_tag = None
183
self.stop_checker()
297
184
def checker_callback(self, pid, condition):
298
185
"""The checker has completed, so take appropriate actions."""
299
186
now = datetime.datetime.now()
300
self.checker_callback_tag = None
301
self.checker = None
302
187
if os.WIFEXITED(condition) \
303
188
and (os.WEXITSTATUS(condition) == 0):
304
logger.info(u"Checker for %(name)s succeeded",
305
vars(self))
306
self.last_checked_ok = now
189
logger.debug(u"Checker for %(name)s succeeded",
190
vars(self))
191
self.last_seen = now
307
192
gobject.source_remove(self.stop_initiator_tag)
308
193
self.stop_initiator_tag = gobject.timeout_add\
309
194
(self._timeout_milliseconds,
310
195
self.stop)
311
elif not os.WIFEXITED(condition):
196
if not os.WIFEXITED(condition):
312
197
logger.warning(u"Checker for %(name)s crashed?",
313
198
vars(self))
314
199
else:
315
logger.info(u"Checker for %(name)s failed",
316
vars(self))
200
logger.debug(u"Checker for %(name)s failed",
201
vars(self))
202
self.checker = None
203
self.checker_callback_tag = None
317
204
def start_checker(self):
318
205
"""Start a new checker subprocess if one is not running.
319
206
If a checker already exists, leave it running and do
320
207
nothing."""
321
# The reason for not killing a running checker is that if we
322
# did that, then if a checker (for some reason) started
323
# running slowly and taking more than 'interval' time, the
324
# client would inevitably timeout, since no checker would get
325
# a chance to run to completion. If we instead leave running
326
# checkers alone, the checker would have to take more time
327
# than 'timeout' for the client to be declared invalid, which
328
# is as it should be.
329
208
if self.checker is None:
209
logger.debug(u"Starting checker for %s",
210
self.name)
330
211
try:
331
# In case check_command has exactly one % operator
332
command = self.check_command % self.host
212
command = self.check_command % self.fqdn
333
213
except TypeError:
334
# Escape attributes for the shell
335
214
escaped_attrs = dict((key, re.escape(str(val)))
336
215
for key, val in
337
216
vars(self).iteritems())
338
217
try:
339
218
command = self.check_command % escaped_attrs
340
219
except TypeError, error:
341
logger.error(u'Could not format string "%s":'
342
u' %s', self.check_command, error)
220
logger.critical(u'Could not format string "%s": %s',
221
self.check_command, error)
343
222
return True # Try again later
344
223
try:
345
logger.info(u"Starting checker %r for %s",
346
command, self.name)
347
# We don't need to redirect stdout and stderr, since
348
# in normal mode, that is already done by daemon(),
349
# and in debug mode we don't want to. (Stdin is
350
# always replaced by /dev/null.)
351
self.checker = subprocess.Popen(command,
352
close_fds=True,
353
shell=True, cwd="/")
354
self.checker_callback_tag = gobject.child_watch_add\
355
(self.checker.pid,
356
self.checker_callback)
357
except OSError, error:
224
self.checker = subprocess.\
225
Popen(command,
226
stdout=subprocess.PIPE,
227
close_fds=True, shell=True,
228
cwd="/")
229
self.checker_callback_tag = gobject.\
230
child_watch_add(self.checker.pid,
231
self.\
232
checker_callback)
233
except subprocess.OSError, error:
358
234
logger.error(u"Failed to start subprocess: %s",
359
235
error)
360
236
# Re-run this periodically if run by gobject.timeout_add
361
237
return True
362
238
def stop_checker(self):
363
239
"""Force the checker process, if any, to stop."""
364
if self.checker_callback_tag:
365
gobject.source_remove(self.checker_callback_tag)
366
self.checker_callback_tag = None
367
if getattr(self, "checker", None) is None:
240
if not hasattr(self, "checker") or self.checker is None:
368
241
return
369
logger.debug(u"Stopping checker for %(name)s", vars(self))
370
try:
371
os.kill(self.checker.pid, signal.SIGTERM)
372
#os.sleep(0.5)
373
#if self.checker.poll() is None:
374
# os.kill(self.checker.pid, signal.SIGKILL)
375
except OSError, error:
376
if error.errno != errno.ESRCH: # No such process
377
raise
242
gobject.source_remove(self.checker_callback_tag)
243
self.checker_callback_tag = None
244
os.kill(self.checker.pid, signal.SIGTERM)
245
if self.checker.poll() is None:
246
os.kill(self.checker.pid, signal.SIGKILL)
378
247
self.checker = None
379
def still_valid(self):
248
def still_valid(self, now=None):
380
249
"""Has the timeout not yet passed for this client?"""
381
now = datetime.datetime.now()
382
if self.last_checked_ok is None:
250
if now is None:
251
now = datetime.datetime.now()
252
if self.last_seen is None:
383
253
return now < (self.created + self.timeout)
384
254
else:
385
return now < (self.last_checked_ok + self.timeout)
255
return now < (self.last_seen + self.timeout)
386
256
387
257
388
258
def peer_certificate(session):
389
"Return the peer's OpenPGP certificate as a bytestring"
390
259
# If not an OpenPGP certificate...
391
260
if gnutls.library.functions.gnutls_certificate_type_get\
392
261
(session._c_object) \
403
272
404
273
405
274
def fingerprint(openpgp):
406
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
275
# New empty GnuTLS certificate
276
crt = gnutls.library.types.gnutls_openpgp_crt_t()
277
gnutls.library.functions.gnutls_openpgp_crt_init\
278
(ctypes.byref(crt))
407
279
# New GnuTLS "datum" with the OpenPGP public key
408
280
datum = gnutls.library.types.gnutls_datum_t\
409
281
(ctypes.cast(ctypes.c_char_p(openpgp),
410
282
ctypes.POINTER(ctypes.c_ubyte)),
411
283
ctypes.c_uint(len(openpgp)))
412
# New empty GnuTLS certificate
413
crt = gnutls.library.types.gnutls_openpgp_crt_t()
414
gnutls.library.functions.gnutls_openpgp_crt_init\
415
(ctypes.byref(crt))
416
284
# Import the OpenPGP public key into the certificate
417
gnutls.library.functions.gnutls_openpgp_crt_import\
418
(crt, ctypes.byref(datum),
419
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
420
# Verify the self signature in the key
421
crtverify = ctypes.c_uint()
422
gnutls.library.functions.gnutls_openpgp_crt_verify_self\
423
(crt, 0, ctypes.byref(crtverify))
424
if crtverify.value != 0:
425
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
426
raise gnutls.errors.CertificateSecurityError("Verify failed")
285
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
286
(crt,
287
ctypes.byref(datum),
288
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
427
289
# New buffer for the fingerprint
428
buf = ctypes.create_string_buffer(20)
429
buf_len = ctypes.c_size_t()
290
buffer = ctypes.create_string_buffer(20)
291
buffer_length = ctypes.c_size_t()
430
292
# Get the fingerprint from the certificate into the buffer
431
293
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
432
(crt, ctypes.byref(buf), ctypes.byref(buf_len))
294
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
433
295
# Deinit the certificate
434
296
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
435
297
# Convert the buffer to a Python bytestring
436
fpr = ctypes.string_at(buf, buf_len.value)
298
fpr = ctypes.string_at(buffer, buffer_length.value)
437
299
# Convert the bytestring to hexadecimal notation
438
300
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
439
301
return hex_fpr
440
302
441
303
442
class TCP_handler(SocketServer.BaseRequestHandler, object):
304
class tcp_handler(SocketServer.BaseRequestHandler, object):
443
305
"""A TCP request handler class.
444
306
Instantiated by IPv6_TCPServer for each request to handle it.
445
307
Note: This will run in its own forked process."""
446
308
447
309
def handle(self):
448
logger.info(u"TCP connection from: %s",
310
logger.debug(u"TCP connection from: %s",
449
311
unicode(self.client_address))
450
session = gnutls.connection.ClientSession\
451
(self.request, gnutls.connection.X509Credentials())
452
453
line = self.request.makefile().readline()
454
logger.debug(u"Protocol version: %r", line)
455
try:
456
if int(line.strip().split()[0]) > 1:
457
raise RuntimeError
458
except (ValueError, IndexError, RuntimeError), error:
459
logger.error(u"Unknown protocol version: %s", error)
460
return
461
462
# Note: gnutls.connection.X509Credentials is really a generic
463
# GnuTLS certificate credentials object so long as no X.509
464
# keys are added to it. Therefore, we can use it here despite
465
# using OpenPGP certificates.
312
session = gnutls.connection.ClientSession(self.request,
313
gnutls.connection.\
314
X509Credentials())
466
315
467
316
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
468
317
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
469
318
# "+DHE-DSS"))
470
priority = "NORMAL" # Fallback default, since this
471
# MUST be set.
472
if self.server.settings["priority"]:
473
priority = self.server.settings["priority"]
319
priority = "SECURE256"
320
474
321
gnutls.library.functions.gnutls_priority_set_direct\
475
(session._c_object, priority, None)
322
(session._c_object, priority, None);
476
323
477
324
try:
478
325
session.handshake()
479
326
except gnutls.errors.GNUTLSError, error:
480
logger.warning(u"Handshake failed: %s", error)
327
logger.debug(u"Handshake failed: %s", error)
481
328
# Do not run session.bye() here: the session is not
482
329
# established. Just abandon the request.
483
330
return
484
331
try:
485
332
fpr = fingerprint(peer_certificate(session))
486
333
except (TypeError, gnutls.errors.GNUTLSError), error:
487
logger.warning(u"Bad certificate: %s", error)
334
logger.debug(u"Bad certificate: %s", error)
488
335
session.bye()
489
336
return
490
337
logger.debug(u"Fingerprint: %s", fpr)
491
338
client = None
492
for c in self.server.clients:
339
for c in clients:
493
340
if c.fingerprint == fpr:
494
341
client = c
495
342
break
496
if not client:
497
logger.warning(u"Client not found for fingerprint: %s",
498
fpr)
499
session.bye()
500
return
501
343
# Have to check if client.still_valid(), since it is possible
502
344
# that the client timed out while establishing the GnuTLS
503
345
# session.
504
if not client.still_valid():
505
logger.warning(u"Client %(name)s is invalid",
506
vars(client))
346
if (not client) or (not client.still_valid()):
347
if client:
348
logger.debug(u"Client %(name)s is invalid",
349
vars(client))
350
else:
351
logger.debug(u"Client not found for fingerprint: %s",
352
fpr)
507
353
session.bye()
508
354
return
509
355
sent_size = 0
519
365
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
520
366
"""IPv6 TCP server. Accepts 'None' as address and/or port.
521
367
Attributes:
522
settings: Server settings
368
options: Command line options
523
369
clients: Set() of Client objects
524
enabled: Boolean; whether this server is activated yet
525
370
"""
526
371
address_family = socket.AF_INET6
527
372
def __init__(self, *args, **kwargs):
528
if "settings" in kwargs:
529
self.settings = kwargs["settings"]
530
del kwargs["settings"]
373
if "options" in kwargs:
374
self.options = kwargs["options"]
375
del kwargs["options"]
531
376
if "clients" in kwargs:
532
377
self.clients = kwargs["clients"]
533
378
del kwargs["clients"]
534
self.enabled = False
535
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
379
return super(type(self), self).__init__(*args, **kwargs)
536
380
def server_bind(self):
537
381
"""This overrides the normal server_bind() function
538
382
to bind to an interface if one was specified, and also NOT to
539
383
bind to an address or port if they were not specified."""
540
if self.settings["interface"]:
541
# 25 is from /usr/include/asm-i486/socket.h
542
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
384
if self.options.interface:
385
if not hasattr(socket, "SO_BINDTODEVICE"):
386
# From /usr/include/asm-i486/socket.h
387
socket.SO_BINDTODEVICE = 25
543
388
try:
544
389
self.socket.setsockopt(socket.SOL_SOCKET,
545
SO_BINDTODEVICE,
546
self.settings["interface"])
390
socket.SO_BINDTODEVICE,
391
self.options.interface)
547
392
except socket.error, error:
548
393
if error[0] == errno.EPERM:
549
logger.error(u"No permission to"
550
u" bind to interface %s",
551
self.settings["interface"])
394
logger.warning(u"No permission to"
395
u" bind to interface %s",
396
self.options.interface)
552
397
else:
553
398
raise error
554
399
# Only bind(2) the socket if we really need to.
557
402
in6addr_any = "::"
558
403
self.server_address = (in6addr_any,
559
404
self.server_address[1])
560
elif not self.server_address[1]:
405
elif self.server_address[1] is None:
561
406
self.server_address = (self.server_address[0],
562
407
0)
563
# if self.settings["interface"]:
564
# self.server_address = (self.server_address[0],
565
# 0, # port
566
# 0, # flowinfo
567
# if_nametoindex
568
# (self.settings
569
# ["interface"]))
570
return super(IPv6_TCPServer, self).server_bind()
571
def server_activate(self):
572
if self.enabled:
573
return super(IPv6_TCPServer, self).server_activate()
574
def enable(self):
575
self.enabled = True
408
return super(type(self), self).server_bind()
576
409
577
410
578
411
def string_to_delta(interval):
588
421
datetime.timedelta(1)
589
422
>>> string_to_delta(u'1w')
590
423
datetime.timedelta(7)
591
>>> string_to_delta('5m 30s')
592
datetime.timedelta(0, 330)
593
424
"""
594
timevalue = datetime.timedelta(0)
595
for s in interval.split():
596
try:
597
suffix = unicode(s[-1])
598
value = int(s[:-1])
599
if suffix == u"d":
600
delta = datetime.timedelta(value)
601
elif suffix == u"s":
602
delta = datetime.timedelta(0, value)
603
elif suffix == u"m":
604
delta = datetime.timedelta(0, 0, 0, 0, value)
605
elif suffix == u"h":
606
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
607
elif suffix == u"w":
608
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
609
else:
610
raise ValueError
611
except (ValueError, IndexError):
425
try:
426
suffix=unicode(interval[-1])
427
value=int(interval[:-1])
428
if suffix == u"d":
429
delta = datetime.timedelta(value)
430
elif suffix == u"s":
431
delta = datetime.timedelta(0, value)
432
elif suffix == u"m":
433
delta = datetime.timedelta(0, 0, 0, 0, value)
434
elif suffix == u"h":
435
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
436
elif suffix == u"w":
437
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
438
else:
612
439
raise ValueError
613
timevalue += delta
614
return timevalue
440
except (ValueError, IndexError):
441
raise ValueError
442
return delta
443
444
445
def add_service():
446
"""From the Avahi server example code"""
447
global group, serviceName, serviceType, servicePort, serviceTXT, \
448
domain, host
449
if group is None:
450
group = dbus.Interface(
451
bus.get_object( avahi.DBUS_NAME,
452
server.EntryGroupNew()),
453
avahi.DBUS_INTERFACE_ENTRY_GROUP)
454
group.connect_to_signal('StateChanged',
455
entry_group_state_changed)
456
logger.debug(u"Adding service '%s' of type '%s' ...",
457
serviceName, serviceType)
458
459
group.AddService(
460
serviceInterface, # interface
461
avahi.PROTO_INET6, # protocol
462
dbus.UInt32(0), # flags
463
serviceName, serviceType,
464
domain, host,
465
dbus.UInt16(servicePort),
466
avahi.string_array_to_txt_array(serviceTXT))
467
group.Commit()
468
469
470
def remove_service():
471
"""From the Avahi server example code"""
472
global group
473
474
if not group is None:
475
group.Reset()
615
476
616
477
617
478
def server_state_changed(state):
618
"""Derived from the Avahi example code"""
479
"""From the Avahi server example code"""
619
480
if state == avahi.SERVER_COLLISION:
620
logger.error(u"Zeroconf server name collision")
621
service.remove()
481
logger.warning(u"Server name collision")
482
remove_service()
622
483
elif state == avahi.SERVER_RUNNING:
623
service.add()
484
add_service()
624
485
625
486
626
487
def entry_group_state_changed(state, error):
627
"""Derived from the Avahi example code"""
628
logger.debug(u"Avahi state change: %i", state)
488
"""From the Avahi server example code"""
489
global serviceName, server, rename_count
490
491
logger.debug(u"state change: %i", state)
629
492
630
493
if state == avahi.ENTRY_GROUP_ESTABLISHED:
631
logger.debug(u"Zeroconf service established.")
494
logger.debug(u"Service established.")
632
495
elif state == avahi.ENTRY_GROUP_COLLISION:
633
logger.warning(u"Zeroconf service name collision.")
634
service.rename()
496
497
rename_count = rename_count - 1
498
if rename_count > 0:
499
name = server.GetAlternativeServiceName(name)
500
logger.warning(u"Service name collision, "
501
u"changing name to '%s' ...", name)
502
remove_service()
503
add_service()
504
505
else:
506
logger.error(u"No suitable service name found "
507
u"after %i retries, exiting.",
508
n_rename)
509
main_loop.quit()
635
510
elif state == avahi.ENTRY_GROUP_FAILURE:
636
logger.critical(u"Avahi: Error in group state changed %s",
637
unicode(error))
638
raise AvahiGroupError("State changed: %s", str(error))
511
logger.error(u"Error in group state changed %s",
512
unicode(error))
513
main_loop.quit()
514
return
515
639
516
640
517
def if_nametoindex(interface):
641
"""Call the C function if_nametoindex(), or equivalent"""
642
global if_nametoindex
518
"""Call the C function if_nametoindex()"""
643
519
try:
644
if_nametoindex = ctypes.cdll.LoadLibrary\
645
(ctypes.util.find_library("c")).if_nametoindex
520
libc = ctypes.cdll.LoadLibrary("libc.so.6")
521
return libc.if_nametoindex(interface)
646
522
except (OSError, AttributeError):
647
523
if "struct" not in sys.modules:
648
524
import struct
649
525
if "fcntl" not in sys.modules:
650
526
import fcntl
651
def if_nametoindex(interface):
652
"Get an interface index the hard way, i.e. using fcntl()"
653
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
654
s = socket.socket()
655
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
656
struct.pack("16s16x", interface))
657
s.close()
658
interface_index = struct.unpack("I", ifreq[16:20])[0]
659
return interface_index
660
return if_nametoindex(interface)
661
662
663
def daemon(nochdir = False, noclose = False):
664
"""See daemon(3). Standard BSD Unix function.
665
This should really exist as os.daemon, but it doesn't (yet)."""
666
if os.fork():
667
sys.exit()
668
os.setsid()
669
if not nochdir:
670
os.chdir("/")
671
if os.fork():
672
sys.exit()
673
if not noclose:
674
# Close all standard open file descriptors
675
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
676
if not stat.S_ISCHR(os.fstat(null).st_mode):
677
raise OSError(errno.ENODEV,
678
"/dev/null not a character device")
679
os.dup2(null, sys.stdin.fileno())
680
os.dup2(null, sys.stdout.fileno())
681
os.dup2(null, sys.stderr.fileno())
682
if null > 2:
683
os.close(null)
684
685
686
def main():
687
parser = OptionParser(version = "%%prog %s" % version)
527
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
528
s = socket.socket()
529
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
530
struct.pack("16s16x", interface))
531
s.close()
532
interface_index = struct.unpack("I", ifreq[16:20])[0]
533
return interface_index
534
535
536
if __name__ == '__main__':
537
parser = OptionParser()
688
538
parser.add_option("-i", "--interface", type="string",
689
metavar="IF", help="Bind to interface IF")
690
parser.add_option("-a", "--address", type="string",
691
help="Address to listen for requests on")
692
parser.add_option("-p", "--port", type="int",
539
default=None, metavar="IF",
540
help="Bind to interface IF")
541
parser.add_option("--cert", type="string", default="cert.pem",
542
metavar="FILE",
543
help="Public key certificate PEM file to use")
544
parser.add_option("--key", type="string", default="key.pem",
545
metavar="FILE",
546
help="Private key PEM file to use")
547
parser.add_option("--ca", type="string", default="ca.pem",
548
metavar="FILE",
549
help="Certificate Authority certificate PEM file to use")
550
parser.add_option("--crl", type="string", default="crl.pem",
551
metavar="FILE",
552
help="Certificate Revokation List PEM file to use")
553
parser.add_option("-p", "--port", type="int", default=None,
693
554
help="Port number to receive requests on")
555
parser.add_option("--timeout", type="string", # Parsed later
556
default="1h",
557
help="Amount of downtime allowed for clients")
558
parser.add_option("--interval", type="string", # Parsed later
559
default="5m",
560
help="How often to check that a client is up")
694
561
parser.add_option("--check", action="store_true", default=False,
695
562
help="Run self-test")
696
parser.add_option("--debug", action="store_true",
697
help="Debug mode; run in foreground and log to"
698
" terminal")
699
parser.add_option("--priority", type="string", help="GnuTLS"
700
" priority string (see GnuTLS documentation)")
701
parser.add_option("--servicename", type="string", metavar="NAME",
702
help="Zeroconf service name")
703
parser.add_option("--configdir", type="string",
704
default="/etc/mandos", metavar="DIR",
705
help="Directory to search for configuration"
706
" files")
707
options = parser.parse_args()[0]
563
parser.add_option("--debug", action="store_true", default=False,
564
help="Debug mode")
565
(options, args) = parser.parse_args()
708
566
709
567
if options.check:
710
568
import doctest
711
569
doctest.testmod()
712
570
sys.exit()
713
571
714
# Default values for config file for server-global settings
715
server_defaults = { "interface": "",
716
"address": "",
717
"port": "",
718
"debug": "False",
719
"priority":
720
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
721
"servicename": "Mandos",
722
}
723
724
# Parse config file for server-global settings
725
server_config = ConfigParser.SafeConfigParser(server_defaults)
726
del server_defaults
727
server_config.read(os.path.join(options.configdir, "mandos.conf"))
728
# Convert the SafeConfigParser object to a dict
729
server_settings = server_config.defaults()
730
# Use getboolean on the boolean config option
731
server_settings["debug"] = server_config.getboolean\
732
("DEFAULT", "debug")
733
del server_config
734
735
# Override the settings from the config file with command line
736
# options, if set.
737
for option in ("interface", "address", "port", "debug",
738
"priority", "servicename", "configdir"):
739
value = getattr(options, option)
740
if value is not None:
741
server_settings[option] = value
742
del options
743
# Now we have our good server settings in "server_settings"
744
745
debug = server_settings["debug"]
746
747
if not debug:
748
syslogger.setLevel(logging.WARNING)
749
console.setLevel(logging.WARNING)
750
751
if server_settings["servicename"] != "Mandos":
752
syslogger.setFormatter(logging.Formatter\
753
('Mandos (%s): %%(levelname)s:'
754
' %%(message)s'
755
% server_settings["servicename"]))
756
757
# Parse config file with clients
758
client_defaults = { "timeout": "1h",
759
"interval": "5m",
760
"checker": "fping -q -- %(host)s",
761
"host": "",
762
}
763
client_config = ConfigParser.SafeConfigParser(client_defaults)
764
client_config.read(os.path.join(server_settings["configdir"],
765
"clients.conf"))
766
767
clients = Set()
768
tcp_server = IPv6_TCPServer((server_settings["address"],
769
server_settings["port"]),
770
TCP_handler,
771
settings=server_settings,
772
clients=clients)
773
pidfilename = "/var/run/mandos.pid"
774
try:
775
pidfile = open(pidfilename, "w")
776
except IOError, error:
777
logger.error("Could not open file %r", pidfilename)
778
779
uid = 65534
780
gid = 65534
781
try:
782
uid = pwd.getpwnam("mandos").pw_uid
783
except KeyError:
784
try:
785
uid = pwd.getpwnam("nobody").pw_uid
786
except KeyError:
787
pass
788
try:
789
gid = pwd.getpwnam("mandos").pw_gid
790
except KeyError:
791
try:
792
gid = pwd.getpwnam("nogroup").pw_gid
793
except KeyError:
794
pass
795
try:
796
os.setuid(uid)
797
os.setgid(gid)
798
except OSError, error:
799
if error[0] != errno.EPERM:
800
raise error
801
802
global service
803
service = AvahiService(name = server_settings["servicename"],
804
servicetype = "_mandos._tcp", )
805
if server_settings["interface"]:
806
service.interface = if_nametoindex\
807
(server_settings["interface"])
808
809
global main_loop
810
global bus
811
global server
812
# From the Avahi example code
572
# Parse the time arguments
573
try:
574
options.timeout = string_to_delta(options.timeout)
575
except ValueError:
576
parser.error("option --timeout: Unparseable time")
577
try:
578
options.interval = string_to_delta(options.interval)
579
except ValueError:
580
parser.error("option --interval: Unparseable time")
581
582
# Parse config file
583
defaults = { "checker": "sleep 1; fping -q -- %%(fqdn)s" }
584
client_config = ConfigParser.SafeConfigParser(defaults)
585
#client_config.readfp(open("secrets.conf"), "secrets.conf")
586
client_config.read("mandos-clients.conf")
587
588
# From the Avahi server example code
813
589
DBusGMainLoop(set_as_default=True )
814
590
main_loop = gobject.MainLoop()
815
591
bus = dbus.SystemBus()
816
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
817
avahi.DBUS_PATH_SERVER),
818
avahi.DBUS_INTERFACE_SERVER)
592
server = dbus.Interface(
593
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
594
avahi.DBUS_INTERFACE_SERVER )
819
595
# End of Avahi example code
820
596
597
debug = options.debug
598
599
clients = Set()
821
600
def remove_from_clients(client):
822
601
clients.remove(client)
823
602
if not clients:
824
logger.critical(u"No clients left, exiting")
825
sys.exit()
603
logger.debug(u"No clients left, exiting")
604
main_loop.quit()
826
605
827
clients.update(Set(Client(name = section,
606
clients.update(Set(Client(name=section, options=options,
828
607
stop_hook = remove_from_clients,
829
config
830
= dict(client_config.items(section)))
608
**(dict(client_config\
609
.items(section))))
831
610
for section in client_config.sections()))
832
if not clients:
833
logger.critical(u"No clients defined")
834
sys.exit(1)
835
836
if debug:
837
# Redirect stdin so all checkers get /dev/null
838
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
839
os.dup2(null, sys.stdin.fileno())
840
if null > 2:
841
os.close(null)
842
else:
843
# No console logging
844
logger.removeHandler(console)
845
# Close all input and output, do double fork, etc.
846
daemon()
847
848
try:
849
pid = os.getpid()
850
pidfile.write(str(pid) + "\n")
851
pidfile.close()
852
del pidfile
853
except IOError:
854
logger.error(u"Could not write to file %r with PID %d",
855
pidfilename, pid)
856
except NameError:
857
# "pidfile" was never created
858
pass
859
del pidfilename
860
861
def cleanup():
862
"Cleanup function; run on exit"
863
global group
864
# From the Avahi example code
865
if not group is None:
866
group.Free()
867
group = None
868
# End of Avahi example code
869
870
while clients:
871
client = clients.pop()
872
client.stop_hook = None
873
client.stop()
874
875
atexit.register(cleanup)
876
877
if not debug:
878
signal.signal(signal.SIGINT, signal.SIG_IGN)
879
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
880
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
881
882
611
for client in clients:
883
612
client.start()
884
613
885
tcp_server.enable()
886
tcp_server.server_activate()
887
888
# Find out what port we got
889
service.port = tcp_server.socket.getsockname()[1]
890
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
891
u" scope_id %d" % tcp_server.socket.getsockname())
892
893
#service.interface = tcp_server.socket.getsockname()[3]
894
614
tcp_server = IPv6_TCPServer((None, options.port),
615
tcp_handler,
616
options=options,
617
clients=clients)
618
# Find out what random port we got
619
servicePort = tcp_server.socket.getsockname()[1]
620
logger.debug(u"Now listening on port %d", servicePort)
621
622
if options.interface is not None:
623
serviceInterface = if_nametoindex(options.interface)
624
625
# From the Avahi server example code
626
server.connect_to_signal("StateChanged", server_state_changed)
627
server_state_changed(server.GetState())
628
# End of Avahi example code
629
630
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
631
lambda *args, **kwargs:
632
tcp_server.handle_request(*args[2:],
633
**kwargs) or True)
895
634
try:
896
# From the Avahi example code
897
server.connect_to_signal("StateChanged", server_state_changed)
898
try:
899
server_state_changed(server.GetState())
900
except dbus.exceptions.DBusException, error:
901
logger.critical(u"DBusException: %s", error)
902
sys.exit(1)
903
# End of Avahi example code
904
905
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
906
lambda *args, **kwargs:
907
tcp_server.handle_request\
908
(*args[2:], **kwargs) or True)
909
910
logger.debug(u"Starting main loop")
911
635
main_loop.run()
912
except AvahiError, error:
913
logger.critical(u"AvahiError: %s" + unicode(error))
914
sys.exit(1)
915
636
except KeyboardInterrupt:
916
if debug:
917
print
637
print
638
639
# Cleanup here
918
640
919
if __name__ == '__main__':
920
main()
641
# From the Avahi server example code
642
if not group is None:
643
group.Free()
644
# End of Avahi example code
645
646
for client in clients:
647
client.stop_hook = None
648
client.stop()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0