5 #define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1 57 #if (CRYPTOPP_MSC_VERSION >= 1410) 58 # pragma strict_gs_check (on) 64 bool ValidateAll(
bool thorough)
66 bool pass=TestSettings();
67 pass=TestOS_RNG() && pass;
68 pass=TestAutoSeeded() && pass;
70 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 71 pass=TestRDRAND() && pass;
72 pass=TestRDSEED() && pass;
77 #if !defined(NDEBUG) && !defined(CRYPTOPP_IMPORTS) 79 pass=TestPolynomialMod2() && pass;
82 pass=ValidateCRC32() && pass;
83 pass=ValidateAdler32() && pass;
84 pass=ValidateMD2() && pass;
85 pass=ValidateMD5() && pass;
86 pass=ValidateSHA() && pass;
87 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/sha3.txt") && pass;
88 pass=ValidateTiger() && pass;
89 pass=ValidateRIPEMD() && pass;
90 pass=ValidatePanama() && pass;
91 pass=ValidateWhirlpool() && pass;
93 pass=ValidateHMAC() && pass;
94 pass=ValidateTTMAC() && pass;
96 pass=ValidatePBKDF() && pass;
97 pass=ValidateHKDF() && pass;
99 pass=ValidateDES() && pass;
100 pass=ValidateCipherModes() && pass;
101 pass=ValidateIDEA() && pass;
102 pass=ValidateSAFER() && pass;
103 pass=ValidateRC2() && pass;
104 pass=ValidateARC4() && pass;
105 pass=ValidateRC5() && pass;
106 pass=ValidateBlowfish() && pass;
107 pass=ValidateThreeWay() && pass;
108 pass=ValidateGOST() && pass;
109 pass=ValidateSHARK() && pass;
110 pass=ValidateCAST() && pass;
111 pass=ValidateSquare() && pass;
112 pass=ValidateSKIPJACK() && pass;
113 pass=ValidateSEAL() && pass;
114 pass=ValidateRC6() && pass;
115 pass=ValidateMARS() && pass;
116 pass=ValidateRijndael() && pass;
117 pass=ValidateTwofish() && pass;
118 pass=ValidateSerpent() && pass;
119 pass=ValidateSHACAL2() && pass;
120 pass=ValidateCamellia() && pass;
121 pass=ValidateSalsa() && pass;
122 pass=ValidateSosemanuk() && pass;
123 pass=ValidateVMAC() && pass;
124 pass=ValidateCCM() && pass;
125 pass=ValidateGCM() && pass;
126 pass=ValidateCMAC() && pass;
127 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/eax.txt") && pass;
128 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/seed.txt") && pass;
130 pass=ValidateBBS() && pass;
131 pass=ValidateDH() && pass;
132 pass=ValidateMQV() && pass;
133 pass=ValidateRSA() && pass;
134 pass=ValidateElGamal() && pass;
135 pass=ValidateDLIES() && pass;
136 pass=ValidateNR() && pass;
137 pass=ValidateDSA(thorough) && pass;
138 pass=ValidateLUC() && pass;
139 pass=ValidateLUC_DH() && pass;
140 pass=ValidateLUC_DL() && pass;
141 pass=ValidateXTR_DH() && pass;
142 pass=ValidateRabin() && pass;
143 pass=ValidateRW() && pass;
145 pass=ValidateECP() && pass;
146 pass=ValidateEC2N() && pass;
147 pass=ValidateECDSA() && pass;
148 pass=ValidateESIGN() && pass;
151 cout <<
"\nAll tests passed!\n";
153 cout <<
"\nOops! Not all tests passed.\n";
161 #if defined(__MINGW32__) 167 cout <<
"\nTesting Settings...\n\n";
170 memcpy_s(&w,
sizeof(w),
"\x01\x02\x03\x04", 4);
172 if (w == 0x04030201L)
174 #ifdef IS_LITTLE_ENDIAN 180 cout <<
"Your machine is little endian.\n";
182 else if (w == 0x01020304L)
184 #ifndef IS_LITTLE_ENDIAN 190 cout <<
"Your machine is big endian.\n";
194 cout <<
"FAILED: Your machine is neither big endian nor little endian.\n";
198 #ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS 199 byte testvals[10] = {1,2,2,3,3,3,3,2,2,1};
200 if (*(word32 *)(testvals+3) == 0x03030303 && *(word64 *)(testvals+1) == W64LIT(0x0202030303030202))
201 cout <<
"passed: Your machine allows unaligned data access.\n";
204 cout <<
"FAILED: Unaligned data access gave incorrect results.\n";
208 cout <<
"passed: CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS is not defined. Will restrict to aligned data access.\n";
211 if (
sizeof(byte) == 1)
218 cout <<
"sizeof(byte) == " <<
sizeof(byte) << endl;
220 if (
sizeof(word16) == 2)
227 cout <<
"sizeof(word16) == " <<
sizeof(word16) << endl;
229 if (
sizeof(word32) == 4)
236 cout <<
"sizeof(word32) == " <<
sizeof(word32) << endl;
238 if (
sizeof(word64) == 8)
245 cout <<
"sizeof(word64) == " <<
sizeof(word64) << endl;
247 #ifdef CRYPTOPP_WORD128_AVAILABLE 248 if (
sizeof(word128) == 16)
255 cout <<
"sizeof(word128) == " <<
sizeof(word128) << endl;
258 if (
sizeof(word) == 2*
sizeof(hword)
259 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
260 &&
sizeof(dword) == 2*
sizeof(word)
269 cout <<
"sizeof(hword) == " <<
sizeof(hword) <<
", sizeof(word) == " <<
sizeof(word);
270 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE 271 cout <<
", sizeof(dword) == " <<
sizeof(dword);
275 #ifdef CRYPTOPP_CPUID_AVAILABLE 276 bool hasMMX = HasMMX();
277 bool hasISSE = HasISSE();
278 bool hasSSE2 = HasSSE2();
279 bool hasSSSE3 = HasSSSE3();
281 int cacheLineSize = GetCacheLineSize();
283 if ((isP4 && (!hasMMX || !hasSSE2)) || (hasSSE2 && !hasMMX) || (cacheLineSize < 16 || cacheLineSize > 256 || !
IsPowerOf2(cacheLineSize)))
291 cout <<
"hasMMX == " << hasMMX <<
", hasISSE == " << hasISSE <<
", hasSSE2 == " << hasSSE2 <<
", hasSSSE3 == " << hasSSSE3 <<
", hasAESNI == " << HasAESNI() <<
", hasRDRAND == " << HasRDRAND() <<
", hasRDSEED == " << HasRDSEED() <<
", hasCLMUL == " << HasCLMUL() <<
", isP4 == " << isP4 <<
", cacheLineSize == " << cacheLineSize;
292 cout <<
", AESNI_INTRINSICS == " << CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE << endl;
297 cout <<
"Some critical setting in config.h is in error. Please fix it and recompile." << endl;
309 #ifdef BLOCKING_RNG_AVAILABLE 316 cout <<
"\nTesting operating system provided blocking random number generator...\n\n";
320 unsigned long total=0, length=0;
321 time_t t = time(NULL), t1 = 0;
322 CRYPTOPP_UNUSED(length);
325 while (total < 16 && (t1 < 10 || total*8 > (
unsigned long)t1))
339 cout <<
" it took " << long(t1) <<
" seconds to generate " << total <<
" bytes" << endl;
341 #if 0 // disable this part. it's causing an unpredictable pause during the validation testing 347 while (time(NULL) - t < 2)
356 while (time(NULL) - t < 2)
369 cout <<
" it generated " << length <<
" bytes in " << long(time(NULL) - t) <<
" seconds" << endl;
373 test.AttachedTransformation()->MessageEnd();
375 if (meter.GetTotalBytes() < total)
382 cout <<
" " << total <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
385 cout <<
"\nNo operating system provided blocking random number generator, skipping test." << endl;
388 #ifdef NONBLOCKING_RNG_AVAILABLE 395 cout <<
"\nTesting operating system provided nonblocking random number generator...\n\n";
400 if (meter.GetTotalBytes() < 100000)
407 cout <<
" 100000 generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
410 cout <<
"\nNo operating system provided nonblocking random number generator, skipping test." << endl;
416 bool TestAutoSeeded()
421 bool TestAutoSeeded()
424 cout <<
"\nTesting AutoSeeded generator...\n\n";
427 bool generate =
true, discard =
true;
432 if (meter.GetTotalBytes() < 100000)
439 cout <<
" 100000 generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
454 cout <<
" discarded 10000 bytes" << endl;
456 return generate && discard;
458 #endif // NO_OS_DEPENDENCE 460 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 464 bool entropy =
true, compress =
true, discard =
true;
465 static const unsigned int SIZE = 10000;
469 cout <<
"\nTesting RDRAND generator...\n\n";
476 chsw.AddDefaultRoute(deflator);
477 chsw.AddDefaultRoute(maurer);
480 deflator.Flush(
true);
483 const double mv = maurer.GetTestValue();
492 const std::streamsize oldp = cout.precision(6);
493 const std::ios::fmtflags oldf = cout.setf(std::ios::fixed, std::ios::floatfield);
494 cout <<
" Maurer Randomness Test returned value " << mv << endl;
495 cout.precision(oldp);
496 cout.setf(oldf, std::ios::floatfield);
498 if (meter.GetTotalBytes() < SIZE)
505 cout <<
" " << SIZE <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE\n";
520 cout <<
" discarded " << SIZE <<
" bytes\n";
523 cout <<
"\nRDRAND generator not available, skipping test.\n";
525 if (!(entropy && compress && discard))
528 return entropy && compress && discard;
532 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 536 bool entropy =
true, compress =
true, discard =
true;
537 static const unsigned int SIZE = 10000;
541 cout <<
"\nTesting RDSEED generator...\n\n";
548 chsw.AddDefaultRoute(deflator);
549 chsw.AddDefaultRoute(maurer);
552 deflator.Flush(
true);
555 const double mv = maurer.GetTestValue();
564 const std::streamsize oldp = cout.precision(6);
565 const std::ios::fmtflags oldf = cout.setf(std::ios::fixed, std::ios::floatfield);
566 cout <<
" Maurer Randomness Test returned value " << mv << endl;
567 cout.precision(oldp);
568 cout.setf(oldf, std::ios::floatfield);
570 if (meter.GetTotalBytes() < SIZE)
577 cout <<
" " << SIZE <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE\n";
592 cout <<
" discarded " << SIZE <<
" bytes\n";
595 cout <<
"\nRDSEED generator not available, skipping test.\n";
597 if (!(entropy && compress && discard))
600 return entropy && compress && discard;
605 typedef auto_ptr<BlockTransformation> apbt;
610 virtual unsigned int BlockSize()
const =0;
611 virtual unsigned int KeyLength()
const =0;
613 virtual apbt NewEncryption(
const byte *key)
const =0;
614 virtual apbt NewDecryption(
const byte *key)
const =0;
621 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
622 unsigned int KeyLength()
const {
return m_keylen;}
624 apbt NewEncryption(
const byte *key)
const 625 {
return apbt(
new E(key, m_keylen));}
626 apbt NewDecryption(
const byte *key)
const 627 {
return apbt(
new D(key, m_keylen));}
629 unsigned int m_keylen;
636 : m_keylen(keylen ? keylen : E::DEFAULT_KEYLENGTH), m_rounds(rounds ? rounds : E::DEFAULT_ROUNDS) {}
637 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
638 unsigned int KeyLength()
const {
return m_keylen;}
640 apbt NewEncryption(
const byte *key)
const 641 {
return apbt(
new E(key, m_keylen, m_rounds));}
642 apbt NewDecryption(
const byte *key)
const 643 {
return apbt(
new D(key, m_keylen, m_rounds));}
645 unsigned int m_keylen, m_rounds;
651 SecByteBlock plain(cg.BlockSize()), cipher(cg.BlockSize()), out(cg.BlockSize()), outplain(cg.BlockSize());
653 bool pass=
true, fail;
657 valdata.
Get(key, cg.KeyLength());
658 valdata.
Get(plain, cg.BlockSize());
659 valdata.
Get(cipher, cg.BlockSize());
661 apbt transE = cg.NewEncryption(key);
662 transE->ProcessBlock(plain, out);
663 fail = memcmp(out, cipher, cg.BlockSize()) != 0;
665 apbt transD = cg.NewDecryption(key);
666 transD->ProcessBlock(out, outplain);
667 fail=fail || memcmp(outplain, plain, cg.BlockSize());
669 pass = pass && !fail;
671 cout << (fail ?
"FAILED " :
"passed ");
672 output.
Put(key, cg.KeyLength());
674 output.
Put(outplain, cg.BlockSize());
676 output.
Put(out, cg.BlockSize());
686 : validOutput(validOutput), outputLen(outputLen), counter(0), fail(
false) {}
687 void PutByte(byte inByte)
689 if (counter >= outputLen || validOutput[counter] != inByte)
691 std::cerr <<
"incorrect output " << counter <<
", " << (word16)validOutput[counter] <<
", " << (word16)inByte <<
"\n";
697 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
699 CRYPTOPP_UNUSED(messageEnd), CRYPTOPP_UNUSED(blocking);
702 FilterTester::PutByte(*inString++);
705 if (counter != outputLen)
718 const byte *validOutput;
719 size_t outputLen, counter;
731 bt.
Put(in, randomLen);
736 return ft->GetResult();
741 cout <<
"\nDES validation suite running...\n\n";
746 cout <<
"\nTesting EDE2, EDE3, and XEX3 variants...\n\n";
764 for (
unsigned int i=1; i<20480; i*=2)
778 if (!TestFilter(filter, plaintext, length, plaintext, length))
785 bool ValidateCipherModes()
787 cout <<
"\nTesting DES modes...\n\n";
788 const byte key[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
789 const byte iv[] = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
790 const byte plain[] = {
791 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
792 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
793 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20};
796 bool pass=
true, fail;
800 const byte encrypted[] = {
801 0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15,
802 0x6a, 0x27, 0x17, 0x87, 0xab, 0x88, 0x83, 0xf9,
803 0x89, 0x3d, 0x51, 0xec, 0x4b, 0x56, 0x3b, 0x53};
807 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
808 pass = pass && !fail;
809 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB encryption" << endl;
813 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
814 pass = pass && !fail;
815 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB decryption" << endl;
819 const byte encrypted[] = {
820 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
821 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
822 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6};
826 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
827 pass = pass && !fail;
828 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with no padding" << endl;
832 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
833 pass = pass && !fail;
834 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with no padding" << endl;
836 fail = !TestModeIV(modeE, modeD);
837 pass = pass && !fail;
838 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC mode IV generation" << endl;
843 const byte encrypted[] = {
844 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
845 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
846 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
847 0x62, 0xC1, 0x6A, 0x27, 0xE4, 0xFC, 0xF2, 0x77};
851 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
852 pass = pass && !fail;
853 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with PKCS #7 padding" << endl;
857 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
858 pass = pass && !fail;
859 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with PKCS #7 padding" << endl;
864 const byte encrypted[] = {
865 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
866 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
867 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
868 0xcf, 0xb7, 0xc7, 0x64, 0x0e, 0x7c, 0xd9, 0xa7};
872 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
873 pass = pass && !fail;
874 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with one-and-zeros padding" << endl;
878 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
879 pass = pass && !fail;
880 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with one-and-zeros padding" << endl;
883 const byte plain_1[] = {
'a', 0, 0, 0, 0, 0, 0, 0};
885 const byte encrypted[] = {
886 0x9B, 0x47, 0x57, 0x59, 0xD6, 0x9C, 0xF6, 0xD0};
890 plain_1, 1, encrypted,
sizeof(encrypted));
891 pass = pass && !fail;
892 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with zeros padding" << endl;
896 encrypted,
sizeof(encrypted), plain_1,
sizeof(plain_1));
897 pass = pass && !fail;
898 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with zeros padding" << endl;
903 const byte encrypted[] = {
904 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
905 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
906 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F};
910 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
911 pass = pass && !fail;
912 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext stealing (CTS)" << endl;
916 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
917 pass = pass && !fail;
918 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext stealing (CTS)" << endl;
920 fail = !TestModeIV(modeE, modeD);
921 pass = pass && !fail;
922 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC CTS IV generation" << endl;
926 const byte decryptionIV[] = {0x4D, 0xD0, 0xAC, 0x8F, 0x47, 0xCF, 0x79, 0xCE};
927 const byte encrypted[] = {0x12, 0x34, 0x56};
932 modeE.SetStolenIV(stolenIV);
934 plain, 3, encrypted,
sizeof(encrypted));
935 fail = memcmp(stolenIV, decryptionIV, 8) != 0 || fail;
936 pass = pass && !fail;
937 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext and IV stealing" << endl;
941 encrypted,
sizeof(encrypted), plain, 3);
942 pass = pass && !fail;
943 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext and IV stealing" << endl;
946 const byte encrypted[] = {
947 0xF3,0x09,0x62,0x49,0xC7,0xF4,0x6E,0x51,
948 0xA6,0x9E,0x83,0x9B,0x1A,0x92,0xF7,0x84,
949 0x03,0x46,0x71,0x33,0x89,0x8E,0xA6,0x22};
953 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
954 pass = pass && !fail;
955 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB encryption" << endl;
959 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
960 pass = pass && !fail;
961 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB decryption" << endl;
963 fail = !TestModeIV(modeE, modeD);
964 pass = pass && !fail;
965 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB mode IV generation" << endl;
968 const byte plain_2[] = {
969 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
970 const byte encrypted[] = {
971 0xf3,0x1f,0xda,0x07,0x01,0x14,0x62,0xee,0x18,0x7f};
975 plain_2,
sizeof(plain_2), encrypted,
sizeof(encrypted));
976 pass = pass && !fail;
977 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) encryption" << endl;
981 encrypted,
sizeof(encrypted), plain_2,
sizeof(plain_2));
982 pass = pass && !fail;
983 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) decryption" << endl;
985 fail = !TestModeIV(modeE, modeD);
986 pass = pass && !fail;
987 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) IV generation" << endl;
990 const byte encrypted[] = {
991 0xf3,0x09,0x62,0x49,0xc7,0xf4,0x6e,0x51,
992 0x35,0xf2,0x4a,0x24,0x2e,0xeb,0x3d,0x3f,
993 0x3d,0x6d,0x5b,0xe3,0x25,0x5a,0xf8,0xc3};
997 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
998 pass = pass && !fail;
999 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB encryption" << endl;
1003 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1004 pass = pass && !fail;
1005 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB decryption" << endl;
1007 fail = !TestModeIV(modeE, modeD);
1008 pass = pass && !fail;
1009 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB IV generation" << endl;
1012 const byte encrypted[] = {
1013 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51,
1014 0x16, 0x3A, 0x8C, 0xA0, 0xFF, 0xC9, 0x4C, 0x27,
1015 0xFA, 0x2F, 0x80, 0xF4, 0x80, 0xB8, 0x6F, 0x75};
1019 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1020 pass = pass && !fail;
1021 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode encryption" << endl;
1025 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1026 pass = pass && !fail;
1027 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode decryption" << endl;
1029 fail = !TestModeIV(modeE, modeD);
1030 pass = pass && !fail;
1031 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode IV generation" << endl;
1034 const byte plain_3[] = {
1035 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1036 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1037 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
1038 0x66, 0x6f, 0x72, 0x20};
1039 const byte mac1[] = {
1040 0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
1041 const byte mac2[] = {
1042 0x35, 0x80, 0xC5, 0xC4, 0x6B, 0x81, 0x24, 0xE2};
1046 fail = !TestFilter(cbcmacFilter, plain_3,
sizeof(plain_3), mac1,
sizeof(mac1));
1047 pass = pass && !fail;
1048 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC MAC" << endl;
1052 fail = !TestFilter(dmacFilter, plain_3,
sizeof(plain_3), mac2,
sizeof(mac2));
1053 pass = pass && !fail;
1054 cout << (fail ?
"FAILED " :
"passed ") <<
"DMAC" << endl;
1059 fail = !TestModeIV(modeE, modeD);
1060 pass = pass && !fail;
1061 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CTR Mode" << endl;
1066 fail = !TestModeIV(modeE, modeD);
1067 pass = pass && !fail;
1068 cout << (fail ?
"FAILED " :
"passed ") <<
"AES OFB Mode" << endl;
1073 fail = !TestModeIV(modeE, modeD);
1074 pass = pass && !fail;
1075 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CFB Mode" << endl;
1080 fail = !TestModeIV(modeE, modeD);
1081 pass = pass && !fail;
1082 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CBC Mode" << endl;
1090 cout <<
"\nIDEA validation suite running...\n\n";
1096 bool ValidateSAFER()
1098 cout <<
"\nSAFER validation suite running...\n\n";
1111 cout <<
"\nRC2 validation suite running...\n\n";
1115 SecByteBlock plain(RC2Encryption::BLOCKSIZE), cipher(RC2Encryption::BLOCKSIZE), out(RC2Encryption::BLOCKSIZE), outplain(RC2Encryption::BLOCKSIZE);
1117 bool pass=
true, fail;
1121 byte keyLen, effectiveLen;
1123 valdata.
Get(keyLen);
1124 valdata.
Get(effectiveLen);
1125 valdata.
Get(key, keyLen);
1126 valdata.
Get(plain, RC2Encryption::BLOCKSIZE);
1127 valdata.
Get(cipher, RC2Encryption::BLOCKSIZE);
1130 transE->ProcessBlock(plain, out);
1131 fail = memcmp(out, cipher, RC2Encryption::BLOCKSIZE) != 0;
1134 transD->ProcessBlock(out, outplain);
1135 fail=fail || memcmp(outplain, plain, RC2Encryption::BLOCKSIZE);
1137 pass = pass && !fail;
1139 cout << (fail ?
"FAILED " :
"passed ");
1140 output.
Put(key, keyLen);
1142 output.
Put(outplain, RC2Encryption::BLOCKSIZE);
1144 output.
Put(out, RC2Encryption::BLOCKSIZE);
1152 unsigned char Key0[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
1153 unsigned char Input0[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
1154 unsigned char Output0[] = {0x75,0xb7,0x87,0x80,0x99,0xe0,0xc5,0x96};
1156 unsigned char Key1[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
1157 unsigned char Input1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1158 unsigned char Output1[]={0x74,0x94,0xc2,0xe7,0x10,0x4b,0x08,0x79};
1160 unsigned char Key2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1161 unsigned char Input2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1162 unsigned char Output2[]={0xde,0x18,0x89,0x41,0xa3,0x37,0x5d,0x3a};
1164 unsigned char Key3[]={0xef,0x01,0x23,0x45};
1165 unsigned char Input3[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1166 unsigned char Output3[]={0xd6,0xa1,0x41,0xa7,0xec,0x3c,0x38,0xdf,0xbd,0x61};
1168 unsigned char Key4[]={ 0x01,0x23,0x45,0x67,0x89,0xab, 0xcd,0xef };
1169 unsigned char Input4[] =
1170 {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1171 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1172 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1173 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1174 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1175 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1176 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1177 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1178 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1179 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1180 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1181 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1182 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1183 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1184 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1185 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1186 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1187 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1188 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1189 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1190 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1191 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1192 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1193 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1194 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1195 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1196 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1197 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1198 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1199 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1200 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1201 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1202 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1203 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1204 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1205 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1206 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1207 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1208 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1209 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1210 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1211 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1212 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1213 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1214 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1215 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1216 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1217 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1218 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1219 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1220 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1222 unsigned char Output4[]= {
1223 0x75,0x95,0xc3,0xe6,0x11,0x4a,0x09,0x78,0x0c,0x4a,0xd4,
1224 0x52,0x33,0x8e,0x1f,0xfd,0x9a,0x1b,0xe9,0x49,0x8f,
1225 0x81,0x3d,0x76,0x53,0x34,0x49,0xb6,0x77,0x8d,0xca,
1226 0xd8,0xc7,0x8a,0x8d,0x2b,0xa9,0xac,0x66,0x08,0x5d,
1227 0x0e,0x53,0xd5,0x9c,0x26,0xc2,0xd1,0xc4,0x90,0xc1,
1228 0xeb,0xbe,0x0c,0xe6,0x6d,0x1b,0x6b,0x1b,0x13,0xb6,
1229 0xb9,0x19,0xb8,0x47,0xc2,0x5a,0x91,0x44,0x7a,0x95,
1230 0xe7,0x5e,0x4e,0xf1,0x67,0x79,0xcd,0xe8,0xbf,0x0a,
1231 0x95,0x85,0x0e,0x32,0xaf,0x96,0x89,0x44,0x4f,0xd3,
1232 0x77,0x10,0x8f,0x98,0xfd,0xcb,0xd4,0xe7,0x26,0x56,
1233 0x75,0x00,0x99,0x0b,0xcc,0x7e,0x0c,0xa3,0xc4,0xaa,
1234 0xa3,0x04,0xa3,0x87,0xd2,0x0f,0x3b,0x8f,0xbb,0xcd,
1235 0x42,0xa1,0xbd,0x31,0x1d,0x7a,0x43,0x03,0xdd,0xa5,
1236 0xab,0x07,0x88,0x96,0xae,0x80,0xc1,0x8b,0x0a,0xf6,
1237 0x6d,0xff,0x31,0x96,0x16,0xeb,0x78,0x4e,0x49,0x5a,
1238 0xd2,0xce,0x90,0xd7,0xf7,0x72,0xa8,0x17,0x47,0xb6,
1239 0x5f,0x62,0x09,0x3b,0x1e,0x0d,0xb9,0xe5,0xba,0x53,
1240 0x2f,0xaf,0xec,0x47,0x50,0x83,0x23,0xe6,0x71,0x32,
1241 0x7d,0xf9,0x44,0x44,0x32,0xcb,0x73,0x67,0xce,0xc8,
1242 0x2f,0x5d,0x44,0xc0,0xd0,0x0b,0x67,0xd6,0x50,0xa0,
1243 0x75,0xcd,0x4b,0x70,0xde,0xdd,0x77,0xeb,0x9b,0x10,
1244 0x23,0x1b,0x6b,0x5b,0x74,0x13,0x47,0x39,0x6d,0x62,
1245 0x89,0x74,0x21,0xd4,0x3d,0xf9,0xb4,0x2e,0x44,0x6e,
1246 0x35,0x8e,0x9c,0x11,0xa9,0xb2,0x18,0x4e,0xcb,0xef,
1247 0x0c,0xd8,0xe7,0xa8,0x77,0xef,0x96,0x8f,0x13,0x90,
1248 0xec,0x9b,0x3d,0x35,0xa5,0x58,0x5c,0xb0,0x09,0x29,
1249 0x0e,0x2f,0xcd,0xe7,0xb5,0xec,0x66,0xd9,0x08,0x4b,
1250 0xe4,0x40,0x55,0xa6,0x19,0xd9,0xdd,0x7f,0xc3,0x16,
1251 0x6f,0x94,0x87,0xf7,0xcb,0x27,0x29,0x12,0x42,0x64,
1252 0x45,0x99,0x85,0x14,0xc1,0x5d,0x53,0xa1,0x8c,0x86,
1253 0x4c,0xe3,0xa2,0xb7,0x55,0x57,0x93,0x98,0x81,0x26,
1254 0x52,0x0e,0xac,0xf2,0xe3,0x06,0x6e,0x23,0x0c,0x91,
1255 0xbe,0xe4,0xdd,0x53,0x04,0xf5,0xfd,0x04,0x05,0xb3,
1256 0x5b,0xd9,0x9c,0x73,0x13,0x5d,0x3d,0x9b,0xc3,0x35,
1257 0xee,0x04,0x9e,0xf6,0x9b,0x38,0x67,0xbf,0x2d,0x7b,
1258 0xd1,0xea,0xa5,0x95,0xd8,0xbf,0xc0,0x06,0x6f,0xf8,
1259 0xd3,0x15,0x09,0xeb,0x0c,0x6c,0xaa,0x00,0x6c,0x80,
1260 0x7a,0x62,0x3e,0xf8,0x4c,0x3d,0x33,0xc1,0x95,0xd2,
1261 0x3e,0xe3,0x20,0xc4,0x0d,0xe0,0x55,0x81,0x57,0xc8,
1262 0x22,0xd4,0xb8,0xc5,0x69,0xd8,0x49,0xae,0xd5,0x9d,
1263 0x4e,0x0f,0xd7,0xf3,0x79,0x58,0x6b,0x4b,0x7f,0xf6,
1264 0x84,0xed,0x6a,0x18,0x9f,0x74,0x86,0xd4,0x9b,0x9c,
1265 0x4b,0xad,0x9b,0xa2,0x4b,0x96,0xab,0xf9,0x24,0x37,
1266 0x2c,0x8a,0x8f,0xff,0xb1,0x0d,0x55,0x35,0x49,0x00,
1267 0xa7,0x7a,0x3d,0xb5,0xf2,0x05,0xe1,0xb9,0x9f,0xcd,
1268 0x86,0x60,0x86,0x3a,0x15,0x9a,0xd4,0xab,0xe4,0x0f,
1269 0xa4,0x89,0x34,0x16,0x3d,0xdd,0xe5,0x42,0xa6,0x58,
1270 0x55,0x40,0xfd,0x68,0x3c,0xbf,0xd8,0xc0,0x0f,0x12,
1271 0x12,0x9a,0x28,0x4d,0xea,0xcc,0x4c,0xde,0xfe,0x58,
1272 0xbe,0x71,0x37,0x54,0x1c,0x04,0x71,0x26,0xc8,0xd4,
1273 0x9e,0x27,0x55,0xab,0x18,0x1a,0xb7,0xe9,0x40,0xb0,
1278 bool pass=
true, fail;
1281 cout <<
"\nARC4 validation suite running...\n\n";
1283 arc4.reset(
new Weak::ARC4(Key0,
sizeof(Key0)));
1284 arc4->ProcessString(Input0,
sizeof(Input0));
1285 fail = memcmp(Input0, Output0,
sizeof(Input0)) != 0;
1286 cout << (fail ?
"FAILED" :
"passed") <<
" Test 0" << endl;
1287 pass = pass && !fail;
1289 arc4.reset(
new Weak::ARC4(Key1,
sizeof(Key1)));
1290 arc4->ProcessString(Key1, Input1,
sizeof(Key1));
1291 fail = memcmp(Output1, Key1,
sizeof(Key1)) != 0;
1292 cout << (fail ?
"FAILED" :
"passed") <<
" Test 1" << endl;
1293 pass = pass && !fail;
1295 arc4.reset(
new Weak::ARC4(Key2,
sizeof(Key2)));
1296 for (i=0, fail=
false; i<
sizeof(Input2); i++)
1297 if (arc4->ProcessByte(Input2[i]) != Output2[i])
1299 cout << (fail ?
"FAILED" :
"passed") <<
" Test 2" << endl;
1300 pass = pass && !fail;
1302 arc4.reset(
new Weak::ARC4(Key3,
sizeof(Key3)));
1303 for (i=0, fail=
false; i<
sizeof(Input3); i++)
1304 if (arc4->ProcessByte(Input3[i]) != Output3[i])
1306 cout << (fail ?
"FAILED" :
"passed") <<
" Test 3" << endl;
1307 pass = pass && !fail;
1309 arc4.reset(
new Weak::ARC4(Key4,
sizeof(Key4)));
1310 for (i=0, fail=
false; i<
sizeof(Input4); i++)
1311 if (arc4->ProcessByte(Input4[i]) != Output4[i])
1313 cout << (fail ?
"FAILED" :
"passed") <<
" Test 4" << endl;
1314 pass = pass && !fail;
1321 cout <<
"\nRC5 validation suite running...\n\n";
1329 cout <<
"\nRC6 validation suite running...\n\n";
1341 cout <<
"\nMARS validation suite running...\n\n";
1351 bool ValidateRijndael()
1353 cout <<
"\nRijndael (AES) validation suite running...\n\n";
1360 pass = RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/aes.txt") && pass;
1364 bool ValidateTwofish()
1366 cout <<
"\nTwofish validation suite running...\n\n";
1376 bool ValidateSerpent()
1378 cout <<
"\nSerpent validation suite running...\n\n";
1388 bool ValidateBlowfish()
1390 cout <<
"\nBlowfish validation suite running...\n\n";
1393 const char *key[]={
"abcdefghijklmnopqrstuvwxyz",
"Who is John Galt?"};
1394 byte *plain[]={(byte *)
"BLOWFISH", (byte *)
"\xfe\xdc\xba\x98\x76\x54\x32\x10"};
1395 byte *cipher[]={(byte *)
"\x32\x4e\xd0\xfe\xf4\x13\xa2\x03", (byte *)
"\xcc\x91\x73\x2b\x80\x22\xf6\x84"};
1396 byte out[8], outplain[8];
1397 bool pass=
true, fail;
1399 for (
int i=0; i<2; i++)
1402 enc.ProcessData(out, plain[i], 8);
1403 fail = memcmp(out, cipher[i], 8) != 0;
1406 dec.ProcessData(outplain, cipher[i], 8);
1407 fail = fail || memcmp(outplain, plain[i], 8);
1408 pass = pass && !fail;
1410 cout << (fail ?
"FAILED " :
"passed ");
1411 cout <<
'\"' << key[i] <<
'\"';
1412 for (
int j=0; j<(
signed int)(30-strlen(key[i])); j++)
1414 output.
Put(outplain, 8);
1422 bool ValidateThreeWay()
1424 cout <<
"\n3-WAY validation suite running...\n\n";
1432 cout <<
"\nGOST validation suite running...\n\n";
1438 bool ValidateSHARK()
1440 cout <<
"\nSHARK validation suite running...\n\n";
1450 cout <<
"\nCAST-128 validation suite running...\n\n";
1457 cout <<
"\nCAST-256 validation suite running...\n\n";
1467 bool ValidateSquare()
1469 cout <<
"\nSquare validation suite running...\n\n";
1475 bool ValidateSKIPJACK()
1477 cout <<
"\nSKIPJACK validation suite running...\n\n";
1485 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};
1487 byte key[] = {0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba, 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0};
1488 byte iv[] = {0x01, 0x35, 0x77, 0xaf};
1490 cout <<
"\nSEAL validation suite running...\n\n";
1493 unsigned int size =
sizeof(input);
1496 memset(output, 1, size);
1497 seal.ProcessString(output, input, size);
1498 for (
unsigned int i=0; i<size; i++)
1503 output[1] = seal.ProcessByte(output[1]);
1504 seal.ProcessString(output+2, size-2);
1505 pass = pass && memcmp(output+1, input+1, size-1) == 0;
1507 cout << (pass ?
"passed" :
"FAILED") << endl;
1511 bool ValidateBaseCode()
1513 bool pass =
true, fail;
1515 for (
unsigned int i=0; i<255; i++)
1517 static const char hexEncoded[] =
1518 "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627" 1519 "28292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F" 1520 "505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F7071727374757677" 1521 "78797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F" 1522 "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7" 1523 "C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF" 1524 "F0F1F2F3F4F5F6F7F8F9FAFBFCFDFE";
1525 static const char base32Encoded[] =
1526 "AAASEA2EAWDAQCAJBIFS2DIQB6IBCESVCSKTNF22DEPBYHA7D2RUAIJCENUCKJTHFAWUWK3NFWZC8NBT" 1527 "GI3VIPJYG66DUQT5HS8V6R4AIFBEGTCFI3DWSUKKJPGE4VURKBIXEW4WKXMFQYC3MJPX2ZK8M7SGC2VD" 1528 "NTUYN35IPFXGY5DPP3ZZA6MUQP4HK7VZRB6ZW856RX9H9AEBSKB2JBNGS8EIVCWMTUG27D6SUGJJHFEX" 1529 "U4M3TGN4VQQJ5HW9WCS4FI7EWYVKRKFJXKX43MPQX82MDNXVYU45PP72ZG7MZRF7Z496BSQC2RCNMTYH" 1530 "3DE6XU8N3ZHN9WGT4MJ7JXQY49NPVYY55VQ77Z9A6HTQH3HF65V8T4RK7RYQ55ZR8D29F69W8Z5RR8H3" 1532 const char *base64AndHexEncoded =
1533 "41414543417751464267634943516F4C4441304F4478415245684D554652595847426B6147787764" 1534 "486838674953496A4A43556D4A7967704B6973734C5334764D4445794D7A51310A4E6A63344F546F" 1535 "375044302B50304242516B4E4552555A4853456C4B5330784E546B395155564A5456465657563168" 1536 "5A576C746358563566594746695932526C5A6D646F615770720A6247317562334278636E4E306458" 1537 "5A3365486C3665337839666E2B4167594B44684957476834694A696F754D6A5936506B4A47536B35" 1538 "53566C7065596D5A71626E4A32656E3643680A6F714F6B7061616E714B6D717136797472712B7773" 1539 "624B7A744C573274376935757275387662362F774D484377385446787366497963724C7A4D334F7A" 1540 "39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673" 1541 "3765377638504879382F5431397666342B6672372F50332B0A";
1543 cout <<
"\nBase64, base32 and hex coding validation suite running...\n\n";
1545 fail = !TestFilter(
HexEncoder().Ref(), data, 255, (
const byte *)hexEncoded, strlen(hexEncoded));
1546 cout << (fail ?
"FAILED " :
"passed ");
1547 cout <<
"Hex Encoding\n";
1548 pass = pass && !fail;
1550 fail = !TestFilter(
HexDecoder().Ref(), (
const byte *)hexEncoded, strlen(hexEncoded), data, 255);
1551 cout << (fail ?
"FAILED " :
"passed ");
1552 cout <<
"Hex Decoding\n";
1553 pass = pass && !fail;
1555 fail = !TestFilter(
Base32Encoder().Ref(), data, 255, (
const byte *)base32Encoded, strlen(base32Encoded));
1556 cout << (fail ?
"FAILED " :
"passed ");
1557 cout <<
"Base32 Encoding\n";
1558 pass = pass && !fail;
1560 fail = !TestFilter(
Base32Decoder().Ref(), (
const byte *)base32Encoded, strlen(base32Encoded), data, 255);
1561 cout << (fail ?
"FAILED " :
"passed ");
1562 cout <<
"Base32 Decoding\n";
1563 pass = pass && !fail;
1565 fail = !TestFilter(
Base64Encoder(
new HexEncoder).Ref(), data, 255, (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded));
1566 cout << (fail ?
"FAILED " :
"passed ");
1567 cout <<
"Base64 Encoding\n";
1568 pass = pass && !fail;
1570 fail = !TestFilter(
HexDecoder(
new Base64Decoder).Ref(), (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded), data, 255);
1571 cout << (fail ?
"FAILED " :
"passed ");
1572 cout <<
"Base64 Decoding\n";
1573 pass = pass && !fail;
1578 bool ValidateSHACAL2()
1580 cout <<
"\nSHACAL-2 validation suite running...\n\n";
1589 bool ValidateCamellia()
1591 cout <<
"\nCamellia validation suite running...\n\n";
1601 bool ValidateSalsa()
1603 cout <<
"\nSalsa validation suite running...\n";
1605 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/salsa.txt");
1608 bool ValidateSosemanuk()
1610 cout <<
"\nSosemanuk validation suite running...\n";
1611 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/sosemanuk.txt");
1616 cout <<
"\nVMAC validation suite running...\n";
1617 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/vmac.txt");
1622 cout <<
"\nAES/CCM validation suite running...\n";
1623 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/ccm.txt");
1628 cout <<
"\nAES/GCM validation suite running...\n";
1629 cout <<
"\n2K tables:";
1631 cout <<
"\n64K tables:";
1637 cout <<
"\nCMAC validation suite running...\n";
1638 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.
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.
Route input to different and/or multiple channels based on channel ID.
Classes for multiple named channels.
Classes for the Twofish block cipher.
1 and 0's padding added to a block
Classes for the Blowfish block cipher.
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.
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.
unsigned int BytesNeeded() const
Provides the number of bytes of input is needed by the test.
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.