/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-09-13 15:36:18 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080913153618-atp386q2bqj0ku99
* Makefile (install-client-nokey): Do "&&" instead of ";" to catch
                                   errors.

* README: Kill the straight quotes.  Add copyright notice.

* overview.xml: Improved wording.

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
24
24
#     GNU General Public License for more details.
25
25
# 
26
26
# You should have received a copy of the GNU General Public License
27
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
27
# along with this program.  If not, see
 
28
# <http://www.gnu.org/licenses/>.
28
29
# 
29
30
# Contact the authors at <mandos@fukt.bsnet.se>.
30
31
# 
54
55
import stat
55
56
import logging
56
57
import logging.handlers
 
58
import pwd
57
59
 
58
60
import dbus
59
61
import gobject
61
63
from dbus.mainloop.glib import DBusGMainLoop
62
64
import ctypes
63
65
 
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
 
 
 
66
version = "1.0"
75
67
 
76
68
logger = logging.Logger('mandos')
77
69
syslogger = logging.handlers.SysLogHandler\
78
 
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON)
 
70
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
71
             address = "/dev/log")
79
72
syslogger.setFormatter(logging.Formatter\
80
 
                        ('%(levelname)s: %(message)s'))
 
73
                        ('Mandos: %(levelname)s: %(message)s'))
81
74
logger.addHandler(syslogger)
82
 
del syslogger
83
75
 
 
76
console = logging.StreamHandler()
 
77
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
 
78
                                       ' %(message)s'))
 
79
logger.addHandler(console)
84
80
 
85
81
class AvahiError(Exception):
86
82
    def __init__(self, value):
113
109
    """
114
110
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
111
                 type = None, port = None, TXT = None, domain = "",
116
 
                 host = "", max_renames = 12):
 
112
                 host = "", max_renames = 32768):
117
113
        self.interface = interface
118
114
        self.name = name
119
115
        self.type = type
125
121
        self.domain = domain
126
122
        self.host = host
127
123
        self.rename_count = 0
 
124
        self.max_renames = max_renames
128
125
    def rename(self):
129
126
        """Derived from the Avahi example code"""
130
127
        if self.rename_count >= self.max_renames:
131
 
            logger.critical(u"No suitable service name found after %i"
132
 
                            u" retries, exiting.", rename_count)
 
128
            logger.critical(u"No suitable Zeroconf service name found"
 
129
                            u" after %i retries, exiting.",
 
130
                            rename_count)
133
131
            raise AvahiServiceError("Too many renames")
134
 
        name = server.GetAlternativeServiceName(name)
135
 
        logger.error(u"Changing name to %r ...", name)
 
132
        self.name = server.GetAlternativeServiceName(self.name)
 
133
        logger.info(u"Changing Zeroconf service name to %r ...",
 
134
                    str(self.name))
 
135
        syslogger.setFormatter(logging.Formatter\
 
136
                               ('Mandos (%s): %%(levelname)s:'
 
137
                               ' %%(message)s' % self.name))
136
138
        self.remove()
137
139
        self.add()
138
140
        self.rename_count += 1
150
152
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
151
153
            group.connect_to_signal('StateChanged',
152
154
                                    entry_group_state_changed)
153
 
        logger.debug(u"Adding service '%s' of type '%s' ...",
 
155
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
154
156
                     service.name, service.type)
155
157
        group.AddService(
156
158
                self.interface,         # interface
174
176
    fingerprint: string (40 or 32 hexadecimal digits); used to
175
177
                 uniquely identify the client
176
178
    secret:    bytestring; sent verbatim (over TLS) to client
177
 
    fqdn:      string (FQDN); available for use by the checker command
 
179
    host:      string; available for use by the checker command
178
180
    created:   datetime.datetime(); object creation, not client host
179
181
    last_checked_ok: datetime.datetime() or None if not yet checked OK
180
182
    timeout:   datetime.timedelta(); How long from last_checked_ok
241
243
        else:
242
244
            raise TypeError(u"No secret or secfile for client %s"
243
245
                            % self.name)
244
 
        self.fqdn = config.get("fqdn", "")
 
246
        self.host = config.get("host", "")
245
247
        self.created = datetime.datetime.now()
246
248
        self.last_checked_ok = None
247
249
        self.timeout = string_to_delta(config["timeout"])
270
272
        The possibility that a client might be restarted is left open,
271
273
        but not currently used."""
