using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Security.Cryptography;
using System.Text;
using Mono.Security.Cryptography;

namespace Mono.Security.X509
{
	// Token: 0x02000043 RID: 67
	public class X509Certificate : ISerializable
	{
		// Token: 0x060002DC RID: 732 RVA: 0x000153CC File Offset: 0x000135CC
		public X509Certificate(byte[] data)
		{
			if (data != null)
			{
				if (data.Length > 0 && data[0] != 48)
				{
					try
					{
						data = X509Certificate.PEM("CERTIFICATE", data);
					}
					catch (Exception ex)
					{
						throw new CryptographicException(X509Certificate.encoding_error, ex);
					}
				}
				this.Parse(data);
			}
		}

		// Token: 0x060002DD RID: 733 RVA: 0x00015440 File Offset: 0x00013640
		protected X509Certificate(SerializationInfo info, StreamingContext context)
		{
			this.Parse((byte[])info.GetValue("raw", typeof(byte[])));
		}

		// Token: 0x060002DF RID: 735 RVA: 0x00015488 File Offset: 0x00013688
		private void Parse(byte[] data)
		{
			try
			{
				this.decoder = new ASN1(data);
				if (this.decoder.Tag != 48)
				{
					throw new CryptographicException(X509Certificate.encoding_error);
				}
				if (this.decoder[0].Tag != 48)
				{
					throw new CryptographicException(X509Certificate.encoding_error);
				}
				ASN1 asn = this.decoder[0];
				int num = 0;
				ASN1 asn2 = this.decoder[0][num];
				this.version = 1;
				if (asn2.Tag == 160 && asn2.Count > 0)
				{
					this.version += (int)asn2[0].Value[0];
					num++;
				}
				ASN1 asn3 = this.decoder[0][num++];
				if (asn3.Tag != 2)
				{
					throw new CryptographicException(X509Certificate.encoding_error);
				}
				this.serialnumber = asn3.Value;
				Array.Reverse(this.serialnumber, 0, this.serialnumber.Length);
				num++;
				this.issuer = asn.Element(num++, 48);
				this.m_issuername = X501.ToString(this.issuer);
				ASN1 asn4 = asn.Element(num++, 48);
				ASN1 asn5 = asn4[0];
				this.m_from = ASN1Convert.ToDateTime(asn5);
				ASN1 asn6 = asn4[1];
				this.m_until = ASN1Convert.ToDateTime(asn6);
				this.subject = asn.Element(num++, 48);
				this.m_subject = X501.ToString(this.subject);
				ASN1 asn7 = asn.Element(num++, 48);
				ASN1 asn8 = asn7.Element(0, 48);
				ASN1 asn9 = asn8.Element(0, 6);
				this.m_keyalgo = ASN1Convert.ToOid(asn9);
				ASN1 asn10 = asn8[1];
				this.m_keyalgoparams = ((asn8.Count <= 1) ? null : asn10.GetBytes());
				ASN1 asn11 = asn7.Element(1, 3);
				int num2 = asn11.Length - 1;
				this.m_publickey = new byte[num2];
				Buffer.BlockCopy(asn11.Value, 1, this.m_publickey, 0, num2);
				byte[] value = this.decoder[2].Value;
				this.signature = new byte[value.Length - 1];
				Buffer.BlockCopy(value, 1, this.signature, 0, this.signature.Length);
				asn8 = this.decoder[1];
				asn9 = asn8.Element(0, 6);
				this.m_signaturealgo = ASN1Convert.ToOid(asn9);
				asn10 = asn8[1];
				if (asn10 != null)
				{
					this.m_signaturealgoparams = asn10.GetBytes();
				}
				else
				{
					this.m_signaturealgoparams = null;
				}
				ASN1 asn12 = asn.Element(num, 129);
				if (asn12 != null)
				{
					num++;
					this.issuerUniqueID = asn12.Value;
				}
				ASN1 asn13 = asn.Element(num, 130);
				if (asn13 != null)
				{
					num++;
					this.subjectUniqueID = asn13.Value;
				}
				ASN1 asn14 = asn.Element(num, 163);
				if (asn14 != null && asn14.Count == 1)
				{
					this.extensions = new X509ExtensionCollection(asn14[0]);
				}
				else
				{
					this.extensions = new X509ExtensionCollection(null);
				}
				this.m_encodedcert = (byte[])data.Clone();
			}
			catch (Exception ex)
			{
				throw new CryptographicException(X509Certificate.encoding_error, ex);
			}
		}

