CyaSSL-Encryp - cya_u

Users » vbahl2 » Code » CyaSSL-Encryp

cya_u

Fork of CyaSSL-forEncrypt by Mobius IoT

integer.c@2:d0516dc143b1, 2017-05-10 (annotated)

Committer:: vbahl2
Date:: Wed May 10 18:20:47 2017 +0000
Revision:: 2:d0516dc143b1
Parent:: 0:5045d2638c29

updated

Who changed what in which revision?

User	Revision	Line number	New contents of line
toddouska	0:5045d2638c29	1	/* integer.c
toddouska	0:5045d2638c29	2	*
toddouska	0:5045d2638c29	3	* Copyright (C) 2006-2009 Sawtooth Consulting Ltd.
toddouska	0:5045d2638c29	4	*
toddouska	0:5045d2638c29	5	* This file is part of CyaSSL.
toddouska	0:5045d2638c29	6	*
toddouska	0:5045d2638c29	7	* CyaSSL is free software; you can redistribute it and/or modify
toddouska	0:5045d2638c29	8	* it under the terms of the GNU General Public License as published by
toddouska	0:5045d2638c29	9	* the Free Software Foundation; either version 2 of the License, or
toddouska	0:5045d2638c29	10	* (at your option) any later version.
toddouska	0:5045d2638c29	11	*
toddouska	0:5045d2638c29	12	* CyaSSL is distributed in the hope that it will be useful,
toddouska	0:5045d2638c29	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
toddouska	0:5045d2638c29	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
toddouska	0:5045d2638c29	15	* GNU General Public License for more details.
toddouska	0:5045d2638c29	16	*
toddouska	0:5045d2638c29	17	* You should have received a copy of the GNU General Public License
toddouska	0:5045d2638c29	18	* along with this program; if not, write to the Free Software
toddouska	0:5045d2638c29	19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
toddouska	0:5045d2638c29	20	*/
toddouska	0:5045d2638c29	21
toddouska	0:5045d2638c29	22	/*
toddouska	0:5045d2638c29	23	* Based on public domain LibTomMath 0.38 by Tom St Denis, tomstdenis@iahu.ca,
toddouska	0:5045d2638c29	24	* http://math.libtomcrypt.com
toddouska	0:5045d2638c29	25	*/
toddouska	0:5045d2638c29	26
toddouska	0:5045d2638c29	27
toddouska	0:5045d2638c29	28	#ifndef USE_FAST_MATH
toddouska	0:5045d2638c29	29
toddouska	0:5045d2638c29	30	#include "integer.h"
toddouska	0:5045d2638c29	31
toddouska	0:5045d2638c29	32
toddouska	0:5045d2638c29	33	/* handle up to 6 inits */
toddouska	0:5045d2638c29	34	int mp_init_multi(mp_int* a, mp_int* b, mp_int* c, mp_int* d, mp_int* e,
toddouska	0:5045d2638c29	35	mp_int* f)
toddouska	0:5045d2638c29	36	{
toddouska	0:5045d2638c29	37	int res = MP_OKAY;
toddouska	0:5045d2638c29	38
toddouska	0:5045d2638c29	39	if (a && ((res = mp_init(a)) != MP_OKAY))
toddouska	0:5045d2638c29	40	return res;
toddouska	0:5045d2638c29	41
toddouska	0:5045d2638c29	42	if (b && ((res = mp_init(b)) != MP_OKAY)) {
toddouska	0:5045d2638c29	43	mp_clear(a);
toddouska	0:5045d2638c29	44	return res;
toddouska	0:5045d2638c29	45	}
toddouska	0:5045d2638c29	46
toddouska	0:5045d2638c29	47	if (c && ((res = mp_init(c)) != MP_OKAY)) {
toddouska	0:5045d2638c29	48	mp_clear(a); mp_clear(b);
toddouska	0:5045d2638c29	49	return res;
toddouska	0:5045d2638c29	50	}
toddouska	0:5045d2638c29	51
toddouska	0:5045d2638c29	52	if (d && ((res = mp_init(d)) != MP_OKAY)) {
toddouska	0:5045d2638c29	53	mp_clear(a); mp_clear(b); mp_clear(c);
toddouska	0:5045d2638c29	54	return res;
toddouska	0:5045d2638c29	55	}
toddouska	0:5045d2638c29	56
toddouska	0:5045d2638c29	57	if (e && ((res = mp_init(e)) != MP_OKAY)) {
toddouska	0:5045d2638c29	58	mp_clear(a); mp_clear(b); mp_clear(c); mp_clear(d);
toddouska	0:5045d2638c29	59	return res;
toddouska	0:5045d2638c29	60	}
toddouska	0:5045d2638c29	61
toddouska	0:5045d2638c29	62	if (f && ((res = mp_init(f)) != MP_OKAY)) {
toddouska	0:5045d2638c29	63	mp_clear(a); mp_clear(b); mp_clear(c); mp_clear(d); mp_clear(e);
toddouska	0:5045d2638c29	64	return res;
toddouska	0:5045d2638c29	65	}
toddouska	0:5045d2638c29	66
toddouska	0:5045d2638c29	67	return res;
toddouska	0:5045d2638c29	68	}
toddouska	0:5045d2638c29	69
toddouska	0:5045d2638c29	70
toddouska	0:5045d2638c29	71	/* init a new mp_int */
toddouska	0:5045d2638c29	72	int mp_init (mp_int * a)
toddouska	0:5045d2638c29	73	{
toddouska	0:5045d2638c29	74	int i;
toddouska	0:5045d2638c29	75
toddouska	0:5045d2638c29	76	/* allocate memory required and clear it */
toddouska	0:5045d2638c29	77	a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * MP_PREC, 0,
toddouska	0:5045d2638c29	78	DYNAMIC_TYPE_BIGINT);
toddouska	0:5045d2638c29	79	if (a->dp == NULL) {
toddouska	0:5045d2638c29	80	return MP_MEM;
toddouska	0:5045d2638c29	81	}
toddouska	0:5045d2638c29	82
toddouska	0:5045d2638c29	83	/* set the digits to zero */
toddouska	0:5045d2638c29	84	for (i = 0; i < MP_PREC; i++) {
toddouska	0:5045d2638c29	85	a->dp[i] = 0;
toddouska	0:5045d2638c29	86	}
toddouska	0:5045d2638c29	87
toddouska	0:5045d2638c29	88	/* set the used to zero, allocated digits to the default precision
toddouska	0:5045d2638c29	89	* and sign to positive */
toddouska	0:5045d2638c29	90	a->used = 0;
toddouska	0:5045d2638c29	91	a->alloc = MP_PREC;
toddouska	0:5045d2638c29	92	a->sign = MP_ZPOS;
toddouska	0:5045d2638c29	93
toddouska	0:5045d2638c29	94	return MP_OKAY;
toddouska	0:5045d2638c29	95	}
toddouska	0:5045d2638c29	96
toddouska	0:5045d2638c29	97
toddouska	0:5045d2638c29	98	/* clear one (frees) */
toddouska	0:5045d2638c29	99	void
toddouska	0:5045d2638c29	100	mp_clear (mp_int * a)
toddouska	0:5045d2638c29	101	{
toddouska	0:5045d2638c29	102	int i;
toddouska	0:5045d2638c29	103
toddouska	0:5045d2638c29	104	/* only do anything if a hasn't been freed previously */
toddouska	0:5045d2638c29	105	if (a->dp != NULL) {
toddouska	0:5045d2638c29	106	/* first zero the digits */
toddouska	0:5045d2638c29	107	for (i = 0; i < a->used; i++) {
toddouska	0:5045d2638c29	108	a->dp[i] = 0;
toddouska	0:5045d2638c29	109	}
toddouska	0:5045d2638c29	110
toddouska	0:5045d2638c29	111	/* free ram */
toddouska	0:5045d2638c29	112	XFREE(a->dp, 0, DYNAMIC_TYPE_BIGINT);
toddouska	0:5045d2638c29	113
toddouska	0:5045d2638c29	114	/* reset members to make debugging easier */
toddouska	0:5045d2638c29	115	a->dp = NULL;
toddouska	0:5045d2638c29	116	a->alloc = a->used = 0;
toddouska	0:5045d2638c29	117	a->sign = MP_ZPOS;
toddouska	0:5045d2638c29	118	}
toddouska	0:5045d2638c29	119	}
toddouska	0:5045d2638c29	120
toddouska	0:5045d2638c29	121
toddouska	0:5045d2638c29	122	/* get the size for an unsigned equivalent */
toddouska	0:5045d2638c29	123	int mp_unsigned_bin_size (mp_int * a)
toddouska	0:5045d2638c29	124	{
toddouska	0:5045d2638c29	125	int size = mp_count_bits (a);
toddouska	0:5045d2638c29	126	return (size / 8 + ((size & 7) != 0 ? 1 : 0));
toddouska	0:5045d2638c29	127	}
toddouska	0:5045d2638c29	128
toddouska	0:5045d2638c29	129
toddouska	0:5045d2638c29	130	/* returns the number of bits in an int */
toddouska	0:5045d2638c29	131	int
toddouska	0:5045d2638c29	132	mp_count_bits (mp_int * a)
toddouska	0:5045d2638c29	133	{
toddouska	0:5045d2638c29	134	int r;
toddouska	0:5045d2638c29	135	mp_digit q;
toddouska	0:5045d2638c29	136
toddouska	0:5045d2638c29	137	/* shortcut */
toddouska	0:5045d2638c29	138	if (a->used == 0) {
toddouska	0:5045d2638c29	139	return 0;
toddouska	0:5045d2638c29	140	}
toddouska	0:5045d2638c29	141
toddouska	0:5045d2638c29	142	/* get number of digits and add that */
toddouska	0:5045d2638c29	143	r = (a->used - 1) * DIGIT_BIT;
toddouska	0:5045d2638c29	144
toddouska	0:5045d2638c29	145	/* take the last digit and count the bits in it */
toddouska	0:5045d2638c29	146	q = a->dp[a->used - 1];
toddouska	0:5045d2638c29	147	while (q > ((mp_digit) 0)) {
toddouska	0:5045d2638c29	148	++r;
toddouska	0:5045d2638c29	149	q >>= ((mp_digit) 1);
toddouska	0:5045d2638c29	150	}
toddouska	0:5045d2638c29	151	return r;
toddouska	0:5045d2638c29	152	}
toddouska	0:5045d2638c29	153
toddouska	0:5045d2638c29	154
toddouska	0:5045d2638c29	155	/* store in unsigned [big endian] format */
toddouska	0:5045d2638c29	156	int mp_to_unsigned_bin (mp_int * a, unsigned char *b)
toddouska	0:5045d2638c29	157	{
toddouska	0:5045d2638c29	158	int x, res;
toddouska	0:5045d2638c29	159	mp_int t;
toddouska	0:5045d2638c29	160
toddouska	0:5045d2638c29	161	if ((res = mp_init_copy (&t, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	162	return res;
toddouska	0:5045d2638c29	163	}
toddouska	0:5045d2638c29	164
toddouska	0:5045d2638c29	165	x = 0;
toddouska	0:5045d2638c29	166	while (mp_iszero (&t) == 0) {
toddouska	0:5045d2638c29	167	#ifndef MP_8BIT
toddouska	0:5045d2638c29	168	b[x++] = (unsigned char) (t.dp[0] & 255);
toddouska	0:5045d2638c29	169	#else
toddouska	0:5045d2638c29	170	b[x++] = (unsigned char) (t.dp[0] \| ((t.dp[1] & 0x01) << 7));
toddouska	0:5045d2638c29	171	#endif
toddouska	0:5045d2638c29	172	if ((res = mp_div_2d (&t, 8, &t, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	173	mp_clear (&t);
toddouska	0:5045d2638c29	174	return res;
toddouska	0:5045d2638c29	175	}
toddouska	0:5045d2638c29	176	}
toddouska	0:5045d2638c29	177	bn_reverse (b, x);
toddouska	0:5045d2638c29	178	mp_clear (&t);
toddouska	0:5045d2638c29	179	return MP_OKAY;
toddouska	0:5045d2638c29	180	}
toddouska	0:5045d2638c29	181
toddouska	0:5045d2638c29	182
toddouska	0:5045d2638c29	183	/* creates "a" then copies b into it */
toddouska	0:5045d2638c29	184	int mp_init_copy (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	185	{
toddouska	0:5045d2638c29	186	int res;
toddouska	0:5045d2638c29	187
toddouska	0:5045d2638c29	188	if ((res = mp_init (a)) != MP_OKAY) {
toddouska	0:5045d2638c29	189	return res;
toddouska	0:5045d2638c29	190	}
toddouska	0:5045d2638c29	191	return mp_copy (b, a);
toddouska	0:5045d2638c29	192	}
toddouska	0:5045d2638c29	193
toddouska	0:5045d2638c29	194
toddouska	0:5045d2638c29	195	/* copy, b = a */
toddouska	0:5045d2638c29	196	int
toddouska	0:5045d2638c29	197	mp_copy (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	198	{
toddouska	0:5045d2638c29	199	int res, n;
toddouska	0:5045d2638c29	200
toddouska	0:5045d2638c29	201	/* if dst == src do nothing */
toddouska	0:5045d2638c29	202	if (a == b) {
toddouska	0:5045d2638c29	203	return MP_OKAY;
toddouska	0:5045d2638c29	204	}
toddouska	0:5045d2638c29	205
toddouska	0:5045d2638c29	206	/* grow dest */
toddouska	0:5045d2638c29	207	if (b->alloc < a->used) {
toddouska	0:5045d2638c29	208	if ((res = mp_grow (b, a->used)) != MP_OKAY) {
toddouska	0:5045d2638c29	209	return res;
toddouska	0:5045d2638c29	210	}
toddouska	0:5045d2638c29	211	}
toddouska	0:5045d2638c29	212
toddouska	0:5045d2638c29	213	/* zero b and copy the parameters over */
toddouska	0:5045d2638c29	214	{
toddouska	0:5045d2638c29	215	register mp_digit tmpa, tmpb;
toddouska	0:5045d2638c29	216
toddouska	0:5045d2638c29	217	/* pointer aliases */
toddouska	0:5045d2638c29	218
toddouska	0:5045d2638c29	219	/* source */
toddouska	0:5045d2638c29	220	tmpa = a->dp;
toddouska	0:5045d2638c29	221
toddouska	0:5045d2638c29	222	/* destination */
toddouska	0:5045d2638c29	223	tmpb = b->dp;
toddouska	0:5045d2638c29	224
toddouska	0:5045d2638c29	225	/* copy all the digits */
toddouska	0:5045d2638c29	226	for (n = 0; n < a->used; n++) {
toddouska	0:5045d2638c29	227	tmpb++ = tmpa++;
toddouska	0:5045d2638c29	228	}
toddouska	0:5045d2638c29	229
toddouska	0:5045d2638c29	230	/* clear high digits */
toddouska	0:5045d2638c29	231	for (; n < b->used; n++) {
toddouska	0:5045d2638c29	232	*tmpb++ = 0;
toddouska	0:5045d2638c29	233	}
toddouska	0:5045d2638c29	234	}
toddouska	0:5045d2638c29	235
toddouska	0:5045d2638c29	236	/* copy used count and sign */
toddouska	0:5045d2638c29	237	b->used = a->used;
toddouska	0:5045d2638c29	238	b->sign = a->sign;
toddouska	0:5045d2638c29	239	return MP_OKAY;
toddouska	0:5045d2638c29	240	}
toddouska	0:5045d2638c29	241
toddouska	0:5045d2638c29	242
toddouska	0:5045d2638c29	243	/* grow as required */
toddouska	0:5045d2638c29	244	int mp_grow (mp_int * a, int size)
toddouska	0:5045d2638c29	245	{
toddouska	0:5045d2638c29	246	int i;
toddouska	0:5045d2638c29	247	mp_digit *tmp;
toddouska	0:5045d2638c29	248
toddouska	0:5045d2638c29	249	/* if the alloc size is smaller alloc more ram */
toddouska	0:5045d2638c29	250	if (a->alloc < size) {
toddouska	0:5045d2638c29	251	/* ensure there are always at least MP_PREC digits extra on top */
toddouska	0:5045d2638c29	252	size += (MP_PREC * 2) - (size % MP_PREC);
toddouska	0:5045d2638c29	253
toddouska	0:5045d2638c29	254	/* reallocate the array a->dp
toddouska	0:5045d2638c29	255	*
toddouska	0:5045d2638c29	256	* We store the return in a temporary variable
toddouska	0:5045d2638c29	257	* in case the operation failed we don't want
toddouska	0:5045d2638c29	258	* to overwrite the dp member of a.
toddouska	0:5045d2638c29	259	*/
toddouska	0:5045d2638c29	260	tmp = OPT_CAST(mp_digit) XREALLOC (a->dp, sizeof (mp_digit) * size, 0,
toddouska	0:5045d2638c29	261	DYNAMIC_TYPE_BIGINT);
toddouska	0:5045d2638c29	262	if (tmp == NULL) {
toddouska	0:5045d2638c29	263	/* reallocation failed but "a" is still valid [can be freed] */
toddouska	0:5045d2638c29	264	return MP_MEM;
toddouska	0:5045d2638c29	265	}
toddouska	0:5045d2638c29	266
toddouska	0:5045d2638c29	267	/* reallocation succeeded so set a->dp */
toddouska	0:5045d2638c29	268	a->dp = tmp;
toddouska	0:5045d2638c29	269
toddouska	0:5045d2638c29	270	/* zero excess digits */
toddouska	0:5045d2638c29	271	i = a->alloc;
toddouska	0:5045d2638c29	272	a->alloc = size;
toddouska	0:5045d2638c29	273	for (; i < a->alloc; i++) {
toddouska	0:5045d2638c29	274	a->dp[i] = 0;
toddouska	0:5045d2638c29	275	}
toddouska	0:5045d2638c29	276	}
toddouska	0:5045d2638c29	277	return MP_OKAY;
toddouska	0:5045d2638c29	278	}
toddouska	0:5045d2638c29	279
toddouska	0:5045d2638c29	280
toddouska	0:5045d2638c29	281	/* reverse an array, used for radix code */
toddouska	0:5045d2638c29	282	void
toddouska	0:5045d2638c29	283	bn_reverse (unsigned char *s, int len)
toddouska	0:5045d2638c29	284	{
toddouska	0:5045d2638c29	285	int ix, iy;
toddouska	0:5045d2638c29	286	unsigned char t;
toddouska	0:5045d2638c29	287
toddouska	0:5045d2638c29	288	ix = 0;
toddouska	0:5045d2638c29	289	iy = len - 1;
toddouska	0:5045d2638c29	290	while (ix < iy) {
toddouska	0:5045d2638c29	291	t = s[ix];
toddouska	0:5045d2638c29	292	s[ix] = s[iy];
toddouska	0:5045d2638c29	293	s[iy] = t;
toddouska	0:5045d2638c29	294	++ix;
toddouska	0:5045d2638c29	295	--iy;
toddouska	0:5045d2638c29	296	}
toddouska	0:5045d2638c29	297	}
toddouska	0:5045d2638c29	298
toddouska	0:5045d2638c29	299
toddouska	0:5045d2638c29	300	/* shift right by a certain bit count (store quotient in c, optional
toddouska	0:5045d2638c29	301	remainder in d) */
toddouska	0:5045d2638c29	302	int mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
toddouska	0:5045d2638c29	303	{
toddouska	0:5045d2638c29	304	mp_digit D, r, rr;
toddouska	0:5045d2638c29	305	int x, res;
toddouska	0:5045d2638c29	306	mp_int t;
toddouska	0:5045d2638c29	307
toddouska	0:5045d2638c29	308
toddouska	0:5045d2638c29	309	/* if the shift count is <= 0 then we do no work */
toddouska	0:5045d2638c29	310	if (b <= 0) {
toddouska	0:5045d2638c29	311	res = mp_copy (a, c);
toddouska	0:5045d2638c29	312	if (d != NULL) {
toddouska	0:5045d2638c29	313	mp_zero (d);
toddouska	0:5045d2638c29	314	}
toddouska	0:5045d2638c29	315	return res;
toddouska	0:5045d2638c29	316	}
toddouska	0:5045d2638c29	317
toddouska	0:5045d2638c29	318	if ((res = mp_init (&t)) != MP_OKAY) {
toddouska	0:5045d2638c29	319	return res;
toddouska	0:5045d2638c29	320	}
toddouska	0:5045d2638c29	321
toddouska	0:5045d2638c29	322	/* get the remainder */
toddouska	0:5045d2638c29	323	if (d != NULL) {
toddouska	0:5045d2638c29	324	if ((res = mp_mod_2d (a, b, &t)) != MP_OKAY) {
toddouska	0:5045d2638c29	325	mp_clear (&t);
toddouska	0:5045d2638c29	326	return res;
toddouska	0:5045d2638c29	327	}
toddouska	0:5045d2638c29	328	}
toddouska	0:5045d2638c29	329
toddouska	0:5045d2638c29	330	/* copy */
toddouska	0:5045d2638c29	331	if ((res = mp_copy (a, c)) != MP_OKAY) {
toddouska	0:5045d2638c29	332	mp_clear (&t);
toddouska	0:5045d2638c29	333	return res;
toddouska	0:5045d2638c29	334	}
toddouska	0:5045d2638c29	335
toddouska	0:5045d2638c29	336	/* shift by as many digits in the bit count */
toddouska	0:5045d2638c29	337	if (b >= (int)DIGIT_BIT) {
toddouska	0:5045d2638c29	338	mp_rshd (c, b / DIGIT_BIT);
toddouska	0:5045d2638c29	339	}
toddouska	0:5045d2638c29	340
toddouska	0:5045d2638c29	341	/* shift any bit count < DIGIT_BIT */
toddouska	0:5045d2638c29	342	D = (mp_digit) (b % DIGIT_BIT);
toddouska	0:5045d2638c29	343	if (D != 0) {
toddouska	0:5045d2638c29	344	register mp_digit *tmpc, mask, shift;
toddouska	0:5045d2638c29	345
toddouska	0:5045d2638c29	346	/* mask */
toddouska	0:5045d2638c29	347	mask = (((mp_digit)1) << D) - 1;
toddouska	0:5045d2638c29	348
toddouska	0:5045d2638c29	349	/* shift for lsb */
toddouska	0:5045d2638c29	350	shift = DIGIT_BIT - D;
toddouska	0:5045d2638c29	351
toddouska	0:5045d2638c29	352	/* alias */
toddouska	0:5045d2638c29	353	tmpc = c->dp + (c->used - 1);
toddouska	0:5045d2638c29	354
toddouska	0:5045d2638c29	355	/* carry */
toddouska	0:5045d2638c29	356	r = 0;
toddouska	0:5045d2638c29	357	for (x = c->used - 1; x >= 0; x--) {
toddouska	0:5045d2638c29	358	/* get the lower bits of this word in a temp */
toddouska	0:5045d2638c29	359	rr = *tmpc & mask;
toddouska	0:5045d2638c29	360
toddouska	0:5045d2638c29	361	/* shift the current word and mix in the carry bits from the previous
toddouska	0:5045d2638c29	362	word */
toddouska	0:5045d2638c29	363	tmpc = (tmpc >> D) \| (r << shift);
toddouska	0:5045d2638c29	364	--tmpc;
toddouska	0:5045d2638c29	365
toddouska	0:5045d2638c29	366	/* set the carry to the carry bits of the current word found above */
toddouska	0:5045d2638c29	367	r = rr;
toddouska	0:5045d2638c29	368	}
toddouska	0:5045d2638c29	369	}
toddouska	0:5045d2638c29	370	mp_clamp (c);
toddouska	0:5045d2638c29	371	if (d != NULL) {
toddouska	0:5045d2638c29	372	mp_exch (&t, d);
toddouska	0:5045d2638c29	373	}
toddouska	0:5045d2638c29	374	mp_clear (&t);
toddouska	0:5045d2638c29	375	return MP_OKAY;
toddouska	0:5045d2638c29	376	}
toddouska	0:5045d2638c29	377
toddouska	0:5045d2638c29	378
toddouska	0:5045d2638c29	379	/* set to zero */
toddouska	0:5045d2638c29	380	void mp_zero (mp_int * a)
toddouska	0:5045d2638c29	381	{
toddouska	0:5045d2638c29	382	int n;
toddouska	0:5045d2638c29	383	mp_digit *tmp;
toddouska	0:5045d2638c29	384
toddouska	0:5045d2638c29	385	a->sign = MP_ZPOS;
toddouska	0:5045d2638c29	386	a->used = 0;
toddouska	0:5045d2638c29	387
toddouska	0:5045d2638c29	388	tmp = a->dp;
toddouska	0:5045d2638c29	389	for (n = 0; n < a->alloc; n++) {
toddouska	0:5045d2638c29	390	*tmp++ = 0;
toddouska	0:5045d2638c29	391	}
toddouska	0:5045d2638c29	392	}
toddouska	0:5045d2638c29	393
toddouska	0:5045d2638c29	394
toddouska	0:5045d2638c29	395	/* trim unused digits
toddouska	0:5045d2638c29	396	*
toddouska	0:5045d2638c29	397	* This is used to ensure that leading zero digits are
toddouska	0:5045d2638c29	398	* trimed and the leading "used" digit will be non-zero
toddouska	0:5045d2638c29	399	* Typically very fast. Also fixes the sign if there
toddouska	0:5045d2638c29	400	* are no more leading digits
toddouska	0:5045d2638c29	401	*/
toddouska	0:5045d2638c29	402	void
toddouska	0:5045d2638c29	403	mp_clamp (mp_int * a)
toddouska	0:5045d2638c29	404	{
toddouska	0:5045d2638c29	405	/* decrease used while the most significant digit is
toddouska	0:5045d2638c29	406	* zero.
toddouska	0:5045d2638c29	407	*/
toddouska	0:5045d2638c29	408	while (a->used > 0 && a->dp[a->used - 1] == 0) {
toddouska	0:5045d2638c29	409	--(a->used);
toddouska	0:5045d2638c29	410	}
toddouska	0:5045d2638c29	411
toddouska	0:5045d2638c29	412	/* reset the sign flag if used == 0 */
toddouska	0:5045d2638c29	413	if (a->used == 0) {
toddouska	0:5045d2638c29	414	a->sign = MP_ZPOS;
toddouska	0:5045d2638c29	415	}
toddouska	0:5045d2638c29	416	}
toddouska	0:5045d2638c29	417
toddouska	0:5045d2638c29	418
toddouska	0:5045d2638c29	419	/* swap the elements of two integers, for cases where you can't simply swap the
toddouska	0:5045d2638c29	420	* mp_int pointers around
toddouska	0:5045d2638c29	421	*/
toddouska	0:5045d2638c29	422	void
toddouska	0:5045d2638c29	423	mp_exch (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	424	{
toddouska	0:5045d2638c29	425	mp_int t;
toddouska	0:5045d2638c29	426
toddouska	0:5045d2638c29	427	t = *a;
toddouska	0:5045d2638c29	428	a = b;
toddouska	0:5045d2638c29	429	*b = t;
toddouska	0:5045d2638c29	430	}
toddouska	0:5045d2638c29	431
toddouska	0:5045d2638c29	432
toddouska	0:5045d2638c29	433	/* shift right a certain amount of digits */
toddouska	0:5045d2638c29	434	void mp_rshd (mp_int * a, int b)
toddouska	0:5045d2638c29	435	{
toddouska	0:5045d2638c29	436	int x;
toddouska	0:5045d2638c29	437
toddouska	0:5045d2638c29	438	/* if b <= 0 then ignore it */
toddouska	0:5045d2638c29	439	if (b <= 0) {
toddouska	0:5045d2638c29	440	return;
toddouska	0:5045d2638c29	441	}
toddouska	0:5045d2638c29	442
toddouska	0:5045d2638c29	443	/* if b > used then simply zero it and return */
toddouska	0:5045d2638c29	444	if (a->used <= b) {
toddouska	0:5045d2638c29	445	mp_zero (a);
toddouska	0:5045d2638c29	446	return;
toddouska	0:5045d2638c29	447	}
toddouska	0:5045d2638c29	448
toddouska	0:5045d2638c29	449	{
toddouska	0:5045d2638c29	450	register mp_digit bottom, top;
toddouska	0:5045d2638c29	451
toddouska	0:5045d2638c29	452	/* shift the digits down */
toddouska	0:5045d2638c29	453
toddouska	0:5045d2638c29	454	/* bottom */
toddouska	0:5045d2638c29	455	bottom = a->dp;
toddouska	0:5045d2638c29	456
toddouska	0:5045d2638c29	457	/* top [offset into digits] */
toddouska	0:5045d2638c29	458	top = a->dp + b;
toddouska	0:5045d2638c29	459
toddouska	0:5045d2638c29	460	/* this is implemented as a sliding window where
toddouska	0:5045d2638c29	461	* the window is b-digits long and digits from
toddouska	0:5045d2638c29	462	* the top of the window are copied to the bottom
toddouska	0:5045d2638c29	463	*
toddouska	0:5045d2638c29	464	* e.g.
toddouska	0:5045d2638c29	465
toddouska	0:5045d2638c29	466	b-2 \| b-1 \| b0 \| b1 \| b2 \| ... \| bb \| ---->
toddouska	0:5045d2638c29	467	/\ \| ---->
toddouska	0:5045d2638c29	468	\-------------------/ ---->
toddouska	0:5045d2638c29	469	*/
toddouska	0:5045d2638c29	470	for (x = 0; x < (a->used - b); x++) {
toddouska	0:5045d2638c29	471	bottom++ = top++;
toddouska	0:5045d2638c29	472	}
toddouska	0:5045d2638c29	473
toddouska	0:5045d2638c29	474	/* zero the top digits */
toddouska	0:5045d2638c29	475	for (; x < a->used; x++) {
toddouska	0:5045d2638c29	476	*bottom++ = 0;
toddouska	0:5045d2638c29	477	}
toddouska	0:5045d2638c29	478	}
toddouska	0:5045d2638c29	479
toddouska	0:5045d2638c29	480	/* remove excess digits */
toddouska	0:5045d2638c29	481	a->used -= b;
toddouska	0:5045d2638c29	482	}
toddouska	0:5045d2638c29	483
toddouska	0:5045d2638c29	484
toddouska	0:5045d2638c29	485	/* calc a value mod 2*b /
toddouska	0:5045d2638c29	486	int
toddouska	0:5045d2638c29	487	mp_mod_2d (mp_int * a, int b, mp_int * c)
toddouska	0:5045d2638c29	488	{
toddouska	0:5045d2638c29	489	int x, res;
toddouska	0:5045d2638c29	490
toddouska	0:5045d2638c29	491	/* if b is <= 0 then zero the int */
toddouska	0:5045d2638c29	492	if (b <= 0) {
toddouska	0:5045d2638c29	493	mp_zero (c);
toddouska	0:5045d2638c29	494	return MP_OKAY;
toddouska	0:5045d2638c29	495	}
toddouska	0:5045d2638c29	496
toddouska	0:5045d2638c29	497	/* if the modulus is larger than the value than return */
toddouska	0:5045d2638c29	498	if (b >= (int) (a->used * DIGIT_BIT)) {
toddouska	0:5045d2638c29	499	res = mp_copy (a, c);
toddouska	0:5045d2638c29	500	return res;
toddouska	0:5045d2638c29	501	}
toddouska	0:5045d2638c29	502
toddouska	0:5045d2638c29	503	/* copy */
toddouska	0:5045d2638c29	504	if ((res = mp_copy (a, c)) != MP_OKAY) {
toddouska	0:5045d2638c29	505	return res;
toddouska	0:5045d2638c29	506	}
toddouska	0:5045d2638c29	507
toddouska	0:5045d2638c29	508	/* zero digits above the last digit of the modulus */
toddouska	0:5045d2638c29	509	for (x = (b / DIGIT_BIT) + ((b % DIGIT_BIT) == 0 ? 0 : 1); x < c->used; x++) {
toddouska	0:5045d2638c29	510	c->dp[x] = 0;
toddouska	0:5045d2638c29	511	}
toddouska	0:5045d2638c29	512	/* clear the digit that is not completely outside/inside the modulus */
toddouska	0:5045d2638c29	513	c->dp[b / DIGIT_BIT] &= (mp_digit) ((((mp_digit) 1) <<
toddouska	0:5045d2638c29	514	(((mp_digit) b) % DIGIT_BIT)) - ((mp_digit) 1));
toddouska	0:5045d2638c29	515	mp_clamp (c);
toddouska	0:5045d2638c29	516	return MP_OKAY;
toddouska	0:5045d2638c29	517	}
toddouska	0:5045d2638c29	518
toddouska	0:5045d2638c29	519
toddouska	0:5045d2638c29	520	/* reads a unsigned char array, assumes the msb is stored first [big endian] */
toddouska	0:5045d2638c29	521	int mp_read_unsigned_bin (mp_int * a, const unsigned char *b, int c)
toddouska	0:5045d2638c29	522	{
toddouska	0:5045d2638c29	523	int res;
toddouska	0:5045d2638c29	524
toddouska	0:5045d2638c29	525	/* make sure there are at least two digits */
toddouska	0:5045d2638c29	526	if (a->alloc < 2) {
toddouska	0:5045d2638c29	527	if ((res = mp_grow(a, 2)) != MP_OKAY) {
toddouska	0:5045d2638c29	528	return res;
toddouska	0:5045d2638c29	529	}
toddouska	0:5045d2638c29	530	}
toddouska	0:5045d2638c29	531
toddouska	0:5045d2638c29	532	/* zero the int */
toddouska	0:5045d2638c29	533	mp_zero (a);
toddouska	0:5045d2638c29	534
toddouska	0:5045d2638c29	535	/* read the bytes in */
toddouska	0:5045d2638c29	536	while (c-- > 0) {
toddouska	0:5045d2638c29	537	if ((res = mp_mul_2d (a, 8, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	538	return res;
toddouska	0:5045d2638c29	539	}
toddouska	0:5045d2638c29	540
toddouska	0:5045d2638c29	541	#ifndef MP_8BIT
toddouska	0:5045d2638c29	542	a->dp[0] \|= *b++;
toddouska	0:5045d2638c29	543	a->used += 1;
toddouska	0:5045d2638c29	544	#else
toddouska	0:5045d2638c29	545	a->dp[0] = (*b & MP_MASK);
toddouska	0:5045d2638c29	546	a->dp[1] \|= ((*b++ >> 7U) & 1);
toddouska	0:5045d2638c29	547	a->used += 2;
toddouska	0:5045d2638c29	548	#endif
toddouska	0:5045d2638c29	549	}
toddouska	0:5045d2638c29	550	mp_clamp (a);
toddouska	0:5045d2638c29	551	return MP_OKAY;
toddouska	0:5045d2638c29	552	}
toddouska	0:5045d2638c29	553
toddouska	0:5045d2638c29	554
toddouska	0:5045d2638c29	555	/* shift left by a certain bit count */
toddouska	0:5045d2638c29	556	int mp_mul_2d (mp_int * a, int b, mp_int * c)
toddouska	0:5045d2638c29	557	{
toddouska	0:5045d2638c29	558	mp_digit d;
toddouska	0:5045d2638c29	559	int res;
toddouska	0:5045d2638c29	560
toddouska	0:5045d2638c29	561	/* copy */
toddouska	0:5045d2638c29	562	if (a != c) {
toddouska	0:5045d2638c29	563	if ((res = mp_copy (a, c)) != MP_OKAY) {
toddouska	0:5045d2638c29	564	return res;
toddouska	0:5045d2638c29	565	}
toddouska	0:5045d2638c29	566	}
toddouska	0:5045d2638c29	567
toddouska	0:5045d2638c29	568	if (c->alloc < (int)(c->used + b/DIGIT_BIT + 1)) {
toddouska	0:5045d2638c29	569	if ((res = mp_grow (c, c->used + b / DIGIT_BIT + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	570	return res;
toddouska	0:5045d2638c29	571	}
toddouska	0:5045d2638c29	572	}
toddouska	0:5045d2638c29	573
toddouska	0:5045d2638c29	574	/* shift by as many digits in the bit count */
toddouska	0:5045d2638c29	575	if (b >= (int)DIGIT_BIT) {
toddouska	0:5045d2638c29	576	if ((res = mp_lshd (c, b / DIGIT_BIT)) != MP_OKAY) {
toddouska	0:5045d2638c29	577	return res;
toddouska	0:5045d2638c29	578	}
toddouska	0:5045d2638c29	579	}
toddouska	0:5045d2638c29	580
toddouska	0:5045d2638c29	581	/* shift any bit count < DIGIT_BIT */
toddouska	0:5045d2638c29	582	d = (mp_digit) (b % DIGIT_BIT);
toddouska	0:5045d2638c29	583	if (d != 0) {
toddouska	0:5045d2638c29	584	register mp_digit *tmpc, shift, mask, r, rr;
toddouska	0:5045d2638c29	585	register int x;
toddouska	0:5045d2638c29	586
toddouska	0:5045d2638c29	587	/* bitmask for carries */
toddouska	0:5045d2638c29	588	mask = (((mp_digit)1) << d) - 1;
toddouska	0:5045d2638c29	589
toddouska	0:5045d2638c29	590	/* shift for msbs */
toddouska	0:5045d2638c29	591	shift = DIGIT_BIT - d;
toddouska	0:5045d2638c29	592
toddouska	0:5045d2638c29	593	/* alias */
toddouska	0:5045d2638c29	594	tmpc = c->dp;
toddouska	0:5045d2638c29	595
toddouska	0:5045d2638c29	596	/* carry */
toddouska	0:5045d2638c29	597	r = 0;
toddouska	0:5045d2638c29	598	for (x = 0; x < c->used; x++) {
toddouska	0:5045d2638c29	599	/* get the higher bits of the current word */
toddouska	0:5045d2638c29	600	rr = (*tmpc >> shift) & mask;
toddouska	0:5045d2638c29	601
toddouska	0:5045d2638c29	602	/* shift the current word and OR in the carry */
toddouska	0:5045d2638c29	603	tmpc = ((tmpc << d) \| r) & MP_MASK;
toddouska	0:5045d2638c29	604	++tmpc;
toddouska	0:5045d2638c29	605
toddouska	0:5045d2638c29	606	/* set the carry to the carry bits of the current word */
toddouska	0:5045d2638c29	607	r = rr;
toddouska	0:5045d2638c29	608	}
toddouska	0:5045d2638c29	609
toddouska	0:5045d2638c29	610	/* set final carry */
toddouska	0:5045d2638c29	611	if (r != 0) {
toddouska	0:5045d2638c29	612	c->dp[(c->used)++] = r;
toddouska	0:5045d2638c29	613	}
toddouska	0:5045d2638c29	614	}
toddouska	0:5045d2638c29	615	mp_clamp (c);
toddouska	0:5045d2638c29	616	return MP_OKAY;
toddouska	0:5045d2638c29	617	}
toddouska	0:5045d2638c29	618
toddouska	0:5045d2638c29	619
toddouska	0:5045d2638c29	620	/* shift left a certain amount of digits */
toddouska	0:5045d2638c29	621	int mp_lshd (mp_int * a, int b)
toddouska	0:5045d2638c29	622	{
toddouska	0:5045d2638c29	623	int x, res;
toddouska	0:5045d2638c29	624
toddouska	0:5045d2638c29	625	/* if its less than zero return */
toddouska	0:5045d2638c29	626	if (b <= 0) {
toddouska	0:5045d2638c29	627	return MP_OKAY;
toddouska	0:5045d2638c29	628	}
toddouska	0:5045d2638c29	629
toddouska	0:5045d2638c29	630	/* grow to fit the new digits */
toddouska	0:5045d2638c29	631	if (a->alloc < a->used + b) {
toddouska	0:5045d2638c29	632	if ((res = mp_grow (a, a->used + b)) != MP_OKAY) {
toddouska	0:5045d2638c29	633	return res;
toddouska	0:5045d2638c29	634	}
toddouska	0:5045d2638c29	635	}
toddouska	0:5045d2638c29	636
toddouska	0:5045d2638c29	637	{
toddouska	0:5045d2638c29	638	register mp_digit top, bottom;
toddouska	0:5045d2638c29	639
toddouska	0:5045d2638c29	640	/* increment the used by the shift amount then copy upwards */
toddouska	0:5045d2638c29	641	a->used += b;
toddouska	0:5045d2638c29	642
toddouska	0:5045d2638c29	643	/* top */
toddouska	0:5045d2638c29	644	top = a->dp + a->used - 1;
toddouska	0:5045d2638c29	645
toddouska	0:5045d2638c29	646	/* base */
toddouska	0:5045d2638c29	647	bottom = a->dp + a->used - 1 - b;
toddouska	0:5045d2638c29	648
toddouska	0:5045d2638c29	649	/* much like mp_rshd this is implemented using a sliding window
toddouska	0:5045d2638c29	650	* except the window goes the otherway around. Copying from
toddouska	0:5045d2638c29	651	* the bottom to the top. see bn_mp_rshd.c for more info.
toddouska	0:5045d2638c29	652	*/
toddouska	0:5045d2638c29	653	for (x = a->used - 1; x >= b; x--) {
toddouska	0:5045d2638c29	654	top-- = bottom--;
toddouska	0:5045d2638c29	655	}
toddouska	0:5045d2638c29	656
toddouska	0:5045d2638c29	657	/* zero the lower digits */
toddouska	0:5045d2638c29	658	top = a->dp;
toddouska	0:5045d2638c29	659	for (x = 0; x < b; x++) {
toddouska	0:5045d2638c29	660	*top++ = 0;
toddouska	0:5045d2638c29	661	}
toddouska	0:5045d2638c29	662	}
toddouska	0:5045d2638c29	663	return MP_OKAY;
toddouska	0:5045d2638c29	664	}
toddouska	0:5045d2638c29	665
toddouska	0:5045d2638c29	666
toddouska	0:5045d2638c29	667	/* this is a shell function that calls either the normal or Montgomery
toddouska	0:5045d2638c29	668	* exptmod functions. Originally the call to the montgomery code was
toddouska	0:5045d2638c29	669	* embedded in the normal function but that wasted alot of stack space
toddouska	0:5045d2638c29	670	* for nothing (since 99% of the time the Montgomery code would be called)
toddouska	0:5045d2638c29	671	*/
toddouska	0:5045d2638c29	672	int mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
toddouska	0:5045d2638c29	673	{
toddouska	0:5045d2638c29	674	int dr;
toddouska	0:5045d2638c29	675
toddouska	0:5045d2638c29	676	/* modulus P must be positive */
toddouska	0:5045d2638c29	677	if (P->sign == MP_NEG) {
toddouska	0:5045d2638c29	678	return MP_VAL;
toddouska	0:5045d2638c29	679	}
toddouska	0:5045d2638c29	680
toddouska	0:5045d2638c29	681	/* if exponent X is negative we have to recurse */
toddouska	0:5045d2638c29	682	if (X->sign == MP_NEG) {
toddouska	0:5045d2638c29	683	#ifdef BN_MP_INVMOD_C
toddouska	0:5045d2638c29	684	mp_int tmpG, tmpX;
toddouska	0:5045d2638c29	685	int err;
toddouska	0:5045d2638c29	686
toddouska	0:5045d2638c29	687	/* first compute 1/G mod P */
toddouska	0:5045d2638c29	688	if ((err = mp_init(&tmpG)) != MP_OKAY) {
toddouska	0:5045d2638c29	689	return err;
toddouska	0:5045d2638c29	690	}
toddouska	0:5045d2638c29	691	if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) {
toddouska	0:5045d2638c29	692	mp_clear(&tmpG);
toddouska	0:5045d2638c29	693	return err;
toddouska	0:5045d2638c29	694	}
toddouska	0:5045d2638c29	695
toddouska	0:5045d2638c29	696	/* now get \|X\| */
toddouska	0:5045d2638c29	697	if ((err = mp_init(&tmpX)) != MP_OKAY) {
toddouska	0:5045d2638c29	698	mp_clear(&tmpG);
toddouska	0:5045d2638c29	699	return err;
toddouska	0:5045d2638c29	700	}
toddouska	0:5045d2638c29	701	if ((err = mp_abs(X, &tmpX)) != MP_OKAY) {
toddouska	0:5045d2638c29	702	mp_clear(&tmpG);
toddouska	0:5045d2638c29	703	mp_clear(&tmpX);
toddouska	0:5045d2638c29	704	return err;
toddouska	0:5045d2638c29	705	}
toddouska	0:5045d2638c29	706
toddouska	0:5045d2638c29	707	/* and now compute (1/G)\|X\| instead of GX [X < 0] */
toddouska	0:5045d2638c29	708	err = mp_exptmod(&tmpG, &tmpX, P, Y);
toddouska	0:5045d2638c29	709	mp_clear(&tmpG);
toddouska	0:5045d2638c29	710	mp_clear(&tmpX);
toddouska	0:5045d2638c29	711	return err;
toddouska	0:5045d2638c29	712	#else
toddouska	0:5045d2638c29	713	/* no invmod */
toddouska	0:5045d2638c29	714	return MP_VAL;
toddouska	0:5045d2638c29	715	#endif
toddouska	0:5045d2638c29	716	}
toddouska	0:5045d2638c29	717
toddouska	0:5045d2638c29	718	/* modified diminished radix reduction */
toddouska	0:5045d2638c29	719	#if defined(BN_MP_REDUCE_IS_2K_L_C) && defined(BN_MP_REDUCE_2K_L_C) && \
toddouska	0:5045d2638c29	720	defined(BN_S_MP_EXPTMOD_C)
toddouska	0:5045d2638c29	721	if (mp_reduce_is_2k_l(P) == MP_YES) {
toddouska	0:5045d2638c29	722	return s_mp_exptmod(G, X, P, Y, 1);
toddouska	0:5045d2638c29	723	}
toddouska	0:5045d2638c29	724	#endif
toddouska	0:5045d2638c29	725
toddouska	0:5045d2638c29	726	#ifdef BN_MP_DR_IS_MODULUS_C
toddouska	0:5045d2638c29	727	/* is it a DR modulus? */
toddouska	0:5045d2638c29	728	dr = mp_dr_is_modulus(P);
toddouska	0:5045d2638c29	729	#else
toddouska	0:5045d2638c29	730	/* default to no */
toddouska	0:5045d2638c29	731	dr = 0;
toddouska	0:5045d2638c29	732	#endif
toddouska	0:5045d2638c29	733
toddouska	0:5045d2638c29	734	#ifdef BN_MP_REDUCE_IS_2K_C
toddouska	0:5045d2638c29	735	/* if not, is it a unrestricted DR modulus? */
toddouska	0:5045d2638c29	736	if (dr == 0) {
toddouska	0:5045d2638c29	737	dr = mp_reduce_is_2k(P) << 1;
toddouska	0:5045d2638c29	738	}
toddouska	0:5045d2638c29	739	#endif
toddouska	0:5045d2638c29	740
toddouska	0:5045d2638c29	741	/* if the modulus is odd or dr != 0 use the montgomery method */
toddouska	0:5045d2638c29	742	#ifdef BN_MP_EXPTMOD_FAST_C
toddouska	0:5045d2638c29	743	if (mp_isodd (P) == 1 \|\| dr != 0) {
toddouska	0:5045d2638c29	744	return mp_exptmod_fast (G, X, P, Y, dr);
toddouska	0:5045d2638c29	745	} else {
toddouska	0:5045d2638c29	746	#endif
toddouska	0:5045d2638c29	747	#ifdef BN_S_MP_EXPTMOD_C
toddouska	0:5045d2638c29	748	/* otherwise use the generic Barrett reduction technique */
toddouska	0:5045d2638c29	749	return s_mp_exptmod (G, X, P, Y, 0);
toddouska	0:5045d2638c29	750	#else
toddouska	0:5045d2638c29	751	/* no exptmod for evens */
toddouska	0:5045d2638c29	752	return MP_VAL;
toddouska	0:5045d2638c29	753	#endif
toddouska	0:5045d2638c29	754	#ifdef BN_MP_EXPTMOD_FAST_C
toddouska	0:5045d2638c29	755	}
toddouska	0:5045d2638c29	756	#endif
toddouska	0:5045d2638c29	757	}
toddouska	0:5045d2638c29	758
toddouska	0:5045d2638c29	759
toddouska	0:5045d2638c29	760	/* b = \|a\|
toddouska	0:5045d2638c29	761	*
toddouska	0:5045d2638c29	762	* Simple function copies the input and fixes the sign to positive
toddouska	0:5045d2638c29	763	*/
toddouska	0:5045d2638c29	764	int
toddouska	0:5045d2638c29	765	mp_abs (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	766	{
toddouska	0:5045d2638c29	767	int res;
toddouska	0:5045d2638c29	768
toddouska	0:5045d2638c29	769	/* copy a to b */
toddouska	0:5045d2638c29	770	if (a != b) {
toddouska	0:5045d2638c29	771	if ((res = mp_copy (a, b)) != MP_OKAY) {
toddouska	0:5045d2638c29	772	return res;
toddouska	0:5045d2638c29	773	}
toddouska	0:5045d2638c29	774	}
toddouska	0:5045d2638c29	775
toddouska	0:5045d2638c29	776	/* force the sign of b to positive */
toddouska	0:5045d2638c29	777	b->sign = MP_ZPOS;
toddouska	0:5045d2638c29	778
toddouska	0:5045d2638c29	779	return MP_OKAY;
toddouska	0:5045d2638c29	780	}
toddouska	0:5045d2638c29	781
toddouska	0:5045d2638c29	782
toddouska	0:5045d2638c29	783	/* hac 14.61, pp608 */
toddouska	0:5045d2638c29	784	int mp_invmod (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	785	{
toddouska	0:5045d2638c29	786	/* b cannot be negative */
toddouska	0:5045d2638c29	787	if (b->sign == MP_NEG \|\| mp_iszero(b) == 1) {
toddouska	0:5045d2638c29	788	return MP_VAL;
toddouska	0:5045d2638c29	789	}
toddouska	0:5045d2638c29	790
toddouska	0:5045d2638c29	791	#ifdef BN_FAST_MP_INVMOD_C
toddouska	0:5045d2638c29	792	/* if the modulus is odd we can use a faster routine instead */
toddouska	0:5045d2638c29	793	if (mp_isodd (b) == 1) {
toddouska	0:5045d2638c29	794	return fast_mp_invmod (a, b, c);
toddouska	0:5045d2638c29	795	}
toddouska	0:5045d2638c29	796	#endif
toddouska	0:5045d2638c29	797
toddouska	0:5045d2638c29	798	#ifdef BN_MP_INVMOD_SLOW_C
toddouska	0:5045d2638c29	799	return mp_invmod_slow(a, b, c);
toddouska	0:5045d2638c29	800	#endif
toddouska	0:5045d2638c29	801	}
toddouska	0:5045d2638c29	802
toddouska	0:5045d2638c29	803
toddouska	0:5045d2638c29	804	/* computes the modular inverse via binary extended euclidean algorithm,
toddouska	0:5045d2638c29	805	* that is c = 1/a mod b
toddouska	0:5045d2638c29	806	*
toddouska	0:5045d2638c29	807	* Based on slow invmod except this is optimized for the case where b is
toddouska	0:5045d2638c29	808	* odd as per HAC Note 14.64 on pp. 610
toddouska	0:5045d2638c29	809	*/
toddouska	0:5045d2638c29	810	int fast_mp_invmod (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	811	{
toddouska	0:5045d2638c29	812	mp_int x, y, u, v, B, D;
toddouska	0:5045d2638c29	813	int res, neg;
toddouska	0:5045d2638c29	814
toddouska	0:5045d2638c29	815	/* 2. [modified] b must be odd */
toddouska	0:5045d2638c29	816	if (mp_iseven (b) == 1) {
toddouska	0:5045d2638c29	817	return MP_VAL;
toddouska	0:5045d2638c29	818	}
toddouska	0:5045d2638c29	819
toddouska	0:5045d2638c29	820	/* init all our temps */
toddouska	0:5045d2638c29	821	if ((res = mp_init_multi(&x, &y, &u, &v, &B, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	822	return res;
toddouska	0:5045d2638c29	823	}
toddouska	0:5045d2638c29	824
toddouska	0:5045d2638c29	825	/* x == modulus, y == value to invert */
toddouska	0:5045d2638c29	826	if ((res = mp_copy (b, &x)) != MP_OKAY) {
toddouska	0:5045d2638c29	827	goto LBL_ERR;
toddouska	0:5045d2638c29	828	}
toddouska	0:5045d2638c29	829
toddouska	0:5045d2638c29	830	/* we need y = \|a\| */
toddouska	0:5045d2638c29	831	if ((res = mp_mod (a, b, &y)) != MP_OKAY) {
toddouska	0:5045d2638c29	832	goto LBL_ERR;
toddouska	0:5045d2638c29	833	}
toddouska	0:5045d2638c29	834
toddouska	0:5045d2638c29	835	/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
toddouska	0:5045d2638c29	836	if ((res = mp_copy (&x, &u)) != MP_OKAY) {
toddouska	0:5045d2638c29	837	goto LBL_ERR;
toddouska	0:5045d2638c29	838	}
toddouska	0:5045d2638c29	839	if ((res = mp_copy (&y, &v)) != MP_OKAY) {
toddouska	0:5045d2638c29	840	goto LBL_ERR;
toddouska	0:5045d2638c29	841	}
toddouska	0:5045d2638c29	842	mp_set (&D, 1);
toddouska	0:5045d2638c29	843
toddouska	0:5045d2638c29	844	top:
toddouska	0:5045d2638c29	845	/* 4. while u is even do */
toddouska	0:5045d2638c29	846	while (mp_iseven (&u) == 1) {
toddouska	0:5045d2638c29	847	/* 4.1 u = u/2 */
toddouska	0:5045d2638c29	848	if ((res = mp_div_2 (&u, &u)) != MP_OKAY) {
toddouska	0:5045d2638c29	849	goto LBL_ERR;
toddouska	0:5045d2638c29	850	}
toddouska	0:5045d2638c29	851	/* 4.2 if B is odd then */
toddouska	0:5045d2638c29	852	if (mp_isodd (&B) == 1) {
toddouska	0:5045d2638c29	853	if ((res = mp_sub (&B, &x, &B)) != MP_OKAY) {
toddouska	0:5045d2638c29	854	goto LBL_ERR;
toddouska	0:5045d2638c29	855	}
toddouska	0:5045d2638c29	856	}
toddouska	0:5045d2638c29	857	/* B = B/2 */
toddouska	0:5045d2638c29	858	if ((res = mp_div_2 (&B, &B)) != MP_OKAY) {
toddouska	0:5045d2638c29	859	goto LBL_ERR;
toddouska	0:5045d2638c29	860	}
toddouska	0:5045d2638c29	861	}
toddouska	0:5045d2638c29	862
toddouska	0:5045d2638c29	863	/* 5. while v is even do */
toddouska	0:5045d2638c29	864	while (mp_iseven (&v) == 1) {
toddouska	0:5045d2638c29	865	/* 5.1 v = v/2 */
toddouska	0:5045d2638c29	866	if ((res = mp_div_2 (&v, &v)) != MP_OKAY) {
toddouska	0:5045d2638c29	867	goto LBL_ERR;
toddouska	0:5045d2638c29	868	}
toddouska	0:5045d2638c29	869	/* 5.2 if D is odd then */
toddouska	0:5045d2638c29	870	if (mp_isodd (&D) == 1) {
toddouska	0:5045d2638c29	871	/* D = (D-x)/2 */
toddouska	0:5045d2638c29	872	if ((res = mp_sub (&D, &x, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	873	goto LBL_ERR;
toddouska	0:5045d2638c29	874	}
toddouska	0:5045d2638c29	875	}
toddouska	0:5045d2638c29	876	/* D = D/2 */
toddouska	0:5045d2638c29	877	if ((res = mp_div_2 (&D, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	878	goto LBL_ERR;
toddouska	0:5045d2638c29	879	}
toddouska	0:5045d2638c29	880	}
toddouska	0:5045d2638c29	881
toddouska	0:5045d2638c29	882	/* 6. if u >= v then */
toddouska	0:5045d2638c29	883	if (mp_cmp (&u, &v) != MP_LT) {
toddouska	0:5045d2638c29	884	/* u = u - v, B = B - D */
toddouska	0:5045d2638c29	885	if ((res = mp_sub (&u, &v, &u)) != MP_OKAY) {
toddouska	0:5045d2638c29	886	goto LBL_ERR;
toddouska	0:5045d2638c29	887	}
toddouska	0:5045d2638c29	888
toddouska	0:5045d2638c29	889	if ((res = mp_sub (&B, &D, &B)) != MP_OKAY) {
toddouska	0:5045d2638c29	890	goto LBL_ERR;
toddouska	0:5045d2638c29	891	}
toddouska	0:5045d2638c29	892	} else {
toddouska	0:5045d2638c29	893	/* v - v - u, D = D - B */
toddouska	0:5045d2638c29	894	if ((res = mp_sub (&v, &u, &v)) != MP_OKAY) {
toddouska	0:5045d2638c29	895	goto LBL_ERR;
toddouska	0:5045d2638c29	896	}
toddouska	0:5045d2638c29	897
toddouska	0:5045d2638c29	898	if ((res = mp_sub (&D, &B, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	899	goto LBL_ERR;
toddouska	0:5045d2638c29	900	}
toddouska	0:5045d2638c29	901	}
toddouska	0:5045d2638c29	902
toddouska	0:5045d2638c29	903	/* if not zero goto step 4 */
toddouska	0:5045d2638c29	904	if (mp_iszero (&u) == 0) {
toddouska	0:5045d2638c29	905	goto top;
toddouska	0:5045d2638c29	906	}
toddouska	0:5045d2638c29	907
toddouska	0:5045d2638c29	908	/* now a = C, b = D, gcd == gv /
toddouska	0:5045d2638c29	909
toddouska	0:5045d2638c29	910	/* if v != 1 then there is no inverse */
toddouska	0:5045d2638c29	911	if (mp_cmp_d (&v, 1) != MP_EQ) {
toddouska	0:5045d2638c29	912	res = MP_VAL;
toddouska	0:5045d2638c29	913	goto LBL_ERR;
toddouska	0:5045d2638c29	914	}
toddouska	0:5045d2638c29	915
toddouska	0:5045d2638c29	916	/* b is now the inverse */
toddouska	0:5045d2638c29	917	neg = a->sign;
toddouska	0:5045d2638c29	918	while (D.sign == MP_NEG) {
toddouska	0:5045d2638c29	919	if ((res = mp_add (&D, b, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	920	goto LBL_ERR;
toddouska	0:5045d2638c29	921	}
toddouska	0:5045d2638c29	922	}
toddouska	0:5045d2638c29	923	mp_exch (&D, c);
toddouska	0:5045d2638c29	924	c->sign = neg;
toddouska	0:5045d2638c29	925	res = MP_OKAY;
toddouska	0:5045d2638c29	926
toddouska	0:5045d2638c29	927	LBL_ERR:mp_clear(&x);
toddouska	0:5045d2638c29	928	mp_clear(&y);
toddouska	0:5045d2638c29	929	mp_clear(&u);
toddouska	0:5045d2638c29	930	mp_clear(&v);
toddouska	0:5045d2638c29	931	mp_clear(&B);
toddouska	0:5045d2638c29	932	mp_clear(&D);
toddouska	0:5045d2638c29	933	return res;
toddouska	0:5045d2638c29	934	}
toddouska	0:5045d2638c29	935
toddouska	0:5045d2638c29	936
toddouska	0:5045d2638c29	937	/* hac 14.61, pp608 */
toddouska	0:5045d2638c29	938	int mp_invmod_slow (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	939	{
toddouska	0:5045d2638c29	940	mp_int x, y, u, v, A, B, C, D;
toddouska	0:5045d2638c29	941	int res;
toddouska	0:5045d2638c29	942
toddouska	0:5045d2638c29	943	/* b cannot be negative */
toddouska	0:5045d2638c29	944	if (b->sign == MP_NEG \|\| mp_iszero(b) == 1) {
toddouska	0:5045d2638c29	945	return MP_VAL;
toddouska	0:5045d2638c29	946	}
toddouska	0:5045d2638c29	947
toddouska	0:5045d2638c29	948	/* init temps */
toddouska	0:5045d2638c29	949	if ((res = mp_init_multi(&x, &y, &u, &v,
toddouska	0:5045d2638c29	950	&A, &B)) != MP_OKAY) {
toddouska	0:5045d2638c29	951	return res;
toddouska	0:5045d2638c29	952	}
toddouska	0:5045d2638c29	953
toddouska	0:5045d2638c29	954	/* init rest of tmps temps */
toddouska	0:5045d2638c29	955	if ((res = mp_init_multi(&C, &D, 0, 0, 0, 0)) != MP_OKAY) {
toddouska	0:5045d2638c29	956	return res;
toddouska	0:5045d2638c29	957	}
toddouska	0:5045d2638c29	958
toddouska	0:5045d2638c29	959	/* x = a, y = b */
toddouska	0:5045d2638c29	960	if ((res = mp_mod(a, b, &x)) != MP_OKAY) {
toddouska	0:5045d2638c29	961	goto LBL_ERR;
toddouska	0:5045d2638c29	962	}
toddouska	0:5045d2638c29	963	if ((res = mp_copy (b, &y)) != MP_OKAY) {
toddouska	0:5045d2638c29	964	goto LBL_ERR;
toddouska	0:5045d2638c29	965	}
toddouska	0:5045d2638c29	966
toddouska	0:5045d2638c29	967	/* 2. [modified] if x,y are both even then return an error! */
toddouska	0:5045d2638c29	968	if (mp_iseven (&x) == 1 && mp_iseven (&y) == 1) {
toddouska	0:5045d2638c29	969	res = MP_VAL;
toddouska	0:5045d2638c29	970	goto LBL_ERR;
toddouska	0:5045d2638c29	971	}
toddouska	0:5045d2638c29	972
toddouska	0:5045d2638c29	973	/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
toddouska	0:5045d2638c29	974	if ((res = mp_copy (&x, &u)) != MP_OKAY) {
toddouska	0:5045d2638c29	975	goto LBL_ERR;
toddouska	0:5045d2638c29	976	}
toddouska	0:5045d2638c29	977	if ((res = mp_copy (&y, &v)) != MP_OKAY) {
toddouska	0:5045d2638c29	978	goto LBL_ERR;
toddouska	0:5045d2638c29	979	}
toddouska	0:5045d2638c29	980	mp_set (&A, 1);
toddouska	0:5045d2638c29	981	mp_set (&D, 1);
toddouska	0:5045d2638c29	982
toddouska	0:5045d2638c29	983	top:
toddouska	0:5045d2638c29	984	/* 4. while u is even do */
toddouska	0:5045d2638c29	985	while (mp_iseven (&u) == 1) {
toddouska	0:5045d2638c29	986	/* 4.1 u = u/2 */
toddouska	0:5045d2638c29	987	if ((res = mp_div_2 (&u, &u)) != MP_OKAY) {
toddouska	0:5045d2638c29	988	goto LBL_ERR;
toddouska	0:5045d2638c29	989	}
toddouska	0:5045d2638c29	990	/* 4.2 if A or B is odd then */
toddouska	0:5045d2638c29	991	if (mp_isodd (&A) == 1 \|\| mp_isodd (&B) == 1) {
toddouska	0:5045d2638c29	992	/* A = (A+y)/2, B = (B-x)/2 */
toddouska	0:5045d2638c29	993	if ((res = mp_add (&A, &y, &A)) != MP_OKAY) {
toddouska	0:5045d2638c29	994	goto LBL_ERR;
toddouska	0:5045d2638c29	995	}
toddouska	0:5045d2638c29	996	if ((res = mp_sub (&B, &x, &B)) != MP_OKAY) {
toddouska	0:5045d2638c29	997	goto LBL_ERR;
toddouska	0:5045d2638c29	998	}
toddouska	0:5045d2638c29	999	}
toddouska	0:5045d2638c29	1000	/* A = A/2, B = B/2 */
toddouska	0:5045d2638c29	1001	if ((res = mp_div_2 (&A, &A)) != MP_OKAY) {
toddouska	0:5045d2638c29	1002	goto LBL_ERR;
toddouska	0:5045d2638c29	1003	}
toddouska	0:5045d2638c29	1004	if ((res = mp_div_2 (&B, &B)) != MP_OKAY) {
toddouska	0:5045d2638c29	1005	goto LBL_ERR;
toddouska	0:5045d2638c29	1006	}
toddouska	0:5045d2638c29	1007	}
toddouska	0:5045d2638c29	1008
toddouska	0:5045d2638c29	1009	/* 5. while v is even do */
toddouska	0:5045d2638c29	1010	while (mp_iseven (&v) == 1) {
toddouska	0:5045d2638c29	1011	/* 5.1 v = v/2 */
toddouska	0:5045d2638c29	1012	if ((res = mp_div_2 (&v, &v)) != MP_OKAY) {
toddouska	0:5045d2638c29	1013	goto LBL_ERR;
toddouska	0:5045d2638c29	1014	}
toddouska	0:5045d2638c29	1015	/* 5.2 if C or D is odd then */
toddouska	0:5045d2638c29	1016	if (mp_isodd (&C) == 1 \|\| mp_isodd (&D) == 1) {
toddouska	0:5045d2638c29	1017	/* C = (C+y)/2, D = (D-x)/2 */
toddouska	0:5045d2638c29	1018	if ((res = mp_add (&C, &y, &C)) != MP_OKAY) {
toddouska	0:5045d2638c29	1019	goto LBL_ERR;
toddouska	0:5045d2638c29	1020	}
toddouska	0:5045d2638c29	1021	if ((res = mp_sub (&D, &x, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	1022	goto LBL_ERR;
toddouska	0:5045d2638c29	1023	}
toddouska	0:5045d2638c29	1024	}
toddouska	0:5045d2638c29	1025	/* C = C/2, D = D/2 */
toddouska	0:5045d2638c29	1026	if ((res = mp_div_2 (&C, &C)) != MP_OKAY) {
toddouska	0:5045d2638c29	1027	goto LBL_ERR;
toddouska	0:5045d2638c29	1028	}
toddouska	0:5045d2638c29	1029	if ((res = mp_div_2 (&D, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	1030	goto LBL_ERR;
toddouska	0:5045d2638c29	1031	}
toddouska	0:5045d2638c29	1032	}
toddouska	0:5045d2638c29	1033
toddouska	0:5045d2638c29	1034	/* 6. if u >= v then */
toddouska	0:5045d2638c29	1035	if (mp_cmp (&u, &v) != MP_LT) {
toddouska	0:5045d2638c29	1036	/* u = u - v, A = A - C, B = B - D */
toddouska	0:5045d2638c29	1037	if ((res = mp_sub (&u, &v, &u)) != MP_OKAY) {
toddouska	0:5045d2638c29	1038	goto LBL_ERR;
toddouska	0:5045d2638c29	1039	}
toddouska	0:5045d2638c29	1040
toddouska	0:5045d2638c29	1041	if ((res = mp_sub (&A, &C, &A)) != MP_OKAY) {
toddouska	0:5045d2638c29	1042	goto LBL_ERR;
toddouska	0:5045d2638c29	1043	}
toddouska	0:5045d2638c29	1044
toddouska	0:5045d2638c29	1045	if ((res = mp_sub (&B, &D, &B)) != MP_OKAY) {
toddouska	0:5045d2638c29	1046	goto LBL_ERR;
toddouska	0:5045d2638c29	1047	}
toddouska	0:5045d2638c29	1048	} else {
toddouska	0:5045d2638c29	1049	/* v - v - u, C = C - A, D = D - B */
toddouska	0:5045d2638c29	1050	if ((res = mp_sub (&v, &u, &v)) != MP_OKAY) {
toddouska	0:5045d2638c29	1051	goto LBL_ERR;
toddouska	0:5045d2638c29	1052	}
toddouska	0:5045d2638c29	1053
toddouska	0:5045d2638c29	1054	if ((res = mp_sub (&C, &A, &C)) != MP_OKAY) {
toddouska	0:5045d2638c29	1055	goto LBL_ERR;
toddouska	0:5045d2638c29	1056	}
toddouska	0:5045d2638c29	1057
toddouska	0:5045d2638c29	1058	if ((res = mp_sub (&D, &B, &D)) != MP_OKAY) {
toddouska	0:5045d2638c29	1059	goto LBL_ERR;
toddouska	0:5045d2638c29	1060	}
toddouska	0:5045d2638c29	1061	}
toddouska	0:5045d2638c29	1062
toddouska	0:5045d2638c29	1063	/* if not zero goto step 4 */
toddouska	0:5045d2638c29	1064	if (mp_iszero (&u) == 0)
toddouska	0:5045d2638c29	1065	goto top;
toddouska	0:5045d2638c29	1066
toddouska	0:5045d2638c29	1067	/* now a = C, b = D, gcd == gv /
toddouska	0:5045d2638c29	1068
toddouska	0:5045d2638c29	1069	/* if v != 1 then there is no inverse */
toddouska	0:5045d2638c29	1070	if (mp_cmp_d (&v, 1) != MP_EQ) {
toddouska	0:5045d2638c29	1071	res = MP_VAL;
toddouska	0:5045d2638c29	1072	goto LBL_ERR;
toddouska	0:5045d2638c29	1073	}
toddouska	0:5045d2638c29	1074
toddouska	0:5045d2638c29	1075	/* if its too low */
toddouska	0:5045d2638c29	1076	while (mp_cmp_d(&C, 0) == MP_LT) {
toddouska	0:5045d2638c29	1077	if ((res = mp_add(&C, b, &C)) != MP_OKAY) {
toddouska	0:5045d2638c29	1078	goto LBL_ERR;
toddouska	0:5045d2638c29	1079	}
toddouska	0:5045d2638c29	1080	}
toddouska	0:5045d2638c29	1081
toddouska	0:5045d2638c29	1082	/* too big */
toddouska	0:5045d2638c29	1083	while (mp_cmp_mag(&C, b) != MP_LT) {
toddouska	0:5045d2638c29	1084	if ((res = mp_sub(&C, b, &C)) != MP_OKAY) {
toddouska	0:5045d2638c29	1085	goto LBL_ERR;
toddouska	0:5045d2638c29	1086	}
toddouska	0:5045d2638c29	1087	}
toddouska	0:5045d2638c29	1088
toddouska	0:5045d2638c29	1089	/* C is now the inverse */
toddouska	0:5045d2638c29	1090	mp_exch (&C, c);
toddouska	0:5045d2638c29	1091	res = MP_OKAY;
toddouska	0:5045d2638c29	1092	LBL_ERR:mp_clear(&x);
toddouska	0:5045d2638c29	1093	mp_clear(&y);
toddouska	0:5045d2638c29	1094	mp_clear(&u);
toddouska	0:5045d2638c29	1095	mp_clear(&v);
toddouska	0:5045d2638c29	1096	mp_clear(&A);
toddouska	0:5045d2638c29	1097	mp_clear(&B);
toddouska	0:5045d2638c29	1098	mp_clear(&C);
toddouska	0:5045d2638c29	1099	mp_clear(&D);
toddouska	0:5045d2638c29	1100	return res;
toddouska	0:5045d2638c29	1101	}
toddouska	0:5045d2638c29	1102
toddouska	0:5045d2638c29	1103
toddouska	0:5045d2638c29	1104	/* compare maginitude of two ints (unsigned) */
toddouska	0:5045d2638c29	1105	int mp_cmp_mag (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	1106	{
toddouska	0:5045d2638c29	1107	int n;
toddouska	0:5045d2638c29	1108	mp_digit tmpa, tmpb;
toddouska	0:5045d2638c29	1109
toddouska	0:5045d2638c29	1110	/* compare based on # of non-zero digits */
toddouska	0:5045d2638c29	1111	if (a->used > b->used) {
toddouska	0:5045d2638c29	1112	return MP_GT;
toddouska	0:5045d2638c29	1113	}
toddouska	0:5045d2638c29	1114
toddouska	0:5045d2638c29	1115	if (a->used < b->used) {
toddouska	0:5045d2638c29	1116	return MP_LT;
toddouska	0:5045d2638c29	1117	}
toddouska	0:5045d2638c29	1118
toddouska	0:5045d2638c29	1119	/* alias for a */
toddouska	0:5045d2638c29	1120	tmpa = a->dp + (a->used - 1);
toddouska	0:5045d2638c29	1121
toddouska	0:5045d2638c29	1122	/* alias for b */
toddouska	0:5045d2638c29	1123	tmpb = b->dp + (a->used - 1);
toddouska	0:5045d2638c29	1124
toddouska	0:5045d2638c29	1125	/* compare based on digits */
toddouska	0:5045d2638c29	1126	for (n = 0; n < a->used; ++n, --tmpa, --tmpb) {
toddouska	0:5045d2638c29	1127	if (tmpa > tmpb) {
toddouska	0:5045d2638c29	1128	return MP_GT;
toddouska	0:5045d2638c29	1129	}
toddouska	0:5045d2638c29	1130
toddouska	0:5045d2638c29	1131	if (tmpa < tmpb) {
toddouska	0:5045d2638c29	1132	return MP_LT;
toddouska	0:5045d2638c29	1133	}
toddouska	0:5045d2638c29	1134	}
toddouska	0:5045d2638c29	1135	return MP_EQ;
toddouska	0:5045d2638c29	1136	}
toddouska	0:5045d2638c29	1137
toddouska	0:5045d2638c29	1138
toddouska	0:5045d2638c29	1139	/* compare two ints (signed)*/
toddouska	0:5045d2638c29	1140	int
toddouska	0:5045d2638c29	1141	mp_cmp (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	1142	{
toddouska	0:5045d2638c29	1143	/* compare based on sign */
toddouska	0:5045d2638c29	1144	if (a->sign != b->sign) {
toddouska	0:5045d2638c29	1145	if (a->sign == MP_NEG) {
toddouska	0:5045d2638c29	1146	return MP_LT;
toddouska	0:5045d2638c29	1147	} else {
toddouska	0:5045d2638c29	1148	return MP_GT;
toddouska	0:5045d2638c29	1149	}
toddouska	0:5045d2638c29	1150	}
toddouska	0:5045d2638c29	1151
toddouska	0:5045d2638c29	1152	/* compare digits */
toddouska	0:5045d2638c29	1153	if (a->sign == MP_NEG) {
toddouska	0:5045d2638c29	1154	/* if negative compare opposite direction */
toddouska	0:5045d2638c29	1155	return mp_cmp_mag(b, a);
toddouska	0:5045d2638c29	1156	} else {
toddouska	0:5045d2638c29	1157	return mp_cmp_mag(a, b);
toddouska	0:5045d2638c29	1158	}
toddouska	0:5045d2638c29	1159	}
toddouska	0:5045d2638c29	1160
toddouska	0:5045d2638c29	1161
toddouska	0:5045d2638c29	1162	/* compare a digit */
toddouska	0:5045d2638c29	1163	int mp_cmp_d(mp_int * a, mp_digit b)
toddouska	0:5045d2638c29	1164	{
toddouska	0:5045d2638c29	1165	/* compare based on sign */
toddouska	0:5045d2638c29	1166	if (a->sign == MP_NEG) {
toddouska	0:5045d2638c29	1167	return MP_LT;
toddouska	0:5045d2638c29	1168	}
toddouska	0:5045d2638c29	1169
toddouska	0:5045d2638c29	1170	/* compare based on magnitude */
toddouska	0:5045d2638c29	1171	if (a->used > 1) {
toddouska	0:5045d2638c29	1172	return MP_GT;
toddouska	0:5045d2638c29	1173	}
toddouska	0:5045d2638c29	1174
toddouska	0:5045d2638c29	1175	/* compare the only digit of a to b */
toddouska	0:5045d2638c29	1176	if (a->dp[0] > b) {
toddouska	0:5045d2638c29	1177	return MP_GT;
toddouska	0:5045d2638c29	1178	} else if (a->dp[0] < b) {
toddouska	0:5045d2638c29	1179	return MP_LT;
toddouska	0:5045d2638c29	1180	} else {
toddouska	0:5045d2638c29	1181	return MP_EQ;
toddouska	0:5045d2638c29	1182	}
toddouska	0:5045d2638c29	1183	}
toddouska	0:5045d2638c29	1184
toddouska	0:5045d2638c29	1185
toddouska	0:5045d2638c29	1186	/* set to a digit */
toddouska	0:5045d2638c29	1187	void mp_set (mp_int * a, mp_digit b)
toddouska	0:5045d2638c29	1188	{
toddouska	0:5045d2638c29	1189	mp_zero (a);
toddouska	0:5045d2638c29	1190	a->dp[0] = b & MP_MASK;
toddouska	0:5045d2638c29	1191	a->used = (a->dp[0] != 0) ? 1 : 0;
toddouska	0:5045d2638c29	1192	}
toddouska	0:5045d2638c29	1193
toddouska	0:5045d2638c29	1194
toddouska	0:5045d2638c29	1195	/* c = a mod b, 0 <= c < b */
toddouska	0:5045d2638c29	1196	int
toddouska	0:5045d2638c29	1197	mp_mod (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	1198	{
toddouska	0:5045d2638c29	1199	mp_int t;
toddouska	0:5045d2638c29	1200	int res;
toddouska	0:5045d2638c29	1201
toddouska	0:5045d2638c29	1202	if ((res = mp_init (&t)) != MP_OKAY) {
toddouska	0:5045d2638c29	1203	return res;
toddouska	0:5045d2638c29	1204	}
toddouska	0:5045d2638c29	1205
toddouska	0:5045d2638c29	1206	if ((res = mp_div (a, b, NULL, &t)) != MP_OKAY) {
toddouska	0:5045d2638c29	1207	mp_clear (&t);
toddouska	0:5045d2638c29	1208	return res;
toddouska	0:5045d2638c29	1209	}
toddouska	0:5045d2638c29	1210
toddouska	0:5045d2638c29	1211	if (t.sign != b->sign) {
toddouska	0:5045d2638c29	1212	res = mp_add (b, &t, c);
toddouska	0:5045d2638c29	1213	} else {
toddouska	0:5045d2638c29	1214	res = MP_OKAY;
toddouska	0:5045d2638c29	1215	mp_exch (&t, c);
toddouska	0:5045d2638c29	1216	}
toddouska	0:5045d2638c29	1217
toddouska	0:5045d2638c29	1218	mp_clear (&t);
toddouska	0:5045d2638c29	1219	return res;
toddouska	0:5045d2638c29	1220	}
toddouska	0:5045d2638c29	1221
toddouska	0:5045d2638c29	1222
toddouska	0:5045d2638c29	1223	/* slower bit-bang division... also smaller */
toddouska	0:5045d2638c29	1224	int mp_div(mp_int * a, mp_int * b, mp_int * c, mp_int * d)
toddouska	0:5045d2638c29	1225	{
toddouska	0:5045d2638c29	1226	mp_int ta, tb, tq, q;
toddouska	0:5045d2638c29	1227	int res, n, n2;
toddouska	0:5045d2638c29	1228
toddouska	0:5045d2638c29	1229	/* is divisor zero ? */
toddouska	0:5045d2638c29	1230	if (mp_iszero (b) == 1) {
toddouska	0:5045d2638c29	1231	return MP_VAL;
toddouska	0:5045d2638c29	1232	}
toddouska	0:5045d2638c29	1233
toddouska	0:5045d2638c29	1234	/* if a < b then q=0, r = a */
toddouska	0:5045d2638c29	1235	if (mp_cmp_mag (a, b) == MP_LT) {
toddouska	0:5045d2638c29	1236	if (d != NULL) {
toddouska	0:5045d2638c29	1237	res = mp_copy (a, d);
toddouska	0:5045d2638c29	1238	} else {
toddouska	0:5045d2638c29	1239	res = MP_OKAY;
toddouska	0:5045d2638c29	1240	}
toddouska	0:5045d2638c29	1241	if (c != NULL) {
toddouska	0:5045d2638c29	1242	mp_zero (c);
toddouska	0:5045d2638c29	1243	}
toddouska	0:5045d2638c29	1244	return res;
toddouska	0:5045d2638c29	1245	}
toddouska	0:5045d2638c29	1246
toddouska	0:5045d2638c29	1247	/* init our temps */
toddouska	0:5045d2638c29	1248	if ((res = mp_init_multi(&ta, &tb, &tq, &q, 0, 0) != MP_OKAY)) {
toddouska	0:5045d2638c29	1249	return res;
toddouska	0:5045d2638c29	1250	}
toddouska	0:5045d2638c29	1251
toddouska	0:5045d2638c29	1252
toddouska	0:5045d2638c29	1253	mp_set(&tq, 1);
toddouska	0:5045d2638c29	1254	n = mp_count_bits(a) - mp_count_bits(b);
toddouska	0:5045d2638c29	1255	if (((res = mp_abs(a, &ta)) != MP_OKAY) \|\|
toddouska	0:5045d2638c29	1256	((res = mp_abs(b, &tb)) != MP_OKAY) \|\|
toddouska	0:5045d2638c29	1257	((res = mp_mul_2d(&tb, n, &tb)) != MP_OKAY) \|\|
toddouska	0:5045d2638c29	1258	((res = mp_mul_2d(&tq, n, &tq)) != MP_OKAY)) {
toddouska	0:5045d2638c29	1259	goto LBL_ERR;
toddouska	0:5045d2638c29	1260	}
toddouska	0:5045d2638c29	1261
toddouska	0:5045d2638c29	1262	while (n-- >= 0) {
toddouska	0:5045d2638c29	1263	if (mp_cmp(&tb, &ta) != MP_GT) {
toddouska	0:5045d2638c29	1264	if (((res = mp_sub(&ta, &tb, &ta)) != MP_OKAY) \|\|
toddouska	0:5045d2638c29	1265	((res = mp_add(&q, &tq, &q)) != MP_OKAY)) {
toddouska	0:5045d2638c29	1266	goto LBL_ERR;
toddouska	0:5045d2638c29	1267	}
toddouska	0:5045d2638c29	1268	}
toddouska	0:5045d2638c29	1269	if (((res = mp_div_2d(&tb, 1, &tb, NULL)) != MP_OKAY) \|\|
toddouska	0:5045d2638c29	1270	((res = mp_div_2d(&tq, 1, &tq, NULL)) != MP_OKAY)) {
toddouska	0:5045d2638c29	1271	goto LBL_ERR;
toddouska	0:5045d2638c29	1272	}
toddouska	0:5045d2638c29	1273	}
toddouska	0:5045d2638c29	1274
toddouska	0:5045d2638c29	1275	/* now q == quotient and ta == remainder */
toddouska	0:5045d2638c29	1276	n = a->sign;
toddouska	0:5045d2638c29	1277	n2 = (a->sign == b->sign ? MP_ZPOS : MP_NEG);
toddouska	0:5045d2638c29	1278	if (c != NULL) {
toddouska	0:5045d2638c29	1279	mp_exch(c, &q);
toddouska	0:5045d2638c29	1280	c->sign = (mp_iszero(c) == MP_YES) ? MP_ZPOS : n2;
toddouska	0:5045d2638c29	1281	}
toddouska	0:5045d2638c29	1282	if (d != NULL) {
toddouska	0:5045d2638c29	1283	mp_exch(d, &ta);
toddouska	0:5045d2638c29	1284	d->sign = (mp_iszero(d) == MP_YES) ? MP_ZPOS : n;
toddouska	0:5045d2638c29	1285	}
toddouska	0:5045d2638c29	1286	LBL_ERR:
toddouska	0:5045d2638c29	1287	mp_clear(&ta);
toddouska	0:5045d2638c29	1288	mp_clear(&tb);
toddouska	0:5045d2638c29	1289	mp_clear(&tq);
toddouska	0:5045d2638c29	1290	mp_clear(&q);
toddouska	0:5045d2638c29	1291	return res;
toddouska	0:5045d2638c29	1292	}
toddouska	0:5045d2638c29	1293
toddouska	0:5045d2638c29	1294
toddouska	0:5045d2638c29	1295	/* b = a/2 */
toddouska	0:5045d2638c29	1296	int mp_div_2(mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	1297	{
toddouska	0:5045d2638c29	1298	int x, res, oldused;
toddouska	0:5045d2638c29	1299
toddouska	0:5045d2638c29	1300	/* copy */
toddouska	0:5045d2638c29	1301	if (b->alloc < a->used) {
toddouska	0:5045d2638c29	1302	if ((res = mp_grow (b, a->used)) != MP_OKAY) {
toddouska	0:5045d2638c29	1303	return res;
toddouska	0:5045d2638c29	1304	}
toddouska	0:5045d2638c29	1305	}
toddouska	0:5045d2638c29	1306
toddouska	0:5045d2638c29	1307	oldused = b->used;
toddouska	0:5045d2638c29	1308	b->used = a->used;
toddouska	0:5045d2638c29	1309	{
toddouska	0:5045d2638c29	1310	register mp_digit r, rr, tmpa, tmpb;
toddouska	0:5045d2638c29	1311
toddouska	0:5045d2638c29	1312	/* source alias */
toddouska	0:5045d2638c29	1313	tmpa = a->dp + b->used - 1;
toddouska	0:5045d2638c29	1314
toddouska	0:5045d2638c29	1315	/* dest alias */
toddouska	0:5045d2638c29	1316	tmpb = b->dp + b->used - 1;
toddouska	0:5045d2638c29	1317
toddouska	0:5045d2638c29	1318	/* carry */
toddouska	0:5045d2638c29	1319	r = 0;
toddouska	0:5045d2638c29	1320	for (x = b->used - 1; x >= 0; x--) {
toddouska	0:5045d2638c29	1321	/* get the carry for the next iteration */
toddouska	0:5045d2638c29	1322	rr = *tmpa & 1;
toddouska	0:5045d2638c29	1323
toddouska	0:5045d2638c29	1324	/* shift the current digit, add in carry and store */
toddouska	0:5045d2638c29	1325	tmpb-- = (tmpa-- >> 1) \| (r << (DIGIT_BIT - 1));
toddouska	0:5045d2638c29	1326
toddouska	0:5045d2638c29	1327	/* forward carry to next iteration */
toddouska	0:5045d2638c29	1328	r = rr;
toddouska	0:5045d2638c29	1329	}
toddouska	0:5045d2638c29	1330
toddouska	0:5045d2638c29	1331	/* zero excess digits */
toddouska	0:5045d2638c29	1332	tmpb = b->dp + b->used;
toddouska	0:5045d2638c29	1333	for (x = b->used; x < oldused; x++) {
toddouska	0:5045d2638c29	1334	*tmpb++ = 0;
toddouska	0:5045d2638c29	1335	}
toddouska	0:5045d2638c29	1336	}
toddouska	0:5045d2638c29	1337	b->sign = a->sign;
toddouska	0:5045d2638c29	1338	mp_clamp (b);
toddouska	0:5045d2638c29	1339	return MP_OKAY;
toddouska	0:5045d2638c29	1340	}
toddouska	0:5045d2638c29	1341
toddouska	0:5045d2638c29	1342
toddouska	0:5045d2638c29	1343	/* high level addition (handles signs) */
toddouska	0:5045d2638c29	1344	int mp_add (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	1345	{
toddouska	0:5045d2638c29	1346	int sa, sb, res;
toddouska	0:5045d2638c29	1347
toddouska	0:5045d2638c29	1348	/* get sign of both inputs */
toddouska	0:5045d2638c29	1349	sa = a->sign;
toddouska	0:5045d2638c29	1350	sb = b->sign;
toddouska	0:5045d2638c29	1351
toddouska	0:5045d2638c29	1352	/* handle two cases, not four */
toddouska	0:5045d2638c29	1353	if (sa == sb) {
toddouska	0:5045d2638c29	1354	/* both positive or both negative */
toddouska	0:5045d2638c29	1355	/* add their magnitudes, copy the sign */
toddouska	0:5045d2638c29	1356	c->sign = sa;
toddouska	0:5045d2638c29	1357	res = s_mp_add (a, b, c);
toddouska	0:5045d2638c29	1358	} else {
toddouska	0:5045d2638c29	1359	/* one positive, the other negative */
toddouska	0:5045d2638c29	1360	/* subtract the one with the greater magnitude from */
toddouska	0:5045d2638c29	1361	/* the one of the lesser magnitude. The result gets */
toddouska	0:5045d2638c29	1362	/* the sign of the one with the greater magnitude. */
toddouska	0:5045d2638c29	1363	if (mp_cmp_mag (a, b) == MP_LT) {
toddouska	0:5045d2638c29	1364	c->sign = sb;
toddouska	0:5045d2638c29	1365	res = s_mp_sub (b, a, c);
toddouska	0:5045d2638c29	1366	} else {
toddouska	0:5045d2638c29	1367	c->sign = sa;
toddouska	0:5045d2638c29	1368	res = s_mp_sub (a, b, c);
toddouska	0:5045d2638c29	1369	}
toddouska	0:5045d2638c29	1370	}
toddouska	0:5045d2638c29	1371	return res;
toddouska	0:5045d2638c29	1372	}
toddouska	0:5045d2638c29	1373
toddouska	0:5045d2638c29	1374
toddouska	0:5045d2638c29	1375	/* low level addition, based on HAC pp.594, Algorithm 14.7 */
toddouska	0:5045d2638c29	1376	int
toddouska	0:5045d2638c29	1377	s_mp_add (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	1378	{
toddouska	0:5045d2638c29	1379	mp_int *x;
toddouska	0:5045d2638c29	1380	int olduse, res, min, max;
toddouska	0:5045d2638c29	1381
toddouska	0:5045d2638c29	1382	/* find sizes, we let \|a\| <= \|b\| which means we have to sort
toddouska	0:5045d2638c29	1383	* them. "x" will point to the input with the most digits
toddouska	0:5045d2638c29	1384	*/
toddouska	0:5045d2638c29	1385	if (a->used > b->used) {
toddouska	0:5045d2638c29	1386	min = b->used;
toddouska	0:5045d2638c29	1387	max = a->used;
toddouska	0:5045d2638c29	1388	x = a;
toddouska	0:5045d2638c29	1389	} else {
toddouska	0:5045d2638c29	1390	min = a->used;
toddouska	0:5045d2638c29	1391	max = b->used;
toddouska	0:5045d2638c29	1392	x = b;
toddouska	0:5045d2638c29	1393	}
toddouska	0:5045d2638c29	1394
toddouska	0:5045d2638c29	1395	/* init result */
toddouska	0:5045d2638c29	1396	if (c->alloc < max + 1) {
toddouska	0:5045d2638c29	1397	if ((res = mp_grow (c, max + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	1398	return res;
toddouska	0:5045d2638c29	1399	}
toddouska	0:5045d2638c29	1400	}
toddouska	0:5045d2638c29	1401
toddouska	0:5045d2638c29	1402	/* get old used digit count and set new one */
toddouska	0:5045d2638c29	1403	olduse = c->used;
toddouska	0:5045d2638c29	1404	c->used = max + 1;
toddouska	0:5045d2638c29	1405
toddouska	0:5045d2638c29	1406	{
toddouska	0:5045d2638c29	1407	register mp_digit u, tmpa, tmpb, *tmpc;
toddouska	0:5045d2638c29	1408	register int i;
toddouska	0:5045d2638c29	1409
toddouska	0:5045d2638c29	1410	/* alias for digit pointers */
toddouska	0:5045d2638c29	1411
toddouska	0:5045d2638c29	1412	/* first input */
toddouska	0:5045d2638c29	1413	tmpa = a->dp;
toddouska	0:5045d2638c29	1414
toddouska	0:5045d2638c29	1415	/* second input */
toddouska	0:5045d2638c29	1416	tmpb = b->dp;
toddouska	0:5045d2638c29	1417
toddouska	0:5045d2638c29	1418	/* destination */
toddouska	0:5045d2638c29	1419	tmpc = c->dp;
toddouska	0:5045d2638c29	1420
toddouska	0:5045d2638c29	1421	/* zero the carry */
toddouska	0:5045d2638c29	1422	u = 0;
toddouska	0:5045d2638c29	1423	for (i = 0; i < min; i++) {
toddouska	0:5045d2638c29	1424	/* Compute the sum at one digit, T[i] = A[i] + B[i] + U */
toddouska	0:5045d2638c29	1425	tmpc = tmpa++ + *tmpb++ + u;
toddouska	0:5045d2638c29	1426
toddouska	0:5045d2638c29	1427	/* U = carry bit of T[i] */
toddouska	0:5045d2638c29	1428	u = *tmpc >> ((mp_digit)DIGIT_BIT);
toddouska	0:5045d2638c29	1429
toddouska	0:5045d2638c29	1430	/* take away carry bit from T[i] */
toddouska	0:5045d2638c29	1431	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	1432	}
toddouska	0:5045d2638c29	1433
toddouska	0:5045d2638c29	1434	/* now copy higher words if any, that is in A+B
toddouska	0:5045d2638c29	1435	* if A or B has more digits add those in
toddouska	0:5045d2638c29	1436	*/
toddouska	0:5045d2638c29	1437	if (min != max) {
toddouska	0:5045d2638c29	1438	for (; i < max; i++) {
toddouska	0:5045d2638c29	1439	/* T[i] = X[i] + U */
toddouska	0:5045d2638c29	1440	*tmpc = x->dp[i] + u;
toddouska	0:5045d2638c29	1441
toddouska	0:5045d2638c29	1442	/* U = carry bit of T[i] */
toddouska	0:5045d2638c29	1443	u = *tmpc >> ((mp_digit)DIGIT_BIT);
toddouska	0:5045d2638c29	1444
toddouska	0:5045d2638c29	1445	/* take away carry bit from T[i] */
toddouska	0:5045d2638c29	1446	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	1447	}
toddouska	0:5045d2638c29	1448	}
toddouska	0:5045d2638c29	1449
toddouska	0:5045d2638c29	1450	/* add carry */
toddouska	0:5045d2638c29	1451	*tmpc++ = u;
toddouska	0:5045d2638c29	1452
toddouska	0:5045d2638c29	1453	/* clear digits above oldused */
toddouska	0:5045d2638c29	1454	for (i = c->used; i < olduse; i++) {
toddouska	0:5045d2638c29	1455	*tmpc++ = 0;
toddouska	0:5045d2638c29	1456	}
toddouska	0:5045d2638c29	1457	}
toddouska	0:5045d2638c29	1458
toddouska	0:5045d2638c29	1459	mp_clamp (c);
toddouska	0:5045d2638c29	1460	return MP_OKAY;
toddouska	0:5045d2638c29	1461	}
toddouska	0:5045d2638c29	1462
toddouska	0:5045d2638c29	1463
toddouska	0:5045d2638c29	1464	/* low level subtraction (assumes \|a\| > \|b\|), HAC pp.595 Algorithm 14.9 */
toddouska	0:5045d2638c29	1465	int
toddouska	0:5045d2638c29	1466	s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	1467	{
toddouska	0:5045d2638c29	1468	int olduse, res, min, max;
toddouska	0:5045d2638c29	1469
toddouska	0:5045d2638c29	1470	/* find sizes */
toddouska	0:5045d2638c29	1471	min = b->used;
toddouska	0:5045d2638c29	1472	max = a->used;
toddouska	0:5045d2638c29	1473
toddouska	0:5045d2638c29	1474	/* init result */
toddouska	0:5045d2638c29	1475	if (c->alloc < max) {
toddouska	0:5045d2638c29	1476	if ((res = mp_grow (c, max)) != MP_OKAY) {
toddouska	0:5045d2638c29	1477	return res;
toddouska	0:5045d2638c29	1478	}
toddouska	0:5045d2638c29	1479	}
toddouska	0:5045d2638c29	1480	olduse = c->used;
toddouska	0:5045d2638c29	1481	c->used = max;
toddouska	0:5045d2638c29	1482
toddouska	0:5045d2638c29	1483	{
toddouska	0:5045d2638c29	1484	register mp_digit u, tmpa, tmpb, *tmpc;
toddouska	0:5045d2638c29	1485	register int i;
toddouska	0:5045d2638c29	1486
toddouska	0:5045d2638c29	1487	/* alias for digit pointers */
toddouska	0:5045d2638c29	1488	tmpa = a->dp;
toddouska	0:5045d2638c29	1489	tmpb = b->dp;
toddouska	0:5045d2638c29	1490	tmpc = c->dp;
toddouska	0:5045d2638c29	1491
toddouska	0:5045d2638c29	1492	/* set carry to zero */
toddouska	0:5045d2638c29	1493	u = 0;
toddouska	0:5045d2638c29	1494	for (i = 0; i < min; i++) {
toddouska	0:5045d2638c29	1495	/* T[i] = A[i] - B[i] - U */
toddouska	0:5045d2638c29	1496	tmpc = tmpa++ - *tmpb++ - u;
toddouska	0:5045d2638c29	1497
toddouska	0:5045d2638c29	1498	/* U = carry bit of T[i]
toddouska	0:5045d2638c29	1499	* Note this saves performing an AND operation since
toddouska	0:5045d2638c29	1500	* if a carry does occur it will propagate all the way to the
toddouska	0:5045d2638c29	1501	* MSB. As a result a single shift is enough to get the carry
toddouska	0:5045d2638c29	1502	*/
toddouska	0:5045d2638c29	1503	u = tmpc >> ((mp_digit)(CHAR_BIT sizeof (mp_digit) - 1));
toddouska	0:5045d2638c29	1504
toddouska	0:5045d2638c29	1505	/* Clear carry from T[i] */
toddouska	0:5045d2638c29	1506	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	1507	}
toddouska	0:5045d2638c29	1508
toddouska	0:5045d2638c29	1509	/* now copy higher words if any, e.g. if A has more digits than B */
toddouska	0:5045d2638c29	1510	for (; i < max; i++) {
toddouska	0:5045d2638c29	1511	/* T[i] = A[i] - U */
toddouska	0:5045d2638c29	1512	tmpc = tmpa++ - u;
toddouska	0:5045d2638c29	1513
toddouska	0:5045d2638c29	1514	/* U = carry bit of T[i] */
toddouska	0:5045d2638c29	1515	u = tmpc >> ((mp_digit)(CHAR_BIT sizeof (mp_digit) - 1));
toddouska	0:5045d2638c29	1516
toddouska	0:5045d2638c29	1517	/* Clear carry from T[i] */
toddouska	0:5045d2638c29	1518	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	1519	}
toddouska	0:5045d2638c29	1520
toddouska	0:5045d2638c29	1521	/* clear digits above used (since we may not have grown result above) */
toddouska	0:5045d2638c29	1522	for (i = c->used; i < olduse; i++) {
toddouska	0:5045d2638c29	1523	*tmpc++ = 0;
toddouska	0:5045d2638c29	1524	}
toddouska	0:5045d2638c29	1525	}
toddouska	0:5045d2638c29	1526
toddouska	0:5045d2638c29	1527	mp_clamp (c);
toddouska	0:5045d2638c29	1528	return MP_OKAY;
toddouska	0:5045d2638c29	1529	}
toddouska	0:5045d2638c29	1530
toddouska	0:5045d2638c29	1531
toddouska	0:5045d2638c29	1532	/* high level subtraction (handles signs) */
toddouska	0:5045d2638c29	1533	int
toddouska	0:5045d2638c29	1534	mp_sub (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	1535	{
toddouska	0:5045d2638c29	1536	int sa, sb, res;
toddouska	0:5045d2638c29	1537
toddouska	0:5045d2638c29	1538	sa = a->sign;
toddouska	0:5045d2638c29	1539	sb = b->sign;
toddouska	0:5045d2638c29	1540
toddouska	0:5045d2638c29	1541	if (sa != sb) {
toddouska	0:5045d2638c29	1542	/* subtract a negative from a positive, OR */
toddouska	0:5045d2638c29	1543	/* subtract a positive from a negative. */
toddouska	0:5045d2638c29	1544	/* In either case, ADD their magnitudes, */
toddouska	0:5045d2638c29	1545	/* and use the sign of the first number. */
toddouska	0:5045d2638c29	1546	c->sign = sa;
toddouska	0:5045d2638c29	1547	res = s_mp_add (a, b, c);
toddouska	0:5045d2638c29	1548	} else {
toddouska	0:5045d2638c29	1549	/* subtract a positive from a positive, OR */
toddouska	0:5045d2638c29	1550	/* subtract a negative from a negative. */
toddouska	0:5045d2638c29	1551	/* First, take the difference between their */
toddouska	0:5045d2638c29	1552	/* magnitudes, then... */
toddouska	0:5045d2638c29	1553	if (mp_cmp_mag (a, b) != MP_LT) {
toddouska	0:5045d2638c29	1554	/* Copy the sign from the first */
toddouska	0:5045d2638c29	1555	c->sign = sa;
toddouska	0:5045d2638c29	1556	/* The first has a larger or equal magnitude */
toddouska	0:5045d2638c29	1557	res = s_mp_sub (a, b, c);
toddouska	0:5045d2638c29	1558	} else {
toddouska	0:5045d2638c29	1559	/* The result has the opposite sign from */
toddouska	0:5045d2638c29	1560	/* the first number. */
toddouska	0:5045d2638c29	1561	c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS;
toddouska	0:5045d2638c29	1562	/* The second has a larger magnitude */
toddouska	0:5045d2638c29	1563	res = s_mp_sub (b, a, c);
toddouska	0:5045d2638c29	1564	}
toddouska	0:5045d2638c29	1565	}
toddouska	0:5045d2638c29	1566	return res;
toddouska	0:5045d2638c29	1567	}
toddouska	0:5045d2638c29	1568
toddouska	0:5045d2638c29	1569
toddouska	0:5045d2638c29	1570	/* determines if reduce_2k_l can be used */
toddouska	0:5045d2638c29	1571	int mp_reduce_is_2k_l(mp_int *a)
toddouska	0:5045d2638c29	1572	{
toddouska	0:5045d2638c29	1573	int ix, iy;
toddouska	0:5045d2638c29	1574
toddouska	0:5045d2638c29	1575	if (a->used == 0) {
toddouska	0:5045d2638c29	1576	return MP_NO;
toddouska	0:5045d2638c29	1577	} else if (a->used == 1) {
toddouska	0:5045d2638c29	1578	return MP_YES;
toddouska	0:5045d2638c29	1579	} else if (a->used > 1) {
toddouska	0:5045d2638c29	1580	/* if more than half of the digits are -1 we're sold */
toddouska	0:5045d2638c29	1581	for (iy = ix = 0; ix < a->used; ix++) {
toddouska	0:5045d2638c29	1582	if (a->dp[ix] == MP_MASK) {
toddouska	0:5045d2638c29	1583	++iy;
toddouska	0:5045d2638c29	1584	}
toddouska	0:5045d2638c29	1585	}
toddouska	0:5045d2638c29	1586	return (iy >= (a->used/2)) ? MP_YES : MP_NO;
toddouska	0:5045d2638c29	1587
toddouska	0:5045d2638c29	1588	}
toddouska	0:5045d2638c29	1589	return MP_NO;
toddouska	0:5045d2638c29	1590	}
toddouska	0:5045d2638c29	1591
toddouska	0:5045d2638c29	1592
toddouska	0:5045d2638c29	1593	/* determines if mp_reduce_2k can be used */
toddouska	0:5045d2638c29	1594	int mp_reduce_is_2k(mp_int *a)
toddouska	0:5045d2638c29	1595	{
toddouska	0:5045d2638c29	1596	int ix, iy, iw;
toddouska	0:5045d2638c29	1597	mp_digit iz;
toddouska	0:5045d2638c29	1598
toddouska	0:5045d2638c29	1599	if (a->used == 0) {
toddouska	0:5045d2638c29	1600	return MP_NO;
toddouska	0:5045d2638c29	1601	} else if (a->used == 1) {
toddouska	0:5045d2638c29	1602	return MP_YES;
toddouska	0:5045d2638c29	1603	} else if (a->used > 1) {
toddouska	0:5045d2638c29	1604	iy = mp_count_bits(a);
toddouska	0:5045d2638c29	1605	iz = 1;
toddouska	0:5045d2638c29	1606	iw = 1;
toddouska	0:5045d2638c29	1607
toddouska	0:5045d2638c29	1608	/* Test every bit from the second digit up, must be 1 */
toddouska	0:5045d2638c29	1609	for (ix = DIGIT_BIT; ix < iy; ix++) {
toddouska	0:5045d2638c29	1610	if ((a->dp[iw] & iz) == 0) {
toddouska	0:5045d2638c29	1611	return MP_NO;
toddouska	0:5045d2638c29	1612	}
toddouska	0:5045d2638c29	1613	iz <<= 1;
toddouska	0:5045d2638c29	1614	if (iz > (mp_digit)MP_MASK) {
toddouska	0:5045d2638c29	1615	++iw;
toddouska	0:5045d2638c29	1616	iz = 1;
toddouska	0:5045d2638c29	1617	}
toddouska	0:5045d2638c29	1618	}
toddouska	0:5045d2638c29	1619	}
toddouska	0:5045d2638c29	1620	return MP_YES;
toddouska	0:5045d2638c29	1621	}
toddouska	0:5045d2638c29	1622
toddouska	0:5045d2638c29	1623
toddouska	0:5045d2638c29	1624	/* determines if a number is a valid DR modulus */
toddouska	0:5045d2638c29	1625	int mp_dr_is_modulus(mp_int *a)
toddouska	0:5045d2638c29	1626	{
toddouska	0:5045d2638c29	1627	int ix;
toddouska	0:5045d2638c29	1628
toddouska	0:5045d2638c29	1629	/* must be at least two digits */
toddouska	0:5045d2638c29	1630	if (a->used < 2) {
toddouska	0:5045d2638c29	1631	return 0;
toddouska	0:5045d2638c29	1632	}
toddouska	0:5045d2638c29	1633
toddouska	0:5045d2638c29	1634	/* must be of the form b**k - a [a <= b] so all
toddouska	0:5045d2638c29	1635	* but the first digit must be equal to -1 (mod b).
toddouska	0:5045d2638c29	1636	*/
toddouska	0:5045d2638c29	1637	for (ix = 1; ix < a->used; ix++) {
toddouska	0:5045d2638c29	1638	if (a->dp[ix] != MP_MASK) {
toddouska	0:5045d2638c29	1639	return 0;
toddouska	0:5045d2638c29	1640	}
toddouska	0:5045d2638c29	1641	}
toddouska	0:5045d2638c29	1642	return 1;
toddouska	0:5045d2638c29	1643	}
toddouska	0:5045d2638c29	1644
toddouska	0:5045d2638c29	1645
toddouska	0:5045d2638c29	1646	/* computes Y == G**X mod P, HAC pp.616, Algorithm 14.85
toddouska	0:5045d2638c29	1647	*
toddouska	0:5045d2638c29	1648	* Uses a left-to-right k-ary sliding window to compute the modular
toddouska	0:5045d2638c29	1649	* exponentiation.
toddouska	0:5045d2638c29	1650	* The value of k changes based on the size of the exponent.
toddouska	0:5045d2638c29	1651	*
toddouska	0:5045d2638c29	1652	* Uses Montgomery or Diminished Radix reduction [whichever appropriate]
toddouska	0:5045d2638c29	1653	*/
toddouska	0:5045d2638c29	1654
toddouska	0:5045d2638c29	1655	#ifdef MP_LOW_MEM
toddouska	0:5045d2638c29	1656	#define TAB_SIZE 32
toddouska	0:5045d2638c29	1657	#else
toddouska	0:5045d2638c29	1658	#define TAB_SIZE 256
toddouska	0:5045d2638c29	1659	#endif
toddouska	0:5045d2638c29	1660
toddouska	0:5045d2638c29	1661	int mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y,
toddouska	0:5045d2638c29	1662	int redmode)
toddouska	0:5045d2638c29	1663	{
toddouska	0:5045d2638c29	1664	mp_int M[TAB_SIZE], res;
toddouska	0:5045d2638c29	1665	mp_digit buf, mp;
toddouska	0:5045d2638c29	1666	int err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
toddouska	0:5045d2638c29	1667
toddouska	0:5045d2638c29	1668	/* use a pointer to the reduction algorithm. This allows us to use
toddouska	0:5045d2638c29	1669	* one of many reduction algorithms without modding the guts of
toddouska	0:5045d2638c29	1670	* the code with if statements everywhere.
toddouska	0:5045d2638c29	1671	*/
toddouska	0:5045d2638c29	1672	int (redux)(mp_int,mp_int*,mp_digit);
toddouska	0:5045d2638c29	1673
toddouska	0:5045d2638c29	1674	/* find window size */
toddouska	0:5045d2638c29	1675	x = mp_count_bits (X);
toddouska	0:5045d2638c29	1676	if (x <= 7) {
toddouska	0:5045d2638c29	1677	winsize = 2;
toddouska	0:5045d2638c29	1678	} else if (x <= 36) {
toddouska	0:5045d2638c29	1679	winsize = 3;
toddouska	0:5045d2638c29	1680	} else if (x <= 140) {
toddouska	0:5045d2638c29	1681	winsize = 4;
toddouska	0:5045d2638c29	1682	} else if (x <= 450) {
toddouska	0:5045d2638c29	1683	winsize = 5;
toddouska	0:5045d2638c29	1684	} else if (x <= 1303) {
toddouska	0:5045d2638c29	1685	winsize = 6;
toddouska	0:5045d2638c29	1686	} else if (x <= 3529) {
toddouska	0:5045d2638c29	1687	winsize = 7;
toddouska	0:5045d2638c29	1688	} else {
toddouska	0:5045d2638c29	1689	winsize = 8;
toddouska	0:5045d2638c29	1690	}
toddouska	0:5045d2638c29	1691
toddouska	0:5045d2638c29	1692	#ifdef MP_LOW_MEM
toddouska	0:5045d2638c29	1693	if (winsize > 5) {
toddouska	0:5045d2638c29	1694	winsize = 5;
toddouska	0:5045d2638c29	1695	}
toddouska	0:5045d2638c29	1696	#endif
toddouska	0:5045d2638c29	1697
toddouska	0:5045d2638c29	1698	/* init M array */
toddouska	0:5045d2638c29	1699	/* init first cell */
toddouska	0:5045d2638c29	1700	if ((err = mp_init(&M[1])) != MP_OKAY) {
toddouska	0:5045d2638c29	1701	return err;
toddouska	0:5045d2638c29	1702	}
toddouska	0:5045d2638c29	1703
toddouska	0:5045d2638c29	1704	/* now init the second half of the array */
toddouska	0:5045d2638c29	1705	for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
toddouska	0:5045d2638c29	1706	if ((err = mp_init(&M[x])) != MP_OKAY) {
toddouska	0:5045d2638c29	1707	for (y = 1<<(winsize-1); y < x; y++) {
toddouska	0:5045d2638c29	1708	mp_clear (&M[y]);
toddouska	0:5045d2638c29	1709	}
toddouska	0:5045d2638c29	1710	mp_clear(&M[1]);
toddouska	0:5045d2638c29	1711	return err;
toddouska	0:5045d2638c29	1712	}
toddouska	0:5045d2638c29	1713	}
toddouska	0:5045d2638c29	1714
toddouska	0:5045d2638c29	1715	/* determine and setup reduction code */
toddouska	0:5045d2638c29	1716	if (redmode == 0) {
toddouska	0:5045d2638c29	1717	#ifdef BN_MP_MONTGOMERY_SETUP_C
toddouska	0:5045d2638c29	1718	/* now setup montgomery */
toddouska	0:5045d2638c29	1719	if ((err = mp_montgomery_setup (P, &mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1720	goto LBL_M;
toddouska	0:5045d2638c29	1721	}
toddouska	0:5045d2638c29	1722	#else
toddouska	0:5045d2638c29	1723	err = MP_VAL;
toddouska	0:5045d2638c29	1724	goto LBL_M;
toddouska	0:5045d2638c29	1725	#endif
toddouska	0:5045d2638c29	1726
toddouska	0:5045d2638c29	1727	/* automatically pick the comba one if available (saves quite a few
toddouska	0:5045d2638c29	1728	calls/ifs) */
toddouska	0:5045d2638c29	1729	#ifdef BN_FAST_MP_MONTGOMERY_REDUCE_C
toddouska	0:5045d2638c29	1730	if (((P->used * 2 + 1) < MP_WARRAY) &&
toddouska	0:5045d2638c29	1731	P->used < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
toddouska	0:5045d2638c29	1732	redux = fast_mp_montgomery_reduce;
toddouska	0:5045d2638c29	1733	} else
toddouska	0:5045d2638c29	1734	#endif
toddouska	0:5045d2638c29	1735	{
toddouska	0:5045d2638c29	1736	#ifdef BN_MP_MONTGOMERY_REDUCE_C
toddouska	0:5045d2638c29	1737	/* use slower baseline Montgomery method */
toddouska	0:5045d2638c29	1738	redux = mp_montgomery_reduce;
toddouska	0:5045d2638c29	1739	#else
toddouska	0:5045d2638c29	1740	err = MP_VAL;
toddouska	0:5045d2638c29	1741	goto LBL_M;
toddouska	0:5045d2638c29	1742	#endif
toddouska	0:5045d2638c29	1743	}
toddouska	0:5045d2638c29	1744	} else if (redmode == 1) {
toddouska	0:5045d2638c29	1745	#if defined(BN_MP_DR_SETUP_C) && defined(BN_MP_DR_REDUCE_C)
toddouska	0:5045d2638c29	1746	/* setup DR reduction for moduli of the form B*k - b /
toddouska	0:5045d2638c29	1747	mp_dr_setup(P, &mp);
toddouska	0:5045d2638c29	1748	redux = mp_dr_reduce;
toddouska	0:5045d2638c29	1749	#else
toddouska	0:5045d2638c29	1750	err = MP_VAL;
toddouska	0:5045d2638c29	1751	goto LBL_M;
toddouska	0:5045d2638c29	1752	#endif
toddouska	0:5045d2638c29	1753	} else {
toddouska	0:5045d2638c29	1754	#if defined(BN_MP_REDUCE_2K_SETUP_C) && defined(BN_MP_REDUCE_2K_C)
toddouska	0:5045d2638c29	1755	/* setup DR reduction for moduli of the form 2*k - b /
toddouska	0:5045d2638c29	1756	if ((err = mp_reduce_2k_setup(P, &mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1757	goto LBL_M;
toddouska	0:5045d2638c29	1758	}
toddouska	0:5045d2638c29	1759	redux = mp_reduce_2k;
toddouska	0:5045d2638c29	1760	#else
toddouska	0:5045d2638c29	1761	err = MP_VAL;
toddouska	0:5045d2638c29	1762	goto LBL_M;
toddouska	0:5045d2638c29	1763	#endif
toddouska	0:5045d2638c29	1764	}
toddouska	0:5045d2638c29	1765
toddouska	0:5045d2638c29	1766	/* setup result */
toddouska	0:5045d2638c29	1767	if ((err = mp_init (&res)) != MP_OKAY) {
toddouska	0:5045d2638c29	1768	goto LBL_M;
toddouska	0:5045d2638c29	1769	}
toddouska	0:5045d2638c29	1770
toddouska	0:5045d2638c29	1771	/* create M table
toddouska	0:5045d2638c29	1772	*
toddouska	0:5045d2638c29	1773
toddouska	0:5045d2638c29	1774	*
toddouska	0:5045d2638c29	1775	* The first half of the table is not computed though accept for M[0] and M[1]
toddouska	0:5045d2638c29	1776	*/
toddouska	0:5045d2638c29	1777
toddouska	0:5045d2638c29	1778	if (redmode == 0) {
toddouska	0:5045d2638c29	1779	#ifdef BN_MP_MONTGOMERY_CALC_NORMALIZATION_C
toddouska	0:5045d2638c29	1780	/* now we need R mod m */
toddouska	0:5045d2638c29	1781	if ((err = mp_montgomery_calc_normalization (&res, P)) != MP_OKAY) {
toddouska	0:5045d2638c29	1782	goto LBL_RES;
toddouska	0:5045d2638c29	1783	}
toddouska	0:5045d2638c29	1784	#else
toddouska	0:5045d2638c29	1785	err = MP_VAL;
toddouska	0:5045d2638c29	1786	goto LBL_RES;
toddouska	0:5045d2638c29	1787	#endif
toddouska	0:5045d2638c29	1788
toddouska	0:5045d2638c29	1789	/* now set M[1] to G * R mod m */
toddouska	0:5045d2638c29	1790	if ((err = mp_mulmod (G, &res, P, &M[1])) != MP_OKAY) {
toddouska	0:5045d2638c29	1791	goto LBL_RES;
toddouska	0:5045d2638c29	1792	}
toddouska	0:5045d2638c29	1793	} else {
toddouska	0:5045d2638c29	1794	mp_set(&res, 1);
toddouska	0:5045d2638c29	1795	if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) {
toddouska	0:5045d2638c29	1796	goto LBL_RES;
toddouska	0:5045d2638c29	1797	}
toddouska	0:5045d2638c29	1798	}
toddouska	0:5045d2638c29	1799
toddouska	0:5045d2638c29	1800	/* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times*/
toddouska	0:5045d2638c29	1801	if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
toddouska	0:5045d2638c29	1802	goto LBL_RES;
toddouska	0:5045d2638c29	1803	}
toddouska	0:5045d2638c29	1804
toddouska	0:5045d2638c29	1805	for (x = 0; x < (winsize - 1); x++) {
toddouska	0:5045d2638c29	1806	if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
toddouska	0:5045d2638c29	1807	goto LBL_RES;
toddouska	0:5045d2638c29	1808	}
toddouska	0:5045d2638c29	1809	if ((err = redux (&M[1 << (winsize - 1)], P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1810	goto LBL_RES;
toddouska	0:5045d2638c29	1811	}
toddouska	0:5045d2638c29	1812	}
toddouska	0:5045d2638c29	1813
toddouska	0:5045d2638c29	1814	/* create upper table */
toddouska	0:5045d2638c29	1815	for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
toddouska	0:5045d2638c29	1816	if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
toddouska	0:5045d2638c29	1817	goto LBL_RES;
toddouska	0:5045d2638c29	1818	}
toddouska	0:5045d2638c29	1819	if ((err = redux (&M[x], P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1820	goto LBL_RES;
toddouska	0:5045d2638c29	1821	}
toddouska	0:5045d2638c29	1822	}
toddouska	0:5045d2638c29	1823
toddouska	0:5045d2638c29	1824	/* set initial mode and bit cnt */
toddouska	0:5045d2638c29	1825	mode = 0;
toddouska	0:5045d2638c29	1826	bitcnt = 1;
toddouska	0:5045d2638c29	1827	buf = 0;
toddouska	0:5045d2638c29	1828	digidx = X->used - 1;
toddouska	0:5045d2638c29	1829	bitcpy = 0;
toddouska	0:5045d2638c29	1830	bitbuf = 0;
toddouska	0:5045d2638c29	1831
toddouska	0:5045d2638c29	1832	for (;;) {
toddouska	0:5045d2638c29	1833	/* grab next digit as required */
toddouska	0:5045d2638c29	1834	if (--bitcnt == 0) {
toddouska	0:5045d2638c29	1835	/* if digidx == -1 we are out of digits so break */
toddouska	0:5045d2638c29	1836	if (digidx == -1) {
toddouska	0:5045d2638c29	1837	break;
toddouska	0:5045d2638c29	1838	}
toddouska	0:5045d2638c29	1839	/* read next digit and reset bitcnt */
toddouska	0:5045d2638c29	1840	buf = X->dp[digidx--];
toddouska	0:5045d2638c29	1841	bitcnt = (int)DIGIT_BIT;
toddouska	0:5045d2638c29	1842	}
toddouska	0:5045d2638c29	1843
toddouska	0:5045d2638c29	1844	/* grab the next msb from the exponent */
toddouska	0:5045d2638c29	1845	y = (mp_digit)(buf >> (DIGIT_BIT - 1)) & 1;
toddouska	0:5045d2638c29	1846	buf <<= (mp_digit)1;
toddouska	0:5045d2638c29	1847
toddouska	0:5045d2638c29	1848	/* if the bit is zero and mode == 0 then we ignore it
toddouska	0:5045d2638c29	1849	* These represent the leading zero bits before the first 1 bit
toddouska	0:5045d2638c29	1850	* in the exponent. Technically this opt is not required but it
toddouska	0:5045d2638c29	1851	* does lower the # of trivial squaring/reductions used
toddouska	0:5045d2638c29	1852	*/
toddouska	0:5045d2638c29	1853	if (mode == 0 && y == 0) {
toddouska	0:5045d2638c29	1854	continue;
toddouska	0:5045d2638c29	1855	}
toddouska	0:5045d2638c29	1856
toddouska	0:5045d2638c29	1857	/* if the bit is zero and mode == 1 then we square */
toddouska	0:5045d2638c29	1858	if (mode == 1 && y == 0) {
toddouska	0:5045d2638c29	1859	if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	1860	goto LBL_RES;
toddouska	0:5045d2638c29	1861	}
toddouska	0:5045d2638c29	1862	if ((err = redux (&res, P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1863	goto LBL_RES;
toddouska	0:5045d2638c29	1864	}
toddouska	0:5045d2638c29	1865	continue;
toddouska	0:5045d2638c29	1866	}
toddouska	0:5045d2638c29	1867
toddouska	0:5045d2638c29	1868	/* else we add it to the window */
toddouska	0:5045d2638c29	1869	bitbuf \|= (y << (winsize - ++bitcpy));
toddouska	0:5045d2638c29	1870	mode = 2;
toddouska	0:5045d2638c29	1871
toddouska	0:5045d2638c29	1872	if (bitcpy == winsize) {
toddouska	0:5045d2638c29	1873	/* ok window is filled so square as required and multiply */
toddouska	0:5045d2638c29	1874	/* square first */
toddouska	0:5045d2638c29	1875	for (x = 0; x < winsize; x++) {
toddouska	0:5045d2638c29	1876	if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	1877	goto LBL_RES;
toddouska	0:5045d2638c29	1878	}
toddouska	0:5045d2638c29	1879	if ((err = redux (&res, P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1880	goto LBL_RES;
toddouska	0:5045d2638c29	1881	}
toddouska	0:5045d2638c29	1882	}
toddouska	0:5045d2638c29	1883
toddouska	0:5045d2638c29	1884	/* then multiply */
toddouska	0:5045d2638c29	1885	if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	1886	goto LBL_RES;
toddouska	0:5045d2638c29	1887	}
toddouska	0:5045d2638c29	1888	if ((err = redux (&res, P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1889	goto LBL_RES;
toddouska	0:5045d2638c29	1890	}
toddouska	0:5045d2638c29	1891
toddouska	0:5045d2638c29	1892	/* empty window and reset */
toddouska	0:5045d2638c29	1893	bitcpy = 0;
toddouska	0:5045d2638c29	1894	bitbuf = 0;
toddouska	0:5045d2638c29	1895	mode = 1;
toddouska	0:5045d2638c29	1896	}
toddouska	0:5045d2638c29	1897	}
toddouska	0:5045d2638c29	1898
toddouska	0:5045d2638c29	1899	/* if bits remain then square/multiply */
toddouska	0:5045d2638c29	1900	if (mode == 2 && bitcpy > 0) {
toddouska	0:5045d2638c29	1901	/* square then multiply if the bit is set */
toddouska	0:5045d2638c29	1902	for (x = 0; x < bitcpy; x++) {
toddouska	0:5045d2638c29	1903	if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	1904	goto LBL_RES;
toddouska	0:5045d2638c29	1905	}
toddouska	0:5045d2638c29	1906	if ((err = redux (&res, P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1907	goto LBL_RES;
toddouska	0:5045d2638c29	1908	}
toddouska	0:5045d2638c29	1909
toddouska	0:5045d2638c29	1910	/* get next bit of the window */
toddouska	0:5045d2638c29	1911	bitbuf <<= 1;
toddouska	0:5045d2638c29	1912	if ((bitbuf & (1 << winsize)) != 0) {
toddouska	0:5045d2638c29	1913	/* then multiply */
toddouska	0:5045d2638c29	1914	if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	1915	goto LBL_RES;
toddouska	0:5045d2638c29	1916	}
toddouska	0:5045d2638c29	1917	if ((err = redux (&res, P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1918	goto LBL_RES;
toddouska	0:5045d2638c29	1919	}
toddouska	0:5045d2638c29	1920	}
toddouska	0:5045d2638c29	1921	}
toddouska	0:5045d2638c29	1922	}
toddouska	0:5045d2638c29	1923
toddouska	0:5045d2638c29	1924	if (redmode == 0) {
toddouska	0:5045d2638c29	1925	/* fixup result if Montgomery reduction is used
toddouska	0:5045d2638c29	1926	* recall that any value in a Montgomery system is
toddouska	0:5045d2638c29	1927	* actually multiplied by R mod n. So we have
toddouska	0:5045d2638c29	1928	* to reduce one more time to cancel out the factor
toddouska	0:5045d2638c29	1929	* of R.
toddouska	0:5045d2638c29	1930	*/
toddouska	0:5045d2638c29	1931	if ((err = redux(&res, P, mp)) != MP_OKAY) {
toddouska	0:5045d2638c29	1932	goto LBL_RES;
toddouska	0:5045d2638c29	1933	}
toddouska	0:5045d2638c29	1934	}
toddouska	0:5045d2638c29	1935
toddouska	0:5045d2638c29	1936	/* swap res with Y */
toddouska	0:5045d2638c29	1937	mp_exch (&res, Y);
toddouska	0:5045d2638c29	1938	err = MP_OKAY;
toddouska	0:5045d2638c29	1939	LBL_RES:mp_clear (&res);
toddouska	0:5045d2638c29	1940	LBL_M:
toddouska	0:5045d2638c29	1941	mp_clear(&M[1]);
toddouska	0:5045d2638c29	1942	for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
toddouska	0:5045d2638c29	1943	mp_clear (&M[x]);
toddouska	0:5045d2638c29	1944	}
toddouska	0:5045d2638c29	1945	return err;
toddouska	0:5045d2638c29	1946	}
toddouska	0:5045d2638c29	1947
toddouska	0:5045d2638c29	1948
toddouska	0:5045d2638c29	1949	/* setups the montgomery reduction stuff */
toddouska	0:5045d2638c29	1950	int
toddouska	0:5045d2638c29	1951	mp_montgomery_setup (mp_int * n, mp_digit * rho)
toddouska	0:5045d2638c29	1952	{
toddouska	0:5045d2638c29	1953	mp_digit x, b;
toddouska	0:5045d2638c29	1954
toddouska	0:5045d2638c29	1955	/* fast inversion mod 2**k
toddouska	0:5045d2638c29	1956	*
toddouska	0:5045d2638c29	1957	* Based on the fact that
toddouska	0:5045d2638c29	1958	*
toddouska	0:5045d2638c29	1959	* XA = 1 (mod 2n) => (X(2-XA)) A = 1 (mod 22n)
toddouska	0:5045d2638c29	1960	* => 2XA - XXA*A = 1
toddouska	0:5045d2638c29	1961	* => 2*(1) - (1) = 1
toddouska	0:5045d2638c29	1962	*/
toddouska	0:5045d2638c29	1963	b = n->dp[0];
toddouska	0:5045d2638c29	1964
toddouska	0:5045d2638c29	1965	if ((b & 1) == 0) {
toddouska	0:5045d2638c29	1966	return MP_VAL;
toddouska	0:5045d2638c29	1967	}
toddouska	0:5045d2638c29	1968
toddouska	0:5045d2638c29	1969	x = (((b + 2) & 4) << 1) + b; /* here xa==1 mod 24 /
toddouska	0:5045d2638c29	1970	x = 2 - b x; /* here xa==1 mod 28 /
toddouska	0:5045d2638c29	1971	#if !defined(MP_8BIT)
toddouska	0:5045d2638c29	1972	x = 2 - b x; /* here xa==1 mod 216 /
toddouska	0:5045d2638c29	1973	#endif
toddouska	0:5045d2638c29	1974	#if defined(MP_64BIT) \|\| !(defined(MP_8BIT) \|\| defined(MP_16BIT))
toddouska	0:5045d2638c29	1975	x = 2 - b x; /* here xa==1 mod 232 /
toddouska	0:5045d2638c29	1976	#endif
toddouska	0:5045d2638c29	1977	#ifdef MP_64BIT
toddouska	0:5045d2638c29	1978	x = 2 - b x; /* here xa==1 mod 264 /
toddouska	0:5045d2638c29	1979	#endif
toddouska	0:5045d2638c29	1980
toddouska	0:5045d2638c29	1981	/* rho = -1/m mod b */
toddouska	0:5045d2638c29	1982	/* TAO, switched mp_word casts to mp_digit to shut up compiler */
toddouska	0:5045d2638c29	1983	*rho = (((mp_digit)1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
toddouska	0:5045d2638c29	1984
toddouska	0:5045d2638c29	1985	return MP_OKAY;
toddouska	0:5045d2638c29	1986	}
toddouska	0:5045d2638c29	1987
toddouska	0:5045d2638c29	1988
toddouska	0:5045d2638c29	1989	/* computes xR**-1 == x (mod N) via Montgomery Reduction
toddouska	0:5045d2638c29	1990	*
toddouska	0:5045d2638c29	1991	* This is an optimized implementation of montgomery_reduce
toddouska	0:5045d2638c29	1992	* which uses the comba method to quickly calculate the columns of the
toddouska	0:5045d2638c29	1993	* reduction.
toddouska	0:5045d2638c29	1994	*
toddouska	0:5045d2638c29	1995	* Based on Algorithm 14.32 on pp.601 of HAC.
toddouska	0:5045d2638c29	1996	*/
toddouska	0:5045d2638c29	1997	int fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
toddouska	0:5045d2638c29	1998	{
toddouska	0:5045d2638c29	1999	int ix, res, olduse;
toddouska	0:5045d2638c29	2000	mp_word W[MP_WARRAY];
toddouska	0:5045d2638c29	2001
toddouska	0:5045d2638c29	2002	/* get old used count */
toddouska	0:5045d2638c29	2003	olduse = x->used;
toddouska	0:5045d2638c29	2004
toddouska	0:5045d2638c29	2005	/* grow a as required */
toddouska	0:5045d2638c29	2006	if (x->alloc < n->used + 1) {
toddouska	0:5045d2638c29	2007	if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	2008	return res;
toddouska	0:5045d2638c29	2009	}
toddouska	0:5045d2638c29	2010	}
toddouska	0:5045d2638c29	2011
toddouska	0:5045d2638c29	2012	/* first we have to get the digits of the input into
toddouska	0:5045d2638c29	2013	* an array of double precision words W[...]
toddouska	0:5045d2638c29	2014	*/
toddouska	0:5045d2638c29	2015	{
toddouska	0:5045d2638c29	2016	register mp_word *_W;
toddouska	0:5045d2638c29	2017	register mp_digit *tmpx;
toddouska	0:5045d2638c29	2018
toddouska	0:5045d2638c29	2019	/* alias for the W[] array */
toddouska	0:5045d2638c29	2020	_W = W;
toddouska	0:5045d2638c29	2021
toddouska	0:5045d2638c29	2022	/* alias for the digits of x*/
toddouska	0:5045d2638c29	2023	tmpx = x->dp;
toddouska	0:5045d2638c29	2024
toddouska	0:5045d2638c29	2025	/* copy the digits of a into W[0..a->used-1] */
toddouska	0:5045d2638c29	2026	for (ix = 0; ix < x->used; ix++) {
toddouska	0:5045d2638c29	2027	_W++ = tmpx++;
toddouska	0:5045d2638c29	2028	}
toddouska	0:5045d2638c29	2029
toddouska	0:5045d2638c29	2030	/* zero the high words of W[a->used..m->used2] /
toddouska	0:5045d2638c29	2031	for (; ix < n->used * 2 + 1; ix++) {
toddouska	0:5045d2638c29	2032	*_W++ = 0;
toddouska	0:5045d2638c29	2033	}
toddouska	0:5045d2638c29	2034	}
toddouska	0:5045d2638c29	2035
toddouska	0:5045d2638c29	2036	/* now we proceed to zero successive digits
toddouska	0:5045d2638c29	2037	* from the least significant upwards
toddouska	0:5045d2638c29	2038	*/
toddouska	0:5045d2638c29	2039	for (ix = 0; ix < n->used; ix++) {
toddouska	0:5045d2638c29	2040	/* mu = ai * m' mod b
toddouska	0:5045d2638c29	2041	*
toddouska	0:5045d2638c29	2042	* We avoid a double precision multiplication (which isn't required)
toddouska	0:5045d2638c29	2043	* by casting the value down to a mp_digit. Note this requires
toddouska	0:5045d2638c29	2044	* that W[ix-1] have the carry cleared (see after the inner loop)
toddouska	0:5045d2638c29	2045	*/
toddouska	0:5045d2638c29	2046	register mp_digit mu;
toddouska	0:5045d2638c29	2047	mu = (mp_digit) (((W[ix] & MP_MASK) * rho) & MP_MASK);
toddouska	0:5045d2638c29	2048
toddouska	0:5045d2638c29	2049	/* a = a + mu * m * b**i
toddouska	0:5045d2638c29	2050	*
toddouska	0:5045d2638c29	2051	* This is computed in place and on the fly. The multiplication
toddouska	0:5045d2638c29	2052	* by b**i is handled by offseting which columns the results
toddouska	0:5045d2638c29	2053	* are added to.
toddouska	0:5045d2638c29	2054	*
toddouska	0:5045d2638c29	2055	* Note the comba method normally doesn't handle carries in the
toddouska	0:5045d2638c29	2056	* inner loop In this case we fix the carry from the previous
toddouska	0:5045d2638c29	2057	* column since the Montgomery reduction requires digits of the
toddouska	0:5045d2638c29	2058	* result (so far) [see above] to work. This is
toddouska	0:5045d2638c29	2059	* handled by fixing up one carry after the inner loop. The
toddouska	0:5045d2638c29	2060	* carry fixups are done in order so after these loops the
toddouska	0:5045d2638c29	2061	* first m->used words of W[] have the carries fixed
toddouska	0:5045d2638c29	2062	*/
toddouska	0:5045d2638c29	2063	{
toddouska	0:5045d2638c29	2064	register int iy;
toddouska	0:5045d2638c29	2065	register mp_digit *tmpn;
toddouska	0:5045d2638c29	2066	register mp_word *_W;
toddouska	0:5045d2638c29	2067
toddouska	0:5045d2638c29	2068	/* alias for the digits of the modulus */
toddouska	0:5045d2638c29	2069	tmpn = n->dp;
toddouska	0:5045d2638c29	2070
toddouska	0:5045d2638c29	2071	/* Alias for the columns set by an offset of ix */
toddouska	0:5045d2638c29	2072	_W = W + ix;
toddouska	0:5045d2638c29	2073
toddouska	0:5045d2638c29	2074	/* inner loop */
toddouska	0:5045d2638c29	2075	for (iy = 0; iy < n->used; iy++) {
toddouska	0:5045d2638c29	2076	_W++ += ((mp_word)mu) ((mp_word)*tmpn++);
toddouska	0:5045d2638c29	2077	}
toddouska	0:5045d2638c29	2078	}
toddouska	0:5045d2638c29	2079
toddouska	0:5045d2638c29	2080	/* now fix carry for next digit, W[ix+1] */
toddouska	0:5045d2638c29	2081	W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT);
toddouska	0:5045d2638c29	2082	}
toddouska	0:5045d2638c29	2083
toddouska	0:5045d2638c29	2084	/* now we have to propagate the carries and
toddouska	0:5045d2638c29	2085	* shift the words downward [all those least
toddouska	0:5045d2638c29	2086	* significant digits we zeroed].
toddouska	0:5045d2638c29	2087	*/
toddouska	0:5045d2638c29	2088	{
toddouska	0:5045d2638c29	2089	register mp_digit *tmpx;
toddouska	0:5045d2638c29	2090	register mp_word _W, _W1;
toddouska	0:5045d2638c29	2091
toddouska	0:5045d2638c29	2092	/* nox fix rest of carries */
toddouska	0:5045d2638c29	2093
toddouska	0:5045d2638c29	2094	/* alias for current word */
toddouska	0:5045d2638c29	2095	_W1 = W + ix;
toddouska	0:5045d2638c29	2096
toddouska	0:5045d2638c29	2097	/* alias for next word, where the carry goes */
toddouska	0:5045d2638c29	2098	_W = W + ++ix;
toddouska	0:5045d2638c29	2099
toddouska	0:5045d2638c29	2100	for (; ix <= n->used * 2 + 1; ix++) {
toddouska	0:5045d2638c29	2101	_W++ += _W1++ >> ((mp_word) DIGIT_BIT);
toddouska	0:5045d2638c29	2102	}
toddouska	0:5045d2638c29	2103
toddouska	0:5045d2638c29	2104	/* copy out, A = A/b**n
toddouska	0:5045d2638c29	2105	*
toddouska	0:5045d2638c29	2106	* The result is A/b**n but instead of converting from an
toddouska	0:5045d2638c29	2107	* array of mp_word to mp_digit than calling mp_rshd
toddouska	0:5045d2638c29	2108	* we just copy them in the right order
toddouska	0:5045d2638c29	2109	*/
toddouska	0:5045d2638c29	2110
toddouska	0:5045d2638c29	2111	/* alias for destination word */
toddouska	0:5045d2638c29	2112	tmpx = x->dp;
toddouska	0:5045d2638c29	2113
toddouska	0:5045d2638c29	2114	/* alias for shifted double precision result */
toddouska	0:5045d2638c29	2115	_W = W + n->used;
toddouska	0:5045d2638c29	2116
toddouska	0:5045d2638c29	2117	for (ix = 0; ix < n->used + 1; ix++) {
toddouska	0:5045d2638c29	2118	tmpx++ = (mp_digit)(_W++ & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	2119	}
toddouska	0:5045d2638c29	2120
toddouska	0:5045d2638c29	2121	/* zero oldused digits, if the input a was larger than
toddouska	0:5045d2638c29	2122	* m->used+1 we'll have to clear the digits
toddouska	0:5045d2638c29	2123	*/
toddouska	0:5045d2638c29	2124	for (; ix < olduse; ix++) {
toddouska	0:5045d2638c29	2125	*tmpx++ = 0;
toddouska	0:5045d2638c29	2126	}
toddouska	0:5045d2638c29	2127	}
toddouska	0:5045d2638c29	2128
toddouska	0:5045d2638c29	2129	/* set the max used and clamp */
toddouska	0:5045d2638c29	2130	x->used = n->used + 1;
toddouska	0:5045d2638c29	2131	mp_clamp (x);
toddouska	0:5045d2638c29	2132
toddouska	0:5045d2638c29	2133	/* if A >= m then A = A - m */
toddouska	0:5045d2638c29	2134	if (mp_cmp_mag (x, n) != MP_LT) {
toddouska	0:5045d2638c29	2135	return s_mp_sub (x, n, x);
toddouska	0:5045d2638c29	2136	}
toddouska	0:5045d2638c29	2137	return MP_OKAY;
toddouska	0:5045d2638c29	2138	}
toddouska	0:5045d2638c29	2139
toddouska	0:5045d2638c29	2140
toddouska	0:5045d2638c29	2141	/* computes xR*-1 == x (mod N) via Montgomery Reduction /
toddouska	0:5045d2638c29	2142	int
toddouska	0:5045d2638c29	2143	mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
toddouska	0:5045d2638c29	2144	{
toddouska	0:5045d2638c29	2145	int ix, res, digs;
toddouska	0:5045d2638c29	2146	mp_digit mu;
toddouska	0:5045d2638c29	2147
toddouska	0:5045d2638c29	2148	/* can the fast reduction [comba] method be used?
toddouska	0:5045d2638c29	2149	*
toddouska	0:5045d2638c29	2150	* Note that unlike in mul you're safely allowed less
toddouska	0:5045d2638c29	2151	* than the available columns [255 per default] since carries
toddouska	0:5045d2638c29	2152	* are fixed up in the inner loop.
toddouska	0:5045d2638c29	2153	*/
toddouska	0:5045d2638c29	2154	digs = n->used * 2 + 1;
toddouska	0:5045d2638c29	2155	if ((digs < MP_WARRAY) &&
toddouska	0:5045d2638c29	2156	n->used <
toddouska	0:5045d2638c29	2157	(1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
toddouska	0:5045d2638c29	2158	return fast_mp_montgomery_reduce (x, n, rho);
toddouska	0:5045d2638c29	2159	}
toddouska	0:5045d2638c29	2160
toddouska	0:5045d2638c29	2161	/* grow the input as required */
toddouska	0:5045d2638c29	2162	if (x->alloc < digs) {
toddouska	0:5045d2638c29	2163	if ((res = mp_grow (x, digs)) != MP_OKAY) {
toddouska	0:5045d2638c29	2164	return res;
toddouska	0:5045d2638c29	2165	}
toddouska	0:5045d2638c29	2166	}
toddouska	0:5045d2638c29	2167	x->used = digs;
toddouska	0:5045d2638c29	2168
toddouska	0:5045d2638c29	2169	for (ix = 0; ix < n->used; ix++) {
toddouska	0:5045d2638c29	2170	/* mu = ai * rho mod b
toddouska	0:5045d2638c29	2171	*
toddouska	0:5045d2638c29	2172	* The value of rho must be precalculated via
toddouska	0:5045d2638c29	2173	* montgomery_setup() such that
toddouska	0:5045d2638c29	2174	* it equals -1/n0 mod b this allows the
toddouska	0:5045d2638c29	2175	* following inner loop to reduce the
toddouska	0:5045d2638c29	2176	* input one digit at a time
toddouska	0:5045d2638c29	2177	*/
toddouska	0:5045d2638c29	2178	mu = (mp_digit) (((mp_word)x->dp[ix]) * ((mp_word)rho) & MP_MASK);
toddouska	0:5045d2638c29	2179
toddouska	0:5045d2638c29	2180	/* a = a + mu * m * b*i /
toddouska	0:5045d2638c29	2181	{
toddouska	0:5045d2638c29	2182	register int iy;
toddouska	0:5045d2638c29	2183	register mp_digit tmpn, tmpx, u;
toddouska	0:5045d2638c29	2184	register mp_word r;
toddouska	0:5045d2638c29	2185
toddouska	0:5045d2638c29	2186	/* alias for digits of the modulus */
toddouska	0:5045d2638c29	2187	tmpn = n->dp;
toddouska	0:5045d2638c29	2188
toddouska	0:5045d2638c29	2189	/* alias for the digits of x [the input] */
toddouska	0:5045d2638c29	2190	tmpx = x->dp + ix;
toddouska	0:5045d2638c29	2191
toddouska	0:5045d2638c29	2192	/* set the carry to zero */
toddouska	0:5045d2638c29	2193	u = 0;
toddouska	0:5045d2638c29	2194
toddouska	0:5045d2638c29	2195	/* Multiply and add in place */
toddouska	0:5045d2638c29	2196	for (iy = 0; iy < n->used; iy++) {
toddouska	0:5045d2638c29	2197	/* compute product and sum */
toddouska	0:5045d2638c29	2198	r = ((mp_word)mu) * ((mp_word)*tmpn++) +
toddouska	0:5045d2638c29	2199	((mp_word) u) + ((mp_word) * tmpx);
toddouska	0:5045d2638c29	2200
toddouska	0:5045d2638c29	2201	/* get carry */
toddouska	0:5045d2638c29	2202	u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
toddouska	0:5045d2638c29	2203
toddouska	0:5045d2638c29	2204	/* fix digit */
toddouska	0:5045d2638c29	2205	*tmpx++ = (mp_digit)(r & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	2206	}
toddouska	0:5045d2638c29	2207	/* At this point the ix'th digit of x should be zero */
toddouska	0:5045d2638c29	2208
toddouska	0:5045d2638c29	2209
toddouska	0:5045d2638c29	2210	/* propagate carries upwards as required*/
toddouska	0:5045d2638c29	2211	while (u) {
toddouska	0:5045d2638c29	2212	*tmpx += u;
toddouska	0:5045d2638c29	2213	u = *tmpx >> DIGIT_BIT;
toddouska	0:5045d2638c29	2214	*tmpx++ &= MP_MASK;
toddouska	0:5045d2638c29	2215	}
toddouska	0:5045d2638c29	2216	}
toddouska	0:5045d2638c29	2217	}
toddouska	0:5045d2638c29	2218
toddouska	0:5045d2638c29	2219	/* at this point the n.used'th least
toddouska	0:5045d2638c29	2220	* significant digits of x are all zero
toddouska	0:5045d2638c29	2221	* which means we can shift x to the
toddouska	0:5045d2638c29	2222	* right by n.used digits and the
toddouska	0:5045d2638c29	2223	* residue is unchanged.
toddouska	0:5045d2638c29	2224	*/
toddouska	0:5045d2638c29	2225
toddouska	0:5045d2638c29	2226	/* x = x/b*n.used /
toddouska	0:5045d2638c29	2227	mp_clamp(x);
toddouska	0:5045d2638c29	2228	mp_rshd (x, n->used);
toddouska	0:5045d2638c29	2229
toddouska	0:5045d2638c29	2230	/* if x >= n then x = x - n */
toddouska	0:5045d2638c29	2231	if (mp_cmp_mag (x, n) != MP_LT) {
toddouska	0:5045d2638c29	2232	return s_mp_sub (x, n, x);
toddouska	0:5045d2638c29	2233	}
toddouska	0:5045d2638c29	2234
toddouska	0:5045d2638c29	2235	return MP_OKAY;
toddouska	0:5045d2638c29	2236	}
toddouska	0:5045d2638c29	2237
toddouska	0:5045d2638c29	2238
toddouska	0:5045d2638c29	2239	/* determines the setup value */
toddouska	0:5045d2638c29	2240	void mp_dr_setup(mp_int a, mp_digit d)
toddouska	0:5045d2638c29	2241	{
toddouska	0:5045d2638c29	2242	/* the casts are required if DIGIT_BIT is one less than
toddouska	0:5045d2638c29	2243	* the number of bits in a mp_digit [e.g. DIGIT_BIT==31]
toddouska	0:5045d2638c29	2244	*/
toddouska	0:5045d2638c29	2245	*d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) -
toddouska	0:5045d2638c29	2246	((mp_word)a->dp[0]));
toddouska	0:5045d2638c29	2247	}
toddouska	0:5045d2638c29	2248
toddouska	0:5045d2638c29	2249
toddouska	0:5045d2638c29	2250	/* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
toddouska	0:5045d2638c29	2251	*
toddouska	0:5045d2638c29	2252	* Based on algorithm from the paper
toddouska	0:5045d2638c29	2253	*
toddouska	0:5045d2638c29	2254	* "Generating Efficient Primes for Discrete Log Cryptosystems"
toddouska	0:5045d2638c29	2255	* Chae Hoon Lim, Pil Joong Lee,
toddouska	0:5045d2638c29	2256	* POSTECH Information Research Laboratories
toddouska	0:5045d2638c29	2257	*
toddouska	0:5045d2638c29	2258	* The modulus must be of a special format [see manual]
toddouska	0:5045d2638c29	2259	*
toddouska	0:5045d2638c29	2260	* Has been modified to use algorithm 7.10 from the LTM book instead
toddouska	0:5045d2638c29	2261	*
toddouska	0:5045d2638c29	2262	* Input x must be in the range 0 <= x <= (n-1)**2
toddouska	0:5045d2638c29	2263	*/
toddouska	0:5045d2638c29	2264	int
toddouska	0:5045d2638c29	2265	mp_dr_reduce (mp_int * x, mp_int * n, mp_digit k)
toddouska	0:5045d2638c29	2266	{
toddouska	0:5045d2638c29	2267	int err, i, m;
toddouska	0:5045d2638c29	2268	mp_word r;
toddouska	0:5045d2638c29	2269	mp_digit mu, tmpx1, tmpx2;
toddouska	0:5045d2638c29	2270
toddouska	0:5045d2638c29	2271	/* m = digits in modulus */
toddouska	0:5045d2638c29	2272	m = n->used;
toddouska	0:5045d2638c29	2273
toddouska	0:5045d2638c29	2274	/* ensure that "x" has at least 2m digits */
toddouska	0:5045d2638c29	2275	if (x->alloc < m + m) {
toddouska	0:5045d2638c29	2276	if ((err = mp_grow (x, m + m)) != MP_OKAY) {
toddouska	0:5045d2638c29	2277	return err;
toddouska	0:5045d2638c29	2278	}
toddouska	0:5045d2638c29	2279	}
toddouska	0:5045d2638c29	2280
toddouska	0:5045d2638c29	2281	/* top of loop, this is where the code resumes if
toddouska	0:5045d2638c29	2282	* another reduction pass is required.
toddouska	0:5045d2638c29	2283	*/
toddouska	0:5045d2638c29	2284	top:
toddouska	0:5045d2638c29	2285	/* aliases for digits */
toddouska	0:5045d2638c29	2286	/* alias for lower half of x */
toddouska	0:5045d2638c29	2287	tmpx1 = x->dp;
toddouska	0:5045d2638c29	2288
toddouska	0:5045d2638c29	2289	/* alias for upper half of x, or x/B*m /
toddouska	0:5045d2638c29	2290	tmpx2 = x->dp + m;
toddouska	0:5045d2638c29	2291
toddouska	0:5045d2638c29	2292	/* set carry to zero */
toddouska	0:5045d2638c29	2293	mu = 0;
toddouska	0:5045d2638c29	2294
toddouska	0:5045d2638c29	2295	/* compute (x mod B*m) + k [x/B*m] inline and inplace /
toddouska	0:5045d2638c29	2296	for (i = 0; i < m; i++) {
toddouska	0:5045d2638c29	2297	r = ((mp_word)tmpx2++) ((mp_word)k) + *tmpx1 + mu;
toddouska	0:5045d2638c29	2298	*tmpx1++ = (mp_digit)(r & MP_MASK);
toddouska	0:5045d2638c29	2299	mu = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
toddouska	0:5045d2638c29	2300	}
toddouska	0:5045d2638c29	2301
toddouska	0:5045d2638c29	2302	/* set final carry */
toddouska	0:5045d2638c29	2303	*tmpx1++ = mu;
toddouska	0:5045d2638c29	2304
toddouska	0:5045d2638c29	2305	/* zero words above m */
toddouska	0:5045d2638c29	2306	for (i = m + 1; i < x->used; i++) {
toddouska	0:5045d2638c29	2307	*tmpx1++ = 0;
toddouska	0:5045d2638c29	2308	}
toddouska	0:5045d2638c29	2309
toddouska	0:5045d2638c29	2310	/* clamp, sub and return */
toddouska	0:5045d2638c29	2311	mp_clamp (x);
toddouska	0:5045d2638c29	2312
toddouska	0:5045d2638c29	2313	/* if x >= n then subtract and reduce again
toddouska	0:5045d2638c29	2314	* Each successive "recursion" makes the input smaller and smaller.
toddouska	0:5045d2638c29	2315	*/
toddouska	0:5045d2638c29	2316	if (mp_cmp_mag (x, n) != MP_LT) {
toddouska	0:5045d2638c29	2317	s_mp_sub(x, n, x);
toddouska	0:5045d2638c29	2318	goto top;
toddouska	0:5045d2638c29	2319	}
toddouska	0:5045d2638c29	2320	return MP_OKAY;
toddouska	0:5045d2638c29	2321	}
toddouska	0:5045d2638c29	2322
toddouska	0:5045d2638c29	2323
toddouska	0:5045d2638c29	2324	/* reduces a modulo n where n is of the form 2*p - d /
toddouska	0:5045d2638c29	2325	int mp_reduce_2k(mp_int a, mp_int n, mp_digit d)
toddouska	0:5045d2638c29	2326	{
toddouska	0:5045d2638c29	2327	mp_int q;
toddouska	0:5045d2638c29	2328	int p, res;
toddouska	0:5045d2638c29	2329
toddouska	0:5045d2638c29	2330	if ((res = mp_init(&q)) != MP_OKAY) {
toddouska	0:5045d2638c29	2331	return res;
toddouska	0:5045d2638c29	2332	}
toddouska	0:5045d2638c29	2333
toddouska	0:5045d2638c29	2334	p = mp_count_bits(n);
toddouska	0:5045d2638c29	2335	top:
toddouska	0:5045d2638c29	2336	/* q = a/2p, a = a mod 2p */
toddouska	0:5045d2638c29	2337	if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	2338	goto ERR;
toddouska	0:5045d2638c29	2339	}
toddouska	0:5045d2638c29	2340
toddouska	0:5045d2638c29	2341	if (d != 1) {
toddouska	0:5045d2638c29	2342	/* q = q * d */
toddouska	0:5045d2638c29	2343	if ((res = mp_mul_d(&q, d, &q)) != MP_OKAY) {
toddouska	0:5045d2638c29	2344	goto ERR;
toddouska	0:5045d2638c29	2345	}
toddouska	0:5045d2638c29	2346	}
toddouska	0:5045d2638c29	2347
toddouska	0:5045d2638c29	2348	/* a = a + q */
toddouska	0:5045d2638c29	2349	if ((res = s_mp_add(a, &q, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	2350	goto ERR;
toddouska	0:5045d2638c29	2351	}
toddouska	0:5045d2638c29	2352
toddouska	0:5045d2638c29	2353	if (mp_cmp_mag(a, n) != MP_LT) {
toddouska	0:5045d2638c29	2354	s_mp_sub(a, n, a);
toddouska	0:5045d2638c29	2355	goto top;
toddouska	0:5045d2638c29	2356	}
toddouska	0:5045d2638c29	2357
toddouska	0:5045d2638c29	2358	ERR:
toddouska	0:5045d2638c29	2359	mp_clear(&q);
toddouska	0:5045d2638c29	2360	return res;
toddouska	0:5045d2638c29	2361	}
toddouska	0:5045d2638c29	2362
toddouska	0:5045d2638c29	2363
toddouska	0:5045d2638c29	2364	/* determines the setup value */
toddouska	0:5045d2638c29	2365	int mp_reduce_2k_setup(mp_int a, mp_digit d)
toddouska	0:5045d2638c29	2366	{
toddouska	0:5045d2638c29	2367	int res, p;
toddouska	0:5045d2638c29	2368	mp_int tmp;
toddouska	0:5045d2638c29	2369
toddouska	0:5045d2638c29	2370	if ((res = mp_init(&tmp)) != MP_OKAY) {
toddouska	0:5045d2638c29	2371	return res;
toddouska	0:5045d2638c29	2372	}
toddouska	0:5045d2638c29	2373
toddouska	0:5045d2638c29	2374	p = mp_count_bits(a);
toddouska	0:5045d2638c29	2375	if ((res = mp_2expt(&tmp, p)) != MP_OKAY) {
toddouska	0:5045d2638c29	2376	mp_clear(&tmp);
toddouska	0:5045d2638c29	2377	return res;
toddouska	0:5045d2638c29	2378	}
toddouska	0:5045d2638c29	2379
toddouska	0:5045d2638c29	2380	if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) {
toddouska	0:5045d2638c29	2381	mp_clear(&tmp);
toddouska	0:5045d2638c29	2382	return res;
toddouska	0:5045d2638c29	2383	}
toddouska	0:5045d2638c29	2384
toddouska	0:5045d2638c29	2385	*d = tmp.dp[0];
toddouska	0:5045d2638c29	2386	mp_clear(&tmp);
toddouska	0:5045d2638c29	2387	return MP_OKAY;
toddouska	0:5045d2638c29	2388	}
toddouska	0:5045d2638c29	2389
toddouska	0:5045d2638c29	2390
toddouska	0:5045d2638c29	2391	/* computes a = 2**b
toddouska	0:5045d2638c29	2392	*
toddouska	0:5045d2638c29	2393	* Simple algorithm which zeroes the int, grows it then just sets one bit
toddouska	0:5045d2638c29	2394	* as required.
toddouska	0:5045d2638c29	2395	*/
toddouska	0:5045d2638c29	2396	int
toddouska	0:5045d2638c29	2397	mp_2expt (mp_int * a, int b)
toddouska	0:5045d2638c29	2398	{
toddouska	0:5045d2638c29	2399	int res;
toddouska	0:5045d2638c29	2400
toddouska	0:5045d2638c29	2401	/* zero a as per default */
toddouska	0:5045d2638c29	2402	mp_zero (a);
toddouska	0:5045d2638c29	2403
toddouska	0:5045d2638c29	2404	/* grow a to accomodate the single bit */
toddouska	0:5045d2638c29	2405	if ((res = mp_grow (a, b / DIGIT_BIT + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	2406	return res;
toddouska	0:5045d2638c29	2407	}
toddouska	0:5045d2638c29	2408
toddouska	0:5045d2638c29	2409	/* set the used count of where the bit will go */
toddouska	0:5045d2638c29	2410	a->used = b / DIGIT_BIT + 1;
toddouska	0:5045d2638c29	2411
toddouska	0:5045d2638c29	2412	/* put the single bit in its place */
toddouska	0:5045d2638c29	2413	a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT);
toddouska	0:5045d2638c29	2414
toddouska	0:5045d2638c29	2415	return MP_OKAY;
toddouska	0:5045d2638c29	2416	}
toddouska	0:5045d2638c29	2417
toddouska	0:5045d2638c29	2418
toddouska	0:5045d2638c29	2419	/* multiply by a digit */
toddouska	0:5045d2638c29	2420	int
toddouska	0:5045d2638c29	2421	mp_mul_d (mp_int * a, mp_digit b, mp_int * c)
toddouska	0:5045d2638c29	2422	{
toddouska	0:5045d2638c29	2423	mp_digit u, tmpa, tmpc;
toddouska	0:5045d2638c29	2424	mp_word r;
toddouska	0:5045d2638c29	2425	int ix, res, olduse;
toddouska	0:5045d2638c29	2426
toddouska	0:5045d2638c29	2427	/* make sure c is big enough to hold ab /
toddouska	0:5045d2638c29	2428	if (c->alloc < a->used + 1) {
toddouska	0:5045d2638c29	2429	if ((res = mp_grow (c, a->used + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	2430	return res;
toddouska	0:5045d2638c29	2431	}
toddouska	0:5045d2638c29	2432	}
toddouska	0:5045d2638c29	2433
toddouska	0:5045d2638c29	2434	/* get the original destinations used count */
toddouska	0:5045d2638c29	2435	olduse = c->used;
toddouska	0:5045d2638c29	2436
toddouska	0:5045d2638c29	2437	/* set the sign */
toddouska	0:5045d2638c29	2438	c->sign = a->sign;
toddouska	0:5045d2638c29	2439
toddouska	0:5045d2638c29	2440	/* alias for a->dp [source] */
toddouska	0:5045d2638c29	2441	tmpa = a->dp;
toddouska	0:5045d2638c29	2442
toddouska	0:5045d2638c29	2443	/* alias for c->dp [dest] */
toddouska	0:5045d2638c29	2444	tmpc = c->dp;
toddouska	0:5045d2638c29	2445
toddouska	0:5045d2638c29	2446	/* zero carry */
toddouska	0:5045d2638c29	2447	u = 0;
toddouska	0:5045d2638c29	2448
toddouska	0:5045d2638c29	2449	/* compute columns */
toddouska	0:5045d2638c29	2450	for (ix = 0; ix < a->used; ix++) {
toddouska	0:5045d2638c29	2451	/* compute product and carry sum for this term */
toddouska	0:5045d2638c29	2452	r = ((mp_word) u) + ((mp_word)tmpa++) ((mp_word)b);
toddouska	0:5045d2638c29	2453
toddouska	0:5045d2638c29	2454	/* mask off higher bits to get a single digit */
toddouska	0:5045d2638c29	2455	*tmpc++ = (mp_digit) (r & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	2456
toddouska	0:5045d2638c29	2457	/* send carry into next iteration */
toddouska	0:5045d2638c29	2458	u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
toddouska	0:5045d2638c29	2459	}
toddouska	0:5045d2638c29	2460
toddouska	0:5045d2638c29	2461	/* store final carry [if any] and increment ix offset */
toddouska	0:5045d2638c29	2462	*tmpc++ = u;
toddouska	0:5045d2638c29	2463	++ix;
toddouska	0:5045d2638c29	2464
toddouska	0:5045d2638c29	2465	/* now zero digits above the top */
toddouska	0:5045d2638c29	2466	while (ix++ < olduse) {
toddouska	0:5045d2638c29	2467	*tmpc++ = 0;
toddouska	0:5045d2638c29	2468	}
toddouska	0:5045d2638c29	2469
toddouska	0:5045d2638c29	2470	/* set used count */
toddouska	0:5045d2638c29	2471	c->used = a->used + 1;
toddouska	0:5045d2638c29	2472	mp_clamp(c);
toddouska	0:5045d2638c29	2473
toddouska	0:5045d2638c29	2474	return MP_OKAY;
toddouska	0:5045d2638c29	2475	}
toddouska	0:5045d2638c29	2476
toddouska	0:5045d2638c29	2477
toddouska	0:5045d2638c29	2478	/* d = a * b (mod c) */
toddouska	0:5045d2638c29	2479	int mp_mulmod (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
toddouska	0:5045d2638c29	2480	{
toddouska	0:5045d2638c29	2481	int res;
toddouska	0:5045d2638c29	2482	mp_int t;
toddouska	0:5045d2638c29	2483
toddouska	0:5045d2638c29	2484	if ((res = mp_init (&t)) != MP_OKAY) {
toddouska	0:5045d2638c29	2485	return res;
toddouska	0:5045d2638c29	2486	}
toddouska	0:5045d2638c29	2487
toddouska	0:5045d2638c29	2488	if ((res = mp_mul (a, b, &t)) != MP_OKAY) {
toddouska	0:5045d2638c29	2489	mp_clear (&t);
toddouska	0:5045d2638c29	2490	return res;
toddouska	0:5045d2638c29	2491	}
toddouska	0:5045d2638c29	2492	res = mp_mod (&t, c, d);
toddouska	0:5045d2638c29	2493	mp_clear (&t);
toddouska	0:5045d2638c29	2494	return res;
toddouska	0:5045d2638c29	2495	}
toddouska	0:5045d2638c29	2496
toddouska	0:5045d2638c29	2497
toddouska	0:5045d2638c29	2498	/* computes b = aa /
toddouska	0:5045d2638c29	2499	int
toddouska	0:5045d2638c29	2500	mp_sqr (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	2501	{
toddouska	0:5045d2638c29	2502	int res;
toddouska	0:5045d2638c29	2503
toddouska	0:5045d2638c29	2504	{
toddouska	0:5045d2638c29	2505	#ifdef BN_FAST_S_MP_SQR_C
toddouska	0:5045d2638c29	2506	/* can we use the fast comba multiplier? */
toddouska	0:5045d2638c29	2507	if ((a->used * 2 + 1) < MP_WARRAY &&
toddouska	0:5045d2638c29	2508	a->used <
toddouska	0:5045d2638c29	2509	(1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) {
toddouska	0:5045d2638c29	2510	res = fast_s_mp_sqr (a, b);
toddouska	0:5045d2638c29	2511	} else
toddouska	0:5045d2638c29	2512	#endif
toddouska	0:5045d2638c29	2513	#ifdef BN_S_MP_SQR_C
toddouska	0:5045d2638c29	2514	res = s_mp_sqr (a, b);
toddouska	0:5045d2638c29	2515	#else
toddouska	0:5045d2638c29	2516	res = MP_VAL;
toddouska	0:5045d2638c29	2517	#endif
toddouska	0:5045d2638c29	2518	}
toddouska	0:5045d2638c29	2519	b->sign = MP_ZPOS;
toddouska	0:5045d2638c29	2520	return res;
toddouska	0:5045d2638c29	2521	}
toddouska	0:5045d2638c29	2522
toddouska	0:5045d2638c29	2523
toddouska	0:5045d2638c29	2524	/* high level multiplication (handles sign) */
toddouska	0:5045d2638c29	2525	int mp_mul (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	2526	{
toddouska	0:5045d2638c29	2527	int res, neg;
toddouska	0:5045d2638c29	2528	neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
toddouska	0:5045d2638c29	2529
toddouska	0:5045d2638c29	2530	{
toddouska	0:5045d2638c29	2531	/* can we use the fast multiplier?
toddouska	0:5045d2638c29	2532	*
toddouska	0:5045d2638c29	2533	* The fast multiplier can be used if the output will
toddouska	0:5045d2638c29	2534	* have less than MP_WARRAY digits and the number of
toddouska	0:5045d2638c29	2535	* digits won't affect carry propagation
toddouska	0:5045d2638c29	2536	*/
toddouska	0:5045d2638c29	2537	int digs = a->used + b->used + 1;
toddouska	0:5045d2638c29	2538
toddouska	0:5045d2638c29	2539	#ifdef BN_FAST_S_MP_MUL_DIGS_C
toddouska	0:5045d2638c29	2540	if ((digs < MP_WARRAY) &&
toddouska	0:5045d2638c29	2541	MIN(a->used, b->used) <=
toddouska	0:5045d2638c29	2542	(1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
toddouska	0:5045d2638c29	2543	res = fast_s_mp_mul_digs (a, b, c, digs);
toddouska	0:5045d2638c29	2544	} else
toddouska	0:5045d2638c29	2545	#endif
toddouska	0:5045d2638c29	2546	#ifdef BN_S_MP_MUL_DIGS_C
toddouska	0:5045d2638c29	2547	res = s_mp_mul (a, b, c); /* uses s_mp_mul_digs */
toddouska	0:5045d2638c29	2548	#else
toddouska	0:5045d2638c29	2549	res = MP_VAL;
toddouska	0:5045d2638c29	2550	#endif
toddouska	0:5045d2638c29	2551
toddouska	0:5045d2638c29	2552	}
toddouska	0:5045d2638c29	2553	c->sign = (c->used > 0) ? neg : MP_ZPOS;
toddouska	0:5045d2638c29	2554	return res;
toddouska	0:5045d2638c29	2555	}
toddouska	0:5045d2638c29	2556
toddouska	0:5045d2638c29	2557
toddouska	0:5045d2638c29	2558	/* b = a2 /
toddouska	0:5045d2638c29	2559	int mp_mul_2(mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	2560	{
toddouska	0:5045d2638c29	2561	int x, res, oldused;
toddouska	0:5045d2638c29	2562
toddouska	0:5045d2638c29	2563	/* grow to accomodate result */
toddouska	0:5045d2638c29	2564	if (b->alloc < a->used + 1) {
toddouska	0:5045d2638c29	2565	if ((res = mp_grow (b, a->used + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	2566	return res;
toddouska	0:5045d2638c29	2567	}
toddouska	0:5045d2638c29	2568	}
toddouska	0:5045d2638c29	2569
toddouska	0:5045d2638c29	2570	oldused = b->used;
toddouska	0:5045d2638c29	2571	b->used = a->used;
toddouska	0:5045d2638c29	2572
toddouska	0:5045d2638c29	2573	{
toddouska	0:5045d2638c29	2574	register mp_digit r, rr, tmpa, tmpb;
toddouska	0:5045d2638c29	2575
toddouska	0:5045d2638c29	2576	/* alias for source */
toddouska	0:5045d2638c29	2577	tmpa = a->dp;
toddouska	0:5045d2638c29	2578
toddouska	0:5045d2638c29	2579	/* alias for dest */
toddouska	0:5045d2638c29	2580	tmpb = b->dp;
toddouska	0:5045d2638c29	2581
toddouska	0:5045d2638c29	2582	/* carry */
toddouska	0:5045d2638c29	2583	r = 0;
toddouska	0:5045d2638c29	2584	for (x = 0; x < a->used; x++) {
toddouska	0:5045d2638c29	2585
toddouska	0:5045d2638c29	2586	/* get what will be the next carry bit from the
toddouska	0:5045d2638c29	2587	* MSB of the current digit
toddouska	0:5045d2638c29	2588	*/
toddouska	0:5045d2638c29	2589	rr = *tmpa >> ((mp_digit)(DIGIT_BIT - 1));
toddouska	0:5045d2638c29	2590
toddouska	0:5045d2638c29	2591	/* now shift up this digit, add in the carry [from the previous] */
toddouska	0:5045d2638c29	2592	tmpb++ = ((tmpa++ << ((mp_digit)1)) \| r) & MP_MASK;
toddouska	0:5045d2638c29	2593
toddouska	0:5045d2638c29	2594	/* copy the carry that would be from the source
toddouska	0:5045d2638c29	2595	* digit into the next iteration
toddouska	0:5045d2638c29	2596	*/
toddouska	0:5045d2638c29	2597	r = rr;
toddouska	0:5045d2638c29	2598	}
toddouska	0:5045d2638c29	2599
toddouska	0:5045d2638c29	2600	/* new leading digit? */
toddouska	0:5045d2638c29	2601	if (r != 0) {
toddouska	0:5045d2638c29	2602	/* add a MSB which is always 1 at this point */
toddouska	0:5045d2638c29	2603	*tmpb = 1;
toddouska	0:5045d2638c29	2604	++(b->used);
toddouska	0:5045d2638c29	2605	}
toddouska	0:5045d2638c29	2606
toddouska	0:5045d2638c29	2607	/* now zero any excess digits on the destination
toddouska	0:5045d2638c29	2608	* that we didn't write to
toddouska	0:5045d2638c29	2609	*/
toddouska	0:5045d2638c29	2610	tmpb = b->dp + b->used;
toddouska	0:5045d2638c29	2611	for (x = b->used; x < oldused; x++) {
toddouska	0:5045d2638c29	2612	*tmpb++ = 0;
toddouska	0:5045d2638c29	2613	}
toddouska	0:5045d2638c29	2614	}
toddouska	0:5045d2638c29	2615	b->sign = a->sign;
toddouska	0:5045d2638c29	2616	return MP_OKAY;
toddouska	0:5045d2638c29	2617	}
toddouska	0:5045d2638c29	2618
toddouska	0:5045d2638c29	2619
toddouska	0:5045d2638c29	2620	/* divide by three (based on routine from MPI and the GMP manual) */
toddouska	0:5045d2638c29	2621	int
toddouska	0:5045d2638c29	2622	mp_div_3 (mp_int * a, mp_int c, mp_digit d)
toddouska	0:5045d2638c29	2623	{
toddouska	0:5045d2638c29	2624	mp_int q;
toddouska	0:5045d2638c29	2625	mp_word w, t;
toddouska	0:5045d2638c29	2626	mp_digit b;
toddouska	0:5045d2638c29	2627	int res, ix;
toddouska	0:5045d2638c29	2628
toddouska	0:5045d2638c29	2629	/* b = 2*DIGIT_BIT / 3 /
toddouska	0:5045d2638c29	2630	b = (((mp_word)1) << ((mp_word)DIGIT_BIT)) / ((mp_word)3);
toddouska	0:5045d2638c29	2631
toddouska	0:5045d2638c29	2632	if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
toddouska	0:5045d2638c29	2633	return res;
toddouska	0:5045d2638c29	2634	}
toddouska	0:5045d2638c29	2635
toddouska	0:5045d2638c29	2636	q.used = a->used;
toddouska	0:5045d2638c29	2637	q.sign = a->sign;
toddouska	0:5045d2638c29	2638	w = 0;
toddouska	0:5045d2638c29	2639	for (ix = a->used - 1; ix >= 0; ix--) {
toddouska	0:5045d2638c29	2640	w = (w << ((mp_word)DIGIT_BIT)) \| ((mp_word)a->dp[ix]);
toddouska	0:5045d2638c29	2641
toddouska	0:5045d2638c29	2642	if (w >= 3) {
toddouska	0:5045d2638c29	2643	/* multiply w by [1/3] */
toddouska	0:5045d2638c29	2644	t = (w * ((mp_word)b)) >> ((mp_word)DIGIT_BIT);
toddouska	0:5045d2638c29	2645
toddouska	0:5045d2638c29	2646	/* now subtract 3 * [w/3] from w, to get the remainder */
toddouska	0:5045d2638c29	2647	w -= t+t+t;
toddouska	0:5045d2638c29	2648
toddouska	0:5045d2638c29	2649	/* fixup the remainder as required since
toddouska	0:5045d2638c29	2650	* the optimization is not exact.
toddouska	0:5045d2638c29	2651	*/
toddouska	0:5045d2638c29	2652	while (w >= 3) {
toddouska	0:5045d2638c29	2653	t += 1;
toddouska	0:5045d2638c29	2654	w -= 3;
toddouska	0:5045d2638c29	2655	}
toddouska	0:5045d2638c29	2656	} else {
toddouska	0:5045d2638c29	2657	t = 0;
toddouska	0:5045d2638c29	2658	}
toddouska	0:5045d2638c29	2659	q.dp[ix] = (mp_digit)t;
toddouska	0:5045d2638c29	2660	}
toddouska	0:5045d2638c29	2661
toddouska	0:5045d2638c29	2662	/* [optional] store the remainder */
toddouska	0:5045d2638c29	2663	if (d != NULL) {
toddouska	0:5045d2638c29	2664	*d = (mp_digit)w;
toddouska	0:5045d2638c29	2665	}
toddouska	0:5045d2638c29	2666
toddouska	0:5045d2638c29	2667	/* [optional] store the quotient */
toddouska	0:5045d2638c29	2668	if (c != NULL) {
toddouska	0:5045d2638c29	2669	mp_clamp(&q);
toddouska	0:5045d2638c29	2670	mp_exch(&q, c);
toddouska	0:5045d2638c29	2671	}
toddouska	0:5045d2638c29	2672	mp_clear(&q);
toddouska	0:5045d2638c29	2673
toddouska	0:5045d2638c29	2674	return res;
toddouska	0:5045d2638c29	2675	}
toddouska	0:5045d2638c29	2676
toddouska	0:5045d2638c29	2677
toddouska	0:5045d2638c29	2678	/* init an mp_init for a given size */
toddouska	0:5045d2638c29	2679	int mp_init_size (mp_int * a, int size)
toddouska	0:5045d2638c29	2680	{
toddouska	0:5045d2638c29	2681	int x;
toddouska	0:5045d2638c29	2682
toddouska	0:5045d2638c29	2683	/* pad size so there are always extra digits */
toddouska	0:5045d2638c29	2684	size += (MP_PREC * 2) - (size % MP_PREC);
toddouska	0:5045d2638c29	2685
toddouska	0:5045d2638c29	2686	/* alloc mem */
toddouska	0:5045d2638c29	2687	a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * size, 0,
toddouska	0:5045d2638c29	2688	DYNAMIC_TYPE_BIGINT);
toddouska	0:5045d2638c29	2689	if (a->dp == NULL) {
toddouska	0:5045d2638c29	2690	return MP_MEM;
toddouska	0:5045d2638c29	2691	}
toddouska	0:5045d2638c29	2692
toddouska	0:5045d2638c29	2693	/* set the members */
toddouska	0:5045d2638c29	2694	a->used = 0;
toddouska	0:5045d2638c29	2695	a->alloc = size;
toddouska	0:5045d2638c29	2696	a->sign = MP_ZPOS;
toddouska	0:5045d2638c29	2697
toddouska	0:5045d2638c29	2698	/* zero the digits */
toddouska	0:5045d2638c29	2699	for (x = 0; x < size; x++) {
toddouska	0:5045d2638c29	2700	a->dp[x] = 0;
toddouska	0:5045d2638c29	2701	}
toddouska	0:5045d2638c29	2702
toddouska	0:5045d2638c29	2703	return MP_OKAY;
toddouska	0:5045d2638c29	2704	}
toddouska	0:5045d2638c29	2705
toddouska	0:5045d2638c29	2706
toddouska	0:5045d2638c29	2707	/* the jist of squaring...
toddouska	0:5045d2638c29	2708	* you do like mult except the offset of the tmpx [one that
toddouska	0:5045d2638c29	2709	* starts closer to zero] can't equal the offset of tmpy.
toddouska	0:5045d2638c29	2710	* So basically you set up iy like before then you min it with
toddouska	0:5045d2638c29	2711	* (ty-tx) so that it never happens. You double all those
toddouska	0:5045d2638c29	2712	* you add in the inner loop
toddouska	0:5045d2638c29	2713
toddouska	0:5045d2638c29	2714	After that loop you do the squares and add them in.
toddouska	0:5045d2638c29	2715	*/
toddouska	0:5045d2638c29	2716
toddouska	0:5045d2638c29	2717	int fast_s_mp_sqr (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	2718	{
toddouska	0:5045d2638c29	2719	int olduse, res, pa, ix, iz;
toddouska	0:5045d2638c29	2720	mp_digit W[MP_WARRAY], *tmpx;
toddouska	0:5045d2638c29	2721	mp_word W1;
toddouska	0:5045d2638c29	2722
toddouska	0:5045d2638c29	2723	/* grow the destination as required */
toddouska	0:5045d2638c29	2724	pa = a->used + a->used;
toddouska	0:5045d2638c29	2725	if (b->alloc < pa) {
toddouska	0:5045d2638c29	2726	if ((res = mp_grow (b, pa)) != MP_OKAY) {
toddouska	0:5045d2638c29	2727	return res;
toddouska	0:5045d2638c29	2728	}
toddouska	0:5045d2638c29	2729	}
toddouska	0:5045d2638c29	2730
toddouska	0:5045d2638c29	2731	/* number of output digits to produce */
toddouska	0:5045d2638c29	2732	W1 = 0;
toddouska	0:5045d2638c29	2733	for (ix = 0; ix < pa; ix++) {
toddouska	0:5045d2638c29	2734	int tx, ty, iy;
toddouska	0:5045d2638c29	2735	mp_word _W;
toddouska	0:5045d2638c29	2736	mp_digit *tmpy;
toddouska	0:5045d2638c29	2737
toddouska	0:5045d2638c29	2738	/* clear counter */
toddouska	0:5045d2638c29	2739	_W = 0;
toddouska	0:5045d2638c29	2740
toddouska	0:5045d2638c29	2741	/* get offsets into the two bignums */
toddouska	0:5045d2638c29	2742	ty = MIN(a->used-1, ix);
toddouska	0:5045d2638c29	2743	tx = ix - ty;
toddouska	0:5045d2638c29	2744
toddouska	0:5045d2638c29	2745	/* setup temp aliases */
toddouska	0:5045d2638c29	2746	tmpx = a->dp + tx;
toddouska	0:5045d2638c29	2747	tmpy = a->dp + ty;
toddouska	0:5045d2638c29	2748
toddouska	0:5045d2638c29	2749	/* this is the number of times the loop will iterrate, essentially
toddouska	0:5045d2638c29	2750	while (tx++ < a->used && ty-- >= 0) { ... }
toddouska	0:5045d2638c29	2751	*/
toddouska	0:5045d2638c29	2752	iy = MIN(a->used-tx, ty+1);
toddouska	0:5045d2638c29	2753
toddouska	0:5045d2638c29	2754	/* now for squaring tx can never equal ty
toddouska	0:5045d2638c29	2755	* we halve the distance since they approach at a rate of 2x
toddouska	0:5045d2638c29	2756	* and we have to round because odd cases need to be executed
toddouska	0:5045d2638c29	2757	*/
toddouska	0:5045d2638c29	2758	iy = MIN(iy, (ty-tx+1)>>1);
toddouska	0:5045d2638c29	2759
toddouska	0:5045d2638c29	2760	/* execute loop */
toddouska	0:5045d2638c29	2761	for (iz = 0; iz < iy; iz++) {
toddouska	0:5045d2638c29	2762	_W += ((mp_word)tmpx++)((mp_word)*tmpy--);
toddouska	0:5045d2638c29	2763	}
toddouska	0:5045d2638c29	2764
toddouska	0:5045d2638c29	2765	/* double the inner product and add carry */
toddouska	0:5045d2638c29	2766	_W = _W + _W + W1;
toddouska	0:5045d2638c29	2767
toddouska	0:5045d2638c29	2768	/* even columns have the square term in them */
toddouska	0:5045d2638c29	2769	if ((ix&1) == 0) {
toddouska	0:5045d2638c29	2770	_W += ((mp_word)a->dp[ix>>1])*((mp_word)a->dp[ix>>1]);
toddouska	0:5045d2638c29	2771	}
toddouska	0:5045d2638c29	2772
toddouska	0:5045d2638c29	2773	/* store it */
toddouska	0:5045d2638c29	2774	W[ix] = (mp_digit)(_W & MP_MASK);
toddouska	0:5045d2638c29	2775
toddouska	0:5045d2638c29	2776	/* make next carry */
toddouska	0:5045d2638c29	2777	W1 = _W >> ((mp_word)DIGIT_BIT);
toddouska	0:5045d2638c29	2778	}
toddouska	0:5045d2638c29	2779
toddouska	0:5045d2638c29	2780	/* setup dest */
toddouska	0:5045d2638c29	2781	olduse = b->used;
toddouska	0:5045d2638c29	2782	b->used = a->used+a->used;
toddouska	0:5045d2638c29	2783
toddouska	0:5045d2638c29	2784	{
toddouska	0:5045d2638c29	2785	mp_digit *tmpb;
toddouska	0:5045d2638c29	2786	tmpb = b->dp;
toddouska	0:5045d2638c29	2787	for (ix = 0; ix < pa; ix++) {
toddouska	0:5045d2638c29	2788	*tmpb++ = W[ix] & MP_MASK;
toddouska	0:5045d2638c29	2789	}
toddouska	0:5045d2638c29	2790
toddouska	0:5045d2638c29	2791	/* clear unused digits [that existed in the old copy of c] */
toddouska	0:5045d2638c29	2792	for (; ix < olduse; ix++) {
toddouska	0:5045d2638c29	2793	*tmpb++ = 0;
toddouska	0:5045d2638c29	2794	}
toddouska	0:5045d2638c29	2795	}
toddouska	0:5045d2638c29	2796	mp_clamp (b);
toddouska	0:5045d2638c29	2797	return MP_OKAY;
toddouska	0:5045d2638c29	2798	}
toddouska	0:5045d2638c29	2799
toddouska	0:5045d2638c29	2800
toddouska	0:5045d2638c29	2801	/* Fast (comba) multiplier
toddouska	0:5045d2638c29	2802	*
toddouska	0:5045d2638c29	2803	* This is the fast column-array [comba] multiplier. It is
toddouska	0:5045d2638c29	2804	* designed to compute the columns of the product first
toddouska	0:5045d2638c29	2805	* then handle the carries afterwards. This has the effect
toddouska	0:5045d2638c29	2806	* of making the nested loops that compute the columns very
toddouska	0:5045d2638c29	2807	* simple and schedulable on super-scalar processors.
toddouska	0:5045d2638c29	2808	*
toddouska	0:5045d2638c29	2809	* This has been modified to produce a variable number of
toddouska	0:5045d2638c29	2810	* digits of output so if say only a half-product is required
toddouska	0:5045d2638c29	2811	* you don't have to compute the upper half (a feature
toddouska	0:5045d2638c29	2812	* required for fast Barrett reduction).
toddouska	0:5045d2638c29	2813	*
toddouska	0:5045d2638c29	2814	* Based on Algorithm 14.12 on pp.595 of HAC.
toddouska	0:5045d2638c29	2815	*
toddouska	0:5045d2638c29	2816	*/
toddouska	0:5045d2638c29	2817	int fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
toddouska	0:5045d2638c29	2818	{
toddouska	0:5045d2638c29	2819	int olduse, res, pa, ix, iz;
toddouska	0:5045d2638c29	2820	mp_digit W[MP_WARRAY];
toddouska	0:5045d2638c29	2821	register mp_word _W;
toddouska	0:5045d2638c29	2822
toddouska	0:5045d2638c29	2823	/* grow the destination as required */
toddouska	0:5045d2638c29	2824	if (c->alloc < digs) {
toddouska	0:5045d2638c29	2825	if ((res = mp_grow (c, digs)) != MP_OKAY) {
toddouska	0:5045d2638c29	2826	return res;
toddouska	0:5045d2638c29	2827	}
toddouska	0:5045d2638c29	2828	}
toddouska	0:5045d2638c29	2829
toddouska	0:5045d2638c29	2830	/* number of output digits to produce */
toddouska	0:5045d2638c29	2831	pa = MIN(digs, a->used + b->used);
toddouska	0:5045d2638c29	2832
toddouska	0:5045d2638c29	2833	/* clear the carry */
toddouska	0:5045d2638c29	2834	_W = 0;
toddouska	0:5045d2638c29	2835	for (ix = 0; ix < pa; ix++) {
toddouska	0:5045d2638c29	2836	int tx, ty;
toddouska	0:5045d2638c29	2837	int iy;
toddouska	0:5045d2638c29	2838	mp_digit tmpx, tmpy;
toddouska	0:5045d2638c29	2839
toddouska	0:5045d2638c29	2840	/* get offsets into the two bignums */
toddouska	0:5045d2638c29	2841	ty = MIN(b->used-1, ix);
toddouska	0:5045d2638c29	2842	tx = ix - ty;
toddouska	0:5045d2638c29	2843
toddouska	0:5045d2638c29	2844	/* setup temp aliases */
toddouska	0:5045d2638c29	2845	tmpx = a->dp + tx;
toddouska	0:5045d2638c29	2846	tmpy = b->dp + ty;
toddouska	0:5045d2638c29	2847
toddouska	0:5045d2638c29	2848	/* this is the number of times the loop will iterrate, essentially
toddouska	0:5045d2638c29	2849	while (tx++ < a->used && ty-- >= 0) { ... }
toddouska	0:5045d2638c29	2850	*/
toddouska	0:5045d2638c29	2851	iy = MIN(a->used-tx, ty+1);
toddouska	0:5045d2638c29	2852
toddouska	0:5045d2638c29	2853	/* execute loop */
toddouska	0:5045d2638c29	2854	for (iz = 0; iz < iy; ++iz) {
toddouska	0:5045d2638c29	2855	_W += ((mp_word)tmpx++)((mp_word)*tmpy--);
toddouska	0:5045d2638c29	2856
toddouska	0:5045d2638c29	2857	}
toddouska	0:5045d2638c29	2858
toddouska	0:5045d2638c29	2859	/* store term */
toddouska	0:5045d2638c29	2860	W[ix] = ((mp_digit)_W) & MP_MASK;
toddouska	0:5045d2638c29	2861
toddouska	0:5045d2638c29	2862	/* make next carry */
toddouska	0:5045d2638c29	2863	_W = _W >> ((mp_word)DIGIT_BIT);
toddouska	0:5045d2638c29	2864	}
toddouska	0:5045d2638c29	2865
toddouska	0:5045d2638c29	2866	/* setup dest */
toddouska	0:5045d2638c29	2867	olduse = c->used;
toddouska	0:5045d2638c29	2868	c->used = pa;
toddouska	0:5045d2638c29	2869
toddouska	0:5045d2638c29	2870	{
toddouska	0:5045d2638c29	2871	register mp_digit *tmpc;
toddouska	0:5045d2638c29	2872	tmpc = c->dp;
toddouska	0:5045d2638c29	2873	for (ix = 0; ix < pa+1; ix++) {
toddouska	0:5045d2638c29	2874	/* now extract the previous digit [below the carry] */
toddouska	0:5045d2638c29	2875	*tmpc++ = W[ix];
toddouska	0:5045d2638c29	2876	}
toddouska	0:5045d2638c29	2877
toddouska	0:5045d2638c29	2878	/* clear unused digits [that existed in the old copy of c] */
toddouska	0:5045d2638c29	2879	for (; ix < olduse; ix++) {
toddouska	0:5045d2638c29	2880	*tmpc++ = 0;
toddouska	0:5045d2638c29	2881	}
toddouska	0:5045d2638c29	2882	}
toddouska	0:5045d2638c29	2883	mp_clamp (c);
toddouska	0:5045d2638c29	2884	return MP_OKAY;
toddouska	0:5045d2638c29	2885	}
toddouska	0:5045d2638c29	2886
toddouska	0:5045d2638c29	2887
toddouska	0:5045d2638c29	2888	/* low level squaring, b = aa, HAC pp.596-597, Algorithm 14.16 /
toddouska	0:5045d2638c29	2889	int s_mp_sqr (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	2890	{
toddouska	0:5045d2638c29	2891	mp_int t;
toddouska	0:5045d2638c29	2892	int res, ix, iy, pa;
toddouska	0:5045d2638c29	2893	mp_word r;
toddouska	0:5045d2638c29	2894	mp_digit u, tmpx, *tmpt;
toddouska	0:5045d2638c29	2895
toddouska	0:5045d2638c29	2896	pa = a->used;
toddouska	0:5045d2638c29	2897	if ((res = mp_init_size (&t, 2*pa + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	2898	return res;
toddouska	0:5045d2638c29	2899	}
toddouska	0:5045d2638c29	2900
toddouska	0:5045d2638c29	2901	/* default used is maximum possible size */
toddouska	0:5045d2638c29	2902	t.used = 2*pa + 1;
toddouska	0:5045d2638c29	2903
toddouska	0:5045d2638c29	2904	for (ix = 0; ix < pa; ix++) {
toddouska	0:5045d2638c29	2905	/* first calculate the digit at 2ix /
toddouska	0:5045d2638c29	2906	/* calculate double precision result */
toddouska	0:5045d2638c29	2907	r = ((mp_word) t.dp[2*ix]) +
toddouska	0:5045d2638c29	2908	((mp_word)a->dp[ix])*((mp_word)a->dp[ix]);
toddouska	0:5045d2638c29	2909
toddouska	0:5045d2638c29	2910	/* store lower part in result */
toddouska	0:5045d2638c29	2911	t.dp[ix+ix] = (mp_digit) (r & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	2912
toddouska	0:5045d2638c29	2913	/* get the carry */
toddouska	0:5045d2638c29	2914	u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
toddouska	0:5045d2638c29	2915
toddouska	0:5045d2638c29	2916	/* left hand side of A[ix] * A[iy] */
toddouska	0:5045d2638c29	2917	tmpx = a->dp[ix];
toddouska	0:5045d2638c29	2918
toddouska	0:5045d2638c29	2919	/* alias for where to store the results */
toddouska	0:5045d2638c29	2920	tmpt = t.dp + (2*ix + 1);
toddouska	0:5045d2638c29	2921
toddouska	0:5045d2638c29	2922	for (iy = ix + 1; iy < pa; iy++) {
toddouska	0:5045d2638c29	2923	/* first calculate the product */
toddouska	0:5045d2638c29	2924	r = ((mp_word)tmpx) * ((mp_word)a->dp[iy]);
toddouska	0:5045d2638c29	2925
toddouska	0:5045d2638c29	2926	/* now calculate the double precision result, note we use
toddouska	0:5045d2638c29	2927	* addition instead of *2 since it's easier to optimize
toddouska	0:5045d2638c29	2928	*/
toddouska	0:5045d2638c29	2929	r = ((mp_word) *tmpt) + r + r + ((mp_word) u);
toddouska	0:5045d2638c29	2930
toddouska	0:5045d2638c29	2931	/* store lower part */
toddouska	0:5045d2638c29	2932	*tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	2933
toddouska	0:5045d2638c29	2934	/* get carry */
toddouska	0:5045d2638c29	2935	u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
toddouska	0:5045d2638c29	2936	}
toddouska	0:5045d2638c29	2937	/* propagate upwards */
toddouska	0:5045d2638c29	2938	while (u != ((mp_digit) 0)) {
toddouska	0:5045d2638c29	2939	r = ((mp_word) *tmpt) + ((mp_word) u);
toddouska	0:5045d2638c29	2940	*tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	2941	u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
toddouska	0:5045d2638c29	2942	}
toddouska	0:5045d2638c29	2943	}
toddouska	0:5045d2638c29	2944
toddouska	0:5045d2638c29	2945	mp_clamp (&t);
toddouska	0:5045d2638c29	2946	mp_exch (&t, b);
toddouska	0:5045d2638c29	2947	mp_clear (&t);
toddouska	0:5045d2638c29	2948	return MP_OKAY;
toddouska	0:5045d2638c29	2949	}
toddouska	0:5045d2638c29	2950
toddouska	0:5045d2638c29	2951
toddouska	0:5045d2638c29	2952	/* multiplies \|a\| * \|b\| and only computes upto digs digits of result
toddouska	0:5045d2638c29	2953	* HAC pp. 595, Algorithm 14.12 Modified so you can control how
toddouska	0:5045d2638c29	2954	* many digits of output are created.
toddouska	0:5045d2638c29	2955	*/
toddouska	0:5045d2638c29	2956	int s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
toddouska	0:5045d2638c29	2957	{
toddouska	0:5045d2638c29	2958	mp_int t;
toddouska	0:5045d2638c29	2959	int res, pa, pb, ix, iy;
toddouska	0:5045d2638c29	2960	mp_digit u;
toddouska	0:5045d2638c29	2961	mp_word r;
toddouska	0:5045d2638c29	2962	mp_digit tmpx, tmpt, tmpy;
toddouska	0:5045d2638c29	2963
toddouska	0:5045d2638c29	2964	/* can we use the fast multiplier? */
toddouska	0:5045d2638c29	2965	if (((digs) < MP_WARRAY) &&
toddouska	0:5045d2638c29	2966	MIN (a->used, b->used) <
toddouska	0:5045d2638c29	2967	(1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
toddouska	0:5045d2638c29	2968	return fast_s_mp_mul_digs (a, b, c, digs);
toddouska	0:5045d2638c29	2969	}
toddouska	0:5045d2638c29	2970
toddouska	0:5045d2638c29	2971	if ((res = mp_init_size (&t, digs)) != MP_OKAY) {
toddouska	0:5045d2638c29	2972	return res;
toddouska	0:5045d2638c29	2973	}
toddouska	0:5045d2638c29	2974	t.used = digs;
toddouska	0:5045d2638c29	2975
toddouska	0:5045d2638c29	2976	/* compute the digits of the product directly */
toddouska	0:5045d2638c29	2977	pa = a->used;
toddouska	0:5045d2638c29	2978	for (ix = 0; ix < pa; ix++) {
toddouska	0:5045d2638c29	2979	/* set the carry to zero */
toddouska	0:5045d2638c29	2980	u = 0;
toddouska	0:5045d2638c29	2981
toddouska	0:5045d2638c29	2982	/* limit ourselves to making digs digits of output */
toddouska	0:5045d2638c29	2983	pb = MIN (b->used, digs - ix);
toddouska	0:5045d2638c29	2984
toddouska	0:5045d2638c29	2985	/* setup some aliases */
toddouska	0:5045d2638c29	2986	/* copy of the digit from a used within the nested loop */
toddouska	0:5045d2638c29	2987	tmpx = a->dp[ix];
toddouska	0:5045d2638c29	2988
toddouska	0:5045d2638c29	2989	/* an alias for the destination shifted ix places */
toddouska	0:5045d2638c29	2990	tmpt = t.dp + ix;
toddouska	0:5045d2638c29	2991
toddouska	0:5045d2638c29	2992	/* an alias for the digits of b */
toddouska	0:5045d2638c29	2993	tmpy = b->dp;
toddouska	0:5045d2638c29	2994
toddouska	0:5045d2638c29	2995	/* compute the columns of the output and propagate the carry */
toddouska	0:5045d2638c29	2996	for (iy = 0; iy < pb; iy++) {
toddouska	0:5045d2638c29	2997	/* compute the column as a mp_word */
toddouska	0:5045d2638c29	2998	r = ((mp_word)*tmpt) +
toddouska	0:5045d2638c29	2999	((mp_word)tmpx) * ((mp_word)*tmpy++) +
toddouska	0:5045d2638c29	3000	((mp_word) u);
toddouska	0:5045d2638c29	3001
toddouska	0:5045d2638c29	3002	/* the new column is the lower part of the result */
toddouska	0:5045d2638c29	3003	*tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	3004
toddouska	0:5045d2638c29	3005	/* get the carry word from the result */
toddouska	0:5045d2638c29	3006	u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
toddouska	0:5045d2638c29	3007	}
toddouska	0:5045d2638c29	3008	/* set carry if it is placed below digs */
toddouska	0:5045d2638c29	3009	if (ix + iy < digs) {
toddouska	0:5045d2638c29	3010	*tmpt = u;
toddouska	0:5045d2638c29	3011	}
toddouska	0:5045d2638c29	3012	}
toddouska	0:5045d2638c29	3013
toddouska	0:5045d2638c29	3014	mp_clamp (&t);
toddouska	0:5045d2638c29	3015	mp_exch (&t, c);
toddouska	0:5045d2638c29	3016
toddouska	0:5045d2638c29	3017	mp_clear (&t);
toddouska	0:5045d2638c29	3018	return MP_OKAY;
toddouska	0:5045d2638c29	3019	}
toddouska	0:5045d2638c29	3020
toddouska	0:5045d2638c29	3021
toddouska	0:5045d2638c29	3022	/*
toddouska	0:5045d2638c29	3023	* shifts with subtractions when the result is greater than b.
toddouska	0:5045d2638c29	3024	*
toddouska	0:5045d2638c29	3025	* The method is slightly modified to shift B unconditionally upto just under
toddouska	0:5045d2638c29	3026	* the leading bit of b. This saves alot of multiple precision shifting.
toddouska	0:5045d2638c29	3027	*/
toddouska	0:5045d2638c29	3028	int mp_montgomery_calc_normalization (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	3029	{
toddouska	0:5045d2638c29	3030	int x, bits, res;
toddouska	0:5045d2638c29	3031
toddouska	0:5045d2638c29	3032	/* how many bits of last digit does b use */
toddouska	0:5045d2638c29	3033	bits = mp_count_bits (b) % DIGIT_BIT;
toddouska	0:5045d2638c29	3034
toddouska	0:5045d2638c29	3035	if (b->used > 1) {
toddouska	0:5045d2638c29	3036	if ((res = mp_2expt (a, (b->used - 1) * DIGIT_BIT + bits - 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	3037	return res;
toddouska	0:5045d2638c29	3038	}
toddouska	0:5045d2638c29	3039	} else {
toddouska	0:5045d2638c29	3040	mp_set(a, 1);
toddouska	0:5045d2638c29	3041	bits = 1;
toddouska	0:5045d2638c29	3042	}
toddouska	0:5045d2638c29	3043
toddouska	0:5045d2638c29	3044
toddouska	0:5045d2638c29	3045	/* now compute C = A * B mod b */
toddouska	0:5045d2638c29	3046	for (x = bits - 1; x < (int)DIGIT_BIT; x++) {
toddouska	0:5045d2638c29	3047	if ((res = mp_mul_2 (a, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	3048	return res;
toddouska	0:5045d2638c29	3049	}
toddouska	0:5045d2638c29	3050	if (mp_cmp_mag (a, b) != MP_LT) {
toddouska	0:5045d2638c29	3051	if ((res = s_mp_sub (a, b, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	3052	return res;
toddouska	0:5045d2638c29	3053	}
toddouska	0:5045d2638c29	3054	}
toddouska	0:5045d2638c29	3055	}
toddouska	0:5045d2638c29	3056
toddouska	0:5045d2638c29	3057	return MP_OKAY;
toddouska	0:5045d2638c29	3058	}
toddouska	0:5045d2638c29	3059
toddouska	0:5045d2638c29	3060
toddouska	0:5045d2638c29	3061	#ifdef MP_LOW_MEM
toddouska	0:5045d2638c29	3062	#define TAB_SIZE 32
toddouska	0:5045d2638c29	3063	#else
toddouska	0:5045d2638c29	3064	#define TAB_SIZE 256
toddouska	0:5045d2638c29	3065	#endif
toddouska	0:5045d2638c29	3066
toddouska	0:5045d2638c29	3067	int s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
toddouska	0:5045d2638c29	3068	{
toddouska	0:5045d2638c29	3069	mp_int M[TAB_SIZE], res, mu;
toddouska	0:5045d2638c29	3070	mp_digit buf;
toddouska	0:5045d2638c29	3071	int err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
toddouska	0:5045d2638c29	3072	int (redux)(mp_int,mp_int,mp_int);
toddouska	0:5045d2638c29	3073
toddouska	0:5045d2638c29	3074	/* find window size */
toddouska	0:5045d2638c29	3075	x = mp_count_bits (X);
toddouska	0:5045d2638c29	3076	if (x <= 7) {
toddouska	0:5045d2638c29	3077	winsize = 2;
toddouska	0:5045d2638c29	3078	} else if (x <= 36) {
toddouska	0:5045d2638c29	3079	winsize = 3;
toddouska	0:5045d2638c29	3080	} else if (x <= 140) {
toddouska	0:5045d2638c29	3081	winsize = 4;
toddouska	0:5045d2638c29	3082	} else if (x <= 450) {
toddouska	0:5045d2638c29	3083	winsize = 5;
toddouska	0:5045d2638c29	3084	} else if (x <= 1303) {
toddouska	0:5045d2638c29	3085	winsize = 6;
toddouska	0:5045d2638c29	3086	} else if (x <= 3529) {
toddouska	0:5045d2638c29	3087	winsize = 7;
toddouska	0:5045d2638c29	3088	} else {
toddouska	0:5045d2638c29	3089	winsize = 8;
toddouska	0:5045d2638c29	3090	}
toddouska	0:5045d2638c29	3091
toddouska	0:5045d2638c29	3092	#ifdef MP_LOW_MEM
toddouska	0:5045d2638c29	3093	if (winsize > 5) {
toddouska	0:5045d2638c29	3094	winsize = 5;
toddouska	0:5045d2638c29	3095	}
toddouska	0:5045d2638c29	3096	#endif
toddouska	0:5045d2638c29	3097
toddouska	0:5045d2638c29	3098	/* init M array */
toddouska	0:5045d2638c29	3099	/* init first cell */
toddouska	0:5045d2638c29	3100	if ((err = mp_init(&M[1])) != MP_OKAY) {
toddouska	0:5045d2638c29	3101	return err;
toddouska	0:5045d2638c29	3102	}
toddouska	0:5045d2638c29	3103
toddouska	0:5045d2638c29	3104	/* now init the second half of the array */
toddouska	0:5045d2638c29	3105	for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
toddouska	0:5045d2638c29	3106	if ((err = mp_init(&M[x])) != MP_OKAY) {
toddouska	0:5045d2638c29	3107	for (y = 1<<(winsize-1); y < x; y++) {
toddouska	0:5045d2638c29	3108	mp_clear (&M[y]);
toddouska	0:5045d2638c29	3109	}
toddouska	0:5045d2638c29	3110	mp_clear(&M[1]);
toddouska	0:5045d2638c29	3111	return err;
toddouska	0:5045d2638c29	3112	}
toddouska	0:5045d2638c29	3113	}
toddouska	0:5045d2638c29	3114
toddouska	0:5045d2638c29	3115	/* create mu, used for Barrett reduction */
toddouska	0:5045d2638c29	3116	if ((err = mp_init (&mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3117	goto LBL_M;
toddouska	0:5045d2638c29	3118	}
toddouska	0:5045d2638c29	3119
toddouska	0:5045d2638c29	3120	if (redmode == 0) {
toddouska	0:5045d2638c29	3121	if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) {
toddouska	0:5045d2638c29	3122	goto LBL_MU;
toddouska	0:5045d2638c29	3123	}
toddouska	0:5045d2638c29	3124	redux = mp_reduce;
toddouska	0:5045d2638c29	3125	} else {
toddouska	0:5045d2638c29	3126	if ((err = mp_reduce_2k_setup_l (P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3127	goto LBL_MU;
toddouska	0:5045d2638c29	3128	}
toddouska	0:5045d2638c29	3129	redux = mp_reduce_2k_l;
toddouska	0:5045d2638c29	3130	}
toddouska	0:5045d2638c29	3131
toddouska	0:5045d2638c29	3132	/* create M table
toddouska	0:5045d2638c29	3133	*
toddouska	0:5045d2638c29	3134	* The M table contains powers of the base,
toddouska	0:5045d2638c29	3135	* e.g. M[x] = G**x mod P
toddouska	0:5045d2638c29	3136	*
toddouska	0:5045d2638c29	3137	* The first half of the table is not
toddouska	0:5045d2638c29	3138	* computed though accept for M[0] and M[1]
toddouska	0:5045d2638c29	3139	*/
toddouska	0:5045d2638c29	3140	if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) {
toddouska	0:5045d2638c29	3141	goto LBL_MU;
toddouska	0:5045d2638c29	3142	}
toddouska	0:5045d2638c29	3143
toddouska	0:5045d2638c29	3144	/* compute the value at M[1<<(winsize-1)] by squaring
toddouska	0:5045d2638c29	3145	* M[1] (winsize-1) times
toddouska	0:5045d2638c29	3146	*/
toddouska	0:5045d2638c29	3147	if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
toddouska	0:5045d2638c29	3148	goto LBL_MU;
toddouska	0:5045d2638c29	3149	}
toddouska	0:5045d2638c29	3150
toddouska	0:5045d2638c29	3151	for (x = 0; x < (winsize - 1); x++) {
toddouska	0:5045d2638c29	3152	/* square it */
toddouska	0:5045d2638c29	3153	if ((err = mp_sqr (&M[1 << (winsize - 1)],
toddouska	0:5045d2638c29	3154	&M[1 << (winsize - 1)])) != MP_OKAY) {
toddouska	0:5045d2638c29	3155	goto LBL_MU;
toddouska	0:5045d2638c29	3156	}
toddouska	0:5045d2638c29	3157
toddouska	0:5045d2638c29	3158	/* reduce modulo P */
toddouska	0:5045d2638c29	3159	if ((err = redux (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3160	goto LBL_MU;
toddouska	0:5045d2638c29	3161	}
toddouska	0:5045d2638c29	3162	}
toddouska	0:5045d2638c29	3163
toddouska	0:5045d2638c29	3164	/* create upper table, that is M[x] = M[x-1] * M[1] (mod P)
toddouska	0:5045d2638c29	3165	* for x = (2(winsize - 1) + 1) to (2winsize - 1)
toddouska	0:5045d2638c29	3166	*/
toddouska	0:5045d2638c29	3167	for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
toddouska	0:5045d2638c29	3168	if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
toddouska	0:5045d2638c29	3169	goto LBL_MU;
toddouska	0:5045d2638c29	3170	}
toddouska	0:5045d2638c29	3171	if ((err = redux (&M[x], P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3172	goto LBL_MU;
toddouska	0:5045d2638c29	3173	}
toddouska	0:5045d2638c29	3174	}
toddouska	0:5045d2638c29	3175
toddouska	0:5045d2638c29	3176	/* setup result */
toddouska	0:5045d2638c29	3177	if ((err = mp_init (&res)) != MP_OKAY) {
toddouska	0:5045d2638c29	3178	goto LBL_MU;
toddouska	0:5045d2638c29	3179	}
toddouska	0:5045d2638c29	3180	mp_set (&res, 1);
toddouska	0:5045d2638c29	3181
toddouska	0:5045d2638c29	3182	/* set initial mode and bit cnt */
toddouska	0:5045d2638c29	3183	mode = 0;
toddouska	0:5045d2638c29	3184	bitcnt = 1;
toddouska	0:5045d2638c29	3185	buf = 0;
toddouska	0:5045d2638c29	3186	digidx = X->used - 1;
toddouska	0:5045d2638c29	3187	bitcpy = 0;
toddouska	0:5045d2638c29	3188	bitbuf = 0;
toddouska	0:5045d2638c29	3189
toddouska	0:5045d2638c29	3190	for (;;) {
toddouska	0:5045d2638c29	3191	/* grab next digit as required */
toddouska	0:5045d2638c29	3192	if (--bitcnt == 0) {
toddouska	0:5045d2638c29	3193	/* if digidx == -1 we are out of digits */
toddouska	0:5045d2638c29	3194	if (digidx == -1) {
toddouska	0:5045d2638c29	3195	break;
toddouska	0:5045d2638c29	3196	}
toddouska	0:5045d2638c29	3197	/* read next digit and reset the bitcnt */
toddouska	0:5045d2638c29	3198	buf = X->dp[digidx--];
toddouska	0:5045d2638c29	3199	bitcnt = (int) DIGIT_BIT;
toddouska	0:5045d2638c29	3200	}
toddouska	0:5045d2638c29	3201
toddouska	0:5045d2638c29	3202	/* grab the next msb from the exponent */
toddouska	0:5045d2638c29	3203	y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
toddouska	0:5045d2638c29	3204	buf <<= (mp_digit)1;
toddouska	0:5045d2638c29	3205
toddouska	0:5045d2638c29	3206	/* if the bit is zero and mode == 0 then we ignore it
toddouska	0:5045d2638c29	3207	* These represent the leading zero bits before the first 1 bit
toddouska	0:5045d2638c29	3208	* in the exponent. Technically this opt is not required but it
toddouska	0:5045d2638c29	3209	* does lower the # of trivial squaring/reductions used
toddouska	0:5045d2638c29	3210	*/
toddouska	0:5045d2638c29	3211	if (mode == 0 && y == 0) {
toddouska	0:5045d2638c29	3212	continue;
toddouska	0:5045d2638c29	3213	}
toddouska	0:5045d2638c29	3214
toddouska	0:5045d2638c29	3215	/* if the bit is zero and mode == 1 then we square */
toddouska	0:5045d2638c29	3216	if (mode == 1 && y == 0) {
toddouska	0:5045d2638c29	3217	if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	3218	goto LBL_RES;
toddouska	0:5045d2638c29	3219	}
toddouska	0:5045d2638c29	3220	if ((err = redux (&res, P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3221	goto LBL_RES;
toddouska	0:5045d2638c29	3222	}
toddouska	0:5045d2638c29	3223	continue;
toddouska	0:5045d2638c29	3224	}
toddouska	0:5045d2638c29	3225
toddouska	0:5045d2638c29	3226	/* else we add it to the window */
toddouska	0:5045d2638c29	3227	bitbuf \|= (y << (winsize - ++bitcpy));
toddouska	0:5045d2638c29	3228	mode = 2;
toddouska	0:5045d2638c29	3229
toddouska	0:5045d2638c29	3230	if (bitcpy == winsize) {
toddouska	0:5045d2638c29	3231	/* ok window is filled so square as required and multiply */
toddouska	0:5045d2638c29	3232	/* square first */
toddouska	0:5045d2638c29	3233	for (x = 0; x < winsize; x++) {
toddouska	0:5045d2638c29	3234	if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	3235	goto LBL_RES;
toddouska	0:5045d2638c29	3236	}
toddouska	0:5045d2638c29	3237	if ((err = redux (&res, P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3238	goto LBL_RES;
toddouska	0:5045d2638c29	3239	}
toddouska	0:5045d2638c29	3240	}
toddouska	0:5045d2638c29	3241
toddouska	0:5045d2638c29	3242	/* then multiply */
toddouska	0:5045d2638c29	3243	if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	3244	goto LBL_RES;
toddouska	0:5045d2638c29	3245	}
toddouska	0:5045d2638c29	3246	if ((err = redux (&res, P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3247	goto LBL_RES;
toddouska	0:5045d2638c29	3248	}
toddouska	0:5045d2638c29	3249
toddouska	0:5045d2638c29	3250	/* empty window and reset */
toddouska	0:5045d2638c29	3251	bitcpy = 0;
toddouska	0:5045d2638c29	3252	bitbuf = 0;
toddouska	0:5045d2638c29	3253	mode = 1;
toddouska	0:5045d2638c29	3254	}
toddouska	0:5045d2638c29	3255	}
toddouska	0:5045d2638c29	3256
toddouska	0:5045d2638c29	3257	/* if bits remain then square/multiply */
toddouska	0:5045d2638c29	3258	if (mode == 2 && bitcpy > 0) {
toddouska	0:5045d2638c29	3259	/* square then multiply if the bit is set */
toddouska	0:5045d2638c29	3260	for (x = 0; x < bitcpy; x++) {
toddouska	0:5045d2638c29	3261	if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	3262	goto LBL_RES;
toddouska	0:5045d2638c29	3263	}
toddouska	0:5045d2638c29	3264	if ((err = redux (&res, P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3265	goto LBL_RES;
toddouska	0:5045d2638c29	3266	}
toddouska	0:5045d2638c29	3267
toddouska	0:5045d2638c29	3268	bitbuf <<= 1;
toddouska	0:5045d2638c29	3269	if ((bitbuf & (1 << winsize)) != 0) {
toddouska	0:5045d2638c29	3270	/* then multiply */
toddouska	0:5045d2638c29	3271	if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	3272	goto LBL_RES;
toddouska	0:5045d2638c29	3273	}
toddouska	0:5045d2638c29	3274	if ((err = redux (&res, P, &mu)) != MP_OKAY) {
toddouska	0:5045d2638c29	3275	goto LBL_RES;
toddouska	0:5045d2638c29	3276	}
toddouska	0:5045d2638c29	3277	}
toddouska	0:5045d2638c29	3278	}
toddouska	0:5045d2638c29	3279	}
toddouska	0:5045d2638c29	3280
toddouska	0:5045d2638c29	3281	mp_exch (&res, Y);
toddouska	0:5045d2638c29	3282	err = MP_OKAY;
toddouska	0:5045d2638c29	3283	LBL_RES:mp_clear (&res);
toddouska	0:5045d2638c29	3284	LBL_MU:mp_clear (&mu);
toddouska	0:5045d2638c29	3285	LBL_M:
toddouska	0:5045d2638c29	3286	mp_clear(&M[1]);
toddouska	0:5045d2638c29	3287	for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
toddouska	0:5045d2638c29	3288	mp_clear (&M[x]);
toddouska	0:5045d2638c29	3289	}
toddouska	0:5045d2638c29	3290	return err;
toddouska	0:5045d2638c29	3291	}
toddouska	0:5045d2638c29	3292
toddouska	0:5045d2638c29	3293
toddouska	0:5045d2638c29	3294	/* pre-calculate the value required for Barrett reduction
toddouska	0:5045d2638c29	3295	* For a given modulus "b" it calulates the value required in "a"
toddouska	0:5045d2638c29	3296	*/
toddouska	0:5045d2638c29	3297	int mp_reduce_setup (mp_int * a, mp_int * b)
toddouska	0:5045d2638c29	3298	{
toddouska	0:5045d2638c29	3299	int res;
toddouska	0:5045d2638c29	3300
toddouska	0:5045d2638c29	3301	if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) {
toddouska	0:5045d2638c29	3302	return res;
toddouska	0:5045d2638c29	3303	}
toddouska	0:5045d2638c29	3304	return mp_div (a, b, a, NULL);
toddouska	0:5045d2638c29	3305	}
toddouska	0:5045d2638c29	3306
toddouska	0:5045d2638c29	3307
toddouska	0:5045d2638c29	3308	/* reduces x mod m, assumes 0 < x < m**2, mu is
toddouska	0:5045d2638c29	3309	* precomputed via mp_reduce_setup.
toddouska	0:5045d2638c29	3310	* From HAC pp.604 Algorithm 14.42
toddouska	0:5045d2638c29	3311	*/
toddouska	0:5045d2638c29	3312	int mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
toddouska	0:5045d2638c29	3313	{
toddouska	0:5045d2638c29	3314	mp_int q;
toddouska	0:5045d2638c29	3315	int res, um = m->used;
toddouska	0:5045d2638c29	3316
toddouska	0:5045d2638c29	3317	/* q = x */
toddouska	0:5045d2638c29	3318	if ((res = mp_init_copy (&q, x)) != MP_OKAY) {
toddouska	0:5045d2638c29	3319	return res;
toddouska	0:5045d2638c29	3320	}
toddouska	0:5045d2638c29	3321
toddouska	0:5045d2638c29	3322	/* q1 = x / b*(k-1) /
toddouska	0:5045d2638c29	3323	mp_rshd (&q, um - 1);
toddouska	0:5045d2638c29	3324
toddouska	0:5045d2638c29	3325	/* according to HAC this optimization is ok */
toddouska	0:5045d2638c29	3326	if (((unsigned long) um) > (((mp_digit)1) << (DIGIT_BIT - 1))) {
toddouska	0:5045d2638c29	3327	if ((res = mp_mul (&q, mu, &q)) != MP_OKAY) {
toddouska	0:5045d2638c29	3328	goto CLEANUP;
toddouska	0:5045d2638c29	3329	}
toddouska	0:5045d2638c29	3330	} else {
toddouska	0:5045d2638c29	3331	#ifdef BN_S_MP_MUL_HIGH_DIGS_C
toddouska	0:5045d2638c29	3332	if ((res = s_mp_mul_high_digs (&q, mu, &q, um)) != MP_OKAY) {
toddouska	0:5045d2638c29	3333	goto CLEANUP;
toddouska	0:5045d2638c29	3334	}
toddouska	0:5045d2638c29	3335	#elif defined(BN_FAST_S_MP_MUL_HIGH_DIGS_C)
toddouska	0:5045d2638c29	3336	if ((res = fast_s_mp_mul_high_digs (&q, mu, &q, um)) != MP_OKAY) {
toddouska	0:5045d2638c29	3337	goto CLEANUP;
toddouska	0:5045d2638c29	3338	}
toddouska	0:5045d2638c29	3339	#else
toddouska	0:5045d2638c29	3340	{
toddouska	0:5045d2638c29	3341	res = MP_VAL;
toddouska	0:5045d2638c29	3342	goto CLEANUP;
toddouska	0:5045d2638c29	3343	}
toddouska	0:5045d2638c29	3344	#endif
toddouska	0:5045d2638c29	3345	}
toddouska	0:5045d2638c29	3346
toddouska	0:5045d2638c29	3347	/* q3 = q2 / b*(k+1) /
toddouska	0:5045d2638c29	3348	mp_rshd (&q, um + 1);
toddouska	0:5045d2638c29	3349
toddouska	0:5045d2638c29	3350	/* x = x mod b*(k+1), quick (no division) /
toddouska	0:5045d2638c29	3351	if ((res = mp_mod_2d (x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) {
toddouska	0:5045d2638c29	3352	goto CLEANUP;
toddouska	0:5045d2638c29	3353	}
toddouska	0:5045d2638c29	3354
toddouska	0:5045d2638c29	3355	/* q = q * m mod b*(k+1), quick (no division) /
toddouska	0:5045d2638c29	3356	if ((res = s_mp_mul_digs (&q, m, &q, um + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	3357	goto CLEANUP;
toddouska	0:5045d2638c29	3358	}
toddouska	0:5045d2638c29	3359
toddouska	0:5045d2638c29	3360	/* x = x - q */
toddouska	0:5045d2638c29	3361	if ((res = mp_sub (x, &q, x)) != MP_OKAY) {
toddouska	0:5045d2638c29	3362	goto CLEANUP;
toddouska	0:5045d2638c29	3363	}
toddouska	0:5045d2638c29	3364
toddouska	0:5045d2638c29	3365	/* If x < 0, add b*(k+1) to it /
toddouska	0:5045d2638c29	3366	if (mp_cmp_d (x, 0) == MP_LT) {
toddouska	0:5045d2638c29	3367	mp_set (&q, 1);
toddouska	0:5045d2638c29	3368	if ((res = mp_lshd (&q, um + 1)) != MP_OKAY)
toddouska	0:5045d2638c29	3369	goto CLEANUP;
toddouska	0:5045d2638c29	3370	if ((res = mp_add (x, &q, x)) != MP_OKAY)
toddouska	0:5045d2638c29	3371	goto CLEANUP;
toddouska	0:5045d2638c29	3372	}
toddouska	0:5045d2638c29	3373
toddouska	0:5045d2638c29	3374	/* Back off if it's too big */
toddouska	0:5045d2638c29	3375	while (mp_cmp (x, m) != MP_LT) {
toddouska	0:5045d2638c29	3376	if ((res = s_mp_sub (x, m, x)) != MP_OKAY) {
toddouska	0:5045d2638c29	3377	goto CLEANUP;
toddouska	0:5045d2638c29	3378	}
toddouska	0:5045d2638c29	3379	}
toddouska	0:5045d2638c29	3380
toddouska	0:5045d2638c29	3381	CLEANUP:
toddouska	0:5045d2638c29	3382	mp_clear (&q);
toddouska	0:5045d2638c29	3383
toddouska	0:5045d2638c29	3384	return res;
toddouska	0:5045d2638c29	3385	}
toddouska	0:5045d2638c29	3386
toddouska	0:5045d2638c29	3387
toddouska	0:5045d2638c29	3388	/* reduces a modulo n where n is of the form 2**p - d
toddouska	0:5045d2638c29	3389	This differs from reduce_2k since "d" can be larger
toddouska	0:5045d2638c29	3390	than a single digit.
toddouska	0:5045d2638c29	3391	*/
toddouska	0:5045d2638c29	3392	int mp_reduce_2k_l(mp_int a, mp_int n, mp_int *d)
toddouska	0:5045d2638c29	3393	{
toddouska	0:5045d2638c29	3394	mp_int q;
toddouska	0:5045d2638c29	3395	int p, res;
toddouska	0:5045d2638c29	3396
toddouska	0:5045d2638c29	3397	if ((res = mp_init(&q)) != MP_OKAY) {
toddouska	0:5045d2638c29	3398	return res;
toddouska	0:5045d2638c29	3399	}
toddouska	0:5045d2638c29	3400
toddouska	0:5045d2638c29	3401	p = mp_count_bits(n);
toddouska	0:5045d2638c29	3402	top:
toddouska	0:5045d2638c29	3403	/* q = a/2p, a = a mod 2p */
toddouska	0:5045d2638c29	3404	if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	3405	goto ERR;
toddouska	0:5045d2638c29	3406	}
toddouska	0:5045d2638c29	3407
toddouska	0:5045d2638c29	3408	/* q = q * d */
toddouska	0:5045d2638c29	3409	if ((res = mp_mul(&q, d, &q)) != MP_OKAY) {
toddouska	0:5045d2638c29	3410	goto ERR;
toddouska	0:5045d2638c29	3411	}
toddouska	0:5045d2638c29	3412
toddouska	0:5045d2638c29	3413	/* a = a + q */
toddouska	0:5045d2638c29	3414	if ((res = s_mp_add(a, &q, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	3415	goto ERR;
toddouska	0:5045d2638c29	3416	}
toddouska	0:5045d2638c29	3417
toddouska	0:5045d2638c29	3418	if (mp_cmp_mag(a, n) != MP_LT) {
toddouska	0:5045d2638c29	3419	s_mp_sub(a, n, a);
toddouska	0:5045d2638c29	3420	goto top;
toddouska	0:5045d2638c29	3421	}
toddouska	0:5045d2638c29	3422
toddouska	0:5045d2638c29	3423	ERR:
toddouska	0:5045d2638c29	3424	mp_clear(&q);
toddouska	0:5045d2638c29	3425	return res;
toddouska	0:5045d2638c29	3426	}
toddouska	0:5045d2638c29	3427
toddouska	0:5045d2638c29	3428
toddouska	0:5045d2638c29	3429	/* determines the setup value */
toddouska	0:5045d2638c29	3430	int mp_reduce_2k_setup_l(mp_int a, mp_int d)
toddouska	0:5045d2638c29	3431	{
toddouska	0:5045d2638c29	3432	int res;
toddouska	0:5045d2638c29	3433	mp_int tmp;
toddouska	0:5045d2638c29	3434
toddouska	0:5045d2638c29	3435	if ((res = mp_init(&tmp)) != MP_OKAY) {
toddouska	0:5045d2638c29	3436	return res;
toddouska	0:5045d2638c29	3437	}
toddouska	0:5045d2638c29	3438
toddouska	0:5045d2638c29	3439	if ((res = mp_2expt(&tmp, mp_count_bits(a))) != MP_OKAY) {
toddouska	0:5045d2638c29	3440	goto ERR;
toddouska	0:5045d2638c29	3441	}
toddouska	0:5045d2638c29	3442
toddouska	0:5045d2638c29	3443	if ((res = s_mp_sub(&tmp, a, d)) != MP_OKAY) {
toddouska	0:5045d2638c29	3444	goto ERR;
toddouska	0:5045d2638c29	3445	}
toddouska	0:5045d2638c29	3446
toddouska	0:5045d2638c29	3447	ERR:
toddouska	0:5045d2638c29	3448	mp_clear(&tmp);
toddouska	0:5045d2638c29	3449	return res;
toddouska	0:5045d2638c29	3450	}
toddouska	0:5045d2638c29	3451
toddouska	0:5045d2638c29	3452
toddouska	0:5045d2638c29	3453	/* multiplies \|a\| * \|b\| and does not compute the lower digs digits
toddouska	0:5045d2638c29	3454	* [meant to get the higher part of the product]
toddouska	0:5045d2638c29	3455	*/
toddouska	0:5045d2638c29	3456	int
toddouska	0:5045d2638c29	3457	s_mp_mul_high_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
toddouska	0:5045d2638c29	3458	{
toddouska	0:5045d2638c29	3459	mp_int t;
toddouska	0:5045d2638c29	3460	int res, pa, pb, ix, iy;
toddouska	0:5045d2638c29	3461	mp_digit u;
toddouska	0:5045d2638c29	3462	mp_word r;
toddouska	0:5045d2638c29	3463	mp_digit tmpx, tmpt, tmpy;
toddouska	0:5045d2638c29	3464
toddouska	0:5045d2638c29	3465	/* can we use the fast multiplier? */
toddouska	0:5045d2638c29	3466	#ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C
toddouska	0:5045d2638c29	3467	if (((a->used + b->used + 1) < MP_WARRAY)
toddouska	0:5045d2638c29	3468	&& MIN (a->used, b->used) < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
toddouska	0:5045d2638c29	3469	return fast_s_mp_mul_high_digs (a, b, c, digs);
toddouska	0:5045d2638c29	3470	}
toddouska	0:5045d2638c29	3471	#endif
toddouska	0:5045d2638c29	3472
toddouska	0:5045d2638c29	3473	if ((res = mp_init_size (&t, a->used + b->used + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	3474	return res;
toddouska	0:5045d2638c29	3475	}
toddouska	0:5045d2638c29	3476	t.used = a->used + b->used + 1;
toddouska	0:5045d2638c29	3477
toddouska	0:5045d2638c29	3478	pa = a->used;
toddouska	0:5045d2638c29	3479	pb = b->used;
toddouska	0:5045d2638c29	3480	for (ix = 0; ix < pa; ix++) {
toddouska	0:5045d2638c29	3481	/* clear the carry */
toddouska	0:5045d2638c29	3482	u = 0;
toddouska	0:5045d2638c29	3483
toddouska	0:5045d2638c29	3484	/* left hand side of A[ix] * B[iy] */
toddouska	0:5045d2638c29	3485	tmpx = a->dp[ix];
toddouska	0:5045d2638c29	3486
toddouska	0:5045d2638c29	3487	/* alias to the address of where the digits will be stored */
toddouska	0:5045d2638c29	3488	tmpt = &(t.dp[digs]);
toddouska	0:5045d2638c29	3489
toddouska	0:5045d2638c29	3490	/* alias for where to read the right hand side from */
toddouska	0:5045d2638c29	3491	tmpy = b->dp + (digs - ix);
toddouska	0:5045d2638c29	3492
toddouska	0:5045d2638c29	3493	for (iy = digs - ix; iy < pb; iy++) {
toddouska	0:5045d2638c29	3494	/* calculate the double precision result */
toddouska	0:5045d2638c29	3495	r = ((mp_word)*tmpt) +
toddouska	0:5045d2638c29	3496	((mp_word)tmpx) * ((mp_word)*tmpy++) +
toddouska	0:5045d2638c29	3497	((mp_word) u);
toddouska	0:5045d2638c29	3498
toddouska	0:5045d2638c29	3499	/* get the lower part */
toddouska	0:5045d2638c29	3500	*tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
toddouska	0:5045d2638c29	3501
toddouska	0:5045d2638c29	3502	/* carry the carry */
toddouska	0:5045d2638c29	3503	u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
toddouska	0:5045d2638c29	3504	}
toddouska	0:5045d2638c29	3505	*tmpt = u;
toddouska	0:5045d2638c29	3506	}
toddouska	0:5045d2638c29	3507	mp_clamp (&t);
toddouska	0:5045d2638c29	3508	mp_exch (&t, c);
toddouska	0:5045d2638c29	3509	mp_clear (&t);
toddouska	0:5045d2638c29	3510	return MP_OKAY;
toddouska	0:5045d2638c29	3511	}
toddouska	0:5045d2638c29	3512
toddouska	0:5045d2638c29	3513
toddouska	0:5045d2638c29	3514	/* this is a modified version of fast_s_mul_digs that only produces
toddouska	0:5045d2638c29	3515	* output digits above digs. See the comments for fast_s_mul_digs
toddouska	0:5045d2638c29	3516	* to see how it works.
toddouska	0:5045d2638c29	3517	*
toddouska	0:5045d2638c29	3518	* This is used in the Barrett reduction since for one of the multiplications
toddouska	0:5045d2638c29	3519	* only the higher digits were needed. This essentially halves the work.
toddouska	0:5045d2638c29	3520	*
toddouska	0:5045d2638c29	3521	* Based on Algorithm 14.12 on pp.595 of HAC.
toddouska	0:5045d2638c29	3522	*/
toddouska	0:5045d2638c29	3523	int fast_s_mp_mul_high_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
toddouska	0:5045d2638c29	3524	{
toddouska	0:5045d2638c29	3525	int olduse, res, pa, ix, iz;
toddouska	0:5045d2638c29	3526	mp_digit W[MP_WARRAY];
toddouska	0:5045d2638c29	3527	mp_word _W;
toddouska	0:5045d2638c29	3528
toddouska	0:5045d2638c29	3529	/* grow the destination as required */
toddouska	0:5045d2638c29	3530	pa = a->used + b->used;
toddouska	0:5045d2638c29	3531	if (c->alloc < pa) {
toddouska	0:5045d2638c29	3532	if ((res = mp_grow (c, pa)) != MP_OKAY) {
toddouska	0:5045d2638c29	3533	return res;
toddouska	0:5045d2638c29	3534	}
toddouska	0:5045d2638c29	3535	}
toddouska	0:5045d2638c29	3536
toddouska	0:5045d2638c29	3537	/* number of output digits to produce */
toddouska	0:5045d2638c29	3538	pa = a->used + b->used;
toddouska	0:5045d2638c29	3539	_W = 0;
toddouska	0:5045d2638c29	3540	for (ix = digs; ix < pa; ix++) {
toddouska	0:5045d2638c29	3541	int tx, ty, iy;
toddouska	0:5045d2638c29	3542	mp_digit tmpx, tmpy;
toddouska	0:5045d2638c29	3543
toddouska	0:5045d2638c29	3544	/* get offsets into the two bignums */
toddouska	0:5045d2638c29	3545	ty = MIN(b->used-1, ix);
toddouska	0:5045d2638c29	3546	tx = ix - ty;
toddouska	0:5045d2638c29	3547
toddouska	0:5045d2638c29	3548	/* setup temp aliases */
toddouska	0:5045d2638c29	3549	tmpx = a->dp + tx;
toddouska	0:5045d2638c29	3550	tmpy = b->dp + ty;
toddouska	0:5045d2638c29	3551
toddouska	0:5045d2638c29	3552	/* this is the number of times the loop will iterrate, essentially its
toddouska	0:5045d2638c29	3553	while (tx++ < a->used && ty-- >= 0) { ... }
toddouska	0:5045d2638c29	3554	*/
toddouska	0:5045d2638c29	3555	iy = MIN(a->used-tx, ty+1);
toddouska	0:5045d2638c29	3556
toddouska	0:5045d2638c29	3557	/* execute loop */
toddouska	0:5045d2638c29	3558	for (iz = 0; iz < iy; iz++) {
toddouska	0:5045d2638c29	3559	_W += ((mp_word)tmpx++)((mp_word)*tmpy--);
toddouska	0:5045d2638c29	3560	}
toddouska	0:5045d2638c29	3561
toddouska	0:5045d2638c29	3562	/* store term */
toddouska	0:5045d2638c29	3563	W[ix] = ((mp_digit)_W) & MP_MASK;
toddouska	0:5045d2638c29	3564
toddouska	0:5045d2638c29	3565	/* make next carry */
toddouska	0:5045d2638c29	3566	_W = _W >> ((mp_word)DIGIT_BIT);
toddouska	0:5045d2638c29	3567	}
toddouska	0:5045d2638c29	3568
toddouska	0:5045d2638c29	3569	/* setup dest */
toddouska	0:5045d2638c29	3570	olduse = c->used;
toddouska	0:5045d2638c29	3571	c->used = pa;
toddouska	0:5045d2638c29	3572
toddouska	0:5045d2638c29	3573	{
toddouska	0:5045d2638c29	3574	register mp_digit *tmpc;
toddouska	0:5045d2638c29	3575
toddouska	0:5045d2638c29	3576	tmpc = c->dp + digs;
toddouska	0:5045d2638c29	3577	for (ix = digs; ix <= pa; ix++) {
toddouska	0:5045d2638c29	3578	/* now extract the previous digit [below the carry] */
toddouska	0:5045d2638c29	3579	*tmpc++ = W[ix];
toddouska	0:5045d2638c29	3580	}
toddouska	0:5045d2638c29	3581
toddouska	0:5045d2638c29	3582	/* clear unused digits [that existed in the old copy of c] */
toddouska	0:5045d2638c29	3583	for (; ix < olduse; ix++) {
toddouska	0:5045d2638c29	3584	*tmpc++ = 0;
toddouska	0:5045d2638c29	3585	}
toddouska	0:5045d2638c29	3586	}
toddouska	0:5045d2638c29	3587	mp_clamp (c);
toddouska	0:5045d2638c29	3588	return MP_OKAY;
toddouska	0:5045d2638c29	3589	}
toddouska	0:5045d2638c29	3590
toddouska	0:5045d2638c29	3591
toddouska	0:5045d2638c29	3592	#ifdef CYASSL_KEY_GEN
toddouska	0:5045d2638c29	3593
toddouska	0:5045d2638c29	3594	int mp_cnt_lsb(mp_int *a);
toddouska	0:5045d2638c29	3595
toddouska	0:5045d2638c29	3596	/* c = a * a (mod b) */
toddouska	0:5045d2638c29	3597	int mp_sqrmod (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	3598	{
toddouska	0:5045d2638c29	3599	int res;
toddouska	0:5045d2638c29	3600	mp_int t;
toddouska	0:5045d2638c29	3601
toddouska	0:5045d2638c29	3602	if ((res = mp_init (&t)) != MP_OKAY) {
toddouska	0:5045d2638c29	3603	return res;
toddouska	0:5045d2638c29	3604	}
toddouska	0:5045d2638c29	3605
toddouska	0:5045d2638c29	3606	if ((res = mp_sqr (a, &t)) != MP_OKAY) {
toddouska	0:5045d2638c29	3607	mp_clear (&t);
toddouska	0:5045d2638c29	3608	return res;
toddouska	0:5045d2638c29	3609	}
toddouska	0:5045d2638c29	3610	res = mp_mod (&t, b, c);
toddouska	0:5045d2638c29	3611	mp_clear (&t);
toddouska	0:5045d2638c29	3612	return res;
toddouska	0:5045d2638c29	3613	}
toddouska	0:5045d2638c29	3614
toddouska	0:5045d2638c29	3615
toddouska	0:5045d2638c29	3616	/* single digit addition */
toddouska	0:5045d2638c29	3617	int mp_add_d (mp_int * a, mp_digit b, mp_int * c)
toddouska	0:5045d2638c29	3618	{
toddouska	0:5045d2638c29	3619	int res, ix, oldused;
toddouska	0:5045d2638c29	3620	mp_digit tmpa, tmpc, mu;
toddouska	0:5045d2638c29	3621
toddouska	0:5045d2638c29	3622	/* grow c as required */
toddouska	0:5045d2638c29	3623	if (c->alloc < a->used + 1) {
toddouska	0:5045d2638c29	3624	if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	3625	return res;
toddouska	0:5045d2638c29	3626	}
toddouska	0:5045d2638c29	3627	}
toddouska	0:5045d2638c29	3628
toddouska	0:5045d2638c29	3629	/* if a is negative and \|a\| >= b, call c = \|a\| - b */
toddouska	0:5045d2638c29	3630	if (a->sign == MP_NEG && (a->used > 1 \|\| a->dp[0] >= b)) {
toddouska	0:5045d2638c29	3631	/* temporarily fix sign of a */
toddouska	0:5045d2638c29	3632	a->sign = MP_ZPOS;
toddouska	0:5045d2638c29	3633
toddouska	0:5045d2638c29	3634	/* c = \|a\| - b */
toddouska	0:5045d2638c29	3635	res = mp_sub_d(a, b, c);
toddouska	0:5045d2638c29	3636
toddouska	0:5045d2638c29	3637	/* fix sign */
toddouska	0:5045d2638c29	3638	a->sign = c->sign = MP_NEG;
toddouska	0:5045d2638c29	3639
toddouska	0:5045d2638c29	3640	/* clamp */
toddouska	0:5045d2638c29	3641	mp_clamp(c);
toddouska	0:5045d2638c29	3642
toddouska	0:5045d2638c29	3643	return res;
toddouska	0:5045d2638c29	3644	}
toddouska	0:5045d2638c29	3645
toddouska	0:5045d2638c29	3646	/* old number of used digits in c */
toddouska	0:5045d2638c29	3647	oldused = c->used;
toddouska	0:5045d2638c29	3648
toddouska	0:5045d2638c29	3649	/* sign always positive */
toddouska	0:5045d2638c29	3650	c->sign = MP_ZPOS;
toddouska	0:5045d2638c29	3651
toddouska	0:5045d2638c29	3652	/* source alias */
toddouska	0:5045d2638c29	3653	tmpa = a->dp;
toddouska	0:5045d2638c29	3654
toddouska	0:5045d2638c29	3655	/* destination alias */
toddouska	0:5045d2638c29	3656	tmpc = c->dp;
toddouska	0:5045d2638c29	3657
toddouska	0:5045d2638c29	3658	/* if a is positive */
toddouska	0:5045d2638c29	3659	if (a->sign == MP_ZPOS) {
toddouska	0:5045d2638c29	3660	/* add digit, after this we're propagating
toddouska	0:5045d2638c29	3661	* the carry.
toddouska	0:5045d2638c29	3662	*/
toddouska	0:5045d2638c29	3663	tmpc = tmpa++ + b;
toddouska	0:5045d2638c29	3664	mu = *tmpc >> DIGIT_BIT;
toddouska	0:5045d2638c29	3665	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	3666
toddouska	0:5045d2638c29	3667	/* now handle rest of the digits */
toddouska	0:5045d2638c29	3668	for (ix = 1; ix < a->used; ix++) {
toddouska	0:5045d2638c29	3669	tmpc = tmpa++ + mu;
toddouska	0:5045d2638c29	3670	mu = *tmpc >> DIGIT_BIT;
toddouska	0:5045d2638c29	3671	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	3672	}
toddouska	0:5045d2638c29	3673	/* set final carry */
toddouska	0:5045d2638c29	3674	ix++;
toddouska	0:5045d2638c29	3675	*tmpc++ = mu;
toddouska	0:5045d2638c29	3676
toddouska	0:5045d2638c29	3677	/* setup size */
toddouska	0:5045d2638c29	3678	c->used = a->used + 1;
toddouska	0:5045d2638c29	3679	} else {
toddouska	0:5045d2638c29	3680	/* a was negative and \|a\| < b */
toddouska	0:5045d2638c29	3681	c->used = 1;
toddouska	0:5045d2638c29	3682
toddouska	0:5045d2638c29	3683	/* the result is a single digit */
toddouska	0:5045d2638c29	3684	if (a->used == 1) {
toddouska	0:5045d2638c29	3685	*tmpc++ = b - a->dp[0];
toddouska	0:5045d2638c29	3686	} else {
toddouska	0:5045d2638c29	3687	*tmpc++ = b;
toddouska	0:5045d2638c29	3688	}
toddouska	0:5045d2638c29	3689
toddouska	0:5045d2638c29	3690	/* setup count so the clearing of oldused
toddouska	0:5045d2638c29	3691	* can fall through correctly
toddouska	0:5045d2638c29	3692	*/
toddouska	0:5045d2638c29	3693	ix = 1;
toddouska	0:5045d2638c29	3694	}
toddouska	0:5045d2638c29	3695
toddouska	0:5045d2638c29	3696	/* now zero to oldused */
toddouska	0:5045d2638c29	3697	while (ix++ < oldused) {
toddouska	0:5045d2638c29	3698	*tmpc++ = 0;
toddouska	0:5045d2638c29	3699	}
toddouska	0:5045d2638c29	3700	mp_clamp(c);
toddouska	0:5045d2638c29	3701
toddouska	0:5045d2638c29	3702	return MP_OKAY;
toddouska	0:5045d2638c29	3703	}
toddouska	0:5045d2638c29	3704
toddouska	0:5045d2638c29	3705
toddouska	0:5045d2638c29	3706	/* single digit subtraction */
toddouska	0:5045d2638c29	3707	int mp_sub_d (mp_int * a, mp_digit b, mp_int * c)
toddouska	0:5045d2638c29	3708	{
toddouska	0:5045d2638c29	3709	mp_digit tmpa, tmpc, mu;
toddouska	0:5045d2638c29	3710	int res, ix, oldused;
toddouska	0:5045d2638c29	3711
toddouska	0:5045d2638c29	3712	/* grow c as required */
toddouska	0:5045d2638c29	3713	if (c->alloc < a->used + 1) {
toddouska	0:5045d2638c29	3714	if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) {
toddouska	0:5045d2638c29	3715	return res;
toddouska	0:5045d2638c29	3716	}
toddouska	0:5045d2638c29	3717	}
toddouska	0:5045d2638c29	3718
toddouska	0:5045d2638c29	3719	/* if a is negative just do an unsigned
toddouska	0:5045d2638c29	3720	* addition [with fudged signs]
toddouska	0:5045d2638c29	3721	*/
toddouska	0:5045d2638c29	3722	if (a->sign == MP_NEG) {
toddouska	0:5045d2638c29	3723	a->sign = MP_ZPOS;
toddouska	0:5045d2638c29	3724	res = mp_add_d(a, b, c);
toddouska	0:5045d2638c29	3725	a->sign = c->sign = MP_NEG;
toddouska	0:5045d2638c29	3726
toddouska	0:5045d2638c29	3727	/* clamp */
toddouska	0:5045d2638c29	3728	mp_clamp(c);
toddouska	0:5045d2638c29	3729
toddouska	0:5045d2638c29	3730	return res;
toddouska	0:5045d2638c29	3731	}
toddouska	0:5045d2638c29	3732
toddouska	0:5045d2638c29	3733	/* setup regs */
toddouska	0:5045d2638c29	3734	oldused = c->used;
toddouska	0:5045d2638c29	3735	tmpa = a->dp;
toddouska	0:5045d2638c29	3736	tmpc = c->dp;
toddouska	0:5045d2638c29	3737
toddouska	0:5045d2638c29	3738	/* if a <= b simply fix the single digit */
toddouska	0:5045d2638c29	3739	if ((a->used == 1 && a->dp[0] <= b) \|\| a->used == 0) {
toddouska	0:5045d2638c29	3740	if (a->used == 1) {
toddouska	0:5045d2638c29	3741	tmpc++ = b - tmpa;
toddouska	0:5045d2638c29	3742	} else {
toddouska	0:5045d2638c29	3743	*tmpc++ = b;
toddouska	0:5045d2638c29	3744	}
toddouska	0:5045d2638c29	3745	ix = 1;
toddouska	0:5045d2638c29	3746
toddouska	0:5045d2638c29	3747	/* negative/1digit */
toddouska	0:5045d2638c29	3748	c->sign = MP_NEG;
toddouska	0:5045d2638c29	3749	c->used = 1;
toddouska	0:5045d2638c29	3750	} else {
toddouska	0:5045d2638c29	3751	/* positive/size */
toddouska	0:5045d2638c29	3752	c->sign = MP_ZPOS;
toddouska	0:5045d2638c29	3753	c->used = a->used;
toddouska	0:5045d2638c29	3754
toddouska	0:5045d2638c29	3755	/* subtract first digit */
toddouska	0:5045d2638c29	3756	tmpc = tmpa++ - b;
toddouska	0:5045d2638c29	3757	mu = tmpc >> (sizeof(mp_digit) CHAR_BIT - 1);
toddouska	0:5045d2638c29	3758	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	3759
toddouska	0:5045d2638c29	3760	/* handle rest of the digits */
toddouska	0:5045d2638c29	3761	for (ix = 1; ix < a->used; ix++) {
toddouska	0:5045d2638c29	3762	tmpc = tmpa++ - mu;
toddouska	0:5045d2638c29	3763	mu = tmpc >> (sizeof(mp_digit) CHAR_BIT - 1);
toddouska	0:5045d2638c29	3764	*tmpc++ &= MP_MASK;
toddouska	0:5045d2638c29	3765	}
toddouska	0:5045d2638c29	3766	}
toddouska	0:5045d2638c29	3767
toddouska	0:5045d2638c29	3768	/* zero excess digits */
toddouska	0:5045d2638c29	3769	while (ix++ < oldused) {
toddouska	0:5045d2638c29	3770	*tmpc++ = 0;
toddouska	0:5045d2638c29	3771	}
toddouska	0:5045d2638c29	3772	mp_clamp(c);
toddouska	0:5045d2638c29	3773	return MP_OKAY;
toddouska	0:5045d2638c29	3774	}
toddouska	0:5045d2638c29	3775
toddouska	0:5045d2638c29	3776
toddouska	0:5045d2638c29	3777	static int s_is_power_of_two(mp_digit b, int *p)
toddouska	0:5045d2638c29	3778	{
toddouska	0:5045d2638c29	3779	int x;
toddouska	0:5045d2638c29	3780
toddouska	0:5045d2638c29	3781	/* fast return if no power of two */
toddouska	0:5045d2638c29	3782	if ((b==0) \|\| (b & (b-1))) {
toddouska	0:5045d2638c29	3783	return 0;
toddouska	0:5045d2638c29	3784	}
toddouska	0:5045d2638c29	3785
toddouska	0:5045d2638c29	3786	for (x = 0; x < DIGIT_BIT; x++) {
toddouska	0:5045d2638c29	3787	if (b == (((mp_digit)1)<<x)) {
toddouska	0:5045d2638c29	3788	*p = x;
toddouska	0:5045d2638c29	3789	return 1;
toddouska	0:5045d2638c29	3790	}
toddouska	0:5045d2638c29	3791	}
toddouska	0:5045d2638c29	3792	return 0;
toddouska	0:5045d2638c29	3793	}
toddouska	0:5045d2638c29	3794
toddouska	0:5045d2638c29	3795	/* single digit division (based on routine from MPI) */
toddouska	0:5045d2638c29	3796	int mp_div_d (mp_int * a, mp_digit b, mp_int * c, mp_digit * d)
toddouska	0:5045d2638c29	3797	{
toddouska	0:5045d2638c29	3798	mp_int q;
toddouska	0:5045d2638c29	3799	mp_word w;
toddouska	0:5045d2638c29	3800	mp_digit t;
toddouska	0:5045d2638c29	3801	int res, ix;
toddouska	0:5045d2638c29	3802
toddouska	0:5045d2638c29	3803	/* cannot divide by zero */
toddouska	0:5045d2638c29	3804	if (b == 0) {
toddouska	0:5045d2638c29	3805	return MP_VAL;
toddouska	0:5045d2638c29	3806	}
toddouska	0:5045d2638c29	3807
toddouska	0:5045d2638c29	3808	/* quick outs */
toddouska	0:5045d2638c29	3809	if (b == 1 \|\| mp_iszero(a) == 1) {
toddouska	0:5045d2638c29	3810	if (d != NULL) {
toddouska	0:5045d2638c29	3811	*d = 0;
toddouska	0:5045d2638c29	3812	}
toddouska	0:5045d2638c29	3813	if (c != NULL) {
toddouska	0:5045d2638c29	3814	return mp_copy(a, c);
toddouska	0:5045d2638c29	3815	}
toddouska	0:5045d2638c29	3816	return MP_OKAY;
toddouska	0:5045d2638c29	3817	}
toddouska	0:5045d2638c29	3818
toddouska	0:5045d2638c29	3819	/* power of two ? */
toddouska	0:5045d2638c29	3820	if (s_is_power_of_two(b, &ix) == 1) {
toddouska	0:5045d2638c29	3821	if (d != NULL) {
toddouska	0:5045d2638c29	3822	*d = a->dp[0] & ((((mp_digit)1)<<ix) - 1);
toddouska	0:5045d2638c29	3823	}
toddouska	0:5045d2638c29	3824	if (c != NULL) {
toddouska	0:5045d2638c29	3825	return mp_div_2d(a, ix, c, NULL);
toddouska	0:5045d2638c29	3826	}
toddouska	0:5045d2638c29	3827	return MP_OKAY;
toddouska	0:5045d2638c29	3828	}
toddouska	0:5045d2638c29	3829
toddouska	0:5045d2638c29	3830	#ifdef BN_MP_DIV_3_C
toddouska	0:5045d2638c29	3831	/* three? */
toddouska	0:5045d2638c29	3832	if (b == 3) {
toddouska	0:5045d2638c29	3833	return mp_div_3(a, c, d);
toddouska	0:5045d2638c29	3834	}
toddouska	0:5045d2638c29	3835	#endif
toddouska	0:5045d2638c29	3836
toddouska	0:5045d2638c29	3837	/* no easy answer [c'est la vie]. Just division */
toddouska	0:5045d2638c29	3838	if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
toddouska	0:5045d2638c29	3839	return res;
toddouska	0:5045d2638c29	3840	}
toddouska	0:5045d2638c29	3841
toddouska	0:5045d2638c29	3842	q.used = a->used;
toddouska	0:5045d2638c29	3843	q.sign = a->sign;
toddouska	0:5045d2638c29	3844	w = 0;
toddouska	0:5045d2638c29	3845	for (ix = a->used - 1; ix >= 0; ix--) {
toddouska	0:5045d2638c29	3846	w = (w << ((mp_word)DIGIT_BIT)) \| ((mp_word)a->dp[ix]);
toddouska	0:5045d2638c29	3847
toddouska	0:5045d2638c29	3848	if (w >= b) {
toddouska	0:5045d2638c29	3849	t = (mp_digit)(w / b);
toddouska	0:5045d2638c29	3850	w -= ((mp_word)t) * ((mp_word)b);
toddouska	0:5045d2638c29	3851	} else {
toddouska	0:5045d2638c29	3852	t = 0;
toddouska	0:5045d2638c29	3853	}
toddouska	0:5045d2638c29	3854	q.dp[ix] = (mp_digit)t;
toddouska	0:5045d2638c29	3855	}
toddouska	0:5045d2638c29	3856
toddouska	0:5045d2638c29	3857	if (d != NULL) {
toddouska	0:5045d2638c29	3858	*d = (mp_digit)w;
toddouska	0:5045d2638c29	3859	}
toddouska	0:5045d2638c29	3860
toddouska	0:5045d2638c29	3861	if (c != NULL) {
toddouska	0:5045d2638c29	3862	mp_clamp(&q);
toddouska	0:5045d2638c29	3863	mp_exch(&q, c);
toddouska	0:5045d2638c29	3864	}
toddouska	0:5045d2638c29	3865	mp_clear(&q);
toddouska	0:5045d2638c29	3866
toddouska	0:5045d2638c29	3867	return res;
toddouska	0:5045d2638c29	3868	}
toddouska	0:5045d2638c29	3869
toddouska	0:5045d2638c29	3870
toddouska	0:5045d2638c29	3871	int mp_mod_d (mp_int * a, mp_digit b, mp_digit * c)
toddouska	0:5045d2638c29	3872	{
toddouska	0:5045d2638c29	3873	return mp_div_d(a, b, NULL, c);
toddouska	0:5045d2638c29	3874	}
toddouska	0:5045d2638c29	3875
toddouska	0:5045d2638c29	3876
toddouska	0:5045d2638c29	3877	const mp_digit ltm_prime_tab[] = {
toddouska	0:5045d2638c29	3878	0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013,
toddouska	0:5045d2638c29	3879	0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035,
toddouska	0:5045d2638c29	3880	0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059,
toddouska	0:5045d2638c29	3881	0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F,
toddouska	0:5045d2638c29	3882	#ifndef MP_8BIT
toddouska	0:5045d2638c29	3883	0x0083,
toddouska	0:5045d2638c29	3884	0x0089, 0x008B, 0x0095, 0x0097, 0x009D, 0x00A3, 0x00A7, 0x00AD,
toddouska	0:5045d2638c29	3885	0x00B3, 0x00B5, 0x00BF, 0x00C1, 0x00C5, 0x00C7, 0x00D3, 0x00DF,
toddouska	0:5045d2638c29	3886	0x00E3, 0x00E5, 0x00E9, 0x00EF, 0x00F1, 0x00FB, 0x0101, 0x0107,
toddouska	0:5045d2638c29	3887	0x010D, 0x010F, 0x0115, 0x0119, 0x011B, 0x0125, 0x0133, 0x0137,
toddouska	0:5045d2638c29	3888
toddouska	0:5045d2638c29	3889	0x0139, 0x013D, 0x014B, 0x0151, 0x015B, 0x015D, 0x0161, 0x0167,
toddouska	0:5045d2638c29	3890	0x016F, 0x0175, 0x017B, 0x017F, 0x0185, 0x018D, 0x0191, 0x0199,
toddouska	0:5045d2638c29	3891	0x01A3, 0x01A5, 0x01AF, 0x01B1, 0x01B7, 0x01BB, 0x01C1, 0x01C9,
toddouska	0:5045d2638c29	3892	0x01CD, 0x01CF, 0x01D3, 0x01DF, 0x01E7, 0x01EB, 0x01F3, 0x01F7,
toddouska	0:5045d2638c29	3893	0x01FD, 0x0209, 0x020B, 0x021D, 0x0223, 0x022D, 0x0233, 0x0239,
toddouska	0:5045d2638c29	3894	0x023B, 0x0241, 0x024B, 0x0251, 0x0257, 0x0259, 0x025F, 0x0265,
toddouska	0:5045d2638c29	3895	0x0269, 0x026B, 0x0277, 0x0281, 0x0283, 0x0287, 0x028D, 0x0293,
toddouska	0:5045d2638c29	3896	0x0295, 0x02A1, 0x02A5, 0x02AB, 0x02B3, 0x02BD, 0x02C5, 0x02CF,
toddouska	0:5045d2638c29	3897
toddouska	0:5045d2638c29	3898	0x02D7, 0x02DD, 0x02E3, 0x02E7, 0x02EF, 0x02F5, 0x02F9, 0x0301,
toddouska	0:5045d2638c29	3899	0x0305, 0x0313, 0x031D, 0x0329, 0x032B, 0x0335, 0x0337, 0x033B,
toddouska	0:5045d2638c29	3900	0x033D, 0x0347, 0x0355, 0x0359, 0x035B, 0x035F, 0x036D, 0x0371,
toddouska	0:5045d2638c29	3901	0x0373, 0x0377, 0x038B, 0x038F, 0x0397, 0x03A1, 0x03A9, 0x03AD,
toddouska	0:5045d2638c29	3902	0x03B3, 0x03B9, 0x03C7, 0x03CB, 0x03D1, 0x03D7, 0x03DF, 0x03E5,
toddouska	0:5045d2638c29	3903	0x03F1, 0x03F5, 0x03FB, 0x03FD, 0x0407, 0x0409, 0x040F, 0x0419,
toddouska	0:5045d2638c29	3904	0x041B, 0x0425, 0x0427, 0x042D, 0x043F, 0x0443, 0x0445, 0x0449,
toddouska	0:5045d2638c29	3905	0x044F, 0x0455, 0x045D, 0x0463, 0x0469, 0x047F, 0x0481, 0x048B,
toddouska	0:5045d2638c29	3906
toddouska	0:5045d2638c29	3907	0x0493, 0x049D, 0x04A3, 0x04A9, 0x04B1, 0x04BD, 0x04C1, 0x04C7,
toddouska	0:5045d2638c29	3908	0x04CD, 0x04CF, 0x04D5, 0x04E1, 0x04EB, 0x04FD, 0x04FF, 0x0503,
toddouska	0:5045d2638c29	3909	0x0509, 0x050B, 0x0511, 0x0515, 0x0517, 0x051B, 0x0527, 0x0529,
toddouska	0:5045d2638c29	3910	0x052F, 0x0551, 0x0557, 0x055D, 0x0565, 0x0577, 0x0581, 0x058F,
toddouska	0:5045d2638c29	3911	0x0593, 0x0595, 0x0599, 0x059F, 0x05A7, 0x05AB, 0x05AD, 0x05B3,
toddouska	0:5045d2638c29	3912	0x05BF, 0x05C9, 0x05CB, 0x05CF, 0x05D1, 0x05D5, 0x05DB, 0x05E7,
toddouska	0:5045d2638c29	3913	0x05F3, 0x05FB, 0x0607, 0x060D, 0x0611, 0x0617, 0x061F, 0x0623,
toddouska	0:5045d2638c29	3914	0x062B, 0x062F, 0x063D, 0x0641, 0x0647, 0x0649, 0x064D, 0x0653
toddouska	0:5045d2638c29	3915	#endif
toddouska	0:5045d2638c29	3916	};
toddouska	0:5045d2638c29	3917
toddouska	0:5045d2638c29	3918
toddouska	0:5045d2638c29	3919	/* Miller-Rabin test of "a" to the base of "b" as described in
toddouska	0:5045d2638c29	3920	* HAC pp. 139 Algorithm 4.24
toddouska	0:5045d2638c29	3921	*
toddouska	0:5045d2638c29	3922	* Sets result to 0 if definitely composite or 1 if probably prime.
toddouska	0:5045d2638c29	3923	* Randomly the chance of error is no more than 1/4 and often
toddouska	0:5045d2638c29	3924	* very much lower.
toddouska	0:5045d2638c29	3925	*/
toddouska	0:5045d2638c29	3926	int mp_prime_miller_rabin (mp_int * a, mp_int * b, int *result)
toddouska	0:5045d2638c29	3927	{
toddouska	0:5045d2638c29	3928	mp_int n1, y, r;
toddouska	0:5045d2638c29	3929	int s, j, err;
toddouska	0:5045d2638c29	3930
toddouska	0:5045d2638c29	3931	/* default */
toddouska	0:5045d2638c29	3932	*result = MP_NO;
toddouska	0:5045d2638c29	3933
toddouska	0:5045d2638c29	3934	/* ensure b > 1 */
toddouska	0:5045d2638c29	3935	if (mp_cmp_d(b, 1) != MP_GT) {
toddouska	0:5045d2638c29	3936	return MP_VAL;
toddouska	0:5045d2638c29	3937	}
toddouska	0:5045d2638c29	3938
toddouska	0:5045d2638c29	3939	/* get n1 = a - 1 */
toddouska	0:5045d2638c29	3940	if ((err = mp_init_copy (&n1, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	3941	return err;
toddouska	0:5045d2638c29	3942	}
toddouska	0:5045d2638c29	3943	if ((err = mp_sub_d (&n1, 1, &n1)) != MP_OKAY) {
toddouska	0:5045d2638c29	3944	goto LBL_N1;
toddouska	0:5045d2638c29	3945	}
toddouska	0:5045d2638c29	3946
toddouska	0:5045d2638c29	3947	/* set 2*s r = n1 */
toddouska	0:5045d2638c29	3948	if ((err = mp_init_copy (&r, &n1)) != MP_OKAY) {
toddouska	0:5045d2638c29	3949	goto LBL_N1;
toddouska	0:5045d2638c29	3950	}
toddouska	0:5045d2638c29	3951
toddouska	0:5045d2638c29	3952	/* count the number of least significant bits
toddouska	0:5045d2638c29	3953	* which are zero
toddouska	0:5045d2638c29	3954	*/
toddouska	0:5045d2638c29	3955	s = mp_cnt_lsb(&r);
toddouska	0:5045d2638c29	3956
toddouska	0:5045d2638c29	3957	/* now divide n - 1 by 2*s /
toddouska	0:5045d2638c29	3958	if ((err = mp_div_2d (&r, s, &r, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	3959	goto LBL_R;
toddouska	0:5045d2638c29	3960	}
toddouska	0:5045d2638c29	3961
toddouska	0:5045d2638c29	3962	/* compute y = b*r mod a /
toddouska	0:5045d2638c29	3963	if ((err = mp_init (&y)) != MP_OKAY) {
toddouska	0:5045d2638c29	3964	goto LBL_R;
toddouska	0:5045d2638c29	3965	}
toddouska	0:5045d2638c29	3966	if ((err = mp_exptmod (b, &r, a, &y)) != MP_OKAY) {
toddouska	0:5045d2638c29	3967	goto LBL_Y;
toddouska	0:5045d2638c29	3968	}
toddouska	0:5045d2638c29	3969
toddouska	0:5045d2638c29	3970	/* if y != 1 and y != n1 do */
toddouska	0:5045d2638c29	3971	if (mp_cmp_d (&y, 1) != MP_EQ && mp_cmp (&y, &n1) != MP_EQ) {
toddouska	0:5045d2638c29	3972	j = 1;
toddouska	0:5045d2638c29	3973	/* while j <= s-1 and y != n1 */
toddouska	0:5045d2638c29	3974	while ((j <= (s - 1)) && mp_cmp (&y, &n1) != MP_EQ) {
toddouska	0:5045d2638c29	3975	if ((err = mp_sqrmod (&y, a, &y)) != MP_OKAY) {
toddouska	0:5045d2638c29	3976	goto LBL_Y;
toddouska	0:5045d2638c29	3977	}
toddouska	0:5045d2638c29	3978
toddouska	0:5045d2638c29	3979	/* if y == 1 then composite */
toddouska	0:5045d2638c29	3980	if (mp_cmp_d (&y, 1) == MP_EQ) {
toddouska	0:5045d2638c29	3981	goto LBL_Y;
toddouska	0:5045d2638c29	3982	}
toddouska	0:5045d2638c29	3983
toddouska	0:5045d2638c29	3984	++j;
toddouska	0:5045d2638c29	3985	}
toddouska	0:5045d2638c29	3986
toddouska	0:5045d2638c29	3987	/* if y != n1 then composite */
toddouska	0:5045d2638c29	3988	if (mp_cmp (&y, &n1) != MP_EQ) {
toddouska	0:5045d2638c29	3989	goto LBL_Y;
toddouska	0:5045d2638c29	3990	}
toddouska	0:5045d2638c29	3991	}
toddouska	0:5045d2638c29	3992
toddouska	0:5045d2638c29	3993	/* probably prime now */
toddouska	0:5045d2638c29	3994	*result = MP_YES;
toddouska	0:5045d2638c29	3995	LBL_Y:mp_clear (&y);
toddouska	0:5045d2638c29	3996	LBL_R:mp_clear (&r);
toddouska	0:5045d2638c29	3997	LBL_N1:mp_clear (&n1);
toddouska	0:5045d2638c29	3998	return err;
toddouska	0:5045d2638c29	3999	}
toddouska	0:5045d2638c29	4000
toddouska	0:5045d2638c29	4001
toddouska	0:5045d2638c29	4002	/* determines if an integers is divisible by one
toddouska	0:5045d2638c29	4003	* of the first PRIME_SIZE primes or not
toddouska	0:5045d2638c29	4004	*
toddouska	0:5045d2638c29	4005	* sets result to 0 if not, 1 if yes
toddouska	0:5045d2638c29	4006	*/
toddouska	0:5045d2638c29	4007	int mp_prime_is_divisible (mp_int * a, int *result)
toddouska	0:5045d2638c29	4008	{
toddouska	0:5045d2638c29	4009	int err, ix;
toddouska	0:5045d2638c29	4010	mp_digit res;
toddouska	0:5045d2638c29	4011
toddouska	0:5045d2638c29	4012	/* default to not */
toddouska	0:5045d2638c29	4013	*result = MP_NO;
toddouska	0:5045d2638c29	4014
toddouska	0:5045d2638c29	4015	for (ix = 0; ix < PRIME_SIZE; ix++) {
toddouska	0:5045d2638c29	4016	/* what is a mod LBL_prime_tab[ix] */
toddouska	0:5045d2638c29	4017	if ((err = mp_mod_d (a, ltm_prime_tab[ix], &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	4018	return err;
toddouska	0:5045d2638c29	4019	}
toddouska	0:5045d2638c29	4020
toddouska	0:5045d2638c29	4021	/* is the residue zero? */
toddouska	0:5045d2638c29	4022	if (res == 0) {
toddouska	0:5045d2638c29	4023	*result = MP_YES;
toddouska	0:5045d2638c29	4024	return MP_OKAY;
toddouska	0:5045d2638c29	4025	}
toddouska	0:5045d2638c29	4026	}
toddouska	0:5045d2638c29	4027
toddouska	0:5045d2638c29	4028	return MP_OKAY;
toddouska	0:5045d2638c29	4029	}
toddouska	0:5045d2638c29	4030
toddouska	0:5045d2638c29	4031
toddouska	0:5045d2638c29	4032	/*
toddouska	0:5045d2638c29	4033	* Sets result to 1 if probably prime, 0 otherwise
toddouska	0:5045d2638c29	4034	*/
toddouska	0:5045d2638c29	4035	int mp_prime_is_prime (mp_int * a, int t, int *result)
toddouska	0:5045d2638c29	4036	{
toddouska	0:5045d2638c29	4037	mp_int b;
toddouska	0:5045d2638c29	4038	int ix, err, res;
toddouska	0:5045d2638c29	4039
toddouska	0:5045d2638c29	4040	/* default to no */
toddouska	0:5045d2638c29	4041	*result = MP_NO;
toddouska	0:5045d2638c29	4042
toddouska	0:5045d2638c29	4043	/* valid value of t? */
toddouska	0:5045d2638c29	4044	if (t <= 0 \|\| t > PRIME_SIZE) {
toddouska	0:5045d2638c29	4045	return MP_VAL;
toddouska	0:5045d2638c29	4046	}
toddouska	0:5045d2638c29	4047
toddouska	0:5045d2638c29	4048	/* is the input equal to one of the primes in the table? */
toddouska	0:5045d2638c29	4049	for (ix = 0; ix < PRIME_SIZE; ix++) {
toddouska	0:5045d2638c29	4050	if (mp_cmp_d(a, ltm_prime_tab[ix]) == MP_EQ) {
toddouska	0:5045d2638c29	4051	*result = 1;
toddouska	0:5045d2638c29	4052	return MP_OKAY;
toddouska	0:5045d2638c29	4053	}
toddouska	0:5045d2638c29	4054	}
toddouska	0:5045d2638c29	4055
toddouska	0:5045d2638c29	4056	/* first perform trial division */
toddouska	0:5045d2638c29	4057	if ((err = mp_prime_is_divisible (a, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	4058	return err;
toddouska	0:5045d2638c29	4059	}
toddouska	0:5045d2638c29	4060
toddouska	0:5045d2638c29	4061	/* return if it was trivially divisible */
toddouska	0:5045d2638c29	4062	if (res == MP_YES) {
toddouska	0:5045d2638c29	4063	return MP_OKAY;
toddouska	0:5045d2638c29	4064	}
toddouska	0:5045d2638c29	4065
toddouska	0:5045d2638c29	4066	/* now perform the miller-rabin rounds */
toddouska	0:5045d2638c29	4067	if ((err = mp_init (&b)) != MP_OKAY) {
toddouska	0:5045d2638c29	4068	return err;
toddouska	0:5045d2638c29	4069	}
toddouska	0:5045d2638c29	4070
toddouska	0:5045d2638c29	4071	for (ix = 0; ix < t; ix++) {
toddouska	0:5045d2638c29	4072	/* set the prime */
toddouska	0:5045d2638c29	4073	mp_set (&b, ltm_prime_tab[ix]);
toddouska	0:5045d2638c29	4074
toddouska	0:5045d2638c29	4075	if ((err = mp_prime_miller_rabin (a, &b, &res)) != MP_OKAY) {
toddouska	0:5045d2638c29	4076	goto LBL_B;
toddouska	0:5045d2638c29	4077	}
toddouska	0:5045d2638c29	4078
toddouska	0:5045d2638c29	4079	if (res == MP_NO) {
toddouska	0:5045d2638c29	4080	goto LBL_B;
toddouska	0:5045d2638c29	4081	}
toddouska	0:5045d2638c29	4082	}
toddouska	0:5045d2638c29	4083
toddouska	0:5045d2638c29	4084	/* passed the test */
toddouska	0:5045d2638c29	4085	*result = MP_YES;
toddouska	0:5045d2638c29	4086	LBL_B:mp_clear (&b);
toddouska	0:5045d2638c29	4087	return err;
toddouska	0:5045d2638c29	4088	}
toddouska	0:5045d2638c29	4089
toddouska	0:5045d2638c29	4090
toddouska	0:5045d2638c29	4091	/* computes least common multiple as \|ab\|/(a, b) /
toddouska	0:5045d2638c29	4092	int mp_lcm (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	4093	{
toddouska	0:5045d2638c29	4094	int res;
toddouska	0:5045d2638c29	4095	mp_int t1, t2;
toddouska	0:5045d2638c29	4096
toddouska	0:5045d2638c29	4097
toddouska	0:5045d2638c29	4098	if ((res = mp_init_multi (&t1, &t2, NULL, NULL, NULL, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4099	return res;
toddouska	0:5045d2638c29	4100	}
toddouska	0:5045d2638c29	4101
toddouska	0:5045d2638c29	4102	/* t1 = get the GCD of the two inputs */
toddouska	0:5045d2638c29	4103	if ((res = mp_gcd (a, b, &t1)) != MP_OKAY) {
toddouska	0:5045d2638c29	4104	goto LBL_T;
toddouska	0:5045d2638c29	4105	}
toddouska	0:5045d2638c29	4106
toddouska	0:5045d2638c29	4107	/* divide the smallest by the GCD */
toddouska	0:5045d2638c29	4108	if (mp_cmp_mag(a, b) == MP_LT) {
toddouska	0:5045d2638c29	4109	/* store quotient in t2 such that t2 * b is the LCM */
toddouska	0:5045d2638c29	4110	if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4111	goto LBL_T;
toddouska	0:5045d2638c29	4112	}
toddouska	0:5045d2638c29	4113	res = mp_mul(b, &t2, c);
toddouska	0:5045d2638c29	4114	} else {
toddouska	0:5045d2638c29	4115	/* store quotient in t2 such that t2 * a is the LCM */
toddouska	0:5045d2638c29	4116	if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4117	goto LBL_T;
toddouska	0:5045d2638c29	4118	}
toddouska	0:5045d2638c29	4119	res = mp_mul(a, &t2, c);
toddouska	0:5045d2638c29	4120	}
toddouska	0:5045d2638c29	4121
toddouska	0:5045d2638c29	4122	/* fix the sign to positive */
toddouska	0:5045d2638c29	4123	c->sign = MP_ZPOS;
toddouska	0:5045d2638c29	4124
toddouska	0:5045d2638c29	4125	LBL_T:
toddouska	0:5045d2638c29	4126	mp_clear(&t1);
toddouska	0:5045d2638c29	4127	mp_clear(&t2);
toddouska	0:5045d2638c29	4128	return res;
toddouska	0:5045d2638c29	4129	}
toddouska	0:5045d2638c29	4130
toddouska	0:5045d2638c29	4131
toddouska	0:5045d2638c29	4132	static const int lnz[16] = {
toddouska	0:5045d2638c29	4133	4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
toddouska	0:5045d2638c29	4134	};
toddouska	0:5045d2638c29	4135
toddouska	0:5045d2638c29	4136	/* Counts the number of lsbs which are zero before the first zero bit */
toddouska	0:5045d2638c29	4137	int mp_cnt_lsb(mp_int *a)
toddouska	0:5045d2638c29	4138	{
toddouska	0:5045d2638c29	4139	int x;
toddouska	0:5045d2638c29	4140	mp_digit q, qq;
toddouska	0:5045d2638c29	4141
toddouska	0:5045d2638c29	4142	/* easy out */
toddouska	0:5045d2638c29	4143	if (mp_iszero(a) == 1) {
toddouska	0:5045d2638c29	4144	return 0;
toddouska	0:5045d2638c29	4145	}
toddouska	0:5045d2638c29	4146
toddouska	0:5045d2638c29	4147	/* scan lower digits until non-zero */
toddouska	0:5045d2638c29	4148	for (x = 0; x < a->used && a->dp[x] == 0; x++);
toddouska	0:5045d2638c29	4149	q = a->dp[x];
toddouska	0:5045d2638c29	4150	x *= DIGIT_BIT;
toddouska	0:5045d2638c29	4151
toddouska	0:5045d2638c29	4152	/* now scan this digit until a 1 is found */
toddouska	0:5045d2638c29	4153	if ((q & 1) == 0) {
toddouska	0:5045d2638c29	4154	do {
toddouska	0:5045d2638c29	4155	qq = q & 15;
toddouska	0:5045d2638c29	4156	x += lnz[qq];
toddouska	0:5045d2638c29	4157	q >>= 4;
toddouska	0:5045d2638c29	4158	} while (qq == 0);
toddouska	0:5045d2638c29	4159	}
toddouska	0:5045d2638c29	4160	return x;
toddouska	0:5045d2638c29	4161	}
toddouska	0:5045d2638c29	4162
toddouska	0:5045d2638c29	4163
toddouska	0:5045d2638c29	4164	/* Greatest Common Divisor using the binary method */
toddouska	0:5045d2638c29	4165	int mp_gcd (mp_int * a, mp_int * b, mp_int * c)
toddouska	0:5045d2638c29	4166	{
toddouska	0:5045d2638c29	4167	mp_int u, v;
toddouska	0:5045d2638c29	4168	int k, u_lsb, v_lsb, res;
toddouska	0:5045d2638c29	4169
toddouska	0:5045d2638c29	4170	/* either zero than gcd is the largest */
toddouska	0:5045d2638c29	4171	if (mp_iszero (a) == MP_YES) {
toddouska	0:5045d2638c29	4172	return mp_abs (b, c);
toddouska	0:5045d2638c29	4173	}
toddouska	0:5045d2638c29	4174	if (mp_iszero (b) == MP_YES) {
toddouska	0:5045d2638c29	4175	return mp_abs (a, c);
toddouska	0:5045d2638c29	4176	}
toddouska	0:5045d2638c29	4177
toddouska	0:5045d2638c29	4178	/* get copies of a and b we can modify */
toddouska	0:5045d2638c29	4179	if ((res = mp_init_copy (&u, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	4180	return res;
toddouska	0:5045d2638c29	4181	}
toddouska	0:5045d2638c29	4182
toddouska	0:5045d2638c29	4183	if ((res = mp_init_copy (&v, b)) != MP_OKAY) {
toddouska	0:5045d2638c29	4184	goto LBL_U;
toddouska	0:5045d2638c29	4185	}
toddouska	0:5045d2638c29	4186
toddouska	0:5045d2638c29	4187	/* must be positive for the remainder of the algorithm */
toddouska	0:5045d2638c29	4188	u.sign = v.sign = MP_ZPOS;
toddouska	0:5045d2638c29	4189
toddouska	0:5045d2638c29	4190	/* B1. Find the common power of two for u and v */
toddouska	0:5045d2638c29	4191	u_lsb = mp_cnt_lsb(&u);
toddouska	0:5045d2638c29	4192	v_lsb = mp_cnt_lsb(&v);
toddouska	0:5045d2638c29	4193	k = MIN(u_lsb, v_lsb);
toddouska	0:5045d2638c29	4194
toddouska	0:5045d2638c29	4195	if (k > 0) {
toddouska	0:5045d2638c29	4196	/* divide the power of two out */
toddouska	0:5045d2638c29	4197	if ((res = mp_div_2d(&u, k, &u, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4198	goto LBL_V;
toddouska	0:5045d2638c29	4199	}
toddouska	0:5045d2638c29	4200
toddouska	0:5045d2638c29	4201	if ((res = mp_div_2d(&v, k, &v, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4202	goto LBL_V;
toddouska	0:5045d2638c29	4203	}
toddouska	0:5045d2638c29	4204	}
toddouska	0:5045d2638c29	4205
toddouska	0:5045d2638c29	4206	/* divide any remaining factors of two out */
toddouska	0:5045d2638c29	4207	if (u_lsb != k) {
toddouska	0:5045d2638c29	4208	if ((res = mp_div_2d(&u, u_lsb - k, &u, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4209	goto LBL_V;
toddouska	0:5045d2638c29	4210	}
toddouska	0:5045d2638c29	4211	}
toddouska	0:5045d2638c29	4212
toddouska	0:5045d2638c29	4213	if (v_lsb != k) {
toddouska	0:5045d2638c29	4214	if ((res = mp_div_2d(&v, v_lsb - k, &v, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4215	goto LBL_V;
toddouska	0:5045d2638c29	4216	}
toddouska	0:5045d2638c29	4217	}
toddouska	0:5045d2638c29	4218
toddouska	0:5045d2638c29	4219	while (mp_iszero(&v) == 0) {
toddouska	0:5045d2638c29	4220	/* make sure v is the largest */
toddouska	0:5045d2638c29	4221	if (mp_cmp_mag(&u, &v) == MP_GT) {
toddouska	0:5045d2638c29	4222	/* swap u and v to make sure v is >= u */
toddouska	0:5045d2638c29	4223	mp_exch(&u, &v);
toddouska	0:5045d2638c29	4224	}
toddouska	0:5045d2638c29	4225
toddouska	0:5045d2638c29	4226	/* subtract smallest from largest */
toddouska	0:5045d2638c29	4227	if ((res = s_mp_sub(&v, &u, &v)) != MP_OKAY) {
toddouska	0:5045d2638c29	4228	goto LBL_V;
toddouska	0:5045d2638c29	4229	}
toddouska	0:5045d2638c29	4230
toddouska	0:5045d2638c29	4231	/* Divide out all factors of two */
toddouska	0:5045d2638c29	4232	if ((res = mp_div_2d(&v, mp_cnt_lsb(&v), &v, NULL)) != MP_OKAY) {
toddouska	0:5045d2638c29	4233	goto LBL_V;
toddouska	0:5045d2638c29	4234	}
toddouska	0:5045d2638c29	4235	}
toddouska	0:5045d2638c29	4236
toddouska	0:5045d2638c29	4237	/* multiply by 2*k which we divided out at the beginning /
toddouska	0:5045d2638c29	4238	if ((res = mp_mul_2d (&u, k, c)) != MP_OKAY) {
toddouska	0:5045d2638c29	4239	goto LBL_V;
toddouska	0:5045d2638c29	4240	}
toddouska	0:5045d2638c29	4241	c->sign = MP_ZPOS;
toddouska	0:5045d2638c29	4242	res = MP_OKAY;
toddouska	0:5045d2638c29	4243	LBL_V:mp_clear (&u);
toddouska	0:5045d2638c29	4244	LBL_U:mp_clear (&v);
toddouska	0:5045d2638c29	4245	return res;
toddouska	0:5045d2638c29	4246	}
toddouska	0:5045d2638c29	4247
toddouska	0:5045d2638c29	4248
toddouska	0:5045d2638c29	4249	/* set a 32-bit const */
toddouska	0:5045d2638c29	4250	int mp_set_int (mp_int * a, unsigned long b)
toddouska	0:5045d2638c29	4251	{
toddouska	0:5045d2638c29	4252	int x, res;
toddouska	0:5045d2638c29	4253
toddouska	0:5045d2638c29	4254	mp_zero (a);
toddouska	0:5045d2638c29	4255
toddouska	0:5045d2638c29	4256	/* set four bits at a time */
toddouska	0:5045d2638c29	4257	for (x = 0; x < 8; x++) {
toddouska	0:5045d2638c29	4258	/* shift the number up four bits */
toddouska	0:5045d2638c29	4259	if ((res = mp_mul_2d (a, 4, a)) != MP_OKAY) {
toddouska	0:5045d2638c29	4260	return res;
toddouska	0:5045d2638c29	4261	}
toddouska	0:5045d2638c29	4262
toddouska	0:5045d2638c29	4263	/* OR in the top four bits of the source */
toddouska	0:5045d2638c29	4264	a->dp[0] \|= (b >> 28) & 15;
toddouska	0:5045d2638c29	4265
toddouska	0:5045d2638c29	4266	/* shift the source up to the next four bits */
toddouska	0:5045d2638c29	4267	b <<= 4;
toddouska	0:5045d2638c29	4268
toddouska	0:5045d2638c29	4269	/* ensure that digits are not clamped off */
toddouska	0:5045d2638c29	4270	a->used += 1;
toddouska	0:5045d2638c29	4271	}
toddouska	0:5045d2638c29	4272	mp_clamp (a);
toddouska	0:5045d2638c29	4273	return MP_OKAY;
toddouska	0:5045d2638c29	4274	}
toddouska	0:5045d2638c29	4275
toddouska	0:5045d2638c29	4276
toddouska	0:5045d2638c29	4277	#endif /* CYASSL_KEY_GEN */
toddouska	0:5045d2638c29	4278
toddouska	0:5045d2638c29	4279	#endif /* USE_FAST_MATH */
toddouska	0:5045d2638c29	4280

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	10 May 2017
Imports:	0
Forks:	0
Commits:	3
Dependents:	0
Dependencies:	0
Followers:	1

integer.c@2:d0516dc143b1, 2017-05-10 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning