public static void Initialize(SHA256 *instance)
{
instance->state[0] = 0x6a09e667;
instance->state[1] = 0xbb67ae85;
instance->state[2] = 0x3c6ef372;
instance->state[3] = 0xa54ff53a;
instance->state[4] = 0x510e527f;
instance->state[5] = 0x9b05688c;
instance->state[6] = 0x1f83d9ab;
instance->state[7] = 0x5be0cd19;
}
public static void Update(SHA256 *instance, byte *buffer, int sz)
{
for (int i = 0; i < sz; ++i)
{
instance->data[instance->datalen] = buffer[i];
instance->datalen++;
if (instance->datalen == 64)
{
Transform(instance);
instance->bitlen += 512;
instance->datalen = 0;
}
}
}
public static void Final(SHA256 *instance, NativeArray <byte> hash)
{
int i = instance->datalen;
if (instance->datalen < 56)
{
instance->data[i++] = 0x80;
while (i < 56)
{
instance->data[i++] = 0x00;
}
}
else
{
instance->data[i++] = 0x80;
while (i < 64)
{
instance->data[i++] = 0x00;
}
Transform(instance);
}
instance->bitlen += (ulong)instance->datalen * 8;
instance->data[63] = (byte)(instance->bitlen);
instance->data[62] = (byte)(instance->bitlen >> 8);
instance->data[61] = (byte)(instance->bitlen >> 16);
instance->data[60] = (byte)(instance->bitlen >> 24);
instance->data[59] = (byte)(instance->bitlen >> 32);
instance->data[58] = (byte)(instance->bitlen >> 40);
instance->data[57] = (byte)(instance->bitlen >> 48);
instance->data[56] = (byte)(instance->bitlen >> 56);
Transform(instance);
for (i = 0; i < 4; ++i)
{
hash[i] = (byte)(((instance->state[0]) >> (int)(24 - i * 8)) & 0x000000ff);
hash[i + 4] = (byte)(((instance->state[1]) >> (int)(24 - i * 8)) & 0x000000ff);
hash[i + 8] = (byte)(((instance->state[2]) >> (int)(24 - i * 8)) & 0x000000ff);
hash[i + 12] = (byte)((instance->state[3] >> (int)(24 - i * 8)) & 0x000000ff);
hash[i + 16] = (byte)((instance->state[4] >> (int)(24 - i * 8)) & 0x000000ff);
hash[i + 20] = (byte)((instance->state[5] >> (int)(24 - i * 8)) & 0x000000ff);
hash[i + 24] = (byte)((instance->state[6] >> (int)(24 - i * 8)) & 0x000000ff);
hash[i + 28] = (byte)((instance->state[7] >> (int)(24 - i * 8)) & 0x000000ff);
}
}
private static void Transform(SHA256 *instance)
{
uint a, b, c, d, e, f, g, h, i, j, t1, t2;
var m = stackalloc uint[64];
for (i = 0, j = 0; i < 16; ++i, j += 4)
{
m[i] = (uint)((instance->data[(int)j] << 24) | (instance->data[(int)j + 1] << 16) | (instance->data[(int)j + 2] << 8) | (instance->data[(int)j + 3]));
}
for (; i < 64; ++i)
{
m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
}
a = instance->state[0];
b = instance->state[1];
c = instance->state[2];
d = instance->state[3];
e = instance->state[4];
f = instance->state[5];
g = instance->state[6];
h = instance->state[7];
for (i = 0; i < 64; ++i)
{
t1 = h + EP1(e) + CH(e, f, g) + k[i] + m[i];
t2 = EP0(a) + MAJ(a, b, c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
instance->state[0] += a;
instance->state[1] += b;
instance->state[2] += c;
instance->state[3] += d;
instance->state[4] += e;
instance->state[5] += f;
instance->state[6] += g;
instance->state[7] += h;
}
