[thirdparty/openssl.git] / crypto / ecdsa / ecdsatest.c

/* crypto/ecdsa/ecdsatest.c */
/*
 * Written by Nils Larsch for the OpenSSL project.
 */
/* ====================================================================
 * Copyright (c) 2000-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
 *    licensing@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 the attached software ("Contribution") are developed by 
 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
 *
 * The Contribution is licensed pursuant to the OpenSSL open source
 * license provided above.
 *
 * The elliptic curve binary polynomial software is originally written by 
 * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <openssl/opensslconf.h> /* To see if OPENSSL_NO_ECDSA is defined */

#ifdef OPENSSL_NO_ECDSA
int main(int argc, char * argv[])
	{
	puts("Elliptic curves are disabled.");
	return 0;
	}
#else

#include <openssl/crypto.h>
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/bn.h>
#include <openssl/ecdsa.h>
#ifndef OPENSSL_NO_ENGINE
#include <openssl/engine.h>
#endif
#include <openssl/err.h>
#include <openssl/rand.h>

static const char rnd_seed[] = "string to make the random number generator "
	"think it has entropy";

/* declaration of the test functions */
int x9_62_tests(BIO *);
int x9_62_test_internal(BIO *out, int nid, const char *r, const char *s);
int test_builtin(BIO *);

/* functions to change the RAND_METHOD */
int change_rand(void);
int restore_rand(void);
int fbytes(unsigned char *buf, int num);

RAND_METHOD	fake_rand;
const RAND_METHOD *old_rand;

int change_rand(void)
	{
	/* save old rand method */
	if ((old_rand = RAND_get_rand_method()) == NULL)
		return 0;

	fake_rand.seed    = old_rand->seed;
	fake_rand.cleanup = old_rand->cleanup;
	fake_rand.add     = old_rand->add;
	fake_rand.status  = old_rand->status;
	/* use own random function */
	fake_rand.bytes      = fbytes;
	fake_rand.pseudorand = old_rand->bytes;
	/* set new RAND_METHOD */
	if (!RAND_set_rand_method(&fake_rand))
		return 0;
	return 1;
	}

int restore_rand(void)
	{
	if (!RAND_set_rand_method(old_rand))
		return 0;
	else
		return 1;
	}

static int fbytes_counter = 0;
static const char *numbers[8] = {
	"651056770906015076056810763456358567190100156695615665659",
	"6140507067065001063065065565667405560006161556565665656654",
	"8763001015071075675010661307616710783570106710677817767166"
	"71676178726717",
	"7000000175690566466555057817571571075705015757757057795755"
	"55657156756655",
	"1275552191113212300012030439187146164646146646466749494799",
	"1542725565216523985789236956265265265235675811949404040041",
	"1456427555219115346513212300075341203043918714616464614664"
	"64667494947990",
	"1712787255652165239672857892369562652652652356758119494040"
	"40041670216363"};

int fbytes(unsigned char *buf, int num)
	{
	int	ret;
	BIGNUM	*tmp = NULL;

	if (fbytes_counter >= 8)
		return 0;
	tmp = BN_new();
	if (!tmp)
		return 0;
	if (!BN_dec2bn(&tmp, numbers[fbytes_counter]))
		{
		BN_free(tmp);
		return 0;
		}
	fbytes_counter ++;
	ret = BN_bn2bin(tmp, buf);	
	if (ret == 0 || ret != num)
		ret = 0;
	else
		ret = 1;
	if (tmp)
		BN_free(tmp);
	return ret;
	}

