kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Squashed 'src/secp256k1/' changes from 84973d393..0b7024185 

0b7024185 Merge #474: Fix header guards using reserved identifiers
ab1f89f00 Merge #478: Fixed multiple typos
8c7ea22d5 Fixed multiple typos
abe2d3e84 Fix header guards using reserved identifiers
f532bdc9f Merge #459: Add pubkey prefix constants to include/secp256k1.h
cac7c5559 Merge #470: Fix wnaf_const documentation
768514bac Fix wnaf_const documentation with respect to return value and number of words set
b8c26a399 Merge #458: Fix typo in API documentation
817fb2013 Merge #440: Fix typos
12230f90e Merge #468: Remove redundant conditional expression
2e1ccdca0 Remove redundant conditional expression
bc61b91ac add pubkey prefix constants to include/secp256k1.h
b0452e664 Fix typo in API documentation
4c0f32ed5 Fix typo: "Agressive" → "Aggressive"
73aca8364 Fix typo: "exectured" → "executed"

git-subtree-dir: src/secp256k1
git-subtree-split: 0b7024185045a49a1a6a4c5615bf31c94f63d9c4
0.16
MarcoFalke 7 years ago
parent
e7c1b4490f
commit
fd86f998fc
50 changed files with 187 additions and 178 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      contrib/lax_der_parsing.h
  2. 6
      contrib/lax_der_privatekey_parsing.h
  3. 15
      include/secp256k1.h
  4. 6
      include/secp256k1_ecdh.h
  5. 6
      include/secp256k1_recovery.h
  6. 4
      sage/group_prover.sage
  7. 4
      src/asm/field_10x26_arm.s
  8. 9
      src/basic-config.h
  9. 6
      src/bench.h
  10. 6
      src/ecdsa.h
  11. 8
      src/ecdsa_impl.h
  12. 6
      src/eckey.h
  13. 17
      src/eckey_impl.h
  14. 6
      src/ecmult.h
  15. 6
      src/ecmult_const.h
  16. 13
      src/ecmult_const_impl.h
  17. 6
      src/ecmult_gen.h
  18. 6
      src/ecmult_gen_impl.h
  19. 6
      src/ecmult_impl.h
  20. 6
      src/field.h
  21. 7
      src/field_10x26.h
  22. 6
      src/field_10x26_impl.h
  23. 6
      src/field_5x52.h
  24. 6
      src/field_5x52_asm_impl.h
  25. 6
      src/field_5x52_impl.h
  26. 6
      src/field_5x52_int128_impl.h
  27. 6
      src/field_impl.h
  28. 6
      src/group.h
  29. 6
      src/group_impl.h
  30. 6
      src/hash.h
  31. 6
      src/hash_impl.h
  32. 6
      src/modules/ecdh/main_impl.h
  33. 6
      src/modules/ecdh/tests_impl.h
  34. 6
      src/modules/recovery/main_impl.h
  35. 6
      src/modules/recovery/tests_impl.h
  36. 6
      src/num.h
  37. 6
      src/num_gmp.h
  38. 6
      src/num_gmp_impl.h
  39. 6
      src/num_impl.h
  40. 6
      src/scalar.h
  41. 6
      src/scalar_4x64.h
  42. 6
      src/scalar_4x64_impl.h
  43. 6
      src/scalar_8x32.h
  44. 6
      src/scalar_8x32_impl.h
  45. 6
      src/scalar_impl.h
  46. 6
      src/scalar_low.h
  47. 6
      src/scalar_low_impl.h
  48. 6
      src/testrand.h
  49. 6
      src/testrand_impl.h
  50. 6
      src/util.h

6
contrib/lax_der_parsing.h
Unescape View File

@ -48,8 +48,8 @@
* 8.3.1. * 8.3.1.
*/ */
#ifndef _SECP256K1_CONTRIB_LAX_DER_PARSING_H_ #ifndef SECP256K1_CONTRIB_LAX_DER_PARSING_H
#define _SECP256K1_CONTRIB_LAX_DER_PARSING_H_ #define SECP256K1_CONTRIB_LAX_DER_PARSING_H
#include <secp256k1.h> #include <secp256k1.h>
@ -88,4 +88,4 @@ int ecdsa_signature_parse_der_lax(
} }
#endif #endif
#endif #endif /* SECP256K1_CONTRIB_LAX_DER_PARSING_H */

6
contrib/lax_der_privatekey_parsing.h
Unescape View File

@ -25,8 +25,8 @@
* library are sufficient. * library are sufficient.
*/ */
#ifndef _SECP256K1_CONTRIB_BER_PRIVATEKEY_H_ #ifndef SECP256K1_CONTRIB_BER_PRIVATEKEY_H
#define _SECP256K1_CONTRIB_BER_PRIVATEKEY_H_ #define SECP256K1_CONTRIB_BER_PRIVATEKEY_H
#include <secp256k1.h> #include <secp256k1.h>
@ -87,4 +87,4 @@ SECP256K1_WARN_UNUSED_RESULT int ec_privkey_import_der(
} }
#endif #endif
#endif #endif /* SECP256K1_CONTRIB_BER_PRIVATEKEY_H */

