arne
/
cryptopp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added validat0.cpp and moved bit tests into it. Provided tests for SafeConvert. Removed "using namespace std" from test sources (auto_ptr causes a collision becuase std:: provides it in C++03, but CryptoPP:: provides it in C++11

pull/35/head
Jeffrey Walton 2015-07-30 10:36:49 -04:00
parent 264018e8ec
commit 5a35640912
8 changed files with 833 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
GNUmakefile
View File

@ -337,7 +337,7 @@ OBJS = $(SRCS:.cpp=.o)
TEMPS = $(SRCS:.cpp=.s) $(SRCS:.cpp=.ii) TEMPS = $(SRCS:.cpp=.s) $(SRCS:.cpp=.ii)
# test.o needs to be after bench.o for cygwin 1.1.4 (possible ld bug?) # test.o needs to be after bench.o for cygwin 1.1.4 (possible ld bug?)
TESTOBJS = bench.o bench2.o test.o validat1.o validat2.o validat3.o adhoc.o datatest.o regtest.o fipsalgt.o dlltest.o TESTOBJS = bench.o bench2.o test.o validat0.o validat1.o validat2.o validat3.o adhoc.o datatest.o regtest.o fipsalgt.o dlltest.o
LIBOBJS = $(filter-out $(TESTOBJS),$(OBJS)) LIBOBJS = $(filter-out $(TESTOBJS),$(OBJS))
DLLSRCS = algebra.cpp algparam.cpp asn.cpp basecode.cpp cbcmac.cpp channels.cpp cryptlib.cpp des.cpp dessp.cpp dh.cpp \ DLLSRCS = algebra.cpp algparam.cpp asn.cpp basecode.cpp cbcmac.cpp channels.cpp cryptlib.cpp des.cpp dessp.cpp dh.cpp \

16
smartptr.h
View File

@ -7,25 +7,27 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
// Hack ahead. Apple's standard library does not have C++'s unique_ptr. We can't test // Hack ahead. Apple's standard library does not have C++'s unique_ptr in C++11. We can't
// for unique_ptr directly because some of the Clangs on Apple fail the same way. // test for unique_ptr directly because some of the non-Apple Clangs on OS X fail the same
// However, modern standard libraries have <forward_list>, so we test for it instead. // way. However, modern standard libraries have <forward_list>, so we test for it instead.
// Thanks to Jonathan Wakely for devising the clever test for modern/ancient versions. // Thanks to Jonathan Wakely for devising the clever test for modern/ancient versions.
#if (__cplusplus >= 201103L) || (_MSC_VER >= 1600) #if (__cplusplus >= 201103L) || (_MSC_VER >= 1600)
# if defined(__clang__) && (__has_include(<forward_list>)) # if defined(__clang__)
# if (__has_include(<forward_list>))
# define CRYPTOPP_HAVE_UNIQUE_PTR 1 # define CRYPTOPP_HAVE_UNIQUE_PTR 1
# endif
# else # else
# define CRYPTOPP_HAVE_UNIQUE_PTR 1 # define CRYPTOPP_HAVE_UNIQUE_PTR 1
# endif # endif
#endif #endif
// The result of below is a CryptoPP::auto_ptr in both cases
#ifdef CRYPTOPP_HAVE_UNIQUE_PTR #ifdef CRYPTOPP_HAVE_UNIQUE_PTR
// use unique_ptr instead of auto_ptr template<typename T>
template<typename T>
using std::auto_ptr = std::unique_ptr<T>; using std::auto_ptr = std::unique_ptr<T>;
#else #else
// do nothing; use auto_ptr using std::auto_ptr;
#endif #endif
template <class T> class simple_ptr template <class T> class simple_ptr

121
test.cpp
View File

@ -50,8 +50,8 @@
#endif #endif
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma comment(lib, "cryptlib_bds.lib") # pragma comment(lib, "cryptlib_bds.lib")
#pragma comment(lib, "ws2_32.lib") # pragma comment(lib, "ws2_32.lib")
#endif #endif
USING_NAMESPACE(CryptoPP) USING_NAMESPACE(CryptoPP)
@ -131,7 +131,7 @@ struct DebugTrapHandler
ret = sigemptyset (&new_handler.sa_mask); ret = sigemptyset (&new_handler.sa_mask);
if (ret != 0) break; // Failed if (ret != 0) break; // Failed
// Install it // Install i
ret = sigaction (SIGTRAP, &new_handler, NULL); ret = sigaction (SIGTRAP, &new_handler, NULL);
if (ret != 0) break; // Failed if (ret != 0) break; // Failed
@ -193,16 +193,16 @@ int CRYPTOPP_API main(int argc, char *argv[])
char seed[1024], privFilename[128], pubFilename[128]; char seed[1024], privFilename[128], pubFilename[128];
unsigned int keyLength; unsigned int keyLength;
cout << "Key length in bits: "; std::cout << "Key length in bits: ";
cin >> keyLength; cin >> keyLength;
cout << "\nSave private key to file: "; std::cout << "\nSave private key to file: ";
cin >> privFilename; cin >> privFilename;
cout << "\nSave public key to file: "; std::cout << "\nSave public key to file: ";
cin >> pubFilename; cin >> pubFilename;
cout << "\nRandom Seed: "; std::cout << "\nRandom Seed: ";
ws(cin); ws(cin);
cin.getline(seed, 1024); cin.getline(seed, 1024);
@ -213,38 +213,38 @@ int CRYPTOPP_API main(int argc, char *argv[])
else if (command == "rv") else if (command == "rv")
{ {
bool verified = RSAVerifyFile(argv[2], argv[3], argv[4]); bool verified = RSAVerifyFile(argv[2], argv[3], argv[4]);
cout << (verified ? "valid signature" : "invalid signature") << endl; std::cout << (verified ? "valid signature" : "invalid signature") << std::endl;
} }
else if (command == "r") else if (command == "r")
{ {
char privFilename[128], pubFilename[128]; char privFilename[128], pubFilename[128];
char seed[1024], message[1024]; char seed[1024], message[1024];
cout << "Private key file: "; std::cout << "Private key file: ";
cin >> privFilename; cin >> privFilename;
cout << "\nPublic key file: "; std::cout << "\nPublic key file: ";
cin >> pubFilename; cin >> pubFilename;
cout << "\nRandom Seed: "; std::cout << "\nRandom Seed: ";
ws(cin); ws(cin);
cin.getline(seed, 1024); cin.getline(seed, 1024);
cout << "\nMessage: "; std::cout << "\nMessage: ";
cin.getline(message, 1024); cin.getline(message, 1024);
string ciphertext = RSAEncryptString(pubFilename, seed, message); string ciphertext = RSAEncryptString(pubFilename, seed, message);
cout << "\nCiphertext: " << ciphertext << endl; std::cout << "\nCiphertext: " << ciphertext << std::endl;
string decrypted = RSADecryptString(privFilename, ciphertext.c_str()); string decrypted = RSADecryptString(privFilename, ciphertext.c_str());
cout << "\nDecrypted: " << decrypted << endl; std::cout << "\nDecrypted: " << decrypted << std::endl;
} }
else if (command == "mt") else if (command == "mt")
{ {
MaurerRandomnessTest mt; MaurerRandomnessTest mt;
FileStore fs(argv[2]); FileStore fs(argv[2]);
fs.TransferAllTo(mt); fs.TransferAllTo(mt);
cout << "Maurer Test Value: " << mt.GetTestValue() << endl; std::cout << "Maurer Test Value: " << mt.GetTestValue() << std::endl;
} }
else if (command == "mac_dll") else if (command == "mac_dll")
{ {
@ -253,7 +253,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
std::ifstream::pos_type fileEnd = dllFile.seekg(0, std::ios_base::end).tellg(); std::ifstream::pos_type fileEnd = dllFile.seekg(0, std::ios_base::end).tellg();
if (fileEnd > 20*1000*1000) if (fileEnd > 20*1000*1000)
{ {
cerr << "Input file too large (more than 20 MB).\n"; std::cerr << "Input file too large (more than 20 MB).\n";
return 1; return 1;
} }
@ -269,7 +269,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
word16 optionalHeaderMagic = *(word16 *)(buf+optionalHeaderPos); word16 optionalHeaderMagic = *(word16 *)(buf+optionalHeaderPos);
if (optionalHeaderMagic != 0x10b && optionalHeaderMagic != 0x20b) if (optionalHeaderMagic != 0x10b && optionalHeaderMagic != 0x20b)
{ {
cerr << "Target file is not a PE32 or PE32+ image.\n"; std::cerr << "Target file is not a PE32 or PE32+ image.\n";
return 3; return 3;
} }
word32 checksumPos = optionalHeaderPos + 64; word32 checksumPos = optionalHeaderPos + 64;
@ -277,14 +277,14 @@ int CRYPTOPP_API main(int argc, char *argv[])
word32 certificateTablePos = *(word32 *)(buf+certificateTableDirectoryPos); word32 certificateTablePos = *(word32 *)(buf+certificateTableDirectoryPos);
word32 certificateTableSize = *(word32 *)(buf+certificateTableDirectoryPos+4); word32 certificateTableSize = *(word32 *)(buf+certificateTableDirectoryPos+4);
if (certificateTableSize != 0) if (certificateTableSize != 0)
cerr << "Warning: certificate table (IMAGE_DIRECTORY_ENTRY_SECURITY) of target image is not empty.\n"; std::cerr << "Warning: certificate table (IMAGE_DIRECTORY_ENTRY_SECURITY) of target image is not empty.\n";
// find where to place computed MAC // find where to place computed MAC
byte mac[] = CRYPTOPP_DUMMY_DLL_MAC; byte mac[] = CRYPTOPP_DUMMY_DLL_MAC;
byte *found = std::search(buf.begin(), buf.end(), mac+0, mac+sizeof(mac)); byte *found = std::search(buf.begin(), buf.end(), mac+0, mac+sizeof(mac));
if (found == buf.end()) if (found == buf.end())
{ {
cerr << "MAC placeholder not found. Possibly the actual MAC was already placed.\n"; std::cerr << "MAC placeholder not found. Possibly the actual MAC was already placed.\n";
return 2; return 2;
} }
word32 macPos = (unsigned int)(found-buf.begin()); word32 macPos = (unsigned int)(found-buf.begin());
@ -300,7 +300,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
f.PutMessageEnd(buf.begin(), buf.size()); f.PutMessageEnd(buf.begin(), buf.size());
// place MAC // place MAC
cout << "Placing MAC in file " << argv[2] << ", location " << macPos << ".\n"; std::cout << "Placing MAC in file " << argv[2] << ", location " << macPos << ".\n";
dllFile.seekg(macPos, std::ios_base::beg); dllFile.seekg(macPos, std::ios_base::beg);
dllFile.write((char *)mac, sizeof(mac)); dllFile.write((char *)mac, sizeof(mac));
} }
@ -318,17 +318,17 @@ int CRYPTOPP_API main(int argc, char *argv[])
// VC60 workaround: use char array instead of std::string to workaround MSVC's getline bug // VC60 workaround: use char array instead of std::string to workaround MSVC's getline bug
char passPhrase[MAX_PHRASE_LENGTH], plaintext[1024]; char passPhrase[MAX_PHRASE_LENGTH], plaintext[1024];
cout << "Passphrase: "; std::cout << "Passphrase: ";
cin.getline(passPhrase, MAX_PHRASE_LENGTH); cin.getline(passPhrase, MAX_PHRASE_LENGTH);
cout << "\nPlaintext: "; std::cout << "\nPlaintext: ";
cin.getline(plaintext, 1024); cin.getline(plaintext, 1024);
string ciphertext = EncryptString(plaintext, passPhrase); string ciphertext = EncryptString(plaintext, passPhrase);
cout << "\nCiphertext: " << ciphertext << endl; std::cout << "\nCiphertext: " << ciphertext << std::endl;
string decrypted = DecryptString(ciphertext.c_str(), passPhrase); string decrypted = DecryptString(ciphertext.c_str(), passPhrase);
cout << "\nDecrypted: " << decrypted << endl; std::cout << "\nDecrypted: " << decrypted << std::endl;
return 0; return 0;
} }
@ -343,7 +343,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
else if (command == "e" || command == "d") else if (command == "e" || command == "d")
{ {
char passPhrase[MAX_PHRASE_LENGTH]; char passPhrase[MAX_PHRASE_LENGTH];
cout << "Passphrase: "; std::cout << "Passphrase: ";
cin.getline(passPhrase, MAX_PHRASE_LENGTH); cin.getline(passPhrase, MAX_PHRASE_LENGTH);
if (command == "e") if (command == "e")
EncryptFile(argv[2], argv[3], passPhrase); EncryptFile(argv[2], argv[3], passPhrase);
@ -353,7 +353,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
else if (command == "ss") else if (command == "ss")
{ {
char seed[1024]; char seed[1024];
cout << "\nRandom Seed: "; std::cout << "\nRandom Seed: ";
ws(cin); ws(cin);
cin.getline(seed, 1024); cin.getline(seed, 1024);
SecretShareFile(atoi(argv[2]), atoi(argv[3]), argv[4], seed); SecretShareFile(atoi(argv[2]), atoi(argv[3]), argv[4], seed);
@ -386,7 +386,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
return (*AdhocTest)(argc, argv); return (*AdhocTest)(argc, argv);
else else
{ {
cerr << "AdhocTest not defined.\n"; std::cerr << "AdhocTest not defined.\n";
return 1; return 1;
} }
} }
@ -396,28 +396,28 @@ int CRYPTOPP_API main(int argc, char *argv[])
AES_CTR_Encrypt(argv[2], argv[3], argv[4], argv[5]); AES_CTR_Encrypt(argv[2], argv[3], argv[4], argv[5]);
else if (command == "h") else if (command == "h")
{ {
FileSource usage("TestData/usage.dat", true, new FileSink(cout)); FileSource usage("TestData/usage.dat", true, new FileSink(std::cout));
return 1; return 1;
} }
else if (command == "V") else if (command == "V")
{ {
cout << CRYPTOPP_VERSION / 100 << '.' << (CRYPTOPP_VERSION % 100) / 10 << '.' << CRYPTOPP_VERSION % 10 << endl; std::cout << CRYPTOPP_VERSION / 100 << '.' << (CRYPTOPP_VERSION % 100) / 10 << '.' << CRYPTOPP_VERSION % 10 << std::endl;
} }
else else
{ {
cerr << "Unrecognized command. Run \"cryptest h\" to obtain usage information.\n"; std::cerr << "Unrecognized command. Run \"cryptest h\" to obtain usage information.\n";
return 1; return 1;
} }
return 0; return 0;
} }
catch(CryptoPP::Exception &e) catch(CryptoPP::Exception &e)
{ {
cout << "\nCryptoPP::Exception caught: " << e.what() << endl; std::cout << "\nCryptoPP::Exception caught: " << e.what() << std::endl;
return -1; return -1;
} }
catch(std::exception &e) catch(std::exception &e)
{ {
cout << "\nstd::exception caught: " << e.what() << endl; std::cout << "\nstd::exception caught: " << e.what() << std::endl;
return -2; return -2;
} }
} }
@ -431,7 +431,7 @@ void FIPS140_GenerateRandomFiles()
for (unsigned int i=0; i<100000; i++) for (unsigned int i=0; i<100000; i++)
store.TransferTo(FileSink((IntToString(i) + ".rnd").c_str()).Ref(), 20000); store.TransferTo(FileSink((IntToString(i) + ".rnd").c_str()).Ref(), 20000);
#else #else
cout << "OS provided RNG not available.\n"; std::cout << "OS provided RNG not available.\n";
exit(-1); exit(-1);
#endif #endif
} }
@ -530,12 +530,12 @@ void DigestFile(const char *filename)
channelSwitch->AddDefaultRoute(*filters[i]); channelSwitch->AddDefaultRoute(*filters[i]);
FileSource(filename, true, channelSwitch.release()); FileSource(filename, true, channelSwitch.release());
HexEncoder encoder(new FileSink(cout), false); HexEncoder encoder(new FileSink(std::cout), false);
for (i=0; i<filters.size(); i++) for (i=0; i<filters.size(); i++)
{ {
cout << filters[i]->AlgorithmName() << ": "; std::cout << filters[i]->AlgorithmName() << ": ";
filters[i]->TransferTo(encoder); filters[i]->TransferTo(encoder);
cout << "\n"; std::cout << "\n";
} }
} }
@ -544,7 +544,7 @@ void HmacFile(const char *hexKey, const char *file)
member_ptr<MessageAuthenticationCode> mac; member_ptr<MessageAuthenticationCode> mac;
if (strcmp(hexKey, "selftest") == 0) if (strcmp(hexKey, "selftest") == 0)
{ {
cerr << "Computing HMAC/SHA1 value for self test.\n"; std::cerr << "Computing HMAC/SHA1 value for self test.\n";
mac.reset(NewIntegrityCheckingMAC()); mac.reset(NewIntegrityCheckingMAC());
} }
else else
@ -553,7 +553,7 @@ void HmacFile(const char *hexKey, const char *file)
StringSource(hexKey, true, new HexDecoder(new StringSink(decodedKey))); StringSource(hexKey, true, new HexDecoder(new StringSink(decodedKey)));
mac.reset(new HMAC<SHA1>((const byte *)decodedKey.data(), decodedKey.size())); mac.reset(new HMAC<SHA1>((const byte *)decodedKey.data(), decodedKey.size()));
} }
FileSource(file, true, new HashFilter(*mac, new HexEncoder(new FileSink(cout)))); FileSource(file, true, new HashFilter(*mac, new HexEncoder(new FileSink(std::cout))));
} }
void AES_CTR_Encrypt(const char *hexKey, const char *hexIV, const char *infile, const char *outfile) void AES_CTR_Encrypt(const char *hexKey, const char *hexIV, const char *infile, const char *outfile)
@ -701,11 +701,11 @@ void InformationRecoverFile(int threshold, const char *outFilename, char *const
void GzipFile(const char *in, const char *out, int deflate_level) void GzipFile(const char *in, const char *out, int deflate_level)
{ {
// FileSource(in, true, new Gzip(new FileSink(out), deflate_level)); // FileSource(in, true, new Gzip(new FileSink(out), deflate_level));
// use a filter graph to compare decompressed data with original // use a filter graph to compare decompressed data with original
// //
// Source ----> Gzip ------> Sink // Source --------> Gzip --------> Sink
// \ | // \ |
// \ Gunzip // \ Gunzip
// \ | // \ |
@ -770,18 +770,18 @@ void ForwardTcpPort(const char *sourcePortName, const char *destinationHost, con
sockListen.Bind(sourcePort); sockListen.Bind(sourcePort);
setsockopt(sockListen, IPPROTO_TCP, TCP_NODELAY, "\x01", 1); setsockopt(sockListen, IPPROTO_TCP, TCP_NODELAY, "\x01", 1);
cout << "Listing on port " << sourcePort << ".\n"; std::cout << "Listing on port " << sourcePort << ".\n";
sockListen.Listen(); sockListen.Listen();
sockListen.Accept(sockSource); sockListen.Accept(sockSource);
cout << "Connection accepted on port " << sourcePort << ".\n"; std::cout << "Connection accepted on port " << sourcePort << ".\n";
sockListen.CloseSocket(); sockListen.CloseSocket();
cout << "Making connection to " << destinationHost << ", port " << destinationPort << ".\n"; std::cout << "Making connection to " << destinationHost << ", port " << destinationPort << ".\n";
sockDestination.Create(); sockDestination.Create();
sockDestination.Connect(destinationHost, destinationPort); sockDestination.Connect(destinationHost, destinationPort);
cout << "Connection made to " << destinationHost << ", starting to forward.\n"; std::cout << "Connection made to " << destinationHost << ", starting to forward.\n";
SocketSource out(sockSource, false, new SocketSink(sockDestination)); SocketSource out(sockSource, false, new SocketSink(sockDestination));
SocketSource in(sockDestination, false, new SocketSink(sockSource)); SocketSource in(sockDestination, false, new SocketSink(sockSource));
@ -799,22 +799,22 @@ void ForwardTcpPort(const char *sourcePortName, const char *destinationHost, con
if (!out.SourceExhausted()) if (!out.SourceExhausted())
{ {
cout << "o" << flush; std::cout << "o" << flush;
out.PumpAll2(false); out.PumpAll2(false);
if (out.SourceExhausted()) if (out.SourceExhausted())
cout << "EOF received on source socket.\n"; std::cout << "EOF received on source socket.\n";
} }
if (!in.SourceExhausted()) if (!in.SourceExhausted())
{ {
cout << "i" << flush; std::cout << "i" << flush;
in.PumpAll2(false); in.PumpAll2(false);
if (in.SourceExhausted()) if (in.SourceExhausted())
cout << "EOF received on destination socket.\n"; std::cout << "EOF received on destination socket.\n";
} }
} }
#else #else
cout << "Socket support was not enabled at compile time.\n"; std::cout << "Socket support was not enabled at compile time.\n";
exit(-1); exit(-1);
#endif #endif
} }
@ -826,7 +826,7 @@ bool Validate(int alg, bool thorough, const char *seedInput)
std::string seed = seedInput ? std::string(seedInput) : IntToString(time(NULL)); std::string seed = seedInput ? std::string(seedInput) : IntToString(time(NULL));
seed.resize(16); seed.resize(16);
cout << "Using seed: " << seed << endl; std::cout << "Using seed: " << seed << std::endl;
s_globalRNG.SetKeyWithIV((byte *)seed.data(), 16, (byte *)seed.data()); s_globalRNG.SetKeyWithIV((byte *)seed.data(), 16, (byte *)seed.data());
#ifdef _OPENMP #ifdef _OPENMP
@ -836,15 +836,17 @@ bool Validate(int alg, bool thorough, const char *seedInput)
tc = omp_get_num_threads(); tc = omp_get_num_threads();
} }
cout << "Using " << tc << " OMP " << (tc == 1 ? "thread" : "threads") << endl; std::cout << "Using " << tc << " OMP " << (tc == 1 ? "thread" : "threads") << std::endl;
#endif #endif
cout << endl; std::cout << std::endl;
switch (alg) switch (alg)
{ {
case 0: result = ValidateAll(thorough); break; case 0: result = ValidateAll(thorough); break;
case 1: result = TestSettings(); break; case 1: result = TestSettings(); break;
case 70: result = TestRotate(); break;
case 71: result = TestConversion(); break;
case 2: result = TestOS_RNG(); break; case 2: result = TestOS_RNG(); break;
case 3: result = ValidateMD5(); break; case 3: result = ValidateMD5(); break;
case 4: result = ValidateSHA(); break; case 4: result = ValidateSHA(); break;
@ -853,26 +855,26 @@ bool Validate(int alg, bool thorough, const char *seedInput)
case 7: result = ValidateARC4(); break; case 7: result = ValidateARC4(); break;
case 8: result = ValidateRC5(); break; case 8: result = ValidateRC5(); break;
case 9: result = ValidateBlowfish(); break; case 9: result = ValidateBlowfish(); break;
// case 10: result = ValidateDiamond2(); break; // case 10: result = ValidateDiamond2(); break;
case 11: result = ValidateThreeWay(); break; case 11: result = ValidateThreeWay(); break;
case 12: result = ValidateBBS(); break; case 12: result = ValidateBBS(); break;
case 13: result = ValidateDH(); break; case 13: result = ValidateDH(); break;
case 14: result = ValidateRSA(); break; case 14: result = ValidateRSA(); break;
case 15: result = ValidateElGamal(); break; case 15: result = ValidateElGamal(); break;
case 16: result = ValidateDSA(thorough); break; case 16: result = ValidateDSA(thorough); break;
// case 17: result = ValidateHAVAL(); break; // case 17: result = ValidateHAVAL(); break;
case 18: result = ValidateSAFER(); break; case 18: result = ValidateSAFER(); break;
case 19: result = ValidateLUC(); break; case 19: result = ValidateLUC(); break;
case 20: result = ValidateRabin(); break; case 20: result = ValidateRabin(); break;
// case 21: result = ValidateBlumGoldwasser(); break; // case 21: result = ValidateBlumGoldwasser(); break;
case 22: result = ValidateECP(); break; case 22: result = ValidateECP(); break;
case 23: result = ValidateEC2N(); break; case 23: result = ValidateEC2N(); break;
// case 24: result = ValidateMD5MAC(); break; // case 24: result = ValidateMD5MAC(); break;
case 25: result = ValidateGOST(); break; case 25: result = ValidateGOST(); break;
case 26: result = ValidateTiger(); break; case 26: result = ValidateTiger(); break;
case 27: result = ValidateRIPEMD(); break; case 27: result = ValidateRIPEMD(); break;
case 28: result = ValidateHMAC(); break; case 28: result = ValidateHMAC(); break;
// case 29: result = ValidateXMACC(); break; // case 29: result = ValidateXMACC(); break;
case 30: result = ValidateSHARK(); break; case 30: result = ValidateSHARK(); break;
case 32: result = ValidateLUC_DH(); break; case 32: result = ValidateLUC_DH(); break;
case 33: result = ValidateLUC_DL(); break; case 33: result = ValidateLUC_DL(); break;
@ -912,12 +914,13 @@ bool Validate(int alg, bool thorough, const char *seedInput)
case 67: result = ValidateCCM(); break; case 67: result = ValidateCCM(); break;
case 68: result = ValidateGCM(); break; case 68: result = ValidateGCM(); break;
case 69: result = ValidateCMAC(); break; case 69: result = ValidateCMAC(); break;
case 72: result = ValidateHKDF(); break;
default: return false; default: return false;
} }
time_t endTime = time(NULL); time_t endTime = time(NULL);
cout << "\nTest ended at " << asctime(localtime(&endTime)); std::cout << "\nTest ended at " << asctime(localtime(&endTime));
cout << "Seed used was: " << seed << endl; std::cout << "Seed used was: " << seed << std::endl;
return result; return result;
} }

