Fix for Win32.

[openssl.git] / crypto / sha / sha256.c

diff --git a/crypto/sha/sha256.c b/crypto/sha/sha256.c
index f31eb3e7861635b08fd45c097c312135278a07ae..bbc20da0e97f9e030f6412846880cb23978206dc 100644 (file)
--- a/crypto/sha/sha256.c
+++ b/crypto/sha/sha256.c
@@ -4,10 +4,12 @@
  * according to the OpenSSL license [found in ../../LICENSE].
  * ====================================================================
  */
+#include <openssl/opensslconf.h>
+#if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA256)
+
 #include <stdlib.h>
 #include <string.h>
 
-#include <openssl/opensslconf.h>
 #include <openssl/crypto.h>
 #include <openssl/sha.h>
 #include <openssl/opensslv.h>
@@ -20,9 +22,9 @@ int SHA224_Init (SHA256_CTX *c)
        c->h[2]=0x3070dd17UL;   c->h[3]=0xf70e5939UL;
        c->h[4]=0xffc00b31UL;   c->h[5]=0x68581511UL;
        c->h[6]=0x64f98fa7UL;   c->h[7]=0xbefa4fa4UL;
-        c->Nl=0;        c->Nh=0;
-        c->num=0;
-        return 1;
+       c->Nl=0;        c->Nh=0;
+       c->num=0;       c->md_len=SHA224_DIGEST_LENGTH;
+       return 1;
        }
 
 int SHA256_Init (SHA256_CTX *c)
@@ -31,23 +33,20 @@ int SHA256_Init (SHA256_CTX *c)
        c->h[2]=0x3c6ef372UL;   c->h[3]=0xa54ff53aUL;
        c->h[4]=0x510e527fUL;   c->h[5]=0x9b05688cUL;
        c->h[6]=0x1f83d9abUL;   c->h[7]=0x5be0cd19UL;
-        c->Nl=0;        c->Nh=0;
-        c->num=0;
-        return 1;
+       c->Nl=0;        c->Nh=0;
+       c->num=0;       c->md_len=SHA256_DIGEST_LENGTH;
+       return 1;
        }
 
 unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md)
        {
        SHA256_CTX c;
-       static unsigned char m[SHA256_DIGEST_LENGTH];
+       static unsigned char m[SHA224_DIGEST_LENGTH];
 
+       if (md == NULL) md=m;
        SHA224_Init(&c);
        SHA256_Update(&c,d,n);
-       SHA256_Final(m,&c);
-       if (md != NULL) memcpy (md,m,SHA224_DIGEST_LENGTH),
-                       memset (m,0,sizeof(m));
-       else            md=m,
-                       memset (m+SHA224_DIGEST_LENGTH,0,sizeof(m)-SHA256_DIGEST_LENGTH);
+       SHA256_Final(md,&c);
        OPENSSL_cleanse(&c,sizeof(c));
        return(md);
        }
@@ -65,6 +64,11 @@ unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md)
        return(md);
        }
 
+int SHA224_Update(SHA256_CTX *c, const void *data, size_t len)
+{   return SHA256_Update (c,data,len);   }
+int SHA224_Final (unsigned char *md, SHA256_CTX *c)
+{   return SHA256_Final (md,c);   }
+
 #ifndef        SHA_LONG_LOG2
 #define        SHA_LONG_LOG2   2       /* default to 32 bits */
 #endif
@@ -76,12 +80,33 @@ unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md)
 #define        HASH_CTX                SHA256_CTX
 #define        HASH_CBLOCK             SHA_CBLOCK
 #define        HASH_LBLOCK             SHA_LBLOCK
