5 #define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1 56 #if (CRYPTOPP_MSC_VERSION >= 1410) 57 # pragma strict_gs_check (on) 63 bool ValidateAll(
bool thorough)
65 bool pass=TestSettings();
66 pass=TestOS_RNG() && pass;
67 pass=TestAutoSeeded() && pass;
69 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 70 pass=TestRDRAND() && pass;
71 pass=TestRDSEED() && pass;
74 #if !defined(NDEBUG) && !defined(CRYPTOPP_IMPORTS) 76 pass=TestSecBlock() && pass;
78 pass=TestPolynomialMod2() && pass;
81 pass=ValidateCRC32() && pass;
82 pass=ValidateAdler32() && pass;
83 pass=ValidateMD2() && pass;
84 pass=ValidateMD5() && pass;
85 pass=ValidateSHA() && pass;
86 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/sha3.txt") && pass;
87 pass=ValidateTiger() && pass;
88 pass=ValidateRIPEMD() && pass;
89 pass=ValidatePanama() && pass;
90 pass=ValidateWhirlpool() && pass;
92 pass=ValidateHMAC() && pass;
93 pass=ValidateTTMAC() && pass;
95 pass=ValidatePBKDF() && pass;
96 pass=ValidateHKDF() && pass;
98 pass=ValidateDES() && pass;
99 pass=ValidateCipherModes() && pass;
100 pass=ValidateIDEA() && pass;
101 pass=ValidateSAFER() && pass;
102 pass=ValidateRC2() && pass;
103 pass=ValidateARC4() && pass;
104 pass=ValidateRC5() && pass;
105 pass=ValidateBlowfish() && pass;
106 pass=ValidateThreeWay() && pass;
107 pass=ValidateGOST() && pass;
108 pass=ValidateSHARK() && pass;
109 pass=ValidateCAST() && pass;
110 pass=ValidateSquare() && pass;
111 pass=ValidateSKIPJACK() && pass;
112 pass=ValidateSEAL() && pass;
113 pass=ValidateRC6() && pass;
114 pass=ValidateMARS() && pass;
115 pass=ValidateRijndael() && pass;
116 pass=ValidateTwofish() && pass;
117 pass=ValidateSerpent() && pass;
118 pass=ValidateSHACAL2() && pass;
119 pass=ValidateCamellia() && pass;
120 pass=ValidateSalsa() && pass;
121 pass=ValidateSosemanuk() && pass;
122 pass=ValidateVMAC() && pass;
123 pass=ValidateCCM() && pass;
124 pass=ValidateGCM() && pass;
125 pass=ValidateCMAC() && pass;
126 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/eax.txt") && pass;
127 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/seed.txt") && pass;
129 pass=ValidateBBS() && pass;
130 pass=ValidateDH() && pass;
131 pass=ValidateMQV() && pass;
132 pass=ValidateRSA() && pass;
133 pass=ValidateElGamal() && pass;
134 pass=ValidateDLIES() && pass;
135 pass=ValidateNR() && pass;
136 pass=ValidateDSA(thorough) && pass;
137 pass=ValidateLUC() && pass;
138 pass=ValidateLUC_DH() && pass;
139 pass=ValidateLUC_DL() && pass;
140 pass=ValidateXTR_DH() && pass;
141 pass=ValidateRabin() && pass;
142 pass=ValidateRW() && pass;
144 pass=ValidateECP() && pass;
145 pass=ValidateEC2N() && pass;
146 pass=ValidateECDSA() && pass;
147 pass=ValidateESIGN() && pass;
150 cout <<
"\nAll tests passed!\n";
152 cout <<
"\nOops! Not all tests passed.\n";
160 #if defined(__MINGW32__) 166 cout <<
"\nTesting Settings...\n\n";
169 memcpy_s(&w,
sizeof(w),
"\x01\x02\x03\x04", 4);
171 if (w == 0x04030201L)
173 #ifdef IS_LITTLE_ENDIAN 179 cout <<
"Your machine is little endian.\n";
181 else if (w == 0x01020304L)
183 #ifndef IS_LITTLE_ENDIAN 189 cout <<
"Your machine is big endian.\n";
193 cout <<
"FAILED: Your machine is neither big endian nor little endian.\n";
197 #ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS 198 byte testvals[10] = {1,2,2,3,3,3,3,2,2,1};
199 if (*(word32 *)(testvals+3) == 0x03030303 && *(word64 *)(testvals+1) == W64LIT(0x0202030303030202))
200 cout <<
"passed: Your machine allows unaligned data access.\n";
203 cout <<
"FAILED: Unaligned data access gave incorrect results.\n";
207 cout <<
"passed: CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS is not defined. Will restrict to aligned data access.\n";
210 if (
sizeof(byte) == 1)
217 cout <<
"sizeof(byte) == " <<
sizeof(byte) << endl;
219 if (
sizeof(word16) == 2)
226 cout <<
"sizeof(word16) == " <<
sizeof(word16) << endl;
228 if (
sizeof(word32) == 4)
235 cout <<
"sizeof(word32) == " <<
sizeof(word32) << endl;
237 if (
sizeof(word64) == 8)
244 cout <<
"sizeof(word64) == " <<
sizeof(word64) << endl;
246 #ifdef CRYPTOPP_WORD128_AVAILABLE 247 if (
sizeof(word128) == 16)
254 cout <<
"sizeof(word128) == " <<
sizeof(word128) << endl;
257 if (
sizeof(word) == 2*
sizeof(hword)
258 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
259 &&
sizeof(dword) == 2*
sizeof(word)
268 cout <<
"sizeof(hword) == " <<
sizeof(hword) <<
", sizeof(word) == " <<
sizeof(word);
269 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE 270 cout <<
", sizeof(dword) == " <<
sizeof(dword);
274 #ifdef CRYPTOPP_CPUID_AVAILABLE 275 bool hasMMX = HasMMX();
276 bool hasISSE = HasISSE();
277 bool hasSSE2 = HasSSE2();
278 bool hasSSSE3 = HasSSSE3();
280 int cacheLineSize = GetCacheLineSize();
282 if ((isP4 && (!hasMMX || !hasSSE2)) || (hasSSE2 && !hasMMX) || (cacheLineSize < 16 || cacheLineSize > 256 || !
IsPowerOf2(cacheLineSize)))
290 cout <<
"hasMMX == " << hasMMX <<
", hasISSE == " << hasISSE <<
", hasSSE2 == " << hasSSE2 <<
", hasSSSE3 == " << hasSSSE3 <<
", hasAESNI == " << HasAESNI() <<
", hasRDRAND == " << HasRDRAND() <<
", hasRDSEED == " << HasRDSEED() <<
", hasCLMUL == " << HasCLMUL() <<
", isP4 == " << isP4 <<
", cacheLineSize == " << cacheLineSize;
291 cout <<
", AESNI_INTRINSICS == " << CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE << endl;
296 cout <<
"Some critical setting in config.h is in error. Please fix it and recompile." << endl;
302 #if !defined(NDEBUG) && !defined(CRYPTOPP_IMPORTS) 306 cout <<
"\nTesting SecBlock...\n\n";
307 bool r1 =
true, r2 =
true, r3 =
true;
308 bool r4 =
true, r5 =
true, r6 =
true;
315 a.
Assign((
const byte*)
"a", 1);
316 b.
Assign((
const byte*)
"b", 1);
323 a.
Assign((
const byte*)
"ab", 2);
324 b.
Assign((
const byte*)
"cd", 2);
328 r1 &= (a[0] ==
'a' && a[1] ==
'b');
329 r1 &= (b[0] ==
'c' && b[1] ==
'd');
340 cout <<
" Assign byte" << endl;
345 word32 one[1] = {1}, two[1] = {2};
355 word32 three[2] = {1,2}, four[2] = {3,4};
362 r2 &= (a[0] == 1 && a[1] == 2);
363 r2 &= (b[0] == 3 && b[1] == 4);
374 cout <<
" Assign word32" << endl;
381 a.
Assign((
const byte*)
"a", 1);
382 b.
Assign((
const byte*)
"b", 1);
386 r3 &= (a[0] ==
'a' && a[1] ==
'b');
388 a.
Assign((
const byte*)
"ab", 2);
389 b.
Assign((
const byte*)
"cd", 2);
393 r3 &= (a[0] ==
'a' && a[1] ==
'b' && a[2] ==
'c' && a[3] ==
'd');
395 a.
Assign((
const byte*)
"a", 1);
399 r3 &= (a[0] ==
'a' && a[1] ==
'a');
401 a.
Assign((
const byte*)
"ab", 2);
405 r3 &= (a[0] ==
'a' && a[1] ==
'b' && a[2] ==
'a' && a[3] ==
'b');
416 cout <<
" Append byte" << endl;
421 word32 one[1] = {1}, two[1] = {2};
428 r4 &= (a[0] == 1 && a[1] == 2);
430 word32 three[2] = {1,2}, four[2] = {3,4};
437 r4 &= (a[0] == 1 && a[1] == 2 && a[2] == 3 && a[3] == 4);
443 r4 &= (a[0] == 1 && a[1] == 1);
449 r4 &= (a[0] == 1 && a[1] == 2 && a[2] == 1 && a[3] == 2);
461 cout <<
" Append word32" << endl;
468 a.
Assign((
const byte*)
"a", 1);
469 b.
Assign((
const byte*)
"b", 1);
475 r5 &= (c[0] ==
'a' && c[1] ==
'b');
477 a.
Assign((
const byte*)
"ab", 2);
478 b.Assign((
const byte*)
"cd", 2);
481 r5 &= (a[0] ==
'a' && a[1] ==
'b');
482 r5 &= (b[0] ==
'c' && b[1] ==
'd');
484 r5 &= (c[0] ==
'a' && c[1] ==
'b' && c[2] ==
'c' && c[3] ==
'd');
495 cout <<
" Concatenate byte" << endl;
500 word32 one[1] = {1}, two[1] = {2};
509 r6 &= (c[0] == 1 && c[1] == 2);
511 word32 three[2] = {1,2}, four[2] = {3,4};
517 r6 &= (a[0] == 1 && a[1] == 2);
518 r6 &= (b[0] == 3 && b[1] == 4);
520 r6 &= (c[0] == 1 && c[1] == 2 && c[2] == 3 && c[3] == 4);
531 cout <<
" Concatenate word32" << endl;
534 return r1 && r2 && r3 && r4 && r5 && r6;
544 #ifdef BLOCKING_RNG_AVAILABLE 551 cout <<
"\nTesting operating system provided blocking random number generator...\n\n";
555 unsigned long total=0, length=0;
556 time_t t = time(NULL), t1 = 0;
557 CRYPTOPP_UNUSED(length);
560 while (total < 16 && (t1 < 10 || total*8 > (
unsigned long)t1))
574 cout <<
" it took " << long(t1) <<
" seconds to generate " << total <<
" bytes" << endl;
576 #if 0 // disable this part. it's causing an unpredictable pause during the validation testing 582 while (time(NULL) - t < 2)
591 while (time(NULL) - t < 2)
604 cout <<
" it generated " << length <<
" bytes in " << long(time(NULL) - t) <<
" seconds" << endl;
608 test.AttachedTransformation()->MessageEnd();
610 if (meter.GetTotalBytes() < total)
617 cout <<
" " << total <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
620 cout <<
"\nNo operating system provided blocking random number generator, skipping test." << endl;
623 #ifdef NONBLOCKING_RNG_AVAILABLE 630 cout <<
"\nTesting operating system provided nonblocking random number generator...\n\n";
635 if (meter.GetTotalBytes() < 100000)
642 cout <<
" 100000 generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
645 cout <<
"\nNo operating system provided nonblocking random number generator, skipping test." << endl;
651 bool TestAutoSeeded()
656 bool TestAutoSeeded()
659 cout <<
"\nTesting AutoSeeded generator...\n\n";
662 bool generate =
true, discard =
true;
667 if (meter.GetTotalBytes() < 100000)
674 cout <<
" 100000 generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
689 cout <<
" discarded 10000 bytes" << endl;
691 return generate && discard;
693 #endif // NO_OS_DEPENDENCE 695 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 699 bool maurer =
true, generate =
true, discard =
true;
700 static const unsigned int SIZE = 10000;
704 cout <<
"\nTesting RDRAND generator...\n\n";
713 const double mv = mt.GetTestValue();
722 const std::streamsize oldp = cout.precision(5);
723 const std::ios::fmtflags oldf = cout.setf(std::ios::fixed, std::ios::floatfield);
724 cout <<
" Maurer Randomness Test value of " << mv << endl;
725 cout.precision(oldp);
726 cout.setf(oldf, std::ios::floatfield);
731 if (meter.GetTotalBytes() < SIZE)
738 cout <<
" " << SIZE <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE\n";
753 cout <<
" discarded " << SIZE <<
" bytes\n";
756 cout <<
"\nRDRAND generator not available, skipping test.\n";
758 if (!(maurer && generate && discard))
761 return maurer && generate && discard;
765 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 769 bool maurer =
true, generate =
true, discard =
true;
770 static const unsigned int SIZE = 10000;
774 cout <<
"\nTesting RDSEED generator...\n\n";
783 const double mv = mt.GetTestValue();
792 const std::streamsize oldp = cout.precision(5);
793 const std::ios::fmtflags oldf = cout.setf(std::ios::fixed, std::ios::floatfield);
794 cout <<
" Maurer Randomness Test value of " << mv << endl;
795 cout.precision(oldp);
796 cout.setf(oldf, std::ios::floatfield);
801 if (meter.GetTotalBytes() < SIZE)
808 cout <<
" " << SIZE <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE\n";
823 cout <<
" discarded " << SIZE <<
" bytes\n";
826 cout <<
"\nRDSEED generator not available, skipping test.\n";
828 if (!(maurer && generate && discard))
831 return maurer && generate && discard;
836 typedef auto_ptr<BlockTransformation> apbt;
841 virtual unsigned int BlockSize()
const =0;
842 virtual unsigned int KeyLength()
const =0;
844 virtual apbt NewEncryption(
const byte *key)
const =0;
845 virtual apbt NewDecryption(
const byte *key)
const =0;
852 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
853 unsigned int KeyLength()
const {
return m_keylen;}
855 apbt NewEncryption(
const byte *key)
const 856 {
return apbt(
new E(key, m_keylen));}
857 apbt NewDecryption(
const byte *key)
const 858 {
return apbt(
new D(key, m_keylen));}
860 unsigned int m_keylen;
867 : m_keylen(keylen ? keylen : E::DEFAULT_KEYLENGTH), m_rounds(rounds ? rounds : E::DEFAULT_ROUNDS) {}
868 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
869 unsigned int KeyLength()
const {
return m_keylen;}
871 apbt NewEncryption(
const byte *key)
const 872 {
return apbt(
new E(key, m_keylen, m_rounds));}
873 apbt NewDecryption(
const byte *key)
const 874 {
return apbt(
new D(key, m_keylen, m_rounds));}
876 unsigned int m_keylen, m_rounds;
882 SecByteBlock plain(cg.BlockSize()), cipher(cg.BlockSize()), out(cg.BlockSize()), outplain(cg.BlockSize());
884 bool pass=
true, fail;
888 valdata.
Get(key, cg.KeyLength());
889 valdata.
Get(plain, cg.BlockSize());
890 valdata.
Get(cipher, cg.BlockSize());
892 apbt transE = cg.NewEncryption(key);
893 transE->ProcessBlock(plain, out);
894 fail = memcmp(out, cipher, cg.BlockSize()) != 0;
896 apbt transD = cg.NewDecryption(key);
897 transD->ProcessBlock(out, outplain);
898 fail=fail || memcmp(outplain, plain, cg.BlockSize());
900 pass = pass && !fail;
902 cout << (fail ?
"FAILED " :
"passed ");
903 output.
Put(key, cg.KeyLength());
905 output.
Put(outplain, cg.BlockSize());
907 output.
Put(out, cg.BlockSize());
917 : validOutput(validOutput), outputLen(outputLen), counter(0), fail(
false) {}
918 void PutByte(byte inByte)
920 if (counter >= outputLen || validOutput[counter] != inByte)
922 std::cerr <<
"incorrect output " << counter <<
", " << (word16)validOutput[counter] <<
", " << (word16)inByte <<
"\n";
928 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
930 CRYPTOPP_UNUSED(messageEnd), CRYPTOPP_UNUSED(blocking);
933 FilterTester::PutByte(*inString++);
936 if (counter != outputLen)
949 const byte *validOutput;
950 size_t outputLen, counter;
962 bt.
Put(in, randomLen);
967 return ft->GetResult();
972 cout <<
"\nDES validation suite running...\n\n";
977 cout <<
"\nTesting EDE2, EDE3, and XEX3 variants...\n\n";
995 for (
unsigned int i=1; i<20480; i*=2)
1009 if (!TestFilter(filter, plaintext, length, plaintext, length))
1016 bool ValidateCipherModes()
1018 cout <<
"\nTesting DES modes...\n\n";
1019 const byte key[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
1020 const byte iv[] = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
1021 const byte plain[] = {
1022 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
1023 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
1024 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20};
1027 bool pass=
true, fail;
1031 const byte encrypted[] = {
1032 0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15,
1033 0x6a, 0x27, 0x17, 0x87, 0xab, 0x88, 0x83, 0xf9,
1034 0x89, 0x3d, 0x51, 0xec, 0x4b, 0x56, 0x3b, 0x53};
1038 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1039 pass = pass && !fail;
1040 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB encryption" << endl;
1044 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1045 pass = pass && !fail;
1046 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB decryption" << endl;
1050 const byte encrypted[] = {
1051 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
1052 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
1053 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6};
1057 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1058 pass = pass && !fail;
1059 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with no padding" << endl;
1063 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1064 pass = pass && !fail;
1065 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with no padding" << endl;
1067 fail = !TestModeIV(modeE, modeD);
1068 pass = pass && !fail;
1069 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC mode IV generation" << endl;
1074 const byte encrypted[] = {
1075 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
1076 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
1077 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
1078 0x62, 0xC1, 0x6A, 0x27, 0xE4, 0xFC, 0xF2, 0x77};
1082 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1083 pass = pass && !fail;
1084 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with PKCS #7 padding" << endl;
1088 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1089 pass = pass && !fail;
1090 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with PKCS #7 padding" << endl;
1095 const byte encrypted[] = {
1096 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
1097 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
1098 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
1099 0xcf, 0xb7, 0xc7, 0x64, 0x0e, 0x7c, 0xd9, 0xa7};
1103 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1104 pass = pass && !fail;
1105 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with one-and-zeros padding" << endl;
1109 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1110 pass = pass && !fail;
1111 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with one-and-zeros padding" << endl;
1114 const byte plain_1[] = {
'a', 0, 0, 0, 0, 0, 0, 0};
1116 const byte encrypted[] = {
1117 0x9B, 0x47, 0x57, 0x59, 0xD6, 0x9C, 0xF6, 0xD0};
1121 plain_1, 1, encrypted,
sizeof(encrypted));
1122 pass = pass && !fail;
1123 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with zeros padding" << endl;
1127 encrypted,
sizeof(encrypted), plain_1,
sizeof(plain_1));
1128 pass = pass && !fail;
1129 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with zeros padding" << endl;
1134 const byte encrypted[] = {
1135 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
1136 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
1137 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F};
1141 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1142 pass = pass && !fail;
1143 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext stealing (CTS)" << endl;
1147 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1148 pass = pass && !fail;
1149 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext stealing (CTS)" << endl;
1151 fail = !TestModeIV(modeE, modeD);
1152 pass = pass && !fail;
1153 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC CTS IV generation" << endl;
1157 const byte decryptionIV[] = {0x4D, 0xD0, 0xAC, 0x8F, 0x47, 0xCF, 0x79, 0xCE};
1158 const byte encrypted[] = {0x12, 0x34, 0x56};
1163 modeE.SetStolenIV(stolenIV);
1165 plain, 3, encrypted,
sizeof(encrypted));
1166 fail = memcmp(stolenIV, decryptionIV, 8) != 0 || fail;
1167 pass = pass && !fail;
1168 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext and IV stealing" << endl;
1172 encrypted,
sizeof(encrypted), plain, 3);
1173 pass = pass && !fail;
1174 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext and IV stealing" << endl;
1177 const byte encrypted[] = {
1178 0xF3,0x09,0x62,0x49,0xC7,0xF4,0x6E,0x51,
1179 0xA6,0x9E,0x83,0x9B,0x1A,0x92,0xF7,0x84,
1180 0x03,0x46,0x71,0x33,0x89,0x8E,0xA6,0x22};
1184 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1185 pass = pass && !fail;
1186 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB encryption" << endl;
1190 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1191 pass = pass && !fail;
1192 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB decryption" << endl;
1194 fail = !TestModeIV(modeE, modeD);
1195 pass = pass && !fail;
1196 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB mode IV generation" << endl;
1199 const byte plain_2[] = {
1200 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
1201 const byte encrypted[] = {
1202 0xf3,0x1f,0xda,0x07,0x01,0x14,0x62,0xee,0x18,0x7f};
1206 plain_2,
sizeof(plain_2), encrypted,
sizeof(encrypted));
1207 pass = pass && !fail;
1208 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) encryption" << endl;
1212 encrypted,
sizeof(encrypted), plain_2,
sizeof(plain_2));
1213 pass = pass && !fail;
1214 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) decryption" << endl;
1216 fail = !TestModeIV(modeE, modeD);
1217 pass = pass && !fail;
1218 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) IV generation" << endl;
1221 const byte encrypted[] = {
1222 0xf3,0x09,0x62,0x49,0xc7,0xf4,0x6e,0x51,
1223 0x35,0xf2,0x4a,0x24,0x2e,0xeb,0x3d,0x3f,
1224 0x3d,0x6d,0x5b,0xe3,0x25,0x5a,0xf8,0xc3};
1228 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1229 pass = pass && !fail;
1230 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB encryption" << endl;
1234 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1235 pass = pass && !fail;
1236 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB decryption" << endl;
1238 fail = !TestModeIV(modeE, modeD);
1239 pass = pass && !fail;
1240 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB IV generation" << endl;
1243 const byte encrypted[] = {
1244 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51,
1245 0x16, 0x3A, 0x8C, 0xA0, 0xFF, 0xC9, 0x4C, 0x27,
1246 0xFA, 0x2F, 0x80, 0xF4, 0x80, 0xB8, 0x6F, 0x75};
1250 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1251 pass = pass && !fail;
1252 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode encryption" << endl;
1256 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1257 pass = pass && !fail;
1258 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode decryption" << endl;
1260 fail = !TestModeIV(modeE, modeD);
1261 pass = pass && !fail;
1262 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode IV generation" << endl;
1265 const byte plain_3[] = {
1266 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1267 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1268 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
1269 0x66, 0x6f, 0x72, 0x20};
1270 const byte mac1[] = {
1271 0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
1272 const byte mac2[] = {
1273 0x35, 0x80, 0xC5, 0xC4, 0x6B, 0x81, 0x24, 0xE2};
1277 fail = !TestFilter(cbcmacFilter, plain_3,
sizeof(plain_3), mac1,
sizeof(mac1));
1278 pass = pass && !fail;
1279 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC MAC" << endl;
1283 fail = !TestFilter(dmacFilter, plain_3,
sizeof(plain_3), mac2,
sizeof(mac2));
1284 pass = pass && !fail;
1285 cout << (fail ?
"FAILED " :
"passed ") <<
"DMAC" << endl;
1290 fail = !TestModeIV(modeE, modeD);
1291 pass = pass && !fail;
1292 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CTR Mode" << endl;
1297 fail = !TestModeIV(modeE, modeD);
1298 pass = pass && !fail;
1299 cout << (fail ?
"FAILED " :
"passed ") <<
"AES OFB Mode" << endl;
1304 fail = !TestModeIV(modeE, modeD);
1305 pass = pass && !fail;
1306 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CFB Mode" << endl;
1311 fail = !TestModeIV(modeE, modeD);
1312 pass = pass && !fail;
1313 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CBC Mode" << endl;
1321 cout <<
"\nIDEA validation suite running...\n\n";
1327 bool ValidateSAFER()
1329 cout <<
"\nSAFER validation suite running...\n\n";
1342 cout <<
"\nRC2 validation suite running...\n\n";
1346 SecByteBlock plain(RC2Encryption::BLOCKSIZE), cipher(RC2Encryption::BLOCKSIZE), out(RC2Encryption::BLOCKSIZE), outplain(RC2Encryption::BLOCKSIZE);
1348 bool pass=
true, fail;
1352 byte keyLen, effectiveLen;
1354 valdata.
Get(keyLen);
1355 valdata.
Get(effectiveLen);
1356 valdata.
Get(key, keyLen);
1357 valdata.
Get(plain, RC2Encryption::BLOCKSIZE);
1358 valdata.
Get(cipher, RC2Encryption::BLOCKSIZE);
1361 transE->ProcessBlock(plain, out);
1362 fail = memcmp(out, cipher, RC2Encryption::BLOCKSIZE) != 0;
1365 transD->ProcessBlock(out, outplain);
1366 fail=fail || memcmp(outplain, plain, RC2Encryption::BLOCKSIZE);
1368 pass = pass && !fail;
1370 cout << (fail ?
"FAILED " :
"passed ");
1371 output.
Put(key, keyLen);
1373 output.
Put(outplain, RC2Encryption::BLOCKSIZE);
1375 output.
Put(out, RC2Encryption::BLOCKSIZE);
1383 unsigned char Key0[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
1384 unsigned char Input0[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
1385 unsigned char Output0[] = {0x75,0xb7,0x87,0x80,0x99,0xe0,0xc5,0x96};
1387 unsigned char Key1[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
1388 unsigned char Input1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1389 unsigned char Output1[]={0x74,0x94,0xc2,0xe7,0x10,0x4b,0x08,0x79};
1391 unsigned char Key2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1392 unsigned char Input2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1393 unsigned char Output2[]={0xde,0x18,0x89,0x41,0xa3,0x37,0x5d,0x3a};
1395 unsigned char Key3[]={0xef,0x01,0x23,0x45};
1396 unsigned char Input3[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1397 unsigned char Output3[]={0xd6,0xa1,0x41,0xa7,0xec,0x3c,0x38,0xdf,0xbd,0x61};
1399 unsigned char Key4[]={ 0x01,0x23,0x45,0x67,0x89,0xab, 0xcd,0xef };
1400 unsigned char Input4[] =
1401 {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1402 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1403 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1404 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1405 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1406 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1407 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1408 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1409 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1410 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1411 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1412 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1413 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1414 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1415 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1416 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1417 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1418 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1419 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1420 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1421 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1422 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1423 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1424 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1425 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1426 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1427 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1428 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1429 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1430 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1431 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1432 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1433 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1434 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1435 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1436 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1437 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1438 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1439 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1440 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1441 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1442 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1443 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1444 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1445 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1446 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1447 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1448 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1449 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1450 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1451 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1453 unsigned char Output4[]= {
1454 0x75,0x95,0xc3,0xe6,0x11,0x4a,0x09,0x78,0x0c,0x4a,0xd4,
1455 0x52,0x33,0x8e,0x1f,0xfd,0x9a,0x1b,0xe9,0x49,0x8f,
1456 0x81,0x3d,0x76,0x53,0x34,0x49,0xb6,0x77,0x8d,0xca,
1457 0xd8,0xc7,0x8a,0x8d,0x2b,0xa9,0xac,0x66,0x08,0x5d,
1458 0x0e,0x53,0xd5,0x9c,0x26,0xc2,0xd1,0xc4,0x90,0xc1,
1459 0xeb,0xbe,0x0c,0xe6,0x6d,0x1b,0x6b,0x1b,0x13,0xb6,
1460 0xb9,0x19,0xb8,0x47,0xc2,0x5a,0x91,0x44,0x7a,0x95,
1461 0xe7,0x5e,0x4e,0xf1,0x67,0x79,0xcd,0xe8,0xbf,0x0a,
1462 0x95,0x85,0x0e,0x32,0xaf,0x96,0x89,0x44,0x4f,0xd3,
1463 0x77,0x10,0x8f,0x98,0xfd,0xcb,0xd4,0xe7,0x26,0x56,
1464 0x75,0x00,0x99,0x0b,0xcc,0x7e,0x0c,0xa3,0xc4,0xaa,
1465 0xa3,0x04,0xa3,0x87,0xd2,0x0f,0x3b,0x8f,0xbb,0xcd,
1466 0x42,0xa1,0xbd,0x31,0x1d,0x7a,0x43,0x03,0xdd,0xa5,
1467 0xab,0x07,0x88,0x96,0xae,0x80,0xc1,0x8b,0x0a,0xf6,
1468 0x6d,0xff,0x31,0x96,0x16,0xeb,0x78,0x4e,0x49,0x5a,
1469 0xd2,0xce,0x90,0xd7,0xf7,0x72,0xa8,0x17,0x47,0xb6,
1470 0x5f,0x62,0x09,0x3b,0x1e,0x0d,0xb9,0xe5,0xba,0x53,
1471 0x2f,0xaf,0xec,0x47,0x50,0x83,0x23,0xe6,0x71,0x32,
1472 0x7d,0xf9,0x44,0x44,0x32,0xcb,0x73,0x67,0xce,0xc8,
1473 0x2f,0x5d,0x44,0xc0,0xd0,0x0b,0x67,0xd6,0x50,0xa0,
1474 0x75,0xcd,0x4b,0x70,0xde,0xdd,0x77,0xeb,0x9b,0x10,
1475 0x23,0x1b,0x6b,0x5b,0x74,0x13,0x47,0x39,0x6d,0x62,
1476 0x89,0x74,0x21,0xd4,0x3d,0xf9,0xb4,0x2e,0x44,0x6e,
1477 0x35,0x8e,0x9c,0x11,0xa9,0xb2,0x18,0x4e,0xcb,0xef,
1478 0x0c,0xd8,0xe7,0xa8,0x77,0xef,0x96,0x8f,0x13,0x90,
1479 0xec,0x9b,0x3d,0x35,0xa5,0x58,0x5c,0xb0,0x09,0x29,
1480 0x0e,0x2f,0xcd,0xe7,0xb5,0xec,0x66,0xd9,0x08,0x4b,
1481 0xe4,0x40,0x55,0xa6,0x19,0xd9,0xdd,0x7f,0xc3,0x16,
1482 0x6f,0x94,0x87,0xf7,0xcb,0x27,0x29,0x12,0x42,0x64,
1483 0x45,0x99,0x85,0x14,0xc1,0x5d,0x53,0xa1,0x8c,0x86,
1484 0x4c,0xe3,0xa2,0xb7,0x55,0x57,0x93,0x98,0x81,0x26,
1485 0x52,0x0e,0xac,0xf2,0xe3,0x06,0x6e,0x23,0x0c,0x91,
1486 0xbe,0xe4,0xdd,0x53,0x04,0xf5,0xfd,0x04,0x05,0xb3,
1487 0x5b,0xd9,0x9c,0x73,0x13,0x5d,0x3d,0x9b,0xc3,0x35,
1488 0xee,0x04,0x9e,0xf6,0x9b,0x38,0x67,0xbf,0x2d,0x7b,
1489 0xd1,0xea,0xa5,0x95,0xd8,0xbf,0xc0,0x06,0x6f,0xf8,
1490 0xd3,0x15,0x09,0xeb,0x0c,0x6c,0xaa,0x00,0x6c,0x80,
1491 0x7a,0x62,0x3e,0xf8,0x4c,0x3d,0x33,0xc1,0x95,0xd2,
1492 0x3e,0xe3,0x20,0xc4,0x0d,0xe0,0x55,0x81,0x57,0xc8,
1493 0x22,0xd4,0xb8,0xc5,0x69,0xd8,0x49,0xae,0xd5,0x9d,
1494 0x4e,0x0f,0xd7,0xf3,0x79,0x58,0x6b,0x4b,0x7f,0xf6,
1495 0x84,0xed,0x6a,0x18,0x9f,0x74,0x86,0xd4,0x9b,0x9c,
1496 0x4b,0xad,0x9b,0xa2,0x4b,0x96,0xab,0xf9,0x24,0x37,
1497 0x2c,0x8a,0x8f,0xff,0xb1,0x0d,0x55,0x35,0x49,0x00,
1498 0xa7,0x7a,0x3d,0xb5,0xf2,0x05,0xe1,0xb9,0x9f,0xcd,
1499 0x86,0x60,0x86,0x3a,0x15,0x9a,0xd4,0xab,0xe4,0x0f,
1500 0xa4,0x89,0x34,0x16,0x3d,0xdd,0xe5,0x42,0xa6,0x58,
1501 0x55,0x40,0xfd,0x68,0x3c,0xbf,0xd8,0xc0,0x0f,0x12,
1502 0x12,0x9a,0x28,0x4d,0xea,0xcc,0x4c,0xde,0xfe,0x58,
1503 0xbe,0x71,0x37,0x54,0x1c,0x04,0x71,0x26,0xc8,0xd4,
1504 0x9e,0x27,0x55,0xab,0x18,0x1a,0xb7,0xe9,0x40,0xb0,
1509 bool pass=
true, fail;
1512 cout <<
"\nARC4 validation suite running...\n\n";
1514 arc4.reset(
new Weak::ARC4(Key0,
sizeof(Key0)));
1515 arc4->ProcessString(Input0,
sizeof(Input0));
1516 fail = memcmp(Input0, Output0,
sizeof(Input0)) != 0;
1517 cout << (fail ?
"FAILED" :
"passed") <<
" Test 0" << endl;
1518 pass = pass && !fail;
1520 arc4.reset(
new Weak::ARC4(Key1,
sizeof(Key1)));
1521 arc4->ProcessString(Key1, Input1,
sizeof(Key1));
1522 fail = memcmp(Output1, Key1,
sizeof(Key1)) != 0;
1523 cout << (fail ?
"FAILED" :
"passed") <<
" Test 1" << endl;
1524 pass = pass && !fail;
1526 arc4.reset(
new Weak::ARC4(Key2,
sizeof(Key2)));
1527 for (i=0, fail=
false; i<
sizeof(Input2); i++)
1528 if (arc4->ProcessByte(Input2[i]) != Output2[i])
1530 cout << (fail ?
"FAILED" :
"passed") <<
" Test 2" << endl;
1531 pass = pass && !fail;
1533 arc4.reset(
new Weak::ARC4(Key3,
sizeof(Key3)));
1534 for (i=0, fail=
false; i<
sizeof(Input3); i++)
1535 if (arc4->ProcessByte(Input3[i]) != Output3[i])
1537 cout << (fail ?
"FAILED" :
"passed") <<
" Test 3" << endl;
1538 pass = pass && !fail;
1540 arc4.reset(
new Weak::ARC4(Key4,
sizeof(Key4)));
1541 for (i=0, fail=
false; i<
sizeof(Input4); i++)
1542 if (arc4->ProcessByte(Input4[i]) != Output4[i])
1544 cout << (fail ?
"FAILED" :
"passed") <<
" Test 4" << endl;
1545 pass = pass && !fail;
1552 cout <<
"\nRC5 validation suite running...\n\n";
1560 cout <<
"\nRC6 validation suite running...\n\n";
1572 cout <<
"\nMARS validation suite running...\n\n";
1582 bool ValidateRijndael()
1584 cout <<
"\nRijndael (AES) validation suite running...\n\n";
1591 pass = RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/aes.txt") && pass;
1595 bool ValidateTwofish()
1597 cout <<
"\nTwofish validation suite running...\n\n";
1607 bool ValidateSerpent()
1609 cout <<
"\nSerpent validation suite running...\n\n";
1619 bool ValidateBlowfish()
1621 cout <<
"\nBlowfish validation suite running...\n\n";
1624 const char *key[]={
"abcdefghijklmnopqrstuvwxyz",
"Who is John Galt?"};
1625 byte *plain[]={(byte *)
"BLOWFISH", (byte *)
"\xfe\xdc\xba\x98\x76\x54\x32\x10"};
1626 byte *cipher[]={(byte *)
"\x32\x4e\xd0\xfe\xf4\x13\xa2\x03", (byte *)
"\xcc\x91\x73\x2b\x80\x22\xf6\x84"};
1627 byte out[8], outplain[8];
1628 bool pass=
true, fail;
1630 for (
int i=0; i<2; i++)
1633 enc.ProcessData(out, plain[i], 8);
1634 fail = memcmp(out, cipher[i], 8) != 0;
1637 dec.ProcessData(outplain, cipher[i], 8);
1638 fail = fail || memcmp(outplain, plain[i], 8);
1639 pass = pass && !fail;
1641 cout << (fail ?
"FAILED " :
"passed ");
1642 cout <<
'\"' << key[i] <<
'\"';
1643 for (
int j=0; j<(
signed int)(30-strlen(key[i])); j++)
1645 output.
Put(outplain, 8);
1653 bool ValidateThreeWay()
1655 cout <<
"\n3-WAY validation suite running...\n\n";
1663 cout <<
"\nGOST validation suite running...\n\n";
1669 bool ValidateSHARK()
1671 cout <<
"\nSHARK validation suite running...\n\n";
1681 cout <<
"\nCAST-128 validation suite running...\n\n";
1688 cout <<
"\nCAST-256 validation suite running...\n\n";
1698 bool ValidateSquare()
1700 cout <<
"\nSquare validation suite running...\n\n";
1706 bool ValidateSKIPJACK()
1708 cout <<
"\nSKIPJACK validation suite running...\n\n";
1716 byte input[] = {0x37,0xa0,0x05,0x95,0x9b,0x84,0xc4,0x9c,0xa4,0xbe,0x1e,0x05,0x06,0x73,0x53,0x0f,0x5f,0xb0,0x97,0xfd,0xf6,0xa1,0x3f,0xbd,0x6c,0x2c,0xde,0xcd,0x81,0xfd,0xee,0x7c};
1718 byte key[] = {0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba, 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0};
1719 byte iv[] = {0x01, 0x35, 0x77, 0xaf};
1721 cout <<
"\nSEAL validation suite running...\n\n";
1724 unsigned int size =
sizeof(input);
1727 memset(output, 1, size);
1728 seal.ProcessString(output, input, size);
1729 for (
unsigned int i=0; i<size; i++)
1734 output[1] = seal.ProcessByte(output[1]);
1735 seal.ProcessString(output+2, size-2);
1736 pass = pass && memcmp(output+1, input+1, size-1) == 0;
1738 cout << (pass ?
"passed" :
"FAILED") << endl;
1742 bool ValidateBaseCode()
1744 bool pass =
true, fail;
1746 for (
unsigned int i=0; i<255; i++)
1748 static const char hexEncoded[] =
1749 "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627" 1750 "28292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F" 1751 "505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F7071727374757677" 1752 "78797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F" 1753 "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7" 1754 "C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF" 1755 "F0F1F2F3F4F5F6F7F8F9FAFBFCFDFE";
1756 static const char base32Encoded[] =
1757 "AAASEA2EAWDAQCAJBIFS2DIQB6IBCESVCSKTNF22DEPBYHA7D2RUAIJCENUCKJTHFAWUWK3NFWZC8NBT" 1758 "GI3VIPJYG66DUQT5HS8V6R4AIFBEGTCFI3DWSUKKJPGE4VURKBIXEW4WKXMFQYC3MJPX2ZK8M7SGC2VD" 1759 "NTUYN35IPFXGY5DPP3ZZA6MUQP4HK7VZRB6ZW856RX9H9AEBSKB2JBNGS8EIVCWMTUG27D6SUGJJHFEX" 1760 "U4M3TGN4VQQJ5HW9WCS4FI7EWYVKRKFJXKX43MPQX82MDNXVYU45PP72ZG7MZRF7Z496BSQC2RCNMTYH" 1761 "3DE6XU8N3ZHN9WGT4MJ7JXQY49NPVYY55VQ77Z9A6HTQH3HF65V8T4RK7RYQ55ZR8D29F69W8Z5RR8H3" 1763 const char *base64AndHexEncoded =
1764 "41414543417751464267634943516F4C4441304F4478415245684D554652595847426B6147787764" 1765 "486838674953496A4A43556D4A7967704B6973734C5334764D4445794D7A51310A4E6A63344F546F" 1766 "375044302B50304242516B4E4552555A4853456C4B5330784E546B395155564A5456465657563168" 1767 "5A576C746358563566594746695932526C5A6D646F615770720A6247317562334278636E4E306458" 1768 "5A3365486C3665337839666E2B4167594B44684957476834694A696F754D6A5936506B4A47536B35" 1769 "53566C7065596D5A71626E4A32656E3643680A6F714F6B7061616E714B6D717136797472712B7773" 1770 "624B7A744C573274376935757275387662362F774D484377385446787366497963724C7A4D334F7A" 1771 "39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673" 1772 "3765377638504879382F5431397666342B6672372F50332B0A";
1774 cout <<
"\nBase64, base32 and hex coding validation suite running...\n\n";
1776 fail = !TestFilter(
HexEncoder().Ref(), data, 255, (
const byte *)hexEncoded, strlen(hexEncoded));
1777 cout << (fail ?
"FAILED " :
"passed ");
1778 cout <<
"Hex Encoding\n";
1779 pass = pass && !fail;
1781 fail = !TestFilter(
HexDecoder().Ref(), (
const byte *)hexEncoded, strlen(hexEncoded), data, 255);
1782 cout << (fail ?
"FAILED " :
"passed ");
1783 cout <<
"Hex Decoding\n";
1784 pass = pass && !fail;
1786 fail = !TestFilter(
Base32Encoder().Ref(), data, 255, (
const byte *)base32Encoded, strlen(base32Encoded));
1787 cout << (fail ?
"FAILED " :
"passed ");
1788 cout <<
"Base32 Encoding\n";
1789 pass = pass && !fail;
1791 fail = !TestFilter(
Base32Decoder().Ref(), (
const byte *)base32Encoded, strlen(base32Encoded), data, 255);
1792 cout << (fail ?
"FAILED " :
"passed ");
1793 cout <<
"Base32 Decoding\n";
1794 pass = pass && !fail;
1796 fail = !TestFilter(
Base64Encoder(
new HexEncoder).Ref(), data, 255, (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded));
1797 cout << (fail ?
"FAILED " :
"passed ");
1798 cout <<
"Base64 Encoding\n";
1799 pass = pass && !fail;
1801 fail = !TestFilter(
HexDecoder(
new Base64Decoder).Ref(), (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded), data, 255);
1802 cout << (fail ?
"FAILED " :
"passed ");
1803 cout <<
"Base64 Decoding\n";
1804 pass = pass && !fail;
1809 bool ValidateSHACAL2()
1811 cout <<
"\nSHACAL-2 validation suite running...\n\n";
1820 bool ValidateCamellia()
1822 cout <<
"\nCamellia validation suite running...\n\n";
1832 bool ValidateSalsa()
1834 cout <<
"\nSalsa validation suite running...\n";
1836 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/salsa.txt");
1839 bool ValidateSosemanuk()
1841 cout <<
"\nSosemanuk validation suite running...\n";
1842 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/sosemanuk.txt");
1847 cout <<
"\nVMAC validation suite running...\n";
1848 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/vmac.txt");
1853 cout <<
"\nAES/CCM validation suite running...\n";
1854 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/ccm.txt");
1859 cout <<
"\nAES/GCM validation suite running...\n";
1860 cout <<
"\n2K tables:";
1862 cout <<
"\n64K tables:";
1868 cout <<
"\nCMAC validation suite running...\n";
1869 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/cmac.txt");
Base class for all exceptions thrown by Crypto++.
OFB block cipher mode of operation.
Wrapper class for /dev/random and /dev/srandom.
Class file for modes of operation.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
This file contains helper classes/functions for implementing public key algorithms.
Hardware generated random numbers using RDRAND instruction.
size_type SizeInBytes() const
Provides the number of bytes in the SecBlock.
file-based implementation of Source interface
Converts given data to base 16.
Classes for the RC5 block cipher.
virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL)
Generate a random 32 bit word in the range min to max, inclusive.
Decode base 16 data back to bytes.
Abstract base classes that provide a uniform interface to this library.
void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memcpy()
Classes for the RC2 block cipher.
BufferedTransformation & TheBitBucket()
An input discarding BufferedTransformation.
Manages resources for an array of objects.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
Classes for automatic resource management.
DEFLATE (RFC 1951) compressor.
Classes for the GIST block cipher.
Classes for the Cameliia block cipher.
Classes for RDRAND and RDSEED.
Classes for Base32Encoder and Base32Decoder.
SecByteBlock is a SecBlock<byte> typedef.
Classes for the RC6 block cipher.
Classes for the Twofish block cipher.
1 and 0's padding added to a block
Classes for the Blowfish block cipher.
Copy input to a memory buffer.
Classes for the MARS block cipher (IBM AES submission)
const char * TableSize()
int, in bytes
Classes for the SKIPJACK block cipher.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
Filter Wrapper for HashTransformation.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Exception thrown when an operating system error is encountered.
virtual void Resynchronize(const byte *iv, int ivLength=-1)
resynchronize with an IV. ivLength=-1 means use IVSize()
Classes for HexEncoder and HexDecoder.
Maurer's Universal Statistical Test for Random Bit Generators.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
Automatically Seeded Randomness Pool.
void Assign(const T *ptr, size_type len)
Set contents and size from an array.
Class file for the AES cipher (Rijndael)
Classes for the CAST-128 and CAST-256 block ciphers.
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode...
Provides class member functions to key a block cipher.
Classes for DMAC message authentication code.
virtual unsigned int IVSize() const
Returns length of the IV accepted by this object.
Implementation of schemes based on DL over GF(p)
bool IsPowerOf2(const T &value)
Tests whether a value is a power of 2.
Miscellaneous classes for RNGs.
Classes for SEAL stream cipher.
Redirect input to another BufferedTransformation without owning it.
Classes for Rijndael encryption algorithm.
Classes, functions, intrinsics and features for X86, X32 nd X64 assembly.
Classes for DES, 2-key Triple-DES, 3-key Triple-DES and DESX.
Implementation of BufferedTransformation's attachment interface in cryptlib.h.
Hardware generated random numbers using RDSEED instruction.
Classes for the Base64Encoder, Base64Decoder, Base64URLEncoder and Base64URLDecoder.
Classes for the SAFER block cipher.
Base class for unflushable filters.
Wrapper class for /dev/random and /dev/srandom.
0's padding added to a block
measure how many byte and messages pass through, also serves as valve
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
Classes for the 3-Way block cipher.
No padding added to a block.
Classes and functions for Elliptic Curves over prime and binary fields.
Classes for the Serpent block cipher.
Crypto++ library namespace.
Class specific methods used to operate the cipher in the reverse direction.
RNG-based implementation of Source interface.
Classes for the SHARK block cipher.
Class specific methods used to operate the cipher in the forward direction.
file-based implementation of Sink interface
Classes for the Square block cipher.
virtual void GetNextIV(RandomNumberGenerator &rng, byte *iv)
Gets a secure IV for the next message.
Classes for access to the operating system's random number generators.
Classes for the IDEA block cipher.