/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", "remove", "server_state_changed",

# "entry_group_state_changed", "cleanup", and "activate" in the

# "AvahiService" class, and some lines in "main".

# 

# Everything else is

# Copyright © 2008-2012 Teddy Hogeborn

# Copyright © 2008-2012 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@recompile.se>.

# 

from __future__ import (division, absolute_import, print_function,

                        unicode_literals)

import SocketServer as socketserver

import socket

import argparse

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 as configparser

import sys

import re

import os

import signal

import subprocess

import atexit

import stat

import logging

import logging.handlers

import pwd

import contextlib

import struct

import fcntl

import functools

import cPickle as pickle

import multiprocessing

import types

import binascii

import tempfile

import dbus

import dbus.service

import gobject

import avahi

from dbus.mainloop.glib import DBusGMainLoop

import ctypes

import ctypes.util

import xml.dom.minidom

import inspect

import GnuPGInterface

try:

    SO_BINDTODEVICE = socket.SO_BINDTODEVICE

except AttributeError:

    try:

        from IN import SO_BINDTODEVICE

    except ImportError:

        SO_BINDTODEVICE = None

version = "1.4.1"

stored_state_file = "clients.pickle"

logger = logging.getLogger()

syslogger = (logging.handlers.SysLogHandler

             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,

              address = str("/dev/log")))

try:

    if_nametoindex = (ctypes.cdll.LoadLibrary

                      (ctypes.util.find_library("c"))

                      .if_nametoindex)

except (OSError, AttributeError):

    def if_nametoindex(interface):

        "Get an interface index the hard way, i.e. using fcntl()"

        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h

        with contextlib.closing(socket.socket()) as s:

            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

                                struct.pack(str("16s16x"),

                                            interface))

        interface_index = struct.unpack(str("I"),

                                        ifreq[16:20])[0]

        return interface_index

def initlogger(debug, level=logging.WARNING):

    """init logger and add loglevel"""

    syslogger.setFormatter(logging.Formatter

                           ('Mandos [%(process)d]: %(levelname)s:'

                            ' %(message)s'))

    logger.addHandler(syslogger)

    if debug:

        console = logging.StreamHandler()

        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'

                                               ' [%(process)d]:'

                                               ' %(levelname)s:'

                                               ' %(message)s'))

        logger.addHandler(console)

    logger.setLevel(level)

class PGPError(Exception):

    """Exception if encryption/decryption fails"""

    pass

