28
61
from dbus.mainloop.glib import DBusGMainLoop
32
import logging.handlers
64
# Brief description of the operation of this program:
66
# This server announces itself as a Zeroconf service. Connecting
67
# clients use the TLS protocol, with the unusual quirk that this
68
# server program acts as a TLS "client" while a connecting client acts
69
# as a TLS "server". The client (acting as a TLS "server") must
70
# supply an OpenPGP certificate, and the fingerprint of this
71
# certificate is used by this server to look up (in a list read from a
72
# file at start time) which binary blob to give the client. No other
73
# authentication or authorization is done by this server.
34
# logghandler.setFormatter(logging.Formatter('%(levelname)s %(message)s')
36
76
logger = logging.Logger('mandos')
37
logger.addHandler(logging.handlers.SysLogHandler(facility = logging.handlers.SysLogHandler.LOG_DAEMON))
39
# This variable is used to optionally bind to a specified interface.
40
# It is a global variable to fit in with the other variables from the
41
# Avahi server example code.
42
serviceInterface = avahi.IF_UNSPEC
43
# From the Avahi server example code:
44
serviceName = "Mandos"
45
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
46
servicePort = None # Not known at startup
47
serviceTXT = [] # TXT record for the service
48
domain = "" # Domain to publish on, default to .local
49
host = "" # Host to publish records for, default to localhost
50
group = None #our entry group
51
rename_count = 12 # Counter so we only rename after collisions a
52
# sensible number of times
77
syslogger = logging.handlers.SysLogHandler\
78
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
79
syslogger.setFormatter(logging.Formatter\
80
('%(levelname)s: %(message)s'))
81
logger.addHandler(syslogger)
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):
100
interface: integer; avahi.IF_UNSPEC or an interface index.
101
Used to optionally bind to the specified interface.
102
name = string; Example: "Mandos"
103
type = string; Example: "_mandos._tcp".
104
See <http://www.dns-sd.org/ServiceTypes.html>
105
port = integer; what port to announce
106
TXT = list of strings; TXT record for the service
107
domain = string; Domain to publish on, default to .local if empty.
108
host = string; Host to publish records for, default to 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
"""An Avahi (Zeroconf) service. """
118
self.interface = interface
128
self.rename_count = 0
130
"""Derived from the Avahi example code"""
131
if self.rename_count >= self.max_renames:
132
logger.critical(u"No suitable service name found after %i"
133
u" retries, exiting.", rename_count)
134
raise AvahiServiceError("Too many renames")
135
name = server.GetAlternativeServiceName(name)
136
logger.notice(u"Changing name to %r ...", name)
139
self.rename_count += 1
141
"""Derived from the Avahi example code"""
142
if group is not None:
145
"""Derived from the Avahi example code"""
148
group = dbus.Interface\
149
(bus.get_object(avahi.DBUS_NAME,
150
server.EntryGroupNew()),
151
avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
group.connect_to_signal('StateChanged',
153
entry_group_state_changed)
154
logger.debug(u"Adding service '%s' of type '%s' ...",
155
service.name, service.type)
157
self.interface, # interface
158
avahi.PROTO_INET6, # protocol
159
dbus.UInt32(0), # flags
160
self.name, self.type,
161
self.domain, self.host,
162
dbus.UInt16(self.port),
163
avahi.string_array_to_txt_array(self.TXT))
166
# From the Avahi example code:
167
group = None # our entry group
53
168
# End of Avahi example code
61
176
uniquely identify the client
62
177
secret: bytestring; sent verbatim (over TLS) to client
63
178
fqdn: string (FQDN); available for use by the checker command
64
created: datetime.datetime()
65
last_seen: datetime.datetime() or None if not yet seen
66
timeout: datetime.timedelta(); How long from last_seen until
67
this client is invalid
179
created: datetime.datetime(); object creation, not client host
180
last_checked_ok: datetime.datetime() or None if not yet checked OK
181
timeout: datetime.timedelta(); How long from last_checked_ok
182
until this client is invalid
68
183
interval: datetime.timedelta(); How often to start a new checker
69
184
stop_hook: If set, called by stop() as stop_hook(self)
70
185
checker: subprocess.Popen(); a running checker process used
71
186
to see if the client lives.
72
Is None if no process is running.
187
'None' if no process is running.
73
188
checker_initiator_tag: a gobject event source tag, or None
74
189
stop_initiator_tag: - '' -
75
190
checker_callback_tag: - '' -
76
191
checker_command: string; External command which is run to check if
77
client lives. %()s expansions are done at
192
client lives. %() expansions are done at
78
193
runtime with vars(self) as dict, so that for
79
194
instance %(name)s can be used in the command.
80
195
Private attibutes:
81
196
_timeout: Real variable for 'timeout'
82
197
_interval: Real variable for 'interval'
83
_timeout_milliseconds: Used by gobject.timeout_add()
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
84
199
_interval_milliseconds: - '' -
86
201
def _set_timeout(self, timeout):
171
288
# Do not run this again if called by a gobject.timeout_add
173
290
def __del__(self):
174
# Some code duplication here and in stop()
175
if hasattr(self, "stop_initiator_tag") \
176
and self.stop_initiator_tag:
177
gobject.source_remove(self.stop_initiator_tag)
178
self.stop_initiator_tag = None
179
if hasattr(self, "checker_initiator_tag") \
180
and self.checker_initiator_tag:
181
gobject.source_remove(self.checker_initiator_tag)
182
self.checker_initiator_tag = None
291
self.stop_hook = None
184
293
def checker_callback(self, pid, condition):
185
294
"""The checker has completed, so take appropriate actions."""
186
295
now = datetime.datetime.now()
296
self.checker_callback_tag = None
187
298
if os.WIFEXITED(condition) \
188
299
and (os.WEXITSTATUS(condition) == 0):
189
300
logger.debug(u"Checker for %(name)s succeeded",
302
self.last_checked_ok = now
192
303
gobject.source_remove(self.stop_initiator_tag)
193
304
self.stop_initiator_tag = gobject.timeout_add\
194
305
(self._timeout_milliseconds,
196
if not os.WIFEXITED(condition):
307
elif not os.WIFEXITED(condition):
197
308
logger.warning(u"Checker for %(name)s crashed?",
200
311
logger.debug(u"Checker for %(name)s failed",
203
self.checker_callback_tag = None
204
313
def start_checker(self):
205
314
"""Start a new checker subprocess if one is not running.
206
315
If a checker already exists, leave it running and do
317
# The reason for not killing a running checker is that if we
318
# did that, then if a checker (for some reason) started
319
# running slowly and taking more than 'interval' time, the
320
# client would inevitably timeout, since no checker would get
321
# a chance to run to completion. If we instead leave running
322
# checkers alone, the checker would have to take more time
323
# than 'timeout' for the client to be declared invalid, which
324
# is as it should be.
208
325
if self.checker is None:
209
logger.debug(u"Starting checker for %s",
327
# In case check_command has exactly one % operator
212
328
command = self.check_command % self.fqdn
213
329
except TypeError:
330
# Escape attributes for the shell
214
331
escaped_attrs = dict((key, re.escape(str(val)))
216
333
vars(self).iteritems())
218
335
command = self.check_command % escaped_attrs
219
336
except TypeError, error:
220
logger.critical(u'Could not format string "%s": %s',
221
self.check_command, error)
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
222
339
return True # Try again later
224
self.checker = subprocess.\
226
stdout=subprocess.PIPE,
227
close_fds=True, shell=True,
229
self.checker_callback_tag = gobject.\
230
child_watch_add(self.checker.pid,
341
logger.debug(u"Starting checker %r for %s",
343
self.checker = subprocess.Popen(command,
346
self.checker_callback_tag = gobject.child_watch_add\
348
self.checker_callback)
233
349
except subprocess.OSError, error:
234
350
logger.error(u"Failed to start subprocess: %s",
238
354
def stop_checker(self):
239
355
"""Force the checker process, if any, to stop."""
240
if not hasattr(self, "checker") or self.checker is None:
356
if self.checker_callback_tag:
357
gobject.source_remove(self.checker_callback_tag)
358
self.checker_callback_tag = None
359
if getattr(self, "checker", None) is None:
242
gobject.source_remove(self.checker_callback_tag)
243
self.checker_callback_tag = None
244
os.kill(self.checker.pid, signal.SIGTERM)
245
if self.checker.poll() is None:
246
os.kill(self.checker.pid, signal.SIGKILL)
361
logger.debug("Stopping checker for %(name)s", vars(self))
363
os.kill(self.checker.pid, signal.SIGTERM)
365
#if self.checker.poll() is None:
366
# os.kill(self.checker.pid, signal.SIGKILL)
367
except OSError, error:
368
if error.errno != errno.ESRCH: # No such process
247
370
self.checker = None
248
def still_valid(self, now=None):
371
def still_valid(self):
249
372
"""Has the timeout not yet passed for this client?"""
251
now = datetime.datetime.now()
252
if self.last_seen is None:
373
now = datetime.datetime.now()
374
if self.last_checked_ok is None:
253
375
return now < (self.created + self.timeout)
255
return now < (self.last_seen + self.timeout)
377
return now < (self.last_checked_ok + self.timeout)
258
380
def peer_certificate(session):
381
"Return the peer's OpenPGP certificate as a bytestring"
259
382
# If not an OpenPGP certificate...
260
383
if gnutls.library.functions.gnutls_certificate_type_get\
261
384
(session._c_object) \
309
433
def handle(self):
310
434
logger.debug(u"TCP connection from: %s",
311
435
unicode(self.client_address))
312
session = gnutls.connection.ClientSession(self.request,
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
session = gnutls.connection.ClientSession\
447
(self.request, gnutls.connection.X509Credentials())
448
# Note: gnutls.connection.X509Credentials is really a generic
449
# GnuTLS certificate credentials object so long as no X.509
450
# keys are added to it. Therefore, we can use it here despite
451
# using OpenPGP certificates.
316
453
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
317
454
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
319
priority = "SECURE256"
456
priority = "NORMAL" # Fallback default, since this
458
if self.server.settings["priority"]:
459
priority = self.server.settings["priority"]
321
460
gnutls.library.functions.gnutls_priority_set_direct\
322
461
(session._c_object, priority, None);
446
"""From the Avahi server example code"""
447
global group, serviceName, serviceType, servicePort, serviceTXT, \
450
group = dbus.Interface(
451
bus.get_object( avahi.DBUS_NAME,
452
server.EntryGroupNew()),
453
avahi.DBUS_INTERFACE_ENTRY_GROUP)
454
group.connect_to_signal('StateChanged',
455
entry_group_state_changed)
456
logger.debug(u"Adding service '%s' of type '%s' ...",
457
serviceName, serviceType)
460
serviceInterface, # interface
461
avahi.PROTO_INET6, # protocol
462
dbus.UInt32(0), # flags
463
serviceName, serviceType,
465
dbus.UInt16(servicePort),
466
avahi.string_array_to_txt_array(serviceTXT))
470
def remove_service():
471
"""From the Avahi server example code"""
474
if not group is None:
478
582
def server_state_changed(state):
479
"""From the Avahi server example code"""
583
"""Derived from the Avahi example code"""
480
584
if state == avahi.SERVER_COLLISION:
481
585
logger.warning(u"Server name collision")
483
587
elif state == avahi.SERVER_RUNNING:
487
591
def entry_group_state_changed(state, error):
488
"""From the Avahi server example code"""
489
global serviceName, server, rename_count
592
"""Derived from the Avahi example code"""
491
593
logger.debug(u"state change: %i", state)
493
595
if state == avahi.ENTRY_GROUP_ESTABLISHED:
494
596
logger.debug(u"Service established.")
495
597
elif state == avahi.ENTRY_GROUP_COLLISION:
497
rename_count = rename_count - 1
499
name = server.GetAlternativeServiceName(name)
500
logger.warning(u"Service name collision, "
501
u"changing name to '%s' ...", name)
506
logger.error(u"No suitable service name found "
507
u"after %i retries, exiting.",
598
logger.warning(u"Service name collision.")
510
600
elif state == avahi.ENTRY_GROUP_FAILURE:
511
logger.error(u"Error in group state changed %s",
517
def if_nametoindex(interface):
518
"""Call the C function if_nametoindex()"""
601
logger.critical(u"Error in group state changed %s",
603
raise AvahiGroupError("State changed: %s", str(error))
605
def if_nametoindex(interface, _func=[None]):
606
"""Call the C function if_nametoindex(), or equivalent"""
607
if _func[0] is not None:
608
return _func[0](interface)
520
libc = ctypes.cdll.LoadLibrary("libc.so.6")
521
return libc.if_nametoindex(interface)
610
if "ctypes.util" not in sys.modules:
614
libc = ctypes.cdll.LoadLibrary\
615
(ctypes.util.find_library("c"))
616
_func[0] = libc.if_nametoindex
617
return _func[0](interface)
522
621
except (OSError, AttributeError):
523
622
if "struct" not in sys.modules:
525
624
if "fcntl" not in sys.modules:
527
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
529
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
530
struct.pack("16s16x", interface))
532
interface_index = struct.unpack("I", ifreq[16:20])[0]
533
return interface_index
536
if __name__ == '__main__':
626
def the_hard_way(interface):
627
"Get an interface index the hard way, i.e. using fcntl()"
628
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
630
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
631
struct.pack("16s16x", interface))
633
interface_index = struct.unpack("I", ifreq[16:20])[0]
634
return interface_index
635
_func[0] = the_hard_way
636
return _func[0](interface)
639
def daemon(nochdir, noclose):
640
"""See daemon(3). Standard BSD Unix function.
641
This should really exist as os.daemon, but it doesn't (yet)."""
648
# Close all standard open file descriptors
649
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
650
if not stat.S_ISCHR(os.fstat(null).st_mode):
651
raise OSError(errno.ENODEV,
652
"/dev/null not a character device")
653
os.dup2(null, sys.stdin.fileno())
654
os.dup2(null, sys.stdout.fileno())
655
os.dup2(null, sys.stderr.fileno())
661
global main_loop_started
662
main_loop_started = False
537
664
parser = OptionParser()
538
665
parser.add_option("-i", "--interface", type="string",
539
default=None, metavar="IF",
540
help="Bind to interface IF")
541
parser.add_option("--cert", type="string", default="cert.pem",
543
help="Public key certificate PEM file to use")
544
parser.add_option("--key", type="string", default="key.pem",
546
help="Private key PEM file to use")
547
parser.add_option("--ca", type="string", default="ca.pem",
549
help="Certificate Authority certificate PEM file to use")
550
parser.add_option("--crl", type="string", default="crl.pem",
552
help="Certificate Revokation List PEM file to use")
553
parser.add_option("-p", "--port", type="int", default=None,
666
metavar="IF", help="Bind to interface IF")
667
parser.add_option("-a", "--address", type="string",
668
help="Address to listen for requests on")
669
parser.add_option("-p", "--port", type="int",
554
670
help="Port number to receive requests on")
555
parser.add_option("--timeout", type="string", # Parsed later
557
help="Amount of downtime allowed for clients")
558
parser.add_option("--interval", type="string", # Parsed later
560
help="How often to check that a client is up")
561
671
parser.add_option("--check", action="store_true", default=False,
562
672
help="Run self-test")
563
673
parser.add_option("--debug", action="store_true", default=False,
674
help="Debug mode; run in foreground and log to"
676
parser.add_option("--priority", type="string", help="GnuTLS"
677
" priority string (see GnuTLS documentation)")
678
parser.add_option("--servicename", type="string", metavar="NAME",
679
help="Zeroconf service name")
680
parser.add_option("--configdir", type="string",
681
default="/etc/mandos", metavar="DIR",
682
help="Directory to search for configuration"
565
684
(options, args) = parser.parse_args()
567
686
if options.check:
569
688
doctest.testmod()
572
# Parse the time arguments
574
options.timeout = string_to_delta(options.timeout)
576
parser.error("option --timeout: Unparseable time")
578
options.interval = string_to_delta(options.interval)
580
parser.error("option --interval: Unparseable time")
583
defaults = { "checker": "sleep 1; fping -q -- %%(fqdn)s" }
584
client_config = ConfigParser.SafeConfigParser(defaults)
585
#client_config.readfp(open("secrets.conf"), "secrets.conf")
586
client_config.read("mandos-clients.conf")
588
# From the Avahi server example code
691
# Default values for config file for server-global settings
692
server_defaults = { "interface": "",
697
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
698
"servicename": "Mandos",
701
# Parse config file for server-global settings
702
server_config = ConfigParser.SafeConfigParser(server_defaults)
704
server_config.read(os.path.join(options.configdir, "server.conf"))
705
server_section = "server"
706
# Convert the SafeConfigParser object to a dict
707
server_settings = dict(server_config.items(server_section))
708
# Use getboolean on the boolean config option
709
server_settings["debug"] = server_config.getboolean\
710
(server_section, "debug")
713
# Override the settings from the config file with command line
715
for option in ("interface", "address", "port", "debug",
716
"priority", "servicename", "configdir"):
717
value = getattr(options, option)
718
if value is not None:
719
server_settings[option] = value
721
# Now we have our good server settings in "server_settings"
723
# Parse config file with clients
724
client_defaults = { "timeout": "1h",
726
"checker": "fping -q -- %%(fqdn)s",
728
client_config = ConfigParser.SafeConfigParser(client_defaults)
729
client_config.read(os.path.join(server_settings["configdir"],
733
service = AvahiService(name = server_settings["servicename"],
734
type = "_mandos._tcp", );
735
if server_settings["interface"]:
736
service.interface = if_nametoindex(server_settings["interface"])
741
# From the Avahi example code
589
742
DBusGMainLoop(set_as_default=True )
590
743
main_loop = gobject.MainLoop()
591
744
bus = dbus.SystemBus()
594
747
avahi.DBUS_INTERFACE_SERVER )
595
748
# End of Avahi example code
597
debug = options.debug
750
debug = server_settings["debug"]
753
console = logging.StreamHandler()
754
# console.setLevel(logging.DEBUG)
755
console.setFormatter(logging.Formatter\
756
('%(levelname)s: %(message)s'))
757
logger.addHandler(console)
600
761
def remove_from_clients(client):
601
762
clients.remove(client)
603
764
logger.debug(u"No clients left, exiting")
606
clients.update(Set(Client(name=section, options=options,
767
clients.update(Set(Client(name=section,
607
768
stop_hook = remove_from_clients,
608
769
**(dict(client_config\
609
770
.items(section))))
610
771
for section in client_config.sections()))
777
"Cleanup function; run on exit"
779
# From the Avahi example code
780
if not group is None:
783
# End of Avahi example code
786
client = clients.pop()
787
client.stop_hook = None
790
atexit.register(cleanup)
793
signal.signal(signal.SIGINT, signal.SIG_IGN)
794
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
795
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
611
797
for client in clients:
614
tcp_server = IPv6_TCPServer((None, options.port),
800
tcp_server = IPv6_TCPServer((server_settings["address"],
801
server_settings["port"]),
803
settings=server_settings,
618
# Find out what random port we got
619
servicePort = tcp_server.socket.getsockname()[1]
620
logger.debug(u"Now listening on port %d", servicePort)
622
if options.interface is not None:
623
serviceInterface = if_nametoindex(options.interface)
625
# From the Avahi server example code
626
server.connect_to_signal("StateChanged", server_state_changed)
627
server_state_changed(server.GetState())
628
# End of Avahi example code
630
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
631
lambda *args, **kwargs:
632
tcp_server.handle_request(*args[2:],
805
# Find out what port we got
806
service.port = tcp_server.socket.getsockname()[1]
807
logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
808
u" scope_id %d" % tcp_server.socket.getsockname())
810
#service.interface = tcp_server.socket.getsockname()[3]
813
# From the Avahi example code
814
server.connect_to_signal("StateChanged", server_state_changed)
816
server_state_changed(server.GetState())
817
except dbus.exceptions.DBusException, error:
818
logger.critical(u"DBusException: %s", error)
820
# End of Avahi example code
822
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
823
lambda *args, **kwargs:
824
tcp_server.handle_request\
825
(*args[2:], **kwargs) or True)
827
logger.debug("Starting main loop")
828
main_loop_started = True
830
except AvahiError, error:
831
logger.critical(u"AvahiError: %s" + unicode(error))
636
833
except KeyboardInterrupt:
641
# From the Avahi server example code
642
if not group is None:
644
# End of Avahi example code
646
for client in clients:
647
client.stop_hook = None
837
if __name__ == '__main__':