svn merge ^/branches/released .

3 files changed, 3224 insertions, 3212 deletions

diff --git a/openssl/crypto/ec/ec2_smpl.c b/openssl/crypto/ec/ec2_smpl.c
index cf357b462..1725dd128 100644
--- a/openssl/crypto/ec/ec2_smpl.c
+++ b/openssl/crypto/ec/ec2_smpl.c
@@ -1,1039 +1,1042 @@
-/* crypto/ec/ec2_smpl.c */
-/* ====================================================================
- * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
- *
- * The Elliptic Curve Public-Key Crypto Library (ECC Code) included
- * herein is developed by SUN MICROSYSTEMS, INC., and is contributed
- * to the OpenSSL project.
- *
- * The ECC Code is licensed pursuant to the OpenSSL open source
- * license provided below.
- *
- * The software is originally written by Sheueling Chang Shantz and
- * Douglas Stebila of Sun Microsystems Laboratories.
- *
- */
-/* ====================================================================
- * Copyright (c) 1998-2005 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"
-
-
-const EC_METHOD *EC_GF2m_simple_method(void)
-	{
-	static const EC_METHOD ret = {
-		NID_X9_62_characteristic_two_field,
-		ec_GF2m_simple_group_init,
-		ec_GF2m_simple_group_finish,
-		ec_GF2m_simple_group_clear_finish,
-		ec_GF2m_simple_group_copy,
-		ec_GF2m_simple_group_set_curve,
-		ec_GF2m_simple_group_get_curve,
-		ec_GF2m_simple_group_get_degree,
-		ec_GF2m_simple_group_check_discriminant,
-		ec_GF2m_simple_point_init,
-		ec_GF2m_simple_point_finish,
-		ec_GF2m_simple_point_clear_finish,
-		ec_GF2m_simple_point_copy,
-		ec_GF2m_simple_point_set_to_infinity,
-		0 /* set_Jprojective_coordinates_GFp */,
-		0 /* get_Jprojective_coordinates_GFp */,
-		ec_GF2m_simple_point_set_affine_coordinates,
-		ec_GF2m_simple_point_get_affine_coordinates,
-		ec_GF2m_simple_set_compressed_coordinates,
-		ec_GF2m_simple_point2oct,
-		ec_GF2m_simple_oct2point,
-		ec_GF2m_simple_add,
-		ec_GF2m_simple_dbl,
-		ec_GF2m_simple_invert,
-		ec_GF2m_simple_is_at_infinity,
-		ec_GF2m_simple_is_on_curve,
-		ec_GF2m_simple_cmp,
-		ec_GF2m_simple_make_affine,
-		ec_GF2m_simple_points_make_affine,
-
-		/* the following three method functions are defined in ec2_mult.c */
-		ec_GF2m_simple_mul,
-		ec_GF2m_precompute_mult,
-		ec_GF2m_have_precompute_mult,
-
-		ec_GF2m_simple_field_mul,
-		ec_GF2m_simple_field_sqr,
-		ec_GF2m_simple_field_div,
-		0 /* field_encode */,
-		0 /* field_decode */,
-		0 /* field_set_to_one */ };
-
-	return &ret;
-	}
-
-
-/* Initialize a GF(2^m)-based EC_GROUP structure.
- * Note that all other members are handled by EC_GROUP_new.
- */
-int ec_GF2m_simple_group_init(EC_GROUP *group)
-	{
-	BN_init(&group->field);
-	BN_init(&group->a);
-	BN_init(&group->b);
-	return 1;
-	}
-
-
-/* Free a GF(2^m)-based EC_GROUP structure.
- * Note that all other members are handled by EC_GROUP_free.
- */
-void ec_GF2m_simple_group_finish(EC_GROUP *group)
-	{
-	BN_free(&group->field);
-	BN_free(&group->a);
-	BN_free(&group->b);
-	}
-
-
-/* Clear and free a GF(2^m)-based EC_GROUP structure.
- * Note that all other members are handled by EC_GROUP_clear_free.
- */
-void ec_GF2m_simple_group_clear_finish(EC_GROUP *group)
-	{
-	BN_clear_free(&group->field);
-	BN_clear_free(&group->a);
-	BN_clear_free(&group->b);
-	group->poly[0] = 0;
-	group->poly[1] = 0;
-	group->poly[2] = 0;
-	group->poly[3] = 0;
-	group->poly[4] = 0;
-	group->poly[5] = -1;
-	}
-
-
-/* Copy a GF(2^m)-based EC_GROUP structure.
- * Note that all other members are handled by EC_GROUP_copy.
- */
-int ec_GF2m_simple_group_copy(EC_GROUP *dest, const EC_GROUP *src)
-	{
-	int i;
-	if (!BN_copy(&dest->field, &src->field)) return 0;
-	if (!BN_copy(&dest->a, &src->a)) return 0;
-	if (!BN_copy(&dest->b, &src->b)) return 0;
-	dest->poly[0] = src->poly[0];
-	dest->poly[1] = src->poly[1];
-	dest->poly[2] = src->poly[2];
-	dest->poly[3] = src->poly[3];
-	dest->poly[4] = src->poly[4];
-	dest->poly[5] = src->poly[5];
-	if (bn_wexpand(&dest->a, (int)(dest->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) return 0;
-	if (bn_wexpand(&dest->b, (int)(dest->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) return 0;
-	for (i = dest->a.top; i < dest->a.dmax; i++) dest->a.d[i] = 0;
-	for (i = dest->b.top; i < dest->b.dmax; i++) dest->b.d[i] = 0;
-	return 1;
-	}
-
-
-/* Set the curve parameters of an EC_GROUP structure. */
-int ec_GF2m_simple_group_set_curve(EC_GROUP *group,
-	const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
-	{
-	int ret = 0, i;
-
-	/* group->field */
-	if (!BN_copy(&group->field, p)) goto err;
-	i = BN_GF2m_poly2arr(&group->field, group->poly, 6) - 1;
-	if ((i != 5) && (i != 3))
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE, EC_R_UNSUPPORTED_FIELD);
-		goto err;
-		}
-
-	/* group->a */
-	if (!BN_GF2m_mod_arr(&group->a, a, group->poly)) goto err;
-	if(bn_wexpand(&group->a, (int)(group->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) goto err;
-	for (i = group->a.top; i < group->a.dmax; i++) group->a.d[i] = 0;
-	
-	/* group->b */
-	if (!BN_GF2m_mod_arr(&group->b, b, group->poly)) goto err;
-	if(bn_wexpand(&group->b, (int)(group->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) goto err;
-	for (i = group->b.top; i < group->b.dmax; i++) group->b.d[i] = 0;
-		
-	ret = 1;
-  err:
-	return ret;
-	}
-
-
-/* Get the curve parameters of an EC_GROUP structure.
- * If p, a, or b are NULL then there values will not be set but the method will return with success.
- */
-int ec_GF2m_simple_group_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
-	{
-	int ret = 0;
-	
-	if (p != NULL)
-		{
-		if (!BN_copy(p, &group->field)) return 0;
-		}
-
-	if (a != NULL)
-		{
-		if (!BN_copy(a, &group->a)) goto err;
-		}
-
-	if (b != NULL)
-		{
-		if (!BN_copy(b, &group->b)) goto err;
-		}
-	
-	ret = 1;
-	
-  err:
-	return ret;
-	}
-
-
-/* Gets the degree of the field.  For a curve over GF(2^m) this is the value m. */
-int ec_GF2m_simple_group_get_degree(const EC_GROUP *group)
-	{
-	return BN_num_bits(&group->field)-1;
-	}
-
-
-/* Checks the discriminant of the curve.
- * y^2 + x*y = x^3 + a*x^2 + b is an elliptic curve <=> b != 0 (mod p) 
- */
-int ec_GF2m_simple_group_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
-	{
-	int ret = 0;
-	BIGNUM *b;
-	BN_CTX *new_ctx = NULL;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			{
-			ECerr(EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT, ERR_R_MALLOC_FAILURE);
-			goto err;
-			}
-		}
-	BN_CTX_start(ctx);
-	b = BN_CTX_get(ctx);
-	if (b == NULL) goto err;
-
-	if (!BN_GF2m_mod_arr(b, &group->b, group->poly)) goto err;
-	
-	/* check the discriminant:
-	 * y^2 + x*y = x^3 + a*x^2 + b is an elliptic curve <=> b != 0 (mod p) 
-	 */
-	if (BN_is_zero(b)) goto err;
-
-	ret = 1;
-
-err:
-	if (ctx != NULL)
-		BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-/* Initializes an EC_POINT. */
-int ec_GF2m_simple_point_init(EC_POINT *point)
-	{
-	BN_init(&point->X);
-	BN_init(&point->Y);
-	BN_init(&point->Z);
-	return 1;
-	}
-
-
-/* Frees an EC_POINT. */
-void ec_GF2m_simple_point_finish(EC_POINT *point)
-	{
-	BN_free(&point->X);
-	BN_free(&point->Y);
-	BN_free(&point->Z);
-	}
-
-
-/* Clears and frees an EC_POINT. */
-void ec_GF2m_simple_point_clear_finish(EC_POINT *point)
-	{
-	BN_clear_free(&point->X);
-	BN_clear_free(&point->Y);
-	BN_clear_free(&point->Z);
-	point->Z_is_one = 0;
-	}
-
-
-/* Copy the contents of one EC_POINT into another.  Assumes dest is initialized. */
-int ec_GF2m_simple_point_copy(EC_POINT *dest, const EC_POINT *src)
-	{
-	if (!BN_copy(&dest->X, &src->X)) return 0;
-	if (!BN_copy(&dest->Y, &src->Y)) return 0;
-	if (!BN_copy(&dest->Z, &src->Z)) return 0;
-	dest->Z_is_one = src->Z_is_one;
-
-	return 1;
-	}
-
-
-/* Set an EC_POINT to the point at infinity.  
- * A point at infinity is represented by having Z=0.
- */
-int ec_GF2m_simple_point_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
-	{
-	point->Z_is_one = 0;
-	BN_zero(&point->Z);
-	return 1;
-	}
-
-
-/* Set the coordinates of an EC_POINT using affine coordinates. 
- * Note that the simple implementation only uses affine coordinates.
- */
-int ec_GF2m_simple_point_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,
-	const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
-	{
-	int ret = 0;	
-	if (x == NULL || y == NULL)
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES, ERR_R_PASSED_NULL_PARAMETER);
-		return 0;
-		}
-
-	if (!BN_copy(&point->X, x)) goto err;
-	BN_set_negative(&point->X, 0);
-	if (!BN_copy(&point->Y, y)) goto err;
-	BN_set_negative(&point->Y, 0);
-	if (!BN_copy(&point->Z, BN_value_one())) goto err;
-	BN_set_negative(&point->Z, 0);
-	point->Z_is_one = 1;
-	ret = 1;
-
-  err:
-	return ret;
-	}
-
-
-/* Gets the affine coordinates of an EC_POINT. 
- * Note that the simple implementation only uses affine coordinates.
- */
-int ec_GF2m_simple_point_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,
-	BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
-	{
-	int ret = 0;
-
-	if (EC_POINT_is_at_infinity(group, point))
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES, EC_R_POINT_AT_INFINITY);
-		return 0;
-		}
-
-	if (BN_cmp(&point->Z, BN_value_one())) 
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-		return 0;
-		}
-	if (x != NULL)
-		{
-		if (!BN_copy(x, &point->X)) goto err;
-		BN_set_negative(x, 0);
-		}
-	if (y != NULL)
-		{
-		if (!BN_copy(y, &point->Y)) goto err;
-		BN_set_negative(y, 0);
-		}
-	ret = 1;
-		
- err:
-	return ret;
-	}
-
-
-/* Calculates and sets the affine coordinates of an EC_POINT from the given
- * compressed coordinates.  Uses algorithm 2.3.4 of SEC 1. 
- * Note that the simple implementation only uses affine coordinates.
- *
- * The method is from the following publication:
- * 
- *     Harper, Menezes, Vanstone:
- *     "Public-Key Cryptosystems with Very Small Key Lengths",
- *     EUROCRYPT '92, Springer-Verlag LNCS 658,
- *     published February 1993
- *
- * US Patents 6,141,420 and 6,618,483 (Vanstone, Mullin, Agnew) describe
- * the same method, but claim no priority date earlier than July 29, 1994
- * (and additionally fail to cite the EUROCRYPT '92 publication as prior art).
- */
-int ec_GF2m_simple_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *point,
-	const BIGNUM *x_, int y_bit, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *tmp, *x, *y, *z;
-	int ret = 0, z0;
-
-	/* clear error queue */
-	ERR_clear_error();
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	y_bit = (y_bit != 0) ? 1 : 0;
-
-	BN_CTX_start(ctx);
-	tmp = BN_CTX_get(ctx);
-	x = BN_CTX_get(ctx);
-	y = BN_CTX_get(ctx);
-	z = BN_CTX_get(ctx);
-	if (z == NULL) goto err;
-
-	if (!BN_GF2m_mod_arr(x, x_, group->poly)) goto err;
-	if (BN_is_zero(x))
-		{
-		if (!BN_GF2m_mod_sqrt_arr(y, &group->b, group->poly, ctx)) goto err;
-		}
-	else
-		{
-		if (!group->meth->field_sqr(group, tmp, x, ctx)) goto err;
-		if (!group->meth->field_div(group, tmp, &group->b, tmp, ctx)) goto err;
-		if (!BN_GF2m_add(tmp, &group->a, tmp)) goto err;
-		if (!BN_GF2m_add(tmp, x, tmp)) goto err;
-		if (!BN_GF2m_mod_solve_quad_arr(z, tmp, group->poly, ctx))
-			{
-			unsigned long err = ERR_peek_last_error();
-			
-			if (ERR_GET_LIB(err) == ERR_LIB_BN && ERR_GET_REASON(err) == BN_R_NO_SOLUTION)
-				{
-				ERR_clear_error();
-				ECerr(EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSED_POINT);
-				}
-			else
-				ECerr(EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES, ERR_R_BN_LIB);
-			goto err;
-			}
-		z0 = (BN_is_odd(z)) ? 1 : 0;
-		if (!group->meth->field_mul(group, y, x, z, ctx)) goto err;
-		if (z0 != y_bit)
-			{
-			if (!BN_GF2m_add(y, y, x)) goto err;
-			}
-		}
-
-	if (!EC_POINT_set_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;
-
-	ret = 1;
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-/* Converts an EC_POINT to an octet string.  
- * If buf is NULL, the encoded length will be returned.
- * If the length len of buf is smaller than required an error will be returned.
- */
-size_t ec_GF2m_simple_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
-	unsigned char *buf, size_t len, BN_CTX *ctx)
-	{
-	size_t ret;
-	BN_CTX *new_ctx = NULL;
-	int used_ctx = 0;
-	BIGNUM *x, *y, *yxi;
-	size_t field_len, i, skip;
-
-	if ((form != POINT_CONVERSION_COMPRESSED)
-		&& (form != POINT_CONVERSION_UNCOMPRESSED)
-		&& (form != POINT_CONVERSION_HYBRID))
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, EC_R_INVALID_FORM);
-		goto err;
-		}
-
-	if (EC_POINT_is_at_infinity(group, point))
-		{
-		/* encodes to a single 0 octet */
-		if (buf != NULL)
-			{
-			if (len < 1)
-				{
-				ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);
-				return 0;
-				}
-			buf[0] = 0;
-			}
-		return 1;
-		}
-
-
-	/* ret := required output buffer length */
-	field_len = (EC_GROUP_get_degree(group) + 7) / 8;
-	ret = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;
-
-	/* if 'buf' is NULL, just return required length */
-	if (buf != NULL)
-		{
-		if (len < ret)
-			{
-			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);
-			goto err;
-			}
-
-		if (ctx == NULL)
-			{
-			ctx = new_ctx = BN_CTX_new();
-			if (ctx == NULL)
-				return 0;
-			}
-
-		BN_CTX_start(ctx);
-		used_ctx = 1;
-		x = BN_CTX_get(ctx);
-		y = BN_CTX_get(ctx);
-		yxi = BN_CTX_get(ctx);
-		if (yxi == NULL) goto err;
-
-		if (!EC_POINT_get_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;
-
-		buf[0] = form;
-		if ((form != POINT_CONVERSION_UNCOMPRESSED) && !BN_is_zero(x))
-			{
-			if (!group->meth->field_div(group, yxi, y, x, ctx)) goto err;
-			if (BN_is_odd(yxi)) buf[0]++;
-			}
-
-		i = 1;
-		
-		skip = field_len - BN_num_bytes(x);
-		if (skip > field_len)
-			{
-			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-			goto err;
-			}
-		while (skip > 0)
-			{
-			buf[i++] = 0;
-			skip--;
-			}
-		skip = BN_bn2bin(x, buf + i);
-		i += skip;
-		if (i != 1 + field_len)
-			{
-			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-			goto err;
-			}
-
-		if (form == POINT_CONVERSION_UNCOMPRESSED || form == POINT_CONVERSION_HYBRID)
-			{
-			skip = field_len - BN_num_bytes(y);
-			if (skip > field_len)
-				{
-				ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-				goto err;
-				}
-			while (skip > 0)
-				{
-				buf[i++] = 0;
-				skip--;
-				}
-			skip = BN_bn2bin(y, buf + i);
-			i += skip;
-			}
-
-		if (i != ret)
-			{
-			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-			goto err;
-			}
-		}
-	
-	if (used_ctx)
-		BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-
- err:
-	if (used_ctx)
-		BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return 0;
-	}
-
-
-/* Converts an octet string representation to an EC_POINT. 
- * Note that the simple implementation only uses affine coordinates.
- */
-int ec_GF2m_simple_oct2point(const EC_GROUP *group, EC_POINT *point,
-	const unsigned char *buf, size_t len, BN_CTX *ctx)
-	{
-	point_conversion_form_t form;
-	int y_bit;
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *x, *y, *yxi;
-	size_t field_len, enc_len;
-	int ret = 0;
-
-	if (len == 0)
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_BUFFER_TOO_SMALL);
-		return 0;
-		}
-	form = buf[0];
-	y_bit = form & 1;
-	form = form & ~1U;
-	if ((form != 0)	&& (form != POINT_CONVERSION_COMPRESSED)
-		&& (form != POINT_CONVERSION_UNCOMPRESSED)
-		&& (form != POINT_CONVERSION_HYBRID))
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		return 0;
-		}
-	if ((form == 0 || form == POINT_CONVERSION_UNCOMPRESSED) && y_bit)
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		return 0;
-		}
-
-	if (form == 0)
-		{
-		if (len != 1)
-			{
-			ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-			return 0;
-			}
-
-		return EC_POINT_set_to_infinity(group, point);
-		}
-	
-	field_len = (EC_GROUP_get_degree(group) + 7) / 8;
-	enc_len = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;
-
-	if (len != enc_len)
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		return 0;
-		}
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	x = BN_CTX_get(ctx);
-	y = BN_CTX_get(ctx);
-	yxi = BN_CTX_get(ctx);
-	if (yxi == NULL) goto err;
-
-	if (!BN_bin2bn(buf + 1, field_len, x)) goto err;
-	if (BN_ucmp(x, &group->field) >= 0)
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		goto err;
-		}
-
-	if (form == POINT_CONVERSION_COMPRESSED)
-		{
-		if (!EC_POINT_set_compressed_coordinates_GF2m(group, point, x, y_bit, ctx)) goto err;
-		}
-	else
-		{
-		if (!BN_bin2bn(buf + 1 + field_len, field_len, y)) goto err;
-		if (BN_ucmp(y, &group->field) >= 0)
-			{
-			ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-			goto err;
-			}
-		if (form == POINT_CONVERSION_HYBRID)
-			{
-			if (!group->meth->field_div(group, yxi, y, x, ctx)) goto err;
-			if (y_bit != BN_is_odd(yxi))
-				{
-				ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-				goto err;
-				}
-			}
-
-		if (!EC_POINT_set_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;
-		}
-	
-	if (!EC_POINT_is_on_curve(group, point, ctx)) /* test required by X9.62 */
-		{
-		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_POINT_IS_NOT_ON_CURVE);
-		goto err;
-		}
-
-	ret = 1;
-	
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-/* Computes a + b and stores the result in r.  r could be a or b, a could be b.
- * Uses algorithm A.10.2 of IEEE P1363.
- */
-int ec_GF2m_simple_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *x0, *y0, *x1, *y1, *x2, *y2, *s, *t;
-	int ret = 0;
-	
-	if (EC_POINT_is_at_infinity(group, a))
-		{
-		if (!EC_POINT_copy(r, b)) return 0;
-		return 1;
-		}
-
-	if (EC_POINT_is_at_infinity(group, b))
-		{
-		if (!EC_POINT_copy(r, a)) return 0;
-		return 1;
-		}
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	x0 = BN_CTX_get(ctx);
-	y0 = BN_CTX_get(ctx);
-	x1 = BN_CTX_get(ctx);
-	y1 = BN_CTX_get(ctx);
-	x2 = BN_CTX_get(ctx);
-	y2 = BN_CTX_get(ctx);
-	s = BN_CTX_get(ctx);
-	t = BN_CTX_get(ctx);
-	if (t == NULL) goto err;
-
-	if (a->Z_is_one) 
-		{
-		if (!BN_copy(x0, &a->X)) goto err;
-		if (!BN_copy(y0, &a->Y)) goto err;
-		}
-	else
-		{
-		if (!EC_POINT_get_affine_coordinates_GF2m(group, a, x0, y0, ctx)) goto err;
-		}
-	if (b->Z_is_one) 
-		{
-		if (!BN_copy(x1, &b->X)) goto err;
-		if (!BN_copy(y1, &b->Y)) goto err;
-		}
-	else
-		{
-		if (!EC_POINT_get_affine_coordinates_GF2m(group, b, x1, y1, ctx)) goto err;
-		}
-
-
-	if (BN_GF2m_cmp(x0, x1))
-		{
-		if (!BN_GF2m_add(t, x0, x1)) goto err;
-		if (!BN_GF2m_add(s, y0, y1)) goto err;
-		if (!group->meth->field_div(group, s, s, t, ctx)) goto err;
-		if (!group->meth->field_sqr(group, x2, s, ctx)) goto err;
-		if (!BN_GF2m_add(x2, x2, &group->a)) goto err;
-		if (!BN_GF2m_add(x2, x2, s)) goto err;
-		if (!BN_GF2m_add(x2, x2, t)) goto err;
-		}
-	else
-		{
-		if (BN_GF2m_cmp(y0, y1) || BN_is_zero(x1))
-			{
-			if (!EC_POINT_set_to_infinity(group, r)) goto err;
-			ret = 1;
-			goto err;
-			}
-		if (!group->meth->field_div(group, s, y1, x1, ctx)) goto err;
-		if (!BN_GF2m_add(s, s, x1)) goto err;
-		
-		if (!group->meth->field_sqr(group, x2, s, ctx)) goto err;
-		if (!BN_GF2m_add(x2, x2, s)) goto err;
-		if (!BN_GF2m_add(x2, x2, &group->a)) goto err;
-		}
-
-	if (!BN_GF2m_add(y2, x1, x2)) goto err;
-	if (!group->meth->field_mul(group, y2, y2, s, ctx)) goto err;
-	if (!BN_GF2m_add(y2, y2, x2)) goto err;
-	if (!BN_GF2m_add(y2, y2, y1)) goto err;
-
-	if (!EC_POINT_set_affine_coordinates_GF2m(group, r, x2, y2, ctx)) goto err;
-
-	ret = 1;
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-/* Computes 2 * a and stores the result in r.  r could be a.
- * Uses algorithm A.10.2 of IEEE P1363.
- */
-int ec_GF2m_simple_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
-	{
-	return ec_GF2m_simple_add(group, r, a, a, ctx);
-	}
-
-
-int ec_GF2m_simple_invert(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
-	{
-	if (EC_POINT_is_at_infinity(group, point) || BN_is_zero(&point->Y))
-		/* point is its own inverse */
-		return 1;
-	
-	if (!EC_POINT_make_affine(group, point, ctx)) return 0;
-	return BN_GF2m_add(&point->Y, &point->X, &point->Y);
-	}
-
-
-/* Indicates whether the given point is the point at infinity. */
-int ec_GF2m_simple_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
-	{
-	return BN_is_zero(&point->Z);
-	}
-
-
-/* Determines whether the given EC_POINT is an actual point on the curve defined
- * in the EC_GROUP.  A point is valid if it satisfies the Weierstrass equation:
- *      y^2 + x*y = x^3 + a*x^2 + b.
- */
-int ec_GF2m_simple_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
-	{
-	int ret = -1;
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *lh, *y2;
-	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);
-	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);
-
-	if (EC_POINT_is_at_infinity(group, point))
-		return 1;
-
-	field_mul = group->meth->field_mul;
-	field_sqr = group->meth->field_sqr;	
-
-	/* only support affine coordinates */
-	if (!point->Z_is_one) goto err;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return -1;
-		}
-
-	BN_CTX_start(ctx);
-	y2 = BN_CTX_get(ctx);
-	lh = BN_CTX_get(ctx);
-	if (lh == NULL) goto err;
-
-	/* We have a curve defined by a Weierstrass equation
-	 *      y^2 + x*y = x^3 + a*x^2 + b.
-	 *  <=> x^3 + a*x^2 + x*y + b + y^2 = 0
-	 *  <=> ((x + a) * x + y ) * x + b + y^2 = 0
-	 */
-	if (!BN_GF2m_add(lh, &point->X, &group->a)) goto err;
-	if (!field_mul(group, lh, lh, &point->X, ctx)) goto err;
-	if (!BN_GF2m_add(lh, lh, &point->Y)) goto err;
-	if (!field_mul(group, lh, lh, &point->X, ctx)) goto err;
-	if (!BN_GF2m_add(lh, lh, &group->b)) goto err;
-	if (!field_sqr(group, y2, &point->Y, ctx)) goto err;
-	if (!BN_GF2m_add(lh, lh, y2)) goto err;
-	ret = BN_is_zero(lh);
- err:
-	if (ctx) BN_CTX_end(ctx);
-	if (new_ctx) BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-/* Indicates whether two points are equal.
- * Return values:
- *  -1   error
- *   0   equal (in affine coordinates)
- *   1   not equal
- */
-int ec_GF2m_simple_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
-	{
-	BIGNUM *aX, *aY, *bX, *bY;
-	BN_CTX *new_ctx = NULL;
-	int ret = -1;
-
-	if (EC_POINT_is_at_infinity(group, a))
-		{
-		return EC_POINT_is_at_infinity(group, b) ? 0 : 1;
-		}
-	
-	if (a->Z_is_one && b->Z_is_one)
-		{
-		return ((BN_cmp(&a->X, &b->X) == 0) && BN_cmp(&a->Y, &b->Y) == 0) ? 0 : 1;
-		}
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return -1;
-		}
-
-	BN_CTX_start(ctx);
-	aX = BN_CTX_get(ctx);
-	aY = BN_CTX_get(ctx);
-	bX = BN_CTX_get(ctx);
-	bY = BN_CTX_get(ctx);
-	if (bY == NULL) goto err;
-
-	if (!EC_POINT_get_affine_coordinates_GF2m(group, a, aX, aY, ctx)) goto err;
-	if (!EC_POINT_get_affine_coordinates_GF2m(group, b, bX, bY, ctx)) goto err;
-	ret = ((BN_cmp(aX, bX) == 0) && BN_cmp(aY, bY) == 0) ? 0 : 1;
-
-  err:	
-	if (ctx) BN_CTX_end(ctx);
-	if (new_ctx) BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-/* Forces the given EC_POINT to internally use affine coordinates. */
-int ec_GF2m_simple_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *x, *y;
-	int ret = 0;
-
-	if (point->Z_is_one || EC_POINT_is_at_infinity(group, point))
-		return 1;
-	
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	x = BN_CTX_get(ctx);
-	y = BN_CTX_get(ctx);
-	if (y == NULL) goto err;
-	
-	if (!EC_POINT_get_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;
-	if (!BN_copy(&point->X, x)) goto err;
-	if (!BN_copy(&point->Y, y)) goto err;
-	if (!BN_one(&point->Z)) goto err;
-	
-	ret = 1;		
-
-  err:
-	if (ctx) BN_CTX_end(ctx);
-	if (new_ctx) BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-/* Forces each of the EC_POINTs in the given array to use affine coordinates. */
-int ec_GF2m_simple_points_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
-	{
-	size_t i;
-
-	for (i = 0; i < num; i++)
-		{
-		if (!group->meth->make_affine(group, points[i], ctx)) return 0;
-		}
-
-	return 1;
-	}
-
-
-/* Wrapper to simple binary polynomial field multiplication implementation. */
-int ec_GF2m_simple_field_mul(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
-	{
-	return BN_GF2m_mod_mul_arr(r, a, b, group->poly, ctx);
-	}
-
-
-/* Wrapper to simple binary polynomial field squaring implementation. */
-int ec_GF2m_simple_field_sqr(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
-	{
-	return BN_GF2m_mod_sqr_arr(r, a, group->poly, ctx);
-	}
-
-
-/* Wrapper to simple binary polynomial field division implementation. */
-int ec_GF2m_simple_field_div(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
-	{
-	return BN_GF2m_mod_div(r, a, b, &group->field, ctx);
-	}
+/* crypto/ec/ec2_smpl.c */

+/* ====================================================================

+ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

+ *

+ * The Elliptic Curve Public-Key Crypto Library (ECC Code) included

+ * herein is developed by SUN MICROSYSTEMS, INC., and is contributed

+ * to the OpenSSL project.

+ *

+ * The ECC Code is licensed pursuant to the OpenSSL open source

+ * license provided below.

+ *

+ * The software is originally written by Sheueling Chang Shantz and

+ * Douglas Stebila of Sun Microsystems Laboratories.

+ *

+ */

+/* ====================================================================

+ * Copyright (c) 1998-2005 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"

+

+

+const EC_METHOD *EC_GF2m_simple_method(void)

+	{

+	static const EC_METHOD ret = {

+		NID_X9_62_characteristic_two_field,

+		ec_GF2m_simple_group_init,

+		ec_GF2m_simple_group_finish,

+		ec_GF2m_simple_group_clear_finish,

+		ec_GF2m_simple_group_copy,

+		ec_GF2m_simple_group_set_curve,

+		ec_GF2m_simple_group_get_curve,

+		ec_GF2m_simple_group_get_degree,

+		ec_GF2m_simple_group_check_discriminant,

+		ec_GF2m_simple_point_init,

+		ec_GF2m_simple_point_finish,

+		ec_GF2m_simple_point_clear_finish,

+		ec_GF2m_simple_point_copy,

+		ec_GF2m_simple_point_set_to_infinity,

+		0 /* set_Jprojective_coordinates_GFp */,

+		0 /* get_Jprojective_coordinates_GFp */,

+		ec_GF2m_simple_point_set_affine_coordinates,

+		ec_GF2m_simple_point_get_affine_coordinates,

+		ec_GF2m_simple_set_compressed_coordinates,

+		ec_GF2m_simple_point2oct,

+		ec_GF2m_simple_oct2point,

+		ec_GF2m_simple_add,

+		ec_GF2m_simple_dbl,

+		ec_GF2m_simple_invert,

+		ec_GF2m_simple_is_at_infinity,

+		ec_GF2m_simple_is_on_curve,

+		ec_GF2m_simple_cmp,

+		ec_GF2m_simple_make_affine,

+		ec_GF2m_simple_points_make_affine,

+

+		/* the following three method functions are defined in ec2_mult.c */

+		ec_GF2m_simple_mul,

+		ec_GF2m_precompute_mult,

+		ec_GF2m_have_precompute_mult,

+

+		ec_GF2m_simple_field_mul,

+		ec_GF2m_simple_field_sqr,

+		ec_GF2m_simple_field_div,

+		0 /* field_encode */,

+		0 /* field_decode */,

+		0 /* field_set_to_one */ };

+

+	return &ret;

+	}

+

+

+/* Initialize a GF(2^m)-based EC_GROUP structure.

+ * Note that all other members are handled by EC_GROUP_new.

+ */

+int ec_GF2m_simple_group_init(EC_GROUP *group)

+	{

+	BN_init(&group->field);

+	BN_init(&group->a);

+	BN_init(&group->b);

+	return 1;

+	}

+

+

+/* Free a GF(2^m)-based EC_GROUP structure.

+ * Note that all other members are handled by EC_GROUP_free.

+ */

+void ec_GF2m_simple_group_finish(EC_GROUP *group)

+	{

+	BN_free(&group->field);

+	BN_free(&group->a);

+	BN_free(&group->b);

+	}

+

+

+/* Clear and free a GF(2^m)-based EC_GROUP structure.

+ * Note that all other members are handled by EC_GROUP_clear_free.

+ */

+void ec_GF2m_simple_group_clear_finish(EC_GROUP *group)

+	{

+	BN_clear_free(&group->field);

+	BN_clear_free(&group->a);

+	BN_clear_free(&group->b);

+	group->poly[0] = 0;

+	group->poly[1] = 0;

+	group->poly[2] = 0;

+	group->poly[3] = 0;

+	group->poly[4] = 0;

+	group->poly[5] = -1;

+	}

+

+

+/* Copy a GF(2^m)-based EC_GROUP structure.

+ * Note that all other members are handled by EC_GROUP_copy.

+ */

+int ec_GF2m_simple_group_copy(EC_GROUP *dest, const EC_GROUP *src)

+	{

+	int i;

+	if (!BN_copy(&dest->field, &src->field)) return 0;

+	if (!BN_copy(&dest->a, &src->a)) return 0;

+	if (!BN_copy(&dest->b, &src->b)) return 0;

+	dest->poly[0] = src->poly[0];

+	dest->poly[1] = src->poly[1];

+	dest->poly[2] = src->poly[2];

+	dest->poly[3] = src->poly[3];

+	dest->poly[4] = src->poly[4];

+	dest->poly[5] = src->poly[5];

+	if (bn_wexpand(&dest->a, (int)(dest->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) return 0;

+	if (bn_wexpand(&dest->b, (int)(dest->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) return 0;

+	for (i = dest->a.top; i < dest->a.dmax; i++) dest->a.d[i] = 0;

+	for (i = dest->b.top; i < dest->b.dmax; i++) dest->b.d[i] = 0;

+	return 1;

+	}

+

+

+/* Set the curve parameters of an EC_GROUP structure. */

+int ec_GF2m_simple_group_set_curve(EC_GROUP *group,

+	const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)

+	{

+	int ret = 0, i;

+

+	/* group->field */

+	if (!BN_copy(&group->field, p)) goto err;

+	i = BN_GF2m_poly2arr(&group->field, group->poly, 6) - 1;

+	if ((i != 5) && (i != 3))

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE, EC_R_UNSUPPORTED_FIELD);

+		goto err;

+		}

+

+	/* group->a */

+	if (!BN_GF2m_mod_arr(&group->a, a, group->poly)) goto err;

+	if(bn_wexpand(&group->a, (int)(group->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) goto err;

+	for (i = group->a.top; i < group->a.dmax; i++) group->a.d[i] = 0;

+	

+	/* group->b */

+	if (!BN_GF2m_mod_arr(&group->b, b, group->poly)) goto err;

+	if(bn_wexpand(&group->b, (int)(group->poly[0] + BN_BITS2 - 1) / BN_BITS2) == NULL) goto err;

+	for (i = group->b.top; i < group->b.dmax; i++) group->b.d[i] = 0;

+		

+	ret = 1;

+  err:

+	return ret;

+	}

+

+

+/* Get the curve parameters of an EC_GROUP structure.

+ * If p, a, or b are NULL then there values will not be set but the method will return with success.

+ */

+int ec_GF2m_simple_group_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)

+	{

+	int ret = 0;

+	

+	if (p != NULL)

+		{

+		if (!BN_copy(p, &group->field)) return 0;

+		}

+

+	if (a != NULL)

+		{

+		if (!BN_copy(a, &group->a)) goto err;

+		}

+

+	if (b != NULL)

+		{

+		if (!BN_copy(b, &group->b)) goto err;

+		}

+	

+	ret = 1;

+	

+  err:

+	return ret;

+	}

+

+

+/* Gets the degree of the field.  For a curve over GF(2^m) this is the value m. */

+int ec_GF2m_simple_group_get_degree(const EC_GROUP *group)

+	{

+	return BN_num_bits(&group->field)-1;

+	}

+

+

+/* Checks the discriminant of the curve.

+ * y^2 + x*y = x^3 + a*x^2 + b is an elliptic curve <=> b != 0 (mod p) 

+ */

+int ec_GF2m_simple_group_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)

+	{

+	int ret = 0;

+	BIGNUM *b;

+	BN_CTX *new_ctx = NULL;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			{

+			ECerr(EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT, ERR_R_MALLOC_FAILURE);

+			goto err;

+			}

+		}

+	BN_CTX_start(ctx);

+	b = BN_CTX_get(ctx);

+	if (b == NULL) goto err;

+

+	if (!BN_GF2m_mod_arr(b, &group->b, group->poly)) goto err;

+	

+	/* check the discriminant:

+	 * y^2 + x*y = x^3 + a*x^2 + b is an elliptic curve <=> b != 0 (mod p) 

+	 */

+	if (BN_is_zero(b)) goto err;

+

+	ret = 1;

+

+err:

+	if (ctx != NULL)

+		BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+/* Initializes an EC_POINT. */

+int ec_GF2m_simple_point_init(EC_POINT *point)

+	{

+	BN_init(&point->X);

+	BN_init(&point->Y);

+	BN_init(&point->Z);

+	return 1;

+	}

+

+

+/* Frees an EC_POINT. */

+void ec_GF2m_simple_point_finish(EC_POINT *point)

+	{

+	BN_free(&point->X);

+	BN_free(&point->Y);

+	BN_free(&point->Z);

+	}

+

+

+/* Clears and frees an EC_POINT. */

+void ec_GF2m_simple_point_clear_finish(EC_POINT *point)

+	{

+	BN_clear_free(&point->X);

+	BN_clear_free(&point->Y);

+	BN_clear_free(&point->Z);

+	point->Z_is_one = 0;

+	}

+

+

+/* Copy the contents of one EC_POINT into another.  Assumes dest is initialized. */

+int ec_GF2m_simple_point_copy(EC_POINT *dest, const EC_POINT *src)

+	{

+	if (!BN_copy(&dest->X, &src->X)) return 0;

+	if (!BN_copy(&dest->Y, &src->Y)) return 0;

+	if (!BN_copy(&dest->Z, &src->Z)) return 0;

+	dest->Z_is_one = src->Z_is_one;

+

+	return 1;

+	}

+

+

+/* Set an EC_POINT to the point at infinity.  

+ * A point at infinity is represented by having Z=0.

+ */

+int ec_GF2m_simple_point_set_to_infinity(const EC_GROUP *group, EC_POINT *point)

+	{

+	point->Z_is_one = 0;

+	BN_zero(&point->Z);

+	return 1;

+	}

+

+

+/* Set the coordinates of an EC_POINT using affine coordinates. 

+ * Note that the simple implementation only uses affine coordinates.

+ */

+int ec_GF2m_simple_point_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,

+	const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)

+	{

+	int ret = 0;	

+	if (x == NULL || y == NULL)

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES, ERR_R_PASSED_NULL_PARAMETER);

+		return 0;

+		}

+

+	if (!BN_copy(&point->X, x)) goto err;

+	BN_set_negative(&point->X, 0);

+	if (!BN_copy(&point->Y, y)) goto err;

+	BN_set_negative(&point->Y, 0);

+	if (!BN_copy(&point->Z, BN_value_one())) goto err;

+	BN_set_negative(&point->Z, 0);

+	point->Z_is_one = 1;

+	ret = 1;

+

+  err:

+	return ret;

+	}

+

+

+/* Gets the affine coordinates of an EC_POINT. 

+ * Note that the simple implementation only uses affine coordinates.

+ */

+int ec_GF2m_simple_point_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,

+	BIGNUM *x, BIGNUM *y, BN_CTX *ctx)

