using System;
using System.Configuration.Assemblies;
using System.Globalization;
using System.IO;
using System.Security.Cryptography;
using Mono.Security.Cryptography;

namespace Mono.Security
{
	// Token: 0x0200001A RID: 26
	public sealed class StrongName
	{
		// Token: 0x06000108 RID: 264 RVA: 0x00007250 File Offset: 0x00005450
		public StrongName()
		{
		}

		// Token: 0x06000109 RID: 265 RVA: 0x00007258 File Offset: 0x00005458
		public StrongName(int keySize)
		{
			this.rsa = new RSAManaged(keySize);
		}

		// Token: 0x0600010A RID: 266 RVA: 0x0000726C File Offset: 0x0000546C
		public StrongName(byte[] data)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			if (data.Length == 16)
			{
				int i = 0;
				int num = 0;
				while (i < data.Length)
				{
					num += (int)data[i++];
				}
				if (num == 4)
				{
					this.publicKey = (byte[])data.Clone();
				}
			}
			else
			{
				this.RSA = CryptoConvert.FromCapiKeyBlob(data);
				if (this.rsa == null)
				{
					throw new ArgumentException("data isn't a correctly encoded RSA public key");
				}
			}
		}

		// Token: 0x0600010B RID: 267 RVA: 0x000072F8 File Offset: 0x000054F8
		public StrongName(RSA rsa)
		{
			if (rsa == null)
			{
				throw new ArgumentNullException("rsa");
			}
			this.RSA = rsa;
		}

		// Token: 0x0600010C RID: 268 RVA: 0x00007318 File Offset: 0x00005518
		private void InvalidateCache()
		{
			this.publicKey = null;
			this.keyToken = null;
		}

		// Token: 0x17000031 RID: 49
		// (get) Token: 0x0600010D RID: 269 RVA: 0x00007328 File Offset: 0x00005528
		public bool CanSign
		{
			get
			{
				if (this.rsa == null)
				{
					return false;
				}
				if (this.RSA is RSAManaged)
				{
					return !(this.rsa as RSAManaged).PublicOnly;
				}
				bool flag;
				try
				{
					RSAParameters rsaparameters = this.rsa.ExportParameters(true);
					flag = rsaparameters.D != null && rsaparameters.P != null && rsaparameters.Q != null;
				}
				catch (CryptographicException)
				{
					flag = false;
				}
				return flag;
			}
		}

		// Token: 0x17000032 RID: 50
		// (get) Token: 0x0600010E RID: 270 RVA: 0x000073D0 File Offset: 0x000055D0
		// (set) Token: 0x0600010F RID: 271 RVA: 0x000073F0 File Offset: 0x000055F0
		public RSA RSA
		{
			get
			{
				if (this.rsa == null)
				{
					this.rsa = RSA.Create();
				}
				return this.rsa;
			}
			set
			{
				this.rsa = value;
				this.InvalidateCache();
			}
		}

		// Token: 0x17000033 RID: 51
		// (get) Token: 0x06000110 RID: 272 RVA: 0x00007400 File Offset: 0x00005600
		public byte[] PublicKey
		{
			get
			{
				if (this.publicKey == null)
				{
					byte[] array = CryptoConvert.ToCapiKeyBlob(this.rsa, false);
					this.publicKey = new byte[32 + (this.rsa.KeySize >> 3)];
					this.publicKey[0] = array[4];
					this.publicKey[1] = array[5];
					this.publicKey[2] = array[6];
					this.publicKey[3] = array[7];
					this.publicKey[4] = 4;
					this.publicKey[5] = 128;
					this.publicKey[6] = 0;
					this.publicKey[7] = 0;
					byte[] bytes = BitConverterLE.GetBytes(this.publicKey.Length - 12);
					this.publicKey[8] = bytes[0];
					this.publicKey[9] = bytes[1];
					this.publicKey[10] = bytes[2];
					this.publicKey[11] = bytes[3];
					this.publicKey[12] = 6;
					Buffer.BlockCopy(array, 1, this.publicKey, 13, this.publicKey.Length - 13);
					this.publicKey[23] = 49;
				}
				return (byte[])this.publicKey.Clone();
			}
		}