15
include/secp256k1.h
Unescape View File

@ -1,5 +1,5 @@
#ifndef _SECP256K1_ #ifndef SECP256K1_H
# define _SECP256K1_ #define SECP256K1_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -61,7 +61,7 @@ typedef struct {
* however guaranteed to be 64 bytes in size, and can be safely copied/moved. * however guaranteed to be 64 bytes in size, and can be safely copied/moved.
* If you need to convert to a format suitable for storage, transmission, or * If you need to convert to a format suitable for storage, transmission, or
* comparison, use the secp256k1_ecdsa_signature_serialize_* and * comparison, use the secp256k1_ecdsa_signature_serialize_* and
* secp256k1_ecdsa_signature_serialize_* functions. * secp256k1_ecdsa_signature_parse_* functions.
*/ */
typedef struct { typedef struct {
unsigned char data[64]; unsigned char data[64];
@ -159,6 +159,13 @@ typedef int (*secp256k1_nonce_function)(
#define SECP256K1_EC_COMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION) #define SECP256K1_EC_COMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION)
#define SECP256K1_EC_UNCOMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION) #define SECP256K1_EC_UNCOMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION)
/** Prefix byte used to tag various encoded curvepoints for specific purposes */
#define SECP256K1_TAG_PUBKEY_EVEN 0x02
#define SECP256K1_TAG_PUBKEY_ODD 0x03
#define SECP256K1_TAG_PUBKEY_UNCOMPRESSED 0x04
#define SECP256K1_TAG_PUBKEY_HYBRID_EVEN 0x06
#define SECP256K1_TAG_PUBKEY_HYBRID_ODD 0x07
/** Create a secp256k1 context object. /** Create a secp256k1 context object.
* *
* Returns: a newly created context object. * Returns: a newly created context object.
@ -611,4 +618,4 @@ SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_combine(
} }
#endif #endif
#endif #endif /* SECP256K1_H */

6
include/secp256k1_ecdh.h
Unescape View File

@ -1,5 +1,5 @@
#ifndef _SECP256K1_ECDH_ #ifndef SECP256K1_ECDH_H
# define _SECP256K1_ECDH_ #define SECP256K1_ECDH_H
#include "secp256k1.h" #include "secp256k1.h"
@ -28,4 +28,4 @@ SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdh(
} }
#endif #endif
#endif #endif /* SECP256K1_ECDH_H */

6
include/secp256k1_recovery.h
Unescape View File

@ -1,5 +1,5 @@
#ifndef _SECP256K1_RECOVERY_ #ifndef SECP256K1_RECOVERY_H
# define _SECP256K1_RECOVERY_ #define SECP256K1_RECOVERY_H
#include "secp256k1.h" #include "secp256k1.h"
@ -107,4 +107,4 @@ SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_recover(
} }
#endif #endif
#endif #endif /* SECP256K1_RECOVERY_H */

4
sage/group_prover.sage
Unescape View File

@ -3,7 +3,7 @@
# to independently set assumptions on input or intermediary variables. # to independently set assumptions on input or intermediary variables.
# #
# The general approach is: # The general approach is:
# * A constraint is a tuple of two sets of of symbolic expressions: # * A constraint is a tuple of two sets of symbolic expressions:
# the first of which are required to evaluate to zero, the second of which # the first of which are required to evaluate to zero, the second of which
# are required to evaluate to nonzero. # are required to evaluate to nonzero.
# - A constraint is said to be conflicting if any of its nonzero expressions # - A constraint is said to be conflicting if any of its nonzero expressions
@ -17,7 +17,7 @@
# - A constraint describing the requirements of the law, called "require" # - A constraint describing the requirements of the law, called "require"
# * Implementations are transliterated into functions that operate as well on # * Implementations are transliterated into functions that operate as well on
# algebraic input points, and are called once per combination of branches # algebraic input points, and are called once per combination of branches
# exectured. Each execution returns: # executed. Each execution returns:
# - A constraint describing the assumptions this implementation requires # - A constraint describing the assumptions this implementation requires
# (such as Z1=1), called "assumeFormula" # (such as Z1=1), called "assumeFormula"
# - A constraint describing the assumptions this specific branch requires, # - A constraint describing the assumptions this specific branch requires,

4
src/asm/field_10x26_arm.s
Unescape View File

@ -11,7 +11,7 @@ Note:
- To avoid unnecessary loads and make use of available registers, two - To avoid unnecessary loads and make use of available registers, two
'passes' have every time been interleaved, with the odd passes accumulating c' and d' 'passes' have every time been interleaved, with the odd passes accumulating c' and d'
which will be added to c and d respectively in the the even passes which will be added to c and d respectively in the even passes
*/ */
@ -23,7 +23,7 @@ Note:
.eabi_attribute 10, 0 @ Tag_FP_arch = none .eabi_attribute 10, 0 @ Tag_FP_arch = none
.eabi_attribute 24, 1 @ Tag_ABI_align_needed = 8-byte .eabi_attribute 24, 1 @ Tag_ABI_align_needed = 8-byte
.eabi_attribute 25, 1 @ Tag_ABI_align_preserved = 8-byte, except leaf SP .eabi_attribute 25, 1 @ Tag_ABI_align_preserved = 8-byte, except leaf SP
.eabi_attribute 30, 2 @ Tag_ABI_optimization_goals = Agressive Speed .eabi_attribute 30, 2 @ Tag_ABI_optimization_goals = Aggressive Speed
.eabi_attribute 34, 1 @ Tag_CPU_unaligned_access = v6 .eabi_attribute 34, 1 @ Tag_CPU_unaligned_access = v6
.text .text

9
src/basic-config.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_BASIC_CONFIG_ #ifndef SECP256K1_BASIC_CONFIG_H
#define _SECP256K1_BASIC_CONFIG_ #define SECP256K1_BASIC_CONFIG_H
#ifdef USE_BASIC_CONFIG #ifdef USE_BASIC_CONFIG
@ -28,5 +28,6 @@
#define USE_FIELD_10X26 1 #define USE_FIELD_10X26 1
#define USE_SCALAR_8X32 1 #define USE_SCALAR_8X32 1
#endif // USE_BASIC_CONFIG #endif /* USE_BASIC_CONFIG */
#endif // _SECP256K1_BASIC_CONFIG_
#endif /* SECP256K1_BASIC_CONFIG_H */

6
src/bench.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_BENCH_H_ #ifndef SECP256K1_BENCH_H
#define _SECP256K1_BENCH_H_ #define SECP256K1_BENCH_H
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
@ -63,4 +63,4 @@ void run_benchmark(char *name, void (*benchmark)(void*), void (*setup)(void*), v
printf("us\n"); printf("us\n");
} }
#endif #endif /* SECP256K1_BENCH_H */

