Remove building with NOCRYPTO option

[minix3.git] / external / bsd / dhcp / dist / dst / dst_api.c

/*      $NetBSD: dst_api.c,v 1.4 2014/07/12 12:09:37 spz Exp $  */
#ifndef LINT
static const char rcsid[] = "Header: /tmp/cvstest/DHCP/dst/dst_api.c,v 1.10 2012/04/11 15:43:34 sar Exp ";
#endif

/*
 * Portions Copyright (c) 1995-1998 by Trusted Information Systems, Inc.
 * Portions Copyright (c) 2007,2009 by Internet Systems Consortium, Inc. ("ISC")
 * Portions Copyright (c) 2012-2013 by Internet Systems Consortium, Inc. ("ISC")
 *
 * 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 TRUSTED INFORMATION SYSTEMS
 * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL
 * TRUSTED INFORMATION SYSTEMS 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 THE SOFTWARE.
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: dst_api.c,v 1.4 2014/07/12 12:09:37 spz Exp $");
/*
 * This file contains the interface between the DST API and the crypto API.
 * This is the only file that needs to be changed if the crypto system is
 * changed.  Exported functions are:
 * void dst_init()       Initialize the toolkit
 * int  dst_check_algorithm()   Function to determines if alg is supported.
 * int  dst_compare_keys()      Function to compare two keys for equality.
 * int  dst_sign_data()         Incremental signing routine.
 * int  dst_verify_data()       Incremental verify routine.
 * int  dst_generate_key()      Function to generate new KEY
 * DST_KEY *dst_read_key()      Function to retrieve private/public KEY.
 * void dst_write_key()         Function to write out a key.
 * DST_KEY *dst_dnskey_to_key() Function to convert DNS KEY RR to a DST
 *                              KEY structure.
 * int dst_key_to_dnskey()      Function to return a public key in DNS 
 *                              format binary
 * DST_KEY *dst_buffer_to_key() Convert a data in buffer to KEY
 * int *dst_key_to_buffer()     Writes out DST_KEY key material in buffer
 * void dst_free_key()          Releases all memory referenced by key structure
 */

#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <memory.h>
#include <ctype.h>
#include <time.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>

#include "cdefs.h"
#include "osdep.h"
#include "arpa/nameser.h"

#include "dst_internal.h"

/* static variables */
static int done_init = 0;
dst_func *dst_t_func[DST_MAX_ALGS];
const char *key_file_fmt_str = "Private-key-format: v%s\nAlgorithm: %d (%s)\n";
const char *dst_path = "";

/* internal I/O functions */
static DST_KEY *dst_s_read_public_key(const char *in_name, 
                                      const unsigned in_id, int in_alg);
static int dst_s_read_private_key_file(char *name, DST_KEY *pk_key,
                                       unsigned in_id, int in_alg);
static int dst_s_write_public_key(const DST_KEY *key);
static int dst_s_write_private_key(const DST_KEY *key);

/* internal function to set up data structure */
static DST_KEY *dst_s_get_key_struct(const char *name, const int alg,
                                     const u_int32_t flags, const int protocol,
                                     const int bits);

/*
 *  dst_init
 *      This function initializes the Digital Signature Toolkit.
 *      Right now, it just checks the DSTKEYPATH environment variable.
 *  Parameters
 *      none
 *  Returns
 *      none
 */
void
dst_init()
{
        char *s;
        unsigned len;

        if (done_init != 0)
                return;
        done_init = 1;

        s = getenv("DSTKEYPATH");
        if (s) {
                struct stat statbuf;

                len = strlen(s);
                if (len > PATH_MAX) {
                        EREPORT(("%s is longer than %d characters, ignoring\n",
                                 s, PATH_MAX));
                } else if (stat(s, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode)) {
                        EREPORT(("%s is not a valid directory\n", s));
                } else {
                        char *dp = (char *) malloc(len + 2);
                        int l;
                        memcpy(dp, s, len + 1);
                        l = strlen (dp);
                        if (dp[l - 1] != '/') {
                                dp[l + 1] = 0;
                                dp[l] = '/';
                        }
                        dst_path = dp;
                }
        }
        memset(dst_t_func, 0, sizeof(dst_t_func));
        /* first one is selected */
#if 0
        dst_bsafe_init();
        dst_rsaref_init(); 
#endif
        dst_hmac_md5_init();
#if 0
        dst_eay_dss_init();
        dst_cylink_init();
#endif
}

/*
 *  dst_check_algorithm
 *      This function determines if the crypto system for the specified
 *      algorithm is present.
 *  Parameters
 *      alg     1       KEY_RSA
 *              3       KEY_DSA
 *            157     KEY_HMAC_MD5
 *                    future algorithms TBD and registered with IANA.
 *  Returns
 *      1 - The algorithm is available.
 *      0 - The algorithm is not available.
 */
