using System;
using System.Runtime.InteropServices;

namespace System.Security.Cryptography
{
	/// <summary>Converts a <see cref="T:System.Security.Cryptography.CryptoStream" /> from base 64.</summary>
	// Token: 0x02000500 RID: 1280
	[ComVisible(true)]
	public class FromBase64Transform : IDisposable, ICryptoTransform
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.FromBase64Transform" /> class.</summary>
		// Token: 0x06002F3E RID: 12094 RVA: 0x00098240 File Offset: 0x00096440
		public FromBase64Transform()
			: this(FromBase64TransformMode.IgnoreWhiteSpaces)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.FromBase64Transform" /> class with the specified transformation mode.</summary>
		/// <param name="whitespaces">One of the <see cref="T:System.Security.Cryptography.FromBase64Transform" /> values. </param>
		// Token: 0x06002F3F RID: 12095 RVA: 0x0009824C File Offset: 0x0009644C
		public FromBase64Transform(FromBase64TransformMode whitespaces)
		{
			this.mode = whitespaces;
			this.accumulator = new byte[4];
			this.accPtr = 0;
			this.m_disposed = false;
		}

		/// <summary>Releases the unmanaged resources used by the <see cref="T:System.Security.Cryptography.FromBase64Transform" /> and optionally releases the managed resources.</summary>
		// Token: 0x06002F40 RID: 12096 RVA: 0x00098278 File Offset: 0x00096478
		void IDisposable.Dispose()
		{
			this.Dispose(true);
			GC.SuppressFinalize(this);
		}

		/// <summary>Releases the unmanaged resources used by the <see cref="T:System.Security.Cryptography.FromBase64Transform" />.</summary>
		// Token: 0x06002F41 RID: 12097 RVA: 0x00098288 File Offset: 0x00096488
		~FromBase64Transform()
		{
			this.Dispose(false);
		}

		/// <summary>Gets a value that indicates whether multiple blocks can be transformed.</summary>
		/// <returns>Always false.</returns>
		// Token: 0x17000953 RID: 2387
		// (get) Token: 0x06002F42 RID: 12098 RVA: 0x000982C4 File Offset: 0x000964C4
		public bool CanTransformMultipleBlocks
		{
			get
			{
				return false;
			}
		}

		/// <summary>Gets a value indicating whether the current transform can be reused.</summary>
		/// <returns>Always true.</returns>
		// Token: 0x17000954 RID: 2388
		// (get) Token: 0x06002F43 RID: 12099 RVA: 0x000982C8 File Offset: 0x000964C8
		public virtual bool CanReuseTransform
		{
			get
			{
				return true;
			}
		}

		/// <summary>Gets the input block size.</summary>
		/// <returns>The size of the input data blocks in bytes.</returns>
		// Token: 0x17000955 RID: 2389
		// (get) Token: 0x06002F44 RID: 12100 RVA: 0x000982CC File Offset: 0x000964CC
		public int InputBlockSize
		{
			get
			{
				return 1;
			}
		}

		/// <summary>Gets the output block size.</summary>
		/// <returns>The size of the output data blocks in bytes.</returns>
		// Token: 0x17000956 RID: 2390
		// (get) Token: 0x06002F45 RID: 12101 RVA: 0x000982D0 File Offset: 0x000964D0
		public int OutputBlockSize
		{
			get
			{
				return 3;
			}
		}

		/// <summary>Releases all resources used by the <see cref="T:System.Security.Cryptography.FromBase64Transform" />.</summary>
		// Token: 0x06002F46 RID: 12102 RVA: 0x000982D4 File Offset: 0x000964D4
		public void Clear()
		{
			this.Dispose(true);
		}

		/// <summary>Releases the unmanaged resources used by the <see cref="T:System.Security.Cryptography.FromBase64Transform" /> and optionally releases the managed resources.</summary>
		/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources. </param>
		// Token: 0x06002F47 RID: 12103 RVA: 0x000982E0 File Offset: 0x000964E0
		protected virtual void Dispose(bool disposing)
		{
			if (!this.m_disposed)
			{
				if (this.accumulator != null)
				{
					Array.Clear(this.accumulator, 0, this.accumulator.Length);
				}
				if (disposing)
				{
					this.accumulator = null;
				}
				this.m_disposed = true;
			}
		}

