1 /*
2 * tsig.c
3 *
4 * contains the functions needed for TSIG [RFC2845]
5 *
6 * (c) 2005-2006 NLnet Labs
7 * See the file LICENSE for the license
8 */
9
10 #include <ldns/config.h>
11
12 #include <ldns/ldns.h>
13
14 #include <strings.h>
15
16 #ifdef HAVE_SSL
17 #include <openssl/hmac.h>
18 #include <openssl/md5.h>
19 #endif /* HAVE_SSL */
20
21 const char *
ldns_tsig_algorithm(const ldns_tsig_credentials * tc)22 ldns_tsig_algorithm(const ldns_tsig_credentials *tc)
23 {
24 return tc->algorithm;
25 }
26
27 const char *
ldns_tsig_keyname(const ldns_tsig_credentials * tc)28 ldns_tsig_keyname(const ldns_tsig_credentials *tc)
29 {
30 return tc->keyname;
31 }
32
33 const char *
ldns_tsig_keydata(const ldns_tsig_credentials * tc)34 ldns_tsig_keydata(const ldns_tsig_credentials *tc)
35 {
36 return tc->keydata;
37 }
38
39 char *
ldns_tsig_keyname_clone(const ldns_tsig_credentials * tc)40 ldns_tsig_keyname_clone(const ldns_tsig_credentials *tc)
41 {
42 return strdup(tc->keyname);
43 }
44
45 char *
ldns_tsig_keydata_clone(const ldns_tsig_credentials * tc)46 ldns_tsig_keydata_clone(const ldns_tsig_credentials *tc)
47 {
48 return strdup(tc->keydata);
49 }
50
51 /*
52 * Makes an exact copy of the wire, but with the tsig rr removed
53 */
54 static uint8_t *
ldns_tsig_prepare_pkt_wire(const uint8_t * wire,size_t wire_len,size_t * result_len)55 ldns_tsig_prepare_pkt_wire(const uint8_t *wire, size_t wire_len, size_t *result_len)
56 {
57 uint8_t *wire2 = NULL;
58 uint16_t qd_count;
59 uint16_t an_count;
60 uint16_t ns_count;
61 uint16_t ar_count;
62 ldns_rr *rr;
63
64 size_t pos;
65 uint16_t i;
66
67 ldns_status status;
68
69 if(wire_len < LDNS_HEADER_SIZE) {
70 return NULL;
71 }
72 /* fake parse the wire */
73 qd_count = LDNS_QDCOUNT(wire);
74 an_count = LDNS_ANCOUNT(wire);
75 ns_count = LDNS_NSCOUNT(wire);
76 ar_count = LDNS_ARCOUNT(wire);
77
78 if (ar_count > 0) {
79 ar_count--;
80 } else {
81 return NULL;
82 }
83
84 pos = LDNS_HEADER_SIZE;
85
86 for (i = 0; i < qd_count; i++) {
87 status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_QUESTION);
88 if (status != LDNS_STATUS_OK) {
89 return NULL;
90 }
91 ldns_rr_free(rr);
92 }
93
94 for (i = 0; i < an_count; i++) {
95 status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_ANSWER);
96 if (status != LDNS_STATUS_OK) {
97 return NULL;
98 }
99 ldns_rr_free(rr);
100 }
101
102 for (i = 0; i < ns_count; i++) {
103 status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_AUTHORITY);
104 if (status != LDNS_STATUS_OK) {
105 return NULL;
106 }
107 ldns_rr_free(rr);
108 }
109
110 for (i = 0; i < ar_count; i++) {
111 status = ldns_wire2rr(&rr, wire, wire_len, &pos,
112 LDNS_SECTION_ADDITIONAL);
113 if (status != LDNS_STATUS_OK) {
114 return NULL;
115 }
116 ldns_rr_free(rr);
117 }
118
119 *result_len = pos;
120 wire2 = LDNS_XMALLOC(uint8_t, *result_len);
121 if(!wire2) {
122 return NULL;
123 }
124 memcpy(wire2, wire, *result_len);
125
126 ldns_write_uint16(wire2 + LDNS_ARCOUNT_OFF, ar_count);
127
128 return wire2;
129 }
130
131 #ifdef HAVE_SSL
132 static const EVP_MD *
ldns_digest_function(char * name)133 ldns_digest_function(char *name)
134 {
135 /* these are the mandatory algorithms from RFC4635 */
136 /* The optional algorithms are not yet implemented */
137 if (strcasecmp(name, "hmac-sha512.") == 0) {
138 #ifdef HAVE_EVP_SHA512
139 return EVP_sha512();
140 #else
141 return NULL;
142 #endif
143 } else if (strcasecmp(name, "hmac-shac384.") == 0) {
144 #ifdef HAVE_EVP_SHA384
145 return EVP_sha384();
146 #else
147 return NULL;
148 #endif
149 } else if (strcasecmp(name, "hmac-sha256.") == 0) {
150 #ifdef HAVE_EVP_SHA256
151 return EVP_sha256();
152 #else
153 return NULL;
154 #endif
155 } else if (strcasecmp(name, "hmac-sha1.") == 0) {
156 return EVP_sha1();
157 } else if (strcasecmp(name, "hmac-md5.sig-alg.reg.int.") == 0) {
158 return EVP_md5();
159 } else {
160 return NULL;
161 }
162 }
163 #endif
164
165 #ifdef HAVE_SSL
166 static ldns_status
ldns_tsig_mac_new(ldns_rdf ** tsig_mac,const uint8_t * pkt_wire,size_t pkt_wire_size,const char * key_data,const ldns_rdf * key_name_rdf,const ldns_rdf * fudge_rdf,const ldns_rdf * algorithm_rdf,const ldns_rdf * time_signed_rdf,const ldns_rdf * error_rdf,const ldns_rdf * other_data_rdf,const ldns_rdf * orig_mac_rdf,int tsig_timers_only)167 ldns_tsig_mac_new(ldns_rdf **tsig_mac, const uint8_t *pkt_wire, size_t pkt_wire_size,
168 const char *key_data, const ldns_rdf *key_name_rdf, const ldns_rdf *fudge_rdf,
169 const ldns_rdf *algorithm_rdf, const ldns_rdf *time_signed_rdf, const ldns_rdf *error_rdf,
170 const ldns_rdf *other_data_rdf, const ldns_rdf *orig_mac_rdf, int tsig_timers_only)
171 {
172 ldns_status status;
173 char *wireformat;
174 int wiresize;
175 unsigned char *mac_bytes = NULL;
176 unsigned char *key_bytes = NULL;
177 int key_size;
178 const EVP_MD *digester;
179 char *algorithm_name = NULL;
180 unsigned int md_len = EVP_MAX_MD_SIZE;
181 ldns_rdf *result = NULL;
182 ldns_buffer *data_buffer = NULL;
183 ldns_rdf *canonical_key_name_rdf = NULL;
184 ldns_rdf *canonical_algorithm_rdf = NULL;
185
186 if (key_name_rdf == NULL || algorithm_rdf == NULL) {
187 return LDNS_STATUS_NULL;
188 }
189 canonical_key_name_rdf = ldns_rdf_clone(key_name_rdf);
190 if (canonical_key_name_rdf == NULL) {
191 return LDNS_STATUS_MEM_ERR;
192 }
193 canonical_algorithm_rdf = ldns_rdf_clone(algorithm_rdf);
194 if (canonical_algorithm_rdf == NULL) {
195 ldns_rdf_deep_free(canonical_key_name_rdf);
196 return LDNS_STATUS_MEM_ERR;
197 }
198 /*
199 * prepare the digestible information
200 */
201 data_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
202 if (!data_buffer) {
203 status = LDNS_STATUS_MEM_ERR;
204 goto clean;
205 }
206 /* if orig_mac is not NULL, add it too */
207 if (orig_mac_rdf) {
208 (void) ldns_rdf2buffer_wire(data_buffer, orig_mac_rdf);
209 }
210 ldns_buffer_write(data_buffer, pkt_wire, pkt_wire_size);
211 if (!tsig_timers_only) {
212 ldns_dname2canonical(canonical_key_name_rdf);
213 (void)ldns_rdf2buffer_wire(data_buffer,
214 canonical_key_name_rdf);
215 ldns_buffer_write_u16(data_buffer, LDNS_RR_CLASS_ANY);
216 ldns_buffer_write_u32(data_buffer, 0);
217 ldns_dname2canonical(canonical_algorithm_rdf);
218 (void)ldns_rdf2buffer_wire(data_buffer,
219 canonical_algorithm_rdf);
220 }
221 (void)ldns_rdf2buffer_wire(data_buffer, time_signed_rdf);
222 (void)ldns_rdf2buffer_wire(data_buffer, fudge_rdf);
223 if (!tsig_timers_only) {
224 (void)ldns_rdf2buffer_wire(data_buffer, error_rdf);
225 (void)ldns_rdf2buffer_wire(data_buffer, other_data_rdf);
226 }
227
228 wireformat = (char *) data_buffer->_data;
229 wiresize = (int) ldns_buffer_position(data_buffer);
230
231 algorithm_name = ldns_rdf2str(algorithm_rdf);
232 if(!algorithm_name) {
233 status = LDNS_STATUS_MEM_ERR;
234 goto clean;
235 }
236
237 /* prepare the key */
238 key_bytes = LDNS_XMALLOC(unsigned char,
239 ldns_b64_pton_calculate_size(strlen(key_data)));
240 if(!key_bytes) {
241 status = LDNS_STATUS_MEM_ERR;
242 goto clean;
243 }
244 key_size = ldns_b64_pton(key_data, key_bytes,
245 ldns_b64_pton_calculate_size(strlen(key_data)));
246 if (key_size < 0) {
247 status = LDNS_STATUS_INVALID_B64;
248 goto clean;
249 }
250 /* hmac it */
251 /* 2 spare bytes for the length */
252 mac_bytes = LDNS_XMALLOC(unsigned char, md_len+2);
253 if(!mac_bytes) {
254 status = LDNS_STATUS_MEM_ERR;
255 goto clean;
256 }
257 memset(mac_bytes, 0, md_len+2);
258
259 digester = ldns_digest_function(algorithm_name);
260
261 if (digester) {
262 (void) HMAC(digester, key_bytes, key_size, (void *)wireformat,
263 (size_t) wiresize, mac_bytes + 2, &md_len);
264
265 ldns_write_uint16(mac_bytes, md_len);
266 result = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT16_DATA, md_len + 2,
267 mac_bytes);
268 } else {
269 status = LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
270 goto clean;
271 }
272 *tsig_mac = result;
273 status = LDNS_STATUS_OK;
274 clean:
275 LDNS_FREE(mac_bytes);
276 LDNS_FREE(key_bytes);
277 LDNS_FREE(algorithm_name);
278 ldns_buffer_free(data_buffer);
279 ldns_rdf_deep_free(canonical_algorithm_rdf);
280 ldns_rdf_deep_free(canonical_key_name_rdf);
281 return status;
282 }
283 #endif /* HAVE_SSL */
284
285
286 #ifdef HAVE_SSL
287 bool
ldns_pkt_tsig_verify(ldns_pkt * pkt,const uint8_t * wire,size_t wirelen,const char * key_name,const char * key_data,const ldns_rdf * orig_mac_rdf)288 ldns_pkt_tsig_verify(ldns_pkt *pkt, const uint8_t *wire, size_t wirelen, const char *key_name,
289 const char *key_data, const ldns_rdf *orig_mac_rdf)
290 {
291 return ldns_pkt_tsig_verify_next(pkt, wire, wirelen, key_name, key_data, orig_mac_rdf, 0);
292 }
293
294 bool
ldns_pkt_tsig_verify_next(ldns_pkt * pkt,const uint8_t * wire,size_t wirelen,const char * key_name,const char * key_data,const ldns_rdf * orig_mac_rdf,int tsig_timers_only)295 ldns_pkt_tsig_verify_next(ldns_pkt *pkt, const uint8_t *wire, size_t wirelen, const char* key_name,
296 const char *key_data, const ldns_rdf *orig_mac_rdf, int tsig_timers_only)
297 {
298 ldns_rdf *fudge_rdf;
299 ldns_rdf *algorithm_rdf;
300 ldns_rdf *time_signed_rdf;
301 ldns_rdf *orig_id_rdf;
302 ldns_rdf *error_rdf;
303 ldns_rdf *other_data_rdf;
304 ldns_rdf *pkt_mac_rdf;
305 ldns_rdf *my_mac_rdf;
306 ldns_rdf *key_name_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, key_name);
307 uint16_t pkt_id, orig_pkt_id;
308 ldns_status status;
309
310 uint8_t *prepared_wire = NULL;
311 size_t prepared_wire_size = 0;
312
313 ldns_rr *orig_tsig = ldns_pkt_tsig(pkt);
314
315 if (!orig_tsig || ldns_rr_rd_count(orig_tsig) <= 6) {
316 ldns_rdf_deep_free(key_name_rdf);
317 return false;
318 }
319 algorithm_rdf = ldns_rr_rdf(orig_tsig, 0);
320 time_signed_rdf = ldns_rr_rdf(orig_tsig, 1);
321 fudge_rdf = ldns_rr_rdf(orig_tsig, 2);
322 pkt_mac_rdf = ldns_rr_rdf(orig_tsig, 3);
323 orig_id_rdf = ldns_rr_rdf(orig_tsig, 4);
324 error_rdf = ldns_rr_rdf(orig_tsig, 5);
325 other_data_rdf = ldns_rr_rdf(orig_tsig, 6);
326
327 /* remove temporarily */
328 ldns_pkt_set_tsig(pkt, NULL);
329 /* temporarily change the id to the original id */
330 pkt_id = ldns_pkt_id(pkt);
331 orig_pkt_id = ldns_rdf2native_int16(orig_id_rdf);
332 ldns_pkt_set_id(pkt, orig_pkt_id);
333
334 prepared_wire = ldns_tsig_prepare_pkt_wire(wire, wirelen, &prepared_wire_size);
335
336 status = ldns_tsig_mac_new(&my_mac_rdf, prepared_wire, prepared_wire_size,
337 key_data, key_name_rdf, fudge_rdf, algorithm_rdf,
338 time_signed_rdf, error_rdf, other_data_rdf, orig_mac_rdf, tsig_timers_only);
339
340 LDNS_FREE(prepared_wire);
341
342 if (status != LDNS_STATUS_OK) {
343 ldns_rdf_deep_free(key_name_rdf);
344 return false;
345 }
346 /* Put back the values */
347 ldns_pkt_set_tsig(pkt, orig_tsig);
348 ldns_pkt_set_id(pkt, pkt_id);
349
350 ldns_rdf_deep_free(key_name_rdf);
351
352 if( ldns_rdf_size(pkt_mac_rdf) != ldns_rdf_size(my_mac_rdf)) {
353 ldns_rdf_deep_free(my_mac_rdf);
354 return false;
355 }
356 /* use time insensitive memory compare */
357 if(
358 #ifdef HAVE_CRYPTO_MEMCMP
359 CRYPTO_memcmp
360 #else
361 memcmp
362 #endif
363 (ldns_rdf_data(pkt_mac_rdf), ldns_rdf_data(my_mac_rdf),
364 ldns_rdf_size(my_mac_rdf)) == 0) {
365 ldns_rdf_deep_free(my_mac_rdf);
366 return true;
367 } else {
368 ldns_rdf_deep_free(my_mac_rdf);
369 return false;
370 }
371 }
372 #endif /* HAVE_SSL */
373
374 #ifdef HAVE_SSL
375 ldns_status
ldns_pkt_tsig_sign(ldns_pkt * pkt,const char * key_name,const char * key_data,uint16_t fudge,const char * algorithm_name,const ldns_rdf * query_mac)376 ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data,
377 uint16_t fudge, const char *algorithm_name, const ldns_rdf *query_mac)
378 {
379 return ldns_pkt_tsig_sign_next(pkt, key_name, key_data, fudge, algorithm_name, query_mac, 0);
380 }
381
382 ldns_status
ldns_pkt_tsig_sign_next(ldns_pkt * pkt,const char * key_name,const char * key_data,uint16_t fudge,const char * algorithm_name,const ldns_rdf * query_mac,int tsig_timers_only)383 ldns_pkt_tsig_sign_next(ldns_pkt *pkt, const char *key_name, const char *key_data,
384 uint16_t fudge, const char *algorithm_name, const ldns_rdf *query_mac, int tsig_timers_only)
385 {
386 ldns_rr *tsig_rr;
387 ldns_rdf *key_name_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, key_name);
388 ldns_rdf *fudge_rdf = NULL;
389 ldns_rdf *orig_id_rdf = NULL;
390 ldns_rdf *algorithm_rdf;
391 ldns_rdf *error_rdf = NULL;
392 ldns_rdf *mac_rdf = NULL;
393 ldns_rdf *other_data_rdf = NULL;
394
395 ldns_status status = LDNS_STATUS_OK;
396
397 uint8_t *pkt_wire = NULL;
398 size_t pkt_wire_len;
399
400 struct timeval tv_time_signed;
401 uint8_t *time_signed = NULL;
402 ldns_rdf *time_signed_rdf = NULL;
403
404 algorithm_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, algorithm_name);
405 if(!key_name_rdf || !algorithm_rdf) {
406 status = LDNS_STATUS_MEM_ERR;
407 goto clean;
408 }
409
410 /* eww don't have create tsigtime rdf yet :( */
411 /* bleh :p */
412 if (gettimeofday(&tv_time_signed, NULL) == 0) {
413 time_signed = LDNS_XMALLOC(uint8_t, 6);
414 if(!time_signed) {
415 status = LDNS_STATUS_MEM_ERR;
416 goto clean;
417 }
418 ldns_write_uint64_as_uint48(time_signed,
419 (uint64_t)tv_time_signed.tv_sec);
420 } else {
421 status = LDNS_STATUS_INTERNAL_ERR;
422 goto clean;
423 }
424
425 time_signed_rdf = ldns_rdf_new(LDNS_RDF_TYPE_TSIGTIME, 6, time_signed);
426 if(!time_signed_rdf) {
427 LDNS_FREE(time_signed);
428 status = LDNS_STATUS_MEM_ERR;
429 goto clean;
430 }
431
432 fudge_rdf = ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, fudge);
433
434 orig_id_rdf = ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, ldns_pkt_id(pkt));
435
436 error_rdf = ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, 0);
437
438 other_data_rdf = ldns_native2rdf_int16_data(0, NULL);
439
440 if(!fudge_rdf || !orig_id_rdf || !error_rdf || !other_data_rdf) {
441 status = LDNS_STATUS_MEM_ERR;
442 goto clean;
443 }
444
445 if (ldns_pkt2wire(&pkt_wire, pkt, &pkt_wire_len) != LDNS_STATUS_OK) {
446 status = LDNS_STATUS_ERR;
447 goto clean;
448 }
449
450 status = ldns_tsig_mac_new(&mac_rdf, pkt_wire, pkt_wire_len,
451 key_data, key_name_rdf, fudge_rdf, algorithm_rdf,
452 time_signed_rdf, error_rdf, other_data_rdf, query_mac, tsig_timers_only);
453
454 if (!mac_rdf) {
455 goto clean;
456 }
457
458 LDNS_FREE(pkt_wire);
459
460 /* Create the TSIG RR */
461 tsig_rr = ldns_rr_new();
462 if(!tsig_rr) {
463 status = LDNS_STATUS_MEM_ERR;
464 goto clean;
465 }
466 ldns_rr_set_owner(tsig_rr, key_name_rdf);
467 ldns_rr_set_class(tsig_rr, LDNS_RR_CLASS_ANY);
468 ldns_rr_set_type(tsig_rr, LDNS_RR_TYPE_TSIG);
469 ldns_rr_set_ttl(tsig_rr, 0);
470
471 ldns_rr_push_rdf(tsig_rr, algorithm_rdf);
472 ldns_rr_push_rdf(tsig_rr, time_signed_rdf);
473 ldns_rr_push_rdf(tsig_rr, fudge_rdf);
474 ldns_rr_push_rdf(tsig_rr, mac_rdf);
475 ldns_rr_push_rdf(tsig_rr, orig_id_rdf);
476 ldns_rr_push_rdf(tsig_rr, error_rdf);
477 ldns_rr_push_rdf(tsig_rr, other_data_rdf);
478
479 ldns_pkt_set_tsig(pkt, tsig_rr);
480
481 return status;
482
483 clean:
484 LDNS_FREE(pkt_wire);
485 ldns_rdf_free(key_name_rdf);
486 ldns_rdf_free(algorithm_rdf);
487 ldns_rdf_free(time_signed_rdf);
488 ldns_rdf_free(fudge_rdf);
489 ldns_rdf_free(orig_id_rdf);
490 ldns_rdf_free(error_rdf);
491 ldns_rdf_free(other_data_rdf);
492 return status;
493 }
494 #endif /* HAVE_SSL */
495