blob: e4f9bf8307e7b3d8d1d91d6ab1398f371ec93fcc [file] [log] [blame]
markus@openbsd.org1b11ea72018-02-23 15:58:37 +00001/* $OpenBSD: dns.c,v 1.38 2018/02/23 15:58:37 markus Exp $ */
Damien Miller37876e92003-05-15 10:19:46 +10002
3/*
4 * Copyright (c) 2003 Wesley Griffin. All rights reserved.
5 * Copyright (c) 2003 Jakob Schlyter. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
Damien Miller37876e92003-05-15 10:19:46 +100028#include "includes.h"
29
Damien Millere3b60b52006-07-10 21:08:03 +100030#include <sys/types.h>
31#include <sys/socket.h>
32
Damien Millerb8fe89c2006-07-24 14:51:00 +100033#include <netdb.h>
Damien Millerded319c2006-09-01 15:38:36 +100034#include <stdarg.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100035#include <stdio.h>
Damien Millere3476ed2006-07-24 14:13:33 +100036#include <string.h>
Damien Miller86687062014-07-02 15:28:02 +100037#include <stdlib.h>
Damien Miller37876e92003-05-15 10:19:46 +100038
39#include "xmalloc.h"
djm@openbsd.org1129dcf2015-01-15 09:40:00 +000040#include "sshkey.h"
41#include "ssherr.h"
Damien Miller37876e92003-05-15 10:19:46 +100042#include "dns.h"
43#include "log.h"
djm@openbsd.org56d1c832014-12-21 22:27:55 +000044#include "digest.h"
Damien Miller37876e92003-05-15 10:19:46 +100045
Damien Miller37876e92003-05-15 10:19:46 +100046static const char *errset_text[] = {
47 "success", /* 0 ERRSET_SUCCESS */
48 "out of memory", /* 1 ERRSET_NOMEMORY */
49 "general failure", /* 2 ERRSET_FAIL */
50 "invalid parameter", /* 3 ERRSET_INVAL */
51 "name does not exist", /* 4 ERRSET_NONAME */
52 "data does not exist", /* 5 ERRSET_NODATA */
53};
54
55static const char *
Darren Tucker3f9fdc72004-06-22 12:56:01 +100056dns_result_totext(unsigned int res)
Damien Miller37876e92003-05-15 10:19:46 +100057{
Darren Tucker3f9fdc72004-06-22 12:56:01 +100058 switch (res) {
Damien Miller37876e92003-05-15 10:19:46 +100059 case ERRSET_SUCCESS:
60 return errset_text[ERRSET_SUCCESS];
61 case ERRSET_NOMEMORY:
62 return errset_text[ERRSET_NOMEMORY];
63 case ERRSET_FAIL:
64 return errset_text[ERRSET_FAIL];
65 case ERRSET_INVAL:
66 return errset_text[ERRSET_INVAL];
67 case ERRSET_NONAME:
68 return errset_text[ERRSET_NONAME];
69 case ERRSET_NODATA:
70 return errset_text[ERRSET_NODATA];
71 default:
72 return "unknown error";
73 }
74}
Damien Miller37876e92003-05-15 10:19:46 +100075
76/*
77 * Read SSHFP parameters from key buffer.
78 */
79static int
80dns_read_key(u_int8_t *algorithm, u_int8_t *digest_type,
djm@openbsd.org1129dcf2015-01-15 09:40:00 +000081 u_char **digest, size_t *digest_len, struct sshkey *key)
Damien Miller37876e92003-05-15 10:19:46 +100082{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +000083 int r, success = 0;
djm@openbsd.org56d1c832014-12-21 22:27:55 +000084 int fp_alg = -1;
Damien Miller37876e92003-05-15 10:19:46 +100085
86 switch (key->type) {
87 case KEY_RSA:
88 *algorithm = SSHFP_KEY_RSA;
Damien Miller3bde12a2012-06-20 21:51:11 +100089 if (!*digest_type)
90 *digest_type = SSHFP_HASH_SHA1;
Damien Miller37876e92003-05-15 10:19:46 +100091 break;
92 case KEY_DSA:
93 *algorithm = SSHFP_KEY_DSA;
Damien Miller3bde12a2012-06-20 21:51:11 +100094 if (!*digest_type)
95 *digest_type = SSHFP_HASH_SHA1;
Damien Miller37876e92003-05-15 10:19:46 +100096 break;
Damien Miller3bde12a2012-06-20 21:51:11 +100097 case KEY_ECDSA:
98 *algorithm = SSHFP_KEY_ECDSA;
99 if (!*digest_type)
100 *digest_type = SSHFP_HASH_SHA256;
101 break;
Damien Miller16cd3922014-05-15 13:45:58 +1000102 case KEY_ED25519:
103 *algorithm = SSHFP_KEY_ED25519;
104 if (!*digest_type)
105 *digest_type = SSHFP_HASH_SHA256;
106 break;
markus@openbsd.org1b11ea72018-02-23 15:58:37 +0000107 case KEY_XMSS:
108 *algorithm = SSHFP_KEY_XMSS;
109 if (!*digest_type)
110 *digest_type = SSHFP_HASH_SHA256;
111 break;
Damien Miller37876e92003-05-15 10:19:46 +1000112 default:
Damien Miller65712492005-11-05 15:09:27 +1100113 *algorithm = SSHFP_KEY_RESERVED; /* 0 */
Damien Miller3bde12a2012-06-20 21:51:11 +1000114 *digest_type = SSHFP_HASH_RESERVED; /* 0 */
Damien Miller37876e92003-05-15 10:19:46 +1000115 }
116
Damien Miller3bde12a2012-06-20 21:51:11 +1000117 switch (*digest_type) {
118 case SSHFP_HASH_SHA1:
djm@openbsd.org56d1c832014-12-21 22:27:55 +0000119 fp_alg = SSH_DIGEST_SHA1;
Damien Miller3bde12a2012-06-20 21:51:11 +1000120 break;
121 case SSHFP_HASH_SHA256:
djm@openbsd.org56d1c832014-12-21 22:27:55 +0000122 fp_alg = SSH_DIGEST_SHA256;
Damien Miller3bde12a2012-06-20 21:51:11 +1000123 break;
124 default:
125 *digest_type = SSHFP_HASH_RESERVED; /* 0 */
126 }
127
128 if (*algorithm && *digest_type) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000129 if ((r = sshkey_fingerprint_raw(key, fp_alg, digest,
130 digest_len)) != 0)
131 fatal("%s: sshkey_fingerprint_raw: %s", __func__,
132 ssh_err(r));
Damien Miller37876e92003-05-15 10:19:46 +1000133 success = 1;
134 } else {
Damien Miller37876e92003-05-15 10:19:46 +1000135 *digest = NULL;
136 *digest_len = 0;
137 success = 0;
138 }
139
140 return success;
141}
142
143/*
144 * Read SSHFP parameters from rdata buffer.
145 */
146static int
147dns_read_rdata(u_int8_t *algorithm, u_int8_t *digest_type,
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000148 u_char **digest, size_t *digest_len, u_char *rdata, int rdata_len)
Damien Miller37876e92003-05-15 10:19:46 +1000149{
150 int success = 0;
151
152 *algorithm = SSHFP_KEY_RESERVED;
153 *digest_type = SSHFP_HASH_RESERVED;
154
155 if (rdata_len >= 2) {
156 *algorithm = rdata[0];
157 *digest_type = rdata[1];
158 *digest_len = rdata_len - 2;
159
160 if (*digest_len > 0) {
deraadt@openbsd.orgce445b02015-08-20 22:32:42 +0000161 *digest = xmalloc(*digest_len);
Damien Miller37876e92003-05-15 10:19:46 +1000162 memcpy(*digest, rdata + 2, *digest_len);
163 } else {
Damien Miller59962942006-03-26 00:06:48 +1100164 *digest = (u_char *)xstrdup("");
Damien Miller37876e92003-05-15 10:19:46 +1000165 }
166
167 success = 1;
168 }
169
170 return success;
171}
172
Damien Millera31c9292005-05-26 12:03:31 +1000173/*
174 * Check if hostname is numerical.
175 * Returns -1 if hostname is numeric, 0 otherwise
176 */
177static int
178is_numeric_hostname(const char *hostname)
179{
180 struct addrinfo hints, *ai;
181
Darren Tucker30ac73b2008-06-13 04:46:45 +1000182 /*
183 * We shouldn't ever get a null host but if we do then log an error
184 * and return -1 which stops DNS key fingerprint processing.
185 */
186 if (hostname == NULL) {
187 error("is_numeric_hostname called with NULL hostname");
188 return -1;
189 }
190
Damien Millera31c9292005-05-26 12:03:31 +1000191 memset(&hints, 0, sizeof(hints));
192 hints.ai_socktype = SOCK_DGRAM;
193 hints.ai_flags = AI_NUMERICHOST;
194
Darren Tucker30ac73b2008-06-13 04:46:45 +1000195 if (getaddrinfo(hostname, NULL, &hints, &ai) == 0) {
Damien Millera31c9292005-05-26 12:03:31 +1000196 freeaddrinfo(ai);
197 return -1;
198 }
199
200 return 0;
201}
Damien Miller37876e92003-05-15 10:19:46 +1000202
203/*
204 * Verify the given hostname, address and host key using DNS.
Damien Millera8e06ce2003-11-21 23:48:55 +1100205 * Returns 0 if lookup succeeds, -1 otherwise
Damien Miller37876e92003-05-15 10:19:46 +1000206 */
207int
208verify_host_key_dns(const char *hostname, struct sockaddr *address,
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000209 struct sshkey *hostkey, int *flags)
Damien Miller37876e92003-05-15 10:19:46 +1000210{
Damien Millereccb9de2005-06-17 12:59:34 +1000211 u_int counter;
Damien Miller37876e92003-05-15 10:19:46 +1000212 int result;
213 struct rrsetinfo *fingerprints = NULL;
Damien Miller37876e92003-05-15 10:19:46 +1000214
215 u_int8_t hostkey_algorithm;
Damien Miller3bde12a2012-06-20 21:51:11 +1000216 u_int8_t hostkey_digest_type = SSHFP_HASH_RESERVED;
Damien Miller37876e92003-05-15 10:19:46 +1000217 u_char *hostkey_digest;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000218 size_t hostkey_digest_len;
Damien Miller37876e92003-05-15 10:19:46 +1000219
220 u_int8_t dnskey_algorithm;
221 u_int8_t dnskey_digest_type;
222 u_char *dnskey_digest;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000223 size_t dnskey_digest_len;
Damien Miller37876e92003-05-15 10:19:46 +1000224
Damien Miller150b5572003-11-17 21:19:29 +1100225 *flags = 0;
Damien Miller37876e92003-05-15 10:19:46 +1000226
Damien Miller319550a2005-11-05 15:11:15 +1100227 debug3("verify_host_key_dns");
Damien Miller37876e92003-05-15 10:19:46 +1000228 if (hostkey == NULL)
229 fatal("No key to look up!");
230
Damien Millera31c9292005-05-26 12:03:31 +1000231 if (is_numeric_hostname(hostname)) {
232 debug("skipped DNS lookup for numerical hostname");
233 return -1;
234 }
235
Damien Miller37876e92003-05-15 10:19:46 +1000236 result = getrrsetbyname(hostname, DNS_RDATACLASS_IN,
237 DNS_RDATATYPE_SSHFP, 0, &fingerprints);
238 if (result) {
239 verbose("DNS lookup error: %s", dns_result_totext(result));
Damien Miller150b5572003-11-17 21:19:29 +1100240 return -1;
Damien Miller37876e92003-05-15 10:19:46 +1000241 }
242
Damien Miller150b5572003-11-17 21:19:29 +1100243 if (fingerprints->rri_flags & RRSET_VALIDATED) {
244 *flags |= DNS_VERIFY_SECURE;
245 debug("found %d secure fingerprints in DNS",
246 fingerprints->rri_nrdatas);
247 } else {
248 debug("found %d insecure fingerprints in DNS",
249 fingerprints->rri_nrdatas);
Damien Miller37876e92003-05-15 10:19:46 +1000250 }
Damien Miller37876e92003-05-15 10:19:46 +1000251
Damien Miller3bde12a2012-06-20 21:51:11 +1000252 /* Initialize default host key parameters */
Damien Miller37876e92003-05-15 10:19:46 +1000253 if (!dns_read_key(&hostkey_algorithm, &hostkey_digest_type,
254 &hostkey_digest, &hostkey_digest_len, hostkey)) {
255 error("Error calculating host key fingerprint.");
Damien Millerb0622652003-05-15 13:27:28 +1000256 freerrset(fingerprints);
Damien Miller150b5572003-11-17 21:19:29 +1100257 return -1;
Damien Miller37876e92003-05-15 10:19:46 +1000258 }
259
Damien Miller150b5572003-11-17 21:19:29 +1100260 if (fingerprints->rri_nrdatas)
261 *flags |= DNS_VERIFY_FOUND;
262
Damien Miller80163902007-01-05 16:30:16 +1100263 for (counter = 0; counter < fingerprints->rri_nrdatas; counter++) {
Damien Miller37876e92003-05-15 10:19:46 +1000264 /*
265 * Extract the key from the answer. Ignore any badly
266 * formatted fingerprints.
267 */
268 if (!dns_read_rdata(&dnskey_algorithm, &dnskey_digest_type,
269 &dnskey_digest, &dnskey_digest_len,
270 fingerprints->rri_rdatas[counter].rdi_data,
271 fingerprints->rri_rdatas[counter].rdi_length)) {
272 verbose("Error parsing fingerprint from DNS.");
273 continue;
274 }
275
Damien Miller3bde12a2012-06-20 21:51:11 +1000276 if (hostkey_digest_type != dnskey_digest_type) {
277 hostkey_digest_type = dnskey_digest_type;
Darren Tuckera627d422013-06-02 07:31:17 +1000278 free(hostkey_digest);
Damien Miller3bde12a2012-06-20 21:51:11 +1000279
280 /* Initialize host key parameters */
281 if (!dns_read_key(&hostkey_algorithm,
282 &hostkey_digest_type, &hostkey_digest,
283 &hostkey_digest_len, hostkey)) {
284 error("Error calculating key fingerprint.");
285 freerrset(fingerprints);
286 return -1;
287 }
288 }
289
Damien Miller37876e92003-05-15 10:19:46 +1000290 /* Check if the current key is the same as the given key */
291 if (hostkey_algorithm == dnskey_algorithm &&
292 hostkey_digest_type == dnskey_digest_type) {
Damien Miller37876e92003-05-15 10:19:46 +1000293 if (hostkey_digest_len == dnskey_digest_len &&
Damien Miller3bde12a2012-06-20 21:51:11 +1000294 timingsafe_bcmp(hostkey_digest, dnskey_digest,
295 hostkey_digest_len) == 0)
Damien Miller150b5572003-11-17 21:19:29 +1100296 *flags |= DNS_VERIFY_MATCH;
Damien Miller37876e92003-05-15 10:19:46 +1000297 }
Darren Tuckera627d422013-06-02 07:31:17 +1000298 free(dnskey_digest);
Damien Miller37876e92003-05-15 10:19:46 +1000299 }
300
djm@openbsd.orgb8286052017-09-01 05:53:56 +0000301 free(hostkey_digest); /* from sshkey_fingerprint_raw() */
302 freerrset(fingerprints);
303
djm@openbsd.orgaea59a02017-09-14 04:32:21 +0000304 if (*flags & DNS_VERIFY_FOUND)
305 if (*flags & DNS_VERIFY_MATCH)
306 debug("matching host key fingerprint found in DNS");
307 else
308 debug("mismatching host key fingerprint found in DNS");
309 else
310 debug("no host key fingerprint found in DNS");
311
Damien Miller150b5572003-11-17 21:19:29 +1100312 return 0;
Damien Miller37876e92003-05-15 10:19:46 +1000313}
314
Damien Miller37876e92003-05-15 10:19:46 +1000315/*
316 * Export the fingerprint of a key as a DNS resource record
317 */
318int
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000319export_dns_rr(const char *hostname, struct sshkey *key, FILE *f, int generic)
Damien Miller37876e92003-05-15 10:19:46 +1000320{
321 u_int8_t rdata_pubkey_algorithm = 0;
Damien Miller3bde12a2012-06-20 21:51:11 +1000322 u_int8_t rdata_digest_type = SSHFP_HASH_RESERVED;
323 u_int8_t dtype;
Damien Miller37876e92003-05-15 10:19:46 +1000324 u_char *rdata_digest;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000325 size_t i, rdata_digest_len;
Damien Miller37876e92003-05-15 10:19:46 +1000326 int success = 0;
327
Damien Miller3bde12a2012-06-20 21:51:11 +1000328 for (dtype = SSHFP_HASH_SHA1; dtype < SSHFP_HASH_MAX; dtype++) {
329 rdata_digest_type = dtype;
330 if (dns_read_key(&rdata_pubkey_algorithm, &rdata_digest_type,
331 &rdata_digest, &rdata_digest_len, key)) {
332 if (generic) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000333 fprintf(f, "%s IN TYPE%d \\# %zu %02x %02x ",
Damien Miller3bde12a2012-06-20 21:51:11 +1000334 hostname, DNS_RDATATYPE_SSHFP,
335 2 + rdata_digest_len,
336 rdata_pubkey_algorithm, rdata_digest_type);
337 } else {
338 fprintf(f, "%s IN SSHFP %d %d ", hostname,
339 rdata_pubkey_algorithm, rdata_digest_type);
340 }
341 for (i = 0; i < rdata_digest_len; i++)
342 fprintf(f, "%02x", rdata_digest[i]);
343 fprintf(f, "\n");
djm@openbsd.org9ce86c92015-01-28 22:36:00 +0000344 free(rdata_digest); /* from sshkey_fingerprint_raw() */
Damien Miller3bde12a2012-06-20 21:51:11 +1000345 success = 1;
346 }
347 }
Damien Miller37876e92003-05-15 10:19:46 +1000348
Damien Miller3bde12a2012-06-20 21:51:11 +1000349 /* No SSHFP record was generated at all */
350 if (success == 0) {
351 error("%s: unsupported algorithm and/or digest_type", __func__);
Damien Miller37876e92003-05-15 10:19:46 +1000352 }
353
354 return success;
355}