Merged the two internal hash API functions, to simplify and reduce code.

gnutls_hmac* and gnutls_hash* were merged to gnutls_hash API.

1 files changed, 78 insertions, 190 deletions

diff --git a/lib/gnutls_hash_int.c b/lib/gnutls_hash_int.c
index 7f3b322049..1c79e3aaaf 100644
--- a/lib/gnutls_hash_int.c
+++ b/lib/gnutls_hash_int.c
@@ -57,45 +57,8 @@ digest_length (gnutls_digest_algorithm_t algo)
     }
 }
 
-int
-_gnutls_hash_init (digest_hd_st * dig, gnutls_digest_algorithm_t algorithm)
-{
-  int result;
-  gnutls_crypto_single_digest_st *cc = NULL;
-
-  dig->algorithm = algorithm;
-
-  /* check if a digest has been registered 
-   */
-  cc = _gnutls_get_crypto_digest (algorithm);
-  if (cc != NULL)
-    {
-      dig->registered = 1;
-      dig->hd.rh.cc = cc;
-      if (cc->init (algorithm, &dig->hd.rh.ctx) < 0)
-	{
-	  gnutls_assert ();
-	  return GNUTLS_E_HASH_FAILED;
-	}
-      dig->active = 1;
-      return 0;
-    }
-
-  dig->registered = 0;
-
-  result = _gnutls_digest_ops.init (algorithm, &dig->hd.gc);
-  if (result < 0)
-    {
-      gnutls_assert ();
-      return result;
-    }
-
-  dig->active = 1;
-  return 0;
-}
+/* HMAC interface */
 
-/* returns the output size of the given hash/mac algorithm
- */
 int
 _gnutls_hash_get_algo_len (gnutls_digest_algorithm_t algorithm)
 {
@@ -103,97 +66,13 @@ _gnutls_hash_get_algo_len (gnutls_digest_algorithm_t algorithm)
 }
 
 int
