1 // fipstest.cpp - written and placed in the public domain by Wei Dai
2
3 #include "pch.h"
4 #include "config.h"
5
6 #ifndef CRYPTOPP_IMPORTS
7
8 #define CRYPTOPP_DEFAULT_NO_DLL
9 #include "dll.h"
10 #include "cryptlib.h"
11 #include "filters.h"
12 #include "smartptr.h"
13 #include "misc.h"
14
15 // Simply disable CRYPTOPP_WIN32_AVAILABLE for Windows Phone and Windows Store apps
16 #ifdef CRYPTOPP_WIN32_AVAILABLE
17 # if defined(WINAPI_FAMILY)
18 # if !(WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP))
19 # undef CRYPTOPP_WIN32_AVAILABLE
20 # endif
21 # endif
22 #endif
23
24 #ifdef CRYPTOPP_WIN32_AVAILABLE
25 #ifndef _WIN32_WINNT
26 #define _WIN32_WINNT 0x0400
27 #endif
28
29 #include <windows.h>
30
31 #if defined(_MSC_VER) && _MSC_VER >= 1400
32 #ifdef _M_IX86
33 #define _CRT_DEBUGGER_HOOK _crt_debugger_hook
34 #else
35 #define _CRT_DEBUGGER_HOOK __crt_debugger_hook
36 #endif
37 #if _MSC_VER < 1900
38 extern "C" {_CRTIMP void __cdecl _CRT_DEBUGGER_HOOK(int);}
39 #else
40 extern "C" {void __cdecl _CRT_DEBUGGER_HOOK(int); }
41 #endif
42 #endif
43 #endif
44
45 #include <sstream>
46 #include <iostream>
47
48 #if CRYPTOPP_MSC_VERSION
49 # pragma warning(disable: 4100)
50 #endif
51
52 NAMESPACE_BEGIN(CryptoPP)
53
54 extern PowerUpSelfTestStatus g_powerUpSelfTestStatus;
55 SecByteBlock g_actualMac;
56 unsigned long g_macFileLocation = 0;
57
58 // $ grep -iIR baseaddress *.*proj
59 // cryptdll.vcxproj: <BaseAddress>0x42900000</BaseAddress>
60 // cryptdll.vcxproj: <BaseAddress>0x42900000</BaseAddress>
61 // cryptdll.vcxproj: <BaseAddress>0x42900000</BaseAddress>
62 // cryptdll.vcxproj: <BaseAddress>0x42900000</BaseAddress>
63 const void* g_BaseAddressOfMAC = reinterpret_cast<void*>(0x42900000);
64
65 // use a random dummy string here, to be searched/replaced later with the real MAC
66 static const byte s_moduleMac[CryptoPP::HMAC<CryptoPP::SHA1>::DIGESTSIZE] = CRYPTOPP_DUMMY_DLL_MAC;
67 CRYPTOPP_COMPILE_ASSERT(sizeof(s_moduleMac) == CryptoPP::SHA1::DIGESTSIZE);
68
69 #ifdef CRYPTOPP_WIN32_AVAILABLE
70 static HMODULE s_hModule = NULL;
71 #endif
72
GetActualMacAndLocation(unsigned int & macSize,unsigned int & fileLocation)73 const byte * CRYPTOPP_API GetActualMacAndLocation(unsigned int &macSize, unsigned int &fileLocation)
74 {
75 macSize = (unsigned int)g_actualMac.size();
76 fileLocation = g_macFileLocation;
77 return g_actualMac;
78 }
79
KnownAnswerTest(RandomNumberGenerator & rng,const char * output)80 void KnownAnswerTest(RandomNumberGenerator &rng, const char *output)
81 {
82 EqualityComparisonFilter comparison;
83
84 RandomNumberStore(rng, strlen(output)/2).TransferAllTo(comparison, "0");
85 StringSource(output, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
86
87 comparison.ChannelMessageSeriesEnd("0");
88 comparison.ChannelMessageSeriesEnd("1");
89 }
90
91 template <class CIPHER>
X917RNG_KnownAnswerTest(const char * key,const char * seed,const char * deterministicTimeVector,const char * output)92 void X917RNG_KnownAnswerTest(
93 const char *key,
94 const char *seed,
95 const char *deterministicTimeVector,
96 const char *output)
97 {
98 #ifdef OS_RNG_AVAILABLE
99 std::string decodedKey, decodedSeed, decodedDeterministicTimeVector;
100 StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
101 StringSource(seed, true, new HexDecoder(new StringSink(decodedSeed)));
102 StringSource(deterministicTimeVector, true, new HexDecoder(new StringSink(decodedDeterministicTimeVector)));
103
104 AutoSeededX917RNG<CIPHER> rng(false, false);
105 rng.Reseed((const byte *)decodedKey.data(), decodedKey.size(), (const byte *)decodedSeed.data(), (const byte *)decodedDeterministicTimeVector.data());
106 KnownAnswerTest(rng, output);
107 #else
108 throw 0;
109 #endif
110 }
111
KnownAnswerTest(StreamTransformation & encryption,StreamTransformation & decryption,const char * plaintext,const char * ciphertext)112 void KnownAnswerTest(StreamTransformation &encryption, StreamTransformation &decryption, const char *plaintext, const char *ciphertext)
113 {
114 EqualityComparisonFilter comparison;
115
116 StringSource(plaintext, true, new HexDecoder(new StreamTransformationFilter(encryption, new ChannelSwitch(comparison, "0"), StreamTransformationFilter::NO_PADDING)));
117 StringSource(ciphertext, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
118
119 StringSource(ciphertext, true, new HexDecoder(new StreamTransformationFilter(decryption, new ChannelSwitch(comparison, "0"), StreamTransformationFilter::NO_PADDING)));
120 StringSource(plaintext, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
121
122 comparison.ChannelMessageSeriesEnd("0");
123 comparison.ChannelMessageSeriesEnd("1");
124 }
125
126 template <class CIPHER>
SymmetricEncryptionKnownAnswerTest(const char * key,const char * hexIV,const char * plaintext,const char * ecb,const char * cbc,const char * cfb,const char * ofb,const char * ctr)127 void SymmetricEncryptionKnownAnswerTest(
128 const char *key,
129 const char *hexIV,
130 const char *plaintext,
131 const char *ecb,
132 const char *cbc,
133 const char *cfb,
134 const char *ofb,
135 const char *ctr)
136 {
137 std::string decodedKey;
138 StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
139
140 typename CIPHER::Encryption encryption((const byte *)decodedKey.data(), decodedKey.size());
141 typename CIPHER::Decryption decryption((const byte *)decodedKey.data(), decodedKey.size());
142
143 SecByteBlock iv(encryption.BlockSize());
144 StringSource(hexIV, true, new HexDecoder(new ArraySink(iv, iv.size())));
145
146 if (ecb)
147 KnownAnswerTest(ECB_Mode_ExternalCipher::Encryption(encryption).Ref(), ECB_Mode_ExternalCipher::Decryption(decryption).Ref(), plaintext, ecb);
148 if (cbc)
149 KnownAnswerTest(CBC_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CBC_Mode_ExternalCipher::Decryption(decryption, iv).Ref(), plaintext, cbc);
150 if (cfb)
151 KnownAnswerTest(CFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, cfb);
152 if (ofb)
153 KnownAnswerTest(OFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), OFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ofb);
154 if (ctr)
155 KnownAnswerTest(CTR_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CTR_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ctr);
156 }
157
KnownAnswerTest(HashTransformation & hash,const char * message,const char * digest)158 void KnownAnswerTest(HashTransformation &hash, const char *message, const char *digest)
159 {
160 EqualityComparisonFilter comparison;
161 StringSource(digest, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
162 StringSource(message, true, new HashFilter(hash, new ChannelSwitch(comparison, "0")));
163
164 comparison.ChannelMessageSeriesEnd("0");
165 comparison.ChannelMessageSeriesEnd("1");
166 }
167
168 template <class HASH>
SecureHashKnownAnswerTest(const char * message,const char * digest)169 void SecureHashKnownAnswerTest(const char *message, const char *digest)
170 {
171 HASH hash;
172 KnownAnswerTest(hash, message, digest);
173 }
174
175 template <class MAC>
MAC_KnownAnswerTest(const char * key,const char * message,const char * digest)176 void MAC_KnownAnswerTest(const char *key, const char *message, const char *digest)
177 {
178 std::string decodedKey;
179 StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
180
181 MAC mac((const byte *)decodedKey.data(), decodedKey.size());
182 KnownAnswerTest(mac, message, digest);
183 }
184
185 template <class SCHEME>
SignatureKnownAnswerTest(const char * key,const char * message,const char * signature)186 void SignatureKnownAnswerTest(const char *key, const char *message, const char *signature)
187 {
188 typename SCHEME::Signer signer(StringSource(key, true, new HexDecoder).Ref());
189 typename SCHEME::Verifier verifier(signer);
190
191 RandomPool rng;
192 EqualityComparisonFilter comparison;
193
194 StringSource(message, true, new SignerFilter(rng, signer, new ChannelSwitch(comparison, "0")));
195 StringSource(signature, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
196
197 comparison.ChannelMessageSeriesEnd("0");
198 comparison.ChannelMessageSeriesEnd("1");
199
200 VerifierFilter verifierFilter(verifier, NULL, VerifierFilter::SIGNATURE_AT_BEGIN | VerifierFilter::THROW_EXCEPTION);
201 StringSource(signature, true, new HexDecoder(new Redirector(verifierFilter, Redirector::DATA_ONLY)));
202 StringSource(message, true, new Redirector(verifierFilter));
203 }
204
EncryptionPairwiseConsistencyTest(const PK_Encryptor & encryptor,const PK_Decryptor & decryptor)205 void EncryptionPairwiseConsistencyTest(const PK_Encryptor &encryptor, const PK_Decryptor &decryptor)
206 {
207 try
208 {
209 RandomPool rng;
210 const char *testMessage ="test message";
211 std::string ciphertext, decrypted;
212
213 StringSource(
214 testMessage,
215 true,
216 new PK_EncryptorFilter(
217 rng,
218 encryptor,
219 new StringSink(ciphertext)));
220
221 if (ciphertext == testMessage)
222 throw 0;
223
224 StringSource(
225 ciphertext,
226 true,
227 new PK_DecryptorFilter(
228 rng,
229 decryptor,
230 new StringSink(decrypted)));
231
232 if (decrypted != testMessage)
233 throw 0;
234 }
235 catch (...)
236 {
237 throw SelfTestFailure(encryptor.AlgorithmName() + ": pairwise consistency test failed");
238 }
239 }
240
SignaturePairwiseConsistencyTest(const PK_Signer & signer,const PK_Verifier & verifier)241 void SignaturePairwiseConsistencyTest(const PK_Signer &signer, const PK_Verifier &verifier)
242 {
243 try
244 {
245 RandomPool rng;
246
247 StringSource(
248 "test message",
249 true,
250 new SignerFilter(
251 rng,
252 signer,
253 new VerifierFilter(verifier, NULL, VerifierFilter::THROW_EXCEPTION),
254 true));
255 }
256 catch (...)
257 {
258 throw SelfTestFailure(signer.AlgorithmName() + ": pairwise consistency test failed");
259 }
260 }
261
262 template <class SCHEME>
SignaturePairwiseConsistencyTest(const char * key)263 void SignaturePairwiseConsistencyTest(const char *key)
264 {
265 typename SCHEME::Signer signer(StringSource(key, true, new HexDecoder).Ref());
266 typename SCHEME::Verifier verifier(signer);
267
268 SignaturePairwiseConsistencyTest(signer, verifier);
269 }
270
NewIntegrityCheckingMAC()271 MessageAuthenticationCode * NewIntegrityCheckingMAC()
272 {
273 byte key[] = {0x47, 0x1E, 0x33, 0x96, 0x65, 0xB1, 0x6A, 0xED, 0x0B, 0xF8, 0x6B, 0xFD, 0x01, 0x65, 0x05, 0xCC};
274 return new HMAC<SHA1>(key, sizeof(key));
275 }
276
IntegrityCheckModule(const char * moduleFilename,const byte * expectedModuleMac,SecByteBlock * pActualMac,unsigned long * pMacFileLocation)277 bool IntegrityCheckModule(const char *moduleFilename, const byte *expectedModuleMac, SecByteBlock *pActualMac, unsigned long *pMacFileLocation)
278 {
279 member_ptr<MessageAuthenticationCode> mac(NewIntegrityCheckingMAC());
280 unsigned int macSize = mac->DigestSize();
281
282 SecByteBlock tempMac;
283 SecByteBlock &actualMac = pActualMac ? *pActualMac : tempMac;
284 actualMac.resize(macSize);
285
286 unsigned long tempLocation = 0;
287 unsigned long &macFileLocation = pMacFileLocation ? *pMacFileLocation : tempLocation;
288 macFileLocation = 0;
289
290 MeterFilter verifier(new HashFilter(*mac, new ArraySink(actualMac, actualMac.size())));
291 // MeterFilter verifier(new FileSink("c:\\dt.tmp"));
292 std::ifstream moduleStream;
293
294 #ifdef CRYPTOPP_WIN32_AVAILABLE
295 HMODULE h = NULL;
296 {
297 const size_t FIPS_MODULE_MAX_PATH = 2*MAX_PATH;
298 char moduleFilenameBuf[FIPS_MODULE_MAX_PATH] = "";
299 if (moduleFilename == NULL)
300 {
301 #if (_MSC_VER >= 1400 && !defined(_STLPORT_VERSION)) // ifstream doesn't support wide filename on other compilers
302 wchar_t wideModuleFilename[FIPS_MODULE_MAX_PATH];
303 if (GetModuleFileNameW(s_hModule, wideModuleFilename, FIPS_MODULE_MAX_PATH) > 0)
304 {
305 moduleStream.open(wideModuleFilename, std::ios::in | std::ios::binary);
306 h = GetModuleHandleW(wideModuleFilename);
307 }
308 else
309 #endif
310 {
311 GetModuleFileNameA(s_hModule, moduleFilenameBuf, FIPS_MODULE_MAX_PATH);
312 moduleFilename = moduleFilenameBuf;
313 }
314 }
315 #endif
316 if (moduleFilename != NULL)
317 {
318 moduleStream.open(moduleFilename, std::ios::in | std::ios::binary);
319 #ifdef CRYPTOPP_WIN32_AVAILABLE
320 h = GetModuleHandleA(moduleFilename);
321 moduleFilename = NULL;
322 }
323 #endif
324 }
325
326 #ifdef CRYPTOPP_WIN32_AVAILABLE
327 if (h == g_BaseAddressOfMAC)
328 {
329 std::ostringstream oss;
330 oss << "Crypto++ DLL loaded at base address 0x" << std::hex << h << ".\n";
331 OutputDebugString(oss.str().c_str());
332 }
333 else
334 {
335 std::ostringstream oss;
336 oss << "Crypto++ DLL integrity check may fail. Expected module base address is 0x";
337 oss << std::hex << g_BaseAddressOfMAC << ", but module loaded at 0x" << h << ".\n";
338 OutputDebugString(oss.str().c_str());
339 }
340 #endif
341
342 if (!moduleStream)
343 {
344 #ifdef CRYPTOPP_WIN32_AVAILABLE
345 OutputDebugString("Crypto++ DLL integrity check failed. Cannot open file for reading.");
346 #endif
347 return false;
348 }
349 FileStore file(moduleStream);
350
351 #ifdef CRYPTOPP_WIN32_AVAILABLE
352 // try to hash from memory first
353 const byte *memBase = (const byte *)h;
354 const IMAGE_DOS_HEADER *ph = (IMAGE_DOS_HEADER *)memBase;
355 const IMAGE_NT_HEADERS *phnt = (IMAGE_NT_HEADERS *)(memBase + ph->e_lfanew);
356 const IMAGE_SECTION_HEADER *phs = IMAGE_FIRST_SECTION(phnt);
357 DWORD nSections = phnt->FileHeader.NumberOfSections;
358 size_t currentFilePos = 0;
359
360 size_t checksumPos = (byte *)&phnt->OptionalHeader.CheckSum - memBase;
361 size_t checksumSize = sizeof(phnt->OptionalHeader.CheckSum);
362 size_t certificateTableDirectoryPos = (byte *)&phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY] - memBase;
363 size_t certificateTableDirectorySize = sizeof(phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
364 size_t certificateTablePos = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress;
365 size_t certificateTableSize = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size;
366
367 verifier.AddRangeToSkip(0, checksumPos, checksumSize);
368 verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
369 verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);
370
371 while (nSections--)
372 {
373 switch (phs->Characteristics)
374 {
375 default:
376 break;
377 case IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
378 case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ:
379 unsigned int sectionSize = STDMIN(phs->SizeOfRawData, phs->Misc.VirtualSize);
380 const byte *sectionMemStart = memBase + phs->VirtualAddress;
381 unsigned int sectionFileStart = phs->PointerToRawData;
382 size_t subSectionStart = 0, nextSubSectionStart;
383
384 do
385 {
386 const byte *subSectionMemStart = sectionMemStart + subSectionStart;
387 size_t subSectionFileStart = sectionFileStart + subSectionStart;
388 size_t subSectionSize = sectionSize - subSectionStart;
389 nextSubSectionStart = 0;
390
391 unsigned int entriesToReadFromDisk[] = {IMAGE_DIRECTORY_ENTRY_IMPORT, IMAGE_DIRECTORY_ENTRY_IAT};
392 for (unsigned int i=0; i<sizeof(entriesToReadFromDisk)/sizeof(entriesToReadFromDisk[0]); i++)
393 {
394 const IMAGE_DATA_DIRECTORY &entry = phnt->OptionalHeader.DataDirectory[entriesToReadFromDisk[i]];
395 const byte *entryMemStart = memBase + entry.VirtualAddress;
396 if (subSectionMemStart <= entryMemStart && entryMemStart < subSectionMemStart + subSectionSize)
397 {
398 subSectionSize = entryMemStart - subSectionMemStart;
399 nextSubSectionStart = entryMemStart - sectionMemStart + entry.Size;
400 }
401 }
402
403 #if defined(_MSC_VER) && _MSC_VER >= 1400
404 // first byte of _CRT_DEBUGGER_HOOK gets modified in memory by the debugger invisibly, so read it from file
405 if (IsDebuggerPresent())
406 {
407 if (subSectionMemStart <= (byte *)&_CRT_DEBUGGER_HOOK && (byte *)&_CRT_DEBUGGER_HOOK < subSectionMemStart + subSectionSize)
408 {
409 subSectionSize = (byte *)&_CRT_DEBUGGER_HOOK - subSectionMemStart;
410 nextSubSectionStart = (byte *)&_CRT_DEBUGGER_HOOK - sectionMemStart + 1;
411 }
412 }
413 #endif
414
415 if (subSectionMemStart <= expectedModuleMac && expectedModuleMac < subSectionMemStart + subSectionSize)
416 {
417 // found stored MAC
418 macFileLocation = (unsigned long)(subSectionFileStart + (expectedModuleMac - subSectionMemStart));
419 verifier.AddRangeToSkip(0, macFileLocation, macSize);
420 }
421
422 file.TransferTo(verifier, subSectionFileStart - currentFilePos);
423 verifier.Put(subSectionMemStart, subSectionSize);
424 file.Skip(subSectionSize);
425 currentFilePos = subSectionFileStart + subSectionSize;
426 subSectionStart = nextSubSectionStart;
427 } while (nextSubSectionStart != 0);
428 }
429 phs++;
430 }
431 #endif
432 file.TransferAllTo(verifier);
433
434 #ifdef CRYPTOPP_WIN32_AVAILABLE
435 // if that fails (could be caused by debug breakpoints or DLL base relocation modifying image in memory),
436 // hash from disk instead
437 if (!VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
438 {
439 OutputDebugString("Crypto++ DLL in-memory integrity check failed. This may be caused by debug breakpoints or DLL relocation.\n");
440 moduleStream.clear();
441 moduleStream.seekg(0);
442 verifier.Initialize(MakeParameters(Name::OutputBuffer(), ByteArrayParameter(actualMac, (unsigned int)actualMac.size())));
443 // verifier.Initialize(MakeParameters(Name::OutputFileName(), (const char *)"c:\\dt2.tmp"));
444 verifier.AddRangeToSkip(0, checksumPos, checksumSize);
445 verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
446 verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);
447 verifier.AddRangeToSkip(0, macFileLocation, macSize);
448 FileStore(moduleStream).TransferAllTo(verifier);
449 }
450 #endif
451
452 if (VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
453 return true;
454
455 #ifdef CRYPTOPP_WIN32_AVAILABLE
456 std::string hexMac;
457 HexEncoder(new StringSink(hexMac)).PutMessageEnd(actualMac, actualMac.size());
458 OutputDebugString((("Crypto++ DLL integrity check failed. Actual MAC is: " + hexMac) + ".\n").c_str());
459 #endif
460 return false;
461 }
462
DoPowerUpSelfTest(const char * moduleFilename,const byte * expectedModuleMac)463 void DoPowerUpSelfTest(const char *moduleFilename, const byte *expectedModuleMac)
464 {
465 g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_NOT_DONE;
466 SetPowerUpSelfTestInProgressOnThisThread(true);
467
468 try
469 {
470 if (FIPS_140_2_ComplianceEnabled() || expectedModuleMac != NULL)
471 {
472 if (!IntegrityCheckModule(moduleFilename, expectedModuleMac, &g_actualMac, &g_macFileLocation))
473 throw 0; // throw here so we break in the debugger, this will be caught right away
474 }
475
476 // algorithm tests
477
478 X917RNG_KnownAnswerTest<AES>(
479 "2b7e151628aed2a6abf7158809cf4f3c", // key
480 "000102030405060708090a0b0c0d0e0f", // seed
481 "00000000000000000000000000000001", // time vector
482 "D176EDD27493B0395F4D10546232B0693DC7061C03C3A554F09CECF6F6B46D945A"); // output
483
484 SymmetricEncryptionKnownAnswerTest<DES_EDE3>(
485 "385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E",
486 "C141B5FCCD28DC8A",
487 "6E1BD7C6120947A464A6AAB293A0F89A563D8D40D3461B68",
488 "64EAAD4ACBB9CEAD6C7615E7C7E4792FE587D91F20C7D2F4",
489 "6235A461AFD312973E3B4F7AA7D23E34E03371F8E8C376C9",
490 "E26BA806A59B0330DE40CA38E77A3E494BE2B212F6DD624B",
491 "E26BA806A59B03307DE2BCC25A08BA40A8BA335F5D604C62",
492 "E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371");
493
494 SymmetricEncryptionKnownAnswerTest<SKIPJACK>(
495 "1555E5531C3A169B2D65",
496 "6EC9795701F49864",
497 "00AFA48E9621E52E8CBDA312660184EDDB1F33D9DACDA8DA",
498 "DBEC73562EFCAEB56204EB8AE9557EBF77473FBB52D17CD1",
499 "0C7B0B74E21F99B8F2C8DF37879F6C044967F42A796DCA8B",
500 "79FDDA9724E36CC2E023E9A5C717A8A8A7FDA465CADCBF63",
501 "79FDDA9724E36CC26CACBD83C1ABC06EAF5B249BE5B1E040",
502 "79FDDA9724E36CC211B0AEC607B95A96BCDA318440B82F49");
503
504 SymmetricEncryptionKnownAnswerTest<AES>(
505 "2b7e151628aed2a6abf7158809cf4f3c",
506 "000102030405060708090a0b0c0d0e0f",
507 "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710", // plaintext
508 "3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4", // ecb
509 "7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7", // cbc
510 "3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6", // cfb
511 "3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e", // ofb
512 NULL);
513
514 SymmetricEncryptionKnownAnswerTest<AES>(
515 "2b7e151628aed2a6abf7158809cf4f3c",
516 "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
517 "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
518 NULL,
519 NULL,
520 NULL,
521 NULL,
522 "874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab1e031dda2fbe03d1792170a0f3009cee"); // ctr
523
524
525 SecureHashKnownAnswerTest<SHA1>(
526 "abc",
527 "A9993E364706816ABA3E25717850C26C9CD0D89D");
528
529 SecureHashKnownAnswerTest<SHA224>(
530 "abc",
531 "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7");
532
533 SecureHashKnownAnswerTest<SHA256>(
534 "abc",
535 "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
536
537 SecureHashKnownAnswerTest<SHA384>(
538 "abc",
539 "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7");
540
541 SecureHashKnownAnswerTest<SHA512>(
542 "abc",
543 "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");
544
545 MAC_KnownAnswerTest<HMAC<SHA1> >(
546 "303132333435363738393a3b3c3d3e3f40414243",
547 "Sample #2",
548 "0922d3405faa3d194f82a45830737d5cc6c75d24");
549
550 const char *keyRSA1 =
551 "30820150020100300d06092a864886f70d01010105000482013a3082013602010002400a66791dc6988168de7ab77419bb7fb0"
552 "c001c62710270075142942e19a8d8c51d053b3e3782a1de5dc5af4ebe99468170114a1dfe67cdc9a9af55d655620bbab0203010001"
553 "02400123c5b61ba36edb1d3679904199a89ea80c09b9122e1400c09adcf7784676d01d23356a7d44d6bd8bd50e94bfc723fa"
554 "87d8862b75177691c11d757692df8881022033d48445c859e52340de704bcdda065fbb4058d740bd1d67d29e9c146c11cf61"
555 "0220335e8408866b0fd38dc7002d3f972c67389a65d5d8306566d5c4f2a5aa52628b0220045ec90071525325d3d46db79695e9af"
556 "acc4523964360e02b119baa366316241022015eb327360c7b60d12e5e2d16bdcd97981d17fba6b70db13b20b436e24eada590220"
557 "2ca6366d72781dfa24d34a9a24cbc2ae927a9958af426563ff63fb11658a461d";
558
559 const char *keyRSA2 =
560 "30820273020100300D06092A864886F70D01010105000482025D3082025902010002818100D40AF9"
561 "A2B713034249E5780056D70FC7DE75D76E44565AA6A6B8ED9646F3C19F9E254D72D7DE6E49DB2264"
562 "0C1D05AB9E2A5F901D8F3FE1F7AE02CEE2ECCE54A40ABAE55A004692752E70725AEEE7CDEA67628A"
563 "82A9239B4AB660C2BC56D9F01E90CBAAB9BF0FC8E17173CEFC5709A29391A7DDF3E0B758691AAF30"
564 "725B292F4F020111027F18C0BA087D082C45D75D3594E0767E4820818EB35612B80CEAB8C880ACA5"
565 "44B6876DFFEF85A576C0D45B551AFAA1FD63209CD745DF75C5A0F0B580296EA466CD0338207E4752"
566 "FF4E7DB724D8AE18CE5CF4153BB94C27869FBB50E64F02546E4B02997A0B8623E64017CC770759C6"
567 "695DB649EEFD829D688D441BCC4E7348F1024100EF86DD7AF3F32CDE8A9F6564E43A559A0C9F8BAD"
568 "36CC25330548B347AC158A345631FA90F7B873C36EFFAE2F7823227A3F580B5DD18304D5932751E7"
569 "43E9234F024100E2A039854B55688740E32A51DF4AF88613D91A371CF8DDD95D780A89D7CF2119A9"
570 "54F1AC0F3DCDB2F6959926E6D9D37D8BC07A4C634DE6F16315BD5F0DAC340102407ECEEDB9903572"
571 "1B76909F174BA6698DCA72953D957B22C0A871C8531EDE3A1BB52984A719BC010D1CA57A555DB83F"
572 "6DE54CBAB932AEC652F38D497A6F3F30CF024100854F30E4FF232E6DADB2CD99926855F484255AB7"
573 "01FBCDCB27EC426F33A7046972AA700ADBCA008763DF87440F52F4E070531AC385B55AAC1C2AE7DD"
574 "8F9278F1024100C313F4AF9E4A9DE1253C21080CE524251560C111550772FD08690F13FBE658342E"
575 "BD2D41C9DCB12374E871B1839E26CAE252E1AE3DAAD5F1EE1F42B4D0EE7581";
576
577 SignatureKnownAnswerTest<RSASS<PKCS1v15, SHA1> >(
578 keyRSA1,
579 "Everyone gets Friday off.",
580 "0610761F95FFD1B8F29DA34212947EC2AA0E358866A722F03CC3C41487ADC604A48FF54F5C6BEDB9FB7BD59F82D6E55D8F3174BA361B2214B2D74E8825E04E81");
581
582 SignatureKnownAnswerTest<RSASS_ISO<SHA1> >(
583 keyRSA2,
584 "test",
585 "32F6BA41C8930DE71EE67F2627172CC539EDE04267FDE03AC295E3C50311F26C3B275D3AF513AC96"
586 "8EE493BAB7DA3A754661D1A7C4A0D1A2B7EE8B313AACD8CB8BFBC5C15EFB0EF15C86A9334A1E87AD"
587 "291EB961B5CA0E84930429B28780816AA94F96FC2367B71E2D2E4866FA966795B147F00600E5207E"
588 "2F189C883B37477C");
589
590 SignaturePairwiseConsistencyTest<DSA>(
591 "3082014A0201003082012B06072A8648CE3804013082011E02818100F468699A6F6EBCC0120D3B34C8E007F125EC7D81F763B8D0F33869AE3BD6B9F2ECCC7DF34DF84C0307449E9B85D30D57194BCCEB310F48141914DD13A077AAF9B624A6CBE666BBA1D7EBEA95B5BA6F54417FD5D4E4220C601E071D316A24EA814E8B0122DBF47EE8AEEFD319EBB01DD95683F10DBB4FEB023F8262A07EAEB7FD02150082AD4E034DA6EEACDFDAE68C36F2BAD614F9E53B02818071AAF73361A26081529F7D84078ADAFCA48E031DB54AD57FB1A833ADBD8672328AABAA0C756247998D7A5B10DACA359D231332CE8120B483A784FE07D46EEBFF0D7D374A10691F78653E6DC29E27CCB1B174923960DFE5B959B919B2C3816C19251832AFD8E35D810E598F82877ABF7D40A041565168BD7F0E21E3FE2A8D8C1C0416021426EBA66E846E755169F84A1DA981D86502405DDF");
592
593 SignaturePairwiseConsistencyTest<ECDSA<EC2N, SHA1> >(
594 "302D020100301006072A8648CE3D020106052B8104000404163014020101040F0070337065E1E196980A9D00E37211");
595
596 SignaturePairwiseConsistencyTest<ECDSA<ECP, SHA1> >(
597 "3039020100301306072A8648CE3D020106082A8648CE3D030101041F301D02010104182BB8A13C8B867010BD9471D9E81FDB01ABD0538C64D6249A");
598
599 SignaturePairwiseConsistencyTest<RSASS<PSS, SHA1> >(keyRSA1);
600 }
601 catch (...)
602 {
603 g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_FAILED;
604 goto done;
605 }
606
607 g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_PASSED;
608
609 done:
610 SetPowerUpSelfTestInProgressOnThisThread(false);
611 return;
612 }
613
614 #ifdef CRYPTOPP_WIN32_AVAILABLE
615
DoDllPowerUpSelfTest()616 void DoDllPowerUpSelfTest()
617 {
618 CryptoPP::DoPowerUpSelfTest(NULL, s_moduleMac);
619 }
620
621 #else
622
DoDllPowerUpSelfTest()623 void DoDllPowerUpSelfTest()
624 {
625 throw NotImplemented("DoDllPowerUpSelfTest() only available on Windows");
626 }
627
628 #endif // #ifdef CRYPTOPP_WIN32_AVAILABLE
629
630 NAMESPACE_END
631
632 #ifdef CRYPTOPP_WIN32_AVAILABLE
633
634 // DllMain needs to be in the global namespace
DllMain(HANDLE hModule,DWORD dwReason,LPVOID)635 BOOL APIENTRY DllMain(HANDLE hModule,
636 DWORD dwReason,
637 LPVOID /*lpReserved*/)
638 {
639 if (dwReason == DLL_PROCESS_ATTACH)
640 {
641 CryptoPP::s_hModule = (HMODULE)hModule;
642 CryptoPP::DoDllPowerUpSelfTest();
643 }
644 return TRUE;
645 }
646
647 #endif // #ifdef CRYPTOPP_WIN32_AVAILABLE
648
649 #endif // #ifndef CRYPTOPP_IMPORTS
650