X-Git-Url: https://git.novaco.in/?p=novacoin.git;a=blobdiff_plain;f=src%2Fkey.cpp;h=1c700d0754ffdb62c79d07c2b83f9a701d5507f0;hp=1012915c1ef6bdacc7707c8862fd083603999863;hb=73e57db0e728423c3541f5ad7b260e8fd9e6e7d1;hpb=fbd44e84d5841867d36d295d4f347fd5e55d293f diff --git a/src/key.cpp b/src/key.cpp index 1012915..1c700d0 100644 --- a/src/key.cpp +++ b/src/key.cpp @@ -5,6 +5,7 @@ #include #include +#include #include #include "key.h" @@ -164,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); @@ -174,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() @@ -217,7 +215,8 @@ CKey& CKey::operator=(const CKey& b) CKey::~CKey() { - EC_KEY_free(pkey); + if (pkey != NULL) + EC_KEY_free(pkey); } bool CKey::IsNull() const @@ -235,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; @@ -299,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()); @@ -331,6 +331,17 @@ 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; @@ -349,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); @@ -462,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; @@ -473,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(); @@ -522,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; } @@ -545,6 +556,7 @@ bool CKey::IsValid() CSecret secret = GetSecret(fCompr); CKey key2; key2.SetSecret(secret, fCompr); + return GetPubKey() == key2.GetPubKey(); } @@ -604,15 +616,16 @@ bool CPoint::setBytes(const std::vector &vchBytes) } // Initialize from octets stream -bool CPoint::setPubKey(const CPubKey &vchPubKey) +bool CPoint::setPubKey(const CPubKey &key) { - return setBytes(vchPubKey.Raw()); + std::vector vchPubKey(key.begin(), key.end()); + return setBytes(vchPubKey); } // Serialize to octets stream bool CPoint::getBytes(std::vector &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; @@ -812,7 +825,7 @@ bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSe CKey keyL(pvchSecretL); CKey keyH(pvchSecretH); - if (!keyL.IsValid() || !keyL.IsValid()) + if (!keyL.IsValid() || !keyH.IsValid()) return false; vchSecretL = pvchSecretL; @@ -823,14 +836,8 @@ bool CMalleableKey::SetSecrets(const CSecret &pvchSecretL, const CSecret &pvchSe 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(), H.GetPubKey()); } // Check ownership @@ -841,35 +848,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); - std::vector 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; @@ -879,7 +891,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) @@ -892,7 +905,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 @@ -911,35 +925,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); - std::vector 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; @@ -949,7 +968,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) @@ -962,7 +982,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 @@ -978,7 +999,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; } @@ -1027,14 +1048,12 @@ CMalleableKeyView::CMalleableKeyView(const CMalleableKey &b) 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) @@ -1047,9 +1066,8 @@ CMalleableKeyView& CMalleableKeyView::operator=(const CMalleableKey &b) { vchSecretL = b.vchSecretL; - CKey H; - H.SetSecret(b.vchSecretH, true); - vchPubKeyH = H.GetPubKey().Raw(); + CKey H(b.vchSecretH); + vchPubKeyH = H.GetPubKey(); return (*this); } @@ -1060,40 +1078,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; @@ -1103,7 +1130,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) @@ -1116,7 +1144,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 @@ -1168,25 +1197,22 @@ bool CMalleableKeyView::IsValid() const void CPubKey::EncryptData(const std::vector& data, std::vector& encrypted) { - CKey key; - key.SetPubKey(*this); - - key.EncryptData(data, encrypted); -} - -void CKey::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) { - free(ctx); + delete ctx; ctx = NULL; throw key_error(std::string("Error in encryption: %s") + error); } @@ -1195,7 +1221,7 @@ void CKey::EncryptData(const std::vector& data, std::vector& encrypted, std::vector& data) @@ -1218,7 +1244,7 @@ void CKey::DecryptData(const std::vector& encrypted, std::vector< 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);