00001
00002
00003 #include "pch.h"
00004
00005 #define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
00006 #include "files.h"
00007 #include "hex.h"
00008 #include "base32.h"
00009 #include "base64.h"
00010 #include "modes.h"
00011 #include "cbcmac.h"
00012 #include "dmac.h"
00013 #include "idea.h"
00014 #include "des.h"
00015 #include "rc2.h"
00016 #include "arc4.h"
00017 #include "rc5.h"
00018 #include "blowfish.h"
00019 #include "wake.h"
00020 #include "3way.h"
00021 #include "safer.h"
00022 #include "gost.h"
00023 #include "shark.h"
00024 #include "cast.h"
00025 #include "square.h"
00026 #include "seal.h"
00027 #include "rc6.h"
00028 #include "mars.h"
00029 #include "rijndael.h"
00030 #include "twofish.h"
00031 #include "serpent.h"
00032 #include "skipjack.h"
00033 #include "shacal2.h"
00034 #include "camellia.h"
00035 #include "osrng.h"
00036 #include "zdeflate.h"
00037 #include "cpu.h"
00038
00039 #include <stdlib.h>
00040 #include <time.h>
00041 #include <memory>
00042 #include <iostream>
00043 #include <iomanip>
00044
00045 #include "validate.h"
00046
00047 USING_NAMESPACE(CryptoPP)
00048 USING_NAMESPACE(std)
00049
00050 bool ValidateAll(bool thorough)
00051 {
00052 bool pass=TestSettings();
00053 pass=TestOS_RNG() && pass;
00054
00055 pass=ValidateCRC32() && pass;
00056 pass=ValidateAdler32() && pass;
00057 pass=ValidateMD2() && pass;
00058 pass=ValidateMD5() && pass;
00059 pass=ValidateSHA() && pass;
00060 pass=ValidateSHA2() && pass;
00061 pass=ValidateTiger() && pass;
00062 pass=ValidateRIPEMD() && pass;
00063 pass=ValidatePanama() && pass;
00064 pass=ValidateWhirlpool() && pass;
00065
00066 pass=ValidateHMAC() && pass;
00067 pass=ValidateTTMAC() && pass;
00068
00069 pass=ValidatePBKDF() && pass;
00070
00071 pass=ValidateDES() && pass;
00072 pass=ValidateCipherModes() && pass;
00073 pass=ValidateIDEA() && pass;
00074 pass=ValidateSAFER() && pass;
00075 pass=ValidateRC2() && pass;
00076 pass=ValidateARC4() && pass;
00077 pass=ValidateRC5() && pass;
00078 pass=ValidateBlowfish() && pass;
00079 pass=ValidateThreeWay() && pass;
00080 pass=ValidateGOST() && pass;
00081 pass=ValidateSHARK() && pass;
00082 pass=ValidateCAST() && pass;
00083 pass=ValidateSquare() && pass;
00084 pass=ValidateSKIPJACK() && pass;
00085 pass=ValidateSEAL() && pass;
00086 pass=ValidateRC6() && pass;
00087 pass=ValidateMARS() && pass;
00088 pass=ValidateRijndael() && pass;
00089 pass=ValidateTwofish() && pass;
00090 pass=ValidateSerpent() && pass;
00091 pass=ValidateSHACAL2() && pass;
00092 pass=ValidateCamellia() && pass;
00093 pass=ValidateSalsa() && pass;
00094 pass=ValidateSosemanuk() && pass;
00095 pass=ValidateVMAC() && pass;
00096 pass=ValidateCCM() && pass;
00097 pass=ValidateGCM() && pass;
00098 pass=ValidateCMAC() && pass;
00099 pass=RunTestDataFile("TestVectors/eax.txt") && pass;
00100 pass=RunTestDataFile("TestVectors/seed.txt") && pass;
00101
00102 pass=ValidateBBS() && pass;
00103 pass=ValidateDH() && pass;
00104 pass=ValidateMQV() && pass;
00105 pass=ValidateRSA() && pass;
00106 pass=ValidateElGamal() && pass;
00107 pass=ValidateDLIES() && pass;
00108 pass=ValidateNR() && pass;
00109 pass=ValidateDSA(thorough) && pass;
00110 pass=ValidateLUC() && pass;
00111 pass=ValidateLUC_DH() && pass;
00112 pass=ValidateLUC_DL() && pass;
00113 pass=ValidateXTR_DH() && pass;
00114 pass=ValidateRabin() && pass;
00115 pass=ValidateRW() && pass;
00116
00117 pass=ValidateECP() && pass;
00118 pass=ValidateEC2N() && pass;
00119 pass=ValidateECDSA() && pass;
00120 pass=ValidateESIGN() && pass;
00121
00122 if (pass)
00123 cout << "\nAll tests passed!\n";
00124 else
00125 cout << "\nOops! Not all tests passed.\n";
00126
00127 return pass;
00128 }
00129
00130 bool TestSettings()
00131 {
00132 bool pass = true;
00133
00134 cout << "\nTesting Settings...\n\n";
00135
00136 if (*(word32 *)"\x01\x02\x03\x04" == 0x04030201L)
00137 {
00138 #ifdef IS_LITTLE_ENDIAN
00139 cout << "passed: ";
00140 #else
00141 cout << "FAILED: ";
00142 pass = false;
00143 #endif
00144 cout << "Your machine is little endian.\n";
00145 }
00146 else if (*(word32 *)"\x01\x02\x03\x04" == 0x01020304L)
00147 {
00148 #ifndef IS_LITTLE_ENDIAN
00149 cout << "passed: ";
00150 #else
00151 cout << "FAILED: ";
00152 pass = false;
00153 #endif
00154 cout << "Your machine is big endian.\n";
00155 }
00156 else
00157 {
00158 cout << "FAILED: Your machine is neither big endian nor little endian.\n";
00159 pass = false;
00160 }
00161
00162 #ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS
00163 byte testvals[10] = {1,2,2,3,3,3,3,2,2,1};
00164 if (*(word32 *)(testvals+3) == 0x03030303 && *(word64 *)(testvals+1) == W64LIT(0x0202030303030202))
00165 cout << "passed: Your machine allows unaligned data access.\n";
00166 else
00167 {
00168 cout << "FAILED: Unaligned data access gave incorrect results.\n";
00169 pass = false;
00170 }
00171 #else
00172 cout << "passed: CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS is not defined. Will restrict to aligned data access.\n";
00173 #endif
00174
00175 if (sizeof(byte) == 1)
00176 cout << "passed: ";
00177 else
00178 {
00179 cout << "FAILED: ";
00180 pass = false;
00181 }
00182 cout << "sizeof(byte) == " << sizeof(byte) << endl;
00183
00184 if (sizeof(word16) == 2)
00185 cout << "passed: ";
00186 else
00187 {
00188 cout << "FAILED: ";
00189 pass = false;
00190 }
00191 cout << "sizeof(word16) == " << sizeof(word16) << endl;
00192
00193 if (sizeof(word32) == 4)
00194 cout << "passed: ";
00195 else
00196 {
00197 cout << "FAILED: ";
00198 pass = false;
00199 }
00200 cout << "sizeof(word32) == " << sizeof(word32) << endl;
00201
00202 if (sizeof(word64) == 8)
00203 cout << "passed: ";
00204 else
00205 {
00206 cout << "FAILED: ";
00207 pass = false;
00208 }
00209 cout << "sizeof(word64) == " << sizeof(word64) << endl;
00210
00211 #ifdef CRYPTOPP_WORD128_AVAILABLE
00212 if (sizeof(word128) == 16)
00213 cout << "passed: ";
00214 else
00215 {
00216 cout << "FAILED: ";
00217 pass = false;
00218 }
00219 cout << "sizeof(word128) == " << sizeof(word128) << endl;
00220 #endif
00221
00222 if (sizeof(word) == 2*sizeof(hword)
00223 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
00224 && sizeof(dword) == 2*sizeof(word)
00225 #endif
00226 )
00227 cout << "passed: ";
00228 else
00229 {
00230 cout << "FAILED: ";
00231 pass = false;
00232 }
00233 cout << "sizeof(hword) == " << sizeof(hword) << ", sizeof(word) == " << sizeof(word);
00234 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
00235 cout << ", sizeof(dword) == " << sizeof(dword);
00236 #endif
00237 cout << endl;
00238
00239 bool hasMMX = HasMMX();
00240 bool hasISSE = HasISSE();
00241 bool hasSSE2 = HasSSE2();
00242 bool hasSSSE3 = HasSSSE3();
00243 bool isP4 = IsP4();
00244 int cacheLineSize = GetCacheLineSize();
00245
00246 if ((isP4 && (!hasMMX || !hasSSE2)) || (hasSSE2 && !hasMMX) || (cacheLineSize < 16 || cacheLineSize > 256 || !IsPowerOf2(cacheLineSize)))
00247 {
00248 cout << "FAILED: ";
00249 pass = false;
00250 }
00251 else
00252 cout << "passed: ";
00253
00254 cout << "hasMMX == " << hasMMX << ", hasISSE == " << hasISSE << ", hasSSE2 == " << hasSSE2 << ", hasSSSE3 == " << hasSSSE3 << ", isP4 == " << isP4 << ", cacheLineSize == " << cacheLineSize;
00255
00256 if (!pass)
00257 {
00258 cout << "Some critical setting in config.h is in error. Please fix it and recompile." << endl;
00259 abort();
00260 }
00261 return pass;
00262 }
00263
00264 bool TestOS_RNG()
00265 {
00266 bool pass = true;
00267
00268 member_ptr<RandomNumberGenerator> rng;
00269 #ifdef BLOCKING_RNG_AVAILABLE
00270 try {rng.reset(new BlockingRng);}
00271 catch (OS_RNG_Err &) {}
00272 #endif
00273
00274 if (rng.get())
00275 {
00276 cout << "\nTesting operating system provided blocking random number generator...\n\n";
00277
00278 ArraySink *sink;
00279 RandomNumberSource test(*rng, UINT_MAX, false, new Deflator(sink=new ArraySink(NULL,0)));
00280 unsigned long total=0, length=0;
00281 time_t t = time(NULL), t1 = 0;
00282
00283
00284 while (total < 16 && (t1 < 10 || total*8 > (unsigned long)t1))
00285 {
00286 test.Pump(1);
00287 total += 1;
00288 t1 = time(NULL) - t;
00289 }
00290
00291 if (total < 16)
00292 {
00293 cout << "FAILED:";
00294 pass = false;
00295 }
00296 else
00297 cout << "passed:";
00298 cout << " it took " << long(t1) << " seconds to generate " << total << " bytes" << endl;
00299
00300 #if 0 // disable this part. it's causing an unpredictable pause during the validation testing
00301 if (t1 < 2)
00302 {
00303
00304
00305 t = time(NULL);
00306 while (time(NULL) - t < 2)
00307 {
00308 test.Pump(1);
00309 total += 1;
00310 }
00311
00312
00313
00314 t = time(NULL);
00315 while (time(NULL) - t < 2)
00316 {
00317 test.Pump(1);
00318 total += 1;
00319 length += 1;
00320 }
00321 if (length > 1024)
00322 {
00323 cout << "FAILED:";
00324 pass = false;
00325 }
00326 else
00327 cout << "passed:";
00328 cout << " it generated " << length << " bytes in " << long(time(NULL) - t) << " seconds" << endl;
00329 }
00330 #endif
00331
00332 test.AttachedTransformation()->MessageEnd();
00333
00334 if (sink->TotalPutLength() < total)
00335 {
00336 cout << "FAILED:";
00337 pass = false;
00338 }
00339 else
00340 cout << "passed:";
00341 cout << " " << total << " generated bytes compressed to " << (size_t)sink->TotalPutLength() << " bytes by DEFLATE" << endl;
00342 }
00343 else
00344 cout << "\nNo operating system provided blocking random number generator, skipping test." << endl;
00345
00346 rng.reset(NULL);
00347 #ifdef NONBLOCKING_RNG_AVAILABLE
00348 try {rng.reset(new NonblockingRng);}
00349 catch (OS_RNG_Err &) {}
00350 #endif
00351
00352 if (rng.get())
00353 {
00354 cout << "\nTesting operating system provided nonblocking random number generator...\n\n";
00355
00356 ArraySink *sink;
00357 RandomNumberSource test(*rng, 100000, true, new Deflator(sink=new ArraySink(NULL, 0)));
00358
00359 if (sink->TotalPutLength() < 100000)
00360 {
00361 cout << "FAILED:";
00362 pass = false;
00363 }
00364 else
00365 cout << "passed:";
00366 cout << " 100000 generated bytes compressed to " << (size_t)sink->TotalPutLength() << " bytes by DEFLATE" << endl;
00367 }
00368 else
00369 cout << "\nNo operating system provided nonblocking random number generator, skipping test." << endl;
00370
00371 return pass;
00372 }
00373
00374
00375 typedef auto_ptr<BlockTransformation> apbt;
00376
00377 class CipherFactory
00378 {
00379 public:
00380 virtual unsigned int BlockSize() const =0;
00381 virtual unsigned int KeyLength() const =0;
00382
00383 virtual apbt NewEncryption(const byte *key) const =0;
00384 virtual apbt NewDecryption(const byte *key) const =0;
00385 };
00386
00387 template <class E, class D> class FixedRoundsCipherFactory : public CipherFactory
00388 {
00389 public:
00390 FixedRoundsCipherFactory(unsigned int keylen=0) : m_keylen(keylen?keylen:E::DEFAULT_KEYLENGTH) {}
00391 unsigned int BlockSize() const {return E::BLOCKSIZE;}
00392 unsigned int KeyLength() const {return m_keylen;}
00393
00394 apbt NewEncryption(const byte *key) const
00395 {return apbt(new E(key, m_keylen));}
00396 apbt NewDecryption(const byte *key) const
00397 {return apbt(new D(key, m_keylen));}
00398
00399 unsigned int m_keylen;
00400 };
00401
00402 template <class E, class D> class VariableRoundsCipherFactory : public CipherFactory
00403 {
00404 public:
00405 VariableRoundsCipherFactory(unsigned int keylen=0, unsigned int rounds=0)
00406 : m_keylen(keylen ? keylen : E::DEFAULT_KEYLENGTH), m_rounds(rounds ? rounds : E::DEFAULT_ROUNDS) {}
00407 unsigned int BlockSize() const {return E::BLOCKSIZE;}
00408 unsigned int KeyLength() const {return m_keylen;}
00409
00410 apbt NewEncryption(const byte *key) const
00411 {return apbt(new E(key, m_keylen, m_rounds));}
00412 apbt NewDecryption(const byte *key) const
00413 {return apbt(new D(key, m_keylen, m_rounds));}
00414
00415 unsigned int m_keylen, m_rounds;
00416 };
00417
00418 bool BlockTransformationTest(const CipherFactory &cg, BufferedTransformation &valdata, unsigned int tuples = 0xffff)
00419 {
00420 HexEncoder output(new FileSink(cout));
00421 SecByteBlock plain(cg.BlockSize()), cipher(cg.BlockSize()), out(cg.BlockSize()), outplain(cg.BlockSize());
00422 SecByteBlock key(cg.KeyLength());
00423 bool pass=true, fail;
00424
00425 while (valdata.MaxRetrievable() && tuples--)
00426 {
00427 valdata.Get(key, cg.KeyLength());
00428 valdata.Get(plain, cg.BlockSize());
00429 valdata.Get(cipher, cg.BlockSize());
00430
00431 apbt transE = cg.NewEncryption(key);
00432 transE->ProcessBlock(plain, out);
00433 fail = memcmp(out, cipher, cg.BlockSize()) != 0;
00434
00435 apbt transD = cg.NewDecryption(key);
00436 transD->ProcessBlock(out, outplain);
00437 fail=fail || memcmp(outplain, plain, cg.BlockSize());
00438
00439 pass = pass && !fail;
00440
00441 cout << (fail ? "FAILED " : "passed ");
00442 output.Put(key, cg.KeyLength());
00443 cout << " ";
00444 output.Put(outplain, cg.BlockSize());
00445 cout << " ";
00446 output.Put(out, cg.BlockSize());
00447 cout << endl;
00448 }
00449 return pass;
00450 }
00451
00452 class FilterTester : public Unflushable<Sink>
00453 {
00454 public:
00455 FilterTester(const byte *validOutput, size_t outputLen)
00456 : validOutput(validOutput), outputLen(outputLen), counter(0), fail(false) {}
00457 void PutByte(byte inByte)
00458 {
00459 if (counter >= outputLen || validOutput[counter] != inByte)
00460 {
00461 std::cerr << "incorrect output " << counter << ", " << (word16)validOutput[counter] << ", " << (word16)inByte << "\n";
00462 fail = true;
00463 assert(false);
00464 }
00465 counter++;
00466 }
00467 size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
00468 {
00469 while (length--)
00470 FilterTester::PutByte(*inString++);
00471
00472 if (messageEnd)
00473 if (counter != outputLen)
00474 {
00475 fail = true;
00476 assert(false);
00477 }
00478
00479 return 0;
00480 }
00481 bool GetResult()
00482 {
00483 return !fail;
00484 }
00485
00486 const byte *validOutput;
00487 size_t outputLen, counter;
00488 bool fail;
00489 };
00490
00491 bool TestFilter(BufferedTransformation &bt, const byte *in, size_t inLen, const byte *out, size_t outLen)
00492 {
00493 FilterTester *ft;
00494 bt.Attach(ft = new FilterTester(out, outLen));
00495
00496 while (inLen)
00497 {
00498 size_t randomLen = GlobalRNG().GenerateWord32(0, (word32)inLen);
00499 bt.Put(in, randomLen);
00500 in += randomLen;
00501 inLen -= randomLen;
00502 }
00503 bt.MessageEnd();
00504 return ft->GetResult();
00505 }
00506
00507 bool ValidateDES()
00508 {
00509 cout << "\nDES validation suite running...\n\n";
00510
00511 FileSource valdata("TestData/descert.dat", true, new HexDecoder);
00512 bool pass = BlockTransformationTest(FixedRoundsCipherFactory<DESEncryption, DESDecryption>(), valdata);
00513
00514 cout << "\nTesting EDE2, EDE3, and XEX3 variants...\n\n";
00515
00516 FileSource valdata1("TestData/3desval.dat", true, new HexDecoder);
00517 pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_EDE2_Encryption, DES_EDE2_Decryption>(), valdata1, 1) && pass;
00518 pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_EDE3_Encryption, DES_EDE3_Decryption>(), valdata1, 1) && pass;
00519 pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_XEX3_Encryption, DES_XEX3_Decryption>(), valdata1, 1) && pass;
00520
00521 return pass;
00522 }
00523
00524 bool TestModeIV(SymmetricCipher &e, SymmetricCipher &d)
00525 {
00526 SecByteBlock lastIV, iv(e.IVSize());
00527 StreamTransformationFilter filter(e, new StreamTransformationFilter(d));
00528 byte plaintext[20480];
00529
00530 for (unsigned int i=1; i<sizeof(plaintext); i*=2)
00531 {
00532 e.GetNextIV(GlobalRNG(), iv);
00533 if (iv == lastIV)
00534 return false;
00535 else
00536 lastIV = iv;
00537
00538 e.Resynchronize(iv);
00539 d.Resynchronize(iv);
00540
00541 unsigned int length = STDMAX(GlobalRNG().GenerateWord32(0, i), (word32)e.MinLastBlockSize());
00542 GlobalRNG().GenerateBlock(plaintext, length);
00543
00544 if (!TestFilter(filter, plaintext, length, plaintext, length))
00545 return false;
00546 }
00547
00548 return true;
00549 }
00550
00551 bool ValidateCipherModes()
00552 {
00553 cout << "\nTesting DES modes...\n\n";
00554 const byte key[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
00555 const byte iv[] = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
00556 const byte plain[] = {
00557 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
00558 0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
00559 0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20};
00560 DESEncryption desE(key);
00561 DESDecryption desD(key);
00562 bool pass=true, fail;
00563
00564 {
00565
00566 const byte encrypted[] = {
00567 0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15,
00568 0x6a, 0x27, 0x17, 0x87, 0xab, 0x88, 0x83, 0xf9,
00569 0x89, 0x3d, 0x51, 0xec, 0x4b, 0x56, 0x3b, 0x53};
00570
00571 ECB_Mode_ExternalCipher::Encryption modeE(desE);
00572 fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
00573 plain, sizeof(plain), encrypted, sizeof(encrypted));
00574 pass = pass && !fail;
00575 cout << (fail ? "FAILED " : "passed ") << "ECB encryption" << endl;
00576
00577 ECB_Mode_ExternalCipher::Decryption modeD(desD);
00578 fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
00579 encrypted, sizeof(encrypted), plain, sizeof(plain));
00580 pass = pass && !fail;
00581 cout << (fail ? "FAILED " : "passed ") << "ECB decryption" << endl;
00582 }
00583 {
00584
00585 const byte encrypted[] = {
00586 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
00587 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
00588 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6};
00589
00590 CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
00591 fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
00592 plain, sizeof(plain), encrypted, sizeof(encrypted));
00593 pass = pass && !fail;
00594 cout << (fail ? "FAILED " : "passed ") << "CBC encryption with no padding" << endl;
00595
00596 CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
00597 fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
00598 encrypted, sizeof(encrypted), plain, sizeof(plain));
00599 pass = pass && !fail;
00600 cout << (fail ? "FAILED " : "passed ") << "CBC decryption with no padding" << endl;
00601
00602 fail = !TestModeIV(modeE, modeD);
00603 pass = pass && !fail;
00604 cout << (fail ? "FAILED " : "passed ") << "CBC mode IV generation" << endl;
00605 }
00606 {
00607
00608
00609 const byte encrypted[] = {
00610 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
00611 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
00612 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
00613 0x62, 0xC1, 0x6A, 0x27, 0xE4, 0xFC, 0xF2, 0x77};
00614
00615 CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
00616 fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
00617 plain, sizeof(plain), encrypted, sizeof(encrypted));
00618 pass = pass && !fail;
00619 cout << (fail ? "FAILED " : "passed ") << "CBC encryption with PKCS #7 padding" << endl;
00620
00621 CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
00622 fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
00623 encrypted, sizeof(encrypted), plain, sizeof(plain));
00624 pass = pass && !fail;
00625 cout << (fail ? "FAILED " : "passed ") << "CBC decryption with PKCS #7 padding" << endl;
00626 }
00627 {
00628
00629
00630 const byte encrypted[] = {
00631 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
00632 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
00633 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
00634 0xcf, 0xb7, 0xc7, 0x64, 0x0e, 0x7c, 0xd9, 0xa7};
00635
00636 CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
00637 fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::ONE_AND_ZEROS_PADDING).Ref(),
00638 plain, sizeof(plain), encrypted, sizeof(encrypted));
00639 pass = pass && !fail;
00640 cout << (fail ? "FAILED " : "passed ") << "CBC encryption with one-and-zeros padding" << endl;
00641
00642 CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
00643 fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::ONE_AND_ZEROS_PADDING).Ref(),
00644 encrypted, sizeof(encrypted), plain, sizeof(plain));
00645 pass = pass && !fail;
00646 cout << (fail ? "FAILED " : "passed ") << "CBC decryption with one-and-zeros padding" << endl;
00647 }
00648 {
00649 const byte plain[] = {'a', 0, 0, 0, 0, 0, 0, 0};
00650
00651 const byte encrypted[] = {
00652 0x9B, 0x47, 0x57, 0x59, 0xD6, 0x9C, 0xF6, 0xD0};
00653
00654 CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
00655 fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::ZEROS_PADDING).Ref(),
00656 plain, 1, encrypted, sizeof(encrypted));
00657 pass = pass && !fail;
00658 cout << (fail ? "FAILED " : "passed ") << "CBC encryption with zeros padding" << endl;
00659
00660 CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
00661 fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::ZEROS_PADDING).Ref(),
00662 encrypted, sizeof(encrypted), plain, sizeof(plain));
00663 pass = pass && !fail;
00664 cout << (fail ? "FAILED " : "passed ") << "CBC decryption with zeros padding" << endl;
00665 }
00666 {
00667
00668
00669 const byte encrypted[] = {
00670 0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
00671 0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
00672 0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F};
00673
00674 CBC_CTS_Mode_ExternalCipher::Encryption modeE(desE, iv);
00675 fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
00676 plain, sizeof(plain), encrypted, sizeof(encrypted));
00677 pass = pass && !fail;
00678 cout << (fail ? "FAILED " : "passed ") << "CBC encryption with ciphertext stealing (CTS)" << endl;
00679
00680 CBC_CTS_Mode_ExternalCipher::Decryption modeD(desD, iv);
00681 fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
00682 encrypted, sizeof(encrypted), plain, sizeof(plain));
00683 pass = pass && !fail;
00684 cout << (fail ? "FAILED " : "passed ") << "CBC decryption with ciphertext stealing (CTS)" << endl;
00685
00686 fail = !TestModeIV(modeE, modeD);
00687 pass = pass && !fail;
00688 cout << (fail ? "FAILED " : "passed ") << "CBC CTS IV generation" << endl;
00689 }
00690 {
00691
00692 const byte decryptionIV[] = {0x4D, 0xD0, 0xAC, 0x8F, 0x47, 0xCF, 0x79, 0xCE};
00693 const byte encrypted[] = {0x12, 0x34, 0x56};
00694
00695 byte stolenIV[8];
00696
00697 CBC_CTS_Mode_ExternalCipher::Encryption modeE(desE, iv);
00698 modeE.SetStolenIV(stolenIV);
00699 fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
00700 plain, 3, encrypted, sizeof(encrypted));
00701 fail = memcmp(stolenIV, decryptionIV, 8) != 0 || fail;
00702 pass = pass && !fail;
00703 cout << (fail ? "FAILED " : "passed ") << "CBC encryption with ciphertext and IV stealing" << endl;
00704
00705 CBC_CTS_Mode_ExternalCipher::Decryption modeD(desD, stolenIV);
00706 fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
00707 encrypted, sizeof(encrypted), plain, 3);
00708 pass = pass && !fail;
00709 cout << (fail ? "FAILED " : "passed ") << "CBC decryption with ciphertext and IV stealing" << endl;
00710 }
00711 {
00712 const byte encrypted[] = {
00713 0xF3,0x09,0x62,0x49,0xC7,0xF4,0x6E,0x51,
00714 0xA6,0x9E,0x83,0x9B,0x1A,0x92,0xF7,0x84,
00715 0x03,0x46,0x71,0x33,0x89,0x8E,0xA6,0x22};
00716
00717 CFB_Mode_ExternalCipher::Encryption modeE(desE, iv);
00718 fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
00719 plain, sizeof(plain), encrypted, sizeof(encrypted));
00720 pass = pass && !fail;
00721 cout << (fail ? "FAILED " : "passed ") << "CFB encryption" << endl;
00722
00723 CFB_Mode_ExternalCipher::Decryption modeD(desE, iv);
00724 fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
00725 encrypted, sizeof(encrypted), plain, sizeof(plain));
00726 pass = pass && !fail;
00727 cout << (fail ? "FAILED " : "passed ") << "CFB decryption" << endl;
00728
00729 fail = !TestModeIV(modeE, modeD);
00730 pass = pass && !fail;
00731 cout << (fail ? "FAILED " : "passed ") << "CFB mode IV generation" << endl;
00732 }
00733 {
00734 const byte plain[] = {
00735 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
00736 const byte encrypted[] = {
00737 0xf3,0x1f,0xda,0x07,0x01,0x14,0x62,0xee,0x18,0x7f};
00738
00739 CFB_Mode_ExternalCipher::Encryption modeE(desE, iv, 1);
00740 fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
00741 plain, sizeof(plain), encrypted, sizeof(encrypted));
00742 pass = pass && !fail;
00743 cout << (fail ? "FAILED " : "passed ") << "CFB (8-bit feedback) encryption" << endl;
00744
00745 CFB_Mode_ExternalCipher::Decryption modeD(desE, iv, 1);
00746 fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
00747 encrypted, sizeof(encrypted), plain, sizeof(plain));
00748 pass = pass && !fail;
00749 cout << (fail ? "FAILED " : "passed ") << "CFB (8-bit feedback) decryption" << endl;
00750
00751 fail = !TestModeIV(modeE, modeD);
00752 pass = pass && !fail;
00753 cout << (fail ? "FAILED " : "passed ") << "CFB (8-bit feedback) IV generation" << endl;
00754 }
00755 {
00756 const byte encrypted[] = {
00757 0xf3,0x09,0x62,0x49,0xc7,0xf4,0x6e,0x51,
00758 0x35,0xf2,0x4a,0x24,0x2e,0xeb,0x3d,0x3f,
00759 0x3d,0x6d,0x5b,0xe3,0x25,0x5a,0xf8,0xc3};
00760
00761 OFB_Mode_ExternalCipher::Encryption modeE(desE, iv);
00762 fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
00763 plain, sizeof(plain), encrypted, sizeof(encrypted));
00764 pass = pass && !fail;
00765 cout << (fail ? "FAILED " : "passed ") << "OFB encryption" << endl;
00766
00767 OFB_Mode_ExternalCipher::Decryption modeD(desE, iv);
00768 fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
00769 encrypted, sizeof(encrypted), plain, sizeof(plain));
00770 pass = pass && !fail;
00771 cout << (fail ? "FAILED " : "passed ") << "OFB decryption" << endl;
00772
00773 fail = !TestModeIV(modeE, modeD);
00774 pass = pass && !fail;
00775 cout << (fail ? "FAILED " : "passed ") << "OFB IV generation" << endl;
00776 }
00777 {
00778 const byte encrypted[] = {
00779 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51,
00780 0x16, 0x3A, 0x8C, 0xA0, 0xFF, 0xC9, 0x4C, 0x27,
00781 0xFA, 0x2F, 0x80, 0xF4, 0x80, 0xB8, 0x6F, 0x75};
00782
00783 CTR_Mode_ExternalCipher::Encryption modeE(desE, iv);
00784 fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
00785 plain, sizeof(plain), encrypted, sizeof(encrypted));
00786 pass = pass && !fail;
00787 cout << (fail ? "FAILED " : "passed ") << "Counter Mode encryption" << endl;
00788
00789 CTR_Mode_ExternalCipher::Decryption modeD(desE, iv);
00790 fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
00791 encrypted, sizeof(encrypted), plain, sizeof(plain));
00792 pass = pass && !fail;
00793 cout << (fail ? "FAILED " : "passed ") << "Counter Mode decryption" << endl;
00794
00795 fail = !TestModeIV(modeE, modeD);
00796 pass = pass && !fail;
00797 cout << (fail ? "FAILED " : "passed ") << "Counter Mode IV generation" << endl;
00798 }
00799 {
00800 const byte plain[] = {
00801 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
00802 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
00803 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
00804 0x66, 0x6f, 0x72, 0x20};
00805 const byte mac1[] = {
00806 0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
00807 const byte mac2[] = {
00808 0x35, 0x80, 0xC5, 0xC4, 0x6B, 0x81, 0x24, 0xE2};
00809
00810 CBC_MAC<DES> cbcmac(key);
00811 HashFilter cbcmacFilter(cbcmac);
00812 fail = !TestFilter(cbcmacFilter, plain, sizeof(plain), mac1, sizeof(mac1));
00813 pass = pass && !fail;
00814 cout << (fail ? "FAILED " : "passed ") << "CBC MAC" << endl;
00815
00816 DMAC<DES> dmac(key);
00817 HashFilter dmacFilter(dmac);
00818 fail = !TestFilter(dmacFilter, plain, sizeof(plain), mac2, sizeof(mac2));
00819 pass = pass && !fail;
00820 cout << (fail ? "FAILED " : "passed ") << "DMAC" << endl;
00821 }
00822 {
00823 CTR_Mode<AES>::Encryption modeE(plain, 16, plain);
00824 CTR_Mode<AES>::Decryption modeD(plain, 16, plain);
00825 fail = !TestModeIV(modeE, modeD);
00826 pass = pass && !fail;
00827 cout << (fail ? "FAILED " : "passed ") << "AES CTR Mode" << endl;
00828 }
00829 {
00830 OFB_Mode<AES>::Encryption modeE(plain, 16, plain);
00831 OFB_Mode<AES>::Decryption modeD(plain, 16, plain);
00832 fail = !TestModeIV(modeE, modeD);
00833 pass = pass && !fail;
00834 cout << (fail ? "FAILED " : "passed ") << "AES OFB Mode" << endl;
00835 }
00836 {
00837 CFB_Mode<AES>::Encryption modeE(plain, 16, plain);
00838 CFB_Mode<AES>::Decryption modeD(plain, 16, plain);
00839 fail = !TestModeIV(modeE, modeD);
00840 pass = pass && !fail;
00841 cout << (fail ? "FAILED " : "passed ") << "AES CFB Mode" << endl;
00842 }
00843 {
00844 CBC_Mode<AES>::Encryption modeE(plain, 16, plain);
00845 CBC_Mode<AES>::Decryption modeD(plain, 16, plain);
00846 fail = !TestModeIV(modeE, modeD);
00847 pass = pass && !fail;
00848 cout << (fail ? "FAILED " : "passed ") << "AES CBC Mode" << endl;
00849 }
00850
00851 return pass;
00852 }
00853
00854 bool ValidateIDEA()
00855 {
00856 cout << "\nIDEA validation suite running...\n\n";
00857
00858 FileSource valdata("TestData/ideaval.dat", true, new HexDecoder);
00859 return BlockTransformationTest(FixedRoundsCipherFactory<IDEAEncryption, IDEADecryption>(), valdata);
00860 }
00861
00862 bool ValidateSAFER()
00863 {
00864 cout << "\nSAFER validation suite running...\n\n";
00865
00866 FileSource valdata("TestData/saferval.dat", true, new HexDecoder);
00867 bool pass = true;
00868 pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_K_Encryption, SAFER_K_Decryption>(8,6), valdata, 4) && pass;
00869 pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_K_Encryption, SAFER_K_Decryption>(16,12), valdata, 4) && pass;
00870 pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_SK_Encryption, SAFER_SK_Decryption>(8,6), valdata, 4) && pass;
00871 pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_SK_Encryption, SAFER_SK_Decryption>(16,10), valdata, 4) && pass;
00872 return pass;
00873 }
00874
00875 bool ValidateRC2()
00876 {
00877 cout << "\nRC2 validation suite running...\n\n";
00878
00879 FileSource valdata("TestData/rc2val.dat", true, new HexDecoder);
00880 HexEncoder output(new FileSink(cout));
00881 SecByteBlock plain(RC2Encryption::BLOCKSIZE), cipher(RC2Encryption::BLOCKSIZE), out(RC2Encryption::BLOCKSIZE), outplain(RC2Encryption::BLOCKSIZE);
00882 SecByteBlock key(128);
00883 bool pass=true, fail;
00884
00885 while (valdata.MaxRetrievable())
00886 {
00887 byte keyLen, effectiveLen;
00888
00889 valdata.Get(keyLen);
00890 valdata.Get(effectiveLen);
00891 valdata.Get(key, keyLen);
00892 valdata.Get(plain, RC2Encryption::BLOCKSIZE);
00893 valdata.Get(cipher, RC2Encryption::BLOCKSIZE);
00894
00895 apbt transE(new RC2Encryption(key, keyLen, effectiveLen));
00896 transE->ProcessBlock(plain, out);
00897 fail = memcmp(out, cipher, RC2Encryption::BLOCKSIZE) != 0;
00898
00899 apbt transD(new RC2Decryption(key, keyLen, effectiveLen));
00900 transD->ProcessBlock(out, outplain);
00901 fail=fail || memcmp(outplain, plain, RC2Encryption::BLOCKSIZE);
00902
00903 pass = pass && !fail;
00904
00905 cout << (fail ? "FAILED " : "passed ");
00906 output.Put(key, keyLen);
00907 cout << " ";
00908 output.Put(outplain, RC2Encryption::BLOCKSIZE);
00909 cout << " ";
00910 output.Put(out, RC2Encryption::BLOCKSIZE);
00911 cout << endl;
00912 }
00913 return pass;
00914 }
00915
00916 bool ValidateARC4()
00917 {
00918 unsigned char Key0[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
00919 unsigned char Input0[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
00920 unsigned char Output0[] = {0x75,0xb7,0x87,0x80,0x99,0xe0,0xc5,0x96};
00921
00922 unsigned char Key1[]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
00923 unsigned char Input1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
00924 unsigned char Output1[]={0x74,0x94,0xc2,0xe7,0x10,0x4b,0x08,0x79};
00925
00926 unsigned char Key2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
00927 unsigned char Input2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
00928 unsigned char Output2[]={0xde,0x18,0x89,0x41,0xa3,0x37,0x5d,0x3a};
00929
00930 unsigned char Key3[]={0xef,0x01,0x23,0x45};
00931 unsigned char Input3[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
00932 unsigned char Output3[]={0xd6,0xa1,0x41,0xa7,0xec,0x3c,0x38,0xdf,0xbd,0x61};
00933
00934 unsigned char Key4[]={ 0x01,0x23,0x45,0x67,0x89,0xab, 0xcd,0xef };
00935 unsigned char Input4[] =
00936 {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00937 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00938 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00939 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00940 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00941 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00942 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00943 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00944 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00945 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00946 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00947 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00948 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00949 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00950 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00951 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00952 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00953 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00954 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00955 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00956 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00957 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00958 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00959 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00960 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00961 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00962 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00963 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00964 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00965 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00966 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00967 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00968 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00969 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00970 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00971 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00972 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00973 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00974 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00975 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00976 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00977 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00978 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00979 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00980 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00981 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00982 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00983 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00984 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00985 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00986 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
00987 0x01};
00988 unsigned char Output4[]= {
00989 0x75,0x95,0xc3,0xe6,0x11,0x4a,0x09,0x78,0x0c,0x4a,0xd4,
00990 0x52,0x33,0x8e,0x1f,0xfd,0x9a,0x1b,0xe9,0x49,0x8f,
00991 0x81,0x3d,0x76,0x53,0x34,0x49,0xb6,0x77,0x8d,0xca,
00992 0xd8,0xc7,0x8a,0x8d,0x2b,0xa9,0xac,0x66,0x08,0x5d,
00993 0x0e,0x53,0xd5,0x9c,0x26,0xc2,0xd1,0xc4,0x90,0xc1,
00994 0xeb,0xbe,0x0c,0xe6,0x6d,0x1b,0x6b,0x1b,0x13,0xb6,
00995 0xb9,0x19,0xb8,0x47,0xc2,0x5a,0x91,0x44,0x7a,0x95,
00996 0xe7,0x5e,0x4e,0xf1,0x67,0x79,0xcd,0xe8,0xbf,0x0a,
00997 0x95,0x85,0x0e,0x32,0xaf,0x96,0x89,0x44,0x4f,0xd3,
00998 0x77,0x10,0x8f,0x98,0xfd,0xcb,0xd4,0xe7,0x26,0x56,
00999 0x75,0x00,0x99,0x0b,0xcc,0x7e,0x0c,0xa3,0xc4,0xaa,
01000 0xa3,0x04,0xa3,0x87,0xd2,0x0f,0x3b,0x8f,0xbb,0xcd,
01001 0x42,0xa1,0xbd,0x31,0x1d,0x7a,0x43,0x03,0xdd,0xa5,
01002 0xab,0x07,0x88,0x96,0xae,0x80,0xc1,0x8b,0x0a,0xf6,
01003 0x6d,0xff,0x31,0x96,0x16,0xeb,0x78,0x4e,0x49,0x5a,
01004 0xd2,0xce,0x90,0xd7,0xf7,0x72,0xa8,0x17,0x47,0xb6,
01005 0x5f,0x62,0x09,0x3b,0x1e,0x0d,0xb9,0xe5,0xba,0x53,
01006 0x2f,0xaf,0xec,0x47,0x50,0x83,0x23,0xe6,0x71,0x32,
01007 0x7d,0xf9,0x44,0x44,0x32,0xcb,0x73,0x67,0xce,0xc8,
01008 0x2f,0x5d,0x44,0xc0,0xd0,0x0b,0x67,0xd6,0x50,0xa0,
01009 0x75,0xcd,0x4b,0x70,0xde,0xdd,0x77,0xeb,0x9b,0x10,
01010 0x23,0x1b,0x6b,0x5b,0x74,0x13,0x47,0x39,0x6d,0x62,
01011 0x89,0x74,0x21,0xd4,0x3d,0xf9,0xb4,0x2e,0x44,0x6e,
01012 0x35,0x8e,0x9c,0x11,0xa9,0xb2,0x18,0x4e,0xcb,0xef,
01013 0x0c,0xd8,0xe7,0xa8,0x77,0xef,0x96,0x8f,0x13,0x90,
01014 0xec,0x9b,0x3d,0x35,0xa5,0x58,0x5c,0xb0,0x09,0x29,
01015 0x0e,0x2f,0xcd,0xe7,0xb5,0xec,0x66,0xd9,0x08,0x4b,
01016 0xe4,0x40,0x55,0xa6,0x19,0xd9,0xdd,0x7f,0xc3,0x16,
01017 0x6f,0x94,0x87,0xf7,0xcb,0x27,0x29,0x12,0x42,0x64,
01018 0x45,0x99,0x85,0x14,0xc1,0x5d,0x53,0xa1,0x8c,0x86,
01019 0x4c,0xe3,0xa2,0xb7,0x55,0x57,0x93,0x98,0x81,0x26,
01020 0x52,0x0e,0xac,0xf2,0xe3,0x06,0x6e,0x23,0x0c,0x91,
01021 0xbe,0xe4,0xdd,0x53,0x04,0xf5,0xfd,0x04,0x05,0xb3,
01022 0x5b,0xd9,0x9c,0x73,0x13,0x5d,0x3d,0x9b,0xc3,0x35,
01023 0xee,0x04,0x9e,0xf6,0x9b,0x38,0x67,0xbf,0x2d,0x7b,
01024 0xd1,0xea,0xa5,0x95,0xd8,0xbf,0xc0,0x06,0x6f,0xf8,
01025 0xd3,0x15,0x09,0xeb,0x0c,0x6c,0xaa,0x00,0x6c,0x80,
01026 0x7a,0x62,0x3e,0xf8,0x4c,0x3d,0x33,0xc1,0x95,0xd2,
01027 0x3e,0xe3,0x20,0xc4,0x0d,0xe0,0x55,0x81,0x57,0xc8,
01028 0x22,0xd4,0xb8,0xc5,0x69,0xd8,0x49,0xae,0xd5,0x9d,
01029 0x4e,0x0f,0xd7,0xf3,0x79,0x58,0x6b,0x4b,0x7f,0xf6,
01030 0x84,0xed,0x6a,0x18,0x9f,0x74,0x86,0xd4,0x9b,0x9c,
01031 0x4b,0xad,0x9b,0xa2,0x4b,0x96,0xab,0xf9,0x24,0x37,
01032 0x2c,0x8a,0x8f,0xff,0xb1,0x0d,0x55,0x35,0x49,0x00,
01033 0xa7,0x7a,0x3d,0xb5,0xf2,0x05,0xe1,0xb9,0x9f,0xcd,
01034 0x86,0x60,0x86,0x3a,0x15,0x9a,0xd4,0xab,0xe4,0x0f,
01035 0xa4,0x89,0x34,0x16,0x3d,0xdd,0xe5,0x42,0xa6,0x58,
01036 0x55,0x40,0xfd,0x68,0x3c,0xbf,0xd8,0xc0,0x0f,0x12,
01037 0x12,0x9a,0x28,0x4d,0xea,0xcc,0x4c,0xde,0xfe,0x58,
01038 0xbe,0x71,0x37,0x54,0x1c,0x04,0x71,0x26,0xc8,0xd4,
01039 0x9e,0x27,0x55,0xab,0x18,0x1a,0xb7,0xe9,0x40,0xb0,
01040 0xc0};
01041
01042
01043 member_ptr<Weak::ARC4> arc4;
01044 bool pass=true, fail;
01045 int i;
01046
01047 cout << "\nARC4 validation suite running...\n\n";
01048
01049 arc4.reset(new Weak::ARC4(Key0, sizeof(Key0)));
01050 arc4->ProcessString(Input0, sizeof(Input0));
01051 fail = memcmp(Input0, Output0, sizeof(Input0)) != 0;
01052 cout << (fail ? "FAILED" : "passed") << " Test 0" << endl;
01053 pass = pass && !fail;
01054
01055 arc4.reset(new Weak::ARC4(Key1, sizeof(Key1)));
01056 arc4->ProcessString(Key1, Input1, sizeof(Key1));
01057 fail = memcmp(Output1, Key1, sizeof(Key1)) != 0;
01058 cout << (fail ? "FAILED" : "passed") << " Test 1" << endl;
01059 pass = pass && !fail;
01060
01061 arc4.reset(new Weak::ARC4(Key2, sizeof(Key2)));
01062 for (i=0, fail=false; i<sizeof(Input2); i++)
01063 if (arc4->ProcessByte(Input2[i]) != Output2[i])
01064 fail = true;
01065 cout << (fail ? "FAILED" : "passed") << " Test 2" << endl;
01066 pass = pass && !fail;
01067
01068 arc4.reset(new Weak::ARC4(Key3, sizeof(Key3)));
01069 for (i=0, fail=false; i<sizeof(Input3); i++)
01070 if (arc4->ProcessByte(Input3[i]) != Output3[i])
01071 fail = true;
01072 cout << (fail ? "FAILED" : "passed") << " Test 3" << endl;
01073 pass = pass && !fail;
01074
01075 arc4.reset(new Weak::ARC4(Key4, sizeof(Key4)));
01076 for (i=0, fail=false; i<sizeof(Input4); i++)
01077 if (arc4->ProcessByte(Input4[i]) != Output4[i])
01078 fail = true;
01079 cout << (fail ? "FAILED" : "passed") << " Test 4" << endl;
01080 pass = pass && !fail;
01081
01082 return pass;
01083 }
01084
01085 bool ValidateRC5()
01086 {
01087 cout << "\nRC5 validation suite running...\n\n";
01088
01089 FileSource valdata("TestData/rc5val.dat", true, new HexDecoder);
01090 return BlockTransformationTest(VariableRoundsCipherFactory<RC5Encryption, RC5Decryption>(16, 12), valdata);
01091 }
01092
01093 bool ValidateRC6()
01094 {
01095 cout << "\nRC6 validation suite running...\n\n";
01096
01097 FileSource valdata("TestData/rc6val.dat", true, new HexDecoder);
01098 bool pass = true;
01099 pass = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(16), valdata, 2) && pass;
01100 pass = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(24), valdata, 2) && pass;
01101 pass = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(32), valdata, 2) && pass;
01102 return pass;
01103 }
01104
01105 bool ValidateMARS()
01106 {
01107 cout << "\nMARS validation suite running...\n\n";
01108
01109 FileSource valdata("TestData/marsval.dat", true, new HexDecoder);
01110 bool pass = true;
01111 pass = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(16), valdata, 4) && pass;
01112 pass = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(24), valdata, 3) && pass;
01113 pass = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(32), valdata, 2) && pass;
01114 return pass;
01115 }
01116
01117 bool ValidateRijndael()
01118 {
01119 cout << "\nRijndael (AES) validation suite running...\n\n";
01120
01121 FileSource valdata("TestData/rijndael.dat", true, new HexDecoder);
01122 bool pass = true;
01123 pass = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(16), valdata, 4) && pass;
01124 pass = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(24), valdata, 3) && pass;
01125 pass = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(32), valdata, 2) && pass;
01126 pass = RunTestDataFile("TestVectors/aes.txt") && pass;
01127 return pass;
01128 }
01129
01130 bool ValidateTwofish()
01131 {
01132 cout << "\nTwofish validation suite running...\n\n";
01133
01134 FileSource valdata("TestData/twofishv.dat", true, new HexDecoder);
01135 bool pass = true;
01136 pass = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(16), valdata, 4) && pass;
01137 pass = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(24), valdata, 3) && pass;
01138 pass = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(32), valdata, 2) && pass;
01139 return pass;
01140 }
01141
01142 bool ValidateSerpent()
01143 {
01144 cout << "\nSerpent validation suite running...\n\n";
01145
01146 FileSource valdata("TestData/serpentv.dat", true, new HexDecoder);
01147 bool pass = true;
01148 pass = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(16), valdata, 4) && pass;
01149 pass = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(24), valdata, 3) && pass;
01150 pass = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(32), valdata, 2) && pass;
01151 return pass;
01152 }
01153
01154 bool ValidateBlowfish()
01155 {
01156 cout << "\nBlowfish validation suite running...\n\n";
01157
01158 HexEncoder output(new FileSink(cout));
01159 const char *key[]={"abcdefghijklmnopqrstuvwxyz", "Who is John Galt?"};
01160 byte *plain[]={(byte *)"BLOWFISH", (byte *)"\xfe\xdc\xba\x98\x76\x54\x32\x10"};
01161 byte *cipher[]={(byte *)"\x32\x4e\xd0\xfe\xf4\x13\xa2\x03", (byte *)"\xcc\x91\x73\x2b\x80\x22\xf6\x84"};
01162 byte out[8], outplain[8];
01163 bool pass=true, fail;
01164
01165 for (int i=0; i<2; i++)
01166 {
01167 ECB_Mode<Blowfish>::Encryption enc((byte *)key[i], strlen(key[i]));
01168 enc.ProcessData(out, plain[i], 8);
01169 fail = memcmp(out, cipher[i], 8) != 0;
01170
01171 ECB_Mode<Blowfish>::Decryption dec((byte *)key[i], strlen(key[i]));
01172 dec.ProcessData(outplain, cipher[i], 8);
01173 fail = fail || memcmp(outplain, plain[i], 8);
01174 pass = pass && !fail;
01175
01176 cout << (fail ? "FAILED " : "passed ");
01177 cout << '\"' << key[i] << '\"';
01178 for (int j=0; j<(signed int)(30-strlen(key[i])); j++)
01179 cout << ' ';
01180 output.Put(outplain, 8);
01181 cout << " ";
01182 output.Put(out, 8);
01183 cout << endl;
01184 }
01185 return pass;
01186 }
01187
01188 bool ValidateThreeWay()
01189 {
01190 cout << "\n3-WAY validation suite running...\n\n";
01191
01192 FileSource valdata("TestData/3wayval.dat", true, new HexDecoder);
01193 return BlockTransformationTest(FixedRoundsCipherFactory<ThreeWayEncryption, ThreeWayDecryption>(), valdata);
01194 }
01195
01196 bool ValidateGOST()
01197 {
01198 cout << "\nGOST validation suite running...\n\n";
01199
01200 FileSource valdata("TestData/gostval.dat", true, new HexDecoder);
01201 return BlockTransformationTest(FixedRoundsCipherFactory<GOSTEncryption, GOSTDecryption>(), valdata);
01202 }
01203
01204 bool ValidateSHARK()
01205 {
01206 cout << "\nSHARK validation suite running...\n\n";
01207
01208 FileSource valdata("TestData/sharkval.dat", true, new HexDecoder);
01209 return BlockTransformationTest(FixedRoundsCipherFactory<SHARKEncryption, SHARKDecryption>(), valdata);
01210 }
01211
01212 bool ValidateCAST()
01213 {
01214 bool pass = true;
01215
01216 cout << "\nCAST-128 validation suite running...\n\n";
01217
01218 FileSource val128("TestData/cast128v.dat", true, new HexDecoder);
01219 pass = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(16), val128, 1) && pass;
01220 pass = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(10), val128, 1) && pass;
01221 pass = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(5), val128, 1) && pass;
01222
01223 cout << "\nCAST-256 validation suite running...\n\n";
01224
01225 FileSource val256("TestData/cast256v.dat", true, new HexDecoder);
01226 pass = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(16), val256, 1) && pass;
01227 pass = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(24), val256, 1) && pass;
01228 pass = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(32), val256, 1) && pass;
01229
01230 return pass;
01231 }
01232
01233 bool ValidateSquare()
01234 {
01235 cout << "\nSquare validation suite running...\n\n";
01236
01237 FileSource valdata("TestData/squareva.dat", true, new HexDecoder);
01238 return BlockTransformationTest(FixedRoundsCipherFactory<SquareEncryption, SquareDecryption>(), valdata);
01239 }
01240
01241 bool ValidateSKIPJACK()
01242 {
01243 cout << "\nSKIPJACK validation suite running...\n\n";
01244
01245 FileSource valdata("TestData/skipjack.dat", true, new HexDecoder);
01246 return BlockTransformationTest(FixedRoundsCipherFactory<SKIPJACKEncryption, SKIPJACKDecryption>(), valdata);
01247 }
01248
01249 bool ValidateSEAL()
01250 {
01251 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};
01252 byte output[32];
01253 byte key[] = {0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba, 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0};
01254 byte iv[] = {0x01, 0x35, 0x77, 0xaf};
01255
01256 cout << "\nSEAL validation suite running...\n\n";
01257
01258 SEAL<>::Encryption seal(key, sizeof(key), iv);
01259 unsigned int size = sizeof(input);
01260 bool pass = true;
01261
01262 memset(output, 1, size);
01263 seal.ProcessString(output, input, size);
01264 for (unsigned int i=0; i<size; i++)
01265 if (output[i] != 0)
01266 pass = false;
01267
01268 seal.Seek(1);
01269 output[1] = seal.ProcessByte(output[1]);
01270 seal.ProcessString(output+2, size-2);
01271 pass = pass && memcmp(output+1, input+1, size-1) == 0;
01272
01273 cout << (pass ? "passed" : "FAILED") << endl;
01274 return pass;
01275 }
01276
01277 bool ValidateBaseCode()
01278 {
01279 bool pass = true, fail;
01280 byte data[255];
01281 for (unsigned int i=0; i<255; i++)
01282 data[i] = i;
01283 const char *hexEncoded =
01284 "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627"
01285 "28292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F"
01286 "505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F7071727374757677"
01287 "78797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F"
01288 "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7"
01289 "C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF"
01290 "F0F1F2F3F4F5F6F7F8F9FAFBFCFDFE";
01291 const char *base32Encoded =
01292 "AAASEA2EAWDAQCAJBIFS2DIQB6IBCESVCSKTNF22DEPBYHA7D2RUAIJCENUCKJTHFAWUWK3NFWZC8NBT"
01293 "GI3VIPJYG66DUQT5HS8V6R4AIFBEGTCFI3DWSUKKJPGE4VURKBIXEW4WKXMFQYC3MJPX2ZK8M7SGC2VD"
01294 "NTUYN35IPFXGY5DPP3ZZA6MUQP4HK7VZRB6ZW856RX9H9AEBSKB2JBNGS8EIVCWMTUG27D6SUGJJHFEX"
01295 "U4M3TGN4VQQJ5HW9WCS4FI7EWYVKRKFJXKX43MPQX82MDNXVYU45PP72ZG7MZRF7Z496BSQC2RCNMTYH"
01296 "3DE6XU8N3ZHN9WGT4MJ7JXQY49NPVYY55VQ77Z9A6HTQH3HF65V8T4RK7RYQ55ZR8D29F69W8Z5RR8H3"
01297 "9M7939R8";
01298 const char *base64AndHexEncoded =
01299 "41414543417751464267634943516F4C4441304F4478415245684D554652595847426B6147787764"
01300 "486838674953496A4A43556D4A7967704B6973734C5334764D4445794D7A51310A4E6A63344F546F"
01301 "375044302B50304242516B4E4552555A4853456C4B5330784E546B395155564A5456465657563168"
01302 "5A576C746358563566594746695932526C5A6D646F615770720A6247317562334278636E4E306458"
01303 "5A3365486C3665337839666E2B4167594B44684957476834694A696F754D6A5936506B4A47536B35"
01304 "53566C7065596D5A71626E4A32656E3643680A6F714F6B7061616E714B6D717136797472712B7773"
01305 "624B7A744C573274376935757275387662362F774D484377385446787366497963724C7A4D334F7A"
01306 "39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673"
01307 "3765377638504879382F5431397666342B6672372F50332B0A";
01308
01309 cout << "\nBase64, base32 and hex coding validation suite running...\n\n";
01310
01311 fail = !TestFilter(HexEncoder().Ref(), data, 255, (const byte *)hexEncoded, strlen(hexEncoded));
01312 cout << (fail ? "FAILED " : "passed ");
01313 cout << "Hex Encoding\n";
01314 pass = pass && !fail;
01315
01316 fail = !TestFilter(HexDecoder().Ref(), (const byte *)hexEncoded, strlen(hexEncoded), data, 255);
01317 cout << (fail ? "FAILED " : "passed ");
01318 cout << "Hex Decoding\n";
01319 pass = pass && !fail;
01320
01321 fail = !TestFilter(Base32Encoder().Ref(), data, 255, (const byte *)base32Encoded, strlen(base32Encoded));
01322 cout << (fail ? "FAILED " : "passed ");
01323 cout << "Base32 Encoding\n";
01324 pass = pass && !fail;
01325
01326 fail = !TestFilter(Base32Decoder().Ref(), (const byte *)base32Encoded, strlen(base32Encoded), data, 255);
01327 cout << (fail ? "FAILED " : "passed ");
01328 cout << "Base32 Decoding\n";
01329 pass = pass && !fail;
01330
01331 fail = !TestFilter(Base64Encoder(new HexEncoder).Ref(), data, 255, (const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded));
01332 cout << (fail ? "FAILED " : "passed ");
01333 cout << "Base64 Encoding\n";
01334 pass = pass && !fail;
01335
01336 fail = !TestFilter(HexDecoder(new Base64Decoder).Ref(), (const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded), data, 255);
01337 cout << (fail ? "FAILED " : "passed ");
01338 cout << "Base64 Decoding\n";
01339 pass = pass && !fail;
01340
01341 return pass;
01342 }
01343
01344 bool ValidateSHACAL2()
01345 {
01346 cout << "\nSHACAL-2 validation suite running...\n\n";
01347
01348 bool pass = true;
01349 FileSource valdata("TestData/shacal2v.dat", true, new HexDecoder);
01350 pass = BlockTransformationTest(FixedRoundsCipherFactory<SHACAL2Encryption, SHACAL2Decryption>(16), valdata, 4) && pass;
01351 pass = BlockTransformationTest(FixedRoundsCipherFactory<SHACAL2Encryption, SHACAL2Decryption>(64), valdata, 10) && pass;
01352 return pass;
01353 }
01354
01355 bool ValidateCamellia()
01356 {
01357 cout << "\nCamellia validation suite running...\n\n";
01358
01359 bool pass = true;
01360 FileSource valdata("TestData/camellia.dat", true, new HexDecoder);
01361 pass = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(16), valdata, 15) && pass;
01362 pass = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(24), valdata, 15) && pass;
01363 pass = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(32), valdata, 15) && pass;
01364 return pass;
01365 }
01366
01367 bool ValidateSalsa()
01368 {
01369 cout << "\nSalsa validation suite running...\n";
01370
01371 return RunTestDataFile("TestVectors/salsa.txt");
01372 }
01373
01374 bool ValidateSosemanuk()
01375 {
01376 cout << "\nSosemanuk validation suite running...\n";
01377 return RunTestDataFile("TestVectors/sosemanuk.txt");
01378 }
01379
01380 bool ValidateVMAC()
01381 {
01382 cout << "\nVMAC validation suite running...\n";
01383 return RunTestDataFile("TestVectors/vmac.txt");
01384 }
01385
01386 bool ValidateCCM()
01387 {
01388 cout << "\nAES/CCM validation suite running...\n";
01389 return RunTestDataFile("TestVectors/ccm.txt");
01390 }
01391
01392 bool ValidateGCM()
01393 {
01394 cout << "\nAES/GCM validation suite running...\n";
01395 cout << "\n2K tables:";
01396 bool pass = RunTestDataFile("TestVectors/gcm.txt", MakeParameters(Name::TableSize(), (int)2048));
01397 cout << "\n64K tables:";
01398 return RunTestDataFile("TestVectors/gcm.txt", MakeParameters(Name::TableSize(), (int)64*1024)) && pass;
01399 }
01400
01401 bool ValidateCMAC()
01402 {
01403 cout << "\nCMAC validation suite running...\n";
01404 return RunTestDataFile("TestVectors/cmac.txt");
01405 }