[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 <string.h>

#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;

	ret->extra_data = NULL;
	ret->extra_data_dup_func = 0;
	ret->extra_data_free_func = 0;
	ret->extra_data_clear_free_func = 0;
	
	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);

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


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: 'set' and 'get' functions for EC_GROUPs */


/* 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(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);
	}


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);
	}
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
c4b36ff4 BM	56	#include <string.h>
c4b36ff4 BM	57
0657bf9c BM	58	#include <openssl/err.h>
0657bf9c BM	59
65e81670	60	#include "ec_lcl.h"
0657bf9c BM	61
	62
	63	/* functions for EC_GROUP objects */
	64
	65	EC_GROUP EC_GROUP_new(const EC_METHOD meth)
	66	{
	67	EC_GROUP *ret;
	68
	69	if (meth == NULL)
	70	{
	71	ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
	72	return NULL;
	73	}
	74	if (meth->group_init == 0)
	75	{
	76	ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	77	return NULL;
	78	}
	79
	80	ret = OPENSSL_malloc(sizeof *ret);
	81	if (ret == NULL)
	82	{
	83	ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
	84	return NULL;
	85	}
	86
	87	ret->meth = meth;
df9cc153 BM	88
	89	ret->extra_data = NULL;
	90	ret->extra_data_dup_func = 0;
	91	ret->extra_data_free_func = 0;
	92	ret->extra_data_clear_free_func = 0;
0657bf9c BM	93
	94	if (!meth->group_init(ret))
	95	{
	96	OPENSSL_free(ret);
	97	return NULL;
	98	}
	99
	100	return ret;
	101	}
	102
	103
	104	int EC_GROUP_set_curve_GFp(EC_GROUP group, const BIGNUM p, const BIGNUM a, const BIGNUM b, BN_CTX *ctx)
	105	{
	106	if (group->meth->group_set_curve_GFp == 0)
	107	{
	108	ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	109	return 0;
	110	}
0657bf9c BM	111	return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
	112	}
	113
	114
	115	void EC_GROUP_free(EC_GROUP *group)
	116	{
	117	if (group->meth->group_finish != 0)
	118	group->meth->group_finish(group);
df9cc153 BM	119
	120	EC_GROUP_free_extra_data(group);
	121
0657bf9c BM	122	OPENSSL_free(group);
	123	}
	124
	125
	126	void EC_GROUP_clear_free(EC_GROUP *group)
	127	{
	128	if (group->meth->group_clear_finish != 0)
	129	group->meth->group_clear_finish(group);
	130	else if (group->meth != NULL && group->meth->group_finish != 0)
	131	group->meth->group_finish(group);
df9cc153 BM	132
	133	EC_GROUP_clear_free_extra_data(group);
	134
c4b36ff4	135	memset(group, 0, sizeof *group);
0657bf9c BM	136	OPENSSL_free(group);
	137	}
	138
	139
	140	int EC_GROUP_copy(EC_GROUP dest, const EC_GROUP src)
	141	{
	142	if (dest->meth->group_copy == 0)
	143	{
	144	ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	145	return 0;
	146	}
	147	if (dest->meth != src->meth)
	148	{
	149	ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
	150	return 0;
	151	}
1d5bd6cf BM	152	if (dest == src)
1d5bd6cf BM	153	return 1;
0657bf9c	154
df9cc153 BM	155	EC_GROUP_clear_free_extra_data(dest);
	156	if (src->extra_data_dup_func)
	157	{
	158	if (src->extra_data != NULL)
	159	{
	160	dest->extra_data = src->extra_data_dup_func(src->extra_data);
	161	if (dest->extra_data == NULL)
	162	return 0;
	163	}
	164
	165	dest->extra_data_dup_func = src->extra_data_dup_func;
	166	dest->extra_data_free_func = src->extra_data_free_func;
	167	dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
	168	}
	169
0657bf9c BM	170	return dest->meth->group_copy(dest, src);
	171	}
	172
	173
	174	int EC_GROUP_set_generator(EC_GROUP group, const EC_POINT generator, const BIGNUM order, const BIGNUM cofactor)
	175	{
	176	if (group->meth->group_set_generator == 0)
	177	{
	178	ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	179	return 0;
	180	}
	181	return group->meth->group_set_generator(group, generator, order, cofactor);
	182	}
	183
	184
