1 /*
2  * validator/val_kentry.c - validator key entry definition.
3  *
4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
5  *
6  * This software is open source.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * Redistributions of source code must retain the above copyright notice,
13  * this list of conditions and the following disclaimer.
14  *
15  * Redistributions in binary form must reproduce the above copyright notice,
16  * this list of conditions and the following disclaimer in the documentation
17  * and/or other materials provided with the distribution.
18  *
19  * Neither the name of the NLNET LABS nor the names of its contributors may
20  * be used to endorse or promote products derived from this software without
21  * specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35 
36 /**
37  * \file
38  *
39  * This file contains functions for dealing with validator key entries.
40  */
41 #include "config.h"
42 #include "validator/val_kentry.h"
43 #include "util/data/packed_rrset.h"
44 #include "util/data/dname.h"
45 #include "util/storage/lookup3.h"
46 #include "util/regional.h"
47 #include "util/net_help.h"
48 #include "sldns/rrdef.h"
49 #include "sldns/keyraw.h"
50 
51 size_t
key_entry_sizefunc(void * key,void * data)52 key_entry_sizefunc(void* key, void* data)
53 {
54 	struct key_entry_key* kk = (struct key_entry_key*)key;
55 	struct key_entry_data* kd = (struct key_entry_data*)data;
56 	size_t s = sizeof(*kk) + kk->namelen;
57 	s += sizeof(*kd) + lock_get_mem(&kk->entry.lock);
58 	if(kd->rrset_data)
59 		s += packed_rrset_sizeof(kd->rrset_data);
60 	if(kd->reason)
61 		s += strlen(kd->reason)+1;
62 	if(kd->algo)
63 		s += strlen((char*)kd->algo)+1;
64 	return s;
65 }
66 
67 int
key_entry_compfunc(void * k1,void * k2)68 key_entry_compfunc(void* k1, void* k2)
69 {
70 	struct key_entry_key* n1 = (struct key_entry_key*)k1;
71 	struct key_entry_key* n2 = (struct key_entry_key*)k2;
72 	if(n1->key_class != n2->key_class) {
73 		if(n1->key_class < n2->key_class)
74 			return -1;
75 		return 1;
76 	}
77 	return query_dname_compare(n1->name, n2->name);
78 }
79 
80 void
key_entry_delkeyfunc(void * key,void * ATTR_UNUSED (userarg))81 key_entry_delkeyfunc(void* key, void* ATTR_UNUSED(userarg))
82 {
83 	struct key_entry_key* kk = (struct key_entry_key*)key;
84 	if(!key)
85 		return;
86 	lock_rw_destroy(&kk->entry.lock);
87 	free(kk->name);
88 	free(kk);
89 }
90 
91 void
key_entry_deldatafunc(void * data,void * ATTR_UNUSED (userarg))92 key_entry_deldatafunc(void* data, void* ATTR_UNUSED(userarg))
93 {
94 	struct key_entry_data* kd = (struct key_entry_data*)data;
95 	free(kd->reason);
96 	free(kd->rrset_data);
97 	free(kd->algo);
98 	free(kd);
99 }
100 
101 void
key_entry_hash(struct key_entry_key * kk)102 key_entry_hash(struct key_entry_key* kk)
103 {
104 	kk->entry.hash = 0x654;
105 	kk->entry.hash = hashlittle(&kk->key_class, sizeof(kk->key_class),
106 		kk->entry.hash);
107 	kk->entry.hash = dname_query_hash(kk->name, kk->entry.hash);
108 }
109 
110 struct key_entry_key*
key_entry_copy_toregion(struct key_entry_key * kkey,struct regional * region)111 key_entry_copy_toregion(struct key_entry_key* kkey, struct regional* region)
112 {
113 	struct key_entry_key* newk;
114 	newk = regional_alloc_init(region, kkey, sizeof(*kkey));
115 	if(!newk)
116 		return NULL;
117 	newk->name = regional_alloc_init(region, kkey->name, kkey->namelen);
118 	if(!newk->name)
119 		return NULL;
120 	newk->entry.key = newk;
121 	if(newk->entry.data) {
122 		/* copy data element */
123 		struct key_entry_data *d = (struct key_entry_data*)
124 			kkey->entry.data;
125 		struct key_entry_data *newd;
126 		newd = regional_alloc_init(region, d, sizeof(*d));
127 		if(!newd)
128 			return NULL;
129 		/* copy rrset */
130 		if(d->rrset_data) {
131 			newd->rrset_data = regional_alloc_init(region,
132 				d->rrset_data,
133 				packed_rrset_sizeof(d->rrset_data));
134 			if(!newd->rrset_data)
135 				return NULL;
136 			packed_rrset_ptr_fixup(newd->rrset_data);
137 		}
138 		if(d->reason) {
139 			newd->reason = regional_strdup(region, d->reason);
140 			if(!newd->reason)
141 				return NULL;
142 		}
143 		if(d->algo) {
144 			newd->algo = (uint8_t*)regional_strdup(region,
145 				(char*)d->algo);
146 			if(!newd->algo)
147 				return NULL;
148 		}
149 		newk->entry.data = newd;
150 	}
151 	return newk;
152 }
153 
154 struct key_entry_key*
key_entry_copy(struct key_entry_key * kkey)155 key_entry_copy(struct key_entry_key* kkey)
156 {
157 	struct key_entry_key* newk;
158 	if(!kkey)
159 		return NULL;
160 	newk = memdup(kkey, sizeof(*kkey));
161 	if(!newk)
162 		return NULL;
163 	newk->name = memdup(kkey->name, kkey->namelen);
164 	if(!newk->name) {
165 		free(newk);
166 		return NULL;
167 	}
168 	lock_rw_init(&newk->entry.lock);
169 	newk->entry.key = newk;
170 	if(newk->entry.data) {
171 		/* copy data element */
172 		struct key_entry_data *d = (struct key_entry_data*)
173 			kkey->entry.data;
174 		struct key_entry_data *newd;
175 		newd = memdup(d, sizeof(*d));
176 		if(!newd) {
177 			free(newk->name);
178 			free(newk);
179 			return NULL;
180 		}
181 		/* copy rrset */
182 		if(d->rrset_data) {
183 			newd->rrset_data = memdup(d->rrset_data,
184 				packed_rrset_sizeof(d->rrset_data));
185 			if(!newd->rrset_data) {
186 				free(newd);
187 				free(newk->name);
188 				free(newk);
189 				return NULL;
190 			}
191 			packed_rrset_ptr_fixup(newd->rrset_data);
192 		}
193 		if(d->reason) {
194 			newd->reason = strdup(d->reason);
195 			if(!newd->reason) {
196 				free(newd->rrset_data);
197 				free(newd);
198 				free(newk->name);
199 				free(newk);
200 				return NULL;
201 			}
202 		}
203 		if(d->algo) {
204 			newd->algo = (uint8_t*)strdup((char*)d->algo);
205 			if(!newd->algo) {
206 				free(newd->rrset_data);
207 				free(newd->reason);
208 				free(newd);
209 				free(newk->name);
210 				free(newk);
211 				return NULL;
212 			}
213 		}
214 		newk->entry.data = newd;
215 	}
216 	return newk;
217 }
218 
219 int
key_entry_isnull(struct key_entry_key * kkey)220 key_entry_isnull(struct key_entry_key* kkey)
221 {
222 	struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
223 	return (!d->isbad && d->rrset_data == NULL);
224 }
225 
226 int
key_entry_isgood(struct key_entry_key * kkey)227 key_entry_isgood(struct key_entry_key* kkey)
228 {
229 	struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
230 	return (!d->isbad && d->rrset_data != NULL);
231 }
232 
233 int
key_entry_isbad(struct key_entry_key * kkey)234 key_entry_isbad(struct key_entry_key* kkey)
235 {
236 	struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
237 	return (int)(d->isbad);
238 }
239 
240 void
key_entry_set_reason(struct key_entry_key * kkey,char * reason)241 key_entry_set_reason(struct key_entry_key* kkey, char* reason)
242 {
243 	struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
244 	d->reason = reason;
245 }
246 
247 char*
key_entry_get_reason(struct key_entry_key * kkey)248 key_entry_get_reason(struct key_entry_key* kkey)
249 {
250 	struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
251 	return d->reason;
252 }
253 
254 /** setup key entry in region */
255 static int
key_entry_setup(struct regional * region,uint8_t * name,size_t namelen,uint16_t dclass,struct key_entry_key ** k,struct key_entry_data ** d)256 key_entry_setup(struct regional* region,
257 	uint8_t* name, size_t namelen, uint16_t dclass,
258 	struct key_entry_key** k, struct key_entry_data** d)
259 {
260 	*k = regional_alloc(region, sizeof(**k));
261 	if(!*k)
262 		return 0;
263 	memset(*k, 0, sizeof(**k));
264 	(*k)->entry.key = *k;
265 	(*k)->name = regional_alloc_init(region, name, namelen);
266 	if(!(*k)->name)
267 		return 0;
268 	(*k)->namelen = namelen;
269 	(*k)->key_class = dclass;
270 	*d = regional_alloc(region, sizeof(**d));
271 	if(!*d)
272 		return 0;
273 	(*k)->entry.data = *d;
274 	return 1;
275 }
276 
277 struct key_entry_key*
key_entry_create_null(struct regional * region,uint8_t * name,size_t namelen,uint16_t dclass,time_t ttl,time_t now)278 key_entry_create_null(struct regional* region,
279 	uint8_t* name, size_t namelen, uint16_t dclass, time_t ttl,
280 	time_t now)
281 {
282 	struct key_entry_key* k;
283 	struct key_entry_data* d;
284 	if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
285 		return NULL;
286 	d->ttl = now + ttl;
287 	d->isbad = 0;
288 	d->reason = NULL;
289 	d->rrset_type = LDNS_RR_TYPE_DNSKEY;
290 	d->rrset_data = NULL;
291 	d->algo = NULL;
292 	return k;
293 }
294 
295 struct key_entry_key*
key_entry_create_rrset(struct regional * region,uint8_t * name,size_t namelen,uint16_t dclass,struct ub_packed_rrset_key * rrset,uint8_t * sigalg,time_t now)296 key_entry_create_rrset(struct regional* region,
297 	uint8_t* name, size_t namelen, uint16_t dclass,
298 	struct ub_packed_rrset_key* rrset, uint8_t* sigalg, time_t now)
299 {
300 	struct key_entry_key* k;
301 	struct key_entry_data* d;
302 	struct packed_rrset_data* rd = (struct packed_rrset_data*)
303 		rrset->entry.data;
304 	if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
305 		return NULL;
306 	d->ttl = rd->ttl + now;
307 	d->isbad = 0;
308 	d->reason = NULL;
309 	d->rrset_type = ntohs(rrset->rk.type);
310 	d->rrset_data = (struct packed_rrset_data*)regional_alloc_init(region,
311 		rd, packed_rrset_sizeof(rd));
312 	if(!d->rrset_data)
313 		return NULL;
314 	if(sigalg) {
315 		d->algo = (uint8_t*)regional_strdup(region, (char*)sigalg);
316 		if(!d->algo)
317 			return NULL;
318 	} else d->algo = NULL;
319 	packed_rrset_ptr_fixup(d->rrset_data);
320 	return k;
321 }
322 
323 struct key_entry_key*
key_entry_create_bad(struct regional * region,uint8_t * name,size_t namelen,uint16_t dclass,time_t ttl,time_t now)324 key_entry_create_bad(struct regional* region,
325 	uint8_t* name, size_t namelen, uint16_t dclass, time_t ttl,
326 	time_t now)
327 {
328 	struct key_entry_key* k;
329 	struct key_entry_data* d;
330 	if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
331 		return NULL;
332 	d->ttl = now + ttl;
333 	d->isbad = 1;
334 	d->reason = NULL;
335 	d->rrset_type = LDNS_RR_TYPE_DNSKEY;
336 	d->rrset_data = NULL;
337 	d->algo = NULL;
338 	return k;
339 }
340 
341 struct ub_packed_rrset_key*
key_entry_get_rrset(struct key_entry_key * kkey,struct regional * region)342 key_entry_get_rrset(struct key_entry_key* kkey, struct regional* region)
343 {
344 	struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
345 	struct ub_packed_rrset_key* rrk;
346 	struct packed_rrset_data* rrd;
347 	if(!d || !d->rrset_data)
348 		return NULL;
349 	rrk = regional_alloc(region, sizeof(*rrk));
350 	if(!rrk)
351 		return NULL;
352 	memset(rrk, 0, sizeof(*rrk));
353 	rrk->rk.dname = regional_alloc_init(region, kkey->name, kkey->namelen);
354 	if(!rrk->rk.dname)
355 		return NULL;
356 	rrk->rk.dname_len = kkey->namelen;
357 	rrk->rk.type = htons(d->rrset_type);
358 	rrk->rk.rrset_class = htons(kkey->key_class);
359 	rrk->entry.key = rrk;
360 	rrd = regional_alloc_init(region, d->rrset_data,
361 		packed_rrset_sizeof(d->rrset_data));
362 	if(!rrd)
363 		return NULL;
364 	rrk->entry.data = rrd;
365 	packed_rrset_ptr_fixup(rrd);
366 	return rrk;
367 }
368 
369 /** Get size of key in keyset */
370 static size_t
dnskey_get_keysize(struct packed_rrset_data * data,size_t idx)371 dnskey_get_keysize(struct packed_rrset_data* data, size_t idx)
372 {
373 	unsigned char* pk;
374 	unsigned int pklen = 0;
375 	int algo;
376 	if(data->rr_len[idx] < 2+5)
377 		return 0;
378 	algo = (int)data->rr_data[idx][2+3];
379 	pk = (unsigned char*)data->rr_data[idx]+2+4;
380 	pklen = (unsigned)data->rr_len[idx]-2-4;
381 	return sldns_rr_dnskey_key_size_raw(pk, pklen, algo);
382 }
383 
384 /** get dnskey flags from data */
385 static uint16_t
kd_get_flags(struct packed_rrset_data * data,size_t idx)386 kd_get_flags(struct packed_rrset_data* data, size_t idx)
387 {
388 	uint16_t f;
389 	if(data->rr_len[idx] < 2+2)
390 		return 0;
391 	memmove(&f, data->rr_data[idx]+2, 2);
392 	f = ntohs(f);
393 	return f;
394 }
395 
396 size_t
key_entry_keysize(struct key_entry_key * kkey)397 key_entry_keysize(struct key_entry_key* kkey)
398 {
399 	struct packed_rrset_data* d;
400 	/* compute size of smallest ZSK key in the rrset */
401 	size_t i;
402 	size_t bits = 0;
403 	if(!key_entry_isgood(kkey))
404 		return 0;
405 	d = ((struct key_entry_data*)kkey->entry.data)->rrset_data;
406 	for(i=0; i<d->count; i++) {
407 		if(!(kd_get_flags(d, i) & DNSKEY_BIT_ZSK))
408 			continue;
409 		if(i==0 || dnskey_get_keysize(d, i) < bits)
410 			bits = dnskey_get_keysize(d, i);
411 	}
412 	return bits;
413 }
414