int
dst_check_algorithm(const int alg)
{
        return (dst_t_func[alg] != NULL);
}

/* 
 * dst_s_get_key_struct 
 *      This function allocates key structure and fills in some of the 
 *      fields of the structure. 
 * Parameters: 
 *      name:     the name of the key 
 *      alg:      the algorithm number 
 *      flags:    the dns flags of the key
 *      protocol: the dns protocol of the key
 *      bits:     the size of the key
 * Returns:
 *       NULL if error
 *       valid pointer otherwise
 */
static DST_KEY *
dst_s_get_key_struct(const char *name, const int alg, const u_int32_t flags,
                     const int protocol, const int bits)
{
        DST_KEY *new_key = NULL; 

        if (dst_check_algorithm(alg)) /* make sure alg is available */
                new_key = (DST_KEY *) malloc(sizeof(*new_key));
        if (new_key == NULL)
                return (NULL);

        memset(new_key, 0, sizeof(*new_key));
        new_key->dk_key_name = strdup(name);
        new_key->dk_alg = alg;
        new_key->dk_flags = flags;
        new_key->dk_proto = protocol;
        new_key->dk_KEY_struct = NULL;
        new_key->dk_key_size = bits;
        new_key->dk_func = dst_t_func[alg];
        return (new_key);
}

/*
 *  dst_compare_keys
 *      Compares two keys for equality.
 *  Parameters
 *      key1, key2      Two keys to be compared.
 *  Returns
 *      0              The keys are equal.
 *      non-zero        The keys are not equal.
 */

int
dst_compare_keys(const DST_KEY *key1, const DST_KEY *key2)
{
        if (key1 == key2)
                return (0);
        if (key1 == NULL || key2 == NULL)
                return (4);
        if (key1->dk_alg != key2->dk_alg)
                return (1);
        if (key1->dk_key_size != key2->dk_key_size)
                return (2);
        if (key1->dk_id != key2->dk_id)
                return (3);
        return (key1->dk_func->compare(key1, key2));
}


/*
 * dst_sign_data
 *      An incremental signing function.  Data is signed in steps.
 *      First the context must be initialized (SIG_MODE_INIT).
 *      Then data is hashed (SIG_MODE_UPDATE).  Finally the signature
 *      itself is created (SIG_MODE_FINAL).  This function can be called
 *      once with INIT, UPDATE and FINAL modes all set, or it can be

 *      called separately with a different mode set for each step.  The
 *      UPDATE step can be repeated.
 * Parameters
 *      mode    A bit mask used to specify operation(s) to be performed.
 *                SIG_MODE_INIT    1   Initialize digest
 *                SIG_MODE_UPDATE        2   Add data to digest
 *                SIG_MODE_FINAL          4   Generate signature
 *                                            from signature
 *                SIG_MODE_ALL (SIG_MODE_INIT,SIG_MODE_UPDATE,SIG_MODE_FINAL
 *      data    Data to be signed.
 *      len     The length in bytes of data to be signed.
 *      in_key  Contains a private key to sign with.
 *                KEY structures should be handled (created, converted,
 *                compared, stored, freed) by the DST.
 *      signature
 *            The location to which the signature will be written.
 *      sig_len Length of the signature field in bytes.
 * Return
 *       0      Successful INIT or Update operation
 *      >0      success FINAL (sign) operation
 *      <0      failure
 */

int
dst_sign_data(const int mode, DST_KEY *in_key, void **context, 
              const u_char *data, const unsigned len,
              u_char *signature, const unsigned sig_len)
{
        DUMP(data, mode, len, "dst_sign_data()");

        if (mode & SIG_MODE_FINAL &&
            (in_key->dk_KEY_struct == NULL || signature == NULL))
                return (MISSING_KEY_OR_SIGNATURE);

        if (in_key->dk_func && in_key->dk_func->sign)
                return (in_key->dk_func->sign(mode, in_key, context, data, len,
                                              signature, sig_len));
        return (UNKNOWN_KEYALG);
}


/*
 *  dst_verify_data
 *      An incremental verify function.  Data is verified in steps.
 *      First the context must be initialized (SIG_MODE_INIT).
 *      Then data is hashed (SIG_MODE_UPDATE).  Finally the signature
 *      is verified (SIG_MODE_FINAL).  This function can be called
 *      once with INIT, UPDATE and FINAL modes all set, or it can be
 *      called separately with a different mode set for each step.  The
 *      UPDATE step can be repeated.
 *  Parameters
 *      mode    Operations to perform this time.
 *                    SIG_MODE_INIT       1   Initialize digest
 *                    SIG_MODE_UPDATE     2   add data to digest
 *                    SIG_MODE_FINAL      4   verify signature
 *                    SIG_MODE_ALL
 *                        (SIG_MODE_INIT,SIG_MODE_UPDATE,SIG_MODE_FINAL)
 *      data    Data to pass through the hash function.
 *      len      Length of the data in bytes.
 *      in_key      Key for verification.
 *      signature   Location of signature.
 *      sig_len     Length of the signature in bytes.
 *  Returns
 *      0          Verify success
 *      Non-Zero    Verify Failure
 */

