using System;
using System.Collections;
using System.Security.Cryptography;
using Mono.Security.X509;

namespace Mono.Security
{
	// Token: 0x02000011 RID: 17
	public sealed class PKCS7
	{
		// Token: 0x060000AF RID: 175 RVA: 0x00005C0C File Offset: 0x00003E0C
		private PKCS7()
		{
		}

		// Token: 0x060000B0 RID: 176 RVA: 0x00005C14 File Offset: 0x00003E14
		public static ASN1 Attribute(string oid, ASN1 value)
		{
			ASN1 asn = new ASN1(48);
			asn.Add(ASN1Convert.FromOid(oid));
			ASN1 asn2 = asn.Add(new ASN1(49));
			asn2.Add(value);
			return asn;
		}

		// Token: 0x060000B1 RID: 177 RVA: 0x00005C50 File Offset: 0x00003E50
		public static ASN1 AlgorithmIdentifier(string oid)
		{
			ASN1 asn = new ASN1(48);
			asn.Add(ASN1Convert.FromOid(oid));
			asn.Add(new ASN1(5));
			return asn;
		}

		// Token: 0x060000B2 RID: 178 RVA: 0x00005C80 File Offset: 0x00003E80
		public static ASN1 AlgorithmIdentifier(string oid, ASN1 parameters)
		{
			ASN1 asn = new ASN1(48);
			asn.Add(ASN1Convert.FromOid(oid));
			asn.Add(parameters);
			return asn;
		}

		// Token: 0x060000B3 RID: 179 RVA: 0x00005CAC File Offset: 0x00003EAC
		public static ASN1 IssuerAndSerialNumber(X509Certificate x509)
		{
			ASN1 asn = null;
			ASN1 asn2 = null;
			ASN1 asn3 = new ASN1(x509.RawData);
			int i = 0;
			bool flag = false;
			while (i < asn3[0].Count)
			{
				ASN1 asn4 = asn3[0][i++];
				if (asn4.Tag == 2)
				{
					asn2 = asn4;
				}
				else if (asn4.Tag == 48)
				{
					if (flag)
					{
						asn = asn4;
						break;
					}
					flag = true;
				}
			}
			ASN1 asn5 = new ASN1(48);
			asn5.Add(asn);
			asn5.Add(asn2);
			return asn5;
		}

		// Token: 0x02000012 RID: 18
		public class Oid
		{
			// Token: 0x04000034 RID: 52
			public const string rsaEncryption = "1.2.840.113549.1.1.1";

			// Token: 0x04000035 RID: 53
			public const string data = "1.2.840.113549.1.7.1";

			// Token: 0x04000036 RID: 54
			public const string signedData = "1.2.840.113549.1.7.2";

			// Token: 0x04000037 RID: 55
			public const string envelopedData = "1.2.840.113549.1.7.3";

			// Token: 0x04000038 RID: 56
			public const string signedAndEnvelopedData = "1.2.840.113549.1.7.4";

			// Token: 0x04000039 RID: 57
			public const string digestedData = "1.2.840.113549.1.7.5";

			// Token: 0x0400003A RID: 58
			public const string encryptedData = "1.2.840.113549.1.7.6";

			// Token: 0x0400003B RID: 59
			public const string contentType = "1.2.840.113549.1.9.3";

			// Token: 0x0400003C RID: 60
			public const string messageDigest = "1.2.840.113549.1.9.4";

			// Token: 0x0400003D RID: 61
			public const string signingTime = "1.2.840.113549.1.9.5";

			// Token: 0x0400003E RID: 62
			public const string countersignature = "1.2.840.113549.1.9.6";
		}

		// Token: 0x02000013 RID: 19
		public class ContentInfo
		{
			// Token: 0x060000B5 RID: 181 RVA: 0x00005D54 File Offset: 0x00003F54
			public ContentInfo()
			{
				this.content = new ASN1(160);
			}

			// Token: 0x060000B6 RID: 182 RVA: 0x00005D6C File Offset: 0x00003F6C
			public ContentInfo(string oid)
				: this()
			{
				this.contentType = oid;
			}

			// Token: 0x060000B7 RID: 183 RVA: 0x00005D7C File Offset: 0x00003F7C
			public ContentInfo(byte[] data)
				: this(new ASN1(data))
			{
			}

			// Token: 0x060000B8 RID: 184 RVA: 0x00005D8C File Offset: 0x00003F8C
			public ContentInfo(ASN1 asn1)
			{
				if (asn1.Tag != 48 || (asn1.Count < 1 && asn1.Count > 2))
				{
					throw new ArgumentException("Invalid ASN1");
				}
				if (asn1[0].Tag != 6)
				{
					throw new ArgumentException("Invalid contentType");
				}
				this.contentType = ASN1Convert.ToOid(asn1[0]);
				if (asn1.Count > 1)
				{
					if (asn1[1].Tag != 160)
					{
						throw new ArgumentException("Invalid content");
					}
					this.content = asn1[1];
				}
			}

