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