?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / common / crypto / ecc / ec2_test.c
blobe2b4bb558e5d69e25737e2bb40a8d5dde60b6323
1 /*
2 * ***** BEGIN LICENSE BLOCK *****
3 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4 *
5 * The contents of this file are subject to the Mozilla Public License Version
6 * 1.1 (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 * http://www.mozilla.org/MPL/
9 *
10 * Software distributed under the License is distributed on an "AS IS" basis,
11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 * for the specific language governing rights and limitations under the
13 * License.
14 *
15 * The Original Code is the elliptic curve math library for binary polynomial field curves.
16 *
17 * The Initial Developer of the Original Code is
18 * Sun Microsystems, Inc.
19 * Portions created by the Initial Developer are Copyright (C) 2003
20 * the Initial Developer. All Rights Reserved.
21 *
22 * Contributor(s):
23 * Douglas Stebila <douglas@stebila.ca>, Sun Microsystems Laboratories
24 *
25 * Alternatively, the contents of this file may be used under the terms of
26 * either the GNU General Public License Version 2 or later (the "GPL"), or
27 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
28 * in which case the provisions of the GPL or the LGPL are applicable instead
29 * of those above. If you wish to allow use of your version of this file only
30 * under the terms of either the GPL or the LGPL, and not to allow others to
31 * use your version of this file under the terms of the MPL, indicate your
32 * decision by deleting the provisions above and replace them with the notice
33 * and other provisions required by the GPL or the LGPL. If you do not delete
34 * the provisions above, a recipient may use your version of this file under
35 * the terms of any one of the MPL, the GPL or the LGPL.
36 *
37 * ***** END LICENSE BLOCK ***** */
38 /*
39 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
40 * Use is subject to license terms.
41 *
42 * Sun elects to use this software under the MPL license.
43 */
44
45 #pragma ident "%Z%%M% %I% %E% SMI"
46
47 #ifdef _KERNEL
48 #include <sys/types.h>
49 #include <sys/systm.h>
50 #include <sys/param.h>
51 #include <sys/modctl.h>
52 #include <sys/ddi.h>
53 #include <sys/crypto/spi.h>
54 #include <sys/sysmacros.h>
55 #include <sys/strsun.h>
56 #include <sys/md5.h>
57 #include <sys/sha1.h>
58 #include <sys/sha2.h>
59 #include <sys/random.h>
60 #include <sys/conf.h>
61 #include <sys/devops.h>
62 #include <sys/sunddi.h>
63 #include <sys/varargs.h>
64 #include <sys/kmem.h>
65 #include <sys/kstat.h>
66 #include <sys/crypto/common.h>
67 #else
68 #include <stdio.h>
69 #include <string.h>
70 #include <strings.h>
71 #include <assert.h>
72 #include <time.h>
73 #include <sys/time.h>
74 #include <sys/resource.h>
75 #endif /* _KERNEL */
76
77 #include "mpi.h"
78 #include "mplogic.h"
79 #include "mpprime.h"
80 #include "mp_gf2m.h"
81 #include "ecl.h"
82 #include "ecl-curve.h"
83 #include "ec2.h"
84 #include "ecc_impl.h"
85 #include "ec.h"
86
87 #ifndef KM_SLEEP
88 #define KM_SLEEP 0
89 #endif
90
91 #ifndef _KERNEL
92 /* Time k repetitions of operation op. */
93 #define M_TimeOperation(op, k) { \
94 double dStart, dNow, dUserTime; \
95 struct rusage ru; \
96 int i; \
97 getrusage(RUSAGE_SELF, &ru); \
98 dStart = (double)ru.ru_utime.tv_sec+(double)ru.ru_utime.tv_usec*0.000001; \
99 for (i = 0; i < k; i++) { \
100 { op; } \
101 }; \
102 getrusage(RUSAGE_SELF, &ru); \
103 dNow = (double)ru.ru_utime.tv_sec+(double)ru.ru_utime.tv_usec*0.000001; \
104 dUserTime = dNow-dStart; \
105 if (dUserTime) printf(" %-45s k: %6i, t: %6.2f sec\n", #op, k, dUserTime); \
106 }
107 #else
108 #define M_TimeOperation(op, k)
109 #endif
110
111 /* Test curve using generic field arithmetic. */
112 #define ECTEST_GENERIC_GF2M(name_c, name) \
113 printf("Testing %s using generic implementation...\n", name_c); \
114 params = EC_GetNamedCurveParams(name, KM_SLEEP); \
115 if (params == NULL) { \
116 printf(" Error: could not construct params.\n"); \
117 res = MP_NO; \
118 goto CLEANUP; \
119 } \
120 ECGroup_free(group); \
121 group = ECGroup_fromHex(params, KM_SLEEP); \
122 if (group == NULL) { \
123 printf(" Error: could not construct group.\n"); \
124 res = MP_NO; \
125 goto CLEANUP; \
126 } \
127 MP_CHECKOK( ectest_curve_GF2m(group, ectestPrint, ectestTime, 1, KM_SLEEP) ); \
128 printf("... okay.\n");
129
130 /* Test curve using specific field arithmetic. */
131 #define ECTEST_NAMED_GF2M(name_c, name) \
132 printf("Testing %s using specific implementation...\n", name_c); \
133 ECGroup_free(group); \
134 group = ECGroup_fromName(name, KM_SLEEP); \
135 if (group == NULL) { \
136 printf(" Warning: could not construct group.\n"); \
137 printf("... failed; continuing with remaining tests.\n"); \
138 } else { \
139 MP_CHECKOK( ectest_curve_GF2m(group, ectestPrint, ectestTime, 0, KM_SLEEP) ); \
140 printf("... okay.\n"); \
141 }
142
143 /* Performs basic tests of elliptic curve cryptography over binary
144 * polynomial fields. If tests fail, then it prints an error message,
145 * aborts, and returns an error code. Otherwise, returns 0. */
146 int
147 ectest_curve_GF2m(ECGroup *group, int ectestPrint, int ectestTime,
148 int generic, int kmflag)
149 {
150
151 mp_int one, order_1, gx, gy, rx, ry, n;
152 int size;
153 mp_err res;
154 char s[1000];
155
156 /* initialize values */
157 MP_CHECKOK(mp_init(&one, kmflag));
158 MP_CHECKOK(mp_init(&order_1, kmflag));
159 MP_CHECKOK(mp_init(&gx, kmflag));
160 MP_CHECKOK(mp_init(&gy, kmflag));
161 MP_CHECKOK(mp_init(&rx, kmflag));
162 MP_CHECKOK(mp_init(&ry, kmflag));
163 MP_CHECKOK(mp_init(&n, kmflag));
164
165 MP_CHECKOK(mp_set_int(&one, 1));
166 MP_CHECKOK(mp_sub(&group->order, &one, &order_1));
167
168 /* encode base point */
169 if (group->meth->field_dec) {
170 MP_CHECKOK(group->meth->field_dec(&group->genx, &gx, group->meth));
171 MP_CHECKOK(group->meth->field_dec(&group->geny, &gy, group->meth));
172 } else {
173 MP_CHECKOK(mp_copy(&group->genx, &gx));
174 MP_CHECKOK(mp_copy(&group->geny, &gy));
175 }
176
177 if (ectestPrint) {
178 /* output base point */
179 printf(" base point P:\n");
180 MP_CHECKOK(mp_toradix(&gx, s, 16));
181 printf(" %s\n", s);
182 MP_CHECKOK(mp_toradix(&gy, s, 16));
183 printf(" %s\n", s);
184 if (group->meth->field_enc) {
185 printf(" base point P (encoded):\n");
186 MP_CHECKOK(mp_toradix(&group->genx, s, 16));
187 printf(" %s\n", s);
188 MP_CHECKOK(mp_toradix(&group->geny, s, 16));
189 printf(" %s\n", s);
190 }
191 }
192
193 #ifdef ECL_ENABLE_GF2M_PT_MUL_AFF
194 /* multiply base point by order - 1 and check for negative of base
195 * point */
196 MP_CHECKOK(ec_GF2m_pt_mul_aff
197 (&order_1, &group->genx, &group->geny, &rx, &ry, group));
198 if (ectestPrint) {
199 printf(" (order-1)*P (affine):\n");
200 MP_CHECKOK(mp_toradix(&rx, s, 16));
201 printf(" %s\n", s);
202 MP_CHECKOK(mp_toradix(&ry, s, 16));
203 printf(" %s\n", s);
204 }
205 MP_CHECKOK(group->meth->field_add(&ry, &rx, &ry, group->meth));
206 if ((mp_cmp(&rx, &group->genx) != 0)
207 || (mp_cmp(&ry, &group->geny) != 0)) {
208 printf(" Error: invalid result (expected (- base point)).\n");
209 res = MP_NO;
210 goto CLEANUP;
211 }
212 #endif
213
214 /* multiply base point by order - 1 and check for negative of base
215 * point */
216 MP_CHECKOK(ec_GF2m_pt_mul_mont
217 (&order_1, &group->genx, &group->geny, &rx, &ry, group));
218 if (ectestPrint) {
219 printf(" (order-1)*P (montgomery):\n");
220 MP_CHECKOK(mp_toradix(&rx, s, 16));
221 printf(" %s\n", s);
222 MP_CHECKOK(mp_toradix(&ry, s, 16));
223 printf(" %s\n", s);
224 }
225 MP_CHECKOK(group->meth->field_add(&ry, &rx, &ry, group->meth));
226 if ((mp_cmp(&rx, &group->genx) != 0)
227 || (mp_cmp(&ry, &group->geny) != 0)) {
228 printf(" Error: invalid result (expected (- base point)).\n");
229 res = MP_NO;
230 goto CLEANUP;
231 }
232
233 #ifdef ECL_ENABLE_GF2M_PROJ
234 /* multiply base point by order - 1 and check for negative of base
235 * point */
236 MP_CHECKOK(ec_GF2m_pt_mul_proj
237 (&order_1, &group->genx, &group->geny, &rx, &ry, group));
238 if (ectestPrint) {
239 printf(" (order-1)*P (projective):\n");
240 MP_CHECKOK(mp_toradix(&rx, s, 16));
241 printf(" %s\n", s);
242 MP_CHECKOK(mp_toradix(&ry, s, 16));
243 printf(" %s\n", s);
244 }
245 MP_CHECKOK(group->meth->field_add(&ry, &rx, &ry, group->meth));
246 if ((mp_cmp(&rx, &group->genx) != 0)
247 || (mp_cmp(&ry, &group->geny) != 0)) {
248 printf(" Error: invalid result (expected (- base point)).\n");
249 res = MP_NO;
250 goto CLEANUP;
251 }
252 #endif
253
254 /* multiply base point by order - 1 and check for negative of base
255 * point */
256 MP_CHECKOK(ECPoint_mul(group, &order_1, NULL, NULL, &rx, &ry));
257 if (ectestPrint) {
258 printf(" (order-1)*P (ECPoint_mul):\n");
259 MP_CHECKOK(mp_toradix(&rx, s, 16));
260 printf(" %s\n", s);
261 MP_CHECKOK(mp_toradix(&ry, s, 16));
262 printf(" %s\n", s);
263 }
264 MP_CHECKOK(ec_GF2m_add(&ry, &rx, &ry, group->meth));
265 if ((mp_cmp(&rx, &gx) != 0) || (mp_cmp(&ry, &gy) != 0)) {
266 printf(" Error: invalid result (expected (- base point)).\n");
267 res = MP_NO;
268 goto CLEANUP;
269 }
270
271 /* multiply base point by order - 1 and check for negative of base
272 * point */
273 MP_CHECKOK(ECPoint_mul(group, &order_1, &gx, &gy, &rx, &ry));
274 if (ectestPrint) {
275 printf(" (order-1)*P (ECPoint_mul):\n");
276 MP_CHECKOK(mp_toradix(&rx, s, 16));
277 printf(" %s\n", s);
278 MP_CHECKOK(mp_toradix(&ry, s, 16));
279 printf(" %s\n", s);
280 }
281 MP_CHECKOK(ec_GF2m_add(&ry, &rx, &ry, group->meth));
282 if ((mp_cmp(&rx, &gx) != 0) || (mp_cmp(&ry, &gy) != 0)) {
283 printf(" Error: invalid result (expected (- base point)).\n");
284 res = MP_NO;
285 goto CLEANUP;
286 }
287
288 #ifdef ECL_ENABLE_GF2M_PT_MUL_AFF
289 /* multiply base point by order and check for point at infinity */
290 MP_CHECKOK(ec_GF2m_pt_mul_aff
291 (&group->order, &group->genx, &group->geny, &rx, &ry,
292 group));
293 if (ectestPrint) {
294 printf(" (order)*P (affine):\n");
295 MP_CHECKOK(mp_toradix(&rx, s, 16));
296 printf(" %s\n", s);
297 MP_CHECKOK(mp_toradix(&ry, s, 16));
298 printf(" %s\n", s);
299 }
300 if (ec_GF2m_pt_is_inf_aff(&rx, &ry) != MP_YES) {
301 printf(" Error: invalid result (expected point at infinity).\n");
302 res = MP_NO;
303 goto CLEANUP;
304 }
305 #endif
306
307 /* multiply base point by order and check for point at infinity */
308 MP_CHECKOK(ec_GF2m_pt_mul_mont
309 (&group->order, &group->genx, &group->geny, &rx, &ry,
310 group));
311 if (ectestPrint) {
312 printf(" (order)*P (montgomery):\n");
313 MP_CHECKOK(mp_toradix(&rx, s, 16));
314 printf(" %s\n", s);
315 MP_CHECKOK(mp_toradix(&ry, s, 16));
316 printf(" %s\n", s);
317 }
318 if (ec_GF2m_pt_is_inf_aff(&rx, &ry) != MP_YES) {
319 printf(" Error: invalid result (expected point at infinity).\n");
320 res = MP_NO;
321 goto CLEANUP;
322 }
323
324 #ifdef ECL_ENABLE_GF2M_PROJ
325 /* multiply base point by order and check for point at infinity */
326 MP_CHECKOK(ec_GF2m_pt_mul_proj
327 (&group->order, &group->genx, &group->geny, &rx, &ry,
328 group));
329 if (ectestPrint) {
330 printf(" (order)*P (projective):\n");
331 MP_CHECKOK(mp_toradix(&rx, s, 16));
332 printf(" %s\n", s);
333 MP_CHECKOK(mp_toradix(&ry, s, 16));
334 printf(" %s\n", s);
335 }
336 if (ec_GF2m_pt_is_inf_aff(&rx, &ry) != MP_YES) {
337 printf(" Error: invalid result (expected point at infinity).\n");
338 res = MP_NO;
339 goto CLEANUP;
340 }
341 #endif
342
343 /* multiply base point by order and check for point at infinity */
344 MP_CHECKOK(ECPoint_mul(group, &group->order, NULL, NULL, &rx, &ry));
345 if (ectestPrint) {
346 printf(" (order)*P (ECPoint_mul):\n");
347 MP_CHECKOK(mp_toradix(&rx, s, 16));
348 printf(" %s\n", s);
349 MP_CHECKOK(mp_toradix(&ry, s, 16));
350 printf(" %s\n", s);
351 }
352 if (ec_GF2m_pt_is_inf_aff(&rx, &ry) != MP_YES) {
353 printf(" Error: invalid result (expected point at infinity).\n");
354 res = MP_NO;
355 goto CLEANUP;
356 }
357
358 /* multiply base point by order and check for point at infinity */
359 MP_CHECKOK(ECPoint_mul(group, &group->order, &gx, &gy, &rx, &ry));
360 if (ectestPrint) {
361 printf(" (order)*P (ECPoint_mul):\n");
362 MP_CHECKOK(mp_toradix(&rx, s, 16));
363 printf(" %s\n", s);
364 MP_CHECKOK(mp_toradix(&ry, s, 16));
365 printf(" %s\n", s);
366 }
367 if (ec_GF2m_pt_is_inf_aff(&rx, &ry) != MP_YES) {
368 printf(" Error: invalid result (expected point at infinity).\n");
369 res = MP_NO;
370 goto CLEANUP;
371 }
372
373 /* check that (order-1)P + (order-1)P + P == (order-1)P */
374 MP_CHECKOK(ECPoints_mul
375 (group, &order_1, &order_1, &gx, &gy, &rx, &ry));
376 MP_CHECKOK(ECPoints_mul(group, &one, &one, &rx, &ry, &rx, &ry));
377 if (ectestPrint) {
378 printf
379 (" (order-1)*P + (order-1)*P + P == (order-1)*P (ECPoints_mul):\n");
380 MP_CHECKOK(mp_toradix(&rx, s, 16));
381 printf(" %s\n", s);
382 MP_CHECKOK(mp_toradix(&ry, s, 16));
383 printf(" %s\n", s);
384 }
385 MP_CHECKOK(ec_GF2m_add(&ry, &rx, &ry, group->meth));
386 if ((mp_cmp(&rx, &gx) != 0) || (mp_cmp(&ry, &gy) != 0)) {
387 printf(" Error: invalid result (expected (- base point)).\n");
388 res = MP_NO;
389 goto CLEANUP;
390 }
391
392 /* test validate_point function */
393 if (ECPoint_validate(group, &gx, &gy) != MP_YES) {
394 printf(" Error: validate point on base point failed.\n");
395 res = MP_NO;
396 goto CLEANUP;
397 }
398 MP_CHECKOK(mp_add_d(&gy, 1, &ry));
399 if (ECPoint_validate(group, &gx, &ry) != MP_NO) {
400 printf(" Error: validate point on invalid point passed.\n");
401 res = MP_NO;
402 goto CLEANUP;
403 }
404
405 if (ectestTime) {
406 /* compute random scalar */
407 size = mpl_significant_bits(&group->meth->irr);
408 if (size < MP_OKAY) {
409 goto CLEANUP;
410 }
411 MP_CHECKOK(mpp_random_size(&n, (size + ECL_BITS - 1) / ECL_BITS));
412 MP_CHECKOK(group->meth->field_mod(&n, &n, group->meth));
413 /* timed test */
414 if (generic) {
415 #ifdef ECL_ENABLE_GF2M_PT_MUL_AFF
416 M_TimeOperation(MP_CHECKOK
417 (ec_GF2m_pt_mul_aff
418 (&n, &group->genx, &group->geny, &rx, &ry,
419 group)), 100);
420 #endif
421 M_TimeOperation(MP_CHECKOK
422 (ECPoint_mul(group, &n, NULL, NULL, &rx, &ry)),
423 100);
424 M_TimeOperation(MP_CHECKOK
425 (ECPoints_mul
426 (group, &n, &n, &gx, &gy, &rx, &ry)), 100);
427 } else {
428 M_TimeOperation(MP_CHECKOK
429 (ECPoint_mul(group, &n, NULL, NULL, &rx, &ry)),
430 100);
431 M_TimeOperation(MP_CHECKOK
432 (ECPoint_mul(group, &n, &gx, &gy, &rx, &ry)),
433 100);
434 M_TimeOperation(MP_CHECKOK
435 (ECPoints_mul
436 (group, &n, &n, &gx, &gy, &rx, &ry)), 100);
437 }
438 }
439
440 CLEANUP:
441 mp_clear(&one);
442 mp_clear(&order_1);
443 mp_clear(&gx);
444 mp_clear(&gy);
445 mp_clear(&rx);
446 mp_clear(&ry);
447 mp_clear(&n);
448 if (res != MP_OKAY) {
449 #ifdef _KERNEL
450 printf(" Error: exiting with error value 0x%x\n", res);
451 #else
452 printf(" Error: exiting with error value %i\n", res);
453 #endif
454 }
455 return res;
456 }
457
458 /* Performs tests of elliptic curve cryptography over binary polynomial
459 * fields. If tests fail, then it prints an error message, aborts, and
460 * returns an error code. Otherwise, returns 0. */
461 int
462 ec2_test()
463 {
464 int ectestTime = 0;
465 int ectestPrint = 0;
466 int i;
467 ECGroup *group = NULL;
468 ECCurveParams *params = NULL;
469 mp_err res;
470
471 /* generic arithmetic tests */
472 ECTEST_GENERIC_GF2M("SECT-131R1", ECCurve_SECG_CHAR2_131R1);
473
474 /* specific arithmetic tests */
475 ECTEST_NAMED_GF2M("NIST-K163", ECCurve_NIST_K163);
476 ECTEST_NAMED_GF2M("NIST-B163", ECCurve_NIST_B163);
477 ECTEST_NAMED_GF2M("NIST-K233", ECCurve_NIST_K233);
478 ECTEST_NAMED_GF2M("NIST-B233", ECCurve_NIST_B233);
479 ECTEST_NAMED_GF2M("NIST-K283", ECCurve_NIST_K283);
480 ECTEST_NAMED_GF2M("NIST-B283", ECCurve_NIST_B283);
481 ECTEST_NAMED_GF2M("NIST-K409", ECCurve_NIST_K409);
482 ECTEST_NAMED_GF2M("NIST-B409", ECCurve_NIST_B409);
483 ECTEST_NAMED_GF2M("NIST-K571", ECCurve_NIST_K571);
484 ECTEST_NAMED_GF2M("NIST-B571", ECCurve_NIST_B571);
485 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB163V1", ECCurve_X9_62_CHAR2_PNB163V1);
486 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB163V2", ECCurve_X9_62_CHAR2_PNB163V2);
487 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB163V3", ECCurve_X9_62_CHAR2_PNB163V3);
488 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB176V1", ECCurve_X9_62_CHAR2_PNB176V1);
489 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB191V1", ECCurve_X9_62_CHAR2_TNB191V1);
490 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB191V2", ECCurve_X9_62_CHAR2_TNB191V2);
491 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB191V3", ECCurve_X9_62_CHAR2_TNB191V3);
492 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB208W1", ECCurve_X9_62_CHAR2_PNB208W1);
493 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB239V1", ECCurve_X9_62_CHAR2_TNB239V1);
494 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB239V2", ECCurve_X9_62_CHAR2_TNB239V2);
495 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB239V3", ECCurve_X9_62_CHAR2_TNB239V3);
496 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB272W1", ECCurve_X9_62_CHAR2_PNB272W1);
497 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB304W1", ECCurve_X9_62_CHAR2_PNB304W1);
498 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB359V1", ECCurve_X9_62_CHAR2_TNB359V1);
499 ECTEST_NAMED_GF2M("ANSI X9.62 C2PNB368W1", ECCurve_X9_62_CHAR2_PNB368W1);
500 ECTEST_NAMED_GF2M("ANSI X9.62 C2TNB431R1", ECCurve_X9_62_CHAR2_TNB431R1);
501 ECTEST_NAMED_GF2M("SECT-113R1", ECCurve_SECG_CHAR2_113R1);
502 ECTEST_NAMED_GF2M("SECT-113R2", ECCurve_SECG_CHAR2_113R2);
503 ECTEST_NAMED_GF2M("SECT-131R1", ECCurve_SECG_CHAR2_131R1);
504 ECTEST_NAMED_GF2M("SECT-131R2", ECCurve_SECG_CHAR2_131R2);
505 ECTEST_NAMED_GF2M("SECT-163K1", ECCurve_SECG_CHAR2_163K1);
506 ECTEST_NAMED_GF2M("SECT-163R1", ECCurve_SECG_CHAR2_163R1);
507 ECTEST_NAMED_GF2M("SECT-163R2", ECCurve_SECG_CHAR2_163R2);
508 ECTEST_NAMED_GF2M("SECT-193R1", ECCurve_SECG_CHAR2_193R1);
509 ECTEST_NAMED_GF2M("SECT-193R2", ECCurve_SECG_CHAR2_193R2);
510 ECTEST_NAMED_GF2M("SECT-233K1", ECCurve_SECG_CHAR2_233K1);
511 ECTEST_NAMED_GF2M("SECT-233R1", ECCurve_SECG_CHAR2_233R1);
512 ECTEST_NAMED_GF2M("SECT-239K1", ECCurve_SECG_CHAR2_239K1);
513 ECTEST_NAMED_GF2M("SECT-283K1", ECCurve_SECG_CHAR2_283K1);
514 ECTEST_NAMED_GF2M("SECT-283R1", ECCurve_SECG_CHAR2_283R1);
515 ECTEST_NAMED_GF2M("SECT-409K1", ECCurve_SECG_CHAR2_409K1);
516 ECTEST_NAMED_GF2M("SECT-409R1", ECCurve_SECG_CHAR2_409R1);
517 ECTEST_NAMED_GF2M("SECT-571K1", ECCurve_SECG_CHAR2_571K1);
518 ECTEST_NAMED_GF2M("SECT-571R1", ECCurve_SECG_CHAR2_571R1);
519 ECTEST_NAMED_GF2M("WTLS-1 (113)", ECCurve_WTLS_1);
520 ECTEST_NAMED_GF2M("WTLS-3 (163)", ECCurve_WTLS_3);
521 ECTEST_NAMED_GF2M("WTLS-4 (113)", ECCurve_WTLS_4);
522 ECTEST_NAMED_GF2M("WTLS-5 (163)", ECCurve_WTLS_5);
523 ECTEST_NAMED_GF2M("WTLS-10 (233)", ECCurve_WTLS_10);
524 ECTEST_NAMED_GF2M("WTLS-11 (233)", ECCurve_WTLS_11);
525
526 CLEANUP:
527 EC_FreeCurveParams(params);
528 ECGroup_free(group);
529 if (res != MP_OKAY) {
530 #ifdef _KERNEL
531 printf("Error: exiting with error value 0x%x\n", res);
532 #else
533 printf("Error: exiting with error value %i\n", res);
534 #endif
535 }
536 return res;
537 }
unleashed repo fork