Add prototypes, update Win32 ordinals.

[openssl.git] / crypto / evp / evp.h

diff --git a/crypto/evp/evp.h b/crypto/evp/evp.h
index 2622b53bab61074c8125a79702d90787a61ff992..417842391033fade78feecb19f0935abf7441ef2 100644 (file)
--- a/crypto/evp/evp.h
+++ b/crypto/evp/evp.h
@@ -176,6 +176,8 @@ struct env_md_st
        int required_pkey_type[5]; /*EVP_PKEY_xxx */
        int block_size;
        int ctx_size; /* how big does the ctx->md_data need to be */
+       /* control function */
+       int (*md_ctrl)(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
        } /* EVP_MD */;
 
 typedef int evp_sign_method(int type,const unsigned char *m,
@@ -197,6 +199,30 @@ typedef int evp_verify_method(int type,const unsigned char *m,
 
 #define EVP_MD_FLAG_PKEY_METHOD_SIGNATURE      0x0004
 
+/* DigestAlgorithmIdentifier flags... */
+
+#define EVP_MD_FLAG_DIGALGID_MASK              0x0018
+
+/* NULL or absent parameter accepted. Use NULL */
+
+#define EVP_MD_FLAG_DIGALGID_NULL              0x0000
+
+/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */
+
+#define EVP_MD_FLAG_DIGALGID_ABSENT            0x0008
+
+/* Custom handling via ctrl */
+
+#define EVP_MD_FLAG_DIGALGID_CUSTOM            0x0018
+
+/* Digest ctrls */
+
+#define        EVP_MD_CTRL_DIGALGID                    0x1
+
+/* Minimum Algorithm specific ctrl value */
+
+#define        EVP_MD_CTRL_ALG_CTRL                    0x1000
+
 #define EVP_PKEY_NULL_method   NULL,NULL,{0,0,0,0}
 
 #ifndef OPENSSL_NO_DSA
@@ -237,6 +263,8 @@ struct env_md_ctx_st
        ENGINE *engine; /* functional reference if 'digest' is ENGINE-provided */
        unsigned long flags;
        void *md_data;
+       /* Public key context for sign/verify */
+       EVP_PKEY_CTX *pctx;
        } /* EVP_MD_CTX */;
 
 /* values for EVP_MD_CTX flags */
@@ -248,6 +276,14 @@ struct env_md_ctx_st
 #define EVP_MD_CTX_FLAG_REUSE          0x0004 /* Don't free up ctx->md_data
                                                * in EVP_MD_CTX_cleanup */
 
+/* MD operational flags */
+
+#define EVP_MD_CTX_FLAG_OP_MASK                0x00f0
+
+#define EVP_MD_CTX_FLAG_OP_DIGEST      0x0000
+#define EVP_MD_CTX_FLAG_OP_SIGN                0x0010
+#define EVP_MD_CTX_FLAG_OP_VERIFY      0x0020
+
 struct evp_cipher_st
        {
        int nid;
@@ -416,6 +452,8 @@ typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 #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)
 #define EVP_SealUpdate(a,b,c,d,e)      EVP_EncryptUpdate(a,b,c,d,e)    
+#define EVP_SignDigestUpdate(a,b,c)    EVP_DigestUpdate(a,b,c)
+#define EVP_VerifyDigestUpdate(a,b,c)  EVP_DigestUpdate(a,b,c)
 
 #ifdef CONST_STRICT
 void BIO_set_md(BIO *,const EVP_MD *md);
@@ -500,6 +538,16 @@ int        EVP_SignFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s,
 int    EVP_VerifyFinal(EVP_MD_CTX *ctx,const unsigned char *sigbuf,
                unsigned int siglen,EVP_PKEY *pkey);
 
+int    EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                       const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey);
+int    EVP_DigestSignFinal(EVP_MD_CTX *ctx,
+                       unsigned char *sigret, size_t *siglen);
+
+int    EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                       const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey);
+int    EVP_DigestVerifyFinal(EVP_MD_CTX *ctx,
+                       unsigned char *sig, size_t siglen);
+
 int    EVP_OpenInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
                const unsigned char *ek, int ekl, const unsigned char *iv,
                EVP_PKEY *priv);
@@ -908,10 +956,12 @@ void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
 
 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type, ENGINE *e);
 EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags);
+void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
 
 EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
 EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
+EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx);
 void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
 
 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
@@ -928,28 +978,28 @@ void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);
 
 int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
-                       unsigned char *sig, int *siglen,
-                       const unsigned char *tbs, int tbslen);
+                       unsigned char *sig, size_t *siglen,
+                       const unsigned char *tbs, size_t tbslen);
 int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
-                       const unsigned char *sig, int siglen,
-                       const unsigned char *tbs, int tbslen);
+                       const unsigned char *sig, size_t siglen,
+                       const unsigned char *tbs, size_t tbslen);
 int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
-                       unsigned char *rout, int *routlen,
-                       const unsigned char *sig, int siglen);
+                       unsigned char *rout, size_t *routlen,
+                       const unsigned char *sig, size_t siglen);
 int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
-                       unsigned char *out, int *outlen,
-                       const unsigned char *in, int inlen);
+                       unsigned char *out, size_t *outlen,
+                       const unsigned char *in, size_t inlen);
 int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
-                       unsigned char *out, int *outlen,
-                       const unsigned char *in, int inlen);
+                       unsigned char *out, size_t *outlen,
+                       const unsigned char *in, size_t inlen);
 
 int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
-int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, int *keylen);
+int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
 
 typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
 
@@ -964,6 +1014,9 @@ int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);
 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
        int (*init)(EVP_PKEY_CTX *ctx));
 
+void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
+       int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src));
+
 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
        void (*cleanup)(EVP_PKEY_CTX *ctx));
 
@@ -977,23 +1030,23 @@ void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
 
 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
        int (*sign_init)(EVP_PKEY_CTX *ctx),
-       int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, int *siglen,
-                                       const unsigned char *tbs, int tbslen));
+       int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                                       const unsigned char *tbs, size_t tbslen));
 
 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
        int (*verify_init)(EVP_PKEY_CTX *ctx),
-       int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
-                                       const unsigned char *tbs, int tbslen));
+       int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
+                                       const unsigned char *tbs, size_t tbslen));
 
 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
        int (*verify_recover_init)(EVP_PKEY_CTX *ctx),
        int (*verify_recover)(EVP_PKEY_CTX *ctx,
-                                       unsigned char *sig, int *siglen,
-                                       const unsigned char *tbs, int tbslen));
+                                       unsigned char *sig, size_t *siglen,
+                                       const unsigned char *tbs, size_t tbslen));
 
 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
        int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
-       int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, int *siglen,
+       int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
                                        EVP_MD_CTX *mctx));
 
 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
@@ -1003,17 +1056,17 @@ void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
 
 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
        int (*encrypt_init)(EVP_PKEY_CTX *ctx),
-       int (*encrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, int *outlen,
-                                       const unsigned char *in, int inlen));
+       int (*encrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                                       const unsigned char *in, size_t inlen));
 
 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
        int (*decrypt_init)(EVP_PKEY_CTX *ctx),
-       int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, int *outlen,
-                                       const unsigned char *in, int inlen));
+       int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                                       const unsigned char *in, size_t inlen));
 
 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
        int (*derive_init)(EVP_PKEY_CTX *ctx),
-       int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, int *keylen));
+       int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
 
 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
        int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2),