+	{

+	int ret = 0;

+

+	if (EC_POINT_is_at_infinity(group, point))

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES, EC_R_POINT_AT_INFINITY);

+		return 0;

+		}

+

+	if (BN_cmp(&point->Z, BN_value_one())) 

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

+		return 0;

+		}

+	if (x != NULL)

+		{

+		if (!BN_copy(x, &point->X)) goto err;

+		BN_set_negative(x, 0);

+		}

+	if (y != NULL)

+		{

+		if (!BN_copy(y, &point->Y)) goto err;

+		BN_set_negative(y, 0);

+		}

+	ret = 1;

+		

+ err:

+	return ret;

+	}

+

+

+/* Calculates and sets the affine coordinates of an EC_POINT from the given

+ * compressed coordinates.  Uses algorithm 2.3.4 of SEC 1. 

+ * Note that the simple implementation only uses affine coordinates.

+ *

+ * The method is from the following publication:

+ * 

+ *     Harper, Menezes, Vanstone:

+ *     "Public-Key Cryptosystems with Very Small Key Lengths",

+ *     EUROCRYPT '92, Springer-Verlag LNCS 658,

+ *     published February 1993

+ *

+ * US Patents 6,141,420 and 6,618,483 (Vanstone, Mullin, Agnew) describe

+ * the same method, but claim no priority date earlier than July 29, 1994

+ * (and additionally fail to cite the EUROCRYPT '92 publication as prior art).

+ */

+int ec_GF2m_simple_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *point,

+	const BIGNUM *x_, int y_bit, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *tmp, *x, *y, *z;

+	int ret = 0, z0;

+

+	/* clear error queue */

+	ERR_clear_error();

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	y_bit = (y_bit != 0) ? 1 : 0;

+

+	BN_CTX_start(ctx);

+	tmp = BN_CTX_get(ctx);

+	x = BN_CTX_get(ctx);

+	y = BN_CTX_get(ctx);

+	z = BN_CTX_get(ctx);

+	if (z == NULL) goto err;

+

+	if (!BN_GF2m_mod_arr(x, x_, group->poly)) goto err;

+	if (BN_is_zero(x))

+		{

+		if (!BN_GF2m_mod_sqrt_arr(y, &group->b, group->poly, ctx)) goto err;

+		}

+	else

+		{

+		if (!group->meth->field_sqr(group, tmp, x, ctx)) goto err;

+		if (!group->meth->field_div(group, tmp, &group->b, tmp, ctx)) goto err;

+		if (!BN_GF2m_add(tmp, &group->a, tmp)) goto err;

+		if (!BN_GF2m_add(tmp, x, tmp)) goto err;

+		if (!BN_GF2m_mod_solve_quad_arr(z, tmp, group->poly, ctx))

+			{

+			unsigned long err = ERR_peek_last_error();

+			

+			if (ERR_GET_LIB(err) == ERR_LIB_BN && ERR_GET_REASON(err) == BN_R_NO_SOLUTION)

+				{

+				ERR_clear_error();

+				ECerr(EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSED_POINT);

+				}

+			else

+				ECerr(EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES, ERR_R_BN_LIB);

+			goto err;

+			}

+		z0 = (BN_is_odd(z)) ? 1 : 0;

+		if (!group->meth->field_mul(group, y, x, z, ctx)) goto err;

+		if (z0 != y_bit)

+			{

+			if (!BN_GF2m_add(y, y, x)) goto err;

+			}

+		}

+

+	if (!EC_POINT_set_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;

+

+	ret = 1;

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+/* Converts an EC_POINT to an octet string.  

+ * If buf is NULL, the encoded length will be returned.

+ * If the length len of buf is smaller than required an error will be returned.

+ */

+size_t ec_GF2m_simple_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,

+	unsigned char *buf, size_t len, BN_CTX *ctx)

+	{

+	size_t ret;

+	BN_CTX *new_ctx = NULL;

+	int used_ctx = 0;

+	BIGNUM *x, *y, *yxi;

+	size_t field_len, i, skip;

+

+	if ((form != POINT_CONVERSION_COMPRESSED)

+		&& (form != POINT_CONVERSION_UNCOMPRESSED)

+		&& (form != POINT_CONVERSION_HYBRID))

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, EC_R_INVALID_FORM);

+		goto err;

+		}

+

+	if (EC_POINT_is_at_infinity(group, point))

+		{

+		/* encodes to a single 0 octet */

+		if (buf != NULL)

+			{

+			if (len < 1)

+				{

+				ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);

+				return 0;

+				}

+			buf[0] = 0;

+			}

+		return 1;

+		}

+

+

+	/* ret := required output buffer length */

+	field_len = (EC_GROUP_get_degree(group) + 7) / 8;

+	ret = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;

+

+	/* if 'buf' is NULL, just return required length */

+	if (buf != NULL)

+		{

+		if (len < ret)

+			{

+			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);

+			goto err;

+			}

