To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 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
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
# following functions: "add_service", "remove_service",
10
# "server_state_changed", "entry_group_state_changed", and some lines
11
# in "main".
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
12
#
13
# Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
14
# Påhlsson.
13
# Everything else is
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn 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 <http://www.gnu.org/licenses/>.
27
# along with this program. If not, see
28
# <http://www.gnu.org/licenses/>.
28
29
#
29
# Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
30
# <https://www.fukt.bsnet.se/~teddy/>.
30
# Contact the authors at <mandos@fukt.bsnet.se>.
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
# 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
65
version = "1.0"
76
66
77
67
logger = logging.Logger('mandos')
78
68
syslogger = logging.handlers.SysLogHandler\
79
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
69
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
70
address = "/dev/log")
80
71
syslogger.setFormatter(logging.Formatter\
81
('%(levelname)s: %(message)s'))
72
('Mandos: %(levelname)s: %(message)s'))
82
73
logger.addHandler(syslogger)
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
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
89
166
# From the Avahi example code:
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
167
group = None # our entry group
99
168
# End of Avahi example code
100
169
101
170
106
175
fingerprint: string (40 or 32 hexadecimal digits); used to
107
176
uniquely identify the client
108
177
secret: bytestring; sent verbatim (over TLS) to client
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
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
114
183
interval: datetime.timedelta(); How often to start a new checker
115
184
stop_hook: If set, called by stop() as stop_hook(self)
116
185
checker: subprocess.Popen(); a running checker process used
117
186
to see if the client lives.
118
Is None if no process is running.
187
'None' if no process is running.
119
188
checker_initiator_tag: a gobject event source tag, or None
120
189
stop_initiator_tag: - '' -
121
190
checker_callback_tag: - '' -
122
191
checker_command: string; External command which is run to check if
123
client lives. %()s expansions are done at
192
client lives. %() expansions are done at
124
193
runtime with vars(self) as dict, so that for
125
194
instance %(name)s can be used in the command.
126
195
Private attibutes:
127
196
_timeout: Real variable for 'timeout'
128
197
_interval: Real variable for 'interval'
129
_timeout_milliseconds: Used by gobject.timeout_add()
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
130
199
_interval_milliseconds: - '' -
131
200
"""
132
201
def _set_timeout(self, timeout):
152
221
interval = property(lambda self: self._interval,
153
222
_set_interval)
154
223
del _set_interval
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.."""
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."""
160
228
self.name = name
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)
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"])
169
240
self.secret = sf.read()
170
241
sf.close()
171
242
else:
172
raise RuntimeError(u"No secret or secfile for client %s"
173
% self.name)
174
self.fqdn = fqdn # string
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.host = config.get("host", "")
175
246
self.created = datetime.datetime.now()
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)
247
self.last_checked_ok = None
248
self.timeout = string_to_delta(config["timeout"])
249
self.interval = string_to_delta(config["interval"])
185
250
self.stop_hook = stop_hook
186
251
self.checker = None
187
252
self.checker_initiator_tag = None
188
253
self.stop_initiator_tag = None
189
254
self.checker_callback_tag = None
190
self.check_command = checker
255
self.check_command = config["checker"]
191
256
def start(self):
192
257
"""Start this client's checker and timeout hooks"""
193
258
# Schedule a new checker to be started an 'interval' from now,
203
268
self.stop)
204
269
def stop(self):
205
270
"""Stop this client.
206
The possibility that this client might be restarted is left
207
open, but not currently used."""
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
208
273
# If this client doesn't have a secret, it is already stopped.
209
if self.secret:
210
logger.debug(u"Stopping client %s", self.name)
274
if hasattr(self, "secret") and self.secret:
275
logger.info(u"Stopping client %s", self.name)
211
276
self.secret = None
212
277
else:
213
278
return False
214
if hasattr(self, "stop_initiator_tag") \
215
and self.stop_initiator_tag:
279
if getattr(self, "stop_initiator_tag", False):
216
280
gobject.source_remove(self.stop_initiator_tag)
217
281
self.stop_initiator_tag = None
218
if hasattr(self, "checker_initiator_tag") \
219
and self.checker_initiator_tag:
282
if getattr(self, "checker_initiator_tag", False):
220
283
gobject.source_remove(self.checker_initiator_tag)
221
284
self.checker_initiator_tag = None
222
285
self.stop_checker()
234
297
self.checker = None
235
298
if os.WIFEXITED(condition) \
236
299
and (os.WEXITSTATUS(condition) == 0):
237
logger.debug(u"Checker for %(name)s succeeded",
238
vars(self))
239
self.last_seen = now
300
logger.info(u"Checker for %(name)s succeeded",
301
vars(self))
302
self.last_checked_ok = now
240
303
gobject.source_remove(self.stop_initiator_tag)
241
304
self.stop_initiator_tag = gobject.timeout_add\
242
305
(self._timeout_milliseconds,
245
308
logger.warning(u"Checker for %(name)s crashed?",
246
309
vars(self))
247
310
else:
248
logger.debug(u"Checker for %(name)s failed",
249
vars(self))
311
logger.info(u"Checker for %(name)s failed",
312
vars(self))
250
313
def start_checker(self):
251
314
"""Start a new checker subprocess if one is not running.
252
315
If a checker already exists, leave it running and do
261
324
# is as it should be.
262
325
if self.checker is None:
263
326
try:
264
command = self.check_command % self.fqdn
327
# In case check_command has exactly one % operator
328
command = self.check_command % self.host
265
329
except TypeError:
330
# Escape attributes for the shell
266
331
escaped_attrs = dict((key, re.escape(str(val)))
267
332
for key, val in
268
333
vars(self).iteritems())
269
334
try:
270
335
command = self.check_command % escaped_attrs
271
336
except TypeError, error:
272
logger.critical(u'Could not format string "%s":'
273
u' %s', self.check_command, error)
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
274
339
return True # Try again later
275
340
try:
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="/")
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="/")
282
350
self.checker_callback_tag = gobject.child_watch_add\
283
351
(self.checker.pid,
284
352
self.checker_callback)
285
except subprocess.OSError, error:
353
except OSError, error:
286
354
logger.error(u"Failed to start subprocess: %s",
287
355
error)
288
356
# Re-run this periodically if run by gobject.timeout_add
292
360
if self.checker_callback_tag:
293
361
gobject.source_remove(self.checker_callback_tag)
294
362
self.checker_callback_tag = None
295
if not hasattr(self, "checker") or self.checker is None:
363
if getattr(self, "checker", None) is None:
296
364
return
297
logger.debug("Stopping checker for %(name)s", vars(self))
365
logger.debug(u"Stopping checker for %(name)s", vars(self))
298
366
try:
299
367
os.kill(self.checker.pid, signal.SIGTERM)
300
368
#os.sleep(0.5)
301
369
#if self.checker.poll() is None:
302
370
# os.kill(self.checker.pid, signal.SIGKILL)
303
371
except OSError, error:
304
if error.errno != errno.ESRCH:
372
if error.errno != errno.ESRCH: # No such process
305
373
raise
306
374
self.checker = None
307
def still_valid(self, now=None):
375
def still_valid(self):
308
376
"""Has the timeout not yet passed for this client?"""
309
if now is None:
310
now = datetime.datetime.now()
311
if self.last_seen is None:
377
now = datetime.datetime.now()
378
if self.last_checked_ok is None:
312
379
return now < (self.created + self.timeout)
313
380
else:
314
return now < (self.last_seen + self.timeout)
381
return now < (self.last_checked_ok + self.timeout)
315
382
316
383
317
384
def peer_certificate(session):
333
400
334
401
def fingerprint(openpgp):
335
402
"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))
340
403
# New GnuTLS "datum" with the OpenPGP public key
341
404
datum = gnutls.library.types.gnutls_datum_t\
342
405
(ctypes.cast(ctypes.c_char_p(openpgp),
343
406
ctypes.POINTER(ctypes.c_ubyte)),
344
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))
345
412
# Import the OpenPGP public key into the certificate
346
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
347
(crt,
348
ctypes.byref(datum),
349
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")
350
423
# New buffer for the fingerprint
351
424
buffer = ctypes.create_string_buffer(20)
352
425
buffer_length = ctypes.c_size_t()
368
441
Note: This will run in its own forked process."""
369
442
370
443
def handle(self):
371
logger.debug(u"TCP connection from: %s",
444
logger.info(u"TCP connection from: %s",
372
445
unicode(self.client_address))
373
session = gnutls.connection.ClientSession(self.request,
374
gnutls.connection.\
375
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.
376
462
377
463
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
378
464
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
379
465
# "+DHE-DSS"))
380
priority = "SECURE256"
381
466
priority = "NORMAL" # Fallback default, since this
467
# MUST be set.
468
if self.server.settings["priority"]:
469
priority = self.server.settings["priority"]
382
470
gnutls.library.functions.gnutls_priority_set_direct\
383
471
(session._c_object, priority, None);
384
472
385
473
try:
386
474
session.handshake()
387
475
except gnutls.errors.GNUTLSError, error:
388
logger.debug(u"Handshake failed: %s", error)
476
logger.warning(u"Handshake failed: %s", error)
389
477
# Do not run session.bye() here: the session is not
390
478
# established. Just abandon the request.
391
479
return
392
480
try:
393
481
fpr = fingerprint(peer_certificate(session))
394
482
except (TypeError, gnutls.errors.GNUTLSError), error:
395
logger.debug(u"Bad certificate: %s", error)
483
logger.warning(u"Bad certificate: %s", error)
396
484
session.bye()
397
485
return
398
486
logger.debug(u"Fingerprint: %s", fpr)
401
489
if c.fingerprint == fpr:
402
490
client = c
403
491
break
492
if not client:
493
logger.warning(u"Client not found for fingerprint: %s",
494
fpr)
495
session.bye()
496
return
404
497
# Have to check if client.still_valid(), since it is possible
405
498
# that the client timed out while establishing the GnuTLS
406
499
# session.
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)
500
if not client.still_valid():
501
logger.warning(u"Client %(name)s is invalid",
502
vars(client))
414
503
session.bye()
415
504
return
416
505
sent_size = 0
426
515
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
427
516
"""IPv6 TCP server. Accepts 'None' as address and/or port.
428
517
Attributes:
429
options: Command line options
518
settings: Server settings
430
519
clients: Set() of Client objects
431
520
"""
432
521
address_family = socket.AF_INET6
433
522
def __init__(self, *args, **kwargs):
434
if "options" in kwargs:
435
self.options = kwargs["options"]
436
del kwargs["options"]
523
if "settings" in kwargs:
524
self.settings = kwargs["settings"]
525
del kwargs["settings"]
437
526
if "clients" in kwargs:
438
527
self.clients = kwargs["clients"]
439
528
del kwargs["clients"]
442
531
"""This overrides the normal server_bind() function
443
532
to bind to an interface if one was specified, and also NOT to
444
533
bind to an address or port if they were not specified."""
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
534
if self.settings["interface"]:
535
# 25 is from /usr/include/asm-i486/socket.h
536
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
449
537
try:
450
538
self.socket.setsockopt(socket.SOL_SOCKET,
451
socket.SO_BINDTODEVICE,
452
self.options.interface)
539
SO_BINDTODEVICE,
540
self.settings["interface"])
453
541
except socket.error, error:
454
542
if error[0] == errno.EPERM:
455
logger.warning(u"No permission to"
456
u" bind to interface %s",
457
self.options.interface)
543
logger.error(u"No permission to"
544
u" bind to interface %s",
545
self.settings["interface"])
458
546
else:
459
547
raise error
460
548
# Only bind(2) the socket if we really need to.
463
551
in6addr_any = "::"
464
552
self.server_address = (in6addr_any,
465
553
self.server_address[1])
466
elif self.server_address[1] is None:
554
elif not self.server_address[1]:
467
555
self.server_address = (self.server_address[0],
468
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"]))
469
564
return super(type(self), self).server_bind()
470
565
471
566
482
577
datetime.timedelta(1)
483
578
>>> string_to_delta(u'1w')
484
579
datetime.timedelta(7)
580
>>> string_to_delta('5m 30s')
581
datetime.timedelta(0, 330)
485
582
"""
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:
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):
500
601
raise ValueError
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()
602
timevalue += delta
603
return timevalue
537
604
538
605
539
606
def server_state_changed(state):
540
607
"""Derived from the Avahi example code"""
541
608
if state == avahi.SERVER_COLLISION:
542
logger.warning(u"Server name collision")
543
remove_service()
609
logger.error(u"Zeroconf server name collision")
610
service.remove()
544
611
elif state == avahi.SERVER_RUNNING:
545
add_service()
612
service.add()
546
613
547
614
548
615
def entry_group_state_changed(state, error):
549
616
"""Derived from the Avahi example code"""
550
global serviceName, server, rename_count
551
552
logger.debug(u"state change: %i", state)
617
logger.debug(u"Avahi state change: %i", state)
553
618
554
619
if state == avahi.ENTRY_GROUP_ESTABLISHED:
555
logger.debug(u"Service established.")
620
logger.debug(u"Zeroconf service established.")
556
621
elif state == avahi.ENTRY_GROUP_COLLISION:
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)
622
logger.warning(u"Zeroconf service name collision.")
623
service.rename()
570
624
elif state == avahi.ENTRY_GROUP_FAILURE:
571
logger.error(u"Error in group state changed %s",
572
unicode(error))
573
killme(1)
574
625
logger.critical(u"Avahi: Error in group state changed %s",
626
unicode(error))
627
raise AvahiGroupError("State changed: %s", str(error))
575
628
576
629
def if_nametoindex(interface):
577
"""Call the C function if_nametoindex()"""
630
"""Call the C function if_nametoindex(), or equivalent"""
631
global if_nametoindex
578
632
try:
579
libc = ctypes.cdll.LoadLibrary("libc.so.6")
580
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
581
637
except (OSError, AttributeError):
582
638
if "struct" not in sys.modules:
583
639
import struct
584
640
if "fcntl" not in sys.modules:
585
641
import fcntl
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):
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):
596
655
"""See daemon(3). Standard BSD Unix function.
597
656
This should really exist as os.daemon, but it doesn't (yet)."""
598
657
if os.fork():
600
659
os.setsid()
601
660
if not nochdir:
602
661
os.chdir("/")
662
if os.fork():
663
sys.exit()
603
664
if not noclose:
604
665
# Close all standard open file descriptors
605
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
666
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
606
667
if not stat.S_ISCHR(os.fstat(null).st_mode):
607
668
raise OSError(errno.ENODEV,
608
669
"/dev/null not a character device")
613
674
os.close(null)
614
675
615
676
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
625
677
def main():
626
global exitstatus
627
exitstatus = 0
628
678
global main_loop_started
629
679
main_loop_started = False
630
680
631
parser = OptionParser()
681
parser = OptionParser(version = "%%prog %s" % version)
632
682
parser.add_option("-i", "--interface", type="string",
633
default=None, metavar="IF",
634
help="Bind to interface IF")
635
parser.add_option("-a", "--address", type="string", default=None,
683
metavar="IF", help="Bind to interface IF")
684
parser.add_option("-a", "--address", type="string",
636
685
help="Address to listen for requests on")
637
parser.add_option("-p", "--port", type="int", default=None,
686
parser.add_option("-p", "--port", type="int",
638
687
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")
645
688
parser.add_option("--check", action="store_true", default=False,
646
689
help="Run self-test")
647
parser.add_option("--debug", action="store_true", default=False,
648
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")
649
701
(options, args) = parser.parse_args()
650
702
651
703
if options.check:
653
705
doctest.testmod()
654
706
sys.exit()
655
707
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")
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"])
671
767
672
768
global main_loop
673
769
global bus
676
772
DBusGMainLoop(set_as_default=True )
677
773
main_loop = gobject.MainLoop()
678
774
bus = dbus.SystemBus()
679
server = dbus.Interface(
680
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
681
avahi.DBUS_INTERFACE_SERVER )
775
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
776
avahi.DBUS_PATH_SERVER),
777
avahi.DBUS_INTERFACE_SERVER)
682
778
# End of Avahi example code
683
779
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
694
780
clients = Set()
695
781
def remove_from_clients(client):
696
782
clients.remove(client)
697
783
if not clients:
698
logger.debug(u"No clients left, exiting")
699
killme()
784
logger.critical(u"No clients left, exiting")
785
sys.exit()
700
786
701
clients.update(Set(Client(name=section, options=options,
787
clients.update(Set(Client(name = section,
702
788
stop_hook = remove_from_clients,
703
**(dict(client_config\
704
.items(section))))
789
config
790
= dict(client_config.items(section)))
705
791
for section in client_config.sections()))
706
707
if not debug:
708
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())
709
818
710
819
def cleanup():
711
820
"Cleanup function; run on exit"
725
834
726
835
if not debug:
727
836
signal.signal(signal.SIGINT, signal.SIG_IGN)
728
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
729
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())
730
839
731
840
for client in clients:
732
841
client.start()
733
842
734
tcp_server = IPv6_TCPServer((options.address, options.port),
843
tcp_server = IPv6_TCPServer((server_settings["address"],
844
server_settings["port"]),
735
845
tcp_handler,
736
options=options,
846
settings=server_settings,
737
847
clients=clients)
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")
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")
762
871
main_loop_started = True
763
872
main_loop.run()
873
except AvahiError, error:
874
logger.critical(u"AvahiError: %s" + unicode(error))
875
sys.exit(1)
764
876
except KeyboardInterrupt:
765
877
if debug:
766
878
print
767
768
sys.exit(exitstatus)
769
879
770
880
if __name__ == '__main__':
771
881
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0