/* some tests from the X9.62 draft */
int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in)
	{
	int	ret = 0;
	const char message[] = "abc";
	unsigned char digest[20];
	unsigned int  dgst_len = 0;
	EVP_MD_CTX md_ctx;
	EC_KEY    *key = NULL;
	ECDSA_SIG *signature = NULL;
	BIGNUM    *r = NULL, *s = NULL;

	EVP_MD_CTX_init(&md_ctx);
	/* get the message digest */
	EVP_DigestInit(&md_ctx, EVP_ecdsa());
	EVP_DigestUpdate(&md_ctx, (const void*)message, 3);
	EVP_DigestFinal(&md_ctx, digest, &dgst_len);

	BIO_printf(out, "testing %s: ", OBJ_nid2sn(nid));
	/* create the key */
	if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)
		goto x962_int_err;
	if (!EC_KEY_generate_key(key))
		goto x962_int_err;
	BIO_printf(out, ".");
	(void)BIO_flush(out);
	/* create the signature */
	signature = ECDSA_do_sign(digest, 20, key);
	if (signature == NULL)
		goto x962_int_err;
	BIO_printf(out, ".");
	(void)BIO_flush(out);
	/* compare the created signature with the expected signature */
	if ((r = BN_new()) == NULL || (s = BN_new()) == NULL)
		goto x962_int_err;
	if (!BN_dec2bn(&r, r_in) ||
	    !BN_dec2bn(&s, s_in))
		goto x962_int_err;
	if (BN_cmp(signature->r ,r) || BN_cmp(signature->s, s))
		goto x962_int_err;
	BIO_printf(out, ".");
	(void)BIO_flush(out);
	/* verify the signature */
	if (ECDSA_do_verify(digest, 20, signature, key) != 1)
		goto x962_int_err;
	BIO_printf(out, ".");
	(void)BIO_flush(out);

	BIO_printf(out, " ok\n");
	ret = 1;
x962_int_err:
	if (!ret)
		BIO_printf(out, " failed\n");
	if (key)
		EC_KEY_free(key);
	if (signature)
		ECDSA_SIG_free(signature);
	if (r)
		BN_free(r);
	if (s)
		BN_free(s);
	EVP_MD_CTX_cleanup(&md_ctx);
	return ret;
	}

int x9_62_tests(BIO *out)
	{
	int ret = 0;

	BIO_printf(out, "some tests from X9.62:\n");

	/* set own rand method */
	if (!change_rand())
		goto x962_err;

	if (!x9_62_test_internal(out, NID_X9_62_prime192v1,
		"3342403536405981729393488334694600415596881826869351677613",
		"5735822328888155254683894997897571951568553642892029982342"))
		goto x962_err;
	if (!x9_62_test_internal(out, NID_X9_62_prime239v1,
		"3086361431751678114926225473006680188549593787585317781474"
		"62058306432176",
		"3238135532097973577080787768312505059318910517550078427819"
		"78505179448783"))
		goto x962_err;
	if (!x9_62_test_internal(out, NID_X9_62_c2tnb191v1,
		"87194383164871543355722284926904419997237591535066528048",
		"308992691965804947361541664549085895292153777025772063598"))
		goto x962_err;
	if (!x9_62_test_internal(out, NID_X9_62_c2tnb239v1,
		"2159633321041961198501834003903461262881815148684178964245"
		"5876922391552",
		"1970303740007316867383349976549972270528498040721988191026"
		"49413465737174"))
		goto x962_err;

	ret = 1;
x962_err:
	if (!restore_rand())
		ret = 0;
	return ret;
	}