int
dst_verify_data(const int mode, DST_KEY *in_key, void **context, 
                const u_char *data, const unsigned len,
                const u_char *signature, const unsigned sig_len)
{
        DUMP(data, mode, len, "dst_verify_data()");
        if (mode & SIG_MODE_FINAL &&
            (in_key->dk_KEY_struct == NULL || signature == NULL))
                return (MISSING_KEY_OR_SIGNATURE);

        if (in_key->dk_func == NULL || in_key->dk_func->verify == NULL)
                return (UNSUPPORTED_KEYALG);
        return (in_key->dk_func->verify(mode, in_key, context, data, len,
                                        signature, sig_len));
}


/*
 *  dst_read_private_key
 *      Access a private key.  First the list of private keys that have
 *      already been read in is searched, then the key accessed on disk.
 *      If the private key can be found, it is returned.  If the key cannot
 *      be found, a null pointer is returned.  The options specify required
 *      key characteristics.  If the private key requested does not have
 *      these characteristics, it will not be read.
 *  Parameters
 *      in_keyname  The private key name.
 *      in_id       The id of the private key.
 *      options     DST_FORCE_READ  Read from disk - don't use a previously
 *                                    read key.
 *                DST_CAN_SIGN    The key must be usable for signing.
 *                DST_NO_AUTHEN   The key must be usable for authentication.
 *                DST_STANDARD    Return any key 
 *  Returns
 *      NULL    If there is no key found in the current directory or
 *                    this key has not been loaded before.
 *      !NULL       Success - KEY structure returned.
 */

DST_KEY *
dst_read_key(const char *in_keyname, const unsigned in_id, 
             const int in_alg, const int type)
{
        char keyname[PATH_MAX];
        DST_KEY *dg_key = NULL, *pubkey = NULL;

        if (!dst_check_algorithm(in_alg)) { /* make sure alg is available */
                EREPORT(("dst_read_private_key(): Algorithm %d not supported\n",
                         in_alg));
                return (NULL);
        }
        if ((type & (DST_PUBLIC | DST_PRIVATE)) == 0) 
                return (NULL);
        if (in_keyname == NULL) {
                EREPORT(("dst_read_private_key(): Null key name passed in\n"));
                return (NULL);
        } else
                strncpy(keyname, in_keyname, PATH_MAX);

        /* before I read in the public key, check if it is allowed to sign */
        if ((pubkey = dst_s_read_public_key(keyname, in_id, in_alg)) == NULL)
                return (NULL);

        if (type == DST_PUBLIC) 
                return pubkey; 

        if (!(dg_key = dst_s_get_key_struct(keyname, pubkey->dk_alg,
                                            pubkey->dk_flags, pubkey->dk_proto,
                                            0)))
                return (dg_key);
        /* Fill in private key and some fields in the general key structure */
        if (dst_s_read_private_key_file(keyname, dg_key, pubkey->dk_id,
                                        pubkey->dk_alg) == 0)
                dg_key = dst_free_key(dg_key);

        (void) dst_free_key(pubkey);
        return (dg_key);
}

int 
dst_write_key(const DST_KEY *key, const int type)
{
        int pub = 0, priv = 0;

        if (key == NULL) 
                return (0);
        if (!dst_check_algorithm(key->dk_alg)) { /* make sure alg is available */
                EREPORT(("dst_write_key(): Algorithm %d not supported\n", 
                         key->dk_alg));
                return (UNSUPPORTED_KEYALG);
        }
        if ((type & (DST_PRIVATE|DST_PUBLIC)) == 0)
                return (0);

        if (type & DST_PUBLIC) 
                if ((pub = dst_s_write_public_key(key)) < 0)
                        return (pub);
        if (type & DST_PRIVATE)
                if ((priv = dst_s_write_private_key(key)) < 0)
                        return (priv);
        return (priv+pub);
}

/*
 *  dst_write_private_key
 *      Write a private key to disk.  The filename will be of the form:
 *      K<key->dk_name>+<key->dk_alg>+<key->dk_id>.<private key suffix>.
 *      If there is already a file with this name, an error is returned.
 *
 *  Parameters
 *      key     A DST managed key structure that contains
 *            all information needed about a key.
 *  Return
 *      >= 0    Correct behavior.  Returns length of encoded key value
 *                written to disk.
 *      <  0    error.
 */

