Demo/Linux_Drivers
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
4bc998a131443f3515f2a6f877f1c499f39f150b
Linux_Drivers/fsbl/lib/BigDigits/bigd.c
sam.xiang 4bc998a131 [fsbl] add fsbl for cv181x/cv180x 
Change-Id: I6809bc5016d4bc148f62be2ed3f8e928ec111f19
2023-03-10 20:33:00 +08:00

1564 lines
30 KiB
C
Raw Blame History

/* $Id: bigd.c $ */
/***** BEGIN LICENSE BLOCK *****
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* Copyright (c) 2001-16 David Ireland, D.I. Management Services Pty Limited
* <http://www.di-mgt.com.au/bigdigits.html>. All rights reserved.
*
***** END LICENSE BLOCK *****/
/*
* Last updated:
* $Date: 2016-03-31 09:51:00 $
* $Revision: 2.6.1 $
* $Author: dai $
*/
/* BIGD "bd" wrapper functions around BigDigits "mp" functions */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>
#include "bigd.h"
#include "bigdigits.h"
/* Required for opaque pointers */
#define T BIGD
struct T
{
DIGIT_T *digits; /* Ptr to array of digits, least sig. first */
size_t ndigits; /* No of non-zero significant digits */
size_t maxdigits; /* Max size allocated */
/*int is_signed;*/ /* (for future use) */
};
#define OCTETS_PER_DIGIT (sizeof(bdigit_t))
/*
All these functions MUST make sure that there are always
enough digits before doing anything, and SHOULD reset <ndigits>
afterwards to reflect the final significant size.
-- <maxdigits> is the size allocated (at least one).
-- <ndigits> may be zero.
-- <ndigits> may be too long if MS digits compute to zero so
consider it an upper bound on significant digits, not gospel.
It is an error to pass a NULL BIGD parameter except to bdFree.
*/
#ifdef _DEBUG
static int debug = 0; /* <= change this to > 0 for console debugging */
#else
static int debug = 0; /* <= ALWAYS ZERO */
#endif
/* Useful definitions */
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
T bdNew(void)
{
struct T *p;
p = calloc(1, (long)sizeof(*p));
if (!p)
{
mpFail("bdNew: Failed to calloc memory.");
}
copyright_notice();
/* set up with single zero digit */
p->digits = mpAlloc(1);
p->digits[0] = 0;
p->ndigits = 0;
p->maxdigits = 1;
//p->sign = 0;
return p;
}
void bdFree(T *p)
/* Zeroise and free memory. Set ptr to NULL. */
{
T bd = *p;
if (*p)
{
/* Zeroise them all, just in case */
if (bd->digits)
{
mpSetZero(bd->digits, bd->maxdigits);
free(bd->digits);
}
bd->maxdigits = 0;
bd->ndigits = 0;
free(*p);
}
*p = NULL;
}
static int bd_resize(T b, size_t newsize)
{
/*
Internal fn to re-size a BIGD structure before a calc.
Use carefully!
1. If growing, it allocs more digits and increases maxdigits
2. If shrinking, it decreases ndigits and zeroises the excess.
3. It does not increase b->ndigits; that's up to you later.
4. It does not release excess digits; use bdFree.
In other words, it's like middle-aged spread:
you go from a 32" waist to a 38 but can never go backwards.
Be careful doing the following:-
n = new_size_we_expect;
bd_resize(b, n);
mpFunctionOfSorts(b->digits, n);
b->ndigits = mpSizeof(b->digits, b->ndigits); // NO!
b->ndigits may be set too short
Better:
n = new_size_we_expect;
bd_resize(b, n);
mpFunctionOfSorts(b->digits, n);
b->ndigits = mpSizeof(b->digits, n); // Yes.
*/
size_t i;
/* Check just in case NULL */
assert(b);
assert(b->digits);
/* If we are shrinking, clear high digits */
if (newsize < b->ndigits)
{
for (i = newsize; i < b->ndigits; i++)
b->digits[i] = 0;
b->ndigits = newsize;
return 0;
}
/* We need more room */
if (b->maxdigits < newsize)
{
DIGIT_T *newp, *oldp;
size_t oldsize = b->maxdigits;
/* Increase size of digit array */
//b->digits = (DIGIT_T *)realloc(b->digits, newsize * sizeof(DIGIT_T));
/* -- [v2.2] changed [2008-03-30] to avoid realloc */
newp = (DIGIT_T *)malloc(newsize * sizeof(DIGIT_T));
oldp = b->digits;
/* Check for failure */
if (!newp)
{
mpSetZero(oldp, oldsize);
free(oldp);
mpFail("bd_resize: Failed to realloc memory.");
}
memcpy(newp, oldp, oldsize * sizeof(DIGIT_T));
mpSetZero(oldp, oldsize);
free(oldp);
b->digits = newp;
b->maxdigits = newsize; /* Remember new allocated size */
}
/* Make sure new digits are zero */
for (i = b->ndigits; i < newsize; i++)
b->digits[i] = 0;
return 0;
}
/* New in [v2.6]: A more compact way to allocate and free BIGD variables */
void bdNewVars(BIGD *pb1, ...)
{
BIGD *pbd;
va_list ap;
va_start(ap, pb1);
while ((pbd = va_arg(ap, BIGD*))) {
*pbd = bdNew();
}
va_end(ap);
/* Deal with the first argument */
*pb1 = bdNew();
}
void bdFreeVars(BIGD *pb1, ...)
{
BIGD *pbd;
va_list ap;
/* NB the stdarg macros do not permit programmers to code a function with no fixed arguments
* So this skips the first argument */
va_start(ap, pb1);
while ((pbd = va_arg(ap, BIGD*))) {
bdFree(pbd);
}
va_end(ap);
/* Deal with the first argument */
bdFree(pb1);
}
size_t bdConvFromOctets(T b, const unsigned char *c, size_t nbytes)
/* Converts nbytes octets into big digit b, resizing if necessary */
{
size_t ndigits, n;
assert(b);
ndigits = (nbytes + OCTETS_PER_DIGIT - 1) / OCTETS_PER_DIGIT;
bd_resize(b, ndigits);
n = mpConvFromOctets(b->digits, ndigits, c, nbytes);
b->ndigits = mpSizeof(b->digits, n);
return n;
}
size_t bdConvToOctets(T b, unsigned char *c, size_t nbytes)
/* Convert big digit b into string of octets, in big-endian order,
padding to nbytes or truncating if necessary.
Returns # significant bytes.
If c is NULL or nbytes == 0 then just return required size.
*/
{
size_t noctets, nbits, n;
assert(b);
nbits = mpBitLength(b->digits, b->ndigits);
noctets = (nbits + 7) / 8;
/* [2008-05-23] always return at least 1 */
if (0 == noctets) noctets = 1;
if (!c || 0 == nbytes)
{
return noctets;
}
n = mpConvToOctets(b->digits, b->ndigits, c, nbytes);
return n;
}
size_t bdConvFromHex(T b, const char *s)
/* Converts a hex string into big digit b */
{
size_t ndigits, n;
assert(b);
/* Revision [2006-02-21] */
/* EDIT: ndigits = (strlen(s) / 2 + OCTETS_PER_DIGIT - 1) / OCTETS_PER_DIGIT; */
ndigits = ((strlen(s) + 1) / 2 + OCTETS_PER_DIGIT - 1) / OCTETS_PER_DIGIT;
bd_resize(b, ndigits);
n = mpConvFromHex(b->digits, ndigits, s);
b->ndigits = mpSizeof(b->digits, n);
return n;
}
size_t bdConvToHex(T b, char *s, size_t smax)
{
assert(b);
return mpConvToHex(b->digits, b->ndigits, s, smax);
}
size_t bdConvFromDecimal(BIGD b, const char *s)
{
size_t ndigits, n;
assert(b);
/* approx size but never too small */
ndigits = (strlen(s) / 2 + OCTETS_PER_DIGIT) / OCTETS_PER_DIGIT;
bd_resize(b, ndigits);
n = mpConvFromDecimal(b->digits, ndigits, s);
b->ndigits = n;
return n;
}
size_t bdConvToDecimal(BIGD b, char *s, size_t smax)
{
assert(b);
return mpConvToDecimal(b->digits, b->ndigits, s, smax);
}
int bdSetShort(T b, bdigit_t value)
/* Converts value into a (single-digit) big digit b */
{
assert(b);
bd_resize(b, 1);
b->digits[0] = (DIGIT_T)value;
b->ndigits = (value ? 1 : 0);
return 0;
}
/** Returns the least significant digit in b */
bdigit_t bdToShort(T b)
{
assert(b);
return mpToShort(b->digits, b->ndigits);
}
size_t bdBitLength(T b)
/* Returns base-1 index to most significant bit in b */
{
assert(b);
return mpBitLength(b->digits, b->ndigits);
}
size_t bdSizeof(T b)
/* Returns number of significant non-zero bytes in b */
{
assert(b);
return mpSizeof(b->digits, b->ndigits);
}
/* Print function for bigdigit_t structures [OBSOLETE] */
void bdPrint(T p, size_t flags)
{
size_t n;
assert(p);
n = p->ndigits;
if (n == 0) {
bdSetZero(p); // Added [v2.6]
n = 1;
}
if (flags & BD_PRINT_TRIM) /* Trim leading zeroes */
{
if (flags & BD_PRINT_NL) /* add newlines */
mpPrintTrimNL(p->digits, n);
else
mpPrintTrim(p->digits, n);
}
else
{
if (flags & BD_PRINT_NL) /* add newlines */
mpPrintNL(p->digits, n);
else
mpPrint(p->digits, n);
}
}
void bdPrintHex(const char *prefix, T p, const char *suffix)
{
size_t n;
assert(p);
n = p->ndigits;
if (n == 0) {
bdSetZero(p); // Added [v2.6]
n = 1;
}
mpPrintHex(prefix, p->digits, n, suffix);
}
void bdPrintDecimal(const char *prefix, T p, const char *suffix)
{
size_t n;
assert(p);
n = p->ndigits;
if (n == 0) {
bdSetZero(p); // Added [v2.6]
n = 1;
}
mpPrintDecimal(prefix, p->digits, n, suffix);
}
void bdPrintBits(const char *prefix, T p, const char *suffix)
{
size_t n;
assert(p);
n = p->ndigits;
if (n == 0) {
bdSetZero(p); // Added [v2.6]
n = 1;
}
mpPrintBits(prefix, p->digits, n, suffix);
}
/** Returns true if a == 0, else false */
int bdIsZero(T a)
{
assert(a);
return mpIsZero(a->digits, a->ndigits);
}
int bdIsZero_ct(T a)
{
assert(a);
/* [v2.6] Use constant-time fn */
return mpIsZero_ct(a->digits, a->ndigits);
}
/** Returns true if a == b, else false */
static int isequal_local(T a, T b, int ct)
{
size_t n, na, nb;
assert(a && b);
if (a->ndigits != b->ndigits) {
na = mpSizeof(a->digits, a->ndigits);
nb = mpSizeof(b->digits, b->ndigits);
if (na != nb)
return FALSE;
if (na == 0 && nb == 0)
return TRUE;
n = na;
} else {
n = a->ndigits;
}
/* [v2.5] Use constant-time fn if equal length */
/* [v2.6] ... only if _ct function is called */
if (ct)
return mpEqual_ct(a->digits, b->digits, n);
else
return mpEqual(a->digits, b->digits, n);
}
/** Returns true if a == b, else false */
int bdIsEqual(T a, T b)
{
return isequal_local(a, b, 0);
}
int bdIsEqual_ct(T a, T b)
{
return isequal_local(a, b, 1);
}
/** Returns sign of (a-b) */
static int compare_local(T a, T b, int ct)
{
size_t n, na, nb;
assert(a && b);
if (a->ndigits != b->ndigits) {
na = mpSizeof(a->digits, a->ndigits);
nb = mpSizeof(b->digits, b->ndigits);
if (na > nb) return 1;
if (na < nb) return -1;
n = na;
} else {
n = a->ndigits;
}
/* [v2.5] Use constant-time fn if equal length */
/* [v2.6] ... only if _ct function is called */
if (ct)
return mpCompare_ct(a->digits, b->digits, n);
else
return mpCompare(a->digits, b->digits, n);
}
/** Returns sign of (a-b) */
int bdCompare(T a, T b)
{
return compare_local(a, b, 0);
}
int bdCompare_ct(T a, T b)
{
return compare_local(a, b, 0);
}
/** Returns sign of (a-d) */
int bdShortCmp(T a, bdigit_t d)
{
assert(a);
return mpShortCmp(a->digits, d, a->ndigits);
}
/** Returns true if a == d, else false, where d is a single digit */
int bdShortIsEqual(BIGD a, bdigit_t d)
{
assert(a);
return mpShortIsEqual(a->digits, d, a->ndigits);
}
int bdIsEven(T a)
{
assert(a);
return ISEVEN(a->digits[0]);
}
int bdIsOdd(T a)
{
assert(a);
return ISODD(a->digits[0]);
}
int bdSetEqual(T a, T b)
/* Sets a = b */
{
assert(a && b);
bd_resize(a, b->ndigits);
mpSetEqual(a->digits, b->digits, b->ndigits);
a->ndigits = b->ndigits;
return 0;
}
int bdSetZero(T a)
/* Sets a = 0 */
{
assert(a);
/* [v2.6] changed a->ndigits to a->maxdigits to make sure we clear any residual */
mpSetZero(a->digits, a->maxdigits);
a->ndigits = 0;
return 0;
}
int bdShortAdd(T w, T u, bdigit_t d)
/* Compute w = u + d,
returns 1 if we had a carry */
{
DIGIT_T carry;
size_t dig_size = max(u->ndigits, 1);
assert(w && u);
bd_resize(w, dig_size + 1);
carry = mpShortAdd(w->digits, u->digits, d, dig_size);
/* Cope with overflow */
if (carry)
{
w->digits[dig_size] = carry;
w->ndigits = dig_size + 1;
}
else
w->ndigits = dig_size;
return carry;
}
int bdAdd(T w, T u, T v)
/* Compute w = u + v, w#v */
{
size_t dig_size;
DIGIT_T carry;
assert(w && u && v);
/* Check for cheaper option */
if (v->ndigits == 1)
return bdShortAdd(w, u, v->digits[0]);
/* Make sure u and v are the same size */
dig_size = max(u->ndigits, v->ndigits);
bd_resize(v, dig_size);
bd_resize(u, dig_size);
/* Now make sure w is big enough for sum (incl carry) */
bd_resize(w, dig_size + 1);
/* Finally, do the business */
carry = mpAdd(w->digits, u->digits, v->digits, dig_size);
/* Make sure we've set the right size for w */
if (carry)
{
w->digits[dig_size] = carry;
w->ndigits = dig_size + 1;
}
else
w->ndigits = mpSizeof(w->digits, dig_size);
return carry;
}
int bdAdd_s(T w, T u, T v)
/* Compute w = u + v (safe) */
{
DIGIT_T carry;
T ww;
assert(w && u && v);
/* Use temp */
ww = bdNew();
bdSetEqual(ww, w);
carry = bdAdd(ww, u, v);
bdSetEqual(w, ww);
bdFree(&ww);
return carry;
}
int bdShortSub(T w, T u, bdigit_t d)
/* Compute w = u - d, return borrow */
{
DIGIT_T borrow;
size_t dig_size = max(u->ndigits, 1);
assert(w && u);
bd_resize(w, dig_size);
borrow = mpShortSub(w->digits, u->digits, d, dig_size);
w->ndigits = dig_size;
return borrow;
}
int bdSubtract(T w, T u, T v)
/* Compute w = u - v, return borrow, w#v */
{
size_t dig_size;
DIGIT_T borrow;
assert(w && u && v);
/* Check for cheaper option */
if (v->ndigits == 1)
return bdShortSub(w, u, v->digits[0]);
/* Make sure u and v are the same size */
dig_size = max(u->ndigits, v->ndigits);
bd_resize(v, dig_size);
bd_resize(u, dig_size);
bd_resize(w, dig_size);
/* Finally, do the business */
borrow = mpSubtract(w->digits, u->digits, v->digits, dig_size);
/* Make sure we've set the right size for w */
w->ndigits = mpSizeof(w->digits, dig_size);
return borrow;
}
int bdSubtract_s(T w, T u, T v)
/* Compute w = u - v (safe) */
{
DIGIT_T carry;
T ww;
assert(w && u && v);
/* Use temp */
ww = bdNew();
bdSetEqual(ww, w);
carry = bdSubtract(ww, u, v);
bdSetEqual(w, ww);
bdFree(&ww);
return carry;
}
int bdIncrement(T a)
/* Sets a = a + 1, returns carry */
{
assert(a);
return bdShortAdd(a, a, 1);
}
int bdDecrement(T a)
/* Sets a = a - 1, returns borrow */
{
assert(a);
return bdShortSub(a, a, 1);
}
int bdShortMult(T w, T u, bdigit_t d)
/* Compute w = u * d */
{
DIGIT_T overflow;
size_t dig_size = u->ndigits;
assert(w && u);
/***************************************************/
// [2013-06-05]: catch empty u; make sure w is empty
if (dig_size == 0 || d == 0)
{ /* u == 0 */
bd_resize(w, 0);
return 0;
}
/***************************************************/
bd_resize(w, dig_size+1);
overflow = mpShortMult(w->digits, u->digits, d, dig_size);
/* Cope with overflow */
if (overflow)
{
w->digits[dig_size] = overflow;
w->ndigits = dig_size + 1;
}
else
w->ndigits = mpSizeof(w->digits, dig_size);
return 0;
}
int bdMultiply(T w, T u, T v)
/* Compute w = u * v
-- no overlap permitted
*/
{
size_t dig_size;
assert(w && u && v);
/* Check for cheaper option */
if (v->ndigits == 1)
return bdShortMult(w, u, v->digits[0]);
/* Make sure u and v are the same size */
dig_size = max(u->ndigits, v->ndigits);
bd_resize(v, dig_size);
bd_resize(u, dig_size);
/* Now make sure w is big enough for product */
bd_resize(w, 2 * dig_size);
/* Finally, do the business */
mpMultiply(w->digits, u->digits, v->digits, dig_size);
/* Make sure we've set the right size for w */
w->ndigits = mpSizeof(w->digits, 2 * dig_size);
return 0;
}
int bdMultiply_s(T w, T u, T v)
/* Compute w = u * v (safe) */
{
T ww;
assert(w && u && v);
/* Use temp */
ww = bdNew();
bdSetEqual(ww, w);
bdMultiply(ww, u, v);
bdSetEqual(w, ww);
bdFree(&ww);
return 0;
}
int bdSquare(T w, T x)
/* Computes w = x^2, w#x */
{
size_t dig_size;
assert(w && x);
dig_size = max(x->ndigits, 1);
/* Make sure w is big enough for product */
bd_resize(w, 2 * dig_size);
/* Finally, do the business */
mpSquare(w->digits, x->digits, dig_size);
/* Make sure we've set the right size for w */
w->ndigits = mpSizeof(w->digits, 2 * dig_size);
return 0;
}
int bdSquare_s(T w, T x)
/* Compute w = x^2 (safe) */
{
T ww;
assert(w && x);
/* Use temp */
ww = bdNew();
bdSetEqual(ww, w);
bdSquare(ww, x);
bdSetEqual(w, ww);
bdFree(&ww);
return 0;
}
int bdPower(BIGD y, BIGD g, unsigned short int n)
/* Computes y = g^n (up to available memory!) */
{
BIGD z;
z = bdNew();
/* Use Right-Left Binary */
/* 1. Set y <-- 1, z <-- g */
bdSetShort(y, 1);
bdSetEqual(z, g);
/* If n = 0, output y and stop */
while (n > 0)
{
/* 2. If n is odd, set y <-- z.y */
if (n & 0x1)
bdMultiply_s(y, z, y);
/* 3. Set n <-- [n/2]. If n = 0, output y and stop */
n >>= 1;
if (n > 0)
/* 3b. Otherwise set z <-- z.z and go to step 2 */
bdSquare_s(z, z);
}
bdFree(&z);
/* Result is in y */
return 0;
}
int bdSqrt(BIGD s, BIGD x)
/* Computes integer square root s = floor(sqrt(x)) */
{
size_t dig_size;
int r;
assert(s && x);
dig_size = x->ndigits;
bd_resize(s, dig_size);
r = mpSqrt(s->digits, x->digits, dig_size);
s->ndigits = mpSizeof(s->digits, dig_size);
return r;
}
int bdCubeRoot(BIGD s, BIGD x)
/* Computes integer cube root s = floor(cuberoot(x)) */
{
size_t dig_size;
int r;
assert(s && x);
dig_size = x->ndigits;
bd_resize(s, dig_size);
r = mpCubeRoot(s->digits, x->digits, dig_size);
s->ndigits = mpSizeof(s->digits, dig_size);
return r;
}
int bdShortDiv(T q, T r, T u, bdigit_t d)
/* Computes quotient q = u / d and remainder r = u mod d */
{
DIGIT_T rem;
size_t dig_size;
assert(q && r && u);
dig_size = u->ndigits;
bd_resize(q, dig_size);
rem = mpShortDiv(q->digits, u->digits, d, dig_size);
bdSetShort(r, rem);
q->ndigits = mpSizeof(q->digits, dig_size);
return 0;
}
int bdDivide(T q, T r, T u, T v)
/* Computes quotient q = u / v and remainder r = u mod v
trashes q and r first
*/
{
size_t dig_size;
assert(q && r && u && v);
dig_size = u->ndigits;
bd_resize(q, dig_size);
bd_resize(r, dig_size);
/* Do the business */
mpDivide(q->digits, r->digits, u->digits, dig_size, v->digits, v->ndigits);
/* Set final sizes */
q->ndigits = mpSizeof(q->digits, dig_size);
r->ndigits = mpSizeof(r->digits, dig_size);
return 0;
}
int bdDivide_s(T q, T r, T u, T v)
/* Computes quotient q = u / v and remainder r = u mod v (safe) */
{
size_t dig_size;
BIGD qq, rr;
assert(q && r && u && v);
/* Use temps because mpDivide trashes q and r */
qq = bdNew();
rr = bdNew();
dig_size = u->ndigits;
bd_resize(qq, dig_size);
bd_resize(rr, dig_size);
/* Do the business */
mpDivide(qq->digits, rr->digits, u->digits, dig_size, v->digits, v->ndigits);
/* Copy temps */
qq->ndigits = dig_size;
rr->ndigits = dig_size;
bdSetEqual(q, qq);
bdSetEqual(r, rr);
/* Set final sizes */
q->ndigits = mpSizeof(q->digits, dig_size);
r->ndigits = mpSizeof(r->digits, dig_size);
/* Free temps */
bdFree(&qq);
bdFree(&rr);
return 0;
}
bdigit_t bdShortMod(T r, T u, bdigit_t d)
/* Returns r = u mod d */
{
DIGIT_T rr;
assert(r && u);
rr = mpShortMod(u->digits, d, u->ndigits);
bdSetShort(r, rr);
return rr;
}
int bdModulo(T r, T u, T v)
/* Computes r = u mod v, r#u */
{
size_t nr;
assert(r && u && v);
/* NB r is only vdigits long at most */
nr = v->ndigits;
bd_resize(r, nr);
/* Do the business */
mpModulo(r->digits, u->digits, u->ndigits, v->digits, v->ndigits);
/* Set final size */
r->ndigits = mpSizeof(r->digits, nr);
return 0;
}
int bdModulo_s(T r, T u, T v)
/* Computes r = u mod v (safe) */
{
T rr;
assert(r && u && v);
/* Use temp */
rr = bdNew();
bdSetEqual(rr, r);
bdModulo(rr, u, v);
bdSetEqual(r, rr);
bdFree(&rr);
return 0;
}
int bdSetBit(T a, size_t ibit, int value)
/* Set bit ibit (0..nbits-1) with value 1 or 0
-- increases size if a too small but does not shrink */
{
size_t idigit;
assert(a);
/* Which digit? (0-based) */
idigit = ibit / BITS_PER_DIGIT;
/* Check size */
/* [EDIT v2.1:] change a->maxdigits to a->ndigits */
if (idigit >= a->ndigits)
{
bd_resize(a, idigit+1);
a->ndigits = idigit+1;
}
/* [v2.2] use mp function */
mpSetBit(a->digits, a->ndigits, ibit, value);
/* Set the right size */
a->ndigits = mpSizeof(a->digits, a->ndigits);
return 0;
}
int bdGetBit(T a, size_t ibit)
/* Returns value 1 or 0 of bit ibit (0..nbits-1) */
{
size_t idigit;
assert(a);
/* Which digit? (0-based) */
idigit = ibit / BITS_PER_DIGIT;
/* Check size */
if (idigit >= a->maxdigits)
return 0;
/* [v2.2] use mp function */
return mpGetBit(a->digits, a->ndigits, ibit);
}
void bdShiftLeft(T a, T b, size_t s)
/* Computes a = b << s */
{
/* Increases the size of a if necessary. */
/* [v2.1.0] modified to allow any size of shift */
size_t dig_size = b->ndigits;
assert(a && b);
if (s >= BITS_PER_DIGIT)
dig_size += (s / BITS_PER_DIGIT);
/* Assume overflow */
dig_size++;
/* Make sure both big enough */
bd_resize(a, dig_size);
bd_resize(b, dig_size);
/* Set the final size */
mpShiftLeft(a->digits, b->digits, s, dig_size);
a->ndigits = mpSizeof(a->digits, dig_size);
}
void bdShiftRight(T a, T b, size_t n)
/* Computes a = b >> n */
{
/* Throws away shifted bits */
/* [v2.1.0] modified to allow any size of shift */
size_t dig_size = b->ndigits;
assert(a && b);
bd_resize(a, dig_size);
mpShiftRight(a->digits, b->digits, n, dig_size);
/* Set the final size */
a->ndigits = mpSizeof(a->digits, dig_size);
}
void bdXorBits(T a, T b, T c)
/* Computes bitwise operation a = b XOR c */
{
size_t n;
assert(a && b && c);
/* Make sure all variables are the same size */
n = max(b->ndigits, c->ndigits);
bd_resize(a, n);
bd_resize(b, n);
bd_resize(c, n);
/* Do the business */
mpXorBits(a->digits, b->digits, c->digits, n);
/* Set the final size */
a->ndigits = mpSizeof(a->digits, n);
}
void bdOrBits(T a, T b, T c)
/* Computes bitwise operation a = b OR c */
{
size_t n;
assert(a && b && c);
/* Make sure all variables are the same size */
n = max(b->ndigits, c->ndigits);
bd_resize(a, n);
bd_resize(b, n);
bd_resize(c, n);
/* Do the business */
mpOrBits(a->digits, b->digits, c->digits, n);
/* Set the final size */
a->ndigits = mpSizeof(a->digits, n);
}
void bdAndBits(T a, T b, T c)
/* Computes bitwise operation a = b AND c */
{
size_t n;
assert(a && b && c);
/* Make sure all variables are the same size */
n = max(b->ndigits, c->ndigits);
bd_resize(a, n);
bd_resize(b, n);
bd_resize(c, n);
/* Do the business */
mpAndBits(a->digits, b->digits, c->digits, n);
/* Set the final size */
a->ndigits = mpSizeof(a->digits, n);
}
void bdNotBits(BIGD a, BIGD b)
/* Computes bitwise a = NOT b */
{
size_t n;
assert(a && b);
/* Make sure all variables are the same size */
n = b->ndigits;
bd_resize(a, n);
/* Do the business */
mpNotBits(a->digits, b->digits, n);
/* Set the final size */
a->ndigits = mpSizeof(a->digits, n);
}
void bdModPowerOf2(BIGD a, size_t L)
/* Computes a = a mod 2^L */
{
size_t n;
assert(a);
n = a->ndigits;
/* Do the business */
mpModPowerOf2(a->digits, n, L);
/* Set the final size */
a->ndigits = mpSizeof(a->digits, n);
}
/** Compute y = x^e mod m, x,e < m */
static int modexp_internal(T y, T x, T e, T m, int constant_time)
{
size_t n;
int status;
assert(y && x && e && m);
/* Make sure all variables are the same size */
n = max(e->ndigits, m->ndigits);
n = max(x->ndigits, n);
bd_resize(y, n);
bd_resize(x, n);
bd_resize(e, n);
bd_resize(m, n);
/* Finally, do the business */
if (constant_time)
status = mpModExp_ct(y->digits, x->digits, e->digits, m->digits, n);
else
status = mpModExp(y->digits, x->digits, e->digits, m->digits, n);
y->ndigits = mpSizeof(y->digits, n);
return status;
}
/** Compute y = x^e mod m, x,e < m */
int bdModExp(BIGD y, BIGD x, BIGD e, BIGD m)
{
return modexp_internal(y, x, e, m, 0);
}
/** Compute y = x^e mod m in constant time */
int bdModExp_ct(BIGD y, BIGD x, BIGD e, BIGD m)
{
return modexp_internal(y, x, e, m, 1);
}
/** Compute a = (x * y) mod m */
int bdModMult(T a, T x, T y, T m)
{
size_t n;
int status;
assert(a && x && y && m);
/* Make sure all variables are the same size */
n = max(y->ndigits, m->ndigits);
n = max(x->ndigits, n);
bd_resize(a, n);
bd_resize(y, n);
bd_resize(x, n);
bd_resize(m, n);
/* Do the business */
status = mpModMult(a->digits, x->digits, y->digits, m->digits, n);
a->ndigits = mpSizeof(a->digits, n);
return status;
}
/** Computes a = x^2 mod m */
int bdModSquare(BIGD a, BIGD x, BIGD m)
{
size_t n;
int status;
assert(a && x && m);
/* Make sure all variables are the same size */
n = max(x->ndigits, m->ndigits);
bd_resize(a, n);
bd_resize(x, n);
bd_resize(m, n);
/* Do the business */
status = mpModSquare(a->digits, x->digits, m->digits, n);
a->ndigits = mpSizeof(a->digits, n);
return status;
}
/** Computes x = sqrt(a) mod p */
int bdModSqrt(BIGD x, BIGD a, BIGD p)
{
size_t n;
int status;
assert(x && a && p);
/* Make sure all variables are the same size */
n = max(a->ndigits, p->ndigits);
bd_resize(x, n);
bd_resize(a, n);
bd_resize(p, n);
/* Do the business */
status = mpModSqrt(x->digits, a->digits, p->digits, n);
x->ndigits = mpSizeof(x->digits, n);
return status;
}
/** Computes w = u/2 (mod p) for an odd prime p */
void bdModHalve(BIGD w, const BIGD u, const BIGD p)
{
size_t n;
assert(w && u && p);
/* Make sure all variables are the same size */
n = max(u->ndigits, p->ndigits);
bd_resize(w, n);
bd_resize(u, n);
bd_resize(p, n);
/* Do the business */
mpModHalve(w->digits, u->digits, p->digits, n);
w->ndigits = mpSizeof(w->digits, n);
}
/* Computes w = u + v (mod m) for 0 <= u,v < m*/
void bdModAdd(BIGD w, BIGD u, BIGD v, BIGD m)
{
size_t n;
assert(w && u && v && m);
/* Make sure all variables are the same size */
n = max(v->ndigits, m->ndigits);
n = max(u->ndigits, n);
bd_resize(w, n);
bd_resize(u, n);
bd_resize(v, n);
bd_resize(m, n);
/* Do the business */
mpModAdd(w->digits, u->digits, v->digits, m->digits, n);
w->ndigits = mpSizeof(w->digits, n);
}
/* Computes w = u - v (mod m) for 0 <= u,v < m*/
void bdModSub(BIGD w, BIGD u, BIGD v, BIGD m)
{
size_t n;
assert(w && u && v && m);
/* Make sure all variables are the same size */
n = max(v->ndigits, m->ndigits);
n = max(u->ndigits, n);
bd_resize(w, n);
bd_resize(u, n);
bd_resize(v, n);
bd_resize(m, n);
/* Do the business */
mpModSub(w->digits, u->digits, v->digits, m->digits, n);
w->ndigits = mpSizeof(w->digits, n);
}
/** Compute x = a^-1 mod m */
int bdModInv(T x, T a, T m)
{
size_t n;
int status;
assert(x && a && m);
/* Make sure all variables are the same size */
n = max(a->ndigits, m->ndigits);
bd_resize(x, n);
bd_resize(a, n);
bd_resize(m, n);
/* Do the business */
status = mpModInv(x->digits, a->digits, m->digits, n);
x->ndigits = mpSizeof(x->digits, n);
return status;
}
int bdGcd(T g, T x, T y)
/* Compute g = gcd(x, y) */
{
size_t n;
int status;
assert(g && x && y);
n = max(x->ndigits, y->ndigits);
bd_resize(g, n);
bd_resize(y, n);
bd_resize(x, n);
/* Do the business */
status = mpGcd(g->digits, x->digits, y->digits, n);
g->ndigits = mpSizeof(g->digits, n);
return status;
}
int bdJacobi(T a, T m)
/* Returns Jacobi(a, m) = {0, +1, -1} */
{
size_t n; /* Careful with n and m here! */
int status;
assert(a && m);
n = max(a->ndigits, m->ndigits);
bd_resize(a, n);
bd_resize(m, n);
/* Do the business */
status = mpJacobi(a->digits, m->digits, n);
return status;
}
int bdIsPrime(T b, size_t ntests)
/* Returns true if passes ntests x Miller-Rabin tests */
{
assert(b);
return (mpIsPrime(b->digits, b->ndigits, ntests));
}
int bdRabinMiller(T b, size_t ntests)
/* Returns true if passes ntests x Miller-Rabin tests without trial division */
{
assert(b);
return (mpRabinMiller(b->digits, b->ndigits, ntests));
}
/* [Version 2.1: bdRandDigit moved to bdRand.c] */
/* Make a random BIGD of up to `ndigits` digits
-- NB just for doing tests
Return # digits actually set
*/
size_t bdSetRandTest(T a, size_t ndigits)
{
/* Re-written [v2.6] */
size_t n;
size_t nbitstarget = ndigits * BITS_PER_DIGIT;
/* Half the time, pick a shorter bitlength at random from [4,nbits]
so at least a >= 16 */
if (spSimpleRand(0, 1)) {
n = (size_t)spSimpleRand(4, (DIGIT_T)nbitstarget);
}
else {
n = nbitstarget;
}
bdQuickRandBits(a, n);
/* Make sure a > 1 */
if (bdShortCmp(a, 2) < 0)
bdQuickRandBits(a, nbitstarget);
return bdSizeof(a);
}
/** Generate a quick-and-dirty random number a <= 2^{nbits}-1 using plain-old-rand
* @return Number of digits actually set
* @remark Not crypto secure
*/ /* Added [v2.4] */
size_t bdQuickRandBits(T a, size_t nbits)
{
size_t n;
assert(a);
n = (nbits + BITS_PER_DIGIT - 1) / BITS_PER_DIGIT;
bd_resize(a, n);
n = mpQuickRandBits(a->digits, n, nbits);
a->ndigits = n;
return n;
}
int bdRandomSeeded(T a, size_t nbits, const unsigned char *seed,
size_t seedlen, BD_RANDFUNC RandFunc)
/* Create a random mp digit at most nbits long
-- high bit may or may not be set
-- Uses whatever RNG function the user specifies */
{
size_t i, hibit, ndigits, nbytes;
DIGIT_T chop;
assert(a);
/* Make sure big enough */
ndigits = (nbits + BITS_PER_DIGIT - 1) / BITS_PER_DIGIT;
bd_resize(a, ndigits);
nbytes = ndigits * sizeof(DIGIT_T);
/* Generate random bytes using callback function */
RandFunc((unsigned char *)a->digits, nbytes, seed, seedlen);
/* Clear unwanted high bits */
hibit = (nbits-1) % BITS_PER_DIGIT;
for (chop = 0x01, i = 0; i < hibit; i++)
chop = (chop << 1) | chop;
a->digits[ndigits-1] &= chop;
a->ndigits = ndigits;
return 0;
}
int bdGeneratePrime(T b, size_t nbits, size_t ntests,
const unsigned char *seed, size_t seedlen, BD_RANDFUNC RandFunc)
{
size_t i, hibit, ndigits, nbytes;
DIGIT_T mask, chop;
DIGIT_T *p;
int done;
size_t iloop, maxloops, j, maxodd;
assert(b);
/* Make sure big enough */
ndigits = (nbits + BITS_PER_DIGIT - 1) / BITS_PER_DIGIT;
bd_resize(b, ndigits);
nbytes = ndigits * sizeof(DIGIT_T);
/* use a ptr */
p = b->digits;
maxloops = 5;
maxodd = 100 * nbits;
done = 0;
for (iloop = 0; !done && iloop < maxloops; iloop++)
{
/* Generate random digits using callback function */
RandFunc((unsigned char *)p, nbytes, seed, seedlen);
/* Set high and low bits */
hibit = (nbits-1) % BITS_PER_DIGIT;
mask = 0x01 << hibit;
for (chop = 0x01, i = 0; i < hibit; i++)
chop = (chop << 1) | chop;
p[ndigits-1] |= mask;
p[ndigits-1] &= chop;
p[0] |= 0x01;
/* Try each odd number until success or too many tries */
for (j = 0; !done && j < maxodd; j++, mpShortAdd(p, p, 2, ndigits))
{
if (!(p[ndigits-1] & mask))
break; /* Catch overflow */
if (debug) mpPrintNL(p, ndigits);
if (mpIsPrime(p, ndigits, ntests))
{
done = 1;
break;
}
}
}
if (debug) mpPrintNL(p, ndigits);
b->ndigits = ndigits;
return (done ? 0 : 1);
}
/* Version Info - added in [v2.0.2] */
int bdVersion(void)
{
return mpVersion();
}
/* Added [v2.6] */
const char *bdCompileTime(void)
{
return __DATE__" "__TIME__;
}
Reference in New Issue View Git Blame Copy Permalink