Big Integer API

The bigint implementation as used by the axTLS project. More...

Functions
static bigint *	bi_int_multiply (BI_CTX *ctx, bigint *bia, comp b)
	Perform a multiply between a bigint an an (unsigned) integer.
static bigint *	bi_int_divide (BI_CTX *ctx, bigint *biR, comp denom)
static bigint __malloc *	alloc (BI_CTX *ctx, int size)
static bigint *	trim (bigint *bi)
static void	more_comps (bigint *bi, int n)
BI_CTX *	bi_initialize (void)
	Start a new bigint context.
void	bi_terminate (BI_CTX *ctx)
	Close the bigint context and free any resources.
bigint *	bi_copy (bigint *bi)
	Increment the number of references to this object.
void	bi_permanent (bigint *bi)
	Simply make a bigint object "unfreeable" if bi_free() is called on it.
void	bi_depermanent (bigint *bi)
	Take a permanent object and make it eligible for freedom.
void	bi_free (BI_CTX *ctx, bigint *bi)
	Free a bigint object so it can be used again.
bigint *	int_to_bi (BI_CTX *ctx, comp i)
	Convert an (unsigned) integer into a bigint.
bigint *	bi_clone (BI_CTX *ctx, const bigint *bi)
	Do a full copy of the bigint object.
bigint *	bi_add (BI_CTX *ctx, bigint *bia, bigint *bib)
	Perform an addition operation between two bigints.
bigint *	bi_subtract (BI_CTX *ctx, bigint *bia, bigint *bib, int *is_negative)
	Perform a subtraction operation between two bigints.
bigint *	bi_divide (BI_CTX *ctx, bigint *u, bigint *v, int is_mod)
	Does both division and modulo calculations.
static bigint *	bi_int_divide (BI_CTX *ctx __unused, bigint *biR, comp denom)
bigint *	bi_import (BI_CTX *ctx, const uint8_t *data, int size)
	Allow a binary sequence to be imported as a bigint.
void	bi_export (BI_CTX *ctx, bigint *x, uint8_t *data, int size)
	Take a bigint and convert it into a byte sequence.
void	bi_set_mod (BI_CTX *ctx, bigint *bim, int mod_offset)
	Pre-calculate some of the expensive steps in reduction.
void	bi_free_mod (BI_CTX *ctx, int mod_offset)
	Used when cleaning various bigints at the end of a session.
static bigint *	regular_multiply (BI_CTX *ctx, bigint *bia, bigint *bib)
	Perform a standard multiplication between two bigints.
bigint *	bi_multiply (BI_CTX *ctx, bigint *bia, bigint *bib)
	Perform a multiplication operation between two bigints.
int	bi_compare (bigint *bia, bigint *bib)
	Compare two bigints.
static int	find_max_exp_index (bigint *biexp)
static int	exp_bit_is_one (bigint *biexp, int offset)
bigint *	bi_mod_power (BI_CTX *ctx, bigint *bi, bigint *biexp)
	Perform a modular exponentiation.
bigint *	bi_mod_power2 (BI_CTX *ctx, bigint *bi, bigint *bim, bigint *biexp)
	Perform a modular exponentiation using a temporary modulus.

---

Detailed Description

The bigint implementation as used by the axTLS project.

The bigint library is for RSA encryption/decryption as well as signing. This code tries to minimise use of malloc/free by maintaining a small cache. A bigint context may maintain state by being made "permanent". It be be later released with a bi_depermanent() and bi_free() call.

It supports the following reduction techniques:

• Classical
• Barrett
• Montgomery

It also implements the following:

• Karatsuba multiplication
• Squaring
• Sliding window exponentiation
• Chinese Remainder Theorem (implemented in rsa.c).

All the algorithms used are pretty standard, and designed for different data bus sizes. Negative numbers are not dealt with at all, so a subtraction may need to be tested for negativity.

This library steals some ideas from Jef Poskanzer <http://cs.marlboro.edu/term/cs-fall02/algorithms/crypto/RSA/bigint> and GMP <http://www.swox.com/gmp>. It gets most of its implementation detail from "The Handbook of Applied Cryptography" <http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf>

---

Function Documentation

static bigint * bi_int_multiply	(	BI_CTX *	ctx,
		bigint *	bi,
		comp	i
	)			[static]

Perform a multiply between a bigint an an (unsigned) integer.

Definition at line 317 of file bigint.c.

References alloc(), bi_free(), check, COMP_BIT_SIZE, COMP_BYTE_SIZE, _bigint::comps, memset(), r, _bigint::size, and trim().

Referenced by bi_divide(), and bi_set_mod().

