diff --git a/sha.cpp b/sha.cpp
index 72a82e61..cd0cdd5d 100644
--- a/sha.cpp
+++ b/sha.cpp
@@ -8,13 +8,21 @@
 
 // In August 2017 Walton reworked the internals to align all the implementations.
 //    Formerly all hashes were software based, IterHashBase handled endian conversions,
-//    IterHashBase repeatedly called the single block SHA{N}::Transform. The rework
-//    added SHA{N}::HashMultipleBlocks, and the SHA classes attempt to always use it.
-//    Now SHA{N}::Transform calls into SHA{N}::HashMultipleBlocks. An added wrinkle is
-//    hardware is little endian and software is big endian, so HashMultipleBlocks
-//    accepts a ByteOrder for the incoming data. Hardware based SHA{N}::HashMultipleBlocks
-//    can often perform the endian swap much easier by setting an EPI mask. The rework
-//    also removed the hacked-in pointers to implementations.
+//    and IterHashBase dispatched a single to block SHA{N}::Transform. SHA{N}::Transform
+//    then performed the single block hashing. It was repeated for multiple blocks.
+//
+//    The rework added SHA{N}::HashMultipleBlocks (class) and SHA{N}_HashMultipleBlocks
+//    (free standing). There are also hardware accelerated variations. Callers enter
+//    SHA{N}::HashMultipleBlocks (class), and the function calls SHA{N}_HashMultipleBlocks
+//    (free standing) or SHA{N}_HashBlock (free standing) as a fallback.
+//
+//    An added wrinkle is hardware is little endian, C++ is big endian, and callers use big endian,
+//    so SHA{N}_HashMultipleBlock accepts a ByteOrder for the incoming data arrangement. Hardware
+//    based SHA{N}_HashMultipleBlock can often perform the endian swap much easier by setting
+//    an EPI mask. Endian swap incurs no penalty on Intel SHA, and 4-instruction penaly on ARM SHA.
+//    Under C++ the full software based swap penalty is incurred due to use of ReverseBytes().
+//
+//    The rework also removed the hacked-in pointers to implementations.
 
 // use "cl /EP /P /DCRYPTOPP_GENERATE_X64_MASM sha.cpp" to generate MASM code
 
@@ -44,12 +52,17 @@
 #define M128_CAST(x) ((__m128i *)(void *)(x))
 #define CONST_M128_CAST(x) ((const __m128i *)(const void *)(x))
 
+// C++ makes const internal linkage
+#define EXPORT_TABLE extern
+
 NAMESPACE_BEGIN(CryptoPP)
 
 ////////////////////////////////
 // start of Steve Reid's code //
 ////////////////////////////////
 
+ANONYMOUS_NAMESPACE_BEGIN
+
 #define blk0(i) (W[i] = data[i])
 #define blk1(i) (W[i&15] = rotlFixed(W[(i+13)&15]^W[(i+8)&15]^W[(i+2)&15]^W[i&15],1))
 
@@ -65,7 +78,7 @@ NAMESPACE_BEGIN(CryptoPP)
 #define R3(v,w,x,y,z,i) z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rotlFixed(v,5);w=rotlFixed(w,30);
 #define R4(v,w,x,y,z,i) z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rotlFixed(v,5);w=rotlFixed(w,30);
 
-static void SHA1_CXX_HashBlock(word32 *state, const word32 *data)
+void SHA1_CXX_HashBlock(word32 *state, const word32 *data)
 {
     CRYPTOPP_ASSERT(state);
     CRYPTOPP_ASSERT(data);
@@ -106,6 +119,8 @@ static void SHA1_CXX_HashBlock(word32 *state, const word32 *data)
     state[4] += e;
 }
 
+ANONYMOUS_NAMESPACE_END
+
 //////////////////////////////
 // end of Steve Reid's code //
 //////////////////////////////
@@ -115,12 +130,15 @@ static void SHA1_CXX_HashBlock(word32 *state, const word32 *data)
 ///////////////////////////////////
 
 #if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
