@qntx/nostr-native 0.0.0-stage → 0.12.1

package/vendor/secp256k1/src/field.h

@@ -0,0 +1,351 @@
+/***********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille                              *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_FIELD_H
+#define SECP256K1_FIELD_H
+
+#include "util.h"
+
+/* This file defines the generic interface for working with nostr_native_secp256k1_fe
+ * objects, which represent field elements (integers modulo 2^256 - 2^32 - 977).
+ *
+ * The actual definition of the nostr_native_secp256k1_fe type depends on the chosen field
+ * implementation; see the field_5x52.h and field_10x26.h files for details.
+ *
+ * All nostr_native_secp256k1_fe objects have implicit properties that determine what
+ * operations are permitted on it. These are purely a function of what
+ * nostr_native_secp256k1_fe_ operations are applied on it, generally (implicitly) fixed at
+ * compile time, and do not depend on the chosen field implementation. Despite
+ * that, what these properties actually entail for the field representation
+ * values depends on the chosen field implementation. These properties are:
+ * - magnitude: an integer in [0,32]
+ * - normalized: 0 or 1; normalized=1 implies magnitude <= 1.
+ *
+ * In VERIFY mode, they are materialized explicitly as fields in the struct,
+ * allowing run-time verification of these properties. In that case, the field
+ * implementation also provides a nostr_native_secp256k1_fe_verify routine to verify that
+ * these fields match the run-time value and perform internal consistency
+ * checks. */
+#ifdef VERIFY
+#  define SECP256K1_FE_VERIFY_FIELDS \
+    int magnitude; \
+    int normalized;
+#else
+#  define SECP256K1_FE_VERIFY_FIELDS
+#endif
+
+#if defined(SECP256K1_WIDEMUL_INT128)
+#include "field_5x52.h"
+#elif defined(SECP256K1_WIDEMUL_INT64)
+#include "field_10x26.h"
+#else
+#error "Please select wide multiplication implementation"
+#endif
+
+#ifdef VERIFY
+/* Magnitude and normalized value for constants. */
+#define SECP256K1_FE_VERIFY_CONST(d7, d6, d5, d4, d3, d2, d1, d0) \
+    /* Magnitude is 0 for constant 0; 1 otherwise. */ \
+    , (((d7) | (d6) | (d5) | (d4) | (d3) | (d2) | (d1) | (d0)) != 0) \
+    /* Normalized is 1 unless sum(d_i<<(32*i) for i=0..7) exceeds field modulus. */ \
+    , (!(((d7) & (d6) & (d5) & (d4) & (d3) & (d2)) == 0xfffffffful && ((d1) == 0xfffffffful || ((d1) == 0xfffffffe && (d0 >= 0xfffffc2f)))))
+#else
+#define SECP256K1_FE_VERIFY_CONST(d7, d6, d5, d4, d3, d2, d1, d0)
+#endif
+
+/** This expands to an initializer for a nostr_native_secp256k1_fe valued sum((i*32) * d_i, i=0..7) mod p.
+ *
+ * It has magnitude 1, unless d_i are all 0, in which case the magnitude is 0.
+ * It is normalized, unless sum(2^(i*32) * d_i, i=0..7) >= p.
+ *
+ * SECP256K1_FE_CONST_INNER is provided by the implementation.
+ */
+#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0)) SECP256K1_FE_VERIFY_CONST((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0)) }
+
+static const nostr_native_secp256k1_fe nostr_native_secp256k1_fe_one = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1);
+static const nostr_native_secp256k1_fe nostr_native_secp256k1_const_beta = SECP256K1_FE_CONST(
+    0x7ae96a2bul, 0x657c0710ul, 0x6e64479eul, 0xac3434e9ul,
+    0x9cf04975ul, 0x12f58995ul, 0xc1396c28ul, 0x719501eeul
+);
+
+#ifndef VERIFY
+/* In non-VERIFY mode, we #define the fe operations to be identical to their
+ * internal field implementation, to avoid the potential overhead of a
+ * function call (even though presumably inlinable). */
+#  define nostr_native_secp256k1_fe_normalize nostr_native_secp256k1_fe_impl_normalize
+#  define nostr_native_secp256k1_fe_normalize_weak nostr_native_secp256k1_fe_impl_normalize_weak
+#  define nostr_native_secp256k1_fe_normalize_var nostr_native_secp256k1_fe_impl_normalize_var
+#  define nostr_native_secp256k1_fe_normalizes_to_zero nostr_native_secp256k1_fe_impl_normalizes_to_zero
+#  define nostr_native_secp256k1_fe_normalizes_to_zero_var nostr_native_secp256k1_fe_impl_normalizes_to_zero_var
+#  define nostr_native_secp256k1_fe_set_int nostr_native_secp256k1_fe_impl_set_int
+#  define nostr_native_secp256k1_fe_is_zero nostr_native_secp256k1_fe_impl_is_zero
+#  define nostr_native_secp256k1_fe_is_odd nostr_native_secp256k1_fe_impl_is_odd
+#  define nostr_native_secp256k1_fe_cmp_var nostr_native_secp256k1_fe_impl_cmp_var
+#  define nostr_native_secp256k1_fe_set_b32_mod nostr_native_secp256k1_fe_impl_set_b32_mod
+#  define nostr_native_secp256k1_fe_set_b32_limit nostr_native_secp256k1_fe_impl_set_b32_limit
+#  define nostr_native_secp256k1_fe_get_b32 nostr_native_secp256k1_fe_impl_get_b32
+#  define nostr_native_secp256k1_fe_negate_unchecked nostr_native_secp256k1_fe_impl_negate_unchecked
+#  define nostr_native_secp256k1_fe_mul_int_unchecked nostr_native_secp256k1_fe_impl_mul_int_unchecked
+#  define nostr_native_secp256k1_fe_add nostr_native_secp256k1_fe_impl_add
+#  define nostr_native_secp256k1_fe_mul nostr_native_secp256k1_fe_impl_mul
+#  define nostr_native_secp256k1_fe_sqr nostr_native_secp256k1_fe_impl_sqr
+#  define nostr_native_secp256k1_fe_cmov nostr_native_secp256k1_fe_impl_cmov
+#  define nostr_native_secp256k1_fe_to_storage nostr_native_secp256k1_fe_impl_to_storage
+#  define nostr_native_secp256k1_fe_from_storage nostr_native_secp256k1_fe_impl_from_storage
+#  define nostr_native_secp256k1_fe_inv nostr_native_secp256k1_fe_impl_inv
+#  define nostr_native_secp256k1_fe_inv_var nostr_native_secp256k1_fe_impl_inv_var
+#  define nostr_native_secp256k1_fe_get_bounds nostr_native_secp256k1_fe_impl_get_bounds
+#  define nostr_native_secp256k1_fe_half nostr_native_secp256k1_fe_impl_half
+#  define nostr_native_secp256k1_fe_add_int nostr_native_secp256k1_fe_impl_add_int
+#  define nostr_native_secp256k1_fe_is_square_var nostr_native_secp256k1_fe_impl_is_square_var
+#endif /* !defined(VERIFY) */
+
+/** Normalize a field element.
+ *
+ * On input, r must be a valid field element.
+ * On output, r represents the same value but has normalized=1 and magnitude=1.
+ */
+static void nostr_native_secp256k1_fe_normalize(nostr_native_secp256k1_fe *r);
+
+/** Give a field element magnitude 1.
+ *
+ * On input, r must be a valid field element.
+ * On output, r represents the same value but has magnitude=1. Normalized is unchanged.
+ */
+static void nostr_native_secp256k1_fe_normalize_weak(nostr_native_secp256k1_fe *r);
+
+/** Normalize a field element, without constant-time guarantee.
+ *
+ * Identical in behavior to nostr_native_secp256k1_fe_normalize, but not constant time in r.
+ */
+static void nostr_native_secp256k1_fe_normalize_var(nostr_native_secp256k1_fe *r);
+
+/** Determine whether r represents field element 0.
+ *
+ * On input, r must be a valid field element.
+ * Returns whether r = 0 (mod p).
+ */
+static int nostr_native_secp256k1_fe_normalizes_to_zero(const nostr_native_secp256k1_fe *r);
+
+/** Determine whether r represents field element 0, without constant-time guarantee.
+ *
+ * Identical in behavior to nostr_native_secp256k1_normalizes_to_zero, but not constant time in r.
+ */
+static int nostr_native_secp256k1_fe_normalizes_to_zero_var(const nostr_native_secp256k1_fe *r);
+
+/** Set a field element to an integer in range [0,0x7FFF].
+ *
+ * On input, r does not need to be initialized, a must be in [0,0x7FFF].
+ * On output, r represents value a, is normalized and has magnitude (a!=0).
+ */
+static void nostr_native_secp256k1_fe_set_int(nostr_native_secp256k1_fe *r, int a);
+
+/** Clear a field element to prevent leaking sensitive information. */
+static void nostr_native_secp256k1_fe_clear(nostr_native_secp256k1_fe *a);
+
+/** Determine whether a represents field element 0.
+ *
+ * On input, a must be a valid normalized field element.
+ * Returns whether a = 0 (mod p).
+ *
+ * This behaves identical to nostr_native_secp256k1_normalizes_to_zero{,_var}, but requires
+ * normalized input (and is much faster).
+ */
+static int nostr_native_secp256k1_fe_is_zero(const nostr_native_secp256k1_fe *a);
+
+/** Determine whether a (mod p) is odd.
+ *
+ * On input, a must be a valid normalized field element.
+ * Returns (int(a) mod p) & 1.
+ */
+static int nostr_native_secp256k1_fe_is_odd(const nostr_native_secp256k1_fe *a);
+
+/** Determine whether two field elements are equal.
+ *
+ * On input, a and b must be valid field elements with magnitudes not exceeding
+ * 1 and 30, respectively.
+ * Returns a = b (mod p).
+ */
+static int nostr_native_secp256k1_fe_equal(const nostr_native_secp256k1_fe *a, const nostr_native_secp256k1_fe *b);
+
+/** Compare the values represented by 2 field elements, without constant-time guarantee.
+ *
+ * On input, a and b must be valid normalized field elements.
+ * Returns 1 if a > b, -1 if a < b, and 0 if a = b (comparisons are done as integers
+ * in range 0..p-1).
+ */
+static int nostr_native_secp256k1_fe_cmp_var(const nostr_native_secp256k1_fe *a, const nostr_native_secp256k1_fe *b);
+
+/** Set a field element equal to the element represented by a provided 32-byte big endian value
+ * interpreted modulo p.
+ *
+ * On input, r does not need to be initialized. a must be a pointer to an initialized 32-byte array.
+ * On output, r = a (mod p). It will have magnitude 1, and not be normalized.
+ */
+static void nostr_native_secp256k1_fe_set_b32_mod(nostr_native_secp256k1_fe *r, const unsigned char *a);
+
+/** Set a field element equal to a provided 32-byte big endian value, checking for overflow.
+ *
+ * On input, r does not need to be initialized. a must be a pointer to an initialized 32-byte array.
+ * On output, r = a if (a < p), it will be normalized with magnitude 1, and 1 is returned.
+ * If a >= p, 0 is returned, and r will be made invalid (and must not be used without overwriting).
+ */
+static int nostr_native_secp256k1_fe_set_b32_limit(nostr_native_secp256k1_fe *r, const unsigned char *a);
+
+/** Convert a field element to 32-byte big endian byte array.
+ * On input, a must be a valid normalized field element, and r a pointer to a 32-byte array.
+ * On output, r = a (mod p).
+ */
+static void nostr_native_secp256k1_fe_get_b32(unsigned char *r, const nostr_native_secp256k1_fe *a);
+
+/** Negate a field element.
+ *
+ * On input, r does not need to be initialized. a must be a valid field element with
+ * magnitude not exceeding m. m must be an integer constant expression in [0,31].
+ * Performs {r = -a}.
+ * On output, r will not be normalized, and will have magnitude m+1.
+ */
+#define nostr_native_secp256k1_fe_negate(r, a, m) ASSERT_INT_CONST_AND_DO(m, nostr_native_secp256k1_fe_negate_unchecked(r, a, m))
+
+/** Like nostr_native_secp256k1_fe_negate_unchecked but m is not checked to be an integer constant expression.
+ *
+ * Should not be called directly outside of tests.
+ */
+static void nostr_native_secp256k1_fe_negate_unchecked(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe *a, int m);
+
+/** Add a small integer to a field element.
+ *
+ * Performs {r += a}. The magnitude of r increases by 1, and normalized is cleared.
+ * a must be in range [0,0x7FFF].
+ */
+static void nostr_native_secp256k1_fe_add_int(nostr_native_secp256k1_fe *r, int a);
+
+/** Multiply a field element with a small integer.
+ *
+ * On input, r must be a valid field element. a must be an integer constant expression in [0,32].
+ * The magnitude of r times a must not exceed 32.
+ * Performs {r *= a}.
+ * On output, r's magnitude is multiplied by a, and r will not be normalized.
+ */
+#define nostr_native_secp256k1_fe_mul_int(r, a) ASSERT_INT_CONST_AND_DO(a, nostr_native_secp256k1_fe_mul_int_unchecked(r, a))
+
+/** Like nostr_native_secp256k1_fe_mul_int but a is not checked to be an integer constant expression.
+ *
+ * Should not be called directly outside of tests.
+ */
+static void nostr_native_secp256k1_fe_mul_int_unchecked(nostr_native_secp256k1_fe *r, int a);
+
+/** Increment a field element by another.
+ *
+ * On input, r and a must be valid field elements, not necessarily normalized.
+ * The sum of their magnitudes must not exceed 32.
+ * Performs {r += a}.
+ * On output, r will not be normalized, and will have magnitude incremented by a's.
+ */
+static void nostr_native_secp256k1_fe_add(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe *a);
+
+/** Multiply two field elements.
+ *
+ * On input, a and b must be valid field elements; r does not need to be initialized.
+ * r and a may point to the same object, but neither may point to the object pointed
+ * to by b. The magnitudes of a and b must not exceed 8.
+ * Performs {r = a * b}
+ * On output, r will have magnitude 1, but won't be normalized.
+ */
+static void nostr_native_secp256k1_fe_mul(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe *a, const nostr_native_secp256k1_fe * SECP256K1_RESTRICT b);
+
+/** Square a field element.
+ *
+ * On input, a must be a valid field element; r does not need to be initialized. The magnitude
+ * of a must not exceed 8.
+ * Performs {r = a**2}
+ * On output, r will have magnitude 1, but won't be normalized.
+ */
+static void nostr_native_secp256k1_fe_sqr(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe *a);
+
+/** Compute a square root of a field element.
+ *
+ * On input, a must be a valid field element with magnitude<=8; r need not be initialized.
+ * If sqrt(a) exists, performs {r = sqrt(a)} and returns 1.
+ * Otherwise, sqrt(-a) exists. The function performs {r = sqrt(-a)} and returns 0.
+ * The resulting value represented by r will be a square itself.
+ * Variables r and a must not point to the same object.
+ * On output, r will have magnitude 1 but will not be normalized.
+ */
+static int nostr_native_secp256k1_fe_sqrt(nostr_native_secp256k1_fe * SECP256K1_RESTRICT r, const nostr_native_secp256k1_fe * SECP256K1_RESTRICT a);
+
+/** Compute the modular inverse of a field element.
+ *
+ * On input, a must be a valid field element; r need not be initialized.
+ * Performs {r = a**(p-2)} (which maps 0 to 0, and every other element to its
+ * inverse).
+ * On output, r will have magnitude (a.magnitude != 0) and be normalized.
+ */
+static void nostr_native_secp256k1_fe_inv(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe *a);
+
+/** Compute the modular inverse of a field element, without constant-time guarantee.
+ *
+ * Behaves identically to nostr_native_secp256k1_fe_inv, but is not constant-time in a.
+ */
+static void nostr_native_secp256k1_fe_inv_var(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe *a);
+
+/** Convert a field element to nostr_native_secp256k1_fe_storage.
+ *
+ * On input, a must be a valid normalized field element.
+ * Performs {r = a}.
+ */
+static void nostr_native_secp256k1_fe_to_storage(nostr_native_secp256k1_fe_storage *r, const nostr_native_secp256k1_fe *a);
+
+/** Convert a field element back from nostr_native_secp256k1_fe_storage.
+ *
+ * On input, r need not be initialized.
+ * Performs {r = a}.
+ * On output, r will be normalized and will have magnitude 1.
+ */
+static void nostr_native_secp256k1_fe_from_storage(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe_storage *a);
+
+/** If flag is 1, set *r equal to *a; if flag is 0, leave it. Constant-time.
+ * Both *r and *a must be initialized. Flag must be 0 or 1. */
+static void nostr_native_secp256k1_fe_storage_cmov(nostr_native_secp256k1_fe_storage *r, const nostr_native_secp256k1_fe_storage *a, int flag);
+
+/** Conditionally move a field element in constant time.
+ *
+ * On input, both r and a must be valid field elements. Flag must be 0 or 1.
+ * Performs {r = flag ? a : r}.
+ *
+ * On output, r's magnitude will be the maximum of both input magnitudes.
+ * It will be normalized if and only if both inputs were normalized.
+ */
+static void nostr_native_secp256k1_fe_cmov(nostr_native_secp256k1_fe *r, const nostr_native_secp256k1_fe *a, int flag);
+
+/** Halve the value of a field element modulo the field prime in constant-time.
+ *
+ * On input, r must be a valid field element.
+ * On output, r will be normalized and have magnitude floor(m/2) + 1 where m is
+ * the magnitude of r on input.
+ */
+static void nostr_native_secp256k1_fe_half(nostr_native_secp256k1_fe *r);
+
+/** Sets r to a field element with magnitude m, normalized if (and only if) m==0.
+ *  The value is chosen so that it is likely to trigger edge cases related to
+ *  internal overflows. */
+static void nostr_native_secp256k1_fe_get_bounds(nostr_native_secp256k1_fe *r, int m);
+
+/** Determine whether a is a square (modulo p).
+ *
+ * On input, a must be a valid field element.
+ */
+static int nostr_native_secp256k1_fe_is_square_var(const nostr_native_secp256k1_fe *a);
+
+/** Check invariants on a field element (no-op unless VERIFY is enabled). */
+static void nostr_native_secp256k1_fe_verify(const nostr_native_secp256k1_fe *a);
+#define SECP256K1_FE_VERIFY(a) nostr_native_secp256k1_fe_verify(a)
+
+/** Check that magnitude of a is at most m (no-op unless VERIFY is enabled). */
+static void nostr_native_secp256k1_fe_verify_magnitude(const nostr_native_secp256k1_fe *a, int m);
+#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) nostr_native_secp256k1_fe_verify_magnitude(a, m)
+
+#endif /* SECP256K1_FIELD_H */

