niko
297 lines
8.6 KiB
C#
297 lines
8.6 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace System.Security.Cryptography
|
|
{
|
|
/// <summary>Computes the <see cref="T:System.Security.Cryptography.SHA512" /> hash algorithm for the input data using the managed library.</summary>
|
|
// Token: 0x02000533 RID: 1331
|
|
[ComVisible(true)]
|
|
public class SHA512Managed : SHA512
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.SHA512Managed" /> class.</summary>
|
|
/// <exception cref="T:System.InvalidOperationException">The Federal Information Processing Standards (FIPS) security setting is enabled. This implementation is not part of the Windows Platform FIPS-validated cryptographic algorithms.</exception>
|
|
// Token: 0x060030BB RID: 12475 RVA: 0x000A7740 File Offset: 0x000A5940
|
|
public SHA512Managed()
|
|
{
|
|
this.xBuf = new byte[8];
|
|
this.W = new ulong[80];
|
|
this.Initialize(false);
|
|
}
|
|
|
|
// Token: 0x060030BC RID: 12476 RVA: 0x000A7774 File Offset: 0x000A5974
|
|
private void Initialize(bool reuse)
|
|
{
|
|
this.H1 = 7640891576956012808UL;
|
|
this.H2 = 13503953896175478587UL;
|
|
this.H3 = 4354685564936845355UL;
|
|
this.H4 = 11912009170470909681UL;
|
|
this.H5 = 5840696475078001361UL;
|
|
this.H6 = 11170449401992604703UL;
|
|
this.H7 = 2270897969802886507UL;
|
|
this.H8 = 6620516959819538809UL;
|
|
if (reuse)
|
|
{
|
|
this.byteCount1 = 0UL;
|
|
this.byteCount2 = 0UL;
|
|
this.xBufOff = 0;
|
|
for (int i = 0; i < this.xBuf.Length; i++)
|
|
{
|
|
this.xBuf[i] = 0;
|
|
}
|
|
this.wOff = 0;
|
|
for (int num = 0; num != this.W.Length; num++)
|
|
{
|
|
this.W[num] = 0UL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Initializes an instance of the <see cref="T:System.Security.Cryptography.SHA512Managed" /> class using the managed library.</summary>
|
|
// Token: 0x060030BD RID: 12477 RVA: 0x000A7864 File Offset: 0x000A5A64
|
|
public override void Initialize()
|
|
{
|
|
this.Initialize(true);
|
|
}
|
|
|
|
/// <summary>When overridden in a derived class, routes data written to the object into the <see cref="T:System.Security.Cryptography.SHA512Managed" /> hash algorithm for computing the hash.</summary>
|
|
/// <param name="rgb">The input data. </param>
|
|
/// <param name="ibStart">The offset into the byte array from which to begin using data. </param>
|
|
/// <param name="cbSize">The number of bytes in the array to use as data. </param>
|
|
// Token: 0x060030BE RID: 12478 RVA: 0x000A7870 File Offset: 0x000A5A70
|
|
protected override void HashCore(byte[] rgb, int ibStart, int cbSize)
|
|
{
|
|
while (this.xBufOff != 0 && cbSize > 0)
|
|
{
|
|
this.update(rgb[ibStart]);
|
|
ibStart++;
|
|
cbSize--;
|
|
}
|
|
while (cbSize > this.xBuf.Length)
|
|
{
|
|
this.processWord(rgb, ibStart);
|
|
ibStart += this.xBuf.Length;
|
|
cbSize -= this.xBuf.Length;
|
|
this.byteCount1 += (ulong)((long)this.xBuf.Length);
|
|
}
|
|
while (cbSize > 0)
|
|
{
|
|
this.update(rgb[ibStart]);
|
|
ibStart++;
|
|
cbSize--;
|
|
}
|
|
}
|
|
|
|
/// <summary>When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.</summary>
|
|
/// <returns>The computed hash code.</returns>
|
|
// Token: 0x060030BF RID: 12479 RVA: 0x000A7910 File Offset: 0x000A5B10
|
|
protected override byte[] HashFinal()
|
|
{
|
|
this.adjustByteCounts();
|
|
ulong num = this.byteCount1 << 3;
|
|
ulong num2 = this.byteCount2;
|
|
this.update(128);
|
|
while (this.xBufOff != 0)
|
|
{
|
|
this.update(0);
|
|
}
|
|
this.processLength(num, num2);
|
|
this.processBlock();
|
|
byte[] array = new byte[64];
|
|
this.unpackWord(this.H1, array, 0);
|
|
this.unpackWord(this.H2, array, 8);
|
|
this.unpackWord(this.H3, array, 16);
|
|
this.unpackWord(this.H4, array, 24);
|
|
this.unpackWord(this.H5, array, 32);
|
|
this.unpackWord(this.H6, array, 40);
|
|
this.unpackWord(this.H7, array, 48);
|
|
this.unpackWord(this.H8, array, 56);
|
|
this.Initialize();
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060030C0 RID: 12480 RVA: 0x000A79E8 File Offset: 0x000A5BE8
|
|
private void update(byte input)
|
|
{
|
|
this.xBuf[this.xBufOff++] = input;
|
|
if (this.xBufOff == this.xBuf.Length)
|
|
{
|
|
this.processWord(this.xBuf, 0);
|
|
this.xBufOff = 0;
|
|
}
|
|
this.byteCount1 += 1UL;
|
|
}
|
|
|
|
// Token: 0x060030C1 RID: 12481 RVA: 0x000A7A44 File Offset: 0x000A5C44
|
|
private void processWord(byte[] input, int inOff)
|
|
{
|
|
this.W[this.wOff++] = ((ulong)input[inOff] << 56) | ((ulong)input[inOff + 1] << 48) | ((ulong)input[inOff + 2] << 40) | ((ulong)input[inOff + 3] << 32) | ((ulong)input[inOff + 4] << 24) | ((ulong)input[inOff + 5] << 16) | ((ulong)input[inOff + 6] << 8) | (ulong)input[inOff + 7];
|
|
if (this.wOff == 16)
|
|
{
|
|
this.processBlock();
|
|
}
|
|
}
|
|
|
|
// Token: 0x060030C2 RID: 12482 RVA: 0x000A7AC8 File Offset: 0x000A5CC8
|
|
private void unpackWord(ulong word, byte[] output, int outOff)
|
|
{
|
|
output[outOff] = (byte)(word >> 56);
|
|
output[outOff + 1] = (byte)(word >> 48);
|
|
output[outOff + 2] = (byte)(word >> 40);
|
|
output[outOff + 3] = (byte)(word >> 32);
|
|
output[outOff + 4] = (byte)(word >> 24);
|
|
output[outOff + 5] = (byte)(word >> 16);
|
|
output[outOff + 6] = (byte)(word >> 8);
|
|
output[outOff + 7] = (byte)word;
|
|
}
|
|
|
|
// Token: 0x060030C3 RID: 12483 RVA: 0x000A7B20 File Offset: 0x000A5D20
|
|
private void adjustByteCounts()
|
|
{
|
|
if (this.byteCount1 > 2305843009213693951UL)
|
|
{
|
|
this.byteCount2 += this.byteCount1 >> 61;
|
|
this.byteCount1 &= 2305843009213693951UL;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060030C4 RID: 12484 RVA: 0x000A7B70 File Offset: 0x000A5D70
|
|
private void processLength(ulong lowW, ulong hiW)
|
|
{
|
|
if (this.wOff > 14)
|
|
{
|
|
this.processBlock();
|
|
}
|
|
this.W[14] = hiW;
|
|
this.W[15] = lowW;
|
|
}
|
|
|
|
// Token: 0x060030C5 RID: 12485 RVA: 0x000A7B9C File Offset: 0x000A5D9C
|
|
private void processBlock()
|
|
{
|
|
this.adjustByteCounts();
|
|
for (int i = 16; i <= 79; i++)
|
|
{
|
|
this.W[i] = this.Sigma1(this.W[i - 2]) + this.W[i - 7] + this.Sigma0(this.W[i - 15]) + this.W[i - 16];
|
|
}
|
|
ulong num = this.H1;
|
|
ulong num2 = this.H2;
|
|
ulong num3 = this.H3;
|
|
ulong num4 = this.H4;
|
|
ulong num5 = this.H5;
|
|
ulong num6 = this.H6;
|
|
ulong num7 = this.H7;
|
|
ulong num8 = this.H8;
|
|
for (int j = 0; j <= 79; j++)
|
|
{
|
|
ulong num9 = num8 + this.Sum1(num5) + this.Ch(num5, num6, num7) + SHAConstants.K2[j] + this.W[j];
|
|
ulong num10 = this.Sum0(num) + this.Maj(num, num2, num3);
|
|
num8 = num7;
|
|
num7 = num6;
|
|
num6 = num5;
|
|
num5 = num4 + num9;
|
|
num4 = num3;
|
|
num3 = num2;
|
|
num2 = num;
|
|
num = num9 + num10;
|
|
}
|
|
this.H1 += num;
|
|
this.H2 += num2;
|
|
this.H3 += num3;
|
|
this.H4 += num4;
|
|
this.H5 += num5;
|
|
this.H6 += num6;
|
|
this.H7 += num7;
|
|
this.H8 += num8;
|
|
this.wOff = 0;
|
|
for (int num11 = 0; num11 != this.W.Length; num11++)
|
|
{
|
|
this.W[num11] = 0UL;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060030C6 RID: 12486 RVA: 0x000A7D5C File Offset: 0x000A5F5C
|
|
private ulong rotateRight(ulong x, int n)
|
|
{
|
|
return (x >> n) | (x << 64 - n);
|
|
}
|
|
|
|
// Token: 0x060030C7 RID: 12487 RVA: 0x000A7D70 File Offset: 0x000A5F70
|
|
private ulong Ch(ulong x, ulong y, ulong z)
|
|
{
|
|
return (x & y) ^ (~x & z);
|
|
}
|
|
|
|
// Token: 0x060030C8 RID: 12488 RVA: 0x000A7D7C File Offset: 0x000A5F7C
|
|
private ulong Maj(ulong x, ulong y, ulong z)
|
|
{
|
|
return (x & y) ^ (x & z) ^ (y & z);
|
|
}
|
|
|
|
// Token: 0x060030C9 RID: 12489 RVA: 0x000A7D8C File Offset: 0x000A5F8C
|
|
private ulong Sum0(ulong x)
|
|
{
|
|
return this.rotateRight(x, 28) ^ this.rotateRight(x, 34) ^ this.rotateRight(x, 39);
|
|
}
|
|
|
|
// Token: 0x060030CA RID: 12490 RVA: 0x000A7DB8 File Offset: 0x000A5FB8
|
|
private ulong Sum1(ulong x)
|
|
{
|
|
return this.rotateRight(x, 14) ^ this.rotateRight(x, 18) ^ this.rotateRight(x, 41);
|
|
}
|
|
|
|
// Token: 0x060030CB RID: 12491 RVA: 0x000A7DE4 File Offset: 0x000A5FE4
|
|
private ulong Sigma0(ulong x)
|
|
{
|
|
return this.rotateRight(x, 1) ^ this.rotateRight(x, 8) ^ (x >> 7);
|
|
}
|
|
|
|
// Token: 0x060030CC RID: 12492 RVA: 0x000A7DFC File Offset: 0x000A5FFC
|
|
private ulong Sigma1(ulong x)
|
|
{
|
|
return this.rotateRight(x, 19) ^ this.rotateRight(x, 61) ^ (x >> 6);
|
|
}
|
|
|
|
// Token: 0x040013E5 RID: 5093
|
|
private byte[] xBuf;
|
|
|
|
// Token: 0x040013E6 RID: 5094
|
|
private int xBufOff;
|
|
|
|
// Token: 0x040013E7 RID: 5095
|
|
private ulong byteCount1;
|
|
|
|
// Token: 0x040013E8 RID: 5096
|
|
private ulong byteCount2;
|
|
|
|
// Token: 0x040013E9 RID: 5097
|
|
private ulong H1;
|
|
|
|
// Token: 0x040013EA RID: 5098
|
|
private ulong H2;
|
|
|
|
// Token: 0x040013EB RID: 5099
|
|
private ulong H3;
|
|
|
|
// Token: 0x040013EC RID: 5100
|
|
private ulong H4;
|
|
|
|
// Token: 0x040013ED RID: 5101
|
|
private ulong H5;
|
|
|
|
// Token: 0x040013EE RID: 5102
|
|
private ulong H6;
|
|
|
|
// Token: 0x040013EF RID: 5103
|
|
private ulong H7;
|
|
|
|
// Token: 0x040013F0 RID: 5104
|
|
private ulong H8;
|
|
|
|
// Token: 0x040013F1 RID: 5105
|
|
private ulong[] W;
|
|
|
|
// Token: 0x040013F2 RID: 5106
|
|
private int wOff;
|
|
}
|
|
}
|