+
+ANONYMOUS_NAMESPACE_BEGIN
+
 // Based on http://software.intel.com/en-us/articles/intel-sha-extensions and code by Sean Gulley.
-static void SHA1_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
+void SHA1_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
 {
     CRYPTOPP_ASSERT(state);
     CRYPTOPP_ASSERT(data);
-    CRYPTOPP_ASSERT(length >= 64);
+    CRYPTOPP_ASSERT(length >= SHA1::BLOCKSIZE);
 
     __m128i ABCD, ABCD_SAVE, E0, E0_SAVE, E1;
     __m128i MASK, MSG0, MSG1, MSG2, MSG3;
@@ -137,7 +155,7 @@ static void SHA1_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, siz
            _mm_set_epi8(0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15) :
            _mm_set_epi8(3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12) ;
 
-    while (length >= 64)
+    while (length >= SHA1::BLOCKSIZE)
     {
         // Save current hash
         ABCD_SAVE = ABCD;
@@ -303,8 +321,8 @@ static void SHA1_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, siz
         E0 = _mm_sha1nexte_epu32(E0, E0_SAVE);
         ABCD = _mm_add_epi32(ABCD, ABCD_SAVE);
 
-        data += 16;
-        length -= 64;
+        data += SHA1::BLOCKSIZE/sizeof(word32);
+        length -= SHA1::BLOCKSIZE;
     }
 
     // Save state
@@ -312,7 +330,10 @@ static void SHA1_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, siz
     _mm_storeu_si128(M128_CAST(state), ABCD);
     state[4] = _mm_extract_epi32(E0, 3);
 }
-#endif
+
+ANONYMOUS_NAMESPACE_END
+
+#endif  // CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
 
 /////////////////////////////////
 // end of Walton/Gulley's code //
@@ -323,11 +344,14 @@ static void SHA1_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, siz
 //////////////////////////////////////////////////////////////
 
 #if CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
-static void SHA1_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
+
+ANONYMOUS_NAMESPACE_BEGIN
+
+void SHA1_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
 {
     CRYPTOPP_ASSERT(state);
     CRYPTOPP_ASSERT(data);
-    CRYPTOPP_ASSERT(length >= 64);
+    CRYPTOPP_ASSERT(length >= SHA1::BLOCKSIZE);
 
     uint32x4_t C0, C1, C2, C3;
     uint32x4_t ABCD, ABCD_SAVED;
@@ -344,7 +368,7 @@ static void SHA1_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data, s
     ABCD = vld1q_u32(&state[0]);
     E0 = state[4];
 
-    while (length >= 64)
+    while (length >= SHA1::BLOCKSIZE)
     {
         // Save current hash
         ABCD_SAVED = ABCD;
@@ -501,14 +525,17 @@ static void SHA1_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data, s
         E0 += E0_SAVED;
         ABCD = vaddq_u32(ABCD_SAVED, ABCD);
 
-        data += 16;
-        length -= 64;
+        data += SHA1::BLOCKSIZE/sizeof(word32);
+        length -= SHA1::BLOCKSIZE;
     }
 
     // Save state
     vst1q_u32(&state[0], ABCD);
     state[4] = E0;
 }
+
+ANONYMOUS_NAMESPACE_END
+
 #endif  // CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
 
 ///////////////////////////////////////////////////////
@@ -550,7 +577,7 @@ void SHA1::Transform(word32 *state, const word32 *data)
 size_t SHA1::HashMultipleBlocks(const word32 *input, size_t length)
 {
     CRYPTOPP_ASSERT(input);
-    CRYPTOPP_ASSERT(length >= 64);
+    CRYPTOPP_ASSERT(length >= SHA1::BLOCKSIZE);
 
 #if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
     if (HasSHA())
@@ -573,27 +600,25 @@ size_t SHA1::HashMultipleBlocks(const word32 *input, size_t length)
     {
         if (noReverse)
         {
-            // this->HashEndianCorrectedBlock(input);
             SHA1_CXX_HashBlock(m_state, input);
         }
         else
         {
-            ByteReverse(dataBuf, input, 64);
-            // this->HashEndianCorrectedBlock(dataBuf);
+            ByteReverse(dataBuf, input, SHA1::BLOCKSIZE);
             SHA1_CXX_HashBlock(m_state, dataBuf);
         }
 
-        input += 16;
-        length -= 64;
+        input += SHA1::BLOCKSIZE/sizeof(word32);
+        length -= SHA1::BLOCKSIZE;
     }
-    while (length >= 64);
+    while (length >= SHA1::BLOCKSIZE);
     return length;
 }
 
 // *************************************************************
 
