Add support for legacy PEM format private keys in EVP_PKEY_ASN1_METHOD.
[openssl.git] / crypto / evp / evp.h
index 42462d7..76ed876 100644 (file)
 # undef OPENSSL_ALGORITHM_DEFINES
 #endif
 
+#include <openssl/ossl_typ.h>
+
+#include <openssl/symhacks.h>
+
 #ifndef OPENSSL_NO_BIO
 #include <openssl/bio.h>
 #endif
-#ifndef OPENSSL_NO_MD2
-#include <openssl/md2.h>
-#endif
-#ifndef OPENSSL_NO_MD4
-#include <openssl/md4.h>
-#endif
-#ifndef OPENSSL_NO_MD5
-#include <openssl/md5.h>
-#endif
-#ifndef OPENSSL_NO_SHA
-#include <openssl/sha.h>
-#endif
-#ifndef OPENSSL_NO_RIPEMD
-#include <openssl/ripemd.h>
-#endif
-#ifndef OPENSSL_NO_DES
-#include <openssl/des.h>
-#endif
-#ifndef OPENSSL_NO_RC4
-#include <openssl/rc4.h>
-#endif
-#ifndef OPENSSL_NO_RC2
-#include <openssl/rc2.h>
-#endif
-#ifndef OPENSSL_NO_RC5
-#include <openssl/rc5.h>
-#endif
-#ifndef OPENSSL_NO_BF
-#include <openssl/blowfish.h>
-#endif
-#ifndef OPENSSL_NO_CAST
-#include <openssl/cast.h>
-#endif
-#ifndef OPENSSL_NO_IDEA
-#include <openssl/idea.h>
-#endif
-#ifndef OPENSSL_NO_MDC2
-#include <openssl/mdc2.h>
-#endif
-#ifndef OPENSSL_NO_AES
-#include <openssl/rijndael.h>
-#endif
 
+/*
 #define EVP_RC2_KEY_SIZE               16
 #define EVP_RC4_KEY_SIZE               16
 #define EVP_BLOWFISH_KEY_SIZE          16
 #define EVP_CAST5_KEY_SIZE             16
 #define EVP_RC5_32_12_16_KEY_SIZE      16
-#define EVP_MAX_MD_SIZE                        (16+20) /* The SSLv3 md5+sha1 type */
+*/
+#define EVP_MAX_MD_SIZE                        64      /* longest known is SHA512 */
 #define EVP_MAX_KEY_LENGTH             32
 #define EVP_MAX_IV_LENGTH              16
 #define EVP_MAX_BLOCK_LENGTH           32
 /* Default PKCS#5 iteration count */
 #define PKCS5_DEFAULT_ITER             2048
 
-#ifndef OPENSSL_NO_RSA
-#include <openssl/rsa.h>
-#endif
-
-#ifndef OPENSSL_NO_DSA
-#include <openssl/dsa.h>
-#endif
-
-#ifndef OPENSSL_NO_DH
-#include <openssl/dh.h>
-#endif
-
 #include <openssl/objects.h>
 
 #define EVP_PK_RSA     0x0001
 #define EVP_PK_DSA     0x0002
 #define EVP_PK_DH      0x0004
+#define EVP_PK_EC      0x0008
 #define EVP_PKT_SIGN   0x0010
 #define EVP_PKT_ENC    0x0020
 #define EVP_PKT_EXCH   0x0040
 #define EVP_PKS_RSA    0x0100
 #define EVP_PKS_DSA    0x0200
+#define EVP_PKS_EC     0x0400
 #define EVP_PKT_EXP    0x1000 /* <= 512 bit key */
 
 #define EVP_PKEY_NONE  NID_undef
 #define EVP_PKEY_DSA3  NID_dsaWithSHA1
 #define EVP_PKEY_DSA4  NID_dsaWithSHA1_2
 #define EVP_PKEY_DH    NID_dhKeyAgreement
+#define EVP_PKEY_EC    NID_X9_62_id_ecPublicKey
 
 #ifdef __cplusplus
 extern "C" {
@@ -168,11 +123,12 @@ extern "C" {
 /* Type needs to be a bit field
  * Sub-type needs to be for variations on the method, as in, can it do
  * arbitrary encryption.... */
-typedef struct evp_pkey_st
+struct evp_pkey_st
        {
        int type;
        int save_type;
        int references;
+       const EVP_PKEY_ASN1_METHOD *ameth;
        union   {
                char *ptr;
 #ifndef OPENSSL_NO_RSA
@@ -183,11 +139,14 @@ typedef struct evp_pkey_st
 #endif
 #ifndef OPENSSL_NO_DH
                struct dh_st *dh;       /* DH */
+#endif
+#ifndef OPENSSL_NO_EC
+               struct ec_key_st *ec;   /* ECC */
 #endif
                } pkey;
        int save_parameters;
        STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */
-       } EVP_PKEY;
+       } /* EVP_PKEY */;
 
 #define EVP_PKEY_MO_SIGN       0x0001
 #define EVP_PKEY_MO_VERIFY     0x0002
@@ -232,7 +191,7 @@ typedef struct evp_pkey_md_st
                        EVP_rsa_octet_string(),EVP_mdc2())
 #define EVP_dsa_sha() \
                EVP_PKEY_MD_add(NID_dsaWithSHA,\
-                       EVP_dsa(),EVP_mdc2())
+                       EVP_dsa(),EVP_sha())
 #define EVP_dsa_sha1() \
                EVP_PKEY_MD_add(NID_dsaWithSHA1,\
                        EVP_dsa(),EVP_sha1())
