react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/C/Sha256.c

@@ -1,113 +1,25 @@
-/* Sha256.c -- SHA-256 Hash
-: Igor Pavlov : Public domain
+/* Crypto/Sha256.c -- SHA-256 Hash
+2017-04-03 : Igor Pavlov : Public domain
 This code is based on public domain code from Wei Dai's Crypto++ library. */
 
 #include "Precomp.h"
 
 #include <string.h>
 
-#include "Sha256.h"
-#include "RotateDefs.h"
 #include "CpuArch.h"
-
-#ifdef MY_CPU_X86_OR_AMD64
-  #if   defined(Z7_LLVM_CLANG_VERSION)  && (Z7_LLVM_CLANG_VERSION  >= 30800) \
-     || defined(Z7_APPLE_CLANG_VERSION) && (Z7_APPLE_CLANG_VERSION >= 50100) \
-     || defined(Z7_GCC_VERSION)         && (Z7_GCC_VERSION         >= 40900) \
-     || defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1600) \
-     || defined(_MSC_VER) && (_MSC_VER >= 1200)
-      #define Z7_COMPILER_SHA256_SUPPORTED
-  #endif
-#elif defined(MY_CPU_ARM64) && defined(MY_CPU_LE)
-
-  #if   defined(__ARM_FEATURE_SHA2) \
-     || defined(__ARM_FEATURE_CRYPTO)
-    #define Z7_COMPILER_SHA256_SUPPORTED
-  #else
-    #if  defined(MY_CPU_ARM64) \
-      || defined(__ARM_ARCH) && (__ARM_ARCH >= 4) \
-      || defined(Z7_MSC_VER_ORIGINAL)
-    #if  defined(__ARM_FP) && \
-          (   defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30800) \
-           || defined(__GNUC__) && (__GNUC__ >= 6) \
-          ) \
-      || defined(Z7_MSC_VER_ORIGINAL) && (_MSC_VER >= 1910)
-    #if  defined(MY_CPU_ARM64) \
-      || !defined(Z7_CLANG_VERSION) \
-      || defined(__ARM_NEON) && \
-          (Z7_CLANG_VERSION < 170000 || \
-           Z7_CLANG_VERSION > 170001)
-      #define Z7_COMPILER_SHA256_SUPPORTED
-    #endif
-    #endif
-    #endif
-  #endif
-#endif
-
-void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks);
-
-#ifdef Z7_COMPILER_SHA256_SUPPORTED
-  void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
-
-  static SHA256_FUNC_UPDATE_BLOCKS g_SHA256_FUNC_UPDATE_BLOCKS = Sha256_UpdateBlocks;
-  static SHA256_FUNC_UPDATE_BLOCKS g_SHA256_FUNC_UPDATE_BLOCKS_HW;
-
-  #define SHA256_UPDATE_BLOCKS(p) p->v.vars.func_UpdateBlocks
-#else
-  #define SHA256_UPDATE_BLOCKS(p) Sha256_UpdateBlocks
-#endif
-
-
-BoolInt Sha256_SetFunction(CSha256 *p, unsigned algo)
-{
-  SHA256_FUNC_UPDATE_BLOCKS func = Sha256_UpdateBlocks;
-  
-  #ifdef Z7_COMPILER_SHA256_SUPPORTED
-    if (algo != SHA256_ALGO_SW)
-    {
-      if (algo == SHA256_ALGO_DEFAULT)
-        func = g_SHA256_FUNC_UPDATE_BLOCKS;
-      else
-      {
-        if (algo != SHA256_ALGO_HW)
-          return False;
-        func = g_SHA256_FUNC_UPDATE_BLOCKS_HW;
-        if (!func)
-          return False;
-      }
-    }
-  #else
-    if (algo > 1)
-      return False;
-  #endif
-
-  p->v.vars.func_UpdateBlocks = func;
-  return True;
-}
-
+#include "RotateDefs.h"
+#include "Sha256.h"
 
 /* define it for speed optimization */
