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

namespace Mono.Security.X509
{
	// Token: 0x020000BC RID: 188
	internal class X509Certificate : ISerializable
	{
		// Token: 0x06000A29 RID: 2601 RVA: 0x0002D4B8 File Offset: 0x0002B6B8
		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: 0x06000A2A RID: 2602 RVA: 0x0002D52C File Offset: 0x0002B72C
		protected X509Certificate(SerializationInfo info, StreamingContext context)
		{
			this.Parse((byte[])info.GetValue("raw", typeof(byte[])));
		}

		// Token: 0x06000A2C RID: 2604 RVA: 0x0002D574 File Offset: 0x0002B774
		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: 0x06000A2D RID: 2605 RVA: 0x0002D904 File Offset: 0x0002BB04
		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: 0x1700013A RID: 314
		// (get) Token: 0x06000A2E RID: 2606 RVA: 0x0002D934 File Offset: 0x0002BB34
		// (set) Token: 0x06000A2F RID: 2607 RVA: 0x0002DA78 File Offset: 0x0002BC78
		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: 0x1700013B RID: 315
		// (get) Token: 0x06000A30 RID: 2608 RVA: 0x0002DA90 File Offset: 0x0002BC90
		public X509ExtensionCollection Extensions
		{
			get
			{
				return this.extensions;
			}
		}

		// Token: 0x1700013C RID: 316
		// (get) Token: 0x06000A31 RID: 2609 RVA: 0x0002DA98 File Offset: 0x0002BC98
		public byte[] Hash
		{
			get
			{
				if (this.certhash == null)
				{
					string signaturealgo = this.m_signaturealgo;
					if (signaturealgo != null)
					{
						if (X509Certificate.<>f__switch$map13 == null)
						{
							X509Certificate.<>f__switch$map13 = new Dictionary<string, int>(5)
							{
								{ "1.2.840.113549.1.1.2", 0 },
								{ "1.2.840.113549.1.1.4", 1 },
								{ "1.2.840.113549.1.1.5", 2 },
								{ "1.3.14.3.2.29", 2 },
								{ "1.2.840.10040.4.3", 2 }
							};
						}
						int num;
						if (X509Certificate.<>f__switch$map13.TryGetValue(signaturealgo, out num))
						{
							HashAlgorithm hashAlgorithm;
							switch (num)
							{
							case 0:
								hashAlgorithm = HashAlgorithm.Create("MD2");
								break;
							case 1:
								hashAlgorithm = MD5.Create();
								break;
							case 2:
								hashAlgorithm = SHA1.Create();
								break;
							default:
								goto IL_BD;
							}
							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_100;
						}
					}
					IL_BD:
					return null;
				}
				IL_100:
				return (byte[])this.certhash.Clone();
			}
		}

		// Token: 0x1700013D RID: 317
		// (get) Token: 0x06000A32 RID: 2610 RVA: 0x0002DBB8 File Offset: 0x0002BDB8
		public virtual string IssuerName
		{
			get
			{
				return this.m_issuername;
			}
		}

		// Token: 0x1700013E RID: 318
		// (get) Token: 0x06000A33 RID: 2611 RVA: 0x0002DBC0 File Offset: 0x0002BDC0
		public virtual string KeyAlgorithm
		{
			get
			{
				return this.m_keyalgo;
			}
		}

		// Token: 0x1700013F RID: 319
		// (get) Token: 0x06000A34 RID: 2612 RVA: 0x0002DBC8 File Offset: 0x0002BDC8
		// (set) Token: 0x06000A35 RID: 2613 RVA: 0x0002DBE8 File Offset: 0x0002BDE8
		public virtual byte[] KeyAlgorithmParameters
		{
			get
			{
				if (this.m_keyalgoparams == null)
				{
					return null;
				}
				return (byte[])this.m_keyalgoparams.Clone();
			}
			set
			{
				this.m_keyalgoparams = value;
			}
		}

		// Token: 0x17000140 RID: 320
		// (get) Token: 0x06000A36 RID: 2614 RVA: 0x0002DBF4 File Offset: 0x0002BDF4
		public virtual byte[] PublicKey
		{
			get
			{
				if (this.m_publickey == null)
				{
					return null;
				}
				return (byte[])this.m_publickey.Clone();
			}
		}

		// Token: 0x17000141 RID: 321
		// (get) Token: 0x06000A37 RID: 2615 RVA: 0x0002DC14 File Offset: 0x0002BE14
		// (set) Token: 0x06000A38 RID: 2616 RVA: 0x0002DCC0 File Offset: 0x0002BEC0
		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: 0x17000142 RID: 322
		// (get) Token: 0x06000A39 RID: 2617 RVA: 0x0002DCD8 File Offset: 0x0002BED8
		public virtual byte[] RawData
		{
			get
			{
				if (this.m_encodedcert == null)
				{
					return null;
				}
				return (byte[])this.m_encodedcert.Clone();
			}
		}

