[thirdparty/openssl.git] / crypto / ec / ec_lib.c

/* crypto/ec/ec_lib.c */
/* ====================================================================
 * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    openssl-core@openssl.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <openssl/err.h>

#include "ec_lcl.h"


/* functions for EC_GROUP objects */

EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
	{
	EC_GROUP *ret;

	if (meth == NULL)
		{
		ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
		return NULL;
		}
	if (meth->group_init == 0)
		{
		ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return NULL;
		}

	ret = OPENSSL_malloc(sizeof *ret);
	if (ret == NULL)
		{
		ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
		return NULL;
		}

	ret->meth = meth;
	
	if (!meth->group_init(ret))
		{
		OPENSSL_free(ret);
		return NULL;
		}
	
	return ret;
	}


int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
	{
	if (group->meth->group_set_curve_GFp == 0)
		{
		ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	
	return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
	}


void EC_GROUP_free(EC_GROUP *group)
	{
	if (group->meth->group_finish != 0)
		group->meth->group_finish(group);
	OPENSSL_free(group);
	}
 

void EC_GROUP_clear_free(EC_GROUP *group)
	{
	if (group->meth->group_clear_finish != 0)
		group->meth->group_clear_finish(group);
	else if (group->meth != NULL && group->meth->group_finish != 0)
		group->meth->group_finish(group);
	memset(point, 0, sizeof *group);
	OPENSSL_free(group);
	}


int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
	{
	if (dest->meth->group_copy == 0)
		{
		ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (dest->meth != src->meth)
		{
		ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	
	return dest->meth->group_copy(dest, src);
	}


int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
	{
	if (group->meth->group_set_generator == 0)
		{
		ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	return group->meth->group_set_generator(group, generator, order, cofactor);
	}


/* TODO: 'get' functions for EC_GROUPs */


/* functions for EC_POINT objects */

EC_POINT *EC_POINT_new(const EC_GROUP *group)
	{
	EC_POINT *ret;

	if (group == NULL)
		{
		ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
		return NULL;
		}
	if (group->meth->point_init == 0)
		{
		ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return NULL;
		}

	ret = OPENSSL_malloc(sizeof *ret);
	if (ret == NULL)
		{
		ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
		return NULL;
		}

	ret->meth = group->meth;
	
	if (!ret->meth->point_init(ret))
		{
		OPENSSL_free(ret);
		return NULL;
		}
	
	return ret;
	}


void EC_POINT_free(EC_POINT *point)
	{
	if (point->meth->point_finish != 0)
		point->meth->point_finish(point);
	OPENSSL_free(point);
	}
 

void EC_POINT_clear_free(EC_POINT *point)
	{
	if (point->meth->point_clear_finish != 0)
		point->meth->point_clear_finish(point);
	else if (point->meth != NULL && point->meth->point_finish != 0)
		point->meth->point_finish(point);
	memset(point, 0, sizeof *point);
	OPENSSL_free(point);
	}


int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
	{
	if (dest->meth->point_copy == 0)
		{
		ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (dest->meth != src->meth)
		{
		ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	
	return dest->meth->point_copy(dest, src);
	}


/* TODO: 'set' and 'get' functions for EC_POINTs */


size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
        unsigned char *buf, size_t len, BN_CTX *ctx)
	{
	if (group->meth->point2oct == 0)
		{
		ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->point2oct(group, point, form, buf, len, ctx);
	}


int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
        const unsigned char *buf, size_t len, BN_CTX *ctx)
	{
	if (group->meth->oct2point == 0)
		{
		ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->oct2point(group, point, buf, len, ctx);
	}


int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
	{
	if (group->meth->add == 0)
		{
		ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
		{
		ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->add(group, r, a, b, ctx);
	}


int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
	{
	if (group->meth->dbl == 0)
		{
		ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if ((group->meth != r->meth) || (r->meth != a->meth))
		{
		ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->dbl(group, r, a, ctx);
	}


int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
	{
	if (group->meth->is_at_infinity == 0)
		{
		ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->is_at_infinity(group, point);
	}


int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
	{
	if (group->meth->is_on_curve == 0)
		{
		ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->is_on_curve(group, point, ctx);
	}


int EC_POINT_make_affine(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
	{
	if (group->meth->make_affine == 0)
		{
		ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->make_affine(group, point, ctx);
	}
Commit	Line	Data
65e81670 BM	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
0657bf9c BM	56	#include <openssl/err.h>
0657bf9c BM	57
65e81670	58	#include "ec_lcl.h"
0657bf9c BM	59
	60
	61	/* functions for EC_GROUP objects */
	62
	63	EC_GROUP EC_GROUP_new(const EC_METHOD meth)
	64	{
	65	EC_GROUP *ret;
	66
	67	if (meth == NULL)
	68	{
	69	ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
	70	return NULL;
	71	}
	72	if (meth->group_init == 0)
	73	{
	74	ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	75	return NULL;
	76	}
	77
	78	ret = OPENSSL_malloc(sizeof *ret);
	79	if (ret == NULL)
	80	{
	81	ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
	82	return NULL;
	83	}
	84
	85	ret->meth = meth;
	86
	87	if (!meth->group_init(ret))
	88	{
	89	OPENSSL_free(ret);
	90	return NULL;
	91	}
	92
	93	return ret;
	94	}
	95
	96
	97	int EC_GROUP_set_curve_GFp(EC_GROUP group, const BIGNUM p, const BIGNUM a, const BIGNUM b, BN_CTX *ctx)
	98	{
	99	if (group->meth->group_set_curve_GFp == 0)
	100	{
	101	ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	102	return 0;
	103	}
	104
	105	return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
	106	}
	107
	108
	109	void EC_GROUP_free(EC_GROUP *group)
	110	{
	111	if (group->meth->group_finish != 0)
	112	group->meth->group_finish(group);
	113	OPENSSL_free(group);
	114	}
	115
	116
	117	void EC_GROUP_clear_free(EC_GROUP *group)
	118	{
	119	if (group->meth->group_clear_finish != 0)
	120	group->meth->group_clear_finish(group);
	121	else if (group->meth != NULL && group->meth->group_finish != 0)
	122	group->meth->group_finish(group);
f418f8c1	123	memset(point, 0, sizeof *group);
0657bf9c BM	124	OPENSSL_free(group);
	125	}
	126
	127
	128	int EC_GROUP_copy(EC_GROUP dest, const EC_GROUP src)
	129	{
	130	if (dest->meth->group_copy == 0)
	131	{
	132	ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	133	return 0;
	134	}
	135	if (dest->meth != src->meth)
	136	{
	137	ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
	138	return 0;
	139	}
	140
	141	return dest->meth->group_copy(dest, src);
	142	}
	143
	144
	145	int EC_GROUP_set_generator(EC_GROUP group, const EC_POINT generator, const BIGNUM order, const BIGNUM cofactor)
	146	{
	147	if (group->meth->group_set_generator == 0)
	148	{
	149	ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	150	return 0;
	151	}
	152	return group->meth->group_set_generator(group, generator, order, cofactor);
	153	}
	154
	155
	156	/* TODO: 'get' functions for EC_GROUPs */
	157
	158
	159
	160	/* functions for EC_POINT objects */
	161
	162	EC_POINT EC_POINT_new(const EC_GROUP group)
	163	{
	164	EC_POINT *ret;
	165
	166	if (group == NULL)
	167	{
	168	ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
	169	return NULL;
	170	}
	171	if (group->meth->point_init == 0)
	172	{
	173	ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	174	return NULL;
	175	}
	176
	177	ret = OPENSSL_malloc(sizeof *ret);
	178	if (ret == NULL)
	179	{
	180	ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
	181	return NULL;
	182	}
	183
	184	ret->meth = group->meth;
	185
	186	if (!ret->meth->point_init(ret))
	187	{
188	OPENSSL_free(ret);
189	return NULL;
190	}
191
192	return ret;
193	}
194
195
196	void EC_POINT_free(EC_POINT *point)
197	{
198	if (point->meth->point_finish != 0)
199	point->meth->point_finish(point);
200	OPENSSL_free(point);
201	}
202
203
204	void EC_POINT_clear_free(EC_POINT *point)
205	{
206	if (point->meth->point_clear_finish != 0)
207	point->meth->point_clear_finish(point);
208	else if (point->meth != NULL && point->meth->point_finish != 0)
209	point->meth->point_finish(point);
f418f8c1	210	memset(point, 0, sizeof *point);
0657bf9c BM	211	OPENSSL_free(point);
	212	}
	213
	214
	215	int EC_POINT_copy(EC_POINT dest, const EC_POINT src)
	216	{
	217	if (dest->meth->point_copy == 0)
	218	{
	219	ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	220	return 0;
	221	}
	222	if (dest->meth != src->meth)
	223	{
	224	ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
	225	return 0;
	226	}
	227
	228	return dest->meth->point_copy(dest, src);
	229	}
	230
	231
	232	/* TODO: 'set' and 'get' functions for EC_POINTs */
	233
	234
	235	size_t EC_POINT_point2oct(const EC_GROUP group, const EC_POINT point, point_conversion_form_t form,
	236	unsigned char buf, size_t len, BN_CTX ctx)
	237	{
	238	if (group->meth->point2oct == 0)
	239	{
	240	ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	241	return 0;
	242	}
	243	if (group->meth != point->meth)
	244	{
	245	ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
	246	return 0;
	247	}
	248	return group->meth->point2oct(group, point, form, buf, len, ctx);
	249	}
	250
	251
	252	int EC_POINT_oct2point(const EC_GROUP group, EC_POINT point,
	253	const unsigned char buf, size_t len, BN_CTX ctx)
	254	{
	255	if (group->meth->oct2point == 0)
	256	{
	257	ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	258	return 0;
	259	}
	260	if (group->meth != point->meth)
	261	{
	262	ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
	263	return 0;
	264	}
	265	return group->meth->oct2point(group, point, buf, len, ctx);
	266	}
	267
	268
	269	int EC_POINT_add(const EC_GROUP group, EC_POINT r, const EC_POINT a, const EC_POINT b, BN_CTX *ctx)
	270	{
	271	if (group->meth->add == 0)
	272	{
	273	ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	274	return 0;
275	}
276	if ((group->meth != r->meth) \|\| (r->meth != a->meth) \|\| (a->meth != b->meth))
277	{
278	ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
279	return 0;
280	}
281	return group->meth->add(group, r, a, b, ctx);
282	}
283
284
285	int EC_POINT_dbl(const EC_GROUP group, EC_POINT r, const EC_POINT a, BN_CTX ctx)
286	{
287	if (group->meth->dbl == 0)
288	{
289	ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
290	return 0;
291	}
292	if ((group->meth != r->meth) \|\| (r->meth != a->meth))
293	{
294	ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
295	return 0;
296	}
297	return group->meth->dbl(group, r, a, ctx);
298	}
299
300
301	int EC_POINT_is_at_infinity(const EC_GROUP group, const EC_POINT point)
302	{
303	if (group->meth->is_at_infinity == 0)
304	{
305	ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
306	return 0;
307	}
308	if (group->meth != point->meth)
309	{
310	ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
311	return 0;
312	}
313	return group->meth->is_at_infinity(group, point);
314	}
315
316
317	int EC_POINT_is_on_curve(const EC_GROUP group, const EC_POINT point, BN_CTX *ctx)
318	{
319	if (group->meth->is_on_curve == 0)
320	{
321	ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
322	return 0;
323	}
324	if (group->meth != point->meth)
325	{
326	ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
327	return 0;
328	}
329	return group->meth->is_on_curve(group, point, ctx);
330	}
331
332
333	int EC_POINT_make_affine(const EC_GROUP group, const EC_POINT point, BN_CTX *ctx)
334	{
335	if (group->meth->make_affine == 0)
336	{
337	ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
338	return 0;
339	}
340	if (group->meth != point->meth)
341	{
342	ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
343	return 0;
344	}
345	return group->meth->make_affine(group, point, ctx);
346	}