using System;
using System.Runtime.InteropServices;
using System.Text;

namespace System.Security.Cryptography
{
	/// <summary>Derives a key from a password using an extension of the PBKDF1 algorithm.</summary>
	// Token: 0x02000514 RID: 1300
	[ComVisible(true)]
	public class PasswordDeriveBytes : DeriveBytes
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class with the password and key salt to use to derive the key.</summary>
		/// <param name="strPassword">The password for which to derive the key. </param>
		/// <param name="rgbSalt">The key salt to use to derive the key. </param>
		// Token: 0x06002FB8 RID: 12216 RVA: 0x0009A3C8 File Offset: 0x000985C8
		public PasswordDeriveBytes(string strPassword, byte[] rgbSalt)
		{
			this.Prepare(strPassword, rgbSalt, "SHA1", 100);
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class with the password, key salt, and cryptographic service provider (CSP) parameters to use to derive the key.</summary>
		/// <param name="strPassword">The password for which to derive the key. </param>
		/// <param name="rgbSalt">The key salt to use to derive the key. </param>
		/// <param name="cspParams">The CSP parameters for the operation. </param>
		// Token: 0x06002FB9 RID: 12217 RVA: 0x0009A3E0 File Offset: 0x000985E0
		public PasswordDeriveBytes(string strPassword, byte[] rgbSalt, CspParameters cspParams)
		{
			this.Prepare(strPassword, rgbSalt, "SHA1", 100);
			if (cspParams != null)
			{
				throw new NotSupportedException(Locale.GetText("CspParameters not supported by Mono for PasswordDeriveBytes."));
			}
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class with the password, key salt, hash name, and number of iterations to use to derive the key.</summary>
		/// <param name="strPassword">The password for which to derive the key. </param>
		/// <param name="rgbSalt">The key salt to use to derive the key. </param>
		/// <param name="strHashName">The name of the hash algorithm for the operation. </param>
		/// <param name="iterations">The number of iterations for the operation. </param>
		// Token: 0x06002FBA RID: 12218 RVA: 0x0009A410 File Offset: 0x00098610
		public PasswordDeriveBytes(string strPassword, byte[] rgbSalt, string strHashName, int iterations)
		{
			this.Prepare(strPassword, rgbSalt, strHashName, iterations);
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class with the password, key salt, hash name, number of iterations, and cryptographic service provider (CSP) parameters to use to derive the key.</summary>
		/// <param name="strPassword">The password for which to derive the key. </param>
		/// <param name="rgbSalt">The key salt to use to derive the key. </param>
		/// <param name="strHashName">The name of the hash algorithm for the operation. </param>
		/// <param name="iterations">The number of iterations for the operation. </param>
		/// <param name="cspParams">The CSP parameters for the operation. </param>
		// Token: 0x06002FBB RID: 12219 RVA: 0x0009A424 File Offset: 0x00098624
		public PasswordDeriveBytes(string strPassword, byte[] rgbSalt, string strHashName, int iterations, CspParameters cspParams)
		{
			this.Prepare(strPassword, rgbSalt, strHashName, iterations);
			if (cspParams != null)
			{
				throw new NotSupportedException(Locale.GetText("CspParameters not supported by Mono for PasswordDeriveBytes."));
			}
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class specifying the password and key salt to use to derive the key.</summary>
		/// <param name="password">The password to derive the key for.</param>
		/// <param name="salt">The key salt to use to derive the key.</param>
		// Token: 0x06002FBC RID: 12220 RVA: 0x0009A45C File Offset: 0x0009865C
		public PasswordDeriveBytes(byte[] password, byte[] salt)
		{
			this.Prepare(password, salt, "SHA1", 100);
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class specifying the password, key salt, and cryptographic service provider (CSP) to use to derive the key.</summary>
		/// <param name="password">The password to derive the key for.</param>
		/// <param name="salt">The key salt to use to derive the key.</param>
		/// <param name="cspParams">The cryptographic service provider (CSP) parameters for the operation.</param>
		// Token: 0x06002FBD RID: 12221 RVA: 0x0009A474 File Offset: 0x00098674
		public PasswordDeriveBytes(byte[] password, byte[] salt, CspParameters cspParams)
		{
			this.Prepare(password, salt, "SHA1", 100);
			if (cspParams != null)
			{
				throw new NotSupportedException(Locale.GetText("CspParameters not supported by Mono for PasswordDeriveBytes."));
			}
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class specifying the password, key salt, hash name, and iterations to use to derive the key.</summary>
		/// <param name="password">The password to derive the key for.</param>
		/// <param name="salt">The key salt to use to derive the key.</param>
		/// <param name="hashName">The hash algorithm to use to derive the key.</param>
		/// <param name="iterations">The iteration count to use to derive the key.</param>
		// Token: 0x06002FBE RID: 12222 RVA: 0x0009A4A4 File Offset: 0x000986A4
		public PasswordDeriveBytes(byte[] password, byte[] salt, string hashName, int iterations)
		{
			this.Prepare(password, salt, hashName, iterations);
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> class specifying the password, key salt, hash name, iterations, and cryptographic service provider (CSP) to use to derive the key.</summary>
		/// <param name="password">The password to derive the key for.</param>
		/// <param name="salt">The key salt to use to derive the key.</param>
		/// <param name="hashName">The hash algorithm to use to derive the key.</param>
		/// <param name="iterations">The iteration count to use to derive the key.</param>
		/// <param name="cspParams">The cryptographic service provider (CSP) parameters for the operation.</param>
		// Token: 0x06002FBF RID: 12223 RVA: 0x0009A4B8 File Offset: 0x000986B8
		public PasswordDeriveBytes(byte[] password, byte[] salt, string hashName, int iterations, CspParameters cspParams)
		{
			this.Prepare(password, salt, hashName, iterations);
			if (cspParams != null)
			{
				throw new NotSupportedException(Locale.GetText("CspParameters not supported by Mono for PasswordDeriveBytes."));
			}
		}

		// Token: 0x06002FC0 RID: 12224 RVA: 0x0009A4F0 File Offset: 0x000986F0
		~PasswordDeriveBytes()
		{
			if (this.initial != null)
			{
				Array.Clear(this.initial, 0, this.initial.Length);
				this.initial = null;
			}
			Array.Clear(this.password, 0, this.password.Length);
		}

		// Token: 0x06002FC1 RID: 12225 RVA: 0x0009A560 File Offset: 0x00098760
		private void Prepare(string strPassword, byte[] rgbSalt, string strHashName, int iterations)
		{
			if (strPassword == null)
			{
				throw new ArgumentNullException("strPassword");
			}
			byte[] bytes = Encoding.UTF8.GetBytes(strPassword);
			this.Prepare(bytes, rgbSalt, strHashName, iterations);
			Array.Clear(bytes, 0, bytes.Length);
		}

		// Token: 0x06002FC2 RID: 12226 RVA: 0x0009A5A0 File Offset: 0x000987A0
		private void Prepare(byte[] password, byte[] rgbSalt, string strHashName, int iterations)
		{
			if (password == null)
			{
				throw new ArgumentNullException("password");
			}
			this.password = (byte[])password.Clone();
			this.Salt = rgbSalt;
			this.HashName = strHashName;
			this.IterationCount = iterations;
			this.state = 0;
		}

		/// <summary>Gets or sets the name of the hash algorithm for the operation.</summary>
		/// <returns>The name of the hash algorithm for the operation.</returns>
		/// <exception cref="T:System.Security.Cryptography.CryptographicException">The name of the hash value is fixed and an attempt is made to change this value. </exception>
		// Token: 0x1700096E RID: 2414
		// (get) Token: 0x06002FC3 RID: 12227 RVA: 0x0009A5EC File Offset: 0x000987EC
		// (set) Token: 0x06002FC4 RID: 12228 RVA: 0x0009A5F4 File Offset: 0x000987F4
		public string HashName
		{
			get
			{
				return this.HashNameValue;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("HashName");
				}
				if (this.state != 0)
				{
					throw new CryptographicException(Locale.GetText("Can't change this property at this stage"));
				}
				this.HashNameValue = value;
			}
		}

		/// <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.Security.Cryptography.CryptographicException">The number of iterations is fixed and an attempt is made to change this value. </exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The property cannot be set because its value is out of range. This property requires a non-negative number.</exception>
		// Token: 0x1700096F RID: 2415
		// (get) Token: 0x06002FC5 RID: 12229 RVA: 0x0009A62C File Offset: 0x0009882C
		// (set) Token: 0x06002FC6 RID: 12230 RVA: 0x0009A634 File Offset: 0x00098834
		public int IterationCount
		{
			get
			{
				return this.IterationsValue;
			}
			set
			{
				if (value < 1)
				{
					throw new ArgumentOutOfRangeException("> 0", "IterationCount");
				}
				if (this.state != 0)
				{
					throw new CryptographicException(Locale.GetText("Can't change this property at this stage"));
				}
				this.IterationsValue = 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.Security.Cryptography.CryptographicException">The key salt value is fixed and an attempt is made to change this value. </exception>
		// Token: 0x17000970 RID: 2416
		// (get) Token: 0x06002FC7 RID: 12231 RVA: 0x0009A670 File Offset: 0x00098870
		// (set) Token: 0x06002FC8 RID: 12232 RVA: 0x0009A690 File Offset: 0x00098890
		public byte[] Salt
		{
			get
			{
				if (this.SaltValue == null)
				{
					return null;
				}
				return (byte[])this.SaltValue.Clone();
			}
			set
			{
				if (this.state != 0)
				{
					throw new CryptographicException(Locale.GetText("Can't change this property at this stage"));
				}
				if (value != null)
				{
					this.SaltValue = (byte[])value.Clone();
				}
				else
				{
					this.SaltValue = null;
				}
			}
		}

		/// <summary>Derives a cryptographic key from the <see cref="T:System.Security.Cryptography.PasswordDeriveBytes" /> object.</summary>
		/// <returns>The derived key.</returns>
		/// <param name="algname">The algorithm name for which to derive the key. </param>
		/// <param name="alghashname">The hash algorithm name to use to derive the key. </param>
		/// <param name="keySize">The size of the key, in bits, to derive. </param>
		/// <param name="rgbIV">The initialization vector (IV) to use to derive the key. </param>
		/// <exception cref="T:System.Security.Cryptography.CryptographicException">The <paramref name="keySize" /> parameter is incorrect.-or- The cryptographic service provider (CSP) cannot be acquired.-or- The <paramref name="algname" /> parameter is not a valid algorithm name.-or- The <paramref name="alghashname" /> parameter is not a valid hash algorithm name. </exception>
		/// <PermissionSet>
		///   <IPermission class="System.Security.Permissions.KeyContainerPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" />
		/// </PermissionSet>
		// Token: 0x06002FC9 RID: 12233 RVA: 0x0009A6DC File Offset: 0x000988DC
		public byte[] CryptDeriveKey(string algname, string alghashname, int keySize, byte[] rgbIV)
		{
			if (keySize > 128)
			{
				throw new CryptographicException(Locale.GetText("Key Size can't be greater than 128 bits"));
			}
			throw new NotSupportedException(Locale.GetText("CspParameters not supported by Mono"));
		}

		/// <summary>Returns pseudo-random key bytes.</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>
		// Token: 0x06002FCA RID: 12234 RVA: 0x0009A714 File Offset: 0x00098914
		[Obsolete("see Rfc2898DeriveBytes for PKCS#5 v2 support")]
		public override byte[] GetBytes(int cb)
		{
			if (cb < 1)
			{
				throw new IndexOutOfRangeException("cb");
			}
			if (this.state == 0)
			{
				this.Reset();
				this.state = 1;
			}
			byte[] array = new byte[cb];
			int i = 0;
			int num = Math.Max(1, this.IterationsValue - 1);
			if (this.output == null)
			{
				this.output = this.initial;
				for (int j = 0; j < num - 1; j++)
				{
					this.output = this.hash.ComputeHash(this.output);
				}
			}
			while (i < cb)
			{
				byte[] array2;
				if (this.hashnumber == 0)
				{
					array2 = this.hash.ComputeHash(this.output);
				}
				else
				{
					if (this.hashnumber >= 1000)
					{
						throw new CryptographicException(Locale.GetText("too long"));
					}
					string text = Convert.ToString(this.hashnumber);
					array2 = new byte[this.output.Length + text.Length];
					for (int k = 0; k < text.Length; k++)
					{
						array2[k] = (byte)text[k];
					}
					Buffer.BlockCopy(this.output, 0, array2, text.Length, this.output.Length);
					array2 = this.hash.ComputeHash(array2);
				}
				int num2 = array2.Length - this.position;
				int num3 = Math.Min(cb - i, num2);
				Buffer.BlockCopy(array2, this.position, array, i, num3);
				i += num3;
				this.position += num3;
				while (this.position >= array2.Length)
				{
					this.position -= array2.Length;
					this.hashnumber++;
				}
			}
			return array;
		}

		/// <summary>Resets the state of the operation.</summary>
		// Token: 0x06002FCB RID: 12235 RVA: 0x0009A8EC File Offset: 0x00098AEC
		public override void Reset()
		{
			this.state = 0;
			this.position = 0;
			this.hashnumber = 0;
			this.hash = HashAlgorithm.Create(this.HashNameValue);
			if (this.SaltValue != null)
			{
				this.hash.TransformBlock(this.password, 0, this.password.Length, this.password, 0);
				this.hash.TransformFinalBlock(this.SaltValue, 0, this.SaltValue.Length);
				this.initial = this.hash.Hash;
			}
			else
			{
				this.initial = this.hash.ComputeHash(this.password);
			}
		}

		// Token: 0x04001377 RID: 4983
		private string HashNameValue;

		// Token: 0x04001378 RID: 4984
		private byte[] SaltValue;

		// Token: 0x04001379 RID: 4985
		private int IterationsValue;

		// Token: 0x0400137A RID: 4986
		private HashAlgorithm hash;

		// Token: 0x0400137B RID: 4987
		private int state;

		// Token: 0x0400137C RID: 4988
		private byte[] password;

		// Token: 0x0400137D RID: 4989
		private byte[] initial;

		// Token: 0x0400137E RID: 4990
		private byte[] output;

		// Token: 0x0400137F RID: 4991
		private int position;

		// Token: 0x04001380 RID: 4992
		private int hashnumber;
	}
}