src/scalar_8x32_impl.h

   1 /**********************************************************************
   2  * Copyright (c) 2014 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 #ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
   8 #define _SECP256K1_SCALAR_REPR_IMPL_H_
   9
  10 /* Limbs of the secp256k1 order. */
  11 #define SECP256K1_N_0 ((uint32_t)0xD0364141UL)
  12 #define SECP256K1_N_1 ((uint32_t)0xBFD25E8CUL)
  13 #define SECP256K1_N_2 ((uint32_t)0xAF48A03BUL)
  14 #define SECP256K1_N_3 ((uint32_t)0xBAAEDCE6UL)
  15 #define SECP256K1_N_4 ((uint32_t)0xFFFFFFFEUL)
  16 #define SECP256K1_N_5 ((uint32_t)0xFFFFFFFFUL)
  17 #define SECP256K1_N_6 ((uint32_t)0xFFFFFFFFUL)
  18 #define SECP256K1_N_7 ((uint32_t)0xFFFFFFFFUL)
  19
  20 /* Limbs of 2^256 minus the secp256k1 order. */
  21 #define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1)
  22 #define SECP256K1_N_C_1 (~SECP256K1_N_1)
  23 #define SECP256K1_N_C_2 (~SECP256K1_N_2)
  24 #define SECP256K1_N_C_3 (~SECP256K1_N_3)
  25 #define SECP256K1_N_C_4 (1)
  26
  27 /* Limbs of half the secp256k1 order. */
  28 #define SECP256K1_N_H_0 ((uint32_t)0x681B20A0UL)
  29 #define SECP256K1_N_H_1 ((uint32_t)0xDFE92F46UL)
  30 #define SECP256K1_N_H_2 ((uint32_t)0x57A4501DUL)
  31 #define SECP256K1_N_H_3 ((uint32_t)0x5D576E73UL)
  32 #define SECP256K1_N_H_4 ((uint32_t)0xFFFFFFFFUL)
  33 #define SECP256K1_N_H_5 ((uint32_t)0xFFFFFFFFUL)
  34 #define SECP256K1_N_H_6 ((uint32_t)0xFFFFFFFFUL)
  35 #define SECP256K1_N_H_7 ((uint32_t)0x7FFFFFFFUL)
  36
  37 SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar_t *r) {
  38     r->d[0] = 0;
  39     r->d[1] = 0;
  40     r->d[2] = 0;
  41     r->d[3] = 0;
  42     r->d[4] = 0;
  43     r->d[5] = 0;
  44     r->d[6] = 0;
  45     r->d[7] = 0;
  46 }
  47
  48 SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, unsigned int v) {
  49     r->d[0] = v;
  50     r->d[1] = 0;
  51     r->d[2] = 0;
  52     r->d[3] = 0;
  53     r->d[4] = 0;
  54     r->d[5] = 0;
  55     r->d[6] = 0;
  56     r->d[7] = 0;
  57 }
  58
  59 SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
  60     VERIFY_CHECK((offset + count - 1) >> 5 == offset >> 5);
  61     return (a->d[offset >> 5] >> (offset & 0x1F)) & ((1 << count) - 1);
  62 }
  63
  64 SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
  65     VERIFY_CHECK(count < 32);
  66     VERIFY_CHECK(offset + count <= 256);
  67     if ((offset + count - 1) >> 5 == offset >> 5) {
  68         return secp256k1_scalar_get_bits(a, offset, count);
  69     } else {
  70         VERIFY_CHECK((offset >> 5) + 1 < 8);
  71         return ((a->d[offset >> 5] >> (offset & 0x1F)) | (a->d[(offset >> 5) + 1] << (32 - (offset & 0x1F)))) & ((((uint32_t)1) << count) - 1);
  72     }
  73 }
  74
  75 SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar_t *a) {
  76     int yes = 0;
  77     int no = 0;
  78     no |= (a->d[7] < SECP256K1_N_7); /* No need for a > check. */
  79     no |= (a->d[6] < SECP256K1_N_6); /* No need for a > check. */
  80     no |= (a->d[5] < SECP256K1_N_5); /* No need for a > check. */
  81     no |= (a->d[4] < SECP256K1_N_4);
  82     yes |= (a->d[4] > SECP256K1_N_4) & ~no;
  83     no |= (a->d[3] < SECP256K1_N_3) & ~yes;
  84     yes |= (a->d[3] > SECP256K1_N_3) & ~no;
  85     no |= (a->d[2] < SECP256K1_N_2) & ~yes;
  86     yes |= (a->d[2] > SECP256K1_N_2) & ~no;
  87     no |= (a->d[1] < SECP256K1_N_1) & ~yes;
  88     yes |= (a->d[1] > SECP256K1_N_1) & ~no;
  89     yes |= (a->d[0] >= SECP256K1_N_0) & ~no;
  90     return yes;
  91 }
  92
  93 SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar_t *r, uint32_t overflow) {
  94     uint64_t t;
  95     VERIFY_CHECK(overflow <= 1);
  96     t = (uint64_t)r->d[0] + overflow * SECP256K1_N_C_0;
  97     r->d[0] = t & 0xFFFFFFFFUL; t >>= 32;
  98     t += (uint64_t)r->d[1] + overflow * SECP256K1_N_C_1;
  99     r->d[1] = t & 0xFFFFFFFFUL; t >>= 32;
 100     t += (uint64_t)r->d[2] + overflow * SECP256K1_N_C_2;
 101     r->d[2] = t & 0xFFFFFFFFUL; t >>= 32;
 102     t += (uint64_t)r->d[3] + overflow * SECP256K1_N_C_3;
 103     r->d[3] = t & 0xFFFFFFFFUL; t >>= 32;
 104     t += (uint64_t)r->d[4] + overflow * SECP256K1_N_C_4;
 105     r->d[4] = t & 0xFFFFFFFFUL; t >>= 32;
 106     t += (uint64_t)r->d[5];
 107     r->d[5] = t & 0xFFFFFFFFUL; t >>= 32;
 108     t += (uint64_t)r->d[6];
 109     r->d[6] = t & 0xFFFFFFFFUL; t >>= 32;
 110     t += (uint64_t)r->d[7];
 111     r->d[7] = t & 0xFFFFFFFFUL;
 112     return overflow;
 113 }
 114
 115 static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
 116     int overflow;
 117     uint64_t t = (uint64_t)a->d[0] + b->d[0];
 118     r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
 119     t += (uint64_t)a->d[1] + b->d[1];
 120     r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
 121     t += (uint64_t)a->d[2] + b->d[2];
 122     r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
 123     t += (uint64_t)a->d[3] + b->d[3];
 124     r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
 125     t += (uint64_t)a->d[4] + b->d[4];
 126     r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
 127     t += (uint64_t)a->d[5] + b->d[5];
 128     r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
 129     t += (uint64_t)a->d[6] + b->d[6];
 130     r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
 131     t += (uint64_t)a->d[7] + b->d[7];
 132     r->d[7] = t & 0xFFFFFFFFULL; t >>= 32;
 133     overflow = t + secp256k1_scalar_check_overflow(r);
 134     VERIFY_CHECK(overflow == 0 || overflow == 1);
 135     secp256k1_scalar_reduce(r, overflow);
 136     return overflow;
 137 }
 138
 139 static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit) {
 140     uint64_t t;
 141     VERIFY_CHECK(bit < 256);
 142     t = (uint64_t)r->d[0] + (((uint32_t)((bit >> 5) == 0)) << (bit & 0x1F));
 143     r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
 144     t += (uint64_t)r->d[1] + (((uint32_t)((bit >> 5) == 1)) << (bit & 0x1F));
 145     r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
 146     t += (uint64_t)r->d[2] + (((uint32_t)((bit >> 5) == 2)) << (bit & 0x1F));
 147     r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
 148     t += (uint64_t)r->d[3] + (((uint32_t)((bit >> 5) == 3)) << (bit & 0x1F));
 149     r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
 150     t += (uint64_t)r->d[4] + (((uint32_t)((bit >> 5) == 4)) << (bit & 0x1F));
 151     r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
 152     t += (uint64_t)r->d[5] + (((uint32_t)((bit >> 5) == 5)) << (bit & 0x1F));
 153     r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
 154     t += (uint64_t)r->d[6] + (((uint32_t)((bit >> 5) == 6)) << (bit & 0x1F));
 155     r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
 156     t += (uint64_t)r->d[7] + (((uint32_t)((bit >> 5) == 7)) << (bit & 0x1F));
 157     r->d[7] = t & 0xFFFFFFFFULL;
 158 #ifdef VERIFY
 159     VERIFY_CHECK((t >> 32) == 0);
 160     VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
 161 #endif
 162 }
 163
 164 static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *b32, int *overflow) {
 165     int over;
 166     r->d[0] = (uint32_t)b32[31] | (uint32_t)b32[30] << 8 | (uint32_t)b32[29] << 16 | (uint32_t)b32[28] << 24;
 167     r->d[1] = (uint32_t)b32[27] | (uint32_t)b32[26] << 8 | (uint32_t)b32[25] << 16 | (uint32_t)b32[24] << 24;
 168     r->d[2] = (uint32_t)b32[23] | (uint32_t)b32[22] << 8 | (uint32_t)b32[21] << 16 | (uint32_t)b32[20] << 24;
 169     r->d[3] = (uint32_t)b32[19] | (uint32_t)b32[18] << 8 | (uint32_t)b32[17] << 16 | (uint32_t)b32[16] << 24;
 170     r->d[4] = (uint32_t)b32[15] | (uint32_t)b32[14] << 8 | (uint32_t)b32[13] << 16 | (uint32_t)b32[12] << 24;
 171     r->d[5] = (uint32_t)b32[11] | (uint32_t)b32[10] << 8 | (uint32_t)b32[9] << 16 | (uint32_t)b32[8] << 24;
 172     r->d[6] = (uint32_t)b32[7] | (uint32_t)b32[6] << 8 | (uint32_t)b32[5] << 16 | (uint32_t)b32[4] << 24;
 173     r->d[7] = (uint32_t)b32[3] | (uint32_t)b32[2] << 8 | (uint32_t)b32[1] << 16 | (uint32_t)b32[0] << 24;
 174     over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
 175     if (overflow) {
 176         *overflow = over;
 177     }
 178 }
 179
 180 static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a) {
 181     bin[0] = a->d[7] >> 24; bin[1] = a->d[7] >> 16; bin[2] = a->d[7] >> 8; bin[3] = a->d[7];
 182     bin[4] = a->d[6] >> 24; bin[5] = a->d[6] >> 16; bin[6] = a->d[6] >> 8; bin[7] = a->d[6];
 183     bin[8] = a->d[5] >> 24; bin[9] = a->d[5] >> 16; bin[10] = a->d[5] >> 8; bin[11] = a->d[5];
 184     bin[12] = a->d[4] >> 24; bin[13] = a->d[4] >> 16; bin[14] = a->d[4] >> 8; bin[15] = a->d[4];
 185     bin[16] = a->d[3] >> 24; bin[17] = a->d[3] >> 16; bin[18] = a->d[3] >> 8; bin[19] = a->d[3];
 186     bin[20] = a->d[2] >> 24; bin[21] = a->d[2] >> 16; bin[22] = a->d[2] >> 8; bin[23] = a->d[2];
 187     bin[24] = a->d[1] >> 24; bin[25] = a->d[1] >> 16; bin[26] = a->d[1] >> 8; bin[27] = a->d[1];
 188     bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
 189 }
 190
 191 SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar_t *a) {
 192     return (a->d[0] | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
 193 }
 194
 195 static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
 196     uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(a) == 0);
 197     uint64_t t = (uint64_t)(~a->d[0]) + SECP256K1_N_0 + 1;
 198     r->d[0] = t & nonzero; t >>= 32;
 199     t += (uint64_t)(~a->d[1]) + SECP256K1_N_1;
 200     r->d[1] = t & nonzero; t >>= 32;
 201     t += (uint64_t)(~a->d[2]) + SECP256K1_N_2;
 202     r->d[2] = t & nonzero; t >>= 32;
 203     t += (uint64_t)(~a->d[3]) + SECP256K1_N_3;
 204     r->d[3] = t & nonzero; t >>= 32;
 205     t += (uint64_t)(~a->d[4]) + SECP256K1_N_4;
 206     r->d[4] = t & nonzero; t >>= 32;
 207     t += (uint64_t)(~a->d[5]) + SECP256K1_N_5;
 208     r->d[5] = t & nonzero; t >>= 32;
 209     t += (uint64_t)(~a->d[6]) + SECP256K1_N_6;
 210     r->d[6] = t & nonzero; t >>= 32;
 211     t += (uint64_t)(~a->d[7]) + SECP256K1_N_7;
 212     r->d[7] = t & nonzero;
 213 }
 214
 215 SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar_t *a) {
 216     return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
 217 }
 218
 219 static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
 220     int yes = 0;
 221     int no = 0;
 222     no |= (a->d[7] < SECP256K1_N_H_7);
 223     yes |= (a->d[7] > SECP256K1_N_H_7) & ~no;
 224     no |= (a->d[6] < SECP256K1_N_H_6) & ~yes; /* No need for a > check. */
 225     no |= (a->d[5] < SECP256K1_N_H_5) & ~yes; /* No need for a > check. */
 226     no |= (a->d[4] < SECP256K1_N_H_4) & ~yes; /* No need for a > check. */
 227     no |= (a->d[3] < SECP256K1_N_H_3) & ~yes;
 228     yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
 229     no |= (a->d[2] < SECP256K1_N_H_2) & ~yes;
 230     yes |= (a->d[2] > SECP256K1_N_H_2) & ~no;
 231     no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
 232     yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
 233     yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
 234     return yes;
 235 }
 236
 237 /* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
 238
 239 /** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
 240 #define muladd(a,b) { \
 241     uint32_t tl, th; \
 242     { \
 243         uint64_t t = (uint64_t)a * b; \
 244         th = t >> 32;         /* at most 0xFFFFFFFE */ \
 245         tl = t; \
 246     } \
 247     c0 += tl;                 /* overflow is handled on the next line */ \
 248     th += (c0 < tl) ? 1 : 0;  /* at most 0xFFFFFFFF */ \
 249     c1 += th;                 /* overflow is handled on the next line */ \
 250     c2 += (c1 < th) ? 1 : 0;  /* never overflows by contract (verified in the next line) */ \
 251     VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
 252 }
 253
 254 /** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
 255 #define muladd_fast(a,b) { \
 256     uint32_t tl, th; \
 257     { \
 258         uint64_t t = (uint64_t)a * b; \
 259         th = t >> 32;         /* at most 0xFFFFFFFE */ \
 260         tl = t; \
 261     } \
 262     c0 += tl;                 /* overflow is handled on the next line */ \
 263     th += (c0 < tl) ? 1 : 0;  /* at most 0xFFFFFFFF */ \
 264     c1 += th;                 /* never overflows by contract (verified in the next line) */ \
 265     VERIFY_CHECK(c1 >= th); \
 266 }
 267
 268 /** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
 269 #define muladd2(a,b) { \
 270     uint32_t tl, th, th2, tl2; \
 271     { \
 272         uint64_t t = (uint64_t)a * b; \
 273         th = t >> 32;               /* at most 0xFFFFFFFE */ \
 274         tl = t; \
 275     } \
 276     th2 = th + th;                  /* at most 0xFFFFFFFE (in case th was 0x7FFFFFFF) */ \
 277     c2 += (th2 < th) ? 1 : 0;       /* never overflows by contract (verified the next line) */ \
 278     VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
 279     tl2 = tl + tl;                  /* at most 0xFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFF) */ \
 280     th2 += (tl2 < tl) ? 1 : 0;      /* at most 0xFFFFFFFF */ \
 281     c0 += tl2;                      /* overflow is handled on the next line */ \
 282     th2 += (c0 < tl2) ? 1 : 0;      /* second overflow is handled on the next line */ \
 283     c2 += (c0 < tl2) & (th2 == 0);  /* never overflows by contract (verified the next line) */ \
 284     VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
 285     c1 += th2;                      /* overflow is handled on the next line */ \
 286     c2 += (c1 < th2) ? 1 : 0;       /* never overflows by contract (verified the next line) */ \
 287     VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
 288 }
 289
 290 /** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
 291 #define sumadd(a) { \
 292     unsigned int over; \
 293     c0 += (a);                  /* overflow is handled on the next line */ \
 294     over = (c0 < (a)) ? 1 : 0; \
 295     c1 += over;                 /* overflow is handled on the next line */ \
 296     c2 += (c1 < over) ? 1 : 0;  /* never overflows by contract */ \
 297 }
 298
 299 /** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
 300 #define sumadd_fast(a) { \
 301     c0 += (a);                 /* overflow is handled on the next line */ \
 302     c1 += (c0 < (a)) ? 1 : 0;  /* never overflows by contract (verified the next line) */ \
 303     VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
 304     VERIFY_CHECK(c2 == 0); \
 305 }
 306
 307 /** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. */
 308 #define extract(n) { \
 309     (n) = c0; \
 310     c0 = c1; \
 311     c1 = c2; \
 312     c2 = 0; \
 313 }
 314
 315 /** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. c2 is required to be zero. */
 316 #define extract_fast(n) { \
 317     (n) = c0; \
 318     c0 = c1; \
 319     c1 = 0; \
 320     VERIFY_CHECK(c2 == 0); \
 321 }
 322
 323 static void secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint32_t *l) {
 324     uint64_t c;
 325     uint32_t n0 = l[8], n1 = l[9], n2 = l[10], n3 = l[11], n4 = l[12], n5 = l[13], n6 = l[14], n7 = l[15];
 326     uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12;
 327     uint32_t p0, p1, p2, p3, p4, p5, p6, p7, p8;
 328
 329     /* 96 bit accumulator. */
 330     uint32_t c0, c1, c2;
 331
 332     /* Reduce 512 bits into 385. */
 333     /* m[0..12] = l[0..7] + n[0..7] * SECP256K1_N_C. */
 334     c0 = l[0]; c1 = 0; c2 = 0;
 335     muladd_fast(n0, SECP256K1_N_C_0);
 336     extract_fast(m0);
 337     sumadd_fast(l[1]);
 338     muladd(n1, SECP256K1_N_C_0);
 339     muladd(n0, SECP256K1_N_C_1);
 340     extract(m1);
 341     sumadd(l[2]);
 342     muladd(n2, SECP256K1_N_C_0);
 343     muladd(n1, SECP256K1_N_C_1);
 344     muladd(n0, SECP256K1_N_C_2);
 345     extract(m2);
 346     sumadd(l[3]);
 347     muladd(n3, SECP256K1_N_C_0);
 348     muladd(n2, SECP256K1_N_C_1);
 349     muladd(n1, SECP256K1_N_C_2);
 350     muladd(n0, SECP256K1_N_C_3);
 351     extract(m3);
 352     sumadd(l[4]);
 353     muladd(n4, SECP256K1_N_C_0);
 354     muladd(n3, SECP256K1_N_C_1);
 355     muladd(n2, SECP256K1_N_C_2);
 356     muladd(n1, SECP256K1_N_C_3);
 357     sumadd(n0);
 358     extract(m4);
 359     sumadd(l[5]);
 360     muladd(n5, SECP256K1_N_C_0);
 361     muladd(n4, SECP256K1_N_C_1);
 362     muladd(n3, SECP256K1_N_C_2);
 363     muladd(n2, SECP256K1_N_C_3);
 364     sumadd(n1);
 365     extract(m5);
 366     sumadd(l[6]);
 367     muladd(n6, SECP256K1_N_C_0);
 368     muladd(n5, SECP256K1_N_C_1);
 369     muladd(n4, SECP256K1_N_C_2);
 370     muladd(n3, SECP256K1_N_C_3);
 371     sumadd(n2);
 372     extract(m6);
 373     sumadd(l[7]);
 374     muladd(n7, SECP256K1_N_C_0);
 375     muladd(n6, SECP256K1_N_C_1);
 376     muladd(n5, SECP256K1_N_C_2);
 377     muladd(n4, SECP256K1_N_C_3);
 378     sumadd(n3);
 379     extract(m7);
 380     muladd(n7, SECP256K1_N_C_1);
 381     muladd(n6, SECP256K1_N_C_2);
 382     muladd(n5, SECP256K1_N_C_3);
 383     sumadd(n4);
 384     extract(m8);
 385     muladd(n7, SECP256K1_N_C_2);
 386     muladd(n6, SECP256K1_N_C_3);
 387     sumadd(n5);
 388     extract(m9);
 389     muladd(n7, SECP256K1_N_C_3);
 390     sumadd(n6);
 391     extract(m10);
 392     sumadd_fast(n7);
 393     extract_fast(m11);
 394     VERIFY_CHECK(c0 <= 1);
 395     m12 = c0;
 396
 397     /* Reduce 385 bits into 258. */
 398     /* p[0..8] = m[0..7] + m[8..12] * SECP256K1_N_C. */
 399     c0 = m0; c1 = 0; c2 = 0;
 400     muladd_fast(m8, SECP256K1_N_C_0);
 401     extract_fast(p0);
 402     sumadd_fast(m1);
 403     muladd(m9, SECP256K1_N_C_0);
 404     muladd(m8, SECP256K1_N_C_1);
 405     extract(p1);
 406     sumadd(m2);
 407     muladd(m10, SECP256K1_N_C_0);
 408     muladd(m9, SECP256K1_N_C_1);
 409     muladd(m8, SECP256K1_N_C_2);
 410     extract(p2);
 411     sumadd(m3);
 412     muladd(m11, SECP256K1_N_C_0);
 413     muladd(m10, SECP256K1_N_C_1);
 414     muladd(m9, SECP256K1_N_C_2);
 415     muladd(m8, SECP256K1_N_C_3);
 416     extract(p3);
 417     sumadd(m4);
 418     muladd(m12, SECP256K1_N_C_0);
 419     muladd(m11, SECP256K1_N_C_1);
 420     muladd(m10, SECP256K1_N_C_2);
 421     muladd(m9, SECP256K1_N_C_3);
 422     sumadd(m8);
 423     extract(p4);
 424     sumadd(m5);
 425     muladd(m12, SECP256K1_N_C_1);
 426     muladd(m11, SECP256K1_N_C_2);
 427     muladd(m10, SECP256K1_N_C_3);
 428     sumadd(m9);
 429     extract(p5);
 430     sumadd(m6);
 431     muladd(m12, SECP256K1_N_C_2);
 432     muladd(m11, SECP256K1_N_C_3);
 433     sumadd(m10);
 434     extract(p6);
 435     sumadd_fast(m7);
 436     muladd_fast(m12, SECP256K1_N_C_3);
 437     sumadd_fast(m11);
 438     extract_fast(p7);
 439     p8 = c0 + m12;
 440     VERIFY_CHECK(p8 <= 2);
 441
 442     /* Reduce 258 bits into 256. */
 443     /* r[0..7] = p[0..7] + p[8] * SECP256K1_N_C. */
 444     c = p0 + (uint64_t)SECP256K1_N_C_0 * p8;
 445     r->d[0] = c & 0xFFFFFFFFUL; c >>= 32;
 446     c += p1 + (uint64_t)SECP256K1_N_C_1 * p8;
 447     r->d[1] = c & 0xFFFFFFFFUL; c >>= 32;
 448     c += p2 + (uint64_t)SECP256K1_N_C_2 * p8;
 449     r->d[2] = c & 0xFFFFFFFFUL; c >>= 32;
 450     c += p3 + (uint64_t)SECP256K1_N_C_3 * p8;
 451     r->d[3] = c & 0xFFFFFFFFUL; c >>= 32;
 452     c += p4 + (uint64_t)p8;
 453     r->d[4] = c & 0xFFFFFFFFUL; c >>= 32;
 454     c += p5;
 455     r->d[5] = c & 0xFFFFFFFFUL; c >>= 32;
 456     c += p6;
 457     r->d[6] = c & 0xFFFFFFFFUL; c >>= 32;
 458     c += p7;
 459     r->d[7] = c & 0xFFFFFFFFUL; c >>= 32;
 460
 461     /* Final reduction of r. */
 462     secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
 463 }
 464
 465 static void secp256k1_scalar_mul_512(uint32_t l[16], const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
 466     /* 96 bit accumulator. */
 467     uint32_t c0 = 0, c1 = 0, c2 = 0;
 468
 469     /* l[0..15] = a[0..7] * b[0..7]. */
 470     muladd_fast(a->d[0], b->d[0]);
 471     extract_fast(l[0]);
 472     muladd(a->d[0], b->d[1]);
 473     muladd(a->d[1], b->d[0]);
 474     extract(l[1]);
 475     muladd(a->d[0], b->d[2]);
 476     muladd(a->d[1], b->d[1]);
 477     muladd(a->d[2], b->d[0]);
 478     extract(l[2]);
 479     muladd(a->d[0], b->d[3]);
 480     muladd(a->d[1], b->d[2]);
 481     muladd(a->d[2], b->d[1]);
 482     muladd(a->d[3], b->d[0]);
 483     extract(l[3]);
 484     muladd(a->d[0], b->d[4]);
 485     muladd(a->d[1], b->d[3]);
 486     muladd(a->d[2], b->d[2]);
 487     muladd(a->d[3], b->d[1]);
 488     muladd(a->d[4], b->d[0]);
 489     extract(l[4]);
 490     muladd(a->d[0], b->d[5]);
 491     muladd(a->d[1], b->d[4]);
 492     muladd(a->d[2], b->d[3]);
 493     muladd(a->d[3], b->d[2]);
 494     muladd(a->d[4], b->d[1]);
 495     muladd(a->d[5], b->d[0]);
 496     extract(l[5]);
 497     muladd(a->d[0], b->d[6]);
 498     muladd(a->d[1], b->d[5]);
 499     muladd(a->d[2], b->d[4]);
 500     muladd(a->d[3], b->d[3]);
 501     muladd(a->d[4], b->d[2]);
 502     muladd(a->d[5], b->d[1]);
 503     muladd(a->d[6], b->d[0]);
 504     extract(l[6]);
 505     muladd(a->d[0], b->d[7]);
 506     muladd(a->d[1], b->d[6]);
 507     muladd(a->d[2], b->d[5]);
 508     muladd(a->d[3], b->d[4]);
 509     muladd(a->d[4], b->d[3]);
 510     muladd(a->d[5], b->d[2]);
 511     muladd(a->d[6], b->d[1]);
 512     muladd(a->d[7], b->d[0]);
 513     extract(l[7]);
 514     muladd(a->d[1], b->d[7]);
 515     muladd(a->d[2], b->d[6]);
 516     muladd(a->d[3], b->d[5]);
 517     muladd(a->d[4], b->d[4]);
 518     muladd(a->d[5], b->d[3]);
 519     muladd(a->d[6], b->d[2]);
 520     muladd(a->d[7], b->d[1]);
 521     extract(l[8]);
 522     muladd(a->d[2], b->d[7]);
 523     muladd(a->d[3], b->d[6]);
 524     muladd(a->d[4], b->d[5]);
 525     muladd(a->d[5], b->d[4]);
 526     muladd(a->d[6], b->d[3]);
 527     muladd(a->d[7], b->d[2]);
 528     extract(l[9]);
 529     muladd(a->d[3], b->d[7]);
 530     muladd(a->d[4], b->d[6]);
 531     muladd(a->d[5], b->d[5]);
 532     muladd(a->d[6], b->d[4]);
 533     muladd(a->d[7], b->d[3]);
 534     extract(l[10]);
 535     muladd(a->d[4], b->d[7]);
 536     muladd(a->d[5], b->d[6]);
 537     muladd(a->d[6], b->d[5]);
 538     muladd(a->d[7], b->d[4]);
 539     extract(l[11]);
 540     muladd(a->d[5], b->d[7]);
 541     muladd(a->d[6], b->d[6]);
 542     muladd(a->d[7], b->d[5]);
 543     extract(l[12]);
 544     muladd(a->d[6], b->d[7]);
 545     muladd(a->d[7], b->d[6]);
 546     extract(l[13]);
 547     muladd_fast(a->d[7], b->d[7]);
 548     extract_fast(l[14]);
 549     VERIFY_CHECK(c1 == 0);
 550     l[15] = c0;
 551 }
 552
 553 static void secp256k1_scalar_sqr_512(uint32_t l[16], const secp256k1_scalar_t *a) {
 554     /* 96 bit accumulator. */
 555     uint32_t c0 = 0, c1 = 0, c2 = 0;
 556
 557     /* l[0..15] = a[0..7]^2. */
 558     muladd_fast(a->d[0], a->d[0]);
 559     extract_fast(l[0]);
 560     muladd2(a->d[0], a->d[1]);
 561     extract(l[1]);
 562     muladd2(a->d[0], a->d[2]);
 563     muladd(a->d[1], a->d[1]);
 564     extract(l[2]);
 565     muladd2(a->d[0], a->d[3]);
 566     muladd2(a->d[1], a->d[2]);
 567     extract(l[3]);
 568     muladd2(a->d[0], a->d[4]);
 569     muladd2(a->d[1], a->d[3]);
 570     muladd(a->d[2], a->d[2]);
 571     extract(l[4]);
 572     muladd2(a->d[0], a->d[5]);
 573     muladd2(a->d[1], a->d[4]);
 574     muladd2(a->d[2], a->d[3]);
 575     extract(l[5]);
 576     muladd2(a->d[0], a->d[6]);
 577     muladd2(a->d[1], a->d[5]);
 578     muladd2(a->d[2], a->d[4]);
 579     muladd(a->d[3], a->d[3]);
 580     extract(l[6]);
 581     muladd2(a->d[0], a->d[7]);
 582     muladd2(a->d[1], a->d[6]);
 583     muladd2(a->d[2], a->d[5]);
 584     muladd2(a->d[3], a->d[4]);
 585     extract(l[7]);
 586     muladd2(a->d[1], a->d[7]);
 587     muladd2(a->d[2], a->d[6]);
 588     muladd2(a->d[3], a->d[5]);
 589     muladd(a->d[4], a->d[4]);
 590     extract(l[8]);
 591     muladd2(a->d[2], a->d[7]);
 592     muladd2(a->d[3], a->d[6]);
 593     muladd2(a->d[4], a->d[5]);
 594     extract(l[9]);
 595     muladd2(a->d[3], a->d[7]);
 596     muladd2(a->d[4], a->d[6]);
 597     muladd(a->d[5], a->d[5]);
 598     extract(l[10]);
 599     muladd2(a->d[4], a->d[7]);
 600     muladd2(a->d[5], a->d[6]);
 601     extract(l[11]);
 602     muladd2(a->d[5], a->d[7]);
 603     muladd(a->d[6], a->d[6]);
 604     extract(l[12]);
 605     muladd2(a->d[6], a->d[7]);
 606     extract(l[13]);
 607     muladd_fast(a->d[7], a->d[7]);
 608     extract_fast(l[14]);
 609     VERIFY_CHECK(c1 == 0);
 610     l[15] = c0;
 611 }
 612
 613 #undef sumadd
 614 #undef sumadd_fast
 615 #undef muladd
 616 #undef muladd_fast
 617 #undef muladd2
 618 #undef extract
 619 #undef extract_fast
 620
 621 static void secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
 622     uint32_t l[16];
 623     secp256k1_scalar_mul_512(l, a, b);
 624     secp256k1_scalar_reduce_512(r, l);
 625 }
 626
 627 static void secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
 628     uint32_t l[16];
 629     secp256k1_scalar_sqr_512(l, a);
 630     secp256k1_scalar_reduce_512(r, l);
 631 }
 632
 633 static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a) {
 634     r1->d[0] = a->d[0];
 635     r1->d[1] = a->d[1];
 636     r1->d[2] = a->d[2];
 637     r1->d[3] = a->d[3];
 638     r1->d[4] = 0;
 639     r1->d[5] = 0;
 640     r1->d[6] = 0;
 641     r1->d[7] = 0;
 642     r2->d[0] = a->d[4];
 643     r2->d[1] = a->d[5];
 644     r2->d[2] = a->d[6];
 645     r2->d[3] = a->d[7];
 646     r2->d[4] = 0;
 647     r2->d[5] = 0;
 648     r2->d[6] = 0;
 649     r2->d[7] = 0;
 650 }
 651
 652 SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
 653     return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3]) | (a->d[4] ^ b->d[4]) | (a->d[5] ^ b->d[5]) | (a->d[6] ^ b->d[6]) | (a->d[7] ^ b->d[7])) == 0;
 654 }
 655
 656 SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b, unsigned int shift) {
 657     uint32_t l[16];
 658     unsigned int shiftlimbs;
 659     unsigned int shiftlow;
 660     unsigned int shifthigh;
 661     VERIFY_CHECK(shift >= 256);
 662     secp256k1_scalar_mul_512(l, a, b);
 663     shiftlimbs = shift >> 5;
 664     shiftlow = shift & 0x1F;
 665     shifthigh = 32 - shiftlow;
 666     r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 480 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
 667     r->d[1] = shift < 480 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
 668     r->d[2] = shift < 448 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 416 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
 669     r->d[3] = shift < 416 ? (l[3 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[4 + shiftlimbs] << shifthigh) : 0)) : 0;
 670     r->d[4] = shift < 384 ? (l[4 + shiftlimbs] >> shiftlow | (shift < 352 && shiftlow ? (l[5 + shiftlimbs] << shifthigh) : 0)) : 0;
 671     r->d[5] = shift < 352 ? (l[5 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[6 + shiftlimbs] << shifthigh) : 0)) : 0;
 672     r->d[6] = shift < 320 ? (l[6 + shiftlimbs] >> shiftlow | (shift < 288 && shiftlow ? (l[7 + shiftlimbs] << shifthigh) : 0)) : 0;
 673     r->d[7] = shift < 288 ? (l[7 + shiftlimbs] >> shiftlow)  : 0;
 674     if ((l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1) {
 675         secp256k1_scalar_add_bit(r, 0);
 676     }
 677 }
 678
 679 #endif