659
validat0.cpp Normal file
View File

@ -0,0 +1,659 @@
// validat0.cpp - written and placed in the public domain by Wei Dai and Jeffrey Walton
#include "pch.h"
#include "config.h"
#include "stdcpp.h"
#include "misc.h"
#include "integer.h"
#include "validate.h"
#include <iostream>
USING_NAMESPACE(CryptoPP)
#if GCC_DIAGNOSTIC_AWARE
# pragma GCC diagnostic ignored "-Wunused-value"
#endif
bool TestSettings()
{
bool pass = true;
std::cout << "\nTesting Settings...\n\n";
word32 w;
memcpy_s(&w, sizeof(w), "\x01\x02\x03\x04", 4);
if (w == 0x04030201L)
{
#ifdef IS_LITTLE_ENDIAN
std::cout << "passed: ";
#else
std::cout << "FAILED: ";
pass = false;
#endif
std::cout << "Your machine is little endian.\n";
}
else if (w == 0x01020304L)
{
#ifndef IS_LITTLE_ENDIAN
std::cout << "passed: ";
#else
std::cout << "FAILED: ";
pass = false;
#endif
std::cout << "Your machine is big endian.\n";
}
else
{
std::cout << "FAILED: Your machine is neither big endian nor little endian.\n";
pass = false;
}
#ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS
byte testvals[10] = {1,2,2,3,3,3,3,2,2,1};
if (*(word32 *)(testvals+3) == 0x03030303 && *(word64 *)(testvals+1) == W64LIT(0x0202030303030202))
std::cout << "passed: Your machine allows unaligned data access.\n";
else
{
std::cout << "FAILED: Unaligned data access gave incorrect results.\n";
pass = false;
}
#else
std::cout << "passed: CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS is not defined. Will restrict to aligned data access.\n";
#endif
if (sizeof(byte) == 1)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(byte) == " << sizeof(byte) << std::endl;
if (sizeof(word16) == 2)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word16) == " << sizeof(word16) << std::endl;
if (sizeof(word32) == 4)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word32) == " << sizeof(word32) << std::endl;
if (sizeof(word64) == 8)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word64) == " << sizeof(word64) << std::endl;
#ifdef CRYPTOPP_WORD128_AVAILABLE
if (sizeof(word128) == 16)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word128) == " << sizeof(word128) << std::endl;
#endif
if (sizeof(word) == 2*sizeof(hword)
#ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
&& sizeof(dword) == 2*sizeof(word)
#endif
)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(hword) == " << sizeof(hword) << ", sizeof(word) == " << sizeof(word);
#ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
std::cout << ", sizeof(dword) == " << sizeof(dword);
#endif
std::cout << std::endl;
#ifdef CRYPTOPP_CPUID_AVAILABLE
bool hasMMX = HasMMX();
bool hasISSE = HasSSE();
bool hasSSE2 = HasSSE2();
bool hasSSSE3 = HasSSSE3();
bool isP4 = IsP4();
int cacheLineSize = GetCacheLineSize();
if ((isP4 && (!hasMMX || !hasSSE2)) || (hasSSE2 && !hasMMX) || (cacheLineSize < 16 || cacheLineSize > 256 || !IsPowerOf2(cacheLineSize)))
{
std::cout << "FAILED: ";
pass = false;
}
else
std::cout << "passed: ";
std::cout << "hasMMX == " << hasMMX << ", hasISSE == " << hasISSE << ", hasSSE2 == " << hasSSE2 << ", hasSSSE3 == " << hasSSSE3 << ", hasAESNI == " << HasAESNI() << ", hasCLMUL == " << HasCLMUL() << ", isP4 == " << isP4 << ", cacheLineSize == " << cacheLineSize;
std::cout << ", AESNI_INTRINSICS == " << CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE << std::endl;
#endif
if (!pass)
{
std::cout << "Some critical setting in config.h is in error. Please fix it and recompile." << std::endl;
abort();
}
return pass;
}
bool TestRotate()
{
bool pass = true;
std::cout << "\nTesting rotate...\n\n";
std::cout << (!pass ? "FAILED " : "passed ") << " left rotate" << std::endl;
std::cout << (!pass ? "FAILED " : "passed ") << " right rotate" << std::endl;
return pass;
}
bool TestConversion()
{
bool pass = true;
std::cout << "\nTesting conversions...\n\n";
/********** signed char **********/
{
signed char v1, v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<signed char>::min(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<signed char>::min() + 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<signed char>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<signed char>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " signed char" << std::endl;
pass &= p;
}
/********** signed char overflow **********/
{
signed char v; bool p = true;
{
signed short v1 = std::numeric_limits<signed short>::min(); p = !SafeConvert(v1, v) && p;
signed short v2 = std::numeric_limits<signed short>::max(); p = !SafeConvert(v2, v) && p;
unsigned short v3 = std::numeric_limits<unsigned short>::max(); p = !SafeConvert(v3, v) && p;
}
{
signed int v1 = std::numeric_limits<signed int>::min(); p = !SafeConvert(v1, v) && p;
signed int v2 = std::numeric_limits<signed int>::max(); p = !SafeConvert(v2, v) && p;
unsigned int v3 = std::numeric_limits<unsigned int>::max(); p = !SafeConvert(v3, v) && p;
}
{
signed long v1 = std::numeric_limits<signed long>::min(); p = !SafeConvert(v1, v) && p;
signed long v2 = std::numeric_limits<signed long>::max(); p = !SafeConvert(v2, v) && p;
unsigned long v3 = std::numeric_limits<unsigned long>::max(); p = !SafeConvert(v3, v) && p;
}
{
signed long long v1 = std::numeric_limits<signed long long>::min(); p = !SafeConvert(v1, v) && p;
signed long long v2 = std::numeric_limits<signed long long>::max(); p = !SafeConvert(v2, v) && p;
unsigned long long v3 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v3, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " signed char overflow" << std::endl;
pass &= p;
}
/********** unsigned char **********/
{
unsigned char v1, v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned char>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned char>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " unsigned char" << std::endl;
pass &= p;
}
/********** unsigned char overflow **********/
{
unsigned char v; bool p = true;
{
unsigned short v1 = std::numeric_limits<unsigned short>::max(); p = !SafeConvert(v1, v) && p;
}
{
unsigned int v1 = std::numeric_limits<unsigned int>::max(); p = !SafeConvert(v1, v) && p;
}
{
unsigned long v1 = std::numeric_limits<unsigned long>::max(); p = !SafeConvert(v1, v) && p;
}
{
unsigned long long v1 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v1, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " unsigned char overflow" << std::endl;
pass &= p;
}
/********** signed short **********/
{
signed short v1, v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<short>::min(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<short>::min() + 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<short>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<short>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " signed short" << std::endl;
pass &= p;
}
/********** signed short overflow **********/
{
signed short v; bool p = true;
{
signed int v1 = std::numeric_limits<signed int>::min(); p = !SafeConvert(v1, v) && p;
signed int v2 = std::numeric_limits<signed int>::max(); p = !SafeConvert(v2, v) && p;
unsigned int v3 = std::numeric_limits<unsigned int>::max(); p = !SafeConvert(v3, v) && p;
}
{
signed long v1 = std::numeric_limits<signed long>::min(); p = !SafeConvert(v1, v) && p;
signed long v2 = std::numeric_limits<signed long>::max(); p = !SafeConvert(v2, v) && p;
unsigned long v3 = std::numeric_limits<unsigned long>::max(); p = !SafeConvert(v3, v) && p;
}
{
signed long long v1 = std::numeric_limits<signed long long>::min(); p = !SafeConvert(v1, v) && p;
signed long long v2 = std::numeric_limits<signed long long>::max(); p = !SafeConvert(v2, v) && p;
unsigned long long v3 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v3, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " signed short overflow" << std::endl;
pass &= p;
}
/********** unsigned short **********/
{
unsigned short v1, v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned short>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned short>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " unsigned short" << std::endl;
pass &= p;
}
/********** unsigned short overflow **********/
{
unsigned short v; bool p = true;
{
unsigned int v1 = std::numeric_limits<unsigned int>::max(); p = !SafeConvert(v1, v) && p;
}
{
unsigned long v1 = std::numeric_limits<unsigned long>::max(); p = !SafeConvert(v1, v) && p;
}
{
unsigned long long v1 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v1, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " unsigned short overflow" << std::endl;
pass &= p;
}
/********** signed int **********/
{
signed int v1, v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<int>::min(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<int>::min() + 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<int>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<int>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " signed int" << std::endl;
pass &= p;
}
/********** signed int overflow **********/
{
signed int v; bool p = true;
{
signed long v1 = std::numeric_limits<signed long>::min(); p = !SafeConvert(v1, v) && p;
signed long v2 = std::numeric_limits<signed long>::max(); p = !SafeConvert(v2, v) && p;
unsigned long v3 = std::numeric_limits<unsigned long>::max(); p = !SafeConvert(v3, v) && p;
}
{
signed long long v1 = std::numeric_limits<signed long long>::min(); p = !SafeConvert(v1, v) && p;
signed long long v2 = std::numeric_limits<signed long long>::max(); p = !SafeConvert(v2, v) && p;
unsigned long long v3 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v3, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " signed int overflow" << std::endl;
pass &= p;
}
/********** unsigned int **********/
{
unsigned int v1, v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned int>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned int>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " unsigned int" << std::endl;
pass &= p;
}
/********** unsigned int overflow **********/
{
unsigned int v; bool p = true;
{
unsigned long v1 = std::numeric_limits<unsigned long>::max(); p = !SafeConvert(v1, v) && p;
}
{
unsigned long long v1 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v1, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " unsigned int overflow" << std::endl;
pass &= p;
}
/********** signed long **********/
{
signed long v1, v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long>::min(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long>::min() + 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " signed long" << std::endl;
pass &= p;
}
/********** signed long overflow **********/
{
if(sizeof(signed long) != sizeof(signed long long))
{
signed long v; bool p = true;
{
signed long long v1 = std::numeric_limits<signed long long>::min(); p = !SafeConvert(v1, v) && p;
signed long long v2 = std::numeric_limits<signed long long>::max(); p = !SafeConvert(v2, v) && p;
unsigned long long v3 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v3, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " signed long overflow" << std::endl;
pass &= p;
}
else
{
std::cout << "passed signed long overflow (skipped due to range of types)" << std::endl;
}
}
/********** unsigned long **********/
{
unsigned long v1, v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned long>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned long>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " unsigned long" << std::endl;
pass &= p;
}
/********** unsigned long overflow **********/
{
if(sizeof(unsigned long) != sizeof(unsigned long long))
{
unsigned long v; bool p = true;
{
unsigned long long v1 = std::numeric_limits<unsigned long long>::max(); p = !SafeConvert(v1, v) && p;
}
std::cout << (!p ? "FAILED " : "passed ") << " unsigned long overflow" << std::endl;
pass &= p;
}
else
{
std::cout << "passed unsigned long overflow (skipped due to range of types)" << std::endl;
}
}
/********** signed long long **********/
{
signed long long v1, v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long long>::min(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long long>::min() + 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long long>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<long long>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " signed long long" << std::endl;
pass &= p;
}
/********** unsigned long long **********/
{
unsigned long long v1, v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned long long>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<unsigned long long>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " unsigned long long" << std::endl;
pass &= p;
}
/********** ssize_t **********/
{
ssize_t v1, v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<ssize_t>::min(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<ssize_t>::min() + 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<ssize_t>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<ssize_t>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " ssize_t" << std::endl;
pass &= p;
}
/********** size_t **********/
{
size_t v1, v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<size_t>::max(); p = SafeConvert(v1, v2) && p;
v1 = std::numeric_limits<size_t>::max() - 1; p = SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " size_t" << std::endl;
pass &= p;
}
#if 0
{
Integer v1; signed char v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<char>::min()); p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<char>::min()) + 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<char>::min()) - 1; p = !SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<char>::max()); p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<char>::max()) - 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<char>::max()) + 1; p = !SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " Integer to signed char" << std::endl;
pass &= p;
}
{
Integer v1; unsigned char v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<unsigned char>::max()); p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<unsigned char>::max()) - 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<unsigned char>::max()) + 1; p = !SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " Integer to unsigned char" << std::endl;
pass &= p;
}
{
Integer v1; signed short v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<short>::min()); p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<short>::min()) + 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<short>::min()) - 1; p = !SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<short>::max()); p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<short>::max()) - 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<short>::max()) + 1; p = !SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " Integer to signed short" << std::endl;
pass &= p;
}
{
Integer v1; unsigned short v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p;
v1 = 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<unsigned short>::max()); p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<unsigned short>::max()) - 1; p = SafeConvert(v1, v2) && p;
v1 = Integer((signed long)std::numeric_limits<unsigned short>::max()) + 1; p = !SafeConvert(v1, v2) && p;
std::cout << (!p ? "FAILED " : "passed ") << " Integer to unsigned short" << std::endl;
pass &= p;
}
{
Integer v1; signed int v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 0; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<int>::min()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << "Limit: " << (int) std::numeric_limits<int>::min() << std::endl;
std::cout << "Digits: " << (int) std::numeric_limits<int>::digits << std::endl;
std::cout << "Value: " << v1 << std::endl;
std::cout << "BitCount: " << v1.BitCount() << std::endl;
v1 = Integer((signed long)std::numeric_limits<int>::min()) + 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<int>::min()) - 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<int>::max()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<int>::max()) - 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<int>::max()) + 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << (!p ? "FAILED " : "passed ") << " Integer to signed int" << std::endl;
pass &= p;
}
{
Integer v1; unsigned int v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<unsigned int>::max()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<unsigned int>::max()) - 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<unsigned int>::max()) + 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << (!p ? "FAILED " : "passed ") << " Integer to unsigned int" << std::endl;
pass &= p;
}
{
Integer v1; signed long v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 0; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<signed long>::min()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<signed long>::min()) + 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<signed long>::min()) - 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<signed long>::max()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<signed long>::max()) - 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<signed long>::max()) + 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << (!p ? "FAILED " : "passed ") << " Integer to signed long" << std::endl;
pass &= p;
}
{
Integer v1; unsigned long v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<unsigned long>::max()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<unsigned long>::max()) - 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<unsigned long>::max()) + 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << (!p ? "FAILED " : "passed ") << " Integer to signed long" << std::endl;
pass &= p;
}
{
Integer v1; ssize_t v2; bool p = true;
v1 = -1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 0; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<ssize_t>::min()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<ssize_t>::min()) + 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<ssize_t>::min()) - 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<ssize_t>::max()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<ssize_t>::max()) - 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((signed long)std::numeric_limits<ssize_t>::max()) + 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << (!p ? "FAILED " : "passed ") << " Integer to signed ssize_t" << std::endl;
pass &= p;
}
{
Integer v1; size_t v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<size_t>::max()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<size_t>::max()) - 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<size_t>::max()) + 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << (!p ? "FAILED " : "passed ") << " Integer to size_t" << std::endl;
pass &= p;
}
{
CRYPTOPP_COMPILE_ASSERT(sizeof(word64) >= sizeof(unsigned long long));
Integer v1; unsigned long long v2; bool p = true;
v1 = 0; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<unsigned long long>::max()); p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<unsigned long long>::max()) - 1; p = SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
v1 = Integer((word64)std::numeric_limits<unsigned long long>::max()) + 1; p = !SafeConvert(v1, v2) && p; CRYPTOPP_ASSERT(p);
std::cout << (!p ? "FAILED " : "passed ") << " Integer to unsigned long long" << std::endl;
pass &= p;
}
#endif
return pass;
}

