using System;
using System.IO;
using System.Runtime.InteropServices;
using Cpp2IlInjected;

namespace System.Security.Cryptography
{
	/// <summary>Represents the base class from which all implementations of cryptographic hash algorithms must derive.</summary>
	// Token: 0x02000405 RID: 1029
	[Token(Token = "0x2000405")]
	[ComVisible(true)]
	public abstract class HashAlgorithm : IDisposable, ICryptoTransform
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Security.Cryptography.HashAlgorithm" /> class.</summary>
		// Token: 0x060023B4 RID: 9140 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60023B4")]
		[Address(RVA = "0x412370", Offset = "0x411370", VA = "0x180412370")]
		protected HashAlgorithm()
		{
		}

		/// <summary>Gets the size, in bits, of the computed hash code.</summary>
		/// <returns>The size, in bits, of the computed hash code.</returns>
		// Token: 0x1700050E RID: 1294
		// (get) Token: 0x060023B5 RID: 9141 RVA: 0x00016D70 File Offset: 0x00014F70
		[Token(Token = "0x1700050E")]
		public virtual int HashSize
		{
			[Token(Token = "0x60023B5")]
			[Address(RVA = "0x40F000", Offset = "0x40E000", VA = "0x18040F000", Slot = "11")]
			get
			{
				return 0;
			}
		}

		/// <summary>Gets the value of the computed hash code.</summary>
		/// <returns>The current value of the computed hash code.</returns>
		/// <exception cref="T:System.Security.Cryptography.CryptographicUnexpectedOperationException">
		///   <see cref="F:System.Security.Cryptography.HashAlgorithm.HashValue" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ObjectDisposedException">The object has already been disposed.</exception>
		// Token: 0x1700050F RID: 1295
		// (get) Token: 0x060023B6 RID: 9142 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x1700050F")]
		public virtual byte[] Hash
		{
			[Token(Token = "0x60023B6")]
			[Address(RVA = "0xC0C3C0", Offset = "0xC0B3C0", VA = "0x180C0C3C0", Slot = "12")]
			get
			{
				return null;
			}
		}

		/// <summary>Creates an instance of the default implementation of a hash algorithm.</summary>
		/// <returns>A new <see cref="T:System.Security.Cryptography.SHA1CryptoServiceProvider" /> instance, unless the default settings have been changed using the .</returns>
		// Token: 0x060023B7 RID: 9143 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60023B7")]
		[Address(RVA = "0xC0BDC0", Offset = "0xC0ADC0", VA = "0x180C0BDC0")]
		public static HashAlgorithm Create()
		{
			return null;
		}

		/// <summary>Creates an instance of the specified implementation of a hash algorithm.</summary>
		/// <param name="hashName">The hash algorithm implementation to use. The following table shows the valid values for the <paramref name="hashName" /> parameter and the algorithms they map to.  
		///   Parameter value  
		///
		///   Implements  
		///
		///   SHA  
		///
		///  <see cref="T:System.Security.Cryptography.SHA1CryptoServiceProvider" /> SHA1  
		///
		///  <see cref="T:System.Security.Cryptography.SHA1CryptoServiceProvider" /> System.Security.Cryptography.SHA1  
		///
		///  <see cref="T:System.Security.Cryptography.SHA1CryptoServiceProvider" /> System.Security.Cryptography.HashAlgorithm  
		///
		///  <see cref="T:System.Security.Cryptography.SHA1CryptoServiceProvider" /> MD5  
		///
		///  <see cref="T:System.Security.Cryptography.MD5CryptoServiceProvider" /> System.Security.Cryptography.MD5  
		///
		///  <see cref="T:System.Security.Cryptography.MD5CryptoServiceProvider" /> SHA256  
		///
		///  <see cref="T:System.Security.Cryptography.SHA256Managed" /> SHA-256  
		///
		///  <see cref="T:System.Security.Cryptography.SHA256Managed" /> System.Security.Cryptography.SHA256  
		///
		///  <see cref="T:System.Security.Cryptography.SHA256Managed" /> SHA384  
		///
		///  <see cref="T:System.Security.Cryptography.SHA384Managed" /> SHA-384  
		///
		///  <see cref="T:System.Security.Cryptography.SHA384Managed" /> System.Security.Cryptography.SHA384  
		///
		///  <see cref="T:System.Security.Cryptography.SHA384Managed" /> SHA512  
		///
		///  <see cref="T:System.Security.Cryptography.SHA512Managed" /> SHA-512  
		///
		///  <see cref="T:System.Security.Cryptography.SHA512Managed" /> System.Security.Cryptography.SHA512  
		///
		///  <see cref="T:System.Security.Cryptography.SHA512Managed" /></param>
		/// <returns>A new instance of the specified hash algorithm, or <see langword="null" /> if <paramref name="hashName" /> is not a valid hash algorithm.</returns>
		// Token: 0x060023B8 RID: 9144 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60023B8")]
		[Address(RVA = "0xC0BE10", Offset = "0xC0AE10", VA = "0x180C0BE10")]
		public static HashAlgorithm Create(string hashName)
		{
			return null;
		}

