diff --git a/crypto/test/UnitTests.csproj b/crypto/test/UnitTests.csproj
index 67d3e1b91..be8b7d3c5 100644
--- a/crypto/test/UnitTests.csproj
+++ b/crypto/test/UnitTests.csproj
@@ -156,6 +156,8 @@
<Compile Include="src\crypto\test\AESWrapTest.cs" />
<Compile Include="src\crypto\test\AllTests.cs" />
<Compile Include="src\crypto\test\BCryptTest.cs" />
+ <Compile Include="src\crypto\test\Blake2bDigestTest.cs" />
+ <Compile Include="src\crypto\test\Blake2sDigestTest.cs" />
<Compile Include="src\crypto\test\BlockCipherMonteCarloTest.cs" />
<Compile Include="src\crypto\test\BlockCipherVectorTest.cs" />
<Compile Include="src\crypto\test\BlowfishTest.cs" />
diff --git a/crypto/test/src/crypto/test/Blake2bDigestTest.cs b/crypto/test/src/crypto/test/Blake2bDigestTest.cs
new file mode 100644
index 000000000..0d0853977
--- /dev/null
+++ b/crypto/test/src/crypto/test/Blake2bDigestTest.cs
@@ -0,0 +1,251 @@
+using System;
+using System.Text;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities.Test;
+
+namespace Org.BouncyCastle.Crypto.Tests
+{
+ [TestFixture]
+ public class Blake2bDigestTest
+ : SimpleTest
+ {
+ private static readonly string[][] keyedTestVectors =
+ { // input/message, key, hash
+
+ // Vectors from BLAKE2 web site: https://blake2.net/blake2b-test.txt
+ new string[]{
+ "",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+ "10ebb67700b1868efb4417987acf4690ae9d972fb7a590c2f02871799aaa4786b5e996e8f0f4eb981fc214b005f42d2ff4233499391653df7aefcbc13fc51568" },
+
+ new string[]{
+ "00",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+ "961f6dd1e4dd30f63901690c512e78e4b45e4742ed197c3c5e45c549fd25f2e4187b0bc9fe30492b16b0d0bc4ef9b0f34c7003fac09a5ef1532e69430234cebd" },
+
+ new string[]{
+ "0001",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+ "da2cfbe2d8409a0f38026113884f84b50156371ae304c4430173d08a99d9fb1b983164a3770706d537f49e0c916d9f32b95cc37a95b99d857436f0232c88a965" },
+
+ new string[]{
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+ "f1aa2b044f8f0c638a3f362e677b5d891d6fd2ab0765f6ee1e4987de057ead357883d9b405b9d609eea1b869d97fb16d9b51017c553f3b93c0a1e0f1296fedcd" },
+
+ new string[]{
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+ "c230f0802679cb33822ef8b3b21bf7a9a28942092901d7dac3760300831026cf354c9232df3e084d9903130c601f63c1f4a4a4b8106e468cd443bbe5a734f45f" },
+
+ new string[]{
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+ "142709d62e28fcccd0af97fad0f8465b971e82201dc51070faa0372aa43e92484be1c1e73ba10906d5d1853db6a4106e0a7bf9800d373d6dee2d46d62ef2a461" }
+ };
+
+ private static readonly string[][] unkeyedTestVectors =
+ { // from: http://fossies.org/linux/john/src/rawBLAKE2_512_fmt_plug.c
+ // hash, input/message
+ // digests without leading $BLAKE2$
+ new string[]{
+ "4245af08b46fbb290222ab8a68613621d92ce78577152d712467742417ebc1153668f1c9e1ec1e152a32a9c242dc686d175e087906377f0c483c5be2cb68953e",
+ "blake2" },
+ new string[]{
+ "021ced8799296ceca557832ab941a50b4a11f83478cf141f51f933f653ab9fbcc05a037cddbed06e309bf334942c4e58cdf1a46e237911ccd7fcf9787cbc7fd0",
+ "hello world" },
+ new string[]{
+ "1f7d9b7c9a90f7bfc66e52b69f3b6c3befbd6aee11aac860e99347a495526f30c9e51f6b0db01c24825092a09dd1a15740f0ade8def87e60c15da487571bcef7",
+ "verystrongandlongpassword" },
+ new string[]{
+ "a8add4bdddfd93e4877d2746e62817b116364a1fa7bc148d95090bc7333b3673f82401cf7aa2e4cb1ecd90296e3f14cb5413f8ed77be73045b13914cdcd6a918",
+ "The quick brown fox jumps over the lazy dog" },
+ new string[]{
+ "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce",
+ "" },
+ new string[]{
+ "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923",
+ "abc" },
+ };
+
+ public override string Name
+ {
+ get { return "BLAKE2b"; }
+ }
+
+ private void offsetTest(
+ IDigest digest,
+ byte[] input,
+ byte[] expected)
+ {
+ byte[] resBuf = new byte[expected.Length + 11];
+
+ digest.BlockUpdate(input, 0, input.Length);
+
+ digest.DoFinal(resBuf, 11);
+
+ if (!AreEqual(Arrays.CopyOfRange(resBuf, 11, resBuf.Length), expected))
+ {
+ Fail("Offset failed got " + Hex.ToHexString(resBuf));
+ }
+ }
+
+ public override void PerformTest()
+ {
+ // test keyed test vectors:
+
+ Blake2bDigest blake2bkeyed = new Blake2bDigest(Hex.Decode(keyedTestVectors[0][1]));
+ for (int tv = 0; tv < keyedTestVectors.Length; tv++)
+ {
+
+ byte[] input = Hex.Decode(keyedTestVectors[tv][0]);
+ blake2bkeyed.Reset();
+
+ blake2bkeyed.BlockUpdate(input, 0, input.Length);
+ byte[] keyedHash = new byte[64];
+ blake2bkeyed.DoFinal(keyedHash, 0);
+
+ if (!Arrays.AreEqual(Hex.Decode(keyedTestVectors[tv][2]), keyedHash))
+ {
+ Fail("BLAKE2b mismatch on test vector ",
+ keyedTestVectors[tv][2],
+ Hex.ToHexString(keyedHash));
+ }
+
+ offsetTest(blake2bkeyed, input, keyedHash);
+ }
+
+ Blake2bDigest blake2bunkeyed = new Blake2bDigest();
+ // test unkeyed test vectors:
+ for (int i = 0; i < unkeyedTestVectors.Length; i++)
+ {
+ // blake2bunkeyed.update(
+ // unkeyedTestVectors[i][1].getBytes("UTF-8"));
+ // test update(byte b)
+ byte[] unkeyedInput = Encoding.UTF8.GetBytes(unkeyedTestVectors[i][1]);
+ for (int j = 0; j < unkeyedInput.Length; j++)
+ {
+ blake2bunkeyed.Update(unkeyedInput[j]);
+ }
+
+ byte[] unkeyedHash = new byte[64];
+ blake2bunkeyed.DoFinal(unkeyedHash, 0);
+ blake2bunkeyed.Reset();
+
+ if (!Arrays.AreEqual(Hex.Decode(unkeyedTestVectors[i][0]),
+ unkeyedHash))
+ {
+ Fail("BLAKE2b mismatch on test vector ",
+ unkeyedTestVectors[i][0],
+ Hex.ToHexString(unkeyedHash));
+ }
+ }
+
+ cloneTest();
+ resetTest();
+ }
+
+ private void cloneTest()
+ {
+ Blake2bDigest blake2bCloneSource = new Blake2bDigest(Hex.Decode(keyedTestVectors[3][1]), 16, Hex.Decode("000102030405060708090a0b0c0d0e0f"), Hex.Decode("101112131415161718191a1b1c1d1e1f"));
+ byte[] expected = Hex.Decode("b6d48ed5771b17414c4e08bd8d8a3bc4");
+
+ checkClone(blake2bCloneSource, expected);
+
+ // just digest size
+ blake2bCloneSource = new Blake2bDigest(160);
+ expected = Hex.Decode("64202454e538279b21cea0f5a7688be656f8f484");
+ checkClone(blake2bCloneSource, expected);
+
+ // null salt and personalisation
+ blake2bCloneSource = new Blake2bDigest(Hex.Decode(keyedTestVectors[3][1]), 16, null, null);
+ expected = Hex.Decode("2b4a081fae2d7b488f5eed7e83e42a20");
+ checkClone(blake2bCloneSource, expected);
+
+ // null personalisation
+ blake2bCloneSource = new Blake2bDigest(Hex.Decode(keyedTestVectors[3][1]), 16, Hex.Decode("000102030405060708090a0b0c0d0e0f"), null);
+ expected = Hex.Decode("00c3a2a02fcb9f389857626e19d706f6");
+ checkClone(blake2bCloneSource, expected);
+
+ // null salt
+ blake2bCloneSource = new Blake2bDigest(Hex.Decode(keyedTestVectors[3][1]), 16, null, Hex.Decode("101112131415161718191a1b1c1d1e1f"));
+ expected = Hex.Decode("f445ec9c062a3c724f8fdef824417abb");
+ checkClone(blake2bCloneSource, expected);
+ }
+
+ private void checkClone(Blake2bDigest blake2bCloneSource, byte[] expected)
+ {
+ byte[] message = Hex.Decode(keyedTestVectors[3][0]);
+
+ blake2bCloneSource.BlockUpdate(message, 0, message.Length);
+
+ byte[] hash = new byte[blake2bCloneSource.GetDigestSize()];
+
+ Blake2bDigest digClone = new Blake2bDigest(blake2bCloneSource);
+
+ blake2bCloneSource.DoFinal(hash, 0);
+ if (!AreEqual(expected, hash))
+ {
+ Fail("clone source not correct");
+ }
+
+ digClone.DoFinal(hash, 0);
+ if (!AreEqual(expected, hash))
+ {
+ Fail("clone not correct");
+ }
+ }
+
+ private void resetTest()
+ {
+ // Generate a non-zero key
+ byte[] key = new byte[32];
+ for (byte i = 0; i < key.Length; i++)
+ {
+ key[i] = i;
+ }
+ // Generate some non-zero input longer than the key
+ byte[] input = new byte[key.Length + 1];
+ for (byte i = 0; i < input.Length; i++)
+ {
+ input[i] = i;
+ }
+ // Hash the input
+ Blake2bDigest digest = new Blake2bDigest(key);
+ digest.BlockUpdate(input, 0, input.Length);
+ byte[] hash = new byte[digest.GetDigestSize()];
+ digest.DoFinal(hash, 0);
+ // Using a second instance, hash the input without calling doFinal()
+ Blake2bDigest digest1 = new Blake2bDigest(key);
+ digest1.BlockUpdate(input, 0, input.Length);
+ // Reset the second instance and hash the input again
+ digest1.Reset();
+ digest1.BlockUpdate(input, 0, input.Length);
+ byte[] hash1 = new byte[digest.GetDigestSize()];
+ digest1.DoFinal(hash1, 0);
+ // The hashes should be identical
+ if (!Arrays.AreEqual(hash, hash1))
+ {
+ Fail("state was not reset");
+ }
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new Blake2bDigestTest());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/test/Blake2sDigestTest.cs b/crypto/test/src/crypto/test/Blake2sDigestTest.cs
new file mode 100644
index 000000000..2365071dd
--- /dev/null
+++ b/crypto/test/src/crypto/test/Blake2sDigestTest.cs
@@ -0,0 +1,243 @@
+using System;
+using System.Text;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities.Test;
+
+namespace Org.BouncyCastle.Crypto.Tests
+{
+ [TestFixture]
+ public class Blake2sDigestTest
+ : SimpleTest
+ {
+ // Vectors from BLAKE2 web site: https://blake2.net/blake2s-test.txt
+ private static readonly string[][] keyedTestVectors = {
+ // input/message, key, hash
+ new string[]{
+ "",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+ "48a8997da407876b3d79c0d92325ad3b89cbb754d86ab71aee047ad345fd2c49",
+ },
+ new string[]{
+ "00",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+ "40d15fee7c328830166ac3f918650f807e7e01e177258cdc0a39b11f598066f1",
+ },
+ new string[]{
+ "0001",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+ "6bb71300644cd3991b26ccd4d274acd1adeab8b1d7914546c1198bbe9fc9d803",
+ },
+ new string[]{
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+ "172ffc67153d12e0ca76a8b6cd5d4731885b39ce0cac93a8972a18006c8b8baf",
+ },
+ new string[]{
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+ "4f8ce1e51d2fe7f24043a904d898ebfc91975418753413aa099b795ecb35cedb",
+ },
+ new string[]{
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe",
+ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+ "3fb735061abc519dfe979e54c1ee5bfad0a9d858b3315bad34bde999efd724dd",
+ },
+ };
+
+ public override string Name
+ {
+ get { return "BLAKE2s"; }
+ }
+
+ public void DoTestDigestWithKeyedTestVectors()
+ {
+ Blake2sDigest digest = new Blake2sDigest(Hex.Decode(
+ keyedTestVectors[0][1]));
+ for (int i = 0; i != keyedTestVectors.Length; i++)
+ {
+ String[] keyedTestVector = keyedTestVectors[i];
+ byte[] input = Hex.Decode(keyedTestVector[0]);
+ digest.Reset();
+
+ digest.BlockUpdate(input, 0, input.Length);
+ byte[] hash = new byte[32];
+ digest.DoFinal(hash, 0);
+
+ if (!AreEqual(Hex.Decode(keyedTestVector[2]), hash))
+ {
+ Fail("BLAKE2s mismatch on test vector ",
+ keyedTestVector[2],
+ Hex.ToHexString(hash));
+ }
+ }
+ }
+
+ public void DoTestDigestWithKeyedTestVectorsAndRandomUpdate()
+ {
+ Blake2sDigest digest = new Blake2sDigest(Hex.Decode(
+ keyedTestVectors[0][1]));
+ Random random = new Random();
+ for (int i = 0; i < 100; i++)
+ {
+ for (int j = 0; j != keyedTestVectors.Length; j++)
+ {
+ String[] keyedTestVector = keyedTestVectors[j];
+ byte[] input = Hex.Decode(keyedTestVector[0]);
+ if (input.Length < 3)
+ {
+ continue;
+ }
+ digest.Reset();
+
+ int pos = (random.Next() & 0xffff) % input.Length;
+ if (pos > 0)
+ {
+ digest.BlockUpdate(input, 0, pos);
+ }
+ digest.Update(input[pos]);
+ if (pos < (input.Length - 1))
+ {
+ digest.BlockUpdate(input, pos + 1, input.Length - (pos + 1));
+ }
+
+ byte[] hash = new byte[32];
+ digest.DoFinal(hash, 0);
+
+ if (!AreEqual(Hex.Decode(keyedTestVector[2]), hash))
+ {
+ Fail("BLAKE2s mismatch on test vector ",
+ keyedTestVector[2],
+ Hex.ToHexString(hash));
+ }
+ }
+ }
+ }
+
+ public void DoTestReset()
+ {
+ // Generate a non-zero key
+ byte[] key = new byte[32];
+ for (byte i = 0; i < key.Length; i++)
+ {
+ key[i] = i;
+ }
+ // Generate some non-zero input longer than the key
+ byte[] input = new byte[key.Length + 1];
+ for (byte i = 0; i < input.Length; i++)
+ {
+ input[i] = i;
+ }
+ // Hash the input
+ Blake2sDigest digest = new Blake2sDigest(key);
+ digest.BlockUpdate(input, 0, input.Length);
+ byte[] hash = new byte[digest.GetDigestSize()];
+ digest.DoFinal(hash, 0);
+ // Create a second instance, hash the input without calling doFinal()
+ Blake2sDigest digest1 = new Blake2sDigest(key);
+ digest1.BlockUpdate(input, 0, input.Length);
+ // Reset the second instance and hash the input again
+ digest1.Reset();
+ digest1.BlockUpdate(input, 0, input.Length);
+ byte[] hash1 = new byte[digest.GetDigestSize()];
+ digest1.DoFinal(hash1, 0);
+ // The hashes should be identical
+ if (!AreEqual(hash, hash1))
+ {
+ Fail("BLAKE2s mismatch on test vector ",
+ Hex.ToHexString(hash),
+ Hex.ToHexString(hash1));
+ }
+ }
+
+ // Self-test routine from https://tools.ietf.org/html/rfc7693#appendix-E
+ private static readonly string SELF_TEST_RESULT =
+ "6A411F08CE25ADCDFB02ABA641451CEC53C598B24F4FC787FBDC88797F4C1DFE";
+ private static readonly int[] SELF_TEST_DIGEST_LEN = {16, 20, 28, 32};
+ private static readonly int[] SELF_TEST_INPUT_LEN = {0, 3, 64, 65, 255, 1024};
+
+ private static byte[] selfTestSequence(int len, int seed)
+ {
+ int a = (int)(0xDEAD4BAD * seed);
+ int b = 1;
+ int t;
+ byte[] output = new byte[len];
+
+ for (int i = 0; i < len; i++)
+ {
+ t = a + b;
+ a = b;
+ b = t;
+ output[i] = (byte)(t >> 24);
+ }
+
+ return output;
+ }
+
+ public void RunSelfTest()
+ {
+ Blake2sDigest testDigest = new Blake2sDigest();
+ byte[] md = new byte[32];
+
+ for (int i = 0; i < 4; i++)
+ {
+ int outlen = SELF_TEST_DIGEST_LEN[i];
+ for (int j = 0; j < 6; j++)
+ {
+ int inlen = SELF_TEST_INPUT_LEN[j];
+
+ // unkeyed hash
+ byte[] input = selfTestSequence(inlen, inlen);
+ Blake2sDigest unkeyedDigest = new Blake2sDigest(outlen * 8);
+ unkeyedDigest.BlockUpdate(input, 0, inlen);
+ unkeyedDigest.DoFinal(md, 0);
+ // hash the hash
+ testDigest.BlockUpdate(md, 0, outlen);
+
+ // keyed hash
+ byte[] key = selfTestSequence(outlen, outlen);
+ Blake2sDigest keyedDigest = new Blake2sDigest(key, outlen, null,
+ null);
+ keyedDigest.BlockUpdate(input, 0, inlen);
+ keyedDigest.DoFinal(md, 0);
+ // hash the hash
+ testDigest.BlockUpdate(md, 0, outlen);
+ }
+ }
+
+ byte[] hash = new byte[32];
+ testDigest.DoFinal(hash, 0);
+ if (!AreEqual(Hex.Decode(SELF_TEST_RESULT), hash))
+ {
+ Fail("BLAKE2s mismatch on test vector ",
+ SELF_TEST_RESULT,
+ Hex.ToHexString(hash));
+ }
+ }
+
+ public override void PerformTest()
+ {
+ DoTestDigestWithKeyedTestVectors();
+ DoTestDigestWithKeyedTestVectorsAndRandomUpdate();
+ DoTestReset();
+ RunSelfTest();
+ }
+
+ public static void Main(string[] args)
+ {
+ RunTest(new Blake2sDigestTest());
+ }
+
+ [Test]
+ public void TestFunction()
+ {
+ string resultText = Perform().ToString();
+
+ Assert.AreEqual(Name + ": Okay", resultText);
+ }
+ }
+}
diff --git a/crypto/test/src/crypto/test/RegressionTest.cs b/crypto/test/src/crypto/test/RegressionTest.cs
index c065a1320..13fe23ecc 100644
--- a/crypto/test/src/crypto/test/RegressionTest.cs
+++ b/crypto/test/src/crypto/test/RegressionTest.cs
@@ -126,6 +126,8 @@ namespace Org.BouncyCastle.Crypto.Tests
new BCryptTest(),
new OpenBsdBCryptTest(),
new X931SignerTest(),
+ new Blake2bDigestTest(),
+ new Blake2sDigestTest(),
new KeccakDigestTest(),
new ShakeDigestTest(),
new SM2EngineTest(),
diff --git a/crypto/test/src/test/DigestTest.cs b/crypto/test/src/test/DigestTest.cs
index 5d840ee66..9f68a8361 100644
--- a/crypto/test/src/test/DigestTest.cs
+++ b/crypto/test/src/test/DigestTest.cs
@@ -3,6 +3,9 @@ using System.Text;
using NUnit.Framework;
+using Org.BouncyCastle.Asn1.Misc;
+using Org.BouncyCastle.Asn1.Rosstandart;
+using Org.BouncyCastle.Asn1.UA;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Utilities.Encoders;
@@ -32,7 +35,43 @@ namespace Org.BouncyCastle.Tests
{ "RIPEMD320", "de4c01b3054f8930a79d09ae738e92301e5a17085beffdc1b8d116713e74f82fa942d64cdbc4682d" },
{ "Tiger", "2AAB1484E8C158F2BFB8C5FF41B57A525129131C957B5F93" },
{ "GOST3411", "b285056dbf18d7392d7677369524dd14747459ed8143997e163b2986f92fd42c" },
- { "WHIRLPOOL", "4E2448A4C6F486BB16B6562C73B4020BF3043E3A731BCE721AE1B303D97E6D4C7181EEBDB6C57E277D0E34957114CBD6C797FC9D95D8B582D225292076D4EEF5" }
+ { "WHIRLPOOL", "4E2448A4C6F486BB16B6562C73B4020BF3043E3A731BCE721AE1B303D97E6D4C7181EEBDB6C57E277D0E34957114CBD6C797FC9D95D8B582D225292076D4EEF5" },
+ { "SM3", "66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0" },
+ { "SHA3-224", "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf" },
+ { "SHA3-256", "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532" },
+ { "SHA3-384", "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25" },
+ { "SHA3-512", "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0" },
+ { "KECCAK-224", "c30411768506ebe1c2871b1ee2e87d38df342317300a9b97a95ec6a8" },
+ { "KECCAK-256", "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45" },
+ { "KECCAK-288", "20ff13d217d5789fa7fc9e0e9a2ee627363ec28171d0b6c52bbd2f240554dbc94289f4d6" },
+ { "KECCAK-384", "f7df1165f033337be098e7d288ad6a2f74409d7a60b49c36642218de161b1f99f8c681e4afaf31a34db29fb763e3c28e" },
+ { "KECCAK-512", "18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96" },
+ { "BLAKE2B-160", "384264f676f39536840523f284921cdc68b6846b" },
+ { "BLAKE2B-256", "bddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319" },
+ { "BLAKE2B-384", "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4" },
+ { "BLAKE2B-512", "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923" },
+ { MiscObjectIdentifiers.id_blake2b160.Id, "384264f676f39536840523f284921cdc68b6846b" },
+ { MiscObjectIdentifiers.id_blake2b256.Id, "bddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319" },
+ { MiscObjectIdentifiers.id_blake2b384.Id, "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4" },
+ { MiscObjectIdentifiers.id_blake2b512.Id, "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923" },
+ { "BLAKE2S-128", "aa4938119b1dc7b87cbad0ffd200d0ae" },
+ { "BLAKE2S-160", "5ae3b99be29b01834c3b508521ede60438f8de17" },
+ { "BLAKE2S-224", "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55" },
+ { "BLAKE2S-256", "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982" },
+ { MiscObjectIdentifiers.id_blake2s128.Id, "aa4938119b1dc7b87cbad0ffd200d0ae" },
+ { MiscObjectIdentifiers.id_blake2s160.Id, "5ae3b99be29b01834c3b508521ede60438f8de17" },
+ { MiscObjectIdentifiers.id_blake2s224.Id, "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55" },
+ { MiscObjectIdentifiers.id_blake2s256.Id, "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982" },
+ { "GOST3411-2012-256", "4e2919cf137ed41ec4fb6270c61826cc4fffb660341e0af3688cd0626d23b481" },
+ { RosstandartObjectIdentifiers.id_tc26_gost_3411_12_256.Id, "4e2919cf137ed41ec4fb6270c61826cc4fffb660341e0af3688cd0626d23b481" },
+ { "GOST3411-2012-512", "28156e28317da7c98f4fe2bed6b542d0dab85bb224445fcedaf75d46e26d7eb8d5997f3e0915dd6b7f0aab08d9c8beb0d8c64bae2ab8b3c8c6bc53b3bf0db728" },
+ { RosstandartObjectIdentifiers.id_tc26_gost_3411_12_512.Id, "28156e28317da7c98f4fe2bed6b542d0dab85bb224445fcedaf75d46e26d7eb8d5997f3e0915dd6b7f0aab08d9c8beb0d8c64bae2ab8b3c8c6bc53b3bf0db728" },
+ { "DSTU7564-256", "0bd1b36109f1318411a0517315aa46b8839df06622a278676f5487996c9cfc04" },
+ { UAObjectIdentifiers.dstu7564digest_256.Id, "0bd1b36109f1318411a0517315aa46b8839df06622a278676f5487996c9cfc04" },
+ { "DSTU7564-384", "72945012b0820c3132846ddc90da511f80bb7b70abd0cb1ab8df785d600c187b9d0ac567e8b6f76fde8a0b417a2ebf88" },
+ { UAObjectIdentifiers.dstu7564digest_384.Id, "72945012b0820c3132846ddc90da511f80bb7b70abd0cb1ab8df785d600c187b9d0ac567e8b6f76fde8a0b417a2ebf88" },
+ { "DSTU7564-512", "9e5be7daf7b68b49d2ecbd04c7a5b3af72945012b0820c3132846ddc90da511f80bb7b70abd0cb1ab8df785d600c187b9d0ac567e8b6f76fde8a0b417a2ebf88" },
+ { UAObjectIdentifiers.dstu7564digest_512.Id, "9e5be7daf7b68b49d2ecbd04c7a5b3af72945012b0820c3132846ddc90da511f80bb7b70abd0cb1ab8df785d600c187b9d0ac567e8b6f76fde8a0b417a2ebf88" },
};
public override string Name
|