		// Token: 0x060002E0 RID: 736 RVA: 0x00015818 File Offset: 0x00013A18
		private byte[] GetUnsignedBigInteger(byte[] integer)
		{
			if (integer[0] == 0)
			{
				int num = integer.Length - 1;
				byte[] array = new byte[num];
				Buffer.BlockCopy(integer, 1, array, 0, num);
				return array;
			}
			return integer;
		}

		// Token: 0x17000089 RID: 137
		// (get) Token: 0x060002E1 RID: 737 RVA: 0x00015848 File Offset: 0x00013A48
		// (set) Token: 0x060002E2 RID: 738 RVA: 0x0001598C File Offset: 0x00013B8C
		public DSA DSA
		{
			get
			{
				if (this.m_keyalgoparams == null)
				{
					throw new CryptographicException("Missing key algorithm parameters.");
				}
				if (this._dsa == null)
				{
					DSAParameters dsaparameters = default(DSAParameters);
					ASN1 asn = new ASN1(this.m_publickey);
					if (asn == null || asn.Tag != 2)
					{
						return null;
					}
					dsaparameters.Y = this.GetUnsignedBigInteger(asn.Value);
					ASN1 asn2 = new ASN1(this.m_keyalgoparams);
					if (asn2 == null || asn2.Tag != 48 || asn2.Count < 3)
					{
						return null;
					}
					if (asn2[0].Tag != 2 || asn2[1].Tag != 2 || asn2[2].Tag != 2)
					{
						return null;
					}
					dsaparameters.P = this.GetUnsignedBigInteger(asn2[0].Value);
					dsaparameters.Q = this.GetUnsignedBigInteger(asn2[1].Value);
					dsaparameters.G = this.GetUnsignedBigInteger(asn2[2].Value);
					this._dsa = new DSACryptoServiceProvider(dsaparameters.Y.Length << 3);
					this._dsa.ImportParameters(dsaparameters);
				}
				return this._dsa;
			}
			set
			{
				this._dsa = value;
				if (value != null)
				{
					this._rsa = null;
				}
			}
		}

		// Token: 0x1700008A RID: 138
		// (get) Token: 0x060002E3 RID: 739 RVA: 0x000159A4 File Offset: 0x00013BA4
		public X509ExtensionCollection Extensions
		{
			get
			{
				return this.extensions;
			}
		}

		// Token: 0x1700008B RID: 139
		// (get) Token: 0x060002E4 RID: 740 RVA: 0x000159AC File Offset: 0x00013BAC
		public byte[] Hash
		{
			get
			{
				if (this.certhash == null)
				{
					string signaturealgo = this.m_signaturealgo;
					if (signaturealgo != null)
					{
						if (X509Certificate.<>f__switch$mapF == null)
						{
							X509Certificate.<>f__switch$mapF = new Dictionary<string, int>(9)
							{
								{ "1.2.840.113549.1.1.2", 0 },
								{ "1.2.840.113549.1.1.3", 1 },
								{ "1.2.840.113549.1.1.4", 2 },
								{ "1.2.840.113549.1.1.5", 3 },
								{ "1.3.14.3.2.29", 3 },
								{ "1.2.840.10040.4.3", 3 },
								{ "1.2.840.113549.1.1.11", 4 },
								{ "1.2.840.113549.1.1.12", 5 },
								{ "1.2.840.113549.1.1.13", 6 }
							};
						}
						int num;
						if (X509Certificate.<>f__switch$mapF.TryGetValue(signaturealgo, out num))
						{
							HashAlgorithm hashAlgorithm;
							switch (num)
							{
							case 0:
								hashAlgorithm = MD2.Create();
								break;
							case 1:
								hashAlgorithm = MD4.Create();
								break;
							case 2:
								hashAlgorithm = MD5.Create();
								break;
							case 3:
								hashAlgorithm = SHA1.Create();
								break;
							case 4:
								hashAlgorithm = SHA256.Create();
								break;
							case 5:
								hashAlgorithm = SHA384.Create();
								break;
							case 6:
								hashAlgorithm = SHA512.Create();
								break;
							default:
								goto IL_125;
							}
							if (this.decoder == null || this.decoder.Count < 1)
							{
								return null;
							}
							byte[] bytes = this.decoder[0].GetBytes();
							this.certhash = hashAlgorithm.ComputeHash(bytes, 0, bytes.Length);
							goto IL_168;
						}
					}
					IL_125:
					return null;
				}
				IL_168:
				return (byte[])this.certhash.Clone();
			}
		}

