[become] / src / check.c

/* -*-c-*-
 *
 * $Id: check.c,v 1.5 1997/09/26 09:14:58 mdw Exp $
 *
 * Check validity of requests
 *
 * (c) 1997 EBI
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of `become'
 *
 * `Become' 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 2 of the License, or
 * (at your option) any later version.
 *
 * `Become' 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 `become'; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------*
 *
 * $Log: check.c,v $
 * Revision 1.5  1997/09/26 09:14:58  mdw
 * Merged blowfish branch into trunk.
 *
 * Revision 1.4.2.1  1997/09/26 09:08:01  mdw
 * Use the Blowfish encryption algorithm instead of IDEA.  This is partly
 * because I prefer Blowfish (without any particularly strong evidence) but
 * mainly because IDEA is patented and Blowfish isn't.
 *
 * Revision 1.4  1997/08/07 09:52:05  mdw
 * (Log entry for previous version is bogus.)  Added support for multiple
 * servers.
 *
 * Revision 1.2  1997/08/04 10:24:20  mdw
 * Sources placed under CVS control.
 *
 * Revision 1.1  1997/07/21  13:47:53  mdw
 * Initial revision
 *
 */

/*----- Header files ------------------------------------------------------*/

/* --- ANSI headers --- */

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/* --- Unix headers --- */

#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>
#include <unistd.h>

/* --- Local headers --- */

#include "become.h"
#include "blowfish.h"
#include "config.h"
#include "crypt.h"
#include "lexer.h"
#include "name.h"
#include "netg.h"
#include "rule.h"
#include "parser.h"
#include "tx.h"
#include "userdb.h"
#include "utils.h"

/*----- Main code ---------------------------------------------------------*/

/* --- @check__send@ --- *
 *
 * Arguments:   @unsigned char *crq@ = pointer to encrypted request
 *              @int fd@ = socket to send from
 *              @struct sockaddr_in *serv@ = pointer to table of servers
 *              @size_t n_serv@ = number of servers
 *
 * Returns:     ---
 *
 * Use:         Sends the request packet to the list of servers.  If the
 *              message couldn't be sent to any of them, an error is
 *              reported.
 */

static void check__send(unsigned char *crq, int fd,
                        struct sockaddr_in *serv, size_t n_serv)
{
  size_t i;
  int ok = 0;
  int err = 0;

  for (i = 0; i < n_serv; i++) {
    if (sendto(fd, (char *)crq, crq_size, 0,
               (struct sockaddr *)(serv + i), sizeof(serv[i])) < 0) {
      T( trace(TRACE_CLIENT, "client: send to %s failed: %s",
               inet_ntoa(serv[i].sin_addr), strerror(errno)); )
      err = errno;
    } else
      ok = 1;
  }

  if (!ok)
    die("couldn't send request to server: %s", strerror(err));
}

/* --- @check__ask@ --- *
 *
 * Arguments:   @request *rq@ = pointer to request buffer
 *              @struct sockaddr_in *serv@ = pointer to table of servers
 *              @size_t n_serv@ = number of servers
 *
 * Returns:     Nonzero if OK, zero if forbidden
 *
 * Use:         Contacts a number of servers to decide whether the request
 *              is OK.
 */

