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

Add search for test vectors and test data (GH #760)

pull/762/head
Jeffrey Walton 2018-12-07 12:25:52 -05:00
parent 52035583de
commit 1c88fd6f59
No known key found for this signature in database
GPG Key ID: B36AB348921B1838
11 changed files with 184 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
bench3.cpp
View File

@ -273,7 +273,7 @@ void BenchMarkAgreement(const char *name, AuthenticatedKeyAgreementDomain &d, do
template <class SCHEME> template <class SCHEME>
void BenchMarkCrypto(const char *filename, const char *name, double timeTotal) void BenchMarkCrypto(const char *filename, const char *name, double timeTotal)
{ {
FileSource f(filename, true, new HexDecoder); FileSource f(DataDir(filename).c_str(), true, new HexDecoder);
typename SCHEME::Decryptor priv(f); typename SCHEME::Decryptor priv(f);
typename SCHEME::Encryptor pub(priv); typename SCHEME::Encryptor pub(priv);
BenchMarkEncryption(name, pub, timeTotal); BenchMarkEncryption(name, pub, timeTotal);
@ -283,7 +283,7 @@ void BenchMarkCrypto(const char *filename, const char *name, double timeTotal)
template <class SCHEME> template <class SCHEME>
void BenchMarkSignature(const char *filename, const char *name, double timeTotal) void BenchMarkSignature(const char *filename, const char *name, double timeTotal)
{ {
FileSource f(filename, true, new HexDecoder); FileSource f(DataDir(filename).c_str(), true, new HexDecoder);
typename SCHEME::Signer priv(f); typename SCHEME::Signer priv(f);
typename SCHEME::Verifier pub(priv); typename SCHEME::Verifier pub(priv);
BenchMarkSigning(name, priv, timeTotal); BenchMarkSigning(name, priv, timeTotal);
@ -293,7 +293,7 @@ void BenchMarkSignature(const char *filename, const char *name, double timeTotal
template <class D> template <class D>
void BenchMarkKeyAgreement(const char *filename, const char *name, double timeTotal) void BenchMarkKeyAgreement(const char *filename, const char *name, double timeTotal)
{ {
FileSource f(filename, true, new HexDecoder); FileSource f(DataDir(filename).c_str(), true, new HexDecoder);
D d(f); D d(f);
BenchMarkKeyGen(name, d, timeTotal); BenchMarkKeyGen(name, d, timeTotal);
BenchMarkAgreement(name, d, timeTotal); BenchMarkAgreement(name, d, timeTotal);
@ -318,63 +318,63 @@ void Benchmark3(double t, double hertz)
std::cout << "\n<TBODY style=\"background: white;\">"; std::cout << "\n<TBODY style=\"background: white;\">";
{ {
BenchMarkCrypto<RSAES<OAEP<SHA1> > >(CRYPTOPP_DATA_DIR "TestData/rsa1024.dat", "RSA 1024", t); BenchMarkCrypto<RSAES<OAEP<SHA1> > >("TestData/rsa1024.dat", "RSA 1024", t);
BenchMarkCrypto<LUCES<OAEP<SHA1> > >(CRYPTOPP_DATA_DIR "TestData/luc1024.dat", "LUC 1024", t); BenchMarkCrypto<LUCES<OAEP<SHA1> > >("TestData/luc1024.dat", "LUC 1024", t);
BenchMarkCrypto<DLIES<> >(CRYPTOPP_DATA_DIR "TestData/dlie1024.dat", "DLIES 1024", t); BenchMarkCrypto<DLIES<> >("TestData/dlie1024.dat", "DLIES 1024", t);
BenchMarkCrypto<LUC_IES<> >(CRYPTOPP_DATA_DIR "TestData/lucc512.dat", "LUCELG 512", t); BenchMarkCrypto<LUC_IES<> >("TestData/lucc512.dat", "LUCELG 512", t);
} }
std::cout << "\n<TBODY style=\"background: yellow;\">"; std::cout << "\n<TBODY style=\"background: yellow;\">";
{ {
BenchMarkCrypto<RSAES<OAEP<SHA1> > >(CRYPTOPP_DATA_DIR "TestData/rsa2048.dat", "RSA 2048", t); BenchMarkCrypto<RSAES<OAEP<SHA1> > >("TestData/rsa2048.dat", "RSA 2048", t);
BenchMarkCrypto<LUCES<OAEP<SHA1> > >(CRYPTOPP_DATA_DIR "TestData/luc2048.dat", "LUC 2048", t); BenchMarkCrypto<LUCES<OAEP<SHA1> > >("TestData/luc2048.dat", "LUC 2048", t);
BenchMarkCrypto<DLIES<> >(CRYPTOPP_DATA_DIR "TestData/dlie2048.dat", "DLIES 2048", t); BenchMarkCrypto<DLIES<> >("TestData/dlie2048.dat", "DLIES 2048", t);
BenchMarkCrypto<LUC_IES<> >(CRYPTOPP_DATA_DIR "TestData/lucc1024.dat", "LUCELG 1024", t); BenchMarkCrypto<LUC_IES<> >("TestData/lucc1024.dat", "LUCELG 1024", t);
} }
std::cout << "\n<TBODY style=\"background: white;\">"; std::cout << "\n<TBODY style=\"background: white;\">";
{ {
BenchMarkSignature<RSASS<PSSR, SHA1> >(CRYPTOPP_DATA_DIR "TestData/rsa1024.dat", "RSA 1024", t); BenchMarkSignature<RSASS<PSSR, SHA1> >("TestData/rsa1024.dat", "RSA 1024", t);
BenchMarkSignature<RWSS<PSSR, SHA1> >(CRYPTOPP_DATA_DIR "TestData/rw1024.dat", "RW 1024", t); BenchMarkSignature<RWSS<PSSR, SHA1> >("TestData/rw1024.dat", "RW 1024", t);
BenchMarkSignature<LUCSS<PSSR, SHA1> >(CRYPTOPP_DATA_DIR "TestData/luc1024.dat", "LUC 1024", t); BenchMarkSignature<LUCSS<PSSR, SHA1> >("TestData/luc1024.dat", "LUC 1024", t);
BenchMarkSignature<NR<SHA1> >(CRYPTOPP_DATA_DIR "TestData/nr1024.dat", "NR 1024", t); BenchMarkSignature<NR<SHA1> >("TestData/nr1024.dat", "NR 1024", t);
BenchMarkSignature<DSA>(CRYPTOPP_DATA_DIR "TestData/dsa1024.dat", "DSA 1024", t); BenchMarkSignature<DSA>("TestData/dsa1024.dat", "DSA 1024", t);
BenchMarkSignature<LUC_HMP<SHA1> >(CRYPTOPP_DATA_DIR "TestData/lucs512.dat", "LUC-HMP 512", t); BenchMarkSignature<LUC_HMP<SHA1> >("TestData/lucs512.dat", "LUC-HMP 512", t);
BenchMarkSignature<ESIGN<SHA1> >(CRYPTOPP_DATA_DIR "TestData/esig1023.dat", "ESIGN 1023", t); BenchMarkSignature<ESIGN<SHA1> >("TestData/esig1023.dat", "ESIGN 1023", t);
BenchMarkSignature<ESIGN<SHA1> >(CRYPTOPP_DATA_DIR "TestData/esig1536.dat", "ESIGN 1536", t); BenchMarkSignature<ESIGN<SHA1> >("TestData/esig1536.dat", "ESIGN 1536", t);
} }
std::cout << "\n<TBODY style=\"background: yellow;\">"; std::cout << "\n<TBODY style=\"background: yellow;\">";
{ {
BenchMarkSignature<RSASS<PSSR, SHA1> >(CRYPTOPP_DATA_DIR "TestData/rsa2048.dat", "RSA 2048", t); BenchMarkSignature<RSASS<PSSR, SHA1> >("TestData/rsa2048.dat", "RSA 2048", t);
BenchMarkSignature<RWSS<PSSR, SHA1> >(CRYPTOPP_DATA_DIR "TestData/rw2048.dat", "RW 2048", t); BenchMarkSignature<RWSS<PSSR, SHA1> >("TestData/rw2048.dat", "RW 2048", t);
BenchMarkSignature<LUCSS<PSSR, SHA1> >(CRYPTOPP_DATA_DIR "TestData/luc2048.dat", "LUC 2048", t); BenchMarkSignature<LUCSS<PSSR, SHA1> >("TestData/luc2048.dat", "LUC 2048", t);
BenchMarkSignature<NR<SHA1> >(CRYPTOPP_DATA_DIR "TestData/nr2048.dat", "NR 2048", t); BenchMarkSignature<NR<SHA1> >("TestData/nr2048.dat", "NR 2048", t);
BenchMarkSignature<LUC_HMP<SHA1> >(CRYPTOPP_DATA_DIR "TestData/lucs1024.dat", "LUC-HMP 1024", t); BenchMarkSignature<LUC_HMP<SHA1> >("TestData/lucs1024.dat", "LUC-HMP 1024", t);
BenchMarkSignature<ESIGN<SHA1> >(CRYPTOPP_DATA_DIR "TestData/esig2046.dat", "ESIGN 2046", t); BenchMarkSignature<ESIGN<SHA1> >("TestData/esig2046.dat", "ESIGN 2046", t);
} }
std::cout << "\n<TBODY style=\"background: white;\">"; std::cout << "\n<TBODY style=\"background: white;\">";
{ {
BenchMarkKeyAgreement<XTR_DH>(CRYPTOPP_DATA_DIR "TestData/xtrdh171.dat", "XTR-DH 171", t); BenchMarkKeyAgreement<XTR_DH>("TestData/xtrdh171.dat", "XTR-DH 171", t);
BenchMarkKeyAgreement<XTR_DH>(CRYPTOPP_DATA_DIR "TestData/xtrdh342.dat", "XTR-DH 342", t); BenchMarkKeyAgreement<XTR_DH>("TestData/xtrdh342.dat", "XTR-DH 342", t);
BenchMarkKeyAgreement<DH>(CRYPTOPP_DATA_DIR "TestData/dh1024.dat", "DH 1024", t); BenchMarkKeyAgreement<DH>("TestData/dh1024.dat", "DH 1024", t);
BenchMarkKeyAgreement<DH>(CRYPTOPP_DATA_DIR "TestData/dh2048.dat", "DH 2048", t); BenchMarkKeyAgreement<DH>("TestData/dh2048.dat", "DH 2048", t);
BenchMarkKeyAgreement<LUC_DH>(CRYPTOPP_DATA_DIR "TestData/lucd512.dat", "LUCDIF 512", t); BenchMarkKeyAgreement<LUC_DH>("TestData/lucd512.dat", "LUCDIF 512", t);
BenchMarkKeyAgreement<LUC_DH>(CRYPTOPP_DATA_DIR "TestData/lucd1024.dat", "LUCDIF 1024", t); BenchMarkKeyAgreement<LUC_DH>("TestData/lucd1024.dat", "LUCDIF 1024", t);
BenchMarkKeyAgreement<MQV>(CRYPTOPP_DATA_DIR "TestData/mqv1024.dat", "MQV 1024", t); BenchMarkKeyAgreement<MQV>("TestData/mqv1024.dat", "MQV 1024", t);
BenchMarkKeyAgreement<MQV>(CRYPTOPP_DATA_DIR "TestData/mqv2048.dat", "MQV 2048", t); BenchMarkKeyAgreement<MQV>("TestData/mqv2048.dat", "MQV 2048", t);
#if 0 #if 0
BenchMarkKeyAgreement<ECHMQV160>(CRYPTOPP_DATA_DIR "TestData/hmqv160.dat", "HMQV P-160", t); BenchMarkKeyAgreement<ECHMQV160>("TestData/hmqv160.dat", "HMQV P-160", t);
BenchMarkKeyAgreement<ECHMQV256>(CRYPTOPP_DATA_DIR "TestData/hmqv256.dat", "HMQV P-256", t); BenchMarkKeyAgreement<ECHMQV256>("TestData/hmqv256.dat", "HMQV P-256", t);
BenchMarkKeyAgreement<ECHMQV384>(CRYPTOPP_DATA_DIR "TestData/hmqv384.dat", "HMQV P-384", t); BenchMarkKeyAgreement<ECHMQV384>("TestData/hmqv384.dat", "HMQV P-384", t);
BenchMarkKeyAgreement<ECHMQV512>(CRYPTOPP_DATA_DIR "TestData/hmqv512.dat", "HMQV P-512", t); BenchMarkKeyAgreement<ECHMQV512>("TestData/hmqv512.dat", "HMQV P-512", t);
BenchMarkKeyAgreement<ECFHMQV160>(CRYPTOPP_DATA_DIR "TestData/fhmqv160.dat", "FHMQV P-160", t); BenchMarkKeyAgreement<ECFHMQV160>("TestData/fhmqv160.dat", "FHMQV P-160", t);
BenchMarkKeyAgreement<ECFHMQV256>(CRYPTOPP_DATA_DIR "TestData/fhmqv256.dat", "FHMQV P-256", t); BenchMarkKeyAgreement<ECFHMQV256>("TestData/fhmqv256.dat", "FHMQV P-256", t);
BenchMarkKeyAgreement<ECFHMQV384>(CRYPTOPP_DATA_DIR "TestData/fhmqv384.dat", "FHMQV P-384", t); BenchMarkKeyAgreement<ECFHMQV384>("TestData/fhmqv384.dat", "FHMQV P-384", t);
BenchMarkKeyAgreement<ECFHMQV512>(CRYPTOPP_DATA_DIR "TestData/fhmqv512.dat", "FHMQV P-512", t); BenchMarkKeyAgreement<ECFHMQV512>("TestData/fhmqv512.dat", "FHMQV P-512", t);
#endif #endif
} }

15
config.h
View File

@ -95,12 +95,23 @@
#define CRYPTOPP_VERSION 710 #define CRYPTOPP_VERSION 710
// Define this if you want to set a prefix for TestData/ and TestVectors/ // Define this if you want to set a prefix for TestData/ and TestVectors/
// Be mindful of the trailing slash since its simple concatenation. // Be sure to add the trailing slash since its simple concatenation.
// g++ ... -DCRYPTOPP_DATA_DIR='"/tmp/cryptopp_test/share/"' // After https://github.com/weidai11/cryptopp/issues/760 the library
// should find the test vectors and data without much effort. It
// will search in "./" and "$ORIGIN/../share/cryptopp" automatically.
#ifndef CRYPTOPP_DATA_DIR #ifndef CRYPTOPP_DATA_DIR
# define CRYPTOPP_DATA_DIR "" # define CRYPTOPP_DATA_DIR ""
#endif #endif
// Define this to disable the test suite from searching for test
// vectors and data in "./" and "$ORIGIN/../share/cryptopp". The
// library will still search in CRYPTOPP_DATA_DIR, regardless.
// Some distros may want to disable this feature. Also see
// https://github.com/weidai11/cryptopp/issues/760
// #ifndef CRYPTOPP_DISABLE_DATA_DIR_SEARCH
// # define CRYPTOPP_DISABLE_DATA_DIR_SEARCH
// #endif
// Define this if you want or need the library's memcpy_s and memmove_s. // Define this if you want or need the library's memcpy_s and memmove_s.
// See http://github.com/weidai11/cryptopp/issues/28. // See http://github.com/weidai11/cryptopp/issues/28.
// #if !defined(CRYPTOPP_WANT_SECURE_LIB) // #if !defined(CRYPTOPP_WANT_SECURE_LIB)

8
datatest.cpp
View File

@ -913,13 +913,7 @@ void OutputNameValuePairs(const NameValuePairs &v)
void TestDataFile(std::string filename, const NameValuePairs &overrideParameters, unsigned int &totalTests, unsigned int &failedTests) void TestDataFile(std::string filename, const NameValuePairs &overrideParameters, unsigned int &totalTests, unsigned int &failedTests)
{ {
static const std::string dataDirectory(CRYPTOPP_DATA_DIR); filename = DataDir(filename);
if (!dataDirectory.empty())
{
if(dataDirectory != filename.substr(0, dataDirectory.length()))
filename.insert(0, dataDirectory);
}
std::ifstream file(filename.c_str()); std::ifstream file(filename.c_str());
if (!file.good()) if (!file.good())
throw Exception(Exception::OTHER_ERROR, "Can not open file " + filename + " for reading"); throw Exception(Exception::OTHER_ERROR, "Can not open file " + filename + " for reading");

2
test.cpp
View File

@ -398,7 +398,7 @@ int scoped_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(CRYPTOPP_DATA_DIR "TestData/usage.dat", true, new FileSink(std::cout)); FileSource usage(DataDir("TestData/usage.dat").c_str(), true, new FileSink(std::cout));
return 1; return 1;
} }
else if (command == "V") else if (command == "V")

14
validat3.cpp
View File

@ -99,8 +99,8 @@ bool ValidateAll(bool thorough)
pass=ValidateMD5() && pass; pass=ValidateMD5() && pass;
pass=ValidateSHA() && pass; pass=ValidateSHA() && pass;
pass=RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/keccak.txt") && pass; pass=RunTestDataFile("TestVectors/keccak.txt") && pass;
pass=RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/sha3.txt") && pass; pass=RunTestDataFile("TestVectors/sha3.txt") && pass;
pass=ValidateHashDRBG() && pass; pass=ValidateHashDRBG() && pass;
pass=ValidateHmacDRBG() && pass; pass=ValidateHmacDRBG() && pass;
@ -158,15 +158,15 @@ bool ValidateAll(bool thorough)
pass=ValidateRabbit() && pass; pass=ValidateRabbit() && pass;
pass=ValidateHC128() && pass; pass=ValidateHC128() && pass;
pass=ValidateHC256() && pass; pass=ValidateHC256() && pass;
pass=RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/seed.txt") && pass; pass=RunTestDataFile("TestVectors/seed.txt") && pass;
pass=RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/threefish.txt") && pass; pass=RunTestDataFile("TestVectors/threefish.txt") && pass;
pass=RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/kalyna.txt") && pass; pass=RunTestDataFile("TestVectors/kalyna.txt") && pass;
pass=RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/sm4.txt") && pass; pass=RunTestDataFile("TestVectors/sm4.txt") && pass;
pass=ValidateVMAC() && pass; pass=ValidateVMAC() && pass;
pass=ValidateCCM() && pass; pass=ValidateCCM() && pass;
pass=ValidateGCM() && pass; pass=ValidateGCM() && pass;
pass=ValidateCMAC() && pass; pass=ValidateCMAC() && pass;
pass=RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/eax.txt") && pass; pass=RunTestDataFile("TestVectors/eax.txt") && pass;
pass=ValidateBBS() && pass; pass=ValidateBBS() && pass;
pass=ValidateDH() && pass; pass=ValidateDH() && pass;

78
validat4.cpp
View File

@ -327,12 +327,12 @@ bool ValidateDES()
{ {
std::cout << "\nDES validation suite running...\n\n"; std::cout << "\nDES validation suite running...\n\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/descert.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/descert.dat").c_str(), true, new HexDecoder);
bool pass = BlockTransformationTest(FixedRoundsCipherFactory<DESEncryption, DESDecryption>(), valdata); bool pass = BlockTransformationTest(FixedRoundsCipherFactory<DESEncryption, DESDecryption>(), valdata);
std::cout << "\nTesting EDE2, EDE3, and XEX3 variants...\n\n"; std::cout << "\nTesting EDE2, EDE3, and XEX3 variants...\n\n";
FileSource valdata1(CRYPTOPP_DATA_DIR "TestData/3desval.dat", true, new HexDecoder); FileSource valdata1(DataDir("TestData/3desval.dat").c_str(), true, new HexDecoder);
pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_EDE2_Encryption, DES_EDE2_Decryption>(), valdata1, 1) && pass; pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_EDE2_Encryption, DES_EDE2_Decryption>(), valdata1, 1) && pass;
pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_EDE3_Encryption, DES_EDE3_Decryption>(), valdata1, 1) && pass; pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_EDE3_Encryption, DES_EDE3_Decryption>(), valdata1, 1) && pass;
pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_XEX3_Encryption, DES_XEX3_Decryption>(), valdata1, 1) && pass; pass = BlockTransformationTest(FixedRoundsCipherFactory<DES_XEX3_Encryption, DES_XEX3_Decryption>(), valdata1, 1) && pass;
@ -649,7 +649,7 @@ bool ValidateIDEA()
{ {
std::cout << "\nIDEA validation suite running...\n\n"; std::cout << "\nIDEA validation suite running...\n\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/ideaval.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/ideaval.dat").c_str(), true, new HexDecoder);
return BlockTransformationTest(FixedRoundsCipherFactory<IDEAEncryption, IDEADecryption>(), valdata); return BlockTransformationTest(FixedRoundsCipherFactory<IDEAEncryption, IDEADecryption>(), valdata);
} }
@ -657,7 +657,7 @@ bool ValidateSAFER()
{ {
std::cout << "\nSAFER validation suite running...\n\n"; std::cout << "\nSAFER validation suite running...\n\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/saferval.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/saferval.dat").c_str(), true, new HexDecoder);
bool pass = true; bool pass = true;
pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_K_Encryption, SAFER_K_Decryption>(8,6), valdata, 4) && pass; pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_K_Encryption, SAFER_K_Decryption>(8,6), valdata, 4) && pass;
pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_K_Encryption, SAFER_K_Decryption>(16,12), valdata, 4) && pass; pass = BlockTransformationTest(VariableRoundsCipherFactory<SAFER_K_Encryption, SAFER_K_Decryption>(16,12), valdata, 4) && pass;
@ -670,7 +670,7 @@ bool ValidateRC2()
{ {
std::cout << "\nRC2 validation suite running...\n\n"; std::cout << "\nRC2 validation suite running...\n\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/rc2val.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/rc2val.dat").c_str(), true, new HexDecoder);
HexEncoder output(new FileSink(std::cout)); HexEncoder output(new FileSink(std::cout));
SecByteBlock plain(RC2Encryption::BLOCKSIZE), cipher(RC2Encryption::BLOCKSIZE), out(RC2Encryption::BLOCKSIZE), outplain(RC2Encryption::BLOCKSIZE); SecByteBlock plain(RC2Encryption::BLOCKSIZE), cipher(RC2Encryption::BLOCKSIZE), out(RC2Encryption::BLOCKSIZE), outplain(RC2Encryption::BLOCKSIZE);
SecByteBlock key(128); SecByteBlock key(128);
@ -899,7 +899,7 @@ bool ValidateRC5()
pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2; pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/rc5val.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/rc5val.dat").c_str(), true, new HexDecoder);
return BlockTransformationTest(VariableRoundsCipherFactory<RC5Encryption, RC5Decryption>(16, 12), valdata) && pass1 && pass2; return BlockTransformationTest(VariableRoundsCipherFactory<RC5Encryption, RC5Decryption>(16, 12), valdata) && pass1 && pass2;
} }
@ -929,7 +929,7 @@ bool ValidateRC6()
pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2; pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/rc6val.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/rc6val.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(16), valdata, 2) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(16), valdata, 2) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(24), valdata, 2) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(24), valdata, 2) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(32), valdata, 2) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RC6Encryption, RC6Decryption>(32), valdata, 2) && pass3;
@ -962,7 +962,7 @@ bool ValidateMARS()
pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2; pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/marsval.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/marsval.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(16), valdata, 4) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(16), valdata, 4) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(24), valdata, 3) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(24), valdata, 3) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(32), valdata, 2) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<MARSEncryption, MARSDecryption>(32), valdata, 2) && pass3;
@ -995,11 +995,11 @@ bool ValidateRijndael()
pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2; pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/rijndael.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/rijndael.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(16), valdata, 4) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(16), valdata, 4) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(24), valdata, 3) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(24), valdata, 3) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(32), valdata, 2) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<RijndaelEncryption, RijndaelDecryption>(32), valdata, 2) && pass3;
pass3 = RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/aes.txt") && pass3; pass3 = RunTestDataFile("TestVectors/aes.txt") && pass3;
return pass1 && pass2 && pass3; return pass1 && pass2 && pass3;
} }
@ -1025,7 +1025,7 @@ bool ValidateTwofish()
pass2 = dec.StaticGetValidKeyLength(128) == 32 && pass2; pass2 = dec.StaticGetValidKeyLength(128) == 32 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/twofishv.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/twofishv.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(16), valdata, 4) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(16), valdata, 4) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(24), valdata, 3) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(24), valdata, 3) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(32), valdata, 2) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<TwofishEncryption, TwofishDecryption>(32), valdata, 2) && pass3;
@ -1054,7 +1054,7 @@ bool ValidateSerpent()
pass2 = dec.StaticGetValidKeyLength(128) == 32 && pass2; pass2 = dec.StaticGetValidKeyLength(128) == 32 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/serpentv.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/serpentv.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(16), valdata, 5) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(16), valdata, 5) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(24), valdata, 4) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(24), valdata, 4) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(32), valdata, 3) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SerpentEncryption, SerpentDecryption>(32), valdata, 3) && pass3;
@ -1142,7 +1142,7 @@ bool ValidateThreeWay()
pass2 = dec.StaticGetValidKeyLength(16) == 12 && pass2; pass2 = dec.StaticGetValidKeyLength(16) == 12 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/3wayval.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/3wayval.dat").c_str(), true, new HexDecoder);
return BlockTransformationTest(FixedRoundsCipherFactory<ThreeWayEncryption, ThreeWayDecryption>(), valdata) && pass1 && pass2; return BlockTransformationTest(FixedRoundsCipherFactory<ThreeWayEncryption, ThreeWayDecryption>(), valdata) && pass1 && pass2;
} }
@ -1168,7 +1168,7 @@ bool ValidateGOST()
pass2 = dec.StaticGetValidKeyLength(64) == 32 && pass2; pass2 = dec.StaticGetValidKeyLength(64) == 32 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/gostval.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/gostval.dat").c_str(), true, new HexDecoder);
return BlockTransformationTest(FixedRoundsCipherFactory<GOSTEncryption, GOSTDecryption>(), valdata) && pass1 && pass2; return BlockTransformationTest(FixedRoundsCipherFactory<GOSTEncryption, GOSTDecryption>(), valdata) && pass1 && pass2;
} }
@ -1194,7 +1194,7 @@ bool ValidateSHARK()
pass2 = dec.StaticGetValidKeyLength(32) == 16 && pass2; pass2 = dec.StaticGetValidKeyLength(32) == 16 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/sharkval.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/sharkval.dat").c_str(), true, new HexDecoder);
return BlockTransformationTest(FixedRoundsCipherFactory<SHARKEncryption, SHARKDecryption>(), valdata) && pass1 && pass2; return BlockTransformationTest(FixedRoundsCipherFactory<SHARKEncryption, SHARKDecryption>(), valdata) && pass1 && pass2;
} }
@ -1220,7 +1220,7 @@ bool ValidateCAST()
pass2 = dec1.StaticGetValidKeyLength(17) == 16 && pass2; pass2 = dec1.StaticGetValidKeyLength(17) == 16 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource val128(CRYPTOPP_DATA_DIR "TestData/cast128v.dat", true, new HexDecoder); FileSource val128(DataDir("TestData/cast128v.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(16), val128, 1) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(16), val128, 1) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(10), val128, 1) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(10), val128, 1) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(5), val128, 1) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CAST128Encryption, CAST128Decryption>(5), val128, 1) && pass3;
@ -1253,7 +1253,7 @@ bool ValidateCAST()
pass5 = dec2.StaticGetValidKeyLength(33) == 32 && pass5; pass5 = dec2.StaticGetValidKeyLength(33) == 32 && pass5;
std::cout << (pass4 && pass5 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass4 && pass5 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource val256(CRYPTOPP_DATA_DIR "TestData/cast256v.dat", true, new HexDecoder); FileSource val256(DataDir("TestData/cast256v.dat").c_str(), true, new HexDecoder);
pass6 = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(16), val256, 1) && pass6; pass6 = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(16), val256, 1) && pass6;
pass6 = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(24), val256, 1) && pass6; pass6 = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(24), val256, 1) && pass6;
pass6 = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(32), val256, 1) && pass6; pass6 = BlockTransformationTest(FixedRoundsCipherFactory<CAST256Encryption, CAST256Decryption>(32), val256, 1) && pass6;
@ -1279,7 +1279,7 @@ bool ValidateSquare()
pass2 = dec.StaticGetValidKeyLength(17) == 16 && pass2; pass2 = dec.StaticGetValidKeyLength(17) == 16 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/squareva.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/squareva.dat").c_str(), true, new HexDecoder);
return BlockTransformationTest(FixedRoundsCipherFactory<SquareEncryption, SquareDecryption>(), valdata) && pass1 && pass2; return BlockTransformationTest(FixedRoundsCipherFactory<SquareEncryption, SquareDecryption>(), valdata) && pass1 && pass2;
} }
@ -1301,7 +1301,7 @@ bool ValidateSKIPJACK()
pass2 = dec.StaticGetValidKeyLength(16) == 10 && pass2; pass2 = dec.StaticGetValidKeyLength(16) == 10 && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/skipjack.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/skipjack.dat").c_str(), true, new HexDecoder);
return BlockTransformationTest(FixedRoundsCipherFactory<SKIPJACKEncryption, SKIPJACKDecryption>(), valdata) && pass1 && pass2; return BlockTransformationTest(FixedRoundsCipherFactory<SKIPJACKEncryption, SKIPJACKDecryption>(), valdata) && pass1 && pass2;
} }
@ -1615,7 +1615,7 @@ bool ValidateSHACAL2()
pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2; pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/shacal2v.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/shacal2v.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SHACAL2Encryption, SHACAL2Decryption>(16), valdata, 4) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SHACAL2Encryption, SHACAL2Decryption>(16), valdata, 4) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SHACAL2Encryption, SHACAL2Decryption>(64), valdata, 10) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<SHACAL2Encryption, SHACAL2Decryption>(64), valdata, 10) && pass3;
return pass1 && pass2 && pass3; return pass1 && pass2 && pass3;
@ -1647,7 +1647,7 @@ bool ValidateARIA()
pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2; pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/aria.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/aria.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<ARIAEncryption, ARIADecryption>(16), valdata, 15) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<ARIAEncryption, ARIADecryption>(16), valdata, 15) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<ARIAEncryption, ARIADecryption>(24), valdata, 15) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<ARIAEncryption, ARIADecryption>(24), valdata, 15) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<ARIAEncryption, ARIADecryption>(32), valdata, 15) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<ARIAEncryption, ARIADecryption>(32), valdata, 15) && pass3;
@ -1658,42 +1658,42 @@ bool ValidateSIMECK()
{ {
std::cout << "\nSIMECK validation suite running...\n"; std::cout << "\nSIMECK validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/simeck.txt"); return RunTestDataFile("TestVectors/simeck.txt");
} }
bool ValidateCHAM() bool ValidateCHAM()
{ {
std::cout << "\nCHAM validation suite running...\n"; std::cout << "\nCHAM validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/cham.txt"); return RunTestDataFile("TestVectors/cham.txt");
} }
bool ValidateHIGHT() bool ValidateHIGHT()
{ {
std::cout << "\nHIGHT validation suite running...\n"; std::cout << "\nHIGHT validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/hight.txt"); return RunTestDataFile("TestVectors/hight.txt");
} }
bool ValidateLEA() bool ValidateLEA()
{ {
std::cout << "\nLEA validation suite running...\n"; std::cout << "\nLEA validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/lea.txt"); return RunTestDataFile("TestVectors/lea.txt");
} }
bool ValidateSIMON() bool ValidateSIMON()
{ {
std::cout << "\nSIMON validation suite running...\n"; std::cout << "\nSIMON validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/simon.txt"); return RunTestDataFile("TestVectors/simon.txt");
} }
bool ValidateSPECK() bool ValidateSPECK()
{ {
std::cout << "\nSPECK validation suite running...\n"; std::cout << "\nSPECK validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/speck.txt"); return RunTestDataFile("TestVectors/speck.txt");
} }
bool ValidateCamellia() bool ValidateCamellia()
@ -1722,7 +1722,7 @@ bool ValidateCamellia()
pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2; pass2 = dec.StaticGetValidKeyLength(SIZE_MAX) == dec.MaxKeyLength() && pass2;
std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n"; std::cout << (pass1 && pass2 ? "passed:" : "FAILED:") << " Algorithm key lengths\n";
FileSource valdata(CRYPTOPP_DATA_DIR "TestData/camellia.dat", true, new HexDecoder); FileSource valdata(DataDir("TestData/camellia.dat").c_str(), true, new HexDecoder);
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(16), valdata, 15) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(16), valdata, 15) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(24), valdata, 15) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(24), valdata, 15) && pass3;
pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(32), valdata, 15) && pass3; pass3 = BlockTransformationTest(FixedRoundsCipherFactory<CamelliaEncryption, CamelliaDecryption>(32), valdata, 15) && pass3;
@ -1733,65 +1733,65 @@ bool ValidateSalsa()
{ {
std::cout << "\nSalsa validation suite running...\n"; std::cout << "\nSalsa validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/salsa.txt"); return RunTestDataFile("TestVectors/salsa.txt");
} }
bool ValidateChaCha() bool ValidateChaCha()
{ {
std::cout << "\nChaCha validation suite running...\n"; std::cout << "\nChaCha validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/chacha.txt"); return RunTestDataFile("TestVectors/chacha.txt");
} }
bool ValidateSosemanuk() bool ValidateSosemanuk()
{ {
std::cout << "\nSosemanuk validation suite running...\n"; std::cout << "\nSosemanuk validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/sosemanuk.txt"); return RunTestDataFile("TestVectors/sosemanuk.txt");
} }
bool ValidateRabbit() bool ValidateRabbit()
{ {
std::cout << "\nRabbit validation suite running...\n"; std::cout << "\nRabbit validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/rabbit.txt"); return RunTestDataFile("TestVectors/rabbit.txt");
} }
bool ValidateHC128() bool ValidateHC128()
{ {
std::cout << "\nHC-128 validation suite running...\n"; std::cout << "\nHC-128 validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/hc128.txt"); return RunTestDataFile("TestVectors/hc128.txt");
} }
bool ValidateHC256() bool ValidateHC256()
{ {
std::cout << "\nHC-256 validation suite running...\n"; std::cout << "\nHC-256 validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/hc256.txt"); return RunTestDataFile("TestVectors/hc256.txt");
} }
bool ValidateVMAC() bool ValidateVMAC()
{ {
std::cout << "\nVMAC validation suite running...\n"; std::cout << "\nVMAC validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/vmac.txt"); return RunTestDataFile("TestVectors/vmac.txt");
} }
bool ValidateCCM() bool ValidateCCM()
{ {
std::cout << "\nAES/CCM validation suite running...\n"; std::cout << "\nAES/CCM validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/ccm.txt"); return RunTestDataFile("TestVectors/ccm.txt");
} }
bool ValidateGCM() bool ValidateGCM()
{ {
std::cout << "\nAES/GCM validation suite running...\n"; std::cout << "\nAES/GCM validation suite running...\n";
std::cout << "\n2K tables:"; std::cout << "\n2K tables:";
bool pass = RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/gcm.txt", MakeParameters(Name::TableSize(), (int)2048)); bool pass = RunTestDataFile("TestVectors/gcm.txt", MakeParameters(Name::TableSize(), (int)2048));
std::cout << "\n64K tables:"; std::cout << "\n64K tables:";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/gcm.txt", MakeParameters(Name::TableSize(), (int)64*1024)) && pass; return RunTestDataFile("TestVectors/gcm.txt", MakeParameters(Name::TableSize(), (int)64*1024)) && pass;
} }
bool ValidateCMAC() bool ValidateCMAC()
{ {
std::cout << "\nCMAC validation suite running...\n"; std::cout << "\nCMAC validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/cmac.txt"); return RunTestDataFile("TestVectors/cmac.txt");
} }
NAMESPACE_END // Test NAMESPACE_END // Test

