List <bool> BlumMicali(int size, int key) { MyBigType g = new MyBigType("1347981406723692103108327603051596927581014069867"); MyBigType p = new MyBigType("1347981406723692103108327603051596927581014069863"); MyBigType x0 = new MyBigType(key); MyBigType x = new MyBigType(1); string ccout = "x0 = " + Convert.ToString(x0); MessageBox.Show(ccout); List <bool> klucz = new List <bool>(); for (int s = 0; s < size * 8; s++) { x = powermodulo(g, x0, p); if (x > (p - 1) / 2) { klucz.Add(false); } else { klucz.Add(true); } x0 = x; } return(klucz); }
public static int Compare(MyBigType leftSide, MyBigType rightSide) { if (object.ReferenceEquals(leftSide, rightSide)) { return(0); } if (object.ReferenceEquals(leftSide, null)) { throw new ArgumentNullException("leftSide"); } if (object.ReferenceEquals(rightSide, null)) { throw new ArgumentNullException("rightSide"); } if (leftSide > rightSide) { return(1); } if (leftSide == rightSide) { return(0); } return(-1); }
List <bool> BlumMicali(int size) { var random = new Random(); MyBigType g = new MyBigType("1347981406723692103108327603051596927581014069867"); MyBigType p = new MyBigType("1347981406723692103108327603051596927581014069863"); x0i = random.Next(10, 500); MyBigType x0 = new MyBigType(x0i); MyBigType x = new MyBigType(1); string ccout = "x0 = " + Convert.ToString(x0); System.IO.File.WriteAllText(@".\ZaszyfrowanyKlucz.txt", Convert.ToString(x0)); MessageBox.Show(ccout); List <bool> klucz = new List <bool>(); for (int s = 0; s < size * 8; s++) { x = powermodulo(g, x0, p); if (x > (p - 1) / 2) { klucz.Add(false); } else { klucz.Add(true); } x0 = x; } return(klucz); }
// Returns true if n is prime public static bool isPrime(MyBigType n) { // Corner cases if (n <= 1) { return(false); } if (n <= 3) { return(true); } // This is checked so that we can skip // middle five numbers in below loop if (n % 2 == 0 || n % 3 == 0) { return(false); } for (MyBigType i = 5; i *i <= n; i = i + 6) { if (n % i == 0 || n % (i + 2) == 0) { return(false); } } return(true); }
// Utility function to store prime factors of a number public static void findPrimefactors(HashSet <MyBigType> s, MyBigType n) { // Print the number of 2s that divide n while (n % 2 == 0) { s.Add(2); n = n / 2; } // n must be odd at this point. So we can skip // one element (Note i = i +2) for (int i = 3; i <= n.Pow(2); i = i + 2) { // While i divides n, print i and divide n while (n % i == 0) { s.Add(i); n = n / i; } } // This condition is to handle the case when // n is a prime number greater than 2 if (n > 2) { s.Add(n); } }
public static MyBigType Pow(MyBigType b, MyBigType power) { if (b == null) { throw new ArgumentNullException("b"); } if (power == null) { throw new ArgumentNullException("power"); } if (power < 0) { throw new ArgumentOutOfRangeException("power", "Currently negative exponents are not supported"); } MyBigType result = 1; while (power != 0) { if ((power & 1) != 0) { result *= b; } power >>= 1; b *= b; } return(result); }
public override bool Equals(object obj) { if (object.ReferenceEquals(obj, null)) { return(false); } if (object.ReferenceEquals(this, obj)) { return(true); } MyBigType c = (MyBigType)obj; if (this.m_digits.DataUsed != c.m_digits.DataUsed) { return(false); } for (int idx = 0; idx < this.m_digits.DataUsed; idx++) { if (this.m_digits[idx] != c.m_digits[idx]) { return(false); } } return(true); }
//// Returns true if n is prime //public static bool isPrime(MyBigType n) //{ // // Corner cases // if (n <= 1) // { // return false; // } // if (n <= 3) // { // return true; // } // // This is checked so that we can skip // // middle five numbers in below loop // if (n % 2 == 0 || n % 3 == 0) // { // return false; // } // for (MyBigType i = 5; i * i <= n; i = i + 6) // { // if (n % i == 0 || n % (i + 2) == 0) // { // return false; // } // } // return true; //} ///* Iterative Function to calculate (x^n)%p in //O(logy) */ //public static MyBigType power(MyBigType x, MyBigType y, MyBigType p) //{ // MyBigType res = 1; // Initialize result // x = x % p; // Update x if it is more than or // // equal to p // while (y > 0) // { // // If y is odd, multiply x with result // if (y % 2 == 1) // { // res = (res * x) % p; // } // // y must be even now // y = y >> 1; // y = y/2 // x = (x * x) % p; // } // return res; //} //// Utility function to store prime factors of a number //public static void findPrimefactors(HashSet<MyBigType> s, MyBigType n) //{ // // Print the number of 2s that divide n // while (n % 2 == 0) // { // s.Add(2); // n = n / 2; // } // // n must be odd at this point. So we can skip // // one element (Note i = i +2) // for (int i = 3; i <= n.Pow(2); i = i + 2) // { // // While i divides n, print i and divide n // while (n % i == 0) // { // s.Add(i); // n = n / i; // } // } // // This condition is to handle the case when // // n is a prime number greater than 2 // if (n > 2) // { // s.Add(n); // } //} //// Function to find smallest primitive root of n //public static MyBigType findPrimitive(MyBigType n) //{ // HashSet<MyBigType> s = new HashSet<MyBigType>(); // // Check if n is prime or not // if (isPrime(n) == false) // { // return -1; // } // // Find value of Euler Totient function of n // // Since n is a prime number, the value of Euler // // Totient function is n-1 as there are n-1 // // relatively prime numbers. // MyBigType phi = n - 1; // // Find prime factors of phi and store in a set // findPrimefactors(s, phi); // // Check for every number from 2 to phi // for (int r = 2; r <= phi; r++) // { // // Iterate through all prime factors of phi. // // and check if we found a power with value 1 // bool flag = false; // foreach (MyBigType a in s) // { // // Check if r^((phi)/primefactors) mod n // // is 1 or not // if (power(r, phi / (a), n) == 1) // { // flag = true; // break; // } // } // // If there was no power with value 1. // if (flag == false) // { // return r; // } // } // // If no primitive root found // return -1; //} public static MyBigType RightShift(MyBigType leftSide, int shiftCount) { if (leftSide == null) { throw new ArgumentNullException("leftSide"); } return(leftSide >> shiftCount); }
public static MyBigType Abs(MyBigType leftSide) { if (object.ReferenceEquals(leftSide, null)) { throw new ArgumentNullException("leftSide"); } if (leftSide.IsNegative) { return(-leftSide); } return(leftSide); }
//MyBigType powerTo(MyBigType x, MyBigType y, MyBigType p) //{ // MyBigType res = new MyBigType(1); // x = x % p; // MyBigType zero = new MyBigType(0); // while (y > zero) // { // if ((y % 2) == 1) // { // res *= x; // res = res % p; // } // x *= x; // x = x % p; // y /= 2; // } // return res; //} static MyBigType powermodulo(MyBigType x, MyBigType y, MyBigType p) { MyBigType res = 1; x = x % p; while (y > 0) { if ((y & 1) == 1) { res = (res * x) % p; } y = y >> 1; x = (x * x) % p; } return(res); }
// Function to find smallest primitive root of n public static MyBigType findPrimitive(MyBigType n) { HashSet <MyBigType> s = new HashSet <MyBigType>(); // Check if n is prime or not if (isPrime(n) == false) { return(-1); } // Find value of Euler Totient function of n // Since n is a prime number, the value of Euler // Totient function is n-1 as there are n-1 // relatively prime numbers. MyBigType phi = n - 1; // Find prime factors of phi and store in a set findPrimefactors(s, phi); // Check for every number from 2 to phi for (int r = 2; r <= phi; r++) { // Iterate through all prime factors of phi. // and check if we found a power with value 1 bool flag = false; foreach (MyBigType a in s) { // Check if r^((phi)/primefactors) mod n // is 1 or not if (power(r, phi / (a), n) == 1) { flag = true; break; } } // If there was no power with value 1. if (flag == false) { return(r); } } // If no primitive root found return(-1); }
private void Construct(string digits, int radix) { if (digits == null) { throw new ArgumentNullException("digits"); } MyBigType multiplier = new MyBigType(1); MyBigType result = new MyBigType(); digits = digits.ToUpper(System.Globalization.CultureInfo.CurrentCulture).Trim(); int nDigits = (digits[0] == '-' ? 1 : 0); for (int idx = digits.Length - 1; idx >= nDigits; idx--) { int d = (int)digits[idx]; if (d >= '0' && d <= '9') { d -= '0'; } else if (d >= 'A' && d <= 'Z') { d = (d - 'A') + 10; } else { throw new ArgumentOutOfRangeException("digits"); } if (d >= radix) { throw new ArgumentOutOfRangeException("digits"); } result += (multiplier * d); multiplier *= radix; } if (digits[0] == '-') { result = -result; } this.m_digits = result.m_digits; }
private static void Divide(MyBigType leftSide, MyBigType rightSide, out MyBigType quotient, out MyBigType remainder) { if (leftSide.IsZero) { quotient = new MyBigType(); remainder = new MyBigType(); return; } if (rightSide.m_digits.DataUsed == 1) { SingleDivide(leftSide, rightSide, out quotient, out remainder); } else { MultiDivide(leftSide, rightSide, out quotient, out remainder); } }
private static void SingleDivide(MyBigType leftSide, MyBigType rightSide, out MyBigType quotient, out MyBigType remainder) { if (rightSide.IsZero) { throw new DivideByZeroException(); } ArrayForDigits remainderDigits = new ArrayForDigits(leftSide.m_digits); remainderDigits.ResetDataUsed(); int pos = remainderDigits.DataUsed - 1; ulong divisor = (ulong)rightSide.m_digits[0]; ulong dividend = (ulong)remainderDigits[pos]; unsignIn[] result = new unsignIn[leftSide.m_digits.Count]; leftSide.m_digits.CopyTo(result, 0, result.Length); int resultPos = 0; if (dividend >= divisor) { result[resultPos++] = (unsignIn)(dividend / divisor); remainderDigits[pos] = (unsignIn)(dividend % divisor); } pos--; while (pos >= 0) { dividend = ((ulong)(remainderDigits[pos + 1]) << ArrayForDigits.DataSizeBits) + (ulong)remainderDigits[pos]; result[resultPos++] = (unsignIn)(dividend / divisor); remainderDigits[pos + 1] = 0; remainderDigits[pos--] = (unsignIn)(dividend % divisor); } remainder = new MyBigType(remainderDigits); ArrayForDigits quotientDigits = new ArrayForDigits(resultPos + 1, resultPos); int j = 0; for (int i = quotientDigits.DataUsed - 1; i >= 0; i--, j++) { quotientDigits[j] = result[i]; } quotient = new MyBigType(quotientDigits); }
public MyBigType findPrime(MyBigType a) { bool isPrime = true; MyBigType i = new MyBigType(2); for (; ; a++) { while (i < a && isPrime == true) { if (a % i == 0) { isPrime = false; } i++; } i = 2; isPrime = true; } }
public static MyBigType operator *(MyBigType leftSide, MyBigType rightSide) { if (object.ReferenceEquals(leftSide, null)) { throw new ArgumentNullException("leftSide"); } if (object.ReferenceEquals(rightSide, null)) { throw new ArgumentNullException("rightSide"); } bool leftSideNeg = leftSide.IsNegative; bool rightSideNeg = rightSide.IsNegative; leftSide = Abs(leftSide); rightSide = Abs(rightSide); ArrayForDigits da = new ArrayForDigits(leftSide.m_digits.DataUsed + rightSide.m_digits.DataUsed); da.DataUsed = da.Count; for (int i = 0; i < leftSide.m_digits.DataUsed; i++) { ulong carry = 0; for (int j = 0, k = i; j < rightSide.m_digits.DataUsed; j++, k++) { ulong val = ((ulong)leftSide.m_digits[i] * (ulong)rightSide.m_digits[j]) + (ulong)da[k] + carry; da[k] = (unsignIn)(val & ArrayForDigits.AllBits); carry = (val >> ArrayForDigits.DataSizeBits); } if (carry != 0) { da[i + rightSide.m_digits.DataUsed] = (unsignIn)carry; } } MyBigType result = new MyBigType(da); return(leftSideNeg != rightSideNeg ? -result : result); }
/* Iterative Function to calculate (x^n)%p in * O(logy) */ public static MyBigType power(MyBigType x, MyBigType y, MyBigType p) { MyBigType res = 1; // Initialize result x = x % p; // Update x if it is more than or // equal to p while (y > 0) { // If y is odd, multiply x with result if (y % 2 == 1) { res = (res * x) % p; } // y must be even now y = y >> 1; // y = y/2 x = (x * x) % p; } return(res); }
public string ToString(int radix) { if (radix < 2 || radix > 36) { throw new ArgumentOutOfRangeException("radix"); } if (IsZero) { return("0"); } MyBigType a = this; bool negative = a.IsNegative; a = Abs(this); MyBigType quotient; MyBigType remainder; MyBigType biRadix = new MyBigType(radix); const string charSet = "0123456789abcdefghijklmnopqrstuvwxyz"; System.Collections.ArrayList al = new System.Collections.ArrayList(); while (a.m_digits.DataUsed > 1 || (a.m_digits.DataUsed == 1 && a.m_digits[0] != 0)) { Divide(a, biRadix, out quotient, out remainder); al.Insert(0, charSet[(int)remainder.m_digits[0]]); a = quotient; } string result = new String((char[])al.ToArray(typeof(char))); if (radix == 10 && negative) { return("-" + result); } return(result); }
public MyBigType Pow(MyBigType power) { return(Pow(this, power)); }
public static MyBigType Subtract(MyBigType leftSide, MyBigType rightSide) { return(leftSide - rightSide); }
public MyBigType(MyBigType m) { m_digits = m.m_digits; }
private static void MultiDivide(MyBigType leftSide, MyBigType rightSide, out MyBigType quotient, out MyBigType remainder) { if (rightSide.IsZero) { throw new DivideByZeroException(); } unsignIn val = rightSide.m_digits[rightSide.m_digits.DataUsed - 1]; int d = 0; for (uint mask = ArrayForDigits.HiBitSet; mask != 0 && (val & mask) == 0; mask >>= 1) { d++; } int remainderLen = leftSide.m_digits.DataUsed + 1; unsignIn[] remainderDat = new unsignIn[remainderLen]; leftSide.m_digits.CopyTo(remainderDat, 0, leftSide.m_digits.DataUsed); ArrayForDigits.ShiftLeft(remainderDat, d); rightSide = rightSide << d; ulong firstDivisor = rightSide.m_digits[rightSide.m_digits.DataUsed - 1]; ulong secondDivisor = (rightSide.m_digits.DataUsed < 2 ? (unsignIn)0 : rightSide.m_digits[rightSide.m_digits.DataUsed - 2]); int divisorLen = rightSide.m_digits.DataUsed + 1; ArrayForDigits dividendPart = new ArrayForDigits(divisorLen, divisorLen); unsignIn[] result = new unsignIn[leftSide.m_digits.Count + 1]; int resultPos = 0; ulong carryBit = (ulong)0x1 << ArrayForDigits.DataSizeBits; // 0x100000000 for (int j = remainderLen - rightSide.m_digits.DataUsed, pos = remainderLen - 1; j > 0; j--, pos--) { ulong dividend = ((ulong)remainderDat[pos] << ArrayForDigits.DataSizeBits) + (ulong)remainderDat[pos - 1]; ulong qHat = (dividend / firstDivisor); ulong rHat = (dividend % firstDivisor); while (pos >= 2) { if (qHat == carryBit || (qHat * secondDivisor) > ((rHat << ArrayForDigits.DataSizeBits) + remainderDat[pos - 2])) { qHat--; rHat += firstDivisor; if (rHat < carryBit) { continue; } } break; } for (int h = 0; h < divisorLen; h++) { dividendPart[divisorLen - h - 1] = remainderDat[pos - h]; } MyBigType dTemp = new MyBigType(dividendPart); MyBigType rTemp = rightSide * (long)qHat; while (rTemp > dTemp) { qHat--; rTemp -= rightSide; } rTemp = dTemp - rTemp; for (int h = 0; h < divisorLen; h++) { remainderDat[pos - h] = rTemp.m_digits[rightSide.m_digits.DataUsed - h]; } result[resultPos++] = (unsignIn)qHat; } Array.Reverse(result, 0, resultPos); quotient = new MyBigType(new ArrayForDigits(result)); int n = ArrayForDigits.ShiftRight(remainderDat, d); ArrayForDigits rDA = new ArrayForDigits(n, n); rDA.CopyFrom(remainderDat, 0, 0, rDA.DataUsed); remainder = new MyBigType(rDA); }
public int CompareTo(MyBigType value) { return(Compare(this, value)); }