init commit

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Digests/SM3Digest.cs

@@ -0,0 +1,231 @@
+using System;
+using Org.BouncyCastle.Crypto.Utilities;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Crypto.Digests;
+
+public class SM3Digest : GeneralDigest
+{
+	private const int DIGEST_LENGTH = 32;
+
+	private const int BLOCK_SIZE = 16;
+
+	private uint[] V = new uint[8];
+
+	private uint[] inwords = new uint[16];
+
+	private int xOff;
+
+	private uint[] W = new uint[68];
+
+	private static readonly uint[] T;
+
+	public override string AlgorithmName => "SM3";
+
+	static SM3Digest()
+	{
+		T = new uint[64];
+		for (int i = 0; i < 16; i++)
+		{
+			uint num = 2043430169u;
+			T[i] = (num << i) | (num >> 32 - i);
+		}
+		for (int j = 16; j < 64; j++)
+		{
+			int num2 = j % 32;
+			uint num3 = 2055708042u;
+			T[j] = (num3 << num2) | (num3 >> 32 - num2);
+		}
+	}
+
+	public SM3Digest()
+	{
+		Reset();
+	}
+
+	public SM3Digest(SM3Digest t)
+		: base(t)
+	{
+		CopyIn(t);
+	}
+
+	private void CopyIn(SM3Digest t)
+	{
+		Array.Copy(t.V, 0, V, 0, V.Length);
+		Array.Copy(t.inwords, 0, inwords, 0, inwords.Length);
+		xOff = t.xOff;
+	}
+
+	public override int GetDigestSize()
+	{
+		return 32;
+	}
+
+	public override IMemoable Copy()
+	{
+		return new SM3Digest(this);
+	}
+
+	public override void Reset(IMemoable other)
+	{
+		SM3Digest t = (SM3Digest)other;
+		CopyIn((GeneralDigest)t);
+		CopyIn(t);
+	}
+
+	public override void Reset()
+	{
+		base.Reset();
+		V[0] = 1937774191u;
+		V[1] = 1226093241u;
+		V[2] = 388252375u;
+		V[3] = 3666478592u;
+		V[4] = 2842636476u;
+		V[5] = 372324522u;
+		V[6] = 3817729613u;
+		V[7] = 2969243214u;
+		xOff = 0;
+	}
+
+	public override int DoFinal(byte[] output, int outOff)
+	{
+		Finish();
+		Pack.UInt32_To_BE(V, output, outOff);
+		Reset();
+		return 32;
+	}
+
+	internal override void ProcessWord(byte[] input, int inOff)
+	{
+		uint num = Pack.BE_To_UInt32(input, inOff);
+		inwords[xOff] = num;
+		xOff++;
+		if (xOff >= 16)
+		{
+			ProcessBlock();
+		}
+	}
+
+	internal override void ProcessLength(long bitLength)
+	{
+		if (xOff > 14)
+		{
+			inwords[xOff] = 0u;
+			xOff++;
+			ProcessBlock();
+		}
+		while (xOff < 14)
+		{
+			inwords[xOff] = 0u;
+			xOff++;
+		}
+		inwords[xOff++] = (uint)(bitLength >> 32);
+		inwords[xOff++] = (uint)bitLength;
+	}
+
+	private uint P0(uint x)
+	{
+		uint num = (x << 9) | (x >> 23);
+		uint num2 = (x << 17) | (x >> 15);
+		return x ^ num ^ num2;
+	}
+
+	private uint P1(uint x)
+	{
+		uint num = (x << 15) | (x >> 17);
+		uint num2 = (x << 23) | (x >> 9);
+		return x ^ num ^ num2;
+	}
+
+	private uint FF0(uint x, uint y, uint z)
+	{
+		return x ^ y ^ z;
+	}
+
+	private uint FF1(uint x, uint y, uint z)
+	{
+		return (x & y) | (x & z) | (y & z);
+	}
+
+	private uint GG0(uint x, uint y, uint z)
+	{
+		return x ^ y ^ z;
+	}
+
+	private uint GG1(uint x, uint y, uint z)
+	{
+		return (x & y) | (~x & z);
+	}
+
+	internal override void ProcessBlock()
+	{
+		for (int i = 0; i < 16; i++)
+		{
+			W[i] = inwords[i];
+		}
+		for (int j = 16; j < 68; j++)
+		{
+			uint num = W[j - 3];
+			uint num2 = (num << 15) | (num >> 17);
+			uint num3 = W[j - 13];
+			uint num4 = (num3 << 7) | (num3 >> 25);
+			W[j] = P1(W[j - 16] ^ W[j - 9] ^ num2) ^ num4 ^ W[j - 6];
+		}
+		uint num5 = V[0];
+		uint num6 = V[1];
+		uint num7 = V[2];
+		uint num8 = V[3];
+		uint num9 = V[4];
+		uint num10 = V[5];
+		uint num11 = V[6];
+		uint num12 = V[7];
+		for (int k = 0; k < 16; k++)
+		{
+			uint num13 = (num5 << 12) | (num5 >> 20);
+			uint num14 = num13 + num9 + T[k];
+			uint num15 = (num14 << 7) | (num14 >> 25);
+			uint num16 = num15 ^ num13;
+			uint num17 = W[k];
+			uint num18 = num17 ^ W[k + 4];
+			uint num19 = FF0(num5, num6, num7) + num8 + num16 + num18;
+			uint x = GG0(num9, num10, num11) + num12 + num15 + num17;
+			num8 = num7;
+			num7 = (num6 << 9) | (num6 >> 23);
+			num6 = num5;
+			num5 = num19;
+			num12 = num11;
+			num11 = (num10 << 19) | (num10 >> 13);
+			num10 = num9;
+			num9 = P0(x);
+		}
+		for (int l = 16; l < 64; l++)
+		{
+			uint num20 = (num5 << 12) | (num5 >> 20);
+			uint num21 = num20 + num9 + T[l];
+			uint num22 = (num21 << 7) | (num21 >> 25);
+			uint num23 = num22 ^ num20;
+			uint num24 = W[l];
+			uint num25 = num24 ^ W[l + 4];
+			uint num26 = FF1(num5, num6, num7) + num8 + num23 + num25;
+			uint x2 = GG1(num9, num10, num11) + num12 + num22 + num24;
+			num8 = num7;
+			num7 = (num6 << 9) | (num6 >> 23);
+			num6 = num5;
+			num5 = num26;
+			num12 = num11;
+			num11 = (num10 << 19) | (num10 >> 13);
+			num10 = num9;
+			num9 = P0(x2);
+		}
+		uint[] v;
+		(v = V)[0] = v[0] ^ num5;
+		(v = V)[1] = v[1] ^ num6;
+		(v = V)[2] = v[2] ^ num7;
+		(v = V)[3] = v[3] ^ num8;
+		(v = V)[4] = v[4] ^ num9;
+		(v = V)[5] = v[5] ^ num10;
+		(v = V)[6] = v[6] ^ num11;
+		(v = V)[7] = v[7] ^ num12;
+		xOff = 0;
+	}
+}