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