/// <summary> /// Gets BigNum <paramref name="b"/>. /// Generates p and q, prime numbers. /// While b is not inverse number to p-1 and q-1, p and q re-generates. /// After finding good p and q, calculate a that is inverse of b mod ((p-1)(q-1)). /// n is calculated as p * q. /// Returns by reference the BigNum a, p, q, and n. /// </summary> /// <param name="b"></param> /// <param name="a"></param> /// <param name="q"></param> /// <param name="p"></param> /// <param name="nByRef"></param> public static void GenRSA(BigNum b, BigNum a, BigNum q, BigNum p, BigNum nByRef) { bool isBInverseOfPMinus1AndQMinus1 = false; BigNum n = new BigNum(); while (!isBInverseOfPMinus1AndQMinus1) { p.Set(GenPrime()); q.Set(GenPrime()); BigNum pMinus1 = new BigNum(p); pMinus1.SubNum(GlobalVariables.one); BigNum qMinus1 = new BigNum(q); qMinus1.SubNum(GlobalVariables.one); BigNum fiOfN = new BigNum(pMinus1); fiOfN.MultNum(qMinus1); BigNum gcd = new BigNum(); ExtendedGCD(b, fiOfN, new BigNum(), new BigNum(), gcd); if (gcd.CompNumWithoutPrint(GlobalVariables.one)) { isBInverseOfPMinus1AndQMinus1 = true; a.Set(Inverse(b, fiOfN)); if (a.IsNegative) { a.AddNum(fiOfN); } n = new BigNum(p); n.MultNum(q); } } nByRef.Set(n); }
public static bool MillerRabinAlgorithm(BigNum n, BigNum t, BigNum u) { bool isPrimeNumber = true; BigNum randomNumber = GenerateNumberFromOneToGivenTop(n); BigNum x0 = Power(randomNumber, u, n); BigNum x1 = new BigNum(); BigNum iterationNumber = new BigNum(GlobalVariables.one); while (iterationNumber <= t) // Iterates t times. { x1 = Power(x0, GlobalVariables.two, n); x0.Set(x1); if ((x1.CompNumWithoutPrint(GlobalVariables.one)) && (!x0.CompNumWithoutPrint(GlobalVariables.one)) && (!x0.CompNumWithoutPrint(GlobalVariables.minusOne))) { isPrimeNumber = false; break; } iterationNumber.AddNum(GlobalVariables.one); } if (isPrimeNumber) { if (!x1.CompNumWithoutPrint(GlobalVariables.one)) { isPrimeNumber = false; } } return(isPrimeNumber); }
public static void IIB() { Console.WriteLine("II."); Console.WriteLine("Finds the first five prime numbers with 100 binary digits"); int countPrimeNumberFound = 0; int tryNumber = 0; while (countPrimeNumberFound < 5) { List <int> positionsOf1s = new List <int> // Trusting that the number will have 100 binary digits. { GlobalVariables.MAX_NUM - 100, GlobalVariables.MAX_NUM - 1 }; int k = 20; BigNum primeNumberSuspect = new BigNum(); primeNumberSuspect.ReadNum(positionsOf1s); Console.WriteLine($"try number: {++tryNumber}"); if (MathOps.IsPrime(primeNumberSuspect, k)) { Console.WriteLine($"Prime {countPrimeNumberFound}: {primeNumberSuspect.BinaryValue}"); Console.WriteLine(); } primeNumberSuspect.AddNum(GlobalVariables.two); } Console.WriteLine(); }
/// <summary> /// D. /// Converts the big number from this instance to long number. /// Checks that the number can fit into long. If so, returns it. /// The biggest positive value that can be hold by long variable is: 2^63 -1, /// therfore has 63 bits. /// </summary> /// <returns>longNumber</returns> public long?BigToLong() { BigNum copyNumber = new BigNum(this); long? longNumber; int fromBase = 2; bool isNegative = false; if (IsNegative) { // Make copyNumber represented as positive number. copyNumber.Complement(); copyNumber.AddNum(GlobalVariables.one); isNegative = true; } if (IsBigNumFitsIntoLongType(copyNumber)) { longNumber = Convert.ToInt64(copyNumber.WriteNum(), fromBase); if (isNegative) { longNumber = -longNumber; } } else { longNumber = null; Console.WriteLine($"Convertion from BigNum to long is not possible," + $"this BigNum has more then {GlobalVariables.MaxNumberOfDigitsInLongType} digits"); } return(longNumber); }
/// <summary> /// I. /// Gets BigNum type and substract between the current value of the binary number with the given one. /// Let do substraction A = A-B. We know that A-B = A + (-B). /// Calculating -B: Doing complement and then add 1. /// </summary> /// <param name="numberToSubtract"></param> public void SubNum(BigNum numberToSubtract) { // numberToSubstract = B. BigNum modifiedNumberToSubtract = new BigNum(numberToSubtract); modifiedNumberToSubtract.Complement(); // numberToSubtract = -B - 1. modifiedNumberToSubtract.AddNum(GlobalVariables.one); // numberToSubtract = -B. AddNum(modifiedNumberToSubtract); // Allready updates <mMSB1Location>. UpdateMSB1Location(); }
public static void E() { Console.WriteLine("(E) Using AddNum method."); Console.WriteLine("8 + 13 = 21."); BigNum bigNumE1 = new BigNum(8L); BigNum bigNumE2 = new BigNum(13L); bigNumE1.AddNum(bigNumE2); Console.WriteLine(bigNumE1.WriteNum()); Console.WriteLine(); }
/// <summary> /// Gets a number m. /// Finds p >= 0 and k (k is odd), where m = 2^p * k. /// Return p and k by ref. /// /// p = 0; /// if (!IsEven(m)) /// { /// k = m; /// } /// else // m is even. /// { /// while(IsEven(m)) /// { /// m /= 2; /// p++; /// } /// k = m; /// } /// </summary> /// <param name=""></param> /// <param name=""></param> public static void FindExpressionOfGivenNumberByPowerOfTwoTimesOddNumber(BigNum m, BigNum p, BigNum k) { if (!m.IsEven()) { k.Set(m); } else { while (m.IsEven()) { DivNum(m, GlobalVariables.two, m, new BigNum()); p.AddNum(GlobalVariables.one); } k.Set(m); } }