/mandos/trunk

#!/usr/bin/python

# -*- mode: python; coding: utf-8 -*-

# 

# Mandos server - give out binary blobs to connecting clients.

# 

# This program is partly derived from an example program for an Avahi

# service publisher, downloaded from

# <http://avahi.org/wiki/PythonPublishExample>.  This includes the

# methods "add" and "remove" in the "AvahiService" class, the

# "server_state_changed" and "entry_group_state_changed" functions,

# and some lines in "main".

# 

# Everything else is

# Copyright © 2008,2009 Teddy Hogeborn

# Copyright © 2008,2009 Björn Påhlsson

# 

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

#     This program is distributed in the hope that it will be useful,

#     but WITHOUT ANY WARRANTY; without even the implied warranty of

#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#     GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see

# <http://www.gnu.org/licenses/>.

# 

# Contact the authors at <mandos@fukt.bsnet.se>.

# 

from __future__ import division, with_statement, absolute_import

import SocketServer

import socket

import optparse

import datetime

import errno

import gnutls.crypto

import gnutls.connection

import gnutls.errors

import gnutls.library.functions

import gnutls.library.constants

import gnutls.library.types

import ConfigParser

import sys

import re

import os

import signal

from sets import Set

import subprocess

import atexit

import stat

import logging

import logging.handlers

import pwd

from contextlib import closing

import dbus

import dbus.service

import gobject

import avahi

from dbus.mainloop.glib import DBusGMainLoop

import ctypes

import ctypes.util

version = "1.0.5"

logger = logging.Logger('mandos')

syslogger = (logging.handlers.SysLogHandler

             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,

              address = "/dev/log"))

syslogger.setFormatter(logging.Formatter

                       ('Mandos: %(levelname)s: %(message)s'))

logger.addHandler(syslogger)

console = logging.StreamHandler()

console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'

                                       ' %(message)s'))

logger.addHandler(console)

class AvahiError(Exception):

    def __init__(self, value, *args, **kwargs):

        self.value = value

        super(AvahiError, self).__init__(value, *args, **kwargs)

    def __unicode__(self):

        return unicode(repr(self.value))

class AvahiServiceError(AvahiError):

    pass

class AvahiGroupError(AvahiError):

    pass

class AvahiService(object):

    """An Avahi (Zeroconf) service.

    Attributes:

    interface: integer; avahi.IF_UNSPEC or an interface index.

               Used to optionally bind to the specified interface.

    name: string; Example: 'Mandos'

    type: string; Example: '_mandos._tcp'.

                  See <http://www.dns-sd.org/ServiceTypes.html>

    port: integer; what port to announce

    TXT: list of strings; TXT record for the service

    domain: string; Domain to publish on, default to .local if empty.

    host: string; Host to publish records for, default is localhost

    max_renames: integer; maximum number of renames

    rename_count: integer; counter so we only rename after collisions

                  a sensible number of times

    """

    def __init__(self, interface = avahi.IF_UNSPEC, name = None,

                 servicetype = None, port = None, TXT = None,

                 domain = "", host = "", max_renames = 32768):

        self.interface = interface

        self.name = name

        self.type = servicetype

        self.port = port

        self.TXT = TXT if TXT is not None else []

        self.domain = domain

        self.host = host

        self.rename_count = 0

        self.max_renames = max_renames

    def rename(self):

        """Derived from the Avahi example code"""

        if self.rename_count >= self.max_renames:

            logger.critical(u"No suitable Zeroconf service name found"

                            u" after %i retries, exiting.",

                            self.rename_count)

            raise AvahiServiceError(u"Too many renames")

        self.name = server.GetAlternativeServiceName(self.name)

        logger.info(u"Changing Zeroconf service name to %r ...",

                    str(self.name))

        syslogger.setFormatter(logging.Formatter

                               ('Mandos (%s): %%(levelname)s:'

                                ' %%(message)s' % self.name))

        self.remove()

        self.add()

        self.rename_count += 1

    def remove(self):

        """Derived from the Avahi example code"""

        if group is not None:

            group.Reset()

    def add(self):

        """Derived from the Avahi example code"""

        global group

        if group is None:

            group = dbus.Interface(bus.get_object

                                   (avahi.DBUS_NAME,

                                    server.EntryGroupNew()),

                                   avahi.DBUS_INTERFACE_ENTRY_GROUP)

            group.connect_to_signal('StateChanged',

                                    entry_group_state_changed)

        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",

                     service.name, service.type)

        group.AddService(

                self.interface,         # interface

                avahi.PROTO_INET6,      # protocol

                dbus.UInt32(0),         # flags

                self.name, self.type,

                self.domain, self.host,

                dbus.UInt16(self.port),

                avahi.string_array_to_txt_array(self.TXT))

        group.Commit()

