trevor/SuperVPN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init commit

Browse Source
This commit is contained in:
Andrey K. Choi
2025-10-09 09:57:24 +09:00
commit 4d551bd74f
6636 changed files with 1218703 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/BasicGcmExponentiator.cs Normal file
View File

@@ -0,0 +1,33 @@
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
public class BasicGcmExponentiator : IGcmExponentiator
{
private uint[] x;
public void Init(byte[] x)
{
this.x = GcmUtilities.AsUints(x);
}
public void ExponentiateX(long pow, byte[] output)
{
uint[] array = GcmUtilities.OneAsUints();
if (pow > 0)
{
uint[] y = Arrays.Clone(x);
do
{
if ((pow & 1) != 0)
{
GcmUtilities.Multiply(array, y);
}
GcmUtilities.Multiply(y, y);
pow >>= 1;
}
while (pow > 0);
}
GcmUtilities.AsBytes(array, output);
}
}

18
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/BasicGcmMultiplier.cs Normal file
View File

@@ -0,0 +1,18 @@
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
public class BasicGcmMultiplier : IGcmMultiplier
{
private uint[] H;
public void Init(byte[] H)
{
this.H = GcmUtilities.AsUints(H);
}
public void MultiplyH(byte[] x)
{
uint[] x2 = GcmUtilities.AsUints(x);
GcmUtilities.Multiply(x2, H);
GcmUtilities.AsBytes(x2, x);
}
}

403
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/GcmUtilities.cs Normal file
View File

