if (!eckey) return 0;
- const EC_GROUP *group = EC_KEY_get0_group(eckey);
+ auto group = EC_KEY_get0_group(eckey);
if ((ctx = BN_CTX_new()) == NULL)
goto err;
int n = 0;
int i = recid / 2;
- const EC_GROUP *group = EC_KEY_get0_group(eckey);
+ auto group = EC_KEY_get0_group(eckey);
if ((ctx = BN_CTX_new()) == NULL) { ret = -1; goto err; }
BN_CTX_start(ctx);
order = BN_CTX_get(ctx);
const unsigned char *vchZero = NULL;
-void CKey::SetCompressedPubKey()
+CScriptID::CScriptID(const CScript& in) : uint160(Hash160(in.begin(), in.end()))
{
- EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
- fCompressedPubKey = true;
+}
+
+void CKey::SetCompressedPubKey(bool fCompressed)
+{
+ EC_KEY_set_conv_form(pkey, fCompressed ? POINT_CONVERSION_COMPRESSED : POINT_CONVERSION_UNCOMPRESSED);
}
void CKey::Reset()
{
- fCompressedPubKey = fSet = false;
+ 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(const CKey&) : EC_KEY_dup failed");
fSet = b.fSet;
- fCompressedPubKey = b.fCompressedPubKey;
}
CKey::CKey(const CSecret& b, bool fCompressed)
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);
}
bool CKey::IsCompressed() const
{
- return fCompressedPubKey;
+ return (EC_KEY_get_conv_form(pkey) == POINT_CONVERSION_COMPRESSED);
}
bool CKey::CheckSignatureElement(const unsigned char *vch, int len, bool half) {
if (vchSig.empty())
return false;
- unsigned char *pos = &vchSig[0];
- ECDSA_SIG *sig = d2i_ECDSA_SIG(NULL, (const unsigned char **)&pos, vchSig.size());
+ auto pos = &vchSig[0];
+ auto sig = d2i_ECDSA_SIG(NULL, (const unsigned char **)&pos, vchSig.size());
if (sig == NULL)
return false;
{
if (!EC_KEY_generate_key(pkey))
throw key_error("CKey::MakeNewKey() : EC_KEY_generate_key failed");
- if (fCompressed)
- SetCompressedPubKey();
+ SetCompressedPubKey(fCompressed);
fSet = true;
}
bool CKey::SetPrivKey(const CPrivKey& vchPrivKey)
{
- const unsigned char* pbegin = &vchPrivKey[0];
+ auto pbegin = &vchPrivKey[0];
if (d2i_ECPrivateKey(&pkey, &pbegin, vchPrivKey.size()))
{
// In testing, d2i_ECPrivateKey can return true
if (vchSecret.size() != 32)
throw key_error("CKey::SetSecret() : secret must be 32 bytes");
- BIGNUM *bn = BN_bin2bn(&vchSecret[0],32,BN_new());
+ auto bn = BN_bin2bn(&vchSecret[0],32,BN_new());
if (bn == NULL)
throw key_error("CKey::SetSecret() : BN_bin2bn failed");
if (!EC_KEY_regenerate_key(pkey,bn))
}
BN_clear_free(bn);
fSet = true;
- if (fCompressed || fCompressedPubKey)
- SetCompressedPubKey();
+ SetCompressedPubKey(fCompressed);
return true;
}
{
CSecret vchRet;
vchRet.resize(32);
- const BIGNUM *bn = EC_KEY_get0_private_key(pkey);
+ auto bn = EC_KEY_get0_private_key(pkey);
int nBytes = BN_num_bytes(bn);
if (bn == NULL)
throw key_error("CKey::GetSecret() : EC_KEY_get0_private_key failed");
int n=BN_bn2bin(bn,&vchRet[32 - nBytes]);
if (n != nBytes)
throw key_error("CKey::GetSecret(): BN_bn2bin failed");
- fCompressed = fCompressedPubKey;
+ fCompressed = IsCompressed();
return vchRet;
}
bool CKey::WritePEM(BIO *streamObj, const SecureString &strPassKey) const // dumppem 4KJLA99FyqMMhjjDe7KnRXK4sjtv9cCtNS /tmp/test.pem 123
{
- EVP_PKEY *evpKey = EVP_PKEY_new();
- bool result = true;
-
- do
- {
- if (!EVP_PKEY_assign_EC_KEY(evpKey, pkey))
- {
- result = error("CKey::WritePEM() : Error initializing EVP_PKEY instance.");
- break;
- }
-
- if(!PEM_write_bio_PKCS8PrivateKey(streamObj, evpKey, EVP_aes_256_cbc(), (char *)&strPassKey[0], strPassKey.size(), NULL, NULL))
- {
- result = error("CKey::WritePEM() : Error writing private key data to stream object");
- break;
- }
+ auto 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");
- if(!PEM_write_bio_PUBKEY(streamObj, evpKey))
- {
- result = error("CKey::WritePEM() : Error writing public key data to stream object");
- break;
- }
- }
- while(false);
-
- EVP_PKEY_free(evpKey);
- return result;
+ return true;
}
CSecret CKey::GetSecret() const
if (!nSize)
throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey failed");
CPrivKey vchPrivKey(nSize, 0);
- unsigned char* pbegin = &vchPrivKey[0];
+ auto pbegin = &vchPrivKey[0];
if (i2d_ECPrivateKey(pkey, &pbegin) != nSize)
throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey returned unexpected size");
return vchPrivKey;
bool CKey::Sign(uint256 hash, std::vector<unsigned char>& vchSig)
{
vchSig.clear();
- ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
+ auto sig = ECDSA_do_sign(hash.begin(), hash.size(), pkey);
if (sig==NULL)
return false;
- const EC_GROUP *group = EC_KEY_get0_group(pkey);
+ auto group = EC_KEY_get0_group(pkey);
CBigNum order, halforder;
EC_GROUP_get_order(group, &order, NULL);
BN_rshift1(&halforder, &order);
if (BN_cmp(sig->s, &halforder) > 0) {
BN_sub(sig->s, &order, sig->s);
}
- unsigned int nSize = ECDSA_size(pkey);
+ size_t nSize = ECDSA_size(pkey);
vchSig.resize(nSize); // Make sure it is big enough
- unsigned char *pos = &vchSig[0];
+ auto pos = &vchSig[0];
nSize = i2d_ECDSA_SIG(sig, &pos);
ECDSA_SIG_free(sig);
vchSig.resize(nSize); // Shrink to fit actual size
// Testing our new signature
- if (ECDSA_verify(0, (unsigned char*)&hash, sizeof(hash), &vchSig[0], vchSig.size(), pkey) != 1) {
+ if (ECDSA_verify(0, hash.begin(), hash.size(), &vchSig[0], vchSig.size(), pkey) != 1) {
vchSig.clear();
return false;
}
// The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
// The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
// 0x1D = second key with even y, 0x1E = second key with odd y
-bool CKey::SignCompact(uint256 hash, std::vector<unsigned char>& vchSig)
+bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig)
{
bool fOk = false;
- ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
+ auto sig = ECDSA_do_sign(hash.begin(), hash.size(), pkey);
if (sig==NULL)
return false;
- const EC_GROUP *group = EC_KEY_get0_group(pkey);
+ auto group = EC_KEY_get0_group(pkey);
CBigNum order, halforder;
EC_GROUP_get_order(group, &order, NULL);
BN_rshift1(&halforder, &order);
vchSig.resize(65,0);
int nBitsR = BN_num_bits(sig->r);
int nBitsS = BN_num_bits(sig->s);
+ bool fCompressedPubKey = IsCompressed();
if (nBitsR <= 256 && nBitsS <= 256)
{
int8_t nRecId = -1;
{
CKey keyRec;
keyRec.fSet = true;
- if (fCompressedPubKey)
- keyRec.SetCompressedPubKey();
- if (ECDSA_SIG_recover_key_GFp(keyRec.pkey, sig, (unsigned char*)&hash, sizeof(hash), i, 1) == 1)
+ keyRec.SetCompressedPubKey(fCompressedPubKey);
+ if (ECDSA_SIG_recover_key_GFp(keyRec.pkey, sig, hash.begin(), hash.size(), i, 1) == 1)
if (keyRec.GetPubKey() == this->GetPubKey())
{
nRecId = i;
// 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 CPubKey::SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig)
+bool CPubKey::SetCompactSignature(const uint256 &hash, const std::vector<unsigned char>& vchSig)
{
if (vchSig.size() != 65)
return false;
int nV = vchSig[0];
if (nV<27 || nV>=35)
return false;
- ECDSA_SIG *sig = ECDSA_SIG_new();
+ bool fSuccessful = false;
+ auto sig = ECDSA_SIG_new();
+ auto pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
BN_bin2bn(&vchSig[1],32,sig->r);
BN_bin2bn(&vchSig[33],32,sig->s);
-
- EC_KEY* pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
if (nV >= 31)
{
nV -= 4;
EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
}
-
do
{
- if (ECDSA_SIG_recover_key_GFp(pkey, sig, (unsigned char*)&hash, sizeof(hash), nV - 27, 0) != 1)
+ if (ECDSA_SIG_recover_key_GFp(pkey, sig, hash.begin(), hash.size(), nV - 27, 0) != 1)
break;
- ECDSA_SIG_free(sig);
-
int nSize = i2o_ECPublicKey(pkey, NULL);
if (!nSize)
break;
std::vector<unsigned char> vchPubKey(nSize, 0);
- unsigned char* pbegin = &vchPubKey[0];
+ auto pbegin = &vchPubKey[0];
if (i2o_ECPublicKey(pkey, &pbegin) != nSize)
break;
Set(vchPubKey.begin(), vchPubKey.end());
- return IsValid();
+ fSuccessful = IsValid();
} while (false);
-
ECDSA_SIG_free(sig);
- Invalidate();
- return false;
+ EC_KEY_free(pkey);
+ if (!fSuccessful)
+ Invalidate();
+ return fSuccessful;
}
bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& vchSig) const
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
+ auto pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ auto norm_sig = ECDSA_SIG_new();
- // 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();
- const unsigned char* sigptr = &vchSig[0];
assert(norm_sig);
- if (d2i_ECDSA_SIG(&norm_sig, &sigptr, vchSig.size()) == NULL)
+ assert(pkey);
+
+ bool ret = false;
+ do
{
- /* As of OpenSSL 1.0.0p d2i_ECDSA_SIG frees and nulls the pointer on
- * error. But OpenSSL's own use of this function redundantly frees the
- * result. As ECDSA_SIG_free(NULL) is a no-op, and in the absence of a
- * clear contract for the function behaving the same way is more
- * conservative.
- */
- ECDSA_SIG_free(norm_sig);
- return false;
- }
- int derlen = i2d_ECDSA_SIG(norm_sig, &norm_der);
+ int derlen;
+ uint8_t *norm_der = NULL;
+ auto pbegin = &vbytes[0];
+ auto sigptr = &vchSig[0];
+
+ // Trying to parse public key
+ if (!o2i_ECPublicKey(&pkey, &pbegin, size()))
+ break;
+ // New versions of OpenSSL are rejecting a non-canonical DER signatures, de/re-serialize first.
+ if (d2i_ECDSA_SIG(&norm_sig, &sigptr, vchSig.size()) == NULL)
+ break;
+ if ((derlen = i2d_ECDSA_SIG(norm_sig, &norm_der)) <= 0)
+ break;
+
+ // -1 = error, 0 = bad sig, 1 = good
+ ret = ECDSA_verify(0, hash.begin(), hash.size(), norm_der, derlen, pkey) == 1;
+ OPENSSL_free(norm_der);
+ } while(false);
+
ECDSA_SIG_free(norm_sig);
- if (derlen <= 0)
- return false;
+ EC_KEY_free(pkey);
- // -1 = error, 0 = bad sig, 1 = good
- bool ret = ECDSA_verify(0, (unsigned char*)&hash, sizeof(hash), norm_der, derlen, pkey) == 1;
- OPENSSL_free(norm_der);
return ret;
}
-bool CPubKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
+bool CPubKey::VerifyCompact(const uint256 &hash, const std::vector<unsigned char>& vchSig)
{
CPubKey key;
if (!key.SetCompactSignature(hash, vchSig))
return false;
- if ((*this) != key)
- return false;
return true;
}
return false;
bool fCompr;
- CSecret secret = GetSecret(fCompr);
+ auto secret = GetSecret(fCompr);
CKey key2;
key2.SetSecret(secret, fCompr);
bnHash.setuint160(Hash160(vchLr));
CPoint pointH;
- pointH.setPubKey(pubKeyH);
+ if (!pointH.setPubKey(pubKeyH)) {
+ throw key_error("CMalleablePubKey::GetVariant() : Unable to decode H value");
+ }
CPoint P;
// Calculate P = Hash(L*r)*G + H
}
std::vector<unsigned char> vchResult;
- P.getBytes(vchResult);
+ if (!P.getBytes(vchResult)) {
+ throw key_error("CMalleablePubKey::GetVariant() : Unable to convert P value");
+ }
vchPubKeyVariant = CPubKey(vchResult);
}
if (!DecodeBase58Check(strMalleablePubKey, vchTemp)) {
throw key_error("CMalleablePubKey::SetString() : Provided key data seems corrupted.");
}
+ if (vchTemp.size() != 68)
+ return false;
CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
ssKey >> *this;
if (!DecodeBase58Check(strMutableKey, vchTemp)) {
throw key_error("CMalleableKey::SetString() : Provided key data seems corrupted.");
}
-
+ if (vchTemp.size() != 66)
+ return false;
CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
ssKey >> *this;
throw key_error("CMalleableKeyView::SetString() : Provided key data seems corrupted.");
}
+ if (vchTemp.size() != 67)
+ return false;
+
CDataStream ssKey(vchTemp, SER_NETWORK, PROTOCOL_VERSION);
ssKey >> *this;
git://git.novaco.in / novacoin.git / blobdiff