@@ -248,7 +207,6 @@ typedef struct evp_pkey_method_st
        int (*sign)();
        int (*verify)();
        struct  {
-               int
                int (*set)();   /* get and/or set the underlying type */
                int (*get)();
                int (*encrypt)();
@@ -263,40 +221,65 @@ typedef struct evp_pkey_method_st
 #endif
 
 #ifndef EVP_MD
-typedef struct env_md_st
+struct env_md_st
        {
        int type;
        int pkey_type;
        int md_size;
-       void (*init)();
-       void (*update)();
-       void (*final)();
-
-       int (*sign)();
-       int (*verify)();
+       unsigned long flags;
+       int (*init)(EVP_MD_CTX *ctx);
+       int (*update)(EVP_MD_CTX *ctx,const void *data,size_t count);
+       int (*final)(EVP_MD_CTX *ctx,unsigned char *md);
+       int (*copy)(EVP_MD_CTX *to,const EVP_MD_CTX *from);
+       int (*cleanup)(EVP_MD_CTX *ctx);
+
+       /* FIXME: prototype these some day */
+       int (*sign)(int type, const unsigned char *m, unsigned int m_length,
+                   unsigned char *sigret, unsigned int *siglen, void *key);
+       int (*verify)(int type, const unsigned char *m, unsigned int m_length,
+                     const unsigned char *sigbuf, unsigned int siglen,
+                     void *key);
        int required_pkey_type[5]; /*EVP_PKEY_xxx */
        int block_size;
-       int ctx_size; /* how big does the ctx need to be */
-       } EVP_MD;
+       int ctx_size; /* how big does the ctx->md_data need to be */
+       } /* EVP_MD */;
 
+typedef int evp_sign_method(int type,const unsigned char *m,
+                           unsigned int m_length,unsigned char *sigret,
+                           unsigned int *siglen, void *key);
+typedef int evp_verify_method(int type,const unsigned char *m,
+                           unsigned int m_length,const unsigned char *sigbuf,
+                           unsigned int siglen, void *key);
 
+#define EVP_MD_FLAG_ONESHOT    0x0001 /* digest can only handle a single
+                                       * block */
 
 #define EVP_PKEY_NULL_method   NULL,NULL,{0,0,0,0}
 
 #ifndef OPENSSL_NO_DSA
-#define EVP_PKEY_DSA_method    DSA_sign,DSA_verify, \
+#define EVP_PKEY_DSA_method    (evp_sign_method *)DSA_sign, \
+                               (evp_verify_method *)DSA_verify, \
                                {EVP_PKEY_DSA,EVP_PKEY_DSA2,EVP_PKEY_DSA3, \
                                        EVP_PKEY_DSA4,0}
 #else
 #define EVP_PKEY_DSA_method    EVP_PKEY_NULL_method
 #endif
 
+#ifndef OPENSSL_NO_ECDSA
+#define EVP_PKEY_ECDSA_method   (evp_sign_method *)ECDSA_sign, \
+                               (evp_verify_method *)ECDSA_verify, \
+                                 {EVP_PKEY_EC,0,0,0}
+#else   
+#define EVP_PKEY_ECDSA_method   EVP_PKEY_NULL_method
+#endif
+
 #ifndef OPENSSL_NO_RSA
-#define EVP_PKEY_RSA_method    RSA_sign,RSA_verify, \
+#define EVP_PKEY_RSA_method    (evp_sign_method *)RSA_sign, \
+                               (evp_verify_method *)RSA_verify, \
                                {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0}
 #define EVP_PKEY_RSA_ASN1_OCTET_STRING_method \
-                               RSA_sign_ASN1_OCTET_STRING, \
-                               RSA_verify_ASN1_OCTET_STRING, \
+                               (evp_sign_method *)RSA_sign_ASN1_OCTET_STRING, \
+                               (evp_verify_method *)RSA_verify_ASN1_OCTET_STRING, \
                                {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0}
 #else
 #define EVP_PKEY_RSA_method    EVP_PKEY_NULL_method
@@ -305,34 +288,22 @@ typedef struct env_md_st
 
 #endif /* !EVP_MD */
 
-typedef struct env_md_ctx_st
+struct env_md_ctx_st
        {
        const EVP_MD *digest;
-       union   {
-               unsigned char base[4];
-#ifndef OPENSSL_NO_MD2
-               MD2_CTX md2;
-#endif
-#ifndef OPENSSL_NO_MD5
-               MD5_CTX md5;
-#endif
-#ifndef OPENSSL_NO_MD4
-               MD4_CTX md4;
-#endif
-#ifndef OPENSSL_NO_RIPEMD
-               RIPEMD160_CTX ripemd160;
-#endif
-#ifndef OPENSSL_NO_SHA
-               SHA_CTX sha;
-#endif
-#ifndef OPENSSL_NO_MDC2
-               MDC2_CTX mdc2;
-#endif
-               } md;
-       } EVP_MD_CTX;
+       ENGINE *engine; /* functional reference if 'digest' is ENGINE-provided */
+       unsigned long flags;
+       void *md_data;
+       } /* EVP_MD_CTX */;
 
-typedef struct evp_cipher_st EVP_CIPHER;
-typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
+/* values for EVP_MD_CTX flags */
+
+#define EVP_MD_CTX_FLAG_ONESHOT                0x0001 /* digest update will be called
+                                               * once only */
+#define EVP_MD_CTX_FLAG_CLEANED                0x0002 /* context has already been
+                                               * cleaned */
+#define EVP_MD_CTX_FLAG_REUSE          0x0004 /* Don't free up ctx->md_data
+                                               * in EVP_MD_CTX_cleanup */
 
 struct evp_cipher_st
        {
@@ -346,12 +317,12 @@ struct evp_cipher_st
        int (*do_cipher)(EVP_CIPHER_CTX *ctx, unsigned char *out,
                         const unsigned char *in, unsigned int inl);/* encrypt/decrypt data */
        int (*cleanup)(EVP_CIPHER_CTX *); /* cleanup ctx */
-       int ctx_size;           /* how big the ctx needs to be */
+       int ctx_size;           /* how big ctx->cipher_data needs to be */
        int (*set_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *); /* Populate a ASN1_TYPE with parameters */
        int (*get_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *); /* Get parameters from a ASN1_TYPE */
        int (*ctrl)(EVP_CIPHER_CTX *, int type, int arg, void *ptr); /* Miscellaneous operations */
        void *app_data;         /* Application data */
-       };
+       } /* EVP_CIPHER */;
 
 /* Values for cipher flags */
 
