blob: ad5acb68e078011d941775395c31dc0f2f0ff42a [file] [log] [blame]
djm@openbsd.org6fdcaeb2014-10-20 03:43:01 +00001/* $OpenBSD: hostfile.c,v 1.58 2014/10/20 03:43:01 djm Exp $ */
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002/*
Damien Miller95def091999-11-25 00:26:21 +11003 * Author: Tatu Ylonen <ylo@cs.hut.fi>
Damien Miller95def091999-11-25 00:26:21 +11004 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11006 * Functions for manipulating the known hosts files.
Damien Miller4af51302000-04-16 11:18:38 +10007 *
Damien Millere4340be2000-09-16 13:29:08 +11008 * 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 *
Ben Lindstrom44697232001-07-04 03:32:30 +000015 * Copyright (c) 1999, 2000 Markus Friedl. All rights reserved.
Damien Millere4340be2000-09-16 13:29:08 +110016 * 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.
Damien Miller95def091999-11-25 00:26:21 +110037 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100038
39#include "includes.h"
Damien Millere1776152005-03-01 21:47:37 +110040
Damien Miller8ec8c3e2006-07-10 20:35:38 +100041#include <sys/types.h>
42
43#include <netinet/in.h>
44
Damien Millere7a1e5c2006-08-05 11:34:19 +100045#include <resolv.h>
Damien Millerded319c2006-09-01 15:38:36 +100046#include <stdarg.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100047#include <stdio.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100048#include <stdlib.h>
49#include <string.h>
Damien Miller86687062014-07-02 15:28:02 +100050#include <stdarg.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100051
Damien Millerd7834352006-08-05 12:39:39 +100052#include "xmalloc.h"
Damien Miller450a7a12000-03-26 13:04:51 +100053#include "match.h"
Damien Miller450a7a12000-03-26 13:04:51 +100054#include "key.h"
55#include "hostfile.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000056#include "log.h"
Damien Millerd925dcd2010-12-01 12:21:51 +110057#include "misc.h"
Damien Millerb3051d02014-01-10 10:58:53 +110058#include "digest.h"
Damien Miller4e8d9372014-02-04 11:02:42 +110059#include "hmac.h"
Damien Millerd925dcd2010-12-01 12:21:51 +110060
61struct hostkeys {
62 struct hostkey_entry *entries;
63 u_int num_entries;
64};
Damien Millere1776152005-03-01 21:47:37 +110065
66static int
Damien Millerce986542013-07-18 16:12:44 +100067extract_salt(const char *s, u_int l, u_char *salt, size_t salt_len)
Damien Millere1776152005-03-01 21:47:37 +110068{
69 char *p, *b64salt;
70 u_int b64len;
71 int ret;
72
73 if (l < sizeof(HASH_MAGIC) - 1) {
74 debug2("extract_salt: string too short");
75 return (-1);
76 }
77 if (strncmp(s, HASH_MAGIC, sizeof(HASH_MAGIC) - 1) != 0) {
78 debug2("extract_salt: invalid magic identifier");
79 return (-1);
80 }
81 s += sizeof(HASH_MAGIC) - 1;
82 l -= sizeof(HASH_MAGIC) - 1;
83 if ((p = memchr(s, HASH_DELIM, l)) == NULL) {
84 debug2("extract_salt: missing salt termination character");
85 return (-1);
86 }
87
88 b64len = p - s;
89 /* Sanity check */
90 if (b64len == 0 || b64len > 1024) {
91 debug2("extract_salt: bad encoded salt length %u", b64len);
92 return (-1);
93 }
94 b64salt = xmalloc(1 + b64len);
95 memcpy(b64salt, s, b64len);
96 b64salt[b64len] = '\0';
97
98 ret = __b64_pton(b64salt, salt, salt_len);
Darren Tuckera627d422013-06-02 07:31:17 +100099 free(b64salt);
Damien Millere1776152005-03-01 21:47:37 +1100100 if (ret == -1) {
101 debug2("extract_salt: salt decode error");
102 return (-1);
103 }
Damien Miller4e8d9372014-02-04 11:02:42 +1100104 if (ret != (int)ssh_hmac_bytes(SSH_DIGEST_SHA1)) {
105 debug2("extract_salt: expected salt len %zd, got %d",
106 ssh_hmac_bytes(SSH_DIGEST_SHA1), ret);
Damien Millere1776152005-03-01 21:47:37 +1100107 return (-1);
108 }
Darren Tucker47eede72005-03-14 23:08:12 +1100109
Damien Millere1776152005-03-01 21:47:37 +1100110 return (0);
111}
112
113char *
114host_hash(const char *host, const char *name_from_hostfile, u_int src_len)
115{
Damien Miller4e8d9372014-02-04 11:02:42 +1100116 struct ssh_hmac_ctx *ctx;
Damien Millerce986542013-07-18 16:12:44 +1000117 u_char salt[256], result[256];
118 char uu_salt[512], uu_result[512];
Damien Millere1776152005-03-01 21:47:37 +1100119 static char encoded[1024];
120 u_int i, len;
121
Damien Miller4e8d9372014-02-04 11:02:42 +1100122 len = ssh_digest_bytes(SSH_DIGEST_SHA1);
Damien Millere1776152005-03-01 21:47:37 +1100123
124 if (name_from_hostfile == NULL) {
125 /* Create new salt */
126 for (i = 0; i < len; i++)
127 salt[i] = arc4random();
128 } else {
129 /* Extract salt from known host entry */
130 if (extract_salt(name_from_hostfile, src_len, salt,
131 sizeof(salt)) == -1)
132 return (NULL);
133 }
134
Damien Miller4e8d9372014-02-04 11:02:42 +1100135 if ((ctx = ssh_hmac_start(SSH_DIGEST_SHA1)) == NULL ||
136 ssh_hmac_init(ctx, salt, len) < 0 ||
137 ssh_hmac_update(ctx, host, strlen(host)) < 0 ||
138 ssh_hmac_final(ctx, result, sizeof(result)))
139 fatal("%s: ssh_hmac failed", __func__);
140 ssh_hmac_free(ctx);
Damien Millere1776152005-03-01 21:47:37 +1100141
Darren Tucker47eede72005-03-14 23:08:12 +1100142 if (__b64_ntop(salt, len, uu_salt, sizeof(uu_salt)) == -1 ||
Damien Millere1776152005-03-01 21:47:37 +1100143 __b64_ntop(result, len, uu_result, sizeof(uu_result)) == -1)
Damien Miller4e8d9372014-02-04 11:02:42 +1100144 fatal("%s: __b64_ntop failed", __func__);
Damien Millere1776152005-03-01 21:47:37 +1100145
146 snprintf(encoded, sizeof(encoded), "%s%s%c%s", HASH_MAGIC, uu_salt,
147 HASH_DELIM, uu_result);
148
149 return (encoded);
150}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000151
Damien Miller5428f641999-11-25 11:54:57 +1100152/*
Damien Miller450a7a12000-03-26 13:04:51 +1000153 * Parses an RSA (number of bits, e, n) or DSA key from a string. Moves the
154 * pointer over the key. Skips any whitespace at the beginning and at end.
Damien Miller5428f641999-11-25 11:54:57 +1100155 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000156
Damien Miller5b2aea92001-12-21 12:47:09 +1100157int
Damien Millerce986542013-07-18 16:12:44 +1000158hostfile_read_key(char **cpp, int *bitsp, Key *ret)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000159{
Damien Miller95def091999-11-25 00:26:21 +1100160 char *cp;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000161
Damien Miller95def091999-11-25 00:26:21 +1100162 /* Skip leading whitespace. */
Damien Miller5428f641999-11-25 11:54:57 +1100163 for (cp = *cpp; *cp == ' ' || *cp == '\t'; cp++)
164 ;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000165
Damien Miller0bc1bd82000-11-13 22:57:25 +1100166 if (key_read(ret, &cp) != 1)
Damien Miller95def091999-11-25 00:26:21 +1100167 return 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000168
Damien Miller95def091999-11-25 00:26:21 +1100169 /* Skip trailing whitespace. */
Damien Miller5428f641999-11-25 11:54:57 +1100170 for (; *cp == ' ' || *cp == '\t'; cp++)
171 ;
Damien Miller95def091999-11-25 00:26:21 +1100172
173 /* Return results. */
174 *cpp = cp;
Damien Millerce986542013-07-18 16:12:44 +1000175 if (bitsp != NULL) {
176 if ((*bitsp = key_size(ret)) <= 0)
177 return 0;
178 }
Damien Miller95def091999-11-25 00:26:21 +1100179 return 1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000180}
181
Ben Lindstrombba81212001-06-25 05:01:22 +0000182static int
Damien Millerd925dcd2010-12-01 12:21:51 +1100183hostfile_check_key(int bits, const Key *key, const char *host,
184 const char *filename, u_long linenum)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000185{
Damien Miller1f0311c2014-05-15 14:24:09 +1000186#ifdef WITH_SSH1
Damien Miller0bc1bd82000-11-13 22:57:25 +1100187 if (key == NULL || key->type != KEY_RSA1 || key->rsa == NULL)
Damien Miller450a7a12000-03-26 13:04:51 +1000188 return 1;
189 if (bits != BN_num_bits(key->rsa->n)) {
Damien Millerd925dcd2010-12-01 12:21:51 +1100190 logit("Warning: %s, line %lu: keysize mismatch for host %s: "
Damien Miller450a7a12000-03-26 13:04:51 +1000191 "actual %d vs. announced %d.",
192 filename, linenum, host, BN_num_bits(key->rsa->n), bits);
Damien Millerd925dcd2010-12-01 12:21:51 +1100193 logit("Warning: replace %d with %d in %s, line %lu.",
Damien Miller450a7a12000-03-26 13:04:51 +1000194 bits, BN_num_bits(key->rsa->n), filename, linenum);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000195 }
Damien Miller1f0311c2014-05-15 14:24:09 +1000196#endif
Damien Miller450a7a12000-03-26 13:04:51 +1000197 return 1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000198}
199
Damien Millerd925dcd2010-12-01 12:21:51 +1100200static HostkeyMarker
Damien Miller1aed65e2010-03-04 21:53:35 +1100201check_markers(char **cpp)
202{
203 char marker[32], *sp, *cp = *cpp;
204 int ret = MRK_NONE;
205
206 while (*cp == '@') {
207 /* Only one marker is allowed */
208 if (ret != MRK_NONE)
209 return MRK_ERROR;
210 /* Markers are terminated by whitespace */
211 if ((sp = strchr(cp, ' ')) == NULL &&
212 (sp = strchr(cp, '\t')) == NULL)
213 return MRK_ERROR;
214 /* Extract marker for comparison */
215 if (sp <= cp + 1 || sp >= cp + sizeof(marker))
216 return MRK_ERROR;
217 memcpy(marker, cp, sp - cp);
218 marker[sp - cp] = '\0';
219 if (strcmp(marker, CA_MARKER) == 0)
220 ret = MRK_CA;
221 else if (strcmp(marker, REVOKE_MARKER) == 0)
222 ret = MRK_REVOKE;
223 else
224 return MRK_ERROR;
225
226 /* Skip past marker and any whitespace that follows it */
227 cp = sp;
228 for (; *cp == ' ' || *cp == '\t'; cp++)
229 ;
230 }
231 *cpp = cp;
232 return ret;
233}
234
Damien Millerd925dcd2010-12-01 12:21:51 +1100235struct hostkeys *
236init_hostkeys(void)
237{
238 struct hostkeys *ret = xcalloc(1, sizeof(*ret));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000239
Damien Millerd925dcd2010-12-01 12:21:51 +1100240 ret->entries = NULL;
241 return ret;
242}
243
244void
245load_hostkeys(struct hostkeys *hostkeys, const char *host, const char *path)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000246{
Damien Miller95def091999-11-25 00:26:21 +1100247 FILE *f;
248 char line[8192];
Damien Millerd925dcd2010-12-01 12:21:51 +1100249 u_long linenum = 0, num_loaded = 0;
Damien Millere1776152005-03-01 21:47:37 +1100250 char *cp, *cp2, *hashed_host;
Damien Millerd925dcd2010-12-01 12:21:51 +1100251 HostkeyMarker marker;
252 Key *key;
253 int kbits;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000254
Damien Millerd925dcd2010-12-01 12:21:51 +1100255 if ((f = fopen(path, "r")) == NULL)
256 return;
257 debug3("%s: loading entries for host \"%.100s\" from file \"%s\"",
258 __func__, host, path);
259 while (read_keyfile_line(f, path, line, sizeof(line), &linenum) == 0) {
Damien Miller95def091999-11-25 00:26:21 +1100260 cp = line;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000261
Damien Miller5428f641999-11-25 11:54:57 +1100262 /* Skip any leading whitespace, comments and empty lines. */
263 for (; *cp == ' ' || *cp == '\t'; cp++)
264 ;
Damien Miller95def091999-11-25 00:26:21 +1100265 if (!*cp || *cp == '#' || *cp == '\n')
266 continue;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000267
Damien Millerd925dcd2010-12-01 12:21:51 +1100268 if ((marker = check_markers(&cp)) == MRK_ERROR) {
269 verbose("%s: invalid marker at %s:%lu",
270 __func__, path, linenum);
Damien Miller1aed65e2010-03-04 21:53:35 +1100271 continue;
Damien Millerd925dcd2010-12-01 12:21:51 +1100272 }
Damien Miller0a80ca12010-02-27 07:55:05 +1100273
Damien Miller95def091999-11-25 00:26:21 +1100274 /* Find the end of the host name portion. */
Damien Miller5428f641999-11-25 11:54:57 +1100275 for (cp2 = cp; *cp2 && *cp2 != ' ' && *cp2 != '\t'; cp2++)
276 ;
Damien Miller7e8e8201999-11-16 13:37:16 +1100277
Damien Miller95def091999-11-25 00:26:21 +1100278 /* Check if the host name matches. */
Damien Millere1776152005-03-01 21:47:37 +1100279 if (match_hostname(host, cp, (u_int) (cp2 - cp)) != 1) {
280 if (*cp != HASH_DELIM)
281 continue;
282 hashed_host = host_hash(host, cp, (u_int) (cp2 - cp));
283 if (hashed_host == NULL) {
Damien Millerd925dcd2010-12-01 12:21:51 +1100284 debug("Invalid hashed host line %lu of %s",
285 linenum, path);
Damien Millere1776152005-03-01 21:47:37 +1100286 continue;
287 }
288 if (strncmp(hashed_host, cp, (u_int) (cp2 - cp)) != 0)
289 continue;
290 }
Damien Miller95def091999-11-25 00:26:21 +1100291
292 /* Got a match. Skip host name. */
293 cp = cp2;
294
Damien Miller5428f641999-11-25 11:54:57 +1100295 /*
296 * Extract the key from the line. This will skip any leading
297 * whitespace. Ignore badly formatted lines.
298 */
Damien Millerd925dcd2010-12-01 12:21:51 +1100299 key = key_new(KEY_UNSPEC);
300 if (!hostfile_read_key(&cp, &kbits, key)) {
301 key_free(key);
Damien Miller1f0311c2014-05-15 14:24:09 +1000302#ifdef WITH_SSH1
Damien Millerd925dcd2010-12-01 12:21:51 +1100303 key = key_new(KEY_RSA1);
304 if (!hostfile_read_key(&cp, &kbits, key)) {
305 key_free(key);
306 continue;
Damien Miller6db780e2006-03-26 13:52:20 +1100307 }
Damien Miller1f0311c2014-05-15 14:24:09 +1000308#else
309 continue;
310#endif
Ben Lindstrom3ed66402002-08-01 01:21:56 +0000311 }
Damien Millerd925dcd2010-12-01 12:21:51 +1100312 if (!hostfile_check_key(kbits, key, host, path, linenum))
Ben Lindstrom3ed66402002-08-01 01:21:56 +0000313 continue;
314
Damien Millerd925dcd2010-12-01 12:21:51 +1100315 debug3("%s: found %skey type %s in file %s:%lu", __func__,
316 marker == MRK_NONE ? "" :
317 (marker == MRK_CA ? "ca " : "revoked "),
318 key_type(key), path, linenum);
319 hostkeys->entries = xrealloc(hostkeys->entries,
320 hostkeys->num_entries + 1, sizeof(*hostkeys->entries));
321 hostkeys->entries[hostkeys->num_entries].host = xstrdup(host);
322 hostkeys->entries[hostkeys->num_entries].file = xstrdup(path);
323 hostkeys->entries[hostkeys->num_entries].line = linenum;
324 hostkeys->entries[hostkeys->num_entries].key = key;
325 hostkeys->entries[hostkeys->num_entries].marker = marker;
326 hostkeys->num_entries++;
327 num_loaded++;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000328 }
Damien Millerd925dcd2010-12-01 12:21:51 +1100329 debug3("%s: loaded %lu keys", __func__, num_loaded);
Darren Tucker094f1e92010-12-05 09:03:31 +1100330 fclose(f);
Damien Millerd925dcd2010-12-01 12:21:51 +1100331 return;
djm@openbsd.org6fdcaeb2014-10-20 03:43:01 +0000332}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000333
Damien Millerd925dcd2010-12-01 12:21:51 +1100334void
335free_hostkeys(struct hostkeys *hostkeys)
336{
337 u_int i;
338
339 for (i = 0; i < hostkeys->num_entries; i++) {
Darren Tuckera627d422013-06-02 07:31:17 +1000340 free(hostkeys->entries[i].host);
341 free(hostkeys->entries[i].file);
Damien Millerd925dcd2010-12-01 12:21:51 +1100342 key_free(hostkeys->entries[i].key);
Damien Miller1d2c4562014-02-04 11:18:20 +1100343 explicit_bzero(hostkeys->entries + i, sizeof(*hostkeys->entries));
Damien Millerd925dcd2010-12-01 12:21:51 +1100344 }
Darren Tuckera627d422013-06-02 07:31:17 +1000345 free(hostkeys->entries);
Damien Miller1d2c4562014-02-04 11:18:20 +1100346 explicit_bzero(hostkeys, sizeof(*hostkeys));
Darren Tuckera627d422013-06-02 07:31:17 +1000347 free(hostkeys);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000348}
349
Damien Millerd925dcd2010-12-01 12:21:51 +1100350static int
351check_key_not_revoked(struct hostkeys *hostkeys, Key *k)
352{
353 int is_cert = key_is_cert(k);
354 u_int i;
355
356 for (i = 0; i < hostkeys->num_entries; i++) {
357 if (hostkeys->entries[i].marker != MRK_REVOKE)
358 continue;
359 if (key_equal_public(k, hostkeys->entries[i].key))
360 return -1;
361 if (is_cert &&
362 key_equal_public(k->cert->signature_key,
363 hostkeys->entries[i].key))
364 return -1;
365 }
366 return 0;
367}
368
369/*
370 * Match keys against a specified key, or look one up by key type.
371 *
372 * If looking for a keytype (key == NULL) and one is found then return
373 * HOST_FOUND, otherwise HOST_NEW.
374 *
375 * If looking for a key (key != NULL):
376 * 1. If the key is a cert and a matching CA is found, return HOST_OK
377 * 2. If the key is not a cert and a matching key is found, return HOST_OK
378 * 3. If no key matches but a key with a different type is found, then
379 * return HOST_CHANGED
380 * 4. If no matching keys are found, then return HOST_NEW.
381 *
382 * Finally, check any found key is not revoked.
383 */
384static HostStatus
385check_hostkeys_by_key_or_type(struct hostkeys *hostkeys,
386 Key *k, int keytype, const struct hostkey_entry **found)
387{
388 u_int i;
389 HostStatus end_return = HOST_NEW;
390 int want_cert = key_is_cert(k);
391 HostkeyMarker want_marker = want_cert ? MRK_CA : MRK_NONE;
392 int proto = (k ? k->type : keytype) == KEY_RSA1 ? 1 : 2;
393
394 if (found != NULL)
395 *found = NULL;
396
397 for (i = 0; i < hostkeys->num_entries; i++) {
398 if (proto == 1 && hostkeys->entries[i].key->type != KEY_RSA1)
399 continue;
400 if (proto == 2 && hostkeys->entries[i].key->type == KEY_RSA1)
401 continue;
402 if (hostkeys->entries[i].marker != want_marker)
403 continue;
404 if (k == NULL) {
405 if (hostkeys->entries[i].key->type != keytype)
406 continue;
407 end_return = HOST_FOUND;
408 if (found != NULL)
409 *found = hostkeys->entries + i;
410 k = hostkeys->entries[i].key;
411 break;
412 }
413 if (want_cert) {
414 if (key_equal_public(k->cert->signature_key,
415 hostkeys->entries[i].key)) {
416 /* A matching CA exists */
417 end_return = HOST_OK;
418 if (found != NULL)
419 *found = hostkeys->entries + i;
420 break;
421 }
422 } else {
423 if (key_equal(k, hostkeys->entries[i].key)) {
424 end_return = HOST_OK;
425 if (found != NULL)
426 *found = hostkeys->entries + i;
427 break;
428 }
429 /* A non-maching key exists */
430 end_return = HOST_CHANGED;
431 if (found != NULL)
432 *found = hostkeys->entries + i;
433 }
434 }
435 if (check_key_not_revoked(hostkeys, k) != 0) {
436 end_return = HOST_REVOKED;
437 if (found != NULL)
438 *found = NULL;
439 }
440 return end_return;
441}
djm@openbsd.org6fdcaeb2014-10-20 03:43:01 +0000442
Ben Lindstrom3ed66402002-08-01 01:21:56 +0000443HostStatus
Damien Millerd925dcd2010-12-01 12:21:51 +1100444check_key_in_hostkeys(struct hostkeys *hostkeys, Key *key,
445 const struct hostkey_entry **found)
Ben Lindstrom3ed66402002-08-01 01:21:56 +0000446{
447 if (key == NULL)
448 fatal("no key to look up");
Damien Millerd925dcd2010-12-01 12:21:51 +1100449 return check_hostkeys_by_key_or_type(hostkeys, key, 0, found);
Ben Lindstrom3ed66402002-08-01 01:21:56 +0000450}
451
452int
Damien Millerd925dcd2010-12-01 12:21:51 +1100453lookup_key_in_hostkeys_by_type(struct hostkeys *hostkeys, int keytype,
454 const struct hostkey_entry **found)
Ben Lindstrom3ed66402002-08-01 01:21:56 +0000455{
Damien Millerd925dcd2010-12-01 12:21:51 +1100456 return (check_hostkeys_by_key_or_type(hostkeys, NULL, keytype,
457 found) == HOST_FOUND);
Ben Lindstrom3ed66402002-08-01 01:21:56 +0000458}
459
Damien Miller5428f641999-11-25 11:54:57 +1100460/*
461 * Appends an entry to the host file. Returns false if the entry could not
462 * be appended.
463 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000464
465int
Darren Tucker47eede72005-03-14 23:08:12 +1100466add_host_to_hostfile(const char *filename, const char *host, const Key *key,
Damien Millere1776152005-03-01 21:47:37 +1100467 int store_hash)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000468{
Damien Miller95def091999-11-25 00:26:21 +1100469 FILE *f;
Damien Miller450a7a12000-03-26 13:04:51 +1000470 int success = 0;
Darren Tucker40858532005-08-02 17:07:07 +1000471 char *hashed_host = NULL;
Damien Millere1776152005-03-01 21:47:37 +1100472
Damien Miller450a7a12000-03-26 13:04:51 +1000473 if (key == NULL)
Damien Millereba71ba2000-04-29 23:57:08 +1000474 return 1; /* XXX ? */
Damien Miller95def091999-11-25 00:26:21 +1100475 f = fopen(filename, "a");
476 if (!f)
477 return 0;
Damien Millere1776152005-03-01 21:47:37 +1100478
479 if (store_hash) {
480 if ((hashed_host = host_hash(host, NULL, 0)) == NULL) {
481 error("add_host_to_hostfile: host_hash failed");
482 fclose(f);
483 return 0;
484 }
485 }
486 fprintf(f, "%s ", store_hash ? hashed_host : host);
487
Damien Miller450a7a12000-03-26 13:04:51 +1000488 if (key_write(key, f)) {
Damien Miller450a7a12000-03-26 13:04:51 +1000489 success = 1;
490 } else {
Damien Millereba71ba2000-04-29 23:57:08 +1000491 error("add_host_to_hostfile: saving key in %s failed", filename);
Damien Miller95def091999-11-25 00:26:21 +1100492 }
Damien Millereba71ba2000-04-29 23:57:08 +1000493 fprintf(f, "\n");
Damien Miller95def091999-11-25 00:26:21 +1100494 fclose(f);
Damien Miller450a7a12000-03-26 13:04:51 +1000495 return success;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000496}