public static Stream PemToStream(string pemStr)
{
MemoryStream memoryStream = new MemoryStream(Asn1Util.PemToBytes(pemStr));
memoryStream.Position = 0L;
return((Stream)memoryStream);
}
public static Asn1Node Paste()
{
DataFormats.GetFormat(Asn1ClipboardData.asn1FormatName);
Asn1Node asn1Node1 = new Asn1Node();
IDataObject dataObject = Clipboard.GetDataObject();
byte[] data1 = (byte[])dataObject.GetData(Asn1ClipboardData.asn1FormatName);
if (data1 != null)
{
MemoryStream memoryStream = new MemoryStream(data1);
memoryStream.Position = 0L;
asn1Node1.LoadData((Stream)memoryStream);
}
else
{
string data2 = (string)dataObject.GetData(DataFormats.Text);
Asn1Node asn1Node2 = new Asn1Node();
if (Asn1Util.IsAsn1EncodedHexStr(data2))
{
byte[] bytes = Asn1Util.HexStrToBytes(data2);
asn1Node1.LoadData(bytes);
}
}
return(asn1Node1);
}
/// <summary>
/// Check if there is ASN.1 DER encoded data in the clipboard.
/// </summary>
/// <returns>true:Yes; false:No</returns>
public static bool IsDataReady()
{
bool retval = false;
try
{
IDataObject aRetrieveObj = Clipboard.GetDataObject();
byte[] aData = (byte[])aRetrieveObj.GetData(asn1FormatName);
if (aData != null)
{
retval = true;
}
else
{
string dataStr = (string)aRetrieveObj.GetData(DataFormats.Text);
if (Asn1Util.IsAsn1EncodedHexStr(dataStr))
{
retval = true;
}
}
}
catch
{
retval = false;
}
return(retval);
}
/// <summary>
/// Generate node text header. This method is used by GetNodeText to put heading.
/// </summary>
/// <param name="lineLen">Line length.</param>
/// <returns>Header string.</returns>
static public string GetNodeTextHeader(int lineLen)
{
string header = String.Format("Offset| Len |LenByte|\r\n");
header += "======+======+=======+" + Asn1Util.GenStr(lineLen + 10, '=') + "\r\n";
return(header);
}
public static byte[] HexStrToBytes(string hexStr)
{
hexStr = hexStr.Replace(" ", "");
hexStr = hexStr.Replace("\r", "");
hexStr = hexStr.Replace("\n", "");
hexStr = hexStr.ToUpper();
if (hexStr.Length % 2 != 0)
{
throw new Exception("Invalid Hex string: odd length.");
}
for (int index = 0; index < hexStr.Length; ++index)
{
if (!Asn1Util.IsValidHexDigits(hexStr[index]))
{
throw new Exception("Invalid Hex string: included invalid character [" + (object)hexStr[index] + "]");
}
}
int length = hexStr.Length / 2;
byte[] numArray = new byte[length];
for (int index = 0; index < length; ++index)
{
int num = (int)Asn1Util.GetHexDigitsVal(hexStr[index * 2]) << 4 | (int)Asn1Util.GetHexDigitsVal(hexStr[index * 2 + 1]);
numArray[index] = (byte)num;
}
return(numArray);
}
protected bool GeneralDecode(Stream xdata)
{
bool flag = false;
long num = xdata.Length - xdata.Position;
this.tag = (byte)xdata.ReadByte();
long position = xdata.Position;
this.dataLength = Asn1Util.DerLengthDecode(xdata, ref this.isIndefiniteLength);
if (this.dataLength < 0L)
{
return(flag);
}
this.lengthFieldBytes = xdata.Position - position;
if (num < this.dataLength + 1L + this.lengthFieldBytes || (this.ParentNode == null || ((int)this.ParentNode.tag & 32) == 0) && (((int)this.tag & 31) <= 0 || ((int)this.tag & 31) > 30))
{
return(flag);
}
if (this.tag == (byte)3)
{
if (this.dataLength < 1L)
{
return(flag);
}
this.unusedBits = (byte)xdata.ReadByte();
this.data = new byte[this.dataLength - 1L];
xdata.Read(this.data, 0, (int)(this.dataLength - 1L));
}
else
{
this.data = new byte[this.dataLength];
xdata.Read(this.data, 0, (int)this.dataLength);
}
return(true);
}
private string GetHexPrintingStr(
Asn1Node startNode,
string baseLine,
string lStr,
int lineLen)
{
string str1 = "";
string indentStr = this.GetIndentStr(startNode);
string hexString = Asn1Util.ToHexString(this.data);
string str2;
if (hexString.Length > 0)
{
if (baseLine.Length + hexString.Length < lineLen)
{
str2 = str1 + baseLine + "'" + hexString + "'";
}
else
{
str2 = str1 + baseLine + this.FormatLineHexString(lStr, indentStr.Length, lineLen, hexString);
}
}
else
{
str2 = str1 + baseLine;
}
return(str2 + "\r\n");
}
/// <summary>
/// Paste clipboard data as an Asn1Node. It try to get data from
/// Asn1NodeDataFormat first, then try Text data format.
/// </summary>
/// <returns>Asn1Node</returns>
public static Asn1Node Paste()
{
DataFormats.Format asn1Format = DataFormats.GetFormat(asn1FormatName);
Asn1Node retval = new Asn1Node();
IDataObject aRetrieveObj = Clipboard.GetDataObject();
byte[] aData = (byte[])aRetrieveObj.GetData(asn1FormatName);
if (aData != null)
{
MemoryStream ms = new MemoryStream(aData);
ms.Position = 0;
retval.LoadData(ms);
}
else
{
string dataStr = (string)aRetrieveObj.GetData(DataFormats.Text);
Asn1Node tmpNode = new Asn1Node();
if (Asn1Util.IsAsn1EncodedHexStr(dataStr))
{
byte[] data = Asn1Util.HexStrToBytes(dataStr);
retval.LoadData(data);
}
}
return(retval);
}
public bool SaveData(Stream xdata)
{
bool flag = true;
long childNodeCount = this.ChildNodeCount;
xdata.WriteByte(this.tag);
Asn1Util.DERLengthEncode(xdata, (ulong)this.dataLength);
if (this.tag == (byte)3)
{
xdata.WriteByte(this.unusedBits);
}
if (childNodeCount == 0L)
{
if (this.data != null)
{
xdata.Write(this.data, 0, this.data.Length);
}
}
else
{
for (int index = 0; (long)index < childNodeCount; ++index)
{
flag = this.GetChildNode(index).SaveData(xdata);
}
}
return(flag);
}
protected void EncodeValue(Stream bt, ulong v)
{
for (int index = (Asn1Util.BitPrecision(v) - 1) / 7; index > 0; --index)
{
bt.WriteByte((byte)(128UL | v >> index * 7 & (ulong)sbyte.MaxValue));
}
bt.WriteByte((byte)(v & (ulong)sbyte.MaxValue));
}
/// <summary>
/// Encode single OID value.
/// </summary>
/// <param name="bt">output stream.</param>
/// <param name="v">source value.</param>
protected void EncodeValue(Stream bt, ulong v)
{
for (int i = (Asn1Util.BitPrecision(v) - 1) / 7; i > 0; i--)
{
bt.WriteByte((byte)(0x80 | ((v >> (i * 7)) & 0x7f)));
}
bt.WriteByte((byte)(v & 0x7f));
}
protected static void ResetDataLengthFieldWidth(Asn1Node node)
{
MemoryStream memoryStream = new MemoryStream();
Asn1Util.DERLengthEncode((Stream)memoryStream, (ulong)node.dataLength);
node.lengthFieldBytes = memoryStream.Length;
memoryStream.Close();
}
public static bool IsPemFormated(string pemStr)
{
byte[] bytes;
try
{
bytes = Asn1Util.PemToBytes(pemStr);
}
catch
{
return(false);
}
return(bytes.Length > 0);
}
public static bool IsHexStr(string hexStr)
{
byte[] bytes;
try
{
bytes = Asn1Util.HexStrToBytes(hexStr);
}
catch
{
return(false);
}
return(bytes != null && bytes.Length >= 0);
}
public string GetDataStr(bool pureHexMode)
{
string str;
if (pureHexMode)
{
str = Asn1Util.FormatString(Asn1Util.ToHexString(this.data), 32, 2);
}
else
{
switch (this.tag)
{
case 2:
str = Asn1Util.FormatString(Asn1Util.ToHexString(this.data), 32, 2);
break;
case 3:
str = Asn1Util.FormatString(Asn1Util.ToHexString(this.data), 32, 2);
break;
case 6:
str = new Oid().Decode((Stream) new MemoryStream(this.data));
break;
case 12:
str = new UTF8Encoding().GetString(this.data);
break;
case 13:
str = new RelativeOid().Decode((Stream) new MemoryStream(this.data));
break;
case 18:
case 19:
case 22:
case 23:
case 24:
case 26:
case 27:
case 28:
case 30:
str = Asn1Util.BytesToString(this.data);
break;
default:
str = ((int)this.tag & 31) == 6 || Asn1Util.IsAsciiString(this.Data) ? Asn1Util.BytesToString(this.data) : Asn1Util.FormatString(Asn1Util.ToHexString(this.data), 32, 2);
break;
}
}
return(str);
}
public static string BytesToPem(byte[] data, string pemHeader)
{
if (pemHeader == null || pemHeader.Length < 1)
{
pemHeader = "ASN.1 Editor Generated PEM File";
}
if (pemHeader.Length > 0 && pemHeader[0] != ' ')
{
pemHeader = " " + pemHeader;
}
string str = Asn1Util.FormatString(Convert.ToBase64String(data), 64, 0);
return("-----BEGIN" + pemHeader + "-----\r\n" + str + "\r\n-----END" + pemHeader + "-----\r\n");
}
public static string GetPemFileHeader(string fileName)
{
try
{
FileStream fileStream = new FileStream(fileName, FileMode.Open);
byte[] numArray = new byte[fileStream.Length];
fileStream.Read(numArray, 0, numArray.Length);
fileStream.Close();
return(Asn1Util.GetPemHeader(Asn1Util.BytesToString(numArray)));
}
catch
{
return("");
}
}
public static bool IsPemFormatedFile(string fileName)
{
try
{
FileStream fileStream = new FileStream(fileName, FileMode.Open);
byte[] numArray = new byte[fileStream.Length];
fileStream.Read(numArray, 0, numArray.Length);
fileStream.Close();
return(Asn1Util.IsPemFormated(Asn1Util.BytesToString(numArray)));
}
catch
{
return(false);
}
}
public static void Copy(Asn1Node node)
{
DataFormats.GetFormat(Asn1ClipboardData.asn1FormatName);
MemoryStream memoryStream = new MemoryStream();
node.SaveData((Stream)memoryStream);
memoryStream.Position = 0L;
byte[] numArray = new byte[memoryStream.Length];
memoryStream.Read(numArray, 0, (int)memoryStream.Length);
memoryStream.Close();
DataObject dataObject = new DataObject();
dataObject.SetData(Asn1ClipboardData.asn1FormatName, (object)numArray);
dataObject.SetData(DataFormats.Text, (object)Asn1Util.FormatString(Asn1Util.ToHexString(numArray), 32, 2));
Clipboard.SetDataObject((object)dataObject, true);
}
/// <summary>
/// Retrieve PEM file heading.
/// </summary>
/// <param name="fileName">source file name.</param>
/// <returns>heading string.</returns>
public static string GetPemFileHeader(string fileName)
{
try
{
FileStream fs = new FileStream(fileName, FileMode.Open);
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
fs.Close();
string dataStr = Asn1Util.BytesToString(data);
return(GetPemHeader(dataStr));
}
catch
{
return("");
}
}
public static bool IsAsn1EncodedHexStr(string dataStr)
{
bool flag = false;
try
{
byte[] bytes = Asn1Util.HexStrToBytes(dataStr);
if (bytes.Length > 0)
{
flag = new Asn1Node().LoadData(bytes);
}
}
catch
{
flag = false;
}
return(flag);
}
public void LoadPemData(string fileName)
{
FileStream fileStream = new FileStream(fileName, FileMode.Open);
byte[] numArray = new byte[fileStream.Length];
fileStream.Read(numArray, 0, numArray.Length);
fileStream.Close();
string pemStr = Asn1Util.BytesToString(numArray);
if (!Asn1Util.IsPemFormated(pemStr))
{
throw new Exception("It is a invalid PEM file: " + fileName);
}
Stream stream = Asn1Util.PemToStream(pemStr);
stream.Position = 0L;
this.LoadData(stream);
}
/// <summary>
/// Copy Asn1Node data into clipboard as Asn1NodeDataFormat and Text format.
/// </summary>
/// <param name="node">Asn1Node</param>
public static void Copy(Asn1Node node)
{
DataFormats.Format asn1Format = DataFormats.GetFormat(asn1FormatName);
MemoryStream ms = new MemoryStream();
node.SaveData(ms);
ms.Position = 0;
byte[] ndata = new byte[ms.Length];
ms.Read(ndata, 0, (int)ms.Length);
ms.Close();
DataObject aDataObj = new DataObject();
aDataObj.SetData(asn1FormatName, ndata);
aDataObj.SetData(
DataFormats.Text,
Asn1Util.FormatString(Asn1Util.ToHexString(ndata), 32, 2));
Clipboard.SetDataObject(aDataObj, true);
}
/// <summary>
/// Check if a file is PEM formated.
/// </summary>
/// <param name="fileName">source file name.</param>
/// <returns>true:Yes, false:No.</returns>
public static bool IsPemFormatedFile(string fileName)
{
bool retval = false;
try
{
FileStream fs = new FileStream(fileName, System.IO.FileMode.Open);
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
fs.Close();
string dataStr = Asn1Util.BytesToString(data);
retval = IsPemFormated(dataStr);
}
catch
{
retval = false;
}
return(retval);
}
/// <summary>
/// Load PEM formated file.
/// </summary>
/// <param name="fileName">PEM file name.</param>
public void LoadPemData(string fileName)
{
FileStream fs = new FileStream(fileName, FileMode.Open);
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
fs.Close();
string dataStr = Asn1Util.BytesToString(data);
if (Asn1Util.IsPemFormated(dataStr))
{
Stream ms = Asn1Util.PemToStream(dataStr);
ms.Position = 0;
LoadData(ms);
}
else
{
throw new Exception("It is a invalid PEM file: " + fileName);
}
}
private string FormatLineString(string lStr, int indent, int lineLen, string msg)
{
string str = "";
indent += 3;
int length = lineLen - indent;
int len = indent;
for (int startIndex = 0; startIndex < msg.Length; startIndex += length)
{
if (startIndex + length > msg.Length)
{
str = str + "\r\n" + lStr + Asn1Util.GenStr(len, ' ') + "'" + msg.Substring(startIndex, msg.Length - startIndex) + "'";
}
else
{
str = str + "\r\n" + lStr + Asn1Util.GenStr(len, ' ') + "'" + msg.Substring(startIndex, length) + "'";
}
}
return(str);
}
public static bool IsDataReady()
{
bool flag = false;
try
{
IDataObject dataObject = Clipboard.GetDataObject();
if ((byte[])dataObject.GetData(Asn1ClipboardData.asn1FormatName) != null)
{
flag = true;
}
else if (Asn1Util.IsAsn1EncodedHexStr((string)dataObject.GetData(DataFormats.Text)))
{
flag = true;
}
}
catch
{
flag = false;
}
return(flag);
}
public static int DERLengthEncode(Stream xdata, ulong length)
{
int num1 = 0;
int num2;
if (length <= (ulong)sbyte.MaxValue)
{
xdata.WriteByte((byte)length);
num2 = num1 + 1;
}
else
{
xdata.WriteByte((byte)(Asn1Util.BytePrecision(length) | 128));
num2 = num1 + 1;
for (int index = Asn1Util.BytePrecision(length); index > 0; --index)
{
xdata.WriteByte((byte)(length >> (index - 1) * 8));
++num2;
}
}
return(num2);
}
protected bool ListDecode(Stream xdata)
{
bool flag = false;
long position1 = xdata.Position;
try
{
long num = xdata.Length - xdata.Position;
this.tag = (byte)xdata.ReadByte();
long position2 = xdata.Position;
this.dataLength = Asn1Util.DerLengthDecode(xdata, ref this.isIndefiniteLength);
if (this.dataLength < 0L || num < this.dataLength)
{
return(flag);
}
this.lengthFieldBytes = xdata.Position - position2;
long dataOffset = this.dataOffset + 1L + this.lengthFieldBytes;
if (this.tag == (byte)3)
{
this.unusedBits = (byte)xdata.ReadByte();
--this.dataLength;
++dataOffset;
}
if (this.dataLength <= 0L)
{
return(flag);
}
Stream xdata1 = (Stream) new MemoryStream((int)this.dataLength);
byte[] buffer = new byte[this.dataLength];
xdata.Read(buffer, 0, (int)this.dataLength);
if (this.tag == (byte)3)
{
++this.dataLength;
}
xdata1.Write(buffer, 0, buffer.Length);
xdata1.Position = 0L;
while (xdata1.Position < xdata1.Length)
{
Asn1Node xdata2 = new Asn1Node(this, dataOffset);
xdata2.parseEncapsulatedData = this.parseEncapsulatedData;
long position3 = xdata1.Position;
if (!xdata2.InternalLoadData(xdata1))
{
return(flag);
}
this.AddChild(xdata2);
long position4 = xdata1.Position;
dataOffset += position4 - position3;
}
flag = true;
return(flag);
}
finally
{
if (!flag)
{
xdata.Position = position1;
this.ClearAll();
}
}
}
public static string BytesToPem(byte[] data)
{
return(Asn1Util.BytesToPem(data, ""));
}
