hostfile.c revision 204917 
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
60static int
61extract_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
107char *
108host_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
149int
150hostfile_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
171static int
172hostfile_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
186static enum { MRK_ERROR, MRK_NONE, MRK_REVOKE, MRK_CA }
187check_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
231static HostStatus
232check_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
379HostStatus
380check_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
392int
393lookup_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
405int
406add_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