int test_builtin(BIO *out)
	{
	EC_builtin_curve *curves = NULL;
	size_t		crv_len = 0, n = 0;
	EC_KEY		*eckey = NULL, *wrong_eckey = NULL;
	EC_GROUP	*group;
	unsigned char	digest[20], wrong_digest[20];
	unsigned char	*signature = NULL; 
	unsigned int	sig_len;
	int		nid, ret =  0;
	
	/* fill digest values with some random data */
	if (!RAND_pseudo_bytes(digest, 20) ||
	    !RAND_pseudo_bytes(wrong_digest, 20))
		{
		BIO_printf(out, "ERROR: unable to get random data\n");
		goto builtin_err;
		}

	/* create and verify a ecdsa signature with every availble curve
	 * (with ) */
	BIO_printf(out, "\ntesting ECDSA_sign() and ECDSA_verify() "
		"with some internal curves:\n");

	/* get a list of all internal curves */
	crv_len = EC_get_builtin_curves(NULL, 0);

	curves = OPENSSL_malloc(sizeof(EC_builtin_curve) * crv_len);

	if (curves == NULL)
		{
		BIO_printf(out, "malloc error\n");
		goto builtin_err;
		}
	
	if (!EC_get_builtin_curves(curves, crv_len))
		{
		BIO_printf(out, "unable to get internal curves\n");
		goto builtin_err;
		}

	/* now create and verify a signature for every curve */
	for (n = 0; n < crv_len; n++)
		{
		unsigned char dirt, offset;

		nid = curves[n].nid;
		if (nid == NID_ipsec4)
			continue;
		/* create new ecdsa key (== EC_KEY) */
		if ((eckey = EC_KEY_new()) == NULL)
			goto builtin_err;
		group = EC_GROUP_new_by_curve_name(nid);
		if (group == NULL)
			goto builtin_err;
		if (EC_KEY_set_group(eckey, group) == 0)
			goto builtin_err;
		EC_GROUP_free(group);
		if (EC_GROUP_get_degree(EC_KEY_get0_group(eckey)) < 160)
			/* drop the curve */ 
			{
			EC_KEY_free(eckey);
			eckey = NULL;
			continue;
			}
		BIO_printf(out, "%s: ", OBJ_nid2sn(nid));
		/* create key */
		if (!EC_KEY_generate_key(eckey))
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}
		/* create second key */
		if ((wrong_eckey = EC_KEY_new()) == NULL)
			goto builtin_err;
		group = EC_GROUP_new_by_curve_name(nid);
		if (group == NULL)
			goto builtin_err;
		if (EC_KEY_set_group(wrong_eckey, group) == 0)
			goto builtin_err;
		EC_GROUP_free(group);
		if (!EC_KEY_generate_key(wrong_eckey))
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}

		BIO_printf(out, ".");
		(void)BIO_flush(out);
		/* check key */
		if (!EC_KEY_check_key(eckey))
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}
		BIO_printf(out, ".");
		(void)BIO_flush(out);
		/* create signature */
		sig_len = ECDSA_size(eckey);
		if ((signature = OPENSSL_malloc(sig_len)) == NULL)
			goto builtin_err;
                if (!ECDSA_sign(0, digest, 20, signature, &sig_len, eckey))
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}
		BIO_printf(out, ".");
		(void)BIO_flush(out);
		/* verify signature */
		if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1)
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}
		BIO_printf(out, ".");
		(void)BIO_flush(out);
		/* verify signature with the wrong key */
		if (ECDSA_verify(0, digest, 20, signature, sig_len, 
			wrong_eckey) == 1)
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}
		BIO_printf(out, ".");
		(void)BIO_flush(out);
		/* wrong digest */
		if (ECDSA_verify(0, wrong_digest, 20, signature, sig_len,
			eckey) == 1)
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}
		BIO_printf(out, ".");
		(void)BIO_flush(out);
		/* modify a single byte of the signature */
		offset = signature[10] % sig_len;
		dirt   = signature[11];
		signature[offset] ^= dirt ? dirt : 1; 
		if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) == 1)
			{
			BIO_printf(out, " failed\n");
			goto builtin_err;
			}
		BIO_printf(out, ".");
		(void)BIO_flush(out);
		
		BIO_printf(out, " ok\n");
		/* cleanup */
		OPENSSL_free(signature);
		signature = NULL;
		EC_KEY_free(eckey);
		eckey = NULL;
		EC_KEY_free(wrong_eckey);
		wrong_eckey = NULL;
		}

	ret = 1;	
builtin_err:
	if (eckey)
		EC_KEY_free(eckey);
	if (wrong_eckey)
		EC_KEY_free(wrong_eckey);
	if (signature)
		OPENSSL_free(signature);
	if (curves)
		OPENSSL_free(curves);

	return ret;
	}