		// Token: 0x06002F48 RID: 12104 RVA: 0x0009832C File Offset: 0x0009652C
		private byte lookup(byte input)
		{
			if ((int)input >= this.lookupTable.Length)
			{
				throw new FormatException(Locale.GetText("Invalid character in a Base-64 string."));
			}
			byte b = this.lookupTable[(int)input];
			if (b == 255)
			{
				throw new FormatException(Locale.GetText("Invalid character in a Base-64 string."));
			}
			return b;
		}

		// Token: 0x06002F49 RID: 12105 RVA: 0x0009837C File Offset: 0x0009657C
		private int ProcessBlock(byte[] output, int offset)
		{
			int num = 0;
			if (this.accumulator[3] == 61)
			{
				num++;
			}
			if (this.accumulator[2] == 61)
			{
				num++;
			}
			this.lookupTable = Base64Constants.DecodeTable;
			switch (num)
			{
			case 0:
			{
				int num2 = (int)this.lookup(this.accumulator[0]);
				int num3 = (int)this.lookup(this.accumulator[1]);
				int num4 = (int)this.lookup(this.accumulator[2]);
				int num5 = (int)this.lookup(this.accumulator[3]);
				output[offset++] = (byte)((num2 << 2) | (num3 >> 4));
				output[offset++] = (byte)((num3 << 4) | (num4 >> 2));
				output[offset] = (byte)((num4 << 6) | num5);
				break;
			}
			case 1:
			{
				int num2 = (int)this.lookup(this.accumulator[0]);
				int num3 = (int)this.lookup(this.accumulator[1]);
				int num4 = (int)this.lookup(this.accumulator[2]);
				output[offset++] = (byte)((num2 << 2) | (num3 >> 4));
				output[offset] = (byte)((num3 << 4) | (num4 >> 2));
				break;
			}
			case 2:
			{
				int num2 = (int)this.lookup(this.accumulator[0]);
				int num3 = (int)this.lookup(this.accumulator[1]);
				output[offset] = (byte)((num2 << 2) | (num3 >> 4));
				break;
			}
			}
			return 3 - num;
		}

		// Token: 0x06002F4A RID: 12106 RVA: 0x000984C4 File Offset: 0x000966C4
		private void CheckInputParameters(byte[] inputBuffer, int inputOffset, int inputCount)
		{
			if (inputBuffer == null)
			{
				throw new ArgumentNullException("inputBuffer");
			}
			if (inputOffset < 0)
			{
				throw new ArgumentOutOfRangeException("inputOffset", "< 0");
			}
			if (inputCount > inputBuffer.Length)
			{
				throw new OutOfMemoryException("inputCount " + Locale.GetText("Overflow"));
			}
			if (inputOffset > inputBuffer.Length - inputCount)
			{
				throw new ArgumentException("inputOffset", Locale.GetText("Overflow"));
			}
			if (inputCount < 0)
			{
				throw new OverflowException("inputCount < 0");
			}
		}

