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;
76 #if !defined(NDEBUG) && !defined(CRYPTOPP_IMPORTS) 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;
308 #ifdef BLOCKING_RNG_AVAILABLE 315 cout <<
"\nTesting operating system provided blocking random number generator...\n\n";
319 unsigned long total=0, length=0;
320 time_t t = time(NULL), t1 = 0;
321 CRYPTOPP_UNUSED(length);
324 while (total < 16 && (t1 < 10 || total*8 > (
unsigned long)t1))
338 cout <<
" it took " << long(t1) <<
" seconds to generate " << total <<
" bytes" << endl;
340 #if 0 // disable this part. it's causing an unpredictable pause during the validation testing 346 while (time(NULL) - t < 2)
355 while (time(NULL) - t < 2)
368 cout <<
" it generated " << length <<
" bytes in " << long(time(NULL) - t) <<
" seconds" << endl;
372 test.AttachedTransformation()->MessageEnd();
374 if (meter.GetTotalBytes() < total)
381 cout <<
" " << total <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
384 cout <<
"\nNo operating system provided blocking random number generator, skipping test." << endl;
387 #ifdef NONBLOCKING_RNG_AVAILABLE 394 cout <<
"\nTesting operating system provided nonblocking random number generator...\n\n";
399 if (meter.GetTotalBytes() < 100000)
406 cout <<
" 100000 generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
409 cout <<
"\nNo operating system provided nonblocking random number generator, skipping test." << endl;
415 bool TestAutoSeeded()
420 bool TestAutoSeeded()
423 cout <<
"\nTesting AutoSeeded generator...\n\n";
426 bool generate =
true, discard =
true;
431 if (meter.GetTotalBytes() < 100000)
438 cout <<
" 100000 generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE" << endl;
453 cout <<
" discarded 10000 bytes" << endl;
455 return generate && discard;
457 #endif // NO_OS_DEPENDENCE 459 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 464 bool maurer =
true, generate =
true, discard =
true;
465 static const unsigned int SIZE = 10000;
469 cout <<
"\nTesting RDRAND generator...\n\n";
478 const double mv = mt.GetTestValue();
487 const std::streamsize oldp = cout.precision(5);
488 const std::ios::fmtflags oldf = cout.setf(std::ios::fixed, std::ios::floatfield);
489 cout <<
" Maurer Randomness Test value of " << mv << endl;
490 cout.precision(oldp);
491 cout.setf(oldf, std::ios::floatfield);
496 if (meter.GetTotalBytes() < SIZE)
503 cout <<
" " << SIZE <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE\n";
518 cout <<
" discarded " << SIZE <<
" bytes\n";
521 cout <<
"\nRDRAND generator not available, skipping test.\n";
523 if (!(maurer && generate && discard))
526 return maurer && generate && discard;
530 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 535 bool maurer =
true, generate =
true, discard =
true;
536 static const unsigned int SIZE = 10000;
540 cout <<
"\nTesting RDSEED generator...\n\n";
549 const double mv = mt.GetTestValue();
558 const std::streamsize oldp = cout.precision(5);
559 const std::ios::fmtflags oldf = cout.setf(std::ios::fixed, std::ios::floatfield);
560 cout <<
" Maurer Randomness Test value of " << mv << endl;
561 cout.precision(oldp);
562 cout.setf(oldf, std::ios::floatfield);
567 if (meter.GetTotalBytes() < SIZE)
574 cout <<
" " << SIZE <<
" generated bytes compressed to " << meter.GetTotalBytes() <<
" bytes by DEFLATE\n";
578 rdseed.DiscardBytes(SIZE);
589 cout <<
" discarded " << SIZE <<
" bytes\n";
592 cout <<
"\nRDSEED generator not available, skipping test.\n";
594 if (!(maurer && generate && discard))
597 return maurer && generate && discard;
602 typedef auto_ptr<BlockTransformation> apbt;
607 virtual unsigned int BlockSize()
const =0;
608 virtual unsigned int KeyLength()
const =0;
610 virtual apbt NewEncryption(
const byte *key)
const =0;
611 virtual apbt NewDecryption(
const byte *key)
const =0;
618 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
619 unsigned int KeyLength()
const {
return m_keylen;}
621 apbt NewEncryption(
const byte *key)
const 622 {
return apbt(
new E(key, m_keylen));}
623 apbt NewDecryption(
const byte *key)
const 624 {
return apbt(
new D(key, m_keylen));}
626 unsigned int m_keylen;
633 : m_keylen(keylen ? keylen : E::DEFAULT_KEYLENGTH), m_rounds(rounds ? rounds : E::DEFAULT_ROUNDS) {}
634 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
635 unsigned int KeyLength()
const {
return m_keylen;}
637 apbt NewEncryption(
const byte *key)
const 638 {
return apbt(
new E(key, m_keylen, m_rounds));}
639 apbt NewDecryption(
const byte *key)
const 640 {
return apbt(
new D(key, m_keylen, m_rounds));}
642 unsigned int m_keylen, m_rounds;
648 SecByteBlock plain(cg.BlockSize()), cipher(cg.BlockSize()), out(cg.BlockSize()), outplain(cg.BlockSize());
650 bool pass=
true, fail;
654 valdata.
Get(key, cg.KeyLength());
655 valdata.
Get(plain, cg.BlockSize());
656 valdata.
Get(cipher, cg.BlockSize());
658 apbt transE = cg.NewEncryption(key);
659 transE->ProcessBlock(plain, out);
660 fail = memcmp(out, cipher, cg.BlockSize()) != 0;
662 apbt transD = cg.NewDecryption(key);
663 transD->ProcessBlock(out, outplain);
664 fail=fail || memcmp(outplain, plain, cg.BlockSize());
666 pass = pass && !fail;
668 cout << (fail ?
"FAILED " :
"passed ");
669 output.
Put(key, cg.KeyLength());
671 output.
Put(outplain, cg.BlockSize());
673 output.
Put(out, cg.BlockSize());
683 : validOutput(validOutput), outputLen(outputLen), counter(0), fail(
false) {}
684 void PutByte(byte inByte)
686 if (counter >= outputLen || validOutput[counter] != inByte)
688 std::cerr <<
"incorrect output " << counter <<
", " << (word16)validOutput[counter] <<
", " << (word16)inByte <<
"\n";
694 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
696 CRYPTOPP_UNUSED(messageEnd), CRYPTOPP_UNUSED(blocking);
699 FilterTester::PutByte(*inString++);
702 if (counter != outputLen)
715 const byte *validOutput;
716 size_t outputLen, counter;
728 bt.
Put(in, randomLen);
733 return ft->GetResult();
738 cout <<
"\nDES validation suite running...\n\n";
743 cout <<
"\nTesting EDE2, EDE3, and XEX3 variants...\n\n";
761 for (
unsigned int i=1; i<20480; i*=2)
775 if (!TestFilter(filter, plaintext, length, plaintext, length))
782 bool ValidateCipherModes()
784 cout <<
"\nTesting DES modes...\n\n";
785 const byte key[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
786 const byte iv[] = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
787 const byte plain[] = {
788 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
789 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
790 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20};
793 bool pass=
true, fail;
797 const byte encrypted[] = {
798 0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15,
799 0x6a, 0x27, 0x17, 0x87, 0xab, 0x88, 0x83, 0xf9,
800 0x89, 0x3d, 0x51, 0xec, 0x4b, 0x56, 0x3b, 0x53};
804 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
805 pass = pass && !fail;
806 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB encryption" << endl;
810 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
811 pass = pass && !fail;
812 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB decryption" << endl;
816 const byte encrypted[] = {
817 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
818 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
819 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6};
823 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
824 pass = pass && !fail;
825 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with no padding" << endl;
829 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
830 pass = pass && !fail;
831 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with no padding" << endl;
833 fail = !TestModeIV(modeE, modeD);
834 pass = pass && !fail;
835 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC mode IV generation" << endl;
840 const byte encrypted[] = {
841 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
842 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
843 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
844 0x62, 0xC1, 0x6A, 0x27, 0xE4, 0xFC, 0xF2, 0x77};
848 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
849 pass = pass && !fail;
850 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with PKCS #7 padding" << endl;
854 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
855 pass = pass && !fail;
856 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with PKCS #7 padding" << endl;
861 const byte encrypted[] = {
862 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
863 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
864 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
865 0xcf, 0xb7, 0xc7, 0x64, 0x0e, 0x7c, 0xd9, 0xa7};
869 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
870 pass = pass && !fail;
871 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with one-and-zeros padding" << endl;
875 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
876 pass = pass && !fail;
877 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with one-and-zeros padding" << endl;
880 const byte plain_1[] = {
'a', 0, 0, 0, 0, 0, 0, 0};
882 const byte encrypted[] = {
883 0x9B, 0x47, 0x57, 0x59, 0xD6, 0x9C, 0xF6, 0xD0};
887 plain_1, 1, encrypted,
sizeof(encrypted));
888 pass = pass && !fail;
889 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with zeros padding" << endl;
893 encrypted,
sizeof(encrypted), plain_1,
sizeof(plain_1));
894 pass = pass && !fail;
895 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with zeros padding" << endl;
900 const byte encrypted[] = {
901 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
902 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
903 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F};
907 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
908 pass = pass && !fail;
909 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext stealing (CTS)" << endl;
913 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
914 pass = pass && !fail;
915 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext stealing (CTS)" << endl;
917 fail = !TestModeIV(modeE, modeD);
918 pass = pass && !fail;
919 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC CTS IV generation" << endl;
923 const byte decryptionIV[] = {0x4D, 0xD0, 0xAC, 0x8F, 0x47, 0xCF, 0x79, 0xCE};
924 const byte encrypted[] = {0x12, 0x34, 0x56};
929 modeE.SetStolenIV(stolenIV);
931 plain, 3, encrypted,
sizeof(encrypted));
932 fail = memcmp(stolenIV, decryptionIV, 8) != 0 || fail;
933 pass = pass && !fail;
934 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext and IV stealing" << endl;
938 encrypted,
sizeof(encrypted), plain, 3);
939 pass = pass && !fail;
940 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext and IV stealing" << endl;
943 const byte encrypted[] = {
944 0xF3,0x09,0x62,0x49,0xC7,0xF4,0x6E,0x51,
945 0xA6,0x9E,0x83,0x9B,0x1A,0x92,0xF7,0x84,
946 0x03,0x46,0x71,0x33,0x89,0x8E,0xA6,0x22};
950 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
951 pass = pass && !fail;
952 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB encryption" << endl;
956 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
957 pass = pass && !fail;
958 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB decryption" << endl;
960 fail = !TestModeIV(modeE, modeD);
961 pass = pass && !fail;
962 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB mode IV generation" << endl;
965 const byte plain_2[] = {
966 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
967 const byte encrypted[] = {
968 0xf3,0x1f,0xda,0x07,0x01,0x14,0x62,0xee,0x18,0x7f};
972 plain_2,
sizeof(plain_2), encrypted,
sizeof(encrypted));
973 pass = pass && !fail;
974 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) encryption" << endl;
978 encrypted,
sizeof(encrypted), plain_2,
sizeof(plain_2));
979 pass = pass && !fail;
980 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) decryption" << endl;
982 fail = !TestModeIV(modeE, modeD);
983 pass = pass && !fail;
984 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) IV generation" << endl;
987 const byte encrypted[] = {
988 0xf3,0x09,0x62,0x49,0xc7,0xf4,0x6e,0x51,
989 0x35,0xf2,0x4a,0x24,0x2e,0xeb,0x3d,0x3f,
990 0x3d,0x6d,0x5b,0xe3,0x25,0x5a,0xf8,0xc3};
994 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
995 pass = pass && !fail;
996 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB encryption" << endl;
1000 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1001 pass = pass && !fail;
1002 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB decryption" << endl;
1004 fail = !TestModeIV(modeE, modeD);
1005 pass = pass && !fail;
1006 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB IV generation" << endl;
1009 const byte encrypted[] = {
1010 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51,
1011 0x16, 0x3A, 0x8C, 0xA0, 0xFF, 0xC9, 0x4C, 0x27,
1012 0xFA, 0x2F, 0x80, 0xF4, 0x80, 0xB8, 0x6F, 0x75};
1016 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
1017 pass = pass && !fail;
1018 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode encryption" << endl;
1022 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
1023 pass = pass && !fail;
1024 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode decryption" << endl;
1026 fail = !TestModeIV(modeE, modeD);
1027 pass = pass && !fail;
1028 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode IV generation" << endl;
1031 const byte plain_3[] = {
1032 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1033 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1034 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
1035 0x66, 0x6f, 0x72, 0x20};
1036 const byte mac1[] = {
1037 0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
1038 const byte mac2[] = {
1039 0x35, 0x80, 0xC5, 0xC4, 0x6B, 0x81, 0x24, 0xE2};
1043 fail = !TestFilter(cbcmacFilter, plain_3,
sizeof(plain_3), mac1,
sizeof(mac1));
1044 pass = pass && !fail;
1045 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC MAC" << endl;
1049 fail = !TestFilter(dmacFilter, plain_3,
sizeof(plain_3), mac2,
sizeof(mac2));
1050 pass = pass && !fail;
1051 cout << (fail ?
"FAILED " :
"passed ") <<
"DMAC" << endl;
1056 fail = !TestModeIV(modeE, modeD);
1057 pass = pass && !fail;
1058 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CTR Mode" << endl;
1063 fail = !TestModeIV(modeE, modeD);
1064 pass = pass && !fail;
1065 cout << (fail ?
"FAILED " :
"passed ") <<
"AES OFB Mode" << endl;
1070 fail = !TestModeIV(modeE, modeD);
1071 pass = pass && !fail;
1072 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CFB Mode" << endl;
1077 fail = !TestModeIV(modeE, modeD);
1078 pass = pass && !fail;
1079 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CBC Mode" << endl;
1087 cout <<
"\nIDEA validation suite running...\n\n";
1093 bool ValidateSAFER()
1095 cout <<
"\nSAFER validation suite running...\n\n";
1108 cout <<
"\nRC2 validation suite running...\n\n";
1112 SecByteBlock plain(RC2Encryption::BLOCKSIZE), cipher(RC2Encryption::BLOCKSIZE), out(RC2Encryption::BLOCKSIZE), outplain(RC2Encryption::BLOCKSIZE);
1114 bool pass=
true, fail;
1118 byte keyLen, effectiveLen;
1120 valdata.
Get(keyLen);
1121 valdata.
Get(effectiveLen);
1122 valdata.
Get(key, keyLen);
1123 valdata.
Get(plain, RC2Encryption::BLOCKSIZE);
1124 valdata.
Get(cipher, RC2Encryption::BLOCKSIZE);
1127 transE->ProcessBlock(plain, out);
1128 fail = memcmp(out, cipher, RC2Encryption::BLOCKSIZE) != 0;
1131 transD->ProcessBlock(out, outplain);
1132 fail=fail || memcmp(outplain, plain, RC2Encryption::BLOCKSIZE);
1134 pass = pass && !fail;
1136 cout << (fail ?
"FAILED " :
"passed ");
1137 output.
Put(key, keyLen);
1139 output.
Put(outplain, RC2Encryption::BLOCKSIZE);
1141 output.
Put(out, RC2Encryption::BLOCKSIZE);
1149 unsigned char Key0[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
1150 unsigned char Input0[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
1151 unsigned char Output0[] = {0x75,0xb7,0x87,0x80,0x99,0xe0,0xc5,0x96};
1153 unsigned char Key1[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
1154 unsigned char Input1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1155 unsigned char Output1[]={0x74,0x94,0xc2,0xe7,0x10,0x4b,0x08,0x79};
1157 unsigned char Key2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1158 unsigned char Input2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1159 unsigned char Output2[]={0xde,0x18,0x89,0x41,0xa3,0x37,0x5d,0x3a};
1161 unsigned char Key3[]={0xef,0x01,0x23,0x45};
1162 unsigned char Input3[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1163 unsigned char Output3[]={0xd6,0xa1,0x41,0xa7,0xec,0x3c,0x38,0xdf,0xbd,0x61};
1165 unsigned char Key4[]={ 0x01,0x23,0x45,0x67,0x89,0xab, 0xcd,0xef };
1166 unsigned char Input4[] =
1167 {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1168 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1169 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1170 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,
1219 unsigned char Output4[]= {
1220 0x75,0x95,0xc3,0xe6,0x11,0x4a,0x09,0x78,0x0c,0x4a,0xd4,
1221 0x52,0x33,0x8e,0x1f,0xfd,0x9a,0x1b,0xe9,0x49,0x8f,
1222 0x81,0x3d,0x76,0x53,0x34,0x49,0xb6,0x77,0x8d,0xca,
1223 0xd8,0xc7,0x8a,0x8d,0x2b,0xa9,0xac,0x66,0x08,0x5d,
1224 0x0e,0x53,0xd5,0x9c,0x26,0xc2,0xd1,0xc4,0x90,0xc1,
1225 0xeb,0xbe,0x0c,0xe6,0x6d,0x1b,0x6b,0x1b,0x13,0xb6,
1226 0xb9,0x19,0xb8,0x47,0xc2,0x5a,0x91,0x44,0x7a,0x95,
1227 0xe7,0x5e,0x4e,0xf1,0x67,0x79,0xcd,0xe8,0xbf,0x0a,
1228 0x95,0x85,0x0e,0x32,0xaf,0x96,0x89,0x44,0x4f,0xd3,
1229 0x77,0x10,0x8f,0x98,0xfd,0xcb,0xd4,0xe7,0x26,0x56,
1230 0x75,0x00,0x99,0x0b,0xcc,0x7e,0x0c,0xa3,0xc4,0xaa,
1231 0xa3,0x04,0xa3,0x87,0xd2,0x0f,0x3b,0x8f,0xbb,0xcd,
1232 0x42,0xa1,0xbd,0x31,0x1d,0x7a,0x43,0x03,0xdd,0xa5,
1233 0xab,0x07,0x88,0x96,0xae,0x80,0xc1,0x8b,0x0a,0xf6,
1234 0x6d,0xff,0x31,0x96,0x16,0xeb,0x78,0x4e,0x49,0x5a,
1235 0xd2,0xce,0x90,0xd7,0xf7,0x72,0xa8,0x17,0x47,0xb6,
1236 0x5f,0x62,0x09,0x3b,0x1e,0x0d,0xb9,0xe5,0xba,0x53,
1237 0x2f,0xaf,0xec,0x47,0x50,0x83,0x23,0xe6,0x71,0x32,
1238 0x7d,0xf9,0x44,0x44,0x32,0xcb,0x73,0x67,0xce,0xc8,
1239 0x2f,0x5d,0x44,0xc0,0xd0,0x0b,0x67,0xd6,0x50,0xa0,
1240 0x75,0xcd,0x4b,0x70,0xde,0xdd,0x77,0xeb,0x9b,0x10,
1241 0x23,0x1b,0x6b,0x5b,0x74,0x13,0x47,0x39,0x6d,0x62,
1242 0x89,0x74,0x21,0xd4,0x3d,0xf9,0xb4,0x2e,0x44,0x6e,
1243 0x35,0x8e,0x9c,0x11,0xa9,0xb2,0x18,0x4e,0xcb,0xef,
1244 0x0c,0xd8,0xe7,0xa8,0x77,0xef,0x96,0x8f,0x13,0x90,
1245 0xec,0x9b,0x3d,0x35,0xa5,0x58,0x5c,0xb0,0x09,0x29,
1246 0x0e,0x2f,0xcd,0xe7,0xb5,0xec,0x66,0xd9,0x08,0x4b,
1247 0xe4,0x40,0x55,0xa6,0x19,0xd9,0xdd,0x7f,0xc3,0x16,
1248 0x6f,0x94,0x87,0xf7,0xcb,0x27,0x29,0x12,0x42,0x64,
1249 0x45,0x99,0x85,0x14,0xc1,0x5d,0x53,0xa1,0x8c,0x86,
1250 0x4c,0xe3,0xa2,0xb7,0x55,0x57,0x93,0x98,0x81,0x26,
1251 0x52,0x0e,0xac,0xf2,0xe3,0x06,0x6e,0x23,0x0c,0x91,
1252 0xbe,0xe4,0xdd,0x53,0x04,0xf5,0xfd,0x04,0x05,0xb3,
1253 0x5b,0xd9,0x9c,0x73,0x13,0x5d,0x3d,0x9b,0xc3,0x35,
1254 0xee,0x04,0x9e,0xf6,0x9b,0x38,0x67,0xbf,0x2d,0x7b,
1255 0xd1,0xea,0xa5,0x95,0xd8,0xbf,0xc0,0x06,0x6f,0xf8,
1256 0xd3,0x15,0x09,0xeb,0x0c,0x6c,0xaa,0x00,0x6c,0x80,
1257 0x7a,0x62,0x3e,0xf8,0x4c,0x3d,0x33,0xc1,0x95,0xd2,
1258 0x3e,0xe3,0x20,0xc4,0x0d,0xe0,0x55,0x81,0x57,0xc8,
1259 0x22,0xd4,0xb8,0xc5,0x69,0xd8,0x49,0xae,0xd5,0x9d,
1260 0x4e,0x0f,0xd7,0xf3,0x79,0x58,0x6b,0x4b,0x7f,0xf6,
1261 0x84,0xed,0x6a,0x18,0x9f,0x74,0x86,0xd4,0x9b,0x9c,
1262 0x4b,0xad,0x9b,0xa2,0x4b,0x96,0xab,0xf9,0x24,0x37,
1263 0x2c,0x8a,0x8f,0xff,0xb1,0x0d,0x55,0x35,0x49,0x00,
1264 0xa7,0x7a,0x3d,0xb5,0xf2,0x05,0xe1,0xb9,0x9f,0xcd,
1265 0x86,0x60,0x86,0x3a,0x15,0x9a,0xd4,0xab,0xe4,0x0f,
1266 0xa4,0x89,0x34,0x16,0x3d,0xdd,0xe5,0x42,0xa6,0x58,
1267 0x55,0x40,0xfd,0x68,0x3c,0xbf,0xd8,0xc0,0x0f,0x12,
1268 0x12,0x9a,0x28,0x4d,0xea,0xcc,0x4c,0xde,0xfe,0x58,
1269 0xbe,0x71,0x37,0x54,0x1c,0x04,0x71,0x26,0xc8,0xd4,
1270 0x9e,0x27,0x55,0xab,0x18,0x1a,0xb7,0xe9,0x40,0xb0,
1275 bool pass=
true, fail;
1278 cout <<
"\nARC4 validation suite running...\n\n";
1280 arc4.reset(
new Weak::ARC4(Key0,
sizeof(Key0)));
1281 arc4->ProcessString(Input0,
sizeof(Input0));
1282 fail = memcmp(Input0, Output0,
sizeof(Input0)) != 0;
1283 cout << (fail ?
"FAILED" :
"passed") <<
" Test 0" << endl;
1284 pass = pass && !fail;
1286 arc4.reset(
new Weak::ARC4(Key1,
sizeof(Key1)));
1287 arc4->ProcessString(Key1, Input1,
sizeof(Key1));
1288 fail = memcmp(Output1, Key1,
sizeof(Key1)) != 0;
1289 cout << (fail ?
"FAILED" :
"passed") <<
" Test 1" << endl;
1290 pass = pass && !fail;
1292 arc4.reset(
new Weak::ARC4(Key2,
sizeof(Key2)));
1293 for (i=0, fail=
false; i<
sizeof(Input2); i++)
1294 if (arc4->ProcessByte(Input2[i]) != Output2[i])
1296 cout << (fail ?
"FAILED" :
"passed") <<
" Test 2" << endl;
1297 pass = pass && !fail;
1299 arc4.reset(
new Weak::ARC4(Key3,
sizeof(Key3)));
1300 for (i=0, fail=
false; i<
sizeof(Input3); i++)
1301 if (arc4->ProcessByte(Input3[i]) != Output3[i])
1303 cout << (fail ?
"FAILED" :
"passed") <<
" Test 3" << endl;
1304 pass = pass && !fail;
1306 arc4.reset(
new Weak::ARC4(Key4,
sizeof(Key4)));
1307 for (i=0, fail=
false; i<
sizeof(Input4); i++)
1308 if (arc4->ProcessByte(Input4[i]) != Output4[i])
1310 cout << (fail ?
"FAILED" :
"passed") <<
" Test 4" << endl;
1311 pass = pass && !fail;
1318 cout <<
"\nRC5 validation suite running...\n\n";
1326 cout <<
"\nRC6 validation suite running...\n\n";
1338 cout <<
"\nMARS validation suite running...\n\n";
1348 bool ValidateRijndael()
1350 cout <<
"\nRijndael (AES) validation suite running...\n\n";
1357 pass = RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/aes.txt") && pass;
1361 bool ValidateTwofish()
1363 cout <<
"\nTwofish validation suite running...\n\n";
1373 bool ValidateSerpent()
1375 cout <<
"\nSerpent validation suite running...\n\n";
1385 bool ValidateBlowfish()
1387 cout <<
"\nBlowfish validation suite running...\n\n";
1390 const char *key[]={
"abcdefghijklmnopqrstuvwxyz",
"Who is John Galt?"};
1391 byte *plain[]={(byte *)
"BLOWFISH", (byte *)
"\xfe\xdc\xba\x98\x76\x54\x32\x10"};
1392 byte *cipher[]={(byte *)
"\x32\x4e\xd0\xfe\xf4\x13\xa2\x03", (byte *)
"\xcc\x91\x73\x2b\x80\x22\xf6\x84"};
1393 byte out[8], outplain[8];
1394 bool pass=
true, fail;
1396 for (
int i=0; i<2; i++)
1399 enc.ProcessData(out, plain[i], 8);
1400 fail = memcmp(out, cipher[i], 8) != 0;
1403 dec.ProcessData(outplain, cipher[i], 8);
1404 fail = fail || memcmp(outplain, plain[i], 8);
1405 pass = pass && !fail;
1407 cout << (fail ?
"FAILED " :
"passed ");
1408 cout <<
'\"' << key[i] <<
'\"';
1409 for (
int j=0; j<(
signed int)(30-strlen(key[i])); j++)
1411 output.
Put(outplain, 8);
1419 bool ValidateThreeWay()
1421 cout <<
"\n3-WAY validation suite running...\n\n";
1429 cout <<
"\nGOST validation suite running...\n\n";
1435 bool ValidateSHARK()
1437 cout <<
"\nSHARK validation suite running...\n\n";
1447 cout <<
"\nCAST-128 validation suite running...\n\n";
1454 cout <<
"\nCAST-256 validation suite running...\n\n";
1464 bool ValidateSquare()
1466 cout <<
"\nSquare validation suite running...\n\n";
1472 bool ValidateSKIPJACK()
1474 cout <<
"\nSKIPJACK validation suite running...\n\n";
1482 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};
1484 byte key[] = {0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba, 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0};
1485 byte iv[] = {0x01, 0x35, 0x77, 0xaf};
1487 cout <<
"\nSEAL validation suite running...\n\n";
1490 unsigned int size =
sizeof(input);
1493 memset(output, 1, size);
1494 seal.ProcessString(output, input, size);
1495 for (
unsigned int i=0; i<size; i++)
1500 output[1] = seal.ProcessByte(output[1]);
1501 seal.ProcessString(output+2, size-2);
1502 pass = pass && memcmp(output+1, input+1, size-1) == 0;
1504 cout << (pass ?
"passed" :
"FAILED") << endl;
1508 bool ValidateBaseCode()
1510 bool pass =
true, fail;
1512 for (
unsigned int i=0; i<255; i++)
1514 static const char hexEncoded[] =
1515 "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627" 1516 "28292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F" 1517 "505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F7071727374757677" 1518 "78797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F" 1519 "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7" 1520 "C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF" 1521 "F0F1F2F3F4F5F6F7F8F9FAFBFCFDFE";
1522 static const char base32Encoded[] =
1523 "AAASEA2EAWDAQCAJBIFS2DIQB6IBCESVCSKTNF22DEPBYHA7D2RUAIJCENUCKJTHFAWUWK3NFWZC8NBT" 1524 "GI3VIPJYG66DUQT5HS8V6R4AIFBEGTCFI3DWSUKKJPGE4VURKBIXEW4WKXMFQYC3MJPX2ZK8M7SGC2VD" 1525 "NTUYN35IPFXGY5DPP3ZZA6MUQP4HK7VZRB6ZW856RX9H9AEBSKB2JBNGS8EIVCWMTUG27D6SUGJJHFEX" 1526 "U4M3TGN4VQQJ5HW9WCS4FI7EWYVKRKFJXKX43MPQX82MDNXVYU45PP72ZG7MZRF7Z496BSQC2RCNMTYH" 1527 "3DE6XU8N3ZHN9WGT4MJ7JXQY49NPVYY55VQ77Z9A6HTQH3HF65V8T4RK7RYQ55ZR8D29F69W8Z5RR8H3" 1529 const char *base64AndHexEncoded =
1530 "41414543417751464267634943516F4C4441304F4478415245684D554652595847426B6147787764" 1531 "486838674953496A4A43556D4A7967704B6973734C5334764D4445794D7A51310A4E6A63344F546F" 1532 "375044302B50304242516B4E4552555A4853456C4B5330784E546B395155564A5456465657563168" 1533 "5A576C746358563566594746695932526C5A6D646F615770720A6247317562334278636E4E306458" 1534 "5A3365486C3665337839666E2B4167594B44684957476834694A696F754D6A5936506B4A47536B35" 1535 "53566C7065596D5A71626E4A32656E3643680A6F714F6B7061616E714B6D717136797472712B7773" 1536 "624B7A744C573274376935757275387662362F774D484377385446787366497963724C7A4D334F7A" 1537 "39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673" 1538 "3765377638504879382F5431397666342B6672372F50332B0A";
1540 cout <<
"\nBase64, base32 and hex coding validation suite running...\n\n";
1542 fail = !TestFilter(
HexEncoder().Ref(), data, 255, (
const byte *)hexEncoded, strlen(hexEncoded));
1543 cout << (fail ?
"FAILED " :
"passed ");
1544 cout <<
"Hex Encoding\n";
1545 pass = pass && !fail;
1547 fail = !TestFilter(
HexDecoder().Ref(), (
const byte *)hexEncoded, strlen(hexEncoded), data, 255);
1548 cout << (fail ?
"FAILED " :
"passed ");
1549 cout <<
"Hex Decoding\n";
1550 pass = pass && !fail;
1552 fail = !TestFilter(
Base32Encoder().Ref(), data, 255, (
const byte *)base32Encoded, strlen(base32Encoded));
1553 cout << (fail ?
"FAILED " :
"passed ");
1554 cout <<
"Base32 Encoding\n";
1555 pass = pass && !fail;
1557 fail = !TestFilter(
Base32Decoder().Ref(), (
const byte *)base32Encoded, strlen(base32Encoded), data, 255);
1558 cout << (fail ?
"FAILED " :
"passed ");
1559 cout <<
"Base32 Decoding\n";
1560 pass = pass && !fail;
1562 fail = !TestFilter(
Base64Encoder(
new HexEncoder).Ref(), data, 255, (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded));
1563 cout << (fail ?
"FAILED " :
"passed ");
1564 cout <<
"Base64 Encoding\n";
1565 pass = pass && !fail;
1567 fail = !TestFilter(
HexDecoder(
new Base64Decoder).Ref(), (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded), data, 255);
1568 cout << (fail ?
"FAILED " :
"passed ");
1569 cout <<
"Base64 Decoding\n";
1570 pass = pass && !fail;
1575 bool ValidateSHACAL2()
1577 cout <<
"\nSHACAL-2 validation suite running...\n\n";
1586 bool ValidateCamellia()
1588 cout <<
"\nCamellia validation suite running...\n\n";
1598 bool ValidateSalsa()
1600 cout <<
"\nSalsa validation suite running...\n";
1602 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/salsa.txt");
1605 bool ValidateSosemanuk()
1607 cout <<
"\nSosemanuk validation suite running...\n";
1608 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/sosemanuk.txt");
1613 cout <<
"\nVMAC validation suite running...\n";
1614 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/vmac.txt");
1619 cout <<
"\nAES/CCM validation suite running...\n";
1620 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/ccm.txt");
1625 cout <<
"\nAES/GCM validation suite running...\n";
1626 cout <<
"\n2K tables:";
1628 cout <<
"\n64K tables:";
1634 cout <<
"\nCMAC validation suite running...\n";
1635 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.
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.
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.
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.