scripts
This commit is contained in:
niko
@@ -0,0 +1,713 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Runtime.Serialization;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
|
||||
namespace Mono.Security.X509
|
||||
{
|
||||
// Token: 0x020000BC RID: 188
|
||||
internal class X509Certificate : ISerializable
|
||||
{
|
||||
// Token: 0x06000A29 RID: 2601 RVA: 0x0002D4B8 File Offset: 0x0002B6B8
|
||||
public X509Certificate(byte[] data)
|
||||
{
|
||||
if (data != null)
|
||||
{
|
||||
if (data.Length > 0 && data[0] != 48)
|
||||
{
|
||||
try
|
||||
{
|
||||
data = X509Certificate.PEM("CERTIFICATE", data);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new CryptographicException(X509Certificate.encoding_error, ex);
|
||||
}
|
||||
}
|
||||
this.Parse(data);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000A2A RID: 2602 RVA: 0x0002D52C File Offset: 0x0002B72C
|
||||
protected X509Certificate(SerializationInfo info, StreamingContext context)
|
||||
{
|
||||
this.Parse((byte[])info.GetValue("raw", typeof(byte[])));
|
||||
}
|
||||
|
||||
// Token: 0x06000A2C RID: 2604 RVA: 0x0002D574 File Offset: 0x0002B774
|
||||
private void Parse(byte[] data)
|
||||
{
|
||||
try
|
||||
{
|
||||
this.decoder = new ASN1(data);
|
||||
if (this.decoder.Tag != 48)
|
||||
{
|
||||
throw new CryptographicException(X509Certificate.encoding_error);
|
||||
}
|
||||
if (this.decoder[0].Tag != 48)
|
||||
{
|
||||
throw new CryptographicException(X509Certificate.encoding_error);
|
||||
}
|
||||
ASN1 asn = this.decoder[0];
|
||||
int num = 0;
|
||||
ASN1 asn2 = this.decoder[0][num];
|
||||
this.version = 1;
|
||||
if (asn2.Tag == 160 && asn2.Count > 0)
|
||||
{
|
||||
this.version += (int)asn2[0].Value[0];
|
||||
num++;
|
||||
}
|
||||
ASN1 asn3 = this.decoder[0][num++];
|
||||
if (asn3.Tag != 2)
|
||||
{
|
||||
throw new CryptographicException(X509Certificate.encoding_error);
|
||||
}
|
||||
this.serialnumber = asn3.Value;
|
||||
Array.Reverse(this.serialnumber, 0, this.serialnumber.Length);
|
||||
num++;
|
||||
this.issuer = asn.Element(num++, 48);
|
||||
this.m_issuername = X501.ToString(this.issuer);
|
||||
ASN1 asn4 = asn.Element(num++, 48);
|
||||
ASN1 asn5 = asn4[0];
|
||||
this.m_from = ASN1Convert.ToDateTime(asn5);
|
||||
ASN1 asn6 = asn4[1];
|
||||
this.m_until = ASN1Convert.ToDateTime(asn6);
|
||||
this.subject = asn.Element(num++, 48);
|
||||
this.m_subject = X501.ToString(this.subject);
|
||||
ASN1 asn7 = asn.Element(num++, 48);
|
||||
ASN1 asn8 = asn7.Element(0, 48);
|
||||
ASN1 asn9 = asn8.Element(0, 6);
|
||||
this.m_keyalgo = ASN1Convert.ToOid(asn9);
|
||||
ASN1 asn10 = asn8[1];
|
||||
this.m_keyalgoparams = ((asn8.Count <= 1) ? null : asn10.GetBytes());
|
||||
ASN1 asn11 = asn7.Element(1, 3);
|
||||
int num2 = asn11.Length - 1;
|
||||
this.m_publickey = new byte[num2];
|
||||
Buffer.BlockCopy(asn11.Value, 1, this.m_publickey, 0, num2);
|
||||
byte[] value = this.decoder[2].Value;
|
||||
this.signature = new byte[value.Length - 1];
|
||||
Buffer.BlockCopy(value, 1, this.signature, 0, this.signature.Length);
|
||||
asn8 = this.decoder[1];
|
||||
asn9 = asn8.Element(0, 6);
|
||||
this.m_signaturealgo = ASN1Convert.ToOid(asn9);
|
||||
asn10 = asn8[1];
|
||||
if (asn10 != null)
|
||||
{
|
||||
this.m_signaturealgoparams = asn10.GetBytes();
|
||||
}
|
||||
else
|
||||
{
|
||||
this.m_signaturealgoparams = null;
|
||||
}
|
||||
ASN1 asn12 = asn.Element(num, 129);
|
||||
if (asn12 != null)
|
||||
{
|
||||
num++;
|
||||
this.issuerUniqueID = asn12.Value;
|
||||
}
|
||||
ASN1 asn13 = asn.Element(num, 130);
|
||||
if (asn13 != null)
|
||||
{
|
||||
num++;
|
||||
this.subjectUniqueID = asn13.Value;
|
||||
}
|
||||
ASN1 asn14 = asn.Element(num, 163);
|
||||
if (asn14 != null && asn14.Count == 1)
|
||||
{
|
||||
this.extensions = new X509ExtensionCollection(asn14[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.extensions = new X509ExtensionCollection(null);
|
||||
}
|
||||
this.m_encodedcert = (byte[])data.Clone();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new CryptographicException(X509Certificate.encoding_error, ex);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000A2D RID: 2605 RVA: 0x0002D904 File Offset: 0x0002BB04
|
||||
private byte[] GetUnsignedBigInteger(byte[] integer)
|
||||
{
|
||||
if (integer[0] == 0)
|
||||
{
|
||||
int num = integer.Length - 1;
|
||||
byte[] array = new byte[num];
|
||||
Buffer.BlockCopy(integer, 1, array, 0, num);
|
||||
return array;
|
||||
}
|
||||
return integer;
|
||||
}
|
||||
|
||||
// Token: 0x1700013A RID: 314
|
||||
// (get) Token: 0x06000A2E RID: 2606 RVA: 0x0002D934 File Offset: 0x0002BB34
|
||||
// (set) Token: 0x06000A2F RID: 2607 RVA: 0x0002DA78 File Offset: 0x0002BC78
|
||||
public DSA DSA
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.m_keyalgoparams == null)
|
||||
{
|
||||
throw new CryptographicException("Missing key algorithm parameters.");
|
||||
}
|
||||
if (this._dsa == null)
|
||||
{
|
||||
DSAParameters dsaparameters = default(DSAParameters);
|
||||
ASN1 asn = new ASN1(this.m_publickey);
|
||||
if (asn == null || asn.Tag != 2)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
dsaparameters.Y = this.GetUnsignedBigInteger(asn.Value);
|
||||
ASN1 asn2 = new ASN1(this.m_keyalgoparams);
|
||||
if (asn2 == null || asn2.Tag != 48 || asn2.Count < 3)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (asn2[0].Tag != 2 || asn2[1].Tag != 2 || asn2[2].Tag != 2)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
dsaparameters.P = this.GetUnsignedBigInteger(asn2[0].Value);
|
||||
dsaparameters.Q = this.GetUnsignedBigInteger(asn2[1].Value);
|
||||
dsaparameters.G = this.GetUnsignedBigInteger(asn2[2].Value);
|
||||
this._dsa = new DSACryptoServiceProvider(dsaparameters.Y.Length << 3);
|
||||
this._dsa.ImportParameters(dsaparameters);
|
||||
}
|
||||
return this._dsa;
|
||||
}
|
||||
set
|
||||
{
|
||||
this._dsa = value;
|
||||
if (value != null)
|
||||
{
|
||||
this._rsa = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700013B RID: 315
|
||||
// (get) Token: 0x06000A30 RID: 2608 RVA: 0x0002DA90 File Offset: 0x0002BC90
|
||||
public X509ExtensionCollection Extensions
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.extensions;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700013C RID: 316
|
||||
// (get) Token: 0x06000A31 RID: 2609 RVA: 0x0002DA98 File Offset: 0x0002BC98
|
||||
public byte[] Hash
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.certhash == null)
|
||||
{
|
||||
string signaturealgo = this.m_signaturealgo;
|
||||
if (signaturealgo != null)
|
||||
{
|
||||
if (X509Certificate.<>f__switch$map13 == null)
|
||||
{
|
||||
X509Certificate.<>f__switch$map13 = new Dictionary<string, int>(5)
|
||||
{
|
||||
{ "1.2.840.113549.1.1.2", 0 },
|
||||
{ "1.2.840.113549.1.1.4", 1 },
|
||||
{ "1.2.840.113549.1.1.5", 2 },
|
||||
{ "1.3.14.3.2.29", 2 },
|
||||
{ "1.2.840.10040.4.3", 2 }
|
||||
};
|
||||
}
|
||||
int num;
|
||||
if (X509Certificate.<>f__switch$map13.TryGetValue(signaturealgo, out num))
|
||||
{
|
||||
HashAlgorithm hashAlgorithm;
|
||||
switch (num)
|
||||
{
|
||||
case 0:
|
||||
hashAlgorithm = HashAlgorithm.Create("MD2");
|
||||
break;
|
||||
case 1:
|
||||
hashAlgorithm = MD5.Create();
|
||||
break;
|
||||
case 2:
|
||||
hashAlgorithm = SHA1.Create();
|
||||
break;
|
||||
default:
|
||||
goto IL_BD;
|
||||
}
|
||||
if (this.decoder == null || this.decoder.Count < 1)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] bytes = this.decoder[0].GetBytes();
|
||||
this.certhash = hashAlgorithm.ComputeHash(bytes, 0, bytes.Length);
|
||||
goto IL_100;
|
||||
}
|
||||
}
|
||||
IL_BD:
|
||||
return null;
|
||||
}
|
||||
IL_100:
|
||||
return (byte[])this.certhash.Clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700013D RID: 317
|
||||
// (get) Token: 0x06000A32 RID: 2610 RVA: 0x0002DBB8 File Offset: 0x0002BDB8
|
||||
public virtual string IssuerName
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.m_issuername;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700013E RID: 318
|
||||
// (get) Token: 0x06000A33 RID: 2611 RVA: 0x0002DBC0 File Offset: 0x0002BDC0
|
||||
public virtual string KeyAlgorithm
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.m_keyalgo;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700013F RID: 319
|
||||
// (get) Token: 0x06000A34 RID: 2612 RVA: 0x0002DBC8 File Offset: 0x0002BDC8
|
||||
// (set) Token: 0x06000A35 RID: 2613 RVA: 0x0002DBE8 File Offset: 0x0002BDE8
|
||||
public virtual byte[] KeyAlgorithmParameters
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.m_keyalgoparams == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return (byte[])this.m_keyalgoparams.Clone();
|
||||
}
|
||||
set
|
||||
{
|
||||
this.m_keyalgoparams = value;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000140 RID: 320
|
||||
// (get) Token: 0x06000A36 RID: 2614 RVA: 0x0002DBF4 File Offset: 0x0002BDF4
|
||||
public virtual byte[] PublicKey
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.m_publickey == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return (byte[])this.m_publickey.Clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000141 RID: 321
|
||||
// (get) Token: 0x06000A37 RID: 2615 RVA: 0x0002DC14 File Offset: 0x0002BE14
|
||||
// (set) Token: 0x06000A38 RID: 2616 RVA: 0x0002DCC0 File Offset: 0x0002BEC0
|
||||
public virtual RSA RSA
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this._rsa == null)
|
||||
{
|
||||
RSAParameters rsaparameters = default(RSAParameters);
|
||||
ASN1 asn = new ASN1(this.m_publickey);
|
||||
ASN1 asn2 = asn[0];
|
||||
if (asn2 == null || asn2.Tag != 2)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
ASN1 asn3 = asn[1];
|
||||
if (asn3.Tag != 2)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
rsaparameters.Modulus = this.GetUnsignedBigInteger(asn2.Value);
|
||||
rsaparameters.Exponent = asn3.Value;
|
||||
int num = rsaparameters.Modulus.Length << 3;
|
||||
this._rsa = new RSACryptoServiceProvider(num);
|
||||
this._rsa.ImportParameters(rsaparameters);
|
||||
}
|
||||
return this._rsa;
|
||||
}
|
||||
set
|
||||
{
|
||||
if (value != null)
|
||||
{
|
||||
this._dsa = null;
|
||||
}
|
||||
this._rsa = value;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000142 RID: 322
|
||||
// (get) Token: 0x06000A39 RID: 2617 RVA: 0x0002DCD8 File Offset: 0x0002BED8
|
||||
public virtual byte[] RawData
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.m_encodedcert == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return (byte[])this.m_encodedcert.Clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000143 RID: 323
|
||||
// (get) Token: 0x06000A3A RID: 2618 RVA: 0x0002DCF8 File Offset: 0x0002BEF8
|
||||
public virtual byte[] SerialNumber
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.serialnumber == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return (byte[])this.serialnumber.Clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000144 RID: 324
|
||||
// (get) Token: 0x06000A3B RID: 2619 RVA: 0x0002DD18 File Offset: 0x0002BF18
|
||||
public virtual byte[] Signature
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.signature == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
string signaturealgo = this.m_signaturealgo;
|
||||
if (signaturealgo != null)
|
||||
{
|
||||
if (X509Certificate.<>f__switch$map14 == null)
|
||||
{
|
||||
X509Certificate.<>f__switch$map14 = new Dictionary<string, int>(5)
|
||||
{
|
||||
{ "1.2.840.113549.1.1.2", 0 },
|
||||
{ "1.2.840.113549.1.1.4", 0 },
|
||||
{ "1.2.840.113549.1.1.5", 0 },
|
||||
{ "1.3.14.3.2.29", 0 },
|
||||
{ "1.2.840.10040.4.3", 1 }
|
||||
};
|
||||
}
|
||||
int num;
|
||||
if (X509Certificate.<>f__switch$map14.TryGetValue(signaturealgo, out num))
|
||||
{
|
||||
if (num == 0)
|
||||
{
|
||||
return (byte[])this.signature.Clone();
|
||||
}
|
||||
if (num == 1)
|
||||
{
|
||||
ASN1 asn = new ASN1(this.signature);
|
||||
if (asn == null || asn.Count != 2)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
byte[] value = asn[0].Value;
|
||||
byte[] value2 = asn[1].Value;
|
||||
byte[] array = new byte[40];
|
||||
int num2 = Math.Max(0, value.Length - 20);
|
||||
int num3 = Math.Max(0, 20 - value.Length);
|
||||
Buffer.BlockCopy(value, num2, array, num3, value.Length - num2);
|
||||
int num4 = Math.Max(0, value2.Length - 20);
|
||||
int num5 = Math.Max(20, 40 - value2.Length);
|
||||
Buffer.BlockCopy(value2, num4, array, num5, value2.Length - num4);
|
||||
return array;
|
||||
}
|
||||
}
|
||||
}
|
||||
throw new CryptographicException("Unsupported hash algorithm: " + this.m_signaturealgo);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000145 RID: 325
|
||||
// (get) Token: 0x06000A3C RID: 2620 RVA: 0x0002DE88 File Offset: 0x0002C088
|
||||
public virtual string SignatureAlgorithm
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.m_signaturealgo;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000146 RID: 326
|
||||
// (get) Token: 0x06000A3D RID: 2621 RVA: 0x0002DE90 File Offset: 0x0002C090
|
||||
public virtual byte[] SignatureAlgorithmParameters
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.m_signaturealgoparams == null)
|
||||
{
|
||||
return this.m_signaturealgoparams;
|
||||
}
|
||||
return (byte[])this.m_signaturealgoparams.Clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000147 RID: 327
|
||||
// (get) Token: 0x06000A3E RID: 2622 RVA: 0x0002DEC0 File Offset: 0x0002C0C0
|
||||
public virtual string SubjectName
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.m_subject;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000148 RID: 328
|
||||
// (get) Token: 0x06000A3F RID: 2623 RVA: 0x0002DEC8 File Offset: 0x0002C0C8
|
||||
public virtual DateTime ValidFrom
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.m_from;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x17000149 RID: 329
|
||||
// (get) Token: 0x06000A40 RID: 2624 RVA: 0x0002DED0 File Offset: 0x0002C0D0
|
||||
public virtual DateTime ValidUntil
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.m_until;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700014A RID: 330
|
||||
// (get) Token: 0x06000A41 RID: 2625 RVA: 0x0002DED8 File Offset: 0x0002C0D8
|
||||
public int Version
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.version;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700014B RID: 331
|
||||
// (get) Token: 0x06000A42 RID: 2626 RVA: 0x0002DEE0 File Offset: 0x0002C0E0
|
||||
public bool IsCurrent
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.WasCurrent(DateTime.UtcNow);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000A43 RID: 2627 RVA: 0x0002DEF0 File Offset: 0x0002C0F0
|
||||
public bool WasCurrent(DateTime instant)
|
||||
{
|
||||
return instant > this.ValidFrom && instant <= this.ValidUntil;
|
||||
}
|
||||
|
||||
// Token: 0x1700014C RID: 332
|
||||
// (get) Token: 0x06000A44 RID: 2628 RVA: 0x0002DF20 File Offset: 0x0002C120
|
||||
public byte[] IssuerUniqueIdentifier
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.issuerUniqueID == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return (byte[])this.issuerUniqueID.Clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700014D RID: 333
|
||||
// (get) Token: 0x06000A45 RID: 2629 RVA: 0x0002DF40 File Offset: 0x0002C140
|
||||
public byte[] SubjectUniqueIdentifier
|
||||
{
|
||||
get
|
||||
{
|
||||
if (this.subjectUniqueID == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return (byte[])this.subjectUniqueID.Clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000A46 RID: 2630 RVA: 0x0002DF60 File Offset: 0x0002C160
|
||||
internal bool VerifySignature(DSA dsa)
|
||||
{
|
||||
DSASignatureDeformatter dsasignatureDeformatter = new DSASignatureDeformatter(dsa);
|
||||
dsasignatureDeformatter.SetHashAlgorithm("SHA1");
|
||||
return dsasignatureDeformatter.VerifySignature(this.Hash, this.Signature);
|
||||
}
|
||||
|
||||
// Token: 0x06000A47 RID: 2631 RVA: 0x0002DF94 File Offset: 0x0002C194
|
||||
internal string GetHashNameFromOID(string oid)
|
||||
{
|
||||
switch (oid)
|
||||
{
|
||||
case "1.2.840.113549.1.1.2":
|
||||
return "MD2";
|
||||
case "1.2.840.113549.1.1.4":
|
||||
return "MD5";
|
||||
case "1.2.840.113549.1.1.5":
|
||||
case "1.3.14.3.2.29":
|
||||
return "SHA1";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// Token: 0x06000A48 RID: 2632 RVA: 0x0002E02C File Offset: 0x0002C22C
|
||||
internal bool VerifySignature(RSA rsa)
|
||||
{
|
||||
RSAPKCS1SignatureDeformatter rsapkcs1SignatureDeformatter = new RSAPKCS1SignatureDeformatter(rsa);
|
||||
string hashNameFromOID = this.GetHashNameFromOID(this.m_signaturealgo);
|
||||
if (hashNameFromOID == null)
|
||||
{
|
||||
throw new CryptographicException("Unsupported hash algorithm: " + this.m_signaturealgo);
|
||||
}
|
||||
rsapkcs1SignatureDeformatter.SetHashAlgorithm(hashNameFromOID);
|
||||
return rsapkcs1SignatureDeformatter.VerifySignature(this.Hash, this.Signature);
|
||||
}
|
||||
|
||||
// Token: 0x06000A49 RID: 2633 RVA: 0x0002E084 File Offset: 0x0002C284
|
||||
public bool VerifySignature(AsymmetricAlgorithm aa)
|
||||
{
|
||||
if (aa == null)
|
||||
{
|
||||
throw new ArgumentNullException("aa");
|
||||
}
|
||||
if (aa is RSA)
|
||||
{
|
||||
return this.VerifySignature(aa as RSA);
|
||||
}
|
||||
if (aa is DSA)
|
||||
{
|
||||
return this.VerifySignature(aa as DSA);
|
||||
}
|
||||
throw new NotSupportedException("Unknown Asymmetric Algorithm " + aa.ToString());
|
||||
}
|
||||
|
||||
// Token: 0x06000A4A RID: 2634 RVA: 0x0002E0E8 File Offset: 0x0002C2E8
|
||||
public bool CheckSignature(byte[] hash, string hashAlgorithm, byte[] signature)
|
||||
{
|
||||
RSACryptoServiceProvider rsacryptoServiceProvider = (RSACryptoServiceProvider)this.RSA;
|
||||
return rsacryptoServiceProvider.VerifyHash(hash, hashAlgorithm, signature);
|
||||
}
|
||||
|
||||
// Token: 0x1700014E RID: 334
|
||||
// (get) Token: 0x06000A4B RID: 2635 RVA: 0x0002E10C File Offset: 0x0002C30C
|
||||
public bool IsSelfSigned
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.m_issuername == this.m_subject && this.VerifySignature(this.RSA);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000A4C RID: 2636 RVA: 0x0002E140 File Offset: 0x0002C340
|
||||
public ASN1 GetIssuerName()
|
||||
{
|
||||
return this.issuer;
|
||||
}
|
||||
|
||||
// Token: 0x06000A4D RID: 2637 RVA: 0x0002E148 File Offset: 0x0002C348
|
||||
public ASN1 GetSubjectName()
|
||||
{
|
||||
return this.subject;
|
||||
}
|
||||
|
||||
// Token: 0x06000A4E RID: 2638 RVA: 0x0002E150 File Offset: 0x0002C350
|
||||
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
|
||||
{
|
||||
info.AddValue("raw", this.m_encodedcert);
|
||||
}
|
||||
|
||||
// Token: 0x06000A4F RID: 2639 RVA: 0x0002E164 File Offset: 0x0002C364
|
||||
private static byte[] PEM(string type, byte[] data)
|
||||
{
|
||||
string @string = Encoding.ASCII.GetString(data);
|
||||
string text = string.Format("-----BEGIN {0}-----", type);
|
||||
string text2 = string.Format("-----END {0}-----", type);
|
||||
int num = @string.IndexOf(text) + text.Length;
|
||||
int num2 = @string.IndexOf(text2, num);
|
||||
string text3 = @string.Substring(num, num2 - num);
|
||||
return Convert.FromBase64String(text3);
|
||||
}
|
||||
|
||||
// Token: 0x04000292 RID: 658
|
||||
private ASN1 decoder;
|
||||
|
||||
// Token: 0x04000293 RID: 659
|
||||
private byte[] m_encodedcert;
|
||||
|
||||
// Token: 0x04000294 RID: 660
|
||||
private DateTime m_from;
|
||||
|
||||
// Token: 0x04000295 RID: 661
|
||||
private DateTime m_until;
|
||||
|
||||
// Token: 0x04000296 RID: 662
|
||||
private ASN1 issuer;
|
||||
|
||||
// Token: 0x04000297 RID: 663
|
||||
private string m_issuername;
|
||||
|
||||
// Token: 0x04000298 RID: 664
|
||||
private string m_keyalgo;
|
||||
|
||||
// Token: 0x04000299 RID: 665
|
||||
private byte[] m_keyalgoparams;
|
||||
|
||||
// Token: 0x0400029A RID: 666
|
||||
private ASN1 subject;
|
||||
|
||||
// Token: 0x0400029B RID: 667
|
||||
private string m_subject;
|
||||
|
||||
// Token: 0x0400029C RID: 668
|
||||
private byte[] m_publickey;
|
||||
|
||||
// Token: 0x0400029D RID: 669
|
||||
private byte[] signature;
|
||||
|
||||
// Token: 0x0400029E RID: 670
|
||||
private string m_signaturealgo;
|
||||
|
||||
// Token: 0x0400029F RID: 671
|
||||
private byte[] m_signaturealgoparams;
|
||||
|
||||
// Token: 0x040002A0 RID: 672
|
||||
private byte[] certhash;
|
||||
|
||||
// Token: 0x040002A1 RID: 673
|
||||
private RSA _rsa;
|
||||
|
||||
// Token: 0x040002A2 RID: 674
|
||||
private DSA _dsa;
|
||||
|
||||
// Token: 0x040002A3 RID: 675
|
||||
private int version;
|
||||
|
||||
// Token: 0x040002A4 RID: 676
|
||||
private byte[] serialnumber;
|
||||
|
||||
// Token: 0x040002A5 RID: 677
|
||||
private byte[] issuerUniqueID;
|
||||
|
||||
// Token: 0x040002A6 RID: 678
|
||||
private byte[] subjectUniqueID;
|
||||
|
||||
// Token: 0x040002A7 RID: 679
|
||||
private X509ExtensionCollection extensions;
|
||||
|
||||
// Token: 0x040002A8 RID: 680
|
||||
private static string encoding_error = Locale.GetText("Input data cannot be coded as a valid certificate.");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user