Import bind 9.5.2 vendor sources.
[dragonfly.git] / contrib / bind-9.5.2 / lib / dns / dst_api.c
1 /*
2  * Portions Copyright (C) 2004-2009  Internet Systems Consortium, Inc. ("ISC")
3  * Portions Copyright (C) 1999-2003  Internet Software Consortium.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS
10  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
11  * WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE
12  * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
15  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  *
17  * Portions Copyright (C) 1995-2000 by Network Associates, Inc.
18  *
19  * Permission to use, copy, modify, and/or distribute this software for any
20  * purpose with or without fee is hereby granted, provided that the above
21  * copyright notice and this permission notice appear in all copies.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS
24  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
25  * WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE
26  * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
27  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
28  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
29  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
30  */
31
32 /*
33  * Principal Author: Brian Wellington
34  * $Id: dst_api.c,v 1.11.92.7 2009/07/29 23:55:00 each Exp $
35  */
36
37 /*! \file */
38
39 #include <config.h>
40
41 #include <stdlib.h>
42
43 #include <isc/buffer.h>
44 #include <isc/dir.h>
45 #include <isc/entropy.h>
46 #include <isc/fsaccess.h>
47 #include <isc/hmacsha.h>
48 #include <isc/lex.h>
49 #include <isc/mem.h>
50 #include <isc/once.h>
51 #include <isc/print.h>
52 #include <isc/random.h>
53 #include <isc/string.h>
54 #include <isc/time.h>
55 #include <isc/util.h>
56
57 #include <dns/fixedname.h>
58 #include <dns/keyvalues.h>
59 #include <dns/name.h>
60 #include <dns/rdata.h>
61 #include <dns/rdataclass.h>
62 #include <dns/ttl.h>
63 #include <dns/types.h>
64
65 #include <dst/result.h>
66
67 #include "dst_internal.h"
68
69 #define DST_AS_STR(t) ((t).value.as_textregion.base)
70
71 static dst_func_t *dst_t_func[DST_MAX_ALGS];
72 static isc_entropy_t *dst_entropy_pool = NULL;
73 static unsigned int dst_entropy_flags = 0;
74 static isc_boolean_t dst_initialized = ISC_FALSE;
75
76 void gss_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
77
78 isc_mem_t *dst__memory_pool = NULL;
79
80 /*
81  * Static functions.
82  */
83 static dst_key_t *      get_key_struct(dns_name_t *name,
84                                        unsigned int alg,
85                                        unsigned int flags,
86                                        unsigned int protocol,
87                                        unsigned int bits,
88                                        dns_rdataclass_t rdclass,
89                                        isc_mem_t *mctx);
90 static isc_result_t     write_public_key(const dst_key_t *key, int type,
91                                          const char *directory);
92 static isc_result_t     buildfilename(dns_name_t *name,
93                                       dns_keytag_t id,
94                                       unsigned int alg,
95                                       unsigned int type,
96                                       const char *directory,
97                                       isc_buffer_t *out);
98 static isc_result_t     computeid(dst_key_t *key);
99 static isc_result_t     frombuffer(dns_name_t *name,
100                                    unsigned int alg,
101                                    unsigned int flags,
102                                    unsigned int protocol,
103                                    dns_rdataclass_t rdclass,
104                                    isc_buffer_t *source,
105                                    isc_mem_t *mctx,
106                                    dst_key_t **keyp);
107
108 static isc_result_t     algorithm_status(unsigned int alg);
109
110 static isc_result_t     addsuffix(char *filename, unsigned int len,
111                                   const char *ofilename, const char *suffix);
112
113 #define RETERR(x)                               \
114         do {                                    \
115                 result = (x);                   \
116                 if (result != ISC_R_SUCCESS)    \
117                         goto out;               \
118         } while (0)
119
120 #define CHECKALG(alg)                           \
121         do {                                    \
122                 isc_result_t _r;                \
123                 _r = algorithm_status(alg);     \
124                 if (_r != ISC_R_SUCCESS)        \
125                         return (_r);            \
126         } while (0);                            \
127
128 #ifdef OPENSSL
129 static void *
130 default_memalloc(void *arg, size_t size) {
131         UNUSED(arg);
132         if (size == 0U)
133                 size = 1;
134         return (malloc(size));
135 }
136
137 static void
138 default_memfree(void *arg, void *ptr) {
139         UNUSED(arg);
140         free(ptr);
141 }
142 #endif
143
144 isc_result_t
145 dst_lib_init(isc_mem_t *mctx, isc_entropy_t *ectx, unsigned int eflags) {
146         isc_result_t result;
147
148         REQUIRE(mctx != NULL && ectx != NULL);
149         REQUIRE(dst_initialized == ISC_FALSE);
150
151         dst__memory_pool = NULL;
152
153 #ifdef OPENSSL
154         UNUSED(mctx);
155         /*
156          * When using --with-openssl, there seems to be no good way of not
157          * leaking memory due to the openssl error handling mechanism.
158          * Avoid assertions by using a local memory context and not checking
159          * for leaks on exit.  Note: as there are leaks we cannot use
160          * ISC_MEMFLAG_INTERNAL as it will free up memory still being used
161          * by libcrypto.
162          */
163         result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
164                                   NULL, &dst__memory_pool, 0);
165         if (result != ISC_R_SUCCESS)
166                 return (result);
167         isc_mem_setname(dst__memory_pool, "dst", NULL);
168         isc_mem_setdestroycheck(dst__memory_pool, ISC_FALSE);
169 #else
170         isc_mem_attach(mctx, &dst__memory_pool);
171 #endif
172         isc_entropy_attach(ectx, &dst_entropy_pool);
173         dst_entropy_flags = eflags;
174
175         dst_result_register();
176
177         memset(dst_t_func, 0, sizeof(dst_t_func));
178         RETERR(dst__hmacmd5_init(&dst_t_func[DST_ALG_HMACMD5]));
179         RETERR(dst__hmacsha1_init(&dst_t_func[DST_ALG_HMACSHA1]));
180         RETERR(dst__hmacsha224_init(&dst_t_func[DST_ALG_HMACSHA224]));
181         RETERR(dst__hmacsha256_init(&dst_t_func[DST_ALG_HMACSHA256]));
182         RETERR(dst__hmacsha384_init(&dst_t_func[DST_ALG_HMACSHA384]));
183         RETERR(dst__hmacsha512_init(&dst_t_func[DST_ALG_HMACSHA512]));
184 #ifdef OPENSSL
185         RETERR(dst__openssl_init());
186         RETERR(dst__opensslrsa_init(&dst_t_func[DST_ALG_RSAMD5]));
187         RETERR(dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA1]));
188 #ifdef HAVE_OPENSSL_DSA
189         RETERR(dst__openssldsa_init(&dst_t_func[DST_ALG_DSA]));
190 #endif
191         RETERR(dst__openssldh_init(&dst_t_func[DST_ALG_DH]));
192 #endif /* OPENSSL */
193 #ifdef GSSAPI
194         RETERR(dst__gssapi_init(&dst_t_func[DST_ALG_GSSAPI]));
195 #endif
196         dst_initialized = ISC_TRUE;
197         return (ISC_R_SUCCESS);
198
199  out:
200         dst_lib_destroy();
201         return (result);
202 }
203
204 void
205 dst_lib_destroy(void) {
206         int i;
207         RUNTIME_CHECK(dst_initialized == ISC_TRUE);
208         dst_initialized = ISC_FALSE;
209
210         for (i = 0; i < DST_MAX_ALGS; i++)
211                 if (dst_t_func[i] != NULL && dst_t_func[i]->cleanup != NULL)
212                         dst_t_func[i]->cleanup();
213 #ifdef OPENSSL
214         dst__openssl_destroy();
215 #endif
216         if (dst__memory_pool != NULL)
217                 isc_mem_detach(&dst__memory_pool);
218         if (dst_entropy_pool != NULL)
219                 isc_entropy_detach(&dst_entropy_pool);
220
221 }
222
223 isc_boolean_t
224 dst_algorithm_supported(unsigned int alg) {
225         REQUIRE(dst_initialized == ISC_TRUE);
226
227         if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL)
228                 return (ISC_FALSE);
229         return (ISC_TRUE);
230 }
231
232 isc_result_t
233 dst_context_create(dst_key_t *key, isc_mem_t *mctx, dst_context_t **dctxp) {
234         dst_context_t *dctx;
235         isc_result_t result;
236
237         REQUIRE(dst_initialized == ISC_TRUE);
238         REQUIRE(VALID_KEY(key));
239         REQUIRE(mctx != NULL);
240         REQUIRE(dctxp != NULL && *dctxp == NULL);
241
242         if (key->func->createctx == NULL)
243                 return (DST_R_UNSUPPORTEDALG);
244         if (key->keydata.generic == NULL)
245                 return (DST_R_NULLKEY);
246
247         dctx = isc_mem_get(mctx, sizeof(dst_context_t));
248         if (dctx == NULL)
249                 return (ISC_R_NOMEMORY);
250         dctx->key = key;
251         dctx->mctx = mctx;
252         result = key->func->createctx(key, dctx);
253         if (result != ISC_R_SUCCESS) {
254                 isc_mem_put(mctx, dctx, sizeof(dst_context_t));
255                 return (result);
256         }
257         dctx->magic = CTX_MAGIC;
258         *dctxp = dctx;
259         return (ISC_R_SUCCESS);
260 }
261
262 void
263 dst_context_destroy(dst_context_t **dctxp) {
264         dst_context_t *dctx;
265
266         REQUIRE(dctxp != NULL && VALID_CTX(*dctxp));
267
268         dctx = *dctxp;
269         INSIST(dctx->key->func->destroyctx != NULL);
270         dctx->key->func->destroyctx(dctx);
271         dctx->magic = 0;
272         isc_mem_put(dctx->mctx, dctx, sizeof(dst_context_t));
273         *dctxp = NULL;
274 }
275
276 isc_result_t
277 dst_context_adddata(dst_context_t *dctx, const isc_region_t *data) {
278         REQUIRE(VALID_CTX(dctx));
279         REQUIRE(data != NULL);
280         INSIST(dctx->key->func->adddata != NULL);
281
282         return (dctx->key->func->adddata(dctx, data));
283 }
284
285 isc_result_t
286 dst_context_sign(dst_context_t *dctx, isc_buffer_t *sig) {
287         dst_key_t *key;
288
289         REQUIRE(VALID_CTX(dctx));
290         REQUIRE(sig != NULL);
291
292         key = dctx->key;
293         CHECKALG(key->key_alg);
294         if (key->keydata.generic == NULL)
295                 return (DST_R_NULLKEY);
296         if (key->func->sign == NULL)
297                 return (DST_R_NOTPRIVATEKEY);
298         if (key->func->isprivate == NULL ||
299             key->func->isprivate(key) == ISC_FALSE)
300                 return (DST_R_NOTPRIVATEKEY);
301
302         return (key->func->sign(dctx, sig));
303 }
304
305 isc_result_t
306 dst_context_verify(dst_context_t *dctx, isc_region_t *sig) {
307         REQUIRE(VALID_CTX(dctx));
308         REQUIRE(sig != NULL);
309
310         CHECKALG(dctx->key->key_alg);
311         if (dctx->key->keydata.generic == NULL)
312                 return (DST_R_NULLKEY);
313         if (dctx->key->func->verify == NULL)
314                 return (DST_R_NOTPUBLICKEY);
315
316         return (dctx->key->func->verify(dctx, sig));
317 }
318
319 isc_result_t
320 dst_key_computesecret(const dst_key_t *pub, const dst_key_t *priv,
321                       isc_buffer_t *secret)
322 {
323         REQUIRE(dst_initialized == ISC_TRUE);
324         REQUIRE(VALID_KEY(pub) && VALID_KEY(priv));
325         REQUIRE(secret != NULL);
326
327         CHECKALG(pub->key_alg);
328         CHECKALG(priv->key_alg);
329
330         if (pub->keydata.generic == NULL || priv->keydata.generic == NULL)
331                 return (DST_R_NULLKEY);
332
333         if (pub->key_alg != priv->key_alg ||
334             pub->func->computesecret == NULL ||
335             priv->func->computesecret == NULL)
336                 return (DST_R_KEYCANNOTCOMPUTESECRET);
337
338         if (dst_key_isprivate(priv) == ISC_FALSE)
339                 return (DST_R_NOTPRIVATEKEY);
340
341         return (pub->func->computesecret(pub, priv, secret));
342 }
343
344 isc_result_t
345 dst_key_tofile(const dst_key_t *key, int type, const char *directory) {
346         isc_result_t ret = ISC_R_SUCCESS;
347
348         REQUIRE(dst_initialized == ISC_TRUE);
349         REQUIRE(VALID_KEY(key));
350         REQUIRE((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) != 0);
351
352         CHECKALG(key->key_alg);
353
354         if (key->func->tofile == NULL)
355                 return (DST_R_UNSUPPORTEDALG);
356
357         if (type & DST_TYPE_PUBLIC) {
358                 ret = write_public_key(key, type, directory);
359                 if (ret != ISC_R_SUCCESS)
360                         return (ret);
361         }
362
363         if ((type & DST_TYPE_PRIVATE) &&
364             (key->key_flags & DNS_KEYFLAG_TYPEMASK) != DNS_KEYTYPE_NOKEY)
365                 return (key->func->tofile(key, directory));
366         else
367                 return (ISC_R_SUCCESS);
368 }
369
370 isc_result_t
371 dst_key_fromfile(dns_name_t *name, dns_keytag_t id,
372                  unsigned int alg, int type, const char *directory,
373                  isc_mem_t *mctx, dst_key_t **keyp)
374 {
375         char filename[ISC_DIR_NAMEMAX];
376         isc_buffer_t b;
377         dst_key_t *key;
378         isc_result_t result;
379
380         REQUIRE(dst_initialized == ISC_TRUE);
381         REQUIRE(dns_name_isabsolute(name));
382         REQUIRE((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) != 0);
383         REQUIRE(mctx != NULL);
384         REQUIRE(keyp != NULL && *keyp == NULL);
385
386         CHECKALG(alg);
387
388         isc_buffer_init(&b, filename, sizeof(filename));
389         result = buildfilename(name, id, alg, type, directory, &b);
390         if (result != ISC_R_SUCCESS)
391                 return (result);
392
393         key = NULL;
394         result = dst_key_fromnamedfile(filename, type, mctx, &key);
395         if (result != ISC_R_SUCCESS)
396                 return (result);
397
398         result = computeid(key);
399         if (result != ISC_R_SUCCESS) {
400                 dst_key_free(&key);
401                 return (result);
402         }
403
404         if (!dns_name_equal(name, key->key_name) || id != key->key_id ||
405             alg != key->key_alg) {
406                 dst_key_free(&key);
407                 return (DST_R_INVALIDPRIVATEKEY);
408         }
409         key->key_id = id;
410
411         *keyp = key;
412         return (ISC_R_SUCCESS);
413 }
414
415 isc_result_t
416 dst_key_fromnamedfile(const char *filename, int type, isc_mem_t *mctx,
417                       dst_key_t **keyp)
418 {
419         isc_result_t result;
420         dst_key_t *pubkey = NULL, *key = NULL;
421         dns_keytag_t id;
422         char *newfilename = NULL;
423         int newfilenamelen = 0;
424         isc_lex_t *lex = NULL;
425
426         REQUIRE(dst_initialized == ISC_TRUE);
427         REQUIRE(filename != NULL);
428         REQUIRE((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) != 0);
429         REQUIRE(mctx != NULL);
430         REQUIRE(keyp != NULL && *keyp == NULL);
431
432         newfilenamelen = strlen(filename) + 5;
433         newfilename = isc_mem_get(mctx, newfilenamelen);
434         if (newfilename == NULL)
435                 return (ISC_R_NOMEMORY);
436         result = addsuffix(newfilename, newfilenamelen, filename, ".key");
437         INSIST(result == ISC_R_SUCCESS);
438
439         result = dst_key_read_public(newfilename, type, mctx, &pubkey);
440         isc_mem_put(mctx, newfilename, newfilenamelen);
441         newfilename = NULL;
442         if (result != ISC_R_SUCCESS)
443                 return (result);
444
445         if ((type & (DST_TYPE_PRIVATE | DST_TYPE_PUBLIC)) == DST_TYPE_PUBLIC ||
446             (pubkey->key_flags & DNS_KEYFLAG_TYPEMASK) == DNS_KEYTYPE_NOKEY) {
447                 result = computeid(pubkey);
448                 if (result != ISC_R_SUCCESS) {
449                         dst_key_free(&pubkey);
450                         return (result);
451                 }
452
453                 *keyp = pubkey;
454                 return (ISC_R_SUCCESS);
455         }
456
457         result = algorithm_status(pubkey->key_alg);
458         if (result != ISC_R_SUCCESS) {
459                 dst_key_free(&pubkey);
460                 return (result);
461         }
462
463         key = get_key_struct(pubkey->key_name, pubkey->key_alg,
464                              pubkey->key_flags, pubkey->key_proto, 0,
465                              pubkey->key_class, mctx);
466         id = pubkey->key_id;
467         dst_key_free(&pubkey);
468
469         if (key == NULL)
470                 return (ISC_R_NOMEMORY);
471
472         if (key->func->parse == NULL)
473                 RETERR(DST_R_UNSUPPORTEDALG);
474
475         newfilenamelen = strlen(filename) + 9;
476         newfilename = isc_mem_get(mctx, newfilenamelen);
477         if (newfilename == NULL)
478                 RETERR(ISC_R_NOMEMORY);
479         result = addsuffix(newfilename, newfilenamelen, filename, ".private");
480         INSIST(result == ISC_R_SUCCESS);
481
482         RETERR(isc_lex_create(mctx, 1500, &lex));
483         RETERR(isc_lex_openfile(lex, newfilename));
484         isc_mem_put(mctx, newfilename, newfilenamelen);
485
486         RETERR(key->func->parse(key, lex));
487         isc_lex_destroy(&lex);
488
489         RETERR(computeid(key));
490
491         if (id != key->key_id)
492                 RETERR(DST_R_INVALIDPRIVATEKEY);
493
494         *keyp = key;
495         return (ISC_R_SUCCESS);
496  out:
497         if (newfilename != NULL)
498                 isc_mem_put(mctx, newfilename, newfilenamelen);
499         if (lex != NULL)
500                 isc_lex_destroy(&lex);
501         dst_key_free(&key);
502         return (result);
503 }
504
505 isc_result_t
506 dst_key_todns(const dst_key_t *key, isc_buffer_t *target) {
507         REQUIRE(dst_initialized == ISC_TRUE);
508         REQUIRE(VALID_KEY(key));
509         REQUIRE(target != NULL);
510
511         CHECKALG(key->key_alg);
512
513         if (key->func->todns == NULL)
514                 return (DST_R_UNSUPPORTEDALG);
515
516         if (isc_buffer_availablelength(target) < 4)
517                 return (ISC_R_NOSPACE);
518         isc_buffer_putuint16(target, (isc_uint16_t)(key->key_flags & 0xffff));
519         isc_buffer_putuint8(target, (isc_uint8_t)key->key_proto);
520         isc_buffer_putuint8(target, (isc_uint8_t)key->key_alg);
521
522         if (key->key_flags & DNS_KEYFLAG_EXTENDED) {
523                 if (isc_buffer_availablelength(target) < 2)
524                         return (ISC_R_NOSPACE);
525                 isc_buffer_putuint16(target,
526                                      (isc_uint16_t)((key->key_flags >> 16)
527                                                     & 0xffff));
528         }
529
530         if (key->keydata.generic == NULL) /*%< NULL KEY */
531                 return (ISC_R_SUCCESS);
532
533         return (key->func->todns(key, target));
534 }
535
536 isc_result_t
537 dst_key_fromdns(dns_name_t *name, dns_rdataclass_t rdclass,
538                 isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp)
539 {
540         isc_uint8_t alg, proto;
541         isc_uint32_t flags, extflags;
542         dst_key_t *key = NULL;
543         dns_keytag_t id;
544         isc_region_t r;
545         isc_result_t result;
546
547         REQUIRE(dst_initialized);
548
549         isc_buffer_remainingregion(source, &r);
550
551         if (isc_buffer_remaininglength(source) < 4)
552                 return (DST_R_INVALIDPUBLICKEY);
553         flags = isc_buffer_getuint16(source);
554         proto = isc_buffer_getuint8(source);
555         alg = isc_buffer_getuint8(source);
556
557         id = dst_region_computeid(&r, alg);
558
559         if (flags & DNS_KEYFLAG_EXTENDED) {
560                 if (isc_buffer_remaininglength(source) < 2)
561                         return (DST_R_INVALIDPUBLICKEY);
562                 extflags = isc_buffer_getuint16(source);
563                 flags |= (extflags << 16);
564         }
565
566         result = frombuffer(name, alg, flags, proto, rdclass, source,
567                             mctx, &key);
568         if (result != ISC_R_SUCCESS)
569                 return (result);
570         key->key_id = id;
571
572         *keyp = key;
573         return (ISC_R_SUCCESS);
574 }
575
576 isc_result_t
577 dst_key_frombuffer(dns_name_t *name, unsigned int alg,
578                    unsigned int flags, unsigned int protocol,
579                    dns_rdataclass_t rdclass,
580                    isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp)
581 {
582         dst_key_t *key = NULL;
583         isc_result_t result;
584
585         REQUIRE(dst_initialized);
586
587         result = frombuffer(name, alg, flags, protocol, rdclass, source,
588                             mctx, &key);
589         if (result != ISC_R_SUCCESS)
590                 return (result);
591
592         result = computeid(key);
593         if (result != ISC_R_SUCCESS) {
594                 dst_key_free(&key);
595                 return (result);
596         }
597
598         *keyp = key;
599         return (ISC_R_SUCCESS);
600 }
601
602 isc_result_t
603 dst_key_tobuffer(const dst_key_t *key, isc_buffer_t *target) {
604         REQUIRE(dst_initialized == ISC_TRUE);
605         REQUIRE(VALID_KEY(key));
606         REQUIRE(target != NULL);
607
608         CHECKALG(key->key_alg);
609
610         if (key->func->todns == NULL)
611                 return (DST_R_UNSUPPORTEDALG);
612
613         return (key->func->todns(key, target));
614 }
615
616 isc_result_t
617 dst_key_privatefrombuffer(dst_key_t *key, isc_buffer_t *buffer) {
618         isc_lex_t *lex = NULL;
619         isc_result_t result = ISC_R_SUCCESS;
620
621         REQUIRE(dst_initialized == ISC_TRUE);
622         REQUIRE(VALID_KEY(key));
623         REQUIRE(!dst_key_isprivate(key));
624         REQUIRE(buffer != NULL);
625
626         if (key->func->parse == NULL)
627                 RETERR(DST_R_UNSUPPORTEDALG);
628
629         RETERR(isc_lex_create(key->mctx, 1500, &lex));
630         RETERR(isc_lex_openbuffer(lex, buffer));
631         RETERR(key->func->parse(key, lex));
632  out:
633         if (lex != NULL)
634                 isc_lex_destroy(&lex);
635         return (result);
636 }
637
638 gss_ctx_id_t
639 dst_key_getgssctx(const dst_key_t *key)
640 {
641         REQUIRE(key != NULL);
642
643         return (key->keydata.gssctx);
644 }
645
646 isc_result_t
647 dst_key_fromgssapi(dns_name_t *name, gss_ctx_id_t gssctx, isc_mem_t *mctx,
648                    dst_key_t **keyp)
649 {
650         dst_key_t *key;
651
652         REQUIRE(gssctx != NULL);
653         REQUIRE(keyp != NULL && *keyp == NULL);
654
655         key = get_key_struct(name, DST_ALG_GSSAPI, 0, DNS_KEYPROTO_DNSSEC,
656                              0, dns_rdataclass_in, mctx);
657         if (key == NULL)
658                 return (ISC_R_NOMEMORY);
659
660         key->keydata.gssctx = gssctx;
661         *keyp = key;
662         return (ISC_R_SUCCESS);
663 }
664
665 isc_result_t
666 dst_key_generate(dns_name_t *name, unsigned int alg,
667                  unsigned int bits, unsigned int param,
668                  unsigned int flags, unsigned int protocol,
669                  dns_rdataclass_t rdclass,
670                  isc_mem_t *mctx, dst_key_t **keyp)
671 {
672         dst_key_t *key;
673         isc_result_t ret;
674
675         REQUIRE(dst_initialized == ISC_TRUE);
676         REQUIRE(dns_name_isabsolute(name));
677         REQUIRE(mctx != NULL);
678         REQUIRE(keyp != NULL && *keyp == NULL);
679
680         CHECKALG(alg);
681
682         key = get_key_struct(name, alg, flags, protocol, bits, rdclass, mctx);
683         if (key == NULL)
684                 return (ISC_R_NOMEMORY);
685
686         if (bits == 0) { /*%< NULL KEY */
687                 key->key_flags |= DNS_KEYTYPE_NOKEY;
688                 *keyp = key;
689                 return (ISC_R_SUCCESS);
690         }
691
692         if (key->func->generate == NULL) {
693                 dst_key_free(&key);
694                 return (DST_R_UNSUPPORTEDALG);
695         }
696
697         ret = key->func->generate(key, param);
698         if (ret != ISC_R_SUCCESS) {
699                 dst_key_free(&key);
700                 return (ret);
701         }
702
703         ret = computeid(key);
704         if (ret != ISC_R_SUCCESS) {
705                 dst_key_free(&key);
706                 return (ret);
707         }
708
709         *keyp = key;
710         return (ISC_R_SUCCESS);
711 }
712
713 isc_boolean_t
714 dst_key_compare(const dst_key_t *key1, const dst_key_t *key2) {
715         REQUIRE(dst_initialized == ISC_TRUE);
716         REQUIRE(VALID_KEY(key1));
717         REQUIRE(VALID_KEY(key2));
718
719         if (key1 == key2)
720                 return (ISC_TRUE);
721         if (key1 == NULL || key2 == NULL)
722                 return (ISC_FALSE);
723         if (key1->key_alg == key2->key_alg &&
724             key1->key_id == key2->key_id &&
725             key1->func->compare != NULL &&
726             key1->func->compare(key1, key2) == ISC_TRUE)
727                 return (ISC_TRUE);
728         else
729                 return (ISC_FALSE);
730 }
731
732 isc_boolean_t
733 dst_key_paramcompare(const dst_key_t *key1, const dst_key_t *key2) {
734         REQUIRE(dst_initialized == ISC_TRUE);
735         REQUIRE(VALID_KEY(key1));
736         REQUIRE(VALID_KEY(key2));
737
738         if (key1 == key2)
739                 return (ISC_TRUE);
740         if (key1 == NULL || key2 == NULL)
741                 return (ISC_FALSE);
742         if (key1->key_alg == key2->key_alg &&
743             key1->func->paramcompare != NULL &&
744             key1->func->paramcompare(key1, key2) == ISC_TRUE)
745                 return (ISC_TRUE);
746         else
747                 return (ISC_FALSE);
748 }
749
750 void
751 dst_key_free(dst_key_t **keyp) {
752         isc_mem_t *mctx;
753         dst_key_t *key;
754
755         REQUIRE(dst_initialized == ISC_TRUE);
756         REQUIRE(keyp != NULL && VALID_KEY(*keyp));
757
758         key = *keyp;
759         mctx = key->mctx;
760
761         if (key->keydata.generic != NULL) {
762                 INSIST(key->func->destroy != NULL);
763                 key->func->destroy(key);
764         }
765
766         dns_name_free(key->key_name, mctx);
767         isc_mem_put(mctx, key->key_name, sizeof(dns_name_t));
768         memset(key, 0, sizeof(dst_key_t));
769         isc_mem_put(mctx, key, sizeof(dst_key_t));
770         *keyp = NULL;
771 }
772
773 isc_boolean_t
774 dst_key_isprivate(const dst_key_t *key) {
775         REQUIRE(VALID_KEY(key));
776         INSIST(key->func->isprivate != NULL);
777         return (key->func->isprivate(key));
778 }
779
780 isc_result_t
781 dst_key_buildfilename(const dst_key_t *key, int type,
782                       const char *directory, isc_buffer_t *out) {
783
784         REQUIRE(VALID_KEY(key));
785         REQUIRE(type == DST_TYPE_PRIVATE || type == DST_TYPE_PUBLIC ||
786                 type == 0);
787
788         return (buildfilename(key->key_name, key->key_id, key->key_alg,
789                               type, directory, out));
790 }
791
792 isc_result_t
793 dst_key_sigsize(const dst_key_t *key, unsigned int *n) {
794         REQUIRE(dst_initialized == ISC_TRUE);
795         REQUIRE(VALID_KEY(key));
796         REQUIRE(n != NULL);
797
798         /* XXXVIX this switch statement is too sparse to gen a jump table. */
799         switch (key->key_alg) {
800         case DST_ALG_RSAMD5:
801         case DST_ALG_RSASHA1:
802                 *n = (key->key_size + 7) / 8;
803                 break;
804         case DST_ALG_DSA:
805                 *n = DNS_SIG_DSASIGSIZE;
806                 break;
807         case DST_ALG_HMACMD5:
808                 *n = 16;
809                 break;
810         case DST_ALG_HMACSHA1:
811                 *n = ISC_SHA1_DIGESTLENGTH;
812                 break;
813         case DST_ALG_HMACSHA224:
814                 *n = ISC_SHA224_DIGESTLENGTH;
815                 break;
816         case DST_ALG_HMACSHA256:
817                 *n = ISC_SHA256_DIGESTLENGTH;
818                 break;
819         case DST_ALG_HMACSHA384:
820                 *n = ISC_SHA384_DIGESTLENGTH;
821                 break;
822         case DST_ALG_HMACSHA512:
823                 *n = ISC_SHA512_DIGESTLENGTH;
824                 break;
825         case DST_ALG_GSSAPI:
826                 *n = 128; /*%< XXX */
827                 break;
828         case DST_ALG_DH:
829         default:
830                 return (DST_R_UNSUPPORTEDALG);
831         }
832         return (ISC_R_SUCCESS);
833 }
834
835 isc_result_t
836 dst_key_secretsize(const dst_key_t *key, unsigned int *n) {
837         REQUIRE(dst_initialized == ISC_TRUE);
838         REQUIRE(VALID_KEY(key));
839         REQUIRE(n != NULL);
840
841         if (key->key_alg == DST_ALG_DH)
842                 *n = (key->key_size + 7) / 8;
843         else
844                 return (DST_R_UNSUPPORTEDALG);
845         return (ISC_R_SUCCESS);
846 }
847
848 /***
849  *** Static methods
850  ***/
851
852 /*%
853  * Allocates a key structure and fills in some of the fields.
854  */
855 static dst_key_t *
856 get_key_struct(dns_name_t *name, unsigned int alg,
857                unsigned int flags, unsigned int protocol,
858                unsigned int bits, dns_rdataclass_t rdclass,
859                isc_mem_t *mctx)
860 {
861         dst_key_t *key;
862         isc_result_t result;
863
864         key = (dst_key_t *) isc_mem_get(mctx, sizeof(dst_key_t));
865         if (key == NULL)
866                 return (NULL);
867
868         memset(key, 0, sizeof(dst_key_t));
869         key->magic = KEY_MAGIC;
870
871         key->key_name = isc_mem_get(mctx, sizeof(dns_name_t));
872         if (key->key_name == NULL) {
873                 isc_mem_put(mctx, key, sizeof(dst_key_t));
874                 return (NULL);
875         }
876         dns_name_init(key->key_name, NULL);
877         result = dns_name_dup(name, mctx, key->key_name);
878         if (result != ISC_R_SUCCESS) {
879                 isc_mem_put(mctx, key->key_name, sizeof(dns_name_t));
880                 isc_mem_put(mctx, key, sizeof(dst_key_t));
881                 return (NULL);
882         }
883         key->key_alg = alg;
884         key->key_flags = flags;
885         key->key_proto = protocol;
886         key->mctx = mctx;
887         key->keydata.generic = NULL;
888         key->key_size = bits;
889         key->key_class = rdclass;
890         key->func = dst_t_func[alg];
891         return (key);
892 }
893
894 /*%
895  * Reads a public key from disk
896  */
897 isc_result_t
898 dst_key_read_public(const char *filename, int type,
899                     isc_mem_t *mctx, dst_key_t **keyp)
900 {
901         u_char rdatabuf[DST_KEY_MAXSIZE];
902         isc_buffer_t b;
903         dns_fixedname_t name;
904         isc_lex_t *lex = NULL;
905         isc_token_t token;
906         isc_result_t ret;
907         dns_rdata_t rdata = DNS_RDATA_INIT;
908         unsigned int opt = ISC_LEXOPT_DNSMULTILINE;
909         dns_rdataclass_t rdclass = dns_rdataclass_in;
910         isc_lexspecials_t specials;
911         isc_uint32_t ttl;
912         isc_result_t result;
913         dns_rdatatype_t keytype;
914
915         /*
916          * Open the file and read its formatted contents
917          * File format:
918          *    domain.name [ttl] [class] [KEY|DNSKEY] <flags> <protocol> <algorithm> <key>
919          */
920
921         /* 1500 should be large enough for any key */
922         ret = isc_lex_create(mctx, 1500, &lex);
923         if (ret != ISC_R_SUCCESS)
924                 goto cleanup;
925
926         memset(specials, 0, sizeof(specials));
927         specials['('] = 1;
928         specials[')'] = 1;
929         specials['"'] = 1;
930         isc_lex_setspecials(lex, specials);
931         isc_lex_setcomments(lex, ISC_LEXCOMMENT_DNSMASTERFILE);
932
933         ret = isc_lex_openfile(lex, filename);
934         if (ret != ISC_R_SUCCESS)
935                 goto cleanup;
936
937 #define NEXTTOKEN(lex, opt, token) { \
938         ret = isc_lex_gettoken(lex, opt, token); \
939         if (ret != ISC_R_SUCCESS) \
940                 goto cleanup; \
941         }
942
943 #define BADTOKEN() { \
944         ret = ISC_R_UNEXPECTEDTOKEN; \
945         goto cleanup; \
946         }
947
948         /* Read the domain name */
949         NEXTTOKEN(lex, opt, &token);
950         if (token.type != isc_tokentype_string)
951                 BADTOKEN();
952
953         /*
954          * We don't support "@" in .key files.
955          */
956         if (!strcmp(DST_AS_STR(token), "@"))
957                 BADTOKEN();
958
959         dns_fixedname_init(&name);
960         isc_buffer_init(&b, DST_AS_STR(token), strlen(DST_AS_STR(token)));
961         isc_buffer_add(&b, strlen(DST_AS_STR(token)));
962         ret = dns_name_fromtext(dns_fixedname_name(&name), &b, dns_rootname,
963                                 ISC_FALSE, NULL);
964         if (ret != ISC_R_SUCCESS)
965                 goto cleanup;
966
967         /* Read the next word: either TTL, class, or 'KEY' */
968         NEXTTOKEN(lex, opt, &token);
969
970         if (token.type != isc_tokentype_string)
971                 BADTOKEN();
972
973         /* If it's a TTL, read the next one */
974         result = dns_ttl_fromtext(&token.value.as_textregion, &ttl);
975         if (result == ISC_R_SUCCESS)
976                 NEXTTOKEN(lex, opt, &token);
977
978         if (token.type != isc_tokentype_string)
979                 BADTOKEN();
980
981         ret = dns_rdataclass_fromtext(&rdclass, &token.value.as_textregion);
982         if (ret == ISC_R_SUCCESS)
983                 NEXTTOKEN(lex, opt, &token);
984
985         if (token.type != isc_tokentype_string)
986                 BADTOKEN();
987
988         if (strcasecmp(DST_AS_STR(token), "DNSKEY") == 0)
989                 keytype = dns_rdatatype_dnskey;
990         else if (strcasecmp(DST_AS_STR(token), "KEY") == 0)
991                 keytype = dns_rdatatype_key; /*%< SIG(0), TKEY */
992         else
993                 BADTOKEN();
994
995         if (((type & DST_TYPE_KEY) != 0 && keytype != dns_rdatatype_key) ||
996             ((type & DST_TYPE_KEY) == 0 && keytype != dns_rdatatype_dnskey)) {
997                 ret = DST_R_BADKEYTYPE;
998                 goto cleanup;
999         }
1000
1001         isc_buffer_init(&b, rdatabuf, sizeof(rdatabuf));
1002         ret = dns_rdata_fromtext(&rdata, rdclass, keytype, lex, NULL,
1003                                  ISC_FALSE, mctx, &b, NULL);
1004         if (ret != ISC_R_SUCCESS)
1005                 goto cleanup;
1006
1007         ret = dst_key_fromdns(dns_fixedname_name(&name), rdclass, &b, mctx,
1008                               keyp);
1009         if (ret != ISC_R_SUCCESS)
1010                 goto cleanup;
1011
1012  cleanup:
1013         if (lex != NULL)
1014                 isc_lex_destroy(&lex);
1015         return (ret);
1016 }
1017
1018 static isc_boolean_t
1019 issymmetric(const dst_key_t *key) {
1020         REQUIRE(dst_initialized == ISC_TRUE);
1021         REQUIRE(VALID_KEY(key));
1022
1023         /* XXXVIX this switch statement is too sparse to gen a jump table. */
1024         switch (key->key_alg) {
1025         case DST_ALG_RSAMD5:
1026         case DST_ALG_RSASHA1:
1027         case DST_ALG_DSA:
1028         case DST_ALG_DH:
1029                 return (ISC_FALSE);
1030         case DST_ALG_HMACMD5:
1031         case DST_ALG_GSSAPI:
1032                 return (ISC_TRUE);
1033         default:
1034                 return (ISC_FALSE);
1035         }
1036 }
1037
1038 /*%
1039  * Writes a public key to disk in DNS format.
1040  */
1041 static isc_result_t
1042 write_public_key(const dst_key_t *key, int type, const char *directory) {
1043         FILE *fp;
1044         isc_buffer_t keyb, textb, fileb, classb;
1045         isc_region_t r;
1046         char filename[ISC_DIR_NAMEMAX];
1047         unsigned char key_array[DST_KEY_MAXSIZE];
1048         char text_array[DST_KEY_MAXTEXTSIZE];
1049         char class_array[10];
1050         isc_result_t ret;
1051         dns_rdata_t rdata = DNS_RDATA_INIT;
1052         isc_fsaccess_t access;
1053
1054         REQUIRE(VALID_KEY(key));
1055
1056         isc_buffer_init(&keyb, key_array, sizeof(key_array));
1057         isc_buffer_init(&textb, text_array, sizeof(text_array));
1058         isc_buffer_init(&classb, class_array, sizeof(class_array));
1059
1060         ret = dst_key_todns(key, &keyb);
1061         if (ret != ISC_R_SUCCESS)
1062                 return (ret);
1063
1064         isc_buffer_usedregion(&keyb, &r);
1065         dns_rdata_fromregion(&rdata, key->key_class, dns_rdatatype_dnskey, &r);
1066
1067         ret = dns_rdata_totext(&rdata, (dns_name_t *) NULL, &textb);
1068         if (ret != ISC_R_SUCCESS)
1069                 return (DST_R_INVALIDPUBLICKEY);
1070
1071         ret = dns_rdataclass_totext(key->key_class, &classb);
1072         if (ret != ISC_R_SUCCESS)
1073                 return (DST_R_INVALIDPUBLICKEY);
1074
1075         /*
1076          * Make the filename.
1077          */
1078         isc_buffer_init(&fileb, filename, sizeof(filename));
1079         ret = dst_key_buildfilename(key, DST_TYPE_PUBLIC, directory, &fileb);
1080         if (ret != ISC_R_SUCCESS)
1081                 return (ret);
1082
1083         /*
1084          * Create public key file.
1085          */
1086         if ((fp = fopen(filename, "w")) == NULL)
1087                 return (DST_R_WRITEERROR);
1088
1089         if (issymmetric(key)) {
1090                 access = 0;
1091                 isc_fsaccess_add(ISC_FSACCESS_OWNER,
1092                                  ISC_FSACCESS_READ | ISC_FSACCESS_WRITE,
1093                                  &access);
1094                 (void)isc_fsaccess_set(filename, access);
1095         }
1096
1097         ret = dns_name_print(key->key_name, fp);
1098         if (ret != ISC_R_SUCCESS) {
1099                 fclose(fp);
1100                 return (ret);
1101         }
1102
1103         fprintf(fp, " ");
1104
1105         isc_buffer_usedregion(&classb, &r);
1106         fwrite(r.base, 1, r.length, fp);
1107
1108         if ((type & DST_TYPE_KEY) != 0)
1109                 fprintf(fp, " KEY ");
1110         else
1111                 fprintf(fp, " DNSKEY ");
1112
1113         isc_buffer_usedregion(&textb, &r);
1114         fwrite(r.base, 1, r.length, fp);
1115
1116         fputc('\n', fp);
1117         fflush(fp);
1118         if (ferror(fp))
1119                 ret = DST_R_WRITEERROR;
1120         fclose(fp);
1121
1122         return (ret);
1123 }
1124
1125 static isc_result_t
1126 buildfilename(dns_name_t *name, dns_keytag_t id,
1127               unsigned int alg, unsigned int type,
1128               const char *directory, isc_buffer_t *out)
1129 {
1130         const char *suffix = "";
1131         unsigned int len;
1132         isc_result_t result;
1133
1134         REQUIRE(out != NULL);
1135         if ((type & DST_TYPE_PRIVATE) != 0)
1136                 suffix = ".private";
1137         else if (type == DST_TYPE_PUBLIC)
1138                 suffix = ".key";
1139         if (directory != NULL) {
1140                 if (isc_buffer_availablelength(out) < strlen(directory))
1141                         return (ISC_R_NOSPACE);
1142                 isc_buffer_putstr(out, directory);
1143                 if (strlen(directory) > 0U &&
1144                     directory[strlen(directory) - 1] != '/')
1145                         isc_buffer_putstr(out, "/");
1146         }
1147         if (isc_buffer_availablelength(out) < 1)
1148                 return (ISC_R_NOSPACE);
1149         isc_buffer_putstr(out, "K");
1150         result = dns_name_tofilenametext(name, ISC_FALSE, out);
1151         if (result != ISC_R_SUCCESS)
1152                 return (result);
1153         len = 1 + 3 + 1 + 5 + strlen(suffix) + 1;
1154         if (isc_buffer_availablelength(out) < len)
1155                 return (ISC_R_NOSPACE);
1156         sprintf((char *) isc_buffer_used(out), "+%03d+%05d%s", alg, id,
1157                 suffix);
1158         isc_buffer_add(out, len);
1159
1160         return (ISC_R_SUCCESS);
1161 }
1162
1163 static isc_result_t
1164 computeid(dst_key_t *key) {
1165         isc_buffer_t dnsbuf;
1166         unsigned char dns_array[DST_KEY_MAXSIZE];
1167         isc_region_t r;
1168         isc_result_t ret;
1169
1170         isc_buffer_init(&dnsbuf, dns_array, sizeof(dns_array));
1171         ret = dst_key_todns(key, &dnsbuf);
1172         if (ret != ISC_R_SUCCESS)
1173                 return (ret);
1174
1175         isc_buffer_usedregion(&dnsbuf, &r);
1176         key->key_id = dst_region_computeid(&r, key->key_alg);
1177         return (ISC_R_SUCCESS);
1178 }
1179
1180 static isc_result_t
1181 frombuffer(dns_name_t *name, unsigned int alg, unsigned int flags,
1182            unsigned int protocol, dns_rdataclass_t rdclass,
1183            isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp)
1184 {
1185         dst_key_t *key;
1186         isc_result_t ret;
1187
1188         REQUIRE(dns_name_isabsolute(name));
1189         REQUIRE(source != NULL);
1190         REQUIRE(mctx != NULL);
1191         REQUIRE(keyp != NULL && *keyp == NULL);
1192
1193         key = get_key_struct(name, alg, flags, protocol, 0, rdclass, mctx);
1194         if (key == NULL)
1195                 return (ISC_R_NOMEMORY);
1196
1197         if (isc_buffer_remaininglength(source) > 0) {
1198                 ret = algorithm_status(alg);
1199                 if (ret != ISC_R_SUCCESS) {
1200                         dst_key_free(&key);
1201                         return (ret);
1202                 }
1203                 if (key->func->fromdns == NULL) {
1204                         dst_key_free(&key);
1205                         return (DST_R_UNSUPPORTEDALG);
1206                 }
1207
1208                 ret = key->func->fromdns(key, source);
1209                 if (ret != ISC_R_SUCCESS) {
1210                         dst_key_free(&key);
1211                         return (ret);
1212                 }
1213         }
1214
1215         *keyp = key;
1216         return (ISC_R_SUCCESS);
1217 }
1218
1219 static isc_result_t
1220 algorithm_status(unsigned int alg) {
1221         REQUIRE(dst_initialized == ISC_TRUE);
1222
1223         if (dst_algorithm_supported(alg))
1224                 return (ISC_R_SUCCESS);
1225 #ifndef OPENSSL
1226         if (alg == DST_ALG_RSAMD5 || alg == DST_ALG_RSASHA1 ||
1227             alg == DST_ALG_DSA || alg == DST_ALG_DH ||
1228             alg == DST_ALG_HMACMD5)
1229                 return (DST_R_NOCRYPTO);
1230 #endif
1231         return (DST_R_UNSUPPORTEDALG);
1232 }
1233
1234 static isc_result_t
1235 addsuffix(char *filename, unsigned int len, const char *ofilename,
1236           const char *suffix)
1237 {
1238         int olen = strlen(ofilename);
1239         int n;
1240
1241         if (olen > 1 && ofilename[olen - 1] == '.')
1242                 olen -= 1;
1243         else if (olen > 8 && strcmp(ofilename + olen - 8, ".private") == 0)
1244                 olen -= 8;
1245         else if (olen > 4 && strcmp(ofilename + olen - 4, ".key") == 0)
1246                 olen -= 4;
1247
1248         n = snprintf(filename, len, "%.*s%s", olen, ofilename, suffix);
1249         if (n < 0)
1250                 return (ISC_R_NOSPACE);
1251         return (ISC_R_SUCCESS);
1252 }
1253
1254 isc_result_t
1255 dst__entropy_getdata(void *buf, unsigned int len, isc_boolean_t pseudo) {
1256         unsigned int flags = dst_entropy_flags;
1257         if (pseudo)
1258                 flags &= ~ISC_ENTROPY_GOODONLY;
1259         return (isc_entropy_getdata(dst_entropy_pool, buf, len, NULL, flags));
1260 }
1261
1262 unsigned int
1263 dst__entropy_status(void) {
1264         return (isc_entropy_status(dst_entropy_pool));
1265 }