			// Token: 0x1700000A RID: 10
			// (get) Token: 0x060000B9 RID: 185 RVA: 0x00005E38 File Offset: 0x00004038
			public ASN1 ASN1
			{
				get
				{
					return this.GetASN1();
				}
			}

			// Token: 0x1700000B RID: 11
			// (get) Token: 0x060000BA RID: 186 RVA: 0x00005E40 File Offset: 0x00004040
			// (set) Token: 0x060000BB RID: 187 RVA: 0x00005E48 File Offset: 0x00004048
			public ASN1 Content
			{
				get
				{
					return this.content;
				}
				set
				{
					this.content = value;
				}
			}

			// Token: 0x1700000C RID: 12
			// (get) Token: 0x060000BC RID: 188 RVA: 0x00005E54 File Offset: 0x00004054
			// (set) Token: 0x060000BD RID: 189 RVA: 0x00005E5C File Offset: 0x0000405C
			public string ContentType
			{
				get
				{
					return this.contentType;
				}
				set
				{
					this.contentType = value;
				}
			}

			// Token: 0x060000BE RID: 190 RVA: 0x00005E68 File Offset: 0x00004068
			internal ASN1 GetASN1()
			{
				ASN1 asn = new ASN1(48);
				asn.Add(ASN1Convert.FromOid(this.contentType));
				if (this.content != null && this.content.Count > 0)
				{
					asn.Add(this.content);
				}
				return asn;
			}

			// Token: 0x060000BF RID: 191 RVA: 0x00005EBC File Offset: 0x000040BC
			public byte[] GetBytes()
			{
				return this.GetASN1().GetBytes();
			}

			// Token: 0x0400003F RID: 63
			private string contentType;

			// Token: 0x04000040 RID: 64
			private ASN1 content;
		}

		// Token: 0x02000014 RID: 20
		public class EncryptedData
		{
			// Token: 0x060000C0 RID: 192 RVA: 0x00005ECC File Offset: 0x000040CC
			public EncryptedData()
			{
				this._version = 0;
			}

			// Token: 0x060000C1 RID: 193 RVA: 0x00005EDC File Offset: 0x000040DC
			public EncryptedData(byte[] data)
				: this(new ASN1(data))
			{
			}

			// Token: 0x060000C2 RID: 194 RVA: 0x00005EEC File Offset: 0x000040EC
			public EncryptedData(ASN1 asn1)
				: this()
			{
				if (asn1.Tag != 48 || asn1.Count < 2)
				{
					throw new ArgumentException("Invalid EncryptedData");
				}
				if (asn1[0].Tag != 2)
				{
					throw new ArgumentException("Invalid version");
				}
				this._version = asn1[0].Value[0];
				ASN1 asn2 = asn1[1];
				if (asn2.Tag != 48)
				{
					throw new ArgumentException("missing EncryptedContentInfo");
				}
				ASN1 asn3 = asn2[0];
				if (asn3.Tag != 6)
				{
					throw new ArgumentException("missing EncryptedContentInfo.ContentType");
				}
				this._content = new PKCS7.ContentInfo(ASN1Convert.ToOid(asn3));
				ASN1 asn4 = asn2[1];
				if (asn4.Tag != 48)
				{
					throw new ArgumentException("missing EncryptedContentInfo.ContentEncryptionAlgorithmIdentifier");
				}
				this._encryptionAlgorithm = new PKCS7.ContentInfo(ASN1Convert.ToOid(asn4[0]));
				this._encryptionAlgorithm.Content = asn4[1];
				ASN1 asn5 = asn2[2];
				if (asn5.Tag != 128)
				{
					throw new ArgumentException("missing EncryptedContentInfo.EncryptedContent");
				}
				this._encrypted = asn5.Value;
			}

			// Token: 0x1700000D RID: 13
			// (get) Token: 0x060000C3 RID: 195 RVA: 0x0000601C File Offset: 0x0000421C
			public ASN1 ASN1
			{
				get
				{
					return this.GetASN1();
				}
			}

			// Token: 0x1700000E RID: 14
			// (get) Token: 0x060000C4 RID: 196 RVA: 0x00006024 File Offset: 0x00004224
			public PKCS7.ContentInfo ContentInfo
			{
				get
				{
					return this._content;
				}
			}

			// Token: 0x1700000F RID: 15
			// (get) Token: 0x060000C5 RID: 197 RVA: 0x0000602C File Offset: 0x0000422C
			public PKCS7.ContentInfo EncryptionAlgorithm
			{
				get
				{
					return this._encryptionAlgorithm;
				}
			}

			// Token: 0x17000010 RID: 16
			// (get) Token: 0x060000C6 RID: 198 RVA: 0x00006034 File Offset: 0x00004234
			public byte[] EncryptedContent
			{
				get
				{
					if (this._encrypted == null)
					{
						return null;
					}
					return (byte[])this._encrypted.Clone();
				}
			}