{
    int j = 0, n = bia->size;
    bigint *biR = alloc(ctx, n + 1);
    comp carry = 0;
    comp *r = biR->comps;
    comp *a = bia->comps;

    check(bia);

    /* clear things to start with */
    memset(r, 0, ((n+1)*COMP_BYTE_SIZE));

    do
    {
        long_comp tmp = *r + (long_comp)a[j]*b + carry;
        *r++ = (comp)tmp;              /* downsize */
        carry = (comp)(tmp >> COMP_BIT_SIZE);
    } while (++j < n);

    *r = carry;
    bi_free(ctx, bia);
    return trim(biR);
}

static bigint* bi_int_divide	(	BI_CTX *	ctx,
		bigint *	biR,
		comp	denom
	)			[static]

Referenced by bi_divide().

static bigint * alloc	(	BI_CTX *	ctx,
		int	size
	)			[static]

Definition at line 1039 of file bigint.c.

References abort, BI_CTX::active_count, COMP_BYTE_SIZE, _bigint::comps, BI_CTX::free_count, BI_CTX::free_list, malloc(), _bigint::max_comps, more_comps(), _bigint::next, NULL, printf(), _bigint::refs, and _bigint::size.

Referenced by bi_clone(), bi_divide(), bi_import(), bi_initialize(), bi_int_multiply(), int_to_bi(), and regular_multiply().

{
    bigint *biR;

    /* Can we recycle an old bigint? */
    if (ctx->free_list != NULL)
    {
        biR = ctx->free_list;
        ctx->free_list = biR->next;
        ctx->free_count--;

        if (biR->refs != 0)
        {
#ifdef CONFIG_SSL_FULL_MODE
            printf("alloc: refs was not 0\n");
#endif
            abort();    /* create a stack trace from a core dump */
        }

        more_comps(biR, size);
    }
    else
    {
        /* No free bigints available - create a new one. */
        biR = (bigint *)malloc(sizeof(bigint));
        biR->comps = (comp*)malloc(size * COMP_BYTE_SIZE);
        biR->max_comps = size;  /* give some space to spare */
    }

    biR->size = size;
    biR->refs = 1;
    biR->next = NULL;
    ctx->active_count++;
    return biR;
}

static bigint * trim

(

bigint *

bi

)

[static]

Definition at line 1145 of file bigint.c.

References check, _bigint::comps, and _bigint::size.

Referenced by bi_add(), bi_divide(), bi_import(), bi_int_divide(), bi_int_multiply(), bi_subtract(), and regular_multiply().

{
    check(bi);

    while (bi->comps[bi->size-1] == 0 && bi->size > 1)
    {
        bi->size--;
    }

    return bi;
}

static void more_comps	(	bigint *	bi,
		int	n
	)			[static]

Definition at line 1019 of file bigint.c.

References COMP_BYTE_SIZE, _bigint::comps, max, _bigint::max_comps, memset(), realloc(), and _bigint::size.

Referenced by alloc(), bi_add(), bi_divide(), and bi_subtract().

{
    if (n > bi->max_comps)
    {
        bi->max_comps = max(bi->max_comps * 2, n);
        bi->comps = (comp*)realloc(bi->comps, bi->max_comps * COMP_BYTE_SIZE);
    }

    if (n > bi->size)
    {
        memset(&bi->comps[bi->size], 0, (n-bi->size)*COMP_BYTE_SIZE);
    }

    bi->size = n;
}

BI_CTX* bi_initialize

(

void

)

Start a new bigint context.

Returns:

A bigint context.

Definition at line 78 of file bigint.c.

References alloc(), bi_permanent(), BI_CTX::bi_radix, calloc(), and _bigint::comps.

Referenced by bi_mod_power2(), and RSA_pub_key_new().

{
    /* calloc() sets everything to zero */
    BI_CTX *ctx = (BI_CTX *)calloc(1, sizeof(BI_CTX));
   
    /* the radix */
    ctx->bi_radix = alloc(ctx, 2); 
    ctx->bi_radix->comps[0] = 0;
    ctx->bi_radix->comps[1] = 1;
    bi_permanent(ctx->bi_radix);
    return ctx;
}

void bi_terminate

(

BI_CTX *

ctx

)

Close the bigint context and free any resources.

Free up any used memory - a check is done if all objects were not properly freed.

Parameters:

ctx

[in] The bigint session context.

Definition at line 98 of file bigint.c.

References abort, BI_CTX::active_count, bi_depermanent(), bi_free(), BI_CTX::bi_radix, _bigint::comps, free(), BI_CTX::free_list, _bigint::next, NULL, and printf().

Referenced by bi_mod_power2(), and RSA_free().

