status-im
/
secp256k1
mirror of https://github.com/status-im/secp256k1.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Get rid of reserved _t in type names

This commit is contained in:
Pieter Wuille 2017-09-27 15:01:26 -07:00
parent 0b70241850
commit d1dc9dfc0a
12 changed files with 79 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/bench_ecdh.c
View File

@ -15,11 +15,11 @@ typedef struct {
secp256k1_context *ctx; secp256k1_context *ctx;
secp256k1_pubkey point; secp256k1_pubkey point;
unsigned char scalar[32]; unsigned char scalar[32];
} bench_ecdh_t; } bench_ecdh;
static void bench_ecdh_setup(void* arg) { static void bench_ecdh_setup(void* arg) {
int i; int i;
bench_ecdh_t *data = (bench_ecdh_t*)arg; bench_ecdh *data = (bench_ecdh*)arg;
const unsigned char point[] = { const unsigned char point[] = {
0x03, 0x03,
0x54, 0x94, 0xc1, 0x5d, 0x32, 0x09, 0x97, 0x06, 0x54, 0x94, 0xc1, 0x5d, 0x32, 0x09, 0x97, 0x06,
@ -39,7 +39,7 @@ static void bench_ecdh_setup(void* arg) {
static void bench_ecdh(void* arg) { static void bench_ecdh(void* arg) {
int i; int i;
unsigned char res[32]; unsigned char res[32];
bench_ecdh_t *data = (bench_ecdh_t*)arg; bench_ecdh *data = (bench_ecdh*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
CHECK(secp256k1_ecdh(data->ctx, res, &data->point, data->scalar) == 1); CHECK(secp256k1_ecdh(data->ctx, res, &data->point, data->scalar) == 1);
@ -47,7 +47,7 @@ static void bench_ecdh(void* arg) {
} }
int main(void) { int main(void) {
bench_ecdh_t data; bench_ecdh data;
run_benchmark("ecdh", bench_ecdh, bench_ecdh_setup, NULL, &data, 10, 20000); run_benchmark("ecdh", bench_ecdh, bench_ecdh_setup, NULL, &data, 10, 20000);
return 0; return 0;

62
src/bench_internal.c
View File

@ -25,10 +25,10 @@ typedef struct {
secp256k1_gej gej_x, gej_y; secp256k1_gej gej_x, gej_y;
unsigned char data[64]; unsigned char data[64];
int wnaf[256]; int wnaf[256];
} bench_inv_t; } bench_inv;
void bench_setup(void* arg) { void bench_setup(void* arg) {
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
static const unsigned char init_x[32] = { static const unsigned char init_x[32] = {
0x02, 0x03, 0x05, 0x07, 0x0b, 0x0d, 0x11, 0x13, 0x02, 0x03, 0x05, 0x07, 0x0b, 0x0d, 0x11, 0x13,
@ -58,7 +58,7 @@ void bench_setup(void* arg) {
void bench_scalar_add(void* arg) { void bench_scalar_add(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 2000000; i++) { for (i = 0; i < 2000000; i++) {
secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y); secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
@ -67,7 +67,7 @@ void bench_scalar_add(void* arg) {
void bench_scalar_negate(void* arg) { void bench_scalar_negate(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 2000000; i++) { for (i = 0; i < 2000000; i++) {
secp256k1_scalar_negate(&data->scalar_x, &data->scalar_x); secp256k1_scalar_negate(&data->scalar_x, &data->scalar_x);
@ -76,7 +76,7 @@ void bench_scalar_negate(void* arg) {
void bench_scalar_sqr(void* arg) { void bench_scalar_sqr(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_scalar_sqr(&data->scalar_x, &data->scalar_x); secp256k1_scalar_sqr(&data->scalar_x, &data->scalar_x);
@ -85,7 +85,7 @@ void bench_scalar_sqr(void* arg) {
void bench_scalar_mul(void* arg) { void bench_scalar_mul(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_scalar_mul(&data->scalar_x, &data->scalar_x, &data->scalar_y); secp256k1_scalar_mul(&data->scalar_x, &data->scalar_x, &data->scalar_y);
@ -95,7 +95,7 @@ void bench_scalar_mul(void* arg) {
#ifdef USE_ENDOMORPHISM #ifdef USE_ENDOMORPHISM
void bench_scalar_split(void* arg) { void bench_scalar_split(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_scalar l, r; secp256k1_scalar l, r;
@ -107,7 +107,7 @@ void bench_scalar_split(void* arg) {
void bench_scalar_inverse(void* arg) { void bench_scalar_inverse(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 2000; i++) { for (i = 0; i < 2000; i++) {
secp256k1_scalar_inverse(&data->scalar_x, &data->scalar_x); secp256k1_scalar_inverse(&data->scalar_x, &data->scalar_x);
@ -117,7 +117,7 @@ void bench_scalar_inverse(void* arg) {
void bench_scalar_inverse_var(void* arg) { void bench_scalar_inverse_var(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 2000; i++) { for (i = 0; i < 2000; i++) {
secp256k1_scalar_inverse_var(&data->scalar_x, &data->scalar_x); secp256k1_scalar_inverse_var(&data->scalar_x, &data->scalar_x);
@ -127,7 +127,7 @@ void bench_scalar_inverse_var(void* arg) {
void bench_field_normalize(void* arg) { void bench_field_normalize(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 2000000; i++) { for (i = 0; i < 2000000; i++) {
secp256k1_fe_normalize(&data->fe_x); secp256k1_fe_normalize(&data->fe_x);
@ -136,7 +136,7 @@ void bench_field_normalize(void* arg) {
void bench_field_normalize_weak(void* arg) { void bench_field_normalize_weak(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 2000000; i++) { for (i = 0; i < 2000000; i++) {
secp256k1_fe_normalize_weak(&data->fe_x); secp256k1_fe_normalize_weak(&data->fe_x);
@ -145,7 +145,7 @@ void bench_field_normalize_weak(void* arg) {
void bench_field_mul(void* arg) { void bench_field_mul(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_fe_mul(&data->fe_x, &data->fe_x, &data->fe_y); secp256k1_fe_mul(&data->fe_x, &data->fe_x, &data->fe_y);
@ -154,7 +154,7 @@ void bench_field_mul(void* arg) {
void bench_field_sqr(void* arg) { void bench_field_sqr(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_fe_sqr(&data->fe_x, &data->fe_x); secp256k1_fe_sqr(&data->fe_x, &data->fe_x);
@ -163,7 +163,7 @@ void bench_field_sqr(void* arg) {
void bench_field_inverse(void* arg) { void bench_field_inverse(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_fe_inv(&data->fe_x, &data->fe_x); secp256k1_fe_inv(&data->fe_x, &data->fe_x);
@ -173,7 +173,7 @@ void bench_field_inverse(void* arg) {
void bench_field_inverse_var(void* arg) { void bench_field_inverse_var(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_fe_inv_var(&data->fe_x, &data->fe_x); secp256k1_fe_inv_var(&data->fe_x, &data->fe_x);
@ -183,7 +183,7 @@ void bench_field_inverse_var(void* arg) {
void bench_field_sqrt(void* arg) { void bench_field_sqrt(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_fe_sqrt(&data->fe_x, &data->fe_x); secp256k1_fe_sqrt(&data->fe_x, &data->fe_x);
@ -193,7 +193,7 @@ void bench_field_sqrt(void* arg) {
void bench_group_double_var(void* arg) { void bench_group_double_var(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_gej_double_var(&data->gej_x, &data->gej_x, NULL); secp256k1_gej_double_var(&data->gej_x, &data->gej_x, NULL);
@ -202,7 +202,7 @@ void bench_group_double_var(void* arg) {
void bench_group_add_var(void* arg) { void bench_group_add_var(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y, NULL); secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y, NULL);
@ -211,7 +211,7 @@ void bench_group_add_var(void* arg) {
void bench_group_add_affine(void* arg) { void bench_group_add_affine(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_gej_add_ge(&data->gej_x, &data->gej_x, &data->ge_y); secp256k1_gej_add_ge(&data->gej_x, &data->gej_x, &data->ge_y);
@ -220,7 +220,7 @@ void bench_group_add_affine(void* arg) {
void bench_group_add_affine_var(void* arg) { void bench_group_add_affine_var(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 200000; i++) { for (i = 0; i < 200000; i++) {
secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y, NULL); secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y, NULL);
@ -229,7 +229,7 @@ void bench_group_add_affine_var(void* arg) {
void bench_group_jacobi_var(void* arg) { void bench_group_jacobi_var(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_gej_has_quad_y_var(&data->gej_x); secp256k1_gej_has_quad_y_var(&data->gej_x);
@ -238,7 +238,7 @@ void bench_group_jacobi_var(void* arg) {
void bench_ecmult_wnaf(void* arg) { void bench_ecmult_wnaf(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A); secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A);
@ -248,7 +248,7 @@ void bench_ecmult_wnaf(void* arg) {
void bench_wnaf_const(void* arg) { void bench_wnaf_const(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_wnaf_const(data->wnaf, data->scalar_x, WINDOW_A); secp256k1_wnaf_const(data->wnaf, data->scalar_x, WINDOW_A);
@ -259,8 +259,8 @@ void bench_wnaf_const(void* arg) {
void bench_sha256(void* arg) { void bench_sha256(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
secp256k1_sha256_t sha; secp256k1_sha256 sha;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_sha256_initialize(&sha); secp256k1_sha256_initialize(&sha);
@ -271,8 +271,8 @@ void bench_sha256(void* arg) {
void bench_hmac_sha256(void* arg) { void bench_hmac_sha256(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
secp256k1_hmac_sha256_t hmac; secp256k1_hmac_sha256 hmac;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_hmac_sha256_initialize(&hmac, data->data, 32); secp256k1_hmac_sha256_initialize(&hmac, data->data, 32);
@ -283,8 +283,8 @@ void bench_hmac_sha256(void* arg) {
void bench_rfc6979_hmac_sha256(void* arg) { void bench_rfc6979_hmac_sha256(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
secp256k1_rfc6979_hmac_sha256_t rng; secp256k1_rfc6979_hmac_sha256 rng;
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 64); secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 64);
@ -311,7 +311,7 @@ void bench_context_sign(void* arg) {
#ifndef USE_NUM_NONE #ifndef USE_NUM_NONE
void bench_num_jacobi(void* arg) { void bench_num_jacobi(void* arg) {
int i; int i;
bench_inv_t *data = (bench_inv_t*)arg; bench_inv *data = (bench_inv*)arg;
secp256k1_num nx, norder; secp256k1_num nx, norder;
secp256k1_scalar_get_num(&nx, &data->scalar_x); secp256k1_scalar_get_num(&nx, &data->scalar_x);
@ -340,7 +340,7 @@ int have_flag(int argc, char** argv, char *flag) {
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
bench_inv_t data; bench_inv data;
if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "add")) run_benchmark("scalar_add", bench_scalar_add, bench_setup, NULL, &data, 10, 2000000); if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "add")) run_benchmark("scalar_add", bench_scalar_add, bench_setup, NULL, &data, 10, 2000000);
if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "negate")) run_benchmark("scalar_negate", bench_scalar_negate, bench_setup, NULL, &data, 10, 2000000); if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "negate")) run_benchmark("scalar_negate", bench_scalar_negate, bench_setup, NULL, &data, 10, 2000000);
if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "sqr")) run_benchmark("scalar_sqr", bench_scalar_sqr, bench_setup, NULL, &data, 10, 200000); if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "sqr")) run_benchmark("scalar_sqr", bench_scalar_sqr, bench_setup, NULL, &data, 10, 200000);

8
src/bench_recover.c
View File

@ -13,11 +13,11 @@ typedef struct {
secp256k1_context *ctx; secp256k1_context *ctx;
unsigned char msg[32]; unsigned char msg[32];
unsigned char sig[64]; unsigned char sig[64];
} bench_recover_t; } bench_recover;
void bench_recover(void* arg) { void bench_recover(void* arg) {
int i; int i;
bench_recover_t *data = (bench_recover_t*)arg; bench_recover *data = (bench_recover*)arg;
secp256k1_pubkey pubkey; secp256k1_pubkey pubkey;
unsigned char pubkeyc[33]; unsigned char pubkeyc[33];
@ -38,7 +38,7 @@ void bench_recover(void* arg) {
void bench_recover_setup(void* arg) { void bench_recover_setup(void* arg) {
int i; int i;
bench_recover_t *data = (bench_recover_t*)arg; bench_recover *data = (bench_recover*)arg;
for (i = 0; i < 32; i++) { for (i = 0; i < 32; i++) {
data->msg[i] = 1 + i; data->msg[i] = 1 + i;
@ -49,7 +49,7 @@ void bench_recover_setup(void* arg) {
} }
int main(void) { int main(void) {
bench_recover_t data; bench_recover data;
data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY); data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);

12
src/bench_sign.c
View File

@ -12,11 +12,11 @@ typedef struct {
secp256k1_context* ctx; secp256k1_context* ctx;
unsigned char msg[32]; unsigned char msg[32];
unsigned char key[32]; unsigned char key[32];
} bench_sign_t; } bench_sign;
static void bench_sign_setup(void* arg) { static void bench_sign_setup(void* arg) {
int i; int i;
bench_sign_t *data = (bench_sign_t*)arg; bench_sign *data = (bench_sign*)arg;
for (i = 0; i < 32; i++) { for (i = 0; i < 32; i++) {
data->msg[i] = i + 1; data->msg[i] = i + 1;
@ -26,9 +26,9 @@ static void bench_sign_setup(void* arg) {
} }
} }
static void bench_sign(void* arg) { static void bench_sign_run(void* arg) {
int i; int i;
bench_sign_t *data = (bench_sign_t*)arg; bench_sign *data = (bench_sign*)arg;
unsigned char sig[74]; unsigned char sig[74];
for (i = 0; i < 20000; i++) { for (i = 0; i < 20000; i++) {
@ -45,11 +45,11 @@ static void bench_sign(void* arg) {
} }
int main(void) { int main(void) {
bench_sign_t data; bench_sign data;
data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN); data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
run_benchmark("ecdsa_sign", bench_sign, bench_sign_setup, NULL, &data, 10, 20000); run_benchmark("ecdsa_sign", bench_sign_run, bench_sign_setup, NULL, &data, 10, 20000);
secp256k1_context_destroy(data.ctx); secp256k1_context_destroy(data.ctx);
return 0; return 0;

2
src/ecmult_gen_impl.h
View File

@ -161,7 +161,7 @@ static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const
secp256k1_gej gb; secp256k1_gej gb;
secp256k1_fe s; secp256k1_fe s;
unsigned char nonce32[32]; unsigned char nonce32[32];
secp256k1_rfc6979_hmac_sha256_t rng; secp256k1_rfc6979_hmac_sha256 rng;
int retry; int retry;
unsigned char keydata[64] = {0}; unsigned char keydata[64] = {0};
if (seed32 == NULL) { if (seed32 == NULL) {

26
src/hash.h
View File

@ -14,28 +14,28 @@ typedef struct {
uint32_t s[8]; uint32_t s[8];
uint32_t buf[16]; /* In big endian */ uint32_t buf[16]; /* In big endian */
size_t bytes; size_t bytes;
} secp256k1_sha256_t; } secp256k1_sha256;
static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash); static void secp256k1_sha256_initialize(secp256k1_sha256 *hash);
static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char *data, size_t size); static void secp256k1_sha256_write(secp256k1_sha256 *hash, const unsigned char *data, size_t size);
static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *out32); static void secp256k1_sha256_finalize(secp256k1_sha256 *hash, unsigned char *out32);
typedef struct { typedef struct {
secp256k1_sha256_t inner, outer; secp256k1_sha256 inner, outer;
} secp256k1_hmac_sha256_t; } secp256k1_hmac_sha256;
static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t size); static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256 *hash, const unsigned char *key, size_t size);
static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, const unsigned char *data, size_t size); static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256 *hash, const unsigned char *data, size_t size);
static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsigned char *out32); static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256 *hash, unsigned char *out32);
typedef struct { typedef struct {
unsigned char v[32]; unsigned char v[32];
unsigned char k[32]; unsigned char k[32];
int retry; int retry;
} secp256k1_rfc6979_hmac_sha256_t; } secp256k1_rfc6979_hmac_sha256;
static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen); static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256 *rng, const unsigned char *key, size_t keylen);
static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen); static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256 *rng, unsigned char *out, size_t outlen);
static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng); static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256 *rng);
#endif /* SECP256K1_HASH_H */ #endif /* SECP256K1_HASH_H */

26
src/hash_impl.h
View File

@ -33,7 +33,7 @@
#define BE32(p) ((((p) & 0xFF) << 24) | (((p) & 0xFF00) << 8) | (((p) & 0xFF0000) >> 8) | (((p) & 0xFF000000) >> 24)) #define BE32(p) ((((p) & 0xFF) << 24) | (((p) & 0xFF00) << 8) | (((p) & 0xFF0000) >> 8) | (((p) & 0xFF000000) >> 24))
#endif #endif
static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash) { static void secp256k1_sha256_initialize(secp256k1_sha256 *hash) {
hash->s[0] = 0x6a09e667ul; hash->s[0] = 0x6a09e667ul;
hash->s[1] = 0xbb67ae85ul; hash->s[1] = 0xbb67ae85ul;
hash->s[2] = 0x3c6ef372ul; hash->s[2] = 0x3c6ef372ul;
@ -128,7 +128,7 @@ static void secp256k1_sha256_transform(uint32_t* s, const uint32_t* chunk) {
s[7] += h; s[7] += h;
} }
static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char *data, size_t len) { static void secp256k1_sha256_write(secp256k1_sha256 *hash, const unsigned char *data, size_t len) {
size_t bufsize = hash->bytes & 0x3F; size_t bufsize = hash->bytes & 0x3F;
hash->bytes += len; hash->bytes += len;
while (bufsize + len >= 64) { while (bufsize + len >= 64) {
@ -145,7 +145,7 @@ static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char
} }
} }
static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *out32) { static void secp256k1_sha256_finalize(secp256k1_sha256 *hash, unsigned char *out32) {
static const unsigned char pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; static const unsigned char pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint32_t sizedesc[2]; uint32_t sizedesc[2];
uint32_t out[8]; uint32_t out[8];
@ -161,14 +161,14 @@ static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *o
memcpy(out32, (const unsigned char*)out, 32); memcpy(out32, (const unsigned char*)out, 32);
} }
static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t keylen) { static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256 *hash, const unsigned char *key, size_t keylen) {
int n; int n;
unsigned char rkey[64]; unsigned char rkey[64];
if (keylen <= 64) { if (keylen <= 64) {
memcpy(rkey, key, keylen); memcpy(rkey, key, keylen);
memset(rkey + keylen, 0, 64 - keylen); memset(rkey + keylen, 0, 64 - keylen);
} else { } else {
secp256k1_sha256_t sha256; secp256k1_sha256 sha256;
secp256k1_sha256_initialize(&sha256); secp256k1_sha256_initialize(&sha256);
secp256k1_sha256_write(&sha256, key, keylen); secp256k1_sha256_write(&sha256, key, keylen);
secp256k1_sha256_finalize(&sha256, rkey); secp256k1_sha256_finalize(&sha256, rkey);
@ -189,11 +189,11 @@ static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, cons
memset(rkey, 0, 64); memset(rkey, 0, 64);
} }
static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, const unsigned char *data, size_t size) { static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256 *hash, const unsigned char *data, size_t size) {
secp256k1_sha256_write(&hash->inner, data, size); secp256k1_sha256_write(&hash->inner, data, size);
} }
static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsigned char *out32) { static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256 *hash, unsigned char *out32) {
unsigned char temp[32]; unsigned char temp[32];
secp256k1_sha256_finalize(&hash->inner, temp); secp256k1_sha256_finalize(&hash->inner, temp);
secp256k1_sha256_write(&hash->outer, temp, 32); secp256k1_sha256_write(&hash->outer, temp, 32);
@ -202,8 +202,8 @@ static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsign
} }
static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen) { static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256 *rng, const unsigned char *key, size_t keylen) {
secp256k1_hmac_sha256_t hmac; secp256k1_hmac_sha256 hmac;
static const unsigned char zero[1] = {0x00}; static const unsigned char zero[1] = {0x00};
static const unsigned char one[1] = {0x01}; static const unsigned char one[1] = {0x01};
@ -232,11 +232,11 @@ static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha2
rng->retry = 0; rng->retry = 0;
} }
static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen) { static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256 *rng, unsigned char *out, size_t outlen) {
/* RFC6979 3.2.h. */ /* RFC6979 3.2.h. */
static const unsigned char zero[1] = {0x00}; static const unsigned char zero[1] = {0x00};
if (rng->retry) { if (rng->retry) {
secp256k1_hmac_sha256_t hmac; secp256k1_hmac_sha256 hmac;
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32); secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
secp256k1_hmac_sha256_write(&hmac, rng->v, 32); secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
secp256k1_hmac_sha256_write(&hmac, zero, 1); secp256k1_hmac_sha256_write(&hmac, zero, 1);
@ -247,7 +247,7 @@ static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256
} }
while (outlen > 0) { while (outlen > 0) {
secp256k1_hmac_sha256_t hmac; secp256k1_hmac_sha256 hmac;
int now = outlen; int now = outlen;
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32); secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
secp256k1_hmac_sha256_write(&hmac, rng->v, 32); secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
@ -263,7 +263,7 @@ static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256
rng->retry = 1; rng->retry = 1;
} }
static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng) { static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256 *rng) {
memset(rng->k, 0, 32); memset(rng->k, 0, 32);
memset(rng->v, 0, 32); memset(rng->v, 0, 32);
rng->retry = 0; rng->retry = 0;

2
src/modules/ecdh/main_impl.h
View File

@ -28,7 +28,7 @@ int secp256k1_ecdh(const secp256k1_context* ctx, unsigned char *result, const se
} else { } else {
unsigned char x[32]; unsigned char x[32];
unsigned char y[1]; unsigned char y[1];
secp256k1_sha256_t sha; secp256k1_sha256 sha;
secp256k1_ecmult_const(&res, &pt, &s); secp256k1_ecmult_const(&res, &pt, &s);
secp256k1_ge_set_gej(&pt, &res); secp256k1_ge_set_gej(&pt, &res);

2
src/modules/ecdh/tests_impl.h
View File

@ -44,7 +44,7 @@ void test_ecdh_generator_basepoint(void) {
s_one[31] = 1; s_one[31] = 1;
/* Check against pubkey creation when the basepoint is the generator */ /* Check against pubkey creation when the basepoint is the generator */
for (i = 0; i < 100; ++i) { for (i = 0; i < 100; ++i) {
secp256k1_sha256_t sha; secp256k1_sha256 sha;
unsigned char s_b32[32]; unsigned char s_b32[32];
unsigned char output_ecdh[32]; unsigned char output_ecdh[32];
unsigned char output_ser[32]; unsigned char output_ser[32];

2
src/secp256k1.c
View File

@ -310,7 +310,7 @@ int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_s
static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) { static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
unsigned char keydata[112]; unsigned char keydata[112];
int keylen = 64; int keylen = 64;
secp256k1_rfc6979_hmac_sha256_t rng; secp256k1_rfc6979_hmac_sha256 rng;
unsigned int i; unsigned int i;
/* We feed a byte array to the PRNG as input, consisting of: /* We feed a byte array to the PRNG as input, consisting of:
* - the private key (32 bytes) and message (32 bytes), see RFC 6979 3.2d. * - the private key (32 bytes) and message (32 bytes), see RFC 6979 3.2d.

2
src/testrand_impl.h
View File

@ -13,7 +13,7 @@
#include "testrand.h" #include "testrand.h"
#include "hash.h" #include "hash.h"
static secp256k1_rfc6979_hmac_sha256_t secp256k1_test_rng; static secp256k1_rfc6979_hmac_sha256 secp256k1_test_rng;
static uint32_t secp256k1_test_rng_precomputed[8]; static uint32_t secp256k1_test_rng_precomputed[8];
static int secp256k1_test_rng_precomputed_used = 8; static int secp256k1_test_rng_precomputed_used = 8;
static uint64_t secp256k1_test_rng_integer; static uint64_t secp256k1_test_rng_integer;

6
src/tests.c
View File

@ -270,7 +270,7 @@ void run_sha256_tests(void) {
int i; int i;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
unsigned char out[32]; unsigned char out[32];
secp256k1_sha256_t hasher; secp256k1_sha256 hasher;
secp256k1_sha256_initialize(&hasher); secp256k1_sha256_initialize(&hasher);
secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i])); secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
secp256k1_sha256_finalize(&hasher, out); secp256k1_sha256_finalize(&hasher, out);
@ -313,7 +313,7 @@ void run_hmac_sha256_tests(void) {
}; };
int i; int i;
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
secp256k1_hmac_sha256_t hasher; secp256k1_hmac_sha256 hasher;
unsigned char out[32]; unsigned char out[32];
secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i])); secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i]));
secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i])); secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
@ -345,7 +345,7 @@ void run_rfc6979_hmac_sha256_tests(void) {
{0x75, 0x97, 0x88, 0x7c, 0xbd, 0x76, 0x32, 0x1f, 0x32, 0xe3, 0x04, 0x40, 0x67, 0x9a, 0x22, 0xcf, 0x7f, 0x8d, 0x9d, 0x2e, 0xac, 0x39, 0x0e, 0x58, 0x1f, 0xea, 0x09, 0x1c, 0xe2, 0x02, 0xba, 0x94} {0x75, 0x97, 0x88, 0x7c, 0xbd, 0x76, 0x32, 0x1f, 0x32, 0xe3, 0x04, 0x40, 0x67, 0x9a, 0x22, 0xcf, 0x7f, 0x8d, 0x9d, 0x2e, 0xac, 0x39, 0x0e, 0x58, 0x1f, 0xea, 0x09, 0x1c, 0xe2, 0x02, 0xba, 0x94}
}; };
secp256k1_rfc6979_hmac_sha256_t rng; secp256k1_rfc6979_hmac_sha256 rng;
unsigned char out[32]; unsigned char out[32];
int i; int i;