Skip to content

Commit 55a3104

Browse files
siv2rsiv2r
committed
add edge cases tests (secadaptor remaining)
1 parent afbcc16 commit 55a3104

File tree

3 files changed

+150
-138
lines changed

3 files changed

+150
-138
lines changed

Diff for: ‎src/modules/ecdsa_adaptor/tests_impl.h

-4
Original file line numberDiff line numberDiff line change
@@ -100,10 +100,6 @@ static void dleq_tests(void) {
100100
CHECK(secp256k1_dleq_nonce(&k, sk32, gen2_33, p1_33, p2_33, NULL, NULL) == 1);
101101
}
102102

103-
static void rand_flip_bit(unsigned char *array, size_t n) {
104-
array[secp256k1_testrand_int(n)] ^= 1 << secp256k1_testrand_int(8);
105-
}
106-
107103
/* Helper function for test_ecdsa_adaptor_spec_vectors
108104
* Checks that the adaptor signature is valid for the public and encryption keys. */
109105
static void test_ecdsa_adaptor_spec_vectors_check_verify(const unsigned char *adaptor_sig162, const unsigned char *msg32, const unsigned char *pubkey33, const unsigned char *encryption_key33, int expected) {

Diff for: ‎src/modules/schnorr_adaptor/tests_impl.h

+146-134
Original file line numberDiff line numberDiff line change
@@ -111,7 +111,7 @@ static void test_schnorr_adaptor_api(void) {
111111
secp256k1_xonly_pubkey pk;
112112
secp256k1_xonly_pubkey zero_pk;
113113
unsigned char pre_sig[65];
114-
unsigned char invalid_pre_sig[65] = {{ 0 }};
114+
unsigned char invalid_pre_sig[65] = { 0 };
115115
unsigned char sig[64];
116116
unsigned char sec_adaptor[32];
117117
secp256k1_pubkey adaptor;
@@ -130,7 +130,7 @@ static void test_schnorr_adaptor_api(void) {
130130
CHECK(secp256k1_ec_pubkey_create(CTX, &adaptor, sec_adaptor) == 1);
131131

132132
/* main test body */
133-
CHECK(CTX, secp256k1_schnorr_adaptor_presign(CTX, pre_sig, msg, &keypair, &adaptor, NULL) == 1);
133+
CHECK(secp256k1_schnorr_adaptor_presign(CTX, pre_sig, msg, &keypair, &adaptor, NULL) == 1);
134134
CHECK_ILLEGAL(CTX, secp256k1_schnorr_adaptor_presign(CTX, NULL, msg, &keypair, &adaptor, NULL));
135135
CHECK_ILLEGAL(CTX, secp256k1_schnorr_adaptor_presign(CTX, pre_sig, NULL, &keypair, &adaptor, NULL));
136136
CHECK_ILLEGAL(CTX, secp256k1_schnorr_adaptor_presign(CTX, pre_sig, msg, NULL, &adaptor, NULL));
@@ -159,6 +159,7 @@ static void test_schnorr_adaptor_api(void) {
159159
CHECK(secp256k1_schnorr_adaptor_extract_sec(CTX, extracted_sec_adaptor, pre_sig, sig) == 1);
160160
CHECK_ILLEGAL(CTX, secp256k1_schnorr_adaptor_extract_sec(CTX, NULL, pre_sig, sig));
161161
CHECK_ILLEGAL(CTX, secp256k1_schnorr_adaptor_extract_sec(CTX, extracted_sec_adaptor, NULL, sig));
162+
/* invokes the ARG_CHECK on pre_sig[0] */
162163
CHECK_ILLEGAL(CTX, secp256k1_schnorr_adaptor_extract_sec(CTX, extracted_sec_adaptor, invalid_pre_sig, sig));
163164
CHECK_ILLEGAL(CTX, secp256k1_schnorr_adaptor_extract_sec(CTX, extracted_sec_adaptor, pre_sig, NULL));
164165
}
@@ -1001,150 +1002,163 @@ static void test_schnorr_adaptor_spec_vectors(void) {
10011002
};
10021003
}
10031004

1004-
static void test_schnorr_adaptor_presign(void) {
1005+
static void test_schnorr_adaptor_edge_cases(void) {
10051006
unsigned char sk[32];
10061007
secp256k1_xonly_pubkey pk;
10071008
secp256k1_keypair keypair;
1008-
secp256k1_scalar adaptor_scalar;
1009-
secp256k1_gej tj;
1010-
secp256k1_ge tg;
1011-
const unsigned char msg[32] = "this is for the schnorr adaptor.";
1012-
unsigned char sig[65];
1013-
unsigned char sig2[65];
1014-
unsigned char secadaptor[32];
1015-
unsigned char aux_rand[32];
1016-
unsigned char adaptor33[33];
1017-
secp256k1_pubkey t;
1009+
const unsigned char msg[32] = "this is a schnorr adaptor msg...";
1010+
unsigned char sec_adaptor[32];
1011+
unsigned char extracted_sec_adaptor[32];
10181012
secp256k1_pubkey adaptor;
1019-
size_t size = 33;
1013+
secp256k1_pubkey extracted_adaptor;
1014+
unsigned char aux_rand[32];
1015+
unsigned char pre_sig[65];
1016+
unsigned char sig[64];
10201017

10211018
secp256k1_testrand256(sk);
1022-
secp256k1_testrand256(secadaptor);
1019+
secp256k1_testrand256(sec_adaptor);
10231020
secp256k1_testrand256(aux_rand);
1024-
secp256k1_scalar_set_b32(&adaptor_scalar, secadaptor, NULL);
1025-
secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &tj, &adaptor_scalar);
1026-
secp256k1_ge_set_gej(&tg, &tj);
1027-
CHECK(secp256k1_eckey_pubkey_serialize(&tg, adaptor33, &size, 1) == 1);
1028-
CHECK(secp256k1_keypair_create(CTX, &keypair, sk) == 1);
1029-
CHECK(secp256k1_keypair_xonly_pub(CTX, &pk, NULL, &keypair) == 1);
1030-
CHECK(secp256k1_ec_pubkey_parse(CTX, &adaptor, adaptor33, 33) == 1);
1031-
CHECK(secp256k1_schnorr_adaptor_presign(CTX, sig, msg, &keypair, &adaptor, NULL) == 1);
1032-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig, msg, &pk));
1033-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor) == 0);
1034-
/* Test with aux_rand */
1035-
CHECK(secp256k1_schnorr_adaptor_presign(CTX, sig2, msg, &keypair, &adaptor, aux_rand) == 1);
1036-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig, msg, &pk));
1037-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor) == 0);
1038-
}
1021+
CHECK(secp256k1_keypair_create(CTX, &keypair, sk));
1022+
CHECK(secp256k1_keypair_xonly_pub(CTX, &pk, NULL, &keypair));
1023+
CHECK(secp256k1_ec_pubkey_create(CTX, &adaptor, sec_adaptor));
10391024