{
    bigint *p, *pn;

    bi_depermanent(ctx->bi_radix); 
    bi_free(ctx, ctx->bi_radix);

    if (ctx->active_count != 0)
    {
#ifdef CONFIG_SSL_FULL_MODE
        printf("bi_terminate: there were %d un-freed bigints\n",
                       ctx->active_count);
#endif
        abort();
    }

    for (p = ctx->free_list; p != NULL; p = pn)
    {
        pn = p->next;
        free(p->comps);
        free(p);
    }

    free(ctx);
}

bigint* bi_copy

(

bigint *

bi

)

Increment the number of references to this object.

It does not do a full copy.

Parameters:

bi

[in] The bigint to copy.

Returns:

A reference to the same bigint.

Definition at line 130 of file bigint.c.

References check, PERMANENT, and _bigint::refs.

Referenced by bi_divide().

{
    check(bi);
    if (bi->refs != PERMANENT)
        bi->refs++;
    return bi;
}

void bi_permanent

(

bigint *

bi

)

Simply make a bigint object "unfreeable" if bi_free() is called on it.

For this object to be freed, bi_depermanent() must be called.

Parameters:

bi

[in] The bigint to be made permanent.

Definition at line 144 of file bigint.c.

References abort, check, PERMANENT, printf(), and _bigint::refs.

Referenced by bi_initialize(), bi_mod_power(), bi_set_mod(), RSA_priv_key_new(), and RSA_pub_key_new().

{
    check(bi);
    if (bi->refs != 1)
    {
#ifdef CONFIG_SSL_FULL_MODE
        printf("bi_permanent: refs was not 1\n");
#endif
        abort();
    }

    bi->refs = PERMANENT;
}

void bi_depermanent

(

bigint *

bi

)

Take a permanent object and make it eligible for freedom.

Parameters:

bi

[in] The bigint to be made back to temporary.

Definition at line 162 of file bigint.c.

References abort, check, PERMANENT, printf(), and _bigint::refs.

Referenced by bi_free_mod(), bi_mod_power(), bi_terminate(), and RSA_free().

{
    check(bi);
    if (bi->refs != PERMANENT)
    {
#ifdef CONFIG_SSL_FULL_MODE
        printf("bi_depermanent: bigint was not permanent\n");
#endif
        abort();
    }

    bi->refs = 1;
}

void bi_free	(	BI_CTX *	ctx,
		bigint *	bi
	)

Free a bigint object so it can be used again.

The memory itself it not actually freed, just tagged as being available

Parameters:

	ctx	[in] The bigint session context.
	bi	[in] The bigint to be freed.

Definition at line 183 of file bigint.c.

References abort, BI_CTX::active_count, check, BI_CTX::free_count, BI_CTX::free_list, _bigint::next, PERMANENT, printf(), and _bigint::refs.

Referenced by bi_add(), bi_divide(), bi_export(), bi_free_mod(), bi_int_multiply(), bi_mod_power(), bi_mod_power2(), bi_subtract(), bi_terminate(), regular_multiply(), and RSA_free().

{
    check(bi);
    if (bi->refs == PERMANENT)
    {
        return;
    }

    if (--bi->refs > 0)
    {
        return;
    }

    bi->next = ctx->free_list;
    ctx->free_list = bi;
    ctx->free_count++;

    if (--ctx->active_count < 0)
    {
#ifdef CONFIG_SSL_FULL_MODE
        printf("bi_free: active_count went negative "
                "- double-freed bigint?\n");
#endif
        abort();
    }
}

bigint* int_to_bi	(	BI_CTX *	ctx,
		comp	i
	)

Convert an (unsigned) integer into a bigint.

Parameters:

	ctx	[in] The bigint session context.
	i	[in] The (unsigned) integer to be converted.

Definition at line 216 of file bigint.c.

References alloc(), and _bigint::comps.

Referenced by bi_mod_power().

{
    bigint *biR = alloc(ctx, 1);
    biR->comps[0] = i;
    return biR;
}

bigint* bi_clone	(	BI_CTX *	ctx,
		const bigint *	bi
	)

Do a full copy of the bigint object.

Parameters:

	ctx	[in] The bigint session context.
	bi	[in] The bigint object to be copied.

Definition at line 228 of file bigint.c.

References alloc(), check, COMP_BYTE_SIZE, _bigint::comps, memcpy, and _bigint::size.

Referenced by bi_mod_power(), bi_mod_power2(), and bi_set_mod().

{
    bigint *biR = alloc(ctx, bi->size);
    check(bi);
    memcpy(biR->comps, bi->comps, bi->size*COMP_BYTE_SIZE);
    return biR;
}

bigint* bi_add	(	BI_CTX *	ctx,
		bigint *	bia,
		bigint *	bib
	)