@@ -375,6 +346,8 @@ struct evp_cipher_st
 #define        EVP_CIPH_CUSTOM_KEY_LENGTH      0x80
 /* Don't use standard block padding */
 #define        EVP_CIPH_NO_PADDING             0x100
+/* cipher handles random key generation */
+#define        EVP_CIPH_RAND_KEY               0x200
 
 /* ctrl() values */
 
@@ -384,6 +357,7 @@ struct evp_cipher_st
 #define        EVP_CTRL_SET_RC2_KEY_BITS       0x3
 #define        EVP_CTRL_GET_RC5_ROUNDS         0x4
 #define        EVP_CTRL_SET_RC5_ROUNDS         0x5
+#define        EVP_CTRL_RAND_KEY               0x6
 
 typedef struct evp_cipher_info_st
        {
@@ -394,6 +368,7 @@ typedef struct evp_cipher_info_st
 struct evp_cipher_ctx_st
        {
        const EVP_CIPHER *cipher;
+       ENGINE *engine; /* functional reference if 'cipher' is ENGINE-provided */
        int encrypt;            /* encrypt or decrypt */
        int buf_len;            /* number we have left */
 
@@ -405,58 +380,11 @@ struct evp_cipher_ctx_st
        void *app_data;         /* application stuff */
        int key_len;            /* May change for variable length cipher */
        unsigned long flags;    /* Various flags */
-       union
-               {
-#ifndef OPENSSL_NO_RC4
-               struct
-                       {
-                       unsigned char key[EVP_RC4_KEY_SIZE];
-                       RC4_KEY ks;     /* working key */
-                       } rc4;
-#endif
-#ifndef OPENSSL_NO_DES
-               des_key_schedule des_ks;/* key schedule */
-               struct
-                       {
-                       des_key_schedule ks;/* key schedule */
-                       des_cblock inw;
-                       des_cblock outw;
-                       } desx_cbc;
-               struct
-                       {
-                       des_key_schedule ks1;/* key schedule */
-                       des_key_schedule ks2;/* key schedule (for ede) */
-                       des_key_schedule ks3;/* key schedule (for ede3) */
-                       } des_ede;
-#endif
-#ifndef OPENSSL_NO_IDEA
-               IDEA_KEY_SCHEDULE idea_ks;/* key schedule */
-#endif
-#ifndef OPENSSL_NO_RC2
-               struct
-                       {
-                       int key_bits;   /* effective key bits */
-                       RC2_KEY ks;/* key schedule */
-                       } rc2;
-#endif
-#ifndef OPENSSL_NO_RC5
-               struct
-                       {
-                       int rounds;     /* number of rounds */
-                       RC5_32_KEY ks;/* key schedule */
-                       } rc5;
-#endif
-#ifndef OPENSSL_NO_BF
-               BF_KEY bf_ks;/* key schedule */
-#endif
-#ifndef OPENSSL_NO_CAST
-               CAST_KEY cast_ks;/* key schedule */
-#endif
-#ifndef OPENSSL_NO_AES
-               RIJNDAEL_KEY rijndael;
-#endif
-               } c;
-       };
+       void *cipher_data; /* per EVP data */
+       int final_used;
+       int block_mask;
+       unsigned char final[EVP_MAX_BLOCK_LENGTH];/* possible final block */
+       } /* EVP_CIPHER_CTX */;
 
 typedef struct evp_Encode_Ctx_st
        {
@@ -473,8 +401,8 @@ typedef struct evp_Encode_Ctx_st
 
 /* Password based encryption function */
 typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-               ASN1_TYPE *param, EVP_CIPHER *cipher,
-                EVP_MD *md, int en_de);
+               ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                const EVP_MD *md, int en_de);
 
 #ifndef OPENSSL_NO_RSA
 #define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\
@@ -491,6 +419,11 @@ typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
                                        (char *)(dh))
 #endif
 
+#ifndef OPENSSL_NO_EC
+#define EVP_PKEY_assign_EC_KEY(pkey,eckey) EVP_PKEY_assign((pkey),EVP_PKEY_EC,\
+                                        (char *)(eckey))
+#endif
+
 /* Add some extra combinations */
 #define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a))
 #define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a))
@@ -498,6 +431,8 @@ typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 #define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a))
 
 #define EVP_MD_type(e)                 ((e)->type)
+#define EVP_MD_nid(e)                  EVP_MD_type(e)
+#define EVP_MD_name(e)                 OBJ_nid2sn(EVP_MD_nid(e))
 #define EVP_MD_pkey_type(e)            ((e)->pkey_type)
 #define EVP_MD_size(e)                 ((e)->md_size)
 #define EVP_MD_block_size(e)           ((e)->block_size)
@@ -508,11 +443,12 @@ typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 #define EVP_MD_CTX_type(e)             EVP_MD_type((e)->digest)
 
 #define EVP_CIPHER_nid(e)              ((e)->nid)
+#define EVP_CIPHER_name(e)             OBJ_nid2sn(EVP_CIPHER_nid(e))
 #define EVP_CIPHER_block_size(e)       ((e)->block_size)
 #define EVP_CIPHER_key_length(e)       ((e)->key_len)
 #define EVP_CIPHER_iv_length(e)                ((e)->iv_len)
 #define EVP_CIPHER_flags(e)            ((e)->flags)
-#define EVP_CIPHER_mode(e)             ((e)->flags) & EVP_CIPH_MODE)
+#define EVP_CIPHER_mode(e)             (((e)->flags) & EVP_CIPH_MODE)
 
 #define EVP_CIPHER_CTX_cipher(e)       ((e)->cipher)
 #define EVP_CIPHER_CTX_nid(e)          ((e)->cipher->nid)
