Changeset View
Changeset View
Standalone View
Standalone View
src/secp256k1/src/modules/extrakeys/tests_impl.h
Show All 29 Lines | void test_xonly_pubkey(void) { | ||||
int pk_parity; | int pk_parity; | ||||
int i; | int i; | ||||
int ecount; | int ecount; | ||||
secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | ||||
secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | ||||
secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
memset(ones32, 0xFF, 32); | memset(ones32, 0xFF, 32); | ||||
secp256k1_rand256(xy_sk); | secp256k1_testrand256(xy_sk); | ||||
CHECK(secp256k1_ec_pubkey_create(sign, &pk, sk) == 1); | CHECK(secp256k1_ec_pubkey_create(sign, &pk, sk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &xonly_pk, &pk_parity, &pk) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &xonly_pk, &pk_parity, &pk) == 1); | ||||
/* Test xonly_pubkey_from_pubkey */ | /* Test xonly_pubkey_from_pubkey */ | ||||
ecount = 0; | ecount = 0; | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &xonly_pk, &pk_parity, &pk) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &xonly_pk, &pk_parity, &pk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(sign, &xonly_pk, &pk_parity, &pk) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(sign, &xonly_pk, &pk_parity, &pk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(verify, &xonly_pk, &pk_parity, &pk) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(verify, &xonly_pk, &pk_parity, &pk) == 1); | ||||
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines | void test_xonly_pubkey(void) { | ||||
/* There's no point with x-coordinate 0 on secp256k1 */ | /* There's no point with x-coordinate 0 on secp256k1 */ | ||||
CHECK(secp256k1_xonly_pubkey_parse(none, &xonly_pk, zeros64) == 0); | CHECK(secp256k1_xonly_pubkey_parse(none, &xonly_pk, zeros64) == 0); | ||||
CHECK(memcmp(&xonly_pk, zeros64, sizeof(xonly_pk)) == 0); | CHECK(memcmp(&xonly_pk, zeros64, sizeof(xonly_pk)) == 0); | ||||
/* If a random 32-byte string can not be parsed with ec_pubkey_parse | /* If a random 32-byte string can not be parsed with ec_pubkey_parse | ||||
* (because interpreted as X coordinate it does not correspond to a point on | * (because interpreted as X coordinate it does not correspond to a point on | ||||
* the curve) then xonly_pubkey_parse should fail as well. */ | * the curve) then xonly_pubkey_parse should fail as well. */ | ||||
for (i = 0; i < count; i++) { | for (i = 0; i < count; i++) { | ||||
unsigned char rand33[33]; | unsigned char rand33[33]; | ||||
secp256k1_rand256(&rand33[1]); | secp256k1_testrand256(&rand33[1]); | ||||
rand33[0] = SECP256K1_TAG_PUBKEY_EVEN; | rand33[0] = SECP256K1_TAG_PUBKEY_EVEN; | ||||
if (!secp256k1_ec_pubkey_parse(ctx, &pk, rand33, 33)) { | if (!secp256k1_ec_pubkey_parse(ctx, &pk, rand33, 33)) { | ||||
memset(&xonly_pk, 1, sizeof(xonly_pk)); | memset(&xonly_pk, 1, sizeof(xonly_pk)); | ||||
CHECK(secp256k1_xonly_pubkey_parse(ctx, &xonly_pk, &rand33[1]) == 0); | CHECK(secp256k1_xonly_pubkey_parse(ctx, &xonly_pk, &rand33[1]) == 0); | ||||
CHECK(memcmp(&xonly_pk, zeros64, sizeof(xonly_pk)) == 0); | CHECK(memcmp(&xonly_pk, zeros64, sizeof(xonly_pk)) == 0); | ||||
} else { | } else { | ||||
CHECK(secp256k1_xonly_pubkey_parse(ctx, &xonly_pk, &rand33[1]) == 1); | CHECK(secp256k1_xonly_pubkey_parse(ctx, &xonly_pk, &rand33[1]) == 1); | ||||
} | } | ||||
Show All 17 Lines | void test_xonly_pubkey_tweak(void) { | ||||
int i; | int i; | ||||
int ecount; | int ecount; | ||||
secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | ||||
secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | ||||
secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | ||||
memset(overflows, 0xff, sizeof(overflows)); | memset(overflows, 0xff, sizeof(overflows)); | ||||
secp256k1_rand256(tweak); | secp256k1_testrand256(tweak); | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
CHECK(secp256k1_ec_pubkey_create(ctx, &internal_pk, sk) == 1); | CHECK(secp256k1_ec_pubkey_create(ctx, &internal_pk, sk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &internal_xonly_pk, &pk_parity, &internal_pk) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &internal_xonly_pk, &pk_parity, &internal_pk) == 1); | ||||
ecount = 0; | ecount = 0; | ||||
CHECK(secp256k1_xonly_pubkey_tweak_add(none, &output_pk, &internal_xonly_pk, tweak) == 0); | CHECK(secp256k1_xonly_pubkey_tweak_add(none, &output_pk, &internal_xonly_pk, tweak) == 0); | ||||
CHECK(ecount == 1); | CHECK(ecount == 1); | ||||
CHECK(secp256k1_xonly_pubkey_tweak_add(sign, &output_pk, &internal_xonly_pk, tweak) == 0); | CHECK(secp256k1_xonly_pubkey_tweak_add(sign, &output_pk, &internal_xonly_pk, tweak) == 0); | ||||
CHECK(ecount == 2); | CHECK(ecount == 2); | ||||
Show All 26 Lines | for (i = 0; i < count; i++) { | ||||
secp256k1_scalar_get_b32(tweak, &scalar_tweak); | secp256k1_scalar_get_b32(tweak, &scalar_tweak); | ||||
CHECK((secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, sk) == 0) | CHECK((secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, sk) == 0) | ||||
|| (secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, tweak) == 0)); | || (secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, tweak) == 0)); | ||||
CHECK(memcmp(&output_pk, zeros64, sizeof(output_pk)) == 0); | CHECK(memcmp(&output_pk, zeros64, sizeof(output_pk)) == 0); | ||||
} | } | ||||
/* Invalid pk with a valid tweak */ | /* Invalid pk with a valid tweak */ | ||||
memset(&internal_xonly_pk, 0, sizeof(internal_xonly_pk)); | memset(&internal_xonly_pk, 0, sizeof(internal_xonly_pk)); | ||||
secp256k1_rand256(tweak); | secp256k1_testrand256(tweak); | ||||
ecount = 0; | ecount = 0; | ||||
CHECK(secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, tweak) == 0); | CHECK(secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, tweak) == 0); | ||||
CHECK(ecount == 1); | CHECK(ecount == 1); | ||||
CHECK(memcmp(&output_pk, zeros64, sizeof(output_pk)) == 0); | CHECK(memcmp(&output_pk, zeros64, sizeof(output_pk)) == 0); | ||||
secp256k1_context_destroy(none); | secp256k1_context_destroy(none); | ||||
secp256k1_context_destroy(sign); | secp256k1_context_destroy(sign); | ||||
secp256k1_context_destroy(verify); | secp256k1_context_destroy(verify); | ||||
Show All 13 Lines | void test_xonly_pubkey_tweak_check(void) { | ||||
unsigned char tweak[32]; | unsigned char tweak[32]; | ||||
int ecount; | int ecount; | ||||
secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | ||||
secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | ||||
secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | ||||
memset(overflows, 0xff, sizeof(overflows)); | memset(overflows, 0xff, sizeof(overflows)); | ||||
secp256k1_rand256(tweak); | secp256k1_testrand256(tweak); | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
CHECK(secp256k1_ec_pubkey_create(ctx, &internal_pk, sk) == 1); | CHECK(secp256k1_ec_pubkey_create(ctx, &internal_pk, sk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &internal_xonly_pk, &pk_parity, &internal_pk) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(none, &internal_xonly_pk, &pk_parity, &internal_pk) == 1); | ||||
ecount = 0; | ecount = 0; | ||||
CHECK(secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, tweak) == 1); | CHECK(secp256k1_xonly_pubkey_tweak_add(verify, &output_pk, &internal_xonly_pk, tweak) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(verify, &output_xonly_pk, &pk_parity, &output_pk) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(verify, &output_xonly_pk, &pk_parity, &output_pk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_serialize(ctx, buf32, &output_xonly_pk) == 1); | CHECK(secp256k1_xonly_pubkey_serialize(ctx, buf32, &output_xonly_pk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_tweak_add_check(none, buf32, pk_parity, &internal_xonly_pk, tweak) == 0); | CHECK(secp256k1_xonly_pubkey_tweak_add_check(none, buf32, pk_parity, &internal_xonly_pk, tweak) == 0); | ||||
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines | |||||
#define N_PUBKEYS 32 | #define N_PUBKEYS 32 | ||||
void test_xonly_pubkey_tweak_recursive(void) { | void test_xonly_pubkey_tweak_recursive(void) { | ||||
unsigned char sk[32]; | unsigned char sk[32]; | ||||
secp256k1_pubkey pk[N_PUBKEYS]; | secp256k1_pubkey pk[N_PUBKEYS]; | ||||
unsigned char pk_serialized[32]; | unsigned char pk_serialized[32]; | ||||
unsigned char tweak[N_PUBKEYS - 1][32]; | unsigned char tweak[N_PUBKEYS - 1][32]; | ||||
int i; | int i; | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
CHECK(secp256k1_ec_pubkey_create(ctx, &pk[0], sk) == 1); | CHECK(secp256k1_ec_pubkey_create(ctx, &pk[0], sk) == 1); | ||||
/* Add tweaks */ | /* Add tweaks */ | ||||
for (i = 0; i < N_PUBKEYS - 1; i++) { | for (i = 0; i < N_PUBKEYS - 1; i++) { | ||||
secp256k1_xonly_pubkey xonly_pk; | secp256k1_xonly_pubkey xonly_pk; | ||||
memset(tweak[i], i + 1, sizeof(tweak[i])); | memset(tweak[i], i + 1, sizeof(tweak[i])); | ||||
CHECK(secp256k1_xonly_pubkey_from_pubkey(ctx, &xonly_pk, NULL, &pk[i]) == 1); | CHECK(secp256k1_xonly_pubkey_from_pubkey(ctx, &xonly_pk, NULL, &pk[i]) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_tweak_add(ctx, &pk[i + 1], &xonly_pk, tweak[i]) == 1); | CHECK(secp256k1_xonly_pubkey_tweak_add(ctx, &pk[i + 1], &xonly_pk, tweak[i]) == 1); | ||||
} | } | ||||
Show All 23 Lines | void test_keypair(void) { | ||||
secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | ||||
secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | ||||
CHECK(sizeof(zeros96) == sizeof(keypair)); | CHECK(sizeof(zeros96) == sizeof(keypair)); | ||||
memset(overflows, 0xFF, sizeof(overflows)); | memset(overflows, 0xFF, sizeof(overflows)); | ||||
/* Test keypair_create */ | /* Test keypair_create */ | ||||
ecount = 0; | ecount = 0; | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
CHECK(secp256k1_keypair_create(none, &keypair, sk) == 0); | CHECK(secp256k1_keypair_create(none, &keypair, sk) == 0); | ||||
CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | ||||
CHECK(ecount == 1); | CHECK(ecount == 1); | ||||
CHECK(secp256k1_keypair_create(verify, &keypair, sk) == 0); | CHECK(secp256k1_keypair_create(verify, &keypair, sk) == 0); | ||||
CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | ||||
CHECK(ecount == 2); | CHECK(ecount == 2); | ||||
CHECK(secp256k1_keypair_create(sign, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(sign, &keypair, sk) == 1); | ||||
CHECK(secp256k1_keypair_create(sign, NULL, sk) == 0); | CHECK(secp256k1_keypair_create(sign, NULL, sk) == 0); | ||||
CHECK(ecount == 3); | CHECK(ecount == 3); | ||||
CHECK(secp256k1_keypair_create(sign, &keypair, NULL) == 0); | CHECK(secp256k1_keypair_create(sign, &keypair, NULL) == 0); | ||||
CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | ||||
CHECK(ecount == 4); | CHECK(ecount == 4); | ||||
/* Invalid secret key */ | /* Invalid secret key */ | ||||
CHECK(secp256k1_keypair_create(sign, &keypair, zeros96) == 0); | CHECK(secp256k1_keypair_create(sign, &keypair, zeros96) == 0); | ||||
CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | ||||
CHECK(secp256k1_keypair_create(sign, &keypair, overflows) == 0); | CHECK(secp256k1_keypair_create(sign, &keypair, overflows) == 0); | ||||
CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | CHECK(memcmp(zeros96, &keypair, sizeof(keypair)) == 0); | ||||
/* Test keypair_pub */ | /* Test keypair_pub */ | ||||
ecount = 0; | ecount = 0; | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | ||||
CHECK(secp256k1_keypair_pub(none, &pk, &keypair) == 1); | CHECK(secp256k1_keypair_pub(none, &pk, &keypair) == 1); | ||||
CHECK(secp256k1_keypair_pub(none, NULL, &keypair) == 0); | CHECK(secp256k1_keypair_pub(none, NULL, &keypair) == 0); | ||||
CHECK(ecount == 1); | CHECK(ecount == 1); | ||||
CHECK(secp256k1_keypair_pub(none, &pk, NULL) == 0); | CHECK(secp256k1_keypair_pub(none, &pk, NULL) == 0); | ||||
CHECK(ecount == 2); | CHECK(ecount == 2); | ||||
CHECK(memcmp(zeros96, &pk, sizeof(pk)) == 0); | CHECK(memcmp(zeros96, &pk, sizeof(pk)) == 0); | ||||
/* Using an invalid keypair is fine for keypair_pub */ | /* Using an invalid keypair is fine for keypair_pub */ | ||||
memset(&keypair, 0, sizeof(keypair)); | memset(&keypair, 0, sizeof(keypair)); | ||||
CHECK(secp256k1_keypair_pub(none, &pk, &keypair) == 1); | CHECK(secp256k1_keypair_pub(none, &pk, &keypair) == 1); | ||||
CHECK(memcmp(zeros96, &pk, sizeof(pk)) == 0); | CHECK(memcmp(zeros96, &pk, sizeof(pk)) == 0); | ||||
/* keypair holds the same pubkey as pubkey_create */ | /* keypair holds the same pubkey as pubkey_create */ | ||||
CHECK(secp256k1_ec_pubkey_create(sign, &pk, sk) == 1); | CHECK(secp256k1_ec_pubkey_create(sign, &pk, sk) == 1); | ||||
CHECK(secp256k1_keypair_create(sign, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(sign, &keypair, sk) == 1); | ||||
CHECK(secp256k1_keypair_pub(none, &pk_tmp, &keypair) == 1); | CHECK(secp256k1_keypair_pub(none, &pk_tmp, &keypair) == 1); | ||||
CHECK(memcmp(&pk, &pk_tmp, sizeof(pk)) == 0); | CHECK(memcmp(&pk, &pk_tmp, sizeof(pk)) == 0); | ||||
/** Test keypair_xonly_pub **/ | /** Test keypair_xonly_pub **/ | ||||
ecount = 0; | ecount = 0; | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | ||||
CHECK(secp256k1_keypair_xonly_pub(none, &xonly_pk, &pk_parity, &keypair) == 1); | CHECK(secp256k1_keypair_xonly_pub(none, &xonly_pk, &pk_parity, &keypair) == 1); | ||||
CHECK(secp256k1_keypair_xonly_pub(none, NULL, &pk_parity, &keypair) == 0); | CHECK(secp256k1_keypair_xonly_pub(none, NULL, &pk_parity, &keypair) == 0); | ||||
CHECK(ecount == 1); | CHECK(ecount == 1); | ||||
CHECK(secp256k1_keypair_xonly_pub(none, &xonly_pk, NULL, &keypair) == 1); | CHECK(secp256k1_keypair_xonly_pub(none, &xonly_pk, NULL, &keypair) == 1); | ||||
CHECK(secp256k1_keypair_xonly_pub(none, &xonly_pk, &pk_parity, NULL) == 0); | CHECK(secp256k1_keypair_xonly_pub(none, &xonly_pk, &pk_parity, NULL) == 0); | ||||
CHECK(ecount == 2); | CHECK(ecount == 2); | ||||
CHECK(memcmp(zeros96, &xonly_pk, sizeof(xonly_pk)) == 0); | CHECK(memcmp(zeros96, &xonly_pk, sizeof(xonly_pk)) == 0); | ||||
Show All 26 Lines | void test_keypair_add(void) { | ||||
unsigned char tweak[32]; | unsigned char tweak[32]; | ||||
int i; | int i; | ||||
int ecount = 0; | int ecount = 0; | ||||
secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | secp256k1_context *none = api_test_context(SECP256K1_CONTEXT_NONE, &ecount); | ||||
secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | secp256k1_context *sign = api_test_context(SECP256K1_CONTEXT_SIGN, &ecount); | ||||
secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | secp256k1_context *verify = api_test_context(SECP256K1_CONTEXT_VERIFY, &ecount); | ||||
CHECK(sizeof(zeros96) == sizeof(keypair)); | CHECK(sizeof(zeros96) == sizeof(keypair)); | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
secp256k1_rand256(tweak); | secp256k1_testrand256(tweak); | ||||
memset(overflows, 0xFF, 32); | memset(overflows, 0xFF, 32); | ||||
CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | ||||
CHECK(secp256k1_keypair_xonly_tweak_add(none, &keypair, tweak) == 0); | CHECK(secp256k1_keypair_xonly_tweak_add(none, &keypair, tweak) == 0); | ||||
CHECK(ecount == 1); | CHECK(ecount == 1); | ||||
CHECK(secp256k1_keypair_xonly_tweak_add(sign, &keypair, tweak) == 0); | CHECK(secp256k1_keypair_xonly_tweak_add(sign, &keypair, tweak) == 0); | ||||
CHECK(ecount == 2); | CHECK(ecount == 2); | ||||
CHECK(secp256k1_keypair_xonly_tweak_add(verify, &keypair, tweak) == 1); | CHECK(secp256k1_keypair_xonly_tweak_add(verify, &keypair, tweak) == 1); | ||||
Show All 12 Lines | void test_keypair_add(void) { | ||||
/* A zero tweak is fine */ | /* A zero tweak is fine */ | ||||
CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | ||||
CHECK(secp256k1_keypair_xonly_tweak_add(ctx, &keypair, zeros96) == 1); | CHECK(secp256k1_keypair_xonly_tweak_add(ctx, &keypair, zeros96) == 1); | ||||
/* Fails if the resulting keypair was (sk=0, pk=infinity) */ | /* Fails if the resulting keypair was (sk=0, pk=infinity) */ | ||||
for (i = 0; i < count; i++) { | for (i = 0; i < count; i++) { | ||||
secp256k1_scalar scalar_tweak; | secp256k1_scalar scalar_tweak; | ||||
secp256k1_keypair keypair_tmp; | secp256k1_keypair keypair_tmp; | ||||
secp256k1_rand256(sk); | secp256k1_testrand256(sk); | ||||
CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | ||||
memcpy(&keypair_tmp, &keypair, sizeof(keypair)); | memcpy(&keypair_tmp, &keypair, sizeof(keypair)); | ||||
/* Because sk may be negated before adding, we need to try with tweak = | /* Because sk may be negated before adding, we need to try with tweak = | ||||
* sk as well as tweak = -sk. */ | * sk as well as tweak = -sk. */ | ||||
secp256k1_scalar_set_b32(&scalar_tweak, sk, NULL); | secp256k1_scalar_set_b32(&scalar_tweak, sk, NULL); | ||||
secp256k1_scalar_negate(&scalar_tweak, &scalar_tweak); | secp256k1_scalar_negate(&scalar_tweak, &scalar_tweak); | ||||
secp256k1_scalar_get_b32(tweak, &scalar_tweak); | secp256k1_scalar_get_b32(tweak, &scalar_tweak); | ||||
CHECK((secp256k1_keypair_xonly_tweak_add(ctx, &keypair, sk) == 0) | CHECK((secp256k1_keypair_xonly_tweak_add(ctx, &keypair, sk) == 0) | ||||
|| (secp256k1_keypair_xonly_tweak_add(ctx, &keypair_tmp, tweak) == 0)); | || (secp256k1_keypair_xonly_tweak_add(ctx, &keypair_tmp, tweak) == 0)); | ||||
CHECK(memcmp(&keypair, zeros96, sizeof(keypair)) == 0 | CHECK(memcmp(&keypair, zeros96, sizeof(keypair)) == 0 | ||||
|| memcmp(&keypair_tmp, zeros96, sizeof(keypair_tmp)) == 0); | || memcmp(&keypair_tmp, zeros96, sizeof(keypair_tmp)) == 0); | ||||
} | } | ||||
/* Invalid keypair with a valid tweak */ | /* Invalid keypair with a valid tweak */ | ||||
memset(&keypair, 0, sizeof(keypair)); | memset(&keypair, 0, sizeof(keypair)); | ||||
secp256k1_rand256(tweak); | secp256k1_testrand256(tweak); | ||||
ecount = 0; | ecount = 0; | ||||
CHECK(secp256k1_keypair_xonly_tweak_add(verify, &keypair, tweak) == 0); | CHECK(secp256k1_keypair_xonly_tweak_add(verify, &keypair, tweak) == 0); | ||||
CHECK(ecount == 1); | CHECK(ecount == 1); | ||||
CHECK(memcmp(&keypair, zeros96, sizeof(keypair)) == 0); | CHECK(memcmp(&keypair, zeros96, sizeof(keypair)) == 0); | ||||
/* Only seckey part of keypair invalid */ | /* Only seckey part of keypair invalid */ | ||||
CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | CHECK(secp256k1_keypair_create(ctx, &keypair, sk) == 1); | ||||
memset(&keypair, 0, 32); | memset(&keypair, 0, 32); | ||||
CHECK(secp256k1_keypair_xonly_tweak_add(verify, &keypair, tweak) == 0); | CHECK(secp256k1_keypair_xonly_tweak_add(verify, &keypair, tweak) == 0); | ||||
Show All 9 Lines | void test_keypair_add(void) { | ||||
for (i = 0; i < count; i++) { | for (i = 0; i < count; i++) { | ||||
secp256k1_xonly_pubkey internal_pk; | secp256k1_xonly_pubkey internal_pk; | ||||
secp256k1_xonly_pubkey output_pk; | secp256k1_xonly_pubkey output_pk; | ||||
secp256k1_pubkey output_pk_xy; | secp256k1_pubkey output_pk_xy; | ||||
secp256k1_pubkey output_pk_expected; | secp256k1_pubkey output_pk_expected; | ||||
unsigned char pk32[32]; | unsigned char pk32[32]; | ||||
int pk_parity; | int pk_parity; | ||||
secp256k1_rand256(tweak); | secp256k1_testrand256(tweak); | ||||
CHECK(secp256k1_keypair_xonly_pub(ctx, &internal_pk, NULL, &keypair) == 1); | CHECK(secp256k1_keypair_xonly_pub(ctx, &internal_pk, NULL, &keypair) == 1); | ||||
CHECK(secp256k1_keypair_xonly_tweak_add(ctx, &keypair, tweak) == 1); | CHECK(secp256k1_keypair_xonly_tweak_add(ctx, &keypair, tweak) == 1); | ||||
CHECK(secp256k1_keypair_xonly_pub(ctx, &output_pk, &pk_parity, &keypair) == 1); | CHECK(secp256k1_keypair_xonly_pub(ctx, &output_pk, &pk_parity, &keypair) == 1); | ||||
/* Check that it passes xonly_pubkey_tweak_add_check */ | /* Check that it passes xonly_pubkey_tweak_add_check */ | ||||
CHECK(secp256k1_xonly_pubkey_serialize(ctx, pk32, &output_pk) == 1); | CHECK(secp256k1_xonly_pubkey_serialize(ctx, pk32, &output_pk) == 1); | ||||
CHECK(secp256k1_xonly_pubkey_tweak_add_check(ctx, pk32, pk_parity, &internal_pk, tweak) == 1); | CHECK(secp256k1_xonly_pubkey_tweak_add_check(ctx, pk32, pk_parity, &internal_pk, tweak) == 1); | ||||
Show All 27 Lines |