Symaptic: os/ossrv/ssl/tsrc/crypto_test/src/bntest.c@260cb5ec6c19 (annotated)

sl@0	1	/* crypto/bn/bntest.c */
sl@0	2	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
sl@0	3	* All rights reserved.
sl@0	4	*
sl@0	5	* This package is an SSL implementation written
sl@0	6	* by Eric Young (eay@cryptsoft.com).
sl@0	7	* The implementation was written so as to conform with Netscapes SSL.
sl@0	8	*
sl@0	9	* This library is free for commercial and non-commercial use as long as
sl@0	10	* the following conditions are aheared to. The following conditions
sl@0	11	* apply to all code found in this distribution, be it the RC4, RSA,
sl@0	12	* lhash, DES, etc., code; not just the SSL code. The SSL documentation
sl@0	13	* included with this distribution is covered by the same copyright terms
sl@0	14	* except that the holder is Tim Hudson (tjh@cryptsoft.com).
sl@0	15	*
sl@0	16	* Copyright remains Eric Young's, and as such any Copyright notices in
sl@0	17	* the code are not to be removed.
sl@0	18	* If this package is used in a product, Eric Young should be given attribution
sl@0	19	* as the author of the parts of the library used.
sl@0	20	* This can be in the form of a textual message at program startup or
sl@0	21	* in documentation (online or textual) provided with the package.
sl@0	22	*
sl@0	23	* Redistribution and use in source and binary forms, with or without
sl@0	24	* modification, are permitted provided that the following conditions
sl@0	25	* are met:
sl@0	26	* 1. Redistributions of source code must retain the copyright
sl@0	27	* notice, this list of conditions and the following disclaimer.
sl@0	28	* 2. Redistributions in binary form must reproduce the above copyright
sl@0	29	* notice, this list of conditions and the following disclaimer in the
sl@0	30	* documentation and/or other materials provided with the distribution.
sl@0	31	* 3. All advertising materials mentioning features or use of this software
sl@0	32	* must display the following acknowledgement:
sl@0	33	* "This product includes cryptographic software written by
sl@0	34	* Eric Young (eay@cryptsoft.com)"
sl@0	35	* The word 'cryptographic' can be left out if the rouines from the library
sl@0	36	* being used are not cryptographic related :-).
sl@0	37	* 4. If you include any Windows specific code (or a derivative thereof) from
sl@0	38	* the apps directory (application code) you must include an acknowledgement:
sl@0	39	* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
sl@0	40	*
sl@0	41	* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
sl@0	42	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
sl@0	43	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
sl@0	44	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
sl@0	45	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
sl@0	46	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
sl@0	47	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
sl@0	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
sl@0	49	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
sl@0	50	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
sl@0	51	* SUCH DAMAGE.
sl@0	52	*
sl@0	53	* The licence and distribution terms for any publically available version or
sl@0	54	* derivative of this code cannot be changed. i.e. this code cannot simply be
sl@0	55	* copied and put under another distribution licence
sl@0	56	* [including the GNU Public Licence.]
sl@0	57	*/
sl@0	58	/* ====================================================================
sl@0	59	* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
sl@0	60	*
sl@0	61	* Portions of the attached software ("Contribution") are developed by
sl@0	62	* SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
sl@0	63	*
sl@0	64	* The Contribution is licensed pursuant to the Eric Young open source
sl@0	65	* license provided above.
sl@0	66	*
sl@0	67	* The binary polynomial arithmetic software is originally written by
sl@0	68	* Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
sl@0	69	*
sl@0	70	*/
sl@0	71	/*
sl@0	72	© Portions copyright (c) 2006 Nokia Corporation. All rights reserved.
sl@0	73	*/
sl@0	74
sl@0	75	/* Until the key-gen callbacks are modified to use newer prototypes, we allow
sl@0	76	* deprecated functions for openssl-internal code */
sl@0	77	#ifndef SYMBIAN
sl@0	78	#ifdef OPENSSL_NO_DEPRECATED
sl@0	79	#undef OPENSSL_NO_DEPRECATED
sl@0	80	#endif
sl@0	81	#endif
sl@0	82
sl@0	83	#ifdef SYMBIAN
sl@0	84	#include <e32def.h>
sl@0	85	#endif
sl@0	86
sl@0	87
sl@0	88	#include <stdio.h>
sl@0	89	#include <stdlib.h>
sl@0	90	#include <string.h>
sl@0	91	#ifndef SYMBIAN
sl@0	92	#include "../e_os.h"
sl@0	93	#else
sl@0	94	#include "e_os.h"
sl@0	95	#endif
sl@0	96
sl@0	97	#include <openssl/bio.h>
sl@0	98	#include <openssl/bn.h>
sl@0	99	#include <openssl/rand.h>
sl@0	100	#include <openssl/x509.h>
sl@0	101	#include <openssl/err.h>
sl@0	102	#ifdef SYMBIAN
sl@0	103	#ifdef stdin
sl@0	104	#undef stdin
sl@0	105	#endif
sl@0	106	#ifdef stdout
sl@0	107	#undef stdout
sl@0	108	#endif
sl@0	109	#ifdef stderr
sl@0	110	#undef stderr
sl@0	111	#endif
sl@0	112	#define stdin fp_stdin
sl@0	113	#define stdout fp_stdout
sl@0	114	#define stderr fp_stderr
sl@0	115	extern FILE *fp_stdout;
sl@0	116	extern FILE *fp_stderr;
sl@0	117	#endif
sl@0	118
sl@0	119	const int num0 = 100; /* number of tests */
sl@0	120	const int num1 = 50; /* additional tests for some functions */
sl@0	121	const int num2 = 5; /* number of tests for slow functions */
sl@0	122
sl@0	123	int test_add(BIO *bp);
sl@0	124	int test_sub(BIO *bp);
sl@0	125	int test_lshift1(BIO *bp);
sl@0	126	int test_lshift(BIO bp,BN_CTX ctx,BIGNUM *a_);
sl@0	127	int test_rshift1(BIO *bp);
sl@0	128	int test_rshift(BIO bp,BN_CTX ctx);
sl@0	129	int test_div(BIO bp,BN_CTX ctx);
sl@0	130	int test_div_word(BIO *bp);
sl@0	131	int test_div_recp(BIO bp,BN_CTX ctx);
sl@0	132	int test_mul(BIO *bp);
sl@0	133	int test_sqr(BIO bp,BN_CTX ctx);
sl@0	134	int test_mont(BIO bp,BN_CTX ctx);
sl@0	135	int test_mod(BIO bp,BN_CTX ctx);
sl@0	136	int test_mod_mul(BIO bp,BN_CTX ctx);
sl@0	137	int test_mod_exp(BIO bp,BN_CTX ctx);
sl@0	138	int test_mod_exp_mont_consttime(BIO bp,BN_CTX ctx);
sl@0	139	int test_exp(BIO bp,BN_CTX ctx);
sl@0	140	int test_gf2m_add(BIO *bp);
sl@0	141	int test_gf2m_mod(BIO *bp);
sl@0	142	int test_gf2m_mod_mul(BIO bp,BN_CTX ctx);
sl@0	143	int test_gf2m_mod_sqr(BIO bp,BN_CTX ctx);
sl@0	144	int test_gf2m_mod_inv(BIO bp,BN_CTX ctx);
sl@0	145	int test_gf2m_mod_div(BIO bp,BN_CTX ctx);
sl@0	146	int test_gf2m_mod_exp(BIO bp,BN_CTX ctx);
sl@0	147	int test_gf2m_mod_sqrt(BIO bp,BN_CTX ctx);
sl@0	148	int test_gf2m_mod_solve_quad(BIO bp,BN_CTX ctx);
sl@0	149	int test_kron(BIO bp,BN_CTX ctx);
sl@0	150	int test_sqrt(BIO bp,BN_CTX ctx);
sl@0	151	int rand_neg(void);
sl@0	152	static int results=0;
sl@0	153
sl@0	154	static unsigned char lst[]="\xC6\x4F\x43\x04\x2A\xEA\xCA\x6E\x58\x36\x80\x5B\xE8\xC9"
sl@0	155	"\x9B\x04\x5D\x48\x36\xC2\xFD\x16\xC9\x64\xF0";
sl@0	156
sl@0	157	static const char rnd_seed[] = "string to make the random number generator think it has entropy";
sl@0	158
sl@0	159	static void message(BIO out, char m)
sl@0	160	{
sl@0	161	fprintf(stderr, "test %s\n", m);
sl@0	162	BIO_puts(out, "print \"test ");
sl@0	163	BIO_puts(out, m);
sl@0	164	BIO_puts(out, "\\n\"\n");
sl@0	165	}
sl@0	166
sl@0	167	#ifndef SYMBIAN
sl@0	168	int main(int argc, char *argv[])
sl@0	169	#else
sl@0	170	int bn_main(int argc, char *argv[])
sl@0	171	#endif
sl@0	172
sl@0	173	{
sl@0	174	BN_CTX *ctx;
sl@0	175	BIO *out;
sl@0	176	char *outfile=NULL;
sl@0	177
sl@0	178	results = 0;
sl@0	179	RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_generate_prime may fail */
sl@0	180	if(errno==ENOMEM)
sl@0	181	{
sl@0	182	return 1;
sl@0	183	}
sl@0	184	#ifndef SYMBIAN
sl@0	185	argc--;
sl@0	186	argv++;
sl@0	187	#endif
sl@0	188	while (argc >= 1)
sl@0	189	{
sl@0	190	if (strcmp(*argv,"-results") == 0)
sl@0	191	results=1;
sl@0	192	else if (strcmp(*argv,"-out") == 0)
sl@0	193	{
sl@0	194	if (--argc < 1) break;
sl@0	195	outfile= *(++argv);
sl@0	196	}
sl@0	197	argc--;
sl@0	198	argv++;
sl@0	199	}
sl@0	200
sl@0	201
sl@0	202	ctx=BN_CTX_new();
sl@0	203	if(ctx == NULL&&errno==ENOMEM)
sl@0	204	{
sl@0	205	return 1;
sl@0	206	}
sl@0	207	if (ctx == NULL)
sl@0	208	return 1;
sl@0	209	out=BIO_new(BIO_s_file());
sl@0	210	if(out == NULL&&errno==ENOMEM)
sl@0	211	{
sl@0	212	return 1;
sl@0	213	}
sl@0	214
sl@0	215	if (out == NULL)
sl@0	216	return 1;
sl@0	217	if (outfile == NULL)
sl@0	218	{
sl@0	219	BIO_set_fp(out,stdout,BIO_NOCLOSE);
sl@0	220	if(errno==ENOMEM)
sl@0	221	{
sl@0	222	return 1;
sl@0	223	}
sl@0	224	}
sl@0	225	else
sl@0	226	{
sl@0	227	if (!BIO_write_filename(out,outfile))
sl@0	228	{
sl@0	229	return 1;
sl@0	230	}
sl@0	231	}
sl@0	232
sl@0	233	if (!results)
sl@0	234	BIO_puts(out,"obase=16\nibase=16\n");
sl@0	235	if(errno==ENOMEM)
sl@0	236	{
sl@0	237	return 1;
sl@0	238	}
sl@0	239	message(out,"BN_add");
sl@0	240	if (!test_add(out))
sl@0	241	{
sl@0	242	if(errno==ENOMEM)
sl@0	243	{
sl@0	244	return 1;
sl@0	245	}
sl@0	246	goto err;
sl@0	247	}
sl@0	248	(void)BIO_flush(out);
sl@0	249	if(errno==ENOMEM)
sl@0	250	{
sl@0	251	return 1;
sl@0	252	}
sl@0	253
sl@0	254	message(out,"BN_sub");
sl@0	255	if (!test_sub(out))
sl@0	256	{
sl@0	257	if(errno==ENOMEM)
sl@0	258	{
sl@0	259	return 1;
sl@0	260	}
sl@0	261	goto err;
sl@0	262	}
sl@0	263	(void)BIO_flush(out);
sl@0	264	if(errno==ENOMEM)
sl@0	265	{
sl@0	266	return 1;
sl@0	267	}
sl@0	268
sl@0	269	message(out,"BN_lshift1");
sl@0	270	if (!test_lshift1(out))
sl@0	271	{
sl@0	272	if(errno==ENOMEM)
sl@0	273	{
sl@0	274	return 1;
sl@0	275	}
sl@0	276	goto err;
sl@0	277	}
sl@0	278	(void)BIO_flush(out);
sl@0	279	if(errno==ENOMEM)
sl@0	280	{
sl@0	281	return 1;
sl@0	282	}
sl@0	283	message(out,"BN_lshift (fixed)");
sl@0	284	if (!test_lshift(out,ctx,BN_bin2bn(lst,sizeof(lst)-1,NULL)))
sl@0	285	{
sl@0	286	if(errno==ENOMEM)
sl@0	287	{
sl@0	288	return 1;
sl@0	289	}
sl@0	290	goto err;
sl@0	291	}
sl@0	292	(void)BIO_flush(out);
sl@0	293	if(errno==ENOMEM)
sl@0	294	{
sl@0	295	return 1;
sl@0	296	}
sl@0	297	message(out,"BN_lshift");
sl@0	298	if (!test_lshift(out,ctx,NULL))
sl@0	299	{
sl@0	300	if(errno==ENOMEM)
sl@0	301	{
sl@0	302	return 1;
sl@0	303	}
sl@0	304	goto err;
sl@0	305	}
sl@0	306	(void)BIO_flush(out);
sl@0	307	if(errno==ENOMEM)
sl@0	308	{
sl@0	309	return 1;
sl@0	310	}
sl@0	311	message(out,"BN_rshift1");
sl@0	312	if (!test_rshift1(out))
sl@0	313	{
sl@0	314	if(errno==ENOMEM)
sl@0	315	{
sl@0	316	return 1;
sl@0	317	}
sl@0	318	goto err;
sl@0	319	}
sl@0	320	(void)BIO_flush(out);
sl@0	321	if(errno==ENOMEM)
sl@0	322	{
sl@0	323	return 1;
sl@0	324	}
sl@0	325	message(out,"BN_rshift");
sl@0	326	if (!test_rshift(out,ctx))
sl@0	327	{
sl@0	328	if(errno==ENOMEM)
sl@0	329	{
sl@0	330	return 1;
sl@0	331	}
sl@0	332	goto err;
sl@0	333	}
sl@0	334	(void)BIO_flush(out);
sl@0	335	if(errno==ENOMEM)
sl@0	336	{
sl@0	337	return 1;
sl@0	338	}
sl@0	339	message(out,"BN_sqr");
sl@0	340	if (!test_sqr(out,ctx))
sl@0	341	{
sl@0	342	if(errno==ENOMEM)
sl@0	343	{
sl@0	344	return 1;
sl@0	345	}
sl@0	346	goto err;
sl@0	347	}
sl@0	348	(void)BIO_flush(out);
sl@0	349	if(errno==ENOMEM)
sl@0	350	{
sl@0	351	return 1;
sl@0	352	}
sl@0	353
sl@0	354	message(out,"BN_mul");
sl@0	355	if (!test_mul(out))
sl@0	356	{
sl@0	357	if(errno==ENOMEM)
sl@0	358	{
sl@0	359	return 1;
sl@0	360	}
sl@0	361	goto err;
sl@0	362	}
sl@0	363	(void)BIO_flush(out);
sl@0	364	if(errno==ENOMEM)
sl@0	365	{
sl@0	366	return 1;
sl@0	367	}
sl@0	368	message(out,"BN_div");
sl@0	369	if (!test_div(out,ctx))
sl@0	370	{
sl@0	371	if(errno==ENOMEM)
sl@0	372	{
sl@0	373	return 1;
sl@0	374	}
sl@0	375	goto err;
sl@0	376	}
sl@0	377	(void)BIO_flush(out);
sl@0	378	if(errno==ENOMEM)
sl@0	379	{
sl@0	380	return 1;
sl@0	381	}
sl@0	382	message(out,"BN_div_word");
sl@0	383	if (!test_div_word(out))
sl@0	384	{
sl@0	385	if(errno==ENOMEM)
sl@0	386	{
sl@0	387	return 1;
sl@0	388	}
sl@0	389	goto err;
sl@0	390	}
sl@0	391	(void)BIO_flush(out);
sl@0	392	if(errno==ENOMEM)
sl@0	393	{
sl@0	394	return 1;
sl@0	395	}
sl@0	396	message(out,"BN_div_recp");
sl@0	397	if (!test_div_recp(out,ctx))
sl@0	398	{
sl@0	399	if(errno==ENOMEM)
sl@0	400	{
sl@0	401	return 1;
sl@0	402	}
sl@0	403	goto err;
sl@0	404	}
sl@0	405	(void)BIO_flush(out);
sl@0	406	if(errno==ENOMEM)
sl@0	407	{
sl@0	408	return 1;
sl@0	409	}
sl@0	410	message(out,"BN_mod");
sl@0	411	if (!test_mod(out,ctx))
sl@0	412	{
sl@0	413	if(errno==ENOMEM)
sl@0	414	{
sl@0	415	return 1;
sl@0	416	}
sl@0	417	goto err;
sl@0	418	}
sl@0	419	(void)BIO_flush(out);
sl@0	420	if(errno==ENOMEM)
sl@0	421	{
sl@0	422	return 1;
sl@0	423	}
sl@0	424	message(out,"BN_mod_mul");
sl@0	425	if (!test_mod_mul(out,ctx))
sl@0	426	{
sl@0	427	if(errno==ENOMEM)
sl@0	428	{
sl@0	429	return 1;
sl@0	430	}
sl@0	431	goto err;
sl@0	432	}
sl@0	433	(void)BIO_flush(out);
sl@0	434	if(errno==ENOMEM)
sl@0	435	{
sl@0	436	return 1;
sl@0	437	}
sl@0	438	message(out,"BN_mont");
sl@0	439	if (!test_mont(out,ctx))
sl@0	440	{
sl@0	441	if(errno==ENOMEM)
sl@0	442	{
sl@0	443	return 1;
sl@0	444	}
sl@0	445	goto err;
sl@0	446	}
sl@0	447	(void)BIO_flush(out);
sl@0	448	if(errno==ENOMEM)
sl@0	449	{
sl@0	450	return 1;
sl@0	451	}
sl@0	452	message(out,"BN_mod_exp");
sl@0	453	if (!test_mod_exp(out,ctx))
sl@0	454	{
sl@0	455	if(errno==ENOMEM)
sl@0	456	{
sl@0	457	return 1;
sl@0	458	}
sl@0	459	goto err;
sl@0	460	}
sl@0	461	(void)BIO_flush(out);
sl@0	462	if(errno==ENOMEM)
sl@0	463	{
sl@0	464	return 1;
sl@0	465	}
sl@0	466	message(out,"BN_mod_exp_mont_consttime");
sl@0	467	if (!test_mod_exp_mont_consttime(out,ctx))
sl@0	468	{
sl@0	469	if(errno==ENOMEM)
sl@0	470	{
sl@0	471	return 1;
sl@0	472	}
sl@0	473	goto err;
sl@0	474	}
sl@0	475	(void)BIO_flush(out);
sl@0	476	if(errno==ENOMEM)
sl@0	477	{
sl@0	478	return 1;
sl@0	479	}
sl@0	480	message(out,"BN_exp");
sl@0	481	if (!test_exp(out,ctx))
sl@0	482	{
sl@0	483	if(errno==ENOMEM)
sl@0	484	{
sl@0	485	return 1;
sl@0	486	}
sl@0	487	goto err;
sl@0	488	}
sl@0	489	(void)BIO_flush(out);
sl@0	490	if(errno==ENOMEM)
sl@0	491	{
sl@0	492	return 1;
sl@0	493	}
sl@0	494	message(out,"BN_kronecker");
sl@0	495	if (!test_kron(out,ctx))
sl@0	496	{
sl@0	497	if(errno==ENOMEM)
sl@0	498	{
sl@0	499	return 1;
sl@0	500	}
sl@0	501	goto err;
sl@0	502	}
sl@0	503	(void)BIO_flush(out);
sl@0	504	if(errno==ENOMEM)
sl@0	505	{
sl@0	506	return 1;
sl@0	507	}
sl@0	508	message(out,"BN_mod_sqrt");
sl@0	509	if (!test_sqrt(out,ctx))
sl@0	510	{
sl@0	511	if(errno==ENOMEM)
sl@0	512	{
sl@0	513	return 1;
sl@0	514	}
sl@0	515	goto err;
sl@0	516	}
sl@0	517	(void)BIO_flush(out);
sl@0	518	if(errno==ENOMEM)
sl@0	519	{
sl@0	520	return 1;
sl@0	521	}
sl@0	522	message(out,"BN_GF2m_add");
sl@0	523	if (!test_gf2m_add(out))
sl@0	524	{
sl@0	525	if(errno==ENOMEM)
sl@0	526	{
sl@0	527	return 1;
sl@0	528	}
sl@0	529	goto err;
sl@0	530	}
sl@0	531	(void)BIO_flush(out);
sl@0	532	if(errno==ENOMEM)
sl@0	533	{
sl@0	534	return 1;
sl@0	535	}
sl@0	536	message(out,"BN_GF2m_mod");
sl@0	537	if (!test_gf2m_mod(out))
sl@0	538	{
sl@0	539	if(errno==ENOMEM)
sl@0	540	{
sl@0	541	return 1;
sl@0	542	}
sl@0	543	goto err;
sl@0	544	}
sl@0	545	(void)BIO_flush(out);
sl@0	546	if(errno==ENOMEM)
sl@0	547	{
sl@0	548	return 1;
sl@0	549	}
sl@0	550	message(out,"BN_GF2m_mod_mul");
sl@0	551	if (!test_gf2m_mod_mul(out,ctx))
sl@0	552	{
sl@0	553	if(errno==ENOMEM)
sl@0	554	{
sl@0	555	return 1;
sl@0	556	}
sl@0	557	goto err;
sl@0	558	}
sl@0	559	(void)BIO_flush(out);
sl@0	560	if(errno==ENOMEM)
sl@0	561	{
sl@0	562	return 1;
sl@0	563	}
sl@0	564	message(out,"BN_GF2m_mod_sqr");
sl@0	565	if (!test_gf2m_mod_sqr(out,ctx))
sl@0	566	{
sl@0	567	if(errno==ENOMEM)
sl@0	568	{
sl@0	569	return 1;
sl@0	570	}
sl@0	571	goto err;
sl@0	572	}
sl@0	573	(void)BIO_flush(out);
sl@0	574	if(errno==ENOMEM)
sl@0	575	{
sl@0	576	return 1;
sl@0	577	}
sl@0	578	message(out,"BN_GF2m_mod_inv");
sl@0	579	if (!test_gf2m_mod_inv(out,ctx))
sl@0	580	{
sl@0	581	if(errno==ENOMEM)
sl@0	582	{
sl@0	583	return 1;
sl@0	584	}
sl@0	585	goto err;
sl@0	586	}
sl@0	587	(void)BIO_flush(out);
sl@0	588	if(errno==ENOMEM)
sl@0	589	{
sl@0	590	return 1;
sl@0	591	}
sl@0	592	message(out,"BN_GF2m_mod_div");
sl@0	593	if (!test_gf2m_mod_div(out,ctx))
sl@0	594	{
sl@0	595	if(errno==ENOMEM)
sl@0	596	{
sl@0	597	return 1;
sl@0	598	}
sl@0	599	goto err;
sl@0	600	}
sl@0	601	(void)BIO_flush(out);
sl@0	602	if(errno==ENOMEM)
sl@0	603	{
sl@0	604	return 1;
sl@0	605	}
sl@0	606	message(out,"BN_GF2m_mod_exp");
sl@0	607	if (!test_gf2m_mod_exp(out,ctx))
sl@0	608	{
sl@0	609	if(errno==ENOMEM)
sl@0	610	{
sl@0	611	return 1;
sl@0	612	}
sl@0	613	goto err;
sl@0	614	}
sl@0	615	(void)BIO_flush(out);
sl@0	616	if(errno==ENOMEM)
sl@0	617	{
sl@0	618	return 1;
sl@0	619	}
sl@0	620	message(out,"BN_GF2m_mod_sqrt");
sl@0	621	if (!test_gf2m_mod_sqrt(out,ctx))
sl@0	622	{
sl@0	623	if(errno==ENOMEM)
sl@0	624	{
sl@0	625	return 1;
sl@0	626	}
sl@0	627	goto err;
sl@0	628	}
sl@0	629	(void)BIO_flush(out);
sl@0	630	if(errno==ENOMEM)
sl@0	631	{
sl@0	632	return 1;
sl@0	633	}
sl@0	634	message(out,"BN_GF2m_mod_solve_quad");
sl@0	635	if (!test_gf2m_mod_solve_quad(out,ctx))
sl@0	636	{
sl@0	637	if(errno==ENOMEM)
sl@0	638	{
sl@0	639	return 1;
sl@0	640	}
sl@0	641	goto err;
sl@0	642	}
sl@0	643	(void)BIO_flush(out);
sl@0	644	if(errno==ENOMEM)
sl@0	645	{
sl@0	646	return 1;
sl@0	647	}
sl@0	648	BN_CTX_free(ctx);
sl@0	649	if(errno==ENOMEM)
sl@0	650	{
sl@0	651	return 1;
sl@0	652	}
sl@0	653	BIO_free(out);
sl@0	654	if(errno==ENOMEM)
sl@0	655	{
sl@0	656	return 1;
sl@0	657	}
sl@0	658	#ifdef SYMBIAN
sl@0	659	CRYPTO_cleanup_all_ex_data();
sl@0	660	if(errno==ENOMEM)
sl@0	661	{
sl@0	662	return 1;
sl@0	663	}
sl@0	664	ERR_remove_state(0);
sl@0	665	if(errno==ENOMEM)
sl@0	666	{
sl@0	667	return 1;
sl@0	668	}
sl@0	669	ERR_free_strings();
sl@0	670	if(errno==ENOMEM)
sl@0	671	{
sl@0	672	return 1;
sl@0	673	}
sl@0	674
sl@0	675	#endif
sl@0	676	fprintf(stderr,"Test case passed!\n");
sl@0	677	fprintf(stdout,"Test case passed!\n");
sl@0	678	return 0;
sl@0	679	err:
sl@0	680	BIO_puts(out,"1\n"); /* make sure the Perl script fed by bc notices
sl@0	681	* the failure, see test_bn in test/Makefile.ssl*/
sl@0	682	if(errno==ENOMEM)
sl@0	683	{
sl@0	684	return 1;
sl@0	685	}
sl@0	686	(void)BIO_flush(out);
sl@0	687	if(errno==ENOMEM)
sl@0	688	{
sl@0	689	return 1;
sl@0	690	}
sl@0	691	ERR_load_crypto_strings();
sl@0	692	if(errno==ENOMEM)
sl@0	693	{
sl@0	694	return 1;
sl@0	695	}
sl@0	696	ERR_print_errors_fp(stderr);
sl@0	697	if(errno==ENOMEM)
sl@0	698	{
sl@0	699	return 1;
sl@0	700	}
sl@0	701	ERR_remove_state(0);
sl@0	702	if(errno==ENOMEM)
sl@0	703	{
sl@0	704	return 1;
sl@0	705	}
sl@0	706	ERR_free_strings();
sl@0	707	if(errno==ENOMEM)
sl@0	708	{
sl@0	709	return 1;
sl@0	710	}
sl@0	711
sl@0	712	#ifdef SYMBIAN
sl@0	713	CRYPTO_cleanup_all_ex_data();
sl@0	714	if(errno==ENOMEM)
sl@0	715	{
sl@0	716	return 1;
sl@0	717	}
sl@0	718
sl@0	719	#endif
sl@0	720	return(1);
sl@0	721	}
sl@0	722
sl@0	723
sl@0	724	int test_add(BIO *bp)
sl@0	725	{
sl@0	726	BIGNUM a,b,c;
sl@0	727	int i;
sl@0	728
sl@0	729	BN_init(&a);
sl@0	730
sl@0	731	if(errno==ENOMEM)
sl@0	732	{
sl@0	733	return 0;
sl@0	734	}
sl@0	735	BN_init(&b);
sl@0	736	if(errno==ENOMEM)
sl@0	737	{
sl@0	738	return 0;
sl@0	739	}
sl@0	740
sl@0	741	BN_init(&c);
sl@0	742	if(errno==ENOMEM)
sl@0	743	{
sl@0	744	return 0;
sl@0	745	}
sl@0	746
sl@0	747
sl@0	748	BN_bntest_rand(&a,512,0,0);
sl@0	749	if(errno==ENOMEM)
sl@0	750	{
sl@0	751	return 0;
sl@0	752	}
sl@0	753
sl@0	754	for (i=0; i<num0; i++)
sl@0	755	{
sl@0	756	BN_bntest_rand(&b,450+i,0,0);
sl@0	757	if(errno==ENOMEM)
sl@0	758	{
sl@0	759	return 0;
sl@0	760	}
sl@0	761	a.neg=rand_neg();
sl@0	762	if(errno==ENOMEM)
sl@0	763	{
sl@0	764	return 0;
sl@0	765	}
sl@0	766	b.neg=rand_neg();
sl@0	767	if(errno==ENOMEM)
sl@0	768	{
sl@0	769	return 0;
sl@0	770	}
sl@0	771	BN_add(&c,&a,&b);
sl@0	772	if(errno==ENOMEM)
sl@0	773	{
sl@0	774	return 0;
sl@0	775	}
sl@0	776
sl@0	777	if (bp != NULL)
sl@0	778	{
sl@0	779	if (!results)
sl@0	780	{
sl@0	781	BN_print(bp,&a);
sl@0	782	if(errno==ENOMEM)
sl@0	783	{
sl@0	784	return 0;
sl@0	785	}
sl@0	786	BIO_puts(bp," + ");
sl@0	787	if(errno==ENOMEM)
sl@0	788	{
sl@0	789	return 0;
sl@0	790	}
sl@0	791
sl@0	792	BN_print(bp,&b);
sl@0	793	if(errno==ENOMEM)
sl@0	794	{
sl@0	795	return 0;
sl@0	796	}
sl@0	797
sl@0	798	BIO_puts(bp," - ");
sl@0	799	if(errno==ENOMEM)
sl@0	800	{
sl@0	801	return 0;
sl@0	802	}
sl@0	803
sl@0	804	}
sl@0	805	BN_print(bp,&c);
sl@0	806	if(errno==ENOMEM)
sl@0	807	{
sl@0	808	return 0;
sl@0	809	}
sl@0	810
sl@0	811	BIO_puts(bp,"\n");
sl@0	812	if(errno==ENOMEM)
sl@0	813	{
sl@0	814	return 0;
sl@0	815	}
sl@0	816
sl@0	817	}
sl@0	818	a.neg=!a.neg;
sl@0	819	b.neg=!b.neg;
sl@0	820	BN_add(&c,&c,&b);
sl@0	821	if(errno==ENOMEM)
sl@0	822	{
sl@0	823	return 0;
sl@0	824	}
sl@0	825
sl@0	826	BN_add(&c,&c,&a);
sl@0	827	if(errno==ENOMEM)
sl@0	828	{
sl@0	829	return 0;
sl@0	830	}
sl@0	831
sl@0	832	if(!BN_is_zero(&c))
sl@0	833	{
sl@0	834	if(errno==ENOMEM)
sl@0	835	{
sl@0	836	return 0;
sl@0	837	}
sl@0	838	fprintf(stderr,"Add test failed!\n");
sl@0	839	return 0;
sl@0	840	}
sl@0	841	}
sl@0	842	BN_free(&a);
sl@0	843	if(errno==ENOMEM)
sl@0	844	{
sl@0	845	return 0;
sl@0	846	}
sl@0	847
sl@0	848	BN_free(&b);
sl@0	849	if(errno==ENOMEM)
sl@0	850	{
sl@0	851	return 0;
sl@0	852	}
sl@0	853
sl@0	854	BN_free(&c);
sl@0	855	if(errno==ENOMEM)
sl@0	856	{
sl@0	857	return 0;
sl@0	858	}
sl@0	859	return(1);
sl@0	860	}
sl@0	861
sl@0	862	int test_sub(BIO *bp)
sl@0	863	{
sl@0	864	BIGNUM a,b,c;
sl@0	865	int i;
sl@0	866
sl@0	867	BN_init(&a);
sl@0	868	if(errno==ENOMEM)
sl@0	869	{
sl@0	870	return 0;
sl@0	871	}
sl@0	872
sl@0	873	BN_init(&b);
sl@0	874	if(errno==ENOMEM)
sl@0	875	{
sl@0	876	return 0;
sl@0	877	}
sl@0	878
sl@0	879	BN_init(&c);
sl@0	880	if(errno==ENOMEM)
sl@0	881	{
sl@0	882	return 0;
sl@0	883	}
sl@0	884
sl@0	885	for (i=0; i<num0+num1; i++)
sl@0	886	{
sl@0	887	if (i < num1)
sl@0	888	{
sl@0	889	BN_bntest_rand(&a,512,0,0);
sl@0	890	if(errno==ENOMEM)
sl@0	891	{
sl@0	892	return 0;
sl@0	893	}
sl@0	894	BN_copy(&b,&a);
sl@0	895	if(errno==ENOMEM)
sl@0	896	{
sl@0	897	return 0;
sl@0	898	}
sl@0	899	if (BN_set_bit(&a,i)==0) return(0);
sl@0	900	if(errno==ENOMEM)
sl@0	901	{
sl@0	902	return 0;
sl@0	903	}
sl@0	904	BN_add_word(&b,i);
sl@0	905	if(errno==ENOMEM)
sl@0	906	{
sl@0	907	return 0;
sl@0	908	}
sl@0	909
sl@0	910	}
sl@0	911	else
sl@0	912	{
sl@0	913	BN_bntest_rand(&b,400+i-num1,0,0);
sl@0	914	if(errno==ENOMEM)
sl@0	915	{
sl@0	916	return 0;
sl@0	917	}
sl@0	918	a.neg=rand_neg();
sl@0	919	if(errno==ENOMEM)
sl@0	920	{
sl@0	921	return 0;
sl@0	922	}
sl@0	923	b.neg=rand_neg();
sl@0	924	if(errno==ENOMEM)
sl@0	925	{
sl@0	926	return 0;
sl@0	927	}
sl@0	928
sl@0	929	}
sl@0	930	BN_sub(&c,&a,&b);
sl@0	931	if(errno==ENOMEM)
sl@0	932	{
sl@0	933	return 0;
sl@0	934	}
sl@0	935
sl@0	936	if (bp != NULL)
sl@0	937	{
sl@0	938	if (!results)
sl@0	939	{
sl@0	940	BN_print(bp,&a);
sl@0	941	if(errno==ENOMEM)
sl@0	942	{
sl@0	943	return 0;
sl@0	944	}
sl@0	945
sl@0	946	BIO_puts(bp," - ");
sl@0	947	if(errno==ENOMEM)
sl@0	948	{
sl@0	949	return 0;
sl@0	950	}
sl@0	951
sl@0	952	BN_print(bp,&b);
sl@0	953	if(errno==ENOMEM)
sl@0	954	{
sl@0	955	return 0;
sl@0	956	}
sl@0	957
sl@0	958	BIO_puts(bp," - ");
sl@0	959	if(errno==ENOMEM)
sl@0	960	{
sl@0	961	return 0;
sl@0	962	}
sl@0	963
sl@0	964	}
sl@0	965	BN_print(bp,&c);
sl@0	966	if(errno==ENOMEM)
sl@0	967	{
sl@0	968	return 0;
sl@0	969	}
sl@0	970
sl@0	971	BIO_puts(bp,"\n");
sl@0	972	if(errno==ENOMEM)
sl@0	973	{
sl@0	974	return 0;
sl@0	975	}
sl@0	976
sl@0	977	}
sl@0	978	BN_add(&c,&c,&b);
sl@0	979	if(errno==ENOMEM)
sl@0	980	{
sl@0	981	return 0;
sl@0	982	}
sl@0	983
sl@0	984	BN_sub(&c,&c,&a);
sl@0	985	if(errno==ENOMEM)
sl@0	986	{
sl@0	987	return 0;
sl@0	988	}
sl@0	989
sl@0	990	if(!BN_is_zero(&c))
sl@0	991	{
sl@0	992	if(errno==ENOMEM)
sl@0	993	{
sl@0	994	return 0;
sl@0	995	}
sl@0	996
sl@0	997	fprintf(stderr,"Subtract test failed!\n");
sl@0	998	return 0;
sl@0	999	}
sl@0	1000	}
sl@0	1001	BN_free(&a);
sl@0	1002	if(errno==ENOMEM)
sl@0	1003	{
sl@0	1004	return 0;
sl@0	1005	}
sl@0	1006	BN_free(&b);
sl@0	1007	if(errno==ENOMEM)
sl@0	1008	{
sl@0	1009	return 0;
sl@0	1010	}
sl@0	1011	BN_free(&c);
sl@0	1012	if(errno==ENOMEM)
sl@0	1013	{
sl@0	1014	return 0;
sl@0	1015	}
sl@0	1016	return(1);
sl@0	1017	}
sl@0	1018
sl@0	1019	int test_div(BIO bp, BN_CTX ctx)
sl@0	1020	{
sl@0	1021	BIGNUM a,b,c,d,e;
sl@0	1022	int i;
sl@0	1023
sl@0	1024	BN_init(&a);
sl@0	1025	if(errno==ENOMEM)
sl@0	1026	{
sl@0	1027	return 0;
sl@0	1028	}
sl@0	1029
sl@0	1030	BN_init(&b);
sl@0	1031	if(errno==ENOMEM)
sl@0	1032	{
sl@0	1033	return 0;
sl@0	1034	}
sl@0	1035
sl@0	1036	BN_init(&c);
sl@0	1037	if(errno==ENOMEM)
sl@0	1038	{
sl@0	1039	return 0;
sl@0	1040	}
sl@0	1041
sl@0	1042	BN_init(&d);
sl@0	1043	if(errno==ENOMEM)
sl@0	1044	{
sl@0	1045	return 0;
sl@0	1046	}
sl@0	1047
sl@0	1048	BN_init(&e);
sl@0	1049	if(errno==ENOMEM)
sl@0	1050	{
sl@0	1051	return 0;
sl@0	1052	}
sl@0	1053
sl@0	1054
sl@0	1055	for (i=0; i<num0+num1; i++)
sl@0	1056	{
sl@0	1057	if (i < num1)
sl@0	1058	{
sl@0	1059	BN_bntest_rand(&a,400,0,0);
sl@0	1060	if(errno==ENOMEM)
sl@0	1061	{
sl@0	1062	return 0;
sl@0	1063	}
sl@0	1064
sl@0	1065	BN_copy(&b,&a);
sl@0	1066	if(errno==ENOMEM)
sl@0	1067	{
sl@0	1068	return 0;
sl@0	1069	}
sl@0	1070	BN_lshift(&a,&a,i);
sl@0	1071	if(errno==ENOMEM)
sl@0	1072	{
sl@0	1073	return 0;
sl@0	1074	}
sl@0	1075	BN_add_word(&a,i);
sl@0	1076	if(errno==ENOMEM)
sl@0	1077	{
sl@0	1078	return 0;
sl@0	1079	}
sl@0	1080	}
sl@0	1081	else
sl@0	1082	BN_bntest_rand(&b,50+3*(i-num1),0,0);
sl@0	1083	if(errno==ENOMEM)
sl@0	1084	{
sl@0	1085	return 0;
sl@0	1086	}
sl@0	1087
sl@0	1088	a.neg=rand_neg();
sl@0	1089	if(errno==ENOMEM)
sl@0	1090	{
sl@0	1091	return 0;
sl@0	1092	}
sl@0	1093	b.neg=rand_neg();
sl@0	1094	if(errno==ENOMEM)
sl@0	1095	{
sl@0	1096	return 0;
sl@0	1097	}
sl@0	1098	BN_div(&d,&c,&a,&b,ctx);
sl@0	1099	if(errno==ENOMEM)
sl@0	1100	{
sl@0	1101	return 0;
sl@0	1102	}
sl@0	1103	if (bp != NULL)
sl@0	1104	{
sl@0	1105	if (!results)
sl@0	1106	{
sl@0	1107	BN_print(bp,&a);
sl@0	1108	if(errno==ENOMEM)
sl@0	1109	{
sl@0	1110	return 0;
sl@0	1111	}
sl@0	1112	BIO_puts(bp," / ");
sl@0	1113	if(errno==ENOMEM)
sl@0	1114	{
sl@0	1115	return 0;
sl@0	1116	}
sl@0	1117
sl@0	1118	BN_print(bp,&b);
sl@0	1119	if(errno==ENOMEM)
sl@0	1120	{
sl@0	1121	return 0;
sl@0	1122	}
sl@0	1123
sl@0	1124	BIO_puts(bp," - ");
sl@0	1125	if(errno==ENOMEM)
sl@0	1126	{
sl@0	1127	return 0;
sl@0	1128	}
sl@0	1129
sl@0	1130	}
sl@0	1131	BN_print(bp,&d);
sl@0	1132	if(errno==ENOMEM)
sl@0	1133	{
sl@0	1134	return 0;
sl@0	1135	}
sl@0	1136
sl@0	1137	BIO_puts(bp,"\n");
sl@0	1138	if(errno==ENOMEM)
sl@0	1139	{
sl@0	1140	return 0;
sl@0	1141	}
sl@0	1142
sl@0	1143
sl@0	1144	if (!results)
sl@0	1145	{
sl@0	1146	BN_print(bp,&a);
sl@0	1147	if(errno==ENOMEM)
sl@0	1148	{
sl@0	1149	return 0;
sl@0	1150	}
sl@0	1151
sl@0	1152	BIO_puts(bp," % ");
sl@0	1153	if(errno==ENOMEM)
sl@0	1154	{
sl@0	1155	return 0;
sl@0	1156	}
sl@0	1157
sl@0	1158	BN_print(bp,&b);
sl@0	1159	if(errno==ENOMEM)
sl@0	1160	{
sl@0	1161	return 0;
sl@0	1162	}
sl@0	1163
sl@0	1164	BIO_puts(bp," - ");
sl@0	1165	if(errno==ENOMEM)
sl@0	1166	{
sl@0	1167	return 0;
sl@0	1168	}
sl@0	1169
sl@0	1170	}
sl@0	1171	BN_print(bp,&c);
sl@0	1172	if(errno==ENOMEM)
sl@0	1173	{
sl@0	1174	return 0;
sl@0	1175	}
sl@0	1176
sl@0	1177	BIO_puts(bp,"\n");
sl@0	1178	if(errno==ENOMEM)
sl@0	1179	{
sl@0	1180	return 0;
sl@0	1181	}
sl@0	1182
sl@0	1183	}
sl@0	1184	BN_mul(&e,&d,&b,ctx);
sl@0	1185	if(errno==ENOMEM)
sl@0	1186	{
sl@0	1187	return 0;
sl@0	1188	}
sl@0	1189
sl@0	1190	BN_add(&d,&e,&c);
sl@0	1191	if(errno==ENOMEM)
sl@0	1192	{
sl@0	1193	return 0;
sl@0	1194	}
sl@0	1195
sl@0	1196	BN_sub(&d,&d,&a);
sl@0	1197	if(errno==ENOMEM)
sl@0	1198	{
sl@0	1199	return 0;
sl@0	1200	}
sl@0	1201
sl@0	1202	if(!BN_is_zero(&d))
sl@0	1203	{
sl@0	1204	if(errno==ENOMEM)
sl@0	1205	{
sl@0	1206	return 0;
sl@0	1207	}
sl@0	1208
sl@0	1209	fprintf(stderr,"Division test failed!\n");
sl@0	1210	return 0;
sl@0	1211	}
sl@0	1212	}
sl@0	1213	BN_free(&a);
sl@0	1214	if(errno==ENOMEM)
sl@0	1215	{
sl@0	1216	return 0;
sl@0	1217	}
sl@0	1218
sl@0	1219	BN_free(&b);
sl@0	1220	if(errno==ENOMEM)
sl@0	1221	{
sl@0	1222	return 0;
sl@0	1223	}
sl@0	1224
sl@0	1225	BN_free(&c);
sl@0	1226	if(errno==ENOMEM)
sl@0	1227	{
sl@0	1228	return 0;
sl@0	1229	}
sl@0	1230
sl@0	1231	BN_free(&d);
sl@0	1232	if(errno==ENOMEM)
sl@0	1233	{
sl@0	1234	return 0;
sl@0	1235	}
sl@0	1236
sl@0	1237	BN_free(&e);
sl@0	1238	if(errno==ENOMEM)
sl@0	1239	{
sl@0	1240	return 0;
sl@0	1241	}
sl@0	1242
sl@0	1243	return(1);
sl@0	1244	}
sl@0	1245
sl@0	1246	static void print_word(BIO *bp,BN_ULONG w)
sl@0	1247	{
sl@0	1248	#ifdef SIXTY_FOUR_BIT
sl@0	1249	if (sizeof(w) > sizeof(unsigned long))
sl@0	1250	{
sl@0	1251	unsigned long h=(unsigned long)(w>>32),
sl@0	1252	l=(unsigned long)(w);
sl@0	1253
sl@0	1254	if (h) BIO_printf(bp,"%lX%08lX",h,l);
sl@0	1255	else BIO_printf(bp,"%lX",l);
sl@0	1256	return;
sl@0	1257	}
sl@0	1258	#endif
sl@0	1259	BIO_printf(bp,"%lX",w);
sl@0	1260	}
sl@0	1261
sl@0	1262	int test_div_word(BIO *bp)
sl@0	1263	{
sl@0	1264	BIGNUM a,b;
sl@0	1265	BN_ULONG r,s;
sl@0	1266	int i;
sl@0	1267
sl@0	1268	BN_init(&a);
sl@0	1269	if(errno==ENOMEM)
sl@0	1270	{
sl@0	1271	return 0;
sl@0	1272	}
sl@0	1273	BN_init(&b);
sl@0	1274	if(errno==ENOMEM)
sl@0	1275	{
sl@0	1276	return 0;
sl@0	1277	}
sl@0	1278
sl@0	1279
sl@0	1280	for (i=0; i<num0; i++)
sl@0	1281	{
sl@0	1282	do {
sl@0	1283	BN_bntest_rand(&a,512,-1,0);
sl@0	1284	if(errno==ENOMEM)
sl@0	1285	{
sl@0	1286	return 0;
sl@0	1287	}
sl@0	1288	BN_bntest_rand(&b,BN_BITS2,-1,0);
sl@0	1289	if(errno==ENOMEM)
sl@0	1290	{
sl@0	1291	return 0;
sl@0	1292	}
sl@0	1293	s = b.d[0];
sl@0	1294	} while (!s);
sl@0	1295
sl@0	1296	BN_copy(&b, &a);
sl@0	1297	if(errno==ENOMEM)
sl@0	1298	{
sl@0	1299	return 0;
sl@0	1300	}
sl@0	1301
sl@0	1302	r = BN_div_word(&b, s);
sl@0	1303	if(errno==ENOMEM)
sl@0	1304	{
sl@0	1305	return 0;
sl@0	1306	}
sl@0	1307
sl@0	1308	if (bp != NULL)
sl@0	1309	{
sl@0	1310	if (!results)
sl@0	1311	{
sl@0	1312	BN_print(bp,&a);
sl@0	1313	if(errno==ENOMEM)
sl@0	1314	{
sl@0	1315	return 0;
sl@0	1316	}
sl@0	1317
sl@0	1318	BIO_puts(bp," / ");
sl@0	1319	if(errno==ENOMEM)
sl@0	1320	{
sl@0	1321	return 0;
sl@0	1322	}
sl@0	1323
sl@0	1324	print_word(bp,s);
sl@0	1325	if(errno==ENOMEM)
sl@0	1326	{
sl@0	1327	return 0;
sl@0	1328	}
sl@0	1329
sl@0	1330	BIO_puts(bp," - ");
sl@0	1331	if(errno==ENOMEM)
sl@0	1332	{
sl@0	1333	return 0;
sl@0	1334	}
sl@0	1335
sl@0	1336	}
sl@0	1337	BN_print(bp,&b);
sl@0	1338	if(errno==ENOMEM)
sl@0	1339	{
sl@0	1340	return 0;
sl@0	1341	}
sl@0	1342
sl@0	1343	BIO_puts(bp,"\n");
sl@0	1344	if(errno==ENOMEM)
sl@0	1345	{
sl@0	1346	return 0;
sl@0	1347	}
sl@0	1348
sl@0	1349
sl@0	1350	if (!results)
sl@0	1351	{
sl@0	1352	BN_print(bp,&a);
sl@0	1353	if(errno==ENOMEM)
sl@0	1354	{
sl@0	1355	return 0;
sl@0	1356	}
sl@0	1357	BIO_puts(bp," % ");
sl@0	1358	if(errno==ENOMEM)
sl@0	1359	{
sl@0	1360	return 0;
sl@0	1361	}
sl@0	1362	print_word(bp,s);
sl@0	1363	if(errno==ENOMEM)
sl@0	1364	{
sl@0	1365	return 0;
sl@0	1366	}
sl@0	1367	BIO_puts(bp," - ");
sl@0	1368	if(errno==ENOMEM)
sl@0	1369	{
sl@0	1370	return 0;
sl@0	1371	}
sl@0	1372
sl@0	1373	}
sl@0	1374	print_word(bp,r);
sl@0	1375	if(errno==ENOMEM)
sl@0	1376	{
sl@0	1377	return 0;
sl@0	1378	}
sl@0	1379
sl@0	1380	BIO_puts(bp,"\n");
sl@0	1381	if(errno==ENOMEM)
sl@0	1382	{
sl@0	1383	return 0;
sl@0	1384	}
sl@0	1385
sl@0	1386	}
sl@0	1387	BN_mul_word(&b,s);
sl@0	1388	if(errno==ENOMEM)
sl@0	1389	{
sl@0	1390	return 0;
sl@0	1391	}
sl@0	1392	BN_add_word(&b,r);
sl@0	1393	if(errno==ENOMEM)
sl@0	1394	{
sl@0	1395	return 0;
sl@0	1396	}
sl@0	1397
sl@0	1398	BN_sub(&b,&a,&b);
sl@0	1399	if(errno==ENOMEM)
sl@0	1400	{
sl@0	1401	return 0;
sl@0	1402	}
sl@0	1403
sl@0	1404	if(!BN_is_zero(&b))
sl@0	1405	{
sl@0	1406	if(errno==ENOMEM)
sl@0	1407	{
sl@0	1408	return 0;
sl@0	1409	}
sl@0	1410	fprintf(stderr,"Division (word) test failed!\n");
sl@0	1411	return 0;
sl@0	1412	}
sl@0	1413	}
sl@0	1414	BN_free(&a);
sl@0	1415	if(errno==ENOMEM)
sl@0	1416	{
sl@0	1417	return 0;
sl@0	1418	}
sl@0	1419
sl@0	1420	BN_free(&b);
sl@0	1421	if(errno==ENOMEM)
sl@0	1422	{
sl@0	1423	return 0;
sl@0	1424	}
sl@0	1425
sl@0	1426	return(1);
sl@0	1427	}
sl@0	1428
sl@0	1429	int test_div_recp(BIO bp, BN_CTX ctx)
sl@0	1430	{
sl@0	1431	BIGNUM a,b,c,d,e;
sl@0	1432	BN_RECP_CTX recp;
sl@0	1433	int i;
sl@0	1434
sl@0	1435	BN_RECP_CTX_init(&recp);
sl@0	1436	if(errno==ENOMEM)
sl@0	1437	{
sl@0	1438	return 0;
sl@0	1439	}
sl@0	1440
sl@0	1441	BN_init(&a);
sl@0	1442	if(errno==ENOMEM)
sl@0	1443	{
sl@0	1444	return 0;
sl@0	1445	}
sl@0	1446
sl@0	1447	BN_init(&b);
sl@0	1448	if(errno==ENOMEM)
sl@0	1449	{
sl@0	1450	return 0;
sl@0	1451	}
sl@0	1452
sl@0	1453	BN_init(&c);
sl@0	1454	if(errno==ENOMEM)
sl@0	1455	{
sl@0	1456	return 0;
sl@0	1457	}
sl@0	1458
sl@0	1459	BN_init(&d);
sl@0	1460	if(errno==ENOMEM)
sl@0	1461	{
sl@0	1462	return 0;
sl@0	1463	}
sl@0	1464
sl@0	1465	BN_init(&e);
sl@0	1466	if(errno==ENOMEM)
sl@0	1467	{
sl@0	1468	return 0;
sl@0	1469	}
sl@0	1470
sl@0	1471
sl@0	1472	for (i=0; i<num0+num1; i++)
sl@0	1473	{
sl@0	1474	if (i < num1)
sl@0	1475	{
sl@0	1476	BN_bntest_rand(&a,400,0,0);
sl@0	1477	if(errno==ENOMEM)
sl@0	1478	{
sl@0	1479	return 0;
sl@0	1480	}
sl@0	1481	BN_copy(&b,&a);
sl@0	1482	if(errno==ENOMEM)
sl@0	1483	{
sl@0	1484	return 0;
sl@0	1485	}
sl@0	1486	BN_lshift(&a,&a,i);
sl@0	1487	if(errno==ENOMEM)
sl@0	1488	{
sl@0	1489	return 0;
sl@0	1490	}
sl@0	1491	BN_add_word(&a,i);
sl@0	1492	if(errno==ENOMEM)
sl@0	1493	{
sl@0	1494	return 0;
sl@0	1495	}
sl@0	1496
sl@0	1497	}
sl@0	1498	else
sl@0	1499	BN_bntest_rand(&b,50+3*(i-num1),0,0);
sl@0	1500	if(errno==ENOMEM)
sl@0	1501	{
sl@0	1502	return 0;
sl@0	1503	}
sl@0	1504
sl@0	1505	a.neg=rand_neg();
sl@0	1506	if(errno==ENOMEM)
sl@0	1507	{
sl@0	1508	return 0;
sl@0	1509	}
sl@0	1510
sl@0	1511	b.neg=rand_neg();
sl@0	1512	if(errno==ENOMEM)
sl@0	1513	{
sl@0	1514	return 0;
sl@0	1515	}
sl@0	1516
sl@0	1517	BN_RECP_CTX_set(&recp,&b,ctx);
sl@0	1518	if(errno==ENOMEM)
sl@0	1519	{
sl@0	1520	return 0;
sl@0	1521	}
sl@0	1522
sl@0	1523	BN_div_recp(&d,&c,&a,&recp,ctx);
sl@0	1524	if(errno==ENOMEM)
sl@0	1525	{
sl@0	1526	return 0;
sl@0	1527	}
sl@0	1528
sl@0	1529	if (bp != NULL)
sl@0	1530	{
sl@0	1531	if (!results)
sl@0	1532	{
sl@0	1533	BN_print(bp,&a);
sl@0	1534	if(errno==ENOMEM)
sl@0	1535	{
sl@0	1536	return 0;
sl@0	1537	}
sl@0	1538
sl@0	1539	BIO_puts(bp," / ");
sl@0	1540	if(errno==ENOMEM)
sl@0	1541	{
sl@0	1542	return 0;
sl@0	1543	}
sl@0	1544
sl@0	1545	BN_print(bp,&b);
sl@0	1546	if(errno==ENOMEM)
sl@0	1547	{
sl@0	1548	return 0;
sl@0	1549	}
sl@0	1550
sl@0	1551	BIO_puts(bp," - ");
sl@0	1552	if(errno==ENOMEM)
sl@0	1553	{
sl@0	1554	return 0;
sl@0	1555	}
sl@0	1556
sl@0	1557	}
sl@0	1558	BN_print(bp,&d);
sl@0	1559	if(errno==ENOMEM)
sl@0	1560	{
sl@0	1561	return 0;
sl@0	1562	}
sl@0	1563
sl@0	1564	BIO_puts(bp,"\n");
sl@0	1565	if(errno==ENOMEM)
sl@0	1566	{
sl@0	1567	return 0;
sl@0	1568	}
sl@0	1569
sl@0	1570
sl@0	1571	if (!results)
sl@0	1572	{
sl@0	1573	BN_print(bp,&a);
sl@0	1574	if(errno==ENOMEM)
sl@0	1575	{
sl@0	1576	return 0;
sl@0	1577	}
sl@0	1578
sl@0	1579	BIO_puts(bp," % ");
sl@0	1580	if(errno==ENOMEM)
sl@0	1581	{
sl@0	1582	return 0;
sl@0	1583	}
sl@0	1584
sl@0	1585	BN_print(bp,&b);
sl@0	1586	if(errno==ENOMEM)
sl@0	1587	{
sl@0	1588	return 0;
sl@0	1589	}
sl@0	1590	BIO_puts(bp," - ");
sl@0	1591	if(errno==ENOMEM)
sl@0	1592	{
sl@0	1593	return 0;
sl@0	1594	}
sl@0	1595
sl@0	1596	}
sl@0	1597	BN_print(bp,&c);
sl@0	1598	if(errno==ENOMEM)
sl@0	1599	{
sl@0	1600	return 0;
sl@0	1601	}
sl@0	1602
sl@0	1603	BIO_puts(bp,"\n");
sl@0	1604	if(errno==ENOMEM)
sl@0	1605	{
sl@0	1606	return 0;
sl@0	1607	}
sl@0	1608
sl@0	1609	}
sl@0	1610	BN_mul(&e,&d,&b,ctx);
sl@0	1611	if(errno==ENOMEM)
sl@0	1612	{
sl@0	1613	return 0;
sl@0	1614	}
sl@0	1615
sl@0	1616	BN_add(&d,&e,&c);
sl@0	1617	if(errno==ENOMEM)
sl@0	1618	{
sl@0	1619	return 0;
sl@0	1620	}
sl@0	1621
sl@0	1622	BN_sub(&d,&d,&a);
sl@0	1623	if(errno==ENOMEM)
sl@0	1624	{
sl@0	1625	return 0;
sl@0	1626	}
sl@0	1627
sl@0	1628	if(!BN_is_zero(&d))
sl@0	1629	{
sl@0	1630	if(errno==ENOMEM)
sl@0	1631	{
sl@0	1632	return 0;
sl@0	1633	}
sl@0	1634	fprintf(stderr,"Reciprocal division test failed!\n");
sl@0	1635	fprintf(stderr,"a=");
sl@0	1636	BN_print_fp(stderr,&a);
sl@0	1637	if(errno==ENOMEM)
sl@0	1638	{
sl@0	1639	return 0;
sl@0	1640	}
sl@0	1641
sl@0	1642	fprintf(stderr,"\nb=");
sl@0	1643	BN_print_fp(stderr,&b);
sl@0	1644	if(errno==ENOMEM)
sl@0	1645	{
sl@0	1646	return 0;
sl@0	1647	}
sl@0	1648
sl@0	1649	fprintf(stderr,"\n");
sl@0	1650	return 0;
sl@0	1651	}
sl@0	1652	}
sl@0	1653	BN_free(&a);
sl@0	1654	if(errno==ENOMEM)
sl@0	1655	{
sl@0	1656	return 0;
sl@0	1657	}
sl@0	1658	BN_free(&b);
sl@0	1659	if(errno==ENOMEM)
sl@0	1660	{
sl@0	1661	return 0;
sl@0	1662	}
sl@0	1663
sl@0	1664	BN_free(&c);
sl@0	1665	if(errno==ENOMEM)
sl@0	1666	{
sl@0	1667	return 0;
sl@0	1668	}
sl@0	1669
sl@0	1670	BN_free(&d);
sl@0	1671	if(errno==ENOMEM)
sl@0	1672	{
sl@0	1673	return 0;
sl@0	1674	}
sl@0	1675
sl@0	1676	BN_free(&e);
sl@0	1677	if(errno==ENOMEM)
sl@0	1678	{
sl@0	1679	return 0;
sl@0	1680	}
sl@0	1681
sl@0	1682	BN_RECP_CTX_free(&recp);
sl@0	1683	if(errno==ENOMEM)
sl@0	1684	{
sl@0	1685	return 0;
sl@0	1686	}
sl@0	1687
sl@0	1688	return(1);
sl@0	1689	}
sl@0	1690
sl@0	1691	int test_mul(BIO *bp)
sl@0	1692	{
sl@0	1693	BIGNUM a,b,c,d,e;
sl@0	1694	int i;
sl@0	1695	BN_CTX *ctx;
sl@0	1696
sl@0	1697	ctx = BN_CTX_new();
sl@0	1698	if (ctx == NULL)
sl@0	1699	return 1;
sl@0	1700
sl@0	1701	BN_init(&a);
sl@0	1702	if(errno==ENOMEM)
sl@0	1703	{
sl@0	1704	return 0;
sl@0	1705	}
sl@0	1706	BN_init(&b);
sl@0	1707	if(errno==ENOMEM)
sl@0	1708	{
sl@0	1709	return 0;
sl@0	1710	}
sl@0	1711	BN_init(&c);
sl@0	1712	if(errno==ENOMEM)
sl@0	1713	{
sl@0	1714	return 0;
sl@0	1715	}
sl@0	1716	BN_init(&d);
sl@0	1717	if(errno==ENOMEM)
sl@0	1718	{
sl@0	1719	return 0;
sl@0	1720	}
sl@0	1721	BN_init(&e);
sl@0	1722	if(errno==ENOMEM)
sl@0	1723	{
sl@0	1724	return 0;
sl@0	1725	}
sl@0	1726
sl@0	1727	for (i=0; i<num0+num1; i++)
sl@0	1728	{
sl@0	1729	if (i <= num1)
sl@0	1730	{
sl@0	1731	BN_bntest_rand(&a,100,0,0);
sl@0	1732	if(errno==ENOMEM)
sl@0	1733	{
sl@0	1734	return 0;
sl@0	1735	}
sl@0	1736	BN_bntest_rand(&b,100,0,0);
sl@0	1737	if(errno==ENOMEM)
sl@0	1738	{
sl@0	1739	return 0;
sl@0	1740	}
sl@0	1741	}
sl@0	1742	else
sl@0	1743	BN_bntest_rand(&b,i-num1,0,0);
sl@0	1744	if(errno==ENOMEM)
sl@0	1745	{
sl@0	1746	return 0;
sl@0	1747	}
sl@0	1748	a.neg=rand_neg();
sl@0	1749	if(errno==ENOMEM)
sl@0	1750	{
sl@0	1751	return 0;
sl@0	1752	}
sl@0	1753	b.neg=rand_neg();
sl@0	1754	if(errno==ENOMEM)
sl@0	1755	{
sl@0	1756	return 0;
sl@0	1757	}
sl@0	1758	BN_mul(&c,&a,&b,ctx);
sl@0	1759	if(errno==ENOMEM)
sl@0	1760	{
sl@0	1761	return 0;
sl@0	1762	}
sl@0	1763	if (bp != NULL)
sl@0	1764	{
sl@0	1765	if (!results)
sl@0	1766	{
sl@0	1767	BN_print(bp,&a);
sl@0	1768	if(errno==ENOMEM)
sl@0	1769	{
sl@0	1770	return 0;
sl@0	1771	}
sl@0	1772	BIO_puts(bp," * ");
sl@0	1773	if(errno==ENOMEM)
sl@0	1774	{
sl@0	1775	return 0;
sl@0	1776	}
sl@0	1777	BN_print(bp,&b);
sl@0	1778	if(errno==ENOMEM)
sl@0	1779	{
sl@0	1780	return 0;
sl@0	1781	}
sl@0	1782	BIO_puts(bp," - ");
sl@0	1783	if(errno==ENOMEM)
sl@0	1784	{
sl@0	1785	return 0;
sl@0	1786	}
sl@0	1787	}
sl@0	1788	BN_print(bp,&c);
sl@0	1789	if(errno==ENOMEM)
sl@0	1790	{
sl@0	1791	return 0;
sl@0	1792	}
sl@0	1793	BIO_puts(bp,"\n");
sl@0	1794	if(errno==ENOMEM)
sl@0	1795	{
sl@0	1796	return 0;
sl@0	1797	}
sl@0	1798	}
sl@0	1799	BN_div(&d,&e,&c,&a,ctx);
sl@0	1800	if(errno==ENOMEM)
sl@0	1801	{
sl@0	1802	return 0;
sl@0	1803	}
sl@0	1804	BN_sub(&d,&d,&b);
sl@0	1805	if(errno==ENOMEM)
sl@0	1806	{
sl@0	1807	return 0;
sl@0	1808	}
sl@0	1809	if(!BN_is_zero(&d) \|\| !BN_is_zero(&e))
sl@0	1810	{
sl@0	1811	if(errno==ENOMEM)
sl@0	1812	{
sl@0	1813	return 0;
sl@0	1814	}
sl@0	1815	fprintf(stderr,"Multiplication test failed!\n");
sl@0	1816	return 0;
sl@0	1817	}
sl@0	1818	}
sl@0	1819	BN_free(&a);
sl@0	1820	if(errno==ENOMEM)
sl@0	1821	{
sl@0	1822	return 0;
sl@0	1823	}
sl@0	1824	BN_free(&b);
sl@0	1825	if(errno==ENOMEM)
sl@0	1826	{
sl@0	1827	return 0;
sl@0	1828	}
sl@0	1829	BN_free(&c);
sl@0	1830	if(errno==ENOMEM)
sl@0	1831	{
sl@0	1832	return 0;
sl@0	1833	}
sl@0	1834	BN_free(&d);
sl@0	1835	if(errno==ENOMEM)
sl@0	1836	{
sl@0	1837	return 0;
sl@0	1838	}
sl@0	1839	BN_free(&e);
sl@0	1840	if(errno==ENOMEM)
sl@0	1841	{
sl@0	1842	return 0;
sl@0	1843	}
sl@0	1844	BN_CTX_free(ctx);
sl@0	1845	if(errno==ENOMEM)
sl@0	1846	{
sl@0	1847	return 0;
sl@0	1848	}
sl@0	1849	return(1);
sl@0	1850	}
sl@0	1851
sl@0	1852	int test_sqr(BIO bp, BN_CTX ctx)
sl@0	1853	{
sl@0	1854	BIGNUM a,c,d,e;
sl@0	1855	int i;
sl@0	1856
sl@0	1857	BN_init(&a);
sl@0	1858	if(errno==ENOMEM)
sl@0	1859	{
sl@0	1860	return 0;
sl@0	1861	}
sl@0	1862	BN_init(&c);
sl@0	1863	if(errno==ENOMEM)
sl@0	1864	{
sl@0	1865	return 0;
sl@0	1866	}
sl@0	1867	BN_init(&d);
sl@0	1868	if(errno==ENOMEM)
sl@0	1869	{
sl@0	1870	return 0;
sl@0	1871	}
sl@0	1872	BN_init(&e);
sl@0	1873	if(errno==ENOMEM)
sl@0	1874	{
sl@0	1875	return 0;
sl@0	1876	}
sl@0	1877
sl@0	1878	for (i=0; i<num0; i++)
sl@0	1879	{
sl@0	1880	BN_bntest_rand(&a,40+i*10,0,0);
sl@0	1881	if(errno==ENOMEM)
sl@0	1882	{
sl@0	1883	return 0;
sl@0	1884	}
sl@0	1885	a.neg=rand_neg();
sl@0	1886	if(errno==ENOMEM)
sl@0	1887	{
sl@0	1888	return 0;
sl@0	1889	}
sl@0	1890	BN_sqr(&c,&a,ctx);
sl@0	1891	if(errno==ENOMEM)
sl@0	1892	{
sl@0	1893	return 0;
sl@0	1894	}
sl@0	1895	if (bp != NULL)
sl@0	1896	{
sl@0	1897	if (!results)
sl@0	1898	{
sl@0	1899	BN_print(bp,&a);
sl@0	1900	if(errno==ENOMEM)
sl@0	1901	{
sl@0	1902	return 0;
sl@0	1903	}
sl@0	1904	BIO_puts(bp," * ");
sl@0	1905	if(errno==ENOMEM)
sl@0	1906	{
sl@0	1907	return 0;
sl@0	1908	}
sl@0	1909	BN_print(bp,&a);
sl@0	1910	if(errno==ENOMEM)
sl@0	1911	{
sl@0	1912	return 0;
sl@0	1913	}
sl@0	1914	BIO_puts(bp," - ");
sl@0	1915	if(errno==ENOMEM)
sl@0	1916	{
sl@0	1917	return 0;
sl@0	1918	}
sl@0	1919	}
sl@0	1920	BN_print(bp,&c);
sl@0	1921	if(errno==ENOMEM)
sl@0	1922	{
sl@0	1923	return 0;
sl@0	1924	}
sl@0	1925	BIO_puts(bp,"\n");
sl@0	1926	if(errno==ENOMEM)
sl@0	1927	{
sl@0	1928	return 0;
sl@0	1929	}
sl@0	1930	}
sl@0	1931	BN_div(&d,&e,&c,&a,ctx);
sl@0	1932	if(errno==ENOMEM)
sl@0	1933	{
sl@0	1934	return 0;
sl@0	1935	}
sl@0	1936	BN_sub(&d,&d,&a);
sl@0	1937	if(errno==ENOMEM)
sl@0	1938	{
sl@0	1939	return 0;
sl@0	1940	}
sl@0	1941	if(!BN_is_zero(&d) \|\| !BN_is_zero(&e))
sl@0	1942	{
sl@0	1943	if(errno==ENOMEM)
sl@0	1944	{
sl@0	1945	return 0;
sl@0	1946	}
sl@0	1947	fprintf(stderr,"Square test failed!\n");
sl@0	1948	return 0;
sl@0	1949	}
sl@0	1950	}
sl@0	1951	BN_free(&a);
sl@0	1952	if(errno==ENOMEM)
sl@0	1953	{
sl@0	1954	return 0;
sl@0	1955	}
sl@0	1956	BN_free(&c);
sl@0	1957	if(errno==ENOMEM)
sl@0	1958	{
sl@0	1959	return 0;
sl@0	1960	}
sl@0	1961	BN_free(&d);
sl@0	1962	if(errno==ENOMEM)
sl@0	1963	{
sl@0	1964	return 0;
sl@0	1965	}
sl@0	1966	BN_free(&e);
sl@0	1967	if(errno==ENOMEM)
sl@0	1968	{
sl@0	1969	return 0;
sl@0	1970	}
sl@0	1971	return(1);
sl@0	1972	}
sl@0	1973
sl@0	1974	int test_mont(BIO bp, BN_CTX ctx)
sl@0	1975	{
sl@0	1976	BIGNUM a,b,c,d,A,B;
sl@0	1977	BIGNUM n;
sl@0	1978	int i;
sl@0	1979	BN_MONT_CTX *mont;
sl@0	1980
sl@0	1981	BN_init(&a);
sl@0	1982	if(errno==ENOMEM)
sl@0	1983	{
sl@0	1984	return 0;
sl@0	1985	}
sl@0	1986	BN_init(&b);
sl@0	1987	if(errno==ENOMEM)
sl@0	1988	{
sl@0	1989	return 0;
sl@0	1990	}
sl@0	1991	BN_init(&c);
sl@0	1992	if(errno==ENOMEM)
sl@0	1993	{
sl@0	1994	return 0;
sl@0	1995	}
sl@0	1996	BN_init(&d);
sl@0	1997	if(errno==ENOMEM)
sl@0	1998	{
sl@0	1999	return 0;
sl@0	2000	}
sl@0	2001	BN_init(&A);
sl@0	2002	if(errno==ENOMEM)
sl@0	2003	{
sl@0	2004	return 0;
sl@0	2005	}
sl@0	2006	BN_init(&B);
sl@0	2007	if(errno==ENOMEM)
sl@0	2008	{
sl@0	2009	return 0;
sl@0	2010	}
sl@0	2011	BN_init(&n);
sl@0	2012	if(errno==ENOMEM)
sl@0	2013	{
sl@0	2014	return 0;
sl@0	2015	}
sl@0	2016
sl@0	2017	mont=BN_MONT_CTX_new();
sl@0	2018	if(errno==ENOMEM)
sl@0	2019	{
sl@0	2020	return 0;
sl@0	2021	}
sl@0	2022
sl@0	2023	BN_bntest_rand(&a,100,0,0); /**/
sl@0	2024	if(errno==ENOMEM)
sl@0	2025	{
sl@0	2026	return 0;
sl@0	2027	}
sl@0	2028	BN_bntest_rand(&b,100,0,0); /**/
sl@0	2029	if(errno==ENOMEM)
sl@0	2030	{
sl@0	2031	return 0;
sl@0	2032	}
sl@0	2033	for (i=0; i<num2; i++)
sl@0	2034	{
sl@0	2035	int bits = (200*(i+1))/num2;
sl@0	2036
sl@0	2037	if (bits == 0)
sl@0	2038	continue;
sl@0	2039	BN_bntest_rand(&n,bits,0,1);
sl@0	2040	if(errno==ENOMEM)
sl@0	2041	{
sl@0	2042	return 0;
sl@0	2043	}
sl@0	2044	BN_MONT_CTX_set(mont,&n,ctx);
sl@0	2045	if(errno==ENOMEM)
sl@0	2046	{
sl@0	2047	return 0;
sl@0	2048	}
sl@0	2049
sl@0	2050	BN_nnmod(&a,&a,&n,ctx);
sl@0	2051	if(errno==ENOMEM)
sl@0	2052	{
sl@0	2053	return 0;
sl@0	2054	}
sl@0	2055	BN_nnmod(&b,&b,&n,ctx);
sl@0	2056	if(errno==ENOMEM)
sl@0	2057	{
sl@0	2058	return 0;
sl@0	2059	}
sl@0	2060
sl@0	2061	BN_to_montgomery(&A,&a,mont,ctx);
sl@0	2062	if(errno==ENOMEM)
sl@0	2063	{
sl@0	2064	return 0;
sl@0	2065	}
sl@0	2066	BN_to_montgomery(&B,&b,mont,ctx);
sl@0	2067	if(errno==ENOMEM)
sl@0	2068	{
sl@0	2069	return 0;
sl@0	2070	}
sl@0	2071
sl@0	2072	BN_mod_mul_montgomery(&c,&A,&B,mont,ctx);/**/
sl@0	2073	if(errno==ENOMEM)
sl@0	2074	{
sl@0	2075	return 0;
sl@0	2076	}
sl@0	2077	BN_from_montgomery(&A,&c,mont,ctx);/**/
sl@0	2078	if(errno==ENOMEM)
sl@0	2079	{
sl@0	2080	return 0;
sl@0	2081	}
sl@0	2082	if (bp != NULL)
sl@0	2083	{
sl@0	2084	if (!results)
sl@0	2085	{
sl@0	2086	#ifdef undef
sl@0	2087	fprintf(stderr,"%d * %d %% %d\n",
sl@0	2088	BN_num_bits(&a),
sl@0	2089	BN_num_bits(&b),
sl@0	2090	BN_num_bits(mont->N));
sl@0	2091	#endif
sl@0	2092	BN_print(bp,&a);
sl@0	2093	if(errno==ENOMEM)
sl@0	2094	{
sl@0	2095	return 0;
sl@0	2096	}
sl@0	2097	BIO_puts(bp," * ");
sl@0	2098	if(errno==ENOMEM)
sl@0	2099	{
sl@0	2100	return 0;
sl@0	2101	}
sl@0	2102	BN_print(bp,&b);
sl@0	2103	if(errno==ENOMEM)
sl@0	2104	{
sl@0	2105	return 0;
sl@0	2106	}
sl@0	2107	BIO_puts(bp," % ");
sl@0	2108	if(errno==ENOMEM)
sl@0	2109	{
sl@0	2110	return 0;
sl@0	2111	}
sl@0	2112	BN_print(bp,&(mont->N));
sl@0	2113	if(errno==ENOMEM)
sl@0	2114	{
sl@0	2115	return 0;
sl@0	2116	}
sl@0	2117	BIO_puts(bp," - ");
sl@0	2118	if(errno==ENOMEM)
sl@0	2119	{
sl@0	2120	return 0;
sl@0	2121	}
sl@0	2122	}
sl@0	2123	BN_print(bp,&A);
sl@0	2124	if(errno==ENOMEM)
sl@0	2125	{
sl@0	2126	return 0;
sl@0	2127	}
sl@0	2128	BIO_puts(bp,"\n");
sl@0	2129	if(errno==ENOMEM)
sl@0	2130	{
sl@0	2131	return 0;
sl@0	2132	}
sl@0	2133	}
sl@0	2134	BN_mod_mul(&d,&a,&b,&n,ctx);
sl@0	2135	if(errno==ENOMEM)
sl@0	2136	{
sl@0	2137	return 0;
sl@0	2138	}
sl@0	2139	BN_sub(&d,&d,&A);
sl@0	2140	if(errno==ENOMEM)
sl@0	2141	{
sl@0	2142	return 0;
sl@0	2143	}
sl@0	2144	if(!BN_is_zero(&d))
sl@0	2145	{
sl@0	2146	if(errno==ENOMEM)
sl@0	2147	{
sl@0	2148	return 0;
sl@0	2149	}
sl@0	2150	fprintf(stderr,"Montgomery multiplication test failed!\n");
sl@0	2151	return 0;
sl@0	2152	}
sl@0	2153	}
sl@0	2154	BN_MONT_CTX_free(mont);
sl@0	2155	if(errno==ENOMEM)
sl@0	2156	{
sl@0	2157	return 0;
sl@0	2158	}
sl@0	2159	BN_free(&a);
sl@0	2160	if(errno==ENOMEM)
sl@0	2161	{
sl@0	2162	return 0;
sl@0	2163	}
sl@0	2164	BN_free(&b);
sl@0	2165	if(errno==ENOMEM)
sl@0	2166	{
sl@0	2167	return 0;
sl@0	2168	}
sl@0	2169	BN_free(&c);
sl@0	2170	if(errno==ENOMEM)
sl@0	2171	{
sl@0	2172	return 0;
sl@0	2173	}
sl@0	2174	BN_free(&d);
sl@0	2175	if(errno==ENOMEM)
sl@0	2176	{
sl@0	2177	return 0;
sl@0	2178	}
sl@0	2179	BN_free(&A);
sl@0	2180	if(errno==ENOMEM)
sl@0	2181	{
sl@0	2182	return 0;
sl@0	2183	}
sl@0	2184	BN_free(&B);
sl@0	2185	if(errno==ENOMEM)
sl@0	2186	{
sl@0	2187	return 0;
sl@0	2188	}
sl@0	2189	BN_free(&n);
sl@0	2190	if(errno==ENOMEM)
sl@0	2191	{
sl@0	2192	return 0;
sl@0	2193	}
sl@0	2194	return(1);
sl@0	2195	}
sl@0	2196
sl@0	2197	int test_mod(BIO bp, BN_CTX ctx)
sl@0	2198	{
sl@0	2199	BIGNUM a,b,c,d,*e;
sl@0	2200	int i;
sl@0	2201
sl@0	2202	a=BN_new();
sl@0	2203	if(errno==ENOMEM)
sl@0	2204	{
sl@0	2205	return 0;
sl@0	2206	}
sl@0	2207	b=BN_new();
sl@0	2208	if(errno==ENOMEM)
sl@0	2209	{
sl@0	2210	return 0;
sl@0	2211	}
sl@0	2212	c=BN_new();
sl@0	2213	if(errno==ENOMEM)
sl@0	2214	{
sl@0	2215	return 0;
sl@0	2216	}
sl@0	2217	d=BN_new();
sl@0	2218	if(errno==ENOMEM)
sl@0	2219	{
sl@0	2220	return 0;
sl@0	2221	}
sl@0	2222	e=BN_new();
sl@0	2223	if(errno==ENOMEM)
sl@0	2224	{
sl@0	2225	return 0;
sl@0	2226	}
sl@0	2227
sl@0	2228	BN_bntest_rand(a,1024,0,0); /**/
sl@0	2229	if(errno==ENOMEM)
sl@0	2230	{
sl@0	2231	return 0;
sl@0	2232	}
sl@0	2233	for (i=0; i<num0; i++)
sl@0	2234	{
sl@0	2235	BN_bntest_rand(b,450+i10,0,0); /*/
sl@0	2236	if(errno==ENOMEM)
sl@0	2237	{
sl@0	2238	return 0;
sl@0	2239	}
sl@0	2240	a->neg=rand_neg();
sl@0	2241	if(errno==ENOMEM)
sl@0	2242	{
sl@0	2243	return 0;
sl@0	2244	}
sl@0	2245	b->neg=rand_neg();
sl@0	2246	if(errno==ENOMEM)
sl@0	2247	{
sl@0	2248	return 0;
sl@0	2249	}
sl@0	2250	BN_mod(c,a,b,ctx);/**/
sl@0	2251	if(errno==ENOMEM)
sl@0	2252	{
sl@0	2253	return 0;
sl@0	2254	}
sl@0	2255	if (bp != NULL)
sl@0	2256	{
sl@0	2257	if (!results)
sl@0	2258	{
sl@0	2259	BN_print(bp,a);
sl@0	2260	if(errno==ENOMEM)
sl@0	2261	{
sl@0	2262	return 0;
sl@0	2263	}
sl@0	2264	BIO_puts(bp," % ");
sl@0	2265	if(errno==ENOMEM)
sl@0	2266	{
sl@0	2267	return 0;
sl@0	2268	}
sl@0	2269	BN_print(bp,b);
sl@0	2270	if(errno==ENOMEM)
sl@0	2271	{
sl@0	2272	return 0;
sl@0	2273	}
sl@0	2274	BIO_puts(bp," - ");
sl@0	2275	if(errno==ENOMEM)
sl@0	2276	{
sl@0	2277	return 0;
sl@0	2278	}
sl@0	2279	}
sl@0	2280	BN_print(bp,c);
sl@0	2281	if(errno==ENOMEM)
sl@0	2282	{
sl@0	2283	return 0;
sl@0	2284	}
sl@0	2285	BIO_puts(bp,"\n");
sl@0	2286	if(errno==ENOMEM)
sl@0	2287	{
sl@0	2288	return 0;
sl@0	2289	}
sl@0	2290	}
sl@0	2291	BN_div(d,e,a,b,ctx);
sl@0	2292	if(errno==ENOMEM)
sl@0	2293	{
sl@0	2294	return 0;
sl@0	2295	}
sl@0	2296	BN_sub(e,e,c);
sl@0	2297	if(errno==ENOMEM)
sl@0	2298	{
sl@0	2299	return 0;
sl@0	2300	}
sl@0	2301	if(!BN_is_zero(e))
sl@0	2302	{
sl@0	2303	if(errno==ENOMEM)
sl@0	2304	{
sl@0	2305	return 0;
sl@0	2306	}
sl@0	2307	fprintf(stderr,"Modulo test failed!\n");
sl@0	2308	return 0;
sl@0	2309	}
sl@0	2310	}
sl@0	2311	BN_free(a);
sl@0	2312	if(errno==ENOMEM)
sl@0	2313	{
sl@0	2314	return 0;
sl@0	2315	}
sl@0	2316	BN_free(b);
sl@0	2317	if(errno==ENOMEM)
sl@0	2318	{
sl@0	2319	return 0;
sl@0	2320	}
sl@0	2321	BN_free(c);
sl@0	2322	if(errno==ENOMEM)
sl@0	2323	{
sl@0	2324	return 0;
sl@0	2325	}
sl@0	2326	BN_free(d);
sl@0	2327	if(errno==ENOMEM)
sl@0	2328	{
sl@0	2329	return 0;
sl@0	2330	}
sl@0	2331	BN_free(e);
sl@0	2332	if(errno==ENOMEM)
sl@0	2333	{
sl@0	2334	return 0;
sl@0	2335	}
sl@0	2336	return(1);
sl@0	2337	}
sl@0	2338
sl@0	2339	int test_mod_mul(BIO bp, BN_CTX ctx)
sl@0	2340	{
sl@0	2341	BIGNUM a,b,c,d,*e;
sl@0	2342	int i,j;
sl@0	2343	unsigned long l;
sl@0	2344
sl@0	2345	a=BN_new();
sl@0	2346	if(errno==ENOMEM)
sl@0	2347	{
sl@0	2348	return 0;
sl@0	2349	}
sl@0	2350	b=BN_new();
sl@0	2351	if(errno==ENOMEM)
sl@0	2352	{
sl@0	2353	return 0;
sl@0	2354	}
sl@0	2355	c=BN_new();
sl@0	2356	if(errno==ENOMEM)
sl@0	2357	{
sl@0	2358	return 0;
sl@0	2359	}
sl@0	2360	d=BN_new();
sl@0	2361	if(errno==ENOMEM)
sl@0	2362	{
sl@0	2363	return 0;
sl@0	2364	}
sl@0	2365	e=BN_new();
sl@0	2366	if(errno==ENOMEM)
sl@0	2367	{
sl@0	2368	return 0;
sl@0	2369	}
sl@0	2370
sl@0	2371	for (j=0; j<3; j++) {
sl@0	2372	BN_bntest_rand(c,1024,0,0); /**/
sl@0	2373	if(errno==ENOMEM)
sl@0	2374	{
sl@0	2375	return 0;
sl@0	2376	}
sl@0	2377	for (i=0; i<num0; i++)
sl@0	2378	{
sl@0	2379	BN_bntest_rand(a,475+i10,0,0); /*/
sl@0	2380	if(errno==ENOMEM)
sl@0	2381	{
sl@0	2382	return 0;
sl@0	2383	}
sl@0	2384	BN_bntest_rand(b,425+i11,0,0); /*/
sl@0	2385	if(errno==ENOMEM)
sl@0	2386	{
sl@0	2387	return 0;
sl@0	2388	}
sl@0	2389	a->neg=rand_neg();
sl@0	2390	if(errno==ENOMEM)
sl@0	2391	{
sl@0	2392	return 0;
sl@0	2393	}
sl@0	2394	b->neg=rand_neg();
sl@0	2395	if(errno==ENOMEM)
sl@0	2396	{
sl@0	2397	return 0;
sl@0	2398	}
sl@0	2399	if (!BN_mod_mul(e,a,b,c,ctx))
sl@0	2400	{
sl@0	2401	if(errno==ENOMEM)
sl@0	2402	{
sl@0	2403	return 0;
sl@0	2404	}
sl@0	2405
sl@0	2406
sl@0	2407	while ((l=ERR_get_error()))
sl@0	2408	fprintf(stderr,"ERROR:%s\n",
sl@0	2409	ERR_error_string(l,NULL));
sl@0	2410	return 1;
sl@0	2411	if(errno==ENOMEM)
sl@0	2412	{
sl@0	2413	return 0;
sl@0	2414	}
sl@0	2415	}
sl@0	2416	if (bp != NULL)
sl@0	2417	{
sl@0	2418	if (!results)
sl@0	2419	{
sl@0	2420	BN_print(bp,a);
sl@0	2421	if(errno==ENOMEM)
sl@0	2422	{
sl@0	2423	return 0;
sl@0	2424	}
sl@0	2425	BIO_puts(bp," * ");
sl@0	2426	if(errno==ENOMEM)
sl@0	2427	{
sl@0	2428	return 0;
sl@0	2429	}
sl@0	2430	BN_print(bp,b);
sl@0	2431	if(errno==ENOMEM)
sl@0	2432	{
sl@0	2433	return 0;
sl@0	2434	}
sl@0	2435	BIO_puts(bp," % ");
sl@0	2436	if(errno==ENOMEM)
sl@0	2437	{
sl@0	2438	return 0;
sl@0	2439	}
sl@0	2440	BN_print(bp,c);
sl@0	2441	if(errno==ENOMEM)
sl@0	2442	{
sl@0	2443	return 0;
sl@0	2444	}
sl@0	2445	if ((a->neg ^ b->neg) && !BN_is_zero(e))
sl@0	2446	{
sl@0	2447	/* If (a*b) % c is negative, c must be added
sl@0	2448	* in order to obtain the normalized remainder
sl@0	2449	* (new with OpenSSL 0.9.7, previous versions of
sl@0	2450	* BN_mod_mul could generate negative results)
sl@0	2451	*/
sl@0	2452	if(errno==ENOMEM)
sl@0	2453	{
sl@0	2454	return 0;
sl@0	2455	}
sl@0	2456	BIO_puts(bp," + ");
sl@0	2457	if(errno==ENOMEM)
sl@0	2458	{
sl@0	2459	return 0;
sl@0	2460	}
sl@0	2461	BN_print(bp,c);
sl@0	2462	if(errno==ENOMEM)
sl@0	2463	{
sl@0	2464	return 0;
sl@0	2465	}
sl@0	2466	}
sl@0	2467	BIO_puts(bp," - ");
sl@0	2468	if(errno==ENOMEM)
sl@0	2469	{
sl@0	2470	return 0;
sl@0	2471	}
sl@0	2472	}
sl@0	2473	BN_print(bp,e);
sl@0	2474	if(errno==ENOMEM)
sl@0	2475	{
sl@0	2476	return 0;
sl@0	2477	}
sl@0	2478	BIO_puts(bp,"\n");
sl@0	2479	if(errno==ENOMEM)
sl@0	2480	{
sl@0	2481	return 0;
sl@0	2482	}
sl@0	2483	}
sl@0	2484	BN_mul(d,a,b,ctx);
sl@0	2485	if(errno==ENOMEM)
sl@0	2486	return 0;
sl@0	2487	BN_sub(d,d,e);
sl@0	2488	if(errno==ENOMEM)
sl@0	2489	return 0;
sl@0	2490	BN_div(a,b,d,c,ctx);
sl@0	2491	if(errno==ENOMEM)
sl@0	2492	return 0;
sl@0	2493	if(!BN_is_zero(b))
sl@0	2494	{
sl@0	2495	if(errno==ENOMEM)
sl@0	2496	return 0;
sl@0	2497	fprintf(stderr,"Modulo multiply test failed!\n");
sl@0	2498	ERR_print_errors_fp(stderr);
sl@0	2499	if(errno==ENOMEM)
sl@0	2500	return 0;
sl@0	2501	return 0;
sl@0	2502	}
sl@0	2503	}
sl@0	2504	}
sl@0	2505	BN_free(a);
sl@0	2506	if(errno==ENOMEM)
sl@0	2507	return 0;
sl@0	2508	BN_free(b);
sl@0	2509	if(errno==ENOMEM)
sl@0	2510	return 0;
sl@0	2511	BN_free(c);
sl@0	2512	if(errno==ENOMEM)
sl@0	2513	return 0;
sl@0	2514	BN_free(d);
sl@0	2515	if(errno==ENOMEM)
sl@0	2516	return 0;
sl@0	2517	BN_free(e);
sl@0	2518	if(errno==ENOMEM)
sl@0	2519	return 0;
sl@0	2520	return(1);
sl@0	2521	}
sl@0	2522
sl@0	2523	int test_mod_exp(BIO bp, BN_CTX ctx)
sl@0	2524	{
sl@0	2525	BIGNUM a,b,c,d,*e;
sl@0	2526	int i;
sl@0	2527
sl@0	2528	a=BN_new();
sl@0	2529	if(errno==ENOMEM)
sl@0	2530	return 0;
sl@0	2531	b=BN_new();
sl@0	2532	if(errno==ENOMEM)
sl@0	2533	return 0;
sl@0	2534	c=BN_new();
sl@0	2535	if(errno==ENOMEM)
sl@0	2536	return 0;
sl@0	2537	d=BN_new();
sl@0	2538	if(errno==ENOMEM)
sl@0	2539	return 0;
sl@0	2540	e=BN_new();
sl@0	2541	if(errno==ENOMEM)
sl@0	2542	return 0;
sl@0	2543
sl@0	2544	BN_bntest_rand(c,30,0,1); /* must be odd for montgomery */
sl@0	2545	if(errno==ENOMEM)
sl@0	2546	return 0;
sl@0	2547	for (i=0; i<num2; i++)
sl@0	2548	{
sl@0	2549	BN_bntest_rand(a,20+i5,0,0); /*/
sl@0	2550	if(errno==ENOMEM)
sl@0	2551	return 0;
sl@0	2552	BN_bntest_rand(b,2+i,0,0); /**/
sl@0	2553	if(errno==ENOMEM)
sl@0	2554	return 0;
sl@0	2555
sl@0	2556	if (!BN_mod_exp(d,a,b,c,ctx))
sl@0	2557	{
sl@0	2558	if(errno==ENOMEM)
sl@0	2559	return 0;
sl@0	2560	return(00);
sl@0	2561	}
sl@0	2562
sl@0	2563	if (bp != NULL)
sl@0	2564	{
sl@0	2565	if (!results)
sl@0	2566	{
sl@0	2567	BN_print(bp,a);
sl@0	2568	if(errno==ENOMEM)
sl@0	2569	return 0;
sl@0	2570	BIO_puts(bp," ^ ");
sl@0	2571	if(errno==ENOMEM)
sl@0	2572	return 0;
sl@0	2573	BN_print(bp,b);
sl@0	2574	if(errno==ENOMEM)
sl@0	2575	return 0;
sl@0	2576	BIO_puts(bp," % ");
sl@0	2577	if(errno==ENOMEM)
sl@0	2578	return 0;
sl@0	2579	BN_print(bp,c);
sl@0	2580	if(errno==ENOMEM)
sl@0	2581	return 0;
sl@0	2582	BIO_puts(bp," - ");
sl@0	2583	if(errno==ENOMEM)
sl@0	2584	return 0;
sl@0	2585	}
sl@0	2586	BN_print(bp,d);
sl@0	2587	if(errno==ENOMEM)
sl@0	2588	return 0;
sl@0	2589	BIO_puts(bp,"\n");
sl@0	2590	if(errno==ENOMEM)
sl@0	2591	return 0;
sl@0	2592	}
sl@0	2593	BN_exp(e,a,b,ctx);
sl@0	2594	if(errno==ENOMEM)
sl@0	2595	return 0;
sl@0	2596	BN_sub(e,e,d);
sl@0	2597	if(errno==ENOMEM)
sl@0	2598	return 0;
sl@0	2599	BN_div(a,b,e,c,ctx);
sl@0	2600	if(errno==ENOMEM)
sl@0	2601	return 0;
sl@0	2602	if(!BN_is_zero(b))
sl@0	2603	{
sl@0	2604	if(errno==ENOMEM)
sl@0	2605	return 0;
sl@0	2606	fprintf(stderr,"Modulo exponentiation test failed!\n");
sl@0	2607	return 0;
sl@0	2608	}
sl@0	2609	}
sl@0	2610	BN_free(a);
sl@0	2611	if(errno==ENOMEM)
sl@0	2612	return 0;
sl@0	2613	BN_free(b);
sl@0	2614	if(errno==ENOMEM)
sl@0	2615	return 0;
sl@0	2616	BN_free(c);
sl@0	2617	if(errno==ENOMEM)
sl@0	2618	return 0;
sl@0	2619	BN_free(d);
sl@0	2620	if(errno==ENOMEM)
sl@0	2621	return 0;
sl@0	2622	BN_free(e);
sl@0	2623	if(errno==ENOMEM)
sl@0	2624	return 0;
sl@0	2625	return(1);
sl@0	2626	}
sl@0	2627
sl@0	2628	int test_mod_exp_mont_consttime(BIO bp, BN_CTX ctx)
sl@0	2629	{
sl@0	2630	BIGNUM a,b,c,d,*e;
sl@0	2631	int i;
sl@0	2632
sl@0	2633	a=BN_new();
sl@0	2634	if(errno==ENOMEM)
sl@0	2635	return 0;
sl@0	2636	b=BN_new();
sl@0	2637	if(errno==ENOMEM)
sl@0	2638	return 0;
sl@0	2639	c=BN_new();
sl@0	2640	if(errno==ENOMEM)
sl@0	2641	return 0;
sl@0	2642	d=BN_new();
sl@0	2643	if(errno==ENOMEM)
sl@0	2644	return 0;
sl@0	2645	e=BN_new();
sl@0	2646	if(errno==ENOMEM)
sl@0	2647	return 0;
sl@0	2648
sl@0	2649	BN_bntest_rand(c,30,0,1); /* must be odd for montgomery */
sl@0	2650	if(errno==ENOMEM)
sl@0	2651	return 0;
sl@0	2652	for (i=0; i<num2; i++)
sl@0	2653	{
sl@0	2654	BN_bntest_rand(a,20+i5,0,0); /*/
sl@0	2655	if(errno==ENOMEM)
sl@0	2656	return 0;
sl@0	2657	BN_bntest_rand(b,2+i,0,0); /**/
sl@0	2658	if(errno==ENOMEM)
sl@0	2659	return 0;
sl@0	2660
sl@0	2661	if (!BN_mod_exp_mont_consttime(d,a,b,c,ctx,NULL))
sl@0	2662	{
sl@0	2663
sl@0	2664	if(errno==ENOMEM)
sl@0	2665	return 0;
sl@0	2666	return(00);
sl@0	2667	}
sl@0	2668	if (bp != NULL)
sl@0	2669	{
sl@0	2670	if (!results)
sl@0	2671	{
sl@0	2672	BN_print(bp,a);
sl@0	2673	if(errno==ENOMEM)
sl@0	2674	return 0;
sl@0	2675	BIO_puts(bp," ^ ");
sl@0	2676	if(errno==ENOMEM)
sl@0	2677	return 0;
sl@0	2678	BN_print(bp,b);
sl@0	2679	if(errno==ENOMEM)
sl@0	2680	return 0;
sl@0	2681	BIO_puts(bp," % ");
sl@0	2682	if(errno==ENOMEM)
sl@0	2683	return 0;
sl@0	2684	BN_print(bp,c);
sl@0	2685	if(errno==ENOMEM)
sl@0	2686	return 0;
sl@0	2687	BIO_puts(bp," - ");
sl@0	2688	if(errno==ENOMEM)
sl@0	2689	return 0;
sl@0	2690	}
sl@0	2691	BN_print(bp,d);
sl@0	2692	if(errno==ENOMEM)
sl@0	2693	return 0;
sl@0	2694	BIO_puts(bp,"\n");
sl@0	2695	if(errno==ENOMEM)
sl@0	2696	return 0;
sl@0	2697	}
sl@0	2698	BN_exp(e,a,b,ctx);
sl@0	2699	if(errno==ENOMEM)
sl@0	2700	return 0;
sl@0	2701	BN_sub(e,e,d);
sl@0	2702	if(errno==ENOMEM)
sl@0	2703	return 0;
sl@0	2704	BN_div(a,b,e,c,ctx);
sl@0	2705	if(errno==ENOMEM)
sl@0	2706	return 0;
sl@0	2707	if(!BN_is_zero(b))
sl@0	2708	{
sl@0	2709
sl@0	2710	if(errno==ENOMEM)
sl@0	2711	return 0;
sl@0	2712	fprintf(stderr,"Modulo exponentiation test failed!\n");
sl@0	2713	return 0;
sl@0	2714	}
sl@0	2715	}
sl@0	2716	BN_free(a);
sl@0	2717	if(errno==ENOMEM)
sl@0	2718	return 0;
sl@0	2719	BN_free(b);
sl@0	2720	if(errno==ENOMEM)
sl@0	2721	return 0;
sl@0	2722	BN_free(c);
sl@0	2723	if(errno==ENOMEM)
sl@0	2724	return 0;
sl@0	2725	BN_free(d);
sl@0	2726	if(errno==ENOMEM)
sl@0	2727	return 0;
sl@0	2728	BN_free(e);
sl@0	2729	if(errno==ENOMEM)
sl@0	2730	return 0;
sl@0	2731	return(1);
sl@0	2732	}
sl@0	2733
sl@0	2734	int test_exp(BIO bp, BN_CTX ctx)
sl@0	2735	{
sl@0	2736	BIGNUM a,b,d,e,*one;
sl@0	2737	int i;
sl@0	2738
sl@0	2739	a=BN_new();
sl@0	2740	if(errno==ENOMEM)
sl@0	2741	return 0;
sl@0	2742	b=BN_new();
sl@0	2743	if(errno==ENOMEM)
sl@0	2744	return 0;
sl@0	2745	d=BN_new();
sl@0	2746	if(errno==ENOMEM)
sl@0	2747	return 0;
sl@0	2748	e=BN_new();
sl@0	2749	if(errno==ENOMEM)
sl@0	2750	return 0;
sl@0	2751	one=BN_new();
sl@0	2752	if(errno==ENOMEM)
sl@0	2753	return 0;
sl@0	2754	BN_one(one);
sl@0	2755	if(errno==ENOMEM)
sl@0	2756	return 0;
sl@0	2757
sl@0	2758	for (i=0; i<num2; i++)
sl@0	2759	{
sl@0	2760	BN_bntest_rand(a,20+i5,0,0); /*/
sl@0	2761	if(errno==ENOMEM)
sl@0	2762	return 0;
sl@0	2763	BN_bntest_rand(b,2+i,0,0); /**/
sl@0	2764	if(errno==ENOMEM)
sl@0	2765	return 0;
sl@0	2766
sl@0	2767	if (!BN_exp(d,a,b,ctx))
sl@0	2768	{
sl@0	2769
sl@0	2770	if(errno==ENOMEM)
sl@0	2771	return 0;
sl@0	2772	return(00);
sl@0	2773	}
sl@0	2774	if (bp != NULL)
sl@0	2775	{
sl@0	2776	if (!results)
sl@0	2777	{
sl@0	2778	BN_print(bp,a);
sl@0	2779	if(errno==ENOMEM)
sl@0	2780	return 0;
sl@0	2781	BIO_puts(bp," ^ ");
sl@0	2782	if(errno==ENOMEM)
sl@0	2783	return 0;
sl@0	2784	BN_print(bp,b);
sl@0	2785	if(errno==ENOMEM)
sl@0	2786	return 0;
sl@0	2787	BIO_puts(bp," - ");
sl@0	2788	if(errno==ENOMEM)
sl@0	2789	return 0;
sl@0	2790	}
sl@0	2791	BN_print(bp,d);
sl@0	2792	if(errno==ENOMEM)
sl@0	2793	return 0;
sl@0	2794	BIO_puts(bp,"\n");
sl@0	2795	if(errno==ENOMEM)
sl@0	2796	return 0;
sl@0	2797	}
sl@0	2798	BN_one(e);
sl@0	2799	if(errno==ENOMEM)
sl@0	2800	return 0;
sl@0	2801	for( ; !BN_is_zero(b) ; BN_sub(b,b,one))
sl@0	2802	{
sl@0	2803	if(errno==ENOMEM)
sl@0	2804	return 0;
sl@0	2805	BN_mul(e,e,a,ctx);
sl@0	2806	if(errno==ENOMEM)
sl@0	2807	return 0;
sl@0	2808	}
sl@0	2809	BN_sub(e,e,d);
sl@0	2810	if(errno==ENOMEM)
sl@0	2811	return 0;
sl@0	2812	if(!BN_is_zero(e))
sl@0	2813	{
sl@0	2814	if(errno==ENOMEM)
sl@0	2815	return 0;
sl@0	2816	fprintf(stderr,"Exponentiation test failed!\n");
sl@0	2817	return 0;
sl@0	2818	}
sl@0	2819	}
sl@0	2820	BN_free(a);
sl@0	2821	if(errno==ENOMEM)
sl@0	2822	return 0;
sl@0	2823	BN_free(b);
sl@0	2824	if(errno==ENOMEM)
sl@0	2825	return 0;
sl@0	2826	BN_free(d);
sl@0	2827	if(errno==ENOMEM)
sl@0	2828	return 0;
sl@0	2829	BN_free(e);
sl@0	2830	if(errno==ENOMEM)
sl@0	2831	return 0;
sl@0	2832	BN_free(one);
sl@0	2833	if(errno==ENOMEM)
sl@0	2834	return 0;
sl@0	2835	return(1);
sl@0	2836	}
sl@0	2837
sl@0	2838	int test_gf2m_add(BIO *bp)
sl@0	2839	{
sl@0	2840	BIGNUM a,b,c;
sl@0	2841	int i, ret = 0;
sl@0	2842
sl@0	2843	BN_init(&a);
sl@0	2844	if(errno==ENOMEM)
sl@0	2845	return 0;
sl@0	2846	BN_init(&b);
sl@0	2847	if(errno==ENOMEM)
sl@0	2848	return 0;
sl@0	2849	BN_init(&c);
sl@0	2850	if(errno==ENOMEM)
sl@0	2851	return 0;
sl@0	2852
sl@0	2853	for (i=0; i<num0; i++)
sl@0	2854	{
sl@0	2855	BN_rand(&a,512,0,0);
sl@0	2856	if(errno==ENOMEM)
sl@0	2857	return 0;
sl@0	2858	BN_copy(&b, BN_value_one());
sl@0	2859	if(errno==ENOMEM)
sl@0	2860	return 0;
sl@0	2861	a.neg=rand_neg();
sl@0	2862	if(errno==ENOMEM)
sl@0	2863	return 0;
sl@0	2864	b.neg=rand_neg();
sl@0	2865	if(errno==ENOMEM)
sl@0	2866	return 0;
sl@0	2867	BN_GF2m_add(&c,&a,&b);
sl@0	2868	if(errno==ENOMEM)
sl@0	2869	return 0;
sl@0	2870	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	2871	if (bp != NULL)
sl@0	2872	{
sl@0	2873	if (!results)
sl@0	2874	{
sl@0	2875	BN_print(bp,&a);
sl@0	2876	if(errno==ENOMEM)
sl@0	2877	return 0;
sl@0	2878	BIO_puts(bp," ^ ");
sl@0	2879	if(errno==ENOMEM)
sl@0	2880	return 0;
sl@0	2881	BN_print(bp,&b);
sl@0	2882	if(errno==ENOMEM)
sl@0	2883	return 0;
sl@0	2884	BIO_puts(bp," = ");
sl@0	2885	if(errno==ENOMEM)
sl@0	2886	return 0;
sl@0	2887	}
sl@0	2888	BN_print(bp,&c);
sl@0	2889	if(errno==ENOMEM)
sl@0	2890	return 0;
sl@0	2891	BIO_puts(bp,"\n");
sl@0	2892	if(errno==ENOMEM)
sl@0	2893	return 0;
sl@0	2894	}
sl@0	2895	#endif
sl@0	2896	/* Test that two added values have the correct parity. */
sl@0	2897	if((BN_is_odd(&a) && BN_is_odd(&c)) \|\| (!BN_is_odd(&a) && !BN_is_odd(&c)))
sl@0	2898	{
sl@0	2899
sl@0	2900	if(errno==ENOMEM)
sl@0	2901	return 0;
sl@0	2902	fprintf(stderr,"GF(2^m) addition test (a) failed!\n");
sl@0	2903	goto err;
sl@0	2904	}
sl@0	2905	BN_GF2m_add(&c,&c,&c);
sl@0	2906	if(errno==ENOMEM)
sl@0	2907	return 0;
sl@0	2908	/* Test that c + c = 0. */
sl@0	2909	if(!BN_is_zero(&c))
sl@0	2910	{
sl@0	2911
sl@0	2912	if(errno==ENOMEM)
sl@0	2913	return 0;
sl@0	2914	fprintf(stderr,"GF(2^m) addition test (b) failed!\n");
sl@0	2915	goto err;
sl@0	2916	}
sl@0	2917	}
sl@0	2918	ret = 1;
sl@0	2919	err:
sl@0	2920	BN_free(&a);
sl@0	2921	if(errno==ENOMEM)
sl@0	2922	return 0;
sl@0	2923	BN_free(&b);
sl@0	2924	if(errno==ENOMEM)
sl@0	2925	return 0;
sl@0	2926	BN_free(&c);
sl@0	2927	if(errno==ENOMEM)
sl@0	2928	return 0;
sl@0	2929	return ret;
sl@0	2930	}
sl@0	2931
sl@0	2932	int test_gf2m_mod(BIO *bp)
sl@0	2933	{
sl@0	2934	BIGNUM a,b[2],c,d,*e;
sl@0	2935	int i, j, ret = 0;
sl@0	2936	unsigned int p0[] = {163,7,6,3,0};
sl@0	2937	unsigned int p1[] = {193,15,0};
sl@0	2938
sl@0	2939	a=BN_new();
sl@0	2940	if(errno==ENOMEM)
sl@0	2941	return 0;
sl@0	2942	b[0]=BN_new();
sl@0	2943	if(errno==ENOMEM)
sl@0	2944	return 0;
sl@0	2945	b[1]=BN_new();
sl@0	2946	if(errno==ENOMEM)
sl@0	2947	return 0;
sl@0	2948	c=BN_new();
sl@0	2949	if(errno==ENOMEM)
sl@0	2950	return 0;
sl@0	2951	d=BN_new();
sl@0	2952	if(errno==ENOMEM)
sl@0	2953	return 0;
sl@0	2954	e=BN_new();
sl@0	2955	if(errno==ENOMEM)
sl@0	2956	return 0;
sl@0	2957
sl@0	2958	BN_GF2m_arr2poly(p0, b[0]);
sl@0	2959	if(errno==ENOMEM)
sl@0	2960	return 0;
sl@0	2961	BN_GF2m_arr2poly(p1, b[1]);
sl@0	2962	if(errno==ENOMEM)
sl@0	2963	return 0;
sl@0	2964
sl@0	2965	for (i=0; i<num0; i++)
sl@0	2966	{
sl@0	2967	BN_bntest_rand(a, 1024, 0, 0);
sl@0	2968	if(errno==ENOMEM)
sl@0	2969	return 0;
sl@0	2970	for (j=0; j < 2; j++)
sl@0	2971	{
sl@0	2972	BN_GF2m_mod(c, a, b[j]);
sl@0	2973	if(errno==ENOMEM)
sl@0	2974	return 0;
sl@0	2975	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	2976	if (bp != NULL)
sl@0	2977	{
sl@0	2978	if (!results)
sl@0	2979	{
sl@0	2980	BN_print(bp,a);
sl@0	2981	if(errno==ENOMEM)
sl@0	2982	return 0;
sl@0	2983	BIO_puts(bp," % ");
sl@0	2984	if(errno==ENOMEM)
sl@0	2985	return 0;
sl@0	2986	BN_print(bp,b[j]);
sl@0	2987	if(errno==ENOMEM)
sl@0	2988	return 0;
sl@0	2989	BIO_puts(bp," - ");
sl@0	2990	if(errno==ENOMEM)
sl@0	2991	return 0;
sl@0	2992	BN_print(bp,c);
sl@0	2993	if(errno==ENOMEM)
sl@0	2994	return 0;
sl@0	2995	BIO_puts(bp,"\n");
sl@0	2996	if(errno==ENOMEM)
sl@0	2997	return 0;
sl@0	2998	}
sl@0	2999	}
sl@0	3000	#endif
sl@0	3001	BN_GF2m_add(d, a, c);
sl@0	3002	if(errno==ENOMEM)
sl@0	3003	return 0;
sl@0	3004	BN_GF2m_mod(e, d, b[j]);
sl@0	3005	if(errno==ENOMEM)
sl@0	3006	return 0;
sl@0	3007	/* Test that a + (a mod p) mod p == 0. */
sl@0	3008	if(!BN_is_zero(e))
sl@0	3009	{
sl@0	3010	if(errno==ENOMEM)
sl@0	3011	return 0;
sl@0	3012	fprintf(stderr,"GF(2^m) modulo test failed!\n");
sl@0	3013	goto err;
sl@0	3014	}
sl@0	3015	}
sl@0	3016	}
sl@0	3017	ret = 1;
sl@0	3018	err:
sl@0	3019	BN_free(a);
sl@0	3020	if(errno==ENOMEM)
sl@0	3021	return 0;
sl@0	3022	BN_free(b[0]);
sl@0	3023	if(errno==ENOMEM)
sl@0	3024	return 0;
sl@0	3025	BN_free(b[1]);
sl@0	3026	if(errno==ENOMEM)
sl@0	3027	return 0;
sl@0	3028	BN_free(c);
sl@0	3029	if(errno==ENOMEM)
sl@0	3030	return 0;
sl@0	3031	BN_free(d);
sl@0	3032	if(errno==ENOMEM)
sl@0	3033	return 0;
sl@0	3034	BN_free(e);
sl@0	3035	if(errno==ENOMEM)
sl@0	3036	return 0;
sl@0	3037	return ret;
sl@0	3038	}
sl@0	3039
sl@0	3040	int test_gf2m_mod_mul(BIO bp,BN_CTX ctx)
sl@0	3041	{
sl@0	3042	BIGNUM a,b[2],c,d,e,f,g,h;
sl@0	3043	int i, j, ret = 0;
sl@0	3044	unsigned int p0[] = {163,7,6,3,0};
sl@0	3045	unsigned int p1[] = {193,15,0};
sl@0	3046
sl@0	3047	a=BN_new();
sl@0	3048	if(errno==ENOMEM)
sl@0	3049	return 0;
sl@0	3050	b[0]=BN_new();
sl@0	3051	if(errno==ENOMEM)
sl@0	3052	return 0;
sl@0	3053	b[1]=BN_new();
sl@0	3054	if(errno==ENOMEM)
sl@0	3055	return 0;
sl@0	3056	c=BN_new();
sl@0	3057	if(errno==ENOMEM)
sl@0	3058	return 0;
sl@0	3059	d=BN_new();
sl@0	3060	if(errno==ENOMEM)
sl@0	3061	return 0;
sl@0	3062	e=BN_new();
sl@0	3063	if(errno==ENOMEM)
sl@0	3064	return 0;
sl@0	3065	f=BN_new();
sl@0	3066	if(errno==ENOMEM)
sl@0	3067	return 0;
sl@0	3068	g=BN_new();
sl@0	3069	if(errno==ENOMEM)
sl@0	3070	return 0;
sl@0	3071	h=BN_new();
sl@0	3072	if(errno==ENOMEM)
sl@0	3073	return 0;
sl@0	3074
sl@0	3075	BN_GF2m_arr2poly(p0, b[0]);
sl@0	3076	if(errno==ENOMEM)
sl@0	3077	return 0;
sl@0	3078	BN_GF2m_arr2poly(p1, b[1]);
sl@0	3079	if(errno==ENOMEM)
sl@0	3080	return 0;
sl@0	3081
sl@0	3082	for (i=0; i<num0; i++)
sl@0	3083	{
sl@0	3084	BN_bntest_rand(a, 1024, 0, 0);
sl@0	3085	if(errno==ENOMEM)
sl@0	3086	return 0;
sl@0	3087	BN_bntest_rand(c, 1024, 0, 0);
sl@0	3088	if(errno==ENOMEM)
sl@0	3089	return 0;
sl@0	3090	BN_bntest_rand(d, 1024, 0, 0);
sl@0	3091	if(errno==ENOMEM)
sl@0	3092	return 0;
sl@0	3093	for (j=0; j < 2; j++)
sl@0	3094	{
sl@0	3095	BN_GF2m_mod_mul(e, a, c, b[j], ctx);
sl@0	3096	if(errno==ENOMEM)
sl@0	3097	return 0;
sl@0	3098	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3099	if (bp != NULL)
sl@0	3100	{
sl@0	3101	if (!results)
sl@0	3102	{
sl@0	3103	BN_print(bp,a);
sl@0	3104	if(errno==ENOMEM)
sl@0	3105	return 0;
sl@0	3106	BIO_puts(bp," * ");
sl@0	3107	if(errno==ENOMEM)
sl@0	3108	return 0;
sl@0	3109	BN_print(bp,c);
sl@0	3110	if(errno==ENOMEM)
sl@0	3111	return 0;
sl@0	3112	BIO_puts(bp," % ");
sl@0	3113	if(errno==ENOMEM)
sl@0	3114	return 0;
sl@0	3115	BN_print(bp,b[j]);
sl@0	3116	if(errno==ENOMEM)
sl@0	3117	return 0;
sl@0	3118	BIO_puts(bp," - ");
sl@0	3119	if(errno==ENOMEM)
sl@0	3120	return 0;
sl@0	3121	BN_print(bp,e);
sl@0	3122	if(errno==ENOMEM)
sl@0	3123	return 0;
sl@0	3124	BIO_puts(bp,"\n");
sl@0	3125	if(errno==ENOMEM)
sl@0	3126	return 0;
sl@0	3127	}
sl@0	3128	}
sl@0	3129	#endif
sl@0	3130	BN_GF2m_add(f, a, d);
sl@0	3131	if(errno==ENOMEM)
sl@0	3132	return 0;
sl@0	3133	BN_GF2m_mod_mul(g, f, c, b[j], ctx);
sl@0	3134	if(errno==ENOMEM)
sl@0	3135	return 0;
sl@0	3136	BN_GF2m_mod_mul(h, d, c, b[j], ctx);
sl@0	3137	if(errno==ENOMEM)
sl@0	3138	return 0;
sl@0	3139	BN_GF2m_add(f, e, g);
sl@0	3140	if(errno==ENOMEM)
sl@0	3141	return 0;
sl@0	3142	BN_GF2m_add(f, f, h);
sl@0	3143	if(errno==ENOMEM)
sl@0	3144	return 0;
sl@0	3145	/* Test that (a+d)c = ac + dc. /
sl@0	3146	if(!BN_is_zero(f))
sl@0	3147	{
sl@0	3148
sl@0	3149	if(errno==ENOMEM)
sl@0	3150	return 0;
sl@0	3151	fprintf(stderr,"GF(2^m) modular multiplication test failed!\n");
sl@0	3152	goto err;
sl@0	3153	}
sl@0	3154	}
sl@0	3155	}
sl@0	3156	ret = 1;
sl@0	3157	err:
sl@0	3158	BN_free(a);
sl@0	3159	if(errno==ENOMEM)
sl@0	3160	return 0;
sl@0	3161	BN_free(b[0]);
sl@0	3162	if(errno==ENOMEM)
sl@0	3163	return 0;
sl@0	3164	BN_free(b[1]);
sl@0	3165	if(errno==ENOMEM)
sl@0	3166	return 0;
sl@0	3167	BN_free(c);
sl@0	3168	if(errno==ENOMEM)
sl@0	3169	return 0;
sl@0	3170	BN_free(d);
sl@0	3171	if(errno==ENOMEM)
sl@0	3172	return 0;
sl@0	3173	BN_free(e);
sl@0	3174	if(errno==ENOMEM)
sl@0	3175	return 0;
sl@0	3176	BN_free(f);
sl@0	3177	if(errno==ENOMEM)
sl@0	3178	return 0;
sl@0	3179	BN_free(g);
sl@0	3180	if(errno==ENOMEM)
sl@0	3181	return 0;
sl@0	3182	BN_free(h);
sl@0	3183	if(errno==ENOMEM)
sl@0	3184	return 0;
sl@0	3185	return ret;
sl@0	3186	}
sl@0	3187
sl@0	3188	int test_gf2m_mod_sqr(BIO bp,BN_CTX ctx)
sl@0	3189	{
sl@0	3190	BIGNUM a,b[2],c,d;
sl@0	3191	int i, j, ret = 0;
sl@0	3192	unsigned int p0[] = {163,7,6,3,0};
sl@0	3193	unsigned int p1[] = {193,15,0};
sl@0	3194
sl@0	3195	a=BN_new();
sl@0	3196	if(errno==ENOMEM)
sl@0	3197	return 0;
sl@0	3198	b[0]=BN_new();
sl@0	3199	if(errno==ENOMEM)
sl@0	3200	return 0;
sl@0	3201	b[1]=BN_new();
sl@0	3202	if(errno==ENOMEM)
sl@0	3203	return 0;
sl@0	3204	c=BN_new();
sl@0	3205	if(errno==ENOMEM)
sl@0	3206	return 0;
sl@0	3207	d=BN_new();
sl@0	3208	if(errno==ENOMEM)
sl@0	3209	return 0;
sl@0	3210
sl@0	3211	BN_GF2m_arr2poly(p0, b[0]);
sl@0	3212	if(errno==ENOMEM)
sl@0	3213	return 0;
sl@0	3214	BN_GF2m_arr2poly(p1, b[1]);
sl@0	3215	if(errno==ENOMEM)
sl@0	3216	return 0;
sl@0	3217
sl@0	3218	for (i=0; i<num0; i++)
sl@0	3219	{
sl@0	3220	BN_bntest_rand(a, 1024, 0, 0);
sl@0	3221	if(errno==ENOMEM)
sl@0	3222	return 0;
sl@0	3223	for (j=0; j < 2; j++)
sl@0	3224	{
sl@0	3225	BN_GF2m_mod_sqr(c, a, b[j], ctx);
sl@0	3226	if(errno==ENOMEM)
sl@0	3227	return 0;
sl@0	3228	BN_copy(d, a);
sl@0	3229	if(errno==ENOMEM)
sl@0	3230	return 0;
sl@0	3231	BN_GF2m_mod_mul(d, a, d, b[j], ctx);
sl@0	3232	if(errno==ENOMEM)
sl@0	3233	return 0;
sl@0	3234	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3235	if (bp != NULL)
sl@0	3236	{
sl@0	3237	if (!results)
sl@0	3238	{
sl@0	3239	BN_print(bp,a);
sl@0	3240	if(errno==ENOMEM)
sl@0	3241	return 0;
sl@0	3242	BIO_puts(bp," ^ 2 % ");
sl@0	3243	if(errno==ENOMEM)
sl@0	3244	return 0;
sl@0	3245	BN_print(bp,b[j]);
sl@0	3246	if(errno==ENOMEM)
sl@0	3247	return 0;
sl@0	3248	BIO_puts(bp, " = ");
sl@0	3249	if(errno==ENOMEM)
sl@0	3250	return 0;
sl@0	3251	BN_print(bp,c);
sl@0	3252	if(errno==ENOMEM)
sl@0	3253	return 0;
sl@0	3254	BIO_puts(bp,"; a * a = ");
sl@0	3255	if(errno==ENOMEM)
sl@0	3256	return 0;
sl@0	3257	BN_print(bp,d);
sl@0	3258	if(errno==ENOMEM)
sl@0	3259	return 0;
sl@0	3260	BIO_puts(bp,"\n");
sl@0	3261	if(errno==ENOMEM)
sl@0	3262	return 0;
sl@0	3263	}
sl@0	3264	}
sl@0	3265	#endif
sl@0	3266	BN_GF2m_add(d, c, d);
sl@0	3267	if(errno==ENOMEM)
sl@0	3268	return 0;
sl@0	3269	/* Test that aa = a^2. /
sl@0	3270	if(!BN_is_zero(d))
sl@0	3271	{
sl@0	3272	if(errno==ENOMEM)
sl@0	3273	return 0;
sl@0	3274	fprintf(stderr,"GF(2^m) modular squaring test failed!\n");
sl@0	3275	goto err;
sl@0	3276	}
sl@0	3277	}
sl@0	3278	}
sl@0	3279	ret = 1;
sl@0	3280	err:
sl@0	3281	BN_free(a);
sl@0	3282	if(errno==ENOMEM)
sl@0	3283	return 0;
sl@0	3284	BN_free(b[0]);
sl@0	3285	if(errno==ENOMEM)
sl@0	3286	return 0;
sl@0	3287	BN_free(b[1]);
sl@0	3288	if(errno==ENOMEM)
sl@0	3289	return 0;
sl@0	3290	BN_free(c);
sl@0	3291	if(errno==ENOMEM)
sl@0	3292	return 0;
sl@0	3293	BN_free(d);
sl@0	3294	if(errno==ENOMEM)
sl@0	3295	return 0;
sl@0	3296	return ret;
sl@0	3297	}
sl@0	3298
sl@0	3299	int test_gf2m_mod_inv(BIO bp,BN_CTX ctx)
sl@0	3300	{
sl@0	3301	BIGNUM a,b[2],c,d;
sl@0	3302	int i, j, ret = 0;
sl@0	3303	unsigned int p0[] = {163,7,6,3,0};
sl@0	3304	unsigned int p1[] = {193,15,0};
sl@0	3305
sl@0	3306	a=BN_new();
sl@0	3307	if(errno==ENOMEM)
sl@0	3308	return 0;
sl@0	3309	b[0]=BN_new();
sl@0	3310	if(errno==ENOMEM)
sl@0	3311	return 0;
sl@0	3312	b[1]=BN_new();
sl@0	3313	if(errno==ENOMEM)
sl@0	3314	return 0;
sl@0	3315	c=BN_new();
sl@0	3316	if(errno==ENOMEM)
sl@0	3317	return 0;
sl@0	3318	d=BN_new();
sl@0	3319	if(errno==ENOMEM)
sl@0	3320	return 0;
sl@0	3321
sl@0	3322	BN_GF2m_arr2poly(p0, b[0]);
sl@0	3323	if(errno==ENOMEM)
sl@0	3324	return 0;
sl@0	3325	BN_GF2m_arr2poly(p1, b[1]);
sl@0	3326	if(errno==ENOMEM)
sl@0	3327	return 0;
sl@0	3328
sl@0	3329	for (i=0; i<num0; i++)
sl@0	3330	{
sl@0	3331	BN_bntest_rand(a, 512, 0, 0);
sl@0	3332	for (j=0; j < 2; j++)
sl@0	3333	{
sl@0	3334	BN_GF2m_mod_inv(c, a, b[j], ctx);
sl@0	3335	if(errno==ENOMEM)
sl@0	3336	return 0;
sl@0	3337	BN_GF2m_mod_mul(d, a, c, b[j], ctx);
sl@0	3338	if(errno==ENOMEM)
sl@0	3339	return 0;
sl@0	3340	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3341	if (bp != NULL)
sl@0	3342	{
sl@0	3343	if (!results)
sl@0	3344	{
sl@0	3345	BN_print(bp,a);
sl@0	3346	if(errno==ENOMEM)
sl@0	3347	return 0;
sl@0	3348	BIO_puts(bp, " * ");
sl@0	3349	if(errno==ENOMEM)
sl@0	3350	return 0;
sl@0	3351	BN_print(bp,c);
sl@0	3352	if(errno==ENOMEM)
sl@0	3353	return 0;
sl@0	3354	BIO_puts(bp," - 1 % ");
sl@0	3355	if(errno==ENOMEM)
sl@0	3356	return 0;
sl@0	3357	BN_print(bp,b[j]);
sl@0	3358	if(errno==ENOMEM)
sl@0	3359	return 0;
sl@0	3360	BIO_puts(bp,"\n");
sl@0	3361	if(errno==ENOMEM)
sl@0	3362	return 0;
sl@0	3363	}
sl@0	3364	}
sl@0	3365	#endif
sl@0	3366	/* Test that ((1/a)a) = 1. /
sl@0	3367	if(!BN_is_one(d))
sl@0	3368	{
sl@0	3369	if(errno==ENOMEM)
sl@0	3370	return 0;
sl@0	3371	fprintf(stderr,"GF(2^m) modular inversion test failed!\n");
sl@0	3372	goto err;
sl@0	3373	}
sl@0	3374	}
sl@0	3375	}
sl@0	3376	ret = 1;
sl@0	3377	err:
sl@0	3378	BN_free(a);
sl@0	3379	if(errno==ENOMEM)
sl@0	3380	return 0;
sl@0	3381	BN_free(b[0]);
sl@0	3382	if(errno==ENOMEM)
sl@0	3383	return 0;
sl@0	3384	BN_free(b[1]);
sl@0	3385	if(errno==ENOMEM)
sl@0	3386	return 0;
sl@0	3387	BN_free(c);
sl@0	3388	if(errno==ENOMEM)
sl@0	3389	return 0;
sl@0	3390	BN_free(d);
sl@0	3391	if(errno==ENOMEM)
sl@0	3392	return 0;
sl@0	3393	return ret;
sl@0	3394	}
sl@0	3395
sl@0	3396	int test_gf2m_mod_div(BIO bp,BN_CTX ctx)
sl@0	3397	{
sl@0	3398	BIGNUM a,b[2],c,d,e,f;
sl@0	3399	int i, j, ret = 0;
sl@0	3400	unsigned int p0[] = {163,7,6,3,0};
sl@0	3401	unsigned int p1[] = {193,15,0};
sl@0	3402
sl@0	3403	a=BN_new();
sl@0	3404	if(errno==ENOMEM)
sl@0	3405	return 0;
sl@0	3406	b[0]=BN_new();
sl@0	3407	if(errno==ENOMEM)
sl@0	3408	return 0;
sl@0	3409	b[1]=BN_new();
sl@0	3410	if(errno==ENOMEM)
sl@0	3411	return 0;
sl@0	3412	c=BN_new();
sl@0	3413	if(errno==ENOMEM)
sl@0	3414	return 0;
sl@0	3415	d=BN_new();
sl@0	3416	if(errno==ENOMEM)
sl@0	3417	return 0;
sl@0	3418	e=BN_new();
sl@0	3419	if(errno==ENOMEM)
sl@0	3420	return 0;
sl@0	3421	f=BN_new();
sl@0	3422	if(errno==ENOMEM)
sl@0	3423	return 0;
sl@0	3424
sl@0	3425	BN_GF2m_arr2poly(p0, b[0]);
sl@0	3426	if(errno==ENOMEM)
sl@0	3427	return 0;
sl@0	3428	BN_GF2m_arr2poly(p1, b[1]);
sl@0	3429	if(errno==ENOMEM)
sl@0	3430	return 0;
sl@0	3431
sl@0	3432	for (i=0; i<num0; i++)
sl@0	3433	{
sl@0	3434	BN_bntest_rand(a, 512, 0, 0);
sl@0	3435	if(errno==ENOMEM)
sl@0	3436	return 0;
sl@0	3437	BN_bntest_rand(c, 512, 0, 0);
sl@0	3438	if(errno==ENOMEM)
sl@0	3439	return 0;
sl@0	3440	for (j=0; j < 2; j++)
sl@0	3441	{
sl@0	3442	BN_GF2m_mod_div(d, a, c, b[j], ctx);
sl@0	3443	if(errno==ENOMEM)
sl@0	3444	return 0;
sl@0	3445	BN_GF2m_mod_mul(e, d, c, b[j], ctx);
sl@0	3446	if(errno==ENOMEM)
sl@0	3447	return 0;
sl@0	3448	BN_GF2m_mod_div(f, a, e, b[j], ctx);
sl@0	3449	if(errno==ENOMEM)
sl@0	3450	return 0;
sl@0	3451	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3452	if (bp != NULL)
sl@0	3453	{
sl@0	3454	if (!results)
sl@0	3455	{
sl@0	3456	BN_print(bp,a);
sl@0	3457	if(errno==ENOMEM)
sl@0	3458	return 0;
sl@0	3459	BIO_puts(bp, " = ");
sl@0	3460	if(errno==ENOMEM)
sl@0	3461	return 0;
sl@0	3462	BN_print(bp,c);
sl@0	3463	if(errno==ENOMEM)
sl@0	3464	return 0;
sl@0	3465	BIO_puts(bp," * ");
sl@0	3466	if(errno==ENOMEM)
sl@0	3467	return 0;
sl@0	3468	BN_print(bp,d);
sl@0	3469	BIO_puts(bp, " % ");
sl@0	3470	if(errno==ENOMEM)
sl@0	3471	return 0;
sl@0	3472	BN_print(bp,b[j]);
sl@0	3473	if(errno==ENOMEM)
sl@0	3474	return 0;
sl@0	3475	BIO_puts(bp,"\n");
sl@0	3476	if(errno==ENOMEM)
sl@0	3477	return 0;
sl@0	3478	}
sl@0	3479	}
sl@0	3480	#endif
sl@0	3481	/* Test that ((a/c)c)/a = 1. /
sl@0	3482	if(!BN_is_one(f))
sl@0	3483	{
sl@0	3484
sl@0	3485	if(errno==ENOMEM)
sl@0	3486	return 0;
sl@0	3487	fprintf(stderr,"GF(2^m) modular division test failed!\n");
sl@0	3488	goto err;
sl@0	3489	}
sl@0	3490	}
sl@0	3491	}
sl@0	3492	ret = 1;
sl@0	3493	err:
sl@0	3494	BN_free(a);
sl@0	3495	if(errno==ENOMEM)
sl@0	3496	return 0;
sl@0	3497	BN_free(b[0]);
sl@0	3498	if(errno==ENOMEM)
sl@0	3499	return 0;
sl@0	3500	BN_free(b[1]);
sl@0	3501	if(errno==ENOMEM)
sl@0	3502	return 0;
sl@0	3503	BN_free(c);
sl@0	3504	if(errno==ENOMEM)
sl@0	3505	return 0;
sl@0	3506	BN_free(d);
sl@0	3507	if(errno==ENOMEM)
sl@0	3508	return 0;
sl@0	3509	BN_free(e);
sl@0	3510	if(errno==ENOMEM)
sl@0	3511	return 0;
sl@0	3512	BN_free(f);
sl@0	3513	if(errno==ENOMEM)
sl@0	3514	return 0;
sl@0	3515	return ret;
sl@0	3516	}
sl@0	3517
sl@0	3518	int test_gf2m_mod_exp(BIO bp,BN_CTX ctx)
sl@0	3519	{
sl@0	3520	BIGNUM a,b[2],c,d,e,f;
sl@0	3521	int i, j, ret = 0;
sl@0	3522	unsigned int p0[] = {163,7,6,3,0};
sl@0	3523	unsigned int p1[] = {193,15,0};
sl@0	3524
sl@0	3525	a=BN_new();
sl@0	3526	if(errno==ENOMEM)
sl@0	3527	return 0;
sl@0	3528	b[0]=BN_new();
sl@0	3529	if(errno==ENOMEM)
sl@0	3530	return 0;
sl@0	3531	b[1]=BN_new();
sl@0	3532	if(errno==ENOMEM)
sl@0	3533	return 0;
sl@0	3534	c=BN_new();
sl@0	3535	if(errno==ENOMEM)
sl@0	3536	return 0;
sl@0	3537	d=BN_new();
sl@0	3538	if(errno==ENOMEM)
sl@0	3539	return 0;
sl@0	3540	e=BN_new();
sl@0	3541	if(errno==ENOMEM)
sl@0	3542	return 0;
sl@0	3543	f=BN_new();
sl@0	3544	if(errno==ENOMEM)
sl@0	3545	return 0;
sl@0	3546
sl@0	3547	BN_GF2m_arr2poly(p0, b[0]);
sl@0	3548	if(errno==ENOMEM)
sl@0	3549	return 0;
sl@0	3550	BN_GF2m_arr2poly(p1, b[1]);
sl@0	3551	if(errno==ENOMEM)
sl@0	3552	return 0;
sl@0	3553
sl@0	3554	for (i=0; i<num0; i++)
sl@0	3555	{
sl@0	3556	BN_bntest_rand(a, 512, 0, 0);
sl@0	3557	if(errno==ENOMEM)
sl@0	3558	return 0;
sl@0	3559	BN_bntest_rand(c, 512, 0, 0);
sl@0	3560	if(errno==ENOMEM)
sl@0	3561	return 0;
sl@0	3562	BN_bntest_rand(d, 512, 0, 0);
sl@0	3563	if(errno==ENOMEM)
sl@0	3564	return 0;
sl@0	3565	for (j=0; j < 2; j++)
sl@0	3566	{
sl@0	3567	BN_GF2m_mod_exp(e, a, c, b[j], ctx);
sl@0	3568	if(errno==ENOMEM)
sl@0	3569	return 0;
sl@0	3570	BN_GF2m_mod_exp(f, a, d, b[j], ctx);
sl@0	3571	if(errno==ENOMEM)
sl@0	3572	return 0;
sl@0	3573	BN_GF2m_mod_mul(e, e, f, b[j], ctx);
sl@0	3574	if(errno==ENOMEM)
sl@0	3575	return 0;
sl@0	3576	BN_add(f, c, d);
sl@0	3577	if(errno==ENOMEM)
sl@0	3578	return 0;
sl@0	3579	BN_GF2m_mod_exp(f, a, f, b[j], ctx);
sl@0	3580	if(errno==ENOMEM)
sl@0	3581	return 0;
sl@0	3582	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3583	if (bp != NULL)
sl@0	3584	{
sl@0	3585	if (!results)
sl@0	3586	{
sl@0	3587	BN_print(bp,a);
sl@0	3588	if(errno==ENOMEM)
sl@0	3589	return 0;
sl@0	3590	BIO_puts(bp, " ^ (");
sl@0	3591	if(errno==ENOMEM)
sl@0	3592	return 0;
sl@0	3593	BN_print(bp,c);
sl@0	3594	if(errno==ENOMEM)
sl@0	3595	return 0;
sl@0	3596	BIO_puts(bp," + ");
sl@0	3597	if(errno==ENOMEM)
sl@0	3598	return 0;
sl@0	3599	BN_print(bp,d);
sl@0	3600	if(errno==ENOMEM)
sl@0	3601	return 0;
sl@0	3602	BIO_puts(bp, ") = ");
sl@0	3603	if(errno==ENOMEM)
sl@0	3604	return 0;
sl@0	3605	BN_print(bp,e);
sl@0	3606	if(errno==ENOMEM)
sl@0	3607	return 0;
sl@0	3608	BIO_puts(bp, "; - ");
sl@0	3609	if(errno==ENOMEM)
sl@0	3610	return 0;
sl@0	3611	BN_print(bp,f);
sl@0	3612	if(errno==ENOMEM)
sl@0	3613	return 0;
sl@0	3614	BIO_puts(bp, " % ");
sl@0	3615	if(errno==ENOMEM)
sl@0	3616	return 0;
sl@0	3617	BN_print(bp,b[j]);
sl@0	3618	if(errno==ENOMEM)
sl@0	3619	return 0;
sl@0	3620	BIO_puts(bp,"\n");
sl@0	3621	if(errno==ENOMEM)
sl@0	3622	return 0;
sl@0	3623	}
sl@0	3624	}
sl@0	3625	#endif
sl@0	3626	BN_GF2m_add(f, e, f);
sl@0	3627	if(errno==ENOMEM)
sl@0	3628	return 0;
sl@0	3629	/* Test that a^(c+d)=a^ca^d. /
sl@0	3630	if(!BN_is_zero(f))
sl@0	3631	{
sl@0	3632	if(errno==ENOMEM)
sl@0	3633	return 0;
sl@0	3634	fprintf(stderr,"GF(2^m) modular exponentiation test failed!\n");
sl@0	3635	goto err;
sl@0	3636	}
sl@0	3637	}
sl@0	3638	}
sl@0	3639	ret = 1;
sl@0	3640	err:
sl@0	3641	BN_free(a);
sl@0	3642	if(errno==ENOMEM)
sl@0	3643	return 0;
sl@0	3644	BN_free(b[0]);
sl@0	3645	if(errno==ENOMEM)
sl@0	3646	return 0;
sl@0	3647	BN_free(b[1]);
sl@0	3648	if(errno==ENOMEM)
sl@0	3649	return 0;
sl@0	3650	BN_free(c);
sl@0	3651	if(errno==ENOMEM)
sl@0	3652	return 0;
sl@0	3653	BN_free(d);
sl@0	3654	if(errno==ENOMEM)
sl@0	3655	return 0;
sl@0	3656	BN_free(e);
sl@0	3657	if(errno==ENOMEM)
sl@0	3658	return 0;
sl@0	3659	BN_free(f);
sl@0	3660	if(errno==ENOMEM)
sl@0	3661	return 0;
sl@0	3662	return ret;
sl@0	3663	}
sl@0	3664
sl@0	3665	int test_gf2m_mod_sqrt(BIO bp,BN_CTX ctx)
sl@0	3666	{
sl@0	3667	BIGNUM a,b[2],c,d,e,f;
sl@0	3668	int i, j, ret = 0;
sl@0	3669	unsigned int p0[] = {163,7,6,3,0};
sl@0	3670	unsigned int p1[] = {193,15,0};
sl@0	3671
sl@0	3672	a=BN_new();
sl@0	3673	if(errno==ENOMEM)
sl@0	3674	return 0;
sl@0	3675	b[0]=BN_new();
sl@0	3676	if(errno==ENOMEM)
sl@0	3677	return 0;
sl@0	3678	b[1]=BN_new();
sl@0	3679	if(errno==ENOMEM)
sl@0	3680	return 0;
sl@0	3681	c=BN_new();
sl@0	3682	if(errno==ENOMEM)
sl@0	3683	return 0;
sl@0	3684	d=BN_new();
sl@0	3685	if(errno==ENOMEM)
sl@0	3686	return 0;
sl@0	3687	e=BN_new();
sl@0	3688	if(errno==ENOMEM)
sl@0	3689	return 0;
sl@0	3690	f=BN_new();
sl@0	3691	if(errno==ENOMEM)
sl@0	3692	return 0;
sl@0	3693
sl@0	3694	BN_GF2m_arr2poly(p0, b[0]);
sl@0	3695	if(errno==ENOMEM)
sl@0	3696	return 0;
sl@0	3697	BN_GF2m_arr2poly(p1, b[1]);
sl@0	3698	if(errno==ENOMEM)
sl@0	3699	return 0;
sl@0	3700
sl@0	3701	for (i=0; i<num0; i++)
sl@0	3702	{
sl@0	3703	BN_bntest_rand(a, 512, 0, 0);
sl@0	3704	if(errno==ENOMEM)
sl@0	3705	return 0;
sl@0	3706	for (j=0; j < 2; j++)
sl@0	3707	{
sl@0	3708	BN_GF2m_mod(c, a, b[j]);
sl@0	3709	if(errno==ENOMEM)
sl@0	3710	return 0;
sl@0	3711	BN_GF2m_mod_sqrt(d, a, b[j], ctx);
sl@0	3712	if(errno==ENOMEM)
sl@0	3713	return 0;
sl@0	3714	BN_GF2m_mod_sqr(e, d, b[j], ctx);
sl@0	3715	if(errno==ENOMEM)
sl@0	3716	return 0;
sl@0	3717	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3718	if (bp != NULL)
sl@0	3719	{
sl@0	3720	if (!results)
sl@0	3721	{
sl@0	3722	BN_print(bp,d);
sl@0	3723	if(errno==ENOMEM)
sl@0	3724	return 0;
sl@0	3725	BIO_puts(bp, " ^ 2 - ");
sl@0	3726	if(errno==ENOMEM)
sl@0	3727	return 0;
sl@0	3728	BN_print(bp,a);
sl@0	3729	if(errno==ENOMEM)
sl@0	3730	return 0;
sl@0	3731	BIO_puts(bp,"\n");
sl@0	3732	if(errno==ENOMEM)
sl@0	3733	return 0;
sl@0	3734	}
sl@0	3735	}
sl@0	3736	#endif
sl@0	3737	BN_GF2m_add(f, c, e);
sl@0	3738	if(errno==ENOMEM)
sl@0	3739	return 0;
sl@0	3740	/* Test that d^2 = a, where d = sqrt(a). */
sl@0	3741	if(!BN_is_zero(f))
sl@0	3742	{
sl@0	3743	if(errno==ENOMEM)
sl@0	3744	return 0;
sl@0	3745	fprintf(stderr,"GF(2^m) modular square root test failed!\n");
sl@0	3746	goto err;
sl@0	3747	}
sl@0	3748	}
sl@0	3749	}
sl@0	3750	ret = 1;
sl@0	3751	err:
sl@0	3752	BN_free(a);
sl@0	3753	if(errno==ENOMEM)
sl@0	3754	return 0;
sl@0	3755	BN_free(b[0]);
sl@0	3756	if(errno==ENOMEM)
sl@0	3757	return 0;
sl@0	3758	BN_free(b[1]);
sl@0	3759	if(errno==ENOMEM)
sl@0	3760	return 0;
sl@0	3761	BN_free(c);
sl@0	3762	if(errno==ENOMEM)
sl@0	3763	return 0;
sl@0	3764	BN_free(d);
sl@0	3765	if(errno==ENOMEM)
sl@0	3766	return 0;
sl@0	3767	BN_free(e);
sl@0	3768	if(errno==ENOMEM)
sl@0	3769	return 0;
sl@0	3770	BN_free(f);
sl@0	3771	if(errno==ENOMEM)
sl@0	3772	return 0;
sl@0	3773	return ret;
sl@0	3774	}
sl@0	3775
sl@0	3776	int test_gf2m_mod_solve_quad(BIO bp,BN_CTX ctx)
sl@0	3777	{
sl@0	3778	BIGNUM a,b[2],c,d,*e;
sl@0	3779	int i, j, s = 0, t, ret = 0;
sl@0	3780	unsigned int p0[] = {163,7,6,3,0};
sl@0	3781	unsigned int p1[] = {193,15,0};
sl@0	3782
sl@0	3783	a=BN_new();
sl@0	3784	if(errno==ENOMEM)
sl@0	3785	return 0;
sl@0	3786	b[0]=BN_new();
sl@0	3787	if(errno==ENOMEM)
sl@0	3788	return 0;
sl@0	3789	b[1]=BN_new();
sl@0	3790	if(errno==ENOMEM)
sl@0	3791	return 0;
sl@0	3792	c=BN_new();
sl@0	3793	if(errno==ENOMEM)
sl@0	3794	return 0;
sl@0	3795	d=BN_new();
sl@0	3796	if(errno==ENOMEM)
sl@0	3797	return 0;
sl@0	3798	e=BN_new();
sl@0	3799	if(errno==ENOMEM)
sl@0	3800	return 0;
sl@0	3801
sl@0	3802	BN_GF2m_arr2poly(p0, b[0]);
sl@0	3803	if(errno==ENOMEM)
sl@0	3804	return 0;
sl@0	3805	BN_GF2m_arr2poly(p1, b[1]);
sl@0	3806	if(errno==ENOMEM)
sl@0	3807	return 0;
sl@0	3808
sl@0	3809	for (i=0; i<num0; i++)
sl@0	3810	{
sl@0	3811	BN_bntest_rand(a, 512, 0, 0);
sl@0	3812	if(errno==ENOMEM)
sl@0	3813	return 0;
sl@0	3814	for (j=0; j < 2; j++)
sl@0	3815	{
sl@0	3816	t = BN_GF2m_mod_solve_quad(c, a, b[j], ctx);
sl@0	3817	if(errno==ENOMEM)
sl@0	3818	return 0;
sl@0	3819	if (t)
sl@0	3820	{
sl@0	3821	s++;
sl@0	3822	BN_GF2m_mod_sqr(d, c, b[j], ctx);
sl@0	3823	if(errno==ENOMEM)
sl@0	3824	return 0;
sl@0	3825	BN_GF2m_add(d, c, d);
sl@0	3826	if(errno==ENOMEM)
sl@0	3827	return 0;
sl@0	3828	BN_GF2m_mod(e, a, b[j]);
sl@0	3829	if(errno==ENOMEM)
sl@0	3830	return 0;
sl@0	3831	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3832	if (bp != NULL)
sl@0	3833	{
sl@0	3834	if (!results)
sl@0	3835	{
sl@0	3836	BN_print(bp,c);
sl@0	3837	BIO_puts(bp, " is root of z^2 + z = ");
sl@0	3838	BN_print(bp,a);
sl@0	3839	BIO_puts(bp, " % ");
sl@0	3840	BN_print(bp,b[j]);
sl@0	3841	BIO_puts(bp, "\n");
sl@0	3842	}
sl@0	3843	}
sl@0	3844	#endif
sl@0	3845	BN_GF2m_add(e, e, d);
sl@0	3846	if(errno==ENOMEM)
sl@0	3847	return 0;
sl@0	3848	/* Test that solution of quadratic c satisfies c^2 + c = a. */
sl@0	3849	if(!BN_is_zero(e))
sl@0	3850	{
sl@0	3851	if(errno==ENOMEM)
sl@0	3852	return 0;
sl@0	3853	fprintf(stderr,"GF(2^m) modular solve quadratic test failed!\n");
sl@0	3854	goto err;
sl@0	3855	}
sl@0	3856
sl@0	3857	}
sl@0	3858	else
sl@0	3859	{
sl@0	3860	#if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
sl@0	3861	if (bp != NULL)
sl@0	3862	{
sl@0	3863	if (!results)
sl@0	3864	{
sl@0	3865	BIO_puts(bp, "There are no roots of z^2 + z = ");
sl@0	3866	if(errno==ENOMEM)
sl@0	3867	return 0;
sl@0	3868	BN_print(bp,a);
sl@0	3869	if(errno==ENOMEM)
sl@0	3870	return 0;
sl@0	3871	BIO_puts(bp, " % ");
sl@0	3872	if(errno==ENOMEM)
sl@0	3873	return 0;
sl@0	3874	BN_print(bp,b[j]);
sl@0	3875	if(errno==ENOMEM)
sl@0	3876	return 0;
sl@0	3877	BIO_puts(bp, "\n");
sl@0	3878	if(errno==ENOMEM)
sl@0	3879	return 0;
sl@0	3880	}
sl@0	3881	}
sl@0	3882	#endif
sl@0	3883	}
sl@0	3884	}
sl@0	3885	}
sl@0	3886	if (s == 0)
sl@0	3887	{
sl@0	3888	fprintf(stderr,"All %i tests of GF(2^m) modular solve quadratic resulted in no roots;\n", num0);
sl@0	3889	fprintf(stderr,"this is very unlikely and probably indicates an error.\n");
sl@0	3890	goto err;
sl@0	3891	}
sl@0	3892	ret = 1;
sl@0	3893	err:
sl@0	3894	BN_free(a);
sl@0	3895	if(errno==ENOMEM)
sl@0	3896	return 0;
sl@0	3897	BN_free(b[0]);
sl@0	3898	if(errno==ENOMEM)
sl@0	3899	return 0;
sl@0	3900	BN_free(b[1]);
sl@0	3901	if(errno==ENOMEM)
sl@0	3902	return 0;
sl@0	3903	BN_free(c);
sl@0	3904	if(errno==ENOMEM)
sl@0	3905	return 0;
sl@0	3906	BN_free(d);
sl@0	3907	if(errno==ENOMEM)
sl@0	3908	return 0;
sl@0	3909	BN_free(e);
sl@0	3910	if(errno==ENOMEM)
sl@0	3911	return 0;
sl@0	3912	return ret;
sl@0	3913	}
sl@0	3914
sl@0	3915	static int genprime_cb(int p, int n, BN_GENCB *arg)
sl@0	3916	{
sl@0	3917	char c='*';
sl@0	3918
sl@0	3919	if (p == 0) c='.';
sl@0	3920	if (p == 1) c='+';
sl@0	3921	if (p == 2) c='*';
sl@0	3922	if (p == 3) c='\n';
sl@0	3923	putc(c, stderr);
sl@0	3924	fflush(stderr);
sl@0	3925	return 1;
sl@0	3926	}
sl@0	3927
sl@0	3928	int test_kron(BIO bp, BN_CTX ctx)
sl@0	3929	{
sl@0	3930	BN_GENCB cb;
sl@0	3931	BIGNUM a,b,r,t;
sl@0	3932	int i;
sl@0	3933	int legendre, kronecker;
sl@0	3934	int ret = 0;
sl@0	3935
sl@0	3936	a = BN_new();
sl@0	3937	if(errno==ENOMEM)
sl@0	3938	return 0;
sl@0	3939	b = BN_new();
sl@0	3940	if(errno==ENOMEM)
sl@0	3941	return 0;
sl@0	3942	r = BN_new();
sl@0	3943	if(errno==ENOMEM)
sl@0	3944	return 0;
sl@0	3945	t = BN_new();
sl@0	3946	if(errno==ENOMEM)
sl@0	3947	return 0;
sl@0	3948	if (a == NULL \|\| b == NULL \|\| r == NULL \|\| t == NULL) goto err;
sl@0	3949
sl@0	3950	BN_GENCB_set(&cb, genprime_cb, NULL);
sl@0	3951	if(errno==ENOMEM)
sl@0	3952	return 0;
sl@0	3953
sl@0	3954	/* We test BN_kronecker(a, b, ctx) just for b odd (Jacobi symbol).
sl@0	3955	* In this case we know that if b is prime, then BN_kronecker(a, b, ctx)
sl@0	3956	* is congruent to $a^{(b-1)/2}$, modulo $b$ (Legendre symbol).
sl@0	3957	* So we generate a random prime b and compare these values
sl@0	3958	* for a number of random a's. (That is, we run the Solovay-Strassen
sl@0	3959	* primality test to confirm that b is prime, except that we
sl@0	3960	* don't want to test whether b is prime but whether BN_kronecker
sl@0	3961	* works.) */
sl@0	3962
sl@0	3963	if (!BN_generate_prime_ex(b, 512, 0, NULL, NULL, &cb))
sl@0	3964	{
sl@0	3965
sl@0	3966	if(errno==ENOMEM)
sl@0	3967	return 0;
sl@0	3968	goto err;
sl@0	3969	}
sl@0	3970	b->neg = rand_neg();
sl@0	3971
sl@0	3972	if(errno==ENOMEM)
sl@0	3973	return 0;
sl@0	3974	putc('\n', stderr);
sl@0	3975
sl@0	3976	for (i = 0; i < num0; i++)
sl@0	3977	{
sl@0	3978	if (!BN_bntest_rand(a, 512, 0, 0))
sl@0	3979	{
sl@0	3980	if(errno==ENOMEM)
sl@0	3981	return 0;
sl@0	3982	goto err;
sl@0	3983	}
sl@0	3984	a->neg = rand_neg();
sl@0	3985
sl@0	3986	if(errno==ENOMEM)
sl@0	3987	return 0;
sl@0	3988
sl@0	3989	/* t := (\|b\|-1)/2 (note that b is odd) */
sl@0	3990	if (!BN_copy(t, b)) goto err;
sl@0	3991	t->neg = 0;
sl@0	3992	if (!BN_sub_word(t, 1)) goto err;
sl@0	3993	if (!BN_rshift1(t, t)) goto err;
sl@0	3994	/* r := a^t mod b */
sl@0	3995	b->neg=0;
sl@0	3996
sl@0	3997	if (!BN_mod_exp_recp(r, a, t, b, ctx)) goto err;
sl@0	3998	b->neg=1;
sl@0	3999
sl@0	4000	if (BN_is_word(r, 1))
sl@0	4001	legendre = 1;
sl@0	4002	else if (BN_is_zero(r))
sl@0	4003	legendre = 0;
sl@0	4004	else
sl@0	4005	{
sl@0	4006	if (!BN_add_word(r, 1)) goto err;
sl@0	4007	if (0 != BN_ucmp(r, b))
sl@0	4008	{
sl@0	4009	fprintf(stderr, "Legendre symbol computation failed\n");
sl@0	4010	goto err;
sl@0	4011	}
sl@0	4012	legendre = -1;
sl@0	4013	}
sl@0	4014
sl@0	4015	kronecker = BN_kronecker(a, b, ctx);
sl@0	4016	if (kronecker < -1) goto err;
sl@0	4017	/* we actually need BN_kronecker(a, \|b\|) */
sl@0	4018	if (a->neg && b->neg)
sl@0	4019	kronecker = -kronecker;
sl@0	4020
sl@0	4021	if (legendre != kronecker)
sl@0	4022	{
sl@0	4023	fprintf(stderr, "legendre != kronecker; a = ");
sl@0	4024	BN_print_fp(stderr, a);
sl@0	4025	fprintf(stderr, ", b = ");
sl@0	4026	BN_print_fp(stderr, b);
sl@0	4027	fprintf(stderr, "\n");
sl@0	4028	goto err;
sl@0	4029	}
sl@0	4030
sl@0	4031	putc('.', stderr);
sl@0	4032	fflush(stderr);
sl@0	4033	}
sl@0	4034
sl@0	4035	putc('\n', stderr);
sl@0	4036	fflush(stderr);
sl@0	4037	ret = 1;
sl@0	4038	err:
sl@0	4039	if (a != NULL) BN_free(a);
sl@0	4040	if (b != NULL) BN_free(b);
sl@0	4041	if (r != NULL) BN_free(r);
sl@0	4042	if (t != NULL) BN_free(t);
sl@0	4043	if(errno==ENOMEM)
sl@0	4044	return 0;
sl@0	4045	return ret;
sl@0	4046	}
sl@0	4047
sl@0	4048	int test_sqrt(BIO bp, BN_CTX ctx)
sl@0	4049	{
sl@0	4050	BN_GENCB cb;
sl@0	4051	BIGNUM a,p,*r;
sl@0	4052	int i, j;
sl@0	4053	int ret = 0;
sl@0	4054
sl@0	4055	a = BN_new();
sl@0	4056	if(errno==ENOMEM)
sl@0	4057	return 0;
sl@0	4058	p = BN_new();
sl@0	4059	if(errno==ENOMEM)
sl@0	4060	return 0;
sl@0	4061	r = BN_new();
sl@0	4062	if(errno==ENOMEM)
sl@0	4063	return 0;
sl@0	4064	if (a == NULL \|\| p == NULL \|\| r == NULL) goto err;
sl@0	4065
sl@0	4066	BN_GENCB_set(&cb, genprime_cb, NULL);
sl@0	4067	if(errno==ENOMEM)
sl@0	4068	return 0;
sl@0	4069
sl@0	4070	for (i = 0; i < 16; i++)
sl@0	4071	{
sl@0	4072	if (i < 8)
sl@0	4073	{
sl@0	4074	unsigned primes[8] = { 2, 3, 5, 7, 11, 13, 17, 19 };
sl@0	4075
sl@0	4076	if (!BN_set_word(p, primes[i])) goto err;
sl@0	4077	}
sl@0	4078	else
sl@0	4079	{
sl@0	4080	if (!BN_set_word(a, 32)) goto err;
sl@0	4081	if (!BN_set_word(r, 2*i + 1)) goto err;
sl@0	4082
sl@0	4083	if (!BN_generate_prime_ex(p, 256, 0, a, r, &cb)) goto err;
sl@0	4084	putc('\n', stderr);
sl@0	4085	}
sl@0	4086	p->neg = rand_neg();
sl@0	4087
sl@0	4088	if(errno==ENOMEM)
sl@0	4089	return 0;
sl@0	4090	for (j = 0; j < num2; j++)
sl@0	4091	{
sl@0	4092	/* construct 'a' such that it is a square modulo p,
sl@0	4093	* but in general not a proper square and not reduced modulo p */
sl@0	4094	if (!BN_bntest_rand(r, 256, 0, 3)) goto err;
sl@0	4095	if (!BN_nnmod(r, r, p, ctx)) goto err;
sl@0	4096	if (!BN_mod_sqr(r, r, p, ctx)) goto err;
sl@0	4097	if (!BN_bntest_rand(a, 256, 0, 3)) goto err;
sl@0	4098	if (!BN_nnmod(a, a, p, ctx)) goto err;
sl@0	4099	if (!BN_mod_sqr(a, a, p, ctx)) goto err;
sl@0	4100	if (!BN_mul(a, a, r, ctx)) goto err;
sl@0	4101	if (rand_neg())
sl@0	4102	if (!BN_sub(a, a, p)) goto err;
sl@0	4103
sl@0	4104	if (!BN_mod_sqrt(r, a, p, ctx)) goto err;
sl@0	4105	if (!BN_mod_sqr(r, r, p, ctx)) goto err;
sl@0	4106
sl@0	4107	if (!BN_nnmod(a, a, p, ctx)) goto err;
sl@0	4108
sl@0	4109	if (BN_cmp(a, r) != 0)
sl@0	4110	{
sl@0	4111	fprintf(stderr, "BN_mod_sqrt failed: a = ");
sl@0	4112	BN_print_fp(stderr, a);
sl@0	4113	fprintf(stderr, ", r = ");
sl@0	4114	BN_print_fp(stderr, r);
sl@0	4115	fprintf(stderr, ", p = ");
sl@0	4116	BN_print_fp(stderr, p);
sl@0	4117	fprintf(stderr, "\n");
sl@0	4118	goto err;
sl@0	4119	}
sl@0	4120
sl@0	4121	putc('.', stderr);
sl@0	4122	fflush(stderr);
sl@0	4123	}
sl@0	4124
sl@0	4125	putc('\n', stderr);
sl@0	4126	fflush(stderr);
sl@0	4127	}
sl@0	4128	ret = 1;
sl@0	4129	err:
sl@0	4130	if (a != NULL) BN_free(a);
sl@0	4131	if (p != NULL) BN_free(p);
sl@0	4132	if (r != NULL) BN_free(r);
sl@0	4133
sl@0	4134	if(errno==ENOMEM)
sl@0	4135	return 0;
sl@0	4136	return ret;
sl@0	4137	}
sl@0	4138
sl@0	4139	int test_lshift(BIO bp,BN_CTX ctx,BIGNUM *a_)
sl@0	4140	{
sl@0	4141	BIGNUM a,b,c,d;
sl@0	4142	int i;
sl@0	4143
sl@0	4144	b=BN_new();
sl@0	4145	if(errno==ENOMEM)
sl@0	4146	return 0;
sl@0	4147	c=BN_new();
sl@0	4148	if(errno==ENOMEM)
sl@0	4149	return 0;
sl@0	4150	d=BN_new();
sl@0	4151	if(errno==ENOMEM)
sl@0	4152	return 0;
sl@0	4153	BN_one(c);
sl@0	4154	if(errno==ENOMEM)
sl@0	4155	return 0;
sl@0	4156
sl@0	4157	if(a_)
sl@0	4158	a=a_;
sl@0	4159	else
sl@0	4160	{
sl@0	4161	a=BN_new();
sl@0	4162	if(errno==ENOMEM)
sl@0	4163	return 0;
sl@0	4164	BN_bntest_rand(a,200,0,0); /**/
sl@0	4165	if(errno==ENOMEM)
sl@0	4166	return 0;
sl@0	4167	a->neg=rand_neg();
sl@0	4168	if(errno==ENOMEM)
sl@0	4169	return 0;
sl@0	4170	}
sl@0	4171	for (i=0; i<num0; i++)
sl@0	4172	{
sl@0	4173	BN_lshift(b,a,i+1);
sl@0	4174	if(errno==ENOMEM)
sl@0	4175	return 0;
sl@0	4176	BN_add(c,c,c);
sl@0	4177	if(errno==ENOMEM)
sl@0	4178	return 0;
sl@0	4179	if (bp != NULL)
sl@0	4180	{
sl@0	4181	if (!results)
sl@0	4182	{
sl@0	4183	BN_print(bp,a);
sl@0	4184	if(errno==ENOMEM)
sl@0	4185	return 0;
sl@0	4186	BIO_puts(bp," * ");
sl@0	4187	if(errno==ENOMEM)
sl@0	4188	return 0;
sl@0	4189	BN_print(bp,c);
sl@0	4190	if(errno==ENOMEM)
sl@0	4191	return 0;
sl@0	4192	BIO_puts(bp," - ");
sl@0	4193	if(errno==ENOMEM)
sl@0	4194	return 0;
sl@0	4195	}
sl@0	4196	BN_print(bp,b);
sl@0	4197	if(errno==ENOMEM)
sl@0	4198	return 0;
sl@0	4199	BIO_puts(bp,"\n");
sl@0	4200	if(errno==ENOMEM)
sl@0	4201	return 0;
sl@0	4202	}
sl@0	4203	BN_mul(d,a,c,ctx);
sl@0	4204	if(errno==ENOMEM)
sl@0	4205	return 0;
sl@0	4206	BN_sub(d,d,b);
sl@0	4207	if(errno==ENOMEM)
sl@0	4208	return 0;
sl@0	4209	if(!BN_is_zero(d))
sl@0	4210	{
sl@0	4211	if(errno==ENOMEM)
sl@0	4212	return 0;
sl@0	4213	fprintf(stderr,"Left shift test failed!\n");
sl@0	4214	fprintf(stderr,"a=");
sl@0	4215	BN_print_fp(stderr,a);
sl@0	4216	if(errno==ENOMEM)
sl@0	4217	return 0;
sl@0	4218	fprintf(stderr,"\nb=");
sl@0	4219	BN_print_fp(stderr,b);
sl@0	4220	if(errno==ENOMEM)
sl@0	4221	return 0;
sl@0	4222	fprintf(stderr,"\nc=");
sl@0	4223	BN_print_fp(stderr,c);
sl@0	4224	if(errno==ENOMEM)
sl@0	4225	return 0;
sl@0	4226	fprintf(stderr,"\nd=");
sl@0	4227	BN_print_fp(stderr,d);
sl@0	4228	if(errno==ENOMEM)
sl@0	4229	return 0;
sl@0	4230	fprintf(stderr,"\n");
sl@0	4231	return 0;
sl@0	4232	}
sl@0	4233	}
sl@0	4234	BN_free(a);
sl@0	4235	if(errno==ENOMEM)
sl@0	4236	return 0;
sl@0	4237	BN_free(b);
sl@0	4238	if(errno==ENOMEM)
sl@0	4239	return 0;
sl@0	4240	BN_free(c);
sl@0	4241	if(errno==ENOMEM)
sl@0	4242	return 0;
sl@0	4243	BN_free(d);
sl@0	4244	if(errno==ENOMEM)
sl@0	4245	return 0;
sl@0	4246	return(1);
sl@0	4247	}
sl@0	4248
sl@0	4249	int test_lshift1(BIO *bp)
sl@0	4250	{
sl@0	4251	BIGNUM a,b,*c;
sl@0	4252	int i;
sl@0	4253
sl@0	4254	a=BN_new();
sl@0	4255	if(errno==ENOMEM)
sl@0	4256	return 0;
sl@0	4257	b=BN_new();
sl@0	4258	if(errno==ENOMEM)
sl@0	4259	return 0;
sl@0	4260	c=BN_new();
sl@0	4261	if(errno==ENOMEM)
sl@0	4262	return 0;
sl@0	4263
sl@0	4264	BN_bntest_rand(a,200,0,0); /**/
sl@0	4265	if(errno==ENOMEM)
sl@0	4266	return 0;
sl@0	4267	a->neg=rand_neg();
sl@0	4268	if(errno==ENOMEM)
sl@0	4269	return 0;
sl@0	4270	for (i=0; i<num0; i++)
sl@0	4271	{
sl@0	4272	BN_lshift1(b,a);
sl@0	4273	if(errno==ENOMEM)
sl@0	4274	return 0;
sl@0	4275	if (bp != NULL)
sl@0	4276	{
sl@0	4277	if (!results)
sl@0	4278	{
sl@0	4279	BN_print(bp,a);
sl@0	4280	if(errno==ENOMEM)
sl@0	4281	return 0;
sl@0	4282	BIO_puts(bp," * 2");
sl@0	4283	if(errno==ENOMEM)
sl@0	4284	return 0;
sl@0	4285	BIO_puts(bp," - ");
sl@0	4286	if(errno==ENOMEM)
sl@0	4287	return 0;
sl@0	4288	}
sl@0	4289	BN_print(bp,b);
sl@0	4290	if(errno==ENOMEM)
sl@0	4291	return 0;
sl@0	4292	BIO_puts(bp,"\n");
sl@0	4293	if(errno==ENOMEM)
sl@0	4294	return 0;
sl@0	4295	}
sl@0	4296	BN_add(c,a,a);
sl@0	4297	if(errno==ENOMEM)
sl@0	4298	return 0;
sl@0	4299	BN_sub(a,b,c);
sl@0	4300	if(errno==ENOMEM)
sl@0	4301	return 0;
sl@0	4302	if(!BN_is_zero(a))
sl@0	4303	{
sl@0	4304	if(errno==ENOMEM)
sl@0	4305	return 0;
sl@0	4306	fprintf(stderr,"Left shift one test failed!\n");
sl@0	4307	return 0;
sl@0	4308	}
sl@0	4309
sl@0	4310	BN_copy(a,b);
sl@0	4311	if(errno==ENOMEM)
sl@0	4312	return 0;
sl@0	4313	}
sl@0	4314	BN_free(a);
sl@0	4315	if(errno==ENOMEM)
sl@0	4316	return 0;
sl@0	4317	BN_free(b);
sl@0	4318	if(errno==ENOMEM)
sl@0	4319	return 0;
sl@0	4320	BN_free(c);
sl@0	4321	if(errno==ENOMEM)
sl@0	4322	return 0;
sl@0	4323	return(1);
sl@0	4324	}
sl@0	4325
sl@0	4326	int test_rshift(BIO bp,BN_CTX ctx)
sl@0	4327	{
sl@0	4328	BIGNUM a,b,c,d,*e;
sl@0	4329	int i;
sl@0	4330
sl@0	4331	a=BN_new();
sl@0	4332	if(errno==ENOMEM)
sl@0	4333	return 0;
sl@0	4334	b=BN_new();
sl@0	4335	if(errno==ENOMEM)
sl@0	4336	return 0;
sl@0	4337	c=BN_new();
sl@0	4338	if(errno==ENOMEM)
sl@0	4339	return 0;
sl@0	4340	d=BN_new();
sl@0	4341	if(errno==ENOMEM)
sl@0	4342	return 0;
sl@0	4343	e=BN_new();
sl@0	4344	if(errno==ENOMEM)
sl@0	4345	return 0;
sl@0	4346	BN_one(c);
sl@0	4347	if(errno==ENOMEM)
sl@0	4348	return 0;
sl@0	4349
sl@0	4350	BN_bntest_rand(a,200,0,0); /**/
sl@0	4351	if(errno==ENOMEM)
sl@0	4352	return 0;
sl@0	4353	a->neg=rand_neg();
sl@0	4354	if(errno==ENOMEM)
sl@0	4355	return 0;
sl@0	4356	for (i=0; i<num0; i++)
sl@0	4357	{
sl@0	4358	BN_rshift(b,a,i+1);
sl@0	4359	if(errno==ENOMEM)
sl@0	4360	return 0;
sl@0	4361	BN_add(c,c,c);
sl@0	4362	if(errno==ENOMEM)
sl@0	4363	return 0;
sl@0	4364	if (bp != NULL)
sl@0	4365	{
sl@0	4366	if (!results)
sl@0	4367	{
sl@0	4368	BN_print(bp,a);
sl@0	4369	if(errno==ENOMEM)
sl@0	4370	return 0;
sl@0	4371	BIO_puts(bp," / ");
sl@0	4372	if(errno==ENOMEM)
sl@0	4373	return 0;
sl@0	4374	BN_print(bp,c);
sl@0	4375	if(errno==ENOMEM)
sl@0	4376	return 0;
sl@0	4377	BIO_puts(bp," - ");
sl@0	4378	if(errno==ENOMEM)
sl@0	4379	return 0;
sl@0	4380	}
sl@0	4381	BN_print(bp,b);
sl@0	4382	if(errno==ENOMEM)
sl@0	4383	return 0;
sl@0	4384	BIO_puts(bp,"\n");
sl@0	4385	if(errno==ENOMEM)
sl@0	4386	return 0;
sl@0	4387	}
sl@0	4388	BN_div(d,e,a,c,ctx);
sl@0	4389	if(errno==ENOMEM)
sl@0	4390	return 0;
sl@0	4391	BN_sub(d,d,b);
sl@0	4392	if(errno==ENOMEM)
sl@0	4393	return 0;
sl@0	4394	if(!BN_is_zero(d))
sl@0	4395	{
sl@0	4396	if(errno==ENOMEM)
sl@0	4397	return 0;
sl@0	4398	fprintf(stderr,"Right shift test failed!\n");
sl@0	4399	return 0;
sl@0	4400	}
sl@0	4401	}
sl@0	4402	BN_free(a);
sl@0	4403	if(errno==ENOMEM)
sl@0	4404	return 0;
sl@0	4405	BN_free(b);
sl@0	4406	if(errno==ENOMEM)
sl@0	4407	return 0;
sl@0	4408	BN_free(c);
sl@0	4409	if(errno==ENOMEM)
sl@0	4410	return 0;
sl@0	4411	BN_free(d);
sl@0	4412	if(errno==ENOMEM)
sl@0	4413	return 0;
sl@0	4414	BN_free(e);
sl@0	4415	if(errno==ENOMEM)
sl@0	4416	return 0;
sl@0	4417	return(1);
sl@0	4418	}
sl@0	4419
sl@0	4420	int test_rshift1(BIO *bp)
sl@0	4421	{
sl@0	4422	BIGNUM a,b,*c;
sl@0	4423	int i;
sl@0	4424
sl@0	4425	a=BN_new();
sl@0	4426	if(errno==ENOMEM)
sl@0	4427	return 0;
sl@0	4428	b=BN_new();
sl@0	4429	if(errno==ENOMEM)
sl@0	4430	return 0;
sl@0	4431	c=BN_new();
sl@0	4432	if(errno==ENOMEM)
sl@0	4433	return 0;
sl@0	4434
sl@0	4435	BN_bntest_rand(a,200,0,0); /**/
sl@0	4436	if(errno==ENOMEM)
sl@0	4437	return 0;
sl@0	4438	a->neg=rand_neg();
sl@0	4439	if(errno==ENOMEM)
sl@0	4440	return 0;
sl@0	4441	for (i=0; i<num0; i++)
sl@0	4442	{
sl@0	4443	BN_rshift1(b,a);
sl@0	4444	if(errno==ENOMEM)
sl@0	4445	return 0;
sl@0	4446	if (bp != NULL)
sl@0	4447	{
sl@0	4448	if (!results)
sl@0	4449	{
sl@0	4450	BN_print(bp,a);
sl@0	4451	if(errno==ENOMEM)
sl@0	4452	return 0;
sl@0	4453	BIO_puts(bp," / 2");
sl@0	4454	if(errno==ENOMEM)
sl@0	4455	return 0;
sl@0	4456	BIO_puts(bp," - ");
sl@0	4457	if(errno==ENOMEM)
sl@0	4458	return 0;
sl@0	4459	}
sl@0	4460	BN_print(bp,b);
sl@0	4461	if(errno==ENOMEM)
sl@0	4462	return 0;
sl@0	4463	BIO_puts(bp,"\n");
sl@0	4464	if(errno==ENOMEM)
sl@0	4465	return 0;
sl@0	4466	}
sl@0	4467	BN_sub(c,a,b);
sl@0	4468	if(errno==ENOMEM)
sl@0	4469	return 0;
sl@0	4470	BN_sub(c,c,b);
sl@0	4471	if(errno==ENOMEM)
sl@0	4472	return 0;
sl@0	4473	if(!BN_is_zero(c) && !BN_abs_is_word(c, 1))
sl@0	4474	{
sl@0	4475	if(errno==ENOMEM)
sl@0	4476	return 0;
sl@0	4477	fprintf(stderr,"Right shift one test failed!\n");
sl@0	4478	return 0;
sl@0	4479	}
sl@0	4480	BN_copy(a,b);
sl@0	4481	if(errno==ENOMEM)
sl@0	4482	return 0;
sl@0	4483	}
sl@0	4484	BN_free(a);
sl@0	4485	if(errno==ENOMEM)
sl@0	4486	return 0;
sl@0	4487	BN_free(b);
sl@0	4488	if(errno==ENOMEM)
sl@0	4489	return 0;
sl@0	4490	BN_free(c);
sl@0	4491	if(errno==ENOMEM)
sl@0	4492	return 0;
sl@0	4493	return(1);
sl@0	4494	}
sl@0	4495
sl@0	4496	int rand_neg(void)
sl@0	4497	{
sl@0	4498	static unsigned int neg=0;
sl@0	4499	static int sign[8]={0,0,0,1,1,0,1,1};
sl@0	4500
sl@0	4501	return(sign[(neg++)%8]);
sl@0	4502	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--