		// Token: 0x17000034 RID: 52
		// (get) Token: 0x06000111 RID: 273 RVA: 0x00007514 File Offset: 0x00005714
		public byte[] PublicKeyToken
		{
			get
			{
				if (this.keyToken == null)
				{
					byte[] array = this.PublicKey;
					if (array == null)
					{
						return null;
					}
					HashAlgorithm hashAlgorithm = HashAlgorithm.Create(this.TokenAlgorithm);
					byte[] array2 = hashAlgorithm.ComputeHash(array);
					this.keyToken = new byte[8];
					Buffer.BlockCopy(array2, array2.Length - 8, this.keyToken, 0, 8);
					Array.Reverse(this.keyToken, 0, 8);
				}
				return (byte[])this.keyToken.Clone();
			}
		}

		// Token: 0x17000035 RID: 53
		// (get) Token: 0x06000112 RID: 274 RVA: 0x0000758C File Offset: 0x0000578C
		// (set) Token: 0x06000113 RID: 275 RVA: 0x000075AC File Offset: 0x000057AC
		public string TokenAlgorithm
		{
			get
			{
				if (this.tokenAlgorithm == null)
				{
					this.tokenAlgorithm = "SHA1";
				}
				return this.tokenAlgorithm;
			}
			set
			{
				string text = value.ToUpper(CultureInfo.InvariantCulture);
				if (text == "SHA1" || text == "MD5")
				{
					this.tokenAlgorithm = value;
					this.InvalidateCache();
					return;
				}
				throw new ArgumentException("Unsupported hash algorithm for token");
			}
		}

		// Token: 0x06000114 RID: 276 RVA: 0x00007604 File Offset: 0x00005804
		public byte[] GetBytes()
		{
			return CryptoConvert.ToCapiPrivateKeyBlob(this.RSA);
		}

		// Token: 0x06000115 RID: 277 RVA: 0x00007614 File Offset: 0x00005814
		private uint RVAtoPosition(uint r, int sections, byte[] headers)
		{
			for (int i = 0; i < sections; i++)
			{
				uint num = BitConverterLE.ToUInt32(headers, i * 40 + 20);
				uint num2 = BitConverterLE.ToUInt32(headers, i * 40 + 12);
				int num3 = (int)BitConverterLE.ToUInt32(headers, i * 40 + 8);
				if (num2 <= r && (ulong)r < (ulong)num2 + (ulong)((long)num3))
				{
					return num + r - num2;
				}
			}
			return 0U;
		}

