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
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
#
3
32
4
33
from __future__ import division
5
34
6
35
import SocketServer
7
36
import socket
8
import select
9
37
from optparse import OptionParser
10
38
import datetime
11
39
import errno
24
52
import subprocess
25
53
import atexit
26
54
import stat
55
import logging
56
import logging.handlers
57
import pwd
27
58
28
59
import dbus
29
60
import gobject
30
61
import avahi
31
62
from dbus.mainloop.glib import DBusGMainLoop
32
63
import ctypes
64
import ctypes.util
33
65
34
import logging
35
import logging.handlers
66
version = "1.0.2"
36
67
37
68
logger = logging.Logger('mandos')
38
69
syslogger = logging.handlers.SysLogHandler\
39
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
70
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
71
address = "/dev/log")
40
72
syslogger.setFormatter(logging.Formatter\
41
('%(levelname)s: %(message)s'))
73
('Mandos: %(levelname)s: %(message)s'))
42
74
logger.addHandler(syslogger)
43
del syslogger
44
45
# This variable is used to optionally bind to a specified interface.
46
# It is a global variable to fit in with the other variables from the
47
# Avahi server example code.
48
serviceInterface = avahi.IF_UNSPEC
49
# From the Avahi server example code:
50
serviceName = "Mandos"
51
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
52
servicePort = None # Not known at startup
53
serviceTXT = [] # TXT record for the service
54
domain = "" # Domain to publish on, default to .local
55
host = "" # Host to publish records for, default to localhost
56
group = None #our entry group
57
rename_count = 12 # Counter so we only rename after collisions a
58
# sensible number of times
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
59
170
# End of Avahi example code
60
171
61
172
66
177
fingerprint: string (40 or 32 hexadecimal digits); used to
67
178
uniquely identify the client
68
179
secret: bytestring; sent verbatim (over TLS) to client
69
fqdn: string (FQDN); available for use by the checker command
70
created: datetime.datetime()
71
last_seen: datetime.datetime() or None if not yet seen
72
timeout: datetime.timedelta(); How long from last_seen until
73
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
74
185
interval: datetime.timedelta(); How often to start a new checker
75
186
stop_hook: If set, called by stop() as stop_hook(self)
76
187
checker: subprocess.Popen(); a running checker process used
77
188
to see if the client lives.
78
Is None if no process is running.
189
'None' if no process is running.
79
190
checker_initiator_tag: a gobject event source tag, or None
80
191
stop_initiator_tag: - '' -
81
192
checker_callback_tag: - '' -
82
193
checker_command: string; External command which is run to check if
83
client lives. %()s expansions are done at
194
client lives. %() expansions are done at
84
195
runtime with vars(self) as dict, so that for
85
196
instance %(name)s can be used in the command.
86
197
Private attibutes:
87
198
_timeout: Real variable for 'timeout'
88
199
_interval: Real variable for 'interval'
89
_timeout_milliseconds: Used by gobject.timeout_add()
200
_timeout_milliseconds: Used when calling gobject.timeout_add()
90
201
_interval_milliseconds: - '' -
91
202
"""
92
203
def _set_timeout(self, timeout):
112
223
interval = property(lambda self: self._interval,
113
224
_set_interval)
114
225
del _set_interval
115
def __init__(self, name=None, options=None, stop_hook=None,
116
fingerprint=None, secret=None, secfile=None,
117
fqdn=None, 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 = {}
118
232
self.name = name
119
# Uppercase and remove spaces from fingerprint
120
# for later comparison purposes with return value of
121
# the fingerprint() function
122
self.fingerprint = fingerprint.upper().replace(u" ", u"")
123
if secret:
124
self.secret = secret.decode(u"base64")
125
elif secfile:
126
sf = open(secfile)
127
self.secret = sf.read()
128
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()
129
247
else:
130
raise RuntimeError(u"No secret or secfile for client %s"
131
% self.name)
132
self.fqdn = fqdn # string
248
raise TypeError(u"No secret or secfile for client %s"
249
% self.name)
250
self.host = config.get("host", "")
133
251
self.created = datetime.datetime.now()
134
self.last_seen = None
135
if timeout is None:
136
self.timeout = options.timeout
137
else:
138
self.timeout = string_to_delta(timeout)
139
if interval == -1:
140
self.interval = options.interval
141
else:
142
self.interval = string_to_delta(interval)
252
self.last_checked_ok = None
253
self.timeout = string_to_delta(config["timeout"])
254
self.interval = string_to_delta(config["interval"])
143
255
self.stop_hook = stop_hook
144
256
self.checker = None
145
257
self.checker_initiator_tag = None
146
258
self.stop_initiator_tag = None
147
259
self.checker_callback_tag = None
148
self.check_command = checker
260
self.check_command = config["checker"]
149
261
def start(self):
150
"""Start this clients checker and timeout hooks"""
262
"""Start this client's checker and timeout hooks"""
151
263
# Schedule a new checker to be started an 'interval' from now,
152
264
# and every interval from then on.
153
265
self.checker_initiator_tag = gobject.timeout_add\
161
273
self.stop)
162
274
def stop(self):
163
275
"""Stop this client.
164
The possibility that this client might be restarted is left
165
open, but not currently used."""
166
logger.debug(u"Stopping client %s", self.name)
167
self.secret = None
168
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):
169
285
gobject.source_remove(self.stop_initiator_tag)
170
286
self.stop_initiator_tag = None
171
if self.checker_initiator_tag:
287
if getattr(self, "checker_initiator_tag", False):
172
288
gobject.source_remove(self.checker_initiator_tag)
173
289
self.checker_initiator_tag = None
174
290
self.stop_checker()
177
293
# Do not run this again if called by a gobject.timeout_add
178
294
return False
179
295
def __del__(self):
180
# Some code duplication here and in stop()
181
if hasattr(self, "stop_initiator_tag") \
182
and self.stop_initiator_tag:
183
gobject.source_remove(self.stop_initiator_tag)
184
self.stop_initiator_tag = None
185
if hasattr(self, "checker_initiator_tag") \
186
and self.checker_initiator_tag:
187
gobject.source_remove(self.checker_initiator_tag)
188
self.checker_initiator_tag = None
189
self.stop_checker()
296
self.stop_hook = None
297
self.stop()
190
298
def checker_callback(self, pid, condition):
191
299
"""The checker has completed, so take appropriate actions."""
192
300
now = datetime.datetime.now()
301
self.checker_callback_tag = None
302
self.checker = None
193
303
if os.WIFEXITED(condition) \
194
304
and (os.WEXITSTATUS(condition) == 0):
195
logger.debug(u"Checker for %(name)s succeeded",
196
vars(self))
197
self.last_seen = now
305
logger.info(u"Checker for %(name)s succeeded",
306
vars(self))
307
self.last_checked_ok = now
198
308
gobject.source_remove(self.stop_initiator_tag)
199
309
self.stop_initiator_tag = gobject.timeout_add\
200
310
(self._timeout_milliseconds,
203
313
logger.warning(u"Checker for %(name)s crashed?",
204
314
vars(self))
205
315
else:
206
logger.debug(u"Checker for %(name)s failed",
207
vars(self))
208
self.checker = None
209
self.checker_callback_tag = None
316
logger.info(u"Checker for %(name)s failed",
317
vars(self))
210
318
def start_checker(self):
211
319
"""Start a new checker subprocess if one is not running.
212
320
If a checker already exists, leave it running and do
213
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.
214
330
if self.checker is None:
215
331
try:
216
command = self.check_command % self.fqdn
332
# In case check_command has exactly one % operator
333
command = self.check_command % self.host
217
334
except TypeError:
335
# Escape attributes for the shell
218
336
escaped_attrs = dict((key, re.escape(str(val)))
219
337
for key, val in
220
338
vars(self).iteritems())
221
339
try:
222
340
command = self.check_command % escaped_attrs
223
341
except TypeError, error:
224
logger.critical(u'Could not format string "%s":'
225
u' %s', self.check_command, error)
342
logger.error(u'Could not format string "%s":'
343
u' %s', self.check_command, error)
226
344
return True # Try again later
227
345
try:
228
logger.debug(u"Starting checker %r for %s",
229
command, self.name)
230
self.checker = subprocess.\
231
Popen(command,
232
close_fds=True, shell=True,
233
cwd="/")
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="/")
234
355
self.checker_callback_tag = gobject.child_watch_add\
235
356
(self.checker.pid,
236
357
self.checker_callback)
237
except subprocess.OSError, error:
358
except OSError, error:
238
359
logger.error(u"Failed to start subprocess: %s",
239
360
error)
240
361
# Re-run this periodically if run by gobject.timeout_add
241
362
return True
242
363
def stop_checker(self):
243
364
"""Force the checker process, if any, to stop."""
244
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:
245
369
return
246
gobject.source_remove(self.checker_callback_tag)
247
self.checker_callback_tag = None
248
os.kill(self.checker.pid, signal.SIGTERM)
249
if self.checker.poll() is None:
250
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
251
379
self.checker = None
252
def still_valid(self, now=None):
380
def still_valid(self):
253
381
"""Has the timeout not yet passed for this client?"""
254
if now is None:
255
now = datetime.datetime.now()
256
if self.last_seen is None:
382
now = datetime.datetime.now()
383
if self.last_checked_ok is None:
257
384
return now < (self.created + self.timeout)
258
385
else:
259
return now < (self.last_seen + self.timeout)
386
return now < (self.last_checked_ok + self.timeout)
260
387
261
388
262
389
def peer_certificate(session):
263
"Return an OpenPGP data packet string for the peer's certificate"
390
"Return the peer's OpenPGP certificate as a bytestring"
264
391
# If not an OpenPGP certificate...
265
392
if gnutls.library.functions.gnutls_certificate_type_get\
266
393
(session._c_object) \
277
404
278
405
279
406
def fingerprint(openpgp):
280
"Convert an OpenPGP data string to a hexdigit fingerprint string"
281
# New empty GnuTLS certificate
282
crt = gnutls.library.types.gnutls_openpgp_crt_t()
283
gnutls.library.functions.gnutls_openpgp_crt_init\
284
(ctypes.byref(crt))
407
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
285
408
# New GnuTLS "datum" with the OpenPGP public key
286
409
datum = gnutls.library.types.gnutls_datum_t\
287
410
(ctypes.cast(ctypes.c_char_p(openpgp),
288
411
ctypes.POINTER(ctypes.c_ubyte)),
289
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))
290
417
# Import the OpenPGP public key into the certificate
291
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
292
(crt,
293
ctypes.byref(datum),
294
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")
295
428
# New buffer for the fingerprint
296
buffer = ctypes.create_string_buffer(20)
297
buffer_length = ctypes.c_size_t()
429
buf = ctypes.create_string_buffer(20)
430
buf_len = ctypes.c_size_t()
298
431
# Get the fingerprint from the certificate into the buffer
299
432
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
300
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
433
(crt, ctypes.byref(buf), ctypes.byref(buf_len))
301
434
# Deinit the certificate
302
435
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
303
436
# Convert the buffer to a Python bytestring
304
fpr = ctypes.string_at(buffer, buffer_length.value)
437
fpr = ctypes.string_at(buf, buf_len.value)
305
438
# Convert the bytestring to hexadecimal notation
306
439
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
307
440
return hex_fpr
308
441
309
442
310
class tcp_handler(SocketServer.BaseRequestHandler, object):
443
class TCP_handler(SocketServer.BaseRequestHandler, object):
311
444
"""A TCP request handler class.
312
445
Instantiated by IPv6_TCPServer for each request to handle it.
313
446
Note: This will run in its own forked process."""
314
447
315
448
def handle(self):
316
logger.debug(u"TCP connection from: %s",
449
logger.info(u"TCP connection from: %s",
317
450
unicode(self.client_address))
318
session = gnutls.connection.ClientSession(self.request,
319
gnutls.connection.\
320
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.
321
467
322
468
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
323
469
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
324
470
# "+DHE-DSS"))
325
priority = "SECURE256"
326
471
priority = "NORMAL" # Fallback default, since this
472
# MUST be set.
473
if self.server.settings["priority"]:
474
priority = self.server.settings["priority"]
327
475
gnutls.library.functions.gnutls_priority_set_direct\
328
(session._c_object, priority, None);
476
(session._c_object, priority, None)
329
477
330
478
try:
331
479
session.handshake()
332
480
except gnutls.errors.GNUTLSError, error:
333
logger.debug(u"Handshake failed: %s", error)
481
logger.warning(u"Handshake failed: %s", error)
334
482
# Do not run session.bye() here: the session is not
335
483
# established. Just abandon the request.
336
484
return
337
485
try:
338
486
fpr = fingerprint(peer_certificate(session))
339
487
except (TypeError, gnutls.errors.GNUTLSError), error:
340
logger.debug(u"Bad certificate: %s", error)
488
logger.warning(u"Bad certificate: %s", error)
341
489
session.bye()
342
490
return
343
491
logger.debug(u"Fingerprint: %s", fpr)
344
492
client = None
345
for c in clients:
493
for c in self.server.clients:
346
494
if c.fingerprint == fpr:
347
495
client = c
348
496
break
497
if not client:
498
logger.warning(u"Client not found for fingerprint: %s",
499
fpr)
500
session.bye()
501
return
349
502
# Have to check if client.still_valid(), since it is possible
350
503
# that the client timed out while establishing the GnuTLS
351
504
# session.
352
if (not client) or (not client.still_valid()):
353
if client:
354
logger.debug(u"Client %(name)s is invalid",
355
vars(client))
356
else:
357
logger.debug(u"Client not found for fingerprint: %s",
358
fpr)
505
if not client.still_valid():
506
logger.warning(u"Client %(name)s is invalid",
507
vars(client))
359
508
session.bye()
360
509
return
361
510
sent_size = 0
371
520
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
372
521
"""IPv6 TCP server. Accepts 'None' as address and/or port.
373
522
Attributes:
374
options: Command line options
523
settings: Server settings
375
524
clients: Set() of Client objects
525
enabled: Boolean; whether this server is activated yet
376
526
"""
377
527
address_family = socket.AF_INET6
378
528
def __init__(self, *args, **kwargs):
379
if "options" in kwargs:
380
self.options = kwargs["options"]
381
del kwargs["options"]
529
if "settings" in kwargs:
530
self.settings = kwargs["settings"]
531
del kwargs["settings"]
382
532
if "clients" in kwargs:
383
533
self.clients = kwargs["clients"]
384
534
del kwargs["clients"]
385
return super(type(self), self).__init__(*args, **kwargs)
535
self.enabled = False
536
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
386
537
def server_bind(self):
387
538
"""This overrides the normal server_bind() function
388
539
to bind to an interface if one was specified, and also NOT to
389
540
bind to an address or port if they were not specified."""
390
if self.options.interface:
391
if not hasattr(socket, "SO_BINDTODEVICE"):
392
# From /usr/include/asm-i486/socket.h
393
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)
394
544
try:
395
545
self.socket.setsockopt(socket.SOL_SOCKET,
396
socket.SO_BINDTODEVICE,
397
self.options.interface)
546
SO_BINDTODEVICE,
547
self.settings["interface"])
398
548
except socket.error, error:
399
549
if error[0] == errno.EPERM:
400
logger.warning(u"No permission to"
401
u" bind to interface %s",
402
self.options.interface)
550
logger.error(u"No permission to"
551
u" bind to interface %s",
552
self.settings["interface"])
403
553
else:
404
554
raise error
405
555
# Only bind(2) the socket if we really need to.
408
558
in6addr_any = "::"
409
559
self.server_address = (in6addr_any,
410
560
self.server_address[1])
411
elif self.server_address[1] is None:
561
elif not self.server_address[1]:
412
562
self.server_address = (self.server_address[0],
413
563
0)
414
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
415
577
416
578
417
579
def string_to_delta(interval):
427
589
datetime.timedelta(1)
428
590
>>> string_to_delta(u'1w')
429
591
datetime.timedelta(7)
592
>>> string_to_delta('5m 30s')
593
datetime.timedelta(0, 330)
430
594
"""
431
try:
432
suffix=unicode(interval[-1])
433
value=int(interval[:-1])
434
if suffix == u"d":
435
delta = datetime.timedelta(value)
436
elif suffix == u"s":
437
delta = datetime.timedelta(0, value)
438
elif suffix == u"m":
439
delta = datetime.timedelta(0, 0, 0, 0, value)
440
elif suffix == u"h":
441
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
442
elif suffix == u"w":
443
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
444
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):
445
613
raise ValueError
446
except (ValueError, IndexError):
447
raise ValueError
448
return delta
449
450
451
def add_service():
452
"""From the Avahi server example code"""
453
global group, serviceName, serviceType, servicePort, serviceTXT, \
454
domain, host
455
if group is None:
456
group = dbus.Interface(
457
bus.get_object( avahi.DBUS_NAME,
458
server.EntryGroupNew()),
459
avahi.DBUS_INTERFACE_ENTRY_GROUP)
460
group.connect_to_signal('StateChanged',
461
entry_group_state_changed)
462
logger.debug(u"Adding service '%s' of type '%s' ...",
463
serviceName, serviceType)
464
465
group.AddService(
466
serviceInterface, # interface
467
avahi.PROTO_INET6, # protocol
468
dbus.UInt32(0), # flags
469
serviceName, serviceType,
470
domain, host,
471
dbus.UInt16(servicePort),
472
avahi.string_array_to_txt_array(serviceTXT))
473
group.Commit()
474
475
476
def remove_service():
477
"""From the Avahi server example code"""
478
global group
479
480
if not group is None:
481
group.Reset()
614
timevalue += delta
615
return timevalue
482
616
483
617
484
618
def server_state_changed(state):
485
"""From the Avahi server example code"""
619
"""Derived from the Avahi example code"""
486
620
if state == avahi.SERVER_COLLISION:
487
logger.warning(u"Server name collision")
488
remove_service()
621
logger.error(u"Zeroconf server name collision")
622
service.remove()
489
623
elif state == avahi.SERVER_RUNNING:
490
add_service()
624
service.add()
491
625
492
626
493
627
def entry_group_state_changed(state, error):
494
"""From the Avahi server example code"""
495
global serviceName, server, rename_count
496
497
logger.debug(u"state change: %i", state)
628
"""Derived from the Avahi example code"""
629
logger.debug(u"Avahi state change: %i", state)
498
630
499
631
if state == avahi.ENTRY_GROUP_ESTABLISHED:
500
logger.debug(u"Service established.")
632
logger.debug(u"Zeroconf service established.")
501
633
elif state == avahi.ENTRY_GROUP_COLLISION:
502
503
rename_count = rename_count - 1
504
if rename_count > 0:
505
name = server.GetAlternativeServiceName(name)
506
logger.warning(u"Service name collision, "
507
u"changing name to '%s' ...", name)
508
remove_service()
509
add_service()
510
511
else:
512
logger.error(u"No suitable service name found after %i"
513
u" retries, exiting.", n_rename)
514
killme(1)
634
logger.warning(u"Zeroconf service name collision.")
635
service.rename()
515
636
elif state == avahi.ENTRY_GROUP_FAILURE:
516
logger.error(u"Error in group state changed %s",
517
unicode(error))
518
killme(1)
519
637
logger.critical(u"Avahi: Error in group state changed %s",
638
unicode(error))
639
raise AvahiGroupError("State changed: %s", str(error))
520
640
521
641
def if_nametoindex(interface):
522
"""Call the C function if_nametoindex()"""
642
"""Call the C function if_nametoindex(), or equivalent"""
643
global if_nametoindex
523
644
try:
524
libc = ctypes.cdll.LoadLibrary("libc.so.6")
525
return libc.if_nametoindex(interface)
645
if_nametoindex = ctypes.cdll.LoadLibrary\
646
(ctypes.util.find_library("c")).if_nametoindex
526
647
except (OSError, AttributeError):
527
648
if "struct" not in sys.modules:
528
649
import struct
529
650
if "fcntl" not in sys.modules:
530
651
import fcntl
531
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
532
s = socket.socket()
533
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
534
struct.pack("16s16x", interface))
535
s.close()
536
interface_index = struct.unpack("I", ifreq[16:20])[0]
537
return interface_index
538
539
540
def daemon(nochdir, noclose):
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):
541
665
"""See daemon(3). Standard BSD Unix function.
542
666
This should really exist as os.daemon, but it doesn't (yet)."""
543
667
if os.fork():
545
669
os.setsid()
546
670
if not nochdir:
547
671
os.chdir("/")
672
if os.fork():
673
sys.exit()
548
674
if not noclose:
549
675
# Close all standard open file descriptors
550
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
676
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
551
677
if not stat.S_ISCHR(os.fstat(null).st_mode):
552
678
raise OSError(errno.ENODEV,
553
679
"/dev/null not a character device")
558
684
os.close(null)
559
685
560
686
561
def killme(status = 0):
562
logger.debug("Stopping server with exit status %d", status)
563
exitstatus = status
564
if main_loop_started:
565
main_loop.quit()
566
else:
567
sys.exit(status)
568
569
570
if __name__ == '__main__':
571
exitstatus = 0
572
main_loop_started = False
573
parser = OptionParser()
687
def main():
688
parser = OptionParser(version = "%%prog %s" % version)
574
689
parser.add_option("-i", "--interface", type="string",
575
default=None, metavar="IF",
576
help="Bind to interface IF")
577
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",
578
694
help="Port number to receive requests on")
579
parser.add_option("--timeout", type="string", # Parsed later
580
default="1h",
581
help="Amount of downtime allowed for clients")
582
parser.add_option("--interval", type="string", # Parsed later
583
default="5m",
584
help="How often to check that a client is up")
585
695
parser.add_option("--check", action="store_true", default=False,
586
696
help="Run self-test")
587
parser.add_option("--debug", action="store_true", default=False,
588
help="Debug mode")
589
(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]
590
709
591
710
if options.check:
592
711
import doctest
593
712
doctest.testmod()
594
713
sys.exit()
595
714
596
# Parse the time arguments
597
try:
598
options.timeout = string_to_delta(options.timeout)
599
except ValueError:
600
parser.error("option --timeout: Unparseable time")
601
try:
602
options.interval = string_to_delta(options.interval)
603
except ValueError:
604
parser.error("option --interval: Unparseable time")
605
606
# Parse config file
607
defaults = { "checker": "fping -q -- %%(fqdn)s" }
608
client_config = ConfigParser.SafeConfigParser(defaults)
609
#client_config.readfp(open("secrets.conf"), "secrets.conf")
610
client_config.read("mandos-clients.conf")
611
612
# 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
613
814
DBusGMainLoop(set_as_default=True )
614
815
main_loop = gobject.MainLoop()
615
816
bus = dbus.SystemBus()
616
server = dbus.Interface(
617
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
618
avahi.DBUS_INTERFACE_SERVER )
817
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
818
avahi.DBUS_PATH_SERVER),
819
avahi.DBUS_INTERFACE_SERVER)
619
820
# End of Avahi example code
620
821
621
debug = options.debug
622
623
if debug:
624
console = logging.StreamHandler()
625
# console.setLevel(logging.DEBUG)
626
console.setFormatter(logging.Formatter\
627
('%(levelname)s: %(message)s'))
628
logger.addHandler(console)
629
del console
630
631
clients = Set()
632
822
def remove_from_clients(client):
633
823
clients.remove(client)
634
824
if not clients:
635
logger.debug(u"No clients left, exiting")
636
killme()
825
logger.critical(u"No clients left, exiting")
826
sys.exit()
637
827
638
clients.update(Set(Client(name=section, options=options,
828
clients.update(Set(Client(name = section,
639
829
stop_hook = remove_from_clients,
640
**(dict(client_config\
641
.items(section))))
830
config
831
= dict(client_config.items(section)))
642
832
for section in client_config.sections()))
643
644
if not debug:
645
daemon(False, False)
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
646
861
647
862
def cleanup():
648
863
"Cleanup function; run on exit"
649
864
global group
650
# From the Avahi server example code
865
# From the Avahi example code
651
866
if not group is None:
652
867
group.Free()
653
868
group = None
654
869
# End of Avahi example code
655
870
656
for client in clients:
871
while clients:
872
client = clients.pop()
657
873
client.stop_hook = None
658
874
client.stop()
659
875
661
877
662
878
if not debug:
663
879
signal.signal(signal.SIGINT, signal.SIG_IGN)
664
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
665
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
880
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
881
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
666
882
667
883
for client in clients:
668
884
client.start()
669
885
670
tcp_server = IPv6_TCPServer((None, options.port),
671
tcp_handler,
672
options=options,
673
clients=clients)
674
# Find out what random port we got
675
servicePort = tcp_server.socket.getsockname()[1]
676
logger.debug(u"Now listening on port %d", servicePort)
677
678
if options.interface is not None:
679
serviceInterface = if_nametoindex(options.interface)
680
681
# From the Avahi server example code
682
server.connect_to_signal("StateChanged", server_state_changed)
683
try:
684
server_state_changed(server.GetState())
685
except dbus.exceptions.DBusException, error:
686
logger.critical(u"DBusException: %s", error)
687
killme(1)
688
# End of Avahi example code
689
690
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
691
lambda *args, **kwargs:
692
tcp_server.handle_request(*args[2:],
693
**kwargs) or True)
694
try:
695
main_loop_started = 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
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")
696
912
main_loop.run()
913
except AvahiError, error:
914
logger.critical(u"AvahiError: %s" + unicode(error))
915
sys.exit(1)
697
916
except KeyboardInterrupt:
698
917
if debug:
699
918
print
700
701
sys.exit(exitstatus)
919
920
if __name__ == '__main__':
921
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0