00001
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
#include <windows.h>
00012
#endif
00013
00014 NAMESPACE_BEGIN(CryptoPP)
00015
00016 extern PowerUpSelfTestStatus g_powerUpSelfTestStatus;
00017
SecByteBlock g_actualMac;
00018
unsigned long g_macFileLocation = 0;
00019
00020 const byte * CRYPTOPP_API GetActualMacAndLocation(
unsigned int &macSize,
unsigned int &fileLocation)
00021 {
00022 macSize = g_actualMac.
size();
00023 fileLocation = g_macFileLocation;
00024
return g_actualMac;
00025 }
00026
00027
void KnownAnswerTest(
RandomNumberGenerator &rng,
const char *output)
00028 {
00029
EqualityComparisonFilter comparison;
00030
00031
RandomNumberStore(rng, strlen(output)/2).TransferAllTo(comparison,
"0");
00032
StringSource(output,
true,
new HexDecoder(
new ChannelSwitch(comparison,
"1")));
00033
00034 comparison.
ChannelMessageSeriesEnd(
"0");
00035 comparison.
ChannelMessageSeriesEnd(
"1");
00036 }
00037
00038
template <
class CIPHER>
00039
void X917RNG_KnownAnswerTest(
00040
const char *key,
00041
const char *seed,
00042
const char *output,
00043
unsigned int deterministicTimeVector,
00044 CIPHER *dummy = NULL)
00045 {
00046
#ifdef OS_RNG_AVAILABLE
00047
std::string decodedKey, decodedSeed;
00048
StringSource(key,
true,
new HexDecoder(
new StringSink(decodedKey)));
00049
StringSource(seed,
true,
new HexDecoder(
new StringSink(decodedSeed)));
00050
00051
AutoSeededX917RNG<CIPHER> rng;
00052 rng.
Reseed((
const byte *)decodedKey.data(), decodedKey.size(), (
const byte *)decodedSeed.data(), deterministicTimeVector);
00053 KnownAnswerTest(rng, output);
00054
#else
00055
throw 0;
00056
#endif
00057
}
00058
00059
void KnownAnswerTest(
StreamTransformation &encryption,
StreamTransformation &decryption,
const char *plaintext,
const char *ciphertext)
00060 {
00061
EqualityComparisonFilter comparison;
00062
00063
StringSource(plaintext,
true,
new HexDecoder(
new StreamTransformationFilter(encryption,
new ChannelSwitch(comparison,
"0"), StreamTransformationFilter::NO_PADDING)));
00064
StringSource(ciphertext,
true,
new HexDecoder(
new ChannelSwitch(comparison,
"1")));
00065
00066
StringSource(ciphertext,
true,
new HexDecoder(
new StreamTransformationFilter(decryption,
new ChannelSwitch(comparison,
"0"), StreamTransformationFilter::NO_PADDING)));
00067
StringSource(plaintext,
true,
new HexDecoder(
new ChannelSwitch(comparison,
"1")));
00068
00069 comparison.
ChannelMessageSeriesEnd(
"0");
00070 comparison.
ChannelMessageSeriesEnd(
"1");
00071 }
00072
00073
template <
class CIPHER>
00074
void SymmetricEncryptionKnownAnswerTest(
00075
const char *key,
00076
const char *hexIV,
00077
const char *plaintext,
00078
const char *ecb,
00079
const char *cbc,
00080
const char *cfb,
00081
const char *ofb,
00082
const char *ctr,
00083 CIPHER *dummy = NULL)
00084 {
00085 std::string decodedKey;
00086
StringSource(key,
true,
new HexDecoder(
new StringSink(decodedKey)));
00087
00088
typename CIPHER::Encryption encryption((
const byte *)decodedKey.data(), decodedKey.size());
00089
typename CIPHER::Decryption decryption((
const byte *)decodedKey.data(), decodedKey.size());
00090
00091
SecByteBlock iv(encryption.BlockSize());
00092
StringSource(hexIV,
true,
new HexDecoder(
new ArraySink(iv, iv.size())));
00093
00094
if (ecb)
00095 KnownAnswerTest(
ECB_Mode_ExternalCipher::Encryption(encryption).Ref(),
ECB_Mode_ExternalCipher::Decryption(decryption).Ref(), plaintext, ecb);
00096
if (cbc)
00097 KnownAnswerTest(
CBC_Mode_ExternalCipher::Encryption(encryption, iv).Ref(),
CBC_Mode_ExternalCipher::Decryption(decryption, iv).Ref(), plaintext, cbc);
00098
if (cfb)
00099 KnownAnswerTest(
CFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(),
CFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, cfb);
00100
if (ofb)
00101 KnownAnswerTest(
OFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(),
OFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ofb);
00102
if (ctr)
00103 KnownAnswerTest(
CTR_Mode_ExternalCipher::Encryption(encryption, iv).Ref(),
CTR_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ctr);
00104 }
00105
00106
void KnownAnswerTest(
HashTransformation &hash,
const char *message,
const char *digest)
00107 {
00108
EqualityComparisonFilter comparison;
00109
StringSource(digest,
true,
new HexDecoder(
new ChannelSwitch(comparison,
"1")));
00110
StringSource(message,
true,
new HashFilter(hash,
new ChannelSwitch(comparison,
"0")));
00111
00112 comparison.
ChannelMessageSeriesEnd(
"0");
00113 comparison.
ChannelMessageSeriesEnd(
"1");
00114 }
00115
00116
template <
class HASH>
00117
void SecureHashKnownAnswerTest(
const char *message,
const char *digest, HASH *dummy = NULL)
00118 {
00119 HASH hash;
00120 KnownAnswerTest(hash, message, digest);
00121 }
00122
00123
template <
class MAC>
00124
void MAC_KnownAnswerTest(
const char *key,
const char *message,
const char *digest, MAC *dummy = NULL)
00125 {
00126 std::string decodedKey;
00127
StringSource(key,
true,
new HexDecoder(
new StringSink(decodedKey)));
00128
00129 MAC mac((
const byte *)decodedKey.data(), decodedKey.size());
00130 KnownAnswerTest(mac, message, digest);
00131 }
00132
00133
template <
class SCHEME>
00134
void SignatureKnownAnswerTest(
const char *key,
const char *message,
const char *signature, SCHEME *dummy = NULL)
00135 {
00136
#ifdef OS_RNG_AVAILABLE
00137
AutoSeededX917RNG<DES_EDE3> rng;
00138
#else
00139
RandomNumberGenerator &rng = NullRNG();
00140
#endif
00141
00142
typename SCHEME::Signer signer(
StringSource(key,
true,
new HexDecoder).Ref());
00143
typename SCHEME::Verifier verifier(signer);
00144
00145
EqualityComparisonFilter comparison;
00146
00147
StringSource(message,
true,
new SignerFilter(rng, signer,
new ChannelSwitch(comparison,
"0")));
00148
StringSource(signature,
true,
new HexDecoder(
new ChannelSwitch(comparison,
"1")));
00149
00150 comparison.
ChannelMessageSeriesEnd(
"0");
00151 comparison.
ChannelMessageSeriesEnd(
"1");
00152
00153
VerifierFilter verifierFilter(verifier, NULL, VerifierFilter::SIGNATURE_AT_BEGIN | VerifierFilter::THROW_EXCEPTION);
00154
StringSource(signature,
true,
new HexDecoder(
new Redirector(verifierFilter, Redirector::DATA_ONLY)));
00155
StringSource(message,
true,
new Redirector(verifierFilter));
00156 }
00157
00158
void EncryptionPairwiseConsistencyTest(
const PK_Encryptor &encryptor,
const PK_Decryptor &decryptor)
00159 {
00160
try
00161 {
00162
#ifdef OS_RNG_AVAILABLE
00163
AutoSeededX917RNG<DES_EDE3> rng;
00164
#else
00165
RandomNumberGenerator &rng = NullRNG();
00166
#endif
00167
const char *testMessage =
"test message";
00168 std::string ciphertext, decrypted;
00169
00170
StringSource(
00171 testMessage,
00172
true,
00173
new PK_EncryptorFilter(
00174 rng,
00175 encryptor,
00176
new StringSink(ciphertext)));
00177
00178
if (ciphertext == testMessage)
00179
throw 0;
00180
00181
StringSource(
00182 ciphertext,
00183
true,
00184
new PK_DecryptorFilter(
00185 rng,
00186 decryptor,
00187
new StringSink(decrypted)));
00188
00189
if (decrypted != testMessage)
00190
throw 0;
00191 }
00192
catch (...)
00193 {
00194
throw SelfTestFailure(encryptor.
AlgorithmName() +
": pairwise consistency test failed");
00195 }
00196 }
00197
00198
void SignaturePairwiseConsistencyTest(
const PK_Signer &signer,
const PK_Verifier &verifier)
00199 {
00200
try
00201 {
00202
#ifdef OS_RNG_AVAILABLE
00203
AutoSeededX917RNG<DES_EDE3> rng;
00204
#else
00205
RandomNumberGenerator &rng = NullRNG();
00206
#endif
00207
00208
StringSource(
00209
"test message",
00210
true,
00211
new SignerFilter(
00212 rng,
00213 signer,
00214
new VerifierFilter(verifier, NULL, VerifierFilter::THROW_EXCEPTION),
00215
true));
00216 }
00217
catch (...)
00218 {
00219
throw SelfTestFailure(signer.
AlgorithmName() +
": pairwise consistency test failed");
00220 }
00221 }
00222
00223
template <
class SCHEME>
00224
void SignaturePairwiseConsistencyTest(
const char *key, SCHEME *dummy = NULL)
00225 {
00226
typename SCHEME::Signer signer(
StringSource(key,
true,
new HexDecoder).Ref());
00227
typename SCHEME::Verifier verifier(signer);
00228
00229 SignaturePairwiseConsistencyTest(signer, verifier);
00230 }
00231
00232
MessageAuthenticationCode * NewIntegrityCheckingMAC()
00233 {
00234 byte key[] = {0x47, 0x1E, 0x33, 0x96, 0x65, 0xB1, 0x6A, 0xED, 0x0B, 0xF8, 0x6B, 0xFD, 0x01, 0x65, 0x05, 0xCC};
00235
return new HMAC<SHA1>(key,
sizeof(key));
00236 }
00237
00238
bool IntegrityCheckModule(
const char *moduleFilename,
const byte *expectedModuleMac,
SecByteBlock *pActualMac,
unsigned long *pMacFileLocation)
00239 {
00240 std::auto_ptr<MessageAuthenticationCode> mac(NewIntegrityCheckingMAC());
00241
unsigned int macSize = mac->DigestSize();
00242
00243
SecByteBlock tempMac;
00244
SecByteBlock &actualMac = pActualMac ? *pActualMac : tempMac;
00245 actualMac.
resize(macSize);
00246
00247
unsigned long tempLocation;
00248
unsigned long &macFileLocation = pMacFileLocation ? *pMacFileLocation : tempLocation;
00249 macFileLocation = 0;
00250
00251
HashFilter verifier(*mac,
new ArraySink(actualMac, actualMac.size()));
00252
00253
FileStore file(moduleFilename);
00254
00255
#ifdef CRYPTOPP_WIN32_AVAILABLE
00256
00257 HMODULE h = GetModuleHandle(moduleFilename);
00258
const byte *memBase = (
const byte *)h;
00259 IMAGE_DOS_HEADER *ph = (IMAGE_DOS_HEADER *)h;
00260 IMAGE_NT_HEADERS *phnt = (IMAGE_NT_HEADERS *)((byte *)h + ph->e_lfanew);
00261 IMAGE_SECTION_HEADER *phs = IMAGE_FIRST_SECTION(phnt);
00262 DWORD nSections = phnt->FileHeader.NumberOfSections;
00263 DWORD currentFilePos = 0;
00264
00265
while (nSections--)
00266 {
00267
switch (phs->Characteristics)
00268 {
00269
default:
00270
break;
00271
case IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
00272
case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ:
00273
unsigned int sectionSize = STDMIN(phs->SizeOfRawData, phs->Misc.VirtualSize);
00274
const byte *sectionMemStart = memBase + phs->VirtualAddress;
00275
unsigned int sectionFileStart = phs->PointerToRawData;
00276
unsigned int subSectionStart = 0, nextSubSectionStart;
00277
00278
do
00279 {
00280
const byte *subSectionMemStart = sectionMemStart + subSectionStart;
00281
unsigned int subSectionFileStart = sectionFileStart + subSectionStart;
00282
unsigned int subSectionSize = sectionSize - subSectionStart;
00283 nextSubSectionStart = 0;
00284
00285
unsigned int entriesToReadFromDisk[] = {IMAGE_DIRECTORY_ENTRY_IMPORT, IMAGE_DIRECTORY_ENTRY_IAT};
00286
for (
unsigned int i=0; i<
sizeof(entriesToReadFromDisk)/
sizeof(entriesToReadFromDisk[0]); i++)
00287 {
00288
const IMAGE_DATA_DIRECTORY &entry = phnt->OptionalHeader.DataDirectory[entriesToReadFromDisk[i]];
00289
const byte *entryMemStart = memBase + entry.VirtualAddress;
00290
if (subSectionMemStart <= entryMemStart && entryMemStart < subSectionMemStart + subSectionSize)
00291 {
00292 subSectionSize = entryMemStart - subSectionMemStart;
00293 nextSubSectionStart = entryMemStart - sectionMemStart + entry.Size;
00294 }
00295 }
00296
00297 file.TransferTo(verifier, subSectionFileStart - currentFilePos);
00298
if (subSectionMemStart <= expectedModuleMac && expectedModuleMac < subSectionMemStart + subSectionSize)
00299 {
00300
00301 verifier.Put(subSectionMemStart, expectedModuleMac - subSectionMemStart);
00302 verifier.Put(expectedModuleMac + macSize, subSectionSize - macSize - (expectedModuleMac - subSectionMemStart));
00303 macFileLocation = subSectionFileStart + (expectedModuleMac - subSectionMemStart);
00304 }
00305
else
00306 verifier.Put(subSectionMemStart, subSectionSize);
00307 file.Skip(subSectionSize);
00308 currentFilePos = subSectionFileStart + subSectionSize;
00309 subSectionStart = nextSubSectionStart;
00310 }
while (nextSubSectionStart != 0);
00311 }
00312 phs++;
00313 }
00314
#endif
00315
file.TransferAllTo(verifier);
00316
00317
#ifdef CRYPTOPP_WIN32_AVAILABLE
00318
00319
00320
if (memcmp(expectedModuleMac, actualMac, macSize) != 0)
00321 {
00322 OutputDebugString(
"In memory integrity check failed. This may be caused by debug breakpoints or DLL relocation.\n");
00323 file.Initialize(MakeParameters(
"InputFileName", moduleFilename));
00324 verifier.Detach(
new ArraySink(actualMac, actualMac.size()));
00325
if (macFileLocation)
00326 {
00327 file.TransferTo(verifier, macFileLocation);
00328 file.Skip(macSize);
00329 }
00330 file.TransferAllTo(verifier);
00331 }
00332
#endif
00333
00334
if (memcmp(expectedModuleMac, actualMac, macSize) == 0)
00335
return true;
00336
00337
#ifdef CRYPTOPP_WIN32_AVAILABLE
00338
std::string hexMac;
00339
HexEncoder(
new StringSink(hexMac)).PutMessageEnd(actualMac, actualMac.
size());
00340 OutputDebugString((moduleFilename + (
" integrity check failed. Actual MAC is: " + hexMac) +
"\n").c_str());
00341
#endif
00342
return false;
00343 }
00344
00345
void DoPowerUpSelfTest(
const char *moduleFilename,
const byte *expectedModuleMac)
00346 {
00347 g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_NOT_DONE;
00348 SetPowerUpSelfTestInProgressOnThisThread(
true);
00349
00350
try
00351 {
00352
if (FIPS_140_2_ComplianceEnabled() || moduleFilename != NULL)
00353 {
00354
if (!IntegrityCheckModule(moduleFilename, expectedModuleMac, &g_actualMac, &g_macFileLocation))
00355
throw 0;
00356 }
00357
00358
00359
00360 X917RNG_KnownAnswerTest<DES_EDE3>(
00361
"48851090B4992453E83CDA86416534E53EA2FCE1A0B3A40C",
00362
"7D00BD0A79F6B0F5",
00363
"22B590B08B53363AEB89AD65F81A5B6FB83F326CE06BF35751E6C41B43B729C4",
00364 1489728269);
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376 SymmetricEncryptionKnownAnswerTest<DES_EDE3>(
00377
"385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E",
00378
"C141B5FCCD28DC8A",
00379
"6E1BD7C6120947A464A6AAB293A0F89A563D8D40D3461B68",
00380
"64EAAD4ACBB9CEAD6C7615E7C7E4792FE587D91F20C7D2F4",
00381
"6235A461AFD312973E3B4F7AA7D23E34E03371F8E8C376C9",
00382
"E26BA806A59B0330DE40CA38E77A3E494BE2B212F6DD624B",
00383
"E26BA806A59B03307DE2BCC25A08BA40A8BA335F5D604C62",
00384
"E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371");
00385
00386 SymmetricEncryptionKnownAnswerTest<SKIPJACK>(
00387
"1555E5531C3A169B2D65",
00388
"6EC9795701F49864",
00389
"00AFA48E9621E52E8CBDA312660184EDDB1F33D9DACDA8DA",
00390
"DBEC73562EFCAEB56204EB8AE9557EBF77473FBB52D17CD1",
00391
"0C7B0B74E21F99B8F2C8DF37879F6C044967F42A796DCA8B",
00392
"79FDDA9724E36CC2E023E9A5C717A8A8A7FDA465CADCBF63",
00393
"79FDDA9724E36CC26CACBD83C1ABC06EAF5B249BE5B1E040",
00394
"79FDDA9724E36CC211B0AEC607B95A96BCDA318440B82F49");
00395
00396 SymmetricEncryptionKnownAnswerTest<AES>(
00397
"2b7e151628aed2a6abf7158809cf4f3c",
00398
"000102030405060708090a0b0c0d0e0f",
00399
"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
00400
"3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4",
00401
"7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7",
00402
"3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6",
00403
"3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e",
00404 NULL);
00405
00406 SymmetricEncryptionKnownAnswerTest<AES>(
00407
"2b7e151628aed2a6abf7158809cf4f3c",
00408
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
00409
"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
00410 NULL,
00411 NULL,
00412 NULL,
00413 NULL,
00414
"874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab1e031dda2fbe03d1792170a0f3009cee");
00415
00416
00417 SecureHashKnownAnswerTest<SHA>(
00418
"abc",
00419
"A9993E364706816ABA3E25717850C26C9CD0D89D");
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433 MAC_KnownAnswerTest<HMAC<SHA> >(
00434
"303132333435363738393a3b3c3d3e3f40414243",
00435
"Sample #2",
00436
"0922d3405faa3d194f82a45830737d5cc6c75d24");
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453 SignatureKnownAnswerTest<RSASS<PKCS1v15, SHA> >(
00454
"30820150020100300d06092a864886f70d01010105000482013a3082013602010002400a66791dc6988168de7ab77419bb7fb0"
00455
"c001c62710270075142942e19a8d8c51d053b3e3782a1de5dc5af4ebe99468170114a1dfe67cdc9a9af55d655620bbab0203010001"
00456
"02400123c5b61ba36edb1d3679904199a89ea80c09b9122e1400c09adcf7784676d01d23356a7d44d6bd8bd50e94bfc723fa"
00457
"87d8862b75177691c11d757692df8881022033d48445c859e52340de704bcdda065fbb4058d740bd1d67d29e9c146c11cf61"
00458
"0220335e8408866b0fd38dc7002d3f972c67389a65d5d8306566d5c4f2a5aa52628b0220045ec90071525325d3d46db79695e9af"
00459
"acc4523964360e02b119baa366316241022015eb327360c7b60d12e5e2d16bdcd97981d17fba6b70db13b20b436e24eada590220"
00460
"2ca6366d72781dfa24d34a9a24cbc2ae927a9958af426563ff63fb11658a461d",
00461
"Everyone gets Friday off.",
00462
"0610761F95FFD1B8F29DA34212947EC2AA0E358866A722F03CC3C41487ADC604A48FF54F5C6BEDB9FB7BD59F82D6E55D8F3174BA361B2214B2D74E8825E04E81");
00463
00464 SignaturePairwiseConsistencyTest<DSA>(
00465
"3082014A0201003082012B06072A8648CE3804013082011E02818100F468699A6F6EBCC0120D3B34C8E007F125EC7D81F763B8D0F33869AE3BD6B9F2ECCC7DF34DF84C0307449E9B85D30D57194BCCEB310F48141914DD13A077AAF9B624A6CBE666BBA1D7EBEA95B5BA6F54417FD5D4E4220C601E071D316A24EA814E8B0122DBF47EE8AEEFD319EBB01DD95683F10DBB4FEB023F8262A07EAEB7FD02150082AD4E034DA6EEACDFDAE68C36F2BAD614F9E53B02818071AAF73361A26081529F7D84078ADAFCA48E031DB54AD57FB1A833ADBD8672328AABAA0C756247998D7A5B10DACA359D231332CE8120B483A784FE07D46EEBFF0D7D374A10691F78653E6DC29E27CCB1B174923960DFE5B959B919B2C3816C19251832AFD8E35D810E598F82877ABF7D40A041565168BD7F0E21E3FE2A8D8C1C0416021426EBA66E846E755169F84A1DA981D86502405DDF");
00466
00467 SignaturePairwiseConsistencyTest<ECDSA<EC2N, SHA> >(
00468
"302D020100301006072A8648CE3D020106052B8104000404163014020101040F0070337065E1E196980A9D00E37211");
00469
00470 SignaturePairwiseConsistencyTest<ECDSA<ECP, SHA> >(
00471
"3039020100301306072A8648CE3D020106082A8648CE3D030101041F301D02010104182BB8A13C8B867010BD9471D9E81FDB01ABD0538C64D6249A");
00472 }
00473
catch (...)
00474 {
00475 g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_FAILED;
00476
goto done;
00477 }
00478
00479 g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_PASSED;
00480
00481 done:
00482 SetPowerUpSelfTestInProgressOnThisThread(
false);
00483
return;
00484 }
00485
00486
#ifdef CRYPTOPP_WIN32_AVAILABLE
00487
00488
static const byte s_moduleMac[CryptoPP::HMAC<CryptoPP::SHA1>::DIGESTSIZE] =
"reserved for mac";
00489
static HMODULE s_hModule = NULL;
00490
00491
void DoDllPowerUpSelfTest()
00492 {
00493
char moduleFileName[MAX_PATH];
00494 GetModuleFileNameA(s_hModule, moduleFileName,
sizeof(moduleFileName));
00495 CryptoPP::DoPowerUpSelfTest(moduleFileName, s_moduleMac);
00496 }
00497
00498
#else
00499
00500
void DoDllPowerUpSelfTest()
00501 {
00502
throw NotImplemented(
"DoDllPowerUpSelfTest() only available on Windows");
00503 }
00504
00505
#endif // #ifdef CRYPTOPP_WIN32_AVAILABLE
00506
00507 NAMESPACE_END
00508
00509
#ifdef CRYPTOPP_WIN32_AVAILABLE
00510
00511
00512 BOOL APIENTRY DllMain(HANDLE hModule,
00513 DWORD ul_reason_for_call,
00514 LPVOID lpReserved)
00515 {
00516
if (ul_reason_for_call == DLL_PROCESS_ATTACH)
00517 {
00518 CryptoPP::s_hModule = (HMODULE)hModule;
00519 CryptoPP::DoDllPowerUpSelfTest();
00520 }
00521
return TRUE;
00522 }
00523
00524
#endif // #ifdef CRYPTOPP_WIN32_AVAILABLE
00525
00526
#endif // #ifndef CRYPTOPP_IMPORTS