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 234
- compare with another revision
- download diff
- download tarball
- view history from revision 234
- Committer: Teddy Hogeborn
- Date: 2008-10-18 11:17:22 UTC
- Revision ID: teddy@fukt.bsnet.se-20081018111722-jtbz35c031lxuuc9
* debian/mandos-client.docs (NEWS): Added.
* debian/mandos.docs (NEWS): - '' -
* debian/mandos.docs (NEWS): - '' -
- files added:
- .bzr-builddeb
- debian
- debian/po
- files removed:
- ca.pem
- files renamed:
- mandos-clients.conf => clients.conf
- server.py => mandos
- plugbasedclient.c => plugin-runner.c
- plugins.d/mandosclient.c => plugins.d/mandos-client.c
- plugins.d/passprompt.c => plugins.d/password-prompt.c
- 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
import logging
32
import logging.handlers
33
34
# logghandler.setFormatter(logging.Formatter('%(levelname)s %(message)s')
64
import ctypes.util
65
66
version = "1.0.2"
35
67
36
68
logger = logging.Logger('mandos')
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
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
53
170
# End of Avahi example code
54
171
55
172
60
177
fingerprint: string (40 or 32 hexadecimal digits); used to
61
178
uniquely identify the client
62
179
secret: bytestring; sent verbatim (over TLS) to client
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
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
68
185
interval: datetime.timedelta(); How often to start a new checker
69
186
stop_hook: If set, called by stop() as stop_hook(self)
70
187
checker: subprocess.Popen(); a running checker process used
71
188
to see if the client lives.
72
Is None if no process is running.
189
'None' if no process is running.
73
190
checker_initiator_tag: a gobject event source tag, or None
74
191
stop_initiator_tag: - '' -
75
192
checker_callback_tag: - '' -
76
193
checker_command: string; External command which is run to check if
77
client lives. %()s expansions are done at
194
client lives. %() expansions are done at
78
195
runtime with vars(self) as dict, so that for
79
196
instance %(name)s can be used in the command.
80
197
Private attibutes:
81
198
_timeout: Real variable for 'timeout'
82
199
_interval: Real variable for 'interval'
83
_timeout_milliseconds: Used by gobject.timeout_add()
200
_timeout_milliseconds: Used when calling gobject.timeout_add()
84
201
_interval_milliseconds: - '' -
85
202
"""
86
203
def _set_timeout(self, timeout):
106
223
interval = property(lambda self: self._interval,
107
224
_set_interval)
108
225
del _set_interval
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):
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 = {}
112
232
self.name = name
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()
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()
123
247
else:
124
raise RuntimeError(u"No secret or secfile for client %s"
125
% self.name)
126
self.fqdn = fqdn # string
248
raise TypeError(u"No secret or secfile for client %s"
249
% self.name)
250
self.host = config.get("host", "")
127
251
self.created = datetime.datetime.now()
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
252
self.last_checked_ok = None
253
self.timeout = string_to_delta(config["timeout"])
254
self.interval = string_to_delta(config["interval"])
137
255
self.stop_hook = stop_hook
138
256
self.checker = None
139
257
self.checker_initiator_tag = None
140
258
self.stop_initiator_tag = None
141
259
self.checker_callback_tag = None
142
self.check_command = checker
260
self.check_command = config["checker"]
143
261
def start(self):
144
"""Start this clients checker and timeout hooks"""
262
"""Start this client's checker and timeout hooks"""
145
263
# Schedule a new checker to be started an 'interval' from now,
146
264
# and every interval from then on.
147
265
self.checker_initiator_tag = gobject.timeout_add\
155
273
self.stop)
156
274
def stop(self):
157
275
"""Stop this client.
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:
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):
163
285
gobject.source_remove(self.stop_initiator_tag)
164
286
self.stop_initiator_tag = None
165
if self.checker_initiator_tag:
287
if getattr(self, "checker_initiator_tag", False):
166
288
gobject.source_remove(self.checker_initiator_tag)
167
289
self.checker_initiator_tag = None
168
290
self.stop_checker()
171
293
# Do not run this again if called by a gobject.timeout_add
172
294
return False
173
295
def __del__(self):
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()
296
self.stop_hook = None
297
self.stop()
184
298
def checker_callback(self, pid, condition):
185
299
"""The checker has completed, so take appropriate actions."""
186
300
now = datetime.datetime.now()
301
self.checker_callback_tag = None
302
self.checker = None
187
303
if os.WIFEXITED(condition) \
188
304
and (os.WEXITSTATUS(condition) == 0):
189
logger.debug(u"Checker for %(name)s succeeded",
190
vars(self))
191
self.last_seen = now
305
logger.info(u"Checker for %(name)s succeeded",
306
vars(self))
307
self.last_checked_ok = now
192
308
gobject.source_remove(self.stop_initiator_tag)
193
309
self.stop_initiator_tag = gobject.timeout_add\
194
310
(self._timeout_milliseconds,
195
311
self.stop)
196
if not os.WIFEXITED(condition):
312
elif not os.WIFEXITED(condition):
197
313
logger.warning(u"Checker for %(name)s crashed?",
198
314
vars(self))
199
315
else:
200
logger.debug(u"Checker for %(name)s failed",
201
vars(self))
202
self.checker = None
203
self.checker_callback_tag = None
316
logger.info(u"Checker for %(name)s failed",
317
vars(self))
204
318
def start_checker(self):
205
319
"""Start a new checker subprocess if one is not running.
206
320
If a checker already exists, leave it running and do
207
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.
208
330
if self.checker is None:
209
logger.debug(u"Starting checker for %s",
210
self.name)
211
331
try:
212
command = self.check_command % self.fqdn
332
# In case check_command has exactly one % operator
333
command = self.check_command % self.host
213
334
except TypeError:
335
# Escape attributes for the shell
214
336
escaped_attrs = dict((key, re.escape(str(val)))
215
337
for key, val in
216
338
vars(self).iteritems())
217
339
try:
218
340
command = self.check_command % escaped_attrs
219
341
except TypeError, error:
220
logger.critical(u'Could not format string "%s": %s',
221
self.check_command, error)
342
logger.error(u'Could not format string "%s":'
343
u' %s', self.check_command, error)
222
344
return True # Try again later
223
345
try:
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:
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:
234
359
logger.error(u"Failed to start subprocess: %s",
235
360
error)
236
361
# Re-run this periodically if run by gobject.timeout_add
237
362
return True
238
363
def stop_checker(self):
239
364
"""Force the checker process, if any, to stop."""
240
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:
241
369
return
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)
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
247
379
self.checker = None
248
def still_valid(self, now=None):
380
def still_valid(self):
249
381
"""Has the timeout not yet passed for this client?"""
250
if now is None:
251
now = datetime.datetime.now()
252
if self.last_seen is None:
382
now = datetime.datetime.now()
383
if self.last_checked_ok is None:
253
384
return now < (self.created + self.timeout)
254
385
else:
255
return now < (self.last_seen + self.timeout)
386
return now < (self.last_checked_ok + self.timeout)
256
387
257
388
258
389
def peer_certificate(session):
390
"Return the peer's OpenPGP certificate as a bytestring"
259
391
# If not an OpenPGP certificate...
260
392
if gnutls.library.functions.gnutls_certificate_type_get\
261
393
(session._c_object) \
272
404
273
405
274
406
def fingerprint(openpgp):
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
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
279
408
# New GnuTLS "datum" with the OpenPGP public key
280
409
datum = gnutls.library.types.gnutls_datum_t\
281
410
(ctypes.cast(ctypes.c_char_p(openpgp),
282
411
ctypes.POINTER(ctypes.c_ubyte)),
283
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))
284
417
# Import the OpenPGP public key into the certificate
285
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
286
(crt,
287
ctypes.byref(datum),
288
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")
289
428
# New buffer for the fingerprint
290
buffer = ctypes.create_string_buffer(20)
291
buffer_length = ctypes.c_size_t()
429
buf = ctypes.create_string_buffer(20)
430
buf_len = ctypes.c_size_t()
292
431
# Get the fingerprint from the certificate into the buffer
293
432
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
294
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
433
(crt, ctypes.byref(buf), ctypes.byref(buf_len))
295
434
# Deinit the certificate
296
435
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
297
436
# Convert the buffer to a Python bytestring
298
fpr = ctypes.string_at(buffer, buffer_length.value)
437
fpr = ctypes.string_at(buf, buf_len.value)
299
438
# Convert the bytestring to hexadecimal notation
300
439
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
301
440
return hex_fpr
302
441
303
442
304
class tcp_handler(SocketServer.BaseRequestHandler, object):
443
class TCP_handler(SocketServer.BaseRequestHandler, object):
305
444
"""A TCP request handler class.
306
445
Instantiated by IPv6_TCPServer for each request to handle it.
307
446
Note: This will run in its own forked process."""
308
447
309
448
def handle(self):
310
logger.debug(u"TCP connection from: %s",
449
logger.info(u"TCP connection from: %s",
311
450
unicode(self.client_address))
312
session = gnutls.connection.ClientSession(self.request,
313
gnutls.connection.\
314
X509Credentials())
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.
315
467
316
468
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
317
469
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
318
470
# "+DHE-DSS"))
319
priority = "SECURE256"
320
471
priority = "NORMAL" # Fallback default, since this
472
# MUST be set.
473
if self.server.settings["priority"]:
474
priority = self.server.settings["priority"]
321
475
gnutls.library.functions.gnutls_priority_set_direct\
322
(session._c_object, priority, None);
476
(session._c_object, priority, None)
323
477
324
478
try:
325
479
session.handshake()
326
480
except gnutls.errors.GNUTLSError, error:
327
logger.debug(u"Handshake failed: %s", error)
481
logger.warning(u"Handshake failed: %s", error)
328
482
# Do not run session.bye() here: the session is not
329
483
# established. Just abandon the request.
330
484
return
331
485
try:
332
486
fpr = fingerprint(peer_certificate(session))
333
487
except (TypeError, gnutls.errors.GNUTLSError), error:
334
logger.debug(u"Bad certificate: %s", error)
488
logger.warning(u"Bad certificate: %s", error)
335
489
session.bye()
336
490
return
337
491
logger.debug(u"Fingerprint: %s", fpr)
338
492
client = None
339
for c in clients:
493
for c in self.server.clients:
340
494
if c.fingerprint == fpr:
341
495
client = c
342
496
break
497
if not client:
498
logger.warning(u"Client not found for fingerprint: %s",
499
fpr)
500
session.bye()
501
return
343
502
# Have to check if client.still_valid(), since it is possible
344
503
# that the client timed out while establishing the GnuTLS
345
504
# session.
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)
505
if not client.still_valid():
506
logger.warning(u"Client %(name)s is invalid",
507
vars(client))
353
508
session.bye()
354
509
return
355
510
sent_size = 0
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
logger.warning(u"No permission to"
395
u" bind to interface %s",
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
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()
614
timevalue += delta
615
return timevalue
476
616
477
617
478
618
def server_state_changed(state):
479
"""From the Avahi server example code"""
619
"""Derived from the Avahi example code"""
480
620
if state == avahi.SERVER_COLLISION:
481
logger.warning(u"Server name collision")
482
remove_service()
621
logger.error(u"Zeroconf server name collision")
622
service.remove()
483
623
elif state == avahi.SERVER_RUNNING:
484
add_service()
624
service.add()
485
625
486
626
487
627
def entry_group_state_changed(state, error):
488
"""From the Avahi server example code"""
489
global serviceName, server, rename_count
490
491
logger.debug(u"state change: %i", state)
628
"""Derived from the Avahi example code"""
629
logger.debug(u"Avahi state change: %i", state)
492
630
493
631
if state == avahi.ENTRY_GROUP_ESTABLISHED:
494
logger.debug(u"Service established.")
632
logger.debug(u"Zeroconf service established.")
495
633
elif state == avahi.ENTRY_GROUP_COLLISION:
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()
634
logger.warning(u"Zeroconf service name collision.")
635
service.rename()
510
636
elif state == avahi.ENTRY_GROUP_FAILURE:
511
logger.error(u"Error in group state changed %s",
512
unicode(error))
513
main_loop.quit()
514
return
515
637
logger.critical(u"Avahi: Error in group state changed %s",
638
unicode(error))
639
raise AvahiGroupError("State changed: %s", str(error))
516
640
517
641
def if_nametoindex(interface):
518
"""Call the C function if_nametoindex()"""
642
"""Call the C function if_nametoindex(), or equivalent"""
643
global if_nametoindex
519
644
try:
520
libc = ctypes.cdll.LoadLibrary("libc.so.6")
521
return libc.if_nametoindex(interface)
645
if_nametoindex = ctypes.cdll.LoadLibrary\
646
(ctypes.util.find_library("c")).if_nametoindex
522
647
except (OSError, AttributeError):
523
648
if "struct" not in sys.modules:
524
649
import struct
525
650
if "fcntl" not in sys.modules:
526
651
import fcntl
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()
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)
538
689
parser.add_option("-i", "--interface", type="string",
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,
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",
554
694
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")
561
695
parser.add_option("--check", action="store_true", default=False,
562
696
help="Run self-test")
563
parser.add_option("--debug", action="store_true", default=False,
564
help="Debug mode")
565
(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]
566
709
567
710
if options.check:
568
711
import doctest
569
712
doctest.testmod()
570
713
sys.exit()
571
714
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
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
589
814
DBusGMainLoop(set_as_default=True )
590
815
main_loop = gobject.MainLoop()
591
816
bus = dbus.SystemBus()
592
server = dbus.Interface(
593
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
594
avahi.DBUS_INTERFACE_SERVER )
817
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
818
avahi.DBUS_PATH_SERVER),
819
avahi.DBUS_INTERFACE_SERVER)
595
820
# End of Avahi example code
596
821
597
debug = options.debug
598
599
clients = Set()
600
822
def remove_from_clients(client):
601
823
clients.remove(client)
602
824
if not clients:
603
logger.debug(u"No clients left, exiting")
604
main_loop.quit()
825
logger.critical(u"No clients left, exiting")
826
sys.exit()
605
827
606
clients.update(Set(Client(name=section, options=options,
828
clients.update(Set(Client(name = section,
607
829
stop_hook = remove_from_clients,
608
**(dict(client_config\
609
.items(section))))
830
config
831
= dict(client_config.items(section)))
610
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
611
883
for client in clients:
612
884
client.start()
613
885
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)
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
634
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")
635
912
main_loop.run()
913
except AvahiError, error:
914
logger.critical(u"AvahiError: %s" + unicode(error))
915
sys.exit(1)
636
916
except KeyboardInterrupt:
637
print
638
639
# Cleanup here
917
if debug:
918
print
640
919
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()
920
if __name__ == '__main__':
921
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0