/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2008-08-07 21:45:41 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080807214541-pyg8itw6kphz1dy5
* plugbasedclient.c: Renamed to "mandos-client.c".  All users changed.

* plugins.d/mandosclient.c: Renamed to "plugins.d/password-request.c".
                            All users changed.

* plugins.d/passprompt.c: Renamed to "plugins.d/password-prompt.c".
                          All users changed.

* server.conf: Renamed to "mandos.conf".  All users changed.

* server.py: Renamed to "mandos".
  (daemon): Have default values for arguments. Caller changed.

* Makefile (distclean, mostlyclean, maintainer-clean): New aliases for
                                                       "clean".
  (check, run-client, run-server): New.

* network-protocol.txt: New.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
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: "AvahiService.add", "AvahiService.remove",
10
 
# "server_state_changed", "entry_group_state_changed", and some lines
11
 
# in "main".
 
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".
12
12
# 
13
13
# Everything else is
14
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
61
61
from dbus.mainloop.glib import DBusGMainLoop
62
62
import ctypes
63
63
 
64
 
# Brief description of the operation of this program:
65
 
# 
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.
74
 
 
75
64
 
76
65
logger = logging.Logger('mandos')
77
66
syslogger = logging.handlers.SysLogHandler\
96
85
 
97
86
 
98
87
class AvahiService(object):
99
 
    """
 
88
    """An Avahi (Zeroconf) service.
 
89
    Attributes:
100
90
    interface: integer; avahi.IF_UNSPEC or an interface index.
101
91
               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
109
 
                   if empty.
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
 
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
113
102
    """
114
103
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
104
                 type = None, port = None, TXT = None, domain = "",
116
105
                 host = "", max_renames = 12):
117
 
        """An Avahi (Zeroconf) service. """
118
106
        self.interface = interface
119
107
        self.name = name
120
108
        self.type = type
133
121
                            u" retries, exiting.", rename_count)
134
122
            raise AvahiServiceError("Too many renames")
135
123
        name = server.GetAlternativeServiceName(name)
136
 
        logger.notice(u"Changing name to %r ...", name)
 
124
        logger.error(u"Changing name to %r ...", name)
137
125
        self.remove()
138
126
        self.add()
139
127
        self.rename_count += 1
221
209
    interval = property(lambda self: self._interval,
222
210
                        _set_interval)
223
211
    del _set_interval
224
 
    def __init__(self, name=None, stop_hook=None, fingerprint=None,
225
 
                 secret=None, secfile=None, fqdn=None, timeout=None,
226
 
                 interval=-1, checker=None):
227
 
        """Note: the 'checker' argument sets the 'checker_command'
228
 
        attribute and not the 'checker' attribute.."""
 
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'
 
215
        attribute."""
229
216
        self.name = name
230
217
        logger.debug(u"Creating client %r", self.name)
231
 
        # Uppercase and remove spaces from fingerprint
232
 
        # for later comparison purposes with return value of
233
 
        # the fingerprint() function
234
 
        self.fingerprint = fingerprint.upper().replace(u" ", u"")
 
218
        # Uppercase and remove spaces from fingerprint for later
 
219
        # comparison purposes with return value from the fingerprint()
 
220
        # function
 
221
        self.fingerprint = config["fingerprint"].upper()\
 
222
                           .replace(u" ", u"")
235
223
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
236
 
        if secret:
237
 
            self.secret = secret.decode(u"base64")
238
 
        elif secfile:
239
 
            sf = open(secfile)
 
224
        if "secret" in config:
 
225
            self.secret = config["secret"].decode(u"base64")
 
226
        elif "secfile" in config:
 
227
            sf = open(config["secfile"])
240
228
            self.secret = sf.read()
241
229
            sf.close()
242
230
        else:
243
231
            raise TypeError(u"No secret or secfile for client %s"
244
232
                            % self.name)
245
 
        self.fqdn = fqdn
 
233
        self.fqdn = config.get("fqdn", "")
246
234
        self.created = datetime.datetime.now()
247
235
        self.last_checked_ok = None
