Fabcoin Core  0.16.2
P2P Digital Currency
key.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2017 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include <key.h>
6 
7 #include <arith_uint256.h>
8 #include <crypto/common.h>
9 #include <crypto/hmac_sha512.h>
10 #include <pubkey.h>
11 #include <random.h>
12 
13 #include <secp256k1.h>
14 #include <secp256k1_recovery.h>
15 
16 static secp256k1_context* secp256k1_context_sign = nullptr;
17 
19 static int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen) {
20  const unsigned char *end = privkey + privkeylen;
21  int lenb = 0;
22  int len = 0;
23  memset(out32, 0, 32);
24  /* sequence header */
25  if (end < privkey+1 || *privkey != 0x30) {
26  return 0;
27  }
28  privkey++;
29  /* sequence length constructor */
30  if (end < privkey+1 || !(*privkey & 0x80)) {
31  return 0;
32  }
33  lenb = *privkey & ~0x80; privkey++;
34  if (lenb < 1 || lenb > 2) {
35  return 0;
36  }
37  if (end < privkey+lenb) {
38  return 0;
39  }
40  /* sequence length */
41  len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0);
42  privkey += lenb;
43  if (end < privkey+len) {
44  return 0;
45  }
46  /* sequence element 0: version number (=1) */
47  if (end < privkey+3 || privkey[0] != 0x02 || privkey[1] != 0x01 || privkey[2] != 0x01) {
48  return 0;
49  }
50  privkey += 3;
51  /* sequence element 1: octet string, up to 32 bytes */
52  if (end < privkey+2 || privkey[0] != 0x04 || privkey[1] > 0x20 || end < privkey+2+privkey[1]) {
53  return 0;
54  }
55  memcpy(out32 + 32 - privkey[1], privkey + 2, privkey[1]);
56  if (!secp256k1_ec_seckey_verify(ctx, out32)) {
57  memset(out32, 0, 32);
58  return 0;
59  }
60  return 1;
61 }
62 
63 static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed) {
64  secp256k1_pubkey pubkey;
65  size_t pubkeylen = 0;
66  if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
67  *privkeylen = 0;
68  return 0;
69  }
70  if (compressed) {
71  static const unsigned char begin[] = {
72  0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
73  };
74  static const unsigned char middle[] = {
75  0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
76  0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
77  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
78  0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
79  0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
80  0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
81  0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
82  0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
83  0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
84  };
85  unsigned char *ptr = privkey;
86  memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
87  memcpy(ptr, key32, 32); ptr += 32;
88  memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
89  pubkeylen = 33;
90  secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
91  ptr += pubkeylen;
92  *privkeylen = ptr - privkey;
93  } else {
94  static const unsigned char begin[] = {
95  0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
96  };
97  static const unsigned char middle[] = {
98  0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
99  0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
100  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
101  0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
102  0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
103  0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
104  0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
105  0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
106  0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
107  0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
108  0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
109  };
110  unsigned char *ptr = privkey;
111  memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
112  memcpy(ptr, key32, 32); ptr += 32;
113  memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
114  pubkeylen = 65;
115  secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
116  ptr += pubkeylen;
117  *privkeylen = ptr - privkey;
118  }
119  return 1;
120 }
121 
122 bool CKey::Check(const unsigned char *vch) {
123  return secp256k1_ec_seckey_verify(secp256k1_context_sign, vch);
124 }
125 
126 void CKey::MakeNewKey(bool fCompressedIn) {
127  do {
128  GetStrongRandBytes(keydata.data(), keydata.size());
129  } while (!Check(keydata.data()));
130  fValid = true;
131  fCompressed = fCompressedIn;
132 }
133 
135  assert(fValid);
136  CPrivKey privkey;
137  int ret;
138  size_t privkeylen;
139  privkey.resize(279);
140  privkeylen = 279;
141  ret = ec_privkey_export_der(secp256k1_context_sign, (unsigned char*) privkey.data(), &privkeylen, begin(), fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
142  assert(ret);
143  privkey.resize(privkeylen);
144  return privkey;
145 }
146 
148  assert(fValid);
149  secp256k1_pubkey pubkey;
150  size_t clen = 65;
151  CPubKey result;
152  int ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &pubkey, begin());
153  assert(ret);
154  secp256k1_ec_pubkey_serialize(secp256k1_context_sign, (unsigned char*)result.begin(), &clen, &pubkey, fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
155  assert(result.size() == clen);
156  assert(result.IsValid());
157  return result;
158 }
159 
160 bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, uint32_t test_case) const {
161  if (!fValid)
162  return false;
163  vchSig.resize(72);
164  size_t nSigLen = 72;
165  unsigned char extra_entropy[32] = {0};
166  WriteLE32(extra_entropy, test_case);
168  int ret = secp256k1_ecdsa_sign(secp256k1_context_sign, &sig, hash.begin(), begin(), secp256k1_nonce_function_rfc6979, test_case ? extra_entropy : nullptr);
169  assert(ret);
170  secp256k1_ecdsa_signature_serialize_der(secp256k1_context_sign, (unsigned char*)vchSig.data(), &nSigLen, &sig);
171  vchSig.resize(nSigLen);
172  return true;
173 }
174 
175 bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
176  if (pubkey.IsCompressed() != fCompressed) {
177  return false;
178  }
179  unsigned char rnd[8];
180  std::string str = "Bitcoin key verification\n";
181  GetRandBytes(rnd, sizeof(rnd));
182  uint256 hash;
183  CHash256().Write((unsigned char*)str.data(), str.size()).Write(rnd, sizeof(rnd)).Finalize(hash.begin());
184  std::vector<unsigned char> vchSig;
185  Sign(hash, vchSig);
186  return pubkey.Verify(hash, vchSig);
187 }
188 
189 bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) const {
190  if (!fValid)
191  return false;
192  vchSig.resize(65);
193  int rec = -1;
195  int ret = secp256k1_ecdsa_sign_recoverable(secp256k1_context_sign, &sig, hash.begin(), begin(), secp256k1_nonce_function_rfc6979, nullptr);
196  assert(ret);
197  secp256k1_ecdsa_recoverable_signature_serialize_compact(secp256k1_context_sign, (unsigned char*)&vchSig[1], &rec, &sig);
198  assert(ret);
199  assert(rec != -1);
200  vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
201  return true;
202 }
203 
204 bool CKey::Load(CPrivKey &privkey, CPubKey &vchPubKey, bool fSkipCheck=false) {
205  if (!ec_privkey_import_der(secp256k1_context_sign, (unsigned char*)begin(), privkey.data(), privkey.size()))
206  return false;
207  fCompressed = vchPubKey.IsCompressed();
208  fValid = true;
209 
210  if (fSkipCheck)
211  return true;
212 
213  return VerifyPubKey(vchPubKey);
214 }
215 
216 bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode& cc) const {
217  assert(IsValid());
218  assert(IsCompressed());
219  std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
220  if ((nChild >> 31) == 0) {
221  CPubKey pubkey = GetPubKey();
222  assert(pubkey.begin() + 33 == pubkey.end());
223  BIP32Hash(cc, nChild, *pubkey.begin(), pubkey.begin()+1, vout.data());
224  } else {
225  assert(begin() + 32 == end());
226  BIP32Hash(cc, nChild, 0, begin(), vout.data());
227  }
228  memcpy(ccChild.begin(), vout.data()+32, 32);
229  memcpy((unsigned char*)keyChild.begin(), begin(), 32);
230  bool ret = secp256k1_ec_privkey_tweak_add(secp256k1_context_sign, (unsigned char*)keyChild.begin(), vout.data());
231  keyChild.fCompressed = true;
232  keyChild.fValid = ret;
233  return ret;
234 }
235 
236 bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
237  out.nDepth = nDepth + 1;
238  CKeyID id = key.GetPubKey().GetID();
239  memcpy(&out.vchFingerprint[0], &id, 4);
240  out.nChild = _nChild;
241  return key.Derive(out.key, out.chaincode, _nChild, chaincode);
242 }
243 
244 void CExtKey::SetMaster(const unsigned char *seed, unsigned int nSeedLen) {
245  static const unsigned char hashkey[] = {'B','i','t','c','o','i','n',' ','s','e','e','d'};
246  std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
247  CHMAC_SHA512(hashkey, sizeof(hashkey)).Write(seed, nSeedLen).Finalize(vout.data());
248  key.Set(vout.data(), vout.data() + 32, true);
249  memcpy(chaincode.begin(), vout.data() + 32, 32);
250  nDepth = 0;
251  nChild = 0;
252  memset(vchFingerprint, 0, sizeof(vchFingerprint));
253 }
254 
256  CExtPubKey ret;
257  ret.nDepth = nDepth;
258  memcpy(&ret.vchFingerprint[0], &vchFingerprint[0], 4);
259  ret.nChild = nChild;
260  ret.pubkey = key.GetPubKey();
261  ret.chaincode = chaincode;
262  return ret;
263 }
264 
265 void CExtKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
266  code[0] = nDepth;
267  memcpy(code+1, vchFingerprint, 4);
268  code[5] = (nChild >> 24) & 0xFF; code[6] = (nChild >> 16) & 0xFF;
269  code[7] = (nChild >> 8) & 0xFF; code[8] = (nChild >> 0) & 0xFF;
270  memcpy(code+9, chaincode.begin(), 32);
271  code[41] = 0;
272  assert(key.size() == 32);
273  memcpy(code+42, key.begin(), 32);
274 }
275 
276 void CExtKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
277  nDepth = code[0];
278  memcpy(vchFingerprint, code+1, 4);
279  nChild = (code[5] << 24) | (code[6] << 16) | (code[7] << 8) | code[8];
280  memcpy(chaincode.begin(), code+9, 32);
281  key.Set(code+42, code+BIP32_EXTKEY_SIZE, true);
282 }
283 
285  CKey key;
286  key.MakeNewKey(true);
287  CPubKey pubkey = key.GetPubKey();
288  return key.VerifyPubKey(pubkey);
289 }
290 
291 void ECC_Start() {
292  assert(secp256k1_context_sign == nullptr);
293 
295  assert(ctx != nullptr);
296 
297  {
298  // Pass in a random blinding seed to the secp256k1 context.
299  std::vector<unsigned char, secure_allocator<unsigned char>> vseed(32);
300  GetRandBytes(vseed.data(), 32);
301  bool ret = secp256k1_context_randomize(ctx, vseed.data());
302  assert(ret);
303  }
304 
305  secp256k1_context_sign = ctx;
306 }
307 
308 void ECC_Stop() {
309  secp256k1_context *ctx = secp256k1_context_sign;
310  secp256k1_context_sign = nullptr;
311 
312  if (ctx) {
314  }
315 }
void Finalize(unsigned char hash[OUTPUT_SIZE])
Definition: hmac_sha512.cpp:29
CHMAC_SHA512 & Write(const unsigned char *data, size_t len)
Definition: hmac_sha512.h:24
void ECC_Start()
Initialize the elliptic curve support.
Definition: key.cpp:291
unsigned char vchFingerprint[4]
Definition: pubkey.h:199
const unsigned char * begin() const
Definition: key.h:88
CExtPubKey Neuter() const
Definition: key.cpp:255
CKey key
Definition: key.h:145
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
Definition: key.cpp:175
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_context_randomize(secp256k1_context *ctx, const unsigned char *seed32) SECP256K1_ARG_NONNULL(1)
Updates the context randomization to protect against side-channel leakage.
Definition: secp256k1.c:547
CHash256 & Write(const unsigned char *data, size_t len)
Definition: hash.h:33
const unsigned char * end() const
Definition: key.h:89
Definition: key.h:140
Opaque data structured that holds a parsed ECDSA signature, supporting pubkey recovery.
unsigned int size() const
Simple read-only vector-like interface to the pubkey data.
Definition: pubkey.h:97
unsigned char vchFingerprint[4]
Definition: key.h:142
unsigned char nDepth
Definition: pubkey.h:198
void GetStrongRandBytes(unsigned char *out, int num)
Function to gather random data from multiple sources, failing whenever any of those source fail to pr...
Definition: random.cpp:317
assert(len-trim+(2 *lenIndices)<=WIDTH)
SECP256K1_API int secp256k1_ec_pubkey_serialize(const secp256k1_context *ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey *pubkey, unsigned int flags) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4)
Serialize a pubkey object into a serialized byte sequence.
Definition: secp256k1.c:165
A hasher class for Fabcoin&#39;s 256-bit hash (double SHA-256).
Definition: hash.h:21
ChainCode chaincode
Definition: pubkey.h:201
#define SECP256K1_CONTEXT_SIGN
Definition: secp256k1.h:155
bytes code
Definition: SmartVM.cpp:45
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_add(const secp256k1_context *ctx, unsigned char *seckey, const unsigned char *tweak) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
Tweak a private key by adding tweak to it.
Definition: secp256k1.c:454
unsigned char * begin()
Definition: uint256.h:65
bool fValid
Whether this private key is valid.
Definition: key.h:40
unsigned int nChild
Definition: pubkey.h:200
bool Derive(CExtKey &out, unsigned int nChild) const
Definition: key.cpp:236
SECP256K1_API const secp256k1_nonce_function secp256k1_nonce_function_rfc6979
An implementation of RFC6979 (using HMAC-SHA256) as nonce generation function.
Definition: secp256k1.c:342
bool IsValid() const
Check whether this private key is valid.
Definition: key.h:92
SECP256K1_API void secp256k1_context_destroy(secp256k1_context *ctx)
Destroy a secp256k1 context object.
Definition: secp256k1.c:92
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_create(const secp256k1_context *ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
Compute the public key for a secret key.
Definition: secp256k1.c:404
std::vector< unsigned char, secure_allocator< unsigned char > > CPrivKey
secp256k1: const unsigned int PRIVATE_KEY_SIZE = 279; const unsigned int PUBLIC_KEY_SIZE = 65; const ...
Definition: key.h:32
#define SECP256K1_EC_UNCOMPRESSED
Definition: secp256k1.h:160
#define SECP256K1_EC_COMPRESSED
Flag to pass to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export.
Definition: secp256k1.h:159
bool IsCompressed() const
Check whether the public key corresponding to this private key is (to be) compressed.
Definition: key.h:95
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_verify(const secp256k1_context *ctx, const unsigned char *seckey) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2)
Verify an ECDSA secret key.
Definition: secp256k1.c:391
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:147
void ECC_Stop()
Deinitialize the elliptic curve support.
Definition: key.cpp:308
CPrivKey GetPrivKey() const
Convert the private key to a CPrivKey (serialized OpenSSL private key data).
Definition: key.cpp:134
unsigned char nDepth
Definition: key.h:141
void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64])
Definition: hash.cpp:72
SECP256K1_API int secp256k1_ecdsa_sign(const secp256k1_context *ctx, secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void *ndata) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4)
Create an ECDSA signature.
Definition: secp256k1.c:345
SECP256K1_API int secp256k1_ecdsa_sign_recoverable(const secp256k1_context *ctx, secp256k1_ecdsa_recoverable_signature *sig, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void *ndata) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4)
Create a recoverable ECDSA signature.
Definition: main_impl.h:123
An encapsulated public key.
Definition: pubkey.h:39
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:126
unsigned int nChild
Definition: key.h:143
Opaque data structured that holds a parsed ECDSA signature.
Definition: secp256k1.h:66
SECP256K1_API int secp256k1_ecdsa_recoverable_signature_serialize_compact(const secp256k1_context *ctx, unsigned char *output64, int *recid, const secp256k1_ecdsa_recoverable_signature *sig) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4)
Serialize an ECDSA signature in compact format (64 bytes + recovery id).
Definition: main_impl.h:60
ChainCode chaincode
Definition: key.h:144
const unsigned char * begin() const
Definition: pubkey.h:98
bool Load(CPrivKey &privkey, CPubKey &vchPubKey, bool fSkipCheck)
Load private key and check that public key matches.
Definition: key.cpp:204
void Decode(const unsigned char code[BIP32_EXTKEY_SIZE])
Definition: key.cpp:276
bool IsCompressed() const
Check whether this is a compressed public key.
Definition: pubkey.h:171
256-bit opaque blob.
Definition: uint256.h:132
SECP256K1_API int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context *ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature *sig) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4)
Serialize an ECDSA signature in DER format.
Definition: secp256k1.c:249
bool SignCompact(const uint256 &hash, std::vector< unsigned char > &vchSig) const
Create a compact signature (65 bytes), which allows reconstructing the used public key...
Definition: key.cpp:189
void * memcpy(void *a, const void *b, size_t c)
const unsigned int BIP32_EXTKEY_SIZE
secp256k1: const unsigned int PRIVATE_KEY_SIZE = 279; const unsigned int PUBLIC_KEY_SIZE = 65; const ...
Definition: pubkey.h:26
A reference to a CKey: the Hash160 of its serialized public key.
Definition: pubkey.h:29
bool fCompressed
Whether the public key corresponding to this private key is (to be) compressed.
Definition: key.h:43
bool IsValid() const
Definition: pubkey.h:162
void GetRandBytes(unsigned char *buf, int num)
Functions to gather random data via the OpenSSL PRNG.
Definition: random.cpp:273
void SetMaster(const unsigned char *seed, unsigned int nSeedLen)
Definition: key.cpp:244
CPubKey pubkey
Definition: pubkey.h:202
std::vector< unsigned char, secure_allocator< unsigned char > > keydata
The actual byte data.
Definition: key.h:46
static bool Check(const unsigned char *vch)
Check whether the 32-byte array pointed to by vch is valid keydata.
Definition: key.cpp:122
An encapsulated private key.
Definition: key.h:35
bool ECC_InitSanityCheck()
Check that required EC support is available at runtime.
Definition: key.cpp:284
bool Verify(const uint256 &hash, const std::vector< unsigned char > &vchSig) const
Verify a DER signature (~72 bytes).
Definition: pubkey.cpp:167
SECP256K1_API secp256k1_context * secp256k1_context_create(unsigned int flags) SECP256K1_WARN_UNUSED_RESULT
Create a secp256k1 context object.
Definition: secp256k1.c:58
void Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const
Definition: key.cpp:265
bool Derive(CKey &keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child key.
Definition: key.cpp:216
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, uint32_t test_case=0) const
Create a DER-serialized signature.
Definition: key.cpp:160
const unsigned char * end() const
Definition: pubkey.h:99
Opaque data structure that holds a parsed and valid public key.
Definition: secp256k1.h:53
A hasher class for HMAC-SHA-512.
Definition: hmac_sha512.h:14