@@ -528,8 +464,10 @@ typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 #define EVP_ENCODE_LENGTH(l)   (((l+2)/3*4)+(l/48+1)*2+80)
 #define EVP_DECODE_LENGTH(l)   ((l+3)/4*3+80)
 
+#define EVP_SignInit_ex(a,b,c)         EVP_DigestInit_ex(a,b,c)
 #define EVP_SignInit(a,b)              EVP_DigestInit(a,b)
 #define EVP_SignUpdate(a,b,c)          EVP_DigestUpdate(a,b,c)
+#define        EVP_VerifyInit_ex(a,b,c)        EVP_DigestInit_ex(a,b,c)
 #define        EVP_VerifyInit(a,b)             EVP_DigestInit(a,b)
 #define        EVP_VerifyUpdate(a,b,c)         EVP_DigestUpdate(a,b,c)
 #define EVP_OpenUpdate(a,b,c,d,e)      EVP_DecryptUpdate(a,b,c,d,e)
@@ -556,218 +494,337 @@ void BIO_set_md(BIO *,const EVP_MD *md);
 #define EVP_delete_digest_alias(alias) \
        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS);
 
-
-int     EVP_MD_CTX_copy(EVP_MD_CTX *out,EVP_MD_CTX *in);  
-void   EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
-void   EVP_DigestUpdate(EVP_MD_CTX *ctx,const void *d,
-                        unsigned int cnt);
-void   EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
-int    EVP_Digest(void *data, unsigned int count,
-               unsigned char *md, unsigned int *size, const EVP_MD *type);
+void   EVP_MD_CTX_init(EVP_MD_CTX *ctx);
+int    EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx);
+EVP_MD_CTX *EVP_MD_CTX_create(void);
+void   EVP_MD_CTX_destroy(EVP_MD_CTX *ctx);
+int     EVP_MD_CTX_copy_ex(EVP_MD_CTX *out,const EVP_MD_CTX *in);  
+#define EVP_MD_CTX_set_flags(ctx,flgs) ((ctx)->flags|=(flgs))
+#define EVP_MD_CTX_clear_flags(ctx,flgs) ((ctx)->flags&=~(flgs))
+#define EVP_MD_CTX_test_flags(ctx,flgs) ((ctx)->flags&(flgs))
+int    EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
+int    EVP_DigestUpdate(EVP_MD_CTX *ctx,const void *d,
+                        size_t cnt);
+int    EVP_DigestFinal_ex(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
+int    EVP_Digest(const void *data, size_t count,
+               unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl);
+
+int     EVP_MD_CTX_copy(EVP_MD_CTX *out,const EVP_MD_CTX *in);  
+int    EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
+int    EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
 
 int    EVP_read_pw_string(char *buf,int length,const char *prompt,int verify);
-void   EVP_set_pw_prompt(char *prompt);
+void   EVP_set_pw_prompt(const char *prompt);
 char * EVP_get_pw_prompt(void);
 
-int    EVP_BytesToKey(const EVP_CIPHER *type,EVP_MD *md,unsigned char *salt,
-               unsigned char *data, int datal, int count,
-               unsigned char *key,unsigned char *iv);
+int    EVP_BytesToKey(const EVP_CIPHER *type,const EVP_MD *md,
+               const unsigned char *salt, const unsigned char *data,
+               int datal, int count, unsigned char *key,unsigned char *iv);
 
-int    EVP_EncryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
-               unsigned char *key, unsigned char *iv);
+int    EVP_EncryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher,
+               const unsigned char *key, const unsigned char *iv);
+int    EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl,
+               const unsigned char *key, const unsigned char *iv);
 int    EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
-               int *outl, unsigned char *in, int inl);
+               int *outl, const unsigned char *in, int inl);
+int    EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
 int    EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
 
-int    EVP_DecryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
-               unsigned char *key, unsigned char *iv);
+int    EVP_DecryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher,
+               const unsigned char *key, const unsigned char *iv);
+int    EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl,
+               const unsigned char *key, const unsigned char *iv);
 int    EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
-               int *outl, unsigned char *in, int inl);
+               int *outl, const unsigned char *in, int inl);
 int    EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
-
-int    EVP_CipherInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
-                      unsigned char *key,unsigned char *iv,int enc);
+int    EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
+
+int    EVP_CipherInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher,
+                      const unsigned char *key,const unsigned char *iv,
+                      int enc);
+int    EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl,
+                      const unsigned char *key,const unsigned char *iv,
+                      int enc);
 int    EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
-               int *outl, unsigned char *in, int inl);
+               int *outl, const unsigned char *in, int inl);
 int    EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
+int    EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
 
 int    EVP_SignFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s,
                EVP_PKEY *pkey);
 
-int    EVP_VerifyFinal(EVP_MD_CTX *ctx,unsigned char *sigbuf,
+int    EVP_VerifyFinal(EVP_MD_CTX *ctx,const unsigned char *sigbuf,
                unsigned int siglen,EVP_PKEY *pkey);
 
-int    EVP_OpenInit(EVP_CIPHER_CTX *ctx,EVP_CIPHER *type,unsigned char *ek,
-               int ekl,unsigned char *iv,EVP_PKEY *priv);
+int    EVP_OpenInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
+               const unsigned char *ek, int ekl, const unsigned char *iv,
+               EVP_PKEY *priv);
 int    EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
 
-int    EVP_SealInit(EVP_CIPHER_CTX *ctx, EVP_CIPHER *type, unsigned char **ek,
-               int *ekl, unsigned char *iv,EVP_PKEY **pubk, int npubk);
-void   EVP_SealFinal(EVP_CIPHER_CTX *ctx,unsigned char *out,int *outl);
+int    EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
+                unsigned char **ek, int *ekl, unsigned char *iv,
+               EVP_PKEY **pubk, int npubk);
+int    EVP_SealFinal(EVP_CIPHER_CTX *ctx,unsigned char *out,int *outl);
 
 void   EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
