public void ComputeHash_ExceptionsTest()
{
byte[] goodBa = { 1, 2, 3 };
Sha256 sha = new Sha256();
Assert.Throws <ArgumentNullException>(() => sha.ComputeHash(null));
sha.Dispose();
Assert.Throws <ObjectDisposedException>(() => sha.ComputeHash(goodBa));
}
public void ComputeHash_ReuseTest()
{
byte[] msg1 = Encoding.UTF8.GetBytes("The quick brown fox jumps over the lazy dog");
byte[] msg2 = Encoding.UTF8.GetBytes("The quick brown fox jumps over the lazy cog");
byte[] exp1 = Helper.HexToBytes("d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592");
byte[] exp2 = Helper.HexToBytes("e4c4d8f3bf76b692de791a173e05321150f7a345b46484fe427f6acc7ecc81be");
using Sha256 sha = new Sha256();
byte[] act1 = sha.ComputeHash(msg1);
byte[] act2 = sha.ComputeHash(msg2);
Assert.Equal(exp1, act1);
Assert.Equal(exp2, act2);
}
public void Test_QueueStream()
{
using (FileStream stream1 = new FileStream("QueueStream1.tmp", FileMode.Create))
using (QueueStream queueStream = new QueueStream(stream1, StreamMode.Write, 1024 * 1024 * 4, _bufferManager))
using (FileStream stream2 = new FileStream("QueueStream2.tmp", FileMode.Create))
{
byte[] buffer = new byte[1024];
for (int i = 0; i < 1024 * 32; i++)
{
_random.NextBytes(buffer);
queueStream.Write(buffer, 0, buffer.Length);
stream2.Write(buffer, 0, buffer.Length);
}
}
using (FileStream stream1 = new FileStream("QueueStream1.tmp", FileMode.Open))
using (FileStream stream2 = new FileStream("QueueStream2.tmp", FileMode.Open))
{
Assert.IsTrue(CollectionUtilities.Equals(Sha256.ComputeHash(stream1), Sha256.ComputeHash(stream2)), "QueueStream #1");
}
using (FileStream stream1 = new FileStream("QueueStream1.tmp", FileMode.Open))
using (QueueStream queueStream = new QueueStream(stream1, StreamMode.Read, 1024 * 1024 * 4, _bufferManager))
using (FileStream stream2 = new FileStream("QueueStream2.tmp", FileMode.Open))
{
Assert.IsTrue(CollectionUtilities.Equals(Sha256.ComputeHash(queueStream), Sha256.ComputeHash(stream2)), "QueueStream #2");
}
}
public void ComputeHashTwiceTest(byte[] message, byte[] expectedHash)
{
using Sha256 sha = new Sha256();
byte[] actualHash = sha.ComputeHashTwice(message);
expectedHash = sha.ComputeHash(expectedHash);
Assert.Equal(expectedHash, actualHash);
}
public void ComputeHash_NistMonteCarloTest()
{
byte[] seed = Helper.HexToBytes("6d1e72ad03ddeb5de891e572e2396f8da015d899ef0e79503152d6010a3fe691");
JObject jObjs = Helper.ReadResources <JObject>("Sha256NistTestData");
int size = 32;
byte[] toHash = new byte[3 * size];
byte[] M0 = seed;
byte[] M1 = seed;
byte[] M2 = seed;
Sha256 sha = new Sha256(false);
foreach (var item in jObjs["MonteCarlo"])
{
byte[] expected = Helper.HexToBytes(item.ToString());
for (int i = 0; i < 1000; i++)
{
Buffer.BlockCopy(M0, 0, toHash, 0, size);
Buffer.BlockCopy(M1, 0, toHash, size, size);
Buffer.BlockCopy(M2, 0, toHash, size * 2, size);
M0 = M1;
M1 = M2;
M2 = sha.ComputeHash(toHash);
}
M0 = M2;
M1 = M2;
Assert.Equal(expected, M2);
}
sha.Dispose();
}
public override void Close()
{
if (_disposed)
{
return;
}
if (_blockBufferPosition != 0)
{
Key key = null;
if (_hashAlgorithm == HashAlgorithm.Sha256)
{
key = new Key(Sha256.ComputeHash(_blockBuffer, 0, _blockBufferPosition), _hashAlgorithm);
}
else
{
throw new NotSupportedException();
}
lock (_cacheManager.ThisLock)
{
_cacheManager.Lock(key);
_cacheManager[key] = new ArraySegment <byte>(_blockBuffer, 0, _blockBufferPosition);
}
_keyList.Add(key);
_blockBufferPosition = 0;
}
base.Close();
}
private static Stream RemoveHash(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
int type = (int)Varint.GetUInt64(stream);
if (type == (int)ConvertHashAlgorithm.Sha256)
{
var value = new byte[32];
stream.Read(value, 0, value.Length);
var dataStream = new RangeStream(stream, true);
if (!Unsafe.Equals(value, Sha256.ComputeHash(new WrapperStream(dataStream, true))))
{
throw new ArgumentException("Hash");
}
dataStream.Seek(0, SeekOrigin.Begin);
return(dataStream);
}
else
{
throw new NotSupportedException();
}
}
private static Stream AddHash(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
try
{
var targetStream = new RangeStream(stream, true);
BufferStream metadataStream = new BufferStream(_bufferManager);
metadataStream.WriteByte((byte)ConvertHashAlgorithm.Sha256);
targetStream.Seek(0, SeekOrigin.Begin);
var hash = Sha256.ComputeHash(targetStream);
BufferStream hashStream = new BufferStream(_bufferManager);
hashStream.Write(hash, 0, hash.Length);
return(new UniteStream(metadataStream, targetStream, hashStream));
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
public void ComputeHashTest()
{
var input = StringHelper.GetRandomString(100);
var result = Sha256.ComputeHash(input);
Assert.IsNotNull(result);
Assert.AreNotEqual(result, input);
}
public void ComputeHash_AMillionATest()
{
using Sha256 sha = new Sha256();
byte[] actualHash = sha.ComputeHash(HashTestCaseHelper.GetAMillionA());
byte[] expectedHash = Helper.HexToBytes("cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
Assert.Equal(expectedHash, actualHash);
}
public void ComputeHash_WithIndexTest()
{
using Sha256 sha = new Sha256();
byte[] data = Helper.HexToBytes("123fab54686520717569636b2062726f776e20666f78206a756d7073206f76657220746865206c617a7920646f67f3a25c92");
byte[] actualHash = sha.ComputeHash(data, 3, 43);
byte[] expectedHash = Helper.HexToBytes("d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592");
Assert.Equal(expectedHash, actualHash);
}
private uint[] Convert8To11(FastStream stream)
{
using Sha256 sha = new Sha256();
byte[] hash = sha.ComputeHash(stream.ToByteArray());
int bitSize = stream.GetSize() * 8;
int cs = 11 - (bitSize % 11);
if (cs < 4)
{
cs += 11;
}
Debug.Assert(cs >= 4 && cs <= 14);
stream.Write(hash, 0, cs > 8 ? 2 : 1);
bitSize += cs;
int wordCount = bitSize / 11;
Debug.Assert(bitSize % 11 == 0);
byte[] ba = stream.ToByteArray();
uint[] bits = new uint[(int)Math.Ceiling((double)bitSize / 32)];
for (int i = 0, j = 0; j < bits.Length; i += 4, j++)
{
bits[j] = (uint)(ba[i + 3] | (ba[i + 2] << 8) | (ba[i + 1] << 16) | (ba[i] << 24));
}
int itemIndex = 0;
int bitIndex = 0;
// Number of bits in a word
int toTake = 11;
// UInt32 is 32 bit!
int maxBits = 32;
uint[] wordIndexes = new uint[wordCount];
for (int i = 0; i < wordIndexes.Length; i++)
{
if (bitIndex + toTake <= maxBits)
{
wordIndexes[i] = (bits[itemIndex] << bitIndex) >> (maxBits - toTake);
}
else
{
wordIndexes[i] = ((bits[itemIndex] << bitIndex) >> (maxBits - toTake)) |
(bits[itemIndex + 1] >> (maxBits - toTake + maxBits - bitIndex));
}
bitIndex += toTake;
if (bitIndex >= maxBits)
{
bitIndex -= maxBits;
itemIndex++;
}
}
return(wordIndexes);
}
public void ComputeHash_DoubleTest()
{
using Sha256 sha = new Sha256(true);
var data = Helper.HexToBytes("fb8049137747e712628240cf6d7056ea2870170cb7d9bc713d91e901b514c6ae7d7dda3cd03ea1b99cf85046a505f3590541123d3f8f2c22c4d7d6e65de65c4ebb9251f09619");
byte[] actualHash = sha.ComputeHash(data);
byte[] expectedHash = Helper.HexToBytes("d2cee8d3cfaf1819c55cce1214d01cdef1d97446719ccfaad4d76d912a8126f9");
Assert.Equal(expectedHash, actualHash);
}
public void TestInformalAbc()
{
byte[] bytes = Encoding.ASCII.GetBytes("abc");
Sha256 hash = New <Sha256>();
byte[] actual;
actual = hash.ComputeHash(bytes);
Assert.That(actual, Is.EquivalentTo("BA7816BF 8F01CFEA 414140DE 5DAE2223 B00361A3 96177A9C B410FF61 F20015AD".FromHex()));
}
public void TestSha256()
{
var sha256 = new Sha256();
var bytes = Encoding.UTF8.GetBytes("abc");
var hash = sha256.ComputeHash(bytes);
var sha256str = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
Assert.AreEqual(sha256str, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
}
public void TestInformalLongerText()
{
byte[] bytes = Encoding.ASCII.GetBytes("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq");
Sha256 hash = New <Sha256>();
byte[] actual;
actual = hash.ComputeHash(bytes);
Assert.That(actual, Is.EquivalentTo("248D6A61 D20638B8 E5C02693 0C3E6039 A33CE459 64FF2167 F6ECEDD4 19DB06C1".FromHex()));
}
private static bool VerifyHash()
{
try
{
var csp = (RSACryptoServiceProvider)ServerCertificate.PublicKey.Key;
return(csp.VerifyHash(Sha256.ComputeHash(Encoding.UTF8.GetBytes(Key)), CryptoConfig.MapNameToOID("SHA256"), Convert.FromBase64String(Serversignature)));
}
catch (Exception)
{
return(false);
}
}
public override void Write(byte[] buffer, int offset, int count)
{
if (_disposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
if (offset < 0 || buffer.Length < offset)
{
throw new ArgumentOutOfRangeException("offset");
}
if (count < 0 || (buffer.Length - offset) < count)
{
throw new ArgumentOutOfRangeException("count");
}
int writeLength = 0;
while (count > 0)
{
int length = Math.Min(_blockBufferLength - _blockBufferPosition, count);
Unsafe.Copy(buffer, offset, _blockBuffer, _blockBufferPosition, length);
_blockBufferPosition += length;
offset += length;
count -= length;
writeLength += length;
if (_blockBufferLength == _blockBufferPosition)
{
Key key = null;
if (_hashAlgorithm == HashAlgorithm.Sha256)
{
key = new Key(Sha256.ComputeHash(_blockBuffer, 0, _blockBufferPosition), _hashAlgorithm);
}
else
{
throw new NotSupportedException();
}
lock (_cacheManager.ThisLock)
{
_cacheManager.Lock(key);
_cacheManager[key] = new ArraySegment <byte>(_blockBuffer, 0, _blockBufferPosition);
}
_keyList.Add(key);
_blockBufferPosition = 0;
}
}
_length += writeLength;
}
public static string CreateToken(string token, string dsId)
{
if (string.IsNullOrEmpty(token))
{
throw new ArgumentException("Invalid token");
}
var tokenHash = dsId + token;
tokenHash = UrlBase64.Encode(Sha256.ComputeHash(Encoding.UTF8.GetBytes(tokenHash)));
return(token.Substring(0, 16) + tokenHash);
}
static bool VerifyHash()
{
try
{
var csp = (RSACryptoServiceProvider)SERVERCERTIFICATE.PublicKey.Key;
return(csp.VerifyHash(Sha256.ComputeHash(Encoding.UTF8.GetBytes(ENCRYPTIONKEY)), CryptoConfig.MapNameToOID("SHA256"),
Convert.FromBase64String(SERVERSIGNATURE)));
}
catch (Exception)
{
return(false);
}
}
public void Hash(int count, string value)
{
Assert.Equal(count, value.Length);
var shaClr = SHA256.Create();
var sha = new Sha256();
var data = Encoding.UTF8.GetBytes(value);
var expectedHash = shaClr.ComputeHash(data);
var result = new byte[32];
sha.ComputeHash(data, result);
Assert.Equal(expectedHash, result);
}
/// <summary>
/// Replaces top stack item with its hash digest. Return value indicates success.
/// </summary>
/// <param name="opData">Data to use</param>
/// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param>
/// <returns>True if operation was successful, false if otherwise</returns>
public override bool Run(IOpData opData, out string error)
{
if (opData.ItemCount < 1)
{
error = Err.OpNotEnoughItems;
return(false);
}
using Sha256 hash = new Sha256();
opData.Push(hash.ComputeHash(opData.Pop()));
error = null;
return(true);
}
//[InlineData(0x5a, 0x20000000, "15a1868c12cc53951e182344277447cd0979536badcc512ad24c67e9b2d4f3dd")]
//[InlineData(0x00, 0x41000000, "461c19a93bd4344f9215f5ec64357090342bc66b15a148317d276e31cbc20b53")]
//[InlineData(0x42, 0x6000003e, "c23ce8a7895f4b21ec0daf37920ac0a262a220045a03eb2dfed48ef9b05aabea")]
public void HashNist(byte value, int byteCount, string expectedHex)
{
Assert.Equal(64, expectedHex.Length);
var sha = new Sha256();
//var sha = SHA256.Create();
var expectedHash = ToBin(expectedHex);
var data = new byte[byteCount];
Array.Fill(data, value);
var result = new byte[32];
sha.ComputeHash(data, result);
Assert.Equal(expectedHash, result);
}
private void btnLogin_Click(object sender, EventArgs e)
{
lblError.Text = "";
Employee = null;
int id;
if (!Int32.TryParse(txtId.Text, out id))
{
lblError.Text = "Employee id must be integer";
return;
}
var bytes = Sha256.ComputeHash(Encoding.UTF8.GetBytes(txtPassword.Text));
var builder = new StringBuilder();
foreach (byte b in bytes)
{
builder.Append(b.ToString("x2"));
}
string password = builder.ToString();
var employee = Entities.Employee
.Where(v => v.id == id)
.FirstOrDefault();
if (employee == null)
{
lblError.Text = "Invalid ID";
return;
}
if (!employee.password.Equals(password))
{
lblError.Text = "Wrong Password";
return;
}
Employee = employee;
Hide();
new FormMain().ShowDialog();
Close();
}
public byte[] CreateHash(HashAlgorithm hashAlgorithm)
{
if (_Sha256_hash == null)
{
using (var stream = this.Export(BufferManager.Instance))
{
_Sha256_hash = Sha256.ComputeHash(stream);
}
}
if (hashAlgorithm == HashAlgorithm.Sha256)
{
return(_Sha256_hash);
}
return(null);
}
private static Stream AddHash(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
var hashStream = new BufferStream(_bufferManager);
{
Varint.SetUInt64(hashStream, (uint)ConvertHashAlgorithm.Sha256);
var value = Sha256.ComputeHash(new WrapperStream(stream, true));
hashStream.Write(value, 0, value.Length);
}
return(new UniteStream(hashStream, stream));
}
public PublicKeyThumbprint(byte[] modulus, byte[] exponent)
{
if (modulus == null)
{
throw new ArgumentNullException("modulus");
}
if (exponent == null)
{
throw new ArgumentNullException("exponent");
}
Sha256 sha256 = New <Sha256>();
byte[] bytes = modulus.Append(exponent);
byte[] hash = sha256.ComputeHash(bytes);
_thumbprint = hash.Reduce(16);
}
private static Stream RemoveHash(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
byte type = (byte)stream.ReadByte();
if (type == (byte)ConvertHashAlgorithm.Sha256)
{
Stream dataStream = null;
try
{
byte[] hash = new byte[32];
using (RangeStream hashStream = new RangeStream(stream, stream.Length - 32, 32, true))
{
hashStream.Read(hash, 0, hash.Length);
}
dataStream = new RangeStream(stream, 1, stream.Length - (1 + 32));
if (!Unsafe.Equals(hash, Sha256.ComputeHash(dataStream)))
{
throw new FormatException();
}
dataStream.Seek(0, SeekOrigin.Begin);
return(dataStream);
}
catch (Exception)
{
if (dataStream != null)
{
dataStream.Dispose();
}
throw;
}
}
throw new NotSupportedException();
}
/// <summary>
/// Returns the 256-bit result of double SHA-256 hash of the message with the added constant used in signing operation.
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <param name="message">
/// UTF-8 encoded message to sign (will be normalized using full compatibility decomposition form).
/// <para/>Note that trailing spaces, new line character,... will not be changed here.
/// Caller has to decide whether to change those
/// </param>
/// <returns>256-bit hash</returns>
public byte[] GetBytesToSign(string message)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message), "Message can not be null.");
}
using Sha256 hash = new Sha256(true);
FastStream stream = new FastStream();
stream.Write((byte)Constants.MsgSignConst.Length);
stream.Write(Encoding.UTF8.GetBytes(Constants.MsgSignConst));
byte[] messageBytes = Encoding.UTF8.GetBytes(message.Normalize(NormalizationForm.FormKD));
stream.WriteWithCompactIntLength(messageBytes);
byte[] result = hash.ComputeHash(stream.ToByteArray());
return(result);
}
private bool CheckMessage(string message, out byte[] toSign)
{
try
{
FastStream stream = new FastStream();
byte[] msgBa = Encoding.UTF8.GetBytes(message);
stream.Write((byte)MessageSignConstant.Length);
stream.Write(Encoding.UTF8.GetBytes(MessageSignConstant));
new CompactInt((ulong)msgBa.Length).WriteToStream(stream);
stream.Write(msgBa);
toSign = hash.ComputeHash(stream.ToByteArray());
return(true);
}
catch (Exception)
{
toSign = null;
return(false);
}
}
