private static BigIntegerBC createUValueOf(
ulong value)
{
int msw = (int)(value >> 32);
int lsw = (int)value;
if (msw != 0)
return new BigIntegerBC(1, new int[] { msw, lsw }, false);
if (lsw != 0)
{
BigIntegerBC n = new BigIntegerBC(1, new int[] { lsw }, false);
// Check for a power of two
if ((lsw & -lsw) == lsw)
{
n.nBits = 1;
}
return n;
}
return Zero;
}
public BigIntegerBC ShiftLeft(
int n)
{
if (sign == 0 || magnitude.Length == 0)
return Zero;
if (n == 0)
return this;
if (n < 0)
return ShiftRight(-n);
BigIntegerBC result = new BigIntegerBC(sign, ShiftLeft(magnitude, n), true);
if (this.nBits != -1)
{
result.nBits = sign > 0
? this.nBits
: this.nBits + n;
}
if (this.nBitLength != -1)
{
result.nBitLength = this.nBitLength + n;
}
return result;
}
public BigIntegerBC Subtract(
BigIntegerBC n)
{
if (n.sign == 0)
return this;
if (this.sign == 0)
return n.Negate();
if (this.sign != n.sign)
return Add(n.Negate());
int compare = CompareNoLeadingZeroes(0, magnitude, 0, n.magnitude);
if (compare == 0)
return Zero;
BigIntegerBC bigun, lilun;
if (compare < 0)
{
bigun = n;
lilun = this;
}
else
{
bigun = this;
lilun = n;
}
return new BigIntegerBC(this.sign * compare, doSubBigLil(bigun.magnitude, lilun.magnitude), true);
}
public BigIntegerBC Multiply(
BigIntegerBC val)
{
if (sign == 0 || val.sign == 0)
return Zero;
if (val.QuickPow2Check()) // val is power of two
{
BigIntegerBC result = this.ShiftLeft(val.Abs().BitLength - 1);
return val.sign > 0 ? result : result.Negate();
}
if (this.QuickPow2Check()) // this is power of two
{
BigIntegerBC result = val.ShiftLeft(this.Abs().BitLength - 1);
return this.sign > 0 ? result : result.Negate();
}
int maxBitLength = this.BitLength + val.BitLength;
int resLength = (maxBitLength + BitsPerInt - 1) / BitsPerInt;
int[] res = new int[resLength];
if (val == this)
{
Square(res, this.magnitude);
}
else
{
Multiply(res, this.magnitude, val.magnitude);
}
return new BigIntegerBC(sign * val.sign, res, true);
}
public BigIntegerBC Remainder(
BigIntegerBC n)
{
if (n.sign == 0)
throw new ArithmeticException("Division by zero error");
if (this.sign == 0)
return Zero;
// For small values, use fast remainder method
if (n.magnitude.Length == 1)
{
int val = n.magnitude[0];
if (val > 0)
{
if (val == 1)
return Zero;
// TODO Make this func work on uint, and handle val == 1?
int rem = Remainder(val);
return rem == 0
? Zero
: new BigIntegerBC(sign, new int[] { rem }, false);
}
}
if (CompareNoLeadingZeroes(0, magnitude, 0, n.magnitude) < 0)
return this;
int[] result;
if (n.QuickPow2Check()) // n is power of two
{
// TODO Move before small values branch above?
result = LastNBits(n.Abs().BitLength - 1);
}
else
{
result = (int[])this.magnitude.Clone();
result = Remainder(result, n.magnitude);
}
return new BigIntegerBC(sign, result, true);
}
public BigIntegerBC AndNot(
BigIntegerBC val)
{
return And(val.Not());
}
public BigIntegerBC[] DivideAndRemainder(
BigIntegerBC val)
{
if (val.sign == 0)
throw new ArithmeticException("Division by zero error");
BigIntegerBC[] biggies = new BigIntegerBC[2];
if (sign == 0)
{
biggies[0] = Zero;
biggies[1] = Zero;
}
else if (val.QuickPow2Check()) // val is power of two
{
int e = val.Abs().BitLength - 1;
BigIntegerBC quotient = this.Abs().ShiftRight(e);
int[] remainder = this.LastNBits(e);
biggies[0] = val.sign == this.sign ? quotient : quotient.Negate();
biggies[1] = new BigIntegerBC(this.sign, remainder, true);
}
else
{
int[] remainder = (int[])this.magnitude.Clone();
int[] quotient = Divide(remainder, val.magnitude);
biggies[0] = new BigIntegerBC(this.sign * val.sign, quotient, true);
biggies[1] = new BigIntegerBC(this.sign, remainder, true);
}
return biggies;
}
public BigIntegerBC ModInverse(
BigIntegerBC m)
{
if (m.sign < 1)
throw new ArithmeticException("Modulus must be positive");
// TODO Too slow at the moment
// // "Fast Key Exchange with Elliptic Curve Systems" R.Schoeppel
// if (m.TestBit(0))
// {
// //The Almost Inverse Algorithm
// int k = 0;
// BigIntegerBC B = One, C = Zero, F = this, G = m, tmp;
//
// for (;;)
// {
// // While F is even, do F=F/u, C=C*u, k=k+1.
// int zeroes = F.GetLowestSetBit();
// if (zeroes > 0)
// {
// F = F.ShiftRight(zeroes);
// C = C.ShiftLeft(zeroes);
// k += zeroes;
// }
//
// // If F = 1, then return B,k.
// if (F.Equals(One))
// {
// BigIntegerBC half = m.Add(One).ShiftRight(1);
// BigIntegerBC halfK = half.ModPow(BigIntegerBC.ValueOf(k), m);
// return B.Multiply(halfK).Mod(m);
// }
//
// if (F.CompareTo(G) < 0)
// {
// tmp = G; G = F; F = tmp;
// tmp = B; B = C; C = tmp;
// }
//
// F = F.Add(G);
// B = B.Add(C);
// }
// }
BigIntegerBC x = new BigIntegerBC();
BigIntegerBC gcd = ExtEuclid(this, m, x, null);
if (!gcd.Equals(One))
throw new ArithmeticException("Numbers not relatively prime.");
if (x.sign < 0)
{
x.sign = 1;
//x = m.Subtract(x);
x.magnitude = doSubBigLil(m.magnitude, x.magnitude);
}
return x;
}
/**
* Calculate the numbers u1, u2, and u3 such that:
*
* u1 * a + u2 * b = u3
*
* where u3 is the greatest common divider of a and b.
* a and b using the extended Euclid algorithm (refer p. 323
* of The Art of Computer Programming vol 2, 2nd ed).
* This also seems to have the side effect of calculating
* some form of multiplicative inverse.
*
* @param a First number to calculate gcd for
* @param b Second number to calculate gcd for
* @param u1Out the return object for the u1 value
* @param u2Out the return object for the u2 value
* @return The greatest common divisor of a and b
*/
private static BigIntegerBC ExtEuclid(
BigIntegerBC a,
BigIntegerBC b,
BigIntegerBC u1Out,
BigIntegerBC u2Out)
{
BigIntegerBC u1 = One;
BigIntegerBC u3 = a;
BigIntegerBC v1 = Zero;
BigIntegerBC v3 = b;
while (v3.sign > 0)
{
BigIntegerBC[] q = u3.DivideAndRemainder(v3);
BigIntegerBC tmp = v1.Multiply(q[0]);
BigIntegerBC tn = u1.Subtract(tmp);
u1 = v1;
v1 = tn;
u3 = v3;
v3 = q[1];
}
if (u1Out != null)
{
u1Out.sign = u1.sign;
u1Out.magnitude = u1.magnitude;
}
if (u2Out != null)
{
BigIntegerBC tmp = u1.Multiply(a);
tmp = u3.Subtract(tmp);
BigIntegerBC res = tmp.Divide(b);
u2Out.sign = res.sign;
u2Out.magnitude = res.magnitude;
}
return u3;
}
public BigIntegerBC Min(
BigIntegerBC value)
{
return CompareTo(value) < 0 ? this : value;
}
public BigIntegerBC Mod(
BigIntegerBC m)
{
if (m.sign < 1)
throw new ArithmeticException("Modulus must be positive");
BigIntegerBC biggie = Remainder(m);
return (biggie.sign >= 0 ? biggie : biggie.Add(m));
}
public BigIntegerBC Max(
BigIntegerBC value)
{
return CompareTo(value) > 0 ? this : value;
}
internal bool RabinMillerTest(
int certainty,
Random random)
{
Debug.Assert(certainty > 0);
Debug.Assert(BitLength > 2);
Debug.Assert(TestBit(0));
// let n = 1 + d . 2^s
BigIntegerBC n = this;
BigIntegerBC nMinusOne = n.Subtract(One);
int s = nMinusOne.GetLowestSetBit();
BigIntegerBC r = nMinusOne.ShiftRight(s);
Debug.Assert(s >= 1);
do
{
// TODO Make a method for random BigIntegerBCs in range 0 < x < n)
// - Method can be optimized by only replacing examined bits at each trial
BigIntegerBC a;
do
{
a = new BigIntegerBC(n.BitLength, random);
}
while (a.CompareTo(One) <= 0 || a.CompareTo(nMinusOne) >= 0);
BigIntegerBC y = a.ModPow(r, n);
if (!y.Equals(One))
{
int j = 0;
while (!y.Equals(nMinusOne))
{
if (++j == s)
return false;
y = y.ModPow(Two, n);
if (y.Equals(One))
return false;
}
}
certainty -= 2; // composites pass for only 1/4 possible 'a'
}
while (certainty > 0);
return true;
}
public BigIntegerBC Gcd(
BigIntegerBC value)
{
if (value.sign == 0)
return Abs();
if (sign == 0)
return value.Abs();
BigIntegerBC r;
BigIntegerBC u = this;
BigIntegerBC v = value;
while (v.sign != 0)
{
r = u.Mod(v);
u = v;
v = r;
}
return u;
}
public BigIntegerBC Add(
BigIntegerBC value)
{
if (this.sign == 0)
return value;
if (this.sign != value.sign)
{
if (value.sign == 0)
return this;
if (value.sign < 0)
return Subtract(value.Negate());
return value.Subtract(Negate());
}
return AddToMagnitude(value.magnitude);
}
public BigIntegerBC ModPow(
BigIntegerBC exponent,
BigIntegerBC m)
{
if (m.sign < 1)
throw new ArithmeticException("Modulus must be positive");
if (m.Equals(One))
return Zero;
if (exponent.sign == 0)
return One;
if (sign == 0)
return Zero;
int[] zVal = null;
int[] yAccum = null;
int[] yVal;
// Montgomery exponentiation is only possible if the modulus is odd,
// but AFAIK, this is always the case for crypto algo's
bool useMonty = ((m.magnitude[m.magnitude.Length - 1] & 1) == 1);
long mQ = 0;
if (useMonty)
{
mQ = m.GetMQuote();
// tmp = this * R mod m
BigIntegerBC tmp = ShiftLeft(32 * m.magnitude.Length).Mod(m);
zVal = tmp.magnitude;
useMonty = (zVal.Length <= m.magnitude.Length);
if (useMonty)
{
yAccum = new int[m.magnitude.Length + 1];
if (zVal.Length < m.magnitude.Length)
{
int[] longZ = new int[m.magnitude.Length];
zVal.CopyTo(longZ, longZ.Length - zVal.Length);
zVal = longZ;
}
}
}
if (!useMonty)
{
if (magnitude.Length <= m.magnitude.Length)
{
//zAccum = new int[m.magnitude.Length * 2];
zVal = new int[m.magnitude.Length];
magnitude.CopyTo(zVal, zVal.Length - magnitude.Length);
}
else
{
//
// in normal practice we'll never see this...
//
BigIntegerBC tmp = Remainder(m);
//zAccum = new int[m.magnitude.Length * 2];
zVal = new int[m.magnitude.Length];
tmp.magnitude.CopyTo(zVal, zVal.Length - tmp.magnitude.Length);
}
yAccum = new int[m.magnitude.Length * 2];
}
yVal = new int[m.magnitude.Length];
//
// from LSW to MSW
//
for (int i = 0; i < exponent.magnitude.Length; i++)
{
int v = exponent.magnitude[i];
int bits = 0;
if (i == 0)
{
while (v > 0)
{
v <<= 1;
bits++;
}
//
// first time in initialise y
//
zVal.CopyTo(yVal, 0);
v <<= 1;
bits++;
}
while (v != 0)
{
if (useMonty)
{
// Montgomery square algo doesn't exist, and a normal
// square followed by a Montgomery reduction proved to
// be almost as heavy as a Montgomery mulitply.
MultiplyMonty(yAccum, yVal, yVal, m.magnitude, mQ);
}
else
{
Square(yAccum, yVal);
Remainder(yAccum, m.magnitude);
Array.Copy(yAccum, yAccum.Length - yVal.Length, yVal, 0, yVal.Length);
ZeroOut(yAccum);
}
bits++;
if (v < 0)
{
if (useMonty)
{
MultiplyMonty(yAccum, yVal, zVal, m.magnitude, mQ);
}
else
{
Multiply(yAccum, yVal, zVal);
Remainder(yAccum, m.magnitude);
Array.Copy(yAccum, yAccum.Length - yVal.Length, yVal, 0,
yVal.Length);
ZeroOut(yAccum);
}
}
v <<= 1;
}
while (bits < 32)
{
if (useMonty)
{
MultiplyMonty(yAccum, yVal, yVal, m.magnitude, mQ);
}
else
{
Square(yAccum, yVal);
Remainder(yAccum, m.magnitude);
Array.Copy(yAccum, yAccum.Length - yVal.Length, yVal, 0, yVal.Length);
ZeroOut(yAccum);
}
bits++;
}
}
if (useMonty)
{
// Return y * R^(-1) mod m by doing y * 1 * R^(-1) mod m
ZeroOut(zVal);
zVal[zVal.Length - 1] = 1;
MultiplyMonty(yAccum, yVal, zVal, m.magnitude, mQ);
}
BigIntegerBC result = new BigIntegerBC(1, yVal, true);
return exponent.sign > 0
? result
: result.ModInverse(m);
}
public BigIntegerBC And(
BigIntegerBC value)
{
if (this.sign == 0 || value.sign == 0)
{
return Zero;
}
int[] aMag = this.sign > 0
? this.magnitude
: Add(One).magnitude;
int[] bMag = value.sign > 0
? value.magnitude
: value.Add(One).magnitude;
bool resultNeg = sign < 0 && value.sign < 0;
int resultLength = System.Math.Max(aMag.Length, bMag.Length);
int[] resultMag = new int[resultLength];
int aStart = resultMag.Length - aMag.Length;
int bStart = resultMag.Length - bMag.Length;
for (int i = 0; i < resultMag.Length; ++i)
{
int aWord = i >= aStart ? aMag[i - aStart] : 0;
int bWord = i >= bStart ? bMag[i - bStart] : 0;
if (this.sign < 0)
{
aWord = ~aWord;
}
if (value.sign < 0)
{
bWord = ~bWord;
}
resultMag[i] = aWord & bWord;
if (resultNeg)
{
resultMag[i] = ~resultMag[i];
}
}
BigIntegerBC result = new BigIntegerBC(1, resultMag, true);
// TODO Optimise this case
if (resultNeg)
{
result = result.Not();
}
return result;
}
public BigIntegerBC Modulus(
BigIntegerBC val)
{
return this.Mod(val);
}
public int CompareTo(
BigIntegerBC value)
{
return sign < value.sign ? -1
: sign > value.sign ? 1
: sign == 0 ? 0
: sign * CompareNoLeadingZeroes(0, magnitude, 0, value.magnitude);
}
public BigIntegerBC Divide(
BigIntegerBC val)
{
if (val.sign == 0)
throw new ArithmeticException("Division by zero error");
if (sign == 0)
return Zero;
if (val.QuickPow2Check()) // val is power of two
{
BigIntegerBC result = this.Abs().ShiftRight(val.Abs().BitLength - 1);
return val.sign == this.sign ? result : result.Negate();
}
int[] mag = (int[])this.magnitude.Clone();
return new BigIntegerBC(this.sign * val.sign, Divide(mag, val.magnitude), true);
}