10#define SECP256K1_BUILD
11#define ENABLE_MODULE_GENERATOR 1
12#define ENABLE_MODULE_BPPP 1
13#define ENABLE_MODULE_EXTRAKEYS 1
14#define ENABLE_MODULE_SCHNORRSIG 1
24#if defined(PURIFY_VALGRIND_TESTING)
25#include <valgrind/memcheck.h>
27#define PURIFY_BRIDGE_DECLASSIFY(data, size) \
28 VALGRIND_MAKE_MEM_DEFINED((data), (size))
30#define PURIFY_BRIDGE_DECLASSIFY(data, size) ((void)(data), (void)(size))
33#include "third_party/secp256k1-zkp/include/secp256k1_extrakeys.h"
34#include "third_party/secp256k1-zkp/include/secp256k1_schnorrsig.h"
35#include "third_party/secp256k1-zkp/src/secp256k1.c"
36#include "third_party/secp256k1-zkp/src/precomputed_ecmult.c"
37#include "third_party/secp256k1-zkp/src/precomputed_ecmult_gen.c"
40#undef secp256k1_scratch_alloc
42_Static_assert(
sizeof(
purify_scalar) ==
sizeof(secp256k1_scalar),
"purify_scalar size mismatch");
43_Static_assert(_Alignof(
purify_scalar) >= _Alignof(secp256k1_scalar),
"purify_scalar alignment mismatch");
46 secp256k1_context*
ctx;
51 const unsigned char* rhs,
55 return context != NULL ? context->
ctx : NULL;
59 unsigned char seed32[32] = {0};
62 if (context == NULL) {
65 context->
ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
66 if (context->
ctx == NULL) {
71 || !secp256k1_context_randomize(context->
ctx, seed32)) {
73 secp256k1_context_destroy(context->
ctx);
82 if (context == NULL) {
85 if (context->
ctx != NULL) {
86 secp256k1_context_destroy(context->
ctx);
92 if (data != NULL && size != 0u) {
93 secp256k1_memclear_explicit(data, size);
99 if (scratch != NULL && scratch->data != NULL && checkpoint <= scratch->max_size) {
101 scratch->max_size - checkpoint);
114 return resources != NULL && resources->
scratch != NULL ? resources->
scratch->max_size : 0;
121 secp256k1_bppp_generators*
gens;
134 if (lhs != 0 && rhs > SIZE_MAX / lhs) {
145 if (rhs > SIZE_MAX - lhs) {
174 const secp256k1_context* ctx,
size_t generators_count) {
177 size_t allocation_size;
185 if (generators_count == 0
187 sizeof(secp256k1_ge) + 2 *
sizeof(secp256k1_scalar), &frame)
190 ROUND_TO_ALIGN(
sizeof(secp256k1_scratch)), &allocation_size)) {
193 return secp256k1_scratch_space_create(ctx, capacity);
203 size_t allocation_size;
254 secp256k1_scratch_space* replacement;
259 if (required <= resources->scratch_capacity) {
262 replacement = secp256k1_scratch_space_create(resources->
ctx, required);
263 if (replacement == NULL) {
267 secp256k1_scratch_space_destroy(resources->
ctx, resources->
scratch);
268 resources->
scratch = replacement;
282 return malloc(bytes);
294 return calloc(1, bytes);
298 const secp256k1_bppp_generators* generators) {
299 secp256k1_bppp_generators* clone;
300 size_t generator_bytes = 0;
302 if (generators == NULL || generators->gens == NULL || generators->n == 0 ||
307 clone = (secp256k1_bppp_generators*)calloc(1,
sizeof(*clone));
311 clone->n = generators->n;
313 if (clone->gens == NULL) {
317 memcpy(clone->gens, generators->gens, generator_bytes);
324 size_t generator_bytes = 0;
326 if (resources == NULL || resources->
gens == NULL || resources->
gens->gens == NULL ||
333 memcpy(resources->
gens_scratch.gens, resources->
gens->gens, generator_bytes);
353 if (guard != NULL && guard->
resources != NULL) {
362 size_t generator_count = 0;
365 if (ctx == NULL || n_gates == 0 || !secp256k1_is_power_of_two(n_gates)) {
373 if (resources == NULL) {
377 resources->
ctx = ctx;
381 if (resources->
scratch == NULL) {
387 if (resources->
gens == NULL || resources->
gens->
n < generator_count) {
399 size_t generator_count = 0;
401 if (resources == NULL || resources->
ctx == NULL || resources->
n_gates == 0 ||
410 clone->
ctx = resources->
ctx;
419 clone->
ctx, secp256k1_generator_h, generator_count, 1);
420 if (clone->
gens == NULL || clone->
gens->
n < generator_count) {
428 if (resources == NULL) {
431 if (resources->
gens != NULL && resources->
ctx != NULL) {
434 if (resources->
scratch != NULL && resources->
ctx != NULL) {
436 secp256k1_scratch_space_destroy(resources->
ctx, resources->
scratch);
442 const unsigned char* generators33,
443 size_t generators_count) {
445 size_t serialized_len = 0;
448 if (ctx == NULL || generators33 == NULL || generators_count == 0) {
456 if (resources == NULL) {
460 resources->
ctx = ctx;
463 if (resources->
scratch == NULL) {
468 resources->
gens = secp256k1_bppp_generators_parse(resources->
ctx, generators33, serialized_len);
469 if (resources->
gens == NULL || resources->
gens->n != generators_count) {
488 size_t generator_bytes = 0;
500 clone->
ctx = resources->
ctx;
508 if (clone->
gens == NULL) {
524 if (resources == NULL) {
527 if (resources->
gens != NULL && resources->
ctx != NULL) {
528 secp256k1_bppp_generators_destroy(resources->
ctx, resources->
gens);
533 if (resources->
scratch != NULL && resources->
ctx != NULL) {
535 secp256k1_scratch_space_destroy(resources->
ctx, resources->
scratch);
541 return (secp256k1_scalar*)scalar;
545 return (
const secp256k1_scalar*)scalar;
606 static const unsigned char zero = 0;
607 secp256k1_sha256 sha256;
609 if (data == NULL && data_len == 0) {
613 secp256k1_sha256_initialize(&sha256);
615 secp256k1_sha256_write(&sha256, data, data_len);
617 secp256k1_sha256_finalize(&sha256, output32);
618 secp256k1_sha256_clear(&sha256);
622 const unsigned char *
const *items,
623 const size_t *item_lens,
624 size_t items_count) {
625 secp256k1_sha256 sha256;
626 if (output32 == NULL) {
629 if (items_count != 0 && (items == NULL || item_lens == NULL)) {
630 memset(output32, 0, 32);
633 secp256k1_sha256_initialize(&sha256);
634 for (
size_t i = 0; i < items_count; ++i) {
635 const unsigned char *item = items[i];
636 size_t item_len = item_lens[i];
639 secp256k1_sha256_clear(&sha256);
640 memset(output32, 0, 32);
646 secp256k1_sha256_write(&sha256, item, item_len);
649 secp256k1_sha256_finalize(&sha256, output32);
650 secp256k1_sha256_clear(&sha256);
655 const unsigned char* key,
size_t key_len,
656 const unsigned char* data,
size_t data_len) {
657 static const unsigned char zero = 0;
658 secp256k1_hmac_sha256 hmac;
660 if (key == NULL && key_len == 0) {
663 if (data == NULL && data_len == 0) {
667 secp256k1_hmac_sha256_initialize(&hmac, key, key_len);
669 secp256k1_hmac_sha256_write(&hmac, data, data_len);
671 secp256k1_hmac_sha256_finalize(&hmac, output32);
672 secp256k1_hmac_sha256_clear(&hmac);
676 const secp256k1_context* ctx,
unsigned char scalar32[32],
677 unsigned char xonly_pubkey32[32]) {
678 secp256k1_scalar scalar = {0};
680 secp256k1_gej pointj;
684 secp256k1_scalar_set_b32(&scalar, scalar32, &overflow);
685 if (overflow || secp256k1_scalar_is_zero(&scalar)) {
688 secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pointj, &scalar);
689 secp256k1_ge_set_gej(&point, &pointj);
690 secp256k1_fe_normalize(&point.x);
691 secp256k1_fe_normalize(&point.y);
692 secp256k1_scalar_cond_negate(
693 &scalar, secp256k1_fe_is_odd(&point.y));
694 secp256k1_scalar_get_b32(scalar32, &scalar);
695 secp256k1_fe_get_b32(xonly_pubkey32, &point.x);
699 secp256k1_scalar_clear(&scalar);
706 unsigned char seckey32[32],
707 unsigned char xonly_pubkey32[32]) {
711 if (xonly_pubkey32 != NULL) {
712 memset(xonly_pubkey32, 0, 32);
715 if (ctx == NULL || seckey32 == NULL || xonly_pubkey32 == NULL) {
720 ctx, seckey32, xonly_pubkey32);
723 memset(xonly_pubkey32, 0, 32);
729 unsigned char scalar32[32],
730 unsigned char xonly_nonce32[32]) {
734 if (xonly_nonce32 != NULL) {
735 memset(xonly_nonce32, 0, 32);
738 if (ctx == NULL || scalar32 == NULL || xonly_nonce32 == NULL) {
743 ctx, scalar32, xonly_nonce32);
746 memset(xonly_nonce32, 0, 32);
752 const unsigned char point33[33],
753 unsigned char xonly32[32],
756 secp256k1_pubkey pubkey;
757 secp256k1_xonly_pubkey xonly;
761 memset(&pubkey, 0,
sizeof(pubkey));
762 memset(&xonly, 0,
sizeof(xonly));
763 if (xonly32 != NULL) {
764 memset(xonly32, 0, 32);
766 if (parity_out != NULL) {
770 if (ctx == NULL || point33 == NULL || xonly32 == NULL) {
774 ok = secp256k1_ec_pubkey_parse(ctx, &pubkey, point33, 33);
776 ok = secp256k1_xonly_pubkey_from_pubkey(ctx, &xonly, &parity, &pubkey);
779 ok = secp256k1_xonly_pubkey_serialize(ctx, xonly32, &xonly);
781 if (ok && parity_out != NULL) {
782 *parity_out = parity;
785 memset(xonly32, 0, 32);
794 const unsigned char xonly_pubkey32[32]) {
796 secp256k1_xonly_pubkey xonly;
799 memset(&xonly, 0,
sizeof(xonly));
800 if (ctx == NULL || xonly_pubkey32 == NULL) {
804 ok = secp256k1_xonly_pubkey_parse(ctx, &xonly, xonly_pubkey32);
811 const unsigned char sig64[64]) {
813 secp256k1_xonly_pubkey rxonly;
820 if (ctx == NULL || sig64 == NULL) {
824 ok = secp256k1_xonly_pubkey_parse(ctx, &rxonly, sig64);
826 secp256k1_scalar_set_b32(&s, sig64 + 32, &overflow);
831 secp256k1_scalar_clear(&s);
836 const unsigned char *msg,
size_t msglen,
837 const unsigned char *key32,
838 const unsigned char *xonly_pk32,
839 const unsigned char *algo,
size_t algolen,
848 if (nonce32 == NULL || data == NULL) {
851 memcpy(nonce32, data, 32);
856 unsigned char sig64[64],
857 const unsigned char* msg,
size_t msglen,
858 const unsigned char seckey32[32],
859 const unsigned char nonce32[32]) {
861 secp256k1_keypair keypair;
862 secp256k1_scalar nonce_scalar;
863 secp256k1_schnorrsig_extraparams extraparams = SECP256K1_SCHNORRSIG_EXTRAPARAMS_INIT;
864 unsigned char canonical_nonce32[32];
865 unsigned char xonly_nonce32[32];
874 memset(sig64, 0, 64);
877 if (ctx == NULL || sig64 == NULL || seckey32 == NULL || nonce32 == NULL || (msg == NULL && msglen != 0)) {
881 memcpy(canonical_nonce32, nonce32, 32);
885 canonical_nonce32, nonce32,
sizeof(canonical_nonce32));
887 secp256k1_scalar_set_b32(&nonce_scalar, nonce32, &overflow);
888 if (ok && !overflow && !secp256k1_scalar_is_zero(&nonce_scalar)) {
889 ok = secp256k1_keypair_create(ctx, &keypair, seckey32);
892 extraparams.ndata = (
void*)nonce32;
893 ok = secp256k1_schnorrsig_sign_custom(ctx, sig64, msg, msglen, &keypair, &extraparams);
898 secp256k1_scalar_clear(&nonce_scalar);
902 memset(sig64, 0, 64);
908 const unsigned char sig64[64],
909 const unsigned char* msg,
size_t msglen,
910 const unsigned char xonly_pubkey32[32]) {
912 secp256k1_xonly_pubkey pubkey;
915 memset(&pubkey, 0,
sizeof(pubkey));
916 if (ctx == NULL || sig64 == NULL || xonly_pubkey32 == NULL || (msg == NULL && msglen != 0)) {
920 ok = secp256k1_xonly_pubkey_parse(ctx, &pubkey, xonly_pubkey32);
922 ok = secp256k1_schnorrsig_verify(ctx, sig64, msg, msglen, &pubkey);
925 memset(&pubkey, 0,
sizeof(pubkey));
929static int purify_parse_scalar(
const unsigned char input32[32], secp256k1_scalar* scalar,
int reject_zero) {
931 secp256k1_scalar_set_b32(scalar, input32, &overflow);
935 if (reject_zero && secp256k1_scalar_is_zero(scalar)) {
943 for (i = 0; i < count; ++i) {
955 secp256k1_fe_normalize(&point->x);
956 secp256k1_fe_normalize(&point->y);
957 return secp256k1_bppp_serialize_pt(out33, point);
961 const unsigned char* rhs,
963 volatile unsigned char difference = 0;
966 for (i = 0; i < size; ++i) {
967 difference |= lhs[i] ^ rhs[i];
969 return difference == 0;
973 secp256k1_scalar one, two, neg_one, neg_two;
979 secp256k1_scalar_set_int(&one, 1);
980 secp256k1_scalar_set_int(&two, 2);
981 secp256k1_scalar_negate(&neg_one, &one);
982 secp256k1_scalar_negate(&neg_two, &two);
985 if (secp256k1_scalar_is_zero(&scalar->
scal)) {
987 }
else if (secp256k1_scalar_eq(&scalar->
scal, &one)) {
989 }
else if (secp256k1_scalar_eq(&scalar->
scal, &two)) {
991 }
else if (secp256k1_scalar_eq(&scalar->
scal, &neg_one)) {
993 }
else if (secp256k1_scalar_eq(&scalar->
scal, &neg_two)) {
1000 secp256k1_generator generator;
1001 if (ctx == NULL || generator33 == NULL || out == NULL) {
1004 if (!secp256k1_generator_parse(ctx, &generator, generator33)) {
1007 secp256k1_generator_load(out, &generator);
1012 if (point33 == NULL || out == NULL) {
1015 return secp256k1_eckey_pubkey_parse(out, point33, 33);
1019 if (circuit == NULL) {
1028 memset(circuit, 0,
sizeof(*circuit));
1032 if (assignment == NULL) {
1039 memset(assignment, 0,
sizeof(*assignment));
1058 for (i = 0; i < count; ++i) {
1059 if (rows[i].size != 0 && (rows[i].indices == NULL || rows[i].scalars32 == NULL)) {
1075 size_t n_constraints,
1079 for (i = 0; i < row_count; ++i) {
1081 out_rows[i].
size = in_rows[i].
size;
1082 out_rows[i].
entry = in_rows[i].
size == 0 ? NULL : entries + *offset;
1083 for (j = 0; j < in_rows[i].
size; ++j) {
1084 size_t entry_idx = *offset + j;
1085 if (in_rows[i].indices[j] >= n_constraints) {
1092 entries[entry_idx] = out_rows[i].
entry[j];
1094 *offset += in_rows[i].
size;
1101 const secp256k1_scalar* assn) {
1103 for (j = 0; j < row->
size; ++j) {
1104 secp256k1_scalar term;
1106 secp256k1_scalar_add(&acc[row->
entry[j].
idx], &acc[row->
entry[j].
idx], &term);
1107 secp256k1_scalar_clear(&term);
1113 secp256k1_scalar* acc = NULL;
1117 if (circuit == NULL || assignment == NULL) {
1129 for (i = 0; i < assignment->
n_gates; ++i) {
1130 secp256k1_scalar product;
1132 secp256k1_scalar_mul(&product, &assignment->
al[i], &assignment->
ar[i]);
1133 matches = secp256k1_scalar_eq(&product, &assignment->
ao[i]);
1134 secp256k1_scalar_clear(&product);
1141 secp256k1_scalar_clear(&acc[i]);
1144 for (i = 0; i < circuit->
n_gates; ++i) {
1149 for (i = 0; i < circuit->
n_commits; ++i) {
1150 secp256k1_scalar negated_v;
1151 secp256k1_scalar_negate(&negated_v, &assignment->
v[i]);
1153 secp256k1_scalar_clear(&negated_v);
1156 secp256k1_scalar constant_term;
1157 secp256k1_scalar one;
1159 secp256k1_scalar_set_int(&one, 1);
1161 matches = secp256k1_scalar_eq(&acc[i], &constant_term);
1162 secp256k1_scalar_clear(&constant_term);
1163 secp256k1_scalar_clear(&one);
1178 size_t row_entries = 0;
1179 size_t total_entries = 0;
1186 if (view == NULL || out == NULL || (view->
n_constraints != 0 && view->
c32 == NULL)) {
1189 if (!secp256k1_is_power_of_two(view->
n_gates)) {
1192 memset(out, 0,
sizeof(*out));
1216 if ((view->
n_gates != 0 && (out->
wl == NULL || out->
wr == NULL || out->
wo == NULL)) ||
1219 (total_entries != 0 && out->
entries == NULL)) {
1242 if (view == NULL || out == NULL) {
1245 if ((view->
n_gates != 0 && (view->
al32 == NULL || view->
ar32 == NULL || view->
ao32 == NULL)) ||
1249 memset(out, 0,
sizeof(*out));
1256 if ((view->
n_gates != 0 && (out->
al == NULL || out->
ar == NULL || out->
ao == NULL)) ||
1272 size_t proof_size = 0;
1285 const unsigned char* blinds32,
1286 const unsigned char value_gen33[33],
1287 const unsigned char nonce32[32],
1288 const unsigned char* extra_commit,
1289 size_t extra_commit_len,
1290 unsigned char* commitments_out33,
1291 unsigned char* proof_out,
1293 int require_valid_assignment,
1296 secp256k1_context* ctx = NULL;
1297 secp256k1_scratch_space* scratch = NULL;
1301 secp256k1_ge value_gen;
1302 secp256k1_ge* commit_points = NULL;
1303 secp256k1_scalar* blinds = NULL;
1304 size_t n_commits = 0;
1305 size_t required_generators = 0;
1306 size_t commitment_bytes = 0;
1307 size_t scratch_checkpoint = 0;
1310 int owns_resources = 0;
1311 int scratch_contains_secrets = 0;
1313 memset(&bp_circuit, 0,
sizeof(bp_circuit));
1314 memset(&bp_assignment, 0,
sizeof(bp_assignment));
1316 if (circuit == NULL || assignment == NULL || value_gen33 == NULL || nonce32 == NULL || proof_out == NULL || proof_len == NULL) {
1319 if (extra_commit == NULL && extra_commit_len != 0) {
1332 if (resources == NULL) {
1334 if (resources == NULL) {
1345 ctx = resources->
ctx;
1347 gens = resources->
gens;
1349 gens->
n < required_generators) {
1360 if (n_commits != 0) {
1361 if (commitments_out33 == NULL) {
1364 memset(commitments_out33, 0, commitment_bytes);
1367 if (commit_points == NULL || blinds == NULL) {
1371 for (i = 0; i < n_commits; ++i) {
1372 secp256k1_gej commitj;
1377 if (secp256k1_gej_is_infinity(&commitj)) {
1380 secp256k1_ge_set_gej(&commit_points[i], &commitj);
1386 scratch_checkpoint = secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
1387 scratch_contains_secrets = 1;
1389 &ctx->error_callback,
1394 n_commits == 0 ? NULL : commit_points,
1395 n_commits == 0 ? NULL : blinds,
1406 if (scratch_contains_secrets) {
1409 if (blinds != NULL) {
1410 for (i = 0; i < n_commits; ++i) secp256k1_scalar_clear(&blinds[i]);
1413 free(commit_points);
1416 if (owns_resources) {
1425 const unsigned char* blinds32,
1426 const unsigned char value_gen33[33],
1427 const unsigned char nonce32[32],
1428 const unsigned char* extra_commit,
1429 size_t extra_commit_len,
1430 unsigned char* commitments_out33,
1431 unsigned char* proof_out,
1432 size_t* proof_len) {
1434 extra_commit, extra_commit_len, commitments_out33,
1435 proof_out, proof_len, 1, context, NULL);
1441 const unsigned char* blinds32,
1442 const unsigned char value_gen33[33],
1443 const unsigned char nonce32[32],
1444 const unsigned char* extra_commit,
1445 size_t extra_commit_len,
1446 unsigned char* commitments_out33,
1447 unsigned char* proof_out,
1448 size_t* proof_len) {
1450 extra_commit, extra_commit_len, commitments_out33,
1451 proof_out, proof_len, 1, NULL, resources);
1457 const unsigned char* blinds32,
1458 const unsigned char value_gen33[33],
1459 const unsigned char nonce32[32],
1460 const unsigned char* extra_commit,
1461 size_t extra_commit_len,
1462 unsigned char* commitments_out33,
1463 unsigned char* proof_out,
1464 size_t* proof_len) {
1466 extra_commit, extra_commit_len, commitments_out33,
1467 proof_out, proof_len, 0, context, NULL);
1473 const unsigned char* blinds32,
1474 const unsigned char value_gen33[33],
1475 const unsigned char nonce32[32],
1476 const unsigned char* extra_commit,
1477 size_t extra_commit_len,
1478 unsigned char* commitments_out33,
1479 unsigned char* proof_out,
1480 size_t* proof_len) {
1482 extra_commit, extra_commit_len, commitments_out33,
1483 proof_out, proof_len, 0, NULL, resources);
1489 const unsigned char* commitments33,
1490 const unsigned char value_gen33[33],
1491 const unsigned char* extra_commit,
1492 size_t extra_commit_len,
1493 const unsigned char* proof,
1498 const unsigned char* commitments33,
1499 const unsigned char value_gen33[33],
1500 const unsigned char* extra_commit,
1501 size_t extra_commit_len,
1502 const unsigned char* proof,
1505 extra_commit, extra_commit_len, proof, proof_len);
1511 const unsigned char* commitments33,
1512 const unsigned char value_gen33[33],
1513 const unsigned char* extra_commit,
1514 size_t extra_commit_len,
1515 const unsigned char* proof,
1517 secp256k1_context* ctx = NULL;
1518 secp256k1_scratch_space* scratch = NULL;
1521 secp256k1_ge value_gen;
1522 secp256k1_ge* commit_points = NULL;
1523 const secp256k1_ge* commit_ptr = NULL;
1525 const unsigned char* proof_ptr = NULL;
1526 const unsigned char* extra_commit_ptr = NULL;
1527 size_t n_commits = 0;
1528 size_t required_generators = 0;
1529 size_t commitment_bytes = 0;
1532 int owns_resources = 0;
1534 memset(&bp_circuit, 0,
sizeof(bp_circuit));
1535 if (circuit == NULL || value_gen33 == NULL || proof == NULL) {
1538 if (extra_commit == NULL && extra_commit_len != 0) {
1544 if (resources == NULL) {
1546 if (resources == NULL) {
1557 ctx = resources->
ctx;
1559 gens = resources->
gens;
1561 gens->
n < required_generators) {
1572 if (n_commits != 0) {
1573 if (commitments33 == NULL) {
1577 if (commit_points == NULL) {
1580 for (i = 0; i < n_commits; ++i) {
1585 commit_ptr = commit_points;
1588 circuit_ptr = &bp_circuit;
1590 extra_commit_ptr = extra_commit;
1592 &ctx->error_callback,
1597 n_commits == 0 ? NULL : &commit_ptr,
1598 n_commits == 0 ? NULL : &n_commits,
1607 free(commit_points);
1609 if (owns_resources) {
1617 const unsigned char* commitments33,
1618 const unsigned char value_gen33[33],
1619 const unsigned char* extra_commit,
1620 size_t extra_commit_len,
1621 const unsigned char* proof,
1624 extra_commit, extra_commit_len, proof, proof_len);
1628 const secp256k1_bppp_generators* gens_vec,
size_t g_len,
1629 const secp256k1_scalar* c_vec,
size_t c_vec_len) {
1630 static const unsigned char tag[] =
"Purify/BPPP/NormArg/PublicDataV1";
1631 unsigned char ser_point[33], ser_scalar[32], ser_le64[8];
1632 secp256k1_sha256 public_data;
1635 secp256k1_sha256_initialize_tagged(&public_data, tag,
sizeof(tag) - 1);
1636 secp256k1_scalar_get_b32(ser_scalar, rho);
1637 secp256k1_sha256_write(&public_data, ser_scalar,
sizeof(ser_scalar));
1638 secp256k1_bppp_le64(ser_le64, g_len);
1639 secp256k1_sha256_write(&public_data, ser_le64,
sizeof(ser_le64));
1640 secp256k1_bppp_le64(ser_le64, gens_vec->n);
1641 secp256k1_sha256_write(&public_data, ser_le64,
sizeof(ser_le64));
1642 for (i = 0; i < gens_vec->n; ++i) {
1643 secp256k1_ge gen = gens_vec->gens[i];
1645 secp256k1_sha256_clear(&public_data);
1648 secp256k1_sha256_write(&public_data, ser_point,
sizeof(ser_point));
1650 secp256k1_bppp_le64(ser_le64, c_vec_len);
1651 secp256k1_sha256_write(&public_data, ser_le64,
sizeof(ser_le64));
1652 for (i = 0; i < c_vec_len; ++i) {
1653 secp256k1_scalar_get_b32(ser_scalar, &c_vec[i]);
1654 secp256k1_sha256_write(&public_data, ser_scalar,
sizeof(ser_scalar));
1656 secp256k1_sha256_finalize(&public_data, digest);
1657 secp256k1_sha256_clear(&public_data);
1662 const secp256k1_bppp_generators* gens_vec,
size_t g_len,
1663 const secp256k1_scalar* c_vec,
size_t c_vec_len,
1664 const secp256k1_ge* commit) {
1665 static const unsigned char tag[] =
"Purify/BPPP/NormArg/TranscriptV1";
1666 unsigned char public_digest[32], ser_commit[33];
1667 secp256k1_ge comm = *commit;
1678 secp256k1_sha256_initialize_tagged(transcript, tag,
sizeof(tag) - 1);
1679 secp256k1_sha256_write(transcript, public_digest,
sizeof(public_digest));
1680 secp256k1_sha256_write(transcript, ser_commit,
sizeof(ser_commit));
1685 secp256k1_scalar** ns, secp256k1_scalar** ls, secp256k1_scalar** cs,
1686 secp256k1_ge** gs,
const secp256k1_scalar* n_vec,
1687 const secp256k1_scalar* l_vec,
const secp256k1_scalar* c_vec,
1688 const secp256k1_ge* gens_vec,
size_t g_len,
size_t h_len) {
1689 size_t scalar_g_bytes = 0;
1690 size_t scalar_h_bytes = 0;
1691 size_t ge_count = 0;
1692 size_t ge_bytes = 0;
1705 if (*ns == NULL || *ls == NULL || *cs == NULL || *gs == NULL) {
1708 memcpy(*ns, n_vec, scalar_g_bytes);
1709 memcpy(*ls, l_vec, scalar_h_bytes);
1710 memcpy(*cs, c_vec, scalar_h_bytes);
1711 memcpy(*gs, gens_vec, ge_bytes);
1730 secp256k1_fe_cmov(&r->x, &a->x, flag);
1731 secp256k1_fe_cmov(&r->y, &a->y, flag);
1732 r->infinity ^= (r->infinity ^ a->infinity) & flag;
1736 const secp256k1_ge* point,
1737 const secp256k1_scalar* scalar) {
1738 secp256k1_gej termj, candidate;
1740 int term_is_infinity;
1742 secp256k1_ecmult_const(&termj, point, scalar);
1743 secp256k1_ge_set_gej(&term, &termj);
1744 term_is_infinity = term.infinity;
1746 candidate = *accumulator;
1747 secp256k1_gej_add_ge(&candidate, &candidate, &term);
1748 secp256k1_gej_cmov(accumulator, &candidate,
1749 term_is_infinity ^ 1);
1757 secp256k1_gej* result,
1758 const secp256k1_scalar* base_scalar,
1759 secp256k1_ecmult_multi_callback callback,
1760 void* callback_data,
1761 size_t point_count) {
1764 if (base_scalar != NULL) {
1765 secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, result, base_scalar);
1767 secp256k1_gej_set_infinity(result);
1769 for (i = 0; i < point_count; ++i) {
1770 secp256k1_scalar scalar = {0};
1771 secp256k1_ge point = {0};
1772 int callback_ok = callback(&scalar, &point, i, callback_data);
1774 secp256k1_scalar_clear(&scalar);
1780 secp256k1_scalar_clear(&scalar);
1787 secp256k1_scalar* result,
1788 const secp256k1_scalar* lhs,
1790 const secp256k1_scalar* rhs,
1796 secp256k1_scalar_set_int(result, 0);
1797 for (i = 0; i < length; ++i) {
1798 secp256k1_scalar term;
1799 secp256k1_scalar_mul(
1800 &term, &lhs[lhs_offset + step * i],
1801 &rhs[rhs_offset + step * i]);
1802 secp256k1_scalar_add(result, result, &term);
1803 secp256k1_scalar_clear(&term);
1808 secp256k1_scalar* result,
1809 const secp256k1_scalar* lhs,
1811 const secp256k1_scalar* rhs,
1815 const secp256k1_scalar* weight) {
1816 secp256k1_scalar weight_power = *weight;
1819 secp256k1_scalar_set_int(result, 0);
1820 for (i = 0; i < length; ++i) {
1821 secp256k1_scalar term;
1822 secp256k1_scalar_mul(
1823 &term, &lhs[lhs_offset + step * i],
1824 &rhs[rhs_offset + step * i]);
1825 secp256k1_scalar_mul(&term, &term, &weight_power);
1826 secp256k1_scalar_mul(&weight_power, &weight_power, weight);
1827 secp256k1_scalar_add(result, result, &term);
1828 secp256k1_scalar_clear(&term);
1830 secp256k1_scalar_clear(&weight_power);
1834 secp256k1_ge* commit,
1835 const secp256k1_bppp_generators* generators,
1836 const secp256k1_scalar* n_vec,
1838 const secp256k1_scalar* l_vec,
1840 const secp256k1_scalar* c_vec,
1842 const secp256k1_scalar* mu) {
1843 secp256k1_scalar v, l_c;
1844 secp256k1_gej commitj;
1845 ecmult_bp_commit_cb_data data;
1849 VERIFY_CHECK(generators->n == n_vec_len + l_vec_len);
1850 VERIFY_CHECK(l_vec_len == c_vec_len);
1851 VERIFY_CHECK(secp256k1_is_power_of_two(n_vec_len));
1852 VERIFY_CHECK(secp256k1_is_power_of_two(c_vec_len));
1855 &v, n_vec, 0, n_vec, 0, 1, n_vec_len, mu);
1857 &l_c, l_vec, 0, c_vec, 0, 1, l_vec_len);
1858 secp256k1_scalar_add(&v, &v, &l_c);
1860 data.g = generators->gens;
1863 data.g_len = n_vec_len;
1865 ctx, &commitj, &v, ecmult_bp_commit_cb, &data,
1866 n_vec_len + l_vec_len);
1868 secp256k1_ge_set_gej(commit, &commitj);
1872 secp256k1_scalar_clear(&v);
1873 secp256k1_scalar_clear(&l_c);
1886 const secp256k1_context* ctx,
1887 unsigned char* proof,
1889 secp256k1_sha256* transcript,
1890 const secp256k1_scalar* rho,
1891 secp256k1_ge* g_vec,
1893 secp256k1_scalar* n_vec,
1895 secp256k1_scalar* l_vec,
1897 secp256k1_scalar* c_vec,
1900 void* callback_data) {
1901 secp256k1_scalar mu_f, rho_f = *rho;
1902 size_t proof_idx = 0;
1903 ecmult_x_cb_data x_cb_data;
1904 ecmult_r_cb_data r_cb_data;
1905 size_t g_len = n_vec_len, h_len = l_vec_len;
1906 const size_t G_GENS_LEN = g_len;
1910 size_t log_g_len_ver, log_h_len_ver, num_rounds_ver;
1911 VERIFY_CHECK(g_len > 0 && h_len > 0);
1912 log_g_len_ver = secp256k1_bppp_log2(g_len);
1913 log_h_len_ver = secp256k1_bppp_log2(h_len);
1914 num_rounds_ver = log_g_len_ver > log_h_len_ver
1915 ? log_g_len_ver : log_h_len_ver;
1916 VERIFY_CHECK(*proof_len >= 65 * num_rounds_ver + 64);
1917 VERIFY_CHECK(g_vec_len == n_vec_len + l_vec_len);
1918 VERIFY_CHECK(l_vec_len == c_vec_len);
1919 VERIFY_CHECK(secp256k1_is_power_of_two(n_vec_len));
1920 VERIFY_CHECK(secp256k1_is_power_of_two(c_vec_len));
1927 x_cb_data.n = n_vec;
1928 x_cb_data.g = g_vec;
1929 x_cb_data.l = l_vec;
1930 x_cb_data.G_GENS_LEN = G_GENS_LEN;
1931 r_cb_data.n1 = n_vec;
1932 r_cb_data.g1 = g_vec;
1933 r_cb_data.l1 = l_vec;
1934 r_cb_data.G_GENS_LEN = G_GENS_LEN;
1935 secp256k1_scalar_sqr(&mu_f, &rho_f);
1937 while (g_len > 1 || h_len > 1) {
1938 size_t i, num_points;
1939 secp256k1_scalar mu_sq, rho_inv, c0_l1, c1_l0;
1940 secp256k1_scalar x_v, c1_l1, r_v, gamma;
1941 secp256k1_gej rj, xj;
1942 secp256k1_ge r_ge, x_ge;
1946 secp256k1_scalar_inverse_var(&rho_inv, &rho_f);
1947 secp256k1_scalar_sqr(&mu_sq, &mu_f);
1949 &c0_l1, c_vec, 0, l_vec, 1, 2, h_len / 2);
1951 &c1_l0, c_vec, 1, l_vec, 0, 2, h_len / 2);
1953 &x_v, n_vec, 0, n_vec, 1, 2, g_len / 2, &mu_sq);
1954 secp256k1_scalar_mul(&x_v, &x_v, &rho_inv);
1955 secp256k1_scalar_add(&x_v, &x_v, &x_v);
1956 secp256k1_scalar_add(&x_v, &x_v, &c0_l1);
1957 secp256k1_scalar_add(&x_v, &x_v, &c1_l0);
1959 x_cb_data.rho = &rho_f;
1960 x_cb_data.rho_inv = &rho_inv;
1961 x_cb_data.n_len = g_len >= 2 ? g_len : 0;
1962 num_points = x_cb_data.n_len + (h_len >= 2 ? h_len : 0);
1964 ctx, &xj, &x_v, ecmult_x_cb, &x_cb_data, num_points);
1970 &r_v, n_vec, 1, n_vec, 1, 2, g_len / 2, &mu_sq);
1972 &c1_l1, c_vec, 1, l_vec, 1, 2, h_len / 2);
1973 secp256k1_scalar_add(&r_v, &r_v, &c1_l1);
1975 r_cb_data.n_len = g_len / 2;
1976 num_points = r_cb_data.n_len + h_len / 2;
1978 ctx, &rj, &r_v, ecmult_r_cb, &r_cb_data, num_points);
1984 secp256k1_ge_set_gej(&x_ge, &xj);
1985 secp256k1_ge_set_gej(&r_ge, &rj);
1986 secp256k1_fe_normalize(&x_ge.x);
1987 secp256k1_fe_normalize(&x_ge.y);
1988 secp256k1_fe_normalize(&r_ge.x);
1989 secp256k1_fe_normalize(&r_ge.y);
1992 secp256k1_bppp_serialize_points(
1993 &proof[proof_idx], &x_ge, &r_ge);
1995 if (challenge_callback != NULL) {
1996 unsigned char challenge32[32] = {0};
1997 const size_t round = proof_idx / 65u - 1u;
1998 ok = challenge_callback(callback_data, &proof[proof_idx - 65],
1999 round, challenge32);
2002 sizeof(challenge32));
2007 secp256k1_sha256_write(
2008 transcript, &proof[proof_idx - 65], 65);
2009 secp256k1_bppp_challenge_scalar(&gamma, transcript, 0);
2013 for (i = 0; i < g_len; i += 2) {
2014 secp256k1_scalar nl, nr;
2015 secp256k1_gej gl, gr;
2016 secp256k1_scalar_mul(&nl, &n_vec[i], &rho_inv);
2017 secp256k1_scalar_mul(&nr, &n_vec[i + 1], &gamma);
2018 secp256k1_scalar_add(&n_vec[i / 2], &nl, &nr);
2021 secp256k1_gej_set_ge(&gl, &g_vec[i]);
2022 secp256k1_ecmult(&gl, &gl, &rho_f, NULL);
2023 secp256k1_gej_set_ge(&gr, &g_vec[i + 1]);
2024 secp256k1_ecmult(&gr, &gr, &gamma, NULL);
2025 secp256k1_gej_add_var(&gl, &gl, &gr, NULL);
2026 secp256k1_ge_set_gej_var(&g_vec[i / 2], &gl);
2028 secp256k1_scalar_clear(&nl);
2029 secp256k1_scalar_clear(&nr);
2035 for (i = 0; i < h_len; i += 2) {
2036 secp256k1_scalar temporary;
2037 secp256k1_gej folded_generator;
2038 secp256k1_scalar_mul(
2039 &temporary, &c_vec[i + 1], &gamma);
2040 secp256k1_scalar_add(
2041 &c_vec[i / 2], &c_vec[i], &temporary);
2042 secp256k1_scalar_mul(
2043 &temporary, &l_vec[i + 1], &gamma);
2044 secp256k1_scalar_add(
2045 &l_vec[i / 2], &l_vec[i], &temporary);
2047 secp256k1_gej_set_ge(
2048 &folded_generator, &g_vec[G_GENS_LEN + i + 1]);
2050 &folded_generator, &folded_generator, &gamma, NULL);
2051 secp256k1_gej_add_ge_var(
2052 &folded_generator, &folded_generator,
2053 &g_vec[G_GENS_LEN + i], NULL);
2054 secp256k1_ge_set_gej_var(
2055 &g_vec[G_GENS_LEN + i / 2], &folded_generator);
2057 secp256k1_scalar_clear(&temporary);
2059 &folded_generator,
sizeof(folded_generator));
2067 secp256k1_scalar_clear(&mu_sq);
2068 secp256k1_scalar_clear(&rho_inv);
2069 secp256k1_scalar_clear(&c0_l1);
2070 secp256k1_scalar_clear(&c1_l0);
2071 secp256k1_scalar_clear(&x_v);
2072 secp256k1_scalar_clear(&c1_l1);
2073 secp256k1_scalar_clear(&r_v);
2074 secp256k1_scalar_clear(&gamma);
2082 secp256k1_scalar_clear(&mu_sq);
2083 secp256k1_scalar_clear(&rho_inv);
2084 secp256k1_scalar_clear(&c0_l1);
2085 secp256k1_scalar_clear(&c1_l0);
2086 secp256k1_scalar_clear(&x_v);
2087 secp256k1_scalar_clear(&c1_l1);
2088 secp256k1_scalar_clear(&r_v);
2089 secp256k1_scalar_clear(&gamma);
2094 secp256k1_scalar_clear(&mu_f);
2095 secp256k1_scalar_clear(&rho_f);
2101 secp256k1_scalar_get_b32(&proof[proof_idx], &n_vec[0]);
2102 secp256k1_scalar_get_b32(&proof[proof_idx + 32], &l_vec[0]);
2105 *proof_len = proof_idx;
2106 secp256k1_scalar_clear(&mu_f);
2107 secp256k1_scalar_clear(&rho_f);
2114 const secp256k1_context* ctx, secp256k1_scratch_space* scratch,
2115 unsigned char* proof,
size_t* proof_len,
2116 secp256k1_sha256* transcript,
const secp256k1_scalar* rho,
2117 const secp256k1_ge* g_vec,
size_t g_vec_len,
2118 const secp256k1_scalar* n_vec,
size_t n_vec_len,
2119 const secp256k1_scalar* l_vec,
size_t l_vec_len,
2120 const secp256k1_scalar* c_vec,
size_t c_vec_len,
2121 size_t secure_clear_checkpoint,
2123 void* callback_data) {
2124 secp256k1_scalar *ns = NULL, *ls = NULL, *cs = NULL;
2125 secp256k1_ge *gs = NULL;
2126 size_t checkpoint = secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
2129 if (
purify_copy_vectors_into_scratch(ctx, scratch, &ns, &ls, &cs, &gs, n_vec, l_vec, c_vec, g_vec, n_vec_len, l_vec_len)) {
2131 ctx, proof, proof_len, transcript, rho, gs, g_vec_len,
2132 ns, n_vec_len, ls, l_vec_len, cs, c_vec_len,
2133 challenge_callback, callback_data);
2140 secp256k1_scratch_apply_checkpoint(&ctx->error_callback, scratch, checkpoint);
2145 size_t log_g_len, log_h_len, max_log_len, proof_size = 0;
2146 if (n_vec_len == 0 || c_vec_len == 0 || n_vec_len < c_vec_len) {
2149 log_g_len = secp256k1_bppp_log2(n_vec_len);
2150 log_h_len = secp256k1_bppp_log2(c_vec_len);
2151 max_log_len = log_g_len > log_h_len ? log_g_len : log_h_len;
2161 secp256k1_generator generator;
2162 secp256k1_ge ge = secp256k1_ge_const_g;
2165 if (ctx == NULL || out33 == NULL) {
2168 secp256k1_generator_save(&generator, &ge);
2169 ok = secp256k1_generator_serialize(ctx, out33, &generator);
2177 if (ctx == NULL || out33 == NULL) {
2180 ok = secp256k1_generator_serialize(ctx, out33, secp256k1_generator_h);
2186 secp256k1_bppp_generators* gens = NULL;
2187 size_t required = 0;
2190 if (ctx == NULL || out_len == NULL) {
2197 if (*out_len < required || out == NULL) {
2198 *out_len = required;
2201 gens = secp256k1_bppp_generators_create(ctx, count);
2205 ok = secp256k1_bppp_generators_serialize(ctx, gens, out, out_len);
2206 secp256k1_bppp_generators_destroy(ctx, gens);
2212 const unsigned char generator33[33],
2213 const unsigned char scalar32[32],
2214 unsigned char out33[33]) {
2216 secp256k1_generator generator = {{0}}, result_generator = {{0}};
2217 secp256k1_scalar scalar = {0};
2218 secp256k1_ge generator_ge = {0}, result_ge = {0};
2219 secp256k1_gej result_j = {0};
2222 if (ctx == NULL || generator33 == NULL || scalar32 == NULL || out33 == NULL) {
2225 if (!secp256k1_generator_parse(ctx, &generator, generator33) ||
2229 secp256k1_generator_load(&generator_ge, &generator);
2230 secp256k1_ecmult_const(&result_j, &generator_ge, &scalar);
2231 if (secp256k1_gej_is_infinity(&result_j)) {
2234 secp256k1_ge_set_gej(&result_ge, &result_j);
2235 secp256k1_generator_save(&result_generator, &result_ge);
2236 ok = secp256k1_generator_serialize(ctx, out33, &result_generator);
2239 if (!ok && out33 != NULL) {
2240 memset(out33, 0, 33);
2242 secp256k1_scalar_clear(&scalar);
2243 secp256k1_ge_clear(&generator_ge);
2244 secp256k1_ge_clear(&result_ge);
2245 secp256k1_gej_clear(&result_j);
2246 secp256k1_memclear_explicit(&generator,
sizeof(generator));
2247 secp256k1_memclear_explicit(&result_generator,
2248 sizeof(result_generator));
2253 const unsigned char generator33[33],
2254 unsigned char out33[33]) {
2256 secp256k1_generator generator;
2257 secp256k1_ge generator_ge;
2259 if (ctx == NULL || generator33 == NULL || out33 == NULL) {
2262 if (!secp256k1_generator_parse(ctx, &generator, generator33)) {
2265 secp256k1_generator_load(&generator_ge, &generator);
2270 const unsigned char blind32[32],
const unsigned char value32[32],
2271 const unsigned char value_gen33[33],
const unsigned char blind_gen33[33],
2272 unsigned char commitment_out33[33]) {
2274 secp256k1_scalar blind_scalar = {0}, value_scalar = {0};
2275 secp256k1_generator value_generator, blind_generator;
2276 secp256k1_ge value_ge, blind_ge, commit_ge;
2277 secp256k1_gej total;
2280 if (ctx == NULL || blind32 == NULL || value32 == NULL || value_gen33 == NULL || blind_gen33 == NULL || commitment_out33 == NULL) {
2287 if (!secp256k1_generator_parse(ctx, &value_generator, value_gen33) || !secp256k1_generator_parse(ctx, &blind_generator, blind_gen33)) {
2290 secp256k1_generator_load(&value_ge, &value_generator);
2291 secp256k1_generator_load(&blind_ge, &blind_generator);
2292 secp256k1_gej_set_infinity(&total);
2295 secp256k1_ge_set_gej(&commit_ge, &total);
2297 if (!commit_ge.infinity) {
2302 secp256k1_scalar_clear(&blind_scalar);
2303 secp256k1_scalar_clear(&value_scalar);
2313 const unsigned char rho32[32],
const unsigned char* generators33,
2314 size_t generators_count,
const unsigned char* n_vec32,
size_t n_vec_len,
2315 const unsigned char* l_vec32,
size_t l_vec_len,
2316 const unsigned char* c_vec32,
size_t c_vec_len,
2317 unsigned char commitment_out33[33]) {
2319 secp256k1_scratch_space* scratch = resources != NULL ? resources->
scratch : NULL;
2320 secp256k1_bppp_generators* gens = resources != NULL ? resources->
gens : NULL;
2321 secp256k1_scalar rho = {0}, mu = {0};
2322 secp256k1_scalar *n_vec = NULL, *l_vec = NULL, *c_vec = NULL;
2323 secp256k1_ge commit;
2324 size_t expected_generators = 0;
2325 size_t serialized_generators_len = 0;
2326 size_t scratch_checkpoint = 0;
2328 int scratch_contains_secrets = 0;
2330 if (ctx == NULL || rho32 == NULL || (resources == NULL && generators33 == NULL) || n_vec32 == NULL || l_vec32 == NULL || c_vec32 == NULL ||
2331 commitment_out33 == NULL) {
2334 if (n_vec_len == 0 || l_vec_len == 0 || c_vec_len == 0 || l_vec_len != c_vec_len) {
2337 if (!secp256k1_is_power_of_two(n_vec_len) || !secp256k1_is_power_of_two(c_vec_len) ||
2339 generators_count != expected_generators ||
2343 if (resources != NULL && resources->
generators_count != generators_count) {
2349 if (resources == NULL) {
2351 gens = secp256k1_bppp_generators_parse(ctx, generators33, serialized_generators_len);
2356 if (scratch == NULL || gens == NULL || n_vec == NULL || l_vec == NULL || c_vec == NULL) {
2364 scratch_checkpoint = secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
2365 scratch_contains_secrets = 1;
2366 secp256k1_scalar_sqr(&mu, &rho);
2368 l_vec, l_vec_len, c_vec, c_vec_len, &mu)) {
2377 if (scratch_contains_secrets) {
2380 secp256k1_scalar_clear(&rho);
2381 secp256k1_scalar_clear(&mu);
2383 if (resources == NULL) {
2384 if (gens != NULL) secp256k1_bppp_generators_destroy(ctx, gens);
2385 if (scratch != NULL) secp256k1_scratch_space_destroy(ctx, scratch);
2391 const unsigned char rho32[32],
const unsigned char* generators33,
size_t generators_count,
2392 const unsigned char* n_vec32,
size_t n_vec_len,
const unsigned char* l_vec32,
2393 size_t l_vec_len,
const unsigned char* c_vec32,
size_t c_vec_len,
2394 unsigned char commitment_out33[33]) {
2396 l_vec32, l_vec_len, c_vec32, c_vec_len, commitment_out33);
2400 const unsigned char rho32[32],
2401 const unsigned char* n_vec32,
size_t n_vec_len,
2402 const unsigned char* l_vec32,
size_t l_vec_len,
2403 const unsigned char* c_vec32,
size_t c_vec_len,
2404 unsigned char commitment_out33[33]) {
2407 n_vec32, n_vec_len, l_vec32, l_vec_len, c_vec32, c_vec_len,
2413 const unsigned char* generators33,
size_t generators_count,
2414 const unsigned char* n_vec32,
size_t n_vec_len,
2415 const unsigned char* l_vec32,
size_t l_vec_len,
2416 unsigned char commitment_out33[33]) {
2418 secp256k1_scratch_space* scratch = resources != NULL ? resources->
scratch : NULL;
2419 secp256k1_bppp_generators* gens = resources != NULL ? resources->
gens : NULL;
2420 secp256k1_scalar zero = {0};
2421 secp256k1_scalar *n_vec = NULL, *l_vec = NULL;
2422 secp256k1_ge commit;
2423 secp256k1_gej commitj;
2424 ecmult_bp_commit_cb_data data;
2425 size_t expected_generators = 0;
2426 size_t serialized_generators_len = 0;
2427 size_t scratch_checkpoint = 0;
2429 int scratch_contains_secrets = 0;
2431 if (ctx == NULL || (resources == NULL && generators33 == NULL) || n_vec32 == NULL || l_vec32 == NULL || commitment_out33 == NULL) {
2434 if (n_vec_len == 0 || l_vec_len == 0 ||
2436 generators_count != expected_generators ||
2440 if (resources != NULL && resources->
generators_count != generators_count) {
2444 if (resources == NULL) {
2446 gens = secp256k1_bppp_generators_parse(ctx, generators33, serialized_generators_len);
2450 if (scratch == NULL || gens == NULL || n_vec == NULL || l_vec == NULL) {
2458 scratch_checkpoint = secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
2459 scratch_contains_secrets = 1;
2460 secp256k1_scalar_set_int(&zero, 0);
2461 data.g = gens->gens;
2464 data.g_len = n_vec_len;
2466 ecmult_bp_commit_cb, &data,
2467 expected_generators)) {
2471 sizeof(commitj.infinity));
2472 if (secp256k1_gej_is_infinity(&commitj)) {
2475 secp256k1_ge_set_gej(&commit, &commitj);
2482 if (scratch_contains_secrets) {
2485 secp256k1_scalar_clear(&zero);
2489 if (resources == NULL) {
2490 if (gens != NULL) secp256k1_bppp_generators_destroy(ctx, gens);
2491 if (scratch != NULL) secp256k1_scratch_space_destroy(ctx, scratch);
2497 const unsigned char* generators33,
size_t generators_count,
2498 const unsigned char* n_vec32,
size_t n_vec_len,
const unsigned char* l_vec32,
2499 size_t l_vec_len,
unsigned char commitment_out33[33]) {
2501 n_vec32, n_vec_len, l_vec32, l_vec_len, commitment_out33);
2505 const unsigned char* n_vec32,
size_t n_vec_len,
2506 const unsigned char* l_vec32,
size_t l_vec_len,
2507 unsigned char commitment_out33[33]) {
2510 n_vec32, n_vec_len, l_vec32, l_vec_len, commitment_out33);
2514 const unsigned char commitment33[33],
const unsigned char scalar32[32],
2515 unsigned char commitment_out33[33]) {
2517 secp256k1_scalar scalar = {0};
2518 secp256k1_ge commitment_ge, result_ge;
2519 secp256k1_gej result_j;
2522 if (ctx == NULL || commitment33 == NULL || scalar32 == NULL || commitment_out33 == NULL) {
2531 secp256k1_gej_set_ge(&result_j, &commitment_ge);
2533 &result_j, &secp256k1_ge_const_g, &scalar);
2534 secp256k1_ge_set_gej(&result_ge, &result_j);
2536 if (!result_ge.infinity) {
2541 secp256k1_scalar_clear(&scalar);
2549 const unsigned char point33[33],
const unsigned char scalar32[32],
2550 unsigned char out33[33]) {
2552 secp256k1_scalar scalar = {0};
2553 secp256k1_ge point_ge, result_ge;
2554 secp256k1_gej result_j;
2557 if (ctx == NULL || point33 == NULL || scalar32 == NULL || out33 == NULL) {
2566 secp256k1_ecmult_const(&result_j, &point_ge, &scalar);
2567 secp256k1_ge_set_gej(&result_ge, &result_j);
2569 if (!result_ge.infinity) {
2574 secp256k1_scalar_clear(&scalar);
2582 const unsigned char lhs33[33],
const unsigned char rhs33[33],
2583 unsigned char out33[33]) {
2585 secp256k1_ge lhs_ge, rhs_ge, result_ge;
2586 secp256k1_gej lhs_j, result_j;
2589 if (ctx == NULL || lhs33 == NULL || rhs33 == NULL || out33 == NULL) {
2597 secp256k1_gej_set_ge(&lhs_j, &lhs_ge);
2598 secp256k1_gej_add_ge_var(&result_j, &lhs_j, &rhs_ge, NULL);
2599 if (!secp256k1_gej_is_infinity(&result_j)) {
2600 secp256k1_ge_set_gej(&result_ge, &result_j);
2608 const unsigned char rhs33[33],
unsigned char out33[33]) {
2610 secp256k1_ge lhs_ge, rhs_ge, result_ge;
2611 secp256k1_gej lhs_j, rhs_j, result_j;
2612 static const unsigned char infinity33[33] = {0};
2617 if (ctx == NULL || lhs33 == NULL || rhs33 == NULL || out33 == NULL) {
2628 secp256k1_gej_set_infinity(&lhs_j);
2630 secp256k1_gej_set_ge(&lhs_j, &lhs_ge);
2633 secp256k1_gej_set_infinity(&rhs_j);
2635 secp256k1_gej_set_ge(&rhs_j, &rhs_ge);
2637 secp256k1_gej_add_var(&result_j, &lhs_j, &rhs_j, NULL);
2638 if (secp256k1_gej_is_infinity(&result_j)) {
2641 secp256k1_ge_set_gej(&result_ge, &result_j);
2657 const unsigned char rhs33[33],
unsigned char out33[33]) {
2659 secp256k1_ge lhs_ge, rhs_ge, result_ge;
2660 secp256k1_gej lhs_j, result_j;
2663 if (ctx == NULL || lhs33 == NULL || rhs33 == NULL || out33 == NULL) {
2672 secp256k1_ge_neg(&rhs_ge, &rhs_ge);
2673 secp256k1_gej_set_ge(&lhs_j, &lhs_ge);
2674 secp256k1_gej_add_ge_var(&result_j, &lhs_j, &rhs_ge, NULL);
2675 if (secp256k1_gej_is_infinity(&result_j)) {
2678 secp256k1_ge_set_gej(&result_ge, &result_j);
2693 const unsigned char rho32[32],
const unsigned char* generators33,
2694 size_t generators_count,
const unsigned char* n_vec32,
size_t n_vec_len,
2695 const unsigned char* l_vec32,
size_t l_vec_len,
2696 const unsigned char* c_vec32,
size_t c_vec_len,
2697 unsigned char commitment_out33[33],
unsigned char* proof_out,
2698 size_t* proof_len) {
2700 secp256k1_scratch_space* scratch = resources != NULL ? resources->
scratch : NULL;
2701 secp256k1_bppp_generators* gens = NULL;
2702 secp256k1_scalar rho = {0}, mu = {0};
2703 secp256k1_scalar *n_vec = NULL, *l_vec = NULL, *c_vec = NULL;
2704 secp256k1_ge commit;
2705 secp256k1_sha256 transcript;
2707 size_t expected_generators = 0;
2708 size_t serialized_generators_len = 0;
2709 size_t scratch_checkpoint = 0;
2711 int scratch_contains_secrets = 0;
2712 int scratch_tail_cleared = 0;
2715 if (ctx == NULL || rho32 == NULL || (resources == NULL && generators33 == NULL) || n_vec32 == NULL || l_vec32 == NULL || c_vec32 == NULL ||
2716 commitment_out33 == NULL || proof_out == NULL || proof_len == NULL) {
2719 if (n_vec_len == 0 || l_vec_len == 0 || c_vec_len == 0 || l_vec_len != c_vec_len ||
2720 n_vec_len < c_vec_len) {
2723 if (!secp256k1_is_power_of_two(n_vec_len) || !secp256k1_is_power_of_two(c_vec_len) ||
2725 generators_count != expected_generators ||
2729 if (resources != NULL && resources->
generators_count != generators_count) {
2732 if (*proof_len < required) {
2733 *proof_len = required;
2739 if (resources != NULL) {
2746 gens = secp256k1_bppp_generators_parse(ctx, generators33, serialized_generators_len);
2751 if (scratch == NULL || gens == NULL || n_vec == NULL || l_vec == NULL || c_vec == NULL) {
2759 scratch_checkpoint = secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
2760 scratch_contains_secrets = 1;
2761 secp256k1_scalar_sqr(&mu, &rho);
2763 l_vec, l_vec_len, c_vec, c_vec_len, &mu)) {
2773 ctx, scratch, proof_out, proof_len, &transcript, &rho, gens->gens,
2774 gens->n, n_vec, n_vec_len, l_vec, l_vec_len, c_vec, c_vec_len,
2775 scratch_checkpoint, NULL, NULL);
2776 scratch_tail_cleared = 1;
2782 if (scratch_contains_secrets && !scratch_tail_cleared) {
2785 secp256k1_scalar_clear(&rho);
2786 secp256k1_scalar_clear(&mu);
2790 if (resources == NULL) {
2791 if (gens != NULL) secp256k1_bppp_generators_destroy(ctx, gens);
2792 if (scratch != NULL) secp256k1_scratch_space_destroy(ctx, scratch);
2798 const unsigned char rho32[32],
const unsigned char* generators33,
size_t generators_count,
2799 const unsigned char* n_vec32,
size_t n_vec_len,
const unsigned char* l_vec32,
2800 size_t l_vec_len,
const unsigned char* c_vec32,
size_t c_vec_len,
2801 unsigned char commitment_out33[33],
unsigned char* proof_out,
size_t* proof_len) {
2803 l_vec32, l_vec_len, c_vec32, c_vec_len, commitment_out33,
2804 proof_out, proof_len);
2808 const unsigned char rho32[32],
2809 const unsigned char* n_vec32,
size_t n_vec_len,
2810 const unsigned char* l_vec32,
size_t l_vec_len,
2811 const unsigned char* c_vec32,
size_t c_vec_len,
2812 unsigned char commitment_out33[33],
unsigned char* proof_out,
2813 size_t* proof_len) {
2816 n_vec32, n_vec_len, l_vec32, l_vec_len, c_vec32, c_vec_len,
2817 commitment_out33, proof_out, proof_len);
2822 const unsigned char rho32[32],
const unsigned char* generators33,
2823 size_t generators_count,
const unsigned char* n_vec32,
2824 size_t n_vec_len,
const unsigned char* l_vec32,
2825 size_t l_vec_len,
const unsigned char* c_vec32,
2826 size_t c_vec_len,
const unsigned char commitment33[33],
2827 unsigned char* proof_out,
size_t* proof_len,
2829 void* callback_data) {
2831 secp256k1_scratch_space* scratch = resources != NULL ? resources->
scratch : NULL;
2832 secp256k1_bppp_generators* gens = NULL;
2833 secp256k1_scalar rho = {0}, mu = {0};
2834 secp256k1_scalar *n_vec = NULL, *l_vec = NULL, *c_vec = NULL;
2835 secp256k1_ge expected_commit, commitment_ge;
2836 secp256k1_sha256 transcript;
2837 unsigned char expected_commitment33[33];
2839 size_t expected_generators = 0;
2840 size_t serialized_generators_len = 0;
2841 size_t scratch_checkpoint = 0;
2843 int scratch_contains_secrets = 0;
2844 int scratch_tail_cleared = 0;
2847 memset(expected_commitment33, 0,
sizeof(expected_commitment33));
2848 if (ctx == NULL || rho32 == NULL || (resources == NULL && generators33 == NULL) || n_vec32 == NULL || l_vec32 == NULL || c_vec32 == NULL ||
2849 commitment33 == NULL || proof_out == NULL || proof_len == NULL) {
2852 if (n_vec_len == 0 || l_vec_len == 0 || c_vec_len == 0 || l_vec_len != c_vec_len ||
2853 n_vec_len < c_vec_len) {
2856 if (!secp256k1_is_power_of_two(n_vec_len) || !secp256k1_is_power_of_two(c_vec_len) ||
2858 generators_count != expected_generators ||
2862 if (resources != NULL && resources->
generators_count != generators_count) {
2865 if (*proof_len < required) {
2866 *proof_len = required;
2872 if (resources != NULL) {
2879 gens = secp256k1_bppp_generators_parse(ctx, generators33, serialized_generators_len);
2884 if (scratch == NULL || gens == NULL || n_vec == NULL || l_vec == NULL || c_vec == NULL) {
2892 scratch_checkpoint = secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
2893 scratch_contains_secrets = 1;
2894 secp256k1_scalar_sqr(&mu, &rho);
2896 n_vec_len, l_vec, l_vec_len, c_vec,
2904 sizeof(expected_commitment33))) {
2911 ctx, scratch, proof_out, proof_len, &transcript, &rho, gens->gens,
2912 gens->n, n_vec, n_vec_len, l_vec, l_vec_len, c_vec, c_vec_len,
2913 scratch_checkpoint, challenge_callback, callback_data);
2914 scratch_tail_cleared = 1;
2920 if (scratch_contains_secrets && !scratch_tail_cleared) {
2923 secp256k1_scalar_clear(&rho);
2924 secp256k1_scalar_clear(&mu);
2928 sizeof(expected_commitment33));
2931 if (resources == NULL) {
2932 if (gens != NULL) secp256k1_bppp_generators_destroy(ctx, gens);
2933 if (scratch != NULL) secp256k1_scratch_space_destroy(ctx, scratch);
2939 const unsigned char rho32[32],
const unsigned char* generators33,
size_t generators_count,
2940 const unsigned char* n_vec32,
size_t n_vec_len,
const unsigned char* l_vec32,
2941 size_t l_vec_len,
const unsigned char* c_vec32,
size_t c_vec_len,
2942 const unsigned char commitment33[33],
unsigned char* proof_out,
size_t* proof_len) {
2944 n_vec32, n_vec_len, l_vec32, l_vec_len, c_vec32, c_vec_len,
2945 commitment33, proof_out, proof_len, NULL, NULL);
2949 const unsigned char rho32[32],
2950 const unsigned char* n_vec32,
size_t n_vec_len,
2951 const unsigned char* l_vec32,
size_t l_vec_len,
2952 const unsigned char* c_vec32,
size_t c_vec_len,
2953 const unsigned char commitment33[33],
2954 unsigned char* proof_out,
size_t* proof_len) {
2957 n_vec32, n_vec_len, l_vec32, l_vec_len, c_vec32, c_vec_len,
2958 commitment33, proof_out, proof_len, NULL, NULL);
2963 const unsigned char rho32[32],
2964 const unsigned char* generators33,
2965 size_t generators_count,
2966 const unsigned char* n_vec32,
2968 const unsigned char* l_vec32,
2970 const unsigned char* c_vec32,
2972 const unsigned char commitment33[33],
2974 void* callback_data,
2975 unsigned char* proof_out,
2976 size_t* proof_len) {
2977 if (challenge_callback == NULL) {
2981 context, NULL, rho32, generators33, generators_count,
2982 n_vec32, n_vec_len, l_vec32, l_vec_len, c_vec32, c_vec_len,
2983 commitment33, proof_out, proof_len, challenge_callback,
2988 const secp256k1_context* ctx,
2989 secp256k1_scratch_space* scratch,
2990 const unsigned char* proof,
2992 const secp256k1_scalar* rho,
2993 const secp256k1_bppp_generators* g_vec,
2995 const secp256k1_scalar* c_vec,
2997 const secp256k1_ge* commit,
2998 const secp256k1_scalar* gammas,
2999 size_t gamma_count) {
3000 secp256k1_scalar rho_f, mu_f, v, n, l, rho_inv, h_c;
3001 secp256k1_scalar *s_g, *s_h, *rho_inv_pows;
3002 secp256k1_gej res1, res2;
3003 size_t i = 0, scratch_checkpoint;
3005 size_t log_g_len, log_h_len, n_rounds;
3006 size_t h_len = c_vec_len;
3009 if (g_len == 0 || c_vec_len == 0) {
3012 log_g_len = secp256k1_bppp_log2(g_len);
3013 log_h_len = secp256k1_bppp_log2(c_vec_len);
3014 n_rounds = log_g_len > log_h_len ? log_g_len : log_h_len;
3015 if (g_vec->n != h_len + g_len ||
3016 proof_len != 65u * n_rounds + 64u ||
3017 gamma_count != n_rounds ||
3018 (gamma_count != 0 && gammas == NULL) ||
3019 !secp256k1_is_power_of_two(g_len) ||
3020 !secp256k1_is_power_of_two(h_len)) {
3024 secp256k1_scalar_set_b32(&n, &proof[n_rounds * 65u], &overflow);
3028 secp256k1_scalar_set_b32(&l, &proof[n_rounds * 65u + 32u], &overflow);
3029 if (overflow || secp256k1_scalar_is_zero(rho)) {
3033 scratch_checkpoint =
3034 secp256k1_scratch_checkpoint(&ctx->error_callback, scratch);
3036 &ctx->error_callback, scratch, g_len *
sizeof(*s_g));
3038 &ctx->error_callback, scratch, h_len *
sizeof(*s_h));
3040 &ctx->error_callback, scratch,
3041 log_g_len *
sizeof(*rho_inv_pows));
3042 if (s_g == NULL || s_h == NULL || rho_inv_pows == NULL) {
3046 secp256k1_scalar_inverse_var(&rho_inv, rho);
3047 secp256k1_bppp_powers_of_rho(rho_inv_pows, &rho_inv, log_g_len);
3049 for (i = 0; i < log_g_len; ++i) {
3050 secp256k1_scalar_sqr(&rho_f, &rho_f);
3053 secp256k1_scalar_mul(&s_g[0], &n, &rho_f);
3054 secp256k1_scalar_mul(&s_g[0], &s_g[0], &rho_inv);
3055 for (i = 1; i < g_len; ++i) {
3056 const size_t log_i = secp256k1_bppp_log2(i);
3057 const size_t nearest_pow_of_two = (size_t)1 << log_i;
3058 secp256k1_scalar_mul(&s_g[i],
3059 &s_g[i - nearest_pow_of_two],
3061 secp256k1_scalar_mul(&s_g[i], &s_g[i], &rho_inv_pows[log_i]);
3064 secp256k1_scalar_set_int(&h_c, 0);
3065 for (i = 1; i < h_len; ++i) {
3066 const size_t log_i = secp256k1_bppp_log2(i);
3067 const size_t nearest_pow_of_two = (size_t)1 << log_i;
3068 secp256k1_scalar_mul(&s_h[i],
3069 &s_h[i - nearest_pow_of_two],
3072 secp256k1_scalar_inner_product(&h_c, c_vec, 0, s_h, 0, 1, h_len);
3073 secp256k1_scalar_sqr(&mu_f, &rho_f);
3074 secp256k1_scalar_mul(&v, &n, &n);
3075 secp256k1_scalar_mul(&v, &v, &mu_f);
3076 secp256k1_scalar_add(&v, &v, &h_c);
3079 ec_mult_verify_cb_data1 data;
3081 data.commit = commit;
3082 data.gammas = gammas;
3083 if (!secp256k1_ecmult_multi_var(
3084 &ctx->error_callback, scratch, &res1, NULL,
3085 ec_mult_verify_cb1, &data, 2u * n_rounds + 1u)) {
3090 ec_mult_verify_cb_data2 data;
3091 data.g_vec = g_vec->gens;
3092 data.g_vec_len = g_len;
3095 if (!secp256k1_ecmult_multi_var(
3096 &ctx->error_callback, scratch, &res2, &v,
3097 ec_mult_verify_cb2, &data, g_len + h_len)) {
3101 ok = secp256k1_gej_eq_var(&res1, &res2);
3104 secp256k1_scratch_apply_checkpoint(
3105 &ctx->error_callback, scratch, scratch_checkpoint);
3111 const unsigned char rho32[32],
const unsigned char* generators33,
3112 size_t generators_count,
const unsigned char* c_vec32,
size_t c_vec_len,
3113 size_t n_vec_len,
const unsigned char commitment33[33],
3114 const unsigned char* proof,
size_t proof_len,
3115 const unsigned char* gammas32,
3116 size_t gamma_count) {
3118 secp256k1_scratch_space* scratch = resources != NULL ? resources->
scratch : NULL;
3119 secp256k1_bppp_generators* gens = resources != NULL ? resources->
gens : NULL;
3120 secp256k1_scalar rho, *c_vec = NULL, *gammas = NULL;
3121 secp256k1_ge commit;
3122 secp256k1_sha256 transcript;
3123 size_t expected_generators = 0;
3124 size_t serialized_generators_len = 0;
3127 if (ctx == NULL || rho32 == NULL || (resources == NULL && generators33 == NULL) || c_vec32 == NULL || commitment33 == NULL || proof == NULL) {
3132 if (n_vec_len == 0 || c_vec_len == 0 || n_vec_len < c_vec_len ||
3134 generators_count != expected_generators ||
3138 if (!secp256k1_is_power_of_two(n_vec_len) || !secp256k1_is_power_of_two(c_vec_len)) {
3141 if (resources != NULL && resources->
generators_count != generators_count) {
3144 if (!
purify_parse_scalar(rho32, &rho, 1) || !secp256k1_ge_parse_ext(&commit, commitment33)) {
3147 if (resources == NULL) {
3149 gens = secp256k1_bppp_generators_parse(ctx, generators33, serialized_generators_len);
3152 if (scratch == NULL || gens == NULL || c_vec == NULL) {
3158 if (gammas32 != NULL) {
3159 const size_t rounds = secp256k1_bppp_log2(n_vec_len);
3160 if (gamma_count != rounds) {
3164 gamma_count,
sizeof(*gammas));
3165 if ((gamma_count != 0 && gammas == NULL) ||
3169 for (
size_t i = 0; i < gamma_count; ++i) {
3170 if (secp256k1_scalar_is_zero(&gammas[i])) {
3175 ctx, scratch, proof, proof_len, &rho, gens, n_vec_len,
3176 c_vec, c_vec_len, &commit, gammas, gamma_count);
3178 if (gamma_count != 0 ||
3180 &transcript, &rho, gens, n_vec_len, c_vec, c_vec_len,
3184 ok = secp256k1_bppp_rangeproof_norm_product_verify(
3185 ctx, scratch, proof, proof_len, &transcript, &rho,
3186 gens, n_vec_len, c_vec, c_vec_len, &commit);
3191 if (c_vec != NULL) free(c_vec);
3192 if (resources == NULL) {
3193 if (gens != NULL) secp256k1_bppp_generators_destroy(ctx, gens);
3194 if (scratch != NULL) secp256k1_scratch_space_destroy(ctx, scratch);
3200 const unsigned char rho32[32],
const unsigned char* generators33,
size_t generators_count,
3201 const unsigned char* c_vec32,
size_t c_vec_len,
size_t n_vec_len,
3202 const unsigned char commitment33[33],
const unsigned char* proof,
size_t proof_len) {
3204 c_vec32, c_vec_len, n_vec_len, commitment33, proof, proof_len,
3209 const unsigned char rho32[32],
3210 const unsigned char* c_vec32,
size_t c_vec_len,
size_t n_vec_len,
3211 const unsigned char commitment33[33],
const unsigned char* proof,
3215 c_vec32, c_vec_len, n_vec_len, commitment33, proof, proof_len,
3221 const unsigned char rho32[32],
3222 const unsigned char* generators33,
3223 size_t generators_count,
3224 const unsigned char* c_vec32,
3227 const unsigned char commitment33[33],
3228 const unsigned char* proof,
3230 const unsigned char* gammas32,
3231 size_t gamma_count) {
3232 if (gammas32 == NULL) {
3236 context, NULL, rho32, generators33, generators_count,
3237 c_vec32, c_vec_len, n_vec_len, commitment33, proof, proof_len,
3238 gammas32, gamma_count);
3243 const unsigned char rho32[32],
3244 const unsigned char* generators33,
3245 size_t generators_count,
3246 const unsigned char* c_vec32,
3249 const unsigned char commitment33[33],
3250 const unsigned char* proof,
3252 const unsigned char* supplied_gammas32,
3253 unsigned char* derived_gammas32,
3255 unsigned char terminal_n32[32],
3256 unsigned char terminal_l32[32],
3257 unsigned char residual33[33]) {
3259 secp256k1_scratch_space* scratch = NULL;
3260 secp256k1_bppp_generators* gens = NULL;
3261 secp256k1_scalar rho, n, l, norm, *c_vec = NULL, *gammas = NULL;
3262 secp256k1_ge commit, residual;
3263 secp256k1_gej residual_j;
3264 secp256k1_sha256 transcript;
3265 ec_mult_verify_cb_data1 equation;
3266 size_t expected_generators, generator_bytes, rounds, i;
3269 if (ctx == NULL || rho32 == NULL || generators33 == NULL || c_vec32 == NULL ||
3270 commitment33 == NULL || proof == NULL || terminal_n32 == NULL ||
3271 terminal_l32 == NULL || residual33 == NULL ||
3272 (gamma_count != 0 && supplied_gammas32 == NULL &&
3273 derived_gammas32 == NULL)) {
3277 if (!secp256k1_is_power_of_two(n_vec_len) || !secp256k1_is_power_of_two(c_vec_len) ||
3278 n_vec_len < c_vec_len ||
3280 generators_count != expected_generators ||
3284 rounds = secp256k1_bppp_log2(n_vec_len);
3285 if (gamma_count != rounds || proof_len != 65u * rounds + 64u ||
3293 gens = secp256k1_bppp_generators_parse(ctx, generators33, generator_bytes);
3298 if (scratch == NULL || gens == NULL || c_vec == NULL ||
3299 (rounds != 0 && gammas == NULL) ||
3303 if (supplied_gammas32 != NULL) {
3305 supplied_gammas32, rounds, gammas)) {
3308 for (i = 0; i < rounds; ++i) {
3309 if (secp256k1_scalar_is_zero(&gammas[i])) {
3315 &transcript, &rho, gens, n_vec_len, c_vec, c_vec_len,
3319 for (i = 0; i < rounds; ++i) {
3320 secp256k1_sha256_write(&transcript, proof + 65u * i, 65u);
3321 secp256k1_bppp_challenge_scalar(&gammas[i], &transcript, 0);
3323 secp256k1_sha256_clear(&transcript);
3333 for (i = 0; i <= rounds; ++i) {
3334 secp256k1_scalar_sqr(&norm, &norm);
3336 secp256k1_scalar_mul(&norm, &norm, &n);
3337 secp256k1_scalar_mul(&norm, &norm, &n);
3338 secp256k1_scalar_negate(&norm, &norm);
3339 equation.proof = proof;
3340 equation.commit = &commit;
3341 equation.gammas = gammas;
3342 if (!secp256k1_ecmult_multi_var(&ctx->error_callback, scratch, &residual_j, &norm,
3343 ec_mult_verify_cb1, &equation, 2u * rounds + 1u)) {
3346 secp256k1_ge_set_gej_var(&residual, &residual_j);
3347 secp256k1_ge_serialize_ext(residual33, &residual);
3348 secp256k1_scalar_get_b32(terminal_n32, &n);
3349 secp256k1_scalar_get_b32(terminal_l32, &l);
3350 for (i = 0; derived_gammas32 != NULL && i < rounds; ++i) {
3351 secp256k1_scalar_get_b32(
3352 derived_gammas32 + 32u * i, &gammas[i]);
3359 if (gens != NULL) secp256k1_bppp_generators_destroy(ctx, gens);
3360 if (scratch != NULL) secp256k1_scratch_space_destroy(ctx, scratch);
3365 const unsigned char rho32[32],
3366 const unsigned char* generators33,
size_t generators_count,
3367 const unsigned char* c_vec32,
size_t c_vec_len,
size_t n_vec_len,
3368 const unsigned char commitment33[33],
3369 const unsigned char* proof,
size_t proof_len,
3370 unsigned char terminal_n32[32],
unsigned char terminal_l32[32],
3371 unsigned char* gammas32,
size_t gamma_count,
3372 unsigned char residual33[33]) {
3374 context, rho32, generators33, generators_count, c_vec32,
3375 c_vec_len, n_vec_len, commitment33, proof, proof_len, NULL,
3376 gammas32, gamma_count, terminal_n32, terminal_l32, residual33);
3381 const unsigned char rho32[32],
3382 const unsigned char* generators33,
3383 size_t generators_count,
3384 const unsigned char* c_vec32,
3387 const unsigned char commitment33[33],
3388 const unsigned char* proof,
3390 const unsigned char* gammas32,
3392 unsigned char terminal_n32[32],
3393 unsigned char terminal_l32[32],
3394 unsigned char residual33[33]) {
3395 if (gammas32 == NULL) {
3399 context, rho32, generators33, generators_count, c_vec32,
3400 c_vec_len, n_vec_len, commitment33, proof, proof_len,
3401 gammas32, NULL, gamma_count, terminal_n32, terminal_l32,
3406 const unsigned char* generators33,
size_t generators_count,
3407 unsigned char* points_out33) {
3411 if (ctx == NULL || generators33 == NULL || points_out33 == NULL || generators_count == 0 ||
3415 for (i = 0; i < generators_count; ++i) {
3431 size_t index,
void* data_ptr) {
3434 && secp256k1_ge_parse_ext(point, data->
points33 + 33u * index);
3438 const unsigned char* points33,
const unsigned char* scalars32,
3439 size_t count,
unsigned char out33[33]) {
3441 secp256k1_scratch_space* scratch = NULL;
3442 secp256k1_gej result_j;
3443 secp256k1_ge result;
3445 size_t point_bytes, scalar_bytes;
3448 if (ctx == NULL || out33 == NULL || (count != 0 && (points33 == NULL || scalars32 == NULL)) ||
3454 memset(out33, 0, 33);
3457 memset(out33, 0, 33);
3461 ok = secp256k1_ecmult_multi_var(&ctx->error_callback, NULL,
3466 scratch = secp256k1_scratch_space_create(
3468 if (scratch == NULL)
return 0;
3469 ok = secp256k1_ecmult_multi_var(
3470 &ctx->error_callback, scratch, &result_j, NULL,
3474 secp256k1_ge_set_gej_var(&result, &result_j);
3475 secp256k1_ge_serialize_ext(out33, &result);
3477 if (scratch != NULL) {
3478 secp256k1_scratch_space_destroy(ctx, scratch);
3484 const unsigned char point33[33]) {
3486 unsigned char canonical[33];
3488 if (point33 == NULL ||
3489 !secp256k1_ge_parse_ext(&point, point33)) {
3492 secp256k1_ge_serialize_ext(canonical, &point);
3493 return memcmp(point33, canonical,
sizeof(canonical)) == 0;
3497 const unsigned char* input,
size_t input_len,
3498 unsigned char out33[33]) {
3499 static const unsigned char tag[] =
"Purify/BPPP/PublicHashToPointV1";
3501 secp256k1_sha256 transcript;
3502 secp256k1_generator generator;
3504 unsigned char seed[32];
3506 if (ctx == NULL || out33 == NULL || (input_len != 0 && input == NULL))
return 0;
3507 secp256k1_sha256_initialize_tagged(&transcript, tag,
sizeof(tag) - 1);
3508 if (input_len != 0) secp256k1_sha256_write(&transcript, input, input_len);
3509 secp256k1_sha256_finalize(&transcript, seed);
3510 secp256k1_sha256_clear(&transcript);
3511 if (!secp256k1_generator_generate(ctx, &generator, seed))
return 0;
3512 secp256k1_generator_load(&point, &generator);
static secp256k1_scalar * purify_scalar_cast(purify_scalar *scalar)
int purify_bppp_verify_norm_arg_with_challenges(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len, const unsigned char *gammas32, size_t gamma_count)
static int purify_bppp_rangeproof_norm_product_prove_secret(const secp256k1_context *ctx, unsigned char *proof, size_t *proof_len, secp256k1_sha256 *transcript, const secp256k1_scalar *rho, secp256k1_ge *g_vec, size_t g_vec_len, secp256k1_scalar *n_vec, size_t n_vec_len, secp256k1_scalar *l_vec, size_t l_vec_len, secp256k1_scalar *c_vec, size_t c_vec_len, purify_bppp_round_challenge_callback challenge_callback, void *callback_data)
static int purify_bulletproof_add_scratch_frame(size_t *total, size_t bytes, size_t objects)
int purify_bulletproof_prove_circuit_with_resources(purify_bulletproof_backend_resources *resources, const purify_bulletproof_circuit_view *circuit, const purify_bulletproof_assignment_view *assignment, const unsigned char *blinds32, const unsigned char value_gen33[33], const unsigned char nonce32[32], const unsigned char *extra_commit, size_t extra_commit_len, unsigned char *commitments_out33, unsigned char *proof_out, size_t *proof_len)
static void purify_bulletproof_circuit_evaluate_sum_row(secp256k1_scalar *acc, const secp256k1_bulletproof_wmatrix_row *row, const secp256k1_scalar *assn)
void purify_scalar_mul(purify_scalar *out, const purify_scalar *lhs, const purify_scalar *rhs)
Multiplies two scalars modulo the backend field.
int purify_bppp_prove_norm_arg_to_commitment_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, const unsigned char commitment33[33], unsigned char *proof_out, size_t *proof_len)
static int purify_ecmult_multi_secret(const secp256k1_context *ctx, secp256k1_gej *result, const secp256k1_scalar *base_scalar, secp256k1_ecmult_multi_callback callback, void *callback_data, size_t point_count)
static int purify_parse_scalar_array(const unsigned char *input32, size_t count, secp256k1_scalar *out)
static void purify_ge_cmov(secp256k1_ge *r, const secp256k1_ge *a, int flag)
static int purify_bppp_backend_resources_reset_scratch_gens(purify_bppp_backend_resources *resources)
static int purify_build_row_family(secp256k1_bulletproof_wmatrix_row *out_rows, size_t row_count, const purify_bulletproof_row_view *in_rows, size_t n_constraints, secp256k1_bulletproof_wmatrix_entry *entries, size_t *offset)
static void purify_scalar_inner_product_secret(secp256k1_scalar *result, const secp256k1_scalar *lhs, size_t lhs_offset, const secp256k1_scalar *rhs, size_t rhs_offset, size_t step, size_t length)
static secp256k1_bppp_generators * purify_bppp_backend_resources_acquire_scratch_gens(purify_bppp_backend_resources *resources, purify_bppp_mutable_generators_guard *guard)
static int purify_parse_scalar(const unsigned char input32[32], secp256k1_scalar *scalar, int reject_zero)
static int purify_build_bulletproof_assignment(const purify_bulletproof_assignment_view *view, secp256k1_bulletproof_circuit_assignment *out)
int purify_bppp_commit_witness_only_with_resources(purify_bppp_backend_resources *resources, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, unsigned char commitment_out33[33])
int purify_scalar_is_zero(const purify_scalar *value)
Returns nonzero when the scalar is zero.
int purify_bip340_xonly_from_point(purify_secp_context *context, const unsigned char point33[33], unsigned char xonly32[32], int *parity_out)
Converts a compressed secp256k1 point into its x-only public key encoding.
#define PURIFY_BRIDGE_DECLASSIFY(data, size)
static int purify_bulletproof_prove_circuit_impl(const purify_bulletproof_circuit_view *circuit, const purify_bulletproof_assignment_view *assignment, const unsigned char *blinds32, const unsigned char value_gen33[33], const unsigned char nonce32[32], const unsigned char *extra_commit, size_t extra_commit_len, unsigned char *commitments_out33, unsigned char *proof_out, size_t *proof_len, int require_valid_assignment, purify_secp_context *context, purify_bulletproof_backend_resources *resources)
int purify_point_subtract_allow_infinity(purify_secp_context *context, const unsigned char lhs33[33], const unsigned char rhs33[33], unsigned char out33[33])
int purify_bulletproof_verify_circuit(purify_secp_context *context, const purify_bulletproof_circuit_view *circuit, const unsigned char *commitments33, const unsigned char value_gen33[33], const unsigned char *extra_commit, size_t extra_commit_len, const unsigned char *proof, size_t proof_len)
int purify_bip340_key_from_seckey(purify_secp_context *context, unsigned char seckey32[32], unsigned char xonly_pubkey32[32])
Canonicalizes a valid secp256k1 secret key for BIP340 and derives its x-only public key.
static void purify_bridge_secure_free_array(void *data, size_t count, size_t elem_size)
int purify_scalar_add(purify_scalar *out, const purify_scalar *lhs, const purify_scalar *rhs)
Adds two scalars modulo the backend field.
int purify_bip340_nonce_from_scalar(purify_secp_context *context, unsigned char scalar32[32], unsigned char xonly_nonce32[32])
Canonicalizes a valid secp256k1 nonce scalar for BIP340 and derives its x-only public nonce.
int purify_point_scale(purify_secp_context *context, const unsigned char point33[33], const unsigned char scalar32[32], unsigned char out33[33])
void purify_scalar_set_int(purify_scalar *out, unsigned int value)
Initializes a scalar from an unsigned integer.
int purify_bulletproof_verify_circuit_with_resources(purify_bulletproof_backend_resources *resources, const purify_bulletproof_circuit_view *circuit, const unsigned char *commitments33, const unsigned char value_gen33[33], const unsigned char *extra_commit, size_t extra_commit_len, const unsigned char *proof, size_t proof_len)
void purify_scalar_cmov(purify_scalar *dst, const purify_scalar *src, int flag)
Conditionally assigns src into dst when flag is nonzero.
static int purify_bppp_rangeproof_norm_product_verify_challenges(const secp256k1_context *ctx, secp256k1_scratch_space *scratch, const unsigned char *proof, size_t proof_len, const secp256k1_scalar *rho, const secp256k1_bppp_generators *g_vec, size_t g_len, const secp256k1_scalar *c_vec, size_t c_vec_len, const secp256k1_ge *commit, const secp256k1_scalar *gammas, size_t gamma_count)
static int purify_copy_vectors_into_scratch(const secp256k1_context *ctx, secp256k1_scratch_space *scratch, secp256k1_scalar **ns, secp256k1_scalar **ls, secp256k1_scalar **cs, secp256k1_ge **gs, const secp256k1_scalar *n_vec, const secp256k1_scalar *l_vec, const secp256k1_scalar *c_vec, const secp256k1_ge *gens_vec, size_t g_len, size_t h_len)
static int purify_bridge_checked_mul_size(size_t lhs, size_t rhs, size_t *out)
static int purify_bulletproof_circuit_scratch_size(const secp256k1_bulletproof_circuit *circuit, size_t *out)
int purify_bppp_prove_norm_arg_to_commitment_with_callback(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, const unsigned char commitment33[33], purify_bppp_round_challenge_callback challenge_callback, void *callback_data, unsigned char *proof_out, size_t *proof_len)
int purify_bppp_prepare_norm_arg_claim_with_challenges(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len, const unsigned char *gammas32, size_t gamma_count, unsigned char terminal_n32[32], unsigned char terminal_l32[32], unsigned char residual33[33])
static int purify_parse_point_as_ge(const unsigned char point33[33], secp256k1_ge *out)
int purify_bip340_sign_with_fixed_nonce(purify_secp_context *context, unsigned char sig64[64], const unsigned char *msg, size_t msglen, const unsigned char seckey32[32], const unsigned char nonce32[32])
Signs a message with a caller-supplied BIP340 nonce scalar.
static int purify_bulletproof_verify_circuit_impl(purify_secp_context *context, purify_bulletproof_backend_resources *resources, const purify_bulletproof_circuit_view *circuit, const unsigned char *commitments33, const unsigned char value_gen33[33], const unsigned char *extra_commit, size_t extra_commit_len, const unsigned char *proof, size_t proof_len)
static int purify_bppp_prove_norm_arg_to_commitment_impl(purify_secp_context *context, purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, const unsigned char commitment33[33], unsigned char *proof_out, size_t *proof_len, purify_bppp_round_challenge_callback challenge_callback, void *callback_data)
int purify_bppp_scale_generator(purify_secp_context *context, const unsigned char generator33[33], const unsigned char scalar32[32], unsigned char out33[33])
static int purify_bulletproof_reserve_circuit_scratch(purify_bulletproof_backend_resources *resources, const secp256k1_bulletproof_circuit *circuit)
static int purify_bppp_rangeproof_norm_product_prove_with_copied_inputs(const secp256k1_context *ctx, secp256k1_scratch_space *scratch, unsigned char *proof, size_t *proof_len, secp256k1_sha256 *transcript, const secp256k1_scalar *rho, const secp256k1_ge *g_vec, size_t g_vec_len, const secp256k1_scalar *n_vec, size_t n_vec_len, const secp256k1_scalar *l_vec, size_t l_vec_len, const secp256k1_scalar *c_vec, size_t c_vec_len, size_t secure_clear_checkpoint, purify_bppp_round_challenge_callback challenge_callback, void *callback_data)
int purify_scalar_is_even(const purify_scalar *value)
Returns nonzero when the scalar is even.
static void purify_free_bulletproof_circuit(secp256k1_bulletproof_circuit *circuit)
int purify_bulletproof_prove_circuit(purify_secp_context *context, const purify_bulletproof_circuit_view *circuit, const purify_bulletproof_assignment_view *assignment, const unsigned char *blinds32, const unsigned char value_gen33[33], const unsigned char nonce32[32], const unsigned char *extra_commit, size_t extra_commit_len, unsigned char *commitments_out33, unsigned char *proof_out, size_t *proof_len)
static int purify_norm_arg_public_digest(unsigned char digest[32], const secp256k1_scalar *rho, const secp256k1_bppp_generators *gens_vec, size_t g_len, const secp256k1_scalar *c_vec, size_t c_vec_len)
int purify_bppp_generator_to_point(purify_secp_context *context, const unsigned char generator33[33], unsigned char out33[33])
static int purify_bppp_commit_norm_arg_impl(purify_secp_context *context, purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33])
static int purify_fixed_nonce_function(unsigned char *nonce32, const unsigned char *msg, size_t msglen, const unsigned char *key32, const unsigned char *xonly_pk32, const unsigned char *algo, size_t algolen, void *data)
int purify_bulletproof_prove_circuit_assume_valid(purify_secp_context *context, const purify_bulletproof_circuit_view *circuit, const purify_bulletproof_assignment_view *assignment, const unsigned char *blinds32, const unsigned char value_gen33[33], const unsigned char nonce32[32], const unsigned char *extra_commit, size_t extra_commit_len, unsigned char *commitments_out33, unsigned char *proof_out, size_t *proof_len)
int purify_sha256_many(unsigned char output32[32], const unsigned char *const *items, const size_t *item_lens, size_t items_count)
Computes SHA-256 over a set of byte strings.
int purify_bppp_prove_norm_arg(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33], unsigned char *proof_out, size_t *proof_len)
Produces a standalone BPPP norm argument.
int purify_bppp_commit_witness_only(purify_secp_context *context, const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, unsigned char commitment_out33[33])
int purify_bppp_commit_norm_arg(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33])
static void purify_free_bulletproof_assignment(secp256k1_bulletproof_circuit_assignment *assignment)
int purify_bppp_prepare_norm_arg_claim(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len, unsigned char terminal_n32[32], unsigned char terminal_l32[32], unsigned char *gammas32, size_t gamma_count, unsigned char residual33[33])
void purify_sha256(unsigned char output32[32], const unsigned char *data, size_t data_len)
Computes SHA-256 over a byte string.
int purify_scalar_is_one(const purify_scalar *value)
Returns nonzero when the scalar is one.
int purify_bppp_public_point_validate(const unsigned char point33[33])
static size_t purify_total_row_entries(const purify_bulletproof_row_view *rows, size_t count, int *ok)
int purify_bip340_validate_signature(purify_secp_context *context, const unsigned char sig64[64])
Returns nonzero when the 64-byte BIP340 signature has a syntactically valid encoding.
void purify_secp_context_destroy(purify_secp_context *context)
Destroys a context returned by purify_secp_context_create.
void purify_bppp_backend_resources_destroy(purify_bppp_backend_resources *resources)
int purify_bppp_public_msm(purify_secp_context *context, const unsigned char *points33, const unsigned char *scalars32, size_t count, unsigned char out33[33])
int purify_bulletproof_prove_circuit_assume_valid_with_resources(purify_bulletproof_backend_resources *resources, const purify_bulletproof_circuit_view *circuit, const purify_bulletproof_assignment_view *assignment, const unsigned char *blinds32, const unsigned char value_gen33[33], const unsigned char nonce32[32], const unsigned char *extra_commit, size_t extra_commit_len, unsigned char *commitments_out33, unsigned char *proof_out, size_t *proof_len)
size_t purify_bulletproof_backend_resources_scratch_capacity(const purify_bulletproof_backend_resources *resources)
void purify_scalar_inverse(purify_scalar *out, const purify_scalar *value)
Computes the multiplicative inverse of a scalar in constant time.
static int purify_bppp_commit_secret(const secp256k1_context *ctx, secp256k1_ge *commit, const secp256k1_bppp_generators *generators, const secp256k1_scalar *n_vec, size_t n_vec_len, const secp256k1_scalar *l_vec, size_t l_vec_len, const secp256k1_scalar *c_vec, size_t c_vec_len, const secp256k1_scalar *mu)
int purify_bppp_value_generator_h(purify_secp_context *context, unsigned char out33[33])
Serializes the alternate value generator used by Pedersen commitments.
int purify_bppp_create_generators(purify_secp_context *context, size_t count, unsigned char *out, size_t *out_len)
Expands the generator list required by the BPPP prover and verifier.
purify_bppp_backend_resources * purify_bppp_backend_resources_clone(const purify_bppp_backend_resources *resources)
static const secp256k1_scalar * purify_scalar_cast_const(const purify_scalar *scalar)
static int purify_bulletproof_circuit_evaluate(const secp256k1_bulletproof_circuit *circuit, const secp256k1_bulletproof_circuit_assignment *assignment)
int purify_point_add(purify_secp_context *context, const unsigned char lhs33[33], const unsigned char rhs33[33], unsigned char out33[33])
int purify_bppp_verify_norm_arg(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len)
Verifies a standalone BPPP norm argument.
static const size_t purify_bulletproof_msm_scratch_size
int purify_pedersen_commit_char(purify_secp_context *context, const unsigned char blind32[32], const unsigned char value32[32], const unsigned char value_gen33[33], const unsigned char blind_gen33[33], unsigned char commitment_out33[33])
Computes a Pedersen commitment to an arbitrary 32-byte scalar value.
void purify_scalar_inverse_var(purify_scalar *out, const purify_scalar *value)
Computes the multiplicative inverse of a scalar.
int purify_bip340_validate_xonly_pubkey(purify_secp_context *context, const unsigned char xonly_pubkey32[32])
Returns nonzero when the x-only public key encoding parses successfully.
static secp256k1_context * purify_context_handle(const purify_secp_context *context)
static int purify_bppp_prepare_norm_arg_claim_impl(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len, const unsigned char *supplied_gammas32, unsigned char *derived_gammas32, size_t gamma_count, unsigned char terminal_n32[32], unsigned char terminal_l32[32], unsigned char residual33[33])
static void purify_bridge_secure_clear(void *data, size_t size)
int purify_bppp_prove_norm_arg_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33], unsigned char *proof_out, size_t *proof_len)
static int purify_bip340_canonicalize_scalar(const secp256k1_context *ctx, unsigned char scalar32[32], unsigned char xonly_pubkey32[32])
int purify_scalar_eq(const purify_scalar *lhs, const purify_scalar *rhs)
Returns nonzero when two scalars are equal.
static int purify_parse_generator_as_ge(const secp256k1_context *ctx, const unsigned char generator33[33], secp256k1_ge *out)
int purify_bppp_offset_commitment(purify_secp_context *context, const unsigned char commitment33[33], const unsigned char scalar32[32], unsigned char commitment_out33[33])
static int purify_parse_fast_scalar(const unsigned char input32[32], secp256k1_fast_scalar *scalar)
void purify_scalar_negate(purify_scalar *out, const purify_scalar *value)
Computes the additive inverse of a scalar.
void purify_bulletproof_backend_resources_destroy(purify_bulletproof_backend_resources *resources)
int purify_bppp_public_hash_to_point(purify_secp_context *context, const unsigned char *input, size_t input_len, unsigned char out33[33])
purify_secp_context * purify_secp_context_create(void)
Creates one reusable secp256k1 context for the Purify bridge and public APIs.
int purify_bppp_prove_norm_arg_to_commitment(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, const unsigned char commitment33[33], unsigned char *proof_out, size_t *proof_len)
static secp256k1_scratch_space * purify_bppp_create_scratch(const secp256k1_context *ctx, size_t generators_count)
int purify_bppp_generators_to_points(purify_secp_context *context, const unsigned char *generators33, size_t generators_count, unsigned char *points_out33)
static int purify_bppp_verify_norm_arg_impl(purify_secp_context *context, purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len, const unsigned char *gammas32, size_t gamma_count)
purify_bulletproof_backend_resources * purify_bulletproof_backend_resources_create(purify_secp_context *context, size_t n_gates)
int purify_point_add_allow_infinity(purify_secp_context *context, const unsigned char lhs33[33], const unsigned char rhs33[33], unsigned char out33[33])
static void purify_gej_add_secret_scalar_term(secp256k1_gej *accumulator, const secp256k1_ge *point, const secp256k1_scalar *scalar)
static int purify_bppp_public_msm_cb(secp256k1_scalar *scalar, secp256k1_ge *point, size_t index, void *data_ptr)
static int purify_norm_arg_commit_initial_data(secp256k1_sha256 *transcript, const secp256k1_scalar *rho, const secp256k1_bppp_generators *gens_vec, size_t g_len, const secp256k1_scalar *c_vec, size_t c_vec_len, const secp256k1_ge *commit)
purify_bulletproof_backend_resources * purify_bulletproof_backend_resources_clone(const purify_bulletproof_backend_resources *resources)
static void purify_bridge_secure_clear_scratch_tail(secp256k1_scratch_space *scratch, size_t checkpoint)
int purify_bppp_base_generator(purify_secp_context *context, unsigned char out33[33])
Serializes the secp256k1 base generator into compressed form.
int purify_bppp_commit_norm_arg_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33])
size_t purify_bppp_required_proof_size(size_t n_vec_len, size_t c_vec_len)
Computes the maximum serialized size of a BPPP norm proof.
static secp256k1_bppp_generators * purify_bppp_generators_clone(const secp256k1_bppp_generators *generators)
static int purify_bppp_prove_norm_arg_impl(purify_secp_context *context, purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33], unsigned char *proof_out, size_t *proof_len)
static void purify_weighted_scalar_inner_product_secret(secp256k1_scalar *result, const secp256k1_scalar *lhs, size_t lhs_offset, const secp256k1_scalar *rhs, size_t rhs_offset, size_t step, size_t length, const secp256k1_scalar *weight)
static void * purify_malloc_array(size_t count, size_t elem_size)
void purify_scalar_set_u64(purify_scalar *out, uint64_t value)
Initializes a scalar from a 64-bit unsigned integer.
void purify_hmac_sha256(unsigned char output32[32], const unsigned char *key, size_t key_len, const unsigned char *data, size_t data_len)
Computes HMAC-SHA256 over a byte string.
static void purify_bppp_backend_resources_release_scratch_gens(purify_bppp_mutable_generators_guard *guard)
void purify_scalar_get_b32(unsigned char output32[32], const purify_scalar *value)
Serializes a scalar as 32 big-endian bytes.
size_t purify_bulletproof_required_proof_size(size_t n_gates)
purify_bppp_backend_resources * purify_bppp_backend_resources_create(purify_secp_context *context, const unsigned char *generators33, size_t generators_count)
static int purify_bridge_checked_add_size(size_t lhs, size_t rhs, size_t *out)
static int purify_bridge_memeq_const(const unsigned char *lhs, const unsigned char *rhs, size_t size)
int purify_bip340_verify(purify_secp_context *context, const unsigned char sig64[64], const unsigned char *msg, size_t msglen, const unsigned char xonly_pubkey32[32])
Verifies a BIP340 signature against a serialized x-only public key.
static void * purify_calloc_array(size_t count, size_t elem_size)
static int purify_serialize_point(unsigned char out33[33], secp256k1_ge *point)
int purify_bppp_verify_norm_arg_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len)
void purify_scalar_set_b32(purify_scalar *out, const unsigned char input32[32], int *overflow)
Parses a big-endian 32-byte scalar.
static int purify_build_bulletproof_circuit(const purify_bulletproof_circuit_view *view, secp256k1_bulletproof_circuit *out)
static int purify_bppp_commit_witness_only_impl(purify_secp_context *context, purify_bppp_backend_resources *resources, const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, unsigned char commitment_out33[33])
C ABI bridging Purify C++ code to secp256k1-zkp BPPP functionality.
int(* purify_bppp_round_challenge_callback)(void *callback_data, const unsigned char point_pair65[65], size_t round, unsigned char challenge32[32])
static void secp256k1_fast_scalar_mul(secp256k1_scalar *r, const secp256k1_fast_scalar *a, const secp256k1_scalar *b)
static int secp256k1_bulletproof_relation66_verify_impl(const secp256k1_ecmult_context *ecmult_ctx, secp256k1_scratch *scratch, const unsigned char *const *proof, size_t n_proofs, size_t plen, const secp256k1_ge *const *commitp, size_t *nc, const secp256k1_ge *value_gen, const secp256k1_bulletproof_circuit *const *circ, const secp256k1_bulletproof_generators *gens, const unsigned char **extra_commit, size_t *extra_commit_len)
static int secp256k1_bulletproof_relation66_prove_impl(const secp256k1_ecmult_context *ecmult_ctx, secp256k1_scratch *scratch, unsigned char *proof, size_t *plen, const secp256k1_bulletproof_circuit_assignment *assn, const secp256k1_ge *commitp, const secp256k1_scalar *blinds, size_t nc, const secp256k1_ge *value_gen, const secp256k1_bulletproof_circuit *circ, const secp256k1_bulletproof_generators *gens, const unsigned char *nonce, const unsigned char *extra_commit, size_t extra_commit_len)
size_t secp256k1_bulletproof_innerproduct_proof_length(size_t n)
static secp256k1_bulletproof_generators * secp256k1_bulletproof_generators_create(const secp256k1_context *ctx, const secp256k1_generator *blinding_gen, size_t n, size_t precomp_n)
static void secp256k1_bulletproof_generators_destroy(const secp256k1_context *ctx, secp256k1_bulletproof_generators *gen)
#define secp256k1_scratch_alloc(scratch, size)
static SECP256K1_INLINE void secp256k1_pedersen_ecmult_scalar(secp256k1_gej *rj, const secp256k1_scalar *sec, const secp256k1_scalar *value, const secp256k1_ge *value_gen, const secp256k1_ge *blind_gen)
Public C core for Purify key validation, key derivation, key generation, and evaluation.
purify_error_code purify_fill_secure_random(unsigned char *bytes, size_t bytes_len)
Fills a caller-owned buffer with secure operating-system randomness.
Narrow C ABI exposing secp256k1 scalar and HMAC helpers to the C++ headers.
secp256k1_scratch_space * scratch
secp256k1_bppp_generators * gens
secp256k1_bppp_generators gens_scratch
purify_bppp_backend_resources * resources
const unsigned char * scalars32
const unsigned char * points33
const unsigned char * ar32
const unsigned char * al32
const unsigned char * ao32
const unsigned char * v32
secp256k1_scratch_space * scratch
secp256k1_bulletproof_generators * gens
const purify_bulletproof_row_view * wr
const purify_bulletproof_row_view * wo
const purify_bulletproof_row_view * wl
const purify_bulletproof_row_view * wv
const unsigned char * c32
Opaque scalar storage compatible with secp256k1-zkp internal scalar storage.
secp256k1_bulletproof_wmatrix_row * wl
secp256k1_bulletproof_wmatrix_row * wv
secp256k1_bulletproof_wmatrix_entry * entries
secp256k1_bulletproof_wmatrix_row * wo
secp256k1_bulletproof_wmatrix_row * wr
secp256k1_fast_scalar * c
secp256k1_ge * blinding_gen
secp256k1_fast_scalar scal
secp256k1_bulletproof_wmatrix_entry * entry
static SECP256K1_INLINE size_t secp256k1_floor_lg(size_t n)