niko
390 lines
8.2 KiB
C#
390 lines
8.2 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace Mono.Security
|
|
{
|
|
// Token: 0x020000DA RID: 218
|
|
internal class ASN1
|
|
{
|
|
// Token: 0x06000ADA RID: 2778 RVA: 0x0002FF08 File Offset: 0x0002E108
|
|
public ASN1()
|
|
: this(0, null)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000ADB RID: 2779 RVA: 0x0002FF14 File Offset: 0x0002E114
|
|
public ASN1(byte tag)
|
|
: this(tag, null)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000ADC RID: 2780 RVA: 0x0002FF20 File Offset: 0x0002E120
|
|
public ASN1(byte tag, byte[] data)
|
|
{
|
|
this.m_nTag = tag;
|
|
this.m_aValue = data;
|
|
}
|
|
|
|
// Token: 0x06000ADD RID: 2781 RVA: 0x0002FF38 File Offset: 0x0002E138
|
|
public ASN1(byte[] data)
|
|
{
|
|
this.m_nTag = data[0];
|
|
int num = 0;
|
|
int num2 = (int)data[1];
|
|
if (num2 > 128)
|
|
{
|
|
num = num2 - 128;
|
|
num2 = 0;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
num2 *= 256;
|
|
num2 += (int)data[i + 2];
|
|
}
|
|
}
|
|
else if (num2 == 128)
|
|
{
|
|
throw new NotSupportedException("Undefined length encoding.");
|
|
}
|
|
this.m_aValue = new byte[num2];
|
|
Buffer.BlockCopy(data, 2 + num, this.m_aValue, 0, num2);
|
|
if ((this.m_nTag & 32) == 32)
|
|
{
|
|
int num3 = 2 + num;
|
|
this.Decode(data, ref num3, data.Length);
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700016E RID: 366
|
|
// (get) Token: 0x06000ADE RID: 2782 RVA: 0x0002FFEC File Offset: 0x0002E1EC
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
if (this.elist == null)
|
|
{
|
|
return 0;
|
|
}
|
|
return this.elist.Count;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700016F RID: 367
|
|
// (get) Token: 0x06000ADF RID: 2783 RVA: 0x00030008 File Offset: 0x0002E208
|
|
public byte Tag
|
|
{
|
|
get
|
|
{
|
|
return this.m_nTag;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000170 RID: 368
|
|
// (get) Token: 0x06000AE0 RID: 2784 RVA: 0x00030010 File Offset: 0x0002E210
|
|
public int Length
|
|
{
|
|
get
|
|
{
|
|
if (this.m_aValue != null)
|
|
{
|
|
return this.m_aValue.Length;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000171 RID: 369
|
|
// (get) Token: 0x06000AE1 RID: 2785 RVA: 0x00030028 File Offset: 0x0002E228
|
|
// (set) Token: 0x06000AE2 RID: 2786 RVA: 0x00030058 File Offset: 0x0002E258
|
|
public byte[] Value
|
|
{
|
|
get
|
|
{
|
|
if (this.m_aValue == null)
|
|
{
|
|
this.GetBytes();
|
|
}
|
|
return (byte[])this.m_aValue.Clone();
|
|
}
|
|
set
|
|
{
|
|
if (value != null)
|
|
{
|
|
this.m_aValue = (byte[])value.Clone();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000AE3 RID: 2787 RVA: 0x00030074 File Offset: 0x0002E274
|
|
private bool CompareArray(byte[] array1, byte[] array2)
|
|
{
|
|
bool flag = array1.Length == array2.Length;
|
|
if (flag)
|
|
{
|
|
for (int i = 0; i < array1.Length; i++)
|
|
{
|
|
if (array1[i] != array2[i])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000AE4 RID: 2788 RVA: 0x000300B4 File Offset: 0x0002E2B4
|
|
public bool Equals(byte[] asn1)
|
|
{
|
|
return this.CompareArray(this.GetBytes(), asn1);
|
|
}
|
|
|
|
// Token: 0x06000AE5 RID: 2789 RVA: 0x000300C4 File Offset: 0x0002E2C4
|
|
public bool CompareValue(byte[] value)
|
|
{
|
|
return this.CompareArray(this.m_aValue, value);
|
|
}
|
|
|
|
// Token: 0x06000AE6 RID: 2790 RVA: 0x000300D4 File Offset: 0x0002E2D4
|
|
public ASN1 Add(ASN1 asn1)
|
|
{
|
|
if (asn1 != null)
|
|
{
|
|
if (this.elist == null)
|
|
{
|
|
this.elist = new ArrayList();
|
|
}
|
|
this.elist.Add(asn1);
|
|
}
|
|
return asn1;
|
|
}
|
|
|
|
// Token: 0x06000AE7 RID: 2791 RVA: 0x0003010C File Offset: 0x0002E30C
|
|
public virtual byte[] GetBytes()
|
|
{
|
|
byte[] array = null;
|
|
if (this.Count > 0)
|
|
{
|
|
int num = 0;
|
|
ArrayList arrayList = new ArrayList();
|
|
foreach (object obj in this.elist)
|
|
{
|
|
ASN1 asn = (ASN1)obj;
|
|
byte[] bytes = asn.GetBytes();
|
|
arrayList.Add(bytes);
|
|
num += bytes.Length;
|
|
}
|
|
array = new byte[num];
|
|
int num2 = 0;
|
|
for (int i = 0; i < this.elist.Count; i++)
|
|
{
|
|
byte[] array2 = (byte[])arrayList[i];
|
|
Buffer.BlockCopy(array2, 0, array, num2, array2.Length);
|
|
num2 += array2.Length;
|
|
}
|
|
}
|
|
else if (this.m_aValue != null)
|
|
{
|
|
array = this.m_aValue;
|
|
}
|
|
int num3 = 0;
|
|
byte[] array3;
|
|
if (array != null)
|
|
{
|
|
int num4 = array.Length;
|
|
if (num4 > 127)
|
|
{
|
|
if (num4 <= 255)
|
|
{
|
|
array3 = new byte[3 + num4];
|
|
Buffer.BlockCopy(array, 0, array3, 3, num4);
|
|
num3 = 129;
|
|
array3[2] = (byte)num4;
|
|
}
|
|
else if (num4 <= 65535)
|
|
{
|
|
array3 = new byte[4 + num4];
|
|
Buffer.BlockCopy(array, 0, array3, 4, num4);
|
|
num3 = 130;
|
|
array3[2] = (byte)(num4 >> 8);
|
|
array3[3] = (byte)num4;
|
|
}
|
|
else if (num4 <= 16777215)
|
|
{
|
|
array3 = new byte[5 + num4];
|
|
Buffer.BlockCopy(array, 0, array3, 5, num4);
|
|
num3 = 131;
|
|
array3[2] = (byte)(num4 >> 16);
|
|
array3[3] = (byte)(num4 >> 8);
|
|
array3[4] = (byte)num4;
|
|
}
|
|
else
|
|
{
|
|
array3 = new byte[6 + num4];
|
|
Buffer.BlockCopy(array, 0, array3, 6, num4);
|
|
num3 = 132;
|
|
array3[2] = (byte)(num4 >> 24);
|
|
array3[3] = (byte)(num4 >> 16);
|
|
array3[4] = (byte)(num4 >> 8);
|
|
array3[5] = (byte)num4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
array3 = new byte[2 + num4];
|
|
Buffer.BlockCopy(array, 0, array3, 2, num4);
|
|
num3 = num4;
|
|
}
|
|
if (this.m_aValue == null)
|
|
{
|
|
this.m_aValue = array;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
array3 = new byte[2];
|
|
}
|
|
array3[0] = this.m_nTag;
|
|
array3[1] = (byte)num3;
|
|
return array3;
|
|
}
|
|
|
|
// Token: 0x06000AE8 RID: 2792 RVA: 0x0003037C File Offset: 0x0002E57C
|
|
protected void Decode(byte[] asn1, ref int anPos, int anLength)
|
|
{
|
|
while (anPos < anLength - 1)
|
|
{
|
|
byte b;
|
|
int num;
|
|
byte[] array;
|
|
this.DecodeTLV(asn1, ref anPos, out b, out num, out array);
|
|
if (b != 0)
|
|
{
|
|
ASN1 asn2 = this.Add(new ASN1(b, array));
|
|
if ((b & 32) == 32)
|
|
{
|
|
int num2 = anPos;
|
|
asn2.Decode(asn1, ref num2, num2 + num);
|
|
}
|
|
anPos += num;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000AE9 RID: 2793 RVA: 0x000303E4 File Offset: 0x0002E5E4
|
|
protected void DecodeTLV(byte[] asn1, ref int pos, out byte tag, out int length, out byte[] content)
|
|
{
|
|
tag = asn1[pos++];
|
|
length = (int)asn1[pos++];
|
|
if ((length & 128) == 128)
|
|
{
|
|
int num = length & 127;
|
|
length = 0;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
length = length * 256 + (int)asn1[pos++];
|
|
}
|
|
}
|
|
content = new byte[length];
|
|
Buffer.BlockCopy(asn1, pos, content, 0, length);
|
|
}
|
|
|
|
// Token: 0x17000172 RID: 370
|
|
public ASN1 this[int index]
|
|
{
|
|
get
|
|
{
|
|
ASN1 asn;
|
|
try
|
|
{
|
|
if (this.elist == null || index >= this.elist.Count)
|
|
{
|
|
asn = null;
|
|
}
|
|
else
|
|
{
|
|
asn = (ASN1)this.elist[index];
|
|
}
|
|
}
|
|
catch (ArgumentOutOfRangeException)
|
|
{
|
|
asn = null;
|
|
}
|
|
return asn;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000AEB RID: 2795 RVA: 0x000304E8 File Offset: 0x0002E6E8
|
|
public ASN1 Element(int index, byte anTag)
|
|
{
|
|
ASN1 asn;
|
|
try
|
|
{
|
|
if (this.elist == null || index >= this.elist.Count)
|
|
{
|
|
asn = null;
|
|
}
|
|
else
|
|
{
|
|
ASN1 asn2 = (ASN1)this.elist[index];
|
|
if (asn2.Tag == anTag)
|
|
{
|
|
asn = asn2;
|
|
}
|
|
else
|
|
{
|
|
asn = null;
|
|
}
|
|
}
|
|
}
|
|
catch (ArgumentOutOfRangeException)
|
|
{
|
|
asn = null;
|
|
}
|
|
return asn;
|
|
}
|
|
|
|
// Token: 0x06000AEC RID: 2796 RVA: 0x00030574 File Offset: 0x0002E774
|
|
public override string ToString()
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
stringBuilder.AppendFormat("Tag: {0} {1}", this.m_nTag.ToString("X2"), Environment.NewLine);
|
|
stringBuilder.AppendFormat("Length: {0} {1}", this.Value.Length, Environment.NewLine);
|
|
stringBuilder.Append("Value: ");
|
|
stringBuilder.Append(Environment.NewLine);
|
|
for (int i = 0; i < this.Value.Length; i++)
|
|
{
|
|
stringBuilder.AppendFormat("{0} ", this.Value[i].ToString("X2"));
|
|
if ((i + 1) % 16 == 0)
|
|
{
|
|
stringBuilder.AppendFormat(Environment.NewLine, new object[0]);
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x06000AED RID: 2797 RVA: 0x0003063C File Offset: 0x0002E83C
|
|
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: 0x040002D4 RID: 724
|
|
private byte m_nTag;
|
|
|
|
// Token: 0x040002D5 RID: 725
|
|
private byte[] m_aValue;
|
|
|
|
// Token: 0x040002D6 RID: 726
|
|
private ArrayList elist;
|
|
}
|
|
}
|