			// Token: 0x17000011 RID: 17
			// (get) Token: 0x060000C7 RID: 199 RVA: 0x00006054 File Offset: 0x00004254
			// (set) Token: 0x060000C8 RID: 200 RVA: 0x0000605C File Offset: 0x0000425C
			public byte Version
			{
				get
				{
					return this._version;
				}
				set
				{
					this._version = value;
				}
			}

			// Token: 0x060000C9 RID: 201 RVA: 0x00006068 File Offset: 0x00004268
			internal ASN1 GetASN1()
			{
				return null;
			}

			// Token: 0x060000CA RID: 202 RVA: 0x0000606C File Offset: 0x0000426C
			public byte[] GetBytes()
			{
				return this.GetASN1().GetBytes();
			}

			// Token: 0x04000041 RID: 65
			private byte _version;

			// Token: 0x04000042 RID: 66
			private PKCS7.ContentInfo _content;

			// Token: 0x04000043 RID: 67
			private PKCS7.ContentInfo _encryptionAlgorithm;

			// Token: 0x04000044 RID: 68
			private byte[] _encrypted;
		}

		// Token: 0x02000015 RID: 21
		public class EnvelopedData
		{
			// Token: 0x060000CB RID: 203 RVA: 0x0000607C File Offset: 0x0000427C
			public EnvelopedData()
			{
				this._version = 0;
				this._content = new PKCS7.ContentInfo();
				this._encryptionAlgorithm = new PKCS7.ContentInfo();
				this._recipientInfos = new ArrayList();
			}

			// Token: 0x060000CC RID: 204 RVA: 0x000060B8 File Offset: 0x000042B8
			public EnvelopedData(byte[] data)
				: this(new ASN1(data))
			{
			}

			// Token: 0x060000CD RID: 205 RVA: 0x000060C8 File Offset: 0x000042C8
			public EnvelopedData(ASN1 asn1)
				: this()
			{
				if (asn1[0].Tag != 48 || asn1[0].Count < 3)
				{
					throw new ArgumentException("Invalid EnvelopedData");
				}
				if (asn1[0][0].Tag != 2)
				{
					throw new ArgumentException("Invalid version");
				}
				this._version = asn1[0][0].Value[0];
				ASN1 asn2 = asn1[0][1];
				if (asn2.Tag != 49)
				{
					throw new ArgumentException("missing RecipientInfos");
				}
				for (int i = 0; i < asn2.Count; i++)
				{
					ASN1 asn3 = asn2[i];
					this._recipientInfos.Add(new PKCS7.RecipientInfo(asn3));
				}
				ASN1 asn4 = asn1[0][2];
				if (asn4.Tag != 48)
				{
					throw new ArgumentException("missing EncryptedContentInfo");
				}
				ASN1 asn5 = asn4[0];
				if (asn5.Tag != 6)
				{
					throw new ArgumentException("missing EncryptedContentInfo.ContentType");
				}
				this._content = new PKCS7.ContentInfo(ASN1Convert.ToOid(asn5));
				ASN1 asn6 = asn4[1];
				if (asn6.Tag != 48)
				{
					throw new ArgumentException("missing EncryptedContentInfo.ContentEncryptionAlgorithmIdentifier");
				}
				this._encryptionAlgorithm = new PKCS7.ContentInfo(ASN1Convert.ToOid(asn6[0]));
				this._encryptionAlgorithm.Content = asn6[1];
				ASN1 asn7 = asn4[2];
				if (asn7.Tag != 128)
				{
					throw new ArgumentException("missing EncryptedContentInfo.EncryptedContent");
				}
				this._encrypted = asn7.Value;
			}

			// Token: 0x17000012 RID: 18
			// (get) Token: 0x060000CE RID: 206 RVA: 0x00006278 File Offset: 0x00004478
			public ArrayList RecipientInfos
			{
				get
				{
					return this._recipientInfos;
				}
			}

			// Token: 0x17000013 RID: 19
			// (get) Token: 0x060000CF RID: 207 RVA: 0x00006280 File Offset: 0x00004480
			public ASN1 ASN1
			{
				get
				{
					return this.GetASN1();
				}
			}

			// Token: 0x17000014 RID: 20
			// (get) Token: 0x060000D0 RID: 208 RVA: 0x00006288 File Offset: 0x00004488
			public PKCS7.ContentInfo ContentInfo
			{
				get
				{
					return this._content;
				}
			}

			// Token: 0x17000015 RID: 21
			// (get) Token: 0x060000D1 RID: 209 RVA: 0x00006290 File Offset: 0x00004490
			public PKCS7.ContentInfo EncryptionAlgorithm
			{
				get
				{
					return this._encryptionAlgorithm;
				}
			}

			// Token: 0x17000016 RID: 22
			// (get) Token: 0x060000D2 RID: 210 RVA: 0x00006298 File Offset: 0x00004498
			public byte[] EncryptedContent
			{
				get
				{
					if (this._encrypted == null)
					{
						return null;
					}
					return (byte[])this._encrypted.Clone();
				}
			}

