#include <map>
#include <openssl/ecdsa.h>
+#include <openssl/evp.h>
#include <openssl/obj_mac.h>
#include "key.h"
const unsigned char *vchZero = NULL;
-
-
void CKey::SetCompressedPubKey()
{
EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
void CKey::Reset()
{
- fCompressedPubKey = false;
+ fCompressedPubKey = fSet = false;
if (pkey != NULL)
EC_KEY_free(pkey);
pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
if (pkey == NULL)
throw key_error("CKey::CKey() : EC_KEY_new_by_curve_name failed");
- fSet = false;
}
CKey::CKey()
CKey::~CKey()
{
- EC_KEY_free(pkey);
+ if (pkey != NULL)
+ EC_KEY_free(pkey);
}
bool CKey::IsNull() const
CompareBigEndian(vch, len, half ? vchMaxModHalfOrder : vchMaxModOrder, 32) <= 0;
}
-bool CKey::ReserealizeSignature(std::vector<unsigned char>& vchSig)
+bool CPubKey::ReserealizeSignature(std::vector<unsigned char>& vchSig)
{
if (vchSig.empty())
return false;
pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
if (pkey == NULL)
throw key_error("CKey::SetSecret() : EC_KEY_new_by_curve_name failed");
+
if (vchSecret.size() != 32)
throw key_error("CKey::SetSecret() : secret must be 32 bytes");
BIGNUM *bn = BN_bin2bn(&vchSecret[0],32,BN_new());
return vchRet;
}
+bool CKey::WritePEM(BIO *streamObj, const SecureString &strPassKey) const // dumppem 4KJLA99FyqMMhjjDe7KnRXK4sjtv9cCtNS /tmp/test.pem 123
+{
+ EVP_PKEY *evpKey = EVP_PKEY_new();
+ if (!EVP_PKEY_assign_EC_KEY(evpKey, pkey))
+ return error("CKey::WritePEM() : Error initializing EVP_PKEY instance.");
+ if(!PEM_write_bio_PKCS8PrivateKey(streamObj, evpKey, EVP_aes_256_cbc(), (char *)&strPassKey[0], strPassKey.size(), NULL, NULL))
+ return error("CKey::WritePEM() : Error writing private key data to stream object");
+
+ return true;
+}
+
CSecret CKey::GetSecret() const
{
bool fCompressed;
return vchPrivKey;
}
-bool CKey::SetPubKey(const CPubKey& vchPubKey)
-{
- const unsigned char* pbegin = &vchPubKey.vchPubKey[0];
- if (o2i_ECPublicKey(&pkey, &pbegin, vchPubKey.vchPubKey.size()))
- {
- fSet = true;
- if (vchPubKey.vchPubKey.size() == 33)
- SetCompressedPubKey();
- return true;
- }
- pkey = NULL;
- Reset();
- return false;
-}
-
CPubKey CKey::GetPubKey() const
{
int nSize = i2o_ECPublicKey(pkey, NULL);
// This is only slightly more CPU intensive than just verifying it.
// If this function succeeds, the recovered public key is guaranteed to be valid
// (the signature is a valid signature of the given data for that key)
-bool CKey::SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig)
+bool CPubKey::SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig)
{
if (vchSig.size() != 65)
return false;
BN_bin2bn(&vchSig[1],32,sig->r);
BN_bin2bn(&vchSig[33],32,sig->s);
- EC_KEY_free(pkey);
- pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ EC_KEY* pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
if (nV >= 31)
{
- SetCompressedPubKey();
nV -= 4;
+ EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
}
- if (ECDSA_SIG_recover_key_GFp(pkey, sig, (unsigned char*)&hash, sizeof(hash), nV - 27, 0) == 1)
+
+ do
{
- fSet = true;
+ if (ECDSA_SIG_recover_key_GFp(pkey, sig, (unsigned char*)&hash, sizeof(hash), nV - 27, 0) != 1)
+ break;
ECDSA_SIG_free(sig);
- return true;
- }
+
+ int nSize = i2o_ECPublicKey(pkey, NULL);
+ if (!nSize)
+ break;
+ std::vector<unsigned char> vchPubKey(nSize, 0);
+ unsigned char* pbegin = &vchPubKey[0];
+ if (i2o_ECPublicKey(pkey, &pbegin) != nSize)
+ break;
+ Set(vchPubKey.begin(), vchPubKey.end());
+ return IsValid();
+
+ } while (false);
+
ECDSA_SIG_free(sig);
+ Invalidate();
return false;
}
-bool CKey::Verify(uint256 hash, const std::vector<unsigned char>& vchSig)
+bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& vchSig) const
{
- if (vchSig.empty())
+ if (vchSig.empty() || !IsValid())
return false;
+ const unsigned char* pbegin = &vbytes[0];
+ EC_KEY *pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ if (!o2i_ECPublicKey(&pkey, &pbegin, size()))
+ return false; // Unable to parse public key
+
// New versions of OpenSSL will reject non-canonical DER signatures. de/re-serialize first.
unsigned char *norm_der = NULL;
ECDSA_SIG *norm_sig = ECDSA_SIG_new();
return ret;
}
-bool CKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
+bool CPubKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
{
- CKey key;
+ CPubKey key;
if (!key.SetCompactSignature(hash, vchSig))
return false;
- if (GetPubKey() != key.GetPubKey())
- return false;
-
return true;
}
CSecret secret = GetSecret(fCompr);
CKey key2;
key2.SetSecret(secret, fCompr);
+
return GetPubKey() == key2.GetPubKey();
}
}
// Initialize from octets stream
-bool CPoint::setPubKey(const CPubKey &vchPubKey)
+bool CPoint::setPubKey(const CPubKey &key)
{
- return setBytes(vchPubKey.Raw());
+ std::vector<uint8_t> vchPubKey(key.begin(), key.end());
+ return setBytes(vchPubKey);
}
// Serialize to octets stream
bool CPoint::getBytes(std::vector<unsigned char> &vchBytes)
{
- unsigned int nSize = EC_POINT_point2oct(group, point, POINT_CONVERSION_COMPRESSED, NULL, 0, ctx);
+ size_t nSize = EC_POINT_point2oct(group, point, POINT_CONVERSION_COMPRESSED, NULL, 0, ctx);
vchBytes.resize(nSize);
if (!(nSize == EC_POINT_point2oct(group, point, POINT_CONVERSION_COMPRESSED, &vchBytes[0], nSize, ctx))) {
return false;
return EncodeBase58Check(vch);
}
+bool CMalleablePubKey::setvch(const std::vector<unsigned char> &vchPubKeyPair)
+{
+ CDataStream ssKey(vchPubKeyPair, SER_NETWORK, PROTOCOL_VERSION);
+ ssKey >> *this;
+
+ return IsValid();
+}
+
std::vector<unsigned char> CMalleablePubKey::Raw() const
{
CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION);
CKey keyL(pvchSecretL);
CKey keyH(pvchSecretH);
- if (!keyL.IsValid() || !keyL.IsValid())
+ if (!keyL.IsValid() || !keyH.IsValid())
return false;
vchSecretL = pvchSecretL;
CMalleablePubKey CMalleableKey::GetMalleablePubKey() const
{
- CKey L, H;
- L.SetSecret(vchSecretL, true);
- H.SetSecret(vchSecretH, true);
-
- std::vector<unsigned char> vchPubKeyL = L.GetPubKey().Raw();
- std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
-
- return CMalleablePubKey(vchPubKeyL, vchPubKeyH);
+ CKey L(vchSecretL), H(vchSecretH);
+ return CMalleablePubKey(L.GetPubKey(), H.GetPubKey());
}
// Check ownership
}
if (!R.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : R is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : R is invalid");
+ return false;
}
if (!vchPubKeyVariant.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ return false;
}
CPoint point_R;
if (!point_R.setPubKey(R)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ return false;
}
- CKey H;
- H.SetSecret(vchSecretH, true);
- std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
+ CKey H(vchSecretH);
+ CPubKey vchPubKeyH = H.GetPubKey();
CPoint point_H;
if (!point_H.setPubKey(vchPubKeyH)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ return false;
}
CPoint point_P;
if (!point_P.setPubKey(vchPubKeyVariant)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ return false;
}
// Infinity points are senseless
if (point_P.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : P is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : P is infinity");
+ return false;
}
CBigNum bnl;
std::vector<unsigned char> vchRl;
if (!point_R.getBytes(vchRl)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ return false;
}
// Calculate Hash(R*l)
// Infinity points are senseless
if (point_Ps.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ return false;
}
// Check ownership
}
if (!R.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : R is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : R is invalid");
+ return false;
}
if (!vchPubKeyVariant.IsValid()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid");
+ return false;
}
CPoint point_R;
if (!point_R.setPubKey(R)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value");
+ return false;
}
- CKey H;
- H.SetSecret(vchSecretH, true);
- std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
+ CKey H(vchSecretH);
+ CPubKey vchPubKeyH = H.GetPubKey();
CPoint point_H;
if (!point_H.setPubKey(vchPubKeyH)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value");
+ return false;
}
CPoint point_P;
if (!point_P.setPubKey(vchPubKeyVariant)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value");
+ return false;
}
// Infinity points are senseless
if (point_P.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : P is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : P is infinity");
+ return false;
}
CBigNum bnl;
std::vector<unsigned char> vchRl;
if (!point_R.getBytes(vchRl)) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value");
+ return false;
}
// Calculate Hash(R*l)
// Infinity points are senseless
if (point_Ps.IsInfinity()) {
- throw key_error("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ printf("CMalleableKey::CheckKeyVariant() : Ps is infinity");
+ return false;
}
// Check ownership
CBigNum bnp = bnHash + bnh;
std::vector<unsigned char> vchp = bnp.getBytes();
- privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()), true);
+ privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()));
return true;
}
throw key_error("CMalleableKeyView::CMalleableKeyView() : L size must be 32 bytes");
if (b.vchSecretH.size() != 32)
- throw key_error("CMalleableKeyView::CMalleableKeyView() : L size must be 32 bytes");
+ throw key_error("CMalleableKeyView::CMalleableKeyView() : H size must be 32 bytes");
vchSecretL = b.vchSecretL;
- CKey H;
- H.SetSecret(b.vchSecretH, true);
-
- vchPubKeyH = H.GetPubKey().Raw();
+ CKey H(b.vchSecretH);
+ vchPubKeyH = H.GetPubKey();
}
CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b)
{
vchSecretL = b.vchSecretL;
- CKey H;
- H.SetSecret(b.vchSecretH, true);
- vchPubKeyH = H.GetPubKey().Raw();
+ CKey H(b.vchSecretH);
+ vchPubKeyH = H.GetPubKey();
return (*this);
}
CMalleablePubKey CMalleableKeyView::GetMalleablePubKey() const
{
- CKey keyL;
- keyL.SetSecret(vchSecretL, true);
+ CKey keyL(vchSecretL);
return CMalleablePubKey(keyL.GetPubKey(), vchPubKeyH);
}
// Check ownership
bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const
{
+ if (!IsValid()) {
+ throw key_error("CMalleableKeyView::CheckKeyVariant() : Attempting to run on invalid view object.");
+ }
+
if (!R.IsValid()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : R is invalid");
+ printf("CMalleableKeyView::CheckKeyVariant() : R is invalid");
+ return false;
}
if (!vchPubKeyVariant.IsValid()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid");
+ printf("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid");
+ return false;
}
CPoint point_R;
if (!point_R.setPubKey(R)) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value");
+ return false;
}
CPoint point_H;
if (!point_H.setPubKey(vchPubKeyH)) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value");
+ return false;
}
CPoint point_P;
if (!point_P.setPubKey(vchPubKeyVariant)) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value");
+ return false;
}
// Infinity points are senseless
if (point_P.IsInfinity()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : P is infinity");
+ printf("CMalleableKeyView::CheckKeyVariant() : P is infinity");
+ return false;
}
CBigNum bnl;
std::vector<unsigned char> vchRl;
if (!point_R.getBytes(vchRl)) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value");
+ printf("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value");
+ return false;
}
// Calculate Hash(R*l)
// Infinity points are senseless
if (point_Ps.IsInfinity()) {
- throw key_error("CMalleableKeyView::CheckKeyVariant() : Ps is infinity");
+ printf("CMalleableKeyView::CheckKeyVariant() : Ps is infinity");
+ return false;
}
// Check ownership
void CPubKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
{
- CKey key;
- key.SetPubKey(*this);
-
- key.EncryptData(data, encrypted);
-}
-
-void CKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
-{
ies_ctx_t *ctx;
char error[1024] = "Unknown error";
cryptogram_t *cryptogram;
+ const unsigned char* pbegin = &vbytes[0];
+ EC_KEY *pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ if (!o2i_ECPublicKey(&pkey, &pbegin, size()))
+ throw key_error("Unable to parse EC key");
+
ctx = create_context(pkey);
if (!EC_KEY_get0_public_key(ctx->user_key))
throw key_error("Given EC key is not public key");
cryptogram = ecies_encrypt(ctx, (unsigned char*)&data[0], data.size(), error);
if (cryptogram == NULL) {
- free(ctx);
+ delete ctx;
ctx = NULL;
throw key_error(std::string("Error in encryption: %s") + error);
}
unsigned char *key_data = cryptogram_key_data(cryptogram);
memcpy(&encrypted[0], key_data, encrypted.size());
cryptogram_free(cryptogram);
- free(ctx);
+ delete ctx;
}
void CKey::DecryptData(const std::vector<unsigned char>& encrypted, std::vector<unsigned char>& data)
decrypted = ecies_decrypt(ctx, cryptogram, &length, error);
cryptogram_free(cryptogram);
- free(ctx);
+ delete ctx;
if (decrypted == NULL) {
throw key_error(std::string("Error in decryption: %s") + error);
git://git.novaco.in / novacoin.git / blobdiff