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
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
13
# Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
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
61
62
from dbus.mainloop.glib import DBusGMainLoop
65
# Brief description of the operation of this program:
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.
65
77
logger = logging.Logger('mandos')
66
78
syslogger = logging.handlers.SysLogHandler\
70
82
logger.addHandler(syslogger)
74
class AvahiError(Exception):
75
def __init__(self, value):
78
return repr(self.value)
80
class AvahiServiceError(AvahiError):
83
class AvahiGroupError(AvahiError):
87
class AvahiService(object):
88
"""An Avahi (Zeroconf) service.
90
interface: integer; avahi.IF_UNSPEC or an interface index.
91
Used to optionally bind to the specified interface.
92
name: string; Example: 'Mandos'
93
type: string; Example: '_mandos._tcp'.
94
See <http://www.dns-sd.org/ServiceTypes.html>
95
port: integer; what port to announce
96
TXT: list of strings; TXT record for the service
97
domain: string; Domain to publish on, default to .local if empty.
98
host: string; Host to publish records for, default is localhost
99
max_renames: integer; maximum number of renames
100
rename_count: integer; counter so we only rename after collisions
101
a sensible number of times
103
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
104
type = None, port = None, TXT = None, domain = "",
105
host = "", max_renames = 12):
106
self.interface = interface
116
self.rename_count = 0
118
"""Derived from the Avahi example code"""
119
if self.rename_count >= self.max_renames:
120
logger.critical(u"No suitable service name found after %i"
121
u" retries, exiting.", rename_count)
122
raise AvahiServiceError("Too many renames")
123
name = server.GetAlternativeServiceName(name)
124
logger.error(u"Changing name to %r ...", name)
127
self.rename_count += 1
129
"""Derived from the Avahi example code"""
130
if group is not None:
133
"""Derived from the Avahi example code"""
136
group = dbus.Interface\
137
(bus.get_object(avahi.DBUS_NAME,
138
server.EntryGroupNew()),
139
avahi.DBUS_INTERFACE_ENTRY_GROUP)
140
group.connect_to_signal('StateChanged',
141
entry_group_state_changed)
142
logger.debug(u"Adding service '%s' of type '%s' ...",
143
service.name, service.type)
145
self.interface, # interface
146
avahi.PROTO_INET6, # protocol
147
dbus.UInt32(0), # flags
148
self.name, self.type,
149
self.domain, self.host,
150
dbus.UInt16(self.port),
151
avahi.string_array_to_txt_array(self.TXT))
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
88
serviceInterface = avahi.IF_UNSPEC
154
89
# From the Avahi example code:
155
group = None # our entry group
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
156
99
# End of Avahi example code
164
107
uniquely identify the client
165
108
secret: bytestring; sent verbatim (over TLS) to client
166
109
fqdn: string (FQDN); available for use by the checker command
167
created: datetime.datetime(); object creation, not client host
168
last_checked_ok: datetime.datetime() or None if not yet checked OK
169
timeout: datetime.timedelta(); How long from last_checked_ok
170
until this client is invalid
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
171
114
interval: datetime.timedelta(); How often to start a new checker
172
115
stop_hook: If set, called by stop() as stop_hook(self)
173
116
checker: subprocess.Popen(); a running checker process used
174
117
to see if the client lives.
175
'None' if no process is running.
118
Is None if no process is running.
176
119
checker_initiator_tag: a gobject event source tag, or None
177
120
stop_initiator_tag: - '' -
178
121
checker_callback_tag: - '' -
179
122
checker_command: string; External command which is run to check if
180
client lives. %() expansions are done at
123
client lives. %()s expansions are done at
181
124
runtime with vars(self) as dict, so that for
182
125
instance %(name)s can be used in the command.
183
126
Private attibutes:
184
127
_timeout: Real variable for 'timeout'
185
128
_interval: Real variable for 'interval'
186
_timeout_milliseconds: Used when calling gobject.timeout_add()
129
_timeout_milliseconds: Used by gobject.timeout_add()
187
130
_interval_milliseconds: - '' -
189
132
def _set_timeout(self, timeout):
209
152
interval = property(lambda self: self._interval,
211
154
del _set_interval
212
def __init__(self, name = None, stop_hook=None, config={}):
213
"""Note: the 'checker' key in 'config' sets the
214
'checker_command' attribute and *not* the 'checker'
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.."""
217
161
logger.debug(u"Creating client %r", self.name)
218
# Uppercase and remove spaces from fingerprint for later
219
# comparison purposes with return value from the fingerprint()
221
self.fingerprint = config["fingerprint"].upper()\
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"")
223
166
logger.debug(u" Fingerprint: %s", self.fingerprint)
224
if "secret" in config:
225
self.secret = config["secret"].decode(u"base64")
226
elif "secfile" in config:
227
sf = open(config["secfile"])
168
self.secret = secret.decode(u"base64")
228
171
self.secret = sf.read()
231
raise TypeError(u"No secret or secfile for client %s"
233
self.fqdn = config.get("fqdn", "")
174
raise RuntimeError(u"No secret or secfile for client %s"
176
self.fqdn = fqdn # string
234
177
self.created = datetime.datetime.now()
235
self.last_checked_ok = None
236
self.timeout = string_to_delta(config["timeout"])
237
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)
238
181
self.stop_hook = stop_hook
239
182
self.checker = None
240
183
self.checker_initiator_tag = None
241
184
self.stop_initiator_tag = None
242
185
self.checker_callback_tag = None
243
self.check_command = config["checker"]
186
self.check_command = checker
245
188
"""Start this client's checker and timeout hooks"""
246
189
# Schedule a new checker to be started an 'interval' from now,
258
201
"""Stop this client.
259
The possibility that a client might be restarted is left open,
260
but not currently used."""
202
The possibility that this client might be restarted is left
203
open, but not currently used."""
261
204
# If this client doesn't have a secret, it is already stopped.
263
logger.info(u"Stopping client %s", self.name)
206
logger.debug(u"Stopping client %s", self.name)
264
207
self.secret = None
267
if getattr(self, "stop_initiator_tag", False):
210
if hasattr(self, "stop_initiator_tag") \
211
and self.stop_initiator_tag:
268
212
gobject.source_remove(self.stop_initiator_tag)
269
213
self.stop_initiator_tag = None
270
if getattr(self, "checker_initiator_tag", False):
214
if hasattr(self, "checker_initiator_tag") \
215
and self.checker_initiator_tag:
271
216
gobject.source_remove(self.checker_initiator_tag)
272
217
self.checker_initiator_tag = None
273
218
self.stop_checker()
312
257
# is as it should be.
313
258
if self.checker is None:
315
# In case check_command has exactly one % operator
316
260
command = self.check_command % self.fqdn
317
261
except TypeError:
318
# Escape attributes for the shell
319
262
escaped_attrs = dict((key, re.escape(str(val)))
321
264
vars(self).iteritems())
323
266
command = self.check_command % escaped_attrs
324
267
except TypeError, error:
325
logger.error(u'Could not format string "%s":'
326
u' %s', self.check_command, error)
268
logger.critical(u'Could not format string "%s":'
269
u' %s', self.check_command, error)
327
270
return True # Try again later
329
logger.info(u"Starting checker %r for %s",
331
self.checker = subprocess.Popen(command,
272
logger.debug(u"Starting checker %r for %s",
274
self.checker = subprocess.\
276
close_fds=True, shell=True,
334
278
self.checker_callback_tag = gobject.child_watch_add\
335
279
(self.checker.pid,
336
280
self.checker_callback)
353
297
#if self.checker.poll() is None:
354
298
# os.kill(self.checker.pid, signal.SIGKILL)
355
299
except OSError, error:
356
if error.errno != errno.ESRCH: # No such process
300
if error.errno != errno.ESRCH:
358
302
self.checker = None
359
def still_valid(self):
303
def still_valid(self, now=None):
360
304
"""Has the timeout not yet passed for this client?"""
361
now = datetime.datetime.now()
362
if self.last_checked_ok is None:
306
now = datetime.datetime.now()
307
if self.last_seen is None:
363
308
return now < (self.created + self.timeout)
365
return now < (self.last_checked_ok + self.timeout)
310
return now < (self.last_seen + self.timeout)
368
313
def peer_certificate(session):
385
330
def fingerprint(openpgp):
386
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\
387
336
# New GnuTLS "datum" with the OpenPGP public key
388
337
datum = gnutls.library.types.gnutls_datum_t\
389
338
(ctypes.cast(ctypes.c_char_p(openpgp),
390
339
ctypes.POINTER(ctypes.c_ubyte)),
391
340
ctypes.c_uint(len(openpgp)))
392
# New empty GnuTLS certificate
393
crt = gnutls.library.types.gnutls_openpgp_crt_t()
394
gnutls.library.functions.gnutls_openpgp_crt_init\
396
341
# Import the OpenPGP public key into the certificate
397
gnutls.library.functions.gnutls_openpgp_crt_import\
398
(crt, ctypes.byref(datum),
399
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
342
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
345
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
400
346
# New buffer for the fingerprint
401
347
buffer = ctypes.create_string_buffer(20)
402
348
buffer_length = ctypes.c_size_t()
418
364
Note: This will run in its own forked process."""
420
366
def handle(self):
421
logger.info(u"TCP connection from: %s",
367
logger.debug(u"TCP connection from: %s",
422
368
unicode(self.client_address))
423
session = gnutls.connection.ClientSession\
424
(self.request, gnutls.connection.X509Credentials())
426
line = self.request.makefile().readline()
427
logger.debug(u"Protocol version: %r", line)
429
if int(line.strip().split()[0]) > 1:
431
except (ValueError, IndexError, RuntimeError), error:
432
logger.error(u"Unknown protocol version: %s", error)
435
# Note: gnutls.connection.X509Credentials is really a generic
436
# GnuTLS certificate credentials object so long as no X.509
437
# keys are added to it. Therefore, we can use it here despite
438
# using OpenPGP certificates.
369
session = gnutls.connection.ClientSession(self.request,
440
373
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
441
374
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
443
priority = "NORMAL" # Fallback default, since this
445
if self.server.settings["priority"]:
446
priority = self.server.settings["priority"]
377
if self.server.options.priority:
378
priority = self.server.options.priority
447
379
gnutls.library.functions.gnutls_priority_set_direct\
448
380
(session._c_object, priority, None);
451
383
session.handshake()
452
384
except gnutls.errors.GNUTLSError, error:
453
logger.warning(u"Handshake failed: %s", error)
385
logger.debug(u"Handshake failed: %s", error)
454
386
# Do not run session.bye() here: the session is not
455
387
# established. Just abandon the request.
458
390
fpr = fingerprint(peer_certificate(session))
459
391
except (TypeError, gnutls.errors.GNUTLSError), error:
460
logger.warning(u"Bad certificate: %s", error)
392
logger.debug(u"Bad certificate: %s", error)
463
395
logger.debug(u"Fingerprint: %s", fpr)
508
439
"""This overrides the normal server_bind() function
509
440
to bind to an interface if one was specified, and also NOT to
510
441
bind to an address or port if they were not specified."""
511
if self.settings["interface"]:
512
# 25 is from /usr/include/asm-i486/socket.h
513
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
515
447
self.socket.setsockopt(socket.SOL_SOCKET,
517
self.settings["interface"])
448
socket.SO_BINDTODEVICE,
449
self.options.interface)
518
450
except socket.error, error:
519
451
if error[0] == errno.EPERM:
520
logger.error(u"No permission to"
521
u" bind to interface %s",
522
self.settings["interface"])
452
logger.warning(u"No permission to"
453
u" bind to interface %s",
454
self.options.interface)
525
457
# Only bind(2) the socket if we really need to.
504
"""Derived from the Avahi example code"""
505
global group, serviceName, serviceType, servicePort, serviceTXT, \
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)
518
serviceInterface, # interface
519
avahi.PROTO_INET6, # protocol
520
dbus.UInt32(0), # flags
521
serviceName, serviceType,
523
dbus.UInt16(servicePort),
524
avahi.string_array_to_txt_array(serviceTXT))
528
def remove_service():
529
"""From the Avahi example code"""
532
if not group is None:
578
536
def server_state_changed(state):
579
537
"""Derived from the Avahi example code"""
580
538
if state == avahi.SERVER_COLLISION:
581
logger.error(u"Server name collision")
539
logger.warning(u"Server name collision")
583
541
elif state == avahi.SERVER_RUNNING:
587
545
def entry_group_state_changed(state, error):
588
546
"""Derived from the Avahi example code"""
547
global serviceName, server, rename_count
589
549
logger.debug(u"state change: %i", state)
591
551
if state == avahi.ENTRY_GROUP_ESTABLISHED:
592
552
logger.debug(u"Service established.")
593
553
elif state == avahi.ENTRY_GROUP_COLLISION:
594
logger.warning(u"Service name collision.")
555
rename_count = rename_count - 1
557
name = server.GetAlternativeServiceName(name)
558
logger.warning(u"Service name collision, "
559
u"changing name to '%s' ...", name)
564
logger.error(u"No suitable service name found after %i"
565
u" retries, exiting.", n_rename)
596
567
elif state == avahi.ENTRY_GROUP_FAILURE:
597
logger.critical(u"Error in group state changed %s",
599
raise AvahiGroupError("State changed: %s", str(error))
568
logger.error(u"Error in group state changed %s",
601
573
def if_nametoindex(interface):
602
"""Call the C function if_nametoindex(), or equivalent"""
603
global if_nametoindex
574
"""Call the C function if_nametoindex()"""
605
if "ctypes.util" not in sys.modules:
607
if_nametoindex = ctypes.cdll.LoadLibrary\
608
(ctypes.util.find_library("c")).if_nametoindex
576
libc = ctypes.cdll.LoadLibrary("libc.so.6")
577
return libc.if_nametoindex(interface)
609
578
except (OSError, AttributeError):
610
579
if "struct" not in sys.modules:
612
581
if "fcntl" not in sys.modules:
614
def if_nametoindex(interface):
615
"Get an interface index the hard way, i.e. using fcntl()"
616
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
618
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
619
struct.pack("16s16x", interface))
621
interface_index = struct.unpack("I", ifreq[16:20])[0]
622
return interface_index
623
return if_nametoindex(interface)
626
def daemon(nochdir = False, noclose = False):
583
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
585
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
586
struct.pack("16s16x", interface))
588
interface_index = struct.unpack("I", ifreq[16:20])[0]
589
return interface_index
592
def daemon(nochdir, noclose):
627
593
"""See daemon(3). Standard BSD Unix function.
628
594
This should really exist as os.daemon, but it doesn't (yet)."""
613
def killme(status = 0):
614
logger.debug("Stopping server with exit status %d", status)
616
if main_loop_started:
650
625
global main_loop_started
651
626
main_loop_started = False
653
628
parser = OptionParser()
654
629
parser.add_option("-i", "--interface", type="string",
655
metavar="IF", help="Bind to interface IF")
656
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,
657
633
help="Address to listen for requests on")
658
parser.add_option("-p", "--port", type="int",
634
parser.add_option("-p", "--port", type="int", default=None,
659
635
help="Port number to receive requests on")
660
636
parser.add_option("--check", action="store_true", default=False,
661
637
help="Run self-test")
662
parser.add_option("--debug", action="store_true",
663
help="Debug mode; run in foreground and log to"
665
parser.add_option("--priority", type="string", help="GnuTLS"
666
" priority string (see GnuTLS documentation)")
667
parser.add_option("--servicename", type="string", metavar="NAME",
668
help="Zeroconf service name")
669
parser.add_option("--configdir", type="string",
670
default="/etc/mandos", metavar="DIR",
671
help="Directory to search for configuration"
638
parser.add_option("--debug", action="store_true", default=False,
640
parser.add_option("--priority", type="string",
642
help="GnuTLS priority string"
643
" (see GnuTLS documentation)")
644
parser.add_option("--servicename", type="string",
645
default="Mandos", help="Zeroconf service name")
673
646
(options, args) = parser.parse_args()
675
648
if options.check:
677
650
doctest.testmod()
680
# Default values for config file for server-global settings
681
server_defaults = { "interface": "",
686
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
687
"servicename": "Mandos",
690
# Parse config file for server-global settings
691
server_config = ConfigParser.SafeConfigParser(server_defaults)
693
server_config.read(os.path.join(options.configdir, "mandos.conf"))
694
server_section = "server"
695
# Convert the SafeConfigParser object to a dict
696
server_settings = dict(server_config.items(server_section))
697
# Use getboolean on the boolean config option
698
server_settings["debug"] = server_config.getboolean\
699
(server_section, "debug")
702
# Override the settings from the config file with command line
704
for option in ("interface", "address", "port", "debug",
705
"priority", "servicename", "configdir"):
706
value = getattr(options, option)
707
if value is not None:
708
server_settings[option] = value
710
# Now we have our good server settings in "server_settings"
712
# Parse config file with clients
713
client_defaults = { "timeout": "1h",
715
"checker": "fping -q -- %%(fqdn)s",
717
client_config = ConfigParser.SafeConfigParser(client_defaults)
718
client_config.read(os.path.join(server_settings["configdir"],
722
service = AvahiService(name = server_settings["servicename"],
723
type = "_mandos._tcp", );
724
if server_settings["interface"]:
725
service.interface = if_nametoindex(server_settings["interface"])
654
defaults = { "timeout": "1h",
656
"checker": "fping -q -- %%(fqdn)s",
658
client_config = ConfigParser.SafeConfigParser(defaults)
659
#client_config.readfp(open("global.conf"), "global.conf")
660
client_config.read("mandos-clients.conf")
663
serviceName = options.servicename;
782
720
signal.signal(signal.SIGINT, signal.SIG_IGN)
783
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
784
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())
786
724
for client in clients:
789
tcp_server = IPv6_TCPServer((server_settings["address"],
790
server_settings["port"]),
727
tcp_server = IPv6_TCPServer((options.address, options.port),
792
settings=server_settings,
794
# Find out what port we got
795
service.port = tcp_server.socket.getsockname()[1]
796
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
797
u" scope_id %d" % tcp_server.socket.getsockname())
799
#service.interface = tcp_server.socket.getsockname()[3]
802
# From the Avahi example code
803
server.connect_to_signal("StateChanged", server_state_changed)
805
server_state_changed(server.GetState())
806
except dbus.exceptions.DBusException, error:
807
logger.critical(u"DBusException: %s", error)
809
# End of Avahi example code
811
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
812
lambda *args, **kwargs:
813
tcp_server.handle_request\
814
(*args[2:], **kwargs) or True)
731
# Find out what random port we got
733
servicePort = tcp_server.socket.getsockname()[1]
734
logger.debug(u"Now listening on port %d", servicePort)
736
if options.interface is not None:
737
global serviceInterface
738
serviceInterface = if_nametoindex(options.interface)
740
# From the Avahi example code
741
server.connect_to_signal("StateChanged", server_state_changed)
743
server_state_changed(server.GetState())
744
except dbus.exceptions.DBusException, error:
745
logger.critical(u"DBusException: %s", error)
747
# End of Avahi example code
749
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
750
lambda *args, **kwargs:
751
tcp_server.handle_request(*args[2:],
816
754
logger.debug("Starting main loop")
817
755
main_loop_started = True
819
except AvahiError, error:
820
logger.critical(u"AvahiError: %s" + unicode(error))
822
757
except KeyboardInterrupt:
826
763
if __name__ == '__main__':