package/vendor/secp256k1/src/field_10x26.h

@@ -0,0 +1,57 @@
+/***********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille                              *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_FIELD_REPR_H
+#define SECP256K1_FIELD_REPR_H
+
+#include <stdint.h>
+
+/** This field implementation represents the value as 10 uint32_t limbs in base
+ *  2^26. */
+typedef struct {
+   /* A field element f represents the sum(i=0..9, f.n[i] << (i*26)) mod p,
+    * where p is the field modulus, 2^256 - 2^32 - 977.
+    *
+    * The individual limbs f.n[i] can exceed 2^26; the field's magnitude roughly
+    * corresponds to how much excess is allowed. The value
+    * sum(i=0..9, f.n[i] << (i*26)) may exceed p, unless the field element is
+    * normalized. */
+    uint32_t n[10];
+    /*
+     * Magnitude m requires:
+     *     n[i] <= 2 * m * (2^26 - 1) for i=0..8
+     *     n[9] <= 2 * m * (2^22 - 1)
+     *
+     * Normalized requires:
+     *     n[i] <= (2^26 - 1) for i=0..8
+     *     sum(i=0..9, n[i] << (i*26)) < p
+     *     (together these imply n[9] <= 2^22 - 1)
+     */
+    SECP256K1_FE_VERIFY_FIELDS
+} nostr_native_secp256k1_fe;
+
+/* Unpacks a constant into a overlapping multi-limbed FE element. */
+#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
+    (d0) & 0x3FFFFFFUL, \
+    (((uint32_t)d0) >> 26) | (((uint32_t)(d1) & 0xFFFFFUL) << 6), \
+    (((uint32_t)d1) >> 20) | (((uint32_t)(d2) & 0x3FFFUL) << 12), \
+    (((uint32_t)d2) >> 14) | (((uint32_t)(d3) & 0xFFUL) << 18), \
+    (((uint32_t)d3) >> 8) | (((uint32_t)(d4) & 0x3UL) << 24), \
+    (((uint32_t)d4) >> 2) & 0x3FFFFFFUL, \
+    (((uint32_t)d4) >> 28) | (((uint32_t)(d5) & 0x3FFFFFUL) << 4), \
+    (((uint32_t)d5) >> 22) | (((uint32_t)(d6) & 0xFFFFUL) << 10), \
+    (((uint32_t)d6) >> 16) | (((uint32_t)(d7) & 0x3FFUL) << 16), \
+    (((uint32_t)d7) >> 10) \
+}
+
+typedef struct {
+    uint32_t n[8];
+} nostr_native_secp256k1_fe_storage;
+
+#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}
+#define SECP256K1_FE_STORAGE_CONST_GET(d) d.n[7], d.n[6], d.n[5], d.n[4],d.n[3], d.n[2], d.n[1], d.n[0]
+
+#endif /* SECP256K1_FIELD_REPR_H */