To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 153
- compare with another revision
- download diff
- download tarball
- view history from revision 153
- Committer: Teddy Hogeborn
- Date: 2008-09-04 07:30:58 UTC
- mfrom: (24.1.87 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080904073058-h21spydersnh8jml
* README: Improved wording.
- files added:
- .bzrignore
- files removed:
- ca.pem
- files renamed:
- mandos-clients.conf => clients.conf
- server.py => mandos
- plugbasedclient.c => plugin-runner.c
- plugins.d/passprompt.c => plugins.d/password-prompt.c
- plugins.d/mandosclient.c => plugins.d/password-request.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 © 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
#
3
32
4
33
from __future__ import division
5
34
24
53
import subprocess
25
54
import atexit
26
55
import stat
56
import logging
57
import logging.handlers
27
58
28
59
import dbus
29
60
import gobject
31
62
from dbus.mainloop.glib import DBusGMainLoop
32
63
import ctypes
33
64
34
import logging
35
import logging.handlers
65
version = "1.0"
36
66
37
67
logger = logging.Logger('mandos')
38
68
syslogger = logging.handlers.SysLogHandler\
39
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
69
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
70
address = "/dev/log")
40
71
syslogger.setFormatter(logging.Formatter\
41
('%(levelname)s: %(message)s'))
72
('Mandos: %(levelname)s: %(message)s'))
42
73
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
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
59
168
# End of Avahi example code
60
169
61
170
66
175
fingerprint: string (40 or 32 hexadecimal digits); used to
67
176
uniquely identify the client
68
177
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
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
74
183
interval: datetime.timedelta(); How often to start a new checker
75
184
stop_hook: If set, called by stop() as stop_hook(self)
76
185
checker: subprocess.Popen(); a running checker process used
77
186
to see if the client lives.
78
Is None if no process is running.
187
'None' if no process is running.
79
188
checker_initiator_tag: a gobject event source tag, or None
80
189
stop_initiator_tag: - '' -
81
190
checker_callback_tag: - '' -
82
191
checker_command: string; External command which is run to check if
83
client lives. %()s expansions are done at
192
client lives. %() expansions are done at
84
193
runtime with vars(self) as dict, so that for
85
194
instance %(name)s can be used in the command.
86
195
Private attibutes:
87
196
_timeout: Real variable for 'timeout'
88
197
_interval: Real variable for 'interval'
89
_timeout_milliseconds: Used by gobject.timeout_add()
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
90
199
_interval_milliseconds: - '' -
91
200
"""
92
201
def _set_timeout(self, timeout):
112
221
interval = property(lambda self: self._interval,
113
222
_set_interval)
114
223
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):
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."""
118
228
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)
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"])
127
240
self.secret = sf.read()
128
241
sf.close()
129
242
else:
130
raise RuntimeError(u"No secret or secfile for client %s"
131
% self.name)
132
self.fqdn = fqdn # string
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.host = config.get("host", "")
133
246
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)
247
self.last_checked_ok = None
248
self.timeout = string_to_delta(config["timeout"])
249
self.interval = string_to_delta(config["interval"])
143
250
self.stop_hook = stop_hook
144
251
self.checker = None
145
252
self.checker_initiator_tag = None
146
253
self.stop_initiator_tag = None
147
254
self.checker_callback_tag = None
148
self.check_command = checker
255
self.check_command = config["checker"]
149
256
def start(self):
150
"""Start this clients checker and timeout hooks"""
257
"""Start this client's checker and timeout hooks"""
151
258
# Schedule a new checker to be started an 'interval' from now,
152
259
# and every interval from then on.
153
260
self.checker_initiator_tag = gobject.timeout_add\
161
268
self.stop)
162
269
def stop(self):
163
270
"""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:
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):
169
280
gobject.source_remove(self.stop_initiator_tag)
170
281
self.stop_initiator_tag = None
171
if self.checker_initiator_tag:
282
if getattr(self, "checker_initiator_tag", False):
172
283
gobject.source_remove(self.checker_initiator_tag)
173
284
self.checker_initiator_tag = None
174
285
self.stop_checker()
177
288
# Do not run this again if called by a gobject.timeout_add
178
289
return False
179
290
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()
291
self.stop_hook = None
292
self.stop()
190
293
def checker_callback(self, pid, condition):
191
294
"""The checker has completed, so take appropriate actions."""
192
295
now = datetime.datetime.now()
296
self.checker_callback_tag = None
297
self.checker = None
193
298
if os.WIFEXITED(condition) \
194
299
and (os.WEXITSTATUS(condition) == 0):
195
logger.debug(u"Checker for %(name)s succeeded",
196
vars(self))
197
self.last_seen = now
300
logger.info(u"Checker for %(name)s succeeded",
301
vars(self))
302
self.last_checked_ok = now
198
303
gobject.source_remove(self.stop_initiator_tag)
199
304
self.stop_initiator_tag = gobject.timeout_add\
200
305
(self._timeout_milliseconds,
203
308
logger.warning(u"Checker for %(name)s crashed?",
204
309
vars(self))
205
310
else:
206
logger.debug(u"Checker for %(name)s failed",
207
vars(self))
208
self.checker = None
209
self.checker_callback_tag = None
311
logger.info(u"Checker for %(name)s failed",
312
vars(self))
210
313
def start_checker(self):
211
314
"""Start a new checker subprocess if one is not running.
212
315
If a checker already exists, leave it running and do
213
316
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.
214
325
if self.checker is None:
215
326
try:
216
command = self.check_command % self.fqdn
327
# In case check_command has exactly one % operator
328
command = self.check_command % self.host
217
329
except TypeError:
330
# Escape attributes for the shell
218
331
escaped_attrs = dict((key, re.escape(str(val)))
219
332
for key, val in
220
333
vars(self).iteritems())
221
334
try:
222
335
command = self.check_command % escaped_attrs
223
336
except TypeError, error:
224
logger.critical(u'Could not format string "%s":'
225
u' %s', self.check_command, error)
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
226
339
return True # Try again later
227
340
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="/")
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="/")
234
350
self.checker_callback_tag = gobject.child_watch_add\
235
351
(self.checker.pid,
236
352
self.checker_callback)
237
except subprocess.OSError, error:
353
except OSError, error:
238
354
logger.error(u"Failed to start subprocess: %s",
239
355
error)
240
356
# Re-run this periodically if run by gobject.timeout_add
241
357
return True
242
358
def stop_checker(self):
243
359
"""Force the checker process, if any, to stop."""
244
if not hasattr(self, "checker") or self.checker is None:
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:
245
364
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)
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
251
374
self.checker = None
252
def still_valid(self, now=None):
375
def still_valid(self):
253
376
"""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:
377
now = datetime.datetime.now()
378
if self.last_checked_ok is None:
257
379
return now < (self.created + self.timeout)
258
380
else:
259
return now < (self.last_seen + self.timeout)
381
return now < (self.last_checked_ok + self.timeout)
260
382
261
383
262
384
def peer_certificate(session):
263
"Return an OpenPGP data packet string for the peer's certificate"
385
"Return the peer's OpenPGP certificate as a bytestring"
264
386
# If not an OpenPGP certificate...
265
387
if gnutls.library.functions.gnutls_certificate_type_get\
266
388
(session._c_object) \
277
399
278
400
279
401
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))
402
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
285
403
# New GnuTLS "datum" with the OpenPGP public key
286
404
datum = gnutls.library.types.gnutls_datum_t\
287
405
(ctypes.cast(ctypes.c_char_p(openpgp),
288
406
ctypes.POINTER(ctypes.c_ubyte)),
289
407
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))
290
412
# 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)
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")
295
423
# New buffer for the fingerprint
296
424
buffer = ctypes.create_string_buffer(20)
297
425
buffer_length = ctypes.c_size_t()
313
441
Note: This will run in its own forked process."""
314
442
315
443
def handle(self):
316
logger.debug(u"TCP connection from: %s",
444
logger.info(u"TCP connection from: %s",
317
445
unicode(self.client_address))
318
session = gnutls.connection.ClientSession(self.request,
319
gnutls.connection.\
320
X509Credentials())
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.
321
462
322
463
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
323
464
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
324
465
# "+DHE-DSS"))
325
priority = "SECURE256"
326
466
priority = "NORMAL" # Fallback default, since this
467
# MUST be set.
468
if self.server.settings["priority"]:
469
priority = self.server.settings["priority"]
327
470
gnutls.library.functions.gnutls_priority_set_direct\
328
471
(session._c_object, priority, None);
329
472
330
473
try:
331
474
session.handshake()
332
475
except gnutls.errors.GNUTLSError, error:
333
logger.debug(u"Handshake failed: %s", error)
476
logger.warning(u"Handshake failed: %s", error)
334
477
# Do not run session.bye() here: the session is not
335
478
# established. Just abandon the request.
336
479
return
337
480
try:
338
481
fpr = fingerprint(peer_certificate(session))
339
482
except (TypeError, gnutls.errors.GNUTLSError), error:
340
logger.debug(u"Bad certificate: %s", error)
483
logger.warning(u"Bad certificate: %s", error)
341
484
session.bye()
342
485
return
343
486
logger.debug(u"Fingerprint: %s", fpr)
344
487
client = None
345
for c in clients:
488
for c in self.server.clients:
346
489
if c.fingerprint == fpr:
347
490
client = c
348
491
break
492
if not client:
493
logger.warning(u"Client not found for fingerprint: %s",
494
fpr)
495
session.bye()
496
return
349
497
# Have to check if client.still_valid(), since it is possible
350
498
# that the client timed out while establishing the GnuTLS
351
499
# 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)
500
if not client.still_valid():
501
logger.warning(u"Client %(name)s is invalid",
502
vars(client))
359
503
session.bye()
360
504
return
361
505
sent_size = 0
371
515
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
372
516
"""IPv6 TCP server. Accepts 'None' as address and/or port.
373
517
Attributes:
374
options: Command line options
518
settings: Server settings
375
519
clients: Set() of Client objects
376
520
"""
377
521
address_family = socket.AF_INET6
378
522
def __init__(self, *args, **kwargs):
379
if "options" in kwargs:
380
self.options = kwargs["options"]
381
del kwargs["options"]
523
if "settings" in kwargs:
524
self.settings = kwargs["settings"]
525
del kwargs["settings"]
382
526
if "clients" in kwargs:
383
527
self.clients = kwargs["clients"]
384
528
del kwargs["clients"]
387
531
"""This overrides the normal server_bind() function
388
532
to bind to an interface if one was specified, and also NOT to
389
533
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
534
if self.settings["interface"]:
535
# 25 is from /usr/include/asm-i486/socket.h
536
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
394
537
try:
395
538
self.socket.setsockopt(socket.SOL_SOCKET,
396
socket.SO_BINDTODEVICE,
397
self.options.interface)
539
SO_BINDTODEVICE,
540
self.settings["interface"])
398
541
except socket.error, error:
399
542
if error[0] == errno.EPERM:
400
logger.warning(u"No permission to"
401
u" bind to interface %s",
402
self.options.interface)
543
logger.error(u"No permission to"
544
u" bind to interface %s",
545
self.settings["interface"])
403
546
else:
404
547
raise error
405
548
# Only bind(2) the socket if we really need to.
408
551
in6addr_any = "::"
409
552
self.server_address = (in6addr_any,
410
553
self.server_address[1])
411
elif self.server_address[1] is None:
554
elif not self.server_address[1]:
412
555
self.server_address = (self.server_address[0],
413
556
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"]))
414
564
return super(type(self), self).server_bind()
415
565
416
566
427
577
datetime.timedelta(1)
428
578
>>> string_to_delta(u'1w')
429
579
datetime.timedelta(7)
580
>>> string_to_delta('5m 30s')
581
datetime.timedelta(0, 330)
430
582
"""
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:
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):
445
601
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()
602
timevalue += delta
603
return timevalue
482
604
483
605
484
606
def server_state_changed(state):
485
"""From the Avahi server example code"""
607
"""Derived from the Avahi example code"""
486
608
if state == avahi.SERVER_COLLISION:
487
logger.warning(u"Server name collision")
488
remove_service()
609
logger.error(u"Zeroconf server name collision")
610
service.remove()
489
611
elif state == avahi.SERVER_RUNNING:
490
add_service()
612
service.add()
491
613
492
614
493
615
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)
616
"""Derived from the Avahi example code"""
617
logger.debug(u"Avahi state change: %i", state)
498
618
499
619
if state == avahi.ENTRY_GROUP_ESTABLISHED:
500
logger.debug(u"Service established.")
620
logger.debug(u"Zeroconf service established.")
501
621
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)
622
logger.warning(u"Zeroconf service name collision.")
623
service.rename()
515
624
elif state == avahi.ENTRY_GROUP_FAILURE:
516
logger.error(u"Error in group state changed %s",
517
unicode(error))
518
killme(1)
519
625
logger.critical(u"Avahi: Error in group state changed %s",
626
unicode(error))
627
raise AvahiGroupError("State changed: %s", str(error))
520
628
521
629
def if_nametoindex(interface):
522
"""Call the C function if_nametoindex()"""
630
"""Call the C function if_nametoindex(), or equivalent"""
631
global if_nametoindex
523
632
try:
524
libc = ctypes.cdll.LoadLibrary("libc.so.6")
525
return libc.if_nametoindex(interface)
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
526
637
except (OSError, AttributeError):
527
638
if "struct" not in sys.modules:
528
639
import struct
529
640
if "fcntl" not in sys.modules:
530
641
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):
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):
541
655
"""See daemon(3). Standard BSD Unix function.
542
656
This should really exist as os.daemon, but it doesn't (yet)."""
543
657
if os.fork():
545
659
os.setsid()
546
660
if not nochdir:
547
661
os.chdir("/")
662
if os.fork():
663
sys.exit()
548
664
if not noclose:
549
665
# Close all standard open file descriptors
550
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
666
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
551
667
if not stat.S_ISCHR(os.fstat(null).st_mode):
552
668
raise OSError(errno.ENODEV,
553
669
"/dev/null not a character device")
558
674
os.close(null)
559
675
560
676
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
677
def main():
678
global main_loop_started
572
679
main_loop_started = False
573
parser = OptionParser()
680
681
parser = OptionParser(version = "%%prog %s" % version)
574
682
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,
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",
578
687
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
688
parser.add_option("--check", action="store_true", default=False,
586
689
help="Run self-test")
587
parser.add_option("--debug", action="store_true", default=False,
588
help="Debug mode")
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")
589
701
(options, args) = parser.parse_args()
590
702
591
703
if options.check:
593
705
doctest.testmod()
594
706
sys.exit()
595
707
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
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
613
772
DBusGMainLoop(set_as_default=True )
614
773
main_loop = gobject.MainLoop()
615
774
bus = dbus.SystemBus()
616
server = dbus.Interface(
617
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
618
avahi.DBUS_INTERFACE_SERVER )
775
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
776
avahi.DBUS_PATH_SERVER),
777
avahi.DBUS_INTERFACE_SERVER)
619
778
# End of Avahi example code
620
779
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
780
clients = Set()
632
781
def remove_from_clients(client):
633
782
clients.remove(client)
634
783
if not clients:
635
logger.debug(u"No clients left, exiting")
636
killme()
784
logger.critical(u"No clients left, exiting")
785
sys.exit()
637
786
638
clients.update(Set(Client(name=section, options=options,
787
clients.update(Set(Client(name = section,
639
788
stop_hook = remove_from_clients,
640
**(dict(client_config\
641
.items(section))))
789
config
790
= dict(client_config.items(section)))
642
791
for section in client_config.sections()))
643
644
if not debug:
645
daemon(False, False)
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())
646
818
647
819
def cleanup():
648
820
"Cleanup function; run on exit"
649
821
global group
650
# From the Avahi server example code
822
# From the Avahi example code
651
823
if not group is None:
652
824
group.Free()
653
825
group = None
654
826
# End of Avahi example code
655
827
656
for client in clients:
828
while clients:
829
client = clients.pop()
657
830
client.stop_hook = None
658
831
client.stop()
659
832
661
834
662
835
if not debug:
663
836
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())
837
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
838
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
666
839
667
840
for client in clients:
668
841
client.start()
669
842
670
tcp_server = IPv6_TCPServer((None, options.port),
843
tcp_server = IPv6_TCPServer((server_settings["address"],
844
server_settings["port"]),
671
845
tcp_handler,
672
options=options,
846
settings=server_settings,
673
847
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:
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")
695
871
main_loop_started = True
696
872
main_loop.run()
873
except AvahiError, error:
874
logger.critical(u"AvahiError: %s" + unicode(error))
875
sys.exit(1)
697
876
except KeyboardInterrupt:
698
877
if debug:
699
878
print
700
701
sys.exit(exitstatus)
879
880
if __name__ == '__main__':
881
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0