# From the Avahi example code:

group = None                            # our entry group

# End of Avahi example code

def _datetime_to_dbus(dt, variant_level=0):

    """Convert a UTC datetime.datetime() to a D-Bus type."""

    return dbus.String(dt.isoformat(), variant_level=variant_level)

class Client(dbus.service.Object):

    """A representation of a client host served by this server.

    Attributes:

    name:       string; from the config file, used in log messages and

                        D-Bus identifiers

    fingerprint: string (40 or 32 hexadecimal digits); used to

                 uniquely identify the client

    secret:     bytestring; sent verbatim (over TLS) to client

    host:       string; available for use by the checker command

    created:    datetime.datetime(); (UTC) object creation

    last_enabled: datetime.datetime(); (UTC)

    enabled:    bool()

    last_checked_ok: datetime.datetime(); (UTC) or None

    timeout:    datetime.timedelta(); How long from last_checked_ok

                                      until this client is invalid

    interval:   datetime.timedelta(); How often to start a new checker

    disable_hook:  If set, called by disable() as disable_hook(self)

    checker:    subprocess.Popen(); a running checker process used

                                    to see if the client lives.

                                    'None' if no process is running.

    checker_initiator_tag: a gobject event source tag, or None

    disable_initiator_tag:    - '' -

    checker_callback_tag:  - '' -

    checker_command: string; External command which is run to check if

                     client lives.  %() expansions are done at

                     runtime with vars(self) as dict, so that for

                     instance %(name)s can be used in the command.

    use_dbus: bool(); Whether to provide D-Bus interface and signals

    dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus

    """

    def timeout_milliseconds(self):

        "Return the 'timeout' attribute in milliseconds"

        return ((self.timeout.days * 24 * 60 * 60 * 1000)

                + (self.timeout.seconds * 1000)

                + (self.timeout.microseconds // 1000))

    def interval_milliseconds(self):

        "Return the 'interval' attribute in milliseconds"

        return ((self.interval.days * 24 * 60 * 60 * 1000)

                + (self.interval.seconds * 1000)

                + (self.interval.microseconds // 1000))

    def __init__(self, name = None, disable_hook=None, config=None,

                 use_dbus=True):

        """Note: the 'checker' key in 'config' sets the

        'checker_command' attribute and *not* the 'checker'

        attribute."""

        self.name = name

        if config is None:

            config = {}

        logger.debug(u"Creating client %r", self.name)

        self.use_dbus = False   # During __init__

        # Uppercase and remove spaces from fingerprint for later

        # comparison purposes with return value from the fingerprint()

        # function

        self.fingerprint = (config["fingerprint"].upper()

                            .replace(u" ", u""))

        logger.debug(u"  Fingerprint: %s", self.fingerprint)

        if "secret" in config:

            self.secret = config["secret"].decode(u"base64")

        elif "secfile" in config:

            with closing(open(os.path.expanduser

                              (os.path.expandvars

                               (config["secfile"])))) as secfile:

                self.secret = secfile.read()

        else:

            raise TypeError(u"No secret or secfile for client %s"

                            % self.name)

        self.host = config.get("host", "")

        self.created = datetime.datetime.utcnow()

        self.enabled = False

        self.last_enabled = None

        self.last_checked_ok = None

        self.timeout = string_to_delta(config["timeout"])

        self.interval = string_to_delta(config["interval"])

        self.disable_hook = disable_hook

        self.checker = None

        self.checker_initiator_tag = None

        self.disable_initiator_tag = None

        self.checker_callback_tag = None

        self.checker_command = config["checker"]

        self.last_connect = None

        # Only now, when this client is initialized, can it show up on

        # the D-Bus

        self.use_dbus = use_dbus

        if self.use_dbus:

            self.dbus_object_path = (dbus.ObjectPath

                                     ("/clients/"

                                      + self.name.replace(".", "_")))

            dbus.service.Object.__init__(self, bus,

                                         self.dbus_object_path)

    def enable(self):

        """Start this client's checker and timeout hooks"""

        self.last_enabled = datetime.datetime.utcnow()

        # Schedule a new checker to be started an 'interval' from now,

        # and every interval from then on.

        self.checker_initiator_tag = (gobject.timeout_add

                                      (self.interval_milliseconds(),

                                       self.start_checker))

        # Also start a new checker *right now*.

        self.start_checker()

        # Schedule a disable() when 'timeout' has passed

        self.disable_initiator_tag = (gobject.timeout_add

                                   (self.timeout_milliseconds(),

                                    self.disable))

        self.enabled = True

        if self.use_dbus:

            # Emit D-Bus signals

            self.PropertyChanged(dbus.String(u"enabled"),

                                 dbus.Boolean(True, variant_level=1))

            self.PropertyChanged(dbus.String(u"last_enabled"),

                                 (_datetime_to_dbus(self.last_enabled,

                                                    variant_level=1)))

    def disable(self):

        """Disable this client."""

        if not getattr(self, "enabled", False):

            return False

        logger.info(u"Disabling client %s", self.name)

        if getattr(self, "disable_initiator_tag", False):

            gobject.source_remove(self.disable_initiator_tag)

            self.disable_initiator_tag = None

        if getattr(self, "checker_initiator_tag", False):

            gobject.source_remove(self.checker_initiator_tag)

            self.checker_initiator_tag = None

        self.stop_checker()

        if self.disable_hook:

            self.disable_hook(self)

        self.enabled = False

        if self.use_dbus:

            # Emit D-Bus signal

            self.PropertyChanged(dbus.String(u"enabled"),

                                 dbus.Boolean(False, variant_level=1))

        # Do not run this again if called by a gobject.timeout_add

        return False

    def __del__(self):

        self.disable_hook = None

        self.disable()

    def checker_callback(self, pid, condition, command):

        """The checker has completed, so take appropriate actions."""

        self.checker_callback_tag = None

        self.checker = None

        if self.use_dbus:

            # Emit D-Bus signal

            self.PropertyChanged(dbus.String(u"checker_running"),

                                 dbus.Boolean(False, variant_level=1))

        if os.WIFEXITED(condition):

            exitstatus = os.WEXITSTATUS(condition)

            if exitstatus == 0:

                logger.info(u"Checker for %(name)s succeeded",

                            vars(self))

                self.checked_ok()

            else:

                logger.info(u"Checker for %(name)s failed",

                            vars(self))

            if self.use_dbus:

                # Emit D-Bus signal

                self.CheckerCompleted(dbus.Int16(exitstatus),

                                      dbus.Int64(condition),

                                      dbus.String(command))

        else:

            logger.warning(u"Checker for %(name)s crashed?",

                           vars(self))

            if self.use_dbus:

                # Emit D-Bus signal

                self.CheckerCompleted(dbus.Int16(-1),

                                      dbus.Int64(condition),

                                      dbus.String(command))

    def checked_ok(self):

        """Bump up the timeout for this client.

        This should only be called when the client has been seen,

        alive and well.

        """

        self.last_checked_ok = datetime.datetime.utcnow()

        gobject.source_remove(self.disable_initiator_tag)

        self.disable_initiator_tag = (gobject.timeout_add

                                      (self.timeout_milliseconds(),

                                       self.disable))

        if self.use_dbus:

            # Emit D-Bus signal

            self.PropertyChanged(

                dbus.String(u"last_checked_ok"),

                (_datetime_to_dbus(self.last_checked_ok,

                                   variant_level=1)))

    def start_checker(self):

        """Start a new checker subprocess if one is not running.

        If a checker already exists, leave it running and do

        nothing."""

        # The reason for not killing a running checker is that if we

        # did that, then if a checker (for some reason) started

        # running slowly and taking more than 'interval' time, the

        # client would inevitably timeout, since no checker would get

        # a chance to run to completion.  If we instead leave running

        # checkers alone, the checker would have to take more time

        # than 'timeout' for the client to be declared invalid, which

        # is as it should be.

        if self.checker is None:

            try:

                # In case checker_command has exactly one % operator

                command = self.checker_command % self.host

            except TypeError:

                # Escape attributes for the shell

                escaped_attrs = dict((key, re.escape(str(val)))

                                     for key, val in

                                     vars(self).iteritems())

                try:

                    command = self.checker_command % escaped_attrs

                except TypeError, error:

                    logger.error(u'Could not format string "%s":'

                                 u' %s', self.checker_command, error)

                    return True # Try again later

            try:

                logger.info(u"Starting checker %r for %s",

                            command, self.name)

                # We don't need to redirect stdout and stderr, since

                # in normal mode, that is already done by daemon(),

                # and in debug mode we don't want to.  (Stdin is

                # always replaced by /dev/null.)

                self.checker = subprocess.Popen(command,

                                                close_fds=True,

                                                shell=True, cwd="/")

                if self.use_dbus:

                    # Emit D-Bus signal

                    self.CheckerStarted(command)

                    self.PropertyChanged(

                        dbus.String("checker_running"),

                        dbus.Boolean(True, variant_level=1))

                self.checker_callback_tag = (gobject.child_watch_add

                                             (self.checker.pid,

                                              self.checker_callback,

                                              data=command))

            except OSError, error:

                logger.error(u"Failed to start subprocess: %s",

                             error)

        # Re-run this periodically if run by gobject.timeout_add

        return True

    def stop_checker(self):

        """Force the checker process, if any, to stop."""

        if self.checker_callback_tag:

            gobject.source_remove(self.checker_callback_tag)

            self.checker_callback_tag = None

        if getattr(self, "checker", None) is None:

            return

        logger.debug(u"Stopping checker for %(name)s", vars(self))

        try:

            os.kill(self.checker.pid, signal.SIGTERM)

            #os.sleep(0.5)

            #if self.checker.poll() is None:

            #    os.kill(self.checker.pid, signal.SIGKILL)

        except OSError, error:

            if error.errno != errno.ESRCH: # No such process

                raise

        self.checker = None

        if self.use_dbus:

            self.PropertyChanged(dbus.String(u"checker_running"),

                                 dbus.Boolean(False, variant_level=1))

    def still_valid(self):

        """Has the timeout not yet passed for this client?"""

        if not getattr(self, "enabled", False):

            return False

        now = datetime.datetime.utcnow()

        if self.last_checked_ok is None:

            return now < (self.created + self.timeout)

        else:

            return now < (self.last_checked_ok + self.timeout)

    ## D-Bus methods & signals

    _interface = u"se.bsnet.fukt.Mandos.Client"

    # CheckedOK - method

    CheckedOK = dbus.service.method(_interface)(checked_ok)

    CheckedOK.__name__ = "CheckedOK"

    # CheckerCompleted - signal

    @dbus.service.signal(_interface, signature="nxs")

    def CheckerCompleted(self, exitcode, waitstatus, command):

        "D-Bus signal"

        pass

    # CheckerStarted - signal

    @dbus.service.signal(_interface, signature="s")

    def CheckerStarted(self, command):

        "D-Bus signal"

        pass

    # GetAllProperties - method

    @dbus.service.method(_interface, out_signature="a{sv}")

    def GetAllProperties(self):

        "D-Bus method"

        return dbus.Dictionary({

                dbus.String("name"):

                    dbus.String(self.name, variant_level=1),

                dbus.String("fingerprint"):

                    dbus.String(self.fingerprint, variant_level=1),

                dbus.String("host"):

                    dbus.String(self.host, variant_level=1),

                dbus.String("created"):

                    _datetime_to_dbus(self.created, variant_level=1),

                dbus.String("last_enabled"):

                    (_datetime_to_dbus(self.last_enabled,

                                       variant_level=1)

                     if self.last_enabled is not None

                     else dbus.Boolean(False, variant_level=1)),

                dbus.String("enabled"):

                    dbus.Boolean(self.enabled, variant_level=1),

                dbus.String("last_checked_ok"):

                    (_datetime_to_dbus(self.last_checked_ok,

                                       variant_level=1)

                     if self.last_checked_ok is not None

                     else dbus.Boolean (False, variant_level=1)),

                dbus.String("timeout"):

                    dbus.UInt64(self.timeout_milliseconds(),

                                variant_level=1),

                dbus.String("interval"):

                    dbus.UInt64(self.interval_milliseconds(),

                                variant_level=1),

                dbus.String("checker"):

                    dbus.String(self.checker_command,

                                variant_level=1),

                dbus.String("checker_running"):

                    dbus.Boolean(self.checker is not None,

                                 variant_level=1),

                dbus.String("object_path"):

                    dbus.ObjectPath(self.dbus_object_path,

                                    variant_level=1)

                }, signature="sv")

    # IsStillValid - method

    IsStillValid = (dbus.service.method(_interface, out_signature="b")

                    (still_valid))

    IsStillValid.__name__ = "IsStillValid"

    # PropertyChanged - signal

    @dbus.service.signal(_interface, signature="sv")

    def PropertyChanged(self, property, value):

        "D-Bus signal"

        pass

    # SetChecker - method

    @dbus.service.method(_interface, in_signature="s")

    def SetChecker(self, checker):

        "D-Bus setter method"

        self.checker_command = checker

        # Emit D-Bus signal

        self.PropertyChanged(dbus.String(u"checker"),

                             dbus.String(self.checker_command,

                                         variant_level=1))

    # SetHost - method

    @dbus.service.method(_interface, in_signature="s")

    def SetHost(self, host):

        "D-Bus setter method"

        self.host = host

        # Emit D-Bus signal

        self.PropertyChanged(dbus.String(u"host"),

                             dbus.String(self.host, variant_level=1))

    # SetInterval - method

    @dbus.service.method(_interface, in_signature="t")

    def SetInterval(self, milliseconds):

        self.interval = datetime.timedelta(0, 0, 0, milliseconds)

        # Emit D-Bus signal

        self.PropertyChanged(dbus.String(u"interval"),

                             (dbus.UInt64(self.interval_milliseconds(),

                                          variant_level=1)))

    # SetSecret - method

    @dbus.service.method(_interface, in_signature="ay",

                         byte_arrays=True)

    def SetSecret(self, secret):

        "D-Bus setter method"

        self.secret = str(secret)

    # SetTimeout - method

    @dbus.service.method(_interface, in_signature="t")

    def SetTimeout(self, milliseconds):

        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)

        # Emit D-Bus signal

        self.PropertyChanged(dbus.String(u"timeout"),

                             (dbus.UInt64(self.timeout_milliseconds(),

                                          variant_level=1)))

    # Enable - method

    Enable = dbus.service.method(_interface)(enable)

    Enable.__name__ = "Enable"

    # StartChecker - method

    @dbus.service.method(_interface)

    def StartChecker(self):

        "D-Bus method"

        self.start_checker()

    # Disable - method

    @dbus.service.method(_interface)

    def Disable(self):

        "D-Bus method"

        self.disable()

    # StopChecker - method

    StopChecker = dbus.service.method(_interface)(stop_checker)

    StopChecker.__name__ = "StopChecker"

    del _interface

def peer_certificate(session):

    "Return the peer's OpenPGP certificate as a bytestring"

    # If not an OpenPGP certificate...

    if (gnutls.library.functions

        .gnutls_certificate_type_get(session._c_object)

        != gnutls.library.constants.GNUTLS_CRT_OPENPGP):

        # ...do the normal thing

        return session.peer_certificate

    list_size = ctypes.c_uint()

    cert_list = (gnutls.library.functions

                 .gnutls_certificate_get_peers

                 (session._c_object, ctypes.byref(list_size)))

    if list_size.value == 0:

        return None

    cert = cert_list[0]

    return ctypes.string_at(cert.data, cert.size)

def fingerprint(openpgp):

    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"

    # New GnuTLS "datum" with the OpenPGP public key

    datum = (gnutls.library.types

             .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),

                                         ctypes.POINTER

                                         (ctypes.c_ubyte)),

                             ctypes.c_uint(len(openpgp))))

    # New empty GnuTLS certificate

    crt = gnutls.library.types.gnutls_openpgp_crt_t()

    (gnutls.library.functions

     .gnutls_openpgp_crt_init(ctypes.byref(crt)))

    # Import the OpenPGP public key into the certificate

    (gnutls.library.functions

     .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),