Skip to content

Commit 792bcdb

Browse files
gmaxwellgmaxwell
committed
Covert several more files to C89.
1 parent 45cdf44 commit 792bcdb

File tree

5 files changed

+66
-50
lines changed

5 files changed

+66
-50
lines changed

‎src/ecdsa_impl.h‎

Lines changed: 33 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -25,32 +25,37 @@ static const secp256k1_fe_t secp256k1_ecdsa_const_p_minus_order = SECP256K1_FE_C
2525
);
2626

2727
static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned char *sig, int size) {
28+
unsigned char ra[32] = {0}, sa[32] = {0};
29+
const unsigned char *rp;
30+
const unsigned char *sp;
31+
int lenr;
32+
int lens;
33+
int overflow;
2834
if (sig[0] != 0x30) return 0;
29-
int lenr = sig[3];
35+
lenr = sig[3];
3036
if (5+lenr >= size) return 0;
31-
int lens = sig[lenr+5];
37+
lens = sig[lenr+5];
3238
if (sig[1] != lenr+lens+4) return 0;
3339
if (lenr+lens+6 > size) return 0;
3440
if (sig[2] != 0x02) return 0;
3541
if (lenr == 0) return 0;
3642
if (sig[lenr+4] != 0x02) return 0;
3743
if (lens == 0) return 0;
38-
const unsigned char *sp = sig + 6 + lenr;
44+
sp = sig + 6 + lenr;
3945
while (lens > 0 && sp[0] == 0) {
4046
lens--;
4147
sp++;
4248
}
4349
if (lens > 32) return 0;
44-
const unsigned char *rp = sig + 4;
50+
rp = sig + 4;
4551
while (lenr > 0 && rp[0] == 0) {
4652
lenr--;
4753
rp++;
4854
}
4955
if (lenr > 32) return 0;
50-
unsigned char ra[32] = {0}, sa[32] = {0};
5156
memcpy(ra + 32 - lenr, rp, lenr);
5257
memcpy(sa + 32 - lens, sp, lens);
53-
int overflow = 0;
58+
overflow = 0;
5459
secp256k1_scalar_set_b32(&r->r, ra, &overflow);
5560
if (overflow) return 0;
5661
secp256k1_scalar_set_b32(&r->s, sa, &overflow);
@@ -60,10 +65,10 @@ static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned ch
6065

6166
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_ecdsa_sig_t *a) {
6267
unsigned char r[33] = {0}, s[33] = {0};
63-
secp256k1_scalar_get_b32(&r[1], &a->r);
64-
secp256k1_scalar_get_b32(&s[1], &a->s);
6568
unsigned char *rp = r, *sp = s;
6669
int lenR = 33, lenS = 33;
70+
secp256k1_scalar_get_b32(&r[1], &a->r);
71+
secp256k1_scalar_get_b32(&s[1], &a->s);
6772
while (lenR > 1 && rp[0] == 0 && rp[1] < 0x80) { lenR--; rp++; }
6873
while (lenS > 1 && sp[0] == 0 && sp[1] < 0x80) { lenS--; sp++; }
6974
if (*size < 6+lenS+lenR)
@@ -81,21 +86,24 @@ static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const se
8186
}
8287

8388
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecdsa_sig_t *sig, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message) {
89+
unsigned char c[32];
90+
secp256k1_scalar_t sn, u1, u2;
91+
secp256k1_fe_t xr;
92+
secp256k1_gej_t pubkeyj;
93+
secp256k1_gej_t pr;
94+
8495
if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s))
8596
return 0;
8697