+

+		if (ctx == NULL)

+			{

+			ctx = new_ctx = BN_CTX_new();

+			if (ctx == NULL)

+				return 0;

+			}

+

+		BN_CTX_start(ctx);

+		used_ctx = 1;

+		x = BN_CTX_get(ctx);

+		y = BN_CTX_get(ctx);

+		yxi = BN_CTX_get(ctx);

+		if (yxi == NULL) goto err;

+

+		if (!EC_POINT_get_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;

+

+		buf[0] = form;

+		if ((form != POINT_CONVERSION_UNCOMPRESSED) && !BN_is_zero(x))

+			{

+			if (!group->meth->field_div(group, yxi, y, x, ctx)) goto err;

+			if (BN_is_odd(yxi)) buf[0]++;

+			}

+

+		i = 1;

+		

+		skip = field_len - BN_num_bytes(x);

+		if (skip > field_len)

+			{

+			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+			goto err;

+			}

+		while (skip > 0)

+			{

+			buf[i++] = 0;

+			skip--;

+			}

+		skip = BN_bn2bin(x, buf + i);

+		i += skip;

+		if (i != 1 + field_len)

+			{

+			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+			goto err;

+			}

+

+		if (form == POINT_CONVERSION_UNCOMPRESSED || form == POINT_CONVERSION_HYBRID)

+			{

+			skip = field_len - BN_num_bytes(y);

+			if (skip > field_len)

+				{

+				ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+				goto err;

+				}

+			while (skip > 0)

+				{

+				buf[i++] = 0;

+				skip--;

+				}

+			skip = BN_bn2bin(y, buf + i);

+			i += skip;

+			}

+

+		if (i != ret)

+			{

+			ECerr(EC_F_EC_GF2M_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+			goto err;

+			}

+		}

+	

+	if (used_ctx)

+		BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+

+ err:

+	if (used_ctx)

+		BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return 0;

+	}

+

+

+/* Converts an octet string representation to an EC_POINT. 

+ * Note that the simple implementation only uses affine coordinates.

+ */

+int ec_GF2m_simple_oct2point(const EC_GROUP *group, EC_POINT *point,

+	const unsigned char *buf, size_t len, BN_CTX *ctx)

+	{

+	point_conversion_form_t form;

+	int y_bit;

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *x, *y, *yxi;

+	size_t field_len, enc_len;

+	int ret = 0;

+

+	if (len == 0)

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_BUFFER_TOO_SMALL);

+		return 0;

+		}

+	form = buf[0];

+	y_bit = form & 1;

+	form = form & ~1U;

+	if ((form != 0)	&& (form != POINT_CONVERSION_COMPRESSED)

+		&& (form != POINT_CONVERSION_UNCOMPRESSED)

+		&& (form != POINT_CONVERSION_HYBRID))

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		return 0;

+		}

+	if ((form == 0 || form == POINT_CONVERSION_UNCOMPRESSED) && y_bit)

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		return 0;

+		}

+

+	if (form == 0)

+		{

+		if (len != 1)

+			{

+			ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+			return 0;

+			}

+

+		return EC_POINT_set_to_infinity(group, point);

+		}

+	

+	field_len = (EC_GROUP_get_degree(group) + 7) / 8;

+	enc_len = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;

+

+	if (len != enc_len)

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		return 0;

+		}

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	x = BN_CTX_get(ctx);

+	y = BN_CTX_get(ctx);

+	yxi = BN_CTX_get(ctx);

+	if (yxi == NULL) goto err;

+

+	if (!BN_bin2bn(buf + 1, field_len, x)) goto err;

+	if (BN_ucmp(x, &group->field) >= 0)

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		goto err;

+		}

+

+	if (form == POINT_CONVERSION_COMPRESSED)

+		{

+		if (!EC_POINT_set_compressed_coordinates_GF2m(group, point, x, y_bit, ctx)) goto err;

+		}

+	else

+		{

+		if (!BN_bin2bn(buf + 1 + field_len, field_len, y)) goto err;

+		if (BN_ucmp(y, &group->field) >= 0)

+			{

+			ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+			goto err;

+			}

+		if (form == POINT_CONVERSION_HYBRID)

+			{

+			if (!group->meth->field_div(group, yxi, y, x, ctx)) goto err;

+			if (y_bit != BN_is_odd(yxi))

+				{

+				ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+				goto err;

+				}

+			}

+

+		if (!EC_POINT_set_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;

+		}

+	

+	if (!EC_POINT_is_on_curve(group, point, ctx)) /* test required by X9.62 */

+		{

+		ECerr(EC_F_EC_GF2M_SIMPLE_OCT2POINT, EC_R_POINT_IS_NOT_ON_CURVE);

+		goto err;

+		}

+

+	ret = 1;

+	

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+/* Computes a + b and stores the result in r.  r could be a or b, a could be b.

+ * Uses algorithm A.10.2 of IEEE P1363.

+ */

+int ec_GF2m_simple_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *x0, *y0, *x1, *y1, *x2, *y2, *s, *t;

+	int ret = 0;

+	

+	if (EC_POINT_is_at_infinity(group, a))

+		{

+		if (!EC_POINT_copy(r, b)) return 0;

+		return 1;

+		}

+

+	if (EC_POINT_is_at_infinity(group, b))

+		{

+		if (!EC_POINT_copy(r, a)) return 0;

+		return 1;

+		}

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	x0 = BN_CTX_get(ctx);

+	y0 = BN_CTX_get(ctx);

+	x1 = BN_CTX_get(ctx);

+	y1 = BN_CTX_get(ctx);

+	x2 = BN_CTX_get(ctx);

+	y2 = BN_CTX_get(ctx);

+	s = BN_CTX_get(ctx);

+	t = BN_CTX_get(ctx);

+	if (t == NULL) goto err;

+

+	if (a->Z_is_one) 

+		{

+		if (!BN_copy(x0, &a->X)) goto err;

+		if (!BN_copy(y0, &a->Y)) goto err;

+		}

+	else

+		{

+		if (!EC_POINT_get_affine_coordinates_GF2m(group, a, x0, y0, ctx)) goto err;

+		}

+	if (b->Z_is_one) 

+		{

+		if (!BN_copy(x1, &b->X)) goto err;

+		if (!BN_copy(y1, &b->Y)) goto err;

+		}

+	else

+		{

+		if (!EC_POINT_get_affine_coordinates_GF2m(group, b, x1, y1, ctx)) goto err;

+		}

+

+

+	if (BN_GF2m_cmp(x0, x1))

+		{

+		if (!BN_GF2m_add(t, x0, x1)) goto err;

+		if (!BN_GF2m_add(s, y0, y1)) goto err;

+		if (!group->meth->field_div(group, s, s, t, ctx)) goto err;

+		if (!group->meth->field_sqr(group, x2, s, ctx)) goto err;

+		if (!BN_GF2m_add(x2, x2, &group->a)) goto err;

+		if (!BN_GF2m_add(x2, x2, s)) goto err;

+		if (!BN_GF2m_add(x2, x2, t)) goto err;

+		}

+	else

+		{

+		if (BN_GF2m_cmp(y0, y1) || BN_is_zero(x1))

+			{

+			if (!EC_POINT_set_to_infinity(group, r)) goto err;

+			ret = 1;

+			goto err;

+			}

+		if (!group->meth->field_div(group, s, y1, x1, ctx)) goto err;

+		if (!BN_GF2m_add(s, s, x1)) goto err;

+		

+		if (!group->meth->field_sqr(group, x2, s, ctx)) goto err;

+		if (!BN_GF2m_add(x2, x2, s)) goto err;

+		if (!BN_GF2m_add(x2, x2, &group->a)) goto err;

+		}

+

+	if (!BN_GF2m_add(y2, x1, x2)) goto err;

+	if (!group->meth->field_mul(group, y2, y2, s, ctx)) goto err;

+	if (!BN_GF2m_add(y2, y2, x2)) goto err;

+	if (!BN_GF2m_add(y2, y2, y1)) goto err;

+

+	if (!EC_POINT_set_affine_coordinates_GF2m(group, r, x2, y2, ctx)) goto err;

+

+	ret = 1;

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+/* Computes 2 * a and stores the result in r.  r could be a.

+ * Uses algorithm A.10.2 of IEEE P1363.

+ */

+int ec_GF2m_simple_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)

+	{

+	return ec_GF2m_simple_add(group, r, a, a, ctx);

+	}

+

+

+int ec_GF2m_simple_invert(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)

+	{

+	if (EC_POINT_is_at_infinity(group, point) || BN_is_zero(&point->Y))

+		/* point is its own inverse */

+		return 1;

+	

+	if (!EC_POINT_make_affine(group, point, ctx)) return 0;

+	return BN_GF2m_add(&point->Y, &point->X, &point->Y);

+	}

+

+

+/* Indicates whether the given point is the point at infinity. */

+int ec_GF2m_simple_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)

+	{

+	return BN_is_zero(&point->Z);

+	}

+

+

+/* Determines whether the given EC_POINT is an actual point on the curve defined

+ * in the EC_GROUP.  A point is valid if it satisfies the Weierstrass equation:

+ *      y^2 + x*y = x^3 + a*x^2 + b.

+ */

+int ec_GF2m_simple_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)

+	{

+	int ret = -1;

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *lh, *y2;

+	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);

+	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);

+

+	if (EC_POINT_is_at_infinity(group, point))

+		return 1;

+

+	field_mul = group->meth->field_mul;

+	field_sqr = group->meth->field_sqr;	

+

+	/* only support affine coordinates */

+	if (!point->Z_is_one) goto err;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return -1;

+		}

+

+	BN_CTX_start(ctx);

+	y2 = BN_CTX_get(ctx);

+	lh = BN_CTX_get(ctx);

+	if (lh == NULL) goto err;

+

+	/* We have a curve defined by a Weierstrass equation

+	 *      y^2 + x*y = x^3 + a*x^2 + b.

+	 *  <=> x^3 + a*x^2 + x*y + b + y^2 = 0

+	 *  <=> ((x + a) * x + y ) * x + b + y^2 = 0

+	 */

+	if (!BN_GF2m_add(lh, &point->X, &group->a)) goto err;

+	if (!field_mul(group, lh, lh, &point->X, ctx)) goto err;

+	if (!BN_GF2m_add(lh, lh, &point->Y)) goto err;

+	if (!field_mul(group, lh, lh, &point->X, ctx)) goto err;

+	if (!BN_GF2m_add(lh, lh, &group->b)) goto err;

+	if (!field_sqr(group, y2, &point->Y, ctx)) goto err;

+	if (!BN_GF2m_add(lh, lh, y2)) goto err;

+	ret = BN_is_zero(lh);

+ err:

+	if (ctx) BN_CTX_end(ctx);

+	if (new_ctx) BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+/* Indicates whether two points are equal.

+ * Return values:

+ *  -1   error

+ *   0   equal (in affine coordinates)

+ *   1   not equal

+ */

+int ec_GF2m_simple_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)

+	{

+	BIGNUM *aX, *aY, *bX, *bY;

+	BN_CTX *new_ctx = NULL;

+	int ret = -1;

+

+	if (EC_POINT_is_at_infinity(group, a))

+		{

+		return EC_POINT_is_at_infinity(group, b) ? 0 : 1;

+		}

+

+	if (EC_POINT_is_at_infinity(group, b))

+		return 1;

+	

+	if (a->Z_is_one && b->Z_is_one)

+		{

+		return ((BN_cmp(&a->X, &b->X) == 0) && BN_cmp(&a->Y, &b->Y) == 0) ? 0 : 1;

+		}

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return -1;

+		}

+

+	BN_CTX_start(ctx);

+	aX = BN_CTX_get(ctx);

+	aY = BN_CTX_get(ctx);

+	bX = BN_CTX_get(ctx);

+	bY = BN_CTX_get(ctx);

+	if (bY == NULL) goto err;

+

+	if (!EC_POINT_get_affine_coordinates_GF2m(group, a, aX, aY, ctx)) goto err;

+	if (!EC_POINT_get_affine_coordinates_GF2m(group, b, bX, bY, ctx)) goto err;

+	ret = ((BN_cmp(aX, bX) == 0) && BN_cmp(aY, bY) == 0) ? 0 : 1;

+

+  err:	

+	if (ctx) BN_CTX_end(ctx);

+	if (new_ctx) BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+/* Forces the given EC_POINT to internally use affine coordinates. */

+int ec_GF2m_simple_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *x, *y;

+	int ret = 0;

+

+	if (point->Z_is_one || EC_POINT_is_at_infinity(group, point))

+		return 1;

+	

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	x = BN_CTX_get(ctx);

+	y = BN_CTX_get(ctx);

+	if (y == NULL) goto err;

+	

+	if (!EC_POINT_get_affine_coordinates_GF2m(group, point, x, y, ctx)) goto err;

+	if (!BN_copy(&point->X, x)) goto err;

+	if (!BN_copy(&point->Y, y)) goto err;

+	if (!BN_one(&point->Z)) goto err;

+	

+	ret = 1;		

+

+  err:

+	if (ctx) BN_CTX_end(ctx);

+	if (new_ctx) BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+/* Forces each of the EC_POINTs in the given array to use affine coordinates. */

+int ec_GF2m_simple_points_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)

+	{

+	size_t i;

+

+	for (i = 0; i < num; i++)

+		{

+		if (!group->meth->make_affine(group, points[i], ctx)) return 0;

+		}

+

+	return 1;

+	}

+

+

+/* Wrapper to simple binary polynomial field multiplication implementation. */

+int ec_GF2m_simple_field_mul(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)

+	{

+	return BN_GF2m_mod_mul_arr(r, a, b, group->poly, ctx);

+	}

+

+

+/* Wrapper to simple binary polynomial field squaring implementation. */

+int ec_GF2m_simple_field_sqr(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)

+	{

+	return BN_GF2m_mod_sqr_arr(r, a, group->poly, ctx);

+	}

+

+

+/* Wrapper to simple binary polynomial field division implementation. */

+int ec_GF2m_simple_field_div(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)

+	{

+	return BN_GF2m_mod_div(r, a, b, &group->field, ctx);

+	}

diff --git a/openssl/crypto/ec/ec_key.c b/openssl/crypto/ec/ec_key.c
index 12fb0e6d6..0458d340b 100644
--- a/openssl/crypto/ec/ec_key.c
+++ b/openssl/crypto/ec/ec_key.c
@@ -1,457 +1,463 @@
-/* crypto/ec/ec_key.c */
-/*
- * Written by Nils Larsch for the OpenSSL project.
- */
-/* ====================================================================
- * Copyright (c) 1998-2005 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).
- *
- */
-/* ====================================================================
- * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
- * Portions originally developed by SUN MICROSYSTEMS, INC., and 
- * contributed to the OpenSSL project.
- */
-
-#include <string.h>
-#include "ec_lcl.h"
-#include <openssl/err.h>
-#include <string.h>
-
-EC_KEY *EC_KEY_new(void)
-	{
-	EC_KEY *ret;
-
-	ret=(EC_KEY *)OPENSSL_malloc(sizeof(EC_KEY));
-	if (ret == NULL)
-		{
-		ECerr(EC_F_EC_KEY_NEW, ERR_R_MALLOC_FAILURE);
-		return(NULL);
-		}
-
-	ret->version = 1;	
-	ret->group   = NULL;
-	ret->pub_key = NULL;
-	ret->priv_key= NULL;
-	ret->enc_flag= 0; 
-	ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;
-	ret->references= 1;
-	ret->method_data = NULL;
-	return(ret);
-	}
-
-EC_KEY *EC_KEY_new_by_curve_name(int nid)
-	{
-	EC_KEY *ret = EC_KEY_new();
-	if (ret == NULL)
-		return NULL;
-	ret->group = EC_GROUP_new_by_curve_name(nid);
-	if (ret->group == NULL)
-		{
-		EC_KEY_free(ret);
-		return NULL;
-		}
-	return ret;
-	}
-
-void EC_KEY_free(EC_KEY *r)
-	{
-	int i;
-
-	if (r == NULL) return;
-
-	i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_EC);
-#ifdef REF_PRINT
-	REF_PRINT("EC_KEY",r);
-#endif
-	if (i > 0) return;
-#ifdef REF_CHECK
-	if (i < 0)
-		{
-		fprintf(stderr,"EC_KEY_free, bad reference count\n");
-		abort();
-		}
-#endif
-
-	if (r->group    != NULL) 
-		EC_GROUP_free(r->group);
-	if (r->pub_key  != NULL)
-		EC_POINT_free(r->pub_key);
-	if (r->priv_key != NULL)
-		BN_clear_free(r->priv_key);
-
-	EC_EX_DATA_free_all_data(&r->method_data);
-
-	OPENSSL_cleanse((void *)r, sizeof(EC_KEY));
-
-	OPENSSL_free(r);
-	}
-
-EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
-	{
-	EC_EXTRA_DATA *d;
-
-	if (dest == NULL || src == NULL)
-		{
-		ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);
-		return NULL;
-		}
-	/* copy the parameters */
-	if (src->group)
-		{
-		const EC_METHOD *meth = EC_GROUP_method_of(src->group);
-		/* clear the old group */
-		if (dest->group)
-			EC_GROUP_free(dest->group);
-		dest->group = EC_GROUP_new(meth);
-		if (dest->group == NULL)
-			return NULL;
-		if (!EC_GROUP_copy(dest->group, src->group))
-			return NULL;
-		}
-	/*  copy the public key */
-	if (src->pub_key && src->group)
-		{
-		if (dest->pub_key)
-			EC_POINT_free(dest->pub_key);
-		dest->pub_key = EC_POINT_new(src->group);
-		if (dest->pub_key == NULL)
-			return NULL;
-		if (!EC_POINT_copy(dest->pub_key, src->pub_key))
-			return NULL;
-		}
-	/* copy the private key */
-	if (src->priv_key)
-		{
-		if (dest->priv_key == NULL)
-			{
-			dest->priv_key = BN_new();
-			if (dest->priv_key == NULL)
-				return NULL;
-			}
-		if (!BN_copy(dest->priv_key, src->priv_key))
-			return NULL;
-		}
-	/* copy method/extra data */
-	EC_EX_DATA_free_all_data(&dest->method_data);
-
-	for (d = src->method_data; d != NULL; d = d->next)
-		{
-		void *t = d->dup_func(d->data);
-		
-		if (t == NULL)
-			return 0;
-		if (!EC_EX_DATA_set_data(&dest->method_data, t, d->dup_func, d->free_func, d->clear_free_func))
-			return 0;
-		}
-
-	/* copy the rest */
-	dest->enc_flag  = src->enc_flag;
-	dest->conv_form = src->conv_form;
-	dest->version   = src->version;
-
-	return dest;
-	}
-
-EC_KEY *EC_KEY_dup(const EC_KEY *ec_key)
-	{
-	EC_KEY *ret = EC_KEY_new();
-	if (ret == NULL)
-		return NULL;
-	if (EC_KEY_copy(ret, ec_key) == NULL)
-		{
-		EC_KEY_free(ret);
-		return NULL;
-		}
-	return ret;
-	}
-
-int EC_KEY_up_ref(EC_KEY *r)
-	{
-	int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC);
-#ifdef REF_PRINT
-	REF_PRINT("EC_KEY",r);
-#endif
-#ifdef REF_CHECK
-	if (i < 2)
-		{
-		fprintf(stderr, "EC_KEY_up, bad reference count\n");
-		abort();
-		}
-#endif
-	return ((i > 1) ? 1 : 0);
-	}
-
-int EC_KEY_generate_key(EC_KEY *eckey)
-	{	
-	int	ok = 0;
-	BN_CTX	*ctx = NULL;
-	BIGNUM	*priv_key = NULL, *order = NULL;
-	EC_POINT *pub_key = NULL;
-
-	if (!eckey || !eckey->group)
-		{
-		ECerr(EC_F_EC_KEY_GENERATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
-		return 0;
-		}
-
-	if ((order = BN_new()) == NULL) goto err;
-	if ((ctx = BN_CTX_new()) == NULL) goto err;
-
-	if (eckey->priv_key == NULL)
-		{
-		priv_key = BN_new();
-		if (priv_key == NULL)
-			goto err;
-		}
-	else
-		priv_key = eckey->priv_key;
-
-	if (!EC_GROUP_get_order(eckey->group, order, ctx))
-		goto err;
-
-	do
-		if (!BN_rand_range(priv_key, order))
-			goto err;
-	while (BN_is_zero(priv_key));
-
-	if (eckey->pub_key == NULL)
-		{
-		pub_key = EC_POINT_new(eckey->group);
-		if (pub_key == NULL)
-			goto err;
-		}
-	else
-		pub_key = eckey->pub_key;
-
-	if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, ctx))
-		goto err;
-
-	eckey->priv_key = priv_key;
-	eckey->pub_key  = pub_key;
-
-	ok=1;
-
-err:	
-	if (order)
-		BN_free(order);
-	if (pub_key  != NULL && eckey->pub_key  == NULL)
-		EC_POINT_free(pub_key);
-	if (priv_key != NULL && eckey->priv_key == NULL)
-		BN_free(priv_key);
-	if (ctx != NULL)
-		BN_CTX_free(ctx);
-	return(ok);
-	}
-
-int EC_KEY_check_key(const EC_KEY *eckey)
-	{
-	int	ok   = 0;
-	BN_CTX	*ctx = NULL;
-	const BIGNUM	*order  = NULL;
-	EC_POINT *point = NULL;
-
-	if (!eckey || !eckey->group || !eckey->pub_key)
-		{
-		ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);
-		return 0;
-		}
-	
-	if ((ctx = BN_CTX_new()) == NULL)
-		goto err;
-	if ((point = EC_POINT_new(eckey->group)) == NULL)
-		goto err;
-
-	/* testing whether the pub_key is on the elliptic curve */
-	if (!EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx))
-		{
-		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE);
-		goto err;
-		}
-	/* testing whether pub_key * order is the point at infinity */
-	order = &eckey->group->order;
-	if (BN_is_zero(order))
-		{
-		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER);
-		goto err;
-		}
-	if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx))
-		{
-		ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
-		goto err;
-		}
-	if (!EC_POINT_is_at_infinity(eckey->group, point))
-		{
-		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
-		goto err;
-		}
-	/* in case the priv_key is present : 
-	 * check if generator * priv_key == pub_key 
-	 */
-	if (eckey->priv_key)
-		{
-		if (BN_cmp(eckey->priv_key, order) >= 0)
-			{
-			ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
-			goto err;
-			}
-		if (!EC_POINT_mul(eckey->group, point, eckey->priv_key,
-			NULL, NULL, ctx))
-			{
-			ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
-			goto err;
-			}
-		if (EC_POINT_cmp(eckey->group, point, eckey->pub_key, 
-			ctx) != 0)
-			{
-			ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_PRIVATE_KEY);
-			goto err;
-			}
-		}
-	ok = 1;
-err:
-	if (ctx   != NULL)
-		BN_CTX_free(ctx);
-	if (point != NULL)
-		EC_POINT_free(point);
-	return(ok);
-	}
-
-const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key)
-	{
-	return key->group;
-	}
-
-int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
-	{
-	if (key->group != NULL)
-		EC_GROUP_free(key->group);
-	key->group = EC_GROUP_dup(group);
-	return (key->group == NULL) ? 0 : 1;
-	}
-
-const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key)
-	{
-	return key->priv_key;
-	}
-
-int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
-	{
-	if (key->priv_key)
-		BN_clear_free(key->priv_key);
-	key->priv_key = BN_dup(priv_key);
-	return (key->priv_key == NULL) ? 0 : 1;
-	}
-
-const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key)
-	{
-	return key->pub_key;
-	}
-
-int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
-	{
-	if (key->pub_key != NULL)
-		EC_POINT_free(key->pub_key);
-	key->pub_key = EC_POINT_dup(pub_key, key->group);
-	return (key->pub_key == NULL) ? 0 : 1;
-	}
-
-unsigned int EC_KEY_get_enc_flags(const EC_KEY *key)
-	{
-	return key->enc_flag;
-	}
-
-void EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
-	{
-	key->enc_flag = flags;
-	}
-
-point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key)
-	{
-	return key->conv_form;
-	}
-
-void EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
-	{
-	key->conv_form = cform;
-	if (key->group != NULL)
-		EC_GROUP_set_point_conversion_form(key->group, cform);
-	}
-
-void *EC_KEY_get_key_method_data(EC_KEY *key,
-	void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))
-	{
-	return EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);
-	}
-
-void EC_KEY_insert_key_method_data(EC_KEY *key, void *data,
-	void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))
-	{
-	EC_EXTRA_DATA *ex_data;
-	CRYPTO_w_lock(CRYPTO_LOCK_EC);
-	ex_data = EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);
-	if (ex_data == NULL)
-		EC_EX_DATA_set_data(&key->method_data, data, dup_func, free_func, clear_free_func);
-	CRYPTO_w_unlock(CRYPTO_LOCK_EC);
-	}
-
-void EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
-	{
-	if (key->group != NULL)
-		EC_GROUP_set_asn1_flag(key->group, flag);
-	}
-
-int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
-	{
-	if (key->group == NULL)
-		return 0;
-	return EC_GROUP_precompute_mult(key->group, ctx);
-	}
+/* crypto/ec/ec_key.c */