2e0db076	185	/* TODO: 'set' and 'get' functions for EC_GROUPs */
0657bf9c BM	186
0657bf9c BM	187
df9cc153 BM	188	/* this has 'package' visibility */
	189	int EC_GROUP_set_extra_data(EC_GROUP group, void extra_data, void (extra_data_dup_func)(void *),
	190	void (extra_data_free_func)(void ), void (extra_data_clear_free_func)(void ))
	191	{
	192	if ((group->extra_data != NULL)
	193	\|\| (group->extra_data_dup_func != 0)
	194	\|\| (group->extra_data_free_func != 0)
	195	\|\| (group->extra_data_clear_free_func != 0))
	196	{
	197	ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
	198	return 0;
	199	}
	200
	201	group->extra_data = extra_data;
	202	group->extra_data_dup_func = extra_data_dup_func;
	203	group->extra_data_free_func = extra_data_free_func;
	204	group->extra_data_clear_free_func = extra_data_clear_free_func;
	205	return 1;
	206	}
	207
	208
	209	/* this has 'package' visibility */
	210	void EC_GROUP_get_extra_data(EC_GROUP group, void (extra_data_dup_func)(void *),
	211	void (extra_data_free_func)(void ), void (extra_data_clear_free_func)(void ))
	212	{
	213	if ((group->extra_data_dup_func != extra_data_dup_func)
	214	\|\| (group->extra_data_free_func != extra_data_free_func)
	215	\|\| (group->extra_data_clear_free_func != extra_data_clear_free_func))
	216	{
	217	ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
	218	return NULL;
	219	}
	220
	221	return group->extra_data;
	222	}
	223
	224
	225	/* this has 'package' visibility */
	226	void EC_GROUP_free_extra_data(EC_GROUP *group)
	227	{
	228	if (group->extra_data_free_func)
	229	group->extra_data_free_func(group->extra_data);
	230	group->extra_data = NULL;
	231	group->extra_data_dup_func = 0;
	232	group->extra_data_free_func = 0;
	233	group->extra_data_clear_free_func = 0;
	234	}
	235
	236
	237	/* this has 'package' visibility */
	238	void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
	239	{
	240	if (group->extra_data_clear_free_func)
	241	group->extra_data_clear_free_func(group->extra_data);
	242	else if (group->extra_data_free_func)
	243	group->extra_data_free_func(group->extra_data);
	244	group->extra_data = NULL;
	245	group->extra_data_dup_func = 0;
	246	group->extra_data_free_func = 0;
	247	group->extra_data_clear_free_func = 0;
	248	}
	249
	250
