/// <summary> /// Тест Миллера — Рабина на простоту /// </summary> /// <param name="n">Тестируемое число</param> /// <param name="testCount">Колличество итераций проверки</param> /// <returns></returns> public static bool IsPrime(this BigInteger n, uint testCount = 20) { if (testCount < 10) { throw new ArgumentException("test count must be greater 10"); } if (n.Sign != 1) { throw new ArgumentException("n must be positive"); } if (n == 2) { return(true); } if (n.IsEven) { return(false); } ulong s = 0; BigInteger t = n - 1; while (t.IsEven) { s++; t = t >> 1; } for (uint i = 0; i < testCount; i++) { BigInteger a = NumMethodsClass.GenerateBigInteger(2, n - 2); BigInteger x = BigInteger.ModPow(a, t, n); if ((x == BigInteger.One) || (x == (n - 1))) { continue; } for (ulong j = 0; j < (s - 1); j++) { x = BigInteger.ModPow(x, 2, n); if (x == BigInteger.One) { return(false); } if (x == (n - 1)) { break; } } if (x != (n - 1)) { return(false); } } return(true); }
private void RegenerateSizeParameters() { int keySize = NumMethodsClass.GetModuleSize(BigInteger.Parse(GeneralParameter)); _readingSize = keySize - 1; _packingSize = keySize; }
public void GenerateKey() { try { BigInteger p = NumMethodsClass.GeneratePrime(95); BigInteger q = NumMethodsClass.GeneratePrime(98); BigInteger modulus = p * q; BigInteger phi = (p - 1) * (q - 1); BigInteger pubExp = NumMethodsClass.GetPublicExponent(p.ToString(), q.ToString());; BigInteger privateExponentInt = pubExp.Inverse(phi); if (privateExponentInt == 0) { throw new ApplicationException(); } _modulus = modulus.ToString(); _phi = phi.ToString(); _openExponent = pubExp.ToString(); _secretExponent = privateExponentInt.ToString(); RegenerateSizeParameters(); } catch (Exception) { throw new ApplicationException("Error via generate key"); } }
private void RegenerateSizeParameters() { string modulus = GeneralParameter.Split(" ")[0]; int keySize = NumMethodsClass.GetModuleSize(BigInteger.Parse(modulus)); _readingSize = keySize - 1; _packingSize = keySize; }
public byte[] Sign(IKey Key, byte[] hash) { byte[] hashBytes = hash; if (Key.IsKeyValid(isSigning: true)) { List <byte> result = new List <byte>(); string[] generalList = Key.GeneralParameter.Split(" "); BigInteger p = BigInteger.Parse(generalList[0]); BigInteger q = BigInteger.Parse(generalList[1]); BigInteger g = BigInteger.Parse(generalList[2]); BigInteger x = BigInteger.Parse(Key.SecretParameter); BigInteger k = BigInteger.Zero; BigInteger r = BigInteger.Zero; do { k = NumMethodsClass.GenerateBigInteger(1, q - 1); BigInteger temp = BigInteger.ModPow(g, k, p); BigInteger.DivRem(temp, q, out r); } while (r == 0); int countOfBytes = hashBytes.Length; // calculate count of bytes in block byte[] block = new byte[countOfBytes + 1]; Buffer.BlockCopy(hashBytes, 0, block, 0, countOfBytes); BigInteger s = BigInteger.Zero; BigInteger.DivRem(k.Inverse(q) * (new BigInteger(block) + x * r), q, out s); if (s == BigInteger.Zero) { throw new ApplicationException("Generate keys again. Invalid keys"); } byte[] tempResult = s.ToByteArray(); byte[] packingUnit = new byte[hashBytes.Length]; Buffer.BlockCopy(tempResult, 0, packingUnit, 0, Math.Min(tempResult.Length, hashBytes.Length)); //copy to packing block from result of ciphering result.AddRange(packingUnit); result.AddRange(r.ToByteArray()); return(result.ToArray()); } else { throw new ApplicationException("Key is not valid"); } }
public MainWindow() { Thread thread = new Thread(() => { NumMethodsClass.LoadPyScript(); }); thread.Start(); InitializeComponent(); DataContext = new SignToolMainVM(); }
private ElgamalPrivateKey GetElgamalPrivateKey(ElgamalPublicParams param) { ElgamalPublicParams parameters = param; ElgamalPrivateKey pk; BigInteger x; BigInteger y; x = NumMethodsClass.GenerateBigInteger(2, parameters.Modulus - 1); y = CalculateKeysByPowm(parameters.Generator, x, parameters.Modulus); pk.X = x; pk.Y = y; return(pk); }
public static BigInteger Inverse(this BigInteger a, BigInteger module) { var result = NumMethodsClass.GCDex(a, module); if (result.d != BigInteger.One) { return(0); } BigInteger.DivRem(result.x, module, out result.x); if (result.x.Sign == -1) { result.x += module; BigInteger.DivRem(result.x, module, out result.x); } return(result.x); }
public static DHPublicParams Generate(int decimalNubmerCount) { BigInteger min = BigInteger.Pow(10, decimalNubmerCount); BigInteger max = BigInteger.Pow(10, decimalNubmerCount + 1); BigInteger p; BigInteger q; while (true) { q = NumMethodsClass.GenerateBigInteger(min, max); if (q.IsPrime()) { p = (q << 1) + BigInteger.One; if (p.IsPrime()) { break; } } } BigInteger pMinusOne = p - 1; BigInteger g; do { g = NumMethodsClass.GenerateBigInteger(2, pMinusOne); } while (BigInteger.ModPow(g, 2, p) == BigInteger.One || BigInteger.ModPow(g, q, p) == BigInteger.One); DHPublicParams dHPublic; dHPublic.Modulus = p; dHPublic.Generator = g; return(dHPublic); }
public void GenerateKey() { BigInteger q = NumMethodsClass.GeneratePrimeByPython(160); BigInteger p; BigInteger b; do { b = NumMethodsClass.GenerateBigInteger((1024 - 160) / 8); p = b * q + 1; } while (!p.IsPrime()); BigInteger g = BigInteger.Zero; for (BigInteger i = 2; i < p - 1; i++) { g = BigInteger.ModPow(i, b, p); if (g > 1) { break; } } if (g == BigInteger.Zero) { throw new ApplicationException("Try generate again, error via generating G"); } BigInteger x = NumMethodsClass.GenerateBigInteger(2, q - 1); BigInteger y = BigInteger.ModPow(g, x, p); GeneralParameter = $"{p.ToString()} {q.ToString()} {g.ToString()}"; OpenParameter = y.ToString(); SecretParameter = x.ToString(); RegenerateSizeParameters(); }
public byte[] Sign(IKey Key, byte[] hash) { byte[] hashBytes = hash; List <byte> result = new List <byte>(hashBytes.Length); if (!Key.IsKeyValid(isSigning: true)) { throw new ApplicationException("Key is not valid"); } try { int readSize = Key.ReadingSize; int writeSize = Key.PackingSize; BigInteger k; string[] generalParameters = Key.GeneralParameter.Split(" "); BigInteger modulus = BigInteger.Parse(generalParameters[0]); BigInteger generator = BigInteger.Parse(generalParameters[1]); BigInteger secret = BigInteger.Parse(Key.SecretParameter); do { k = NumMethodsClass.GenerateBigInteger(2, modulus - 3); } while (BigInteger.GreatestCommonDivisor(k, modulus - 1) != 1); BigInteger r = BigInteger.ModPow(generator, k, modulus); byte[] packedBlock = new byte[writeSize]; byte[] rBlock = r.ToByteArray(false); Buffer.BlockCopy(rBlock, 0, packedBlock, 0, rBlock.Length); result.AddRange(packedBlock); for (int currentByte = 0; currentByte < hashBytes.Length; currentByte += readSize) { int byteCopyCount = Math.Min(readSize, hashBytes.Length - currentByte); byte[] currentBlock = new byte[byteCopyCount + 1]; // Добавлен 0х00 чтобы число было положительным Buffer.BlockCopy(hashBytes, currentByte, currentBlock, 0, byteCopyCount); BigInteger h = new BigInteger(currentBlock); BigInteger temp; BigInteger.DivRem(secret * r, modulus - 1, out temp); BigInteger u; BigInteger.DivRem(h - temp + (modulus - 1), modulus - 1, out u); BigInteger s; BigInteger.DivRem(k.Inverse(modulus - 1) * u, modulus - 1, out s); byte[] cipherBlock = s.ToByteArray(false); packedBlock = new byte[writeSize]; Buffer.BlockCopy(cipherBlock, 0, packedBlock, 0, cipherBlock.Length); result.AddRange(packedBlock); } } catch (Exception ex) { throw new Exception(ex.Message); } return(result.ToArray()); }