+/*

+ * Written by Nils Larsch for the OpenSSL project.

+ */

+/* ====================================================================

+ * Copyright (c) 1998-2005 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).

+ *

+ */

+/* ====================================================================

+ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

+ * Portions originally developed by SUN MICROSYSTEMS, INC., and 

+ * contributed to the OpenSSL project.

+ */

+

+#include <string.h>

+#include "ec_lcl.h"

+#include <openssl/err.h>

+#include <string.h>

+

+EC_KEY *EC_KEY_new(void)

+	{

+	EC_KEY *ret;

+

+	ret=(EC_KEY *)OPENSSL_malloc(sizeof(EC_KEY));

+	if (ret == NULL)

+		{

+		ECerr(EC_F_EC_KEY_NEW, ERR_R_MALLOC_FAILURE);

+		return(NULL);

+		}

+

+	ret->version = 1;	

+	ret->group   = NULL;

+	ret->pub_key = NULL;

+	ret->priv_key= NULL;

+	ret->enc_flag= 0; 

+	ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;

+	ret->references= 1;

+	ret->method_data = NULL;

+	return(ret);

+	}

+

+EC_KEY *EC_KEY_new_by_curve_name(int nid)

+	{

+	EC_KEY *ret = EC_KEY_new();

+	if (ret == NULL)

+		return NULL;

+	ret->group = EC_GROUP_new_by_curve_name(nid);

+	if (ret->group == NULL)

+		{

+		EC_KEY_free(ret);

+		return NULL;

+		}

+	return ret;

+	}

+

+void EC_KEY_free(EC_KEY *r)

+	{

+	int i;

+

+	if (r == NULL) return;

+

+	i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_EC);

+#ifdef REF_PRINT

+	REF_PRINT("EC_KEY",r);

+#endif

+	if (i > 0) return;

+#ifdef REF_CHECK

+	if (i < 0)

+		{

+		fprintf(stderr,"EC_KEY_free, bad reference count\n");

+		abort();

+		}

+#endif

+

+	if (r->group    != NULL) 

+		EC_GROUP_free(r->group);

+	if (r->pub_key  != NULL)

+		EC_POINT_free(r->pub_key);

+	if (r->priv_key != NULL)

+		BN_clear_free(r->priv_key);

+

+	EC_EX_DATA_free_all_data(&r->method_data);

+

+	OPENSSL_cleanse((void *)r, sizeof(EC_KEY));

+

+	OPENSSL_free(r);

+	}

+

+EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)

+	{

+	EC_EXTRA_DATA *d;

+

+	if (dest == NULL || src == NULL)

+		{

+		ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);

+		return NULL;

+		}

+	/* copy the parameters */

+	if (src->group)

+		{

+		const EC_METHOD *meth = EC_GROUP_method_of(src->group);

+		/* clear the old group */

+		if (dest->group)

+			EC_GROUP_free(dest->group);

+		dest->group = EC_GROUP_new(meth);

+		if (dest->group == NULL)

+			return NULL;

+		if (!EC_GROUP_copy(dest->group, src->group))

+			return NULL;

+		}

+	/*  copy the public key */

+	if (src->pub_key && src->group)

+		{

+		if (dest->pub_key)

+			EC_POINT_free(dest->pub_key);

+		dest->pub_key = EC_POINT_new(src->group);

+		if (dest->pub_key == NULL)

+			return NULL;

+		if (!EC_POINT_copy(dest->pub_key, src->pub_key))

+			return NULL;

+		}

+	/* copy the private key */

+	if (src->priv_key)

+		{

+		if (dest->priv_key == NULL)

+			{

+			dest->priv_key = BN_new();

+			if (dest->priv_key == NULL)

+				return NULL;

+			}

+		if (!BN_copy(dest->priv_key, src->priv_key))

+			return NULL;

+		}

+	/* copy method/extra data */

+	EC_EX_DATA_free_all_data(&dest->method_data);

+

+	for (d = src->method_data; d != NULL; d = d->next)

+		{

+		void *t = d->dup_func(d->data);

+		

+		if (t == NULL)

+			return 0;

+		if (!EC_EX_DATA_set_data(&dest->method_data, t, d->dup_func, d->free_func, d->clear_free_func))

+			return 0;

+		}

+

+	/* copy the rest */

+	dest->enc_flag  = src->enc_flag;

+	dest->conv_form = src->conv_form;

+	dest->version   = src->version;

+

+	return dest;

+	}

+

+EC_KEY *EC_KEY_dup(const EC_KEY *ec_key)

+	{

+	EC_KEY *ret = EC_KEY_new();

+	if (ret == NULL)

+		return NULL;

+	if (EC_KEY_copy(ret, ec_key) == NULL)

+		{

+		EC_KEY_free(ret);

+		return NULL;

+		}

+	return ret;

+	}

+

+int EC_KEY_up_ref(EC_KEY *r)

+	{

+	int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC);

+#ifdef REF_PRINT

+	REF_PRINT("EC_KEY",r);

+#endif

+#ifdef REF_CHECK

+	if (i < 2)

+		{

+		fprintf(stderr, "EC_KEY_up, bad reference count\n");

+		abort();

+		}

+#endif

+	return ((i > 1) ? 1 : 0);

+	}

+

+int EC_KEY_generate_key(EC_KEY *eckey)

+	{	

+	int	ok = 0;

+	BN_CTX	*ctx = NULL;

+	BIGNUM	*priv_key = NULL, *order = NULL;

+	EC_POINT *pub_key = NULL;

+

+	if (!eckey || !eckey->group)

+		{

+		ECerr(EC_F_EC_KEY_GENERATE_KEY, ERR_R_PASSED_NULL_PARAMETER);

+		return 0;

+		}

+

+	if ((order = BN_new()) == NULL) goto err;

+	if ((ctx = BN_CTX_new()) == NULL) goto err;

+

+	if (eckey->priv_key == NULL)

+		{

+		priv_key = BN_new();

+		if (priv_key == NULL)

+			goto err;

+		}

+	else

+		priv_key = eckey->priv_key;

+

+	if (!EC_GROUP_get_order(eckey->group, order, ctx))

+		goto err;

+

+	do

+		if (!BN_rand_range(priv_key, order))

+			goto err;

+	while (BN_is_zero(priv_key));

+

+	if (eckey->pub_key == NULL)

+		{

+		pub_key = EC_POINT_new(eckey->group);

+		if (pub_key == NULL)

+			goto err;

+		}

+	else

+		pub_key = eckey->pub_key;

+

+	if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, ctx))

+		goto err;

+

+	eckey->priv_key = priv_key;

+	eckey->pub_key  = pub_key;

+

+	ok=1;

+

+err:	

+	if (order)

+		BN_free(order);

+	if (pub_key  != NULL && eckey->pub_key  == NULL)

+		EC_POINT_free(pub_key);

+	if (priv_key != NULL && eckey->priv_key == NULL)

+		BN_free(priv_key);

+	if (ctx != NULL)

+		BN_CTX_free(ctx);

+	return(ok);

+	}

+

+int EC_KEY_check_key(const EC_KEY *eckey)

+	{

+	int	ok   = 0;

+	BN_CTX	*ctx = NULL;

+	const BIGNUM	*order  = NULL;

+	EC_POINT *point = NULL;

+

+	if (!eckey || !eckey->group || !eckey->pub_key)

+		{

+		ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);

+		return 0;

+		}

+

+	if (EC_POINT_is_at_infinity(eckey->group, eckey->pub_key))

+		{

+		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_AT_INFINITY);

+		goto err;

+		}

+

+	if ((ctx = BN_CTX_new()) == NULL)

+		goto err;

+	if ((point = EC_POINT_new(eckey->group)) == NULL)

+		goto err;

+

+	/* testing whether the pub_key is on the elliptic curve */

+	if (!EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx))

+		{

+		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE);

+		goto err;

+		}

+	/* testing whether pub_key * order is the point at infinity */

+	order = &eckey->group->order;

+	if (BN_is_zero(order))

+		{

+		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER);

+		goto err;

+		}

+	if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx))

+		{

+		ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);

+		goto err;

+		}

+	if (!EC_POINT_is_at_infinity(eckey->group, point))

+		{

+		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);

+		goto err;

+		}

+	/* in case the priv_key is present : 

+	 * check if generator * priv_key == pub_key 

+	 */

+	if (eckey->priv_key)

+		{

+		if (BN_cmp(eckey->priv_key, order) >= 0)

+			{

+			ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);

+			goto err;

+			}

+		if (!EC_POINT_mul(eckey->group, point, eckey->priv_key,

+			NULL, NULL, ctx))

+			{

+			ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);

+			goto err;

+			}

+		if (EC_POINT_cmp(eckey->group, point, eckey->pub_key, 

+			ctx) != 0)

+			{

+			ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_PRIVATE_KEY);

+			goto err;

+			}

+		}

+	ok = 1;

+err:

+	if (ctx   != NULL)

+		BN_CTX_free(ctx);

+	if (point != NULL)

+		EC_POINT_free(point);

+	return(ok);

+	}

+

+const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key)

+	{

+	return key->group;

+	}

+

+int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)

+	{

+	if (key->group != NULL)

+		EC_GROUP_free(key->group);

+	key->group = EC_GROUP_dup(group);

+	return (key->group == NULL) ? 0 : 1;

+	}

+

+const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key)

+	{

+	return key->priv_key;

+	}

+

+int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)

+	{

+	if (key->priv_key)

+		BN_clear_free(key->priv_key);

+	key->priv_key = BN_dup(priv_key);

+	return (key->priv_key == NULL) ? 0 : 1;

+	}

+

+const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key)

+	{

+	return key->pub_key;

+	}

+

+int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)

+	{

+	if (key->pub_key != NULL)

+		EC_POINT_free(key->pub_key);

+	key->pub_key = EC_POINT_dup(pub_key, key->group);

+	return (key->pub_key == NULL) ? 0 : 1;

+	}

+

+unsigned int EC_KEY_get_enc_flags(const EC_KEY *key)

+	{

+	return key->enc_flag;

+	}

+

+void EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)

+	{

+	key->enc_flag = flags;

+	}

+

+point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key)

+	{

+	return key->conv_form;

+	}

+

+void EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)

+	{

+	key->conv_form = cform;

+	if (key->group != NULL)

+		EC_GROUP_set_point_conversion_form(key->group, cform);

+	}

+

+void *EC_KEY_get_key_method_data(EC_KEY *key,

+	void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))

+	{

+	return EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);

+	}

+

+void EC_KEY_insert_key_method_data(EC_KEY *key, void *data,

+	void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))

+	{

+	EC_EXTRA_DATA *ex_data;

+	CRYPTO_w_lock(CRYPTO_LOCK_EC);

+	ex_data = EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);

+	if (ex_data == NULL)

+		EC_EX_DATA_set_data(&key->method_data, data, dup_func, free_func, clear_free_func);

+	CRYPTO_w_unlock(CRYPTO_LOCK_EC);

+	}

+

+void EC_KEY_set_asn1_flag(EC_KEY *key, int flag)

+	{

+	if (key->group != NULL)

+		EC_GROUP_set_asn1_flag(key->group, flag);

+	}

+

+int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)

+	{

+	if (key->group == NULL)

+		return 0;

+	return EC_GROUP_precompute_mult(key->group, ctx);

+	}