		// Token: 0x06000116 RID: 278 RVA: 0x00007678 File Offset: 0x00005878
		internal StrongName.StrongNameSignature StrongHash(Stream stream, StrongName.StrongNameOptions options)
		{
			StrongName.StrongNameSignature strongNameSignature = new StrongName.StrongNameSignature();
			HashAlgorithm hashAlgorithm = HashAlgorithm.Create(this.TokenAlgorithm);
			CryptoStream cryptoStream = new CryptoStream(Stream.Null, hashAlgorithm, CryptoStreamMode.Write);
			byte[] array = new byte[128];
			stream.Read(array, 0, 128);
			if (BitConverterLE.ToUInt16(array, 0) != 23117)
			{
				return null;
			}
			uint num = BitConverterLE.ToUInt32(array, 60);
			cryptoStream.Write(array, 0, 128);
			if (num != 128U)
			{
				byte[] array2 = new byte[num - 128U];
				stream.Read(array2, 0, array2.Length);
				cryptoStream.Write(array2, 0, array2.Length);
			}
			byte[] array3 = new byte[248];
			stream.Read(array3, 0, 248);
			if (BitConverterLE.ToUInt32(array3, 0) != 17744U)
			{
				return null;
			}
			if (BitConverterLE.ToUInt16(array3, 4) != 332)
			{
				return null;
			}
			byte[] array4 = new byte[8];
			Buffer.BlockCopy(array4, 0, array3, 88, 4);
			Buffer.BlockCopy(array4, 0, array3, 152, 8);
			cryptoStream.Write(array3, 0, 248);
			ushort num2 = BitConverterLE.ToUInt16(array3, 6);
			int num3 = (int)(num2 * 40);
			byte[] array5 = new byte[num3];
			stream.Read(array5, 0, num3);
			cryptoStream.Write(array5, 0, num3);
			uint num4 = BitConverterLE.ToUInt32(array3, 232);
			uint num5 = this.RVAtoPosition(num4, (int)num2, array5);
			int num6 = (int)BitConverterLE.ToUInt32(array3, 236);
			byte[] array6 = new byte[num6];
			stream.Position = (long)((ulong)num5);
			stream.Read(array6, 0, num6);
			uint num7 = BitConverterLE.ToUInt32(array6, 32);
			strongNameSignature.SignaturePosition = this.RVAtoPosition(num7, (int)num2, array5);
			strongNameSignature.SignatureLength = BitConverterLE.ToUInt32(array6, 36);
			uint num8 = BitConverterLE.ToUInt32(array6, 8);
			strongNameSignature.MetadataPosition = this.RVAtoPosition(num8, (int)num2, array5);
			strongNameSignature.MetadataLength = BitConverterLE.ToUInt32(array6, 12);
			if (options == StrongName.StrongNameOptions.Metadata)
			{
				cryptoStream.Close();
				hashAlgorithm.Initialize();
				byte[] array7 = new byte[strongNameSignature.MetadataLength];
				stream.Position = (long)((ulong)strongNameSignature.MetadataPosition);
				stream.Read(array7, 0, array7.Length);
				strongNameSignature.Hash = hashAlgorithm.ComputeHash(array7);
				return strongNameSignature;
			}
			for (int i = 0; i < (int)num2; i++)
			{
				uint num9 = BitConverterLE.ToUInt32(array5, i * 40 + 20);
				int num10 = (int)BitConverterLE.ToUInt32(array5, i * 40 + 16);
				byte[] array8 = new byte[num10];
				stream.Position = (long)((ulong)num9);
				stream.Read(array8, 0, num10);
				if (num9 <= strongNameSignature.SignaturePosition && (ulong)strongNameSignature.SignaturePosition < (ulong)num9 + (ulong)((long)num10))
				{
					int num11 = (int)(strongNameSignature.SignaturePosition - num9);
					if (num11 > 0)
					{
						cryptoStream.Write(array8, 0, num11);
					}
					strongNameSignature.Signature = new byte[strongNameSignature.SignatureLength];
					Buffer.BlockCopy(array8, num11, strongNameSignature.Signature, 0, (int)strongNameSignature.SignatureLength);
					Array.Reverse(strongNameSignature.Signature);
					int num12 = (int)((long)num11 + (long)((ulong)strongNameSignature.SignatureLength));
					int num13 = num10 - num12;
					if (num13 > 0)
					{
						cryptoStream.Write(array8, num12, num13);
					}
				}
				else
				{
					cryptoStream.Write(array8, 0, num10);
				}
			}
			cryptoStream.Close();
			strongNameSignature.Hash = hashAlgorithm.Hash;
			return strongNameSignature;
		}

		// Token: 0x06000117 RID: 279 RVA: 0x000079C4 File Offset: 0x00005BC4
		public byte[] Hash(string fileName)
		{
			FileStream fileStream = File.OpenRead(fileName);
			StrongName.StrongNameSignature strongNameSignature = this.StrongHash(fileStream, StrongName.StrongNameOptions.Metadata);
			fileStream.Close();
			return strongNameSignature.Hash;
		}

