bef62961e16690e017c25335f9f0fc230c284c77
[openssl.git] / crypto / ec / ec_lib.c
1 /* crypto/ec/ec_lib.c */
2 /* ====================================================================
3  * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer. 
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in
14  *    the documentation and/or other materials provided with the
15  *    distribution.
16  *
17  * 3. All advertising materials mentioning features or use of this
18  *    software must display the following acknowledgment:
19  *    "This product includes software developed by the OpenSSL Project
20  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
21  *
22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23  *    endorse or promote products derived from this software without
24  *    prior written permission. For written permission, please contact
25  *    openssl-core@openssl.org.
26  *
27  * 5. Products derived from this software may not be called "OpenSSL"
28  *    nor may "OpenSSL" appear in their names without prior written
29  *    permission of the OpenSSL Project.
30  *
31  * 6. Redistributions of any form whatsoever must retain the following
32  *    acknowledgment:
33  *    "This product includes software developed by the OpenSSL Project
34  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
35  *
36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47  * OF THE POSSIBILITY OF SUCH DAMAGE.
48  * ====================================================================
49  *
50  * This product includes cryptographic software written by Eric Young
51  * (eay@cryptsoft.com).  This product includes software written by Tim
52  * Hudson (tjh@cryptsoft.com).
53  *
54  */
55
56 #include <string.h>
57
58 #include <openssl/err.h>
59
60 #include "ec_lcl.h"
61
62
63 /* functions for EC_GROUP objects */
64
65 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
66         {
67         EC_GROUP *ret;
68
69         if (meth == NULL)
70                 {
71                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
72                 return NULL;
73                 }
74         if (meth->group_init == 0)
75                 {
76                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
77                 return NULL;
78                 }
79
80         ret = OPENSSL_malloc(sizeof *ret);
81         if (ret == NULL)
82                 {
83                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
84                 return NULL;
85                 }
86
87         ret->meth = meth;
88
89         ret->extra_data = NULL;
90         ret->extra_data_dup_func = 0;
91         ret->extra_data_free_func = 0;
92         ret->extra_data_clear_free_func = 0;
93         
94         if (!meth->group_init(ret))
95                 {
96                 OPENSSL_free(ret);
97                 return NULL;
98                 }
99         
100         return ret;
101         }
102
103
104 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
105         {
106         if (group->meth->group_set_curve_GFp == 0)
107                 {
108                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
109                 return 0;
110                 }
111         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
112         }
113
114
115 void EC_GROUP_free(EC_GROUP *group)
116         {
117         if (group->meth->group_finish != 0)
118                 group->meth->group_finish(group);
119
120         EC_GROUP_free_extra_data(group);
121
122         OPENSSL_free(group);
123         }
124  
125
126 void EC_GROUP_clear_free(EC_GROUP *group)
127         {
128         if (group->meth->group_clear_finish != 0)
129                 group->meth->group_clear_finish(group);
130         else if (group->meth != NULL && group->meth->group_finish != 0)
131                 group->meth->group_finish(group);
132
133         EC_GROUP_clear_free_extra_data(group);
134
135         memset(group, 0, sizeof *group);
136         OPENSSL_free(group);
137         }
138
139
140 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
141         {
142         if (dest->meth->group_copy == 0)
143                 {
144                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
145                 return 0;
146                 }
147         if (dest->meth != src->meth)
148                 {
149                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
150                 return 0;
151                 }
152         if (dest == src)
153                 return 1;
154         
155         EC_GROUP_clear_free_extra_data(dest);
156         if (src->extra_data_dup_func)
157                 {
158                 if (src->extra_data != NULL)
159                         {
160                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
161                         if (dest->extra_data == NULL)
162                                 return 0;
163                         }
164
165                 dest->extra_data_dup_func = src->extra_data_dup_func;
166                 dest->extra_data_free_func = src->extra_data_free_func;
167                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
168                 }
169
170         return dest->meth->group_copy(dest, src);
171         }
172
173
174 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
175         {
176         if (group->meth->group_set_generator == 0)
177                 {
178                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
179                 return 0;
180                 }
181         return group->meth->group_set_generator(group, generator, order, cofactor);
182         }
183
184
185 /* TODO: 'set' and 'get' functions for EC_GROUPs */
186
187
188 /* this has 'package' visibility */
189 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
190         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
191         {
192         if ((group->extra_data != NULL)
193                 || (group->extra_data_dup_func != 0)
194                 || (group->extra_data_free_func != 0)
195                 || (group->extra_data_clear_free_func != 0))
196                 {
197                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
198                 return 0;
199                 }
200
201         group->extra_data = extra_data;
202         group->extra_data_dup_func = extra_data_dup_func;
203         group->extra_data_free_func = extra_data_free_func;
204         group->extra_data_clear_free_func = extra_data_clear_free_func;
205         return 1;
206         }
207
208
209 /* this has 'package' visibility */
210 void *EC_GROUP_get_extra_data(EC_GROUP *group, void *(*extra_data_dup_func)(void *),
211         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
212         {
213         if ((group->extra_data_dup_func != extra_data_dup_func)
214                 || (group->extra_data_free_func != extra_data_free_func)
215                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
216                 {
217                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
218                 return NULL;
219                 }
220
221         return group->extra_data;
222         }
223
224
225 /* this has 'package' visibility */
226 void EC_GROUP_free_extra_data(EC_GROUP *group)
227         {
228         if (group->extra_data_free_func)
229                 group->extra_data_free_func(group->extra_data);
230         group->extra_data = NULL;
231         group->extra_data_dup_func = 0;
232         group->extra_data_free_func = 0;
233         group->extra_data_clear_free_func = 0;
234         }
235
236
237 /* this has 'package' visibility */
238 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
239         {
240         if (group->extra_data_clear_free_func)
241                 group->extra_data_clear_free_func(group->extra_data);
242         else if (group->extra_data_free_func)
243                 group->extra_data_free_func(group->extra_data);
244         group->extra_data = NULL;
245         group->extra_data_dup_func = 0;
246         group->extra_data_free_func = 0;
247         group->extra_data_clear_free_func = 0;
248         }
249
250
251
252 /* functions for EC_POINT objects */
253
254 EC_POINT *EC_POINT_new(const EC_GROUP *group)
255         {
256         EC_POINT *ret;
257
258         if (group == NULL)
259                 {
260                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
261                 return NULL;
262                 }
263         if (group->meth->point_init == 0)
264                 {
265                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
266                 return NULL;
267                 }
268
269         ret = OPENSSL_malloc(sizeof *ret);
270         if (ret == NULL)
271                 {
272                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
273                 return NULL;
274                 }
275
276         ret->meth = group->meth;
277         
278         if (!ret->meth->point_init(ret))
279                 {
280                 OPENSSL_free(ret);
281                 return NULL;
282                 }
283         
284         return ret;
285         }
286
287
288 void EC_POINT_free(EC_POINT *point)
289         {
290         if (point->meth->point_finish != 0)
291                 point->meth->point_finish(point);
292         OPENSSL_free(point);
293         }
294  
295
296 void EC_POINT_clear_free(EC_POINT *point)
297         {
298         if (point->meth->point_clear_finish != 0)
299                 point->meth->point_clear_finish(point);
300         else if (point->meth != NULL && point->meth->point_finish != 0)
301                 point->meth->point_finish(point);
302         memset(point, 0, sizeof *point);
303         OPENSSL_free(point);
304         }
305
306
307 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
308         {
309         if (dest->meth->point_copy == 0)
310                 {
311                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
312                 return 0;
313                 }
314         if (dest->meth != src->meth)
315                 {
316                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
317                 return 0;
318                 }
319         if (dest == src)
320                 return 1;
321         return dest->meth->point_copy(dest, src);
322         }
323
324
325 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
326         {
327         if (group->meth->point_set_to_infinity == 0)
328                 {
329                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
330                 return 0;
331                 }
332         if (group->meth != point->meth)
333                 {
334                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
335                 return 0;
336                 }
337         return group->meth->point_set_to_infinity(group, point);
338         }
339
340
341 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
342         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
343         {
344         if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
345                 {
346                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
347                 return 0;
348                 }
349         if (group->meth != point->meth)
350                 {
351                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
352                 return 0;
353                 }
354         return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
355         }
356
357
358 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
359         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
360         {
361         if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
362                 {
363                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
364                 return 0;
365                 }
366         if (group->meth != point->meth)
367                 {
368                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
369                 return 0;
370                 }
371         return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
372         }
373
374
375 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
376         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
377         {
378         if (group->meth->point_set_affine_coordinates_GFp == 0)
379                 {
380                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
381                 return 0;
382                 }
383         if (group->meth != point->meth)
384                 {
385                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
386                 return 0;
387                 }
388         return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
389         }
390
391
392 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
393         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
394         {
395         if (group->meth->point_get_affine_coordinates_GFp == 0)
396                 {
397                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
398                 return 0;
399                 }
400         if (group->meth != point->meth)
401                 {
402                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
403                 return 0;
404                 }
405         return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
406         }
407
408
409 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
410         const BIGNUM *x, int y_bit, BN_CTX *ctx)
411         {
412         if (group->meth->point_set_compressed_coordinates_GFp == 0)
413                 {
414                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
415                 return 0;
416                 }
417         if (group->meth != point->meth)
418                 {
419                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
420                 return 0;
421                 }
422         return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
423         }
424
425
426 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
427         unsigned char *buf, size_t len, BN_CTX *ctx)
428         {
429         if (group->meth->point2oct == 0)
430                 {
431                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
432                 return 0;
433                 }
434         if (group->meth != point->meth)
435                 {
436                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
437                 return 0;
438                 }
439         return group->meth->point2oct(group, point, form, buf, len, ctx);
440         }
441
442
443 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
444         const unsigned char *buf, size_t len, BN_CTX *ctx)
445         {
446         if (group->meth->oct2point == 0)
447                 {
448                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
449                 return 0;
450                 }
451         if (group->meth != point->meth)
452                 {
453                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
454                 return 0;
455                 }
456         return group->meth->oct2point(group, point, buf, len, ctx);
457         }
458
459
460 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
461         {
462         if (group->meth->add == 0)
463                 {
464                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
465                 return 0;
466                 }
467         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
468                 {
469                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
470                 return 0;
471                 }
472         return group->meth->add(group, r, a, b, ctx);
473         }
474
475
476 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
477         {
478         if (group->meth->dbl == 0)
479                 {
480                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
481                 return 0;
482                 }
483         if ((group->meth != r->meth) || (r->meth != a->meth))
484                 {
485                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
486                 return 0;
487                 }
488         return group->meth->dbl(group, r, a, ctx);
489         }
490
491
492 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
493         {
494         if (group->meth->dbl == 0)
495                 {
496                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
497                 return 0;
498                 }
499         if (group->meth != a->meth)
500                 {
501                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
502                 return 0;
503                 }
504         return group->meth->invert(group, a, ctx);
505         }
506
507
508 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
509         {
510         if (group->meth->is_at_infinity == 0)
511                 {
512                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
513                 return 0;
514                 }
515         if (group->meth != point->meth)
516                 {
517                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
518                 return 0;
519                 }
520         return group->meth->is_at_infinity(group, point);
521         }
522
523
524 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
525         {
526         if (group->meth->is_on_curve == 0)
527                 {
528                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
529                 return 0;
530                 }
531         if (group->meth != point->meth)
532                 {
533                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
534                 return 0;
535                 }
536         return group->meth->is_on_curve(group, point, ctx);
537         }
538
539
540 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
541         {
542         if (group->meth->point_cmp == 0)
543                 {
544                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
545                 return 0;
546                 }
547         if ((group->meth != a->meth) || (a->meth != b->meth))
548                 {
549                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
550                 return 0;
551                 }
552         return group->meth->point_cmp(group, a, b, ctx);
553         }
554
555
556 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
557         {
558         if (group->meth->make_affine == 0)
559                 {
560                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
561                 return 0;
562                 }
563         if (group->meth != point->meth)
564                 {
565                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
566                 return 0;
567                 }
568         return group->meth->make_affine(group, point, ctx);
569         }