public bool CheckKey()
{
return
(PoupardSternProof != null && _PermutationTestProof != null &&
PoupardStern.VerifyPoupardStern(_PublicKey._Key, PoupardSternProof, PoupardSetup) &&
PermutationTest.VerifyPermutationTest(_PublicKey._Key, PermutationTestProof, PermutationSetup));
}
public void CheckAlphaNTest0()
{
// Sanity check
var keyPair = TestUtils.GeneratePrivate(Exp, setup.KeySize);
var pubKey = (RsaKeyParameters)keyPair.Public;
var Modulus = pubKey.Modulus;
// Assert CheckAlphaN returns True
Assert.IsTrue(PermutationTest.CheckAlphaN(alpha, Modulus));
}
public void _CheckAlphaN(BigInteger Exp, int keySize, int alpha, out double alphaTime)
{
var keyPair = TestUtils.GeneratePrivate(Exp, keySize);
var pubKey = (RsaKeyParameters)keyPair.Public;
var Modulus = pubKey.Modulus;
sw.Restart(); //Check AlphaN start
var output = PermutationTest.CheckAlphaN(alpha, Modulus);
sw.Stop(); //Check AlphaN ends
Assert.IsTrue(output);
alphaTime = sw.Elapsed.TotalMilliseconds;
}
public void CheckAlphaNTest3()
{
// CheckAlphaN outputs fail if N is even (2 * alpha).
BigInteger p, q;
// p is Two (Even)
p = BigInteger.Two;
// Generate q to fill N
q = BigInteger.ValueOf(alpha);
var Modulus = p.Multiply(q);
// Assert CheckAlphaN returns False
Assert.IsFalse(PermutationTest.CheckAlphaN(alpha, Modulus));
}
public void GetRhos_Data()
{
// GetRhos is really producing outputs rho that are<N and have GCD(N, rho) = 1
int m2 = 10000;
var keyPair = TestUtils.GeneratePrivate(Exp, keySize);
var privKey = (RsaPrivateCrtKeyParameters)keyPair.Private;
var pubKey = (RsaKeyParameters)keyPair.Public;
var Modulus = pubKey.Modulus;
// Generate list of rho values
PermutationTest.GetRhos(m2, ps, pubKey, keySize, out byte[][] rhoValues);
Console.WriteLine(String.Join(",", rhoValues.Select(a => new BigInteger(1, a))));
}
public void Get_m1_m2Test()
{
// Get_m1_m2 produce outputs that match those in Section 2.7 of setup.pdf
var k = 128;
var Exp = 65537;
PermutationTest.Get_m1_m2(41, Exp, k, out int m1, out int m2);
Assert.IsTrue(m1.Equals(24) && m2.Equals(24));
PermutationTest.Get_m1_m2(89, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(20) && m2.Equals(20));
PermutationTest.Get_m1_m2(191, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(17) && m2.Equals(17));
PermutationTest.Get_m1_m2(937, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(13) && m2.Equals(13));
PermutationTest.Get_m1_m2(1667, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(12) && m2.Equals(12));
PermutationTest.Get_m1_m2(3187, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(11) && m2.Equals(12));
}
public void Get_m1_m2Test()
{
// Get_m1_m2 produce outputs that match those in Section 2.7 of setup.pdf
var k = 128;
var Exp = 65537;
PermutationTest.Get_m1_m2(41, Exp, k, out int m1, out int m2);
Assert.IsTrue(m1.Equals(25) && m2.Equals(25));
PermutationTest.Get_m1_m2(997, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(13) && m2.Equals(13));
PermutationTest.Get_m1_m2(4999, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(11) && m2.Equals(11));
PermutationTest.Get_m1_m2(7649, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(10) && m2.Equals(11));
PermutationTest.Get_m1_m2(20663, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(9) && m2.Equals(10));
PermutationTest.Get_m1_m2(33469, Exp, k, out m1, out m2);
Assert.IsTrue(m1.Equals(9) && m2.Equals(9));
}
public void CheckAlphaNTest2()
{
// CheckAlphaN outputs fail if N is even.
// Sanity check
var keyPair = TestUtils.GeneratePrivate(Exp, setup.KeySize);
var privKey = (RsaPrivateCrtKeyParameters)keyPair.Private;
var pubKey = (RsaKeyParameters)keyPair.Public;
var Modulus = pubKey.Modulus;
var ModBytes = Modulus.ToByteArrayUnsigned();
// Make the LSB a zero to make it even.
ModBytes[ModBytes.Length - 1] &= (byte)0xfe;
Modulus = new BigInteger(1, ModBytes);
// Assert CheckAlphaN returns False
Assert.IsFalse(PermutationTest.CheckAlphaN(alpha, Modulus));
}
public void CheckAlphaNTest1()
{
// CheckAlphaN outputs fail if N has some prime number p < alpha as a factor.
BigInteger p, q;
// prime that comes immediately before alpha
var primeN = Utils.Primes(alpha - 1).Last();
p = BigInteger.ValueOf(primeN);
int pbitlength = p.BitLength;
int qbitlength = (setup.KeySize - pbitlength);
// Generate q
q = TestUtils.GenQ(p, qbitlength, setup.KeySize, Exp);
var Modulus = p.Multiply(q);
// Assert CheckAlphaN returns False
Assert.IsFalse(PermutationTest.CheckAlphaN(alpha, Modulus));
}
public void GetRhosTest()
{
// GetRhos is really producing outputs rho that are<N and have GCD(N, rho) = 1
int m2 = 11;
var keyPair = TestUtils.GeneratePrivate(Exp, setup.KeySize);
var privKey = (RsaPrivateCrtKeyParameters)keyPair.Private;
var pubKey = (RsaKeyParameters)keyPair.Public;
var Modulus = pubKey.Modulus;
// Generate list of rho values
PermutationTest.GetRhos(m2, ps, pubKey, setup.KeySize, out byte[][] rhoValues);
for (int i = 0; i < rhoValues.Length; i++)
{
// Convert rho value to a number
var num = Utils.OS2IP(rhoValues[i]);
// Assert the number is less than N
Assert.IsTrue(num.CompareTo(Modulus) < 0);
// Assert GCD(rho, N) == 1
Assert.IsTrue(Modulus.Gcd(num).Equals(BigInteger.One));
}
}
public void BenchmarkPermutationTest()
{
Console.WriteLine($"Parameters,,, {keySizeList[0]}-bit RSA,, {keySizeList[1]}-bit RSA,, {keySizeList[2]}-bit RSA,");
Console.WriteLine("alpha, m1, m2, Prove, Verify, Prove, Verify, Prove, Verify");
foreach (int alpha in alphaList)
{
PermutationTest.Get_m1_m2(alpha, Exp.IntValue, k, out int m1, out int m2);
Console.Write($"{alpha},{m1},{m2}");
foreach (int keySize in keySizeList)
{
double ProvingTime = 0.0;
double VerifyingTime = 0.0;
for (int i = 0; i < iterations; i++)
{
_ProvingAndVerifyingTest1(Exp, keySize, alpha, out double subPTime, out double subVTime);
ProvingTime += subPTime;
VerifyingTime += subVTime;
}
Console.Write($",{ProvingTime / iterations} ,{VerifyingTime / iterations}");
}
Console.WriteLine();
}
}
private static Tuple <RsaKey, RSAKeyData> LoadRSAKeyData(string dataDir, string keyName, bool noRSAProof)
{
RSAKeyData data = new RSAKeyData();
RsaKey key = null;
{
var rsaFile = Path.Combine(dataDir, keyName);
if (!File.Exists(rsaFile))
{
Logs.Configuration.LogWarning("RSA private key not found, please backup it. Creating...");
key = new RsaKey();
File.WriteAllBytes(rsaFile, key.ToBytes());
Logs.Configuration.LogInformation("RSA key saved (" + rsaFile + ")");
}
else
{
Logs.Configuration.LogInformation("RSA private key found (" + rsaFile + ")");
key = new RsaKey(File.ReadAllBytes(rsaFile));
}
}
data.PublicKey = key.PubKey;
if (!noRSAProof)
{
{
var poupard = Path.Combine(dataDir, "ProofPoupard-" + keyName);
PoupardSternProof poupardProof = null;
if (!File.Exists(poupard))
{
Logs.Configuration.LogInformation("Creating Poupard Stern proof...");
poupardProof = PoupardStern.ProvePoupardStern(key._Key, RSAKeyData.PoupardSetup);
MemoryStream ms = new MemoryStream();
BitcoinStream bs = new BitcoinStream(ms, true);
bs.ReadWriteC(ref poupardProof);
File.WriteAllBytes(poupard, ms.ToArray());
Logs.Configuration.LogInformation("Poupard Stern proof created (" + poupard + ")");
}
else
{
Logs.Configuration.LogInformation("Poupard Stern Proof found (" + poupard + ")");
var bytes = File.ReadAllBytes(poupard);
MemoryStream ms = new MemoryStream(bytes);
BitcoinStream bs = new BitcoinStream(ms, false);
bs.ReadWriteC(ref poupardProof);
}
data.PoupardSternProof = poupardProof;
}
{
var permutation = Path.Combine(dataDir, "ProofPermutation-" + keyName);
PermutationTestProof permutationProof = null;
if (!File.Exists(permutation))
{
Logs.Configuration.LogInformation("Creating Permutation Test proof...");
permutationProof = PermutationTest.ProvePermutationTest(key._Key, RSAKeyData.PermutationSetup);
MemoryStream ms = new MemoryStream();
BitcoinStream bs = new BitcoinStream(ms, true);
bs.ReadWriteC(ref permutationProof);
File.WriteAllBytes(permutation, ms.ToArray());
Logs.Configuration.LogInformation("Permutation Test proof created (" + permutation + ")");
}
else
{
Logs.Configuration.LogInformation("Permutation Test Proof found (" + permutation + ")");
var bytes = File.ReadAllBytes(permutation);
MemoryStream ms = new MemoryStream(bytes);
BitcoinStream bs = new BitcoinStream(ms, false);
bs.ReadWriteC(ref permutationProof);
}
data.PermutationTestProof = permutationProof;
}
}
return(Tuple.Create(key, data));
}
