public ModulusRing(BigInteger modulus) { _mod = modulus; // calculate constant = b^ (2k) / m var i = _mod._length << 1; _constant = new BigInteger(Sign.Positive, i + 1); _constant._data[i] = 0x00000001; _constant = _constant/_mod; }
public static byte[] Calculate(BigInteger.BigInteger a, BigInteger.BigInteger b) { byte[] bytes; lock (Locker) bytes = a.ModPow(b, Prime).GetBytes(); if (bytes.Length < 96) { var oldBytes = bytes; bytes = new byte[96]; Array.Copy(oldBytes, 0, bytes, 96 - oldBytes.Length, oldBytes.Length); for (var i = 0; i < (96 - oldBytes.Length); i++) { bytes[i] = 0; } } return(bytes); }
private static BigInteger[] DwordDivMod(BigInteger n, uint d) { var ret = new BigInteger(Sign.Positive, n._length); ulong r = 0; var i = n._length; while (i-- > 0) { r <<= 32; r |= n._data[i]; ret._data[i] = (uint) (r/d); r %= d; } ret.Normalize(); BigInteger rem = (uint) r; return new[] {ret, rem}; }
public BigInteger(BigInteger bi, uint len) { _data = new uint[len]; for (uint i = 0; i < bi._length; i++) _data[i] = bi._data[i]; _length = bi._length; }
public static BigInteger DwordDiv(BigInteger n, uint d) { var ret = new BigInteger(Sign.Positive, n._length); ulong r = 0; var i = n._length; while (i-- > 0) { r <<= 32; r |= n._data[i]; ret._data[i] = (uint) (r/d); r %= d; } ret.Normalize(); return ret; }
public Sign Compare(BigInteger bi) { return Kernel.Compare(this, bi); }
public static byte[] Calculate(byte[] a, BigInteger.BigInteger b) { return(Calculate(new BigInteger.BigInteger(a), b)); //UInt64ToBytes(Calculate(BytesToUInt64(a), b)); }
public static BigInteger LeftShift(BigInteger bi, int n) { if (n == 0) return new BigInteger(bi, bi._length + 1); var w = n >> 5; n &= ((1 << 5) - 1); var ret = new BigInteger(Sign.Positive, bi._length + 1 + (uint) w); uint i = 0, l = bi._length; if (n != 0) { uint carry = 0; while (i < l) { var x = bi._data[i]; ret._data[i + w] = (x << n) | carry; carry = x >> (32 - n); i++; } ret._data[i + w] = carry; } else { while (i < l) { ret._data[i + w] = bi._data[i]; i++; } } ret.Normalize(); return ret; }
public static BigInteger MultiplyByDword(BigInteger n, uint f) { var ret = new BigInteger(Sign.Positive, n._length + 1); uint i = 0; ulong c = 0; do { c += n._data[i]*(ulong) f; ret._data[i] = (uint) c; c >>= 32; } while (++i < n._length); ret._data[i] = (uint) c; ret.Normalize(); return ret; }
/// <summary> /// Compares two BigInteger /// </summary> /// <param name="bi1">A BigInteger</param> /// <param name="bi2">A BigInteger</param> /// <returns>The sign of bi1 - bi2</returns> public static Sign Compare(BigInteger bi1, BigInteger bi2) { // // Step 1. Compare the lengths // uint l1 = bi1._length, l2 = bi2._length; while (l1 > 0 && bi1._data[l1 - 1] == 0) l1--; while (l2 > 0 && bi2._data[l2 - 1] == 0) l2--; if (l1 == 0 && l2 == 0) return Sign.Zero; // bi1 len < bi2 len if (l1 < l2) return Sign.Negative; // bi1 len > bi2 len if (l1 > l2) return Sign.Positive; // // Step 2. Compare the bits // var pos = l1 - 1; while (pos != 0 && bi1._data[pos] == bi2._data[pos]) pos--; if (bi1._data[pos] < bi2._data[pos]) return Sign.Negative; if (bi1._data[pos] > bi2._data[pos]) return Sign.Positive; return Sign.Zero; }
/// <summary> /// Adds two numbers with the same sign. /// </summary> /// <param name="bi1">A BigInteger</param> /// <param name="bi2">A BigInteger</param> /// <returns>bi1 + bi2</returns> public static BigInteger AddSameSign(BigInteger bi1, BigInteger bi2) { uint[] x, y; uint yMax, xMax, i = 0; // x should be bigger if (bi1._length < bi2._length) { x = bi2._data; xMax = bi2._length; y = bi1._data; yMax = bi1._length; } else { x = bi1._data; xMax = bi1._length; y = bi2._data; yMax = bi2._length; } var result = new BigInteger(Sign.Positive, xMax + 1); var r = result._data; ulong sum = 0; // Add common parts of both numbers do { sum = x[i] + ((ulong) y[i]) + sum; r[i] = (uint) sum; sum >>= 32; } while (++i < yMax); // Copy remainder of longer number while carry propagation is required var carry = (sum != 0); if (carry) { if (i < xMax) { do carry = ((r[i] = x[i] + 1) == 0); while (++i < xMax && carry); } if (carry) { r[i] = 1; result._length = ++i; return result; } } // Copy the rest if (i < xMax) { do r[i] = x[i]; while (++i < xMax); } result.Normalize(); return result; }
public BigInteger Pow(BigInteger a, BigInteger k) { var b = new BigInteger(1); if (k == 0) return b; var aCopy = a; if (k.TestBit(0)) b = a; var bitCount = k.BitCount(); for (var i = 1; i < bitCount; i++) { aCopy = Multiply(aCopy, aCopy); if (k.TestBit(i)) b = Multiply(aCopy, b); } return b; }
public BigInteger Pow(uint b, BigInteger exp) { return Pow(new BigInteger(b), exp); }
public BigInteger Difference(BigInteger a, BigInteger b) { var cmp = Kernel.Compare(a, b); BigInteger diff; switch (cmp) { case Sign.Zero: return 0; case Sign.Positive: diff = a - b; break; case Sign.Negative: diff = b - a; break; default: throw new Exception(); } if (diff >= _mod) { if (diff._length >= _mod._length << 1) diff %= _mod; else BarrettReduction(diff); } if (cmp == Sign.Negative) diff = _mod - diff; return diff; }
public BigInteger Multiply(BigInteger a, BigInteger b) { if (a == 0 || b == 0) return 0; if (a > _mod) a %= _mod; if (b > _mod) b %= _mod; var ret = a*b; BarrettReduction(ret); return ret; }
public string ToString(uint radix, string characterSet) { if (characterSet.Length < radix) throw new ArgumentException("charSet length less than radix", "characterSet"); if (radix == 1) throw new ArgumentException("There is no such thing as radix one notation", "radix"); if (this == 0) return "0"; if (this == 1) return "1"; var result = ""; var a = new BigInteger(this); while (a != 0) { var rem = Kernel.SingleByteDivideInPlace(a, radix); result = characterSet[(int) rem] + result; } return result; }
public static BigInteger[] MultiByteDivide(BigInteger bi1, BigInteger bi2) { if (Compare(bi1, bi2) == Sign.Negative) return new BigInteger[] {0, new BigInteger(bi1)}; bi1.Normalize(); bi2.Normalize(); if (bi2._length == 1) return DwordDivMod(bi1, bi2._data[0]); var remainderLen = bi1._length + 1; var divisorLen = (int) bi2._length + 1; var mask = 0x80000000; var val = bi2._data[bi2._length - 1]; var shift = 0; var resultPos = (int) bi1._length - (int) bi2._length; while (mask != 0 && (val & mask) == 0) { shift++; mask >>= 1; } var quot = new BigInteger(Sign.Positive, bi1._length - bi2._length + 1); var rem = (bi1 << shift); var remainder = rem._data; bi2 = bi2 << shift; var j = (int) (remainderLen - bi2._length); var pos = (int) remainderLen - 1; var firstDivisorByte = bi2._data[bi2._length - 1]; ulong secondDivisorByte = bi2._data[bi2._length - 2]; while (j > 0) { var dividend = ((ulong) remainder[pos] << 32) + remainder[pos - 1]; var qHat = dividend/firstDivisorByte; var rHat = dividend%firstDivisorByte; do { if (qHat == 0x100000000 || (qHat*secondDivisorByte) > ((rHat << 32) + remainder[pos - 2])) { qHat--; rHat += firstDivisorByte; if (rHat < 0x100000000) continue; } break; } while (true); // // At this point, q_hat is either exact, or one too large // (more likely to be exact) so, we attempt to multiply the // divisor by q_hat, if we get a borrow, we just subtract // one from q_hat and add the divisor back. // uint dPos = 0; var nPos = pos - divisorLen + 1; ulong mc = 0; var uintQHat = (uint) qHat; do { mc += bi2._data[dPos]*(ulong) uintQHat; var t = remainder[nPos]; remainder[nPos] -= (uint) mc; mc >>= 32; if (remainder[nPos] > t) mc++; dPos++; nPos++; } while (dPos < divisorLen); nPos = pos - divisorLen + 1; dPos = 0; // Overestimate if (mc != 0) { uintQHat--; ulong sum = 0; do { sum = remainder[nPos] + ((ulong) bi2._data[dPos]) + sum; remainder[nPos] = (uint) sum; sum >>= 32; dPos++; nPos++; } while (dPos < divisorLen); } quot._data[resultPos--] = uintQHat; pos--; j--; } quot.Normalize(); rem.Normalize(); var ret = new[] {quot, rem}; if (shift != 0) ret[1] >>= shift; return ret; }
public static BigInteger Subtract(BigInteger big, BigInteger small) { var result = new BigInteger(Sign.Positive, big._length); uint[] r = result._data, b = big._data, s = small._data; uint i = 0, c = 0; do { var x = s[i]; if (((x += c) < c) | ((r[i] = b[i] - x) > ~x)) c = 1; else c = 0; } while (++i < small._length); if (i == big._length) goto fixup; if (c == 1) { do r[i] = b[i] - 1; while (b[i++] == 0 && i < big._length); if (i == big._length) goto fixup; } do r[i] = b[i]; while (++i < big._length); fixup: result.Normalize(); return result; }
public BigInteger ModPow(BigInteger exp, BigInteger n) { var mr = new ModulusRing(n); return mr.Pow(this, exp); }
public static BigInteger Gcd(BigInteger a, BigInteger b) { var x = a; var y = b; var g = y; while (x._length > 1) { g = x; x = y%x; y = g; } if (x == 0) return g; // TODO: should we have something here if we can convert to long? // // Now we can just do it with single precision. I am using the binary gcd method, // as it should be faster. // var yy = x._data[0]; var xx = y%yy; var t = 0; while (((xx | yy) & 1) == 0) { xx >>= 1; yy >>= 1; t++; } while (xx != 0) { while ((xx & 1) == 0) xx >>= 1; while ((yy & 1) == 0) yy >>= 1; if (xx >= yy) xx = (xx - yy) >> 1; else yy = (yy - xx) >> 1; } return yy << t; }
public static BigInteger RightShift(BigInteger bi, int n) { if (n == 0) return new BigInteger(bi); var w = n >> 5; var s = n & ((1 << 5) - 1); var ret = new BigInteger(Sign.Positive, bi._length - (uint) w + 1); var l = (uint) ret._data.Length - 1; if (s != 0) { uint carry = 0; while (l-- > 0) { var x = bi._data[l + w]; ret._data[l] = (x >> n) | carry; carry = x << (32 - n); } } else { while (l-- > 0) ret._data[l] = bi._data[l + w]; } ret.Normalize(); return ret; }
public static BigInteger ModInverse(BigInteger bi, BigInteger modulus) { if (modulus._length == 1) return ModInverse(bi, modulus._data[0]); BigInteger[] p = {0, 1}; var q = new BigInteger[2]; // quotients BigInteger[] r = {0, 0}; // remainders var step = 0; var a = modulus; var b = bi; var mr = new ModulusRing(modulus); while (b != 0) { if (step > 1) { var pval = mr.Difference(p[0], p[1]*q[0]); p[0] = p[1]; p[1] = pval; } var divret = MultiByteDivide(a, b); q[0] = q[1]; q[1] = divret[0]; r[0] = r[1]; r[1] = divret[1]; a = b; b = divret[1]; step++; } if (r[0] != 1) throw (new ArithmeticException("No inverse!")); return mr.Difference(p[0], p[1]*q[0]); }
public static void MinusEq(BigInteger big, BigInteger small) { uint[] b = big._data, s = small._data; uint i = 0, c = 0; do { var x = s[i]; if (((x += c) < c) | ((b[i] -= x) > ~x)) c = 1; else c = 0; } while (++i < small._length); if (i == big._length) goto fixup; if (c == 1) { do b[i]--; while (b[i++] == 0 && i < big._length); } fixup: // Normalize length while (big._length > 0 && big._data[big._length - 1] == 0) big._length--; // Check for zero if (big._length == 0) big._length++; }
public static BigInteger operator *(BigInteger bi1, BigInteger bi2) { if (bi1 == 0 || bi2 == 0) return 0; // // Validate pointers // if (bi1._data.Length < bi1._length) throw new IndexOutOfRangeException("bi1 out of range"); if (bi2._data.Length < bi2._length) throw new IndexOutOfRangeException("bi2 out of range"); var ret = new BigInteger(Sign.Positive, bi1._length + bi2._length); Kernel.Multiply(bi1._data, 0, bi1._length, bi2._data, 0, bi2._length, ret._data, 0); ret.Normalize(); return ret; }
public void BarrettReduction(BigInteger x) { var n = _mod; uint k = n._length, kPlusOne = k + 1, kMinusOne = k - 1; // x < mod, so nothing to do. if (x._length < k) return; // // Validate pointers // if (x._data.Length < x._length) throw new IndexOutOfRangeException("x out of range"); // q1 = x / b^ (k-1) // q2 = q1 * constant // q3 = q2 / b^ (k+1), Needs to be accessed with an offset of kPlusOne // TODO: We should the method in HAC p 604 to do this (14.45) var q3 = new BigInteger(Sign.Positive, x._length - kMinusOne + _constant._length); Kernel.Multiply(x._data, kMinusOne, x._length - kMinusOne, _constant._data, 0, _constant._length, q3._data, 0); // r1 = x mod b^ (k+1) // i.e. keep the lowest (k+1) words var lengthToCopy = (x._length > kPlusOne) ? kPlusOne : x._length; x._length = lengthToCopy; x.Normalize(); // r2 = (q3 * n) mod b^ (k+1) // partial multiplication of q3 and n var r2 = new BigInteger(Sign.Positive, kPlusOne); Kernel.MultiplyMod2P32Pmod(q3._data, (int) kPlusOne, (int) q3._length - (int) kPlusOne, n._data, 0, (int) n._length, r2._data, 0, (int) kPlusOne); r2.Normalize(); if (r2 <= x) { Kernel.MinusEq(x, r2); } else { var val = new BigInteger(Sign.Positive, kPlusOne + 1); val._data[kPlusOne] = 0x00000001; Kernel.MinusEq(val, r2); Kernel.PlusEq(x, val); } while (x >= n) Kernel.MinusEq(x, n); }
public static void PlusEq(BigInteger bi1, BigInteger bi2) { uint[] x, y; uint yMax, xMax, i = 0; var flag = false; // x should be bigger if (bi1._length < bi2._length) { flag = true; x = bi2._data; xMax = bi2._length; y = bi1._data; yMax = bi1._length; } else { x = bi1._data; xMax = bi1._length; y = bi2._data; yMax = bi2._length; } var r = bi1._data; ulong sum = 0; // Add common parts of both numbers do { sum += x[i] + ((ulong) y[i]); r[i] = (uint) sum; sum >>= 32; } while (++i < yMax); // Copy remainder of longer number while carry propagation is required var carry = (sum != 0); if (carry) { if (i < xMax) { do carry = ((r[i] = x[i] + 1) == 0); while (++i < xMax && carry); } if (carry) { r[i] = 1; bi1._length = ++i; return; } } // Copy the rest if (flag && i < xMax - 1) { do r[i] = x[i]; while (++i < xMax); } bi1._length = xMax + 1; bi1.Normalize(); }
public static byte[] Calculate(BigInteger.BigInteger a, byte[] b) { return(Calculate(a, new BigInteger.BigInteger(b))); //UInt64ToBytes(Calculate(a, BytesToUInt64(b))); }
/// <summary> /// Performs n / d and n % d in one operation. /// </summary> /// <param name="n">A BigInteger, upon exit this will hold n / d</param> /// <param name="d">The divisor</param> /// <returns>n % d</returns> public static uint SingleByteDivideInPlace(BigInteger n, uint d) { ulong r = 0; var i = n._length; while (i-- > 0) { r <<= 32; r |= n._data[i]; n._data[i] = (uint) (r/d); r %= d; } n.Normalize(); return (uint) r; }
public static uint DwordMod(BigInteger n, uint d) { ulong r = 0; var i = n._length; while (i-- > 0) { r <<= 32; r |= n._data[i]; r %= d; } return (uint) r; }
public BigInteger(BigInteger bi) { _data = (uint[]) bi._data.Clone(); _length = bi._length; }