		// Token: 0x06000118 RID: 280 RVA: 0x000079F0 File Offset: 0x00005BF0
		public bool Sign(string fileName)
		{
			bool flag = false;
			StrongName.StrongNameSignature strongNameSignature;
			using (FileStream fileStream = File.OpenRead(fileName))
			{
				strongNameSignature = this.StrongHash(fileStream, StrongName.StrongNameOptions.Signature);
				fileStream.Close();
			}
			if (strongNameSignature.Hash == null)
			{
				return false;
			}
			byte[] array = null;
			try
			{
				RSAPKCS1SignatureFormatter rsapkcs1SignatureFormatter = new RSAPKCS1SignatureFormatter(this.rsa);
				rsapkcs1SignatureFormatter.SetHashAlgorithm(this.TokenAlgorithm);
				array = rsapkcs1SignatureFormatter.CreateSignature(strongNameSignature.Hash);
				Array.Reverse(array);
			}
			catch (CryptographicException)
			{
				return false;
			}
			using (FileStream fileStream2 = File.OpenWrite(fileName))
			{
				fileStream2.Position = (long)((ulong)strongNameSignature.SignaturePosition);
				fileStream2.Write(array, 0, array.Length);
				fileStream2.Close();
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000119 RID: 281 RVA: 0x00007B08 File Offset: 0x00005D08
		public bool Verify(string fileName)
		{
			bool flag = false;
			using (FileStream fileStream = File.OpenRead(fileName))
			{
				flag = this.Verify(fileStream);
				fileStream.Close();
			}
			return flag;
		}

		// Token: 0x0600011A RID: 282 RVA: 0x00007B5C File Offset: 0x00005D5C
		public bool Verify(Stream stream)
		{
			StrongName.StrongNameSignature strongNameSignature = this.StrongHash(stream, StrongName.StrongNameOptions.Signature);
			if (strongNameSignature.Hash == null)
			{
				return false;
			}
			bool flag;
			try
			{
				AssemblyHashAlgorithm assemblyHashAlgorithm = AssemblyHashAlgorithm.SHA1;
				if (this.tokenAlgorithm == "MD5")
				{
					assemblyHashAlgorithm = AssemblyHashAlgorithm.MD5;
				}
				flag = StrongName.Verify(this.rsa, assemblyHashAlgorithm, strongNameSignature.Hash, strongNameSignature.Signature);
			}
			catch (CryptographicException)
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x0600011B RID: 283 RVA: 0x00007BF0 File Offset: 0x00005DF0
		private static bool Verify(RSA rsa, AssemblyHashAlgorithm algorithm, byte[] hash, byte[] signature)
		{
			RSAPKCS1SignatureDeformatter rsapkcs1SignatureDeformatter = new RSAPKCS1SignatureDeformatter(rsa);
			if (algorithm != AssemblyHashAlgorithm.MD5)
			{
				if (algorithm != AssemblyHashAlgorithm.SHA1 && algorithm != AssemblyHashAlgorithm.None)
				{
				}
				rsapkcs1SignatureDeformatter.SetHashAlgorithm("SHA1");
			}
			else
			{
				rsapkcs1SignatureDeformatter.SetHashAlgorithm("MD5");
			}
			return rsapkcs1SignatureDeformatter.VerifySignature(hash, signature);
		}

		// Token: 0x04000063 RID: 99
		private RSA rsa;

		// Token: 0x04000064 RID: 100
		private byte[] publicKey;

		// Token: 0x04000065 RID: 101
		private byte[] keyToken;

		// Token: 0x04000066 RID: 102
		private string tokenAlgorithm;

		// Token: 0x0200001B RID: 27
		internal class StrongNameSignature
		{
			// Token: 0x17000036 RID: 54
			// (get) Token: 0x0600011D RID: 285 RVA: 0x00007C58 File Offset: 0x00005E58
			// (set) Token: 0x0600011E RID: 286 RVA: 0x00007C60 File Offset: 0x00005E60
			public byte[] Hash
			{
				get
				{
					return this.hash;
				}
				set
				{
					this.hash = value;
				}
			}

			// Token: 0x17000037 RID: 55
			// (get) Token: 0x0600011F RID: 287 RVA: 0x00007C6C File Offset: 0x00005E6C
			// (set) Token: 0x06000120 RID: 288 RVA: 0x00007C74 File Offset: 0x00005E74
			public byte[] Signature
			{
				get
				{
					return this.signature;
				}
				set
				{
					this.signature = value;
				}
			}

			// Token: 0x17000038 RID: 56
			// (get) Token: 0x06000121 RID: 289 RVA: 0x00007C80 File Offset: 0x00005E80
			// (set) Token: 0x06000122 RID: 290 RVA: 0x00007C88 File Offset: 0x00005E88
			public uint MetadataPosition
			{
				get
				{
					return this.metadataPosition;
				}
				set
				{
					this.metadataPosition = value;
				}
			}

			// Token: 0x17000039 RID: 57
			// (get) Token: 0x06000123 RID: 291 RVA: 0x00007C94 File Offset: 0x00005E94
			// (set) Token: 0x06000124 RID: 292 RVA: 0x00007C9C File Offset: 0x00005E9C
			public uint MetadataLength
			{
				get
				{
					return this.metadataLength;
				}
				set
				{
					this.metadataLength = value;
				}
			}

			// Token: 0x1700003A RID: 58
			// (get) Token: 0x06000125 RID: 293 RVA: 0x00007CA8 File Offset: 0x00005EA8
			// (set) Token: 0x06000126 RID: 294 RVA: 0x00007CB0 File Offset: 0x00005EB0
			public uint SignaturePosition
			{
				get
				{
					return this.signaturePosition;
				}
				set
				{
					this.signaturePosition = value;
				}
			}

			// Token: 0x1700003B RID: 59
			// (get) Token: 0x06000127 RID: 295 RVA: 0x00007CBC File Offset: 0x00005EBC
			// (set) Token: 0x06000128 RID: 296 RVA: 0x00007CC4 File Offset: 0x00005EC4
			public uint SignatureLength
			{
				get
				{
					return this.signatureLength;
				}
				set
				{
					this.signatureLength = value;
				}
			}

			// Token: 0x1700003C RID: 60
			// (get) Token: 0x06000129 RID: 297 RVA: 0x00007CD0 File Offset: 0x00005ED0
			// (set) Token: 0x0600012A RID: 298 RVA: 0x00007CD8 File Offset: 0x00005ED8
			public byte CliFlag
			{
				get
				{
					return this.cliFlag;
				}
				set
				{
					this.cliFlag = value;
				}
			}

			// Token: 0x1700003D RID: 61
			// (get) Token: 0x0600012B RID: 299 RVA: 0x00007CE4 File Offset: 0x00005EE4
			// (set) Token: 0x0600012C RID: 300 RVA: 0x00007CEC File Offset: 0x00005EEC
			public uint CliFlagPosition
			{
				get
				{
					return this.cliFlagPosition;
				}
				set
				{
					this.cliFlagPosition = value;
				}
			}

			// Token: 0x04000067 RID: 103
			private byte[] hash;

			// Token: 0x04000068 RID: 104
			private byte[] signature;

			// Token: 0x04000069 RID: 105
			private uint signaturePosition;

			// Token: 0x0400006A RID: 106
			private uint signatureLength;

			// Token: 0x0400006B RID: 107
			private uint metadataPosition;

			// Token: 0x0400006C RID: 108
			private uint metadataLength;

			// Token: 0x0400006D RID: 109
			private byte cliFlag;

			// Token: 0x0400006E RID: 110
			private uint cliFlagPosition;
		}

		// Token: 0x0200001C RID: 28
		internal enum StrongNameOptions
		{
			// Token: 0x04000070 RID: 112
			Metadata,
			// Token: 0x04000071 RID: 113
			Signature
		}
	}
}