init commit
This commit is contained in:
@@ -0,0 +1,385 @@
|
||||
using System;
|
||||
using Org.BouncyCastle.Crypto.Utilities;
|
||||
using Org.BouncyCastle.Utilities;
|
||||
|
||||
namespace Org.BouncyCastle.Crypto.Digests;
|
||||
|
||||
public class Blake2sDigest : IDigest
|
||||
{
|
||||
private const int ROUNDS = 10;
|
||||
|
||||
private const int BLOCK_LENGTH_BYTES = 64;
|
||||
|
||||
private static readonly uint[] blake2s_IV = new uint[8] { 1779033703u, 3144134277u, 1013904242u, 2773480762u, 1359893119u, 2600822924u, 528734635u, 1541459225u };
|
||||
|
||||
private static readonly byte[,] blake2s_sigma = new byte[10, 16]
|
||||
{
|
||||
{
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
|
||||
10, 11, 12, 13, 14, 15
|
||||
},
|
||||
{
|
||||
14, 10, 4, 8, 9, 15, 13, 6, 1, 12,
|
||||
0, 2, 11, 7, 5, 3
|
||||
},
|
||||
{
|
||||
11, 8, 12, 0, 5, 2, 15, 13, 10, 14,
|
||||
3, 6, 7, 1, 9, 4
|
||||
},
|
||||
{
|
||||
7, 9, 3, 1, 13, 12, 11, 14, 2, 6,
|
||||
5, 10, 4, 0, 15, 8
|
||||
},
|
||||
{
|
||||
9, 0, 5, 7, 2, 4, 10, 15, 14, 1,
|
||||
11, 12, 6, 8, 3, 13
|
||||
},
|
||||
{
|
||||
2, 12, 6, 10, 0, 11, 8, 3, 4, 13,
|
||||
7, 5, 15, 14, 1, 9
|
||||
},
|
||||
{
|
||||
12, 5, 1, 15, 14, 13, 4, 10, 0, 7,
|
||||
6, 3, 9, 2, 8, 11
|
||||
},
|
||||
{
|
||||
13, 11, 7, 14, 12, 1, 3, 9, 5, 0,
|
||||
15, 4, 8, 6, 2, 10
|
||||
},
|
||||
{
|
||||
6, 15, 14, 9, 11, 3, 0, 8, 12, 2,
|
||||
13, 7, 1, 4, 10, 5
|
||||
},
|
||||
{
|
||||
10, 2, 8, 4, 7, 6, 1, 5, 15, 11,
|
||||
9, 14, 3, 12, 13, 0
|
||||
}
|
||||
};
|
||||
|
||||
private int digestLength = 32;
|
||||
|
||||
private int keyLength = 0;
|
||||
|
||||
private byte[] salt = null;
|
||||
|
||||
private byte[] personalization = null;
|
||||
|
||||
private byte[] key = null;
|
||||
|
||||
private byte[] buffer = null;
|
||||
|
||||
private int bufferPos = 0;
|
||||
|
||||
private uint[] internalState = new uint[16];
|
||||
|
||||
private uint[] chainValue = null;
|
||||
|
||||
private uint t0 = 0u;
|
||||
|
||||
private uint t1 = 0u;
|
||||
|
||||
private uint f0 = 0u;
|
||||
|
||||
public virtual string AlgorithmName => "BLAKE2s";
|
||||
|
||||
public Blake2sDigest()
|
||||
: this(256)
|
||||
{
|
||||
}
|
||||
|
||||
public Blake2sDigest(Blake2sDigest digest)
|
||||
{
|
||||
bufferPos = digest.bufferPos;
|
||||
buffer = Arrays.Clone(digest.buffer);
|
||||
keyLength = digest.keyLength;
|
||||
key = Arrays.Clone(digest.key);
|
||||
digestLength = digest.digestLength;
|
||||
chainValue = Arrays.Clone(digest.chainValue);
|
||||
personalization = Arrays.Clone(digest.personalization);
|
||||
}
|
||||
|
||||
public Blake2sDigest(int digestBits)
|
||||
{
|
||||
if (digestBits < 8 || digestBits > 256 || digestBits % 8 != 0)
|
||||
{
|
||||
throw new ArgumentException("BLAKE2s digest bit length must be a multiple of 8 and not greater than 256");
|
||||
}
|
||||
buffer = new byte[64];
|
||||
keyLength = 0;
|
||||
digestLength = digestBits / 8;
|
||||
Init();
|
||||
}
|
||||
|
||||
public Blake2sDigest(byte[] key)
|
||||
{
|
||||
buffer = new byte[64];
|
||||
if (key != null)
|
||||
{
|
||||
if (key.Length > 32)
|
||||
{
|
||||
throw new ArgumentException("Keys > 32 are not supported");
|
||||
}
|
||||
this.key = new byte[key.Length];
|
||||
Array.Copy(key, 0, this.key, 0, key.Length);
|
||||
keyLength = key.Length;
|
||||
Array.Copy(key, 0, buffer, 0, key.Length);
|
||||
bufferPos = 64;
|
||||
}
|
||||
digestLength = 32;
|
||||
Init();
|
||||
}
|
||||
|
||||
public Blake2sDigest(byte[] key, int digestBytes, byte[] salt, byte[] personalization)
|
||||
{
|
||||
if (digestBytes < 1 || digestBytes > 32)
|
||||
{
|
||||
throw new ArgumentException("Invalid digest length (required: 1 - 32)");
|
||||
}
|
||||
digestLength = digestBytes;
|
||||
buffer = new byte[64];
|
||||
if (salt != null)
|
||||
{
|
||||
if (salt.Length != 8)
|
||||
{
|
||||
throw new ArgumentException("Salt length must be exactly 8 bytes");
|
||||
}
|
||||
this.salt = new byte[8];
|
||||
Array.Copy(salt, 0, this.salt, 0, salt.Length);
|
||||
}
|
||||
if (personalization != null)
|
||||
{
|
||||
if (personalization.Length != 8)
|
||||
{
|
||||
throw new ArgumentException("Personalization length must be exactly 8 bytes");
|
||||
}
|
||||
this.personalization = new byte[8];
|
||||
Array.Copy(personalization, 0, this.personalization, 0, personalization.Length);
|
||||
}
|
||||
if (key != null)
|
||||
{
|
||||
if (key.Length > 32)
|
||||
{
|
||||
throw new ArgumentException("Keys > 32 bytes are not supported");
|
||||
}
|
||||
this.key = new byte[key.Length];
|
||||
Array.Copy(key, 0, this.key, 0, key.Length);
|
||||
keyLength = key.Length;
|
||||
Array.Copy(key, 0, buffer, 0, key.Length);
|
||||
bufferPos = 64;
|
||||
}
|
||||
Init();
|
||||
}
|
||||
|
||||
private void Init()
|
||||
{
|
||||
if (chainValue == null)
|
||||
{
|
||||
chainValue = new uint[8];
|
||||
chainValue[0] = blake2s_IV[0] ^ (uint)(digestLength | (keyLength << 8) | 0x1010000);
|
||||
chainValue[1] = blake2s_IV[1];
|
||||
chainValue[2] = blake2s_IV[2];
|
||||
chainValue[3] = blake2s_IV[3];
|
||||
chainValue[4] = blake2s_IV[4];
|
||||
chainValue[5] = blake2s_IV[5];
|
||||
if (salt != null)
|
||||
{
|
||||
uint[] array;
|
||||
(array = chainValue)[4] = array[4] ^ Pack.LE_To_UInt32(salt, 0);
|
||||
(array = chainValue)[5] = array[5] ^ Pack.LE_To_UInt32(salt, 4);
|
||||
}
|
||||
chainValue[6] = blake2s_IV[6];
|
||||
chainValue[7] = blake2s_IV[7];
|
||||
if (personalization != null)
|
||||
{
|
||||
uint[] array;
|
||||
(array = chainValue)[6] = array[6] ^ Pack.LE_To_UInt32(personalization, 0);
|
||||
(array = chainValue)[7] = array[7] ^ Pack.LE_To_UInt32(personalization, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void InitializeInternalState()
|
||||
{
|
||||
Array.Copy(chainValue, 0, internalState, 0, chainValue.Length);
|
||||
Array.Copy(blake2s_IV, 0, internalState, chainValue.Length, 4);
|
||||
internalState[12] = t0 ^ blake2s_IV[4];
|
||||
internalState[13] = t1 ^ blake2s_IV[5];
|
||||
internalState[14] = f0 ^ blake2s_IV[6];
|
||||
internalState[15] = blake2s_IV[7];
|
||||
}
|
||||
|
||||
public virtual void Update(byte b)
|
||||
{
|
||||
if (64 - bufferPos == 0)
|
||||
{
|
||||
t0 += 64u;
|
||||
if (t0 == 0)
|
||||
{
|
||||
t1++;
|
||||
}
|
||||
Compress(buffer, 0);
|
||||
Array.Clear(buffer, 0, buffer.Length);
|
||||
buffer[0] = b;
|
||||
bufferPos = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
buffer[bufferPos] = b;
|
||||
bufferPos++;
|
||||
}
|
||||
}
|
||||
|
||||
public virtual void BlockUpdate(byte[] message, int offset, int len)
|
||||
{
|
||||
if (message == null || len == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
int num = 0;
|
||||
if (bufferPos != 0)
|
||||
{
|
||||
num = 64 - bufferPos;
|
||||
if (num >= len)
|
||||
{
|
||||
Array.Copy(message, offset, buffer, bufferPos, len);
|
||||
bufferPos += len;
|
||||
return;
|
||||
}
|
||||
Array.Copy(message, offset, buffer, bufferPos, num);
|
||||
t0 += 64u;
|
||||
if (t0 == 0)
|
||||
{
|
||||
t1++;
|
||||
}
|
||||
Compress(buffer, 0);
|
||||
bufferPos = 0;
|
||||
Array.Clear(buffer, 0, buffer.Length);
|
||||
}
|
||||
int num2 = offset + len - 64;
|
||||
int i;
|
||||
for (i = offset + num; i < num2; i += 64)
|
||||
{
|
||||
t0 += 64u;
|
||||
if (t0 == 0)
|
||||
{
|
||||
t1++;
|
||||
}
|
||||
Compress(message, i);
|
||||
}
|
||||
Array.Copy(message, i, buffer, 0, offset + len - i);
|
||||
bufferPos += offset + len - i;
|
||||
}
|
||||
|
||||
public virtual int DoFinal(byte[] output, int outOffset)
|
||||
{
|
||||
f0 = uint.MaxValue;
|
||||
t0 += (uint)bufferPos;
|
||||
if (t0 < 0 && bufferPos > 0L - (long)t0)
|
||||
{
|
||||
t1++;
|
||||
}
|
||||
Compress(buffer, 0);
|
||||
Array.Clear(buffer, 0, buffer.Length);
|
||||
Array.Clear(internalState, 0, internalState.Length);
|
||||
for (int i = 0; i < chainValue.Length && i * 4 < digestLength; i++)
|
||||
{
|
||||
byte[] sourceArray = Pack.UInt32_To_LE(chainValue[i]);
|
||||
if (i * 4 < digestLength - 4)
|
||||
{
|
||||
Array.Copy(sourceArray, 0, output, outOffset + i * 4, 4);
|
||||
}
|
||||
else
|
||||
{
|
||||
Array.Copy(sourceArray, 0, output, outOffset + i * 4, digestLength - i * 4);
|
||||
}
|
||||
}
|
||||
Array.Clear(chainValue, 0, chainValue.Length);
|
||||
Reset();
|
||||
return digestLength;
|
||||
}
|
||||
|
||||
public virtual void Reset()
|
||||
{
|
||||
bufferPos = 0;
|
||||
f0 = 0u;
|
||||
t0 = 0u;
|
||||
t1 = 0u;
|
||||
chainValue = null;
|
||||
Array.Clear(buffer, 0, buffer.Length);
|
||||
if (key != null)
|
||||
{
|
||||
Array.Copy(key, 0, buffer, 0, key.Length);
|
||||
bufferPos = 64;
|
||||
}
|
||||
Init();
|
||||
}
|
||||
|
||||
private void Compress(byte[] message, int messagePos)
|
||||
{
|
||||
InitializeInternalState();
|
||||
uint[] array = new uint[16];
|
||||
for (int i = 0; i < 16; i++)
|
||||
{
|
||||
array[i] = Pack.LE_To_UInt32(message, messagePos + i * 4);
|
||||
}
|
||||
for (int j = 0; j < 10; j++)
|
||||
{
|
||||
G(array[blake2s_sigma[j, 0]], array[blake2s_sigma[j, 1]], 0, 4, 8, 12);
|
||||
G(array[blake2s_sigma[j, 2]], array[blake2s_sigma[j, 3]], 1, 5, 9, 13);
|
||||
G(array[blake2s_sigma[j, 4]], array[blake2s_sigma[j, 5]], 2, 6, 10, 14);
|
||||
G(array[blake2s_sigma[j, 6]], array[blake2s_sigma[j, 7]], 3, 7, 11, 15);
|
||||
G(array[blake2s_sigma[j, 8]], array[blake2s_sigma[j, 9]], 0, 5, 10, 15);
|
||||
G(array[blake2s_sigma[j, 10]], array[blake2s_sigma[j, 11]], 1, 6, 11, 12);
|
||||
G(array[blake2s_sigma[j, 12]], array[blake2s_sigma[j, 13]], 2, 7, 8, 13);
|
||||
G(array[blake2s_sigma[j, 14]], array[blake2s_sigma[j, 15]], 3, 4, 9, 14);
|
||||
}
|
||||
for (int k = 0; k < chainValue.Length; k++)
|
||||
{
|
||||
chainValue[k] = chainValue[k] ^ internalState[k] ^ internalState[k + 8];
|
||||
}
|
||||
}
|
||||
|
||||
private void G(uint m1, uint m2, int posA, int posB, int posC, int posD)
|
||||
{
|
||||
internalState[posA] = internalState[posA] + internalState[posB] + m1;
|
||||
internalState[posD] = rotr32(internalState[posD] ^ internalState[posA], 16);
|
||||
internalState[posC] += internalState[posD];
|
||||
internalState[posB] = rotr32(internalState[posB] ^ internalState[posC], 12);
|
||||
internalState[posA] = internalState[posA] + internalState[posB] + m2;
|
||||
internalState[posD] = rotr32(internalState[posD] ^ internalState[posA], 8);
|
||||
internalState[posC] += internalState[posD];
|
||||
internalState[posB] = rotr32(internalState[posB] ^ internalState[posC], 7);
|
||||
}
|
||||
|
||||
private uint rotr32(uint x, int rot)
|
||||
{
|
||||
return (x >> rot) | (x << -rot);
|
||||
}
|
||||
|
||||
public virtual int GetDigestSize()
|
||||
{
|
||||
return digestLength;
|
||||
}
|
||||
|
||||
public virtual int GetByteLength()
|
||||
{
|
||||
return 64;
|
||||
}
|
||||
|
||||
public virtual void ClearKey()
|
||||
{
|
||||
if (key != null)
|
||||
{
|
||||
Array.Clear(key, 0, key.Length);
|
||||
Array.Clear(buffer, 0, buffer.Length);
|
||||
}
|
||||
}
|
||||
|
||||
public virtual void ClearSalt()
|
||||
{
|
||||
if (salt != null)
|
||||
{
|
||||
Array.Clear(salt, 0, salt.Length);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user