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