void EDDSATests::testPKCS8()
{
// Get ed25519 domain parameters
ECParameters* p = new ECParameters;
p->setEC(ByteString("06032b6570"));
// Generate a key-pair
AsymmetricKeyPair* kp;
CPPUNIT_ASSERT(eddsa->generateKeyPair(&kp, p));
CPPUNIT_ASSERT(kp != NULL);
EDPrivateKey* priv = (EDPrivateKey*) kp->getPrivateKey();
CPPUNIT_ASSERT(priv != NULL);
// Encode and decode the private key
ByteString pkcs8 = priv->PKCS8Encode();
CPPUNIT_ASSERT(pkcs8.size() != 0);
EDPrivateKey* dPriv = (EDPrivateKey*) eddsa->newPrivateKey();
CPPUNIT_ASSERT(dPriv != NULL);
CPPUNIT_ASSERT(dPriv->PKCS8Decode(pkcs8));
CPPUNIT_ASSERT(priv->getEC() == dPriv->getEC());
CPPUNIT_ASSERT(priv->getK() == dPriv->getK());
eddsa->recycleParameters(p);
eddsa->recycleKeyPair(kp);
eddsa->recyclePrivateKey(dPriv);
}
void ECDSATests::testKeyGeneration()
{
AsymmetricKeyPair* kp;
// Curves to test
std::vector<ByteString> curves;
// Add X9.62 prime256v1
curves.push_back(ByteString("06082a8648ce3d030107"));
// Add secp384r1
curves.push_back(ByteString("06052b81040022"));
for (std::vector<ByteString>::iterator c = curves.begin(); c != curves.end(); c++)
{
// Set domain parameters
ECParameters* p = new ECParameters;
p->setEC(*c);
// Generate key-pair
CPPUNIT_ASSERT(ecdsa->generateKeyPair(&kp, p));
ECPublicKey* pub = (ECPublicKey*) kp->getPublicKey();
ECPrivateKey* priv = (ECPrivateKey*) kp->getPrivateKey();
CPPUNIT_ASSERT(pub->getEC() == *c);
CPPUNIT_ASSERT(priv->getEC() == *c);
ecdsa->recycleParameters(p);
ecdsa->recycleKeyPair(kp);
}
}
void EDDSATests::testKeyGeneration()
{
AsymmetricKeyPair* kp;
// Curves to test
std::vector<ByteString> curves;
// Add x25519
curves.push_back(ByteString("06032b656e"));
// Add ed25519
curves.push_back(ByteString("06032b6570"));
for (std::vector<ByteString>::iterator c = curves.begin(); c != curves.end(); c++)
{
// Set domain parameters
ECParameters* p = new ECParameters;
p->setEC(*c);
// Generate key-pair
CPPUNIT_ASSERT(eddsa->generateKeyPair(&kp, p));
EDPublicKey* pub = (EDPublicKey*) kp->getPublicKey();
EDPrivateKey* priv = (EDPrivateKey*) kp->getPrivateKey();
CPPUNIT_ASSERT(pub->getEC() == *c);
CPPUNIT_ASSERT(priv->getEC() == *c);
eddsa->recycleParameters(p);
eddsa->recycleKeyPair(kp);
}
}
void ECDSATests::testPKCS8()
{
// Get prime256v1 domain parameters
ECParameters* p = new ECParameters;
p->setEC(ByteString("06082a8648ce3d030107"));
// Generate a key-pair
AsymmetricKeyPair* kp;
CPPUNIT_ASSERT(ecdsa->generateKeyPair(&kp, p));
CPPUNIT_ASSERT(kp != NULL);
ECPrivateKey* priv = (ECPrivateKey*) kp->getPrivateKey();
CPPUNIT_ASSERT(priv != NULL);
// Encode and decode the private key
ByteString pkcs8 = priv->PKCS8Encode();
CPPUNIT_ASSERT(pkcs8.size() != 0);
ECPrivateKey* dPriv = (ECPrivateKey*) ecdsa->newPrivateKey();
CPPUNIT_ASSERT(dPriv != NULL);
CPPUNIT_ASSERT(dPriv->PKCS8Decode(pkcs8));
CPPUNIT_ASSERT(priv->getEC() == dPriv->getEC());
CPPUNIT_ASSERT(priv->getD() == dPriv->getD());
ecdsa->recycleParameters(p);
ecdsa->recycleKeyPair(kp);
ecdsa->recyclePrivateKey(dPriv);
}
void GOSTTests::testKeyGeneration()
{
AsymmetricKeyPair* kp;
CPPUNIT_ASSERT((gost = CryptoFactory::i()->getAsymmetricAlgorithm("gost")));
// Set domain parameters
ByteString curve = "06072a850302022301";
ECParameters* p = new ECParameters;
p->setEC(curve);
// Generate key-pair
CPPUNIT_ASSERT(gost->generateKeyPair(&kp, p));
GOSTPublicKey* pub = (GOSTPublicKey*) kp->getPublicKey();
GOSTPrivateKey* priv = (GOSTPrivateKey*) kp->getPrivateKey();
CPPUNIT_ASSERT(pub->getQ().size() == 64);
CPPUNIT_ASSERT(priv->getD().size() == 32);
gost->recycleParameters(p);
gost->recycleKeyPair(kp);
CryptoFactory::i()->recycleAsymmetricAlgorithm(gost);
gost = NULL;
}
void GOSTTests::testSerialisation()
{
CPPUNIT_ASSERT((gost = CryptoFactory::i()->getAsymmetricAlgorithm("gost")));
// Get GOST R 34.10-2001 params-A domain parameters
ECParameters* p = new ECParameters;
p->setEC(ByteString("06072a850302022301"));
// Serialise the parameters
ByteString serialisedParams = p->serialise();
// Deserialise the parameters
AsymmetricParameters* dEC;
CPPUNIT_ASSERT(gost->reconstructParameters(&dEC, serialisedParams));
CPPUNIT_ASSERT(dEC->areOfType(ECParameters::type));
ECParameters* ddEC = (ECParameters*) dEC;
CPPUNIT_ASSERT(p->getEC() == ddEC->getEC());
// Generate a key-pair
AsymmetricKeyPair* kp;
CPPUNIT_ASSERT(gost->generateKeyPair(&kp, dEC));
// Serialise the key-pair
ByteString serialisedKP = kp->serialise();
// Deserialise the key-pair
AsymmetricKeyPair* dKP;
CPPUNIT_ASSERT(gost->reconstructKeyPair(&dKP, serialisedKP));
// Check the deserialised key-pair
GOSTPrivateKey* privKey = (GOSTPrivateKey*) kp->getPrivateKey();
GOSTPublicKey* pubKey = (GOSTPublicKey*) kp->getPublicKey();
GOSTPrivateKey* dPrivKey = (GOSTPrivateKey*) dKP->getPrivateKey();
GOSTPublicKey* dPubKey = (GOSTPublicKey*) dKP->getPublicKey();
CPPUNIT_ASSERT(privKey->getD() == dPrivKey->getD());
CPPUNIT_ASSERT(pubKey->getQ() == dPubKey->getQ());
gost->recycleParameters(p);
gost->recycleParameters(dEC);
gost->recycleKeyPair(kp);
gost->recycleKeyPair(dKP);
CryptoFactory::i()->recycleAsymmetricAlgorithm(gost);
gost = NULL;
}
void ECDSATests::testSerialisation()
{
// Get prime256v1 domain parameters
ECParameters* p = new ECParameters;
p->setEC(ByteString("06082a8648ce3d030107"));
// Serialise the parameters
ByteString serialisedParams = p->serialise();
// Deserialise the parameters
AsymmetricParameters* dEC;
CPPUNIT_ASSERT(ecdsa->reconstructParameters(&dEC, serialisedParams));
CPPUNIT_ASSERT(dEC->areOfType(ECParameters::type));
ECParameters* ddEC = (ECParameters*) dEC;
CPPUNIT_ASSERT(p->getEC() == ddEC->getEC());
// Generate a key-pair
AsymmetricKeyPair* kp;
CPPUNIT_ASSERT(ecdsa->generateKeyPair(&kp, dEC));
// Serialise the key-pair
ByteString serialisedKP = kp->serialise();
// Deserialise the key-pair
AsymmetricKeyPair* dKP;
CPPUNIT_ASSERT(ecdsa->reconstructKeyPair(&dKP, serialisedKP));
// Check the deserialised key-pair
ECPrivateKey* privKey = (ECPrivateKey*) kp->getPrivateKey();
ECPublicKey* pubKey = (ECPublicKey*) kp->getPublicKey();
ECPrivateKey* dPrivKey = (ECPrivateKey*) dKP->getPrivateKey();
ECPublicKey* dPubKey = (ECPublicKey*) dKP->getPublicKey();
CPPUNIT_ASSERT(privKey->getEC() == dPrivKey->getEC());
CPPUNIT_ASSERT(privKey->getD() == dPrivKey->getD());
CPPUNIT_ASSERT(pubKey->getEC() == dPubKey->getEC());
CPPUNIT_ASSERT(pubKey->getQ() == dPubKey->getQ());
ecdsa->recycleParameters(p);
ecdsa->recycleParameters(dEC);
ecdsa->recycleKeyPair(kp);
ecdsa->recycleKeyPair(dKP);
}
void ECDSATests::testSigningVerifying()
{
AsymmetricKeyPair* kp;
ECParameters *p;
// Curves/Hashes to test
std::vector<std::pair<ByteString, const char*> > totest;
// Add X9.62 prime256v1
totest.push_back(std::make_pair(ByteString("06082a8648ce3d030107"), "sha256"));
// Add secp384r1
totest.push_back(std::make_pair(ByteString("06052b81040022"), "sha384"));
for (std::vector<std::pair<ByteString, const char*> >::iterator k = totest.begin(); k != totest.end(); k++)
{
// Get parameters
p = new ECParameters;
CPPUNIT_ASSERT(p != NULL);
p->setEC(k->first);
HashAlgorithm *hash;
hash = CryptoFactory::i()->getHashAlgorithm(k->second);
CPPUNIT_ASSERT(hash != NULL);
// Generate key-pair
CPPUNIT_ASSERT(ecdsa->generateKeyPair(&kp, p));
// Generate some data to sign
ByteString dataToSign;
RNG* rng = CryptoFactory::i()->getRNG();
CPPUNIT_ASSERT(rng != NULL);
CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567));
// Sign the data
CPPUNIT_ASSERT(hash->hashInit());
CPPUNIT_ASSERT(hash->hashUpdate(dataToSign));
ByteString hResult;
CPPUNIT_ASSERT(hash->hashFinal(hResult));
ByteString sig;
CPPUNIT_ASSERT(ecdsa->sign(kp->getPrivateKey(), hResult, sig, "ECDSA"));
// And verify it
CPPUNIT_ASSERT(ecdsa->verify(kp->getPublicKey(), hResult, sig, "ECDSA"));
ecdsa->recycleKeyPair(kp);
ecdsa->recycleParameters(p);
CryptoFactory::i()->recycleHashAlgorithm(hash);
}
}
void ECDHTests::testDerivation()
{
AsymmetricKeyPair* kpa;
AsymmetricKeyPair* kpb;
ECParameters* p;
// Curves to test
std::vector<ByteString> curves;
// Add X9.62 prime256v1
curves.push_back(ByteString("06082a8648ce3d030107"));
// Add secp384r1
curves.push_back(ByteString("06052b81040022"));
for (std::vector<ByteString>::iterator c = curves.begin(); c != curves.end(); c++)
{
// Get parameters
p = new ECParameters;
CPPUNIT_ASSERT(p != NULL);
p->setEC(*c);
// Generate key-pairs
CPPUNIT_ASSERT(ecdh->generateKeyPair(&kpa, p));
CPPUNIT_ASSERT(ecdh->generateKeyPair(&kpb, p));
// Derive secrets
SymmetricKey* sa;
CPPUNIT_ASSERT(ecdh->deriveKey(&sa, kpb->getPublicKey(), kpa->getPrivateKey()));
SymmetricKey* sb;
CPPUNIT_ASSERT(ecdh->deriveKey(&sb, kpa->getPublicKey(), kpb->getPrivateKey()));
// Must be the same
CPPUNIT_ASSERT(sa->getKeyBits() == sb->getKeyBits());
// Clean up
ecdh->recycleSymmetricKey(sa);
ecdh->recycleSymmetricKey(sb);
ecdh->recycleKeyPair(kpa);
ecdh->recycleKeyPair(kpb);
ecdh->recycleParameters(p);
}
}
void EDDSATests::testDerivation()
{
AsymmetricKeyPair* kpa;
AsymmetricKeyPair* kpb;
ECParameters* p;
// Curves to test
std::vector<ByteString> curves;
// Add x25519
curves.push_back(ByteString("06032b656e"));
for (std::vector<ByteString>::iterator c = curves.begin(); c != curves.end(); c++)
{
// Get parameters
p = new ECParameters;
CPPUNIT_ASSERT(p != NULL);
p->setEC(*c);
// Generate key-pairs
CPPUNIT_ASSERT(eddsa->generateKeyPair(&kpa, p));
CPPUNIT_ASSERT(eddsa->generateKeyPair(&kpb, p));
// Derive secrets
SymmetricKey* sa;
CPPUNIT_ASSERT(eddsa->deriveKey(&sa, kpb->getPublicKey(), kpa->getPrivateKey()));
SymmetricKey* sb;
CPPUNIT_ASSERT(eddsa->deriveKey(&sb, kpa->getPublicKey(), kpb->getPrivateKey()));
// Must be the same
CPPUNIT_ASSERT(sa->getKeyBits() == sb->getKeyBits());
// Clean up
eddsa->recycleSymmetricKey(sa);
eddsa->recycleSymmetricKey(sb);
eddsa->recycleKeyPair(kpa);
eddsa->recycleKeyPair(kpb);
eddsa->recycleParameters(p);
}
}
void EDDSATests::testSigningVerifying()
{
AsymmetricKeyPair* kp;
ECParameters *p;
// Curves to test
std::vector<ByteString> curves;
// Add ed25519
curves.push_back(ByteString("06032b6570"));
for (std::vector<ByteString>::iterator c = curves.begin(); c != curves.end(); c++)
{
// Get parameters
p = new ECParameters;
CPPUNIT_ASSERT(p != NULL);
p->setEC(*c);
// Generate key-pair
CPPUNIT_ASSERT(eddsa->generateKeyPair(&kp, p));
// Generate some data to sign
ByteString dataToSign;
RNG* rng = CryptoFactory::i()->getRNG();
CPPUNIT_ASSERT(rng != NULL);
CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567));
// Sign the data
ByteString sig;
CPPUNIT_ASSERT(eddsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::EDDSA));
// And verify it
CPPUNIT_ASSERT(eddsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::EDDSA));
eddsa->recycleKeyPair(kp);
eddsa->recycleParameters(p);
}
}
void GOSTTests::testSigningVerifying()
{
AsymmetricKeyPair* kp;
ECParameters *p;
ByteString curve = "06072a850302022301";
CPPUNIT_ASSERT((gost = CryptoFactory::i()->getAsymmetricAlgorithm("gost")));
// Get parameters
p = new ECParameters;
CPPUNIT_ASSERT(p != NULL);
p->setEC(curve);
// Generate key-pair
CPPUNIT_ASSERT(gost->generateKeyPair(&kp, p));
// Generate some data to sign
ByteString dataToSign;
RNG* rng = CryptoFactory::i()->getRNG();
CPPUNIT_ASSERT(rng != NULL);
CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567));
// Sign the data
ByteString sig;
CPPUNIT_ASSERT(gost->sign(kp->getPrivateKey(), dataToSign, sig, "gost-gost"));
// And verify it
CPPUNIT_ASSERT(gost->verify(kp->getPublicKey(), dataToSign, sig, "gost-gost"));
gost->recycleKeyPair(kp);
gost->recycleParameters(p);
CryptoFactory::i()->recycleAsymmetricAlgorithm(gost);
gost = NULL;
}