int main(void)
	{
	int 	ret = 1;
	BIO	*out;

	out = BIO_new_fp(stdout, BIO_NOCLOSE);
	
	/* enable memory leak checking unless explicitly disabled */
	if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && 
		(0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
		{
		CRYPTO_malloc_debug_init();
		CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
		}
	else
		{
		/* OPENSSL_DEBUG_MEMORY=off */
		CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
		}
	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);

	ERR_load_crypto_strings();

	/* initialize the prng */
	RAND_seed(rnd_seed, sizeof(rnd_seed));

	/* the tests */
	if (!x9_62_tests(out))  goto err;
	if (!test_builtin(out)) goto err;
	
	ret = 0;
err:	
	if (ret) 	
		BIO_printf(out, "\nECDSA test failed\n");
	else 
		BIO_printf(out, "\nECDSA test passed\n");
	if (ret)
		ERR_print_errors(out);
	CRYPTO_cleanup_all_ex_data();
	ERR_remove_state(0);
	ERR_free_strings();
	CRYPTO_mem_leaks(out);
	if (out != NULL)
		BIO_free(out);
	return ret;
	}	
#endif
Commit	Line	Data
4d94ae00	1	/* crypto/ecdsa/ecdsatest.c */
2b32b281 BM	2	/*
	3	* Written by Nils Larsch for the OpenSSL project.
	4	*/
4d94ae00	5	/* ====================================================================
9dd84053	6	* Copyright (c) 2000-2005 The OpenSSL Project. All rights reserved.
4d94ae00 BM	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	*
	12	* 1. Redistributions of source code must retain the above copyright
	13	* notice, this list of conditions and the following disclaimer.
	14	*
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in
	17	* the documentation and/or other materials provided with the
	18	* distribution.
	19	*
	20	* 3. All advertising materials mentioning features or use of this
	21	* software must display the following acknowledgment:
	22	* "This product includes software developed by the OpenSSL Project
	23	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	24	*
	25	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	26	* endorse or promote products derived from this software without
	27	* prior written permission. For written permission, please contact
	28	* licensing@OpenSSL.org.
	29	*
	30	* 5. Products derived from this software may not be called "OpenSSL"
	31	* nor may "OpenSSL" appear in their names without prior written
	32	* permission of the OpenSSL Project.
	33	*
	34	* 6. Redistributions of any form whatsoever must retain the following
	35	* acknowledgment:
	36	* "This product includes software developed by the OpenSSL Project
	37	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	38	*
	39	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	40	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	41	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	42	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	43	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	44	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	45	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	46	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	47	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	48	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	49	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	50	* OF THE POSSIBILITY OF SUCH DAMAGE.
	51	* ====================================================================
	52	*
	53	* This product includes cryptographic software written by Eric Young
	54	* (eay@cryptsoft.com). This product includes software written by Tim
	55	* Hudson (tjh@cryptsoft.com).
	56	*
	57	*/
e172d60d BM	58	/* ====================================================================
	59	* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
	60	*
	61	* Portions of the attached software ("Contribution") are developed by
	62	* SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
	63	*
	64	* The Contribution is licensed pursuant to the OpenSSL open source
	65	* license provided above.
	66	*
e172d60d BM	67	* The elliptic curve binary polynomial software is originally written by
	68	* Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
	69	*
	70	*/
	71
4d94ae00 BM	72	#include <stdio.h>
	73	#include <stdlib.h>
	74	#include <string.h>
4d94ae00	75
3b6aa36c RL	76	#include <openssl/opensslconf.h> /* To see if OPENSSL_NO_ECDSA is defined */
3b6aa36c RL	77
4d94ae00	78	#ifdef OPENSSL_NO_ECDSA
2b32b281 BM	79	int main(int argc, char * argv[])
	80	{
	81	puts("Elliptic curves are disabled.");
	82	return 0;
	83	}
4d94ae00 BM	84	#else
4d94ae00 BM	85
690ecff7 BM	86	#include <openssl/crypto.h>
	87	#include <openssl/bio.h>
	88	#include <openssl/evp.h>
4913b88f	89	#include <openssl/bn.h>
690ecff7	90	#include <openssl/ecdsa.h>
8bdbf507	91	#ifndef OPENSSL_NO_ENGINE
690ecff7	92	#include <openssl/engine.h>
8bdbf507	93	#endif
690ecff7	94	#include <openssl/err.h>
3a87a9b9	95	#include <openssl/rand.h>
690ecff7	96
2b32b281 BM	97	static const char rnd_seed[] = "string to make the random number generator "
	98	"think it has entropy";
	99
	100	/* declaration of the test functions */
	101	int x9_62_tests(BIO *);
	102	int x9_62_test_internal(BIO out, int nid, const char r, const char *s);
	103	int test_builtin(BIO *);
	104
	105	/* functions to change the RAND_METHOD */
	106	int change_rand(void);
	107	int restore_rand(void);
	108	int fbytes(unsigned char *buf, int num);
	109
	110	RAND_METHOD fake_rand;
	111	const RAND_METHOD *old_rand;
	112
	113	int change_rand(void)
