Support building the distribution .tar file on platforms with limited
[openssl.git] / crypto / ec / ec_lib.c
1 /* crypto/ec/ec_lib.c */
2 /* ====================================================================
3  * Copyright (c) 1998-2002 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 #include <openssl/opensslv.h>
60
61 #include "ec_lcl.h"
62
63 static const char EC_version[] = "EC" OPENSSL_VERSION_PTEXT;
64
65
66 /* functions for EC_GROUP objects */
67
68 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
69         {
70         EC_GROUP *ret;
71
72         if (meth == NULL)
73                 {
74                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
75                 return NULL;
76                 }
77         if (meth->group_init == 0)
78                 {
79                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
80                 return NULL;
81                 }
82
83         ret = OPENSSL_malloc(sizeof *ret);
84         if (ret == NULL)
85                 {
86                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
87                 return NULL;
88                 }
89
90         ret->meth = meth;
91
92         ret->extra_data = NULL;
93         ret->extra_data_dup_func = 0;
94         ret->extra_data_free_func = 0;
95         ret->extra_data_clear_free_func = 0;
96
97         ret->generator = NULL;
98         BN_init(&ret->order);
99         BN_init(&ret->cofactor);
100
101         ret->nid = 0;   
102         ret->asn1_flag = OPENSSL_EC_EXPLICIT | OPENSSL_EC_COMPRESSED;
103
104         ret->seed = NULL;
105         ret->seed_len = 0;
106
107         if (!meth->group_init(ret))
108                 {
109                 OPENSSL_free(ret);
110                 return NULL;
111                 }
112         
113         return ret;
114         }
115
116
117 void EC_GROUP_free(EC_GROUP *group)
118         {
119         if (!group) return;
120
121         if (group->meth->group_finish != 0)
122                 group->meth->group_finish(group);
123
124         EC_GROUP_free_extra_data(group);
125
126         if (group->generator != NULL)
127                 EC_POINT_free(group->generator);
128         BN_free(&group->order);
129         BN_free(&group->cofactor);
130
131         if (group->seed)
132                 OPENSSL_free(group->seed);
133
134         OPENSSL_free(group);
135         }
136  
137
138 void EC_GROUP_clear_free(EC_GROUP *group)
139         {
140         if (!group) return;
141
142         if (group->meth->group_clear_finish != 0)
143                 group->meth->group_clear_finish(group);
144         else if (group->meth != NULL && group->meth->group_finish != 0)
145                 group->meth->group_finish(group);
146
147         EC_GROUP_clear_free_extra_data(group);
148
149         if (group->generator != NULL)
150                 EC_POINT_clear_free(group->generator);
151         BN_clear_free(&group->order);
152         BN_clear_free(&group->cofactor);
153
154         if (group->seed)
155                 {
156                 memset(group->seed, 0, group->seed_len);
157                 OPENSSL_free(group->seed);
158                 }
159
160         memset(group, 0, sizeof *group);
161         OPENSSL_free(group);
162         }
163
164
165 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
166         {
167         if (dest->meth->group_copy == 0)
168                 {
169                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
170                 return 0;
171                 }
172         if (dest->meth != src->meth)
173                 {
174                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
175                 return 0;
176                 }
177         if (dest == src)
178                 return 1;
179         
180         EC_GROUP_clear_free_extra_data(dest);
181         if (src->extra_data_dup_func)
182                 {
183                 if (src->extra_data != NULL)
184                         {
185                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
186                         if (dest->extra_data == NULL)
187                                 return 0;
188                         }
189
190                 dest->extra_data_dup_func = src->extra_data_dup_func;
191                 dest->extra_data_free_func = src->extra_data_free_func;
192                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
193                 }
194
195         if (src->generator != NULL)
196                 {
197                 if (dest->generator == NULL)
198                         {
199                         dest->generator = EC_POINT_new(dest);
200                         if (dest->generator == NULL) return 0;
201                         }
202                 if (!EC_POINT_copy(dest->generator, src->generator)) return 0;
203                 }
204         else
205                 {
206                 /* src->generator == NULL */
207                 if (dest->generator != NULL)
208                         {
209                         EC_POINT_clear_free(dest->generator);
210                         dest->generator = NULL;
211                         }
212                 }
213
214         if (!BN_copy(&dest->order, &src->order)) return 0;
215         if (!BN_copy(&dest->cofactor, &src->cofactor)) return 0;
216
217         dest->nid = src->nid;
218         dest->asn1_flag = src->asn1_flag;
219
220         if (src->seed)
221                 {
222                 if (dest->seed)
223                         OPENSSL_free(dest->seed);
224                 dest->seed = OPENSSL_malloc(src->seed_len);
225                 if (dest->seed == NULL)
226                         return 0;
227                 if (!memcpy(dest->seed, src->seed, src->seed_len))
228                         return 0;
229                 dest->seed_len = src->seed_len;
230                 }
231         else
232                 {
233                 if (dest->seed)
234                         OPENSSL_free(dest->seed);
235                 dest->seed = NULL;
236                 dest->seed_len = 0;
237                 }
238         
239
240         return dest->meth->group_copy(dest, src);
241         }
242
243
244 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
245         {
246         return group->meth;
247         }
248
249
250 int EC_METHOD_get_field_type(const EC_METHOD *meth)
251         {
252         return meth->field_type;
253         }
254
255
256 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
257         {
258         if (generator == NULL)
259                 {
260                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
261                 return 0   ;
262                 }
263
264         if (group->generator == NULL)
265                 {
266                 group->generator = EC_POINT_new(group);
267                 if (group->generator == NULL) return 0;
268                 }
269         if (!EC_POINT_copy(group->generator, generator)) return 0;
270
271         if (order != NULL)
272                 { if (!BN_copy(&group->order, order)) return 0; }       
273         else
274                 { if (!BN_zero(&group->order)) return 0; }      
275
276         if (cofactor != NULL)
277                 { if (!BN_copy(&group->cofactor, cofactor)) return 0; } 
278         else
279                 { if (!BN_zero(&group->cofactor)) return 0; }   
280
281         return 1;
282         }
283
284
285 EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
286         {
287         return group->generator;
288         }
289
290
291 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
292         {
293         if (!BN_copy(order, &group->order))
294                 return 0;
295
296         return !BN_is_zero(order);
297         }
298
299
300 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
301         {
302         if (!BN_copy(cofactor, &group->cofactor))
303                 return 0;
304
305         return !BN_is_zero(&group->cofactor);
306         }
307
308
309 void EC_GROUP_set_nid(EC_GROUP *group, int nid)
310         {
311         group->nid = nid;
312         }
313
314
315 int EC_GROUP_get_nid(const EC_GROUP *group)
316         {
317         return group->nid;
318         }
319
320
321 void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
322         {
323         group->asn1_flag = flag;
324         }
325
326
327 int EC_GROUP_get_asn1_flag(const EC_GROUP *group)
328         {
329         return group->asn1_flag;
330         }
331
332
333 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
334         {
335         if (group->meth->group_set_curve_GFp == 0)
336                 {
337                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
338                 return 0;
339                 }
340         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
341         }
342
343
344 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
345         {
346         if (group->meth->group_get_curve_GFp == 0)
347                 {
348                 ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
349                 return 0;
350                 }
351         return group->meth->group_get_curve_GFp(group, p, a, b, ctx);
352         }
353
354
355 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
356         {
357         if (group->meth->group_check_discriminant == 0)
358                 {
359                 ECerr(EC_F_EC_GROUP_CHECK_DISCRIMINANT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
360                 return 0;
361                 }
362         return group->meth->group_check_discriminant(group, ctx);
363         }
364
365
366 /* this has 'package' visibility */
367 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
368         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
369         {
370         if ((group->extra_data != NULL)
371                 || (group->extra_data_dup_func != 0)
372                 || (group->extra_data_free_func != 0)
373                 || (group->extra_data_clear_free_func != 0))
374                 {
375                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
376                 return 0;
377                 }
378
379         group->extra_data = extra_data;
380         group->extra_data_dup_func = extra_data_dup_func;
381         group->extra_data_free_func = extra_data_free_func;
382         group->extra_data_clear_free_func = extra_data_clear_free_func;
383         return 1;
384         }
385
386
387 /* this has 'package' visibility */
388 void *EC_GROUP_get_extra_data(const EC_GROUP *group, void *(*extra_data_dup_func)(void *),
389         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
390         {
391         if ((group->extra_data_dup_func != extra_data_dup_func)
392                 || (group->extra_data_free_func != extra_data_free_func)
393                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
394                 {
395                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
396                 return NULL;
397                 }
398
399         return group->extra_data;
400         }
401
402
403 /* this has 'package' visibility */
404 void EC_GROUP_free_extra_data(EC_GROUP *group)
405         {
406         if (group->extra_data_free_func)
407                 group->extra_data_free_func(group->extra_data);
408         group->extra_data = NULL;
409         group->extra_data_dup_func = 0;
410         group->extra_data_free_func = 0;
411         group->extra_data_clear_free_func = 0;
412         }
413
414
415 /* this has 'package' visibility */
416 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
417         {
418         if (group->extra_data_clear_free_func)
419                 group->extra_data_clear_free_func(group->extra_data);
420         else if (group->extra_data_free_func)
421                 group->extra_data_free_func(group->extra_data);
422         group->extra_data = NULL;
423         group->extra_data_dup_func = 0;
424         group->extra_data_free_func = 0;
425         group->extra_data_clear_free_func = 0;
426         }
427
428
429 /* functions for EC_POINT objects */
430
431 EC_POINT *EC_POINT_new(const EC_GROUP *group)
432         {
433         EC_POINT *ret;
434
435         if (group == NULL)
436                 {
437                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
438                 return NULL;
439                 }
440         if (group->meth->point_init == 0)
441                 {
442                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
443                 return NULL;
444                 }
445
446         ret = OPENSSL_malloc(sizeof *ret);
447         if (ret == NULL)
448                 {
449                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
450                 return NULL;
451                 }
452
453         ret->meth = group->meth;
454         
455         if (!ret->meth->point_init(ret))
456                 {
457                 OPENSSL_free(ret);
458                 return NULL;
459                 }
460         
461         return ret;
462         }
463
464
465 void EC_POINT_free(EC_POINT *point)
466         {
467         if (!point) return;
468
469         if (point->meth->point_finish != 0)
470                 point->meth->point_finish(point);
471         OPENSSL_free(point);
472         }
473  
474
475 void EC_POINT_clear_free(EC_POINT *point)
476         {
477         if (!point) return;
478
479         if (point->meth->point_clear_finish != 0)
480                 point->meth->point_clear_finish(point);
481         else if (point->meth != NULL && point->meth->point_finish != 0)
482                 point->meth->point_finish(point);
483         memset(point, 0, sizeof *point);
484         OPENSSL_free(point);
485         }
486
487
488 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
489         {
490         if (dest->meth->point_copy == 0)
491                 {
492                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
493                 return 0;
494                 }
495         if (dest->meth != src->meth)
496                 {
497                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
498                 return 0;
499                 }
500         if (dest == src)
501                 return 1;
502         return dest->meth->point_copy(dest, src);
503         }
504
505
506 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
507         {
508         return point->meth;
509         }
510
511
512 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
513         {
514         if (group->meth->point_set_to_infinity == 0)
515                 {
516                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
517                 return 0;
518                 }
519         if (group->meth != point->meth)
520                 {
521                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
522                 return 0;
523                 }
524         return group->meth->point_set_to_infinity(group, point);
525         }
526
527
528 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
529         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
530         {
531         if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
532                 {
533                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
534                 return 0;
535                 }
536         if (group->meth != point->meth)
537                 {
538                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
539                 return 0;
540                 }
541         return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
542         }
543
544
545 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
546         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
547         {
548         if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
549                 {
550                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
551                 return 0;
552                 }
553         if (group->meth != point->meth)
554                 {
555                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
556                 return 0;
557                 }
558         return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
559         }
560
561
562 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
563         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
564         {
565         if (group->meth->point_set_affine_coordinates_GFp == 0)
566                 {
567                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
568                 return 0;
569                 }
570         if (group->meth != point->meth)
571                 {
572                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
573                 return 0;
574                 }
575         return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
576         }
577
578
579 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
580         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
581         {
582         if (group->meth->point_get_affine_coordinates_GFp == 0)
583                 {
584                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
585                 return 0;
586                 }
587         if (group->meth != point->meth)
588                 {
589                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
590                 return 0;
591                 }
592         return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
593         }
594
595
596 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
597         const BIGNUM *x, int y_bit, BN_CTX *ctx)
598         {
599         if (group->meth->point_set_compressed_coordinates_GFp == 0)
600                 {
601                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
602                 return 0;
603                 }
604         if (group->meth != point->meth)
605                 {
606                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
607                 return 0;
608                 }
609         return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
610         }
611
612
613 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
614         unsigned char *buf, size_t len, BN_CTX *ctx)
615         {
616         if (group->meth->point2oct == 0)
617                 {
618                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
619                 return 0;
620                 }
621         if (group->meth != point->meth)
622                 {
623                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
624                 return 0;
625                 }
626         return group->meth->point2oct(group, point, form, buf, len, ctx);
627         }
628
629
630 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
631         const unsigned char *buf, size_t len, BN_CTX *ctx)
632         {
633         if (group->meth->oct2point == 0)
634                 {
635                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
636                 return 0;
637                 }
638         if (group->meth != point->meth)
639                 {
640                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
641                 return 0;
642                 }
643         return group->meth->oct2point(group, point, buf, len, ctx);
644         }
645
646
647 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
648         {
649         if (group->meth->add == 0)
650                 {
651                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
652                 return 0;
653                 }
654         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
655                 {
656                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
657                 return 0;
658                 }
659         return group->meth->add(group, r, a, b, ctx);
660         }
661
662
663 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
664         {
665         if (group->meth->dbl == 0)
666                 {
667                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
668                 return 0;
669                 }
670         if ((group->meth != r->meth) || (r->meth != a->meth))
671                 {
672                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
673                 return 0;
674                 }
675         return group->meth->dbl(group, r, a, ctx);
676         }
677
678
679 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
680         {
681         if (group->meth->dbl == 0)
682                 {
683                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
684                 return 0;
685                 }
686         if (group->meth != a->meth)
687                 {
688                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
689                 return 0;
690                 }
691         return group->meth->invert(group, a, ctx);
692         }
693
694
695 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
696         {
697         if (group->meth->is_at_infinity == 0)
698                 {
699                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
700                 return 0;
701                 }
702         if (group->meth != point->meth)
703                 {
704                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
705                 return 0;
706                 }
707         return group->meth->is_at_infinity(group, point);
708         }
709
710
711 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
712         {
713         if (group->meth->is_on_curve == 0)
714                 {
715                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
716                 return 0;
717                 }
718         if (group->meth != point->meth)
719                 {
720                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
721                 return 0;
722                 }
723         return group->meth->is_on_curve(group, point, ctx);
724         }
725
726
727 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
728         {
729         if (group->meth->point_cmp == 0)
730                 {
731                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
732                 return 0;
733                 }
734         if ((group->meth != a->meth) || (a->meth != b->meth))
735                 {
736                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
737                 return 0;
738                 }
739         return group->meth->point_cmp(group, a, b, ctx);
740         }
741
742
743 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
744         {
745         if (group->meth->make_affine == 0)
746                 {
747                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
748                 return 0;
749                 }
750         if (group->meth != point->meth)
751                 {
752                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
753                 return 0;
754                 }
755         return group->meth->make_affine(group, point, ctx);
756         }
757
758
759 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
760         {
761         size_t i;
762
763         if (group->meth->points_make_affine == 0)
764                 {
765                 ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
766                 return 0;
767                 }
768         for (i = 0; i < num; i++)
769                 {
770                 if (group->meth != points[i]->meth)
771                         {
772                         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
773                         return 0;
774                         }
775                 }
776         return group->meth->points_make_affine(group, num, points, ctx);
777         }