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 24.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.1
- Committer: Björn Påhlsson
- Date: 2008-07-22 05:26:44 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 26.
- Revision ID: belorn@braxen-20080722052644-tq76a3jnr2ea1jez
Added syntax and support for plugbasedclient arguments and how they
are passed on to the plugins.
are passed on to the plugins.
- 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
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
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".
9
# following functions: "add_service", "remove_service",
10
# "server_state_changed", "entry_group_state_changed", and some lines
11
# in "main".
12
12
#
13
# Everything else is
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
13
# Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
14
# Påhlsson.
15
15
#
16
16
# This program is free software: you can redistribute it and/or modify
17
17
# it under the terms of the GNU General Public License as published by
24
24
# GNU General Public License for more details.
25
25
#
26
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/>.
27
# along with this program. If not, see <http://www.gnu.org/licenses/>.
29
28
#
30
# Contact the authors at <mandos@fukt.bsnet.se>.
29
# Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
30
# <https://www.fukt.bsnet.se/~teddy/>.
31
31
#
32
32
33
33
from __future__ import division
62
62
from dbus.mainloop.glib import DBusGMainLoop
63
63
import ctypes
64
64
65
version = "1.0"
65
# Brief description of the operation of this program:
66
#
67
# This server announces itself as a Zeroconf service. Connecting
68
# clients use the TLS protocol, with the unusual quirk that this
69
# server program acts as a TLS "client" while the connecting clients
70
# acts as a TLS "server". The clients (acting as a TLS "server") must
71
# supply an OpenPGP certificate, and the fingerprint of this
72
# certificate is used by this server to look up (in a list read from a
73
# file at start time) which binary blob to give the client. No other
74
# authentication or authorization is done by this server.
75
66
76
67
77
logger = logging.Logger('mandos')
68
78
syslogger = logging.handlers.SysLogHandler\
69
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
70
address = "/dev/log")
79
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
71
80
syslogger.setFormatter(logging.Formatter\
72
('Mandos: %(levelname)s: %(message)s'))
81
('%(levelname)s: %(message)s'))
73
82
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
83
del syslogger
84
85
# This variable is used to optionally bind to a specified interface.
86
# It is a global variable to fit in with the other variables from the
87
# Avahi example code.
88
serviceInterface = avahi.IF_UNSPEC
166
89
# From the Avahi example code:
167
group = None # our entry group
90
serviceName = "Mandos"
91
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
92
servicePort = None # Not known at startup
93
serviceTXT = [] # TXT record for the service
94
domain = "" # Domain to publish on, default to .local
95
host = "" # Host to publish records for, default to localhost
96
group = None #our entry group
97
rename_count = 12 # Counter so we only rename after collisions a
98
# sensible number of times
168
99
# End of Avahi example code
169
100
170
101
175
106
fingerprint: string (40 or 32 hexadecimal digits); used to
176
107
uniquely identify the client
177
108
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
109
fqdn: string (FQDN); available for use by the checker command
110
created: datetime.datetime()
111
last_seen: datetime.datetime() or None if not yet seen
112
timeout: datetime.timedelta(); How long from last_seen until
113
this client is invalid
183
114
interval: datetime.timedelta(); How often to start a new checker
184
115
stop_hook: If set, called by stop() as stop_hook(self)
185
116
checker: subprocess.Popen(); a running checker process used
186
117
to see if the client lives.
187
'None' if no process is running.
118
Is None if no process is running.
188
119
checker_initiator_tag: a gobject event source tag, or None
189
120
stop_initiator_tag: - '' -
190
121
checker_callback_tag: - '' -
191
122
checker_command: string; External command which is run to check if
192
client lives. %() expansions are done at
123
client lives. %()s expansions are done at
193
124
runtime with vars(self) as dict, so that for
194
125
instance %(name)s can be used in the command.
195
126
Private attibutes:
196
127
_timeout: Real variable for 'timeout'
197
128
_interval: Real variable for 'interval'
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
129
_timeout_milliseconds: Used by gobject.timeout_add()
199
130
_interval_milliseconds: - '' -
200
131
"""
201
132
def _set_timeout(self, timeout):
221
152
interval = property(lambda self: self._interval,
222
153
_set_interval)
223
154
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."""
155
def __init__(self, name=None, options=None, stop_hook=None,
156
fingerprint=None, secret=None, secfile=None,
157
fqdn=None, timeout=None, interval=-1, checker=None):
158
"""Note: the 'checker' argument sets the 'checker_command'
159
attribute and not the 'checker' attribute.."""
228
160
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"])
161
# Uppercase and remove spaces from fingerprint
162
# for later comparison purposes with return value of
163
# the fingerprint() function
164
self.fingerprint = fingerprint.upper().replace(u" ", u"")
165
if secret:
166
self.secret = secret.decode(u"base64")
167
elif secfile:
168
sf = open(secfile)
240
169
self.secret = sf.read()
241
170
sf.close()
242
171
else:
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.host = config.get("host", "")
172
raise RuntimeError(u"No secret or secfile for client %s"
173
% self.name)
174
self.fqdn = fqdn # string
246
175
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"])
176
self.last_seen = None
177
if timeout is None:
178
self.timeout = options.timeout
179
else:
180
self.timeout = string_to_delta(timeout)
181
if interval == -1:
182
self.interval = options.interval
183
else:
184
self.interval = string_to_delta(interval)
250
185
self.stop_hook = stop_hook
251
186
self.checker = None
252
187
self.checker_initiator_tag = None
253
188
self.stop_initiator_tag = None
254
189
self.checker_callback_tag = None
255
self.check_command = config["checker"]
190
self.check_command = checker
256
191
def start(self):
257
192
"""Start this client's checker and timeout hooks"""
258
193
# Schedule a new checker to be started an 'interval' from now,
268
203
self.stop)
269
204
def stop(self):
270
205
"""Stop this client.
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
206
The possibility that this client might be restarted is left
207
open, but not currently used."""
273
208
# 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)
209
if self.secret:
210
logger.debug(u"Stopping client %s", self.name)
276
211
self.secret = None
277
212
else:
278
213
return False
279
if getattr(self, "stop_initiator_tag", False):
214
if hasattr(self, "stop_initiator_tag") \
215
and self.stop_initiator_tag:
280
216
gobject.source_remove(self.stop_initiator_tag)
281
217
self.stop_initiator_tag = None
282
if getattr(self, "checker_initiator_tag", False):
218
if hasattr(self, "checker_initiator_tag") \
219
and self.checker_initiator_tag:
283
220
gobject.source_remove(self.checker_initiator_tag)
284
221
self.checker_initiator_tag = None
285
222
self.stop_checker()
297
234
self.checker = None
298
235
if os.WIFEXITED(condition) \
299
236
and (os.WEXITSTATUS(condition) == 0):
300
logger.info(u"Checker for %(name)s succeeded",
301
vars(self))
302
self.last_checked_ok = now
237
logger.debug(u"Checker for %(name)s succeeded",
238
vars(self))
239
self.last_seen = now
303
240
gobject.source_remove(self.stop_initiator_tag)
304
241
self.stop_initiator_tag = gobject.timeout_add\
305
242
(self._timeout_milliseconds,
308
245
logger.warning(u"Checker for %(name)s crashed?",
309
246
vars(self))
310
247
else:
311
logger.info(u"Checker for %(name)s failed",
312
vars(self))
248
logger.debug(u"Checker for %(name)s failed",
249
vars(self))
313
250
def start_checker(self):
314
251
"""Start a new checker subprocess if one is not running.
315
252
If a checker already exists, leave it running and do
324
261
# is as it should be.
325
262
if self.checker is None:
326
263
try:
327
# In case check_command has exactly one % operator
328
command = self.check_command % self.host
264
command = self.check_command % self.fqdn
329
265
except TypeError:
330
# Escape attributes for the shell
331
266
escaped_attrs = dict((key, re.escape(str(val)))
332
267
for key, val in
333
268
vars(self).iteritems())
334
269
try:
335
270
command = self.check_command % escaped_attrs
336
271
except TypeError, error:
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
272
logger.critical(u'Could not format string "%s":'
273
u' %s', self.check_command, error)
339
274
return True # Try again later
340
275
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="/")
276
logger.debug(u"Starting checker %r for %s",
277
command, self.name)
278
self.checker = subprocess.\
279
Popen(command,
280
close_fds=True, shell=True,
281
cwd="/")
350
282
self.checker_callback_tag = gobject.child_watch_add\
351
283
(self.checker.pid,
352
284
self.checker_callback)
353
except OSError, error:
285
except subprocess.OSError, error:
354
286
logger.error(u"Failed to start subprocess: %s",
355
287
error)
356
288
# Re-run this periodically if run by gobject.timeout_add
360
292
if self.checker_callback_tag:
361
293
gobject.source_remove(self.checker_callback_tag)
362
294
self.checker_callback_tag = None
363
if getattr(self, "checker", None) is None:
295
if not hasattr(self, "checker") or self.checker is None:
364
296
return
365
logger.debug(u"Stopping checker for %(name)s", vars(self))
297
logger.debug("Stopping checker for %(name)s", vars(self))
366
298
try:
367
299
os.kill(self.checker.pid, signal.SIGTERM)
368
300
#os.sleep(0.5)
369
301
#if self.checker.poll() is None:
370
302
# os.kill(self.checker.pid, signal.SIGKILL)
371
303
except OSError, error:
372
if error.errno != errno.ESRCH: # No such process
304
if error.errno != errno.ESRCH:
373
305
raise
374
306
self.checker = None
375
def still_valid(self):
307
def still_valid(self, now=None):
376
308
"""Has the timeout not yet passed for this client?"""
377
now = datetime.datetime.now()
378
if self.last_checked_ok is None:
309
if now is None:
310
now = datetime.datetime.now()
311
if self.last_seen is None:
379
312
return now < (self.created + self.timeout)
380
313
else:
381
return now < (self.last_checked_ok + self.timeout)
314
return now < (self.last_seen + self.timeout)
382
315
383
316
384
317
def peer_certificate(session):
400
333
401
334
def fingerprint(openpgp):
402
335
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
336
# New empty GnuTLS certificate
337
crt = gnutls.library.types.gnutls_openpgp_crt_t()
338
gnutls.library.functions.gnutls_openpgp_crt_init\
339
(ctypes.byref(crt))
403
340
# New GnuTLS "datum" with the OpenPGP public key
404
341
datum = gnutls.library.types.gnutls_datum_t\
405
342
(ctypes.cast(ctypes.c_char_p(openpgp),
406
343
ctypes.POINTER(ctypes.c_ubyte)),
407
344
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
345
# 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")
346
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
347
(crt,
348
ctypes.byref(datum),
349
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
423
350
# New buffer for the fingerprint
424
351
buffer = ctypes.create_string_buffer(20)
425
352
buffer_length = ctypes.c_size_t()
441
368
Note: This will run in its own forked process."""
442
369
443
370
def handle(self):
444
logger.info(u"TCP connection from: %s",
371
logger.debug(u"TCP connection from: %s",
445
372
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.
373
session = gnutls.connection.ClientSession(self.request,
374
gnutls.connection.\
375
X509Credentials())
462
376
463
377
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
464
378
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
465
379
# "+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"]
380
priority = "SECURE256"
381
470
382
gnutls.library.functions.gnutls_priority_set_direct\
471
383
(session._c_object, priority, None);
472
384
473
385
try:
474
386
session.handshake()
475
387
except gnutls.errors.GNUTLSError, error:
476
logger.warning(u"Handshake failed: %s", error)
388
logger.debug(u"Handshake failed: %s", error)
477
389
# Do not run session.bye() here: the session is not
478
390
# established. Just abandon the request.
479
391
return
480
392
try:
481
393
fpr = fingerprint(peer_certificate(session))
482
394
except (TypeError, gnutls.errors.GNUTLSError), error:
483
logger.warning(u"Bad certificate: %s", error)
395
logger.debug(u"Bad certificate: %s", error)
484
396
session.bye()
485
397
return
486
398
logger.debug(u"Fingerprint: %s", fpr)
489
401
if c.fingerprint == fpr:
490
402
client = c
491
403
break
492
if not client:
493
logger.warning(u"Client not found for fingerprint: %s",
494
fpr)
495
session.bye()
496
return
497
404
# Have to check if client.still_valid(), since it is possible
498
405
# that the client timed out while establishing the GnuTLS
499
406
# session.
500
if not client.still_valid():
501
logger.warning(u"Client %(name)s is invalid",
502
vars(client))
407
if (not client) or (not client.still_valid()):
408
if client:
409
logger.debug(u"Client %(name)s is invalid",
410
vars(client))
411
else:
412
logger.debug(u"Client not found for fingerprint: %s",
413
fpr)
503
414
session.bye()
504
415
return
505
416
sent_size = 0
515
426
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
516
427
"""IPv6 TCP server. Accepts 'None' as address and/or port.
517
428
Attributes:
518
settings: Server settings
429
options: Command line options
519
430
clients: Set() of Client objects
520
431
"""
521
432
address_family = socket.AF_INET6
522
433
def __init__(self, *args, **kwargs):
523
if "settings" in kwargs:
524
self.settings = kwargs["settings"]
525
del kwargs["settings"]
434
if "options" in kwargs:
435
self.options = kwargs["options"]
436
del kwargs["options"]
526
437
if "clients" in kwargs:
527
438
self.clients = kwargs["clients"]
528
439
del kwargs["clients"]
531
442
"""This overrides the normal server_bind() function
532
443
to bind to an interface if one was specified, and also NOT to
533
444
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)
445
if self.options.interface:
446
if not hasattr(socket, "SO_BINDTODEVICE"):
447
# From /usr/include/asm-i486/socket.h
448
socket.SO_BINDTODEVICE = 25
537
449
try:
538
450
self.socket.setsockopt(socket.SOL_SOCKET,
539
SO_BINDTODEVICE,
540
self.settings["interface"])
451
socket.SO_BINDTODEVICE,
452
self.options.interface)
541
453
except socket.error, error:
542
454
if error[0] == errno.EPERM:
543
logger.error(u"No permission to"
544
u" bind to interface %s",
545
self.settings["interface"])
455
logger.warning(u"No permission to"
456
u" bind to interface %s",
457
self.options.interface)
546
458
else:
547
459
raise error
548
460
# Only bind(2) the socket if we really need to.
551
463
in6addr_any = "::"
552
464
self.server_address = (in6addr_any,
553
465
self.server_address[1])
554
elif not self.server_address[1]:
466
elif self.server_address[1] is None:
555
467
self.server_address = (self.server_address[0],
556
468
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
469
return super(type(self), self).server_bind()
565
470
566
471
577
482
datetime.timedelta(1)
578
483
>>> string_to_delta(u'1w')
579
484
datetime.timedelta(7)
580
>>> string_to_delta('5m 30s')
581
datetime.timedelta(0, 330)
582
485
"""
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):
486
try:
487
suffix=unicode(interval[-1])
488
value=int(interval[:-1])
489
if suffix == u"d":
490
delta = datetime.timedelta(value)
491
elif suffix == u"s":
492
delta = datetime.timedelta(0, value)
493
elif suffix == u"m":
494
delta = datetime.timedelta(0, 0, 0, 0, value)
495
elif suffix == u"h":
496
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
497
elif suffix == u"w":
498
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
499
else:
601
500
raise ValueError
602
timevalue += delta
603
return timevalue
501
except (ValueError, IndexError):
502
raise ValueError
503
return delta
504
505
506
def add_service():
507
"""Derived from the Avahi example code"""
508
global group, serviceName, serviceType, servicePort, serviceTXT, \
509
domain, host
510
if group is None:
511
group = dbus.Interface(
512
bus.get_object( avahi.DBUS_NAME,
513
server.EntryGroupNew()),
514
avahi.DBUS_INTERFACE_ENTRY_GROUP)
515
group.connect_to_signal('StateChanged',
516
entry_group_state_changed)
517
logger.debug(u"Adding service '%s' of type '%s' ...",
518
serviceName, serviceType)
519
520
group.AddService(
521
serviceInterface, # interface
522
avahi.PROTO_INET6, # protocol
523
dbus.UInt32(0), # flags
524
serviceName, serviceType,
525
domain, host,
526
dbus.UInt16(servicePort),
527
avahi.string_array_to_txt_array(serviceTXT))
528
group.Commit()
529
530
531
def remove_service():
532
"""From the Avahi example code"""
533
global group
534
535
if not group is None:
536
group.Reset()
604
537
605
538
606
539
def server_state_changed(state):
607
540
"""Derived from the Avahi example code"""
608
541
if state == avahi.SERVER_COLLISION:
609
logger.error(u"Zeroconf server name collision")
610
service.remove()
542
logger.warning(u"Server name collision")
543
remove_service()
611
544
elif state == avahi.SERVER_RUNNING:
612
service.add()
545
add_service()
613
546
614
547
615
548
def entry_group_state_changed(state, error):
616
549
"""Derived from the Avahi example code"""
617
logger.debug(u"Avahi state change: %i", state)
550
global serviceName, server, rename_count
551
552
logger.debug(u"state change: %i", state)
618
553
619
554
if state == avahi.ENTRY_GROUP_ESTABLISHED:
620
logger.debug(u"Zeroconf service established.")
555
logger.debug(u"Service established.")
621
556
elif state == avahi.ENTRY_GROUP_COLLISION:
622
logger.warning(u"Zeroconf service name collision.")
623
service.rename()
557
558
rename_count = rename_count - 1
559
if rename_count > 0:
560
name = server.GetAlternativeServiceName(name)
561
logger.warning(u"Service name collision, "
562
u"changing name to '%s' ...", name)
563
remove_service()
564
add_service()
565
566
else:
567
logger.error(u"No suitable service name found after %i"
568
u" retries, exiting.", n_rename)
569
killme(1)
624
570
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))
571
logger.error(u"Error in group state changed %s",
572
unicode(error))
573
killme(1)
574
628
575
629
576
def if_nametoindex(interface):
630
"""Call the C function if_nametoindex(), or equivalent"""
631
global if_nametoindex
577
"""Call the C function if_nametoindex()"""
632
578
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
579
libc = ctypes.cdll.LoadLibrary("libc.so.6")
580
return libc.if_nametoindex(interface)
637
581
except (OSError, AttributeError):
638
582
if "struct" not in sys.modules:
639
583
import struct
640
584
if "fcntl" not in sys.modules:
641
585
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):
586
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
587
s = socket.socket()
588
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
589
struct.pack("16s16x", interface))
590
s.close()
591
interface_index = struct.unpack("I", ifreq[16:20])[0]
592
return interface_index
593
594
595
def daemon(nochdir, noclose):
655
596
"""See daemon(3). Standard BSD Unix function.
656
597
This should really exist as os.daemon, but it doesn't (yet)."""
657
598
if os.fork():
659
600
os.setsid()
660
601
if not nochdir:
661
602
os.chdir("/")
662
if os.fork():
663
sys.exit()
664
603
if not noclose:
665
604
# Close all standard open file descriptors
666
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
605
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
667
606
if not stat.S_ISCHR(os.fstat(null).st_mode):
668
607
raise OSError(errno.ENODEV,
669
608
"/dev/null not a character device")
674
613
os.close(null)
675
614
676
615
616
def killme(status = 0):
617
logger.debug("Stopping server with exit status %d", status)
618
exitstatus = status
619
if main_loop_started:
620
main_loop.quit()
621
else:
622
sys.exit(status)
623
624
677
625
def main():
626
global exitstatus
627
exitstatus = 0
678
628
global main_loop_started
679
629
main_loop_started = False
680
630
681
parser = OptionParser(version = "%%prog %s" % version)
631
parser = OptionParser()
682
632
parser.add_option("-i", "--interface", type="string",
683
metavar="IF", help="Bind to interface IF")
684
parser.add_option("-a", "--address", type="string",
633
default=None, metavar="IF",
634
help="Bind to interface IF")
635
parser.add_option("-a", "--address", type="string", default=None,
685
636
help="Address to listen for requests on")
686
parser.add_option("-p", "--port", type="int",
637
parser.add_option("-p", "--port", type="int", default=None,
687
638
help="Port number to receive requests on")
639
parser.add_option("--timeout", type="string", # Parsed later
640
default="1h",
641
help="Amount of downtime allowed for clients")
642
parser.add_option("--interval", type="string", # Parsed later
643
default="5m",
644
help="How often to check that a client is up")
688
645
parser.add_option("--check", action="store_true", default=False,
689
646
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")
647
parser.add_option("--debug", action="store_true", default=False,
648
help="Debug mode")
701
649
(options, args) = parser.parse_args()
702
650
703
651
if options.check:
705
653
doctest.testmod()
706
654
sys.exit()
707
655
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"])
656
# Parse the time arguments
657
try:
658
options.timeout = string_to_delta(options.timeout)
659
except ValueError:
660
parser.error("option --timeout: Unparseable time")
661
try:
662
options.interval = string_to_delta(options.interval)
663
except ValueError:
664
parser.error("option --interval: Unparseable time")
665
666
# Parse config file
667
defaults = { "checker": "fping -q -- %%(fqdn)s" }
668
client_config = ConfigParser.SafeConfigParser(defaults)
669
#client_config.readfp(open("global.conf"), "global.conf")
670
client_config.read("mandos-clients.conf")
767
671
768
672
global main_loop
769
673
global bus
772
676
DBusGMainLoop(set_as_default=True )
773
677
main_loop = gobject.MainLoop()
774
678
bus = dbus.SystemBus()
775
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
776
avahi.DBUS_PATH_SERVER),
777
avahi.DBUS_INTERFACE_SERVER)
679
server = dbus.Interface(
680
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
681
avahi.DBUS_INTERFACE_SERVER )
778
682
# End of Avahi example code
779
683
684
debug = options.debug
685
686
if debug:
687
console = logging.StreamHandler()
688
# console.setLevel(logging.DEBUG)
689
console.setFormatter(logging.Formatter\
690
('%(levelname)s: %(message)s'))
691
logger.addHandler(console)
692
del console
693
780
694
clients = Set()
781
695
def remove_from_clients(client):
782
696
clients.remove(client)
783
697
if not clients:
784
logger.critical(u"No clients left, exiting")
785
sys.exit()
698
logger.debug(u"No clients left, exiting")
699
killme()
786
700
787
clients.update(Set(Client(name = section,
701
clients.update(Set(Client(name=section, options=options,
788
702
stop_hook = remove_from_clients,
789
config
790
= dict(client_config.items(section)))
703
**(dict(client_config\
704
.items(section))))
791
705
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())
706
707
if not debug:
708
daemon(False, False)
818
709
819
710
def cleanup():
820
711
"Cleanup function; run on exit"
834
725
835
726
if not debug:
836
727
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())
728
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
729
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
839
730
840
731
for client in clients:
841
732
client.start()
842
733
843
tcp_server = IPv6_TCPServer((server_settings["address"],
844
server_settings["port"]),
734
tcp_server = IPv6_TCPServer((options.address, options.port),
845
735
tcp_handler,
846
settings=server_settings,
736
options=options,
847
737
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")
738
# Find out what random port we got
739
global servicePort
740
servicePort = tcp_server.socket.getsockname()[1]
741
logger.debug(u"Now listening on port %d", servicePort)
742
743
if options.interface is not None:
744
global serviceInterface
745
serviceInterface = if_nametoindex(options.interface)
746
747
# From the Avahi example code
748
server.connect_to_signal("StateChanged", server_state_changed)
749
try:
750
server_state_changed(server.GetState())
751
except dbus.exceptions.DBusException, error:
752
logger.critical(u"DBusException: %s", error)
753
killme(1)
754
# End of Avahi example code
755
756
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
757
lambda *args, **kwargs:
758
tcp_server.handle_request(*args[2:],
759
**kwargs) or True)
760
try:
761
logger.debug("Starting main loop")
871
762
main_loop_started = True
872
763
main_loop.run()
873
except AvahiError, error:
874
logger.critical(u"AvahiError: %s" + unicode(error))
875
sys.exit(1)
876
764
except KeyboardInterrupt:
877
765
if debug:
878
766
print
767
768
sys.exit(exitstatus)
879
769
880
770
if __name__ == '__main__':
881
771
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0