-
-#ifdef Z7_SFX
-  #define STEP_PRE 1
-  #define STEP_MAIN 1
-#else
-  #define STEP_PRE 2
-  #define STEP_MAIN 4
-  // #define Z7_SHA256_UNROLL
-#endif
-
-#undef Z7_SHA256_BIG_W
-#if STEP_MAIN != 16
-  #define Z7_SHA256_BIG_W
+#ifndef _SFX
+#define _SHA256_UNROLL
+#define _SHA256_UNROLL2
 #endif
 
+/* #define _SHA256_UNROLL2 */
 
-
-
-void Sha256_InitState(CSha256 *p)
+void Sha256_Init(CSha256 *p)
 {
-  p->v.vars.count = 0;
   p->state[0] = 0x6a09e667;
   p->state[1] = 0xbb67ae85;
   p->state[2] = 0x3c6ef372;
@@ -116,121 +28,69 @@ void Sha256_InitState(CSha256 *p)
   p->state[5] = 0x9b05688c;
   p->state[6] = 0x1f83d9ab;
   p->state[7] = 0x5be0cd19;
+  p->count = 0;
 }
 
-
-
-
-
-
-
-
-void Sha256_Init(CSha256 *p)
-{
-  p->v.vars.func_UpdateBlocks =
-  #ifdef Z7_COMPILER_SHA256_SUPPORTED
-      g_SHA256_FUNC_UPDATE_BLOCKS;
-  #else
-      NULL;
-  #endif
-  Sha256_InitState(p);
-}
-
-#define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x,22))
-#define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x,25))
+#define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x, 22))
+#define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x, 25))
 #define s0(x) (rotrFixed(x, 7) ^ rotrFixed(x,18) ^ (x >> 3))
-#define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >>10))
+#define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >> 10))
+
+#define blk0(i) (W[i])
+#define blk2(i) (W[i] += s1(W[((i)-2)&15]) + W[((i)-7)&15] + s0(W[((i)-15)&15]))
 
 #define Ch(x,y,z) (z^(x&(y^z)))
 #define Maj(x,y,z) ((x&y)|(z&(x|y)))
 
+#ifdef _SHA256_UNROLL2
 
-#define W_PRE(i) (W[(i) + (size_t)(j)] = GetBe32(data + ((size_t)(j) + i) * 4))
-
-#define blk2_main(j, i)  s1(w(j, (i)-2)) + w(j, (i)-7) + s0(w(j, (i)-15))
-
-#ifdef Z7_SHA256_BIG_W
-    // we use +i instead of +(i) to change the order to solve CLANG compiler warning for signed/unsigned.
-    #define w(j, i)     W[(size_t)(j) + i]
-    #define blk2(j, i)  (w(j, i) = w(j, (i)-16) + blk2_main(j, i))
-#else
-    #if STEP_MAIN == 16
-        #define w(j, i)  W[(i) & 15]
-    #else
-        #define w(j, i)  W[((size_t)(j) + (i)) & 15]
-    #endif
-    #define blk2(j, i)  (w(j, i) += blk2_main(j, i))
-#endif
-
-#define W_MAIN(i)  blk2(j, i)
-
-
-#define T1(wx, i) \
-    tmp = h + S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
-    h = g; \
-    g = f; \
-    f = e; \
-    e = d + tmp; \
-    tmp += S0(a) + Maj(a, b, c); \
-    d = c; \
-    c = b; \
-    b = a; \
-    a = tmp; \
-
-#define R1_PRE(i)  T1( W_PRE, i)
-#define R1_MAIN(i) T1( W_MAIN, i)
-
-#if (!defined(Z7_SHA256_UNROLL) || STEP_MAIN < 8) && (STEP_MAIN >= 4)
-#define R2_MAIN(i) \
-    R1_MAIN(i) \
-    R1_MAIN(i + 1) \
-
-#endif
-
+#define R(a,b,c,d,e,f,g,h, i) \
+    h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + (j ? blk2(i) : blk0(i)); \
+    d += h; \
+    h += S0(a) + Maj(a, b, c)
 