20
validat5.cpp
View File

@ -214,13 +214,19 @@ bool ValidateMD5()
bool ValidateSHA() bool ValidateSHA()
{ {
std::cout << "\nSHA validation suite running...\n"; std::cout << "\nSHA validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/sha.txt"); return RunTestDataFile("TestVectors/sha.txt");
} }
bool ValidateSHA2() bool ValidateSHA2()
{ {
std::cout << "\nSHA validation suite running...\n"; std::cout << "\nSHA-2 validation suite running...\n";
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/sha.txt"); return RunTestDataFile("TestVectors/sha2.txt");
}
bool ValidateSHA3()
{
std::cout << "\nSHA-3 validation suite running...\n";
return RunTestDataFile("TestVectors/sha3.txt");
} }
bool ValidateTiger() bool ValidateTiger()
@ -367,12 +373,12 @@ bool ValidateHAVAL()
bool ValidatePanama() bool ValidatePanama()
{ {
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/panama.txt"); return RunTestDataFile("TestVectors/panama.txt");
} }
bool ValidateWhirlpool() bool ValidateWhirlpool()
{ {
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/whrlpool.txt"); return RunTestDataFile("TestVectors/whrlpool.txt");
} }
#ifdef CRYPTOPP_REMOVED #ifdef CRYPTOPP_REMOVED
@ -441,7 +447,7 @@ bool ValidateMD5MAC()
bool ValidateHMAC() bool ValidateHMAC()
{ {
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/hmac.txt"); return RunTestDataFile("TestVectors/hmac.txt");
} }
#ifdef CRYPTOPP_REMOVED #ifdef CRYPTOPP_REMOVED
@ -2016,7 +2022,7 @@ bool ValidateBLAKE2b()
bool ValidateSM3() bool ValidateSM3()
{ {
return RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/sm3.txt"); return RunTestDataFile("TestVectors/sm3.txt");
} }
NAMESPACE_END // Test NAMESPACE_END // Test