272
274
        # If this client doesn't have a secret, it is already stopped.
273
 
        if self.secret:
 
275
        if hasattr(self, "secret") and self.secret:
274
276
            logger.info(u"Stopping client %s", self.name)
275
277
            self.secret = None
276
278
        else:
324
326
        if self.checker is None:
325
327
            try:
326
328
                # In case check_command has exactly one % operator
327
 
                command = self.check_command % self.fqdn
 
329
                command = self.check_command % self.host
328
330
            except TypeError:
329
331
                # Escape attributes for the shell
330
332
                escaped_attrs = dict((key, re.escape(str(val)))
339
341
            try:
340
342
                logger.info(u"Starting checker %r for %s",
341
343
                            command, self.name)
 
344
                # We don't need to redirect stdout and stderr, since
 
345
                # in normal mode, that is already done by daemon(),
 
346
                # and in debug mode we don't want to.  (Stdin is
 
347
                # always replaced by /dev/null.)
342
348
                self.checker = subprocess.Popen(command,
343
349
                                                close_fds=True,
344
350
                                                shell=True, cwd="/")
345
351
                self.checker_callback_tag = gobject.child_watch_add\
346
352
                                            (self.checker.pid,
347
353
                                             self.checker_callback)
348
 
            except subprocess.OSError, error:
 
354
            except OSError, error:
349
355
                logger.error(u"Failed to start subprocess: %s",
350
356
                             error)
351
357
        # Re-run this periodically if run by gobject.timeout_add
357
363
            self.checker_callback_tag = None
358
364
        if getattr(self, "checker", None) is None:
359
365
            return
360
 
        logger.debug("Stopping checker for %(name)s", vars(self))
 
366
        logger.debug(u"Stopping checker for %(name)s", vars(self))
361
367
        try:
362
368
            os.kill(self.checker.pid, signal.SIGTERM)
363
369
            #os.sleep(0.5)
408
414
    gnutls.library.functions.gnutls_openpgp_crt_import\
409
415
                    (crt, ctypes.byref(datum),
410
416
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
 
417
    # Verify the self signature in the key
 
418
    crtverify = ctypes.c_uint();
 
419
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
 
420
        (crt, 0, ctypes.byref(crtverify))
 
421
    if crtverify.value != 0:
 
422
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
423
        raise gnutls.errors.CertificateSecurityError("Verify failed")
411
424
    # New buffer for the fingerprint
412
425
    buffer = ctypes.create_string_buffer(20)
413
426
    buffer_length = ctypes.c_size_t()
505
518
    Attributes:
506
519
        settings:       Server settings
507
520
        clients:        Set() of Client objects
 
521
        enabled:        Boolean; whether this server is activated yet
508
522
    """
509
523
    address_family = socket.AF_INET6
510
524
    def __init__(self, *args, **kwargs):
514
528
        if "clients" in kwargs:
515
529
            self.clients = kwargs["clients"]
516
530
            del kwargs["clients"]
 
531
        self.enabled = False
517
532
        return super(type(self), self).__init__(*args, **kwargs)
518
533
    def server_bind(self):
519
534
        """This overrides the normal server_bind() function
539
554
                in6addr_any = "::"
540
555
                self.server_address = (in6addr_any,
541
556
                                       self.server_address[1])
542
 
            elif self.server_address[1] is None:
 
557
            elif not self.server_address[1]:
543
558
                self.server_address = (self.server_address[0],
544
559
                                       0)
 
560
#                 if self.settings["interface"]:
 
561
#                     self.server_address = (self.server_address[0],
 
562
#                                            0, # port
 
563
#                                            0, # flowinfo
 
564
#                                            if_nametoindex
 
565
#                                            (self.settings
 
566
#                                             ["interface"]))
545
567
            return super(type(self), self).server_bind()
 
568
    def server_activate(self):
 
569
        if self.enabled:
 
570
            return super(type(self), self).server_activate()
 
571
    def enable(self):
 
572
        self.enabled = True
546
573
 
547
574
 
548
575
def string_to_delta(interval):
558
585
    datetime.timedelta(1)
559
586
    >>> string_to_delta(u'1w')
560
587
    datetime.timedelta(7)
 
588
    >>> string_to_delta('5m 30s')
 
589
    datetime.timedelta(0, 330)
561
590
    """
562
 
    try:
563
 
        suffix=unicode(interval[-1])
564
 
        value=int(interval[:-1])
565
 
        if suffix == u"d":
566
 
            delta = datetime.timedelta(value)
567
 
        elif suffix == u"s":
568
 
            delta = datetime.timedelta(0, value)
569
 
        elif suffix == u"m":
570
 
            delta = datetime.timedelta(0, 0, 0, 0, value)
571
 
        elif suffix == u"h":
572
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, value)
573
 
        elif suffix == u"w":
574
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
575
 
        else:
 
591
    timevalue = datetime.timedelta(0)
 
592
    for s in interval.split():
 
593
        try:
 
594
            suffix=unicode(s[-1])
 
595
            value=int(s[:-1])
 
596
            if suffix == u"d":
 
597
                delta = datetime.timedelta(value)
 
598
            elif suffix == u"s":
 
599
                delta = datetime.timedelta(0, value)
 
600
            elif suffix == u"m":
 
601
                delta = datetime.timedelta(0, 0, 0, 0, value)
 
602
            elif suffix == u"h":
 
603
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
 
604
            elif suffix == u"w":
 
605
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
 
606
            else:
 
607
                raise ValueError
 
608
        except (ValueError, IndexError):
576
609
            raise ValueError
577
 
    except (ValueError, IndexError):
578
 
        raise ValueError
579
 
    return delta
 
610
        timevalue += delta
 
611
    return timevalue
580
612
 
581
613
 
582
614
def server_state_changed(state):
583
615
    """Derived from the Avahi example code"""
584
616
    if state == avahi.SERVER_COLLISION:
585
 
        logger.error(u"Server name collision")
 
617
        logger.error(u"Zeroconf server name collision")
586
618
        service.remove()
587
619
    elif state == avahi.SERVER_RUNNING:
588
620
        service.add()
590
622
 
591
623
def entry_group_state_changed(state, error):
592
624
    """Derived from the Avahi example code"""
593
 
    logger.debug(u"state change: %i", state)
 
625
    logger.debug(u"Avahi state change: %i", state)
594
626
    
595
627
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
596
 
        logger.debug(u"Service established.")
 
628
        logger.debug(u"Zeroconf service established.")
597
629
    elif state == avahi.ENTRY_GROUP_COLLISION:
598
 
        logger.warning(u"Service name collision.")
 
630
        logger.warning(u"Zeroconf service name collision.")
599
631
        service.rename()
600
632
    elif state == avahi.ENTRY_GROUP_FAILURE:
601
 
        logger.critical(u"Error in group state changed %s",
 
633
        logger.critical(u"Avahi: Error in group state changed %s",
602
634
                        unicode(error))
603
635
        raise AvahiGroupError("State changed: %s", str(error))
604
636
 
627
659
    return if_nametoindex(interface)
628
660
 
629
661
 
630
 
def daemon(nochdir, noclose):
 
662
def daemon(nochdir = False, noclose = False):
631
663
    """See daemon(3).  Standard BSD Unix function.
632
664
    This should really exist as os.daemon, but it doesn't (yet)."""
633
665
    if os.fork():
635
667
    os.setsid()
636
668
    if not nochdir:
637
669
        os.chdir("/")
 
670
    if os.fork():
 
671
        sys.exit()
638
672
    if not noclose:
639
673
        # Close all standard open file descriptors
640
674
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
652
686
    global main_loop_started
653
687
    main_loop_started = False
654
688
    
655
 
    parser = OptionParser()
 
689
    parser = OptionParser(version = "%%prog %s" % version)
656
690
    parser.add_option("-i", "--interface", type="string",
657
691
                      metavar="IF", help="Bind to interface IF")
658
692
    parser.add_option("-a", "--address", type="string",
661
695
                      help="Port number to receive requests on")
662
696
    parser.add_option("--check", action="store_true", default=False,
663
697
                      help="Run self-test")
664
 
    parser.add_option("--debug", action="store_true", default=False,
 
698
    parser.add_option("--debug", action="store_true",
665
699
                      help="Debug mode; run in foreground and log to"
666
700
                      " terminal")
667
701
    parser.add_option("--priority", type="string", help="GnuTLS"
692
726
    # Parse config file for server-global settings
693
727
    server_config = ConfigParser.SafeConfigParser(server_defaults)
694
728
    del server_defaults
695
 
    server_config.read(os.path.join(options.configdir, "server.conf"))
696
 
    server_section = "server"
 
729
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
697
730
    # Convert the SafeConfigParser object to a dict
698
 
    server_settings = dict(server_config.items(server_section))
 
731
    server_settings = server_config.defaults()
699
732
    # Use getboolean on the boolean config option
700
733
    server_settings["debug"] = server_config.getboolean\
701
 
                               (server_section, "debug")
 
734
                               ("DEFAULT", "debug")
702
735
    del server_config
703
736
    
704
737
    # Override the settings from the config file with command line
711
744
    del options
712
745
    # Now we have our good server settings in "server_settings"
713
746
    
 
747
    debug = server_settings["debug"]
 
748
    
 
749
    if not debug:
 
750
        syslogger.setLevel(logging.WARNING)
 
751
        console.setLevel(logging.WARNING)
 
752
    
 
753
    if server_settings["servicename"] != "Mandos":
 
754
        syslogger.setFormatter(logging.Formatter\
 
755
                               ('Mandos (%s): %%(levelname)s:'
 
756
                                ' %%(message)s'
 
757
                                % server_settings["servicename"]))
 
758
    
714
759
    # Parse config file with clients
715
760
    client_defaults = { "timeout": "1h",
716
761
                        "interval": "5m",
717
 
                        "checker": "fping -q -- %%(fqdn)s",
 
762
                        "checker": "fping -q -- %(host)s",
 
763
                        "host": "",
718
764
                        }
719
765
    client_config = ConfigParser.SafeConfigParser(client_defaults)
720
766
    client_config.read(os.path.join(server_settings["configdir"],
721
767
                                    "clients.conf"))
722
768
    
 
769
    clients = Set()
 
770
    tcp_server = IPv6_TCPServer((server_settings["address"],
 
771
                                 server_settings["port"]),
 
772
                                tcp_handler,
 
773
                                settings=server_settings,
 
774
                                clients=clients)
 
775
    pidfilename = "/var/run/mandos.pid"
 
776
    try:
 
777
        pidfile = open(pidfilename, "w")
 
778
    except IOError, error:
 
779
        logger.error("Could not open file %r", pidfilename)
 
780
    
 
781
    uid = 65534
 
782
    gid = 65534
 
783
    try:
 
784
        uid = pwd.getpwnam("mandos").pw_uid
 
785
    except KeyError:
 
786
        try:
 
787
            uid = pwd.getpwnam("nobody").pw_uid
 
788
        except KeyError:
 
789
            pass
 
790
    try:
 
791
        gid = pwd.getpwnam("mandos").pw_gid
 
792
    except KeyError:
 
793
        try:
 
794
            gid = pwd.getpwnam("nogroup").pw_gid
 
795
        except KeyError:
 
796
            pass
 
797
    try:
 
798
        os.setuid(uid)
 
799
        os.setgid(gid)
 
800
    except OSError, error:
 
801
        if error[0] != errno.EPERM:
 
802
            raise error
 
803
    
723
804
    global service
724
805
    service = AvahiService(name = server_settings["servicename"],
725
806
                           type = "_mandos._tcp", );
726
807
    if server_settings["interface"]:
727
 
        service.interface = if_nametoindex(server_settings["interface"])
 
808
        service.interface = if_nametoindex\
 
809
                            (server_settings["interface"])
728
810
    
729
811
    global main_loop
730
812
    global bus
733
815
    DBusGMainLoop(set_as_default=True )
734
816
    main_loop = gobject.MainLoop()
735
817
    bus = dbus.SystemBus()
736
 
    server = dbus.Interface(
737
 
            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
738
 
            avahi.DBUS_INTERFACE_SERVER )
 
818
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
 
819
                                           avahi.DBUS_PATH_SERVER),
 
820
                            avahi.DBUS_INTERFACE_SERVER)
739
821
    # End of Avahi example code
740
822
    
741
 
    debug = server_settings["debug"]
742
 
    
743
 
    if debug:
744
 
        console = logging.StreamHandler()
745
 
        # console.setLevel(logging.DEBUG)
746
 
        console.setFormatter(logging.Formatter\
747
 
                             ('%(levelname)s: %(message)s'))
748
 
        logger.addHandler(console)
749
 
        del console
750
 
    
751
 
    clients = Set()
752
823
    def remove_from_clients(client):
753
824
        clients.remove(client)
754
825
        if not clients:
760
831
                              config
761
832
                              = dict(client_config.items(section)))
762
833
                       for section in client_config.sections()))