6
src/ecdsa.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECDSA_ #ifndef SECP256K1_ECDSA_H
#define _SECP256K1_ECDSA_ #define SECP256K1_ECDSA_H
#include <stddef.h> #include <stddef.h>
@ -18,4 +18,4 @@ static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, size_t *size, const
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ctx, const secp256k1_scalar* r, const secp256k1_scalar* s, const secp256k1_ge *pubkey, const secp256k1_scalar *message); static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ctx, const secp256k1_scalar* r, const secp256k1_scalar* s, const secp256k1_ge *pubkey, const secp256k1_scalar *message);
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid); static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid);
#endif #endif /* SECP256K1_ECDSA_H */

8
src/ecdsa_impl.h
Unescape View File

@ -5,8 +5,8 @@
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECDSA_IMPL_H_ #ifndef SECP256K1_ECDSA_IMPL_H
#define _SECP256K1_ECDSA_IMPL_H_ #define SECP256K1_ECDSA_IMPL_H
#include "scalar.h" #include "scalar.h"
#include "field.h" #include "field.h"
@ -81,8 +81,6 @@ static int secp256k1_der_read_len(const unsigned char **sigp, const unsigned cha
return -1; return -1;
} }
while (lenleft > 0) { while (lenleft > 0) {
if ((ret >> ((sizeof(size_t) - 1) * 8)) != 0) {
}
ret = (ret << 8) | **sigp; ret = (ret << 8) | **sigp;
if (ret + lenleft > (size_t)(sigend - *sigp)) { if (ret + lenleft > (size_t)(sigend - *sigp)) {
/* Result exceeds the length of the passed array. */ /* Result exceeds the length of the passed array. */
@ -312,4 +310,4 @@ static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, sec
return 1; return 1;
} }
#endif #endif /* SECP256K1_ECDSA_IMPL_H */

6
src/eckey.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECKEY_ #ifndef SECP256K1_ECKEY_H
#define _SECP256K1_ECKEY_ #define SECP256K1_ECKEY_H
#include <stddef.h> #include <stddef.h>
@ -22,4 +22,4 @@ static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context *ctx,
static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, const secp256k1_scalar *tweak); static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, const secp256k1_scalar *tweak);
static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak); static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak);
#endif #endif /* SECP256K1_ECKEY_H */