20
validat7.cpp
View File

@ -45,7 +45,7 @@ bool ValidateDH()
{ {
std::cout << "\nDH validation suite running...\n\n"; std::cout << "\nDH validation suite running...\n\n";
FileSource f(CRYPTOPP_DATA_DIR "TestData/dh1024.dat", true, new HexDecoder()); FileSource f(DataDir("TestData/dh1024.dat").c_str(), true, new HexDecoder);
DH dh(f); DH dh(f);
return SimpleKeyAgreementValidate(dh); return SimpleKeyAgreementValidate(dh);
} }
@ -54,7 +54,7 @@ bool ValidateMQV()
{ {
std::cout << "\nMQV validation suite running...\n\n"; std::cout << "\nMQV validation suite running...\n\n";
FileSource f(CRYPTOPP_DATA_DIR "TestData/mqv1024.dat", true, new HexDecoder()); FileSource f(DataDir("TestData/mqv1024.dat").c_str(), true, new HexDecoder);
MQV mqv(f); MQV mqv(f);
return AuthenticatedKeyAgreementValidate(mqv); return AuthenticatedKeyAgreementValidate(mqv);
} }
@ -64,9 +64,9 @@ bool ValidateHMQV()
std::cout << "\nHMQV validation suite running...\n\n"; std::cout << "\nHMQV validation suite running...\n\n";
ECHMQV256 hmqvB(false); ECHMQV256 hmqvB(false);
FileSource f256(CRYPTOPP_DATA_DIR "TestData/hmqv256.dat", true, new HexDecoder()); FileSource f256(DataDir("TestData/hmqv256.dat").c_str(), true, new HexDecoder);
FileSource f384(CRYPTOPP_DATA_DIR "TestData/hmqv384.dat", true, new HexDecoder()); FileSource f384(DataDir("TestData/hmqv384.dat").c_str(), true, new HexDecoder);
FileSource f512(CRYPTOPP_DATA_DIR "TestData/hmqv512.dat", true, new HexDecoder()); FileSource f512(DataDir("TestData/hmqv512.dat").c_str(), true, new HexDecoder);
hmqvB.AccessGroupParameters().BERDecode(f256); hmqvB.AccessGroupParameters().BERDecode(f256);
std::cout << "HMQV with NIST P-256 and SHA-256:" << std::endl; std::cout << "HMQV with NIST P-256 and SHA-256:" << std::endl;
@ -181,9 +181,9 @@ std::cout << "\nFHMQV validation suite running...\n\n";
//ECFHMQV< ECP >::Domain fhmqvB(false /*server*/); //ECFHMQV< ECP >::Domain fhmqvB(false /*server*/);
ECFHMQV256 fhmqvB(false); ECFHMQV256 fhmqvB(false);
FileSource f256(CRYPTOPP_DATA_DIR "TestData/fhmqv256.dat", true, new HexDecoder()); FileSource f256(DataDir("TestData/fhmqv256.dat").c_str(), true, new HexDecoder);
FileSource f384(CRYPTOPP_DATA_DIR "TestData/fhmqv384.dat", true, new HexDecoder()); FileSource f384(DataDir("TestData/fhmqv384.dat").c_str(), true, new HexDecoder);
FileSource f512(CRYPTOPP_DATA_DIR "TestData/fhmqv512.dat", true, new HexDecoder()); FileSource f512(DataDir("TestData/fhmqv512.dat").c_str(), true, new HexDecoder);
fhmqvB.AccessGroupParameters().BERDecode(f256); fhmqvB.AccessGroupParameters().BERDecode(f256);
std::cout << "FHMQV with NIST P-256 and SHA-256:" << std::endl; std::cout << "FHMQV with NIST P-256 and SHA-256:" << std::endl;
@ -296,7 +296,7 @@ bool ValidateLUC_DH()
{ {
std::cout << "\nLUC-DH validation suite running...\n\n"; std::cout << "\nLUC-DH validation suite running...\n\n";
FileSource f(CRYPTOPP_DATA_DIR "TestData/lucd512.dat", true, new HexDecoder()); FileSource f(DataDir("TestData/lucd512.dat").c_str(), true, new HexDecoder);
LUC_DH dh(f); LUC_DH dh(f);
return SimpleKeyAgreementValidate(dh); return SimpleKeyAgreementValidate(dh);
} }
@ -305,7 +305,7 @@ bool ValidateXTR_DH()
{ {
std::cout << "\nXTR-DH validation suite running...\n\n"; std::cout << "\nXTR-DH validation suite running...\n\n";
FileSource f(CRYPTOPP_DATA_DIR "TestData/xtrdh171.dat", true, new HexDecoder()); FileSource f(DataDir("TestData/xtrdh171.dat").c_str(), true, new HexDecoder);
XTR_DH dh(f); XTR_DH dh(f);
return SimpleKeyAgreementValidate(dh); return SimpleKeyAgreementValidate(dh);
} }

