Dash Core Source Documentation (0.16.0.1)

Find detailed information regarding the Dash Core source code.

key.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2015 The Bitcoin Core developers
2 // Copyright (c) 2017 The Zcash developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 
6 #include <key.h>
7 
8 #include <arith_uint256.h>
9 #include <crypto/common.h>
10 #include <crypto/hmac_sha512.h>
11 #include <random.h>
12 
13 #include <secp256k1.h>
14 #include <secp256k1_recovery.h>
15 
17 
35 static int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen) {
36  const unsigned char *end = privkey + privkeylen;
37  memset(out32, 0, 32);
38  /* sequence header */
39  if (end - privkey < 1 || *privkey != 0x30u) {
40  return 0;
41  }
42  privkey++;
43  /* sequence length constructor */
44  if (end - privkey < 1 || !(*privkey & 0x80u)) {
45  return 0;
46  }
47  size_t lenb = *privkey & ~0x80u; privkey++;
48  if (lenb < 1 || lenb > 2) {
49  return 0;
50  }
51  if (end - privkey < lenb) {
52  return 0;
53  }
54  /* sequence length */
55  size_t len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0u);
56  privkey += lenb;
57  if (end - privkey < len) {
58  return 0;
59  }
60  /* sequence element 0: version number (=1) */
61  if (end - privkey < 3 || privkey[0] != 0x02u || privkey[1] != 0x01u || privkey[2] != 0x01u) {
62  return 0;
63  }
64  privkey += 3;
65  /* sequence element 1: octet string, up to 32 bytes */
66  if (end - privkey < 2 || privkey[0] != 0x04u) {
67  return 0;
68  }
69  size_t oslen = privkey[1];
70  privkey += 2;
71  if (oslen > 32 || end - privkey < oslen) {
72  return 0;
73  }
74  memcpy(out32 + (32 - oslen), privkey, oslen);
75  if (!secp256k1_ec_seckey_verify(ctx, out32)) {
76  memset(out32, 0, 32);
77  return 0;
78  }
79  return 1;
80 }
81 
92 static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed) {
93  assert(*privkeylen >= CKey::PRIVATE_KEY_SIZE);
94  secp256k1_pubkey pubkey;
95  size_t pubkeylen = 0;
96  if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
97  *privkeylen = 0;
98  return 0;
99  }
100  if (compressed) {
101  static const unsigned char begin[] = {
102  0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
103  };
104  static const unsigned char middle[] = {
105  0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
106  0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
107  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
108  0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
109  0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
110  0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
111  0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
112  0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
113  0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
114  };
115  unsigned char *ptr = privkey;
116  memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
117  memcpy(ptr, key32, 32); ptr += 32;
118  memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
120  secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
121  ptr += pubkeylen;
122  *privkeylen = ptr - privkey;
123  assert(*privkeylen == CKey::COMPRESSED_PRIVATE_KEY_SIZE);
124  } else {
125  static const unsigned char begin[] = {
126  0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
127  };
128  static const unsigned char middle[] = {
129  0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
130  0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
131  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
132  0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
133  0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
134  0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
135  0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
136  0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
137  0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
138  0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
139  0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
140  };
141  unsigned char *ptr = privkey;
142  memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
143  memcpy(ptr, key32, 32); ptr += 32;
144  memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
145  pubkeylen = CPubKey::PUBLIC_KEY_SIZE;
146  secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
147  ptr += pubkeylen;
148  *privkeylen = ptr - privkey;
149  assert(*privkeylen == CKey::PRIVATE_KEY_SIZE);
150  }
151  return 1;
152 }
153 
154 bool CKey::Check(const unsigned char *vch) {
156 }
157 
158 void CKey::MakeNewKey(bool fCompressedIn) {
159  do {
160  GetStrongRandBytes(keydata.data(), keydata.size());
161  } while (!Check(keydata.data()));
162  fValid = true;
163  fCompressed = fCompressedIn;
164 }
165 
167  assert(fValid);
168  CPrivKey privkey;
169  int ret;
170  size_t privkeylen;
171  privkey.resize(PRIVATE_KEY_SIZE);
172  privkeylen = PRIVATE_KEY_SIZE;
173  ret = ec_privkey_export_der(secp256k1_context_sign, (unsigned char*) privkey.data(), &privkeylen, begin(), fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
174  assert(ret);
175  privkey.resize(privkeylen);
176  return privkey;
177 }
178 
180  assert(fValid);
181  secp256k1_pubkey pubkey;
182  size_t clen = CPubKey::PUBLIC_KEY_SIZE;
183  CPubKey result;
185  assert(ret);
187  assert(result.size() == clen);
188  assert(result.IsValid());
189  return result;
190 }
191 
192 bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, uint32_t test_case) const {
193  if (!fValid)
194  return false;
195  vchSig.resize(CPubKey::SIGNATURE_SIZE);
196  size_t nSigLen = CPubKey::SIGNATURE_SIZE;
197  unsigned char extra_entropy[32] = {0};
198  WriteLE32(extra_entropy, test_case);
200  int ret = secp256k1_ecdsa_sign(secp256k1_context_sign, &sig, hash.begin(), begin(), secp256k1_nonce_function_rfc6979, test_case ? extra_entropy : nullptr);
201  assert(ret);
202  secp256k1_ecdsa_signature_serialize_der(secp256k1_context_sign, (unsigned char*)vchSig.data(), &nSigLen, &sig);
203  vchSig.resize(nSigLen);
204  return true;
205 }
206 
207 bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
208  if (pubkey.IsCompressed() != fCompressed) {
209  return false;
210  }
211  unsigned char rnd[8];
212  std::string str = "Bitcoin key verification\n";
213  GetRandBytes(rnd, sizeof(rnd));
214  uint256 hash;
215  CHash256().Write((unsigned char*)str.data(), str.size()).Write(rnd, sizeof(rnd)).Finalize(hash.begin());
216  std::vector<unsigned char> vchSig;
217  Sign(hash, vchSig);
218  return pubkey.Verify(hash, vchSig);
219 }
220 
221 bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) const {
222  if (!fValid)
223  return false;
224  vchSig.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
225  int rec = -1;
228  assert(ret);
230  assert(ret);
231  assert(rec != -1);
232  vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
233  return true;
234 }
235 
236 bool CKey::Load(const CPrivKey &privkey, const CPubKey &vchPubKey, bool fSkipCheck=false) {
237  if (!ec_privkey_import_der(secp256k1_context_sign, (unsigned char*)begin(), privkey.data(), privkey.size()))
238  return false;
239  fCompressed = vchPubKey.IsCompressed();
240  fValid = true;
241 
242  if (fSkipCheck)
243  return true;
244 
245  return VerifyPubKey(vchPubKey);
246 }
247 
248 bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode& cc) const {
249  assert(IsValid());
250  assert(IsCompressed());
251  std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
252  if ((nChild >> 31) == 0) {
253  CPubKey pubkey = GetPubKey();
254  assert(pubkey.size() == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE);
255  BIP32Hash(cc, nChild, *pubkey.begin(), pubkey.begin()+1, vout.data());
256  } else {
257  assert(size() == 32);
258  BIP32Hash(cc, nChild, 0, begin(), vout.data());
259  }
260  memcpy(ccChild.begin(), vout.data()+32, 32);
261  memcpy((unsigned char*)keyChild.begin(), begin(), 32);
262  bool ret = secp256k1_ec_privkey_tweak_add(secp256k1_context_sign, (unsigned char*)keyChild.begin(), vout.data());
263  keyChild.fCompressed = true;
264  keyChild.fValid = ret;
265  return ret;
266 }
267 
268 bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
269  out.nDepth = nDepth + 1;
270  CKeyID id = key.GetPubKey().GetID();
271  memcpy(&out.vchFingerprint[0], &id, 4);
272  out.nChild = _nChild;
273  return key.Derive(out.key, out.chaincode, _nChild, chaincode);
274 }
275 
276 void CExtKey::SetMaster(const unsigned char *seed, unsigned int nSeedLen) {
277  static const unsigned char hashkey[] = {'B','i','t','c','o','i','n',' ','s','e','e','d'};
278  std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
279  CHMAC_SHA512(hashkey, sizeof(hashkey)).Write(seed, nSeedLen).Finalize(vout.data());
280  key.Set(vout.data(), vout.data() + 32, true);
281  memcpy(chaincode.begin(), vout.data() + 32, 32);
282  nDepth = 0;
283  nChild = 0;
284  memset(vchFingerprint, 0, sizeof(vchFingerprint));
285 }
286 
288  CExtPubKey ret;
289  ret.nDepth = nDepth;
290  memcpy(&ret.vchFingerprint[0], &vchFingerprint[0], 4);
291  ret.nChild = nChild;
292  ret.pubkey = key.GetPubKey();
293  ret.chaincode = chaincode;
294  return ret;
295 }
296 
297 void CExtKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
298  code[0] = nDepth;
299  memcpy(code+1, vchFingerprint, 4);
300  code[5] = (nChild >> 24) & 0xFF; code[6] = (nChild >> 16) & 0xFF;
301  code[7] = (nChild >> 8) & 0xFF; code[8] = (nChild >> 0) & 0xFF;
302  memcpy(code+9, chaincode.begin(), 32);
303  code[41] = 0;
304  assert(key.size() == 32);
305  memcpy(code+42, key.begin(), 32);
306 }
307 
308 void CExtKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
309  nDepth = code[0];
310  memcpy(vchFingerprint, code+1, 4);
311  nChild = (code[5] << 24) | (code[6] << 16) | (code[7] << 8) | code[8];
312  memcpy(chaincode.begin(), code+9, 32);
313  key.Set(code+42, code+BIP32_EXTKEY_SIZE, true);
314 }
315 
317  CKey key;
318  key.MakeNewKey(true);
319  CPubKey pubkey = key.GetPubKey();
320  return key.VerifyPubKey(pubkey);
321 }
322 
323 void ECC_Start() {
324  assert(secp256k1_context_sign == nullptr);
325 
327  assert(ctx != nullptr);
328 
329  {
330  // Pass in a random blinding seed to the secp256k1 context.
331  std::vector<unsigned char, secure_allocator<unsigned char>> vseed(32);
332  GetRandBytes(vseed.data(), 32);
333  bool ret = secp256k1_context_randomize(ctx, vseed.data());
334  assert(ret);
335  }
336 
338 }
339 
340 void ECC_Stop() {
342  secp256k1_context_sign = nullptr;
343 
344  if (ctx) {
346  }
347 }
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:323
CPrivKey GetPrivKey() const
Convert the private key to a CPrivKey (serialized OpenSSL private key data).
Definition: key.cpp:166
unsigned char vchFingerprint[4]
Definition: pubkey.h:202
CKey key
Definition: key.h:146
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:571
bool Derive(CExtKey &out, unsigned int nChild) const
Definition: key.cpp:268
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
Definition: key.cpp:207
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:179
CHash256 & Write(const unsigned char *data, size_t len)
Definition: hash.h:47
static const unsigned int COMPRESSED_PRIVATE_KEY_SIZE
Definition: key.h:34
Definition: key.h:141
void Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const
Definition: key.cpp:297
Opaque data structured that holds a parsed ECDSA signature, supporting pubkey recovery.
static void WriteLE32(unsigned char *ptr, uint32_t x)
Definition: common.h:44
unsigned char vchFingerprint[4]
Definition: key.h:143
static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed)
This serializes to a DER encoding of the ECPrivateKey type from section C.4 of SEC 1 http://www...
Definition: key.cpp:92
unsigned char nDepth
Definition: pubkey.h:201
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
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:186
A hasher class for Bitcoin&#39;s 256-bit hash (double SHA-256).
Definition: hash.h:35
ChainCode chaincode
Definition: pubkey.h:204
const unsigned char * begin() const
Definition: key.h:89
#define SECP256K1_CONTEXT_SIGN
Definition: secp256k1.h:168
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:478
unsigned char * begin()
Definition: uint256.h:57
bool fValid
see www.keylength.com script supports up to 75 for single byte push
Definition: key.h:41
unsigned int nChild
Definition: pubkey.h:203
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:149
const unsigned char * begin() const
Definition: pubkey.h:105
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, uint32_t test_case=0) const
Create a DER-serialized signature.
Definition: key.cpp:192
SECP256K1_API const secp256k1_nonce_function secp256k1_nonce_function_rfc6979
An implementation of RFC6979 (using HMAC-SHA256) as nonce generation function.
Definition: secp256k1.c:366
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:221
SECP256K1_API void secp256k1_context_destroy(secp256k1_context *ctx)
Destroy a secp256k1 context object.
Definition: secp256k1.c:101
static const unsigned int PUBLIC_KEY_SIZE
secp256k1:
Definition: pubkey.h:36
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:428
std::vector< unsigned char, secure_allocator< unsigned char > > CPrivKey
secure_allocator is defined in allocators.h CPrivKey is a serialized private key, with all parameters...
Definition: key.h:24
#define SECP256K1_EC_UNCOMPRESSED
Definition: secp256k1.h:173
#define SECP256K1_EC_COMPRESSED
Flag to pass to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export.
Definition: secp256k1.h:172
static const unsigned int PRIVATE_KEY_SIZE
secp256k1:
Definition: key.h:33
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:415
static const unsigned int COMPRESSED_PUBLIC_KEY_SIZE
Definition: pubkey.h:37
void ECC_Stop()
Deinitialize the elliptic curve support.
Definition: key.cpp:340
unsigned char nDepth
Definition: key.h:142
void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64])
Definition: hash.cpp:71
static secp256k1_context * ctx
Definition: tests.c:46
bool IsValid() const
Definition: pubkey.h:165
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:369
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:30
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:158
unsigned int nChild
Definition: key.h:144
unsigned int size() const
Simple read-only vector-like interface.
Definition: key.h:88
unsigned int size() const
Simple read-only vector-like interface to the pubkey data.
Definition: pubkey.h:104
bool IsCompressed() const
Check whether the public key corresponding to this private key is (to be) compressed.
Definition: key.h:96
Opaque data structured that holds a parsed ECDSA signature.
Definition: secp256k1.h:79
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
static int ec_privkey_import_der(const secp256k1_context *ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen)
These functions are taken from the libsecp256k1 distribution and are very ugly.
Definition: key.cpp:35
ChainCode chaincode
Definition: key.h:145
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
Definition: key.h:74
static secp256k1_context * secp256k1_context_sign
Definition: key.cpp:16
void Decode(const unsigned char code[BIP32_EXTKEY_SIZE])
Definition: key.cpp:308
256-bit opaque blob.
Definition: uint256.h:123
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:270
static const unsigned int COMPACT_SIGNATURE_SIZE
Definition: pubkey.h:39
CExtPubKey Neuter() const
Definition: key.cpp:287
bool Verify(const uint256 &hash, const std::vector< unsigned char > &vchSig) const
Verify a DER signature (~72 bytes).
Definition: pubkey.cpp:169
bool Derive(CKey &keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child key.
Definition: key.cpp:248
void * memcpy(void *a, const void *b, size_t c)
const unsigned int BIP32_EXTKEY_SIZE
Definition: pubkey.h:17
A reference to a CKey: the Hash160 of its serialized public key.
Definition: pubkey.h:20
bool fCompressed
Whether the public key corresponding to this private key is (to be) compressed.
Definition: key.h:49
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:276
CPubKey pubkey
Definition: pubkey.h:205
static const unsigned int SIGNATURE_SIZE
Definition: pubkey.h:38
std::vector< unsigned char, secure_allocator< unsigned char > > keydata
The actual byte data.
Definition: key.h:52
static bool Check(const unsigned char *vch)
Check whether the 32-byte array pointed to by vch is valid keydata.
Definition: key.cpp:154
An encapsulated private key.
Definition: key.h:27
bool ECC_InitSanityCheck()
Check that required EC support is available at runtime.
Definition: key.cpp:316
SECP256K1_API secp256k1_context * secp256k1_context_create(unsigned int flags) SECP256K1_WARN_UNUSED_RESULT
Create a secp256k1 context object.
Definition: secp256k1.c:67
bool Load(const CPrivKey &privkey, const CPubKey &vchPubKey, bool fSkipCheck)
Load private key and check that public key matches.
Definition: key.cpp:236
bool IsValid() const
Check whether this private key is valid.
Definition: key.h:93
Opaque data structure that holds a parsed and valid public key.
Definition: secp256k1.h:66
bool IsCompressed() const
Check whether this is a compressed public key.
Definition: pubkey.h:174
A hasher class for HMAC-SHA-512.
Definition: hmac_sha512.h:14
Released under the MIT license