+/*
+ * Note that FIPS180-2 discusses "Truncation of the Hash Function Output."
+ * default: case below covers for it. It's not clear however if it's
+ * permitted to truncate to amount of bytes not divisible by 4. I bet not,
+ * but if it is, then default: case shall be extended. For reference.
+ * Idea behind separate cases for pre-defined lenghts is to let the
+ * compiler decide if it's appropriate to unroll small loops.
+ */
 #define        HASH_MAKE_STRING(c,s)   do {    \
        unsigned long ll;               \
-       ll=(c)->h[0]; HOST_l2c(ll,(s)); ll=(c)->h[1]; HOST_l2c(ll,(s)); \
-       ll=(c)->h[2]; HOST_l2c(ll,(s)); ll=(c)->h[3]; HOST_l2c(ll,(s)); \
-       ll=(c)->h[4]; HOST_l2c(ll,(s)); ll=(c)->h[5]; HOST_l2c(ll,(s)); \
-       ll=(c)->h[6]; HOST_l2c(ll,(s)); ll=(c)->h[7]; HOST_l2c(ll,(s)); \
+       unsigned int  n;                \
+       switch ((c)->md_len)            \
+       {   case SHA224_DIGEST_LENGTH:  \
+               for (n=0;n<SHA224_DIGEST_LENGTH/4;n++)  \
+               {   ll=(c)->h[n]; HOST_l2c(ll,(s));   } \
+               break;                  \
+           case SHA256_DIGEST_LENGTH:  \
+               for (n=0;n<SHA256_DIGEST_LENGTH/4;n++)  \
+               {   ll=(c)->h[n]; HOST_l2c(ll,(s));   } \
+               break;                  \
+           default:                    \
+               if ((c)->md_len > SHA256_DIGEST_LENGTH) \
+                   return 0;                           \
+               for (n=0;n<(c)->md_len/4;n++)           \
+               {   ll=(c)->h[n]; HOST_l2c(ll,(s));   } \
+               break;                  \
+       }                               \
        } while (0)
 
 #define        HASH_UPDATE             SHA256_Update
@@ -94,6 +119,9 @@ void sha256_block_data_order (SHA256_CTX *ctx, const void *in, size_t num);
 
 #include "md32_common.h"
 
+#ifdef SHA256_ASM
+void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host);
+#else
 static const SHA_LONG K256[64] = {
        0x428a2f98UL,0x71374491UL,0xb5c0fbcfUL,0xe9b5dba5UL,
        0x3956c25bUL,0x59f111f1UL,0x923f82a4UL,0xab1c5ed5UL,
@@ -151,6 +179,8 @@ static void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host)
                        h = g;  g = f;  f = e;  e = d + T1;
                        d = c;  c = b;  b = a;  a = T1 + T2;
                        }
+
+               data += SHA256_CBLOCK;
                }
        else
                {
@@ -181,7 +211,6 @@ static void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host)
        ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d;
        ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h;
 
-                       data += SHA256_CBLOCK;
                        }
 }
 
@@ -230,6 +259,8 @@ static void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host)
                T1 = X[13] = W[13];     ROUND_00_15(13,d,e,f,g,h,a,b,c);
                T1 = X[14] = W[14];     ROUND_00_15(14,c,d,e,f,g,h,a,b);
                T1 = X[15] = W[15];     ROUND_00_15(15,b,c,d,e,f,g,h,a);
+
+               data += SHA256_CBLOCK;
                }
        else
                {
@@ -268,11 +299,11 @@ static void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host)
        ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d;
        ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h;
 
-                       data += SHA256_CBLOCK;
                        }
        }
 
 #endif
+#endif /* SHA256_ASM */
 
 /*
  * Idea is to trade couple of cycles for some space. On IA-32 we save
@@ -284,3 +315,5 @@ void HASH_BLOCK_HOST_ORDER (SHA256_CTX *ctx, const void *in, size_t num)
 
 void HASH_BLOCK_DATA_ORDER (SHA256_CTX *ctx, const void *in, size_t num)
 {   sha256_block (ctx,in,num,0);   }
+
+#endif /* OPENSSL_NO_SHA256 */