summaryrefslogtreecommitdiffstats
path: root/CryptoPP
diff options
context:
space:
mode:
Diffstat (limited to 'CryptoPP')
-rw-r--r--CryptoPP/config.h4
-rw-r--r--CryptoPP/panama.cpp508
-rw-r--r--CryptoPP/panama.h144
-rw-r--r--CryptoPP/regtest.cpp145
4 files changed, 2 insertions, 799 deletions
diff --git a/CryptoPP/config.h b/CryptoPP/config.h
index ac8870694..93a79ed3d 100644
--- a/CryptoPP/config.h
+++ b/CryptoPP/config.h
@@ -16,12 +16,12 @@
// define this if you want to disable all OS-dependent features,
// such as sockets and OS-provided random number generators
-// #define NO_OS_DEPENDENCE
+#define NO_OS_DEPENDENCE
// Define this to use features provided by Microsoft's CryptoAPI.
// Currently the only feature used is random number generation.
// This macro will be ignored if NO_OS_DEPENDENCE is defined.
-#define USE_MS_CRYPTOAPI
+// #define USE_MS_CRYPTOAPI
// Define this to 1 to enforce the requirement in FIPS 186-2 Change Notice 1 that only 1024 bit moduli be used
#ifndef DSA_1024_BIT_MODULUS_ONLY
diff --git a/CryptoPP/panama.cpp b/CryptoPP/panama.cpp
deleted file mode 100644
index 09b1708f3..000000000
--- a/CryptoPP/panama.cpp
+++ /dev/null
@@ -1,508 +0,0 @@
-// panama.cpp - written and placed in the public domain by Wei Dai
-
-// use "cl /EP /P /DCRYPTOPP_GENERATE_X64_MASM panama.cpp" to generate MASM code
-
-#include "pch.h"
-
-#ifndef CRYPTOPP_GENERATE_X64_MASM
-
-#include "panama.h"
-#include "misc.h"
-#include "cpu.h"
-
-NAMESPACE_BEGIN(CryptoPP)
-
-template <class B>
-void Panama<B>::Reset()
-{
- memset(m_state, 0, m_state.SizeInBytes());
-#if CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE
- m_state[17] = HasSSSE3();
-#endif
-}
-
-#endif // #ifndef CRYPTOPP_GENERATE_X64_MASM
-
-#ifdef CRYPTOPP_X64_MASM_AVAILABLE
-extern "C" {
-void Panama_SSE2_Pull(size_t count, word32 *state, word32 *z, const word32 *y);
-}
-#elif CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
-
-#ifdef CRYPTOPP_GENERATE_X64_MASM
- Panama_SSE2_Pull PROC FRAME
- rex_push_reg rdi
- alloc_stack(2*16)
- save_xmm128 xmm6, 0h
- save_xmm128 xmm7, 10h
- .endprolog
-#else
-#pragma warning(disable: 4731) // frame pointer register 'ebp' modified by inline assembly code
-void CRYPTOPP_NOINLINE Panama_SSE2_Pull(size_t count, word32 *state, word32 *z, const word32 *y)
-{
-#ifdef CRYPTOPP_GNU_STYLE_INLINE_ASSEMBLY
- asm __volatile__
- (
- ".intel_syntax noprefix;"
- AS_PUSH_IF86( bx)
-#else
- AS2( mov AS_REG_1, count)
- AS2( mov AS_REG_2, state)
- AS2( mov AS_REG_3, z)
- AS2( mov AS_REG_4, y)
-#endif
-#endif // #ifdef CRYPTOPP_GENERATE_X64_MASM
-
-#if CRYPTOPP_BOOL_X86
- #define REG_loopEnd [esp]
-#elif defined(CRYPTOPP_GENERATE_X64_MASM)
- #define REG_loopEnd rdi
-#else
- #define REG_loopEnd r8
-#endif
-
- AS2( shl AS_REG_1, 5)
- ASJ( jz, 5, f)
- AS2( mov AS_REG_6d, [AS_REG_2+4*17])
- AS2( add AS_REG_1, AS_REG_6)
-
- #if CRYPTOPP_BOOL_X64
- AS2( mov REG_loopEnd, AS_REG_1)
- #else
- AS1( push ebp)
- AS1( push AS_REG_1)
- #endif
-
- AS2( movdqa xmm0, XMMWORD_PTR [AS_REG_2+0*16])
- AS2( movdqa xmm1, XMMWORD_PTR [AS_REG_2+1*16])
- AS2( movdqa xmm2, XMMWORD_PTR [AS_REG_2+2*16])
- AS2( movdqa xmm3, XMMWORD_PTR [AS_REG_2+3*16])
- AS2( mov eax, dword ptr [AS_REG_2+4*16])
-
- ASL(4)
- // gamma and pi
-#if CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE
- AS2( test AS_REG_6, 1)
- ASJ( jnz, 6, f)
-#endif
- AS2( movdqa xmm6, xmm2)
- AS2( movss xmm6, xmm3)
- ASS( pshufd xmm5, xmm6, 0, 3, 2, 1)
- AS2( movd xmm6, eax)
- AS2( movdqa xmm7, xmm3)
- AS2( movss xmm7, xmm6)
- ASS( pshufd xmm6, xmm7, 0, 3, 2, 1)
-#if CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE
- ASJ( jmp, 7, f)
- ASL(6)
- AS2( movdqa xmm5, xmm3)
- AS3( palignr xmm5, xmm2, 4)
- AS2( movd xmm6, eax)
- AS3( palignr xmm6, xmm3, 4)
- ASL(7)
-#endif
-
- AS2( movd AS_REG_1d, xmm2)
- AS1( not AS_REG_1d)
- AS2( movd AS_REG_7d, xmm3)
- AS2( or AS_REG_1d, AS_REG_7d)
- AS2( xor eax, AS_REG_1d)
-
-#define SSE2_Index(i) ASM_MOD(((i)*13+16), 17)
-
-#define pi(i) \
- AS2( movd AS_REG_1d, xmm7)\
- AS2( rol AS_REG_1d, ASM_MOD((ASM_MOD(5*i,17)*(ASM_MOD(5*i,17)+1)/2), 32))\
- AS2( mov [AS_REG_2+SSE2_Index(ASM_MOD(5*(i), 17))*4], AS_REG_1d)
-
-#define pi4(x, y, z, a, b, c, d) \
- AS2( pcmpeqb xmm7, xmm7)\
- AS2( pxor xmm7, x)\
- AS2( por xmm7, y)\
- AS2( pxor xmm7, z)\
- pi(a)\
- ASS( pshuflw xmm7, xmm7, 1, 0, 3, 2)\
- pi(b)\
- AS2( punpckhqdq xmm7, xmm7)\
- pi(c)\
- ASS( pshuflw xmm7, xmm7, 1, 0, 3, 2)\
- pi(d)
-
- pi4(xmm1, xmm2, xmm3, 1, 5, 9, 13)
- pi4(xmm0, xmm1, xmm2, 2, 6, 10, 14)
- pi4(xmm6, xmm0, xmm1, 3, 7, 11, 15)
- pi4(xmm5, xmm6, xmm0, 4, 8, 12, 16)
-
- // output keystream and update buffer here to hide partial memory stalls between pi and theta
- AS2( movdqa xmm4, xmm3)
- AS2( punpcklqdq xmm3, xmm2) // 1 5 2 6
- AS2( punpckhdq xmm4, xmm2) // 9 10 13 14
- AS2( movdqa xmm2, xmm1)
- AS2( punpcklqdq xmm1, xmm0) // 3 7 4 8
- AS2( punpckhdq xmm2, xmm0) // 11 12 15 16
-
- // keystream
- AS2( test AS_REG_3, AS_REG_3)
- ASJ( jz, 0, f)
- AS2( movdqa xmm6, xmm4)
- AS2( punpcklqdq xmm4, xmm2)
- AS2( punpckhqdq xmm6, xmm2)
- AS2( test AS_REG_4, 15)
- ASJ( jnz, 2, f)
- AS2( test AS_REG_4, AS_REG_4)
- ASJ( jz, 1, f)
- AS2( pxor xmm4, [AS_REG_4])
- AS2( pxor xmm6, [AS_REG_4+16])
- AS2( add AS_REG_4, 32)
- ASJ( jmp, 1, f)
- ASL(2)
- AS2( movdqu xmm0, [AS_REG_4])
- AS2( movdqu xmm2, [AS_REG_4+16])
- AS2( pxor xmm4, xmm0)
- AS2( pxor xmm6, xmm2)
- AS2( add AS_REG_4, 32)
- ASL(1)
- AS2( test AS_REG_3, 15)
- ASJ( jnz, 3, f)
- AS2( movdqa XMMWORD_PTR [AS_REG_3], xmm4)
- AS2( movdqa XMMWORD_PTR [AS_REG_3+16], xmm6)
- AS2( add AS_REG_3, 32)
- ASJ( jmp, 0, f)
- ASL(3)
- AS2( movdqu XMMWORD_PTR [AS_REG_3], xmm4)
- AS2( movdqu XMMWORD_PTR [AS_REG_3+16], xmm6)
- AS2( add AS_REG_3, 32)
- ASL(0)
-
- // buffer update
- AS2( lea AS_REG_1, [AS_REG_6 + 32])
- AS2( and AS_REG_1, 31*32)
- AS2( lea AS_REG_7, [AS_REG_6 + (32-24)*32])
- AS2( and AS_REG_7, 31*32)
-
- AS2( movdqa xmm0, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_1+0*8])
- AS2( pxor xmm3, xmm0)
- ASS( pshufd xmm0, xmm0, 2, 3, 0, 1)
- AS2( movdqa XMMWORD_PTR [AS_REG_2+20*4+AS_REG_1+0*8], xmm3)
- AS2( pxor xmm0, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_7+2*8])
- AS2( movdqa XMMWORD_PTR [AS_REG_2+20*4+AS_REG_7+2*8], xmm0)
-
- AS2( movdqa xmm4, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_1+2*8])
- AS2( pxor xmm1, xmm4)
- AS2( movdqa XMMWORD_PTR [AS_REG_2+20*4+AS_REG_1+2*8], xmm1)
- AS2( pxor xmm4, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_7+0*8])
- AS2( movdqa XMMWORD_PTR [AS_REG_2+20*4+AS_REG_7+0*8], xmm4)
-
- // theta
- AS2( movdqa xmm3, XMMWORD_PTR [AS_REG_2+3*16])
- AS2( movdqa xmm2, XMMWORD_PTR [AS_REG_2+2*16])
- AS2( movdqa xmm1, XMMWORD_PTR [AS_REG_2+1*16])
- AS2( movdqa xmm0, XMMWORD_PTR [AS_REG_2+0*16])
-
-#if CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE
- AS2( test AS_REG_6, 1)
- ASJ( jnz, 8, f)
-#endif
- AS2( movd xmm6, eax)
- AS2( movdqa xmm7, xmm3)
- AS2( movss xmm7, xmm6)
- AS2( movdqa xmm6, xmm2)
- AS2( movss xmm6, xmm3)
- AS2( movdqa xmm5, xmm1)
- AS2( movss xmm5, xmm2)
- AS2( movdqa xmm4, xmm0)
- AS2( movss xmm4, xmm1)
- ASS( pshufd xmm7, xmm7, 0, 3, 2, 1)
- ASS( pshufd xmm6, xmm6, 0, 3, 2, 1)
- ASS( pshufd xmm5, xmm5, 0, 3, 2, 1)
- ASS( pshufd xmm4, xmm4, 0, 3, 2, 1)
-#if CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE
- ASJ( jmp, 9, f)
- ASL(8)
- AS2( movd xmm7, eax)
- AS3( palignr xmm7, xmm3, 4)
- AS2( movq xmm6, xmm3)
- AS3( palignr xmm6, xmm2, 4)
- AS2( movq xmm5, xmm2)
- AS3( palignr xmm5, xmm1, 4)
- AS2( movq xmm4, xmm1)
- AS3( palignr xmm4, xmm0, 4)
- ASL(9)
-#endif
-
- AS2( xor eax, 1)
- AS2( movd AS_REG_1d, xmm0)
- AS2( xor eax, AS_REG_1d)
- AS2( movd AS_REG_1d, xmm3)
- AS2( xor eax, AS_REG_1d)
-
- AS2( pxor xmm3, xmm2)
- AS2( pxor xmm2, xmm1)
- AS2( pxor xmm1, xmm0)
- AS2( pxor xmm0, xmm7)
- AS2( pxor xmm3, xmm7)
- AS2( pxor xmm2, xmm6)
- AS2( pxor xmm1, xmm5)
- AS2( pxor xmm0, xmm4)
-
- // sigma
- AS2( lea AS_REG_1, [AS_REG_6 + (32-4)*32])
- AS2( and AS_REG_1, 31*32)
- AS2( lea AS_REG_7, [AS_REG_6 + 16*32])
- AS2( and AS_REG_7, 31*32)
-
- AS2( movdqa xmm4, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_1+0*16])
- AS2( movdqa xmm5, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_7+0*16])
- AS2( movdqa xmm6, xmm4)
- AS2( punpcklqdq xmm4, xmm5)
- AS2( punpckhqdq xmm6, xmm5)
- AS2( pxor xmm3, xmm4)
- AS2( pxor xmm2, xmm6)
-
- AS2( movdqa xmm4, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_1+1*16])
- AS2( movdqa xmm5, XMMWORD_PTR [AS_REG_2+20*4+AS_REG_7+1*16])
- AS2( movdqa xmm6, xmm4)
- AS2( punpcklqdq xmm4, xmm5)
- AS2( punpckhqdq xmm6, xmm5)
- AS2( pxor xmm1, xmm4)
- AS2( pxor xmm0, xmm6)
-
- // loop
- AS2( add AS_REG_6, 32)
- AS2( cmp AS_REG_6, REG_loopEnd)
- ASJ( jne, 4, b)
-
- // save state
- AS2( mov [AS_REG_2+4*16], eax)
- AS2( movdqa XMMWORD_PTR [AS_REG_2+3*16], xmm3)
- AS2( movdqa XMMWORD_PTR [AS_REG_2+2*16], xmm2)
- AS2( movdqa XMMWORD_PTR [AS_REG_2+1*16], xmm1)
- AS2( movdqa XMMWORD_PTR [AS_REG_2+0*16], xmm0)
-
- #if CRYPTOPP_BOOL_X86
- AS2( add esp, 4)
- AS1( pop ebp)
- #endif
- ASL(5)
-
-#ifdef CRYPTOPP_GNU_STYLE_INLINE_ASSEMBLY
- AS_POP_IF86( bx)
- ".att_syntax prefix;"
- :
- #if CRYPTOPP_BOOL_X64
- : "D" (count), "S" (state), "d" (z), "c" (y)
- : "%r8", "%r9", "r10", "%eax", "memory", "cc", "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7"
- #else
- : "c" (count), "d" (state), "S" (z), "D" (y)
- : "%eax", "memory", "cc"
- #endif
- );
-#endif
-#ifdef CRYPTOPP_GENERATE_X64_MASM
- movdqa xmm6, [rsp + 0h]
- movdqa xmm7, [rsp + 10h]
- add rsp, 2*16
- pop rdi
- ret
- Panama_SSE2_Pull ENDP
-#else
-}
-#endif
-#endif // #ifdef CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
-
-#ifndef CRYPTOPP_GENERATE_X64_MASM
-
-template <class B>
-void Panama<B>::Iterate(size_t count, const word32 *p, word32 *z, const word32 *y)
-{
- word32 bstart = m_state[17];
- word32 *const aPtr = m_state;
- word32 cPtr[17];
-
-#define bPtr ((byte *)(aPtr+20))
-
-// reorder the state for SSE2
-// a and c: 4 8 12 16 | 3 7 11 15 | 2 6 10 14 | 1 5 9 13 | 0
-// xmm0 xmm1 xmm2 xmm3 eax
-#define a(i) aPtr[((i)*13+16) % 17] // 13 is inverse of 4 mod 17
-#define c(i) cPtr[((i)*13+16) % 17]
-// b: 0 4 | 1 5 | 2 6 | 3 7
-#define b(i, j) b##i[(j)*2%8 + (j)/4]
-
-// output
-#define OA(i) z[i] = ConditionalByteReverse(B::ToEnum(), a(i+9))
-#define OX(i) z[i] = y[i] ^ ConditionalByteReverse(B::ToEnum(), a(i+9))
-// buffer update
-#define US(i) {word32 t=b(0,i); b(0,i)=ConditionalByteReverse(B::ToEnum(), p[i])^t; b(25,(i+6)%8)^=t;}
-#define UL(i) {word32 t=b(0,i); b(0,i)=a(i+1)^t; b(25,(i+6)%8)^=t;}
-// gamma and pi
-#define GP(i) c(5*i%17) = rotlFixed(a(i) ^ (a((i+1)%17) | ~a((i+2)%17)), ((5*i%17)*((5*i%17)+1)/2)%32)
-// theta and sigma
-#define T(i,x) a(i) = c(i) ^ c((i+1)%17) ^ c((i+4)%17) ^ x
-#define TS1S(i) T(i+1, ConditionalByteReverse(B::ToEnum(), p[i]))
-#define TS1L(i) T(i+1, b(4,i))
-#define TS2(i) T(i+9, b(16,i))
-
- while (count--)
- {
- if (z)
- {
- if (y)
- {
- OX(0); OX(1); OX(2); OX(3); OX(4); OX(5); OX(6); OX(7);
- y += 8;
- }
- else
- {
- OA(0); OA(1); OA(2); OA(3); OA(4); OA(5); OA(6); OA(7);
- }
- z += 8;
- }
-
- word32 *const b16 = (word32 *)(bPtr+((bstart+16*32) & 31*32));
- word32 *const b4 = (word32 *)(bPtr+((bstart+(32-4)*32) & 31*32));
- bstart += 32;
- word32 *const b0 = (word32 *)(bPtr+((bstart) & 31*32));
- word32 *const b25 = (word32 *)(bPtr+((bstart+(32-25)*32) & 31*32));
-
- if (p)
- {
- US(0); US(1); US(2); US(3); US(4); US(5); US(6); US(7);
- }
- else
- {
- UL(0); UL(1); UL(2); UL(3); UL(4); UL(5); UL(6); UL(7);
- }
-
- GP(0);
- GP(1);
- GP(2);
- GP(3);
- GP(4);
- GP(5);
- GP(6);
- GP(7);
- GP(8);
- GP(9);
- GP(10);
- GP(11);
- GP(12);
- GP(13);
- GP(14);
- GP(15);
- GP(16);
-
- T(0,1);
-
- if (p)
- {
- TS1S(0); TS1S(1); TS1S(2); TS1S(3); TS1S(4); TS1S(5); TS1S(6); TS1S(7);
- p += 8;
- }
- else
- {
- TS1L(0); TS1L(1); TS1L(2); TS1L(3); TS1L(4); TS1L(5); TS1L(6); TS1L(7);
- }
-
- TS2(0); TS2(1); TS2(2); TS2(3); TS2(4); TS2(5); TS2(6); TS2(7);
- }
- m_state[17] = bstart;
-}
-
-namespace Weak {
-template <class B>
-size_t PanamaHash<B>::HashMultipleBlocks(const word32 *input, size_t length)
-{
- this->Iterate(length / this->BLOCKSIZE, input);
- return length % this->BLOCKSIZE;
-}
-
-template <class B>
-void PanamaHash<B>::TruncatedFinal(byte *hash, size_t size)
-{
- this->ThrowIfInvalidTruncatedSize(size);
-
- PadLastBlock(this->BLOCKSIZE, 0x01);
-
- HashEndianCorrectedBlock(this->m_data);
-
- this->Iterate(32); // pull
-
- FixedSizeSecBlock<word32, 8> buf;
- this->Iterate(1, NULL, buf, NULL);
-
- memcpy(hash, buf, size);
-
- this->Restart(); // reinit for next use
-}
-}
-
-template <class B>
-void PanamaCipherPolicy<B>::CipherSetKey(const NameValuePairs &params, const byte *key, size_t length)
-{
- assert(length==32);
- memcpy(m_key, key, 32);
-}
-
-template <class B>
-void PanamaCipherPolicy<B>::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)
-{
- assert(length==32);
- this->Reset();
- this->Iterate(1, m_key);
- if (iv && IsAligned<word32>(iv))
- this->Iterate(1, (const word32 *)iv);
- else
- {
- FixedSizeSecBlock<word32, 8> buf;
- if (iv)
- memcpy(buf, iv, 32);
- else
- memset(buf, 0, 32);
- this->Iterate(1, buf);
- }
-
-#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE || defined(CRYPTOPP_X64_MASM_AVAILABLE)
- if (B::ToEnum() == LITTLE_ENDIAN_ORDER && HasSSE2() && !IsP4()) // SSE2 code is slower on P4 Prescott
- Panama_SSE2_Pull(32, this->m_state, NULL, NULL);
- else
-#endif
- this->Iterate(32);
-}
-
-#if CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X64
-template <class B>
-unsigned int PanamaCipherPolicy<B>::GetAlignment() const
-{
-#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE || defined(CRYPTOPP_X64_MASM_AVAILABLE)
- if (B::ToEnum() == LITTLE_ENDIAN_ORDER && HasSSE2())
- return 16;
- else
-#endif
- return 1;
-}
-#endif
-
-template <class B>
-void PanamaCipherPolicy<B>::OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)
-{
-#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE || defined(CRYPTOPP_X64_MASM_AVAILABLE)
- if (B::ToEnum() == LITTLE_ENDIAN_ORDER && HasSSE2())
- Panama_SSE2_Pull(iterationCount, this->m_state, (word32 *)output, (const word32 *)input);
- else
-#endif
- this->Iterate(iterationCount, NULL, (word32 *)output, (const word32 *)input);
-}
-
-template class Panama<BigEndian>;
-template class Panama<LittleEndian>;
-
-template class Weak::PanamaHash<BigEndian>;
-template class Weak::PanamaHash<LittleEndian>;
-
-template class PanamaCipherPolicy<BigEndian>;
-template class PanamaCipherPolicy<LittleEndian>;
-
-NAMESPACE_END
-
-#endif // #ifndef CRYPTOPP_GENERATE_X64_MASM
diff --git a/CryptoPP/panama.h b/CryptoPP/panama.h
deleted file mode 100644
index 5a2368137..000000000
--- a/CryptoPP/panama.h
+++ /dev/null
@@ -1,144 +0,0 @@
-#ifndef CRYPTOPP_PANAMA_H
-#define CRYPTOPP_PANAMA_H
-
-#include "strciphr.h"
-#include "iterhash.h"
-
-NAMESPACE_BEGIN(CryptoPP)
-
-/// base class, do not use directly
-template <class B>
-class CRYPTOPP_NO_VTABLE Panama
-{
-public:
- void Reset();
- void Iterate(size_t count, const word32 *p=NULL, word32 *z=NULL, const word32 *y=NULL);
-
-protected:
- typedef word32 Stage[8];
- CRYPTOPP_CONSTANT(STAGES = 32)
-
- FixedSizeAlignedSecBlock<word32, 20 + 8*32> m_state;
-};
-
-namespace Weak {
-/// <a href="http://www.weidai.com/scan-mirror/md.html#Panama">Panama Hash</a>
-template <class B = LittleEndian>
-class PanamaHash : protected Panama<B>, public AlgorithmImpl<IteratedHash<word32, NativeByteOrder, 32>, PanamaHash<B> >
-{
-public:
- CRYPTOPP_CONSTANT(DIGESTSIZE = 32)
- PanamaHash() {Panama<B>::Reset();}
- unsigned int DigestSize() const {return DIGESTSIZE;}
- void TruncatedFinal(byte *hash, size_t size);
- static const char * StaticAlgorithmName() {return B::ToEnum() == BIG_ENDIAN_ORDER ? "Panama-BE" : "Panama-LE";}
-
-protected:
- void Init() {Panama<B>::Reset();}
- void HashEndianCorrectedBlock(const word32 *data) {this->Iterate(1, data);} // push
- size_t HashMultipleBlocks(const word32 *input, size_t length);
- word32* StateBuf() {return NULL;}
-};
-}
-
-//! MAC construction using a hermetic hash function
-template <class T_Hash, class T_Info = T_Hash>
-class HermeticHashFunctionMAC : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<MessageAuthenticationCode, VariableKeyLength<32, 0, INT_MAX> > >, T_Info>
-{
-public:
- void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params)
- {
- m_key.Assign(key, length);
- Restart();
- }
-
- void Restart()
- {
- m_hash.Restart();
- m_keyed = false;
- }
-
- void Update(const byte *input, size_t length)
- {
- if (!m_keyed)
- KeyHash();
- m_hash.Update(input, length);
- }
-
- void TruncatedFinal(byte *digest, size_t digestSize)
- {
- if (!m_keyed)
- KeyHash();
- m_hash.TruncatedFinal(digest, digestSize);
- m_keyed = false;
- }
-
- unsigned int DigestSize() const
- {return m_hash.DigestSize();}
- unsigned int BlockSize() const
- {return m_hash.BlockSize();}
- unsigned int OptimalBlockSize() const
- {return m_hash.OptimalBlockSize();}
- unsigned int OptimalDataAlignment() const
- {return m_hash.OptimalDataAlignment();}
-
-protected:
- void KeyHash()
- {
- m_hash.Update(m_key, m_key.size());
- m_keyed = true;
- }
-
- T_Hash m_hash;
- bool m_keyed;
- SecByteBlock m_key;
-};
-
-namespace Weak {
-/// Panama MAC
-template <class B = LittleEndian>
-class PanamaMAC : public HermeticHashFunctionMAC<PanamaHash<B> >
-{
-public:
- PanamaMAC() {}
- PanamaMAC(const byte *key, unsigned int length)
- {this->SetKey(key, length);}
-};
-}
-
-//! algorithm info
-template <class B>
-struct PanamaCipherInfo : public FixedKeyLength<32, SimpleKeyingInterface::UNIQUE_IV, 32>
-{
- static const char * StaticAlgorithmName() {return B::ToEnum() == BIG_ENDIAN_ORDER ? "Panama-BE" : "Panama-LE";}
-};
-
-//! _
-template <class B>
-class PanamaCipherPolicy : public AdditiveCipherConcretePolicy<word32, 8>,
- public PanamaCipherInfo<B>,
- protected Panama<B>
-{
-protected:
- void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length);
- void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount);
- bool CipherIsRandomAccess() const {return false;}
- void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length);
-#if CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X64
- unsigned int GetAlignment() const;
-#endif
-
- FixedSizeSecBlock<word32, 8> m_key;
-};
-
-//! <a href="http://www.cryptolounge.org/wiki/PANAMA">Panama Stream Cipher</a>
-template <class B = LittleEndian>
-struct PanamaCipher : public PanamaCipherInfo<B>, public SymmetricCipherDocumentation
-{
- typedef SymmetricCipherFinal<ConcretePolicyHolder<PanamaCipherPolicy<B>, AdditiveCipherTemplate<> >, PanamaCipherInfo<B> > Encryption;
- typedef Encryption Decryption;
-};
-
-NAMESPACE_END
-
-#endif
diff --git a/CryptoPP/regtest.cpp b/CryptoPP/regtest.cpp
deleted file mode 100644
index 49afcb69d..000000000
--- a/CryptoPP/regtest.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#include "factory.h"
-
-#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
-#include "modes.h"
-#include "dh.h"
-#include "esign.h"
-#include "md2.h"
-#include "rw.h"
-#include "md5.h"
-#include "rsa.h"
-#include "ripemd.h"
-#include "dsa.h"
-#include "seal.h"
-#include "whrlpool.h"
-#include "ttmac.h"
-#include "camellia.h"
-#include "shacal2.h"
-#include "tea.h"
-#include "panama.h"
-#include "pssr.h"
-#include "aes.h"
-#include "salsa.h"
-#include "vmac.h"
-#include "tiger.h"
-#include "md5.h"
-#include "sosemanuk.h"
-#include "arc4.h"
-#include "ccm.h"
-#include "gcm.h"
-#include "eax.h"
-#include "twofish.h"
-#include "serpent.h"
-#include "cast.h"
-#include "rc6.h"
-#include "mars.h"
-#include "shacal2.h"
-#include "des.h"
-#include "idea.h"
-#include "rc5.h"
-#include "tea.h"
-#include "skipjack.h"
-#include "cmac.h"
-#include "dmac.h"
-#include "blowfish.h"
-#include "seed.h"
-#include "wake.h"
-#include "seal.h"
-#include "crc.h"
-#include "adler32.h"
-
-USING_NAMESPACE(CryptoPP)
-
-void RegisterFactories()
-{
- static bool s_registered = false;
- if (s_registered)
- return;
-
- RegisterDefaultFactoryFor<SimpleKeyAgreementDomain, DH>();
- RegisterDefaultFactoryFor<HashTransformation, CRC32>();
- RegisterDefaultFactoryFor<HashTransformation, Adler32>();
- RegisterDefaultFactoryFor<HashTransformation, Weak::MD5>();
- RegisterDefaultFactoryFor<HashTransformation, SHA1>();
- RegisterDefaultFactoryFor<HashTransformation, SHA224>();
- RegisterDefaultFactoryFor<HashTransformation, SHA256>();
- RegisterDefaultFactoryFor<HashTransformation, SHA384>();
- RegisterDefaultFactoryFor<HashTransformation, SHA512>();
- RegisterDefaultFactoryFor<HashTransformation, Whirlpool>();
- RegisterDefaultFactoryFor<HashTransformation, Tiger>();
- RegisterDefaultFactoryFor<HashTransformation, RIPEMD160>();
- RegisterDefaultFactoryFor<HashTransformation, RIPEMD320>();
- RegisterDefaultFactoryFor<HashTransformation, RIPEMD128>();
- RegisterDefaultFactoryFor<HashTransformation, RIPEMD256>();
- RegisterDefaultFactoryFor<HashTransformation, Weak::PanamaHash<LittleEndian> >();
- RegisterDefaultFactoryFor<HashTransformation, Weak::PanamaHash<BigEndian> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, HMAC<Weak::MD5> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, HMAC<SHA1> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, HMAC<RIPEMD160> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, HMAC<SHA224> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, HMAC<SHA256> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, HMAC<SHA384> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, HMAC<SHA512> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, TTMAC>();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, VMAC<AES> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, VMAC<AES, 64> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, Weak::PanamaMAC<LittleEndian> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, Weak::PanamaMAC<BigEndian> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, CMAC<AES> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, DMAC<AES> >();
- RegisterDefaultFactoryFor<MessageAuthenticationCode, CMAC<DES_EDE3> >();
- RegisterAsymmetricCipherDefaultFactories<RSAES<OAEP<SHA1> > >("RSA/OAEP-MGF1(SHA-1)");
- RegisterAsymmetricCipherDefaultFactories<DLIES<> >("DLIES(NoCofactorMultiplication, KDF2(SHA-1), XOR, HMAC(SHA-1), DHAES)");
- RegisterSignatureSchemeDefaultFactories<DSA>("DSA(1363)");
- RegisterSignatureSchemeDefaultFactories<NR<SHA1> >("NR(1363)/EMSA1(SHA-1)");
- RegisterSignatureSchemeDefaultFactories<GDSA<SHA1> >("DSA-1363/EMSA1(SHA-1)");
- RegisterSignatureSchemeDefaultFactories<RSASS<PKCS1v15, Weak::MD2> >("RSA/PKCS1-1.5(MD2)");
- RegisterSignatureSchemeDefaultFactories<RSASS<PKCS1v15, SHA1> >("RSA/PKCS1-1.5(SHA-1)");
- RegisterSignatureSchemeDefaultFactories<ESIGN<SHA1> >("ESIGN/EMSA5-MGF1(SHA-1)");
- RegisterSignatureSchemeDefaultFactories<RWSS<P1363_EMSA2, SHA1> >("RW/EMSA2(SHA-1)");
- RegisterSignatureSchemeDefaultFactories<RSASS<PSS, SHA1> >("RSA/PSS-MGF1(SHA-1)");
- RegisterSymmetricCipherDefaultFactories<SEAL<> >();
- RegisterSymmetricCipherDefaultFactories<ECB_Mode<SHACAL2> >();
- RegisterSymmetricCipherDefaultFactories<ECB_Mode<Camellia> >();
- RegisterSymmetricCipherDefaultFactories<ECB_Mode<TEA> >();
- RegisterSymmetricCipherDefaultFactories<ECB_Mode<XTEA> >();
- RegisterSymmetricCipherDefaultFactories<PanamaCipher<LittleEndian> >();
- RegisterSymmetricCipherDefaultFactories<PanamaCipher<BigEndian> >();
- RegisterSymmetricCipherDefaultFactories<ECB_Mode<AES> >();
- RegisterSymmetricCipherDefaultFactories<CBC_Mode<AES> >();
- RegisterSymmetricCipherDefaultFactories<CFB_Mode<AES> >();
- RegisterSymmetricCipherDefaultFactories<OFB_Mode<AES> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<AES> >();
- RegisterSymmetricCipherDefaultFactories<Salsa20>();
- RegisterSymmetricCipherDefaultFactories<XSalsa20>();
- RegisterSymmetricCipherDefaultFactories<Sosemanuk>();
- RegisterSymmetricCipherDefaultFactories<Weak::MARC4>();
- RegisterSymmetricCipherDefaultFactories<WAKE_OFB<LittleEndian> >();
- RegisterSymmetricCipherDefaultFactories<WAKE_OFB<BigEndian> >();
- RegisterSymmetricCipherDefaultFactories<SEAL<LittleEndian> >();
- RegisterAuthenticatedSymmetricCipherDefaultFactories<CCM<AES> >();
- RegisterAuthenticatedSymmetricCipherDefaultFactories<GCM<AES> >();
- RegisterAuthenticatedSymmetricCipherDefaultFactories<EAX<AES> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<Camellia> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<Twofish> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<Serpent> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<CAST256> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<RC6> >();
- RegisterSymmetricCipherDefaultFactories<ECB_Mode<MARS> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<MARS> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<SHACAL2> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<DES> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<DES_XEX3> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<DES_EDE3> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<IDEA> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<RC5> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<TEA> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<XTEA> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<CAST128> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<SKIPJACK> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<Blowfish> >();
- RegisterSymmetricCipherDefaultFactories<ECB_Mode<SEED> >();
- RegisterSymmetricCipherDefaultFactories<CTR_Mode<SEED> >();
-
- s_registered = true;
-}