4d94ae00	114	{
2b32b281 BM	115	/* save old rand method */
	116	if ((old_rand = RAND_get_rand_method()) == NULL)
	117	return 0;
	118
	119	fake_rand.seed = old_rand->seed;
	120	fake_rand.cleanup = old_rand->cleanup;
	121	fake_rand.add = old_rand->add;
	122	fake_rand.status = old_rand->status;
	123	/* use own random function */
	124	fake_rand.bytes = fbytes;
31182ad3	125	fake_rand.pseudorand = old_rand->bytes;
2b32b281 BM	126	/* set new RAND_METHOD */
	127	if (!RAND_set_rand_method(&fake_rand))
	128	return 0;
	129	return 1;
4d94ae00	130	}
2b32b281 BM	131
2b32b281 BM	132	int restore_rand(void)
4d94ae00	133	{
2b32b281 BM	134	if (!RAND_set_rand_method(old_rand))
	135	return 0;
	136	else
	137	return 1;
4d94ae00	138	}
4d94ae00	139
2b32b281 BM	140	static int fbytes_counter = 0;
	141	static const char *numbers[8] = {
	142	"651056770906015076056810763456358567190100156695615665659",
	143	"6140507067065001063065065565667405560006161556565665656654",
	144	"8763001015071075675010661307616710783570106710677817767166"
	145	"71676178726717",
	146	"7000000175690566466555057817571571075705015757757057795755"
	147	"55657156756655",
	148	"1275552191113212300012030439187146164646146646466749494799",
	149	"1542725565216523985789236956265265265235675811949404040041",
	150	"1456427555219115346513212300075341203043918714616464614664"
	151	"64667494947990",
	152	"1712787255652165239672857892369562652652652356758119494040"
	153	"40041670216363"};
	154
	155	int fbytes(unsigned char *buf, int num)
	156	{
	157	int ret;
	158	BIGNUM *tmp = NULL;
4d94ae00	159
2b32b281	160	if (fbytes_counter >= 8)
4d94ae00	161	return 0;
2b32b281 BM	162	tmp = BN_new();
	163	if (!tmp)
	164	return 0;
	165	if (!BN_dec2bn(&tmp, numbers[fbytes_counter]))
	166	{
	167	BN_free(tmp);
	168	return 0;
	169	}
	170	fbytes_counter ++;
	171	ret = BN_bn2bin(tmp, buf);
	172	if (ret == 0 \|\| ret != num)
	173	ret = 0;
	174	else
	175	ret = 1;
	176	if (tmp)
	177	BN_free(tmp);
	178	return ret;
4d94ae00	179	}
2b32b281 BM	180
	181	/* some tests from the X9.62 draft */
	182	int x9_62_test_internal(BIO out, int nid, const char r_in, const char *s_in)
4d94ae00	183	{
2b32b281 BM	184	int ret = 0;
	185	const char message[] = "abc";
	186	unsigned char digest[20];
	187	unsigned int dgst_len = 0;
	188	EVP_MD_CTX md_ctx;
	189	EC_KEY *key = NULL;
	190	ECDSA_SIG *signature = NULL;
	191	BIGNUM r = NULL, s = NULL;
	192
	193	EVP_MD_CTX_init(&md_ctx);
	194	/* get the message digest */
	195	EVP_DigestInit(&md_ctx, EVP_ecdsa());
	196	EVP_DigestUpdate(&md_ctx, (const void*)message, 3);
	197	EVP_DigestFinal(&md_ctx, digest, &dgst_len);
	198
	199	BIO_printf(out, "testing %s: ", OBJ_nid2sn(nid));
	200	/* create the key */
9dd84053	201	if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)
2b32b281 BM	202	goto x962_int_err;
	203	if (!EC_KEY_generate_key(key))
	204	goto x962_int_err;
	205	BIO_printf(out, ".");
