using System;
using System.Runtime.InteropServices;
using System.Text;
using Mono.Security.Cryptography;

namespace System.Security.Cryptography
{
	/// <summary>Implements password-based key derivation functionality, PBKDF2, by using a pseudo-random number generator based on <see cref="T:System.Security.Cryptography.HMACSHA1" />.</summary>
	// Token: 0x02000525 RID: 1317
	[ComVisible(true)]
	public class Rfc2898DeriveBytes : DeriveBytes
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.Rfc2898DeriveBytes" /> class using a password and salt to derive the key.</summary>
		/// <param name="password">The password used to derive the key. </param>
		/// <param name="salt">The key salt used to derive the key. </param>
		/// <exception cref="T:System.ArgumentException">The specified salt size is smaller than 8 bytes or the iteration count is less than 1. </exception>
		/// <exception cref="T:System.ArgumentNullException">The password or salt is null. </exception>
		// Token: 0x06003060 RID: 12384 RVA: 0x0009E118 File Offset: 0x0009C318
		public Rfc2898DeriveBytes(string password, byte[] salt)
			: this(password, salt, 1000)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.Rfc2898DeriveBytes" /> class using a password, a salt, and number of iterations to derive the key.</summary>
		/// <param name="password">The password used to derive the key. </param>
		/// <param name="salt">The key salt used to derive the key. </param>
		/// <param name="iterations">The number of iterations for the operation. </param>
		/// <exception cref="T:System.ArgumentException">The specified salt size is smaller than 8 bytes or the iteration count is less than 1. </exception>
		/// <exception cref="T:System.ArgumentNullException">The password or salt is null. </exception>
		// Token: 0x06003061 RID: 12385 RVA: 0x0009E128 File Offset: 0x0009C328
		public Rfc2898DeriveBytes(string password, byte[] salt, int iterations)
		{
			if (password == null)
			{
				throw new ArgumentNullException("password");
			}
			this.Salt = salt;
			this.IterationCount = iterations;
			this._hmac = new HMACSHA1(Encoding.UTF8.GetBytes(password));
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.Rfc2898DeriveBytes" /> class using a password, a salt, and number of iterations to derive the key.</summary>
		/// <param name="password">The password used to derive the key. </param>
		/// <param name="salt">The key salt used to derive the key.</param>
		/// <param name="iterations">The number of iterations for the operation. </param>
		/// <exception cref="T:System.ArgumentException">The specified salt size is smaller than 8 bytes or the iteration count is less than 1. </exception>
		/// <exception cref="T:System.ArgumentNullException">The password or salt is null. </exception>
		// Token: 0x06003062 RID: 12386 RVA: 0x0009E170 File Offset: 0x0009C370
		public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations)
		{
			if (password == null)
			{
				throw new ArgumentNullException("password");
			}
			this.Salt = salt;
			this.IterationCount = iterations;
			this._hmac = new HMACSHA1(password);
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.Rfc2898DeriveBytes" /> class using the password and salt size to derive the key.</summary>
		/// <param name="password">The password used to derive the key. </param>
		/// <param name="saltSize">The size of the random salt that you want the class to generate. </param>
		/// <exception cref="T:System.ArgumentException">The specified salt size is smaller than 8 bytes. </exception>
		/// <exception cref="T:System.ArgumentNullException">The password or salt is null. </exception>
		// Token: 0x06003063 RID: 12387 RVA: 0x0009E1B0 File Offset: 0x0009C3B0
		public Rfc2898DeriveBytes(string password, int saltSize)
			: this(password, saltSize, 1000)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.Rfc2898DeriveBytes" /> class using a password, a salt size, and number of iterations to derive the key.</summary>
		/// <param name="password">The password used to derive the key. </param>
		/// <param name="saltSize">The size of the random salt that you want the class to generate. </param>
		/// <param name="iterations">The number of iterations for the operation. </param>
		/// <exception cref="T:System.ArgumentException">The specified salt size is smaller than 8 bytes or the iteration count is less than 1. </exception>
		/// <exception cref="T:System.ArgumentNullException">The password or salt is null. </exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="iterations " />is out of range. This parameter requires a non-negative number.</exception>
		// Token: 0x06003064 RID: 12388 RVA: 0x0009E1C0 File Offset: 0x0009C3C0
		public Rfc2898DeriveBytes(string password, int saltSize, int iterations)
		{
			if (password == null)
			{
				throw new ArgumentNullException("password");
			}
			if (saltSize < 0)
			{
				throw new ArgumentOutOfRangeException("invalid salt length");
			}
			this.Salt = KeyBuilder.Key(saltSize);
			this.IterationCount = iterations;
			this._hmac = new HMACSHA1(Encoding.UTF8.GetBytes(password));
		}

		/// <summary>Gets or sets the number of iterations for the operation.</summary>
		/// <returns>The number of iterations for the operation.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The number of iterations is less than 1. </exception>
		// Token: 0x17000984 RID: 2436
		// (get) Token: 0x06003065 RID: 12389 RVA: 0x0009E220 File Offset: 0x0009C420
		// (set) Token: 0x06003066 RID: 12390 RVA: 0x0009E228 File Offset: 0x0009C428
		public int IterationCount
		{
			get
			{
				return this._iteration;
			}
			set
			{
				if (value < 1)
				{
					throw new ArgumentOutOfRangeException("IterationCount < 1");
				}
				this._iteration = value;
			}
		}

		/// <summary>Gets or sets the key salt value for the operation.</summary>
		/// <returns>The key salt value for the operation.</returns>
		/// <exception cref="T:System.ArgumentException">The specified salt size is smaller than 8 bytes. </exception>
		/// <exception cref="T:System.ArgumentNullException">The salt is null. </exception>
		// Token: 0x17000985 RID: 2437
		// (get) Token: 0x06003067 RID: 12391 RVA: 0x0009E244 File Offset: 0x0009C444
		// (set) Token: 0x06003068 RID: 12392 RVA: 0x0009E258 File Offset: 0x0009C458
		public byte[] Salt
		{
			get
			{
				return (byte[])this._salt.Clone();
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("Salt");
				}
				if (value.Length < 8)
				{
					throw new ArgumentException("Salt < 8 bytes");
				}
				this._salt = (byte[])value.Clone();
			}
		}

