// [TestCase("ffffffff48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001", "fc59093aafa9ab43daae0e914c57635c5402d8e3d2130eb9b3cc181de7f0ecf9b22bf99a7815ce16419e200e01846e6b5df8cc7703041bbceb571de6631d2615")]
public void compression_function_should_return_valid_output(string input, string output)
{
var blake2 = new Blake2();
var result = blake2.Compress(Bytes.FromHexString(input)).ToHexString();
result.Should().BeEquivalentTo(output);
}
public static void Test(string msg, string hash)
{
var a = new Blake2();
var expected = hash.DecodeHex();
var actual = a.Hash(msg.DecodeHex(), expected.Length);
Assert.Equal(expected, actual);
}
public static void HashWithWrongKey()
{
var a = new Blake2();
using (var k = new Key(new Ed25519()))
{
Assert.Throws <ArgumentException>("key", () => a.Hash(k, ReadOnlySpan <byte> .Empty));
}
}
public static void HashWithMaxSpanSuccess()
{
var a = new Blake2();
using (var k = new Key(a))
{
a.Hash(k, ReadOnlySpan <byte> .Empty, new byte[a.MaxHashSize]);
}
}
public static void HashWithSpanTooLarge()
{
var a = new Blake2();
using (var k = new Key(a))
{
Assert.Throws <ArgumentException>("hash", () => a.Hash(k, ReadOnlySpan <byte> .Empty, new byte[a.MaxHashSize + 1]));
}
}
public static void HashWithSizeTooSmall()
{
var a = new Blake2();
using (var k = new Key(a))
{
Assert.Throws <ArgumentOutOfRangeException>("hashSize", () => a.Hash(k, ReadOnlySpan <byte> .Empty, a.MinHashSize - 1));
}
}
private static TheoryData <int> GetKeySizes()
{
var data = new TheoryData <int>();
var a = new Blake2();
data.Add(a.DefaultKeySize);
data.Add(a.MinKeySize);
data.Add(a.MaxKeySize);
return(data);
}
public static void HashWithKeySuccess()
{
var a = new Blake2();
using (var k = new Key(a))
{
var b = a.Hash(k, ReadOnlySpan <byte> .Empty);
Assert.NotNull(b);
Assert.Equal(a.DefaultHashSize, b.Length);
}
}
public static void ExportImportSymmetric(int keySize)
{
var a = new Blake2();
using (var k = Key.Import(a, Utilities.RandomBytes.Slice(0, keySize), KeyBlobFormat.RawSymmetricKey, KeyFlags.AllowExport))
{
Assert.Equal(KeyFlags.AllowExport, k.Flags);
var b = k.Export(KeyBlobFormat.RawSymmetricKey);
Assert.NotNull(b);
Assert.Equal(b.Length, keySize);
}
}
public static void Test(string msg, string key, string hash)
{
var a = new Blake2();
using (var k = Key.Import(a, key.DecodeHex(), KeyBlobFormat.RawSymmetricKey))
{
var m = msg.DecodeHex();
var expected = hash.DecodeHex();
var actual = a.Hash(k, m, expected.Length);
Assert.Equal(expected, actual);
}
}
public static void CreateKey()
{
var a = new Blake2();
using (var k = new Key(a, KeyFlags.AllowArchiving))
{
var actual = k.Export(KeyBlobFormat.RawSymmetricKey);
var expected = new byte[actual.Length];
Utilities.Fill(expected, 0xD0);
Assert.NotEqual(expected, actual);
}
}
public static void Properties()
{
var a = new Blake2();
Assert.True(a.MinKeySize >= 0);
Assert.True(a.DefaultKeySize >= a.MinKeySize);
Assert.True(a.MaxKeySize >= a.DefaultKeySize);
Assert.True(a.MaxKeySize <= 64);
Assert.True(a.MinHashSize >= 1);
Assert.True(a.DefaultHashSize >= a.MinHashSize);
Assert.True(a.MaxHashSize >= a.DefaultHashSize);
Assert.True(a.MaxHashSize <= 64);
}
public (byte[], bool) Run(byte[] inputData)
{
if (inputData.Length != RequiredInputLength)
{
return(Bytes.Empty, false);
}
var finalByte = inputData[212];
if (finalByte != 0 && finalByte != 1)
{
return(Bytes.Empty, false);
}
var blake = new Blake2();
var result = blake.Compress(inputData);
return(result, true);
}
public static void HashWithNullKey()
{
var a = new Blake2();
Assert.Throws <ArgumentNullException>("key", () => a.Hash(null, ReadOnlySpan <byte> .Empty));
}