		// Token: 0x17000143 RID: 323
		// (get) Token: 0x06000A3A RID: 2618 RVA: 0x0002DCF8 File Offset: 0x0002BEF8
		public virtual byte[] SerialNumber
		{
			get
			{
				if (this.serialnumber == null)
				{
					return null;
				}
				return (byte[])this.serialnumber.Clone();
			}
		}

		// Token: 0x17000144 RID: 324
		// (get) Token: 0x06000A3B RID: 2619 RVA: 0x0002DD18 File Offset: 0x0002BF18
		public virtual byte[] Signature
		{
			get
			{
				if (this.signature == null)
				{
					return null;
				}
				string signaturealgo = this.m_signaturealgo;
				if (signaturealgo != null)
				{
					if (X509Certificate.<>f__switch$map14 == null)
					{
						X509Certificate.<>f__switch$map14 = new Dictionary<string, int>(5)
						{
							{ "1.2.840.113549.1.1.2", 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.10040.4.3", 1 }
						};
					}
					int num;
					if (X509Certificate.<>f__switch$map14.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: 0x17000145 RID: 325
		// (get) Token: 0x06000A3C RID: 2620 RVA: 0x0002DE88 File Offset: 0x0002C088
		public virtual string SignatureAlgorithm
		{
			get
			{
				return this.m_signaturealgo;
			}
		}

		// Token: 0x17000146 RID: 326
		// (get) Token: 0x06000A3D RID: 2621 RVA: 0x0002DE90 File Offset: 0x0002C090
		public virtual byte[] SignatureAlgorithmParameters
		{
			get
			{
				if (this.m_signaturealgoparams == null)
				{
					return this.m_signaturealgoparams;
				}
				return (byte[])this.m_signaturealgoparams.Clone();
			}
		}

		// Token: 0x17000147 RID: 327
		// (get) Token: 0x06000A3E RID: 2622 RVA: 0x0002DEC0 File Offset: 0x0002C0C0
		public virtual string SubjectName
		{
			get
			{
				return this.m_subject;
			}
		}

		// Token: 0x17000148 RID: 328
		// (get) Token: 0x06000A3F RID: 2623 RVA: 0x0002DEC8 File Offset: 0x0002C0C8
		public virtual DateTime ValidFrom
		{
			get
			{
				return this.m_from;
			}
		}

		// Token: 0x17000149 RID: 329
		// (get) Token: 0x06000A40 RID: 2624 RVA: 0x0002DED0 File Offset: 0x0002C0D0
		public virtual DateTime ValidUntil
		{
			get
			{
				return this.m_until;
			}
		}

		// Token: 0x1700014A RID: 330
		// (get) Token: 0x06000A41 RID: 2625 RVA: 0x0002DED8 File Offset: 0x0002C0D8
		public int Version
		{
			get
			{
				return this.version;
			}
		}

		// Token: 0x1700014B RID: 331
		// (get) Token: 0x06000A42 RID: 2626 RVA: 0x0002DEE0 File Offset: 0x0002C0E0
		public bool IsCurrent
		{
			get
			{
				return this.WasCurrent(DateTime.UtcNow);
			}
		}

		// Token: 0x06000A43 RID: 2627 RVA: 0x0002DEF0 File Offset: 0x0002C0F0
		public bool WasCurrent(DateTime instant)
		{
			return instant > this.ValidFrom && instant <= this.ValidUntil;
		}

		// Token: 0x1700014C RID: 332
		// (get) Token: 0x06000A44 RID: 2628 RVA: 0x0002DF20 File Offset: 0x0002C120
		public byte[] IssuerUniqueIdentifier
		{
			get
			{
				if (this.issuerUniqueID == null)
				{
					return null;
				}
				return (byte[])this.issuerUniqueID.Clone();
			}
		}

		// Token: 0x1700014D RID: 333
		// (get) Token: 0x06000A45 RID: 2629 RVA: 0x0002DF40 File Offset: 0x0002C140
		public byte[] SubjectUniqueIdentifier
		{
			get
			{
				if (this.subjectUniqueID == null)
				{
					return null;
				}
				return (byte[])this.subjectUniqueID.Clone();
			}
		}

		// Token: 0x06000A46 RID: 2630 RVA: 0x0002DF60 File Offset: 0x0002C160
		internal bool VerifySignature(DSA dsa)
		{
			DSASignatureDeformatter dsasignatureDeformatter = new DSASignatureDeformatter(dsa);
			dsasignatureDeformatter.SetHashAlgorithm("SHA1");
			return dsasignatureDeformatter.VerifySignature(this.Hash, this.Signature);
		}

		// Token: 0x06000A47 RID: 2631 RVA: 0x0002DF94 File Offset: 0x0002C194
		internal string GetHashNameFromOID(string oid)
		{
			switch (oid)
			{
			case "1.2.840.113549.1.1.2":
				return "MD2";
			case "1.2.840.113549.1.1.4":
				return "MD5";
			case "1.2.840.113549.1.1.5":
			case "1.3.14.3.2.29":
				return "SHA1";
			}
			return null;
		}

		// Token: 0x06000A48 RID: 2632 RVA: 0x0002E02C File Offset: 0x0002C22C
		internal bool VerifySignature(RSA rsa)
		{
			RSAPKCS1SignatureDeformatter rsapkcs1SignatureDeformatter = new RSAPKCS1SignatureDeformatter(rsa);
			string hashNameFromOID = this.GetHashNameFromOID(this.m_signaturealgo);
			if (hashNameFromOID == null)
			{
				throw new CryptographicException("Unsupported hash algorithm: " + this.m_signaturealgo);
			}
			rsapkcs1SignatureDeformatter.SetHashAlgorithm(hashNameFromOID);
			return rsapkcs1SignatureDeformatter.VerifySignature(this.Hash, this.Signature);
		}

		// Token: 0x06000A49 RID: 2633 RVA: 0x0002E084 File Offset: 0x0002C284
		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: 0x06000A4A RID: 2634 RVA: 0x0002E0E8 File Offset: 0x0002C2E8
		public bool CheckSignature(byte[] hash, string hashAlgorithm, byte[] signature)
		{
			RSACryptoServiceProvider rsacryptoServiceProvider = (RSACryptoServiceProvider)this.RSA;
			return rsacryptoServiceProvider.VerifyHash(hash, hashAlgorithm, signature);
		}

		// Token: 0x1700014E RID: 334
		// (get) Token: 0x06000A4B RID: 2635 RVA: 0x0002E10C File Offset: 0x0002C30C
		public bool IsSelfSigned
		{
			get
			{
				return this.m_issuername == this.m_subject && this.VerifySignature(this.RSA);
			}
		}

		// Token: 0x06000A4C RID: 2636 RVA: 0x0002E140 File Offset: 0x0002C340
		public ASN1 GetIssuerName()
		{
			return this.issuer;
		}

		// Token: 0x06000A4D RID: 2637 RVA: 0x0002E148 File Offset: 0x0002C348
		public ASN1 GetSubjectName()
		{
			return this.subject;
		}

		// Token: 0x06000A4E RID: 2638 RVA: 0x0002E150 File Offset: 0x0002C350
		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.AddValue("raw", this.m_encodedcert);
		}

		// Token: 0x06000A4F RID: 2639 RVA: 0x0002E164 File Offset: 0x0002C364
		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: 0x04000292 RID: 658
		private ASN1 decoder;

		// Token: 0x04000293 RID: 659
		private byte[] m_encodedcert;

		// Token: 0x04000294 RID: 660
		private DateTime m_from;

		// Token: 0x04000295 RID: 661
		private DateTime m_until;

		// Token: 0x04000296 RID: 662
		private ASN1 issuer;

		// Token: 0x04000297 RID: 663
		private string m_issuername;

		// Token: 0x04000298 RID: 664
		private string m_keyalgo;

		// Token: 0x04000299 RID: 665
		private byte[] m_keyalgoparams;

		// Token: 0x0400029A RID: 666
		private ASN1 subject;

		// Token: 0x0400029B RID: 667
		private string m_subject;

		// Token: 0x0400029C RID: 668
		private byte[] m_publickey;

		// Token: 0x0400029D RID: 669
		private byte[] signature;

		// Token: 0x0400029E RID: 670
		private string m_signaturealgo;

		// Token: 0x0400029F RID: 671
		private byte[] m_signaturealgoparams;

		// Token: 0x040002A0 RID: 672
		private byte[] certhash;

		// Token: 0x040002A1 RID: 673
		private RSA _rsa;

		// Token: 0x040002A2 RID: 674
		private DSA _dsa;

		// Token: 0x040002A3 RID: 675
		private int version;

		// Token: 0x040002A4 RID: 676
		private byte[] serialnumber;

		// Token: 0x040002A5 RID: 677
		private byte[] issuerUniqueID;

		// Token: 0x040002A6 RID: 678
		private byte[] subjectUniqueID;

		// Token: 0x040002A7 RID: 679
		private X509ExtensionCollection extensions;

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