static int
dst_s_write_private_key(const DST_KEY *key)
{
        u_char encoded_block[RAW_KEY_SIZE];
        char file[PATH_MAX];
        unsigned len;
        FILE *fp;

        /* First encode the key into the portable key format */
        if (key == NULL)
                return (-1);
        if (key->dk_KEY_struct == NULL)
                return (0);     /* null key has no private key */

        if (key->dk_func == NULL || key->dk_func->to_file_fmt == NULL) {
                EREPORT(("dst_write_private_key(): Unsupported operation %d\n",
                         key->dk_alg));
                return (-5);
        } else if ((len = key->dk_func->to_file_fmt(key, (char *)encoded_block,
                                             sizeof(encoded_block))) <= 0) {
                EREPORT(("dst_write_private_key(): Failed encoding private RSA bsafe key %d\n", len));
                return (-8);
        }
        /* Now I can create the file I want to use */
        dst_s_build_filename(file, key->dk_key_name, key->dk_id, key->dk_alg,
                             PRIVATE_KEY, PATH_MAX);

        /* Do not overwrite an existing file */
        if ((fp = dst_s_fopen(file, "w", 0600)) != NULL) {
                int nn;
                if ((nn = fwrite(encoded_block, 1, len, fp)) != len) {
                        EREPORT(("dst_write_private_key(): Write failure on %s %d != %d errno=%d\n",
                                 file, out_len, nn, errno));
                        fclose(fp);
                        return (-5);
                }
                fclose(fp);
        } else {
                EREPORT(("dst_write_private_key(): Can not create file %s\n"
                         ,file));
                return (-6);
        }
        memset(encoded_block, 0, len);
        return (len);
}

/*
*
 *  dst_read_public_key
 *      Read a public key from disk and store in a DST key structure.
 *  Parameters
 *      in_name  K<in_name><in_id>.<public key suffix> is the
 *                    filename of the key file to be read.
 *  Returns
 *      NULL        If the key does not exist or no name is supplied.
 *      NON-NULL        Initialized key structure if the key exists.
 */

static DST_KEY *
dst_s_read_public_key(const char *in_name, const unsigned in_id, int in_alg)
{
        unsigned flags, len;
        int proto, alg, dlen;
        int c;
        char name[PATH_MAX], enckey[RAW_KEY_SIZE];
        unsigned char *notspace;
        u_char deckey[RAW_KEY_SIZE];
        FILE *fp;

        if (in_name == NULL) {
                EREPORT(("dst_read_public_key(): No key name given\n"));
                return (NULL);
        }
        if (dst_s_build_filename(name, in_name, in_id, in_alg, PUBLIC_KEY,
                                 PATH_MAX) == -1) {
                EREPORT(("dst_read_public_key(): Cannot make filename from %s, %d, and %s\n",
                         in_name, in_id, PUBLIC_KEY));
                return (NULL);
        }
        /*
         * Open the file and read it's formatted contents up to key
         * File format:
         *    domain.name [ttl] [IN] KEY  <flags> <protocol> <algorithm> <key>
         * flags, proto, alg stored as decimal (or hex numbers FIXME).
         * (FIXME: handle parentheses for line continuation.)
         */
        if ((fp = dst_s_fopen(name, "r", 0)) == NULL) {
                EREPORT(("dst_read_public_key(): Public Key not found %s\n",
                         name));
                return (NULL);
        }
        /* Skip domain name, which ends at first blank */
        while ((c = getc(fp)) != EOF)
                if (isspace(c))
                        break;
        /* Skip blank to get to next field */
        while ((c = getc(fp)) != EOF)
                if (!isspace(c))
                        break;

        /* Skip optional TTL -- if initial digit, skip whole word. */
        if (isdigit(c)) {
                while ((c = getc(fp)) != EOF)
                        if (isspace(c))
                                break;
                while ((c = getc(fp)) != EOF)
                        if (!isspace(c))
                                break;
        }
        /* Skip optional "IN" */
        if (c == 'I' || c == 'i') {
                while ((c = getc(fp)) != EOF)
                        if (isspace(c))
                                break;
                while ((c = getc(fp)) != EOF)
                        if (!isspace(c))
                                break;
        }
        /* Locate and skip "KEY" */
        if (c != 'K' && c != 'k') {
                EREPORT(("\"KEY\" doesn't appear in file: %s", name));
                return NULL;
        }
        while ((c = getc(fp)) != EOF)
                if (isspace(c))
                        break;
        while ((c = getc(fp)) != EOF)
                if (!isspace(c))
                        break;
        ungetc(c, fp);          /* return the character to the input field */
        /* Handle hex!! FIXME.  */

        if (fscanf(fp, "%d %d %d", &flags, &proto, &alg) != 3) {
                EREPORT(("dst_read_public_key(): Can not read flag/proto/alg field from %s\n"
                         ,name));
                return (NULL);
        }
        /* read in the key string */
        if ((fgets(enckey, sizeof(enckey), fp) == NULL) &&
            (ferror(fp) != 0)) {
                EREPORT(("dst_read_public_kety(): Error reading key\n"));
                return (NULL);
        }

        /* If we aren't at end-of-file, something is wrong.  */
        while ((c = getc(fp)) != EOF)
                if (!isspace(c))
                        break;
        if (!feof(fp)) {
                EREPORT(("Key too long in file: %s", name));
                return NULL;
        }
        fclose(fp);

        if ((len = strlen(enckey)) <= 0)
                return (NULL);

        /* discard \n */
        enckey[--len] = '\0';

        /* remove leading spaces */
        for (notspace = (unsigned char *)enckey; isspace(*notspace); len--)
                notspace++;

        dlen = b64_pton((char *)notspace, deckey, sizeof(deckey));
        if (dlen < 0) {
                EREPORT(("dst_read_public_key: bad return from b64_pton = %d",
                         dlen));
                return (NULL);
        }
        /* store key and info in a key structure that is returned */
/*      return dst_store_public_key(in_name, alg, proto, 666, flags, deckey,
                                    dlen);*/
        return dst_buffer_to_key(in_name, alg,
                                 flags, proto, deckey, (unsigned)dlen);
}


