1 /*
2 * Copyright (C) 2009, 2011-2013, 2015 Internet Systems Consortium, Inc. ("ISC")
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
10 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
13 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
14 * PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #ifndef GENERIC_KEYDATA_65533_C
18 #define GENERIC_KEYDATA_65533_C 1
19
20 #include <isc/time.h>
21 #include <isc/stdtime.h>
22
23 #include <dst/dst.h>
24
25 #define RRTYPE_KEYDATA_ATTRIBUTES (0)
26
27 static inline isc_result_t
fromtext_keydata(ARGS_FROMTEXT)28 fromtext_keydata(ARGS_FROMTEXT) {
29 isc_result_t result;
30 isc_token_t token;
31 dns_secalg_t alg;
32 dns_secproto_t proto;
33 dns_keyflags_t flags;
34 isc_uint32_t refresh, addhd, removehd;
35
36 REQUIRE(type == dns_rdatatype_keydata);
37
38 UNUSED(type);
39 UNUSED(rdclass);
40 UNUSED(origin);
41 UNUSED(options);
42 UNUSED(callbacks);
43
44 /* refresh timer */
45 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
46 ISC_FALSE));
47 RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &refresh));
48 RETERR(uint32_tobuffer(refresh, target));
49
50 /* add hold-down */
51 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
52 ISC_FALSE));
53 RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &addhd));
54 RETERR(uint32_tobuffer(addhd, target));
55
56 /* remove hold-down */
57 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
58 ISC_FALSE));
59 RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &removehd));
60 RETERR(uint32_tobuffer(removehd, target));
61
62 /* flags */
63 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
64 ISC_FALSE));
65 RETTOK(dns_keyflags_fromtext(&flags, &token.value.as_textregion));
66 RETERR(uint16_tobuffer(flags, target));
67
68 /* protocol */
69 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
70 ISC_FALSE));
71 RETTOK(dns_secproto_fromtext(&proto, &token.value.as_textregion));
72 RETERR(mem_tobuffer(target, &proto, 1));
73
74 /* algorithm */
75 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
76 ISC_FALSE));
77 RETTOK(dns_secalg_fromtext(&alg, &token.value.as_textregion));
78 RETERR(mem_tobuffer(target, &alg, 1));
79
80 /* No Key? */
81 if ((flags & 0xc000) == 0xc000)
82 return (ISC_R_SUCCESS);
83
84 result = isc_base64_tobuffer(lexer, target, -1);
85 if (result != ISC_R_SUCCESS)
86 return (result);
87
88 /* Ensure there's at least enough data to compute a key ID for MD5 */
89 if (alg == DST_ALG_RSAMD5 && isc_buffer_usedlength(target) < 19)
90 return (ISC_R_UNEXPECTEDEND);
91
92 return (ISC_R_SUCCESS);
93 }
94
95 static inline isc_result_t
totext_keydata(ARGS_TOTEXT)96 totext_keydata(ARGS_TOTEXT) {
97 isc_region_t sr;
98 char buf[sizeof("64000")];
99 unsigned int flags;
100 unsigned char algorithm;
101 unsigned long refresh, add, delete;
102 char algbuf[DNS_NAME_FORMATSIZE];
103 const char *keyinfo;
104
105 REQUIRE(rdata->type == dns_rdatatype_keydata);
106
107 if ((tctx->flags & DNS_STYLEFLAG_KEYDATA) == 0 || rdata->length < 16)
108 return (unknown_totext(rdata, tctx, target));
109
110 dns_rdata_toregion(rdata, &sr);
111
112 /* refresh timer */
113 refresh = uint32_fromregion(&sr);
114 isc_region_consume(&sr, 4);
115 RETERR(dns_time32_totext(refresh, target));
116 RETERR(str_totext(" ", target));
117
118 /* add hold-down */
119 add = uint32_fromregion(&sr);
120 isc_region_consume(&sr, 4);
121 RETERR(dns_time32_totext(add, target));
122 RETERR(str_totext(" ", target));
123
124 /* remove hold-down */
125 delete = uint32_fromregion(&sr);
126 isc_region_consume(&sr, 4);
127 RETERR(dns_time32_totext(delete, target));
128 RETERR(str_totext(" ", target));
129
130 /* flags */
131 flags = uint16_fromregion(&sr);
132 isc_region_consume(&sr, 2);
133 sprintf(buf, "%u", flags);
134 RETERR(str_totext(buf, target));
135 RETERR(str_totext(" ", target));
136 if ((flags & DNS_KEYFLAG_KSK) != 0) {
137 if (flags & DNS_KEYFLAG_REVOKE)
138 keyinfo = "revoked KSK";
139 else
140 keyinfo = "KSK";
141 } else
142 keyinfo = "ZSK";
143
144 /* protocol */
145 sprintf(buf, "%u", sr.base[0]);
146 isc_region_consume(&sr, 1);
147 RETERR(str_totext(buf, target));
148 RETERR(str_totext(" ", target));
149
150 /* algorithm */
151 algorithm = sr.base[0];
152 sprintf(buf, "%u", algorithm);
153 isc_region_consume(&sr, 1);
154 RETERR(str_totext(buf, target));
155
156 /* No Key? */
157 if ((flags & 0xc000) == 0xc000)
158 return (ISC_R_SUCCESS);
159
160 /* key */
161 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
162 RETERR(str_totext(" (", target));
163 RETERR(str_totext(tctx->linebreak, target));
164 if (tctx->width == 0) /* No splitting */
165 RETERR(isc_base64_totext(&sr, 60, "", target));
166 else
167 RETERR(isc_base64_totext(&sr, tctx->width - 2,
168 tctx->linebreak, target));
169
170 if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0)
171 RETERR(str_totext(tctx->linebreak, target));
172 else if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
173 RETERR(str_totext(" ", target));
174
175 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
176 RETERR(str_totext(")", target));
177
178 if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0) {
179 isc_region_t tmpr;
180 char rbuf[ISC_FORMATHTTPTIMESTAMP_SIZE];
181 char abuf[ISC_FORMATHTTPTIMESTAMP_SIZE];
182 char dbuf[ISC_FORMATHTTPTIMESTAMP_SIZE];
183 isc_time_t t;
184
185 RETERR(str_totext(" ; ", target));
186 RETERR(str_totext(keyinfo, target));
187 dns_secalg_format((dns_secalg_t) algorithm, algbuf,
188 sizeof(algbuf));
189 RETERR(str_totext("; alg = ", target));
190 RETERR(str_totext(algbuf, target));
191 RETERR(str_totext("; key id = ", target));
192 dns_rdata_toregion(rdata, &tmpr);
193 /* Skip over refresh, addhd, and removehd */
194 isc_region_consume(&tmpr, 12);
195 sprintf(buf, "%u", dst_region_computeid(&tmpr, algorithm));
196 RETERR(str_totext(buf, target));
197
198 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
199 isc_stdtime_t now;
200
201 isc_stdtime_get(&now);
202
203 RETERR(str_totext(tctx->linebreak, target));
204 RETERR(str_totext("; next refresh: ", target));
205 isc_time_set(&t, refresh, 0);
206 isc_time_formathttptimestamp(&t, rbuf, sizeof(rbuf));
207 RETERR(str_totext(rbuf, target));
208
209 if (add == 0U) {
210 RETERR(str_totext(tctx->linebreak, target));
211 RETERR(str_totext("; no trust", target));
212 } else {
213 RETERR(str_totext(tctx->linebreak, target));
214 if (add < now) {
215 RETERR(str_totext("; trusted since: ",
216 target));
217 } else {
218 RETERR(str_totext("; trust pending: ",
219 target));
220 }
221 isc_time_set(&t, add, 0);
222 isc_time_formathttptimestamp(&t, abuf,
223 sizeof(abuf));
224 RETERR(str_totext(abuf, target));
225 }
226
227 if (delete != 0U) {
228 RETERR(str_totext(tctx->linebreak, target));
229 RETERR(str_totext("; removal pending: ",
230 target));
231 isc_time_set(&t, delete, 0);
232 isc_time_formathttptimestamp(&t, dbuf,
233 sizeof(dbuf));
234 RETERR(str_totext(dbuf, target));
235 }
236 }
237
238 }
239 return (ISC_R_SUCCESS);
240 }
241
242 static inline isc_result_t
fromwire_keydata(ARGS_FROMWIRE)243 fromwire_keydata(ARGS_FROMWIRE) {
244 isc_region_t sr;
245
246 REQUIRE(type == dns_rdatatype_keydata);
247
248 UNUSED(type);
249 UNUSED(rdclass);
250 UNUSED(dctx);
251 UNUSED(options);
252
253 isc_buffer_activeregion(source, &sr);
254 isc_buffer_forward(source, sr.length);
255 return (mem_tobuffer(target, sr.base, sr.length));
256 }
257
258 static inline isc_result_t
towire_keydata(ARGS_TOWIRE)259 towire_keydata(ARGS_TOWIRE) {
260 isc_region_t sr;
261
262 REQUIRE(rdata->type == dns_rdatatype_keydata);
263
264 UNUSED(cctx);
265
266 dns_rdata_toregion(rdata, &sr);
267 return (mem_tobuffer(target, sr.base, sr.length));
268 }
269
270 static inline int
compare_keydata(ARGS_COMPARE)271 compare_keydata(ARGS_COMPARE) {
272 isc_region_t r1;
273 isc_region_t r2;
274
275 REQUIRE(rdata1->type == rdata2->type);
276 REQUIRE(rdata1->rdclass == rdata2->rdclass);
277 REQUIRE(rdata1->type == dns_rdatatype_keydata);
278
279 dns_rdata_toregion(rdata1, &r1);
280 dns_rdata_toregion(rdata2, &r2);
281 return (isc_region_compare(&r1, &r2));
282 }
283
284 static inline isc_result_t
fromstruct_keydata(ARGS_FROMSTRUCT)285 fromstruct_keydata(ARGS_FROMSTRUCT) {
286 dns_rdata_keydata_t *keydata = source;
287
288 REQUIRE(type == dns_rdatatype_keydata);
289 REQUIRE(source != NULL);
290 REQUIRE(keydata->common.rdtype == type);
291 REQUIRE(keydata->common.rdclass == rdclass);
292
293 UNUSED(type);
294 UNUSED(rdclass);
295
296 /* Refresh timer */
297 RETERR(uint32_tobuffer(keydata->refresh, target));
298
299 /* Add hold-down */
300 RETERR(uint32_tobuffer(keydata->addhd, target));
301
302 /* Remove hold-down */
303 RETERR(uint32_tobuffer(keydata->removehd, target));
304
305 /* Flags */
306 RETERR(uint16_tobuffer(keydata->flags, target));
307
308 /* Protocol */
309 RETERR(uint8_tobuffer(keydata->protocol, target));
310
311 /* Algorithm */
312 RETERR(uint8_tobuffer(keydata->algorithm, target));
313
314 /* Data */
315 return (mem_tobuffer(target, keydata->data, keydata->datalen));
316 }
317
318 static inline isc_result_t
tostruct_keydata(ARGS_TOSTRUCT)319 tostruct_keydata(ARGS_TOSTRUCT) {
320 dns_rdata_keydata_t *keydata = target;
321 isc_region_t sr;
322
323 REQUIRE(rdata->type == dns_rdatatype_keydata);
324 REQUIRE(target != NULL);
325
326 keydata->common.rdclass = rdata->rdclass;
327 keydata->common.rdtype = rdata->type;
328 ISC_LINK_INIT(&keydata->common, link);
329
330 dns_rdata_toregion(rdata, &sr);
331
332 /* Refresh timer */
333 if (sr.length < 4)
334 return (ISC_R_UNEXPECTEDEND);
335 keydata->refresh = uint32_fromregion(&sr);
336 isc_region_consume(&sr, 4);
337
338 /* Add hold-down */
339 if (sr.length < 4)
340 return (ISC_R_UNEXPECTEDEND);
341 keydata->addhd = uint32_fromregion(&sr);
342 isc_region_consume(&sr, 4);
343
344 /* Remove hold-down */
345 if (sr.length < 4)
346 return (ISC_R_UNEXPECTEDEND);
347 keydata->removehd = uint32_fromregion(&sr);
348 isc_region_consume(&sr, 4);
349
350 /* Flags */
351 if (sr.length < 2)
352 return (ISC_R_UNEXPECTEDEND);
353 keydata->flags = uint16_fromregion(&sr);
354 isc_region_consume(&sr, 2);
355
356 /* Protocol */
357 if (sr.length < 1)
358 return (ISC_R_UNEXPECTEDEND);
359 keydata->protocol = uint8_fromregion(&sr);
360 isc_region_consume(&sr, 1);
361
362 /* Algorithm */
363 if (sr.length < 1)
364 return (ISC_R_UNEXPECTEDEND);
365 keydata->algorithm = uint8_fromregion(&sr);
366 isc_region_consume(&sr, 1);
367
368 /* Data */
369 keydata->datalen = sr.length;
370 keydata->data = mem_maybedup(mctx, sr.base, keydata->datalen);
371 if (keydata->data == NULL)
372 return (ISC_R_NOMEMORY);
373
374 keydata->mctx = mctx;
375 return (ISC_R_SUCCESS);
376 }
377
378 static inline void
freestruct_keydata(ARGS_FREESTRUCT)379 freestruct_keydata(ARGS_FREESTRUCT) {
380 dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source;
381
382 REQUIRE(source != NULL);
383 REQUIRE(keydata->common.rdtype == dns_rdatatype_keydata);
384
385 if (keydata->mctx == NULL)
386 return;
387
388 if (keydata->data != NULL)
389 isc_mem_free(keydata->mctx, keydata->data);
390 keydata->mctx = NULL;
391 }
392
393 static inline isc_result_t
additionaldata_keydata(ARGS_ADDLDATA)394 additionaldata_keydata(ARGS_ADDLDATA) {
395 REQUIRE(rdata->type == dns_rdatatype_keydata);
396
397 UNUSED(rdata);
398 UNUSED(add);
399 UNUSED(arg);
400
401 return (ISC_R_SUCCESS);
402 }
403
404 static inline isc_result_t
digest_keydata(ARGS_DIGEST)405 digest_keydata(ARGS_DIGEST) {
406 isc_region_t r;
407
408 REQUIRE(rdata->type == dns_rdatatype_keydata);
409
410 dns_rdata_toregion(rdata, &r);
411
412 return ((digest)(arg, &r));
413 }
414
415 static inline isc_boolean_t
checkowner_keydata(ARGS_CHECKOWNER)416 checkowner_keydata(ARGS_CHECKOWNER) {
417
418 REQUIRE(type == dns_rdatatype_keydata);
419
420 UNUSED(name);
421 UNUSED(type);
422 UNUSED(rdclass);
423 UNUSED(wildcard);
424
425 return (ISC_TRUE);
426 }
427
428 static inline isc_boolean_t
checknames_keydata(ARGS_CHECKNAMES)429 checknames_keydata(ARGS_CHECKNAMES) {
430
431 REQUIRE(rdata->type == dns_rdatatype_keydata);
432
433 UNUSED(rdata);
434 UNUSED(owner);
435 UNUSED(bad);
436
437 return (ISC_TRUE);
438 }
439
440 static inline int
casecompare_keydata(ARGS_COMPARE)441 casecompare_keydata(ARGS_COMPARE) {
442 return (compare_keydata(rdata1, rdata2));
443 }
444
445 #endif /* GENERIC_KEYDATA_65533_C */
446