- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

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