1040-
#define N_SIGS 3
1041-
/* Creates N_SIGS valid signatures and verifies them with extract
1042-
* Then flips some bits and checks that extract now fails to get the right
1043-
* adaptor point. */
1044-
static void test_schnorr_adaptor_extract(void) {
1045-
unsigned char sk[32];
1046-
secp256k1_xonly_pubkey pk;
1047-
secp256k1_keypair keypair;
1048-
secp256k1_scalar adaptor_scalar;
1049-
secp256k1_gej tj;
1050-
secp256k1_ge tg;
1051-
secp256k1_scalar s;
1052-
unsigned char msg[N_SIGS][32];
1053-
unsigned char sig[N_SIGS][65];
1054-
unsigned char secadaptor[N_SIGS][32];
1055-
unsigned char adaptor33[N_SIGS][33];
1056-
secp256k1_pubkey t;
1057-
secp256k1_pubkey adaptor[N_SIGS];
1058-
size_t size = 33;
1059-
size_t i;
1025+
/* Test schnorr_adaptor_presign */
1026+
CHECK(secp256k1_schnorr_adaptor_presign(CTX, pre_sig, msg, &keypair, &adaptor, aux_rand) == 1);
10601027

1061-
secp256k1_testrand256(sk);
1062-
CHECK(secp256k1_keypair_create(CTX, &keypair, sk) == 1);
1063-
CHECK(secp256k1_keypair_xonly_pub(CTX, &pk, NULL, &keypair) == 1);
1028+
/* TODO: test with different nonce functions after `schnorr_adaptor_presign_custom`
1029+
* implementation */
10641030

1065-
for (i = 0; i < N_SIGS; i++) {
1066-
secp256k1_testrand256(msg[i]);
1067-
secp256k1_testrand256(secadaptor[i]);
1068-
secp256k1_scalar_set_b32(&adaptor_scalar, secadaptor[i], NULL);
1069-
secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &tj, &adaptor_scalar);
1070-
secp256k1_ge_set_gej(&tg, &tj);
1071-
CHECK(secp256k1_eckey_pubkey_serialize(&tg, adaptor33[i], &size, 1) == 1);
1072-
CHECK(secp256k1_ec_pubkey_parse(CTX, &adaptor[i], adaptor33[i], 33) == 1);
1073-
CHECK(secp256k1_schnorr_adaptor_presign(CTX, sig[i], msg[i], &keypair, &adaptor[i], NULL) == 1);
1074-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig[i], msg[i], &pk));
1075-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor[i]) == 0);
1031+
/* Test schnorr_adaptor_extract */
1032+
CHECK(secp256k1_schnorr_adaptor_presign(CTX, pre_sig, msg, &keypair, &adaptor, aux_rand) == 1);
1033+
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &extracted_adaptor, pre_sig, msg, &pk) == 1);
1034+
CHECK(secp256k1_ec_pubkey_cmp(CTX, &extracted_adaptor, &adaptor) == 0);
1035+
{
1036+
/* invalid R' (= pre_sig[0:33]) */
1037+
unsigned char pre_sig_tmp[65];
1038+
secp256k1_pubkey extracted_adaptor_tmp;
1039+
memcpy(pre_sig_tmp, pre_sig, sizeof(pre_sig_tmp));
1040+
memset(pre_sig_tmp, 0xFF, 33);
1041+
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &extracted_adaptor_tmp, pre_sig_tmp, msg, &pk) == 0);
10761042
}
1077-
10781043
{
1079-
/* Flip some bits in the signature and check that extract fails to
1080-
* extract the correct adaptor point */
1081-
size_t sig_idx = secp256k1_testrand_int(N_SIGS);
1082-
size_t byte_idx = secp256k1_testrand_bits(5);
1083-
unsigned char xorbyte = secp256k1_testrand_int(254)+1;
1084-
sig[sig_idx][33 + byte_idx] ^= xorbyte;
1085-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig[sig_idx], msg[sig_idx], &pk));
1086-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor[sig_idx]) != 0);
1087-
sig[sig_idx][33 + byte_idx] ^= xorbyte;
1088-
1089-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig[sig_idx], msg[sig_idx], &pk));
1090-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor[sig_idx]) == 0);
1044+
/* overflowing s */
1045+
unsigned char pre_sig_tmp[65];
1046+
secp256k1_pubkey extracted_adaptor_tmp;
1047+
memcpy(pre_sig_tmp, pre_sig, sizeof(pre_sig_tmp));
1048+
memset(&pre_sig_tmp[33], 0xFF, 32);
1049+
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &extracted_adaptor_tmp, pre_sig_tmp, msg, &pk) == 0);
10911050
}
1051+
{
1052+
/* negated s */
1053+
unsigned char pre_sig_tmp[65];
1054+
secp256k1_scalar s;
1055+
secp256k1_pubkey extracted_adaptor_tmp;
1056+
memcpy(pre_sig_tmp, pre_sig, sizeof(pre_sig_tmp));
1057+
secp256k1_scalar_set_b32(&s, &pre_sig_tmp[33], NULL);
1058+
secp256k1_scalar_negate(&s, &s);
1059+
secp256k1_scalar_get_b32(&pre_sig_tmp[33], &s);
1060+
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &extracted_adaptor_tmp, pre_sig_tmp, msg, &pk) == 1);
1061+
CHECK(secp256k1_ec_pubkey_cmp(CTX, &extracted_adaptor_tmp, &adaptor) != 0);
1062+
}
1063+
{
1064+
/* any flipped bit in the pre-signature will extract
1065+
* an invalid adaptor point */
1066+
unsigned char pre_sig_tmp[65];
1067+
secp256k1_pubkey extracted_adaptor_tmp;
1068+
memcpy(pre_sig_tmp, pre_sig, sizeof(pre_sig_tmp));
1069+
rand_flip_bit(&pre_sig_tmp[1], sizeof(pre_sig_tmp) - 1);
1070+
/* depending on which bit was flipped adaptor_extract can either
1071+
* return 0 (parsing pre-signature failed) or 1 (parsing
1072+
* pre-signature success) */
1073+
if(secp256k1_schnorr_adaptor_extract(CTX, &extracted_adaptor_tmp, pre_sig_tmp, msg, &pk)) {
1074+
CHECK(secp256k1_ec_pubkey_cmp(CTX, &extracted_adaptor_tmp, &adaptor) != 0);
1075+
}
1076+
}
1077+
{
1078+
/* any flipped bit in the message will extract an invalid
1079+
* adaptor point */
1080+
unsigned char msg_tmp[32];
1081+
secp256k1_pubkey extracted_adaptor_tmp;
1082+
memcpy(msg_tmp, msg, sizeof(msg_tmp));
1083+
rand_flip_bit(msg_tmp, sizeof(msg_tmp));
1084+
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &extracted_adaptor_tmp, pre_sig, msg_tmp, &pk) == 1);
1085+
CHECK(secp256k1_ec_pubkey_cmp(CTX, &extracted_adaptor_tmp, &adaptor) != 0);
1086+
}
1087+
/* Note: presig test vectors 12, 13, 14 will cover the edge case
1088+
* of adaptor_extract returning 0 when [1] R = infinity, or
1089+
* [2] T = infinity. So, we don't need to test such scenarios here */
10921090

