1 /* $OpenBSD: hostfile.c,v 1.48 2010/03/04 10:36:03 djm Exp $ */ 2 /* 3 * Author: Tatu Ylonen <ylo@cs.hut.fi> 4 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland 5 * All rights reserved 6 * Functions for manipulating the known hosts files. 7 * 8 * As far as I am concerned, the code I have written for this software 9 * can be used freely for any purpose. Any derived versions of this 10 * software must be clearly marked as such, and if the derived work is 11 * incompatible with the protocol description in the RFC file, it must be 12 * called by a name other than "ssh" or "Secure Shell". 13 * 14 * 15 * Copyright (c) 1999, 2000 Markus Friedl. All rights reserved. 16 * Copyright (c) 1999 Niels Provos. All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions 20 * are met: 21 * 1. Redistributions of source code must retain the above copyright 22 * notice, this list of conditions and the following disclaimer. 23 * 2. Redistributions in binary form must reproduce the above copyright 24 * notice, this list of conditions and the following disclaimer in the 25 * documentation and/or other materials provided with the distribution. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 28 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 29 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 30 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 31 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 32 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 33 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 34 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 35 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 36 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include "includes.h" 40 41 #include <sys/types.h> 42 43 #include <netinet/in.h> 44 45 #include <openssl/hmac.h> 46 #include <openssl/sha.h> 47 48 #include <resolv.h> 49 #include <stdarg.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <string.h> 53 54 #include "xmalloc.h" 55 #include "match.h" 56 #include "key.h" 57 #include "hostfile.h" 58 #include "log.h" 59 60 static int 61 extract_salt(const char *s, u_int l, char *salt, size_t salt_len) 62 { 63 char *p, *b64salt; 64 u_int b64len; 65 int ret; 66 67 if (l < sizeof(HASH_MAGIC) - 1) { 68 debug2("extract_salt: string too short"); 69 return (-1); 70 } 71 if (strncmp(s, HASH_MAGIC, sizeof(HASH_MAGIC) - 1) != 0) { 72 debug2("extract_salt: invalid magic identifier"); 73 return (-1); 74 } 75 s += sizeof(HASH_MAGIC) - 1; 76 l -= sizeof(HASH_MAGIC) - 1; 77 if ((p = memchr(s, HASH_DELIM, l)) == NULL) { 78 debug2("extract_salt: missing salt termination character"); 79 return (-1); 80 } 81 82 b64len = p - s; 83 /* Sanity check */ 84 if (b64len == 0 || b64len > 1024) { 85 debug2("extract_salt: bad encoded salt length %u", b64len); 86 return (-1); 87 } 88 b64salt = xmalloc(1 + b64len); 89 memcpy(b64salt, s, b64len); 90 b64salt[b64len] = '\0'; 91 92 ret = __b64_pton(b64salt, salt, salt_len); 93 xfree(b64salt); 94 if (ret == -1) { 95 debug2("extract_salt: salt decode error"); 96 return (-1); 97 } 98 if (ret != SHA_DIGEST_LENGTH) { 99 debug2("extract_salt: expected salt len %d, got %d", 100 SHA_DIGEST_LENGTH, ret); 101 return (-1); 102 } 103 104 return (0); 105 } 106 107 char * 108 host_hash(const char *host, const char *name_from_hostfile, u_int src_len) 109 { 110 const EVP_MD *md = EVP_sha1(); 111 HMAC_CTX mac_ctx; 112 char salt[256], result[256], uu_salt[512], uu_result[512]; 113 static char encoded[1024]; 114 u_int i, len; 115 116 len = EVP_MD_size(md); 117 118 if (name_from_hostfile == NULL) { 119 /* Create new salt */ 120 for (i = 0; i < len; i++) 121 salt[i] = arc4random(); 122 } else { 123 /* Extract salt from known host entry */ 124 if (extract_salt(name_from_hostfile, src_len, salt, 125 sizeof(salt)) == -1) 126 return (NULL); 127 } 128 129 HMAC_Init(&mac_ctx, salt, len, md); 130 HMAC_Update(&mac_ctx, host, strlen(host)); 131 HMAC_Final(&mac_ctx, result, NULL); 132 HMAC_cleanup(&mac_ctx); 133 134 if (__b64_ntop(salt, len, uu_salt, sizeof(uu_salt)) == -1 || 135 __b64_ntop(result, len, uu_result, sizeof(uu_result)) == -1) 136 fatal("host_hash: __b64_ntop failed"); 137 138 snprintf(encoded, sizeof(encoded), "%s%s%c%s", HASH_MAGIC, uu_salt, 139 HASH_DELIM, uu_result); 140 141 return (encoded); 142 } 143 144 /* 145 * Parses an RSA (number of bits, e, n) or DSA key from a string. Moves the 146 * pointer over the key. Skips any whitespace at the beginning and at end. 147 */ 148 149 int 150 hostfile_read_key(char **cpp, u_int *bitsp, Key *ret) 151 { 152 char *cp; 153 154 /* Skip leading whitespace. */ 155 for (cp = *cpp; *cp == ' ' || *cp == '\t'; cp++) 156 ; 157 158 if (key_read(ret, &cp) != 1) 159 return 0; 160 161 /* Skip trailing whitespace. */ 162 for (; *cp == ' ' || *cp == '\t'; cp++) 163 ; 164 165 /* Return results. */ 166 *cpp = cp; 167 *bitsp = key_size(ret); 168 return 1; 169 } 170 171 static int 172 hostfile_check_key(int bits, const Key *key, const char *host, const char *filename, int linenum) 173 { 174 if (key == NULL || key->type != KEY_RSA1 || key->rsa == NULL) 175 return 1; 176 if (bits != BN_num_bits(key->rsa->n)) { 177 logit("Warning: %s, line %d: keysize mismatch for host %s: " 178 "actual %d vs. announced %d.", 179 filename, linenum, host, BN_num_bits(key->rsa->n), bits); 180 logit("Warning: replace %d with %d in %s, line %d.", 181 bits, BN_num_bits(key->rsa->n), filename, linenum); 182 } 183 return 1; 184 } 185 186 static enum { MRK_ERROR, MRK_NONE, MRK_REVOKE, MRK_CA } 187 check_markers(char **cpp) 188 { 189 char marker[32], *sp, *cp = *cpp; 190 int ret = MRK_NONE; 191 192 while (*cp == '@') { 193 /* Only one marker is allowed */ 194 if (ret != MRK_NONE) 195 return MRK_ERROR; 196 /* Markers are terminated by whitespace */ 197 if ((sp = strchr(cp, ' ')) == NULL && 198 (sp = strchr(cp, '\t')) == NULL) 199 return MRK_ERROR; 200 /* Extract marker for comparison */ 201 if (sp <= cp + 1 || sp >= cp + sizeof(marker)) 202 return MRK_ERROR; 203 memcpy(marker, cp, sp - cp); 204 marker[sp - cp] = '\0'; 205 if (strcmp(marker, CA_MARKER) == 0) 206 ret = MRK_CA; 207 else if (strcmp(marker, REVOKE_MARKER) == 0) 208 ret = MRK_REVOKE; 209 else 210 return MRK_ERROR; 211 212 /* Skip past marker and any whitespace that follows it */ 213 cp = sp; 214 for (; *cp == ' ' || *cp == '\t'; cp++) 215 ; 216 } 217 *cpp = cp; 218 return ret; 219 } 220 221 /* 222 * Checks whether the given host (which must be in all lowercase) is already 223 * in the list of our known hosts. Returns HOST_OK if the host is known and 224 * has the specified key, HOST_NEW if the host is not known, and HOST_CHANGED 225 * if the host is known but used to have a different host key. 226 * 227 * If no 'key' has been specified and a key of type 'keytype' is known 228 * for the specified host, then HOST_FOUND is returned. 229 */ 230 231 static HostStatus 232 check_host_in_hostfile_by_key_or_type(const char *filename, 233 const char *host, const Key *key, int keytype, Key *found, 234 int want_revocation, int *numret) 235 { 236 FILE *f; 237 char line[8192]; 238 int want, have, linenum = 0, want_cert = key_is_cert(key); 239 u_int kbits; 240 char *cp, *cp2, *hashed_host; 241 HostStatus end_return; 242 243 debug3("check_host_in_hostfile: host %s filename %s", host, filename); 244 245 if (want_revocation && (key == NULL || keytype != 0 || found != NULL)) 246 fatal("%s: invalid arguments", __func__); 247 248 /* Open the file containing the list of known hosts. */ 249 f = fopen(filename, "r"); 250 if (!f) 251 return HOST_NEW; 252 253 /* 254 * Return value when the loop terminates. This is set to 255 * HOST_CHANGED if we have seen a different key for the host and have 256 * not found the proper one. 257 */ 258 end_return = HOST_NEW; 259 260 /* Go through the file. */ 261 while (fgets(line, sizeof(line), f)) { 262 cp = line; 263 linenum++; 264 265 /* Skip any leading whitespace, comments and empty lines. */ 266 for (; *cp == ' ' || *cp == '\t'; cp++) 267 ; 268 if (!*cp || *cp == '#' || *cp == '\n') 269 continue; 270 271 if (want_revocation) 272 want = MRK_REVOKE; 273 else if (want_cert) 274 want = MRK_CA; 275 else 276 want = MRK_NONE; 277 278 if ((have = check_markers(&cp)) == MRK_ERROR) { 279 verbose("%s: invalid marker at %s:%d", 280 __func__, filename, linenum); 281 continue; 282 } else if (want != have) 283 continue; 284 285 /* Find the end of the host name portion. */ 286 for (cp2 = cp; *cp2 && *cp2 != ' ' && *cp2 != '\t'; cp2++) 287 ; 288 289 /* Check if the host name matches. */ 290 if (match_hostname(host, cp, (u_int) (cp2 - cp)) != 1) { 291 if (*cp != HASH_DELIM) 292 continue; 293 hashed_host = host_hash(host, cp, (u_int) (cp2 - cp)); 294 if (hashed_host == NULL) { 295 debug("Invalid hashed host line %d of %s", 296 linenum, filename); 297 continue; 298 } 299 if (strncmp(hashed_host, cp, (u_int) (cp2 - cp)) != 0) 300 continue; 301 } 302 303 /* Got a match. Skip host name. */ 304 cp = cp2; 305 306 if (want_revocation) 307 found = key_new(KEY_UNSPEC); 308 309 /* 310 * Extract the key from the line. This will skip any leading 311 * whitespace. Ignore badly formatted lines. 312 */ 313 if (!hostfile_read_key(&cp, &kbits, found)) 314 continue; 315 316 if (numret != NULL) 317 *numret = linenum; 318 319 if (key == NULL) { 320 /* we found a key of the requested type */ 321 if (found->type == keytype) { 322 fclose(f); 323 return HOST_FOUND; 324 } 325 continue; 326 } 327 328 if (!hostfile_check_key(kbits, found, host, filename, linenum)) 329 continue; 330 331 if (want_revocation) { 332 if (key_is_cert(key) && 333 key_equal_public(key->cert->signature_key, found)) { 334 verbose("check_host_in_hostfile: revoked CA " 335 "line %d", linenum); 336 key_free(found); 337 return HOST_REVOKED; 338 } 339 if (key_equal_public(key, found)) { 340 verbose("check_host_in_hostfile: revoked key " 341 "line %d", linenum); 342 key_free(found); 343 return HOST_REVOKED; 344 } 345 key_free(found); 346 continue; 347 } 348 349 /* Check if the current key is the same as the given key. */ 350 if (want_cert && key_equal(key->cert->signature_key, found)) { 351 /* Found CA cert for key */ 352 debug3("check_host_in_hostfile: CA match line %d", 353 linenum); 354 fclose(f); 355 return HOST_OK; 356 } else if (!want_cert && key_equal(key, found)) { 357 /* Found identical key */ 358 debug3("check_host_in_hostfile: match line %d", linenum); 359 fclose(f); 360 return HOST_OK; 361 } 362 /* 363 * They do not match. We will continue to go through the 364 * file; however, we note that we will not return that it is 365 * new. 366 */ 367 end_return = HOST_CHANGED; 368 } 369 /* Clear variables and close the file. */ 370 fclose(f); 371 372 /* 373 * Return either HOST_NEW or HOST_CHANGED, depending on whether we 374 * saw a different key for the host. 375 */ 376 return end_return; 377 } 378 379 HostStatus 380 check_host_in_hostfile(const char *filename, const char *host, const Key *key, 381 Key *found, int *numret) 382 { 383 if (key == NULL) 384 fatal("no key to look up"); 385 if (check_host_in_hostfile_by_key_or_type(filename, host, 386 key, 0, NULL, 1, NULL) == HOST_REVOKED) 387 return HOST_REVOKED; 388 return check_host_in_hostfile_by_key_or_type(filename, host, key, 0, 389 found, 0, numret); 390 } 391 392 int 393 lookup_key_in_hostfile_by_type(const char *filename, const char *host, 394 int keytype, Key *found, int *numret) 395 { 396 return (check_host_in_hostfile_by_key_or_type(filename, host, NULL, 397 keytype, found, 0, numret) == HOST_FOUND); 398 } 399 400 /* 401 * Appends an entry to the host file. Returns false if the entry could not 402 * be appended. 403 */ 404 405 int 406 add_host_to_hostfile(const char *filename, const char *host, const Key *key, 407 int store_hash) 408 { 409 FILE *f; 410 int success = 0; 411 char *hashed_host = NULL; 412 413 if (key == NULL) 414 return 1; /* XXX ? */ 415 f = fopen(filename, "a"); 416 if (!f) 417 return 0; 418 419 if (store_hash) { 420 if ((hashed_host = host_hash(host, NULL, 0)) == NULL) { 421 error("add_host_to_hostfile: host_hash failed"); 422 fclose(f); 423 return 0; 424 } 425 } 426 fprintf(f, "%s ", store_hash ? hashed_host : host); 427 428 if (key_write(key, f)) { 429 success = 1; 430 } else { 431 error("add_host_to_hostfile: saving key in %s failed", filename); 432 } 433 fprintf(f, "\n"); 434 fclose(f); 435 return success; 436 } 437