-_gnutls_hash (const digest_hd_st * handle, const void *text, size_t textlen)
-{
-  if (textlen > 0)
-    {
-      if (handle->registered)
-	{
-	  return handle->hd.rh.cc->hash (handle->hd.rh.ctx, text, textlen);
-	}
-      return _gnutls_digest_ops.hash (handle->hd.gc, text, textlen);
-    }
-  return 0;
-}
-
-int
-_gnutls_hash_copy (digest_hd_st * dst, digest_hd_st * src)
-{
-  int result;
-
-  memset (dst, 0, sizeof (*dst));
-  dst->algorithm = src->algorithm;
-  dst->registered = src->registered;
-  dst->active = 1;
-
-  if (src->registered)
-    {
-      dst->hd.rh.cc = src->hd.rh.cc;
-      return src->hd.rh.cc->copy (&dst->hd.rh.ctx, src->hd.rh.ctx);
-    }
-
-  result = _gnutls_digest_ops.copy (&dst->hd.gc, src->hd.gc);
-  if (result < 0)
-    {
-      gnutls_assert ();
-      return result;
-    }
-
-  return 0;
-}
-
-/* when the current output is needed without calling deinit
- */
-void
-_gnutls_hash_output (digest_hd_st * handle, void *digest)
-{
-  size_t maclen;
-
-  maclen = _gnutls_hash_get_algo_len (handle->algorithm);
-
-  if (handle->registered && handle->hd.rh.ctx != NULL)
-    {
-      if (digest != NULL)
-	handle->hd.rh.cc->output (handle->hd.rh.ctx, digest, maclen);
-      return;
-    }
-
-  if (digest != NULL)
-    {
-      _gnutls_digest_ops.output (handle->hd.gc, digest, maclen);
-    }
-}
-
-void
-_gnutls_hash_deinit (digest_hd_st * handle, void *digest)
-{
-  if (handle->active != 1)
-    {
-      return;
-    }
-
-  if (digest != NULL)
-    _gnutls_hash_output (handle, digest);
-
-  handle->active = 0;
-
-  if (handle->registered && handle->hd.rh.ctx != NULL)
-    {
-      handle->hd.rh.cc->deinit (handle->hd.rh.ctx);
-      return;
-    }
-
-  _gnutls_digest_ops.deinit (handle->hd.gc);
-}
-
-int
-_gnutls_hash_fast (gnutls_digest_algorithm_t algorithm,
-		   const void *text, size_t textlen, void *digest)
+_gnutls_hash_fast (gnutls_digest_algorithm_t algorithm, const void *key,
+		   int keylen, const void *text, size_t textlen, void *digest)
 {
-  digest_hd_st dig;
+  hash_hd_st dig;
   int ret;
 
-  ret = _gnutls_hash_init (&dig, algorithm);
+  ret = _gnutls_hash_init (&dig, algorithm, key, keylen);
   if (ret < 0)
     {
       gnutls_assert ();
@@ -212,47 +91,12 @@ _gnutls_hash_fast (gnutls_digest_algorithm_t algorithm,
   return 0;
 }
 
-
-/* HMAC interface */
-
-int
-_gnutls_hmac_get_algo_len (gnutls_mac_algorithm_t algorithm)
-{
-  return digest_length (algorithm);
-}
-
 int
-_gnutls_hmac_fast (gnutls_mac_algorithm_t algorithm, const void *key,
-		   int keylen, const void *text, size_t textlen, void *digest)
-{
-  digest_hd_st dig;
-  int ret;
-
-  ret = _gnutls_hmac_init (&dig, algorithm, key, keylen);
-  if (ret < 0)
-    {
-      gnutls_assert ();
-      return ret;
-    }
-
-  ret = _gnutls_hmac (&dig, text, textlen);
-  if (ret < 0)
-    {
-      gnutls_assert ();
-      _gnutls_hmac_deinit (&dig, NULL);
-      return ret;
-    }
-
-  _gnutls_hmac_deinit (&dig, digest);
-  return 0;
-}
-
-int
-_gnutls_hmac_init (digest_hd_st * dig, gnutls_mac_algorithm_t algorithm,
+_gnutls_hash_init (hash_hd_st * dig, gnutls_digest_algorithm_t algorithm,
 		   const void *key, int keylen)
 {
   int result;
-  gnutls_crypto_single_mac_st *cc = NULL;
+  const gnutls_crypto_digest_st *cc = NULL;
 
   dig->algorithm = algorithm;
   dig->key = key;
@@ -272,11 +116,14 @@ _gnutls_hmac_init (digest_hd_st * dig, gnutls_mac_algorithm_t algorithm,
 	  return GNUTLS_E_HASH_FAILED;
 	}
 
-      if (cc->setkey (dig->hd.rh.ctx, key, keylen) < 0)
+      if (key)
 	{
-	  gnutls_assert ();
-	  cc->deinit (dig->hd.rh.ctx);
-	  return GNUTLS_E_HASH_FAILED;
+	  if (cc->setkey == NULL || cc->setkey (dig->hd.rh.ctx, key, keylen) < 0)
+	    {
+	      gnutls_assert ();
+  	      cc->deinit (dig->hd.rh.ctx);
+	      return GNUTLS_E_HASH_FAILED;
+            }
 	}
 
       dig->active = 1;
@@ -292,14 +139,17 @@ _gnutls_hmac_init (digest_hd_st * dig, gnutls_mac_algorithm_t algorithm,
       return result;
     }
 
-  _gnutls_mac_ops.setkey (dig->hd.gc, key, keylen);
+  if (key) 
+    {
+      _gnutls_mac_ops.setkey (dig->hd.gc, key, keylen);
+    }
 
   dig->active = 1;
   return 0;
 }
 
 int
-_gnutls_hmac (const digest_hd_st * handle, const void *text, size_t textlen)
+_gnutls_hash (const hash_hd_st * handle, const void *text, size_t textlen)
 {
   if (textlen > 0)
     {
@@ -313,11 +163,11 @@ _gnutls_hmac (const digest_hd_st * handle, const void *text, size_t textlen)
 }
 
 void
-_gnutls_hmac_output (digest_hd_st * handle, void *digest)
+_gnutls_hash_output (hash_hd_st * handle, void *digest)
 {
   int maclen;
 
-  maclen = _gnutls_hmac_get_algo_len (handle->algorithm);
+  maclen = _gnutls_hash_get_algo_len (handle->algorithm);
 
   if (handle->registered && handle->hd.rh.ctx != NULL)
     {
@@ -332,8 +182,46 @@ _gnutls_hmac_output (digest_hd_st * handle, void *digest)
     }
 }
 
+int
+_gnutls_hash_copy (hash_hd_st * dst, hash_hd_st * src)
+{
+  int result;
+
+  memset (dst, 0, sizeof (*dst));
+  dst->algorithm = src->algorithm;
+  dst->registered = src->registered;
+  dst->active = 1;
+
+  if (src->registered)
+   {
+      dst->hd.rh.cc = src->hd.rh.cc;
+      return src->hd.rh.cc->copy (&dst->hd.rh.ctx, src->hd.rh.ctx);
+    }
+
+  result = _gnutls_mac_ops.copy (&dst->hd.gc, src->hd.gc);
+  if (result < 0)
+    {
+      gnutls_assert ();
+      return result;
+    }
+
+  return 0;
+}
+
 void
-_gnutls_hmac_deinit (digest_hd_st * handle, void *digest)
+_gnutls_hash_reset (hash_hd_st * handle)
+{
+  if (handle->registered && handle->hd.rh.ctx != NULL)
+    {
+      handle->hd.rh.cc->reset (handle->hd.rh.ctx);
+      return;
+    }
+
+    _gnutls_mac_ops.reset (handle->hd.gc);
+}
+
+void
+_gnutls_hash_deinit (hash_hd_st * handle, void *digest)
 {
   if (handle->active != 1)
     {
@@ -341,7 +229,7 @@ _gnutls_hmac_deinit (digest_hd_st * handle, void *digest)
     }
 
   if (digest)
-    _gnutls_hmac_output (handle, digest);
+    _gnutls_hash_output (handle, digest);
 
   handle->active = 0;
   if (handle->registered && handle->hd.rh.ctx != NULL)
@@ -354,7 +242,7 @@ _gnutls_hmac_deinit (digest_hd_st * handle, void *digest)
 }
 
 inline static int
-get_padsize (gnutls_mac_algorithm_t algorithm)
+get_padsize (gnutls_digest_algorithm_t algorithm)
 {
   switch (algorithm)
     {
@@ -372,7 +260,7 @@ get_padsize (gnutls_mac_algorithm_t algorithm)
  */
 
 int
-_gnutls_mac_init_ssl3 (digest_hd_st * ret, gnutls_mac_algorithm_t algorithm,
+_gnutls_mac_init_ssl3 (hash_hd_st * ret, gnutls_digest_algorithm_t algorithm,
 		       void *key, int keylen)
 {
   opaque ipad[48];
@@ -387,7 +275,7 @@ _gnutls_mac_init_ssl3 (digest_hd_st * ret, gnutls_mac_algorithm_t algorithm,
 
   memset (ipad, 0x36, padsize);
 
-  result = _gnutls_hash_init (ret, algorithm);
+  result = _gnutls_hash_init (ret, algorithm, NULL, 0);
   if (result < 0)
     {
       gnutls_assert ();
@@ -405,10 +293,10 @@ _gnutls_mac_init_ssl3 (digest_hd_st * ret, gnutls_mac_algorithm_t algorithm,
 }
 
 void
-_gnutls_mac_deinit_ssl3 (digest_hd_st * handle, void *digest)
+_gnutls_mac_deinit_ssl3 (hash_hd_st * handle, void *digest)
 {
   opaque ret[MAX_HASH_SIZE];
-  digest_hd_st td;
+  hash_hd_st td;
   opaque opad[48];
   int padsize;
   int block, rc;
@@ -423,7 +311,7 @@ _gnutls_mac_deinit_ssl3 (digest_hd_st * handle, void *digest)
 
   memset (opad, 0x5C, padsize);
 
-  rc = _gnutls_hash_init (&td, handle->algorithm);
+  rc = _gnutls_hash_init (&td, handle->algorithm, NULL, 0);
   if (rc < 0)
     {
       gnutls_assert ();
@@ -435,7 +323,7 @@ _gnutls_mac_deinit_ssl3 (digest_hd_st * handle, void *digest)
     _gnutls_hash (&td, handle->key, handle->keysize);
 
   _gnutls_hash (&td, opad, padsize);
-  block = _gnutls_hmac_get_algo_len (handle->algorithm);
+  block = _gnutls_hash_get_algo_len (handle->algorithm);
   _gnutls_hash_deinit (handle, ret);	/* get the previous hash */
   _gnutls_hash (&td, ret, block);
 
@@ -445,12 +333,12 @@ _gnutls_mac_deinit_ssl3 (digest_hd_st * handle, void *digest)
 }
 
 void
-_gnutls_mac_deinit_ssl3_handshake (digest_hd_st * handle,
+_gnutls_mac_deinit_ssl3_handshake (hash_hd_st * handle,
 				   void *digest, opaque * key,
 				   uint32_t key_size)
 {
   opaque ret[MAX_HASH_SIZE];
-  digest_hd_st td;
+  hash_hd_st td;
   opaque opad[48];
   opaque ipad[48];
   int padsize;
@@ -466,7 +354,7 @@ _gnutls_mac_deinit_ssl3_handshake (digest_hd_st * handle,
   memset (opad, 0x5C, padsize);
   memset (ipad, 0x36, padsize);
 
-  rc = _gnutls_hash_init (&td, handle->algorithm);
+  rc = _gnutls_hash_init (&td, handle->algorithm, NULL, 0);
   if (rc < 0)
     {
       gnutls_assert ();
@@ -477,7 +365,7 @@ _gnutls_mac_deinit_ssl3_handshake (digest_hd_st * handle,
     _gnutls_hash (&td, key, key_size);
 
   _gnutls_hash (&td, opad, padsize);
-  block = _gnutls_hmac_get_algo_len (handle->algorithm);
+  block = _gnutls_hash_get_algo_len (handle->algorithm);
 
   if (key_size > 0)
     _gnutls_hash (handle, key, key_size);
@@ -498,14 +386,14 @@ ssl3_sha (int i, opaque * secret, int secret_len,
   int j, ret;
   opaque text1[26];
 
-  digest_hd_st td;
+  hash_hd_st td;
 
   for (j = 0; j < i + 1; j++)
     {
       text1[j] = 65 + i;	/* A==65 */
     }
 
-  ret = _gnutls_hash_init (&td, GNUTLS_MAC_SHA1);
+  ret = _gnutls_hash_init (&td, GNUTLS_MAC_SHA1, NULL, 0);
   if (ret < 0)
     {
       gnutls_assert ();
@@ -525,10 +413,10 @@ ssl3_md5 (int i, opaque * secret, int secret_len,
 	  opaque * rnd, int rnd_len, void *digest)
 {
   opaque tmp[MAX_HASH_SIZE];
-  digest_hd_st td;
+  hash_hd_st td;
   int ret;
 
-  ret = _gnutls_hash_init (&td, GNUTLS_MAC_MD5);
+  ret = _gnutls_hash_init (&td, GNUTLS_MAC_MD5, NULL, 0);
   if (ret < 0)
     {
       gnutls_assert ();
@@ -557,11 +445,11 @@ _gnutls_ssl3_hash_md5 (const void *first, int first_len,
 		       int ret_len, opaque * ret)
 {
   opaque digest[MAX_HASH_SIZE];
-  digest_hd_st td;
+  hash_hd_st td;
   int block = _gnutls_hash_get_algo_len (GNUTLS_MAC_MD5);
   int rc;
 
-  rc = _gnutls_hash_init (&td, GNUTLS_MAC_MD5);
+  rc = _gnutls_hash_init (&td, GNUTLS_MAC_MD5, NULL, 0);
   if (rc < 0)
     {
       gnutls_assert ();