17
src/eckey_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECKEY_IMPL_H_ #ifndef SECP256K1_ECKEY_IMPL_H
#define _SECP256K1_ECKEY_IMPL_H_ #define SECP256K1_ECKEY_IMPL_H
#include "eckey.h" #include "eckey.h"
@ -15,16 +15,17 @@
#include "ecmult_gen.h" #include "ecmult_gen.h"
static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size) { static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size) {
if (size == 33 && (pub[0] == 0x02 || pub[0] == 0x03)) { if (size == 33 && (pub[0] == SECP256K1_TAG_PUBKEY_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_ODD)) {
secp256k1_fe x; secp256k1_fe x;
return secp256k1_fe_set_b32(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == 0x03); return secp256k1_fe_set_b32(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == SECP256K1_TAG_PUBKEY_ODD);
} else if (size == 65 && (pub[0] == 0x04 || pub[0] == 0x06 || pub[0] == 0x07)) { } else if (size == 65 && (pub[0] == 0x04 || pub[0] == 0x06 || pub[0] == 0x07)) {
secp256k1_fe x, y; secp256k1_fe x, y;
if (!secp256k1_fe_set_b32(&x, pub+1) || !secp256k1_fe_set_b32(&y, pub+33)) { if (!secp256k1_fe_set_b32(&x, pub+1) || !secp256k1_fe_set_b32(&y, pub+33)) {
return 0; return 0;
} }
secp256k1_ge_set_xy(elem, &x, &y); secp256k1_ge_set_xy(elem, &x, &y);
if ((pub[0] == 0x06 || pub[0] == 0x07) && secp256k1_fe_is_odd(&y) != (pub[0] == 0x07)) { if ((pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD) &&
secp256k1_fe_is_odd(&y) != (pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
return 0; return 0;
} }
return secp256k1_ge_is_valid_var(elem); return secp256k1_ge_is_valid_var(elem);
@ -42,10 +43,10 @@ static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *p
secp256k1_fe_get_b32(&pub[1], &elem->x); secp256k1_fe_get_b32(&pub[1], &elem->x);
if (compressed) { if (compressed) {
*size = 33; *size = 33;
pub[0] = 0x02 | (secp256k1_fe_is_odd(&elem->y) ? 0x01 : 0x00); pub[0] = secp256k1_fe_is_odd(&elem->y) ? SECP256K1_TAG_PUBKEY_ODD : SECP256K1_TAG_PUBKEY_EVEN;
} else { } else {
*size = 65; *size = 65;
pub[0] = 0x04; pub[0] = SECP256K1_TAG_PUBKEY_UNCOMPRESSED;
secp256k1_fe_get_b32(&pub[33], &elem->y); secp256k1_fe_get_b32(&pub[33], &elem->y);
} }
return 1; return 1;
@ -96,4 +97,4 @@ static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context *ctx,
return 1; return 1;
} }
#endif #endif /* SECP256K1_ECKEY_IMPL_H */

6
src/ecmult.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECMULT_ #ifndef SECP256K1_ECMULT_H
#define _SECP256K1_ECMULT_ #define SECP256K1_ECMULT_H
#include "num.h" #include "num.h"
#include "group.h" #include "group.h"
@ -28,4 +28,4 @@ static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context *ctx
/** Double multiply: R = na*A + ng*G */ /** Double multiply: R = na*A + ng*G */
static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng); static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng);
#endif #endif /* SECP256K1_ECMULT_H */

6
src/ecmult_const.h
Unescape View File

@ -4,12 +4,12 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECMULT_CONST_ #ifndef SECP256K1_ECMULT_CONST_H
#define _SECP256K1_ECMULT_CONST_ #define SECP256K1_ECMULT_CONST_H
#include "scalar.h" #include "scalar.h"
#include "group.h" #include "group.h"
static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *q); static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *q);
#endif #endif /* SECP256K1_ECMULT_CONST_H */

13
src/ecmult_const_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECMULT_CONST_IMPL_ #ifndef SECP256K1_ECMULT_CONST_IMPL_H
#define _SECP256K1_ECMULT_CONST_IMPL_ #define SECP256K1_ECMULT_CONST_IMPL_H
#include "scalar.h" #include "scalar.h"
#include "group.h" #include "group.h"
@ -42,11 +42,12 @@
} while(0) } while(0)
/** Convert a number to WNAF notation. The number becomes represented by sum(2^{wi} * wnaf[i], i=0..return_val) /** Convert a number to WNAF notation.
* with the following guarantees: * The number becomes represented by sum(2^{wi} * wnaf[i], i=0..WNAF_SIZE(w)+1) - return_val.
* It has the following guarantees:
* - each wnaf[i] an odd integer between -(1 << w) and (1 << w) * - each wnaf[i] an odd integer between -(1 << w) and (1 << w)
* - each wnaf[i] is nonzero * - each wnaf[i] is nonzero
* - the number of words set is returned; this is always (WNAF_BITS + w - 1) / w * - the number of words set is always WNAF_SIZE(w) + 1
* *
* Adapted from `The Width-w NAF Method Provides Small Memory and Fast Elliptic Scalar * Adapted from `The Width-w NAF Method Provides Small Memory and Fast Elliptic Scalar
* Multiplications Secure against Side Channel Attacks`, Okeya and Tagaki. M. Joye (Ed.) * Multiplications Secure against Side Channel Attacks`, Okeya and Tagaki. M. Joye (Ed.)
@ -236,4 +237,4 @@ static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, cons
} }
} }
#endif #endif /* SECP256K1_ECMULT_CONST_IMPL_H */

