29:I[49813,["/_next/static/chunks/3z--bwudlglfp.js","/_next/static/chunks/2u04xn-9yg2co.js","/_next/static/chunks/1b5-8ftwqgmtb.js","/_next/static/chunks/3nqo6bdos11l6.js","/_next/static/chunks/0fz0mlrjifmq7.js","/_next/static/chunks/2l43yyot7shmw.js","/_next/static/chunks/29v1ttach42xh.js","/_next/static/chunks/2ziic7alkvd8r.js","/_next/static/chunks/1hplpmn3-d0tx.js"],"CodeWorkspace"] 2a:T441c,/*********************************************************************** * Copyright (c) 2020 Gregory Maxwell * * Distributed under the MIT software license, see the accompanying * * file COPYING or https://www.opensource.org/licenses/mit-license.php.* ***********************************************************************/ #include #include #include #include "../include/secp256k1.h" #include "assumptions.h" #include "checkmem.h" #if !SECP256K1_CHECKMEM_ENABLED # error "This tool cannot be compiled without memory-checking interface (valgrind or msan)" #endif #ifdef ENABLE_MODULE_ECDH # include "../include/secp256k1_ecdh.h" #endif #ifdef ENABLE_MODULE_RECOVERY # include "../include/secp256k1_recovery.h" #endif #ifdef ENABLE_MODULE_EXTRAKEYS # include "../include/secp256k1_extrakeys.h" #endif #ifdef ENABLE_MODULE_SCHNORRSIG #include "../include/secp256k1_schnorrsig.h" #endif #ifdef ENABLE_MODULE_MUSIG #include "../include/secp256k1_musig.h" #endif #ifdef ENABLE_MODULE_FULLAGG #include "../include/secp256k1_fullagg.h" #endif #ifdef ENABLE_MODULE_ELLSWIFT #include "../include/secp256k1_ellswift.h" #endif #ifdef ENABLE_MODULE_SILENTPAYMENTS #include "../include/secp256k1_silentpayments.h" #endif #if defined(__GNUC__) # pragma GCC diagnostic push # pragma GCC diagnostic warning "-Wunused-function" #endif #ifdef ENABLE_MODULE_SCHNORRSIG static int nonce_function_custom(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) { return secp256k1_nonce_function_bip340(nonce32, msg, msglen, key32, xonly_pk32, algo, algolen, data); } #endif static void run_tests(secp256k1_context *ctx, unsigned char *key); int main(void) { secp256k1_context* ctx; unsigned char key[32]; int ret, i; if (!SECP256K1_CHECKMEM_RUNNING()) { fprintf(stderr, "This test can only usefully be run inside valgrind because it was not compiled under msan.\n"); fprintf(stderr, "Usage: valgrind ./ctime_tests (or with Autotools: libtool --mode=execute valgrind ./ctime_tests)\n"); return EXIT_FAILURE; } ctx = secp256k1_context_create(SECP256K1_CONTEXT_DECLASSIFY); /** In theory, testing with a single secret input should be sufficient: * If control flow depended on secrets the tool would generate an error. */ for (i = 0; i < 32; i++) { key[i] = i + 65; } run_tests(ctx, key); /* Test context randomisation. Do this last because it leaves the context * tainted. */ SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_context_randomize(ctx, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret); secp256k1_context_destroy(ctx); return EXIT_SUCCESS; } static void run_tests(secp256k1_context *ctx, unsigned char *key) { secp256k1_ecdsa_signature signature; secp256k1_pubkey pubkey; size_t siglen = 74; size_t outputlen = 33; int i; int ret; unsigned char msg[32]; unsigned char sig[74]; unsigned char spubkey[33]; #ifdef ENABLE_MODULE_RECOVERY secp256k1_ecdsa_recoverable_signature recoverable_signature; int recid; #endif #ifdef ENABLE_MODULE_EXTRAKEYS secp256k1_keypair keypair; #endif #ifdef ENABLE_MODULE_SCHNORRSIG secp256k1_schnorrsig_extraparams extraparams = SECP256K1_SCHNORRSIG_EXTRAPARAMS_INIT; unsigned char aux_rand[32] = { 0 }; #endif #ifdef ENABLE_MODULE_ELLSWIFT unsigned char ellswift[64]; static const unsigned char prefix[64] = {'t', 'e', 's', 't'}; #endif #ifdef ENABLE_MODULE_SILENTPAYMENTS secp256k1_xonly_pubkey generated_output; secp256k1_xonly_pubkey *generated_outputs[1]; secp256k1_silentpayments_recipient recipient; secp256k1_silentpayments_label label; const secp256k1_silentpayments_recipient *recipients[1]; unsigned char outpoint_smallest[36] = { 0 }; secp256k1_keypair sp_keypair; const secp256k1_keypair *sp_keypairs[1]; const unsigned char *sp_seckeys[1]; secp256k1_silentpayments_found_output found_outputs[1]; secp256k1_silentpayments_found_output *found_outputs_ptrs[1]; uint32_t n_found_outputs; const secp256k1_xonly_pubkey *tx_outputs[1]; secp256k1_silentpayments_prevouts_summary prevouts_summary; unsigned char label_tweak[32] = { 0 }; secp256k1_xonly_pubkey sp_xonly_pubkey; const secp256k1_xonly_pubkey *sp_xonly_pubkeys[1]; secp256k1_pubkey sp_pubkey; const secp256k1_pubkey *sp_pubkeys[1]; #endif for (i = 0; i < 32; i++) { msg[i] = i + 1; } /* Test keygen. */ SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ec_pubkey_create(ctx, &pubkey, key); SECP256K1_CHECKMEM_DEFINE(&pubkey, sizeof(secp256k1_pubkey)); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret); CHECK(secp256k1_ec_pubkey_serialize(ctx, spubkey, &outputlen, &pubkey, SECP256K1_EC_COMPRESSED) == 1); /* Test signing. */ SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ecdsa_sign(ctx, &signature, msg, key, NULL, NULL); SECP256K1_CHECKMEM_DEFINE(&signature, sizeof(secp256k1_ecdsa_signature)); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret); CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, sig, &siglen, &signature)); #ifdef ENABLE_MODULE_ECDH /* Test ECDH. */ SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ecdh(ctx, msg, &pubkey, key, NULL, NULL); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); #endif #ifdef ENABLE_MODULE_RECOVERY /* Test signing a recoverable signature. */ SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ecdsa_sign_recoverable(ctx, &recoverable_signature, msg, key, NULL, NULL); SECP256K1_CHECKMEM_DEFINE(&recoverable_signature, sizeof(recoverable_signature)); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret); CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &recoverable_signature)); CHECK(recid >= 0 && recid <= 3); #endif SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ec_seckey_verify(ctx, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ec_seckey_negate(ctx, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(key, 32); SECP256K1_CHECKMEM_UNDEFINE(msg, 32); ret = secp256k1_ec_seckey_tweak_add(ctx, key, msg); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(key, 32); SECP256K1_CHECKMEM_UNDEFINE(msg, 32); ret = secp256k1_ec_seckey_tweak_mul(ctx, key, msg); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); /* Test keypair_create and keypair_xonly_tweak_add. */ #ifdef ENABLE_MODULE_EXTRAKEYS SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_keypair_create(ctx, &keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); /* The tweak is not treated as a secret in keypair_tweak_add */ SECP256K1_CHECKMEM_DEFINE(msg, 32); ret = secp256k1_keypair_xonly_tweak_add(ctx, &keypair, msg); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(key, 32); SECP256K1_CHECKMEM_UNDEFINE(&keypair, sizeof(keypair)); ret = secp256k1_keypair_sec(ctx, key, &keypair); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); #endif #ifdef ENABLE_MODULE_SCHNORRSIG SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_keypair_create(ctx, &keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); ret = secp256k1_schnorrsig_sign32(ctx, sig, msg, &keypair, NULL); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_keypair_create(ctx, &keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(&keypair, sizeof(keypair)); ret = secp256k1_schnorrsig_sign_custom(ctx, sig, msg, 32, &keypair, NULL); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); extraparams.noncefp = NULL; extraparams.ndata = aux_rand; SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_keypair_create(ctx, &keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(&keypair, sizeof(keypair)); ret = secp256k1_schnorrsig_sign_custom(ctx, sig, msg, 32, &keypair, &extraparams); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); extraparams.noncefp = nonce_function_custom; extraparams.ndata = aux_rand; SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_keypair_create(ctx, &keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(&keypair, sizeof(keypair)); ret = secp256k1_schnorrsig_sign_custom(ctx, sig, msg, sizeof(msg), &keypair, &extraparams); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); #endif #ifdef ENABLE_MODULE_MUSIG { secp256k1_pubkey pk; const secp256k1_pubkey *pk_ptr[1]; secp256k1_xonly_pubkey agg_pk; unsigned char session_secrand[32]; uint64_t nonrepeating_cnt = 0; secp256k1_musig_secnonce secnonce; secp256k1_musig_pubnonce pubnonce; const secp256k1_musig_pubnonce *pubnonce_ptr[1]; secp256k1_musig_aggnonce aggnonce; secp256k1_musig_keyagg_cache cache; secp256k1_musig_session session; secp256k1_musig_partial_sig partial_sig; unsigned char extra_input[32]; pk_ptr[0] = &pk; pubnonce_ptr[0] = &pubnonce; SECP256K1_CHECKMEM_DEFINE(key, 32); memcpy(session_secrand, key, sizeof(session_secrand)); session_secrand[0] = session_secrand[0] + 1; memcpy(extra_input, key, sizeof(extra_input)); extra_input[0] = extra_input[0] + 2; CHECK(secp256k1_keypair_create(ctx, &keypair, key)); CHECK(secp256k1_keypair_pub(ctx, &pk, &keypair)); CHECK(secp256k1_musig_pubkey_agg(ctx, &agg_pk, &cache, pk_ptr, 1)); SECP256K1_CHECKMEM_UNDEFINE(key, 32); SECP256K1_CHECKMEM_UNDEFINE(session_secrand, sizeof(session_secrand)); SECP256K1_CHECKMEM_UNDEFINE(extra_input, sizeof(extra_input)); ret = secp256k1_musig_nonce_gen(ctx, &secnonce, &pubnonce, session_secrand, key, &pk, msg, &cache, extra_input); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); ret = secp256k1_musig_nonce_gen_counter(ctx, &secnonce, &pubnonce, nonrepeating_cnt, &keypair, msg, &cache, extra_input); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); CHECK(secp256k1_musig_nonce_agg(ctx, &aggnonce, pubnonce_ptr, 1)); /* Make sure that previous tests don't undefine msg. It's not used as a secret here. */ SECP256K1_CHECKMEM_DEFINE(msg, sizeof(msg)); CHECK(secp256k1_musig_nonce_process(ctx, &session, &aggnonce, msg, &cache) == 1); ret = secp256k1_keypair_create(ctx, &keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); ret = secp256k1_musig_partial_sign(ctx, &partial_sig, &secnonce, &keypair, &cache, &session); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); } #endif #ifdef ENABLE_MODULE_FULLAGG { secp256k1_xonly_pubkey pk; const secp256k1_xonly_pubkey *pk_ptr[1]; const unsigned char *msg_ptr[1]; unsigned char session_secrand[32]; uint64_t nonrepeating_cnt = 0; secp256k1_fullagg_secnonce secnonce; secp256k1_fullagg_pubnonce pubnonce; const secp256k1_fullagg_pubnonce *pubnonce_ptr[1]; secp256k1_fullagg_aggnonce aggnonce; secp256k1_fullagg_session session; secp256k1_fullagg_partial_sig partial_sig; unsigned char extra_input[32]; pk_ptr[0] = &pk; msg_ptr[0] = msg; pubnonce_ptr[0] = &pubnonce; SECP256K1_CHECKMEM_DEFINE(key, 32); memcpy(session_secrand, key, sizeof(session_secrand)); session_secrand[0] = session_secrand[0] + 1; memcpy(extra_input, key, sizeof(extra_input)); extra_input[0] = extra_input[0] + 2; CHECK(secp256k1_keypair_create(ctx, &keypair, key)); CHECK(secp256k1_keypair_xonly_pub(ctx, &pk, NULL, &keypair)); SECP256K1_CHECKMEM_UNDEFINE(key, 32); SECP256K1_CHECKMEM_UNDEFINE(session_secrand, sizeof(session_secrand)); SECP256K1_CHECKMEM_UNDEFINE(extra_input, sizeof(extra_input)); ret = secp256k1_fullagg_nonce_gen(ctx, &secnonce, &pubnonce, session_secrand, key, &pk, extra_input); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); ret = secp256k1_fullagg_nonce_gen_counter(ctx, &secnonce, &pubnonce, nonrepeating_cnt, &keypair, extra_input); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); CHECK(secp256k1_fullagg_nonce_agg(ctx, &aggnonce, pubnonce_ptr, 1)); /* Make sure that previous tests don't undefine msg. It's not used as a secret here. */ SECP256K1_CHECKMEM_DEFINE(msg, sizeof(msg)); CHECK(secp256k1_fullagg_session_init(ctx, &session, &aggnonce, pk_ptr, msg_ptr, pubnonce_ptr, 1) == 1); ret = secp256k1_keypair_create(ctx, &keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); ret = secp256k1_fullagg_partial_sign(ctx, &partial_sig, &secnonce, &keypair, msg, &session, pk_ptr, msg_ptr, pubnonce_ptr, 1, 0); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); } #endif #ifdef ENABLE_MODULE_ELLSWIFT SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ellswift_create(ctx, ellswift, key, NULL); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_ellswift_create(ctx, ellswift, key, ellswift); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); for (i = 0; i < 2; i++) { SECP256K1_CHECKMEM_UNDEFINE(key, 32); SECP256K1_CHECKMEM_DEFINE(&ellswift, sizeof(ellswift)); ret = secp256k1_ellswift_xdh(ctx, msg, ellswift, ellswift, key, i, secp256k1_ellswift_xdh_hash_function_bip324, NULL); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_UNDEFINE(key, 32); SECP256K1_CHECKMEM_DEFINE(&ellswift, sizeof(ellswift)); ret = secp256k1_ellswift_xdh(ctx, msg, ellswift, ellswift, key, i, secp256k1_ellswift_xdh_hash_function_prefix, (void *)prefix); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); } #endif #ifdef ENABLE_MODULE_SILENTPAYMENTS SECP256K1_CHECKMEM_DEFINE(key, 32); generated_outputs[0] = &generated_output; /* Initialize recipient */ CHECK(secp256k1_ec_pubkey_create(ctx, &recipient.scan_pubkey, key)); key[31] ^= 1; CHECK(secp256k1_ec_pubkey_create(ctx, &recipient.spend_pubkey, key)); key[31] ^= (1 << 1); recipient.index = 0; recipients[0] = &recipient; /* Set up secret keys */ SECP256K1_CHECKMEM_UNDEFINE(key, 32); ret = secp256k1_keypair_create(ctx, &sp_keypair, key); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret); key[31] ^= (1 << 2); sp_keypairs[0] = &sp_keypair; sp_seckeys[0] = key; ret = secp256k1_silentpayments_sender_create_outputs(ctx, generated_outputs, recipients, 1, outpoint_smallest, sp_keypairs, 1, sp_seckeys, 1); CHECK(ret == 1); ret = secp256k1_silentpayments_recipient_label_create(ctx, &label, label_tweak, key, 0); key[31] ^= (1 << 3); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); CHECK(secp256k1_keypair_xonly_pub(ctx, &sp_xonly_pubkey, NULL, &sp_keypair)); SECP256K1_CHECKMEM_DEFINE(&sp_xonly_pubkey, sizeof(sp_xonly_pubkey)); sp_xonly_pubkeys[0] = &sp_xonly_pubkey; ret = secp256k1_ec_pubkey_create(ctx, &sp_pubkey, sp_seckeys[0]); SECP256K1_CHECKMEM_DEFINE(&ret, sizeof(ret)); CHECK(ret == 1); SECP256K1_CHECKMEM_DEFINE(&sp_pubkey, sizeof(sp_pubkey)); sp_pubkeys[0] = &sp_pubkey; ret = secp256k1_silentpayments_recipient_prevouts_summary_create(ctx, &prevouts_summary, outpoint_smallest, sp_xonly_pubkeys, 1, sp_pubkeys, 1); CHECK(ret == 1); tx_outputs[0] = generated_outputs[0]; found_outputs_ptrs[0] = &found_outputs[0]; n_found_outputs = 1; SECP256K1_CHECKMEM_DEFINE(&recipient.spend_pubkey, sizeof(recipient.spend_pubkey)); /* It is sufficient to check _recipient_scan_outputs without a label lookup function, since the shared secret is created once (which is where the constant timeness matters) * and then reused for the rest of the scanning logic. */ CHECK(secp256k1_silentpayments_recipient_scan_outputs(ctx, found_outputs_ptrs, &n_found_outputs, tx_outputs, 1, key, &prevouts_summary, &recipient.spend_pubkey, NULL, NULL)); #endif } #if defined(__GNUC__) # pragma GCC diagnostic pop #endif 12:["$","$L29",null,{"project":{"id":"cmuedkp32000101nt46e05n7u","owner":"bitcoin-core","repo":"secp256k1","displayName":"bitcoin-core/secp256k1","defaultBranch":"master"},"commit":{"sha":"1af6f99027a9e9d040cafe24232aa08559650be0","message":"fullagg: Add ctime tests","authorLogin":"fjahr","authorName":"Fabian Jahr","date":"2026-07-10T12:48:26.000Z","htmlUrl":"https://github.com/bitcoin-core/secp256k1/commit/1af6f99027a9e9d040cafe24232aa08559650be0","isHead":false,"headSha":"e74a0187aac1cac734d5ad23ca5e40ceb6ddd4a8"},"gitRef":"1af6f99027a9e9d040cafe24232aa08559650be0","path":"src/ctime_tests.c","target":{"kind":"file","file":{"path":"src/ctime_tests.c","size":17436,"content":"$2a","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/bitcoin-core/secp256k1/blob/1af6f99027a9e9d040cafe24232aa08559650be0/src/ctime_tests.c","mutants":[],"mutantsAtOtherRevisions":0}},"treeCache":{"":[{"name":".github","path":".github","type":"dir","size":null},{"name":"autotools-aux","path":"autotools-aux","type":"dir","size":null},{"name":"ci","path":"ci","type":"dir","size":null},{"name":"cmake","path":"cmake","type":"dir","size":null},{"name":"contrib","path":"contrib","type":"dir","size":null},{"name":"doc","path":"doc","type":"dir","size":null},{"name":"examples","path":"examples","type":"dir","size":null},{"name":"include","path":"include","type":"dir","size":null},{"name":"sage","path":"sage","type":"dir","size":null},{"name":"src","path":"src","type":"dir","size":null},{"name":"tools","path":"tools","type":"dir","size":null},{"name":".gitattributes","path":".gitattributes","type":"file","size":92},{"name":".gitignore","path":".gitignore","type":"file","size":667},{"name":"autogen.sh","path":"autogen.sh","type":"file","size":47},{"name":"CHANGELOG.md","path":"CHANGELOG.md","type":"file","size":18252},{"name":"CMakeLists.txt","path":"CMakeLists.txt","type":"file","size":18043},{"name":"CMakePresets.json","path":"CMakePresets.json","type":"file","size":418},{"name":"configure.ac","path":"configure.ac","type":"file","size":23087},{"name":"CONTRIBUTING.md","path":"CONTRIBUTING.md","type":"file","size":6867},{"name":"COPYING","path":"COPYING","type":"file","size":1057},{"name":"libsecp256k1.pc.in","path":"libsecp256k1.pc.in","type":"file","size":301},{"name":"Makefile.am","path":"Makefile.am","type":"file","size":12011},{"name":"README.md","path":"README.md","type":"file","size":9718},{"name":"SECURITY.md","path":"SECURITY.md","type":"file","size":850}],"src":[{"name":"asm","path":"src/asm","type":"dir","size":null},{"name":"modules","path":"src/modules","type":"dir","size":null},{"name":"wycheproof","path":"src/wycheproof","type":"dir","size":null},{"name":"assumptions.h","path":"src/assumptions.h","type":"file","size":4667},{"name":"bench_ecmult.c","path":"src/bench_ecmult.c","type":"file","size":15658},{"name":"bench_internal.c","path":"src/bench_internal.c","type":"file","size":18493},{"name":"bench.c","path":"src/bench.c","type":"file","size":12779},{"name":"bench.h","path":"src/bench.h","type":"file","size":4777},{"name":"checkmem.h","path":"src/checkmem.h","type":"file","size":5355},{"name":"CMakeLists.txt","path":"src/CMakeLists.txt","type":"file","size":9056},{"name":"ctime_tests.c","path":"src/ctime_tests.c","type":"file","size":17436},{"name":"ecdsa_impl.h","path":"src/ecdsa_impl.h","type":"file","size":10499},{"name":"ecdsa.h","path":"src/ecdsa.h","type":"file","size":1175},{"name":"eckey_impl.h","path":"src/eckey_impl.h","type":"file","size":1652},{"name":"eckey.h","path":"src/eckey.h","type":"file","size":945},{"name":"ecmult_compute_table_impl.h","path":"src/ecmult_compute_table_impl.h","type":"file","size":1916},{"name":"ecmult_compute_table.h","path":"src/ecmult_compute_table.h","type":"file","size":1073},{"name":"ecmult_const_impl.h","path":"src/ecmult_const_impl.h","type":"file","size":19584},{"name":"ecmult_const.h","path":"src/ecmult_const.h","type":"file","size":1354},{"name":"ecmult_gen_compute_table_impl.h","path":"src/ecmult_gen_compute_table_impl.h","type":"file","size":4705},{"name":"ecmult_gen_compute_table.h","path":"src/ecmult_gen_compute_table.h","type":"file","size":672},{"name":"ecmult_gen_impl.h","path":"src/ecmult_gen_impl.h","type":"file","size":17232},{"name":"ecmult_gen.h","path":"src/ecmult_gen.h","type":"file","size":5639},{"name":"ecmult_impl.h","path":"src/ecmult_impl.h","type":"file","size":34325},{"name":"ecmult.h","path":"src/ecmult.h","type":"file","size":2768},{"name":"field_10x26_impl.h","path":"src/field_10x26_impl.h","type":"file","size":51376},{"name":"field_10x26.h","path":"src/field_10x26.h","type":"file","size":2338},{"name":"field_5x52_impl.h","path":"src/field_5x52_impl.h","type":"file","size":18483},{"name":"field_5x52_int128_impl.h","path":"src/field_5x52_int128_impl.h","type":"file","size":11353},{"name":"field_5x52.h","path":"src/field_5x52.h","type":"file","size":2380},{"name":"field_impl.h","path":"src/field_impl.h","type":"file","size":14082},{"name":"field.h","path":"src/field.h","type":"file","size":15462},{"name":"group_impl.h","path":"src/group_impl.h","type":"file","size":44387},{"name":"group.h","path":"src/group.h","type":"file","size":13684},{"name":"hash_impl.h","path":"src/hash_impl.h","type":"file","size":18679},{"name":"hash.h","path":"src/hash.h","type":"file","size":2660},{"name":"hsort_impl.h","path":"src/hsort_impl.h","type":"file","size":4798},{"name":"hsort.h","path":"src/hsort.h","type":"file","size":1685},{"name":"int128_impl.h","path":"src/int128_impl.h","type":"file","size":376},{"name":"int128_native_impl.h","path":"src/int128_native_impl.h","type":"file","size":2881},{"name":"int128_native.h","path":"src/int128_native.h","type":"file","size":581},{"name":"int128_struct_impl.h","path":"src/int128_struct_impl.h","type":"file","size":7884},{"name":"int128_struct.h","path":"src/int128_struct.h","type":"file","size":229},{"name":"int128.h","path":"src/int128.h","type":"file","size":3622},{"name":"modinv32_impl.h","path":"src/modinv32_impl.h","type":"file","size":33492},{"name":"modinv32.h","path":"src/modinv32.h","type":"file","size":1865},{"name":"modinv64_impl.h","path":"src/modinv64_impl.h","type":"file","size":37653},{"name":"modinv64.h","path":"src/modinv64.h","type":"file","size":1969},{"name":"precompute_ecmult_gen.c","path":"src/precompute_ecmult_gen.c","type":"file","size":3864},{"name":"precompute_ecmult.c","path":"src/precompute_ecmult.c","type":"file","size":4017},{"name":"precomputed_ecmult_gen.c","path":"src/precomputed_ecmult_gen.c","type":"file","size":259715},{"name":"precomputed_ecmult_gen.h","path":"src/precomputed_ecmult_gen.h","type":"file","size":973},{"name":"precomputed_ecmult.c","path":"src/precomputed_ecmult.c","type":"file","size":2409168},{"name":"precomputed_ecmult.h","path":"src/precomputed_ecmult.h","type":"file","size":1585},{"name":"scalar_4x64_impl.h","path":"src/scalar_4x64_impl.h","type":"file","size":33058},{"name":"scalar_4x64.h","path":"src/scalar_4x64.h","type":"file","size":801},{"name":"scalar_8x32_impl.h","path":"src/scalar_8x32_impl.h","type":"file","size":29203},{"name":"scalar_8x32.h","path":"src/scalar_8x32.h","type":"file","size":725},{"name":"scalar_impl.h","path":"src/scalar_impl.h","type":"file","size":12113},{"name":"scalar_low_impl.h","path":"src/scalar_low_impl.h","type":"file","size":6212},{"name":"scalar_low.h","path":"src/scalar_low.h","type":"file","size":1135},{"name":"scalar.h","path":"src/scalar.h","type":"file","size":5463},{"name":"scratch_impl.h","path":"src/scratch_impl.h","type":"file","size":3837},{"name":"scratch.h","path":"src/scratch.h","type":"file","size":2224},{"name":"secp256k1.c","path":"src/secp256k1.c","type":"file","size":30505},{"name":"selftest.h","path":"src/selftest.h","type":"file","size":1659},{"name":"testrand_impl.h","path":"src/testrand_impl.h","type":"file","size":5340},{"name":"testrand.h","path":"src/testrand.h","type":"file","size":1813},{"name":"tests_common.h","path":"src/tests_common.h","type":"file","size":1430},{"name":"tests_exhaustive.c","path":"src/tests_exhaustive.c","type":"file","size":18957},{"name":"tests.c","path":"src/tests.c","type":"file","size":387077},{"name":"testutil.h","path":"src/testutil.h","type":"file","size":4945},{"name":"unit_test.c","path":"src/unit_test.c","type":"file","size":17808},{"name":"unit_test.h","path":"src/unit_test.h","type":"file","size":4689},{"name":"util_local_visibility.h","path":"src/util_local_visibility.h","type":"file","size":402},{"name":"util.h","path":"src/util.h","type":"file","size":16095}]},"revisions":[{"commitSha":"a9a61831bdcd97475e200a4bdd1ebed641f7268d","branch":null,"commitMessage":"Merge bitcoin-core/secp256k1#1924: tests: add coverage for the DER long form length encoding","commitDate":"2026-08-30T02:45:33.000Z","mutantCount":241},{"commitSha":"1af6f99027a9e9d040cafe24232aa08559650be0","branch":"dahlias","commitMessage":"fullagg: Add ctime tests","commitDate":"2026-07-10T12:48:26.000Z","mutantCount":331},{"commitSha":"ebf594320dc838b9de1abb54d5ba98cef84f4297","branch":null,"commitMessage":"Merge bitcoin-core/secp256k1#1884: SECURITY.md: remove Jonas Nick from trusted keys","commitDate":"2026-06-30T06:35:53.000Z","mutantCount":24},{"commitSha":"0f4a7e6bf9d971addb2b851df7cd2777fc62b212","branch":null,"commitMessage":"Merge bitcoin-core/secp256k1#1855: bench: add internal benchmark for `secp256k1_fe_normalize_var`","commitDate":"2026-06-09T08:05:56.000Z","mutantCount":21},{"commitSha":"a39093de15345a330fc8acbd09515fd150853bc8","branch":null,"commitMessage":"Merge bitcoin-core/secp256k1#1851: doc: correct API docs for ECDSA signing out-params (s/array/signature object/)","commitDate":"2026-06-01T09:54:06.000Z","mutantCount":267}],"signedIn":false,"pullRequest":{"id":"cmunckgcu000901s2mdovmiix","number":1754,"title":"BIP459: Add FullAgg (DahLIAS) module","headSha":"1af6f99027a9e9d040cafe24232aa08559650be0","state":"OPEN","htmlUrl":"https://github.com/bitcoin-core/secp256k1/pull/1754","ranges":[[39,42],[316,366]],"fileInDiff":true,"atHead":true}}]