			// Token: 0x17000017 RID: 23
			// (get) Token: 0x060000D3 RID: 211 RVA: 0x000062B8 File Offset: 0x000044B8
			// (set) Token: 0x060000D4 RID: 212 RVA: 0x000062C0 File Offset: 0x000044C0
			public byte Version
			{
				get
				{
					return this._version;
				}
				set
				{
					this._version = value;
				}
			}

			// Token: 0x060000D5 RID: 213 RVA: 0x000062CC File Offset: 0x000044CC
			internal ASN1 GetASN1()
			{
				return new ASN1(48);
			}

			// Token: 0x060000D6 RID: 214 RVA: 0x000062E4 File Offset: 0x000044E4
			public byte[] GetBytes()
			{
				return this.GetASN1().GetBytes();
			}

			// Token: 0x04000045 RID: 69
			private byte _version;

			// Token: 0x04000046 RID: 70
			private PKCS7.ContentInfo _content;

			// Token: 0x04000047 RID: 71
			private PKCS7.ContentInfo _encryptionAlgorithm;

			// Token: 0x04000048 RID: 72
			private ArrayList _recipientInfos;

			// Token: 0x04000049 RID: 73
			private byte[] _encrypted;
		}

		// Token: 0x02000016 RID: 22
		public class RecipientInfo
		{
			// Token: 0x060000D7 RID: 215 RVA: 0x000062F4 File Offset: 0x000044F4
			public RecipientInfo()
			{
			}

			// Token: 0x060000D8 RID: 216 RVA: 0x000062FC File Offset: 0x000044FC
			public RecipientInfo(ASN1 data)
			{
				if (data.Tag != 48)
				{
					throw new ArgumentException("Invalid RecipientInfo");
				}
				ASN1 asn = data[0];
				if (asn.Tag != 2)
				{
					throw new ArgumentException("missing Version");
				}
				this._version = (int)asn.Value[0];
				ASN1 asn2 = data[1];
				if (asn2.Tag == 128 && this._version == 3)
				{
					this._ski = asn2.Value;
				}
				else
				{
					this._issuer = X501.ToString(asn2[0]);
					this._serial = asn2[1].Value;
				}
				ASN1 asn3 = data[2];
				this._oid = ASN1Convert.ToOid(asn3[0]);
				ASN1 asn4 = data[3];
				this._key = asn4.Value;
			}

			// Token: 0x17000018 RID: 24
			// (get) Token: 0x060000D9 RID: 217 RVA: 0x000063DC File Offset: 0x000045DC
			public string Oid
			{
				get
				{
					return this._oid;
				}
			}

			// Token: 0x17000019 RID: 25
			// (get) Token: 0x060000DA RID: 218 RVA: 0x000063E4 File Offset: 0x000045E4
			public byte[] Key
			{
				get
				{
					if (this._key == null)
					{
						return null;
					}
					return (byte[])this._key.Clone();
				}
			}

			// Token: 0x1700001A RID: 26
			// (get) Token: 0x060000DB RID: 219 RVA: 0x00006404 File Offset: 0x00004604
			public byte[] SubjectKeyIdentifier
			{
				get
				{
					if (this._ski == null)
					{
						return null;
					}
					return (byte[])this._ski.Clone();
				}
			}

			// Token: 0x1700001B RID: 27
			// (get) Token: 0x060000DC RID: 220 RVA: 0x00006424 File Offset: 0x00004624
			public string Issuer
			{
				get
				{
					return this._issuer;
				}
			}

			// Token: 0x1700001C RID: 28
			// (get) Token: 0x060000DD RID: 221 RVA: 0x0000642C File Offset: 0x0000462C
			public byte[] Serial
			{
				get
				{
					if (this._serial == null)
					{
						return null;
					}
					return (byte[])this._serial.Clone();
				}
			}

			// Token: 0x1700001D RID: 29
			// (get) Token: 0x060000DE RID: 222 RVA: 0x0000644C File Offset: 0x0000464C
			public int Version
			{
				get
				{
					return this._version;
				}
			}

			// Token: 0x0400004A RID: 74
			private int _version;

			// Token: 0x0400004B RID: 75
			private string _oid;

			// Token: 0x0400004C RID: 76
			private byte[] _key;

			// Token: 0x0400004D RID: 77
			private byte[] _ski;

			// Token: 0x0400004E RID: 78
			private string _issuer;

			// Token: 0x0400004F RID: 79
			private byte[] _serial;
		}

		// Token: 0x02000017 RID: 23
		public class SignedData
		{
			// Token: 0x060000DF RID: 223 RVA: 0x00006454 File Offset: 0x00004654
			public SignedData()
			{
				this.version = 1;
				this.contentInfo = new PKCS7.ContentInfo();
				this.certs = new X509CertificateCollection();
				this.crls = new ArrayList();
				this.signerInfo = new PKCS7.SignerInfo();
				this.mda = true;
				this.signed = false;
			}

			// Token: 0x060000E0 RID: 224 RVA: 0x000064A8 File Offset: 0x000046A8
			public SignedData(byte[] data)
				: this(new ASN1(data))
			{
			}

