niko
363 lines
10 KiB
C#
363 lines
10 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Digests;
|
|
using BestHTTP.SecureProtocol.Org.BouncyCastle.Security;
|
|
using Cpp2IlInjected;
|
|
|
|
namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Encodings
|
|
{
|
|
// Token: 0x020016E0 RID: 5856
|
|
[Token(Token = "0x20016E0")]
|
|
[StructLayout(3)]
|
|
public class OaepEncoding : IAsymmetricBlockCipher
|
|
{
|
|
// Token: 0x06009D99 RID: 40345 RVA: 0x00242748 File Offset: 0x00240948
|
|
[Token(Token = "0x6009D99")]
|
|
[Address(RVA = "0x205CAE0", Offset = "0x205B4E0", VA = "0x18205CAE0")]
|
|
public OaepEncoding(IAsymmetricBlockCipher cipher)
|
|
{
|
|
Sha1Digest sha1Digest = new Sha1Digest();
|
|
}
|
|
|
|
// Token: 0x06009D9A RID: 40346 RVA: 0x0024275C File Offset: 0x0024095C
|
|
[Token(Token = "0x6009D9A")]
|
|
[Address(RVA = "0x205CAC0", Offset = "0x205B4C0", VA = "0x18205CAC0")]
|
|
public OaepEncoding(IAsymmetricBlockCipher cipher, IDigest hash)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06009D9B RID: 40347 RVA: 0x0024276C File Offset: 0x0024096C
|
|
[Token(Token = "0x6009D9B")]
|
|
[Address(RVA = "0x205CB60", Offset = "0x205B560", VA = "0x18205CB60")]
|
|
public OaepEncoding(IAsymmetricBlockCipher cipher, IDigest hash, byte[] encodingParams)
|
|
{
|
|
this.engine = cipher;
|
|
this.mgf1Hash = hash;
|
|
byte[] array = new byte[0];
|
|
this.defHash = array;
|
|
if (encodingParams != 0)
|
|
{
|
|
int length = encodingParams.Length;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009D9C RID: 40348 RVA: 0x002427B0 File Offset: 0x002409B0
|
|
[Token(Token = "0x6009D9C")]
|
|
[Address(RVA = "0x205C9D0", Offset = "0x205B3D0", VA = "0x18205C9D0")]
|
|
public OaepEncoding(IAsymmetricBlockCipher cipher, IDigest hash, IDigest mgf1Hash, byte[] encodingParams)
|
|
{
|
|
this.engine = cipher;
|
|
this.mgf1Hash = mgf1Hash;
|
|
byte[] array = new byte[0];
|
|
this.defHash = array;
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009D9D RID: 40349 RVA: 0x002427E8 File Offset: 0x002409E8
|
|
[Token(Token = "0x6009D9D")]
|
|
[Address(RVA = "0x3C1220", Offset = "0x3BFC20", VA = "0x1803C1220")]
|
|
public IAsymmetricBlockCipher GetUnderlyingCipher()
|
|
{
|
|
return this.engine;
|
|
}
|
|
|
|
// Token: 0x17001903 RID: 6403
|
|
// (get) Token: 0x06009D9E RID: 40350 RVA: 0x002427FC File Offset: 0x002409FC
|
|
[Token(Token = "0x17001903")]
|
|
public string AlgorithmName
|
|
{
|
|
[Token(Token = "0x6009D9E")]
|
|
[Address(RVA = "0x205CC50", Offset = "0x205B650", VA = "0x18205CC50", Slot = "4")]
|
|
get
|
|
{
|
|
IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
|
|
return 0 + "/OAEPPadding";
|
|
}
|
|
}
|
|
|
|
// Token: 0x06009D9F RID: 40351 RVA: 0x00242824 File Offset: 0x00240A24
|
|
[Token(Token = "0x6009D9F")]
|
|
[Address(RVA = "0x205C880", Offset = "0x205B280", VA = "0x18205C880", Slot = "5")]
|
|
public void Init(bool forEncryption, ICipherParameters param)
|
|
{
|
|
while (param != 0 && param != 0 && param == 0)
|
|
{
|
|
}
|
|
SecureRandom secureRandom = new SecureRandom();
|
|
this.random = secureRandom;
|
|
IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
|
|
this.forEncryption = forEncryption;
|
|
}
|
|
|
|
// Token: 0x06009DA0 RID: 40352 RVA: 0x00242864 File Offset: 0x00240A64
|
|
[Token(Token = "0x6009DA0")]
|
|
[Address(RVA = "0x205C7A0", Offset = "0x205B1A0", VA = "0x18205C7A0", Slot = "6")]
|
|
public int GetInputBlockSize()
|
|
{
|
|
IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
|
|
if (this.forEncryption)
|
|
{
|
|
int num = this.defHash.Length;
|
|
num += num;
|
|
uint num2;
|
|
num2 -= (uint)num;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009DA1 RID: 40353 RVA: 0x0024289C File Offset: 0x00240A9C
|
|
[Token(Token = "0x6009DA1")]
|
|
[Address(RVA = "0x205C810", Offset = "0x205B210", VA = "0x18205C810", Slot = "7")]
|
|
public int GetOutputBlockSize()
|
|
{
|
|
IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
|
|
if (!this.forEncryption)
|
|
{
|
|
int num = this.defHash.Length;
|
|
num += num;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009DA2 RID: 40354 RVA: 0x002428D0 File Offset: 0x00240AD0
|
|
[Token(Token = "0x6009DA2")]
|
|
[Address(RVA = "0x205C9A0", Offset = "0x205B3A0", VA = "0x18205C9A0", Slot = "8")]
|
|
public byte[] ProcessBlock(byte[] inBytes, int inOff, int inLen)
|
|
{
|
|
if (!this.forEncryption)
|
|
{
|
|
return this.DecodeBlock(inBytes, inOff, inLen);
|
|
}
|
|
return this.EncodeBlock(inBytes, inOff, inLen);
|
|
}
|
|
|
|
// Token: 0x06009DA3 RID: 40355 RVA: 0x002428FC File Offset: 0x00240AFC
|
|
[Token(Token = "0x6009DA3")]
|
|
[Address(RVA = "0x205C400", Offset = "0x205AE00", VA = "0x18205C400")]
|
|
private byte[] EncodeBlock(byte[] inBytes, int inOff, int inLen)
|
|
{
|
|
IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
|
|
uint num2;
|
|
if (this.forEncryption)
|
|
{
|
|
int num = this.defHash.Length;
|
|
num += num;
|
|
num2 -= (uint)num;
|
|
}
|
|
Check.DataLength(inLen > (int)num2, "input data too long");
|
|
IAsymmetricBlockCipher asymmetricBlockCipher2 = this.engine;
|
|
byte[] array = this.defHash;
|
|
if (this.forEncryption)
|
|
{
|
|
int num3 = array.Length;
|
|
num3 += num3;
|
|
}
|
|
int num4 = array.Length;
|
|
num4 += num4;
|
|
num4++;
|
|
byte[] array2 = new byte[0];
|
|
int num5 = array2.Length;
|
|
int num6 = 0;
|
|
num5 -= inLen;
|
|
Array.Copy(inBytes, inOff, array2, num5, inLen);
|
|
int num7 = array2.Length;
|
|
num7 -= inLen;
|
|
byte[] array3 = this.defHash;
|
|
int length = array3.Length;
|
|
int num8 = 0;
|
|
Array.Copy(array3, num8, array2, length, length);
|
|
byte[] array4 = this.defHash;
|
|
SecureRandom secureRandom = this.random;
|
|
int length2 = array4.Length;
|
|
byte[] nextBytes = SecureRandom.GetNextBytes(secureRandom, length2);
|
|
byte[] array5 = this.defHash;
|
|
int length3 = array2.Length;
|
|
int num9 = 0;
|
|
int length4 = nextBytes.Length;
|
|
byte[] array6 = this.maskGeneratorFunction1(nextBytes, num9, length4, length3);
|
|
int num10 = this.defHash.Length;
|
|
if (num10 != array2.Length)
|
|
{
|
|
byte[] array7 = this.defHash;
|
|
num10++;
|
|
}
|
|
int length5 = this.defHash.Length;
|
|
int num11 = 0;
|
|
int num12 = 0;
|
|
Array.Copy(nextBytes, num12, array2, num11, length5);
|
|
int length6 = this.defHash.Length;
|
|
int num13 = array2.Length;
|
|
num13 -= length6;
|
|
byte[] array8 = this.maskGeneratorFunction1(array2, length6, num13, length6);
|
|
byte[] array9 = this.defHash;
|
|
if (num6 != array9.Length)
|
|
{
|
|
num6++;
|
|
byte[] array10 = this.defHash;
|
|
}
|
|
IAsymmetricBlockCipher asymmetricBlockCipher3 = this.engine;
|
|
int length7 = array2.Length;
|
|
throw new IndexOutOfRangeException();
|
|
}
|
|
|
|
// Token: 0x06009DA4 RID: 40356 RVA: 0x00242AD4 File Offset: 0x00240CD4
|
|
[Token(Token = "0x6009DA4")]
|
|
[Address(RVA = "0x205BFF0", Offset = "0x205A9F0", VA = "0x18205BFF0")]
|
|
private byte[] DecodeBlock(byte[] inBytes, int inOff, int inLen)
|
|
{
|
|
IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
|
|
IAsymmetricBlockCipher asymmetricBlockCipher2 = this.engine;
|
|
byte[] array = new byte[0];
|
|
int length = this.defHash.Length;
|
|
int num = array.Length;
|
|
num -= typeof(IAsymmetricBlockCipher).TypeHandle;
|
|
int num2 = 0;
|
|
int length2 = this.defHash.Length;
|
|
int num3 = array.Length;
|
|
num3 -= length2;
|
|
byte[] array2 = this.maskGeneratorFunction1(array, length2, num3, length2);
|
|
byte[] array3 = this.defHash;
|
|
byte[] array4;
|
|
if (num2 != array3.Length)
|
|
{
|
|
num2++;
|
|
array4 = this.defHash;
|
|
}
|
|
int num4 = array.Length;
|
|
int num5 = 0;
|
|
int length3 = array4.Length;
|
|
num4 -= length3;
|
|
byte[] array5 = this.maskGeneratorFunction1(array, num5, length3, num4);
|
|
int num6 = this.defHash.Length;
|
|
int num7 = array.Length;
|
|
if (num6 != num7)
|
|
{
|
|
byte[] array6 = this.defHash;
|
|
num7 = num6;
|
|
num6++;
|
|
}
|
|
int length4 = this.defHash.Length;
|
|
if (num2 != length4)
|
|
{
|
|
num2++;
|
|
}
|
|
if (num2 != num7)
|
|
{
|
|
num2++;
|
|
bool flag = num7 == num7;
|
|
}
|
|
num7++;
|
|
int num8 = num7 - 1;
|
|
num7 -= num7;
|
|
byte[] array7 = new byte[num7];
|
|
int length5 = array7.Length;
|
|
int num9 = 0;
|
|
Array.Copy(array, num7, array7, num9, length5);
|
|
return array7;
|
|
}
|
|
|
|
// Token: 0x06009DA5 RID: 40357 RVA: 0x00242C30 File Offset: 0x00240E30
|
|
[Token(Token = "0x6009DA5")]
|
|
[Address(RVA = "0x1E44410", Offset = "0x1E42E10", VA = "0x181E44410")]
|
|
private void ItoOSP(int i, byte[] sp)
|
|
{
|
|
sp[0] = (byte)i;
|
|
sp[0] = (byte)i;
|
|
sp[0] = (byte)i;
|
|
sp[0] = (byte)i;
|
|
}
|
|
|
|
// Token: 0x06009DA6 RID: 40358 RVA: 0x00242C64 File Offset: 0x00240E64
|
|
[Token(Token = "0x6009DA6")]
|
|
[Address(RVA = "0x205CCB0", Offset = "0x205B6B0", VA = "0x18205CCB0")]
|
|
private byte[] maskGeneratorFunction1(byte[] Z, int zOff, int zLen, int length)
|
|
{
|
|
byte[] array = new byte[0];
|
|
IDigest digest = this.mgf1Hash;
|
|
byte[] array2 = new byte[array];
|
|
byte[] array3 = new byte[4];
|
|
IDigest digest2 = this.mgf1Hash;
|
|
int num = 0;
|
|
int num2 = 0;
|
|
int length2 = array2.Length;
|
|
array3[0] = (byte)num;
|
|
array3[0] = (byte)num;
|
|
array3[0] = (byte)num;
|
|
array3[0] = (byte)num;
|
|
IDigest digest3 = this.mgf1Hash;
|
|
if (num2 < num2)
|
|
{
|
|
num2 += num2;
|
|
num2++;
|
|
}
|
|
IDigest digest4 = this.mgf1Hash;
|
|
int num3 = 0;
|
|
num3 += num3;
|
|
num3++;
|
|
int num4 = 0;
|
|
IDigest digest5 = this.mgf1Hash;
|
|
int num5 = 0;
|
|
if (num5 < num4)
|
|
{
|
|
num5 += num5;
|
|
num5++;
|
|
}
|
|
int num6 = array2.Length;
|
|
int num7 = num6 * num;
|
|
int num8 = 0;
|
|
Array.Copy(array2, num8, array, num7, num6);
|
|
num++;
|
|
num8 += num8;
|
|
num6 += 4;
|
|
num6 += 19;
|
|
num8 += num8;
|
|
num6 += 4;
|
|
num6 += 19;
|
|
num8 += num8;
|
|
num6 += 5;
|
|
num6 += 19;
|
|
array3[0] = (byte)num;
|
|
array3[0] = (byte)num;
|
|
array3[0] = (byte)num;
|
|
array3[0] = (byte)num;
|
|
IDigest digest6 = this.mgf1Hash;
|
|
IDigest digest7 = this.mgf1Hash;
|
|
int length3 = array3.Length;
|
|
IDigest digest8 = this.mgf1Hash;
|
|
int length4 = array2.Length;
|
|
int num9 = array.Length;
|
|
int num10 = 0;
|
|
int num11 = length4 * num;
|
|
num9 -= num11;
|
|
Array.Copy(array2, num10, array, num11, num9);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x040067C8 RID: 26568
|
|
[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
|
|
[Token(Token = "0x40067C8")]
|
|
private byte[] defHash;
|
|
|
|
// Token: 0x040067C9 RID: 26569
|
|
[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
|
|
[Token(Token = "0x40067C9")]
|
|
private IDigest mgf1Hash;
|
|
|
|
// Token: 0x040067CA RID: 26570
|
|
[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
|
|
[Token(Token = "0x40067CA")]
|
|
private IAsymmetricBlockCipher engine;
|
|
|
|
// Token: 0x040067CB RID: 26571
|
|
[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
|
|
[Token(Token = "0x40067CB")]
|
|
private SecureRandom random;
|
|
|
|
// Token: 0x040067CC RID: 26572
|
|
[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
|
|
[Token(Token = "0x40067CC")]
|
|
private bool forEncryption;
|
|
}
|
|
}
|