« back to all changes in this revision
Viewing changes to src/dnssec.c
- browse files at revision 36
- compare with another revision
- download diff
- download tarball
- view history from revision 36
- Committer: Package Import Robot
- Author(s): Simon Kelley
- Date: 2014-04-23 15:14:42 UTC
- mfrom: (0.5.8) (12.2.17 sid)
- Revision ID: package-import@ubuntu.com-20140423151442-22uqxwgu9wi56gd7
Tags: 2.70-1
New upstream.
- files added:
- contrib/try-all-ns/dnsmasq-2.68-try-all-ns
- files modified:
- CHANGELOG
added
removed
src/dnssec.c
1
/* dnssec.c is Copyright (c) 2012 Giovanni Bajo <rasky@develer.com>
2
and Copyright (c) 2012-2014 Simon Kelley
3
4
This program is free software; you can redistribute it and/or modify
5
it under the terms of the GNU General Public License as published by
6
the Free Software Foundation; version 2 dated June, 1991, or
7
(at your option) version 3 dated 29 June, 2007.
8
9
This program is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
GNU General Public License for more details.
13
14
You should have received a copy of the GNU General Public License
15
along with this program. If not, see <http://www.gnu.org/licenses/>.
16
*/
17
18
#include "dnsmasq.h"
19
20
#ifdef HAVE_DNSSEC
21
22
#include <nettle/rsa.h>
23
#include <nettle/dsa.h>
24
#ifndef NO_NETTLE_ECC
25
# include <nettle/ecdsa.h>
26
# include <nettle/ecc-curve.h>
27
#endif
28
#include <nettle/nettle-meta.h>
29
#include <gmp.h>
30
31
#define SERIAL_UNDEF -100
32
#define SERIAL_EQ 0
33
#define SERIAL_LT -1
34
#define SERIAL_GT 1
35
36
/* http://www.iana.org/assignments/ds-rr-types/ds-rr-types.xhtml */
37
static char *ds_digest_name(int digest)
38
{
39
switch (digest)
40
{
41
case 1: return "sha1";
42
case 2: return "sha256";
43
case 3: return "gosthash94";
44
case 4: return "sha384";
45
default: return NULL;
46
}
47
}
48
49
/* http://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml */
50
static char *algo_digest_name(int algo)
51
{
52
switch (algo)
53
{
54
case 1: return "md5";
55
case 3: return "sha1";
56
case 5: return "sha1";
57
case 6: return "sha1";
58
case 7: return "sha1";
59
case 8: return "sha256";
60
case 10: return "sha512";
61
case 12: return "gosthash94";
62
case 13: return "sha256";
63
case 14: return "sha384";
64
default: return NULL;
65
}
66
}
67
68
/* Find pointer to correct hash function in nettle library */
69
static const struct nettle_hash *hash_find(char *name)
70
{
71
int i;
72
73
if (!name)
74
return NULL;
75
76
for (i = 0; nettle_hashes[i]; i++)
77
{
78
if (strcmp(nettle_hashes[i]->name, name) == 0)
79
return nettle_hashes[i];
80
}
81
82
return NULL;
83
}
84
85
/* expand ctx and digest memory allocations if necessary and init hash function */
86
static int hash_init(const struct nettle_hash *hash, void **ctxp, unsigned char **digestp)
87
{
88
static void *ctx = NULL;
89
static unsigned char *digest = NULL;
90
static unsigned int ctx_sz = 0;
91
static unsigned int digest_sz = 0;
92
93
void *new;
94
95
if (ctx_sz < hash->context_size)
96
{
97
if (!(new = whine_malloc(hash->context_size)))
98
return 0;
99
if (ctx)
100
free(ctx);
101
ctx = new;
102
ctx_sz = hash->context_size;
103
}
104
105
if (digest_sz < hash->digest_size)
106
{
107
if (!(new = whine_malloc(hash->digest_size)))
108
return 0;
109
if (digest)
110
free(digest);
111
digest = new;
112
digest_sz = hash->digest_size;
113
}
114
115
*ctxp = ctx;
116
*digestp = digest;
117
118
hash->init(ctx);
119
120
return 1;
121
}
122
123
static int rsa_verify(struct blockdata *key_data, unsigned int key_len, unsigned char *sig, size_t sig_len,
124
unsigned char *digest, int algo)
125
{
126
unsigned char *p;
127
size_t exp_len;
128
129
static struct rsa_public_key *key = NULL;
130
static mpz_t sig_mpz;
131
132
if (key == NULL)
133
{
134
if (!(key = whine_malloc(sizeof(struct rsa_public_key))))
135
return 0;
136
137
nettle_rsa_public_key_init(key);
138
mpz_init(sig_mpz);
139
}
140
141
if ((key_len < 3) || !(p = blockdata_retrieve(key_data, key_len, NULL)))
142
return 0;
143
144
key_len--;
145
if ((exp_len = *p++) == 0)
146
{
147
GETSHORT(exp_len, p);
148
key_len -= 2;
149
}
150
151
if (exp_len >= key_len)
152
return 0;
153
154
key->size = key_len - exp_len;
155
mpz_import(key->e, exp_len, 1, 1, 0, 0, p);
156
mpz_import(key->n, key->size, 1, 1, 0, 0, p + exp_len);
157
158
mpz_import(sig_mpz, sig_len, 1, 1, 0, 0, sig);
159
160
switch (algo)
161
{
162
case 1:
163
return nettle_rsa_md5_verify_digest(key, digest, sig_mpz);
164
case 5: case 7:
165
return nettle_rsa_sha1_verify_digest(key, digest, sig_mpz);
166
case 8:
167
return nettle_rsa_sha256_verify_digest(key, digest, sig_mpz);
168
case 10:
169
return nettle_rsa_sha512_verify_digest(key, digest, sig_mpz);
170
}
171
172
return 0;
173
}
174
175
static int dsa_verify(struct blockdata *key_data, unsigned int key_len, unsigned char *sig, size_t sig_len,
176
unsigned char *digest, int algo)
177
{
178
unsigned char *p;
179
unsigned int t;
180
181
static struct dsa_public_key *key = NULL;
182
static struct dsa_signature *sig_struct;
183
184
if (key == NULL)
185
{
186
if (!(sig_struct = whine_malloc(sizeof(struct dsa_signature))) ||
187
!(key = whine_malloc(sizeof(struct dsa_public_key))))
188
return 0;
189
190
nettle_dsa_public_key_init(key);
191
nettle_dsa_signature_init(sig_struct);
192
}
193
194
if ((sig_len < 41) || !(p = blockdata_retrieve(key_data, key_len, NULL)))
195
return 0;
196
197
t = *p++;
198
199
if (key_len < (213 + (t * 24)))
200
return 0;
201
202
mpz_import(key->q, 20, 1, 1, 0, 0, p); p += 20;
203
mpz_import(key->p, 64 + (t*8), 1, 1, 0, 0, p); p += 64 + (t*8);
204
mpz_import(key->g, 64 + (t*8), 1, 1, 0, 0, p); p += 64 + (t*8);
205
mpz_import(key->y, 64 + (t*8), 1, 1, 0, 0, p); p += 64 + (t*8);
206
207
mpz_import(sig_struct->r, 20, 1, 1, 0, 0, sig+1);
208
mpz_import(sig_struct->s, 20, 1, 1, 0, 0, sig+21);
209
210
(void)algo;
211
212
return nettle_dsa_sha1_verify_digest(key, digest, sig_struct);
213
}
214
215
#ifndef NO_NETTLE_ECC
216
static int dnsmasq_ecdsa_verify(struct blockdata *key_data, unsigned int key_len,
217
unsigned char *sig, size_t sig_len,
218
unsigned char *digest, size_t digest_len, int algo)
219
{
220
unsigned char *p;
221
unsigned int t;
222
struct ecc_point *key;
223
224
static struct ecc_point *key_256 = NULL, *key_384 = NULL;
225
static mpz_t x, y;
226
static struct dsa_signature *sig_struct;
227
228
if (!sig_struct)
229
{
230
if (!(sig_struct = whine_malloc(sizeof(struct dsa_signature))))
231
return 0;
232
233
nettle_dsa_signature_init(sig_struct);
234
mpz_init(x);
235
mpz_init(y);
236
}
237
238
switch (algo)
239
{
240
case 13:
241
if (!key_256)
242
{
243
if (!(key_256 = whine_malloc(sizeof(struct ecc_point))))
244
return 0;
245
246
nettle_ecc_point_init(key_256, &nettle_secp_256r1);
247
}
248
249
key = key_256;
250
t = 32;
251
break;
252
253
case 14:
254
if (!key_384)
255
{
256
if (!(key_384 = whine_malloc(sizeof(struct ecc_point))))
257
return 0;
258
259
nettle_ecc_point_init(key_384, &nettle_secp_384r1);
260
}
261
262
key = key_384;
263
t = 48;
264
break;
265
266
default:
267
return 0;
268
}
269
270
if (sig_len != 2*t || key_len != 2*t ||
271
(p = blockdata_retrieve(key_data, key_len, NULL)))
272
return 0;
273
274
mpz_import(x, t , 1, 1, 0, 0, p);
275
mpz_import(y, t , 1, 1, 0, 0, p + t);
276
277
if (!ecc_point_set(key, x, y))
278
return 0;
279
280
mpz_import(sig_struct->r, t, 1, 1, 0, 0, sig);
281
mpz_import(sig_struct->s, t, 1, 1, 0, 0, sig + t);
282
283
return nettle_ecdsa_verify(key, digest_len, digest, sig_struct);
284
}
285
#endif
286
287
static int verify(struct blockdata *key_data, unsigned int key_len, unsigned char *sig, size_t sig_len,
288
unsigned char *digest, size_t digest_len, int algo)
289
{
290
(void)digest_len;
291
292
switch (algo)
293
{
294
case 1: case 5: case 7: case 8: case 10:
295
return rsa_verify(key_data, key_len, sig, sig_len, digest, algo);
296
297
case 3: case 6:
298
return dsa_verify(key_data, key_len, sig, sig_len, digest, algo);
299
300
#ifndef NO_NETTLE_ECC
301
case 13: case 14:
302
return dnsmasq_ecdsa_verify(key_data, key_len, sig, sig_len, digest, digest_len, algo);
303
#endif
304
}
305
306
return 0;
307
}
308
309
/* Convert from presentation format to wire format, in place.
310
Also map UC -> LC.
311
Note that using extract_name to get presentation format
312
then calling to_wire() removes compression and maps case,
313
thus generating names in canonical form.
314
Calling to_wire followed by from_wire is almost an identity,
315
except that the UC remains mapped to LC.
316
*/
317
static int to_wire(char *name)
318
{
319
unsigned char *l, *p, term;
320
int len;
321
322
for (l = (unsigned char*)name; *l != 0; l = p)
323
{
324
for (p = l; *p != '.' && *p != 0; p++)
325
if (*p >= 'A' && *p <= 'Z')
326
*p = *p - 'A' + 'a';
327
328
term = *p;
329
330
if ((len = p - l) != 0)
331
memmove(l+1, l, len);
332
*l = len;
333
334
p++;
335
336
if (term == 0)
337
*p = 0;
338
}
339
340
return l + 1 - (unsigned char *)name;
341
}
342
343
/* Note: no compression allowed in input. */
344
static void from_wire(char *name)
345
{
346
unsigned char *l;
347
int len;
348
349
for (l = (unsigned char *)name; *l != 0; l += len+1)
350
{
351
len = *l;
352
memmove(l, l+1, len);
353
l[len] = '.';
354
}
355
356
if ((char *)l != name)
357
*(l-1) = 0;
358
}
359
360
/* Input in presentation format */
361
static int count_labels(char *name)
362
{
363
int i;
364
365
if (*name == 0)
366
return 0;
367
368
for (i = 0; *name; name++)
369
if (*name == '.')
370
i++;
371
372
return i+1;
373
}
374
375
/* Implement RFC1982 wrapped compare for 32-bit numbers */
376
static int serial_compare_32(unsigned long s1, unsigned long s2)
377
{
378
if (s1 == s2)
379
return SERIAL_EQ;
380
381
if ((s1 < s2 && (s2 - s1) < (1UL<<31)) ||
382
(s1 > s2 && (s1 - s2) > (1UL<<31)))
383
return SERIAL_LT;
384
if ((s1 < s2 && (s2 - s1) > (1UL<<31)) ||
385
(s1 > s2 && (s1 - s2) < (1UL<<31)))
386
return SERIAL_GT;
387
return SERIAL_UNDEF;
388
}
389
390
/* Check whether today/now is between date_start and date_end */
391
static int check_date_range(unsigned long date_start, unsigned long date_end)
392
{
393
unsigned long curtime;
394
395
/* Checking timestamps may be temporarily disabled */
396
if (option_bool(OPT_DNSSEC_TIME))
397
return 1;
398
399
curtime = time(0);
400
401
/* We must explicitly check against wanted values, because of SERIAL_UNDEF */
402
return serial_compare_32(curtime, date_start) == SERIAL_GT
403
&& serial_compare_32(curtime, date_end) == SERIAL_LT;
404
}
405
406
static u16 *get_desc(int type)
407
{
408
/* List of RRtypes which include domains in the data.
409
0 -> domain
410
integer -> no of plain bytes
411
-1 -> end
412
413
zero is not a valid RRtype, so the final entry is returned for
414
anything which needs no mangling.
415
*/
416
417
static u16 rr_desc[] =
418
{
419
T_NS, 0, -1,
420
T_MD, 0, -1,
421
T_MF, 0, -1,
422
T_CNAME, 0, -1,
423
T_SOA, 0, 0, -1,
424
T_MB, 0, -1,
425
T_MG, 0, -1,
426
T_MR, 0, -1,
427
T_PTR, 0, -1,
428
T_MINFO, 0, 0, -1,
429
T_MX, 2, 0, -1,
430
T_RP, 0, 0, -1,
431
T_AFSDB, 2, 0, -1,
432
T_RT, 2, 0, -1,
433
T_SIG, 18, 0, -1,
434
T_PX, 2, 0, 0, -1,
435
T_NXT, 0, -1,
436
T_KX, 2, 0, -1,
437
T_SRV, 6, 0, -1,
438
T_DNAME, 0, -1,
439
0, -1 /* wildcard/catchall */
440
};
441
442
u16 *p = rr_desc;
443
444
while (*p != type && *p != 0)
445
while (*p++ != (u16)-1);
446
447
return p+1;
448
}
449
450
/* Return bytes of canonicalised rdata, when the return value is zero, the remaining
451
data, pointed to by *p, should be used raw. */
452
static int get_rdata(struct dns_header *header, size_t plen, unsigned char *end, char *buff,
453
unsigned char **p, u16 **desc)
454
{
455
int d = **desc;
456
457
(*desc)++;
458
459
/* No more data needs mangling */
460
if (d == (u16)-1)
461
return 0;
462
463
if (d == 0 && extract_name(header, plen, p, buff, 1, 0))
464
/* domain-name, canonicalise */
465
return to_wire(buff);
466
else
467
{
468
/* plain data preceding a domain-name, don't run off the end of the data */
469
if ((end - *p) < d)
470
d = end - *p;
471
472
if (d != 0)
473
{
474
memcpy(buff, *p, d);
475
*p += d;
476
}
477
478
return d;
479
}
480
}
481
482
static int expand_workspace(unsigned char ***wkspc, int *sz, int new)
483
{
484
unsigned char **p;
485
int new_sz = *sz;
486
487
if (new_sz > new)
488
return 1;
489
490
if (new >= 100)
491
return 0;
492
493
new_sz += 5;
494
495
if (!(p = whine_malloc((new_sz) * sizeof(unsigned char **))))
496
return 0;
497
498
if (*wkspc)
499
{
500
memcpy(p, *wkspc, *sz * sizeof(unsigned char **));
501
free(*wkspc);
502
}
503
504
*wkspc = p;
505
*sz = new_sz;
506
507
return 1;
508
}
509
510
/* Bubble sort the RRset into the canonical order.
511
Note that the byte-streams from two RRs may get unsynced: consider
512
RRs which have two domain-names at the start and then other data.
513
The domain-names may have different lengths in each RR, but sort equal
514
515
------------
516
|abcde|fghi|
517
------------
518
|abcd|efghi|
519
------------
520
521
leaving the following bytes as deciding the order. Hence the nasty left1 and left2 variables.
522
*/
523
524
static void sort_rrset(struct dns_header *header, size_t plen, u16 *rr_desc, int rrsetidx,
525
unsigned char **rrset, char *buff1, char *buff2)
526
{
527
int swap, quit, i;
528
529
do
530
{
531
for (swap = 0, i = 0; i < rrsetidx-1; i++)
532
{
533
int rdlen1, rdlen2, left1, left2, len1, len2, len, rc;
534
u16 *dp1, *dp2;
535
unsigned char *end1, *end2;
536
/* Note that these have been determined to be OK previously,
537
so we don't need to check for NULL return here. */
538
unsigned char *p1 = skip_name(rrset[i], header, plen, 10);
539
unsigned char *p2 = skip_name(rrset[i+1], header, plen, 10);
540
541
p1 += 8; /* skip class, type, ttl */
542
GETSHORT(rdlen1, p1);
543
end1 = p1 + rdlen1;
544
545
p2 += 8; /* skip class, type, ttl */
546
GETSHORT(rdlen2, p2);
547
end2 = p2 + rdlen2;
548
549
dp1 = dp2 = rr_desc;
550
551
for (quit = 0, left1 = 0, left2 = 0, len1 = 0, len2 = 0; !quit;)
552
{
553
if (left1 != 0)
554
memmove(buff1, buff1 + len1 - left1, left1);
555
556
if ((len1 = get_rdata(header, plen, end1, buff1 + left1, &p1, &dp1)) == 0)
557
{
558
quit = 1;
559
len1 = end1 - p1;
560
memcpy(buff1 + left1, p1, len1);
561
}
562
len1 += left1;
563
564
if (left2 != 0)
565
memmove(buff2, buff2 + len2 - left2, left2);
566
567
if ((len2 = get_rdata(header, plen, end2, buff2 + left2, &p2, &dp2)) == 0)
568
{
569
quit = 1;
570
len2 = end2 - p2;
571
memcpy(buff2 + left2, p2, len2);
572
}
573
len2 += left2;
574
575
if (len1 > len2)
576
left1 = len1 - len2, left2 = 0, len = len2;
577
else
578
left2 = len2 - len1, left1 = 0, len = len1;
579
580
rc = (len == 0) ? 0 : memcmp(buff1, buff2, len);
581
582
if (rc > 0 || (rc == 0 && quit && len1 > len2))
583
{
584
unsigned char *tmp = rrset[i+1];
585
rrset[i+1] = rrset[i];
586
rrset[i] = tmp;
587
swap = quit = 1;
588
}
589
else if (rc < 0)
590
quit = 1;
591
}
592
}
593
} while (swap);
594
}
595
596
/* Validate a single RRset (class, type, name) in the supplied DNS reply
597
Return code:
598
STAT_SECURE if it validates.
599
STAT_SECURE_WILDCARD if it validates and is the result of wildcard expansion.
600
STAT_NO_SIG no RRsigs found.
601
STAT_INSECURE RRset empty.
602
STAT_BOGUS signature is wrong, bad packet.
603
STAT_NEED_KEY need DNSKEY to complete validation (name is returned in keyname)
604
605
if key is non-NULL, use that key, which has the algo and tag given in the params of those names,
606
otherwise find the key in the cache.
607
608
name is unchanged on exit. keyname is used as workspace and trashed.
609
*/
610
static int validate_rrset(time_t now, struct dns_header *header, size_t plen, int class,
611
int type, char *name, char *keyname, struct blockdata *key, int keylen, int algo_in, int keytag_in)
612
{
613
static unsigned char **rrset = NULL, **sigs = NULL;
614
static int rrset_sz = 0, sig_sz = 0;
615
616
unsigned char *p;
617
int rrsetidx, sigidx, res, rdlen, j, name_labels;
618
struct crec *crecp = NULL;
619
int type_covered, algo, labels, orig_ttl, sig_expiration, sig_inception, key_tag;
620
u16 *rr_desc = get_desc(type);
621
622
if (!(p = skip_questions(header, plen)))
623
return STAT_BOGUS;
624
625
name_labels = count_labels(name); /* For 4035 5.3.2 check */
626
627
/* look for RRSIGs for this RRset and get pointers to each RR in the set. */
628
for (rrsetidx = 0, sigidx = 0, j = ntohs(header->ancount) + ntohs(header->nscount);
629
j != 0; j--)
630
{
631
unsigned char *pstart, *pdata;
632
int stype, sclass;
633
634
pstart = p;
635
636
if (!(res = extract_name(header, plen, &p, name, 0, 10)))
637
return STAT_BOGUS; /* bad packet */
638
639
GETSHORT(stype, p);
640
GETSHORT(sclass, p);
641
p += 4; /* TTL */
642
643
pdata = p;
644
645
GETSHORT(rdlen, p);
646
647
if (!CHECK_LEN(header, p, plen, rdlen))
648
return STAT_BOGUS;
649
650
if (res == 1 && sclass == class)
651
{
652
if (stype == type)
653
{
654
if (!expand_workspace(&rrset, &rrset_sz, rrsetidx))
655
return STAT_BOGUS;
656
657
rrset[rrsetidx++] = pstart;
658
}
659
660
if (stype == T_RRSIG)
661
{
662
if (rdlen < 18)
663
return STAT_BOGUS; /* bad packet */
664
665
GETSHORT(type_covered, p);
666
667
if (type_covered == type)
668
{
669
if (!expand_workspace(&sigs, &sig_sz, sigidx))
670
return STAT_BOGUS;
671
672
sigs[sigidx++] = pdata;
673
}
674
675
p = pdata + 2; /* restore for ADD_RDLEN */
676
}
677
}
678
679
if (!ADD_RDLEN(header, p, plen, rdlen))
680
return STAT_BOGUS;
681
}
682
683
/* RRset empty */
684
if (rrsetidx == 0)
685
return STAT_INSECURE;
686
687
/* no RRSIGs */
688
if (sigidx == 0)
689
return STAT_NO_SIG;
690
691
/* Sort RRset records into canonical order.
692
Note that at this point keyname and daemon->workspacename buffs are
693
unused, and used as workspace by the sort. */
694
sort_rrset(header, plen, rr_desc, rrsetidx, rrset, daemon->workspacename, keyname);
695
696
/* Now try all the sigs to try and find one which validates */
697
for (j = 0; j <sigidx; j++)
698
{
699
unsigned char *psav, *sig, *digest;
700
int i, wire_len, sig_len;
701
const struct nettle_hash *hash;
702
void *ctx;
703
char *name_start;
704
u32 nsigttl;
705
706
p = sigs[j];
707
GETSHORT(rdlen, p); /* rdlen >= 18 checked previously */
708
psav = p;
709
710
p += 2; /* type_covered - already checked */
711
algo = *p++;
712
labels = *p++;
713
GETLONG(orig_ttl, p);
714
GETLONG(sig_expiration, p);
715
GETLONG(sig_inception, p);
716
GETSHORT(key_tag, p);
717
718
if (!extract_name(header, plen, &p, keyname, 1, 0))
719
return STAT_BOGUS;
720
721
/* RFC 4035 5.3.1 says that the Signer's Name field MUST equal
722
the name of the zone containing the RRset. We can't tell that
723
for certain, but we can check that the RRset name is equal to
724
or encloses the signers name, which should be enough to stop
725
an attacker using signatures made with the key of an unrelated
726
zone he controls. Note that the root key is always allowed. */
727
if (*keyname != 0)
728
{
729
int failed = 0;
730
731
for (name_start = name; !hostname_isequal(name_start, keyname); )
732
if ((name_start = strchr(name_start, '.')))
733
name_start++; /* chop a label off and try again */
734
else
735
{
736
failed = 1;
737
break;
738
}
739
740
/* Bad sig, try another */
741
if (failed)
742
continue;
743
}
744
745
/* Other 5.3.1 checks */
746
if (!check_date_range(sig_inception, sig_expiration) ||
747
labels > name_labels ||
748
!(hash = hash_find(algo_digest_name(algo))) ||
749
!hash_init(hash, &ctx, &digest))
750
continue;
751
752
/* OK, we have the signature record, see if the relevant DNSKEY is in the cache. */
753
if (!key && !(crecp = cache_find_by_name(NULL, keyname, now, F_DNSKEY)))
754
return STAT_NEED_KEY;
755
756
sig = p;
757
sig_len = rdlen - (p - psav);
758
759
nsigttl = htonl(orig_ttl);
760
761
hash->update(ctx, 18, psav);
762
wire_len = to_wire(keyname);
763
hash->update(ctx, (unsigned int)wire_len, (unsigned char*)keyname);
764
from_wire(keyname);
765
766
for (i = 0; i < rrsetidx; ++i)
767
{
768
int seg;
769
unsigned char *end, *cp;
770
u16 len, *dp;
771
772
p = rrset[i];
773
if (!extract_name(header, plen, &p, name, 1, 10))
774
return STAT_BOGUS;
775
776
name_start = name;
777
778
/* if more labels than in RRsig name, hash *.<no labels in rrsig labels field> 4035 5.3.2 */
779
if (labels < name_labels)
780
{
781
int k;
782
for (k = name_labels - labels; k != 0; k--)
783
while (*name_start != '.' && *name_start != 0)
784
name_start++;
785
name_start--;
786
*name_start = '*';
787
}
788
789
wire_len = to_wire(name_start);
790
hash->update(ctx, (unsigned int)wire_len, (unsigned char *)name_start);
791
hash->update(ctx, 4, p); /* class and type */
792
hash->update(ctx, 4, (unsigned char *)&nsigttl);
793
794
p += 8; /* skip class, type, ttl */
795
GETSHORT(rdlen, p);
796
if (!CHECK_LEN(header, p, plen, rdlen))
797
return STAT_BOGUS;
798
799
end = p + rdlen;
800
801
/* canonicalise rdata and calculate length of same, use name buffer as workspace */
802
cp = p;
803
dp = rr_desc;
804
for (len = 0; (seg = get_rdata(header, plen, end, name, &cp, &dp)) != 0; len += seg);
805
len += end - cp;
806
len = htons(len);
807
hash->update(ctx, 2, (unsigned char *)&len);
808
809
/* Now canonicalise again and digest. */
810
cp = p;
811
dp = rr_desc;
812
while ((seg = get_rdata(header, plen, end, name, &cp, &dp)))
813
hash->update(ctx, seg, (unsigned char *)name);
814
if (cp != end)
815
hash->update(ctx, end - cp, cp);
816
}
817
818
hash->digest(ctx, hash->digest_size, digest);
819
820
/* namebuff used for workspace above, restore to leave unchanged on exit */
821
p = (unsigned char*)(rrset[0]);
822
extract_name(header, plen, &p, name, 1, 0);
823
824
if (key)
825
{
826
if (algo_in == algo && keytag_in == key_tag &&
827
verify(key, keylen, sig, sig_len, digest, hash->digest_size, algo))
828
return STAT_SECURE;
829
}
830
else
831
{
832
/* iterate through all possible keys 4035 5.3.1 */
833
for (; crecp; crecp = cache_find_by_name(crecp, keyname, now, F_DNSKEY))
834
if (crecp->addr.key.algo == algo &&
835
crecp->addr.key.keytag == key_tag &&
836
crecp->uid == (unsigned int)class &&
837
verify(crecp->addr.key.keydata, crecp->addr.key.keylen, sig, sig_len, digest, hash->digest_size, algo))
838
return (labels < name_labels) ? STAT_SECURE_WILDCARD : STAT_SECURE;
839
}
840
}
841
842
return STAT_BOGUS;
843
}
844
845
/* The DNS packet is expected to contain the answer to a DNSKEY query.
846
Put all DNSKEYs in the answer which are valid into the cache.
847
return codes:
848
STAT_INSECURE No DNSKEYs in reply.
849
STAT_SECURE At least one valid DNSKEY found and in cache.
850
STAT_BOGUS No DNSKEYs found, which can be validated with DS,
851
or self-sign for DNSKEY RRset is not valid, bad packet.
852
STAT_NEED_DS DS records to validate a key not found, name in keyname
853
*/
854
int dnssec_validate_by_ds(time_t now, struct dns_header *header, size_t plen, char *name, char *keyname, int class)
855
{
856
unsigned char *psave, *p = (unsigned char *)(header+1);
857
struct crec *crecp, *recp1;
858
int rc, j, qtype, qclass, ttl, rdlen, flags, algo, valid, keytag, type_covered;
859
struct blockdata *key;
860
struct all_addr a;
861
862
if (ntohs(header->qdcount) != 1 ||
863
!extract_name(header, plen, &p, name, 1, 4))
864
return STAT_BOGUS;
865
866
GETSHORT(qtype, p);
867
GETSHORT(qclass, p);
868
869
if (qtype != T_DNSKEY || qclass != class)
870
return STAT_BOGUS;
871
872
if (ntohs(header->ancount) == 0)
873
return STAT_INSECURE;
874
875
/* See if we have cached a DS record which validates this key */
876
if (!(crecp = cache_find_by_name(NULL, name, now, F_DS)))
877
{
878
strcpy(keyname, name);
879
return STAT_NEED_DS;
880
}
881
882
/* If we've cached that DS provably doesn't exist, result must be INSECURE */
883
if (crecp->flags & F_NEG)
884
return STAT_INSECURE;
885
886
/* NOTE, we need to find ONE DNSKEY which matches the DS */
887
for (valid = 0, j = ntohs(header->ancount); j != 0 && !valid; j--)
888
{
889
/* Ensure we have type, class TTL and length */
890
if (!(rc = extract_name(header, plen, &p, name, 0, 10)))
891
return STAT_BOGUS; /* bad packet */
892
893
GETSHORT(qtype, p);
894
GETSHORT(qclass, p);
895
GETLONG(ttl, p);
896
GETSHORT(rdlen, p);
897
898
if (!CHECK_LEN(header, p, plen, rdlen) || rdlen < 4)
899
return STAT_BOGUS; /* bad packet */
900
901
if (qclass != class || qtype != T_DNSKEY || rc == 2)
902
{
903
p += rdlen;
904
continue;
905
}
906
907
psave = p;
908
909
GETSHORT(flags, p);
910
if (*p++ != 3)
911
return STAT_BOGUS;
912
algo = *p++;
913
keytag = dnskey_keytag(algo, flags, p, rdlen - 4);
914
key = NULL;
915
916
/* key must have zone key flag set */
917
if (flags & 0x100)
918
key = blockdata_alloc((char*)p, rdlen - 4);
919
920
p = psave;
921
922
if (!ADD_RDLEN(header, p, plen, rdlen))
923
{
924
if (key)
925
blockdata_free(key);
926
return STAT_BOGUS; /* bad packet */
927
}
928
929
/* No zone key flag or malloc failure */
930
if (!key)
931
continue;
932
933
for (recp1 = crecp; recp1; recp1 = cache_find_by_name(recp1, name, now, F_DS))
934
{
935
void *ctx;
936
unsigned char *digest, *ds_digest;
937
const struct nettle_hash *hash;
938
939
if (recp1->addr.ds.algo == algo &&
940
recp1->addr.ds.keytag == keytag &&
941
recp1->uid == (unsigned int)class &&
942
(hash = hash_find(ds_digest_name(recp1->addr.ds.digest))) &&
943
hash_init(hash, &ctx, &digest))
944
945
{
946
int wire_len = to_wire(name);
947
948
/* Note that digest may be different between DSs, so
949
we can't move this outside the loop. */
950
hash->update(ctx, (unsigned int)wire_len, (unsigned char *)name);
951
hash->update(ctx, (unsigned int)rdlen, psave);
952
hash->digest(ctx, hash->digest_size, digest);
953
954
from_wire(name);
955
956
if (recp1->addr.ds.keylen == (int)hash->digest_size &&
957
(ds_digest = blockdata_retrieve(recp1->addr.key.keydata, recp1->addr.ds.keylen, NULL)) &&
958
memcmp(ds_digest, digest, recp1->addr.ds.keylen) == 0 &&
959
validate_rrset(now, header, plen, class, T_DNSKEY, name, keyname, key, rdlen - 4, algo, keytag) == STAT_SECURE)
960
{
961
valid = 1;
962
break;
963
}
964
}
965
}
966
blockdata_free(key);
967
}
968
969
if (valid)
970
{
971
/* DNSKEY RRset determined to be OK, now cache it and the RRsigs that sign it. */
972
cache_start_insert();
973
974
p = skip_questions(header, plen);
975
976
for (j = ntohs(header->ancount); j != 0; j--)
977
{
978
/* Ensure we have type, class TTL and length */
979
if (!(rc = extract_name(header, plen, &p, name, 0, 10)))
980
return STAT_INSECURE; /* bad packet */
981
982
GETSHORT(qtype, p);
983
GETSHORT(qclass, p);
984
GETLONG(ttl, p);
985
GETSHORT(rdlen, p);
986
987
if (!CHECK_LEN(header, p, plen, rdlen))
988
return STAT_BOGUS; /* bad packet */
989
990
if (qclass == class && rc == 1)
991
{
992
psave = p;
993
994
if (qtype == T_DNSKEY)
995
{
996
if (rdlen < 4)
997
return STAT_BOGUS; /* bad packet */
998
999
GETSHORT(flags, p);
1000
if (*p++ != 3)
1001
return STAT_BOGUS;
1002
algo = *p++;
1003
keytag = dnskey_keytag(algo, flags, p, rdlen - 4);
1004
1005
/* Cache needs to known class for DNSSEC stuff */
1006
a.addr.dnssec.class = class;
1007
1008
if ((key = blockdata_alloc((char*)p, rdlen - 4)))
1009
{
1010
if (!(recp1 = cache_insert(name, &a, now, ttl, F_FORWARD | F_DNSKEY | F_DNSSECOK)))
1011
blockdata_free(key);
1012
else
1013
{
1014
a.addr.keytag = keytag;
1015
log_query(F_KEYTAG | F_UPSTREAM, name, &a, "DNSKEY keytag %u");
1016
1017
recp1->addr.key.keylen = rdlen - 4;
1018
recp1->addr.key.keydata = key;
1019
recp1->addr.key.algo = algo;
1020
recp1->addr.key.keytag = keytag;
1021
recp1->addr.key.flags = flags;
1022
}
1023
}
1024
}
1025
else if (qtype == T_RRSIG)
1026
{
1027
/* RRSIG, cache if covers DNSKEY RRset */
1028
if (rdlen < 18)
1029
return STAT_BOGUS; /* bad packet */
1030
1031
GETSHORT(type_covered, p);
1032
1033
if (type_covered == T_DNSKEY)
1034
{
1035
a.addr.dnssec.class = class;
1036
a.addr.dnssec.type = type_covered;
1037
1038
algo = *p++;
1039
p += 13; /* labels, orig_ttl, expiration, inception */
1040
GETSHORT(keytag, p);
1041
if ((key = blockdata_alloc((char*)psave, rdlen)))
1042
{
1043
if (!(crecp = cache_insert(name, &a, now, ttl, F_FORWARD | F_DNSKEY | F_DS)))
1044
blockdata_free(key);
1045
else
1046
{
1047
crecp->addr.sig.keydata = key;
1048
crecp->addr.sig.keylen = rdlen;
1049
crecp->addr.sig.keytag = keytag;
1050
crecp->addr.sig.type_covered = type_covered;
1051
crecp->addr.sig.algo = algo;
1052
}
1053
}
1054
}
1055
}
1056
1057
p = psave;
1058
}
1059
1060
if (!ADD_RDLEN(header, p, plen, rdlen))
1061
return STAT_BOGUS; /* bad packet */
1062
}
1063
1064
/* commit cache insert. */
1065
cache_end_insert();
1066
return STAT_SECURE;
1067
}
1068
1069
log_query(F_UPSTREAM, name, NULL, "BOGUS DNSKEY");
1070
return STAT_BOGUS;
1071
}
1072
1073
/* The DNS packet is expected to contain the answer to a DS query
1074
Put all DSs in the answer which are valid into the cache.
1075
return codes:
1076
STAT_INSECURE no DS in reply or not signed.
1077
STAT_SECURE At least one valid DS found and in cache.
1078
STAT_NO_DS It's proved there's no DS here.
1079
STAT_BOGUS At least one DS found, which fails validation, bad packet.
1080
STAT_NEED_DNSKEY DNSKEY records to validate a DS not found, name in keyname
1081
*/
1082
1083
int dnssec_validate_ds(time_t now, struct dns_header *header, size_t plen, char *name, char *keyname, int class)
1084
{
1085
unsigned char *p = (unsigned char *)(header+1);
1086
int qtype, qclass, val, i, neganswer;
1087
1088
if (ntohs(header->qdcount) != 1 ||
1089
!(p = skip_name(p, header, plen, 4)))
1090
return STAT_BOGUS;
1091
1092
GETSHORT(qtype, p);
1093
GETSHORT(qclass, p);
1094
1095
if (qtype != T_DS || qclass != class)
1096
val = STAT_BOGUS;
1097
else
1098
val = dnssec_validate_reply(now, header, plen, name, keyname, NULL, &neganswer);
1099
1100
if (val == STAT_NO_SIG)
1101
val = STAT_INSECURE;
1102
1103
p = (unsigned char *)(header+1);
1104
extract_name(header, plen, &p, name, 1, 4);
1105
p += 4; /* qtype, qclass */
1106
1107
if (!(p = skip_section(p, ntohs(header->ancount), header, plen)))
1108
return STAT_BOGUS;
1109
1110
if (val == STAT_BOGUS)
1111
log_query(F_UPSTREAM, name, NULL, "BOGUS DS");
1112
1113
if ((val == STAT_SECURE || val == STAT_INSECURE) && neganswer)
1114
{
1115
int rdlen, flags = F_FORWARD | F_DS | F_NEG;
1116
unsigned long ttl, minttl = ULONG_MAX;
1117
struct all_addr a;
1118
1119
if (RCODE(header) == NXDOMAIN)
1120
flags |= F_NXDOMAIN;
1121
1122
if (val == STAT_SECURE)
1123
flags |= F_DNSSECOK;
1124
1125
for (i = ntohs(header->nscount); i != 0; i--)
1126
{
1127
if (!(p = skip_name(p, header, plen, 0)))
1128
return STAT_BOGUS;
1129
1130
GETSHORT(qtype, p);
1131
GETSHORT(qclass, p);
1132
GETLONG(ttl, p);
1133
GETSHORT(rdlen, p);
1134
1135
if (!CHECK_LEN(header, p, plen, rdlen))
1136
return STAT_BOGUS; /* bad packet */
1137
1138
if (qclass != class || qtype != T_SOA)
1139
{
1140
p += rdlen;
1141
continue;
1142
}
1143
1144
if (ttl < minttl)
1145
minttl = ttl;
1146
1147
/* MNAME */
1148
if (!(p = skip_name(p, header, plen, 0)))
1149
return STAT_BOGUS;
1150
/* RNAME */
1151
if (!(p = skip_name(p, header, plen, 20)))
1152
return STAT_BOGUS;
1153
p += 16; /* SERIAL REFRESH RETRY EXPIRE */
1154
1155
GETLONG(ttl, p); /* minTTL */
1156
if (ttl < minttl)
1157
minttl = ttl;
1158
1159
break;
1160
}
1161
1162
if (i != 0)
1163
{
1164
cache_start_insert();
1165
1166
a.addr.dnssec.class = class;
1167
cache_insert(name, &a, now, ttl, flags);
1168
1169
cache_end_insert();
1170
}
1171
1172
return (val == STAT_SECURE) ? STAT_NO_DS : STAT_INSECURE;
1173
}
1174
1175
return val;
1176
}
1177
1178
/* 4034 6.1 */
1179
static int hostname_cmp(const char *a, const char *b)
1180
{
1181
char *sa, *ea, *ca, *sb, *eb, *cb;
1182
unsigned char ac, bc;
1183
1184
sa = ea = (char *)a + strlen(a);
1185
sb = eb = (char *)b + strlen(b);
1186
1187
while (1)
1188
{
1189
while (sa != a && *(sa-1) != '.')
1190
sa--;
1191
1192
while (sb != b && *(sb-1) != '.')
1193
sb--;
1194
1195
ca = sa;
1196
cb = sb;
1197
1198
while (1)
1199
{
1200
if (ca == ea)
1201
{
1202
if (cb == eb)
1203
break;
1204
1205
return -1;
1206
}
1207
1208
if (cb == eb)
1209
return 1;
1210
1211
ac = (unsigned char) *ca++;
1212
bc = (unsigned char) *cb++;
1213
1214
if (ac >= 'A' && ac <= 'Z')
1215
ac += 'a' - 'A';
1216
if (bc >= 'A' && bc <= 'Z')
1217
bc += 'a' - 'A';
1218
1219
if (ac < bc)
1220
return -1;
1221
else if (ac != bc)
1222
return 1;
1223
}
1224
1225
1226
if (sa == a)
1227
{
1228
if (sb == b)
1229
return 0;
1230
1231
return -1;
1232
}
1233
1234
if (sb == b)
1235
return 1;
1236
1237
ea = sa--;
1238
eb = sb--;
1239
}
1240
}
1241
1242
/* Find all the NSEC or NSEC3 records in a reply.
1243
return an array of pointers to them. */
1244
static int find_nsec_records(struct dns_header *header, size_t plen, unsigned char ***nsecsetp, int *nsecsetl, int class_reqd)
1245
{
1246
static unsigned char **nsecset = NULL;
1247
static int nsecset_sz = 0;
1248
1249
int type_found = 0;
1250
unsigned char *p = skip_questions(header, plen);
1251
int type, class, rdlen, i, nsecs_found;
1252
1253
/* Move to NS section */
1254
if (!p || !(p = skip_section(p, ntohs(header->ancount), header, plen)))
1255
return 0;
1256
1257
for (nsecs_found = 0, i = ntohs(header->nscount); i != 0; i--)
1258
{
1259
unsigned char *pstart = p;
1260
1261
if (!(p = skip_name(p, header, plen, 10)))
1262
return 0;
1263
1264
GETSHORT(type, p);
1265
GETSHORT(class, p);
1266
p += 4; /* TTL */
1267
GETSHORT(rdlen, p);
1268
1269
if (class == class_reqd && (type == T_NSEC || type == T_NSEC3))
1270
{
1271
/* No mixed NSECing 'round here, thankyouverymuch */
1272
if (type_found == T_NSEC && type == T_NSEC3)
1273
return 0;
1274
if (type_found == T_NSEC3 && type == T_NSEC)
1275
return 0;
1276
1277
type_found = type;
1278
1279
if (!expand_workspace(&nsecset, &nsecset_sz, nsecs_found))
1280
return 0;
1281
1282
nsecset[nsecs_found++] = pstart;
1283
}
1284
1285
if (!ADD_RDLEN(header, p, plen, rdlen))
1286
return 0;
1287
}
1288
1289
*nsecsetp = nsecset;
1290
*nsecsetl = nsecs_found;
1291
1292
return type_found;
1293
}
1294
1295
static int prove_non_existence_nsec(struct dns_header *header, size_t plen, unsigned char **nsecs, int nsec_count,
1296
char *workspace1, char *workspace2, char *name, int type)
1297
{
1298
int i, rc, rdlen;
1299
unsigned char *p, *psave;
1300
int offset = (type & 0xff) >> 3;
1301
int mask = 0x80 >> (type & 0x07);
1302
1303
/* Find NSEC record that proves name doesn't exist */
1304
for (i = 0; i < nsec_count; i++)
1305
{
1306
p = nsecs[i];
1307
if (!extract_name(header, plen, &p, workspace1, 1, 10))
1308
return STAT_BOGUS;
1309
p += 8; /* class, type, TTL */
1310
GETSHORT(rdlen, p);
1311
psave = p;
1312
if (!extract_name(header, plen, &p, workspace2, 1, 10))
1313
return STAT_BOGUS;
1314
1315
rc = hostname_cmp(workspace1, name);
1316
1317
if (rc == 0)
1318
{
1319
/* 4035 para 5.4. Last sentence */
1320
if (type == T_NSEC || type == T_RRSIG)
1321
return STAT_SECURE;
1322
1323
/* NSEC with the same name as the RR we're testing, check
1324
that the type in question doesn't appear in the type map */
1325
rdlen -= p - psave;
1326
/* rdlen is now length of type map, and p points to it */
1327
1328
while (rdlen >= 2)
1329
{
1330
if (!CHECK_LEN(header, p, plen, rdlen))
1331
return STAT_BOGUS;
1332
1333
if (p[0] == type >> 8)
1334
{
1335
/* Does the NSEC say our type exists? */
1336
if (offset < p[1] && (p[offset+2] & mask) != 0)
1337
return STAT_BOGUS;
1338
1339
break; /* finshed checking */
1340
}
1341
1342
rdlen -= p[1];
1343
p += p[1];
1344
}
1345
1346
return STAT_SECURE;
1347
}
1348
else if (rc == -1)
1349
{
1350
/* Normal case, name falls between NSEC name and next domain name,
1351
wrap around case, name falls between NSEC name (rc == -1) and end */
1352
if (hostname_cmp(workspace2, name) == 1 || hostname_cmp(workspace1, workspace2) == 1)
1353
return STAT_SECURE;
1354
}
1355
else
1356
{
1357
/* wrap around case, name falls between start and next domain name */
1358
if (hostname_cmp(workspace1, workspace2) == 1 && hostname_cmp(workspace2, name) == 1)
1359
return STAT_SECURE;
1360
}
1361
}
1362
1363
return STAT_BOGUS;
1364
}
1365
1366
/* return digest length, or zero on error */
1367
static int hash_name(char *in, unsigned char **out, struct nettle_hash const *hash,
1368
unsigned char *salt, int salt_len, int iterations)
1369
{
1370
void *ctx;
1371
unsigned char *digest;
1372
int i;
1373
1374
if (!hash_init(hash, &ctx, &digest))
1375
return 0;
1376
1377
hash->update(ctx, to_wire(in), (unsigned char *)in);
1378
hash->update(ctx, salt_len, salt);
1379
hash->digest(ctx, hash->digest_size, digest);
1380
1381
for(i = 0; i < iterations; i++)
1382
{
1383
hash->update(ctx, hash->digest_size, digest);
1384
hash->update(ctx, salt_len, salt);
1385
hash->digest(ctx, hash->digest_size, digest);
1386
}
1387
1388
from_wire(in);
1389
1390
*out = digest;
1391
return hash->digest_size;
1392
}
1393
1394
/* Decode base32 to first "." or end of string */
1395
static int base32_decode(char *in, unsigned char *out)
1396
{
1397
int oc, on, c, mask, i;
1398
unsigned char *p = out;
1399
1400
for (c = *in, oc = 0, on = 0; c != 0 && c != '.'; c = *++in)
1401
{
1402
if (c >= '0' && c <= '9')
1403
c -= '0';
1404
else if (c >= 'a' && c <= 'v')
1405
c -= 'a', c += 10;
1406
else if (c >= 'A' && c <= 'V')
1407
c -= 'A', c += 10;
1408
else
1409
return 0;
1410
1411
for (mask = 0x10, i = 0; i < 5; i++)
1412
{
1413
if (c & mask)
1414
oc |= 1;
1415
mask = mask >> 1;
1416
if (((++on) & 7) == 0)
1417
*p++ = oc;
1418
oc = oc << 1;
1419
}
1420
}
1421
1422
if ((on & 7) != 0)
1423
return 0;
1424
1425
return p - out;
1426
}
1427
1428
static int prove_non_existence_nsec3(struct dns_header *header, size_t plen, unsigned char **nsecs, int nsec_count,
1429
char *workspace1, char *workspace2, char *name, int type)
1430
{
1431
unsigned char *salt, *p, *digest;
1432
int digest_len, i, iterations, salt_len, hash_len, base32_len, algo = 0;
1433
struct nettle_hash const *hash;
1434
char *closest_encloser, *next_closest, *wildcard;
1435
1436
/* Look though the NSEC3 records to find the first one with
1437
an algorithm we support (currently only algo == 1).
1438
1439
Take the algo, iterations, and salt of that record
1440
as the ones we're going to use, and prune any
1441
that don't match. */
1442
1443
for (i = 0; i < nsec_count; i++)
1444
{
1445
if (!(p = skip_name(nsecs[i], header, plen, 15)))
1446
return STAT_BOGUS; /* bad packet */
1447
1448
p += 10; /* type, class, TTL, rdlen */
1449
algo = *p++;
1450
1451
if (algo == 1)
1452
break; /* known algo */
1453
}
1454
1455
/* No usable NSEC3s */
1456
if (i == nsec_count)
1457
return STAT_BOGUS;
1458
1459
p++; /* flags */
1460
GETSHORT (iterations, p);
1461
salt_len = *p++;
1462
salt = p;
1463
if (!CHECK_LEN(header, salt, plen, salt_len))
1464
return STAT_BOGUS; /* bad packet */
1465
1466
/* Now prune so we only have NSEC3 records with same iterations, salt and algo */
1467
for (i = 0; i < nsec_count; i++)
1468
{
1469
unsigned char *nsec3p = nsecs[i];
1470
int this_iter;
1471
1472
nsecs[i] = NULL; /* Speculative, will be restored if OK. */
1473
1474
if (!(p = skip_name(nsec3p, header, plen, 15)))
1475
return STAT_BOGUS; /* bad packet */
1476
1477
p += 10; /* type, class, TTL, rdlen */
1478
1479
if (*p++ != algo)
1480
continue;
1481
1482
p++; /* flags */
1483
1484
GETSHORT(this_iter, p);
1485
if (this_iter != iterations)
1486
continue;
1487
1488
if (salt_len != *p++)
1489
continue;
1490
1491
if (!CHECK_LEN(header, p, plen, salt_len))
1492
return STAT_BOGUS; /* bad packet */
1493
1494
if (memcmp(p, salt, salt_len) != 0)
1495
continue;
1496
1497
/* All match, put the pointer back */
1498
nsecs[i] = nsec3p;
1499
}
1500
1501
/* Algo is checked as 1 above */
1502
if (!(hash = hash_find("sha1")))
1503
return STAT_BOGUS;
1504
1505
/* Now, we need the "closest encloser NSEC3" */
1506
closest_encloser = name;
1507
next_closest = NULL;
1508
1509
do
1510
{
1511
if (*closest_encloser == '.')
1512
closest_encloser++;
1513
1514
if ((digest_len = hash_name(closest_encloser, &digest, hash, salt, salt_len, iterations)) == 0)
1515
return STAT_BOGUS;
1516
1517
for (i = 0; i < nsec_count; i++)
1518
if ((p = nsecs[i]))
1519
{
1520
if (!extract_name(header, plen, &p, workspace1, 1, 0) ||
1521
!(base32_len = base32_decode(workspace1, (unsigned char *)workspace2)))
1522
return STAT_BOGUS;
1523
1524
if (digest_len == base32_len &&
1525
memcmp(digest, workspace2, digest_len) == 0)
1526
break; /* Gotit */
1527
}
1528
1529
if (i != nsec_count)
1530
break;
1531
1532
next_closest = closest_encloser;
1533
}
1534
while ((closest_encloser = strchr(closest_encloser, '.')));
1535
1536
/* No usable NSEC3s */
1537
if (i == nsec_count)
1538
return STAT_BOGUS;
1539
1540
if (!next_closest)
1541
{
1542
/* We found an NSEC3 whose hashed name exactly matches the query, so
1543
Now we just need to check the type map. p points to the RR data for the record. */
1544
int rdlen;
1545
unsigned char *psave;
1546
int offset = (type & 0xff) >> 3;
1547
int mask = 0x80 >> (type & 0x07);
1548
1549
p += 8; /* class, type, TTL */
1550
GETSHORT(rdlen, p);
1551
psave = p;
1552
p += 5 + salt_len; /* algo, flags, iterations, salt_len, salt */
1553
hash_len = *p++;
1554
if (!CHECK_LEN(header, p, plen, hash_len))
1555
return STAT_BOGUS; /* bad packet */
1556
p += hash_len;
1557
rdlen -= p - psave;
1558
1559
while (rdlen >= 2)
1560
{
1561
if (!CHECK_LEN(header, p, plen, rdlen))
1562
return STAT_BOGUS;
1563
1564
if (p[0] == type >> 8)
1565
{
1566
/* Does the NSEC3 say our type exists? */
1567
if (offset < p[1] && (p[offset+2] & mask) != 0)
1568
return STAT_BOGUS;
1569
1570
break; /* finshed checking */
1571
}
1572
1573
rdlen -= p[1];
1574
p += p[1];
1575
}
1576
1577
return STAT_SECURE;
1578
}
1579
1580
/* Look for NSEC3 that proves the non-existence of the next-closest encloser */
1581
if ((digest_len = hash_name(next_closest, &digest, hash, salt, salt_len, iterations)) == 0)
1582
return STAT_BOGUS;
1583
1584
for (i = 0; i < nsec_count; i++)
1585
if ((p = nsecs[i]))
1586
{
1587
if (!extract_name(header, plen, &p, workspace1, 1, 0) ||
1588
!(base32_len = base32_decode(workspace1, (unsigned char *)workspace2)))
1589
return STAT_BOGUS;
1590
1591
p += 15 + salt_len; /* class, type, TTL, rdlen, algo, flags, iterations, salt_len, salt */
1592
hash_len = *p++; /* p now points to next hashed name */
1593
1594
if (!CHECK_LEN(header, p, plen, hash_len))
1595
return STAT_BOGUS;
1596
1597
if (digest_len == base32_len && hash_len == base32_len)
1598
{
1599
if (memcmp(workspace2, digest, digest_len) <= 0)
1600
{
1601
/* Normal case, hash falls between NSEC3 name-hash and next domain name-hash,
1602
wrap around case, name-hash falls between NSEC3 name-hash and end */
1603
if (memcmp(p, digest, digest_len) > 0 || memcmp(workspace2, p, digest_len) > 0)
1604
return STAT_SECURE;
1605
}
1606
else
1607
{
1608
/* wrap around case, name falls between start and next domain name */
1609
if (memcmp(workspace2, p, digest_len) > 0 && memcmp(p, digest, digest_len) > 0)
1610
return STAT_SECURE;
1611
}
1612
}
1613
}
1614
1615
/* Finally, check that there's no seat of wildcard synthesis */
1616
if (!(wildcard = strchr(next_closest, '.')) || wildcard == next_closest)
1617
return STAT_BOGUS;
1618
1619
wildcard--;
1620
*wildcard = '*';
1621
1622
if ((digest_len = hash_name(wildcard, &digest, hash, salt, salt_len, iterations)) == 0)
1623
return STAT_BOGUS;
1624
1625
for (i = 0; i < nsec_count; i++)
1626
if ((p = nsecs[i]))
1627
{
1628
if (!extract_name(header, plen, &p, workspace1, 1, 0) ||
1629
!(base32_len = base32_decode(workspace1, (unsigned char *)workspace2)))
1630
return STAT_BOGUS;
1631
1632
p += 15 + salt_len; /* class, type, TTL, rdlen, algo, flags, iterations, salt_len, salt */
1633
hash_len = *p++; /* p now points to next hashed name */
1634
1635
if (!CHECK_LEN(header, p, plen, hash_len))
1636
return STAT_BOGUS;
1637
1638
if (digest_len == base32_len && hash_len == base32_len)
1639
{
1640
if (memcmp(workspace2, digest, digest_len) <= 0)
1641
{
1642
/* Normal case, hash falls between NSEC3 name-hash and next domain name-hash,
1643
wrap around case, name-hash falls between NSEC3 name-hash and end */
1644
if (memcmp(p, digest, digest_len) > 0 || memcmp(workspace2, p, digest_len) > 0)
1645
return STAT_SECURE;
1646
}
1647
else
1648
{
1649
/* wrap around case, name falls between start and next domain name */
1650
if (memcmp(workspace2, p, digest_len) > 0 && memcmp(p, digest, digest_len) > 0)
1651
return STAT_SECURE;
1652
}
1653
}
1654
}
1655
1656
return STAT_BOGUS;
1657
}
1658
1659
/* Validate all the RRsets in the answer and authority sections of the reply (4035:3.2.3) */
1660
/* Returns are the same as validate_rrset, plus the class if the missing key is in *class */
1661
int dnssec_validate_reply(time_t now, struct dns_header *header, size_t plen, char *name, char *keyname, int *class, int *neganswer)
1662
{
1663
unsigned char *ans_start, *qname, *p1, *p2, **nsecs;
1664
int type1, class1, rdlen1, type2, class2, rdlen2, qclass, qtype;
1665
int i, j, rc, nsec_count, cname_count = CNAME_CHAIN;
1666
int nsec_type = 0, have_answer = 0;
1667
1668
if (neganswer)
1669
*neganswer = 0;
1670
1671
if (RCODE(header) == SERVFAIL || ntohs(header->qdcount) != 1)
1672
return STAT_BOGUS;
1673
1674
if (RCODE(header) != NXDOMAIN && RCODE(header) != NOERROR)
1675
return STAT_INSECURE;
1676
1677
qname = p1 = (unsigned char *)(header+1);
1678
1679
if (!extract_name(header, plen, &p1, name, 1, 4))
1680
return STAT_BOGUS;
1681
1682
GETSHORT(qtype, p1);
1683
GETSHORT(qclass, p1);
1684
ans_start = p1;
1685
1686
/* Can't validate an RRISG query */
1687
if (qtype == T_RRSIG)
1688
return STAT_INSECURE;
1689
1690
cname_loop:
1691
for (j = ntohs(header->ancount); j != 0; j--)
1692
{
1693
/* leave pointer to missing name in qname */
1694
1695
if (!(rc = extract_name(header, plen, &p1, name, 0, 10)))
1696
return STAT_BOGUS; /* bad packet */
1697
1698
GETSHORT(type2, p1);
1699
GETSHORT(class2, p1);
1700
p1 += 4; /* TTL */
1701
GETSHORT(rdlen2, p1);
1702
1703
if (rc == 1 && qclass == class2)
1704
{
1705
/* Do we have an answer for the question? */
1706
if (type2 == qtype)
1707
{
1708
have_answer = 1;
1709
break;
1710
}
1711
else if (type2 == T_CNAME)
1712
{
1713
qname = p1;
1714
1715
/* looped CNAMES */
1716
if (!cname_count-- || !extract_name(header, plen, &p1, name, 1, 0))
1717
return STAT_BOGUS;
1718
1719
p1 = ans_start;
1720
goto cname_loop;
1721
}
1722
}
1723
1724
if (!ADD_RDLEN(header, p1, plen, rdlen2))
1725
return STAT_BOGUS;
1726
}
1727
1728
if (neganswer && !have_answer)
1729
*neganswer = 1;
1730
1731
/* No data, therefore no sigs */
1732
if (ntohs(header->ancount) + ntohs(header->nscount) == 0)
1733
return STAT_NO_SIG;
1734
1735
for (p1 = ans_start, i = 0; i < ntohs(header->ancount) + ntohs(header->nscount); i++)
1736
{
1737
if (!extract_name(header, plen, &p1, name, 1, 10))
1738
return STAT_BOGUS; /* bad packet */
1739
1740
GETSHORT(type1, p1);
1741
GETSHORT(class1, p1);
1742
p1 += 4; /* TTL */
1743
GETSHORT(rdlen1, p1);
1744
1745
/* Don't try and validate RRSIGs! */
1746
if (type1 != T_RRSIG)
1747
{
1748
/* Check if we've done this RRset already */
1749
for (p2 = ans_start, j = 0; j < i; j++)
1750
{
1751
if (!(rc = extract_name(header, plen, &p2, name, 0, 10)))
1752
return STAT_BOGUS; /* bad packet */
1753
1754
GETSHORT(type2, p2);
1755
GETSHORT(class2, p2);
1756
p2 += 4; /* TTL */
1757
GETSHORT(rdlen2, p2);
1758
1759
if (type2 == type1 && class2 == class1 && rc == 1)
1760
break; /* Done it before: name, type, class all match. */
1761
1762
if (!ADD_RDLEN(header, p2, plen, rdlen2))
1763
return STAT_BOGUS;
1764
}
1765
1766
/* Not done, validate now */
1767
if (j == i)
1768
{
1769
int ttl, keytag, algo, digest, type_covered;
1770
unsigned char *psave;
1771
struct all_addr a;
1772
struct blockdata *key;
1773
struct crec *crecp;
1774
1775
rc = validate_rrset(now, header, plen, class1, type1, name, keyname, NULL, 0, 0, 0);
1776
1777
if (rc == STAT_SECURE_WILDCARD)
1778
{
1779
/* An attacker replay a wildcard answer with a different
1780
answer and overlay a genuine RR. To prove this
1781
hasn't happened, the answer must prove that
1782
the gennuine record doesn't exist. Check that here. */
1783
if (!nsec_type && !(nsec_type = find_nsec_records(header, plen, &nsecs, &nsec_count, class1)))
1784
return STAT_BOGUS; /* No NSECs or bad packet */
1785
1786
if (nsec_type == T_NSEC)
1787
rc = prove_non_existence_nsec(header, plen, nsecs, nsec_count, daemon->workspacename, keyname, name, type1);
1788
else
1789
rc = prove_non_existence_nsec3(header, plen, nsecs, nsec_count, daemon->workspacename, keyname, name, type1);
1790
1791
if (rc != STAT_SECURE)
1792
return rc;
1793
}
1794
else if (rc != STAT_SECURE)
1795
{
1796
if (class)
1797
*class = class1; /* Class for DS or DNSKEY */
1798
return rc;
1799
}
1800
1801
/* Cache RRsigs in answer section, and if we just validated a DS RRset, cache it */
1802
cache_start_insert();
1803
1804
for (p2 = ans_start, j = 0; j < ntohs(header->ancount); j++)
1805
{
1806
if (!(rc = extract_name(header, plen, &p2, name, 0, 10)))
1807
return STAT_BOGUS; /* bad packet */
1808
1809
GETSHORT(type2, p2);
1810
GETSHORT(class2, p2);
1811
GETLONG(ttl, p2);
1812
GETSHORT(rdlen2, p2);
1813
1814
if (!CHECK_LEN(header, p2, plen, rdlen2))
1815
return STAT_BOGUS; /* bad packet */
1816
1817
if (class2 == class1 && rc == 1)
1818
{
1819
psave = p2;
1820
1821
if (type1 == T_DS && type2 == T_DS)
1822
{
1823
if (rdlen2 < 4)
1824
return STAT_BOGUS; /* bad packet */
1825
1826
GETSHORT(keytag, p2);
1827
algo = *p2++;
1828
digest = *p2++;
1829
1830
/* Cache needs to known class for DNSSEC stuff */
1831
a.addr.dnssec.class = class2;
1832
1833
if ((key = blockdata_alloc((char*)p2, rdlen2 - 4)))
1834
{
1835
if (!(crecp = cache_insert(name, &a, now, ttl, F_FORWARD | F_DS | F_DNSSECOK)))
1836
blockdata_free(key);
1837
else
1838
{
1839
a.addr.keytag = keytag;
1840
log_query(F_KEYTAG | F_UPSTREAM, name, &a, "DS keytag %u");
1841
crecp->addr.ds.digest = digest;
1842
crecp->addr.ds.keydata = key;
1843
crecp->addr.ds.algo = algo;
1844
crecp->addr.ds.keytag = keytag;
1845
crecp->addr.ds.keylen = rdlen2 - 4;
1846
}
1847
}
1848
}
1849
else if (type2 == T_RRSIG)
1850
{
1851
if (rdlen2 < 18)
1852
return STAT_BOGUS; /* bad packet */
1853
1854
GETSHORT(type_covered, p2);
1855
1856
if (type_covered == type1 &&
1857
(type_covered == T_A || type_covered == T_AAAA ||
1858
type_covered == T_CNAME || type_covered == T_DS ||
1859
type_covered == T_DNSKEY || type_covered == T_PTR))
1860
{
1861
a.addr.dnssec.type = type_covered;
1862
a.addr.dnssec.class = class1;
1863
1864
algo = *p2++;
1865
p2 += 13; /* labels, orig_ttl, expiration, inception */
1866
GETSHORT(keytag, p2);
1867
1868
if ((key = blockdata_alloc((char*)psave, rdlen2)))
1869
{
1870
if (!(crecp = cache_insert(name, &a, now, ttl, F_FORWARD | F_DNSKEY | F_DS)))
1871
blockdata_free(key);
1872
else
1873
{
1874
crecp->addr.sig.keydata = key;
1875
crecp->addr.sig.keylen = rdlen2;
1876
crecp->addr.sig.keytag = keytag;
1877
crecp->addr.sig.type_covered = type_covered;
1878
crecp->addr.sig.algo = algo;
1879
}
1880
}
1881
}
1882
}
1883
1884
p2 = psave;
1885
}
1886
1887
if (!ADD_RDLEN(header, p2, plen, rdlen2))
1888
return STAT_BOGUS; /* bad packet */
1889
}
1890
1891
cache_end_insert();
1892
}
1893
}
1894
1895
if (!ADD_RDLEN(header, p1, plen, rdlen1))
1896
return STAT_BOGUS;
1897
}
1898
1899
/* OK, all the RRsets validate, now see if we have a NODATA or NXDOMAIN reply */
1900
if (have_answer)
1901
return STAT_SECURE;
1902
1903
/* NXDOMAIN or NODATA reply, prove that (name, class1, type1) can't exist */
1904
/* First marshall the NSEC records, if we've not done it previously */
1905
if (!nsec_type && !(nsec_type = find_nsec_records(header, plen, &nsecs, &nsec_count, qclass)))
1906
return STAT_BOGUS; /* No NSECs */
1907
1908
/* Get name of missing answer */
1909
if (!extract_name(header, plen, &qname, name, 1, 0))
1910
return STAT_BOGUS;
1911
1912
if (nsec_type == T_NSEC)
1913
return prove_non_existence_nsec(header, plen, nsecs, nsec_count, daemon->workspacename, keyname, name, qtype);
1914
else
1915
return prove_non_existence_nsec3(header, plen, nsecs, nsec_count, daemon->workspacename, keyname, name, qtype);
1916
}
1917
1918
/* Chase the CNAME chain in the packet until the first record which _doesn't validate.
1919
Needed for proving answer in unsigned space.
1920
Return STAT_NEED_*
1921
STAT_BOGUS - error
1922
STAT_INSECURE - name of first non-secure record in name
1923
*/
1924
int dnssec_chase_cname(time_t now, struct dns_header *header, size_t plen, char *name, char *keyname)
1925
{
1926
unsigned char *p = (unsigned char *)(header+1);
1927
int type, class, qclass, rdlen, j, rc;
1928
int cname_count = CNAME_CHAIN;
1929
1930
/* Get question */
1931
if (!extract_name(header, plen, &p, name, 1, 4))
1932
return STAT_BOGUS;
1933
1934
p +=2; /* type */
1935
GETSHORT(qclass, p);
1936
1937
while (1)
1938
{
1939
for (j = ntohs(header->ancount); j != 0; j--)
1940
{
1941
if (!(rc = extract_name(header, plen, &p, name, 0, 10)))
1942
return STAT_BOGUS; /* bad packet */
1943
1944
GETSHORT(type, p);
1945
GETSHORT(class, p);
1946
p += 4; /* TTL */
1947
GETSHORT(rdlen, p);
1948
1949
/* Not target, loop */
1950
if (rc == 2 || qclass != class)
1951
{
1952
if (!ADD_RDLEN(header, p, plen, rdlen))
1953
return STAT_BOGUS;
1954
continue;
1955
}
1956
1957
/* Got to end of CNAME chain. */
1958
if (type != T_CNAME)
1959
return STAT_INSECURE;
1960
1961
/* validate CNAME chain, return if insecure or need more data */
1962
rc = validate_rrset(now, header, plen, class, type, name, keyname, NULL, 0, 0, 0);
1963
if (rc != STAT_SECURE)
1964
{
1965
if (rc == STAT_NO_SIG)
1966
rc = STAT_INSECURE;
1967
return rc;
1968
}
1969
1970
/* Loop down CNAME chain/ */
1971
if (!cname_count-- ||
1972
!extract_name(header, plen, &p, name, 1, 0) ||
1973
!(p = skip_questions(header, plen)))
1974
return STAT_BOGUS;
1975
1976
break;
1977
}
1978
1979
/* End of CNAME chain */
1980
return STAT_INSECURE;
1981
}
1982
}
1983
1984
1985
/* Compute keytag (checksum to quickly index a key). See RFC4034 */
1986
int dnskey_keytag(int alg, int flags, unsigned char *key, int keylen)
1987
{
1988
if (alg == 1)
1989
{
1990
/* Algorithm 1 (RSAMD5) has a different (older) keytag calculation algorithm.
1991
See RFC4034, Appendix B.1 */
1992
return key[keylen-4] * 256 + key[keylen-3];
1993
}
1994
else
1995
{
1996
unsigned long ac = flags + 0x300 + alg;
1997
int i;
1998
1999
for (i = 0; i < keylen; ++i)
2000
ac += (i & 1) ? key[i] : key[i] << 8;
2001
2002
ac += (ac >> 16) & 0xffff;
2003
return ac & 0xffff;
2004
}
2005
}
2006
2007
size_t dnssec_generate_query(struct dns_header *header, char *end, char *name, int class, int type, union mysockaddr *addr)
2008
{
2009
unsigned char *p;
2010
char *types = querystr("dnssec-query", type);
2011
2012
if (addr->sa.sa_family == AF_INET)
2013
log_query(F_DNSSEC | F_IPV4, name, (struct all_addr *)&addr->in.sin_addr, types);
2014
#ifdef HAVE_IPV6
2015
else
2016
log_query(F_DNSSEC | F_IPV6, name, (struct all_addr *)&addr->in6.sin6_addr, types);
2017
#endif
2018
2019
header->qdcount = htons(1);
2020
header->ancount = htons(0);
2021
header->nscount = htons(0);
2022
header->arcount = htons(0);
2023
2024
header->hb3 = HB3_RD;
2025
SET_OPCODE(header, QUERY);
2026
/* For debugging, set Checking Disabled, otherwise, have the upstream check too,
2027
this allows it to select auth servers when one is returning bad data. */
2028
header->hb4 = option_bool(OPT_DNSSEC_DEBUG) ? HB4_CD : 0;
2029
2030
/* ID filled in later */
2031
2032
p = (unsigned char *)(header+1);
2033
2034
p = do_rfc1035_name(p, name);
2035
*p++ = 0;
2036
PUTSHORT(type, p);
2037
PUTSHORT(class, p);
2038
2039
return add_do_bit(header, p - (unsigned char *)header, end);
2040
}
2041
2042
/* Go through a domain name, find "pointers" and fix them up based on how many bytes
2043
we've chopped out of the packet, or check they don't point into an elided part. */
2044
static int check_name(unsigned char **namep, struct dns_header *header, size_t plen, int fixup, unsigned char **rrs, int rr_count)
2045
{
2046
unsigned char *ansp = *namep;
2047
2048
while(1)
2049
{
2050
unsigned int label_type;
2051
2052
if (!CHECK_LEN(header, ansp, plen, 1))
2053
return 0;
2054
2055
label_type = (*ansp) & 0xc0;
2056
2057
if (label_type == 0xc0)
2058
{
2059
/* pointer for compression. */
2060
unsigned int offset;
2061
int i;
2062
unsigned char *p;
2063
2064
if (!CHECK_LEN(header, ansp, plen, 2))
2065
return 0;
2066
2067
offset = ((*ansp++) & 0x3f) << 8;
2068
offset |= *ansp++;
2069
2070
p = offset + (unsigned char *)header;
2071
2072
for (i = 0; i < rr_count; i++)
2073
if (p < rrs[i])
2074
break;
2075
else
2076
if (i & 1)
2077
offset -= rrs[i] - rrs[i-1];
2078
2079
/* does the pointer end up in an elided RR? */
2080
if (i & 1)
2081
return 0;
2082
2083
/* No, scale the pointer */
2084
if (fixup)
2085
{
2086
ansp -= 2;
2087
*ansp++ = (offset >> 8) | 0xc0;
2088
*ansp++ = offset & 0xff;
2089
}
2090
break;
2091
}
2092
else if (label_type == 0x80)
2093
return 0; /* reserved */
2094
else if (label_type == 0x40)
2095
{
2096
/* Extended label type */
2097
unsigned int count;
2098
2099
if (!CHECK_LEN(header, ansp, plen, 2))
2100
return 0;
2101
2102
if (((*ansp++) & 0x3f) != 1)
2103
return 0; /* we only understand bitstrings */
2104
2105
count = *(ansp++); /* Bits in bitstring */
2106
2107
if (count == 0) /* count == 0 means 256 bits */
2108
ansp += 32;
2109
else
2110
ansp += ((count-1)>>3)+1;
2111
}
2112
else
2113
{ /* label type == 0 Bottom six bits is length */
2114
unsigned int len = (*ansp++) & 0x3f;
2115
2116
if (!ADD_RDLEN(header, ansp, plen, len))
2117
return 0;
2118
2119
if (len == 0)
2120
break; /* zero length label marks the end. */
2121
}
2122
}
2123
2124
*namep = ansp;
2125
2126
return 1;
2127
}
2128
2129
/* Go through RRs and check or fixup the domain names contained within */
2130
static int check_rrs(unsigned char *p, struct dns_header *header, size_t plen, int fixup, unsigned char **rrs, int rr_count)
2131
{
2132
int i, type, class, rdlen;
2133
unsigned char *pp;
2134
2135
for (i = 0; i < ntohs(header->ancount) + ntohs(header->nscount); i++)
2136
{
2137
pp = p;
2138
2139
if (!(p = skip_name(p, header, plen, 10)))
2140
return 0;
2141
2142
GETSHORT(type, p);
2143
GETSHORT(class, p);
2144
p += 4; /* TTL */
2145
GETSHORT(rdlen, p);
2146
2147
if (type != T_NSEC && type != T_NSEC3 && type != T_RRSIG)
2148
{
2149
/* fixup name of RR */
2150
if (!check_name(&pp, header, plen, fixup, rrs, rr_count))
2151
return 0;
2152
2153
if (class == C_IN)
2154
{
2155
u16 *d;
2156
2157
for (pp = p, d = get_desc(type); *d != (u16)-1; d++)
2158
{
2159
if (*d != 0)
2160
pp += *d;
2161
else if (!check_name(&pp, header, plen, fixup, rrs, rr_count))
2162
return 0;
2163
}
2164
}
2165
}
2166
2167
if (!ADD_RDLEN(header, p, plen, rdlen))
2168
return 0;
2169
}
2170
2171
return 1;
2172
}
2173
2174
2175
size_t filter_rrsigs(struct dns_header *header, size_t plen)
2176
{
2177
static unsigned char **rrs;
2178
static int rr_sz = 0;
2179
2180
unsigned char *p = (unsigned char *)(header+1);
2181
int i, rdlen, qtype, qclass, rr_found, chop_an, chop_ns;
2182
2183
if (ntohs(header->qdcount) != 1 ||
2184
!(p = skip_name(p, header, plen, 4)))
2185
return plen;
2186
2187
GETSHORT(qtype, p);
2188
GETSHORT(qclass, p);
2189
2190
/* First pass, find pointers to start and end of all the records we wish to elide:
2191
records added for DNSSEC, unless explicity queried for */
2192
for (rr_found = 0, chop_ns = 0, chop_an = 0, i = 0; i < ntohs(header->ancount) + ntohs(header->nscount); i++)
2193
{
2194
unsigned char *pstart = p;
2195
int type, class;
2196
2197
if (!(p = skip_name(p, header, plen, 10)))
2198
return plen;
2199
2200
GETSHORT(type, p);
2201
GETSHORT(class, p);
2202
p += 4; /* TTL */
2203
GETSHORT(rdlen, p);
2204
2205
if ((type == T_NSEC || type == T_NSEC3 || type == T_RRSIG) &&
2206
(type != qtype || class != qclass))
2207
{
2208
if (!expand_workspace(&rrs, &rr_sz, rr_found + 1))
2209
return plen;
2210
2211
rrs[rr_found++] = pstart;
2212
2213
if (!ADD_RDLEN(header, p, plen, rdlen))
2214
return plen;
2215
2216
rrs[rr_found++] = p;
2217
2218
if (i < ntohs(header->ancount))
2219
chop_an++;
2220
else
2221
chop_ns++;
2222
}
2223
else if (!ADD_RDLEN(header, p, plen, rdlen))
2224
return plen;
2225
}
2226
2227
/* Nothing to do. */
2228
if (rr_found == 0)
2229
return plen;
2230
2231
/* Second pass, look for pointers in names in the records we're keeping and make sure they don't
2232
point to records we're going to elide. This is theoretically possible, but unlikely. If
2233
it happens, we give up and leave the answer unchanged. */
2234
p = (unsigned char *)(header+1);
2235
2236
/* question first */
2237
if (!check_name(&p, header, plen, 0, rrs, rr_found))
2238
return plen;
2239
p += 4; /* qclass, qtype */
2240
2241
/* Now answers and NS */
2242
if (!check_rrs(p, header, plen, 0, rrs, rr_found))
2243
return plen;
2244
2245
/* Third pass, elide records */
2246
for (p = rrs[0], i = 1; i < rr_found; i += 2)
2247
{
2248
unsigned char *start = rrs[i];
2249
unsigned char *end = (i != rr_found - 1) ? rrs[i+1] : ((unsigned char *)(header+1)) + plen;
2250
2251
memmove(p, start, end-start);
2252
p += end-start;
2253
}
2254
2255
plen = p - (unsigned char *)header;
2256
header->ancount = htons(ntohs(header->ancount) - chop_an);
2257
header->nscount = htons(ntohs(header->nscount) - chop_ns);
2258
2259
/* Fourth pass, fix up pointers in the remaining records */
2260
p = (unsigned char *)(header+1);
2261
2262
check_name(&p, header, plen, 1, rrs, rr_found);
2263
p += 4; /* qclass, qtype */
2264
2265
check_rrs(p, header, plen, 1, rrs, rr_found);
2266
2267
return plen;
2268
}
2269
2270
unsigned char* hash_questions(struct dns_header *header, size_t plen, char *name)
2271
{
2272
int q;
2273
unsigned int len;
2274
unsigned char *p = (unsigned char *)(header+1);
2275
const struct nettle_hash *hash;
2276
void *ctx;
2277
unsigned char *digest;
2278
2279
if (!(hash = hash_find("sha1")) || !hash_init(hash, &ctx, &digest))
2280
return NULL;
2281
2282
for (q = ntohs(header->qdcount); q != 0; q--)
2283
{
2284
if (!extract_name(header, plen, &p, name, 1, 4))
2285
break; /* bad packet */
2286
2287
len = to_wire(name);
2288
hash->update(ctx, len, (unsigned char *)name);
2289
/* CRC the class and type as well */
2290
hash->update(ctx, 4, p);
2291
2292
p += 4;
2293
if (!CHECK_LEN(header, p, plen, 0))
2294
break; /* bad packet */
2295
}
2296
2297
hash->digest(ctx, hash->digest_size, digest);
2298
return digest;
2299
}
2300
2301
#endif /* HAVE_DNSSEC */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1