-void   EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx,unsigned char *out,
-               int *outl,unsigned char *in,int inl);
+void   EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl,
+               const unsigned char *in,int inl);
 void   EVP_EncodeFinal(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl);
 int    EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);
 
 void   EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
 int    EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl,
-               unsigned char *in, int inl);
+               const unsigned char *in, int inl);
 int    EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned
                char *out, int *outl);
 int    EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);
 
-void   ERR_load_EVP_strings(void );
-
 void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a);
 int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *a);
+EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
+void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *a);
 int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
 int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad);
 int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
+int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
 
 #ifndef OPENSSL_NO_BIO
 BIO_METHOD *BIO_f_md(void);
 BIO_METHOD *BIO_f_base64(void);
 BIO_METHOD *BIO_f_cipher(void);
 BIO_METHOD *BIO_f_reliable(void);
-void BIO_set_cipher(BIO *b,const EVP_CIPHER *c,unsigned char *k,
-       unsigned char *i, int enc);
+void BIO_set_cipher(BIO *b,const EVP_CIPHER *c,const unsigned char *k,
+               const unsigned char *i, int enc);
 #endif
 
-EVP_MD *EVP_md_null(void);
+const EVP_MD *EVP_md_null(void);
 #ifndef OPENSSL_NO_MD2
-EVP_MD *EVP_md2(void);
+const EVP_MD *EVP_md2(void);
 #endif
 #ifndef OPENSSL_NO_MD4
-EVP_MD *EVP_md4(void);
+const EVP_MD *EVP_md4(void);
 #endif
 #ifndef OPENSSL_NO_MD5
-EVP_MD *EVP_md5(void);
+const EVP_MD *EVP_md5(void);
 #endif
 #ifndef OPENSSL_NO_SHA
-EVP_MD *EVP_sha(void);
-EVP_MD *EVP_sha1(void);
-EVP_MD *EVP_dss(void);
-EVP_MD *EVP_dss1(void);
+const EVP_MD *EVP_sha(void);
+const EVP_MD *EVP_sha1(void);
+const EVP_MD *EVP_dss(void);
+const EVP_MD *EVP_dss1(void);
+const EVP_MD *EVP_ecdsa(void);
+#endif
+#ifndef OPENSSL_NO_SHA256
+const EVP_MD *EVP_sha224(void);
+const EVP_MD *EVP_sha256(void);
+#endif
+#ifndef OPENSSL_NO_SHA512
+const EVP_MD *EVP_sha384(void);
+const EVP_MD *EVP_sha512(void);
 #endif
 #ifndef OPENSSL_NO_MDC2
-EVP_MD *EVP_mdc2(void);
+const EVP_MD *EVP_mdc2(void);
 #endif
 #ifndef OPENSSL_NO_RIPEMD
-EVP_MD *EVP_ripemd160(void);
+const EVP_MD *EVP_ripemd160(void);
+#endif
+#ifndef OPENSSL_NO_WHIRLPOOL
+const EVP_MD *EVP_whirlpool(void);
 #endif
-EVP_CIPHER *EVP_enc_null(void);                /* does nothing :-) */
+const EVP_CIPHER *EVP_enc_null(void);          /* does nothing :-) */
 #ifndef OPENSSL_NO_DES
-EVP_CIPHER *EVP_des_ecb(void);
-EVP_CIPHER *EVP_des_ede(void);
-EVP_CIPHER *EVP_des_ede3(void);
-EVP_CIPHER *EVP_des_cfb(void);
-EVP_CIPHER *EVP_des_ede_cfb(void);
-EVP_CIPHER *EVP_des_ede3_cfb(void);
-EVP_CIPHER *EVP_des_ofb(void);
-EVP_CIPHER *EVP_des_ede_ofb(void);
-EVP_CIPHER *EVP_des_ede3_ofb(void);
-EVP_CIPHER *EVP_des_cbc(void);
-EVP_CIPHER *EVP_des_ede_cbc(void);
-EVP_CIPHER *EVP_des_ede3_cbc(void);
-EVP_CIPHER *EVP_desx_cbc(void);
+const EVP_CIPHER *EVP_des_ecb(void);
+const EVP_CIPHER *EVP_des_ede(void);
+const EVP_CIPHER *EVP_des_ede3(void);
+const EVP_CIPHER *EVP_des_ede_ecb(void);
+const EVP_CIPHER *EVP_des_ede3_ecb(void);
+const EVP_CIPHER *EVP_des_cfb64(void);
+# define EVP_des_cfb EVP_des_cfb64
+const EVP_CIPHER *EVP_des_cfb1(void);
+const EVP_CIPHER *EVP_des_cfb8(void);
+const EVP_CIPHER *EVP_des_ede_cfb64(void);
+# define EVP_des_ede_cfb EVP_des_ede_cfb64
+#if 0
+const EVP_CIPHER *EVP_des_ede_cfb1(void);
+const EVP_CIPHER *EVP_des_ede_cfb8(void);
+#endif
+const EVP_CIPHER *EVP_des_ede3_cfb64(void);
+# define EVP_des_ede3_cfb EVP_des_ede3_cfb64
+const EVP_CIPHER *EVP_des_ede3_cfb1(void);
+const EVP_CIPHER *EVP_des_ede3_cfb8(void);
+const EVP_CIPHER *EVP_des_ofb(void);
+const EVP_CIPHER *EVP_des_ede_ofb(void);
+const EVP_CIPHER *EVP_des_ede3_ofb(void);
+const EVP_CIPHER *EVP_des_cbc(void);
+const EVP_CIPHER *EVP_des_ede_cbc(void);
+const EVP_CIPHER *EVP_des_ede3_cbc(void);
+const EVP_CIPHER *EVP_desx_cbc(void);
+/* This should now be supported through the dev_crypto ENGINE. But also, why are
+ * rc4 and md5 declarations made here inside a "NO_DES" precompiler branch? */
+#if 0
+# ifdef OPENSSL_OPENBSD_DEV_CRYPTO
+const EVP_CIPHER *EVP_dev_crypto_des_ede3_cbc(void);
+const EVP_CIPHER *EVP_dev_crypto_rc4(void);
+const EVP_MD *EVP_dev_crypto_md5(void);
+# endif
+#endif
 #endif
 #ifndef OPENSSL_NO_RC4