248
 
        self.timeout = string_to_delta(timeout)
249
 
        self.interval = string_to_delta(interval)
 
236
        self.timeout = string_to_delta(config["timeout"])
 
237
        self.interval = string_to_delta(config["interval"])
250
238
        self.stop_hook = stop_hook
251
239
        self.checker = None
252
240
        self.checker_initiator_tag = None
253
241
        self.stop_initiator_tag = None
254
242
        self.checker_callback_tag = None
255
 
        self.check_command = checker
 
243
        self.check_command = config["checker"]
256
244
    def start(self):
257
245
        """Start this client's checker and timeout hooks"""
258
246
        # Schedule a new checker to be started an 'interval' from now,
272
260
        but not currently used."""
273
261
        # If this client doesn't have a secret, it is already stopped.
274
262
        if self.secret:
275
 
            logger.debug(u"Stopping client %s", self.name)
 
263
            logger.info(u"Stopping client %s", self.name)
276
264
            self.secret = None
277
265
        else:
278
266
            return False
297
285
        self.checker = None
298
286
        if os.WIFEXITED(condition) \
299
287
               and (os.WEXITSTATUS(condition) == 0):
300
 
            logger.debug(u"Checker for %(name)s succeeded",
301
 
                         vars(self))
 
288
            logger.info(u"Checker for %(name)s succeeded",
 
289
                        vars(self))
302
290
            self.last_checked_ok = now
303
291
            gobject.source_remove(self.stop_initiator_tag)
304
292
            self.stop_initiator_tag = gobject.timeout_add\
308
296
            logger.warning(u"Checker for %(name)s crashed?",
309
297
                           vars(self))
310
298
        else:
311
 
            logger.debug(u"Checker for %(name)s failed",
312
 
                         vars(self))
 
299
            logger.info(u"Checker for %(name)s failed",
 
300
                        vars(self))
313
301
    def start_checker(self):
314
302
        """Start a new checker subprocess if one is not running.
315
303
        If a checker already exists, leave it running and do
338
326
                                 u' %s', self.check_command, error)
339
327
                    return True # Try again later
340
328
            try:
341
 
                logger.debug(u"Starting checker %r for %s",
342
 
                             command, self.name)
 
329
                logger.info(u"Starting checker %r for %s",
 
330
                            command, self.name)
343
331
                self.checker = subprocess.Popen(command,
344
332
                                                close_fds=True,
345
333
                                                shell=True, cwd="/")
396
384
 
397
385
def fingerprint(openpgp):
398
386
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
399
 
    # New empty GnuTLS certificate
400
 
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
401
 
    gnutls.library.functions.gnutls_openpgp_crt_init\
402
 
        (ctypes.byref(crt))
403
387
    # New GnuTLS "datum" with the OpenPGP public key
404
388
    datum = gnutls.library.types.gnutls_datum_t\