class PGPEngine(object):

    """A simple class for OpenPGP symmetric encryption & decryption"""

    def __init__(self):

        self.gnupg = GnuPGInterface.GnuPG()

        self.tempdir = tempfile.mkdtemp(prefix="mandos-")

        self.gnupg = GnuPGInterface.GnuPG()

        self.gnupg.options.meta_interactive = False

        self.gnupg.options.homedir = self.tempdir

        self.gnupg.options.extra_args.extend(['--force-mdc',

                                              '--quiet',

                                              '--no-use-agent'])

    def __enter__(self):

        return self

    def __exit__ (self, exc_type, exc_value, traceback):

        self._cleanup()

        return False

    def __del__(self):

        self._cleanup()

    def _cleanup(self):

        if self.tempdir is not None:

            # Delete contents of tempdir

            for root, dirs, files in os.walk(self.tempdir,

                                             topdown = False):

                for filename in files:

                    os.remove(os.path.join(root, filename))

                for dirname in dirs:

                    os.rmdir(os.path.join(root, dirname))

            # Remove tempdir

            os.rmdir(self.tempdir)

            self.tempdir = None

    def password_encode(self, password):

        # Passphrase can not be empty and can not contain newlines or

        # NUL bytes.  So we prefix it and hex encode it.

        return b"mandos" + binascii.hexlify(password)

    def encrypt(self, data, password):

        self.gnupg.passphrase = self.password_encode(password)

        with open(os.devnull) as devnull:

            try:

                proc = self.gnupg.run(['--symmetric'],

                                      create_fhs=['stdin', 'stdout'],

                                      attach_fhs={'stderr': devnull})

                with contextlib.closing(proc.handles['stdin']) as f:

                    f.write(data)

                with contextlib.closing(proc.handles['stdout']) as f:

                    ciphertext = f.read()

                proc.wait()

            except IOError as e:

                raise PGPError(e)

        self.gnupg.passphrase = None

        return ciphertext

    def decrypt(self, data, password):

        self.gnupg.passphrase = self.password_encode(password)

        with open(os.devnull) as devnull:

            try:

                proc = self.gnupg.run(['--decrypt'],

                                      create_fhs=['stdin', 'stdout'],

                                      attach_fhs={'stderr': devnull})

                with contextlib.closing(proc.handles['stdin'] ) as f:

                    f.write(data)

                with contextlib.closing(proc.handles['stdout']) as f:

                    decrypted_plaintext = f.read()

                proc.wait()

            except IOError as e:

                raise PGPError(e)

        self.gnupg.passphrase = None

        return decrypted_plaintext

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

    group: D-Bus Entry Group

    server: D-Bus Server

    bus: dbus.SystemBus()

    """

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

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

                 domain = "", host = "", max_renames = 32768,

                 protocol = avahi.PROTO_UNSPEC, bus = None):

        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

        self.protocol = protocol

        self.group = None       # our entry group

        self.server = None

        self.bus = bus

        self.entry_group_state_changed_match = None

    def rename(self):

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

        if self.rename_count >= self.max_renames:

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

                            " after %i retries, exiting.",

                            self.rename_count)

            raise AvahiServiceError("Too many renames")

        self.name = unicode(self.server

                            .GetAlternativeServiceName(self.name))

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

                    self.name)

        self.remove()

        try:

            self.add()

        except dbus.exceptions.DBusException as error:

            logger.critical("DBusException: %s", error)

            self.cleanup()

            os._exit(1)

        self.rename_count += 1

    def remove(self):

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

        if self.entry_group_state_changed_match is not None:

            self.entry_group_state_changed_match.remove()

            self.entry_group_state_changed_match = None

        if self.group is not None:

            self.group.Reset()

    def add(self):

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

        self.remove()

        if self.group is None:

            self.group = dbus.Interface(

                self.bus.get_object(avahi.DBUS_NAME,

                                    self.server.EntryGroupNew()),

                avahi.DBUS_INTERFACE_ENTRY_GROUP)

        self.entry_group_state_changed_match = (

            self.group.connect_to_signal(

                'StateChanged', self.entry_group_state_changed))

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

                     self.name, self.type)

        self.group.AddService(

            self.interface,

            self.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))

        self.group.Commit()

    def entry_group_state_changed(self, state, error):

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

        logger.debug("Avahi entry group state change: %i", state)

        if state == avahi.ENTRY_GROUP_ESTABLISHED:

            logger.debug("Zeroconf service established.")

        elif state == avahi.ENTRY_GROUP_COLLISION:

            logger.info("Zeroconf service name collision.")

            self.rename()

        elif state == avahi.ENTRY_GROUP_FAILURE:

            logger.critical("Avahi: Error in group state changed %s",

                            unicode(error))

            raise AvahiGroupError("State changed: %s"

                                  % unicode(error))

    def cleanup(self):

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

        if self.group is not None:

            try:

                self.group.Free()

            except (dbus.exceptions.UnknownMethodException,

                    dbus.exceptions.DBusException):

                pass

            self.group = None

        self.remove()

    def server_state_changed(self, state, error=None):

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

        logger.debug("Avahi server state change: %i", state)

        bad_states = { avahi.SERVER_INVALID:

                           "Zeroconf server invalid",

                       avahi.SERVER_REGISTERING: None,

                       avahi.SERVER_COLLISION:

                           "Zeroconf server name collision",

                       avahi.SERVER_FAILURE:

                           "Zeroconf server failure" }

        if state in bad_states:

            if bad_states[state] is not None:

                if error is None:

                    logger.error(bad_states[state])

                else:

                    logger.error(bad_states[state] + ": %r", error)

            self.cleanup()

        elif state == avahi.SERVER_RUNNING:

            self.add()

        else:

            if error is None:

                logger.debug("Unknown state: %r", state)

            else:

                logger.debug("Unknown state: %r: %r", state, error)

    def activate(self):

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

        if self.server is None:

            self.server = dbus.Interface(

                self.bus.get_object(avahi.DBUS_NAME,

                                    avahi.DBUS_PATH_SERVER,

                                    follow_name_owner_changes=True),

                avahi.DBUS_INTERFACE_SERVER)

        self.server.connect_to_signal("StateChanged",

                                 self.server_state_changed)

        self.server_state_changed(self.server.GetState())

class AvahiServiceToSyslog(AvahiService):

    def rename(self):

        """Add the new name to the syslog messages"""

        ret = AvahiService.rename(self)

        syslogger.setFormatter(logging.Formatter

                               ('Mandos (%s) [%%(process)d]:'

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

                                % self.name))

        return ret

def timedelta_to_milliseconds(td):

    "Convert a datetime.timedelta() to milliseconds"

    return ((td.days * 24 * 60 * 60 * 1000)

            + (td.seconds * 1000)

            + (td.microseconds // 1000))

class Client(object):

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

    Attributes:

    approved:   bool(); 'None' if not yet approved/disapproved

    approval_delay: datetime.timedelta(); Time to wait for approval

    approval_duration: datetime.timedelta(); Duration of one approval

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

                                    to see if the client lives.

                                    'None' if no process is running.

    checker_callback_tag: a gobject event source tag, or None

    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.

    checker_initiator_tag: a gobject event source tag, or None

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

    client_structure: Object describing what attributes a client has

                      and is used for storing the client at exit

    current_checker_command: string; current running checker_command

    disable_initiator_tag: a gobject event source tag, or None

    enabled:    bool()

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

                 uniquely identify the client

    host:       string; available for use by the checker command

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

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

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

    last_checker_status: integer between 0 and 255 reflecting exit

                         status of last checker. -1 reflects crashed

                         checker, or None.

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

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

                        D-Bus identifiers

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

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

                                      until this client is disabled

    extended_timeout:   extra long timeout when password has been sent

    runtime_expansions: Allowed attributes for runtime expansion.

    expires:    datetime.datetime(); time (UTC) when a client will be

                disabled, or None

    """

    runtime_expansions = ("approval_delay", "approval_duration",

                          "created", "enabled", "fingerprint",

                          "host", "interval", "last_checked_ok",

                          "last_enabled", "name", "timeout")

    client_defaults = { "timeout": "5m",

                        "extended_timeout": "15m",

                        "interval": "2m",

                        "checker": "fping -q -- %%(host)s",

                        "host": "",

                        "approval_delay": "0s",

                        "approval_duration": "1s",

                        "approved_by_default": "True",

                        "enabled": "True",

                        }

    def timeout_milliseconds(self):

        "Return the 'timeout' attribute in milliseconds"

        return timedelta_to_milliseconds(self.timeout)

    def extended_timeout_milliseconds(self):

        "Return the 'extended_timeout' attribute in milliseconds"

        return timedelta_to_milliseconds(self.extended_timeout)

    def interval_milliseconds(self):

        "Return the 'interval' attribute in milliseconds"

        return timedelta_to_milliseconds(self.interval)

    def approval_delay_milliseconds(self):

        return timedelta_to_milliseconds(self.approval_delay)

    @staticmethod

    def config_parser(config):

        """Construct a new dict of client settings of this form:

        { client_name: {setting_name: value, ...}, ...}

        with exceptions for any special settings as defined above.

        NOTE: Must be a pure function. Must return the same result

        value given the same arguments.

        """

        settings = {}

        for client_name in config.sections():

            section = dict(config.items(client_name))

            client = settings[client_name] = {}

            client["host"] = section["host"]

            # Reformat values from string types to Python types

            client["approved_by_default"] = config.getboolean(

                client_name, "approved_by_default")

            client["enabled"] = config.getboolean(client_name,

                                                  "enabled")

            client["fingerprint"] = (section["fingerprint"].upper()

                                     .replace(" ", ""))

            if "secret" in section:

                client["secret"] = section["secret"].decode("base64")

            elif "secfile" in section:

                with open(os.path.expanduser(os.path.expandvars

                                             (section["secfile"])),

                          "rb") as secfile:

                    client["secret"] = secfile.read()

            else:

                raise TypeError("No secret or secfile for section %s"

                                % section)

            client["timeout"] = string_to_delta(section["timeout"])

            client["extended_timeout"] = string_to_delta(

                section["extended_timeout"])

            client["interval"] = string_to_delta(section["interval"])

            client["approval_delay"] = string_to_delta(

                section["approval_delay"])

            client["approval_duration"] = string_to_delta(

                section["approval_duration"])

            client["checker_command"] = section["checker"]

            client["last_approval_request"] = None

            client["last_checked_ok"] = None

            client["last_checker_status"] = None

        return settings

    def __init__(self, settings, name = None):

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

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

        attribute."""

        self.name = name

        # adding all client settings

        for setting, value in settings.iteritems():

            setattr(self, setting, value)

        if self.enabled:

            if not hasattr(self, "last_enabled"):

                self.last_enabled = datetime.datetime.utcnow()

            if not hasattr(self, "expires"):

                self.expires = (datetime.datetime.utcnow()

                                + self.timeout)

        else:

            self.last_enabled = None

            self.expires = None

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

        # Uppercase and remove spaces from fingerprint for later

        # comparison purposes with return value from the fingerprint()

        # function

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

        self.created = settings.get("created",

                                    datetime.datetime.utcnow())

        # attributes specific for this server instance

        self.checker = None

        self.checker_initiator_tag = None

        self.disable_initiator_tag = None

        self.checker_callback_tag = None

        self.current_checker_command = None

        self.approved = None

        self.approvals_pending = 0

        self.changedstate = (multiprocessing_manager

                             .Condition(multiprocessing_manager

                                        .Lock()))

        self.client_structure = [attr for attr in

                                 self.__dict__.iterkeys()

                                 if not attr.startswith("_")]

        self.client_structure.append("client_structure")

        for name, t in inspect.getmembers(type(self),

                                          lambda obj:

                                              isinstance(obj,

                                                         property)):

            if not name.startswith("_"):

                self.client_structure.append(name)

    # Send notice to process children that client state has changed

    def send_changedstate(self):

        with self.changedstate:

            self.changedstate.notify_all()

    def enable(self):

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

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

            # Already enabled

            return

        self.send_changedstate()

        self.expires = datetime.datetime.utcnow() + self.timeout

        self.enabled = True

        self.last_enabled = datetime.datetime.utcnow()

        self.init_checker()

    def disable(self, quiet=True):

        """Disable this client."""

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

            return False

        if not quiet:

            self.send_changedstate()

        if not quiet:

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

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

            gobject.source_remove(self.disable_initiator_tag)

            self.disable_initiator_tag = None

        self.expires = None

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

            gobject.source_remove(self.checker_initiator_tag)

            self.checker_initiator_tag = None

        self.stop_checker()

        self.enabled = False

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

        return False

    def __del__(self):

        self.disable()

    def init_checker(self):

        # 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))

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

        self.disable_initiator_tag = (gobject.timeout_add

                                   (self.timeout_milliseconds(),

                                    self.disable))

        # Also start a new checker *right now*.

        self.start_checker()

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

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

        self.checker_callback_tag = None

        self.checker = None

        if os.WIFEXITED(condition):

            self.last_checker_status = os.WEXITSTATUS(condition)

            if self.last_checker_status == 0:

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

                            vars(self))

                self.checked_ok()

            else:

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

                            vars(self))

        else:

            self.last_checker_status = -1

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

                           vars(self))

    def checked_ok(self, timeout=None):

        """Bump up the timeout for this client.

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