github.com/ethereum/go-ethereum@v1.16.1/crypto/secp256k1/libsecp256k1/src/testutil.h (about)

     1  /***********************************************************************
     2   * Distributed under the MIT software license, see the accompanying    *
     3   * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
     4   ***********************************************************************/
     5  
     6  #ifndef SECP256K1_TESTUTIL_H
     7  #define SECP256K1_TESTUTIL_H
     8  
     9  #include "field.h"
    10  #include "group.h"
    11  #include "testrand.h"
    12  #include "util.h"
    13  
    14  static void testutil_random_fe(secp256k1_fe *x) {
    15      unsigned char bin[32];
    16      do {
    17          testrand256(bin);
    18          if (secp256k1_fe_set_b32_limit(x, bin)) {
    19              return;
    20          }
    21      } while(1);
    22  }
    23  
    24  static void testutil_random_fe_non_zero(secp256k1_fe *nz) {
    25      do {
    26          testutil_random_fe(nz);
    27      } while (secp256k1_fe_is_zero(nz));
    28  }
    29  
    30  static void testutil_random_fe_magnitude(secp256k1_fe *fe, int m) {
    31      secp256k1_fe zero;
    32      int n = testrand_int(m + 1);
    33      secp256k1_fe_normalize(fe);
    34      if (n == 0) {
    35          return;
    36      }
    37      secp256k1_fe_set_int(&zero, 0);
    38      secp256k1_fe_negate(&zero, &zero, 0);
    39      secp256k1_fe_mul_int_unchecked(&zero, n - 1);
    40      secp256k1_fe_add(fe, &zero);
    41  #ifdef VERIFY
    42      CHECK(fe->magnitude == n);
    43  #endif
    44  }
    45  
    46  static void testutil_random_fe_test(secp256k1_fe *x) {
    47      unsigned char bin[32];
    48      do {
    49          testrand256_test(bin);
    50          if (secp256k1_fe_set_b32_limit(x, bin)) {
    51              return;
    52          }
    53      } while(1);
    54  }
    55  
    56  static void testutil_random_fe_non_zero_test(secp256k1_fe *fe) {
    57      do {
    58          testutil_random_fe_test(fe);
    59      } while(secp256k1_fe_is_zero(fe));
    60  }
    61  
    62  static void testutil_random_ge_x_magnitude(secp256k1_ge *ge) {
    63      testutil_random_fe_magnitude(&ge->x, SECP256K1_GE_X_MAGNITUDE_MAX);
    64  }
    65  
    66  static void testutil_random_ge_y_magnitude(secp256k1_ge *ge) {
    67      testutil_random_fe_magnitude(&ge->y, SECP256K1_GE_Y_MAGNITUDE_MAX);
    68  }
    69  
    70  static void testutil_random_gej_x_magnitude(secp256k1_gej *gej) {
    71      testutil_random_fe_magnitude(&gej->x, SECP256K1_GEJ_X_MAGNITUDE_MAX);
    72  }
    73  
    74  static void testutil_random_gej_y_magnitude(secp256k1_gej *gej) {
    75      testutil_random_fe_magnitude(&gej->y, SECP256K1_GEJ_Y_MAGNITUDE_MAX);
    76  }
    77  
    78  static void testutil_random_gej_z_magnitude(secp256k1_gej *gej) {
    79      testutil_random_fe_magnitude(&gej->z, SECP256K1_GEJ_Z_MAGNITUDE_MAX);
    80  }
    81  
    82  static void testutil_random_ge_test(secp256k1_ge *ge) {
    83      secp256k1_fe fe;
    84      do {
    85          testutil_random_fe_test(&fe);
    86          if (secp256k1_ge_set_xo_var(ge, &fe, testrand_bits(1))) {
    87              secp256k1_fe_normalize(&ge->y);
    88              break;
    89          }
    90      } while(1);
    91      ge->infinity = 0;
    92  }
    93  
    94  static void testutil_random_ge_jacobian_test(secp256k1_gej *gej, const secp256k1_ge *ge) {
    95      secp256k1_fe z2, z3;
    96      testutil_random_fe_non_zero_test(&gej->z);
    97      secp256k1_fe_sqr(&z2, &gej->z);
    98      secp256k1_fe_mul(&z3, &z2, &gej->z);
    99      secp256k1_fe_mul(&gej->x, &ge->x, &z2);
   100      secp256k1_fe_mul(&gej->y, &ge->y, &z3);
   101      gej->infinity = ge->infinity;
   102  }
   103  
   104  static void testutil_random_gej_test(secp256k1_gej *gej) {
   105      secp256k1_ge ge;
   106      testutil_random_ge_test(&ge);
   107      testutil_random_ge_jacobian_test(gej, &ge);
   108  }
   109  
   110  static void testutil_random_pubkey_test(secp256k1_pubkey *pk) {
   111      secp256k1_ge ge;
   112      testutil_random_ge_test(&ge);
   113      secp256k1_pubkey_save(pk, &ge);
   114  }
   115  
   116  static void testutil_random_scalar_order_test(secp256k1_scalar *num) {
   117      do {
   118          unsigned char b32[32];
   119          int overflow = 0;
   120          testrand256_test(b32);
   121          secp256k1_scalar_set_b32(num, b32, &overflow);
   122          if (overflow || secp256k1_scalar_is_zero(num)) {
   123              continue;
   124          }
   125          break;
   126      } while(1);
   127  }
   128  
   129  static void testutil_random_scalar_order(secp256k1_scalar *num) {
   130      do {
   131          unsigned char b32[32];
   132          int overflow = 0;
   133          testrand256(b32);
   134          secp256k1_scalar_set_b32(num, b32, &overflow);
   135          if (overflow || secp256k1_scalar_is_zero(num)) {
   136              continue;
   137          }
   138          break;
   139      } while(1);
   140  }
   141  
   142  static void testutil_random_scalar_order_b32(unsigned char *b32) {
   143      secp256k1_scalar num;
   144      testutil_random_scalar_order(&num);
   145      secp256k1_scalar_get_b32(b32, &num);
   146  }
   147  
   148  #endif /* SECP256K1_TESTUTIL_H */