Uranium-and-Waffles/Dec2017-Script-Dump
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scripts

Browse Source
This commit is contained in:
niko
2026-06-04 11:42:34 +02:00
parent f39ba70a9f
commit e720b98cd1
7488 changed files with 2493818 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Mono.Security/Security/X509/Extensions/AuthorityKeyIdentifierExtension.cs
+95
View File
@@ -0,0 +1,95 @@
using System;
using System.Globalization;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x02000064 RID: 100
public class AuthorityKeyIdentifierExtension : X509Extension
{
// Token: 0x060003C4 RID: 964 RVA: 0x00018D04 File Offset: 0x00016F04
public AuthorityKeyIdentifierExtension()
{
this.extnOid = "2.5.29.35";
}
// Token: 0x060003C5 RID: 965 RVA: 0x00018D18 File Offset: 0x00016F18
public AuthorityKeyIdentifierExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x060003C6 RID: 966 RVA: 0x00018D24 File Offset: 0x00016F24
public AuthorityKeyIdentifierExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x060003C7 RID: 967 RVA: 0x00018D30 File Offset: 0x00016F30
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid AuthorityKeyIdentifier extension");
}
for (int i = 0; i < asn.Count; i++)
{
ASN1 asn2 = asn[i];
byte tag = asn2.Tag;
if (tag == 128)
{
this.aki = asn2.Value;
}
}
}
// Token: 0x170000D7 RID: 215
// (get) Token: 0x060003C8 RID: 968 RVA: 0x00018DB4 File Offset: 0x00016FB4
public override string Name
{
get
{
return "Authority Key Identifier";
}
}
// Token: 0x170000D8 RID: 216
// (get) Token: 0x060003C9 RID: 969 RVA: 0x00018DBC File Offset: 0x00016FBC
public byte[] Identifier
{
get
{
if (this.aki == null)
{
return null;
}
return (byte[])this.aki.Clone();
}
}
// Token: 0x060003CA RID: 970 RVA: 0x00018DDC File Offset: 0x00016FDC
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.aki != null)
{
int i = 0;
stringBuilder.Append("KeyID=");
while (i < this.aki.Length)
{
stringBuilder.Append(this.aki[i].ToString("X2", CultureInfo.InvariantCulture));
if (i % 2 == 1)
{
stringBuilder.Append(" ");
}
i++;
}
}
return stringBuilder.ToString();
}
// Token: 0x040001B9 RID: 441
private byte[] aki;
}
}
Mono.Security/Security/X509/Extensions/BasicConstraintsExtension.cs
+142
View File
@@ -0,0 +1,142 @@
using System;
using System.Globalization;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x02000065 RID: 101
public class BasicConstraintsExtension : X509Extension
{
// Token: 0x060003CB RID: 971 RVA: 0x00018E5C File Offset: 0x0001705C
public BasicConstraintsExtension()
{
this.extnOid = "2.5.29.19";
this.pathLenConstraint = -1;
}
// Token: 0x060003CC RID: 972 RVA: 0x00018E78 File Offset: 0x00017078
public BasicConstraintsExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x060003CD RID: 973 RVA: 0x00018E84 File Offset: 0x00017084
public BasicConstraintsExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x060003CE RID: 974 RVA: 0x00018E90 File Offset: 0x00017090
protected override void Decode()
{
this.cA = false;
this.pathLenConstraint = -1;
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid BasicConstraints extension");
}
int num = 0;
ASN1 asn2 = asn[num++];
if (asn2 != null && asn2.Tag == 1)
{
this.cA = asn2.Value[0] == byte.MaxValue;
asn2 = asn[num++];
}
if (asn2 != null && asn2.Tag == 2)
{
this.pathLenConstraint = ASN1Convert.ToInt32(asn2);
}
}
// Token: 0x060003CF RID: 975 RVA: 0x00018F34 File Offset: 0x00017134
protected override void Encode()
{
ASN1 asn = new ASN1(48);
if (this.cA)
{
asn.Add(new ASN1(1, new byte[] { byte.MaxValue }));
}
if (this.cA && this.pathLenConstraint >= 0)
{
asn.Add(ASN1Convert.FromInt32(this.pathLenConstraint));
}
this.extnValue = new ASN1(4);
this.extnValue.Add(asn);
}
// Token: 0x170000D9 RID: 217
// (get) Token: 0x060003D0 RID: 976 RVA: 0x00018FB4 File Offset: 0x000171B4
// (set) Token: 0x060003D1 RID: 977 RVA: 0x00018FBC File Offset: 0x000171BC
public bool CertificateAuthority
{
get
{
return this.cA;
}
set
{
this.cA = value;
}
}
// Token: 0x170000DA RID: 218
// (get) Token: 0x060003D2 RID: 978 RVA: 0x00018FC8 File Offset: 0x000171C8
public override string Name
{
get
{
return "Basic Constraints";
}
}
// Token: 0x170000DB RID: 219
// (get) Token: 0x060003D3 RID: 979 RVA: 0x00018FD0 File Offset: 0x000171D0
// (set) Token: 0x060003D4 RID: 980 RVA: 0x00018FD8 File Offset: 0x000171D8
public int PathLenConstraint
{
get
{
return this.pathLenConstraint;
}
set
{
if (value < -1)
{
string text = Locale.GetText("PathLenConstraint must be positive or -1 for none ({0}).", new object[] { value });
throw new ArgumentOutOfRangeException(text);
}
this.pathLenConstraint = value;
}
}
// Token: 0x060003D5 RID: 981 RVA: 0x00019014 File Offset: 0x00017214
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("Subject Type=");
stringBuilder.Append((!this.cA) ? "End Entity" : "CA");
stringBuilder.Append(Environment.NewLine);
stringBuilder.Append("Path Length Constraint=");
if (this.pathLenConstraint == -1)
{
stringBuilder.Append("None");
}
else
{
stringBuilder.Append(this.pathLenConstraint.ToString(CultureInfo.InvariantCulture));
}
stringBuilder.Append(Environment.NewLine);
return stringBuilder.ToString();
}
// Token: 0x040001BA RID: 442
public const int NoPathLengthConstraint = -1;
// Token: 0x040001BB RID: 443
private bool cA;
// Token: 0x040001BC RID: 444
private int pathLenConstraint;
}
}
Mono.Security/Security/X509/Extensions/CRLDistributionPointsExtension.cs
+148
View File
@@ -0,0 +1,148 @@
using System;
using System.Collections;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x02000066 RID: 102
public class CRLDistributionPointsExtension : X509Extension
{
// Token: 0x060003D6 RID: 982 RVA: 0x000190B4 File Offset: 0x000172B4
public CRLDistributionPointsExtension()
{
this.extnOid = "2.5.29.31";
this.dps = new ArrayList();
}
// Token: 0x060003D7 RID: 983 RVA: 0x000190D4 File Offset: 0x000172D4
public CRLDistributionPointsExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x060003D8 RID: 984 RVA: 0x000190E0 File Offset: 0x000172E0
public CRLDistributionPointsExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x060003D9 RID: 985 RVA: 0x000190EC File Offset: 0x000172EC
protected override void Decode()
{
this.dps = new ArrayList();
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid CRLDistributionPoints extension");
}
for (int i = 0; i < asn.Count; i++)
{
this.dps.Add(new CRLDistributionPointsExtension.DP(asn[i]));
}
}
// Token: 0x170000DC RID: 220
// (get) Token: 0x060003DA RID: 986 RVA: 0x0001915C File Offset: 0x0001735C
public override string Name
{
get
{
return "CRL Distribution Points";
}
}
// Token: 0x060003DB RID: 987 RVA: 0x00019164 File Offset: 0x00017364
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
int num = 1;
foreach (object obj in this.dps)
{
CRLDistributionPointsExtension.DP dp = (CRLDistributionPointsExtension.DP)obj;
stringBuilder.Append("[");
stringBuilder.Append(num++);
stringBuilder.Append("]CRL Distribution Point");
stringBuilder.Append(Environment.NewLine);
stringBuilder.Append("\tDistribution Point Name:");
stringBuilder.Append("\t\tFull Name:");
stringBuilder.Append(Environment.NewLine);
stringBuilder.Append("\t\t\t");
stringBuilder.Append(dp.DistributionPoint);
stringBuilder.Append(Environment.NewLine);
}
return stringBuilder.ToString();
}
// Token: 0x040001BD RID: 445
private ArrayList dps;
// Token: 0x02000067 RID: 103
internal class DP
{
// Token: 0x060003DC RID: 988 RVA: 0x00019258 File Offset: 0x00017458
public DP(string dp, CRLDistributionPointsExtension.ReasonFlags reasons, string issuer)
{
this.DistributionPoint = dp;
this.Reasons = reasons;
this.CRLIssuer = issuer;
}
// Token: 0x060003DD RID: 989 RVA: 0x00019278 File Offset: 0x00017478
public DP(ASN1 dp)
{
for (int i = 0; i < dp.Count; i++)
{
ASN1 asn = dp[i];
switch (asn.Tag)
{
case 160:
{
for (int j = 0; j < asn.Count; j++)
{
ASN1 asn2 = asn[j];
if (asn2.Tag == 160)
{
this.DistributionPoint = new GeneralNames(asn2).ToString();
}
}
break;
}
}
}
}
// Token: 0x040001BE RID: 446
public string DistributionPoint;
// Token: 0x040001BF RID: 447
public CRLDistributionPointsExtension.ReasonFlags Reasons;
// Token: 0x040001C0 RID: 448
public string CRLIssuer;
}
// Token: 0x02000068 RID: 104
[Flags]
public enum ReasonFlags
{
// Token: 0x040001C2 RID: 450
Unused = 0,
// Token: 0x040001C3 RID: 451
KeyCompromise = 1,
// Token: 0x040001C4 RID: 452
CACompromise = 2,
// Token: 0x040001C5 RID: 453
AffiliationChanged = 3,
// Token: 0x040001C6 RID: 454
Superseded = 4,
// Token: 0x040001C7 RID: 455
CessationOfOperation = 5,
// Token: 0x040001C8 RID: 456
CertificateHold = 6,
// Token: 0x040001C9 RID: 457
PrivilegeWithdrawn = 7,
// Token: 0x040001CA RID: 458
AACompromise = 8
}
}
}
Mono.Security/Security/X509/Extensions/CertificatePoliciesExtension.cs
+76
View File
@@ -0,0 +1,76 @@
using System;
using System.Collections;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x02000069 RID: 105
public class CertificatePoliciesExtension : X509Extension
{
// Token: 0x060003DE RID: 990 RVA: 0x00019320 File Offset: 0x00017520
public CertificatePoliciesExtension()
{
this.extnOid = "2.5.29.32";
this.policies = new Hashtable();
}
// Token: 0x060003DF RID: 991 RVA: 0x00019340 File Offset: 0x00017540
public CertificatePoliciesExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x060003E0 RID: 992 RVA: 0x0001934C File Offset: 0x0001754C
public CertificatePoliciesExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x060003E1 RID: 993 RVA: 0x00019358 File Offset: 0x00017558
protected override void Decode()
{
this.policies = new Hashtable();
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid CertificatePolicies extension");
}
for (int i = 0; i < asn.Count; i++)
{
this.policies.Add(ASN1Convert.ToOid(asn[i][0]), null);
}
}
// Token: 0x170000DD RID: 221
// (get) Token: 0x060003E2 RID: 994 RVA: 0x000193D0 File Offset: 0x000175D0
public override string Name
{
get
{
return "Certificate Policies";
}
}
// Token: 0x060003E3 RID: 995 RVA: 0x000193D8 File Offset: 0x000175D8
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
int num = 1;
foreach (object obj in this.policies)
{
DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
stringBuilder.Append("[");
stringBuilder.Append(num++);
stringBuilder.Append("]Certificate Policy:");
stringBuilder.Append(Environment.NewLine);
stringBuilder.Append("\tPolicyIdentifier=");
stringBuilder.Append((string)dictionaryEntry.Key);
stringBuilder.Append(Environment.NewLine);
}
return stringBuilder.ToString();
}
// Token: 0x040001CB RID: 459
private Hashtable policies;
}
}
Mono.Security/Security/X509/Extensions/ExtendedKeyUsageExtension.cs
+143
View File
@@ -0,0 +1,143 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x0200006A RID: 106
public class ExtendedKeyUsageExtension : X509Extension
{
// Token: 0x060003E4 RID: 996 RVA: 0x000194AC File Offset: 0x000176AC
public ExtendedKeyUsageExtension()
{
this.extnOid = "2.5.29.37";
this.keyPurpose = new ArrayList();
}
// Token: 0x060003E5 RID: 997 RVA: 0x000194CC File Offset: 0x000176CC
public ExtendedKeyUsageExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x060003E6 RID: 998 RVA: 0x000194D8 File Offset: 0x000176D8
public ExtendedKeyUsageExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x060003E7 RID: 999 RVA: 0x000194E4 File Offset: 0x000176E4
protected override void Decode()
{
this.keyPurpose = new ArrayList();
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid ExtendedKeyUsage extension");
}
for (int i = 0; i < asn.Count; i++)
{
this.keyPurpose.Add(ASN1Convert.ToOid(asn[i]));
}
}
// Token: 0x060003E8 RID: 1000 RVA: 0x00019554 File Offset: 0x00017754
protected override void Encode()
{
ASN1 asn = new ASN1(48);
foreach (object obj in this.keyPurpose)
{
string text = (string)obj;
asn.Add(ASN1Convert.FromOid(text));
}
this.extnValue = new ASN1(4);
this.extnValue.Add(asn);
}
// Token: 0x170000DE RID: 222
// (get) Token: 0x060003E9 RID: 1001 RVA: 0x000195EC File Offset: 0x000177EC
public ArrayList KeyPurpose
{
get
{
return this.keyPurpose;
}
}
// Token: 0x170000DF RID: 223
// (get) Token: 0x060003EA RID: 1002 RVA: 0x000195F4 File Offset: 0x000177F4
public override string Name
{
get
{
return "Extended Key Usage";
}
}
// Token: 0x060003EB RID: 1003 RVA: 0x000195FC File Offset: 0x000177FC
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
foreach (object obj in this.keyPurpose)
{
string text = (string)obj;
string text2 = text;
if (text2 == null)
{
goto IL_12E;
}
if (ExtendedKeyUsageExtension.<>f__switch$map14 == null)
{
ExtendedKeyUsageExtension.<>f__switch$map14 = new Dictionary<string, int>(6)
{
{ "1.3.6.1.5.5.7.3.1", 0 },
{ "1.3.6.1.5.5.7.3.2", 1 },
{ "1.3.6.1.5.5.7.3.3", 2 },
{ "1.3.6.1.5.5.7.3.4", 3 },
{ "1.3.6.1.5.5.7.3.8", 4 },
{ "1.3.6.1.5.5.7.3.9", 5 }
};
}
int num;
if (!ExtendedKeyUsageExtension.<>f__switch$map14.TryGetValue(text2, out num))
{
goto IL_12E;
}
switch (num)
{
case 0:
stringBuilder.Append("Server Authentication");
break;
case 1:
stringBuilder.Append("Client Authentication");
break;
case 2:
stringBuilder.Append("Code Signing");
break;
case 3:
stringBuilder.Append("Email Protection");
break;
case 4:
stringBuilder.Append("Time Stamping");
break;
case 5:
stringBuilder.Append("OCSP Signing");
break;
default:
goto IL_12E;
}
IL_13F:
stringBuilder.AppendFormat(" ({0}){1}", text, Environment.NewLine);
continue;
IL_12E:
stringBuilder.Append("unknown");
goto IL_13F;
}
return stringBuilder.ToString();
}
// Token: 0x040001CC RID: 460
private ArrayList keyPurpose;
}
}
Mono.Security/Security/X509/Extensions/GeneralNames.cs
+290
View File
@@ -0,0 +1,290 @@
using System;
using System.Collections;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x0200006B RID: 107
internal class GeneralNames
{
// Token: 0x060003EC RID: 1004 RVA: 0x000197A4 File Offset: 0x000179A4
public GeneralNames()
{
}
// Token: 0x060003ED RID: 1005 RVA: 0x000197AC File Offset: 0x000179AC
public GeneralNames(string[] rfc822s, string[] dnsNames, string[] ipAddresses, string[] uris)
{
this.asn = new ASN1(48);
if (rfc822s != null)
{
this.rfc822Name = new ArrayList();
foreach (string text in rfc822s)
{
this.asn.Add(new ASN1(129, Encoding.ASCII.GetBytes(text)));
this.rfc822Name.Add(rfc822s);
}
}
if (dnsNames != null)
{
this.dnsName = new ArrayList();
foreach (string text2 in dnsNames)
{
this.asn.Add(new ASN1(130, Encoding.ASCII.GetBytes(text2)));
this.dnsName.Add(text2);
}
}
if (ipAddresses != null)
{
this.ipAddr = new ArrayList();
foreach (string text3 in ipAddresses)
{
string[] array = text3.Split(new char[] { '.', ':' });
byte[] array2 = new byte[array.Length];
for (int l = 0; l < array.Length; l++)
{
array2[l] = byte.Parse(array[l]);
}
this.asn.Add(new ASN1(135, array2));
this.ipAddr.Add(text3);
}
}
if (uris != null)
{
this.uris = new ArrayList();
foreach (string text4 in uris)
{
this.asn.Add(new ASN1(134, Encoding.ASCII.GetBytes(text4)));
this.uris.Add(text4);
}
}
}
// Token: 0x060003EE RID: 1006 RVA: 0x00019994 File Offset: 0x00017B94
public GeneralNames(ASN1 sequence)
{
int i = 0;
while (i < sequence.Count)
{
byte tag = sequence[i].Tag;
switch (tag)
{
case 129:
if (this.rfc822Name == null)
{
this.rfc822Name = new ArrayList();
}
this.rfc822Name.Add(Encoding.ASCII.GetString(sequence[i].Value));
break;
case 130:
if (this.dnsName == null)
{
this.dnsName = new ArrayList();
}
this.dnsName.Add(Encoding.ASCII.GetString(sequence[i].Value));
break;
default:
if (tag == 164)
{
goto IL_CF;
}
break;
case 132:
goto IL_CF;
case 134:
if (this.uris == null)
{
this.uris = new ArrayList();
}
this.uris.Add(Encoding.ASCII.GetString(sequence[i].Value));
break;
case 135:
{
if (this.ipAddr == null)
{
this.ipAddr = new ArrayList();
}
byte[] value = sequence[i].Value;
string text = ((value.Length != 4) ? ":" : ".");
StringBuilder stringBuilder = new StringBuilder();
for (int j = 0; j < value.Length; j++)
{
stringBuilder.Append(value[j].ToString());
if (j < value.Length - 1)
{
stringBuilder.Append(text);
}
}
this.ipAddr.Add(stringBuilder.ToString());
if (this.ipAddr == null)
{
this.ipAddr = new ArrayList();
}
break;
}
}
IL_1F9:
i++;
continue;
IL_CF:
if (this.directoryNames == null)
{
this.directoryNames = new ArrayList();
}
this.directoryNames.Add(X501.ToString(sequence[i][0]));
goto IL_1F9;
}
}
// Token: 0x170000E0 RID: 224
// (get) Token: 0x060003EF RID: 1007 RVA: 0x00019BAC File Offset: 0x00017DAC
public string[] RFC822
{
get
{
if (this.rfc822Name == null)
{
return new string[0];
}
return (string[])this.rfc822Name.ToArray(typeof(string));
}
}
// Token: 0x170000E1 RID: 225
// (get) Token: 0x060003F0 RID: 1008 RVA: 0x00019BE8 File Offset: 0x00017DE8
public string[] DirectoryNames
{
get
{
if (this.directoryNames == null)
{
return new string[0];
}
return (string[])this.directoryNames.ToArray(typeof(string));
}
}
// Token: 0x170000E2 RID: 226
// (get) Token: 0x060003F1 RID: 1009 RVA: 0x00019C24 File Offset: 0x00017E24
public string[] DNSNames
{
get
{
if (this.dnsName == null)
{
return new string[0];
}
return (string[])this.dnsName.ToArray(typeof(string));
}
}
// Token: 0x170000E3 RID: 227
// (get) Token: 0x060003F2 RID: 1010 RVA: 0x00019C60 File Offset: 0x00017E60
public string[] UniformResourceIdentifiers
{
get
{
if (this.uris == null)
{
return new string[0];
}
return (string[])this.uris.ToArray(typeof(string));
}
}
// Token: 0x170000E4 RID: 228
// (get) Token: 0x060003F3 RID: 1011 RVA: 0x00019C9C File Offset: 0x00017E9C
public string[] IPAddresses
{
get
{
if (this.ipAddr == null)
{
return new string[0];
}
return (string[])this.ipAddr.ToArray(typeof(string));
}
}
// Token: 0x060003F4 RID: 1012 RVA: 0x00019CD8 File Offset: 0x00017ED8
public byte[] GetBytes()
{
return this.asn.GetBytes();
}
// Token: 0x060003F5 RID: 1013 RVA: 0x00019CE8 File Offset: 0x00017EE8
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.rfc822Name != null)
{
foreach (object obj in this.rfc822Name)
{
string text = (string)obj;
stringBuilder.Append("RFC822 Name=");
stringBuilder.Append(text);
stringBuilder.Append(Environment.NewLine);
}
}
if (this.dnsName != null)
{
foreach (object obj2 in this.dnsName)
{
string text2 = (string)obj2;
stringBuilder.Append("DNS Name=");
stringBuilder.Append(text2);
stringBuilder.Append(Environment.NewLine);
}
}
if (this.directoryNames != null)
{
foreach (object obj3 in this.directoryNames)
{
string text3 = (string)obj3;
stringBuilder.Append("Directory Address: ");
stringBuilder.Append(text3);
stringBuilder.Append(Environment.NewLine);
}
}
if (this.uris != null)
{
foreach (object obj4 in this.uris)
{
string text4 = (string)obj4;
stringBuilder.Append("URL=");
stringBuilder.Append(text4);
stringBuilder.Append(Environment.NewLine);
}
}
if (this.ipAddr != null)
{
foreach (object obj5 in this.ipAddr)
{
string text5 = (string)obj5;
stringBuilder.Append("IP Address=");
stringBuilder.Append(text5);
stringBuilder.Append(Environment.NewLine);
}
}
return stringBuilder.ToString();
}
// Token: 0x040001CE RID: 462
private ArrayList rfc822Name;
// Token: 0x040001CF RID: 463
private ArrayList dnsName;
// Token: 0x040001D0 RID: 464
private ArrayList directoryNames;
// Token: 0x040001D1 RID: 465
private ArrayList uris;
// Token: 0x040001D2 RID: 466
private ArrayList ipAddr;
// Token: 0x040001D3 RID: 467
private ASN1 asn;
}
}
Mono.Security/Security/X509/Extensions/KeyAttributesExtension.cs
+257
View File
@@ -0,0 +1,257 @@
using System;
using System.Globalization;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x0200006C RID: 108
public class KeyAttributesExtension : X509Extension
{
// Token: 0x060003F6 RID: 1014 RVA: 0x00019FB4 File Offset: 0x000181B4
public KeyAttributesExtension()
{
this.extnOid = "2.5.29.2";
}
// Token: 0x060003F7 RID: 1015 RVA: 0x00019FC8 File Offset: 0x000181C8
public KeyAttributesExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x060003F8 RID: 1016 RVA: 0x00019FD4 File Offset: 0x000181D4
public KeyAttributesExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x060003F9 RID: 1017 RVA: 0x00019FE0 File Offset: 0x000181E0
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid KeyAttributesExtension extension");
}
int num = 0;
if (num < asn.Count)
{
ASN1 asn2 = asn[num];
if (asn2.Tag == 4)
{
num++;
this.keyId = asn2.Value;
}
}
if (num < asn.Count)
{
ASN1 asn3 = asn[num];
if (asn3.Tag == 3)
{
num++;
int i = 1;
while (i < asn3.Value.Length)
{
this.kubits = (this.kubits << 8) + (int)asn3.Value[i++];
}
}
}
if (num < asn.Count)
{
ASN1 asn4 = asn[num];
if (asn4.Tag == 48)
{
int num2 = 0;
if (num2 < asn4.Count)
{
ASN1 asn5 = asn4[num2];
if (asn5.Tag == 129)
{
num2++;
this.notBefore = ASN1Convert.ToDateTime(asn5);
}
}
if (num2 < asn4.Count)
{
ASN1 asn6 = asn4[num2];
if (asn6.Tag == 130)
{
this.notAfter = ASN1Convert.ToDateTime(asn6);
}
}
}
}
}
// Token: 0x170000E5 RID: 229
// (get) Token: 0x060003FA RID: 1018 RVA: 0x0001A13C File Offset: 0x0001833C
public byte[] KeyIdentifier
{
get
{
if (this.keyId == null)
{
return null;
}
return (byte[])this.keyId.Clone();
}
}
// Token: 0x170000E6 RID: 230
// (get) Token: 0x060003FB RID: 1019 RVA: 0x0001A15C File Offset: 0x0001835C
public override string Name
{
get
{
return "Key Attributes";
}
}
// Token: 0x170000E7 RID: 231
// (get) Token: 0x060003FC RID: 1020 RVA: 0x0001A164 File Offset: 0x00018364
public DateTime NotAfter
{
get
{
return this.notAfter;
}
}
// Token: 0x170000E8 RID: 232
// (get) Token: 0x060003FD RID: 1021 RVA: 0x0001A16C File Offset: 0x0001836C
public DateTime NotBefore
{
get
{
return this.notBefore;
}
}
// Token: 0x060003FE RID: 1022 RVA: 0x0001A174 File Offset: 0x00018374
public bool Support(KeyUsages usage)
{
int num = Convert.ToInt32(usage, CultureInfo.InvariantCulture);
return (num & this.kubits) == num;
}
// Token: 0x060003FF RID: 1023 RVA: 0x0001A1A0 File Offset: 0x000183A0
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.keyId != null)
{
stringBuilder.Append("KeyID=");
for (int i = 0; i < this.keyId.Length; i++)
{
stringBuilder.Append(this.keyId[i].ToString("X2", CultureInfo.InvariantCulture));
if (i % 2 == 1)
{
stringBuilder.Append(" ");
}
}
stringBuilder.Append(Environment.NewLine);
}
if (this.kubits != 0)
{
stringBuilder.Append("Key Usage=");
if (this.Support(KeyUsages.digitalSignature))
{
stringBuilder.Append("Digital Signature");
}
if (this.Support(KeyUsages.nonRepudiation))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Non-Repudiation");
}
if (this.Support(KeyUsages.keyEncipherment))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Key Encipherment");
}
if (this.Support(KeyUsages.dataEncipherment))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Data Encipherment");
}
if (this.Support(KeyUsages.keyAgreement))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Key Agreement");
}
if (this.Support(KeyUsages.keyCertSign))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Certificate Signing");
}
if (this.Support(KeyUsages.cRLSign))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("CRL Signing");
}
if (this.Support(KeyUsages.encipherOnly))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Encipher Only ");
}
if (this.Support(KeyUsages.decipherOnly))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Decipher Only");
}
stringBuilder.Append("(");
stringBuilder.Append(this.kubits.ToString("X2", CultureInfo.InvariantCulture));
stringBuilder.Append(")");
stringBuilder.Append(Environment.NewLine);
}
if (this.notBefore != DateTime.MinValue)
{
stringBuilder.Append("Not Before=");
stringBuilder.Append(this.notBefore.ToString(CultureInfo.CurrentUICulture));
stringBuilder.Append(Environment.NewLine);
}
if (this.notAfter != DateTime.MinValue)
{
stringBuilder.Append("Not After=");
stringBuilder.Append(this.notAfter.ToString(CultureInfo.CurrentUICulture));
stringBuilder.Append(Environment.NewLine);
}
return stringBuilder.ToString();
}
// Token: 0x040001D4 RID: 468
private byte[] keyId;
// Token: 0x040001D5 RID: 469
private int kubits;
// Token: 0x040001D6 RID: 470
private DateTime notBefore;
// Token: 0x040001D7 RID: 471
private DateTime notAfter;
}
}
Mono.Security/Security/X509/Extensions/KeyUsageExtension.cs
+202
View File
@@ -0,0 +1,202 @@
using System;
using System.Globalization;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x0200006E RID: 110
public class KeyUsageExtension : X509Extension
{
// Token: 0x06000400 RID: 1024 RVA: 0x0001A4B0 File Offset: 0x000186B0
public KeyUsageExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x06000401 RID: 1025 RVA: 0x0001A4BC File Offset: 0x000186BC
public KeyUsageExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x06000402 RID: 1026 RVA: 0x0001A4C8 File Offset: 0x000186C8
public KeyUsageExtension()
{
this.extnOid = "2.5.29.15";
}
// Token: 0x06000403 RID: 1027 RVA: 0x0001A4DC File Offset: 0x000186DC
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 3)
{
throw new ArgumentException("Invalid KeyUsage extension");
}
int i = 1;
while (i < asn.Value.Length)
{
this.kubits = (this.kubits << 8) + (int)asn.Value[i++];
}
}
// Token: 0x06000404 RID: 1028 RVA: 0x0001A544 File Offset: 0x00018744
protected override void Encode()
{
this.extnValue = new ASN1(4);
ushort num = (ushort)this.kubits;
if (num > 0)
{
byte b;
for (b = 15; b > 0; b -= 1)
{
if ((num & 32768) == 32768)
{
break;
}
num = (ushort)(num << 1);
}
if (this.kubits > 255)
{
b -= 8;
this.extnValue.Add(new ASN1(3, new byte[]
{
b,
(byte)this.kubits,
(byte)(this.kubits >> 8)
}));
}
else
{
this.extnValue.Add(new ASN1(3, new byte[]
{
b,
(byte)this.kubits
}));
}
}
else
{
ASN1 extnValue = this.extnValue;
byte b2 = 3;
byte[] array = new byte[2];
array[0] = 7;
extnValue.Add(new ASN1(b2, array));
}
}
// Token: 0x170000E9 RID: 233
// (get) Token: 0x06000405 RID: 1029 RVA: 0x0001A634 File Offset: 0x00018834
// (set) Token: 0x06000406 RID: 1030 RVA: 0x0001A63C File Offset: 0x0001883C
public KeyUsages KeyUsage
{
get
{
return (KeyUsages)this.kubits;
}
set
{
this.kubits = Convert.ToInt32(value, CultureInfo.InvariantCulture);
}
}
// Token: 0x170000EA RID: 234
// (get) Token: 0x06000407 RID: 1031 RVA: 0x0001A654 File Offset: 0x00018854
public override string Name
{
get
{
return "Key Usage";
}
}
// Token: 0x06000408 RID: 1032 RVA: 0x0001A65C File Offset: 0x0001885C
public bool Support(KeyUsages usage)
{
int num = Convert.ToInt32(usage, CultureInfo.InvariantCulture);
return (num & this.kubits) == num;
}
// Token: 0x06000409 RID: 1033 RVA: 0x0001A688 File Offset: 0x00018888
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.Support(KeyUsages.digitalSignature))
{
stringBuilder.Append("Digital Signature");
}
if (this.Support(KeyUsages.nonRepudiation))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Non-Repudiation");
}
if (this.Support(KeyUsages.keyEncipherment))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Key Encipherment");
}
if (this.Support(KeyUsages.dataEncipherment))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Data Encipherment");
}
if (this.Support(KeyUsages.keyAgreement))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Key Agreement");
}
if (this.Support(KeyUsages.keyCertSign))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Certificate Signing");
}
if (this.Support(KeyUsages.cRLSign))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("CRL Signing");
}
if (this.Support(KeyUsages.encipherOnly))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Encipher Only ");
}
if (this.Support(KeyUsages.decipherOnly))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Decipher Only");
}
stringBuilder.Append("(");
stringBuilder.Append(this.kubits.ToString("X2", CultureInfo.InvariantCulture));
stringBuilder.Append(")");
stringBuilder.Append(Environment.NewLine);
return stringBuilder.ToString();
}
// Token: 0x040001E3 RID: 483
private int kubits;
}
}
Mono.Security/Security/X509/Extensions/KeyUsages.cs
+30
View File
@@ -0,0 +1,30 @@
using System;
namespace Mono.Security.X509.Extensions
{
// Token: 0x0200006D RID: 109
[Flags]
public enum KeyUsages
{
// Token: 0x040001D9 RID: 473
digitalSignature = 128,
// Token: 0x040001DA RID: 474
nonRepudiation = 64,
// Token: 0x040001DB RID: 475
keyEncipherment = 32,
// Token: 0x040001DC RID: 476
dataEncipherment = 16,
// Token: 0x040001DD RID: 477
keyAgreement = 8,
// Token: 0x040001DE RID: 478
keyCertSign = 4,
// Token: 0x040001DF RID: 479
cRLSign = 2,
// Token: 0x040001E0 RID: 480
encipherOnly = 1,
// Token: 0x040001E1 RID: 481
decipherOnly = 2048,
// Token: 0x040001E2 RID: 482
none = 0
}
}
Mono.Security/Security/X509/Extensions/NetscapeCertTypeExtension.cs
+146
View File
@@ -0,0 +1,146 @@
using System;
using System.Globalization;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x0200006F RID: 111
public class NetscapeCertTypeExtension : X509Extension
{
// Token: 0x0600040A RID: 1034 RVA: 0x0001A884 File Offset: 0x00018A84
public NetscapeCertTypeExtension()
{
this.extnOid = "2.16.840.1.113730.1.1";
}
// Token: 0x0600040B RID: 1035 RVA: 0x0001A898 File Offset: 0x00018A98
public NetscapeCertTypeExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x0600040C RID: 1036 RVA: 0x0001A8A4 File Offset: 0x00018AA4
public NetscapeCertTypeExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x0600040D RID: 1037 RVA: 0x0001A8B0 File Offset: 0x00018AB0
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 3)
{
throw new ArgumentException("Invalid NetscapeCertType extension");
}
int i = 1;
while (i < asn.Value.Length)
{
this.ctbits = (this.ctbits << 8) + (int)asn.Value[i++];
}
}
// Token: 0x170000EB RID: 235
// (get) Token: 0x0600040E RID: 1038 RVA: 0x0001A918 File Offset: 0x00018B18
public override string Name
{
get
{
return "NetscapeCertType";
}
}
// Token: 0x0600040F RID: 1039 RVA: 0x0001A920 File Offset: 0x00018B20
public bool Support(NetscapeCertTypeExtension.CertTypes usage)
{
int num = Convert.ToInt32(usage, CultureInfo.InvariantCulture);
return (num & this.ctbits) == num;
}
// Token: 0x06000410 RID: 1040 RVA: 0x0001A94C File Offset: 0x00018B4C
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.Support(NetscapeCertTypeExtension.CertTypes.SslClient))
{
stringBuilder.Append("SSL Client Authentication");
}
if (this.Support(NetscapeCertTypeExtension.CertTypes.SslServer))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("SSL Server Authentication");
}
if (this.Support(NetscapeCertTypeExtension.CertTypes.Smime))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("SMIME");
}
if (this.Support(NetscapeCertTypeExtension.CertTypes.ObjectSigning))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Object Signing");
}
if (this.Support(NetscapeCertTypeExtension.CertTypes.SslCA))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("SSL CA");
}
if (this.Support(NetscapeCertTypeExtension.CertTypes.SmimeCA))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("SMIME CA");
}
if (this.Support(NetscapeCertTypeExtension.CertTypes.ObjectSigningCA))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" , ");
}
stringBuilder.Append("Object Signing CA");
}
stringBuilder.Append("(");
stringBuilder.Append(this.ctbits.ToString("X2", CultureInfo.InvariantCulture));
stringBuilder.Append(")");
stringBuilder.Append(Environment.NewLine);
return stringBuilder.ToString();
}
// Token: 0x040001E4 RID: 484
private int ctbits;
// Token: 0x02000070 RID: 112
[Flags]
public enum CertTypes
{
// Token: 0x040001E6 RID: 486
SslClient = 128,
// Token: 0x040001E7 RID: 487
SslServer = 64,
// Token: 0x040001E8 RID: 488
Smime = 32,
// Token: 0x040001E9 RID: 489
ObjectSigning = 16,
// Token: 0x040001EA RID: 490
SslCA = 4,
// Token: 0x040001EB RID: 491
SmimeCA = 2,
// Token: 0x040001EC RID: 492
ObjectSigningCA = 1
}
}
}
Mono.Security/Security/X509/Extensions/PrivateKeyUsagePeriodExtension.cs
+89
View File
@@ -0,0 +1,89 @@
using System;
using System.Globalization;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x02000071 RID: 113
public class PrivateKeyUsagePeriodExtension : X509Extension
{
// Token: 0x06000411 RID: 1041 RVA: 0x0001AAE4 File Offset: 0x00018CE4
public PrivateKeyUsagePeriodExtension()
{
this.extnOid = "2.5.29.16";
}
// Token: 0x06000412 RID: 1042 RVA: 0x0001AAF8 File Offset: 0x00018CF8
public PrivateKeyUsagePeriodExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x06000413 RID: 1043 RVA: 0x0001AB04 File Offset: 0x00018D04
public PrivateKeyUsagePeriodExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x06000414 RID: 1044 RVA: 0x0001AB10 File Offset: 0x00018D10
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
for (int i = 0; i < asn.Count; i++)
{
byte tag = asn[i].Tag;
if (tag != 128)
{
if (tag != 129)
{
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
this.notAfter = ASN1Convert.ToDateTime(asn[i]);
}
else
{
this.notBefore = ASN1Convert.ToDateTime(asn[i]);
}
}
}
// Token: 0x170000EC RID: 236
// (get) Token: 0x06000415 RID: 1045 RVA: 0x0001ABC0 File Offset: 0x00018DC0
public override string Name
{
get
{
return "Private Key Usage Period";
}
}
// Token: 0x06000416 RID: 1046 RVA: 0x0001ABC8 File Offset: 0x00018DC8
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.notBefore != DateTime.MinValue)
{
stringBuilder.Append("Not Before: ");
stringBuilder.Append(this.notBefore.ToString(CultureInfo.CurrentUICulture));
stringBuilder.Append(Environment.NewLine);
}
if (this.notAfter != DateTime.MinValue)
{
stringBuilder.Append("Not After: ");
stringBuilder.Append(this.notAfter.ToString(CultureInfo.CurrentUICulture));
stringBuilder.Append(Environment.NewLine);
}
return stringBuilder.ToString();
}
// Token: 0x040001ED RID: 493
private DateTime notBefore;
// Token: 0x040001EE RID: 494
private DateTime notAfter;
}
}
Mono.Security/Security/X509/Extensions/SubjectAltNameExtension.cs
+105
View File
@@ -0,0 +1,105 @@
using System;
namespace Mono.Security.X509.Extensions
{
// Token: 0x02000072 RID: 114
public class SubjectAltNameExtension : X509Extension
{
// Token: 0x06000417 RID: 1047 RVA: 0x0001AC6C File Offset: 0x00018E6C
public SubjectAltNameExtension()
{
this.extnOid = "2.5.29.17";
this._names = new GeneralNames();
}
// Token: 0x06000418 RID: 1048 RVA: 0x0001AC8C File Offset: 0x00018E8C
public SubjectAltNameExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x06000419 RID: 1049 RVA: 0x0001AC98 File Offset: 0x00018E98
public SubjectAltNameExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x0600041A RID: 1050 RVA: 0x0001ACA4 File Offset: 0x00018EA4
public SubjectAltNameExtension(string[] rfc822, string[] dnsNames, string[] ipAddresses, string[] uris)
{
this._names = new GeneralNames(rfc822, dnsNames, ipAddresses, uris);
this.extnValue = new ASN1(4, this._names.GetBytes());
this.extnOid = "2.5.29.17";
}
// Token: 0x0600041B RID: 1051 RVA: 0x0001ACEC File Offset: 0x00018EEC
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid SubjectAltName extension");
}
this._names = new GeneralNames(asn);
}
// Token: 0x170000ED RID: 237
// (get) Token: 0x0600041C RID: 1052 RVA: 0x0001AD30 File Offset: 0x00018F30
public override string Name
{
get
{
return "Subject Alternative Name";
}
}
// Token: 0x170000EE RID: 238
// (get) Token: 0x0600041D RID: 1053 RVA: 0x0001AD38 File Offset: 0x00018F38
public string[] RFC822
{
get
{
return this._names.RFC822;
}
}
// Token: 0x170000EF RID: 239
// (get) Token: 0x0600041E RID: 1054 RVA: 0x0001AD48 File Offset: 0x00018F48
public string[] DNSNames
{
get
{
return this._names.DNSNames;
}
}
// Token: 0x170000F0 RID: 240
// (get) Token: 0x0600041F RID: 1055 RVA: 0x0001AD58 File Offset: 0x00018F58
public string[] IPAddresses
{
get
{
return this._names.IPAddresses;
}
}
// Token: 0x170000F1 RID: 241
// (get) Token: 0x06000420 RID: 1056 RVA: 0x0001AD68 File Offset: 0x00018F68
public string[] UniformResourceIdentifiers
{
get
{
return this._names.UniformResourceIdentifiers;
}
}
// Token: 0x06000421 RID: 1057 RVA: 0x0001AD78 File Offset: 0x00018F78
public override string ToString()
{
return this._names.ToString();
}
// Token: 0x040001EF RID: 495
private GeneralNames _names;
}
}
Mono.Security/Security/X509/Extensions/SubjectKeyIdentifierExtension.cs
+85
View File
@@ -0,0 +1,85 @@
using System;
using System.Globalization;
using System.Text;
namespace Mono.Security.X509.Extensions
{
// Token: 0x02000073 RID: 115
public class SubjectKeyIdentifierExtension : X509Extension
{
// Token: 0x06000422 RID: 1058 RVA: 0x0001AD88 File Offset: 0x00018F88
public SubjectKeyIdentifierExtension()
{
this.extnOid = "2.5.29.14";
}
// Token: 0x06000423 RID: 1059 RVA: 0x0001AD9C File Offset: 0x00018F9C
public SubjectKeyIdentifierExtension(ASN1 asn1)
: base(asn1)
{
}
// Token: 0x06000424 RID: 1060 RVA: 0x0001ADA8 File Offset: 0x00018FA8
public SubjectKeyIdentifierExtension(X509Extension extension)
: base(extension)
{
}
// Token: 0x06000425 RID: 1061 RVA: 0x0001ADB4 File Offset: 0x00018FB4
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 4)
{
throw new ArgumentException("Invalid SubjectKeyIdentifier extension");
}
this.ski = asn.Value;
}
// Token: 0x170000F2 RID: 242
// (get) Token: 0x06000426 RID: 1062 RVA: 0x0001ADF8 File Offset: 0x00018FF8
public override string Name
{
get
{
return "Subject Key Identifier";
}
}
// Token: 0x170000F3 RID: 243
// (get) Token: 0x06000427 RID: 1063 RVA: 0x0001AE00 File Offset: 0x00019000
public byte[] Identifier
{
get
{
if (this.ski == null)
{
return null;
}
return (byte[])this.ski.Clone();
}
}
// Token: 0x06000428 RID: 1064 RVA: 0x0001AE20 File Offset: 0x00019020
public override string ToString()
{
if (this.ski == null)
{
return null;
}
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < this.ski.Length; i++)
{
stringBuilder.Append(this.ski[i].ToString("X2", CultureInfo.InvariantCulture));
if (i % 2 == 1)
{
stringBuilder.Append(" ");
}
}
return stringBuilder.ToString();
}
// Token: 0x040001F0 RID: 496
private byte[] ski;
}
}