763
 
    
764
 
    if not debug:
765
 
        daemon(False, False)
 
834
    if not clients:
 
835
        logger.critical(u"No clients defined")
 
836
        sys.exit(1)
 
837
    
 
838
    if debug:
 
839
        # Redirect stdin so all checkers get /dev/null
 
840
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
841
        os.dup2(null, sys.stdin.fileno())
 
842
        if null > 2:
 
843
            os.close(null)
 
844
    else:
 
845
        # No console logging
 
846
        logger.removeHandler(console)
 
847
        # Close all input and output, do double fork, etc.
 
848
        daemon()
 
849
    
 
850
    try:
 
851
        pid = os.getpid()
 
852
        pidfile.write(str(pid) + "\n")
 
853
        pidfile.close()
 
854
        del pidfile
 
855
    except IOError, err:
 
856
        logger.error(u"Could not write to file %r with PID %d",
 
857
                     pidfilename, pid)
 
858
    except NameError:
 
859
        # "pidfile" was never created
 
860
        pass
 
861
    del pidfilename
766
862
    
767
863
    def cleanup():
768
864
        "Cleanup function; run on exit"
788
884
    for client in clients:
789
885
        client.start()
790
886
    
791
 
    tcp_server = IPv6_TCPServer((server_settings["address"],
792
 
                                 server_settings["port"]),
793
 
                                tcp_handler,
794
 
                                settings=server_settings,
795
 
                                clients=clients)
 
887
    tcp_server.enable()
 
888
    tcp_server.server_activate()
 
889
    
796
890
    # Find out what port we got
797
891
    service.port = tcp_server.socket.getsockname()[1]
798
892
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
815
909
                             tcp_server.handle_request\
816
910
                             (*args[2:], **kwargs) or True)
817
911
        
818
 
        logger.debug("Starting main loop")
 
912
        logger.debug(u"Starting main loop")
819
913
        main_loop_started = True
820
914
        main_loop.run()
821
915
    except AvahiError, error: