path: root/contrib/bind9/lib/dns/include/dst/dst.h

/*
 * Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
 * Copyright (C) 2000-2002  Internet Software Consortium.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/* $Id: dst.h,v 1.1.4.1 2004/12/09 04:07:19 marka Exp $ */

#ifndef DST_DST_H
#define DST_DST_H 1

#include <isc/lang.h>

#include <dns/types.h>

ISC_LANG_BEGINDECLS

/***
 *** Types
 ***/

/*
 * The dst_key structure is opaque.  Applications should use the accessor
 * functions provided to retrieve key attributes.  If an application needs
 * to set attributes, new accessor functions will be written.
 */

typedef struct dst_key		dst_key_t;
typedef struct dst_context 	dst_context_t;

/* DST algorithm codes */
#define DST_ALG_UNKNOWN		0
#define DST_ALG_RSAMD5		1
#define DST_ALG_RSA		DST_ALG_RSAMD5	/* backwards compatibility */
#define DST_ALG_DH		2
#define DST_ALG_DSA		3
#define DST_ALG_ECC		4
#define DST_ALG_RSASHA1		5
#define DST_ALG_HMACMD5		157
#define DST_ALG_GSSAPI		160
#define DST_ALG_PRIVATE		254
#define DST_ALG_EXPAND		255
#define DST_MAX_ALGS		255

/* A buffer of this size is large enough to hold any key */
#define DST_KEY_MAXSIZE		1280

/*
 * A buffer of this size is large enough to hold the textual representation
 * of any key
 */
#define DST_KEY_MAXTEXTSIZE	2048

/* 'Type' for dst_read_key() */
#define DST_TYPE_KEY		0x1000000	/* KEY key */
#define DST_TYPE_PRIVATE	0x2000000
#define DST_TYPE_PUBLIC		0x4000000

/***
 *** Functions
 ***/

isc_result_t
dst_lib_init(isc_mem_t *mctx, isc_entropy_t *ectx, unsigned int eflags);
/*
 * Initializes the DST subsystem.
 *
 * Requires:
 * 	"mctx" is a valid memory context
 * 	"ectx" is a valid entropy context
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	ISC_R_NOMEMORY
 *
 * Ensures:
 * 	DST is properly initialized.
 */

void
dst_lib_destroy(void);
/*
 * Releases all resources allocated by DST.
 */

isc_boolean_t
dst_algorithm_supported(unsigned int alg);
/*
 * Checks that a given algorithm is supported by DST.
 *
 * Returns:
 * 	ISC_TRUE
 * 	ISC_FALSE
 */

isc_result_t
dst_context_create(dst_key_t *key, isc_mem_t *mctx, dst_context_t **dctxp);
/*
 * Creates a context to be used for a sign or verify operation.
 *
 * Requires:
 *	"key" is a valid key.
 * 	"mctx" is a valid memory context.
 * 	dctxp != NULL && *dctxp == NULL
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	ISC_R_NOMEMORY
 *
 * Ensures:
 *	*dctxp will contain a usable context.
 */

void
dst_context_destroy(dst_context_t **dctxp);
/*
 * Destroys all memory associated with a context.
 *
 * Requires:
 * 	*dctxp != NULL && *dctxp == NULL
 *
 * Ensures:
 *	*dctxp == NULL
 */

isc_result_t
dst_context_adddata(dst_context_t *dctx, const isc_region_t *data);
/*
 * Incrementally adds data to the context to be used in a sign or verify
 * operation.
 *
 * Requires:
 * 	"dctx" is a valid context
 * 	"data" is a valid region
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	DST_R_SIGNFAILURE
 * 	all other errors indicate failure
 */

isc_result_t
dst_context_sign(dst_context_t *dctx, isc_buffer_t *sig);
/*
 * Computes a signature using the data and key stored in the context.
 *
 * Requires:
 * 	"dctx" is a valid context.
 *	"sig" is a valid buffer.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	DST_R_VERIFYFAILURE
 * 	all other errors indicate failure
 *
 * Ensures:
 *	"sig" will contain the signature
 */

isc_result_t
dst_context_verify(dst_context_t *dctx, isc_region_t *sig);
/*
 * Verifies the signature using the data and key stored in the context.
 *
 * Requires:
 * 	"dctx" is a valid context.
 *	"sig" is a valid region.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	all other errors indicate failure
 *
 * Ensures:
 *	"sig" will contain the signature
 */

isc_result_t
dst_key_computesecret(const dst_key_t *pub, const dst_key_t *priv,
		      isc_buffer_t *secret);
/*
 * Computes a shared secret from two (Diffie-Hellman) keys.
 *
 * Requires:
 *     "pub" is a valid key that can be used to derive a shared secret
 *     "priv" is a valid private key that can be used to derive a shared secret
 *     "secret" is a valid buffer
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *      If successful, secret will contain the derived shared secret.
 */

