X-Git-Url: https://git.novaco.in/?p=novacoin.git;a=blobdiff_plain;f=src%2Fkey.cpp;h=49868b8f394abdd193165ad60dc08b356b922cca;hp=c37b1023fdf3d6bbf62986e48b92cb808ccae868;hb=15e9a03687e99d6b1a7a90e56e69a37faa6bb9b8;hpb=7f70ddc68f4afa4a87a15e620ba519afbc5c8b15 diff --git a/src/key.cpp b/src/key.cpp index c37b102..49868b8 100644 --- a/src/key.cpp +++ b/src/key.cpp @@ -6,12 +6,9 @@ #include #include -#include -#include #include "key.h" #include "base58.h" -#include "ies.h" // Generate a private key from just the secret parameter int EC_KEY_regenerate_key(EC_KEY *eckey, BIGNUM *priv_key) @@ -201,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)) @@ -326,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); @@ -714,6 +725,14 @@ std::string CMalleablePubKey::ToString() const 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); @@ -738,9 +757,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; } @@ -750,22 +767,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() @@ -783,58 +796,35 @@ 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 (pvchSecretL.size() != 32 || !pvchSecretH.size() != 32 || !L.SetSecret(pvchSecretL, true) || !H.SetSecret(pvchSecretH, true)) - { - nVersion = 0; + CKey keyL(pvchSecretL); + CKey keyH(pvchSecretH); + + if (!keyL.IsValid() || !keyH.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; - L.SetSecret(vchSecretL, true); - H.SetSecret(vchSecretH, true); - - std::vector vchPubKeyL = L.GetPubKey().Raw(); - std::vector vchPubKeyH = H.GetPubKey().Raw(); - - return CMalleablePubKey(vchPubKeyL, vchPubKeyH); + CKey L(vchSecretL), H(vchSecretH); + return CMalleablePubKey(L.GetPubKey().Raw(), H.GetPubKey().Raw()); } // Check ownership @@ -845,35 +835,40 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa } 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); + CKey H(vchSecretH); std::vector vchPubKeyH = H.GetPubKey().Raw(); 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; @@ -883,7 +878,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa std::vector 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) @@ -896,7 +892,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa // 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 @@ -915,35 +912,40 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa } 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); + CKey H(vchSecretH); std::vector vchPubKeyH = H.GetPubKey().Raw(); 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; @@ -953,7 +955,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa std::vector 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) @@ -966,7 +969,8 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa // 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 @@ -982,7 +986,7 @@ bool CMalleableKey::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubKeyVa CBigNum bnp = bnHash + bnh; std::vector vchp = bnp.getBytes(); - privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end()), true); + privKeyVariant.SetSecret(CSecret(vchp.begin(), vchp.end())); return true; } @@ -1015,50 +1019,42 @@ 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) { 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"); + throw key_error("CMalleableKeyView::CMalleableKeyView() : H size must be 32 bytes"); vchSecretL = b.vchSecretL; - CKey H; - H.SetSecret(b.vchSecretH, true); - + CKey H(b.vchSecretH); vchPubKeyH = H.GetPubKey().Raw(); - nVersion = b.nVersion; } CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b) { vchSecretL = b.vchSecretL; vchPubKeyH = b.vchPubKeyH; - nVersion = CURRENT_VERSION; -} - -CMalleableKeyView::CMalleableKeyView(const CSecret &L, const CPubKey &pvchPubKeyH) -{ - vchSecretL = L; - vchPubKeyH = pvchPubKeyH.Raw(); - nVersion = CURRENT_VERSION; } CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b) { vchSecretL = b.vchSecretL; - CKey H; - H.SetSecret(b.vchSecretH, true); + CKey H(b.vchSecretH); vchPubKeyH = H.GetPubKey().Raw(); - nVersion = b.nVersion; return (*this); } @@ -1069,40 +1065,49 @@ CMalleableKeyView::~CMalleableKeyView() 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; @@ -1112,7 +1117,8 @@ bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubK std::vector 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) @@ -1125,7 +1131,8 @@ bool CMalleableKeyView::CheckKeyVariant(const CPubKey &R, const CPubKey &vchPubK // 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 @@ -1155,7 +1162,7 @@ bool CMalleableKeyView::SetString(const std::string& strMutableKey) CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION); ssKey >> *this; - return IsNull(); + return IsValid(); } std::vector CMalleableKeyView::Raw() const @@ -1168,9 +1175,9 @@ std::vector CMalleableKeyView::Raw() const } -bool CMalleableKeyView::IsNull() const +bool CMalleableKeyView::IsValid() const { - return nVersion != CURRENT_VERSION; + return vchSecretL.size() == 32 && GetMalleablePubKey().IsValid(); } //// Asymmetric encryption