OLD | NEW |
| (Empty) |
1 /* crypto/ec/ec.h */ | |
2 /* | |
3 * Originally written by Bodo Moeller for the OpenSSL project. | |
4 */ | |
5 /** | |
6 * \file crypto/ec/ec.h Include file for the OpenSSL EC functions | |
7 * \author Originally written by Bodo Moeller for the OpenSSL project | |
8 */ | |
9 /* ==================================================================== | |
10 * Copyright (c) 1998-2005 The OpenSSL Project. All rights reserved. | |
11 * | |
12 * Redistribution and use in source and binary forms, with or without | |
13 * modification, are permitted provided that the following conditions | |
14 * are met: | |
15 * | |
16 * 1. Redistributions of source code must retain the above copyright | |
17 * notice, this list of conditions and the following disclaimer. | |
18 * | |
19 * 2. Redistributions in binary form must reproduce the above copyright | |
20 * notice, this list of conditions and the following disclaimer in | |
21 * the documentation and/or other materials provided with the | |
22 * distribution. | |
23 * | |
24 * 3. All advertising materials mentioning features or use of this | |
25 * software must display the following acknowledgment: | |
26 * "This product includes software developed by the OpenSSL Project | |
27 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | |
28 * | |
29 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
30 * endorse or promote products derived from this software without | |
31 * prior written permission. For written permission, please contact | |
32 * openssl-core@openssl.org. | |
33 * | |
34 * 5. Products derived from this software may not be called "OpenSSL" | |
35 * nor may "OpenSSL" appear in their names without prior written | |
36 * permission of the OpenSSL Project. | |
37 * | |
38 * 6. Redistributions of any form whatsoever must retain the following | |
39 * acknowledgment: | |
40 * "This product includes software developed by the OpenSSL Project | |
41 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | |
42 * | |
43 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
44 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
46 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
47 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
49 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
50 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
51 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
52 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
53 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
54 * OF THE POSSIBILITY OF SUCH DAMAGE. | |
55 * ==================================================================== | |
56 * | |
57 * This product includes cryptographic software written by Eric Young | |
58 * (eay@cryptsoft.com). This product includes software written by Tim | |
59 * Hudson (tjh@cryptsoft.com). | |
60 * | |
61 */ | |
62 /* ==================================================================== | |
63 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. | |
64 * | |
65 * Portions of the attached software ("Contribution") are developed by | |
66 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. | |
67 * | |
68 * The Contribution is licensed pursuant to the OpenSSL open source | |
69 * license provided above. | |
70 * | |
71 * The elliptic curve binary polynomial software is originally written by | |
72 * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories. | |
73 * | |
74 */ | |
75 | |
76 #ifndef HEADER_EC_H | |
77 #define HEADER_EC_H | |
78 | |
79 #include <openssl/opensslconf.h> | |
80 | |
81 #ifdef OPENSSL_NO_EC | |
82 #error EC is disabled. | |
83 #endif | |
84 | |
85 #include <openssl/asn1.h> | |
86 #include <openssl/symhacks.h> | |
87 #ifndef OPENSSL_NO_DEPRECATED | |
88 #include <openssl/bn.h> | |
89 #endif | |
90 | |
91 #ifdef __cplusplus | |
92 extern "C" { | |
93 #elif defined(__SUNPRO_C) | |
94 # if __SUNPRO_C >= 0x520 | |
95 # pragma error_messages (off,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE) | |
96 # endif | |
97 #endif | |
98 | |
99 | |
100 #ifndef OPENSSL_ECC_MAX_FIELD_BITS | |
101 # define OPENSSL_ECC_MAX_FIELD_BITS 661 | |
102 #endif | |
103 | |
104 /** Enum for the point conversion form as defined in X9.62 (ECDSA) | |
105 * for the encoding of a elliptic curve point (x,y) */ | |
106 typedef enum { | |
107 /** the point is encoded as z||x, where the octet z specifies | |
108 * which solution of the quadratic equation y is */ | |
109 POINT_CONVERSION_COMPRESSED = 2, | |
110 /** the point is encoded as z||x||y, where z is the octet 0x02 */ | |
111 POINT_CONVERSION_UNCOMPRESSED = 4, | |
112 /** the point is encoded as z||x||y, where the octet z specifies | |
113 * which solution of the quadratic equation y is */ | |
114 POINT_CONVERSION_HYBRID = 6 | |
115 } point_conversion_form_t; | |
116 | |
117 | |
118 typedef struct ec_method_st EC_METHOD; | |
119 | |
120 typedef struct ec_group_st | |
121 /* | |
122 EC_METHOD *meth; | |
123 -- field definition | |
124 -- curve coefficients | |
125 -- optional generator with associated information (order, cofactor) | |
126 -- optional extra data (precomputed table for fast computation of multi
ples of generator) | |
127 -- ASN1 stuff | |
128 */ | |
129 EC_GROUP; | |
130 | |
131 typedef struct ec_point_st EC_POINT; | |
132 | |
133 | |
134 /********************************************************************/ | |
135 /* EC_METHODs for curves over GF(p) */ | |
136 /********************************************************************/ | |
137 | |
138 /** Returns the basic GFp ec methods which provides the basis for the | |
139 * optimized methods. | |
140 * \return EC_METHOD object | |
141 */ | |
142 const EC_METHOD *EC_GFp_simple_method(void); | |
143 | |
144 /** Returns GFp methods using montgomery multiplication. | |
145 * \return EC_METHOD object | |
146 */ | |
147 const EC_METHOD *EC_GFp_mont_method(void); | |
148 | |
149 /** Returns GFp methods using optimized methods for NIST recommended curves | |
150 * \return EC_METHOD object | |
151 */ | |
152 const EC_METHOD *EC_GFp_nist_method(void); | |
153 | |
154 #ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 | |
155 /** Returns 64-bit optimized methods for nistp224 | |
156 * \return EC_METHOD object | |
157 */ | |
158 const EC_METHOD *EC_GFp_nistp224_method(void); | |
159 | |
160 /** Returns 64-bit optimized methods for nistp256 | |
161 * \return EC_METHOD object | |
162 */ | |
163 const EC_METHOD *EC_GFp_nistp256_method(void); | |
164 | |
165 /** Returns 64-bit optimized methods for nistp521 | |
166 * \return EC_METHOD object | |
167 */ | |
168 const EC_METHOD *EC_GFp_nistp521_method(void); | |
169 #endif | |
170 | |
171 #ifndef OPENSSL_NO_EC2M | |
172 /********************************************************************/ | |
173 /* EC_METHOD for curves over GF(2^m) */ | |
174 /********************************************************************/ | |
175 | |
176 /** Returns the basic GF2m ec method | |
177 * \return EC_METHOD object | |
178 */ | |
179 const EC_METHOD *EC_GF2m_simple_method(void); | |
180 | |
181 #endif | |
182 | |
183 | |
184 /********************************************************************/ | |
185 /* EC_GROUP functions */ | |
186 /********************************************************************/ | |
187 | |
188 /** Creates a new EC_GROUP object | |
189 * \param meth EC_METHOD to use | |
190 * \return newly created EC_GROUP object or NULL in case of an error. | |
191 */ | |
192 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth); | |
193 | |
194 /** Frees a EC_GROUP object | |
195 * \param group EC_GROUP object to be freed. | |
196 */ | |
197 void EC_GROUP_free(EC_GROUP *group); | |
198 | |
199 /** Clears and frees a EC_GROUP object | |
200 * \param group EC_GROUP object to be cleared and freed. | |
201 */ | |
202 void EC_GROUP_clear_free(EC_GROUP *group); | |
203 | |
204 /** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD. | |
205 * \param dst destination EC_GROUP object | |
206 * \param src source EC_GROUP object | |
207 * \return 1 on success and 0 if an error occurred. | |
208 */ | |
209 int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src); | |
210 | |
211 /** Creates a new EC_GROUP object and copies the copies the content | |
212 * form src to the newly created EC_KEY object | |
213 * \param src source EC_GROUP object | |
214 * \return newly created EC_GROUP object or NULL in case of an error. | |
215 */ | |
216 EC_GROUP *EC_GROUP_dup(const EC_GROUP *src); | |
217 | |
218 /** Returns the EC_METHOD of the EC_GROUP object. | |
219 * \param group EC_GROUP object | |
220 * \return EC_METHOD used in this EC_GROUP object. | |
221 */ | |
222 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group); | |
223 | |
224 /** Returns the field type of the EC_METHOD. | |
225 * \param meth EC_METHOD object | |
226 * \return NID of the underlying field type OID. | |
227 */ | |
228 int EC_METHOD_get_field_type(const EC_METHOD *meth); | |
229 | |
230 /** Sets the generator and it's order/cofactor of a EC_GROUP object. | |
231 * \param group EC_GROUP object | |
232 * \param generator EC_POINT object with the generator. | |
233 * \param order the order of the group generated by the generator. | |
234 * \param cofactor the index of the sub-group generated by the generator | |
235 * in the group of all points on the elliptic curve. | |
236 * \return 1 on success and 0 if an error occured | |
237 */ | |
238 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIG
NUM *order, const BIGNUM *cofactor); | |
239 | |
240 /** Returns the generator of a EC_GROUP object. | |
241 * \param group EC_GROUP object | |
242 * \return the currently used generator (possibly NULL). | |
243 */ | |
244 const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group); | |
245 | |
246 /** Gets the order of a EC_GROUP | |
247 * \param group EC_GROUP object | |
248 * \param order BIGNUM to which the order is copied | |
249 * \param ctx BN_CTX object (optional) | |
250 * \return 1 on success and 0 if an error occured | |
251 */ | |
252 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx); | |
253 | |
254 /** Gets the cofactor of a EC_GROUP | |
255 * \param group EC_GROUP object | |
256 * \param cofactor BIGNUM to which the cofactor is copied | |
257 * \param ctx BN_CTX object (optional) | |
258 * \return 1 on success and 0 if an error occured | |
259 */ | |
260 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx); | |
261 | |
262 /** Sets the name of a EC_GROUP object | |
263 * \param group EC_GROUP object | |
264 * \param nid NID of the curve name OID | |
265 */ | |
266 void EC_GROUP_set_curve_name(EC_GROUP *group, int nid); | |
267 | |
268 /** Returns the curve name of a EC_GROUP object | |
269 * \param group EC_GROUP object | |
270 * \return NID of the curve name OID or 0 if not set. | |
271 */ | |
272 int EC_GROUP_get_curve_name(const EC_GROUP *group); | |
273 | |
274 void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag); | |
275 int EC_GROUP_get_asn1_flag(const EC_GROUP *group); | |
276 | |
277 void EC_GROUP_set_point_conversion_form(EC_GROUP *group, point_conversion_form_t
form); | |
278 point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *); | |
279 | |
280 unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x); | |
281 size_t EC_GROUP_get_seed_len(const EC_GROUP *); | |
282 size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len); | |
283 | |
284 /** Sets the parameter of a ec over GFp defined by y^2 = x^3 + a*x + b | |
285 * \param group EC_GROUP object | |
286 * \param p BIGNUM with the prime number | |
287 * \param a BIGNUM with parameter a of the equation | |
288 * \param b BIGNUM with parameter b of the equation | |
289 * \param ctx BN_CTX object (optional) | |
290 * \return 1 on success and 0 if an error occured | |
291 */ | |
292 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, co
nst BIGNUM *b, BN_CTX *ctx); | |
293 | |
294 /** Gets the parameter of the ec over GFp defined by y^2 = x^3 + a*x + b | |
295 * \param group EC_GROUP object | |
296 * \param p BIGNUM for the prime number | |
297 * \param a BIGNUM for parameter a of the equation | |
298 * \param b BIGNUM for parameter b of the equation | |
299 * \param ctx BN_CTX object (optional) | |
300 * \return 1 on success and 0 if an error occured | |
301 */ | |
302 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *
b, BN_CTX *ctx); | |
303 | |
304 #ifndef OPENSSL_NO_EC2M | |
305 /** Sets the parameter of a ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 + b | |
306 * \param group EC_GROUP object | |
307 * \param p BIGNUM with the polynomial defining the underlying field | |
308 * \param a BIGNUM with parameter a of the equation | |
309 * \param b BIGNUM with parameter b of the equation | |
310 * \param ctx BN_CTX object (optional) | |
311 * \return 1 on success and 0 if an error occured | |
312 */ | |
313 int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, c
onst BIGNUM *b, BN_CTX *ctx); | |
314 | |
315 /** Gets the parameter of the ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 +
b | |
316 * \param group EC_GROUP object | |
317 * \param p BIGNUM for the polynomial defining the underlying field | |
318 * \param a BIGNUM for parameter a of the equation | |
319 * \param b BIGNUM for parameter b of the equation | |
320 * \param ctx BN_CTX object (optional) | |
321 * \return 1 on success and 0 if an error occured | |
322 */ | |
323 int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM
*b, BN_CTX *ctx); | |
324 #endif | |
325 /** Returns the number of bits needed to represent a field element | |
326 * \param group EC_GROUP object | |
327 * \return number of bits needed to represent a field element | |
328 */ | |
329 int EC_GROUP_get_degree(const EC_GROUP *group); | |
330 | |
331 /** Checks whether the parameter in the EC_GROUP define a valid ec group | |
332 * \param group EC_GROUP object | |
333 * \param ctx BN_CTX object (optional) | |
334 * \return 1 if group is a valid ec group and 0 otherwise | |
335 */ | |
336 int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx); | |
337 | |
338 /** Checks whether the discriminant of the elliptic curve is zero or not | |
339 * \param group EC_GROUP object | |
340 * \param ctx BN_CTX object (optional) | |
341 * \return 1 if the discriminant is not zero and 0 otherwise | |
342 */ | |
343 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx); | |
344 | |
345 /** Compares two EC_GROUP objects | |
346 * \param a first EC_GROUP object | |
347 * \param b second EC_GROUP object | |
348 * \param ctx BN_CTX object (optional) | |
349 * \return 0 if both groups are equal and 1 otherwise | |
350 */ | |
351 int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx); | |
352 | |
353 /* EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() | |
354 * after choosing an appropriate EC_METHOD */ | |
355 | |
356 /** Creates a new EC_GROUP object with the specified parameters defined | |
357 * over GFp (defined by the equation y^2 = x^3 + a*x + b) | |
358 * \param p BIGNUM with the prime number | |
359 * \param a BIGNUM with the parameter a of the equation | |
360 * \param b BIGNUM with the parameter b of the equation | |
361 * \param ctx BN_CTX object (optional) | |
362 * \return newly created EC_GROUP object with the specified parameters | |
363 */ | |
364 EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, const BIGNUM
*b, BN_CTX *ctx); | |
365 #ifndef OPENSSL_NO_EC2M | |
366 /** Creates a new EC_GROUP object with the specified parameters defined | |
367 * over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b) | |
368 * \param p BIGNUM with the polynomial defining the underlying field | |
369 * \param a BIGNUM with the parameter a of the equation | |
370 * \param b BIGNUM with the parameter b of the equation | |
371 * \param ctx BN_CTX object (optional) | |
372 * \return newly created EC_GROUP object with the specified parameters | |
373 */ | |
374 EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a, const BIGNUM
*b, BN_CTX *ctx); | |
375 #endif | |
376 /** Creates a EC_GROUP object with a curve specified by a NID | |
377 * \param nid NID of the OID of the curve name | |
378 * \return newly created EC_GROUP object with specified curve or NULL | |
379 * if an error occurred | |
380 */ | |
381 EC_GROUP *EC_GROUP_new_by_curve_name(int nid); | |
382 | |
383 | |
384 /********************************************************************/ | |
385 /* handling of internal curves */ | |
386 /********************************************************************/ | |
387 | |
388 typedef struct { | |
389 int nid; | |
390 const char *comment; | |
391 } EC_builtin_curve; | |
392 | |
393 /* EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number | |
394 * of all available curves or zero if a error occurred. | |
395 * In case r ist not zero nitems EC_builtin_curve structures | |
396 * are filled with the data of the first nitems internal groups */ | |
397 size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems); | |
398 | |
399 | |
400 /********************************************************************/ | |
401 /* EC_POINT functions */ | |
402 /********************************************************************/ | |
403 | |
404 /** Creates a new EC_POINT object for the specified EC_GROUP | |
405 * \param group EC_GROUP the underlying EC_GROUP object | |
406 * \return newly created EC_POINT object or NULL if an error occurred | |
407 */ | |
408 EC_POINT *EC_POINT_new(const EC_GROUP *group); | |
409 | |
410 /** Frees a EC_POINT object | |
411 * \param point EC_POINT object to be freed | |
412 */ | |
413 void EC_POINT_free(EC_POINT *point); | |
414 | |
415 /** Clears and frees a EC_POINT object | |
416 * \param point EC_POINT object to be cleared and freed | |
417 */ | |
418 void EC_POINT_clear_free(EC_POINT *point); | |
419 | |
420 /** Copies EC_POINT object | |
421 * \param dst destination EC_POINT object | |
422 * \param src source EC_POINT object | |
423 * \return 1 on success and 0 if an error occured | |
424 */ | |
425 int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src); | |
426 | |
427 /** Creates a new EC_POINT object and copies the content of the supplied | |
428 * EC_POINT | |
429 * \param src source EC_POINT object | |
430 * \param group underlying the EC_GROUP object | |
431 * \return newly created EC_POINT object or NULL if an error occurred | |
432 */ | |
433 EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group); | |
434 | |
435 /** Returns the EC_METHOD used in EC_POINT object | |
436 * \param point EC_POINT object | |
437 * \return the EC_METHOD used | |
438 */ | |
439 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point); | |
440 | |
441 /** Sets a point to infinity (neutral element) | |
442 * \param group underlying EC_GROUP object | |
443 * \param point EC_POINT to set to infinity | |
444 * \return 1 on success and 0 if an error occured | |
445 */ | |
446 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point); | |
447 | |
448 /** Sets the jacobian projective coordinates of a EC_POINT over GFp | |
449 * \param group underlying EC_GROUP object | |
450 * \param p EC_POINT object | |
451 * \param x BIGNUM with the x-coordinate | |
452 * \param y BIGNUM with the y-coordinate | |
453 * \param z BIGNUM with the z-coordinate | |
454 * \param ctx BN_CTX object (optional) | |
455 * \return 1 on success and 0 if an error occured | |
456 */ | |
457 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *p, | |
458 const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx); | |
459 | |
460 /** Gets the jacobian projective coordinates of a EC_POINT over GFp | |
461 * \param group underlying EC_GROUP object | |
462 * \param p EC_POINT object | |
463 * \param x BIGNUM for the x-coordinate | |
464 * \param y BIGNUM for the y-coordinate | |
465 * \param z BIGNUM for the z-coordinate | |
466 * \param ctx BN_CTX object (optional) | |
467 * \return 1 on success and 0 if an error occured | |
468 */ | |
469 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, | |
470 const EC_POINT *p, BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx); | |
471 | |
472 /** Sets the affine coordinates of a EC_POINT over GFp | |
473 * \param group underlying EC_GROUP object | |
474 * \param p EC_POINT object | |
475 * \param x BIGNUM with the x-coordinate | |
476 * \param y BIGNUM with the y-coordinate | |
477 * \param ctx BN_CTX object (optional) | |
478 * \return 1 on success and 0 if an error occured | |
479 */ | |
480 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *p, | |
481 const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx); | |
482 | |
483 /** Gets the affine coordinates of a EC_POINT over GFp | |
484 * \param group underlying EC_GROUP object | |
485 * \param p EC_POINT object | |
486 * \param x BIGNUM for the x-coordinate | |
487 * \param y BIGNUM for the y-coordinate | |
488 * \param ctx BN_CTX object (optional) | |
489 * \return 1 on success and 0 if an error occured | |
490 */ | |
491 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, | |
492 const EC_POINT *p, BIGNUM *x, BIGNUM *y, BN_CTX *ctx); | |
493 | |
494 /** Sets the x9.62 compressed coordinates of a EC_POINT over GFp | |
495 * \param group underlying EC_GROUP object | |
496 * \param p EC_POINT object | |
497 * \param x BIGNUM with x-coordinate | |
498 * \param y_bit integer with the y-Bit (either 0 or 1) | |
499 * \param ctx BN_CTX object (optional) | |
500 * \return 1 on success and 0 if an error occured | |
501 */ | |
502 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *p, | |
503 const BIGNUM *x, int y_bit, BN_CTX *ctx); | |
504 #ifndef OPENSSL_NO_EC2M | |
505 /** Sets the affine coordinates of a EC_POINT over GF2m | |
506 * \param group underlying EC_GROUP object | |
507 * \param p EC_POINT object | |
508 * \param x BIGNUM with the x-coordinate | |
509 * \param y BIGNUM with the y-coordinate | |
510 * \param ctx BN_CTX object (optional) | |
511 * \return 1 on success and 0 if an error occured | |
512 */ | |
513 int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group, EC_POINT *p, | |
514 const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx); | |
515 | |
516 /** Gets the affine coordinates of a EC_POINT over GF2m | |
517 * \param group underlying EC_GROUP object | |
518 * \param p EC_POINT object | |
519 * \param x BIGNUM for the x-coordinate | |
520 * \param y BIGNUM for the y-coordinate | |
521 * \param ctx BN_CTX object (optional) | |
522 * \return 1 on success and 0 if an error occured | |
523 */ | |
524 int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group, | |
525 const EC_POINT *p, BIGNUM *x, BIGNUM *y, BN_CTX *ctx); | |
526 | |
527 /** Sets the x9.62 compressed coordinates of a EC_POINT over GF2m | |
528 * \param group underlying EC_GROUP object | |
529 * \param p EC_POINT object | |
530 * \param x BIGNUM with x-coordinate | |
531 * \param y_bit integer with the y-Bit (either 0 or 1) | |
532 * \param ctx BN_CTX object (optional) | |
533 * \return 1 on success and 0 if an error occured | |
534 */ | |
535 int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group, EC_POINT *p, | |
536 const BIGNUM *x, int y_bit, BN_CTX *ctx); | |
537 #endif | |
538 /** Encodes a EC_POINT object to a octet string | |
539 * \param group underlying EC_GROUP object | |
540 * \param p EC_POINT object | |
541 * \param form point conversion form | |
542 * \param buf memory buffer for the result. If NULL the function returns | |
543 * required buffer size. | |
544 * \param len length of the memory buffer | |
545 * \param ctx BN_CTX object (optional) | |
546 * \return the length of the encoded octet string or 0 if an error occurred | |
547 */ | |
548 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p, | |
549 point_conversion_form_t form, | |
550 unsigned char *buf, size_t len, BN_CTX *ctx); | |
551 | |
552 /** Decodes a EC_POINT from a octet string | |
553 * \param group underlying EC_GROUP object | |
554 * \param p EC_POINT object | |
555 * \param buf memory buffer with the encoded ec point | |
556 * \param len length of the encoded ec point | |
557 * \param ctx BN_CTX object (optional) | |
558 * \return 1 on success and 0 if an error occured | |
559 */ | |
560 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p, | |
561 const unsigned char *buf, size_t len, BN_CTX *ctx); | |
562 | |
563 /* other interfaces to point2oct/oct2point: */ | |
564 BIGNUM *EC_POINT_point2bn(const EC_GROUP *, const EC_POINT *, | |
565 point_conversion_form_t form, BIGNUM *, BN_CTX *); | |
566 EC_POINT *EC_POINT_bn2point(const EC_GROUP *, const BIGNUM *, | |
567 EC_POINT *, BN_CTX *); | |
568 char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *, | |
569 point_conversion_form_t form, BN_CTX *); | |
570 EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *, | |
571 EC_POINT *, BN_CTX *); | |
572 | |
573 | |
574 /********************************************************************/ | |
575 /* functions for doing EC_POINT arithmetic */ | |
576 /********************************************************************/ | |
577 | |
578 /** Computes the sum of two EC_POINT | |
579 * \param group underlying EC_GROUP object | |
580 * \param r EC_POINT object for the result (r = a + b) | |
581 * \param a EC_POINT object with the first summand | |
582 * \param b EC_POINT object with the second summand | |
583 * \param ctx BN_CTX object (optional) | |
584 * \return 1 on success and 0 if an error occured | |
585 */ | |
586 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC
_POINT *b, BN_CTX *ctx); | |
587 | |
588 /** Computes the double of a EC_POINT | |
589 * \param group underlying EC_GROUP object | |
590 * \param r EC_POINT object for the result (r = 2 * a) | |
591 * \param a EC_POINT object | |
592 * \param ctx BN_CTX object (optional) | |
593 * \return 1 on success and 0 if an error occured | |
594 */ | |
595 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *
ctx); | |
596 | |
597 /** Computes the inverse of a EC_POINT | |
598 * \param group underlying EC_GROUP object | |
599 * \param a EC_POINT object to be inverted (it's used for the result as w
ell) | |
600 * \param ctx BN_CTX object (optional) | |
601 * \return 1 on success and 0 if an error occured | |
602 */ | |
603 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx); | |
604 | |
605 /** Checks whether the point is the neutral element of the group | |
606 * \param group the underlying EC_GROUP object | |
607 * \param p EC_POINT object | |
608 * \return 1 if the point is the neutral element and 0 otherwise | |
609 */ | |
610 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p); | |
611 | |
612 /** Checks whether the point is on the curve | |
613 * \param group underlying EC_GROUP object | |
614 * \param point EC_POINT object to check | |
615 * \param ctx BN_CTX object (optional) | |
616 * \return 1 if point if on the curve and 0 otherwise | |
617 */ | |
618 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *c
tx); | |
619 | |
620 /** Compares two EC_POINTs | |
621 * \param group underlying EC_GROUP object | |
622 * \param a first EC_POINT object | |
623 * \param b second EC_POINT object | |
624 * \param ctx BN_CTX object (optional) | |
625 * \return 0 if both points are equal and a value != 0 otherwise | |
626 */ | |
627 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN
_CTX *ctx); | |
628 | |
629 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx); | |
630 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[],
BN_CTX *ctx); | |
631 | |
632 /** Computes r = generator * n sum_{i=0}^num p[i] * m[i] | |
633 * \param group underlying EC_GROUP object | |
634 * \param r EC_POINT object for the result | |
635 * \param n BIGNUM with the multiplier for the group generator (optional) | |
636 * \param num number futher summands | |
637 * \param p array of size num of EC_POINT objects | |
638 * \param m array of size num of BIGNUM objects | |
639 * \param ctx BN_CTX object (optional) | |
640 * \return 1 on success and 0 if an error occured | |
641 */ | |
642 int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, size_t nu
m, const EC_POINT *p[], const BIGNUM *m[], BN_CTX *ctx); | |
643 | |
644 /** Computes r = generator * n + q * m | |
645 * \param group underlying EC_GROUP object | |
646 * \param r EC_POINT object for the result | |
647 * \param n BIGNUM with the multiplier for the group generator (optional) | |
648 * \param q EC_POINT object with the first factor of the second summand | |
649 * \param m BIGNUM with the second factor of the second summand | |
650 * \param ctx BN_CTX object (optional) | |
651 * \return 1 on success and 0 if an error occured | |
652 */ | |
653 int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, const EC_P
OINT *q, const BIGNUM *m, BN_CTX *ctx); | |
654 | |
655 /** Stores multiples of generator for faster point multiplication | |
656 * \param group EC_GROUP object | |
657 * \param ctx BN_CTX object (optional) | |
658 * \return 1 on success and 0 if an error occured | |
659 */ | |
660 int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx); | |
661 | |
662 /** Reports whether a precomputation has been done | |
663 * \param group EC_GROUP object | |
664 * \return 1 if a pre-computation has been done and 0 otherwise | |
665 */ | |
666 int EC_GROUP_have_precompute_mult(const EC_GROUP *group); | |
667 | |
668 | |
669 /********************************************************************/ | |
670 /* ASN1 stuff */ | |
671 /********************************************************************/ | |
672 | |
673 /* EC_GROUP_get_basis_type() returns the NID of the basis type | |
674 * used to represent the field elements */ | |
675 int EC_GROUP_get_basis_type(const EC_GROUP *); | |
676 #ifndef OPENSSL_NO_EC2M | |
677 int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k); | |
678 int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1, | |
679 unsigned int *k2, unsigned int *k3); | |
680 #endif | |
681 | |
682 #define OPENSSL_EC_NAMED_CURVE 0x001 | |
683 | |
684 typedef struct ecpk_parameters_st ECPKPARAMETERS; | |
685 | |
686 EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len); | |
687 int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out); | |
688 | |
689 #define d2i_ECPKParameters_bio(bp,x) ASN1_d2i_bio_of(EC_GROUP,NULL,d2i_ECPKParam
eters,bp,x) | |
690 #define i2d_ECPKParameters_bio(bp,x) ASN1_i2d_bio_of_const(EC_GROUP,i2d_ECPKPara
meters,bp,x) | |
691 #define d2i_ECPKParameters_fp(fp,x) (EC_GROUP *)ASN1_d2i_fp(NULL, \ | |
692 (char *(*)())d2i_ECPKParameters,(fp),(unsigned char **)(x)) | |
693 #define i2d_ECPKParameters_fp(fp,x) ASN1_i2d_fp(i2d_ECPKParameters,(fp), \ | |
694 (unsigned char *)(x)) | |
695 | |
696 #ifndef OPENSSL_NO_BIO | |
697 int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off); | |
698 #endif | |
699 #ifndef OPENSSL_NO_FP_API | |
700 int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off); | |
701 #endif | |
702 | |
703 | |
704 /********************************************************************/ | |
705 /* EC_KEY functions */ | |
706 /********************************************************************/ | |
707 | |
708 typedef struct ec_key_st EC_KEY; | |
709 | |
710 /* some values for the encoding_flag */ | |
711 #define EC_PKEY_NO_PARAMETERS 0x001 | |
712 #define EC_PKEY_NO_PUBKEY 0x002 | |
713 | |
714 /* some values for the flags field */ | |
715 #define EC_FLAG_NON_FIPS_ALLOW 0x1 | |
716 #define EC_FLAG_FIPS_CHECKED 0x2 | |
717 | |
718 /** Creates a new EC_KEY object. | |
719 * \return EC_KEY object or NULL if an error occurred. | |
720 */ | |
721 EC_KEY *EC_KEY_new(void); | |
722 | |
723 int EC_KEY_get_flags(const EC_KEY *key); | |
724 | |
725 void EC_KEY_set_flags(EC_KEY *key, int flags); | |
726 | |
727 void EC_KEY_clear_flags(EC_KEY *key, int flags); | |
728 | |
729 /** Creates a new EC_KEY object using a named curve as underlying | |
730 * EC_GROUP object. | |
731 * \param nid NID of the named curve. | |
732 * \return EC_KEY object or NULL if an error occurred. | |
733 */ | |
734 EC_KEY *EC_KEY_new_by_curve_name(int nid); | |
735 | |
736 /** Frees a EC_KEY object. | |
737 * \param key EC_KEY object to be freed. | |
738 */ | |
739 void EC_KEY_free(EC_KEY *key); | |
740 | |
741 /** Copies a EC_KEY object. | |
742 * \param dst destination EC_KEY object | |
743 * \param src src EC_KEY object | |
744 * \return dst or NULL if an error occurred. | |
745 */ | |
746 EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src); | |
747 | |
748 /** Creates a new EC_KEY object and copies the content from src to it. | |
749 * \param src the source EC_KEY object | |
750 * \return newly created EC_KEY object or NULL if an error occurred. | |
751 */ | |
752 EC_KEY *EC_KEY_dup(const EC_KEY *src); | |
753 | |
754 /** Increases the internal reference count of a EC_KEY object. | |
755 * \param key EC_KEY object | |
756 * \return 1 on success and 0 if an error occurred. | |
757 */ | |
758 int EC_KEY_up_ref(EC_KEY *key); | |
759 | |
760 /** Returns the EC_GROUP object of a EC_KEY object | |
761 * \param key EC_KEY object | |
762 * \return the EC_GROUP object (possibly NULL). | |
763 */ | |
764 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key); | |
765 | |
766 /** Sets the EC_GROUP of a EC_KEY object. | |
767 * \param key EC_KEY object | |
768 * \param group EC_GROUP to use in the EC_KEY object (note: the EC_KEY | |
769 * object will use an own copy of the EC_GROUP). | |
770 * \return 1 on success and 0 if an error occurred. | |
771 */ | |
772 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group); | |
773 | |
774 /** Returns the private key of a EC_KEY object. | |
775 * \param key EC_KEY object | |
776 * \return a BIGNUM with the private key (possibly NULL). | |
777 */ | |
778 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key); | |
779 | |
780 /** Sets the private key of a EC_KEY object. | |
781 * \param key EC_KEY object | |
782 * \param prv BIGNUM with the private key (note: the EC_KEY object | |
783 * will use an own copy of the BIGNUM). | |
784 * \return 1 on success and 0 if an error occurred. | |
785 */ | |
786 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv); | |
787 | |
788 /** Returns the public key of a EC_KEY object. | |
789 * \param key the EC_KEY object | |
790 * \return a EC_POINT object with the public key (possibly NULL) | |
791 */ | |
792 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key); | |
793 | |
794 /** Sets the public key of a EC_KEY object. | |
795 * \param key EC_KEY object | |
796 * \param pub EC_POINT object with the public key (note: the EC_KEY object | |
797 * will use an own copy of the EC_POINT object). | |
798 * \return 1 on success and 0 if an error occurred. | |
799 */ | |
800 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub); | |
801 | |
802 unsigned EC_KEY_get_enc_flags(const EC_KEY *key); | |
803 void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags); | |
804 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key); | |
805 void EC_KEY_set_conv_form(EC_KEY *eckey, point_conversion_form_t cform); | |
806 /* functions to set/get method specific data */ | |
807 void *EC_KEY_get_key_method_data(EC_KEY *key, | |
808 void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_
func)(void *)); | |
809 /** Sets the key method data of an EC_KEY object, if none has yet been set. | |
810 * \param key EC_KEY object | |
811 * \param data opaque data to install. | |
812 * \param dup_func a function that duplicates |data|. | |
813 * \param free_func a function that frees |data|. | |
814 * \param clear_free_func a function that wipes and frees |data|. | |
815 * \return the previously set data pointer, or NULL if |data| was inserted. | |
816 */ | |
817 void *EC_KEY_insert_key_method_data(EC_KEY *key, void *data, | |
818 void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_
func)(void *)); | |
819 /* wrapper functions for the underlying EC_GROUP object */ | |
820 void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag); | |
821 | |
822 /** Creates a table of pre-computed multiples of the generator to | |
823 * accelerate further EC_KEY operations. | |
824 * \param key EC_KEY object | |
825 * \param ctx BN_CTX object (optional) | |
826 * \return 1 on success and 0 if an error occurred. | |
827 */ | |
828 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx); | |
829 | |
830 /** Creates a new ec private (and optional a new public) key. | |
831 * \param key EC_KEY object | |
832 * \return 1 on success and 0 if an error occurred. | |
833 */ | |
834 int EC_KEY_generate_key(EC_KEY *key); | |
835 | |
836 /** Verifies that a private and/or public key is valid. | |
837 * \param key the EC_KEY object | |
838 * \return 1 on success and 0 otherwise. | |
839 */ | |
840 int EC_KEY_check_key(const EC_KEY *key); | |
841 | |
842 /** Sets a public key from affine coordindates performing | |
843 * neccessary NIST PKV tests. | |
844 * \param key the EC_KEY object | |
845 * \param x public key x coordinate | |
846 * \param y public key y coordinate | |
847 * \return 1 on success and 0 otherwise. | |
848 */ | |
849 int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y); | |
850 | |
851 | |
852 /********************************************************************/ | |
853 /* de- and encoding functions for SEC1 ECPrivateKey */ | |
854 /********************************************************************/ | |
855 | |
856 /** Decodes a private key from a memory buffer. | |
857 * \param key a pointer to a EC_KEY object which should be used (or NULL) | |
858 * \param in pointer to memory with the DER encoded private key | |
859 * \param len length of the DER encoded private key | |
860 * \return the decoded private key or NULL if an error occurred. | |
861 */ | |
862 EC_KEY *d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len); | |
863 | |
864 /** Encodes a private key object and stores the result in a buffer. | |
865 * \param key the EC_KEY object to encode | |
866 * \param out the buffer for the result (if NULL the function returns number | |
867 * of bytes needed). | |
868 * \return 1 on success and 0 if an error occurred. | |
869 */ | |
870 int i2d_ECPrivateKey(EC_KEY *key, unsigned char **out); | |
871 | |
872 | |
873 /********************************************************************/ | |
874 /* de- and encoding functions for EC parameters */ | |
875 /********************************************************************/ | |
876 | |
877 /** Decodes ec parameter from a memory buffer. | |
878 * \param key a pointer to a EC_KEY object which should be used (or NULL) | |
879 * \param in pointer to memory with the DER encoded ec parameters | |
880 * \param len length of the DER encoded ec parameters | |
881 * \return a EC_KEY object with the decoded parameters or NULL if an error | |
882 * occurred. | |
883 */ | |
884 EC_KEY *d2i_ECParameters(EC_KEY **key, const unsigned char **in, long len); | |
885 | |
886 /** Encodes ec parameter and stores the result in a buffer. | |
887 * \param key the EC_KEY object with ec paramters to encode | |
888 * \param out the buffer for the result (if NULL the function returns number | |
889 * of bytes needed). | |
890 * \return 1 on success and 0 if an error occurred. | |
891 */ | |
892 int i2d_ECParameters(EC_KEY *key, unsigned char **out); | |
893 | |
894 | |
895 /********************************************************************/ | |
896 /* de- and encoding functions for EC public key */ | |
897 /* (octet string, not DER -- hence 'o2i' and 'i2o') */ | |
898 /********************************************************************/ | |
899 | |
900 /** Decodes a ec public key from a octet string. | |
901 * \param key a pointer to a EC_KEY object which should be used | |
902 * \param in memory buffer with the encoded public key | |
903 * \param len length of the encoded public key | |
904 * \return EC_KEY object with decoded public key or NULL if an error | |
905 * occurred. | |
906 */ | |
907 EC_KEY *o2i_ECPublicKey(EC_KEY **key, const unsigned char **in, long len); | |
908 | |
909 /** Encodes a ec public key in an octet string. | |
910 * \param key the EC_KEY object with the public key | |
911 * \param out the buffer for the result (if NULL the function returns number | |
912 * of bytes needed). | |
913 * \return 1 on success and 0 if an error occurred | |
914 */ | |
915 int i2o_ECPublicKey(EC_KEY *key, unsigned char **out); | |
916 | |
917 #ifndef OPENSSL_NO_BIO | |
918 /** Prints out the ec parameters on human readable form. | |
919 * \param bp BIO object to which the information is printed | |
920 * \param key EC_KEY object | |
921 * \return 1 on success and 0 if an error occurred | |
922 */ | |
923 int ECParameters_print(BIO *bp, const EC_KEY *key); | |
924 | |
925 /** Prints out the contents of a EC_KEY object | |
926 * \param bp BIO object to which the information is printed | |
927 * \param key EC_KEY object | |
928 * \param off line offset | |
929 * \return 1 on success and 0 if an error occurred | |
930 */ | |
931 int EC_KEY_print(BIO *bp, const EC_KEY *key, int off); | |
932 | |
933 #endif | |
934 #ifndef OPENSSL_NO_FP_API | |
935 /** Prints out the ec parameters on human readable form. | |
936 * \param fp file descriptor to which the information is printed | |
937 * \param key EC_KEY object | |
938 * \return 1 on success and 0 if an error occurred | |
939 */ | |
940 int ECParameters_print_fp(FILE *fp, const EC_KEY *key); | |
941 | |
942 /** Prints out the contents of a EC_KEY object | |
943 * \param fp file descriptor to which the information is printed | |
944 * \param key EC_KEY object | |
945 * \param off line offset | |
946 * \return 1 on success and 0 if an error occurred | |
947 */ | |
948 int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off); | |
949 | |
950 #endif | |
951 | |
952 #define ECParameters_dup(x) ASN1_dup_of(EC_KEY,i2d_ECParameters,d2i_ECParameters
,x) | |
953 | |
954 #ifndef __cplusplus | |
955 #if defined(__SUNPRO_C) | |
956 # if __SUNPRO_C >= 0x520 | |
957 # pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPL
ETE) | |
958 # endif | |
959 # endif | |
960 #endif | |
961 | |
962 #define EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid) \ | |
963 EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, EVP_PKEY_OP_PARAMGEN, \ | |
964 EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, nid, NULL) | |
965 | |
966 | |
967 #define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID (EVP_PKEY_ALG_CTRL + 1) | |
968 | |
969 /* BEGIN ERROR CODES */ | |
970 /* The following lines are auto generated by the script mkerr.pl. Any changes | |
971 * made after this point may be overwritten when the script is next run. | |
972 */ | |
973 void ERR_load_EC_strings(void); | |
974 | |
975 /* Error codes for the EC functions. */ | |
976 | |
977 /* Function codes. */ | |
978 #define EC_F_BN_TO_FELEM 224 | |
979 #define EC_F_COMPUTE_WNAF 143 | |
980 #define EC_F_D2I_ECPARAMETERS 144 | |
981 #define EC_F_D2I_ECPKPARAMETERS 145 | |
982 #define EC_F_D2I_ECPRIVATEKEY 146 | |
983 #define EC_F_DO_EC_KEY_PRINT 221 | |
984 #define EC_F_ECKEY_PARAM2TYPE 223 | |
985 #define EC_F_ECKEY_PARAM_DECODE 212 | |
986 #define EC_F_ECKEY_PRIV_DECODE 213 | |
987 #define EC_F_ECKEY_PRIV_ENCODE 214 | |
988 #define EC_F_ECKEY_PUB_DECODE 215 | |
989 #define EC_F_ECKEY_PUB_ENCODE 216 | |
990 #define EC_F_ECKEY_TYPE2PARAM 220 | |
991 #define EC_F_ECPARAMETERS_PRINT 147 | |
992 #define EC_F_ECPARAMETERS_PRINT_FP 148 | |
993 #define EC_F_ECPKPARAMETERS_PRINT 149 | |
994 #define EC_F_ECPKPARAMETERS_PRINT_FP 150 | |
995 #define EC_F_ECP_NIST_MOD_192 203 | |
996 #define EC_F_ECP_NIST_MOD_224 204 | |
997 #define EC_F_ECP_NIST_MOD_256 205 | |
998 #define EC_F_ECP_NIST_MOD_521 206 | |
999 #define EC_F_EC_ASN1_GROUP2CURVE 153 | |
1000 #define EC_F_EC_ASN1_GROUP2FIELDID 154 | |
1001 #define EC_F_EC_ASN1_GROUP2PARAMETERS 155 | |
1002 #define EC_F_EC_ASN1_GROUP2PKPARAMETERS 156 | |
1003 #define EC_F_EC_ASN1_PARAMETERS2GROUP 157 | |
1004 #define EC_F_EC_ASN1_PKPARAMETERS2GROUP 158 | |
1005 #define EC_F_EC_EX_DATA_SET_DATA 211 | |
1006 #define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 208 | |
1007 #define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 159 | |
1008 #define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 195 | |
1009 #define EC_F_EC_GF2M_SIMPLE_OCT2POINT 160 | |
1010 #define EC_F_EC_GF2M_SIMPLE_POINT2OCT 161 | |
1011 #define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 162 | |
1012 #define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 163 | |
1013 #define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 164 | |
1014 #define EC_F_EC_GFP_MONT_FIELD_DECODE 133 | |
1015 #define EC_F_EC_GFP_MONT_FIELD_ENCODE 134 | |
1016 #define EC_F_EC_GFP_MONT_FIELD_MUL 131 | |
1017 #define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 209 | |
1018 #define EC_F_EC_GFP_MONT_FIELD_SQR 132 | |
1019 #define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 189 | |
1020 #define EC_F_EC_GFP_MONT_GROUP_SET_CURVE_GFP 135 | |
1021 #define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE 225 | |
1022 #define EC_F_EC_GFP_NISTP224_POINTS_MUL 228 | |
1023 #define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 226 | |
1024 #define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE 230 | |
1025 #define EC_F_EC_GFP_NISTP256_POINTS_MUL 231 | |
1026 #define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 232 | |
1027 #define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE 233 | |
1028 #define EC_F_EC_GFP_NISTP521_POINTS_MUL 234 | |
1029 #define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 235 | |
1030 #define EC_F_EC_GFP_NIST_FIELD_MUL 200 | |
1031 #define EC_F_EC_GFP_NIST_FIELD_SQR 201 | |
1032 #define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 202 | |
1033 #define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 165 | |
1034 #define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 166 | |
1035 #define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE_GFP 100 | |
1036 #define EC_F_EC_GFP_SIMPLE_GROUP_SET_GENERATOR 101 | |
1037 #define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 102 | |
1038 #define EC_F_EC_GFP_SIMPLE_OCT2POINT 103 | |
1039 #define EC_F_EC_GFP_SIMPLE_POINT2OCT 104 | |
1040 #define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 137 | |
1041 #define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 167 | |
1042 #define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES_GFP 105 | |
1043 #define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 168 | |
1044 #define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES_GFP 128 | |
1045 #define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 169 | |
1046 #define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES_GFP 129 | |
1047 #define EC_F_EC_GROUP_CHECK 170 | |
1048 #define EC_F_EC_GROUP_CHECK_DISCRIMINANT 171 | |
1049 #define EC_F_EC_GROUP_COPY 106 | |
1050 #define EC_F_EC_GROUP_GET0_GENERATOR 139 | |
1051 #define EC_F_EC_GROUP_GET_COFACTOR 140 | |
1052 #define EC_F_EC_GROUP_GET_CURVE_GF2M 172 | |
1053 #define EC_F_EC_GROUP_GET_CURVE_GFP 130 | |
1054 #define EC_F_EC_GROUP_GET_DEGREE 173 | |
1055 #define EC_F_EC_GROUP_GET_ORDER 141 | |
1056 #define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 193 | |
1057 #define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 194 | |
1058 #define EC_F_EC_GROUP_NEW 108 | |
1059 #define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 174 | |
1060 #define EC_F_EC_GROUP_NEW_FROM_DATA 175 | |
1061 #define EC_F_EC_GROUP_PRECOMPUTE_MULT 142 | |
1062 #define EC_F_EC_GROUP_SET_CURVE_GF2M 176 | |
1063 #define EC_F_EC_GROUP_SET_CURVE_GFP 109 | |
1064 #define EC_F_EC_GROUP_SET_EXTRA_DATA 110 | |
1065 #define EC_F_EC_GROUP_SET_GENERATOR 111 | |
1066 #define EC_F_EC_KEY_CHECK_KEY 177 | |
1067 #define EC_F_EC_KEY_COPY 178 | |
1068 #define EC_F_EC_KEY_GENERATE_KEY 179 | |
1069 #define EC_F_EC_KEY_NEW 182 | |
1070 #define EC_F_EC_KEY_PRINT 180 | |
1071 #define EC_F_EC_KEY_PRINT_FP 181 | |
1072 #define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES 229 | |
1073 #define EC_F_EC_POINTS_MAKE_AFFINE 136 | |
1074 #define EC_F_EC_POINT_ADD 112 | |
1075 #define EC_F_EC_POINT_CMP 113 | |
1076 #define EC_F_EC_POINT_COPY 114 | |
1077 #define EC_F_EC_POINT_DBL 115 | |
1078 #define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 183 | |
1079 #define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 116 | |
1080 #define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 117 | |
1081 #define EC_F_EC_POINT_INVERT 210 | |
1082 #define EC_F_EC_POINT_IS_AT_INFINITY 118 | |
1083 #define EC_F_EC_POINT_IS_ON_CURVE 119 | |
1084 #define EC_F_EC_POINT_MAKE_AFFINE 120 | |
1085 #define EC_F_EC_POINT_MUL 184 | |
1086 #define EC_F_EC_POINT_NEW 121 | |
1087 #define EC_F_EC_POINT_OCT2POINT 122 | |
1088 #define EC_F_EC_POINT_POINT2OCT 123 | |
1089 #define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 185 | |
1090 #define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 124 | |
1091 #define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 186 | |
1092 #define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 125 | |
1093 #define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 126 | |
1094 #define EC_F_EC_POINT_SET_TO_INFINITY 127 | |
1095 #define EC_F_EC_PRE_COMP_DUP 207 | |
1096 #define EC_F_EC_PRE_COMP_NEW 196 | |
1097 #define EC_F_EC_WNAF_MUL 187 | |
1098 #define EC_F_EC_WNAF_PRECOMPUTE_MULT 188 | |
1099 #define EC_F_I2D_ECPARAMETERS 190 | |
1100 #define EC_F_I2D_ECPKPARAMETERS 191 | |
1101 #define EC_F_I2D_ECPRIVATEKEY 192 | |
1102 #define EC_F_I2O_ECPUBLICKEY 151 | |
1103 #define EC_F_NISTP224_PRE_COMP_NEW 227 | |
1104 #define EC_F_NISTP256_PRE_COMP_NEW 236 | |
1105 #define EC_F_NISTP521_PRE_COMP_NEW 237 | |
1106 #define EC_F_O2I_ECPUBLICKEY 152 | |
1107 #define EC_F_OLD_EC_PRIV_DECODE 222 | |
1108 #define EC_F_PKEY_EC_CTRL 197 | |
1109 #define EC_F_PKEY_EC_CTRL_STR 198 | |
1110 #define EC_F_PKEY_EC_DERIVE 217 | |
1111 #define EC_F_PKEY_EC_KEYGEN 199 | |
1112 #define EC_F_PKEY_EC_PARAMGEN 219 | |
1113 #define EC_F_PKEY_EC_SIGN 218 | |
1114 | |
1115 /* Reason codes. */ | |
1116 #define EC_R_ASN1_ERROR 115 | |
1117 #define EC_R_ASN1_UNKNOWN_FIELD 116 | |
1118 #define EC_R_BIGNUM_OUT_OF_RANGE 144 | |
1119 #define EC_R_BUFFER_TOO_SMALL 100 | |
1120 #define EC_R_COORDINATES_OUT_OF_RANGE 146 | |
1121 #define EC_R_D2I_ECPKPARAMETERS_FAILURE 117 | |
1122 #define EC_R_DECODE_ERROR 142 | |
1123 #define EC_R_DISCRIMINANT_IS_ZERO 118 | |
1124 #define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE 119 | |
1125 #define EC_R_FIELD_TOO_LARGE 143 | |
1126 #define EC_R_GF2M_NOT_SUPPORTED 147 | |
1127 #define EC_R_GROUP2PKPARAMETERS_FAILURE 120 | |
1128 #define EC_R_I2D_ECPKPARAMETERS_FAILURE 121 | |
1129 #define EC_R_INCOMPATIBLE_OBJECTS 101 | |
1130 #define EC_R_INVALID_ARGUMENT 112 | |
1131 #define EC_R_INVALID_COMPRESSED_POINT 110 | |
1132 #define EC_R_INVALID_COMPRESSION_BIT 109 | |
1133 #define EC_R_INVALID_CURVE 141 | |
1134 #define EC_R_INVALID_DIGEST_TYPE 138 | |
1135 #define EC_R_INVALID_ENCODING 102 | |
1136 #define EC_R_INVALID_FIELD 103 | |
1137 #define EC_R_INVALID_FORM 104 | |
1138 #define EC_R_INVALID_GROUP_ORDER 122 | |
1139 #define EC_R_INVALID_PENTANOMIAL_BASIS 132 | |
1140 #define EC_R_INVALID_PRIVATE_KEY 123 | |
1141 #define EC_R_INVALID_TRINOMIAL_BASIS 137 | |
1142 #define EC_R_KEYS_NOT_SET 140 | |
1143 #define EC_R_MISSING_PARAMETERS 124 | |
1144 #define EC_R_MISSING_PRIVATE_KEY 125 | |
1145 #define EC_R_NOT_A_NIST_PRIME 135 | |
1146 #define EC_R_NOT_A_SUPPORTED_NIST_PRIME 136 | |
1147 #define EC_R_NOT_IMPLEMENTED 126 | |
1148 #define EC_R_NOT_INITIALIZED 111 | |
1149 #define EC_R_NO_FIELD_MOD 133 | |
1150 #define EC_R_NO_PARAMETERS_SET 139 | |
1151 #define EC_R_PASSED_NULL_PARAMETER 134 | |
1152 #define EC_R_PKPARAMETERS2GROUP_FAILURE 127 | |
1153 #define EC_R_POINT_AT_INFINITY 106 | |
1154 #define EC_R_POINT_IS_NOT_ON_CURVE 107 | |
1155 #define EC_R_SLOT_FULL 108 | |
1156 #define EC_R_UNDEFINED_GENERATOR 113 | |
1157 #define EC_R_UNDEFINED_ORDER 128 | |
1158 #define EC_R_UNKNOWN_GROUP 129 | |
1159 #define EC_R_UNKNOWN_ORDER 114 | |
1160 #define EC_R_UNSUPPORTED_FIELD 131 | |
1161 #define EC_R_WRONG_CURVE_PARAMETERS 145 | |
1162 #define EC_R_WRONG_ORDER 130 | |
1163 | |
1164 #ifdef __cplusplus | |
1165 } | |
1166 #endif | |
1167 #endif | |
OLD | NEW |