isc_result_t
dst_key_fromfile(dns_name_t *name, dns_keytag_t id, unsigned int alg, int type,
		 const char *directory, isc_mem_t *mctx, dst_key_t **keyp);
/*
 * Reads a key from permanent storage.  The key can either be a public or
 * private key, and is specified by name, algorithm, and id.  If a private key
 * is specified, the public key must also be present.  If directory is NULL,
 * the current directory is assumed.
 *
 * Requires:
 *	"name" is a valid absolute dns name.
 *	"id" is a valid key tag identifier.
 *	"alg" is a supported key algorithm.
 *	"type" is DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or the bitwise union.
 *		  DST_TYPE_KEY look for a KEY record otherwise DNSKEY
 *	"mctx" is a valid memory context.
 *	"keyp" is not NULL and "*keyp" is NULL.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, *keyp will contain a valid key.
 */

isc_result_t
dst_key_fromnamedfile(const char *filename, int type, isc_mem_t *mctx,
		      dst_key_t **keyp);
/*
 * Reads a key from permanent storage.  The key can either be a public or
 * key, and is specified by filename.  If a private key is specified, the
 * public key must also be present.
 *
 * Requires:
 * 	"filename" is not NULL
 *	"type" is DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or the bitwise union
 *		  DST_TYPE_KEY look for a KEY record otherwise DNSKEY
 *	"mctx" is a valid memory context
 *	"keyp" is not NULL and "*keyp" is NULL.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, *keyp will contain a valid key.
 */

isc_result_t
dst_key_tofile(const dst_key_t *key, int type, const char *directory);
/*
 * Writes a key to permanent storage.  The key can either be a public or
 * private key.  Public keys are written in DNS format and private keys
 * are written as a set of base64 encoded values.  If directory is NULL,
 * the current directory is assumed.
 *
 * Requires:
 *	"key" is a valid key.
 *	"type" is DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or the bitwise union
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 */

isc_result_t
dst_key_fromdns(dns_name_t *name, dns_rdataclass_t rdclass,
		isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp);
/*
 * Converts a DNS KEY record into a DST key.
 *
 * Requires:
 *	"name" is a valid absolute dns name.
 *	"source" is a valid buffer.  There must be at least 4 bytes available.
 *	"mctx" is a valid memory context.
 *	"keyp" is not NULL and "*keyp" is NULL.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, *keyp will contain a valid key, and the consumed
 *	pointer in data will be advanced.
 */

isc_result_t
dst_key_todns(const dst_key_t *key, isc_buffer_t *target);
/*
 * Converts a DST key into a DNS KEY record.
 *
 * Requires:
 *	"key" is a valid key.
 *	"target" is a valid buffer.  There must be at least 4 bytes unused.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, the used pointer in 'target' is advanced by at least 4.
 */

isc_result_t
dst_key_frombuffer(dns_name_t *name, unsigned int alg,
		   unsigned int flags, unsigned int protocol,
		   dns_rdataclass_t rdclass,
		   isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp);
/*
 * Converts a buffer containing DNS KEY RDATA into a DST key.
 *
 * Requires:
 *	"name" is a valid absolute dns name.
 *	"alg" is a supported key algorithm.
 *	"source" is a valid buffer.
 *	"mctx" is a valid memory context.
 *	"keyp" is not NULL and "*keyp" is NULL.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, *keyp will contain a valid key, and the consumed
 *	pointer in source will be advanced.
 */

isc_result_t
dst_key_tobuffer(const dst_key_t *key, isc_buffer_t *target);
/*
 * Converts a DST key into DNS KEY RDATA format.
 *
 * Requires:
 *	"key" is a valid key.
 *	"target" is a valid buffer.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, the used pointer in 'target' is advanced.
 */

isc_result_t
dst_key_privatefrombuffer(dst_key_t *key, isc_buffer_t *buffer);
/*
 * Converts a public key into a private key, reading the private key
 * information from the buffer.  The buffer should contain the same data
 * as the .private key file would.
 *
 * Requires:
 * 	"key" is a valid public key.
 *	"buffer" is not NULL.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, key will contain a valid private key.
 */


isc_result_t
dst_key_fromgssapi(dns_name_t *name, void *opaque, isc_mem_t *mctx,
		                   dst_key_t **keyp);
/*
 * Converts a GSSAPI opaque context id into a DST key.
 *
 * Requires:
 *	"name" is a valid absolute dns name.
 *	"opaque" is a GSSAPI context id.
 *	"mctx" is a valid memory context.
 *	"keyp" is not NULL and "*keyp" is NULL.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, *keyp will contain a valid key and be responsible for
 *	the context id.
 */