147
validat1.cpp
View File

@ -47,12 +47,11 @@
USING_NAMESPACE(CryptoPP) USING_NAMESPACE(CryptoPP)
// using CryptoPP::auto_ptr;
using std::auto_ptr;
bool ValidateAll(bool thorough) bool ValidateAll(bool thorough)
{ {
bool pass=TestSettings(); bool pass=TestSettings();
pass=TestRotate() && pass;
pass=TestConversion() && pass;
pass=TestOS_RNG() && pass; pass=TestOS_RNG() && pass;
pass=ValidateCRC32() && pass; pass=ValidateCRC32() && pass;
@ -131,146 +130,6 @@ bool ValidateAll(bool thorough)
return pass; return pass;
} }
bool TestSettings()
{
bool pass = true;
std::cout << "\nTesting Settings...\n\n";
word32 w;
memcpy_s(&w, sizeof(w), "\x01\x02\x03\x04", 4);
if (w == 0x04030201L)
{
#ifdef IS_LITTLE_ENDIAN
std::cout << "passed: ";
#else
std::cout << "FAILED: ";
pass = false;
#endif
std::cout << "Your machine is little endian.\n";
}
else if (w == 0x01020304L)
{
#ifndef IS_LITTLE_ENDIAN
std::cout << "passed: ";
#else
std::cout << "FAILED: ";
pass = false;
#endif
std::cout << "Your machine is big endian.\n";
}
else
{
std::cout << "FAILED: Your machine is neither big endian nor little endian.\n";
pass = false;
}
#ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS
byte testvals[10] = {1,2,2,3,3,3,3,2,2,1};
if (*(word32 *)(testvals+3) == 0x03030303 && *(word64 *)(testvals+1) == W64LIT(0x0202030303030202))
std::cout << "passed: Your machine allows unaligned data access.\n";
else
{
std::cout << "FAILED: Unaligned data access gave incorrect results.\n";
pass = false;
}
#else
std::cout << "passed: CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS is not defined. Will restrict to aligned data access.\n";
#endif
if (sizeof(byte) == 1)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(byte) == " << sizeof(byte) << std::endl;
if (sizeof(word16) == 2)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word16) == " << sizeof(word16) << std::endl;
if (sizeof(word32) == 4)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word32) == " << sizeof(word32) << std::endl;
if (sizeof(word64) == 8)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word64) == " << sizeof(word64) << std::endl;
#ifdef CRYPTOPP_WORD128_AVAILABLE
if (sizeof(word128) == 16)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(word128) == " << sizeof(word128) << std::endl;
#endif
if (sizeof(word) == 2*sizeof(hword)
#ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
&& sizeof(dword) == 2*sizeof(word)
#endif
)
std::cout << "passed: ";
else
{
std::cout << "FAILED: ";
pass = false;
}
std::cout << "sizeof(hword) == " << sizeof(hword) << ", sizeof(word) == " << sizeof(word);
#ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
std::cout << ", sizeof(dword) == " << sizeof(dword);
#endif
std::cout << std::endl;
#ifdef CRYPTOPP_CPUID_AVAILABLE
bool hasMMX = HasMMX();
bool hasISSE = HasSSE();
bool hasSSE2 = HasSSE2();
bool hasSSSE3 = HasSSSE3();
bool isP4 = IsP4();
int cacheLineSize = GetCacheLineSize();
if ((isP4 && (!hasMMX || !hasSSE2)) || (hasSSE2 && !hasMMX) || (cacheLineSize < 16 || cacheLineSize > 256 || !IsPowerOf2(cacheLineSize)))
{
std::cout << "FAILED: ";
pass = false;
}
else
std::cout << "passed: ";
std::cout << "hasMMX == " << hasMMX << ", hasISSE == " << hasISSE << ", hasSSE2 == " << hasSSE2 << ", hasSSSE3 == " << hasSSSE3 << ", hasAESNI == " << HasAESNI() << ", hasCLMUL == " << HasCLMUL() << ", isP4 == " << isP4 << ", cacheLineSize == " << cacheLineSize;
std::cout << ", AESNI_INTRINSICS == " << CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE << std::endl;
#endif
if (!pass)
{
std::cout << "Some critical setting in config.h is in error. Please fix it and recompile." << std::endl;
abort();
}
return pass;
}
bool TestOS_RNG() bool TestOS_RNG()
{ {
bool pass = true; bool pass = true;
@ -1313,7 +1172,7 @@ bool ValidateBaseCode()
"39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673" "39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673"
"3765377638504879382F5431397666342B6672372F50332B0A"; "3765377638504879382F5431397666342B6672372F50332B0A";
std::cout << "\nBase64, base32 and hex coding validation suite running...\n\n"; std::cout << "\nBase64, base32 and std::hex coding validation suite running...\n\n";
fail = !TestFilter(HexEncoder().Ref(), data, 255, (const byte *)hexEncoded, strlen(hexEncoded)); fail = !TestFilter(HexEncoder().Ref(), data, 255, (const byte *)hexEncoded, strlen(hexEncoded));
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");

9
validat2.cpp
View File

@ -36,7 +36,6 @@
#include "validate.h" #include "validate.h"
USING_NAMESPACE(CryptoPP) USING_NAMESPACE(CryptoPP)
USING_NAMESPACE(std)
class FixedRNG : public RandomNumberGenerator class FixedRNG : public RandomNumberGenerator
{ {
@ -78,7 +77,7 @@ bool ValidateBBS()
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");
for (j=0;j<20;j++) for (j=0;j<20;j++)
std::cout << setw(2) << setfill('0') << hex << (int)buf[j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)buf[j];
std::cout << std::endl; std::cout << std::endl;
bbs.Seek(10); bbs.Seek(10);
@ -88,7 +87,7 @@ bool ValidateBBS()
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");
for (j=0;j<10;j++) for (j=0;j<10;j++)
std::cout << setw(2) << setfill('0') << hex << (int)buf[j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)buf[j];
std::cout << std::endl; std::cout << std::endl;
bbs.Seek(1234567); bbs.Seek(1234567);
@ -98,7 +97,7 @@ bool ValidateBBS()
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");
for (j=0;j<20;j++) for (j=0;j<20;j++)
std::cout << setw(2) << setfill('0') << hex << (int)buf[j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)buf[j];
std::cout << std::endl; std::cout << std::endl;
return pass; return pass;
@ -585,7 +584,7 @@ bool ValidateECP()
{ {
DL_GroupParameters_EC<ECP> params(oid); DL_GroupParameters_EC<ECP> params(oid);
bool fail = !params.Validate(GlobalRNG(), 2); bool fail = !params.Validate(GlobalRNG(), 2);
std::cout << (fail ? "FAILED" : "passed") << " " << dec << params.GetCurve().GetField().MaxElementBitLength() << " bits" << std::endl; std::cout << (fail ? "FAILED" : "passed") << " " << std::dec << params.GetCurve().GetField().MaxElementBitLength() << " bits" << std::endl;
pass = pass && !fail; pass = pass && !fail;
} }

19
validat3.cpp
View File

@ -30,7 +30,6 @@
#include "validate.h" #include "validate.h"
USING_NAMESPACE(CryptoPP) USING_NAMESPACE(CryptoPP)
USING_NAMESPACE(std)
struct HashTestTuple struct HashTestTuple
{ {
@ -53,19 +52,19 @@ bool HashModuleTest(HashTransformation &md, const HashTestTuple *testSet, unsign
for (unsigned int i=0; i<testSetSize; i++) for (unsigned int i=0; i<testSetSize; i++)
{ {
unsigned j; unsigned j;
for (j=0; j<testSet[i].repeatTimes; j++) for (j=0; j<testSet[i].repeatTimes; j++)
md.Update(testSet[i].input, testSet[i].inputLen); md.Update(testSet[i].input, testSet[i].inputLen);
md.Final(digest); md.Final(digest);
fail = !VerifyBufsEqual(digest, testSet[i].output, md.DigestSize()); fail = !VerifyBufsEqual(digest, testSet[i].output, md.DigestSize());
pass = pass && !fail; pass = pass && !fail;
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");
for (j=0; j<md.DigestSize(); j++) for (j=0; j<md.DigestSize(); j++)
std::cout << setw(2) << setfill('0') << hex << (int)digest[j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)digest[j];
std::cout << " \"" << (char *)testSet[i].input << '\"'; std::cout << " \"" << (char *)testSet[i].input << '\"';
if (testSet[i].repeatTimes != 1) if (testSet[i].repeatTimes != 1)
std::cout << " repeated " << dec << testSet[i].repeatTimes << " times"; std::cout << " repeated " << std::dec << testSet[i].repeatTimes << " times";
std::cout << std::endl; std::cout << std::endl;
} }
@ -374,7 +373,7 @@ bool ValidateMD5MAC()
MD5MAC mac(keys[k]); MD5MAC mac(keys[k]);
std::cout << "\nKEY: "; std::cout << "\nKEY: ";
for (int j=0;j<MD5MAC::KEYLENGTH;j++) for (int j=0;j<MD5MAC::KEYLENGTH;j++)
std::cout << setw(2) << setfill('0') << hex << (int)keys[k][j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)keys[k][j];
std::cout << std::endl << std::endl; std::cout << std::endl << std::endl;
for (int i=0;i<7;i++) for (int i=0;i<7;i++)
{ {
@ -385,7 +384,7 @@ bool ValidateMD5MAC()
pass = pass && !fail; pass = pass && !fail;
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");
for (int j=0;j<MD5MAC::DIGESTSIZE;j++) for (int j=0;j<MD5MAC::DIGESTSIZE;j++)
std::cout << setw(2) << setfill('0') << hex << (int)digest[j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)digest[j];
std::cout << " \"" << TestVals[i] << '\"' << std::endl; std::cout << " \"" << TestVals[i] << '\"' << std::endl;
} }
} }
@ -445,8 +444,8 @@ bool ValidateXMACC()
XMACC_MD5 mac(keys[k], counters[k]); XMACC_MD5 mac(keys[k], counters[k]);
std::cout << "\nKEY: "; std::cout << "\nKEY: ";
for (int j=0;j<XMACC_MD5::KEYLENGTH;j++) for (int j=0;j<XMACC_MD5::KEYLENGTH;j++)
std::cout << setw(2) << setfill('0') << hex << (int)keys[k][j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)keys[k][j];
std::cout << " COUNTER: 0x" << hex << counters[k] << std::endl << std::endl; std::cout << " COUNTER: 0x" << std::hex << counters[k] << std::endl << std::endl;
for (int i=0;i<7;i++) for (int i=0;i<7;i++)
{ {
mac.Update((byte *)TestVals[i], strlen(TestVals[i])); mac.Update((byte *)TestVals[i], strlen(TestVals[i]));
@ -456,7 +455,7 @@ bool ValidateXMACC()
pass = pass && !fail; pass = pass && !fail;
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");
for (int j=0;j<XMACC_MD5::DIGESTSIZE;j++) for (int j=0;j<XMACC_MD5::DIGESTSIZE;j++)
std::cout << setw(2) << setfill('0') << hex << (int)digest[j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)digest[j];
std::cout << " \"" << TestVals[i] << '\"' << std::endl; std::cout << " \"" << TestVals[i] << '\"' << std::endl;
} }
} }
@ -506,7 +505,7 @@ bool ValidateTTMAC()
pass = pass && !fail; pass = pass && !fail;
std::cout << (fail ? "FAILED " : "passed "); std::cout << (fail ? "FAILED " : "passed ");
for (int j=0;j<TTMAC::DIGESTSIZE;j++) for (int j=0;j<TTMAC::DIGESTSIZE;j++)
std::cout << setw(2) << setfill('0') << hex << (int)digest[j]; std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)digest[j];
std::cout << " \"" << TestVals[k] << '\"' << std::endl; std::cout << " \"" << TestVals[k] << '\"' << std::endl;
} }

2
validate.h
View File

@ -6,6 +6,8 @@
bool ValidateAll(bool thorough); bool ValidateAll(bool thorough);
bool TestSettings(); bool TestSettings();
bool TestOS_RNG(); bool TestOS_RNG();
bool TestConversion();
bool TestRotate();
bool ValidateBaseCode(); bool ValidateBaseCode();
bool ValidateCRC32(); bool ValidateCRC32();