87-
secp256k1_scalar_t sn, u1, u2;
8898
secp256k1_scalar_inverse_var(&sn, &sig->s);
8999
secp256k1_scalar_mul(&u1, &sn, message);
90100
secp256k1_scalar_mul(&u2, &sn, &sig->r);
91-
secp256k1_gej_t pubkeyj; secp256k1_gej_set_ge(&pubkeyj, pubkey);
92-
secp256k1_gej_t pr; secp256k1_ecmult(&pr, &pubkeyj, &u2, &u1);
101+
secp256k1_gej_set_ge(&pubkeyj, pubkey);
102+
secp256k1_ecmult(&pr, &pubkeyj, &u2, &u1);
93103
if (secp256k1_gej_is_infinity(&pr)) {
94104
return 0;
95105
}
96-
unsigned char c[32];
97106
secp256k1_scalar_get_b32(c, &sig->r);
98-
secp256k1_fe_t xr;
99107
secp256k1_fe_set_b32(&xr, c);
100108

101109
/** We now have the recomputed R point in pr, and its claimed x coordinate (modulo n)
@@ -131,44 +139,47 @@ static int secp256k1_ecdsa_sig_verify(const secp256k1_ecdsa_sig_t *sig, const se
131139
}
132140

133141
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecdsa_sig_t *sig, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid) {
142+
unsigned char brx[32];
143+
secp256k1_fe_t fx;
144+
secp256k1_ge_t x;
145+
secp256k1_gej_t xj;
146+
secp256k1_scalar_t rn, u1, u2;
147+
secp256k1_gej_t qj;
148+
134149
if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s))
135150
return 0;
136151

137-
unsigned char brx[32];
138152
secp256k1_scalar_get_b32(brx, &sig->r);
139-
secp256k1_fe_t fx;
140153
VERIFY_CHECK(secp256k1_fe_set_b32(&fx, brx)); /* brx comes from a scalar, so is less than the order; certainly less than p */
141154
if (recid & 2) {
142155
if (secp256k1_fe_cmp_var(&fx, &secp256k1_ecdsa_const_p_minus_order) >= 0)
143156
return 0;
144157
secp256k1_fe_add(&fx, &secp256k1_ecdsa_const_order_as_fe);
145158
}
146-
secp256k1_ge_t x;
147159
if (!secp256k1_ge_set_xo_var(&x, &fx, recid & 1))
148160
return 0;
149-
secp256k1_gej_t xj;
150161
secp256k1_gej_set_ge(&xj, &x);
151-
secp256k1_scalar_t rn, u1, u2;
152162
secp256k1_scalar_inverse_var(&rn, &sig->r);
153163
secp256k1_scalar_mul(&u1, &rn, message);
154164
secp256k1_scalar_negate(&u1, &u1);
155165
secp256k1_scalar_mul(&u2, &rn, &sig->s);
156-
secp256k1_gej_t qj;
157166
secp256k1_ecmult(&qj, &xj, &u2, &u1);
158167
secp256k1_ge_set_gej_var(pubkey, &qj);
159168
return !secp256k1_gej_is_infinity(&qj);
160169
}
161170

