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 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 byte[] Hash(byte[] input)
{
Blake2bDigest digest = new Blake2bDigest(256);
digest.BlockUpdate(input, 0, input.Length);
byte[] hash = new byte[digest.GetDigestSize()];
digest.DoFinal(hash, 0);
return(hash);
}
private string ExecuteHash()
{
IDigest hash;
switch (this.HashFunctionComboBox.Text)
{
case "Blake2b - 256 bit":
hash = new Blake2bDigest(256);
break;
case "Blake2b - 512 bit":
hash = new Blake2bDigest(512);
break;
case "SHA-1":
hash = new Sha1Digest();
break;
case "SHA-2 256 bit":
hash = new Sha256Digest();
break;
case "SHA-2 512 bit":
hash = new Sha512Digest();
break;
case "SHA-3 256 bit":
hash = new Sha3Digest(256);
break;
case "SHA-3 512 bit":
hash = new Sha3Digest(512);
break;
default:
hash = new Sha1Digest();
break;
}
byte[] result = new byte[hash.GetDigestSize()];
using (Stream source = File.OpenRead(this.LocationTextBox.Text))
{
int BytesRead;
while ((BytesRead = source.Read(this._Data, 0, this._Data.Length)) > 0)
{
hash.BlockUpdate(this._Data, 0, BytesRead);
}
}
hash.DoFinal(result, 0);
Array.Clear(this._Data, 0, this._Data.Length);
return(Entities.HashFunctionList.ByteArrayToHexString(result));
}
public static byte[] GetDigest(byte[] msg, int size)
{
var result = new byte[size / 8];
var digest = new Blake2bDigest(size);
digest.BlockUpdate(msg, 0, msg.Length);
digest.DoFinal(result, 0);
return(result);
}
public static byte[] Blake2b(byte[] data)
{
Blake2bDigest black2b = new Blake2bDigest(32 * 8);
black2b.BlockUpdate(data, 0, data.Length);
var hashed = new byte[black2b.GetDigestSize()];
black2b.DoFinal(hashed, 0);
return(hashed);
}
public static byte[] HashBlake2B(byte[] data)
{
Blake2bDigest h = new Blake2bDigest(null, 32, null, null);
h.BlockUpdate(data, 0, data.Length);
var hash = new byte[32];
h.DoFinal(hash, 0);
return(hash);
}
public uint256 GetHash()
{
var blake2b = new Blake2bDigest(null, 32, null, _personalization);
var hash = new byte[blake2b.GetDigestSize()];
blake2b.BlockUpdate(((MemoryStream)Inner).ToArrayEfficient(), 0, (int)Inner.Length);
blake2b.DoFinal(hash, 0);
return(new uint256(hash));
}
public override byte[] ComputeHash(byte[] input, int offset, int count)
{
var blake2b = new Blake2bDigest(DigestSize);
var result = new byte[blake2b.GetDigestSize()];
blake2b.BlockUpdate(input, offset, count);
blake2b.DoFinal(result, 0);
return(result);
}
public static byte[] Hash(byte[] bytes, int bitLength)
{
var digest = new Blake2bDigest(bitLength);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(output, 0);
return(output);
}
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();
}
protected static byte[] ComputeHash(byte[] message, int bits)
{
var digest = new Blake2bDigest(bits);
var output = new byte[digest.GetDigestSize()];
byte[] msg = message ?? new byte[0];
digest.BlockUpdate(msg, 0, msg.Length);
digest.DoFinal(output, 0);
return(output);
}
public static byte[] Compute(byte[] input, int offset, int count, int digestSize)
{
var blake2b = new Blake2bDigest(digestSize);
var result = new byte[blake2b.GetDigestSize()];
blake2b.BlockUpdate(input, offset, count);
blake2b.DoFinal(result, 0);
return(result);
}
public override void PerformTest()
{
// test keyed test vectors:
Blake2bDigest blake2bkeyed = new Blake2bDigest(Hex.Decode(keyedTestVectors[0, 1]));
for (int tv = 0; tv < keyedTestVectors.GetLength(0); 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.GetLength(0); i++)
{
// 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();
DoTestNullKeyVsUnkeyed();
DoTestLengthConstruction();
}
public static byte[] BLAKE2B(byte[] bytes)
{
if (!Blake2BHashers.TryPop(out var hasher))
{
hasher = new Blake2bDigest();
}
try {
var result = new byte[hasher.GetDigestSize()];
hasher.BlockUpdate(bytes, 0, bytes.Length);
hasher.DoFinal(result, 0);
hasher.Reset();
return(result);
} finally {
Blake2BHashers.Push(hasher);
}
}
public static string Hash(string hash_function, byte[] data)
{
IDigest hash;
switch (hash_function)
{
case "Blake2b - 256 bit":
hash = new Blake2bDigest(256);
break;
case "Blake2b - 512 bit":
hash = new Blake2bDigest(512);
break;
case "SHA-1":
hash = new Sha1Digest();
break;
case "SHA-2 256 bit":
hash = new Sha256Digest();
break;
case "SHA-2 512 bit":
hash = new Sha512Digest();
break;
case "SHA-3 256 bit":
hash = new Sha3Digest(256);
break;
case "SHA-3 512 bit":
hash = new Sha3Digest(512);
break;
default:
hash = new Sha1Digest();
break;
}
byte[] result = new byte[hash.GetDigestSize()];
hash.BlockUpdate(data, 0, data.Length);
hash.DoFinal(result, 0);
Array.Clear(data, 0, data.Length);
return(ByteArrayToHexString(result));
}
public static byte[] Blake2b(byte[] message)
{
/**
* Thor public blockchain is using 256 bits digest
*/
var blake2b = new Blake2bDigest(256);
blake2b.BlockUpdate(message, 0, message.Length);
var digest = new byte[32];
int size = blake2b.DoFinal(digest, 0);
if (size > 0)
{
return(digest);
}
else
{
return(null);
}
}
private void DoTestNullKeyVsUnkeyed()
{
byte[] abc = Strings.ToByteArray("abc");
for (int i = 1; i != 64; i++)
{
Blake2bDigest dig1 = new Blake2bDigest(i * 8);
Blake2bDigest dig2 = new Blake2bDigest(null, i, null, null);
byte[] out1 = new byte[i];
byte[] out2 = new byte[i];
dig1.BlockUpdate(abc, 0, abc.Length);
dig2.BlockUpdate(abc, 0, abc.Length);
dig1.DoFinal(out1, 0);
dig2.DoFinal(out2, 0);
IsTrue(Arrays.AreEqual(out1, out2));
}
}
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");
}
}
public Blake2bCryptoServiceProvider(BlakeConfig config)
{
if (config is null || config.Key is null)
{
_digest = new Blake2bDigest();
}
