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