@@ -33,46 +33,46 @@ static secp256k1_context* secp256k1_context_sign = nullptr;
3333 *
3434 * out32 must point to an output buffer of length at least 32 bytes.
3535 */
36- static int ec_privkey_import_der (const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey , size_t privkeylen ) {
37- const unsigned char *end = privkey + privkeylen ;
36+ static int ec_seckey_import_der (const secp256k1_context* ctx, unsigned char *out32, const unsigned char *seckey , size_t seckeylen ) {
37+ const unsigned char *end = seckey + seckeylen ;
3838 memset (out32, 0 , 32 );
3939 /* sequence header */
40- if (end - privkey < 1 || *privkey != 0x30u ) {
40+ if (end - seckey < 1 || *seckey != 0x30u ) {
4141 return 0 ;
4242 }
43- privkey ++;
43+ seckey ++;
4444 /* sequence length constructor */
45- if (end - privkey < 1 || !(*privkey & 0x80u )) {
45+ if (end - seckey < 1 || !(*seckey & 0x80u )) {
4646 return 0 ;
4747 }
48- ptrdiff_t lenb = *privkey & ~0x80u ; privkey ++;
48+ ptrdiff_t lenb = *seckey & ~0x80u ; seckey ++;
4949 if (lenb < 1 || lenb > 2 ) {
5050 return 0 ;
5151 }
52- if (end - privkey < lenb) {
52+ if (end - seckey < lenb) {
5353 return 0 ;
5454 }
5555 /* sequence length */
56- ptrdiff_t len = privkey [lenb-1 ] | (lenb > 1 ? privkey [lenb-2 ] << 8 : 0u );
57- privkey += lenb;
58- if (end - privkey < len) {
56+ ptrdiff_t len = seckey [lenb-1 ] | (lenb > 1 ? seckey [lenb-2 ] << 8 : 0u );
57+ seckey += lenb;
58+ if (end - seckey < len) {
5959 return 0 ;
6060 }
6161 /* sequence element 0: version number (=1) */
62- if (end - privkey < 3 || privkey [0 ] != 0x02u || privkey [1 ] != 0x01u || privkey [2 ] != 0x01u ) {
62+ if (end - seckey < 3 || seckey [0 ] != 0x02u || seckey [1 ] != 0x01u || seckey [2 ] != 0x01u ) {
6363 return 0 ;
6464 }
65- privkey += 3 ;
65+ seckey += 3 ;
6666 /* sequence element 1: octet string, up to 32 bytes */
67- if (end - privkey < 2 || privkey [0 ] != 0x04u ) {
67+ if (end - seckey < 2 || seckey [0 ] != 0x04u ) {
6868 return 0 ;
6969 }
70- ptrdiff_t oslen = privkey [1 ];
71- privkey += 2 ;
72- if (oslen > 32 || end - privkey < oslen) {
70+ ptrdiff_t oslen = seckey [1 ];
71+ seckey += 2 ;
72+ if (oslen > 32 || end - seckey < oslen) {
7373 return 0 ;
7474 }
75- memcpy (out32 + (32 - oslen), privkey , oslen);
75+ memcpy (out32 + (32 - oslen), seckey , oslen);
7676 if (!secp256k1_ec_seckey_verify (ctx, out32)) {
7777 memset (out32, 0 , 32 );
7878 return 0 ;
@@ -85,17 +85,17 @@ static int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *ou
8585 * <http://www.secg.org/sec1-v2.pdf>. The optional parameters and publicKey fields are
8686 * included.
8787 *
88- * privkey must point to an output buffer of length at least CKey::SIZE bytes.
89- * privkeylen must initially be set to the size of the privkey buffer. Upon return it
88+ * seckey must point to an output buffer of length at least CKey::SIZE bytes.
89+ * seckeylen must initially be set to the size of the seckey buffer. Upon return it
9090 * will be set to the number of bytes used in the buffer.
9191 * key32 must point to a 32-byte raw private key.
9292 */
93- static int ec_privkey_export_der (const secp256k1_context *ctx, unsigned char *privkey , size_t *privkeylen , const unsigned char *key32, bool compressed) {
94- assert (*privkeylen >= CKey::SIZE);
93+ static int ec_seckey_export_der (const secp256k1_context *ctx, unsigned char *seckey , size_t *seckeylen , const unsigned char *key32, bool compressed) {
94+ assert (*seckeylen >= CKey::SIZE);
9595 secp256k1_pubkey pubkey;
9696 size_t pubkeylen = 0 ;
9797 if (!secp256k1_ec_pubkey_create (ctx, &pubkey, key32)) {
98- *privkeylen = 0 ;
98+ *seckeylen = 0 ;
9999 return 0 ;
100100 }
101101 if (compressed) {
@@ -113,15 +113,15 @@ static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *pr
113113 0xFF ,0xFF ,0xFF ,0xFF ,0xFE ,0xBA ,0xAE ,0xDC ,0xE6 ,0xAF ,0x48 ,0xA0 ,0x3B ,0xBF ,0xD2 ,0x5E ,
114114 0x8C ,0xD0 ,0x36 ,0x41 ,0x41 ,0x02 ,0x01 ,0x01 ,0xA1 ,0x24 ,0x03 ,0x22 ,0x00
115115 };
116- unsigned char *ptr = privkey ;
116+ unsigned char *ptr = seckey ;
117117 memcpy (ptr, begin, sizeof (begin)); ptr += sizeof (begin);
118118 memcpy (ptr, key32, 32 ); ptr += 32 ;
119119 memcpy (ptr, middle, sizeof (middle)); ptr += sizeof (middle);
120120 pubkeylen = CPubKey::COMPRESSED_SIZE;
121121 secp256k1_ec_pubkey_serialize (ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
122122 ptr += pubkeylen;
123- *privkeylen = ptr - privkey ;
124- assert (*privkeylen == CKey::COMPRESSED_SIZE);
123+ *seckeylen = ptr - seckey ;
124+ assert (*seckeylen == CKey::COMPRESSED_SIZE);
125125 } else {
126126 static const unsigned char begin[] = {
127127 0x30 ,0x82 ,0x01 ,0x13 ,0x02 ,0x01 ,0x01 ,0x04 ,0x20
@@ -139,15 +139,15 @@ static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *pr
139139 0xFF ,0xFF ,0xFF ,0xFF ,0xFE ,0xBA ,0xAE ,0xDC ,0xE6 ,0xAF ,0x48 ,0xA0 ,0x3B ,0xBF ,0xD2 ,0x5E ,
140140 0x8C ,0xD0 ,0x36 ,0x41 ,0x41 ,0x02 ,0x01 ,0x01 ,0xA1 ,0x44 ,0x03 ,0x42 ,0x00
141141 };
142- unsigned char *ptr = privkey ;
142+ unsigned char *ptr = seckey ;
143143 memcpy (ptr, begin, sizeof (begin)); ptr += sizeof (begin);
144144 memcpy (ptr, key32, 32 ); ptr += 32 ;
145145 memcpy (ptr, middle, sizeof (middle)); ptr += sizeof (middle);
146146 pubkeylen = CPubKey::SIZE;
147147 secp256k1_ec_pubkey_serialize (ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
148148 ptr += pubkeylen;
149- *privkeylen = ptr - privkey ;
150- assert (*privkeylen == CKey::SIZE);
149+ *seckeylen = ptr - seckey ;
150+ assert (*seckeylen == CKey::SIZE);
151151 }
152152 return 1 ;
153153}
@@ -167,20 +167,20 @@ void CKey::MakeNewKey(bool fCompressedIn) {
167167bool CKey::Negate ()
168168{
169169 assert (fValid );
170- return secp256k1_ec_privkey_negate (secp256k1_context_sign, keydata.data ());
170+ return secp256k1_ec_seckey_negate (secp256k1_context_sign, keydata.data ());
171171}
172172
173173CPrivKey CKey::GetPrivKey () const {
174174 assert (fValid );
175- CPrivKey privkey ;
175+ CPrivKey seckey ;
176176 int ret;
177- size_t privkeylen ;
178- privkey .resize (SIZE);
179- privkeylen = SIZE;
180- ret = ec_privkey_export_der (secp256k1_context_sign, privkey .data (), &privkeylen , begin (), fCompressed );
177+ size_t seckeylen ;
178+ seckey .resize (SIZE);
179+ seckeylen = SIZE;
180+ ret = ec_seckey_export_der (secp256k1_context_sign, seckey .data (), &seckeylen , begin (), fCompressed );
181181 assert (ret);
182- privkey .resize (privkeylen );
183- return privkey ;
182+ seckey .resize (seckeylen );
183+ return seckey ;
184184}
185185
186186CPubKey CKey::GetPubKey () const {
@@ -260,8 +260,8 @@ bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig)
260260 return true ;
261261}
262262
263- bool CKey::Load (const CPrivKey &privkey , const CPubKey &vchPubKey, bool fSkipCheck =false ) {
264- if (!ec_privkey_import_der (secp256k1_context_sign, (unsigned char *)begin (), privkey .data (), privkey .size ()))
263+ bool CKey::Load (const CPrivKey &seckey , const CPubKey &vchPubKey, bool fSkipCheck =false ) {
264+ if (!ec_seckey_import_der (secp256k1_context_sign, (unsigned char *)begin (), seckey .data (), seckey .size ()))
265265 return false ;
266266 fCompressed = vchPubKey.IsCompressed ();
267267 fValid = true ;
@@ -286,7 +286,7 @@ bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const
286286 }
287287 memcpy (ccChild.begin (), vout.data ()+32 , 32 );
288288 memcpy ((unsigned char *)keyChild.begin (), begin (), 32 );
289- bool ret = secp256k1_ec_privkey_tweak_add (secp256k1_context_sign, (unsigned char *)keyChild.begin (), vout.data ());
289+ bool ret = secp256k1_ec_seckey_tweak_add (secp256k1_context_sign, (unsigned char *)keyChild.begin (), vout.data ());
290290 keyChild.fCompressed = true ;
291291 keyChild.fValid = ret;
292292 return ret;
0 commit comments