ddb0cb5b	206	(void)BIO_flush(out);
2b32b281 BM	207	/* create the signature */
	208	signature = ECDSA_do_sign(digest, 20, key);
	209	if (signature == NULL)
	210	goto x962_int_err;
	211	BIO_printf(out, ".");
ddb0cb5b	212	(void)BIO_flush(out);
2b32b281 BM	213	/* compare the created signature with the expected signature */
	214	if ((r = BN_new()) == NULL \|\| (s = BN_new()) == NULL)
	215	goto x962_int_err;
	216	if (!BN_dec2bn(&r, r_in) \|\|
	217	!BN_dec2bn(&s, s_in))
	218	goto x962_int_err;
	219	if (BN_cmp(signature->r ,r) \|\| BN_cmp(signature->s, s))
	220	goto x962_int_err;
	221	BIO_printf(out, ".");
ddb0cb5b	222	(void)BIO_flush(out);
2b32b281 BM	223	/* verify the signature */
	224	if (ECDSA_do_verify(digest, 20, signature, key) != 1)
	225	goto x962_int_err;
	226	BIO_printf(out, ".");
ddb0cb5b	227	(void)BIO_flush(out);
2b32b281 BM	228
	229	BIO_printf(out, " ok\n");
	230	ret = 1;
	231	x962_int_err:
	232	if (!ret)
	233	BIO_printf(out, " failed\n");
	234	if (key)
	235	EC_KEY_free(key);
	236	if (signature)
	237	ECDSA_SIG_free(signature);
	238	if (r)
	239	BN_free(r);
	240	if (s)
	241	BN_free(s);
	242	EVP_MD_CTX_cleanup(&md_ctx);
	243	return ret;