			// Token: 0x060000E1 RID: 225 RVA: 0x000064B8 File Offset: 0x000046B8
			public SignedData(ASN1 asn1)
			{
				if (asn1[0].Tag != 48 || asn1[0].Count < 4)
				{
					throw new ArgumentException("Invalid SignedData");
				}
				if (asn1[0][0].Tag != 2)
				{
					throw new ArgumentException("Invalid version");
				}
				this.version = asn1[0][0].Value[0];
				this.contentInfo = new PKCS7.ContentInfo(asn1[0][2]);
				int num = 3;
				this.certs = new X509CertificateCollection();
				if (asn1[0][num].Tag == 160)
				{
					for (int i = 0; i < asn1[0][num].Count; i++)
					{
						this.certs.Add(new X509Certificate(asn1[0][num][i].GetBytes()));
					}
					num++;
				}
				this.crls = new ArrayList();
				if (asn1[0][num].Tag == 161)
				{
					for (int j = 0; j < asn1[0][num].Count; j++)
					{
						this.crls.Add(asn1[0][num][j].GetBytes());
					}
					num++;
				}
				if (asn1[0][num].Count > 0)
				{
					this.signerInfo = new PKCS7.SignerInfo(asn1[0][num]);
				}
				else
				{
					this.signerInfo = new PKCS7.SignerInfo();
				}
				if (this.signerInfo.HashName != null)
				{
					this.HashName = this.OidToName(this.signerInfo.HashName);
				}
				this.mda = this.signerInfo.AuthenticatedAttributes.Count > 0;
			}

			// Token: 0x1700001E RID: 30
			// (get) Token: 0x060000E2 RID: 226 RVA: 0x000066BC File Offset: 0x000048BC
			public ASN1 ASN1
			{
				get
				{
					return this.GetASN1();
				}
			}

			// Token: 0x1700001F RID: 31
			// (get) Token: 0x060000E3 RID: 227 RVA: 0x000066C4 File Offset: 0x000048C4
			public X509CertificateCollection Certificates
			{
				get
				{
					return this.certs;
				}
			}

			// Token: 0x17000020 RID: 32
			// (get) Token: 0x060000E4 RID: 228 RVA: 0x000066CC File Offset: 0x000048CC
			public PKCS7.ContentInfo ContentInfo
			{
				get
				{
					return this.contentInfo;
				}
			}

			// Token: 0x17000021 RID: 33
			// (get) Token: 0x060000E5 RID: 229 RVA: 0x000066D4 File Offset: 0x000048D4
			public ArrayList Crls
			{
				get
				{
					return this.crls;
				}
			}

			// Token: 0x17000022 RID: 34
			// (get) Token: 0x060000E6 RID: 230 RVA: 0x000066DC File Offset: 0x000048DC
			// (set) Token: 0x060000E7 RID: 231 RVA: 0x000066E4 File Offset: 0x000048E4
			public string HashName
			{
				get
				{
					return this.hashAlgorithm;
				}
				set
				{
					this.hashAlgorithm = value;
					this.signerInfo.HashName = value;
				}
			}

			// Token: 0x17000023 RID: 35
			// (get) Token: 0x060000E8 RID: 232 RVA: 0x000066FC File Offset: 0x000048FC
			public PKCS7.SignerInfo SignerInfo
			{
				get
				{
					return this.signerInfo;
				}
			}

			// Token: 0x17000024 RID: 36
			// (get) Token: 0x060000E9 RID: 233 RVA: 0x00006704 File Offset: 0x00004904
			// (set) Token: 0x060000EA RID: 234 RVA: 0x0000670C File Offset: 0x0000490C
			public byte Version
			{
				get
				{
					return this.version;
				}
				set
				{
					this.version = value;
				}
			}

			// Token: 0x17000025 RID: 37
			// (get) Token: 0x060000EB RID: 235 RVA: 0x00006718 File Offset: 0x00004918
			// (set) Token: 0x060000EC RID: 236 RVA: 0x00006720 File Offset: 0x00004920
			public bool UseAuthenticatedAttributes
			{
				get
				{
					return this.mda;
				}
				set
				{
					this.mda = value;
				}
			}

			// Token: 0x060000ED RID: 237 RVA: 0x0000672C File Offset: 0x0000492C
			public bool VerifySignature(AsymmetricAlgorithm aa)
			{
				if (aa == null)
				{
					return false;
				}
				RSAPKCS1SignatureDeformatter rsapkcs1SignatureDeformatter = new RSAPKCS1SignatureDeformatter(aa);
				rsapkcs1SignatureDeformatter.SetHashAlgorithm(this.hashAlgorithm);
				HashAlgorithm hashAlgorithm = HashAlgorithm.Create(this.hashAlgorithm);
				byte[] signature = this.signerInfo.Signature;
				byte[] array;
				if (this.mda)
				{
					ASN1 asn = new ASN1(49);
					foreach (object obj in this.signerInfo.AuthenticatedAttributes)
					{
						ASN1 asn2 = (ASN1)obj;
						asn.Add(asn2);
					}
					array = hashAlgorithm.ComputeHash(asn.GetBytes());
				}
				else
				{
					array = hashAlgorithm.ComputeHash(this.contentInfo.Content[0].Value);
				}
				return array != null && signature != null && rsapkcs1SignatureDeformatter.VerifySignature(array, signature);
			}

