diff --git a/crypto/test/src/asn1/test/BitStringTest.cs b/crypto/test/src/asn1/test/BitStringTest.cs
index 3a2dc3156..f2ae3de97 100644
--- a/crypto/test/src/asn1/test/BitStringTest.cs
+++ b/crypto/test/src/asn1/test/BitStringTest.cs
@@ -4,44 +4,124 @@ using System.IO;
using NUnit.Framework;
using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
using Org.BouncyCastle.Utilities.Test;
namespace Org.BouncyCastle.Asn1.Tests
{
[TestFixture]
public class BitStringTest
- : ITest
+ : SimpleTest
{
- public ITestResult Perform()
+ private void DoTestZeroLengthStrings()
+ {
+ // basic construction
+ DerBitString s1 = new DerBitString(new byte[0], 0);
+
+ // check GetBytes()
+ s1.GetBytes();
+
+ // check encoding/decoding
+ DerBitString derBit = (DerBitString)Asn1Object.FromByteArray(s1.GetEncoded());
+
+ if (!Arrays.AreEqual(s1.GetEncoded(), Hex.Decode("030100")))
+ {
+ Fail("zero encoding wrong");
+ }
+
+ try
+ {
+ new DerBitString(null, 1);
+ Fail("exception not thrown");
+ }
+ catch (ArgumentNullException)
+ {
+ }
+
+ try
+ {
+ new DerBitString(new byte[0], 1);
+ Fail("exception not thrown");
+ }
+ catch (ArgumentException)
+ {
+ }
+
+ try
+ {
+ new DerBitString(new byte[1], 8);
+ Fail("exception not thrown");
+ }
+ catch (ArgumentException)
+ {
+ }
+
+ DerBitString s2 = new DerBitString(0);
+ if (!Arrays.AreEqual(s1.GetEncoded(), s2.GetEncoded()))
+ {
+ Fail("zero encoding wrong");
+ }
+ }
+
+ private void DoTestRandomPadBits()
+ {
+ byte[] test = Hex.Decode("030206c0");
+
+ byte[] test1 = Hex.Decode("030206f0");
+ byte[] test2 = Hex.Decode("030206c1");
+ byte[] test3 = Hex.Decode("030206c7");
+ byte[] test4 = Hex.Decode("030206d1");
+
+ EncodingCheck(test, test1);
+ EncodingCheck(test, test2);
+ EncodingCheck(test, test3);
+ EncodingCheck(test, test4);
+ }
+
+ private void EncodingCheck(byte[] derData, byte[] dlData)
+ {
+ if (Arrays.AreEqual(derData, Asn1Object.FromByteArray(dlData).GetEncoded()))
+ {
+ //Fail("failed DL check");
+ Fail("failed BER check");
+ }
+ if (!Arrays.AreEqual(derData, Asn1Object.FromByteArray(dlData).GetDerEncoded()))
+ {
+ Fail("failed DER check");
+ }
+ }
+
+ public override void PerformTest()
{
KeyUsage k = new KeyUsage(KeyUsage.DigitalSignature);
if ((k.GetBytes()[0] != (byte)KeyUsage.DigitalSignature) || (k.PadBits != 7))
{
- return new SimpleTestResult(false, Name + ": failed digitalSignature");
+ Fail("failed digitalSignature");
}
k = new KeyUsage(KeyUsage.NonRepudiation);
if ((k.GetBytes()[0] != (byte)KeyUsage.NonRepudiation) || (k.PadBits != 6))
{
- return new SimpleTestResult(false, Name + ": failed nonRepudiation");
+ Fail("failed nonRepudiation");
}
k = new KeyUsage(KeyUsage.KeyEncipherment);
if ((k.GetBytes()[0] != (byte)KeyUsage.KeyEncipherment) || (k.PadBits != 5))
{
- return new SimpleTestResult(false, Name + ": failed keyEncipherment");
+ Fail("failed keyEncipherment");
}
k = new KeyUsage(KeyUsage.CrlSign);
if ((k.GetBytes()[0] != (byte)KeyUsage.CrlSign) || (k.PadBits != 1))
{
- return new SimpleTestResult(false, Name + ": failed cRLSign");
+ Fail("failed cRLSign");
}
k = new KeyUsage(KeyUsage.DecipherOnly);
if ((k.GetBytes()[1] != (byte)(KeyUsage.DecipherOnly >> 8)) || (k.PadBits != 7))
{
- return new SimpleTestResult(false, Name + ": failed decipherOnly");
+ Fail("failed decipherOnly");
}
// test for zero length bit string
@@ -51,27 +131,25 @@ namespace Org.BouncyCastle.Asn1.Tests
}
catch (IOException e)
{
- return new SimpleTestResult(false, Name + ": " + e);
+ Fail(e.ToString());
}
- return new SimpleTestResult(true, Name + ": Okay");
+ DoTestRandomPadBits();
+ DoTestZeroLengthStrings();
}
- public string Name
+ public override string Name
{
get { return "BitString"; }
}
- public static void Main(
+ public static void Main(
string[] args)
{
- ITest test = new BitStringTest();
- ITestResult result = test.Perform();
-
- Console.WriteLine(result);
+ RunTest(new BitStringTest());
}
- [Test]
+ [Test]
public void TestFunction()
{
string resultText = Perform().ToString();
diff --git a/crypto/test/src/asn1/test/LDSSecurityObjectUnitTest.cs b/crypto/test/src/asn1/test/LDSSecurityObjectUnitTest.cs
index 042781632..914eda0b8 100644
--- a/crypto/test/src/asn1/test/LDSSecurityObjectUnitTest.cs
+++ b/crypto/test/src/asn1/test/LDSSecurityObjectUnitTest.cs
@@ -4,6 +4,7 @@ using NUnit.Framework;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.Icao;
+using Org.BouncyCastle.Asn1.Oiw;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Utilities.Test;
@@ -29,7 +30,7 @@ namespace Org.BouncyCastle.Asn1.Tests
public override void PerformTest()
{
- AlgorithmIdentifier algoId = new AlgorithmIdentifier("1.3.14.3.2.26");
+ AlgorithmIdentifier algoId = new AlgorithmIdentifier(OiwObjectIdentifiers.IdSha1);
DataGroupHash[] datas = new DataGroupHash[2];
datas[0] = new DataGroupHash(1, new DerOctetString(GenerateHash()));
diff --git a/crypto/test/src/asn1/test/PKIFailureInfoTest.cs b/crypto/test/src/asn1/test/PKIFailureInfoTest.cs
index 734dbbc14..7d51dbb5f 100644
--- a/crypto/test/src/asn1/test/PKIFailureInfoTest.cs
+++ b/crypto/test/src/asn1/test/PKIFailureInfoTest.cs
@@ -11,7 +11,7 @@ using Org.BouncyCastle.Utilities.Test;
namespace Org.BouncyCastle.Asn1.Tests
{
/**
- * PKIFailureInfoTest
+ * PkiFailureInfoTest
*/
[TestFixture]
public class PkiFailureInfoTest
@@ -25,12 +25,13 @@ namespace Org.BouncyCastle.Asn1.Tests
get { return "PkiFailureInfo"; }
}
- private void doTestEncoding()
+ private void DoTestEncoding()
{
- DerBitString bitString = (DerBitString) Asn1Object.FromByteArray(CORRECT_FAILURE_INFO);
+ DerBitString bitString = (DerBitString)Asn1Object.FromByteArray(CORRECT_FAILURE_INFO);
PkiFailureInfo correct = new PkiFailureInfo(bitString);
- PkiFailureInfo bug = new PkiFailureInfo(PkiFailureInfo.BadRequest | PkiFailureInfo.BadTime | PkiFailureInfo.BadDataFormat | PkiFailureInfo.IncorrectData);
+ PkiFailureInfo bug = new PkiFailureInfo(
+ PkiFailureInfo.BadRequest | PkiFailureInfo.BadTime | PkiFailureInfo.BadDataFormat | PkiFailureInfo.IncorrectData);
if (!Arrays.AreEqual(correct.GetDerEncoded(), bug.GetDerEncoded()))
{
@@ -40,23 +41,35 @@ namespace Org.BouncyCastle.Asn1.Tests
public override void PerformTest()
{
- BitStringConstantTester.testFlagValueCorrect(0, PkiFailureInfo.BadAlg);
- BitStringConstantTester.testFlagValueCorrect(1, PkiFailureInfo.BadMessageCheck);
- BitStringConstantTester.testFlagValueCorrect(2, PkiFailureInfo.BadRequest);
- BitStringConstantTester.testFlagValueCorrect(3, PkiFailureInfo.BadTime);
- BitStringConstantTester.testFlagValueCorrect(4, PkiFailureInfo.BadCertId);
- BitStringConstantTester.testFlagValueCorrect(5, PkiFailureInfo.BadDataFormat);
- BitStringConstantTester.testFlagValueCorrect(6, PkiFailureInfo.WrongAuthority);
- BitStringConstantTester.testFlagValueCorrect(7, PkiFailureInfo.IncorrectData);
- BitStringConstantTester.testFlagValueCorrect(8, PkiFailureInfo.MissingTimeStamp);
- BitStringConstantTester.testFlagValueCorrect(9, PkiFailureInfo.BadPop);
- BitStringConstantTester.testFlagValueCorrect(14, PkiFailureInfo.TimeNotAvailable);
- BitStringConstantTester.testFlagValueCorrect(15, PkiFailureInfo.UnacceptedPolicy);
- BitStringConstantTester.testFlagValueCorrect(16, PkiFailureInfo.UnacceptedExtension);
- BitStringConstantTester.testFlagValueCorrect(17, PkiFailureInfo.AddInfoNotAvailable);
- BitStringConstantTester.testFlagValueCorrect(25, PkiFailureInfo.SystemFailure);
+ BitStringConstantTester.testFlagValueCorrect(0, PkiFailureInfo.BadAlg);
+ BitStringConstantTester.testFlagValueCorrect(1, PkiFailureInfo.BadMessageCheck);
+ BitStringConstantTester.testFlagValueCorrect(2, PkiFailureInfo.BadRequest);
+ BitStringConstantTester.testFlagValueCorrect(3, PkiFailureInfo.BadTime);
+ BitStringConstantTester.testFlagValueCorrect(4, PkiFailureInfo.BadCertId);
+ BitStringConstantTester.testFlagValueCorrect(5, PkiFailureInfo.BadDataFormat);
+ BitStringConstantTester.testFlagValueCorrect(6, PkiFailureInfo.WrongAuthority);
+ BitStringConstantTester.testFlagValueCorrect(7, PkiFailureInfo.IncorrectData);
+ BitStringConstantTester.testFlagValueCorrect(8, PkiFailureInfo.MissingTimeStamp);
+ BitStringConstantTester.testFlagValueCorrect(9, PkiFailureInfo.BadPop);
+ BitStringConstantTester.testFlagValueCorrect(10, PkiFailureInfo.CertRevoked);
+ BitStringConstantTester.testFlagValueCorrect(11, PkiFailureInfo.CertConfirmed);
+ BitStringConstantTester.testFlagValueCorrect(12, PkiFailureInfo.WrongIntegrity);
+ BitStringConstantTester.testFlagValueCorrect(13, PkiFailureInfo.BadRecipientNonce);
+ BitStringConstantTester.testFlagValueCorrect(14, PkiFailureInfo.TimeNotAvailable);
+ BitStringConstantTester.testFlagValueCorrect(15, PkiFailureInfo.UnacceptedPolicy);
+ BitStringConstantTester.testFlagValueCorrect(16, PkiFailureInfo.UnacceptedExtension);
+ BitStringConstantTester.testFlagValueCorrect(17, PkiFailureInfo.AddInfoNotAvailable);
+ BitStringConstantTester.testFlagValueCorrect(18, PkiFailureInfo.BadSenderNonce);
+ BitStringConstantTester.testFlagValueCorrect(19, PkiFailureInfo.BadCertTemplate);
+ BitStringConstantTester.testFlagValueCorrect(20, PkiFailureInfo.SignerNotTrusted);
+ BitStringConstantTester.testFlagValueCorrect(21, PkiFailureInfo.TransactionIdInUse);
+ BitStringConstantTester.testFlagValueCorrect(22, PkiFailureInfo.UnsupportedVersion);
+ BitStringConstantTester.testFlagValueCorrect(23, PkiFailureInfo.NotAuthorized);
+ BitStringConstantTester.testFlagValueCorrect(24, PkiFailureInfo.SystemUnavail);
+ BitStringConstantTester.testFlagValueCorrect(25, PkiFailureInfo.SystemFailure);
+ BitStringConstantTester.testFlagValueCorrect(26, PkiFailureInfo.DuplicateCertReq);
- doTestEncoding();
+ DoTestEncoding();
}
public static void Main(
diff --git a/crypto/test/src/asn1/test/TagTest.cs b/crypto/test/src/asn1/test/TagTest.cs
index c5fce6dbc..80ca2c0ea 100644
--- a/crypto/test/src/asn1/test/TagTest.cs
+++ b/crypto/test/src/asn1/test/TagTest.cs
@@ -1,4 +1,5 @@
using System;
+using System.IO;
using NUnit.Framework;
@@ -33,14 +34,17 @@ namespace Org.BouncyCastle.Asn1.Tests
public override void PerformTest()
{
- DerApplicationSpecific app = (DerApplicationSpecific)
- Asn1Object.FromByteArray(longTagged);
+ Asn1InputStream aIn = new Asn1InputStream(longTagged);
- app = (DerApplicationSpecific) Asn1Object.FromByteArray(app.GetContents());
+ DerApplicationSpecific app = (DerApplicationSpecific)aIn.ReadObject();
- Asn1InputStream aIn = new Asn1InputStream(app.GetContents());
+ aIn = new Asn1InputStream(app.GetContents());
- Asn1TaggedObject tagged = (Asn1TaggedObject) aIn.ReadObject();
+ app = (DerApplicationSpecific)aIn.ReadObject();
+
+ aIn = new Asn1InputStream(app.GetContents());
+
+ Asn1TaggedObject tagged = (Asn1TaggedObject)aIn.ReadObject();
if (tagged.TagNo != 32)
{
diff --git a/crypto/test/src/asn1/test/X9Test.cs b/crypto/test/src/asn1/test/X9Test.cs
index e310811ea..db2541f7c 100644
--- a/crypto/test/src/asn1/test/X9Test.cs
+++ b/crypto/test/src/asn1/test/X9Test.cs
@@ -27,13 +27,13 @@ namespace Org.BouncyCastle.Asn1.Tests
+ "yUmqLG2UhT0OZgu/hUsclQX+laAh5///////////////9///+XXetBs6YFfDxDIUZSZVECAQED"
+ "IAADG5xRI+Iki/JrvL20hoDUa7Cggzorv5B9yyqSMjYu");
- private static readonly byte[] namedPriv = Base64.Decode("MCICAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEECDAGAgEBBAEK");
+ private static readonly byte[] namedPriv = Base64.Decode("MDkCAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEHzAdAgEBBBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo=");
private static readonly byte[] expPriv = Base64.Decode(
- "MIHnAgEAMIHXBgcqhkjOPQIBMIHLAgEBMCkGByqGSM49AQECHn///////////////3///////4"
- + "AAAAAAAH///////zBXBB5///////////////9///////+AAAAAAAB///////wEHiVXBfoqMGZU"
- + "sfTLA9anUKMMJQEC1JiHF9m6FattPgMVAH1zdBaP/jRxtgqFdoahlHXTv6L/BB8DZ2iujhi7ks"
- + "/PAFyUmqLG2UhT0OZgu/hUsclQX+laAh5///////////////9///+XXetBs6YFfDxDIUZSZVEC"
- + "AQEECDAGAgEBBAEU");
+ "MIIBBAIBADCB1wYHKoZIzj0CATCBywIBATApBgcqhkjOPQEBAh5///////////////9///////"
+ + "+AAAAAAAB///////8wVwQef///////////////f///////gAAAAAAAf//////8BB4lVwX6KjBmVL"
+ + "H0ywPWp1CjDCUBAtSYhxfZuhWrbT4DFQB9c3QWj/40cbYKhXaGoZR107+i/wQfA2doro4Yu5LPzw"
+ + "BclJqixtlIU9DmYLv4VLHJUF/pWgIef///////////////f///l13rQbOmBXw8QyFGUmVRAgEBBC"
+ + "UwIwIBAQQeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU");
private void EncodePublicKey()
{
@@ -99,14 +99,15 @@ namespace Org.BouncyCastle.Asn1.Tests
private void EncodePrivateKey()
{
- X9ECParameters ecP = X962NamedCurves.GetByOid(X9ObjectIdentifiers.Prime239v3);
+ X9ECParameters ecP = X962NamedCurves.GetByOid(X9ObjectIdentifiers.Prime192v1);
//
// named curve
//
X962Parameters _params = new X962Parameters(X9ObjectIdentifiers.Prime192v1);
- PrivateKeyInfo info = new PrivateKeyInfo(new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, _params), new ECPrivateKeyStructure(BigInteger.Ten).ToAsn1Object());
+ PrivateKeyInfo info = new PrivateKeyInfo(new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, _params),
+ new ECPrivateKeyStructure(ecP.N.BitLength, BigInteger.Ten).ToAsn1Object());
if (!Arrays.AreEqual(info.GetEncoded(), namedPriv))
{
@@ -123,9 +124,12 @@ namespace Org.BouncyCastle.Asn1.Tests
//
// explicit curve parameters
//
+ ecP = X962NamedCurves.GetByOid(X9ObjectIdentifiers.Prime239v3);
+
_params = new X962Parameters(ecP);
- info = new PrivateKeyInfo(new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, _params), new ECPrivateKeyStructure(BigInteger.ValueOf(20)).ToAsn1Object());
+ info = new PrivateKeyInfo(new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, _params),
+ new ECPrivateKeyStructure(ecP.N.BitLength, BigInteger.ValueOf(20)).ToAsn1Object());
if (!Arrays.AreEqual(info.GetEncoded(), expPriv))
{
diff --git a/crypto/test/src/crypto/agreement/test/AllTests.cs b/crypto/test/src/crypto/agreement/test/AllTests.cs
index ea8f438e5..66853b285 100644
--- a/crypto/test/src/crypto/agreement/test/AllTests.cs
+++ b/crypto/test/src/crypto/agreement/test/AllTests.cs
@@ -1,4 +1,5 @@
-using System;
+#if !LIB
+using System;
using NUnit.Core;
using NUnit.Framework;
@@ -29,3 +30,4 @@ namespace Org.BouncyCastle.Crypto.Agreement.Tests
}
}
}
+#endif
diff --git a/crypto/test/src/crypto/prng/test/CtrDrbgTest.cs b/crypto/test/src/crypto/prng/test/CtrDrbgTest.cs
new file mode 100644
index 000000000..44b08f3a6
--- /dev/null
+++ b/crypto/test/src/crypto/prng/test/CtrDrbgTest.cs
@@ -0,0 +1,526 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Prng.Drbg;
+using Org.BouncyCastle.Utilities.Test;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace Org.BouncyCastle.Crypto.Prng.Test
+{
+ /**
+ * CTR DRBG Test
+ */
+ [TestFixture]
+ public class CtrDrbgTest
+ : SimpleTest
+ {
+ public override string Name
+ {
+ get { return "CTRDRBGTest"; }
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new CtrDrbgTest());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+
+ private DrbgTestVector[] CreateTestVectorData()
+ {
+ return new DrbgTestVector[]
+ {
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ false,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "ABC88224514D0316EA3D48AEE3C9A2B4",
+ "D3D3F372E43E7ABDC4FA293743EED076"
+ }
+ ),
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ false,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "D4564EE072ACA5BD279536E14F94CB12",
+ "1CCD9AFEF15A9679BA75E35225585DEA"
+ }
+ )
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBC"),
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ false,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "760BED7D92B083B10AF31CF0656081EB",
+ "FD1AC41482384D823CF3FD6F0E6C88B3"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C"),
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ false,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "7A4C1D7ADC8A67FDB50100ED23583A2C",
+ "43044D311C0E07541CA5C8B0916976B2"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C")
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBC"),
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ true,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "8FB78ABCA75C9F284E974E36141866BC",
+ "9D9745FF31C42A4488CBB771B13B5D86"
+ }
+ ),
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ true,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "0E389920A09B485AA4ABD0CA7E60D89C",
+ "F4478EC6659A0D3577625B0C73A211DD"
+ }
+ )
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBC"),
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ true,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "64983055D014550B39DE699E43130B64",
+ "035FDDA8582A2214EC722C410A8D95D3"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C"),
+ new DrbgTestVector(
+ new DesEdeEngine(), 168,
+ new Bit232EntropyProvider().Get(232),
+ true,
+ "20212223242526",
+ 112,
+ new string[]
+ {
+ "A29C1A8C42FBC562D7D1DBA7DC541FFE",
+ "0BDA66B049429061C013E4228C2F44C6"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C")
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBC"),
+ new DrbgTestVector(
+ new AesFastEngine(), 128,
+ new Bit256EntropyProvider().Get(256),
+ false,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "8CF59C8CF6888B96EB1C1E3E79D82387AF08A9E5FF75E23F1FBCD4559B6B997E",
+ "69CDEF912C692D61B1DA4C05146B52EB7B8849BD87937835328254EC25A9180E"
+ }
+ ),
+ new DrbgTestVector(
+ new AesFastEngine(), 128,
+ new Bit256EntropyProvider().Get(256),
+ false,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "E8C74A4B7BFFB53BEB80E78CA86BB6DF70E2032AEB473E0DD54D2339CEFCE9D0",
+ "26B3F823B4DBAFC23B141375E10B3AEB7A0B5DEF1C7D760B6F827D01ECD17AC7"
+ }
+ )
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"),
+ new DrbgTestVector(
+ new AesFastEngine(), 128,
+ new Bit256EntropyProvider().Get(256),
+ false,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "18FDEFBDC43D7A36D5D6D862205765D1D701C9F237007030DF1B8E70EE4EEE29",
+ "9888F1D38BB1CCE31B363AA1BD9B39616876C30DEE1FF0B7BD8C4C441715C833"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F"),
+ new DrbgTestVector(
+ new AesFastEngine(), 128,
+ new Bit256EntropyProvider().Get(256),
+ true,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "BFF4B85D68C84529F24F69F9ACF1756E29BA648DDEB825C225FA32BA490EF4A9",
+ "9BD2635137A52AF7D0FCBEFEFB97EA93A0F4C438BD98956C0DACB04F15EE25B3"
+ }
+ ),
+ new DrbgTestVector(
+ new AesFastEngine(), 128,
+ new Bit256EntropyProvider().Get(256),
+ true,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "4573AC8BBB33D7CC4DBEF3EEDF6EAE748B536C3A1082CEE4948CDB51C83A7F9C",
+ "99C628CDD87BD8C2F1FE443AA7F761DA16886436326323354DA6311FFF5BC678"
+ }
+ )
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"),
+ new DrbgTestVector(
+ new AesFastEngine(), 128,
+ new Bit256EntropyProvider().Get(256),
+ true,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "F324104E2FA14F79D8AA60DF06B93B3BC157324958F0A7EE1E193677A70E0250",
+ "78F4C840134F40DC001BFAD3A90B5EF4DEBDBFAC3CFDF0CD69A89DC4FD34713F"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F"),
+ new DrbgTestVector(
+ new AesFastEngine(), 192,
+ new Bit320EntropyProvider().Get(320),
+ false,
+ "202122232425262728292A2B",
+ 192,
+ new string[]
+ {
+ "E231244B3235B085C81604424357E85201E3828B5C45568679A5555F867AAC8C",
+ "DDD0F7BCCADADAA31A67652259CE569A271DD85CF66C3D6A7E9FAED61F38D219"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F6061626364656667"),
+ new DrbgTestVector(
+ new AesFastEngine(), 192,
+ new Bit320EntropyProvider().Get(320),
+ true,
+ "202122232425262728292A2B",
+ 192,
+ new string[]
+ {
+ "F780D4A2C25CF8EE7407D948EC0B724A4235D8B20E65081392755CA7912AD7C0",
+ "BA14617F915BA964CB79276BDADC840C14B631BBD1A59097054FA6DFF863B238"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F6061626364656667"),
+ new DrbgTestVector(
+ new AesFastEngine(), 256,
+ new Bit384EntropyProvider().Get(384),
+ false,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "47111E146562E9AA2FB2A1B095D37A8165AF8FC7CA611D632BE7D4C145C83900",
+ "98A28E3B1BA363C9DAF0F6887A1CF52B833D3354D77A7C10837DD63DD2E645F8"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F")
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECF"),
+ new DrbgTestVector(
+ new AesFastEngine(), 256,
+ new Bit384EntropyProvider().Get(384),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "71BB3F9C9CEAF4E6C92A83EB4C7225010EE150AC75E23F5F77AD5073EF24D88A",
+ "386DEBBBF091BBF0502957B0329938FB836B82E594A2F5FDD5EB28D4E35528F4"
+ }
+ )
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECF"),
+ new DrbgTestVector(
+ new AesFastEngine(), 256,
+ new Bit384EntropyProvider().Get(384),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "1A2E3FEE9056E98D375525FDC2B63B95B47CE51FCF594D804BD5A17F2E01139B",
+ "601F95384F0D85946301D1EACE8F645A825CE38F1E2565B0C0C439448E9CA8AC"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F"),
+ new DrbgTestVector(
+ new AesFastEngine(), 256,
+ new Bit384EntropyProvider().Get(384),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "EAE6BCE781807E524D26605EA198077932D01EEB445B9AC6C5D99C101D29F46E",
+ "738E99C95AF59519AAD37FF3D5180986ADEBAB6E95836725097E50A8D1D0BD28"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F")
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECF"),
+ new DrbgTestVector(
+ new AesFastEngine(), 256,
+ new Bit384EntropyProvider().Get(384),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "eae6bce781807e524d26605ea198077932d01eeb445b9ac6c5d99c101d29f46e30b27377",
+ "ec51b55b49904c3ff9e13939f1cf27398993e1b3acb2b0be0be8761261428f0aa8ba2657"
+ }
+ )
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F")
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECF")
+ };
+ }
+
+ public override void PerformTest()
+ {
+ DrbgTestVector[] tests = CreateTestVectorData();
+ ISP80090Drbg d;
+ DrbgTestVector tv;
+ byte[] output;
+
+ for (int i = 0; i != tests.Length; i++)
+ {
+ tv = tests[i];
+
+ byte[] nonce = tv.GetNonce();
+ byte[] personalisationString = tv.GetPersonalizationString();
+
+ d = new CtrSP800Drbg(tv.Cipher, tv.KeySizeInBits, tv.SecurityStrength, tv.EntropySource, personalisationString, nonce);
+
+ output = new byte[tv.GetExpectedValue(0).Length];
+
+ d.Generate(output, tv.GetAdditionalInput(0), tv.PredictionResistance);
+
+ byte[] expected = tv.GetExpectedValue(0);
+
+ if (!AreEqual(expected, output))
+ {
+ Fail("Test #" + (i + 1) + ".1 failed, expected " + Hex.ToHexString(tv.GetExpectedValue(0)) + " got " + Hex.ToHexString(output));
+ }
+
+ output = new byte[tv.GetExpectedValue(0).Length];
+
+ d.Generate(output, tv.GetAdditionalInput(1), tv.PredictionResistance);
+
+ expected = tv.GetExpectedValue(1);
+ if (!AreEqual(expected, output))
+ {
+ Fail("Test #" + (i + 1) + ".2 failed, expected " + Hex.ToHexString(tv.GetExpectedValue(1)) + " got " + Hex.ToHexString(output));
+ }
+ }
+
+ // DESede/TDEA key parity test
+ tv = tests[0];
+
+ ISP80090Drbg drbg = new CtrSP800Drbg(new KeyParityCipher(tv.Cipher), tv.KeySizeInBits, tv.SecurityStrength, tv.EntropySource,
+ tv.GetPersonalizationString(), tv.GetNonce());
+
+ output = new byte[tv.GetExpectedValue(0).Length];
+
+ drbg.Generate(output, tv.GetAdditionalInput(0), tv.PredictionResistance);
+
+ // Exception tests
+ try
+ {
+ d = new CtrSP800Drbg(new AesEngine(), 256, 256, new Bit232EntropyProvider().Get(128), null, null);
+ Fail("no exception thrown");
+ }
+ catch (ArgumentException e)
+ {
+ if (!e.Message.Equals("Not enough entropy for security strength required"))
+ {
+ Fail("Wrong exception", e);
+ }
+ }
+
+ try
+ {
+ d = new CtrSP800Drbg(new DesEdeEngine(), 256, 256, new Bit232EntropyProvider().Get(232), null, null);
+ Fail("no exception thrown");
+ }
+ catch (ArgumentException e)
+ {
+ if (!e.Message.Equals("Requested security strength is not supported by block cipher and key size"))
+ {
+ Fail("Wrong exception", e);
+ }
+ }
+
+ try
+ {
+ d = new CtrSP800Drbg(new DesEdeEngine(), 168, 256, new Bit232EntropyProvider().Get(232), null, null);
+ Fail("no exception thrown");
+ }
+ catch (ArgumentException e)
+ {
+ if (!e.Message.Equals("Requested security strength is not supported by block cipher and key size"))
+ {
+ Fail("Wrong exception", e);
+ }
+ }
+
+ try
+ {
+ d = new CtrSP800Drbg(new AesEngine(), 192, 256, new Bit232EntropyProvider().Get(232), null, null);
+ Fail("no exception thrown");
+ }
+ catch (ArgumentException e)
+ {
+ if (!e.Message.Equals("Requested security strength is not supported by block cipher and key size"))
+ {
+ Fail("Wrong exception", e);
+ }
+ }
+ }
+
+ internal class Bit232EntropyProvider : TestEntropySourceProvider
+ {
+ internal Bit232EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C" +
+ "808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDC"), true)
+ { }
+ }
+
+ internal class Bit256EntropyProvider : TestEntropySourceProvider
+ {
+ internal Bit256EntropyProvider(): base(Hex.Decode(
+ "0001020304050607" +
+ "08090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F" +
+ "8081828384858687" +
+ "88898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F" +
+ "C0C1C2C3C4C5C6C7" +
+ "C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF"), true)
+ { }
+ }
+
+ internal class Bit320EntropyProvider : TestEntropySourceProvider
+ {
+ internal Bit320EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E0F" +
+ "101112131415161718191A1B1C1D1E1F2021222324252627" +
+ "808182838485868788898A8B8C8D8E8F" +
+ "909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF" +
+ "D0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7"), true)
+ { }
+ }
+
+ internal class Bit384EntropyProvider : TestEntropySourceProvider
+ {
+ internal Bit384EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E0F1011121314151617" +
+ "18191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F" +
+ "808182838485868788898A8B8C8D8E8F9091929394959697" +
+ "98999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAF" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7" +
+ "D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF"), true)
+ { }
+ }
+
+ internal class KeyParityCipher : IBlockCipher
+ {
+ private IBlockCipher cipher;
+
+ internal KeyParityCipher(IBlockCipher cipher)
+ {
+ this.cipher = cipher;
+ }
+
+ public void Init(bool forEncryption, ICipherParameters parameters)
+ {
+ byte[] k = Arrays.Clone(((KeyParameter)parameters).GetKey());
+
+ DesEdeParameters.SetOddParity(k);
+
+ if (!Arrays.AreEqual(((KeyParameter)parameters).GetKey(), k))
+ {
+ throw new ArgumentException("key not odd parity");
+ }
+
+ cipher.Init(forEncryption, parameters);
+ }
+
+ public String AlgorithmName
+ {
+ get { return cipher.AlgorithmName; }
+ }
+
+ public bool IsPartialBlockOkay
+ {
+ get { return false; }
+ }
+
+ public int GetBlockSize()
+ {
+ return cipher.GetBlockSize();
+ }
+
+ public int ProcessBlock(byte[] input, int inOff, byte[] output, int outOff)
+ {
+ return cipher.ProcessBlock(input, inOff, output, outOff);
+ }
+
+ public void Reset()
+ {
+ cipher.Reset();
+ }
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/prng/test/DrbgTestVector.cs b/crypto/test/src/crypto/prng/test/DrbgTestVector.cs
new file mode 100644
index 000000000..e0a8eeaf5
--- /dev/null
+++ b/crypto/test/src/crypto/prng/test/DrbgTestVector.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Collections;
+
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Crypto.Prng.Test
+{
+ public class DrbgTestVector
+ {
+ private IDigest _digest;
+ private IBlockCipher _cipher;
+ private int _keySizeInBits;
+ private IEntropySource _eSource;
+ private bool _pr;
+ private string _nonce;
+ private string _personalisation;
+ private int _ss;
+ private String[] _ev;
+ private IList _ai = new ArrayList();
+
+ public DrbgTestVector(IDigest digest, IEntropySource eSource, bool predictionResistance, string nonce,
+ int securityStrength, string[] expected)
+ {
+ _digest = digest;
+ _eSource = eSource;
+ _pr = predictionResistance;
+ _nonce = nonce;
+ _ss = securityStrength;
+ _ev = expected;
+ _personalisation = null;
+ }
+
+ public DrbgTestVector(IBlockCipher cipher, int keySizeInBits, IEntropySource eSource, bool predictionResistance,
+ string nonce, int securityStrength, string[] expected)
+ {
+ _cipher = cipher;
+ _keySizeInBits = keySizeInBits;
+ _eSource = eSource;
+ _pr = predictionResistance;
+ _nonce = nonce;
+ _ss = securityStrength;
+ _ev = expected;
+ _personalisation = null;
+ }
+
+ public IDigest Digest
+ {
+ get { return _digest; }
+ }
+
+ public IBlockCipher Cipher
+ {
+ get { return _cipher; }
+ }
+
+ public int KeySizeInBits
+ {
+ get { return _keySizeInBits; }
+ }
+
+ public DrbgTestVector AddAdditionalInput(string input)
+ {
+ _ai.Add(input);
+ return this;
+ }
+
+ public DrbgTestVector SetPersonalizationString(string p)
+ {
+ _personalisation = p;
+ return this;
+ }
+
+ public IEntropySource EntropySource
+ {
+ get { return _eSource; }
+ }
+
+ public bool PredictionResistance
+ {
+ get { return _pr; }
+ }
+
+ public byte[] GetNonce()
+ {
+ return _nonce == null ? null : Hex.Decode(_nonce);
+ }
+
+ public byte[] GetPersonalizationString()
+ {
+ return _personalisation == null ? null : Hex.Decode(_personalisation);
+ }
+
+ public int SecurityStrength
+ {
+ get { return _ss; }
+ }
+
+ public byte[] GetExpectedValue(int index)
+ {
+ return Hex.Decode(_ev[index]);
+ }
+
+ public byte[] GetAdditionalInput(int position)
+ {
+ if (position >= _ai.Count)
+ return null;
+
+ return Hex.Decode((string)_ai[position]);
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/prng/test/HMacDrbgTest.cs b/crypto/test/src/crypto/prng/test/HMacDrbgTest.cs
new file mode 100644
index 000000000..a5ca30836
--- /dev/null
+++ b/crypto/test/src/crypto/prng/test/HMacDrbgTest.cs
@@ -0,0 +1,524 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Crypto.Macs;
+using Org.BouncyCastle.Crypto.Prng.Drbg;
+using Org.BouncyCastle.Utilities.Test;
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Crypto.Prng.Test
+{
+ /**
+ * HMAC SP800-90 DRBG
+ */
+ [TestFixture]
+ public class HMacDrbgTest
+ : SimpleTest
+ {
+ public override string Name
+ {
+ get { return "HMacDRBG"; }
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new HMacDrbgTest());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+
+ private DrbgTestVector[] CreateTestVectorData()
+ {
+ return new DrbgTestVector[]
+ {
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ false,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "5A7D3B449F481CB38DF79AD2B1FCC01E57F8135E8C0B22CD0630BFB0127FB5408C8EFC17A929896E",
+ "82cf772ec3e84b00fc74f5df104efbfb2428554e9ce367d03aeade37827fa8e9cb6a08196115d948"
+ }),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ false,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "B3BD05246CBA12A64735A4E3FDE599BC1BE30F439BD060208EEA7D71F9D123DF47B3CE069D98EDE6",
+ "B5DADA380E2872DF935BCA55B882C8C9376902AB639765472B71ACEBE2EA8B1B6B49629CB67317E0"
+ })
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F70717273747576"),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ false,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "C7AAAC583C6EF6300714C2CC5D06C148CFFB40449AD0BB26FAC0497B5C57E161E36681BCC930CE80",
+ "6EBD2B7B5E0A2AD7A24B1BF9A1DBA47D43271719B9C37B7FE81BA94045A14A7CB514B446666EA5A7"
+ })
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F90919293949596")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6"),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ true,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "FEC4597F06A3A8CC8529D59557B9E661053809C0BC0EFC282ABD87605CC90CBA9B8633DCB1DAE02E",
+ "84ADD5E2D2041C01723A4DE4335B13EFDF16B0E51A0AD39BD15E862E644F31E4A2D7D843E57C5968"
+ }),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ true,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "6C37FDD729AA40F80BC6AB08CA7CC649794F6998B57081E4220F22C5C283E2C91B8E305AB869C625",
+ "CAF57DCFEA393B9236BF691FA456FEA7FDF1DF8361482CA54D5FA723F4C88B4FA504BF03277FA783"
+ })
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F70717273747576"),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ true,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "A1BA8FA58BB5013F43F7B6ED52B4539FA16DC77957AEE815B9C07004C7E992EB8C7E591964AFEEA2",
+ "84264A73A818C95C2F424B37D3CC990B046FB50C2DC64A164211889A010F2471A0912FFEA1BF0195"
+ })
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F90919293949596")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6"),
+ new DrbgTestVector(
+ new Sha256Digest(),
+ new SHA256EntropyProvider().Get(440),
+ false,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "D67B8C1734F46FA3F763CF57C6F9F4F2" +
+ "DC1089BD8BC1F6F023950BFC5617635208C8501238AD7A44" +
+ "00DEFEE46C640B61AF77C2D1A3BFAA90EDE5D207406E5403",
+ "8FDAEC20F8B421407059E3588920DA7E" +
+ "DA9DCE3CF8274DFA1C59C108C1D0AA9B0FA38DA5C792037C" +
+ "4D33CD070CA7CD0C5608DBA8B885654639DE2187B74CB263"
+ }),
+ new DrbgTestVector(
+ new Sha256Digest(),
+ new SHA256EntropyProvider().Get(440),
+ true,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "FABD0AE25C69DC2EFDEFB7F20C5A31B5" +
+ "7AC938AB771AA19BF8F5F1468F665C938C9A1A5DF0628A56" +
+ "90F15A1AD8A613F31BBD65EEAD5457D5D26947F29FE91AA7",
+ "6BD925B0E1C232EFD67CCD84F722E927" +
+ "ECB46AB2B740014777AF14BA0BBF53A45BDBB62B3F7D0B9C" +
+ "8EEAD057C0EC754EF8B53E60A1F434F05946A8B686AFBC7A"
+ }),
+ new DrbgTestVector(
+ new Sha384Digest(),
+ new SHA384EntropyProvider().Get(888),
+ false,
+ "202122232425262728292A2B",
+ 192,
+ new string[]
+ {
+ "03AB8BCE4D1DBBB636C5C5B7E1C58499FEB1C619CDD11D35" +
+ "CD6CF6BB8F20EF27B6F5F9054FF900DB9EBF7BF30ED4DCBB" +
+ "BC8D5B51C965EA226FFEE2CA5AB2EFD00754DC32F357BF7A" +
+ "E42275E0F7704DC44E50A5220AD05AB698A22640AC634829",
+ "B907E77144FD55A54E9BA1A6A0EED0AAC780020C41A15DD8" +
+ "9A6C163830BA1D094E6A17100FF71EE30A96E1EE04D2A966" +
+ "03832A4E404F1966C2B5F4CB61B9927E8D12AC1E1A24CF23" +
+ "88C14E8EC96C35181EAEE32AAA46330DEAAFE5E7CE783C74"
+ })
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE"),
+ new DrbgTestVector(
+ new Sha384Digest(),
+ new SHA384EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B",
+ 192,
+ new string[]
+ {
+ "804A3AD720F4FCE8738D0632514FEF16430CB7D63A8DF1A5" +
+ "F02A3CE3BD7ED6A668B69E63E2BB93F096EE753D6194A0F1" +
+ "A32711063653009636337D22167CC4402D019AC216FA574F" +
+ "091CF6EA283568D737A77BE38E8F09382C69E76B142ABC3A",
+ "73B8E55C753202176A17B9B9754A9FE6F23B01861FCD4059" +
+ "6AEAA301AF1AEF8AF0EAF22FBF34541EFFAB1431666ACACC" +
+ "759338C7E28672819D53CFEF10A3E19DAFBD53295F1980A9" +
+ "F491504A2725506784B7AC826D92C838A8668171CAAA86E7"
+ })
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ false,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "2A5FF6520C20F66E" +
+ "D5EA431BD4AEAC58F975EEC9A015137D5C94B73AA09CB8B5" +
+ "9D611DDEECEB34A52BB999424009EB9EAC5353F92A6699D2" +
+ "0A02164EEBBC6492941E10426323898465DFD731C7E04730" +
+ "60A5AA8973841FDF3446FB6E72A58DA8BDA2A57A36F3DD98" +
+ "6DF85C8A5C6FF31CDE660BF8A841B21DD6AA9D3AC356B87B",
+ "0EDC8D7D7CEEC7FE" +
+ "36333FB30C0A9A4B27AA0BECBF075568B006C1C3693B1C29" +
+ "0F84769C213F98EB5880909EDF068FDA6BFC43503987BBBD" +
+ "4FC23AFBE982FE4B4B007910CC4874EEC217405421C8D8A1" +
+ "BA87EC684D0AF9A6101D9DB787AE82C3A6A25ED478DF1B12" +
+ "212CEC325466F3AC7C48A56166DD0B119C8673A1A9D54F67"
+ })
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "AAE4DC3C9ECC74D9" +
+ "061DD527117EF3D29E1E52B26853C539D6CA797E8DA3D0BB" +
+ "171D8E30B8B194D8C28F7F6BE3B986B88506DC6A01B294A7" +
+ "165DD1C3470F7BE7B396AA0DB7D50C4051E7C7E1C8A7D21A" +
+ "2B5878C0BCB163CAA79366E7A1162FDC88429616CD3E6977" +
+ "8D327520A6BBBF71D8AA2E03EC4A9DAA0E77CF93E1EE30D2 ",
+ "129FF6D31A23FFBC" +
+ "870632B35EE477C2280DDD2ECDABEDB900C78418BE2D243B" +
+ "B9D8E5093ECE7B6BF48638D8F704D134ADDEB7F4E9D5C142" +
+ "CD05683E72B516486AF24AEC15D61E81E270DD4EBED91B62" +
+ "12EB8896A6250D5C8BC3A4A12F7E3068FBDF856F47EB23D3" +
+ "79F82C1EBCD1585FB260B9C0C42625FBCEE68CAD773CD5B1"
+ })
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ false,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "7AE31A2DEC31075F" +
+ "E5972660C16D22ECC0D415C5693001BE5A468B590BC1AE2C" +
+ "43F647F8D681AEEA0D87B79B0B4E5D089CA2C9D327534234" +
+ "0254E6B04690D77A71A294DA9568479EEF8BB2A2110F18B6" +
+ "22F60F35235DE0E8F9D7E98105D84AA24AF0757AF005DFD5" +
+ "2FA51DE3F44FCE0C5F3A27FCE8B0F6E4A3F7C7B53CE34A3D",
+ "D83A8084630F286D" +
+ "A4DB49B9F6F608C8993F7F1397EA0D6F4A72CF3EF2733A11" +
+ "AB823C29F2EBDEC3EDE962F93D920A1DB59C84E1E879C29F" +
+ "5F9995FC3A6A3AF9B587CA7C13EA197D423E81E1D6469942" +
+ "B6E2CA83A97E91F6B298266AC148A1809776C26AF5E239A5" +
+ "5A2BEB9E752203A694E1F3FE2B3E6A0C9C314421CDB55FBD "
+ })
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE")
+ .AddAdditionalInput(
+ "606162636465666768696A6B6C6D6E" +
+ "6F707172737475767778797A7B7C7D7E7F80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCE")
+ .AddAdditionalInput(
+ "A0A1A2A3A4A5A6A7A8A9AAABACADAE" +
+ "AFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6" +
+ "F7F8F9FAFBFCFDFEFF000102030405060708090A0B0C0D0E"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "28FD6060C4F35F4D" +
+ "317AB2060EE32019E0DAA330F3F5650BBCA57CB67EE6AF1C" +
+ "6F25D1B01F3601EDA85DC2ED29A9B2BA4C85CF491CE7185F" +
+ "1A2BD9378AE3C655BD1CEC2EE108AE7FC382989F6D4FEA8A" +
+ "B01499697C2F07945CE02C5ED617D04287FEAF3BA638A4CE" +
+ "F3BB6B827E40AF16279580FCF1FDAD830930F7FDE341E2AF",
+ "C0B1601AFE39338B" +
+ "58DC2BE7C256AEBE3C21C5A939BEEC7E97B3528AC420F0C6" +
+ "341847187666E0FF578A8EB0A37809F877365A28DF2FA0F0" +
+ "6354A6F02496747369375B9A9D6B756FDC4A8FB308E08256" +
+ "9D79A85BB960F747256626389A3B45B0ABE7ECBC39D5CD7B" +
+ "2C18DF2E5FDE8C9B8D43474C54B6F9839468445929B438C7"
+ }),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "72691D2103FB567C" +
+ "CD30370715B36666F63430087B1C688281CA0974DB456BDB" +
+ "A7EB5C48CFF62EA05F9508F3B530CE995A272B11EC079C13" +
+ "923EEF8E011A93C19B58CC6716BC7CB8BD886CAA60C14D85" +
+ "C023348BD77738C475D6C7E1D9BFF4B12C43D8CC73F838DC" +
+ "4F8BD476CF8328EEB71B3D873D6B7B859C9B21065638FF95",
+ "8570DA3D47E1E160" +
+ "5CF3E44B8D328B995EFC64107B6292D1B1036B5F88CE3160" +
+ "2F12BEB71D801C0942E7C0864B3DB67A9356DB203490D881" +
+ "24FE86BCE38AC2269B4FDA6ABAA884039DF80A0336A24D79" +
+ "1EB3067C8F5F0CF0F18DD73B66A7B316FB19E02835CC6293" +
+ "65FCD1D3BE640178ED9093B91B36E1D68135F2785BFF505C"
+ })
+ .AddAdditionalInput(
+ "606162636465666768696A6B6C6D6E" +
+ "6F707172737475767778797A7B7C7D7E7F80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCE")
+ .AddAdditionalInput(
+ "A0A1A2A3A4A5A6A7A8A9AAABACADAE" +
+ "AFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6" +
+ "F7F8F9FAFBFCFDFEFF000102030405060708090A0B0C0D0E"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "AAE4DC3C9ECC74D9" +
+ "061DD527117EF3D29E1E52B26853C539D6CA797E8DA3D0BB" +
+ "171D8E30B8B194D8C28F7F6BE3B986B88506DC6A01B294A7" +
+ "165DD1C3470F7BE7B396AA0DB7D50C4051E7C7E1C8A7D21A" +
+ "2B5878C0BCB163CAA79366E7A1162FDC88429616CD3E6977" +
+ "8D327520A6BBBF71D8AA2E03EC4A9DAA0E77CF93E1EE30D2 ",
+ "129FF6D31A23FFBC" +
+ "870632B35EE477C2280DDD2ECDABEDB900C78418BE2D243B" +
+ "B9D8E5093ECE7B6BF48638D8F704D134ADDEB7F4E9D5C142" +
+ "CD05683E72B516486AF24AEC15D61E81E270DD4EBED91B62" +
+ "12EB8896A6250D5C8BC3A4A12F7E3068FBDF856F47EB23D3" +
+ "79F82C1EBCD1585FB260B9C0C42625FBCEE68CAD773CD5B1"
+ })
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "B8E827652175E6E0" +
+ "6E513C7BE94B5810C14ED94AD903647940CAEB7EE014C848" +
+ "8DCBBE6D4D6616D06656A3DC707CDAC4F02EE6D8408C065F" +
+ "CB068C0760DA47C5D60E5D70D09DC3929B6979615D117F7B" +
+ "EDCC661A98514B3A1F55B2CBABDCA59F11823E4838065F1F" +
+ "8431CBF28A577738234AF3F188C7190CC19739E72E9BBFFF",
+ "7ED41B9CFDC8C256" +
+ "83BBB4C553CC2DC61F690E62ABC9F038A16B8C519690CABE" +
+ "BD1B5C196C57CF759BB9871BE0C163A57315EA96F615136D" +
+ "064572F09F26D659D24211F9610FFCDFFDA8CE23FFA96735" +
+ "7595182660877766035EED800B05364CE324A75EB63FD9B3" +
+ "EED956D147480B1D0A42DF8AA990BB628666F6F61D60CBE2"
+ })
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE")
+ .AddAdditionalInput(
+ "606162636465666768696A6B6C6D6E" +
+ "6F707172737475767778797A7B7C7D7E7F80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCE")
+ .AddAdditionalInput(
+ "A0A1A2A3A4A5A6A7A8A9AAABACADAE" +
+ "AFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6" +
+ "F7F8F9FAFBFCFDFEFF000102030405060708090A0B0C0D0E")
+ };
+ }
+
+ public override void PerformTest()
+ {
+ DrbgTestVector[] tests = CreateTestVectorData();
+ ISP80090Drbg d;
+
+ for (int i = 0; i != tests.Length; i++)
+ {
+ DrbgTestVector tv = tests[i];
+
+ byte[] nonce = tv.GetNonce();
+ byte[] personalisationString = tv.GetPersonalizationString();
+
+ d = new HMacSP800Drbg(new HMac(tv.Digest), tv.SecurityStrength, tv.EntropySource, personalisationString, nonce);
+
+ byte[] output = new byte[tv.GetExpectedValue(0).Length];
+
+ d.Generate(output, tv.GetAdditionalInput(0), tv.PredictionResistance);
+
+ byte[] expected = tv.GetExpectedValue(0);
+
+ if (!AreEqual(expected, output))
+ {
+ Fail("Test #" + (i + 1) + ".1 failed, expected " + Hex.ToHexString(tv.GetExpectedValue(0)) + " got " + Hex.ToHexString(output));
+ }
+
+ output = new byte[tv.GetExpectedValue(0).Length];
+
+ d.Generate(output, tv.GetAdditionalInput(1), tv.PredictionResistance);
+
+ expected = tv.GetExpectedValue(1);
+ if (!AreEqual(expected, output))
+ {
+ Fail("Test #" + (i + 1) + ".2 failed, expected " + Hex.ToHexString(tv.GetExpectedValue(1)) + " got " + Hex.ToHexString(output));
+ }
+ }
+
+ // Exception tests
+ //
+ try
+ {
+ d = new HMacSP800Drbg(new HMac(new Sha256Digest()), 256, new SHA256EntropyProvider().Get(128), null, null);
+ Fail("no exception thrown");
+ }
+ catch (ArgumentException e)
+ {
+ if (!e.Message.Equals("Not enough entropy for security strength required"))
+ {
+ Fail("Wrong exception", e);
+ }
+ }
+ }
+
+ private class SHA1EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA1EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30313233343536" +
+ "808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6"), true)
+ {
+ }
+ }
+
+ internal class SHA256EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA256EntropyProvider() : base(Hex.Decode(
+ "00010203040506" +
+ "0708090A0B0C0D0E0F101112131415161718191A1B1C1D1E" +
+ "1F202122232425262728292A2B2C2D2E2F30313233343536" +
+ "80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "C0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6"), true)
+ {
+ }
+ }
+
+ internal class SHA384EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA384EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20212223242526" +
+ "2728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F50515253545556" +
+ "5758595A5B5C5D5E5F606162636465666768696A6B6C6D6E" +
+ "808182838485868788898A8B8C8D8E" +
+ "8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6" +
+ "A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBE" +
+ "BFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6" +
+ "D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEE" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCE" +
+ "CFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6" +
+ "E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFE" +
+ "FF000102030405060708090A0B0C0D0E0F10111213141516" +
+ "1718191A1B1C1D1E1F202122232425262728292A2B2C2D2E"), true)
+ { }
+ }
+
+ internal class SHA512EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA512EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E" +
+ "0F101112131415161718191A1B1C1D1E1F20212223242526" +
+ "2728292A2B2C2D2E2F303132333435363738393A3B3C3D3E" +
+ "3F404142434445464748494A4B4C4D4E4F50515253545556" +
+ "5758595A5B5C5D5E5F606162636465666768696A6B6C6D6E" +
+ "808182838485868788898A8B8C8D8E" +
+ "8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6" +
+ "A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBE" +
+ "BFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6" +
+ "D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEE" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCE" +
+ "CFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6" +
+ "E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFE" +
+ "FF000102030405060708090A0B0C0D0E0F10111213141516" +
+ "1718191A1B1C1D1E1F202122232425262728292A2B2C2D2E"), true)
+ { }
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/prng/test/HashDrbgTest.cs b/crypto/test/src/crypto/prng/test/HashDrbgTest.cs
new file mode 100644
index 000000000..892ca74da
--- /dev/null
+++ b/crypto/test/src/crypto/prng/test/HashDrbgTest.cs
@@ -0,0 +1,477 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Crypto.Prng.Drbg;
+using Org.BouncyCastle.Utilities.Test;
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Crypto.Prng.Test
+{
+ /**
+ * DRBG Test
+ */
+ [TestFixture]
+ public class HashDrbgTest
+ : SimpleTest
+ {
+ public override string Name
+ {
+ get { return "HashDRBG"; }
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new HashDrbgTest());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+
+ private DrbgTestVector[] CreateTestVectorData()
+ {
+ return new DrbgTestVector[]
+ {
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ false,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "9F7CFF1ECA23E750F66326969F11800F12088BA68E441D15D888B3FE12BF66FE057494F4546DE2F1",
+ "B77AA5C0CD55BBCEED7574AF223AFD988C7EEC8EFF4A94E5E89D26A04F58FA79F5E0D3702D7A9A6A"
+ }
+ ),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ false,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "AB438BD3B01A0AF85CFEE29F7D7B71621C4908B909124D430E7B406FB1086EA994C582E0D656D989",
+ "29D9098F987E7005314A0F51B3DD2B8122F4AED706735DE6AD5DDBF223177C1E5F3AEBC52FAB90B9"
+ })
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F70717273747576"),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ false,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "E76B4EDD5C865BC8AFD809A59B69B429AC7F4352A579BCF3F75E56249A3491F87C3CA6848B0FAB25",
+ "6577B6B4F87A93240B199FE51A3B335313683103DECE171E3256FB7E803586CA4E45DD242EB01F70"
+ })
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F90919293949596")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6"),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ true,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "56EF4913373994D5539F4D7D17AFE7448CDF5E72416CC6A71A340059FA0D5AE526B23250C46C0944",
+ "575B37A2739814F966C63B60A2C4F149CA9ACC84FC4B25493289B085C67B2E30F5F0B99A2C349E2A"
+ }),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ true,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "532CA1165DCFF21C55592687639884AF4BC4B057DF8F41DE653AB44E2ADEC7C9303E75ABE277EDBF",
+ "73C2C67C696D686D0C4DBCEB5C2AF7DDF6F020B6874FAE4390F102117ECAAFF54418529A367005A0"
+ })
+ .SetPersonalizationString("404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F70717273747576"),
+ new DrbgTestVector(
+ new Sha1Digest(),
+ new SHA1EntropyProvider().Get(440),
+ true,
+ "2021222324",
+ 80,
+ new string[]
+ {
+ "183C242A1430E46C4ED70B4DBE1BF9AB0AB8721CDCA2A2D1820AD6F6C956858543B2AA191D8D1287",
+ "F196F9BD021C745CBD5AC7BFCE48EAAF0D0E7C091FBF436940E63A198EE770D9A4F0718669AF2BC9"
+ })
+ .AddAdditionalInput("606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F90919293949596")
+ .AddAdditionalInput("A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6"),
+ new DrbgTestVector(
+ new Sha256Digest(),
+ new SHA256EntropyProvider().Get(440),
+ false,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "77E05A0E7DC78AB5D8934D5E93E82C06" +
+ "A07C04CEE6C9C53045EEB485872777CF3B3E35C474F976B8" +
+ "94BF301A86FA651F463970E89D4A0534B2ECAD29EC044E7E",
+ "5FF4BA493C40CFFF3B01E472C575668C" +
+ "CE3880B9290B05BFEDE5EC96ED5E9B2898508B09BC800EEE" +
+ "099A3C90602ABD4B1D4F343D497C6055C87BB956D53BF351"
+ }
+ ),
+ new DrbgTestVector(
+ new Sha256Digest(),
+ new SHA256EntropyProvider().Get(440),
+ true,
+ "2021222324252627",
+ 128,
+ new string[]
+ {
+ "92275523C70E567BCF9B35EC50B933F8" +
+ "12616DF586B7F72EE1BC7735A5C2654373CBBC72316DFF84" +
+ "20A33BF02B97AC8D1952583F270ACD7005CC027F4CF1187E",
+ "681A46B2AA8694A0FE4DEEA720927A84" +
+ "EAAA985E59C19F8BE0984D8CBEF8C69B754167641946E040" +
+ "EE2043E1CCB29DCF063C0A50830E428E6DCA262ECD77C542"
+ }),
+ new DrbgTestVector(
+ new Sha384Digest(),
+ new SHA384EntropyProvider().Get(888),
+ false,
+ "202122232425262728292A2B",
+ 192,
+ new string[]
+ {
+ "04FF23AD15E78790ADD36B438BBC097C7A11747CC2CCEEDE" +
+ "2C978B23B3DC63B732C953061D7764990ABFEFC47A581B92" +
+ "1BC0428C4F12212460E406A0F0651E7F0CB9A90ABFDB07B5" +
+ "25565C74F0AA085082F6CF213AAFAD0C0646895078F1E1FE",
+ "4F35B85F95DEE3E873054905CFD02341653E18F529930CBE" +
+ "14D909F37FEAF2C790D22FAE7516B4590BE35D53E2FE1A35" +
+ "AFE4B6607CB358589C3B4D094A1D81FE0717F1DF5BDDEB3E" +
+ "114F130BB781E66C22B5B770E8AE115FF39F8ADAF66DEEDF"
+ }
+ ),
+ new DrbgTestVector(
+ new Sha384Digest(),
+ new SHA384EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B",
+ 192,
+ new string[]
+ {
+ "97993B78F7C31C0E876DC92EB7D6C408E09D608AD6B99D0E" +
+ "A2229B05A578C426334FCC8A1C7E676ED2D89A5B4CDF5B3F" +
+ "4ADF11936BF14F4E10909DBA9C24F4FDFFDE72351DA8E2CC" +
+ "3B135A395373899E5F1A5955B880CA9B9E9DD4C9CA7FA4D4",
+ "F5983946320E36C64EF283CA1F65D197CF81624EC6778E77" +
+ "0E78949D84EF21A45CDD62D1DB76920D4C2836FC6AE5299F" +
+ "AF1357D9701FAD10FBD88D1E2832239436D76EB271BDC3CA" +
+ "04425EC88BC0E89A4D5C37FFCE7C6C3ABDE9C413AE6D3FEA"
+ }
+ ),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ false,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "DA126CF95C6BF97E" +
+ "2F731F2137A907ACC70FD7AC9EBACD1C6E31C74029B052E3" +
+ "AABC48F3B00993F2B2381F7650A55322A968C86E05DE88E6" +
+ "367F6EF89A601DB4342E9086C7AC13B5E56C32E9E668040B" +
+ "73847893C5BFD38A1CF44F348B4EEE4CD68ADB7E7B8C837F" +
+ "19BC4F902761F7CFF24AB1D704FD11C4E929D8553753B55D",
+ "400B977CE8A2BB6A" +
+ "84C6FD1CF901459685ABF5408CFF4588CEDF52E2D2DC300A" +
+ "A9B4FAED8CD0161C2172B1FD269253195883D6EBF21020F2" +
+ "C20E5F2C81AE60C8595B834A229B1F5B726C1125717E6207" +
+ "8886EF38E61E32707AD5F8116C6393DFB6E7C7AE0E8E92BB" +
+ "D7E0C3D04BBA02F5169F2F569A58158915FEE4C9D28D45DB"
+ }
+ )
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE")
+ .AddAdditionalInput(
+ "606162636465666768696A6B6C6D6E" +
+ "6F707172737475767778797A7B7C7D7E7F80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCE")
+ .AddAdditionalInput(
+ "A0A1A2A3A4A5A6A7A8A9AAABACADAE" +
+ "AFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6" +
+ "F7F8F9FAFBFCFDFEFF000102030405060708090A0B0C0D0E"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "F93CA6855590A77F" +
+ "07354097E90E026648B6115DF008FFEDBD9D9811F54E8286" +
+ "EF00FDD6BA1E58DF2535E3FBDD9A9BA3754A97F36EE83322" +
+ "1582060A1F37FCE4EE8826636B28EAD589593F4CA8B64738" +
+ "8F24EB3F0A34796968D21BDEE6F81FD5DF93536F935937B8" +
+ "025EC8CBF57DDB0C61F2E41463CC1516D657DA2829C6BF90",
+ "4817618F48C60FB1" +
+ "CE5BFBDA0CAF4591882A31F6EE3FE0F78779992A06EC60F3" +
+ "7FB9A8D6108C231F0A927754B0599FA4FA27A4E25E065EF0" +
+ "3085B892979DC0E7A1080883CAEBFDFD3665A8F2D061C521" +
+ "F7D6E3DA2AF8B97B6B43B6EC831AF515070A83BBB9AC95ED" +
+ "4EF49B756A2377A5F0833D847E27A88DDB0C2CE4AD782E7B "
+ }
+ ),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "0455DD4AD7DBACB2" +
+ "410BE58DF7248D765A4547ABAEE1743B0BCAD37EBD06DA7C" +
+ "F7CE5E2216E525327E9E2005EBEF2CE53BD733B18128627D" +
+ "3FD6153089373AF2606A1584646A0EA488BFEF45228699A0" +
+ "89CEA8AEC44502D86D9591F3552C688B7F7B45FCB0C3C2B9" +
+ "43C1CD8A6FC63DF4D81C3DA543C9CF2843855EA84E4F959C",
+ "C047D46D7F614E4E" +
+ "4A7952C79A451F8F7ACA379967E2977C401C626A2ED70D74" +
+ "A63660579A354115BC8C8C8CC3AEA3050686A0CFCDB6FA9C" +
+ "F78D4C2165BAF851C6F9B1CD16A2E14C15C6DAAC56C16E75" +
+ "FC84A14D58B41622E88B0F1B1995587FD8BAA999CBA98025" +
+ "4C8AB9A9691DF7B84D88B639A9A3106DEABEB63748B99C09"
+ }
+ )
+ .AddAdditionalInput(
+ "606162636465666768696A6B6C6D6E" +
+ "6F707172737475767778797A7B7C7D7E7F80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCE")
+ .AddAdditionalInput(
+ "A0A1A2A3A4A5A6A7A8A9AAABACADAE" +
+ "AFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6" +
+ "F7F8F9FAFBFCFDFEFF000102030405060708090A0B0C0D0E"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "22EB93A67911DA73" +
+ "85D9180C78127DE1A04FF713114C07C9C615F7CC5EF72744" +
+ "A2DDCD7C3CB85E65DED8EF5F240FBDCBEBBDE2BAAC8ECF7D" +
+ "CBC8AC333E54607AD41DC495D83DF72A05EF55B127C1441C" +
+ "9A0EFFDA2C7954DB6C2D04342EB812E5E0B11D6C395F41ED" +
+ "A2702ECE5BA479E2DFA18F953097492636C12FE30CE5C968",
+ "E66698CFBF1B3F2E" +
+ "919C03036E584EAA81CF1C6666240AF05F70637043733954" +
+ "D8A1E5A66A04C53C6900FDC145D4A3A80A31F5868ACE9AC9" +
+ "4E14E2051F624A05EEA1F8B684AA5410BCE315E76EA07C71" +
+ "5D6F34731320FF0DCF78D795E6EFA2DF92B98BE636CDFBA2" +
+ "9008DD392112AEC202F2E481CB9D83F987FEA69CD1B368BB"
+ }
+ )
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE"),
+ new DrbgTestVector(
+ new Sha512Digest(),
+ new SHA512EntropyProvider().Get(888),
+ true,
+ "202122232425262728292A2B2C2D2E2F",
+ 256,
+ new string[]
+ {
+ "7596A76372308BD5" +
+ "A5613439934678B35521A94D81ABFE63A21ACF61ABB88B61" +
+ "E86A12C37F308F2BBBE32BE4B38D03AE808386494D70EF52" +
+ "E9E1365DD18B7784CAB826F31D47579E4D57F69D8BF3152B" +
+ "95741946CEBE58571DF58ED39980D9AF44E69F01E8989759" +
+ "8E40171101A0E3302838E0AD9E849C01988993CF9F6E5263",
+ "DBE5EE36FCD85301" +
+ "303E1C3617C1AC5E23C08885D0BEFAAD0C85A0D89F85B9F1" +
+ "6ECE3D88A24EB96504F2F13EFA7049621782F5DE2C416A0D" +
+ "294CCFE53545C4E309C48E1E285A2B829A574B72B3C2FBE1" +
+ "34D01E3706B486F2401B9820E17298A342666918E15B8462" +
+ "87F8C5AF2D96B20FAF3D0BB392E15F4A06CDB0DECD1B6AD7"
+ }
+ )
+ .SetPersonalizationString(
+ "404142434445464748494A4B4C4D4E" +
+ "4F505152535455565758595A5B5C5D5E5F60616263646566" +
+ "6768696A6B6C6D6E6F707172737475767778797A7B7C7D7E" +
+ "7F808182838485868788898A8B8C8D8E8F90919293949596" +
+ "9798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAE")
+ .AddAdditionalInput(
+ "606162636465666768696A6B6C6D6E" +
+ "6F707172737475767778797A7B7C7D7E7F80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCE")
+ .AddAdditionalInput(
+ "A0A1A2A3A4A5A6A7A8A9AAABACADAE" +
+ "AFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6" +
+ "F7F8F9FAFBFCFDFEFF000102030405060708090A0B0C0D0E")
+ };
+ }
+
+ public override void PerformTest()
+ {
+ DrbgTestVector[] tests = CreateTestVectorData();
+ ISP80090Drbg d;
+
+ for (int i = 0; i != tests.Length; i++)
+ {
+ DrbgTestVector tv = tests[i];
+
+ byte[] nonce = tv.GetNonce();
+ byte[] personalisationString = tv.GetPersonalizationString();
+
+ d = new HashSP800Drbg(tv.Digest, tv.SecurityStrength, tv.EntropySource, personalisationString, nonce);
+
+ byte[] output = new byte[tv.GetExpectedValue(0).Length];
+
+ d.Generate(output, tv.GetAdditionalInput(0), tv.PredictionResistance);
+
+ byte[] expected = tv.GetExpectedValue(0);
+
+ if (!AreEqual(expected, output))
+ {
+ Fail("Test #" + (i + 1) + ".1 failed, expected " + Hex.ToHexString(tv.GetExpectedValue(0)) + " got " + Hex.ToHexString(output));
+ }
+
+ output = new byte[tv.GetExpectedValue(0).Length];
+
+ d.Generate(output, tv.GetAdditionalInput(1), tv.PredictionResistance);
+
+ expected = tv.GetExpectedValue(1);
+ if (!AreEqual(expected, output))
+ {
+ Fail("Test #" + (i + 1) + ".2 failed, expected " + Hex.ToHexString(tv.GetExpectedValue(1)) + " got " + Hex.ToHexString(output));
+ }
+ }
+
+ // Exception tests
+ //
+ try
+ {
+ d = new HashSP800Drbg(new Sha256Digest(), 256, new SHA256EntropyProvider().Get(128), null, null);
+ Fail("no exception thrown");
+ }
+ catch (ArgumentException e)
+ {
+ if (!e.Message.Equals("Not enough entropy for security strength required"))
+ {
+ Fail("Wrong exception", e);
+ }
+ }
+
+ try
+ {
+ d = new HashSP800Drbg(new Sha1Digest(), 256, new SHA256EntropyProvider().Get(256), null, null);
+ Fail("no exception thrown");
+ }
+ catch (ArgumentException e)
+ {
+ if (!e.Message.Equals("Requested security strength is not supported by the derivation function"))
+ {
+ Fail("Wrong exception", e);
+ }
+ }
+ }
+
+ internal class SHA1EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA1EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30313233343536" +
+ "808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6"), true)
+ {}
+ }
+
+ internal class SHA256EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA256EntropyProvider() : base(Hex.Decode(
+ "00010203040506" +
+ "0708090A0B0C0D0E0F101112131415161718191A1B1C1D1E" +
+ "1F202122232425262728292A2B2C2D2E2F30313233343536" +
+ "80818283848586" +
+ "8788898A8B8C8D8E8F909192939495969798999A9B9C9D9E" +
+ "9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6" +
+ "C0C1C2C3C4C5C6" +
+ "C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDE" +
+ "DFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6"), true)
+ { }
+ }
+
+ internal class SHA384EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA384EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20212223242526" +
+ "2728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F50515253545556" +
+ "5758595A5B5C5D5E5F606162636465666768696A6B6C6D6E" +
+ "808182838485868788898A8B8C8D8E" +
+ "8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6" +
+ "A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBE" +
+ "BFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6" +
+ "D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEE" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCE" +
+ "CFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6" +
+ "E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFE" +
+ "FF000102030405060708090A0B0C0D0E0F10111213141516" +
+ "1718191A1B1C1D1E1F202122232425262728292A2B2C2D2E"), true)
+ {}
+ }
+
+ internal class SHA512EntropyProvider : TestEntropySourceProvider
+ {
+ internal SHA512EntropyProvider() : base(Hex.Decode(
+ "000102030405060708090A0B0C0D0E" +
+ "0F101112131415161718191A1B1C1D1E1F20212223242526" +
+ "2728292A2B2C2D2E2F303132333435363738393A3B3C3D3E" +
+ "3F404142434445464748494A4B4C4D4E4F50515253545556" +
+ "5758595A5B5C5D5E5F606162636465666768696A6B6C6D6E" +
+ "808182838485868788898A8B8C8D8E" +
+ "8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6" +
+ "A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBE" +
+ "BFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6" +
+ "D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEE" +
+ "C0C1C2C3C4C5C6C7C8C9CACBCCCDCE" +
+ "CFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6" +
+ "E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFE" +
+ "FF000102030405060708090A0B0C0D0E0F10111213141516" +
+ "1718191A1B1C1D1E1F202122232425262728292A2B2C2D2E"), true)
+ { }
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/prng/test/TestEntropySourceProvider.cs b/crypto/test/src/crypto/prng/test/TestEntropySourceProvider.cs
new file mode 100644
index 000000000..647799630
--- /dev/null
+++ b/crypto/test/src/crypto/prng/test/TestEntropySourceProvider.cs
@@ -0,0 +1,57 @@
+using System;
+
+namespace Org.BouncyCastle.Crypto.Prng.Test
+{
+ public class TestEntropySourceProvider
+ : IEntropySourceProvider
+ {
+ private readonly byte[] data;
+ private readonly bool isPredictionResistant;
+
+ internal TestEntropySourceProvider(byte[] data, bool isPredictionResistant)
+ {
+ this.data = data;
+ this.isPredictionResistant = isPredictionResistant;
+ }
+
+ public IEntropySource Get(int bitsRequired)
+ {
+ return new EntropySource(bitsRequired, data, isPredictionResistant);
+ }
+
+ internal class EntropySource
+ : IEntropySource
+ {
+ private readonly int bitsRequired;
+ private readonly byte[] data;
+ private readonly bool isPredictionResistant;
+
+ int index = 0;
+
+ internal EntropySource(int bitsRequired, byte[] data, bool isPredictionResistant)
+ {
+ this.bitsRequired = bitsRequired;
+ this.data = data;
+ this.isPredictionResistant = isPredictionResistant;
+ }
+
+ public bool IsPredictionResistant
+ {
+ get { return isPredictionResistant; }
+ }
+
+ public byte[] GetEntropy()
+ {
+ byte[] rv = new byte[bitsRequired / 8];
+ Array.Copy(data, index, rv, 0, rv.Length);
+ index += bitsRequired / 8;
+ return rv;
+ }
+
+ public int EntropySize
+ {
+ get { return bitsRequired; }
+ }
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/prng/test/X931Test.cs b/crypto/test/src/crypto/prng/test/X931Test.cs
new file mode 100644
index 000000000..1132ea34a
--- /dev/null
+++ b/crypto/test/src/crypto/prng/test/X931Test.cs
@@ -0,0 +1,137 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities.Test;
+
+namespace Org.BouncyCastle.Crypto.Prng.Test
+{
+ /**
+ * HMAC SP800-90 DRBG
+ */
+ [TestFixture]
+ public class X931Test
+ : SimpleTest
+ {
+ public override string Name
+ {
+ get { return "X931"; }
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new X931Test());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+
+ private X931TestVector[] CreateTestVectorData()
+ {
+ return new X931TestVector[]
+ {
+ new X931TestVector(
+ new AesEngine(),
+ new Aes128EntropyProvider(),
+ "f7d36762b9915f1ed585eb8e91700eb2",
+ "259e67249288597a4d61e7c0e690afae",
+ false,
+ new string[]
+ {
+ "15f013af5a8e9df9a8e37500edaeac43",
+ "a9d74bb1c90a222adc398546d64879cf",
+ "0379e404042d58180764fb9e6c5d94bb",
+ "3c74603e036d28c79947ffb56fee4e51",
+ "e872101a4df81ebbe1e632fc87195d52",
+ "26a6b3d33b8e7e68b75d9630ec036314"
+ }),
+ new X931TestVector(
+ new DesEdeEngine(),
+ new TDesEntropyProvider(),
+ "ef16ec643e5db5892cbc6eabba310b3410e6f8759e3e382c",
+ "55df103deaf68dc4",
+ false,
+ new string[]
+ {
+ "9c960bb9662ce6de",
+ "d9d0e527fd0931da",
+ "3e2db9994e9e6995",
+ "0e3868aef8218cf7",
+ "7b0b0ca137f8fd81",
+ "f657df270ad12265"
+ })
+ };
+ }
+
+ public override void PerformTest()
+ {
+ X931TestVector[] vectors = CreateTestVectorData();
+
+ for (int i = 0; i != vectors.Length; i++)
+ {
+ X931TestVector tv = vectors[i];
+ X931SecureRandomBuilder bld = new X931SecureRandomBuilder(tv.EntropyProvider);
+
+ bld.SetDateTimeVector(Hex.Decode(tv.DateTimeVector));
+
+ SecureRandom rand = bld.Build(tv.Engine, new KeyParameter(Hex.Decode(tv.Key)), tv.IsPredictionResistant);
+
+ for (int j = 0; j != tv.Expected.Length - 1; j++)
+ {
+ byte[] expected = Hex.Decode(tv.Expected[j]);
+ byte[] res = new byte[expected.Length];
+
+ rand.NextBytes(res);
+
+ if (!Arrays.AreEqual(expected, res))
+ {
+ Fail("expected output wrong [" + j + "] got : " + Strings.FromByteArray(Hex.Encode(res)));
+ }
+ }
+
+ {
+ byte[] expected = Hex.Decode(tv.Expected[tv.Expected.Length - 1]);
+ byte[] res = new byte[expected.Length];
+
+ for (int j = tv.Expected.Length - 1; j != 10000; j++)
+ {
+ rand.NextBytes(res);
+ }
+
+ if (!Arrays.AreEqual(expected, res))
+ {
+ Fail("expected output wrong [" + 10000 + "] got : " + Strings.FromByteArray(Hex.Encode(res)));
+ }
+ }
+ }
+ }
+
+ private class Aes128EntropyProvider
+ : TestEntropySourceProvider
+ {
+ internal Aes128EntropyProvider()
+ : base(Hex.Decode("35cc0ea481fc8a4f5f05c7d4667233b2"), true)
+ {
+ }
+ }
+
+ private class TDesEntropyProvider
+ : TestEntropySourceProvider
+ {
+ internal TDesEntropyProvider()
+ : base(Hex.Decode("96d872b9122c5e74"), true)
+ {
+ }
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/prng/test/X931TestVector.cs b/crypto/test/src/crypto/prng/test/X931TestVector.cs
new file mode 100644
index 000000000..e641b0a66
--- /dev/null
+++ b/crypto/test/src/crypto/prng/test/X931TestVector.cs
@@ -0,0 +1,55 @@
+using System;
+
+namespace Org.BouncyCastle.Crypto.Prng.Test
+{
+ public class X931TestVector
+ {
+ private readonly IBlockCipher engine;
+ private readonly IEntropySourceProvider entropyProvider;
+ private readonly string key;
+ private readonly string dateTimeVector;
+ private readonly bool predictionResistant;
+ private readonly string[] expected;
+
+ public X931TestVector(IBlockCipher engine, IEntropySourceProvider entropyProvider, string key, string dateTimeVector,
+ bool predictionResistant, string[] expected)
+ {
+ this.engine = engine;
+ this.entropyProvider = entropyProvider;
+ this.key = key;
+ this.dateTimeVector = dateTimeVector;
+ this.predictionResistant = predictionResistant;
+ this.expected = expected;
+ }
+
+ public string DateTimeVector
+ {
+ get { return dateTimeVector; }
+ }
+
+ public IBlockCipher Engine
+ {
+ get { return engine; }
+ }
+
+ public IEntropySourceProvider EntropyProvider
+ {
+ get { return entropyProvider; }
+ }
+
+ public string[] Expected
+ {
+ get { return expected; }
+ }
+
+ public string Key
+ {
+ get { return key; }
+ }
+
+ public bool IsPredictionResistant
+ {
+ get { return predictionResistant; }
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/test/AllTests.cs b/crypto/test/src/crypto/test/AllTests.cs
index d5feec500..2b690930d 100644
--- a/crypto/test/src/crypto/test/AllTests.cs
+++ b/crypto/test/src/crypto/test/AllTests.cs
@@ -18,17 +18,17 @@ namespace Org.BouncyCastle.Crypto.Tests
Suite.Run(new NullListener(), NUnit.Core.TestFilter.Empty);
}
- [Suite]
- public static TestSuite Suite
- {
- get
- {
- TestSuite suite = new TestSuite("Lightweight Crypto Tests");
- suite.Add(new AllTests());
- suite.Add(new GcmReorderTest());
- return suite;
- }
- }
+ [Suite]
+ public static TestSuite Suite
+ {
+ get
+ {
+ TestSuite suite = new TestSuite("Lightweight Crypto Tests");
+ suite.Add(new AllTests());
+ suite.Add(new GcmReorderTest());
+ return suite;
+ }
+ }
#endif
[Test]
diff --git a/crypto/test/src/crypto/test/NaccacheSternTest.cs b/crypto/test/src/crypto/test/NaccacheSternTest.cs
index faa845059..4fa256f12 100644
--- a/crypto/test/src/crypto/test/NaccacheSternTest.cs
+++ b/crypto/test/src/crypto/test/NaccacheSternTest.cs
@@ -37,12 +37,6 @@ namespace Org.BouncyCastle.Crypto.Tests
static readonly NaccacheSternEngine cryptEng = new NaccacheSternEngine();
static readonly NaccacheSternEngine decryptEng = new NaccacheSternEngine();
- static NaccacheSternTest()
- {
- cryptEng.Debug = debug;
- decryptEng.Debug = debug;
- }
-
// Values from NaccacheStern paper
static readonly BigInteger a = BigInteger.ValueOf(101);
static readonly BigInteger u1 = BigInteger.ValueOf(3);
@@ -82,6 +76,22 @@ namespace Org.BouncyCastle.Crypto.Tests
//
static readonly string edgeInput = "ff6f77206973207468652074696d6520666f7220616c6c20676f6f64206d656e";
+ static NaccacheSternTest()
+ {
+ cryptEng.Debug = debug;
+ decryptEng.Debug = debug;
+
+ // First the Parameters from the NaccacheStern Paper
+ // (see http://www.gemplus.com/smart/rd/publications/pdf/NS98pkcs.pdf )
+
+ smallPrimes.Add(u1);
+ smallPrimes.Add(u2);
+ smallPrimes.Add(u3);
+ smallPrimes.Add(v1);
+ smallPrimes.Add(v2);
+ smallPrimes.Add(v3);
+ }
+
public override string Name
{
get { return "NaccacheStern"; }
@@ -91,16 +101,6 @@ namespace Org.BouncyCastle.Crypto.Tests
{
// Test with given key from NaccacheSternPaper (totally insecure)
- // First the Parameters from the NaccacheStern Paper
- // (see http://www.gemplus.com/smart/rd/publications/pdf/NS98pkcs.pdf )
-
- smallPrimes.Add(u1);
- smallPrimes.Add(u2);
- smallPrimes.Add(u3);
- smallPrimes.Add(v1);
- smallPrimes.Add(v2);
- smallPrimes.Add(v3);
-
NaccacheSternKeyParameters pubParameters = new NaccacheSternKeyParameters(false, g, n, sigma.BitLength);
NaccacheSternPrivateKeyParameters privParameters = new NaccacheSternPrivateKeyParameters(g, n, sigma
diff --git a/crypto/test/src/crypto/test/NonMemoableDigestTest.cs b/crypto/test/src/crypto/test/NonMemoableDigestTest.cs
new file mode 100644
index 000000000..e6b329e88
--- /dev/null
+++ b/crypto/test/src/crypto/test/NonMemoableDigestTest.cs
@@ -0,0 +1,119 @@
+using System;
+using System.Text;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Crypto.Macs;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities.Test;
+
+namespace Org.BouncyCastle.Crypto.Tests
+{
+ /**
+ * SHA1 HMac Test, test vectors from RFC 2202
+ */
+ public class NonMemoableDigestTest
+ : SimpleTest
+ {
+ private static readonly string[] keys = {
+ "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+ "4a656665",
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ "0102030405060708090a0b0c0d0e0f10111213141516171819",
+ "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c",
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ };
+
+ private static readonly string[] digests = {
+ "b617318655057264e28bc0b6fb378c8ef146be00",
+ "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+ "125d7342b9ac11cd91a39af48aa17b4f63f175d3",
+ "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
+ "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+ "aa4ae5e15272d00e95705637ce8a3b55ed402112",
+ "e8e99d0f45237d786d6bbaa7965c7808bbff1a91",
+ "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+ "aa4ae5e15272d00e95705637ce8a3b55ed402112",
+ "e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
+ };
+
+ private static readonly string[] messages = {
+ "Hi There",
+ "what do ya want for nothing?",
+ "0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+ "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+ "Test With Truncation",
+ "Test Using Larger Than Block-Size Key - Hash Key First",
+ "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
+ };
+
+ public override string Name
+ {
+ get { return "NonMemoableDigest"; }
+ }
+
+ public override void PerformTest()
+ {
+ HMac hmac = new HMac(new NonMemoableDigest(new Sha1Digest()));
+ byte[] resBuf = new byte[hmac.GetMacSize()];
+
+ for (int i = 0; i < messages.Length; i++)
+ {
+ byte[] m = Strings.ToByteArray(messages[i]);
+ if (messages[i].StartsWith("0x"))
+ {
+ m = Hex.Decode(messages[i].Substring(2));
+ }
+ hmac.Init(new KeyParameter(Hex.Decode(keys[i])));
+ hmac.BlockUpdate(m, 0, m.Length);
+ hmac.DoFinal(resBuf, 0);
+
+ if (!Arrays.AreEqual(resBuf, Hex.Decode(digests[i])))
+ {
+ Fail(Name + ": Vector " + i + " failed");
+ }
+ }
+
+ //
+ // test reset
+ //
+ {
+ int vector = 0; // vector used for test
+ byte[] m = Strings.ToByteArray(messages[vector]);
+ if (messages[vector].StartsWith("0x"))
+ {
+ m = Hex.Decode(messages[vector].Substring(2));
+ }
+ hmac.Init(new KeyParameter(Hex.Decode(keys[vector])));
+ hmac.BlockUpdate(m, 0, m.Length);
+ hmac.DoFinal(resBuf, 0);
+ hmac.Reset();
+ hmac.BlockUpdate(m, 0, m.Length);
+ hmac.DoFinal(resBuf, 0);
+
+ if (!Arrays.AreEqual(resBuf, Hex.Decode(digests[vector])))
+ {
+ Fail(Name + ": Reset with vector " + vector + " failed");
+ }
+ }
+ }
+
+ public static void Main(
+ string[] args)
+ {
+ RunTest(new NonMemoableDigestTest());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/test/Pkcs5Test.cs b/crypto/test/src/crypto/test/Pkcs5Test.cs
index 8066e8e41..fdf1e7a66 100644
--- a/crypto/test/src/crypto/test/Pkcs5Test.cs
+++ b/crypto/test/src/crypto/test/Pkcs5Test.cs
@@ -115,7 +115,7 @@ namespace Org.BouncyCastle.Crypto.Tests
generator.Init(PbeParametersGenerator.Pkcs5PasswordToBytes(password), salt, iterationCount);
- DerObjectIdentifier algOid = scheme.ObjectID;
+ DerObjectIdentifier algOid = scheme.Algorithm;
byte[] iv;
if (algOid.Equals(PkcsObjectIdentifiers.RC2Cbc))
diff --git a/crypto/test/src/crypto/test/RegressionTest.cs b/crypto/test/src/crypto/test/RegressionTest.cs
index ab6394571..bf38ae360 100644
--- a/crypto/test/src/crypto/test/RegressionTest.cs
+++ b/crypto/test/src/crypto/test/RegressionTest.cs
@@ -34,6 +34,7 @@ namespace Org.BouncyCastle.Crypto.Tests
new RC6Test(),
new RijndaelTest(),
new SerpentTest(),
+ new TnepresTest(),
new CamelliaTest(),
new CamelliaLightTest(),
new DigestRandomNumberTest(),
@@ -118,6 +119,7 @@ namespace Org.BouncyCastle.Crypto.Tests
new SipHashTest(),
new Poly1305Test(),
new OcbTest(),
+ new NonMemoableDigestTest(),
new SM3DigestTest(),
new X931SignerTest(),
new KeccakDigestTest(),
diff --git a/crypto/test/src/crypto/test/SerpentTest.cs b/crypto/test/src/crypto/test/SerpentTest.cs
index 2467797e9..08dbda591 100644
--- a/crypto/test/src/crypto/test/SerpentTest.cs
+++ b/crypto/test/src/crypto/test/SerpentTest.cs
@@ -4,111 +4,142 @@ using NUnit.Framework;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Engines;
-using Org.BouncyCastle.Crypto.Encodings;
+using Org.BouncyCastle.Crypto.Modes;
+using Org.BouncyCastle.Crypto.Paddings;
using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Utilities;
using Org.BouncyCastle.Utilities.Encoders;
using Org.BouncyCastle.Utilities.Test;
namespace Org.BouncyCastle.Crypto.Tests
{
+ /**
+ * Test vectors based on the NESSIE submission
+ */
[TestFixture]
- public class SerpentTest: CipherTest
+ public class SerpentTest
+ : CipherTest
{
- static SimpleTest[] tests =
+ static SimpleTest[] tests =
{
new BlockCipherVectorTest(0, new SerpentEngine(),
- new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
- "00000000000000000000000000000000", "8910494504181950f98dd998a82b6749"),
- new BlockCipherVectorTest(1, new SerpentEngine(),
new KeyParameter(Hex.Decode("00000000000000000000000000000000")),
- "80000000000000000000000000000000", "10b5ffb720b8cb9002a1142b0ba2e94a"),
+ "00000000000000000000000000000000", "3620b17ae6a993d09618b8768266bae9"),
+ new BlockCipherVectorTest(1, new SerpentEngine(),
+ new KeyParameter(Hex.Decode("80000000000000000000000000000000")),
+ "00000000000000000000000000000000", "264E5481EFF42A4606ABDA06C0BFDA3D"),
new BlockCipherVectorTest(2, new SerpentEngine(),
- new KeyParameter(Hex.Decode("00000000000000000000000000000000")),
- "00000000008000000000000000000000", "4f057a42d8d5bd9746e434680ddcd5e5"),
+ new KeyParameter(Hex.Decode("D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9")),
+ "D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9D9", "20EA07F19C8E93FDA30F6B822AD5D486"),
new BlockCipherVectorTest(3, new SerpentEngine(),
- new KeyParameter(Hex.Decode("00000000000000000000000000000000")),
- "00000000000000000000400000000000", "99407bf8582ef12550886ef5b6f169b9"),
+ new KeyParameter(Hex.Decode("000000000000000000000000000000000000000000008000")),
+ "00000000000000000000000000000000", "40520018C4AC2BBA285AEEB9BCB58755"),
new BlockCipherVectorTest(4, new SerpentEngine(),
- new KeyParameter(Hex.Decode("000000000000000000000000000000000000000000000000")),
- "40000000000000000000000000000000", "d522a3b8d6d89d4d2a124fdd88f36896"),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
+ "00000000000000000000000000000001", "AD86DE83231C3203A86AE33B721EAA9F"),
new BlockCipherVectorTest(5, new SerpentEngine(),
- new KeyParameter(Hex.Decode("000000000000000000000000000000000000000000000000")),
- "00000000000200000000000000000000", "189b8ec3470085b3da97e82ca8964e32"),
+ new KeyParameter(Hex.Decode("000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F")),
+ "3DA46FFA6F4D6F30CD258333E5A61369", "00112233445566778899AABBCCDDEEFF"),
new BlockCipherVectorTest(6, new SerpentEngine(),
- new KeyParameter(Hex.Decode("000000000000000000000000000000000000000000000000")),
- "00000000000000000000008000000000", "f77d868cf760b9143a89809510ccb099"),
+ new KeyParameter(Hex.Decode("2BD6459F82C5B300952C49104881FF482BD6459F82C5B300952C49104881FF48")),
+ "677C8DFAA08071743FD2B415D1B28AF2", "EA024714AD5C4D84EA024714AD5C4D84"),
new BlockCipherVectorTest(7, new SerpentEngine(),
- new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
- "08000000000000000000000000000000", "d43b7b981b829342fce0e3ec6f5f4c82"),
+ new KeyParameter(Hex.Decode("000102030405060708090A0B0C0D0E0F1011121314151617")),
+ "4528CACCB954D450655E8CFD71CBFAC7", "00112233445566778899AABBCCDDEEFF"),
new BlockCipherVectorTest(8, new SerpentEngine(),
- new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
- "00000000000000000100000000000000", "0bf30e1a0c33ccf6d5293177886912a7"),
+ new KeyParameter(Hex.Decode("2BD6459F82C5B300952C49104881FF482BD6459F82C5B300")),
+ "E0208BE278E21420C4B1B9747788A954", "EA024714AD5C4D84EA024714AD5C4D84"),
new BlockCipherVectorTest(9, new SerpentEngine(),
- new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
- "00000000000000000000000000000001", "6a7f3b805d2ddcba49b89770ade5e507"),
+ new KeyParameter(Hex.Decode("000102030405060708090A0B0C0D0E0F")),
+ "33B3DC87EDDD9B0F6A1F407D14919365", "00112233445566778899AABBCCDDEEFF"),
new BlockCipherVectorTest(10, new SerpentEngine(),
- new KeyParameter(Hex.Decode("80000000000000000000000000000000")),
- "00000000000000000000000000000000", "49afbfad9d5a34052cd8ffa5986bd2dd"),
- new BlockCipherVectorTest(11, new SerpentEngine(),
- new KeyParameter(Hex.Decode("000000000000000000000000004000000000000000000000")),
- "00000000000000000000000000000000", "ba8829b1de058c4b48615d851fc74f17"),
- new BlockCipherVectorTest(12, new SerpentEngine(),
- new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000100000000")),
- "00000000000000000000000000000000", "89f64377bf1e8a46c8247044e8056a98"),
-/*
- new BlockCipherMonteCarloTest(13, 10000, new SerpentEngine(),
- new KeyParameter(Hex.Decode("47f5f881daab9b67b43bd1342e339c19")),
- "7a4f7db38c52a8b711b778a38d203b6b", "003380e19f10065740394f48e2fe80b7"),
-*/
- new BlockCipherMonteCarloTest(13, 100, new SerpentEngine(),
- new KeyParameter(Hex.Decode("47f5f881daab9b67b43bd1342e339c19")),
- "7a4f7db38c52a8b711b778a38d203b6b", "4db75303d815c2f7cc6ca935d1c5a046"),
-/*
- new BlockCipherMonteCarloTest(14, 10000, new SerpentEngine(),
- new KeyParameter(Hex.Decode("31fba879ebc5e80df35e6fa33eaf92d6")),
- "70a05e12f74589009692a337f53ff614", "afb5425426906db26b70bdf842ac5400"),
-*/
- new BlockCipherMonteCarloTest(14, 100, new SerpentEngine(),
- new KeyParameter(Hex.Decode("31fba879ebc5e80df35e6fa33eaf92d6")),
- "70a05e12f74589009692a337f53ff614", "fc53a50f4d3bc9836001893d2f41742d"),
-/*
- new BlockCipherMonteCarloTest(15, 10000, new SerpentEngine(),
- new KeyParameter(Hex.Decode("bde6dd392307984695aee80e574f9977caae9aa78eda53e8")),
- "9cc523d034a93740a0aa4e2054bb34d8", "1949d506ada7de1f1344986e8ea049b2"),
-*/
- new BlockCipherMonteCarloTest(15, 100, new SerpentEngine(),
- new KeyParameter(Hex.Decode("bde6dd392307984695aee80e574f9977caae9aa78eda53e8")),
- "9cc523d034a93740a0aa4e2054bb34d8", "77117e6a9e80f40b2a36b7d755573c2d"),
-/*
- new BlockCipherMonteCarloTest(16, 10000, new SerpentEngine(),
- new KeyParameter(Hex.Decode("60f6f8ad4290699dc50921a1bbcca92da914e7d9cf01a9317c79c0af8f2487a1")),
- "ee1a61106fae2d381d686cbf854bab65", "e57f45559027cb1f2ed9603d814e1c34"),
-*/
- new BlockCipherMonteCarloTest(16, 100, new SerpentEngine(),
- new KeyParameter(Hex.Decode("60f6f8ad4290699dc50921a1bbcca92da914e7d9cf01a9317c79c0af8f2487a1")),
- "ee1a61106fae2d381d686cbf854bab65", "dcd7f13ea0dcdfd0139d1a42e2ffb84b")
+ new KeyParameter(Hex.Decode("2BD6459F82C5B300952C49104881FF48")),
+ "BEB6C069393822D3BE73FF30525EC43E", "EA024714AD5C4D84EA024714AD5C4D84"),
+ new BlockCipherMonteCarloTest(20, 100, new SerpentEngine(),
+ new KeyParameter(Hex.Decode("F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3")),
+ "F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3", "8FD0E58DB7A54B929FCA6A12F96F20AF"),
+ new BlockCipherMonteCarloTest(21, 100, new SerpentEngine(),
+ new KeyParameter(Hex.Decode("0004000000000000000000000000000000000000000000000000000000000000")),
+ "00000000000000000000000000000000", "E7B681E8871FD05FEAE5FB64DA891EA2"),
+ new BlockCipherMonteCarloTest(22, 100, new SerpentEngine(),
+ new KeyParameter(Hex.Decode("0000000020000000000000000000000000000000000000000000000000000000")),
+ "00000000000000000000000000000000", "C5545D516EEC73BFA3622A8194F95620"),
+ new BlockCipherMonteCarloTest(23, 100, new SerpentEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000002000000")),
+ "00000000000000000000000000000000", "11FF5C9BE006F82C98BD4FAC1A19920E"),
+ new BlockCipherMonteCarloTest(24, 100, new SerpentEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
+ "00000000000000000000000000010000", "47CA1CA404B6481CAD4C21C8A0415A0E"),
+ new BlockCipherMonteCarloTest(25, 100, new SerpentEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
+ "00000000000000008000000000000000", "A0A2D5B07E27D539CA5BEE9DE1EAB3E6")
};
- public SerpentTest()
- : base(tests, new SerpentEngine(), new KeyParameter(new byte[32]))
- {
- }
+ public SerpentTest()
+ : base(tests, new SerpentEngine(), new KeyParameter(new byte[32]))
+ {
+ }
- public override string Name
+ public override void PerformTest()
{
- get { return "Serpent"; }
+ base.PerformTest();
+
+ //DoCbcMonte(new byte[16], new byte[16], new byte[16], Hex.Decode("9ea101ecebaa41c712bcb0d9bab3e2e4"));
+ //DoCbcMonte(Hex.Decode("9ea101ecebaa41c712bcb0d9bab3e2e4"), Hex.Decode("9ea101ecebaa41c712bcb0d9bab3e2e4"), Hex.Decode("b4813d8a66244188b9e92c75913fa2f4"), Hex.Decode("f86b2c265b9c75869f31e2c684c13e9f"));
+
+ DoCbc(Hex.Decode("BE4295539F6BD1752FD0A80229EF8847"), Hex.Decode("00963F59224794D5AD4252094358FBC3"), Strings.ToByteArray("CBC Mode Test"), Hex.Decode("CF2CF2547E02F6D34D97246E8042ED89"));
+
+
+ DoEax(Hex.Decode("7494A57648FB420043BFBFC5639EB82D"), Hex.Decode("6DF94638B83E01458F3E30C9A1D6AF1C"), Strings.ToByteArray("EAX Mode Test"), new byte[0], 128, Hex.Decode("96C521F32DC5E9BBC369DDE4914CB13B710EEBBAB7D706D3ABE06A99DC"));
}
- public static void Main(
- string[] args)
+ private void DoEax(byte[] key, byte[] iv, byte[] pt, byte[] aad, int tagLength, byte[] expected)
{
- ITest test = new SerpentTest();
- ITestResult result = test.Perform();
+ EaxBlockCipher c = new EaxBlockCipher(new SerpentEngine());
- Console.WriteLine(result);
+ c.Init(true, new AeadParameters(new KeyParameter(key), tagLength, iv, aad));
+
+ byte[] output = new byte[expected.Length];
+
+ int len = c.ProcessBytes(pt, 0, pt.Length, output, 0);
+
+ c.DoFinal(output, len);
+
+ if (!Arrays.AreEqual(expected, output))
+ {
+ Fail("EAX test failed");
+ }
+ }
+
+ private void DoCbc(byte[] key, byte[] iv, byte[] pt, byte[] expected)
+ {
+ PaddedBufferedBlockCipher c = new PaddedBufferedBlockCipher(new CbcBlockCipher(new SerpentEngine()), new Pkcs7Padding());
+
+ byte[] ct = new byte[expected.Length];
+
+ c.Init(true, new ParametersWithIV(new KeyParameter(key), iv));
+
+ int l = c.ProcessBytes(pt, 0, pt.Length, ct, 0);
+
+ c.DoFinal(ct, l);
+
+ if (!Arrays.AreEqual(expected, ct))
+ {
+ Fail("CBC test failed");
+ }
+ }
+
+ public override string Name
+ {
+ get { return "Serpent"; }
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new SerpentTest());
}
- [Test]
+ [Test]
public void TestFunction()
{
string resultText = Perform().ToString();
diff --git a/crypto/test/src/crypto/test/TnepresTest.cs b/crypto/test/src/crypto/test/TnepresTest.cs
new file mode 100644
index 000000000..07308dbff
--- /dev/null
+++ b/crypto/test/src/crypto/test/TnepresTest.cs
@@ -0,0 +1,155 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities.Test;
+
+namespace Org.BouncyCastle.Crypto.Tests
+{
+ /**
+ * Test vectors based on Floppy 4 of the Serpent AES submission.
+ */
+ [TestFixture]
+ public class TnepresTest
+ : CipherTest
+ {
+ static SimpleTest[] tests =
+ {
+ new BlockCipherVectorTest(0, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
+ "00000000000000000000000000000000", "8910494504181950f98dd998a82b6749"),
+ new BlockCipherVectorTest(1, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("00000000000000000000000000000000")),
+ "80000000000000000000000000000000", "10b5ffb720b8cb9002a1142b0ba2e94a"),
+ new BlockCipherVectorTest(2, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("00000000000000000000000000000000")),
+ "00000000008000000000000000000000", "4f057a42d8d5bd9746e434680ddcd5e5"),
+ new BlockCipherVectorTest(3, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("00000000000000000000000000000000")),
+ "00000000000000000000400000000000", "99407bf8582ef12550886ef5b6f169b9"),
+ new BlockCipherVectorTest(4, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("000000000000000000000000000000000000000000000000")),
+ "40000000000000000000000000000000", "d522a3b8d6d89d4d2a124fdd88f36896"),
+ new BlockCipherVectorTest(5, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("000000000000000000000000000000000000000000000000")),
+ "00000000000200000000000000000000", "189b8ec3470085b3da97e82ca8964e32"),
+ new BlockCipherVectorTest(6, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("000000000000000000000000000000000000000000000000")),
+ "00000000000000000000008000000000", "f77d868cf760b9143a89809510ccb099"),
+ new BlockCipherVectorTest(7, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
+ "08000000000000000000000000000000", "d43b7b981b829342fce0e3ec6f5f4c82"),
+ new BlockCipherVectorTest(8, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
+ "00000000000000000100000000000000", "0bf30e1a0c33ccf6d5293177886912a7"),
+ new BlockCipherVectorTest(9, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000000000000")),
+ "00000000000000000000000000000001", "6a7f3b805d2ddcba49b89770ade5e507"),
+ new BlockCipherVectorTest(10, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("80000000000000000000000000000000")),
+ "00000000000000000000000000000000", "49afbfad9d5a34052cd8ffa5986bd2dd"),
+ new BlockCipherVectorTest(11, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("000000000000000000000000004000000000000000000000")),
+ "00000000000000000000000000000000", "ba8829b1de058c4b48615d851fc74f17"),
+ new BlockCipherVectorTest(12, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("0000000000000000000000000000000000000000000000000000000100000000")),
+ "00000000000000000000000000000000", "89f64377bf1e8a46c8247044e8056a98"),
+/*
+ new BlockCipherMonteCarloTest(13, 10000, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("47f5f881daab9b67b43bd1342e339c19")),
+ "7a4f7db38c52a8b711b778a38d203b6b", "003380e19f10065740394f48e2fe80b7"),
+*/
+ new BlockCipherMonteCarloTest(13, 100, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("47f5f881daab9b67b43bd1342e339c19")),
+ "7a4f7db38c52a8b711b778a38d203b6b", "4db75303d815c2f7cc6ca935d1c5a046"),
+/*
+ new BlockCipherMonteCarloTest(14, 10000, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("31fba879ebc5e80df35e6fa33eaf92d6")),
+ "70a05e12f74589009692a337f53ff614", "afb5425426906db26b70bdf842ac5400"),
+*/
+ new BlockCipherMonteCarloTest(14, 100, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("31fba879ebc5e80df35e6fa33eaf92d6")),
+ "70a05e12f74589009692a337f53ff614", "fc53a50f4d3bc9836001893d2f41742d"),
+/*
+ new BlockCipherMonteCarloTest(15, 10000, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("bde6dd392307984695aee80e574f9977caae9aa78eda53e8")),
+ "9cc523d034a93740a0aa4e2054bb34d8", "1949d506ada7de1f1344986e8ea049b2"),
+*/
+ new BlockCipherMonteCarloTest(15, 100, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("bde6dd392307984695aee80e574f9977caae9aa78eda53e8")),
+ "9cc523d034a93740a0aa4e2054bb34d8", "77117e6a9e80f40b2a36b7d755573c2d"),
+/*
+ new BlockCipherMonteCarloTest(16, 10000, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("60f6f8ad4290699dc50921a1bbcca92da914e7d9cf01a9317c79c0af8f2487a1")),
+ "ee1a61106fae2d381d686cbf854bab65", "e57f45559027cb1f2ed9603d814e1c34"),
+*/
+ new BlockCipherMonteCarloTest(16, 100, new TnepresEngine(),
+ new KeyParameter(Hex.Decode("60f6f8ad4290699dc50921a1bbcca92da914e7d9cf01a9317c79c0af8f2487a1")),
+ "ee1a61106fae2d381d686cbf854bab65", "dcd7f13ea0dcdfd0139d1a42e2ffb84b")
+ };
+
+ public TnepresTest()
+ : base(tests, new TnepresEngine(), new KeyParameter(new byte[32]))
+ {
+ }
+
+ public override void PerformTest()
+ {
+ base.PerformTest();
+
+ DoCbcMonte(new byte[16], new byte[16], new byte[16], Hex.Decode("9ea101ecebaa41c712bcb0d9bab3e2e4"));
+ DoCbcMonte(Hex.Decode("9ea101ecebaa41c712bcb0d9bab3e2e4"), Hex.Decode("9ea101ecebaa41c712bcb0d9bab3e2e4"), Hex.Decode("b4813d8a66244188b9e92c75913fa2f4"), Hex.Decode("f86b2c265b9c75869f31e2c684c13e9f"));
+ }
+
+ private void DoCbcMonte(byte[] key, byte[] iv, byte[] pt, byte[] expected)
+ {
+ IBlockCipher c = new TnepresEngine();
+
+ byte[] ct = new byte[16];
+
+ Array.Copy(iv, 0, ct, 0, 16);
+
+ for (int i = 0; i < 10000; i++)
+ {
+ for (int k = 0; k != iv.Length; k++)
+ {
+ iv[k] ^= pt[k];
+ }
+ Array.Copy(ct, 0, pt, 0, 16);
+
+ c.Init(true, new KeyParameter(key));
+
+ c.ProcessBlock(iv, 0, ct, 0);
+
+ Array.Copy(ct, 0, iv, 0, 16);
+ }
+
+ if (!Arrays.AreEqual(expected, ct))
+ {
+ Fail("CBC monte test failed");
+ }
+ }
+
+ public override string Name
+ {
+ get { return "Tnepres"; }
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new TnepresTest());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/tls/test/TlsTestClientImpl.cs b/crypto/test/src/crypto/tls/test/TlsTestClientImpl.cs
index 48af9e0f8..0cc1883ba 100644
--- a/crypto/test/src/crypto/tls/test/TlsTestClientImpl.cs
+++ b/crypto/test/src/crypto/tls/test/TlsTestClientImpl.cs
@@ -128,14 +128,14 @@ namespace Org.BouncyCastle.Crypto.Tls.Tests
Asn1EncodableVector v = new Asn1EncodableVector();
v.Add(cert.TbsCertificate);
v.Add(cert.SignatureAlgorithm);
- v.Add(CorruptBitString(cert.Signature));
+ v.Add(CorruptSignature(cert.Signature));
return X509CertificateStructure.GetInstance(new DerSequence(v));
}
- protected virtual DerBitString CorruptBitString(DerBitString bs)
+ protected virtual DerBitString CorruptSignature(DerBitString bs)
{
- return new DerBitString(CorruptBit(bs.GetBytes()));
+ return new DerBitString(CorruptBit(bs.GetOctets()));
}
protected virtual byte[] CorruptBit(byte[] bs)
diff --git a/crypto/test/src/openssl/test/AllTests.cs b/crypto/test/src/openssl/test/AllTests.cs
index 871b926b8..0cc2dcd85 100644
--- a/crypto/test/src/openssl/test/AllTests.cs
+++ b/crypto/test/src/openssl/test/AllTests.cs
@@ -1,9 +1,10 @@
-#if !LIB
using System;
using System.IO;
using System.Text;
+#if !LIB
using NUnit.Core;
+#endif
using NUnit.Framework;
using Org.BouncyCastle.Crypto;
@@ -34,6 +35,7 @@ namespace Org.BouncyCastle.OpenSsl.Tests
}
}
+#if !LIB
public static void Main(string[] args)
{
Suite.Run(new NullListener(), NUnit.Core.TestFilter.Empty);
@@ -49,6 +51,7 @@ namespace Org.BouncyCastle.OpenSsl.Tests
return suite;
}
}
+#endif
[Test]
public void TestOpenSsl()
@@ -129,4 +132,3 @@ namespace Org.BouncyCastle.OpenSsl.Tests
}
}
}
-#endif
diff --git a/crypto/test/src/openssl/test/ReaderTest.cs b/crypto/test/src/openssl/test/ReaderTest.cs
index e3990b562..c0be5c848 100644
--- a/crypto/test/src/openssl/test/ReaderTest.cs
+++ b/crypto/test/src/openssl/test/ReaderTest.cs
@@ -198,7 +198,7 @@ namespace Org.BouncyCastle.OpenSsl.Tests
doDudPasswordTest("3ee7a8", 10, "DER length more than 4 bytes: 57");
doDudPasswordTest("41af75", 11, "unknown tag 16 encountered");
doDudPasswordTest("1704a5", 12, "corrupted stream detected");
- doDudPasswordTest("1c5822", 13, "Unknown object in GetInstance: Org.BouncyCastle.Asn1.DerUtf8String");
+ doDudPasswordTest("1c5822", 13, "extra data found after object");
doDudPasswordTest("5a3d16", 14, "corrupted stream detected");
doDudPasswordTest("8d0c97", 15, "corrupted stream detected");
doDudPasswordTest("bc0daf", 16, "corrupted stream detected");
@@ -342,7 +342,7 @@ namespace Org.BouncyCastle.OpenSsl.Tests
Fail("issue not detected: " + index);
}
- catch (IOException e)
+ catch (Exception e)
{
if (e.Message.IndexOf(message) < 0)
{
diff --git a/crypto/test/src/pkcs/test/PKCS12StoreTest.cs b/crypto/test/src/pkcs/test/PKCS12StoreTest.cs
index c6b39135e..cd9dfcfad 100644
--- a/crypto/test/src/pkcs/test/PKCS12StoreTest.cs
+++ b/crypto/test/src/pkcs/test/PKCS12StoreTest.cs
@@ -837,7 +837,7 @@ namespace Org.BouncyCastle.Pkcs.Tests
EncryptedPrivateKeyInfo encInfo = EncryptedPrivateKeyInfo.GetInstance(sb.BagValue);
// check the key encryption
- if (!encInfo.EncryptionAlgorithm.ObjectID.Equals(keyAlgorithm))
+ if (!encInfo.EncryptionAlgorithm.Algorithm.Equals(keyAlgorithm))
{
Fail("key encryption algorithm wrong");
}
@@ -845,7 +845,7 @@ namespace Org.BouncyCastle.Pkcs.Tests
// check the certificate encryption
EncryptedData cb = EncryptedData.GetInstance(c2.Content);
- if (!cb.EncryptionAlgorithm.ObjectID.Equals(certAlgorithm))
+ if (!cb.EncryptionAlgorithm.Algorithm.Equals(certAlgorithm))
{
Fail("cert encryption algorithm wrong");
}
diff --git a/crypto/test/src/security/test/SecureRandomTest.cs b/crypto/test/src/security/test/SecureRandomTest.cs
index f93afc0aa..f1d83b29c 100644
--- a/crypto/test/src/security/test/SecureRandomTest.cs
+++ b/crypto/test/src/security/test/SecureRandomTest.cs
@@ -3,7 +3,12 @@ using System.Text;
using NUnit.Framework;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Macs;
using Org.BouncyCastle.Crypto.Prng;
+using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Security.Tests
@@ -61,6 +66,30 @@ namespace Org.BouncyCastle.Security.Tests
}
[Test]
+ public void TestSP800Ctr()
+ {
+ SecureRandom random = new SP800SecureRandomBuilder().BuildCtr(new AesFastEngine(), 256, new byte[32], false);
+
+ CheckSecureRandom(random);
+ }
+
+ [Test]
+ public void TestSP800Hash()
+ {
+ SecureRandom random = new SP800SecureRandomBuilder().BuildHash(new Sha256Digest(), new byte[32], false);
+
+ CheckSecureRandom(random);
+ }
+
+ [Test]
+ public void TestSP800HMac()
+ {
+ SecureRandom random = new SP800SecureRandomBuilder().BuildHMac(new HMac(new Sha256Digest()), new byte[32], false);
+
+ CheckSecureRandom(random);
+ }
+
+ [Test]
public void TestThreadedSeed()
{
SecureRandom random = SecureRandom.GetInstance("SHA1PRNG", false);
@@ -73,7 +102,15 @@ namespace Org.BouncyCastle.Security.Tests
public void TestVmpcPrng()
{
SecureRandom random = new SecureRandom(new VmpcRandomGenerator());
- random.SetSeed(SecureRandom.GetSeed(32));
+ random.SetSeed(random.GenerateSeed(32));
+
+ CheckSecureRandom(random);
+ }
+
+ [Test]
+ public void TestX931()
+ {
+ SecureRandom random = new X931SecureRandomBuilder().Build(new AesFastEngine(), new KeyParameter(new byte[16]), false);
CheckSecureRandom(random);
}
@@ -106,7 +143,7 @@ namespace Org.BouncyCastle.Security.Tests
private static double MeasureChiSquared(SecureRandom random, int rounds)
{
- byte[] opts = SecureRandom.GetSeed(2);
+ byte[] opts = random.GenerateSeed(2);
int[] counts = new int[256];
byte[] bs = new byte[256];
diff --git a/crypto/test/src/security/test/TestMacUtil.cs b/crypto/test/src/security/test/TestMacUtil.cs
new file mode 100644
index 000000000..1eb6f35b0
--- /dev/null
+++ b/crypto/test/src/security/test/TestMacUtil.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Globalization;
+using System.Threading;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto;
+
+namespace Org.BouncyCastle.Security.Tests
+{
+ [TestFixture]
+ public class TestMacUtilities
+ {
+ [Test]
+ public void TestCultureIndependence()
+ {
+ Thread t = Thread.CurrentThread;
+ CultureInfo ci = t.CurrentCulture;
+ try
+ {
+ /*
+ * In Hungarian, the "CS" in "HMACSHA256" is linguistically a single character, so "HMAC" is not a prefix.
+ */
+ t.CurrentCulture = new CultureInfo("hu-HU");
+ IMac mac = MacUtilities.GetMac("HMACSHA256");
+ Assert.NotNull(mac);
+ }
+ catch (Exception e)
+ {
+ Assert.Fail("Culture-specific lookup failed: " + e.Message);
+ }
+ finally
+ {
+ t.CurrentCulture = ci;
+ }
+ }
+ }
+}
diff --git a/crypto/test/src/test/BlockCipherTest.cs b/crypto/test/src/test/BlockCipherTest.cs
index 93cf2b0a5..e6f92b84e 100644
--- a/crypto/test/src/test/BlockCipherTest.cs
+++ b/crypto/test/src/test/BlockCipherTest.cs
@@ -114,6 +114,8 @@ namespace Org.BouncyCastle.Tests
"Rijndael/CBC/PKCS7Padding",
"cf87f4d8bb9d1abb36cdd9f44ead7d046db2f802d99e1ef0a5940f306079e08389a44c4a8cc1a47cbaee1128da55bbb7",
"Serpent/CBC/PKCS7Padding",
+ "d8b971931de211cb2d31721773a5b1f9dc4e263efe0465f97c024daa26dd7d03473e9beb82ba809cf36071d4807e4706",
+ "Tnepres/CBC/PKCS7Padding",
"f8940ca31aba8ce1e0693b1ae0b1e08daef6de03c80f019774280052f824ac44540bb8dd74dfad47f83f9c7ec268ca68",
"CAST5/CBC/PKCS7Padding",
"87b6dc0c5a1d23d42fa740b0548be0b298112000544610d889d6361994cf8e670a19d6af72d7289f",
@@ -138,6 +140,8 @@ namespace Org.BouncyCastle.Tests
"Rijndael/CTS/NoPadding",
"6db2f802d99e1ef0a5940f306079e083cf87f4d8bb9d1abb36cdd9f44ead7d04",
"Serpent/CTS/NoPadding",
+ "dc4e263efe0465f97c024daa26dd7d03d8b971931de211cb2d31721773a5b1f9",
+ "Tnepres/CTS/NoPadding",
"aef6de03c80f019774280052f824ac44f8940ca31aba8ce1e0693b1ae0b1e08d",
"CAST5/CTS/NoPadding",
"87b6dc0c5a1d23d42fa740b0548be0b289d6361994cf8e6798112000544610d8",
@@ -166,6 +170,8 @@ namespace Org.BouncyCastle.Tests
"Rijndael/CBC/WithCTS",
"6db2f802d99e1ef0a5940f306079e083cf87f4d8bb9d1abb36cdd9f44ead7d04",
"Serpent/CBC/WithCTS",
+ "dc4e263efe0465f97c024daa26dd7d03d8b971931de211cb2d31721773a5b1f9",
+ "Tnepres/CBC/WithCTS",
"aef6de03c80f019774280052f824ac44f8940ca31aba8ce1e0693b1ae0b1e08d",
"CAST5/CBC/WithCTS",
"87b6dc0c5a1d23d42fa740b0548be0b289d6361994cf8e6798112000544610d8",
@@ -251,7 +257,111 @@ namespace Org.BouncyCastle.Tests
"Twofish/ECB/TBCPadding",
"70336d9c9718a8a2ced1b19deed973a3c58af7ea71a69e7efc4df082dca581c019d7daa58d02b89aab6e8c0d17202439",
"RC2/ECB/TBCPadding",
- "eb5b889bbcced12eb6b1a3da6a3d965bba66a5edfdd4c8a6b6b1a3da6a3d965b6b5359ba5e69b179"
+ "eb5b889bbcced12eb6b1a3da6a3d965bba66a5edfdd4c8a6b6b1a3da6a3d965b6b5359ba5e69b179",
+ "DES/CTR/NoPadding",
+ "537572e480c1714fb47081d35eb18eaca9e0a5aee982f105438a0db6cece1f6d",
+ "DESede/CTR/NoPadding",
+ "481e9872acea7fcfa93b7d4e34ec7bab340c10faba2e43b879d40d38e07c422d",
+ "SKIPJACK/CTR/NoPadding",
+ "71143a124e3a0cdeee98a7b843baa05bd1d59faee8ec9b89880e070314a04cc2",
+ "Blowfish/CTR/NoPadding",
+ "6cd6f7c5d2c65555d2b31f8614f54ec654f5e7888d515008d59302c3edfcc6cb",
+ "Twofish/CTR/NoPadding",
+ "821c54b1b54ae113cf74595eefe10c83d09e95d4599190b9bbd5bc71dd703730",
+ "Threefish-256/CTR/NoPadding",
+ "546ea995dd302f1efcb1f27d14bad468280a3a7994c2af75dfdf1e9fc5ef2373",
+ "Threefish-512/CTR/NoPadding",
+ "152df966484ecc2e9ddfc386559732f7f632e4008920804a1bde4efcf2e6e2f2",
+ "Threefish-1024/CTR/NoPadding",
+ "03953ac751a7377812c6e3e4d14b36c6953f9b390acaa892811c10001c9be454",
+ "RC2/CTR/NoPadding",
+ "0a07cb78537cb04c8c5a0a39a15977a7eb19f3c48a42759c234868c391a99c63",
+ "RC5/CTR/NoPadding",
+ "c62b233df296283b97f17364d5f69a1ff91f46659cf9856caefd322a936203a7",
+ "IDEA/CTR/NoPadding",
+ "dd447da3cbdcf81f4694ab7715d79e3f90af5682e8c318b8f7dadbed6b5c9714",
+ "Blowfish/EAX/NoPadding",
+ "bee85ae6512b8a2346d46f7bac31526238091ccc5de75760c9a39628fb45d44a653bfac0",
+ "CAST5/EAX/NoPadding",
+ "85e0dbd3402f2179f96d231315ec73f04f64f1b7ab1347423b9aec51a07a7222e2bc65a3",
+ "DES/EAX/NoPadding",
+ "07d12249945e77607086f7463f316966466e6a0c0789b3307b8b51a7cc807e3c1fb91f98",
+ "DESede/EAX/NoPadding",
+ "278b28f13537dc13bb688c95391754bd6d39c79a7361b407f8dee0b111b264f20391cb0e",
+ "GOST28147/EAX/NoPadding",
+ "1416713d52affb595b880be996e838edd377e67dfe822fbb0ff235f1b706e6ce34d68dc5",
+ "IDEA/EAX/NoPadding",
+ "b2e9f3e40954c140ac60423466dee0138f84e879fbde003780202bd83c91571b64df7bb7",
+ "RC2/EAX/NoPadding",
+ "5d1c095de75bd5eef6a5146f7d6c44545807a8b452f7a38e2719a14f1a269709d2eda2d3",
+ "SEED/EAX/NoPadding",
+ "6780f18b2dd1f75a934b5a3e45e8fd44877fd3498a9b919b417b3d8a7c67c6021d74bbaef71841ef",
+ "Serpent/EAX/NoPadding",
+ "13c2b1fec2bda74f5ccc8ca31b36a2e91ee024a215387219808640b2fc7a6a41e017aacee3ed893a",
+ "Tnepres/EAX/NoPadding",
+ "8d5ac312ca0d436a0154d56568d39811ccf6bb970012398014fc8a49ed669b117443c0249b07ead8",
+ //"SM4/EAX/NoPadding",
+ //"e072a95da8e529b41199859482142b3fdfa6b7af27348e5ebf35445a099583dae882affde90ea4a4",
+ "Twofish/EAX/NoPadding",
+ "9a90dffe1233a04733fc8869e8ec4cba2fa53d9543f0206825293b1ff102e63f81a60b12204e1fd8",
+ "IDEA/OFB/NoPadding",
+ "dd447da3cbdcf81f4053fb446596261cb00a3c49a66085485af5f7c10ba20dad",
+ "RC2/OFB/NoPadding",
+ "0a07cb78537cb04c0c74e28a7b86b80f80acadf87d6ef32792f1a8cf74b39f74",
+ "SEED/OFB/NoPadding",
+ "9fd249435dc66d3d5d41abad270df5e3c6b972692fadfcb6c311b047f96fb114",
+ "SEED/OCB/NoPadding",
+ "eb04b3612769e1ad681f975af1a6f401d94dc88276dd50fc3ebce791c28825c652b7351acbad8c63d4d66191de94c970",
+ "SEED/CCM/NoPadding",
+ "8bb16b37e7f1d4eb97bb1fa3b9bfd411aca64a3581bb3c5b2a91346983aa334984d73ad629a847f7",
+ "SEED/GCM/NoPadding",
+ "ed5f6293c9a4f280af6695750bfb3bb3b60c214565a049494df955152757812ebfb93705895606c4378498a93f2541b5",
+ //"SM4/GCM/NoPadding",
+ //"323b601a951da693f87e53c6832380719b4d4bd306c94248202b7e337c81e2d9de0044b77a4c556f15f6fd19f828236b",
+ "DES/ECB/TBCPadding",
+ "466da00648ef0e1f9617b1f002e225251a3248d09172f46b9617b1f002e22525698575eb3998481b",
+ "GOST28147/ECB/TBCPadding",
+ "0a77f4114451b37d44c5192619b723dd49093d1047c2373544c5192619b723dde7b0810d205c07ab",
+ "IDEA/ECB/TBCPadding",
+ "8c9fd56823ffdc523f6ccf7f614aa6173553e594fc7a21b53f6ccf7f614aa61747a7c95a57b9eaf4",
+ "RC2/ECB/TBCPadding",
+ "eb5b889bbcced12eb6b1a3da6a3d965bba66a5edfdd4c8a6b6b1a3da6a3d965b6b5359ba5e69b179",
+ "SEED/ECB/TBCPadding",
+ "d53d4ce1f48b9879420949467bfcbfbe2c6a7d4a8770bee0c71211def898d7c509f6e111845db39b4cce1dd155aa592b",
+ "DES/CBC/TBCPadding",
+ "60fa2f8fae5aa2a38e9ac77d0246726beb7511e4515feb12cf99f75cc6e0122ad3b3f002c927f1fd",
+ "GOST28147/CBC/TBCPadding",
+ "ba87be9c465cbb30e1bf0148daa9639c2e4cbc1b6777cfcda860760686596159aa564fd65e66c125",
+ "IDEA/CBC/TBCPadding",
+ "30cd990ebdae80fe12b6c6e4fcd1c064a27d985c276b3d7097351c8684e4c4d922f14e12faecaa0b",
+ "RC2/CBC/TBCPadding",
+ "a51facdb3933c9676795cd38cc3146fd4694722b468b1a979a399c77606abf9997b47d2f64a37e2f",
+ "SEED/CBC/TBCPadding",
+ "fc34f03ddf4d2a4d9934addc82011af1d5f76ee015b691a6524d7ad5464422d7989825d19e23a60ba759407e13d1ea02",
+ "DES/CFB8/NoPadding",
+ "53cb0cdff712a825eb283b23c31e7323aa12495e7e751428b5c4eb89b28a25d4",
+ "GOST28147/CFB8/NoPadding",
+ "29f6ca1ca7ae9670413183932a28cdd4a09f2ba630c3c3fbf6f071d3774d7577",
+ "IDEA/CFB8/NoPadding",
+ "dd7839d2525420d10f95eec23dbaf3463302c445972a28c563c2635191bc19af",
+ "RC2/CFB8/NoPadding",
+ "0aa227f94be3a32ff927c5d25647ea41d7c2a1e94012fc7f2ad6767b9664bce5",
+ "SEED/CFB8/NoPadding",
+ "9f1622c3785a034ee4c595df05fb11e69e4d52036e238d2d451e190e87ee876e",
+ "DES/CTS/NoPadding",
+ "60fa2f8fae5aa2a38e9ac77d0246726bcf99f75cc6e0122aeb7511e4515feb12",
+ "GOST28147/CTS/NoPadding",
+ "ba87be9c465cbb30e1bf0148daa9639ca8607606865961592e4cbc1b6777cfcd",
+ "IDEA/CTS/NoPadding",
+ "30cd990ebdae80fe12b6c6e4fcd1c06497351c8684e4c4d9a27d985c276b3d70",
+ "RC2/CTS/NoPadding",
+ "a51facdb3933c9676795cd38cc3146fd9a399c77606abf994694722b468b1a97",
+ "SEED/CTS/NoPadding",
+ "d5f76ee015b691a6524d7ad5464422d7fc34f03ddf4d2a4d9934addc82011af1",
+ //"SHACAL-2/CBC/PKCS7Padding",
+ //"3af7c54ea55d2497162ac9c79d9b2f7837898f83aa4b50b7b762979aa8087669b6a81cdec475ed4d2394d7ad771404a52eb52d245a39f0d7d3e8062d3b0f0e54",
+ //"SHACAL-2/CBC/TBCPadding",
+ //"3af7c54ea55d2497162ac9c79d9b2f7837898f83aa4b50b7b762979aa80876693f17fbe9a5baa88ed21b2e1a863dc449061f40cafadfc3cf73486208f87b9352",
};
private static readonly string[] cipherTests2 =
@@ -329,8 +439,12 @@ namespace Org.BouncyCastle.Tests
if (!validModes.Contains(baseMode))
throw new Exception("Unhandled mode: " + mode);
+ if (baseMode == "CCM")
+ return 13;
if (baseMode == "ECB")
return 0;
+ if (baseMode == "OCB")
+ return 15;
string baseAlgorithm = parts[0];
IBufferedCipher baseCipher = CipherUtilities.GetCipher(baseAlgorithm);
@@ -410,7 +524,7 @@ namespace Org.BouncyCastle.Tests
else
{
// NB: rand always generates same values each test run
- iv = rand.GenerateSeed(ivLength);
+ iv = SecureRandom.GetNextBytes(rand, ivLength);
}
parameters = new ParametersWithIV(key, iv);
@@ -437,11 +551,16 @@ namespace Org.BouncyCastle.Tests
if (iv != null)
{
// TODO Examine short IV handling for these FIPS-compliant modes in Java build
- if (mode.StartsWith("CFB")
+ if (mode.StartsWith("CCM")
+ || mode.StartsWith("CFB")
|| mode.StartsWith("CTR")
+ || mode.StartsWith("EAX")
+ || mode.StartsWith("GCM")
|| mode.StartsWith("GOFB")
+ || mode.StartsWith("OCB")
|| mode.StartsWith("OFB")
- || mode.StartsWith("OPENPGPCFB"))
+ || mode.StartsWith("OPENPGPCFB")
+ || mode.StartsWith("SIC"))
{
// These modes automatically pad out the IV if it is short
}
diff --git a/crypto/test/src/test/CertTest.cs b/crypto/test/src/test/CertTest.cs
index 9bb4df7d1..72e17e458 100644
--- a/crypto/test/src/test/CertTest.cs
+++ b/crypto/test/src/test/CertTest.cs
@@ -2452,7 +2452,7 @@ namespace Org.BouncyCastle.Tests
DerSequence seq = new DerSequence(
tbsCertificate,
- new AlgorithmIdentifier(sig.ObjectID),
+ new AlgorithmIdentifier(sig.Algorithm),
certStruct.Signature);
try
diff --git a/crypto/test/src/test/PKCS10CertRequestTest.cs b/crypto/test/src/test/PKCS10CertRequestTest.cs
index 819439cd8..9bad0a678 100644
--- a/crypto/test/src/test/PKCS10CertRequestTest.cs
+++ b/crypto/test/src/test/PKCS10CertRequestTest.cs
@@ -193,7 +193,7 @@ namespace Org.BouncyCastle.Tests
Fail("Failed Verify check EC uncompressed encoded.");
}
- if (!req.SignatureAlgorithm.ObjectID.Equals(algOid))
+ if (!req.SignatureAlgorithm.Algorithm.Equals(algOid))
{
Fail("ECDSA oid incorrect.");
}
@@ -210,7 +210,7 @@ namespace Org.BouncyCastle.Tests
byte[] b = req.GetCertificationRequestInfo().GetEncoded();
sig.BlockUpdate(b, 0, b.Length);
- if (!sig.VerifySignature(req.Signature.GetBytes()))
+ if (!sig.VerifySignature(req.GetSignatureOctets()))
{
Fail("signature not mapped correctly.");
}
@@ -247,7 +247,7 @@ namespace Org.BouncyCastle.Tests
Fail("Failed Verify check EC encoded.");
}
- if (!req.SignatureAlgorithm.ObjectID.Equals(CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x2001))
+ if (!req.SignatureAlgorithm.Algorithm.Equals(CryptoProObjectIdentifiers.GostR3411x94WithGostR3410x2001))
{
Fail("ECGOST oid incorrect.");
}
@@ -264,7 +264,7 @@ namespace Org.BouncyCastle.Tests
byte[] b = req.GetCertificationRequestInfo().GetEncoded();
sig.BlockUpdate(b, 0, b.Length);
- if (!sig.VerifySignature(req.Signature.GetBytes()))
+ if (!sig.VerifySignature(req.GetSignatureOctets()))
{
Fail("signature not mapped correctly.");
}
@@ -308,7 +308,7 @@ namespace Org.BouncyCastle.Tests
Fail("Failed verify check PSS encoded.");
}
- if (!req.SignatureAlgorithm.ObjectID.Equals(PkcsObjectIdentifiers.IdRsassaPss))
+ if (!req.SignatureAlgorithm.Algorithm.Equals(PkcsObjectIdentifiers.IdRsassaPss))
{
Fail("PSS oid incorrect.");
}
@@ -325,7 +325,7 @@ namespace Org.BouncyCastle.Tests
byte[] encoded = req.GetCertificationRequestInfo().GetEncoded();
sig.BlockUpdate(encoded, 0, encoded.Length);
- if (!sig.VerifySignature(req.Signature.GetBytes()))
+ if (!sig.VerifySignature(req.GetSignatureOctets()))
{
Fail("signature not mapped correctly.");
}
diff --git a/crypto/test/src/util/io/pem/test/AllTests.cs b/crypto/test/src/util/io/pem/test/AllTests.cs
index 5f0c12c10..921c40cb8 100644
--- a/crypto/test/src/util/io/pem/test/AllTests.cs
+++ b/crypto/test/src/util/io/pem/test/AllTests.cs
@@ -1,11 +1,12 @@
-#if !LIB
using System;
using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Text;
+#if !LIB
using NUnit.Core;
+#endif
using NUnit.Framework;
using Org.BouncyCastle.Crypto;
@@ -20,6 +21,7 @@ namespace Org.BouncyCastle.Utilities.IO.Pem.Tests
[TestFixture]
public class AllTests
{
+#if !LIB
public static void Main(string[] args)
{
Suite.Run(new NullListener(), NUnit.Core.TestFilter.Empty);
@@ -35,6 +37,7 @@ namespace Org.BouncyCastle.Utilities.IO.Pem.Tests
return suite;
}
}
+#endif
[Test]
public void TestPemLength()
@@ -73,4 +76,3 @@ namespace Org.BouncyCastle.Utilities.IO.Pem.Tests
}
}
}
-#endif
diff --git a/crypto/test/src/util/test/FixedSecureRandom.cs b/crypto/test/src/util/test/FixedSecureRandom.cs
index 15a2e9bb3..d8598ac24 100644
--- a/crypto/test/src/util/test/FixedSecureRandom.cs
+++ b/crypto/test/src/util/test/FixedSecureRandom.cs
@@ -38,7 +38,12 @@ namespace Org.BouncyCastle.Utilities.Test
return new FixedSecureRandom(bOut.ToArray());
}
- public override void NextBytes(
+ public override byte[] GenerateSeed(int numBytes)
+ {
+ return SecureRandom.GetNextBytes(this, numBytes);
+ }
+
+ public override void NextBytes(
byte[] buf)
{
Array.Copy(_data, _index, buf, 0, buf.Length);
diff --git a/crypto/test/src/util/test/SimpleTest.cs b/crypto/test/src/util/test/SimpleTest.cs
index faeee65c9..bf6c8fb92 100644
--- a/crypto/test/src/util/test/SimpleTest.cs
+++ b/crypto/test/src/util/test/SimpleTest.cs
@@ -115,7 +115,9 @@ namespace Org.BouncyCastle.Utilities.Test
private static string GetFullName(
string name)
{
-#if PORTABLE
+#if SEPARATE_UNIT_TESTS
+ return "UnitTests.data." + name;
+#elif PORTABLE
return "crypto.tests." + name;
#else
return "crypto.test.data." + name;
@@ -125,7 +127,9 @@ namespace Org.BouncyCastle.Utilities.Test
private static string GetShortName(
string fullName)
{
-#if PORTABLE
+#if SEPARATE_UNIT_TESTS
+ return fullName.Substring("UnitTests.data.".Length);
+#elif PORTABLE
return fullName.Substring("crypto.tests.".Length);
#else
return fullName.Substring("crypto.test.data.".Length);
|