-EVP_CIPHER *EVP_rc4(void);
-EVP_CIPHER *EVP_rc4_40(void);
+const EVP_CIPHER *EVP_rc4(void);
+const EVP_CIPHER *EVP_rc4_40(void);
 #endif
 #ifndef OPENSSL_NO_IDEA
-EVP_CIPHER *EVP_idea_ecb(void);
-EVP_CIPHER *EVP_idea_cfb(void);
-EVP_CIPHER *EVP_idea_ofb(void);
-EVP_CIPHER *EVP_idea_cbc(void);
+const EVP_CIPHER *EVP_idea_ecb(void);
+const EVP_CIPHER *EVP_idea_cfb64(void);
+# define EVP_idea_cfb EVP_idea_cfb64
+const EVP_CIPHER *EVP_idea_ofb(void);
+const EVP_CIPHER *EVP_idea_cbc(void);
 #endif
 #ifndef OPENSSL_NO_RC2
-EVP_CIPHER *EVP_rc2_ecb(void);
-EVP_CIPHER *EVP_rc2_cbc(void);
-EVP_CIPHER *EVP_rc2_40_cbc(void);
-EVP_CIPHER *EVP_rc2_64_cbc(void);
-EVP_CIPHER *EVP_rc2_cfb(void);
-EVP_CIPHER *EVP_rc2_ofb(void);
+const EVP_CIPHER *EVP_rc2_ecb(void);
+const EVP_CIPHER *EVP_rc2_cbc(void);
+const EVP_CIPHER *EVP_rc2_40_cbc(void);
+const EVP_CIPHER *EVP_rc2_64_cbc(void);
+const EVP_CIPHER *EVP_rc2_cfb64(void);
+# define EVP_rc2_cfb EVP_rc2_cfb64
+const EVP_CIPHER *EVP_rc2_ofb(void);
 #endif
 #ifndef OPENSSL_NO_BF
-EVP_CIPHER *EVP_bf_ecb(void);
-EVP_CIPHER *EVP_bf_cbc(void);
-EVP_CIPHER *EVP_bf_cfb(void);
-EVP_CIPHER *EVP_bf_ofb(void);
+const EVP_CIPHER *EVP_bf_ecb(void);
+const EVP_CIPHER *EVP_bf_cbc(void);
+const EVP_CIPHER *EVP_bf_cfb64(void);
+# define EVP_bf_cfb EVP_bf_cfb64
+const EVP_CIPHER *EVP_bf_ofb(void);
 #endif
 #ifndef OPENSSL_NO_CAST
-EVP_CIPHER *EVP_cast5_ecb(void);
-EVP_CIPHER *EVP_cast5_cbc(void);
-EVP_CIPHER *EVP_cast5_cfb(void);
-EVP_CIPHER *EVP_cast5_ofb(void);
+const EVP_CIPHER *EVP_cast5_ecb(void);
+const EVP_CIPHER *EVP_cast5_cbc(void);
+const EVP_CIPHER *EVP_cast5_cfb64(void);
+# define EVP_cast5_cfb EVP_cast5_cfb64
+const EVP_CIPHER *EVP_cast5_ofb(void);
 #endif
 #ifndef OPENSSL_NO_RC5
-EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
-EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
-EVP_CIPHER *EVP_rc5_32_12_16_cfb(void);
-EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);
+const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
+const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
+const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void);
+# define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64
+const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);
 #endif
 #ifndef OPENSSL_NO_AES
-EVP_CIPHER *EVP_aes_128_ecb(void);
-EVP_CIPHER *EVP_aes_128_cbc(void);
-EVP_CIPHER *EVP_aes_192_ecb(void);
-EVP_CIPHER *EVP_aes_192_cbc(void);
-EVP_CIPHER *EVP_aes_256_ecb(void);
-EVP_CIPHER *EVP_aes_256_cbc(void);
+const EVP_CIPHER *EVP_aes_128_ecb(void);
+const EVP_CIPHER *EVP_aes_128_cbc(void);
+const EVP_CIPHER *EVP_aes_128_cfb1(void);
+const EVP_CIPHER *EVP_aes_128_cfb8(void);
+const EVP_CIPHER *EVP_aes_128_cfb128(void);
+# define EVP_aes_128_cfb EVP_aes_128_cfb128
+const EVP_CIPHER *EVP_aes_128_ofb(void);
+#if 0
+const EVP_CIPHER *EVP_aes_128_ctr(void);
+#endif
+const EVP_CIPHER *EVP_aes_192_ecb(void);
+const EVP_CIPHER *EVP_aes_192_cbc(void);
+const EVP_CIPHER *EVP_aes_192_cfb1(void);
+const EVP_CIPHER *EVP_aes_192_cfb8(void);
+const EVP_CIPHER *EVP_aes_192_cfb128(void);
+# define EVP_aes_192_cfb EVP_aes_192_cfb128
+const EVP_CIPHER *EVP_aes_192_ofb(void);
+#if 0
+const EVP_CIPHER *EVP_aes_192_ctr(void);
+#endif
+const EVP_CIPHER *EVP_aes_256_ecb(void);
+const EVP_CIPHER *EVP_aes_256_cbc(void);
+const EVP_CIPHER *EVP_aes_256_cfb1(void);
+const EVP_CIPHER *EVP_aes_256_cfb8(void);
+const EVP_CIPHER *EVP_aes_256_cfb128(void);
+# define EVP_aes_256_cfb EVP_aes_256_cfb128
+const EVP_CIPHER *EVP_aes_256_ofb(void);
+#if 0
+const EVP_CIPHER *EVP_aes_256_ctr(void);
+#endif
+#endif
+
+void OPENSSL_add_all_algorithms_noconf(void);
+void OPENSSL_add_all_algorithms_conf(void);
+
+#ifdef OPENSSL_LOAD_CONF
+#define OpenSSL_add_all_algorithms() \
+               OPENSSL_add_all_algorithms_conf()
+#else
+#define OpenSSL_add_all_algorithms() \
+               OPENSSL_add_all_algorithms_noconf()
 #endif
 
