Rename decaf_448_* to curve448_*
[openssl.git] / crypto / ec / curve448 / scalar.c
1 /**
2  * @file ed448goldilocks/scalar.c
3  * @author Mike Hamburg
4  *
5  * @copyright
6  *   Copyright (c) 2015-2016 Cryptography Research, Inc.  \n
7  *   Released under the MIT License.  See LICENSE.txt for license information.
8  *
9  * @brief Decaf high-level functions.
10  *
11  * @warning This file was automatically generated in Python.
12  * Please do not edit it.
13  */
14 #include <openssl/crypto.h>
15
16 #include "word.h"
17 #include "constant_time.h"
18 #include "point_448.h"
19
20 /* Template stuff */
21 #define SCALAR_BITS DECAF_448_SCALAR_BITS
22 #define SCALAR_SER_BYTES DECAF_448_SCALAR_BYTES
23 #define SCALAR_LIMBS DECAF_448_SCALAR_LIMBS
24 #define scalar_t curve448_scalar_t
25
26 static const decaf_word_t MONTGOMERY_FACTOR = (decaf_word_t)0x3bd440fae918bc5ull;
27 static const scalar_t sc_p = {{{
28     SC_LIMB(0x2378c292ab5844f3), SC_LIMB(0x216cc2728dc58f55), SC_LIMB(0xc44edb49aed63690), SC_LIMB(0xffffffff7cca23e9), SC_LIMB(0xffffffffffffffff), SC_LIMB(0xffffffffffffffff), SC_LIMB(0x3fffffffffffffff)
29 }}}, sc_r2 = {{{
30     SC_LIMB(0xe3539257049b9b60), SC_LIMB(0x7af32c4bc1b195d9), SC_LIMB(0x0d66de2388ea1859), SC_LIMB(0xae17cf725ee4d838), SC_LIMB(0x1a9cc14ba3c47c44), SC_LIMB(0x2052bcb7e4d070af), SC_LIMB(0x3402a939f823b729)
31 }}};
32 /* End of template stuff */
33
34 #define WBITS DECAF_WORD_BITS /* NB this may be different from ARCH_WORD_BITS */
35
36 const scalar_t curve448_scalar_one = {{{1}}}, curve448_scalar_zero = {{{0}}};
37
38 /** {extra,accum} - sub +? p
39  * Must have extra <= 1
40  */
41 static DECAF_NOINLINE void sc_subx(
42     scalar_t out,
43     const decaf_word_t accum[SCALAR_LIMBS],
44     const scalar_t sub,
45     const scalar_t p,
46     decaf_word_t extra
47 ) {
48     decaf_dsword_t chain = 0;
49     unsigned int i;
50     for (i=0; i<SCALAR_LIMBS; i++) {
51         chain = (chain + accum[i]) - sub->limb[i];
52         out->limb[i] = chain;
53         chain >>= WBITS;
54     }
55     decaf_word_t borrow = chain+extra; /* = 0 or -1 */
56     
57     chain = 0;
58     for (i=0; i<SCALAR_LIMBS; i++) {
59         chain = (chain + out->limb[i]) + (p->limb[i] & borrow);
60         out->limb[i] = chain;
61         chain >>= WBITS;
62     }
63 }
64
65 static DECAF_NOINLINE void sc_montmul (
66     scalar_t out,
67     const scalar_t a,
68     const scalar_t b
69 ) {
70     unsigned int i,j;
71     decaf_word_t accum[SCALAR_LIMBS+1] = {0};
72     decaf_word_t hi_carry = 0;
73     
74     for (i=0; i<SCALAR_LIMBS; i++) {
75         decaf_word_t mand = a->limb[i];
76         const decaf_word_t *mier = b->limb;
77         
78         decaf_dword_t chain = 0;
79         for (j=0; j<SCALAR_LIMBS; j++) {
80             chain += ((decaf_dword_t)mand)*mier[j] + accum[j];
81             accum[j] = chain;
82             chain >>= WBITS;
83         }
84         accum[j] = chain;
85         
86         mand = accum[0] * MONTGOMERY_FACTOR;
87         chain = 0;
88         mier = sc_p->limb;
89         for (j=0; j<SCALAR_LIMBS; j++) {
90             chain += (decaf_dword_t)mand*mier[j] + accum[j];
91             if (j) accum[j-1] = chain;
92             chain >>= WBITS;
93         }
94         chain += accum[j];
95         chain += hi_carry;
96         accum[j-1] = chain;
97         hi_carry = chain >> WBITS;
98     }
99     
100     sc_subx(out, accum, sc_p, sc_p, hi_carry);
101 }
102
103 void curve448_scalar_mul (
104     scalar_t out,
105     const scalar_t a,
106     const scalar_t b
107 ) {
108     sc_montmul(out,a,b);
109     sc_montmul(out,out,sc_r2);
110 }
111
112 void curve448_scalar_sub (
113     scalar_t out,
114     const scalar_t a,
115     const scalar_t b
116 ) {
117     sc_subx(out, a->limb, b, sc_p, 0);
118 }
119
120 void curve448_scalar_add (
121     scalar_t out,
122     const scalar_t a,
123     const scalar_t b
124 ) {
125     decaf_dword_t chain = 0;
126     unsigned int i;
127     for (i=0; i<SCALAR_LIMBS; i++) {
128         chain = (chain + a->limb[i]) + b->limb[i];
129         out->limb[i] = chain;
130         chain >>= WBITS;
131     }
132     sc_subx(out, out->limb, sc_p, sc_p, chain);
133 }
134
135 static DECAF_INLINE void scalar_decode_short (
136     scalar_t s,
137     const unsigned char *ser,
138     unsigned int nbytes
139 ) {
140     unsigned int i,j,k=0;
141     for (i=0; i<SCALAR_LIMBS; i++) {
142         decaf_word_t out = 0;
143         for (j=0; j<sizeof(decaf_word_t) && k<nbytes; j++,k++) {
144             out |= ((decaf_word_t)ser[k])<<(8*j);
145         }
146         s->limb[i] = out;
147     }
148 }
149
150 decaf_error_t curve448_scalar_decode(
151     scalar_t s,
152     const unsigned char ser[SCALAR_SER_BYTES]
153 ) {
154     unsigned int i;
155     scalar_decode_short(s, ser, SCALAR_SER_BYTES);
156     decaf_dsword_t accum = 0;
157     for (i=0; i<SCALAR_LIMBS; i++) {
158         accum = (accum + s->limb[i] - sc_p->limb[i]) >> WBITS;
159     }
160     /* Here accum == 0 or -1 */
161     
162     curve448_scalar_mul(s,s,curve448_scalar_one); /* ham-handed reduce */
163     
164     return decaf_succeed_if(~word_is_zero(accum));
165 }
166
167 void curve448_scalar_destroy (
168     scalar_t scalar
169 ) {
170     OPENSSL_cleanse(scalar, sizeof(scalar_t));
171 }
172
173 void curve448_scalar_decode_long(
174     scalar_t s,
175     const unsigned char *ser,
176     size_t ser_len
177 ) {
178     if (ser_len == 0) {
179         curve448_scalar_copy(s, curve448_scalar_zero);
180         return;
181     }
182     
183     size_t i;
184     scalar_t t1, t2;
185
186     i = ser_len - (ser_len%SCALAR_SER_BYTES);
187     if (i==ser_len) i -= SCALAR_SER_BYTES;
188     
189     scalar_decode_short(t1, &ser[i], ser_len-i);
190
191     if (ser_len == sizeof(scalar_t)) {
192         assert(i==0);
193         /* ham-handed reduce */
194         curve448_scalar_mul(s,t1,curve448_scalar_one);
195         curve448_scalar_destroy(t1);
196         return;
197     }
198
199     while (i) {
200         i -= SCALAR_SER_BYTES;
201         sc_montmul(t1,t1,sc_r2);
202         ignore_result( curve448_scalar_decode(t2, ser+i) );
203         curve448_scalar_add(t1, t1, t2);
204     }
205
206     curve448_scalar_copy(s, t1);
207     curve448_scalar_destroy(t1);
208     curve448_scalar_destroy(t2);
209 }
210
211 void curve448_scalar_encode(
212     unsigned char ser[SCALAR_SER_BYTES],
213     const scalar_t s
214 ) {
215     unsigned int i,j,k=0;
216     for (i=0; i<SCALAR_LIMBS; i++) {
217         for (j=0; j<sizeof(decaf_word_t); j++,k++) {
218             ser[k] = s->limb[i] >> (8*j);
219         }
220     }
221 }
222
223 void curve448_scalar_halve (
224     scalar_t out,
225     const scalar_t a
226 ) {
227     decaf_word_t mask = -(a->limb[0] & 1);
228     decaf_dword_t chain = 0;
229     unsigned int i;
230     for (i=0; i<SCALAR_LIMBS; i++) {
231         chain = (chain + a->limb[i]) + (sc_p->limb[i] & mask);
232         out->limb[i] = chain;
233         chain >>= DECAF_WORD_BITS;
234     }
235     for (i=0; i<SCALAR_LIMBS-1; i++) {
236         out->limb[i] = out->limb[i]>>1 | out->limb[i+1]<<(WBITS-1);
237     }
238     out->limb[i] = out->limb[i]>>1 | chain<<(WBITS-1);
239 }
240