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;
	}
}