-void OpenSSL_add_all_algorithms(void);
 void OpenSSL_add_all_ciphers(void);
 void OpenSSL_add_all_digests(void);
 #define SSLeay_add_all_algorithms() OpenSSL_add_all_algorithms()
 #define SSLeay_add_all_ciphers() OpenSSL_add_all_ciphers()
 #define SSLeay_add_all_digests() OpenSSL_add_all_digests()
 
-int EVP_add_cipher(EVP_CIPHER *cipher);
-int EVP_add_digest(EVP_MD *digest);
+int EVP_add_cipher(const EVP_CIPHER *cipher);
+int EVP_add_digest(const EVP_MD *digest);
 
 const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
 const EVP_MD *EVP_get_digestbyname(const char *name);
 void EVP_cleanup(void);
 
-int            EVP_PKEY_decrypt(unsigned char *dec_key,unsigned char *enc_key,
-                       int enc_key_len,EVP_PKEY *private_key);
+int            EVP_PKEY_decrypt(unsigned char *dec_key,
+                       const unsigned char *enc_key,int enc_key_len,
+                       EVP_PKEY *private_key);
 int            EVP_PKEY_encrypt(unsigned char *enc_key,
-                       unsigned char *key,int key_len,EVP_PKEY *pub_key);
+                       const unsigned char *key,int key_len,
+                       EVP_PKEY *pub_key);
 int            EVP_PKEY_type(int type);
 int            EVP_PKEY_bits(EVP_PKEY *pkey);
 int            EVP_PKEY_size(EVP_PKEY *pkey);
 int            EVP_PKEY_assign(EVP_PKEY *pkey,int type,char *key);
+
 #ifndef OPENSSL_NO_RSA
-int            EVP_PKEY_set1_RSA(EVP_PKEY *pkey,RSA *key);
-RSA *          EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
+struct rsa_st;
+int EVP_PKEY_set1_RSA(EVP_PKEY *pkey,struct rsa_st *key);
+struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
 #endif
 #ifndef OPENSSL_NO_DSA
-int            EVP_PKEY_set1_DSA(EVP_PKEY *pkey,DSA *key);
-DSA *          EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
+struct dsa_st;
+int EVP_PKEY_set1_DSA(EVP_PKEY *pkey,struct dsa_st *key);
+struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
 #endif
 #ifndef OPENSSL_NO_DH
-int            EVP_PKEY_set1_DH(EVP_PKEY *pkey,DH *key);
-DH *           EVP_PKEY_get1_DH(EVP_PKEY *pkey);
+struct dh_st;
+int EVP_PKEY_set1_DH(EVP_PKEY *pkey,struct dh_st *key);
+struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
+#endif
+#ifndef OPENSSL_NO_EC
+struct ec_key_st;
+int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey,struct ec_key_st *key);
+struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
 #endif
+
 EVP_PKEY *     EVP_PKEY_new(void);
 void           EVP_PKEY_free(EVP_PKEY *pkey);
-EVP_PKEY *     d2i_PublicKey(int type,EVP_PKEY **a, unsigned char **pp,
+
+EVP_PKEY *     d2i_PublicKey(int type,EVP_PKEY **a, const unsigned char **pp,
                        long length);
 int            i2d_PublicKey(EVP_PKEY *a, unsigned char **pp);
 
-EVP_PKEY *     d2i_PrivateKey(int type,EVP_PKEY **a, unsigned char **pp,
+EVP_PKEY *     d2i_PrivateKey(int type,EVP_PKEY **a, const unsigned char **pp,
                        long length);
-EVP_PKEY *     d2i_AutoPrivateKey(EVP_PKEY **a, unsigned char **pp,
+EVP_PKEY *     d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp,
                        long length);
 int            i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp);
 
-int EVP_PKEY_copy_parameters(EVP_PKEY *to,EVP_PKEY *from);
-int EVP_PKEY_missing_parameters(EVP_PKEY *pkey);
+int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
+int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
 int EVP_PKEY_save_parameters(EVP_PKEY *pkey,int mode);
-int EVP_PKEY_cmp_parameters(EVP_PKEY *a,EVP_PKEY *b);
+int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);
+
+int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);
+
+int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
+                               int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
+                               int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
+                               int indent, ASN1_PCTX *pctx);
 
 int EVP_CIPHER_type(const EVP_CIPHER *ctx);
 
@@ -781,49 +838,85 @@ int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c,ASN1_TYPE *type);
 
 /* PKCS5 password based encryption */
 int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-                        ASN1_TYPE *param, EVP_CIPHER *cipher, EVP_MD *md,
+                        ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md,
                         int en_de);
 int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
-                          unsigned char *salt, int saltlen, int iter,
+                          const unsigned char *salt, int saltlen, int iter,
                           int keylen, unsigned char *out);
 int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-                        ASN1_TYPE *param, EVP_CIPHER *cipher, EVP_MD *md,