		// Token: 0x1700008C RID: 140
		// (get) Token: 0x060002E5 RID: 741 RVA: 0x00015B34 File Offset: 0x00013D34
		public virtual string IssuerName
		{
			get
			{
				return this.m_issuername;
			}
		}

		// Token: 0x1700008D RID: 141
		// (get) Token: 0x060002E6 RID: 742 RVA: 0x00015B3C File Offset: 0x00013D3C
		public virtual string KeyAlgorithm
		{
			get
			{
				return this.m_keyalgo;
			}
		}

		// Token: 0x1700008E RID: 142
		// (get) Token: 0x060002E7 RID: 743 RVA: 0x00015B44 File Offset: 0x00013D44
		// (set) Token: 0x060002E8 RID: 744 RVA: 0x00015B64 File Offset: 0x00013D64
		public virtual byte[] KeyAlgorithmParameters
		{
			get
			{
				if (this.m_keyalgoparams == null)
				{
					return null;
				}
				return (byte[])this.m_keyalgoparams.Clone();
			}
			set
			{
				this.m_keyalgoparams = value;
			}
		}

		// Token: 0x1700008F RID: 143
		// (get) Token: 0x060002E9 RID: 745 RVA: 0x00015B70 File Offset: 0x00013D70
		public virtual byte[] PublicKey
		{
			get
			{
				if (this.m_publickey == null)
				{
					return null;
				}
				return (byte[])this.m_publickey.Clone();
			}
		}

		// Token: 0x17000090 RID: 144
		// (get) Token: 0x060002EA RID: 746 RVA: 0x00015B90 File Offset: 0x00013D90
		// (set) Token: 0x060002EB RID: 747 RVA: 0x00015C3C File Offset: 0x00013E3C
		public virtual RSA RSA
		{
			get
			{
				if (this._rsa == null)
				{
					RSAParameters rsaparameters = default(RSAParameters);
					ASN1 asn = new ASN1(this.m_publickey);
					ASN1 asn2 = asn[0];
					if (asn2 == null || asn2.Tag != 2)
					{
						return null;
					}
					ASN1 asn3 = asn[1];
					if (asn3.Tag != 2)
					{
						return null;
					}
					rsaparameters.Modulus = this.GetUnsignedBigInteger(asn2.Value);
					rsaparameters.Exponent = asn3.Value;
					int num = rsaparameters.Modulus.Length << 3;
					this._rsa = new RSACryptoServiceProvider(num);
					this._rsa.ImportParameters(rsaparameters);
				}
				return this._rsa;
			}
			set
			{
				if (value != null)
				{
					this._dsa = null;
				}
				this._rsa = value;
			}
		}

		// Token: 0x17000091 RID: 145
		// (get) Token: 0x060002EC RID: 748 RVA: 0x00015C54 File Offset: 0x00013E54
		public virtual byte[] RawData
		{
			get
			{
				if (this.m_encodedcert == null)
				{
					return null;
				}
				return (byte[])this.m_encodedcert.Clone();
			}
		}

		// Token: 0x17000092 RID: 146
		// (get) Token: 0x060002ED RID: 749 RVA: 0x00015C74 File Offset: 0x00013E74
		public virtual byte[] SerialNumber
		{
			get
			{
				if (this.serialnumber == null)
				{
					return null;
				}
				return (byte[])this.serialnumber.Clone();
			}
		}

