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. */
146int
147ectest_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. */
461int
462ec2_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}
538