Crypto++: fipstest.cpp Source File

00001 // fipstest.cpp - written and placed in the public domain by Wei Dai
00002 
00003 #include "pch.h"
00004 
00005 #ifndef CRYPTOPP_IMPORTS
00006 
00007 #define CRYPTOPP_DEFAULT_NO_DLL
00008 #include "dll.h"
00009 
00010 #ifdef CRYPTOPP_WIN32_AVAILABLE
00011 #define _WIN32_WINNT 0x0400
00012 #include <windows.h>
00013 
00014 #if defined(_MSC_VER) && _MSC_VER >= 1400
00015 #ifdef _M_IX86
00016 #define _CRT_DEBUGGER_HOOK _crt_debugger_hook
00017 #else
00018 #define _CRT_DEBUGGER_HOOK __crt_debugger_hook
00019 #endif
00020 extern "C" {_CRTIMP void __cdecl _CRT_DEBUGGER_HOOK(int);}
00021 #endif
00022 #endif
00023 
00024 #include <iostream>
00025 
00026 NAMESPACE_BEGIN(CryptoPP)
00027 
00028 extern PowerUpSelfTestStatus g_powerUpSelfTestStatus;
00029 SecByteBlock g_actualMac;
00030 unsigned long g_macFileLocation = 0;
00031 
00032 // use a random dummy string here, to be searched/replaced later with the real MAC
00033 static const byte s_moduleMac[CryptoPP::HMAC<CryptoPP::SHA1>::DIGESTSIZE] = CRYPTOPP_DUMMY_DLL_MAC;
00034 CRYPTOPP_COMPILE_ASSERT(sizeof(s_moduleMac) == CryptoPP::SHA1::DIGESTSIZE);
00035 
00036 #ifdef CRYPTOPP_WIN32_AVAILABLE
00037 static HMODULE s_hModule = NULL;
00038 #endif
00039 
00040 const byte * CRYPTOPP_API GetActualMacAndLocation(unsigned int &macSize, unsigned int &fileLocation)
00041 {
00042         macSize = (unsigned int)g_actualMac.size();
00043         fileLocation = g_macFileLocation;
00044         return g_actualMac;
00045 }
00046 
00047 void KnownAnswerTest(RandomNumberGenerator &rng, const char *output)
00048 {
00049         EqualityComparisonFilter comparison;
00050 
00051         RandomNumberStore(rng, strlen(output)/2).TransferAllTo(comparison, "0");
00052         StringSource(output, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
00053 
00054         comparison.ChannelMessageSeriesEnd("0");
00055         comparison.ChannelMessageSeriesEnd("1");
00056 }
00057 
00058 template <class CIPHER>
00059 void X917RNG_KnownAnswerTest(
00060         const char *key, 
00061         const char *seed, 
00062         const char *deterministicTimeVector,
00063         const char *output,
00064         CIPHER *dummy = NULL)
00065 {
00066 #ifdef OS_RNG_AVAILABLE
00067         std::string decodedKey, decodedSeed, decodedDeterministicTimeVector;
00068         StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
00069         StringSource(seed, true, new HexDecoder(new StringSink(decodedSeed)));
00070         StringSource(deterministicTimeVector, true, new HexDecoder(new StringSink(decodedDeterministicTimeVector)));
00071 
00072         AutoSeededX917RNG<CIPHER> rng(false, false);
00073         rng.Reseed((const byte *)decodedKey.data(), decodedKey.size(), (const byte *)decodedSeed.data(), (const byte *)decodedDeterministicTimeVector.data());
00074         KnownAnswerTest(rng, output);
00075 #else
00076         throw 0;
00077 #endif
00078 }
00079 
00080 void KnownAnswerTest(StreamTransformation &encryption, StreamTransformation &decryption, const char *plaintext, const char *ciphertext)
00081 {
00082         EqualityComparisonFilter comparison;
00083 
00084         StringSource(plaintext, true, new HexDecoder(new StreamTransformationFilter(encryption, new ChannelSwitch(comparison, "0"), StreamTransformationFilter::NO_PADDING)));
00085         StringSource(ciphertext, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
00086 
00087         StringSource(ciphertext, true, new HexDecoder(new StreamTransformationFilter(decryption, new ChannelSwitch(comparison, "0"), StreamTransformationFilter::NO_PADDING)));
00088         StringSource(plaintext, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
00089 
00090         comparison.ChannelMessageSeriesEnd("0");
00091         comparison.ChannelMessageSeriesEnd("1");
00092 }
00093 
00094 template <class CIPHER>
00095 void SymmetricEncryptionKnownAnswerTest(
00096         const char *key, 
00097         const char *hexIV, 
00098         const char *plaintext, 
00099         const char *ecb,
00100         const char *cbc,
00101         const char *cfb,
00102         const char *ofb,
00103         const char *ctr,
00104         CIPHER *dummy = NULL)
00105 {
00106         std::string decodedKey;
00107         StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
00108 
00109         typename CIPHER::Encryption encryption((const byte *)decodedKey.data(), decodedKey.size());
00110         typename CIPHER::Decryption decryption((const byte *)decodedKey.data(), decodedKey.size());
00111 
00112         SecByteBlock iv(encryption.BlockSize());
00113         StringSource(hexIV, true, new HexDecoder(new ArraySink(iv, iv.size())));
00114 
00115         if (ecb)
00116                 KnownAnswerTest(ECB_Mode_ExternalCipher::Encryption(encryption).Ref(), ECB_Mode_ExternalCipher::Decryption(decryption).Ref(), plaintext, ecb);
00117         if (cbc)
00118                 KnownAnswerTest(CBC_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CBC_Mode_ExternalCipher::Decryption(decryption, iv).Ref(), plaintext, cbc);
00119         if (cfb)
00120                 KnownAnswerTest(CFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, cfb);
00121         if (ofb)
00122                 KnownAnswerTest(OFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), OFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ofb);
00123         if (ctr)
00124                 KnownAnswerTest(CTR_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CTR_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ctr);
00125 }
00126 
00127 void KnownAnswerTest(HashTransformation &hash, const char *message, const char *digest)
00128 {
00129         EqualityComparisonFilter comparison;
00130         StringSource(digest, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
00131         StringSource(message, true, new HashFilter(hash, new ChannelSwitch(comparison, "0")));
00132 
00133         comparison.ChannelMessageSeriesEnd("0");
00134         comparison.ChannelMessageSeriesEnd("1");
00135 }
00136 
00137 template <class HASH>
00138 void SecureHashKnownAnswerTest(const char *message, const char *digest, HASH *dummy = NULL)
00139 {
00140         HASH hash;
00141         KnownAnswerTest(hash, message, digest);
00142 }
00143 
00144 template <class MAC>
00145 void MAC_KnownAnswerTest(const char *key, const char *message, const char *digest, MAC *dummy = NULL)
00146 {
00147         std::string decodedKey;
00148         StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
00149 
00150         MAC mac((const byte *)decodedKey.data(), decodedKey.size());
00151         KnownAnswerTest(mac, message, digest);
00152 }
00153 
00154 template <class SCHEME>
00155 void SignatureKnownAnswerTest(const char *key, const char *message, const char *signature, SCHEME *dummy = NULL)
00156 {
00157         typename SCHEME::Signer signer(StringSource(key, true, new HexDecoder).Ref());
00158         typename SCHEME::Verifier verifier(signer);
00159 
00160         RandomPool rng;
00161         EqualityComparisonFilter comparison;
00162 
00163         StringSource(message, true, new SignerFilter(rng, signer, new ChannelSwitch(comparison, "0")));
00164         StringSource(signature, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
00165 
00166         comparison.ChannelMessageSeriesEnd("0");
00167         comparison.ChannelMessageSeriesEnd("1");
00168 
00169         VerifierFilter verifierFilter(verifier, NULL, VerifierFilter::SIGNATURE_AT_BEGIN | VerifierFilter::THROW_EXCEPTION);
00170         StringSource(signature, true, new HexDecoder(new Redirector(verifierFilter, Redirector::DATA_ONLY)));
00171         StringSource(message, true, new Redirector(verifierFilter));
00172 }
00173 
00174 void EncryptionPairwiseConsistencyTest(const PK_Encryptor &encryptor, const PK_Decryptor &decryptor)
00175 {
00176         try
00177         {
00178                 RandomPool rng;
00179                 const char *testMessage ="test message";
00180                 std::string ciphertext, decrypted;
00181 
00182                 StringSource(
00183                         testMessage, 
00184                         true, 
00185                         new PK_EncryptorFilter(
00186                                 rng, 
00187                                 encryptor, 
00188                                 new StringSink(ciphertext)));
00189 
00190                 if (ciphertext == testMessage)
00191                         throw 0;
00192 
00193                 StringSource(
00194                         ciphertext, 
00195                         true, 
00196                         new PK_DecryptorFilter(
00197                                 rng, 
00198                                 decryptor, 
00199                                 new StringSink(decrypted)));
00200 
00201                 if (decrypted != testMessage)
00202                         throw 0;
00203         }
00204         catch (...)
00205         {
00206                 throw SelfTestFailure(encryptor.AlgorithmName() + ": pairwise consistency test failed");
00207         }
00208 }
00209 
00210 void SignaturePairwiseConsistencyTest(const PK_Signer &signer, const PK_Verifier &verifier)
00211 {
00212         try
00213         {
00214                 RandomPool rng;
00215 
00216                 StringSource(
00217                         "test message", 
00218                         true, 
00219                         new SignerFilter(
00220                                 rng, 
00221                                 signer, 
00222                                 new VerifierFilter(verifier, NULL, VerifierFilter::THROW_EXCEPTION),
00223                                 true));
00224         }
00225         catch (...)
00226         {
00227                 throw SelfTestFailure(signer.AlgorithmName() + ": pairwise consistency test failed");
00228         }
00229 }
00230 
00231 template <class SCHEME>
00232 void SignaturePairwiseConsistencyTest(const char *key, SCHEME *dummy = NULL)
00233 {
00234         typename SCHEME::Signer signer(StringSource(key, true, new HexDecoder).Ref());
00235         typename SCHEME::Verifier verifier(signer);
00236 
00237         SignaturePairwiseConsistencyTest(signer, verifier);
00238 }
00239 
00240 MessageAuthenticationCode * NewIntegrityCheckingMAC()
00241 {
00242         byte key[] = {0x47, 0x1E, 0x33, 0x96, 0x65, 0xB1, 0x6A, 0xED, 0x0B, 0xF8, 0x6B, 0xFD, 0x01, 0x65, 0x05, 0xCC};
00243         return new HMAC<SHA1>(key, sizeof(key));
00244 }
00245 
00246 bool IntegrityCheckModule(const char *moduleFilename, const byte *expectedModuleMac, SecByteBlock *pActualMac, unsigned long *pMacFileLocation)
00247 {
00248         std::auto_ptr<MessageAuthenticationCode> mac(NewIntegrityCheckingMAC());
00249         unsigned int macSize = mac->DigestSize();
00250 
00251         SecByteBlock tempMac;
00252         SecByteBlock &actualMac = pActualMac ? *pActualMac : tempMac;
00253         actualMac.resize(macSize);
00254 
00255         unsigned long tempLocation;
00256         unsigned long &macFileLocation = pMacFileLocation ? *pMacFileLocation : tempLocation;
00257         macFileLocation = 0;
00258 
00259         MeterFilter verifier(new HashFilter(*mac, new ArraySink(actualMac, actualMac.size())));
00260 //      MeterFilter verifier(new FileSink("c:\\dt.tmp"));
00261         std::ifstream moduleStream;
00262 
00263 #ifdef CRYPTOPP_WIN32_AVAILABLE
00264         HMODULE h;
00265         {
00266         char moduleFilenameBuf[MAX_PATH] = "";
00267         if (moduleFilename == NULL)
00268         {
00269 #if (_MSC_VER >= 1400 && !defined(_STLPORT_VERSION))    // ifstream doesn't support wide filename on other compilers
00270                 wchar_t wideModuleFilename[MAX_PATH];
00271                 if (GetModuleFileNameW(s_hModule, wideModuleFilename, MAX_PATH) > 0)
00272                 {
00273                         moduleStream.open(wideModuleFilename, std::ios::in | std::ios::binary);
00274                         h = GetModuleHandleW(wideModuleFilename);
00275                 }
00276                 else
00277 #endif
00278                 {
00279                         GetModuleFileNameA(s_hModule, moduleFilenameBuf, MAX_PATH);
00280                         moduleFilename = moduleFilenameBuf;
00281                 }
00282         }
00283 #endif
00284         if (moduleFilename != NULL)
00285         {
00286                         moduleStream.open(moduleFilename, std::ios::in | std::ios::binary);
00287 #ifdef CRYPTOPP_WIN32_AVAILABLE
00288                         h = GetModuleHandleA(moduleFilename);
00289                         moduleFilename = NULL;
00290         }
00291 #endif
00292         }
00293 
00294         if (!moduleStream)
00295         {
00296 #ifdef CRYPTOPP_WIN32_AVAILABLE
00297                 OutputDebugString("Crypto++ DLL integrity check failed. Cannot open file for reading.");
00298 #endif
00299                 return false;
00300         }
00301         FileStore file(moduleStream);
00302 
00303 #ifdef CRYPTOPP_WIN32_AVAILABLE
00304         // try to hash from memory first
00305         const byte *memBase = (const byte *)h;
00306         const IMAGE_DOS_HEADER *ph = (IMAGE_DOS_HEADER *)memBase;
00307         const IMAGE_NT_HEADERS *phnt = (IMAGE_NT_HEADERS *)(memBase + ph->e_lfanew);
00308         const IMAGE_SECTION_HEADER *phs = IMAGE_FIRST_SECTION(phnt);
00309         DWORD nSections = phnt->FileHeader.NumberOfSections;
00310         size_t currentFilePos = 0;
00311 
00312         size_t checksumPos = (byte *)&phnt->OptionalHeader.CheckSum - memBase;
00313         size_t checksumSize = sizeof(phnt->OptionalHeader.CheckSum);
00314         size_t certificateTableDirectoryPos = (byte *)&phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY] - memBase;
00315         size_t certificateTableDirectorySize = sizeof(phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
00316         size_t certificateTablePos = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress;
00317         size_t certificateTableSize = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size;
00318 
00319         verifier.AddRangeToSkip(0, checksumPos, checksumSize);
00320         verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
00321         verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);
00322 
00323         while (nSections--)
00324         {
00325                 switch (phs->Characteristics)
00326                 {
00327                 default:
00328                         break;
00329                 case IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
00330                 case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ:
00331                         unsigned int sectionSize = STDMIN(phs->SizeOfRawData, phs->Misc.VirtualSize);
00332                         const byte *sectionMemStart = memBase + phs->VirtualAddress;
00333                         unsigned int sectionFileStart = phs->PointerToRawData;
00334                         size_t subSectionStart = 0, nextSubSectionStart;
00335 
00336                         do
00337                         {
00338                                 const byte *subSectionMemStart = sectionMemStart + subSectionStart;
00339                                 size_t subSectionFileStart = sectionFileStart + subSectionStart;
00340                                 size_t subSectionSize = sectionSize - subSectionStart;
00341                                 nextSubSectionStart = 0;
00342 
00343                                 unsigned int entriesToReadFromDisk[] = {IMAGE_DIRECTORY_ENTRY_IMPORT, IMAGE_DIRECTORY_ENTRY_IAT};
00344                                 for (unsigned int i=0; i<sizeof(entriesToReadFromDisk)/sizeof(entriesToReadFromDisk[0]); i++)
00345                                 {
00346                                         const IMAGE_DATA_DIRECTORY &entry = phnt->OptionalHeader.DataDirectory[entriesToReadFromDisk[i]];
00347                                         const byte *entryMemStart = memBase + entry.VirtualAddress;
00348                                         if (subSectionMemStart <= entryMemStart && entryMemStart < subSectionMemStart + subSectionSize)
00349                                         {
00350                                                 subSectionSize = entryMemStart - subSectionMemStart;
00351                                                 nextSubSectionStart = entryMemStart - sectionMemStart + entry.Size;
00352                                         }
00353                                 }
00354 
00355 #if defined(_MSC_VER) && _MSC_VER >= 1400
00356                                 // first byte of _CRT_DEBUGGER_HOOK gets modified in memory by the debugger invisibly, so read it from file
00357                                 if (IsDebuggerPresent())
00358                                 {
00359                                         if (subSectionMemStart <= (byte *)&_CRT_DEBUGGER_HOOK && (byte *)&_CRT_DEBUGGER_HOOK < subSectionMemStart + subSectionSize)
00360                                         {
00361                                                 subSectionSize = (byte *)&_CRT_DEBUGGER_HOOK - subSectionMemStart;
00362                                                 nextSubSectionStart = (byte *)&_CRT_DEBUGGER_HOOK - sectionMemStart + 1;
00363                                         }
00364                                 }
00365 #endif
00366 
00367                                 if (subSectionMemStart <= expectedModuleMac && expectedModuleMac < subSectionMemStart + subSectionSize)
00368                                 {
00369                                         // found stored MAC
00370                                         macFileLocation = (unsigned long)(subSectionFileStart + (expectedModuleMac - subSectionMemStart));
00371                                         verifier.AddRangeToSkip(0, macFileLocation, macSize);
00372                                 }
00373 
00374                                 file.TransferTo(verifier, subSectionFileStart - currentFilePos);
00375                                 verifier.Put(subSectionMemStart, subSectionSize);
00376                                 file.Skip(subSectionSize);
00377                                 currentFilePos = subSectionFileStart + subSectionSize;
00378                                 subSectionStart = nextSubSectionStart;
00379                         } while (nextSubSectionStart != 0);
00380                 }
00381                 phs++;
00382         }
00383 #endif
00384         file.TransferAllTo(verifier);
00385 
00386 #ifdef CRYPTOPP_WIN32_AVAILABLE
00387         // if that fails (could be caused by debug breakpoints or DLL base relocation modifying image in memory),
00388         // hash from disk instead
00389         if (!VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
00390         {
00391                 OutputDebugString("In memory integrity check failed. This may be caused by debug breakpoints or DLL relocation.\n");
00392                 moduleStream.clear();
00393                 moduleStream.seekg(0);
00394                 verifier.Initialize(MakeParameters(Name::OutputBuffer(), ByteArrayParameter(actualMac, (unsigned int)actualMac.size())));
00395 //              verifier.Initialize(MakeParameters(Name::OutputFileName(), (const char *)"c:\\dt2.tmp"));
00396                 verifier.AddRangeToSkip(0, checksumPos, checksumSize);
00397                 verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
00398                 verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);
00399                 verifier.AddRangeToSkip(0, macFileLocation, macSize);
00400                 FileStore(moduleStream).TransferAllTo(verifier);
00401         }
00402 #endif
00403 
00404         if (VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
00405                 return true;
00406 
00407 #ifdef CRYPTOPP_WIN32_AVAILABLE
00408         std::string hexMac;
00409         HexEncoder(new StringSink(hexMac)).PutMessageEnd(actualMac, actualMac.size());
00410         OutputDebugString((("Crypto++ DLL integrity check failed. Actual MAC is: " + hexMac) + "\n").c_str());
00411 #endif
00412         return false;
00413 }
00414 
00415 void DoPowerUpSelfTest(const char *moduleFilename, const byte *expectedModuleMac)
00416 {
00417         g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_NOT_DONE;
00418         SetPowerUpSelfTestInProgressOnThisThread(true);
00419 
00420         try
00421         {
00422                 if (FIPS_140_2_ComplianceEnabled() || expectedModuleMac != NULL)
00423                 {
00424                         if (!IntegrityCheckModule(moduleFilename, expectedModuleMac, &g_actualMac, &g_macFileLocation))
00425                                 throw 0;        // throw here so we break in the debugger, this will be caught right away
00426                 }
00427 
00428                 // algorithm tests
00429 
00430                 X917RNG_KnownAnswerTest<AES>(
00431                         "2b7e151628aed2a6abf7158809cf4f3c",                                                                             // key
00432                         "000102030405060708090a0b0c0d0e0f",                                                                             // seed
00433                         "00000000000000000000000000000001",                                                                             // time vector
00434                         "D176EDD27493B0395F4D10546232B0693DC7061C03C3A554F09CECF6F6B46D945A");  // output
00435 
00436                 SymmetricEncryptionKnownAnswerTest<DES_EDE3>(
00437                         "385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E",
00438                         "C141B5FCCD28DC8A",
00439                         "6E1BD7C6120947A464A6AAB293A0F89A563D8D40D3461B68",
00440                         "64EAAD4ACBB9CEAD6C7615E7C7E4792FE587D91F20C7D2F4",
00441                         "6235A461AFD312973E3B4F7AA7D23E34E03371F8E8C376C9",
00442                         "E26BA806A59B0330DE40CA38E77A3E494BE2B212F6DD624B",
00443                         "E26BA806A59B03307DE2BCC25A08BA40A8BA335F5D604C62",
00444                         "E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371");
00445 
00446                 SymmetricEncryptionKnownAnswerTest<SKIPJACK>(
00447                         "1555E5531C3A169B2D65",
00448                         "6EC9795701F49864",
00449                         "00AFA48E9621E52E8CBDA312660184EDDB1F33D9DACDA8DA",
00450                         "DBEC73562EFCAEB56204EB8AE9557EBF77473FBB52D17CD1",
00451                         "0C7B0B74E21F99B8F2C8DF37879F6C044967F42A796DCA8B",
00452                         "79FDDA9724E36CC2E023E9A5C717A8A8A7FDA465CADCBF63",
00453                         "79FDDA9724E36CC26CACBD83C1ABC06EAF5B249BE5B1E040",
00454                         "79FDDA9724E36CC211B0AEC607B95A96BCDA318440B82F49");
00455 
00456                 SymmetricEncryptionKnownAnswerTest<AES>(
00457                         "2b7e151628aed2a6abf7158809cf4f3c",
00458                         "000102030405060708090a0b0c0d0e0f",
00459                         "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",     // plaintext
00460                         "3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4", // ecb
00461                         "7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7",     // cbc
00462                         "3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6", // cfb
00463                         "3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e", // ofb
00464                         NULL);
00465 
00466                 SymmetricEncryptionKnownAnswerTest<AES>(
00467                         "2b7e151628aed2a6abf7158809cf4f3c",
00468                         "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
00469                         "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
00470                         NULL,
00471                         NULL,
00472                         NULL,
00473                         NULL,
00474                         "874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab1e031dda2fbe03d1792170a0f3009cee"); // ctr
00475 
00476 
00477                 SecureHashKnownAnswerTest<SHA1>(
00478                         "abc",
00479                         "A9993E364706816ABA3E25717850C26C9CD0D89D");
00480 
00481                 SecureHashKnownAnswerTest<SHA224>(
00482                         "abc",
00483                         "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7");
00484 
00485                 SecureHashKnownAnswerTest<SHA256>(
00486                         "abc",
00487                         "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
00488 
00489                 SecureHashKnownAnswerTest<SHA384>(
00490                         "abc",
00491                         "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7");
00492 
00493                 SecureHashKnownAnswerTest<SHA512>(
00494                         "abc",
00495                         "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");
00496 
00497                 MAC_KnownAnswerTest<HMAC<SHA1> >(
00498                         "303132333435363738393a3b3c3d3e3f40414243",
00499                         "Sample #2",
00500                         "0922d3405faa3d194f82a45830737d5cc6c75d24");
00501 
00502                 const char *keyRSA1 = 
00503                         "30820150020100300d06092a864886f70d01010105000482013a3082013602010002400a66791dc6988168de7ab77419bb7fb0"
00504                         "c001c62710270075142942e19a8d8c51d053b3e3782a1de5dc5af4ebe99468170114a1dfe67cdc9a9af55d655620bbab0203010001"
00505                         "02400123c5b61ba36edb1d3679904199a89ea80c09b9122e1400c09adcf7784676d01d23356a7d44d6bd8bd50e94bfc723fa"
00506                         "87d8862b75177691c11d757692df8881022033d48445c859e52340de704bcdda065fbb4058d740bd1d67d29e9c146c11cf61"
00507                         "0220335e8408866b0fd38dc7002d3f972c67389a65d5d8306566d5c4f2a5aa52628b0220045ec90071525325d3d46db79695e9af"
00508                         "acc4523964360e02b119baa366316241022015eb327360c7b60d12e5e2d16bdcd97981d17fba6b70db13b20b436e24eada590220"
00509                         "2ca6366d72781dfa24d34a9a24cbc2ae927a9958af426563ff63fb11658a461d";
00510 
00511                 const char *keyRSA2 =
00512                         "30820273020100300D06092A864886F70D01010105000482025D3082025902010002818100D40AF9"
00513                         "A2B713034249E5780056D70FC7DE75D76E44565AA6A6B8ED9646F3C19F9E254D72D7DE6E49DB2264"
00514                         "0C1D05AB9E2A5F901D8F3FE1F7AE02CEE2ECCE54A40ABAE55A004692752E70725AEEE7CDEA67628A"
00515                         "82A9239B4AB660C2BC56D9F01E90CBAAB9BF0FC8E17173CEFC5709A29391A7DDF3E0B758691AAF30"
00516                         "725B292F4F020111027F18C0BA087D082C45D75D3594E0767E4820818EB35612B80CEAB8C880ACA5"
00517                         "44B6876DFFEF85A576C0D45B551AFAA1FD63209CD745DF75C5A0F0B580296EA466CD0338207E4752"
00518                         "FF4E7DB724D8AE18CE5CF4153BB94C27869FBB50E64F02546E4B02997A0B8623E64017CC770759C6"
00519                         "695DB649EEFD829D688D441BCC4E7348F1024100EF86DD7AF3F32CDE8A9F6564E43A559A0C9F8BAD"
00520                         "36CC25330548B347AC158A345631FA90F7B873C36EFFAE2F7823227A3F580B5DD18304D5932751E7"
00521                         "43E9234F024100E2A039854B55688740E32A51DF4AF88613D91A371CF8DDD95D780A89D7CF2119A9"
00522                         "54F1AC0F3DCDB2F6959926E6D9D37D8BC07A4C634DE6F16315BD5F0DAC340102407ECEEDB9903572"
00523                         "1B76909F174BA6698DCA72953D957B22C0A871C8531EDE3A1BB52984A719BC010D1CA57A555DB83F"
00524                         "6DE54CBAB932AEC652F38D497A6F3F30CF024100854F30E4FF232E6DADB2CD99926855F484255AB7"
00525                         "01FBCDCB27EC426F33A7046972AA700ADBCA008763DF87440F52F4E070531AC385B55AAC1C2AE7DD"
00526                         "8F9278F1024100C313F4AF9E4A9DE1253C21080CE524251560C111550772FD08690F13FBE658342E"
00527                         "BD2D41C9DCB12374E871B1839E26CAE252E1AE3DAAD5F1EE1F42B4D0EE7581";
00528 
00529                 SignatureKnownAnswerTest<RSASS<PKCS1v15, SHA1> >(
00530                         keyRSA1,
00531                         "Everyone gets Friday off.",
00532                         "0610761F95FFD1B8F29DA34212947EC2AA0E358866A722F03CC3C41487ADC604A48FF54F5C6BEDB9FB7BD59F82D6E55D8F3174BA361B2214B2D74E8825E04E81");
00533 
00534                 SignatureKnownAnswerTest<RSASS_ISO<SHA1> >(
00535                         keyRSA2,
00536                         "test",
00537                         "32F6BA41C8930DE71EE67F2627172CC539EDE04267FDE03AC295E3C50311F26C3B275D3AF513AC96"
00538                         "8EE493BAB7DA3A754661D1A7C4A0D1A2B7EE8B313AACD8CB8BFBC5C15EFB0EF15C86A9334A1E87AD"
00539                         "291EB961B5CA0E84930429B28780816AA94F96FC2367B71E2D2E4866FA966795B147F00600E5207E"
00540                         "2F189C883B37477C");
00541 
00542                 SignaturePairwiseConsistencyTest<DSA>(
00543                         "3082014A0201003082012B06072A8648CE3804013082011E02818100F468699A6F6EBCC0120D3B34C8E007F125EC7D81F763B8D0F33869AE3BD6B9F2ECCC7DF34DF84C0307449E9B85D30D57194BCCEB310F48141914DD13A077AAF9B624A6CBE666BBA1D7EBEA95B5BA6F54417FD5D4E4220C601E071D316A24EA814E8B0122DBF47EE8AEEFD319EBB01DD95683F10DBB4FEB023F8262A07EAEB7FD02150082AD4E034DA6EEACDFDAE68C36F2BAD614F9E53B02818071AAF73361A26081529F7D84078ADAFCA48E031DB54AD57FB1A833ADBD8672328AABAA0C756247998D7A5B10DACA359D231332CE8120B483A784FE07D46EEBFF0D7D374A10691F78653E6DC29E27CCB1B174923960DFE5B959B919B2C3816C19251832AFD8E35D810E598F82877ABF7D40A041565168BD7F0E21E3FE2A8D8C1C0416021426EBA66E846E755169F84A1DA981D86502405DDF");
00544 
00545                 SignaturePairwiseConsistencyTest<ECDSA<EC2N, SHA1> >(
00546                         "302D020100301006072A8648CE3D020106052B8104000404163014020101040F0070337065E1E196980A9D00E37211");
00547 
00548                 SignaturePairwiseConsistencyTest<ECDSA<ECP, SHA1> >(
00549                         "3039020100301306072A8648CE3D020106082A8648CE3D030101041F301D02010104182BB8A13C8B867010BD9471D9E81FDB01ABD0538C64D6249A");
00550 
00551                 SignaturePairwiseConsistencyTest<RSASS<PSS, SHA1> >(keyRSA1);
00552         }
00553         catch (...)
00554         {
00555                 g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_FAILED;
00556                 goto done;
00557         }
00558 
00559         g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_PASSED;
00560 
00561 done:
00562         SetPowerUpSelfTestInProgressOnThisThread(false);
00563         return;
00564 }
00565 
00566 #ifdef CRYPTOPP_WIN32_AVAILABLE
00567 
00568 void DoDllPowerUpSelfTest()
00569 {
00570         CryptoPP::DoPowerUpSelfTest(NULL, s_moduleMac);
00571 }
00572 
00573 #else
00574 
00575 void DoDllPowerUpSelfTest()
00576 {
00577         throw NotImplemented("DoDllPowerUpSelfTest() only available on Windows");
00578 }
00579 
00580 #endif  // #ifdef CRYPTOPP_WIN32_AVAILABLE
00581 
00582 NAMESPACE_END
00583 
00584 #ifdef CRYPTOPP_WIN32_AVAILABLE
00585 
00586 // DllMain needs to be in the global namespace
00587 BOOL APIENTRY DllMain(HANDLE hModule, 
00588                       DWORD  ul_reason_for_call, 
00589                       LPVOID lpReserved)
00590 {
00591         if (ul_reason_for_call == DLL_PROCESS_ATTACH)
00592         {
00593                 CryptoPP::s_hModule = (HMODULE)hModule;
00594                 CryptoPP::DoDllPowerUpSelfTest();
00595         }
00596     return TRUE;
00597 }
00598 
00599 #endif  // #ifdef CRYPTOPP_WIN32_AVAILABLE
00600 
00601 #endif  // #ifndef CRYPTOPP_IMPORTS