src/secp256k1.c

   1 /**********************************************************************
   2  * Copyright (c) 2013-2015 Pieter Wuille                              *
   3  * Distributed under the MIT software license, see the accompanying   *
   4  * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
   5  **********************************************************************/
   6
   7 #include "include/secp256k1.h"
   8 #include "include/secp256k1_preallocated.h"
   9
  10 #include "util.h"
  11 #include "num_impl.h"
  12 #include "field_impl.h"
  13 #include "scalar_impl.h"
  14 #include "group_impl.h"
  15 #include "ecmult_impl.h"
  16 #include "ecmult_const_impl.h"
  17 #include "ecmult_gen_impl.h"
  18 #include "ecdsa_impl.h"
  19 #include "eckey_impl.h"
  20 #include "hash_impl.h"
  21 #include "scratch_impl.h"
  22
  23 #define ARG_CHECK(cond) do { \
  24     if (EXPECT(!(cond), 0)) { \
  25         secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  26         return 0; \
  27     } \
  28 } while(0)
  29
  30 #define ARG_CHECK_NO_RETURN(cond) do { \
  31     if (EXPECT(!(cond), 0)) { \
  32         secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  33     } \
  34 } while(0)
  35
  36 static void default_illegal_callback_fn(const char* str, void* data) {
  37     (void)data;
  38     fprintf(stderr, "[libsecp256k1] illegal argument: %s\n", str);
  39     abort();
  40 }
  41
  42 static const secp256k1_callback default_illegal_callback = {
  43     default_illegal_callback_fn,
  44     NULL
  45 };
  46
  47 static void default_error_callback_fn(const char* str, void* data) {
  48     (void)data;
  49     fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
  50     abort();
  51 }
  52
  53 static const secp256k1_callback default_error_callback = {
  54     default_error_callback_fn,
  55     NULL
  56 };
  57
  58
  59 struct secp256k1_context_struct {
  60     secp256k1_ecmult_context ecmult_ctx;
  61     secp256k1_ecmult_gen_context ecmult_gen_ctx;
  62     secp256k1_callback illegal_callback;
  63     secp256k1_callback error_callback;
  64 };
  65
  66 static const secp256k1_context secp256k1_context_no_precomp_ = {
  67     { 0 },
  68     { 0 },
  69     { default_illegal_callback_fn, 0 },
  70     { default_error_callback_fn, 0 }
  71 };
  72 const secp256k1_context *secp256k1_context_no_precomp = &secp256k1_context_no_precomp_;
  73
  74 size_t secp256k1_context_preallocated_size(unsigned int flags) {
  75     size_t ret = ROUND_TO_ALIGN(sizeof(secp256k1_context));
  76
  77     if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE_CONTEXT, 0)) {
  78             secp256k1_callback_call(&default_illegal_callback,
  79                                     "Invalid flags");
  80             return 0;
  81     }
  82
  83     if (flags & SECP256K1_FLAGS_BIT_CONTEXT_SIGN) {
  84         ret += SECP256K1_ECMULT_GEN_CONTEXT_PREALLOCATED_SIZE;
  85     }
  86     if (flags & SECP256K1_FLAGS_BIT_CONTEXT_VERIFY) {
  87         ret += SECP256K1_ECMULT_CONTEXT_PREALLOCATED_SIZE;
  88     }
  89     return ret;
  90 }
  91
  92 size_t secp256k1_context_preallocated_clone_size(const secp256k1_context* ctx) {
  93     size_t ret = ROUND_TO_ALIGN(sizeof(secp256k1_context));
  94     VERIFY_CHECK(ctx != NULL);
  95     if (secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx)) {
  96         ret += SECP256K1_ECMULT_GEN_CONTEXT_PREALLOCATED_SIZE;
  97     }
  98     if (secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx)) {
  99         ret += SECP256K1_ECMULT_CONTEXT_PREALLOCATED_SIZE;
 100     }
 101     return ret;
 102 }
 103
 104 secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigned int flags) {
 105     void* const base = prealloc;
 106     size_t prealloc_size;
 107     secp256k1_context* ret;
 108
 109     VERIFY_CHECK(prealloc != NULL);
 110     prealloc_size = secp256k1_context_preallocated_size(flags);
 111     ret = (secp256k1_context*)manual_alloc(&prealloc, sizeof(secp256k1_context), base, prealloc_size);
 112     ret->illegal_callback = default_illegal_callback;
 113     ret->error_callback = default_error_callback;
 114
 115     if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE_CONTEXT, 0)) {
 116             secp256k1_callback_call(&ret->illegal_callback,
 117                                     "Invalid flags");
 118             return NULL;
 119     }
 120
 121     secp256k1_ecmult_context_init(&ret->ecmult_ctx);
 122     secp256k1_ecmult_gen_context_init(&ret->ecmult_gen_ctx);
 123
 124     if (flags & SECP256K1_FLAGS_BIT_CONTEXT_SIGN) {
 125         secp256k1_ecmult_gen_context_build(&ret->ecmult_gen_ctx, &prealloc);
 126     }
 127     if (flags & SECP256K1_FLAGS_BIT_CONTEXT_VERIFY) {
 128         secp256k1_ecmult_context_build(&ret->ecmult_ctx, &prealloc);
 129     }
 130
 131     return (secp256k1_context*) ret;
 132 }
 133
 134 secp256k1_context* secp256k1_context_create(unsigned int flags) {
 135     size_t const prealloc_size = secp256k1_context_preallocated_size(flags);
 136     secp256k1_context* ctx = (secp256k1_context*)checked_malloc(&default_error_callback, prealloc_size);
 137     if (EXPECT(secp256k1_context_preallocated_create(ctx, flags) == NULL, 0)) {
 138         free(ctx);
 139         return NULL;
 140     }
 141
 142     return ctx;
 143 }
 144
 145 secp256k1_context* secp256k1_context_preallocated_clone(const secp256k1_context* ctx, void* prealloc) {
 146     size_t prealloc_size;
 147     secp256k1_context* ret;
 148     VERIFY_CHECK(ctx != NULL);
 149     ARG_CHECK(prealloc != NULL);
 150
 151     prealloc_size = secp256k1_context_preallocated_clone_size(ctx);
 152     ret = (secp256k1_context*)prealloc;
 153     memcpy(ret, ctx, prealloc_size);
 154     secp256k1_ecmult_gen_context_finalize_memcpy(&ret->ecmult_gen_ctx, &ctx->ecmult_gen_ctx);
 155     secp256k1_ecmult_context_finalize_memcpy(&ret->ecmult_ctx, &ctx->ecmult_ctx);
 156     return ret;
 157 }
 158
 159 secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
 160     secp256k1_context* ret;
 161     size_t prealloc_size;
 162
 163     VERIFY_CHECK(ctx != NULL);
 164     prealloc_size = secp256k1_context_preallocated_clone_size(ctx);
 165     ret = (secp256k1_context*)checked_malloc(&ctx->error_callback, prealloc_size);
 166     ret = secp256k1_context_preallocated_clone(ctx, ret);
 167     return ret;
 168 }
 169
 170 void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
 171     ARG_CHECK_NO_RETURN(ctx != secp256k1_context_no_precomp);
 172     if (ctx != NULL) {
 173         secp256k1_ecmult_context_clear(&ctx->ecmult_ctx);
 174         secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
 175     }
 176 }
 177
 178 void secp256k1_context_destroy(secp256k1_context* ctx) {
 179     if (ctx != NULL) {
 180         secp256k1_context_preallocated_destroy(ctx);
 181         free(ctx);
 182     }
 183 }
 184
 185 void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
 186     ARG_CHECK_NO_RETURN(ctx != secp256k1_context_no_precomp);
 187     if (fun == NULL) {
 188         fun = default_illegal_callback_fn;
 189     }
 190     ctx->illegal_callback.fn = fun;
 191     ctx->illegal_callback.data = data;
 192 }
 193
 194 void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
 195     ARG_CHECK_NO_RETURN(ctx != secp256k1_context_no_precomp);
 196     if (fun == NULL) {
 197         fun = default_error_callback_fn;
 198     }
 199     ctx->error_callback.fn = fun;
 200     ctx->error_callback.data = data;
 201 }
 202
 203 secp256k1_scratch_space* secp256k1_scratch_space_create(const secp256k1_context* ctx, size_t max_size) {
 204     VERIFY_CHECK(ctx != NULL);
 205     return secp256k1_scratch_create(&ctx->error_callback, max_size);
 206 }
 207
 208 void secp256k1_scratch_space_destroy(const secp256k1_context *ctx, secp256k1_scratch_space* scratch) {
 209     VERIFY_CHECK(ctx != NULL);
 210     secp256k1_scratch_destroy(&ctx->error_callback, scratch);
 211 }
 212
 213 static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {
 214     if (sizeof(secp256k1_ge_storage) == 64) {
 215         /* When the secp256k1_ge_storage type is exactly 64 byte, use its
 216          * representation inside secp256k1_pubkey, as conversion is very fast.
 217          * Note that secp256k1_pubkey_save must use the same representation. */
 218         secp256k1_ge_storage s;
 219         memcpy(&s, &pubkey->data[0], sizeof(s));
 220         secp256k1_ge_from_storage(ge, &s);
 221     } else {
 222         /* Otherwise, fall back to 32-byte big endian for X and Y. */
 223         secp256k1_fe x, y;
 224         secp256k1_fe_set_b32(&x, pubkey->data);
 225         secp256k1_fe_set_b32(&y, pubkey->data + 32);
 226         secp256k1_ge_set_xy(ge, &x, &y);
 227     }
 228     ARG_CHECK(!secp256k1_fe_is_zero(&ge->x));
 229     return 1;
 230 }
 231
 232 static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
 233     if (sizeof(secp256k1_ge_storage) == 64) {
 234         secp256k1_ge_storage s;
 235         secp256k1_ge_to_storage(&s, ge);
 236         memcpy(&pubkey->data[0], &s, sizeof(s));
 237     } else {
 238         VERIFY_CHECK(!secp256k1_ge_is_infinity(ge));
 239         secp256k1_fe_normalize_var(&ge->x);
 240         secp256k1_fe_normalize_var(&ge->y);
 241         secp256k1_fe_get_b32(pubkey->data, &ge->x);
 242         secp256k1_fe_get_b32(pubkey->data + 32, &ge->y);
 243     }
 244 }
 245
 246 int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen) {
 247     secp256k1_ge Q;
 248
 249     VERIFY_CHECK(ctx != NULL);
 250     ARG_CHECK(pubkey != NULL);
 251     memset(pubkey, 0, sizeof(*pubkey));
 252     ARG_CHECK(input != NULL);
 253     if (!secp256k1_eckey_pubkey_parse(&Q, input, inputlen)) {
 254         return 0;
 255     }
 256     secp256k1_pubkey_save(pubkey, &Q);
 257     secp256k1_ge_clear(&Q);
 258     return 1;
 259 }
 260
 261 int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
 262     secp256k1_ge Q;
 263     size_t len;
 264     int ret = 0;
 265
 266     VERIFY_CHECK(ctx != NULL);
 267     ARG_CHECK(outputlen != NULL);
 268     ARG_CHECK(*outputlen >= ((flags & SECP256K1_FLAGS_BIT_COMPRESSION) ? 33 : 65));
 269     len = *outputlen;
 270     *outputlen = 0;
 271     ARG_CHECK(output != NULL);
 272     memset(output, 0, len);
 273     ARG_CHECK(pubkey != NULL);
 274     ARG_CHECK((flags & SECP256K1_FLAGS_TYPE_MASK) == SECP256K1_FLAGS_TYPE_COMPRESSION);
 275     if (secp256k1_pubkey_load(ctx, &Q, pubkey)) {
 276         ret = secp256k1_eckey_pubkey_serialize(&Q, output, &len, flags & SECP256K1_FLAGS_BIT_COMPRESSION);
 277         if (ret) {
 278             *outputlen = len;
 279         }
 280     }
 281     return ret;
 282 }
 283
 284 static void secp256k1_ecdsa_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_ecdsa_signature* sig) {
 285     (void)ctx;
 286     if (sizeof(secp256k1_scalar) == 32) {
 287         /* When the secp256k1_scalar type is exactly 32 byte, use its
 288          * representation inside secp256k1_ecdsa_signature, as conversion is very fast.
 289          * Note that secp256k1_ecdsa_signature_save must use the same representation. */
 290         memcpy(r, &sig->data[0], 32);
 291         memcpy(s, &sig->data[32], 32);
 292     } else {
 293         secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
 294         secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
 295     }
 296 }
 297
 298 static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s) {
 299     if (sizeof(secp256k1_scalar) == 32) {
 300         memcpy(&sig->data[0], r, 32);
 301         memcpy(&sig->data[32], s, 32);
 302     } else {
 303         secp256k1_scalar_get_b32(&sig->data[0], r);
 304         secp256k1_scalar_get_b32(&sig->data[32], s);
 305     }
 306 }
 307
 308 int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
 309     secp256k1_scalar r, s;
 310
 311     VERIFY_CHECK(ctx != NULL);
 312     ARG_CHECK(sig != NULL);
 313     ARG_CHECK(input != NULL);
 314
 315     if (secp256k1_ecdsa_sig_parse(&r, &s, input, inputlen)) {
 316         secp256k1_ecdsa_signature_save(sig, &r, &s);
 317         return 1;
 318     } else {
 319         memset(sig, 0, sizeof(*sig));
 320         return 0;
 321     }
 322 }
 323
 324 int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64) {
 325     secp256k1_scalar r, s;
 326     int ret = 1;
 327     int overflow = 0;
 328
 329     VERIFY_CHECK(ctx != NULL);
 330     ARG_CHECK(sig != NULL);
 331     ARG_CHECK(input64 != NULL);
 332
 333     secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
 334     ret &= !overflow;
 335     secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
 336     ret &= !overflow;
 337     if (ret) {
 338         secp256k1_ecdsa_signature_save(sig, &r, &s);
 339     } else {
 340         memset(sig, 0, sizeof(*sig));
 341     }
 342     return ret;
 343 }
 344
 345 int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature* sig) {
 346     secp256k1_scalar r, s;
 347
 348     VERIFY_CHECK(ctx != NULL);
 349     ARG_CHECK(output != NULL);
 350     ARG_CHECK(outputlen != NULL);
 351     ARG_CHECK(sig != NULL);
 352
 353     secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
 354     return secp256k1_ecdsa_sig_serialize(output, outputlen, &r, &s);
 355 }
 356
 357 int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig) {
 358     secp256k1_scalar r, s;
 359
 360     VERIFY_CHECK(ctx != NULL);
 361     ARG_CHECK(output64 != NULL);
 362     ARG_CHECK(sig != NULL);
 363
 364     secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
 365     secp256k1_scalar_get_b32(&output64[0], &r);
 366     secp256k1_scalar_get_b32(&output64[32], &s);
 367     return 1;
 368 }
 369
 370 int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin) {
 371     secp256k1_scalar r, s;
 372     int ret = 0;
 373
 374     VERIFY_CHECK(ctx != NULL);
 375     ARG_CHECK(sigin != NULL);
 376
 377     secp256k1_ecdsa_signature_load(ctx, &r, &s, sigin);
 378     ret = secp256k1_scalar_is_high(&s);
 379     if (sigout != NULL) {
 380         if (ret) {
 381             secp256k1_scalar_negate(&s, &s);
 382         }
 383         secp256k1_ecdsa_signature_save(sigout, &r, &s);
 384     }
 385
 386     return ret;
 387 }
 388
 389 int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const secp256k1_pubkey *pubkey) {
 390     secp256k1_ge q;
 391     secp256k1_scalar r, s;
 392     secp256k1_scalar m;
 393     VERIFY_CHECK(ctx != NULL);
 394     ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
 395     ARG_CHECK(msg32 != NULL);
 396     ARG_CHECK(sig != NULL);
 397     ARG_CHECK(pubkey != NULL);
 398
 399     secp256k1_scalar_set_b32(&m, msg32, NULL);
 400     secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
 401     return (!secp256k1_scalar_is_high(&s) &&
 402             secp256k1_pubkey_load(ctx, &q, pubkey) &&
 403             secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &r, &s, &q, &m));
 404 }
 405
 406 static SECP256K1_INLINE void buffer_append(unsigned char *buf, unsigned int *offset, const void *data, unsigned int len) {
 407     memcpy(buf + *offset, data, len);
 408     *offset += len;
 409 }
 410
 411 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) {
 412    unsigned char keydata[112];
 413    unsigned int offset = 0;
 414    secp256k1_rfc6979_hmac_sha256 rng;
 415    unsigned int i;
 416    /* We feed a byte array to the PRNG as input, consisting of:
 417     * - the private key (32 bytes) and message (32 bytes), see RFC 6979 3.2d.
 418     * - optionally 32 extra bytes of data, see RFC 6979 3.6 Additional Data.
 419     * - optionally 16 extra bytes with the algorithm name.
 420     * Because the arguments have distinct fixed lengths it is not possible for
 421     *  different argument mixtures to emulate each other and result in the same
 422     *  nonces.
 423     */
 424    buffer_append(keydata, &offset, key32, 32);
 425    buffer_append(keydata, &offset, msg32, 32);
 426    if (data != NULL) {
 427        buffer_append(keydata, &offset, data, 32);
 428    }
 429    if (algo16 != NULL) {
 430        buffer_append(keydata, &offset, algo16, 16);
 431    }
 432    secp256k1_rfc6979_hmac_sha256_initialize(&rng, keydata, offset);
 433    memset(keydata, 0, sizeof(keydata));
 434    for (i = 0; i <= counter; i++) {
 435        secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
 436    }
 437    secp256k1_rfc6979_hmac_sha256_finalize(&rng);
 438    return 1;
 439 }
 440
 441 const secp256k1_nonce_function secp256k1_nonce_function_rfc6979 = nonce_function_rfc6979;
 442 const secp256k1_nonce_function secp256k1_nonce_function_default = nonce_function_rfc6979;
 443
 444 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) {
 445     secp256k1_scalar r, s;
 446     secp256k1_scalar sec, non, msg;
 447     int ret = 0;
 448     int overflow = 0;
 449     VERIFY_CHECK(ctx != NULL);
 450     ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
 451     ARG_CHECK(msg32 != NULL);
 452     ARG_CHECK(signature != NULL);
 453     ARG_CHECK(seckey != NULL);
 454     if (noncefp == NULL) {
 455         noncefp = secp256k1_nonce_function_default;
 456     }
 457
 458     secp256k1_scalar_set_b32(&sec, seckey, &overflow);
 459     /* Fail if the secret key is invalid. */
 460     if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
 461         unsigned char nonce32[32];
 462         unsigned int count = 0;
 463         secp256k1_scalar_set_b32(&msg, msg32, NULL);
 464         while (1) {
 465             ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
 466             if (!ret) {
 467                 break;
 468             }
 469             secp256k1_scalar_set_b32(&non, nonce32, &overflow);
 470             if (!overflow && !secp256k1_scalar_is_zero(&non)) {
 471                 if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, NULL)) {
 472                     break;
 473                 }
 474             }
 475             count++;
 476         }
 477         memset(nonce32, 0, 32);
 478         secp256k1_scalar_clear(&msg);
 479         secp256k1_scalar_clear(&non);
 480         secp256k1_scalar_clear(&sec);
 481     }
 482     if (ret) {
 483         secp256k1_ecdsa_signature_save(signature, &r, &s);
 484     } else {
 485         memset(signature, 0, sizeof(*signature));
 486     }
 487     return ret;
 488 }
 489
 490 int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {
 491     secp256k1_scalar sec;
 492     int ret;
 493     int overflow;
 494     VERIFY_CHECK(ctx != NULL);
 495     ARG_CHECK(seckey != NULL);
 496
 497     secp256k1_scalar_set_b32(&sec, seckey, &overflow);
 498     ret = !overflow && !secp256k1_scalar_is_zero(&sec);
 499     secp256k1_scalar_clear(&sec);
 500     return ret;
 501 }
 502
 503 int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) {
 504     secp256k1_gej pj;
 505     secp256k1_ge p;
 506     secp256k1_scalar sec;
 507     int overflow;
 508     int ret = 0;
 509     VERIFY_CHECK(ctx != NULL);
 510     ARG_CHECK(pubkey != NULL);
 511     memset(pubkey, 0, sizeof(*pubkey));
 512     ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
 513     ARG_CHECK(seckey != NULL);
 514
 515     secp256k1_scalar_set_b32(&sec, seckey, &overflow);
 516     ret = (!overflow) & (!secp256k1_scalar_is_zero(&sec));
 517     if (ret) {
 518         secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pj, &sec);
 519         secp256k1_ge_set_gej(&p, &pj);
 520         secp256k1_pubkey_save(pubkey, &p);
 521     }
 522     secp256k1_scalar_clear(&sec);
 523     return ret;
 524 }
 525
 526 int secp256k1_ec_privkey_negate(const secp256k1_context* ctx, unsigned char *seckey) {
 527     secp256k1_scalar sec;
 528     VERIFY_CHECK(ctx != NULL);
 529     ARG_CHECK(seckey != NULL);
 530
 531     secp256k1_scalar_set_b32(&sec, seckey, NULL);
 532     secp256k1_scalar_negate(&sec, &sec);
 533     secp256k1_scalar_get_b32(seckey, &sec);
 534
 535     secp256k1_scalar_clear(&sec);
 536     return 1;
 537 }
 538
 539 int secp256k1_ec_pubkey_negate(const secp256k1_context* ctx, secp256k1_pubkey *pubkey) {
 540     int ret = 0;
 541     secp256k1_ge p;
 542     VERIFY_CHECK(ctx != NULL);
 543     ARG_CHECK(pubkey != NULL);
 544
 545     ret = secp256k1_pubkey_load(ctx, &p, pubkey);
 546     memset(pubkey, 0, sizeof(*pubkey));
 547     if (ret) {
 548         secp256k1_ge_neg(&p, &p);
 549         secp256k1_pubkey_save(pubkey, &p);
 550     }
 551     return ret;
 552 }
 553
 554 int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
 555     secp256k1_scalar term;
 556     secp256k1_scalar sec;
 557     int ret = 0;
 558     int overflow = 0;
 559     VERIFY_CHECK(ctx != NULL);
 560     ARG_CHECK(seckey != NULL);
 561     ARG_CHECK(tweak != NULL);
 562
 563     secp256k1_scalar_set_b32(&term, tweak, &overflow);
 564     secp256k1_scalar_set_b32(&sec, seckey, NULL);
 565
 566     ret = !overflow && secp256k1_eckey_privkey_tweak_add(&sec, &term);
 567     memset(seckey, 0, 32);
 568     if (ret) {
 569         secp256k1_scalar_get_b32(seckey, &sec);
 570     }
 571
 572     secp256k1_scalar_clear(&sec);
 573     secp256k1_scalar_clear(&term);
 574     return ret;
 575 }
 576
 577 int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
 578     secp256k1_ge p;
 579     secp256k1_scalar term;
 580     int ret = 0;
 581     int overflow = 0;
 582     VERIFY_CHECK(ctx != NULL);
 583     ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
 584     ARG_CHECK(pubkey != NULL);
 585     ARG_CHECK(tweak != NULL);
 586
 587     secp256k1_scalar_set_b32(&term, tweak, &overflow);
 588     ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
 589     memset(pubkey, 0, sizeof(*pubkey));
 590     if (ret) {
 591         if (secp256k1_eckey_pubkey_tweak_add(&ctx->ecmult_ctx, &p, &term)) {
 592             secp256k1_pubkey_save(pubkey, &p);
 593         } else {
 594             ret = 0;
 595         }
 596     }
 597
 598     return ret;
 599 }
 600
 601 int secp256k1_ec_privkey_tweak_mul(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
 602     secp256k1_scalar factor;
 603     secp256k1_scalar sec;
 604     int ret = 0;
 605     int overflow = 0;
 606     VERIFY_CHECK(ctx != NULL);
 607     ARG_CHECK(seckey != NULL);
 608     ARG_CHECK(tweak != NULL);
 609
 610     secp256k1_scalar_set_b32(&factor, tweak, &overflow);
 611     secp256k1_scalar_set_b32(&sec, seckey, NULL);
 612     ret = !overflow && secp256k1_eckey_privkey_tweak_mul(&sec, &factor);
 613     memset(seckey, 0, 32);
 614     if (ret) {
 615         secp256k1_scalar_get_b32(seckey, &sec);
 616     }
 617
 618     secp256k1_scalar_clear(&sec);
 619     secp256k1_scalar_clear(&factor);
 620     return ret;
 621 }
 622
 623 int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
 624     secp256k1_ge p;
 625     secp256k1_scalar factor;
 626     int ret = 0;
 627     int overflow = 0;
 628     VERIFY_CHECK(ctx != NULL);
 629     ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
 630     ARG_CHECK(pubkey != NULL);
 631     ARG_CHECK(tweak != NULL);
 632
 633     secp256k1_scalar_set_b32(&factor, tweak, &overflow);
 634     ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
 635     memset(pubkey, 0, sizeof(*pubkey));
 636     if (ret) {
 637         if (secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor)) {
 638             secp256k1_pubkey_save(pubkey, &p);
 639         } else {
 640             ret = 0;
 641         }
 642     }
 643
 644     return ret;
 645 }
 646
 647 int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned char *seed32) {
 648     VERIFY_CHECK(ctx != NULL);
 649     if (secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx)) {
 650         secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
 651     }
 652     return 1;
 653 }
 654
 655 int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_pubkey *pubnonce, const secp256k1_pubkey * const *pubnonces, size_t n) {
 656     size_t i;
 657     secp256k1_gej Qj;
 658     secp256k1_ge Q;
 659
 660     ARG_CHECK(pubnonce != NULL);
 661     memset(pubnonce, 0, sizeof(*pubnonce));
 662     ARG_CHECK(n >= 1);
 663     ARG_CHECK(pubnonces != NULL);
 664
 665     secp256k1_gej_set_infinity(&Qj);
 666
 667     for (i = 0; i < n; i++) {
 668         secp256k1_pubkey_load(ctx, &Q, pubnonces[i]);
 669         secp256k1_gej_add_ge(&Qj, &Qj, &Q);
 670     }
 671     if (secp256k1_gej_is_infinity(&Qj)) {
 672         return 0;
 673     }
 674     secp256k1_ge_set_gej(&Q, &Qj);
 675     secp256k1_pubkey_save(pubnonce, &Q);
 676     return 1;
 677 }
 678
 679 #ifdef ENABLE_MODULE_ECDH
 680 # include "modules/ecdh/main_impl.h"
 681 #endif
 682
 683 #ifdef ENABLE_MODULE_RECOVERY
 684 # include "modules/recovery/main_impl.h"
 685 #endif