405
389
        (ctypes.cast(ctypes.c_char_p(openpgp),
406
390
                     ctypes.POINTER(ctypes.c_ubyte)),
407
391
         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\
 
395
        (ctypes.byref(crt))
408
396
    # Import the OpenPGP public key into the certificate
409
 
    ret = gnutls.library.functions.gnutls_openpgp_crt_import\
410
 
        (crt,
411
 
         ctypes.byref(datum),
412
 
         gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
 
397
    gnutls.library.functions.gnutls_openpgp_crt_import\
 
398
                    (crt, ctypes.byref(datum),
 
399
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
400
    # New buffer for the fingerprint
414
401
    buffer = ctypes.create_string_buffer(20)
415
402
    buffer_length = ctypes.c_size_t()
431
418
    Note: This will run in its own forked process."""
432
419
    
433
420
    def handle(self):
434
 
        logger.debug(u"TCP connection from: %s",
 
421
        logger.info(u"TCP connection from: %s",
435
422
                     unicode(self.client_address))
436
423
        session = gnutls.connection.ClientSession\
437
424
                  (self.request, gnutls.connection.X509Credentials())
 
425
        
 
426
        line = self.request.makefile().readline()
 
427
        logger.debug(u"Protocol version: %r", line)
 
428
        try:
 
429
            if int(line.strip().split()[0]) > 1:
 
430
                raise RuntimeError
 
431
        except (ValueError, IndexError, RuntimeError), error:
 
432
            logger.error(u"Unknown protocol version: %s", error)
 
433
            return
 
434
        
438
435
        # Note: gnutls.connection.X509Credentials is really a generic
439
436
        # GnuTLS certificate credentials object so long as no X.509
440
437
        # keys are added to it.  Therefore, we can use it here despite
453
450
        try:
454
451
            session.handshake()
455
452
        except gnutls.errors.GNUTLSError, error:
456
 
            logger.debug(u"Handshake failed: %s", error)
 
453
            logger.warning(u"Handshake failed: %s", error)
457
454
            # Do not run session.bye() here: the session is not
458
455
            # established.  Just abandon the request.
459
456
            return
460
457
        try:
461
458
            fpr = fingerprint(peer_certificate(session))
462
459
        except (TypeError, gnutls.errors.GNUTLSError), error:
463
 
            logger.debug(u"Bad certificate: %s", error)
 
460
            logger.warning(u"Bad certificate: %s", error)
464
461
            session.bye()
465
462
            return
466
463
        logger.debug(u"Fingerprint: %s", fpr)
470
467
                client = c
471
468
                break
472
469
        if not client:
473
 
            logger.debug(u"Client not found for fingerprint: %s", fpr)
 
470
            logger.warning(u"Client not found for fingerprint: %s",
 
471
                           fpr)
474
472
            session.bye()
475
473
            return
476
474
        # Have to check if client.still_valid(), since it is possible
477
475
        # that the client timed out while establishing the GnuTLS
478
476
        # session.
479
477
        if not client.still_valid():
480
 
            logger.debug(u"Client %(name)s is invalid", vars(client))
 
478
            logger.warning(u"Client %(name)s is invalid",
 
479
                           vars(client))
481
480
            session.bye()
482
481
            return
483
482
        sent_size = 0
509
508
        """This overrides the normal server_bind() function
510
509
        to bind to an interface if one was specified, and also NOT to
511
510
        bind to an address or port if they were not specified."""
512
 
        if self.settings["interface"] != avahi.IF_UNSPEC:
 
511
        if self.settings["interface"]:
513
512
            # 25 is from /usr/include/asm-i486/socket.h
514
513
            SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
515
514
            try:
518
517
                                       self.settings["interface"])
519
518
            except socket.error, error:
520
519
                if error[0] == errno.EPERM:
521
 
                    logger.warning(u"No permission to"
522
 
                                   u" bind to interface %s",
523
 
                                   self.settings["interface"])
 
520
                    logger.error(u"No permission to"
 
521
                                 u" bind to interface %s",
 
522
                                 self.settings["interface"])
524
523
                else:
525
524
                    raise error
526
525
        # Only bind(2) the socket if we really need to.
572
571
def server_state_changed(state):
573
572
    """Derived from the Avahi example code"""
574
573
    if state == avahi.SERVER_COLLISION:
575
 
        logger.warning(u"Server name collision")
 
574
        logger.error(u"Server name collision")
576
575
        service.remove()
577
576
    elif state == avahi.SERVER_RUNNING:
578
577
        service.add()
592
591
                        unicode(error))
593
592
        raise AvahiGroupError("State changed: %s", str(error))
594
593
 
595
 
def if_nametoindex(interface, _func=[None]):
 
594
def if_nametoindex(interface):
596
595
    """Call the C function if_nametoindex(), or equivalent"""
597
 
    if _func[0] is not None:
598
 
        return _func[0](interface)
 
596
    global if_nametoindex
599
597
    try:
600
598
        if "ctypes.util" not in sys.modules:
601
599
            import ctypes.util
602
 
        while True:
603
 
            try:
604
 
                libc = ctypes.cdll.LoadLibrary\
605
 
                       (ctypes.util.find_library("c"))
606
 
                func[0] = libc.if_nametoindex
607
 
                return _func[0](interface)
608
 
            except IOError, e:
609
 
                if e != errno.EINTR:
610
 
                    raise
 
600
        if_nametoindex = ctypes.cdll.LoadLibrary\
 
601
            (ctypes.util.find_library("c")).if_nametoindex
611
602
    except (OSError, AttributeError):
612
603
        if "struct" not in sys.modules:
613
604
            import struct
614
605
        if "fcntl" not in sys.modules:
615
606
            import fcntl
616
 
        def the_hard_way(interface):
 
607
        def if_nametoindex(interface):
617
608
            "Get an interface index the hard way, i.e. using fcntl()"
618
609
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
619
610
            s = socket.socket()
622
613
            s.close()
623
614
            interface_index = struct.unpack("I", ifreq[16:20])[0]
624
615
            return interface_index
625
 
        _func[0] = the_hard_way
626
 
        return _func[0](interface)
627
 
 
628
 
 
629
 
def daemon(nochdir, noclose):
 
616
    return if_nametoindex(interface)
 
617
 
 
618
 
 
619
def daemon(nochdir = False, noclose = False):
630
620
    """See daemon(3).  Standard BSD Unix function.
631
621
    This should really exist as os.daemon, but it doesn't (yet)."""
632
622
    if os.fork():
634
624
    os.setsid()
635
625
    if not nochdir:
636
626
        os.chdir("/")
 
627
    if os.fork():
 
628
        sys.exit()
637
629
    if not noclose:
638
630
        # Close all standard open file descriptors
639
631
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
691
683
    # Parse config file for server-global settings
692
684
    server_config = ConfigParser.SafeConfigParser(server_defaults)
693
685
    del server_defaults
694
 
    server_config.read(os.path.join(options.configdir, "server.conf"))
 
686
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
695
687
    server_section = "server"
696
688
    # Convert the SafeConfigParser object to a dict
697
689
    server_settings = dict(server_config.items(server_section))
699
691
    server_settings["debug"] = server_config.getboolean\
700
692
                               (server_section, "debug")
701
693
    del server_config
702
 
    if not server_settings["interface"]:
703
 
        server_settings["interface"] = avahi.IF_UNSPEC
704
694
    
705
695
    # Override the settings from the config file with command line
706
696
    # options, if set.
724
714
    global service
725
715
    service = AvahiService(name = server_settings["servicename"],
726
716
                           type = "_mandos._tcp", );
 
717
    if server_settings["interface"]:
 
718
        service.interface = if_nametoindex(server_settings["interface"])
727
719
    
728
720
    global main_loop
729
721
    global bus
751
743
    def remove_from_clients(client):
752
744
        clients.remove(client)
753
745
        if not clients:
754
 
            logger.debug(u"No clients left, exiting")
 
746
            logger.critical(u"No clients left, exiting")
755
747
            sys.exit()
756
748
    
757
 
    clients.update(Set(Client(name=section,
 
749
    clients.update(Set(Client(name = section,
758
750
                              stop_hook = remove_from_clients,
759
 
                              **(dict(client_config\
760
 
                                      .items(section))))
 
751
                              config
 
752
                              = dict(client_config.items(section)))
761
753
                       for section in client_config.sections()))
762
754
    
763
755
    if not debug:
764
 
        daemon(False, False)
 
756
        daemon()
765
757
    
766
758
    def cleanup():
767
759
        "Cleanup function; run on exit"
794
786
                                clients=clients)
795
787
    # Find out what port we got
796
788
    service.port = tcp_server.socket.getsockname()[1]
797
 
    logger.debug(u"Now listening on port %d", service.port)
 
789
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
 
790
                u" scope_id %d" % tcp_server.socket.getsockname())
798
791
    
799
 
    if not server_settings["interface"]:
800
 
        service.interface = if_nametoindex\
801
 
                            (server_settings["interface"])
 
792
    #service.interface = tcp_server.socket.getsockname()[3]
802
793
    
803
794
    try:
804
795
        # From the Avahi example code