niko
1268 lines
30 KiB
C#
1268 lines
30 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Security.Cryptography;
|
|
using Mono.Security.X509;
|
|
|
|
namespace Mono.Security
|
|
{
|
|
// Token: 0x020000DD RID: 221
|
|
internal sealed class PKCS7
|
|
{
|
|
// Token: 0x06000B10 RID: 2832 RVA: 0x00030E6C File Offset: 0x0002F06C
|
|
private PKCS7()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B11 RID: 2833 RVA: 0x00030E74 File Offset: 0x0002F074
|
|
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: 0x06000B12 RID: 2834 RVA: 0x00030EB0 File Offset: 0x0002F0B0
|
|
public static ASN1 AlgorithmIdentifier(string oid)
|
|
{
|
|
ASN1 asn = new ASN1(48);
|
|
asn.Add(ASN1Convert.FromOid(oid));
|
|
asn.Add(new ASN1(5));
|
|
return asn;
|
|
}
|
|
|
|
// Token: 0x06000B13 RID: 2835 RVA: 0x00030EE0 File Offset: 0x0002F0E0
|
|
public static ASN1 AlgorithmIdentifier(string oid, ASN1 parameters)
|
|
{
|
|
ASN1 asn = new ASN1(48);
|
|
asn.Add(ASN1Convert.FromOid(oid));
|
|
asn.Add(parameters);
|
|
return asn;
|
|
}
|
|
|
|
// Token: 0x06000B14 RID: 2836 RVA: 0x00030F0C File Offset: 0x0002F10C
|
|
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: 0x020000DE RID: 222
|
|
public class Oid
|
|
{
|
|
// Token: 0x040002D7 RID: 727
|
|
public const string rsaEncryption = "1.2.840.113549.1.1.1";
|
|
|
|
// Token: 0x040002D8 RID: 728
|
|
public const string data = "1.2.840.113549.1.7.1";
|
|
|
|
// Token: 0x040002D9 RID: 729
|
|
public const string signedData = "1.2.840.113549.1.7.2";
|
|
|
|
// Token: 0x040002DA RID: 730
|
|
public const string envelopedData = "1.2.840.113549.1.7.3";
|
|
|
|
// Token: 0x040002DB RID: 731
|
|
public const string signedAndEnvelopedData = "1.2.840.113549.1.7.4";
|
|
|
|
// Token: 0x040002DC RID: 732
|
|
public const string digestedData = "1.2.840.113549.1.7.5";
|
|
|
|
// Token: 0x040002DD RID: 733
|
|
public const string encryptedData = "1.2.840.113549.1.7.6";
|
|
|
|
// Token: 0x040002DE RID: 734
|
|
public const string contentType = "1.2.840.113549.1.9.3";
|
|
|
|
// Token: 0x040002DF RID: 735
|
|
public const string messageDigest = "1.2.840.113549.1.9.4";
|
|
|
|
// Token: 0x040002E0 RID: 736
|
|
public const string signingTime = "1.2.840.113549.1.9.5";
|
|
|
|
// Token: 0x040002E1 RID: 737
|
|
public const string countersignature = "1.2.840.113549.1.9.6";
|
|
}
|
|
|
|
// Token: 0x020000DF RID: 223
|
|
public class ContentInfo
|
|
{
|
|
// Token: 0x06000B16 RID: 2838 RVA: 0x00030FB4 File Offset: 0x0002F1B4
|
|
public ContentInfo()
|
|
{
|
|
this.content = new ASN1(160);
|
|
}
|
|
|
|
// Token: 0x06000B17 RID: 2839 RVA: 0x00030FCC File Offset: 0x0002F1CC
|
|
public ContentInfo(string oid)
|
|
: this()
|
|
{
|
|
this.contentType = oid;
|
|
}
|
|
|
|
// Token: 0x06000B18 RID: 2840 RVA: 0x00030FDC File Offset: 0x0002F1DC
|
|
public ContentInfo(byte[] data)
|
|
: this(new ASN1(data))
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B19 RID: 2841 RVA: 0x00030FEC File Offset: 0x0002F1EC
|
|
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: 0x17000173 RID: 371
|
|
// (get) Token: 0x06000B1A RID: 2842 RVA: 0x00031098 File Offset: 0x0002F298
|
|
public ASN1 ASN1
|
|
{
|
|
get
|
|
{
|
|
return this.GetASN1();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000174 RID: 372
|
|
// (get) Token: 0x06000B1B RID: 2843 RVA: 0x000310A0 File Offset: 0x0002F2A0
|
|
// (set) Token: 0x06000B1C RID: 2844 RVA: 0x000310A8 File Offset: 0x0002F2A8
|
|
public ASN1 Content
|
|
{
|
|
get
|
|
{
|
|
return this.content;
|
|
}
|
|
set
|
|
{
|
|
this.content = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000175 RID: 373
|
|
// (get) Token: 0x06000B1D RID: 2845 RVA: 0x000310B4 File Offset: 0x0002F2B4
|
|
// (set) Token: 0x06000B1E RID: 2846 RVA: 0x000310BC File Offset: 0x0002F2BC
|
|
public string ContentType
|
|
{
|
|
get
|
|
{
|
|
return this.contentType;
|
|
}
|
|
set
|
|
{
|
|
this.contentType = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B1F RID: 2847 RVA: 0x000310C8 File Offset: 0x0002F2C8
|
|
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: 0x06000B20 RID: 2848 RVA: 0x0003111C File Offset: 0x0002F31C
|
|
public byte[] GetBytes()
|
|
{
|
|
return this.GetASN1().GetBytes();
|
|
}
|
|
|
|
// Token: 0x040002E2 RID: 738
|
|
private string contentType;
|
|
|
|
// Token: 0x040002E3 RID: 739
|
|
private ASN1 content;
|
|
}
|
|
|
|
// Token: 0x020000E0 RID: 224
|
|
public class EncryptedData
|
|
{
|
|
// Token: 0x06000B21 RID: 2849 RVA: 0x0003112C File Offset: 0x0002F32C
|
|
public EncryptedData()
|
|
{
|
|
this._version = 0;
|
|
}
|
|
|
|
// Token: 0x06000B22 RID: 2850 RVA: 0x0003113C File Offset: 0x0002F33C
|
|
public EncryptedData(byte[] data)
|
|
: this(new ASN1(data))
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B23 RID: 2851 RVA: 0x0003114C File Offset: 0x0002F34C
|
|
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: 0x17000176 RID: 374
|
|
// (get) Token: 0x06000B24 RID: 2852 RVA: 0x0003127C File Offset: 0x0002F47C
|
|
public ASN1 ASN1
|
|
{
|
|
get
|
|
{
|
|
return this.GetASN1();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000177 RID: 375
|
|
// (get) Token: 0x06000B25 RID: 2853 RVA: 0x00031284 File Offset: 0x0002F484
|
|
public PKCS7.ContentInfo ContentInfo
|
|
{
|
|
get
|
|
{
|
|
return this._content;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000178 RID: 376
|
|
// (get) Token: 0x06000B26 RID: 2854 RVA: 0x0003128C File Offset: 0x0002F48C
|
|
public PKCS7.ContentInfo EncryptionAlgorithm
|
|
{
|
|
get
|
|
{
|
|
return this._encryptionAlgorithm;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000179 RID: 377
|
|
// (get) Token: 0x06000B27 RID: 2855 RVA: 0x00031294 File Offset: 0x0002F494
|
|
public byte[] EncryptedContent
|
|
{
|
|
get
|
|
{
|
|
if (this._encrypted == null)
|
|
{
|
|
return null;
|
|
}
|
|
return (byte[])this._encrypted.Clone();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700017A RID: 378
|
|
// (get) Token: 0x06000B28 RID: 2856 RVA: 0x000312B4 File Offset: 0x0002F4B4
|
|
// (set) Token: 0x06000B29 RID: 2857 RVA: 0x000312BC File Offset: 0x0002F4BC
|
|
public byte Version
|
|
{
|
|
get
|
|
{
|
|
return this._version;
|
|
}
|
|
set
|
|
{
|
|
this._version = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B2A RID: 2858 RVA: 0x000312C8 File Offset: 0x0002F4C8
|
|
internal ASN1 GetASN1()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000B2B RID: 2859 RVA: 0x000312CC File Offset: 0x0002F4CC
|
|
public byte[] GetBytes()
|
|
{
|
|
return this.GetASN1().GetBytes();
|
|
}
|
|
|
|
// Token: 0x040002E4 RID: 740
|
|
private byte _version;
|
|
|
|
// Token: 0x040002E5 RID: 741
|
|
private PKCS7.ContentInfo _content;
|
|
|
|
// Token: 0x040002E6 RID: 742
|
|
private PKCS7.ContentInfo _encryptionAlgorithm;
|
|
|
|
// Token: 0x040002E7 RID: 743
|
|
private byte[] _encrypted;
|
|
}
|
|
|
|
// Token: 0x020000E1 RID: 225
|
|
public class EnvelopedData
|
|
{
|
|
// Token: 0x06000B2C RID: 2860 RVA: 0x000312DC File Offset: 0x0002F4DC
|
|
public EnvelopedData()
|
|
{
|
|
this._version = 0;
|
|
this._content = new PKCS7.ContentInfo();
|
|
this._encryptionAlgorithm = new PKCS7.ContentInfo();
|
|
this._recipientInfos = new ArrayList();
|
|
}
|
|
|
|
// Token: 0x06000B2D RID: 2861 RVA: 0x00031318 File Offset: 0x0002F518
|
|
public EnvelopedData(byte[] data)
|
|
: this(new ASN1(data))
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B2E RID: 2862 RVA: 0x00031328 File Offset: 0x0002F528
|
|
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: 0x1700017B RID: 379
|
|
// (get) Token: 0x06000B2F RID: 2863 RVA: 0x000314D8 File Offset: 0x0002F6D8
|
|
public ArrayList RecipientInfos
|
|
{
|
|
get
|
|
{
|
|
return this._recipientInfos;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700017C RID: 380
|
|
// (get) Token: 0x06000B30 RID: 2864 RVA: 0x000314E0 File Offset: 0x0002F6E0
|
|
public ASN1 ASN1
|
|
{
|
|
get
|
|
{
|
|
return this.GetASN1();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700017D RID: 381
|
|
// (get) Token: 0x06000B31 RID: 2865 RVA: 0x000314E8 File Offset: 0x0002F6E8
|
|
public PKCS7.ContentInfo ContentInfo
|
|
{
|
|
get
|
|
{
|
|
return this._content;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700017E RID: 382
|
|
// (get) Token: 0x06000B32 RID: 2866 RVA: 0x000314F0 File Offset: 0x0002F6F0
|
|
public PKCS7.ContentInfo EncryptionAlgorithm
|
|
{
|
|
get
|
|
{
|
|
return this._encryptionAlgorithm;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700017F RID: 383
|
|
// (get) Token: 0x06000B33 RID: 2867 RVA: 0x000314F8 File Offset: 0x0002F6F8
|
|
public byte[] EncryptedContent
|
|
{
|
|
get
|
|
{
|
|
if (this._encrypted == null)
|
|
{
|
|
return null;
|
|
}
|
|
return (byte[])this._encrypted.Clone();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000180 RID: 384
|
|
// (get) Token: 0x06000B34 RID: 2868 RVA: 0x00031518 File Offset: 0x0002F718
|
|
// (set) Token: 0x06000B35 RID: 2869 RVA: 0x00031520 File Offset: 0x0002F720
|
|
public byte Version
|
|
{
|
|
get
|
|
{
|
|
return this._version;
|
|
}
|
|
set
|
|
{
|
|
this._version = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B36 RID: 2870 RVA: 0x0003152C File Offset: 0x0002F72C
|
|
internal ASN1 GetASN1()
|
|
{
|
|
return new ASN1(48);
|
|
}
|
|
|
|
// Token: 0x06000B37 RID: 2871 RVA: 0x00031544 File Offset: 0x0002F744
|
|
public byte[] GetBytes()
|
|
{
|
|
return this.GetASN1().GetBytes();
|
|
}
|
|
|
|
// Token: 0x040002E8 RID: 744
|
|
private byte _version;
|
|
|
|
// Token: 0x040002E9 RID: 745
|
|
private PKCS7.ContentInfo _content;
|
|
|
|
// Token: 0x040002EA RID: 746
|
|
private PKCS7.ContentInfo _encryptionAlgorithm;
|
|
|
|
// Token: 0x040002EB RID: 747
|
|
private ArrayList _recipientInfos;
|
|
|
|
// Token: 0x040002EC RID: 748
|
|
private byte[] _encrypted;
|
|
}
|
|
|
|
// Token: 0x020000E2 RID: 226
|
|
public class RecipientInfo
|
|
{
|
|
// Token: 0x06000B38 RID: 2872 RVA: 0x00031554 File Offset: 0x0002F754
|
|
public RecipientInfo()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B39 RID: 2873 RVA: 0x0003155C File Offset: 0x0002F75C
|
|
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: 0x17000181 RID: 385
|
|
// (get) Token: 0x06000B3A RID: 2874 RVA: 0x0003163C File Offset: 0x0002F83C
|
|
public string Oid
|
|
{
|
|
get
|
|
{
|
|
return this._oid;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000182 RID: 386
|
|
// (get) Token: 0x06000B3B RID: 2875 RVA: 0x00031644 File Offset: 0x0002F844
|
|
public byte[] Key
|
|
{
|
|
get
|
|
{
|
|
if (this._key == null)
|
|
{
|
|
return null;
|
|
}
|
|
return (byte[])this._key.Clone();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000183 RID: 387
|
|
// (get) Token: 0x06000B3C RID: 2876 RVA: 0x00031664 File Offset: 0x0002F864
|
|
public byte[] SubjectKeyIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (this._ski == null)
|
|
{
|
|
return null;
|
|
}
|
|
return (byte[])this._ski.Clone();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000184 RID: 388
|
|
// (get) Token: 0x06000B3D RID: 2877 RVA: 0x00031684 File Offset: 0x0002F884
|
|
public string Issuer
|
|
{
|
|
get
|
|
{
|
|
return this._issuer;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000185 RID: 389
|
|
// (get) Token: 0x06000B3E RID: 2878 RVA: 0x0003168C File Offset: 0x0002F88C
|
|
public byte[] Serial
|
|
{
|
|
get
|
|
{
|
|
if (this._serial == null)
|
|
{
|
|
return null;
|
|
}
|
|
return (byte[])this._serial.Clone();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000186 RID: 390
|
|
// (get) Token: 0x06000B3F RID: 2879 RVA: 0x000316AC File Offset: 0x0002F8AC
|
|
public int Version
|
|
{
|
|
get
|
|
{
|
|
return this._version;
|
|
}
|
|
}
|
|
|
|
// Token: 0x040002ED RID: 749
|
|
private int _version;
|
|
|
|
// Token: 0x040002EE RID: 750
|
|
private string _oid;
|
|
|
|
// Token: 0x040002EF RID: 751
|
|
private byte[] _key;
|
|
|
|
// Token: 0x040002F0 RID: 752
|
|
private byte[] _ski;
|
|
|
|
// Token: 0x040002F1 RID: 753
|
|
private string _issuer;
|
|
|
|
// Token: 0x040002F2 RID: 754
|
|
private byte[] _serial;
|
|
}
|
|
|
|
// Token: 0x020000E3 RID: 227
|
|
public class SignedData
|
|
{
|
|
// Token: 0x06000B40 RID: 2880 RVA: 0x000316B4 File Offset: 0x0002F8B4
|
|
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: 0x06000B41 RID: 2881 RVA: 0x00031708 File Offset: 0x0002F908
|
|
public SignedData(byte[] data)
|
|
: this(new ASN1(data))
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B42 RID: 2882 RVA: 0x00031718 File Offset: 0x0002F918
|
|
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: 0x17000187 RID: 391
|
|
// (get) Token: 0x06000B43 RID: 2883 RVA: 0x0003191C File Offset: 0x0002FB1C
|
|
public ASN1 ASN1
|
|
{
|
|
get
|
|
{
|
|
return this.GetASN1();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000188 RID: 392
|
|
// (get) Token: 0x06000B44 RID: 2884 RVA: 0x00031924 File Offset: 0x0002FB24
|
|
public X509CertificateCollection Certificates
|
|
{
|
|
get
|
|
{
|
|
return this.certs;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000189 RID: 393
|
|
// (get) Token: 0x06000B45 RID: 2885 RVA: 0x0003192C File Offset: 0x0002FB2C
|
|
public PKCS7.ContentInfo ContentInfo
|
|
{
|
|
get
|
|
{
|
|
return this.contentInfo;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700018A RID: 394
|
|
// (get) Token: 0x06000B46 RID: 2886 RVA: 0x00031934 File Offset: 0x0002FB34
|
|
public ArrayList Crls
|
|
{
|
|
get
|
|
{
|
|
return this.crls;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700018B RID: 395
|
|
// (get) Token: 0x06000B47 RID: 2887 RVA: 0x0003193C File Offset: 0x0002FB3C
|
|
// (set) Token: 0x06000B48 RID: 2888 RVA: 0x00031944 File Offset: 0x0002FB44
|
|
public string HashName
|
|
{
|
|
get
|
|
{
|
|
return this.hashAlgorithm;
|
|
}
|
|
set
|
|
{
|
|
this.hashAlgorithm = value;
|
|
this.signerInfo.HashName = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700018C RID: 396
|
|
// (get) Token: 0x06000B49 RID: 2889 RVA: 0x0003195C File Offset: 0x0002FB5C
|
|
public PKCS7.SignerInfo SignerInfo
|
|
{
|
|
get
|
|
{
|
|
return this.signerInfo;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700018D RID: 397
|
|
// (get) Token: 0x06000B4A RID: 2890 RVA: 0x00031964 File Offset: 0x0002FB64
|
|
// (set) Token: 0x06000B4B RID: 2891 RVA: 0x0003196C File Offset: 0x0002FB6C
|
|
public byte Version
|
|
{
|
|
get
|
|
{
|
|
return this.version;
|
|
}
|
|
set
|
|
{
|
|
this.version = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700018E RID: 398
|
|
// (get) Token: 0x06000B4C RID: 2892 RVA: 0x00031978 File Offset: 0x0002FB78
|
|
// (set) Token: 0x06000B4D RID: 2893 RVA: 0x00031980 File Offset: 0x0002FB80
|
|
public bool UseAuthenticatedAttributes
|
|
{
|
|
get
|
|
{
|
|
return this.mda;
|
|
}
|
|
set
|
|
{
|
|
this.mda = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B4E RID: 2894 RVA: 0x0003198C File Offset: 0x0002FB8C
|
|
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: 0x06000B4F RID: 2895 RVA: 0x00031A9C File Offset: 0x0002FC9C
|
|
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: 0x06000B50 RID: 2896 RVA: 0x00031B70 File Offset: 0x0002FD70
|
|
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: 0x06000B51 RID: 2897 RVA: 0x00031E54 File Offset: 0x00030054
|
|
public byte[] GetBytes()
|
|
{
|
|
return this.GetASN1().GetBytes();
|
|
}
|
|
|
|
// Token: 0x040002F3 RID: 755
|
|
private byte version;
|
|
|
|
// Token: 0x040002F4 RID: 756
|
|
private string hashAlgorithm;
|
|
|
|
// Token: 0x040002F5 RID: 757
|
|
private PKCS7.ContentInfo contentInfo;
|
|
|
|
// Token: 0x040002F6 RID: 758
|
|
private X509CertificateCollection certs;
|
|
|
|
// Token: 0x040002F7 RID: 759
|
|
private ArrayList crls;
|
|
|
|
// Token: 0x040002F8 RID: 760
|
|
private PKCS7.SignerInfo signerInfo;
|
|
|
|
// Token: 0x040002F9 RID: 761
|
|
private bool mda;
|
|
|
|
// Token: 0x040002FA RID: 762
|
|
private bool signed;
|
|
}
|
|
|
|
// Token: 0x020000E4 RID: 228
|
|
public class SignerInfo
|
|
{
|
|
// Token: 0x06000B52 RID: 2898 RVA: 0x00031E64 File Offset: 0x00030064
|
|
public SignerInfo()
|
|
{
|
|
this.version = 1;
|
|
this.authenticatedAttributes = new ArrayList();
|
|
this.unauthenticatedAttributes = new ArrayList();
|
|
}
|
|
|
|
// Token: 0x06000B53 RID: 2899 RVA: 0x00031E8C File Offset: 0x0003008C
|
|
public SignerInfo(byte[] data)
|
|
: this(new ASN1(data))
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B54 RID: 2900 RVA: 0x00031E9C File Offset: 0x0003009C
|
|
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: 0x1700018F RID: 399
|
|
// (get) Token: 0x06000B55 RID: 2901 RVA: 0x00032078 File Offset: 0x00030278
|
|
public string IssuerName
|
|
{
|
|
get
|
|
{
|
|
return this.issuer;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000190 RID: 400
|
|
// (get) Token: 0x06000B56 RID: 2902 RVA: 0x00032080 File Offset: 0x00030280
|
|
public byte[] SerialNumber
|
|
{
|
|
get
|
|
{
|
|
if (this.serial == null)
|
|
{
|
|
return null;
|
|
}
|
|
return (byte[])this.serial.Clone();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000191 RID: 401
|
|
// (get) Token: 0x06000B57 RID: 2903 RVA: 0x000320A0 File Offset: 0x000302A0
|
|
public byte[] SubjectKeyIdentifier
|
|
{
|
|
get
|
|
{
|
|
if (this.ski == null)
|
|
{
|
|
return null;
|
|
}
|
|
return (byte[])this.ski.Clone();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000192 RID: 402
|
|
// (get) Token: 0x06000B58 RID: 2904 RVA: 0x000320C0 File Offset: 0x000302C0
|
|
public ASN1 ASN1
|
|
{
|
|
get
|
|
{
|
|
return this.GetASN1();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000193 RID: 403
|
|
// (get) Token: 0x06000B59 RID: 2905 RVA: 0x000320C8 File Offset: 0x000302C8
|
|
public ArrayList AuthenticatedAttributes
|
|
{
|
|
get
|
|
{
|
|
return this.authenticatedAttributes;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000194 RID: 404
|
|
// (get) Token: 0x06000B5A RID: 2906 RVA: 0x000320D0 File Offset: 0x000302D0
|
|
// (set) Token: 0x06000B5B RID: 2907 RVA: 0x000320D8 File Offset: 0x000302D8
|
|
public X509Certificate Certificate
|
|
{
|
|
get
|
|
{
|
|
return this.x509;
|
|
}
|
|
set
|
|
{
|
|
this.x509 = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000195 RID: 405
|
|
// (get) Token: 0x06000B5C RID: 2908 RVA: 0x000320E4 File Offset: 0x000302E4
|
|
// (set) Token: 0x06000B5D RID: 2909 RVA: 0x000320EC File Offset: 0x000302EC
|
|
public string HashName
|
|
{
|
|
get
|
|
{
|
|
return this.hashAlgorithm;
|
|
}
|
|
set
|
|
{
|
|
this.hashAlgorithm = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000196 RID: 406
|
|
// (get) Token: 0x06000B5E RID: 2910 RVA: 0x000320F8 File Offset: 0x000302F8
|
|
// (set) Token: 0x06000B5F RID: 2911 RVA: 0x00032100 File Offset: 0x00030300
|
|
public AsymmetricAlgorithm Key
|
|
{
|
|
get
|
|
{
|
|
return this.key;
|
|
}
|
|
set
|
|
{
|
|
this.key = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000197 RID: 407
|
|
// (get) Token: 0x06000B60 RID: 2912 RVA: 0x0003210C File Offset: 0x0003030C
|
|
// (set) Token: 0x06000B61 RID: 2913 RVA: 0x0003212C File Offset: 0x0003032C
|
|
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: 0x17000198 RID: 408
|
|
// (get) Token: 0x06000B62 RID: 2914 RVA: 0x00032148 File Offset: 0x00030348
|
|
public ArrayList UnauthenticatedAttributes
|
|
{
|
|
get
|
|
{
|
|
return this.unauthenticatedAttributes;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000199 RID: 409
|
|
// (get) Token: 0x06000B63 RID: 2915 RVA: 0x00032150 File Offset: 0x00030350
|
|
// (set) Token: 0x06000B64 RID: 2916 RVA: 0x00032158 File Offset: 0x00030358
|
|
public byte Version
|
|
{
|
|
get
|
|
{
|
|
return this.version;
|
|
}
|
|
set
|
|
{
|
|
this.version = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B65 RID: 2917 RVA: 0x00032164 File Offset: 0x00030364
|
|
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));
|
|
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));
|
|
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: 0x06000B66 RID: 2918 RVA: 0x000323AC File Offset: 0x000305AC
|
|
public byte[] GetBytes()
|
|
{
|
|
return this.GetASN1().GetBytes();
|
|
}
|
|
|
|
// Token: 0x040002FC RID: 764
|
|
private byte version;
|
|
|
|
// Token: 0x040002FD RID: 765
|
|
private X509Certificate x509;
|
|
|
|
// Token: 0x040002FE RID: 766
|
|
private string hashAlgorithm;
|
|
|
|
// Token: 0x040002FF RID: 767
|
|
private AsymmetricAlgorithm key;
|
|
|
|
// Token: 0x04000300 RID: 768
|
|
private ArrayList authenticatedAttributes;
|
|
|
|
// Token: 0x04000301 RID: 769
|
|
private ArrayList unauthenticatedAttributes;
|
|
|
|
// Token: 0x04000302 RID: 770
|
|
private byte[] signature;
|
|
|
|
// Token: 0x04000303 RID: 771
|
|
private string issuer;
|
|
|
|
// Token: 0x04000304 RID: 772
|
|
private byte[] serial;
|
|
|
|
// Token: 0x04000305 RID: 773
|
|
private byte[] ski;
|
|
}
|
|
}
|
|
}
|