text: /**********************************************************************
   * Copyright (c) 2017 Eugene Fillippovsky                              *
   * Distributed under the MIT software license, see the accompanying   *
   * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
   **********************************************************************/
  
  #include "include/secp256k1.h"
  
  #include "util.h"
  #include "num_impl.h"
  #include "field_impl.h"
  #include "scalar_impl.h"
  #include "group_impl.h"
  #include "ecmult_impl.h"
  #include "ecmult_const_impl.h"
  #include "ecmult_gen_impl.h"
  #include "ecdsa_impl.h"
  #include "eckey_impl.h"
  #include "hash_impl.h"
  
  #define ARG_CHECK(cond) do { \
      if (EXPECT(!(cond), 0)) { \
          secp256k1_callback_call(&ctx->illegal_callback, #cond); \
          return 0; \
      } \
  } while(0)
  
  static void default_illegal_callback_fn(const char* str, void* data) {
      (void)data;
      fprintf(stderr, "[libsecp256k1] illegal argument: %s\n", str);
      abort();
  }
  
  static const secp256k1_callback default_illegal_callback = {
      default_illegal_callback_fn,
      NULL
  };
  
  static void default_error_callback_fn(const char* str, void* data) {
      (void)data;
      fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
      abort();
  }
  
  static const secp256k1_callback default_error_callback = {
      default_error_callback_fn,
      NULL
  };
  
  
  struct secp256k1_context_struct {
      secp256k1_ecmult_context ecmult_ctx;
      secp256k1_ecmult_gen_context ecmult_gen_ctx;
      secp256k1_callback illegal_callback;
      secp256k1_callback error_callback;
  };
  
  secp256k1_context* secp256k1_context_create(unsigned int flags) {
      secp256k1_context* ret = (secp256k1_context*)checked_malloc(&default_error_callback, sizeof(secp256k1_context));
      ret->illegal_callback = default_illegal_callback;
      ret->error_callback = default_error_callback;
  
      if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE_CONTEXT, 0)) {
              secp256k1_callback_call(&ret->illegal_callback,
                                      "Invalid flags");
              free(ret);
              return NULL;
      }
  
      secp256k1_ecmult_context_init(&ret->ecmult_ctx);
      secp256k1_ecmult_gen_context_init(&ret->ecmult_gen_ctx);
  
      if (flags & SECP256K1_FLAGS_BIT_CONTEXT_SIGN) {
          secp256k1_ecmult_gen_context_build(&ret->ecmult_gen_ctx, &ret->error_callback);
      }
      if (flags & SECP256K1_FLAGS_BIT_CONTEXT_VERIFY) {
          secp256k1_ecmult_context_build(&ret->ecmult_ctx, &ret->error_callback);
      }
  
      return ret;
  }
  
  secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
      secp256k1_context* ret = (secp256k1_context*)checked_malloc(&ctx->error_callback, sizeof(secp256k1_context));
      ret->illegal_callback = ctx->illegal_callback;
      ret->error_callback = ctx->error_callback;
      secp256k1_ecmult_context_clone(&ret->ecmult_ctx, &ctx->ecmult_ctx, &ctx->error_callback);
      secp256k1_ecmult_gen_context_clone(&ret->ecmult_gen_ctx, &ctx->ecmult_gen_ctx, &ctx->error_callback);
      return ret;
  }
  
  void secp256k1_context_destroy(secp256k1_context* ctx) {
      if (ctx != NULL) {
          secp256k1_ecmult_context_clear(&ctx->ecmult_ctx);
          secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
  
          free(ctx);
      }
  }
  
  void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
      if (fun == NULL) {
          fun = default_illegal_callback_fn;
      }
      ctx->illegal_callback.fn = fun;
      ctx->illegal_callback.data = data;
  }
  
  void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
      if (fun == NULL) {
          fun = default_error_callback_fn;
      }
      ctx->error_callback.fn = fun;
      ctx->error_callback.data = data;
  }
  
  static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {
      if (sizeof(secp256k1_ge_storage) == 64) {
          /* When the secp256k1_ge_storage type is exactly 64 byte, use its
           * representation inside secp256k1_pubkey, as conversion is very fast.
           * Note that secp256k1_pubkey_save must use the same representation. */
          secp256k1_ge_storage s;
          memcpy(&s, &pubkey->data[0], 64);
          secp256k1_ge_from_storage(ge, &s);
      } else {
          /* Otherwise, fall back to 32-byte big endian for X and Y. */
          secp256k1_fe x, y;
          secp256k1_fe_set_b32(&x, pubkey->data);
          secp256k1_fe_set_b32(&y, pubkey->data + 32);
          secp256k1_ge_set_xy(ge, &x, &y);
      }
      ARG_CHECK(!secp256k1_fe_is_zero(&ge->x));
      return 1;
  }
  
  static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
      if (sizeof(secp256k1_ge_storage) == 64) {
          secp256k1_ge_storage s;
          secp256k1_ge_to_storage(&s, ge);
          memcpy(&pubkey->data[0], &s, 64);
      } else {
          VERIFY_CHECK(!secp256k1_ge_is_infinity(ge));
          secp256k1_fe_normalize_var(&ge->x);
          secp256k1_fe_normalize_var(&ge->y);
          secp256k1_fe_get_b32(pubkey->data, &ge->x);
          secp256k1_fe_get_b32(pubkey->data + 32, &ge->y);
      }
  }
  
  int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen) {
      secp256k1_ge Q;
  
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(pubkey != NULL);
      memset(pubkey, 0, sizeof(*pubkey));
      ARG_CHECK(input != NULL);
      if (!secp256k1_eckey_pubkey_parse(&Q, input, inputlen)) {
          return 0;
      }
      secp256k1_pubkey_save(pubkey, &Q);
      secp256k1_ge_clear(&Q);
      return 1;
  }
  
  int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
      secp256k1_ge Q;
      size_t len;
      int ret = 0;
  
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(outputlen != NULL);
      ARG_CHECK(*outputlen >= ((flags & SECP256K1_FLAGS_BIT_COMPRESSION) ? 33 : 65));
      len = *outputlen;
      *outputlen = 0;
      ARG_CHECK(output != NULL);
      memset(output, 0, len);
      ARG_CHECK(pubkey != NULL);
      ARG_CHECK((flags & SECP256K1_FLAGS_TYPE_MASK) == SECP256K1_FLAGS_TYPE_COMPRESSION);
      if (secp256k1_pubkey_load(ctx, &Q, pubkey)) {
          ret = secp256k1_eckey_pubkey_serialize(&Q, output, &len, flags & SECP256K1_FLAGS_BIT_COMPRESSION);
          if (ret) {
              *outputlen = len;
          }
      }
      return ret;
  }
  
  static void secp256k1_ecdsa_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_ecdsa_signature* sig) {
      (void)ctx;
      if (sizeof(secp256k1_scalar) == 32) {
          /* When the secp256k1_scalar type is exactly 32 byte, use its
           * representation inside secp256k1_ecdsa_signature, as conversion is very fast.
           * Note that secp256k1_ecdsa_signature_save must use the same representation. */
          memcpy(r, &sig->data[0], 32);
          memcpy(s, &sig->data[32], 32);
      } else {
          secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
          secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
      }
  }
  
  static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s) {
      if (sizeof(secp256k1_scalar) == 32) {
          memcpy(&sig->data[0], r, 32);
          memcpy(&sig->data[32], s, 32);
      } else {
          secp256k1_scalar_get_b32(&sig->data[0], r);
          secp256k1_scalar_get_b32(&sig->data[32], s);
      }
  }
  
  int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
      secp256k1_scalar r, s;
  
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(sig != NULL);
      ARG_CHECK(input != NULL);
  
      if (secp256k1_ecdsa_sig_parse(&r, &s, input, inputlen)) {
          secp256k1_ecdsa_signature_save(sig, &r, &s);
          return 1;
      } else {
          memset(sig, 0, sizeof(*sig));
          return 0;
      }
  }
  
  int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64) {
      secp256k1_scalar r, s;
      int ret = 1;
      int overflow = 0;
  
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(sig != NULL);
      ARG_CHECK(input64 != NULL);
  
      secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
      ret &= !overflow;
      secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
      ret &= !overflow;
      if (ret) {
          secp256k1_ecdsa_signature_save(sig, &r, &s);
      } else {
          memset(sig, 0, sizeof(*sig));
      }
      return ret;
  }
  
  int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature* sig) {
      secp256k1_scalar r, s;
  
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(output != NULL);
      ARG_CHECK(outputlen != NULL);
      ARG_CHECK(sig != NULL);
  
      secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
      return secp256k1_ecdsa_sig_serialize(output, outputlen, &r, &s);
  }
  
  int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig) {
      secp256k1_scalar r, s;
  
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(output64 != NULL);
      ARG_CHECK(sig != NULL);
  
      secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
      secp256k1_scalar_get_b32(&output64[0], &r);
      secp256k1_scalar_get_b32(&output64[32], &s);
      return 1;
  }
  
  int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin) {
      secp256k1_scalar r, s;
      int ret = 0;
  
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(sigin != NULL);
  
      secp256k1_ecdsa_signature_load(ctx, &r, &s, sigin);
      ret = secp256k1_scalar_is_high(&s);
      if (sigout != NULL) {
          if (ret) {
              secp256k1_scalar_negate(&s, &s);
          }
          secp256k1_ecdsa_signature_save(sigout, &r, &s);
      }
  
      return ret;
  }
  
  int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const secp256k1_pubkey *pubkey) {
      secp256k1_ge q;
      secp256k1_scalar r, s;
      secp256k1_scalar m;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
      ARG_CHECK(msg32 != NULL);
      ARG_CHECK(sig != NULL);
      ARG_CHECK(pubkey != NULL);
  
      secp256k1_scalar_set_b32(&m, msg32, NULL);
      secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
      return (!secp256k1_scalar_is_high(&s) &&
              secp256k1_pubkey_load(ctx, &q, pubkey) &&
              secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &r, &s, &q, &m));
  }
  
  static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
     unsigned char keydata[112];
     int keylen = 64;
     secp256k1_rfc6979_hmac_sha256_t rng;
     unsigned int i;
     /* We feed a byte array to the PRNG as input, consisting of:
      * - the private key (32 bytes) and message (32 bytes), see RFC 6979 3.2d.
      * - optionally 32 extra bytes of data, see RFC 6979 3.6 Additional Data.
      * - optionally 16 extra bytes with the algorithm name.
      * Because the arguments have distinct fixed lengths it is not possible for
      *  different argument mixtures to emulate each other and result in the same
      *  nonces.
      */
     memcpy(keydata, key32, 32);
     memcpy(keydata + 32, msg32, 32);
     if (data != NULL) {
         memcpy(keydata + 64, data, 32);
         keylen = 96;
     }
     if (algo16 != NULL) {
         memcpy(keydata + keylen, algo16, 16);
         keylen += 16;
     }
     secp256k1_rfc6979_hmac_sha256_initialize(&rng, keydata, keylen);
     memset(keydata, 0, sizeof(keydata));
     for (i = 0; i <= counter; i++) {
         secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
     }
     secp256k1_rfc6979_hmac_sha256_finalize(&rng);
     return 1;
  }
  
  const secp256k1_nonce_function secp256k1_nonce_function_rfc6979 = nonce_function_rfc6979;
  const secp256k1_nonce_function secp256k1_nonce_function_default = nonce_function_rfc6979;
  
  int secp256k1_ecdsa_sign(const secp256k1_context* ctx, secp256k1_ecdsa_signature *signature, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
      secp256k1_scalar r, s;
      secp256k1_scalar sec, non, msg;
      int ret = 0;
      int overflow = 0;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
      ARG_CHECK(msg32 != NULL);
      ARG_CHECK(signature != NULL);
      ARG_CHECK(seckey != NULL);
      if (noncefp == NULL) {
          noncefp = secp256k1_nonce_function_default;
      }
  
      secp256k1_scalar_set_b32(&sec, seckey, &overflow);
      /* Fail if the secret key is invalid. */
      if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
          unsigned char nonce32[32];
          unsigned int count = 0;
          secp256k1_scalar_set_b32(&msg, msg32, NULL);
          while (1) {
              ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
              if (!ret) {
                  break;
              }
              secp256k1_scalar_set_b32(&non, nonce32, &overflow);
              if (!overflow && !secp256k1_scalar_is_zero(&non)) {
                  if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, NULL)) {
                      break;
                  }
              }
              count++;
          }
          memset(nonce32, 0, 32);
          secp256k1_scalar_clear(&msg);
          secp256k1_scalar_clear(&non);
          secp256k1_scalar_clear(&sec);
      }
      if (ret) {
          secp256k1_ecdsa_signature_save(signature, &r, &s);
      } else {
          memset(signature, 0, sizeof(*signature));
      }
      return ret;
  }
  
  int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {
      secp256k1_scalar sec;
      int ret;
      int overflow;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(seckey != NULL);
  
      secp256k1_scalar_set_b32(&sec, seckey, &overflow);
      ret = !overflow && !secp256k1_scalar_is_zero(&sec);
      secp256k1_scalar_clear(&sec);
      return ret;
  }
  
  int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) {
      secp256k1_gej pj;
      secp256k1_ge p;
      secp256k1_scalar sec;
      int overflow;
      int ret = 0;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(pubkey != NULL);
      memset(pubkey, 0, sizeof(*pubkey));
      ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
      ARG_CHECK(seckey != NULL);
  
      secp256k1_scalar_set_b32(&sec, seckey, &overflow);
      ret = (!overflow) & (!secp256k1_scalar_is_zero(&sec));
      if (ret) {
          secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pj, &sec);
          secp256k1_ge_set_gej(&p, &pj);
          secp256k1_pubkey_save(pubkey, &p);
      }
      secp256k1_scalar_clear(&sec);
      return ret;
  }
  
  int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
      secp256k1_scalar term;
      secp256k1_scalar sec;
      int ret = 0;
      int overflow = 0;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(seckey != NULL);
      ARG_CHECK(tweak != NULL);
  
      secp256k1_scalar_set_b32(&term, tweak, &overflow);
      secp256k1_scalar_set_b32(&sec, seckey, NULL);
  
      ret = !overflow && secp256k1_eckey_privkey_tweak_add(&sec, &term);
      memset(seckey, 0, 32);
      if (ret) {
          secp256k1_scalar_get_b32(seckey, &sec);
      }
  
      secp256k1_scalar_clear(&sec);
      secp256k1_scalar_clear(&term);
      return ret;
  }
  
  int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
      secp256k1_ge p;
      secp256k1_scalar term;
      int ret = 0;
      int overflow = 0;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
      ARG_CHECK(pubkey != NULL);
      ARG_CHECK(tweak != NULL);
  
      secp256k1_scalar_set_b32(&term, tweak, &overflow);
      ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
      memset(pubkey, 0, sizeof(*pubkey));
      if (ret) {
          if (secp256k1_eckey_pubkey_tweak_add(&ctx->ecmult_ctx, &p, &term)) {
              secp256k1_pubkey_save(pubkey, &p);
          } else {
              ret = 0;
          }
      }
  
      return ret;
  }
  
  int secp256k1_ec_privkey_tweak_mul(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
      secp256k1_scalar factor;
      secp256k1_scalar sec;
      int ret = 0;
      int overflow = 0;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(seckey != NULL);
      ARG_CHECK(tweak != NULL);
  
      secp256k1_scalar_set_b32(&factor, tweak, &overflow);
      secp256k1_scalar_set_b32(&sec, seckey, NULL);
      ret = !overflow && secp256k1_eckey_privkey_tweak_mul(&sec, &factor);
      memset(seckey, 0, 32);
      if (ret) {
          secp256k1_scalar_get_b32(seckey, &sec);
      }
  
      secp256k1_scalar_clear(&sec);
      secp256k1_scalar_clear(&factor);
      return ret;
  }
  
  int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
      secp256k1_ge p;
      secp256k1_scalar factor;
      int ret = 0;
      int overflow = 0;
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
      ARG_CHECK(pubkey != NULL);
      ARG_CHECK(tweak != NULL);
  
      secp256k1_scalar_set_b32(&factor, tweak, &overflow);
      ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
      memset(pubkey, 0, sizeof(*pubkey));
      if (ret) {
          if (secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor)) {
              secp256k1_pubkey_save(pubkey, &p);
          } else {
              ret = 0;
          }
      }
  
      return ret;
  }
  
  int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned char *seed32) {
      VERIFY_CHECK(ctx != NULL);
      ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
      secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
      return 1;
  }
  
  int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_pubkey *pubnonce, const secp256k1_pubkey * const *pubnonces, size_t n) {
      size_t i;
      secp256k1_gej Qj;
      secp256k1_ge Q;
  
      ARG_CHECK(pubnonce != NULL);
      memset(pubnonce, 0, sizeof(*pubnonce));
      ARG_CHECK(n >= 1);
      ARG_CHECK(pubnonces != NULL);
  
      secp256k1_gej_set_infinity(&Qj);
  
      for (i = 0; i < n; i++) {
          secp256k1_pubkey_load(ctx, &Q, pubnonces[i]);
          secp256k1_gej_add_ge(&Qj, &Qj, &Q);
      }
      if (secp256k1_gej_is_infinity(&Qj)) {
          return 0;
      }
      secp256k1_ge_set_gej(&Q, &Qj);
      secp256k1_pubkey_save(pubnonce, &Q);
      return 1;
  }
  
  #ifdef ENABLE_MODULE_ECDH
  # include "modules/ecdh/main_impl.h"
  #endif
  
  #ifdef ENABLE_MODULE_SCHNORR
  # include "modules/schnorr/main_impl.h"
  #endif
  
  #ifdef ENABLE_MODULE_RECOVERY
  # include "modules/recovery/main_impl.h"
  #endif
  