0657bf9c BM	251
	252	/* functions for EC_POINT objects */
	253
	254	EC_POINT EC_POINT_new(const EC_GROUP group)
	255	{
	256	EC_POINT *ret;
	257
	258	if (group == NULL)
	259	{
	260	ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
	261	return NULL;
	262	}
	263	if (group->meth->point_init == 0)
	264	{
	265	ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	266	return NULL;
	267	}
	268
	269	ret = OPENSSL_malloc(sizeof *ret);
	270	if (ret == NULL)
	271	{
	272	ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
	273	return NULL;
	274	}
	275
	276	ret->meth = group->meth;
	277
	278	if (!ret->meth->point_init(ret))
	279	{
	280	OPENSSL_free(ret);
	281	return NULL;
	282	}
	283
	284	return ret;
	285	}
	286
	287
	288	void EC_POINT_free(EC_POINT *point)
	289	{
	290	if (point->meth->point_finish != 0)
	291	point->meth->point_finish(point);
	292	OPENSSL_free(point);
	293	}
	294
	295
	296	void EC_POINT_clear_free(EC_POINT *point)
	297	{
	298	if (point->meth->point_clear_finish != 0)
	299	point->meth->point_clear_finish(point);
	300	else if (point->meth != NULL && point->meth->point_finish != 0)
	301	point->meth->point_finish(point);
f418f8c1	302	memset(point, 0, sizeof *point);
0657bf9c BM	303	OPENSSL_free(point);
	304	}
	305
	306
	307	int EC_POINT_copy(EC_POINT dest, const EC_POINT src)
	308	{
	309	if (dest->meth->point_copy == 0)
	310	{
	311	ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	312	return 0;
	313	}
	314	if (dest->meth != src->meth)
	315	{
	316	ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
	317	return 0;
	318	}
91f29a38 BM	319	if (dest == src)
91f29a38 BM	320	return 1;
0657bf9c BM	321	return dest->meth->point_copy(dest, src);
	322	}
	323
	324
226cc7de BM	325	int EC_POINT_set_to_infinity(const EC_GROUP group, EC_POINT point)
	326	{
	327	if (group->meth->point_set_to_infinity == 0)
	328	{
	329	ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	330	return 0;
	331	}
	332	if (group->meth != point->meth)
	333	{
	334	ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
	335	return 0;
	336	}
	337	return group->meth->point_set_to_infinity(group, point);
	338	}
	339
	340
1d5bd6cf BM	341	int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP group, EC_POINT point,
	342	const BIGNUM x, const BIGNUM y, const BIGNUM z, BN_CTX ctx)
	343	{
	344	if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
	345	{
	346	ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	347	return 0;
	348	}
	349	if (group->meth != point->meth)
	350	{
	351	ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
	352	return 0;
	353	}
	354	return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
	355	}
	356
	357
	358	int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP group, const EC_POINT point,
	359	BIGNUM x, BIGNUM y, BIGNUM z, BN_CTX ctx)
	360	{
	361	if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
	362	{
	363	ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	364	return 0;
	365	}
	366	if (group->meth != point->meth)
	367	{
	368	ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
	369	return 0;
	370	}
	371	return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
	372	}
	373
	374
226cc7de BM	375	int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP group, EC_POINT point,
	376	const BIGNUM x, const BIGNUM y, BN_CTX *ctx)
	377	{
	378	if (group->meth->point_set_affine_coordinates_GFp == 0)
	379	{
	380	ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	381	return 0;
	382	}
	383	if (group->meth != point->meth)
	384	{
	385	ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
	386	return 0;
	387	}
	388	return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
	389	}
	390
	391
	392	int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP group, const EC_POINT point,
	393	BIGNUM x, BIGNUM y, BN_CTX *ctx)
	394	{
	395	if (group->meth->point_get_affine_coordinates_GFp == 0)
	396	{
	397	ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	398	return 0;
	399	}
	400	if (group->meth != point->meth)
	401	{
	402	ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
	403	return 0;
	404	}
	405	return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
	406	}
	407
	408
1d5bd6cf BM	409	int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP group, EC_POINT point,
	410	const BIGNUM x, int y_bit, BN_CTX ctx)
	411	{
	412	if (group->meth->point_set_compressed_coordinates_GFp == 0)
	413	{
	414	ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	415	return 0;
	416	}
	417	if (group->meth != point->meth)
	418	{
	419	ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
	420	return 0;
	421	}
	422	return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
	423	}
