protected void VerifyHmac(
int testCaseId,
string digest,
int truncateSize = -1)
{
byte[] digestBytes = ByteUtils.HexToByteArray(digest);
byte[] computedDigest;
using (HMAC hmac = Create())
{
Assert.True(hmac.HashSize > 0);
byte[] key = (byte[])_testKeys[testCaseId].Clone();
hmac.Key = key;
// make sure the getter returns different objects each time
Assert.NotSame(key, hmac.Key);
Assert.NotSame(hmac.Key, hmac.Key);
// make sure the setter didn't cache the exact object we passed in
key[0] = (byte)(key[0] + 1);
Assert.NotEqual <byte>(key, hmac.Key);
computedDigest = hmac.ComputeHash(_testData[testCaseId]);
}
if (truncateSize != -1)
{
byte[] tmp = new byte[truncateSize];
Array.Copy(computedDigest, tmp, truncateSize);
computedDigest = tmp;
}
Assert.Equal(digestBytes, computedDigest);
}
private void Verify_Span(byte[] input, string output)
{
byte[] expected = ByteUtils.HexToByteArray(output);
byte[] actual;
int bytesWritten;
using (HashAlgorithm hash = Create())
{
// Too small
actual = new byte[expected.Length - 1];
Assert.False(hash.TryComputeHash(input, actual, out bytesWritten));
Assert.Equal(0, bytesWritten);
// Just right
actual = new byte[expected.Length];
Assert.True(hash.TryComputeHash(input, actual, out bytesWritten));
Assert.Equal(expected.Length, bytesWritten);
Assert.Equal(expected, actual);
// Bigger than needed
actual = new byte[expected.Length + 1];
actual[actual.Length - 1] = 42;
Assert.True(hash.TryComputeHash(input, actual, out bytesWritten));
Assert.Equal(expected.Length, bytesWritten);
Assert.Equal(expected, actual.AsSpan(0, expected.Length).ToArray());
Assert.Equal(42, actual[actual.Length - 1]);
}
}
protected void VerifyMultiBlock(string block1, string block2, string expectedHash, string emptyHash)
{
byte[] block1_bytes = ByteUtils.AsciiBytes(block1);
byte[] block2_bytes = ByteUtils.AsciiBytes(block2);
byte[] expected_bytes = ByteUtils.HexToByteArray(expectedHash);
byte[] emptyHash_bytes = ByteUtils.HexToByteArray(emptyHash);
VerifyTransformBlockOutput(block1_bytes, block2_bytes);
VerifyTransformBlockHash(block1_bytes, block2_bytes, expected_bytes, emptyHash_bytes);
VerifyTransformBlockComputeHashInteraction(block1_bytes, block2_bytes, expected_bytes, emptyHash_bytes);
}
protected void VerifyHmac_KeyAlreadySet(
HMAC hmac,
int testCaseId,
string digest)
{
byte[] digestBytes = ByteUtils.HexToByteArray(digest);
byte[] computedDigest;
computedDigest = hmac.ComputeHash(_testData[testCaseId]);
Assert.Equal(digestBytes, computedDigest);
}
private void VerifyComputeHashStream(Stream input, string output)
{
byte[] expected = ByteUtils.HexToByteArray(output);
byte[] actual;
using (HashAlgorithm hash = Create())
{
Assert.True(hash.HashSize > 0);
actual = hash.ComputeHash(input);
}
Assert.Equal(expected, actual);
}
protected void Verify(byte[] input, string output)
{
byte[] expected = ByteUtils.HexToByteArray(output);
byte[] actual;
using (HashAlgorithm hash = Create())
{
Assert.True(hash.HashSize > 0);
actual = hash.ComputeHash(input, 0, input.Length);
}
Assert.Equal(expected, actual);
}
private void VerifyICryptoTransformStream(Stream input, string output)
{
byte[] expected = ByteUtils.HexToByteArray(output);
byte[] actual;
using (HashAlgorithm hash = Create())
using (CryptoStream cryptoStream = new CryptoStream(input, hash, CryptoStreamMode.Read))
{
byte[] buffer = new byte[1024]; // A different default than HashAlgorithm which uses 4K
int bytesRead;
while ((bytesRead = cryptoStream.Read(buffer, 0, buffer.Length)) > 0)
{
// CryptoStream will build up the hash
}
actual = hash.Hash;
}
Assert.Equal(expected, actual);
}