diff --git a/openssl/crypto/ec/ecp_smpl.c b/openssl/crypto/ec/ecp_smpl.c
index 4d26f8bdf..766f5fc51 100644
--- a/openssl/crypto/ec/ecp_smpl.c
+++ b/openssl/crypto/ec/ecp_smpl.c
@@ -1,1716 +1,1719 @@
-/* crypto/ec/ecp_smpl.c */
-/* Includes code written by Lenka Fibikova <fibikova@exp-math.uni-essen.de>
- * for the OpenSSL project. 
- * Includes code written by Bodo Moeller for the OpenSSL project.
-*/
-/* ====================================================================
- * 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).
- *
- */
-/* ====================================================================
- * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
- * Portions of this software developed by SUN MICROSYSTEMS, INC.,
- * and contributed to the OpenSSL project.
- */
-
-#include <openssl/err.h>
-#include <openssl/symhacks.h>
-
-#include "ec_lcl.h"
-
-const EC_METHOD *EC_GFp_simple_method(void)
-	{
-	static const EC_METHOD ret = {
-		NID_X9_62_prime_field,
-		ec_GFp_simple_group_init,
-		ec_GFp_simple_group_finish,
-		ec_GFp_simple_group_clear_finish,
-		ec_GFp_simple_group_copy,
-		ec_GFp_simple_group_set_curve,
-		ec_GFp_simple_group_get_curve,
-		ec_GFp_simple_group_get_degree,
-		ec_GFp_simple_group_check_discriminant,
-		ec_GFp_simple_point_init,
-		ec_GFp_simple_point_finish,
-		ec_GFp_simple_point_clear_finish,
-		ec_GFp_simple_point_copy,
-		ec_GFp_simple_point_set_to_infinity,
-		ec_GFp_simple_set_Jprojective_coordinates_GFp,
-		ec_GFp_simple_get_Jprojective_coordinates_GFp,
-		ec_GFp_simple_point_set_affine_coordinates,
-		ec_GFp_simple_point_get_affine_coordinates,
-		ec_GFp_simple_set_compressed_coordinates,
-		ec_GFp_simple_point2oct,
-		ec_GFp_simple_oct2point,
-		ec_GFp_simple_add,
-		ec_GFp_simple_dbl,
-		ec_GFp_simple_invert,
-		ec_GFp_simple_is_at_infinity,
-		ec_GFp_simple_is_on_curve,
-		ec_GFp_simple_cmp,
-		ec_GFp_simple_make_affine,
-		ec_GFp_simple_points_make_affine,
-		0 /* mul */,
-		0 /* precompute_mult */,
-		0 /* have_precompute_mult */,	
-		ec_GFp_simple_field_mul,
-		ec_GFp_simple_field_sqr,
-		0 /* field_div */,
-		0 /* field_encode */,
-		0 /* field_decode */,
-		0 /* field_set_to_one */ };
-
-	return &ret;
-	}
-
-
-/* Most method functions in this file are designed to work with
- * non-trivial representations of field elements if necessary
- * (see ecp_mont.c): while standard modular addition and subtraction
- * are used, the field_mul and field_sqr methods will be used for
- * multiplication, and field_encode and field_decode (if defined)
- * will be used for converting between representations.
-
- * Functions ec_GFp_simple_points_make_affine() and
- * ec_GFp_simple_point_get_affine_coordinates() specifically assume
- * that if a non-trivial representation is used, it is a Montgomery
- * representation (i.e. 'encoding' means multiplying by some factor R).
- */
-
-
-int ec_GFp_simple_group_init(EC_GROUP *group)
-	{
-	BN_init(&group->field);
-	BN_init(&group->a);
-	BN_init(&group->b);
-	group->a_is_minus3 = 0;
-	return 1;
-	}
-
-
-void ec_GFp_simple_group_finish(EC_GROUP *group)
-	{
-	BN_free(&group->field);
-	BN_free(&group->a);
-	BN_free(&group->b);
-	}
-
-
-void ec_GFp_simple_group_clear_finish(EC_GROUP *group)
-	{
-	BN_clear_free(&group->field);
-	BN_clear_free(&group->a);
-	BN_clear_free(&group->b);
-	}
-
-
-int ec_GFp_simple_group_copy(EC_GROUP *dest, const EC_GROUP *src)
-	{
-	if (!BN_copy(&dest->field, &src->field)) return 0;
-	if (!BN_copy(&dest->a, &src->a)) return 0;
-	if (!BN_copy(&dest->b, &src->b)) return 0;
-
-	dest->a_is_minus3 = src->a_is_minus3;
-
-	return 1;
-	}
-
-
-int ec_GFp_simple_group_set_curve(EC_GROUP *group,
-	const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
-	{
-	int ret = 0;
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *tmp_a;
-	
-	/* p must be a prime > 3 */
-	if (BN_num_bits(p) <= 2 || !BN_is_odd(p))
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE, EC_R_INVALID_FIELD);
-		return 0;
-		}
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	tmp_a = BN_CTX_get(ctx);
-	if (tmp_a == NULL) goto err;
-
-	/* group->field */
-	if (!BN_copy(&group->field, p)) goto err;
-	BN_set_negative(&group->field, 0);
-
-	/* group->a */
-	if (!BN_nnmod(tmp_a, a, p, ctx)) goto err;
-	if (group->meth->field_encode)
-		{ if (!group->meth->field_encode(group, &group->a, tmp_a, ctx)) goto err; }	
-	else
-		if (!BN_copy(&group->a, tmp_a)) goto err;
-	
-	/* group->b */
-	if (!BN_nnmod(&group->b, b, p, ctx)) goto err;
-	if (group->meth->field_encode)
-		if (!group->meth->field_encode(group, &group->b, &group->b, ctx)) goto err;
-	
-	/* group->a_is_minus3 */
-	if (!BN_add_word(tmp_a, 3)) goto err;
-	group->a_is_minus3 = (0 == BN_cmp(tmp_a, &group->field));
-
-	ret = 1;
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_group_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
-	{
-	int ret = 0;
-	BN_CTX *new_ctx = NULL;
-	
-	if (p != NULL)
-		{
-		if (!BN_copy(p, &group->field)) return 0;
-		}
-
-	if (a != NULL || b != NULL)
-		{
-		if (group->meth->field_decode)
-			{
-			if (ctx == NULL)
-				{
-				ctx = new_ctx = BN_CTX_new();
-				if (ctx == NULL)
-					return 0;
-				}
-			if (a != NULL)
-				{
-				if (!group->meth->field_decode(group, a, &group->a, ctx)) goto err;
-				}
-			if (b != NULL)
-				{
-				if (!group->meth->field_decode(group, b, &group->b, ctx)) goto err;
-				}
-			}
-		else
-			{
-			if (a != NULL)
-				{
-				if (!BN_copy(a, &group->a)) goto err;
-				}
-			if (b != NULL)
-				{
-				if (!BN_copy(b, &group->b)) goto err;
-				}
-			}
-		}
-	
-	ret = 1;
-	
- err:
-	if (new_ctx)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_group_get_degree(const EC_GROUP *group)
-	{
-	return BN_num_bits(&group->field);
-	}
-
-
-int ec_GFp_simple_group_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
-	{
-	int ret = 0;
-	BIGNUM *a,*b,*order,*tmp_1,*tmp_2;
-	const BIGNUM *p = &group->field;
-	BN_CTX *new_ctx = NULL;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT, ERR_R_MALLOC_FAILURE);
-			goto err;
-			}
-		}
-	BN_CTX_start(ctx);
-	a = BN_CTX_get(ctx);
-	b = BN_CTX_get(ctx);
-	tmp_1 = BN_CTX_get(ctx);
-	tmp_2 = BN_CTX_get(ctx);
-	order = BN_CTX_get(ctx);
-	if (order == NULL) goto err;
-
-	if (group->meth->field_decode)
-		{
-		if (!group->meth->field_decode(group, a, &group->a, ctx)) goto err;
-		if (!group->meth->field_decode(group, b, &group->b, ctx)) goto err;
-		}
-	else
-		{
-		if (!BN_copy(a, &group->a)) goto err;
-		if (!BN_copy(b, &group->b)) goto err;
-		}
-	
-	/* check the discriminant:
-	 * y^2 = x^3 + a*x + b is an elliptic curve <=> 4*a^3 + 27*b^2 != 0 (mod p) 
-         * 0 =< a, b < p */
-	if (BN_is_zero(a))
-		{
-		if (BN_is_zero(b)) goto err;
-		}
-	else if (!BN_is_zero(b))
-		{
-		if (!BN_mod_sqr(tmp_1, a, p, ctx)) goto err;
-		if (!BN_mod_mul(tmp_2, tmp_1, a, p, ctx)) goto err;
-		if (!BN_lshift(tmp_1, tmp_2, 2)) goto err;
-		/* tmp_1 = 4*a^3 */
-
-		if (!BN_mod_sqr(tmp_2, b, p, ctx)) goto err;
-		if (!BN_mul_word(tmp_2, 27)) goto err;
-		/* tmp_2 = 27*b^2 */
-
-		if (!BN_mod_add(a, tmp_1, tmp_2, p, ctx)) goto err;
-		if (BN_is_zero(a)) goto err;
-		}
-	ret = 1;
-
-err:
-	if (ctx != NULL)
-		BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_point_init(EC_POINT *point)
-	{
-	BN_init(&point->X);
-	BN_init(&point->Y);
-	BN_init(&point->Z);
-	point->Z_is_one = 0;
-
-	return 1;
-	}
-
-
-void ec_GFp_simple_point_finish(EC_POINT *point)
-	{
-	BN_free(&point->X);
-	BN_free(&point->Y);
-	BN_free(&point->Z);
-	}
-
-
-void ec_GFp_simple_point_clear_finish(EC_POINT *point)
-	{
-	BN_clear_free(&point->X);
-	BN_clear_free(&point->Y);
-	BN_clear_free(&point->Z);
-	point->Z_is_one = 0;
-	}
-
-
-int ec_GFp_simple_point_copy(EC_POINT *dest, const EC_POINT *src)
-	{
-	if (!BN_copy(&dest->X, &src->X)) return 0;
-	if (!BN_copy(&dest->Y, &src->Y)) return 0;
-	if (!BN_copy(&dest->Z, &src->Z)) return 0;
-	dest->Z_is_one = src->Z_is_one;
-
-	return 1;
-	}
-
-
-int ec_GFp_simple_point_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
-	{
-	point->Z_is_one = 0;
-	BN_zero(&point->Z);
-	return 1;
-	}
-
-
-int ec_GFp_simple_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
-	const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	int ret = 0;
-	
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	if (x != NULL)
-		{
-		if (!BN_nnmod(&point->X, x, &group->field, ctx)) goto err;
-		if (group->meth->field_encode)
-			{
-			if (!group->meth->field_encode(group, &point->X, &point->X, ctx)) goto err;
-			}
-		}
-	
-	if (y != NULL)
-		{
-		if (!BN_nnmod(&point->Y, y, &group->field, ctx)) goto err;
-		if (group->meth->field_encode)
-			{
-			if (!group->meth->field_encode(group, &point->Y, &point->Y, ctx)) goto err;
-			}
-		}
-	
-	if (z != NULL)
-		{
-		int Z_is_one;
-
-		if (!BN_nnmod(&point->Z, z, &group->field, ctx)) goto err;
-		Z_is_one = BN_is_one(&point->Z);
-		if (group->meth->field_encode)
-			{
-			if (Z_is_one && (group->meth->field_set_to_one != 0))
-				{
-				if (!group->meth->field_set_to_one(group, &point->Z, ctx)) goto err;
-				}
-			else
-				{
-				if (!group->meth->field_encode(group, &point->Z, &point->Z, ctx)) goto err;
-				}
-			}
-		point->Z_is_one = Z_is_one;
-		}
-	
-	ret = 1;
-	
- err:
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
-	BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	int ret = 0;
-	
-	if (group->meth->field_decode != 0)
-		{
-		if (ctx == NULL)
-			{
-			ctx = new_ctx = BN_CTX_new();
-			if (ctx == NULL)
-				return 0;
-			}
-
-		if (x != NULL)
-			{
-			if (!group->meth->field_decode(group, x, &point->X, ctx)) goto err;
-			}
-		if (y != NULL)
-			{
-			if (!group->meth->field_decode(group, y, &point->Y, ctx)) goto err;
-			}
-		if (z != NULL)
-			{
-			if (!group->meth->field_decode(group, z, &point->Z, ctx)) goto err;
-			}
-		}
-	else	
-		{
-		if (x != NULL)
-			{
-			if (!BN_copy(x, &point->X)) goto err;
-			}
-		if (y != NULL)
-			{
-			if (!BN_copy(y, &point->Y)) goto err;
-			}
-		if (z != NULL)
-			{
-			if (!BN_copy(z, &point->Z)) goto err;
-			}
-		}
-	
-	ret = 1;
-
- err:
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_point_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,
-	const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
-	{
-	if (x == NULL || y == NULL)
-		{
-		/* unlike for projective coordinates, we do not tolerate this */
-		ECerr(EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES, ERR_R_PASSED_NULL_PARAMETER);
-		return 0;
-		}
-
-	return EC_POINT_set_Jprojective_coordinates_GFp(group, point, x, y, BN_value_one(), ctx);
-	}
-
-
-int ec_GFp_simple_point_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,
-	BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *Z, *Z_1, *Z_2, *Z_3;
-	const BIGNUM *Z_;
-	int ret = 0;
-
-	if (EC_POINT_is_at_infinity(group, point))
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES, EC_R_POINT_AT_INFINITY);
-		return 0;
-		}
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	Z = BN_CTX_get(ctx);
-	Z_1 = BN_CTX_get(ctx);
-	Z_2 = BN_CTX_get(ctx);
-	Z_3 = BN_CTX_get(ctx);
-	if (Z_3 == NULL) goto err;
-
-	/* transform  (X, Y, Z)  into  (x, y) := (X/Z^2, Y/Z^3) */
-	
-	if (group->meth->field_decode)
-		{
-		if (!group->meth->field_decode(group, Z, &point->Z, ctx)) goto err;
-		Z_ = Z;
-		}
-	else
-		{
-		Z_ = &point->Z;
-		}
-	
-	if (BN_is_one(Z_))
-		{
-		if (group->meth->field_decode)
-			{
-			if (x != NULL)
-				{
-				if (!group->meth->field_decode(group, x, &point->X, ctx)) goto err;
-				}
-			if (y != NULL)
-				{
-				if (!group->meth->field_decode(group, y, &point->Y, ctx)) goto err;
-				}
-			}
-		else
-			{
-			if (x != NULL)
-				{
-				if (!BN_copy(x, &point->X)) goto err;
-				}
-			if (y != NULL)
-				{
-				if (!BN_copy(y, &point->Y)) goto err;
-				}
-			}
-		}
-	else
-		{
-		if (!BN_mod_inverse(Z_1, Z_, &group->field, ctx))
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES, ERR_R_BN_LIB);
-			goto err;
-			}
-		
-		if (group->meth->field_encode == 0)
-			{
-			/* field_sqr works on standard representation */
-			if (!group->meth->field_sqr(group, Z_2, Z_1, ctx)) goto err;
-			}
-		else
-			{
-			if (!BN_mod_sqr(Z_2, Z_1, &group->field, ctx)) goto err;
-			}
-	
-		if (x != NULL)
-			{
-			/* in the Montgomery case, field_mul will cancel out Montgomery factor in X: */
-			if (!group->meth->field_mul(group, x, &point->X, Z_2, ctx)) goto err;
-			}
-
-		if (y != NULL)
-			{
-			if (group->meth->field_encode == 0)
-				{
-				/* field_mul works on standard representation */
-				if (!group->meth->field_mul(group, Z_3, Z_2, Z_1, ctx)) goto err;
-				}
-			else
-				{
-				if (!BN_mod_mul(Z_3, Z_2, Z_1, &group->field, ctx)) goto err;
-				}
-
-			/* in the Montgomery case, field_mul will cancel out Montgomery factor in Y: */
-			if (!group->meth->field_mul(group, y, &point->Y, Z_3, ctx)) goto err;
-			}
-		}
-
-	ret = 1;
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *point,
-	const BIGNUM *x_, int y_bit, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *tmp1, *tmp2, *x, *y;
-	int ret = 0;
-
-	/* clear error queue*/
-	ERR_clear_error();
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	y_bit = (y_bit != 0);
-
-	BN_CTX_start(ctx);
-	tmp1 = BN_CTX_get(ctx);
-	tmp2 = BN_CTX_get(ctx);
-	x = BN_CTX_get(ctx);
-	y = BN_CTX_get(ctx);
-	if (y == NULL) goto err;
-
-	/* Recover y.  We have a Weierstrass equation
-	 *     y^2 = x^3 + a*x + b,
-	 * so  y  is one of the square roots of  x^3 + a*x + b.
-	 */
-
-	/* tmp1 := x^3 */
-	if (!BN_nnmod(x, x_, &group->field,ctx)) goto err;
-	if (group->meth->field_decode == 0)
-		{
-		/* field_{sqr,mul} work on standard representation */
-		if (!group->meth->field_sqr(group, tmp2, x_, ctx)) goto err;
-		if (!group->meth->field_mul(group, tmp1, tmp2, x_, ctx)) goto err;
-		}
-	else
-		{
-		if (!BN_mod_sqr(tmp2, x_, &group->field, ctx)) goto err;
-		if (!BN_mod_mul(tmp1, tmp2, x_, &group->field, ctx)) goto err;
-		}
-	
-	/* tmp1 := tmp1 + a*x */
-	if (group->a_is_minus3)
-		{
-		if (!BN_mod_lshift1_quick(tmp2, x, &group->field)) goto err;
-		if (!BN_mod_add_quick(tmp2, tmp2, x, &group->field)) goto err;
-		if (!BN_mod_sub_quick(tmp1, tmp1, tmp2, &group->field)) goto err;
-		}
-	else
-		{
-		if (group->meth->field_decode)
-			{
-			if (!group->meth->field_decode(group, tmp2, &group->a, ctx)) goto err;
-			if (!BN_mod_mul(tmp2, tmp2, x, &group->field, ctx)) goto err;
-			}
-		else
-			{
-			/* field_mul works on standard representation */
-			if (!group->meth->field_mul(group, tmp2, &group->a, x, ctx)) goto err;
-			}
-		
-		if (!BN_mod_add_quick(tmp1, tmp1, tmp2, &group->field)) goto err;
-		}
-	
-	/* tmp1 := tmp1 + b */
-	if (group->meth->field_decode)
-		{
-		if (!group->meth->field_decode(group, tmp2, &group->b, ctx)) goto err;
-		if (!BN_mod_add_quick(tmp1, tmp1, tmp2, &group->field)) goto err;
-		}
-	else
-		{
-		if (!BN_mod_add_quick(tmp1, tmp1, &group->b, &group->field)) goto err;
-		}
-	
-	if (!BN_mod_sqrt(y, tmp1, &group->field, ctx))
-		{
-		unsigned long err = ERR_peek_last_error();
-		
-		if (ERR_GET_LIB(err) == ERR_LIB_BN && ERR_GET_REASON(err) == BN_R_NOT_A_SQUARE)
-			{
-			ERR_clear_error();
-			ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSED_POINT);
-			}
-		else
-			ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, ERR_R_BN_LIB);
-		goto err;
-		}
-
-	if (y_bit != BN_is_odd(y))
-		{
-		if (BN_is_zero(y))
-			{
-			int kron;
-
-			kron = BN_kronecker(x, &group->field, ctx);
-			if (kron == -2) goto err;
-
-			if (kron == 1)
-				ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSION_BIT);
-			else
-				/* BN_mod_sqrt() should have cought this error (not a square) */
-				ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSED_POINT);
-			goto err;
-			}
-		if (!BN_usub(y, &group->field, y)) goto err;
-		}
-	if (y_bit != BN_is_odd(y))
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, ERR_R_INTERNAL_ERROR);
-		goto err;
-		}
-
-	if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;
-
-	ret = 1;
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-size_t ec_GFp_simple_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
-	unsigned char *buf, size_t len, BN_CTX *ctx)
-	{
-	size_t ret;
-	BN_CTX *new_ctx = NULL;
-	int used_ctx = 0;
-	BIGNUM *x, *y;
-	size_t field_len, i, skip;
-
-	if ((form != POINT_CONVERSION_COMPRESSED)
-		&& (form != POINT_CONVERSION_UNCOMPRESSED)
-		&& (form != POINT_CONVERSION_HYBRID))
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, EC_R_INVALID_FORM);
-		goto err;
-		}
-
-	if (EC_POINT_is_at_infinity(group, point))
-		{
-		/* encodes to a single 0 octet */
-		if (buf != NULL)
-			{
-			if (len < 1)
-				{
-				ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);
-				return 0;
-				}
-			buf[0] = 0;
-			}
-		return 1;
-		}
-
-
-	/* ret := required output buffer length */
-	field_len = BN_num_bytes(&group->field);
-	ret = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;
-
-	/* if 'buf' is NULL, just return required length */
-	if (buf != NULL)
-		{
-		if (len < ret)
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);
-			goto err;
-			}
-
-		if (ctx == NULL)
-			{
-			ctx = new_ctx = BN_CTX_new();
-			if (ctx == NULL)
-				return 0;
-			}
-
-		BN_CTX_start(ctx);
-		used_ctx = 1;
-		x = BN_CTX_get(ctx);
-		y = BN_CTX_get(ctx);
-		if (y == NULL) goto err;
-
-		if (!EC_POINT_get_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;
-
-		if ((form == POINT_CONVERSION_COMPRESSED || form == POINT_CONVERSION_HYBRID) && BN_is_odd(y))
-			buf[0] = form + 1;
-		else
-			buf[0] = form;
-	
-		i = 1;
-		
-		skip = field_len - BN_num_bytes(x);
-		if (skip > field_len)
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-			goto err;
-			}
-		while (skip > 0)
-			{
-			buf[i++] = 0;
-			skip--;
-			}
-		skip = BN_bn2bin(x, buf + i);
-		i += skip;
-		if (i != 1 + field_len)
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-			goto err;
-			}
-
-		if (form == POINT_CONVERSION_UNCOMPRESSED || form == POINT_CONVERSION_HYBRID)
-			{
-			skip = field_len - BN_num_bytes(y);
-			if (skip > field_len)
-				{
-				ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-				goto err;
-				}
-			while (skip > 0)
-				{
-				buf[i++] = 0;
-				skip--;
-				}
-			skip = BN_bn2bin(y, buf + i);
-			i += skip;
-			}
-
-		if (i != ret)
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);
-			goto err;
-			}
-		}
-	
-	if (used_ctx)
-		BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-
- err:
-	if (used_ctx)
-		BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return 0;
-	}
-
-
-int ec_GFp_simple_oct2point(const EC_GROUP *group, EC_POINT *point,
-	const unsigned char *buf, size_t len, BN_CTX *ctx)
-	{
-	point_conversion_form_t form;
-	int y_bit;
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *x, *y;
-	size_t field_len, enc_len;
-	int ret = 0;
-
-	if (len == 0)
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_BUFFER_TOO_SMALL);
-		return 0;
-		}
-	form = buf[0];
-	y_bit = form & 1;
-	form = form & ~1U;
-	if ((form != 0)	&& (form != POINT_CONVERSION_COMPRESSED)
-		&& (form != POINT_CONVERSION_UNCOMPRESSED)
-		&& (form != POINT_CONVERSION_HYBRID))
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		return 0;
-		}
-	if ((form == 0 || form == POINT_CONVERSION_UNCOMPRESSED) && y_bit)
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		return 0;
-		}
-
-	if (form == 0)
-		{
-		if (len != 1)
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-			return 0;
-			}
-
-		return EC_POINT_set_to_infinity(group, point);
-		}
-	
-	field_len = BN_num_bytes(&group->field);
-	enc_len = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;
-
-	if (len != enc_len)
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		return 0;
-		}
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	x = BN_CTX_get(ctx);
-	y = BN_CTX_get(ctx);
-	if (y == NULL) goto err;
-
-	if (!BN_bin2bn(buf + 1, field_len, x)) goto err;
-	if (BN_ucmp(x, &group->field) >= 0)
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-		goto err;
-		}
-
-	if (form == POINT_CONVERSION_COMPRESSED)
-		{
-		if (!EC_POINT_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx)) goto err;
-		}
-	else
-		{
-		if (!BN_bin2bn(buf + 1 + field_len, field_len, y)) goto err;
-		if (BN_ucmp(y, &group->field) >= 0)
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-			goto err;
-			}
-		if (form == POINT_CONVERSION_HYBRID)
-			{
-			if (y_bit != BN_is_odd(y))
-				{
-				ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);
-				goto err;
-				}
-			}
-
-		if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;
-		}
-	
-	if (!EC_POINT_is_on_curve(group, point, ctx)) /* test required by X9.62 */
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_POINT_IS_NOT_ON_CURVE);
-		goto err;
-		}
-
-	ret = 1;
-	
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
-	{
-	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);
-	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);
-	const BIGNUM *p;
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *n0, *n1, *n2, *n3, *n4, *n5, *n6;
-	int ret = 0;
-	
-	if (a == b)
-		return EC_POINT_dbl(group, r, a, ctx);
-	if (EC_POINT_is_at_infinity(group, a))
-		return EC_POINT_copy(r, b);
-	if (EC_POINT_is_at_infinity(group, b))
-		return EC_POINT_copy(r, a);
-	
-	field_mul = group->meth->field_mul;
-	field_sqr = group->meth->field_sqr;
-	p = &group->field;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	n0 = BN_CTX_get(ctx);
-	n1 = BN_CTX_get(ctx);
-	n2 = BN_CTX_get(ctx);
-	n3 = BN_CTX_get(ctx);
-	n4 = BN_CTX_get(ctx);
-	n5 = BN_CTX_get(ctx);
-	n6 = BN_CTX_get(ctx);
-	if (n6 == NULL) goto end;
-
-	/* Note that in this function we must not read components of 'a' or 'b'
-	 * once we have written the corresponding components of 'r'.
-	 * ('r' might be one of 'a' or 'b'.)
-	 */
-
-	/* n1, n2 */
-	if (b->Z_is_one)
-		{
-		if (!BN_copy(n1, &a->X)) goto end;
-		if (!BN_copy(n2, &a->Y)) goto end;
-		/* n1 = X_a */
-		/* n2 = Y_a */
-		}
-	else
-		{
-		if (!field_sqr(group, n0, &b->Z, ctx)) goto end;
-		if (!field_mul(group, n1, &a->X, n0, ctx)) goto end;
-		/* n1 = X_a * Z_b^2 */
-
-		if (!field_mul(group, n0, n0, &b->Z, ctx)) goto end;
-		if (!field_mul(group, n2, &a->Y, n0, ctx)) goto end;
-		/* n2 = Y_a * Z_b^3 */
-		}
-
-	/* n3, n4 */
-	if (a->Z_is_one)
-		{
-		if (!BN_copy(n3, &b->X)) goto end;
-		if (!BN_copy(n4, &b->Y)) goto end;
-		/* n3 = X_b */
-		/* n4 = Y_b */
-		}
-	else
-		{
-		if (!field_sqr(group, n0, &a->Z, ctx)) goto end;
-		if (!field_mul(group, n3, &b->X, n0, ctx)) goto end;
-		/* n3 = X_b * Z_a^2 */
-
-		if (!field_mul(group, n0, n0, &a->Z, ctx)) goto end;
-		if (!field_mul(group, n4, &b->Y, n0, ctx)) goto end;
-		/* n4 = Y_b * Z_a^3 */
-		}
-
-	/* n5, n6 */
-	if (!BN_mod_sub_quick(n5, n1, n3, p)) goto end;
-	if (!BN_mod_sub_quick(n6, n2, n4, p)) goto end;
-	/* n5 = n1 - n3 */
-	/* n6 = n2 - n4 */
-
-	if (BN_is_zero(n5))
-		{
-		if (BN_is_zero(n6))
-			{
-			/* a is the same point as b */
-			BN_CTX_end(ctx);
-			ret = EC_POINT_dbl(group, r, a, ctx);
-			ctx = NULL;
-			goto end;
-			}
-		else
-			{
-			/* a is the inverse of b */
-			BN_zero(&r->Z);
-			r->Z_is_one = 0;
-			ret = 1;
-			goto end;
-			}
-		}
-
-	/* 'n7', 'n8' */
-	if (!BN_mod_add_quick(n1, n1, n3, p)) goto end;
-	if (!BN_mod_add_quick(n2, n2, n4, p)) goto end;
-	/* 'n7' = n1 + n3 */
-	/* 'n8' = n2 + n4 */
-
-	/* Z_r */
-	if (a->Z_is_one && b->Z_is_one)
-		{
-		if (!BN_copy(&r->Z, n5)) goto end;
-		}
-	else
-		{
-		if (a->Z_is_one)
-			{ if (!BN_copy(n0, &b->Z)) goto end; }
-		else if (b->Z_is_one)
-			{ if (!BN_copy(n0, &a->Z)) goto end; }
-		else
-			{ if (!field_mul(group, n0, &a->Z, &b->Z, ctx)) goto end; }
-		if (!field_mul(group, &r->Z, n0, n5, ctx)) goto end;
-		}
-	r->Z_is_one = 0;
-	/* Z_r = Z_a * Z_b * n5 */
-
-	/* X_r */
-	if (!field_sqr(group, n0, n6, ctx)) goto end;
-	if (!field_sqr(group, n4, n5, ctx)) goto end;
-	if (!field_mul(group, n3, n1, n4, ctx)) goto end;
-	if (!BN_mod_sub_quick(&r->X, n0, n3, p)) goto end;
-	/* X_r = n6^2 - n5^2 * 'n7' */
-	
-	/* 'n9' */
-	if (!BN_mod_lshift1_quick(n0, &r->X, p)) goto end;
-	if (!BN_mod_sub_quick(n0, n3, n0, p)) goto end;
-	/* n9 = n5^2 * 'n7' - 2 * X_r */
-
-	/* Y_r */
-	if (!field_mul(group, n0, n0, n6, ctx)) goto end;
-	if (!field_mul(group, n5, n4, n5, ctx)) goto end; /* now n5 is n5^3 */
-	if (!field_mul(group, n1, n2, n5, ctx)) goto end;
-	if (!BN_mod_sub_quick(n0, n0, n1, p)) goto end;
-	if (BN_is_odd(n0))
-		if (!BN_add(n0, n0, p)) goto end;
-	/* now  0 <= n0 < 2*p,  and n0 is even */
-	if (!BN_rshift1(&r->Y, n0)) goto end;
-	/* Y_r = (n6 * 'n9' - 'n8' * 'n5^3') / 2 */
-
-	ret = 1;
-
- end:
-	if (ctx) /* otherwise we already called BN_CTX_end */
-		BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
-	{
-	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);
-	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);
-	const BIGNUM *p;
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *n0, *n1, *n2, *n3;
-	int ret = 0;
-	
-	if (EC_POINT_is_at_infinity(group, a))
-		{
-		BN_zero(&r->Z);
-		r->Z_is_one = 0;
-		return 1;
-		}
-
-	field_mul = group->meth->field_mul;
-	field_sqr = group->meth->field_sqr;
-	p = &group->field;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	n0 = BN_CTX_get(ctx);
-	n1 = BN_CTX_get(ctx);
-	n2 = BN_CTX_get(ctx);
-	n3 = BN_CTX_get(ctx);
-	if (n3 == NULL) goto err;
-
-	/* Note that in this function we must not read components of 'a'
-	 * once we have written the corresponding components of 'r'.
-	 * ('r' might the same as 'a'.)
-	 */
-
-	/* n1 */
-	if (a->Z_is_one)
-		{
-		if (!field_sqr(group, n0, &a->X, ctx)) goto err;
-		if (!BN_mod_lshift1_quick(n1, n0, p)) goto err;
-		if (!BN_mod_add_quick(n0, n0, n1, p)) goto err;
-		if (!BN_mod_add_quick(n1, n0, &group->a, p)) goto err;
-		/* n1 = 3 * X_a^2 + a_curve */
-		}
-	else if (group->a_is_minus3)
-		{
-		if (!field_sqr(group, n1, &a->Z, ctx)) goto err;
-		if (!BN_mod_add_quick(n0, &a->X, n1, p)) goto err;
-		if (!BN_mod_sub_quick(n2, &a->X, n1, p)) goto err;
-		if (!field_mul(group, n1, n0, n2, ctx)) goto err;
-		if (!BN_mod_lshift1_quick(n0, n1, p)) goto err;
-		if (!BN_mod_add_quick(n1, n0, n1, p)) goto err;
-		/* n1 = 3 * (X_a + Z_a^2) * (X_a - Z_a^2)
-		 *    = 3 * X_a^2 - 3 * Z_a^4 */
-		}
-	else
-		{
-		if (!field_sqr(group, n0, &a->X, ctx)) goto err;
-		if (!BN_mod_lshift1_quick(n1, n0, p)) goto err;
-		if (!BN_mod_add_quick(n0, n0, n1, p)) goto err;
-		if (!field_sqr(group, n1, &a->Z, ctx)) goto err;
-		if (!field_sqr(group, n1, n1, ctx)) goto err;
-		if (!field_mul(group, n1, n1, &group->a, ctx)) goto err;
-		if (!BN_mod_add_quick(n1, n1, n0, p)) goto err;
-		/* n1 = 3 * X_a^2 + a_curve * Z_a^4 */
-		}
-
-	/* Z_r */
-	if (a->Z_is_one)
-		{
-		if (!BN_copy(n0, &a->Y)) goto err;
-		}
-	else
-		{
-		if (!field_mul(group, n0, &a->Y, &a->Z, ctx)) goto err;
-		}
-	if (!BN_mod_lshift1_quick(&r->Z, n0, p)) goto err;
-	r->Z_is_one = 0;
-	/* Z_r = 2 * Y_a * Z_a */
-
-	/* n2 */
-	if (!field_sqr(group, n3, &a->Y, ctx)) goto err;
-	if (!field_mul(group, n2, &a->X, n3, ctx)) goto err;
-	if (!BN_mod_lshift_quick(n2, n2, 2, p)) goto err;
-	/* n2 = 4 * X_a * Y_a^2 */
-
-	/* X_r */
-	if (!BN_mod_lshift1_quick(n0, n2, p)) goto err;
-	if (!field_sqr(group, &r->X, n1, ctx)) goto err;
-	if (!BN_mod_sub_quick(&r->X, &r->X, n0, p)) goto err;
-	/* X_r = n1^2 - 2 * n2 */
-	
-	/* n3 */
-	if (!field_sqr(group, n0, n3, ctx)) goto err;
-	if (!BN_mod_lshift_quick(n3, n0, 3, p)) goto err;
-	/* n3 = 8 * Y_a^4 */
-	
-	/* Y_r */
-	if (!BN_mod_sub_quick(n0, n2, &r->X, p)) goto err;
-	if (!field_mul(group, n0, n1, n0, ctx)) goto err;
-	if (!BN_mod_sub_quick(&r->Y, n0, n3, p)) goto err;
-	/* Y_r = n1 * (n2 - X_r) - n3 */
-
-	ret = 1;
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_invert(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
-	{
-	if (EC_POINT_is_at_infinity(group, point) || BN_is_zero(&point->Y))
-		/* point is its own inverse */
-		return 1;
-	
-	return BN_usub(&point->Y, &group->field, &point->Y);
-	}
-
-
-int ec_GFp_simple_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
-	{
-	return BN_is_zero(&point->Z);
-	}
-
-
-int ec_GFp_simple_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
-	{
-	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);
-	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);
-	const BIGNUM *p;
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *rh, *tmp, *Z4, *Z6;
-	int ret = -1;
-
-	if (EC_POINT_is_at_infinity(group, point))
-		return 1;
-	
-	field_mul = group->meth->field_mul;
-	field_sqr = group->meth->field_sqr;
-	p = &group->field;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return -1;
-		}
-
-	BN_CTX_start(ctx);
-	rh = BN_CTX_get(ctx);
-	tmp = BN_CTX_get(ctx);
-	Z4 = BN_CTX_get(ctx);
-	Z6 = BN_CTX_get(ctx);
-	if (Z6 == NULL) goto err;
-
-	/* We have a curve defined by a Weierstrass equation
-	 *      y^2 = x^3 + a*x + b.
-	 * The point to consider is given in Jacobian projective coordinates
-	 * where  (X, Y, Z)  represents  (x, y) = (X/Z^2, Y/Z^3).
-	 * Substituting this and multiplying by  Z^6  transforms the above equation into
-	 *      Y^2 = X^3 + a*X*Z^4 + b*Z^6.
-	 * To test this, we add up the right-hand side in 'rh'.
-	 */
-
-	/* rh := X^2 */
-	if (!field_sqr(group, rh, &point->X, ctx)) goto err;
-
-	if (!point->Z_is_one)
-		{
-		if (!field_sqr(group, tmp, &point->Z, ctx)) goto err;
-		if (!field_sqr(group, Z4, tmp, ctx)) goto err;
-		if (!field_mul(group, Z6, Z4, tmp, ctx)) goto err;
-
-		/* rh := (rh + a*Z^4)*X */
-		if (group->a_is_minus3)
-			{
-			if (!BN_mod_lshift1_quick(tmp, Z4, p)) goto err;
-			if (!BN_mod_add_quick(tmp, tmp, Z4, p)) goto err;
-			if (!BN_mod_sub_quick(rh, rh, tmp, p)) goto err;
-			if (!field_mul(group, rh, rh, &point->X, ctx)) goto err;
-			}
-		else
-			{
-			if (!field_mul(group, tmp, Z4, &group->a, ctx)) goto err;
-			if (!BN_mod_add_quick(rh, rh, tmp, p)) goto err;
-			if (!field_mul(group, rh, rh, &point->X, ctx)) goto err;
-			}
-
-		/* rh := rh + b*Z^6 */
-		if (!field_mul(group, tmp, &group->b, Z6, ctx)) goto err;
-		if (!BN_mod_add_quick(rh, rh, tmp, p)) goto err;
-		}
-	else
-		{
-		/* point->Z_is_one */
-
-		/* rh := (rh + a)*X */
-		if (!BN_mod_add_quick(rh, rh, &group->a, p)) goto err;
-		if (!field_mul(group, rh, rh, &point->X, ctx)) goto err;
-		/* rh := rh + b */
-		if (!BN_mod_add_quick(rh, rh, &group->b, p)) goto err;
-		}
-
-	/* 'lh' := Y^2 */
-	if (!field_sqr(group, tmp, &point->Y, ctx)) goto err;
-
-	ret = (0 == BN_ucmp(tmp, rh));
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
-	{
-	/* return values:
-	 *  -1   error
-	 *   0   equal (in affine coordinates)
-	 *   1   not equal
-	 */
-
-	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);
-	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *tmp1, *tmp2, *Za23, *Zb23;
-	const BIGNUM *tmp1_, *tmp2_;
-	int ret = -1;
-	
-	if (EC_POINT_is_at_infinity(group, a))
-		{
-		return EC_POINT_is_at_infinity(group, b) ? 0 : 1;
-		}
-	
-	if (a->Z_is_one && b->Z_is_one)
-		{
-		return ((BN_cmp(&a->X, &b->X) == 0) && BN_cmp(&a->Y, &b->Y) == 0) ? 0 : 1;
-		}
-
-	field_mul = group->meth->field_mul;
-	field_sqr = group->meth->field_sqr;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return -1;
-		}
-
-	BN_CTX_start(ctx);
-	tmp1 = BN_CTX_get(ctx);
-	tmp2 = BN_CTX_get(ctx);
-	Za23 = BN_CTX_get(ctx);
-	Zb23 = BN_CTX_get(ctx);
-	if (Zb23 == NULL) goto end;
-
-	/* We have to decide whether
-	 *     (X_a/Z_a^2, Y_a/Z_a^3) = (X_b/Z_b^2, Y_b/Z_b^3),
-	 * or equivalently, whether
-	 *     (X_a*Z_b^2, Y_a*Z_b^3) = (X_b*Z_a^2, Y_b*Z_a^3).
-	 */
-
-	if (!b->Z_is_one)
-		{
-		if (!field_sqr(group, Zb23, &b->Z, ctx)) goto end;
-		if (!field_mul(group, tmp1, &a->X, Zb23, ctx)) goto end;
-		tmp1_ = tmp1;
-		}
-	else
-		tmp1_ = &a->X;
-	if (!a->Z_is_one)
-		{
-		if (!field_sqr(group, Za23, &a->Z, ctx)) goto end;
-		if (!field_mul(group, tmp2, &b->X, Za23, ctx)) goto end;
-		tmp2_ = tmp2;
-		}
-	else
-		tmp2_ = &b->X;
-	
-	/* compare  X_a*Z_b^2  with  X_b*Z_a^2 */
-	if (BN_cmp(tmp1_, tmp2_) != 0)
-		{
-		ret = 1; /* points differ */
-		goto end;
-		}
-
-
-	if (!b->Z_is_one)
-		{
-		if (!field_mul(group, Zb23, Zb23, &b->Z, ctx)) goto end;
-		if (!field_mul(group, tmp1, &a->Y, Zb23, ctx)) goto end;
-		/* tmp1_ = tmp1 */
-		}
-	else
-		tmp1_ = &a->Y;
-	if (!a->Z_is_one)
-		{
-		if (!field_mul(group, Za23, Za23, &a->Z, ctx)) goto end;
-		if (!field_mul(group, tmp2, &b->Y, Za23, ctx)) goto end;
-		/* tmp2_ = tmp2 */
-		}
-	else
-		tmp2_ = &b->Y;
-
-	/* compare  Y_a*Z_b^3  with  Y_b*Z_a^3 */
-	if (BN_cmp(tmp1_, tmp2_) != 0)
-		{
-		ret = 1; /* points differ */
-		goto end;
-		}
-
-	/* points are equal */
-	ret = 0;
-
- end:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *x, *y;
-	int ret = 0;
-
-	if (point->Z_is_one || EC_POINT_is_at_infinity(group, point))
-		return 1;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	x = BN_CTX_get(ctx);
-	y = BN_CTX_get(ctx);
-	if (y == NULL) goto err;
-
-	if (!EC_POINT_get_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;
-	if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;
-	if (!point->Z_is_one)
-		{
-		ECerr(EC_F_EC_GFP_SIMPLE_MAKE_AFFINE, ERR_R_INTERNAL_ERROR);
-		goto err;
-		}
-	
-	ret = 1;
-
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	return ret;
-	}
-
-
-int ec_GFp_simple_points_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
-	{
-	BN_CTX *new_ctx = NULL;
-	BIGNUM *tmp0, *tmp1;
-	size_t pow2 = 0;
-	BIGNUM **heap = NULL;
-	size_t i;
-	int ret = 0;
-
-	if (num == 0)
-		return 1;
-
-	if (ctx == NULL)
-		{
-		ctx = new_ctx = BN_CTX_new();
-		if (ctx == NULL)
-			return 0;
-		}
-
-	BN_CTX_start(ctx);
-	tmp0 = BN_CTX_get(ctx);
-	tmp1 = BN_CTX_get(ctx);
-	if (tmp0  == NULL || tmp1 == NULL) goto err;
-
-	/* Before converting the individual points, compute inverses of all Z values.
-	 * Modular inversion is rather slow, but luckily we can do with a single
-	 * explicit inversion, plus about 3 multiplications per input value.
-	 */
-
-	pow2 = 1;
-	while (num > pow2)
-		pow2 <<= 1;
-	/* Now pow2 is the smallest power of 2 satifsying pow2 >= num.
-	 * We need twice that. */
-	pow2 <<= 1;
-
-	heap = OPENSSL_malloc(pow2 * sizeof heap[0]);
-	if (heap == NULL) goto err;
-	
-	/* The array is used as a binary tree, exactly as in heapsort:
-	 *
-	 *                               heap[1]
-	 *                 heap[2]                     heap[3]
-	 *          heap[4]       heap[5]       heap[6]       heap[7]
-	 *   heap[8]heap[9] heap[10]heap[11] heap[12]heap[13] heap[14] heap[15]
-	 *
-	 * We put the Z's in the last line;
-	 * then we set each other node to the product of its two child-nodes (where
-	 * empty or 0 entries are treated as ones);
-	 * then we invert heap[1];
-	 * then we invert each other node by replacing it by the product of its
-	 * parent (after inversion) and its sibling (before inversion).
-	 */
-	heap[0] = NULL;
-	for (i = pow2/2 - 1; i > 0; i--)
-		heap[i] = NULL;
-	for (i = 0; i < num; i++)
-		heap[pow2/2 + i] = &points[i]->Z;
-	for (i = pow2/2 + num; i < pow2; i++)
-		heap[i] = NULL;
-	
-	/* set each node to the product of its children */
-	for (i = pow2/2 - 1; i > 0; i--)
-		{
-		heap[i] = BN_new();
-		if (heap[i] == NULL) goto err;
-		
-		if (heap[2*i] != NULL)
-			{
-			if ((heap[2*i + 1] == NULL) || BN_is_zero(heap[2*i + 1]))
-				{
-				if (!BN_copy(heap[i], heap[2*i])) goto err;
-				}
-			else
-				{
-				if (BN_is_zero(heap[2*i]))
-					{
-					if (!BN_copy(heap[i], heap[2*i + 1])) goto err;
-					}
-				else
-					{
-					if (!group->meth->field_mul(group, heap[i],
-						heap[2*i], heap[2*i + 1], ctx)) goto err;
-					}
-				}
-			}
-		}
-
-	/* invert heap[1] */
-	if (!BN_is_zero(heap[1]))
-		{
-		if (!BN_mod_inverse(heap[1], heap[1], &group->field, ctx))
-			{
-			ECerr(EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE, ERR_R_BN_LIB);
-			goto err;
-			}
-		}
-	if (group->meth->field_encode != 0)
-		{
-		/* in the Montgomery case, we just turned  R*H  (representing H)
-		 * into  1/(R*H),  but we need  R*(1/H)  (representing 1/H);
-		 * i.e. we have need to multiply by the Montgomery factor twice */
-		if (!group->meth->field_encode(group, heap[1], heap[1], ctx)) goto err;
-		if (!group->meth->field_encode(group, heap[1], heap[1], ctx)) goto err;
-		}
-
-	/* set other heap[i]'s to their inverses */
-	for (i = 2; i < pow2/2 + num; i += 2)
-		{
-		/* i is even */
-		if ((heap[i + 1] != NULL) && !BN_is_zero(heap[i + 1]))
-			{
-			if (!group->meth->field_mul(group, tmp0, heap[i/2], heap[i + 1], ctx)) goto err;
-			if (!group->meth->field_mul(group, tmp1, heap[i/2], heap[i], ctx)) goto err;
-			if (!BN_copy(heap[i], tmp0)) goto err;
-			if (!BN_copy(heap[i + 1], tmp1)) goto err;
-			}
-		else
-			{
-			if (!BN_copy(heap[i], heap[i/2])) goto err;
-			}
-		}
-
-	/* we have replaced all non-zero Z's by their inverses, now fix up all the points */
-	for (i = 0; i < num; i++)
-		{
-		EC_POINT *p = points[i];
-		
-		if (!BN_is_zero(&p->Z))
-			{
-			/* turn  (X, Y, 1/Z)  into  (X/Z^2, Y/Z^3, 1) */
-
-			if (!group->meth->field_sqr(group, tmp1, &p->Z, ctx)) goto err;
-			if (!group->meth->field_mul(group, &p->X, &p->X, tmp1, ctx)) goto err;
-
-			if (!group->meth->field_mul(group, tmp1, tmp1, &p->Z, ctx)) goto err;
-			if (!group->meth->field_mul(group, &p->Y, &p->Y, tmp1, ctx)) goto err;
-		
-			if (group->meth->field_set_to_one != 0)
-				{
-				if (!group->meth->field_set_to_one(group, &p->Z, ctx)) goto err;
-				}
-			else
-				{
-				if (!BN_one(&p->Z)) goto err;
-				}
-			p->Z_is_one = 1;
-			}
-		}
-
-	ret = 1;
-		
- err:
-	BN_CTX_end(ctx);
-	if (new_ctx != NULL)
-		BN_CTX_free(new_ctx);
-	if (heap != NULL)
-		{
-		/* heap[pow2/2] .. heap[pow2-1] have not been allocated locally! */
-		for (i = pow2/2 - 1; i > 0; i--)
-			{
-			if (heap[i] != NULL)
-				BN_clear_free(heap[i]);
-			}
-		OPENSSL_free(heap);
-		}
-	return ret;
-	}
-
-
-int ec_GFp_simple_field_mul(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
-	{
-	return BN_mod_mul(r, a, b, &group->field, ctx);
-	}
-
-
-int ec_GFp_simple_field_sqr(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
-	{
-	return BN_mod_sqr(r, a, &group->field, ctx);
-	}
+/* crypto/ec/ecp_smpl.c */

+/* Includes code written by Lenka Fibikova <fibikova@exp-math.uni-essen.de>

+ * for the OpenSSL project. 

+ * Includes code written by Bodo Moeller for the OpenSSL project.

+*/

+/* ====================================================================

+ * 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).

+ *

+ */

+/* ====================================================================

+ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

+ * Portions of this software developed by SUN MICROSYSTEMS, INC.,

+ * and contributed to the OpenSSL project.

+ */

+

+#include <openssl/err.h>

+#include <openssl/symhacks.h>

+

+#include "ec_lcl.h"

+

+const EC_METHOD *EC_GFp_simple_method(void)

+	{

+	static const EC_METHOD ret = {

+		NID_X9_62_prime_field,

+		ec_GFp_simple_group_init,

+		ec_GFp_simple_group_finish,

+		ec_GFp_simple_group_clear_finish,

+		ec_GFp_simple_group_copy,

+		ec_GFp_simple_group_set_curve,

+		ec_GFp_simple_group_get_curve,

+		ec_GFp_simple_group_get_degree,

+		ec_GFp_simple_group_check_discriminant,

+		ec_GFp_simple_point_init,

+		ec_GFp_simple_point_finish,

+		ec_GFp_simple_point_clear_finish,

+		ec_GFp_simple_point_copy,

+		ec_GFp_simple_point_set_to_infinity,

+		ec_GFp_simple_set_Jprojective_coordinates_GFp,

+		ec_GFp_simple_get_Jprojective_coordinates_GFp,

+		ec_GFp_simple_point_set_affine_coordinates,

+		ec_GFp_simple_point_get_affine_coordinates,

+		ec_GFp_simple_set_compressed_coordinates,

+		ec_GFp_simple_point2oct,

+		ec_GFp_simple_oct2point,

+		ec_GFp_simple_add,

+		ec_GFp_simple_dbl,

+		ec_GFp_simple_invert,

+		ec_GFp_simple_is_at_infinity,

+		ec_GFp_simple_is_on_curve,

+		ec_GFp_simple_cmp,

+		ec_GFp_simple_make_affine,

+		ec_GFp_simple_points_make_affine,

+		0 /* mul */,

+		0 /* precompute_mult */,

+		0 /* have_precompute_mult */,	

+		ec_GFp_simple_field_mul,

+		ec_GFp_simple_field_sqr,

+		0 /* field_div */,

+		0 /* field_encode */,

+		0 /* field_decode */,

+		0 /* field_set_to_one */ };

+

+	return &ret;

+	}

+

+

+/* Most method functions in this file are designed to work with

+ * non-trivial representations of field elements if necessary

+ * (see ecp_mont.c): while standard modular addition and subtraction

+ * are used, the field_mul and field_sqr methods will be used for

+ * multiplication, and field_encode and field_decode (if defined)

+ * will be used for converting between representations.

+

+ * Functions ec_GFp_simple_points_make_affine() and

+ * ec_GFp_simple_point_get_affine_coordinates() specifically assume

+ * that if a non-trivial representation is used, it is a Montgomery

+ * representation (i.e. 'encoding' means multiplying by some factor R).

+ */

+

+

+int ec_GFp_simple_group_init(EC_GROUP *group)

+	{

+	BN_init(&group->field);

+	BN_init(&group->a);

+	BN_init(&group->b);

+	group->a_is_minus3 = 0;

+	return 1;

+	}

+

+

+void ec_GFp_simple_group_finish(EC_GROUP *group)

+	{

+	BN_free(&group->field);

+	BN_free(&group->a);

+	BN_free(&group->b);

+	}

+

+

+void ec_GFp_simple_group_clear_finish(EC_GROUP *group)

+	{

+	BN_clear_free(&group->field);

+	BN_clear_free(&group->a);

+	BN_clear_free(&group->b);

+	}

+

+

+int ec_GFp_simple_group_copy(EC_GROUP *dest, const EC_GROUP *src)

+	{

+	if (!BN_copy(&dest->field, &src->field)) return 0;

+	if (!BN_copy(&dest->a, &src->a)) return 0;

+	if (!BN_copy(&dest->b, &src->b)) return 0;

+

+	dest->a_is_minus3 = src->a_is_minus3;

+

+	return 1;

+	}

+

+

+int ec_GFp_simple_group_set_curve(EC_GROUP *group,

+	const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)

+	{

+	int ret = 0;

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *tmp_a;

+	

+	/* p must be a prime > 3 */

+	if (BN_num_bits(p) <= 2 || !BN_is_odd(p))

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE, EC_R_INVALID_FIELD);

+		return 0;

+		}

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	tmp_a = BN_CTX_get(ctx);

+	if (tmp_a == NULL) goto err;

+

+	/* group->field */

+	if (!BN_copy(&group->field, p)) goto err;

+	BN_set_negative(&group->field, 0);

+

+	/* group->a */

+	if (!BN_nnmod(tmp_a, a, p, ctx)) goto err;

+	if (group->meth->field_encode)

+		{ if (!group->meth->field_encode(group, &group->a, tmp_a, ctx)) goto err; }	

+	else

+		if (!BN_copy(&group->a, tmp_a)) goto err;

+	

+	/* group->b */

+	if (!BN_nnmod(&group->b, b, p, ctx)) goto err;

+	if (group->meth->field_encode)

+		if (!group->meth->field_encode(group, &group->b, &group->b, ctx)) goto err;

+	

+	/* group->a_is_minus3 */

+	if (!BN_add_word(tmp_a, 3)) goto err;

+	group->a_is_minus3 = (0 == BN_cmp(tmp_a, &group->field));

+

+	ret = 1;

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_group_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)

