crypto/openssh/hostfile.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  * Functions for manipulating the known hosts files.
   6  *
   7  * As far as I am concerned, the code I have written for this software
   8  * can be used freely for any purpose.  Any derived versions of this
   9  * software must be clearly marked as such, and if the derived work is
  10  * incompatible with the protocol description in the RFC file, it must be
  11  * called by a name other than "ssh" or "Secure Shell".
  12  *
  13  *
  14  * Copyright (c) 1999, 2000 Markus Friedl.  All rights reserved.
  15  * Copyright (c) 1999 Niels Provos.  All rights reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions
  19  * are met:
  20  * 1. Redistributions of source code must retain the above copyright
  21  *    notice, this list of conditions and the following disclaimer.
  22  * 2. Redistributions in binary form must reproduce the above copyright
  23  *    notice, this list of conditions and the following disclaimer in the
  24  *    documentation and/or other materials provided with the distribution.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  29  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  31  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  35  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 #include "includes.h"
  39 RCSID("$OpenBSD: hostfile.c,v 1.30 2002/07/24 16:11:18 markus Exp $");
  40 RCSID("$FreeBSD: src/crypto/openssh/hostfile.c,v 1.1.1.1.2.5 2003/02/03 17:31:06 des Exp $");
  41 RCSID("$DragonFly: src/crypto/openssh/Attic/hostfile.c,v 1.2 2003/06/17 04:24:36 dillon Exp $");
  42
  43 #include "packet.h"
  44 #include "match.h"
  45 #include "key.h"
  46 #include "hostfile.h"
  47 #include "log.h"
  48
  49 /*
  50  * Parses an RSA (number of bits, e, n) or DSA key from a string.  Moves the
  51  * pointer over the key.  Skips any whitespace at the beginning and at end.
  52  */
  53
  54 int
  55 hostfile_read_key(char **cpp, u_int *bitsp, Key *ret)
  56 {
  57         char *cp;
  58
  59         /* Skip leading whitespace. */
  60         for (cp = *cpp; *cp == ' ' || *cp == '\t'; cp++)
  61                 ;
  62
  63         if (key_read(ret, &cp) != 1)
  64                 return 0;
  65
  66         /* Skip trailing whitespace. */
  67         for (; *cp == ' ' || *cp == '\t'; cp++)
  68                 ;
  69
  70         /* Return results. */
  71         *cpp = cp;
  72         *bitsp = key_size(ret);
  73         return 1;
  74 }
  75
  76 static int
  77 hostfile_check_key(int bits, Key *key, const char *host, const char *filename, int linenum)
  78 {
  79         if (key == NULL || key->type != KEY_RSA1 || key->rsa == NULL)
  80                 return 1;
  81         if (bits != BN_num_bits(key->rsa->n)) {
  82                 log("Warning: %s, line %d: keysize mismatch for host %s: "
  83                     "actual %d vs. announced %d.",
  84                     filename, linenum, host, BN_num_bits(key->rsa->n), bits);
  85                 log("Warning: replace %d with %d in %s, line %d.",
  86                     bits, BN_num_bits(key->rsa->n), filename, linenum);
  87         }
  88         return 1;
  89 }
  90
  91 /*
  92  * Checks whether the given host (which must be in all lowercase) is already
  93  * in the list of our known hosts. Returns HOST_OK if the host is known and
  94  * has the specified key, HOST_NEW if the host is not known, and HOST_CHANGED
  95  * if the host is known but used to have a different host key.
  96  *
  97  * If no 'key' has been specified and a key of type 'keytype' is known
  98  * for the specified host, then HOST_FOUND is returned.
  99  */
 100
 101 static HostStatus
 102 check_host_in_hostfile_by_key_or_type(const char *filename,
 103     const char *host, Key *key, int keytype, Key *found, int *numret)
 104 {
 105         FILE *f;
 106         char line[8192];
 107         int linenum = 0;
 108         u_int kbits;
 109         char *cp, *cp2;
 110         HostStatus end_return;
 111
 112         debug3("check_host_in_hostfile: filename %s", filename);
 113
 114         /* Open the file containing the list of known hosts. */
 115         f = fopen(filename, "r");
 116         if (!f)
 117                 return HOST_NEW;
 118
 119         /*
 120          * Return value when the loop terminates.  This is set to
 121          * HOST_CHANGED if we have seen a different key for the host and have
 122          * not found the proper one.
 123          */
 124         end_return = HOST_NEW;
 125
 126         /* Go through the file. */
 127         while (fgets(line, sizeof(line), f)) {
 128                 cp = line;
 129                 linenum++;
 130
 131                 /* Skip any leading whitespace, comments and empty lines. */
 132                 for (; *cp == ' ' || *cp == '\t'; cp++)
 133                         ;
 134                 if (!*cp || *cp == '#' || *cp == '\n')
 135                         continue;
 136
 137                 /* Find the end of the host name portion. */
 138                 for (cp2 = cp; *cp2 && *cp2 != ' ' && *cp2 != '\t'; cp2++)
 139                         ;
 140
 141                 /* Check if the host name matches. */
 142                 if (match_hostname(host, cp, (u_int) (cp2 - cp)) != 1)
 143                         continue;
 144
 145                 /* Got a match.  Skip host name. */
 146                 cp = cp2;
 147
 148                 /*
 149                  * Extract the key from the line.  This will skip any leading
 150                  * whitespace.  Ignore badly formatted lines.
 151                  */
 152                 if (!hostfile_read_key(&cp, &kbits, found))
 153                         continue;
 154
 155                 if (numret != NULL)
 156                         *numret = linenum;
 157
 158                 if (key == NULL) {
 159                         /* we found a key of the requested type */
 160                         if (found->type == keytype)
 161                                 return HOST_FOUND;
 162                         continue;
 163                 }
 164
 165                 if (!hostfile_check_key(kbits, found, host, filename, linenum))
 166                         continue;
 167
 168                 /* Check if the current key is the same as the given key. */
 169                 if (key_equal(key, found)) {
 170                         /* Ok, they match. */
 171                         debug3("check_host_in_hostfile: match line %d", linenum);
 172                         fclose(f);
 173                         return HOST_OK;
 174                 }
 175                 /*
 176                  * They do not match.  We will continue to go through the
 177                  * file; however, we note that we will not return that it is
 178                  * new.
 179                  */
 180                 end_return = HOST_CHANGED;
 181         }
 182         /* Clear variables and close the file. */
 183         fclose(f);
 184
 185         /*
 186          * Return either HOST_NEW or HOST_CHANGED, depending on whether we
 187          * saw a different key for the host.
 188          */
 189         return end_return;
 190 }
 191
 192 HostStatus
 193 check_host_in_hostfile(const char *filename, const char *host, Key *key,
 194     Key *found, int *numret)
 195 {
 196         if (key == NULL)
 197                 fatal("no key to look up");
 198         return (check_host_in_hostfile_by_key_or_type(filename, host, key, 0,
 199             found, numret));
 200 }
 201
 202 int
 203 lookup_key_in_hostfile_by_type(const char *filename, const char *host,
 204     int keytype, Key *found, int *numret)
 205 {
 206         return (check_host_in_hostfile_by_key_or_type(filename, host, NULL,
 207             keytype, found, numret) == HOST_FOUND);
 208 }
 209
 210 /*
 211  * Appends an entry to the host file.  Returns false if the entry could not
 212  * be appended.
 213  */
 214
 215 int
 216 add_host_to_hostfile(const char *filename, const char *host, Key *key)
 217 {
 218         FILE *f;
 219         int success = 0;
 220         if (key == NULL)
 221                 return 1;       /* XXX ? */
 222         f = fopen(filename, "a");
 223         if (!f)
 224                 return 0;
 225         fprintf(f, "%s ", host);
 226         if (key_write(key, f)) {
 227                 success = 1;
 228         } else {
 229                 error("add_host_to_hostfile: saving key in %s failed", filename);
 230         }
 231         fprintf(f, "\n");
 232         fclose(f);
 233         return success;
 234 }