@@ -31,46 +31,46 @@ static secp256k1_context* secp256k1_context_sign = nullptr;
3131 *
3232 * out32 must point to an output buffer of length at least 32 bytes.
3333 */
34- static int ec_privkey_import_der (const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey , size_t privkeylen ) {
35- const unsigned char *end = privkey + privkeylen ;
34+ static int ec_seckey_import_der (const secp256k1_context* ctx, unsigned char *out32, const unsigned char *seckey , size_t seckeylen ) {
35+ const unsigned char *end = seckey + seckeylen ;
3636 memset (out32, 0 , 32 );
3737 /* sequence header */
38- if (end - privkey < 1 || *privkey != 0x30u ) {
38+ if (end - seckey < 1 || *seckey != 0x30u ) {
3939 return 0 ;
4040 }
41- privkey ++;
41+ seckey ++;
4242 /* sequence length constructor */
43- if (end - privkey < 1 || !(*privkey & 0x80u )) {
43+ if (end - seckey < 1 || !(*seckey & 0x80u )) {
4444 return 0 ;
4545 }
46- ptrdiff_t lenb = *privkey & ~0x80u ; privkey ++;
46+ ptrdiff_t lenb = *seckey & ~0x80u ; seckey ++;
4747 if (lenb < 1 || lenb > 2 ) {
4848 return 0 ;
4949 }
50- if (end - privkey < lenb) {
50+ if (end - seckey < lenb) {
5151 return 0 ;
5252 }
5353 /* sequence length */
54- ptrdiff_t len = privkey [lenb-1 ] | (lenb > 1 ? privkey [lenb-2 ] << 8 : 0u );
55- privkey += lenb;
56- if (end - privkey < len) {
54+ ptrdiff_t len = seckey [lenb-1 ] | (lenb > 1 ? seckey [lenb-2 ] << 8 : 0u );
55+ seckey += lenb;
56+ if (end - seckey < len) {
5757 return 0 ;
5858 }
5959 /* sequence element 0: version number (=1) */
60- if (end - privkey < 3 || privkey [0 ] != 0x02u || privkey [1 ] != 0x01u || privkey [2 ] != 0x01u ) {
60+ if (end - seckey < 3 || seckey [0 ] != 0x02u || seckey [1 ] != 0x01u || seckey [2 ] != 0x01u ) {
6161 return 0 ;
6262 }
63- privkey += 3 ;
63+ seckey += 3 ;
6464 /* sequence element 1: octet string, up to 32 bytes */
65- if (end - privkey < 2 || privkey [0 ] != 0x04u ) {
65+ if (end - seckey < 2 || seckey [0 ] != 0x04u ) {
6666 return 0 ;
6767 }
68- ptrdiff_t oslen = privkey [1 ];
69- privkey += 2 ;
70- if (oslen > 32 || end - privkey < oslen) {
68+ ptrdiff_t oslen = seckey [1 ];
69+ seckey += 2 ;
70+ if (oslen > 32 || end - seckey < oslen) {
7171 return 0 ;
7272 }
73- memcpy (out32 + (32 - oslen), privkey , oslen);
73+ memcpy (out32 + (32 - oslen), seckey , oslen);
7474 if (!secp256k1_ec_seckey_verify (ctx, out32)) {
7575 memset (out32, 0 , 32 );
7676 return 0 ;
@@ -83,17 +83,17 @@ static int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *ou
8383 * <http://www.secg.org/sec1-v2.pdf>. The optional parameters and publicKey fields are
8484 * included.
8585 *
86- * privkey must point to an output buffer of length at least CKey::SIZE bytes.
87- * privkeylen must initially be set to the size of the privkey buffer. Upon return it
86+ * seckey must point to an output buffer of length at least CKey::SIZE bytes.
87+ * seckeylen must initially be set to the size of the seckey buffer. Upon return it
8888 * will be set to the number of bytes used in the buffer.
8989 * key32 must point to a 32-byte raw private key.
9090 */
91- static int ec_privkey_export_der (const secp256k1_context *ctx, unsigned char *privkey , size_t *privkeylen , const unsigned char *key32, bool compressed) {
92- assert (*privkeylen >= CKey::SIZE);
91+ static int ec_seckey_export_der (const secp256k1_context *ctx, unsigned char *seckey , size_t *seckeylen , const unsigned char *key32, bool compressed) {
92+ assert (*seckeylen >= CKey::SIZE);
9393 secp256k1_pubkey pubkey;
9494 size_t pubkeylen = 0 ;
9595 if (!secp256k1_ec_pubkey_create (ctx, &pubkey, key32)) {
96- *privkeylen = 0 ;
96+ *seckeylen = 0 ;
9797 return 0 ;
9898 }
9999 if (compressed) {
@@ -111,15 +111,15 @@ static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *pr
111111 0xFF ,0xFF ,0xFF ,0xFF ,0xFE ,0xBA ,0xAE ,0xDC ,0xE6 ,0xAF ,0x48 ,0xA0 ,0x3B ,0xBF ,0xD2 ,0x5E ,
112112 0x8C ,0xD0 ,0x36 ,0x41 ,0x41 ,0x02 ,0x01 ,0x01 ,0xA1 ,0x24 ,0x03 ,0x22 ,0x00
113113 };
114- unsigned char *ptr = privkey ;
114+ unsigned char *ptr = seckey ;
115115 memcpy (ptr, begin, sizeof (begin)); ptr += sizeof (begin);
116116 memcpy (ptr, key32, 32 ); ptr += 32 ;
117117 memcpy (ptr, middle, sizeof (middle)); ptr += sizeof (middle);
118118 pubkeylen = CPubKey::COMPRESSED_SIZE;
119119 secp256k1_ec_pubkey_serialize (ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
120120 ptr += pubkeylen;
121- *privkeylen = ptr - privkey ;
122- assert (*privkeylen == CKey::COMPRESSED_SIZE);
121+ *seckeylen = ptr - seckey ;
122+ assert (*seckeylen == CKey::COMPRESSED_SIZE);
123123 } else {
124124 static const unsigned char begin[] = {
125125 0x30 ,0x82 ,0x01 ,0x13 ,0x02 ,0x01 ,0x01 ,0x04 ,0x20
@@ -137,15 +137,15 @@ static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *pr
137137 0xFF ,0xFF ,0xFF ,0xFF ,0xFE ,0xBA ,0xAE ,0xDC ,0xE6 ,0xAF ,0x48 ,0xA0 ,0x3B ,0xBF ,0xD2 ,0x5E ,
138138 0x8C ,0xD0 ,0x36 ,0x41 ,0x41 ,0x02 ,0x01 ,0x01 ,0xA1 ,0x44 ,0x03 ,0x42 ,0x00
139139 };
140- unsigned char *ptr = privkey ;
140+ unsigned char *ptr = seckey ;
141141 memcpy (ptr, begin, sizeof (begin)); ptr += sizeof (begin);
142142 memcpy (ptr, key32, 32 ); ptr += 32 ;
143143 memcpy (ptr, middle, sizeof (middle)); ptr += sizeof (middle);
144144 pubkeylen = CPubKey::SIZE;
145145 secp256k1_ec_pubkey_serialize (ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
146146 ptr += pubkeylen;
147- *privkeylen = ptr - privkey ;
148- assert (*privkeylen == CKey::SIZE);
147+ *seckeylen = ptr - seckey ;
148+ assert (*seckeylen == CKey::SIZE);
149149 }
150150 return 1 ;
151151}
@@ -165,20 +165,20 @@ void CKey::MakeNewKey(bool fCompressedIn) {
165165bool CKey::Negate ()
166166{
167167 assert (fValid );
168- return secp256k1_ec_privkey_negate (secp256k1_context_sign, keydata.data ());
168+ return secp256k1_ec_seckey_negate (secp256k1_context_sign, keydata.data ());
169169}
170170
171171CPrivKey CKey::GetPrivKey () const {
172172 assert (fValid );
173- CPrivKey privkey ;
173+ CPrivKey seckey ;
174174 int ret;
175- size_t privkeylen ;
176- privkey .resize (SIZE);
177- privkeylen = SIZE;
178- ret = ec_privkey_export_der (secp256k1_context_sign, privkey .data (), &privkeylen , begin (), fCompressed );
175+ size_t seckeylen ;
176+ seckey .resize (SIZE);
177+ seckeylen = SIZE;
178+ ret = ec_seckey_export_der (secp256k1_context_sign, seckey .data (), &seckeylen , begin (), fCompressed );
179179 assert (ret);
180- privkey .resize (privkeylen );
181- return privkey ;
180+ seckey .resize (seckeylen );
181+ return seckey ;
182182}
183183
184184CPubKey CKey::GetPubKey () const {
@@ -258,8 +258,8 @@ bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig)
258258 return true ;
259259}
260260
261- bool CKey::Load (const CPrivKey &privkey , const CPubKey &vchPubKey, bool fSkipCheck =false ) {
262- if (!ec_privkey_import_der (secp256k1_context_sign, (unsigned char *)begin (), privkey .data (), privkey .size ()))
261+ bool CKey::Load (const CPrivKey &seckey , const CPubKey &vchPubKey, bool fSkipCheck =false ) {
262+ if (!ec_seckey_import_der (secp256k1_context_sign, (unsigned char *)begin (), seckey .data (), seckey .size ()))
263263 return false ;
264264 fCompressed = vchPubKey.IsCompressed ();
265265 fValid = true ;
@@ -284,7 +284,7 @@ bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const
284284 }
285285 memcpy (ccChild.begin (), vout.data ()+32 , 32 );
286286 memcpy ((unsigned char *)keyChild.begin (), begin (), 32 );
287- bool ret = secp256k1_ec_privkey_tweak_add (secp256k1_context_sign, (unsigned char *)keyChild.begin (), vout.data ());
287+ bool ret = secp256k1_ec_seckey_tweak_add (secp256k1_context_sign, (unsigned char *)keyChild.begin (), vout.data ());
288288 keyChild.fCompressed = true ;
289289 keyChild.fValid = ret;
290290 return ret;
0 commit comments