+#define RX_8(i) \
+  R(a,b,c,d,e,f,g,h, i); \
+  R(h,a,b,c,d,e,f,g, i+1); \
+  R(g,h,a,b,c,d,e,f, i+2); \
+  R(f,g,h,a,b,c,d,e, i+3); \
+  R(e,f,g,h,a,b,c,d, i+4); \
+  R(d,e,f,g,h,a,b,c, i+5); \
+  R(c,d,e,f,g,h,a,b, i+6); \
+  R(b,c,d,e,f,g,h,a, i+7)
 
-#if defined(Z7_SHA256_UNROLL) && STEP_MAIN >= 8
+#define RX_16  RX_8(0); RX_8(8);
 
-#define T4( a,b,c,d,e,f,g,h, wx, i) \
-    h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
-    tmp = h; \
-    h += d; \
-    d = tmp + S0(a) + Maj(a, b, c); \
+#else
 
-#define R4( wx, i) \
-    T4 ( a,b,c,d,e,f,g,h, wx, (i  )); \
-    T4 ( d,a,b,c,h,e,f,g, wx, (i+1)); \
-    T4 ( c,d,a,b,g,h,e,f, wx, (i+2)); \
-    T4 ( b,c,d,a,f,g,h,e, wx, (i+3)); \
+#define a(i) T[(0-(i))&7]
+#define b(i) T[(1-(i))&7]
+#define c(i) T[(2-(i))&7]
+#define d(i) T[(3-(i))&7]
+#define e(i) T[(4-(i))&7]
+#define f(i) T[(5-(i))&7]
+#define g(i) T[(6-(i))&7]
+#define h(i) T[(7-(i))&7]
 
-#define R4_PRE(i)  R4( W_PRE, i)
-#define R4_MAIN(i) R4( W_MAIN, i)
+#define R(i) \
+    h(i) += S1(e(i)) + Ch(e(i),f(i),g(i)) + K[(i)+(size_t)(j)] + (j ? blk2(i) : blk0(i)); \
+    d(i) += h(i); \
+    h(i) += S0(a(i)) + Maj(a(i), b(i), c(i)) \
 
+#ifdef _SHA256_UNROLL
 
-#define T8( a,b,c,d,e,f,g,h, wx, i) \
-    h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
-    d += h; \
-    h += S0(a) + Maj(a, b, c); \
+#define RX_8(i)  R(i+0); R(i+1); R(i+2); R(i+3); R(i+4); R(i+5); R(i+6); R(i+7);
+#define RX_16  RX_8(0); RX_8(8);
 
-#define R8( wx, i) \
-    T8 ( a,b,c,d,e,f,g,h, wx, i  ); \
-    T8 ( h,a,b,c,d,e,f,g, wx, i+1); \
-    T8 ( g,h,a,b,c,d,e,f, wx, i+2); \
-    T8 ( f,g,h,a,b,c,d,e, wx, i+3); \
-    T8 ( e,f,g,h,a,b,c,d, wx, i+4); \
-    T8 ( d,e,f,g,h,a,b,c, wx, i+5); \
-    T8 ( c,d,e,f,g,h,a,b, wx, i+6); \
-    T8 ( b,c,d,e,f,g,h,a, wx, i+7); \
+#else
 
-#define R8_PRE(i)  R8( W_PRE, i)
-#define R8_MAIN(i) R8( W_MAIN, i)
+#define RX_16  unsigned i; for (i = 0; i < 16; i++) { R(i); }
 
 #endif
 
+#endif
 