6
src/ecmult_gen.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECMULT_GEN_ #ifndef SECP256K1_ECMULT_GEN_H
#define _SECP256K1_ECMULT_GEN_ #define SECP256K1_ECMULT_GEN_H
#include "scalar.h" #include "scalar.h"
#include "group.h" #include "group.h"
@ -40,4 +40,4 @@ static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context* ctx, secp25
static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const unsigned char *seed32); static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const unsigned char *seed32);
#endif #endif /* SECP256K1_ECMULT_GEN_H */

6
src/ecmult_gen_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECMULT_GEN_IMPL_H_ #ifndef SECP256K1_ECMULT_GEN_IMPL_H
#define _SECP256K1_ECMULT_GEN_IMPL_H_ #define SECP256K1_ECMULT_GEN_IMPL_H
#include "scalar.h" #include "scalar.h"
#include "group.h" #include "group.h"
@ -207,4 +207,4 @@ static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const
secp256k1_gej_clear(&gb); secp256k1_gej_clear(&gb);
} }
#endif #endif /* SECP256K1_ECMULT_GEN_IMPL_H */

6
src/ecmult_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_ECMULT_IMPL_H_ #ifndef SECP256K1_ECMULT_IMPL_H
#define _SECP256K1_ECMULT_IMPL_H_ #define SECP256K1_ECMULT_IMPL_H
#include <string.h> #include <string.h>
@ -403,4 +403,4 @@ static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej
} }
} }
#endif #endif /* SECP256K1_ECMULT_IMPL_H */

6
src/field.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_FIELD_ #ifndef SECP256K1_FIELD_H
#define _SECP256K1_FIELD_ #define SECP256K1_FIELD_H
/** Field element module. /** Field element module.
* *
@ -129,4 +129,4 @@ static void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_f
/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */ /** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
static void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag); static void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag);
#endif #endif /* SECP256K1_FIELD_H */

7
src/field_10x26.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_FIELD_REPR_ #ifndef SECP256K1_FIELD_REPR_H
#define _SECP256K1_FIELD_REPR_ #define SECP256K1_FIELD_REPR_H
#include <stdint.h> #include <stdint.h>
@ -44,4 +44,5 @@ typedef struct {
#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(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] #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
#endif /* SECP256K1_FIELD_REPR_H */

6
src/field_10x26_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_FIELD_REPR_IMPL_H_ #ifndef SECP256K1_FIELD_REPR_IMPL_H
#define _SECP256K1_FIELD_REPR_IMPL_H_ #define SECP256K1_FIELD_REPR_IMPL_H
#include "util.h" #include "util.h"
#include "num.h" #include "num.h"
@ -1158,4 +1158,4 @@ static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const se
#endif #endif
} }
#endif #endif /* SECP256K1_FIELD_REPR_IMPL_H */

6
src/field_5x52.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_FIELD_REPR_ #ifndef SECP256K1_FIELD_REPR_H
#define _SECP256K1_FIELD_REPR_ #define SECP256K1_FIELD_REPR_H
#include <stdint.h> #include <stdint.h>
@ -44,4 +44,4 @@ typedef struct {
(d6) | (((uint64_t)(d7)) << 32) \ (d6) | (((uint64_t)(d7)) << 32) \
}} }}
#endif #endif /* SECP256K1_FIELD_REPR_H */

6
src/field_5x52_asm_impl.h
Unescape View File

@ -11,8 +11,8 @@
* - December 2014, Pieter Wuille: converted from YASM to GCC inline assembly * - December 2014, Pieter Wuille: converted from YASM to GCC inline assembly
*/ */
#ifndef _SECP256K1_FIELD_INNER5X52_IMPL_H_ #ifndef SECP256K1_FIELD_INNER5X52_IMPL_H
#define _SECP256K1_FIELD_INNER5X52_IMPL_H_ #define SECP256K1_FIELD_INNER5X52_IMPL_H
SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) { SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
/** /**
@ -499,4 +499,4 @@ __asm__ __volatile__(
); );
} }
#endif #endif /* SECP256K1_FIELD_INNER5X52_IMPL_H */

6
src/field_5x52_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_FIELD_REPR_IMPL_H_ #ifndef SECP256K1_FIELD_REPR_IMPL_H
#define _SECP256K1_FIELD_REPR_IMPL_H_ #define SECP256K1_FIELD_REPR_IMPL_H
#if defined HAVE_CONFIG_H #if defined HAVE_CONFIG_H
#include "libsecp256k1-config.h" #include "libsecp256k1-config.h"
@ -493,4 +493,4 @@ static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const se
#endif #endif
} }
#endif #endif /* SECP256K1_FIELD_REPR_IMPL_H */