+	{

+	int ret = 0;

+	BN_CTX *new_ctx = NULL;

+	

+	if (p != NULL)

+		{

+		if (!BN_copy(p, &group->field)) return 0;

+		}

+

+	if (a != NULL || b != NULL)

+		{

+		if (group->meth->field_decode)

+			{

+			if (ctx == NULL)

+				{

+				ctx = new_ctx = BN_CTX_new();

+				if (ctx == NULL)

+					return 0;

+				}

+			if (a != NULL)

+				{

+				if (!group->meth->field_decode(group, a, &group->a, ctx)) goto err;

+				}

+			if (b != NULL)

+				{

+				if (!group->meth->field_decode(group, b, &group->b, ctx)) goto err;

+				}

+			}

+		else

+			{

+			if (a != NULL)

+				{

+				if (!BN_copy(a, &group->a)) goto err;

+				}

+			if (b != NULL)

+				{

+				if (!BN_copy(b, &group->b)) goto err;

+				}

+			}

+		}

+	

+	ret = 1;

+	

+ err:

+	if (new_ctx)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_group_get_degree(const EC_GROUP *group)

+	{

+	return BN_num_bits(&group->field);

+	}

+

+

+int ec_GFp_simple_group_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)

+	{

+	int ret = 0;

+	BIGNUM *a,*b,*order,*tmp_1,*tmp_2;

+	const BIGNUM *p = &group->field;

+	BN_CTX *new_ctx = NULL;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT, ERR_R_MALLOC_FAILURE);

