1 files changed, 76 insertions, 19 deletions

diff --git a/src/microhttpd/test_md5.c b/src/microhttpd/test_md5.c
index 13f9d46e..e6addab3 100644
--- a/src/microhttpd/test_md5.c
+++ b/src/microhttpd/test_md5.c
@@ -24,11 +24,16 @@
  */
 
 #include "mhd_options.h"
-#include "md5.h"
+#include "mhd_md5_wrap.h"
 #include "test_helpers.h"
 #include <stdio.h>
 #include <stdlib.h>
 
+#if defined(MHD_MD5_TLSLIB) && defined(MHD_HTTPS_REQUIRE_GCRYPT)
+#define NEED_GCRYP_INIT 1
+#include <gcrypt.h>
+#endif /* MHD_MD5_TLSLIB && MHD_HTTPS_REQUIRE_GCRYPT */
+
 static int verbose = 0; /* verbose level (0-1)*/
 
 
@@ -293,9 +298,9 @@ check_result (const char *test_name,
   {
     char calc_str[MD5_DIGEST_STRING_SIZE];
     bin2hex (calculated, MD5_DIGEST_SIZE, calc_str);
-    printf (
-      "PASSED: %s check %u: calculated digest %s match expected digest.\n",
-      test_name, check_num, calc_str);
+    printf ("PASSED: %s check %u: calculated digest %s "
+            "matches expected digest.\n",
+            test_name, check_num, calc_str);
     fflush (stdout);
   }
   return failed ? 1 : 0;
@@ -312,19 +317,28 @@ test1_str (void)
 {
   unsigned int i;
   int num_failed = 0;
-  struct Md5Ctx ctx;
+  struct Md5CtxWr ctx;
+
+  MHD_MD5_init_one_time (&ctx);
 
   for (i = 0; i < units1_num; i++)
   {
     uint8_t digest[MD5_DIGEST_SIZE];
 
-    MHD_MD5_init (&ctx);
     MHD_MD5_update (&ctx, (const uint8_t *) data_units1[i].str_l.str,
                     data_units1[i].str_l.len);
-    MHD_MD5_finish (&ctx, digest);
+    MHD_MD5_finish_reset (&ctx, digest);
+#ifdef MHD_MD5_HAS_EXT_ERROR
+    if (0 != ctx.ext_error)
+    {
+      fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error);
+      exit (99);
+    }
+#endif
     num_failed += check_result (__FUNCTION__, i, digest,
                                 data_units1[i].digest);
   }
+  MHD_MD5_deinit (&ctx);
   return num_failed;
 }
 
@@ -334,18 +348,27 @@ test1_bin (void)
 {
   unsigned int i;
   int num_failed = 0;
-  struct Md5Ctx ctx;
+  struct Md5CtxWr ctx;
+
+  MHD_MD5_init_one_time (&ctx);
 
   for (i = 0; i < units2_num; i++)
   {
     uint8_t digest[MD5_DIGEST_SIZE];
 
-    MHD_MD5_init (&ctx);
     MHD_MD5_update (&ctx, data_units2[i].bin_l.bin, data_units2[i].bin_l.len);
-    MHD_MD5_finish (&ctx, digest);
+    MHD_MD5_finish_reset (&ctx, digest);
+#ifdef MHD_MD5_HAS_EXT_ERROR
+    if (0 != ctx.ext_error)
+    {
+      fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error);
+      exit (99);
+    }
+#endif
     num_failed += check_result (__FUNCTION__, i, digest,
                                 data_units2[i].digest);
   }
+  MHD_MD5_deinit (&ctx);
   return num_failed;
 }
 