			// Token: 0x060000EE RID: 238 RVA: 0x0000683C File Offset: 0x00004A3C
			internal string OidToName(string oid)
			{
				switch (oid)
				{
				case "1.3.14.3.2.26":
					return "SHA1";
				case "1.2.840.113549.2.2":
					return "MD2";
				case "1.2.840.113549.2.5":
					return "MD5";
				case "2.16.840.1.101.3.4.1":
					return "SHA256";
				case "2.16.840.1.101.3.4.2":
					return "SHA384";
				case "2.16.840.1.101.3.4.3":
					return "SHA512";
				}
				return oid;
			}

			// Token: 0x060000EF RID: 239 RVA: 0x00006910 File Offset: 0x00004B10
			internal ASN1 GetASN1()
			{
				ASN1 asn = new ASN1(48);
				byte[] array = new byte[] { this.version };
				asn.Add(new ASN1(2, array));
				ASN1 asn2 = asn.Add(new ASN1(49));
				if (this.hashAlgorithm != null)
				{
					string text = CryptoConfig.MapNameToOID(this.hashAlgorithm);
					asn2.Add(PKCS7.AlgorithmIdentifier(text));
				}
				ASN1 asn3 = this.contentInfo.ASN1;
				asn.Add(asn3);
				if (!this.signed && this.hashAlgorithm != null)
				{
					if (this.mda)
					{
						ASN1 asn4 = PKCS7.Attribute("1.2.840.113549.1.9.3", asn3[0]);
						this.signerInfo.AuthenticatedAttributes.Add(asn4);
						HashAlgorithm hashAlgorithm = HashAlgorithm.Create(this.hashAlgorithm);
						byte[] array2 = hashAlgorithm.ComputeHash(asn3[1][0].Value);
						ASN1 asn5 = new ASN1(48);
						ASN1 asn6 = PKCS7.Attribute("1.2.840.113549.1.9.4", asn5.Add(new ASN1(4, array2)));
						this.signerInfo.AuthenticatedAttributes.Add(asn6);
					}
					else
					{
						RSAPKCS1SignatureFormatter rsapkcs1SignatureFormatter = new RSAPKCS1SignatureFormatter(this.signerInfo.Key);
						rsapkcs1SignatureFormatter.SetHashAlgorithm(this.hashAlgorithm);
						HashAlgorithm hashAlgorithm2 = HashAlgorithm.Create(this.hashAlgorithm);
						byte[] array3 = hashAlgorithm2.ComputeHash(asn3[1][0].Value);
						this.signerInfo.Signature = rsapkcs1SignatureFormatter.CreateSignature(array3);
					}
					this.signed = true;
				}
				if (this.certs.Count > 0)
				{
					ASN1 asn7 = asn.Add(new ASN1(160));
					foreach (X509Certificate x509Certificate in this.certs)
					{
						asn7.Add(new ASN1(x509Certificate.RawData));
					}
				}
				if (this.crls.Count > 0)
				{
					ASN1 asn8 = asn.Add(new ASN1(161));
					foreach (object obj in this.crls)
					{
						byte[] array4 = (byte[])obj;
						asn8.Add(new ASN1(array4));
					}
				}
				ASN1 asn9 = asn.Add(new ASN1(49));
				if (this.signerInfo.Key != null)
				{
					asn9.Add(this.signerInfo.ASN1);
				}
				return asn;
			}

			// Token: 0x060000F0 RID: 240 RVA: 0x00006BF4 File Offset: 0x00004DF4
			public byte[] GetBytes()
			{
				return this.GetASN1().GetBytes();
			}

			// Token: 0x04000050 RID: 80
			private byte version;

			// Token: 0x04000051 RID: 81
			private string hashAlgorithm;

			// Token: 0x04000052 RID: 82
			private PKCS7.ContentInfo contentInfo;

			// Token: 0x04000053 RID: 83
			private X509CertificateCollection certs;

			// Token: 0x04000054 RID: 84
			private ArrayList crls;

			// Token: 0x04000055 RID: 85
			private PKCS7.SignerInfo signerInfo;

			// Token: 0x04000056 RID: 86
			private bool mda;

			// Token: 0x04000057 RID: 87
			private bool signed;
		}

		// Token: 0x02000018 RID: 24
		public class SignerInfo
		{
			// Token: 0x060000F1 RID: 241 RVA: 0x00006C04 File Offset: 0x00004E04
			public SignerInfo()
			{
				this.version = 1;
				this.authenticatedAttributes = new ArrayList();
				this.unauthenticatedAttributes = new ArrayList();
			}

			// Token: 0x060000F2 RID: 242 RVA: 0x00006C2C File Offset: 0x00004E2C
			public SignerInfo(byte[] data)
				: this(new ASN1(data))
			{
			}