static int check__ask(request *rq, struct sockaddr_in *serv, size_t n_serv)
{
  int fd;
  unsigned char crq[crq_size];
  unsigned char sk[BLOWFISH_KEYSIZE];
  time_t t;
  pid_t pid;

  /* --- First, build the encrypted request packet --- */

  {
    unsigned char k[BLOWFISH_KEYSIZE];
    FILE *fp;

    /* --- Read in the encryption key --- */

    if ((fp = fopen(file_KEY, "r")) == 0) {
      die("couldn't open key file `%s': %s", file_KEY,
          strerror(errno));
    }
    tx_getBits(k, 128, fp);

    /* --- Now build a request packet --- */

    t = time(0);
    pid = getpid();
    crypt_packRequest(rq, crq, t, pid, k, sk);
    burn(k);
    T( trace(TRACE_CLIENT, "client: encrypted request packet"); )
  }

  /* --- Create my socket --- */

  {
    struct sockaddr_in sin;

    if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
      die("couldn't create socket: %s", strerror(errno));

    /* --- Bind myself to some address --- */

    sin.sin_family = AF_INET;
    sin.sin_port = 0;
    sin.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
      die("couldn't bind socket to address: %s", strerror(errno));
  }

  /* --- Now wait for a reply --- */

  {
    fd_set fds;
    struct timeval start, now, tv;
    int ind;
    size_t i;

    /* --- State table for waiting for replies --- *
     *
     * For each number, send off the request to our servers, and wait for
     * that many seconds to have elapsed since we started.  If the number is
     * %$-1$% then it's time to give up.
     */

    static int tbl[] = { 0, 5, 10, 20, -1 };

    /* --- Find out when we are --- */

    gettimeofday(&start, 0);
    ind = 0;

    /* --- Now loop until everything's done --- */

    for (;;) {
      gettimeofday(&now, 0);

      /* --- If the current timer has expired, find one that hasn't --- *
       *
       * Also resend the request after I've found a timer which is still
       * extant.  If there aren't any, report an error.
       */

      if (now.tv_sec >= start.tv_sec + tbl[ind] &&
          now.tv_usec >= start.tv_usec) {
        do {
          ind++;
          if (tbl[ind] < 0)
            die("no reply from servers");
        } while (now.tv_sec >= start.tv_sec + tbl[ind] &&
                 now.tv_usec >= start.tv_usec);
        check__send(crq, fd, serv, n_serv);
        T( trace(TRACE_CLIENT, "client: send request to servers"); )
      }

      /* --- Now wait for a packet to arrive --- */

      if (now.tv_usec > start.tv_usec) {
        now.tv_usec -= 1000000;
        now.tv_sec += 1;
      }
      tv.tv_sec = start.tv_sec + tbl[ind] - now.tv_sec;
      tv.tv_usec = start.tv_usec - now.tv_usec;

      /* --- Sort out file descriptors to watch --- */

      FD_ZERO(&fds);
      FD_SET(fd, &fds);

      /* --- Wait for them --- */

      i = select(FD_SETSIZE, &fds, 0, 0, &tv);
      if (i == 0 || (i < 0 && errno == EINTR))
        continue;
      if (i < 0)
        die("error waiting for reply: %s", strerror(errno));

      /* --- A reply should be waiting now --- */

      {
        struct sockaddr_in sin;
        int slen = sizeof(sin);
        unsigned char buff[256];
        int answer;

        /* --- Read the reply data --- */

        if (recvfrom(fd, (char *)buff, sizeof(buff), 0,
                     (struct sockaddr *)&sin, &slen) < 0)
          die("error reading server's reply: %s", strerror(errno));

        IF_TRACING(TRACE_CLIENT, {
          struct hostent *h = gethostbyaddr((char *)&sin.sin_addr,
                                            sizeof(sin.sin_addr), AF_INET);
          trace(TRACE_CLIENT, "client: reply received from %s port %i",
                h ? h->h_name : inet_ntoa(sin.sin_addr),
                ntohs(sin.sin_port));
        })

        /* --- Verify the sender --- *
         *
         * This is more to avoid confusion than for security: an active
         * attacker is quite capable of forging the source address.  We rely
         * on the checksum in the reply packet for authentication.
         */

        for (i = 0; i < n_serv; i++) {
          if (sin.sin_addr.s_addr == serv[i].sin_addr.s_addr &&
              sin.sin_port == serv[i].sin_port)
            break;
        }
        if (i >= n_serv) {
          T( trace(TRACE_CLIENT, "client: reply from unknown host"); )
          continue;
        }
    
        /* --- Unpack and verify the response --- */

        answer = crypt_unpackReply(buff, sk, t, pid);
        if (answer < 0) {
          T( trace(TRACE_CLIENT,
                   "client: invalid or corrupt reply packet"); )
          continue;
        }
        return (answer);
      }
    }
  }

  die("internal error: can't get here in check__ask");
  return (0);
}

/* --- @check__client@ --- *
 *
 * Arguments:   @request *rq@ = pointer to a request block
 *              @FILE *fp@ = file containing server configuration
 *
 * Returns:     Nonzero if OK, zero if forbidden
 *
 * Use:         Asks one or several servers whether a request is acceptable.
 */