-CRYPTOPP_ALIGN_DATA(16)
-extern const word32 SHA256_K[64] CRYPTOPP_SECTION_ALIGN16 = {
+CRYPTOPP_ALIGN_DATA(16) EXPORT_TABLE
+const word32 SHA256_K[64] CRYPTOPP_SECTION_ALIGN16 = {
 
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@@ -613,6 +638,8 @@ extern const word32 SHA256_K[64] CRYPTOPP_SECTION_ALIGN16 = {
     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 };
 
+ANONYMOUS_NAMESPACE_BEGIN
+
 #define blk2(i) (W[i&15]+=s1(W[(i-2)&15])+W[(i-7)&15]+s0(W[(i-15)&15]))
 
 #define Ch(x,y,z) (z^(x&(y^z)))
@@ -636,7 +663,7 @@ extern const word32 SHA256_K[64] CRYPTOPP_SECTION_ALIGN16 = {
 #define s0(x) (rotrFixed(x,7)^rotrFixed(x,18)^(x>>3))
 #define s1(x) (rotrFixed(x,17)^rotrFixed(x,19)^(x>>10))
 
-static void SHA256_CXX_HashBlock(word32 *state, const word32 *data)
+void SHA256_CXX_HashBlock(word32 *state, const word32 *data)
 {
     word32 W[16], T[8];
     /* Copy context->state[] to working vars */
@@ -666,6 +693,8 @@ static void SHA256_CXX_HashBlock(word32 *state, const word32 *data)
 #undef s1
 #undef R
 
+ANONYMOUS_NAMESPACE_END
+
 void SHA224::InitState(HashWordType *state)
 {
     static const word32 s[8] = {0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4};
@@ -677,11 +706,13 @@ void SHA256::InitState(HashWordType *state)
     static const word32 s[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
     memcpy(state, s, sizeof(s));
 }
-#endif // #ifndef CRYPTOPP_GENERATE_X64_MASM
+#endif // Not CRYPTOPP_GENERATE_X64_MASM
 
 #if (defined(CRYPTOPP_X86_ASM_AVAILABLE) || defined(CRYPTOPP_X32_ASM_AVAILABLE) || defined(CRYPTOPP_GENERATE_X64_MASM))
 
-static void CRYPTOPP_FASTCALL SHA256_SSE_HashMultipleBlocks(word32 *state, const word32 *data, size_t len)
+ANONYMOUS_NAMESPACE_BEGIN
+
+void CRYPTOPP_FASTCALL SHA256_SSE_HashMultipleBlocks(word32 *state, const word32 *data, size_t len)
 {
     #define LOCALS_SIZE  8*4 + 16*4 + 4*WORD_SZ
     #define H(i)         [BASE+ASM_MOD(1024+7-(i),8)*4]
@@ -1000,127 +1031,32 @@ INTEL_NOPREFIX
 #endif
 }
 
-#endif    // (defined(CRYPTOPP_X86_ASM_AVAILABLE) || defined(CRYPTOPP_GENERATE_X64_MASM))
+ANONYMOUS_NAMESPACE_END
+
+#endif    // CRYPTOPP_X86_ASM_AVAILABLE or CRYPTOPP_GENERATE_X64_MASM
 
 #ifndef CRYPTOPP_GENERATE_X64_MASM
 
 #ifdef CRYPTOPP_X64_MASM_AVAILABLE
-extern "C" {
+EXPORT_TABLE "C" {
 void CRYPTOPP_FASTCALL SHA256_SSE_HashMultipleBlocks(word32 *state, const word32 *data, size_t len);
 }
 #endif
 
-#if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
-static void SHA256_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order);
-#elif CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
-static void SHA256_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order);
-#endif
-
-size_t SHA256::HashMultipleBlocks(const word32 *input, size_t length)
-{
-    CRYPTOPP_ASSERT(input);
-    CRYPTOPP_ASSERT(length >= 64);
-
-#if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
-    if (HasSHA())
-    {
-        SHA256_SHANI_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
-        return length & (SHA256::BLOCKSIZE - 1);
-    }
-#endif
-#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
-    if (HasSSE2())
-    {
-        const size_t res = length & (SHA256::BLOCKSIZE - 1);
-        SHA256_SSE_HashMultipleBlocks(m_state, input, length-res);
-        return res;
-    }
-#endif
-#if CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
-    if (HasSHA2())
-    {
-        SHA256_ARM_SHA_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
-        return length & (SHA256::BLOCKSIZE - 1);
-    }
-#endif
-
-    const bool noReverse = NativeByteOrderIs(this->GetByteOrder());
-    word32 *dataBuf = this->DataBuf();
-    do
-    {
-        if (noReverse)
-        {
-            // this->HashEndianCorrectedBlock(input);
-            SHA256_CXX_HashBlock(m_state, input);
-        }
-        else
-        {
-            ByteReverse(dataBuf, input, SHA256::BLOCKSIZE);
-            // this->HashEndianCorrectedBlock(dataBuf);
-            SHA256_CXX_HashBlock(m_state, dataBuf);
-        }
-
-        input += SHA256::BLOCKSIZE/sizeof(word32);
-        length -= SHA256::BLOCKSIZE;
-    }
-    while (length >= SHA256::BLOCKSIZE);
-    return length;
-}
-
-size_t SHA224::HashMultipleBlocks(const word32 *input, size_t length)
-{
-    CRYPTOPP_ASSERT(input);
-    CRYPTOPP_ASSERT(length >= 64);
-
-#if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
-    if (HasSHA())
-    {
-        SHA256_SHANI_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
-        return length & (SHA256::BLOCKSIZE - 1);
-    }
-#endif
-#if CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
-    if (HasSHA2())
-    {
-        SHA256_ARM_SHA_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
-        return length & (SHA256::BLOCKSIZE - 1);
-    }
-#endif
-
-    const bool noReverse = NativeByteOrderIs(this->GetByteOrder());
-    word32 *dataBuf = this->DataBuf();
-    do
-    {
-        if (noReverse)
-        {
-            // this->HashEndianCorrectedBlock(input);
-            SHA256_CXX_HashBlock(m_state, input);
-        }
-        else
-        {
-            ByteReverse(dataBuf, input, SHA256::BLOCKSIZE);
-            // this->HashEndianCorrectedBlock(dataBuf);
-            SHA256_CXX_HashBlock(m_state, dataBuf);
-        }
-
-        input += SHA256::BLOCKSIZE/sizeof(word32);
-        length -= SHA256::BLOCKSIZE;
-    }
-    while (length >= SHA256::BLOCKSIZE);
-    return length;
-}
-
 ///////////////////////////////////
 // start of Walton/Gulley's code //
 ///////////////////////////////////
 
 #if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
+
+ANONYMOUS_NAMESPACE_BEGIN
+
 // Based on http://software.intel.com/en-us/articles/intel-sha-extensions and code by Sean Gulley.
-static void SHA256_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
+void SHA256_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
 {
     CRYPTOPP_ASSERT(state);
     CRYPTOPP_ASSERT(data);
-    CRYPTOPP_ASSERT(length >= 64);
+    CRYPTOPP_ASSERT(length >= SHA256::BLOCKSIZE);
 
     __m128i STATE0, STATE1;
     __m128i MSG, TMP, MASK;
@@ -1138,9 +1074,9 @@ static void SHA256_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, s
            _mm_set_epi8(12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3) :
            _mm_set_epi8(15,14,13,12, 11,10,9,8, 7,6,5,4, 3,2,1,0) ;
 
-    TMP = _mm_shuffle_epi32(TMP, 0xB1); // CDAB
-    STATE1 = _mm_shuffle_epi32(STATE1, 0x1B); // EFGH
-    STATE0 = _mm_alignr_epi8(TMP, STATE1, 8); // ABEF
+    TMP = _mm_shuffle_epi32(TMP, 0xB1);          // CDAB
+    STATE1 = _mm_shuffle_epi32(STATE1, 0x1B);    // EFGH
+    STATE0 = _mm_alignr_epi8(TMP, STATE1, 8);    // ABEF
     STATE1 = _mm_blend_epi16(STATE1, TMP, 0xF0); // CDGH
 
     while (length >= SHA256::BLOCKSIZE)
@@ -1309,15 +1245,18 @@ static void SHA256_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, s
         length -= SHA256::BLOCKSIZE;
     }
 
-    TMP = _mm_shuffle_epi32(STATE0, 0x1B); // FEBA
-    STATE1 = _mm_shuffle_epi32(STATE1, 0xB1); // DCHG
+    TMP = _mm_shuffle_epi32(STATE0, 0x1B);       // FEBA
+    STATE1 = _mm_shuffle_epi32(STATE1, 0xB1);    // DCHG
     STATE0 = _mm_blend_epi16(TMP, STATE1, 0xF0); // DCBA
-    STATE1 = _mm_alignr_epi8(STATE1, TMP, 8); // ABEF
+    STATE1 = _mm_alignr_epi8(STATE1, TMP, 8);    // ABEF
 
     // Save state
     _mm_storeu_si128(M128_CAST(&state[0]), STATE0);
     _mm_storeu_si128(M128_CAST(&state[4]), STATE1);
 }
+
+ANONYMOUS_NAMESPACE_END
+
 #endif  // CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
 
 /////////////////////////////////
@@ -1329,8 +1268,15 @@ static void SHA256_SHANI_HashMultipleBlocks(word32 *state, const word32 *data, s
 /////////////////////////////////////////////////////////
 
 #if CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
-static void SHA256_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
+
+ANONYMOUS_NAMESPACE_BEGIN
+
+void SHA256_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data, size_t length, ByteOrder order)
 {
+    CRYPTOPP_ASSERT(state);
+    CRYPTOPP_ASSERT(data);
+    CRYPTOPP_ASSERT(length >= SHA256::BLOCKSIZE);
+
     uint32x4_t STATE0, STATE1, ABEF_SAVE, CDGH_SAVE;
     uint32x4_t MSG0, MSG1, MSG2, MSG3;
     uint32x4_t TMP0, TMP1, TMP2;
@@ -1492,7 +1438,10 @@ static void SHA256_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data,
     vst1q_u32(&state[0], STATE0);
     vst1q_u32(&state[4], STATE1);
 }
-#endif
+
+ANONYMOUS_NAMESPACE_END
+
+#endif  // CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
 
 ///////////////////////////////////////////////////////
 // end of Walton/Schneiders/O'Rourke/Hovsmith's code //
@@ -1500,6 +1449,9 @@ static void SHA256_ARM_SHA_HashMultipleBlocks(word32 *state, const word32 *data,
 
 void SHA256::Transform(word32 *state, const word32 *data)
 {
+    CRYPTOPP_ASSERT(state);
+    CRYPTOPP_ASSERT(data);
+
 #if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
     if (HasSHA())
     {
@@ -1518,6 +1470,104 @@ void SHA256::Transform(word32 *state, const word32 *data)
     SHA256_CXX_HashBlock(state, data);
 }
 
+size_t SHA256::HashMultipleBlocks(const word32 *input, size_t length)
+{
+    CRYPTOPP_ASSERT(input);
+    CRYPTOPP_ASSERT(length >= SHA256::BLOCKSIZE);
+
+#if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
+    if (HasSHA())
+    {
+        SHA256_SHANI_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
+        return length & (SHA256::BLOCKSIZE - 1);
+    }
+#endif
+#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
+    if (HasSSE2())
+    {
+        const size_t res = length & (SHA256::BLOCKSIZE - 1);
+        SHA256_SSE_HashMultipleBlocks(m_state, input, length-res);
+        return res;
+    }
+#endif
+#if CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
+    if (HasSHA2())
+    {
+        SHA256_ARM_SHA_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
+        return length & (SHA256::BLOCKSIZE - 1);
+    }
+#endif
+
+    const bool noReverse = NativeByteOrderIs(this->GetByteOrder());
+    word32 *dataBuf = this->DataBuf();
+    do
+    {
+        if (noReverse)
+        {
+            SHA256_CXX_HashBlock(m_state, input);
+        }
+        else
+        {
+            ByteReverse(dataBuf, input, SHA256::BLOCKSIZE);
+            SHA256_CXX_HashBlock(m_state, dataBuf);
+        }
+
+        input += SHA256::BLOCKSIZE/sizeof(word32);
+        length -= SHA256::BLOCKSIZE;
+    }
+    while (length >= SHA256::BLOCKSIZE);
+    return length;
+}
+
+size_t SHA224::HashMultipleBlocks(const word32 *input, size_t length)
+{
+        CRYPTOPP_ASSERT(input);
+    CRYPTOPP_ASSERT(length >= SHA256::BLOCKSIZE);
+
+#if CRYPTOPP_BOOL_SSE_SHA_INTRINSICS_AVAILABLE
+    if (HasSHA())
+    {
+        SHA256_SHANI_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
+        return length & (SHA256::BLOCKSIZE - 1);
+    }
+#endif
+#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
+    if (HasSSE2())
+    {
+        const size_t res = length & (SHA256::BLOCKSIZE - 1);
+        SHA256_SSE_HashMultipleBlocks(m_state, input, length-res);
+        return res;
+    }
+#endif
+#if CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE
+    if (HasSHA2())
+    {
+        SHA256_ARM_SHA_HashMultipleBlocks(m_state, input, length, BIG_ENDIAN_ORDER);
+        return length & (SHA256::BLOCKSIZE - 1);
+    }
+#endif
+
+    const bool noReverse = NativeByteOrderIs(this->GetByteOrder());
+    word32 *dataBuf = this->DataBuf();
+    do
+    {
+        if (noReverse)
+        {
+            SHA256_CXX_HashBlock(m_state, input);
+        }
+        else
+        {
+            ByteReverse(dataBuf, input, SHA256::BLOCKSIZE);
+            SHA256_CXX_HashBlock(m_state, dataBuf);
+        }
+
+        input += SHA256::BLOCKSIZE/sizeof(word32);
+        length -= SHA256::BLOCKSIZE;
+    }
+    while (length >= SHA256::BLOCKSIZE);
+    return length;
+}
+
 // *************************************************************
 
 void SHA384::InitState(HashWordType *state)
@@ -1540,11 +1590,8 @@ void SHA512::InitState(HashWordType *state)
     memcpy(state, s, sizeof(s));
 }
 
-#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE && (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32)
-CRYPTOPP_ALIGN_DATA(16) static const word64 SHA512_K[80] CRYPTOPP_SECTION_ALIGN16 = {
-#else
-CRYPTOPP_ALIGN_DATA(16) static const word64 SHA512_K[80] CRYPTOPP_SECTION_ALIGN16 = {
-#endif
+CRYPTOPP_ALIGN_DATA(16)
+static const word64 SHA512_K[80] CRYPTOPP_SECTION_ALIGN16 = {
     W64LIT(0x428a2f98d728ae22), W64LIT(0x7137449123ef65cd),
     W64LIT(0xb5c0fbcfec4d3b2f), W64LIT(0xe9b5dba58189dbbc),
     W64LIT(0x3956c25bf348b538), W64LIT(0x59f111f1b605d019),
@@ -1588,8 +1635,10 @@ CRYPTOPP_ALIGN_DATA(16) static const word64 SHA512_K[80] CRYPTOPP_SECTION_ALIGN1
 };
 
 #if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE && (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32)
-// put assembly version in separate function, otherwise MSVC 2005 SP1 doesn't generate correct code for the non-assembly version
-CRYPTOPP_NAKED static void CRYPTOPP_FASTCALL SHA512_SSE2_Transform(word64 *state, const word64 *data)
+
+ANONYMOUS_NAMESPACE_BEGIN
+
+CRYPTOPP_NAKED void CRYPTOPP_FASTCALL SHA512_SSE2_Transform(word64 *state, const word64 *data)
 {
 #ifdef __GNUC__
     __asm__ __volatile__
@@ -1782,28 +1831,25 @@ CRYPTOPP_NAKED static void CRYPTOPP_FASTCALL SHA512_SSE2_Transform(word64 *state
     AS1(    ret)
 #endif
 }
-#endif    // #if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
 
-void SHA512::Transform(word64 *state, const word64 *data)
-{
-    CRYPTOPP_ASSERT(IsAlignedOn(state, GetAlignmentOf<word64>()));
-    CRYPTOPP_ASSERT(IsAlignedOn(data, GetAlignmentOf<word64>()));
+ANONYMOUS_NAMESPACE_END
 
-#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE && (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32)
-    if (HasSSE2())
-    {
-        SHA512_SSE2_Transform(state, data);
-        return;
-    }
-#endif
+#endif    // CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
+
+ANONYMOUS_NAMESPACE_BEGIN
 
 #define S0(x) (rotrFixed(x,28)^rotrFixed(x,34)^rotrFixed(x,39))
 #define S1(x) (rotrFixed(x,14)^rotrFixed(x,18)^rotrFixed(x,41))
 #define s0(x) (rotrFixed(x,1)^rotrFixed(x,8)^(x>>7))
 #define s1(x) (rotrFixed(x,19)^rotrFixed(x,61)^(x>>6))
 
-#define R(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+SHA512_K[i+j]+(j?blk2(i):blk0(i));\
-    d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i))
+#define R(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+SHA512_K[i+j]+\
+	(j?blk2(i):blk0(i));d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i))
+
+void SHA512_CXX_HashBlock(word64 *state, const word64 *data)
+{
+    CRYPTOPP_ASSERT(state);
+    CRYPTOPP_ASSERT(data);
 
     word64 W[16];
     word64 T[8];
@@ -1828,7 +1874,25 @@ void SHA512::Transform(word64 *state, const word64 *data)
     state[7] += h(0);
 }
 
+ANONYMOUS_NAMESPACE_END
+
+void SHA512::Transform(word64 *state, const word64 *data)
+{
+    CRYPTOPP_ASSERT(state);
+    CRYPTOPP_ASSERT(data);
+
+#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE && (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32)
+    if (HasSSE2())
+    {
+        SHA512_SSE2_Transform(state, data);
+        return;
+    }
+#endif
+
+    SHA512_CXX_HashBlock(state, data);
+}
+
 NAMESPACE_END
 
-#endif    // #ifndef CRYPTOPP_GENERATE_X64_MASM
-#endif    // #ifndef CRYPTOPP_IMPORTS
+#endif    // Not CRYPTOPP_GENERATE_X64_MASM
+#endif    // Not CRYPTOPP_IMPORTS
diff --git a/sha.h b/sha.h
index 30a859ac..0b2db7f3 100644
--- a/sha.h
+++ b/sha.h
@@ -2,7 +2,8 @@
 
 //! \file sha.h
 //! \brief Classes for SHA-1 and SHA-2 family of message digests
-//! \since SHA1 since Crypto++ 1.0, SHA2 since Crypto++ 4.0, Intel SHA extensions since Crypto++ 6.0
+//! \since SHA1 since Crypto++ 1.0, SHA2 since Crypto++ 4.0,
+//!   ARM SHA since Crypto++ 6.0, Intel SHA since Crypto++ 6.0
 
 #ifndef CRYPTOPP_SHA_H
 #define CRYPTOPP_SHA_H