Convert to C90 from C99
[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 static const decaf_word_t MONTGOMERY_FACTOR = (decaf_word_t)0x3bd440fae918bc5;
21 static const curve448_scalar_t sc_p = {{{
22     SC_LIMB(0x2378c292ab5844f3), SC_LIMB(0x216cc2728dc58f55), SC_LIMB(0xc44edb49aed63690), SC_LIMB(0xffffffff7cca23e9), SC_LIMB(0xffffffffffffffff), SC_LIMB(0xffffffffffffffff), SC_LIMB(0x3fffffffffffffff)
23 }}}, sc_r2 = {{{
24     SC_LIMB(0xe3539257049b9b60), SC_LIMB(0x7af32c4bc1b195d9), SC_LIMB(0x0d66de2388ea1859), SC_LIMB(0xae17cf725ee4d838), SC_LIMB(0x1a9cc14ba3c47c44), SC_LIMB(0x2052bcb7e4d070af), SC_LIMB(0x3402a939f823b729)
25 }}};
26 /* End of template stuff */
27
28 #define WBITS DECAF_WORD_BITS /* NB this may be different from ARCH_WORD_BITS */
29
30 const curve448_scalar_t curve448_scalar_one = {{{1}}}, curve448_scalar_zero = {{{0}}};
31
32 /** {extra,accum} - sub +? p
33  * Must have extra <= 1
34  */
35 static void sc_subx(
36     curve448_scalar_t out,
37     const decaf_word_t accum[DECAF_448_SCALAR_LIMBS],
38     const curve448_scalar_t sub,
39     const curve448_scalar_t p,
40     decaf_word_t extra
41 ) {
42     decaf_dsword_t chain = 0;
43     unsigned int i;
44     decaf_word_t borrow;
45
46     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
47         chain = (chain + accum[i]) - sub->limb[i];
48         out->limb[i] = chain;
49         chain >>= WBITS;
50     }
51     borrow = chain+extra; /* = 0 or -1 */
52     
53     chain = 0;
54     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
55         chain = (chain + out->limb[i]) + (p->limb[i] & borrow);
56         out->limb[i] = chain;
57         chain >>= WBITS;
58     }
59 }
60
61 static void sc_montmul (
62     curve448_scalar_t out,
63     const curve448_scalar_t a,
64     const curve448_scalar_t b
65 ) {
66     unsigned int i,j;
67     decaf_word_t accum[DECAF_448_SCALAR_LIMBS+1] = {0};
68     decaf_word_t hi_carry = 0;
69     
70     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
71         decaf_word_t mand = a->limb[i];
72         const decaf_word_t *mier = b->limb;
73         
74         decaf_dword_t chain = 0;
75         for (j=0; j<DECAF_448_SCALAR_LIMBS; j++) {
76             chain += ((decaf_dword_t)mand)*mier[j] + accum[j];
77             accum[j] = chain;
78             chain >>= WBITS;
79         }
80         accum[j] = chain;
81         
82         mand = accum[0] * MONTGOMERY_FACTOR;
83         chain = 0;
84         mier = sc_p->limb;
85         for (j=0; j<DECAF_448_SCALAR_LIMBS; j++) {
86             chain += (decaf_dword_t)mand*mier[j] + accum[j];
87             if (j) accum[j-1] = chain;
88             chain >>= WBITS;
89         }
90         chain += accum[j];
91         chain += hi_carry;
92         accum[j-1] = chain;
93         hi_carry = chain >> WBITS;
94     }
95     
96     sc_subx(out, accum, sc_p, sc_p, hi_carry);
97 }
98
99 void curve448_scalar_mul (
100     curve448_scalar_t out,
101     const curve448_scalar_t a,
102     const curve448_scalar_t b
103 ) {
104     sc_montmul(out,a,b);
105     sc_montmul(out,out,sc_r2);
106 }
107
108 void curve448_scalar_sub (
109     curve448_scalar_t out,
110     const curve448_scalar_t a,
111     const curve448_scalar_t b
112 ) {
113     sc_subx(out, a->limb, b, sc_p, 0);
114 }
115
116 void curve448_scalar_add (
117     curve448_scalar_t out,
118     const curve448_scalar_t a,
119     const curve448_scalar_t b
120 ) {
121     decaf_dword_t chain = 0;
122     unsigned int i;
123     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
124         chain = (chain + a->limb[i]) + b->limb[i];
125         out->limb[i] = chain;
126         chain >>= WBITS;
127     }
128     sc_subx(out, out->limb, sc_p, sc_p, chain);
129 }
130
131 static ossl_inline void scalar_decode_short (
132     curve448_scalar_t s,
133     const unsigned char *ser,
134     unsigned int nbytes
135 ) {
136     unsigned int i,j,k=0;
137     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
138         decaf_word_t out = 0;
139         for (j=0; j<sizeof(decaf_word_t) && k<nbytes; j++,k++) {
140             out |= ((decaf_word_t)ser[k])<<(8*j);
141         }
142         s->limb[i] = out;
143     }
144 }
145
146 decaf_error_t curve448_scalar_decode(
147     curve448_scalar_t s,
148     const unsigned char ser[DECAF_448_SCALAR_BYTES]
149 ) {
150     unsigned int i;
151     decaf_dsword_t accum = 0;
152
153     scalar_decode_short(s, ser, DECAF_448_SCALAR_BYTES);
154     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
155         accum = (accum + s->limb[i] - sc_p->limb[i]) >> WBITS;
156     }
157     /* Here accum == 0 or -1 */
158     
159     curve448_scalar_mul(s,s,curve448_scalar_one); /* ham-handed reduce */
160     
161     return decaf_succeed_if(~word_is_zero(accum));
162 }
163
164 void curve448_scalar_destroy (
165     curve448_scalar_t scalar
166 ) {
167     OPENSSL_cleanse(scalar, sizeof(curve448_scalar_t));
168 }
169
170 void curve448_scalar_decode_long(
171     curve448_scalar_t s,
172     const unsigned char *ser,
173     size_t ser_len
174 ) {
175     size_t i;
176     curve448_scalar_t t1, t2;
177
178     if (ser_len == 0) {
179         curve448_scalar_copy(s, curve448_scalar_zero);
180         return;
181     }
182
183     i = ser_len - (ser_len%DECAF_448_SCALAR_BYTES);
184     if (i==ser_len) i -= DECAF_448_SCALAR_BYTES;
185     
186     scalar_decode_short(t1, &ser[i], ser_len-i);
187
188     if (ser_len == sizeof(curve448_scalar_t)) {
189         assert(i==0);
190         /* ham-handed reduce */
191         curve448_scalar_mul(s,t1,curve448_scalar_one);
192         curve448_scalar_destroy(t1);
193         return;
194     }
195
196     while (i) {
197         i -= DECAF_448_SCALAR_BYTES;
198         sc_montmul(t1,t1,sc_r2);
199         ignore_result( curve448_scalar_decode(t2, ser+i) );
200         curve448_scalar_add(t1, t1, t2);
201     }
202
203     curve448_scalar_copy(s, t1);
204     curve448_scalar_destroy(t1);
205     curve448_scalar_destroy(t2);
206 }
207
208 void curve448_scalar_encode(
209     unsigned char ser[DECAF_448_SCALAR_BYTES],
210     const curve448_scalar_t s
211 ) {
212     unsigned int i,j,k=0;
213     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
214         for (j=0; j<sizeof(decaf_word_t); j++,k++) {
215             ser[k] = s->limb[i] >> (8*j);
216         }
217     }
218 }
219
220 void curve448_scalar_halve (
221     curve448_scalar_t out,
222     const curve448_scalar_t a
223 ) {
224     decaf_word_t mask = -(a->limb[0] & 1);
225     decaf_dword_t chain = 0;
226     unsigned int i;
227     for (i=0; i<DECAF_448_SCALAR_LIMBS; i++) {
228         chain = (chain + a->limb[i]) + (sc_p->limb[i] & mask);
229         out->limb[i] = chain;
230         chain >>= DECAF_WORD_BITS;
231     }
232     for (i=0; i<DECAF_448_SCALAR_LIMBS-1; i++) {
233         out->limb[i] = out->limb[i]>>1 | out->limb[i+1]<<(WBITS-1);
234     }
235     out->limb[i] = out->limb[i]>>1 | chain<<(WBITS-1);
236 }
237