public void Extensions_Parse_Should_Return_The_Same_Result_Like_Internal_BigInteger_Parse(string number)
{
var left = BigIntegerExtensions.Parse(number).ToString();
var right = BigInteger.Parse(number).ToString();
Assert.AreEqual(left, right);
}
public static void GenerateTwoPrimesMultipleNumbersInFile(string path, int dividerSize)
{
var topBound = BigInteger.Pow(10, dividerSize);
var bottonBound = BigInteger.Pow(10, dividerSize - 1);
BigInteger GetSizedRandomPrime()
{
BigInteger number = 0;
while (number >= topBound || number <= bottonBound)
{
var randomNumber = BigIntegerExtensions.GetNextRandom(Random, BigInteger.Pow(10, dividerSize));
number = BigIntegerExtensions.NextPrimaryMillerRabin(randomNumber);
}
return(number);
}
var semiPrimeNumbers = new List <string>();
for (var i = 0; i < NumbersCountForDimension; i++)
{
var first = GetSizedRandomPrime();
var second = GetSizedRandomPrime();
var semiPrime = first * second;
semiPrimeNumbers.Add(semiPrime.ToString());
}
File.WriteAllLines(path, semiPrimeNumbers);
}
private void GenRSAKeys(object sender, RoutedEventArgs e)
{
prog.IsIndeterminate = true;
GenRSAKeysB.IsEnabled = false;
SenderPath = Environment.CurrentDirectory + @"\Sender";
if (Directory.Exists(SenderPath))
{
Directory.Delete(SenderPath, true);
}
Directory.CreateDirectory(SenderPath);
var bw = new BackgroundWorker();
bw.DoWork += delegate
{
var keys = BigIntegerExtensions.GenRSAValues(16);
this.keys = keys;
File.WriteAllLines(SenderPath + @"\open_key.txt", new string[]
{
string.Join(" ", keys.Item1.ToByteArray().Select(a => a.ToString("X"))),
string.Join(" ", keys.Item2.ToByteArray().Select(a => a.ToString("X")))
});
File.WriteAllLines(SenderPath + @"\close_key.txt", new string[]
{
string.Join(" ", keys.Item3.ToByteArray().Select(a => a.ToString("X"))),
string.Join(" ", keys.Item4.ToByteArray().Select(a => a.ToString("X")))
}); Dispatcher.Invoke(new Action(() =>
{
MessageBox.Show("Открытый ключ - open_key.txt, Закрытый ключ - close_key.txt");
prog.IsIndeterminate = false;
GenRSAKeysB.IsEnabled = true;
SendCloseKeyB.IsEnabled = true;
}));
};
bw.RunWorkerAsync();
}
public void TestGetPasswordAuthenticationKey()
{
string username = "******";
string password = "******";
string poolName = "Pj8nlkpKR";
byte[] bytes = new byte[1024];
for (int i = bytes.Length - 1; i > 0; i--)
{
bytes[i] = 2;
}
BigInteger a = new BigInteger(bytes);
BigInteger A = BigInteger.ModPow(AuthenticationHelper.g, a, AuthenticationHelper.N);
Tuple <BigInteger, BigInteger> tupleAa = Tuple.Create <BigInteger, BigInteger>(A, a);
string srpb = "8d340308265ada665b1b2c730fb65ff0b6dc746b63c2d7e9f08b8aa9306d4848268bc0c17ee4a2999173ca62af59fd74b"
+ "a5d00f16c96bea082b163f2c3a0b745455d62cb9577425b4b5d4dadba163a8e7759a7c0256795f464682770588c84e82f2c63d47017"
+ "51476da8e8a7b1a131e78560fe7b56b6761fcef88dcc486f403369a0cac2f04c25ed6d5e08b5a2f488500a0d5af4972cfa1213bfca3"
+ "7bbae189c8d58465b13193204f21ea01d267c7688e6e6cb5d3f5a8005db680d272308ee823816032dd2c8fc3b95b6fd0a742feb127e"
+ "3d094cd002a5e6b209415ff82f6abf50d5da43910a0336e9a6fc33dd101bf13f22f13fcb3ea3809aae4917d7c426fb8c0a894030c75"
+ "d3e15f0e1078a9d89e5154391cde6111ac14fab9fa3b3a880da7dbd47fd5a055937581d26b5d225c076e82f980dcbd77b3950d270d8"
+ "b622dca9c9bcd8fd6435a59b9690b3c9e2bdabf58cae3420c19066abc420145b1b66f226a6493c96588c2d53b637798fcaa573379f2"
+ "251848065fe1fafb68ed5e79135e9";
BigInteger B = BigIntegerExtensions.FromUnsignedLittleEndianHex(srpb);
BigInteger salt = BigIntegerExtensions.FromUnsignedLittleEndianHex("b704a27deb8cf5efec43a40eac5b60d2");
byte[] key = AuthenticationHelper.GetPasswordAuthenticationKey(username, password, poolName, tupleAa, B, salt);
string testKey = Convert.ToBase64String(key);
string correctKey = "LmbBsy/4chqMRYOhmtmCrA==";
Assert.Equal(correctKey, testKey);
}
public static void GetAllPoints()
{
BigInteger fieldOrder = BigInteger.Parse("113") * BigInteger.Parse("19");
BigInteger x, y, d;
var random = new Random();
do
{
x = BigIntegerExtensions.GetNextRandom(random, fieldOrder);
y = BigIntegerExtensions.GetNextRandom(random, fieldOrder);
d = ((x * x + y * y - 1) * (x * x * y * y).Inverse(fieldOrder)).Mod(fieldOrder);
} while (d == 1 || d == 0);
// d = 1;
Console.WriteLine($"x = {x}");
Console.WriteLine($"y = {y}");
var edwardsCurve = new AffineEdwardsCurve(d, fieldOrder);
Console.WriteLine(edwardsCurve);
var pointsFactory = new PointsFactory(edwardsCurve);
var points = new List <AffineEdwardsCurvePoint>();
for (var x1 = 0; x1 < fieldOrder; x1++)
{
for (var y1 = 0; y1 < fieldOrder; y1++)
{
if (!pointsFactory.SoftCheckPointOnCurve(x1, y1))
{
continue;
}
points.Add(pointsFactory.CreatePoint(x1, y1));
}
}
Console.WriteLine("Edwards curve has " + points.Count + " points");
var calculator = new AffineEdwardsCurvePointCalculator();
var pairs = points.Join(points, p1 => 1, p2 => 1, (p1, p2) => new { p1, p2 }).ToArray();
try
{
var sumPoints = pairs.AsParallel().Select(pair => calculator.Sum(pair.p1, pair.p2));
Console.WriteLine("Sums were calculated without any exception. Sums count:" + sumPoints.Count());
}
catch (AggregateException e)
{
var gcdFoundException = e.InnerExceptions.First() as GcdFoundException;
if (gcdFoundException == null)
{
throw;
}
Console.WriteLine(gcdFoundException.Message);
Console.WriteLine(gcdFoundException.GreatestCommonDivisor);
}
}
private int countPointInner(long start, long end)
{
var count = 0;
var pLong = (long)p;
if (end >= pLong)
{
end = pLong;
}
for (long x = start; x < end; x++)
{
var z = (long)ExtraBigIntegerExtensions.Mod(x * x * x + a * x + b, p);
if (z == 0)
{
count++;
}
else
{
var legendreSymbol = BigIntegerExtensions.jacobi(z, pLong);
if (legendreSymbol == 1)
{
count += 2;
}
}
}
return(count);
}
public void InitializeParameters()
{
millerRabin = new MillerRabin();
BigInteger p = millerRabin.GetRandomPrime(KeySize / 8);
BigInteger q = millerRabin.GetRandomPrime(KeySize / 8);
BigInteger fi = (p - 1) * (q - 1);
BigInteger e = millerRabin.GetRandomPrime(fi);
BigInteger d = BigIntegerExtensions.ModInverse(e, fi);
BigInteger inverseQ = BigIntegerExtensions.ModInverse(q, p);
BigInteger dp = d % (p - 1);
BigInteger dq = d % (q - 1);
rsaParameters = new RsaParameters
{
P = p,
Q = q,
Modulus = (p * q),
Exponent = e,
Dp = dp,
Dq = dq,
InverseQ = inverseQ,
D = d
};
}
public void ShouldCreateUnsignedBigIntegerFrom4NegativeBytes()
{
byte[] bytes = { 0xFF, 0xFF, 0xFF, 0xFF }; // 4294967295 unsigned, -1 signed (little endian)
BigInteger result = BigIntegerExtensions.UnsignedFromBytes(bytes);
AssertBigIntegerEqual(4294967295L, result);
}
public void ShouldConvertValuesToExtremeMathematics()
{
byte[][] testBytes =
{
// Little endian
new byte[] { 127 },
new byte[] { 255 },
new byte[] {0xFF, 0xFF, 0x7F },
new byte[] {0xFF, 0xFF, 0xFF },
new byte[] {0xFF, 0xFF, 0xFF, 0x7F },
new byte[] {0xFF, 0xFF, 0xFF, 0xFF }
};
foreach (var bytes in testBytes)
{
BigInteger value = new BigInteger(bytes);
if (value.Sign < 0)
{
Assert.Throws <ArgumentException>(() => BigIntegerExtensions.ToUnsignedExtremeMathematics(value));
}
else
{
Assert.AreEqual(value.ToString(),
BigIntegerExtensions.ToUnsignedExtremeMathematics(value).ToString());
}
}
}
public void ShouldCreateUnsignedBigIntegerFromNegativeByte()
{
byte[] bytes = { 255 }; // 255 unsigned, -1 signed
BigInteger result = BigIntegerExtensions.UnsignedFromBytes(bytes);
AssertBigIntegerEqual(255, result);
}
public void ShouldCreateUnsignedBigIntegerFrom4PositiveBytes()
{
byte[] bytes = { 0xFF, 0xFF, 0xFF, 0x7F }; // 2147483647 (little endian)
BigInteger result = BigIntegerExtensions.UnsignedFromBytes(bytes);
AssertBigIntegerEqual(2147483647, result);
}
private byte[] XorKeySizePadding(BigInteger cipheredAgainPreviousBlock, BigInteger block)
{
byte[] xorResult = BigIntegerExtensions.UnsignedToBytes(cipheredAgainPreviousBlock ^ block);
int keySize = rsa.ExportParameters().Modulus.Length;
return(BlockCipherSupport.PadWithZeros(xorResult, keySize));
}
public void ShouldCreateUnsignedBigIntegerFromPositiveByte()
{
byte[] bytes = { 127 };
BigInteger result = BigIntegerExtensions.UnsignedFromBytes(bytes);
AssertBigIntegerEqual(127, result);
}
public void ShouldConvertBigIntegerWithSignByteToUnsignedBytes()
{
BigInteger[] testValues =
{
128,
170,
255,
32768,
33940,
65535,
4294967295
};
byte[][] expectedValues =
{
// Little endian
new byte[] { 128 },
new byte[] { 170 },
new byte[] { 255 },
new byte[] {0x00, 0x80 },
new byte[] {0x94, 0x84 },
new byte[] {0xFF, 0xFF },
new byte[] {0xFF, 0xFF, 0xFF, 0xFF }
};
for (int i = 0; i < testValues.Length; i++)
{
Assert.AreEqual(expectedValues[i], BigIntegerExtensions.UnsignedToBytes(testValues[i]));
}
}
private void Calc(int secretKey)
{
const double scale_f = 1e50;
BigInteger p = BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007908834671663");
float scale_p = (float)((double)p / scale_f);
// Elliptic curve: y^2 = x^3 + a*x + b (mod p): y^2 = x^3 + 7
BigInteger a = 0;
BigInteger b = 7;
// P = G
var G = new EcModPoint
{
x = BigInteger.Parse("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
y = BigInteger.Parse("32670510020758816978083085130507043184471273380659243275938904335757337482424")
};
var lstPoints = BigIntegerExtensions.EcSlowPointListByAddition(p, a, G, secretKey);
var g = pbEcDescrete.CreateGraphics();
g.FillRectangle(Brushes.White, new RectangleF(0, 0, pbEcDescrete.Width, pbEcDescrete.Height));
foreach (var ecPoint in lstPoints)
{
var x = (float)((double)ecPoint.x / scale_f);
var y = (float)((double)ecPoint.y / scale_f);
var scale_x = pbEcDescrete.Width / scale_p;
var scale_y = pbEcDescrete.Height / scale_p;
var x1 = scale_x * x;
var y1 = scale_y * y;
g.FillRectangle(Brushes.Blue, new RectangleF(x1, y1, 3F, 3F));
}
}
public static void Main(string[] args)
{
var random = new Random();
var listOfEc = new List <EllepticCurve>();
const int curvesCountPerDim = 100;
for (var pDim = 2; pDim < 10; pDim++)
{
var dimen = BigInteger.Pow(10, pDim);
for (var i = 0; i < curvesCountPerDim; i++)
{
dimen = BigIntegerExtensions.NextPrimaryMillerRabin(dimen);
var a = BigIntegerExtensions.GetNextRandom(random, dimen);
var b = BigIntegerExtensions.GetNextRandom(random, dimen);
var ec = new EllepticCurve(a, b, dimen);
listOfEc.Add(ec);
}
}
foreach (var curve in listOfEc)
{
var pointsCount = curve.CountPoints;
var b1 = curve.LenstraEdges.B1;
var dim = curve.p.ToString().Length;
var info = $"{dim}\t{curve.a}\t{curve.b}\t{curve.p}\t{pointsCount}\t{b1}\t\r\n";
File.AppendAllText(CurvesWithItsBAndPointsCountTxt, info);
}
}
private byte[] ModPow(byte[] data, BigInteger exponent)
{
BigInteger modulus = BigIntegerExtensions.UnsignedFromBytes(parameters.Modulus);
BigInteger dataBigInteger = BigIntegerExtensions.UnsignedFromBytes(data);
BigInteger result = BigInteger.ModPow(dataBigInteger, exponent, modulus);
return(BigIntegerExtensions.UnsignedToBytes(result));
}
public MInteger(string representation)
{
CreateBitList();
BigInteger big = BigInteger.Parse(representation);
string binaryString = BigIntegerExtensions.ToBinaryString(big);
AppendBinaryString(binaryString);
}
private static void encodeNumeric(String msg, int startpos, int count, StringBuilder sb)
{
#if SILVERLIGHT4 || SILVERLIGHT5 || NET40 || NET45 || NETFX_CORE
int idx = 0;
StringBuilder tmp = new StringBuilder(count / 3 + 1);
BigInteger num900 = new BigInteger(900);
BigInteger num0 = new BigInteger(0);
while (idx < count - 1)
{
tmp.Length = 0;
int len = Math.Min(44, count - idx);
String part = '1' + msg.Substring(startpos + idx, len);
#if SILVERLIGHT4 || SILVERLIGHT5
BigInteger bigint = BigIntegerExtensions.Parse(part);
#else
BigInteger bigint = BigInteger.Parse(part);
#endif
do
{
BigInteger c = bigint % num900;
tmp.Append((char)c);
bigint = BigInteger.Divide(bigint, num900);
} while (!bigint.Equals(num0));
//Reverse temporary string
for (int i = tmp.Length - 1; i >= 0; i--)
{
sb.Append(tmp[i]);
}
idx += len;
}
#else
int idx = 0;
StringBuilder tmp = new StringBuilder(count / 3 + 1);
BigInteger num900 = new BigInteger(900);
BigInteger num0 = new BigInteger(0);
while (idx < count - 1)
{
tmp.Length = 0;
int len = Math.Min(44, count - idx);
String part = '1' + msg.Substring(startpos + idx, len);
BigInteger bigint = BigInteger.Parse(part);
do
{
BigInteger c = BigInteger.Modulo(bigint, num900);
tmp.Append((char)c.GetHashCode());
bigint = BigInteger.Division(bigint, num900);
} while (!bigint.Equals(num0));
//Reverse temporary string
for (int i = tmp.Length - 1; i >= 0; i--)
{
sb.Append(tmp[i]);
}
idx += len;
}
#endif
}
private void TestFromBigEndianPositive(int number, byte[] expectedBigEndianByteArray, int expectedFromBigEndianPositvie)
{
var biNumber = new BigInteger(number);
var bigEndianByteArray = biNumber.ToBigEndianByteArray();
var biFromBigEndianPositive = BigIntegerExtensions.FromUnsignedBigEndian(bigEndianByteArray);
Assert.True(expectedBigEndianByteArray.SequenceEqual(bigEndianByteArray));
Assert.Equal(expectedFromBigEndianPositvie, biFromBigEndianPositive);
}
/// <summary> Символ Лежандра </summary>
public static void LegendreSymbol()
{
int a = 27;
int p = 23;
Console.WriteLine("a = " + a);
Console.WriteLine("p = " + p);
Console.WriteLine("(a/p) = {0}", BigIntegerExtensions.Jacobi(a, p));;
}
public byte[] Decrypt(byte[] data)
{
if (data.Length == 0)
{
return(data);
}
BigInteger d = BigIntegerExtensions.UnsignedFromBytes(parameters.D);
return(ModPow(data, d));
}
public byte[] Encrypt(byte[] data)
{
if (data.Length == 0)
{
return(data);
}
BigInteger exponent = BigIntegerExtensions.UnsignedFromBytes(parameters.Exponent);
return(PadWithZeroes(ModPow(data, exponent))); // Pad in case result is shorter than key
}
private static BigInteger RandomPrime(int numberOfBits)
{
BigInteger result;
do
{
result = BigIntegerExtensions.Random(numberOfBits);
} while (!result.IsProbablyPrime(256));
return(result);
}
public KeyPair GenerateKeyPair(BigInteger p, BigInteger q, BigInteger e)
{
BigInteger n = p * q,
phi = (p - 1) * (q - 1),
d = BigIntegerExtensions.ModInverse(e, phi);
return(new KeyPair(
new PublicKey(e, n),
new PrivateKey(d, n)
));
}
private BigInteger CalculatePreviousXor(List <byte[]> decipheredBlocks, int i, List <byte[]> cipheredBlocks)
{
if (i > 0)
{
var previousDecipheredBlock = BigIntegerExtensions.UnsignedFromBytes(decipheredBlocks[i - 1]);
var previousCipheredBlock = BigIntegerExtensions.UnsignedFromBytes(cipheredBlocks[i - 1]);
return(previousCipheredBlock ^ previousDecipheredBlock);
}
return(InitializationVector);
}
public static CurvePoint BitCoinGenerator()
{
var curve = EllypticCurve.CreateWeierstrass(0, 7, Configurations.MathConfiguration.GenerateSECP256K1());
var g = new Point(
BigInteger.Parse("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
BigInteger.Parse("32670510020758816978083085130507043184471273380659243275938904335757337482424"));
return(new CurvePoint(curve, g,
BigIntegerExtensions.FromBigEndianHexString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")));
}
private static string GenerateSafePrime()
{
var random = new Random();
var bitInt = BigIntegerExtensions.GenerateSafePrime(SafePrimeLength, 1, random);
while (!bitInt.IsSafePrime(100))
{
bitInt = BigIntegerExtensions.GenerateSafePrime(SafePrimeLength, 1, random);
}
return(bitInt.ToString("X2"));
}
/// <summary> Разложение </summary>
public static void Factorize()
{
BigInteger n = BigInteger.Parse("123456794568413263") * BigInteger.Parse("256783548123456833");
var pRs = BigIntegerExtensions.Factorize <ClassicLenstra>(n).OrderBy(x => x.Key);
var nRecover = BigInteger.One;
foreach (var pR in pRs)
{
nRecover *= BigInteger.Pow(pR.Key, pR.Value);
}
var eq = n == nRecover;
}
public void ShouldGenerateUnsignedRandomBigIntegers()
{
int numberOfBits = 512;
for (int i = 0; i < 1000; i++)
{
BigInteger random = BigIntegerExtensions.Random(numberOfBits);
int arrayLength = random.ToByteArray().Length * 8;
Assert.AreEqual(numberOfBits + 8, arrayLength); // Include sign bit for 512 bit values
Assert.AreEqual(1, random.Sign);
}
}