-extern
-MY_ALIGN(64) const UInt32 SHA256_K_ARRAY[64];
-MY_ALIGN(64) const UInt32 SHA256_K_ARRAY[64] = {
+static const UInt32 K[64] = {
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
   0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -249,29 +109,30 @@ MY_ALIGN(64) const UInt32 SHA256_K_ARRAY[64] = {
   0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 };
 
-
-
-
-
-#define K SHA256_K_ARRAY
-
-Z7_NO_INLINE
-void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks)
+static void Sha256_WriteByteBlock(CSha256 *p)
 {
-  UInt32 W
-#ifdef Z7_SHA256_BIG_W
-      [64];
-#else
-      [16];
-#endif
+  UInt32 W[16];
   unsigned j;
+  UInt32 *state;
+
+  #ifdef _SHA256_UNROLL2
   UInt32 a,b,c,d,e,f,g,h;
-#if !defined(Z7_SHA256_UNROLL) || (STEP_MAIN <= 4) || (STEP_PRE <= 4)
-  UInt32 tmp;
-#endif
-  
-  if (numBlocks == 0) return;
+  #else
+  UInt32 T[8];
+  #endif
 
+  for (j = 0; j < 16; j += 4)
+  {
+    const Byte *ccc = p->buffer + j * 4;
+    W[j    ] = GetBe32(ccc);
+    W[j + 1] = GetBe32(ccc + 4);
+    W[j + 2] = GetBe32(ccc + 8);
+    W[j + 3] = GetBe32(ccc + 12);
+  }
+
+  state = p->state;
+
+  #ifdef _SHA256_UNROLL2
   a = state[0];
   b = state[1];
   c = state[2];
@@ -280,213 +141,108 @@ void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t n
   f = state[5];
   g = state[6];
   h = state[7];
+  #else
+  for (j = 0; j < 8; j++)
+    T[j] = state[j];
+  #endif
 
-  do
-  {
-
-  for (j = 0; j < 16; j += STEP_PRE)
-  {
-    #if STEP_PRE > 4
-
-      #if STEP_PRE < 8
-      R4_PRE(0);
-      #else
-      R8_PRE(0);
-      #if STEP_PRE == 16
-      R8_PRE(8);
-      #endif
-      #endif
-
-    #else
-
-      R1_PRE(0)
-      #if STEP_PRE >= 2
-      R1_PRE(1)
-      #if STEP_PRE >= 4
-      R1_PRE(2)
-      R1_PRE(3)
-      #endif
-      #endif
-    
-    #endif
-  }
-
-  for (j = 16; j < 64; j += STEP_MAIN)
+  for (j = 0; j < 64; j += 16)
   {
-    #if defined(Z7_SHA256_UNROLL) && STEP_MAIN >= 8
-
-      #if STEP_MAIN < 8
-      R4_MAIN(0)
-      #else
-      R8_MAIN(0)
-      #if STEP_MAIN == 16
-      R8_MAIN(8)
-      #endif
-      #endif
-
-    #else
-      
-      R1_MAIN(0)
-      #if STEP_MAIN >= 2
-      R1_MAIN(1)
-      #if STEP_MAIN >= 4
-      R2_MAIN(2)
-      #if STEP_MAIN >= 8
-      R2_MAIN(4)
-      R2_MAIN(6)
-      #if STEP_MAIN >= 16
-      R2_MAIN(8)
-      R2_MAIN(10)
-      R2_MAIN(12)
-      R2_MAIN(14)
-      #endif
-      #endif
-      #endif
-      #endif
-    #endif
+    RX_16
   }
 
-  a += state[0]; state[0] = a;
-  b += state[1]; state[1] = b;
-  c += state[2]; state[2] = c;
-  d += state[3]; state[3] = d;
-  e += state[4]; state[4] = e;
-  f += state[5]; state[5] = f;
-  g += state[6]; state[6] = g;
-  h += state[7]; state[7] = h;
-
-  data += SHA256_BLOCK_SIZE;
-  }
-  while (--numBlocks);
+  #ifdef _SHA256_UNROLL2
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+  state[4] += e;
+  state[5] += f;
+  state[6] += g;
+  state[7] += h;
+  #else
+  for (j = 0; j < 8; j++)
+    state[j] += T[j];
+  #endif
+  
+  /* Wipe variables */
+  /* memset(W, 0, sizeof(W)); */
+  /* memset(T, 0, sizeof(T)); */
 }
 
-
-#define Sha256_UpdateBlock(p) SHA256_UPDATE_BLOCKS(p)(p->state, p->buffer, 1)
+#undef S0
+#undef S1
+#undef s0
+#undef s1
 
 void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
 {
   if (size == 0)
     return;
+
   {
-    const unsigned pos = (unsigned)p->v.vars.count & (SHA256_BLOCK_SIZE - 1);
-    const unsigned num = SHA256_BLOCK_SIZE - pos;
-    p->v.vars.count += size;
+    unsigned pos = (unsigned)p->count & 0x3F;
+    unsigned num;
+    
+    p->count += size;
+    
+    num = 64 - pos;
     if (num > size)
     {
       memcpy(p->buffer + pos, data, size);
       return;
     }
-    if (pos != 0)
-    {
-      size -= num;
-      memcpy(p->buffer + pos, data, num);
-      data += num;
-      Sha256_UpdateBlock(p);
-    }
+    
+    size -= num;
+    memcpy(p->buffer + pos, data, num);
+    data += num;
   }
+
+  for (;;)
   {
-    const size_t numBlocks = size >> 6;
-    // if (numBlocks)
-    SHA256_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
-    size &= SHA256_BLOCK_SIZE - 1;
-    if (size == 0)
-      return;
-    data += (numBlocks << 6);
-    memcpy(p->buffer, data, size);
+    Sha256_WriteByteBlock(p);
+    if (size < 64)
+      break;
+    size -= 64;
+    memcpy(p->buffer, data, 64);
+    data += 64;
   }
-}
 
+  if (size != 0)
+    memcpy(p->buffer, data, size);
+}
 
 void Sha256_Final(CSha256 *p, Byte *digest)
 {
-  unsigned pos = (unsigned)p->v.vars.count & (SHA256_BLOCK_SIZE - 1);
+  unsigned pos = (unsigned)p->count & 0x3F;
+  unsigned i;
+  
   p->buffer[pos++] = 0x80;
-  if (pos > (SHA256_BLOCK_SIZE - 4 * 2))
-  {
-    while (pos != SHA256_BLOCK_SIZE) { p->buffer[pos++] = 0; }
-    // memset(&p->buf.buffer[pos], 0, SHA256_BLOCK_SIZE - pos);
-    Sha256_UpdateBlock(p);
-    pos = 0;
-  }
-  memset(&p->buffer[pos], 0, (SHA256_BLOCK_SIZE - 4 * 2) - pos);
+  
+  while (pos != (64 - 8))
   {
-    const UInt64 numBits = p->v.vars.count << 3;
-    SetBe32(p->buffer + SHA256_BLOCK_SIZE - 4 * 2, (UInt32)(numBits >> 32))
-    SetBe32(p->buffer + SHA256_BLOCK_SIZE - 4 * 1, (UInt32)(numBits))
+    pos &= 0x3F;
+    if (pos == 0)
+      Sha256_WriteByteBlock(p);
+    p->buffer[pos++] = 0;
   }
-  Sha256_UpdateBlock(p);
-#if 1 && defined(MY_CPU_BE)
-  memcpy(digest, p->state, SHA256_DIGEST_SIZE);
-#else
+
   {
-    unsigned i;
-    for (i = 0; i < 8; i += 2)
-    {
-      const UInt32 v0 = p->state[i];
-      const UInt32 v1 = p->state[(size_t)i + 1];
-      SetBe32(digest    , v0)
-      SetBe32(digest + 4, v1)
-      digest += 4 * 2;
-    }
+    UInt64 numBits = (p->count << 3);
+    SetBe32(p->buffer + 64 - 8, (UInt32)(numBits >> 32));
+    SetBe32(p->buffer + 64 - 4, (UInt32)(numBits));
   }
+  
+  Sha256_WriteByteBlock(p);
 
-
-
-
-#endif
-  Sha256_InitState(p);
-}
-
-
-void Sha256Prepare(void)
-{
-#ifdef Z7_COMPILER_SHA256_SUPPORTED
-  SHA256_FUNC_UPDATE_BLOCKS f, f_hw;
-  f = Sha256_UpdateBlocks;
-  f_hw = NULL;
-#ifdef MY_CPU_X86_OR_AMD64
-  if (CPU_IsSupported_SHA()
-      && CPU_IsSupported_SSSE3()
-      )
-#else
-  if (CPU_IsSupported_SHA2())
-#endif
+  for (i = 0; i < 8; i += 2)
   {
-    // printf("\n========== HW SHA256 ======== \n");
-    f = f_hw = Sha256_UpdateBlocks_HW;
+    UInt32 v0 = p->state[i];
+    UInt32 v1 = p->state[i + 1];
+    SetBe32(digest    , v0);
+    SetBe32(digest + 4, v1);
+    digest += 8;
   }
-  g_SHA256_FUNC_UPDATE_BLOCKS    = f;
-  g_SHA256_FUNC_UPDATE_BLOCKS_HW = f_hw;
-#endif
+  
+  Sha256_Init(p);
 }
