using System;
using BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Digests;
using BestHTTP.SecureProtocol.Org.BouncyCastle.Security;
using Cpp2IlInjected;

namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Encodings
{
	// Token: 0x02001D9D RID: 7581
	[Token(Token = "0x2001D9D")]
	public class OaepEncoding : IAsymmetricBlockCipher
	{
		// Token: 0x0600BD41 RID: 48449 RVA: 0x002A3204 File Offset: 0x002A1404
		[Token(Token = "0x600BD41")]
		[Address(RVA = "0x24A0190", Offset = "0x249F190", VA = "0x1824A0190")]
		public OaepEncoding(IAsymmetricBlockCipher cipher)
		{
			Sha1Digest sha1Digest = new Sha1Digest();
		}

		// Token: 0x0600BD42 RID: 48450 RVA: 0x002A3218 File Offset: 0x002A1418
		[Token(Token = "0x600BD42")]
		[Address(RVA = "0x24A0170", Offset = "0x249F170", VA = "0x1824A0170")]
		public OaepEncoding(IAsymmetricBlockCipher cipher, IDigest hash)
		{
		}

		// Token: 0x0600BD43 RID: 48451 RVA: 0x002A3228 File Offset: 0x002A1428
		[Token(Token = "0x600BD43")]
		[Address(RVA = "0x24A0210", Offset = "0x249F210", VA = "0x1824A0210")]
		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: 0x0600BD44 RID: 48452 RVA: 0x002A326C File Offset: 0x002A146C
		[Token(Token = "0x600BD44")]
		[Address(RVA = "0x24A0080", Offset = "0x249F080", VA = "0x1824A0080")]
		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: 0x0600BD45 RID: 48453 RVA: 0x002A32A4 File Offset: 0x002A14A4
		[Token(Token = "0x600BD45")]
		[Address(RVA = "0x4157C0", Offset = "0x4147C0", VA = "0x1804157C0")]
		public IAsymmetricBlockCipher GetUnderlyingCipher()
		{
			return this.engine;
		}

		// Token: 0x17001DA1 RID: 7585
		// (get) Token: 0x0600BD46 RID: 48454 RVA: 0x002A32B8 File Offset: 0x002A14B8
		[Token(Token = "0x17001DA1")]
		public string AlgorithmName
		{
			[Token(Token = "0x600BD46")]
			[Address(RVA = "0x24A0300", Offset = "0x249F300", VA = "0x1824A0300", Slot = "4")]
			get
			{
				IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
				return 0 + "/OAEPPadding";
			}
		}

		// Token: 0x0600BD47 RID: 48455 RVA: 0x002A32E0 File Offset: 0x002A14E0
		[Token(Token = "0x600BD47")]
		[Address(RVA = "0x249FF30", Offset = "0x249EF30", VA = "0x18249FF30", 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: 0x0600BD48 RID: 48456 RVA: 0x002A3320 File Offset: 0x002A1520
		[Token(Token = "0x600BD48")]
		[Address(RVA = "0x249FE50", Offset = "0x249EE50", VA = "0x18249FE50", 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: 0x0600BD49 RID: 48457 RVA: 0x002A3358 File Offset: 0x002A1558
		[Token(Token = "0x600BD49")]
		[Address(RVA = "0x249FEC0", Offset = "0x249EEC0", VA = "0x18249FEC0", Slot = "7")]
		public int GetOutputBlockSize()
		{
			IAsymmetricBlockCipher asymmetricBlockCipher = this.engine;
			if (!this.forEncryption)
			{
				int num = this.defHash.Length;
				num += num;
			}
			throw new NullReferenceException();
		}

		// Token: 0x0600BD4A RID: 48458 RVA: 0x002A338C File Offset: 0x002A158C
		[Token(Token = "0x600BD4A")]
		[Address(RVA = "0x24A0050", Offset = "0x249F050", VA = "0x1824A0050", 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: 0x0600BD4B RID: 48459 RVA: 0x002A33B8 File Offset: 0x002A15B8
		[Token(Token = "0x600BD4B")]
		[Address(RVA = "0x249FAB0", Offset = "0x249EAB0", VA = "0x18249FAB0")]
		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: 0x0600BD4C RID: 48460 RVA: 0x002A3590 File Offset: 0x002A1790
		[Token(Token = "0x600BD4C")]
		[Address(RVA = "0x249F6A0", Offset = "0x249E6A0", VA = "0x18249F6A0")]
		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: 0x0600BD4D RID: 48461 RVA: 0x002A36EC File Offset: 0x002A18EC
		[Token(Token = "0x600BD4D")]
		[Address(RVA = "0x235F650", Offset = "0x235E650", VA = "0x18235F650")]
		private void ItoOSP(int i, byte[] sp)
		{
			sp[0] = (byte)i;
			sp[0] = (byte)i;
			sp[0] = (byte)i;
			sp[0] = (byte)i;
		}

		// Token: 0x0600BD4E RID: 48462 RVA: 0x002A3720 File Offset: 0x002A1920
		[Token(Token = "0x600BD4E")]
		[Address(RVA = "0x24A0360", Offset = "0x249F360", VA = "0x1824A0360")]
		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: 0x040077C4 RID: 30660
		[FieldOffset(Offset = "0x10")]
		[Token(Token = "0x40077C4")]
		private byte[] defHash;

		// Token: 0x040077C5 RID: 30661
		[FieldOffset(Offset = "0x18")]
		[Token(Token = "0x40077C5")]
		private IDigest mgf1Hash;

		// Token: 0x040077C6 RID: 30662
		[FieldOffset(Offset = "0x20")]
		[Token(Token = "0x40077C6")]
		private IAsymmetricBlockCipher engine;

		// Token: 0x040077C7 RID: 30663
		[FieldOffset(Offset = "0x28")]
		[Token(Token = "0x40077C7")]
		private SecureRandom random;

		// Token: 0x040077C8 RID: 30664
		[FieldOffset(Offset = "0x30")]
		[Token(Token = "0x40077C8")]
		private bool forEncryption;
	}
}