+			goto err;

+			}

+		}

+	BN_CTX_start(ctx);

+	a = BN_CTX_get(ctx);

+	b = BN_CTX_get(ctx);

+	tmp_1 = BN_CTX_get(ctx);

+	tmp_2 = BN_CTX_get(ctx);

+	order = BN_CTX_get(ctx);

+	if (order == NULL) goto err;

+

+	if (group->meth->field_decode)

+		{

+		if (!group->meth->field_decode(group, a, &group->a, ctx)) goto err;

+		if (!group->meth->field_decode(group, b, &group->b, ctx)) goto err;

+		}

+	else

+		{

+		if (!BN_copy(a, &group->a)) goto err;

+		if (!BN_copy(b, &group->b)) goto err;

+		}

+	

+	/* check the discriminant:

+	 * y^2 = x^3 + a*x + b is an elliptic curve <=> 4*a^3 + 27*b^2 != 0 (mod p) 

+         * 0 =< a, b < p */

+	if (BN_is_zero(a))

+		{

+		if (BN_is_zero(b)) goto err;

+		}

+	else if (!BN_is_zero(b))

+		{

+		if (!BN_mod_sqr(tmp_1, a, p, ctx)) goto err;

+		if (!BN_mod_mul(tmp_2, tmp_1, a, p, ctx)) goto err;

+		if (!BN_lshift(tmp_1, tmp_2, 2)) goto err;

+		/* tmp_1 = 4*a^3 */

+

+		if (!BN_mod_sqr(tmp_2, b, p, ctx)) goto err;

+		if (!BN_mul_word(tmp_2, 27)) goto err;

+		/* tmp_2 = 27*b^2 */

+

+		if (!BN_mod_add(a, tmp_1, tmp_2, p, ctx)) goto err;

+		if (BN_is_zero(a)) goto err;

+		}

+	ret = 1;

+

+err:

+	if (ctx != NULL)

+		BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_point_init(EC_POINT *point)

+	{

+	BN_init(&point->X);

+	BN_init(&point->Y);

+	BN_init(&point->Z);

+	point->Z_is_one = 0;

+

+	return 1;

+	}

+

+

+void ec_GFp_simple_point_finish(EC_POINT *point)

+	{

+	BN_free(&point->X);

+	BN_free(&point->Y);

+	BN_free(&point->Z);

+	}

+

+

+void ec_GFp_simple_point_clear_finish(EC_POINT *point)

+	{

+	BN_clear_free(&point->X);

+	BN_clear_free(&point->Y);

+	BN_clear_free(&point->Z);

+	point->Z_is_one = 0;

+	}

+

+

+int ec_GFp_simple_point_copy(EC_POINT *dest, const EC_POINT *src)

+	{

+	if (!BN_copy(&dest->X, &src->X)) return 0;

+	if (!BN_copy(&dest->Y, &src->Y)) return 0;

+	if (!BN_copy(&dest->Z, &src->Z)) return 0;

+	dest->Z_is_one = src->Z_is_one;

+

+	return 1;

+	}

+

+

+int ec_GFp_simple_point_set_to_infinity(const EC_GROUP *group, EC_POINT *point)

+	{

+	point->Z_is_one = 0;

+	BN_zero(&point->Z);

+	return 1;

+	}

+

+

+int ec_GFp_simple_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,

+	const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	int ret = 0;

+	

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	if (x != NULL)

+		{

+		if (!BN_nnmod(&point->X, x, &group->field, ctx)) goto err;

+		if (group->meth->field_encode)

+			{

+			if (!group->meth->field_encode(group, &point->X, &point->X, ctx)) goto err;

+			}

+		}

+	

+	if (y != NULL)

+		{

+		if (!BN_nnmod(&point->Y, y, &group->field, ctx)) goto err;

+		if (group->meth->field_encode)

+			{

+			if (!group->meth->field_encode(group, &point->Y, &point->Y, ctx)) goto err;

+			}

+		}

+	

+	if (z != NULL)

+		{

+		int Z_is_one;

+

+		if (!BN_nnmod(&point->Z, z, &group->field, ctx)) goto err;

+		Z_is_one = BN_is_one(&point->Z);

+		if (group->meth->field_encode)

+			{

+			if (Z_is_one && (group->meth->field_set_to_one != 0))

+				{

+				if (!group->meth->field_set_to_one(group, &point->Z, ctx)) goto err;

+				}

+			else

+				{

+				if (!group->meth->field_encode(group, &point->Z, &point->Z, ctx)) goto err;

+				}

+			}

+		point->Z_is_one = Z_is_one;

+		}

+	

+	ret = 1;

+	

+ err:

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,

+	BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	int ret = 0;

+	

+	if (group->meth->field_decode != 0)

+		{

+		if (ctx == NULL)

+			{

+			ctx = new_ctx = BN_CTX_new();

+			if (ctx == NULL)

+				return 0;

+			}

+

+		if (x != NULL)

+			{

+			if (!group->meth->field_decode(group, x, &point->X, ctx)) goto err;

+			}

+		if (y != NULL)

+			{

+			if (!group->meth->field_decode(group, y, &point->Y, ctx)) goto err;

+			}

+		if (z != NULL)

+			{

+			if (!group->meth->field_decode(group, z, &point->Z, ctx)) goto err;

+			}

+		}

+	else	

+		{

+		if (x != NULL)

+			{

+			if (!BN_copy(x, &point->X)) goto err;

+			}

+		if (y != NULL)

+			{

+			if (!BN_copy(y, &point->Y)) goto err;

+			}

+		if (z != NULL)

+			{

+			if (!BN_copy(z, &point->Z)) goto err;

+			}

+		}

+	

+	ret = 1;

+

+ err:

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_point_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,

+	const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)

+	{

+	if (x == NULL || y == NULL)

+		{

+		/* unlike for projective coordinates, we do not tolerate this */

+		ECerr(EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES, ERR_R_PASSED_NULL_PARAMETER);

+		return 0;

+		}

+

+	return EC_POINT_set_Jprojective_coordinates_GFp(group, point, x, y, BN_value_one(), ctx);

+	}

+

+

+int ec_GFp_simple_point_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,

+	BIGNUM *x, BIGNUM *y, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *Z, *Z_1, *Z_2, *Z_3;

+	const BIGNUM *Z_;

+	int ret = 0;

+

+	if (EC_POINT_is_at_infinity(group, point))

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES, EC_R_POINT_AT_INFINITY);

+		return 0;

+		}

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	Z = BN_CTX_get(ctx);

+	Z_1 = BN_CTX_get(ctx);

+	Z_2 = BN_CTX_get(ctx);

+	Z_3 = BN_CTX_get(ctx);

+	if (Z_3 == NULL) goto err;

+

+	/* transform  (X, Y, Z)  into  (x, y) := (X/Z^2, Y/Z^3) */

+	

+	if (group->meth->field_decode)

+		{

+		if (!group->meth->field_decode(group, Z, &point->Z, ctx)) goto err;

+		Z_ = Z;

+		}

+	else

+		{

+		Z_ = &point->Z;

+		}

+	

+	if (BN_is_one(Z_))

+		{

+		if (group->meth->field_decode)

+			{

+			if (x != NULL)

+				{

+				if (!group->meth->field_decode(group, x, &point->X, ctx)) goto err;

+				}

+			if (y != NULL)

+				{

+				if (!group->meth->field_decode(group, y, &point->Y, ctx)) goto err;

+				}

+			}

+		else

+			{

+			if (x != NULL)

+				{

+				if (!BN_copy(x, &point->X)) goto err;

+				}

+			if (y != NULL)

+				{

+				if (!BN_copy(y, &point->Y)) goto err;

+				}

+			}

+		}

+	else

+		{

+		if (!BN_mod_inverse(Z_1, Z_, &group->field, ctx))

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES, ERR_R_BN_LIB);

+			goto err;

+			}

+		

+		if (group->meth->field_encode == 0)

+			{

+			/* field_sqr works on standard representation */

+			if (!group->meth->field_sqr(group, Z_2, Z_1, ctx)) goto err;

+			}

+		else

+			{

+			if (!BN_mod_sqr(Z_2, Z_1, &group->field, ctx)) goto err;

+			}

+	

+		if (x != NULL)

+			{

+			/* in the Montgomery case, field_mul will cancel out Montgomery factor in X: */

+			if (!group->meth->field_mul(group, x, &point->X, Z_2, ctx)) goto err;

+			}

+

+		if (y != NULL)

+			{

+			if (group->meth->field_encode == 0)

+				{

+				/* field_mul works on standard representation */

+				if (!group->meth->field_mul(group, Z_3, Z_2, Z_1, ctx)) goto err;

+				}

+			else

+				{

+				if (!BN_mod_mul(Z_3, Z_2, Z_1, &group->field, ctx)) goto err;

+				}

+

+			/* in the Montgomery case, field_mul will cancel out Montgomery factor in Y: */

+			if (!group->meth->field_mul(group, y, &point->Y, Z_3, ctx)) goto err;

+			}

+		}

+

+	ret = 1;

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *point,

+	const BIGNUM *x_, int y_bit, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *tmp1, *tmp2, *x, *y;

+	int ret = 0;

+

+	/* clear error queue*/

+	ERR_clear_error();

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	y_bit = (y_bit != 0);

+

+	BN_CTX_start(ctx);

+	tmp1 = BN_CTX_get(ctx);

+	tmp2 = BN_CTX_get(ctx);

+	x = BN_CTX_get(ctx);

+	y = BN_CTX_get(ctx);

+	if (y == NULL) goto err;

+

+	/* Recover y.  We have a Weierstrass equation

+	 *     y^2 = x^3 + a*x + b,

+	 * so  y  is one of the square roots of  x^3 + a*x + b.

+	 */

+

+	/* tmp1 := x^3 */

+	if (!BN_nnmod(x, x_, &group->field,ctx)) goto err;

+	if (group->meth->field_decode == 0)

+		{

+		/* field_{sqr,mul} work on standard representation */

+		if (!group->meth->field_sqr(group, tmp2, x_, ctx)) goto err;

+		if (!group->meth->field_mul(group, tmp1, tmp2, x_, ctx)) goto err;

+		}

+	else

+		{

+		if (!BN_mod_sqr(tmp2, x_, &group->field, ctx)) goto err;

+		if (!BN_mod_mul(tmp1, tmp2, x_, &group->field, ctx)) goto err;

+		}

+	

+	/* tmp1 := tmp1 + a*x */

+	if (group->a_is_minus3)

+		{

+		if (!BN_mod_lshift1_quick(tmp2, x, &group->field)) goto err;

+		if (!BN_mod_add_quick(tmp2, tmp2, x, &group->field)) goto err;

+		if (!BN_mod_sub_quick(tmp1, tmp1, tmp2, &group->field)) goto err;

+		}

+	else

+		{

+		if (group->meth->field_decode)

+			{

+			if (!group->meth->field_decode(group, tmp2, &group->a, ctx)) goto err;

+			if (!BN_mod_mul(tmp2, tmp2, x, &group->field, ctx)) goto err;

+			}

+		else

+			{

+			/* field_mul works on standard representation */

+			if (!group->meth->field_mul(group, tmp2, &group->a, x, ctx)) goto err;

+			}

+		

+		if (!BN_mod_add_quick(tmp1, tmp1, tmp2, &group->field)) goto err;

+		}

+	

+	/* tmp1 := tmp1 + b */

+	if (group->meth->field_decode)

+		{

+		if (!group->meth->field_decode(group, tmp2, &group->b, ctx)) goto err;

+		if (!BN_mod_add_quick(tmp1, tmp1, tmp2, &group->field)) goto err;

+		}

+	else

+		{

+		if (!BN_mod_add_quick(tmp1, tmp1, &group->b, &group->field)) goto err;

+		}

+	

+	if (!BN_mod_sqrt(y, tmp1, &group->field, ctx))

+		{

+		unsigned long err = ERR_peek_last_error();

+		

+		if (ERR_GET_LIB(err) == ERR_LIB_BN && ERR_GET_REASON(err) == BN_R_NOT_A_SQUARE)

+			{

+			ERR_clear_error();

+			ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSED_POINT);

+			}

+		else

+			ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, ERR_R_BN_LIB);

+		goto err;

+		}

+

+	if (y_bit != BN_is_odd(y))

+		{

+		if (BN_is_zero(y))

+			{

+			int kron;

+

+			kron = BN_kronecker(x, &group->field, ctx);

+			if (kron == -2) goto err;

+

+			if (kron == 1)

+				ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSION_BIT);

+			else

+				/* BN_mod_sqrt() should have cought this error (not a square) */

+				ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, EC_R_INVALID_COMPRESSED_POINT);

+			goto err;

+			}

+		if (!BN_usub(y, &group->field, y)) goto err;

+		}

+	if (y_bit != BN_is_odd(y))

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES, ERR_R_INTERNAL_ERROR);

+		goto err;

+		}

+

+	if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;

+

+	ret = 1;

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+size_t ec_GFp_simple_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,

+	unsigned char *buf, size_t len, BN_CTX *ctx)

+	{

+	size_t ret;

+	BN_CTX *new_ctx = NULL;

+	int used_ctx = 0;

+	BIGNUM *x, *y;

+	size_t field_len, i, skip;

+

+	if ((form != POINT_CONVERSION_COMPRESSED)

+		&& (form != POINT_CONVERSION_UNCOMPRESSED)

+		&& (form != POINT_CONVERSION_HYBRID))

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, EC_R_INVALID_FORM);

+		goto err;

+		}

+

+	if (EC_POINT_is_at_infinity(group, point))

+		{

+		/* encodes to a single 0 octet */

+		if (buf != NULL)

+			{

+			if (len < 1)

+				{

+				ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);

+				return 0;

+				}

+			buf[0] = 0;

+			}

+		return 1;

+		}

+

+

+	/* ret := required output buffer length */

+	field_len = BN_num_bytes(&group->field);

+	ret = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;

+

+	/* if 'buf' is NULL, just return required length */

+	if (buf != NULL)

+		{

+		if (len < ret)

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL);

+			goto err;

+			}

+

+		if (ctx == NULL)

+			{

+			ctx = new_ctx = BN_CTX_new();

+			if (ctx == NULL)

+				return 0;

+			}

+

+		BN_CTX_start(ctx);

+		used_ctx = 1;

+		x = BN_CTX_get(ctx);

+		y = BN_CTX_get(ctx);

+		if (y == NULL) goto err;

+

+		if (!EC_POINT_get_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;

+

+		if ((form == POINT_CONVERSION_COMPRESSED || form == POINT_CONVERSION_HYBRID) && BN_is_odd(y))

+			buf[0] = form + 1;

+		else

+			buf[0] = form;

+	

+		i = 1;

+		

+		skip = field_len - BN_num_bytes(x);

+		if (skip > field_len)

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+			goto err;

+			}

+		while (skip > 0)

+			{

+			buf[i++] = 0;

+			skip--;

+			}

+		skip = BN_bn2bin(x, buf + i);

+		i += skip;

+		if (i != 1 + field_len)

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+			goto err;

+			}

+

+		if (form == POINT_CONVERSION_UNCOMPRESSED || form == POINT_CONVERSION_HYBRID)

+			{

+			skip = field_len - BN_num_bytes(y);

+			if (skip > field_len)

+				{

+				ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+				goto err;

+				}

+			while (skip > 0)

+				{

+				buf[i++] = 0;

+				skip--;

+				}

+			skip = BN_bn2bin(y, buf + i);

+			i += skip;

+			}

+

+		if (i != ret)

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, ERR_R_INTERNAL_ERROR);

+			goto err;

+			}

+		}

+	

+	if (used_ctx)

+		BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+

+ err:

+	if (used_ctx)

+		BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return 0;

+	}

+

+

+int ec_GFp_simple_oct2point(const EC_GROUP *group, EC_POINT *point,

+	const unsigned char *buf, size_t len, BN_CTX *ctx)

+	{

+	point_conversion_form_t form;

+	int y_bit;

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *x, *y;

+	size_t field_len, enc_len;

+	int ret = 0;

+

+	if (len == 0)

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_BUFFER_TOO_SMALL);

+		return 0;

+		}

+	form = buf[0];

+	y_bit = form & 1;

+	form = form & ~1U;

+	if ((form != 0)	&& (form != POINT_CONVERSION_COMPRESSED)

+		&& (form != POINT_CONVERSION_UNCOMPRESSED)

+		&& (form != POINT_CONVERSION_HYBRID))

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		return 0;

+		}

+	if ((form == 0 || form == POINT_CONVERSION_UNCOMPRESSED) && y_bit)

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		return 0;

+		}

+

+	if (form == 0)

+		{

+		if (len != 1)

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+			return 0;

+			}

+

+		return EC_POINT_set_to_infinity(group, point);

+		}

+	

+	field_len = BN_num_bytes(&group->field);

+	enc_len = (form == POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2*field_len;

+

+	if (len != enc_len)

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		return 0;

+		}

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	x = BN_CTX_get(ctx);

+	y = BN_CTX_get(ctx);

+	if (y == NULL) goto err;

+

+	if (!BN_bin2bn(buf + 1, field_len, x)) goto err;

+	if (BN_ucmp(x, &group->field) >= 0)

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+		goto err;

+		}

+

+	if (form == POINT_CONVERSION_COMPRESSED)

+		{

+		if (!EC_POINT_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx)) goto err;

+		}

+	else

+		{

+		if (!BN_bin2bn(buf + 1 + field_len, field_len, y)) goto err;

+		if (BN_ucmp(y, &group->field) >= 0)

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+			goto err;

+			}

+		if (form == POINT_CONVERSION_HYBRID)

+			{

+			if (y_bit != BN_is_odd(y))

+				{

+				ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_INVALID_ENCODING);

+				goto err;

+				}

+			}

+

+		if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;

+		}

+	

+	if (!EC_POINT_is_on_curve(group, point, ctx)) /* test required by X9.62 */

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_OCT2POINT, EC_R_POINT_IS_NOT_ON_CURVE);

+		goto err;

+		}

+

+	ret = 1;

+	

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)

+	{

+	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);

+	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);

+	const BIGNUM *p;

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *n0, *n1, *n2, *n3, *n4, *n5, *n6;

+	int ret = 0;

+	

+	if (a == b)

+		return EC_POINT_dbl(group, r, a, ctx);

+	if (EC_POINT_is_at_infinity(group, a))

+		return EC_POINT_copy(r, b);

+	if (EC_POINT_is_at_infinity(group, b))

+		return EC_POINT_copy(r, a);

+	

+	field_mul = group->meth->field_mul;

+	field_sqr = group->meth->field_sqr;

+	p = &group->field;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	n0 = BN_CTX_get(ctx);

+	n1 = BN_CTX_get(ctx);

+	n2 = BN_CTX_get(ctx);

+	n3 = BN_CTX_get(ctx);

+	n4 = BN_CTX_get(ctx);

+	n5 = BN_CTX_get(ctx);

+	n6 = BN_CTX_get(ctx);

+	if (n6 == NULL) goto end;

+

+	/* Note that in this function we must not read components of 'a' or 'b'

+	 * once we have written the corresponding components of 'r'.

+	 * ('r' might be one of 'a' or 'b'.)

+	 */

+

+	/* n1, n2 */

+	if (b->Z_is_one)

+		{

+		if (!BN_copy(n1, &a->X)) goto end;

+		if (!BN_copy(n2, &a->Y)) goto end;

+		/* n1 = X_a */

+		/* n2 = Y_a */

+		}

+	else

+		{

+		if (!field_sqr(group, n0, &b->Z, ctx)) goto end;

+		if (!field_mul(group, n1, &a->X, n0, ctx)) goto end;

+		/* n1 = X_a * Z_b^2 */

+

+		if (!field_mul(group, n0, n0, &b->Z, ctx)) goto end;

+		if (!field_mul(group, n2, &a->Y, n0, ctx)) goto end;

+		/* n2 = Y_a * Z_b^3 */

+		}

