Make MD functions take EVP_MD_CTX * instead of void *, add copy() function.

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

diff --git a/crypto/evp/digest.c b/crypto/evp/digest.c
index 035218d4314d2f044cc9fc0301d07231f4447608..c81f6e6cf8e8410b2b7567453f9073e7d3a5fbaf 100644 (file)
--- a/crypto/evp/digest.c
+++ b/crypto/evp/digest.c
@@ -1,5 +1,5 @@
 /* crypto/evp/digest.c */
-/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
@@ -58,32 +58,119 @@
 
 #include <stdio.h>
 #include "cryptlib.h"
-#include "objects.h"
-#include "evp.h"
+#include <openssl/objects.h>
+#include <openssl/evp.h>
 
-void EVP_DigestInit(ctx,type)
-EVP_MD_CTX *ctx;
-EVP_MD *type;
+void EVP_MD_CTX_init(EVP_MD_CTX *ctx)
        {
-       ctx->digest=type;
-       type->init(&(ctx->md));
+       memset(ctx,'\0',sizeof *ctx);
        }
 
-void EVP_DigestUpdate(ctx,data,count)
-EVP_MD_CTX *ctx;
-unsigned char *data;
-unsigned int count;
+EVP_MD_CTX *EVP_MD_CTX_create(void)
        {
-       ctx->digest->update(&(ctx->md.base[0]),data,(unsigned long)count);
+       EVP_MD_CTX *ctx=OPENSSL_malloc(sizeof *ctx);
+
+       EVP_MD_CTX_init(ctx);
+
+       return ctx;
        }
 
-void EVP_DigestFinal(ctx,md,size)
-EVP_MD_CTX *ctx;
-unsigned char *md;
-unsigned int *size;
+#ifdef CRYPTO_MDEBUG
+int EVP_DigestInit_dbg(EVP_MD_CTX *ctx, const EVP_MD *type,const char *file,
+                      int line)
+#else
+int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
+#endif
        {
-       ctx->digest->final(md,&(ctx->md.base[0]));
+       if(ctx->digest != type)
+               {
+               if(ctx->digest && ctx->digest->ctx_size)
+                       OPENSSL_free(ctx->md_data);
+               ctx->digest=type;
+               if(type->ctx_size)
+#ifdef CRYPTO_MDEBUG
+                       ctx->md_data=CRYPTO_malloc(type->ctx_size,file,line);
+#else
+                       ctx->md_data=OPENSSL_malloc(type->ctx_size);
+#endif
+               }
+       return type->init(ctx);
+       }
+
+int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data,
+            unsigned int count)
+       {
+       return ctx->digest->update(ctx,data,(unsigned long)count);
+       }
+
+/* The caller can assume that this removes any secret data from the context */
+int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
+       {
+       int ret;
+       ret=ctx->digest->final(ctx,md);
        if (size != NULL)
                *size=ctx->digest->md_size;
-       memset(&(ctx->md),0,sizeof(ctx->md));
+       /* FIXME: add a cleanup function to the ctx? */
+       memset(ctx->md_data,0,ctx->digest->ctx_size);
+       return ret;
+       }
+
+int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
+{
+    if ((in == NULL) || (in->digest == NULL)) {
+        EVPerr(EVP_F_EVP_MD_CTX_COPY,EVP_R_INPUT_NOT_INITIALIZED);
+       return 0;
+    }
+
+    EVP_MD_CTX_cleanup(out);
+    memcpy(out,in,sizeof *out);
+
+    if(out->digest->ctx_size)
+       {
+       out->md_data=OPENSSL_malloc(out->digest->ctx_size);
+       memcpy(out->md_data,in->md_data,out->digest->ctx_size);
+       }
+
+    if(out->digest->copy)
+       return out->digest->copy(out,in);
+
+    return 1;
+}
+
+int EVP_Digest(void *data, unsigned int count,
+               unsigned char *md, unsigned int *size, const EVP_MD *type)
+{
+       EVP_MD_CTX ctx;
+       int ret;
+
+       EVP_MD_CTX_init(&ctx);
+       EVP_MD_CTX_set_flags(&ctx,EVP_MD_CTX_FLAG_ONESHOT);
+       ret=EVP_DigestInit(&ctx, type)
+         && EVP_DigestUpdate(&ctx, data, count)
+         && EVP_DigestFinal(&ctx, md, size);
+       EVP_MD_CTX_cleanup(&ctx);
+
+       return ret;
+}
+
+void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
+       {
+       EVP_MD_CTX_cleanup(ctx);
+       OPENSSL_free(ctx);
+       }
+
+/* This call frees resources associated with the context */
+int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
+       {
+       /* Don't assume ctx->md_data was cleaned in EVP_Digest_Final,
+        * because sometimes only copies of the context are ever finalised.
+        */
+       if(ctx->digest && ctx->digest->ctx_size && ctx->md_data)
+               {
+               memset(ctx->md_data,0,ctx->digest->ctx_size);
+               OPENSSL_free(ctx->md_data);
+               }
+       memset(ctx,'\0',sizeof *ctx);
+
+       return 1;
        }