diff --git a/crypto/test/src/security/test/SecureRandomTest.cs b/crypto/test/src/security/test/SecureRandomTest.cs
new file mode 100644
index 000000000..12e4b9a47
--- /dev/null
+++ b/crypto/test/src/security/test/SecureRandomTest.cs
@@ -0,0 +1,150 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Prng;
+
+namespace Org.BouncyCastle.Security.Tests
+{
+ [TestFixture]
+ public class SecureRandomTest
+ {
+#if !NETCF_1_0
+ [Test]
+ public void TestCryptoApi()
+ {
+ SecureRandom random = new SecureRandom(
+ new CryptoApiRandomGenerator());
+
+ checkSecureRandom(random);
+ }
+#endif
+
+ [Test]
+ public void TestDefault()
+ {
+ SecureRandom random = new SecureRandom();
+
+ checkSecureRandom(random);
+ }
+
+ [Test]
+ public void TestSha1Prng()
+ {
+ SecureRandom random = SecureRandom.GetInstance("SHA1PRNG");
+ random.SetSeed(SecureRandom.GetSeed(20));
+
+ checkSecureRandom(random);
+ }
+
+ [Test]
+ public void TestSha256Prng()
+ {
+ SecureRandom random = SecureRandom.GetInstance("SHA256PRNG");
+ random.SetSeed(SecureRandom.GetSeed(32));
+
+ checkSecureRandom(random);
+ }
+
+ [Test]
+ public void TestThreadedSeed()
+ {
+ SecureRandom random = new SecureRandom(
+ new ThreadedSeedGenerator().GenerateSeed(20, false));
+
+ checkSecureRandom(random);
+ }
+
+ [Test]
+ public void TestVmpcPrng()
+ {
+ SecureRandom random = new SecureRandom(new VmpcRandomGenerator());
+ random.SetSeed(SecureRandom.GetSeed(32));
+
+ checkSecureRandom(random);
+ }
+
+
+ private static void checkSecureRandom(
+ SecureRandom random)
+ {
+ // Note: This will periodically (< 1e-6 probability) give a false alarm.
+ // That's randomness for you!
+ Assert.IsTrue(runChiSquaredTests(random), "Chi2 test detected possible non-randomness");
+ }
+
+ private static bool runChiSquaredTests(
+ SecureRandom random)
+ {
+ int passes = 0;
+
+ for (int tries = 0; tries < 100; ++tries)
+ {
+ double chi2 = measureChiSquared(random, 1000);
+ if (chi2 < 285.0) // 255 degrees of freedom in test => Q ~ 10.0% for 285
+ ++passes;
+ }
+
+ return passes > 75;
+ }
+
+ private static double measureChiSquared(
+ SecureRandom random,
+ int rounds)
+ {
+ int[] counts = new int[256];
+
+ byte[] bs = new byte[256];
+ for (int i = 0; i < rounds; ++i)
+ {
+ random.NextBytes(bs);
+
+ for (int b = 0; b < 256; ++b)
+ {
+ ++counts[bs[b]];
+ }
+ }
+
+ byte mask = SecureRandom.GetSeed(1)[0];
+ for (int i = 0; i < rounds; ++i)
+ {
+ random.NextBytes(bs);
+
+ for (int b = 0; b < 256; ++b)
+ {
+ ++counts[bs[b] ^ mask];
+ }
+
+ ++mask;
+ }
+
+ byte shift = SecureRandom.GetSeed(1)[0];
+ for (int i = 0; i < rounds; ++i)
+ {
+ random.NextBytes(bs);
+
+ for (int b = 0; b < 256; ++b)
+ {
+ ++counts[(byte)(bs[b] + shift)];
+ }
+
+ ++shift;
+ }
+
+ int total = 3 * rounds;
+
+ double chi2 = 0;
+ for (int k = 0; k < counts.Length; ++k)
+ {
+ double diff = ((double) counts[k]) - total;
+ double diff2 = diff * diff;
+
+ chi2 += diff2;
+ }
+
+ chi2 /= total;
+
+ return chi2;
+ }
+ }
+}
diff --git a/crypto/test/src/security/test/TestDigestUtil.cs b/crypto/test/src/security/test/TestDigestUtil.cs
new file mode 100644
index 000000000..0f169f931
--- /dev/null
+++ b/crypto/test/src/security/test/TestDigestUtil.cs
@@ -0,0 +1,63 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Digests;
+
+namespace Org.BouncyCastle.Security.Tests
+{
+ [TestFixture]
+ public class TestDigestUtilities
+ {
+ private static readonly byte[] TestBytes = new byte[100];
+
+ static TestDigestUtilities()
+ {
+ new SecureRandom().NextBytes(TestBytes);
+ }
+
+ [Test]
+ public void TestAlgorithms()
+ {
+ CheckAlgorithm("GOST3411", new Gost3411Digest());
+ CheckAlgorithm("MD2", new MD2Digest());
+ CheckAlgorithm("MD4", new MD4Digest());
+ CheckAlgorithm("MD5", new MD5Digest());
+ CheckAlgorithm("RipeMD128", new RipeMD128Digest());
+ CheckAlgorithm("RipeMD160", new RipeMD160Digest());
+ CheckAlgorithm("RipeMD256", new RipeMD256Digest());
+ CheckAlgorithm("RipeMD320", new RipeMD320Digest());
+ CheckAlgorithm("SHA-1", new Sha1Digest());
+ CheckAlgorithm("SHA-224", new Sha224Digest());
+ CheckAlgorithm("SHA-256", new Sha256Digest());
+ CheckAlgorithm("SHA-384", new Sha384Digest());
+ CheckAlgorithm("SHA-512", new Sha512Digest());
+ CheckAlgorithm("Tiger", new TigerDigest());
+ CheckAlgorithm("Whirlpool", new WhirlpoolDigest());
+ }
+
+ private void CheckAlgorithm(
+ string name,
+ IDigest digest)
+ {
+ byte[] hash1 = MakeTestHash(digest);
+ byte[] hash2 = MakeTestHash(DigestUtilities.GetDigest(name));
+
+ Assert.AreEqual(hash1, hash2, name);
+ }
+
+ private byte[] MakeTestHash(
+ IDigest digest)
+ {
+ for (int i = 0; i < digest.GetDigestSize(); ++i)
+ {
+ digest.Update((byte) i);
+ }
+
+ digest.BlockUpdate(TestBytes, 0, TestBytes.Length);
+
+ return DigestUtilities.DoFinal(digest);
+ }
+ }
+}
diff --git a/crypto/test/src/security/test/TestDotNetUtil.cs b/crypto/test/src/security/test/TestDotNetUtil.cs
new file mode 100644
index 000000000..f880b388f
--- /dev/null
+++ b/crypto/test/src/security/test/TestDotNetUtil.cs
@@ -0,0 +1,88 @@
+#if !(NETCF_1_0 || SILVERLIGHT)
+
+using System;
+using System.Security.Cryptography;
+using SystemX509 = System.Security.Cryptography.X509Certificates;
+using System.Collections;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.X509;
+
+namespace Org.BouncyCastle.Security.Tests
+{
+ [TestFixture]
+ public class TestDotNetUtilities
+ {
+ [Test]
+ public void TestRsaInterop()
+ {
+ for (int i = 0; i < 100; ++i)
+ {
+ RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(512);
+ RSAParameters rp = rsa.ExportParameters(true);
+ AsymmetricCipherKeyPair kp = DotNetUtilities.GetRsaKeyPair(rp);
+
+ DotNetUtilities.ToRSA((RsaKeyParameters)kp.Public);
+ // TODO This method appears to not work for private keys (when no CRT info)
+ //DotNetUtilities.ToRSA((RsaKeyParameters)kp.Private);
+ DotNetUtilities.ToRSA((RsaPrivateCrtKeyParameters)kp.Private);
+ }
+ }
+
+ [Test]
+ public void TestX509CertificateConversion()
+ {
+ BigInteger DSAParaG = new BigInteger(Base64.Decode("AL0fxOTq10OHFbCf8YldyGembqEu08EDVzxyLL29Zn/t4It661YNol1rnhPIs+cirw+yf9zeCe+KL1IbZ/qIMZM="));
+ BigInteger DSAParaP = new BigInteger(Base64.Decode("AM2b/UeQA+ovv3dL05wlDHEKJ+qhnJBsRT5OB9WuyRC830G79y0R8wuq8jyIYWCYcTn1TeqVPWqiTv6oAoiEeOs="));
+ BigInteger DSAParaQ = new BigInteger(Base64.Decode("AIlJT7mcKL6SUBMmvm24zX1EvjNx"));
+ BigInteger DSAPublicY = new BigInteger(Base64.Decode("TtWy2GuT9yGBWOHi1/EpCDa/bWJCk2+yAdr56rAcqP0eHGkMnA9s9GJD2nGU8sFjNHm55swpn6JQb8q0agrCfw=="));
+ BigInteger DsaPrivateX = new BigInteger(Base64.Decode("MMpBAxNlv7eYfxLTZ2BItJeD31A="));
+
+ DsaParameters para = new DsaParameters(DSAParaP, DSAParaQ, DSAParaG);
+ DsaPrivateKeyParameters dsaPriv = new DsaPrivateKeyParameters(DsaPrivateX, para);
+ DsaPublicKeyParameters dsaPub = new DsaPublicKeyParameters(DSAPublicY, para);
+
+ IDictionary attrs = new Hashtable();
+ attrs[X509Name.C] = "AU";
+ attrs[X509Name.O] = "The Legion of the Bouncy Castle";
+ attrs[X509Name.L] = "Melbourne";
+ attrs[X509Name.ST] = "Victoria";
+ attrs[X509Name.E] = "feedback-crypto@bouncycastle.org";
+
+ IList ord = new ArrayList(attrs.Keys);
+
+ X509V3CertificateGenerator certGen = new X509V3CertificateGenerator();
+
+ certGen.SetSerialNumber(BigInteger.One);
+
+ certGen.SetIssuerDN(new X509Name(ord, attrs));
+ certGen.SetNotBefore(DateTime.UtcNow.AddDays(-1));
+ certGen.SetNotAfter(DateTime.UtcNow.AddDays(1));
+ certGen.SetSubjectDN(new X509Name(ord, attrs));
+ certGen.SetPublicKey(dsaPub);
+ certGen.SetSignatureAlgorithm("SHA1WITHDSA");
+
+ X509Certificate cert = certGen.Generate(dsaPriv);
+
+ cert.CheckValidity();
+ cert.Verify(dsaPub);
+
+ SystemX509.X509Certificate dotNetCert = DotNetUtilities.ToX509Certificate(cert);
+
+ X509Certificate certCopy = DotNetUtilities.FromX509Certificate(dotNetCert);
+
+ Assert.AreEqual(cert, certCopy);
+
+ certCopy.CheckValidity();
+ certCopy.Verify(dsaPub);
+ }
+ }
+}
+
+#endif
diff --git a/crypto/test/src/security/test/TestEncodings.cs b/crypto/test/src/security/test/TestEncodings.cs
new file mode 100644
index 000000000..557d2dc51
--- /dev/null
+++ b/crypto/test/src/security/test/TestEncodings.cs
@@ -0,0 +1,188 @@
+using System;
+using System.Collections;
+using System.Text;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.Pkcs;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Generators;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Crypto.Signers;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Math.EC;
+using Org.BouncyCastle.Pkcs;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.X509;
+
+namespace Org.BouncyCastle.Security.Tests
+{
+ [TestFixture]
+ public class TestEncodings
+ {
+ [Test]
+ public void TestEC()
+ {
+ BigInteger ECParraGX = new BigInteger(Base64.Decode("D/qWPNyogWzMM7hkK+35BcPTWFc9Pyf7vTs8uaqv"));
+ BigInteger ECParraGY = new BigInteger(Base64.Decode("AhQXGxb1olGRv6s1LPRfuatMF+cx3ZTGgzSE/Q5R"));
+ BigInteger ECParraH = new BigInteger(Base64.Decode("AQ=="));
+ BigInteger ECParraN = new BigInteger(Base64.Decode("f///////////////f///nl6an12QcfvRUiaIkJ0L"));
+ BigInteger ECPubQX = new BigInteger(Base64.Decode("HWWi17Yb+Bm3PYr/DMjLOYNFhyOwX1QY7ZvqqM+l"));
+ BigInteger ECPubQY = new BigInteger(Base64.Decode("JrlJfxu3WGhqwtL/55BOs/wsUeiDFsvXcGhB8DGx"));
+ BigInteger ECPrivD = new BigInteger(Base64.Decode("GYQmd/NF1B+He1iMkWt3by2Az6Eu07t0ynJ4YCAo"));
+
+ FpCurve curve = new FpCurve(
+ new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q
+ new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a
+ new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b
+
+ ECDomainParameters ecDomain =
+ new ECDomainParameters(
+ curve,
+ new FpPoint(curve,
+ curve.FromBigInteger(ECParraGX),
+ curve.FromBigInteger(ECParraGY)),
+ ECParraN);
+
+ ECPublicKeyParameters ecPub = new ECPublicKeyParameters(
+ new FpPoint(
+ curve,
+ curve.FromBigInteger(ECPubQX),
+ curve.FromBigInteger(ECPubQY)),
+ ecDomain);
+
+ ECPrivateKeyParameters ecPriv = new ECPrivateKeyParameters(ECPrivD, ecDomain);
+
+ SubjectPublicKeyInfo subinfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(ecPub);
+ PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(ecPriv);
+
+ ECPublicKeyParameters tecPub = (ECPublicKeyParameters)PublicKeyFactory.CreateKey(subinfo);
+ ECPrivateKeyParameters tecPriv = (ECPrivateKeyParameters)PrivateKeyFactory.CreateKey(privInfo);
+
+ Assert.IsTrue(tecPub.Equals(ecPub), "EC: public key to info back to public key");
+ Assert.IsTrue(tecPriv.Equals(ecPriv), "EC: private key to info back to private key");
+ }
+
+ [Test]
+ public void TestDH()
+ {
+ BigInteger DHParraP = new BigInteger(Base64.Decode("ALJCm1CUL6mOnyVqWTSV6Z2+DVSGOvgboOhmbyyxCrym59uVnXMmPjIgQTrmniFg7PvdcN7NNFwFmcZleULso1s="));
+ BigInteger DHParraQ = new BigInteger(Base64.Decode("WSFNqEoX1MdPkrUsmkr0zt8GqkMdfA3QdDM3lliFXlNz7crOuZMfGRAgnXNPELB2fe64b2aaLgLM4zK8oXZRrQ=="));
+ BigInteger DHPubY = new BigInteger(Base64.Decode("AIki+8/zggCS2e488AsTNULI4LujdUeQQsZI949Dc9lKXZRmrPIC1h8NRoneHQEhpAe4Rhe0nhUOGZJekT5++SA="));
+ BigInteger DHPrivX = new BigInteger(Base64.Decode("Apo67noMRO5eDWo/TtpRiBmKGw7ywh25shIu0Rs03krQmWKRbDPvdygWdJ5IpW6ZbKlCTAMhSxpz03YSeSEDmw=="));
+
+
+ DHParameters dhPara = new DHParameters(DHParraP, DHParraQ);
+ DHPublicKeyParameters dhPublic = new DHPublicKeyParameters(DHPubY, dhPara);
+ DHPrivateKeyParameters dhPrivate = new DHPrivateKeyParameters(DHPrivX, dhPara);
+
+ SubjectPublicKeyInfo pubInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(dhPublic);
+ PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(dhPrivate);
+
+ DHPublicKeyParameters testPubKey = (DHPublicKeyParameters) PublicKeyFactory.CreateKey(pubInfo);
+ DHPrivateKeyParameters testPrivKey = (DHPrivateKeyParameters) PrivateKeyFactory.CreateKey(privInfo);
+
+ Assert.IsFalse(!testPrivKey.Equals(dhPrivate), "DH: Private key to info back to key");
+ Assert.IsFalse(!testPubKey.Equals(dhPublic), "DH: Public key to info back to key");
+
+ Assert.IsTrue(true, "Diffe Helman Test worked.");
+
+ }
+
+ [Test]
+ public void TestElGamal()
+ {
+
+ BigInteger ELGamalParaG = new BigInteger(Base64.Decode("QAZPRcsH8kHVKS5065R1Xy6QtsPvDkmDZtPuq18EJkvLrCIZivE/m5puQp3/VKJrG7dKgz4NBGpONp3HT+Cn/g=="));
+ BigInteger ELGamalParaP = new BigInteger(Base64.Decode("AKXmAwgkudDLI/Yxk6wk3APn+mSjX5QSyDwpchmegSIi1ZNC0Jb+IbxjroKNhRTBKjtv4/JTXtJS6IqaZv9uKes="));
+ BigInteger ELGamalPubY = new BigInteger(Base64.Decode("AJ/gXuZuCA2X044otNkzs8FI36XuFu1L/YHg5cEmDvICTigycRN2E1DnhP+CTqxEqgEqX8rBe5tuGDlkTLwgNqM="));
+ BigInteger ELGamalPriv = new BigInteger(Base64.Decode("CqVr+K0TpuJKQnc76MjKhxrJzGr93jnuE3mTpth486Meymt8uWEVAQj1tGc9DTt14F9aV9WIT2oYYbvLJRcwow=="));
+
+
+
+ ElGamalParameters elPara = new ElGamalParameters(ELGamalParaP, ELGamalParaG);
+
+ ElGamalPrivateKeyParameters elPriv = new ElGamalPrivateKeyParameters(ELGamalPriv, elPara);
+ ElGamalPublicKeyParameters elPub = new ElGamalPublicKeyParameters(ELGamalPubY, elPara);
+
+ SubjectPublicKeyInfo subInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(elPub);
+ PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(elPriv);
+
+ ElGamalPrivateKeyParameters telPriv = (ElGamalPrivateKeyParameters)PrivateKeyFactory.CreateKey(privInfo);
+ ElGamalPublicKeyParameters telPub = (ElGamalPublicKeyParameters)PublicKeyFactory.CreateKey(subInfo);
+
+
+ // Console.WriteLine(telPriv.Equals(elPriv));
+
+
+
+ Assert.IsTrue(telPriv.Equals(elPriv), "ELGamal Private key to into back to private key.");
+ Assert.IsTrue(telPub.Equals(elPub), "ELGamal Public key to into back to private key.");
+
+ Assert.IsTrue(true, "ELGamal Test worked.");
+
+ }
+
+ [Test]
+ public void TestRsa()
+ {
+
+ BigInteger rsaPubMod = new BigInteger(Base64.Decode("AIASoe2PQb1IP7bTyC9usjHP7FvnUMVpKW49iuFtrw/dMpYlsMMoIU2jupfifDpdFxIktSB4P+6Ymg5WjvHKTIrvQ7SR4zV4jaPTu56Ys0pZ9EDA6gb3HLjtU+8Bb1mfWM+yjKxcPDuFjwEtjGlPHg1Vq+CA9HNcMSKNn2+tW6qt"));
+ BigInteger rsaPubExp = new BigInteger(Base64.Decode("EQ=="));
+ BigInteger rsaPrivMod = new BigInteger(Base64.Decode("AIASoe2PQb1IP7bTyC9usjHP7FvnUMVpKW49iuFtrw/dMpYlsMMoIU2jupfifDpdFxIktSB4P+6Ymg5WjvHKTIrvQ7SR4zV4jaPTu56Ys0pZ9EDA6gb3HLjtU+8Bb1mfWM+yjKxcPDuFjwEtjGlPHg1Vq+CA9HNcMSKNn2+tW6qt"));
+ BigInteger rsaPrivDP = new BigInteger(Base64.Decode("JXzfzG5v+HtLJIZqYMUefJfFLu8DPuJGaLD6lI3cZ0babWZ/oPGoJa5iHpX4Ul/7l3s1PFsuy1GhzCdOdlfRcQ=="));
+ BigInteger rsaPrivDQ = new BigInteger(Base64.Decode("YNdJhw3cn0gBoVmMIFRZzflPDNthBiWy/dUMSRfJCxoZjSnr1gysZHK01HteV1YYNGcwPdr3j4FbOfri5c6DUQ=="));
+ BigInteger rsaPrivExp = new BigInteger(Base64.Decode("DxFAOhDajr00rBjqX+7nyZ/9sHWRCCp9WEN5wCsFiWVRPtdB+NeLcou7mWXwf1Y+8xNgmmh//fPV45G2dsyBeZbXeJwB7bzx9NMEAfedchyOwjR8PYdjK3NpTLKtZlEJ6Jkh4QihrXpZMO4fKZWUm9bid3+lmiq43FwW+Hof8/E="));
+ BigInteger rsaPrivP = new BigInteger(Base64.Decode("AJ9StyTVW+AL/1s7RBtFwZGFBgd3zctBqzzwKPda6LbtIFDznmwDCqAlIQH9X14X7UPLokCDhuAa76OnDXb1OiE="));
+ BigInteger rsaPrivQ = new BigInteger(Base64.Decode("AM3JfD79dNJ5A3beScSzPtWxx/tSLi0QHFtkuhtSizeXdkv5FSba7lVzwEOGKHmW829bRoNxThDy4ds1IihW1w0="));
+ BigInteger rsaPrivQinv = new BigInteger(Base64.Decode("Lt0g7wrsNsQxuDdB8q/rH8fSFeBXMGLtCIqfOec1j7FEIuYA/ACiRDgXkHa0WgN7nLXSjHoy630wC5Toq8vvUg=="));
+ RsaKeyParameters rsaPublic = new RsaKeyParameters(false, rsaPubMod, rsaPubExp);
+ RsaPrivateCrtKeyParameters rsaPrivate = new RsaPrivateCrtKeyParameters(rsaPrivMod, rsaPubExp, rsaPrivExp, rsaPrivP, rsaPrivQ, rsaPrivDP, rsaPrivDQ, rsaPrivQinv);
+
+ SubjectPublicKeyInfo subInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(rsaPublic);
+ RsaKeyParameters testResult = (RsaKeyParameters)PublicKeyFactory.CreateKey(subInfo);
+
+ // check RSA public key.
+
+ Assert.IsFalse(!testResult.Equals(rsaPublic), "RSA: test failed on public key to info and back to public key.");
+
+ PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(rsaPrivate);
+ testResult = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(privInfo);
+
+ Assert.IsFalse(!testResult.Equals(rsaPrivate), "RSA: private key to info back to private key.");
+
+ Assert.IsTrue(true, "RSATest worked.");
+
+ }
+
+ [Test]
+ public void TestDSA()
+ {
+ BigInteger DSAParaG = new BigInteger(Base64.Decode("AL0fxOTq10OHFbCf8YldyGembqEu08EDVzxyLL29Zn/t4It661YNol1rnhPIs+cirw+yf9zeCe+KL1IbZ/qIMZM="));
+ BigInteger DSAParaP = new BigInteger(Base64.Decode("AM2b/UeQA+ovv3dL05wlDHEKJ+qhnJBsRT5OB9WuyRC830G79y0R8wuq8jyIYWCYcTn1TeqVPWqiTv6oAoiEeOs="));
+ BigInteger DSAParaQ = new BigInteger(Base64.Decode("AIlJT7mcKL6SUBMmvm24zX1EvjNx"));
+ BigInteger DSAPublicY = new BigInteger(Base64.Decode("TtWy2GuT9yGBWOHi1/EpCDa/bWJCk2+yAdr56rAcqP0eHGkMnA9s9GJD2nGU8sFjNHm55swpn6JQb8q0agrCfw=="));
+ BigInteger DsaPrivateX = new BigInteger(Base64.Decode("MMpBAxNlv7eYfxLTZ2BItJeD31A="));
+
+ DsaParameters para = new DsaParameters(DSAParaP, DSAParaQ, DSAParaG);
+ DsaPrivateKeyParameters dsaPriv = new DsaPrivateKeyParameters(DsaPrivateX, para);
+ DsaPublicKeyParameters dsaPub = new DsaPublicKeyParameters(DSAPublicY, para);
+
+ SubjectPublicKeyInfo subInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(dsaPub);
+ DsaKeyParameters testResult = (DsaKeyParameters)PublicKeyFactory.CreateKey(subInfo);
+
+ // check RSA public key.
+
+ Assert.IsFalse(!testResult.Equals(dsaPub), "DSA: test failed on public key to info and back to public key.");
+
+ PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(dsaPriv);
+ testResult = (DsaPrivateKeyParameters)PrivateKeyFactory.CreateKey(privInfo);
+
+ Assert.IsFalse(!testResult.Equals(dsaPriv), "DSA: private key to info back to private key.");
+
+ Assert.IsTrue(true, "DSATest worked.");
+
+ }
+ }
+}
diff --git a/crypto/test/src/security/test/TestParameterUtil.cs b/crypto/test/src/security/test/TestParameterUtil.cs
new file mode 100644
index 000000000..fe494212a
--- /dev/null
+++ b/crypto/test/src/security/test/TestParameterUtil.cs
@@ -0,0 +1,74 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1;
+using Org.BouncyCastle.Asn1.Nist;
+using Org.BouncyCastle.Asn1.Oiw;
+using Org.BouncyCastle.Asn1.Pkcs;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Security.Tests
+{
+ [TestFixture]
+ public class TestParameterUtilities
+ {
+ [Test]
+ public void TestCreateKeyParameter()
+ {
+ SecureRandom random = new SecureRandom();
+
+ doTestCreateKeyParameter("AES", NistObjectIdentifiers.IdAes128Cbc,
+ 128, typeof(KeyParameter), random);
+ doTestCreateKeyParameter("DES", OiwObjectIdentifiers.DesCbc,
+ 64, typeof(DesParameters), random);
+ doTestCreateKeyParameter("DESEDE", PkcsObjectIdentifiers.DesEde3Cbc,
+ 192, typeof(DesEdeParameters), random);
+ doTestCreateKeyParameter("RC2", PkcsObjectIdentifiers.RC2Cbc,
+ 128, typeof(RC2Parameters), random);
+ }
+
+ private void doTestCreateKeyParameter(
+ string algorithm,
+ DerObjectIdentifier oid,
+ int keyBits,
+ Type expectedType,
+ SecureRandom random)
+ {
+ int keyLength = keyBits / 8;
+ byte[] bytes = new byte[keyLength];
+ random.NextBytes(bytes);
+
+ KeyParameter key;
+
+ key = ParameterUtilities.CreateKeyParameter(algorithm, bytes);
+ checkKeyParameter(key, expectedType, bytes);
+
+ key = ParameterUtilities.CreateKeyParameter(oid, bytes);
+ checkKeyParameter(key, expectedType, bytes);
+
+ bytes = new byte[keyLength * 2];
+ random.NextBytes(bytes);
+
+ int offset = random.Next(1, keyLength);
+ byte[] expected = new byte[keyLength];
+ Array.Copy(bytes, offset, expected, 0, keyLength);
+
+ key = ParameterUtilities.CreateKeyParameter(algorithm, bytes, offset, keyLength);
+ checkKeyParameter(key, expectedType, expected);
+
+ key = ParameterUtilities.CreateKeyParameter(oid, bytes, offset, keyLength);
+ checkKeyParameter(key, expectedType, expected);
+ }
+
+ private void checkKeyParameter(
+ KeyParameter key,
+ Type expectedType,
+ byte[] expectedBytes)
+ {
+ Assert.IsTrue(expectedType.IsInstanceOfType(key));
+ Assert.IsTrue(Arrays.AreEqual(expectedBytes, key.GetKey()));
+ }
+ }
+}
diff --git a/crypto/test/src/security/test/TestSignerUtil.cs b/crypto/test/src/security/test/TestSignerUtil.cs
new file mode 100644
index 000000000..c1140faf7
--- /dev/null
+++ b/crypto/test/src/security/test/TestSignerUtil.cs
@@ -0,0 +1,180 @@
+using System;
+using System.Collections;
+using System.Text;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.CryptoPro;
+using Org.BouncyCastle.Asn1.Pkcs;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Math.EC;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Generators;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Crypto.Signers;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Security.Tests
+{
+ [TestFixture]
+ public class TestSignerUtilities
+ {
+ [Test]
+ public void TestAlgorithms()
+ {
+ //
+ // RSA parameters
+ //
+ BigInteger rsaMod = new BigInteger("a7295693155b1813bb84877fb45343556e0568043de5910872a3a518cc11e23e2db74eaf4545068c4e3d258a2718fbacdcc3eafa457695b957e88fbf110aed049a992d9c430232d02f3529c67a3419935ea9b569f85b1bcd37de6b899cd62697e843130ff0529d09c97d813cb15f293751ff56f943fbdabb63971cc7f4f6d5bff1594416b1f5907bde5a84a44f9802ef29b43bda1960f948f8afb8766c1ab80d32eec88ed66d0b65aebe44a6d0b3c5e0ab051aaa1b912fbcc17b8e751ddecc5365b6db6dab0020c3057db4013a51213a5798a3aab67985b0f4d88627a54a0f3f0285fbcb4afdfeb65cb153af66825656d43238b75503231500753f4e421e3c57", 16);
+ BigInteger rsaPubExp = new BigInteger("10001", 16);
+
+ BigInteger rsaPrivExp = new BigInteger("65dad56ac7df7abb434e4cb5eeadb16093aa6da7f0033aad3815289b04757d32bfee6ade7749c8e4a323b5050a2fb9e2a99e23469e1ed4ba5bab54336af20a5bfccb8b3424cc6923db2ffca5787ed87aa87aa614cd04cedaebc8f623a2d2063017910f436dff18bb06f01758610787f8b258f0a8efd8bd7de30007c47b2a1031696c7d6523bc191d4d918927a7e0b09584ed205bd2ff4fc4382678df82353f7532b3bbb81d69e3f39070aed3fb64fce032a089e8e64955afa5213a6eb241231bd98d702fba725a9b205952fda186412d9e0d9344d2998c455ad8c2bae85ee672751466d5288304032b5b7e02f7e558c7af82c7fbf58eea0bb4ef0f001e6cd0a9", 16);
+ BigInteger rsaPrivP = new BigInteger("d4fd9ac3474fb83aaf832470643609659e511b322632b239b688f3cd2aad87527d6cf652fb9c9ca67940e84789444f2e99b0cb0cfabbd4de95396106c865f38e2fb7b82b231260a94df0e01756bf73ce0386868d9c41645560a81af2f53c18e4f7cdf3d51d80267372e6e0216afbf67f655c9450769cca494e4f6631b239ce1b", 16);
+ BigInteger rsaPrivQ = new BigInteger("c8eaa0e2a1b3a4412a702bccda93f4d150da60d736c99c7c566fdea4dd1b401cbc0d8c063daaf0b579953d36343aa18b33dbf8b9eae94452490cc905245f8f7b9e29b1a288bc66731a29e1dd1a45c9fd7f8238ff727adc49fff73991d0dc096206b9d3a08f61e7462e2b804d78cb8c5eccdb9b7fbd2ad6a8fea46c1053e1be75", 16);
+ BigInteger rsaPrivDP = new BigInteger("10edcb544421c0f9e123624d1099feeb35c72a8b34e008ac6fa6b90210a7543f293af4e5299c8c12eb464e70092805c7256e18e5823455ba0f504d36f5ccacac1b7cd5c58ff710f9c3f92646949d88fdd1e7ea5fed1081820bb9b0d2a8cd4b093fecfdb96dabd6e28c3a6f8c186dc86cddc89afd3e403e0fcf8a9e0bcb27af0b", 16);
+ BigInteger rsaPrivDQ = new BigInteger("97fc25484b5a415eaa63c03e6efa8dafe9a1c8b004d9ee6e80548fefd6f2ce44ee5cb117e77e70285798f57d137566ce8ea4503b13e0f1b5ed5ca6942537c4aa96b2a395782a4cb5b58d0936e0b0fa63b1192954d39ced176d71ef32c6f42c84e2e19f9d4dd999c2151b032b97bd22aa73fd8c5bcd15a2dca4046d5acc997021", 16);
+ BigInteger rsaPrivQinv = new BigInteger("4bb8064e1eff7e9efc3c4578fcedb59ca4aef0993a8312dfdcb1b3decf458aa6650d3d0866f143cbf0d3825e9381181170a0a1651eefcd7def786b8eb356555d9fa07c85b5f5cbdd74382f1129b5e36b4166b6cc9157923699708648212c484958351fdc9cf14f218dbe7fbf7cbd93a209a4681fe23ceb44bab67d66f45d1c9d", 16);
+
+ RsaKeyParameters rsaPublic = new RsaKeyParameters(false, rsaMod, rsaPubExp);
+ RsaPrivateCrtKeyParameters rsaPrivate = new RsaPrivateCrtKeyParameters(
+ rsaMod, rsaPubExp, rsaPrivExp, rsaPrivP, rsaPrivQ, rsaPrivDP, rsaPrivDQ, rsaPrivQinv);
+
+ //
+ // ECDSA parameters
+ //
+ BigInteger ECParraGX = new BigInteger(Base64.Decode("D/qWPNyogWzMM7hkK+35BcPTWFc9Pyf7vTs8uaqv"));
+ BigInteger ECParraGY = new BigInteger(Base64.Decode("AhQXGxb1olGRv6s1LPRfuatMF+cx3ZTGgzSE/Q5R"));
+ BigInteger ECParraH = new BigInteger(Base64.Decode("AQ=="));
+ BigInteger ECParraN = new BigInteger(Base64.Decode("f///////////////f///nl6an12QcfvRUiaIkJ0L"));
+ BigInteger ECPubQX = new BigInteger(Base64.Decode("HWWi17Yb+Bm3PYr/DMjLOYNFhyOwX1QY7ZvqqM+l"));
+ BigInteger ECPubQY = new BigInteger(Base64.Decode("JrlJfxu3WGhqwtL/55BOs/wsUeiDFsvXcGhB8DGx"));
+ BigInteger ECPrivD = new BigInteger(Base64.Decode("GYQmd/NF1B+He1iMkWt3by2Az6Eu07t0ynJ4YCAo"));
+
+ FpCurve curve = new FpCurve(
+ new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q
+ new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a
+ new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b
+
+ ECDomainParameters ecDomain = new ECDomainParameters(curve,
+ new FpPoint(curve,
+ curve.FromBigInteger(ECParraGX),
+ curve.FromBigInteger(ECParraGY)),
+ ECParraN);
+
+ ECPublicKeyParameters ecPub = new ECPublicKeyParameters(
+ new FpPoint(curve,
+ curve.FromBigInteger(ECPubQX),
+ curve.FromBigInteger(ECPubQY)),
+ ecDomain);
+
+ ECPrivateKeyParameters ecPriv = new ECPrivateKeyParameters(ECPrivD, ecDomain);
+
+ //
+ // DSA parameters
+ //
+ BigInteger DSAParaG = new BigInteger(Base64.Decode("AL0fxOTq10OHFbCf8YldyGembqEu08EDVzxyLL29Zn/t4It661YNol1rnhPIs+cirw+yf9zeCe+KL1IbZ/qIMZM="));
+ BigInteger DSAParaP = new BigInteger(Base64.Decode("AM2b/UeQA+ovv3dL05wlDHEKJ+qhnJBsRT5OB9WuyRC830G79y0R8wuq8jyIYWCYcTn1TeqVPWqiTv6oAoiEeOs="));
+ BigInteger DSAParaQ = new BigInteger(Base64.Decode("AIlJT7mcKL6SUBMmvm24zX1EvjNx"));
+ BigInteger DSAPublicY = new BigInteger(Base64.Decode("TtWy2GuT9yGBWOHi1/EpCDa/bWJCk2+yAdr56rAcqP0eHGkMnA9s9GJD2nGU8sFjNHm55swpn6JQb8q0agrCfw=="));
+ BigInteger DsaPrivateX = new BigInteger(Base64.Decode("MMpBAxNlv7eYfxLTZ2BItJeD31A="));
+
+ DsaParameters para = new DsaParameters(DSAParaP, DSAParaQ, DSAParaG);
+ DsaPrivateKeyParameters dsaPriv = new DsaPrivateKeyParameters(DsaPrivateX, para);
+ DsaPublicKeyParameters dsaPub = new DsaPublicKeyParameters(DSAPublicY, para);
+
+ //
+ // ECGOST3410 parameters
+ //
+ IAsymmetricCipherKeyPairGenerator ecGostKpg = GeneratorUtilities.GetKeyPairGenerator("ECGOST3410");
+ ecGostKpg.Init(
+ new ECKeyGenerationParameters(
+ CryptoProObjectIdentifiers.GostR3410x2001CryptoProA,
+ new SecureRandom()));
+
+ AsymmetricCipherKeyPair ecGostPair = ecGostKpg.GenerateKeyPair();
+
+ //
+ // GOST3410 parameters
+ //
+ IAsymmetricCipherKeyPairGenerator gostKpg = GeneratorUtilities.GetKeyPairGenerator("GOST3410");
+ gostKpg.Init(
+ new Gost3410KeyGenerationParameters(
+ new SecureRandom(),
+ CryptoProObjectIdentifiers.GostR3410x94CryptoProA));
+
+ AsymmetricCipherKeyPair gostPair = gostKpg.GenerateKeyPair();
+
+
+
+ //
+ // signer loop
+ //
+ byte[] shortMsg = new byte[] { 1, 4, 5, 6, 8, 8, 4, 2, 1, 3 };
+ byte[] longMsg = new byte[100];
+ new SecureRandom().NextBytes(longMsg);
+
+ foreach (string algorithm in SignerUtilities.Algorithms)
+ {
+ ISigner signer = SignerUtilities.GetSigner(algorithm);
+
+ string upper = Platform.ToUpperInvariant(algorithm);
+ int withPos = upper.LastIndexOf("WITH");
+
+ string cipherName = withPos < 0
+ ? upper
+ : upper.Substring(withPos + "WITH".Length);
+
+ ICipherParameters signParams = null, verifyParams = null;
+
+ if (cipherName == "RSA" || cipherName == "RSAANDMGF1")
+ {
+ signParams = rsaPrivate;
+ verifyParams = rsaPublic;
+ }
+ else if (cipherName == "ECDSA")
+ {
+ signParams = ecPriv;
+ verifyParams = ecPub;
+ }
+ else if (cipherName == "DSA")
+ {
+ signParams = dsaPriv;
+ verifyParams = dsaPub;
+ }
+ else if (cipherName == "ECGOST3410")
+ {
+ signParams = ecGostPair.Private;
+ verifyParams = ecGostPair.Public;
+ }
+ else if (cipherName == "GOST3410")
+ {
+ signParams = gostPair.Private;
+ verifyParams = gostPair.Public;
+ }
+ else
+ {
+ Assert.Fail("Unknown algorithm encountered: " + cipherName);
+ }
+
+ signer.Init(true, signParams);
+ foreach (byte b in shortMsg)
+ {
+ signer.Update(b);
+ }
+ signer.BlockUpdate(longMsg, 0, longMsg.Length);
+ byte[] sig = signer.GenerateSignature();
+
+ signer.Init(false, verifyParams);
+ foreach (byte b in shortMsg)
+ {
+ signer.Update(b);
+ }
+ signer.BlockUpdate(longMsg, 0, longMsg.Length);
+
+ Assert.IsTrue(signer.VerifySignature(sig), cipherName + " signer " + algorithm + " failed.");
+ }
+ }
+ }
+}
|