/*
 *  dst_write_public_key
 *      Write a key to disk in DNS format.
 *  Parameters
 *      key     Pointer to a DST key structure.
 *  Returns
 *      0       Failure
 *      1       Success
 */

static int
dst_s_write_public_key(const DST_KEY *key)
{
        FILE *fp;
        char filename[PATH_MAX];
        u_char out_key[RAW_KEY_SIZE];
        char enc_key[RAW_KEY_SIZE];
        int len = 0;

        memset(out_key, 0, sizeof(out_key));
        if (key == NULL) {
                EREPORT(("dst_write_public_key(): No key specified \n"));
                return (0);
        } else if ((len = dst_key_to_dnskey(key, out_key, sizeof(out_key)))< 0)
                return (0);

        /* Make the filename */
        if (dst_s_build_filename(filename, key->dk_key_name, key->dk_id,
                                 key->dk_alg, PUBLIC_KEY, PATH_MAX) == -1) {
                EREPORT(("dst_write_public_key(): Cannot make filename from %s, %d, and %s\n",
                         key->dk_key_name, key->dk_id, PUBLIC_KEY));
                return (0);
        }
        /* create public key file */
        if ((fp = dst_s_fopen(filename, "w+", 0644)) == NULL) {
                EREPORT(("DST_write_public_key: open of file:%s failed (errno=%d)\n",
                         filename, errno));
                return (0);
        }
        /*write out key first base64 the key data */
        if (key->dk_flags & DST_EXTEND_FLAG)
                b64_ntop(&out_key[6],
                         (unsigned)(len - 6), enc_key, sizeof(enc_key));
        else
                b64_ntop(&out_key[4],
                         (unsigned)(len - 4), enc_key, sizeof(enc_key));
        fprintf(fp, "%s IN KEY %d %d %d %s\n",
                key->dk_key_name,
                key->dk_flags, key->dk_proto, key->dk_alg, enc_key);
        fclose(fp);
        return (1);
}


/*
 *  dst_dnskey_to_public_key
 *      This function converts the contents of a DNS KEY RR into a DST
 *      key structure.
 *  Parameters
 *      len      Length of the RDATA of the KEY RR RDATA
 *      rdata    A pointer to the the KEY RR RDATA.
 *      in_name     Key name to be stored in key structure.
 *  Returns
 *      NULL        Failure
 *      NON-NULL        Success.  Pointer to key structure.
 *                      Caller's responsibility to free() it.
 */