		// Token: 0x06003069 RID: 12393 RVA: 0x0009E29C File Offset: 0x0009C49C
		private byte[] F(byte[] s, int c, int i)
		{
			s[s.Length - 4] = (byte)(i >> 24);
			s[s.Length - 3] = (byte)(i >> 16);
			s[s.Length - 2] = (byte)(i >> 8);
			s[s.Length - 1] = (byte)i;
			byte[] array = this._hmac.ComputeHash(s);
			byte[] array2 = array;
			for (int j = 1; j < c; j++)
			{
				byte[] array3 = this._hmac.ComputeHash(array2);
				for (int k = 0; k < 20; k++)
				{
					array[k] ^= array3[k];
				}
				array2 = array3;
			}
			return array;
		}

		/// <summary>Returns the pseudo-random key for this object.</summary>
		/// <returns>A byte array filled with pseudo-random key bytes.</returns>
		/// <param name="cb">The number of pseudo-random key bytes to generate. </param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="cb " />is out of range. This parameter requires a non-negative number.</exception>
		// Token: 0x0600306A RID: 12394 RVA: 0x0009E32C File Offset: 0x0009C52C
		public override byte[] GetBytes(int cb)
		{
			if (cb < 1)
			{
				throw new ArgumentOutOfRangeException("cb");
			}
			int num = cb / 20;
			int num2 = cb % 20;
			if (num2 != 0)
			{
				num++;
			}
			byte[] array = new byte[cb];
			int num3 = 0;
			if (this._pos > 0)
			{
				int num4 = Math.Min(20 - this._pos, cb);
				Buffer.BlockCopy(this._buffer, this._pos, array, 0, num4);
				if (num4 >= cb)
				{
					return array;
				}
				this._pos = 0;
				num3 = num4;
			}
			byte[] array2 = new byte[this._salt.Length + 4];
			Buffer.BlockCopy(this._salt, 0, array2, 0, this._salt.Length);
			for (int i = 1; i <= num; i++)
			{
				this._buffer = this.F(array2, this._iteration, ++this._f);
				int num5 = ((i != num) ? 20 : (array.Length - num3));
				Buffer.BlockCopy(this._buffer, this._pos, array, num3, num5);
				num3 += this._pos + num5;
				this._pos = ((num5 != 20) ? num5 : 0);
			}
			return array;
		}

		/// <summary>Resets the state of the operation.</summary>
		// Token: 0x0600306B RID: 12395 RVA: 0x0009E464 File Offset: 0x0009C664
		public override void Reset()
		{
			this._buffer = null;
			this._pos = 0;
			this._f = 0;
		}

		// Token: 0x040013AF RID: 5039
		private const int defaultIterations = 1000;

		// Token: 0x040013B0 RID: 5040
		private int _iteration;

		// Token: 0x040013B1 RID: 5041
		private byte[] _salt;

		// Token: 0x040013B2 RID: 5042
		private HMACSHA1 _hmac;

		// Token: 0x040013B3 RID: 5043
		private byte[] _buffer;

		// Token: 0x040013B4 RID: 5044
		private int _pos;

		// Token: 0x040013B5 RID: 5045
		private int _f;
	}
}