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: 0x0200000E RID: 14
|
|
public class ASN1
|
|
{
|
|
// Token: 0x06000079 RID: 121 RVA: 0x00004CA8 File Offset: 0x00002EA8
|
|
public ASN1()
|
|
: this(0, null)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600007A RID: 122 RVA: 0x00004CB4 File Offset: 0x00002EB4
|
|
public ASN1(byte tag)
|
|
: this(tag, null)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600007B RID: 123 RVA: 0x00004CC0 File Offset: 0x00002EC0
|
|
public ASN1(byte tag, byte[] data)
|
|
{
|
|
this.m_nTag = tag;
|
|
this.m_aValue = data;
|
|
}
|
|
|
|
// Token: 0x0600007C RID: 124 RVA: 0x00004CD8 File Offset: 0x00002ED8
|
|
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: 0x17000005 RID: 5
|
|
// (get) Token: 0x0600007D RID: 125 RVA: 0x00004D8C File Offset: 0x00002F8C
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
if (this.elist == null)
|
|
{
|
|
return 0;
|
|
}
|
|
return this.elist.Count;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000006 RID: 6
|
|
// (get) Token: 0x0600007E RID: 126 RVA: 0x00004DA8 File Offset: 0x00002FA8
|
|
public byte Tag
|
|
{
|
|
get
|
|
{
|
|
return this.m_nTag;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000007 RID: 7
|
|
// (get) Token: 0x0600007F RID: 127 RVA: 0x00004DB0 File Offset: 0x00002FB0
|
|
public int Length
|
|
{
|
|
get
|
|
{
|
|
if (this.m_aValue != null)
|
|
{
|
|
return this.m_aValue.Length;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000008 RID: 8
|
|
// (get) Token: 0x06000080 RID: 128 RVA: 0x00004DC8 File Offset: 0x00002FC8
|
|
// (set) Token: 0x06000081 RID: 129 RVA: 0x00004DF8 File Offset: 0x00002FF8
|
|
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: 0x06000082 RID: 130 RVA: 0x00004E14 File Offset: 0x00003014
|
|
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: 0x06000083 RID: 131 RVA: 0x00004E54 File Offset: 0x00003054
|
|
public bool Equals(byte[] asn1)
|
|
{
|
|
return this.CompareArray(this.GetBytes(), asn1);
|
|
}
|
|
|
|
// Token: 0x06000084 RID: 132 RVA: 0x00004E64 File Offset: 0x00003064
|
|
public bool CompareValue(byte[] value)
|
|
{
|
|
return this.CompareArray(this.m_aValue, value);
|
|
}
|
|
|
|
// Token: 0x06000085 RID: 133 RVA: 0x00004E74 File Offset: 0x00003074
|
|
public ASN1 Add(ASN1 asn1)
|
|
{
|
|
if (asn1 != null)
|
|
{
|
|
if (this.elist == null)
|
|
{
|
|
this.elist = new ArrayList();
|
|
}
|
|
this.elist.Add(asn1);
|
|
}
|
|
return asn1;
|
|
}
|
|
|
|
// Token: 0x06000086 RID: 134 RVA: 0x00004EAC File Offset: 0x000030AC
|
|
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: 0x06000087 RID: 135 RVA: 0x0000511C File Offset: 0x0000331C
|
|
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: 0x06000088 RID: 136 RVA: 0x00005184 File Offset: 0x00003384
|
|
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: 0x17000009 RID: 9
|
|
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: 0x0600008A RID: 138 RVA: 0x00005288 File Offset: 0x00003488
|
|
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: 0x0600008B RID: 139 RVA: 0x00005314 File Offset: 0x00003514
|
|
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: 0x0600008C RID: 140 RVA: 0x000053DC File Offset: 0x000035DC
|
|
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: 0x04000031 RID: 49
|
|
private byte m_nTag;
|
|
|
|
// Token: 0x04000032 RID: 50
|
|
private byte[] m_aValue;
|
|
|
|
// Token: 0x04000033 RID: 51
|
|
private ArrayList elist;
|
|
}
|
|
}
|