5 #define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
45 USING_NAMESPACE(CryptoPP)
48 bool ValidateAll(
bool thorough)
50 bool pass=TestSettings();
51 pass=TestOS_RNG() && pass;
53 pass=ValidateCRC32() && pass;
54 pass=ValidateAdler32() && pass;
55 pass=ValidateMD2() && pass;
56 pass=ValidateMD5() && pass;
57 pass=ValidateSHA() && pass;
58 pass=ValidateTiger() && pass;
59 pass=ValidateRIPEMD() && pass;
60 pass=ValidatePanama() && pass;
61 pass=ValidateWhirlpool() && pass;
63 pass=ValidateHMAC() && pass;
64 pass=ValidateTTMAC() && pass;
66 pass=ValidatePBKDF() && pass;
68 pass=ValidateDES() && pass;
69 pass=ValidateCipherModes() && pass;
70 pass=ValidateIDEA() && pass;
71 pass=ValidateSAFER() && pass;
72 pass=ValidateRC2() && pass;
73 pass=ValidateARC4() && pass;
74 pass=ValidateRC5() && pass;
75 pass=ValidateBlowfish() && pass;
76 pass=ValidateThreeWay() && pass;
77 pass=ValidateGOST() && pass;
78 pass=ValidateSHARK() && pass;
79 pass=ValidateCAST() && pass;
80 pass=ValidateSquare() && pass;
81 pass=ValidateSKIPJACK() && pass;
82 pass=ValidateSEAL() && pass;
83 pass=ValidateRC6() && pass;
84 pass=ValidateMARS() && pass;
85 pass=ValidateRijndael() && pass;
86 pass=ValidateTwofish() && pass;
87 pass=ValidateSerpent() && pass;
88 pass=ValidateSHACAL2() && pass;
89 pass=ValidateCamellia() && pass;
90 pass=ValidateSalsa() && pass;
91 pass=ValidateSosemanuk() && pass;
92 pass=ValidateVMAC() && pass;
93 pass=ValidateCCM() && pass;
94 pass=ValidateGCM() && pass;
95 pass=ValidateCMAC() && pass;
96 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/eax.txt") && pass;
97 pass=RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/seed.txt") && pass;
99 pass=ValidateBBS() && pass;
100 pass=ValidateDH() && pass;
101 pass=ValidateMQV() && pass;
102 pass=ValidateRSA() && pass;
103 pass=ValidateElGamal() && pass;
104 pass=ValidateDLIES() && pass;
105 pass=ValidateNR() && pass;
106 pass=ValidateDSA(thorough) && pass;
107 pass=ValidateLUC() && pass;
108 pass=ValidateLUC_DH() && pass;
109 pass=ValidateLUC_DL() && pass;
110 pass=ValidateXTR_DH() && pass;
111 pass=ValidateRabin() && pass;
112 pass=ValidateRW() && pass;
114 pass=ValidateECP() && pass;
115 pass=ValidateEC2N() && pass;
116 pass=ValidateECDSA() && pass;
117 pass=ValidateESIGN() && pass;
120 cout <<
"\nAll tests passed!\n";
122 cout <<
"\nOops! Not all tests passed.\n";
131 cout <<
"\nTesting Settings...\n\n";
134 memcpy_s(&w,
sizeof(w),
"\x01\x02\x03\x04", 4);
136 if (w == 0x04030201L)
138 #ifdef IS_LITTLE_ENDIAN
144 cout <<
"Your machine is little endian.\n";
146 else if (w == 0x01020304L)
148 #ifndef IS_LITTLE_ENDIAN
154 cout <<
"Your machine is big endian.\n";
158 cout <<
"FAILED: Your machine is neither big endian nor little endian.\n";
162 #ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS
163 byte testvals[10] = {1,2,2,3,3,3,3,2,2,1};
164 if (*(word32 *)(testvals+3) == 0x03030303 && *(word64 *)(testvals+1) == W64LIT(0x0202030303030202))
165 cout <<
"passed: Your machine allows unaligned data access.\n";
168 cout <<
"FAILED: Unaligned data access gave incorrect results.\n";
172 cout <<
"passed: CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS is not defined. Will restrict to aligned data access.\n";
175 if (
sizeof(byte) == 1)
182 cout <<
"sizeof(byte) == " <<
sizeof(byte) << endl;
184 if (
sizeof(word16) == 2)
191 cout <<
"sizeof(word16) == " <<
sizeof(word16) << endl;
193 if (
sizeof(word32) == 4)
200 cout <<
"sizeof(word32) == " <<
sizeof(word32) << endl;
202 if (
sizeof(word64) == 8)
209 cout <<
"sizeof(word64) == " <<
sizeof(word64) << endl;
211 #ifdef CRYPTOPP_WORD128_AVAILABLE
212 if (
sizeof(word128) == 16)
219 cout <<
"sizeof(word128) == " <<
sizeof(word128) << endl;
222 if (
sizeof(word) == 2*
sizeof(hword)
223 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
224 &&
sizeof(dword) == 2*
sizeof(word)
233 cout <<
"sizeof(hword) == " <<
sizeof(hword) <<
", sizeof(word) == " <<
sizeof(word);
234 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
235 cout <<
", sizeof(dword) == " <<
sizeof(dword);
239 #ifdef CRYPTOPP_CPUID_AVAILABLE
240 bool hasMMX = HasMMX();
241 bool hasISSE = HasISSE();
242 bool hasSSE2 = HasSSE2();
243 bool hasSSSE3 = HasSSSE3();
245 int cacheLineSize = GetCacheLineSize();
247 if ((isP4 && (!hasMMX || !hasSSE2)) || (hasSSE2 && !hasMMX) || (cacheLineSize < 16 || cacheLineSize > 256 || !IsPowerOf2(cacheLineSize)))
255 cout <<
"hasMMX == " << hasMMX <<
", hasISSE == " << hasISSE <<
", hasSSE2 == " << hasSSE2 <<
", hasSSSE3 == " << hasSSSE3 <<
", hasAESNI == " << HasAESNI() <<
", hasCLMUL == " << HasCLMUL() <<
", isP4 == " << isP4 <<
", cacheLineSize == " << cacheLineSize;
256 cout <<
", AESNI_INTRINSICS == " << CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE << endl;
261 cout <<
"Some critical setting in config.h is in error. Please fix it and recompile." << endl;
272 #ifdef BLOCKING_RNG_AVAILABLE
279 cout <<
"\nTesting operating system provided blocking random number generator...\n\n";
283 unsigned long total=0, length=0;
284 time_t t = time(NULL), t1 = 0;
287 while (total < 16 && (t1 < 10 || total*8 > (
unsigned long)t1))
301 cout <<
" it took " << long(t1) <<
" seconds to generate " << total <<
" bytes" << endl;
303 #if 0 // disable this part. it's causing an unpredictable pause during the validation testing
309 while (time(NULL) - t < 2)
318 while (time(NULL) - t < 2)
331 cout <<
" it generated " << length <<
" bytes in " << long(time(NULL) - t) <<
" seconds" << endl;
335 test.AttachedTransformation()->MessageEnd();
337 if (sink->TotalPutLength() < total)
344 cout <<
" " << total <<
" generated bytes compressed to " << (size_t)sink->TotalPutLength() <<
" bytes by DEFLATE" << endl;
347 cout <<
"\nNo operating system provided blocking random number generator, skipping test." << endl;
350 #ifdef NONBLOCKING_RNG_AVAILABLE
357 cout <<
"\nTesting operating system provided nonblocking random number generator...\n\n";
362 if (sink->TotalPutLength() < 100000)
369 cout <<
" 100000 generated bytes compressed to " << (size_t)sink->TotalPutLength() <<
" bytes by DEFLATE" << endl;
372 cout <<
"\nNo operating system provided nonblocking random number generator, skipping test." << endl;
378 typedef auto_ptr<BlockTransformation> apbt;
383 virtual unsigned int BlockSize()
const =0;
384 virtual unsigned int KeyLength()
const =0;
386 virtual apbt NewEncryption(
const byte *key)
const =0;
387 virtual apbt NewDecryption(
const byte *key)
const =0;
394 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
395 unsigned int KeyLength()
const {
return m_keylen;}
397 apbt NewEncryption(
const byte *key)
const
398 {
return apbt(
new E(key, m_keylen));}
399 apbt NewDecryption(
const byte *key)
const
400 {
return apbt(
new D(key, m_keylen));}
402 unsigned int m_keylen;
409 : m_keylen(keylen ? keylen : E::DEFAULT_KEYLENGTH), m_rounds(rounds ? rounds : E::DEFAULT_ROUNDS) {}
410 unsigned int BlockSize()
const {
return E::BLOCKSIZE;}
411 unsigned int KeyLength()
const {
return m_keylen;}
413 apbt NewEncryption(
const byte *key)
const
414 {
return apbt(
new E(key, m_keylen, m_rounds));}
415 apbt NewDecryption(
const byte *key)
const
416 {
return apbt(
new D(key, m_keylen, m_rounds));}
418 unsigned int m_keylen, m_rounds;
424 SecByteBlock plain(cg.BlockSize()), cipher(cg.BlockSize()), out(cg.BlockSize()), outplain(cg.BlockSize());
426 bool pass=
true, fail;
430 valdata.
Get(key, cg.KeyLength());
431 valdata.
Get(plain, cg.BlockSize());
432 valdata.
Get(cipher, cg.BlockSize());
434 apbt transE = cg.NewEncryption(key);
435 transE->ProcessBlock(plain, out);
436 fail = memcmp(out, cipher, cg.BlockSize()) != 0;
438 apbt transD = cg.NewDecryption(key);
439 transD->ProcessBlock(out, outplain);
440 fail=fail || memcmp(outplain, plain, cg.BlockSize());
442 pass = pass && !fail;
444 cout << (fail ?
"FAILED " :
"passed ");
445 output.Put(key, cg.KeyLength());
447 output.Put(outplain, cg.BlockSize());
449 output.Put(out, cg.BlockSize());
459 : validOutput(validOutput), outputLen(outputLen), counter(0), fail(
false) {}
460 void PutByte(byte inByte)
462 if (counter >= outputLen || validOutput[counter] != inByte)
464 std::cerr <<
"incorrect output " << counter <<
", " << (word16)validOutput[counter] <<
", " << (word16)inByte <<
"\n";
470 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
473 FilterTester::PutByte(*inString++);
476 if (counter != outputLen)
489 const byte *validOutput;
490 size_t outputLen, counter;
502 bt.
Put(in, randomLen);
507 return ft->GetResult();
512 cout <<
"\nDES validation suite running...\n\n";
517 cout <<
"\nTesting EDE2, EDE3, and XEX3 variants...\n\n";
531 byte plaintext[20480];
533 for (
unsigned int i=1; i<
sizeof(plaintext); i*=2)
544 unsigned int length = STDMAX(GlobalRNG().GenerateWord32(0, i), (word32)e.
MinLastBlockSize());
547 if (!TestFilter(filter, plaintext, length, plaintext, length))
554 bool ValidateCipherModes()
556 cout <<
"\nTesting DES modes...\n\n";
557 const byte key[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
558 const byte iv[] = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
559 const byte plain[] = {
560 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
561 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
562 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20};
565 bool pass=
true, fail;
569 const byte encrypted[] = {
570 0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15,
571 0x6a, 0x27, 0x17, 0x87, 0xab, 0x88, 0x83, 0xf9,
572 0x89, 0x3d, 0x51, 0xec, 0x4b, 0x56, 0x3b, 0x53};
576 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
577 pass = pass && !fail;
578 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB encryption" << endl;
582 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
583 pass = pass && !fail;
584 cout << (fail ?
"FAILED " :
"passed ") <<
"ECB decryption" << endl;
588 const byte encrypted[] = {
589 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
590 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
591 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6};
595 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
596 pass = pass && !fail;
597 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with no padding" << endl;
601 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
602 pass = pass && !fail;
603 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with no padding" << endl;
605 fail = !TestModeIV(modeE, modeD);
606 pass = pass && !fail;
607 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC mode IV generation" << endl;
612 const byte encrypted[] = {
613 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
614 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
615 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
616 0x62, 0xC1, 0x6A, 0x27, 0xE4, 0xFC, 0xF2, 0x77};
620 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
621 pass = pass && !fail;
622 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with PKCS #7 padding" << endl;
626 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
627 pass = pass && !fail;
628 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with PKCS #7 padding" << endl;
633 const byte encrypted[] = {
634 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
635 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
636 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
637 0xcf, 0xb7, 0xc7, 0x64, 0x0e, 0x7c, 0xd9, 0xa7};
641 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
642 pass = pass && !fail;
643 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with one-and-zeros padding" << endl;
647 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
648 pass = pass && !fail;
649 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with one-and-zeros padding" << endl;
652 const byte plain[] = {
'a', 0, 0, 0, 0, 0, 0, 0};
654 const byte encrypted[] = {
655 0x9B, 0x47, 0x57, 0x59, 0xD6, 0x9C, 0xF6, 0xD0};
659 plain, 1, encrypted,
sizeof(encrypted));
660 pass = pass && !fail;
661 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with zeros padding" << endl;
665 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
666 pass = pass && !fail;
667 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with zeros padding" << endl;
672 const byte encrypted[] = {
673 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
674 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
675 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F};
679 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
680 pass = pass && !fail;
681 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext stealing (CTS)" << endl;
685 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
686 pass = pass && !fail;
687 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext stealing (CTS)" << endl;
689 fail = !TestModeIV(modeE, modeD);
690 pass = pass && !fail;
691 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC CTS IV generation" << endl;
695 const byte decryptionIV[] = {0x4D, 0xD0, 0xAC, 0x8F, 0x47, 0xCF, 0x79, 0xCE};
696 const byte encrypted[] = {0x12, 0x34, 0x56};
701 modeE.SetStolenIV(stolenIV);
703 plain, 3, encrypted,
sizeof(encrypted));
704 fail = memcmp(stolenIV, decryptionIV, 8) != 0 || fail;
705 pass = pass && !fail;
706 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC encryption with ciphertext and IV stealing" << endl;
710 encrypted,
sizeof(encrypted), plain, 3);
711 pass = pass && !fail;
712 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC decryption with ciphertext and IV stealing" << endl;
715 const byte encrypted[] = {
716 0xF3,0x09,0x62,0x49,0xC7,0xF4,0x6E,0x51,
717 0xA6,0x9E,0x83,0x9B,0x1A,0x92,0xF7,0x84,
718 0x03,0x46,0x71,0x33,0x89,0x8E,0xA6,0x22};
722 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
723 pass = pass && !fail;
724 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB encryption" << endl;
728 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
729 pass = pass && !fail;
730 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB decryption" << endl;
732 fail = !TestModeIV(modeE, modeD);
733 pass = pass && !fail;
734 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB mode IV generation" << endl;
737 const byte plain[] = {
738 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
739 const byte encrypted[] = {
740 0xf3,0x1f,0xda,0x07,0x01,0x14,0x62,0xee,0x18,0x7f};
744 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
745 pass = pass && !fail;
746 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) encryption" << endl;
750 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
751 pass = pass && !fail;
752 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) decryption" << endl;
754 fail = !TestModeIV(modeE, modeD);
755 pass = pass && !fail;
756 cout << (fail ?
"FAILED " :
"passed ") <<
"CFB (8-bit feedback) IV generation" << endl;
759 const byte encrypted[] = {
760 0xf3,0x09,0x62,0x49,0xc7,0xf4,0x6e,0x51,
761 0x35,0xf2,0x4a,0x24,0x2e,0xeb,0x3d,0x3f,
762 0x3d,0x6d,0x5b,0xe3,0x25,0x5a,0xf8,0xc3};
766 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
767 pass = pass && !fail;
768 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB encryption" << endl;
772 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
773 pass = pass && !fail;
774 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB decryption" << endl;
776 fail = !TestModeIV(modeE, modeD);
777 pass = pass && !fail;
778 cout << (fail ?
"FAILED " :
"passed ") <<
"OFB IV generation" << endl;
781 const byte encrypted[] = {
782 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51,
783 0x16, 0x3A, 0x8C, 0xA0, 0xFF, 0xC9, 0x4C, 0x27,
784 0xFA, 0x2F, 0x80, 0xF4, 0x80, 0xB8, 0x6F, 0x75};
788 plain,
sizeof(plain), encrypted,
sizeof(encrypted));
789 pass = pass && !fail;
790 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode encryption" << endl;
794 encrypted,
sizeof(encrypted), plain,
sizeof(plain));
795 pass = pass && !fail;
796 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode decryption" << endl;
798 fail = !TestModeIV(modeE, modeD);
799 pass = pass && !fail;
800 cout << (fail ?
"FAILED " :
"passed ") <<
"Counter Mode IV generation" << endl;
803 const byte plain[] = {
804 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
805 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
806 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
807 0x66, 0x6f, 0x72, 0x20};
808 const byte mac1[] = {
809 0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
810 const byte mac2[] = {
811 0x35, 0x80, 0xC5, 0xC4, 0x6B, 0x81, 0x24, 0xE2};
815 fail = !TestFilter(cbcmacFilter, plain,
sizeof(plain), mac1,
sizeof(mac1));
816 pass = pass && !fail;
817 cout << (fail ?
"FAILED " :
"passed ") <<
"CBC MAC" << endl;
821 fail = !TestFilter(dmacFilter, plain,
sizeof(plain), mac2,
sizeof(mac2));
822 pass = pass && !fail;
823 cout << (fail ?
"FAILED " :
"passed ") <<
"DMAC" << endl;
828 fail = !TestModeIV(modeE, modeD);
829 pass = pass && !fail;
830 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CTR Mode" << endl;
835 fail = !TestModeIV(modeE, modeD);
836 pass = pass && !fail;
837 cout << (fail ?
"FAILED " :
"passed ") <<
"AES OFB Mode" << endl;
842 fail = !TestModeIV(modeE, modeD);
843 pass = pass && !fail;
844 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CFB Mode" << endl;
849 fail = !TestModeIV(modeE, modeD);
850 pass = pass && !fail;
851 cout << (fail ?
"FAILED " :
"passed ") <<
"AES CBC Mode" << endl;
859 cout <<
"\nIDEA validation suite running...\n\n";
867 cout <<
"\nSAFER validation suite running...\n\n";
880 cout <<
"\nRC2 validation suite running...\n\n";
884 SecByteBlock plain(RC2Encryption::BLOCKSIZE), cipher(RC2Encryption::BLOCKSIZE), out(RC2Encryption::BLOCKSIZE), outplain(RC2Encryption::BLOCKSIZE);
886 bool pass=
true, fail;
890 byte keyLen, effectiveLen;
893 valdata.
Get(effectiveLen);
894 valdata.
Get(key, keyLen);
895 valdata.
Get(plain, RC2Encryption::BLOCKSIZE);
896 valdata.
Get(cipher, RC2Encryption::BLOCKSIZE);
899 transE->ProcessBlock(plain, out);
900 fail = memcmp(out, cipher, RC2Encryption::BLOCKSIZE) != 0;
903 transD->ProcessBlock(out, outplain);
904 fail=fail || memcmp(outplain, plain, RC2Encryption::BLOCKSIZE);
906 pass = pass && !fail;
908 cout << (fail ?
"FAILED " :
"passed ");
909 output.Put(key, keyLen);
911 output.Put(outplain, RC2Encryption::BLOCKSIZE);
913 output.Put(out, RC2Encryption::BLOCKSIZE);
921 unsigned char Key0[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
922 unsigned char Input0[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
923 unsigned char Output0[] = {0x75,0xb7,0x87,0x80,0x99,0xe0,0xc5,0x96};
925 unsigned char Key1[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
926 unsigned char Input1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
927 unsigned char Output1[]={0x74,0x94,0xc2,0xe7,0x10,0x4b,0x08,0x79};
929 unsigned char Key2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
930 unsigned char Input2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
931 unsigned char Output2[]={0xde,0x18,0x89,0x41,0xa3,0x37,0x5d,0x3a};
933 unsigned char Key3[]={0xef,0x01,0x23,0x45};
934 unsigned char Input3[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
935 unsigned char Output3[]={0xd6,0xa1,0x41,0xa7,0xec,0x3c,0x38,0xdf,0xbd,0x61};
937 unsigned char Key4[]={ 0x01,0x23,0x45,0x67,0x89,0xab, 0xcd,0xef };
938 unsigned char Input4[] =
939 {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
940 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
941 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
942 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
943 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
944 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
945 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
946 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
947 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
948 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
949 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
950 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
951 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
952 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
953 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
954 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
955 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
956 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
957 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
958 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
959 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
960 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
961 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
962 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
963 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
964 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
965 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
966 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
967 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
968 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
969 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
970 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
971 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
972 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
973 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
974 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
975 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
976 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
977 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
978 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
979 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
980 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
981 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
982 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
983 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
984 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
985 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
986 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
987 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
988 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
989 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
991 unsigned char Output4[]= {
992 0x75,0x95,0xc3,0xe6,0x11,0x4a,0x09,0x78,0x0c,0x4a,0xd4,
993 0x52,0x33,0x8e,0x1f,0xfd,0x9a,0x1b,0xe9,0x49,0x8f,
994 0x81,0x3d,0x76,0x53,0x34,0x49,0xb6,0x77,0x8d,0xca,
995 0xd8,0xc7,0x8a,0x8d,0x2b,0xa9,0xac,0x66,0x08,0x5d,
996 0x0e,0x53,0xd5,0x9c,0x26,0xc2,0xd1,0xc4,0x90,0xc1,
997 0xeb,0xbe,0x0c,0xe6,0x6d,0x1b,0x6b,0x1b,0x13,0xb6,
998 0xb9,0x19,0xb8,0x47,0xc2,0x5a,0x91,0x44,0x7a,0x95,
999 0xe7,0x5e,0x4e,0xf1,0x67,0x79,0xcd,0xe8,0xbf,0x0a,
1000 0x95,0x85,0x0e,0x32,0xaf,0x96,0x89,0x44,0x4f,0xd3,
1001 0x77,0x10,0x8f,0x98,0xfd,0xcb,0xd4,0xe7,0x26,0x56,
1002 0x75,0x00,0x99,0x0b,0xcc,0x7e,0x0c,0xa3,0xc4,0xaa,
1003 0xa3,0x04,0xa3,0x87,0xd2,0x0f,0x3b,0x8f,0xbb,0xcd,
1004 0x42,0xa1,0xbd,0x31,0x1d,0x7a,0x43,0x03,0xdd,0xa5,
1005 0xab,0x07,0x88,0x96,0xae,0x80,0xc1,0x8b,0x0a,0xf6,
1006 0x6d,0xff,0x31,0x96,0x16,0xeb,0x78,0x4e,0x49,0x5a,
1007 0xd2,0xce,0x90,0xd7,0xf7,0x72,0xa8,0x17,0x47,0xb6,
1008 0x5f,0x62,0x09,0x3b,0x1e,0x0d,0xb9,0xe5,0xba,0x53,
1009 0x2f,0xaf,0xec,0x47,0x50,0x83,0x23,0xe6,0x71,0x32,
1010 0x7d,0xf9,0x44,0x44,0x32,0xcb,0x73,0x67,0xce,0xc8,
1011 0x2f,0x5d,0x44,0xc0,0xd0,0x0b,0x67,0xd6,0x50,0xa0,
1012 0x75,0xcd,0x4b,0x70,0xde,0xdd,0x77,0xeb,0x9b,0x10,
1013 0x23,0x1b,0x6b,0x5b,0x74,0x13,0x47,0x39,0x6d,0x62,
1014 0x89,0x74,0x21,0xd4,0x3d,0xf9,0xb4,0x2e,0x44,0x6e,
1015 0x35,0x8e,0x9c,0x11,0xa9,0xb2,0x18,0x4e,0xcb,0xef,
1016 0x0c,0xd8,0xe7,0xa8,0x77,0xef,0x96,0x8f,0x13,0x90,
1017 0xec,0x9b,0x3d,0x35,0xa5,0x58,0x5c,0xb0,0x09,0x29,
1018 0x0e,0x2f,0xcd,0xe7,0xb5,0xec,0x66,0xd9,0x08,0x4b,
1019 0xe4,0x40,0x55,0xa6,0x19,0xd9,0xdd,0x7f,0xc3,0x16,
1020 0x6f,0x94,0x87,0xf7,0xcb,0x27,0x29,0x12,0x42,0x64,
1021 0x45,0x99,0x85,0x14,0xc1,0x5d,0x53,0xa1,0x8c,0x86,
1022 0x4c,0xe3,0xa2,0xb7,0x55,0x57,0x93,0x98,0x81,0x26,
1023 0x52,0x0e,0xac,0xf2,0xe3,0x06,0x6e,0x23,0x0c,0x91,
1024 0xbe,0xe4,0xdd,0x53,0x04,0xf5,0xfd,0x04,0x05,0xb3,
1025 0x5b,0xd9,0x9c,0x73,0x13,0x5d,0x3d,0x9b,0xc3,0x35,
1026 0xee,0x04,0x9e,0xf6,0x9b,0x38,0x67,0xbf,0x2d,0x7b,
1027 0xd1,0xea,0xa5,0x95,0xd8,0xbf,0xc0,0x06,0x6f,0xf8,
1028 0xd3,0x15,0x09,0xeb,0x0c,0x6c,0xaa,0x00,0x6c,0x80,
1029 0x7a,0x62,0x3e,0xf8,0x4c,0x3d,0x33,0xc1,0x95,0xd2,
1030 0x3e,0xe3,0x20,0xc4,0x0d,0xe0,0x55,0x81,0x57,0xc8,
1031 0x22,0xd4,0xb8,0xc5,0x69,0xd8,0x49,0xae,0xd5,0x9d,
1032 0x4e,0x0f,0xd7,0xf3,0x79,0x58,0x6b,0x4b,0x7f,0xf6,
1033 0x84,0xed,0x6a,0x18,0x9f,0x74,0x86,0xd4,0x9b,0x9c,
1034 0x4b,0xad,0x9b,0xa2,0x4b,0x96,0xab,0xf9,0x24,0x37,
1035 0x2c,0x8a,0x8f,0xff,0xb1,0x0d,0x55,0x35,0x49,0x00,
1036 0xa7,0x7a,0x3d,0xb5,0xf2,0x05,0xe1,0xb9,0x9f,0xcd,
1037 0x86,0x60,0x86,0x3a,0x15,0x9a,0xd4,0xab,0xe4,0x0f,
1038 0xa4,0x89,0x34,0x16,0x3d,0xdd,0xe5,0x42,0xa6,0x58,
1039 0x55,0x40,0xfd,0x68,0x3c,0xbf,0xd8,0xc0,0x0f,0x12,
1040 0x12,0x9a,0x28,0x4d,0xea,0xcc,0x4c,0xde,0xfe,0x58,
1041 0xbe,0x71,0x37,0x54,0x1c,0x04,0x71,0x26,0xc8,0xd4,
1042 0x9e,0x27,0x55,0xab,0x18,0x1a,0xb7,0xe9,0x40,0xb0,
1047 bool pass=
true, fail;
1050 cout <<
"\nARC4 validation suite running...\n\n";
1052 arc4.reset(
new Weak::ARC4(Key0,
sizeof(Key0)));
1053 arc4->ProcessString(Input0,
sizeof(Input0));
1054 fail = memcmp(Input0, Output0,
sizeof(Input0)) != 0;
1055 cout << (fail ?
"FAILED" :
"passed") <<
" Test 0" << endl;
1056 pass = pass && !fail;
1058 arc4.reset(
new Weak::ARC4(Key1,
sizeof(Key1)));
1059 arc4->ProcessString(Key1, Input1,
sizeof(Key1));
1060 fail = memcmp(Output1, Key1,
sizeof(Key1)) != 0;
1061 cout << (fail ?
"FAILED" :
"passed") <<
" Test 1" << endl;
1062 pass = pass && !fail;
1064 arc4.reset(
new Weak::ARC4(Key2,
sizeof(Key2)));
1065 for (i=0, fail=
false; i<
sizeof(Input2); i++)
1066 if (arc4->ProcessByte(Input2[i]) != Output2[i])
1068 cout << (fail ?
"FAILED" :
"passed") <<
" Test 2" << endl;
1069 pass = pass && !fail;
1071 arc4.reset(
new Weak::ARC4(Key3,
sizeof(Key3)));
1072 for (i=0, fail=
false; i<
sizeof(Input3); i++)
1073 if (arc4->ProcessByte(Input3[i]) != Output3[i])
1075 cout << (fail ?
"FAILED" :
"passed") <<
" Test 3" << endl;
1076 pass = pass && !fail;
1078 arc4.reset(
new Weak::ARC4(Key4,
sizeof(Key4)));
1079 for (i=0, fail=
false; i<
sizeof(Input4); i++)
1080 if (arc4->ProcessByte(Input4[i]) != Output4[i])
1082 cout << (fail ?
"FAILED" :
"passed") <<
" Test 4" << endl;
1083 pass = pass && !fail;
1090 cout <<
"\nRC5 validation suite running...\n\n";
1098 cout <<
"\nRC6 validation suite running...\n\n";
1110 cout <<
"\nMARS validation suite running...\n\n";
1120 bool ValidateRijndael()
1122 cout <<
"\nRijndael (AES) validation suite running...\n\n";
1129 pass = RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/aes.txt") && pass;
1133 bool ValidateTwofish()
1135 cout <<
"\nTwofish validation suite running...\n\n";
1145 bool ValidateSerpent()
1147 cout <<
"\nSerpent validation suite running...\n\n";
1157 bool ValidateBlowfish()
1159 cout <<
"\nBlowfish validation suite running...\n\n";
1162 const char *key[]={
"abcdefghijklmnopqrstuvwxyz",
"Who is John Galt?"};
1163 byte *plain[]={(byte *)
"BLOWFISH", (byte *)
"\xfe\xdc\xba\x98\x76\x54\x32\x10"};
1164 byte *cipher[]={(byte *)
"\x32\x4e\xd0\xfe\xf4\x13\xa2\x03", (byte *)
"\xcc\x91\x73\x2b\x80\x22\xf6\x84"};
1165 byte out[8], outplain[8];
1166 bool pass=
true, fail;
1168 for (
int i=0; i<2; i++)
1171 enc.ProcessData(out, plain[i], 8);
1172 fail = memcmp(out, cipher[i], 8) != 0;
1175 dec.ProcessData(outplain, cipher[i], 8);
1176 fail = fail || memcmp(outplain, plain[i], 8);
1177 pass = pass && !fail;
1179 cout << (fail ?
"FAILED " :
"passed ");
1180 cout <<
'\"' << key[i] <<
'\"';
1181 for (
int j=0; j<(
signed int)(30-strlen(key[i])); j++)
1183 output.Put(outplain, 8);
1191 bool ValidateThreeWay()
1193 cout <<
"\n3-WAY validation suite running...\n\n";
1201 cout <<
"\nGOST validation suite running...\n\n";
1207 bool ValidateSHARK()
1209 cout <<
"\nSHARK validation suite running...\n\n";
1219 cout <<
"\nCAST-128 validation suite running...\n\n";
1226 cout <<
"\nCAST-256 validation suite running...\n\n";
1236 bool ValidateSquare()
1238 cout <<
"\nSquare validation suite running...\n\n";
1244 bool ValidateSKIPJACK()
1246 cout <<
"\nSKIPJACK validation suite running...\n\n";
1254 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};
1256 byte key[] = {0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba, 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0};
1257 byte iv[] = {0x01, 0x35, 0x77, 0xaf};
1259 cout <<
"\nSEAL validation suite running...\n\n";
1262 unsigned int size =
sizeof(input);
1265 memset(output, 1, size);
1266 seal.ProcessString(output, input, size);
1267 for (
unsigned int i=0; i<size; i++)
1272 output[1] = seal.ProcessByte(output[1]);
1273 seal.ProcessString(output+2, size-2);
1274 pass = pass && memcmp(output+1, input+1, size-1) == 0;
1276 cout << (pass ?
"passed" :
"FAILED") << endl;
1280 bool ValidateBaseCode()
1282 bool pass =
true, fail;
1284 for (
unsigned int i=0; i<255; i++)
1286 const char *hexEncoded =
1287 "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627"
1288 "28292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F"
1289 "505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F7071727374757677"
1290 "78797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F"
1291 "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7"
1292 "C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF"
1293 "F0F1F2F3F4F5F6F7F8F9FAFBFCFDFE";
1294 const char *base32Encoded =
1295 "AAASEA2EAWDAQCAJBIFS2DIQB6IBCESVCSKTNF22DEPBYHA7D2RUAIJCENUCKJTHFAWUWK3NFWZC8NBT"
1296 "GI3VIPJYG66DUQT5HS8V6R4AIFBEGTCFI3DWSUKKJPGE4VURKBIXEW4WKXMFQYC3MJPX2ZK8M7SGC2VD"
1297 "NTUYN35IPFXGY5DPP3ZZA6MUQP4HK7VZRB6ZW856RX9H9AEBSKB2JBNGS8EIVCWMTUG27D6SUGJJHFEX"
1298 "U4M3TGN4VQQJ5HW9WCS4FI7EWYVKRKFJXKX43MPQX82MDNXVYU45PP72ZG7MZRF7Z496BSQC2RCNMTYH"
1299 "3DE6XU8N3ZHN9WGT4MJ7JXQY49NPVYY55VQ77Z9A6HTQH3HF65V8T4RK7RYQ55ZR8D29F69W8Z5RR8H3"
1301 const char *base64AndHexEncoded =
1302 "41414543417751464267634943516F4C4441304F4478415245684D554652595847426B6147787764"
1303 "486838674953496A4A43556D4A7967704B6973734C5334764D4445794D7A51310A4E6A63344F546F"
1304 "375044302B50304242516B4E4552555A4853456C4B5330784E546B395155564A5456465657563168"
1305 "5A576C746358563566594746695932526C5A6D646F615770720A6247317562334278636E4E306458"
1306 "5A3365486C3665337839666E2B4167594B44684957476834694A696F754D6A5936506B4A47536B35"
1307 "53566C7065596D5A71626E4A32656E3643680A6F714F6B7061616E714B6D717136797472712B7773"
1308 "624B7A744C573274376935757275387662362F774D484377385446787366497963724C7A4D334F7A"
1309 "39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673"
1310 "3765377638504879382F5431397666342B6672372F50332B0A";
1312 cout <<
"\nBase64, base32 and hex coding validation suite running...\n\n";
1314 fail = !TestFilter(
HexEncoder().Ref(), data, 255, (
const byte *)hexEncoded, strlen(hexEncoded));
1315 cout << (fail ?
"FAILED " :
"passed ");
1316 cout <<
"Hex Encoding\n";
1317 pass = pass && !fail;
1319 fail = !TestFilter(
HexDecoder().Ref(), (
const byte *)hexEncoded, strlen(hexEncoded), data, 255);
1320 cout << (fail ?
"FAILED " :
"passed ");
1321 cout <<
"Hex Decoding\n";
1322 pass = pass && !fail;
1324 fail = !TestFilter(
Base32Encoder().Ref(), data, 255, (
const byte *)base32Encoded, strlen(base32Encoded));
1325 cout << (fail ?
"FAILED " :
"passed ");
1326 cout <<
"Base32 Encoding\n";
1327 pass = pass && !fail;
1329 fail = !TestFilter(
Base32Decoder().Ref(), (
const byte *)base32Encoded, strlen(base32Encoded), data, 255);
1330 cout << (fail ?
"FAILED " :
"passed ");
1331 cout <<
"Base32 Decoding\n";
1332 pass = pass && !fail;
1334 fail = !TestFilter(
Base64Encoder(
new HexEncoder).Ref(), data, 255, (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded));
1335 cout << (fail ?
"FAILED " :
"passed ");
1336 cout <<
"Base64 Encoding\n";
1337 pass = pass && !fail;
1339 fail = !TestFilter(
HexDecoder(
new Base64Decoder).Ref(), (
const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded), data, 255);
1340 cout << (fail ?
"FAILED " :
"passed ");
1341 cout <<
"Base64 Decoding\n";
1342 pass = pass && !fail;
1347 bool ValidateSHACAL2()
1349 cout <<
"\nSHACAL-2 validation suite running...\n\n";
1358 bool ValidateCamellia()
1360 cout <<
"\nCamellia validation suite running...\n\n";
1370 bool ValidateSalsa()
1372 cout <<
"\nSalsa validation suite running...\n";
1374 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/salsa.txt");
1377 bool ValidateSosemanuk()
1379 cout <<
"\nSosemanuk validation suite running...\n";
1380 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/sosemanuk.txt");
1385 cout <<
"\nVMAC validation suite running...\n";
1386 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/vmac.txt");
1391 cout <<
"\nAES/CCM validation suite running...\n";
1392 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/ccm.txt");
1397 cout <<
"\nAES/GCM validation suite running...\n";
1398 cout <<
"\n2K tables:";
1399 bool pass = RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/gcm.txt", MakeParameters(
Name::TableSize(), (
int)2048));
1400 cout <<
"\n64K tables:";
1401 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/gcm.txt", MakeParameters(
Name::TableSize(), (
int)64*1024)) && pass;
1406 cout <<
"\nCMAC validation suite running...\n";
1407 return RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/cmac.txt");