6
src/field_5x52_int128_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_FIELD_INNER5X52_IMPL_H_ #ifndef SECP256K1_FIELD_INNER5X52_IMPL_H
#define _SECP256K1_FIELD_INNER5X52_IMPL_H_ #define SECP256K1_FIELD_INNER5X52_IMPL_H
#include <stdint.h> #include <stdint.h>
@ -274,4 +274,4 @@ SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t
/* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */ /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
} }
#endif #endif /* SECP256K1_FIELD_INNER5X52_IMPL_H */

6
src/field_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_FIELD_IMPL_H_ #ifndef SECP256K1_FIELD_IMPL_H
#define _SECP256K1_FIELD_IMPL_H_ #define SECP256K1_FIELD_IMPL_H
#if defined HAVE_CONFIG_H #if defined HAVE_CONFIG_H
#include "libsecp256k1-config.h" #include "libsecp256k1-config.h"
@ -312,4 +312,4 @@ static int secp256k1_fe_is_quad_var(const secp256k1_fe *a) {
#endif #endif
} }
#endif #endif /* SECP256K1_FIELD_IMPL_H */

6
src/group.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_GROUP_ #ifndef SECP256K1_GROUP_H
#define _SECP256K1_GROUP_ #define SECP256K1_GROUP_H
#include "num.h" #include "num.h"
#include "field.h" #include "field.h"
@ -141,4 +141,4 @@ static void secp256k1_ge_storage_cmov(secp256k1_ge_storage *r, const secp256k1_g
/** Rescale a jacobian point by b which must be non-zero. Constant-time. */ /** Rescale a jacobian point by b which must be non-zero. Constant-time. */
static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *b); static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *b);
#endif #endif /* SECP256K1_GROUP_H */

6
src/group_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_GROUP_IMPL_H_ #ifndef SECP256K1_GROUP_IMPL_H
#define _SECP256K1_GROUP_IMPL_H_ #define SECP256K1_GROUP_IMPL_H
#include "num.h" #include "num.h"
#include "field.h" #include "field.h"
@ -697,4 +697,4 @@ static int secp256k1_gej_has_quad_y_var(const secp256k1_gej *a) {
return secp256k1_fe_is_quad_var(&yz); return secp256k1_fe_is_quad_var(&yz);
} }
#endif #endif /* SECP256K1_GROUP_IMPL_H */

6
src/hash.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_HASH_ #ifndef SECP256K1_HASH_H
#define _SECP256K1_HASH_ #define SECP256K1_HASH_H
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
@ -38,4 +38,4 @@ static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha2
static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen); static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen);
static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng); static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng);
#endif #endif /* SECP256K1_HASH_H */

6
src/hash_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_HASH_IMPL_H_ #ifndef SECP256K1_HASH_IMPL_H
#define _SECP256K1_HASH_IMPL_H_ #define SECP256K1_HASH_IMPL_H
#include "hash.h" #include "hash.h"
@ -278,4 +278,4 @@ static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256
#undef Maj #undef Maj
#undef Ch #undef Ch
#endif #endif /* SECP256K1_HASH_IMPL_H */

6
src/modules/ecdh/main_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_MODULE_ECDH_MAIN_ #ifndef SECP256K1_MODULE_ECDH_MAIN_H
#define _SECP256K1_MODULE_ECDH_MAIN_ #define SECP256K1_MODULE_ECDH_MAIN_H
#include "include/secp256k1_ecdh.h" #include "include/secp256k1_ecdh.h"
#include "ecmult_const_impl.h" #include "ecmult_const_impl.h"
@ -51,4 +51,4 @@ int secp256k1_ecdh(const secp256k1_context* ctx, unsigned char *result, const se
return ret; return ret;
} }
#endif #endif /* SECP256K1_MODULE_ECDH_MAIN_H */

