@qntx/nostr-native 0.0.0-stage → 0.12.1

package/vendor/secp256k1/src/precomputed_ecmult_gen.h

@@ -0,0 +1,28 @@
+/*********************************************************************************
+ * Copyright (c) 2013, 2014, 2015, 2021 Thomas Daede, Cory Fields, Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying              *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.          *
+ *********************************************************************************/
+
+#ifndef SECP256K1_PRECOMPUTED_ECMULT_GEN_H
+#define SECP256K1_PRECOMPUTED_ECMULT_GEN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "group.h"
+#include "ecmult_gen.h"
+#include "util_local_visibility.h"
+
+#ifdef EXHAUSTIVE_TEST_ORDER
+static nostr_native_secp256k1_ge_storage nostr_native_secp256k1_ecmult_gen_prec_table[COMB_BLOCKS][COMB_POINTS];
+#else
+SECP256K1_LOCAL_VAR const nostr_native_secp256k1_ge_storage nostr_native_secp256k1_ecmult_gen_prec_table[COMB_BLOCKS][COMB_POINTS];
+#endif /* defined(EXHAUSTIVE_TEST_ORDER) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SECP256K1_PRECOMPUTED_ECMULT_GEN_H */

package/vendor/secp256k1/src/scalar.h

@@ -0,0 +1,105 @@
+/***********************************************************************
+ * Copyright (c) 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_SCALAR_H
+#define SECP256K1_SCALAR_H
+
+#include "util.h"
+
+#if defined(EXHAUSTIVE_TEST_ORDER)
+#include "scalar_low.h"
+#elif defined(SECP256K1_WIDEMUL_INT128)
+#include "scalar_4x64.h"
+#elif defined(SECP256K1_WIDEMUL_INT64)
+#include "scalar_8x32.h"
+#else
+#error "Please select wide multiplication implementation"
+#endif
+
+/** Clear a scalar to prevent the leak of sensitive data. */
+static void nostr_native_secp256k1_scalar_clear(nostr_native_secp256k1_scalar *r);
+
+/** Access bits (1 <= count <= 32) from a scalar. All requested bits must belong to the same 32-bit limb. */
+static uint32_t nostr_native_secp256k1_scalar_get_bits_limb32(const nostr_native_secp256k1_scalar *a, unsigned int offset, unsigned int count);
+
+/** Access bits (1 <= count <= 32) from a scalar. offset + count must be <= 256. Not constant time in offset and count. */
+static uint32_t nostr_native_secp256k1_scalar_get_bits_var(const nostr_native_secp256k1_scalar *a, unsigned int offset, unsigned int count);
+
+/** Set a scalar from a big endian byte array. The scalar will be reduced modulo group order `n`.
+ * In:      bin:        pointer to a 32-byte array.
+ * Out:     r:          scalar to be set.
+ *          overflow:   non-zero if the scalar was bigger or equal to `n` before reduction, zero otherwise (can be NULL).
+ */
+static void nostr_native_secp256k1_scalar_set_b32(nostr_native_secp256k1_scalar *r, const unsigned char *bin, int *overflow);
+
+/** Set a scalar from a big endian byte array and returns 1 if it is a valid
+ *  seckey and 0 otherwise. */
+static int nostr_native_secp256k1_scalar_set_b32_seckey(nostr_native_secp256k1_scalar *r, const unsigned char *bin);
+
+/** Set a scalar to an unsigned integer. */
+static void nostr_native_secp256k1_scalar_set_int(nostr_native_secp256k1_scalar *r, unsigned int v);
+
+/** Convert a scalar to a byte array. */
+static void nostr_native_secp256k1_scalar_get_b32(unsigned char *bin, const nostr_native_secp256k1_scalar* a);
+
+/** Add two scalars together (modulo the group order). Returns whether it overflowed. */
+static int nostr_native_secp256k1_scalar_add(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a, const nostr_native_secp256k1_scalar *b);
+
+/** Conditionally add a power of two to a scalar. The result is not allowed to overflow. Flag must be 0 or 1. */
+static void nostr_native_secp256k1_scalar_cadd_bit(nostr_native_secp256k1_scalar *r, unsigned int bit, int flag);
+
+/** Multiply two scalars (modulo the group order). */
+static void nostr_native_secp256k1_scalar_mul(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a, const nostr_native_secp256k1_scalar *b);
+
+/** Compute the inverse of a scalar (modulo the group order). */
+static void nostr_native_secp256k1_scalar_inverse(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a);
+
+/** Compute the inverse of a scalar (modulo the group order), without constant-time guarantee. */
+static void nostr_native_secp256k1_scalar_inverse_var(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a);
+
+/** Compute the complement of a scalar (modulo the group order). */
+static void nostr_native_secp256k1_scalar_negate(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a);
+
+/** Multiply a scalar with the multiplicative inverse of 2. */
+static void nostr_native_secp256k1_scalar_half(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a);
+
+/** Check whether a scalar equals zero. */
+static int nostr_native_secp256k1_scalar_is_zero(const nostr_native_secp256k1_scalar *a);
+
+/** Check whether a scalar equals one. */
+static int nostr_native_secp256k1_scalar_is_one(const nostr_native_secp256k1_scalar *a);
+
+/** Check whether a scalar, considered as an nonnegative integer, is even. */
+static int nostr_native_secp256k1_scalar_is_even(const nostr_native_secp256k1_scalar *a);
+
+/** Check whether a scalar is higher than the group order divided by 2. */
+static int nostr_native_secp256k1_scalar_is_high(const nostr_native_secp256k1_scalar *a);
+
+/** Conditionally negate a number, in constant time. Flag must be 0 or 1.
+ * Returns -1 if the number was negated, 1 otherwise */
+static int nostr_native_secp256k1_scalar_cond_negate(nostr_native_secp256k1_scalar *a, int flag);
+
+/** Compare two scalars. */
+static int nostr_native_secp256k1_scalar_eq(const nostr_native_secp256k1_scalar *a, const nostr_native_secp256k1_scalar *b);
+
+/** Find r1 and r2 such that r1+r2*2^128 = k. */
+static void nostr_native_secp256k1_scalar_split_128(nostr_native_secp256k1_scalar *r1, nostr_native_secp256k1_scalar *r2, const nostr_native_secp256k1_scalar *k);
+/** Find r1 and r2 such that r1+r2*lambda = k, where r1 and r2 or their
+ *  negations are maximum 128 bits long (see nostr_native_secp256k1_ge_mul_lambda). It is
+ *  required that r1, r2, and k all point to different objects. */
+static void nostr_native_secp256k1_scalar_split_lambda(nostr_native_secp256k1_scalar * SECP256K1_RESTRICT r1, nostr_native_secp256k1_scalar * SECP256K1_RESTRICT r2, const nostr_native_secp256k1_scalar * SECP256K1_RESTRICT k);
+
+/** Multiply a and b (without taking the modulus!), divide by 2**shift, and round to the nearest integer. Shift must be at least 256. */
+static void nostr_native_secp256k1_scalar_mul_shift_var(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a, const nostr_native_secp256k1_scalar *b, unsigned int shift);
+
+/** 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_scalar_cmov(nostr_native_secp256k1_scalar *r, const nostr_native_secp256k1_scalar *a, int flag);
+
+/** Check invariants on a scalar (no-op unless VERIFY is enabled). */
+static void nostr_native_secp256k1_scalar_verify(const nostr_native_secp256k1_scalar *r);
+#define SECP256K1_SCALAR_VERIFY(r) nostr_native_secp256k1_scalar_verify(r)
+
+#endif /* SECP256K1_SCALAR_H */

package/vendor/secp256k1/src/scalar_4x64.h

@@ -0,0 +1,19 @@
+/***********************************************************************
+ * Copyright (c) 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_SCALAR_REPR_H
+#define SECP256K1_SCALAR_REPR_H
+
+#include <stdint.h>
+
+/** A scalar modulo the group order of the secp256k1 curve. */
+typedef struct {
+    uint64_t d[4];
+} nostr_native_secp256k1_scalar;
+
+#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{((uint64_t)(d1)) << 32 | (d0), ((uint64_t)(d3)) << 32 | (d2), ((uint64_t)(d5)) << 32 | (d4), ((uint64_t)(d7)) << 32 | (d6)}}
+
+#endif /* SECP256K1_SCALAR_REPR_H */