Crypto++
|
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