6
src/modules/ecdh/tests_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_MODULE_ECDH_TESTS_ #ifndef SECP256K1_MODULE_ECDH_TESTS_H
#define _SECP256K1_MODULE_ECDH_TESTS_ #define SECP256K1_MODULE_ECDH_TESTS_H
void test_ecdh_api(void) { void test_ecdh_api(void) {
/* Setup context that just counts errors */ /* Setup context that just counts errors */
@ -102,4 +102,4 @@ void run_ecdh_tests(void) {
test_bad_scalar(); test_bad_scalar();
} }
#endif #endif /* SECP256K1_MODULE_ECDH_TESTS_H */

6
src/modules/recovery/main_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_MODULE_RECOVERY_MAIN_ #ifndef SECP256K1_MODULE_RECOVERY_MAIN_H
#define _SECP256K1_MODULE_RECOVERY_MAIN_ #define SECP256K1_MODULE_RECOVERY_MAIN_H
#include "include/secp256k1_recovery.h" #include "include/secp256k1_recovery.h"
@ -190,4 +190,4 @@ int secp256k1_ecdsa_recover(const secp256k1_context* ctx, secp256k1_pubkey *pubk
} }
} }
#endif #endif /* SECP256K1_MODULE_RECOVERY_MAIN_H */

6
src/modules/recovery/tests_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_MODULE_RECOVERY_TESTS_ #ifndef SECP256K1_MODULE_RECOVERY_TESTS_H
#define _SECP256K1_MODULE_RECOVERY_TESTS_ #define SECP256K1_MODULE_RECOVERY_TESTS_H
static int recovery_test_nonce_function(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) { static int recovery_test_nonce_function(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
(void) msg32; (void) msg32;
@ -390,4 +390,4 @@ void run_recovery_tests(void) {
test_ecdsa_recovery_edge_cases(); test_ecdsa_recovery_edge_cases();
} }
#endif #endif /* SECP256K1_MODULE_RECOVERY_TESTS_H */

6
src/num.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_NUM_ #ifndef SECP256K1_NUM_H
#define _SECP256K1_NUM_ #define SECP256K1_NUM_H
#ifndef USE_NUM_NONE #ifndef USE_NUM_NONE
@ -71,4 +71,4 @@ static void secp256k1_num_negate(secp256k1_num *r);
#endif #endif
#endif #endif /* SECP256K1_NUM_H */

6
src/num_gmp.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_NUM_REPR_ #ifndef SECP256K1_NUM_REPR_H
#define _SECP256K1_NUM_REPR_ #define SECP256K1_NUM_REPR_H
#include <gmp.h> #include <gmp.h>
@ -17,4 +17,4 @@ typedef struct {
int limbs; int limbs;
} secp256k1_num; } secp256k1_num;
#endif #endif /* SECP256K1_NUM_REPR_H */

6
src/num_gmp_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_NUM_REPR_IMPL_H_ #ifndef SECP256K1_NUM_REPR_IMPL_H
#define _SECP256K1_NUM_REPR_IMPL_H_ #define SECP256K1_NUM_REPR_IMPL_H
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
@ -285,4 +285,4 @@ static void secp256k1_num_negate(secp256k1_num *r) {
r->neg ^= 1; r->neg ^= 1;
} }
#endif #endif /* SECP256K1_NUM_REPR_IMPL_H */

6
src/num_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_NUM_IMPL_H_ #ifndef SECP256K1_NUM_IMPL_H
#define _SECP256K1_NUM_IMPL_H_ #define SECP256K1_NUM_IMPL_H
#if defined HAVE_CONFIG_H #if defined HAVE_CONFIG_H
#include "libsecp256k1-config.h" #include "libsecp256k1-config.h"
@ -21,4 +21,4 @@
#error "Please select num implementation" #error "Please select num implementation"
#endif #endif
#endif #endif /* SECP256K1_NUM_IMPL_H */

6
src/scalar.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_ #ifndef SECP256K1_SCALAR_H
#define _SECP256K1_SCALAR_ #define SECP256K1_SCALAR_H
#include "num.h" #include "num.h"
@ -103,4 +103,4 @@ static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar
/** Multiply a and b (without taking the modulus!), divide by 2**shift, and round to the nearest integer. Shift must be at least 256. */ /** 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 secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift); static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift);
#endif #endif /* SECP256K1_SCALAR_H */

6
src/scalar_4x64.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_REPR_ #ifndef SECP256K1_SCALAR_REPR_H
#define _SECP256K1_SCALAR_REPR_ #define SECP256K1_SCALAR_REPR_H
#include <stdint.h> #include <stdint.h>
@ -16,4 +16,4 @@ typedef struct {
#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)}} #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 #endif /* SECP256K1_SCALAR_REPR_H */

6
src/scalar_4x64_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_ #ifndef SECP256K1_SCALAR_REPR_IMPL_H
#define _SECP256K1_SCALAR_REPR_IMPL_H_ #define SECP256K1_SCALAR_REPR_IMPL_H
/* Limbs of the secp256k1 order. */ /* Limbs of the secp256k1 order. */
#define SECP256K1_N_0 ((uint64_t)0xBFD25E8CD0364141ULL) #define SECP256K1_N_0 ((uint64_t)0xBFD25E8CD0364141ULL)
@ -946,4 +946,4 @@ SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r,
secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 6] >> ((shift - 1) & 0x3f)) & 1); secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 6] >> ((shift - 1) & 0x3f)) & 1);
} }
#endif #endif /* SECP256K1_SCALAR_REPR_IMPL_H */

