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
51size_t
52key_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
67int
68key_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
80void
81key_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
91void
92key_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
101void
102key_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
110struct key_entry_key*
111key_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
154struct key_entry_key*
155key_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
219int
220key_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
226int
227key_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
233int
234key_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
240void
241key_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
247char*
248key_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 */
255static int
256key_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
277struct key_entry_key*
278key_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
295struct key_entry_key*
296key_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
323struct key_entry_key*
324key_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
341struct ub_packed_rrset_key*
342key_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 */
370static size_t
371dnskey_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 */
385static uint16_t
386kd_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
396size_t
397key_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