niko
263 lines
7.6 KiB
C#
263 lines
7.6 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace System.Security.Cryptography
|
|
{
|
|
/// <summary>Computes the <see cref="T:System.Security.Cryptography.SHA384" /> hash for the input data using the managed library. </summary>
|
|
// Token: 0x02000531 RID: 1329
|
|
[ComVisible(true)]
|
|
public class SHA384Managed : SHA384
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.SHA384Managed" /> 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: 0x060030AD RID: 12461 RVA: 0x000A70BC File Offset: 0x000A52BC
|
|
public SHA384Managed()
|
|
{
|
|
this.xBuf = new byte[8];
|
|
this.W = new ulong[80];
|
|
this.Initialize(false);
|
|
}
|
|
|
|
// Token: 0x060030AE RID: 12462 RVA: 0x000A70F0 File Offset: 0x000A52F0
|
|
private void Initialize(bool reuse)
|
|
{
|
|
this.H1 = 14680500436340154072UL;
|
|
this.H2 = 7105036623409894663UL;
|
|
this.H3 = 10473403895298186519UL;
|
|
this.H4 = 1526699215303891257UL;
|
|
this.H5 = 7436329637833083697UL;
|
|
this.H6 = 10282925794625328401UL;
|
|
this.H7 = 15784041429090275239UL;
|
|
this.H8 = 5167115440072839076UL;
|
|
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 <see cref="T:System.Security.Cryptography.SHA384Managed" />.</summary>
|
|
// Token: 0x060030AF RID: 12463 RVA: 0x000A71E0 File Offset: 0x000A53E0
|
|
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.SHA384Managed" /> 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: 0x060030B0 RID: 12464 RVA: 0x000A71EC File Offset: 0x000A53EC
|
|
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: 0x060030B1 RID: 12465 RVA: 0x000A728C File Offset: 0x000A548C
|
|
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[48];
|
|
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.Initialize();
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060030B2 RID: 12466 RVA: 0x000A7348 File Offset: 0x000A5548
|
|
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: 0x060030B3 RID: 12467 RVA: 0x000A73A4 File Offset: 0x000A55A4
|
|
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: 0x060030B4 RID: 12468 RVA: 0x000A7428 File Offset: 0x000A5628
|
|
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: 0x060030B5 RID: 12469 RVA: 0x000A7480 File Offset: 0x000A5680
|
|
private void adjustByteCounts()
|
|
{
|
|
if (this.byteCount1 > 2305843009213693951UL)
|
|
{
|
|
this.byteCount2 += this.byteCount1 >> 61;
|
|
this.byteCount1 &= 2305843009213693951UL;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060030B6 RID: 12470 RVA: 0x000A74D0 File Offset: 0x000A56D0
|
|
private void processLength(ulong lowW, ulong hiW)
|
|
{
|
|
if (this.wOff > 14)
|
|
{
|
|
this.processBlock();
|
|
}
|
|
this.W[14] = hiW;
|
|
this.W[15] = lowW;
|
|
}
|
|
|
|
// Token: 0x060030B7 RID: 12471 RVA: 0x000A74FC File Offset: 0x000A56FC
|
|
private void processBlock()
|
|
{
|
|
ulong[] w = this.W;
|
|
ulong[] k = SHAConstants.K2;
|
|
this.adjustByteCounts();
|
|
ulong num;
|
|
ulong num2;
|
|
for (int i = 16; i <= 79; i++)
|
|
{
|
|
num = w[i - 15];
|
|
num = ((num >> 1) | (num << 63)) ^ ((num >> 8) | (num << 56)) ^ (num >> 7);
|
|
num2 = w[i - 2];
|
|
num2 = ((num2 >> 19) | (num2 << 45)) ^ ((num2 >> 61) | (num2 << 3)) ^ (num2 >> 6);
|
|
w[i] = num2 + w[i - 7] + num + w[i - 16];
|
|
}
|
|
num = this.H1;
|
|
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 = ((num5 >> 14) | (num5 << 50)) ^ ((num5 >> 18) | (num5 << 46)) ^ ((num5 >> 41) | (num5 << 23));
|
|
num9 += num8 + ((num5 & num6) ^ (~num5 & num7)) + k[j] + w[j];
|
|
ulong num10 = ((num >> 28) | (num << 36)) ^ ((num >> 34) | (num << 30)) ^ ((num >> 39) | (num << 25));
|
|
num10 += (num & num2) ^ (num & num3) ^ (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 != w.Length; num11++)
|
|
{
|
|
w[num11] = 0UL;
|
|
}
|
|
}
|
|
|
|
// Token: 0x040013D7 RID: 5079
|
|
private byte[] xBuf;
|
|
|
|
// Token: 0x040013D8 RID: 5080
|
|
private int xBufOff;
|
|
|
|
// Token: 0x040013D9 RID: 5081
|
|
private ulong byteCount1;
|
|
|
|
// Token: 0x040013DA RID: 5082
|
|
private ulong byteCount2;
|
|
|
|
// Token: 0x040013DB RID: 5083
|
|
private ulong H1;
|
|
|
|
// Token: 0x040013DC RID: 5084
|
|
private ulong H2;
|
|
|
|
// Token: 0x040013DD RID: 5085
|
|
private ulong H3;
|
|
|
|
// Token: 0x040013DE RID: 5086
|
|
private ulong H4;
|
|
|
|
// Token: 0x040013DF RID: 5087
|
|
private ulong H5;
|
|
|
|
// Token: 0x040013E0 RID: 5088
|
|
private ulong H6;
|
|
|
|
// Token: 0x040013E1 RID: 5089
|
|
private ulong H7;
|
|
|
|
// Token: 0x040013E2 RID: 5090
|
|
private ulong H8;
|
|
|
|
// Token: 0x040013E3 RID: 5091
|
|
private ulong[] W;
|
|
|
|
// Token: 0x040013E4 RID: 5092
|
|
private int wOff;
|
|
}
|
|
}
|