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 *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 *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 *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 *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 *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 *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 *r, const secp256k1_scalar *a, const secp256k1_scalar *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_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
 140     uint64_t t;
 141     VERIFY_CHECK(bit < 256);
 142     bit += ((uint32_t) flag - 1) & 0x100;  /* forcing (bit >> 5) > 7 makes this a noop */
 143     t = (uint64_t)r->d[0] + (((uint32_t)((bit >> 5) == 0)) << (bit & 0x1F));
 144     r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
 145     t += (uint64_t)r->d[1] + (((uint32_t)((bit >> 5) == 1)) << (bit & 0x1F));
 146     r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
 147     t += (uint64_t)r->d[2] + (((uint32_t)((bit >> 5) == 2)) << (bit & 0x1F));
 148     r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
 149     t += (uint64_t)r->d[3] + (((uint32_t)((bit >> 5) == 3)) << (bit & 0x1F));
 150     r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
 151     t += (uint64_t)r->d[4] + (((uint32_t)((bit >> 5) == 4)) << (bit & 0x1F));
 152     r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
 153     t += (uint64_t)r->d[5] + (((uint32_t)((bit >> 5) == 5)) << (bit & 0x1F));
 154     r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
 155     t += (uint64_t)r->d[6] + (((uint32_t)((bit >> 5) == 6)) << (bit & 0x1F));
 156     r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
 157     t += (uint64_t)r->d[7] + (((uint32_t)((bit >> 5) == 7)) << (bit & 0x1F));
 158     r->d[7] = t & 0xFFFFFFFFULL;
 159 #ifdef VERIFY
 160     VERIFY_CHECK((t >> 32) == 0);
 161     VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
 162 #endif
 163 }
 164
 165 static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
 166     int over;
 167     r->d[0] = (uint32_t)b32[31] | (uint32_t)b32[30] << 8 | (uint32_t)b32[29] << 16 | (uint32_t)b32[28] << 24;
 168     r->d[1] = (uint32_t)b32[27] | (uint32_t)b32[26] << 8 | (uint32_t)b32[25] << 16 | (uint32_t)b32[24] << 24;
 169     r->d[2] = (uint32_t)b32[23] | (uint32_t)b32[22] << 8 | (uint32_t)b32[21] << 16 | (uint32_t)b32[20] << 24;
 170     r->d[3] = (uint32_t)b32[19] | (uint32_t)b32[18] << 8 | (uint32_t)b32[17] << 16 | (uint32_t)b32[16] << 24;
 171     r->d[4] = (uint32_t)b32[15] | (uint32_t)b32[14] << 8 | (uint32_t)b32[13] << 16 | (uint32_t)b32[12] << 24;
 172     r->d[5] = (uint32_t)b32[11] | (uint32_t)b32[10] << 8 | (uint32_t)b32[9] << 16 | (uint32_t)b32[8] << 24;
 173     r->d[6] = (uint32_t)b32[7] | (uint32_t)b32[6] << 8 | (uint32_t)b32[5] << 16 | (uint32_t)b32[4] << 24;
 174     r->d[7] = (uint32_t)b32[3] | (uint32_t)b32[2] << 8 | (uint32_t)b32[1] << 16 | (uint32_t)b32[0] << 24;
 175     over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
 176     if (overflow) {
 177         *overflow = over;
 178     }
 179 }
 180
 181 static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
 182     bin[0] = a->d[7] >> 24; bin[1] = a->d[7] >> 16; bin[2] = a->d[7] >> 8; bin[3] = a->d[7];
 183     bin[4] = a->d[6] >> 24; bin[5] = a->d[6] >> 16; bin[6] = a->d[6] >> 8; bin[7] = a->d[6];
 184     bin[8] = a->d[5] >> 24; bin[9] = a->d[5] >> 16; bin[10] = a->d[5] >> 8; bin[11] = a->d[5];
 185     bin[12] = a->d[4] >> 24; bin[13] = a->d[4] >> 16; bin[14] = a->d[4] >> 8; bin[15] = a->d[4];
 186     bin[16] = a->d[3] >> 24; bin[17] = a->d[3] >> 16; bin[18] = a->d[3] >> 8; bin[19] = a->d[3];
 187     bin[20] = a->d[2] >> 24; bin[21] = a->d[2] >> 16; bin[22] = a->d[2] >> 8; bin[23] = a->d[2];
 188     bin[24] = a->d[1] >> 24; bin[25] = a->d[1] >> 16; bin[26] = a->d[1] >> 8; bin[27] = a->d[1];
 189     bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
 190 }
 191
 192 SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
 193     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;
 194 }
 195
 196 static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
 197     uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(a) == 0);
 198     uint64_t t = (uint64_t)(~a->d[0]) + SECP256K1_N_0 + 1;
 199     r->d[0] = t & nonzero; t >>= 32;
 200     t += (uint64_t)(~a->d[1]) + SECP256K1_N_1;
 201     r->d[1] = t & nonzero; t >>= 32;
 202     t += (uint64_t)(~a->d[2]) + SECP256K1_N_2;
 203     r->d[2] = t & nonzero; t >>= 32;
 204     t += (uint64_t)(~a->d[3]) + SECP256K1_N_3;
 205     r->d[3] = t & nonzero; t >>= 32;
 206     t += (uint64_t)(~a->d[4]) + SECP256K1_N_4;
 207     r->d[4] = t & nonzero; t >>= 32;
 208     t += (uint64_t)(~a->d[5]) + SECP256K1_N_5;
 209     r->d[5] = t & nonzero; t >>= 32;
 210     t += (uint64_t)(~a->d[6]) + SECP256K1_N_6;
 211     r->d[6] = t & nonzero; t >>= 32;
 212     t += (uint64_t)(~a->d[7]) + SECP256K1_N_7;
 213     r->d[7] = t & nonzero;
 214 }
 215
 216 SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
 217     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;
 218 }
 219
 220 static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
 221     int yes = 0;
 222     int no = 0;
 223     no |= (a->d[7] < SECP256K1_N_H_7);
 224     yes |= (a->d[7] > SECP256K1_N_H_7) & ~no;
 225     no |= (a->d[6] < SECP256K1_N_H_6) & ~yes; /* No need for a > check. */
 226     no |= (a->d[5] < SECP256K1_N_H_5) & ~yes; /* No need for a > check. */
 227     no |= (a->d[4] < SECP256K1_N_H_4) & ~yes; /* No need for a > check. */
 228     no |= (a->d[3] < SECP256K1_N_H_3) & ~yes;
 229     yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
 230     no |= (a->d[2] < SECP256K1_N_H_2) & ~yes;
 231     yes |= (a->d[2] > SECP256K1_N_H_2) & ~no;
 232     no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
 233     yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
 234     yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
 235     return yes;
 236 }
 237
 238 static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
 239     /* If we are flag = 0, mask = 00...00 and this is a no-op;
 240      * if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
 241     uint32_t mask = !flag - 1;
 242     uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(r) == 0);
 243     uint64_t t = (uint64_t)(r->d[0] ^ mask) + ((SECP256K1_N_0 + 1) & mask);
 244     r->d[0] = t & nonzero; t >>= 32;
 245     t += (uint64_t)(r->d[1] ^ mask) + (SECP256K1_N_1 & mask);
 246     r->d[1] = t & nonzero; t >>= 32;
 247     t += (uint64_t)(r->d[2] ^ mask) + (SECP256K1_N_2 & mask);
 248     r->d[2] = t & nonzero; t >>= 32;
 249     t += (uint64_t)(r->d[3] ^ mask) + (SECP256K1_N_3 & mask);
 250     r->d[3] = t & nonzero; t >>= 32;
 251     t += (uint64_t)(r->d[4] ^ mask) + (SECP256K1_N_4 & mask);
 252     r->d[4] = t & nonzero; t >>= 32;
 253     t += (uint64_t)(r->d[5] ^ mask) + (SECP256K1_N_5 & mask);
 254     r->d[5] = t & nonzero; t >>= 32;
 255     t += (uint64_t)(r->d[6] ^ mask) + (SECP256K1_N_6 & mask);
 256     r->d[6] = t & nonzero; t >>= 32;
 257     t += (uint64_t)(r->d[7] ^ mask) + (SECP256K1_N_7 & mask);
 258     r->d[7] = t & nonzero;
 259     return 2 * (mask == 0) - 1;
 260 }
 261
 262
 263 /* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
 264
 265 /** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
 266 #define muladd(a,b) { \
 267     uint32_t tl, th; \
 268     { \
 269         uint64_t t = (uint64_t)a * b; \
 270         th = t >> 32;         /* at most 0xFFFFFFFE */ \
 271         tl = t; \
 272     } \
 273     c0 += tl;                 /* overflow is handled on the next line */ \
 274     th += (c0 < tl);          /* at most 0xFFFFFFFF */ \
 275     c1 += th;                 /* overflow is handled on the next line */ \
 276     c2 += (c1 < th);          /* never overflows by contract (verified in the next line) */ \
 277     VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
 278 }
 279
 280 /** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
 281 #define muladd_fast(a,b) { \
 282     uint32_t tl, th; \
 283     { \
 284         uint64_t t = (uint64_t)a * b; \
 285         th = t >> 32;         /* at most 0xFFFFFFFE */ \
 286         tl = t; \
 287     } \
 288     c0 += tl;                 /* overflow is handled on the next line */ \
 289     th += (c0 < tl);          /* at most 0xFFFFFFFF */ \
 290     c1 += th;                 /* never overflows by contract (verified in the next line) */ \
 291     VERIFY_CHECK(c1 >= th); \
 292 }
 293
 294 /** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
 295 #define muladd2(a,b) { \
 296     uint32_t tl, th, th2, tl2; \
 297     { \
 298         uint64_t t = (uint64_t)a * b; \
 299         th = t >> 32;               /* at most 0xFFFFFFFE */ \
 300         tl = t; \
 301     } \
 302     th2 = th + th;                  /* at most 0xFFFFFFFE (in case th was 0x7FFFFFFF) */ \
 303     c2 += (th2 < th);               /* never overflows by contract (verified the next line) */ \
 304     VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
 305     tl2 = tl + tl;                  /* at most 0xFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFF) */ \
 306     th2 += (tl2 < tl);              /* at most 0xFFFFFFFF */ \
 307     c0 += tl2;                      /* overflow is handled on the next line */ \
 308     th2 += (c0 < tl2);              /* second overflow is handled on the next line */ \
 309     c2 += (c0 < tl2) & (th2 == 0);  /* never overflows by contract (verified the next line) */ \
 310     VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
 311     c1 += th2;                      /* overflow is handled on the next line */ \
 312     c2 += (c1 < th2);               /* never overflows by contract (verified the next line) */ \
 313     VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
 314 }
 315
 316 /** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
 317 #define sumadd(a) { \
 318     unsigned int over; \
 319     c0 += (a);                  /* overflow is handled on the next line */ \
 320     over = (c0 < (a)); \
 321     c1 += over;                 /* overflow is handled on the next line */ \
 322     c2 += (c1 < over);          /* never overflows by contract */ \
 323 }
 324
 325 /** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
 326 #define sumadd_fast(a) { \
 327     c0 += (a);                 /* overflow is handled on the next line */ \
 328     c1 += (c0 < (a));          /* never overflows by contract (verified the next line) */ \
 329     VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
 330     VERIFY_CHECK(c2 == 0); \
 331 }
 332
 333 /** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. */
 334 #define extract(n) { \
 335     (n) = c0; \
 336     c0 = c1; \
 337     c1 = c2; \
 338     c2 = 0; \
 339 }
 340
 341 /** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. c2 is required to be zero. */
 342 #define extract_fast(n) { \
 343     (n) = c0; \
 344     c0 = c1; \
 345     c1 = 0; \
 346     VERIFY_CHECK(c2 == 0); \
 347 }
 348
 349 static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint32_t *l) {
 350     uint64_t c;
 351     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];
 352     uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12;
 353     uint32_t p0, p1, p2, p3, p4, p5, p6, p7, p8;
 354
 355     /* 96 bit accumulator. */
 356     uint32_t c0, c1, c2;
 357
 358     /* Reduce 512 bits into 385. */
 359     /* m[0..12] = l[0..7] + n[0..7] * SECP256K1_N_C. */
 360     c0 = l[0]; c1 = 0; c2 = 0;
 361     muladd_fast(n0, SECP256K1_N_C_0);
 362     extract_fast(m0);
 363     sumadd_fast(l[1]);
 364     muladd(n1, SECP256K1_N_C_0);
 365     muladd(n0, SECP256K1_N_C_1);
 366     extract(m1);
 367     sumadd(l[2]);
 368     muladd(n2, SECP256K1_N_C_0);
 369     muladd(n1, SECP256K1_N_C_1);
 370     muladd(n0, SECP256K1_N_C_2);
 371     extract(m2);
 372     sumadd(l[3]);
 373     muladd(n3, SECP256K1_N_C_0);
 374     muladd(n2, SECP256K1_N_C_1);
 375     muladd(n1, SECP256K1_N_C_2);
 376     muladd(n0, SECP256K1_N_C_3);
 377     extract(m3);
 378     sumadd(l[4]);
 379     muladd(n4, SECP256K1_N_C_0);
 380     muladd(n3, SECP256K1_N_C_1);
 381     muladd(n2, SECP256K1_N_C_2);
 382     muladd(n1, SECP256K1_N_C_3);
 383     sumadd(n0);
 384     extract(m4);
 385     sumadd(l[5]);
 386     muladd(n5, SECP256K1_N_C_0);
 387     muladd(n4, SECP256K1_N_C_1);
 388     muladd(n3, SECP256K1_N_C_2);
 389     muladd(n2, SECP256K1_N_C_3);
 390     sumadd(n1);
 391     extract(m5);
 392     sumadd(l[6]);
 393     muladd(n6, SECP256K1_N_C_0);
 394     muladd(n5, SECP256K1_N_C_1);
 395     muladd(n4, SECP256K1_N_C_2);
 396     muladd(n3, SECP256K1_N_C_3);
 397     sumadd(n2);
 398     extract(m6);
 399     sumadd(l[7]);
 400     muladd(n7, SECP256K1_N_C_0);
 401     muladd(n6, SECP256K1_N_C_1);
 402     muladd(n5, SECP256K1_N_C_2);
 403     muladd(n4, SECP256K1_N_C_3);
 404     sumadd(n3);
 405     extract(m7);
 406     muladd(n7, SECP256K1_N_C_1);
 407     muladd(n6, SECP256K1_N_C_2);
 408     muladd(n5, SECP256K1_N_C_3);
 409     sumadd(n4);
 410     extract(m8);
 411     muladd(n7, SECP256K1_N_C_2);
 412     muladd(n6, SECP256K1_N_C_3);
 413     sumadd(n5);
 414     extract(m9);
 415     muladd(n7, SECP256K1_N_C_3);
 416     sumadd(n6);
 417     extract(m10);
 418     sumadd_fast(n7);
 419     extract_fast(m11);
 420     VERIFY_CHECK(c0 <= 1);
 421     m12 = c0;
 422
 423     /* Reduce 385 bits into 258. */
 424     /* p[0..8] = m[0..7] + m[8..12] * SECP256K1_N_C. */
 425     c0 = m0; c1 = 0; c2 = 0;
 426     muladd_fast(m8, SECP256K1_N_C_0);
 427     extract_fast(p0);
 428     sumadd_fast(m1);
 429     muladd(m9, SECP256K1_N_C_0);
 430     muladd(m8, SECP256K1_N_C_1);
 431     extract(p1);
 432     sumadd(m2);
 433     muladd(m10, SECP256K1_N_C_0);
 434     muladd(m9, SECP256K1_N_C_1);
 435     muladd(m8, SECP256K1_N_C_2);
 436     extract(p2);
 437     sumadd(m3);
 438     muladd(m11, SECP256K1_N_C_0);
 439     muladd(m10, SECP256K1_N_C_1);
 440     muladd(m9, SECP256K1_N_C_2);
 441     muladd(m8, SECP256K1_N_C_3);
 442     extract(p3);
 443     sumadd(m4);
 444     muladd(m12, SECP256K1_N_C_0);
 445     muladd(m11, SECP256K1_N_C_1);
 446     muladd(m10, SECP256K1_N_C_2);
 447     muladd(m9, SECP256K1_N_C_3);
 448     sumadd(m8);
 449     extract(p4);
 450     sumadd(m5);
 451     muladd(m12, SECP256K1_N_C_1);
 452     muladd(m11, SECP256K1_N_C_2);
 453     muladd(m10, SECP256K1_N_C_3);
 454     sumadd(m9);
 455     extract(p5);
 456     sumadd(m6);
 457     muladd(m12, SECP256K1_N_C_2);
 458     muladd(m11, SECP256K1_N_C_3);
 459     sumadd(m10);
 460     extract(p6);
 461     sumadd_fast(m7);
 462     muladd_fast(m12, SECP256K1_N_C_3);
 463     sumadd_fast(m11);
 464     extract_fast(p7);
 465     p8 = c0 + m12;
 466     VERIFY_CHECK(p8 <= 2);
 467
 468     /* Reduce 258 bits into 256. */
 469     /* r[0..7] = p[0..7] + p[8] * SECP256K1_N_C. */
 470     c = p0 + (uint64_t)SECP256K1_N_C_0 * p8;
 471     r->d[0] = c & 0xFFFFFFFFUL; c >>= 32;
 472     c += p1 + (uint64_t)SECP256K1_N_C_1 * p8;
 473     r->d[1] = c & 0xFFFFFFFFUL; c >>= 32;
 474     c += p2 + (uint64_t)SECP256K1_N_C_2 * p8;
 475     r->d[2] = c & 0xFFFFFFFFUL; c >>= 32;
 476     c += p3 + (uint64_t)SECP256K1_N_C_3 * p8;
 477     r->d[3] = c & 0xFFFFFFFFUL; c >>= 32;
 478     c += p4 + (uint64_t)p8;
 479     r->d[4] = c & 0xFFFFFFFFUL; c >>= 32;
 480     c += p5;
 481     r->d[5] = c & 0xFFFFFFFFUL; c >>= 32;
 482     c += p6;
 483     r->d[6] = c & 0xFFFFFFFFUL; c >>= 32;
 484     c += p7;
 485     r->d[7] = c & 0xFFFFFFFFUL; c >>= 32;
 486
 487     /* Final reduction of r. */
 488     secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
 489 }
 490
 491 static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar *a, const secp256k1_scalar *b) {
 492     /* 96 bit accumulator. */
 493     uint32_t c0 = 0, c1 = 0, c2 = 0;
 494
 495     /* l[0..15] = a[0..7] * b[0..7]. */
 496     muladd_fast(a->d[0], b->d[0]);
 497     extract_fast(l[0]);
 498     muladd(a->d[0], b->d[1]);
 499     muladd(a->d[1], b->d[0]);
 500     extract(l[1]);
 501     muladd(a->d[0], b->d[2]);
 502     muladd(a->d[1], b->d[1]);
 503     muladd(a->d[2], b->d[0]);
 504     extract(l[2]);
 505     muladd(a->d[0], b->d[3]);
 506     muladd(a->d[1], b->d[2]);
 507     muladd(a->d[2], b->d[1]);
 508     muladd(a->d[3], b->d[0]);
 509     extract(l[3]);
 510     muladd(a->d[0], b->d[4]);
 511     muladd(a->d[1], b->d[3]);
 512     muladd(a->d[2], b->d[2]);
 513     muladd(a->d[3], b->d[1]);
 514     muladd(a->d[4], b->d[0]);
 515     extract(l[4]);
 516     muladd(a->d[0], b->d[5]);
 517     muladd(a->d[1], b->d[4]);
 518     muladd(a->d[2], b->d[3]);
 519     muladd(a->d[3], b->d[2]);
 520     muladd(a->d[4], b->d[1]);
 521     muladd(a->d[5], b->d[0]);
 522     extract(l[5]);
 523     muladd(a->d[0], b->d[6]);
 524     muladd(a->d[1], b->d[5]);
 525     muladd(a->d[2], b->d[4]);
 526     muladd(a->d[3], b->d[3]);
 527     muladd(a->d[4], b->d[2]);
 528     muladd(a->d[5], b->d[1]);
 529     muladd(a->d[6], b->d[0]);
 530     extract(l[6]);
 531     muladd(a->d[0], b->d[7]);
 532     muladd(a->d[1], b->d[6]);
 533     muladd(a->d[2], b->d[5]);
 534     muladd(a->d[3], b->d[4]);
 535     muladd(a->d[4], b->d[3]);
 536     muladd(a->d[5], b->d[2]);
 537     muladd(a->d[6], b->d[1]);
 538     muladd(a->d[7], b->d[0]);
 539     extract(l[7]);
 540     muladd(a->d[1], b->d[7]);
 541     muladd(a->d[2], b->d[6]);
 542     muladd(a->d[3], b->d[5]);
 543     muladd(a->d[4], b->d[4]);
 544     muladd(a->d[5], b->d[3]);
 545     muladd(a->d[6], b->d[2]);
 546     muladd(a->d[7], b->d[1]);
 547     extract(l[8]);
 548     muladd(a->d[2], b->d[7]);
 549     muladd(a->d[3], b->d[6]);
 550     muladd(a->d[4], b->d[5]);
 551     muladd(a->d[5], b->d[4]);
 552     muladd(a->d[6], b->d[3]);
 553     muladd(a->d[7], b->d[2]);
 554     extract(l[9]);
 555     muladd(a->d[3], b->d[7]);
 556     muladd(a->d[4], b->d[6]);
 557     muladd(a->d[5], b->d[5]);
 558     muladd(a->d[6], b->d[4]);
 559     muladd(a->d[7], b->d[3]);
 560     extract(l[10]);
 561     muladd(a->d[4], b->d[7]);
 562     muladd(a->d[5], b->d[6]);
 563     muladd(a->d[6], b->d[5]);
 564     muladd(a->d[7], b->d[4]);
 565     extract(l[11]);
 566     muladd(a->d[5], b->d[7]);
 567     muladd(a->d[6], b->d[6]);
 568     muladd(a->d[7], b->d[5]);
 569     extract(l[12]);
 570     muladd(a->d[6], b->d[7]);
 571     muladd(a->d[7], b->d[6]);
 572     extract(l[13]);
 573     muladd_fast(a->d[7], b->d[7]);
 574     extract_fast(l[14]);
 575     VERIFY_CHECK(c1 == 0);
 576     l[15] = c0;
 577 }
 578
 579 static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar *a) {
 580     /* 96 bit accumulator. */
 581     uint32_t c0 = 0, c1 = 0, c2 = 0;
 582
 583     /* l[0..15] = a[0..7]^2. */
 584     muladd_fast(a->d[0], a->d[0]);
 585     extract_fast(l[0]);
 586     muladd2(a->d[0], a->d[1]);
 587     extract(l[1]);
 588     muladd2(a->d[0], a->d[2]);
 589     muladd(a->d[1], a->d[1]);
 590     extract(l[2]);
 591     muladd2(a->d[0], a->d[3]);
 592     muladd2(a->d[1], a->d[2]);
 593     extract(l[3]);
 594     muladd2(a->d[0], a->d[4]);
 595     muladd2(a->d[1], a->d[3]);
 596     muladd(a->d[2], a->d[2]);
 597     extract(l[4]);
 598     muladd2(a->d[0], a->d[5]);
 599     muladd2(a->d[1], a->d[4]);
 600     muladd2(a->d[2], a->d[3]);
 601     extract(l[5]);
 602     muladd2(a->d[0], a->d[6]);
 603     muladd2(a->d[1], a->d[5]);
 604     muladd2(a->d[2], a->d[4]);
 605     muladd(a->d[3], a->d[3]);
 606     extract(l[6]);
 607     muladd2(a->d[0], a->d[7]);
 608     muladd2(a->d[1], a->d[6]);
 609     muladd2(a->d[2], a->d[5]);
 610     muladd2(a->d[3], a->d[4]);
 611     extract(l[7]);
 612     muladd2(a->d[1], a->d[7]);
 613     muladd2(a->d[2], a->d[6]);
 614     muladd2(a->d[3], a->d[5]);
 615     muladd(a->d[4], a->d[4]);
 616     extract(l[8]);
 617     muladd2(a->d[2], a->d[7]);
 618     muladd2(a->d[3], a->d[6]);
 619     muladd2(a->d[4], a->d[5]);
 620     extract(l[9]);
 621     muladd2(a->d[3], a->d[7]);
 622     muladd2(a->d[4], a->d[6]);
 623     muladd(a->d[5], a->d[5]);
 624     extract(l[10]);
 625     muladd2(a->d[4], a->d[7]);
 626     muladd2(a->d[5], a->d[6]);
 627     extract(l[11]);
 628     muladd2(a->d[5], a->d[7]);
 629     muladd(a->d[6], a->d[6]);
 630     extract(l[12]);
 631     muladd2(a->d[6], a->d[7]);
 632     extract(l[13]);
 633     muladd_fast(a->d[7], a->d[7]);
 634     extract_fast(l[14]);
 635     VERIFY_CHECK(c1 == 0);
 636     l[15] = c0;
 637 }
 638
 639 #undef sumadd
 640 #undef sumadd_fast
 641 #undef muladd
 642 #undef muladd_fast
 643 #undef muladd2
 644 #undef extract
 645 #undef extract_fast
 646
 647 static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
 648     uint32_t l[16];
 649     secp256k1_scalar_mul_512(l, a, b);
 650     secp256k1_scalar_reduce_512(r, l);
 651 }
 652
 653 static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
 654     int ret;
 655     VERIFY_CHECK(n > 0);
 656     VERIFY_CHECK(n < 16);
 657     ret = r->d[0] & ((1 << n) - 1);
 658     r->d[0] = (r->d[0] >> n) + (r->d[1] << (32 - n));
 659     r->d[1] = (r->d[1] >> n) + (r->d[2] << (32 - n));
 660     r->d[2] = (r->d[2] >> n) + (r->d[3] << (32 - n));
 661     r->d[3] = (r->d[3] >> n) + (r->d[4] << (32 - n));
 662     r->d[4] = (r->d[4] >> n) + (r->d[5] << (32 - n));
 663     r->d[5] = (r->d[5] >> n) + (r->d[6] << (32 - n));
 664     r->d[6] = (r->d[6] >> n) + (r->d[7] << (32 - n));
 665     r->d[7] = (r->d[7] >> n);
 666     return ret;
 667 }
 668
 669 static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
 670     uint32_t l[16];
 671     secp256k1_scalar_sqr_512(l, a);
 672     secp256k1_scalar_reduce_512(r, l);
 673 }
 674
 675 #ifdef USE_ENDOMORPHISM
 676 static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *k) {
 677     r1->d[0] = k->d[0];
 678     r1->d[1] = k->d[1];
 679     r1->d[2] = k->d[2];
 680     r1->d[3] = k->d[3];
 681     r1->d[4] = 0;
 682     r1->d[5] = 0;
 683     r1->d[6] = 0;
 684     r1->d[7] = 0;
 685     r2->d[0] = k->d[4];
 686     r2->d[1] = k->d[5];
 687     r2->d[2] = k->d[6];
 688     r2->d[3] = k->d[7];
 689     r2->d[4] = 0;
 690     r2->d[5] = 0;
 691     r2->d[6] = 0;
 692     r2->d[7] = 0;
 693 }
 694 #endif
 695
 696 SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
 697     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;
 698 }
 699
 700 SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift) {
 701     uint32_t l[16];
 702     unsigned int shiftlimbs;
 703     unsigned int shiftlow;
 704     unsigned int shifthigh;
 705     VERIFY_CHECK(shift >= 256);
 706     secp256k1_scalar_mul_512(l, a, b);
 707     shiftlimbs = shift >> 5;
 708     shiftlow = shift & 0x1F;
 709     shifthigh = 32 - shiftlow;
 710     r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 480 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
 711     r->d[1] = shift < 480 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
 712     r->d[2] = shift < 448 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 416 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
 713     r->d[3] = shift < 416 ? (l[3 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[4 + shiftlimbs] << shifthigh) : 0)) : 0;
 714     r->d[4] = shift < 384 ? (l[4 + shiftlimbs] >> shiftlow | (shift < 352 && shiftlow ? (l[5 + shiftlimbs] << shifthigh) : 0)) : 0;
 715     r->d[5] = shift < 352 ? (l[5 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[6 + shiftlimbs] << shifthigh) : 0)) : 0;
 716     r->d[6] = shift < 320 ? (l[6 + shiftlimbs] >> shiftlow | (shift < 288 && shiftlow ? (l[7 + shiftlimbs] << shifthigh) : 0)) : 0;
 717     r->d[7] = shift < 288 ? (l[7 + shiftlimbs] >> shiftlow)  : 0;
 718     secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1);
 719 }
 720
 721 static SECP256K1_INLINE void secp256k1_scalar_cmov(secp256k1_scalar *r, const secp256k1_scalar *a, int flag) {
 722     uint32_t mask0, mask1;
 723     VG_CHECK_VERIFY(r->d, sizeof(r->d));
 724     mask0 = flag + ~((uint32_t)0);
 725     mask1 = ~mask0;
 726     r->d[0] = (r->d[0] & mask0) | (a->d[0] & mask1);
 727     r->d[1] = (r->d[1] & mask0) | (a->d[1] & mask1);
 728     r->d[2] = (r->d[2] & mask0) | (a->d[2] & mask1);
 729     r->d[3] = (r->d[3] & mask0) | (a->d[3] & mask1);
 730     r->d[4] = (r->d[4] & mask0) | (a->d[4] & mask1);
 731     r->d[5] = (r->d[5] & mask0) | (a->d[5] & mask1);
 732     r->d[6] = (r->d[6] & mask0) | (a->d[6] & mask1);
 733     r->d[7] = (r->d[7] & mask0) | (a->d[7] & mask1);
 734 }
 735
 736 #endif /* SECP256K1_SCALAR_REPR_IMPL_H */