@@ -356,24 +379,33 @@ test2_str (void)
 {
   unsigned int i;
   int num_failed = 0;
-  struct Md5Ctx ctx;
+  struct Md5CtxWr ctx;
+
+  MHD_MD5_init_one_time (&ctx);
 
   for (i = 0; i < units1_num; i++)
   {
     uint8_t digest[MD5_DIGEST_SIZE];
     size_t part_s = data_units1[i].str_l.len / 4;
 
-    MHD_MD5_init (&ctx);
     MHD_MD5_update (&ctx, (const uint8_t *) "", 0);
     MHD_MD5_update (&ctx, (const uint8_t *) data_units1[i].str_l.str, part_s);
     MHD_MD5_update (&ctx, (const uint8_t *) "", 0);
     MHD_MD5_update (&ctx, (const uint8_t *) data_units1[i].str_l.str + part_s,
                     data_units1[i].str_l.len - part_s);
     MHD_MD5_update (&ctx, (const uint8_t *) "", 0);
-    MHD_MD5_finish (&ctx, digest);
+    MHD_MD5_finish_reset (&ctx, digest);
+#ifdef MHD_MD5_HAS_EXT_ERROR
+    if (0 != ctx.ext_error)
+    {
+      fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error);
+      exit (99);
+    }
+#endif
     num_failed += check_result (__FUNCTION__, i, digest,
                                 data_units1[i].digest);
   }
+  MHD_MD5_deinit (&ctx);
   return num_failed;
 }
 
@@ -383,22 +415,31 @@ test2_bin (void)
 {
   unsigned int i;
   int num_failed = 0;
-  struct Md5Ctx ctx;
+  struct Md5CtxWr ctx;
+
+  MHD_MD5_init_one_time (&ctx);
 
   for (i = 0; i < units2_num; i++)
   {
     uint8_t digest[MD5_DIGEST_SIZE];
     size_t part_s = data_units2[i].bin_l.len * 2 / 3;
 
-    MHD_MD5_init (&ctx);
     MHD_MD5_update (&ctx, data_units2[i].bin_l.bin, part_s);
     MHD_MD5_update (&ctx, (const uint8_t *) "", 0);
     MHD_MD5_update (&ctx, data_units2[i].bin_l.bin + part_s,
                     data_units2[i].bin_l.len - part_s);
-    MHD_MD5_finish (&ctx, digest);
+    MHD_MD5_finish_reset (&ctx, digest);
+#ifdef MHD_MD5_HAS_EXT_ERROR
+    if (0 != ctx.ext_error)
+    {
+      fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error);
+      exit (99);
+    }
+#endif
     num_failed += check_result (__FUNCTION__, i, digest,
                                 data_units2[i].digest);
   }
+  MHD_MD5_deinit (&ctx);
   return num_failed;
 }
 
@@ -414,7 +455,7 @@ test_unaligned (void)
   unsigned int offset;
   uint8_t *buf;
   uint8_t *digest_buf;
-  struct Md5Ctx ctx;
+  struct Md5CtxWr ctx;
 
   const struct data_unit2 *const tdata = data_units2 + DATA_POS;
 
@@ -423,6 +464,8 @@ test_unaligned (void)
   if ((NULL == buf) || (NULL == digest_buf))
     exit (99);
 
+  MHD_MD5_init_one_time (&ctx);
+
   for (offset = MAX_OFFSET; offset >= 1; --offset)
   {
     uint8_t *unaligned_digest;
@@ -433,12 +476,19 @@ test_unaligned (void)
     unaligned_digest = digest_buf + MAX_OFFSET - offset;
     memset (unaligned_digest, 0, MD5_DIGEST_SIZE);
 
-    MHD_MD5_init (&ctx);
     MHD_MD5_update (&ctx, unaligned_buf, tdata->bin_l.len);
-    MHD_MD5_finish (&ctx, unaligned_digest);
+    MHD_MD5_finish_reset (&ctx, unaligned_digest);
+#ifdef MHD_MD5_HAS_EXT_ERROR
+    if (0 != ctx.ext_error)
+    {
+      fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error);
+      exit (99);
+    }
+#endif
     num_failed += check_result (__FUNCTION__, MAX_OFFSET - offset,
                                 unaligned_digest, tdata->digest);
   }
+  MHD_MD5_deinit (&ctx);
   free (digest_buf);
   free (buf);
   return num_failed;
@@ -453,6 +503,13 @@ main (int argc, char *argv[])
   if (has_param (argc, argv, "-v") || has_param (argc, argv, "--verbose"))
     verbose = 1;
 
+#ifdef NEED_GCRYP_INIT
+  gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+#ifdef GCRYCTL_INITIALIZATION_FINISHED
+  gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+#endif /* GCRYCTL_INITIALIZATION_FINISHED */
+#endif /* NEED_GCRYP_INIT */
+
   num_failed += test1_str ();
   num_failed += test1_bin ();