0657bf9c BM	424
	425
	426	size_t EC_POINT_point2oct(const EC_GROUP group, const EC_POINT point, point_conversion_form_t form,
	427	unsigned char buf, size_t len, BN_CTX ctx)
	428	{
	429	if (group->meth->point2oct == 0)
	430	{
	431	ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	432	return 0;
	433	}
	434	if (group->meth != point->meth)
	435	{
	436	ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
	437	return 0;
	438	}
	439	return group->meth->point2oct(group, point, form, buf, len, ctx);
	440	}
	441
	442
	443	int EC_POINT_oct2point(const EC_GROUP group, EC_POINT point,
	444	const unsigned char buf, size_t len, BN_CTX ctx)
	445	{
	446	if (group->meth->oct2point == 0)
	447	{
	448	ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	449	return 0;
	450	}
	451	if (group->meth != point->meth)
	452	{
	453	ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
	454	return 0;
	455	}
	456	return group->meth->oct2point(group, point, buf, len, ctx);
	457	}
	458
	459
	460	int EC_POINT_add(const EC_GROUP group, EC_POINT r, const EC_POINT a, const EC_POINT b, BN_CTX *ctx)
	461	{
	462	if (group->meth->add == 0)
	463	{
	464	ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	465	return 0;
	466	}
	467	if ((group->meth != r->meth) \|\| (r->meth != a->meth) \|\| (a->meth != b->meth))
	468	{
	469	ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
	470	return 0;
	471	}
	472	return group->meth->add(group, r, a, b, ctx);
	473	}
	474
	475
	476	int EC_POINT_dbl(const EC_GROUP group, EC_POINT r, const EC_POINT a, BN_CTX ctx)
	477	{
	478	if (group->meth->dbl == 0)
	479	{
	480	ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	481	return 0;
	482	}
	483	if ((group->meth != r->meth) \|\| (r->meth != a->meth))
	484	{
	485	ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
	486	return 0;
	487	}
488	return group->meth->dbl(group, r, a, ctx);
489	}
490
491
1d5bd6cf BM	492	int EC_POINT_invert(const EC_GROUP group, EC_POINT a, BN_CTX *ctx)
	493	{
	494	if (group->meth->dbl == 0)
	495	{
	496	ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	497	return 0;
	498	}
	499	if (group->meth != a->meth)
	500	{
	501	ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
	502	return 0;
	503	}
	504	return group->meth->invert(group, a, ctx);
	505	}
	506
	507
0657bf9c BM	508	int EC_POINT_is_at_infinity(const EC_GROUP group, const EC_POINT point)
	509	{
	510	if (group->meth->is_at_infinity == 0)
	511	{
	512	ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	513	return 0;
	514	}
	515	if (group->meth != point->meth)
	516	{
	517	ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
	518	return 0;
	519	}
	520	return group->meth->is_at_infinity(group, point);
	521	}
	522
	523
	524	int EC_POINT_is_on_curve(const EC_GROUP group, const EC_POINT point, BN_CTX *ctx)
	525	{
	526	if (group->meth->is_on_curve == 0)
	527	{
	528	ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	529	return 0;
	530	}
	531	if (group->meth != point->meth)
	532	{
	533	ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
	534	return 0;
	535	}
	536	return group->meth->is_on_curve(group, point, ctx);
	537	}
	538
	539
1d5bd6cf BM	540	int EC_POINT_cmp(const EC_GROUP group, const EC_POINT a, const EC_POINT b, BN_CTX ctx)
	541	{
	542	if (group->meth->point_cmp == 0)
	543	{
	544	ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	545	return 0;
	546	}
	547	if ((group->meth != a->meth) \|\| (a->meth != b->meth))
	548	{
	549	ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
	550	return 0;
	551	}
	552	return group->meth->point_cmp(group, a, b, ctx);
	553	}
	554
	555
e869d4bd	556	int EC_POINT_make_affine(const EC_GROUP group, EC_POINT point, BN_CTX *ctx)
0657bf9c BM	557	{
	558	if (group->meth->make_affine == 0)
	559	{
	560	ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	561	return 0;
	562	}
	563	if (group->meth != point->meth)
	564	{
	565	ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
	566	return 0;
	567	}
	568	return group->meth->make_affine(group, point, ctx);
	569	}