private static BigInteger GenKey(GeneratorWrap gen, BigInteger modulus) { var key = gen.GetBig() % modulus; while (!KeyCheck(key, modulus)) { key = gen.GetBig() % modulus; } return(key); }
/// <summary> /// Customizable version with full NewKey parameters. /// </summary> /// <param name="wordSize">number of byte of the key</param> /// <param name="testPrecision">percision of the test, error = 1/2^precision</param> /// <param name="primePrecision">percision of primality test, error = 1/2^(2*precision)</param> /// <param name="generator">random number generator, it is not disposed</param> /// <param name="threads">number of threads to use</param> /// <returns>result of the test</returns> public static bool CustomTest(uint wordSize, uint testPrecision, uint primePrecision, RandomNumberGenerator generator, int threads = 1) { if (wordSize < 128 || testPrecision < 1) { throw new ArgumentNullException("FiatShamirIdentification test invalid input\n"); } uint iteration = 0; bool choice; BigInteger number; var result = true; var priv = PrivateKey.NewKey(generator, wordSize, threads, primePrecision); var pub = priv.GetPublicKey(); var verifier = pub.GetVerifier(); var proover = priv.GetProover(generator); //test with key while (iteration < testPrecision && result) { number = proover.Step1(); choice = verifier.Step1(ref number); number = proover.Step2(choice); verifier.Step2(number); result = verifier.CheckState(); iteration++; } if (!result) //if not verified, fail { return(false); } //test without key var genwrap = new GeneratorWrap(generator, wordSize); var falseKey = new PrivateKey(genwrap.GetBig(), genwrap.GetBig(), wordSize); proover = new Proover(falseKey, generator); iteration = 0; while (iteration < testPrecision && result) { number = proover.Step1(); choice = verifier.Step1(ref number); number = proover.Step2(choice); verifier.Step2(number); result = verifier.CheckState(); iteration++; } return(!result); }
//Generates the modulus using one thread private static BigInteger SeqGenMod(GeneratorWrap gen, uint wordSize, uint precision) { IPrime generator = new SequentialPrime(gen.GetInt(), precision, wordSize); var firstPrime = gen.GetBig(); var secondPrime = gen.GetBig(); while (!SecurityCheck(firstPrime, secondPrime)) { secondPrime = gen.GetBig(); } firstPrime = generator.NextPrime(firstPrime); secondPrime = generator.NextPrime(secondPrime); return(firstPrime * secondPrime); }
//Generates the modulus using more thread private static BigInteger ParGenMod(GeneratorWrap gen, uint wordSize, int threads, uint precision) { IPrime mainGenerator, workerGenerator; //threads distribution for primes creation if (threads < 4) { mainGenerator = new SequentialPrime(gen.GetInt(), precision, wordSize); workerGenerator = new SequentialPrime(gen.GetInt(), precision, wordSize); } else { mainGenerator = new ParallelPrime(gen.GetInt(), precision, wordSize, threads - threads / 2); workerGenerator = new ParallelPrime(gen.GetInt(), precision, wordSize, threads / 2); } //primes creation var firstPrime = gen.GetBig(); var secondPrime = gen.GetBig(); while (!SecurityCheck(firstPrime, secondPrime)) { secondPrime = gen.GetBig(); } var worker = new Task <BigInteger>(() => workerGenerator.NextPrime(firstPrime)); worker.Start(); secondPrime = mainGenerator.NextPrime(secondPrime); worker.Wait(); firstPrime = worker.Result; worker.Dispose(); return(firstPrime * secondPrime); }
/// <summary> /// </summary> /// <param name="key">private key</param> /// <param name="gen">random number generator, it is not disposed.</param> internal Proover(PrivateKey key, RandomNumberGenerator gen) { _key = key; _generator = new GeneratorWrap(gen, key.Size); _synch = false; }