00001
00002
00003 #include "pch.h"
00004
00005 #define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
00006 #include "files.h"
00007 #include "hex.h"
00008 #include "base32.h"
00009 #include "base64.h"
00010 #include "modes.h"
00011 #include "cbcmac.h"
00012 #include "dmac.h"
00013 #include "idea.h"
00014 #include "des.h"
00015 #include "rc2.h"
00016 #include "arc4.h"
00017 #include "rc5.h"
00018 #include "blowfish.h"
00019 #include "wake.h"
00020 #include "3way.h"
00021 #include "safer.h"
00022 #include "gost.h"
00023 #include "shark.h"
00024 #include "cast.h"
00025 #include "square.h"
00026 #include "seal.h"
00027 #include "rc6.h"
00028 #include "mars.h"
00029 #include "rijndael.h"
00030 #include "twofish.h"
00031 #include "serpent.h"
00032 #include "skipjack.h"
00033 #include "shacal2.h"
00034 #include "camellia.h"
00035 #include "osrng.h"
00036 #include "zdeflate.h"
00037 #include "cpu.h"
00038
00039 #include <stdlib.h>
00040 #include <time.h>
00041 #include <memory>
00042 #include <iostream>
00043 #include <iomanip>
00044
00045 #include "validate.h"
00046
00047 USING_NAMESPACE(CryptoPP)
00048 USING_NAMESPACE(std)
00049
00050 bool ValidateAll(bool thorough)
00051 {
00052 bool pass=TestSettings();
00053 pass=TestOS_RNG() && pass;
00054
00055 pass=ValidateCRC32() && pass;
00056 pass=ValidateAdler32() && pass;
00057 pass=ValidateMD2() && pass;
00058 pass=ValidateMD5() && pass;
00059 pass=ValidateSHA() && pass;
00060 pass=ValidateSHA2() && pass;
00061 pass=ValidateTiger() && pass;
00062 pass=ValidateRIPEMD() && pass;
00063 pass=ValidatePanama() && pass;
00064 pass=ValidateWhirlpool() && pass;
00065
00066 pass=ValidateHMAC() && pass;
00067 pass=ValidateTTMAC() && pass;
00068
00069 pass=ValidatePBKDF() && pass;
00070
00071 pass=ValidateDES() && pass;
00072 pass=ValidateCipherModes() && pass;
00073 pass=ValidateIDEA() && pass;
00074 pass=ValidateSAFER() && pass;
00075 pass=ValidateRC2() && pass;
00076 pass=ValidateARC4() && pass;
00077 pass=ValidateRC5() && pass;
00078 pass=ValidateBlowfish() && pass;
00079 pass=ValidateThreeWay() && pass;
00080 pass=ValidateGOST() && pass;
00081 pass=ValidateSHARK() && pass;
00082 pass=ValidateCAST() && pass;
00083 pass=ValidateSquare() && pass;
00084 pass=ValidateSKIPJACK() && pass;
00085 pass=ValidateSEAL() && pass;
00086 pass=ValidateRC6() && pass;
00087 pass=ValidateMARS() && pass;
00088 pass=ValidateRijndael() && pass;
00089 pass=ValidateTwofish() && pass;
00090 pass=ValidateSerpent() && pass;
00091 pass=ValidateSHACAL2() && pass;
00092 pass=ValidateCamellia() && pass;
00093 pass=ValidateSalsa() && pass;
00094 pass=ValidateSosemanuk() && pass;
00095 pass=ValidateVMAC() && pass;
00096
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
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
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
00295
00296 t = time(NULL);
00297 while (time(NULL) - t < 2)
00298 {
00299 test.Pump(1);
00300 total += 1;
00301 }
00302
00303
00304
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
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[] = {
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
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
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
00599
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
00620
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
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
00659
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
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[] = {
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[] = {
00726 0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
00727 const byte encrypted[] = {
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[] = {
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[] = {
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[] = {
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[] = {
00797 0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
00798 const byte mac2[] = {
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
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 }