		/// <summary>Converts the specified region of the input byte array from base 64 and copies the result to the specified region of the output byte array.</summary>
		/// <returns>The number of bytes written.</returns>
		/// <param name="inputBuffer">The input to compute from base 64. </param>
		/// <param name="inputOffset">The offset into the input byte array from which to begin using data. </param>
		/// <param name="inputCount">The number of bytes in the input byte array to use as data. </param>
		/// <param name="outputBuffer">The output to which to write the result. </param>
		/// <param name="outputOffset">The offset into the output byte array from which to begin writing data. </param>
		/// <exception cref="T:System.ObjectDisposedException">The current <see cref="T:System.Security.Cryptography.FromBase64Transform" /> object has already been disposed. </exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="inputCount" /> uses an invalid value.-or-<paramref name="inputBuffer" /> has an invalid offset length.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="inputOffset" /> is out of range. This parameter requires a non-negative number.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inputBuffer" /> is null.</exception>
		// Token: 0x06002F4B RID: 12107 RVA: 0x00098550 File Offset: 0x00096750
		public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
		{
			if (this.m_disposed)
			{
				throw new ObjectDisposedException("FromBase64Transform");
			}
			this.CheckInputParameters(inputBuffer, inputOffset, inputCount);
			if (outputBuffer == null || outputOffset < 0)
			{
				throw new FormatException("outputBuffer");
			}
			int num = 0;
			while (inputCount > 0)
			{
				if (this.accPtr < 4)
				{
					byte b = inputBuffer[inputOffset++];
					if (this.mode == FromBase64TransformMode.IgnoreWhiteSpaces)
					{
						if (!char.IsWhiteSpace((char)b))
						{
							this.accumulator[this.accPtr++] = b;
						}
					}
					else
					{
						this.accumulator[this.accPtr++] = b;
					}
				}
				if (this.accPtr == 4)
				{
					num += this.ProcessBlock(outputBuffer, outputOffset);
					outputOffset += 3;
					this.accPtr = 0;
				}
				inputCount--;
			}
			return num;
		}

		/// <summary>Converts the specified region of the specified byte array from base 64.</summary>
		/// <returns>The computed conversion.</returns>
		/// <param name="inputBuffer">The input to convert from base 64. </param>
		/// <param name="inputOffset">The offset into the byte array from which to begin using data. </param>
		/// <param name="inputCount">The number of bytes in the byte array to use as data. </param>
		/// <exception cref="T:System.ObjectDisposedException">The current <see cref="T:System.Security.Cryptography.FromBase64Transform" /> object has already been disposed. </exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="inputBuffer" /> has an invalid offset length.-or-<paramref name="inputCount" /> has an invalid value.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="inputOffset" /> is out of range. This parameter requires a non-negative number.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inputBuffer" /> is null.</exception>
		// Token: 0x06002F4C RID: 12108 RVA: 0x00098634 File Offset: 0x00096834
		public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
		{
			if (this.m_disposed)
			{
				throw new ObjectDisposedException("FromBase64Transform");
			}
			this.CheckInputParameters(inputBuffer, inputOffset, inputCount);
			int num = 0;
			int num2 = 0;
			if (this.mode == FromBase64TransformMode.IgnoreWhiteSpaces)
			{
				int num3 = inputOffset;
				for (int i = 0; i < inputCount; i++)
				{
					if (char.IsWhiteSpace((char)inputBuffer[num3]))
					{
						num++;
					}
					num3++;
				}
				if (num == inputCount)
				{
					return new byte[0];
				}
				int num4 = inputOffset + inputCount - 1;
				int j = Math.Min(2, inputCount);
				while (j > 0)
				{
					char c = (char)inputBuffer[num4--];
					if (c == '=')
					{
						num2++;
						j--;
					}
					else if (!char.IsWhiteSpace(c))
					{
						break;
					}
				}
			}
			else
			{
				if (inputBuffer[inputOffset + inputCount - 1] == 61)
				{
					num2++;
				}
				if (inputBuffer[inputOffset + inputCount - 2] == 61)
				{
					num2++;
				}
			}
			if (inputCount < 4 && num2 < 2)
			{
				if (this.accPtr > 2 && this.accumulator[3] == 61)
				{
					num2++;
				}
				if (this.accPtr > 1 && this.accumulator[2] == 61)
				{
					num2++;
				}
			}
			int num5 = (this.accPtr + inputCount - num >> 2) * 3 - num2;
			if (num5 <= 0)
			{
				return new byte[0];
			}
			byte[] array = new byte[num5];
			this.TransformBlock(inputBuffer, inputOffset, inputCount, array, 0);
			return array;
		}

		// Token: 0x0400134B RID: 4939
		private const byte TerminatorByte = 61;

		// Token: 0x0400134C RID: 4940
		private FromBase64TransformMode mode;

		// Token: 0x0400134D RID: 4941
		private byte[] accumulator;

		// Token: 0x0400134E RID: 4942
		private int accPtr;

		// Token: 0x0400134F RID: 4943
		private bool m_disposed;

		// Token: 0x04001350 RID: 4944
		private byte[] lookupTable;
	}
}