Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

validat1.cpp

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

Generated on Tue Aug 16 08:38:43 2005 for Crypto++ by  doxygen 1.3.9.1