		// Token: 0x17000093 RID: 147
		// (get) Token: 0x060002EE RID: 750 RVA: 0x00015C94 File Offset: 0x00013E94
		public virtual byte[] Signature
		{
			get
			{
				if (this.signature == null)
				{
					return null;
				}
				string signaturealgo = this.m_signaturealgo;
				if (signaturealgo != null)
				{
					if (X509Certificate.<>f__switch$map10 == null)
					{
						X509Certificate.<>f__switch$map10 = new Dictionary<string, int>(9)
						{
							{ "1.2.840.113549.1.1.2", 0 },
							{ "1.2.840.113549.1.1.3", 0 },
							{ "1.2.840.113549.1.1.4", 0 },
							{ "1.2.840.113549.1.1.5", 0 },
							{ "1.3.14.3.2.29", 0 },
							{ "1.2.840.113549.1.1.11", 0 },
							{ "1.2.840.113549.1.1.12", 0 },
							{ "1.2.840.113549.1.1.13", 0 },
							{ "1.2.840.10040.4.3", 1 }
						};
					}
					int num;
					if (X509Certificate.<>f__switch$map10.TryGetValue(signaturealgo, out num))
					{
						if (num == 0)
						{
							return (byte[])this.signature.Clone();
						}
						if (num == 1)
						{
							ASN1 asn = new ASN1(this.signature);
							if (asn == null || asn.Count != 2)
							{
								return null;
							}
							byte[] value = asn[0].Value;
							byte[] value2 = asn[1].Value;
							byte[] array = new byte[40];
							int num2 = Math.Max(0, value.Length - 20);
							int num3 = Math.Max(0, 20 - value.Length);
							Buffer.BlockCopy(value, num2, array, num3, value.Length - num2);
							int num4 = Math.Max(0, value2.Length - 20);
							int num5 = Math.Max(20, 40 - value2.Length);
							Buffer.BlockCopy(value2, num4, array, num5, value2.Length - num4);
							return array;
						}
					}
				}
				throw new CryptographicException("Unsupported hash algorithm: " + this.m_signaturealgo);
			}
		}

		// Token: 0x17000094 RID: 148
		// (get) Token: 0x060002EF RID: 751 RVA: 0x00015E38 File Offset: 0x00014038
		public virtual string SignatureAlgorithm
		{
			get
			{
				return this.m_signaturealgo;
			}
		}

		// Token: 0x17000095 RID: 149
		// (get) Token: 0x060002F0 RID: 752 RVA: 0x00015E40 File Offset: 0x00014040
		public virtual byte[] SignatureAlgorithmParameters
		{
			get
			{
				if (this.m_signaturealgoparams == null)
				{
					return this.m_signaturealgoparams;
				}
				return (byte[])this.m_signaturealgoparams.Clone();
			}
		}

		// Token: 0x17000096 RID: 150
		// (get) Token: 0x060002F1 RID: 753 RVA: 0x00015E70 File Offset: 0x00014070
		public virtual string SubjectName
		{
			get
			{
				return this.m_subject;
			}
		}

		// Token: 0x17000097 RID: 151
		// (get) Token: 0x060002F2 RID: 754 RVA: 0x00015E78 File Offset: 0x00014078
		public virtual DateTime ValidFrom
		{
			get
			{
				return this.m_from;
			}
		}

		// Token: 0x17000098 RID: 152
		// (get) Token: 0x060002F3 RID: 755 RVA: 0x00015E80 File Offset: 0x00014080
		public virtual DateTime ValidUntil
		{
			get
			{
				return this.m_until;
			}
		}

		// Token: 0x17000099 RID: 153
		// (get) Token: 0x060002F4 RID: 756 RVA: 0x00015E88 File Offset: 0x00014088
		public int Version
		{
			get
			{
				return this.version;
			}
		}

