To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to server.py
- browse files at revision 24.1.2
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.2
- Committer: Björn Påhlsson
- Date: 2008-07-22 06:26:12 UTC
- mfrom: (26 mandos)
- mto: (237.7.1 mandos) (24.1.154 mandos)
- mto: This revision was merged to the branch mainline in revision 27.
- Revision ID: belorn@braxen-20080722062612-0om9eb3fpsso8xc4
merge
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- 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 © 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 = 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
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, 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.."""
229
160
self.name = name
230
161
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"")
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"")
236
166
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"])
167
if secret:
168
self.secret = secret.decode(u"base64")
169
elif secfile:
170
sf = open(secfile)
241
171
self.secret = sf.read()
242
172
sf.close()
243
173
else:
244
raise TypeError(u"No secret or secfile for client %s"
245
% self.name)
246
self.host = config.get("host", "")
174
raise RuntimeError(u"No secret or secfile for client %s"
175
% self.name)
176
self.fqdn = fqdn # string
247
177
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"])
178
self.last_seen = None
179
self.timeout = string_to_delta(timeout)
180
self.interval = string_to_delta(interval)
251
181
self.stop_hook = stop_hook
252
182
self.checker = None
253
183
self.checker_initiator_tag = None
254
184
self.stop_initiator_tag = None
255
185
self.checker_callback_tag = None
256
self.check_command = config["checker"]
186
self.check_command = checker
257
187
def start(self):
258
188
"""Start this client's checker and timeout hooks"""
259
189
# Schedule a new checker to be started an 'interval' from now,
269
199
self.stop)
270
200
def stop(self):
271
201
"""Stop this client.
272
The possibility that a client might be restarted is left open,
273
but not currently used."""
202
The possibility that this client might be restarted is left
203
open, but not currently used."""
274
204
# 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)
205
if self.secret:
206
logger.debug(u"Stopping client %s", self.name)
277
207
self.secret = None
278
208
else:
279
209
return False
280
if getattr(self, "stop_initiator_tag", False):
210
if hasattr(self, "stop_initiator_tag") \
211
and self.stop_initiator_tag:
281
212
gobject.source_remove(self.stop_initiator_tag)
282
213
self.stop_initiator_tag = None
283
if getattr(self, "checker_initiator_tag", False):
214
if hasattr(self, "checker_initiator_tag") \
215
and self.checker_initiator_tag:
284
216
gobject.source_remove(self.checker_initiator_tag)
285
217
self.checker_initiator_tag = None
286
218
self.stop_checker()
298
230
self.checker = None
299
231
if os.WIFEXITED(condition) \
300
232
and (os.WEXITSTATUS(condition) == 0):
301
logger.info(u"Checker for %(name)s succeeded",
302
vars(self))
303
self.last_checked_ok = now
233
logger.debug(u"Checker for %(name)s succeeded",
234
vars(self))
235
self.last_seen = now
304
236
gobject.source_remove(self.stop_initiator_tag)
305
237
self.stop_initiator_tag = gobject.timeout_add\
306
238
(self._timeout_milliseconds,
309
241
logger.warning(u"Checker for %(name)s crashed?",
310
242
vars(self))
311
243
else:
312
logger.info(u"Checker for %(name)s failed",
313
vars(self))
244
logger.debug(u"Checker for %(name)s failed",
245
vars(self))
314
246
def start_checker(self):
315
247
"""Start a new checker subprocess if one is not running.
316
248
If a checker already exists, leave it running and do
325
257
# is as it should be.
326
258
if self.checker is None:
327
259
try:
328
# In case check_command has exactly one % operator
329
command = self.check_command % self.host
260
command = self.check_command % self.fqdn
330
261
except TypeError:
331
# Escape attributes for the shell
332
262
escaped_attrs = dict((key, re.escape(str(val)))
333
263
for key, val in
334
264
vars(self).iteritems())
335
265
try:
336
266
command = self.check_command % escaped_attrs
337
267
except TypeError, error:
338
logger.error(u'Could not format string "%s":'
339
u' %s', self.check_command, error)
268
logger.critical(u'Could not format string "%s":'
269
u' %s', self.check_command, error)
340
270
return True # Try again later
341
271
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="/")
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="/")
351
278
self.checker_callback_tag = gobject.child_watch_add\
352
279
(self.checker.pid,
353
280
self.checker_callback)
354
except OSError, error:
281
except subprocess.OSError, error:
355
282
logger.error(u"Failed to start subprocess: %s",
356
283
error)
357
284
# Re-run this periodically if run by gobject.timeout_add
361
288
if self.checker_callback_tag:
362
289
gobject.source_remove(self.checker_callback_tag)
363
290
self.checker_callback_tag = None
364
if getattr(self, "checker", None) is None:
291
if not hasattr(self, "checker") or self.checker is None:
365
292
return
366
logger.debug(u"Stopping checker for %(name)s", vars(self))
293
logger.debug("Stopping checker for %(name)s", vars(self))
367
294
try:
368
295
os.kill(self.checker.pid, signal.SIGTERM)
369
296
#os.sleep(0.5)
370
297
#if self.checker.poll() is None:
371
298
# os.kill(self.checker.pid, signal.SIGKILL)
372
299
except OSError, error:
373
if error.errno != errno.ESRCH: # No such process
300
if error.errno != errno.ESRCH:
374
301
raise
375
302
self.checker = None
376
def still_valid(self):
303
def still_valid(self, now=None):
377
304
"""Has the timeout not yet passed for this client?"""
378
now = datetime.datetime.now()
379
if self.last_checked_ok is None:
305
if now is None:
306
now = datetime.datetime.now()
307
if self.last_seen is None:
380
308
return now < (self.created + self.timeout)
381
309
else:
382
return now < (self.last_checked_ok + self.timeout)
310
return now < (self.last_seen + self.timeout)
383
311
384
312
385
313
def peer_certificate(session):
401
329
402
330
def fingerprint(openpgp):
403
331
"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))
404
336
# New GnuTLS "datum" with the OpenPGP public key
405
337
datum = gnutls.library.types.gnutls_datum_t\
406
338
(ctypes.cast(ctypes.c_char_p(openpgp),
407
339
ctypes.POINTER(ctypes.c_ubyte)),
408
340
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
341
# 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")
342
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
343
(crt,
344
ctypes.byref(datum),
345
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
424
346
# New buffer for the fingerprint
425
347
buffer = ctypes.create_string_buffer(20)
426
348
buffer_length = ctypes.c_size_t()
442
364
Note: This will run in its own forked process."""
443
365
444
366
def handle(self):
445
logger.info(u"TCP connection from: %s",
367
logger.debug(u"TCP connection from: %s",
446
368
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.
369
session = gnutls.connection.ClientSession(self.request,
370
gnutls.connection.\
371
X509Credentials())
463
372
464
373
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
465
374
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
466
375
# "+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"]
376
priority = "NORMAL"
377
if self.server.options.priority:
378
priority = self.server.options.priority
471
379
gnutls.library.functions.gnutls_priority_set_direct\
472
380
(session._c_object, priority, None);
473
381
474
382
try:
475
383
session.handshake()
476
384
except gnutls.errors.GNUTLSError, error:
477
logger.warning(u"Handshake failed: %s", error)
385
logger.debug(u"Handshake failed: %s", error)
478
386
# Do not run session.bye() here: the session is not
479
387
# established. Just abandon the request.
480
388
return
481
389
try:
482
390
fpr = fingerprint(peer_certificate(session))
483
391
except (TypeError, gnutls.errors.GNUTLSError), error:
484
logger.warning(u"Bad certificate: %s", error)
392
logger.debug(u"Bad certificate: %s", error)
485
393
session.bye()
486
394
return
487
395
logger.debug(u"Fingerprint: %s", fpr)
490
398
if c.fingerprint == fpr:
491
399
client = c
492
400
break
493
if not client:
494
logger.warning(u"Client not found for fingerprint: %s",
495
fpr)
496
session.bye()
497
return
498
401
# Have to check if client.still_valid(), since it is possible
499
402
# that the client timed out while establishing the GnuTLS
500
403
# session.
501
if not client.still_valid():
502
logger.warning(u"Client %(name)s is invalid",
503
vars(client))
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)
504
411
session.bye()
505
412
return
506
413
sent_size = 0
516
423
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
517
424
"""IPv6 TCP server. Accepts 'None' as address and/or port.
518
425
Attributes:
519
settings: Server settings
426
options: Command line options
520
427
clients: Set() of Client objects
521
enabled: Boolean; whether this server is activated yet
522
428
"""
523
429
address_family = socket.AF_INET6
524
430
def __init__(self, *args, **kwargs):
525
if "settings" in kwargs:
526
self.settings = kwargs["settings"]
527
del kwargs["settings"]
431
if "options" in kwargs:
432
self.options = kwargs["options"]
433
del kwargs["options"]
528
434
if "clients" in kwargs:
529
435
self.clients = kwargs["clients"]
530
436
del kwargs["clients"]
531
self.enabled = False
532
437
return super(type(self), self).__init__(*args, **kwargs)
533
438
def server_bind(self):
534
439
"""This overrides the normal server_bind() function
535
440
to bind to an interface if one was specified, and also NOT to
536
441
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)
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
540
446
try:
541
447
self.socket.setsockopt(socket.SOL_SOCKET,
542
SO_BINDTODEVICE,
543
self.settings["interface"])
448
socket.SO_BINDTODEVICE,
449
self.options.interface)
544
450
except socket.error, error:
545
451
if error[0] == errno.EPERM:
546
logger.error(u"No permission to"
547
u" bind to interface %s",
548
self.settings["interface"])
452
logger.warning(u"No permission to"
453
u" bind to interface %s",
454
self.options.interface)
549
455
else:
550
456
raise error
551
457
# Only bind(2) the socket if we really need to.
554
460
in6addr_any = "::"
555
461
self.server_address = (in6addr_any,
556
462
self.server_address[1])
557
elif not self.server_address[1]:
463
elif self.server_address[1] is None:
558
464
self.server_address = (self.server_address[0],
559
465
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
466
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
467
574
468
575
469
def string_to_delta(interval):
585
479
datetime.timedelta(1)
586
480
>>> string_to_delta(u'1w')
587
481
datetime.timedelta(7)
588
>>> string_to_delta('5m 30s')
589
datetime.timedelta(0, 330)
590
482
"""
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):
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:
609
497
raise ValueError
610
timevalue += delta
611
return timevalue
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()
612
534
613
535
614
536
def server_state_changed(state):
615
537
"""Derived from the Avahi example code"""
616
538
if state == avahi.SERVER_COLLISION:
617
logger.error(u"Zeroconf server name collision")
618
service.remove()
539
logger.warning(u"Server name collision")
540
remove_service()
619
541
elif state == avahi.SERVER_RUNNING:
620
service.add()
542
add_service()
621
543
622
544
623
545
def entry_group_state_changed(state, error):
624
546
"""Derived from the Avahi example code"""
625
logger.debug(u"Avahi state change: %i", state)
547
global serviceName, server, rename_count
548
549
logger.debug(u"state change: %i", state)
626
550
627
551
if state == avahi.ENTRY_GROUP_ESTABLISHED:
628
logger.debug(u"Zeroconf service established.")
552
logger.debug(u"Service established.")
629
553
elif state == avahi.ENTRY_GROUP_COLLISION:
630
logger.warning(u"Zeroconf service name collision.")
631
service.rename()
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)
632
567
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))
568
logger.error(u"Error in group state changed %s",
569
unicode(error))
570
killme(1)
571
636
572
637
573
def if_nametoindex(interface):
638
"""Call the C function if_nametoindex(), or equivalent"""
639
global if_nametoindex
574
"""Call the C function if_nametoindex()"""
640
575
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
576
libc = ctypes.cdll.LoadLibrary("libc.so.6")
577
return libc.if_nametoindex(interface)
645
578
except (OSError, AttributeError):
646
579
if "struct" not in sys.modules:
647
580
import struct
648
581
if "fcntl" not in sys.modules:
649
582
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):
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):
663
593
"""See daemon(3). Standard BSD Unix function.
664
594
This should really exist as os.daemon, but it doesn't (yet)."""
665
595
if os.fork():
667
597
os.setsid()
668
598
if not nochdir:
669
599
os.chdir("/")
670
if os.fork():
671
sys.exit()
672
600
if not noclose:
673
601
# Close all standard open file descriptors
674
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
602
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
675
603
if not stat.S_ISCHR(os.fstat(null).st_mode):
676
604
raise OSError(errno.ENODEV,
677
605
"/dev/null not a character device")
682
610
os.close(null)
683
611
684
612
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
685
622
def main():
623
global exitstatus
624
exitstatus = 0
686
625
global main_loop_started
687
626
main_loop_started = False
688
627
689
parser = OptionParser(version = "%%prog %s" % version)
628
parser = OptionParser()
690
629
parser.add_option("-i", "--interface", type="string",
691
metavar="IF", help="Bind to interface IF")
692
parser.add_option("-a", "--address", type="string",
630
default=None, metavar="IF",
631
help="Bind to interface IF")
632
parser.add_option("-a", "--address", type="string", default=None,
693
633
help="Address to listen for requests on")
694
parser.add_option("-p", "--port", type="int",
634
parser.add_option("-p", "--port", type="int", default=None,
695
635
help="Port number to receive requests on")
696
636
parser.add_option("--check", action="store_true", default=False,
697
637
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")
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")
709
646
(options, args) = parser.parse_args()
710
647
711
648
if options.check:
713
650
doctest.testmod()
714
651
sys.exit()
715
652
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"])
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;
810
664
811
665
global main_loop
812
666
global bus
815
669
DBusGMainLoop(set_as_default=True )
816
670
main_loop = gobject.MainLoop()
817
671
bus = dbus.SystemBus()
818
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
819
avahi.DBUS_PATH_SERVER),
820
avahi.DBUS_INTERFACE_SERVER)
672
server = dbus.Interface(
673
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
674
avahi.DBUS_INTERFACE_SERVER )
821
675
# End of Avahi example code
822
676
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
clients = Set()
823
688
def remove_from_clients(client):
824
689
clients.remove(client)
825
690
if not clients:
826
logger.critical(u"No clients left, exiting")
827
sys.exit()
691
logger.debug(u"No clients left, exiting")
692
killme()
828
693
829
clients.update(Set(Client(name = section,
694
clients.update(Set(Client(name=section,
830
695
stop_hook = remove_from_clients,
831
config
832
= dict(client_config.items(section)))
696
**(dict(client_config\
697
.items(section))))
833
698
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
699
700
if not debug:
701
daemon(False, False)
862
702
863
703
def cleanup():
864
704
"Cleanup function; run on exit"
878
718
879
719
if not debug:
880
720
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())
721
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
722
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
883
723
884
724
for client in clients:
885
725
client.start()
886
726
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")
727
tcp_server = IPv6_TCPServer((options.address, options.port),
728
tcp_handler,
729
options=options,
730
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")
913
755
main_loop_started = True
914
756
main_loop.run()
915
except AvahiError, error:
916
logger.critical(u"AvahiError: %s" + unicode(error))
917
sys.exit(1)
918
757
except KeyboardInterrupt:
919
758
if debug:
920
759
print
760
761
sys.exit(exitstatus)
921
762
922
763
if __name__ == '__main__':
923
764
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0