Perform an addition operation between two bigints.

Parameters:

	ctx	[in] The bigint session context.
	bia	[in] A bigint.
	bib	[in] Another bigint.

Returns:

The result of the addition.

Definition at line 243 of file bigint.c.

References bi_free(), check, _bigint::comps, max, more_comps(), _bigint::size, and trim().

Referenced by bi_divide().

{
    int n;
    comp carry = 0;
    comp *pa, *pb;

    check(bia);
    check(bib);

    n = max(bia->size, bib->size);
    more_comps(bia, n+1);
    more_comps(bib, n);
    pa = bia->comps;
    pb = bib->comps;

    do
    {
        comp  sl, rl, cy1;
        sl = *pa + *pb++;
        rl = sl + carry;
        cy1 = sl < *pa;
        carry = cy1 | (rl < sl);
        *pa++ = rl;
    } while (--n != 0);

    *pa = carry;                  /* do overflow */
    bi_free(ctx, bib);
    return trim(bia);
}

bigint* bi_subtract	(	BI_CTX *	ctx,
		bigint *	bia,
		bigint *	bib,
		int *	is_negative
	)

Perform a subtraction operation between two bigints.

Parameters:

	ctx	[in] The bigint session context.
	bia	[in] A bigint.
	bib	[in] Another bigint.
	is_negative	[out] If defined, indicates that the result was negative. is_negative may be null.

Returns:

The result of the subtraction. The result is always positive.

Definition at line 282 of file bigint.c.

References bi_free(), check, _bigint::comps, more_comps(), _bigint::size, and trim().

Referenced by bi_divide().

{
    int n = bia->size;
    comp *pa, *pb, carry = 0;

    check(bia);
    check(bib);

    more_comps(bib, n);
    pa = bia->comps;
    pb = bib->comps;

    do 
    {
        comp sl, rl, cy1;
        sl = *pa - *pb++;
        rl = sl - carry;
        cy1 = sl > *pa;
        carry = cy1 | (rl > sl);
        *pa++ = rl;
    } while (--n != 0);

    if (is_negative)    /* indicate a negative result */
    {
        *is_negative = carry;
    }

    bi_free(ctx, trim(bib));    /* put bib back to the way it was */
    return trim(bia);
}

bigint* bi_divide	(	BI_CTX *	ctx,
		bigint *	u,
		bigint *	v,
		int	is_mod
	)

Does both division and modulo calculations.

Used extensively when doing classical reduction.

Parameters:

	ctx	[in] The bigint session context.
	u	[in] A bigint which is the numerator.
	v	[in] Either the denominator or the modulus depending on the mode.
	is_mod	[n] Determines if this is a normal division (0) or a reduction (1).

Returns:

The result of the division/reduction.

Definition at line 353 of file bigint.c.

References alloc(), bi_add(), bi_compare(), bi_copy(), bi_free(), bi_int_divide(), bi_int_multiply(), BI_CTX::bi_normalised_mod, bi_subtract(), check, COMP_BYTE_SIZE, COMP_RADIX, _bigint::comps, memcpy, memset(), BI_CTX::mod_offset, more_comps(), Q, _bigint::size, trim(), U, V1, and V2.

Referenced by bi_set_mod().