		/// <summary>Computes the hash value for the specified <see cref="T:System.IO.Stream" /> object.</summary>
		/// <param name="inputStream">The input to compute the hash code for.</param>
		/// <returns>The computed hash code.</returns>
		/// <exception cref="T:System.ObjectDisposedException">The object has already been disposed.</exception>
		// Token: 0x060023B9 RID: 9145 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60023B9")]
		[Address(RVA = "0xC0BA40", Offset = "0xC0AA40", VA = "0x180C0BA40")]
		public byte[] ComputeHash(Stream inputStream)
		{
			return null;
		}

		/// <summary>Computes the hash value for the specified byte array.</summary>
		/// <param name="buffer">The input to compute the hash code for.</param>
		/// <returns>The computed hash code.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="buffer" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ObjectDisposedException">The object has already been disposed.</exception>
		// Token: 0x060023BA RID: 9146 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60023BA")]
		[Address(RVA = "0xC0B900", Offset = "0xC0A900", VA = "0x180C0B900")]
		public byte[] ComputeHash(byte[] buffer)
		{
			return null;
		}

		/// <summary>Computes the hash value for the specified region of the specified byte array.</summary>
		/// <param name="buffer">The input to compute the hash code for.</param>
		/// <param name="offset">The offset into the byte array from which to begin using data.</param>
		/// <param name="count">The number of bytes in the array to use as data.</param>
		/// <returns>The computed hash code.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="count" /> is an invalid value.  
		/// -or-  
		/// <paramref name="buffer" /> length is invalid.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="buffer" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="offset" /> is out of range. This parameter requires a non-negative number.</exception>
		/// <exception cref="T:System.ObjectDisposedException">The object has already been disposed.</exception>
		// Token: 0x060023BB RID: 9147 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60023BB")]
		[Address(RVA = "0xC0BBA0", Offset = "0xC0ABA0", VA = "0x180C0BBA0")]
		public byte[] ComputeHash(byte[] buffer, int offset, int count)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, gets the input block size.</summary>
		/// <returns>The input block size.</returns>
		// Token: 0x17000510 RID: 1296
		// (get) Token: 0x060023BC RID: 9148 RVA: 0x00016D88 File Offset: 0x00014F88
		[Token(Token = "0x17000510")]
		public virtual int InputBlockSize
		{
			[Token(Token = "0x60023BC")]
			[Address(RVA = "0x4E8690", Offset = "0x4E7690", VA = "0x1804E8690", Slot = "13")]
			get
			{
				return 0;
			}
		}

		/// <summary>When overridden in a derived class, gets the output block size.</summary>
		/// <returns>The output block size.</returns>
		// Token: 0x17000511 RID: 1297
		// (get) Token: 0x060023BD RID: 9149 RVA: 0x00016DA0 File Offset: 0x00014FA0
		[Token(Token = "0x17000511")]
		public virtual int OutputBlockSize
		{
			[Token(Token = "0x60023BD")]
			[Address(RVA = "0x4E8690", Offset = "0x4E7690", VA = "0x1804E8690", Slot = "14")]
			get
			{
				return 0;
			}
		}

