2016-12-31 19:01:21 +01:00
|
|
|
// Copyright (c) 2009-2016 The Bitcoin Core developers
|
2014-10-26 09:33:52 +01:00
|
|
|
// Distributed under the MIT software license, see the accompanying
|
2012-05-18 16:02:28 +02:00
|
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
2011-07-11 21:30:40 +02:00
|
|
|
|
2013-04-13 07:13:08 +02:00
|
|
|
#include "key.h"
|
|
|
|
|
2014-12-16 15:43:03 +01:00
|
|
|
#include "arith_uint256.h"
|
2015-03-27 23:31:44 +01:00
|
|
|
#include "crypto/common.h"
|
2014-10-26 09:23:23 +01:00
|
|
|
#include "crypto/hmac_sha512.h"
|
2014-10-28 22:47:18 +01:00
|
|
|
#include "pubkey.h"
|
2014-06-24 14:27:32 +02:00
|
|
|
#include "random.h"
|
2014-04-20 17:36:25 +02:00
|
|
|
|
2014-06-06 01:26:27 +02:00
|
|
|
#include <secp256k1.h>
|
2015-11-11 06:56:19 +01:00
|
|
|
#include <secp256k1_recovery.h>
|
2013-05-01 06:52:05 +02:00
|
|
|
|
2017-08-07 07:36:37 +02:00
|
|
|
static secp256k1_context* secp256k1_context_sign = nullptr;
|
2015-11-11 06:56:19 +01:00
|
|
|
|
|
|
|
/** These functions are taken from the libsecp256k1 distribution and are very ugly. */
|
|
|
|
static int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen) {
|
|
|
|
const unsigned char *end = privkey + privkeylen;
|
|
|
|
int lenb = 0;
|
|
|
|
int len = 0;
|
|
|
|
memset(out32, 0, 32);
|
|
|
|
/* sequence header */
|
|
|
|
if (end < privkey+1 || *privkey != 0x30) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
privkey++;
|
|
|
|
/* sequence length constructor */
|
|
|
|
if (end < privkey+1 || !(*privkey & 0x80)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
lenb = *privkey & ~0x80; privkey++;
|
|
|
|
if (lenb < 1 || lenb > 2) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (end < privkey+lenb) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* sequence length */
|
|
|
|
len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0);
|
|
|
|
privkey += lenb;
|
|
|
|
if (end < privkey+len) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* sequence element 0: version number (=1) */
|
|
|
|
if (end < privkey+3 || privkey[0] != 0x02 || privkey[1] != 0x01 || privkey[2] != 0x01) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
privkey += 3;
|
|
|
|
/* sequence element 1: octet string, up to 32 bytes */
|
|
|
|
if (end < privkey+2 || privkey[0] != 0x04 || privkey[1] > 0x20 || end < privkey+2+privkey[1]) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
memcpy(out32 + 32 - privkey[1], privkey + 2, privkey[1]);
|
|
|
|
if (!secp256k1_ec_seckey_verify(ctx, out32)) {
|
|
|
|
memset(out32, 0, 32);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed) {
|
|
|
|
secp256k1_pubkey pubkey;
|
|
|
|
size_t pubkeylen = 0;
|
|
|
|
if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
|
|
|
|
*privkeylen = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (compressed) {
|
|
|
|
static const unsigned char begin[] = {
|
|
|
|
0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
|
|
|
|
};
|
|
|
|
static const unsigned char middle[] = {
|
|
|
|
0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
|
|
|
|
0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
|
|
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
|
|
0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
|
|
|
|
0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
|
|
|
|
0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
|
|
|
|
0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
|
|
0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
|
|
|
|
0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
|
|
|
|
};
|
|
|
|
unsigned char *ptr = privkey;
|
|
|
|
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
|
|
|
|
memcpy(ptr, key32, 32); ptr += 32;
|
|
|
|
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
|
|
|
|
pubkeylen = 33;
|
|
|
|
secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
|
|
|
|
ptr += pubkeylen;
|
|
|
|
*privkeylen = ptr - privkey;
|
|
|
|
} else {
|
|
|
|
static const unsigned char begin[] = {
|
|
|
|
0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
|
|
|
|
};
|
|
|
|
static const unsigned char middle[] = {
|
|
|
|
0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
|
|
|
|
0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
|
|
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
|
|
0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
|
|
|
|
0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
|
|
|
|
0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
|
|
|
|
0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
|
|
|
|
0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
|
|
|
|
0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
|
|
|
|
0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
|
|
|
|
0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
|
|
|
|
};
|
|
|
|
unsigned char *ptr = privkey;
|
|
|
|
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
|
|
|
|
memcpy(ptr, key32, 32); ptr += 32;
|
|
|
|
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
|
|
|
|
pubkeylen = 65;
|
|
|
|
secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
|
|
|
|
ptr += pubkeylen;
|
|
|
|
*privkeylen = ptr - privkey;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
2013-05-01 06:52:05 +02:00
|
|
|
|
|
|
|
bool CKey::Check(const unsigned char *vch) {
|
2015-11-11 06:56:19 +01:00
|
|
|
return secp256k1_ec_seckey_verify(secp256k1_context_sign, vch);
|
2012-05-16 18:36:38 +02:00
|
|
|
}
|
|
|
|
|
2013-05-01 06:52:05 +02:00
|
|
|
void CKey::MakeNewKey(bool fCompressedIn) {
|
|
|
|
do {
|
2016-09-18 08:40:14 +02:00
|
|
|
GetStrongRandBytes(keydata.data(), keydata.size());
|
|
|
|
} while (!Check(keydata.data()));
|
2013-05-01 06:52:05 +02:00
|
|
|
fValid = true;
|
|
|
|
fCompressed = fCompressedIn;
|
2012-05-16 18:36:38 +02:00
|
|
|
}
|
|
|
|
|
2013-05-01 06:52:05 +02:00
|
|
|
CPrivKey CKey::GetPrivKey() const {
|
|
|
|
assert(fValid);
|
2014-06-06 01:26:27 +02:00
|
|
|
CPrivKey privkey;
|
2015-11-11 06:56:19 +01:00
|
|
|
int ret;
|
|
|
|
size_t privkeylen;
|
2014-06-06 01:26:27 +02:00
|
|
|
privkey.resize(279);
|
2014-10-09 22:38:38 +02:00
|
|
|
privkeylen = 279;
|
2017-02-19 19:35:49 +01:00
|
|
|
ret = ec_privkey_export_der(secp256k1_context_sign, (unsigned char*) privkey.data(), &privkeylen, begin(), fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
|
2014-06-06 01:26:27 +02:00
|
|
|
assert(ret);
|
|
|
|
privkey.resize(privkeylen);
|
2013-05-01 06:52:05 +02:00
|
|
|
return privkey;
|
2012-05-16 18:36:38 +02:00
|
|
|
}
|
|
|
|
|
2013-05-01 06:52:05 +02:00
|
|
|
CPubKey CKey::GetPubKey() const {
|
|
|
|
assert(fValid);
|
2015-11-11 06:56:19 +01:00
|
|
|
secp256k1_pubkey pubkey;
|
|
|
|
size_t clen = 65;
|
2014-10-21 20:38:25 +02:00
|
|
|
CPubKey result;
|
2015-11-11 06:56:19 +01:00
|
|
|
int ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &pubkey, begin());
|
2014-06-06 01:26:27 +02:00
|
|
|
assert(ret);
|
2015-11-11 06:56:19 +01:00
|
|
|
secp256k1_ec_pubkey_serialize(secp256k1_context_sign, (unsigned char*)result.begin(), &clen, &pubkey, fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
|
|
|
|
assert(result.size() == clen);
|
2014-10-21 20:38:25 +02:00
|
|
|
assert(result.IsValid());
|
|
|
|
return result;
|
2012-05-16 18:36:38 +02:00
|
|
|
}
|
|
|
|
|
2014-11-06 15:54:50 +01:00
|
|
|
bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, uint32_t test_case) const {
|
2013-05-01 06:52:05 +02:00
|
|
|
if (!fValid)
|
2012-05-16 18:36:38 +02:00
|
|
|
return false;
|
2014-06-06 01:26:27 +02:00
|
|
|
vchSig.resize(72);
|
2015-11-11 06:56:19 +01:00
|
|
|
size_t nSigLen = 72;
|
2015-03-27 23:31:44 +01:00
|
|
|
unsigned char extra_entropy[32] = {0};
|
|
|
|
WriteLE32(extra_entropy, test_case);
|
2015-11-11 06:56:19 +01:00
|
|
|
secp256k1_ecdsa_signature sig;
|
2017-08-07 07:36:37 +02:00
|
|
|
int ret = secp256k1_ecdsa_sign(secp256k1_context_sign, &sig, hash.begin(), begin(), secp256k1_nonce_function_rfc6979, test_case ? extra_entropy : nullptr);
|
2014-12-18 14:49:19 +01:00
|
|
|
assert(ret);
|
2017-02-19 19:35:49 +01:00
|
|
|
secp256k1_ecdsa_signature_serialize_der(secp256k1_context_sign, (unsigned char*)vchSig.data(), &nSigLen, &sig);
|
2014-12-18 14:49:19 +01:00
|
|
|
vchSig.resize(nSigLen);
|
|
|
|
return true;
|
2012-05-16 18:36:38 +02:00
|
|
|
}
|
|
|
|
|
2014-11-06 10:17:48 +01:00
|
|
|
bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
|
|
|
|
if (pubkey.IsCompressed() != fCompressed) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
unsigned char rnd[8];
|
|
|
|
std::string str = "Bitcoin key verification\n";
|
|
|
|
GetRandBytes(rnd, sizeof(rnd));
|
|
|
|
uint256 hash;
|
2014-12-18 14:49:19 +01:00
|
|
|
CHash256().Write((unsigned char*)str.data(), str.size()).Write(rnd, sizeof(rnd)).Finalize(hash.begin());
|
2014-11-06 10:17:48 +01:00
|
|
|
std::vector<unsigned char> vchSig;
|
|
|
|
Sign(hash, vchSig);
|
|
|
|
return pubkey.Verify(hash, vchSig);
|
|
|
|
}
|
|
|
|
|
2013-05-01 06:52:05 +02:00
|
|
|
bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) const {
|
|
|
|
if (!fValid)
|
2012-05-16 18:36:38 +02:00
|
|
|
return false;
|
2013-05-01 06:52:05 +02:00
|
|
|
vchSig.resize(65);
|
|
|
|
int rec = -1;
|
2015-11-11 06:56:19 +01:00
|
|
|
secp256k1_ecdsa_recoverable_signature sig;
|
2017-08-07 07:36:37 +02:00
|
|
|
int ret = secp256k1_ecdsa_sign_recoverable(secp256k1_context_sign, &sig, hash.begin(), begin(), secp256k1_nonce_function_rfc6979, nullptr);
|
2015-11-11 06:56:19 +01:00
|
|
|
assert(ret);
|
|
|
|
secp256k1_ecdsa_recoverable_signature_serialize_compact(secp256k1_context_sign, (unsigned char*)&vchSig[1], &rec, &sig);
|
2014-12-18 14:49:19 +01:00
|
|
|
assert(ret);
|
2013-05-01 06:52:05 +02:00
|
|
|
assert(rec != -1);
|
|
|
|
vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
|
|
|
|
return true;
|
|
|
|
}
|
2012-05-16 18:36:38 +02:00
|
|
|
|
2013-08-29 08:53:26 +02:00
|
|
|
bool CKey::Load(CPrivKey &privkey, CPubKey &vchPubKey, bool fSkipCheck=false) {
|
2017-02-19 19:35:49 +01:00
|
|
|
if (!ec_privkey_import_der(secp256k1_context_sign, (unsigned char*)begin(), privkey.data(), privkey.size()))
|
2013-08-29 08:53:26 +02:00
|
|
|
return false;
|
|
|
|
fCompressed = vchPubKey.IsCompressed();
|
|
|
|
fValid = true;
|
2014-06-06 01:26:27 +02:00
|
|
|
|
2013-08-29 10:11:47 +02:00
|
|
|
if (fSkipCheck)
|
|
|
|
return true;
|
2014-06-06 01:26:27 +02:00
|
|
|
|
2014-11-06 10:17:48 +01:00
|
|
|
return VerifyPubKey(vchPubKey);
|
2013-08-29 08:53:26 +02:00
|
|
|
}
|
|
|
|
|
2015-04-22 00:09:37 +02:00
|
|
|
bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode& cc) const {
|
2013-07-15 01:05:25 +02:00
|
|
|
assert(IsValid());
|
|
|
|
assert(IsCompressed());
|
2016-09-18 08:40:14 +02:00
|
|
|
std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
|
2013-07-15 01:05:25 +02:00
|
|
|
if ((nChild >> 31) == 0) {
|
|
|
|
CPubKey pubkey = GetPubKey();
|
|
|
|
assert(pubkey.begin() + 33 == pubkey.end());
|
2016-09-18 08:40:14 +02:00
|
|
|
BIP32Hash(cc, nChild, *pubkey.begin(), pubkey.begin()+1, vout.data());
|
2013-07-15 01:05:25 +02:00
|
|
|
} else {
|
|
|
|
assert(begin() + 32 == end());
|
2016-09-18 08:40:14 +02:00
|
|
|
BIP32Hash(cc, nChild, 0, begin(), vout.data());
|
2013-07-15 01:05:25 +02:00
|
|
|
}
|
2016-09-18 08:40:14 +02:00
|
|
|
memcpy(ccChild.begin(), vout.data()+32, 32);
|
2014-06-06 01:26:27 +02:00
|
|
|
memcpy((unsigned char*)keyChild.begin(), begin(), 32);
|
2016-09-18 08:40:14 +02:00
|
|
|
bool ret = secp256k1_ec_privkey_tweak_add(secp256k1_context_sign, (unsigned char*)keyChild.begin(), vout.data());
|
2013-07-15 01:05:25 +02:00
|
|
|
keyChild.fCompressed = true;
|
|
|
|
keyChild.fValid = ret;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-09-02 18:19:01 +02:00
|
|
|
bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
|
2013-07-15 01:05:25 +02:00
|
|
|
out.nDepth = nDepth + 1;
|
|
|
|
CKeyID id = key.GetPubKey().GetID();
|
|
|
|
memcpy(&out.vchFingerprint[0], &id, 4);
|
2016-09-02 18:19:01 +02:00
|
|
|
out.nChild = _nChild;
|
|
|
|
return key.Derive(out.key, out.chaincode, _nChild, chaincode);
|
2013-07-15 01:05:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CExtKey::SetMaster(const unsigned char *seed, unsigned int nSeedLen) {
|
2014-04-20 17:36:25 +02:00
|
|
|
static const unsigned char hashkey[] = {'B','i','t','c','o','i','n',' ','s','e','e','d'};
|
2016-09-18 08:40:14 +02:00
|
|
|
std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
|
|
|
|
CHMAC_SHA512(hashkey, sizeof(hashkey)).Write(seed, nSeedLen).Finalize(vout.data());
|
2017-02-19 19:35:49 +01:00
|
|
|
key.Set(vout.data(), vout.data() + 32, true);
|
|
|
|
memcpy(chaincode.begin(), vout.data() + 32, 32);
|
2013-07-15 01:05:25 +02:00
|
|
|
nDepth = 0;
|
|
|
|
nChild = 0;
|
|
|
|
memset(vchFingerprint, 0, sizeof(vchFingerprint));
|
|
|
|
}
|
|
|
|
|
|
|
|
CExtPubKey CExtKey::Neuter() const {
|
|
|
|
CExtPubKey ret;
|
|
|
|
ret.nDepth = nDepth;
|
|
|
|
memcpy(&ret.vchFingerprint[0], &vchFingerprint[0], 4);
|
|
|
|
ret.nChild = nChild;
|
|
|
|
ret.pubkey = key.GetPubKey();
|
2015-04-22 00:09:37 +02:00
|
|
|
ret.chaincode = chaincode;
|
2013-07-15 01:05:25 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-06-01 16:35:19 +02:00
|
|
|
void CExtKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
|
2013-07-15 01:05:25 +02:00
|
|
|
code[0] = nDepth;
|
|
|
|
memcpy(code+1, vchFingerprint, 4);
|
|
|
|
code[5] = (nChild >> 24) & 0xFF; code[6] = (nChild >> 16) & 0xFF;
|
|
|
|
code[7] = (nChild >> 8) & 0xFF; code[8] = (nChild >> 0) & 0xFF;
|
2015-04-22 00:09:37 +02:00
|
|
|
memcpy(code+9, chaincode.begin(), 32);
|
2013-07-15 01:05:25 +02:00
|
|
|
code[41] = 0;
|
|
|
|
assert(key.size() == 32);
|
|
|
|
memcpy(code+42, key.begin(), 32);
|
|
|
|
}
|
|
|
|
|
2015-06-01 16:35:19 +02:00
|
|
|
void CExtKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
|
2013-07-15 01:05:25 +02:00
|
|
|
nDepth = code[0];
|
|
|
|
memcpy(vchFingerprint, code+1, 4);
|
|
|
|
nChild = (code[5] << 24) | (code[6] << 16) | (code[7] << 8) | code[8];
|
2015-04-22 00:09:37 +02:00
|
|
|
memcpy(chaincode.begin(), code+9, 32);
|
2015-06-01 16:35:19 +02:00
|
|
|
key.Set(code+42, code+BIP32_EXTKEY_SIZE, true);
|
2013-07-15 01:05:25 +02:00
|
|
|
}
|
|
|
|
|
2014-06-03 01:21:03 +02:00
|
|
|
bool ECC_InitSanityCheck() {
|
2014-11-08 23:29:45 +01:00
|
|
|
CKey key;
|
|
|
|
key.MakeNewKey(true);
|
|
|
|
CPubKey pubkey = key.GetPubKey();
|
|
|
|
return key.VerifyPubKey(pubkey);
|
2014-06-03 01:21:03 +02:00
|
|
|
}
|
Update key.cpp to use new libsecp256k1
libsecp256k1's API changed, so update key.cpp to use it.
Libsecp256k1 now has explicit context objects, which makes it completely thread-safe.
In turn, keep an explicit context object in key.cpp, which is explicitly initialized
destroyed. This is not really pretty now, but it's more efficient than the static
initialized object in key.cpp (which made for example bitcoin-tx slow, as for most of
its calls, libsecp256k1 wasn't actually needed).
This also brings in the new blinding support in libsecp256k1. By passing in a random
seed, temporary variables during the elliptic curve computations are altered, in such
a way that if an attacker does not know the blind, observing the internal operations
leaks less information about the keys used. This was implemented by Greg Maxwell.
2015-04-22 23:28:26 +02:00
|
|
|
|
|
|
|
void ECC_Start() {
|
2017-08-07 07:36:37 +02:00
|
|
|
assert(secp256k1_context_sign == nullptr);
|
Update key.cpp to use new libsecp256k1
libsecp256k1's API changed, so update key.cpp to use it.
Libsecp256k1 now has explicit context objects, which makes it completely thread-safe.
In turn, keep an explicit context object in key.cpp, which is explicitly initialized
destroyed. This is not really pretty now, but it's more efficient than the static
initialized object in key.cpp (which made for example bitcoin-tx slow, as for most of
its calls, libsecp256k1 wasn't actually needed).
This also brings in the new blinding support in libsecp256k1. By passing in a random
seed, temporary variables during the elliptic curve computations are altered, in such
a way that if an attacker does not know the blind, observing the internal operations
leaks less information about the keys used. This was implemented by Greg Maxwell.
2015-04-22 23:28:26 +02:00
|
|
|
|
2015-11-11 06:56:19 +01:00
|
|
|
secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
|
2017-08-07 07:36:37 +02:00
|
|
|
assert(ctx != nullptr);
|
Update key.cpp to use new libsecp256k1
libsecp256k1's API changed, so update key.cpp to use it.
Libsecp256k1 now has explicit context objects, which makes it completely thread-safe.
In turn, keep an explicit context object in key.cpp, which is explicitly initialized
destroyed. This is not really pretty now, but it's more efficient than the static
initialized object in key.cpp (which made for example bitcoin-tx slow, as for most of
its calls, libsecp256k1 wasn't actually needed).
This also brings in the new blinding support in libsecp256k1. By passing in a random
seed, temporary variables during the elliptic curve computations are altered, in such
a way that if an attacker does not know the blind, observing the internal operations
leaks less information about the keys used. This was implemented by Greg Maxwell.
2015-04-22 23:28:26 +02:00
|
|
|
|
|
|
|
{
|
|
|
|
// Pass in a random blinding seed to the secp256k1 context.
|
2016-09-18 08:40:14 +02:00
|
|
|
std::vector<unsigned char, secure_allocator<unsigned char>> vseed(32);
|
|
|
|
GetRandBytes(vseed.data(), 32);
|
|
|
|
bool ret = secp256k1_context_randomize(ctx, vseed.data());
|
Update key.cpp to use new libsecp256k1
libsecp256k1's API changed, so update key.cpp to use it.
Libsecp256k1 now has explicit context objects, which makes it completely thread-safe.
In turn, keep an explicit context object in key.cpp, which is explicitly initialized
destroyed. This is not really pretty now, but it's more efficient than the static
initialized object in key.cpp (which made for example bitcoin-tx slow, as for most of
its calls, libsecp256k1 wasn't actually needed).
This also brings in the new blinding support in libsecp256k1. By passing in a random
seed, temporary variables during the elliptic curve computations are altered, in such
a way that if an attacker does not know the blind, observing the internal operations
leaks less information about the keys used. This was implemented by Greg Maxwell.
2015-04-22 23:28:26 +02:00
|
|
|
assert(ret);
|
|
|
|
}
|
|
|
|
|
2015-11-11 06:56:19 +01:00
|
|
|
secp256k1_context_sign = ctx;
|
Update key.cpp to use new libsecp256k1
libsecp256k1's API changed, so update key.cpp to use it.
Libsecp256k1 now has explicit context objects, which makes it completely thread-safe.
In turn, keep an explicit context object in key.cpp, which is explicitly initialized
destroyed. This is not really pretty now, but it's more efficient than the static
initialized object in key.cpp (which made for example bitcoin-tx slow, as for most of
its calls, libsecp256k1 wasn't actually needed).
This also brings in the new blinding support in libsecp256k1. By passing in a random
seed, temporary variables during the elliptic curve computations are altered, in such
a way that if an attacker does not know the blind, observing the internal operations
leaks less information about the keys used. This was implemented by Greg Maxwell.
2015-04-22 23:28:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ECC_Stop() {
|
2015-11-11 06:56:19 +01:00
|
|
|
secp256k1_context *ctx = secp256k1_context_sign;
|
2017-08-07 07:36:37 +02:00
|
|
|
secp256k1_context_sign = nullptr;
|
Update key.cpp to use new libsecp256k1
libsecp256k1's API changed, so update key.cpp to use it.
Libsecp256k1 now has explicit context objects, which makes it completely thread-safe.
In turn, keep an explicit context object in key.cpp, which is explicitly initialized
destroyed. This is not really pretty now, but it's more efficient than the static
initialized object in key.cpp (which made for example bitcoin-tx slow, as for most of
its calls, libsecp256k1 wasn't actually needed).
This also brings in the new blinding support in libsecp256k1. By passing in a random
seed, temporary variables during the elliptic curve computations are altered, in such
a way that if an attacker does not know the blind, observing the internal operations
leaks less information about the keys used. This was implemented by Greg Maxwell.
2015-04-22 23:28:26 +02:00
|
|
|
|
|
|
|
if (ctx) {
|
|
|
|
secp256k1_context_destroy(ctx);
|
|
|
|
}
|
|
|
|
}
|