/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 server.py

  • Committer: Teddy Hogeborn
  • Date: 2008-08-02 10:48:24 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080802104824-fx0miwp9o4g9r31e
* plugbasedclient.c (struct process): New fields "eof", "completed",
                                      and "status".
  (handle_sigchld): New function.
  (main): Initialize "dir" to NULL to only closedir() it if necessary.
          Move "process_list" to be a global variable to be accessible
          by "handle_sigchld".  Make "handle_sigchld" handle SIGCHLD.
          Remove redundant check for NULL "dir".  Free "filename" when
          no longer used.  Block SIGCHLD around fork()/exec().
          Restore normal signals in child.  Only loop while running
          processes exist.  Print process buffer when the process is
          done and it has emitted EOF, not when it only emits EOF.
          Remove processes from list which exit non-cleanly.  In
          cleaning up, closedir() if necessary.  Bug fix: set next
          pointer correctly when freeing process list.

* plugins.d/passprompt.c (main): Do not ignore SIGQUIT.

Show diffs side-by-side

added added

removed removed

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