7#ifndef SECP256K1_MODULE_EXTRAKEYS_TESTS_H
8#define SECP256K1_MODULE_EXTRAKEYS_TESTS_H
10#include "../../../include/secp256k1_extrakeys.h"
11#include "../../unit_test.h"
20 unsigned char xy_sk[32];
21 unsigned char buf32[32];
22 unsigned char ones32[32];
23 unsigned char zeros64[64] = { 0 };
28 memset(ones32, 0xFF, 32);
38 memset(&
pk, 0,
sizeof(
pk));
42 memset(
sk, 0,
sizeof(
sk));
47 CHECK(pk_parity == 0);
55 CHECK(pk_parity == 1);
70 memset(&pk_tmp, 0,
sizeof(pk_tmp));
86 memset(&xonly_pk, 1,
sizeof(xonly_pk));
90 memset(&xonly_pk, 1,
sizeof(xonly_pk));
97 for (i = 0; i <
COUNT; i++) {
98 unsigned char rand33[33];
102 memset(&xonly_pk, 1,
sizeof(xonly_pk));
112 unsigned char pk1_ser[32] = {
113 0x58, 0x84, 0xb3, 0xa2, 0x4b, 0x97, 0x37, 0x88, 0x92, 0x38, 0xa6, 0x26, 0x62, 0x52, 0x35, 0x11,
114 0xd0, 0x9a, 0xa1, 0x1b, 0x80, 0x0b, 0x5e, 0x93, 0x80, 0x26, 0x11, 0xef, 0x67, 0x4b, 0xd9, 0x23
116 const unsigned char pk2_ser[32] = {
117 0xde, 0x36, 0x0e, 0x87, 0x59, 0x8f, 0x3c, 0x01, 0x36, 0x2a, 0x2a, 0xb8, 0xc6, 0xf4, 0x5e, 0x4d,
118 0xb2, 0xc2, 0xd5, 0x03, 0xa7, 0xf9, 0xf1, 0x4f, 0xa8, 0xfa, 0x95, 0xa8, 0xe9, 0x69, 0x76, 0x1c
132 memset(&pk1, 0,
sizeof(pk1));
145 unsigned char zeros64[64] = { 0 };
146 unsigned char overflows[32];
147 unsigned char sk[32];
152 unsigned char tweak[32];
155 memset(overflows, 0xff,
sizeof(overflows));
180 for (i = 0; i <
COUNT; i++) {
193 memset(&internal_xonly_pk, 0,
sizeof(internal_xonly_pk));
200 unsigned char zeros64[64] = { 0 };
201 unsigned char overflows[32];
202 unsigned char sk[32];
207 unsigned char output_pk32[32];
208 unsigned char buf32[32];
210 unsigned char tweak[32];
212 memset(overflows, 0xff,
sizeof(overflows));
254 unsigned char sk[32];
256 unsigned char pk_serialized[32];
283 unsigned char sk[32];
284 unsigned char sk_tmp[32];
285 unsigned char zeros96[96] = { 0 };
286 unsigned char overflows[32];
290 int pk_parity, pk_parity_tmp;
292 CHECK(
sizeof(zeros96) ==
sizeof(keypair));
293 memset(overflows, 0xFF,
sizeof(overflows));
323 memset(&keypair, 0,
sizeof(keypair));
344 memset(&keypair, 0,
sizeof(keypair));
354 CHECK(pk_parity == pk_parity_tmp);
371 memset(&keypair, 0,
sizeof(keypair));
377 unsigned char sk[32];
379 unsigned char overflows[32];
380 unsigned char zeros96[96] = { 0 };
381 unsigned char tweak[32];
384 CHECK(
sizeof(zeros96) ==
sizeof(keypair));
387 memset(overflows, 0xFF, 32);
408 for (i = 0; i <
COUNT; i++) {
413 memcpy(&keypair_tmp, &keypair,
sizeof(keypair));
426 memset(&keypair, 0,
sizeof(keypair));
432 memset(&keypair, 0, 32);
436 memset(&keypair.
data[32], 0, 64);
441 for (i = 0; i <
COUNT; i++) {
446 unsigned char pk32[32];
447 unsigned char sk32[32];
#define secp256k1_fe_negate(r, a, m)
Negate a field element.
static int secp256k1_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b)
Determine whether two field elements are equal.
#define CHECK(cond)
Unconditional failure on condition failure.
static int tweak(const secp256k1_context *ctx, secp256k1_xonly_pubkey *agg_pk, secp256k1_musig_keyagg_cache *cache)
static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *bin, int *overflow)
Set a scalar from a big endian byte array.
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar *a)
Convert a scalar to a byte array.
static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a)
Compute the complement of a scalar (modulo the group order).
static SECP256K1_INLINE int secp256k1_memcmp_var(const void *s1, const void *s2, size_t n)
Semantics like memcmp.
static int secp256k1_pubkey_load(const secp256k1_context *ctx, secp256k1_ge *ge, const secp256k1_pubkey *pubkey)
#define SECP256K1_TAG_PUBKEY_EVEN
Prefix byte used to tag various encoded curvepoints for specific purposes.
SECP256K1_API void secp256k1_context_set_illegal_callback(secp256k1_context *ctx, void(*fun)(const char *message, void *data), const void *data) SECP256K1_ARG_NONNULL(1)
Set a callback function to be called when an illegal argument is passed to an API call.
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_parse(const secp256k1_context *ctx, secp256k1_pubkey *pubkey, const unsigned char *input, size_t inputlen) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
Parse a variable-length public key into the pubkey object.
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_create(const secp256k1_context *ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3)
Compute the public key for a secret key.
This field implementation represents the value as 10 uint32_t limbs in base 2^26.
A group element in affine coordinates on the secp256k1 curve, or occasionally on an isomorphic curve ...
Opaque data structure that holds a keypair consisting of a secret and a public key.
Opaque data structure that holds a parsed and valid public key.
A scalar modulo the group order of the secp256k1 curve.
Opaque data structure that holds a parsed and valid "x-only" public key.
static void testrand256(unsigned char *b32)
Generate a pseudorandom 32-byte array.
#define CHECK_ILLEGAL_VOID(ctx, expr_or_stmt)
static void counting_callback_fn(const char *str, void *data)
#define CHECK_ILLEGAL(ctx, expr)
static secp256k1_context * CTX
static secp256k1_context * STATIC_CTX