int check__client(request *rq, FILE *fp)
{
  /* --- Format of the file --- *
   *
   * The `servers' file contains entries of the form
   *
   *    %%\syntax{<host> [`:' <port>]}%%
   *
   * separates by whitespace.  I build them all into an array of socket
   * addresses and pass the whole lot to another function.
   */

  struct sockaddr_in *serv;             /* Array of servers */
  size_t n_serv, max_serv;              /* Number and maximum number */

  /* --- Initialise the server array --- */

  T( trace(TRACE_CLIENT, "client: reading server definitions"); )
  n_serv = 0; max_serv = 4;             /* Four seems reasonable */
  serv = xmalloc(sizeof(*serv) * max_serv);

  /* --- Start reading the file --- */

  {
    char buff[256], *p, *l;             /* A buffer and pointers for it */
    int port;                           /* Default port for servers */
    int state;                          /* Current parser state */
    struct in_addr t_host;              /* Temp place for an address*/
    int t_port;                         /* Temp place for a port */
    int ch;                             /* The current character */

    /* --- Parser states --- */

    enum {
      st_start,                         /* Waiting to begin */
      st_host,                          /* Reading a new hostname */
      st_colon,                         /* Expecting a colon, maybe */
      st_preport,                       /* Waiting before reading port */
      st_port,                          /* Reading a port number */
      st_commit,                        /* Commit a newly read server */
      st_done                           /* Finished reading the file */
    };

    /* --- Find a default port --- */

    {
      struct servent *s = getservbyname(quis(), "udp");
      port = (s ? s->s_port : -1);
    }

    /* --- Initialise for scanning the file --- */

    state = st_host;
    p = buff;
    l = buff + sizeof(buff);
    t_port = port;
    ch = getc(fp);

    /* --- Go for it --- */

    while (state != st_done) {
      switch (state) {

        /* --- Initial whitespace before hostname --- */

        case st_start:
          if (ch == EOF)
            state = st_done;
          else if (isspace((unsigned char)ch))
            ch = getc(fp);
          else
            state = st_host;
          break;

        /* --- Read a host name --- */

        case st_host:
          if (p == l)
            die("string too long in `" file_SERVER "'");
          if (ch != EOF && !isspace((unsigned char)ch) && ch != ':') {
            *p++ = ch;
            ch = getc(fp);
          } else {
            struct hostent *h;

            *p++ = 0;
            if ((h = gethostbyname(buff)) == 0)
              die("unknown host `%s' in `" file_SERVER "'", buff);
            memcpy(&t_host, h->h_addr, sizeof(t_host));
            state = st_colon;
          }
          break;

        /* --- Waiting for a colon coming up --- */

        case st_colon:
          if (ch == EOF)
            state = st_commit;
          else if (isspace((unsigned char)ch))
            ch = getc(fp);
          else if (ch == ':') {
            state = st_preport;
            ch = getc(fp);
          }
          else
            state = st_commit;
          break;

        /* --- Clearing whitespace before a port number --- */

        case st_preport:
          if (ch == EOF)
            state = st_commit;
          else if (isspace((unsigned char)ch))
            ch = getc(fp);
          else {
            state = st_port;
            p = buff;
          }
          break;

        /* --- Read a port number --- */

        case st_port:
          if (p == l)
            die("string too long in `" file_SERVER "'");
          if (ch != EOF && !isspace((unsigned char)ch) && ch != ':') {
            *p++ = ch;
            ch = getc(fp);
          } else {
            struct servent *s;

            *p++ = 0;
            s = getservbyname(buff, "udp");
            if (!s && isdigit((unsigned char)buff[0]))
              t_port = htons(atoi(buff));
            else if (!s)
              die("unknown service `%s' in `" file_SERVER "'", buff);
            else
              t_port = s->s_port;
            state = st_commit;
          }
          break;

        /* --- A server has been read successfully --- */

        case st_commit:
          if (n_serv == max_serv) {
            max_serv *= 2;
            serv = xrealloc(serv, max_serv * sizeof(*serv));
          }
          serv[n_serv].sin_family = AF_INET;
          serv[n_serv].sin_addr = t_host;
          serv[n_serv].sin_port = t_port;
          n_serv++;
          state = st_start;
          p = buff;
          t_port = port;
          break;

        /* --- A safety net for a broken parser --- */

        default:
          die("internal error: can't get here in check__client");
          break;          
      }
    }
  }

  fclose(fp);

  /* --- Now start sending requests --- */

  if (!n_serv)
    die("no servers specified in `" file_SERVER "'");

  IF_TRACING(TRACE_CLIENT, {
    size_t i;

    for (i = 0; i < n_serv; i++) {
      trace(TRACE_CLIENT, "client: server %s port %i",
            inet_ntoa(serv[i].sin_addr), ntohs(serv[i].sin_port));
    }
  })
  return (check__ask(rq, serv, n_serv));
}

/* --- @check@ --- *
 *
 * Arguments:   @request *rq@ = pointer to request buffer
 *
 * Returns:     Nonzero if OK, zero if forbidden
 *
 * Use:         Checks to see if the request is acceptable.
 */

int check(request *rq)
{
  FILE *fp;

  /* --- Check if we need to talk to a server --- */

  if ((fp = fopen(file_SERVER, "r")) != 0)
    return (check__client(rq, fp));

  /* --- Otherwise do this all the old-fashioned way --- */

  if ((fp = fopen(file_RULES, "r")) == 0) {
    die("couldn't read configuration file `%s': %s",
        file_RULES, strerror(errno));
  }

  userdb_init();
  userdb_local();
  userdb_yp();
  netg_init();
  name_init();
  rule_init();
  lexer_scan(fp);
  yyparse();

  return (rule_check(rq));
}

/*----- That's all, folks -------------------------------------------------*/