sha1dc: update to fix errors with endianess and unaligned access

This updates our version of SHA1DC to e139984 (Merge pull request #35 from lidl/master, 2017-05-30).

Author: pks-t

sha1.c

@@ -10,27 +10,70 @@
 #include<memory.h>
 #include<stdio.h>
 #include<stdlib.h>
+#endif
+
+#ifdefSHA1DC_CUSTOM_INCLUDE_SHA1_C
+#includeSHA1DC_CUSTOM_INCLUDE_SHA1_C
+#endif
+
+#ifndefSHA1DC_INIT_SAFE_HASH_DEFAULT
+#defineSHA1DC_INIT_SAFE_HASH_DEFAULT 1
+#endif
 
 #include"sha1.h"
 #include"ubc_check.h"
 
 
-/*
+/*
  Because Little-Endian architectures are most common,
- we only set BIGENDIAN if one of these conditions is met.
+ we only set SHA1DC_BIGENDIAN if one of these conditions is met.
  Note that all MSFT platforms are little endian,
  so none of these will be defined under the MSC compiler.
  If you are compiling on a big endian platform and your compiler does not define one of these,
  you will have to add whatever macros your tool chain defines to indicate Big-Endianness.
  */
-#if (defined(__BYTE_ORDER) && (__BYTE_ORDER==__BIG_ENDIAN)) || \
- (defined(__BYTE_ORDER__) && (__BYTE_ORDER__==__BIG_ENDIAN__)) || \
- defined(__BIG_ENDIAN__) || defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \
- defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__)
+#ifdefSHA1DC_BIGENDIAN
+#undef SHA1DC_BIGENDIAN
+#endif
+
+#if (defined(_BYTE_ORDER) || defined(__BYTE_ORDER) || defined(__BYTE_ORDER__))
+
+#if ((defined(_BYTE_ORDER) && (_BYTE_ORDER==_BIG_ENDIAN)) || \
+ (defined(__BYTE_ORDER) && (__BYTE_ORDER==__BIG_ENDIAN)) || \
+ (defined(__BYTE_ORDER__) && (__BYTE_ORDER__==__BIG_ENDIAN__)) )
+#defineSHA1DC_BIGENDIAN
+#endif
+
+#else
+
+#if (defined(_BIG_ENDIAN) || defined(__BIG_ENDIAN) || defined(__BIG_ENDIAN__) || \
+ defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \
+ defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || \
+ defined(__sparc))
+#defineSHA1DC_BIGENDIAN
+#endif
+
+#endif
 
-#defineBIGENDIAN (1)
+#if (defined(SHA1DC_FORCE_LITTLEENDIAN) && defined(SHA1DC_BIGENDIAN))
+#undef SHA1DC_BIGENDIAN
+#endif
+#if (defined(SHA1DC_FORCE_BIGENDIAN) && !defined(SHA1DC_BIGENDIAN))
+#defineSHA1DC_BIGENDIAN
+#endif
+/*ENDIANNESS SELECTION*/
+
+#if (defined SHA1DC_FORCE_UNALIGNED_ACCESS|| \
+ defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || \
+ defined(i386) || defined(__i386) || defined(__i386__) || defined(__i486__) || \
+ defined(__i586__) || defined(__i686__) || defined(_M_IX86) || defined(__X86__) || \
+ defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__) || defined(__INTEL__) || \
+ defined(__386) || defined(_M_X64) || defined(_M_AMD64))
+
+#defineSHA1DC_ALLOW_UNALIGNED_ACCESS
+
+#endif/*UNALIGNMENT DETECTION*/
 
-#endif/*ENDIANNESS SELECTION*/
 
 #definerotate_right(x,n) (((x)>>(n))|((x)<<(32-(n))))
 #definerotate_left(x,n) (((x)<<(n))|((x)>>(32-(n))))
@@ -40,11 +83,11 @@
 
 #definesha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
 
-#if defined(BIGENDIAN)
+#ifdefSHA1DC_BIGENDIAN
 #definesha1_load(m, t, temp){temp = m[t]}
 #else
 #definesha1_load(m, t, temp){temp = m[t]; sha1_bswap32(temp)}
-#endif/*define(BIGENDIAN)*/
+#endif
 
 #definesha1_store(W, t, x) *(volatile uint32_t *)&W[t] = x
 
@@ -873,6 +916,11 @@ static void sha1recompress_fast_ ## t (uint32_t ihvin[5], uint32_t ihvout[5], co
  ihvout[0] = ihvin[0] + a; ihvout[1] = ihvin[1] + b; ihvout[2] = ihvin[2] + c; ihvout[3] = ihvin[3] + d; ihvout[4] = ihvin[4] + e; \
 }
 
+#ifdef_MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4127) /* Complier complains about the checks in the above macro being constant. */
+#endif
+
 #ifdefDOSTORESTATE0
 SHA1_RECOMPRESS(0)
 #endif
@@ -1193,6 +1241,10 @@ SHA1_RECOMPRESS(78)
 SHA1_RECOMPRESS(79)
 #endif
 
+#ifdef_MSC_VER
+#pragma warning(pop)
+#endif
+
 staticvoidsha1_recompression_step(uint32_tstep, uint32_tihvin[5], uint32_tihvout[5], constuint32_tme2[80], constuint32_tstate[5])
 {
 switch (step)
@@ -1610,7 +1662,7 @@ static void sha1_process(SHA1_CTX* ctx, const uint32_t block[16])
 unsignedi, j;
 uint32_tubc_dv_mask[DVMASKSIZE] ={0xFFFFFFFF };
 uint32_tihvtmp[5];
-
+
 ctx->ihv1[0] =ctx->ihv[0];
 ctx->ihv1[1] =ctx->ihv[1];
 ctx->ihv1[2] =ctx->ihv[2];
@@ -1714,6 +1766,7 @@ void SHA1DCSetCallback(SHA1_CTX* ctx, collision_block_callback callback)
 voidSHA1DCUpdate(SHA1_CTX*ctx, constchar*buf, size_tlen)
 {
 unsignedleft, fill;
+
 if (len==0)
 return;
 
@@ -1732,7 +1785,13 @@ void SHA1DCUpdate(SHA1_CTX* ctx, const char* buf, size_t len)
 while (len >= 64)
 {
 ctx->total+=64;
+
+#if defined(SHA1DC_ALLOW_UNALIGNED_ACCESS)
 sha1_process(ctx, (uint32_t*)(buf));
+#else
+memcpy(ctx->buffer, buf, 64);
+sha1_process(ctx, (uint32_t*)(ctx->buffer));
+#endif/* defined(SHA1DC_ALLOW_UNALIGNED_ACCESS) */
 buf+=64;
 len-=64;
  }

ubc_check.h

@@ -27,6 +27,7 @@
 extern"C"{
 #endif
 
+#ifndefSHA1DC_NO_STANDARD_INCLUDES
 #include<stdint.h>
 #endif
 
@@ -44,4 +45,8 @@ void ubc_check(const uint32_t W[80], uint32_t dvmask[DVMASKSIZE]);
 }
 #endif
 
-#endif/* UBC_CHECK_H */
+#ifdefSHA1DC_CUSTOM_TRAILING_INCLUDE_UBC_CHECK_H
+#includeSHA1DC_CUSTOM_TRAILING_INCLUDE_UBC_CHECK_H
+#endif
+
+#endif