- Main Page
- Namespaces
- Classes
- Files

# validat1.cpp

    00001 // validat1.cpp - written and placed in the public domain by Wei Dai
    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 //      pass=ValidateBlumGoldwasser() && pass;
    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                 // check that it doesn't take too long to generate a reasonable amount of randomness
    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                         // that was fast, are we really blocking?
    00304                         // first exhaust the extropy reserve
    00305                         t = time(NULL);
    00306                         while (time(NULL) - t < 2)
    00307                         {
    00308                                 test.Pump(1);
    00309                                 total += 1;
    00310                         }
    00311
    00312                         // if it generates too many bytes in a certain amount of time,
    00313                         // something's probably wrong
    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 // VC50 workaround
    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[] = {  // "Now is the time for all " without tailing 0
    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                 // from FIPS 81
    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                 // from FIPS 81
    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                 // generated with Crypto++, matches FIPS 81
    00608                 // but has extra 8 bytes as result of padding
    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                 // generated with Crypto++ 5.2, matches FIPS 81
    00629                 // but has extra 8 bytes as result of padding
    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                 // generated with Crypto++
    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                 // generated with Crypto++, matches FIPS 81
    00668                 // but with last two blocks swapped as result of CTS
    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                 // generated with Crypto++
    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[] = {      // from FIPS 81
    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[] = {  // "Now is the." without tailing 0
    00735                         0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
    00736                 const byte encrypted[] = {      // from FIPS 81
    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[] = {      // from Eric Young's libdes
    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[] = {      // generated with Crypto++
    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[] = {  // "7654321 Now is the time for "
    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[] = {   // from FIPS 113
    00806                         0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
    00807                 const byte mac2[] = {   // generated with Crypto++
    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         // VC60 workaround: auto_ptr lacks reset()
    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 }