-
-#undef U64C
-#undef K
-#undef S0
-#undef S1
-#undef s0
-#undef s1
-#undef Ch
-#undef Maj
-#undef W_MAIN
-#undef W_PRE
-#undef w
-#undef blk2_main
-#undef blk2
-#undef T1
-#undef T4
-#undef T8
-#undef R1_PRE
-#undef R1_MAIN
-#undef R2_MAIN
-#undef R4
-#undef R4_PRE
-#undef R4_MAIN
-#undef R8
-#undef R8_PRE
-#undef R8_MAIN
-#undef STEP_PRE
-#undef STEP_MAIN
-#undef Z7_SHA256_BIG_W
-#undef Z7_SHA256_UNROLL
-#undef Z7_COMPILER_SHA256_SUPPORTED

package/harmony/pushy/src/main/cpp/lzma/C/Sha256.h

@@ -1,86 +1,26 @@
 /* Sha256.h -- SHA-256 Hash
-: Igor Pavlov : Public domain */
+2013-01-18 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_SHA256_H
-#define ZIP7_INC_SHA256_H
+#ifndef __CRYPTO_SHA256_H
+#define __CRYPTO_SHA256_H
 
 #include "7zTypes.h"
 
 EXTERN_C_BEGIN
 
-#define SHA256_NUM_BLOCK_WORDS  16
-#define SHA256_NUM_DIGEST_WORDS  8
-
-#define SHA256_BLOCK_SIZE   (SHA256_NUM_BLOCK_WORDS * 4)
-#define SHA256_DIGEST_SIZE  (SHA256_NUM_DIGEST_WORDS * 4)
-
-
-
-
-typedef void (Z7_FASTCALL *SHA256_FUNC_UPDATE_BLOCKS)(UInt32 state[8], const Byte *data, size_t numBlocks);
-
-/*
-  if (the system supports different SHA256 code implementations)
-  {
-    (CSha256::func_UpdateBlocks) will be used
-    (CSha256::func_UpdateBlocks) can be set by
-       Sha256_Init()        - to default (fastest)
-       Sha256_SetFunction() - to any algo
-  }
-  else
-  {
-    (CSha256::func_UpdateBlocks) is ignored.
-  }
-*/
+#define SHA256_DIGEST_SIZE 32
 
 typedef struct
 {
-  union
-  {
-    struct
-    {
-      SHA256_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
-      UInt64 count;
-    } vars;
-    UInt64 _pad_64bit[4];
-    void *_pad_align_ptr[2];
-  } v;
-  UInt32 state[SHA256_NUM_DIGEST_WORDS];
-
-  Byte buffer[SHA256_BLOCK_SIZE];
+  UInt32 state[8];
+  UInt64 count;
+  Byte buffer[64];
 } CSha256;
 
-
-#define SHA256_ALGO_DEFAULT 0
-#define SHA256_ALGO_SW      1
-#define SHA256_ALGO_HW      2
-
-/*
-Sha256_SetFunction()
-return:
-  0 - (algo) value is not supported, and func_UpdateBlocks was not changed
-  1 - func_UpdateBlocks was set according (algo) value.
-*/
-
-BoolInt Sha256_SetFunction(CSha256 *p, unsigned algo);
-
-void Sha256_InitState(CSha256 *p);
 void Sha256_Init(CSha256 *p);
 void Sha256_Update(CSha256 *p, const Byte *data, size_t size);
 void Sha256_Final(CSha256 *p, Byte *digest);
 
-
-
-
-// void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks);
-
-/*
-call Sha256Prepare() once at program start.
-It prepares all supported implementations, and detects the fastest implementation.
-*/
-
-void Sha256Prepare(void);
-
 EXTERN_C_END
 
 #endif