1093-
/* Test overflowing s */
1094-
CHECK(secp256k1_schnorr_adaptor_presign(CTX, sig[0], msg[0], &keypair, &adaptor[0], NULL) == 1);
1095-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig[0], msg[0], &pk));
1096-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor[0]) == 0);
1097-
memset(&sig[0][33], 0xFF, 32);
1098-
CHECK(!secp256k1_schnorr_adaptor_extract(CTX, &t, sig[0], msg[0], &pk));
1099-
1100-
/* Test negative s */
1101-
CHECK(secp256k1_schnorr_adaptor_presign(CTX, sig[0], msg[0], &keypair, &adaptor[0], NULL) == 1);
1102-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig[0], msg[0], &pk));
1103-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor[0]) == 0);
1104-
secp256k1_scalar_set_b32(&s, &sig[0][33], NULL);
1105-
secp256k1_scalar_negate(&s, &s);
1106-
secp256k1_scalar_get_b32(&sig[0][33], &s);
1107-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig[0], msg[0], &pk));
1108-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor[0]) != 0);
1109-
}
1110-
#undef N_SIGS
1111-
1112-
static void test_schnorr_adaptor_adapt_extract_sec(void) {
1113-
unsigned char sk[32];
1114-
secp256k1_xonly_pubkey pk;
1115-
secp256k1_keypair keypair;
1116-
secp256k1_scalar adaptor_scalar;
1117-
secp256k1_gej tj;
1118-
secp256k1_ge tg;
1119-
unsigned char msg[32];
1120-
unsigned char sig[65];
1121-
unsigned char sig64[64];
1122-
unsigned char secadaptor[32];
1123-
unsigned char aux_rand[32];
1124-
unsigned char adaptor33[33];
1125-
secp256k1_pubkey t;
1126-
unsigned char t2[32];
1127-
secp256k1_pubkey adaptor;
1128-
size_t size = 33;
1091+
/* Test schnorr_adaptor_adapt */
1092+
CHECK(secp256k1_schnorr_adaptor_presign(CTX, pre_sig, msg, &keypair, &adaptor, aux_rand) == 1);
1093+
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig, pre_sig, sec_adaptor) == 1);
1094+
CHECK(secp256k1_schnorrsig_verify(CTX, sig, msg, sizeof(msg), &pk) == 1);
1095+
{
1096+
/* overflowing sec_adaptor */
1097+
unsigned char sig_tmp[64];
1098+
unsigned char sec_adaptor_tmp[32];
1099+
memset(sec_adaptor_tmp, 0xFF, 32);
1100+
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig_tmp, pre_sig, sec_adaptor_tmp) == 0);
1101+
}
1102+
{
1103+
/* overflowing s */
1104+
unsigned char sig_tmp[64];
1105+
unsigned char pre_sig_tmp[65];
1106+
memcpy(pre_sig_tmp, pre_sig, sizeof(pre_sig_tmp));
1107+
memset(&pre_sig_tmp[33], 0xFF, 32);
1108+
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig_tmp, pre_sig_tmp, sec_adaptor) == 0);
1109+
}
1110+
{
1111+
/* negated s */
1112+
unsigned char sig_tmp[64];
1113+
unsigned char pre_sig_tmp[65];
1114+
secp256k1_scalar s;
1115+
memcpy(pre_sig_tmp, pre_sig, sizeof(pre_sig_tmp));
1116+
secp256k1_scalar_set_b32(&s, &pre_sig_tmp[33], NULL);
1117+
secp256k1_scalar_negate(&s, &s);
1118+
secp256k1_scalar_get_b32(&pre_sig_tmp[33], &s);
1119+
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig_tmp, pre_sig_tmp, sec_adaptor) == 1);
1120+
CHECK(secp256k1_schnorrsig_verify(CTX, sig_tmp, msg, sizeof(msg), &pk) == 0);
1121+
}
1122+
{
1123+
/* any flipped bit in the pre-signature will result in
1124+
* an invalid signature */
1125+
unsigned char sig_tmp[64];
1126+
unsigned char pre_sig_tmp[65];
1127+
memcpy(pre_sig_tmp, pre_sig, sizeof(pre_sig_tmp));
1128+
rand_flip_bit(&pre_sig_tmp[1], sizeof(pre_sig_tmp) - 1);
1129+
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig_tmp, pre_sig_tmp, sec_adaptor) == 1);
1130+
CHECK(secp256k1_schnorrsig_verify(CTX, sig_tmp, msg, sizeof(msg), &pk) == 0);
1131+
}
1132+
{
1133+
/* any flipped bit in the sec_adaptor will result in an
1134+
* invalid signature */
1135+
unsigned char sig_tmp[64];
1136+
unsigned char sec_adaptor_tmp[32];
1137+
memcpy(sec_adaptor_tmp, sec_adaptor, sizeof(sec_adaptor_tmp));
1138+
rand_flip_bit(sec_adaptor_tmp, sizeof(sec_adaptor_tmp));
1139+
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig_tmp, pre_sig, sec_adaptor_tmp) == 1);
1140+
CHECK(secp256k1_schnorrsig_verify(CTX, sig_tmp, msg, sizeof(msg), &pk) == 0);
1141+
}
11291142