16
validat8.cpp
View File

@ -45,7 +45,7 @@ bool ValidateRSA_Encrypt()
bool pass = true, fail; bool pass = true, fail;
{ {
FileSource keys(CRYPTOPP_DATA_DIR "TestData/rsa1024.dat", true, new HexDecoder); FileSource keys(DataDir("TestData/rsa1024.dat").c_str(), true, new HexDecoder);
RSAES_PKCS1v15_Decryptor rsaPriv(keys); RSAES_PKCS1v15_Decryptor rsaPriv(keys);
RSAES_PKCS1v15_Encryptor rsaPub(rsaPriv); RSAES_PKCS1v15_Encryptor rsaPub(rsaPriv);
@ -72,8 +72,8 @@ bool ValidateRSA_Encrypt()
bq.Put(oaepSeed, 20); bq.Put(oaepSeed, 20);
FixedRNG rng(bq); FixedRNG rng(bq);
FileSource privFile(CRYPTOPP_DATA_DIR "TestData/rsa400pv.dat", true, new HexDecoder); FileSource privFile(DataDir("TestData/rsa400pv.dat").c_str(), true, new HexDecoder);
FileSource pubFile(CRYPTOPP_DATA_DIR "TestData/rsa400pb.dat", true, new HexDecoder); FileSource pubFile(DataDir("TestData/rsa400pb.dat").c_str(), true, new HexDecoder);
RSAES_OAEP_SHA_Decryptor rsaPriv; RSAES_OAEP_SHA_Decryptor rsaPriv;
rsaPriv.AccessKey().BERDecodePrivateKey(privFile, false, 0); rsaPriv.AccessKey().BERDecodePrivateKey(privFile, false, 0);
RSAES_OAEP_SHA_Encryptor rsaPub(pubFile); RSAES_OAEP_SHA_Encryptor rsaPub(pubFile);
@ -94,7 +94,7 @@ bool ValidateRSA_Encrypt()
bool ValidateLUC_Encrypt() bool ValidateLUC_Encrypt()
{ {
FileSource f(CRYPTOPP_DATA_DIR "TestData/luc1024.dat", true, new HexDecoder); FileSource f(DataDir("TestData/luc1024.dat").c_str(), true, new HexDecoder);
LUCES_OAEP_SHA_Decryptor priv(GlobalRNG(), 512); LUCES_OAEP_SHA_Decryptor priv(GlobalRNG(), 512);
LUCES_OAEP_SHA_Encryptor pub(priv); LUCES_OAEP_SHA_Encryptor pub(priv);
return CryptoSystemValidate(priv, pub); return CryptoSystemValidate(priv, pub);
@ -104,7 +104,7 @@ bool ValidateLUC_DL_Encrypt()
{ {
std::cout << "\nLUC-IES validation suite running...\n\n"; std::cout << "\nLUC-IES validation suite running...\n\n";
FileSource fc(CRYPTOPP_DATA_DIR "TestData/lucc512.dat", true, new HexDecoder); FileSource fc(DataDir("TestData/lucc512.dat").c_str(), true, new HexDecoder);
LUC_IES<>::Decryptor privC(fc); LUC_IES<>::Decryptor privC(fc);
LUC_IES<>::Encryptor pubC(privC); LUC_IES<>::Encryptor pubC(privC);
return CryptoSystemValidate(privC, pubC); return CryptoSystemValidate(privC, pubC);
@ -112,7 +112,7 @@ bool ValidateLUC_DL_Encrypt()
bool ValidateRabin_Encrypt() bool ValidateRabin_Encrypt()
{ {
FileSource f(CRYPTOPP_DATA_DIR "TestData/rabi1024.dat", true, new HexDecoder); FileSource f(DataDir("TestData/rabi1024.dat").c_str(), true, new HexDecoder);
RabinES<OAEP<SHA1> >::Decryptor priv(f); RabinES<OAEP<SHA1> >::Decryptor priv(f);
RabinES<OAEP<SHA1> >::Encryptor pub(priv); RabinES<OAEP<SHA1> >::Encryptor pub(priv);
return CryptoSystemValidate(priv, pub); return CryptoSystemValidate(priv, pub);
@ -163,7 +163,7 @@ bool ValidateElGamal()
std::cout << "\nElGamal validation suite running...\n\n"; std::cout << "\nElGamal validation suite running...\n\n";
bool pass = true; bool pass = true;
{ {
FileSource fc(CRYPTOPP_DATA_DIR "TestData/elgc1024.dat", true, new HexDecoder); FileSource fc(DataDir("TestData/elgc1024.dat").c_str(), true, new HexDecoder);
ElGamalDecryptor privC(fc); ElGamalDecryptor privC(fc);
ElGamalEncryptor pubC(privC); ElGamalEncryptor pubC(privC);
privC.AccessKey().Precompute(); privC.AccessKey().Precompute();
@ -181,7 +181,7 @@ bool ValidateDLIES()
std::cout << "\nDLIES validation suite running...\n\n"; std::cout << "\nDLIES validation suite running...\n\n";
bool pass = true; bool pass = true;
{ {
FileSource fc(CRYPTOPP_DATA_DIR "TestData/dlie1024.dat", true, new HexDecoder); FileSource fc(DataDir("TestData/dlie1024.dat").c_str(), true, new HexDecoder);
DLIES<>::Decryptor privC(fc); DLIES<>::Decryptor privC(fc);
DLIES<>::Encryptor pubC(privC); DLIES<>::Encryptor pubC(privC);
pass = CryptoSystemValidate(privC, pubC) && pass; pass = CryptoSystemValidate(privC, pubC) && pass;

32
validat9.cpp
View File

@ -56,13 +56,13 @@ bool ValidateRSA_Sign()
{ {
const char plain[] = "Everyone gets Friday off."; const char plain[] = "Everyone gets Friday off.";
static const byte signature[] = const byte signature[] =
"\x05\xfa\x6a\x81\x2f\xc7\xdf\x8b\xf4\xf2\x54\x25\x09\xe0\x3e\x84" "\x05\xfa\x6a\x81\x2f\xc7\xdf\x8b\xf4\xf2\x54\x25\x09\xe0\x3e\x84"
"\x6e\x11\xb9\xc6\x20\xbe\x20\x09\xef\xb4\x40\xef\xbc\xc6\x69\x21" "\x6e\x11\xb9\xc6\x20\xbe\x20\x09\xef\xb4\x40\xef\xbc\xc6\x69\x21"
"\x69\x94\xac\x04\xf3\x41\xb5\x7d\x05\x20\x2d\x42\x8f\xb2\xa2\x7b" "\x69\x94\xac\x04\xf3\x41\xb5\x7d\x05\x20\x2d\x42\x8f\xb2\xa2\x7b"
"\x5c\x77\xdf\xd9\xb1\x5b\xfc\x3d\x55\x93\x53\x50\x34\x10\xc1\xe1"; "\x5c\x77\xdf\xd9\xb1\x5b\xfc\x3d\x55\x93\x53\x50\x34\x10\xc1\xe1";
FileSource keys(CRYPTOPP_DATA_DIR "TestData/rsa512a.dat", true, new HexDecoder); FileSource keys(DataDir("TestData/rsa512a.dat").c_str(), true, new HexDecoder);
Weak::RSASSA_PKCS1v15_MD2_Signer rsaPriv(keys); Weak::RSASSA_PKCS1v15_MD2_Signer rsaPriv(keys);
Weak::RSASSA_PKCS1v15_MD2_Verifier rsaPub(rsaPriv); Weak::RSASSA_PKCS1v15_MD2_Verifier rsaPub(rsaPriv);
@ -90,7 +90,7 @@ bool ValidateRSA_Sign()
///// /////
{ {
const char plain[] = "Everyone gets Friday off."; const char plain[] = "Everyone gets Friday off.";
static const byte signature[] = const byte signature[] =
"\x2e\x87\xda\x1f\xe4\xda\x1d\x7a\xb7\xf2\x42\x36\xe9\xc0\x4e\xab\x3f\x03\x71\xe1" "\x2e\x87\xda\x1f\xe4\xda\x1d\x7a\xb7\xf2\x42\x36\xe9\xc0\x4e\xab\x3f\x03\x71\xe1"
"\x2b\xc5\x3c\xbf\x21\x21\xa8\xd6\x28\xb0\x08\xfd\x9c\xf6\x94\xbd\x37\x32\xda\xfc" "\x2b\xc5\x3c\xbf\x21\x21\xa8\xd6\x28\xb0\x08\xfd\x9c\xf6\x94\xbd\x37\x32\xda\xfc"
"\x42\x1c\x8e\xdb\x8a\x81\x90\x46\x45\xb4\xde\x9e\xce\x90\xfe\xa1\xfd\xbc\x5a\xce" "\x42\x1c\x8e\xdb\x8a\x81\x90\x46\x45\xb4\xde\x9e\xce\x90\xfe\xa1\xfd\xbc\x5a\xce"
@ -105,7 +105,7 @@ bool ValidateRSA_Sign()
"\xeb\x89\x65\x53\x35\xe7\x13\x7e\xbb\x26\xb0\x76\x9c\xf2\x80\xaa\xe1\xb1\x0a\xa6" "\xeb\x89\x65\x53\x35\xe7\x13\x7e\xbb\x26\xb0\x76\x9c\xf2\x80\xaa\xe1\xb1\x0a\xa6"
"\x47\xfc\x5f\xe0\x7f\x82\xd7\x83\x41\xc3\x50\xa1\xe0\x0e\x1a\xe4"; "\x47\xfc\x5f\xe0\x7f\x82\xd7\x83\x41\xc3\x50\xa1\xe0\x0e\x1a\xe4";
FileSource keys(CRYPTOPP_DATA_DIR "TestData/rsa2048a.dat", true, new HexDecoder); FileSource keys(DataDir("TestData/rsa2048a.dat").c_str(), true, new HexDecoder);
RSASS<PKCS1v15, SHA3_256>::Signer rsaPriv(keys); RSASS<PKCS1v15, SHA3_256>::Signer rsaPriv(keys);
RSASS<PKCS1v15, SHA3_256>::Verifier rsaPub(rsaPriv); RSASS<PKCS1v15, SHA3_256>::Verifier rsaPub(rsaPriv);
@ -139,7 +139,7 @@ bool ValidateNR()
std::cout << "\nNR validation suite running...\n\n"; std::cout << "\nNR validation suite running...\n\n";
bool pass = true; bool pass = true;
{ {
FileSource f(CRYPTOPP_DATA_DIR "TestData/nr2048.dat", true, new HexDecoder); FileSource f(DataDir("TestData/nr2048.dat").c_str(), true, new HexDecoder);
NR<SHA1>::Signer privS(f); NR<SHA1>::Signer privS(f);
privS.AccessKey().Precompute(); privS.AccessKey().Precompute();
NR<SHA1>::Verifier pubS(privS); NR<SHA1>::Verifier pubS(privS);
@ -161,21 +161,21 @@ bool ValidateDSA(bool thorough)
std::cout << "\nDSA validation suite running...\n\n"; std::cout << "\nDSA validation suite running...\n\n";
bool pass = true; bool pass = true;
FileSource fs1(CRYPTOPP_DATA_DIR "TestData/dsa1024.dat", true, new HexDecoder()); FileSource fs1(DataDir("TestData/dsa1024.dat").c_str(), true, new HexDecoder);
DSA::Signer priv(fs1); DSA::Signer priv(fs1);
DSA::Verifier pub(priv); DSA::Verifier pub(priv);
FileSource fs2(CRYPTOPP_DATA_DIR "TestData/dsa1024b.dat", true, new HexDecoder()); FileSource fs2(DataDir("TestData/dsa1024b.dat").c_str(), true, new HexDecoder);
DSA::Verifier pub1(fs2); DSA::Verifier pub1(fs2);
CRYPTOPP_ASSERT(pub.GetKey() == pub1.GetKey()); CRYPTOPP_ASSERT(pub.GetKey() == pub1.GetKey());
pass = SignatureValidate(priv, pub, thorough) && pass; pass = SignatureValidate(priv, pub, thorough) && pass;
pass = RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/dsa.txt", g_nullNameValuePairs, thorough) && pass; pass = RunTestDataFile("TestVectors/dsa.txt", g_nullNameValuePairs, thorough) && pass;
return pass; return pass;
} }
bool ValidateLUC_Sign() bool ValidateLUC_Sign()
{ {
FileSource f(CRYPTOPP_DATA_DIR "TestData/luc1024.dat", true, new HexDecoder); FileSource f(DataDir("TestData/luc1024.dat").c_str(), true, new HexDecoder);
LUCSSA_PKCS1v15_SHA_Signer priv(f); LUCSSA_PKCS1v15_SHA_Signer priv(f);
LUCSSA_PKCS1v15_SHA_Verifier pub(priv); LUCSSA_PKCS1v15_SHA_Verifier pub(priv);
return SignatureValidate(priv, pub); return SignatureValidate(priv, pub);
@ -185,7 +185,7 @@ bool ValidateLUC_DL_Sign()
{ {
std::cout << "\nLUC-HMP validation suite running...\n\n"; std::cout << "\nLUC-HMP validation suite running...\n\n";
FileSource f(CRYPTOPP_DATA_DIR "TestData/lucs512.dat", true, new HexDecoder); FileSource f(DataDir("TestData/lucs512.dat").c_str(), true, new HexDecoder);
LUC_HMP<SHA1>::Signer privS(f); LUC_HMP<SHA1>::Signer privS(f);
LUC_HMP<SHA1>::Verifier pubS(privS); LUC_HMP<SHA1>::Verifier pubS(privS);
return SignatureValidate(privS, pubS); return SignatureValidate(privS, pubS);
@ -193,7 +193,7 @@ bool ValidateLUC_DL_Sign()
bool ValidateRabin_Sign() bool ValidateRabin_Sign()
{ {
FileSource f(CRYPTOPP_DATA_DIR "TestData/rabi1024.dat", true, new HexDecoder); FileSource f(DataDir("TestData/rabi1024.dat").c_str(), true, new HexDecoder);
RabinSS<PSSR, SHA1>::Signer priv(f); RabinSS<PSSR, SHA1>::Signer priv(f);
RabinSS<PSSR, SHA1>::Verifier pub(priv); RabinSS<PSSR, SHA1>::Verifier pub(priv);
return SignatureValidate(priv, pub); return SignatureValidate(priv, pub);
@ -203,7 +203,7 @@ bool ValidateRW()
{ {
std::cout << "\nRW validation suite running...\n\n"; std::cout << "\nRW validation suite running...\n\n";
FileSource f(CRYPTOPP_DATA_DIR "TestData/rw1024.dat", true, new HexDecoder); FileSource f(DataDir("TestData/rw1024.dat").c_str(), true, new HexDecoder);
RWSS<PSSR, SHA1>::Signer priv(f); RWSS<PSSR, SHA1>::Signer priv(f);
RWSS<PSSR, SHA1>::Verifier pub(priv); RWSS<PSSR, SHA1>::Verifier pub(priv);
@ -272,7 +272,7 @@ bool ValidateECDSA()
Integer h("A9993E364706816ABA3E25717850C26C9CD0D89DH"); Integer h("A9993E364706816ABA3E25717850C26C9CD0D89DH");
Integer k("3eeace72b4919d991738d521879f787cb590aff8189d2b69H"); Integer k("3eeace72b4919d991738d521879f787cb590aff8189d2b69H");
static const byte sig[]="\x03\x8e\x5a\x11\xfb\x55\xe4\xc6\x54\x71\xdc\xd4\x99\x84\x52\xb1\xe0\x2d\x8a\xf7\x09\x9b\xb9\x30" const byte sig[]="\x03\x8e\x5a\x11\xfb\x55\xe4\xc6\x54\x71\xdc\xd4\x99\x84\x52\xb1\xe0\x2d\x8a\xf7\x09\x9b\xb9\x30"
"\x0c\x9a\x08\xc3\x44\x68\xc2\x44\xb4\xe5\xd6\xb2\x1b\x3c\x68\x36\x28\x07\x41\x60\x20\x32\x8b\x6e"; "\x0c\x9a\x08\xc3\x44\x68\xc2\x44\xb4\xe5\xd6\xb2\x1b\x3c\x68\x36\x28\x07\x41\x60\x20\x32\x8b\x6e";
Integer r(sig, 24); Integer r(sig, 24);
Integer s(sig+24, 24); Integer s(sig+24, 24);
@ -636,8 +636,8 @@ bool ValidateESIGN()
bool pass = true, fail; bool pass = true, fail;
static const char plain[] = "test"; const char plain[] = "test";
static const byte signature[] = const byte signature[] =
"\xA3\xE3\x20\x65\xDE\xDA\xE7\xEC\x05\xC1\xBF\xCD\x25\x79\x7D\x99\xCD\xD5\x73\x9D\x9D\xF3\xA4\xAA\x9A\xA4\x5A\xC8\x23\x3D\x0D\x37" "\xA3\xE3\x20\x65\xDE\xDA\xE7\xEC\x05\xC1\xBF\xCD\x25\x79\x7D\x99\xCD\xD5\x73\x9D\x9D\xF3\xA4\xAA\x9A\xA4\x5A\xC8\x23\x3D\x0D\x37"
"\xFE\xBC\x76\x3F\xF1\x84\xF6\x59\x14\x91\x4F\x0C\x34\x1B\xAE\x9A\x5C\x2E\x2E\x38\x08\x78\x77\xCB\xDC\x3C\x7E\xA0\x34\x44\x5B\x0F" "\xFE\xBC\x76\x3F\xF1\x84\xF6\x59\x14\x91\x4F\x0C\x34\x1B\xAE\x9A\x5C\x2E\x2E\x38\x08\x78\x77\xCB\xDC\x3C\x7E\xA0\x34\x44\x5B\x0F"
"\x67\xD9\x35\x2A\x79\x47\x1A\x52\x37\x71\xDB\x12\x67\xC1\xB6\xC6\x66\x73\xB3\x40\x2E\xD6\xF2\x1A\x84\x0A\xB6\x7B\x0F\xEB\x8B\x88" "\x67\xD9\x35\x2A\x79\x47\x1A\x52\x37\x71\xDB\x12\x67\xC1\xB6\xC6\x66\x73\xB3\x40\x2E\xD6\xF2\x1A\x84\x0A\xB6\x7B\x0F\xEB\x8B\x88"
@ -645,7 +645,7 @@ bool ValidateESIGN()
"\xF4\x15\x65\xB8\xE1\xD1\x45\xAE\x39\x19\xB4\xFF\x5D\xF1\x45\x7B\xE0\xFE\x72\xED\x11\x92\x8F\x61\x41\x4F\x02\x00\xF2\x76\x6F\x7C" "\xF4\x15\x65\xB8\xE1\xD1\x45\xAE\x39\x19\xB4\xFF\x5D\xF1\x45\x7B\xE0\xFE\x72\xED\x11\x92\x8F\x61\x41\x4F\x02\x00\xF2\x76\x6F\x7C"
"\x79\xA2\xE5\x52\x20\x5D\x97\x5E\xFE\x39\xAE\x21\x10\xFB\x35\xF4\x80\x81\x41\x13\xDD\xE8\x5F\xCA\x1E\x4F\xF8\x9B\xB2\x68\xFB\x28"; "\x79\xA2\xE5\x52\x20\x5D\x97\x5E\xFE\x39\xAE\x21\x10\xFB\x35\xF4\x80\x81\x41\x13\xDD\xE8\x5F\xCA\x1E\x4F\xF8\x9B\xB2\x68\xFB\x28";
FileSource keys(CRYPTOPP_DATA_DIR "TestData/esig1536.dat", true, new HexDecoder); FileSource keys(DataDir("TestData/esig1536.dat").c_str(), true, new HexDecoder);
ESIGN<SHA1>::Signer signer(keys); ESIGN<SHA1>::Signer signer(keys);
ESIGN<SHA1>::Verifier verifier(signer); ESIGN<SHA1>::Verifier verifier(signer);

36
validate.h
View File

@ -246,8 +246,42 @@ inline int StringToValue<int, true>(const std::string& str)
return r; return r;
} }
inline std::string AddSeparator(std::string str)
{
const char last = (str.empty() ? '\0' : *str.end()-1);
if (last != '/' && last != '\\')
return str + "/";
return str;
}
inline std::string DataDir(const std::string& filename)
{
std::ifstream file;
#ifndef CRYPTOPP_DISABLE_DATA_DIR_SEARCH
// Data files in PWD are probably the newest. This is probably a build directory.
file.open(std::string("./") + filename);
if (file.is_open())
return std::string("./") + filename;
#endif
#ifdef CRYPTOPP_DATA_DIR
// Honor the user's setting next. This is likely an install directory if it is not "./".
std::string data_dir(AddSeparator(CRYPTOPP_DATA_DIR));
file.open(data_dir + filename);
if (file.is_open())
data_dir + filename;
#endif
#ifndef CRYPTOPP_DISABLE_DATA_DIR_SEARCH
// Finally look in {$ORIGIN}/bin/../share/
file.open(std::string("../share/cryptopp/") + filename);
if (file.is_open())
return std::string("../share/cryptopp/") + filename;
#endif
// This will cause the expected exception in the caller
return filename;
}
// Definition in test.cpp // Definition in test.cpp
RandomNumberGenerator & GlobalRNG(); RandomNumberGenerator& GlobalRNG();
// Definition in datatest.cpp // Definition in datatest.cpp
bool RunTestDataFile(const char *filename, const NameValuePairs &overrideParameters=g_nullNameValuePairs, bool thorough=true); bool RunTestDataFile(const char *filename, const NameValuePairs &overrideParameters=g_nullNameValuePairs, bool thorough=true);