Android build fixes.

[openssl.git] / crypto / hmac / hmac.c

diff --git a/crypto/hmac/hmac.c b/crypto/hmac/hmac.c
index 9b29861ddc3b96cc4182565100923b934c907f29..9504aada943bd337f7fef851c5de82f7325f2626 100644 (file)
--- a/crypto/hmac/hmac.c
+++ b/crypto/hmac/hmac.c
@@ -1,4 +1,3 @@
-/* crypto/hmac/hmac.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -61,6 +60,7 @@
 #include <string.h>
 #include "internal/cryptlib.h"
 #include <openssl/hmac.h>
+#include <openssl/opensslconf.h>
 #include "hmac_lcl.h"
 
 int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
@@ -127,11 +127,11 @@ int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
     return 0;
 }
 
-#ifndef OPENSSL_NO_DEPRECATED
+#if OPENSSL_API_COMPAT < 0x10100000L
 int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md)
 {
     if (key && md)
-        HMAC_CTX_init(ctx);
+        HMAC_CTX_reset(ctx);
     return HMAC_Init_ex(ctx, key, len, md, NULL);
 }
 #endif
@@ -171,53 +171,63 @@ size_t HMAC_size(HMAC_CTX *ctx)
 
 HMAC_CTX *HMAC_CTX_new(void)
 {
-    HMAC_CTX *ctx = (HMAC_CTX *)OPENSSL_zalloc(sizeof(HMAC_CTX));
-    if (ctx)
-        if (!HMAC_CTX_init(ctx)) {
+    HMAC_CTX *ctx = OPENSSL_zalloc(sizeof(HMAC_CTX));
+
+    if (ctx != NULL) {
+        if (!HMAC_CTX_reset(ctx)) {
             HMAC_CTX_free(ctx);
-            ctx = NULL;
+            return NULL;
         }
+    }
     return ctx;
 }
 
+static void hmac_ctx_cleanup(HMAC_CTX *ctx)
+{
+    EVP_MD_CTX_reset(ctx->i_ctx);
+    EVP_MD_CTX_reset(ctx->o_ctx);
+    EVP_MD_CTX_reset(ctx->md_ctx);
+    ctx->md = NULL;
+    ctx->key_length = 0;
+    memset(ctx->key, 0, sizeof(HMAC_MAX_MD_CBLOCK));
+}
+
 void HMAC_CTX_free(HMAC_CTX *ctx)
 {
     if (ctx != NULL) {
-        HMAC_CTX_cleanup(ctx);
+        hmac_ctx_cleanup(ctx);
+        EVP_MD_CTX_free(ctx->i_ctx);
+        EVP_MD_CTX_free(ctx->o_ctx);
+        EVP_MD_CTX_free(ctx->md_ctx);
         OPENSSL_free(ctx);
     }
 }
 
-int HMAC_CTX_init(HMAC_CTX *ctx)
+int HMAC_CTX_reset(HMAC_CTX *ctx)
 {
+    hmac_ctx_cleanup(ctx);
     if (ctx->i_ctx == NULL)
-        ctx->i_ctx = EVP_MD_CTX_create();
-    else
-        EVP_MD_CTX_init(ctx->i_ctx);
+        ctx->i_ctx = EVP_MD_CTX_new();
     if (ctx->i_ctx == NULL)
         goto err;
     if (ctx->o_ctx == NULL)
-        ctx->o_ctx = EVP_MD_CTX_create();
-    else
-        EVP_MD_CTX_init(ctx->o_ctx);
+        ctx->o_ctx = EVP_MD_CTX_new();
     if (ctx->o_ctx == NULL)
         goto err;
     if (ctx->md_ctx == NULL)
-        ctx->md_ctx = EVP_MD_CTX_create();
-    else
-        EVP_MD_CTX_init(ctx->md_ctx);
+        ctx->md_ctx = EVP_MD_CTX_new();
     if (ctx->md_ctx == NULL)
         goto err;
     ctx->md = NULL;
     return 1;
  err:
-    HMAC_CTX_cleanup(ctx);
+    hmac_ctx_cleanup(ctx);
     return 0;
 }
 
 int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
 {
-    if (!HMAC_CTX_init(dctx))
+    if (!HMAC_CTX_reset(dctx))
         goto err;
     if (!EVP_MD_CTX_copy_ex(dctx->i_ctx, sctx->i_ctx))
         goto err;
@@ -230,29 +240,28 @@ int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
     dctx->md = sctx->md;
     return 1;
  err:
-    HMAC_CTX_cleanup(dctx);
+    hmac_ctx_cleanup(dctx);
     return 0;
 }
 
-void HMAC_CTX_cleanup(HMAC_CTX *ctx)
-{
-    EVP_MD_CTX_destroy(ctx->i_ctx);
-    EVP_MD_CTX_destroy(ctx->o_ctx);
-    EVP_MD_CTX_destroy(ctx->md_ctx);
-    memset(ctx, 0, sizeof(*ctx));
-}
-
 unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
                     const unsigned char *d, size_t n, unsigned char *md,
                     unsigned int *md_len)
 {
     HMAC_CTX *c = NULL;
     static unsigned char m[EVP_MAX_MD_SIZE];
+    static const unsigned char dummy_key[1] = {'\0'};
 
     if (md == NULL)
         md = m;
     if ((c = HMAC_CTX_new()) == NULL)
         goto err;
+
+    /* For HMAC_Init_ex, NULL key signals reuse. */
+    if (key == NULL && key_len == 0) {
+        key = dummy_key;
+    }
+
     if (!HMAC_Init_ex(c, key, key_len, evp_md, NULL))
         goto err;
     if (!HMAC_Update(c, d, n))