Import of SSLeay-0.9.0b with RSA and IDEA stubbed + OpenBSD build

functionality for shared libs.

Note that routines such as sslv2_init and friends that use RSA will
not work due to lack of RSA in this library.

Needs documentation and help from ports for easy upgrade to full
functionality where legally possible.

1 files changed, 1152 insertions, 0 deletions

diff --git a/src/lib/libcrypto/x509/x509.h b/src/lib/libcrypto/x509/x509.h
new file mode 100644
index 0000000000..95114f7c43
--- /dev/null
+++ b/src/lib/libcrypto/x509/x509.h
@@ -0,0 +1,1152 @@
+/* crypto/x509/x509.h */
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ * 
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ * 
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from 
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * 
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+
+#ifndef HEADER_X509_H
+#define HEADER_X509_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#include "stack.h"
+#include "asn1.h"
+
+#ifndef NO_RSA
+#include "rsa.h"
+#else
+#define RSA     long
+#endif
+
+#ifndef NO_DSA
+#include "dsa.h"
+#else
+#define DSA     long
+#endif
+
+#ifndef NO_DH
+#include "dh.h"
+#else
+#define DH      long
+#endif
+
+#include "evp.h"
+
+#define X509_FILETYPE_PEM       1
+#define X509_FILETYPE_ASN1      2
+#define X509_FILETYPE_DEFAULT   3
+
+#define X509v3_KU_DIGITAL_SIGNATURE     0x0080
+#define X509v3_KU_NON_REPUDIATION       0x0040
+#define X509v3_KU_KEY_ENCIPHERMENT      0x0020
+#define X509v3_KU_DATA_ENCIPHERMENT     0x0010
+#define X509v3_KU_KEY_AGREEMENT         0x0008
+#define X509v3_KU_KEY_CERT_SIGN         0x0004
+#define X509v3_KU_CRL_SIGN              0x0002
+#define X509v3_KU_ENCIPHER_ONLY         0x0001
+#define X509v3_KU_DECIPHER_ONLY         0x8000
+#define X509v3_KU_UNDEF                 0xffff
+
+typedef struct X509_objects_st
+        {
+        int nid;
+        int (*a2i)();
+        int (*i2a)();
+        } X509_OBJECTS;
+
+typedef struct X509_algor_st
+        {
+        ASN1_OBJECT *algorithm;
+        ASN1_TYPE *parameter;
+        } X509_ALGOR;
+
+typedef struct X509_val_st
+        {
+        ASN1_UTCTIME *notBefore;
+        ASN1_UTCTIME *notAfter;
+        } X509_VAL;
+
+typedef struct X509_pubkey_st
+        {
+        X509_ALGOR *algor;
+        ASN1_BIT_STRING *public_key;
+        struct evp_pkey_st /* EVP_PKEY*/ *pkey;
+        } X509_PUBKEY;
+
+typedef struct X509_sig_st
+        {
+        X509_ALGOR *algor;
+        ASN1_OCTET_STRING *digest;
+        } X509_SIG;
+
+typedef struct X509_name_entry_st
+        {
+        ASN1_OBJECT *object;
+        ASN1_STRING *value;
+        int set;
+        int size;       /* temp variable */
+        } X509_NAME_ENTRY;
+
+/* we always keep X509_NAMEs in 2 forms. */
+typedef struct X509_name_st
+        {
+        STACK *entries; /* of X509_NAME_ENTRY */
+        int modified;   /* true if 'bytes' needs to be built */
+#ifdef HEADER_BUFFER_H
+        BUF_MEM *bytes;
+#else
+        char *bytes;
+#endif
+        unsigned long hash; /* Keep the hash around for lookups */
+        } X509_NAME;
+
+#define X509_EX_V_NETSCAPE_HACK         0x8000
+#define X509_EX_V_INIT                  0x0001
+typedef struct X509_extension_st
+        {
+        ASN1_OBJECT *object;
+        short critical;
+        short netscape_hack;
+        ASN1_OCTET_STRING *value;
+        long argl;                      /* used when decoding */
+        char *argp;                     /* used when decoding */
+        void (*ex_free)();              /* clear argp stuff */
+        } X509_EXTENSION;
+
+/* #if 1 */
+typedef struct x509_extension_method_st
+        {
+        int nid;
+        int data_type;
+        int pack_type;
+        void (*ex_clear)();
+        int (*ex_get_bool)();
+        int (*ex_set_bool)();
+        int (*ex_get_str)();
+        int (*ex_set_str)();
+        char *(*ex_get_struct)();
+        int (*ex_set_struct)();
+        int (*a2i)();
+        int (*i2a)();
+        } X509_EXTENSION_METHOD;
+/* #endif */
+
+typedef struct X509_req_info_st
+        {
+        ASN1_INTEGER *version;
+        X509_NAME *subject;
+        X509_PUBKEY *pubkey;
+        /*  d=2 hl=2 l=  0 cons: cont: 00 */
+        STACK /* X509_ATTRIBUTE */ *attributes; /* [ 0 ] */
+        int req_kludge;
+        } X509_REQ_INFO;
+
+typedef struct X509_req_st
+        {
+        X509_REQ_INFO *req_info;
+        X509_ALGOR *sig_alg;
+        ASN1_BIT_STRING *signature;
+        int references;
+        } X509_REQ;
+
+typedef struct x509_cinf_st
+        {
+        ASN1_INTEGER *version;          /* [ 0 ] default of v1 */
+        ASN1_INTEGER *serialNumber;
+        X509_ALGOR *signature;
+        X509_NAME *issuer;
+        X509_VAL *validity;
+        X509_NAME *subject;
+        X509_PUBKEY *key;
+        ASN1_BIT_STRING *issuerUID;             /* [ 1 ] optional in v2 */
+        ASN1_BIT_STRING *subjectUID;            /* [ 2 ] optional in v2 */
+        STACK /* X509_EXTENSION */ *extensions; /* [ 3 ] optional in v3 */
+        } X509_CINF;
+
+typedef struct x509_st
+        {
+        X509_CINF *cert_info;
+        X509_ALGOR *sig_alg;
+        ASN1_BIT_STRING *signature;
+        int valid;
+        int references;
+        char *name;
+        } X509;
+
+typedef struct X509_revoked_st
+        {
+        ASN1_INTEGER *serialNumber;
+        ASN1_UTCTIME *revocationDate;
+        STACK /* optional X509_EXTENSION */ *extensions;
+        int sequence; /* load sequence */
+        } X509_REVOKED;
+
+typedef struct X509_crl_info_st
+        {
+        ASN1_INTEGER *version;
+        X509_ALGOR *sig_alg;
+        X509_NAME *issuer;
+        ASN1_UTCTIME *lastUpdate;
+        ASN1_UTCTIME *nextUpdate;
+        STACK /* X509_REVOKED */ *revoked;
+        STACK /* [0] X509_EXTENSION */ *extensions;
+        } X509_CRL_INFO;
+
+typedef struct X509_crl_st
+        {
+        /* actual signature */
+        X509_CRL_INFO *crl;
+        X509_ALGOR *sig_alg;
+        ASN1_BIT_STRING *signature;
+        int references;
+        } X509_CRL;
+
+/* a sequence of these are used */
+typedef struct x509_attributes_st
+        {
+        ASN1_OBJECT *object;
+        int set; /* 1 for a set, 0 for a single item (which is wrong) */
+        union   {
+                char            *ptr;
+/* 1 */         STACK /* ASN1_TYPE */ *set;
+/* 0 */         ASN1_TYPE       *single;
+                } value;
+        } X509_ATTRIBUTE;
+
+typedef struct private_key_st
+        {
+        int version;
+        /* The PKCS#8 data types */
+        X509_ALGOR *enc_algor;
+        ASN1_OCTET_STRING *enc_pkey;    /* encrypted pub key */
+
+        /* When decrypted, the following will not be NULL */
+        EVP_PKEY *dec_pkey;
+
+        /* used to encrypt and decrypt */
+        int key_length;
+        char *key_data;
+        int key_free;   /* true if we should auto free key_data */
+
+        /* expanded version of 'enc_algor' */
+        EVP_CIPHER_INFO cipher;
+
+        int references;
+        } X509_PKEY;
+
+#ifdef HEADER_ENVELOPE_H
+typedef struct X509_info_st
+        {
+        X509 *x509;
+        X509_CRL *crl;
+        X509_PKEY *x_pkey;
+
+        EVP_CIPHER_INFO enc_cipher;
+        int enc_len;
+        char *enc_data;
+
+        int references;
+        } X509_INFO;
+#endif
+
+/* The next 2 structures and their 8 routines were sent to me by
+ * Pat Richard <patr@x509.com> and are used to manipulate
+ * Netscapes spki strucutres - usefull if you are writing a CA web page
+ */
+typedef struct Netscape_spkac_st
+        {
+        X509_PUBKEY *pubkey;
+        ASN1_IA5STRING *challenge;      /* challenge sent in atlas >= PR2 */
+        } NETSCAPE_SPKAC;
+
+typedef struct Netscape_spki_st
+        {
+        NETSCAPE_SPKAC *spkac;  /* signed public key and challenge */
+        X509_ALGOR *sig_algor;
+        ASN1_BIT_STRING *signature;
+        } NETSCAPE_SPKI;
+
+#ifndef HEADER_BN_H
+#define BIGNUM          char
+#endif
+
+typedef struct CBCParameter_st
+        {
+        unsigned char iv[8];
+        } CBC_PARAM;
+
+#include "x509_vfy.h"
+#include "pkcs7.h"
+
+#ifdef SSLEAY_MACROS
+#define X509_verify(a,r) ASN1_verify((int (*)())i2d_X509_CINF,a->sig_alg,\
+        a->signature,(char *)a->cert_info,r)
+#define X509_REQ_verify(a,r) ASN1_verify((int (*)())i2d_X509_REQ_INFO, \
+        a->sig_alg,a->signature,(char *)a->req_info,r)
+#define X509_CRL_verify(a,r) ASN1_verify((int (*)())i2d_X509_CRL_INFO, \
+        a->sig_alg, a->signature,(char *)a->crl,r)
+
+#define X509_sign(x,pkey,md) \
+        ASN1_sign((int (*)())i2d_X509_CINF, x->cert_info->signature, \
+                x->sig_alg, x->signature, (char *)x->cert_info,pkey,md)
+#define X509_REQ_sign(x,pkey,md) \
+        ASN1_sign((int (*)())i2d_X509_REQ_INFO,x->sig_alg, NULL, \
+                x->signature, (char *)x->req_info,pkey,md)
+#define X509_CRL_sign(x,pkey,md) \
+        ASN1_sign((int (*)())i2d_X509_CRL_INFO,x->crl->sig_alg,x->sig_alg, \
+                x->signature, (char *)x->crl,pkey,md)
+#define NETSCAPE_SPKI_sign(x,pkey,md) \
+        ASN1_sign((int (*)())i2d_NETSCAPE_SPKAC, x->sig_algor,NULL, \
+                x->signature, (char *)x->spkac,pkey,md)
+
+#define X509_dup(x509) (X509 *)ASN1_dup((int (*)())i2d_X509, \
+                (char *(*)())d2i_X509,(char *)x509)
+#define X509_EXTENSION_dup(ex) (X509_EXTENSION *)ASN1_dup( \
+                (int (*)())i2d_X509_EXTENSION, \
+                (char *(*)())d2i_X509_EXTENSION,(char *)ex)
+#define d2i_X509_fp(fp,x509) (X509 *)ASN1_d2i_fp((char *(*)())X509_new, \
+                (char *(*)())d2i_X509, (fp),(unsigned char **)(x509))
+#define i2d_X509_fp(fp,x509) ASN1_i2d_fp(i2d_X509,fp,(unsigned char *)x509)
+#define d2i_X509_bio(bp,x509) (X509 *)ASN1_d2i_bio((char *(*)())X509_new, \
+                (char *(*)())d2i_X509, (bp),(unsigned char **)(x509))
+#define i2d_X509_bio(bp,x509) ASN1_i2d_bio(i2d_X509,bp,(unsigned char *)x509)
+
+#define X509_CRL_dup(crl) (X509_CRL *)ASN1_dup((int (*)())i2d_X509_CRL, \
+                (char *(*)())d2i_X509_CRL,(char *)crl)
+#define d2i_X509_CRL_fp(fp,crl) (X509_CRL *)ASN1_d2i_fp((char *(*)()) \
+                X509_CRL_new,(char *(*)())d2i_X509_CRL, (fp),\
+                (unsigned char **)(crl))
+#define i2d_X509_CRL_fp(fp,crl) ASN1_i2d_fp(i2d_X509_CRL,fp,\
+                (unsigned char *)crl)
+#define d2i_X509_CRL_bio(bp,crl) (X509_CRL *)ASN1_d2i_bio((char *(*)()) \
+                X509_CRL_new,(char *(*)())d2i_X509_CRL, (bp),\
+                (unsigned char **)(crl))
+#define i2d_X509_CRL_bio(bp,crl) ASN1_i2d_bio(i2d_X509_CRL,bp,\
+                (unsigned char *)crl)
+
+#define PKCS7_dup(p7) (PKCS7 *)ASN1_dup((int (*)())i2d_PKCS7, \
+                (char *(*)())d2i_PKCS7,(char *)p7)
+#define d2i_PKCS7_fp(fp,p7) (PKCS7 *)ASN1_d2i_fp((char *(*)()) \
+                PKCS7_new,(char *(*)())d2i_PKCS7, (fp),\
+                (unsigned char **)(p7))
+#define i2d_PKCS7_fp(fp,p7) ASN1_i2d_fp(i2d_PKCS7,fp,\
+                (unsigned char *)p7)
+#define d2i_PKCS7_bio(bp,p7) (PKCS7 *)ASN1_d2i_bio((char *(*)()) \
+                PKCS7_new,(char *(*)())d2i_PKCS7, (bp),\
+                (unsigned char **)(p7))
+#define i2d_PKCS7_bio(bp,p7) ASN1_i2d_bio(i2d_PKCS7,bp,\
+                (unsigned char *)p7)
+
+#define X509_REQ_dup(req) (X509_REQ *)ASN1_dup((int (*)())i2d_X509_REQ, \
+                (char *(*)())d2i_X509_REQ,(char *)req)
+#define d2i_X509_REQ_fp(fp,req) (X509_REQ *)ASN1_d2i_fp((char *(*)())\
+                X509_REQ_new, (char *(*)())d2i_X509_REQ, (fp),\
+                (unsigned char **)(req))
+#define i2d_X509_REQ_fp(fp,req) ASN1_i2d_fp(i2d_X509_REQ,fp,\
+                (unsigned char *)req)
+#define d2i_X509_REQ_bio(bp,req) (X509_REQ *)ASN1_d2i_bio((char *(*)())\
+                X509_REQ_new, (char *(*)())d2i_X509_REQ, (bp),\
+                (unsigned char **)(req))
+#define i2d_X509_REQ_bio(bp,req) ASN1_i2d_bio(i2d_X509_REQ,bp,\
+                (unsigned char *)req)
+
+#define RSAPublicKey_dup(rsa) (RSA *)ASN1_dup((int (*)())i2d_RSAPublicKey, \
+                (char *(*)())d2i_RSAPublicKey,(char *)rsa)
+#define RSAPrivateKey_dup(rsa) (RSA *)ASN1_dup((int (*)())i2d_RSAPrivateKey, \
+                (char *(*)())d2i_RSAPrivateKey,(char *)rsa)
+
+#define d2i_RSAPrivateKey_fp(fp,rsa) (RSA *)ASN1_d2i_fp((char *(*)())\
+                RSA_new,(char *(*)())d2i_RSAPrivateKey, (fp), \
+                (unsigned char **)(rsa))
+#define i2d_RSAPrivateKey_fp(fp,rsa) ASN1_i2d_fp(i2d_RSAPrivateKey,fp, \
+                (unsigned char *)rsa)
+#define d2i_RSAPrivateKey_bio(bp,rsa) (RSA *)ASN1_d2i_bio((char *(*)())\
+                RSA_new,(char *(*)())d2i_RSAPrivateKey, (bp), \
+                (unsigned char **)(rsa))
+#define i2d_RSAPrivateKey_bio(bp,rsa) ASN1_i2d_bio(i2d_RSAPrivateKey,bp, \
+                (unsigned char *)rsa)
+
+#define d2i_RSAPublicKey_fp(fp,rsa) (RSA *)ASN1_d2i_fp((char *(*)())\
+                RSA_new,(char *(*)())d2i_RSAPublicKey, (fp), \
+                (unsigned char **)(rsa))
+#define i2d_RSAPublicKey_fp(fp,rsa) ASN1_i2d_fp(i2d_RSAPublicKey,fp, \
+                (unsigned char *)rsa)
+#define d2i_RSAPublicKey_bio(bp,rsa) (RSA *)ASN1_d2i_bio((char *(*)())\
+                RSA_new,(char *(*)())d2i_RSAPublicKey, (bp), \
+                (unsigned char **)(rsa))
+#define i2d_RSAPublicKey_bio(bp,rsa) ASN1_i2d_bio(i2d_RSAPublicKey,bp, \
+                (unsigned char *)rsa)
+
+#define d2i_DSAPrivateKey_fp(fp,dsa) (DSA *)ASN1_d2i_fp((char *(*)())\
+                DSA_new,(char *(*)())d2i_DSAPrivateKey, (fp), \
+                (unsigned char **)(dsa))
+#define i2d_DSAPrivateKey_fp(fp,dsa) ASN1_i2d_fp(i2d_DSAPrivateKey,fp, \
+                (unsigned char *)dsa)
+#define d2i_DSAPrivateKey_bio(bp,dsa) (DSA *)ASN1_d2i_bio((char *(*)())\
+                DSA_new,(char *(*)())d2i_DSAPrivateKey, (bp), \
+                (unsigned char **)(dsa))
+#define i2d_DSAPrivateKey_bio(bp,dsa) ASN1_i2d_bio(i2d_DSAPrivateKey,bp, \
+                (unsigned char *)dsa)
+
+#define X509_NAME_dup(xn) (X509_NAME *)ASN1_dup((int (*)())i2d_X509_NAME, \
+                (char *(*)())d2i_X509_NAME,(char *)xn)
+#define X509_NAME_ENTRY_dup(ne) (X509_NAME_ENTRY *)ASN1_dup( \
+                (int (*)())i2d_X509_NAME_ENTRY, \
+                (char *(*)())d2i_X509_NAME_ENTRY,\
+                (char *)ne)
+
+#define X509_digest(data,type,md,len) \
+        ASN1_digest((int (*)())i2d_X509,type,(char *)data,md,len)
+#define X509_NAME_digest(data,type,md,len) \
+        ASN1_digest((int (*)())i2d_X509_NAME,type,(char *)data,md,len)
+#define PKCS7_ISSUER_AND_SERIAL_digest(data,type,md,len) \
+        ASN1_digest((int (*)())i2d_PKCS7_ISSUER_AND_SERIAL,type,\
+                (char *)data,md,len)
+#endif
+
+#define X509_EXT_PACK_UNKNOWN   1
+#define X509_EXT_PACK_STRING    2
+
+#define         X509_get_version(x) ASN1_INTEGER_get((x)->cert_info->version)
+/* #define      X509_get_serialNumber(x) ((x)->cert_info->serialNumber) */
+#define         X509_get_notBefore(x) ((x)->cert_info->validity->notBefore)
+#define         X509_get_notAfter(x) ((x)->cert_info->validity->notAfter)
+#define         X509_extract_key(x)     X509_get_pubkey(x) /*****/
+#define         X509_REQ_get_version(x) ASN1_INTEGER_get((x)->req_info->version)
+#define         X509_REQ_get_subject_name(x) ((x)->req_info->subject)
+#define         X509_REQ_extract_key(a) X509_REQ_get_pubkey(a)
+#define         X509_name_cmp(a,b)      X509_NAME_cmp((a),(b))
+#define         X509_get_signature_type(x) EVP_PKEY_type(OBJ_obj2nid((x)->sig_alg->algorithm))
+
+/* This one is only used so that a binary form can output, as in
+ * i2d_X509_NAME(X509_get_X509_PUBKEY(x),&buf) */
+#define         X509_get_X509_PUBKEY(x) ((x)->cert_info->key)
+
+#ifndef NOPROTO
+
+#ifndef SSLEAY_MACROS
+#ifdef HEADER_ENVELOPE_H
+int X509_verify(X509 *a, EVP_PKEY *r);
+char *X509_verify_cert_error_string(long n);
+
+int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);
+int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);
+int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);
+
+int X509_sign(X509 *x, EVP_PKEY *pkey, EVP_MD *md);
+int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, EVP_MD *md);
+int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, EVP_MD *md);
+int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, EVP_MD *md);
+
+int X509_digest(X509 *data,EVP_MD *type,unsigned char *md,unsigned int *len);
+int X509_NAME_digest(X509_NAME *data,EVP_MD *type,
+        unsigned char *md,unsigned int *len);
+#endif
+
+#ifndef NO_FP_API
+X509 *d2i_X509_fp(FILE *fp, X509 *x509);
+int i2d_X509_fp(FILE *fp,X509 *x509);
+X509_CRL *d2i_X509_CRL_fp(FILE *fp,X509_CRL *crl);
+int i2d_X509_CRL_fp(FILE *fp,X509_CRL *crl);
+X509_REQ *d2i_X509_REQ_fp(FILE *fp,X509_REQ *req);
+int i2d_X509_REQ_fp(FILE *fp,X509_REQ *req);
+RSA *d2i_RSAPrivateKey_fp(FILE *fp,RSA *rsa);
+int i2d_RSAPrivateKey_fp(FILE *fp,RSA *rsa);
+DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA *dsa);
+int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa);
+RSA *d2i_RSAPublicKey_fp(FILE *fp,RSA *rsa);
+int i2d_RSAPublicKey_fp(FILE *fp,RSA *rsa);
+#endif
+
+#ifdef HEADER_BIO_H
+X509 *d2i_X509_bio(BIO *bp,X509 *x509);
+int i2d_X509_bio(BIO *bp,X509 *x509);
+X509_CRL *d2i_X509_CRL_bio(BIO *bp,X509_CRL *crl);
+int i2d_X509_CRL_bio(BIO *bp,X509_CRL *crl);
+X509_REQ *d2i_X509_REQ_bio(BIO *bp,X509_REQ *req);
+int i2d_X509_REQ_bio(BIO *bp,X509_REQ *req);
+RSA *d2i_RSAPrivateKey_bio(BIO *bp,RSA *rsa);
+int i2d_RSAPrivateKey_bio(BIO *bp,RSA *rsa);
+DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA *dsa);
+int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa);
+RSA *d2i_RSAPublicKey_bio(BIO *bp,RSA *rsa);
+int i2d_RSAPublicKey_bio(BIO *bp,RSA *rsa);
+#endif
+
+X509 *X509_dup(X509 *x509);
+X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex);
+X509_CRL *X509_CRL_dup(X509_CRL *crl);
+X509_REQ *X509_REQ_dup(X509_REQ *req);
+X509_NAME *X509_NAME_dup(X509_NAME *xn);
+X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne);
+RSA *RSAPublicKey_dup(RSA *rsa);
+RSA *RSAPrivateKey_dup(RSA *rsa);
+
+#endif /* !SSLEAY_MACROS */
+
+int             X509_cmp_current_time(ASN1_UTCTIME *s);
+ASN1_UTCTIME *  X509_gmtime_adj(ASN1_UTCTIME *s, long adj);
+
+char *          X509_get_default_cert_area(void );
+char *          X509_get_default_cert_dir(void );
+char *          X509_get_default_cert_file(void );
+char *          X509_get_default_cert_dir_env(void );
+char *          X509_get_default_cert_file_env(void );
+char *          X509_get_default_private_dir(void );
+
+X509_REQ *      X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, EVP_MD *md);
+X509 *          X509_REQ_to_X509(X509_REQ *r, int days,EVP_PKEY *pkey);
+void ERR_load_X509_strings(void );
+
+X509_ALGOR *    X509_ALGOR_new(void );
+void            X509_ALGOR_free(X509_ALGOR *a);
+int             i2d_X509_ALGOR(X509_ALGOR *a,unsigned char **pp);
+X509_ALGOR *    d2i_X509_ALGOR(X509_ALGOR **a,unsigned char **pp,
+                        long length);
+
+X509_VAL *      X509_VAL_new(void );
+void            X509_VAL_free(X509_VAL *a);
+int             i2d_X509_VAL(X509_VAL *a,unsigned char **pp);
+X509_VAL *      d2i_X509_VAL(X509_VAL **a,unsigned char **pp,
+                        long length);
+
+X509_PUBKEY *   X509_PUBKEY_new(void );
+void            X509_PUBKEY_free(X509_PUBKEY *a);
+int             i2d_X509_PUBKEY(X509_PUBKEY *a,unsigned char **pp);
+X509_PUBKEY *   d2i_X509_PUBKEY(X509_PUBKEY **a,unsigned char **pp,
+                        long length);
+int             X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
+EVP_PKEY *      X509_PUBKEY_get(X509_PUBKEY *key);
+int             X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK *chain);
+
+
+X509_SIG *      X509_SIG_new(void );
+void            X509_SIG_free(X509_SIG *a);
+int             i2d_X509_SIG(X509_SIG *a,unsigned char **pp);
+X509_SIG *      d2i_X509_SIG(X509_SIG **a,unsigned char **pp,long length);
+
+X509_REQ_INFO *X509_REQ_INFO_new(void);
+void            X509_REQ_INFO_free(X509_REQ_INFO *a);
+int             i2d_X509_REQ_INFO(X509_REQ_INFO *a,unsigned char **pp);
+X509_REQ_INFO *d2i_X509_REQ_INFO(X509_REQ_INFO **a,unsigned char **pp,
+                        long length);
+
+X509_REQ *      X509_REQ_new(void);
+void            X509_REQ_free(X509_REQ *a);
+int             i2d_X509_REQ(X509_REQ *a,unsigned char **pp);
+X509_REQ *      d2i_X509_REQ(X509_REQ **a,unsigned char **pp,long length);
+
+X509_ATTRIBUTE *X509_ATTRIBUTE_new(void );
+void            X509_ATTRIBUTE_free(X509_ATTRIBUTE *a);
+int             i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a,unsigned char **pp);
+X509_ATTRIBUTE *d2i_X509_ATTRIBUTE(X509_ATTRIBUTE **a,unsigned char **pp,
+                        long length);
+
+X509_EXTENSION *X509_EXTENSION_new(void );
+void            X509_EXTENSION_free(X509_EXTENSION *a);
+int             i2d_X509_EXTENSION(X509_EXTENSION *a,unsigned char **pp);
+X509_EXTENSION *d2i_X509_EXTENSION(X509_EXTENSION **a,unsigned char **pp,
+                        long length);
+
+X509_NAME_ENTRY *X509_NAME_ENTRY_new(void);
+void            X509_NAME_ENTRY_free(X509_NAME_ENTRY *a);
+int             i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a,unsigned char **pp);
+X509_NAME_ENTRY *d2i_X509_NAME_ENTRY(X509_NAME_ENTRY **a,unsigned char **pp,
+                        long length);
+
+X509_NAME *     X509_NAME_new(void);
+void            X509_NAME_free(X509_NAME *a);
+int             i2d_X509_NAME(X509_NAME *a,unsigned char **pp);
+X509_NAME *     d2i_X509_NAME(X509_NAME **a,unsigned char **pp,long length);
+int             X509_NAME_set(X509_NAME **xn, X509_NAME *name);
+
+
+X509_CINF *     X509_CINF_new(void);
+void            X509_CINF_free(X509_CINF *a);
+int             i2d_X509_CINF(X509_CINF *a,unsigned char **pp);
+X509_CINF *     d2i_X509_CINF(X509_CINF **a,unsigned char **pp,long length);
+
+X509 *          X509_new(void);
+void            X509_free(X509 *a);
+int             i2d_X509(X509 *a,unsigned char **pp);
+X509 *          d2i_X509(X509 **a,unsigned char **pp,long length);
+
+X509_REVOKED *  X509_REVOKED_new(void);
+void            X509_REVOKED_free(X509_REVOKED *a);
+int             i2d_X509_REVOKED(X509_REVOKED *a,unsigned char **pp);
+X509_REVOKED *  d2i_X509_REVOKED(X509_REVOKED **a,unsigned char **pp,long length);
+
+X509_CRL_INFO *X509_CRL_INFO_new(void);
+void            X509_CRL_INFO_free(X509_CRL_INFO *a);
+int             i2d_X509_CRL_INFO(X509_CRL_INFO *a,unsigned char **pp);
+X509_CRL_INFO *d2i_X509_CRL_INFO(X509_CRL_INFO **a,unsigned char **pp,
+                        long length);
+
+X509_CRL *      X509_CRL_new(void);
+void            X509_CRL_free(X509_CRL *a);
+int             i2d_X509_CRL(X509_CRL *a,unsigned char **pp);
+X509_CRL *      d2i_X509_CRL(X509_CRL **a,unsigned char **pp,long length);
+
+X509_PKEY *     X509_PKEY_new(void );
+void            X509_PKEY_free(X509_PKEY *a);
+int             i2d_X509_PKEY(X509_PKEY *a,unsigned char **pp);
+X509_PKEY *     d2i_X509_PKEY(X509_PKEY **a,unsigned char **pp,long length);
+
+NETSCAPE_SPKI * NETSCAPE_SPKI_new(void );
+void            NETSCAPE_SPKI_free(NETSCAPE_SPKI *a);
+int             i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a,unsigned char **pp);
+NETSCAPE_SPKI * d2i_NETSCAPE_SPKI(NETSCAPE_SPKI **a,unsigned char **pp,
+                        long length);
+
+NETSCAPE_SPKAC *NETSCAPE_SPKAC_new(void );
+void            NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a);
+int             i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a,unsigned char **pp);
+NETSCAPE_SPKAC *d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC **a,unsigned char **pp,
+                long length);
+
+#ifdef HEADER_ENVELOPE_H
+X509_INFO *     X509_INFO_new(void);
+void            X509_INFO_free(X509_INFO *a);
+char *          X509_NAME_oneline(X509_NAME *a,char *buf,int size);
+
+int ASN1_verify(int (*i2d)(), X509_ALGOR *algor1,
+        ASN1_BIT_STRING *signature,char *data,EVP_PKEY *pkey);
+
+int ASN1_digest(int (*i2d)(),EVP_MD *type,char *data,
+        unsigned char *md,unsigned int *len);
+
+int ASN1_sign(int (*i2d)(), X509_ALGOR *algor1, X509_ALGOR *algor2,
+        ASN1_BIT_STRING *signature,
+        char *data,EVP_PKEY *pkey, EVP_MD *type);
+#endif
+
+int             X509_set_version(X509 *x,long version);
+int             X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
+ASN1_INTEGER *  X509_get_serialNumber(X509 *x);
+int             X509_set_issuer_name(X509 *x, X509_NAME *name);
+X509_NAME *     X509_get_issuer_name(X509 *a);
+int             X509_set_subject_name(X509 *x, X509_NAME *name);
+X509_NAME *     X509_get_subject_name(X509 *a);
+int             X509_set_notBefore(X509 *x, ASN1_UTCTIME *tm);
+int             X509_set_notAfter(X509 *x, ASN1_UTCTIME *tm);
+int             X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
+EVP_PKEY *      X509_get_pubkey(X509 *x);
+int             X509_certificate_type(X509 *x,EVP_PKEY *pubkey /* optional */);
+
+int             X509_REQ_set_version(X509_REQ *x,long version);
+int             X509_REQ_set_subject_name(X509_REQ *req,X509_NAME *name);
+int             X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
+EVP_PKEY *      X509_REQ_get_pubkey(X509_REQ *req);
+
+int             X509_check_private_key(X509 *x509,EVP_PKEY *pkey);
+
+int             X509_issuer_and_serial_cmp(X509 *a, X509 *b);
+unsigned long   X509_issuer_and_serial_hash(X509 *a);
+
+int             X509_issuer_name_cmp(X509 *a, X509 *b);
+unsigned long   X509_issuer_name_hash(X509 *a);
+
+int             X509_subject_name_cmp(X509 *a,X509 *b);
+unsigned long   X509_subject_name_hash(X509 *x);
+
+int             X509_NAME_cmp (X509_NAME *a, X509_NAME *b);
+unsigned long   X509_NAME_hash(X509_NAME *x);
+
+int             X509_CRL_cmp(X509_CRL *a,X509_CRL *b);
+#ifndef NO_FP_API
+int             X509_print_fp(FILE *bp,X509 *x);
+int             X509_REQ_print_fp(FILE *bp,X509_REQ *req);
+#endif
+
+#ifdef HEADER_BIO_H
+int             X509_NAME_print(BIO *bp, X509_NAME *name, int obase);
+int             X509_print(BIO *bp,X509 *x);
+int             X509_REQ_print(BIO *bp,X509_REQ *req);
+#endif
+
+int             X509_NAME_entry_count(X509_NAME *name);
+int             X509_NAME_get_text_by_NID(X509_NAME *name, int nid,
+                        char *buf,int len);
+int             X509_NAME_get_text_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj,
+                        char *buf,int len);
+
+/* NOTE: you should be passsing -1, not 0 as lastpos.  The functions that use
+ * lastpos, seach after that position on. */
+int             X509_NAME_get_index_by_NID(X509_NAME *name,int nid,int lastpos);
+int             X509_NAME_get_index_by_OBJ(X509_NAME *name,ASN1_OBJECT *obj,
+                        int lastpos);
+X509_NAME_ENTRY *X509_NAME_get_entry(X509_NAME *name, int loc);
+X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
+int             X509_NAME_add_entry(X509_NAME *name,X509_NAME_ENTRY *ne,
+                        int loc, int set);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
+                        int type,unsigned char *bytes, int len);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
+                        ASN1_OBJECT *obj, int type,unsigned char *bytes,
+                        int len);
+int             X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne,
+                        ASN1_OBJECT *obj);
+int             X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
+                        unsigned char *bytes, int len);
+ASN1_OBJECT *   X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *ne);
+ASN1_STRING *   X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *ne);
+
+int             X509v3_get_ext_count(STACK *x);
+int             X509v3_get_ext_by_NID(STACK *x, int nid, int lastpos);
+int             X509v3_get_ext_by_OBJ(STACK *x,ASN1_OBJECT *obj,int lastpos);
+int             X509v3_get_ext_by_critical(STACK *x, int crit, int lastpos);
+X509_EXTENSION *X509v3_get_ext(STACK *x, int loc);
+X509_EXTENSION *X509v3_delete_ext(STACK *x, int loc);
+STACK *         X509v3_add_ext(STACK **x, X509_EXTENSION *ex, int loc);
+
+int             X509v3_data_type_by_OBJ(ASN1_OBJECT *obj);
+int             X509v3_data_type_by_NID(int nid);
+int             X509v3_pack_type_by_OBJ(ASN1_OBJECT *obj);
+int             X509v3_pack_type_by_NID(int nid);
+
+int             X509_get_ext_count(X509 *x);
+int             X509_get_ext_by_NID(X509 *x, int nid, int lastpos);
+int             X509_get_ext_by_OBJ(X509 *x,ASN1_OBJECT *obj,int lastpos);
+int             X509_get_ext_by_critical(X509 *x, int crit, int lastpos);
+X509_EXTENSION *X509_get_ext(X509 *x, int loc);
+X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
+int             X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
+
+int             X509_CRL_get_ext_count(X509_CRL *x);
+int             X509_CRL_get_ext_by_NID(X509_CRL *x, int nid, int lastpos);
+int             X509_CRL_get_ext_by_OBJ(X509_CRL *x,ASN1_OBJECT *obj,int lastpos);
+int             X509_CRL_get_ext_by_critical(X509_CRL *x, int crit, int lastpos);
+X509_EXTENSION *X509_CRL_get_ext(X509_CRL *x, int loc);
+X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
+int             X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
+
+int             X509_REVOKED_get_ext_count(X509_REVOKED *x);
+int             X509_REVOKED_get_ext_by_NID(X509_REVOKED *x, int nid, int lastpos);
+int             X509_REVOKED_get_ext_by_OBJ(X509_REVOKED *x,ASN1_OBJECT *obj,int lastpos);
+int             X509_REVOKED_get_ext_by_critical(X509_REVOKED *x, int crit, int lastpos);
+X509_EXTENSION *X509_REVOKED_get_ext(X509_REVOKED *x, int loc);
+X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
+int             X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);
+
+X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
+                        int nid, int crit, ASN1_OCTET_STRING *data);
+X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
+                        ASN1_OBJECT *obj,int crit,ASN1_OCTET_STRING *data);
+int             X509_EXTENSION_set_object(X509_EXTENSION *ex,ASN1_OBJECT *obj);
+int             X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
+int             X509_EXTENSION_set_data(X509_EXTENSION *ex,
+                        ASN1_OCTET_STRING *data);
+ASN1_OBJECT *   X509_EXTENSION_get_object(X509_EXTENSION *ex);
+ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
+int             X509_EXTENSION_get_critical(X509_EXTENSION *ex);
+ASN1_OCTET_STRING *X509v3_pack_string(ASN1_OCTET_STRING **ex,int type,
+                        unsigned char *bytes, int len);
+ASN1_STRING *   X509v3_unpack_string(ASN1_STRING **ex,int type,
+                        ASN1_OCTET_STRING *os);
+
+int             X509_verify_cert(X509_STORE_CTX *ctx);
+
+/* lookup a cert from a X509 STACK */
+X509 *X509_find_by_issuer_and_serial(STACK *sk,X509_NAME *name,
+                ASN1_INTEGER *serial);
+X509 *X509_find_by_subject(STACK *sk,X509_NAME *name);
+
+#else
+
+#ifndef SSLEAY_MACROS
+#ifdef HEADER_ENVELOPE_H
+int X509_verify();
+int X509_REQ_verify();
+int X509_CRL_verify();
+int NETSCAPE_SPKI_verify();
+
+int X509_sign();
+int X509_REQ_sign();
+int X509_CRL_sign();
+int NETSCAPE_SPKI_sign();
+
+int X509_digest();
+int X509_NAME_digest();
+#endif
+
+#ifndef NO_FP_API
+X509 *d2i_X509_fp();
+int i2d_X509_fp();
+X509_CRL *d2i_X509_CRL_fp();
+int i2d_X509_CRL_fp();
+X509_REQ *d2i_X509_REQ_fp();
+int i2d_X509_REQ_fp();
+RSA *d2i_RSAPrivateKey_fp();
+int i2d_RSAPrivateKey_fp();
+DSA *d2i_DSAPrivateKey_fp();
+int i2d_DSAPrivateKey_fp();
+RSA *d2i_RSAPublicKey_fp();
+int i2d_RSAPublicKey_fp();
+#endif
+
+X509 *d2i_X509_bio();
+int i2d_X509_bio();
+X509_CRL *d2i_X509_CRL_bio();
+int i2d_X509_CRL_bio();
+X509_REQ *d2i_X509_REQ_bio();
+int i2d_X509_REQ_bio();
+RSA *d2i_RSAPrivateKey_bio();
+int i2d_RSAPrivateKey_bio();
+DSA *d2i_DSAPrivateKey_bio();
+int i2d_DSAPrivateKey_bio();
+RSA *d2i_RSAPublicKey_bio();
+int i2d_RSAPublicKey_bio();
+
+X509 *X509_dup();
+X509_EXTENSION *X509_EXTENSION_dup();
+X509_CRL *X509_CRL_dup();
+X509_REQ *X509_REQ_dup();
+X509_NAME *X509_NAME_dup();
+X509_NAME_ENTRY *X509_NAME_ENTRY_dup();
+RSA *RSAPublicKey_dup();
+RSA *RSAPrivateKey_dup();
+
+#endif /* !SSLEAY_MACROS */
+
+int             X509_cmp_current_time();
+ASN1_UTCTIME *  X509_gmtime_adj();
+
+char *          X509_get_default_cert_area();
+char *          X509_get_default_cert_dir();
+char *          X509_get_default_cert_file();
+char *          X509_get_default_cert_dir_env();
+char *          X509_get_default_cert_file_env();
+char *          X509_get_default_private_dir();
+
+X509_REQ *      X509_to_X509_REQ();
+X509 *          X509_REQ_to_X509();
+void ERR_load_X509_strings();
+
+X509_ALGOR *    X509_ALGOR_new();
+void            X509_ALGOR_free();
+int             i2d_X509_ALGOR();
+X509_ALGOR *    d2i_X509_ALGOR();
+
+X509_VAL *      X509_VAL_new();
+void            X509_VAL_free();
+int             i2d_X509_VAL();
+X509_VAL *      d2i_X509_VAL();
+
+X509_PUBKEY *   X509_PUBKEY_new();
+void            X509_PUBKEY_free();
+int             i2d_X509_PUBKEY();
+X509_PUBKEY *   d2i_X509_PUBKEY();
+int             X509_PUBKEY_set();
+EVP_PKEY *      X509_PUBKEY_get();
+int             X509_get_pubkey_parameters();
+
+X509_SIG *      X509_SIG_new();
+void            X509_SIG_free();
+int             i2d_X509_SIG();
+X509_SIG *      d2i_X509_SIG();
+
+X509_REQ_INFO *X509_REQ_INFO_new();
+void            X509_REQ_INFO_free();
+int             i2d_X509_REQ_INFO();
+X509_REQ_INFO *d2i_X509_REQ_INFO();
+
+X509_REQ *      X509_REQ_new();
+void            X509_REQ_free();
+int             i2d_X509_REQ();
+X509_REQ *      d2i_X509_REQ();
+
+X509_ATTRIBUTE *X509_ATTRIBUTE_new();
+void            X509_ATTRIBUTE_free();
+int             i2d_X509_ATTRIBUTE();
+X509_ATTRIBUTE *d2i_X509_ATTRIBUTE();
+
+X509_EXTENSION *X509_EXTENSION_new();
+void            X509_EXTENSION_free();
+int             i2d_X509_EXTENSION();
+X509_EXTENSION *d2i_X509_EXTENSION();
+
+X509_NAME_ENTRY *X509_NAME_ENTRY_new();
+void            X509_NAME_ENTRY_free();
+int             i2d_X509_NAME_ENTRY();
+X509_NAME_ENTRY *d2i_X509_NAME_ENTRY();
+
+X509_NAME *     X509_NAME_new();
+void            X509_NAME_free();
+int             i2d_X509_NAME();
+X509_NAME *     d2i_X509_NAME();
+int             X509_NAME_set();
+
+
+X509_CINF *     X509_CINF_new();
+void            X509_CINF_free();
+int             i2d_X509_CINF();
+X509_CINF *     d2i_X509_CINF();
+
+X509 *          X509_new();
+void            X509_free();
+int             i2d_X509();
+X509 *          d2i_X509();
+
+X509_REVOKED *  X509_REVOKED_new();
+void            X509_REVOKED_free();
+int             i2d_X509_REVOKED();
+X509_REVOKED *  d2i_X509_REVOKED();
+
+X509_CRL_INFO *X509_CRL_INFO_new();
+void            X509_CRL_INFO_free();
+int             i2d_X509_CRL_INFO();
+X509_CRL_INFO *d2i_X509_CRL_INFO();
+
+X509_CRL *      X509_CRL_new();
+void            X509_CRL_free();
+int             i2d_X509_CRL();
+X509_CRL *      d2i_X509_CRL();
+
+X509_PKEY *     X509_PKEY_new();
+void            X509_PKEY_free();
+int             i2d_X509_PKEY();
+X509_PKEY *     d2i_X509_PKEY();
+
+NETSCAPE_SPKI * NETSCAPE_SPKI_new();
+void            NETSCAPE_SPKI_free();
+int             i2d_NETSCAPE_SPKI();
+NETSCAPE_SPKI * d2i_NETSCAPE_SPKI();
+
+NETSCAPE_SPKAC *NETSCAPE_SPKAC_new();
+void            NETSCAPE_SPKAC_free();
+int             i2d_NETSCAPE_SPKAC();
+NETSCAPE_SPKAC *d2i_NETSCAPE_SPKAC();
+
+#ifdef HEADER_ENVELOPE_H
+X509_INFO *     X509_INFO_new();
+void            X509_INFO_free();
+#endif
+
+char *          X509_NAME_oneline();
+
+int ASN1_verify();
+int ASN1_digest();
+int ASN1_sign();
+
+int             X509_set_version();
+int             X509_set_serialNumber();
+ASN1_INTEGER *  X509_get_serialNumber();
+int             X509_set_issuer_name();
+X509_NAME *     X509_get_issuer_name();
+int             X509_set_subject_name();
+X509_NAME *     X509_get_subject_name();
+int             X509_set_notBefore();
+int             X509_set_notAfter();
+int             X509_set_pubkey();
+EVP_PKEY *      X509_get_pubkey();
+int             X509_certificate_type();
+
+int             X509_REQ_set_version();
+int             X509_REQ_set_subject_name();
+int             X509_REQ_set_pubkey();
+EVP_PKEY *      X509_REQ_get_pubkey();
+
+int             X509_check_private_key();
+
+int             X509_issuer_and_serial_cmp();
+unsigned long   X509_issuer_and_serial_hash();
+
+int             X509_issuer_name_cmp();
+unsigned long   X509_issuer_name_hash();
+
+int             X509_subject_name_cmp();
+unsigned long   X509_subject_name_hash();
+
+int             X509_NAME_cmp ();
+unsigned long   X509_NAME_hash();
+
+int             X509_CRL_cmp();
+#ifndef NO_FP_API
+int             X509_print_fp();
+int             X509_REQ_print_fp();
+#endif
+
+int             X509_NAME_print();
+int             X509_print();
+int             X509_REQ_print();
+
+int             X509_NAME_entry_count();
+int             X509_NAME_get_text_by_NID();
+int             X509_NAME_get_text_by_OBJ();
+
+int             X509_NAME_get_index_by_NID();
+int             X509_NAME_get_index_by_OBJ();
+X509_NAME_ENTRY *X509_NAME_get_entry();
+X509_NAME_ENTRY *X509_NAME_delete_entry();
+int             X509_NAME_add_entry();
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID();
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ();
+int             X509_NAME_ENTRY_set_object();
+int             X509_NAME_ENTRY_set_data();
+ASN1_OBJECT *   X509_NAME_ENTRY_get_object();
+ASN1_STRING *   X509_NAME_ENTRY_get_data();
+
+int             X509v3_get_ext_count();
+int             X509v3_get_ext_by_NID();
+int             X509v3_get_ext_by_OBJ();
+int             X509v3_get_ext_by_critical();
+X509_EXTENSION *X509v3_get_ext();
+X509_EXTENSION *X509v3_delete_ext();
+STACK *         X509v3_add_ext();
+
+int             X509v3_data_type_by_OBJ();
+int             X509v3_data_type_by_NID();
+int             X509v3_pack_type_by_OBJ();
+int             X509v3_pack_type_by_NID();
+
+int             X509_get_ext_count();
+int             X509_get_ext_by_NID();
+int             X509_get_ext_by_OBJ();
+int             X509_get_ext_by_critical();
+X509_EXTENSION *X509_get_ext();
+X509_EXTENSION *X509_delete_ext();
+int             X509_add_ext();
+
+int             X509_CRL_get_ext_count();
+int             X509_CRL_get_ext_by_NID();
+int             X509_CRL_get_ext_by_OBJ();
+int             X509_CRL_get_ext_by_critical();
+X509_EXTENSION *X509_CRL_get_ext();
+X509_EXTENSION *X509_CRL_delete_ext();
+int             X509_CRL_add_ext();
+
+int             X509_REVOKED_get_ext_count();
+int             X509_REVOKED_get_ext_by_NID();
+int             X509_REVOKED_get_ext_by_OBJ();
+int             X509_REVOKED_get_ext_by_critical();
+X509_EXTENSION *X509_REVOKED_get_ext();
+X509_EXTENSION *X509_REVOKED_delete_ext();
+int             X509_REVOKED_add_ext();
+
+X509_EXTENSION *X509_EXTENSION_create_by_NID();
+X509_EXTENSION *X509_EXTENSION_create_by_OBJ();
+int             X509_EXTENSION_set_object();
+int             X509_EXTENSION_set_critical();
+int             X509_EXTENSION_set_data();
+ASN1_OBJECT *   X509_EXTENSION_get_object();
+ASN1_OCTET_STRING *X509_EXTENSION_get_data();
+int             X509_EXTENSION_get_critical();
+ASN1_OCTET_STRING *X509v3_pack_string();
+ASN1_STRING *   X509v3_unpack_string();
+
+int             X509_verify_cert();
+char *          X509_verify_cert_error_string();
+
+/* lookup a cert from a X509 STACK */
+X509 *X509_find_by_issuer_and_serial();
+X509 *X509_find_by_subject();
+
+#endif
+
+/* BEGIN ERROR CODES */
+/* Error codes for the X509 functions. */
+
+/* Function codes. */
+#define X509_F_ADD_CERT_DIR                              100
+#define X509_F_BY_FILE_CTRL                              101
+#define X509_F_DIR_CTRL                                  102
+#define X509_F_GET_CERT_BY_SUBJECT                       103
+#define X509_F_X509V3_ADD_EXT                            104
+#define X509_F_X509V3_ADD_EXTENSION                      105
+#define X509_F_X509V3_PACK_STRING                        106
+#define X509_F_X509V3_UNPACK_STRING                      107
+#define X509_F_X509_EXTENSION_CREATE_BY_NID              108
+#define X509_F_X509_EXTENSION_CREATE_BY_OBJ              109
+#define X509_F_X509_GET_PUBKEY_PARAMETERS                110
+#define X509_F_X509_LOAD_CERT_FILE                       111
+#define X509_F_X509_LOAD_CRL_FILE                        112
+#define X509_F_X509_NAME_ADD_ENTRY                       113
+#define X509_F_X509_NAME_ENTRY_CREATE_BY_NID             114
+#define X509_F_X509_NAME_ENTRY_SET_OBJECT                115
+#define X509_F_X509_NAME_ONELINE                         116
+#define X509_F_X509_NAME_PRINT                           117
+#define X509_F_X509_PRINT_FP                             118
+#define X509_F_X509_PUBKEY_GET                           119
+#define X509_F_X509_PUBKEY_SET                           120
+#define X509_F_X509_REQ_PRINT                            121
+#define X509_F_X509_REQ_PRINT_FP                         122
+#define X509_F_X509_REQ_TO_X509                          123
+#define X509_F_X509_STORE_ADD_CERT                       124
+#define X509_F_X509_STORE_ADD_CRL                        125
+#define X509_F_X509_TO_X509_REQ                          126
+#define X509_F_X509_VERIFY_CERT                          127
+
+/* Reason codes. */
+#define X509_R_BAD_X509_FILETYPE                         100
+#define X509_R_CERT_ALREADY_IN_HASH_TABLE                101
+#define X509_R_ERR_ASN1_LIB                              102
+#define X509_R_LOADING_CERT_DIR                          103
+#define X509_R_LOADING_DEFAULTS                          104
+#define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY              105
+#define X509_R_SHOULD_RETRY                              106
+#define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN        107
+#define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY            108
+#define X509_R_UNKNOWN_NID                               109
+#define X509_R_UNKNOWN_STRING_TYPE                       110
+#define X509_R_UNSUPPORTED_ALGORITHM                     111
+#define X509_R_WRONG_LOOKUP_TYPE                         112
+ 
+#ifdef  __cplusplus
+}
+#endif
+#endif
+