{
    int n = v->size, m = u->size-n;
    int j = 0, orig_u_size = u->size;
    uint8_t mod_offset = ctx->mod_offset;
    comp d;
    bigint *quotient, *tmp_u;
    comp q_dash;

    check(u);
    check(v);

    /* if doing reduction and we are < mod, then return mod */
    if (is_mod && bi_compare(v, u) > 0)
    {
        bi_free(ctx, v);
        return u;
    }

    quotient = alloc(ctx, m+1);
    tmp_u = alloc(ctx, n+1);
    v = trim(v);        /* make sure we have no leading 0's */
    d = (comp)((long_comp)COMP_RADIX/(V1+1));

    /* clear things to start with */
    memset(quotient->comps, 0, ((quotient->size)*COMP_BYTE_SIZE));

    /* normalise */
    if (d > 1)
    {
        u = bi_int_multiply(ctx, u, d);

        if (is_mod)
        {
            v = ctx->bi_normalised_mod[mod_offset];
        }
        else
        {
            v = bi_int_multiply(ctx, v, d);
        }
    }

    if (orig_u_size == u->size)  /* new digit position u0 */
    {
        more_comps(u, orig_u_size + 1);
    }

    do
    {
        /* get a temporary short version of u */
        memcpy(tmp_u->comps, &u->comps[u->size-n-1-j], (n+1)*COMP_BYTE_SIZE);

        /* calculate q' */
        if (U(0) == V1)
        {
            q_dash = COMP_RADIX-1;
        }
        else
        {
            q_dash = (comp)(((long_comp)U(0)*COMP_RADIX + U(1))/V1);
        }

        if (v->size > 1 && V2)
        {
            /* we are implementing the following:
            if (V2*q_dash > (((U(0)*COMP_RADIX + U(1) - 
                    q_dash*V1)*COMP_RADIX) + U(2))) ... */
            comp inner = (comp)((long_comp)COMP_RADIX*U(0) + U(1) - 
                                        (long_comp)q_dash*V1);
            if ((long_comp)V2*q_dash > (long_comp)inner*COMP_RADIX + U(2))
            {
                q_dash--;
            }
        }

        /* multiply and subtract */
        if (q_dash)
        {
            int is_negative;
            tmp_u = bi_subtract(ctx, tmp_u, 
                    bi_int_multiply(ctx, bi_copy(v), q_dash), &is_negative);
            more_comps(tmp_u, n+1);

            Q(j) = q_dash; 

            /* add back */
            if (is_negative)
            {
                Q(j)--;
                tmp_u = bi_add(ctx, tmp_u, bi_copy(v));

                /* lop off the carry */
                tmp_u->size--;
                v->size--;
            }
        }
        else
        {
            Q(j) = 0; 
        }

        /* copy back to u */
        memcpy(&u->comps[u->size-n-1-j], tmp_u->comps, (n+1)*COMP_BYTE_SIZE);
    } while (++j <= m);

    bi_free(ctx, tmp_u);
    bi_free(ctx, v);

    if (is_mod)     /* get the remainder */
    {
        bi_free(ctx, quotient);
        return bi_int_divide(ctx, trim(u), d);
    }
    else            /* get the quotient */
    {
        bi_free(ctx, u);
        return trim(quotient);
    }
}

static bigint* bi_int_divide	(	BI_CTX *ctx	__unused,
		bigint *	biR,
		comp	denom
	)			[static]

Definition at line 476 of file bigint.c.

References check, COMP_BIT_SIZE, _bigint::comps, r, _bigint::size, and trim().

{
    int i = biR->size - 1;
    long_comp r = 0;

    check(biR);

    do
    {
        r = (r<<COMP_BIT_SIZE) + biR->comps[i];
        biR->comps[i] = (comp)(r / denom);
        r %= denom;
    } while (--i != 0);

    return trim(biR);
}

bigint* bi_import	(	BI_CTX *	ctx,
		const uint8_t *	data,
		int	size
	)

Allow a binary sequence to be imported as a bigint.

Parameters:

	ctx	[in] The bigint session context.
	data	[in] The data to be converted.
	size	[in] The number of bytes of data.

Returns:

A bigint representing this data.

Definition at line 589 of file bigint.c.

References alloc(), COMP_BYTE_SIZE, _bigint::comps, memset(), offset, _bigint::size, and trim().

Referenced by RSA_decrypt(), RSA_encrypt(), RSA_priv_key_new(), and RSA_pub_key_new().

{
    bigint *biR = alloc(ctx, (size+COMP_BYTE_SIZE-1)/COMP_BYTE_SIZE);
    int i, j = 0, offset = 0;

    memset(biR->comps, 0, biR->size*COMP_BYTE_SIZE);

    for (i = size-1; i >= 0; i--)
    {
        biR->comps[offset] += data[i] << (j*8);

        if (++j == COMP_BYTE_SIZE)
        {
            j = 0;
            offset ++;
        }
    }

    return trim(biR);
}

void bi_export	(	BI_CTX *	ctx,
		bigint *	x,
		uint8_t *	data,
		int	size
	)

Take a bigint and convert it into a byte sequence.

This is useful after a decrypt operation.

Parameters:

	ctx	[in] The bigint session context.
	x	[in] The bigint to be converted.
	data	[out] The converted data as a byte stream.
	size	[in] The maximum size of the byte stream. Unused bytes will be zeroed.

Definition at line 676 of file bigint.c.

References bi_free(), check, COMP_BYTE_SIZE, _bigint::comps, k, memset(), and _bigint::size.

Referenced by RSA_decrypt(), and RSA_encrypt().

{
    int i, j, k = size-1;

    check(x);
    memset(data, 0, size);  /* ensure all leading 0's are cleared */

    for (i = 0; i < x->size; i++)
    {
        for (j = 0; j < COMP_BYTE_SIZE; j++)
        {
            comp mask = 0xff << (j*8);
            int num = (x->comps[i] & mask) >> (j*8);
            data[k--] = num;

            if (k < 0)
            {
                break;
            }
        }
    }

    bi_free(ctx, x);
}