1130-
secp256k1_testrand256(sk);
1131-
secp256k1_testrand256(msg);
1132-
secp256k1_testrand256(secadaptor);
1133-
secp256k1_testrand256(aux_rand);
1134-
secp256k1_scalar_set_b32(&adaptor_scalar, secadaptor, NULL);
1135-
secp256k1_ecmult_gen(&CTX->ecmult_gen_ctx, &tj, &adaptor_scalar);
1136-
secp256k1_ge_set_gej(&tg, &tj);
1137-
CHECK(secp256k1_eckey_pubkey_serialize(&tg, adaptor33, &size, 1) == 1);
1138-
CHECK(secp256k1_keypair_create(CTX, &keypair, sk) == 1);
1139-
CHECK(secp256k1_keypair_xonly_pub(CTX, &pk, NULL, &keypair) == 1);
1140-
CHECK(secp256k1_ec_pubkey_parse(CTX, &adaptor, adaptor33, 33) == 1);
1141-
CHECK(secp256k1_schnorr_adaptor_presign(CTX, sig, msg, &keypair, &adaptor, aux_rand) == 1);
1142-
CHECK(secp256k1_schnorr_adaptor_extract(CTX, &t, sig, msg, &pk));
1143-
CHECK(secp256k1_ec_pubkey_cmp(CTX, &t, &adaptor) == 0);
1144-
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig64, sig, secadaptor) == 1);
1145-
CHECK(secp256k1_schnorrsig_verify(CTX, sig64, msg, sizeof(msg), &pk) == 1);
1146-
CHECK(secp256k1_schnorr_adaptor_extract_sec(CTX, t2, sig, sig64) == 1);
1147-
CHECK(secp256k1_memcmp_var(t2, secadaptor, 32) == 0);
1143+
/* Test schnorr_adaptor_extract_sec */
1144+
CHECK(secp256k1_schnorr_adaptor_presign(CTX, pre_sig, msg, &keypair, &adaptor, aux_rand) == 1);
1145+
CHECK(secp256k1_schnorr_adaptor_adapt(CTX, sig, pre_sig, sec_adaptor) == 1);
1146+
CHECK(secp256k1_schnorr_adaptor_extract_sec(CTX, extracted_sec_adaptor, pre_sig, sig) == 1);
1147+
CHECK(secp256k1_memcmp_var(extracted_sec_adaptor, sec_adaptor, sizeof(extracted_sec_adaptor)) == 0);
1148+
{
1149+
/* overflowing pre_sig[33:65] */
1150+
}
1151+
{
1152+
/* overflowing sig[32:64] */
1153+
}
1154+
{
1155+
/* any flipped bit in the pre-signature will extract
1156+
* an invalid secret adaptor */
1157+
}
1158+
{
1159+
/* any flipped bit in the signature will extract
1160+
* an invalid secret adaptor */
1161+
}
11481162
}
11491163

11501164
static void run_schnorr_adaptor_tests(void) {
@@ -1154,9 +1168,7 @@ static void run_schnorr_adaptor_tests(void) {
11541168
test_schnorr_adaptor_api();
11551169
test_schnorr_adaptor_spec_vectors();
11561170
for (i = 0; i < COUNT; i++) {
1157-
test_schnorr_adaptor_presign();
1158-
test_schnorr_adaptor_extract();
1159-
test_schnorr_adaptor_adapt_extract_sec();
1171+
test_schnorr_adaptor_edge_cases();
11601172
}
11611173
}
11621174

Diff for: ‎src/testutil.h

+4
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,10 @@ static void random_fe_non_zero(secp256k1_fe *nz) {
2626
} while (secp256k1_fe_is_zero(nz));
2727
}
2828

29+
static void rand_flip_bit(unsigned char *array, size_t n) {
30+
array[secp256k1_testrand_int(n)] ^= 1 << secp256k1_testrand_int(8);
31+
}
32+
2933
static void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
3034
CHECK(a->infinity == b->infinity);
3135
if (a->infinity) {

0 commit comments

Comments
 (0)