2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos server - give out binary blobs to connecting clients.
6
# This program is partly derived from an example program for an Avahi
7
# service publisher, downloaded from
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 Björn Påhlsson
17
# This program is free software: you can redistribute it and/or modify
18
# it under the terms of the GNU General Public License as published by
19
# the Free Software Foundation, either version 3 of the License, or
20
# (at your option) any later version.
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
24
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25
# GNU General Public License for more details.
27
# You should have received a copy of the GNU General Public License
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
31
# Contact the authors at <mandos@fukt.bsnet.se>.
34
from __future__ import division, with_statement, absolute_import
6
from optparse import OptionParser
41
9
import gnutls.crypto
42
10
import gnutls.connection
43
11
import gnutls.errors
44
import gnutls.library.functions
45
import gnutls.library.constants
46
import gnutls.library.types
47
12
import ConfigParser
57
import logging.handlers
59
from contextlib import closing
65
from dbus.mainloop.glib import DBusGMainLoop
71
logger = logging.Logger('mandos')
72
syslogger = (logging.handlers.SysLogHandler
73
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
74
address = "/dev/log"))
75
syslogger.setFormatter(logging.Formatter
76
('Mandos [%(process)d]: %(levelname)s:'
78
logger.addHandler(syslogger)
80
console = logging.StreamHandler()
81
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
82
' %(levelname)s: %(message)s'))
83
logger.addHandler(console)
85
class AvahiError(Exception):
86
def __init__(self, value, *args, **kwargs):
88
super(AvahiError, self).__init__(value, *args, **kwargs)
89
def __unicode__(self):
90
return unicode(repr(self.value))
92
class AvahiServiceError(AvahiError):
95
class AvahiGroupError(AvahiError):
99
class AvahiService(object):
100
"""An Avahi (Zeroconf) service.
102
interface: integer; avahi.IF_UNSPEC or an interface index.
103
Used to optionally bind to the specified interface.
104
name: string; Example: 'Mandos'
105
type: string; Example: '_mandos._tcp'.
106
See <http://www.dns-sd.org/ServiceTypes.html>
107
port: integer; what port to announce
108
TXT: list of strings; TXT record for the service
109
domain: string; Domain to publish on, default to .local if empty.
110
host: string; Host to publish records for, default is localhost
111
max_renames: integer; maximum number of renames
112
rename_count: integer; counter so we only rename after collisions
113
a sensible number of times
115
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
116
servicetype = None, port = None, TXT = None,
117
domain = "", host = "", max_renames = 32768,
118
protocol = avahi.PROTO_UNSPEC):
119
self.interface = interface
121
self.type = servicetype
123
self.TXT = TXT if TXT is not None else []
126
self.rename_count = 0
127
self.max_renames = max_renames
128
self.protocol = protocol
130
"""Derived from the Avahi example code"""
131
if self.rename_count >= self.max_renames:
132
logger.critical(u"No suitable Zeroconf service name found"
133
u" after %i retries, exiting.",
135
raise AvahiServiceError(u"Too many renames")
136
self.name = server.GetAlternativeServiceName(self.name)
137
logger.info(u"Changing Zeroconf service name to %r ...",
139
syslogger.setFormatter(logging.Formatter
140
('Mandos (%s): %%(levelname)s:'
141
' %%(message)s' % self.name))
144
self.rename_count += 1
146
"""Derived from the Avahi example code"""
147
if group is not None:
150
"""Derived from the Avahi example code"""
153
group = dbus.Interface(bus.get_object
155
server.EntryGroupNew()),
156
avahi.DBUS_INTERFACE_ENTRY_GROUP)
157
group.connect_to_signal('StateChanged',
158
entry_group_state_changed)
159
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
160
service.name, service.type)
162
self.interface, # interface
163
self.protocol, # protocol
164
dbus.UInt32(0), # flags
165
self.name, self.type,
166
self.domain, self.host,
167
dbus.UInt16(self.port),
168
avahi.string_array_to_txt_array(self.TXT))
171
# From the Avahi example code:
172
group = None # our entry group
173
# End of Avahi example code
176
def _datetime_to_dbus(dt, variant_level=0):
177
"""Convert a UTC datetime.datetime() to a D-Bus type."""
178
return dbus.String(dt.isoformat(), variant_level=variant_level)
181
class Client(dbus.service.Object):
182
"""A representation of a client host served by this server.
184
name: string; from the config file, used in log messages and
186
fingerprint: string (40 or 32 hexadecimal digits); used to
187
uniquely identify the client
188
secret: bytestring; sent verbatim (over TLS) to client
189
host: string; available for use by the checker command
190
created: datetime.datetime(); (UTC) object creation
191
last_enabled: datetime.datetime(); (UTC)
193
last_checked_ok: datetime.datetime(); (UTC) or None
194
timeout: datetime.timedelta(); How long from last_checked_ok
195
until this client is invalid
196
interval: datetime.timedelta(); How often to start a new checker
197
disable_hook: If set, called by disable() as disable_hook(self)
198
checker: subprocess.Popen(); a running checker process used
199
to see if the client lives.
200
'None' if no process is running.
201
checker_initiator_tag: a gobject event source tag, or None
202
disable_initiator_tag: - '' -
203
checker_callback_tag: - '' -
204
checker_command: string; External command which is run to check if
205
client lives. %() expansions are done at
206
runtime with vars(self) as dict, so that for
207
instance %(name)s can be used in the command.
208
use_dbus: bool(); Whether to provide D-Bus interface and signals
209
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
211
def timeout_milliseconds(self):
212
"Return the 'timeout' attribute in milliseconds"
213
return ((self.timeout.days * 24 * 60 * 60 * 1000)
214
+ (self.timeout.seconds * 1000)
215
+ (self.timeout.microseconds // 1000))
217
def interval_milliseconds(self):
218
"Return the 'interval' attribute in milliseconds"
219
return ((self.interval.days * 24 * 60 * 60 * 1000)
220
+ (self.interval.seconds * 1000)
221
+ (self.interval.microseconds // 1000))
223
def __init__(self, name = None, disable_hook=None, config=None,
225
"""Note: the 'checker' key in 'config' sets the
226
'checker_command' attribute and *not* the 'checker'
231
logger.debug(u"Creating client %r", self.name)
232
self.use_dbus = False # During __init__
233
# Uppercase and remove spaces from fingerprint for later
234
# comparison purposes with return value from the fingerprint()
236
self.fingerprint = (config["fingerprint"].upper()
238
logger.debug(u" Fingerprint: %s", self.fingerprint)
239
if "secret" in config:
240
self.secret = config["secret"].decode(u"base64")
241
elif "secfile" in config:
242
with closing(open(os.path.expanduser
244
(config["secfile"])))) as secfile:
245
self.secret = secfile.read()
247
raise TypeError(u"No secret or secfile for client %s"
249
self.host = config.get("host", "")
250
self.created = datetime.datetime.utcnow()
252
self.last_enabled = None
253
self.last_checked_ok = None
254
self.timeout = string_to_delta(config["timeout"])
255
self.interval = string_to_delta(config["interval"])
256
self.disable_hook = disable_hook
258
self.checker_initiator_tag = None
259
self.disable_initiator_tag = None
260
self.checker_callback_tag = None
261
self.checker_command = config["checker"]
262
self.last_connect = None
263
# Only now, when this client is initialized, can it show up on
265
self.use_dbus = use_dbus
267
self.dbus_object_path = (dbus.ObjectPath
269
+ self.name.replace(".", "_")))
270
dbus.service.Object.__init__(self, bus,
271
self.dbus_object_path)
274
"""Start this client's checker and timeout hooks"""
275
self.last_enabled = datetime.datetime.utcnow()
276
# Schedule a new checker to be started an 'interval' from now,
277
# and every interval from then on.
278
self.checker_initiator_tag = (gobject.timeout_add
279
(self.interval_milliseconds(),
281
# Also start a new checker *right now*.
283
# Schedule a disable() when 'timeout' has passed
284
self.disable_initiator_tag = (gobject.timeout_add
285
(self.timeout_milliseconds(),
290
self.PropertyChanged(dbus.String(u"enabled"),
291
dbus.Boolean(True, variant_level=1))
292
self.PropertyChanged(dbus.String(u"last_enabled"),
293
(_datetime_to_dbus(self.last_enabled,
297
"""Disable this client."""
298
if not getattr(self, "enabled", False):
300
logger.info(u"Disabling client %s", self.name)
301
if getattr(self, "disable_initiator_tag", False):
302
gobject.source_remove(self.disable_initiator_tag)
303
self.disable_initiator_tag = None
304
if getattr(self, "checker_initiator_tag", False):
305
gobject.source_remove(self.checker_initiator_tag)
306
self.checker_initiator_tag = None
308
if self.disable_hook:
309
self.disable_hook(self)
313
self.PropertyChanged(dbus.String(u"enabled"),
314
dbus.Boolean(False, variant_level=1))
315
# Do not run this again if called by a gobject.timeout_add
319
self.disable_hook = None
322
def checker_callback(self, pid, condition, command):
323
"""The checker has completed, so take appropriate actions."""
324
self.checker_callback_tag = None
328
self.PropertyChanged(dbus.String(u"checker_running"),
329
dbus.Boolean(False, variant_level=1))
330
if os.WIFEXITED(condition):
331
exitstatus = os.WEXITSTATUS(condition)
333
logger.info(u"Checker for %(name)s succeeded",
337
logger.info(u"Checker for %(name)s failed",
341
self.CheckerCompleted(dbus.Int16(exitstatus),
342
dbus.Int64(condition),
343
dbus.String(command))
345
logger.warning(u"Checker for %(name)s crashed?",
349
self.CheckerCompleted(dbus.Int16(-1),
350
dbus.Int64(condition),
351
dbus.String(command))
353
def checked_ok(self):
354
"""Bump up the timeout for this client.
355
This should only be called when the client has been seen,
358
self.last_checked_ok = datetime.datetime.utcnow()
359
gobject.source_remove(self.disable_initiator_tag)
360
self.disable_initiator_tag = (gobject.timeout_add
361
(self.timeout_milliseconds(),
365
self.PropertyChanged(
366
dbus.String(u"last_checked_ok"),
367
(_datetime_to_dbus(self.last_checked_ok,
370
def start_checker(self):
371
"""Start a new checker subprocess if one is not running.
372
If a checker already exists, leave it running and do
374
# The reason for not killing a running checker is that if we
375
# did that, then if a checker (for some reason) started
376
# running slowly and taking more than 'interval' time, the
377
# client would inevitably timeout, since no checker would get
378
# a chance to run to completion. If we instead leave running
379
# checkers alone, the checker would have to take more time
380
# than 'timeout' for the client to be declared invalid, which
381
# is as it should be.
382
if self.checker is None:
384
# In case checker_command has exactly one % operator
385
command = self.checker_command % self.host
387
# Escape attributes for the shell
388
escaped_attrs = dict((key, re.escape(str(val)))
390
vars(self).iteritems())
17
def __init__(self, name=None, options=None, dn=None,
18
password=None, passfile=None, fqdn=None,
19
timeout=None, interval=-1):
23
self.password = password
25
self.password = open(passfile).readall()
27
print "No Password or Passfile in client config file"
28
# raise RuntimeError XXX
29
self.password = "gazonk"
31
self.created = datetime.datetime.now()
34
timeout = options.timeout
35
self.timeout = timeout
37
interval = options.interval
38
self.interval = interval
39
self.next_check = datetime.datetime.now()
42
class server_metaclass(type):
43
"Common behavior for the UDP and TCP server classes"
44
def __new__(cls, name, bases, attrs):
45
attrs["address_family"] = socket.AF_INET6
46
attrs["allow_reuse_address"] = True
47
def server_bind(self):
48
if self.options.interface:
49
if not hasattr(socket, "SO_BINDTODEVICE"):
50
# From /usr/include/asm-i486/socket.h
51
socket.SO_BINDTODEVICE = 25
392
command = self.checker_command % escaped_attrs
393
except TypeError, error:
394
logger.error(u'Could not format string "%s":'
395
u' %s', self.checker_command, error)
396
return True # Try again later
398
logger.info(u"Starting checker %r for %s",
400
# We don't need to redirect stdout and stderr, since
401
# in normal mode, that is already done by daemon(),
402
# and in debug mode we don't want to. (Stdin is
403
# always replaced by /dev/null.)
404
self.checker = subprocess.Popen(command,
409
self.CheckerStarted(command)
410
self.PropertyChanged(
411
dbus.String("checker_running"),
412
dbus.Boolean(True, variant_level=1))
413
self.checker_callback_tag = (gobject.child_watch_add
415
self.checker_callback,
417
# The checker may have completed before the gobject
418
# watch was added. Check for this.
419
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
421
gobject.source_remove(self.checker_callback_tag)
422
self.checker_callback(pid, status, command)
423
except OSError, error:
424
logger.error(u"Failed to start subprocess: %s",
426
# Re-run this periodically if run by gobject.timeout_add
429
def stop_checker(self):
430
"""Force the checker process, if any, to stop."""
431
if self.checker_callback_tag:
432
gobject.source_remove(self.checker_callback_tag)
433
self.checker_callback_tag = None
434
if getattr(self, "checker", None) is None:
436
logger.debug(u"Stopping checker for %(name)s", vars(self))
438
os.kill(self.checker.pid, signal.SIGTERM)
440
#if self.checker.poll() is None:
441
# os.kill(self.checker.pid, signal.SIGKILL)
442
except OSError, error:
443
if error.errno != errno.ESRCH: # No such process
447
self.PropertyChanged(dbus.String(u"checker_running"),
448
dbus.Boolean(False, variant_level=1))
450
def still_valid(self):
451
"""Has the timeout not yet passed for this client?"""
452
if not getattr(self, "enabled", False):
454
now = datetime.datetime.utcnow()
455
if self.last_checked_ok is None:
456
return now < (self.created + self.timeout)
458
return now < (self.last_checked_ok + self.timeout)
460
## D-Bus methods & signals
461
_interface = u"se.bsnet.fukt.Mandos.Client"
464
CheckedOK = dbus.service.method(_interface)(checked_ok)
465
CheckedOK.__name__ = "CheckedOK"
467
# CheckerCompleted - signal
468
@dbus.service.signal(_interface, signature="nxs")
469
def CheckerCompleted(self, exitcode, waitstatus, command):
473
# CheckerStarted - signal
474
@dbus.service.signal(_interface, signature="s")
475
def CheckerStarted(self, command):
479
# GetAllProperties - method
480
@dbus.service.method(_interface, out_signature="a{sv}")
481
def GetAllProperties(self):
483
return dbus.Dictionary({
485
dbus.String(self.name, variant_level=1),
486
dbus.String("fingerprint"):
487
dbus.String(self.fingerprint, variant_level=1),
489
dbus.String(self.host, variant_level=1),
490
dbus.String("created"):
491
_datetime_to_dbus(self.created, variant_level=1),
492
dbus.String("last_enabled"):
493
(_datetime_to_dbus(self.last_enabled,
495
if self.last_enabled is not None
496
else dbus.Boolean(False, variant_level=1)),
497
dbus.String("enabled"):
498
dbus.Boolean(self.enabled, variant_level=1),
499
dbus.String("last_checked_ok"):
500
(_datetime_to_dbus(self.last_checked_ok,
502
if self.last_checked_ok is not None
503
else dbus.Boolean (False, variant_level=1)),
504
dbus.String("timeout"):
505
dbus.UInt64(self.timeout_milliseconds(),
507
dbus.String("interval"):
508
dbus.UInt64(self.interval_milliseconds(),
510
dbus.String("checker"):
511
dbus.String(self.checker_command,
513
dbus.String("checker_running"):
514
dbus.Boolean(self.checker is not None,
516
dbus.String("object_path"):
517
dbus.ObjectPath(self.dbus_object_path,
521
# IsStillValid - method
522
IsStillValid = (dbus.service.method(_interface, out_signature="b")
524
IsStillValid.__name__ = "IsStillValid"
526
# PropertyChanged - signal
527
@dbus.service.signal(_interface, signature="sv")
528
def PropertyChanged(self, property, value):
532
# SetChecker - method
533
@dbus.service.method(_interface, in_signature="s")
534
def SetChecker(self, checker):
535
"D-Bus setter method"
536
self.checker_command = checker
538
self.PropertyChanged(dbus.String(u"checker"),
539
dbus.String(self.checker_command,
543
@dbus.service.method(_interface, in_signature="s")
544
def SetHost(self, host):
545
"D-Bus setter method"
548
self.PropertyChanged(dbus.String(u"host"),
549
dbus.String(self.host, variant_level=1))
551
# SetInterval - method
552
@dbus.service.method(_interface, in_signature="t")
553
def SetInterval(self, milliseconds):
554
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
556
self.PropertyChanged(dbus.String(u"interval"),
557
(dbus.UInt64(self.interval_milliseconds(),
561
@dbus.service.method(_interface, in_signature="ay",
563
def SetSecret(self, secret):
564
"D-Bus setter method"
565
self.secret = str(secret)
567
# SetTimeout - method
568
@dbus.service.method(_interface, in_signature="t")
569
def SetTimeout(self, milliseconds):
570
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
572
self.PropertyChanged(dbus.String(u"timeout"),
573
(dbus.UInt64(self.timeout_milliseconds(),
577
Enable = dbus.service.method(_interface)(enable)
578
Enable.__name__ = "Enable"
580
# StartChecker - method
581
@dbus.service.method(_interface)
582
def StartChecker(self):
587
@dbus.service.method(_interface)
592
# StopChecker - method
593
StopChecker = dbus.service.method(_interface)(stop_checker)
594
StopChecker.__name__ = "StopChecker"
599
def peer_certificate(session):
600
"Return the peer's OpenPGP certificate as a bytestring"
601
# If not an OpenPGP certificate...
602
if (gnutls.library.functions
603
.gnutls_certificate_type_get(session._c_object)
604
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
605
# ...do the normal thing
606
return session.peer_certificate
607
list_size = ctypes.c_uint(1)
608
cert_list = (gnutls.library.functions
609
.gnutls_certificate_get_peers
610
(session._c_object, ctypes.byref(list_size)))
611
if not bool(cert_list) and list_size.value != 0:
612
raise gnutls.errors.GNUTLSError("error getting peer"
614
if list_size.value == 0:
617
return ctypes.string_at(cert.data, cert.size)
620
def fingerprint(openpgp):
621
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
622
# New GnuTLS "datum" with the OpenPGP public key
623
datum = (gnutls.library.types
624
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
627
ctypes.c_uint(len(openpgp))))
628
# New empty GnuTLS certificate
629
crt = gnutls.library.types.gnutls_openpgp_crt_t()
630
(gnutls.library.functions
631
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
632
# Import the OpenPGP public key into the certificate
633
(gnutls.library.functions
634
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
635
gnutls.library.constants
636
.GNUTLS_OPENPGP_FMT_RAW))
637
# Verify the self signature in the key
638
crtverify = ctypes.c_uint()
639
(gnutls.library.functions
640
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
641
if crtverify.value != 0:
642
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
643
raise gnutls.errors.CertificateSecurityError("Verify failed")
644
# New buffer for the fingerprint
645
buf = ctypes.create_string_buffer(20)
646
buf_len = ctypes.c_size_t()
647
# Get the fingerprint from the certificate into the buffer
648
(gnutls.library.functions
649
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
650
ctypes.byref(buf_len)))
651
# Deinit the certificate
652
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
653
# Convert the buffer to a Python bytestring
654
fpr = ctypes.string_at(buf, buf_len.value)
655
# Convert the bytestring to hexadecimal notation
656
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
660
class TCP_handler(SocketServer.BaseRequestHandler, object):
661
"""A TCP request handler class.
662
Instantiated by IPv6_TCPServer for each request to handle it.
663
Note: This will run in its own forked process."""
666
logger.info(u"TCP connection from: %s",
667
unicode(self.client_address))
668
session = (gnutls.connection
669
.ClientSession(self.request,
673
line = self.request.makefile().readline()
674
logger.debug(u"Protocol version: %r", line)
676
if int(line.strip().split()[0]) > 1:
678
except (ValueError, IndexError, RuntimeError), error:
679
logger.error(u"Unknown protocol version: %s", error)
682
# Note: gnutls.connection.X509Credentials is really a generic
683
# GnuTLS certificate credentials object so long as no X.509
684
# keys are added to it. Therefore, we can use it here despite
685
# using OpenPGP certificates.
687
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
688
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
690
# Use a fallback default, since this MUST be set.
691
priority = self.server.settings.get("priority", "NORMAL")
692
(gnutls.library.functions
693
.gnutls_priority_set_direct(session._c_object,
698
except gnutls.errors.GNUTLSError, error:
699
logger.warning(u"Handshake failed: %s", error)
700
# Do not run session.bye() here: the session is not
701
# established. Just abandon the request.
703
logger.debug(u"Handshake succeeded")
705
fpr = fingerprint(peer_certificate(session))
706
except (TypeError, gnutls.errors.GNUTLSError), error:
707
logger.warning(u"Bad certificate: %s", error)
710
logger.debug(u"Fingerprint: %s", fpr)
712
for c in self.server.clients:
713
if c.fingerprint == fpr:
717
logger.warning(u"Client not found for fingerprint: %s",
721
# Have to check if client.still_valid(), since it is possible
722
# that the client timed out while establishing the GnuTLS
724
if not client.still_valid():
725
logger.warning(u"Client %(name)s is invalid",
729
## This won't work here, since we're in a fork.
730
# client.checked_ok()
732
while sent_size < len(client.secret):
733
sent = session.send(client.secret[sent_size:])
734
logger.debug(u"Sent: %d, remaining: %d",
735
sent, len(client.secret)
736
- (sent_size + sent))
53
self.socket.setsockopt(socket.SOL_SOCKET,
54
socket.SO_BINDTODEVICE,
55
self.options.interface)
56
except socket.error, error:
57
if error[0] == errno.EPERM:
58
print "Warning: No permission to bind to interface", \
59
self.options.interface
62
return super(type(self), self).server_bind()
63
attrs["server_bind"] = server_bind
64
def init(self, *args, **kwargs):
65
if "options" in kwargs:
66
self.options = kwargs["options"]
68
if "clients" in kwargs:
69
self.clients = kwargs["clients"]
71
if "credentials" in kwargs:
72
self.credentials = kwargs["credentials"]
73
del kwargs["credentials"]
74
return super(type(self), self).__init__(*args, **kwargs)
75
attrs["__init__"] = init
76
return type.__new__(cls, name, bases, attrs)
79
class udp_handler(SocketServer.DatagramRequestHandler, object):
81
self.wfile.write("Polo")
82
print "UDP request answered"
85
class IPv6_UDPServer(SocketServer.UDPServer, object):
86
__metaclass__ = server_metaclass
87
def verify_request(self, request, client_address):
88
print "UDP request came"
89
return request[0] == "Marco"
92
class tcp_handler(SocketServer.BaseRequestHandler, object):
94
print "TCP request came"
95
print "Request:", self.request
96
print "Client Address:", self.client_address
97
print "Server:", self.server
98
session = gnutls.connection.ServerSession(self.request,
99
self.server.credentials)
101
if session.peer_certificate:
102
print "DN:", session.peer_certificate.subject
104
session.verify_peer()
105
except gnutls.errors.CertificateError, error:
106
print "Verify failed", error
110
session.send(dict((client.dn, client.password)
111
for client in self.server.clients)
112
[session.peer_certificate.subject])
114
session.send("gazonk")
741
class IPv6_TCPServer(SocketServer.ForkingMixIn,
742
SocketServer.TCPServer, object):
743
"""IPv6-capable TCP server. Accepts 'None' as address and/or port.
745
settings: Server settings
746
clients: Set() of Client objects
747
enabled: Boolean; whether this server is activated yet
749
address_family = socket.AF_INET6
750
def __init__(self, *args, **kwargs):
751
if "settings" in kwargs:
752
self.settings = kwargs["settings"]
753
del kwargs["settings"]
754
if "clients" in kwargs:
755
self.clients = kwargs["clients"]
756
del kwargs["clients"]
757
if "use_ipv6" in kwargs:
758
if not kwargs["use_ipv6"]:
759
self.address_family = socket.AF_INET
760
del kwargs["use_ipv6"]
762
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
763
def server_bind(self):
764
"""This overrides the normal server_bind() function
765
to bind to an interface if one was specified, and also NOT to
766
bind to an address or port if they were not specified."""
767
if self.settings["interface"]:
768
# 25 is from /usr/include/asm-i486/socket.h
769
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
771
self.socket.setsockopt(socket.SOL_SOCKET,
773
self.settings["interface"])
774
except socket.error, error:
775
if error[0] == errno.EPERM:
776
logger.error(u"No permission to"
777
u" bind to interface %s",
778
self.settings["interface"])
781
# Only bind(2) the socket if we really need to.
782
if self.server_address[0] or self.server_address[1]:
783
if not self.server_address[0]:
784
if self.address_family == socket.AF_INET6:
785
any_address = "::" # in6addr_any
787
any_address = socket.INADDR_ANY
788
self.server_address = (any_address,
789
self.server_address[1])
790
elif not self.server_address[1]:
791
self.server_address = (self.server_address[0],
793
# if self.settings["interface"]:
794
# self.server_address = (self.server_address[0],
800
return super(IPv6_TCPServer, self).server_bind()
801
def server_activate(self):
803
return super(IPv6_TCPServer, self).server_activate()
119
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
120
__metaclass__ = server_metaclass
121
request_queue_size = 1024
808
126
def string_to_delta(interval):
809
127
"""Parse a string and return a datetime.timedelta
811
129
>>> string_to_delta('7d')
812
130
datetime.timedelta(7)
813
131
>>> string_to_delta('60s')
818
136
datetime.timedelta(1)
819
137
>>> string_to_delta(u'1w')
820
138
datetime.timedelta(7)
821
>>> string_to_delta('5m 30s')
822
datetime.timedelta(0, 330)
824
timevalue = datetime.timedelta(0)
825
for s in interval.split():
827
suffix = unicode(s[-1])
830
delta = datetime.timedelta(value)
832
delta = datetime.timedelta(0, value)
834
delta = datetime.timedelta(0, 0, 0, 0, value)
836
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
838
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
841
except (ValueError, IndexError):
141
suffix=unicode(interval[-1])
142
value=int(interval[:-1])
144
delta = datetime.timedelta(value)
146
delta = datetime.timedelta(0, value)
148
delta = datetime.timedelta(0, 0, 0, 0, value)
150
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
152
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
847
def server_state_changed(state):
848
"""Derived from the Avahi example code"""
849
if state == avahi.SERVER_COLLISION:
850
logger.error(u"Zeroconf server name collision")
852
elif state == avahi.SERVER_RUNNING:
856
def entry_group_state_changed(state, error):
857
"""Derived from the Avahi example code"""
858
logger.debug(u"Avahi state change: %i", state)
860
if state == avahi.ENTRY_GROUP_ESTABLISHED:
861
logger.debug(u"Zeroconf service established.")
862
elif state == avahi.ENTRY_GROUP_COLLISION:
863
logger.warning(u"Zeroconf service name collision.")
865
elif state == avahi.ENTRY_GROUP_FAILURE:
866
logger.critical(u"Avahi: Error in group state changed %s",
868
raise AvahiGroupError(u"State changed: %s" % unicode(error))
870
def if_nametoindex(interface):
871
"""Call the C function if_nametoindex(), or equivalent"""
872
global if_nametoindex
874
if_nametoindex = (ctypes.cdll.LoadLibrary
875
(ctypes.util.find_library("c"))
877
except (OSError, AttributeError):
878
if "struct" not in sys.modules:
880
if "fcntl" not in sys.modules:
882
def if_nametoindex(interface):
883
"Get an interface index the hard way, i.e. using fcntl()"
884
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
885
with closing(socket.socket()) as s:
886
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
887
struct.pack("16s16x", interface))
888
interface_index = struct.unpack("I", ifreq[16:20])[0]
889
return interface_index
890
return if_nametoindex(interface)
893
def daemon(nochdir = False, noclose = False):
894
"""See daemon(3). Standard BSD Unix function.
895
This should really exist as os.daemon, but it doesn't (yet)."""
904
# Close all standard open file descriptors
905
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
906
if not stat.S_ISCHR(os.fstat(null).st_mode):
907
raise OSError(errno.ENODEV,
908
"/dev/null not a character device")
909
os.dup2(null, sys.stdin.fileno())
910
os.dup2(null, sys.stdout.fileno())
911
os.dup2(null, sys.stderr.fileno())
155
except (ValueError, IndexError):
917
parser = optparse.OptionParser(version = "%%prog %s" % version)
161
parser = OptionParser()
918
162
parser.add_option("-i", "--interface", type="string",
919
metavar="IF", help="Bind to interface IF")
920
parser.add_option("-a", "--address", type="string",
921
help="Address to listen for requests on")
922
parser.add_option("-p", "--port", type="int",
163
default="eth0", metavar="IF",
164
help="Interface to bind to")
165
parser.add_option("--cert", type="string", default="cert.pem",
167
help="Public key certificate to use")
168
parser.add_option("--key", type="string", default="key.pem",
170
help="Private key to use")
171
parser.add_option("--ca", type="string", default="ca.pem",
173
help="Certificate Authority certificate to use")
174
parser.add_option("--crl", type="string", default="crl.pem",
176
help="Certificate Revokation List to use")
177
parser.add_option("-p", "--port", type="int", default=49001,
923
178
help="Port number to receive requests on")
924
parser.add_option("--check", action="store_true",
179
parser.add_option("--dh", type="int", metavar="BITS",
180
help="DH group to use")
181
parser.add_option("-t", "--timeout", type="string", # Parsed later
183
help="Amount of downtime allowed for clients")
184
parser.add_option("--interval", type="string", # Parsed later
186
help="How often to check that a client is up")
187
parser.add_option("--check", action="store_true", default=False,
925
188
help="Run self-test")
926
parser.add_option("--debug", action="store_true",
927
help="Debug mode; run in foreground and log to"
929
parser.add_option("--priority", type="string", help="GnuTLS"
930
" priority string (see GnuTLS documentation)")
931
parser.add_option("--servicename", type="string", metavar="NAME",
932
help="Zeroconf service name")
933
parser.add_option("--configdir", type="string",
934
default="/etc/mandos", metavar="DIR",
935
help="Directory to search for configuration"
937
parser.add_option("--no-dbus", action="store_false",
939
help="Do not provide D-Bus system bus"
941
parser.add_option("--no-ipv6", action="store_false",
942
dest="use_ipv6", help="Do not use IPv6")
943
options = parser.parse_args()[0]
189
(options, args) = parser.parse_args()
945
191
if options.check:
947
193
doctest.testmod()
950
# Default values for config file for server-global settings
951
server_defaults = { "interface": "",
956
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
957
"servicename": "Mandos",
962
# Parse config file for server-global settings
963
server_config = ConfigParser.SafeConfigParser(server_defaults)
965
server_config.read(os.path.join(options.configdir, "mandos.conf"))
966
# Convert the SafeConfigParser object to a dict
967
server_settings = server_config.defaults()
968
# Use the appropriate methods on the non-string config options
969
server_settings["debug"] = server_config.getboolean("DEFAULT",
971
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
973
server_settings["use_ipv6"] = server_config.getboolean("DEFAULT",
975
if server_settings["port"]:
976
server_settings["port"] = server_config.getint("DEFAULT",
980
# Override the settings from the config file with command line
982
for option in ("interface", "address", "port", "debug",
983
"priority", "servicename", "configdir",
984
"use_dbus", "use_ipv6"):
985
value = getattr(options, option)
986
if value is not None:
987
server_settings[option] = value
989
# Now we have our good server settings in "server_settings"
992
debug = server_settings["debug"]
993
use_dbus = server_settings["use_dbus"]
994
use_ipv6 = server_settings["use_ipv6"]
997
syslogger.setLevel(logging.WARNING)
998
console.setLevel(logging.WARNING)
1000
if server_settings["servicename"] != "Mandos":
1001
syslogger.setFormatter(logging.Formatter
1002
('Mandos (%s): %%(levelname)s:'
1004
% server_settings["servicename"]))
1006
# Parse config file with clients
1007
client_defaults = { "timeout": "1h",
1009
"checker": "fping -q -- %%(host)s",
1012
client_config = ConfigParser.SafeConfigParser(client_defaults)
1013
client_config.read(os.path.join(server_settings["configdir"],
1017
tcp_server = IPv6_TCPServer((server_settings["address"],
1018
server_settings["port"]),
1020
settings=server_settings,
1021
clients=clients, use_ipv6=use_ipv6)
1022
pidfilename = "/var/run/mandos.pid"
1024
pidfile = open(pidfilename, "w")
1026
logger.error("Could not open file %r", pidfilename)
1029
uid = pwd.getpwnam("_mandos").pw_uid
1030
gid = pwd.getpwnam("_mandos").pw_gid
1033
uid = pwd.getpwnam("mandos").pw_uid
1034
gid = pwd.getpwnam("mandos").pw_gid
1037
uid = pwd.getpwnam("nobody").pw_uid
1038
gid = pwd.getpwnam("nogroup").pw_gid
1045
except OSError, error:
1046
if error[0] != errno.EPERM:
1049
# Enable all possible GnuTLS debugging
1051
# "Use a log level over 10 to enable all debugging options."
1053
gnutls.library.functions.gnutls_global_set_log_level(11)
1055
@gnutls.library.types.gnutls_log_func
1056
def debug_gnutls(level, string):
1057
logger.debug("GnuTLS: %s", string[:-1])
1059
(gnutls.library.functions
1060
.gnutls_global_set_log_function(debug_gnutls))
1063
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1064
service = AvahiService(name = server_settings["servicename"],
1065
servicetype = "_mandos._tcp",
1066
protocol = protocol)
1067
if server_settings["interface"]:
1068
service.interface = (if_nametoindex
1069
(server_settings["interface"]))
1074
# From the Avahi example code
1075
DBusGMainLoop(set_as_default=True )
1076
main_loop = gobject.MainLoop()
1077
bus = dbus.SystemBus()
1078
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1079
avahi.DBUS_PATH_SERVER),
1080
avahi.DBUS_INTERFACE_SERVER)
1081
# End of Avahi example code
1083
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1085
clients.update(Set(Client(name = section,
1087
= dict(client_config.items(section)),
1088
use_dbus = use_dbus)
1089
for section in client_config.sections()))
1091
logger.warning(u"No clients defined")
1094
# Redirect stdin so all checkers get /dev/null
1095
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1096
os.dup2(null, sys.stdin.fileno())
1100
# No console logging
1101
logger.removeHandler(console)
1102
# Close all input and output, do double fork, etc.
1107
pidfile.write(str(pid) + "\n")
1111
logger.error(u"Could not write to file %r with PID %d",
1114
# "pidfile" was never created
1119
"Cleanup function; run on exit"
1121
# From the Avahi example code
1122
if not group is None:
1125
# End of Avahi example code
1128
client = clients.pop()
1129
client.disable_hook = None
1132
atexit.register(cleanup)
1135
signal.signal(signal.SIGINT, signal.SIG_IGN)
1136
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1137
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1140
class MandosServer(dbus.service.Object):
1141
"""A D-Bus proxy object"""
1143
dbus.service.Object.__init__(self, bus, "/")
1144
_interface = u"se.bsnet.fukt.Mandos"
1146
@dbus.service.signal(_interface, signature="oa{sv}")
1147
def ClientAdded(self, objpath, properties):
1151
@dbus.service.signal(_interface, signature="os")
1152
def ClientRemoved(self, objpath, name):
1156
@dbus.service.method(_interface, out_signature="ao")
1157
def GetAllClients(self):
1159
return dbus.Array(c.dbus_object_path for c in clients)
1161
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1162
def GetAllClientsWithProperties(self):
1164
return dbus.Dictionary(
1165
((c.dbus_object_path, c.GetAllProperties())
1169
@dbus.service.method(_interface, in_signature="o")
1170
def RemoveClient(self, object_path):
1173
if c.dbus_object_path == object_path:
1175
# Don't signal anything except ClientRemoved
1179
self.ClientRemoved(object_path, c.name)
1185
mandos_server = MandosServer()
1187
for client in clients:
1190
mandos_server.ClientAdded(client.dbus_object_path,
1191
client.GetAllProperties())
1195
tcp_server.server_activate()
1197
# Find out what port we got
1198
service.port = tcp_server.socket.getsockname()[1]
1200
logger.info(u"Now listening on address %r, port %d,"
1201
" flowinfo %d, scope_id %d"
1202
% tcp_server.socket.getsockname())
1204
logger.info(u"Now listening on address %r, port %d"
1205
% tcp_server.socket.getsockname())
1207
#service.interface = tcp_server.socket.getsockname()[3]
1210
# From the Avahi example code
1211
server.connect_to_signal("StateChanged", server_state_changed)
1213
server_state_changed(server.GetState())
1214
except dbus.exceptions.DBusException, error:
1215
logger.critical(u"DBusException: %s", error)
1217
# End of Avahi example code
1219
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1220
lambda *args, **kwargs:
1221
(tcp_server.handle_request
1222
(*args[2:], **kwargs) or True))
1224
logger.debug(u"Starting main loop")
1226
except AvahiError, error:
1227
logger.critical(u"AvahiError: %s", error)
1229
except KeyboardInterrupt:
1232
logger.debug("Server received KeyboardInterrupt")
1233
logger.debug("Server exiting")
1235
if __name__ == '__main__':
196
# Parse the time arguments
198
options.timeout = string_to_delta(options.timeout)
200
parser.error("option --timeout: Unparseable time")
203
options.interval = string_to_delta(options.interval)
205
parser.error("option --interval: Unparseable time")
207
cert = gnutls.crypto.X509Certificate(open(options.cert).read())
208
key = gnutls.crypto.X509PrivateKey(open(options.key).read())
209
ca = gnutls.crypto.X509Certificate(open(options.ca).read())
210
crl = gnutls.crypto.X509CRL(open(options.crl).read())
211
cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])
215
client_config_object = ConfigParser.SafeConfigParser(defaults)
216
client_config_object.read("mandos-clients.conf")
217
clients = [Client(name=section, options=options,
218
**(dict(client_config_object.items(section))))
219
for section in client_config_object.sections()]
221
udp_server = IPv6_UDPServer((in6addr_any, options.port),
225
tcp_server = IPv6_TCPServer((in6addr_any, options.port),
232
in_, out, err = select.select((udp_server,
235
server.handle_request()
238
if __name__ == "__main__":