4d94ae00 BM	244	}
4d94ae00 BM	245
2b32b281	246	int x9_62_tests(BIO *out)
4d94ae00	247	{
2b32b281 BM	248	int ret = 0;
	249
	250	BIO_printf(out, "some tests from X9.62:\n");
	251
	252	/* set own rand method */
	253	if (!change_rand())
	254	goto x962_err;
	255
	256	if (!x9_62_test_internal(out, NID_X9_62_prime192v1,
	257	"3342403536405981729393488334694600415596881826869351677613",
	258	"5735822328888155254683894997897571951568553642892029982342"))
	259	goto x962_err;
	260	if (!x9_62_test_internal(out, NID_X9_62_prime239v1,
	261	"3086361431751678114926225473006680188549593787585317781474"
	262	"62058306432176",
	263	"3238135532097973577080787768312505059318910517550078427819"
	264	"78505179448783"))
	265	goto x962_err;
	266	if (!x9_62_test_internal(out, NID_X9_62_c2tnb191v1,
	267	"87194383164871543355722284926904419997237591535066528048",
	268	"308992691965804947361541664549085895292153777025772063598"))
	269	goto x962_err;
	270	if (!x9_62_test_internal(out, NID_X9_62_c2tnb239v1,
	271	"2159633321041961198501834003903461262881815148684178964245"
	272	"5876922391552",
	273	"1970303740007316867383349976549972270528498040721988191026"
	274	"49413465737174"))
	275	goto x962_err;
4d94ae00	276
2b32b281 BM	277	ret = 1;
	278	x962_err:
	279	if (!restore_rand())
	280	ret = 0;
4d94ae00	281	return ret;
2b32b281 BM	282	}
	283
	284	int test_builtin(BIO *out)
	285	{
	286	EC_builtin_curve *curves = NULL;
	287	size_t crv_len = 0, n = 0;
	288	EC_KEY eckey = NULL, wrong_eckey = NULL;
9dd84053	289	EC_GROUP *group;
2b32b281	290	unsigned char digest[20], wrong_digest[20];
e9224c71	291	unsigned char *signature = NULL;
2b32b281 BM	292	unsigned int sig_len;
	293	int nid, ret = 0;
	294
	295	/* fill digest values with some random data */
	296	if (!RAND_pseudo_bytes(digest, 20) \|\|
	297	!RAND_pseudo_bytes(wrong_digest, 20))
	298	{
	299	BIO_printf(out, "ERROR: unable to get random data\n");
	300	goto builtin_err;
	301	}
4d94ae00	302
2b32b281 BM	303	/* create and verify a ecdsa signature with every availble curve
	304	* (with ) */
	305	BIO_printf(out, "\ntesting ECDSA_sign() and ECDSA_verify() "
	306	"with some internal curves:\n");
4d94ae00	307
2b32b281 BM	308	/* get a list of all internal curves */
	309	crv_len = EC_get_builtin_curves(NULL, 0);
	310
	311	curves = OPENSSL_malloc(sizeof(EC_builtin_curve) * crv_len);
	312
	313	if (curves == NULL)
	314	{
	315	BIO_printf(out, "malloc error\n");
	316	goto builtin_err;
	317	}
4d94ae00	318
2b32b281 BM	319	if (!EC_get_builtin_curves(curves, crv_len))
	320	{
	321	BIO_printf(out, "unable to get internal curves\n");
	322	goto builtin_err;
	323	}
4d94ae00	324
2b32b281 BM	325	/* now create and verify a signature for every curve */
	326	for (n = 0; n < crv_len; n++)
	327	{
ac9c6e10 UM	328	unsigned char dirt, offset;
ac9c6e10 UM	329
2b32b281	330	nid = curves[n].nid;
a9f2330f UM	331	if (nid == NID_ipsec4)
a9f2330f UM	332	continue;
2b32b281 BM	333	/* create new ecdsa key (== EC_KEY) */
	334	if ((eckey = EC_KEY_new()) == NULL)
	335	goto builtin_err;
9dd84053 NL	336	group = EC_GROUP_new_by_curve_name(nid);
	337	if (group == NULL)
	338	goto builtin_err;
	339	if (EC_KEY_set_group(eckey, group) == 0)
2b32b281	340	goto builtin_err;
9dd84053 NL	341	EC_GROUP_free(group);
9dd84053 NL	342	if (EC_GROUP_get_degree(EC_KEY_get0_group(eckey)) < 160)
2b32b281 BM	343	/* drop the curve */
	344	{
	345	EC_KEY_free(eckey);
	346	eckey = NULL;
	347	continue;
	348	}
	349	BIO_printf(out, "%s: ", OBJ_nid2sn(nid));
	350	/* create key */
	351	if (!EC_KEY_generate_key(eckey))
	352	{
	353	BIO_printf(out, " failed\n");
	354	goto builtin_err;
	355	}
	356	/* create second key */
	357	if ((wrong_eckey = EC_KEY_new()) == NULL)
	358	goto builtin_err;
9dd84053 NL	359	group = EC_GROUP_new_by_curve_name(nid);
	360	if (group == NULL)
	361	goto builtin_err;
	362	if (EC_KEY_set_group(wrong_eckey, group) == 0)
2b32b281	363	goto builtin_err;
9dd84053	364	EC_GROUP_free(group);
2b32b281 BM	365	if (!EC_KEY_generate_key(wrong_eckey))
	366	{
	367	BIO_printf(out, " failed\n");
	368	goto builtin_err;
	369	}
	370
	371	BIO_printf(out, ".");
ddb0cb5b	372	(void)BIO_flush(out);
2b32b281 BM	373	/* check key */
	374	if (!EC_KEY_check_key(eckey))
	375	{
	376	BIO_printf(out, " failed\n");
	377	goto builtin_err;
	378	}
	379	BIO_printf(out, ".");
ddb0cb5b	380	(void)BIO_flush(out);
2b32b281 BM	381	/* create signature */
	382	sig_len = ECDSA_size(eckey);
	383	if ((signature = OPENSSL_malloc(sig_len)) == NULL)
	384	goto builtin_err;
	385	if (!ECDSA_sign(0, digest, 20, signature, &sig_len, eckey))
	386	{
	387	BIO_printf(out, " failed\n");
	388	goto builtin_err;
	389	}
	390	BIO_printf(out, ".");
ddb0cb5b	391	(void)BIO_flush(out);
2b32b281 BM	392	/* verify signature */
	393	if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1)
	394	{
	395	BIO_printf(out, " failed\n");
	396	goto builtin_err;
	397	}
	398	BIO_printf(out, ".");
ddb0cb5b	399	(void)BIO_flush(out);
2b32b281 BM	400	/* verify signature with the wrong key */
	401	if (ECDSA_verify(0, digest, 20, signature, sig_len,
	402	wrong_eckey) == 1)
	403	{
	404	BIO_printf(out, " failed\n");
	405	goto builtin_err;
	406	}
	407	BIO_printf(out, ".");
ddb0cb5b	408	(void)BIO_flush(out);
2b32b281 BM	409	/* wrong digest */
	410	if (ECDSA_verify(0, wrong_digest, 20, signature, sig_len,
	411	eckey) == 1)
	412	{
	413	BIO_printf(out, " failed\n");
	414	goto builtin_err;
	415	}
	416	BIO_printf(out, ".");
ddb0cb5b	417	(void)BIO_flush(out);
ac9c6e10 UM	418	/* modify a single byte of the signature */
	419	offset = signature[10] % sig_len;
	420	dirt = signature[11];
	421	signature[offset] ^= dirt ? dirt : 1;
2b32b281 BM	422	if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) == 1)
	423	{
	424	BIO_printf(out, " failed\n");
	425	goto builtin_err;
	426	}
	427	BIO_printf(out, ".");
