Allow digests to supply S/MIME micalg values from a ctrl.

[openssl.git] / crypto / evp / digest.c

diff --git a/crypto/evp/digest.c b/crypto/evp/digest.c
index a969ac69edb6ac98e7f35425c18aaf82189ef265..256efd6e9ddda7ca1f6548ea1121f439b50ca4e6 100644 (file)
--- a/crypto/evp/digest.c
+++ b/crypto/evp/digest.c
@@ -113,7 +113,9 @@
 #include "cryptlib.h"
 #include <openssl/objects.h>
 #include <openssl/evp.h>
+#ifndef OPENSSL_NO_ENGINE
 #include <openssl/engine.h>
+#endif
 
 void EVP_MD_CTX_init(EVP_MD_CTX *ctx)
        {
@@ -138,6 +140,7 @@ int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
 int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
        {
        EVP_MD_CTX_clear_flags(ctx,EVP_MD_CTX_FLAG_CLEANED);
+#ifndef OPENSSL_NO_ENGINE
        /* Whether it's nice or not, "Inits" can be used on "Final"'d contexts
         * so this context may already have an ENGINE! Try to avoid releasing
         * the previous handle, re-querying for an ENGINE, and having a
@@ -156,7 +159,7 @@ int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                        {
                        if (!ENGINE_init(impl))
                                {
-                               EVPerr(EVP_F_EVP_DIGESTINIT, EVP_R_INITIALIZATION_ERROR);
+                               EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_INITIALIZATION_ERROR);
                                return 0;
                                }
                        }
@@ -170,7 +173,7 @@ int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                        if(!d)
                                {
                                /* Same comment from evp_enc.c */
-                               EVPerr(EVP_F_EVP_DIGESTINIT, EVP_R_INITIALIZATION_ERROR);
+                               EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_INITIALIZATION_ERROR);
                                return 0;
                                }
                        /* We'll use the ENGINE's private digest definition */
@@ -183,11 +186,13 @@ int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                else
                        ctx->engine = NULL;
                }
-       else if(!ctx->digest)
+       else
+       if(!ctx->digest)
                {
-               EVPerr(EVP_F_EVP_DIGESTINIT, EVP_R_NO_DIGEST_SET);
+               EVPerr(EVP_F_EVP_DIGESTINIT_EX,EVP_R_NO_DIGEST_SET);
                return 0;
                }
+#endif
        if (ctx->digest != type)
                {
                if (ctx->digest && ctx->digest->ctx_size)
@@ -196,14 +201,16 @@ int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
                if (type->ctx_size)
                        ctx->md_data=OPENSSL_malloc(type->ctx_size);
                }
+#ifndef OPENSSL_NO_ENGINE
 skip_to_init:
+#endif
        return ctx->digest->init(ctx);
        }
 
 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data,
-            unsigned int count)
+            size_t count)
        {
-       return ctx->digest->update(ctx,data,(unsigned long)count);
+       return ctx->digest->update(ctx,data,count);
        }
 
 /* The caller can assume that this removes any secret data from the context */
@@ -219,6 +226,8 @@ int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
 int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
        {
        int ret;
+
+       OPENSSL_assert(ctx->digest->md_size <= EVP_MAX_MD_SIZE);
        ret=ctx->digest->final(ctx,md);
        if (size != NULL)
                *size=ctx->digest->md_size;
@@ -239,34 +248,54 @@ int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
 
 int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
        {
+       unsigned char *tmp_buf;
        if ((in == NULL) || (in->digest == NULL))
                {
-               EVPerr(EVP_F_EVP_MD_CTX_COPY,EVP_R_INPUT_NOT_INITIALIZED);
+               EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,EVP_R_INPUT_NOT_INITIALIZED);
                return 0;
                }
+#ifndef OPENSSL_NO_ENGINE
        /* Make sure it's safe to copy a digest context using an ENGINE */
        if (in->engine && !ENGINE_init(in->engine))
                {
-               EVPerr(EVP_F_EVP_MD_CTX_COPY,ERR_R_ENGINE_LIB);
+               EVPerr(EVP_F_EVP_MD_CTX_COPY_EX,ERR_R_ENGINE_LIB);
                return 0;
                }
+#endif
 
+       if (out->digest == in->digest)
+               {
+               tmp_buf = out->md_data;
+               EVP_MD_CTX_set_flags(out,EVP_MD_CTX_FLAG_REUSE);
+               }
+       else tmp_buf = NULL;
        EVP_MD_CTX_cleanup(out);
        memcpy(out,in,sizeof *out);
 
        if (out->digest->ctx_size)
                {
-               out->md_data=OPENSSL_malloc(out->digest->ctx_size);
+               if (tmp_buf) out->md_data = tmp_buf;
+               else out->md_data=OPENSSL_malloc(out->digest->ctx_size);
                memcpy(out->md_data,in->md_data,out->digest->ctx_size);
                }
-       
+
+       if (in->pctx)
+               {
+               out->pctx = EVP_PKEY_CTX_dup(in->pctx);
+               if (!out->pctx)
+                       {
+                       EVP_MD_CTX_cleanup(out);
+                       return 0;
+                       }
+               }
+
        if (out->digest->copy)
                return out->digest->copy(out,in);
        
        return 1;
        }
 
-int EVP_Digest(void *data, unsigned int count,
+int EVP_Digest(const void *data, size_t count,
                unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl)
        {
        EVP_MD_CTX ctx;
@@ -297,15 +326,20 @@ int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
        if (ctx->digest && ctx->digest->cleanup
            && !EVP_MD_CTX_test_flags(ctx,EVP_MD_CTX_FLAG_CLEANED))
                ctx->digest->cleanup(ctx);
-       if (ctx->digest && ctx->digest->ctx_size && ctx->md_data)
+       if (ctx->digest && ctx->digest->ctx_size && ctx->md_data
+           && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE))
                {
-               memset(ctx->md_data,0,ctx->digest->ctx_size);
+               OPENSSL_cleanse(ctx->md_data,ctx->digest->ctx_size);
                OPENSSL_free(ctx->md_data);
                }
+       if (ctx->pctx)
+               EVP_PKEY_CTX_free(ctx->pctx);
+#ifndef OPENSSL_NO_ENGINE
        if(ctx->engine)
                /* The EVP_MD we used belongs to an ENGINE, release the
                 * functional reference we held for this reason. */
                ENGINE_finish(ctx->engine);
+#endif
        memset(ctx,'\0',sizeof *ctx);
 
        return 1;