public byte[] SHA256()
{
using (var sha256 = new SHA256Managed())
{
var strings = new[] { Str1, Str2, Str3, Str4 };
for (int i = 0; i < strings.Length; i++)
{
string str = strings[i];
if (str != null)
{
// Commented lines are for using ToUpperInvariant()
//str = str.ToUpperInvariant()
byte[] length2 = BitConverter.GetBytes(str.Length);
sha256.TransformBlock(length2, 0, length2.Length, length2, 0);
// byte[] sortKeyBytes = Encoding.UTF8.GetBytes(str);
byte[] sortKeyBytes = CultureInfo.InvariantCulture.CompareInfo.GetSortKey(str, CompareOptions.IgnoreCase).KeyData;
sha256.TransformBlock(sortKeyBytes, 0, sortKeyBytes.Length, sortKeyBytes, 0);
}
else
{
byte[] length2 = BitConverter.GetBytes(-1);
sha256.TransformBlock(length2, 0, length2.Length, length2, 0);
}
}
sha256.TransformFinalBlock(new byte[0], 0, 0);
byte[] hash = sha256.Hash;
return(hash);
}
}
/// <summary>
/// Generates the play ready content key.
/// </summary>
/// <param name="keySeed">The key seed.</param>
/// <param name="keyId">The key id.</param>
/// <returns>The content key.</returns>
public static byte[] GeneratePlayReadyContentKey(byte[] keySeed, Guid keyId)
{
if (keySeed == null)
{
throw new ArgumentNullException("keySeed");
}
byte[] contentKey = new byte[EncryptionUtils.KeySizeInBytesForAes128];
// Truncate the key seed to 30 bytes.
byte[] truncatedKeySeed = new byte[30];
if (keySeed.Length < truncatedKeySeed.Length)
{
throw new ArgumentOutOfRangeException("keySeed", "KeySeed must be at least 30 bytes in length");
}
Array.Copy(keySeed, truncatedKeySeed, truncatedKeySeed.Length);
// Get the keyId as a byte array.
byte[] keyIdAsBytes = keyId.ToByteArray();
using (SHA256Managed sha_A = new SHA256Managed())
using (SHA256Managed sha_B = new SHA256Managed())
using (SHA256Managed sha_C = new SHA256Managed())
{
// Create sha_A_Output buffer. It is the SHA of the truncatedKeySeed and the keyIdAsBytes.
sha_A.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_A.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length);
byte[] sha_A_Output = sha_A.Hash;
// Create sha_B_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes, and
// the truncatedKeySeed again.
sha_B.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_B.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0);
sha_B.TransformFinalBlock(truncatedKeySeed, 0, truncatedKeySeed.Length);
byte[] sha_B_Output = sha_B.Hash;
// Create sha_C_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes,
// the truncatedKeySeed again, and the keyIdAsBytes again.
sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_C.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0);
sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_C.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length);
byte[] sha_C_Output = sha_C.Hash;
for (int i = 0; i < EncryptionUtils.KeySizeInBytesForAes128; i++)
{
contentKey[i] = Convert.ToByte(sha_A_Output[i] ^ sha_A_Output[i + EncryptionUtils.KeySizeInBytesForAes128]
^ sha_B_Output[i] ^ sha_B_Output[i + EncryptionUtils.KeySizeInBytesForAes128]
^ sha_C_Output[i] ^ sha_C_Output[i + EncryptionUtils.KeySizeInBytesForAes128]);
}
}
return(contentKey);
}
/*
* Calculating PlayReady Content Key with Key Seed
* https://docs.microsoft.com/en-us/playready/specifications/playready-key-seed
*
* Services implementing PlayReady must maintain a Key Management System (KMS) to store and manage content keys.
* Specifically, the values of {KID, Content Key} are stored for each content asset that is managed by the service.
* These values are stored at encryption time, and retrieved at license issuance time.
*
* PlayReady provides a convenient way to avoid a complex KMS.
* The Content Key Seed algorithm allows derivation of different content keys for a collection of content assets,
* from a varying KID and a fixed Key Seed:
* Ck(KID) = f(KID, KeySeed)
*
* !!NOTE!!:
* The algorithm is expected to input KeyId as GUID.
* This means the byte data of the KeyId must be GUID LE Byte Array.
*
* The following is the PlayReady standard algorithm:
*/
public static byte[] GeneratePlayReadyContentKey(byte[] keySeed, Guid keyId)
{
const int DRM_AES_KEYSIZE_128 = 16;
byte[] contentKey = new byte[DRM_AES_KEYSIZE_128];
//
// Truncate the key seed to 30 bytes, key seed must be at least 30 bytes long.
//
byte[] truncatedKeySeed = new byte[30];
Array.Copy(keySeed, truncatedKeySeed, truncatedKeySeed.Length);
//
// Get the keyId as a byte array
//
byte[] keyIdAsBytes = keyId.ToByteArray();
//
// Create sha_A_Output buffer. It is the SHA of the truncatedKeySeed and the keyIdAsBytes
//
SHA256Managed sha_A = new SHA256Managed();
sha_A.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_A.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length);
byte[] sha_A_Output = sha_A.Hash;
//
// Create sha_B_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes, and
// the truncatedKeySeed again.
//
SHA256Managed sha_B = new SHA256Managed();
sha_B.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_B.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0);
sha_B.TransformFinalBlock(truncatedKeySeed, 0, truncatedKeySeed.Length);
byte[] sha_B_Output = sha_B.Hash;
//
// Create sha_C_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes,
// the truncatedKeySeed again, and the keyIdAsBytes again.
//
SHA256Managed sha_C = new SHA256Managed();
sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_C.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0);
sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0);
sha_C.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length);
byte[] sha_C_Output = sha_C.Hash;
for (int i = 0; i < DRM_AES_KEYSIZE_128; i++)
{
contentKey[i] = Convert.ToByte(sha_A_Output[i] ^ sha_A_Output[i + DRM_AES_KEYSIZE_128]
^ sha_B_Output[i] ^ sha_B_Output[i + DRM_AES_KEYSIZE_128]
^ sha_C_Output[i] ^ sha_C_Output[i + DRM_AES_KEYSIZE_128]);
}
return(contentKey);
}
public byte[] CalculateHash()
{
using (var sha256 = new SHA256Managed())
{
sha256.Initialize();
sha256.TransformBlock(this.Index);
sha256.TransformBlock(this.PreviousHash);
sha256.TransformBlock(this.TimeStamp.ToBinary());
sha256.TransformBlock(this.Data);
sha256.TransformFinalBlock(this.Nonce);
return(sha256.Hash);
}
}
public void TestSha256()
{
var r = CryptoRandom.NewWeakRandom();
var pbData = new byte[517];
r.NextBytes(pbData);
byte[] pbH1;
using (var h1 = new SHA256Managed())
{
var i = 0;
while (i != pbData.Length)
{
var cb = r.Next(pbData.Length - i) + 1;
h1.TransformBlock(pbData, i, cb, pbData, i);
i += cb;
}
h1.TransformFinalBlock(MemUtil.EmptyByteArray, 0, 0);
pbH1 = h1.Hash;
}
byte[] pbH2;
using (var h2 = new SHA256Managed())
{
pbH2 = h2.ComputeHash(pbData);
}
Assert.That(MemUtil.ArraysEqual(pbH1, pbH2), Is.True);
}
private static string GetSha512Buffered(Stream p_streamIn)
{
string _result;
Process.GetCurrentProcess();
const int _bufferSizeForMd5Hash = 1024 * 1024 * 8;
using (var _md5Prov = new SHA256Managed())
{
int _readCount;
var _bytesTransfered = 0;
var _buffer = new byte[_bufferSizeForMd5Hash];
while ((_readCount = p_streamIn.Read(_buffer, 0, _buffer.Length)) != 0)
{
if (_bytesTransfered + _readCount == p_streamIn.Length)
{
_md5Prov.TransformFinalBlock(_buffer, 0, _readCount);
}
else
{
_md5Prov.TransformBlock(_buffer, 0, _bufferSizeForMd5Hash, _buffer, 0);
}
_bytesTransfered += _readCount;
}
_result = BitConverter.ToString(_md5Prov.Hash).Replace("-", String.Empty).ToLower();
_md5Prov.Clear();
}
return(_result);
}
/// <summary>
/// Computes a SHA256 hash
/// </summary>
/// <param name="text">String or filename of file hash</param>
/// <returns>Hexadecimal SHA256 hash string</returns>
public static string SHA256(string s)
{
if (System.IO.File.Exists(s))
{
int offset = 0;
byte[] block = new byte[ZefieLib.Data.BlockSize];
byte[] hash;
using (BufferedStream f = new BufferedStream(new FileStream(s, FileMode.Open, FileAccess.Read)))
{
using (SHA256 shaM = new SHA256Managed())
{
// For each block:
while (offset + block.Length < f.Length)
{
f.Position = offset;
f.Read(block, 0, ZefieLib.Data.BlockSize);
offset += shaM.TransformBlock(block, 0, block.Length, null, 0);
}
int remain = (int)(f.Length - (long)offset);
block = new byte[remain];
f.Position = offset;
_ = f.Read(block, 0, remain);
_ = shaM.TransformFinalBlock(block, 0, block.Length);
hash = shaM.Hash;
}
}
return(ZefieLib.Data.BytesToHex(hash));
}
else
{
return(SHA256(Encoding.UTF8.GetBytes(s)));
}
}
/**
* Method to compute the hash value
* */
public static byte[] ComputeHash(BinaryReader reader, ulong dataSize)
{
// embadding of the SHA256 algorithm
SHA256Managed sha = new SHA256Managed();
int offset = 0;
byte[] output = new byte[512]; // buffer size
byte[] input;
// with the buffer, we are possible to process large file with small memory usage.
// increasing of the buffer size will speed up the process.
// read and transform a block at a time according to the buffer size
while ((ulong)output.Length - (ulong)offset < dataSize)
{
input = reader.ReadBytes(output.Length);
offset += sha.TransformBlock(input, 0, output.Length, output, 0);
}
// transform final block
input = reader.ReadBytes((int)(dataSize - (ulong)offset));
sha.TransformFinalBlock(input, 0, input.Length);
return(sha.Hash);
}
/// <summary>
/// Stretches the key by first hashing passphrase|salt, then iteratively hashing
/// the hash, for the specified number of iterations. 'Stretching' in this context
/// means artificially applying an extra work-factor so as to effectively lengthen
/// the effective bit-length of the provided passphrase.
/// </summary>
/// <param name="salt">The salt.</param>
/// <param name="passphrase">The passphrase.</param>
/// <param name="iterations">The iterations.</param>
/// <returns></returns>
private static byte[] StretchKey(
byte[] salt,
string passphrase,
int iterations)
{
var ansiEncodedPassphrase =
passphrase.Select(x => (byte)x).ToArray(); //SHA256.ASCIIEncoder(passphrase);
byte[] iteratedHashValue;
using (SHA256 hash = new SHA256Managed())
{
hash.TransformBlock(ansiEncodedPassphrase, 0, ansiEncodedPassphrase.Length, null, 0);
hash.TransformFinalBlock(salt, 0, salt.Length);
iteratedHashValue = hash.Hash;
}
for (var i = 0; i < iterations; ++i)
{
using SHA256 iterationHash = new SHA256Managed();
iteratedHashValue = iterationHash.ComputeHash(iteratedHashValue);
}
return(iteratedHashValue);
}
private byte[] ComputeBinding(ChannelHeader channelHeader, SignatureHeader signatureHeader)
{
using (SHA256Managed digest = new SHA256Managed())
{
digest.Initialize();
digest.TransformBlock(signatureHeader.Nonce.ToByteArray(), 0, signatureHeader.Nonce.Length, null, 0);
digest.TransformBlock(creator.ToByteArray(), 0, creator.Length, null, 0);
byte[] epoch = BitConverter.GetBytes(channelHeader.Epoch);
if (!BitConverter.IsLittleEndian)
{
epoch = epoch.Reverse().ToArray();
}
digest.TransformFinalBlock(epoch, 0, epoch.Length);
return(digest.Hash);
}
}
/// <summary>
/// Hashes data from a stream.
/// </summary>
/// <param name="es">The input stream.</param>
/// <param name="length">The number of bytes to hash.</param>
/// <returns>The hashed digest.</returns>
/// <remarks>
/// The method will hash length bytes of the stream from the current position
/// and the stream position will be restored before the method
/// returns.
/// </remarks>
public static byte[] Compute(EnhancedStream es, long length)
{
var sha256 = new SHA256Managed();
long streamPos;
byte[] buf;
int cb;
streamPos = es.Position;
buf = new byte[8192];
while (length > 0)
{
cb = (int)(length > buf.Length ? buf.Length : length);
if (es.Read(buf, 0, cb) < cb)
{
throw new InvalidOperationException("Read past end of stream.");
}
sha256.TransformBlock(buf, 0, cb, buf, 0);
length -= cb;
}
sha256.TransformFinalBlock(buf, 0, 0);
es.Seek(streamPos, SeekOrigin.Begin);
return(sha256.Hash);
}
public static void Main()
{
FileStream fs = File.OpenRead("App.ico");
SHA256Managed sha256 = new SHA256Managed();
byte[] b = sha256.ComputeHash(fs);
fs.Close();
PB(b);
fs = File.OpenRead("App.ico");
sha256 = new SHA256Managed();
byte[] buffer = new byte[0x1000];
while (true)
{
int n = fs.Read(buffer, 0, 0x1000);
if (n == 0x1000)
{
sha256.TransformBlock(buffer, 0, 0x1000, buffer, 0);
}
else
{
sha256.TransformFinalBlock(buffer, 0, n);
break;
}
}
fs.Close();
PB(sha256.Hash);
}
private string ReadFileHash256(string filepath)
{
string h256s = "";
long hadRead = 0;
using (FileStream fileStream = new FileStream(filepath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
const int bufferlength = 1024 * 1024;
byte[] bytetoread = new byte[bufferlength];
SHA256Managed sha256 = new SHA256Managed();
while (true)
{
int rint = fileStream.Read(bytetoread, 0, bufferlength);
sha256.TransformBlock(bytetoread, 0, rint, bytetoread, 0);
hadRead += rint;
if (hadRead >= fileStream.Length)
{
break;
}
}
sha256.TransformFinalBlock(bytetoread, 0, 0);
h256s = ToBitString(sha256.Hash);
}
return(h256s);
}
public void Add_part(byte[] text) // voeg een deel van de hash toe
{
int hulp = text.Length;
totalBytes += hulp;
sha.TransformBlock(text, 0, hulp, null, 0);
}
private static BigInteger Hash(params BigInteger[] integers)
{
using (var sha256 = new SHA256Managed())
{
sha256.Initialize();
for (int i = 0; i < integers.Length; i++)
{
byte[] buffer = integers[i].ToByteArray(true);
int padding = buffer.Length % 4;
if (padding != 0)
{
Array.Resize(ref buffer, buffer.Length + (4 - padding));
}
if (i == integers.Length - 1)
{
sha256.TransformFinalBlock(buffer, 0, buffer.Length);
}
else
{
sha256.TransformBlock(buffer, 0, buffer.Length, null, 0);
}
}
byte[] hash = sha256.Hash;
ReverseBytesAsUInt32(hash);
return(new BigInteger(hash, true));
}
}
public void Partial()
{
var data = "Some random stuff for testing purposes.".AsciiToBytes();
UInt256 h1;
UInt256 refOnce;
UInt256 refTwice;
using (var alg = new SHA256Managed()) {
alg.TransformFinalBlock(data, 0, data.Length);
refOnce = h1 = (UInt256)alg.Hash;
alg.TransformFinalBlock(data, 0, data.Length);
UInt256 h2 = (UInt256)alg.Hash;
Assert.Equal(h1, h2);
alg.TransformFinalBlock(h1, 0, 32);
refTwice = (UInt256)alg.Hash;
}
using (var alg = new SHA256Managed()) {
alg.TransformBlock(data, 0, data.Length - 12, null, 0);
alg.TransformFinalBlock(data, data.Length - 12, 12);
h1 = (UInt256)alg.Hash;
Assert.Equal(refOnce, h1);
}
using (var alg = new SHA256Managed()) {
alg.TransformBlock(data, 0, data.Length, null, 0);
alg.TransformFinalBlock(data, 0, 0);
h1 = (UInt256)alg.Hash;
Assert.Equal(refOnce, h1);
}
using var hw = new HashWriter();
hw.Add(data[..12]);
private string GetSha256Hash_BigFile(Stream fileStream)
{
string result = string.Empty;
using (SHA256Managed hashAlgorithm = new SHA256Managed())
{
long bytesToHash = fileStream.Length;
byte[] buffer = new byte[bigChunkSize];
int sizeToRead = buffer.Length;
while (bytesToHash > 0)
{
if (bytesToHash < (long)sizeToRead)
{
sizeToRead = (int)bytesToHash;
}
int bytesRead = fileStream.ReadAsync(buffer, 0, sizeToRead, CancellationHelper.GetCancellationToken()).Result;
CancellationHelper.ThrowIfCancelled();
hashAlgorithm.TransformBlock(buffer, 0, bytesRead, null, 0);
bytesToHash -= (long)bytesRead;
if (bytesRead == 0)
{
throw new InvalidOperationException("Unexpected end of stream");
// or break;
}
}
hashAlgorithm.TransformFinalBlock(buffer, 0, 0);
buffer = null;
result = ByteArrayConverter.ToHexString(hashAlgorithm.Hash);
}
return(result);
}
internal static byte[] CreateSaltedHash(byte[] password, byte[] salt, Int32 hashIterations)
{
// Seed for the pseudo-random fcn: salt + block index.
byte[] saltAndIndex = new byte[salt.Length + BLOCK_INDEX];
Array.Copy(salt, 0, saltAndIndex, 0, salt.Length);
byte[] hashOutput = new byte[BLOCK_COUNT * SHA2_256_HASH_SIZE_IN_BYTES];
int hashOutputOffset = 0;
SHA256Managed hashInner = new SHA256Managed();
SHA256Managed hashOuter = new SHA256Managed();
// For HMAC the key must be hashed or padded with zeros so
// that it fits into a single block of the hash algorithm being used.
if (password.Length > SHA2_256_BLOCK_SIZE_IN_BYTES)
{
password = hashInner.ComputeHash(password);
}
byte[] key = new byte[SHA2_256_BLOCK_SIZE_IN_BYTES];
Array.Copy(password, 0, key, 0, password.Length);
byte[] keyInner = new byte[SHA2_256_BLOCK_SIZE_IN_BYTES];
byte[] keyOuter = new byte[SHA2_256_BLOCK_SIZE_IN_BYTES];
for (Int32 i = 0; i < SHA2_256_BLOCK_SIZE_IN_BYTES; i++)
{
keyInner[i] = (byte)(key[i] ^ INNER_HASH_PADDING);
keyOuter[i] = (byte)(key[i] ^ OUTER_HASH_PADDING);
}
// For each block of desired output...
for (Int32 hashBlock = 0; hashBlock < BLOCK_COUNT; hashBlock++)
{
// Seed HMAC with salt & block index.
IncrementInteger(saltAndIndex, salt.Length);
byte[] hmacResult = saltAndIndex;
for (Int32 i = 0; i < hashIterations; i++)
{
// Simple implementation of HMAC-SHA2-256.
hashInner.Initialize();
hashInner.TransformBlock(keyInner, 0, SHA2_256_BLOCK_SIZE_IN_BYTES, keyInner, 0);
hashInner.TransformFinalBlock(hmacResult, 0, hmacResult.Length);
byte[] temp = hashInner.Hash;
hashOuter.Initialize();
hashOuter.TransformBlock(keyOuter, 0, SHA2_256_BLOCK_SIZE_IN_BYTES, keyOuter, 0);
hashOuter.TransformFinalBlock(temp, 0, temp.Length);
hmacResult = hashOuter.Hash;
// XOR result into output buffer.
XorByteArray(hmacResult, 0, hashOutput, hashOutputOffset);
}
hashOutputOffset += SHA2_256_HASH_SIZE_IN_BYTES;
}
byte[] result = new byte[SHA2_256_HASH_SIZE_IN_BYTES];
Array.Copy(hashOutput, 0, result, 0, SHA2_256_HASH_SIZE_IN_BYTES);
return(result);
}
private void OnRandomMouseMove(object sender, MouseEventArgs e)
{
if (m_h == null)
{
Debug.Assert(false); return;
}
byte[] pb = new byte[8 + 4 + 4];
MemUtil.Int64ToBytesEx(DateTime.UtcNow.ToBinary(), pb, 0);
MemUtil.Int32ToBytesEx(e.X, pb, 8);
MemUtil.Int32ToBytesEx(e.Y, pb, 12);
m_h.TransformBlock(pb, 0, pb.Length, pb, 0);
m_fBits += 0.125f;
UpdateUIState();
}
public override void Close()
{
if (m_sBaseStream == null)
{
return;
}
if (m_bWriting)
{
int blockremainder = 32 - (m_ContentLength % 32);
if (blockremainder < 32)
{
// keep in block boundary
byte[] randombytes = CryptoRandom.Instance.GetRandomBytes((uint)blockremainder);
m_CryptoStreamAES.Write(randombytes, 0, blockremainder);
m_CryptoStreamAES.FlushFinalBlock();
m_hash.TransformBlock(randombytes, 0, blockremainder, randombytes, 0);
randombytes = CryptoRandom.Instance.GetRandomBytes((uint)blockremainder);
m_RandomStream.Write(randombytes, 0, blockremainder);
}
m_hash.TransformFinalBlock(new byte[0], 0, 0);
/////// Start writing to base stream //////////
m_sBaseStream.Write(Extensions.GetLittleEndianBytes(m_ContentLength), 0, 4); // write the length
m_AESStream.WriteTo(m_sBaseStream);
CryptoStream CryptoStream3DES;
CryptoStream3DES = new CryptoStream(m_sBaseStream, Get3DES().CreateEncryptor(), CryptoStreamMode.Write);
m_RandomStream.WriteTo(CryptoStream3DES);
CryptoStream3DES.FlushFinalBlock();
CryptoStream3DES.Close();
m_CryptoStreamAES.Close();
}
m_sBaseStream.Close();
m_sBaseStream = null;
}
static byte[] sha256(byte[] seed, byte[] packet)
{
using (SHA256Managed signit = new SHA256Managed())
{
signit.TransformBlock(seed, 0, seed.Length, null, 0);
signit.TransformFinalBlock(packet, 0, packet.Length);
var ctx = signit.Hash;
return(ctx);
}
}
private static byte[] GetSha256Hash(params byte[][] buffers)
{
using (var hash = new SHA256Managed()) {
foreach (var buffer in buffers)
{
hash.TransformBlock(buffer, 0, buffer.Length, buffer, 0);
}
hash.TransformFinalBlock(new byte[] { }, 0, 0);
return(hash.Hash);
}
}
private static byte[] GetBytes(byte[] password, byte[] salt, int iterations, int howManyBytes)
{
// round up
uint cBlocks = (uint)((howManyBytes + HASH_SIZE_IN_BYTES - 1) / HASH_SIZE_IN_BYTES);
// seed for the pseudo-random fcn: salt + block index
byte[] saltAndIndex = new byte[salt.Length + 4];
Array.Copy(salt, 0, saltAndIndex, 0, salt.Length);
byte[] output = new byte[cBlocks * HASH_SIZE_IN_BYTES];
int outputOffset = 0;
SHA256Managed innerHash = new SHA256Managed();
SHA256Managed outerHash = new SHA256Managed();
// HMAC says the key must be hashed or padded with zeros
// so it fits into a single block of the hash in use
if (password.Length > BLOCK_SIZE_IN_BYTES)
{
password = innerHash.ComputeHash(password);
}
byte[] key = new byte[BLOCK_SIZE_IN_BYTES];
Array.Copy(password, 0, key, 0, password.Length);
byte[] InnerKey = new byte[BLOCK_SIZE_IN_BYTES];
byte[] OuterKey = new byte[BLOCK_SIZE_IN_BYTES];
for (int i = 0; i < BLOCK_SIZE_IN_BYTES; ++i)
{
InnerKey[i] = (byte)(key[i] ^ IPAD);
OuterKey[i] = (byte)(key[i] ^ OPAD);
}
// for each block of desired output
for (int iBlock = 0; iBlock < cBlocks; ++iBlock)
{
// seed HMAC with salt & block index
_incrementBigEndianIndex(saltAndIndex, salt.Length);
byte[] U = saltAndIndex;
for (int i = 0; i < iterations; ++i)
{
// simple implementation of HMAC-SHA-256
innerHash.Initialize();
innerHash.TransformBlock(InnerKey, 0, BLOCK_SIZE_IN_BYTES, InnerKey, 0);
innerHash.TransformFinalBlock(U, 0, U.Length);
byte[] temp = innerHash.Hash; outerHash.Initialize();
outerHash.TransformBlock(OuterKey, 0, BLOCK_SIZE_IN_BYTES, OuterKey, 0);
outerHash.TransformFinalBlock(temp, 0, temp.Length);
U = outerHash.Hash;
// U = result of HMAC
// xor result into output buffer
_xorByteArray(U, 0, HASH_SIZE_IN_BYTES, output, outputOffset);
}
outputOffset += HASH_SIZE_IN_BYTES;
}
byte[] result = new byte[howManyBytes];
Array.Copy(output, 0, result, 0, howManyBytes);
return result;
}
public byte[] SHA256()
{
using (var sha256 = new SHA256Managed())
{
var strings = new[] { Str1, Str2, Str3, Str4 };
for (int i = 0; i < strings.Length; i++)
{
string str = strings[i];
int length = str != null ? str.Length : -1;
byte[] length2 = BitConverter.GetBytes(length);
sha256.TransformBlock(length2, 0, length2.Length, length2, 0);
if (str != null)
{
byte[] sortKeyBytes = CultureInfo.InvariantCulture.CompareInfo.GetSortKey(str, CompareOptions.IgnoreCase).KeyData;
sha256.TransformBlock(sortKeyBytes, 0, sortKeyBytes.Length, sortKeyBytes, 0);
}
}
sha256.TransformFinalBlock(new byte[0], 0, 0);
byte[] hash = sha256.Hash;
return(hash);
}
}
public static void PrintHashMultiBlock(byte[] input, int size)
{
SHA256Managed sha = new SHA256Managed();
int offset = 0;
while (input.Length - offset >= size)
{
offset += sha.TransformBlock(input, offset, size, input, offset);
}
sha.TransformFinalBlock(input, offset, input.Length - offset);
Console.WriteLine("MultiBlock {0:00}: {1}", size, BytesToStr(sha.Hash));
}
public static UInt256 ComputeHash(IChainState chainState)
{
using (var sha256 = new SHA256Managed())
{
// add each unspent tx to hash
foreach (var unspentTx in chainState.ReadUnspentTransactions())
{
var unspentTxBytes = DataEncoder.EncodeUnspentTx(unspentTx);
sha256.TransformBlock(unspentTxBytes, 0, unspentTxBytes.Length, unspentTxBytes, 0);
}
// finalize hash
sha256.TransformFinalBlock(new byte[0], 0, 0);
// hash again to return double-hashed utxo committment
return(new UInt256(SHA256Static.ComputeHash(sha256.Hash)));
}
}
public static string Calculate_Hash(string fileName)
{
long read = 0;
var r = -1;
const long bytesToRead = 100 * 1024 * 1024;
const int bufferSize = 4096;
var buffer = new byte[bufferSize];
var sha = new SHA256Managed();
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
while (read <= bytesToRead && r != 0)
{
read += r = stream.Read(buffer, 0, bufferSize);
sha.TransformBlock(buffer, 0, r, null, 0);
}
}
sha.TransformFinalBlock(buffer, 0, 0);
return(string.Join("", sha.Hash.Select(x => x.ToString("x2"))));
}
private void sha256Hash_DoWork(object sender, DoWorkEventArgs e)
{
string[] arg = e.Argument as string[];
SHA256Managed sha = new SHA256Managed();
using (FileStream fs = File.OpenRead(arg[0]))
{
byte[] data = new byte[1024 * 1024];
int len = fs.Read(data, 0, data.Length);
while (fs.Position < fs.Length)
{
sha256Hash.ReportProgress(Convert.ToInt32(fs.Position * 100 / fs.Length) + 1);
sha.TransformBlock(data, 0, len, data, 0);
len = fs.Read(data, 0, data.Length);
}
sha.TransformFinalBlock(data, 0, len);
}
e.Result = new string[] { BitConverter.ToString(sha.Hash).Replace("-", String.Empty), arg[1] };
}
public static string GetSha256Hash_IEnumerable(IEnumerable <byte[]> fileChunks, ulong fileSize)
{
string result = string.Empty;
try
{
using (SHA256Managed hashAlgorithm = new SHA256Managed())
{
foreach (byte[] chunk in fileChunks)
{
hashAlgorithm.TransformBlock(chunk, 0, chunk.Length, null, 0);
}
hashAlgorithm.TransformFinalBlock(new byte[0], 0, 0);
result = ByteArrayConverter.ToHexString(hashAlgorithm.Hash);
}
}
catch
{ }
return(result);
}
/// <summary>
/// Creates a name-based UUID using the algorithm from RFC 4122 §4.3.
/// </summary>
/// <param name="namespaceId">The ID of the namespace.</param>
/// <param name="name">The name (within that namespace).</param>
/// <param name="version">The version number of the UUID to create; this value must be either
/// <returns>A UUID derived from the namespace and name.</returns>
public static Guid CreateGuid(Guid namespaceId, string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
// convert the name to a sequence of octets (as defined by the standard or conventions of its namespace) (step 3)
// ASSUME: UTF-8 encoding is always appropriate
byte[] nameBytes = Encoding.UTF8.GetBytes(name);
// convert the namespace UUID to network order (step 3)
byte[] namespaceBytes = namespaceId.ToByteArray();
SwapByteOrder(namespaceBytes);
// compute the hash of the name space ID concatenated with the name (step 4)
byte[] hash = namespaceId.ToByteArray();
using (SHA256 algorithm = new SHA256Managed())
{
algorithm.TransformBlock(namespaceBytes, 0, namespaceBytes.Length, hash, 0);
algorithm.TransformFinalBlock(nameBytes, 0, nameBytes.Length);
hash = algorithm.Hash;
}
// most bytes from the hash are copied straight to the bytes of the new GUID (steps 5-7, 9, 11-12)
byte[] newGuid = new byte[16];
Array.Copy(hash, 0, newGuid, 0, 16);
// set the four most significant bits (bits 12 through 15) of the time_hi_and_version field to the appropriate 4-bit version number from Section 4.1.3 (step 8)
newGuid[6] = (byte)((newGuid[6] & 0x0F) | (5 << 4));
// set the two most significant bits (bits 6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively (step 10)
newGuid[8] = (byte)((newGuid[8] & 0x3F) | 0x80);
// convert the resulting UUID to local byte order (step 13)
SwapByteOrder(newGuid);
return(new Guid(newGuid));
}
public void Partial()
{
var data = "Some random stuff for testing purposes.".ASCIIToBytes();
KzUInt256 h1;
KzUInt256 h2;
KzUInt256 refonce;
KzUInt256 reftwice;
using (var alg = new SHA256Managed()) {
alg.TransformFinalBlock(data, 0, data.Length);
refonce = h1 = alg.Hash.ToKzUInt256();
alg.TransformFinalBlock(data, 0, data.Length);
h2 = alg.Hash.ToKzUInt256();
Assert.Equal(h1, h2);
alg.TransformFinalBlock(h1.ToBytes(), 0, 32);
reftwice = alg.Hash.ToKzUInt256();
}
using (var alg = new SHA256Managed()) {
alg.TransformBlock(data, 0, data.Length - 12, null, 0);
alg.TransformFinalBlock(data, data.Length - 12, 12);
h1 = alg.Hash.ToKzUInt256();
Assert.Equal(refonce, h1);
}
using (var alg = new SHA256Managed()) {
alg.TransformBlock(data, 0, data.Length, null, 0);
alg.TransformFinalBlock(data, 0, 0);
h1 = alg.Hash.ToKzUInt256();
Assert.Equal(refonce, h1);
}
using (var hw = new KzWriterHash()) {
hw.Add(data[..12]);
public byte[] GenerateMAVLinkPacket20(MAVLINK_MSG_ID messageType, object indata, bool sign = false)
{
byte[] data;
data = MavlinkUtil.StructureToByteArray(indata);
MavlinkUtil.trim_payload(ref data);
int extra = 0;
if (sign)
extra = MAVLINK_SIGNATURE_BLOCK_LEN;
byte[] packet = new byte[data.Length + MAVLINK_NUM_NON_PAYLOAD_BYTES + extra];
packet[0] = MAVLINK_STX;
packet[1] = (byte)data.Length;
packet[2] = 0;//incompat signing
if (sign)
packet[2] |= MAVLINK_IFLAG_SIGNED;
packet[3] = 0;//compat
packet[4] = (byte)packetcount;
packetcount++;
packet[5] = 255; // this is always 255 - MYGCS
packet[6] = (byte)MAV_COMPONENT.MAV_COMP_ID_MISSIONPLANNER;
packet[7] = (byte)((UInt32)messageType);
packet[8] = (byte)((UInt32)messageType >> 8);
packet[9] = (byte)((UInt32)messageType >> 16);
int i = MAVLINK_NUM_HEADER_BYTES;
foreach (byte b in data)
{
packet[i] = b;
i++;
}
ushort checksum = MavlinkCRC.crc_calculate(packet, data.Length + MAVLINK_NUM_HEADER_BYTES);
checksum = MavlinkCRC.crc_accumulate(MAVLINK_MESSAGE_INFOS.GetMessageInfo((uint)messageType).crc, checksum);
byte ck_a = (byte)(checksum & 0xFF); ///< High byte
byte ck_b = (byte)(checksum >> 8); ///< Low byte
packet[i] = ck_a;
i += 1;
packet[i] = ck_b;
i += 1;
if (sign)
{
//https://docs.google.com/document/d/1ETle6qQRcaNWAmpG2wz0oOpFKSF_bcTmYMQvtTGI8ns/edit
/*
8 bits of link ID
48 bits of timestamp
48 bits of signature
*/
// signature = sha256_48(secret_key + header + payload + CRC + link-ID + timestamp)
var timestamp = (UInt64)((DateTime.UtcNow - new DateTime(2015, 1, 1)).TotalMilliseconds * 100);
if (timestamp == lasttimestamp)
timestamp++;
lasttimestamp = timestamp;
var timebytes = BitConverter.GetBytes(timestamp);
var sig = new byte[7]; // 13 includes the outgoing hash
sig[0] = sendlinkid;
Array.Copy(timebytes, 0, sig, 1, 6); // timestamp
//Console.WriteLine("gen linkid {0}, time {1} {2} {3} {4} {5} {6} {7}", sig[0], sig[1], sig[2], sig[3], sig[4], sig[5], sig[6], timestamp);
if (signingKey == null || signingKey.Length != 32)
{
signingKey = new byte[32];
}
using (SHA256Managed signit = new SHA256Managed())
{
signit.TransformBlock(signingKey, 0, signingKey.Length, null, 0);
signit.TransformBlock(packet, 0, i, null, 0);
signit.TransformFinalBlock(sig, 0, sig.Length);
var ctx = signit.Hash;
// trim to 48
Array.Resize(ref ctx, 6);
foreach (byte b in sig)
{
packet[i] = b;
i++;
}
foreach (byte b in ctx)
{
packet[i] = b;
i++;
}
}
}
return packet;
}