			// Token: 0x060000F3 RID: 243 RVA: 0x00006C3C File Offset: 0x00004E3C
			public SignerInfo(ASN1 asn1)
				: this()
			{
				if (asn1[0].Tag != 48 || asn1[0].Count < 5)
				{
					throw new ArgumentException("Invalid SignedData");
				}
				if (asn1[0][0].Tag != 2)
				{
					throw new ArgumentException("Invalid version");
				}
				this.version = asn1[0][0].Value[0];
				ASN1 asn2 = asn1[0][1];
				if (asn2.Tag == 128 && this.version == 3)
				{
					this.ski = asn2.Value;
				}
				else
				{
					this.issuer = X501.ToString(asn2[0]);
					this.serial = asn2[1].Value;
				}
				ASN1 asn3 = asn1[0][2];
				this.hashAlgorithm = ASN1Convert.ToOid(asn3[0]);
				int num = 3;
				ASN1 asn4 = asn1[0][num];
				if (asn4.Tag == 160)
				{
					num++;
					for (int i = 0; i < asn4.Count; i++)
					{
						this.authenticatedAttributes.Add(asn4[i]);
					}
				}
				num++;
				ASN1 asn5 = asn1[0][num++];
				if (asn5.Tag == 4)
				{
					this.signature = asn5.Value;
				}
				ASN1 asn6 = asn1[0][num];
				if (asn6 != null && asn6.Tag == 161)
				{
					for (int j = 0; j < asn6.Count; j++)
					{
						this.unauthenticatedAttributes.Add(asn6[j]);
					}
				}
			}

			// Token: 0x17000026 RID: 38
			// (get) Token: 0x060000F4 RID: 244 RVA: 0x00006E18 File Offset: 0x00005018
			public string IssuerName
			{
				get
				{
					return this.issuer;
				}
			}

			// Token: 0x17000027 RID: 39
			// (get) Token: 0x060000F5 RID: 245 RVA: 0x00006E20 File Offset: 0x00005020
			public byte[] SerialNumber
			{
				get
				{
					if (this.serial == null)
					{
						return null;
					}
					return (byte[])this.serial.Clone();
				}
			}

			// Token: 0x17000028 RID: 40
			// (get) Token: 0x060000F6 RID: 246 RVA: 0x00006E40 File Offset: 0x00005040
			public byte[] SubjectKeyIdentifier
			{
				get
				{
					if (this.ski == null)
					{
						return null;
					}
					return (byte[])this.ski.Clone();
				}
			}

			// Token: 0x17000029 RID: 41
			// (get) Token: 0x060000F7 RID: 247 RVA: 0x00006E60 File Offset: 0x00005060
			public ASN1 ASN1
			{
				get
				{
					return this.GetASN1();
				}
			}

			// Token: 0x1700002A RID: 42
			// (get) Token: 0x060000F8 RID: 248 RVA: 0x00006E68 File Offset: 0x00005068
			public ArrayList AuthenticatedAttributes
			{
				get
				{
					return this.authenticatedAttributes;
				}
			}

			// Token: 0x1700002B RID: 43
			// (get) Token: 0x060000F9 RID: 249 RVA: 0x00006E70 File Offset: 0x00005070
			// (set) Token: 0x060000FA RID: 250 RVA: 0x00006E78 File Offset: 0x00005078
			public X509Certificate Certificate
			{
				get
				{
					return this.x509;
				}
				set
				{
					this.x509 = value;
				}
			}

			// Token: 0x1700002C RID: 44
			// (get) Token: 0x060000FB RID: 251 RVA: 0x00006E84 File Offset: 0x00005084
			// (set) Token: 0x060000FC RID: 252 RVA: 0x00006E8C File Offset: 0x0000508C
			public string HashName
			{
				get
				{
					return this.hashAlgorithm;
				}
				set
				{
					this.hashAlgorithm = value;
				}
			}

			// Token: 0x1700002D RID: 45
			// (get) Token: 0x060000FD RID: 253 RVA: 0x00006E98 File Offset: 0x00005098
			// (set) Token: 0x060000FE RID: 254 RVA: 0x00006EA0 File Offset: 0x000050A0
			public AsymmetricAlgorithm Key
			{
				get
				{
					return this.key;
				}
				set
				{
					this.key = value;
				}
			}

			// Token: 0x1700002E RID: 46
			// (get) Token: 0x060000FF RID: 255 RVA: 0x00006EAC File Offset: 0x000050AC
			// (set) Token: 0x06000100 RID: 256 RVA: 0x00006ECC File Offset: 0x000050CC
			public byte[] Signature
			{
				get
				{
					if (this.signature == null)
					{
						return null;
					}
					return (byte[])this.signature.Clone();
				}
				set
				{
					if (value != null)
					{
						this.signature = (byte[])value.Clone();
					}
				}
			}

			// Token: 0x1700002F RID: 47
			// (get) Token: 0x06000101 RID: 257 RVA: 0x00006EE8 File Offset: 0x000050E8
			public ArrayList UnauthenticatedAttributes
			{
				get
				{
					return this.unauthenticatedAttributes;
				}
			}