void bi_set_mod	(	BI_CTX *	ctx,
		bigint *	bim,
		int	mod_offset
	)

Pre-calculate some of the expensive steps in reduction.

This function should only be called once (normally when a session starts). When the session is over, bi_free_mod() should be called. bi_mod_power() relies on this function being called.

Parameters:

	ctx	[in] The bigint session context.
	bim	[in] The bigint modulus that will be used.
	mod_offset	[in] There are three moduluii that can be stored - the standard modulus, and its two primes p and q. This offset refers to which modulus we are referring to.

See also:

bi_free_mod(), bi_mod_power().

Definition at line 714 of file bigint.c.

References bi_clone(), bi_divide(), bi_int_multiply(), bi_mod, BI_CTX::bi_mod, BI_CTX::bi_normalised_mod, bi_permanent(), BI_CTX::bi_radix, COMP_RADIX, _bigint::comps, k, and _bigint::size.

Referenced by bi_mod_power2(), RSA_priv_key_new(), and RSA_pub_key_new().

{
    int k = bim->size;
    comp d = (comp)((long_comp)COMP_RADIX/(bim->comps[k-1]+1));
#ifdef CONFIG_BIGINT_MONTGOMERY
    bigint *R, *R2;
#endif

    ctx->bi_mod[mod_offset] = bim;
    bi_permanent(ctx->bi_mod[mod_offset]);
    ctx->bi_normalised_mod[mod_offset] = bi_int_multiply(ctx, bim, d);
    bi_permanent(ctx->bi_normalised_mod[mod_offset]);

#if defined(CONFIG_BIGINT_MONTGOMERY)
    /* set montgomery variables */
    R = comp_left_shift(bi_clone(ctx, ctx->bi_radix), k-1);     /* R */
    R2 = comp_left_shift(bi_clone(ctx, ctx->bi_radix), k*2-1);  /* R^2 */
    ctx->bi_RR_mod_m[mod_offset] = bi_mod(ctx, R2);             /* R^2 mod m */
    ctx->bi_R_mod_m[mod_offset] = bi_mod(ctx, R);               /* R mod m */

    bi_permanent(ctx->bi_RR_mod_m[mod_offset]);
    bi_permanent(ctx->bi_R_mod_m[mod_offset]);

    ctx->N0_dash[mod_offset] = modular_inverse(ctx->bi_mod[mod_offset]);

#elif defined (CONFIG_BIGINT_BARRETT)
    ctx->bi_mu[mod_offset] = 
        bi_divide(ctx, comp_left_shift(
            bi_clone(ctx, ctx->bi_radix), k*2-1), ctx->bi_mod[mod_offset], 0);
    bi_permanent(ctx->bi_mu[mod_offset]);
#endif
}

void bi_free_mod	(	BI_CTX *	ctx,
		int	mod_offset
	)

Used when cleaning various bigints at the end of a session.

Parameters:

	ctx	[in] The bigint session context.
	mod_offset	[in] The offset to use.

See also:

bi_set_mod().

Definition at line 753 of file bigint.c.

References bi_depermanent(), bi_free(), BI_CTX::bi_mod, and BI_CTX::bi_normalised_mod.

Referenced by bi_mod_power2(), and RSA_free().

{
    bi_depermanent(ctx->bi_mod[mod_offset]);
    bi_free(ctx, ctx->bi_mod[mod_offset]);
#if defined (CONFIG_BIGINT_MONTGOMERY)
    bi_depermanent(ctx->bi_RR_mod_m[mod_offset]);
    bi_depermanent(ctx->bi_R_mod_m[mod_offset]);
    bi_free(ctx, ctx->bi_RR_mod_m[mod_offset]);
    bi_free(ctx, ctx->bi_R_mod_m[mod_offset]);
#elif defined(CONFIG_BIGINT_BARRETT)
    bi_depermanent(ctx->bi_mu[mod_offset]); 
    bi_free(ctx, ctx->bi_mu[mod_offset]);
#endif
    bi_depermanent(ctx->bi_normalised_mod[mod_offset]); 
    bi_free(ctx, ctx->bi_normalised_mod[mod_offset]);
}

static bigint* regular_multiply	(	BI_CTX *	ctx,
		bigint *	bia,
		bigint *	bib
	)			[static]

Perform a standard multiplication between two bigints.

Definition at line 773 of file bigint.c.

References alloc(), bi_free(), check, COMP_BIT_SIZE, COMP_BYTE_SIZE, _bigint::comps, memset(), _bigint::size, and trim().

Referenced by bi_multiply().