		// Token: 0x1700009A RID: 154
		// (get) Token: 0x060002F5 RID: 757 RVA: 0x00015E90 File Offset: 0x00014090
		public bool IsCurrent
		{
			get
			{
				return this.WasCurrent(DateTime.UtcNow);
			}
		}

		// Token: 0x060002F6 RID: 758 RVA: 0x00015EA0 File Offset: 0x000140A0
		public bool WasCurrent(DateTime instant)
		{
			return instant > this.ValidFrom && instant <= this.ValidUntil;
		}

		// Token: 0x1700009B RID: 155
		// (get) Token: 0x060002F7 RID: 759 RVA: 0x00015ED0 File Offset: 0x000140D0
		public byte[] IssuerUniqueIdentifier
		{
			get
			{
				if (this.issuerUniqueID == null)
				{
					return null;
				}
				return (byte[])this.issuerUniqueID.Clone();
			}
		}

		// Token: 0x1700009C RID: 156
		// (get) Token: 0x060002F8 RID: 760 RVA: 0x00015EF0 File Offset: 0x000140F0
		public byte[] SubjectUniqueIdentifier
		{
			get
			{
				if (this.subjectUniqueID == null)
				{
					return null;
				}
				return (byte[])this.subjectUniqueID.Clone();
			}
		}

		// Token: 0x060002F9 RID: 761 RVA: 0x00015F10 File Offset: 0x00014110
		internal bool VerifySignature(DSA dsa)
		{
			DSASignatureDeformatter dsasignatureDeformatter = new DSASignatureDeformatter(dsa);
			dsasignatureDeformatter.SetHashAlgorithm("SHA1");
			return dsasignatureDeformatter.VerifySignature(this.Hash, this.Signature);
		}

		// Token: 0x060002FA RID: 762 RVA: 0x00015F44 File Offset: 0x00014144
		internal bool VerifySignature(RSA rsa)
		{
			RSAPKCS1SignatureDeformatter rsapkcs1SignatureDeformatter = new RSAPKCS1SignatureDeformatter(rsa);
			string signaturealgo = this.m_signaturealgo;
			if (signaturealgo != null)
			{
				if (X509Certificate.<>f__switch$map11 == null)
				{
					X509Certificate.<>f__switch$map11 = new Dictionary<string, int>(9)
					{
						{ "1.2.840.113549.1.1.2", 0 },
						{ "1.2.840.113549.1.1.3", 1 },
						{ "1.2.840.113549.1.1.4", 2 },
						{ "1.2.840.113549.1.1.5", 3 },
						{ "1.3.14.3.2.29", 3 },
						{ "1.2.840.113549.1.1.11", 4 },
						{ "1.2.840.113549.1.1.12", 5 },
						{ "1.2.840.113549.1.1.13", 6 },
						{ "1.2.840.10040.4.3", 7 }
					};
				}
				int num;
				if (X509Certificate.<>f__switch$map11.TryGetValue(signaturealgo, out num))
				{
					switch (num)
					{
					case 0:
						rsapkcs1SignatureDeformatter.SetHashAlgorithm("MD2");
						break;
					case 1:
						rsapkcs1SignatureDeformatter.SetHashAlgorithm("MD4");
						break;
					case 2:
						rsapkcs1SignatureDeformatter.SetHashAlgorithm("MD5");
						break;
					case 3:
						rsapkcs1SignatureDeformatter.SetHashAlgorithm("SHA1");
						break;
					case 4:
						rsapkcs1SignatureDeformatter.SetHashAlgorithm("SHA256");
						break;
					case 5:
						rsapkcs1SignatureDeformatter.SetHashAlgorithm("SHA384");
						break;
					case 6:
						rsapkcs1SignatureDeformatter.SetHashAlgorithm("SHA512");
						break;
					case 7:
						return false;
					default:
						goto IL_147;
					}
					return rsapkcs1SignatureDeformatter.VerifySignature(this.Hash, this.Signature);
				}
			}
			IL_147:
			throw new CryptographicException("Unsupported hash algorithm: " + this.m_signaturealgo);
		}

