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