{
    int i, j, i_plus_j;
    int n = bia->size; 
    int t = bib->size;
    bigint *biR = alloc(ctx, n + t);
    comp *sr = biR->comps;
    comp *sa = bia->comps;
    comp *sb = bib->comps;

    check(bia);
    check(bib);

    /* clear things to start with */
    memset(biR->comps, 0, ((n+t)*COMP_BYTE_SIZE));
    i = 0;

    do 
    {
        comp carry = 0;
        comp b = *sb++;
        i_plus_j = i;
        j = 0;

        do
        {
            long_comp tmp = sr[i_plus_j] + (long_comp)sa[j]*b + carry;
            sr[i_plus_j++] = (comp)tmp;              /* downsize */
            carry = (comp)(tmp >> COMP_BIT_SIZE);
        } while (++j < n);

        sr[i_plus_j] = carry;
    } while (++i < t);

    bi_free(ctx, bia);
    bi_free(ctx, bib);
    return trim(biR);
}

bigint* bi_multiply	(	BI_CTX *	ctx,
		bigint *	bia,
		bigint *	bib
	)

Perform a multiplication operation between two bigints.

Parameters:

	ctx	[in] The bigint session context.
	bia	[in] A bigint.
	bib	[in] Another bigint.

Returns:

The result of the multiplication.

Definition at line 876 of file bigint.c.

References check, min, regular_multiply(), and _bigint::size.

Referenced by bi_mod_power().

{
    check(bia);
    check(bib);

#ifdef CONFIG_BIGINT_KARATSUBA
    if (min(bia->size, bib->size) < MUL_KARATSUBA_THRESH)
    {
        return regular_multiply(ctx, bia, bib);
    }

    return karatsuba(ctx, bia, bib, 0);
#else
    return regular_multiply(ctx, bia, bib);
#endif
}

int bi_compare	(	bigint *	bia,
		bigint *	bib
	)

Compare two bigints.

Parameters:

	bia	[in] A bigint.
	bib	[in] Another bigint.

Returns:

-1 if smaller, 1 if larger and 0 if equal.

Definition at line 977 of file bigint.c.

References check, _bigint::comps, r, and _bigint::size.

Referenced by bi_divide().

{
    int r, i;

    check(bia);
    check(bib);

    if (bia->size > bib->size)
        r = 1;
    else if (bia->size < bib->size)
        r = -1;
    else
    {
        comp *a = bia->comps; 
        comp *b = bib->comps; 

        /* Same number of components.  Compare starting from the high end
         * and working down. */
        r = 0;
        i = bia->size - 1;

        do 
        {
            if (a[i] > b[i])
            { 
                r = 1;
                break; 
            }
            else if (a[i] < b[i])
            { 
                r = -1;
                break; 
            }
        } while (--i >= 0);
    }

    return r;
}

static int find_max_exp_index

(

bigint *

biexp

)

[static]

Definition at line 1079 of file bigint.c.

References check, COMP_BIT_SIZE, COMP_RADIX, _bigint::comps, _bigint::size, and test.

Referenced by bi_mod_power().

{
    int i = COMP_BIT_SIZE-1;
    comp shift = COMP_RADIX/2;
    comp test = biexp->comps[biexp->size-1];    /* assume no leading zeroes */

    check(biexp);

    do
    {
        if (test & shift)
        {
            return i+(biexp->size-1)*COMP_BIT_SIZE;
        }

        shift >>= 1;
    } while (--i != 0);

    return -1;      /* error - must have been a leading 0 */
}

static int exp_bit_is_one	(	bigint *	biexp,
		int	offset
	)			[static]

Definition at line 1104 of file bigint.c.

References check, COMP_BIT_SIZE, _bigint::comps, and test.

Referenced by bi_mod_power().

{
    comp test = biexp->comps[offset / COMP_BIT_SIZE];
    int num_shifts = offset % COMP_BIT_SIZE;
    comp shift = 1;
    int i;

    check(biexp);

    for (i = 0; i < num_shifts; i++)
    {
        shift <<= 1;
    }

    return test & shift;
}

bigint* bi_mod_power	(	BI_CTX *	ctx,
		bigint *	bi,
		bigint *	biexp
	)

Perform a modular exponentiation.

This function requires bi_set_mod() to have been called previously. This is one of the optimisations used for performance.

Parameters:

	ctx	[in] The bigint session context.
	bi	[in] The bigint on which to perform the mod power operation.
	biexp	[in] The bigint exponent.

See also:

bi_set_mod().

Definition at line 1371 of file bigint.c.

References bi_clone(), bi_depermanent(), bi_free(), bi_multiply(), bi_permanent(), bi_residue, bi_square, check, exp_bit_is_one(), find_max_exp_index(), free(), BI_CTX::g, int_to_bi(), malloc(), BI_CTX::mod_offset, and BI_CTX::window.

