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
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 = None
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, stop_hook=None, fingerprint=None,
156
secret=None, secfile=None, fqdn=None, timeout=None,
157
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
229
logger.debug(u"Creating client %r", self.name)
162
# Uppercase and remove spaces from fingerprint
163
# for later comparison purposes with return value of
164
# the fingerprint() function
165
self.fingerprint = fingerprint.upper().replace(u" ", u"")
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"")
166
235
logger.debug(u" Fingerprint: %s", self.fingerprint)
167
if secret:
168
self.secret = secret.decode(u"base64")
169
elif secfile:
170
sf = open(secfile)
236
if "secret" in config:
237
self.secret = config["secret"].decode(u"base64")
238
elif "secfile" in config:
239
sf = open(config["secfile"])
171
240
self.secret = sf.read()
172
241
sf.close()
173
242
else:
174
raise RuntimeError(u"No secret or secfile for client %s"
175
% self.name)
176
self.fqdn = fqdn # string
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.host = config.get("host", "")
177
246
self.created = datetime.datetime.now()
178
self.last_seen = None
179
self.timeout = string_to_delta(timeout)
180
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"])
181
250
self.stop_hook = stop_hook
182
251
self.checker = None
183
252
self.checker_initiator_tag = None
184
253
self.stop_initiator_tag = None
185
254
self.checker_callback_tag = None
186
self.check_command = checker
255
self.check_command = config["checker"]
187
256
def start(self):
188
257
"""Start this client's checker and timeout hooks"""
189
258
# Schedule a new checker to be started an 'interval' from now,
199
268
self.stop)
200
269
def stop(self):
201
270
"""Stop this client.
202
The possibility that this client might be restarted is left
203
open, but not currently used."""
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
204
273
# If this client doesn't have a secret, it is already stopped.
205
if self.secret:
206
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)
207
276
self.secret = None
208
277
else:
209
278
return False
210
if hasattr(self, "stop_initiator_tag") \
211
and self.stop_initiator_tag:
279
if getattr(self, "stop_initiator_tag", False):
212
280
gobject.source_remove(self.stop_initiator_tag)
213
281
self.stop_initiator_tag = None
214
if hasattr(self, "checker_initiator_tag") \
215
and self.checker_initiator_tag:
282
if getattr(self, "checker_initiator_tag", False):
216
283
gobject.source_remove(self.checker_initiator_tag)
217
284
self.checker_initiator_tag = None
218
285
self.stop_checker()
230
297
self.checker = None
231
298
if os.WIFEXITED(condition) \
232
299
and (os.WEXITSTATUS(condition) == 0):
233
logger.debug(u"Checker for %(name)s succeeded",
234
vars(self))
235
self.last_seen = now
300
logger.info(u"Checker for %(name)s succeeded",
301
vars(self))
302
self.last_checked_ok = now
236
303
gobject.source_remove(self.stop_initiator_tag)
237
304
self.stop_initiator_tag = gobject.timeout_add\
238
305
(self._timeout_milliseconds,
241
308
logger.warning(u"Checker for %(name)s crashed?",
242
309
vars(self))
243
310
else:
244
logger.debug(u"Checker for %(name)s failed",
245
vars(self))
311
logger.info(u"Checker for %(name)s failed",
312
vars(self))
246
313
def start_checker(self):
247
314
"""Start a new checker subprocess if one is not running.
248
315
If a checker already exists, leave it running and do
257
324
# is as it should be.
258
325
if self.checker is None:
259
326
try:
260
command = self.check_command % self.fqdn
327
# In case check_command has exactly one % operator
328
command = self.check_command % self.host
261
329
except TypeError:
330
# Escape attributes for the shell
262
331
escaped_attrs = dict((key, re.escape(str(val)))
263
332
for key, val in
264
333
vars(self).iteritems())
265
334
try:
266
335
command = self.check_command % escaped_attrs
267
336
except TypeError, error:
268
logger.critical(u'Could not format string "%s":'
269
u' %s', self.check_command, error)
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
270
339
return True # Try again later
271
340
try:
272
logger.debug(u"Starting checker %r for %s",
273
command, self.name)
274
self.checker = subprocess.\
275
Popen(command,
276
close_fds=True, shell=True,
277
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="/")
278
350
self.checker_callback_tag = gobject.child_watch_add\
279
351
(self.checker.pid,
280
352
self.checker_callback)
281
except subprocess.OSError, error:
353
except OSError, error:
282
354
logger.error(u"Failed to start subprocess: %s",
283
355
error)
284
356
# Re-run this periodically if run by gobject.timeout_add
288
360
if self.checker_callback_tag:
289
361
gobject.source_remove(self.checker_callback_tag)
290
362
self.checker_callback_tag = None
291
if not hasattr(self, "checker") or self.checker is None:
363
if getattr(self, "checker", None) is None:
292
364
return
293
logger.debug("Stopping checker for %(name)s", vars(self))
365
logger.debug(u"Stopping checker for %(name)s", vars(self))
294
366
try:
295
367
os.kill(self.checker.pid, signal.SIGTERM)
296
368
#os.sleep(0.5)
297
369
#if self.checker.poll() is None:
298
370
# os.kill(self.checker.pid, signal.SIGKILL)
299
371
except OSError, error:
300
if error.errno != errno.ESRCH:
372
if error.errno != errno.ESRCH: # No such process
301
373
raise
302
374
self.checker = None
303
def still_valid(self, now=None):
375
def still_valid(self):
304
376
"""Has the timeout not yet passed for this client?"""
305
if now is None:
306
now = datetime.datetime.now()
307
if self.last_seen is None:
377
now = datetime.datetime.now()
378
if self.last_checked_ok is None:
308
379
return now < (self.created + self.timeout)
309
380
else:
310
return now < (self.last_seen + self.timeout)
381
return now < (self.last_checked_ok + self.timeout)
311
382
312
383
313
384
def peer_certificate(session):
329
400
330
401
def fingerprint(openpgp):
331
402
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
332
# New empty GnuTLS certificate
333
crt = gnutls.library.types.gnutls_openpgp_crt_t()
334
gnutls.library.functions.gnutls_openpgp_crt_init\
335
(ctypes.byref(crt))
336
403
# New GnuTLS "datum" with the OpenPGP public key
337
404
datum = gnutls.library.types.gnutls_datum_t\
338
405
(ctypes.cast(ctypes.c_char_p(openpgp),
339
406
ctypes.POINTER(ctypes.c_ubyte)),
340
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))
341
412
# Import the OpenPGP public key into the certificate
342
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
343
(crt,
344
ctypes.byref(datum),
345
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")
346
423
# New buffer for the fingerprint
347
424
buffer = ctypes.create_string_buffer(20)
348
425
buffer_length = ctypes.c_size_t()
364
441
Note: This will run in its own forked process."""
365
442
366
443
def handle(self):
367
logger.debug(u"TCP connection from: %s",
444
logger.info(u"TCP connection from: %s",
368
445
unicode(self.client_address))
369
session = gnutls.connection.ClientSession(self.request,
370
gnutls.connection.\
371
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.
372
462
373
463
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
374
464
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
375
465
# "+DHE-DSS"))
376
priority = "NORMAL"
377
if self.server.options.priority:
378
priority = self.server.options.priority
466
priority = "NORMAL" # Fallback default, since this
467
# MUST be set.
468
if self.server.settings["priority"]:
469
priority = self.server.settings["priority"]
379
470
gnutls.library.functions.gnutls_priority_set_direct\
380
471
(session._c_object, priority, None);
381
472
382
473
try:
383
474
session.handshake()
384
475
except gnutls.errors.GNUTLSError, error:
385
logger.debug(u"Handshake failed: %s", error)
476
logger.warning(u"Handshake failed: %s", error)
386
477
# Do not run session.bye() here: the session is not
387
478
# established. Just abandon the request.
388
479
return
389
480
try:
390
481
fpr = fingerprint(peer_certificate(session))
391
482
except (TypeError, gnutls.errors.GNUTLSError), error:
392
logger.debug(u"Bad certificate: %s", error)
483
logger.warning(u"Bad certificate: %s", error)
393
484
session.bye()
394
485
return
395
486
logger.debug(u"Fingerprint: %s", fpr)
398
489
if c.fingerprint == fpr:
399
490
client = c
400
491
break
492
if not client:
493
logger.warning(u"Client not found for fingerprint: %s",
494
fpr)
495
session.bye()
496
return
401
497
# Have to check if client.still_valid(), since it is possible
402
498
# that the client timed out while establishing the GnuTLS
403
499
# session.
404
if (not client) or (not client.still_valid()):
405
if client:
406
logger.debug(u"Client %(name)s is invalid",
407
vars(client))
408
else:
409
logger.debug(u"Client not found for fingerprint: %s",
410
fpr)
500
if not client.still_valid():
501
logger.warning(u"Client %(name)s is invalid",
502
vars(client))
411
503
session.bye()
412
504
return
413
505
sent_size = 0
423
515
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
424
516
"""IPv6 TCP server. Accepts 'None' as address and/or port.
425
517
Attributes:
426
options: Command line options
518
settings: Server settings
427
519
clients: Set() of Client objects
428
520
"""
429
521
address_family = socket.AF_INET6
430
522
def __init__(self, *args, **kwargs):
431
if "options" in kwargs:
432
self.options = kwargs["options"]
433
del kwargs["options"]
523
if "settings" in kwargs:
524
self.settings = kwargs["settings"]
525
del kwargs["settings"]
434
526
if "clients" in kwargs:
435
527
self.clients = kwargs["clients"]
436
528
del kwargs["clients"]
439
531
"""This overrides the normal server_bind() function
440
532
to bind to an interface if one was specified, and also NOT to
441
533
bind to an address or port if they were not specified."""
442
if self.options.interface:
443
if not hasattr(socket, "SO_BINDTODEVICE"):
444
# From /usr/include/asm-i486/socket.h
445
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)
446
537
try:
447
538
self.socket.setsockopt(socket.SOL_SOCKET,
448
socket.SO_BINDTODEVICE,
449
self.options.interface)
539
SO_BINDTODEVICE,
540
self.settings["interface"])
450
541
except socket.error, error:
451
542
if error[0] == errno.EPERM:
452
logger.warning(u"No permission to"
453
u" bind to interface %s",
454
self.options.interface)
543
logger.error(u"No permission to"
544
u" bind to interface %s",
545
self.settings["interface"])
455
546
else:
456
547
raise error
457
548
# Only bind(2) the socket if we really need to.
460
551
in6addr_any = "::"
461
552
self.server_address = (in6addr_any,
462
553
self.server_address[1])
463
elif self.server_address[1] is None:
554
elif not self.server_address[1]:
464
555
self.server_address = (self.server_address[0],
465
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"]))
466
564
return super(type(self), self).server_bind()
467
565
468
566
479
577
datetime.timedelta(1)
480
578
>>> string_to_delta(u'1w')
481
579
datetime.timedelta(7)
580
>>> string_to_delta('5m 30s')
581
datetime.timedelta(0, 330)
482
582
"""
483
try:
484
suffix=unicode(interval[-1])
485
value=int(interval[:-1])
486
if suffix == u"d":
487
delta = datetime.timedelta(value)
488
elif suffix == u"s":
489
delta = datetime.timedelta(0, value)
490
elif suffix == u"m":
491
delta = datetime.timedelta(0, 0, 0, 0, value)
492
elif suffix == u"h":
493
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
494
elif suffix == u"w":
495
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
496
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):
497
601
raise ValueError
498
except (ValueError, IndexError):
499
raise ValueError
500
return delta
501
502
503
def add_service():
504
"""Derived from the Avahi example code"""
505
global group, serviceName, serviceType, servicePort, serviceTXT, \
506
domain, host
507
if group is None:
508
group = dbus.Interface(
509
bus.get_object( avahi.DBUS_NAME,
510
server.EntryGroupNew()),
511
avahi.DBUS_INTERFACE_ENTRY_GROUP)
512
group.connect_to_signal('StateChanged',
513
entry_group_state_changed)
514
logger.debug(u"Adding service '%s' of type '%s' ...",
515
serviceName, serviceType)
516
517
group.AddService(
518
serviceInterface, # interface
519
avahi.PROTO_INET6, # protocol
520
dbus.UInt32(0), # flags
521
serviceName, serviceType,
522
domain, host,
523
dbus.UInt16(servicePort),
524
avahi.string_array_to_txt_array(serviceTXT))
525
group.Commit()
526
527
528
def remove_service():
529
"""From the Avahi example code"""
530
global group
531
532
if not group is None:
533
group.Reset()
602
timevalue += delta
603
return timevalue
534
604
535
605
536
606
def server_state_changed(state):
537
607
"""Derived from the Avahi example code"""
538
608
if state == avahi.SERVER_COLLISION:
539
logger.warning(u"Server name collision")
540
remove_service()
609
logger.error(u"Zeroconf server name collision")
610
service.remove()
541
611
elif state == avahi.SERVER_RUNNING:
542
add_service()
612
service.add()
543
613
544
614
545
615
def entry_group_state_changed(state, error):
546
616
"""Derived from the Avahi example code"""
547
global serviceName, server, rename_count
548
549
logger.debug(u"state change: %i", state)
617
logger.debug(u"Avahi state change: %i", state)
550
618
551
619
if state == avahi.ENTRY_GROUP_ESTABLISHED:
552
logger.debug(u"Service established.")
620
logger.debug(u"Zeroconf service established.")
553
621
elif state == avahi.ENTRY_GROUP_COLLISION:
554
555
rename_count = rename_count - 1
556
if rename_count > 0:
557
name = server.GetAlternativeServiceName(name)
558
logger.warning(u"Service name collision, "
559
u"changing name to '%s' ...", name)
560
remove_service()
561
add_service()
562
563
else:
564
logger.error(u"No suitable service name found after %i"
565
u" retries, exiting.", n_rename)
566
killme(1)
622
logger.warning(u"Zeroconf service name collision.")
623
service.rename()
567
624
elif state == avahi.ENTRY_GROUP_FAILURE:
568
logger.error(u"Error in group state changed %s",
569
unicode(error))
570
killme(1)
571
625
logger.critical(u"Avahi: Error in group state changed %s",
626
unicode(error))
627
raise AvahiGroupError("State changed: %s", str(error))
572
628
573
629
def if_nametoindex(interface):
574
"""Call the C function if_nametoindex()"""
630
"""Call the C function if_nametoindex(), or equivalent"""
631
global if_nametoindex
575
632
try:
576
libc = ctypes.cdll.LoadLibrary("libc.so.6")
577
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
578
637
except (OSError, AttributeError):
579
638
if "struct" not in sys.modules:
580
639
import struct
581
640
if "fcntl" not in sys.modules:
582
641
import fcntl
583
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
584
s = socket.socket()
585
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
586
struct.pack("16s16x", interface))
587
s.close()
588
interface_index = struct.unpack("I", ifreq[16:20])[0]
589
return interface_index
590
591
592
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):
593
655
"""See daemon(3). Standard BSD Unix function.
594
656
This should really exist as os.daemon, but it doesn't (yet)."""
595
657
if os.fork():
597
659
os.setsid()
598
660
if not nochdir:
599
661
os.chdir("/")
662
if os.fork():
663
sys.exit()
600
664
if not noclose:
601
665
# Close all standard open file descriptors
602
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
666
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
603
667
if not stat.S_ISCHR(os.fstat(null).st_mode):
604
668
raise OSError(errno.ENODEV,
605
669
"/dev/null not a character device")
610
674
os.close(null)
611
675
612
676
613
def killme(status = 0):
614
logger.debug("Stopping server with exit status %d", status)
615
exitstatus = status
616
if main_loop_started:
617
main_loop.quit()
618
else:
619
sys.exit(status)
620
621
622
677
def main():
623
global exitstatus
624
exitstatus = 0
625
678
global main_loop_started
626
679
main_loop_started = False
627
680
628
parser = OptionParser()
681
parser = OptionParser(version = "%%prog %s" % version)
629
682
parser.add_option("-i", "--interface", type="string",
630
default=None, metavar="IF",
631
help="Bind to interface IF")
632
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",
633
685
help="Address to listen for requests on")
634
parser.add_option("-p", "--port", type="int", default=None,
686
parser.add_option("-p", "--port", type="int",
635
687
help="Port number to receive requests on")
636
688
parser.add_option("--check", action="store_true", default=False,
637
689
help="Run self-test")
638
parser.add_option("--debug", action="store_true", default=False,
639
help="Debug mode")
640
parser.add_option("--priority", type="string",
641
default="SECURE256",
642
help="GnuTLS priority string"
643
" (see GnuTLS documentation)")
644
parser.add_option("--servicename", type="string",
645
default="Mandos", help="Zeroconf service name")
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")
646
701
(options, args) = parser.parse_args()
647
702
648
703
if options.check:
650
705
doctest.testmod()
651
706
sys.exit()
652
707
653
# Parse config file
654
defaults = { "timeout": "1h",
655
"interval": "5m",
656
"checker": "fping -q -- %%(fqdn)s",
657
}
658
client_config = ConfigParser.SafeConfigParser(defaults)
659
#client_config.readfp(open("global.conf"), "global.conf")
660
client_config.read("mandos-clients.conf")
661
662
global serviceName
663
serviceName = options.servicename;
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"])
664
767
665
768
global main_loop
666
769
global bus
669
772
DBusGMainLoop(set_as_default=True )
670
773
main_loop = gobject.MainLoop()
671
774
bus = dbus.SystemBus()
672
server = dbus.Interface(
673
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
674
avahi.DBUS_INTERFACE_SERVER )
775
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
776
avahi.DBUS_PATH_SERVER),
777
avahi.DBUS_INTERFACE_SERVER)
675
778
# End of Avahi example code
676
779
677
debug = options.debug
678
679
if debug:
680
console = logging.StreamHandler()
681
# console.setLevel(logging.DEBUG)
682
console.setFormatter(logging.Formatter\
683
('%(levelname)s: %(message)s'))
684
logger.addHandler(console)
685
del console
686
687
780
clients = Set()
688
781
def remove_from_clients(client):
689
782
clients.remove(client)
690
783
if not clients:
691
logger.debug(u"No clients left, exiting")
692
killme()
784
logger.critical(u"No clients left, exiting")
785
sys.exit()
693
786
694
clients.update(Set(Client(name=section,
787
clients.update(Set(Client(name = section,
695
788
stop_hook = remove_from_clients,
696
**(dict(client_config\
697
.items(section))))
789
config
790
= dict(client_config.items(section)))
698
791
for section in client_config.sections()))
699
700
if not debug:
701
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())
702
818
703
819
def cleanup():
704
820
"Cleanup function; run on exit"
718
834
719
835
if not debug:
720
836
signal.signal(signal.SIGINT, signal.SIG_IGN)
721
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
722
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())
723
839
724
840
for client in clients:
725
841
client.start()
726
842
727
tcp_server = IPv6_TCPServer((options.address, options.port),
843
tcp_server = IPv6_TCPServer((server_settings["address"],
844
server_settings["port"]),
728
845
tcp_handler,
729
options=options,
846
settings=server_settings,
730
847
clients=clients)
731
# Find out what random port we got
732
global servicePort
733
servicePort = tcp_server.socket.getsockname()[1]
734
logger.debug(u"Now listening on port %d", servicePort)
735
736
if options.interface is not None:
737
global serviceInterface
738
serviceInterface = if_nametoindex(options.interface)
739
740
# From the Avahi example code
741
server.connect_to_signal("StateChanged", server_state_changed)
742
try:
743
server_state_changed(server.GetState())
744
except dbus.exceptions.DBusException, error:
745
logger.critical(u"DBusException: %s", error)
746
killme(1)
747
# End of Avahi example code
748
749
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
750
lambda *args, **kwargs:
751
tcp_server.handle_request(*args[2:],
752
**kwargs) or True)
753
try:
754
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")
755
871
main_loop_started = True
756
872
main_loop.run()
873
except AvahiError, error:
874
logger.critical(u"AvahiError: %s" + unicode(error))
875
sys.exit(1)
757
876
except KeyboardInterrupt:
758
877
if debug:
759
878
print
760
761
sys.exit(exitstatus)
762
879
763
880
if __name__ == '__main__':
764
881
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0