			// Token: 0x17000030 RID: 48
			// (get) Token: 0x06000102 RID: 258 RVA: 0x00006EF0 File Offset: 0x000050F0
			// (set) Token: 0x06000103 RID: 259 RVA: 0x00006EF8 File Offset: 0x000050F8
			public byte Version
			{
				get
				{
					return this.version;
				}
				set
				{
					this.version = value;
				}
			}

			// Token: 0x06000104 RID: 260 RVA: 0x00006F04 File Offset: 0x00005104
			internal ASN1 GetASN1()
			{
				if (this.key == null || this.hashAlgorithm == null)
				{
					return null;
				}
				byte[] array = new byte[] { this.version };
				ASN1 asn = new ASN1(48);
				asn.Add(new ASN1(2, array));
				asn.Add(PKCS7.IssuerAndSerialNumber(this.x509));
				string text = CryptoConfig.MapNameToOID(this.hashAlgorithm);
				asn.Add(PKCS7.AlgorithmIdentifier(text));
				ASN1 asn2 = null;
				if (this.authenticatedAttributes.Count > 0)
				{
					asn2 = asn.Add(new ASN1(160));
					this.authenticatedAttributes.Sort(new PKCS7.SortedSet());
					foreach (object obj in this.authenticatedAttributes)
					{
						ASN1 asn3 = (ASN1)obj;
						asn2.Add(asn3);
					}
				}
				if (this.key is RSA)
				{
					asn.Add(PKCS7.AlgorithmIdentifier("1.2.840.113549.1.1.1"));
					if (asn2 != null)
					{
						RSAPKCS1SignatureFormatter rsapkcs1SignatureFormatter = new RSAPKCS1SignatureFormatter(this.key);
						rsapkcs1SignatureFormatter.SetHashAlgorithm(this.hashAlgorithm);
						byte[] bytes = asn2.GetBytes();
						bytes[0] = 49;
						HashAlgorithm hashAlgorithm = HashAlgorithm.Create(this.hashAlgorithm);
						byte[] array2 = hashAlgorithm.ComputeHash(bytes);
						this.signature = rsapkcs1SignatureFormatter.CreateSignature(array2);
					}
					asn.Add(new ASN1(4, this.signature));
					if (this.unauthenticatedAttributes.Count > 0)
					{
						ASN1 asn4 = asn.Add(new ASN1(161));
						this.unauthenticatedAttributes.Sort(new PKCS7.SortedSet());
						foreach (object obj2 in this.unauthenticatedAttributes)
						{
							ASN1 asn5 = (ASN1)obj2;
							asn4.Add(asn5);
						}
					}
					return asn;
				}
				if (this.key is DSA)
				{
					throw new NotImplementedException("not yet");
				}
				throw new CryptographicException("Unknown assymetric algorithm");
			}

			// Token: 0x06000105 RID: 261 RVA: 0x0000716C File Offset: 0x0000536C
			public byte[] GetBytes()
			{
				return this.GetASN1().GetBytes();
			}

			// Token: 0x04000059 RID: 89
			private byte version;

			// Token: 0x0400005A RID: 90
			private X509Certificate x509;

			// Token: 0x0400005B RID: 91
			private string hashAlgorithm;

			// Token: 0x0400005C RID: 92
			private AsymmetricAlgorithm key;

			// Token: 0x0400005D RID: 93
			private ArrayList authenticatedAttributes;

			// Token: 0x0400005E RID: 94
			private ArrayList unauthenticatedAttributes;

			// Token: 0x0400005F RID: 95
			private byte[] signature;

			// Token: 0x04000060 RID: 96
			private string issuer;

			// Token: 0x04000061 RID: 97
			private byte[] serial;

			// Token: 0x04000062 RID: 98
			private byte[] ski;
		}

		// Token: 0x02000019 RID: 25
		internal class SortedSet : IComparer
		{
			// Token: 0x06000107 RID: 263 RVA: 0x00007184 File Offset: 0x00005384
			public int Compare(object x, object y)
			{
				if (x == null)
				{
					return (y != null) ? (-1) : 0;
				}
				if (y == null)
				{
					return 1;
				}
				ASN1 asn = x as ASN1;
				ASN1 asn2 = y as ASN1;
				if (asn == null || asn2 == null)
				{
					throw new ArgumentException(Locale.GetText("Invalid objects."));
				}
				byte[] bytes = asn.GetBytes();
				byte[] bytes2 = asn2.GetBytes();
				for (int i = 0; i < bytes.Length; i++)
				{
					if (i == bytes2.Length)
					{
						break;
					}
					if (bytes[i] != bytes2[i])
					{
						return (bytes[i] >= bytes2[i]) ? 1 : (-1);
					}
				}
				if (bytes.Length > bytes2.Length)
				{
					return 1;
				}
				if (bytes.Length < bytes2.Length)
				{
					return -1;
				}
				return 0;
			}
		}
	}
}