6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# following functions: "add_service", "remove_service",
9
# following functions: "AvahiService.add", "AvahiService.remove",
10
10
# "server_state_changed", "entry_group_state_changed", and some lines
13
# Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
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
82
81
logger.addHandler(syslogger)
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
85
class AvahiError(Exception):
86
def __init__(self, value):
89
return repr(self.value)
91
class AvahiServiceError(AvahiError):
94
class AvahiGroupError(AvahiError):
98
class AvahiService(object):
99
"""An Avahi (Zeroconf) service.
101
interface: integer; avahi.IF_UNSPEC or an interface index.
102
Used to optionally bind to the specified interface.
103
name: string; Example: 'Mandos'
104
type: string; Example: '_mandos._tcp'.
105
See <http://www.dns-sd.org/ServiceTypes.html>
106
port: integer; what port to announce
107
TXT: list of strings; TXT record for the service
108
domain: string; Domain to publish on, default to .local if empty.
109
host: string; Host to publish records for, default is localhost
110
max_renames: integer; maximum number of renames
111
rename_count: integer; counter so we only rename after collisions
112
a sensible number of times
114
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
type = None, port = None, TXT = None, domain = "",
116
host = "", max_renames = 12):
117
self.interface = interface
127
self.rename_count = 0
129
"""Derived from the Avahi example code"""
130
if self.rename_count >= self.max_renames:
131
logger.critical(u"No suitable service name found after %i"
132
u" retries, exiting.", rename_count)
133
raise AvahiServiceError("Too many renames")
134
name = server.GetAlternativeServiceName(name)
135
logger.error(u"Changing name to %r ...", name)
138
self.rename_count += 1
140
"""Derived from the Avahi example code"""
141
if group is not None:
144
"""Derived from the Avahi example code"""
147
group = dbus.Interface\
148
(bus.get_object(avahi.DBUS_NAME,
149
server.EntryGroupNew()),
150
avahi.DBUS_INTERFACE_ENTRY_GROUP)
151
group.connect_to_signal('StateChanged',
152
entry_group_state_changed)
153
logger.debug(u"Adding service '%s' of type '%s' ...",
154
service.name, service.type)
156
self.interface, # interface
157
avahi.PROTO_INET6, # protocol
158
dbus.UInt32(0), # flags
159
self.name, self.type,
160
self.domain, self.host,
161
dbus.UInt16(self.port),
162
avahi.string_array_to_txt_array(self.TXT))
89
165
# From the Avahi example code:
90
serviceName = "Mandos"
91
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
92
servicePort = None # Not known at startup
93
serviceTXT = [] # TXT record for the service
94
domain = "" # Domain to publish on, default to .local
95
host = "" # Host to publish records for, default to localhost
96
group = None #our entry group
97
rename_count = 12 # Counter so we only rename after collisions a
98
# sensible number of times
166
group = None # our entry group
99
167
# End of Avahi example code
107
175
uniquely identify the client
108
176
secret: bytestring; sent verbatim (over TLS) to client
109
177
fqdn: string (FQDN); available for use by the checker command
110
created: datetime.datetime()
111
last_seen: datetime.datetime() or None if not yet seen
112
timeout: datetime.timedelta(); How long from last_seen until
113
this client is invalid
178
created: datetime.datetime(); object creation, not client host
179
last_checked_ok: datetime.datetime() or None if not yet checked OK
180
timeout: datetime.timedelta(); How long from last_checked_ok
181
until this client is invalid
114
182
interval: datetime.timedelta(); How often to start a new checker
115
183
stop_hook: If set, called by stop() as stop_hook(self)
116
184
checker: subprocess.Popen(); a running checker process used
117
185
to see if the client lives.
118
Is None if no process is running.
186
'None' if no process is running.
119
187
checker_initiator_tag: a gobject event source tag, or None
120
188
stop_initiator_tag: - '' -
121
189
checker_callback_tag: - '' -
122
190
checker_command: string; External command which is run to check if
123
client lives. %()s expansions are done at
191
client lives. %() expansions are done at
124
192
runtime with vars(self) as dict, so that for
125
193
instance %(name)s can be used in the command.
126
194
Private attibutes:
127
195
_timeout: Real variable for 'timeout'
128
196
_interval: Real variable for 'interval'
129
_timeout_milliseconds: Used by gobject.timeout_add()
197
_timeout_milliseconds: Used when calling gobject.timeout_add()
130
198
_interval_milliseconds: - '' -
132
200
def _set_timeout(self, timeout):
152
220
interval = property(lambda self: self._interval,
154
222
del _set_interval
155
def __init__(self, name=None, options=None, stop_hook=None,
156
fingerprint=None, secret=None, secfile=None,
157
fqdn=None, timeout=None, interval=-1, checker=None):
158
"""Note: the 'checker' argument sets the 'checker_command'
159
attribute and not the 'checker' attribute.."""
223
def __init__(self, name = None, stop_hook=None, config={}):
224
"""Note: the 'checker' key in 'config' sets the
225
'checker_command' attribute and *not* the 'checker'
161
# Uppercase and remove spaces from fingerprint
162
# for later comparison purposes with return value of
163
# the fingerprint() function
164
self.fingerprint = fingerprint.upper().replace(u" ", u"")
166
self.secret = secret.decode(u"base64")
228
logger.debug(u"Creating client %r", self.name)
229
# Uppercase and remove spaces from fingerprint for later
230
# comparison purposes with return value from the fingerprint()
232
self.fingerprint = config["fingerprint"].upper()\
234
logger.debug(u" Fingerprint: %s", self.fingerprint)
235
if "secret" in config:
236
self.secret = config["secret"].decode(u"base64")
237
elif "secfile" in config:
238
sf = open(config["secfile"])
169
239
self.secret = sf.read()
172
raise RuntimeError(u"No secret or secfile for client %s"
174
self.fqdn = fqdn # string
242
raise TypeError(u"No secret or secfile for client %s"
244
self.fqdn = config.get("fqdn", "")
175
245
self.created = datetime.datetime.now()
176
self.last_seen = None
178
self.timeout = options.timeout
180
self.timeout = string_to_delta(timeout)
182
self.interval = options.interval
184
self.interval = string_to_delta(interval)
246
self.last_checked_ok = None
247
self.timeout = string_to_delta(config["timeout"])
248
self.interval = string_to_delta(config["interval"])
185
249
self.stop_hook = stop_hook
186
250
self.checker = None
187
251
self.checker_initiator_tag = None
188
252
self.stop_initiator_tag = None
189
253
self.checker_callback_tag = None
190
self.check_command = checker
254
self.check_command = config["checker"]
192
256
"""Start this client's checker and timeout hooks"""
193
257
# Schedule a new checker to be started an 'interval' from now,
205
269
"""Stop this client.
206
The possibility that this client might be restarted is left
207
open, but not currently used."""
270
The possibility that a client might be restarted is left open,
271
but not currently used."""
208
272
# If this client doesn't have a secret, it is already stopped.
210
logger.debug(u"Stopping client %s", self.name)
274
logger.info(u"Stopping client %s", self.name)
211
275
self.secret = None
214
if hasattr(self, "stop_initiator_tag") \
215
and self.stop_initiator_tag:
278
if getattr(self, "stop_initiator_tag", False):
216
279
gobject.source_remove(self.stop_initiator_tag)
217
280
self.stop_initiator_tag = None
218
if hasattr(self, "checker_initiator_tag") \
219
and self.checker_initiator_tag:
281
if getattr(self, "checker_initiator_tag", False):
220
282
gobject.source_remove(self.checker_initiator_tag)
221
283
self.checker_initiator_tag = None
222
284
self.stop_checker()
261
323
# is as it should be.
262
324
if self.checker is None:
326
# In case check_command has exactly one % operator
264
327
command = self.check_command % self.fqdn
265
328
except TypeError:
329
# Escape attributes for the shell
266
330
escaped_attrs = dict((key, re.escape(str(val)))
268
332
vars(self).iteritems())
270
334
command = self.check_command % escaped_attrs
271
335
except TypeError, error:
272
logger.critical(u'Could not format string "%s":'
273
u' %s', self.check_command, error)
336
logger.error(u'Could not format string "%s":'
337
u' %s', self.check_command, error)
274
338
return True # Try again later
276
logger.debug(u"Starting checker %r for %s",
278
self.checker = subprocess.\
280
close_fds=True, shell=True,
340
logger.info(u"Starting checker %r for %s",
342
self.checker = subprocess.Popen(command,
282
345
self.checker_callback_tag = gobject.child_watch_add\
283
346
(self.checker.pid,
284
347
self.checker_callback)
301
364
#if self.checker.poll() is None:
302
365
# os.kill(self.checker.pid, signal.SIGKILL)
303
366
except OSError, error:
304
if error.errno != errno.ESRCH:
367
if error.errno != errno.ESRCH: # No such process
306
369
self.checker = None
307
def still_valid(self, now=None):
370
def still_valid(self):
308
371
"""Has the timeout not yet passed for this client?"""
310
now = datetime.datetime.now()
311
if self.last_seen is None:
372
now = datetime.datetime.now()
373
if self.last_checked_ok is None:
312
374
return now < (self.created + self.timeout)
314
return now < (self.last_seen + self.timeout)
376
return now < (self.last_checked_ok + self.timeout)
317
379
def peer_certificate(session):
334
396
def fingerprint(openpgp):
335
397
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
336
# New empty GnuTLS certificate
337
crt = gnutls.library.types.gnutls_openpgp_crt_t()
338
gnutls.library.functions.gnutls_openpgp_crt_init\
340
398
# New GnuTLS "datum" with the OpenPGP public key
341
399
datum = gnutls.library.types.gnutls_datum_t\
342
400
(ctypes.cast(ctypes.c_char_p(openpgp),
343
401
ctypes.POINTER(ctypes.c_ubyte)),
344
402
ctypes.c_uint(len(openpgp)))
403
# New empty GnuTLS certificate
404
crt = gnutls.library.types.gnutls_openpgp_crt_t()
405
gnutls.library.functions.gnutls_openpgp_crt_init\
345
407
# Import the OpenPGP public key into the certificate
346
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
349
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
408
gnutls.library.functions.gnutls_openpgp_crt_import\
409
(crt, ctypes.byref(datum),
410
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
350
411
# New buffer for the fingerprint
351
412
buffer = ctypes.create_string_buffer(20)
352
413
buffer_length = ctypes.c_size_t()
368
429
Note: This will run in its own forked process."""
370
431
def handle(self):
371
logger.debug(u"TCP connection from: %s",
432
logger.info(u"TCP connection from: %s",
372
433
unicode(self.client_address))
373
session = gnutls.connection.ClientSession(self.request,
434
session = gnutls.connection.ClientSession\
435
(self.request, gnutls.connection.X509Credentials())
437
line = self.request.makefile().readline()
438
logger.debug(u"Protocol version: %r", line)
440
if int(line.strip().split()[0]) > 1:
442
except (ValueError, IndexError, RuntimeError), error:
443
logger.error(u"Unknown protocol version: %s", error)
446
# Note: gnutls.connection.X509Credentials is really a generic
447
# GnuTLS certificate credentials object so long as no X.509
448
# keys are added to it. Therefore, we can use it here despite
449
# using OpenPGP certificates.
377
451
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
378
452
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
380
priority = "SECURE256"
454
priority = "NORMAL" # Fallback default, since this
456
if self.server.settings["priority"]:
457
priority = self.server.settings["priority"]
382
458
gnutls.library.functions.gnutls_priority_set_direct\
383
459
(session._c_object, priority, None);
386
462
session.handshake()
387
463
except gnutls.errors.GNUTLSError, error:
388
logger.debug(u"Handshake failed: %s", error)
464
logger.warning(u"Handshake failed: %s", error)
389
465
# Do not run session.bye() here: the session is not
390
466
# established. Just abandon the request.
393
469
fpr = fingerprint(peer_certificate(session))
394
470
except (TypeError, gnutls.errors.GNUTLSError), error:
395
logger.debug(u"Bad certificate: %s", error)
471
logger.warning(u"Bad certificate: %s", error)
398
474
logger.debug(u"Fingerprint: %s", fpr)
442
519
"""This overrides the normal server_bind() function
443
520
to bind to an interface if one was specified, and also NOT to
444
521
bind to an address or port if they were not specified."""
445
if self.options.interface:
446
if not hasattr(socket, "SO_BINDTODEVICE"):
447
# From /usr/include/asm-i486/socket.h
448
socket.SO_BINDTODEVICE = 25
522
if self.settings["interface"]:
523
# 25 is from /usr/include/asm-i486/socket.h
524
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
450
526
self.socket.setsockopt(socket.SOL_SOCKET,
451
socket.SO_BINDTODEVICE,
452
self.options.interface)
528
self.settings["interface"])
453
529
except socket.error, error:
454
530
if error[0] == errno.EPERM:
455
logger.warning(u"No permission to"
456
u" bind to interface %s",
457
self.options.interface)
531
logger.error(u"No permission to"
532
u" bind to interface %s",
533
self.settings["interface"])
460
536
# Only bind(2) the socket if we really need to.
507
"""Derived from the Avahi example code"""
508
global group, serviceName, serviceType, servicePort, serviceTXT, \
511
group = dbus.Interface(
512
bus.get_object( avahi.DBUS_NAME,
513
server.EntryGroupNew()),
514
avahi.DBUS_INTERFACE_ENTRY_GROUP)
515
group.connect_to_signal('StateChanged',
516
entry_group_state_changed)
517
logger.debug(u"Adding service '%s' of type '%s' ...",
518
serviceName, serviceType)
521
serviceInterface, # interface
522
avahi.PROTO_INET6, # protocol
523
dbus.UInt32(0), # flags
524
serviceName, serviceType,
526
dbus.UInt16(servicePort),
527
avahi.string_array_to_txt_array(serviceTXT))
531
def remove_service():
532
"""From the Avahi example code"""
535
if not group is None:
539
582
def server_state_changed(state):
540
583
"""Derived from the Avahi example code"""
541
584
if state == avahi.SERVER_COLLISION:
542
logger.warning(u"Server name collision")
585
logger.error(u"Server name collision")
544
587
elif state == avahi.SERVER_RUNNING:
548
591
def entry_group_state_changed(state, error):
549
592
"""Derived from the Avahi example code"""
550
global serviceName, server, rename_count
552
593
logger.debug(u"state change: %i", state)
554
595
if state == avahi.ENTRY_GROUP_ESTABLISHED:
555
596
logger.debug(u"Service established.")
556
597
elif state == avahi.ENTRY_GROUP_COLLISION:
558
rename_count = rename_count - 1
560
name = server.GetAlternativeServiceName(name)
561
logger.warning(u"Service name collision, "
562
u"changing name to '%s' ...", name)
567
logger.error(u"No suitable service name found after %i"
568
u" retries, exiting.", n_rename)
598
logger.warning(u"Service name collision.")
570
600
elif state == avahi.ENTRY_GROUP_FAILURE:
571
logger.error(u"Error in group state changed %s",
601
logger.critical(u"Error in group state changed %s",
603
raise AvahiGroupError("State changed: %s", str(error))
576
605
def if_nametoindex(interface):
577
"""Call the C function if_nametoindex()"""
606
"""Call the C function if_nametoindex(), or equivalent"""
607
global if_nametoindex
579
libc = ctypes.cdll.LoadLibrary("libc.so.6")
580
return libc.if_nametoindex(interface)
609
if "ctypes.util" not in sys.modules:
611
if_nametoindex = ctypes.cdll.LoadLibrary\
612
(ctypes.util.find_library("c")).if_nametoindex
581
613
except (OSError, AttributeError):
582
614
if "struct" not in sys.modules:
584
616
if "fcntl" not in sys.modules:
586
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
588
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
589
struct.pack("16s16x", interface))
591
interface_index = struct.unpack("I", ifreq[16:20])[0]
592
return interface_index
618
def if_nametoindex(interface):
619
"Get an interface index the hard way, i.e. using fcntl()"
620
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
622
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
623
struct.pack("16s16x", interface))
625
interface_index = struct.unpack("I", ifreq[16:20])[0]
626
return interface_index
627
return if_nametoindex(interface)
595
630
def daemon(nochdir, noclose):
616
def killme(status = 0):
617
logger.debug("Stopping server with exit status %d", status)
619
if main_loop_started:
628
652
global main_loop_started
629
653
main_loop_started = False
631
655
parser = OptionParser()
632
656
parser.add_option("-i", "--interface", type="string",
633
default=None, metavar="IF",
634
help="Bind to interface IF")
635
parser.add_option("-a", "--address", type="string", default=None,
657
metavar="IF", help="Bind to interface IF")
658
parser.add_option("-a", "--address", type="string",
636
659
help="Address to listen for requests on")
637
parser.add_option("-p", "--port", type="int", default=None,
660
parser.add_option("-p", "--port", type="int",
638
661
help="Port number to receive requests on")
639
parser.add_option("--timeout", type="string", # Parsed later
641
help="Amount of downtime allowed for clients")
642
parser.add_option("--interval", type="string", # Parsed later
644
help="How often to check that a client is up")
645
662
parser.add_option("--check", action="store_true", default=False,
646
663
help="Run self-test")
647
664
parser.add_option("--debug", action="store_true", default=False,
665
help="Debug mode; run in foreground and log to"
667
parser.add_option("--priority", type="string", help="GnuTLS"
668
" priority string (see GnuTLS documentation)")
669
parser.add_option("--servicename", type="string", metavar="NAME",
670
help="Zeroconf service name")
671
parser.add_option("--configdir", type="string",
672
default="/etc/mandos", metavar="DIR",
673
help="Directory to search for configuration"
649
675
(options, args) = parser.parse_args()
651
677
if options.check:
653
679
doctest.testmod()
656
# Parse the time arguments
658
options.timeout = string_to_delta(options.timeout)
660
parser.error("option --timeout: Unparseable time")
662
options.interval = string_to_delta(options.interval)
664
parser.error("option --interval: Unparseable time")
667
defaults = { "checker": "fping -q -- %%(fqdn)s" }
668
client_config = ConfigParser.SafeConfigParser(defaults)
669
#client_config.readfp(open("global.conf"), "global.conf")
670
client_config.read("mandos-clients.conf")
682
# Default values for config file for server-global settings
683
server_defaults = { "interface": "",
688
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
689
"servicename": "Mandos",
692
# Parse config file for server-global settings
693
server_config = ConfigParser.SafeConfigParser(server_defaults)
695
server_config.read(os.path.join(options.configdir, "server.conf"))
696
server_section = "server"
697
# Convert the SafeConfigParser object to a dict
698
server_settings = dict(server_config.items(server_section))
699
# Use getboolean on the boolean config option
700
server_settings["debug"] = server_config.getboolean\
701
(server_section, "debug")
704
# Override the settings from the config file with command line
706
for option in ("interface", "address", "port", "debug",
707
"priority", "servicename", "configdir"):
708
value = getattr(options, option)
709
if value is not None:
710
server_settings[option] = value
712
# Now we have our good server settings in "server_settings"
714
# Parse config file with clients
715
client_defaults = { "timeout": "1h",
717
"checker": "fping -q -- %%(fqdn)s",
719
client_config = ConfigParser.SafeConfigParser(client_defaults)
720
client_config.read(os.path.join(server_settings["configdir"],
724
service = AvahiService(name = server_settings["servicename"],
725
type = "_mandos._tcp", );
726
if server_settings["interface"]:
727
service.interface = if_nametoindex(server_settings["interface"])
727
784
signal.signal(signal.SIGINT, signal.SIG_IGN)
728
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
729
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
785
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
786
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
731
788
for client in clients:
734
tcp_server = IPv6_TCPServer((options.address, options.port),
791
tcp_server = IPv6_TCPServer((server_settings["address"],
792
server_settings["port"]),
794
settings=server_settings,
738
# Find out what random port we got
740
servicePort = tcp_server.socket.getsockname()[1]
741
logger.debug(u"Now listening on port %d", servicePort)
743
if options.interface is not None:
744
global serviceInterface
745
serviceInterface = if_nametoindex(options.interface)
747
# From the Avahi example code
748
server.connect_to_signal("StateChanged", server_state_changed)
750
server_state_changed(server.GetState())
751
except dbus.exceptions.DBusException, error:
752
logger.critical(u"DBusException: %s", error)
754
# End of Avahi example code
756
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
757
lambda *args, **kwargs:
758
tcp_server.handle_request(*args[2:],
796
# Find out what port we got
797
service.port = tcp_server.socket.getsockname()[1]
798
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
799
u" scope_id %d" % tcp_server.socket.getsockname())
801
#service.interface = tcp_server.socket.getsockname()[3]
804
# From the Avahi example code
805
server.connect_to_signal("StateChanged", server_state_changed)
807
server_state_changed(server.GetState())
808
except dbus.exceptions.DBusException, error:
809
logger.critical(u"DBusException: %s", error)
811
# End of Avahi example code
813
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
814
lambda *args, **kwargs:
815
tcp_server.handle_request\
816
(*args[2:], **kwargs) or True)
761
818
logger.debug("Starting main loop")
762
819
main_loop_started = True
821
except AvahiError, error:
822
logger.critical(u"AvahiError: %s" + unicode(error))
764
824
except KeyboardInterrupt:
770
828
if __name__ == '__main__':