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

/* crypto/ec/ec_lib.c */
/* ====================================================================
 * Copyright (c) 1998-2002 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 <string.h>

#include <openssl/err.h>
#include <openssl/opensslv.h>

#include "ec_lcl.h"

static const char EC_version[] = "EC" OPENSSL_VERSION_PTEXT;


/* 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;

	ret->extra_data = NULL;
	ret->extra_data_dup_func = 0;
	ret->extra_data_free_func = 0;
	ret->extra_data_clear_free_func = 0;

	ret->nid = 0;	

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


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

	EC_GROUP_free_extra_data(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);

	EC_GROUP_clear_free_extra_data(group);

	memset(group, 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;
		}
	if (dest == src)
		return 1;
	
	EC_GROUP_clear_free_extra_data(dest);
	if (src->extra_data_dup_func)
		{
		if (src->extra_data != NULL)
			{
			dest->extra_data = src->extra_data_dup_func(src->extra_data);
			if (dest->extra_data == NULL)
				return 0;
			}

		dest->extra_data_dup_func = src->extra_data_dup_func;
		dest->extra_data_free_func = src->extra_data_free_func;
		dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
		}

	return dest->meth->group_copy(dest, src);
	}


const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
	{
	return group->meth;
	}


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);
	}


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


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);
	}


EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
	{
	if (group->meth->group_get0_generator == 0)
		{
		ECerr(EC_F_EC_GROUP_GET0_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	return group->meth->group_get0_generator(group);
	}


int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
	{
	if (group->meth->group_get_order == 0)
		{
		ECerr(EC_F_EC_GROUP_GET_ORDER, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	return group->meth->group_get_order(group, order, ctx);
	}


int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
	{
	if (group->meth->group_get_cofactor == 0)
		{
		ECerr(EC_F_EC_GROUP_GET_COFACTOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	return group->meth->group_get_cofactor(group, cofactor, ctx);
	}


int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx)
	{
	if (group->meth->group_check == 0)
		{
		ECerr(EC_F_EC_GROUP_CHECK, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	return group->meth->group_check(group, ctx);
	}


void EC_GROUP_set_nid(EC_GROUP *group, int nid)
	{
	group->nid = nid;
	}


int EC_GROUP_get_nid(const EC_GROUP *group)
	{
	return group->nid;
	}


/* this has 'package' visibility */
int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
	void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
	{
	if ((group->extra_data != NULL)
		|| (group->extra_data_dup_func != 0)
		|| (group->extra_data_free_func != 0)
		|| (group->extra_data_clear_free_func != 0))
		{
		ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
		return 0;
		}

	group->extra_data = extra_data;
	group->extra_data_dup_func = extra_data_dup_func;
	group->extra_data_free_func = extra_data_free_func;
	group->extra_data_clear_free_func = extra_data_clear_free_func;
	return 1;
	}


/* this has 'package' visibility */
void *EC_GROUP_get_extra_data(const EC_GROUP *group, void *(*extra_data_dup_func)(void *),
	void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
	{
	if ((group->extra_data_dup_func != extra_data_dup_func)
		|| (group->extra_data_free_func != extra_data_free_func)
		|| (group->extra_data_clear_free_func != extra_data_clear_free_func))
		{
		ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
		return NULL;
		}

	return group->extra_data;
	}


/* this has 'package' visibility */
void EC_GROUP_free_extra_data(EC_GROUP *group)
	{
	if (group->extra_data_free_func)
		group->extra_data_free_func(group->extra_data);
	group->extra_data = NULL;
	group->extra_data_dup_func = 0;
	group->extra_data_free_func = 0;
	group->extra_data_clear_free_func = 0;
	}


/* this has 'package' visibility */
void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
	{
	if (group->extra_data_clear_free_func)
		group->extra_data_clear_free_func(group->extra_data);
	else if (group->extra_data_free_func)
		group->extra_data_free_func(group->extra_data);
	group->extra_data = NULL;
	group->extra_data_dup_func = 0;
	group->extra_data_free_func = 0;
	group->extra_data_clear_free_func = 0;
	}


/* 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;
		}
	if (dest == src)
		return 1;
	return dest->meth->point_copy(dest, src);
	}


const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
	{
	return point->meth;
	}


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


int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
	const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
	{
	if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
		{
		ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
	}


int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
	BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
	{
	if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
		{
		ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
	}


int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
	const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
	{
	if (group->meth->point_set_affine_coordinates_GFp == 0)
		{
		ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
	}


int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
	BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
	{
	if (group->meth->point_get_affine_coordinates_GFp == 0)
		{
		ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
	}


int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
	const BIGNUM *x, int y_bit, BN_CTX *ctx)
	{
	if (group->meth->point_set_compressed_coordinates_GFp == 0)
		{
		ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if (group->meth != point->meth)
		{
		ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
	}


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_invert(const EC_GROUP *group, 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 != a->meth)
		{
		ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->invert(group, 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_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
	{
	if (group->meth->point_cmp == 0)
		{
		ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
		return 0;
		}
	if ((group->meth != a->meth) || (a->meth != b->meth))
		{
		ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
		return 0;
		}
	return group->meth->point_cmp(group, a, b, ctx);
	}


int EC_POINT_make_affine(const EC_GROUP *group, 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);
	}


int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
	{
	size_t i;

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