DST_KEY *
dst_dnskey_to_key(const char *in_name,
                  const u_char *rdata, const unsigned len)
{
        DST_KEY *key_st;
        int alg ;
        int start = DST_KEY_START;

        if (in_name == NULL || rdata == NULL || len <= DST_KEY_ALG) /* no data */
                return (NULL);
        alg = (u_int8_t) rdata[DST_KEY_ALG];
        if (!dst_check_algorithm(alg)) { /* make sure alg is available */
                EREPORT(("dst_dnskey_to_key(): Algorithm %d not supported\n",
                         alg));
                return (NULL);
        }
        if ((key_st = dst_s_get_key_struct(in_name, alg, 0, 0, 0)) == NULL)
                return (NULL);

        key_st->dk_flags = dst_s_get_int16(rdata);
        key_st->dk_proto = (u_int16_t) rdata[DST_KEY_PROT];
        if (key_st->dk_flags & DST_EXTEND_FLAG) {
                u_int32_t ext_flags;
                ext_flags = (u_int32_t) dst_s_get_int16(&rdata[DST_EXT_FLAG]);
                key_st->dk_flags = key_st->dk_flags | (ext_flags << 16);
                start += 2;
        }
        /*
         * now point to the beginning of the data representing the encoding
         * of the key
         */
        if (key_st->dk_func && key_st->dk_func->from_dns_key) {
                if (key_st->dk_func->from_dns_key(key_st, &rdata[start],
                                                  len - start) > 0)
                        return (key_st);
        } else
                EREPORT(("dst_dnskey_to_public_key(): unsupported alg %d\n",
                         alg));

        SAFE_FREE(key_st);
        return (key_st);
}


/*
 *  dst_public_key_to_dnskey
 *      Function to encode a public key into DNS KEY wire format 
 *  Parameters
 *      key          Key structure to encode.
 *      out_storage     Location to write the encoded key to.
 *      out_len  Size of the output array.
 *  Returns
 *      <0      Failure
 *      >=0     Number of bytes written to out_storage
 */

int
dst_key_to_dnskey(const DST_KEY *key, u_char *out_storage,
                         const unsigned out_len)
{
        u_int16_t val;
        int loc = 0;
        int enc_len = 0;
        if (key == NULL)
                return (-1);

        if (!dst_check_algorithm(key->dk_alg)) { /* make sure alg is available */
                EREPORT(("dst_key_to_dnskey(): Algorithm %d not supported\n",
                         key->dk_alg));
                return (UNSUPPORTED_KEYALG);
        }
        memset(out_storage, 0, out_len);
        val = (u_int16_t)(key->dk_flags & 0xffff);
        out_storage[0] = (val >> 8) & 0xff;
        out_storage[1] = val        & 0xff;
        loc += 2;

        out_storage[loc++] = (u_char) key->dk_proto;
        out_storage[loc++] = (u_char) key->dk_alg;

        if (key->dk_flags > 0xffff) {   /* Extended flags */
                val = (u_int16_t)((key->dk_flags >> 16) & 0xffff);
                out_storage[loc]   = (val >> 8) & 0xff;
                out_storage[loc+1] = val        & 0xff;
                loc += 2;
        }
        if (key->dk_KEY_struct == NULL)
                return (loc);
        if (key->dk_func && key->dk_func->to_dns_key) {
                enc_len = key->dk_func->to_dns_key(key,
                                                 (u_char *) &out_storage[loc],
                                                   out_len - loc);
                if (enc_len > 0)
                        return (enc_len + loc);
                else
                        return (-1);
        } else
                EREPORT(("dst_key_to_dnskey(): Unsupported ALG %d\n",
                         key->dk_alg));
        return (-1);
}


/*
 *  dst_buffer_to_key
 *      Function to encode a string of raw data into a DST key
 *  Parameters
 *      alg             The algorithm (HMAC only)
 *      key             A pointer to the data
 *      keylen          The length of the data
 *  Returns
 *      NULL        an error occurred
 *      NON-NULL        the DST key
 */
DST_KEY *
dst_buffer_to_key(const char *key_name,         /* name of the key */
                  const int alg,                /* algorithm */
                  const unsigned flags,         /* dns flags */
                  const int protocol,           /* dns protocol */
                  const u_char *key_buf,        /* key in dns wire fmt */
                  const unsigned key_len)               /* size of key */
{
        
        DST_KEY *dkey = NULL; 

        if (!dst_check_algorithm(alg)) { /* make sure alg is available */
                EREPORT(("dst_buffer_to_key(): Algorithm %d not supported\n", alg));
                return (NULL);
        }

        dkey = dst_s_get_key_struct(key_name, alg, flags,  protocol, -1);

        if (dkey == NULL)
                return (NULL);
        if (dkey->dk_func != NULL &&
            dkey->dk_func->from_dns_key != NULL) {
                if (dkey->dk_func->from_dns_key(dkey, key_buf, key_len) < 0) {
                        EREPORT(("dst_buffer_to_key(): dst_buffer_to_hmac failed\n"));
                        (void) (dst_free_key(dkey));
                        return (NULL);
                }
                return (dkey);
        }
        (void) (dst_free_key(dkey));
        return (NULL);
}

int 
dst_key_to_buffer(DST_KEY *key, u_char *out_buff, unsigned buf_len)
{
        int len;
  /* this function will extract the secret of HMAC into a buffer */
        if(key == NULL) 
                return (0);
        if(key->dk_func != NULL && key->dk_func != NULL) {
                len = key->dk_func->to_dns_key(key, out_buff, buf_len);
                if (len < 0)
                        return (0);
                return (len);
        }
        return (0);
}