		/// <summary>When overridden in a derived class, gets a value indicating whether multiple blocks can be transformed.</summary>
		/// <returns>
		///   <see langword="true" /> if multiple blocks can be transformed; otherwise, <see langword="false" />.</returns>
		// Token: 0x17000512 RID: 1298
		// (get) Token: 0x060023BE RID: 9150 RVA: 0x00016DB8 File Offset: 0x00014FB8
		[Token(Token = "0x17000512")]
		public virtual bool CanTransformMultipleBlocks
		{
			[Token(Token = "0x60023BE")]
			[Address(RVA = "0x4246A0", Offset = "0x4236A0", VA = "0x1804246A0", Slot = "15")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets a value indicating whether the current transform can be reused.</summary>
		/// <returns>Always <see langword="true" />.</returns>
		// Token: 0x17000513 RID: 1299
		// (get) Token: 0x060023BF RID: 9151 RVA: 0x00016DD0 File Offset: 0x00014FD0
		[Token(Token = "0x17000513")]
		public virtual bool CanReuseTransform
		{
			[Token(Token = "0x60023BF")]
			[Address(RVA = "0x4246A0", Offset = "0x4236A0", VA = "0x1804246A0", Slot = "16")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Computes the hash value for the specified region of the input byte array and copies the specified region of the input byte array to the specified region of the output byte array.</summary>
		/// <param name="inputBuffer">The input to compute the hash code for.</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">A copy of the part of the input array used to compute the hash code.</param>
		/// <param name="outputOffset">The offset into the output byte array from which to begin writing data.</param>
		/// <returns>The number of bytes written.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="inputCount" /> uses an invalid value.  
		/// -or-  
		/// <paramref name="inputBuffer" /> has an invalid length.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inputBuffer" /> is <see langword="null" />.</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.ObjectDisposedException">The object has already been disposed.</exception>
		// Token: 0x060023C0 RID: 9152 RVA: 0x00016DE8 File Offset: 0x00014FE8
		[Token(Token = "0x60023C0")]
		[Address(RVA = "0xC0BF50", Offset = "0xC0AF50", VA = "0x180C0BF50", Slot = "9")]
		public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
		{
			return 0;
		}

		/// <summary>Computes the hash value for the specified region of the specified byte array.</summary>
		/// <param name="inputBuffer">The input to compute the hash code for.</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>
		/// <returns>An array that is a copy of the part of the input that is hashed.</returns>
		/// <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.ArgumentNullException">
		///   <paramref name="inputBuffer" /> is <see langword="null" />.</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.ObjectDisposedException">The object has already been disposed.</exception>
		// Token: 0x060023C1 RID: 9153 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60023C1")]
		[Address(RVA = "0xC0C160", Offset = "0xC0B160", VA = "0x180C0C160", Slot = "10")]
		public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
		{
			return null;
		}

		/// <summary>Releases all resources used by the current instance of the <see cref="T:System.Security.Cryptography.HashAlgorithm" /> class.</summary>
		// Token: 0x060023C2 RID: 9154 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60023C2")]
		[Address(RVA = "0xC0BEE0", Offset = "0xC0AEE0", VA = "0x180C0BEE0", Slot = "4")]
		public void Dispose()
		{
		}

		/// <summary>Releases all resources used by the <see cref="T:System.Security.Cryptography.HashAlgorithm" /> class.</summary>
		// Token: 0x060023C3 RID: 9155 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60023C3")]
		[Address(RVA = "0xC0B8C0", Offset = "0xC0A8C0", VA = "0x180C0B8C0")]
		public void Clear()
		{
		}

		/// <summary>Releases the unmanaged resources used by the <see cref="T:System.Security.Cryptography.HashAlgorithm" /> and optionally releases the managed resources.</summary>
		/// <param name="disposing">
		///   <see langword="true" /> to release both managed and unmanaged resources; <see langword="false" /> to release only unmanaged resources.</param>
		// Token: 0x060023C4 RID: 9156 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60023C4")]
		[Address(RVA = "0xC0BEA0", Offset = "0xC0AEA0", VA = "0x180C0BEA0", Slot = "17")]
		protected virtual void Dispose(bool disposing)
		{
		}

		/// <summary>Initializes an implementation of the <see cref="T:System.Security.Cryptography.HashAlgorithm" /> class.</summary>
		// Token: 0x060023C5 RID: 9157
		[Token(Token = "0x60023C5")]
		[Address(Slot = "18")]
		public abstract void Initialize();

		/// <summary>When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash.</summary>
		/// <param name="array">The input to compute the hash code for.</param>
		/// <param name="ibStart">The offset into the byte array from which to begin using data.</param>
		/// <param name="cbSize">The number of bytes in the byte array to use as data.</param>
		// Token: 0x060023C6 RID: 9158
		[Token(Token = "0x60023C6")]
		[Address(Slot = "19")]
		protected abstract void HashCore(byte[] array, int ibStart, int cbSize);

		/// <summary>When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.</summary>
		/// <returns>The computed hash code.</returns>
		// Token: 0x060023C7 RID: 9159
		[Token(Token = "0x60023C7")]
		[Address(Slot = "20")]
		protected abstract byte[] HashFinal();

		/// <summary>Represents the size, in bits, of the computed hash code.</summary>
		// Token: 0x04001419 RID: 5145
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
		[Token(Token = "0x4001419")]
		protected int HashSizeValue;

		/// <summary>Represents the value of the computed hash code.</summary>
		// Token: 0x0400141A RID: 5146
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
		[Token(Token = "0x400141A")]
		protected internal byte[] HashValue;

		/// <summary>Represents the state of the hash computation.</summary>
		// Token: 0x0400141B RID: 5147
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
		[Token(Token = "0x400141B")]
		protected int State;

		// Token: 0x0400141C RID: 5148
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x24")]
		[Token(Token = "0x400141C")]
		private bool m_bDisposed;
	}
}