X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fkey.cpp;h=b1db7cbf0e6a6f313ce1509a6d659f4640412bba;hb=5f3f7465db4444e49dd4a896f88c090b40d0a303;hp=39a7ebbabd6ccd34611696324159a5cd5e242207;hpb=6db849791e675fa14d1222f86011ec6c08c84183;p=novacoin.git diff --git a/src/key.cpp b/src/key.cpp index 39a7ebb..b1db7cb 100644 --- a/src/key.cpp +++ b/src/key.cpp @@ -198,6 +198,14 @@ CKey::CKey(const CKey& b) 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) { if (!EC_KEY_copy(pkey, b.pkey)) @@ -323,6 +331,12 @@ CSecret CKey::GetSecret(bool &fCompressed) const return vchRet; } +CSecret CKey::GetSecret() const +{ + bool fCompressed; + return GetSecret(fCompressed); +} + CPrivKey CKey::GetPrivKey() const { int nSize = i2d_ECPrivateKey(pkey, NULL); @@ -589,6 +603,12 @@ bool CPoint::setBytes(const std::vector &vchBytes) return true; } +// Initialize from octets stream +bool CPoint::setPubKey(const CPubKey &vchPubKey) +{ + return setBytes(vchPubKey.Raw()); +} + // Serialize to octets stream bool CPoint::getBytes(std::vector &vchBytes) { @@ -663,7 +683,7 @@ void CMalleablePubKey::GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant) EC_KEY_free(eckey); CPoint point; - if (!point.setBytes(pubKeyL.Raw())) { + if (!point.setPubKey(pubKeyL)) { throw key_error("CMalleablePubKey::GetVariant() : Unable to decode L value"); } @@ -680,7 +700,7 @@ void CMalleablePubKey::GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant) bnHash.setuint160(Hash160(vchLr)); CPoint pointH; - pointH.setBytes(pubKeyH.Raw()); + pointH.setPubKey(pubKeyH); CPoint P; // Calculate P = Hash(L*r)*G + H @@ -696,7 +716,7 @@ void CMalleablePubKey::GetVariant(CPubKey &R, CPubKey &vchPubKeyVariant) vchPubKeyVariant = CPubKey(vchResult); } -std::string CMalleablePubKey::ToString() +std::string CMalleablePubKey::ToString() const { CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); ssKey << *this; @@ -705,6 +725,15 @@ std::string CMalleablePubKey::ToString() return EncodeBase58Check(vch); } +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; @@ -720,9 +749,7 @@ bool CMalleablePubKey::SetString(const std::string& strMalleablePubKey) bool CMalleablePubKey::operator==(const CMalleablePubKey &b) { - return (nVersion == b.nVersion && - pubKeyL == b.pubKeyL && - pubKeyH == b.pubKeyH); + return pubKeyL == b.pubKeyL && pubKeyH == b.pubKeyH; } @@ -732,22 +759,18 @@ void CMalleableKey::Reset() { vchSecretL.clear(); vchSecretH.clear(); - - nVersion = 0; } void CMalleableKey::MakeNewKeys() { - CKey L, H; - bool fCompressed = true; - - L.MakeNewKey(true); - H.MakeNewKey(true); + Reset(); - vchSecretL = L.GetSecret(fCompressed); - vchSecretH = H.GetSecret(fCompressed); + CKey keyL, keyH; + keyL.MakeNewKey(); + keyH.MakeNewKey(); - nVersion = CURRENT_VERSION; + vchSecretL = keyL.GetSecret(); + vchSecretH = keyH.GetSecret(); } CMalleableKey::CMalleableKey() @@ -765,46 +788,31 @@ CMalleableKey::CMalleableKey(const CSecret &L, const CSecret &H) SetSecrets(L, H); } -CMalleableKey& CMalleableKey::operator=(const CMalleableKey &b) -{ - SetSecrets(b.vchSecretL, b.vchSecretH); - - return (*this); -} - CMalleableKey::~CMalleableKey() { } bool CMalleableKey::IsNull() const { - return nVersion != CURRENT_VERSION; + return vchSecretL.size() != 32 || vchSecretH.size() != 32; } bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSecretH) { Reset(); - CKey L, H; - if (!L.SetSecret(pvchSecretL, true) || !H.SetSecret(pvchSecretH, true)) - { - nVersion = 0; + CKey keyL(pvchSecretL); + CKey keyH(pvchSecretH); + + if (!keyL.IsValid() || !keyL.IsValid()) return false; - } vchSecretL = pvchSecretL; vchSecretH = pvchSecretH; - nVersion = CURRENT_VERSION; return true; } -void CMalleableKey::GetSecrets(CSecret &pvchSecretL, CSecret &pvchSecretH) const -{ - pvchSecretL = vchSecretL; - pvchSecretH = vchSecretH; -} - CMalleablePubKey CMalleableKey::GetMalleablePubKey() const { CKey L, H; @@ -818,7 +826,7 @@ CMalleablePubKey CMalleableKey::GetMalleablePubKey() const } // Check ownership -bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) +bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const { if (IsNull()) { throw key_error("CMalleableKey::CheckKeyVariant() : Attempting to run on NULL key object."); @@ -833,7 +841,7 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa } CPoint point_R; - if (!point_R.setBytes(R.Raw())) { + if (!point_R.setPubKey(R)) { throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value"); } @@ -842,12 +850,12 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa std::vector vchPubKeyH = H.GetPubKey().Raw(); CPoint point_H; - if (!point_H.setBytes(vchPubKeyH)) { + if (!point_H.setPubKey(vchPubKeyH)) { throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value"); } CPoint point_P; - if (!point_P.setBytes(vchPubKeyVariant.Raw())) { + if (!point_P.setPubKey(vchPubKeyVariant)) { throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value"); } @@ -888,7 +896,7 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa } // Check ownership and restore private key -bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant, CKey &privKeyVariant) +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."); @@ -903,7 +911,7 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa } CPoint point_R; - if (!point_R.setBytes(R.Raw())) { + if (!point_R.setPubKey(R)) { throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode R value"); } @@ -912,12 +920,12 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa std::vector vchPubKeyH = H.GetPubKey().Raw(); CPoint point_H; - if (!point_H.setBytes(vchPubKeyH)) { + if (!point_H.setPubKey(vchPubKeyH)) { throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode H value"); } CPoint point_P; - if (!point_P.setBytes(vchPubKeyVariant.Raw())) { + if (!point_P.setPubKey(vchPubKeyVariant)) { throw key_error("CMalleableKey::CheckKeyVariant() : Unable to decode P value"); } @@ -967,7 +975,7 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa return true; } -std::string CMalleableKey::ToString() +std::string CMalleableKey::ToString() const { CDataStream ssKey(SER_NETWORK, PROTOCOL_VERSION); ssKey << *this; @@ -976,6 +984,15 @@ std::string CMalleableKey::ToString() 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; @@ -986,30 +1003,40 @@ bool CMalleableKey::SetString(const std::string& strMutableKey) CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION); ssKey >> *this; - return IsNull(); + return IsValid(); } // CMalleableKeyView +CMalleableKeyView::CMalleableKeyView(const std::string &strMalleableKey) +{ + SetString(strMalleableKey); +} + CMalleableKeyView::CMalleableKeyView(const CMalleableKey &b) { - assert(b.nVersion == CURRENT_VERSION); + 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() : L size must be 32 bytes"); + vchSecretL = b.vchSecretL; CKey H; H.SetSecret(b.vchSecretH, true); + vchPubKeyH = H.GetPubKey().Raw(); } -CMalleableKeyView::CMalleableKeyView(const CSecret &L, const CPubKey &pvchPubKeyH) +CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b) { - vchSecretL = L; - vchPubKeyH = pvchPubKeyH.Raw(); + vchSecretL = b.vchSecretL; + vchPubKeyH = b.vchPubKeyH; } CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b) { - assert(b.nVersion == CURRENT_VERSION); vchSecretL = b.vchSecretL; CKey H; @@ -1031,7 +1058,7 @@ CMalleablePubKey CMalleableKeyView::GetMalleablePubKey() const } // Check ownership -bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) +bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVariant) const { if (!R.IsValid()) { throw key_error("CMalleableKeyView::CheckKeyVariant() : R is invalid"); @@ -1042,17 +1069,17 @@ bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubK } CPoint point_R; - if (!point_R.setBytes(R.Raw())) { + if (!point_R.setPubKey(R)) { throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode R value"); } CPoint point_H; - if (!point_H.setBytes(vchPubKeyH)) { + if (!point_H.setPubKey(vchPubKeyH)) { throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode H value"); } CPoint point_P; - if (!point_P.setBytes(vchPubKeyVariant.Raw())) { + if (!point_P.setPubKey(vchPubKeyVariant)) { throw key_error("CMalleableKeyView::CheckKeyVariant() : Unable to decode P value"); } @@ -1092,6 +1119,43 @@ bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubK 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)