/*
 * dst_s_read_private_key_file
 *     Function reads in private key from a file.
 *     Fills out the KEY structure.
 * Parameters
 *     name    Name of the key to be read.
 *     pk_key  Structure that the key is returned in.
 *     in_id   Key identifier (tag)
 * Return
 *     1 if everything works
 *     0 if there is any problem
 */

static int
dst_s_read_private_key_file(char *name, DST_KEY *pk_key, unsigned in_id,
                            int in_alg)
{
        int cnt, alg, len, major, minor, file_major, file_minor;
        int id;
        char filename[PATH_MAX];
        u_char in_buff[RAW_KEY_SIZE];
        char *p;
        FILE *fp;

        if (name == NULL || pk_key == NULL) {
                EREPORT(("dst_read_private_key_file(): No key name given\n"));
                return (0);
        }
        /* Make the filename */
        if (dst_s_build_filename(filename, name, in_id, in_alg, PRIVATE_KEY,
                                 PATH_MAX) == -1) {
                EREPORT(("dst_read_private_key(): Cannot make filename from %s, %d, and %s\n",
                         name, in_id, PRIVATE_KEY));
                return (0);
        }
        /* first check if we can find the key file */
        if ((fp = dst_s_fopen(filename, "r", 0)) == NULL) {
                EREPORT(("dst_s_read_private_key_file: Could not open file %s in directory %s\n",
                         filename, dst_path[0] ? dst_path :
                         (char *) getcwd(NULL, PATH_MAX - 1)));
                return (0);
        }
        /* now read the header info from the file */
        if ((cnt = fread(in_buff, 1, sizeof(in_buff), fp)) < 5) {
                fclose(fp);
                EREPORT(("dst_s_read_private_key_file: error reading file %s (empty file)\n",
                         filename));
                return (0);
        }
        /* decrypt key */
        fclose(fp);
        if (memcmp(in_buff, "Private-key-format: v", 20) != 0)
                goto fail;
        len = cnt;
        p = (char *)in_buff;

        if (!dst_s_verify_str((const char **) &p, "Private-key-format: v")) {
                EREPORT(("dst_s_read_private_key_file(): Not a Key file/Decrypt failed %s\n", name));
                goto fail;
        }
        /* read in file format */
        sscanf(p, "%d.%d", &file_major, &file_minor);
        sscanf(KEY_FILE_FORMAT, "%d.%d", &major, &minor);
        if (file_major < 1) {
                EREPORT(("dst_s_read_private_key_file(): Unknown keyfile %d.%d version for %s\n",
                         file_major, file_minor, name));
                goto fail;
        } else if (file_major > major || file_minor > minor)
                EREPORT((
                                "dst_s_read_private_key_file(): Keyfile %s version higher than mine %d.%d MAY FAIL\n",
                                name, file_major, file_minor));

        while (*p++ != '\n') ;  /* skip to end of line */

        if (!dst_s_verify_str((const char **) &p, "Algorithm: "))
                goto fail;

        if (sscanf(p, "%d", &alg) != 1)
                goto fail;
        while (*p++ != '\n') ;  /* skip to end of line */

        if (pk_key->dk_key_name && !strcmp(pk_key->dk_key_name, name))
                SAFE_FREE2(pk_key->dk_key_name, strlen(pk_key->dk_key_name));
        pk_key->dk_key_name = (char *) strdup(name);

        /* allocate and fill in key structure */
        if (pk_key->dk_func == NULL || pk_key->dk_func->from_file_fmt == NULL)
                goto fail;

        id = pk_key->dk_func->from_file_fmt(pk_key, (char *)p,
                                            (unsigned)(&in_buff[len] - (u_char *)p));
        if (id < 0)
                goto fail;

        /* Make sure the actual key tag matches the input tag used in the filename
         */
        if (id != in_id) {
                EREPORT(("dst_s_read_private_key_file(): actual tag of key read %d != input tag used to build filename %d.\n", id, in_id));
                goto fail;
        }
        pk_key->dk_id = (u_int16_t) id;
        pk_key->dk_alg = alg;
        memset(in_buff, 0, (unsigned)cnt);
        return (1);

 fail:
        memset(in_buff, 0, (unsigned)cnt);
        return (0);
}