		// Token: 0x060002FB RID: 763 RVA: 0x000160C0 File Offset: 0x000142C0
		public bool VerifySignature(AsymmetricAlgorithm aa)
		{
			if (aa == null)
			{
				throw new ArgumentNullException("aa");
			}
			if (aa is RSA)
			{
				return this.VerifySignature(aa as RSA);
			}
			if (aa is DSA)
			{
				return this.VerifySignature(aa as DSA);
			}
			throw new NotSupportedException("Unknown Asymmetric Algorithm " + aa.ToString());
		}

		// Token: 0x060002FC RID: 764 RVA: 0x00016124 File Offset: 0x00014324
		public bool CheckSignature(byte[] hash, string hashAlgorithm, byte[] signature)
		{
			RSACryptoServiceProvider rsacryptoServiceProvider = (RSACryptoServiceProvider)this.RSA;
			return rsacryptoServiceProvider.VerifyHash(hash, hashAlgorithm, signature);
		}

		// Token: 0x1700009D RID: 157
		// (get) Token: 0x060002FD RID: 765 RVA: 0x00016148 File Offset: 0x00014348
		public bool IsSelfSigned
		{
			get
			{
				return this.m_issuername == this.m_subject && this.VerifySignature(this.RSA);
			}
		}

		// Token: 0x060002FE RID: 766 RVA: 0x0001617C File Offset: 0x0001437C
		public ASN1 GetIssuerName()
		{
			return this.issuer;
		}

		// Token: 0x060002FF RID: 767 RVA: 0x00016184 File Offset: 0x00014384
		public ASN1 GetSubjectName()
		{
			return this.subject;
		}

		// Token: 0x06000300 RID: 768 RVA: 0x0001618C File Offset: 0x0001438C
		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.AddValue("raw", this.m_encodedcert);
		}

		// Token: 0x06000301 RID: 769 RVA: 0x000161A0 File Offset: 0x000143A0
		private static byte[] PEM(string type, byte[] data)
		{
			string @string = Encoding.ASCII.GetString(data);
			string text = string.Format("-----BEGIN {0}-----", type);
			string text2 = string.Format("-----END {0}-----", type);
			int num = @string.IndexOf(text) + text.Length;
			int num2 = @string.IndexOf(text2, num);
			string text3 = @string.Substring(num, num2 - num);
			return Convert.FromBase64String(text3);
		}

		// Token: 0x0400015E RID: 350
		private ASN1 decoder;

		// Token: 0x0400015F RID: 351
		private byte[] m_encodedcert;

		// Token: 0x04000160 RID: 352
		private DateTime m_from;

		// Token: 0x04000161 RID: 353
		private DateTime m_until;

		// Token: 0x04000162 RID: 354
		private ASN1 issuer;

		// Token: 0x04000163 RID: 355
		private string m_issuername;

		// Token: 0x04000164 RID: 356
		private string m_keyalgo;

		// Token: 0x04000165 RID: 357
		private byte[] m_keyalgoparams;

		// Token: 0x04000166 RID: 358
		private ASN1 subject;

		// Token: 0x04000167 RID: 359
		private string m_subject;

		// Token: 0x04000168 RID: 360
		private byte[] m_publickey;

		// Token: 0x04000169 RID: 361
		private byte[] signature;

		// Token: 0x0400016A RID: 362
		private string m_signaturealgo;

		// Token: 0x0400016B RID: 363
		private byte[] m_signaturealgoparams;

		// Token: 0x0400016C RID: 364
		private byte[] certhash;

		// Token: 0x0400016D RID: 365
		private RSA _rsa;

		// Token: 0x0400016E RID: 366
		private DSA _dsa;

		// Token: 0x0400016F RID: 367
		private int version;

		// Token: 0x04000170 RID: 368
		private byte[] serialnumber;

		// Token: 0x04000171 RID: 369
		private byte[] issuerUniqueID;

		// Token: 0x04000172 RID: 370
		private byte[] subjectUniqueID;

		// Token: 0x04000173 RID: 371
		private X509ExtensionCollection extensions;

		// Token: 0x04000174 RID: 372
		private static string encoding_error = Locale.GetText("Input data cannot be coded as a valid certificate.");
	}
}