/// <summary>
/// Compute hash from message source
/// </summary>
/// <param name="source">Stream or buffer</param>
/// <returns>Hash computed</returns>
public byte[] Compute(MessageToHashReader source)
{
// INIT
// Init hash buffer
UInt64[,] hashState = new UInt64[8, 2];
for (int row = 0; row < 8; row++)
{
hashState[row, 0] = this._initState[row, 0];
hashState[row, 1] = this._initState[row, 1];
}
// UPDATE
// Transform complete blocks
byte[] buffer = new byte[BUFFER_LEN];
ulong blockCount = 0;
long allBytesRead = 0;
int bytesRead;
while ((bytesRead = source.Read(buffer, 0, BUFFER_LEN)) == BUFFER_LEN)
{
allBytesRead += bytesRead;
Compress(hashState, buffer);
blockCount++;
}
allBytesRead += bytesRead;
ulong bitCount = (ulong)(allBytesRead << 3);
// FINAL
ulong bitPadding = 384 + (ulong)((((-(long)bitCount) % 512) + 512) % 512);
ulong totalBlocks = (bitCount + bitPadding + 128) / 512;
int blocksLeft = (int)(totalBlocks - blockCount);
// 0x80 tail and zero padding
buffer[bytesRead] = 0x80;
for (int p = bytesRead + 1; p < BUFFER_LEN; p++)
{
buffer[p] = 0x00;
}
// Process extra blocks
if (blocksLeft > 1) // if two extra blocks
{
Compress(hashState, buffer);
buffer = new byte[BUFFER_LEN];
}
// last extra block
{
byte[] bytes = BitConverter.GetBytes(bitCount);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(bytes);
}
Buffer.BlockCopy(bytes, 0, buffer, BUFFER_LEN - 8, 8);
Compress(hashState, buffer);
}
var result = PlainHash(hashState);
return(result);
}
public byte[] Compute(MessageToHashReader source)
{
// INIT
// Init hash variables (in derivate class)
var bufferLength = this._bufferLength;
InitState(out ISha2State hashState);
// UPDATE
// Transform complete blocks
byte[] buffer = new byte[bufferLength];
UInt64 blockCount = 0;
int bytesRead;
while ((bytesRead = source.Read(buffer, 0, bufferLength)) == bufferLength)
{
Compress(hashState, buffer);
blockCount++;
}
UInt64 bitLength = ((blockCount * (UInt64)bufferLength) + (UInt64)bytesRead) << 3;
// FINAL
// Calc extra blocks
int blocksLeft = 1;
if ((bytesRead + 1 + (bufferLength >> 3)) > bufferLength)
{
blocksLeft++;
}
// 0x80 tail and zero padding
buffer[bytesRead] = 0x80;
for (int p = bytesRead + 1; p < bufferLength; p++)
{
buffer[p] = 0x00;
}
// Process extra blocks
if (blocksLeft > 1) // if two extra blocks
{
Compress(hashState, buffer);
buffer = new byte[bufferLength];
}
// last extra block
{
byte[] length = BitConverter.GetBytes(bitLength);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(length);
}
Buffer.BlockCopy(length, 0, buffer, bufferLength - 8, 8);
Compress(hashState, buffer);
}
// Finalize hash and truncate (Output Transformation)
return(FinalHash(hashState));
}
/// <summary>
/// Compute hash from message source
/// </summary>
/// <param name="source">Stream or buffer</param>
/// <returns>Hash computed</returns>
public byte[] Compute(MessageToHashReader source)
{
// INIT
// Init hash buffer
var state = Init();
var bufferLength = this._bufferLength;
var remain = source.Length; // Skein needs to know data length
// UPDATE
// Transform complete blocks
byte[] buffer = new byte[bufferLength];
long allBytesRead = 0;
int bytesRead;
while (((bytesRead = source.Read(buffer, 0, bufferLength)) == bufferLength) &&
((remain -= bytesRead) > 0)) // This condition order enable full final block
{
allBytesRead += bytesRead;
Compress(ref state, buffer, (UInt64)allBytesRead);
}
allBytesRead += bytesRead;
// FINAL
// Process last block with data
state.Flags |= SkeinFlags.Final;
for (int p = bytesRead; p < bufferLength; p++) // fill with 0 rest of buffer
{
buffer[p] = 0x00;
}
Compress(ref state, buffer, (ulong)allBytesRead);
// Last block for extended hash (> buffer length)
state.Flags = SetType(BlockType.OUT, SkeinFlags.Final);
buffer = new byte[bufferLength];
Compress(ref state, buffer, 8);
// Format final hash
return(FinalHash(state));
}
/// <summary>
/// Compute hash from message source
/// </summary>
/// <param name="source">Stream or buffer</param>
/// <returns>Hash computed</returns>
public byte[] Compute(MessageToHashReader source)
{
// INIT
// Init hash variables (in derivate class)
var bufferLength = this._bufferLength;
InitState(out IBlakeState hashState);
// UPDATE
// Transform complete blocks
byte[] buffer = new byte[bufferLength];
UInt64 bitLength = 0;
UInt64 blockCount = 0;
int bytesRead;
while ((bytesRead = source.Read(buffer, 0, bufferLength)) == bufferLength)
{
bitLength += (UInt64)(bytesRead << 3);
Compress(hashState, buffer, bitLength);
blockCount++;
}
bitLength += (UInt64)(bytesRead << 3);
// FINAL
// Calc extra blocks
int bitWrap = bufferLength << 3;
//int finalBytes = bufferLength >> 3;
UInt64 bitPadding = (UInt64)((((-(long)bitLength - (bufferLength + 1)) % bitWrap) + bitWrap) % bitWrap);
UInt64 totalBlocks = (bitLength + bitPadding + ((UInt64)bufferLength + 1)) / (UInt64)bitWrap;
int blocksLeft = (int)(totalBlocks - blockCount);
// 0x80 tail and zero padding
buffer[bytesRead] = 0x80;
for (int p = bytesRead + 1; p < bufferLength; p++)
{
buffer[p] = 0x00;
}
// Process extra blocks
if (blocksLeft > 1) // if two extra blocks
{
Compress(hashState, buffer, bitLength);
buffer = new byte[bufferLength];
}
// last extra block
{
byte[] length = BitConverter.GetBytes((UInt64)bitLength);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(length);
}
Buffer.BlockCopy(length, 0, buffer, bufferLength - 8, 8);
buffer[bufferLength - (bufferLength >> 3) - 1] ^= this._finalXor;
if (blocksLeft == 2 || (blocksLeft == 1 && bytesRead == 0))
{
bitLength = 0;
}
Compress(hashState, buffer, bitLength);
}
// Finalize hash and truncate (Output Transformation)
return(FinalHash(hashState));
}
public byte[] Compute(MessageToHashReader source)
{
// INIT
// Init hash variables (in derivate class)
var bufferLength = this._bufferLength;
InitState(out IQmhHukState hashState);
// UPDATE
// Transform complete blocks
byte[] buffer = new byte[bufferLength];
UInt64 blockCount = 0;
int bytesRead;
while ((bytesRead = source.Read(buffer, 0, bufferLength)) == bufferLength)
{
Compress(hashState, buffer);
blockCount++;
}
UInt64 bitLength = ((blockCount * (UInt64)bufferLength) + (UInt64)bytesRead) << 3;
// FINAL
// Calc extra blocks
int blocksLeft = 1;
if ((bytesRead + 11) > bufferLength) // 11 = 1 (bit tail) + 2 (bit HASH len) + 8 (bit DATA len)
{
blocksLeft++;
}
// 0x80 tail and PI padding
buffer[bytesRead] = 0x80;
for (int p = bytesRead + 1, pi = 0; p < bufferLength; p++, pi++)
{
buffer[p] = PI_PADDING[pi];
}
// Process extra blocks
if (blocksLeft > 1) // if two extra blocks
{
Compress(hashState, buffer);
buffer = new byte[bufferLength];
Buffer.BlockCopy(PHI_PADDING, 0, buffer, 0, bufferLength);
}
// last extra block
{
// set HASH bitLen
buffer[bufferLength - 10] = _bitLenMark[0];
buffer[bufferLength - 9] = _bitLenMark[1];
// set DATA bitLen
byte[] length = BitConverter.GetBytes(bitLength);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(length);
}
Buffer.BlockCopy(length, 0, buffer, bufferLength - 8, 8);
Compress(hashState, buffer);
}
// Finalize hash and truncate (Output Transformation)
return(FinalHash(hashState));
}