Referenced by bi_mod_power2(), RSA_private(), and RSA_public().

{
    int i = find_max_exp_index(biexp), j, window_size = 1;
    bigint *biR = int_to_bi(ctx, 1);

#if defined(CONFIG_BIGINT_MONTGOMERY)
    uint8_t mod_offset = ctx->mod_offset;
    if (!ctx->use_classical)
    {
        /* preconvert */
        bi = bi_mont(ctx, 
                bi_multiply(ctx, bi, ctx->bi_RR_mod_m[mod_offset]));    /* x' */
        bi_free(ctx, biR);
        biR = ctx->bi_R_mod_m[mod_offset];                              /* A */
    }
#endif

    check(bi);
    check(biexp);

#ifdef CONFIG_BIGINT_SLIDING_WINDOW
    for (j = i; j > 32; j /= 5) /* work out an optimum size */
        window_size++;

    /* work out the slide constants */
    precompute_slide_window(ctx, window_size, bi);
#else   /* just one constant */
    ctx->g = (bigint **)malloc(sizeof(bigint *));
    ctx->g[0] = bi_clone(ctx, bi);
    ctx->window = 1;
    bi_permanent(ctx->g[0]);
#endif

    /* if sliding-window is off, then only one bit will be done at a time and
     * will reduce to standard left-to-right exponentiation */
    do
    {
        if (exp_bit_is_one(biexp, i))
        {
            int l = i-window_size+1;
            int part_exp = 0;

            if (l < 0)  /* LSB of exponent will always be 1 */
                l = 0;
            else
            {
                while (exp_bit_is_one(biexp, l) == 0)
                    l++;    /* go back up */
            }

            /* build up the section of the exponent */
            for (j = i; j >= l; j--)
            {
                biR = bi_residue(ctx, bi_square(ctx, biR));
                if (exp_bit_is_one(biexp, j))
                    part_exp++;

                if (j != l)
                    part_exp <<= 1;
            }

            part_exp = (part_exp-1)/2;  /* adjust for array */
            biR = bi_residue(ctx, bi_multiply(ctx, biR, ctx->g[part_exp]));
            i = l-1;
        }
        else    /* square it */
        {
            biR = bi_residue(ctx, bi_square(ctx, biR));
            i--;
        }
    } while (i >= 0);
     
    /* cleanup */
    for (i = 0; i < ctx->window; i++)
    {
        bi_depermanent(ctx->g[i]);
        bi_free(ctx, ctx->g[i]);
    }

    free(ctx->g);
    bi_free(ctx, bi);
    bi_free(ctx, biexp);
#if defined CONFIG_BIGINT_MONTGOMERY
    return ctx->use_classical ? biR : bi_mont(ctx, biR); /* convert back */
#else /* CONFIG_BIGINT_CLASSICAL or CONFIG_BIGINT_BARRETT */
    return biR;
#endif
}

bigint* bi_mod_power2	(	BI_CTX *	ctx,
		bigint *	bi,
		bigint *	bim,
		bigint *	biexp
	)

Perform a modular exponentiation using a temporary modulus.

We need this function to check the signatures of certificates. The modulus of this function is temporary as it's just used for authentication.

Parameters:

	ctx	[in] The bigint session context.
	bi	[in] The bigint to perform the exp/mod.
	bim	[in] The temporary modulus.
	biexp	[in] The bigint exponent.

See also:

bi_set_mod().

Definition at line 1472 of file bigint.c.

References bi_clone(), bi_free(), bi_free_mod(), bi_initialize(), bi_mod_power(), bi_set_mod(), bi_terminate(), and BIGINT_M_OFFSET.

{
    bigint *biR, *tmp_biR;

    /* Set up a temporary bigint context and transfer what we need between
     * them. We need to do this since we want to keep the original modulus
     * which is already in this context. This operation is only called when
     * doing peer verification, and so is not expensive :-) */
    BI_CTX *tmp_ctx = bi_initialize();
    bi_set_mod(tmp_ctx, bi_clone(tmp_ctx, bim), BIGINT_M_OFFSET);
    tmp_biR = bi_mod_power(tmp_ctx, 
                bi_clone(tmp_ctx, bi), 
                bi_clone(tmp_ctx, biexp));
    biR = bi_clone(ctx, tmp_biR);
    bi_free(tmp_ctx, tmp_biR);
    bi_free_mod(tmp_ctx, BIGINT_M_OFFSET);
    bi_terminate(tmp_ctx);

    bi_free(ctx, bi);
    bi_free(ctx, bim);
    bi_free(ctx, biexp);
    return biR;
}