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