using System; using System.Collections; using System.Collections.Generic; using System.IO; using System.Security.Cryptography; using System.Text; using Mono.Security.Cryptography; namespace Mono.Security.X509 { // Token: 0x020000B6 RID: 182 internal class PKCS12 : ICloneable { // Token: 0x060009B5 RID: 2485 RVA: 0x00027FB8 File Offset: 0x000261B8 public PKCS12() { this._iterations = PKCS12.recommendedIterationCount; this._keyBags = new ArrayList(); this._secretBags = new ArrayList(); this._certs = new X509CertificateCollection(); this._keyBagsChanged = false; this._secretBagsChanged = false; this._certsChanged = false; this._safeBags = new ArrayList(); } // Token: 0x060009B6 RID: 2486 RVA: 0x00028018 File Offset: 0x00026218 public PKCS12(byte[] data) : this() { this.Password = null; this.Decode(data); } // Token: 0x060009B7 RID: 2487 RVA: 0x00028030 File Offset: 0x00026230 public PKCS12(byte[] data, string password) : this() { this.Password = password; this.Decode(data); } // Token: 0x060009B8 RID: 2488 RVA: 0x00028048 File Offset: 0x00026248 public PKCS12(byte[] data, byte[] password) : this() { this._password = password; this.Decode(data); } // Token: 0x060009BA RID: 2490 RVA: 0x00028078 File Offset: 0x00026278 private void Decode(byte[] data) { ASN1 asn = new ASN1(data); if (asn.Tag != 48) { throw new ArgumentException("invalid data"); } ASN1 asn2 = asn[0]; if (asn2.Tag != 2) { throw new ArgumentException("invalid PFX version"); } PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn[1]); if (contentInfo.ContentType != "1.2.840.113549.1.7.1") { throw new ArgumentException("invalid authenticated safe"); } if (asn.Count > 2) { ASN1 asn3 = asn[2]; if (asn3.Tag != 48) { throw new ArgumentException("invalid MAC"); } ASN1 asn4 = asn3[0]; if (asn4.Tag != 48) { throw new ArgumentException("invalid MAC"); } ASN1 asn5 = asn4[0]; string text = ASN1Convert.ToOid(asn5[0]); if (text != "1.3.14.3.2.26") { throw new ArgumentException("unsupported HMAC"); } byte[] value = asn4[1].Value; ASN1 asn6 = asn3[1]; if (asn6.Tag != 4) { throw new ArgumentException("missing MAC salt"); } this._iterations = 1; if (asn3.Count > 2) { ASN1 asn7 = asn3[2]; if (asn7.Tag != 2) { throw new ArgumentException("invalid MAC iteration"); } this._iterations = ASN1Convert.ToInt32(asn7); } byte[] value2 = contentInfo.Content[0].Value; byte[] array = this.MAC(this._password, asn6.Value, this._iterations, value2); if (!this.Compare(value, array)) { throw new CryptographicException("Invalid MAC - file may have been tampered!"); } } ASN1 asn8 = new ASN1(contentInfo.Content[0].Value); int i = 0; while (i < asn8.Count) { PKCS7.ContentInfo contentInfo2 = new PKCS7.ContentInfo(asn8[i]); string contentType = contentInfo2.ContentType; if (contentType != null) { if (PKCS12.<>f__switch$map8 == null) { PKCS12.<>f__switch$map8 = new Dictionary(3) { { "1.2.840.113549.1.7.1", 0 }, { "1.2.840.113549.1.7.6", 1 }, { "1.2.840.113549.1.7.3", 2 } }; } int num; if (PKCS12.<>f__switch$map8.TryGetValue(contentType, out num)) { switch (num) { case 0: { ASN1 asn9 = new ASN1(contentInfo2.Content[0].Value); for (int j = 0; j < asn9.Count; j++) { ASN1 asn10 = asn9[j]; this.ReadSafeBag(asn10); } break; } case 1: { PKCS7.EncryptedData encryptedData = new PKCS7.EncryptedData(contentInfo2.Content[0]); ASN1 asn11 = new ASN1(this.Decrypt(encryptedData)); for (int k = 0; k < asn11.Count; k++) { ASN1 asn12 = asn11[k]; this.ReadSafeBag(asn12); } break; } case 2: throw new NotImplementedException("public key encrypted"); default: goto IL_303; } i++; continue; } } IL_303: throw new ArgumentException("unknown authenticatedSafe"); } } // Token: 0x060009BB RID: 2491 RVA: 0x000283A8 File Offset: 0x000265A8 ~PKCS12() { if (this._password != null) { Array.Clear(this._password, 0, this._password.Length); } this._password = null; } // Token: 0x1700011F RID: 287 // (set) Token: 0x060009BC RID: 2492 RVA: 0x00028404 File Offset: 0x00026604 public string Password { set { if (value != null) { if (value.Length > 0) { int num = value.Length; int num2 = 0; if (num < PKCS12.MaximumPasswordLength) { if (value[num - 1] != '\0') { num2 = 1; } } else { num = PKCS12.MaximumPasswordLength; } this._password = new byte[num + num2 << 1]; Encoding.BigEndianUnicode.GetBytes(value, 0, num, this._password, 0); } else { this._password = new byte[2]; } } else { this._password = null; } } } // Token: 0x17000120 RID: 288 // (get) Token: 0x060009BD RID: 2493 RVA: 0x00028494 File Offset: 0x00026694 // (set) Token: 0x060009BE RID: 2494 RVA: 0x0002849C File Offset: 0x0002669C public int IterationCount { get { return this._iterations; } set { this._iterations = value; } } // Token: 0x17000121 RID: 289 // (get) Token: 0x060009BF RID: 2495 RVA: 0x000284A8 File Offset: 0x000266A8 public ArrayList Keys { get { if (this._keyBagsChanged) { this._keyBags.Clear(); foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.1")) { ASN1 asn = safeBag.ASN1; ASN1 asn2 = asn[1]; PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(asn2.Value); byte[] privateKey = privateKeyInfo.PrivateKey; byte b = privateKey[0]; if (b != 2) { if (b == 48) { this._keyBags.Add(PKCS8.PrivateKeyInfo.DecodeRSA(privateKey)); } } else { DSAParameters dsaparameters = default(DSAParameters); this._keyBags.Add(PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, dsaparameters)); } Array.Clear(privateKey, 0, privateKey.Length); } else if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { ASN1 asn3 = safeBag.ASN1; ASN1 asn4 = asn3[1]; PKCS8.EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new PKCS8.EncryptedPrivateKeyInfo(asn4.Value); byte[] array = this.Decrypt(encryptedPrivateKeyInfo.Algorithm, encryptedPrivateKeyInfo.Salt, encryptedPrivateKeyInfo.IterationCount, encryptedPrivateKeyInfo.EncryptedData); PKCS8.PrivateKeyInfo privateKeyInfo2 = new PKCS8.PrivateKeyInfo(array); byte[] privateKey2 = privateKeyInfo2.PrivateKey; byte b = privateKey2[0]; if (b != 2) { if (b == 48) { this._keyBags.Add(PKCS8.PrivateKeyInfo.DecodeRSA(privateKey2)); } } else { DSAParameters dsaparameters2 = default(DSAParameters); this._keyBags.Add(PKCS8.PrivateKeyInfo.DecodeDSA(privateKey2, dsaparameters2)); } Array.Clear(privateKey2, 0, privateKey2.Length); Array.Clear(array, 0, array.Length); } } this._keyBagsChanged = false; } return ArrayList.ReadOnly(this._keyBags); } } // Token: 0x17000122 RID: 290 // (get) Token: 0x060009C0 RID: 2496 RVA: 0x000286C0 File Offset: 0x000268C0 public ArrayList Secrets { get { if (this._secretBagsChanged) { this._secretBags.Clear(); foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.5")) { ASN1 asn = safeBag.ASN1; ASN1 asn2 = asn[1]; byte[] value = asn2.Value; this._secretBags.Add(value); } } this._secretBagsChanged = false; } return ArrayList.ReadOnly(this._secretBags); } } // Token: 0x17000123 RID: 291 // (get) Token: 0x060009C1 RID: 2497 RVA: 0x00028790 File Offset: 0x00026990 public X509CertificateCollection Certificates { get { if (this._certsChanged) { this._certs.Clear(); foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.3")) { ASN1 asn = safeBag.ASN1; ASN1 asn2 = asn[1]; PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn2.Value); this._certs.Add(new X509Certificate(contentInfo.Content[0].Value)); } } this._certsChanged = false; } return this._certs; } } // Token: 0x17000124 RID: 292 // (get) Token: 0x060009C2 RID: 2498 RVA: 0x00028874 File Offset: 0x00026A74 internal RandomNumberGenerator RNG { get { if (this._rng == null) { this._rng = RandomNumberGenerator.Create(); } return this._rng; } } // Token: 0x060009C3 RID: 2499 RVA: 0x00028894 File Offset: 0x00026A94 private bool Compare(byte[] expected, byte[] actual) { bool flag = false; if (expected.Length == actual.Length) { for (int i = 0; i < expected.Length; i++) { if (expected[i] != actual[i]) { return false; } } flag = true; } return flag; } // Token: 0x060009C4 RID: 2500 RVA: 0x000288D4 File Offset: 0x00026AD4 private SymmetricAlgorithm GetSymmetricAlgorithm(string algorithmOid, byte[] salt, int iterationCount) { string text = null; int num = 8; int num2 = 8; PKCS12.DeriveBytes deriveBytes = new PKCS12.DeriveBytes(); deriveBytes.Password = this._password; deriveBytes.Salt = salt; deriveBytes.IterationCount = iterationCount; if (algorithmOid != null) { if (PKCS12.<>f__switch$map9 == null) { PKCS12.<>f__switch$map9 = new Dictionary(12) { { "1.2.840.113549.1.5.1", 0 }, { "1.2.840.113549.1.5.3", 1 }, { "1.2.840.113549.1.5.4", 2 }, { "1.2.840.113549.1.5.6", 3 }, { "1.2.840.113549.1.5.10", 4 }, { "1.2.840.113549.1.5.11", 5 }, { "1.2.840.113549.1.12.1.1", 6 }, { "1.2.840.113549.1.12.1.2", 7 }, { "1.2.840.113549.1.12.1.3", 8 }, { "1.2.840.113549.1.12.1.4", 9 }, { "1.2.840.113549.1.12.1.5", 10 }, { "1.2.840.113549.1.12.1.6", 11 } }; } int num3; if (PKCS12.<>f__switch$map9.TryGetValue(algorithmOid, out num3)) { switch (num3) { case 0: deriveBytes.HashName = "MD2"; text = "DES"; break; case 1: deriveBytes.HashName = "MD5"; text = "DES"; break; case 2: deriveBytes.HashName = "MD2"; text = "RC2"; num = 4; break; case 3: deriveBytes.HashName = "MD5"; text = "RC2"; num = 4; break; case 4: deriveBytes.HashName = "SHA1"; text = "DES"; break; case 5: deriveBytes.HashName = "SHA1"; text = "RC2"; num = 4; break; case 6: deriveBytes.HashName = "SHA1"; text = "RC4"; num = 16; num2 = 0; break; case 7: deriveBytes.HashName = "SHA1"; text = "RC4"; num = 5; num2 = 0; break; case 8: deriveBytes.HashName = "SHA1"; text = "TripleDES"; num = 24; break; case 9: deriveBytes.HashName = "SHA1"; text = "TripleDES"; num = 16; break; case 10: deriveBytes.HashName = "SHA1"; text = "RC2"; num = 16; break; case 11: deriveBytes.HashName = "SHA1"; text = "RC2"; num = 5; break; default: goto IL_25A; } SymmetricAlgorithm symmetricAlgorithm = SymmetricAlgorithm.Create(text); symmetricAlgorithm.Key = deriveBytes.DeriveKey(num); if (num2 > 0) { symmetricAlgorithm.IV = deriveBytes.DeriveIV(num2); symmetricAlgorithm.Mode = CipherMode.CBC; } return symmetricAlgorithm; } } IL_25A: throw new NotSupportedException("unknown oid " + text); } // Token: 0x060009C5 RID: 2501 RVA: 0x00028B84 File Offset: 0x00026D84 public byte[] Decrypt(string algorithmOid, byte[] salt, int iterationCount, byte[] encryptedData) { SymmetricAlgorithm symmetricAlgorithm = null; byte[] array = null; try { symmetricAlgorithm = this.GetSymmetricAlgorithm(algorithmOid, salt, iterationCount); ICryptoTransform cryptoTransform = symmetricAlgorithm.CreateDecryptor(); array = cryptoTransform.TransformFinalBlock(encryptedData, 0, encryptedData.Length); } finally { if (symmetricAlgorithm != null) { symmetricAlgorithm.Clear(); } } return array; } // Token: 0x060009C6 RID: 2502 RVA: 0x00028BE4 File Offset: 0x00026DE4 public byte[] Decrypt(PKCS7.EncryptedData ed) { return this.Decrypt(ed.EncryptionAlgorithm.ContentType, ed.EncryptionAlgorithm.Content[0].Value, ASN1Convert.ToInt32(ed.EncryptionAlgorithm.Content[1]), ed.EncryptedContent); } // Token: 0x060009C7 RID: 2503 RVA: 0x00028C34 File Offset: 0x00026E34 public byte[] Encrypt(string algorithmOid, byte[] salt, int iterationCount, byte[] data) { byte[] array = null; using (SymmetricAlgorithm symmetricAlgorithm = this.GetSymmetricAlgorithm(algorithmOid, salt, iterationCount)) { ICryptoTransform cryptoTransform = symmetricAlgorithm.CreateEncryptor(); array = cryptoTransform.TransformFinalBlock(data, 0, data.Length); } return array; } // Token: 0x060009C8 RID: 2504 RVA: 0x00028C94 File Offset: 0x00026E94 private DSAParameters GetExistingParameters(out bool found) { foreach (X509Certificate x509Certificate in this.Certificates) { if (x509Certificate.KeyAlgorithmParameters != null) { DSA dsa = x509Certificate.DSA; if (dsa != null) { found = true; return dsa.ExportParameters(false); } } } found = false; return default(DSAParameters); } // Token: 0x060009C9 RID: 2505 RVA: 0x00028D34 File Offset: 0x00026F34 private void AddPrivateKey(PKCS8.PrivateKeyInfo pki) { byte[] privateKey = pki.PrivateKey; byte b = privateKey[0]; if (b != 2) { if (b != 48) { Array.Clear(privateKey, 0, privateKey.Length); throw new CryptographicException("Unknown private key format"); } this._keyBags.Add(PKCS8.PrivateKeyInfo.DecodeRSA(privateKey)); } else { bool flag; DSAParameters existingParameters = this.GetExistingParameters(out flag); if (flag) { this._keyBags.Add(PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, existingParameters)); } } Array.Clear(privateKey, 0, privateKey.Length); } // Token: 0x060009CA RID: 2506 RVA: 0x00028DC0 File Offset: 0x00026FC0 private void ReadSafeBag(ASN1 safeBag) { if (safeBag.Tag != 48) { throw new ArgumentException("invalid safeBag"); } ASN1 asn = safeBag[0]; if (asn.Tag != 6) { throw new ArgumentException("invalid safeBag id"); } ASN1 asn2 = safeBag[1]; string text = ASN1Convert.ToOid(asn); string text2 = text; if (text2 != null) { if (PKCS12.<>f__switch$mapA == null) { PKCS12.<>f__switch$mapA = new Dictionary(6) { { "1.2.840.113549.1.12.10.1.1", 0 }, { "1.2.840.113549.1.12.10.1.2", 1 }, { "1.2.840.113549.1.12.10.1.3", 2 }, { "1.2.840.113549.1.12.10.1.4", 3 }, { "1.2.840.113549.1.12.10.1.5", 4 }, { "1.2.840.113549.1.12.10.1.6", 5 } }; } int num; if (PKCS12.<>f__switch$mapA.TryGetValue(text2, out num)) { switch (num) { case 0: this.AddPrivateKey(new PKCS8.PrivateKeyInfo(asn2.Value)); break; case 1: { PKCS8.EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new PKCS8.EncryptedPrivateKeyInfo(asn2.Value); byte[] array = this.Decrypt(encryptedPrivateKeyInfo.Algorithm, encryptedPrivateKeyInfo.Salt, encryptedPrivateKeyInfo.IterationCount, encryptedPrivateKeyInfo.EncryptedData); this.AddPrivateKey(new PKCS8.PrivateKeyInfo(array)); Array.Clear(array, 0, array.Length); break; } case 2: { PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn2.Value); if (contentInfo.ContentType != "1.2.840.113549.1.9.22.1") { throw new NotSupportedException("unsupport certificate type"); } X509Certificate x509Certificate = new X509Certificate(contentInfo.Content[0].Value); this._certs.Add(x509Certificate); break; } case 3: break; case 4: { byte[] value = asn2.Value; this._secretBags.Add(value); break; } case 5: break; default: goto IL_1CD; } if (safeBag.Count > 2) { ASN1 asn3 = safeBag[2]; if (asn3.Tag != 49) { throw new ArgumentException("invalid safeBag attributes id"); } for (int i = 0; i < asn3.Count; i++) { ASN1 asn4 = asn3[i]; if (asn4.Tag != 48) { throw new ArgumentException("invalid PKCS12 attributes id"); } ASN1 asn5 = asn4[0]; if (asn5.Tag != 6) { throw new ArgumentException("invalid attribute id"); } string text3 = ASN1Convert.ToOid(asn5); ASN1 asn6 = asn4[1]; int j = 0; while (j < asn6.Count) { ASN1 asn7 = asn6[j]; text2 = text3; if (text2 != null) { if (PKCS12.<>f__switch$mapB == null) { PKCS12.<>f__switch$mapB = new Dictionary(2) { { "1.2.840.113549.1.9.20", 0 }, { "1.2.840.113549.1.9.21", 1 } }; } if (PKCS12.<>f__switch$mapB.TryGetValue(text2, out num)) { if (num != 0) { if (num == 1) { if (asn7.Tag != 4) { throw new ArgumentException("invalid attribute value id"); } } } else if (asn7.Tag != 30) { throw new ArgumentException("invalid attribute value id"); } } } IL_31F: j++; continue; goto IL_31F; } } } this._safeBags.Add(new SafeBag(text, safeBag)); return; } } IL_1CD: throw new ArgumentException("unknown safeBag oid"); } // Token: 0x060009CB RID: 2507 RVA: 0x00029128 File Offset: 0x00027328 private ASN1 Pkcs8ShroudedKeyBagSafeBag(AsymmetricAlgorithm aa, IDictionary attributes) { PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(); if (aa is RSA) { privateKeyInfo.Algorithm = "1.2.840.113549.1.1.1"; privateKeyInfo.PrivateKey = PKCS8.PrivateKeyInfo.Encode((RSA)aa); } else { if (!(aa is DSA)) { throw new CryptographicException("Unknown asymmetric algorithm {0}", aa.ToString()); } privateKeyInfo.Algorithm = null; privateKeyInfo.PrivateKey = PKCS8.PrivateKeyInfo.Encode((DSA)aa); } PKCS8.EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new PKCS8.EncryptedPrivateKeyInfo(); encryptedPrivateKeyInfo.Algorithm = "1.2.840.113549.1.12.1.3"; encryptedPrivateKeyInfo.IterationCount = this._iterations; encryptedPrivateKeyInfo.EncryptedData = this.Encrypt("1.2.840.113549.1.12.1.3", encryptedPrivateKeyInfo.Salt, this._iterations, privateKeyInfo.GetBytes()); ASN1 asn = new ASN1(48); asn.Add(ASN1Convert.FromOid("1.2.840.113549.1.12.10.1.2")); ASN1 asn2 = new ASN1(160); asn2.Add(new ASN1(encryptedPrivateKeyInfo.GetBytes())); asn.Add(asn2); if (attributes != null) { ASN1 asn3 = new ASN1(49); IDictionaryEnumerator enumerator = attributes.GetEnumerator(); while (enumerator.MoveNext()) { string text = (string)enumerator.Key; string text2 = text; if (text2 != null) { if (PKCS12.<>f__switch$mapC == null) { PKCS12.<>f__switch$mapC = new Dictionary(2) { { "1.2.840.113549.1.9.20", 0 }, { "1.2.840.113549.1.9.21", 1 } }; } int num; if (PKCS12.<>f__switch$mapC.TryGetValue(text2, out num)) { if (num != 0) { if (num == 1) { ArrayList arrayList = (ArrayList)enumerator.Value; if (arrayList.Count > 0) { ASN1 asn4 = new ASN1(48); asn4.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.21")); ASN1 asn5 = new ASN1(49); foreach (object obj in arrayList) { byte[] array = (byte[])obj; asn5.Add(new ASN1(4) { Value = array }); } asn4.Add(asn5); asn3.Add(asn4); } } } else { ArrayList arrayList2 = (ArrayList)enumerator.Value; if (arrayList2.Count > 0) { ASN1 asn6 = new ASN1(48); asn6.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.20")); ASN1 asn7 = new ASN1(49); foreach (object obj2 in arrayList2) { byte[] array2 = (byte[])obj2; asn7.Add(new ASN1(30) { Value = array2 }); } asn6.Add(asn7); asn3.Add(asn6); } } } } } if (asn3.Count > 0) { asn.Add(asn3); } } return asn; } // Token: 0x060009CC RID: 2508 RVA: 0x00029478 File Offset: 0x00027678 private ASN1 KeyBagSafeBag(AsymmetricAlgorithm aa, IDictionary attributes) { PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(); if (aa is RSA) { privateKeyInfo.Algorithm = "1.2.840.113549.1.1.1"; privateKeyInfo.PrivateKey = PKCS8.PrivateKeyInfo.Encode((RSA)aa); } else { if (!(aa is DSA)) { throw new CryptographicException("Unknown asymmetric algorithm {0}", aa.ToString()); } privateKeyInfo.Algorithm = null; privateKeyInfo.PrivateKey = PKCS8.PrivateKeyInfo.Encode((DSA)aa); } ASN1 asn = new ASN1(48); asn.Add(ASN1Convert.FromOid("1.2.840.113549.1.12.10.1.1")); ASN1 asn2 = new ASN1(160); asn2.Add(new ASN1(privateKeyInfo.GetBytes())); asn.Add(asn2); if (attributes != null) { ASN1 asn3 = new ASN1(49); IDictionaryEnumerator enumerator = attributes.GetEnumerator(); while (enumerator.MoveNext()) { string text = (string)enumerator.Key; string text2 = text; if (text2 != null) { if (PKCS12.<>f__switch$mapD == null) { PKCS12.<>f__switch$mapD = new Dictionary(2) { { "1.2.840.113549.1.9.20", 0 }, { "1.2.840.113549.1.9.21", 1 } }; } int num; if (PKCS12.<>f__switch$mapD.TryGetValue(text2, out num)) { if (num != 0) { if (num == 1) { ArrayList arrayList = (ArrayList)enumerator.Value; if (arrayList.Count > 0) { ASN1 asn4 = new ASN1(48); asn4.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.21")); ASN1 asn5 = new ASN1(49); foreach (object obj in arrayList) { byte[] array = (byte[])obj; asn5.Add(new ASN1(4) { Value = array }); } asn4.Add(asn5); asn3.Add(asn4); } } } else { ArrayList arrayList2 = (ArrayList)enumerator.Value; if (arrayList2.Count > 0) { ASN1 asn6 = new ASN1(48); asn6.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.20")); ASN1 asn7 = new ASN1(49); foreach (object obj2 in arrayList2) { byte[] array2 = (byte[])obj2; asn7.Add(new ASN1(30) { Value = array2 }); } asn6.Add(asn7); asn3.Add(asn6); } } } } } if (asn3.Count > 0) { asn.Add(asn3); } } return asn; } // Token: 0x060009CD RID: 2509 RVA: 0x00029784 File Offset: 0x00027984 private ASN1 SecretBagSafeBag(byte[] secret, IDictionary attributes) { ASN1 asn = new ASN1(48); asn.Add(ASN1Convert.FromOid("1.2.840.113549.1.12.10.1.5")); ASN1 asn2 = new ASN1(128, secret); asn.Add(asn2); if (attributes != null) { ASN1 asn3 = new ASN1(49); IDictionaryEnumerator enumerator = attributes.GetEnumerator(); while (enumerator.MoveNext()) { string text = (string)enumerator.Key; string text2 = text; if (text2 != null) { if (PKCS12.<>f__switch$mapE == null) { PKCS12.<>f__switch$mapE = new Dictionary(2) { { "1.2.840.113549.1.9.20", 0 }, { "1.2.840.113549.1.9.21", 1 } }; } int num; if (PKCS12.<>f__switch$mapE.TryGetValue(text2, out num)) { if (num != 0) { if (num == 1) { ArrayList arrayList = (ArrayList)enumerator.Value; if (arrayList.Count > 0) { ASN1 asn4 = new ASN1(48); asn4.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.21")); ASN1 asn5 = new ASN1(49); foreach (object obj in arrayList) { byte[] array = (byte[])obj; asn5.Add(new ASN1(4) { Value = array }); } asn4.Add(asn5); asn3.Add(asn4); } } } else { ArrayList arrayList2 = (ArrayList)enumerator.Value; if (arrayList2.Count > 0) { ASN1 asn6 = new ASN1(48); asn6.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.20")); ASN1 asn7 = new ASN1(49); foreach (object obj2 in arrayList2) { byte[] array2 = (byte[])obj2; asn7.Add(new ASN1(30) { Value = array2 }); } asn6.Add(asn7); asn3.Add(asn6); } } } } } if (asn3.Count > 0) { asn.Add(asn3); } } return asn; } // Token: 0x060009CE RID: 2510 RVA: 0x00029A0C File Offset: 0x00027C0C private ASN1 CertificateSafeBag(X509Certificate x509, IDictionary attributes) { ASN1 asn = new ASN1(4, x509.RawData); PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(); contentInfo.ContentType = "1.2.840.113549.1.9.22.1"; contentInfo.Content.Add(asn); ASN1 asn2 = new ASN1(160); asn2.Add(contentInfo.ASN1); ASN1 asn3 = new ASN1(48); asn3.Add(ASN1Convert.FromOid("1.2.840.113549.1.12.10.1.3")); asn3.Add(asn2); if (attributes != null) { ASN1 asn4 = new ASN1(49); IDictionaryEnumerator enumerator = attributes.GetEnumerator(); while (enumerator.MoveNext()) { string text = (string)enumerator.Key; string text2 = text; if (text2 != null) { if (PKCS12.<>f__switch$mapF == null) { PKCS12.<>f__switch$mapF = new Dictionary(2) { { "1.2.840.113549.1.9.20", 0 }, { "1.2.840.113549.1.9.21", 1 } }; } int num; if (PKCS12.<>f__switch$mapF.TryGetValue(text2, out num)) { if (num != 0) { if (num == 1) { ArrayList arrayList = (ArrayList)enumerator.Value; if (arrayList.Count > 0) { ASN1 asn5 = new ASN1(48); asn5.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.21")); ASN1 asn6 = new ASN1(49); foreach (object obj in arrayList) { byte[] array = (byte[])obj; asn6.Add(new ASN1(4) { Value = array }); } asn5.Add(asn6); asn4.Add(asn5); } } } else { ArrayList arrayList2 = (ArrayList)enumerator.Value; if (arrayList2.Count > 0) { ASN1 asn7 = new ASN1(48); asn7.Add(ASN1Convert.FromOid("1.2.840.113549.1.9.20")); ASN1 asn8 = new ASN1(49); foreach (object obj2 in arrayList2) { byte[] array2 = (byte[])obj2; asn8.Add(new ASN1(30) { Value = array2 }); } asn7.Add(asn8); asn4.Add(asn7); } } } } } if (asn4.Count > 0) { asn3.Add(asn4); } } return asn3; } // Token: 0x060009CF RID: 2511 RVA: 0x00029CD8 File Offset: 0x00027ED8 private byte[] MAC(byte[] password, byte[] salt, int iterations, byte[] data) { PKCS12.DeriveBytes deriveBytes = new PKCS12.DeriveBytes(); deriveBytes.HashName = "SHA1"; deriveBytes.Password = password; deriveBytes.Salt = salt; deriveBytes.IterationCount = iterations; HMACSHA1 hmacsha = (HMACSHA1)HMAC.Create(); hmacsha.Key = deriveBytes.DeriveMAC(20); return hmacsha.ComputeHash(data, 0, data.Length); } // Token: 0x060009D0 RID: 2512 RVA: 0x00029D34 File Offset: 0x00027F34 public byte[] GetBytes() { ASN1 asn = new ASN1(48); ArrayList arrayList = new ArrayList(); foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.3")) { ASN1 asn2 = safeBag.ASN1; ASN1 asn3 = asn2[1]; PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn3.Value); arrayList.Add(new X509Certificate(contentInfo.Content[0].Value)); } } ArrayList arrayList2 = new ArrayList(); ArrayList arrayList3 = new ArrayList(); foreach (X509Certificate x509Certificate in this.Certificates) { bool flag = false; foreach (object obj2 in arrayList) { X509Certificate x509Certificate2 = (X509Certificate)obj2; if (this.Compare(x509Certificate.RawData, x509Certificate2.RawData)) { flag = true; } } if (!flag) { arrayList2.Add(x509Certificate); } } foreach (object obj3 in arrayList) { X509Certificate x509Certificate3 = (X509Certificate)obj3; bool flag2 = false; foreach (X509Certificate x509Certificate4 in this.Certificates) { if (this.Compare(x509Certificate3.RawData, x509Certificate4.RawData)) { flag2 = true; } } if (!flag2) { arrayList3.Add(x509Certificate3); } } foreach (object obj4 in arrayList3) { X509Certificate x509Certificate5 = (X509Certificate)obj4; this.RemoveCertificate(x509Certificate5); } foreach (object obj5 in arrayList2) { X509Certificate x509Certificate6 = (X509Certificate)obj5; this.AddCertificate(x509Certificate6); } if (this._safeBags.Count > 0) { ASN1 asn4 = new ASN1(48); foreach (object obj6 in this._safeBags) { SafeBag safeBag2 = (SafeBag)obj6; if (safeBag2.BagOID.Equals("1.2.840.113549.1.12.10.1.3")) { asn4.Add(safeBag2.ASN1); } } if (asn4.Count > 0) { PKCS7.ContentInfo contentInfo2 = this.EncryptedContentInfo(asn4, "1.2.840.113549.1.12.1.3"); asn.Add(contentInfo2.ASN1); } } if (this._safeBags.Count > 0) { ASN1 asn5 = new ASN1(48); foreach (object obj7 in this._safeBags) { SafeBag safeBag3 = (SafeBag)obj7; if (safeBag3.BagOID.Equals("1.2.840.113549.1.12.10.1.1") || safeBag3.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { asn5.Add(safeBag3.ASN1); } } if (asn5.Count > 0) { ASN1 asn6 = new ASN1(160); asn6.Add(new ASN1(4, asn5.GetBytes())); asn.Add(new PKCS7.ContentInfo("1.2.840.113549.1.7.1") { Content = asn6 }.ASN1); } } if (this._safeBags.Count > 0) { ASN1 asn7 = new ASN1(48); foreach (object obj8 in this._safeBags) { SafeBag safeBag4 = (SafeBag)obj8; if (safeBag4.BagOID.Equals("1.2.840.113549.1.12.10.1.5")) { asn7.Add(safeBag4.ASN1); } } if (asn7.Count > 0) { PKCS7.ContentInfo contentInfo3 = this.EncryptedContentInfo(asn7, "1.2.840.113549.1.12.1.3"); asn.Add(contentInfo3.ASN1); } } ASN1 asn8 = new ASN1(4, asn.GetBytes()); ASN1 asn9 = new ASN1(160); asn9.Add(asn8); PKCS7.ContentInfo contentInfo4 = new PKCS7.ContentInfo("1.2.840.113549.1.7.1"); contentInfo4.Content = asn9; ASN1 asn10 = new ASN1(48); if (this._password != null) { byte[] array = new byte[20]; this.RNG.GetBytes(array); byte[] array2 = this.MAC(this._password, array, this._iterations, contentInfo4.Content[0].Value); ASN1 asn11 = new ASN1(48); asn11.Add(ASN1Convert.FromOid("1.3.14.3.2.26")); asn11.Add(new ASN1(5)); ASN1 asn12 = new ASN1(48); asn12.Add(asn11); asn12.Add(new ASN1(4, array2)); asn10.Add(asn12); asn10.Add(new ASN1(4, array)); asn10.Add(ASN1Convert.FromInt32(this._iterations)); } ASN1 asn13 = new ASN1(2, new byte[] { 3 }); ASN1 asn14 = new ASN1(48); asn14.Add(asn13); asn14.Add(contentInfo4.ASN1); if (asn10.Count > 0) { asn14.Add(asn10); } return asn14.GetBytes(); } // Token: 0x060009D1 RID: 2513 RVA: 0x0002A488 File Offset: 0x00028688 private PKCS7.ContentInfo EncryptedContentInfo(ASN1 safeBags, string algorithmOid) { byte[] array = new byte[8]; this.RNG.GetBytes(array); ASN1 asn = new ASN1(48); asn.Add(new ASN1(4, array)); asn.Add(ASN1Convert.FromInt32(this._iterations)); ASN1 asn2 = new ASN1(48); asn2.Add(ASN1Convert.FromOid(algorithmOid)); asn2.Add(asn); byte[] array2 = this.Encrypt(algorithmOid, array, this._iterations, safeBags.GetBytes()); ASN1 asn3 = new ASN1(128, array2); ASN1 asn4 = new ASN1(48); asn4.Add(ASN1Convert.FromOid("1.2.840.113549.1.7.1")); asn4.Add(asn2); asn4.Add(asn3); ASN1 asn5 = new ASN1(2, new byte[1]); ASN1 asn6 = new ASN1(48); asn6.Add(asn5); asn6.Add(asn4); ASN1 asn7 = new ASN1(160); asn7.Add(asn6); return new PKCS7.ContentInfo("1.2.840.113549.1.7.6") { Content = asn7 }; } // Token: 0x060009D2 RID: 2514 RVA: 0x0002A598 File Offset: 0x00028798 public void AddCertificate(X509Certificate cert) { this.AddCertificate(cert, null); } // Token: 0x060009D3 RID: 2515 RVA: 0x0002A5A4 File Offset: 0x000287A4 public void AddCertificate(X509Certificate cert, IDictionary attributes) { bool flag = false; int num = 0; while (!flag && num < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.3")) { ASN1 asn = safeBag.ASN1; ASN1 asn2 = asn[1]; PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn2.Value); X509Certificate x509Certificate = new X509Certificate(contentInfo.Content[0].Value); if (this.Compare(cert.RawData, x509Certificate.RawData)) { flag = true; } } num++; } if (!flag) { this._safeBags.Add(new SafeBag("1.2.840.113549.1.12.10.1.3", this.CertificateSafeBag(cert, attributes))); this._certsChanged = true; } } // Token: 0x060009D4 RID: 2516 RVA: 0x0002A678 File Offset: 0x00028878 public void RemoveCertificate(X509Certificate cert) { this.RemoveCertificate(cert, null); } // Token: 0x060009D5 RID: 2517 RVA: 0x0002A684 File Offset: 0x00028884 public void RemoveCertificate(X509Certificate cert, IDictionary attrs) { int num = -1; int num2 = 0; while (num == -1 && num2 < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num2]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.3")) { ASN1 asn = safeBag.ASN1; ASN1 asn2 = asn[1]; PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn2.Value); X509Certificate x509Certificate = new X509Certificate(contentInfo.Content[0].Value); if (this.Compare(cert.RawData, x509Certificate.RawData)) { if (attrs != null) { if (asn.Count == 3) { ASN1 asn3 = asn[2]; int num3 = 0; for (int i = 0; i < asn3.Count; i++) { ASN1 asn4 = asn3[i]; ASN1 asn5 = asn4[0]; string text = ASN1Convert.ToOid(asn5); ArrayList arrayList = (ArrayList)attrs[text]; if (arrayList != null) { ASN1 asn6 = asn4[1]; if (arrayList.Count == asn6.Count) { int num4 = 0; for (int j = 0; j < asn6.Count; j++) { ASN1 asn7 = asn6[j]; byte[] array = (byte[])arrayList[j]; if (this.Compare(array, asn7.Value)) { num4++; } } if (num4 == asn6.Count) { num3++; } } } } if (num3 == asn3.Count) { num = num2; } } } else { num = num2; } } } num2++; } if (num != -1) { this._safeBags.RemoveAt(num); this._certsChanged = true; } } // Token: 0x060009D6 RID: 2518 RVA: 0x0002A850 File Offset: 0x00028A50 private bool CompareAsymmetricAlgorithm(AsymmetricAlgorithm a1, AsymmetricAlgorithm a2) { return a1.KeySize == a2.KeySize && a1.ToXmlString(false) == a2.ToXmlString(false); } // Token: 0x060009D7 RID: 2519 RVA: 0x0002A884 File Offset: 0x00028A84 public void AddPkcs8ShroudedKeyBag(AsymmetricAlgorithm aa) { this.AddPkcs8ShroudedKeyBag(aa, null); } // Token: 0x060009D8 RID: 2520 RVA: 0x0002A890 File Offset: 0x00028A90 public void AddPkcs8ShroudedKeyBag(AsymmetricAlgorithm aa, IDictionary attributes) { bool flag = false; int num = 0; while (!flag && num < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { ASN1 asn = safeBag.ASN1[1]; PKCS8.EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new PKCS8.EncryptedPrivateKeyInfo(asn.Value); byte[] array = this.Decrypt(encryptedPrivateKeyInfo.Algorithm, encryptedPrivateKeyInfo.Salt, encryptedPrivateKeyInfo.IterationCount, encryptedPrivateKeyInfo.EncryptedData); PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(array); byte[] privateKey = privateKeyInfo.PrivateKey; byte b = privateKey[0]; AsymmetricAlgorithm asymmetricAlgorithm; if (b != 2) { if (b != 48) { Array.Clear(array, 0, array.Length); Array.Clear(privateKey, 0, privateKey.Length); throw new CryptographicException("Unknown private key format"); } asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey); } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, default(DSAParameters)); } Array.Clear(array, 0, array.Length); Array.Clear(privateKey, 0, privateKey.Length); if (this.CompareAsymmetricAlgorithm(aa, asymmetricAlgorithm)) { flag = true; } } num++; } if (!flag) { this._safeBags.Add(new SafeBag("1.2.840.113549.1.12.10.1.2", this.Pkcs8ShroudedKeyBagSafeBag(aa, attributes))); this._keyBagsChanged = true; } } // Token: 0x060009D9 RID: 2521 RVA: 0x0002A9F4 File Offset: 0x00028BF4 public void RemovePkcs8ShroudedKeyBag(AsymmetricAlgorithm aa) { int num = -1; int num2 = 0; while (num == -1 && num2 < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num2]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { ASN1 asn = safeBag.ASN1[1]; PKCS8.EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new PKCS8.EncryptedPrivateKeyInfo(asn.Value); byte[] array = this.Decrypt(encryptedPrivateKeyInfo.Algorithm, encryptedPrivateKeyInfo.Salt, encryptedPrivateKeyInfo.IterationCount, encryptedPrivateKeyInfo.EncryptedData); PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(array); byte[] privateKey = privateKeyInfo.PrivateKey; byte b = privateKey[0]; AsymmetricAlgorithm asymmetricAlgorithm; if (b != 2) { if (b != 48) { Array.Clear(array, 0, array.Length); Array.Clear(privateKey, 0, privateKey.Length); throw new CryptographicException("Unknown private key format"); } asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey); } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, default(DSAParameters)); } Array.Clear(array, 0, array.Length); Array.Clear(privateKey, 0, privateKey.Length); if (this.CompareAsymmetricAlgorithm(aa, asymmetricAlgorithm)) { num = num2; } } num2++; } if (num != -1) { this._safeBags.RemoveAt(num); this._keyBagsChanged = true; } } // Token: 0x060009DA RID: 2522 RVA: 0x0002AB48 File Offset: 0x00028D48 public void AddKeyBag(AsymmetricAlgorithm aa) { this.AddKeyBag(aa, null); } // Token: 0x060009DB RID: 2523 RVA: 0x0002AB54 File Offset: 0x00028D54 public void AddKeyBag(AsymmetricAlgorithm aa, IDictionary attributes) { bool flag = false; int num = 0; while (!flag && num < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.1")) { ASN1 asn = safeBag.ASN1[1]; PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(asn.Value); byte[] privateKey = privateKeyInfo.PrivateKey; byte b = privateKey[0]; AsymmetricAlgorithm asymmetricAlgorithm; if (b != 2) { if (b != 48) { Array.Clear(privateKey, 0, privateKey.Length); throw new CryptographicException("Unknown private key format"); } asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey); } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, default(DSAParameters)); } Array.Clear(privateKey, 0, privateKey.Length); if (this.CompareAsymmetricAlgorithm(aa, asymmetricAlgorithm)) { flag = true; } } num++; } if (!flag) { this._safeBags.Add(new SafeBag("1.2.840.113549.1.12.10.1.1", this.KeyBagSafeBag(aa, attributes))); this._keyBagsChanged = true; } } // Token: 0x060009DC RID: 2524 RVA: 0x0002AC74 File Offset: 0x00028E74 public void RemoveKeyBag(AsymmetricAlgorithm aa) { int num = -1; int num2 = 0; while (num == -1 && num2 < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num2]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.1")) { ASN1 asn = safeBag.ASN1[1]; PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(asn.Value); byte[] privateKey = privateKeyInfo.PrivateKey; byte b = privateKey[0]; AsymmetricAlgorithm asymmetricAlgorithm; if (b != 2) { if (b != 48) { Array.Clear(privateKey, 0, privateKey.Length); throw new CryptographicException("Unknown private key format"); } asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey); } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, default(DSAParameters)); } Array.Clear(privateKey, 0, privateKey.Length); if (this.CompareAsymmetricAlgorithm(aa, asymmetricAlgorithm)) { num = num2; } } num2++; } if (num != -1) { this._safeBags.RemoveAt(num); this._keyBagsChanged = true; } } // Token: 0x060009DD RID: 2525 RVA: 0x0002AD84 File Offset: 0x00028F84 public void AddSecretBag(byte[] secret) { this.AddSecretBag(secret, null); } // Token: 0x060009DE RID: 2526 RVA: 0x0002AD90 File Offset: 0x00028F90 public void AddSecretBag(byte[] secret, IDictionary attributes) { bool flag = false; int num = 0; while (!flag && num < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.5")) { ASN1 asn = safeBag.ASN1[1]; byte[] value = asn.Value; if (this.Compare(secret, value)) { flag = true; } } num++; } if (!flag) { this._safeBags.Add(new SafeBag("1.2.840.113549.1.12.10.1.5", this.SecretBagSafeBag(secret, attributes))); this._secretBagsChanged = true; } } // Token: 0x060009DF RID: 2527 RVA: 0x0002AE38 File Offset: 0x00029038 public void RemoveSecretBag(byte[] secret) { int num = -1; int num2 = 0; while (num == -1 && num2 < this._safeBags.Count) { SafeBag safeBag = (SafeBag)this._safeBags[num2]; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.5")) { ASN1 asn = safeBag.ASN1[1]; byte[] value = asn.Value; if (this.Compare(secret, value)) { num = num2; } } num2++; } if (num != -1) { this._safeBags.RemoveAt(num); this._secretBagsChanged = true; } } // Token: 0x060009E0 RID: 2528 RVA: 0x0002AED0 File Offset: 0x000290D0 public AsymmetricAlgorithm GetAsymmetricAlgorithm(IDictionary attrs) { foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.1") || safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { ASN1 asn = safeBag.ASN1; if (asn.Count == 3) { ASN1 asn2 = asn[2]; int num = 0; for (int i = 0; i < asn2.Count; i++) { ASN1 asn3 = asn2[i]; ASN1 asn4 = asn3[0]; string text = ASN1Convert.ToOid(asn4); ArrayList arrayList = (ArrayList)attrs[text]; if (arrayList != null) { ASN1 asn5 = asn3[1]; if (arrayList.Count == asn5.Count) { int num2 = 0; for (int j = 0; j < asn5.Count; j++) { ASN1 asn6 = asn5[j]; byte[] array = (byte[])arrayList[j]; if (this.Compare(array, asn6.Value)) { num2++; } } if (num2 == asn5.Count) { num++; } } } } if (num == asn2.Count) { ASN1 asn7 = asn[1]; AsymmetricAlgorithm asymmetricAlgorithm = null; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.1")) { PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(asn7.Value); byte[] privateKey = privateKeyInfo.PrivateKey; byte b = privateKey[0]; if (b != 2) { if (b == 48) { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey); } } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, default(DSAParameters)); } Array.Clear(privateKey, 0, privateKey.Length); } else if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { PKCS8.EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new PKCS8.EncryptedPrivateKeyInfo(asn7.Value); byte[] array2 = this.Decrypt(encryptedPrivateKeyInfo.Algorithm, encryptedPrivateKeyInfo.Salt, encryptedPrivateKeyInfo.IterationCount, encryptedPrivateKeyInfo.EncryptedData); PKCS8.PrivateKeyInfo privateKeyInfo2 = new PKCS8.PrivateKeyInfo(array2); byte[] privateKey2 = privateKeyInfo2.PrivateKey; byte b = privateKey2[0]; if (b != 2) { if (b == 48) { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey2); } } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey2, default(DSAParameters)); } Array.Clear(privateKey2, 0, privateKey2.Length); Array.Clear(array2, 0, array2.Length); } return asymmetricAlgorithm; } } } } return null; } // Token: 0x060009E1 RID: 2529 RVA: 0x0002B1B8 File Offset: 0x000293B8 public byte[] GetSecret(IDictionary attrs) { foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.5")) { ASN1 asn = safeBag.ASN1; if (asn.Count == 3) { ASN1 asn2 = asn[2]; int num = 0; for (int i = 0; i < asn2.Count; i++) { ASN1 asn3 = asn2[i]; ASN1 asn4 = asn3[0]; string text = ASN1Convert.ToOid(asn4); ArrayList arrayList = (ArrayList)attrs[text]; if (arrayList != null) { ASN1 asn5 = asn3[1]; if (arrayList.Count == asn5.Count) { int num2 = 0; for (int j = 0; j < asn5.Count; j++) { ASN1 asn6 = asn5[j]; byte[] array = (byte[])arrayList[j]; if (this.Compare(array, asn6.Value)) { num2++; } } if (num2 == asn5.Count) { num++; } } } } if (num == asn2.Count) { ASN1 asn7 = asn[1]; return asn7.Value; } } } } return null; } // Token: 0x060009E2 RID: 2530 RVA: 0x0002B354 File Offset: 0x00029554 public X509Certificate GetCertificate(IDictionary attrs) { foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.3")) { ASN1 asn = safeBag.ASN1; if (asn.Count == 3) { ASN1 asn2 = asn[2]; int num = 0; for (int i = 0; i < asn2.Count; i++) { ASN1 asn3 = asn2[i]; ASN1 asn4 = asn3[0]; string text = ASN1Convert.ToOid(asn4); ArrayList arrayList = (ArrayList)attrs[text]; if (arrayList != null) { ASN1 asn5 = asn3[1]; if (arrayList.Count == asn5.Count) { int num2 = 0; for (int j = 0; j < asn5.Count; j++) { ASN1 asn6 = asn5[j]; byte[] array = (byte[])arrayList[j]; if (this.Compare(array, asn6.Value)) { num2++; } } if (num2 == asn5.Count) { num++; } } } } if (num == asn2.Count) { ASN1 asn7 = asn[1]; PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn7.Value); return new X509Certificate(contentInfo.Content[0].Value); } } } } return null; } // Token: 0x060009E3 RID: 2531 RVA: 0x0002B50C File Offset: 0x0002970C public IDictionary GetAttributes(AsymmetricAlgorithm aa) { IDictionary dictionary = new Hashtable(); foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.1") || safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { ASN1 asn = safeBag.ASN1; ASN1 asn2 = asn[1]; AsymmetricAlgorithm asymmetricAlgorithm = null; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.1")) { PKCS8.PrivateKeyInfo privateKeyInfo = new PKCS8.PrivateKeyInfo(asn2.Value); byte[] privateKey = privateKeyInfo.PrivateKey; byte b = privateKey[0]; if (b != 2) { if (b == 48) { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey); } } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey, default(DSAParameters)); } Array.Clear(privateKey, 0, privateKey.Length); } else if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.2")) { PKCS8.EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new PKCS8.EncryptedPrivateKeyInfo(asn2.Value); byte[] array = this.Decrypt(encryptedPrivateKeyInfo.Algorithm, encryptedPrivateKeyInfo.Salt, encryptedPrivateKeyInfo.IterationCount, encryptedPrivateKeyInfo.EncryptedData); PKCS8.PrivateKeyInfo privateKeyInfo2 = new PKCS8.PrivateKeyInfo(array); byte[] privateKey2 = privateKeyInfo2.PrivateKey; byte b = privateKey2[0]; if (b != 2) { if (b == 48) { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeRSA(privateKey2); } } else { asymmetricAlgorithm = PKCS8.PrivateKeyInfo.DecodeDSA(privateKey2, default(DSAParameters)); } Array.Clear(privateKey2, 0, privateKey2.Length); Array.Clear(array, 0, array.Length); } if (asymmetricAlgorithm != null && this.CompareAsymmetricAlgorithm(asymmetricAlgorithm, aa) && asn.Count == 3) { ASN1 asn3 = asn[2]; for (int i = 0; i < asn3.Count; i++) { ASN1 asn4 = asn3[i]; ASN1 asn5 = asn4[0]; string text = ASN1Convert.ToOid(asn5); ArrayList arrayList = new ArrayList(); ASN1 asn6 = asn4[1]; for (int j = 0; j < asn6.Count; j++) { ASN1 asn7 = asn6[j]; arrayList.Add(asn7.Value); } dictionary.Add(text, arrayList); } } } } return dictionary; } // Token: 0x060009E4 RID: 2532 RVA: 0x0002B7AC File Offset: 0x000299AC public IDictionary GetAttributes(X509Certificate cert) { IDictionary dictionary = new Hashtable(); foreach (object obj in this._safeBags) { SafeBag safeBag = (SafeBag)obj; if (safeBag.BagOID.Equals("1.2.840.113549.1.12.10.1.3")) { ASN1 asn = safeBag.ASN1; ASN1 asn2 = asn[1]; PKCS7.ContentInfo contentInfo = new PKCS7.ContentInfo(asn2.Value); X509Certificate x509Certificate = new X509Certificate(contentInfo.Content[0].Value); if (this.Compare(cert.RawData, x509Certificate.RawData) && asn.Count == 3) { ASN1 asn3 = asn[2]; for (int i = 0; i < asn3.Count; i++) { ASN1 asn4 = asn3[i]; ASN1 asn5 = asn4[0]; string text = ASN1Convert.ToOid(asn5); ArrayList arrayList = new ArrayList(); ASN1 asn6 = asn4[1]; for (int j = 0; j < asn6.Count; j++) { ASN1 asn7 = asn6[j]; arrayList.Add(asn7.Value); } dictionary.Add(text, arrayList); } } } } return dictionary; } // Token: 0x060009E5 RID: 2533 RVA: 0x0002B924 File Offset: 0x00029B24 public void SaveToFile(string filename) { if (filename == null) { throw new ArgumentNullException("filename"); } using (FileStream fileStream = File.Create(filename)) { byte[] bytes = this.GetBytes(); fileStream.Write(bytes, 0, bytes.Length); } } // Token: 0x060009E6 RID: 2534 RVA: 0x0002B98C File Offset: 0x00029B8C public object Clone() { PKCS12 pkcs; if (this._password != null) { pkcs = new PKCS12(this.GetBytes(), Encoding.BigEndianUnicode.GetString(this._password)); } else { pkcs = new PKCS12(this.GetBytes()); } pkcs.IterationCount = this.IterationCount; return pkcs; } // Token: 0x17000125 RID: 293 // (get) Token: 0x060009E7 RID: 2535 RVA: 0x0002B9E0 File Offset: 0x00029BE0 // (set) Token: 0x060009E8 RID: 2536 RVA: 0x0002B9E8 File Offset: 0x00029BE8 public static int MaximumPasswordLength { get { return PKCS12.password_max_length; } set { if (value < 32) { string text = Locale.GetText("Maximum password length cannot be less than {0}.", new object[] { 32 }); throw new ArgumentOutOfRangeException(text); } PKCS12.password_max_length = value; } } // Token: 0x060009E9 RID: 2537 RVA: 0x0002BA28 File Offset: 0x00029C28 private static byte[] LoadFile(string filename) { byte[] array = null; using (FileStream fileStream = File.OpenRead(filename)) { array = new byte[fileStream.Length]; fileStream.Read(array, 0, array.Length); fileStream.Close(); } return array; } // Token: 0x060009EA RID: 2538 RVA: 0x0002BA8C File Offset: 0x00029C8C public static PKCS12 LoadFromFile(string filename) { if (filename == null) { throw new ArgumentNullException("filename"); } return new PKCS12(PKCS12.LoadFile(filename)); } // Token: 0x060009EB RID: 2539 RVA: 0x0002BAAC File Offset: 0x00029CAC public static PKCS12 LoadFromFile(string filename, string password) { if (filename == null) { throw new ArgumentNullException("filename"); } return new PKCS12(PKCS12.LoadFile(filename), password); } // Token: 0x04000244 RID: 580 public const string pbeWithSHAAnd128BitRC4 = "1.2.840.113549.1.12.1.1"; // Token: 0x04000245 RID: 581 public const string pbeWithSHAAnd40BitRC4 = "1.2.840.113549.1.12.1.2"; // Token: 0x04000246 RID: 582 public const string pbeWithSHAAnd3KeyTripleDESCBC = "1.2.840.113549.1.12.1.3"; // Token: 0x04000247 RID: 583 public const string pbeWithSHAAnd2KeyTripleDESCBC = "1.2.840.113549.1.12.1.4"; // Token: 0x04000248 RID: 584 public const string pbeWithSHAAnd128BitRC2CBC = "1.2.840.113549.1.12.1.5"; // Token: 0x04000249 RID: 585 public const string pbeWithSHAAnd40BitRC2CBC = "1.2.840.113549.1.12.1.6"; // Token: 0x0400024A RID: 586 public const string keyBag = "1.2.840.113549.1.12.10.1.1"; // Token: 0x0400024B RID: 587 public const string pkcs8ShroudedKeyBag = "1.2.840.113549.1.12.10.1.2"; // Token: 0x0400024C RID: 588 public const string certBag = "1.2.840.113549.1.12.10.1.3"; // Token: 0x0400024D RID: 589 public const string crlBag = "1.2.840.113549.1.12.10.1.4"; // Token: 0x0400024E RID: 590 public const string secretBag = "1.2.840.113549.1.12.10.1.5"; // Token: 0x0400024F RID: 591 public const string safeContentsBag = "1.2.840.113549.1.12.10.1.6"; // Token: 0x04000250 RID: 592 public const string x509Certificate = "1.2.840.113549.1.9.22.1"; // Token: 0x04000251 RID: 593 public const string sdsiCertificate = "1.2.840.113549.1.9.22.2"; // Token: 0x04000252 RID: 594 public const string x509Crl = "1.2.840.113549.1.9.23.1"; // Token: 0x04000253 RID: 595 public const int CryptoApiPasswordLimit = 32; // Token: 0x04000254 RID: 596 private static int recommendedIterationCount = 2000; // Token: 0x04000255 RID: 597 private byte[] _password; // Token: 0x04000256 RID: 598 private ArrayList _keyBags; // Token: 0x04000257 RID: 599 private ArrayList _secretBags; // Token: 0x04000258 RID: 600 private X509CertificateCollection _certs; // Token: 0x04000259 RID: 601 private bool _keyBagsChanged; // Token: 0x0400025A RID: 602 private bool _secretBagsChanged; // Token: 0x0400025B RID: 603 private bool _certsChanged; // Token: 0x0400025C RID: 604 private int _iterations; // Token: 0x0400025D RID: 605 private ArrayList _safeBags; // Token: 0x0400025E RID: 606 private RandomNumberGenerator _rng; // Token: 0x0400025F RID: 607 private static int password_max_length = int.MaxValue; // Token: 0x020000B7 RID: 183 public class DeriveBytes { // Token: 0x17000126 RID: 294 // (get) Token: 0x060009EE RID: 2542 RVA: 0x0002BB28 File Offset: 0x00029D28 // (set) Token: 0x060009EF RID: 2543 RVA: 0x0002BB30 File Offset: 0x00029D30 public string HashName { get { return this._hashName; } set { this._hashName = value; } } // Token: 0x17000127 RID: 295 // (get) Token: 0x060009F0 RID: 2544 RVA: 0x0002BB3C File Offset: 0x00029D3C // (set) Token: 0x060009F1 RID: 2545 RVA: 0x0002BB44 File Offset: 0x00029D44 public int IterationCount { get { return this._iterations; } set { this._iterations = value; } } // Token: 0x17000128 RID: 296 // (get) Token: 0x060009F2 RID: 2546 RVA: 0x0002BB50 File Offset: 0x00029D50 // (set) Token: 0x060009F3 RID: 2547 RVA: 0x0002BB64 File Offset: 0x00029D64 public byte[] Password { get { return (byte[])this._password.Clone(); } set { if (value == null) { this._password = new byte[0]; } else { this._password = (byte[])value.Clone(); } } } // Token: 0x17000129 RID: 297 // (get) Token: 0x060009F4 RID: 2548 RVA: 0x0002BB9C File Offset: 0x00029D9C // (set) Token: 0x060009F5 RID: 2549 RVA: 0x0002BBB0 File Offset: 0x00029DB0 public byte[] Salt { get { return (byte[])this._salt.Clone(); } set { if (value != null) { this._salt = (byte[])value.Clone(); } else { this._salt = null; } } } // Token: 0x060009F6 RID: 2550 RVA: 0x0002BBD8 File Offset: 0x00029DD8 private void Adjust(byte[] a, int aOff, byte[] b) { int num = (int)((b[b.Length - 1] & byte.MaxValue) + (a[aOff + b.Length - 1] & byte.MaxValue) + 1); a[aOff + b.Length - 1] = (byte)num; num >>= 8; for (int i = b.Length - 2; i >= 0; i--) { num += (int)((b[i] & byte.MaxValue) + (a[aOff + i] & byte.MaxValue)); a[aOff + i] = (byte)num; num >>= 8; } } // Token: 0x060009F7 RID: 2551 RVA: 0x0002BC50 File Offset: 0x00029E50 private byte[] Derive(byte[] diversifier, int n) { HashAlgorithm hashAlgorithm = HashAlgorithm.Create(this._hashName); int num = hashAlgorithm.HashSize >> 3; int num2 = 64; byte[] array = new byte[n]; byte[] array2; if (this._salt != null && this._salt.Length != 0) { array2 = new byte[num2 * ((this._salt.Length + num2 - 1) / num2)]; for (int num3 = 0; num3 != array2.Length; num3++) { array2[num3] = this._salt[num3 % this._salt.Length]; } } else { array2 = new byte[0]; } byte[] array3; if (this._password != null && this._password.Length != 0) { array3 = new byte[num2 * ((this._password.Length + num2 - 1) / num2)]; for (int num4 = 0; num4 != array3.Length; num4++) { array3[num4] = this._password[num4 % this._password.Length]; } } else { array3 = new byte[0]; } byte[] array4 = new byte[array2.Length + array3.Length]; Buffer.BlockCopy(array2, 0, array4, 0, array2.Length); Buffer.BlockCopy(array3, 0, array4, array2.Length, array3.Length); byte[] array5 = new byte[num2]; int num5 = (n + num - 1) / num; for (int i = 1; i <= num5; i++) { hashAlgorithm.TransformBlock(diversifier, 0, diversifier.Length, diversifier, 0); hashAlgorithm.TransformFinalBlock(array4, 0, array4.Length); byte[] array6 = hashAlgorithm.Hash; hashAlgorithm.Initialize(); for (int num6 = 1; num6 != this._iterations; num6++) { array6 = hashAlgorithm.ComputeHash(array6, 0, array6.Length); } for (int num7 = 0; num7 != array5.Length; num7++) { array5[num7] = array6[num7 % array6.Length]; } for (int num8 = 0; num8 != array4.Length / num2; num8++) { this.Adjust(array4, num8 * num2, array5); } if (i == num5) { Buffer.BlockCopy(array6, 0, array, (i - 1) * num, array.Length - (i - 1) * num); } else { Buffer.BlockCopy(array6, 0, array, (i - 1) * num, array6.Length); } } return array; } // Token: 0x060009F8 RID: 2552 RVA: 0x0002BE90 File Offset: 0x0002A090 public byte[] DeriveKey(int size) { return this.Derive(PKCS12.DeriveBytes.keyDiversifier, size); } // Token: 0x060009F9 RID: 2553 RVA: 0x0002BEA0 File Offset: 0x0002A0A0 public byte[] DeriveIV(int size) { return this.Derive(PKCS12.DeriveBytes.ivDiversifier, size); } // Token: 0x060009FA RID: 2554 RVA: 0x0002BEB0 File Offset: 0x0002A0B0 public byte[] DeriveMAC(int size) { return this.Derive(PKCS12.DeriveBytes.macDiversifier, size); } // Token: 0x04000268 RID: 616 private static byte[] keyDiversifier = new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; // Token: 0x04000269 RID: 617 private static byte[] ivDiversifier = new byte[] { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }; // Token: 0x0400026A RID: 618 private static byte[] macDiversifier = new byte[] { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; // Token: 0x0400026B RID: 619 private string _hashName; // Token: 0x0400026C RID: 620 private int _iterations; // Token: 0x0400026D RID: 621 private byte[] _password; // Token: 0x0400026E RID: 622 private byte[] _salt; // Token: 0x020000B8 RID: 184 public enum Purpose { // Token: 0x04000270 RID: 624 Key, // Token: 0x04000271 RID: 625 IV, // Token: 0x04000272 RID: 626 MAC } } } }