OLD | NEW |
1 /* This Source Code Form is subject to the terms of the Mozilla Public | 1 /* This Source Code Form is subject to the terms of the Mozilla Public |
2 * License, v. 2.0. If a copy of the MPL was not distributed with this | 2 * License, v. 2.0. If a copy of the MPL was not distributed with this |
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
4 | 4 |
5 #include "ecp_fp.h" | 5 #include "ecp_fp.h" |
6 #include "mpprime.h" | 6 #include "mpprime.h" |
7 | 7 |
8 #include <stdio.h> | 8 #include <stdio.h> |
9 #include <time.h> | 9 #include <time.h> |
10 #include <sys/time.h> | 10 #include <sys/time.h> |
11 #include <sys/resource.h> | 11 #include <sys/resource.h> |
12 | 12 |
13 /* Time k repetitions of operation op. */ | 13 /* Time k repetitions of operation op. */ |
14 #define M_TimeOperation(op, k) { \ | 14 #define M_TimeOperation(op, k) \ |
15 double dStart, dNow, dUserTime; \ | 15 { \ |
16 struct rusage ru; \ | 16 double dStart, dNow, dUserTime; \ |
17 int i; \ | 17 struct rusage ru; \ |
18 getrusage(RUSAGE_SELF, &ru); \ | 18 int i; \ |
19 dStart = (double)ru.ru_utime.tv_sec+(double)ru.ru_utime.tv_usec*0.000001; \ | 19 getrusage(RUSAGE_SELF, &ru); \ |
20 for (i = 0; i < k; i++) { \ | 20 dStart = \ |
21 { op; } \ | 21 (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec * 0.000001; \ |
22 }; \ | 22 for (i = 0; i < k; i++) { \ |
23 getrusage(RUSAGE_SELF, &ru); \ | 23 { op; } \ |
24 dNow = (double)ru.ru_utime.tv_sec+(double)ru.ru_utime.tv_usec*0.000001; \ | 24 }; \ |
25 dUserTime = dNow-dStart; \ | 25 getrusage(RUSAGE_SELF, &ru); \ |
26 if (dUserTime) printf(" %-45s\n k: %6i, t: %6.2f sec, k/t: %6.2f ops/s
ec\n", #op, k, dUserTime, k/dUserTime); \ | 26 dNow = \ |
27 } | 27 (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec * 0.000001; \ |
| 28 dUserTime = dNow - dStart; \ |
| 29 if (dUserTime) \ |
| 30 printf(" %-45s\n k: %6i, t: %6.2f sec, k/t: %6.2f ops/sec\n", \ |
| 31 #op, k, dUserTime, k / dUserTime); \ |
| 32 } |
28 | 33 |
29 /* Test curve using specific floating point field arithmetic. */ | 34 /* Test curve using specific floating point field arithmetic. */ |
30 #define M_TestCurve(name_c, name) { \ | 35 #define M_TestCurve(name_c, name) \ |
31 printf("Testing %s using specific floating point implementation...\n", name_c)
; \ | 36 { \ |
32 ECGroup_free(ecgroup); \ | 37 printf("Testing %s using specific floating point implementation...\n", \ |
33 ecgroup = ECGroup_fromName(name); \ | 38 name_c); \ |
34 if (ecgroup == NULL) { \ | 39 ECGroup_free(ecgroup); \ |
35 printf(" Warning: could not construct group.\n"); \ | 40 ecgroup = ECGroup_fromName(name); \ |
36 printf("%s failed.\n", name_c); \ | 41 if (ecgroup == NULL) { \ |
37 res = MP_NO; \ | 42 printf(" Warning: could not construct group.\n"); \ |
38 goto CLEANUP; \ | 43 printf("%s failed.\n", name_c); \ |
39 } else { \ | 44 res = MP_NO; \ |
40 MP_CHECKOK( testCurve(ecgroup)); \ | 45 goto CLEANUP; \ |
41 printf("%s passed.\n", name_c); \ | 46 } else { \ |
42 } \ | 47 MP_CHECKOK(testCurve(ecgroup)); \ |
43 } | 48 printf("%s passed.\n", name_c); \ |
| 49 } \ |
| 50 } |
44 | 51 |
45 /* Outputs a floating point double (currently not used) */ | 52 /* Outputs a floating point double (currently not used) */ |
46 void | 53 void d_output(const double *u, int len, char *name, const EC_group_fp *group) { |
47 d_output(const double *u, int len, char *name, const EC_group_fp * group) | 54 int i; |
48 { | 55 |
49 » int i; | 56 printf("%s: ", name); |
50 | 57 for (i = 0; i < len; i++) { |
51 » printf("%s: ", name); | 58 printf("+ %.2f * 2^%i ", u[i] / ecfp_exp[i], group->doubleBitSize * i); |
52 » for (i = 0; i < len; i++) { | 59 } |
53 » » printf("+ %.2f * 2^%i ", u[i] / ecfp_exp[i], | 60 printf("\n"); |
54 » » » group->doubleBitSize * i); | |
55 » } | |
56 » printf("\n"); | |
57 } | 61 } |
58 | 62 |
59 /* Tests a point p in Jacobian coordinates, comparing against the | 63 /* Tests a point p in Jacobian coordinates, comparing against the |
60 * expected affine result (x, y). */ | 64 * expected affine result (x, y). */ |
61 mp_err | 65 mp_err testJacPoint(ecfp_jac_pt *p, mp_int *x, mp_int *y, ECGroup *ecgroup) { |
62 testJacPoint(ecfp_jac_pt * p, mp_int *x, mp_int *y, ECGroup *ecgroup) | 66 char s[1000]; |
63 { | 67 mp_int rx, ry, rz; |
64 » char s[1000]; | 68 mp_err res = MP_OKAY; |
65 » mp_int rx, ry, rz; | 69 |
66 » mp_err res = MP_OKAY; | 70 MP_DIGITS(&rx) = 0; |
67 | 71 MP_DIGITS(&ry) = 0; |
68 » MP_DIGITS(&rx) = 0; | 72 MP_DIGITS(&rz) = 0; |
69 » MP_DIGITS(&ry) = 0; | 73 |
70 » MP_DIGITS(&rz) = 0; | 74 MP_CHECKOK(mp_init(&rx)); |
71 | 75 MP_CHECKOK(mp_init(&ry)); |
72 » MP_CHECKOK(mp_init(&rx)); | 76 MP_CHECKOK(mp_init(&rz)); |
73 » MP_CHECKOK(mp_init(&ry)); | 77 |
74 » MP_CHECKOK(mp_init(&rz)); | 78 ecfp_fp2i(&rx, p->x, ecgroup); |
75 | 79 ecfp_fp2i(&ry, p->y, ecgroup); |
76 » ecfp_fp2i(&rx, p->x, ecgroup); | 80 ecfp_fp2i(&rz, p->z, ecgroup); |
77 » ecfp_fp2i(&ry, p->y, ecgroup); | 81 |
78 » ecfp_fp2i(&rz, p->z, ecgroup); | 82 /* convert result R to affine coordinates */ |
79 | 83 ec_GFp_pt_jac2aff(&rx, &ry, &rz, &rx, &ry, ecgroup); |
80 » /* convert result R to affine coordinates */ | 84 |
81 » ec_GFp_pt_jac2aff(&rx, &ry, &rz, &rx, &ry, ecgroup); | 85 /* Compare to expected result */ |
82 | 86 if ((mp_cmp(&rx, x) != 0) || (mp_cmp(&ry, y) != 0)) { |
83 » /* Compare to expected result */ | 87 printf(" Error: Jacobian Floating Point Incorrect.\n"); |
84 » if ((mp_cmp(&rx, x) != 0) || (mp_cmp(&ry, y) != 0)) { | 88 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
85 » » printf(" Error: Jacobian Floating Point Incorrect.\n"); | 89 printf("floating point result\nrx %s\n", s); |
86 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 90 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
87 » » printf("floating point result\nrx %s\n", s); | 91 printf("ry %s\n", s); |
88 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 92 MP_CHECKOK(mp_toradix(x, s, 16)); |
89 » » printf("ry %s\n", s); | 93 printf("integer result\nx %s\n", s); |
90 » » MP_CHECKOK(mp_toradix(x, s, 16)); | 94 MP_CHECKOK(mp_toradix(y, s, 16)); |
91 » » printf("integer result\nx %s\n", s); | 95 printf("y %s\n", s); |
92 » » MP_CHECKOK(mp_toradix(y, s, 16)); | 96 res = MP_NO; |
93 » » printf("y %s\n", s); | 97 goto CLEANUP; |
94 » » res = MP_NO; | 98 } |
95 » » goto CLEANUP; | 99 |
96 » } | 100 CLEANUP: |
97 | 101 mp_clear(&rx); |
98 CLEANUP: | 102 mp_clear(&ry); |
99 » mp_clear(&rx); | 103 mp_clear(&rz); |
100 » mp_clear(&ry); | 104 |
101 » mp_clear(&rz); | 105 return res; |
102 | |
103 » return res; | |
104 } | 106 } |
105 | 107 |
106 /* Tests a point p in Chudnovsky Jacobian coordinates, comparing against | 108 /* Tests a point p in Chudnovsky Jacobian coordinates, comparing against |
107 * the expected affine result (x, y). */ | 109 * the expected affine result (x, y). */ |
108 mp_err | 110 mp_err testChudPoint(ecfp_chud_pt *p, mp_int *x, mp_int *y, ECGroup *ecgroup) { |
109 testChudPoint(ecfp_chud_pt * p, mp_int *x, mp_int *y, ECGroup *ecgroup) | 111 |
110 { | 112 char s[1000]; |
111 | 113 mp_int rx, ry, rz, rz2, rz3, test; |
112 » char s[1000]; | 114 mp_err res = MP_OKAY; |
113 » mp_int rx, ry, rz, rz2, rz3, test; | 115 |
114 » mp_err res = MP_OKAY; | 116 /* Initialization */ |
115 | 117 MP_DIGITS(&rx) = 0; |
116 » /* Initialization */ | 118 MP_DIGITS(&ry) = 0; |
117 » MP_DIGITS(&rx) = 0; | 119 MP_DIGITS(&rz) = 0; |
118 » MP_DIGITS(&ry) = 0; | 120 MP_DIGITS(&rz2) = 0; |
119 » MP_DIGITS(&rz) = 0; | 121 MP_DIGITS(&rz3) = 0; |
120 » MP_DIGITS(&rz2) = 0; | 122 MP_DIGITS(&test) = 0; |
121 » MP_DIGITS(&rz3) = 0; | 123 |
122 » MP_DIGITS(&test) = 0; | 124 MP_CHECKOK(mp_init(&rx)); |
123 | 125 MP_CHECKOK(mp_init(&ry)); |
124 » MP_CHECKOK(mp_init(&rx)); | 126 MP_CHECKOK(mp_init(&rz)); |
125 » MP_CHECKOK(mp_init(&ry)); | 127 MP_CHECKOK(mp_init(&rz2)); |
126 » MP_CHECKOK(mp_init(&rz)); | 128 MP_CHECKOK(mp_init(&rz3)); |
127 » MP_CHECKOK(mp_init(&rz2)); | 129 MP_CHECKOK(mp_init(&test)); |
128 » MP_CHECKOK(mp_init(&rz3)); | 130 |
129 » MP_CHECKOK(mp_init(&test)); | 131 /* Convert to integers */ |
130 | 132 ecfp_fp2i(&rx, p->x, ecgroup); |
131 » /* Convert to integers */ | 133 ecfp_fp2i(&ry, p->y, ecgroup); |
132 » ecfp_fp2i(&rx, p->x, ecgroup); | 134 ecfp_fp2i(&rz, p->z, ecgroup); |
133 » ecfp_fp2i(&ry, p->y, ecgroup); | 135 ecfp_fp2i(&rz2, p->z2, ecgroup); |
134 » ecfp_fp2i(&rz, p->z, ecgroup); | 136 ecfp_fp2i(&rz3, p->z3, ecgroup); |
135 » ecfp_fp2i(&rz2, p->z2, ecgroup); | 137 |
136 » ecfp_fp2i(&rz3, p->z3, ecgroup); | 138 /* Verify z2, z3 are valid */ |
137 | 139 mp_sqrmod(&rz, &ecgroup->meth->irr, &test); |
138 » /* Verify z2, z3 are valid */ | 140 if (mp_cmp(&test, &rz2) != 0) { |
139 » mp_sqrmod(&rz, &ecgroup->meth->irr, &test); | 141 printf(" Error: rzp2 not valid\n"); |
140 » if (mp_cmp(&test, &rz2) != 0) { | 142 res = MP_NO; |
141 » » printf(" Error: rzp2 not valid\n"); | 143 goto CLEANUP; |
142 » » res = MP_NO; | 144 } |
143 » » goto CLEANUP; | 145 mp_mulmod(&test, &rz, &ecgroup->meth->irr, &test); |
144 » } | 146 if (mp_cmp(&test, &rz3) != 0) { |
145 » mp_mulmod(&test, &rz, &ecgroup->meth->irr, &test); | 147 printf(" Error: rzp2 not valid\n"); |
146 » if (mp_cmp(&test, &rz3) != 0) { | 148 res = MP_NO; |
147 » » printf(" Error: rzp2 not valid\n"); | 149 goto CLEANUP; |
148 » » res = MP_NO; | 150 } |
149 » » goto CLEANUP; | 151 |
150 » } | 152 /* convert result R to affine coordinates */ |
151 | 153 ec_GFp_pt_jac2aff(&rx, &ry, &rz, &rx, &ry, ecgroup); |
152 » /* convert result R to affine coordinates */ | 154 |
153 » ec_GFp_pt_jac2aff(&rx, &ry, &rz, &rx, &ry, ecgroup); | 155 /* Compare against expected result */ |
154 | 156 if ((mp_cmp(&rx, x) != 0) || (mp_cmp(&ry, y) != 0)) { |
155 » /* Compare against expected result */ | 157 printf(" Error: Chudnovsky Floating Point Incorrect.\n"); |
156 » if ((mp_cmp(&rx, x) != 0) || (mp_cmp(&ry, y) != 0)) { | 158 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
157 » » printf(" Error: Chudnovsky Floating Point Incorrect.\n"); | 159 printf("floating point result\nrx %s\n", s); |
158 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 160 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
159 » » printf("floating point result\nrx %s\n", s); | 161 printf("ry %s\n", s); |
160 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 162 MP_CHECKOK(mp_toradix(x, s, 16)); |
161 » » printf("ry %s\n", s); | 163 printf("integer result\nx %s\n", s); |
162 » » MP_CHECKOK(mp_toradix(x, s, 16)); | 164 MP_CHECKOK(mp_toradix(y, s, 16)); |
163 » » printf("integer result\nx %s\n", s); | 165 printf("y %s\n", s); |
164 » » MP_CHECKOK(mp_toradix(y, s, 16)); | 166 res = MP_NO; |
165 » » printf("y %s\n", s); | 167 goto CLEANUP; |
166 » » res = MP_NO; | 168 } |
167 » » goto CLEANUP; | 169 |
168 » } | 170 CLEANUP: |
169 | 171 mp_clear(&rx); |
170 CLEANUP: | 172 mp_clear(&ry); |
171 » mp_clear(&rx); | 173 mp_clear(&rz); |
172 » mp_clear(&ry); | 174 mp_clear(&rz2); |
173 » mp_clear(&rz); | 175 mp_clear(&rz3); |
174 » mp_clear(&rz2); | 176 mp_clear(&test); |
175 » mp_clear(&rz3); | 177 |
176 » mp_clear(&test); | 178 return res; |
177 | 179 } |
178 » return res; | 180 |
179 } | 181 /* Tests a point p in Modified Jacobian coordinates, comparing against the |
180 | |
181 /* Tests a point p in Modified Jacobian coordinates, comparing against the· | |
182 * expected affine result (x, y). */ | 182 * expected affine result (x, y). */ |
183 mp_err | 183 mp_err testJmPoint(ecfp_jm_pt *r, mp_int *x, mp_int *y, ECGroup *ecgroup) { |
184 testJmPoint(ecfp_jm_pt * r, mp_int *x, mp_int *y, ECGroup *ecgroup) | 184 |
185 { | 185 char s[1000]; |
186 | 186 mp_int rx, ry, rz, raz4, test; |
187 » char s[1000]; | 187 mp_err res = MP_OKAY; |
188 » mp_int rx, ry, rz, raz4, test; | 188 |
189 » mp_err res = MP_OKAY; | 189 /* Initialization */ |
190 | 190 MP_DIGITS(&rx) = 0; |
191 » /* Initialization */ | 191 MP_DIGITS(&ry) = 0; |
192 » MP_DIGITS(&rx) = 0; | 192 MP_DIGITS(&rz) = 0; |
193 » MP_DIGITS(&ry) = 0; | 193 MP_DIGITS(&raz4) = 0; |
194 » MP_DIGITS(&rz) = 0; | 194 MP_DIGITS(&test) = 0; |
195 » MP_DIGITS(&raz4) = 0; | 195 |
196 » MP_DIGITS(&test) = 0; | 196 MP_CHECKOK(mp_init(&rx)); |
197 | 197 MP_CHECKOK(mp_init(&ry)); |
198 » MP_CHECKOK(mp_init(&rx)); | 198 MP_CHECKOK(mp_init(&rz)); |
199 » MP_CHECKOK(mp_init(&ry)); | 199 MP_CHECKOK(mp_init(&raz4)); |
200 » MP_CHECKOK(mp_init(&rz)); | 200 MP_CHECKOK(mp_init(&test)); |
201 » MP_CHECKOK(mp_init(&raz4)); | 201 |
202 » MP_CHECKOK(mp_init(&test)); | 202 /* Convert to integer */ |
203 | 203 ecfp_fp2i(&rx, r->x, ecgroup); |
204 » /* Convert to integer */ | 204 ecfp_fp2i(&ry, r->y, ecgroup); |
205 » ecfp_fp2i(&rx, r->x, ecgroup); | 205 ecfp_fp2i(&rz, r->z, ecgroup); |
206 » ecfp_fp2i(&ry, r->y, ecgroup); | 206 ecfp_fp2i(&raz4, r->az4, ecgroup); |
207 » ecfp_fp2i(&rz, r->z, ecgroup); | 207 |
208 » ecfp_fp2i(&raz4, r->az4, ecgroup); | 208 /* Verify raz4 = rz^4 * a */ |
209 | 209 mp_sqrmod(&rz, &ecgroup->meth->irr, &test); |
210 » /* Verify raz4 = rz^4 * a */ | 210 mp_sqrmod(&test, &ecgroup->meth->irr, &test); |
211 » mp_sqrmod(&rz, &ecgroup->meth->irr, &test); | 211 mp_mulmod(&test, &ecgroup->curvea, &ecgroup->meth->irr, &test); |
212 » mp_sqrmod(&test, &ecgroup->meth->irr, &test); | 212 if (mp_cmp(&test, &raz4) != 0) { |
213 » mp_mulmod(&test, &ecgroup->curvea, &ecgroup->meth->irr, &test); | 213 printf(" Error: a*z^4 not valid\n"); |
214 » if (mp_cmp(&test, &raz4) != 0) { | 214 MP_CHECKOK(mp_toradix(&ecgroup->curvea, s, 16)); |
215 » » printf(" Error: a*z^4 not valid\n"); | 215 printf("a %s\n", s); |
216 » » MP_CHECKOK(mp_toradix(&ecgroup->curvea, s, 16)); | 216 MP_CHECKOK(mp_toradix(&rz, s, 16)); |
217 » » printf("a %s\n", s); | 217 printf("rz %s\n", s); |
218 » » MP_CHECKOK(mp_toradix(&rz, s, 16)); | 218 MP_CHECKOK(mp_toradix(&raz4, s, 16)); |
219 » » printf("rz %s\n", s); | 219 printf("raz4 %s\n", s); |
220 » » MP_CHECKOK(mp_toradix(&raz4, s, 16)); | 220 res = MP_NO; |
221 » » printf("raz4 %s\n", s); | 221 goto CLEANUP; |
222 » » res = MP_NO; | 222 } |
223 » » goto CLEANUP; | 223 |
224 » } | 224 /* convert result R to affine coordinates */ |
225 | 225 ec_GFp_pt_jac2aff(&rx, &ry, &rz, &rx, &ry, ecgroup); |
226 » /* convert result R to affine coordinates */ | 226 |
227 » ec_GFp_pt_jac2aff(&rx, &ry, &rz, &rx, &ry, ecgroup); | 227 /* Compare against expected result */ |
228 | 228 if ((mp_cmp(&rx, x) != 0) || (mp_cmp(&ry, y) != 0)) { |
229 » /* Compare against expected result */ | 229 printf(" Error: Modified Jacobian Floating Point Incorrect.\n"); |
230 » if ((mp_cmp(&rx, x) != 0) || (mp_cmp(&ry, y) != 0)) { | 230 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
231 » » printf(" Error: Modified Jacobian Floating Point Incorrect.\n")
; | 231 printf("floating point result\nrx %s\n", s); |
232 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 232 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
233 » » printf("floating point result\nrx %s\n", s); | 233 printf("ry %s\n", s); |
234 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 234 MP_CHECKOK(mp_toradix(x, s, 16)); |
235 » » printf("ry %s\n", s); | 235 printf("integer result\nx %s\n", s); |
236 » » MP_CHECKOK(mp_toradix(x, s, 16)); | 236 MP_CHECKOK(mp_toradix(y, s, 16)); |
237 » » printf("integer result\nx %s\n", s); | 237 printf("y %s\n", s); |
238 » » MP_CHECKOK(mp_toradix(y, s, 16)); | 238 res = MP_NO; |
239 » » printf("y %s\n", s); | 239 goto CLEANUP; |
240 » » res = MP_NO; | 240 } |
241 » » goto CLEANUP; | 241 CLEANUP: |
242 » } | 242 mp_clear(&rx); |
243 CLEANUP: | 243 mp_clear(&ry); |
244 » mp_clear(&rx); | 244 mp_clear(&rz); |
245 » mp_clear(&ry); | 245 mp_clear(&raz4); |
246 » mp_clear(&rz); | 246 mp_clear(&test); |
247 » mp_clear(&raz4); | 247 |
248 » mp_clear(&test); | 248 return res; |
249 | |
250 » return res; | |
251 } | 249 } |
252 | 250 |
253 /* Tests point addition of Jacobian + Affine -> Jacobian */ | 251 /* Tests point addition of Jacobian + Affine -> Jacobian */ |
254 mp_err | 252 mp_err testPointAddJacAff(ECGroup *ecgroup) { |
255 testPointAddJacAff(ECGroup *ecgroup) | 253 mp_err res; |
256 { | 254 mp_int pz, rx2, ry2, rz2; |
257 » mp_err res; | 255 ecfp_jac_pt p, r; |
258 » mp_int pz, rx2, ry2, rz2; | 256 ecfp_aff_pt q; |
259 » ecfp_jac_pt p, r; | 257 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
260 » ecfp_aff_pt q; | 258 |
261 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 259 /* Init */ |
262 | 260 MP_DIGITS(&pz) = 0; |
263 » /* Init */ | 261 MP_DIGITS(&rx2) = 0; |
264 » MP_DIGITS(&pz) = 0; | 262 MP_DIGITS(&ry2) = 0; |
265 » MP_DIGITS(&rx2) = 0; | 263 MP_DIGITS(&rz2) = 0; |
266 » MP_DIGITS(&ry2) = 0; | 264 MP_CHECKOK(mp_init(&pz)); |
267 » MP_DIGITS(&rz2) = 0; | 265 MP_CHECKOK(mp_init(&rx2)); |
268 » MP_CHECKOK(mp_init(&pz)); | 266 MP_CHECKOK(mp_init(&ry2)); |
269 » MP_CHECKOK(mp_init(&rx2)); | 267 MP_CHECKOK(mp_init(&rz2)); |
270 » MP_CHECKOK(mp_init(&ry2)); | 268 |
271 » MP_CHECKOK(mp_init(&rz2)); | 269 MP_CHECKOK(mp_set_int(&pz, 5)); |
272 | 270 |
273 » MP_CHECKOK(mp_set_int(&pz, 5)); | 271 /* Set p */ |
274 | 272 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
275 » /* Set p */ | 273 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
276 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 274 ecfp_i2fp(p.z, &pz, ecgroup); |
277 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 275 /* Set q */ |
278 » ecfp_i2fp(p.z, &pz, ecgroup); | 276 ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); |
279 » /* Set q */ | 277 ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); |
280 » ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); | 278 |
281 » ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); | 279 /* Do calculations */ |
282 | 280 group->pt_add_jac_aff(&p, &q, &r, group); |
283 » /* Do calculations */ | 281 |
284 » group->pt_add_jac_aff(&p, &q, &r, group); | 282 /* Do calculation in integer to compare against */ |
285 | 283 MP_CHECKOK(ec_GFp_pt_add_jac_aff(&ecgroup->genx, &ecgroup->geny, &pz, |
286 » /* Do calculation in integer to compare against */ | 284 &ecgroup->geny, &ecgroup->genx, &rx2, &ry2, |
287 » MP_CHECKOK(ec_GFp_pt_add_jac_aff | 285 &rz2, ecgroup)); |
288 » » » (&ecgroup->genx, &ecgroup->geny, &pz, &ecgroup->geny, | 286 /* convert result R to affine coordinates */ |
289 » » » » &ecgroup->genx, &rx2, &ry2, &rz2, ecgroup)); | 287 ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); |
290 » /* convert result R to affine coordinates */ | 288 |
291 » ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); | 289 MP_CHECKOK(testJacPoint(&r, &rx2, &ry2, ecgroup)); |
292 | 290 |
293 » MP_CHECKOK(testJacPoint(&r, &rx2, &ry2, ecgroup)); | 291 CLEANUP: |
294 | 292 if (res == MP_OKAY) |
295 CLEANUP: | 293 printf(" Test Passed - Point Addition - Jacobian & Affine\n"); |
296 » if (res == MP_OKAY) | 294 else |
297 » » printf(" Test Passed - Point Addition - Jacobian & Affine\n"); | 295 printf("TEST FAILED - Point Addition - Jacobian & Affine\n"); |
298 » else | 296 |
299 » » printf("TEST FAILED - Point Addition - Jacobian & Affine\n"); | 297 mp_clear(&pz); |
300 | 298 mp_clear(&rx2); |
301 » mp_clear(&pz); | 299 mp_clear(&ry2); |
302 » mp_clear(&rx2); | 300 mp_clear(&rz2); |
303 » mp_clear(&ry2); | 301 |
304 » mp_clear(&rz2); | 302 return res; |
305 | |
306 » return res; | |
307 } | 303 } |
308 | 304 |
309 /* Tests point addition in Jacobian coordinates */ | 305 /* Tests point addition in Jacobian coordinates */ |
310 mp_err | 306 mp_err testPointAddJac(ECGroup *ecgroup) { |
311 testPointAddJac(ECGroup *ecgroup) | 307 mp_err res; |
312 { | 308 mp_int pz, qz, qx, qy, rx2, ry2, rz2; |
313 » mp_err res; | 309 ecfp_jac_pt p, q, r; |
314 » mp_int pz, qz, qx, qy, rx2, ry2, rz2; | 310 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
315 » ecfp_jac_pt p, q, r; | 311 |
316 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 312 /* Init */ |
317 | 313 MP_DIGITS(&pz) = 0; |
318 » /* Init */ | 314 MP_DIGITS(&qx) = 0; |
319 » MP_DIGITS(&pz) = 0; | 315 MP_DIGITS(&qy) = 0; |
320 » MP_DIGITS(&qx) = 0; | 316 MP_DIGITS(&qz) = 0; |
321 » MP_DIGITS(&qy) = 0; | 317 MP_DIGITS(&rx2) = 0; |
322 » MP_DIGITS(&qz) = 0; | 318 MP_DIGITS(&ry2) = 0; |
323 » MP_DIGITS(&rx2) = 0; | 319 MP_DIGITS(&rz2) = 0; |
324 » MP_DIGITS(&ry2) = 0; | 320 MP_CHECKOK(mp_init(&pz)); |
325 » MP_DIGITS(&rz2) = 0; | 321 MP_CHECKOK(mp_init(&qx)); |
326 » MP_CHECKOK(mp_init(&pz)); | 322 MP_CHECKOK(mp_init(&qy)); |
327 » MP_CHECKOK(mp_init(&qx)); | 323 MP_CHECKOK(mp_init(&qz)); |
328 » MP_CHECKOK(mp_init(&qy)); | 324 MP_CHECKOK(mp_init(&rx2)); |
329 » MP_CHECKOK(mp_init(&qz)); | 325 MP_CHECKOK(mp_init(&ry2)); |
330 » MP_CHECKOK(mp_init(&rx2)); | 326 MP_CHECKOK(mp_init(&rz2)); |
331 » MP_CHECKOK(mp_init(&ry2)); | 327 |
332 » MP_CHECKOK(mp_init(&rz2)); | 328 MP_CHECKOK(mp_set_int(&pz, 5)); |
333 | 329 MP_CHECKOK(mp_set_int(&qz, 105)); |
334 » MP_CHECKOK(mp_set_int(&pz, 5)); | 330 |
335 » MP_CHECKOK(mp_set_int(&qz, 105)); | 331 /* Set p */ |
336 | 332 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
337 » /* Set p */ | 333 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
338 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 334 ecfp_i2fp(p.z, &pz, ecgroup); |
339 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 335 /* Set q */ |
340 » ecfp_i2fp(p.z, &pz, ecgroup); | 336 ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); |
341 » /* Set q */ | 337 ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); |
342 » ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); | 338 ecfp_i2fp(q.z, &qz, ecgroup); |
343 » ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); | 339 |
344 » ecfp_i2fp(q.z, &qz, ecgroup); | 340 /* Do calculations */ |
345 | 341 group->pt_add_jac(&p, &q, &r, group); |
346 » /* Do calculations */ | 342 |
347 » group->pt_add_jac(&p, &q, &r, group); | 343 /* Do calculation in integer to compare against */ |
348 | 344 ec_GFp_pt_jac2aff(&ecgroup->geny, &ecgroup->genx, &qz, &qx, &qy, ecgroup); |
349 » /* Do calculation in integer to compare against */ | 345 MP_CHECKOK(ec_GFp_pt_add_jac_aff(&ecgroup->genx, &ecgroup->geny, &pz, &qx, |
350 » ec_GFp_pt_jac2aff(&ecgroup->geny, &ecgroup->genx, &qz, &qx, &qy, | 346 &qy, &rx2, &ry2, &rz2, ecgroup)); |
351 » » » » » ecgroup); | 347 /* convert result R to affine coordinates */ |
352 » MP_CHECKOK(ec_GFp_pt_add_jac_aff | 348 ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); |
353 » » » (&ecgroup->genx, &ecgroup->geny, &pz, &qx, &qy, &rx2,
&ry2, | 349 |
354 » » » » &rz2, ecgroup)); | 350 MP_CHECKOK(testJacPoint(&r, &rx2, &ry2, ecgroup)); |
355 » /* convert result R to affine coordinates */ | 351 |
356 » ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); | 352 CLEANUP: |
357 | 353 if (res == MP_OKAY) |
358 » MP_CHECKOK(testJacPoint(&r, &rx2, &ry2, ecgroup)); | 354 printf(" Test Passed - Point Addition - Jacobian\n"); |
359 | 355 else |
360 CLEANUP: | 356 printf("TEST FAILED - Point Addition - Jacobian\n"); |
361 » if (res == MP_OKAY) | 357 |
362 » » printf(" Test Passed - Point Addition - Jacobian\n"); | 358 mp_clear(&pz); |
363 » else | 359 mp_clear(&qx); |
364 » » printf("TEST FAILED - Point Addition - Jacobian\n"); | 360 mp_clear(&qy); |
365 | 361 mp_clear(&qz); |
366 » mp_clear(&pz); | 362 mp_clear(&rx2); |
367 » mp_clear(&qx); | 363 mp_clear(&ry2); |
368 » mp_clear(&qy); | 364 mp_clear(&rz2); |
369 » mp_clear(&qz); | 365 |
370 » mp_clear(&rx2); | 366 return res; |
371 » mp_clear(&ry2); | |
372 » mp_clear(&rz2); | |
373 | |
374 » return res; | |
375 } | 367 } |
376 | 368 |
377 /* Tests point addition in Chudnovsky Jacobian Coordinates */ | 369 /* Tests point addition in Chudnovsky Jacobian Coordinates */ |
378 mp_err | 370 mp_err testPointAddChud(ECGroup *ecgroup) { |
379 testPointAddChud(ECGroup *ecgroup) | 371 mp_err res; |
380 { | 372 mp_int rx2, ry2, ix, iy, iz, test, pz, qx, qy, qz; |
381 » mp_err res; | 373 ecfp_chud_pt p, q, r; |
382 » mp_int rx2, ry2, ix, iy, iz, test, pz, qx, qy, qz; | 374 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
383 » ecfp_chud_pt p, q, r; | 375 |
384 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 376 MP_DIGITS(&qx) = 0; |
385 | 377 MP_DIGITS(&qy) = 0; |
386 » MP_DIGITS(&qx) = 0; | 378 MP_DIGITS(&qz) = 0; |
387 » MP_DIGITS(&qy) = 0; | 379 MP_DIGITS(&pz) = 0; |
388 » MP_DIGITS(&qz) = 0; | 380 MP_DIGITS(&rx2) = 0; |
389 » MP_DIGITS(&pz) = 0; | 381 MP_DIGITS(&ry2) = 0; |
390 » MP_DIGITS(&rx2) = 0; | 382 MP_DIGITS(&ix) = 0; |
391 » MP_DIGITS(&ry2) = 0; | 383 MP_DIGITS(&iy) = 0; |
392 » MP_DIGITS(&ix) = 0; | 384 MP_DIGITS(&iz) = 0; |
393 » MP_DIGITS(&iy) = 0; | 385 MP_DIGITS(&test) = 0; |
394 » MP_DIGITS(&iz) = 0; | 386 |
395 » MP_DIGITS(&test) = 0; | 387 MP_CHECKOK(mp_init(&qx)); |
396 | 388 MP_CHECKOK(mp_init(&qy)); |
397 » MP_CHECKOK(mp_init(&qx)); | 389 MP_CHECKOK(mp_init(&qz)); |
398 » MP_CHECKOK(mp_init(&qy)); | 390 MP_CHECKOK(mp_init(&pz)); |
399 » MP_CHECKOK(mp_init(&qz)); | 391 MP_CHECKOK(mp_init(&rx2)); |
400 » MP_CHECKOK(mp_init(&pz)); | 392 MP_CHECKOK(mp_init(&ry2)); |
401 » MP_CHECKOK(mp_init(&rx2)); | 393 MP_CHECKOK(mp_init(&ix)); |
402 » MP_CHECKOK(mp_init(&ry2)); | 394 MP_CHECKOK(mp_init(&iy)); |
403 » MP_CHECKOK(mp_init(&ix)); | 395 MP_CHECKOK(mp_init(&iz)); |
404 » MP_CHECKOK(mp_init(&iy)); | 396 MP_CHECKOK(mp_init(&test)); |
405 » MP_CHECKOK(mp_init(&iz)); | 397 |
406 » MP_CHECKOK(mp_init(&test)); | 398 /* Test Chudnovsky form addition */ |
407 | 399 /* Set p */ |
408 » /* Test Chudnovsky form addition */ | 400 MP_CHECKOK(mp_set_int(&pz, 5)); |
409 » /* Set p */ | 401 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
410 » MP_CHECKOK(mp_set_int(&pz, 5)); | 402 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
411 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 403 ecfp_i2fp(p.z, &pz, ecgroup); |
412 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 404 mp_sqrmod(&pz, &ecgroup->meth->irr, &test); |
413 » ecfp_i2fp(p.z, &pz, ecgroup); | 405 ecfp_i2fp(p.z2, &test, ecgroup); |
414 » mp_sqrmod(&pz, &ecgroup->meth->irr, &test); | 406 mp_mulmod(&test, &pz, &ecgroup->meth->irr, &test); |
415 » ecfp_i2fp(p.z2, &test, ecgroup); | 407 ecfp_i2fp(p.z3, &test, ecgroup); |
416 » mp_mulmod(&test, &pz, &ecgroup->meth->irr, &test); | 408 |
417 » ecfp_i2fp(p.z3, &test, ecgroup); | 409 /* Set q */ |
418 | 410 MP_CHECKOK(mp_set_int(&qz, 105)); |
419 » /* Set q */ | 411 ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); |
420 » MP_CHECKOK(mp_set_int(&qz, 105)); | 412 ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); |
421 » ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); | 413 ecfp_i2fp(q.z, &qz, ecgroup); |
422 » ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); | 414 mp_sqrmod(&qz, &ecgroup->meth->irr, &test); |
423 » ecfp_i2fp(q.z, &qz, ecgroup); | 415 ecfp_i2fp(q.z2, &test, ecgroup); |
424 » mp_sqrmod(&qz, &ecgroup->meth->irr, &test); | 416 mp_mulmod(&test, &qz, &ecgroup->meth->irr, &test); |
425 » ecfp_i2fp(q.z2, &test, ecgroup); | 417 ecfp_i2fp(q.z3, &test, ecgroup); |
426 » mp_mulmod(&test, &qz, &ecgroup->meth->irr, &test); | 418 |
427 » ecfp_i2fp(q.z3, &test, ecgroup); | 419 group->pt_add_chud(&p, &q, &r, group); |
428 | 420 |
429 » group->pt_add_chud(&p, &q, &r, group); | 421 /* Calculate addition to compare against */ |
430 | 422 ec_GFp_pt_jac2aff(&ecgroup->geny, &ecgroup->genx, &qz, &qx, &qy, ecgroup); |
431 » /* Calculate addition to compare against */ | 423 ec_GFp_pt_add_jac_aff(&ecgroup->genx, &ecgroup->geny, &pz, &qx, &qy, &ix, &iy, |
432 » ec_GFp_pt_jac2aff(&ecgroup->geny, &ecgroup->genx, &qz, &qx, &qy, | 424 &iz, ecgroup); |
433 » » » » » ecgroup); | 425 ec_GFp_pt_jac2aff(&ix, &iy, &iz, &rx2, &ry2, ecgroup); |
434 » ec_GFp_pt_add_jac_aff(&ecgroup->genx, &ecgroup->geny, &pz, &qx, &qy, | 426 |
435 » » » » » » &ix, &iy, &iz, ecgroup); | 427 MP_CHECKOK(testChudPoint(&r, &rx2, &ry2, ecgroup)); |
436 » ec_GFp_pt_jac2aff(&ix, &iy, &iz, &rx2, &ry2, ecgroup); | 428 |
437 | 429 CLEANUP: |
438 » MP_CHECKOK(testChudPoint(&r, &rx2, &ry2, ecgroup)); | 430 if (res == MP_OKAY) |
439 | 431 printf(" Test Passed - Point Addition - Chudnovsky Jacobian\n"); |
440 CLEANUP: | 432 else |
441 » if (res == MP_OKAY) | 433 printf("TEST FAILED - Point Addition - Chudnovsky Jacobian\n"); |
442 » » printf(" Test Passed - Point Addition - Chudnovsky Jacobian\n")
; | 434 |
443 » else | 435 mp_clear(&qx); |
444 » » printf("TEST FAILED - Point Addition - Chudnovsky Jacobian\n"); | 436 mp_clear(&qy); |
445 | 437 mp_clear(&qz); |
446 » mp_clear(&qx); | 438 mp_clear(&pz); |
447 » mp_clear(&qy); | 439 mp_clear(&rx2); |
448 » mp_clear(&qz); | 440 mp_clear(&ry2); |
449 » mp_clear(&pz); | 441 mp_clear(&ix); |
450 » mp_clear(&rx2); | 442 mp_clear(&iy); |
451 » mp_clear(&ry2); | 443 mp_clear(&iz); |
452 » mp_clear(&ix); | 444 mp_clear(&test); |
453 » mp_clear(&iy); | 445 |
454 » mp_clear(&iz); | 446 return res; |
455 » mp_clear(&test); | |
456 | |
457 » return res; | |
458 } | 447 } |
459 | 448 |
460 /* Tests point addition in Modified Jacobian + Chudnovsky Jacobian -> | 449 /* Tests point addition in Modified Jacobian + Chudnovsky Jacobian -> |
461 * Modified Jacobian coordinates. */ | 450 * Modified Jacobian coordinates. */ |
462 mp_err | 451 mp_err testPointAddJmChud(ECGroup *ecgroup) { |
463 testPointAddJmChud(ECGroup *ecgroup) | 452 mp_err res; |
464 { | 453 mp_int rx2, ry2, ix, iy, iz, test, pz, paz4, qx, qy, qz; |
465 » mp_err res; | 454 ecfp_chud_pt q; |
466 » mp_int rx2, ry2, ix, iy, iz, test, pz, paz4, qx, qy, qz; | 455 ecfp_jm_pt p, r; |
467 » ecfp_chud_pt q; | 456 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
468 » ecfp_jm_pt p, r; | 457 |
469 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 458 MP_DIGITS(&qx) = 0; |
470 | 459 MP_DIGITS(&qy) = 0; |
471 » MP_DIGITS(&qx) = 0; | 460 MP_DIGITS(&qz) = 0; |
472 » MP_DIGITS(&qy) = 0; | 461 MP_DIGITS(&pz) = 0; |
473 » MP_DIGITS(&qz) = 0; | 462 MP_DIGITS(&paz4) = 0; |
474 » MP_DIGITS(&pz) = 0; | 463 MP_DIGITS(&iz) = 0; |
475 » MP_DIGITS(&paz4) = 0; | 464 MP_DIGITS(&rx2) = 0; |
476 » MP_DIGITS(&iz) = 0; | 465 MP_DIGITS(&ry2) = 0; |
477 » MP_DIGITS(&rx2) = 0; | 466 MP_DIGITS(&ix) = 0; |
478 » MP_DIGITS(&ry2) = 0; | 467 MP_DIGITS(&iy) = 0; |
479 » MP_DIGITS(&ix) = 0; | 468 MP_DIGITS(&iz) = 0; |
480 » MP_DIGITS(&iy) = 0; | 469 MP_DIGITS(&test) = 0; |
481 » MP_DIGITS(&iz) = 0; | 470 |
482 » MP_DIGITS(&test) = 0; | 471 MP_CHECKOK(mp_init(&qx)); |
483 | 472 MP_CHECKOK(mp_init(&qy)); |
484 » MP_CHECKOK(mp_init(&qx)); | 473 MP_CHECKOK(mp_init(&qz)); |
485 » MP_CHECKOK(mp_init(&qy)); | 474 MP_CHECKOK(mp_init(&pz)); |
486 » MP_CHECKOK(mp_init(&qz)); | 475 MP_CHECKOK(mp_init(&paz4)); |
487 » MP_CHECKOK(mp_init(&pz)); | 476 MP_CHECKOK(mp_init(&rx2)); |
488 » MP_CHECKOK(mp_init(&paz4)); | 477 MP_CHECKOK(mp_init(&ry2)); |
489 » MP_CHECKOK(mp_init(&rx2)); | 478 MP_CHECKOK(mp_init(&ix)); |
490 » MP_CHECKOK(mp_init(&ry2)); | 479 MP_CHECKOK(mp_init(&iy)); |
491 » MP_CHECKOK(mp_init(&ix)); | 480 MP_CHECKOK(mp_init(&iz)); |
492 » MP_CHECKOK(mp_init(&iy)); | 481 MP_CHECKOK(mp_init(&test)); |
493 » MP_CHECKOK(mp_init(&iz)); | 482 |
494 » MP_CHECKOK(mp_init(&test)); | 483 /* Test Modified Jacobian form addition */ |
495 | 484 /* Set p */ |
496 » /* Test Modified Jacobian form addition */ | 485 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
497 » /* Set p */ | 486 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
498 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 487 ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); |
499 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 488 /* paz4 = az^4 */ |
500 » ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); | 489 MP_CHECKOK(mp_set_int(&pz, 5)); |
501 » /* paz4 = az^4 */ | 490 mp_sqrmod(&pz, &ecgroup->meth->irr, &paz4); |
502 » MP_CHECKOK(mp_set_int(&pz, 5)); | 491 mp_sqrmod(&paz4, &ecgroup->meth->irr, &paz4); |
503 » mp_sqrmod(&pz, &ecgroup->meth->irr, &paz4); | 492 mp_mulmod(&paz4, &ecgroup->curvea, &ecgroup->meth->irr, &paz4); |
504 » mp_sqrmod(&paz4, &ecgroup->meth->irr, &paz4); | 493 ecfp_i2fp(p.z, &pz, ecgroup); |
505 » mp_mulmod(&paz4, &ecgroup->curvea, &ecgroup->meth->irr, &paz4); | 494 ecfp_i2fp(p.az4, &paz4, ecgroup); |
506 » ecfp_i2fp(p.z, &pz, ecgroup); | 495 |
507 » ecfp_i2fp(p.az4, &paz4, ecgroup); | 496 /* Set q */ |
508 | 497 MP_CHECKOK(mp_set_int(&qz, 105)); |
509 » /* Set q */ | 498 ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); |
510 » MP_CHECKOK(mp_set_int(&qz, 105)); | 499 ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); |
511 » ecfp_i2fp(q.x, &ecgroup->geny, ecgroup); | 500 ecfp_i2fp(q.z, &qz, ecgroup); |
512 » ecfp_i2fp(q.y, &ecgroup->genx, ecgroup); | 501 mp_sqrmod(&qz, &ecgroup->meth->irr, &test); |
513 » ecfp_i2fp(q.z, &qz, ecgroup); | 502 ecfp_i2fp(q.z2, &test, ecgroup); |
514 » mp_sqrmod(&qz, &ecgroup->meth->irr, &test); | 503 mp_mulmod(&test, &qz, &ecgroup->meth->irr, &test); |
515 » ecfp_i2fp(q.z2, &test, ecgroup); | 504 ecfp_i2fp(q.z3, &test, ecgroup); |
516 » mp_mulmod(&test, &qz, &ecgroup->meth->irr, &test); | 505 |
517 » ecfp_i2fp(q.z3, &test, ecgroup); | 506 /* Do calculation */ |
518 | 507 group->pt_add_jm_chud(&p, &q, &r, group); |
519 » /* Do calculation */ | 508 |
520 » group->pt_add_jm_chud(&p, &q, &r, group); | 509 /* Calculate addition to compare against */ |
521 | 510 ec_GFp_pt_jac2aff(&ecgroup->geny, &ecgroup->genx, &qz, &qx, &qy, ecgroup); |
522 » /* Calculate addition to compare against */ | 511 ec_GFp_pt_add_jac_aff(&ecgroup->genx, &ecgroup->geny, &pz, &qx, &qy, &ix, &iy, |
523 » ec_GFp_pt_jac2aff(&ecgroup->geny, &ecgroup->genx, &qz, &qx, &qy, | 512 &iz, ecgroup); |
524 » » » » » ecgroup); | 513 ec_GFp_pt_jac2aff(&ix, &iy, &iz, &rx2, &ry2, ecgroup); |
525 » ec_GFp_pt_add_jac_aff(&ecgroup->genx, &ecgroup->geny, &pz, &qx, &qy, | 514 |
526 » » » » » » &ix, &iy, &iz, ecgroup); | 515 MP_CHECKOK(testJmPoint(&r, &rx2, &ry2, ecgroup)); |
527 » ec_GFp_pt_jac2aff(&ix, &iy, &iz, &rx2, &ry2, ecgroup); | 516 |
528 | 517 CLEANUP: |
529 » MP_CHECKOK(testJmPoint(&r, &rx2, &ry2, ecgroup)); | 518 if (res == MP_OKAY) |
530 | 519 printf(" Test Passed - Point Addition - Modified & Chudnovsky Jacobian\n"); |
531 CLEANUP: | 520 else |
532 » if (res == MP_OKAY) | 521 printf("TEST FAILED - Point Addition - Modified & Chudnovsky Jacobian\n"); |
533 » » printf | 522 |
534 » » » (" Test Passed - Point Addition - Modified & Chudnovsky
Jacobian\n"); | 523 mp_clear(&qx); |
535 » else | 524 mp_clear(&qy); |
536 » » printf | 525 mp_clear(&qz); |
537 » » » ("TEST FAILED - Point Addition - Modified & Chudnovsky J
acobian\n"); | 526 mp_clear(&pz); |
538 | 527 mp_clear(&paz4); |
539 » mp_clear(&qx); | 528 mp_clear(&rx2); |
540 » mp_clear(&qy); | 529 mp_clear(&ry2); |
541 » mp_clear(&qz); | 530 mp_clear(&ix); |
542 » mp_clear(&pz); | 531 mp_clear(&iy); |
543 » mp_clear(&paz4); | 532 mp_clear(&iz); |
544 » mp_clear(&rx2); | 533 mp_clear(&test); |
545 » mp_clear(&ry2); | 534 |
546 » mp_clear(&ix); | 535 return res; |
547 » mp_clear(&iy); | |
548 » mp_clear(&iz); | |
549 » mp_clear(&test); | |
550 | |
551 » return res; | |
552 } | 536 } |
553 | 537 |
554 /* Tests point doubling in Modified Jacobian coordinates */ | 538 /* Tests point doubling in Modified Jacobian coordinates */ |
555 mp_err | 539 mp_err testPointDoubleJm(ECGroup *ecgroup) { |
556 testPointDoubleJm(ECGroup *ecgroup) | 540 mp_err res; |
557 { | 541 mp_int pz, paz4, rx2, ry2, rz2, raz4; |
558 » mp_err res; | 542 ecfp_jm_pt p, r; |
559 » mp_int pz, paz4, rx2, ry2, rz2, raz4; | 543 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
560 » ecfp_jm_pt p, r; | 544 |
561 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 545 MP_DIGITS(&pz) = 0; |
562 | 546 MP_DIGITS(&paz4) = 0; |
563 » MP_DIGITS(&pz) = 0; | 547 MP_DIGITS(&rx2) = 0; |
564 » MP_DIGITS(&paz4) = 0; | 548 MP_DIGITS(&ry2) = 0; |
565 » MP_DIGITS(&rx2) = 0; | 549 MP_DIGITS(&rz2) = 0; |
566 » MP_DIGITS(&ry2) = 0; | 550 MP_DIGITS(&raz4) = 0; |
567 » MP_DIGITS(&rz2) = 0; | 551 |
568 » MP_DIGITS(&raz4) = 0; | 552 MP_CHECKOK(mp_init(&pz)); |
569 | 553 MP_CHECKOK(mp_init(&paz4)); |
570 » MP_CHECKOK(mp_init(&pz)); | 554 MP_CHECKOK(mp_init(&rx2)); |
571 » MP_CHECKOK(mp_init(&paz4)); | 555 MP_CHECKOK(mp_init(&ry2)); |
572 » MP_CHECKOK(mp_init(&rx2)); | 556 MP_CHECKOK(mp_init(&rz2)); |
573 » MP_CHECKOK(mp_init(&ry2)); | 557 MP_CHECKOK(mp_init(&raz4)); |
574 » MP_CHECKOK(mp_init(&rz2)); | 558 |
575 » MP_CHECKOK(mp_init(&raz4)); | 559 /* Set p */ |
576 | 560 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
577 » /* Set p */ | 561 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
578 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 562 ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); |
579 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 563 |
580 » ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); | 564 /* paz4 = az^4 */ |
581 | 565 MP_CHECKOK(mp_set_int(&pz, 5)); |
582 » /* paz4 = az^4 */ | 566 mp_sqrmod(&pz, &ecgroup->meth->irr, &paz4); |
583 » MP_CHECKOK(mp_set_int(&pz, 5)); | 567 mp_sqrmod(&paz4, &ecgroup->meth->irr, &paz4); |
584 » mp_sqrmod(&pz, &ecgroup->meth->irr, &paz4); | 568 mp_mulmod(&paz4, &ecgroup->curvea, &ecgroup->meth->irr, &paz4); |
585 » mp_sqrmod(&paz4, &ecgroup->meth->irr, &paz4); | 569 |
586 » mp_mulmod(&paz4, &ecgroup->curvea, &ecgroup->meth->irr, &paz4); | 570 ecfp_i2fp(p.z, &pz, ecgroup); |
587 | 571 ecfp_i2fp(p.az4, &paz4, ecgroup); |
588 » ecfp_i2fp(p.z, &pz, ecgroup); | 572 |
589 » ecfp_i2fp(p.az4, &paz4, ecgroup); | 573 group->pt_dbl_jm(&p, &r, group); |
590 | 574 |
591 » group->pt_dbl_jm(&p, &r, group); | 575 M_TimeOperation(group->pt_dbl_jm(&p, &r, group), 100000); |
592 | 576 |
593 » M_TimeOperation(group->pt_dbl_jm(&p, &r, group), 100000); | 577 /* Calculate doubling to compare against */ |
594 | 578 ec_GFp_pt_dbl_jac(&ecgroup->genx, &ecgroup->geny, &pz, &rx2, &ry2, &rz2, |
595 » /* Calculate doubling to compare against */ | 579 ecgroup); |
596 » ec_GFp_pt_dbl_jac(&ecgroup->genx, &ecgroup->geny, &pz, &rx2, &ry2, | 580 ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); |
597 » » » » » &rz2, ecgroup); | 581 |
598 » ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); | 582 /* Do comparison and check az^4 */ |
599 | 583 MP_CHECKOK(testJmPoint(&r, &rx2, &ry2, ecgroup)); |
600 » /* Do comparison and check az^4 */ | 584 |
601 » MP_CHECKOK(testJmPoint(&r, &rx2, &ry2, ecgroup)); | 585 CLEANUP: |
602 | 586 if (res == MP_OKAY) |
603 CLEANUP: | 587 printf(" Test Passed - Point Doubling - Modified Jacobian\n"); |
604 » if (res == MP_OKAY) | 588 else |
605 » » printf(" Test Passed - Point Doubling - Modified Jacobian\n"); | 589 printf("TEST FAILED - Point Doubling - Modified Jacobian\n"); |
606 » else | 590 mp_clear(&pz); |
607 » » printf("TEST FAILED - Point Doubling - Modified Jacobian\n"); | 591 mp_clear(&paz4); |
608 » mp_clear(&pz); | 592 mp_clear(&rx2); |
609 » mp_clear(&paz4); | 593 mp_clear(&ry2); |
610 » mp_clear(&rx2); | 594 mp_clear(&rz2); |
611 » mp_clear(&ry2); | 595 mp_clear(&raz4); |
612 » mp_clear(&rz2); | 596 |
613 » mp_clear(&raz4); | 597 return res; |
614 | |
615 » return res; | |
616 | |
617 } | 598 } |
618 | 599 |
619 /* Tests point doubling in Chudnovsky Jacobian coordinates */ | 600 /* Tests point doubling in Chudnovsky Jacobian coordinates */ |
620 mp_err | 601 mp_err testPointDoubleChud(ECGroup *ecgroup) { |
621 testPointDoubleChud(ECGroup *ecgroup) | 602 mp_err res; |
622 { | 603 mp_int px, py, pz, rx2, ry2, rz2; |
623 » mp_err res; | 604 ecfp_aff_pt p; |
624 » mp_int px, py, pz, rx2, ry2, rz2; | 605 ecfp_chud_pt p2; |
625 » ecfp_aff_pt p; | 606 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
626 » ecfp_chud_pt p2; | 607 |
627 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 608 MP_DIGITS(&rx2) = 0; |
628 | 609 MP_DIGITS(&ry2) = 0; |
629 » MP_DIGITS(&rx2) = 0; | 610 MP_DIGITS(&rz2) = 0; |
630 » MP_DIGITS(&ry2) = 0; | 611 MP_DIGITS(&px) = 0; |
631 » MP_DIGITS(&rz2) = 0; | 612 MP_DIGITS(&py) = 0; |
632 » MP_DIGITS(&px) = 0; | 613 MP_DIGITS(&pz) = 0; |
633 » MP_DIGITS(&py) = 0; | 614 |
634 » MP_DIGITS(&pz) = 0; | 615 MP_CHECKOK(mp_init(&rx2)); |
635 | 616 MP_CHECKOK(mp_init(&ry2)); |
636 » MP_CHECKOK(mp_init(&rx2)); | 617 MP_CHECKOK(mp_init(&rz2)); |
637 » MP_CHECKOK(mp_init(&ry2)); | 618 MP_CHECKOK(mp_init(&px)); |
638 » MP_CHECKOK(mp_init(&rz2)); | 619 MP_CHECKOK(mp_init(&py)); |
639 » MP_CHECKOK(mp_init(&px)); | 620 MP_CHECKOK(mp_init(&pz)); |
640 » MP_CHECKOK(mp_init(&py)); | 621 |
641 » MP_CHECKOK(mp_init(&pz)); | 622 /* Set p2 = 2P */ |
642 | 623 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
643 » /* Set p2 = 2P */ | 624 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
644 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 625 ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); |
645 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 626 |
646 » ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); | 627 group->pt_dbl_aff2chud(&p, &p2, group); |
647 | 628 |
648 » group->pt_dbl_aff2chud(&p, &p2, group); | 629 /* Calculate doubling to compare against */ |
649 | 630 MP_CHECKOK(mp_set_int(&pz, 1)); |
650 » /* Calculate doubling to compare against */ | 631 ec_GFp_pt_dbl_jac(&ecgroup->genx, &ecgroup->geny, &pz, &rx2, &ry2, &rz2, |
651 » MP_CHECKOK(mp_set_int(&pz, 1)); | 632 ecgroup); |
652 » ec_GFp_pt_dbl_jac(&ecgroup->genx, &ecgroup->geny, &pz, &rx2, &ry2, | 633 ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); |
653 » » » » » &rz2, ecgroup); | 634 |
654 » ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); | 635 /* Do comparison and check az^4 */ |
655 | 636 MP_CHECKOK(testChudPoint(&p2, &rx2, &ry2, ecgroup)); |
656 » /* Do comparison and check az^4 */ | 637 |
657 » MP_CHECKOK(testChudPoint(&p2, &rx2, &ry2, ecgroup)); | 638 CLEANUP: |
658 | 639 if (res == MP_OKAY) |
659 CLEANUP: | 640 printf(" Test Passed - Point Doubling - Chudnovsky Jacobian\n"); |
660 » if (res == MP_OKAY) | 641 else |
661 » » printf(" Test Passed - Point Doubling - Chudnovsky Jacobian\n")
; | 642 printf("TEST FAILED - Point Doubling - Chudnovsky Jacobian\n"); |
662 » else | 643 |
663 » » printf("TEST FAILED - Point Doubling - Chudnovsky Jacobian\n"); | 644 mp_clear(&rx2); |
664 | 645 mp_clear(&ry2); |
665 » mp_clear(&rx2); | 646 mp_clear(&rz2); |
666 » mp_clear(&ry2); | 647 mp_clear(&px); |
667 » mp_clear(&rz2); | 648 mp_clear(&py); |
668 » mp_clear(&px); | 649 mp_clear(&pz); |
669 » mp_clear(&py); | 650 |
670 » mp_clear(&pz); | 651 return res; |
671 | |
672 » return res; | |
673 } | 652 } |
674 | 653 |
675 /* Test point doubling in Jacobian coordinates */ | 654 /* Test point doubling in Jacobian coordinates */ |
676 mp_err | 655 mp_err testPointDoubleJac(ECGroup *ecgroup) { |
677 testPointDoubleJac(ECGroup *ecgroup) | 656 mp_err res; |
678 { | 657 mp_int pz, rx, ry, rz, rx2, ry2, rz2; |
679 » mp_err res; | 658 ecfp_jac_pt p, p2; |
680 » mp_int pz, rx, ry, rz, rx2, ry2, rz2; | 659 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
681 » ecfp_jac_pt p, p2; | 660 |
682 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 661 MP_DIGITS(&pz) = 0; |
683 | 662 MP_DIGITS(&rx) = 0; |
684 » MP_DIGITS(&pz) = 0; | 663 MP_DIGITS(&ry) = 0; |
685 » MP_DIGITS(&rx) = 0; | 664 MP_DIGITS(&rz) = 0; |
686 » MP_DIGITS(&ry) = 0; | 665 MP_DIGITS(&rx2) = 0; |
687 » MP_DIGITS(&rz) = 0; | 666 MP_DIGITS(&ry2) = 0; |
688 » MP_DIGITS(&rx2) = 0; | 667 MP_DIGITS(&rz2) = 0; |
689 » MP_DIGITS(&ry2) = 0; | 668 |
690 » MP_DIGITS(&rz2) = 0; | 669 MP_CHECKOK(mp_init(&pz)); |
691 | 670 MP_CHECKOK(mp_init(&rx)); |
692 » MP_CHECKOK(mp_init(&pz)); | 671 MP_CHECKOK(mp_init(&ry)); |
693 » MP_CHECKOK(mp_init(&rx)); | 672 MP_CHECKOK(mp_init(&rz)); |
694 » MP_CHECKOK(mp_init(&ry)); | 673 MP_CHECKOK(mp_init(&rx2)); |
695 » MP_CHECKOK(mp_init(&rz)); | 674 MP_CHECKOK(mp_init(&ry2)); |
696 » MP_CHECKOK(mp_init(&rx2)); | 675 MP_CHECKOK(mp_init(&rz2)); |
697 » MP_CHECKOK(mp_init(&ry2)); | 676 |
698 » MP_CHECKOK(mp_init(&rz2)); | 677 MP_CHECKOK(mp_set_int(&pz, 5)); |
699 | 678 |
700 » MP_CHECKOK(mp_set_int(&pz, 5)); | 679 /* Set p2 = 2P */ |
701 | 680 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
702 » /* Set p2 = 2P */ | 681 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
703 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 682 ecfp_i2fp(p.z, &pz, ecgroup); |
704 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 683 ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); |
705 » ecfp_i2fp(p.z, &pz, ecgroup); | 684 |
706 » ecfp_i2fp(group->curvea, &ecgroup->curvea, ecgroup); | 685 group->pt_dbl_jac(&p, &p2, group); |
707 | 686 M_TimeOperation(group->pt_dbl_jac(&p, &p2, group), 100000); |
708 » group->pt_dbl_jac(&p, &p2, group); | 687 |
709 » M_TimeOperation(group->pt_dbl_jac(&p, &p2, group), 100000); | 688 /* Calculate doubling to compare against */ |
710 | 689 ec_GFp_pt_dbl_jac(&ecgroup->genx, &ecgroup->geny, &pz, &rx2, &ry2, &rz2, |
711 » /* Calculate doubling to compare against */ | 690 ecgroup); |
712 » ec_GFp_pt_dbl_jac(&ecgroup->genx, &ecgroup->geny, &pz, &rx2, &ry2, | 691 ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); |
713 » » » » » &rz2, ecgroup); | 692 |
714 » ec_GFp_pt_jac2aff(&rx2, &ry2, &rz2, &rx2, &ry2, ecgroup); | 693 /* Do comparison */ |
715 | 694 MP_CHECKOK(testJacPoint(&p2, &rx2, &ry2, ecgroup)); |
716 » /* Do comparison */ | 695 |
717 » MP_CHECKOK(testJacPoint(&p2, &rx2, &ry2, ecgroup)); | 696 CLEANUP: |
718 | 697 if (res == MP_OKAY) |
719 CLEANUP: | 698 printf(" Test Passed - Point Doubling - Jacobian\n"); |
720 » if (res == MP_OKAY) | 699 else |
721 » » printf(" Test Passed - Point Doubling - Jacobian\n"); | 700 printf("TEST FAILED - Point Doubling - Jacobian\n"); |
722 » else | 701 |
723 » » printf("TEST FAILED - Point Doubling - Jacobian\n"); | 702 mp_clear(&pz); |
724 | 703 mp_clear(&rx); |
725 » mp_clear(&pz); | 704 mp_clear(&ry); |
726 » mp_clear(&rx); | 705 mp_clear(&rz); |
727 » mp_clear(&ry); | 706 mp_clear(&rx2); |
728 » mp_clear(&rz); | 707 mp_clear(&ry2); |
729 » mp_clear(&rx2); | 708 mp_clear(&rz2); |
730 » mp_clear(&ry2); | 709 |
731 » mp_clear(&rz2); | 710 return res; |
732 | |
733 » return res; | |
734 } | 711 } |
735 | 712 |
736 /* Tests a point multiplication (various algorithms) */ | 713 /* Tests a point multiplication (various algorithms) */ |
737 mp_err | 714 mp_err testPointMul(ECGroup *ecgroup) { |
738 testPointMul(ECGroup *ecgroup) | 715 mp_err res; |
739 { | 716 char s[1000]; |
740 » mp_err res; | 717 mp_int rx, ry, order_1; |
741 » char s[1000]; | 718 |
742 » mp_int rx, ry, order_1; | 719 /* Init */ |
743 | 720 MP_DIGITS(&rx) = 0; |
744 » /* Init */ | 721 MP_DIGITS(&ry) = 0; |
745 » MP_DIGITS(&rx) = 0; | 722 MP_DIGITS(&order_1) = 0; |
746 » MP_DIGITS(&ry) = 0; | 723 |
747 » MP_DIGITS(&order_1) = 0; | 724 MP_CHECKOK(mp_init(&rx)); |
748 | 725 MP_CHECKOK(mp_init(&ry)); |
749 » MP_CHECKOK(mp_init(&rx)); | 726 MP_CHECKOK(mp_init(&order_1)); |
750 » MP_CHECKOK(mp_init(&ry)); | 727 |
751 » MP_CHECKOK(mp_init(&order_1)); | 728 MP_CHECKOK(mp_set_int(&order_1, 1)); |
752 | 729 MP_CHECKOK(mp_sub(&ecgroup->order, &order_1, &order_1)); |
753 » MP_CHECKOK(mp_set_int(&order_1, 1)); | 730 |
754 » MP_CHECKOK(mp_sub(&ecgroup->order, &order_1, &order_1)); | 731 /* Test Algorithm 1: Jacobian-Affine Double & Add */ |
755 | 732 ec_GFp_pt_mul_jac_fp(&order_1, &ecgroup->genx, &ecgroup->geny, &rx, &ry, |
756 » /* Test Algorithm 1: Jacobian-Affine Double & Add */ | 733 ecgroup); |
757 » ec_GFp_pt_mul_jac_fp(&order_1, &ecgroup->genx, &ecgroup->geny, &rx, | 734 MP_CHECKOK(ecgroup->meth->field_neg(&ry, &ry, ecgroup->meth)); |
758 » » » » » » &ry, ecgroup); | 735 if ((mp_cmp(&rx, &ecgroup->genx) != 0) || |
759 » MP_CHECKOK(ecgroup->meth->field_neg(&ry, &ry, ecgroup->meth)); | 736 (mp_cmp(&ry, &ecgroup->geny) != 0)) { |
760 » if ((mp_cmp(&rx, &ecgroup->genx) != 0) | 737 printf( |
761 » » || (mp_cmp(&ry, &ecgroup->geny) != 0)) { | 738 " Error: ec_GFp_pt_mul_jac_fp invalid result (expected (- base " |
762 » » printf | 739 "point)).\n"); |
763 » » » (" Error: ec_GFp_pt_mul_jac_fp invalid result (expected
(- base point)).\n"); | 740 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
764 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 741 printf("rx %s\n", s); |
765 » » printf("rx %s\n", s); | 742 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
766 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 743 printf("ry %s\n", s); |
767 » » printf("ry %s\n", s); | 744 res = MP_NO; |
768 » » res = MP_NO; | 745 goto CLEANUP; |
769 » » goto CLEANUP; | 746 } |
770 » } | 747 |
771 | 748 ec_GFp_pt_mul_jac_fp(&ecgroup->order, &ecgroup->genx, &ecgroup->geny, &rx, |
772 » ec_GFp_pt_mul_jac_fp(&ecgroup->order, &ecgroup->genx, &ecgroup->geny, | 749 &ry, ecgroup); |
773 » » » » » » &rx, &ry, ecgroup); | 750 if (ec_GFp_pt_is_inf_aff(&rx, &ry) != MP_YES) { |
774 » if (ec_GFp_pt_is_inf_aff(&rx, &ry) != MP_YES) { | 751 printf( |
775 » » printf | 752 " Error: ec_GFp_pt_mul_jac_fp invalid result (expected point at " |
776 » » » (" Error: ec_GFp_pt_mul_jac_fp invalid result (expected
point at infinity.\n"); | 753 "infinity.\n"); |
777 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 754 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
778 » » printf("rx %s\n", s); | 755 printf("rx %s\n", s); |
779 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 756 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
780 » » printf("ry %s\n", s); | 757 printf("ry %s\n", s); |
781 » » res = MP_NO; | 758 res = MP_NO; |
782 » » goto CLEANUP; | 759 goto CLEANUP; |
783 » } | 760 } |
784 | 761 |
785 » /* Test Algorithm 2: 4-bit Window in Jacobian */ | 762 /* Test Algorithm 2: 4-bit Window in Jacobian */ |
786 » ec_GFp_point_mul_jac_4w_fp(&order_1, &ecgroup->genx, &ecgroup->geny, | 763 ec_GFp_point_mul_jac_4w_fp(&order_1, &ecgroup->genx, &ecgroup->geny, &rx, &ry, |
787 » » » » » » » &rx, &ry, ecgroup); | 764 ecgroup); |
788 » MP_CHECKOK(ecgroup->meth->field_neg(&ry, &ry, ecgroup->meth)); | 765 MP_CHECKOK(ecgroup->meth->field_neg(&ry, &ry, ecgroup->meth)); |
789 » if ((mp_cmp(&rx, &ecgroup->genx) != 0) | 766 if ((mp_cmp(&rx, &ecgroup->genx) != 0) || |
790 » » || (mp_cmp(&ry, &ecgroup->geny) != 0)) { | 767 (mp_cmp(&ry, &ecgroup->geny) != 0)) { |
791 » » printf | 768 printf( |
792 » » » (" Error: ec_GFp_point_mul_jac_4w_fp invalid result (ex
pected (- base point)).\n"); | 769 " Error: ec_GFp_point_mul_jac_4w_fp invalid result (expected (- " |
793 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 770 "base point)).\n"); |
794 » » printf("rx %s\n", s); | 771 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
795 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 772 printf("rx %s\n", s); |
796 » » printf("ry %s\n", s); | 773 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
797 » » res = MP_NO; | 774 printf("ry %s\n", s); |
798 » » goto CLEANUP; | 775 res = MP_NO; |
799 » } | 776 goto CLEANUP; |
800 | 777 } |
801 » ec_GFp_point_mul_jac_4w_fp(&ecgroup->order, &ecgroup->genx, | 778 |
802 » » » » » » » &ecgroup->geny, &rx,
&ry, ecgroup); | 779 ec_GFp_point_mul_jac_4w_fp(&ecgroup->order, &ecgroup->genx, &ecgroup->geny, |
803 » if (ec_GFp_pt_is_inf_aff(&rx, &ry) != MP_YES) { | 780 &rx, &ry, ecgroup); |
804 » » printf | 781 if (ec_GFp_pt_is_inf_aff(&rx, &ry) != MP_YES) { |
805 » » » (" Error: ec_GFp_point_mul_jac_4w_fp invalid result (ex
pected point at infinity.\n"); | 782 printf( |
806 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 783 " Error: ec_GFp_point_mul_jac_4w_fp invalid result (expected point " |
807 » » printf("rx %s\n", s); | 784 "at infinity.\n"); |
808 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 785 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
809 » » printf("ry %s\n", s); | 786 printf("rx %s\n", s); |
810 » » res = MP_NO; | 787 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
811 » » goto CLEANUP; | 788 printf("ry %s\n", s); |
812 » } | 789 res = MP_NO; |
813 | 790 goto CLEANUP; |
814 » /* Test Algorithm 3: wNAF with modified Jacobian coordinates */ | 791 } |
815 » ec_GFp_point_mul_wNAF_fp(&order_1, &ecgroup->genx, &ecgroup->geny, &rx, | 792 |
816 » » » » » » » &ry, ecgroup); | 793 /* Test Algorithm 3: wNAF with modified Jacobian coordinates */ |
817 » MP_CHECKOK(ecgroup->meth->field_neg(&ry, &ry, ecgroup->meth)); | 794 ec_GFp_point_mul_wNAF_fp(&order_1, &ecgroup->genx, &ecgroup->geny, &rx, &ry, |
818 » if ((mp_cmp(&rx, &ecgroup->genx) != 0) | 795 ecgroup); |
819 » » || (mp_cmp(&ry, &ecgroup->geny) != 0)) { | 796 MP_CHECKOK(ecgroup->meth->field_neg(&ry, &ry, ecgroup->meth)); |
820 » » printf | 797 if ((mp_cmp(&rx, &ecgroup->genx) != 0) || |
821 » » » (" Error: ec_GFp_pt_mul_wNAF_fp invalid result (expecte
d (- base point)).\n"); | 798 (mp_cmp(&ry, &ecgroup->geny) != 0)) { |
822 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 799 printf( |
823 » » printf("rx %s\n", s); | 800 " Error: ec_GFp_pt_mul_wNAF_fp invalid result (expected (- base " |
824 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 801 "point)).\n"); |
825 » » printf("ry %s\n", s); | 802 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
826 » » res = MP_NO; | 803 printf("rx %s\n", s); |
827 » » goto CLEANUP; | 804 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
828 » } | 805 printf("ry %s\n", s); |
829 | 806 res = MP_NO; |
830 » ec_GFp_point_mul_wNAF_fp(&ecgroup->order, &ecgroup->genx, | 807 goto CLEANUP; |
831 » » » » » » » &ecgroup->geny, &rx, &r
y, ecgroup); | 808 } |
832 » if (ec_GFp_pt_is_inf_aff(&rx, &ry) != MP_YES) { | 809 |
833 » » printf | 810 ec_GFp_point_mul_wNAF_fp(&ecgroup->order, &ecgroup->genx, &ecgroup->geny, &rx, |
834 » » » (" Error: ec_GFp_pt_mul_wNAF_fp invalid result (expecte
d point at infinity.\n"); | 811 &ry, ecgroup); |
835 » » MP_CHECKOK(mp_toradix(&rx, s, 16)); | 812 if (ec_GFp_pt_is_inf_aff(&rx, &ry) != MP_YES) { |
836 » » printf("rx %s\n", s); | 813 printf( |
837 » » MP_CHECKOK(mp_toradix(&ry, s, 16)); | 814 " Error: ec_GFp_pt_mul_wNAF_fp invalid result (expected point at " |
838 » » printf("ry %s\n", s); | 815 "infinity.\n"); |
839 » » res = MP_NO; | 816 MP_CHECKOK(mp_toradix(&rx, s, 16)); |
840 » » goto CLEANUP; | 817 printf("rx %s\n", s); |
841 » } | 818 MP_CHECKOK(mp_toradix(&ry, s, 16)); |
842 | 819 printf("ry %s\n", s); |
843 CLEANUP: | 820 res = MP_NO; |
844 » if (res == MP_OKAY) | 821 goto CLEANUP; |
845 » » printf(" Test Passed - Point Multiplication\n"); | 822 } |
846 » else | 823 |
847 » » printf("TEST FAILED - Point Multiplication\n"); | 824 CLEANUP: |
848 » mp_clear(&rx); | 825 if (res == MP_OKAY) |
849 » mp_clear(&ry); | 826 printf(" Test Passed - Point Multiplication\n"); |
850 » mp_clear(&order_1); | 827 else |
851 | 828 printf("TEST FAILED - Point Multiplication\n"); |
852 » return res; | 829 mp_clear(&rx); |
| 830 mp_clear(&ry); |
| 831 mp_clear(&order_1); |
| 832 |
| 833 return res; |
853 } | 834 } |
854 | 835 |
855 /* Tests point multiplication with a random scalar repeatedly, comparing | 836 /* Tests point multiplication with a random scalar repeatedly, comparing |
856 * for consistency within different algorithms. */ | 837 * for consistency within different algorithms. */ |
857 mp_err | 838 mp_err testPointMulRandom(ECGroup *ecgroup) { |
858 testPointMulRandom(ECGroup *ecgroup) | 839 mp_err res; |
859 { | 840 mp_int rx, ry, rx2, ry2, n; |
860 » mp_err res; | 841 int i, size; |
861 » mp_int rx, ry, rx2, ry2, n; | 842 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
862 » int i, size; | 843 |
863 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 844 MP_DIGITS(&rx) = 0; |
864 | 845 MP_DIGITS(&ry) = 0; |
865 » MP_DIGITS(&rx) = 0; | 846 MP_DIGITS(&rx2) = 0; |
866 » MP_DIGITS(&ry) = 0; | 847 MP_DIGITS(&ry2) = 0; |
867 » MP_DIGITS(&rx2) = 0; | 848 MP_DIGITS(&n) = 0; |
868 » MP_DIGITS(&ry2) = 0; | 849 |
869 » MP_DIGITS(&n) = 0; | 850 MP_CHECKOK(mp_init(&rx)); |
870 | 851 MP_CHECKOK(mp_init(&ry)); |
871 » MP_CHECKOK(mp_init(&rx)); | 852 MP_CHECKOK(mp_init(&rx2)); |
872 » MP_CHECKOK(mp_init(&ry)); | 853 MP_CHECKOK(mp_init(&ry2)); |
873 » MP_CHECKOK(mp_init(&rx2)); | 854 MP_CHECKOK(mp_init(&n)); |
874 » MP_CHECKOK(mp_init(&ry2)); | 855 |
875 » MP_CHECKOK(mp_init(&n)); | 856 for (i = 0; i < 100; i++) { |
876 | 857 /* compute random scalar */ |
877 » for (i = 0; i < 100; i++) { | 858 size = mpl_significant_bits(&ecgroup->meth->irr); |
878 » » /* compute random scalar */ | 859 if (size < MP_OKAY) { |
879 » » size = mpl_significant_bits(&ecgroup->meth->irr); | 860 res = MP_NO; |
880 » » if (size < MP_OKAY) { | 861 goto CLEANUP; |
881 » » » res = MP_NO; | 862 } |
882 » » » goto CLEANUP; | 863 MP_CHECKOK(mpp_random_size(&n, group->orderBitSize)); |
883 » » } | 864 MP_CHECKOK(mp_mod(&n, &ecgroup->order, &n)); |
884 » » MP_CHECKOK(mpp_random_size(&n, group->orderBitSize)); | 865 |
885 » » MP_CHECKOK(mp_mod(&n, &ecgroup->order, &n)); | 866 ec_GFp_pt_mul_jac(&n, &ecgroup->genx, &ecgroup->geny, &rx, &ry, ecgroup); |
886 | 867 ec_GFp_pt_mul_jac_fp(&n, &ecgroup->genx, &ecgroup->geny, &rx2, &ry2, |
887 » » ec_GFp_pt_mul_jac(&n, &ecgroup->genx, &ecgroup->geny, &rx, &ry, | 868 ecgroup); |
888 » » » » » » ecgroup); | 869 |
889 » » ec_GFp_pt_mul_jac_fp(&n, &ecgroup->genx, &ecgroup->geny, &rx2, | 870 if ((mp_cmp(&rx, &rx2) != 0) || (mp_cmp(&ry, &ry2) != 0)) { |
890 » » » » » » » &ry2, ecgroup); | 871 printf( |
891 | 872 " Error: different results for Point Multiplication - Double & " |
892 » » if ((mp_cmp(&rx, &rx2) != 0) || (mp_cmp(&ry, &ry2) != 0)) { | 873 "Add.\n"); |
893 » » » printf | 874 res = MP_NO; |
894 » » » » (" Error: different results for Point Multiplic
ation - Double & Add.\n"); | 875 goto CLEANUP; |
895 » » » res = MP_NO; | 876 } |
896 » » » goto CLEANUP; | 877 |
897 » » } | 878 ec_GFp_point_mul_wNAF_fp(&n, &ecgroup->genx, &ecgroup->geny, &rx, &ry, |
898 | 879 ecgroup); |
899 » » ec_GFp_point_mul_wNAF_fp(&n, &ecgroup->genx, &ecgroup->geny, &rx
, | 880 if ((mp_cmp(&rx, &rx2) != 0) || (mp_cmp(&ry, &ry2) != 0)) { |
900 » » » » » » » » &ry, ecgroup); | 881 printf(" Error: different results for Point Multiplication - wNAF.\n"); |
901 » » if ((mp_cmp(&rx, &rx2) != 0) || (mp_cmp(&ry, &ry2) != 0)) { | 882 res = MP_NO; |
902 » » » printf | 883 goto CLEANUP; |
903 » » » » (" Error: different results for Point Multiplic
ation - wNAF.\n"); | 884 } |
904 » » » res = MP_NO; | 885 |
905 » » » goto CLEANUP; | 886 ec_GFp_point_mul_jac_4w_fp(&n, &ecgroup->genx, &ecgroup->geny, &rx, &ry, |
906 » » } | 887 ecgroup); |
907 | 888 if ((mp_cmp(&rx, &rx2) != 0) || (mp_cmp(&ry, &ry2) != 0)) { |
908 » » ec_GFp_point_mul_jac_4w_fp(&n, &ecgroup->genx, &ecgroup->geny, &
rx, | 889 printf( |
909 » » » » » » » » &ry, ecgroup)
; | 890 " Error: different results for Point Multiplication - 4 bit " |
910 » » if ((mp_cmp(&rx, &rx2) != 0) || (mp_cmp(&ry, &ry2) != 0)) { | 891 "window.\n"); |
911 » » » printf | 892 res = MP_NO; |
912 » » » » (" Error: different results for Point Multiplic
ation - 4 bit window.\n"); | 893 goto CLEANUP; |
913 » » » res = MP_NO; | 894 } |
914 » » » goto CLEANUP; | 895 } |
915 » » } | 896 |
916 | 897 CLEANUP: |
917 » } | 898 if (res == MP_OKAY) |
918 | 899 printf(" Test Passed - Point Random Multiplication\n"); |
919 CLEANUP: | 900 else |
920 » if (res == MP_OKAY) | 901 printf("TEST FAILED - Point Random Multiplication\n"); |
921 » » printf(" Test Passed - Point Random Multiplication\n"); | 902 mp_clear(&rx); |
922 » else | 903 mp_clear(&ry); |
923 » » printf("TEST FAILED - Point Random Multiplication\n"); | 904 mp_clear(&rx2); |
924 » mp_clear(&rx); | 905 mp_clear(&ry2); |
925 » mp_clear(&ry); | 906 mp_clear(&n); |
926 » mp_clear(&rx2); | 907 |
927 » mp_clear(&ry2); | 908 return res; |
928 » mp_clear(&n); | |
929 | |
930 » return res; | |
931 } | 909 } |
932 | 910 |
933 /* Tests the time required for a point multiplication */ | 911 /* Tests the time required for a point multiplication */ |
934 mp_err | 912 mp_err testPointMulTime(ECGroup *ecgroup) { |
935 testPointMulTime(ECGroup *ecgroup) | 913 mp_err res = MP_OKAY; |
936 { | 914 mp_int rx, ry, n; |
937 » mp_err res = MP_OKAY; | 915 int size; |
938 » mp_int rx, ry, n; | 916 |
939 » int size; | 917 MP_DIGITS(&rx) = 0; |
940 | 918 MP_DIGITS(&ry) = 0; |
941 » MP_DIGITS(&rx) = 0; | 919 MP_DIGITS(&n) = 0; |
942 » MP_DIGITS(&ry) = 0; | 920 |
943 » MP_DIGITS(&n) = 0; | 921 MP_CHECKOK(mp_init(&rx)); |
944 | 922 MP_CHECKOK(mp_init(&ry)); |
945 » MP_CHECKOK(mp_init(&rx)); | 923 MP_CHECKOK(mp_init(&n)); |
946 » MP_CHECKOK(mp_init(&ry)); | 924 |
947 » MP_CHECKOK(mp_init(&n)); | 925 /* compute random scalar */ |
948 | 926 size = mpl_significant_bits(&ecgroup->meth->irr); |
949 » /* compute random scalar */ | 927 if (size < MP_OKAY) { |
950 » size = mpl_significant_bits(&ecgroup->meth->irr); | 928 res = MP_NO; |
951 » if (size < MP_OKAY) { | 929 goto CLEANUP; |
952 » » res = MP_NO; | 930 } |
953 » » goto CLEANUP; | 931 |
954 » } | 932 MP_CHECKOK(mpp_random_size(&n, (size + ECL_BITS - 1) / ECL_BITS)); |
955 | 933 MP_CHECKOK(ecgroup->meth->field_mod(&n, &n, ecgroup->meth)); |
956 » MP_CHECKOK(mpp_random_size(&n, (size + ECL_BITS - 1) / ECL_BITS)); | 934 |
957 » MP_CHECKOK(ecgroup->meth->field_mod(&n, &n, ecgroup->meth)); | 935 M_TimeOperation(ec_GFp_pt_mul_jac_fp(&n, &ecgroup->genx, &ecgroup->geny, &rx, |
958 | 936 &ry, ecgroup), |
959 » M_TimeOperation(ec_GFp_pt_mul_jac_fp | 937 1000); |
960 » » » » » (&n, &ecgroup->genx, &ecgroup->geny, &rx
, &ry, | 938 |
961 » » » » » ecgroup), 1000); | 939 M_TimeOperation(ec_GFp_point_mul_jac_4w_fp(&n, &ecgroup->genx, &ecgroup->geny, |
962 | 940 &rx, &ry, ecgroup), |
963 » M_TimeOperation(ec_GFp_point_mul_jac_4w_fp | 941 1000); |
964 » » » » » (&n, &ecgroup->genx, &ecgroup->geny, &rx
, &ry, | 942 |
965 » » » » » ecgroup), 1000); | 943 M_TimeOperation(ec_GFp_point_mul_wNAF_fp(&n, &ecgroup->genx, &ecgroup->geny, |
966 | 944 &rx, &ry, ecgroup), |
967 » M_TimeOperation(ec_GFp_point_mul_wNAF_fp | 945 1000); |
968 » » » » » (&n, &ecgroup->genx, &ecgroup->geny, &rx
, &ry, | 946 |
969 » » » » » ecgroup), 1000); | 947 M_TimeOperation( |
970 | 948 ec_GFp_pt_mul_jac(&n, &ecgroup->genx, &ecgroup->geny, &rx, &ry, ecgroup), |
971 » M_TimeOperation(ec_GFp_pt_mul_jac | 949 100); |
972 » » » » » (&n, &ecgroup->genx, &ecgroup->geny, &rx
, &ry, | 950 |
973 » » » » » ecgroup), 100); | 951 CLEANUP: |
974 | 952 if (res == MP_OKAY) |
975 CLEANUP: | 953 printf(" Test Passed - Point Multiplication Timing\n"); |
976 » if (res == MP_OKAY) | 954 else |
977 » » printf(" Test Passed - Point Multiplication Timing\n"); | 955 printf("TEST FAILED - Point Multiplication Timing\n"); |
978 » else | 956 mp_clear(&rx); |
979 » » printf("TEST FAILED - Point Multiplication Timing\n"); | 957 mp_clear(&ry); |
980 » mp_clear(&rx); | 958 mp_clear(&n); |
981 » mp_clear(&ry); | 959 |
982 » mp_clear(&n); | 960 return res; |
983 | |
984 » return res; | |
985 } | 961 } |
986 | 962 |
987 /* Tests pre computation of Chudnovsky Jacobian points used in wNAF form */ | 963 /* Tests pre computation of Chudnovsky Jacobian points used in wNAF form */ |
988 mp_err | 964 mp_err testPreCompute(ECGroup *ecgroup) { |
989 testPreCompute(ECGroup *ecgroup) | 965 ecfp_chud_pt precomp[16]; |
990 { | 966 ecfp_aff_pt p; |
991 » ecfp_chud_pt precomp[16]; | 967 EC_group_fp *group = (EC_group_fp *)ecgroup->extra1; |
992 » ecfp_aff_pt p; | 968 int i; |
993 » EC_group_fp *group = (EC_group_fp *) ecgroup->extra1; | 969 mp_err res; |
994 » int i; | 970 |
995 » mp_err res; | 971 mp_int x, y, ny, x2, y2; |
996 | 972 |
997 » mp_int x, y, ny, x2, y2; | 973 MP_DIGITS(&x) = 0; |
998 | 974 MP_DIGITS(&y) = 0; |
999 » MP_DIGITS(&x) = 0; | 975 MP_DIGITS(&ny) = 0; |
1000 » MP_DIGITS(&y) = 0; | 976 MP_DIGITS(&x2) = 0; |
1001 » MP_DIGITS(&ny) = 0; | 977 MP_DIGITS(&y2) = 0; |
1002 » MP_DIGITS(&x2) = 0; | 978 |
1003 » MP_DIGITS(&y2) = 0; | 979 MP_CHECKOK(mp_init(&x)); |
1004 | 980 MP_CHECKOK(mp_init(&y)); |
1005 » MP_CHECKOK(mp_init(&x)); | 981 MP_CHECKOK(mp_init(&ny)); |
1006 » MP_CHECKOK(mp_init(&y)); | 982 MP_CHECKOK(mp_init(&x2)); |
1007 » MP_CHECKOK(mp_init(&ny)); | 983 MP_CHECKOK(mp_init(&y2)); |
1008 » MP_CHECKOK(mp_init(&x2)); | 984 |
1009 » MP_CHECKOK(mp_init(&y2)); | 985 ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); |
1010 | 986 ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); |
1011 » ecfp_i2fp(p.x, &ecgroup->genx, ecgroup); | 987 ecfp_i2fp(group->curvea, &(ecgroup->curvea), ecgroup); |
1012 » ecfp_i2fp(p.y, &ecgroup->geny, ecgroup); | 988 |
1013 » ecfp_i2fp(group->curvea, &(ecgroup->curvea), ecgroup); | 989 /* Perform precomputation */ |
1014 | 990 group->precompute_chud(precomp, &p, group); |
1015 » /* Perform precomputation */ | 991 |
1016 » group->precompute_chud(precomp, &p, group); | 992 M_TimeOperation(group->precompute_chud(precomp, &p, group), 10000); |
1017 | 993 |
1018 » M_TimeOperation(group->precompute_chud(precomp, &p, group), 10000); | 994 /* Calculate addition to compare against */ |
1019 | 995 MP_CHECKOK(mp_copy(&ecgroup->genx, &x)); |
1020 » /* Calculate addition to compare against */ | 996 MP_CHECKOK(mp_copy(&ecgroup->geny, &y)); |
1021 » MP_CHECKOK(mp_copy(&ecgroup->genx, &x)); | 997 MP_CHECKOK(ecgroup->meth->field_neg(&y, &ny, ecgroup->meth)); |
1022 » MP_CHECKOK(mp_copy(&ecgroup->geny, &y)); | 998 |
1023 » MP_CHECKOK(ecgroup->meth->field_neg(&y, &ny, ecgroup->meth)); | 999 ec_GFp_pt_dbl_aff(&x, &y, &x2, &y2, ecgroup); |
1024 | 1000 |
1025 » ec_GFp_pt_dbl_aff(&x, &y, &x2, &y2, ecgroup); | 1001 for (i = 0; i < 8; i++) { |
1026 | 1002 MP_CHECKOK(testChudPoint(&precomp[8 + i], &x, &y, ecgroup)); |
1027 » for (i = 0; i < 8; i++) { | 1003 MP_CHECKOK(testChudPoint(&precomp[7 - i], &x, &ny, ecgroup)); |
1028 » » MP_CHECKOK(testChudPoint(&precomp[8 + i], &x, &y, ecgroup)); | 1004 ec_GFp_pt_add_aff(&x, &y, &x2, &y2, &x, &y, ecgroup); |
1029 » » MP_CHECKOK(testChudPoint(&precomp[7 - i], &x, &ny, ecgroup)); | 1005 MP_CHECKOK(ecgroup->meth->field_neg(&y, &ny, ecgroup->meth)); |
1030 » » ec_GFp_pt_add_aff(&x, &y, &x2, &y2, &x, &y, ecgroup); | 1006 } |
1031 » » MP_CHECKOK(ecgroup->meth->field_neg(&y, &ny, ecgroup->meth)); | 1007 |
1032 » } | 1008 CLEANUP: |
1033 | 1009 if (res == MP_OKAY) |
1034 CLEANUP: | 1010 printf(" Test Passed - Precomputation\n"); |
1035 » if (res == MP_OKAY) | 1011 else |
1036 » » printf(" Test Passed - Precomputation\n"); | 1012 printf("TEST FAILED - Precomputation\n"); |
1037 » else | 1013 |
1038 » » printf("TEST FAILED - Precomputation\n"); | 1014 mp_clear(&x); |
1039 | 1015 mp_clear(&y); |
1040 » mp_clear(&x); | 1016 mp_clear(&ny); |
1041 » mp_clear(&y); | 1017 mp_clear(&x2); |
1042 » mp_clear(&ny); | 1018 mp_clear(&y2); |
1043 » mp_clear(&x2); | 1019 return res; |
1044 » mp_clear(&y2); | |
1045 » return res; | |
1046 } | 1020 } |
1047 | 1021 |
1048 /* Given a curve using floating point arithmetic, test it. This method | 1022 /* Given a curve using floating point arithmetic, test it. This method |
1049 * specifies which of the above tests to run. */ | 1023 * specifies which of the above tests to run. */ |
1050 mp_err | 1024 mp_err testCurve(ECGroup *ecgroup) { |
1051 testCurve(ECGroup *ecgroup) | 1025 int res = MP_OKAY; |
1052 { | 1026 |
1053 » int res = MP_OKAY; | 1027 MP_CHECKOK(testPointAddJacAff(ecgroup)); |
1054 | 1028 MP_CHECKOK(testPointAddJac(ecgroup)); |
1055 » MP_CHECKOK(testPointAddJacAff(ecgroup)); | 1029 MP_CHECKOK(testPointAddChud(ecgroup)); |
1056 » MP_CHECKOK(testPointAddJac(ecgroup)); | 1030 MP_CHECKOK(testPointAddJmChud(ecgroup)); |
1057 » MP_CHECKOK(testPointAddChud(ecgroup)); | 1031 MP_CHECKOK(testPointDoubleJac(ecgroup)); |
1058 » MP_CHECKOK(testPointAddJmChud(ecgroup)); | 1032 MP_CHECKOK(testPointDoubleChud(ecgroup)); |
1059 » MP_CHECKOK(testPointDoubleJac(ecgroup)); | 1033 MP_CHECKOK(testPointDoubleJm(ecgroup)); |
1060 » MP_CHECKOK(testPointDoubleChud(ecgroup)); | 1034 MP_CHECKOK(testPreCompute(ecgroup)); |
1061 » MP_CHECKOK(testPointDoubleJm(ecgroup)); | 1035 MP_CHECKOK(testPointMul(ecgroup)); |
1062 » MP_CHECKOK(testPreCompute(ecgroup)); | 1036 MP_CHECKOK(testPointMulRandom(ecgroup)); |
1063 » MP_CHECKOK(testPointMul(ecgroup)); | 1037 MP_CHECKOK(testPointMulTime(ecgroup)); |
1064 » MP_CHECKOK(testPointMulRandom(ecgroup)); | 1038 CLEANUP: |
1065 » MP_CHECKOK(testPointMulTime(ecgroup)); | 1039 return res; |
1066 CLEANUP: | |
1067 » return res; | |
1068 } | 1040 } |
1069 | 1041 |
1070 /* Tests a number of curves optimized using floating point arithmetic */ | 1042 /* Tests a number of curves optimized using floating point arithmetic */ |
1071 int | 1043 int main(void) { |
1072 main(void) | 1044 mp_err res = MP_OKAY; |
1073 { | 1045 ECGroup *ecgroup = NULL; |
1074 » mp_err res = MP_OKAY; | 1046 |
1075 » ECGroup *ecgroup = NULL; | 1047 /* specific arithmetic tests */ |
1076 | 1048 M_TestCurve("SECG-160R1", ECCurve_SECG_PRIME_160R1); |
1077 » /* specific arithmetic tests */ | 1049 M_TestCurve("SECG-192R1", ECCurve_SECG_PRIME_192R1); |
1078 » M_TestCurve("SECG-160R1", ECCurve_SECG_PRIME_160R1); | 1050 M_TestCurve("SEGC-224R1", ECCurve_SECG_PRIME_224R1); |
1079 » M_TestCurve("SECG-192R1", ECCurve_SECG_PRIME_192R1); | 1051 |
1080 » M_TestCurve("SEGC-224R1", ECCurve_SECG_PRIME_224R1); | 1052 CLEANUP: |
1081 | 1053 ECGroup_free(ecgroup); |
1082 CLEANUP: | 1054 if (res != MP_OKAY) { |
1083 » ECGroup_free(ecgroup); | 1055 printf("Error: exiting with error value %i\n", res); |
1084 » if (res != MP_OKAY) { | 1056 } |
1085 » » printf("Error: exiting with error value %i\n", res); | 1057 return res; |
1086 » } | 1058 } |
1087 » return res; | |
1088 } | |
OLD | NEW |