private void DoTestKey(BigInteger keyId, string passphrase, bool utf8) { PgpSecretKeyRingBundle secretKeyRing = LoadSecretKeyCollection("secring.gpg"); PgpSecretKeyRing secretKey = secretKeyRing.GetSecretKeyRing(keyId.LongValue); Assert.NotNull(secretKey, "Could not locate secret keyring with Id=" + keyId.ToString(16)); PgpSecretKey key = secretKey.GetSecretKey(); Assert.NotNull(key, "Could not locate secret key!"); try { char[] pass = passphrase.ToCharArray(); PgpPrivateKey privateKey = utf8 ? key.ExtractPrivateKeyUtf8(pass) : key.ExtractPrivateKey(pass); Assert.IsTrue(privateKey.KeyId == keyId.LongValue); } catch (PgpException e) { throw new PgpException("Password incorrect!", e); } // all fine! }
public BigIntegerRSAPublicKey(RSAParameters rsaParameters) { this.Modulus = new BigInteger(1, rsaParameters.Modulus); this.modulusAsString = Modulus.ToString(10); this.Exponent = new BigInteger(1, rsaParameters.Exponent); this.exponentAsString = Exponent.ToString(10); }
public static string H2hash(BigInteger qid, BigInteger p) { // H2 je RiPEMD-120: točka iz polja -> niz bita mod p string tocka = qid.ToString(); RIPEMD160Managed crypt = new RIPEMD160Managed(); StringBuilder hash = new StringBuilder(); byte[] crypto = crypt.ComputeHash(Encoding.UTF8.GetBytes(tocka), 0, Encoding.UTF8.GetByteCount(tocka)); foreach (byte theByte in crypto) { hash.Append(theByte.ToString("x2")); } BigInteger hsh = new BigInteger(hash.ToString(), 16); // hash mod n BigInteger c = hsh.DivideAndRemainder(p)[1]; return c.ToString(); }
/// <summary> /// millerov agoritam /// </summary> /// <param name="a">točka</param> /// <param name="b">točka</param> /// <param name="m">red grupe</param> /// <param name="p">red polja, prim</param> /// <returns></returns> private static BigInteger Miller(FpPoint P, FpPoint Q, BigInteger m, BigInteger prim) { // Millerov algoritam string mBin = m.ToString(2); BigInteger t1 = new BigInteger("1", 10); BigInteger t2 = new BigInteger("1", 10); FpPoint V = P; for (int i = 0; i < m.BitLength; i++) { V = (FpPoint)V.Twice(); t1 = t1.ModPow(new BigInteger("2", 10), prim).Multiply(MLF(V, V, Q)); if (mBin[i] == '1') { t1 = t1.Multiply(MLF(V, P, Q)); V = (FpPoint)V.Add(P); } } return t1; }
public ITestResult Perform() { BigInteger r = new BigInteger("8f79a582513df84dc247bcb624340cc0e5a34c4324a20ce7fe3ab8ff38a9db71",16); BigInteger s = new BigInteger("7508d22fd6cbb45efd438cb875e43f137247088d0f54b29a7c91f68a65b5fa85",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
public ITestResult Perform() { BigInteger r = new BigInteger("90892707282f433398488f19d31ac48523a8e2ded68944e0da91c6895ee7045e",16); BigInteger s = new BigInteger("3be4620ee88f1ee8f9dd63c7d145b7e554839feeca125049118262ea4651e9de",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
public ITestResult Perform() { BigInteger r = new BigInteger("712592d285b792e33b8a9a11e8e6c4f512ddf0042972bbfd1abb0a93e8fc6f54",16); BigInteger s = new BigInteger("2cf26758321258b130d5612111339f09ceb8668241f3482e38baa56529963f07",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
public ITestResult Perform() { BigInteger r = new BigInteger("860d82c60e9502cd00c0e9e1f6563feafec304801974d745c5e02079946f729e",16); BigInteger s = new BigInteger("7ef49264ef022801aaa03033cd97915235fbab4c823ed936b0f360c22114688a",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
public ITestResult Perform() { BigInteger r = new BigInteger("81d69a192e9c7ac21fc07da41bd07e230ba6a94eb9f3c1fd104c7bd976733ca5",16); BigInteger s = new BigInteger("315c879c8414f35feb4deb15e7cc0278c48e6ca1596325d6959338d860b0c47a",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
public ITestResult Perform() { BigInteger r = new BigInteger("a8790aabbd5a998ff524bad048ac69cd1faff2dab048265c8d60d1471c44a9ee",16); BigInteger s = new BigInteger("30df5ba32ac77170b9632559bef7d37620017756dff3fea1088b4267db0944b8",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 1, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
public void TestToString() { string s = "12345667890987654321"; Assert.AreEqual(s, new BigInteger(s).ToString()); Assert.AreEqual(s, new BigInteger(s, 10).ToString(10)); Assert.AreEqual(s, new BigInteger(s, 16).ToString(16)); for (int i = 0; i < 100; ++i) { BigInteger n = new BigInteger(i, random); Assert.AreEqual(n, new BigInteger(n.ToString(2), 2)); Assert.AreEqual(n, new BigInteger(n.ToString(10), 10)); Assert.AreEqual(n, new BigInteger(n.ToString(16), 16)); } }
public void TestDivideAndRemainder() { // TODO More basic tests BigInteger n = new BigInteger(48, random); BigInteger[] qr = n.DivideAndRemainder(one); Assert.AreEqual(n, qr[0]); Assert.AreEqual(zero, qr[1]); for (int rep = 0; rep < 10; ++rep) { BigInteger a = new BigInteger(100 - rep, 0, random); BigInteger b = new BigInteger(100 + rep, 0, random); BigInteger c = new BigInteger(10 + rep, 0, random); BigInteger d = a.Multiply(b).Add(c); BigInteger[] es = d.DivideAndRemainder(a); Assert.AreEqual(b, es[0]); Assert.AreEqual(c, es[1]); } // Special tests for power of two since uses different code path internally for (int i = 0; i < 100; ++i) { int shift = random.Next(64); BigInteger a = one.ShiftLeft(shift); BigInteger b = new BigInteger(64 + random.Next(64), random); BigInteger bShift = b.ShiftRight(shift); BigInteger bMod = b.And(a.Subtract(one)); string data = "shift=" + shift +", b=" + b.ToString(16); qr = b.DivideAndRemainder(a); Assert.AreEqual(bShift, qr[0], data); Assert.AreEqual(bMod, qr[1], data); qr = b.DivideAndRemainder(a.Negate()); Assert.AreEqual(bShift.Negate(), qr[0], data); Assert.AreEqual(bMod, qr[1], data); qr = b.Negate().DivideAndRemainder(a); Assert.AreEqual(bShift.Negate(), qr[0], data); Assert.AreEqual(bMod.Negate(), qr[1], data); qr = b.Negate().DivideAndRemainder(a.Negate()); Assert.AreEqual(bShift, qr[0], data); Assert.AreEqual(bMod.Negate(), qr[1], data); } }
public void TestDivide() { for (int i = -5; i <= 5; ++i) { try { val(i).Divide(zero); Assert.Fail("expected ArithmeticException"); } catch (ArithmeticException) {} } int product = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9; int productPlus = product + 1; BigInteger bigProduct = val(product); BigInteger bigProductPlus = val(productPlus); for (int divisor = 1; divisor < 10; ++divisor) { // Exact division BigInteger expected = val(product / divisor); Assert.AreEqual(expected, bigProduct.Divide(val(divisor))); Assert.AreEqual(expected.Negate(), bigProduct.Negate().Divide(val(divisor))); Assert.AreEqual(expected.Negate(), bigProduct.Divide(val(divisor).Negate())); Assert.AreEqual(expected, bigProduct.Negate().Divide(val(divisor).Negate())); expected = val((product + 1)/divisor); Assert.AreEqual(expected, bigProductPlus.Divide(val(divisor))); Assert.AreEqual(expected.Negate(), bigProductPlus.Negate().Divide(val(divisor))); Assert.AreEqual(expected.Negate(), bigProductPlus.Divide(val(divisor).Negate())); Assert.AreEqual(expected, bigProductPlus.Negate().Divide(val(divisor).Negate())); } for (int rep = 0; rep < 10; ++rep) { BigInteger a = new BigInteger(100 - rep, 0, random); BigInteger b = new BigInteger(100 + rep, 0, random); BigInteger c = new BigInteger(10 + rep, 0, random); BigInteger d = a.Multiply(b).Add(c); BigInteger e = d.Divide(a); Assert.AreEqual(b, e); } // Special tests for power of two since uses different code path internally for (int i = 0; i < 100; ++i) { int shift = random.Next(64); BigInteger a = one.ShiftLeft(shift); BigInteger b = new BigInteger(64 + random.Next(64), random); BigInteger bShift = b.ShiftRight(shift); string data = "shift=" + shift +", b=" + b.ToString(16); Assert.AreEqual(bShift, b.Divide(a), data); Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data); Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data); Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data); } // Regression { int shift = 63; BigInteger a = one.ShiftLeft(shift); BigInteger b = new BigInteger(1, Hex.Decode("2504b470dc188499")); BigInteger bShift = b.ShiftRight(shift); string data = "shift=" + shift +", b=" + b.ToString(16); Assert.AreEqual(bShift, b.Divide(a), data); Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data); // Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data); Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data); } }
// Miller "function" private static BigInteger MLF(FpPoint P, FpPoint R, FpPoint Q) { if (!P.Equals(R)) { if (P.X.Equals(R.X)) { return Q.X.Subtract(P.X).ToBigInteger(); } else { BigInteger l = R.Y.Subtract(P.Y).Divide((R.X.Subtract(P.X))).ToBigInteger(); return Q.Y.Subtract(P.Y).ToBigInteger().Subtract(l.Multiply((Q.X.Subtract(P.X).ToBigInteger()))); } } else { // z*y^2=d*x^3+a*x+b -> derivacija po x -> 3*x^2+a BigInteger brojnik = new BigInteger("3", 10).Multiply(P.X.ToBigInteger().Pow(2)); // z*y^2=d*x^3+a*x+b -> derivacija po y -> 2*y BigInteger nazivnik = new BigInteger("2", 10).Multiply(P.Y.ToBigInteger()); if (nazivnik.ToString(10) == "0") { return (Q.X.ToBigInteger().Subtract(P.X.ToBigInteger())); } else { double koef = (double)(brojnik.IntValue / nazivnik.IntValue); double rez = Q.Y.Subtract(P.Y).ToBigInteger().IntValue - koef * (Q.X.Subtract(P.X).ToBigInteger().IntValue); return new BigInteger(rez.ToString(), 10); } } }
public System.Numerics.BigInteger[] Merge(Part[][] parts, int threshold) { Org.BouncyCastle.Math.BigInteger p1 = new Org.BouncyCastle.Math.BigInteger(p.ToString()); Console.WriteLine("p1" + p1.ToString()); int secretSize = parts[0].Length; Console.WriteLine("secretsize" + secretSize); System.Numerics.BigInteger[] results = new System.Numerics.BigInteger[secretSize]; string[] secret = new string[secretSize]; byte[] ba; string str; int count = 0; // loop through each secret partition for (int i = 0; i < secretSize; i++) { Sum = System.Numerics.BigInteger.Zero; //doing lagrange interpolation for (int j = 0; j < threshold; j++) { mult = System.Numerics.BigInteger.One; for (int k = 0; k < threshold; k++) { if (j != k) { System.Numerics.BigInteger numerator = parts[k][i].GetX(); System.Numerics.BigInteger denominator = System.Numerics.BigInteger.Subtract(numerator, parts[j][i].GetX()); // take mod of negative number while (System.Numerics.BigInteger.Compare(denominator, System.Numerics.BigInteger.Zero) < 0) { denominator = System.Numerics.BigInteger.Add(denominator, p); } //convert to bouncycastle biginteger to calculate modInverse Org.BouncyCastle.Math.BigInteger denominator1 = new Org.BouncyCastle.Math.BigInteger(denominator.ToString()); Org.BouncyCastle.Math.BigInteger invDenominator1 = denominator1.ModInverse(p1); System.Numerics.BigInteger invDenominator = System.Numerics.BigInteger.Parse(invDenominator1.ToString()); mult = System.Numerics.BigInteger.Multiply(mult, System.Numerics.BigInteger.Multiply(numerator, invDenominator)); mult = System.Numerics.BigInteger.Remainder(mult, p); } } mult = System.Numerics.BigInteger.Multiply(mult, parts[j][i].GetY()); mult = System.Numerics.BigInteger.Remainder(mult, p); Sum = System.Numerics.BigInteger.Add(Sum, mult); Sum = System.Numerics.BigInteger.Remainder(Sum, p); } results[i] = Sum; } foreach (System.Numerics.BigInteger r in results) { //Console.WriteLine(r); //System.Numerics.BigInteger.TryParse ba = r.ToByteArray(); str = Encoding.UTF8.GetString(ba); //Console.WriteLine(str); secret[count++] = str; } str = string.Join("", secret); str.Replace("\n", ""); return(results); }
public ITestResult Perform() { BigInteger r = new BigInteger("7c07c8cf035c2a1cb2b7fae5807ac7cd623dfca7a1a68f6d858317822f1ea00d",16); BigInteger s = new BigInteger("7e9e036a6ff87dbf9b004818252b1f6fc310bdd4d17cb8c37d9c36c7884de60c",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(512, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!init_random.IsExhausted) { return new SimpleTestResult(false, Name + ": unexpected number of bytes used from 'init_random'."); } if (parameters.ValidationParameters == null) { return new SimpleTestResult(false, Name + ": validation parameters wrong"); } if (parameters.ValidationParameters.CL != 13 || parameters.ValidationParameters.X0L != 1039943409) { return new SimpleTestResult(false, Name + ": validation parameters values wrong"); } if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); if (!keyRandom.IsExhausted) { return new SimpleTestResult(false, Name + ": unexpected number of bytes used from 'keyRandom'."); } ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!random.IsExhausted) { return new SimpleTestResult(false, Name + ": unexpected number of bytes used from 'random'."); } if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (!Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(false, Name + ": verification fails"); } return new SimpleTestResult(true, Name + ": Okay"); }
public ITestResult Perform() { BigInteger r = new BigInteger("169fdb2dc09f690b71332432bfec806042e258fa9a21dafe73c6abfbc71407d9",16); BigInteger s = new BigInteger("9002551808ae40d19f6f31fb67e4563101243cf07cffd5f2f8ff4c537b0c9866",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
// Only the ctor should be calling with isAuthority = true // if isAuthority, value for isMachineCert doesn't matter private X509CertificateContainer CreateCertificate(bool isAuthority, bool isMachineCert, X509Certificate signingCertificate, CertificateCreationSettings certificateCreationSettings) { if (certificateCreationSettings == null) { if (isAuthority) { certificateCreationSettings = new CertificateCreationSettings(); } else { throw new Exception("Parameter certificateCreationSettings cannot be null when isAuthority is false"); } } // Set to default cert creation settings if not set if (certificateCreationSettings.ValidityNotBefore == default(DateTime)) { certificateCreationSettings.ValidityNotBefore = _defaultValidityNotBefore; } if (certificateCreationSettings.ValidityNotAfter == default(DateTime)) { certificateCreationSettings.ValidityNotAfter = _defaultValidityNotAfter; } if (!isAuthority ^ (signingCertificate != null)) { throw new ArgumentException("Either isAuthority == true or signingCertificate is not null"); } string subject = certificateCreationSettings.Subject; // If certificateCreationSettings.SubjectAlternativeNames == null, then we should add exactly one SubjectAlternativeName == Subject // so that the default certificate generated is compatible with mainline scenarios // However, if certificateCreationSettings.SubjectAlternativeNames == string[0], then allow this as this is a legit scenario we want to test out if (certificateCreationSettings.SubjectAlternativeNames == null) { certificateCreationSettings.SubjectAlternativeNames = new string[1] { subject }; } string[] subjectAlternativeNames = certificateCreationSettings.SubjectAlternativeNames; if (!isAuthority && string.IsNullOrWhiteSpace(subject)) { throw new ArgumentException("Certificate Subject must not be an empty string or only whitespace", "creationSettings.Subject"); } EnsureInitialized(); s_certGenerator.Reset(); s_certGenerator.SetSignatureAlgorithm(_signatureAlthorithm); X509Name authorityX509Name = CreateX509Name(_authorityCanonicalName); var serialNum = new BigInteger(64 /*sizeInBits*/, _random).Abs(); var keyPair = isAuthority ? _authorityKeyPair : _keyPairGenerator.GenerateKeyPair(); if (isAuthority) { s_certGenerator.SetIssuerDN(authorityX509Name); s_certGenerator.SetSubjectDN(authorityX509Name); var authorityKeyIdentifier = new AuthorityKeyIdentifier( SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(_authorityKeyPair.Public), new GeneralNames(new GeneralName(authorityX509Name)), serialNum); s_certGenerator.AddExtension(X509Extensions.AuthorityKeyIdentifier, false, authorityKeyIdentifier); s_certGenerator.AddExtension(X509Extensions.KeyUsage, false, new KeyUsage(X509KeyUsage.DigitalSignature | X509KeyUsage.KeyAgreement | X509KeyUsage.KeyCertSign | X509KeyUsage.KeyEncipherment | X509KeyUsage.CrlSign)); } else { X509Name subjectName = CreateX509Name(subject); s_certGenerator.SetIssuerDN(PrincipalUtilities.GetSubjectX509Principal(signingCertificate)); s_certGenerator.SetSubjectDN(subjectName); s_certGenerator.AddExtension(X509Extensions.AuthorityKeyIdentifier, false, new AuthorityKeyIdentifierStructure(_authorityKeyPair.Public)); s_certGenerator.AddExtension(X509Extensions.KeyUsage, false, new KeyUsage(X509KeyUsage.DigitalSignature | X509KeyUsage.KeyAgreement | X509KeyUsage.KeyEncipherment)); } s_certGenerator.AddExtension(X509Extensions.SubjectKeyIdentifier, false, new SubjectKeyIdentifierStructure(keyPair.Public)); s_certGenerator.SetSerialNumber(serialNum); s_certGenerator.SetNotBefore(certificateCreationSettings.ValidityNotBefore); s_certGenerator.SetNotAfter(certificateCreationSettings.ValidityNotAfter); s_certGenerator.SetPublicKey(keyPair.Public); s_certGenerator.AddExtension(X509Extensions.BasicConstraints, true, new BasicConstraints(isAuthority)); s_certGenerator.AddExtension(X509Extensions.ExtendedKeyUsage, false, new ExtendedKeyUsage(KeyPurposeID.IdKPServerAuth, KeyPurposeID.IdKPClientAuth)); if (!isAuthority) { if (isMachineCert) { List<Asn1Encodable> subjectAlternativeNamesAsAsn1EncodableList = new List<Asn1Encodable>(); // All endpoints should also be in the Subject Alt Names for (int i = 0; i < subjectAlternativeNames.Length; i++) { if (!string.IsNullOrWhiteSpace(subjectAlternativeNames[i])) { // Machine certs can have additional DNS names subjectAlternativeNamesAsAsn1EncodableList.Add(new GeneralName(GeneralName.DnsName, subjectAlternativeNames[i])); } } s_certGenerator.AddExtension(X509Extensions.SubjectAlternativeName, true, new DerSequence(subjectAlternativeNamesAsAsn1EncodableList.ToArray())); } else { if (subjectAlternativeNames.Length > 1) { var subjectAlternativeNamesAsAsn1EncodableList = new Asn1EncodableVector(); // Only add a SAN for the user if there are any for (int i = 1; i < subjectAlternativeNames.Length; i++) { if (!string.IsNullOrWhiteSpace(subjectAlternativeNames[i])) { Asn1EncodableVector otherNames = new Asn1EncodableVector(); otherNames.Add(new DerObjectIdentifier(_upnObjectId)); otherNames.Add(new DerTaggedObject(true, 0, new DerUtf8String(subjectAlternativeNames[i]))); Asn1Object genName = new DerTaggedObject(false, 0, new DerSequence(otherNames)); subjectAlternativeNamesAsAsn1EncodableList.Add(genName); } } s_certGenerator.AddExtension(X509Extensions.SubjectAlternativeName, true, new DerSequence(subjectAlternativeNamesAsAsn1EncodableList)); } } } // Our CRL Distribution Point has the serial number in the query string to fool Windows into doing a fresh query // rather than using a cached copy of the CRL in the case where the CRL has been previously accessed before var crlDistributionPoints = new DistributionPoint[2] { new DistributionPoint(new DistributionPointName( new GeneralNames(new GeneralName( GeneralName.UniformResourceIdentifier, string.Format("{0}?serialNum={1}", _crlUri, serialNum.ToString(radix: 16))))), null, null), new DistributionPoint(new DistributionPointName( new GeneralNames(new GeneralName( GeneralName.UniformResourceIdentifier, string.Format("{0}?serialNum={1}", _crlUri, serialNum.ToString(radix: 16))))), null, new GeneralNames(new GeneralName(authorityX509Name))) }; var revocationListExtension = new CrlDistPoint(crlDistributionPoints); s_certGenerator.AddExtension(X509Extensions.CrlDistributionPoints, false, revocationListExtension); X509Certificate cert = s_certGenerator.Generate(_authorityKeyPair.Private, _random); switch (certificateCreationSettings.ValidityType) { case CertificateValidityType.Revoked: RevokeCertificateBySerialNumber(serialNum.ToString(radix: 16)); break; case CertificateValidityType.Expired: break; default: EnsureCertificateIsValid(cert); break; } // For now, given that we don't know what format to return it in, preserve the formats so we have // the flexibility to do what we need to X509CertificateContainer container = new X509CertificateContainer(); X509CertificateEntry[] chain = new X509CertificateEntry[1]; chain[0] = new X509CertificateEntry(cert); Pkcs12Store store = new Pkcs12StoreBuilder().Build(); store.SetKeyEntry( certificateCreationSettings.FriendlyName != null ? certificateCreationSettings.FriendlyName : string.Empty, new AsymmetricKeyEntry(keyPair.Private), chain); using (MemoryStream stream = new MemoryStream()) { store.Save(stream, _password.ToCharArray(), _random); container.Pfx = stream.ToArray(); } X509Certificate2 outputCert; if (isAuthority) { // don't hand out the private key for the cert when it's the authority outputCert = new X509Certificate2(cert.GetEncoded()); } else { // Otherwise, allow encode with the private key. note that X509Certificate2.RawData will not provide the private key // you will have to re-export this cert if needed outputCert = new X509Certificate2(container.Pfx, _password, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet); } container.Subject = subject; container.InternalCertificate = cert; container.Certificate = outputCert; container.Thumbprint = outputCert.Thumbprint; Trace.WriteLine("[CertificateGenerator] generated a certificate:"); Trace.WriteLine(string.Format(" {0} = {1}", "isAuthority", isAuthority)); if (!isAuthority) { Trace.WriteLine(string.Format(" {0} = {1}", "Signed by", signingCertificate.SubjectDN)); Trace.WriteLine(string.Format(" {0} = {1}", "Subject (CN) ", subject)); Trace.WriteLine(string.Format(" {0} = {1}", "Subject Alt names ", string.Join(", ", subjectAlternativeNames))); Trace.WriteLine(string.Format(" {0} = {1}", "Friendly Name ", certificateCreationSettings.FriendlyName)); } Trace.WriteLine(string.Format(" {0} = {1}", "HasPrivateKey:", outputCert.HasPrivateKey)); Trace.WriteLine(string.Format(" {0} = {1}", "Thumbprint", outputCert.Thumbprint)); Trace.WriteLine(string.Format(" {0} = {1}", "CertificateValidityType", certificateCreationSettings.ValidityType)); return container; }
public ITestResult Perform() { BigInteger r = new BigInteger("3e5f895e276d81d2d52c0763270a458157b784c57abdbd807bc44fd43a32ac06",16); BigInteger s = new BigInteger("3f0dd5d4400d47c08e4ce505ff7434b6dbf729592e37c74856dab85115a60955",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(512, 1, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (parameters.ValidationParameters == null) { return new SimpleTestResult(false, Name + "validation parameters wrong"); } if (parameters.ValidationParameters.C != 29505 || parameters.ValidationParameters.X0 != 24265) { return new SimpleTestResult(false, Name + "validation parameters values wrong"); } if (!init_random.IsExhausted) { return new SimpleTestResult(false, Name + ": unexpected number of bytes used from 'init_random'."); } if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); if (!keyRandom.IsExhausted) { return new SimpleTestResult(false, Name + ": unexpected number of bytes used from 'keyRandom'."); } ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer gost3410 = new Gost3410Signer(); gost3410.Init(true, param); BigInteger[] sig = gost3410.GenerateSignature(hashmessage); if (!random.IsExhausted) { return new SimpleTestResult(false, Name + ": unexpected number of bytes used from 'random'."); } if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } gost3410.Init(false, pair.Public); if (gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
/// <summary> /// Generate a set of M-of-N parts for a specific private key. /// If desiredPrivKey is null, then a random key will be selected. /// </summary> public void Generate(int PartsNeededToDecode, int PartsToGenerate, byte[] desiredPrivKey) { if (PartsNeededToDecode > PartsToGenerate) { throw new ApplicationException("Number of parts needed exceeds number of parts to generate."); } if (PartsNeededToDecode > 8 || PartsToGenerate > 8) { throw new ApplicationException("Maximum number of parts is 8"); } if (PartsNeededToDecode < 1 || PartsToGenerate < 1) { throw new ApplicationException("Minimum number of parts is 1"); } if (desiredPrivKey != null && desiredPrivKey.Length != 32) { throw new ApplicationException("Desired private key must be 32 bytes"); } KeyParts.Clear(); decodedKeyParts.Clear(); SecureRandom sr = new SecureRandom(); // Get 8 random big integers into v[i]. byte[][] vvv = new byte[8][]; BigInteger[] v = new BigInteger[8]; for (int i = 0; i < 8; i++) { byte[] b = new byte[32]; sr.NextBytes(b, 0, 32); // For larger values of i, chop off some most-significant-bits to prevent overflows as they are // multiplied with increasingly larger factors. if (i >= 7) { b[0] &= 0x7f; } v[i] = new BigInteger(1, b); Debug.WriteLine(String.Format("v({0})={1}", i, v[i].ToString())); } // if a certain private key is desired, then specify it. if (desiredPrivKey != null) { // replace v[0] with xor(v[1...7]) xor desiredPrivKey BigInteger newv0 = BigInteger.Zero; for (int i=1; i<PartsNeededToDecode; i++) { newv0 = newv0.Xor(v[i]); } v[0] = newv0.Xor(new BigInteger(1,desiredPrivKey)); } // Generate the expected private key from all the parts BigInteger privkey = new BigInteger("0"); for (int i = 0; i < PartsNeededToDecode; i++) { privkey = privkey.Xor(v[i]); } // Get the bitcoin address byte[] keybytes = privkey.ToByteArrayUnsigned(); // make sure we have 32 bytes, we'll need it if (keybytes.Length < 32) { byte[] array32 = new byte[32]; Array.Copy(keybytes, 0, array32, 32 - keybytes.Length, keybytes.Length); keybytes = array32; } KeyPair = new KeyPair(keybytes); byte[] checksum = Util.ComputeSha256(BitcoinAddress); // Generate the parts for (int i = 0; i < PartsToGenerate; i++) { BigInteger total = new BigInteger("0"); for (int j = 0; j < PartsNeededToDecode; j++) { int factor = 1; for (int ii = 0; ii <= i; ii++) factor = factor * (j + 1); BigInteger bfactor = new BigInteger(factor.ToString()); total = total.Add(v[j].Multiply(bfactor)); } Debug.WriteLine(String.Format(" pc{0}={1}", i, total.ToString())); byte[] parts = new byte[39]; parts[0] = 0x4f; parts[1] = (byte)(0x93 + PartsNeededToDecode); int parts23 = (((checksum[0] << 8) + checksum[1]) & 0x1ff); Debug.WriteLine("checksum " + parts23.ToString()); parts23 += 0x6000; parts23 += (i << 9); byte[] btotal = total.ToByteArrayUnsigned(); for (int jj = 0; jj < btotal.Length; jj++) { parts[jj + 4 + (35 - btotal.Length)] = btotal[jj]; } parts[2] = (byte)((parts23 & 0xFF00) >> 8); parts[3] = (byte)(parts23 & 0xFF); KeyParts.Add(Util.ByteArrayToBase58Check(parts)); decodedKeyParts.Add(parts); } }
public ITestResult Perform() { BigInteger r = new BigInteger("64a8856628e5669d85f62cd763dd4a99bc56d33dc0e1859122855d141e9e4774",16); BigInteger s = new BigInteger("319ebac97092b288d469a4b988248794f60c865bc97858d9a3135c6d1a1bf2dd",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
/// <summary> /// Increments the serial number in the serial file /// </summary> public void IncrementSerial() { String txt = File.ReadAllText(SerialFile); var bi = new BigInteger(txt, SerialNumberRadix); bi = bi.Add(BigInteger.One); File.WriteAllText(SerialFile, bi.ToString(SerialNumberRadix)); }
public ITestResult Perform() { BigInteger r = new BigInteger("4deb95a0b35e7ed7edebe9bef5a0f93739e16b7ff27fe794d989d0c13159cfbc",16); BigInteger s = new BigInteger("e1d0d30345c24cfeb33efde3deee5fbbda78ddc822b719d860cd0ba1fb6bd43b",16); Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator(); pGen.Init(1024, 2, init_random); Gost3410Parameters parameters = pGen.GenerateParameters(); if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q)) { return new SimpleTestResult(false, Name + ": p or q wrong"); } Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator(); Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters); Gost3410KeyGen.Init(genParam); AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair(); ParametersWithRandom param = new ParametersWithRandom(pair.Private, random); Gost3410Signer Gost3410 = new Gost3410Signer(); Gost3410.Init(true, param); BigInteger[] sig = Gost3410.GenerateSignature(hashmessage); if (!r.Equals(sig[0])) { return new SimpleTestResult(false, Name + ": r component wrong." + SimpleTest.NewLine + " expecting: " + r.ToString(16) + SimpleTest.NewLine + " got : " + sig[0].ToString(16)); } if (!s.Equals(sig[1])) { return new SimpleTestResult(false, Name + ": s component wrong." + SimpleTest.NewLine + " expecting: " + s.ToString(16) + SimpleTest.NewLine + " got : " + sig[1].ToString(16)); } Gost3410.Init(false, pair.Public); if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1])) { return new SimpleTestResult(true, Name + ": Okay"); } else { return new SimpleTestResult(false, Name + ": verification fails"); } }
public void TestToString() { string s = "12345667890987654321"; Assert.AreEqual(s, new BigInteger(s).ToString()); Assert.AreEqual(s, new BigInteger(s, 10).ToString(10)); Assert.AreEqual(s, new BigInteger(s, 16).ToString(16)); for (int i = 0; i < 100; ++i) { BigInteger n = new BigInteger(i, random); Assert.AreEqual(n, new BigInteger(n.ToString(2), 2)); Assert.AreEqual(n, new BigInteger(n.ToString(10), 10)); Assert.AreEqual(n, new BigInteger(n.ToString(16), 16)); } // Radix version int[] radices = new int[] { 2, 8, 10, 16 }; int trials = 256; BigInteger[] tests = new BigInteger[trials]; for (int i = 0; i < trials; ++i) { int len = random.Next(i + 1); tests[i] = new BigInteger(len, random); } foreach (int radix in radices) { for (int i = 0; i < trials; ++i) { BigInteger n1 = tests[i]; string str = n1.ToString(radix); BigInteger n2 = new BigInteger(str, radix); Assert.AreEqual(n1, n2); } } }