+                        ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md,
                         int en_de);
 
 void PKCS5_PBE_add(void);
 
 int EVP_PBE_CipherInit (ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
             ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
-int EVP_PBE_alg_add(int nid, EVP_CIPHER *cipher, EVP_MD *md,
+int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
                    EVP_PBE_KEYGEN *keygen);
 void EVP_PBE_cleanup(void);
 
+int EVP_PKEY_asn1_get_count(void);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(int type);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(const char *str, int len);
+int EVP_PKEY_asn1_add(const EVP_PKEY_ASN1_METHOD *ameth);
+EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id,
+                                       const char *pem_str, const char *info);
+void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth);
+void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
+               int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf),
+               int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk),
+               int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent,
+                                                       ASN1_PCTX *pctx));
+void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
+               int (*param_decode)(const EVP_PKEY *pk, X509_PUBKEY *pub),
+               int (*param_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk),
+               int (*param_missing)(const EVP_PKEY *pk),
+               int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from),
+               int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
+               int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent,
+                                                       ASN1_PCTX *pctx));
+void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
+               void (*pkey_free)(EVP_PKEY *pkey));
+void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
+               void (*pkey_ctrl)(EVP_PKEY *pkey, int op,
+                                                       long arg1, void *arg2));
+
 /* BEGIN ERROR CODES */
 /* The following lines are auto generated by the script mkerr.pl. Any changes
  * made after this point may be overwritten when the script is next run.
  */
+void ERR_load_EVP_strings(void);
 
 /* Error codes for the EVP functions. */
 
 /* Function codes. */
+#define EVP_F_AES_INIT_KEY                              133
 #define EVP_F_D2I_PKEY                                  100
-#define EVP_F_EVP_CIPHERINIT                            123
+#define EVP_F_DSAPKEY2PKCS8                             134
+#define EVP_F_DSA_PKEY2PKCS8                            135
+#define EVP_F_ECDSA_PKEY2PKCS8                          129
+#define EVP_F_ECKEY_PKEY2PKCS8                          132
+#define EVP_F_EVP_CIPHERINIT_EX                                 123
 #define EVP_F_EVP_CIPHER_CTX_CTRL                       124
 #define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH             122
-#define EVP_F_EVP_DECRYPTFINAL                          101
-#define EVP_F_EVP_ENCRYPTFINAL                          127
-#define EVP_F_EVP_MD_CTX_COPY                           110
+#define EVP_F_EVP_DECRYPTFINAL_EX                       101
+#define EVP_F_EVP_DIGESTINIT_EX                                 128
+#define EVP_F_EVP_ENCRYPTFINAL_EX                       127
+#define EVP_F_EVP_MD_CTX_COPY_EX                        110
 #define EVP_F_EVP_OPENINIT                              102
 #define EVP_F_EVP_PBE_ALG_ADD                           115
 #define EVP_F_EVP_PBE_CIPHERINIT                        116
 #define EVP_F_EVP_PKCS82PKEY                            111
-#define EVP_F_EVP_PKCS8_SET_BROKEN                      112
-#define EVP_F_EVP_PKEY2PKCS8                            113
+#define EVP_F_EVP_PKCS82PKEY_BROKEN                     136
+#define EVP_F_EVP_PKEY2PKCS8_BROKEN                     113
 #define EVP_F_EVP_PKEY_COPY_PARAMETERS                  103
 #define EVP_F_EVP_PKEY_DECRYPT                          104
 #define EVP_F_EVP_PKEY_ENCRYPT                          105
 #define EVP_F_EVP_PKEY_GET1_DH                          119
 #define EVP_F_EVP_PKEY_GET1_DSA                                 120
+#define EVP_F_EVP_PKEY_GET1_ECDSA                       130
+#define EVP_F_EVP_PKEY_GET1_EC_KEY                      131
 #define EVP_F_EVP_PKEY_GET1_RSA                                 121
 #define EVP_F_EVP_PKEY_NEW                              106
 #define EVP_F_EVP_RIJNDAEL                              126
@@ -831,10 +924,13 @@ void EVP_PBE_cleanup(void);
 #define EVP_F_EVP_VERIFYFINAL                           108
 #define EVP_F_PKCS5_PBE_KEYIVGEN                        117
 #define EVP_F_PKCS5_V2_PBE_KEYIVGEN                     118
+#define EVP_F_PKCS8_SET_BROKEN                          112
 #define EVP_F_RC2_MAGIC_TO_METH                                 109
 #define EVP_F_RC5_CTRL                                  125
 
 /* Reason codes. */
+#define EVP_R_AES_KEY_SETUP_FAILED                      143
+#define EVP_R_ASN1_LIB                                  140
 #define EVP_R_BAD_BLOCK_LENGTH                          136
 #define EVP_R_BAD_DECRYPT                               100
 #define EVP_R_BAD_KEY_LENGTH                            137
@@ -851,17 +947,23 @@ void EVP_PBE_cleanup(void);
 #define EVP_R_EXPECTING_AN_RSA_KEY                      127
 #define EVP_R_EXPECTING_A_DH_KEY                        128
 #define EVP_R_EXPECTING_A_DSA_KEY                       129
+#define EVP_R_EXPECTING_A_ECDSA_KEY                     141
+#define EVP_R_EXPECTING_A_EC_KEY                        142
 #define EVP_R_INITIALIZATION_ERROR                      134
 #define EVP_R_INPUT_NOT_INITIALIZED                     111
 #define EVP_R_INVALID_KEY_LENGTH                        130
 #define EVP_R_IV_TOO_LARGE                              102
 #define EVP_R_KEYGEN_FAILURE                            120
+#define EVP_R_METHOD_NOT_SUPPORTED                      144
 #define EVP_R_MISSING_PARAMETERS                        103
 #define EVP_R_NO_CIPHER_SET                             131
+#define EVP_R_NO_DIGEST_SET                             139
 #define EVP_R_NO_DSA_PARAMETERS                                 116
 #define EVP_R_NO_SIGN_FUNCTION_CONFIGURED               104
 #define EVP_R_NO_VERIFY_FUNCTION_CONFIGURED             105
 #define EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE                         117
+#define EVP_R_PRIVATE_KEY_DECODE_ERROR                  145
+#define EVP_R_PRIVATE_KEY_ENCODE_ERROR                  146
 #define EVP_R_PUBLIC_KEY_NOT_RSA                        106
 #define EVP_R_UNKNOWN_PBE_ALGORITHM                     121
 #define EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS               135
@@ -879,4 +981,3 @@ void EVP_PBE_cleanup(void);
 }
 #endif
 #endif
-