@@ -32,46 +32,46 @@ static secp256k1_context* secp256k1_context_sign = nullptr;
3232 *
3333 * out32 must point to an output buffer of length at least 32 bytes.
3434 */
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 ;
35+ static int ec_seckey_import_der (const secp256k1_context* ctx, unsigned char *out32, const unsigned char *seckey , size_t seckeylen ) {
36+ const unsigned char *end = seckey + seckeylen ;
3737 memset (out32, 0 , 32 );
3838 /* sequence header */
39- if (end - privkey < 1 || *privkey != 0x30u ) {
39+ if (end - seckey < 1 || *seckey != 0x30u ) {
4040 return 0 ;
4141 }
42- privkey ++;
42+ seckey ++;
4343 /* sequence length constructor */
44- if (end - privkey < 1 || !(*privkey & 0x80u )) {
44+ if (end - seckey < 1 || !(*seckey & 0x80u )) {
4545 return 0 ;
4646 }
47- ptrdiff_t lenb = *privkey & ~0x80u ; privkey ++;
47+ ptrdiff_t lenb = *seckey & ~0x80u ; seckey ++;
4848 if (lenb < 1 || lenb > 2 ) {
4949 return 0 ;
5050 }
51- if (end - privkey < lenb) {
51+ if (end - seckey < lenb) {
5252 return 0 ;
5353 }
5454 /* sequence length */
55- ptrdiff_t len = privkey [lenb-1 ] | (lenb > 1 ? privkey [lenb-2 ] << 8 : 0u );
56- privkey += lenb;
57- if (end - privkey < len) {
55+ ptrdiff_t len = seckey [lenb-1 ] | (lenb > 1 ? seckey [lenb-2 ] << 8 : 0u );
56+ seckey += lenb;
57+ if (end - seckey < len) {
5858 return 0 ;
5959 }
6060 /* sequence element 0: version number (=1) */
61- if (end - privkey < 3 || privkey [0 ] != 0x02u || privkey [1 ] != 0x01u || privkey [2 ] != 0x01u ) {
61+ if (end - seckey < 3 || seckey [0 ] != 0x02u || seckey [1 ] != 0x01u || seckey [2 ] != 0x01u ) {
6262 return 0 ;
6363 }
64- privkey += 3 ;
64+ seckey += 3 ;
6565 /* sequence element 1: octet string, up to 32 bytes */
66- if (end - privkey < 2 || privkey [0 ] != 0x04u ) {
66+ if (end - seckey < 2 || seckey [0 ] != 0x04u ) {
6767 return 0 ;
6868 }
69- ptrdiff_t oslen = privkey [1 ];
70- privkey += 2 ;
71- if (oslen > 32 || end - privkey < oslen) {
69+ ptrdiff_t oslen = seckey [1 ];
70+ seckey += 2 ;
71+ if (oslen > 32 || end - seckey < oslen) {
7272 return 0 ;
7373 }
74- memcpy (out32 + (32 - oslen), privkey , oslen);
74+ memcpy (out32 + (32 - oslen), seckey , oslen);
7575 if (!secp256k1_ec_seckey_verify (ctx, out32)) {
7676 memset (out32, 0 , 32 );
7777 return 0 ;
@@ -84,17 +84,17 @@ static int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *ou
8484 * <http://www.secg.org/sec1-v2.pdf>. The optional parameters and publicKey fields are
8585 * included.
8686 *
87- * privkey must point to an output buffer of length at least CKey::SIZE bytes.
88- * privkeylen must initially be set to the size of the privkey buffer. Upon return it
87+ * seckey must point to an output buffer of length at least CKey::SIZE bytes.
88+ * seckeylen must initially be set to the size of the seckey buffer. Upon return it
8989 * will be set to the number of bytes used in the buffer.
9090 * key32 must point to a 32-byte raw private key.
9191 */
92- static int ec_privkey_export_der (const secp256k1_context *ctx, unsigned char *privkey , size_t *privkeylen , const unsigned char *key32, bool compressed) {
93- assert (*privkeylen >= CKey::SIZE);
92+ static int ec_seckey_export_der (const secp256k1_context *ctx, unsigned char *seckey , size_t *seckeylen , const unsigned char *key32, bool compressed) {
93+ assert (*seckeylen >= CKey::SIZE);
9494 secp256k1_pubkey pubkey;
9595 size_t pubkeylen = 0 ;
9696 if (!secp256k1_ec_pubkey_create (ctx, &pubkey, key32)) {
97- *privkeylen = 0 ;
97+ *seckeylen = 0 ;
9898 return 0 ;
9999 }
100100 if (compressed) {
@@ -112,15 +112,15 @@ static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *pr
112112 0xFF ,0xFF ,0xFF ,0xFF ,0xFE ,0xBA ,0xAE ,0xDC ,0xE6 ,0xAF ,0x48 ,0xA0 ,0x3B ,0xBF ,0xD2 ,0x5E ,
113113 0x8C ,0xD0 ,0x36 ,0x41 ,0x41 ,0x02 ,0x01 ,0x01 ,0xA1 ,0x24 ,0x03 ,0x22 ,0x00
114114 };
115- unsigned char *ptr = privkey ;
115+ unsigned char *ptr = seckey ;
116116 memcpy (ptr, begin, sizeof (begin)); ptr += sizeof (begin);
117117 memcpy (ptr, key32, 32 ); ptr += 32 ;
118118 memcpy (ptr, middle, sizeof (middle)); ptr += sizeof (middle);
119119 pubkeylen = CPubKey::COMPRESSED_SIZE;
120120 secp256k1_ec_pubkey_serialize (ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
121121 ptr += pubkeylen;
122- *privkeylen = ptr - privkey ;
123- assert (*privkeylen == CKey::COMPRESSED_SIZE);
122+ *seckeylen = ptr - seckey ;
123+ assert (*seckeylen == CKey::COMPRESSED_SIZE);
124124 } else {
125125 static const unsigned char begin[] = {
126126 0x30 ,0x82 ,0x01 ,0x13 ,0x02 ,0x01 ,0x01 ,0x04 ,0x20
@@ -138,15 +138,15 @@ static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *pr
138138 0xFF ,0xFF ,0xFF ,0xFF ,0xFE ,0xBA ,0xAE ,0xDC ,0xE6 ,0xAF ,0x48 ,0xA0 ,0x3B ,0xBF ,0xD2 ,0x5E ,
139139 0x8C ,0xD0 ,0x36 ,0x41 ,0x41 ,0x02 ,0x01 ,0x01 ,0xA1 ,0x44 ,0x03 ,0x42 ,0x00
140140 };
141- unsigned char *ptr = privkey ;
141+ unsigned char *ptr = seckey ;
142142 memcpy (ptr, begin, sizeof (begin)); ptr += sizeof (begin);
143143 memcpy (ptr, key32, 32 ); ptr += 32 ;
144144 memcpy (ptr, middle, sizeof (middle)); ptr += sizeof (middle);
145145 pubkeylen = CPubKey::SIZE;
146146 secp256k1_ec_pubkey_serialize (ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
147147 ptr += pubkeylen;
148- *privkeylen = ptr - privkey ;
149- assert (*privkeylen == CKey::SIZE);
148+ *seckeylen = ptr - seckey ;
149+ assert (*seckeylen == CKey::SIZE);
150150 }
151151 return 1 ;
152152}
@@ -166,20 +166,20 @@ void CKey::MakeNewKey(bool fCompressedIn) {
166166bool CKey::Negate ()
167167{
168168 assert (fValid );
169- return secp256k1_ec_privkey_negate (secp256k1_context_sign, keydata.data ());
169+ return secp256k1_ec_seckey_negate (secp256k1_context_sign, keydata.data ());
170170}
171171
172172CPrivKey CKey::GetPrivKey () const {
173173 assert (fValid );
174- CPrivKey privkey ;
174+ CPrivKey seckey ;
175175 int ret;
176- size_t privkeylen ;
177- privkey .resize (SIZE);
178- privkeylen = SIZE;
179- ret = ec_privkey_export_der (secp256k1_context_sign, privkey .data (), &privkeylen , begin (), fCompressed );
176+ size_t seckeylen ;
177+ seckey .resize (SIZE);
178+ seckeylen = SIZE;
179+ ret = ec_seckey_export_der (secp256k1_context_sign, seckey .data (), &seckeylen , begin (), fCompressed );
180180 assert (ret);
181- privkey .resize (privkeylen );
182- return privkey ;
181+ seckey .resize (seckeylen );
182+ return seckey ;
183183}
184184
185185CPubKey CKey::GetPubKey () const {
@@ -259,8 +259,8 @@ bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig)
259259 return true ;
260260}
261261
262- bool CKey::Load (const CPrivKey &privkey , const CPubKey &vchPubKey, bool fSkipCheck =false ) {
263- if (!ec_privkey_import_der (secp256k1_context_sign, (unsigned char *)begin (), privkey .data (), privkey .size ()))
262+ bool CKey::Load (const CPrivKey &seckey , const CPubKey &vchPubKey, bool fSkipCheck =false ) {
263+ if (!ec_seckey_import_der (secp256k1_context_sign, (unsigned char *)begin (), seckey .data (), seckey .size ()))
264264 return false ;
265265 fCompressed = vchPubKey.IsCompressed ();
266266 fValid = true ;
@@ -285,7 +285,7 @@ bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const
285285 }
286286 memcpy (ccChild.begin (), vout.data ()+32 , 32 );
287287 memcpy ((unsigned char *)keyChild.begin (), begin (), 32 );
288- bool ret = secp256k1_ec_privkey_tweak_add (secp256k1_context_sign, (unsigned char *)keyChild.begin (), vout.data ());
288+ bool ret = secp256k1_ec_seckey_tweak_add (secp256k1_context_sign, (unsigned char *)keyChild.begin (), vout.data ());
289289 keyChild.fCompressed = true ;
290290 keyChild.fValid = ret;
291291 return ret;
0 commit comments