6
src/scalar_8x32.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_REPR_ #ifndef SECP256K1_SCALAR_REPR_H
#define _SECP256K1_SCALAR_REPR_ #define SECP256K1_SCALAR_REPR_H
#include <stdint.h> #include <stdint.h>
@ -16,4 +16,4 @@ typedef struct {
#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)}} #define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)}}
#endif #endif /* SECP256K1_SCALAR_REPR_H */

6
src/scalar_8x32_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_ #ifndef SECP256K1_SCALAR_REPR_IMPL_H
#define _SECP256K1_SCALAR_REPR_IMPL_H_ #define SECP256K1_SCALAR_REPR_IMPL_H
/* Limbs of the secp256k1 order. */ /* Limbs of the secp256k1 order. */
#define SECP256K1_N_0 ((uint32_t)0xD0364141UL) #define SECP256K1_N_0 ((uint32_t)0xD0364141UL)
@ -718,4 +718,4 @@ SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r,
secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1); secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1);
} }
#endif #endif /* SECP256K1_SCALAR_REPR_IMPL_H */

6
src/scalar_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_IMPL_H_ #ifndef SECP256K1_SCALAR_IMPL_H
#define _SECP256K1_SCALAR_IMPL_H_ #define SECP256K1_SCALAR_IMPL_H
#include "group.h" #include "group.h"
#include "scalar.h" #include "scalar.h"
@ -330,4 +330,4 @@ static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar
#endif #endif
#endif #endif
#endif #endif /* SECP256K1_SCALAR_IMPL_H */

6
src/scalar_low.h
Unescape View File

@ -4,12 +4,12 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_REPR_ #ifndef SECP256K1_SCALAR_REPR_H
#define _SECP256K1_SCALAR_REPR_ #define SECP256K1_SCALAR_REPR_H
#include <stdint.h> #include <stdint.h>
/** A scalar modulo the group order of the secp256k1 curve. */ /** A scalar modulo the group order of the secp256k1 curve. */
typedef uint32_t secp256k1_scalar; typedef uint32_t secp256k1_scalar;
#endif #endif /* SECP256K1_SCALAR_REPR_H */

6
src/scalar_low_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_ #ifndef SECP256K1_SCALAR_REPR_IMPL_H
#define _SECP256K1_SCALAR_REPR_IMPL_H_ #define SECP256K1_SCALAR_REPR_IMPL_H
#include "scalar.h" #include "scalar.h"
@ -111,4 +111,4 @@ SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const
return *a == *b; return *a == *b;
} }
#endif #endif /* SECP256K1_SCALAR_REPR_IMPL_H */

6
src/testrand.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_TESTRAND_H_ #ifndef SECP256K1_TESTRAND_H
#define _SECP256K1_TESTRAND_H_ #define SECP256K1_TESTRAND_H
#if defined HAVE_CONFIG_H #if defined HAVE_CONFIG_H
#include "libsecp256k1-config.h" #include "libsecp256k1-config.h"
@ -35,4 +35,4 @@ static void secp256k1_rand256_test(unsigned char *b32);
/** Generate pseudorandom bytes with long sequences of zero and one bits. */ /** Generate pseudorandom bytes with long sequences of zero and one bits. */
static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len); static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len);
#endif #endif /* SECP256K1_TESTRAND_H */

6
src/testrand_impl.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_TESTRAND_IMPL_H_ #ifndef SECP256K1_TESTRAND_IMPL_H
#define _SECP256K1_TESTRAND_IMPL_H_ #define SECP256K1_TESTRAND_IMPL_H
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
@ -107,4 +107,4 @@ static void secp256k1_rand256_test(unsigned char *b32) {
secp256k1_rand_bytes_test(b32, 32); secp256k1_rand_bytes_test(b32, 32);
} }
#endif #endif /* SECP256K1_TESTRAND_IMPL_H */

6
src/util.h
Unescape View File

@ -4,8 +4,8 @@
* file COPYING or http://www.opensource.org/licenses/mit-license.php.* * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/ **********************************************************************/
#ifndef _SECP256K1_UTIL_H_ #ifndef SECP256K1_UTIL_H
#define _SECP256K1_UTIL_H_ #define SECP256K1_UTIL_H
#if defined HAVE_CONFIG_H #if defined HAVE_CONFIG_H
#include "libsecp256k1-config.h" #include "libsecp256k1-config.h"
@ -110,4 +110,4 @@ static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_
SECP256K1_GNUC_EXT typedef unsigned __int128 uint128_t; SECP256K1_GNUC_EXT typedef unsigned __int128 uint128_t;
#endif #endif
#endif #endif /* SECP256K1_UTIL_H */

Write Preview
Loading…
Cancel
Save