X-Git-Url: https://git.novaco.in/?p=novacoin.git;a=blobdiff_plain;f=src%2Fkey.cpp;h=1c700d0754ffdb62c79d07c2b83f9a701d5507f0;hp=6239ba5712e1c848c7f0d8d23fa71b804c53cecd;hb=73e57db0e728423c3541f5ad7b260e8fd9e6e7d1;hpb=afc2bcf340f842111978138a9e04e0b14e5de9fe diff --git a/src/key.cpp b/src/key.cpp index 6239ba5..1c700d0 100644 --- a/src/key.cpp +++ b/src/key.cpp @@ -5,9 +5,11 @@ #include #include +#include #include #include "key.h" +#include "base58.h" // Generate a private key from just the secret parameter int EC_KEY_regenerate_key(EC_KEY *eckey, BIGNUM *priv_key) @@ -163,8 +165,6 @@ const unsigned char vchMaxModHalfOrder[32] = { const unsigned char *vchZero = NULL; - - void CKey::SetCompressedPubKey() { EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED); @@ -173,13 +173,12 @@ void CKey::SetCompressedPubKey() 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() @@ -194,6 +193,15 @@ CKey::CKey(const CKey& b) if (pkey == NULL) throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed"); fSet = b.fSet; + fCompressedPubKey = b.fCompressedPubKey; +} + +CKey::CKey(const CSecret& b, bool fCompressed) +{ + pkey = EC_KEY_new_by_curve_name(NID_secp256k1); + if (pkey == NULL) + throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed"); + SetSecret(b, fCompressed); } CKey& CKey::operator=(const CKey& b) @@ -201,12 +209,14 @@ CKey& CKey::operator=(const CKey& b) if (!EC_KEY_copy(pkey, b.pkey)) throw key_error("CKey::operator=(const CKey&) : EC_KEY_copy failed"); fSet = b.fSet; + fCompressedPubKey = b.fCompressedPubKey; return (*this); } CKey::~CKey() { - EC_KEY_free(pkey); + if (pkey != NULL) + EC_KEY_free(pkey); } bool CKey::IsNull() const @@ -224,7 +234,7 @@ bool CKey::CheckSignatureElement(const unsigned char *vch, int len, bool half) { CompareBigEndian(vch, len, half ? vchMaxModHalfOrder : vchMaxModOrder, 32) <= 0; } -bool CKey::ReserealizeSignature(std::vector& vchSig) +bool CPubKey::ReserealizeSignature(std::vector& vchSig) { if (vchSig.empty()) return false; @@ -288,6 +298,7 @@ bool CKey::SetSecret(const CSecret& vchSecret, bool fCompressed) 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()); @@ -320,6 +331,23 @@ CSecret CKey::GetSecret(bool &fCompressed) const 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 GetSecret(fCompressed); +} + CPrivKey CKey::GetPrivKey() const { int nSize = i2d_ECPrivateKey(pkey, NULL); @@ -332,21 +360,6 @@ CPrivKey CKey::GetPrivKey() const 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); @@ -445,7 +458,7 @@ bool CKey::SignCompact(uint256 hash, std::vector& vchSig) // 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& vchSig) +bool CPubKey::SetCompactSignature(uint256 hash, const std::vector& vchSig) { if (vchSig.size() != 65) return false; @@ -456,28 +469,46 @@ bool CKey::SetCompactSignature(uint256 hash, const std::vector& v 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 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& vchSig) +bool CPubKey::Verify(const uint256 &hash, const std::vector& 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(); @@ -505,14 +536,11 @@ bool CKey::Verify(uint256 hash, const std::vector& vchSig) return ret; } -bool CKey::VerifyCompact(uint256 hash, const std::vector& vchSig) +bool CPubKey::VerifyCompact(uint256 hash, const std::vector& vchSig) { - CKey key; + CPubKey key; if (!key.SetCompactSignature(hash, vchSig)) return false; - if (GetPubKey() != key.GetPubKey()) - return false; - return true; } @@ -528,5 +556,701 @@ bool CKey::IsValid() CSecret secret = GetSecret(fCompr); CKey key2; key2.SetSecret(secret, fCompr); + return GetPubKey() == key2.GetPubKey(); } + +CPoint::CPoint() +{ + std::string err; + group = NULL; + point = NULL; + ctx = NULL; + + group = EC_GROUP_new_by_curve_name(NID_secp256k1); + if (!group) { + err = "EC_KEY_new_by_curve_name failed."; + goto finish; + } + + point = EC_POINT_new(group); + if (!point) { + err = "EC_POINT_new failed."; + goto finish; + } + + ctx = BN_CTX_new(); + if (!ctx) { + err = "BN_CTX_new failed."; + goto finish; + } + + return; + +finish: + if (group) EC_GROUP_free(group); + if (point) EC_POINT_free(point); + throw std::runtime_error(std::string("CPoint::CPoint() : - ") + err); +} + +bool CPoint::operator!=(const CPoint &a) +{ + if (EC_POINT_cmp(group, point, a.point, ctx) != 0) + return true; + return false; +} +CPoint::~CPoint() +{ + if (point) EC_POINT_free(point); + if (group) EC_GROUP_free(group); + if (ctx) BN_CTX_free(ctx); +} + +// Initialize from octets stream +bool CPoint::setBytes(const std::vector &vchBytes) +{ + if (!EC_POINT_oct2point(group, point, &vchBytes[0], vchBytes.size(), ctx)) { + return false; + } + return true; +} + +// Initialize from octets stream +bool CPoint::setPubKey(const CPubKey &key) +{ + std::vector vchPubKey(key.begin(), key.end()); + return setBytes(vchPubKey); +} + +// Serialize to octets stream +bool CPoint::getBytes(std::vector &vchBytes) +{ + 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 true; +} + +// ECC multiplication by specified multiplier +bool CPoint::ECMUL(const CBigNum &bnMultiplier) +{ + if (!EC_POINT_mul(group, point, NULL, point, &bnMultiplier, NULL)) { + printf("CPoint::ECMUL() : EC_POINT_mul failed"); + return false; + } + + return true; +} + +// Calculate G*m + q +bool CPoint::ECMULGEN(const CBigNum &bnMultiplier, const CPoint &qPoint) +{ + if (!EC_POINT_mul(group, point, &bnMultiplier, qPoint.point, BN_value_one(), NULL)) { + printf("CPoint::ECMULGEN() : EC_POINT_mul failed."); + return false; + } + + return true; +} + +// CMalleablePubKey + +void CMalleablePubKey::GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant) +{ + EC_KEY *eckey = NULL; + eckey = EC_KEY_new_by_curve_name(NID_secp256k1); + if (eckey == NULL) { + throw key_error("CMalleablePubKey::GetVariant() : EC_KEY_new_by_curve_name failed"); + } + + // Use standard key generation function to get r and R values. + // + // r will be presented by private key; + // R is ECDSA public key which calculated as G*r + if (!EC_KEY_generate_key(eckey)) { + throw key_error("CMalleablePubKey::GetVariant() : EC_KEY_generate_key failed"); + } + + EC_KEY_set_conv_form(eckey, POINT_CONVERSION_COMPRESSED); + + int nSize = i2o_ECPublicKey(eckey, NULL); + if (!nSize) { + throw key_error("CMalleablePubKey::GetVariant() : i2o_ECPublicKey failed"); + } + + std::vector vchPubKey(nSize, 0); + unsigned char* pbegin_R = &vchPubKey[0]; + + if (i2o_ECPublicKey(eckey, &pbegin_R) != nSize) { + throw key_error("CMalleablePubKey::GetVariant() : i2o_ECPublicKey returned unexpected size"); + } + + // R = G*r + R = CPubKey(vchPubKey); + + // OpenSSL BIGNUM representation of r value + CBigNum bnr; + bnr = *(CBigNum*) EC_KEY_get0_private_key(eckey); + EC_KEY_free(eckey); + + CPoint point; + if (!point.setPubKey(pubKeyL)) { + throw key_error("CMalleablePubKey::GetVariant() : Unable to decode L value"); + } + + // Calculate L*r + point.ECMUL(bnr); + + std::vector vchLr; + if (!point.getBytes(vchLr)) { + throw key_error("CMalleablePubKey::GetVariant() : Unable to convert Lr value"); + } + + // Calculate Hash(L*r) and then get a BIGNUM representation of hash value. + CBigNum bnHash; + bnHash.setuint160(Hash160(vchLr)); + + CPoint pointH; + pointH.setPubKey(pubKeyH); + + CPoint P; + // Calculate P = Hash(L*r)*G + H + P.ECMULGEN(bnHash, pointH); + + if (P.IsInfinity()) { + throw key_error("CMalleablePubKey::GetVariant() : P is infinity"); + } + + std::vector vchResult; + P.getBytes(vchResult); + + vchPubKeyVariant = CPubKey(vchResult); +} + +std::string CMalleablePubKey::ToString() const +{ + CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); + ssKey << *this; + std::vector vch(ssKey.begin(), ssKey.end()); + + return EncodeBase58Check(vch); +} + +bool CMalleablePubKey::setvch(const std::vector &vchPubKeyPair) +{ + CDataStream ssKey(vchPubKeyPair, SER_NETWORK, PROTOCOL_VERSION); + ssKey >> *this; + + return IsValid(); +} + +std::vector CMalleablePubKey::Raw() const +{ + CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); + ssKey << *this; + std::vector vch(ssKey.begin(), ssKey.end()); + + return vch; +} + +bool CMalleablePubKey::SetString(const std::string& strMalleablePubKey) +{ + std::vector vchTemp; + if (!DecodeBase58Check(strMalleablePubKey, vchTemp)) { + throw key_error("CMalleablePubKey::SetString() : Provided key data seems corrupted."); + } + + CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION); + ssKey >> *this; + + return IsValid(); +} + +bool CMalleablePubKey::operator==(const CMalleablePubKey &b) +{ + return pubKeyL == b.pubKeyL && pubKeyH == b.pubKeyH; +} + + +// CMalleableKey + +void CMalleableKey::Reset() +{ + vchSecretL.clear(); + vchSecretH.clear(); +} + +void CMalleableKey::MakeNewKeys() +{ + Reset(); + + CKey keyL, keyH; + keyL.MakeNewKey(); + keyH.MakeNewKey(); + + vchSecretL = keyL.GetSecret(); + vchSecretH = keyH.GetSecret(); +} + +CMalleableKey::CMalleableKey() +{ + Reset(); +} + +CMalleableKey::CMalleableKey(const CMalleableKey &b) +{ + SetSecrets(b.vchSecretL, b.vchSecretH); +} + +CMalleableKey::CMalleableKey(const CSecret &L, const CSecret &H) +{ + SetSecrets(L, H); +} + +CMalleableKey::~CMalleableKey() +{ +} + +bool CMalleableKey::IsNull() const +{ + return vchSecretL.size() != 32 || vchSecretH.size() != 32; +} + +bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH) +{ + Reset(); + + CKey keyL(pvchSecretL); + CKey keyH(pvchSecretH); + + if (!keyL.IsValid() || !keyH.IsValid()) + return false; + + vchSecretL = pvchSecretL; + vchSecretH = pvchSecretH; + + return true; +} + +CMalleablePubKey CMalleableKey::GetMalleablePubKey() const +{ + CKey L(vchSecretL), H(vchSecretH); + return CMalleablePubKey(L.GetPubKey(), H.GetPubKey()); +} + +// Check ownership +bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const +{ + if (IsNull()) { + throw key_error("CMalleableKey::CheckKeyVariant() : Attempting to run on NULL key object."); + } + + if (!R.IsValid()) { + printf("CMalleableKey::CheckKeyVariant() : R is invalid"); + return false; + } + + if (!vchPubKeyVariant.IsValid()) { + printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid"); + return false; + } + + CPoint point_R; + if (!point_R.setPubKey(R)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value"); + return false; + } + + CKey H(vchSecretH); + CPubKey vchPubKeyH = H.GetPubKey(); + + CPoint point_H; + if (!point_H.setPubKey(vchPubKeyH)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value"); + return false; + } + + CPoint point_P; + if (!point_P.setPubKey(vchPubKeyVariant)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value"); + return false; + } + + // Infinity points are senseless + if (point_P.IsInfinity()) { + printf("CMalleableKey::CheckKeyVariant() : P is infinity"); + return false; + } + + CBigNum bnl; + bnl.setBytes(std::vector(vchSecretL.begin(), vchSecretL.end())); + + point_R.ECMUL(bnl); + + std::vector vchRl; + if (!point_R.getBytes(vchRl)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value"); + return false; + } + + // Calculate Hash(R*l) + CBigNum bnHash; + bnHash.setuint160(Hash160(vchRl)); + + CPoint point_Ps; + // Calculate Ps = Hash(L*r)*G + H + point_Ps.ECMULGEN(bnHash, point_H); + + // Infinity points are senseless + if (point_Ps.IsInfinity()) { + printf("CMalleableKey::CheckKeyVariant() : Ps is infinity"); + return false; + } + + // Check ownership + if (point_Ps != point_P) { + return false; + } + + return true; +} + +// Check ownership and restore private key +bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant) const +{ + if (IsNull()) { + throw key_error("CMalleableKey::CheckKeyVariant() : Attempting to run on NULL key object."); + } + + if (!R.IsValid()) { + printf("CMalleableKey::CheckKeyVariant() : R is invalid"); + return false; + } + + if (!vchPubKeyVariant.IsValid()) { + printf("CMalleableKey::CheckKeyVariant() : public key variant is invalid"); + return false; + } + + CPoint point_R; + if (!point_R.setPubKey(R)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to decode R value"); + return false; + } + + CKey H(vchSecretH); + CPubKey vchPubKeyH = H.GetPubKey(); + + CPoint point_H; + if (!point_H.setPubKey(vchPubKeyH)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to decode H value"); + return false; + } + + CPoint point_P; + if (!point_P.setPubKey(vchPubKeyVariant)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to decode P value"); + return false; + } + + // Infinity points are senseless + if (point_P.IsInfinity()) { + printf("CMalleableKey::CheckKeyVariant() : P is infinity"); + return false; + } + + CBigNum bnl; + bnl.setBytes(std::vector(vchSecretL.begin(), vchSecretL.end())); + + point_R.ECMUL(bnl); + + std::vector vchRl; + if (!point_R.getBytes(vchRl)) { + printf("CMalleableKey::CheckKeyVariant() : Unable to convert Rl value"); + return false; + } + + // Calculate Hash(R*l) + CBigNum bnHash; + bnHash.setuint160(Hash160(vchRl)); + + CPoint point_Ps; + // Calculate Ps = Hash(L*r)*G + H + point_Ps.ECMULGEN(bnHash, point_H); + + // Infinity points are senseless + if (point_Ps.IsInfinity()) { + printf("CMalleableKey::CheckKeyVariant() : Ps is infinity"); + return false; + } + + // Check ownership + if (point_Ps != point_P) { + return false; + } + + // OpenSSL BIGNUM representation of the second private key from (l, h) pair + CBigNum bnh; + bnh.setBytes(std::vector(vchSecretH.begin(), vchSecretH.end())); + + // Calculate p = Hash(R*l) + h + CBigNum bnp = bnHash + bnh; + + std::vector vchp = bnp.getBytes(); + privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end())); + + return true; +} + +std::string CMalleableKey::ToString() const +{ + CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); + ssKey << *this; + std::vector vch(ssKey.begin(), ssKey.end()); + + return EncodeBase58Check(vch); +} + +std::vector CMalleableKey::Raw() const +{ + CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); + ssKey << *this; + std::vector vch(ssKey.begin(), ssKey.end()); + + return vch; +} + +bool CMalleableKey::SetString(const std::string& strMutableKey) +{ + std::vector vchTemp; + if (!DecodeBase58Check(strMutableKey, vchTemp)) { + throw key_error("CMalleableKey::SetString() : Provided key data seems corrupted."); + } + + CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION); + ssKey >> *this; + + return IsValid(); +} + +// CMalleableKeyView + +CMalleableKeyView::CMalleableKeyView(const std::string &strMalleableKey) +{ + SetString(strMalleableKey); +} + +CMalleableKeyView::CMalleableKeyView(const CMalleableKey &b) +{ + if (b.vchSecretL.size() != 32) + throw key_error("CMalleableKeyView::CMalleableKeyView() : L size must be 32 bytes"); + + if (b.vchSecretH.size() != 32) + throw key_error("CMalleableKeyView::CMalleableKeyView() : H size must be 32 bytes"); + + vchSecretL = b.vchSecretL; + + CKey H(b.vchSecretH); + vchPubKeyH = H.GetPubKey(); +} + +CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b) +{ + vchSecretL = b.vchSecretL; + vchPubKeyH = b.vchPubKeyH; +} + +CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b) +{ + vchSecretL = b.vchSecretL; + + CKey H(b.vchSecretH); + vchPubKeyH = H.GetPubKey(); + + return (*this); +} + +CMalleableKeyView::~CMalleableKeyView() +{ +} + +CMalleablePubKey CMalleableKeyView::GetMalleablePubKey() const +{ + 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()) { + printf("CMalleableKeyView::CheckKeyVariant() : R is invalid"); + return false; + } + + if (!vchPubKeyVariant.IsValid()) { + printf("CMalleableKeyView::CheckKeyVariant() : public key variant is invalid"); + return false; + } + + CPoint point_R; + if (!point_R.setPubKey(R)) { + printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value"); + return false; + } + + CPoint point_H; + if (!point_H.setPubKey(vchPubKeyH)) { + printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value"); + return false; + } + + CPoint point_P; + if (!point_P.setPubKey(vchPubKeyVariant)) { + printf("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value"); + return false; + } + + // Infinity points are senseless + if (point_P.IsInfinity()) { + printf("CMalleableKeyView::CheckKeyVariant() : P is infinity"); + return false; + } + + CBigNum bnl; + bnl.setBytes(std::vector(vchSecretL.begin(), vchSecretL.end())); + + point_R.ECMUL(bnl); + + std::vector vchRl; + if (!point_R.getBytes(vchRl)) { + printf("CMalleableKeyView::CheckKeyVariant() : Unable to convert Rl value"); + return false; + } + + // Calculate Hash(R*l) + CBigNum bnHash; + bnHash.setuint160(Hash160(vchRl)); + + CPoint point_Ps; + // Calculate Ps = Hash(L*r)*G + H + point_Ps.ECMULGEN(bnHash, point_H); + + // Infinity points are senseless + if (point_Ps.IsInfinity()) { + printf("CMalleableKeyView::CheckKeyVariant() : Ps is infinity"); + return false; + } + + // Check ownership + if (point_Ps != point_P) { + return false; + } + + return true; +} + +std::string CMalleableKeyView::ToString() const +{ + CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); + ssKey << *this; + std::vector vch(ssKey.begin(), ssKey.end()); + + return EncodeBase58Check(vch); +} + +bool CMalleableKeyView::SetString(const std::string& strMutableKey) +{ + std::vector vchTemp; + if (!DecodeBase58Check(strMutableKey, vchTemp)) { + throw key_error("CMalleableKeyView::SetString() : Provided key data seems corrupted."); + } + + CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION); + ssKey >> *this; + + return IsValid(); +} + +std::vector CMalleableKeyView::Raw() const +{ + CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); + ssKey << *this; + std::vector vch(ssKey.begin(), ssKey.end()); + + return vch; +} + + +bool CMalleableKeyView::IsValid() const +{ + return vchSecretL.size() == 32 && GetMalleablePubKey().IsValid(); +} + +//// Asymmetric encryption + +void CPubKey::EncryptData(const std::vector& data, std::vector& 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) { + delete ctx; + ctx = NULL; + throw key_error(std::string("Error in encryption: %s") + error); + } + + encrypted.resize(cryptogram_data_sum_length(cryptogram)); + unsigned char *key_data = cryptogram_key_data(cryptogram); + memcpy(&encrypted[0], key_data, encrypted.size()); + cryptogram_free(cryptogram); + delete ctx; +} + +void CKey::DecryptData(const std::vector& encrypted, std::vector& data) +{ + ies_ctx_t *ctx; + char error[1024] = "Unknown error"; + cryptogram_t *cryptogram; + size_t length; + unsigned char *decrypted; + + ctx = create_context(pkey); + if (!EC_KEY_get0_private_key(ctx->user_key)) + throw key_error("Given EC key is not private key"); + + size_t key_length = ctx->stored_key_length; + size_t mac_length = EVP_MD_size(ctx->md); + cryptogram = cryptogram_alloc(key_length, mac_length, encrypted.size() - key_length - mac_length); + + memcpy(cryptogram_key_data(cryptogram), &encrypted[0], encrypted.size()); + + decrypted = ecies_decrypt(ctx, cryptogram, &length, error); + cryptogram_free(cryptogram); + delete ctx; + + if (decrypted == NULL) { + throw key_error(std::string("Error in decryption: %s") + error); + } + + data.resize(length); + memcpy(&data[0], decrypted, length); + free(decrypted); +}