@@ -0,0 +1,403 @@
using Org.BouncyCastle.Crypto.Utilities;
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
internal abstract class GcmUtilities
{
private const uint E1 = 3774873600u;
private const ulong E1L = 16212958658533785600uL;
private static readonly uint[] LOOKUP = GenerateLookup();
private static uint[] GenerateLookup()
{
uint[] array = new uint[256];
for (int i = 0; i < 256; i++)
{
uint num = 0u;
for (int num2 = 7; num2 >= 0; num2--)
{
if ((i & (1 << num2)) != 0)
{
num ^= (uint)(-520093696 >>> 7 - num2);
}
}
array[i] = num;
}
return array;
}
internal static byte[] OneAsBytes()
{
return new byte[16]
{
128, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0
};
}
internal static uint[] OneAsUints()
{
return new uint[4] { 2147483648u, 0u, 0u, 0u };
}
internal static ulong[] OneAsUlongs()
{
return new ulong[2] { 9223372036854775808uL, 0uL };
}
internal static byte[] AsBytes(uint[] x)
{
return Pack.UInt32_To_BE(x);
}
internal static void AsBytes(uint[] x, byte[] z)
{
Pack.UInt32_To_BE(x, z, 0);
}
internal static byte[] AsBytes(ulong[] x)
{
byte[] array = new byte[16];
Pack.UInt64_To_BE(x, array, 0);
return array;
}
internal static void AsBytes(ulong[] x, byte[] z)
{
Pack.UInt64_To_BE(x, z, 0);
}
internal static uint[] AsUints(byte[] bs)
{
uint[] array = new uint[4];
Pack.BE_To_UInt32(bs, 0, array);
return array;
}
internal static void AsUints(byte[] bs, uint[] output)
{
Pack.BE_To_UInt32(bs, 0, output);
}
internal static ulong[] AsUlongs(byte[] x)
{
ulong[] array = new ulong[2];
Pack.BE_To_UInt64(x, 0, array);
return array;
}
public static void AsUlongs(byte[] x, ulong[] z)
{
Pack.BE_To_UInt64(x, 0, z);
}
internal static void Multiply(byte[] x, byte[] y)
{
uint[] x2 = AsUints(x);
uint[] y2 = AsUints(y);
Multiply(x2, y2);
AsBytes(x2, x);
}
internal static void Multiply(uint[] x, uint[] y)
{
uint num = x[0];
uint num2 = x[1];
uint num3 = x[2];
uint num4 = x[3];
uint num5 = 0u;
uint num6 = 0u;
uint num7 = 0u;
uint num8 = 0u;
for (int i = 0; i < 4; i++)
{
int num9 = (int)y[i];
for (int j = 0; j < 32; j++)
{
uint num10 = (uint)(num9 >> 31);
num9 <<= 1;
num5 ^= num & num10;
num6 ^= num2 & num10;
num7 ^= num3 & num10;
num8 ^= num4 & num10;
uint num11 = (uint)((int)(num4 << 31) >> 8);
num4 = (num4 >> 1) | (num3 << 31);
num3 = (num3 >> 1) | (num2 << 31);
num2 = (num2 >> 1) | (num << 31);
num = (num >> 1) ^ (num11 & 0xE1000000u);
}
}
x[0] = num5;
x[1] = num6;
x[2] = num7;
x[3] = num8;
}
internal static void Multiply(ulong[] x, ulong[] y)
{
ulong num = x[0];
ulong num2 = x[1];
ulong num3 = 0uL;
ulong num4 = 0uL;
for (int i = 0; i < 2; i++)
{
long num5 = (long)y[i];
for (int j = 0; j < 64; j++)
{
ulong num6 = (ulong)(num5 >> 63);
num5 <<= 1;
num3 ^= num & num6;
num4 ^= num2 & num6;
ulong num7 = (ulong)((long)(num2 << 63) >> 8);
num2 = (num2 >> 1) | (num << 63);
num = (num >> 1) ^ (num7 & 0xE100000000000000uL);
}
}
x[0] = num3;
x[1] = num4;
}
internal static void MultiplyP(uint[] x)
{
uint num = (uint)((int)ShiftRight(x) >> 8);
uint[] array;
(array = x)[0] = array[0] ^ (num & 0xE1000000u);
}
internal static void MultiplyP(uint[] x, uint[] z)
{
uint num = (uint)((int)ShiftRight(x, z) >> 8);
uint[] array;
(array = z)[0] = array[0] ^ (num & 0xE1000000u);
}
internal static void MultiplyP8(uint[] x)
{
uint num = ShiftRightN(x, 8);
uint[] array;
(array = x)[0] = array[0] ^ LOOKUP[num >> 24];
}
internal static void MultiplyP8(uint[] x, uint[] y)
{
uint num = ShiftRightN(x, 8, y);
uint[] array;
(array = y)[0] = array[0] ^ LOOKUP[num >> 24];
}
internal static uint ShiftRight(uint[] x)
{
uint num = x[0];
x[0] = num >> 1;
uint num2 = num << 31;
num = x[1];
x[1] = (num >> 1) | num2;
num2 = num << 31;
num = x[2];
x[2] = (num >> 1) | num2;
num2 = num << 31;
num = x[3];
x[3] = (num >> 1) | num2;
return num << 31;
}
internal static uint ShiftRight(uint[] x, uint[] z)
{
uint num = x[0];
z[0] = num >> 1;
uint num2 = num << 31;
num = x[1];
z[1] = (num >> 1) | num2;
num2 = num << 31;
num = x[2];
z[2] = (num >> 1) | num2;
num2 = num << 31;
num = x[3];
z[3] = (num >> 1) | num2;
return num << 31;
}
internal static uint ShiftRightN(uint[] x, int n)
{
uint num = x[0];
int num2 = 32 - n;
x[0] = num >> n;
uint num3 = num << num2;
num = x[1];
x[1] = (num >> n) | num3;
num3 = num << num2;
num = x[2];
x[2] = (num >> n) | num3;
num3 = num << num2;
num = x[3];
x[3] = (num >> n) | num3;
return num << num2;
}
internal static uint ShiftRightN(uint[] x, int n, uint[] z)
{
uint num = x[0];
int num2 = 32 - n;
z[0] = num >> n;
uint num3 = num << num2;
num = x[1];
z[1] = (num >> n) | num3;
num3 = num << num2;
num = x[2];
z[2] = (num >> n) | num3;
num3 = num << num2;
num = x[3];
z[3] = (num >> n) | num3;
return num << num2;
}
internal static void Xor(byte[] x, byte[] y)
{
int num = 0;
do
{
byte[] array2;
byte[] array = (array2 = x);
int num2 = num;
nint num3 = num2;
array[num2] = (byte)(array2[num3] ^ y[num]);
num++;
byte[] array3 = (array2 = x);
int num4 = num;
num3 = num4;
array3[num4] = (byte)(array2[num3] ^ y[num]);
num++;
byte[] array4 = (array2 = x);
int num5 = num;
num3 = num5;
array4[num5] = (byte)(array2[num3] ^ y[num]);
num++;
byte[] array5 = (array2 = x);
int num6 = num;
num3 = num6;
array5[num6] = (byte)(array2[num3] ^ y[num]);
num++;
}
while (num < 16);
}
internal static void Xor(byte[] x, byte[] y, int yOff)
{
int num = 0;
do
{
byte[] array2;
byte[] array = (array2 = x);
int num2 = num;
nint num3 = num2;
array[num2] = (byte)(array2[num3] ^ y[yOff + num]);
num++;
byte[] array3 = (array2 = x);
int num4 = num;
num3 = num4;
array3[num4] = (byte)(array2[num3] ^ y[yOff + num]);
num++;
byte[] array4 = (array2 = x);
int num5 = num;
num3 = num5;
array4[num5] = (byte)(array2[num3] ^ y[yOff + num]);
num++;
byte[] array5 = (array2 = x);
int num6 = num;
num3 = num6;
array5[num6] = (byte)(array2[num3] ^ y[yOff + num]);
num++;
}
while (num < 16);
}
internal static void Xor(byte[] x, int xOff, byte[] y, int yOff, byte[] z, int zOff)
{
int num = 0;
do
{
z[zOff + num] = (byte)(x[xOff + num] ^ y[yOff + num]);
num++;
z[zOff + num] = (byte)(x[xOff + num] ^ y[yOff + num]);
num++;
z[zOff + num] = (byte)(x[xOff + num] ^ y[yOff + num]);
num++;
z[zOff + num] = (byte)(x[xOff + num] ^ y[yOff + num]);
num++;
}
while (num < 16);
}
internal static void Xor(byte[] x, byte[] y, int yOff, int yLen)
{
while (--yLen >= 0)
{
byte[] array2;
byte[] array = (array2 = x);
int num = yLen;
nint num2 = num;
array[num] = (byte)(array2[num2] ^ y[yOff + yLen]);
}
}
internal static void Xor(byte[] x, int xOff, byte[] y, int yOff, int len)
{
while (--len >= 0)
{
byte[] array2;
byte[] array = (array2 = x);
int num = xOff + len;
nint num2 = num;
array[num] = (byte)(array2[num2] ^ y[yOff + len]);
}
}
internal static void Xor(byte[] x, byte[] y, byte[] z)
{
int num = 0;
do
{
z[num] = (byte)(x[num] ^ y[num]);
num++;
z[num] = (byte)(x[num] ^ y[num]);
num++;
z[num] = (byte)(x[num] ^ y[num]);
num++;
z[num] = (byte)(x[num] ^ y[num]);
num++;
}
while (num < 16);
}
internal static void Xor(uint[] x, uint[] y)
{
uint[] array;
(array = x)[0] = array[0] ^ y[0];
(array = x)[1] = array[1] ^ y[1];
(array = x)[2] = array[2] ^ y[2];
(array = x)[3] = array[3] ^ y[3];
}
internal static void Xor(uint[] x, uint[] y, uint[] z)
{
z[0] = x[0] ^ y[0];
z[1] = x[1] ^ y[1];
z[2] = x[2] ^ y[2];
z[3] = x[3] ^ y[3];
}
internal static void Xor(ulong[] x, ulong[] y)
{
ulong[] array;
(array = x)[0] = array[0] ^ y[0];
(array = x)[1] = array[1] ^ y[1];
}
internal static void Xor(ulong[] x, ulong[] y, ulong[] z)
{
z[0] = x[0] ^ y[0];
z[1] = x[1] ^ y[1];
}
}