+

+	/* n3, n4 */

+	if (a->Z_is_one)

+		{

+		if (!BN_copy(n3, &b->X)) goto end;

+		if (!BN_copy(n4, &b->Y)) goto end;

+		/* n3 = X_b */

+		/* n4 = Y_b */

+		}

+	else

+		{

+		if (!field_sqr(group, n0, &a->Z, ctx)) goto end;

+		if (!field_mul(group, n3, &b->X, n0, ctx)) goto end;

+		/* n3 = X_b * Z_a^2 */

+

+		if (!field_mul(group, n0, n0, &a->Z, ctx)) goto end;

+		if (!field_mul(group, n4, &b->Y, n0, ctx)) goto end;

+		/* n4 = Y_b * Z_a^3 */

+		}

+

+	/* n5, n6 */

+	if (!BN_mod_sub_quick(n5, n1, n3, p)) goto end;

+	if (!BN_mod_sub_quick(n6, n2, n4, p)) goto end;

+	/* n5 = n1 - n3 */

+	/* n6 = n2 - n4 */

+

+	if (BN_is_zero(n5))

+		{

+		if (BN_is_zero(n6))

+			{

+			/* a is the same point as b */

+			BN_CTX_end(ctx);

+			ret = EC_POINT_dbl(group, r, a, ctx);

+			ctx = NULL;

+			goto end;

+			}

+		else

+			{

+			/* a is the inverse of b */

+			BN_zero(&r->Z);

+			r->Z_is_one = 0;

+			ret = 1;

+			goto end;

+			}

+		}

+

+	/* 'n7', 'n8' */

+	if (!BN_mod_add_quick(n1, n1, n3, p)) goto end;

+	if (!BN_mod_add_quick(n2, n2, n4, p)) goto end;

+	/* 'n7' = n1 + n3 */

+	/* 'n8' = n2 + n4 */

+

+	/* Z_r */

+	if (a->Z_is_one && b->Z_is_one)

+		{

+		if (!BN_copy(&r->Z, n5)) goto end;

+		}

+	else

+		{

+		if (a->Z_is_one)

+			{ if (!BN_copy(n0, &b->Z)) goto end; }

+		else if (b->Z_is_one)

+			{ if (!BN_copy(n0, &a->Z)) goto end; }

+		else

+			{ if (!field_mul(group, n0, &a->Z, &b->Z, ctx)) goto end; }

+		if (!field_mul(group, &r->Z, n0, n5, ctx)) goto end;

+		}

+	r->Z_is_one = 0;

+	/* Z_r = Z_a * Z_b * n5 */

+

+	/* X_r */

+	if (!field_sqr(group, n0, n6, ctx)) goto end;

+	if (!field_sqr(group, n4, n5, ctx)) goto end;

+	if (!field_mul(group, n3, n1, n4, ctx)) goto end;

+	if (!BN_mod_sub_quick(&r->X, n0, n3, p)) goto end;

+	/* X_r = n6^2 - n5^2 * 'n7' */

+	

+	/* 'n9' */

+	if (!BN_mod_lshift1_quick(n0, &r->X, p)) goto end;

+	if (!BN_mod_sub_quick(n0, n3, n0, p)) goto end;

+	/* n9 = n5^2 * 'n7' - 2 * X_r */

+

+	/* Y_r */

+	if (!field_mul(group, n0, n0, n6, ctx)) goto end;

+	if (!field_mul(group, n5, n4, n5, ctx)) goto end; /* now n5 is n5^3 */

+	if (!field_mul(group, n1, n2, n5, ctx)) goto end;

+	if (!BN_mod_sub_quick(n0, n0, n1, p)) goto end;

+	if (BN_is_odd(n0))

+		if (!BN_add(n0, n0, p)) goto end;

+	/* now  0 <= n0 < 2*p,  and n0 is even */

+	if (!BN_rshift1(&r->Y, n0)) goto end;

+	/* Y_r = (n6 * 'n9' - 'n8' * 'n5^3') / 2 */

+

+	ret = 1;

+

+ end:

+	if (ctx) /* otherwise we already called BN_CTX_end */

+		BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)

+	{

+	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);

+	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);

+	const BIGNUM *p;

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *n0, *n1, *n2, *n3;

+	int ret = 0;

+	

+	if (EC_POINT_is_at_infinity(group, a))

+		{

+		BN_zero(&r->Z);

+		r->Z_is_one = 0;

+		return 1;

+		}

+

+	field_mul = group->meth->field_mul;

+	field_sqr = group->meth->field_sqr;

+	p = &group->field;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	n0 = BN_CTX_get(ctx);

+	n1 = BN_CTX_get(ctx);

+	n2 = BN_CTX_get(ctx);

+	n3 = BN_CTX_get(ctx);

+	if (n3 == NULL) goto err;

+

+	/* Note that in this function we must not read components of 'a'

+	 * once we have written the corresponding components of 'r'.

+	 * ('r' might the same as 'a'.)

+	 */

+

+	/* n1 */

+	if (a->Z_is_one)

+		{

+		if (!field_sqr(group, n0, &a->X, ctx)) goto err;

+		if (!BN_mod_lshift1_quick(n1, n0, p)) goto err;

+		if (!BN_mod_add_quick(n0, n0, n1, p)) goto err;

+		if (!BN_mod_add_quick(n1, n0, &group->a, p)) goto err;

+		/* n1 = 3 * X_a^2 + a_curve */

+		}

+	else if (group->a_is_minus3)

+		{

+		if (!field_sqr(group, n1, &a->Z, ctx)) goto err;

+		if (!BN_mod_add_quick(n0, &a->X, n1, p)) goto err;

+		if (!BN_mod_sub_quick(n2, &a->X, n1, p)) goto err;

+		if (!field_mul(group, n1, n0, n2, ctx)) goto err;

+		if (!BN_mod_lshift1_quick(n0, n1, p)) goto err;

+		if (!BN_mod_add_quick(n1, n0, n1, p)) goto err;

+		/* n1 = 3 * (X_a + Z_a^2) * (X_a - Z_a^2)

+		 *    = 3 * X_a^2 - 3 * Z_a^4 */

+		}

+	else

+		{

+		if (!field_sqr(group, n0, &a->X, ctx)) goto err;

+		if (!BN_mod_lshift1_quick(n1, n0, p)) goto err;

+		if (!BN_mod_add_quick(n0, n0, n1, p)) goto err;

+		if (!field_sqr(group, n1, &a->Z, ctx)) goto err;

+		if (!field_sqr(group, n1, n1, ctx)) goto err;

+		if (!field_mul(group, n1, n1, &group->a, ctx)) goto err;

+		if (!BN_mod_add_quick(n1, n1, n0, p)) goto err;

+		/* n1 = 3 * X_a^2 + a_curve * Z_a^4 */

+		}

+

+	/* Z_r */

+	if (a->Z_is_one)

+		{

+		if (!BN_copy(n0, &a->Y)) goto err;

+		}

+	else

+		{

+		if (!field_mul(group, n0, &a->Y, &a->Z, ctx)) goto err;

+		}

+	if (!BN_mod_lshift1_quick(&r->Z, n0, p)) goto err;

+	r->Z_is_one = 0;

+	/* Z_r = 2 * Y_a * Z_a */

+

+	/* n2 */

+	if (!field_sqr(group, n3, &a->Y, ctx)) goto err;

+	if (!field_mul(group, n2, &a->X, n3, ctx)) goto err;

+	if (!BN_mod_lshift_quick(n2, n2, 2, p)) goto err;

+	/* n2 = 4 * X_a * Y_a^2 */

+

+	/* X_r */

+	if (!BN_mod_lshift1_quick(n0, n2, p)) goto err;

+	if (!field_sqr(group, &r->X, n1, ctx)) goto err;

+	if (!BN_mod_sub_quick(&r->X, &r->X, n0, p)) goto err;

+	/* X_r = n1^2 - 2 * n2 */

+	

+	/* n3 */

+	if (!field_sqr(group, n0, n3, ctx)) goto err;

+	if (!BN_mod_lshift_quick(n3, n0, 3, p)) goto err;

+	/* n3 = 8 * Y_a^4 */

+	

+	/* Y_r */

+	if (!BN_mod_sub_quick(n0, n2, &r->X, p)) goto err;

+	if (!field_mul(group, n0, n1, n0, ctx)) goto err;

+	if (!BN_mod_sub_quick(&r->Y, n0, n3, p)) goto err;

+	/* Y_r = n1 * (n2 - X_r) - n3 */

+

+	ret = 1;

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_invert(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)

+	{

+	if (EC_POINT_is_at_infinity(group, point) || BN_is_zero(&point->Y))

+		/* point is its own inverse */

+		return 1;

+	

+	return BN_usub(&point->Y, &group->field, &point->Y);

+	}

+

+

+int ec_GFp_simple_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)

+	{

+	return BN_is_zero(&point->Z);

+	}

+

+

+int ec_GFp_simple_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)

+	{

+	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);

+	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);

+	const BIGNUM *p;

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *rh, *tmp, *Z4, *Z6;

+	int ret = -1;

+

+	if (EC_POINT_is_at_infinity(group, point))

+		return 1;

+	

+	field_mul = group->meth->field_mul;

+	field_sqr = group->meth->field_sqr;

+	p = &group->field;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return -1;

+		}

+

+	BN_CTX_start(ctx);

+	rh = BN_CTX_get(ctx);

+	tmp = BN_CTX_get(ctx);

+	Z4 = BN_CTX_get(ctx);

+	Z6 = BN_CTX_get(ctx);

+	if (Z6 == NULL) goto err;

+

+	/* We have a curve defined by a Weierstrass equation

+	 *      y^2 = x^3 + a*x + b.

+	 * The point to consider is given in Jacobian projective coordinates

+	 * where  (X, Y, Z)  represents  (x, y) = (X/Z^2, Y/Z^3).

+	 * Substituting this and multiplying by  Z^6  transforms the above equation into

+	 *      Y^2 = X^3 + a*X*Z^4 + b*Z^6.

+	 * To test this, we add up the right-hand side in 'rh'.

+	 */

+

+	/* rh := X^2 */

+	if (!field_sqr(group, rh, &point->X, ctx)) goto err;

+

+	if (!point->Z_is_one)

+		{

+		if (!field_sqr(group, tmp, &point->Z, ctx)) goto err;

+		if (!field_sqr(group, Z4, tmp, ctx)) goto err;

+		if (!field_mul(group, Z6, Z4, tmp, ctx)) goto err;

+

+		/* rh := (rh + a*Z^4)*X */

+		if (group->a_is_minus3)

+			{

+			if (!BN_mod_lshift1_quick(tmp, Z4, p)) goto err;

+			if (!BN_mod_add_quick(tmp, tmp, Z4, p)) goto err;

+			if (!BN_mod_sub_quick(rh, rh, tmp, p)) goto err;

+			if (!field_mul(group, rh, rh, &point->X, ctx)) goto err;

+			}

+		else

+			{

+			if (!field_mul(group, tmp, Z4, &group->a, ctx)) goto err;

+			if (!BN_mod_add_quick(rh, rh, tmp, p)) goto err;

+			if (!field_mul(group, rh, rh, &point->X, ctx)) goto err;

+			}

+

+		/* rh := rh + b*Z^6 */

+		if (!field_mul(group, tmp, &group->b, Z6, ctx)) goto err;

+		if (!BN_mod_add_quick(rh, rh, tmp, p)) goto err;

+		}

+	else

+		{

+		/* point->Z_is_one */

+

+		/* rh := (rh + a)*X */

+		if (!BN_mod_add_quick(rh, rh, &group->a, p)) goto err;

+		if (!field_mul(group, rh, rh, &point->X, ctx)) goto err;

+		/* rh := rh + b */

+		if (!BN_mod_add_quick(rh, rh, &group->b, p)) goto err;

+		}

+

+	/* 'lh' := Y^2 */

+	if (!field_sqr(group, tmp, &point->Y, ctx)) goto err;

+

+	ret = (0 == BN_ucmp(tmp, rh));

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)

+	{

+	/* return values:

+	 *  -1   error

+	 *   0   equal (in affine coordinates)

+	 *   1   not equal

+	 */

+

+	int (*field_mul)(const EC_GROUP *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *);

+	int (*field_sqr)(const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *tmp1, *tmp2, *Za23, *Zb23;

+	const BIGNUM *tmp1_, *tmp2_;

+	int ret = -1;

+	

+	if (EC_POINT_is_at_infinity(group, a))

+		{

+		return EC_POINT_is_at_infinity(group, b) ? 0 : 1;

+		}

+

+	if (EC_POINT_is_at_infinity(group, b))

+		return 1;

+	

+	if (a->Z_is_one && b->Z_is_one)

+		{

+		return ((BN_cmp(&a->X, &b->X) == 0) && BN_cmp(&a->Y, &b->Y) == 0) ? 0 : 1;

+		}

+

+	field_mul = group->meth->field_mul;

+	field_sqr = group->meth->field_sqr;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return -1;

+		}

+

+	BN_CTX_start(ctx);

+	tmp1 = BN_CTX_get(ctx);

+	tmp2 = BN_CTX_get(ctx);

+	Za23 = BN_CTX_get(ctx);

+	Zb23 = BN_CTX_get(ctx);

+	if (Zb23 == NULL) goto end;

+

+	/* We have to decide whether

+	 *     (X_a/Z_a^2, Y_a/Z_a^3) = (X_b/Z_b^2, Y_b/Z_b^3),

+	 * or equivalently, whether

+	 *     (X_a*Z_b^2, Y_a*Z_b^3) = (X_b*Z_a^2, Y_b*Z_a^3).

+	 */

+

+	if (!b->Z_is_one)

+		{

+		if (!field_sqr(group, Zb23, &b->Z, ctx)) goto end;

+		if (!field_mul(group, tmp1, &a->X, Zb23, ctx)) goto end;

+		tmp1_ = tmp1;

+		}

+	else

+		tmp1_ = &a->X;

+	if (!a->Z_is_one)

+		{

+		if (!field_sqr(group, Za23, &a->Z, ctx)) goto end;

+		if (!field_mul(group, tmp2, &b->X, Za23, ctx)) goto end;

+		tmp2_ = tmp2;

+		}

+	else

+		tmp2_ = &b->X;

+	

+	/* compare  X_a*Z_b^2  with  X_b*Z_a^2 */

+	if (BN_cmp(tmp1_, tmp2_) != 0)

+		{

+		ret = 1; /* points differ */

+		goto end;

+		}

+

+

+	if (!b->Z_is_one)

+		{

+		if (!field_mul(group, Zb23, Zb23, &b->Z, ctx)) goto end;

+		if (!field_mul(group, tmp1, &a->Y, Zb23, ctx)) goto end;

+		/* tmp1_ = tmp1 */

+		}

+	else

+		tmp1_ = &a->Y;

+	if (!a->Z_is_one)

+		{

+		if (!field_mul(group, Za23, Za23, &a->Z, ctx)) goto end;

+		if (!field_mul(group, tmp2, &b->Y, Za23, ctx)) goto end;

+		/* tmp2_ = tmp2 */

+		}

+	else

+		tmp2_ = &b->Y;

+

+	/* compare  Y_a*Z_b^3  with  Y_b*Z_a^3 */

+	if (BN_cmp(tmp1_, tmp2_) != 0)

+		{

+		ret = 1; /* points differ */

+		goto end;

+		}

+

+	/* points are equal */

+	ret = 0;

+

+ end:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *x, *y;

+	int ret = 0;

+

+	if (point->Z_is_one || EC_POINT_is_at_infinity(group, point))

+		return 1;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	x = BN_CTX_get(ctx);

+	y = BN_CTX_get(ctx);

+	if (y == NULL) goto err;

+

+	if (!EC_POINT_get_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;

+	if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, ctx)) goto err;

+	if (!point->Z_is_one)

+		{

+		ECerr(EC_F_EC_GFP_SIMPLE_MAKE_AFFINE, ERR_R_INTERNAL_ERROR);

+		goto err;

+		}

+	

+	ret = 1;

+

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	return ret;

+	}

+

+

+int ec_GFp_simple_points_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)

+	{

+	BN_CTX *new_ctx = NULL;

+	BIGNUM *tmp0, *tmp1;

+	size_t pow2 = 0;

+	BIGNUM **heap = NULL;

+	size_t i;

+	int ret = 0;

+

+	if (num == 0)

+		return 1;

+

+	if (ctx == NULL)

+		{

+		ctx = new_ctx = BN_CTX_new();

+		if (ctx == NULL)

+			return 0;

+		}

+

+	BN_CTX_start(ctx);

+	tmp0 = BN_CTX_get(ctx);

+	tmp1 = BN_CTX_get(ctx);

+	if (tmp0  == NULL || tmp1 == NULL) goto err;

+

+	/* Before converting the individual points, compute inverses of all Z values.

+	 * Modular inversion is rather slow, but luckily we can do with a single

+	 * explicit inversion, plus about 3 multiplications per input value.

+	 */

+

+	pow2 = 1;

+	while (num > pow2)

+		pow2 <<= 1;

+	/* Now pow2 is the smallest power of 2 satifsying pow2 >= num.

+	 * We need twice that. */

+	pow2 <<= 1;

+

+	heap = OPENSSL_malloc(pow2 * sizeof heap[0]);

+	if (heap == NULL) goto err;

+	

+	/* The array is used as a binary tree, exactly as in heapsort:

+	 *

+	 *                               heap[1]

+	 *                 heap[2]                     heap[3]

+	 *          heap[4]       heap[5]       heap[6]       heap[7]

+	 *   heap[8]heap[9] heap[10]heap[11] heap[12]heap[13] heap[14] heap[15]

+	 *

+	 * We put the Z's in the last line;

+	 * then we set each other node to the product of its two child-nodes (where

+	 * empty or 0 entries are treated as ones);

+	 * then we invert heap[1];

+	 * then we invert each other node by replacing it by the product of its

+	 * parent (after inversion) and its sibling (before inversion).

+	 */

+	heap[0] = NULL;

+	for (i = pow2/2 - 1; i > 0; i--)

+		heap[i] = NULL;

+	for (i = 0; i < num; i++)

+		heap[pow2/2 + i] = &points[i]->Z;

+	for (i = pow2/2 + num; i < pow2; i++)

+		heap[i] = NULL;

+	

+	/* set each node to the product of its children */

+	for (i = pow2/2 - 1; i > 0; i--)

+		{

+		heap[i] = BN_new();

+		if (heap[i] == NULL) goto err;

+		

+		if (heap[2*i] != NULL)

+			{

+			if ((heap[2*i + 1] == NULL) || BN_is_zero(heap[2*i + 1]))

+				{

+				if (!BN_copy(heap[i], heap[2*i])) goto err;

+				}

+			else

+				{

+				if (BN_is_zero(heap[2*i]))

+					{

+					if (!BN_copy(heap[i], heap[2*i + 1])) goto err;

+					}

+				else

+					{

+					if (!group->meth->field_mul(group, heap[i],

+						heap[2*i], heap[2*i + 1], ctx)) goto err;

+					}

+				}

+			}

+		}

+

+	/* invert heap[1] */

+	if (!BN_is_zero(heap[1]))

+		{

+		if (!BN_mod_inverse(heap[1], heap[1], &group->field, ctx))

+			{

+			ECerr(EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE, ERR_R_BN_LIB);

+			goto err;

+			}

+		}

+	if (group->meth->field_encode != 0)

+		{

+		/* in the Montgomery case, we just turned  R*H  (representing H)

+		 * into  1/(R*H),  but we need  R*(1/H)  (representing 1/H);

+		 * i.e. we have need to multiply by the Montgomery factor twice */

+		if (!group->meth->field_encode(group, heap[1], heap[1], ctx)) goto err;

+		if (!group->meth->field_encode(group, heap[1], heap[1], ctx)) goto err;

+		}

+

+	/* set other heap[i]'s to their inverses */

+	for (i = 2; i < pow2/2 + num; i += 2)

+		{

+		/* i is even */

+		if ((heap[i + 1] != NULL) && !BN_is_zero(heap[i + 1]))

+			{

+			if (!group->meth->field_mul(group, tmp0, heap[i/2], heap[i + 1], ctx)) goto err;

+			if (!group->meth->field_mul(group, tmp1, heap[i/2], heap[i], ctx)) goto err;

+			if (!BN_copy(heap[i], tmp0)) goto err;

+			if (!BN_copy(heap[i + 1], tmp1)) goto err;

+			}

+		else

+			{

+			if (!BN_copy(heap[i], heap[i/2])) goto err;

+			}

+		}

+

+	/* we have replaced all non-zero Z's by their inverses, now fix up all the points */

+	for (i = 0; i < num; i++)

+		{

+		EC_POINT *p = points[i];

+		

+		if (!BN_is_zero(&p->Z))

+			{

+			/* turn  (X, Y, 1/Z)  into  (X/Z^2, Y/Z^3, 1) */

+

+			if (!group->meth->field_sqr(group, tmp1, &p->Z, ctx)) goto err;

+			if (!group->meth->field_mul(group, &p->X, &p->X, tmp1, ctx)) goto err;

+

+			if (!group->meth->field_mul(group, tmp1, tmp1, &p->Z, ctx)) goto err;

+			if (!group->meth->field_mul(group, &p->Y, &p->Y, tmp1, ctx)) goto err;

+		

+			if (group->meth->field_set_to_one != 0)

+				{

+				if (!group->meth->field_set_to_one(group, &p->Z, ctx)) goto err;

+				}

+			else

+				{

+				if (!BN_one(&p->Z)) goto err;

+				}

+			p->Z_is_one = 1;

+			}

+		}

+

+	ret = 1;

+		

+ err:

+	BN_CTX_end(ctx);

+	if (new_ctx != NULL)

+		BN_CTX_free(new_ctx);

+	if (heap != NULL)

+		{

+		/* heap[pow2/2] .. heap[pow2-1] have not been allocated locally! */

+		for (i = pow2/2 - 1; i > 0; i--)

+			{

+			if (heap[i] != NULL)

+				BN_clear_free(heap[i]);

+			}

+		OPENSSL_free(heap);

+		}

+	return ret;

+	}

+

+

+int ec_GFp_simple_field_mul(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)

+	{

+	return BN_mod_mul(r, a, b, &group->field, ctx);

+	}

+

+

+int ec_GFp_simple_field_sqr(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)

+	{

+	return BN_mod_sqr(r, a, &group->field, ctx);

+	}