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)
# 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))
DLLSRCS = algebra.cpp algparam.cpp asn.cpp basecode.cpp cbcmac.cpp channels.cpp cryptlib.cpp des.cpp dessp.cpp dh.cpp \

26
smartptr.h
View File

@ -7,25 +7,27 @@
NAMESPACE_BEGIN(CryptoPP)
// Hack ahead. Apple's standard library does not have C++'s unique_ptr. We can't test
// for unique_ptr directly because some of the Clangs on Apple fail the same way.
// However, modern standard libraries have <forward_list>, so we test for it instead.
// Hack ahead. Apple's standard library does not have C++'s unique_ptr in C++11. We can't
// test for unique_ptr directly because some of the non-Apple Clangs on OS X fail the same
// 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.
#if (__cplusplus >= 201103L) || (_MSC_VER >= 1600)
# if defined(__clang__) && (__has_include(<forward_list>))
# define CRYPTOPP_HAVE_UNIQUE_PTR 1
# else
# define CRYPTOPP_HAVE_UNIQUE_PTR 1
# if defined(__clang__)
# if (__has_include(<forward_list>))
# define CRYPTOPP_HAVE_UNIQUE_PTR 1
# endif
# else
# define CRYPTOPP_HAVE_UNIQUE_PTR 1
# endif
#endif
// The result of below is a CryptoPP::auto_ptr in both cases
#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>;
#else
// do nothing; use auto_ptr
using std::auto_ptr;
#endif
template <class T> class simple_ptr
@ -79,7 +81,7 @@ public:
T *old_p = m_p;
m_p = 0;
return old_p;
}
}
void reset(T *p = 0);
@ -175,7 +177,7 @@ protected:
};
template <class T> counted_ptr<T>::counted_ptr(T *p)
: m_p(p)
: m_p(p)
{
if (m_p)
m_p->m_referenceCount = 1;

279
test.cpp
View File

@ -50,8 +50,8 @@
#endif
#ifdef __BORLANDC__
#pragma comment(lib, "cryptlib_bds.lib")
#pragma comment(lib, "ws2_32.lib")
# pragma comment(lib, "cryptlib_bds.lib")
# pragma comment(lib, "ws2_32.lib")
#endif
USING_NAMESPACE(CryptoPP)
@ -113,31 +113,31 @@ struct DebugTrapHandler
struct sigaction old_handler, new_handler;
memset(&old_handler, 0x00, sizeof(old_handler));
memset(&new_handler, 0x00, sizeof(new_handler));
do
{
int ret = 0;
ret = sigaction (SIGTRAP, NULL, &old_handler);
if (ret != 0) break; // Failed
// Don't step on another's handler
if (old_handler.sa_handler != NULL) break;
// Set up the structure to specify the null action.
new_handler.sa_handler = &DebugTrapHandler::NullHandler;
new_handler.sa_flags = 0;
ret = sigemptyset (&new_handler.sa_mask);
if (ret != 0) break; // Failed
// Install it
// Install i
ret = sigaction (SIGTRAP, &new_handler, NULL);
if (ret != 0) break; // Failed
} while(0);
}
static void NullHandler(int /*unused*/) { }
};
@ -170,7 +170,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
#if defined(__MWERKS__) && defined(macintosh)
argc = ccommand(&argv);
#endif
CRYPTOPP_UNUSED(argc), CRYPTOPP_UNUSED(argv);
try
@ -193,16 +193,16 @@ int CRYPTOPP_API main(int argc, char *argv[])
char seed[1024], privFilename[128], pubFilename[128];
unsigned int keyLength;
cout << "Key length in bits: ";
std::cout << "Key length in bits: ";
cin >> keyLength;
cout << "\nSave private key to file: ";
std::cout << "\nSave private key to file: ";
cin >> privFilename;
cout << "\nSave public key to file: ";
std::cout << "\nSave public key to file: ";
cin >> pubFilename;
cout << "\nRandom Seed: ";
std::cout << "\nRandom Seed: ";
ws(cin);
cin.getline(seed, 1024);
@ -213,38 +213,38 @@ int CRYPTOPP_API main(int argc, char *argv[])
else if (command == "rv")
{
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")
{
char privFilename[128], pubFilename[128];
char seed[1024], message[1024];
cout << "Private key file: ";
std::cout << "Private key file: ";
cin >> privFilename;
cout << "\nPublic key file: ";
std::cout << "\nPublic key file: ";
cin >> pubFilename;
cout << "\nRandom Seed: ";
std::cout << "\nRandom Seed: ";
ws(cin);
cin.getline(seed, 1024);
cout << "\nMessage: ";
std::cout << "\nMessage: ";
cin.getline(message, 1024);
string ciphertext = RSAEncryptString(pubFilename, seed, message);
cout << "\nCiphertext: " << ciphertext << endl;
std::cout << "\nCiphertext: " << ciphertext << std::endl;
string decrypted = RSADecryptString(privFilename, ciphertext.c_str());
cout << "\nDecrypted: " << decrypted << endl;
std::cout << "\nDecrypted: " << decrypted << std::endl;
}
else if (command == "mt")
{
MaurerRandomnessTest mt;
FileStore fs(argv[2]);
fs.TransferAllTo(mt);
cout << "Maurer Test Value: " << mt.GetTestValue() << endl;
std::cout << "Maurer Test Value: " << mt.GetTestValue() << std::endl;
}
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();
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;
}
@ -269,7 +269,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
word16 optionalHeaderMagic = *(word16 *)(buf+optionalHeaderPos);
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;
}
word32 checksumPos = optionalHeaderPos + 64;
@ -277,14 +277,14 @@ int CRYPTOPP_API main(int argc, char *argv[])
word32 certificateTablePos = *(word32 *)(buf+certificateTableDirectoryPos);
word32 certificateTableSize = *(word32 *)(buf+certificateTableDirectoryPos+4);
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
byte mac[] = CRYPTOPP_DUMMY_DLL_MAC;
byte *found = std::search(buf.begin(), buf.end(), mac+0, mac+sizeof(mac));
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;
}
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());
// 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.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
char passPhrase[MAX_PHRASE_LENGTH], plaintext[1024];
cout << "Passphrase: ";
std::cout << "Passphrase: ";
cin.getline(passPhrase, MAX_PHRASE_LENGTH);
cout << "\nPlaintext: ";
std::cout << "\nPlaintext: ";
cin.getline(plaintext, 1024);
string ciphertext = EncryptString(plaintext, passPhrase);
cout << "\nCiphertext: " << ciphertext << endl;
std::cout << "\nCiphertext: " << ciphertext << std::endl;
string decrypted = DecryptString(ciphertext.c_str(), passPhrase);
cout << "\nDecrypted: " << decrypted << endl;
std::cout << "\nDecrypted: " << decrypted << std::endl;
return 0;
}
@ -343,7 +343,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
else if (command == "e" || command == "d")
{
char passPhrase[MAX_PHRASE_LENGTH];
cout << "Passphrase: ";
std::cout << "Passphrase: ";
cin.getline(passPhrase, MAX_PHRASE_LENGTH);
if (command == "e")
EncryptFile(argv[2], argv[3], passPhrase);
@ -353,7 +353,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
else if (command == "ss")
{
char seed[1024];
cout << "\nRandom Seed: ";
std::cout << "\nRandom Seed: ";
ws(cin);
cin.getline(seed, 1024);
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);
else
{
cerr << "AdhocTest not defined.\n";
std::cerr << "AdhocTest not defined.\n";
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]);
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;
}
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
{
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 0;
}
catch(CryptoPP::Exception &e)
{
cout << "\nCryptoPP::Exception caught: " << e.what() << endl;
std::cout << "\nCryptoPP::Exception caught: " << e.what() << std::endl;
return -1;
}
catch(std::exception &e)
{
cout << "\nstd::exception caught: " << e.what() << endl;
std::cout << "\nstd::exception caught: " << e.what() << std::endl;
return -2;
}
}
@ -431,7 +431,7 @@ void FIPS140_GenerateRandomFiles()
for (unsigned int i=0; i<100000; i++)
store.TransferTo(FileSink((IntToString(i) + ".rnd").c_str()).Ref(), 20000);
#else
cout << "OS provided RNG not available.\n";
std::cout << "OS provided RNG not available.\n";
exit(-1);
#endif
}
@ -530,12 +530,12 @@ void DigestFile(const char *filename)
channelSwitch->AddDefaultRoute(*filters[i]);
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++)
{
cout << filters[i]->AlgorithmName() << ": ";
std::cout << filters[i]->AlgorithmName() << ": ";
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;
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());
}
else
@ -553,7 +553,7 @@ void HmacFile(const char *hexKey, const char *file)
StringSource(hexKey, true, new HexDecoder(new StringSink(decodedKey)));
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)
@ -701,17 +701,17 @@ void InformationRecoverFile(int threshold, const char *outFilename, char *const
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
//
// Source ----> Gzip ------> Sink
// \ |
// \ Gunzip
// \ |
// \ v
// Source --------> Gzip --------> Sink
// \ |
// \ Gunzip
// \ |
// \ v
// > ComparisonFilter
EqualityComparisonFilter comparison;
Gunzip gunzip(new ChannelSwitch(comparison, "0"));
@ -770,18 +770,18 @@ void ForwardTcpPort(const char *sourcePortName, const char *destinationHost, con
sockListen.Bind(sourcePort);
setsockopt(sockListen, IPPROTO_TCP, TCP_NODELAY, "\x01", 1);
cout << "Listing on port " << sourcePort << ".\n";
std::cout << "Listing on port " << sourcePort << ".\n";
sockListen.Listen();
sockListen.Accept(sockSource);
cout << "Connection accepted on port " << sourcePort << ".\n";
std::cout << "Connection accepted on port " << sourcePort << ".\n";
sockListen.CloseSocket();
cout << "Making connection to " << destinationHost << ", port " << destinationPort << ".\n";
std::cout << "Making connection to " << destinationHost << ", port " << destinationPort << ".\n";
sockDestination.Create();
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 in(sockDestination, false, new SocketSink(sockSource));
@ -799,22 +799,22 @@ void ForwardTcpPort(const char *sourcePortName, const char *destinationHost, con
if (!out.SourceExhausted())
{
cout << "o" << flush;
std::cout << "o" << flush;
out.PumpAll2(false);
if (out.SourceExhausted())
cout << "EOF received on source socket.\n";
std::cout << "EOF received on source socket.\n";
}
if (!in.SourceExhausted())
{
cout << "i" << flush;
std::cout << "i" << flush;
in.PumpAll2(false);
if (in.SourceExhausted())
cout << "EOF received on destination socket.\n";
std::cout << "EOF received on destination socket.\n";
}
}
#else
cout << "Socket support was not enabled at compile time.\n";
std::cout << "Socket support was not enabled at compile time.\n";
exit(-1);
#endif
}
@ -826,7 +826,7 @@ bool Validate(int alg, bool thorough, const char *seedInput)
std::string seed = seedInput ? std::string(seedInput) : IntToString(time(NULL));
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());
#ifdef _OPENMP
@ -836,88 +836,91 @@ bool Validate(int alg, bool thorough, const char *seedInput)
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
cout << endl;
std::cout << std::endl;
switch (alg)
{
case 0: result = ValidateAll(thorough); break;
case 1: result = TestSettings(); break;
case 2: result = TestOS_RNG(); break;
case 3: result = ValidateMD5(); break;
case 4: result = ValidateSHA(); break;
case 5: result = ValidateDES(); break;
case 6: result = ValidateIDEA(); break;
case 7: result = ValidateARC4(); break;
case 8: result = ValidateRC5(); break;
case 9: result = ValidateBlowfish(); break;
// case 10: result = ValidateDiamond2(); break;
case 11: result = ValidateThreeWay(); break;
case 12: result = ValidateBBS(); break;
case 13: result = ValidateDH(); break;
case 14: result = ValidateRSA(); break;
case 15: result = ValidateElGamal(); break;
case 16: result = ValidateDSA(thorough); break;
// case 17: result = ValidateHAVAL(); break;
case 18: result = ValidateSAFER(); break;
case 19: result = ValidateLUC(); break;
case 20: result = ValidateRabin(); break;
// case 21: result = ValidateBlumGoldwasser(); break;
case 22: result = ValidateECP(); break;
case 23: result = ValidateEC2N(); break;
// case 24: result = ValidateMD5MAC(); break;
case 25: result = ValidateGOST(); break;
case 26: result = ValidateTiger(); break;
case 27: result = ValidateRIPEMD(); break;
case 28: result = ValidateHMAC(); break;
// case 29: result = ValidateXMACC(); break;
case 30: result = ValidateSHARK(); break;
case 32: result = ValidateLUC_DH(); break;
case 33: result = ValidateLUC_DL(); break;
case 34: result = ValidateSEAL(); break;
case 35: result = ValidateCAST(); break;
case 36: result = ValidateSquare(); break;
case 37: result = ValidateRC2(); break;
case 38: result = ValidateRC6(); break;
case 39: result = ValidateMARS(); break;
case 40: result = ValidateRW(); break;
case 41: result = ValidateMD2(); break;
case 42: result = ValidateNR(); break;
case 43: result = ValidateMQV(); break;
case 44: result = ValidateRijndael(); break;
case 45: result = ValidateTwofish(); break;
case 46: result = ValidateSerpent(); break;
case 47: result = ValidateCipherModes(); break;
case 48: result = ValidateCRC32(); break;
case 49: result = ValidateECDSA(); break;
case 50: result = ValidateXTR_DH(); break;
case 51: result = ValidateSKIPJACK(); break;
case 52: result = ValidateSHA2(); break;
case 53: result = ValidatePanama(); break;
case 54: result = ValidateAdler32(); break;
case 55: result = ValidateMD4(); break;
case 56: result = ValidatePBKDF(); break;
case 57: result = ValidateESIGN(); break;
case 58: result = ValidateDLIES(); break;
case 59: result = ValidateBaseCode(); break;
case 60: result = ValidateSHACAL2(); break;
case 61: result = ValidateCamellia(); break;
case 62: result = ValidateWhirlpool(); break;
case 63: result = ValidateTTMAC(); break;
case 64: result = ValidateSalsa(); break;
case 65: result = ValidateSosemanuk(); break;
case 66: result = ValidateVMAC(); break;
case 67: result = ValidateCCM(); break;
case 68: result = ValidateGCM(); break;
case 69: result = ValidateCMAC(); break;
default: return false;
case 0: result = ValidateAll(thorough); break;
case 1: result = TestSettings(); break;
case 70: result = TestRotate(); break;
case 71: result = TestConversion(); break;
case 2: result = TestOS_RNG(); break;
case 3: result = ValidateMD5(); break;
case 4: result = ValidateSHA(); break;
case 5: result = ValidateDES(); break;
case 6: result = ValidateIDEA(); break;
case 7: result = ValidateARC4(); break;
case 8: result = ValidateRC5(); break;
case 9: result = ValidateBlowfish(); break;
// case 10: result = ValidateDiamond2(); break;
case 11: result = ValidateThreeWay(); break;
case 12: result = ValidateBBS(); break;
case 13: result = ValidateDH(); break;
case 14: result = ValidateRSA(); break;
case 15: result = ValidateElGamal(); break;
case 16: result = ValidateDSA(thorough); break;
// case 17: result = ValidateHAVAL(); break;
case 18: result = ValidateSAFER(); break;
case 19: result = ValidateLUC(); break;
case 20: result = ValidateRabin(); break;
// case 21: result = ValidateBlumGoldwasser(); break;
case 22: result = ValidateECP(); break;
case 23: result = ValidateEC2N(); break;
// case 24: result = ValidateMD5MAC(); break;
case 25: result = ValidateGOST(); break;
case 26: result = ValidateTiger(); break;
case 27: result = ValidateRIPEMD(); break;
case 28: result = ValidateHMAC(); break;
// case 29: result = ValidateXMACC(); break;
case 30: result = ValidateSHARK(); break;
case 32: result = ValidateLUC_DH(); break;
case 33: result = ValidateLUC_DL(); break;
case 34: result = ValidateSEAL(); break;
case 35: result = ValidateCAST(); break;
case 36: result = ValidateSquare(); break;
case 37: result = ValidateRC2(); break;
case 38: result = ValidateRC6(); break;
case 39: result = ValidateMARS(); break;
case 40: result = ValidateRW(); break;
case 41: result = ValidateMD2(); break;
case 42: result = ValidateNR(); break;
case 43: result = ValidateMQV(); break;
case 44: result = ValidateRijndael(); break;
case 45: result = ValidateTwofish(); break;
case 46: result = ValidateSerpent(); break;
case 47: result = ValidateCipherModes(); break;
case 48: result = ValidateCRC32(); break;
case 49: result = ValidateECDSA(); break;
case 50: result = ValidateXTR_DH(); break;
case 51: result = ValidateSKIPJACK(); break;
case 52: result = ValidateSHA2(); break;
case 53: result = ValidatePanama(); break;
case 54: result = ValidateAdler32(); break;
case 55: result = ValidateMD4(); break;
case 56: result = ValidatePBKDF(); break;
case 57: result = ValidateESIGN(); break;
case 58: result = ValidateDLIES(); break;
case 59: result = ValidateBaseCode(); break;
case 60: result = ValidateSHACAL2(); break;
case 61: result = ValidateCamellia(); break;
case 62: result = ValidateWhirlpool(); break;
case 63: result = ValidateTTMAC(); break;
case 64: result = ValidateSalsa(); break;
case 65: result = ValidateSosemanuk(); break;
case 66: result = ValidateVMAC(); break;
case 67: result = ValidateCCM(); break;
case 68: result = ValidateGCM(); break;
case 69: result = ValidateCMAC(); break;
case 72: result = ValidateHKDF(); break;
default: return false;
}
time_t endTime = time(NULL);
cout << "\nTest ended at " << asctime(localtime(&endTime));
cout << "Seed used was: " << seed << endl;
std::cout << "\nTest ended at " << asctime(localtime(&endTime));
std::cout << "Seed used was: " << seed << std::endl;
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 CryptoPP::auto_ptr;
using std::auto_ptr;
bool ValidateAll(bool thorough)
{
bool pass=TestSettings();
pass=TestRotate() && pass;
pass=TestConversion() && pass;
pass=TestOS_RNG() && pass;
pass=ValidateCRC32() && pass;
@ -131,146 +130,6 @@ bool ValidateAll(bool thorough)
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 pass = true;
@ -1313,7 +1172,7 @@ bool ValidateBaseCode()
"39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673"
"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));
std::cout << (fail ? "FAILED " : "passed ");

9
validat2.cpp
View File

@ -36,7 +36,6 @@
#include "validate.h"
USING_NAMESPACE(CryptoPP)
USING_NAMESPACE(std)
class FixedRNG : public RandomNumberGenerator
{
@ -78,7 +77,7 @@ bool ValidateBBS()
std::cout << (fail ? "FAILED " : "passed ");
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;
bbs.Seek(10);
@ -88,7 +87,7 @@ bool ValidateBBS()
std::cout << (fail ? "FAILED " : "passed ");
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;
bbs.Seek(1234567);
@ -98,7 +97,7 @@ bool ValidateBBS()
std::cout << (fail ? "FAILED " : "passed ");
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;
return pass;
@ -585,7 +584,7 @@ bool ValidateECP()
{
DL_GroupParameters_EC<ECP> params(oid);
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;
}

19
validat3.cpp
View File

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

2
validate.h
View File

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