Import bind 9.5.2 vendor sources.
[dragonfly.git] / contrib / bind-9.5.2 / lib / dns / include / dst / dst.h
1 /*
2  * Copyright (C) 2004-2007  Internet Systems Consortium, Inc. ("ISC")
3  * Copyright (C) 2000-2002  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 DISCLAIMS ALL WARRANTIES WITH
10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15  * PERFORMANCE OF THIS SOFTWARE.
16  */
17
18 /* $Id: dst.h,v 1.9 2007/06/19 23:47:17 tbox Exp $ */
19
20 #ifndef DST_DST_H
21 #define DST_DST_H 1
22
23 /*! \file dst/dst.h */
24
25 #include <isc/lang.h>
26
27 #include <dns/types.h>
28
29 #include <dst/gssapi.h>
30
31 ISC_LANG_BEGINDECLS
32
33 /***
34  *** Types
35  ***/
36
37 /*%
38  * The dst_key structure is opaque.  Applications should use the accessor
39  * functions provided to retrieve key attributes.  If an application needs
40  * to set attributes, new accessor functions will be written.
41  */
42
43 typedef struct dst_key          dst_key_t;
44 typedef struct dst_context      dst_context_t;
45
46 /* DST algorithm codes */
47 #define DST_ALG_UNKNOWN         0
48 #define DST_ALG_RSAMD5          1
49 #define DST_ALG_RSA             DST_ALG_RSAMD5  /*%< backwards compatibility */
50 #define DST_ALG_DH              2
51 #define DST_ALG_DSA             3
52 #define DST_ALG_ECC             4
53 #define DST_ALG_RSASHA1         5
54 #define DST_ALG_HMACMD5         157
55 #define DST_ALG_GSSAPI          160
56 #define DST_ALG_HMACSHA1        161     /* XXXMPA */
57 #define DST_ALG_HMACSHA224      162     /* XXXMPA */
58 #define DST_ALG_HMACSHA256      163     /* XXXMPA */
59 #define DST_ALG_HMACSHA384      164     /* XXXMPA */
60 #define DST_ALG_HMACSHA512      165     /* XXXMPA */
61 #define DST_ALG_PRIVATE         254
62 #define DST_ALG_EXPAND          255
63 #define DST_MAX_ALGS            255
64
65 /*% A buffer of this size is large enough to hold any key */
66 #define DST_KEY_MAXSIZE         1280
67
68 /*%
69  * A buffer of this size is large enough to hold the textual representation
70  * of any key
71  */
72 #define DST_KEY_MAXTEXTSIZE     2048
73
74 /*% 'Type' for dst_read_key() */
75 #define DST_TYPE_KEY            0x1000000       /* KEY key */
76 #define DST_TYPE_PRIVATE        0x2000000
77 #define DST_TYPE_PUBLIC         0x4000000
78
79 /***
80  *** Functions
81  ***/
82
83 isc_result_t
84 dst_lib_init(isc_mem_t *mctx, isc_entropy_t *ectx, unsigned int eflags);
85 /*%<
86  * Initializes the DST subsystem.
87  *
88  * Requires:
89  * \li  "mctx" is a valid memory context
90  * \li  "ectx" is a valid entropy context
91  *
92  * Returns:
93  * \li  ISC_R_SUCCESS
94  * \li  ISC_R_NOMEMORY
95  *
96  * Ensures:
97  * \li  DST is properly initialized.
98  */
99
100 void
101 dst_lib_destroy(void);
102 /*%<
103  * Releases all resources allocated by DST.
104  */
105
106 isc_boolean_t
107 dst_algorithm_supported(unsigned int alg);
108 /*%<
109  * Checks that a given algorithm is supported by DST.
110  *
111  * Returns:
112  * \li  ISC_TRUE
113  * \li  ISC_FALSE
114  */
115
116 isc_result_t
117 dst_context_create(dst_key_t *key, isc_mem_t *mctx, dst_context_t **dctxp);
118 /*%<
119  * Creates a context to be used for a sign or verify operation.
120  *
121  * Requires:
122  * \li  "key" is a valid key.
123  * \li  "mctx" is a valid memory context.
124  * \li  dctxp != NULL && *dctxp == NULL
125  *
126  * Returns:
127  * \li  ISC_R_SUCCESS
128  * \li  ISC_R_NOMEMORY
129  *
130  * Ensures:
131  * \li  *dctxp will contain a usable context.
132  */
133
134 void
135 dst_context_destroy(dst_context_t **dctxp);
136 /*%<
137  * Destroys all memory associated with a context.
138  *
139  * Requires:
140  * \li  *dctxp != NULL && *dctxp == NULL
141  *
142  * Ensures:
143  * \li  *dctxp == NULL
144  */
145
146 isc_result_t
147 dst_context_adddata(dst_context_t *dctx, const isc_region_t *data);
148 /*%<
149  * Incrementally adds data to the context to be used in a sign or verify
150  * operation.
151  *
152  * Requires:
153  * \li  "dctx" is a valid context
154  * \li  "data" is a valid region
155  *
156  * Returns:
157  * \li  ISC_R_SUCCESS
158  * \li  DST_R_SIGNFAILURE
159  * \li  all other errors indicate failure
160  */
161
162 isc_result_t
163 dst_context_sign(dst_context_t *dctx, isc_buffer_t *sig);
164 /*%<
165  * Computes a signature using the data and key stored in the context.
166  *
167  * Requires:
168  * \li  "dctx" is a valid context.
169  * \li  "sig" is a valid buffer.
170  *
171  * Returns:
172  * \li  ISC_R_SUCCESS
173  * \li  DST_R_VERIFYFAILURE
174  * \li  all other errors indicate failure
175  *
176  * Ensures:
177  * \li  "sig" will contain the signature
178  */
179
180 isc_result_t
181 dst_context_verify(dst_context_t *dctx, isc_region_t *sig);
182 /*%<
183  * Verifies the signature using the data and key stored in the context.
184  *
185  * Requires:
186  * \li  "dctx" is a valid context.
187  * \li  "sig" is a valid region.
188  *
189  * Returns:
190  * \li  ISC_R_SUCCESS
191  * \li  all other errors indicate failure
192  *
193  * Ensures:
194  * \li  "sig" will contain the signature
195  */
196
197 isc_result_t
198 dst_key_computesecret(const dst_key_t *pub, const dst_key_t *priv,
199                       isc_buffer_t *secret);
200 /*%<
201  * Computes a shared secret from two (Diffie-Hellman) keys.
202  *
203  * Requires:
204  * \li  "pub" is a valid key that can be used to derive a shared secret
205  * \li  "priv" is a valid private key that can be used to derive a shared secret
206  * \li  "secret" is a valid buffer
207  *
208  * Returns:
209  * \li  ISC_R_SUCCESS
210  * \li  any other result indicates failure
211  *
212  * Ensures:
213  * \li  If successful, secret will contain the derived shared secret.
214  */
215
216 isc_result_t
217 dst_key_fromfile(dns_name_t *name, dns_keytag_t id, unsigned int alg, int type,
218                  const char *directory, isc_mem_t *mctx, dst_key_t **keyp);
219 /*%<
220  * Reads a key from permanent storage.  The key can either be a public or
221  * private key, and is specified by name, algorithm, and id.  If a private key
222  * is specified, the public key must also be present.  If directory is NULL,
223  * the current directory is assumed.
224  *
225  * Requires:
226  * \li  "name" is a valid absolute dns name.
227  * \li  "id" is a valid key tag identifier.
228  * \li  "alg" is a supported key algorithm.
229  * \li  "type" is DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or the bitwise union.
230  *                DST_TYPE_KEY look for a KEY record otherwise DNSKEY
231  * \li  "mctx" is a valid memory context.
232  * \li  "keyp" is not NULL and "*keyp" is NULL.
233  *
234  * Returns:
235  * \li  ISC_R_SUCCESS
236  * \li  any other result indicates failure
237  *
238  * Ensures:
239  * \li  If successful, *keyp will contain a valid key.
240  */
241
242 isc_result_t
243 dst_key_fromnamedfile(const char *filename, int type, isc_mem_t *mctx,
244                       dst_key_t **keyp);
245 /*%<
246  * Reads a key from permanent storage.  The key can either be a public or
247  * key, and is specified by filename.  If a private key is specified, the
248  * public key must also be present.
249  *
250  * Requires:
251  * \li  "filename" is not NULL
252  * \li  "type" is DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or the bitwise union
253  *                DST_TYPE_KEY look for a KEY record otherwise DNSKEY
254  * \li  "mctx" is a valid memory context
255  * \li  "keyp" is not NULL and "*keyp" is NULL.
256  *
257  * Returns:
258  * \li  ISC_R_SUCCESS
259  * \li  any other result indicates failure
260  *
261  * Ensures:
262  * \li  If successful, *keyp will contain a valid key.
263  */
264
265
266 isc_result_t
267 dst_key_read_public(const char *filename, int type,
268                     isc_mem_t *mctx, dst_key_t **keyp);
269 /*%<
270  * Reads a public key from permanent storage.  The key must be a public key.
271  *
272  * Requires:
273  * \li  "filename" is not NULL
274  * \li  "type" is DST_TYPE_KEY look for a KEY record otherwise DNSKEY
275  * \li  "mctx" is a valid memory context
276  * \li  "keyp" is not NULL and "*keyp" is NULL.
277  *
278  * Returns:
279  * \li  ISC_R_SUCCESS
280  * \li  DST_R_BADKEYTYPE if the key type is not the expected one
281  * \li  ISC_R_UNEXPECTEDTOKEN if the file can not be parsed as a public key
282  * \li  any other result indicates failure
283  *
284  * Ensures:
285  * \li  If successful, *keyp will contain a valid key.
286  */
287
288 isc_result_t
289 dst_key_tofile(const dst_key_t *key, int type, const char *directory);
290 /*%<
291  * Writes a key to permanent storage.  The key can either be a public or
292  * private key.  Public keys are written in DNS format and private keys
293  * are written as a set of base64 encoded values.  If directory is NULL,
294  * the current directory is assumed.
295  *
296  * Requires:
297  * \li  "key" is a valid key.
298  * \li  "type" is DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or the bitwise union
299  *
300  * Returns:
301  * \li  ISC_R_SUCCESS
302  * \li  any other result indicates failure
303  */
304
305 isc_result_t
306 dst_key_fromdns(dns_name_t *name, dns_rdataclass_t rdclass,
307                 isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp);
308 /*%<
309  * Converts a DNS KEY record into a DST key.
310  *
311  * Requires:
312  * \li  "name" is a valid absolute dns name.
313  * \li  "source" is a valid buffer.  There must be at least 4 bytes available.
314  * \li  "mctx" is a valid memory context.
315  * \li  "keyp" is not NULL and "*keyp" is NULL.
316  *
317  * Returns:
318  * \li  ISC_R_SUCCESS
319  * \li  any other result indicates failure
320  *
321  * Ensures:
322  * \li  If successful, *keyp will contain a valid key, and the consumed
323  *      pointer in data will be advanced.
324  */
325
326 isc_result_t
327 dst_key_todns(const dst_key_t *key, isc_buffer_t *target);
328 /*%<
329  * Converts a DST key into a DNS KEY record.
330  *
331  * Requires:
332  * \li  "key" is a valid key.
333  * \li  "target" is a valid buffer.  There must be at least 4 bytes unused.
334  *
335  * Returns:
336  * \li  ISC_R_SUCCESS
337  * \li  any other result indicates failure
338  *
339  * Ensures:
340  * \li  If successful, the used pointer in 'target' is advanced by at least 4.
341  */
342
343 isc_result_t
344 dst_key_frombuffer(dns_name_t *name, unsigned int alg,
345                    unsigned int flags, unsigned int protocol,
346                    dns_rdataclass_t rdclass,
347                    isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp);
348 /*%<
349  * Converts a buffer containing DNS KEY RDATA into a DST key.
350  *
351  * Requires:
352  *\li   "name" is a valid absolute dns name.
353  *\li   "alg" is a supported key algorithm.
354  *\li   "source" is a valid buffer.
355  *\li   "mctx" is a valid memory context.
356  *\li   "keyp" is not NULL and "*keyp" is NULL.
357  *
358  * Returns:
359  *\li   ISC_R_SUCCESS
360  * \li  any other result indicates failure
361  *
362  * Ensures:
363  *\li   If successful, *keyp will contain a valid key, and the consumed
364  *      pointer in source will be advanced.
365  */
366
367 isc_result_t
368 dst_key_tobuffer(const dst_key_t *key, isc_buffer_t *target);
369 /*%<
370  * Converts a DST key into DNS KEY RDATA format.
371  *
372  * Requires:
373  *\li   "key" is a valid key.
374  *\li   "target" is a valid buffer.
375  *
376  * Returns:
377  *\li   ISC_R_SUCCESS
378  * \li  any other result indicates failure
379  *
380  * Ensures:
381  *\li   If successful, the used pointer in 'target' is advanced.
382  */
383
384 isc_result_t
385 dst_key_privatefrombuffer(dst_key_t *key, isc_buffer_t *buffer);
386 /*%<
387  * Converts a public key into a private key, reading the private key
388  * information from the buffer.  The buffer should contain the same data
389  * as the .private key file would.
390  *
391  * Requires:
392  *\li   "key" is a valid public key.
393  *\li   "buffer" is not NULL.
394  *
395  * Returns:
396  *\li   ISC_R_SUCCESS
397  * \li  any other result indicates failure
398  *
399  * Ensures:
400  *\li   If successful, key will contain a valid private key.
401  */
402
403 gss_ctx_id_t
404 dst_key_getgssctx(const dst_key_t *key);
405 /*%<
406  * Returns the opaque key data.
407  * Be cautions when using this value unless you know what you are doing.
408  *
409  * Requires:
410  *\li   "key" is not NULL.
411  *
412  * Returns:
413  *\li   gssctx key data, possibly NULL.
414  */
415
416 isc_result_t
417 dst_key_fromgssapi(dns_name_t *name, gss_ctx_id_t gssctx, isc_mem_t *mctx,
418                    dst_key_t **keyp);
419 /*%<
420  * Converts a GSSAPI opaque context id into a DST key.
421  *
422  * Requires:
423  *\li   "name" is a valid absolute dns name.
424  *\li   "gssctx" is a GSSAPI context id.
425  *\li   "mctx" is a valid memory context.
426  *\li   "keyp" is not NULL and "*keyp" is NULL.
427  *
428  * Returns:
429  *\li   ISC_R_SUCCESS
430  * \li  any other result indicates failure
431  *
432  * Ensures:
433  *\li   If successful, *keyp will contain a valid key and be responsible for
434  *      the context id.
435  */
436
437 isc_result_t
438 dst_key_generate(dns_name_t *name, unsigned int alg,
439                  unsigned int bits, unsigned int param,
440                  unsigned int flags, unsigned int protocol,
441                  dns_rdataclass_t rdclass,
442                  isc_mem_t *mctx, dst_key_t **keyp);
443 /*%<
444  * Generate a DST key (or keypair) with the supplied parameters.  The
445  * interpretation of the "param" field depends on the algorithm:
446  * \code
447  *      RSA:    exponent
448  *              0       use exponent 3
449  *              !0      use Fermat4 (2^16 + 1)
450  *      DH:     generator
451  *              0       default - use well known prime if bits == 768 or 1024,
452  *                      otherwise use 2 as the generator.
453  *              !0      use this value as the generator.
454  *      DSA:    unused
455  *      HMACMD5: entropy
456  *              0       default - require good entropy
457  *              !0      lack of good entropy is ok
458  *\endcode
459  *
460  * Requires:
461  *\li   "name" is a valid absolute dns name.
462  *\li   "keyp" is not NULL and "*keyp" is NULL.
463  *
464  * Returns:
465  *\li   ISC_R_SUCCESS
466  * \li  any other result indicates failure
467  *
468  * Ensures:
469  *\li   If successful, *keyp will contain a valid key.
470  */
471
472 isc_boolean_t
473 dst_key_compare(const dst_key_t *key1, const dst_key_t *key2);
474 /*%<
475  * Compares two DST keys.
476  *
477  * Requires:
478  *\li   "key1" is a valid key.
479  *\li   "key2" is a valid key.
480  *
481  * Returns:
482  *\li   ISC_TRUE
483  * \li  ISC_FALSE
484  */
485
486 isc_boolean_t
487 dst_key_paramcompare(const dst_key_t *key1, const dst_key_t *key2);
488 /*%<
489  * Compares the parameters of two DST keys.  This is used to determine if
490  * two (Diffie-Hellman) keys can be used to derive a shared secret.
491  *
492  * Requires:
493  *\li   "key1" is a valid key.
494  *\li   "key2" is a valid key.
495  *
496  * Returns:
497  *\li   ISC_TRUE
498  * \li  ISC_FALSE
499  */
500
501 void
502 dst_key_free(dst_key_t **keyp);
503 /*%<
504  * Release all memory associated with the key.
505  *
506  * Requires:
507  *\li   "keyp" is not NULL and "*keyp" is a valid key.
508  *
509  * Ensures:
510  *\li   All memory associated with "*keyp" will be freed.
511  *\li   *keyp == NULL
512  */
513
514 /*%<
515  * Accessor functions to obtain key fields.
516  *
517  * Require:
518  *\li   "key" is a valid key.
519  */
520 dns_name_t *
521 dst_key_name(const dst_key_t *key);
522
523 unsigned int
524 dst_key_size(const dst_key_t *key);
525
526 unsigned int
527 dst_key_proto(const dst_key_t *key);
528
529 unsigned int
530 dst_key_alg(const dst_key_t *key);
531
532 isc_uint32_t
533 dst_key_flags(const dst_key_t *key);
534
535 dns_keytag_t
536 dst_key_id(const dst_key_t *key);
537
538 dns_rdataclass_t
539 dst_key_class(const dst_key_t *key);
540
541 isc_boolean_t
542 dst_key_isprivate(const dst_key_t *key);
543
544 isc_boolean_t
545 dst_key_iszonekey(const dst_key_t *key);
546
547 isc_boolean_t
548 dst_key_isnullkey(const dst_key_t *key);
549
550 isc_result_t
551 dst_key_buildfilename(const dst_key_t *key, int type,
552                       const char *directory, isc_buffer_t *out);
553 /*%<
554  * Generates the filename used by dst to store the specified key.
555  * If directory is NULL, the current directory is assumed.
556  *
557  * Requires:
558  *\li   "key" is a valid key
559  *\li   "type" is either DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or 0 for no suffix.
560  *\li   "out" is a valid buffer
561  *
562  * Ensures:
563  *\li   the file name will be written to "out", and the used pointer will
564  *              be advanced.
565  */
566
567 isc_result_t
568 dst_key_sigsize(const dst_key_t *key, unsigned int *n);
569 /*%<
570  * Computes the size of a signature generated by the given key.
571  *
572  * Requires:
573  *\li   "key" is a valid key.
574  *\li   "n" is not NULL
575  *
576  * Returns:
577  *\li   #ISC_R_SUCCESS
578  *\li   DST_R_UNSUPPORTEDALG
579  *
580  * Ensures:
581  *\li   "n" stores the size of a generated signature
582  */
583
584 isc_result_t
585 dst_key_secretsize(const dst_key_t *key, unsigned int *n);
586 /*%<
587  * Computes the size of a shared secret generated by the given key.
588  *
589  * Requires:
590  *\li   "key" is a valid key.
591  *\li   "n" is not NULL
592  *
593  * Returns:
594  *\li   #ISC_R_SUCCESS
595  *\li   DST_R_UNSUPPORTEDALG
596  *
597  * Ensures:
598  *\li   "n" stores the size of a generated shared secret
599  */
600
601 isc_uint16_t
602 dst_region_computeid(const isc_region_t *source, unsigned int alg);
603 /*%<
604  * Computes the key id of the key stored in the provided region with the
605  * given algorithm.
606  *
607  * Requires:
608  *\li   "source" contains a valid, non-NULL region.
609  *
610  * Returns:
611  *\li   the key id
612  */
613
614 isc_uint16_t
615 dst_key_getbits(const dst_key_t *key);
616 /*
617  * Get the number of digest bits required (0 == MAX).
618  *
619  * Requires:
620  *      "key" is a valid key.
621  */
622
623 void
624 dst_key_setbits(dst_key_t *key, isc_uint16_t bits);
625 /*
626  * Set the number of digest bits required (0 == MAX).
627  *
628  * Requires:
629  *      "key" is a valid key.
630  */
631
632 ISC_LANG_ENDDECLS
633
634 #endif /* DST_DST_H */