#include <map>
#include <openssl/ecdsa.h>
+#include <openssl/evp.h>
#include <openssl/obj_mac.h>
#include "key.h"
const unsigned char *vchZero = NULL;
-
-
-void CKey::SetCompressedPubKey()
+void CKey::SetCompressedPubKey(bool fCompressed)
{
- EC_KEY_set_conv_form(pkey, POINT_CONVERSION_COMPRESSED);
- fCompressedPubKey = true;
+ EC_KEY_set_conv_form(pkey, fCompressed ? POINT_CONVERSION_COMPRESSED : POINT_CONVERSION_UNCOMPRESSED);
}
void CKey::Reset()
{
- fCompressedPubKey = 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() : EC_KEY_new_by_curve_name failed");
- fSet = false;
}
CKey::CKey()
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);
}
CKey::~CKey()
{
- EC_KEY_free(pkey);
+ if (pkey != NULL)
+ EC_KEY_free(pkey);
}
bool CKey::IsNull() const
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) {
CompareBigEndian(vch, len, half ? vchMaxModHalfOrder : vchMaxModOrder, 32) <= 0;
}
-bool CKey::ReserealizeSignature(std::vector<unsigned char>& vchSig)
+bool CPubKey::ReserealizeSignature(std::vector<unsigned char>& vchSig)
{
if (vchSig.empty())
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;
}
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());
}
BN_clear_free(bn);
fSet = true;
- if (fCompressed || fCompressedPubKey)
- SetCompressedPubKey();
+ SetCompressedPubKey(fCompressed);
return true;
}
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();
+ 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 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);
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();
+ keyRec.SetCompressedPubKey(fCompressedPubKey);
if (ECDSA_SIG_recover_key_GFp(keyRec.pkey, sig, (unsigned char*)&hash, sizeof(hash), i, 1) == 1)
if (keyRec.GetPubKey() == this->GetPubKey())
{
// 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<unsigned char>& vchSig)
+bool CPubKey::SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig)
{
if (vchSig.size() != 65)
return false;
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<unsigned char> 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<unsigned char>& vchSig)
+bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& 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();
return ret;
}
-bool CKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
+bool CPubKey::VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
{
- CKey key;
+ CPubKey key;
if (!key.SetCompactSignature(hash, vchSig))
return false;
- if (GetPubKey() != key.GetPubKey())
- return false;
-
return true;
}
CSecret secret = GetSecret(fCompr);
CKey key2;
key2.SetSecret(secret, fCompr);
+
return GetPubKey() == key2.GetPubKey();
}
}
// Initialize from octets stream
-bool CPoint::setPubKey(const CPubKey &vchPubKey)
+bool CPoint::setPubKey(const CPubKey &key)
{
- return setBytes(vchPubKey.Raw());
+ std::vector<uint8_t> vchPubKey(key.begin(), key.end());
+ return setBytes(vchPubKey);
}
// Serialize to octets stream
bool CPoint::getBytes(std::vector<unsigned char> &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;
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;
CMalleablePubKey CMalleableKey::GetMalleablePubKey() const
{
CKey L(vchSecretL), H(vchSecretH);
- return CMalleablePubKey(L.GetPubKey().Raw(), H.GetPubKey().Raw());
+ return CMalleablePubKey(L.GetPubKey(), H.GetPubKey());
}
// Check ownership
}
CKey H(vchSecretH);
- std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
+ CPubKey vchPubKeyH = H.GetPubKey();
CPoint point_H;
if (!point_H.setPubKey(vchPubKeyH)) {
}
CKey H(vchSecretH);
- std::vector<unsigned char> vchPubKeyH = H.GetPubKey().Raw();
+ CPubKey vchPubKeyH = H.GetPubKey();
CPoint point_H;
if (!point_H.setPubKey(vchPubKeyH)) {
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;
vchSecretL = b.vchSecretL;
CKey H(b.vchSecretH);
- vchPubKeyH = H.GetPubKey().Raw();
+ vchPubKeyH = H.GetPubKey();
}
CMalleableKeyView::CMalleableKeyView(const CMalleableKeyView &b)
vchSecretL = b.vchSecretL;
CKey H(b.vchSecretH);
- vchPubKeyH = H.GetPubKey().Raw();
+ vchPubKeyH = H.GetPubKey();
return (*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;
void CPubKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& encrypted)
{
- CKey key;
- key.SetPubKey(*this);
-
- key.EncryptData(data, encrypted);
-}
-
-void CKey::EncryptData(const std::vector<unsigned char>& data, std::vector<unsigned char>& 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");
data.resize(length);
memcpy(&data[0], decrypted, length);
free(decrypted);
-}
\ No newline at end of file
+}
git://git.novaco.in / novacoin.git / blobdiff