8
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/IGcmExponentiator.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
public interface IGcmExponentiator
{
void Init(byte[] x);
void ExponentiateX(long pow, byte[] output);
}

8
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/IGcmMultiplier.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
public interface IGcmMultiplier
{
void Init(byte[] H);
void MultiplyH(byte[] x);
}

52
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/Tables1kGcmExponentiator.cs Normal file
View File

@@ -0,0 +1,52 @@
using System.Collections;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
public class Tables1kGcmExponentiator : IGcmExponentiator
{
private IList lookupPowX2;
public void Init(byte[] x)
{
uint[] array = GcmUtilities.AsUints(x);
if (lookupPowX2 == null || !Arrays.AreEqual(array, (uint[])lookupPowX2[0]))
{
lookupPowX2 = Platform.CreateArrayList(8);
lookupPowX2.Add(array);
}
}
public void ExponentiateX(long pow, byte[] output)
{
uint[] x = GcmUtilities.OneAsUints();
int num = 0;
while (pow > 0)
{
if ((pow & 1) != 0)
{
EnsureAvailable(num);
GcmUtilities.Multiply(x, (uint[])lookupPowX2[num]);
}
num++;
pow >>= 1;
}
GcmUtilities.AsBytes(x, output);
}
private void EnsureAvailable(int bit)
{
int num = lookupPowX2.Count;
if (num <= bit)
{
uint[] array = (uint[])lookupPowX2[num - 1];
do
{
array = Arrays.Clone(array);
GcmUtilities.Multiply(array, array);
lookupPowX2.Add(array);
}
while (++num <= bit);
}
}
}

73
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/Tables64kGcmMultiplier.cs Normal file
View File

