571 lines
14 KiB
C
571 lines
14 KiB
C
/*
|
|
* 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 */
|