ddb0cb5b	428	(void)BIO_flush(out);
2b32b281 BM	429
	430	BIO_printf(out, " ok\n");
	431	/* cleanup */
	432	OPENSSL_free(signature);
	433	signature = NULL;
	434	EC_KEY_free(eckey);
	435	eckey = NULL;
	436	EC_KEY_free(wrong_eckey);
	437	wrong_eckey = NULL;
	438	}
	439
	440	ret = 1;
	441	builtin_err:
	442	if (eckey)
	443	EC_KEY_free(eckey);
	444	if (wrong_eckey)
	445	EC_KEY_free(wrong_eckey);
f95d0973	446	if (signature)
2b32b281 BM	447	OPENSSL_free(signature);
	448	if (curves)
	449	OPENSSL_free(curves);
4d94ae00	450
4d94ae00	451	return ret;
2b32b281	452	}
4d94ae00 BM	453
4d94ae00 BM	454	int main(void)
2b32b281	455	{
b3b67209	456	int ret = 1;
2b32b281 BM	457	BIO *out;
	458
	459	out = BIO_new_fp(stdout, BIO_NOCLOSE);
4d94ae00	460
8f06b003	461	/* enable memory leak checking unless explicitly disabled */
2b32b281 BM	462	if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) &&
2b32b281 BM	463	(0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
8f06b003 BM	464	{
	465	CRYPTO_malloc_debug_init();
	466	CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
	467	}
	468	else
	469	{
	470	/* OPENSSL_DEBUG_MEMORY=off */
	471	CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
	472	}
	473	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
4d94ae00	474
8f06b003	475	ERR_load_crypto_strings();
4d94ae00	476
2b32b281	477	/* initialize the prng */
8f06b003	478	RAND_seed(rnd_seed, sizeof(rnd_seed));
4d94ae00	479
2b32b281 BM	480	/* the tests */
	481	if (!x9_62_tests(out)) goto err;
	482	if (!test_builtin(out)) goto err;
4d94ae00	483
b3b67209	484	ret = 0;
2b32b281	485	err:
b3b67209	486	if (ret)
2b32b281	487	BIO_printf(out, "\nECDSA test failed\n");
4d94ae00	488	else
2b32b281	489	BIO_printf(out, "\nECDSA test passed\n");
0210065b	490	if (ret)
2b32b281	491	ERR_print_errors(out);
4d94ae00 BM	492	CRYPTO_cleanup_all_ex_data();
	493	ERR_remove_state(0);
	494	ERR_free_strings();
2b32b281 BM	495	CRYPTO_mem_leaks(out);
	496	if (out != NULL)
	497	BIO_free(out);
b3b67209	498	return ret;
2b32b281	499	}
4d94ae00	500	#endif