isc_result_t
dst_key_generate(dns_name_t *name, unsigned int alg,
		 unsigned int bits, unsigned int param,
		 unsigned int flags, unsigned int protocol,
		 dns_rdataclass_t rdclass,
		 isc_mem_t *mctx, dst_key_t **keyp);
/*
 * Generate a DST key (or keypair) with the supplied parameters.  The
 * interpretation of the "param" field depends on the algorithm:
 * 	RSA:	exponent
 * 		0	use exponent 3
 * 		!0	use Fermat4 (2^16 + 1)
 * 	DH:	generator
 * 		0	default - use well known prime if bits == 768 or 1024,
 * 			otherwise use 2 as the generator.
 * 		!0	use this value as the generator.
 * 	DSA:	unused
 * 	HMACMD5: entropy
 *		0	default - require good entropy
 *		!0	lack of good entropy is ok
 *
 * Requires:
 *	"name" is a valid absolute dns name.
 *	"keyp" is not NULL and "*keyp" is NULL.
 *
 * Returns:
 * 	ISC_R_SUCCESS
 * 	any other result indicates failure
 *
 * Ensures:
 *	If successful, *keyp will contain a valid key.
 */

isc_boolean_t
dst_key_compare(const dst_key_t *key1, const dst_key_t *key2);
/*
 * Compares two DST keys.
 *
 * Requires:
 *	"key1" is a valid key.
 *	"key2" is a valid key.
 *
 * Returns:
 * 	ISC_TRUE
 * 	ISC_FALSE
 */

isc_boolean_t
dst_key_paramcompare(const dst_key_t *key1, const dst_key_t *key2);
/*
 * Compares the parameters of two DST keys.  This is used to determine if
 * two (Diffie-Hellman) keys can be used to derive a shared secret.
 *
 * Requires:
 *	"key1" is a valid key.
 *	"key2" is a valid key.
 *
 * Returns:
 * 	ISC_TRUE
 * 	ISC_FALSE
 */

void
dst_key_free(dst_key_t **keyp);
/*
 * Release all memory associated with the key.
 *
 * Requires:
 *	"keyp" is not NULL and "*keyp" is a valid key.
 *
 * Ensures:
 *	All memory associated with "*keyp" will be freed.
 *	*keyp == NULL
 */

/*
 * Accessor functions to obtain key fields.
 *
 * Require:
 *	"key" is a valid key.
 */
dns_name_t *
dst_key_name(const dst_key_t *key);

unsigned int
dst_key_size(const dst_key_t *key);

unsigned int
dst_key_proto(const dst_key_t *key);

unsigned int
dst_key_alg(const dst_key_t *key);

isc_uint32_t
dst_key_flags(const dst_key_t *key);

dns_keytag_t
dst_key_id(const dst_key_t *key);

dns_rdataclass_t
dst_key_class(const dst_key_t *key);

isc_boolean_t
dst_key_isprivate(const dst_key_t *key);

isc_boolean_t
dst_key_iszonekey(const dst_key_t *key);

isc_boolean_t
dst_key_isnullkey(const dst_key_t *key);

isc_result_t
dst_key_buildfilename(const dst_key_t *key, int type,
		      const char *directory, isc_buffer_t *out);
/*
 * Generates the filename used by dst to store the specified key.
 * If directory is NULL, the current directory is assumed.
 *
 * Requires:
 *	"key" is a valid key
 *	"type" is either DST_TYPE_PUBLIC, DST_TYPE_PRIVATE, or 0 for no suffix.
 *	"out" is a valid buffer
 *
 * Ensures:
 *	the file name will be written to "out", and the used pointer will
 *		be advanced.
 */

isc_result_t
dst_key_sigsize(const dst_key_t *key, unsigned int *n);
/*
 * Computes the size of a signature generated by the given key.
 *
 * Requires:
 *	"key" is a valid key.
 *	"n" is not NULL
 *
 * Returns:
 *	ISC_R_SUCCESS
 *	DST_R_UNSUPPORTEDALG
 *
 * Ensures:
 * 	"n" stores the size of a generated signature
 */

isc_result_t
dst_key_secretsize(const dst_key_t *key, unsigned int *n);
/*
 * Computes the size of a shared secret generated by the given key.
 *
 * Requires:
 *	"key" is a valid key.
 *	"n" is not NULL
 *
 * Returns:
 *	ISC_R_SUCCESS
 *	DST_R_UNSUPPORTEDALG
 *
 * Ensures:
 * 	"n" stores the size of a generated shared secret
 */

isc_uint16_t
dst_region_computeid(const isc_region_t *source, unsigned int alg);
/*
 * Computes the key id of the key stored in the provided region with the
 * given algorithm.
 *
 * Requires:
 * 	"source" contains a valid, non-NULL region.
 *
 * Returns:
 * 	the key id
 */

ISC_LANG_ENDDECLS

#endif /* DST_DST_H */