@@ -0,0 +1,73 @@
using Org.BouncyCastle.Crypto.Utilities;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
public class Tables64kGcmMultiplier : IGcmMultiplier
{
private byte[] H;
private uint[][][] M;
public void Init(byte[] H)
{
if (M == null)
{
M = new uint[16][][];
}
else if (Arrays.AreEqual(this.H, H))
{
return;
}
this.H = Arrays.Clone(H);
M[0] = new uint[256][];
M[0][0] = new uint[4];
M[0][128] = GcmUtilities.AsUints(H);
for (int num = 64; num >= 1; num >>= 1)
{
uint[] array = (uint[])M[0][num + num].Clone();
GcmUtilities.MultiplyP(array);
M[0][num] = array;
}
int num2 = 0;
while (true)
{
for (int i = 2; i < 256; i += i)
{
for (int j = 1; j < i; j++)
{
uint[] array2 = (uint[])M[num2][i].Clone();
GcmUtilities.Xor(array2, M[num2][j]);
M[num2][i + j] = array2;
}
}
if (++num2 == 16)
{
break;
}
M[num2] = new uint[256][];
M[num2][0] = new uint[4];
for (int num3 = 128; num3 > 0; num3 >>= 1)
{
uint[] array3 = (uint[])M[num2 - 1][num3].Clone();
GcmUtilities.MultiplyP8(array3);
M[num2][num3] = array3;
}
}
}
public void MultiplyH(byte[] x)
{
uint[] array = new uint[4];
for (int i = 0; i != 16; i++)
{
uint[] array2 = M[i][x[i]];
uint[] array3;
(array3 = array)[0] = array3[0] ^ array2[0];
(array3 = array)[1] = array3[1] ^ array2[1];
(array3 = array)[2] = array3[2] ^ array2[2];
(array3 = array)[3] = array3[3] ^ array2[3];
}
Pack.UInt32_To_BE(array, x, 0);
}
}

92
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Modes/Gcm/Tables8kGcmMultiplier.cs Normal file
View File

@@ -0,0 +1,92 @@
using Org.BouncyCastle.Crypto.Utilities;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Crypto.Modes.Gcm;
public class Tables8kGcmMultiplier : IGcmMultiplier
{
private byte[] H;
private uint[][][] M;
public void Init(byte[] H)
{
if (M == null)
{
M = new uint[32][][];
}
else if (Arrays.AreEqual(this.H, H))
{
return;
}
this.H = Arrays.Clone(H);
M[0] = new uint[16][];
M[1] = new uint[16][];
M[0][0] = new uint[4];
M[1][0] = new uint[4];
M[1][8] = GcmUtilities.AsUints(H);
for (int num = 4; num >= 1; num >>= 1)
{
uint[] array = (uint[])M[1][num + num].Clone();
GcmUtilities.MultiplyP(array);
M[1][num] = array;
}
uint[] array2 = (uint[])M[1][1].Clone();
GcmUtilities.MultiplyP(array2);
M[0][8] = array2;
for (int num2 = 4; num2 >= 1; num2 >>= 1)
{
uint[] array3 = (uint[])M[0][num2 + num2].Clone();
GcmUtilities.MultiplyP(array3);
M[0][num2] = array3;
}
int num3 = 0;
while (true)
{
for (int i = 2; i < 16; i += i)
{
for (int j = 1; j < i; j++)
{
uint[] array4 = (uint[])M[num3][i].Clone();
GcmUtilities.Xor(array4, M[num3][j]);
M[num3][i + j] = array4;
}
}
if (++num3 == 32)
{
break;
}
if (num3 > 1)
{
M[num3] = new uint[16][];
M[num3][0] = new uint[4];
for (int num4 = 8; num4 > 0; num4 >>= 1)
{
uint[] array5 = (uint[])M[num3 - 2][num4].Clone();
GcmUtilities.MultiplyP8(array5);
M[num3][num4] = array5;
}
}
}
}
public void MultiplyH(byte[] x)
{
uint[] array = new uint[4];
for (int num = 15; num >= 0; num--)
{
uint[] array2 = M[num + num][x[num] & 0xF];
uint[] array3;
(array3 = array)[0] = array3[0] ^ array2[0];
(array3 = array)[1] = array3[1] ^ array2[1];
(array3 = array)[2] = array3[2] ^ array2[2];
(array3 = array)[3] = array3[3] ^ array2[3];
array2 = M[num + num + 1][(x[num] & 0xF0) >> 4];
(array3 = array)[0] = array3[0] ^ array2[0];
(array3 = array)[1] = array3[1] ^ array2[1];
(array3 = array)[2] = array3[2] ^ array2[2];
(array3 = array)[3] = array3[3] ^ array2[3];
}
Pack.UInt32_To_BE(array, x, 0);
}
}