/*
 *  dst_generate_key
 *      Generate and store a public/private keypair.
 *      Keys will be stored in formatted files.
 *  Parameters
 *      name    Name of the new key.  Used to create key files
 *                K<name>+<alg>+<id>.public and K<name>+<alg>+<id>.private.
 *      bits    Size of the new key in bits.
 *      exp     What exponent to use:
 *                0        use exponent 3
 *                non-zero    use Fermant4
 *      flags   The default value of the DNS Key flags.
 *                The DNS Key RR Flag field is defined in RFC 2065,
 *                section 3.3.  The field has 16 bits.
 *      protocol
 *            Default value of the DNS Key protocol field.
 *                The DNS Key protocol field is defined in RFC 2065,
 *                section 3.4.  The field has 8 bits.
 *      alg     What algorithm to use.  Currently defined:
 *                KEY_RSA       1
 *                KEY_DSA       3
 *                KEY_HMAC    157
 *      out_id The key tag is returned.
 *
 *  Return
 *      NULL            Failure
 *      non-NULL        the generated key pair
 *                      Caller frees the result, and its dk_name pointer.
 */
DST_KEY *
dst_generate_key(const char *name, const int bits, const int exp,
                 const unsigned flags, const int protocol, const int alg)
{
        DST_KEY *new_key = NULL;
        int res;
        if (name == NULL)
                return (NULL);

        if (!dst_check_algorithm(alg)) { /* make sure alg is available */
                EREPORT(("dst_generate_key(): Algorithm %d not supported\n", alg));
                return (NULL);
        }

        new_key = dst_s_get_key_struct(name, alg, flags, protocol, bits);
        if (new_key == NULL)
                return (NULL);
        if (bits == 0) /* null key we are done */
                return (new_key);
        if (new_key->dk_func == NULL || new_key->dk_func->generate == NULL) {
                EREPORT(("dst_generate_key_pair():Unsupported algorithm %d\n",
                         alg));
                return (dst_free_key(new_key));
        }
        if ((res = new_key->dk_func->generate(new_key, exp)) <= 0) {
                EREPORT(("dst_generate_key_pair(): Key generation failure %s %d %d %d\n",
                         new_key->dk_key_name, new_key->dk_alg,
                         new_key->dk_key_size, exp));
                return (dst_free_key(new_key));
        }
        return (new_key);
}


/*
 *  dst_free_key
 *      Release all data structures pointed to by a key structure.
 *  Parameters
 *      f_key   Key structure to be freed.
 */

DST_KEY *
dst_free_key(DST_KEY *f_key)
{

        if (f_key == NULL)
                return (f_key);
        if (f_key->dk_func && f_key->dk_func->destroy)
                f_key->dk_KEY_struct =
                        f_key->dk_func->destroy(f_key->dk_KEY_struct);
        else {
                EREPORT(("dst_free_key(): Unknown key alg %d\n",
                         f_key->dk_alg));
        }
        if (f_key->dk_KEY_struct) {
                SAFE_FREE2(f_key->dk_KEY_struct,0);
        }
        if (f_key->dk_key_name)
                SAFE_FREE(f_key->dk_key_name);
        SAFE_FREE(f_key);
        return (NULL);
}

/*
 * dst_sig_size
 *      Return the maximum size of signature from the key specified in bytes
 * Parameters
 *      key 
 * Returns
 *     bytes
 */
int
dst_sig_size(DST_KEY *key) {
        switch (key->dk_alg) {
            case KEY_HMAC_MD5:
                return (16);
            case KEY_HMAC_SHA1:
                return (20);
            case KEY_RSA:
                return (key->dk_key_size + 7) / 8;
            case KEY_DSA:
                return (40);
            default:
                EREPORT(("dst_sig_size(): Unknown key alg %d\n", key->dk_alg));
                return -1;
        }
}

/* 
 * dst_random 
 *  function that multiplexes number of random number generators
 * Parameters  
 *   mode: select the random number generator
 *   wanted is how many bytes of random data are requested 
 *   outran is a buffer of size at least wanted for the output data
 *
 * Returns
 *    number of bytes written to outran
 */
int 
dst_random(const int mode, unsigned wanted, u_char *outran)
{
        u_int32_t *buff = NULL, *bp = NULL;
        int i;
        if (wanted <= 0 || outran == NULL) 
                return (0);

        switch (mode) {
        case DST_RAND_SEMI: 
                bp = buff = (u_int32_t *) malloc(wanted+sizeof(u_int32_t));
                for (i = 0; i < wanted; i+= sizeof(u_int32_t), bp++) {
                        *bp = dst_s_quick_random(i);
                }
                memcpy(outran, buff, (unsigned)wanted);
                SAFE_FREE(buff);
                return (wanted);
        case DST_RAND_STD:
                return (dst_s_semi_random(outran, wanted));
        case DST_RAND_KEY:
                return (dst_s_random(outran, wanted));
        case DST_RAND_DSS:
        default:
                /* need error case here XXX OG */
                return (0);
        }
}