162171
static int secp256k1_ecdsa_sig_sign(secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid) {
172+
unsigned char b[32];
163173
secp256k1_gej_t rp;
164-
secp256k1_ecmult_gen(&rp, nonce);
165174
secp256k1_ge_t r;
175+
secp256k1_scalar_t n;
176+
int overflow = 0;
177+
178+
secp256k1_ecmult_gen(&rp, nonce);
166179
secp256k1_ge_set_gej(&r, &rp);
167-
unsigned char b[32];
168180
secp256k1_fe_normalize(&r.x);
169181
secp256k1_fe_normalize(&r.y);
170182
secp256k1_fe_get_b32(b, &r.x);
171-
int overflow = 0;
172183
secp256k1_scalar_set_b32(&sig->r, b, &overflow);
173184
if (secp256k1_scalar_is_zero(&sig->r)) {
174185
/* P.x = order is on the curve, so technically sig->r could end up zero, which would be an invalid signature. */
@@ -178,7 +189,6 @@ static int secp256k1_ecdsa_sig_sign(secp256k1_ecdsa_sig_t *sig, const secp256k1_
178189
}
179190
if (recid)
180191
*recid = (overflow ? 2 : 0) | (secp256k1_fe_is_odd(&r.y) ? 1 : 0);
181-
secp256k1_scalar_t n;
182192
secp256k1_scalar_mul(&n, &sig->r, seckey);
183193
secp256k1_scalar_add(&n, &n, message);
184194
secp256k1_scalar_inverse(&sig->s, nonce);

‎src/eckey_impl.h‎

Lines changed: 9 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,16 @@ static int secp256k1_eckey_pubkey_serialize(secp256k1_ge_t *elem, unsigned char
5151
}
5252

5353
static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned char *privkey, int privkeylen) {
54+
unsigned char c[32] = {0};
5455
const unsigned char *end = privkey + privkeylen;
56+
int lenb = 0;
57+
int len = 0;
58+
int overflow = 0;
5559
/* sequence header */
5660
if (end < privkey+1 || *privkey != 0x30)
5761
return 0;
5862
privkey++;
5963
/* sequence length constructor */
60-
int lenb = 0;
6164
if (end < privkey+1 || !(*privkey & 0x80))
6265
return 0;
6366
lenb = *privkey & ~0x80; privkey++;
@@ -66,7 +69,6 @@ static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned
6669
if (end < privkey+lenb)
6770
return 0;
6871
/* sequence length */
69-
int len = 0;
7072
len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0);
7173
privkey += lenb;
7274
if (end < privkey+len)
@@ -78,8 +80,6 @@ static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned
7880
/* sequence element 1: octet string, up to 32 bytes */
7981
if (end < privkey+2 || privkey[0] != 0x04 || privkey[1] > 0x20 || end < privkey+2+privkey[1])
8082
return 0;
81-
int overflow = 0;
82-
unsigned char c[32] = {0};
8383
memcpy(c + 32 - privkey[1], privkey + 2, privkey[1]);
8484
secp256k1_scalar_set_b32(key, c, &overflow);
8585
memset(c, 0, 32);
@@ -88,8 +88,9 @@ static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned
8888

8989
static int secp256k1_eckey_privkey_serialize(unsigned char *privkey, int *privkeylen, const secp256k1_scalar_t *key, int compressed) {
9090
secp256k1_gej_t rp;
91-
secp256k1_ecmult_gen(&rp, key);
9291
secp256k1_ge_t r;
92+
int pubkeylen = 0;
93+
secp256k1_ecmult_gen(&rp, key);
9394
secp256k1_ge_set_gej(&r, &rp);
9495
if (compressed) {
9596
static const unsigned char begin[] = {
@@ -110,7 +111,6 @@ static int secp256k1_eckey_privkey_serialize(unsigned char *privkey, int *privke
110111
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
111112
secp256k1_scalar_get_b32(ptr, key); ptr += 32;
112113
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
113-
int pubkeylen = 0;
114114
if (!secp256k1_eckey_pubkey_serialize(&r, ptr, &pubkeylen, 1)) {
115115
return 0;
116116
}
@@ -137,7 +137,6 @@ static int secp256k1_eckey_privkey_serialize(unsigned char *privkey, int *privke
137137
memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
138138
secp256k1_scalar_get_b32(ptr, key); ptr += 32;
139139
memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
140-
int pubkeylen = 0;
141140
if (!secp256k1_eckey_pubkey_serialize(&r, ptr, &pubkeylen, 0)) {
142141
return 0;
143142
}
@@ -156,8 +155,8 @@ static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar_t *key, const secp
156155

157156
static int secp256k1_eckey_pubkey_tweak_add(secp256k1_ge_t *key, const secp256k1_scalar_t *tweak) {
158157
secp256k1_gej_t pt;
159-
secp256k1_gej_set_ge(&pt, key);
160158
secp256k1_scalar_t one;
159+
secp256k1_gej_set_ge(&pt, key);
161160
secp256k1_scalar_set_int(&one, 1);
162161
secp256k1_ecmult(&pt, &pt, &one, tweak);
163162

@@ -176,12 +175,12 @@ static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar_t *key, const secp
176175
}
177176

178177
static int secp256k1_eckey_pubkey_tweak_mul(secp256k1_ge_t *key, const secp256k1_scalar_t *tweak) {
178+
secp256k1_scalar_t zero;
179+
secp256k1_gej_t pt;
179180
if (secp256k1_scalar_is_zero(tweak))
180181
return 0;
181182

182-
secp256k1_scalar_t zero;
183183
secp256k1_scalar_set_int(&zero, 0);
184-
secp256k1_gej_t pt;
185184
secp256k1_gej_set_ge(&pt, key);
186185
secp256k1_ecmult(&pt, &pt, tweak, &zero);
187186
secp256k1_ge_set_gej(key, &pt);

‎src/hash_impl.h‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -174,6 +174,7 @@ static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *o
174174
}
175175

176176
static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t keylen) {
177+
int n;
177178
unsigned char rkey[64];
178179
if (keylen <= 64) {
179180
memcpy(rkey, key, keylen);
@@ -187,12 +188,12 @@ static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, cons
187188
}
188189

189190
secp256k1_sha256_initialize(&hash->outer);
190-
for (int n = 0; n < 64; n++)
191+
for (n = 0; n < 64; n++)
191192
rkey[n] ^= 0x5c;
192193
secp256k1_sha256_write(&hash->outer, rkey, 64);
193194

194195
secp256k1_sha256_initialize(&hash->inner);
195-
for (int n = 0; n < 64; n++)
196+
for (n = 0; n < 64; n++)
196197
rkey[n] ^= 0x5c ^ 0x36;
197198
secp256k1_sha256_write(&hash->inner, rkey, 64);
198199
memset(rkey, 0, 64);
@@ -212,13 +213,13 @@ static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsign
212213

213214

214215
static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen, const unsigned char *msg, size_t msglen) {
216+
secp256k1_hmac_sha256_t hmac;
215217
static const unsigned char zero[1] = {0x00};
216218
static const unsigned char one[1] = {0x01};
217219

218220
memset(rng->v, 0x01, 32);
219221
memset(rng->k, 0x00, 32);
220222

221-
secp256k1_hmac_sha256_t hmac;
222223
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
223224
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
224225
secp256k1_hmac_sha256_write(&hmac, zero, 1);
@@ -256,10 +257,10 @@ static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256
256257

257258
while (outlen > 0) {
258259
secp256k1_hmac_sha256_t hmac;
260+
int now = outlen;
259261
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
260262
secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
261263
secp256k1_hmac_sha256_finalize(&hmac, rng->v);
262-
int now = outlen;
263264
if (now > 32) {
264265
now = 32;
265266
}

‎src/num_gmp_impl.h‎

Lines changed: 17 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -29,10 +29,10 @@ static void secp256k1_num_copy(secp256k1_num_t *r, const secp256k1_num_t *a) {
2929
static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num_t *a) {
3030
unsigned char tmp[65];
3131
int len = 0;
32+
int shift = 0;
3233
if (a->limbs>1 || a->data[0] != 0) {
3334
len = mpn_get_str(tmp, 256, (mp_limb_t*)a->data, a->limbs);
3435
}
35-
int shift = 0;
3636
while (shift < len && tmp[shift] == 0) shift++;
3737
VERIFY_CHECK(len-shift <= (int)rlen);
3838
memset(r, 0, rlen - len + shift);
@@ -43,9 +43,10 @@ static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const sec
4343
}
4444

4545
static void secp256k1_num_set_bin(secp256k1_num_t *r, const unsigned char *a, unsigned int alen) {
46+
int len;
4647
VERIFY_CHECK(alen > 0);
4748
VERIFY_CHECK(alen <= 64);
48-
int len = mpn_set_str(r->data, a, alen, 256);
49+
len = mpn_set_str(r->data, a, alen, 256);
4950
if (len == 0) {
5051
r->data[0] = 0;
5152
len = 1;
@@ -91,6 +92,12 @@ static void secp256k1_num_mod(secp256k1_num_t *r, const secp256k1_num_t *m) {
9192
}
9293

9394
static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *m) {
95+
int i;
96+
mp_limb_t g[NUM_LIMBS+1];
97+
mp_limb_t u[NUM_LIMBS+1];
98+
mp_limb_t v[NUM_LIMBS+1];
99+
mp_size_t sn;
100+
mp_size_t gn;
94101
secp256k1_num_sanity(a);
95102
secp256k1_num_sanity(m);
96103

@@ -106,15 +113,12 @@ static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t
106113
*/
107114
VERIFY_CHECK(m->limbs <= NUM_LIMBS);
108115
VERIFY_CHECK(m->data[m->limbs-1] != 0);
109-
mp_limb_t g[NUM_LIMBS+1];
110-
mp_limb_t u[NUM_LIMBS+1];
111-
mp_limb_t v[NUM_LIMBS+1];
112-
for (int i=0; i < m->limbs; i++) {
116+
for (i = 0; i < m->limbs; i++) {
113117
u[i] = (i < a->limbs) ? a->data[i] : 0;
114118
v[i] = m->data[i];
115119
}
116-
mp_size_t sn = NUM_LIMBS+1;
117-
mp_size_t gn = mpn_gcdext(g, r->data, &sn, u, m->limbs, v, m->limbs);
120+
sn = NUM_LIMBS+1;
121+
gn = mpn_gcdext(g, r->data, &sn, u, m->limbs, v, m->limbs);
118122
VERIFY_CHECK(gn == 1);
119123
VERIFY_CHECK(g[0] == 1);
120124
r->neg = a->neg ^ m->neg;
@@ -183,10 +187,10 @@ static void secp256k1_num_sub(secp256k1_num_t *r, const secp256k1_num_t *a, cons
183187
}
184188

185189
static void secp256k1_num_mul(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
190+
mp_limb_t tmp[2*NUM_LIMBS+1];
186191
secp256k1_num_sanity(a);
187192
secp256k1_num_sanity(b);
188193

189-
mp_limb_t tmp[2*NUM_LIMBS+1];
190194
VERIFY_CHECK(a->limbs + b->limbs <= 2*NUM_LIMBS+1);
191195
if ((a->limbs==1 && a->data[0]==0) || (b->limbs==1 && b->data[0]==0)) {
192196
r->limbs = 1;
@@ -207,13 +211,14 @@ static void secp256k1_num_mul(secp256k1_num_t *r, const secp256k1_num_t *a, cons
207211
}
208212

209213
static void secp256k1_num_shift(secp256k1_num_t *r, int bits) {
214+
int i;
210215
if (bits % GMP_NUMB_BITS) {
211-
// Shift within limbs.
216+
/* Shift within limbs. */
212217
mpn_rshift(r->data, r->data, r->limbs, bits % GMP_NUMB_BITS);
213218
}
214219
if (bits >= GMP_NUMB_BITS) {
215-
// Shift full limbs.
216-
for (int i = 0; i < r->limbs; i++) {
220+
/* Shift full limbs. */
221+
for (i = 0; i < r->limbs; i++) {
217222
int index = i + (bits / GMP_NUMB_BITS);
218223
if (index < r->limbs && index < 2*NUM_LIMBS) {
219224
r->data[i] = r->data[index];

‎src/testrand_impl.h‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,8 @@ SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
3333
}
3434

3535
static void secp256k1_rand256(unsigned char *b32) {
36-
for (int i=0; i<8; i++) {
36+
int i;
37+
for (i = 0; i < 8; i++) {
3738
uint32_t r = secp256k1_rand32();
3839
b32[i*4 + 0] = (r >> 0) & 0xFF;
3940
b32[i*4 + 1] = (r >> 8) & 0xFF;

0 commit comments

Comments
 (0)