/// <summary>
/// Search a Asn1Node in the sub tree of treeNode.
/// </summary>
/// <param name="treeNode">The sub tree node.</param>
/// <param name="node">The Asn1Node node.</param>
/// <returns></returns>
public static TreeNode SearchTreeNode(TreeNode treeNode, Asn1Node node)
{
TreeNode retval = null;
if (node == null)
{
return(retval);
}
if (((Asn1TreeNode)treeNode).ANode == node)
{
return(treeNode);
}
Asn1Node tmpTreeNode;
for (int i = 0; i < treeNode.Nodes.Count; i++)
{
tmpTreeNode = ((Asn1TreeNode)treeNode.Nodes[i]).ANode;
if (tmpTreeNode == node)
{
retval = treeNode.Nodes[i];
break;
}
retval = SearchTreeNode(treeNode.Nodes[i], node);
if (retval != null)
{
break;
}
}
return(retval);
}
public static TreeNode SearchTreeNode(TreeNode treeNode, Asn1Node node)
{
TreeNode treeNode1 = (TreeNode)null;
if (node == null)
{
return(treeNode1);
}
if (((Asn1TreeNode)treeNode).ANode == node)
{
return(treeNode);
}
for (int index = 0; index < treeNode.Nodes.Count; ++index)
{
if (((Asn1TreeNode)treeNode.Nodes[index]).ANode == node)
{
treeNode1 = treeNode.Nodes[index];
break;
}
treeNode1 = Asn1TreeNode.SearchTreeNode(treeNode.Nodes[index], node);
if (treeNode1 != null)
{
break;
}
}
return(treeNode1);
}
private Asn1Node(Asn1Node parentNode, long dataOffset)
{
this.Init();
this.deepness = parentNode.Deepness + 1L;
this.parentNode = parentNode;
this.dataOffset = dataOffset;
}
/// <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);
}
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");
}
protected static long ResetBranchDataLength(Asn1Node node)
{
long num = 0;
if (node.ChildNodeCount < 1L)
{
if (node.data != null)
{
num += (long)node.data.Length;
}
}
else
{
for (int index = 0; (long)index < node.ChildNodeCount; ++index)
{
num += Asn1Node.ResetBranchDataLength(node.GetChildNode(index));
}
}
node.dataLength = num;
if (node.tag == (byte)3)
{
++node.dataLength;
}
Asn1Node.ResetDataLengthFieldWidth(node);
return(node.dataLength + 1L + node.lengthFieldBytes);
}
/// <summary>
/// Generate node text description. It uses GetNodeTextHeader to generate
/// the heading and Asn1Node.GetText to generate the node text.
/// </summary>
/// <param name="node">Target node.</param>
/// <param name="lineLen">Line length.</param>
/// <returns>Text string.</returns>
public static string GetNodeText(Asn1Node node, int lineLen)
{
string nodeStr = GetNodeTextHeader(lineLen);
nodeStr += node.GetText(node, lineLen);
return(nodeStr);
}
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);
}
public Asn1Node GetDescendantNodeByPath(string nodePath)
{
Asn1Node asn1Node = this;
if (nodePath == null)
{
return(asn1Node);
}
nodePath = nodePath.TrimEnd().TrimStart();
if (nodePath.Length < 1)
{
return(asn1Node);
}
string[] strArray = nodePath.Split('/');
try
{
for (int index = 1; index < strArray.Length; ++index)
{
asn1Node = asn1Node.GetChildNode(Convert.ToInt32(strArray[index]));
}
}
catch
{
asn1Node = (Asn1Node)null;
}
return(asn1Node);
}
public int InsertChildAfter(Asn1Node xdata, int index)
{
int index1 = index + 1;
this.childNodeList.Insert(index1, (object)xdata);
this.RecalculateTreePar();
return(index1);
}
public int InsertChildAfter(Asn1Node xdata, Asn1Node indexNode)
{
int index = this.childNodeList.IndexOf((object)indexNode) + 1;
this.childNodeList.Insert(index, (object)xdata);
this.RecalculateTreePar();
return(index);
}
protected static void ResetDataLengthFieldWidth(Asn1Node node)
{
MemoryStream memoryStream = new MemoryStream();
Asn1Util.DERLengthEncode((Stream)memoryStream, (ulong)node.dataLength);
node.lengthFieldBytes = memoryStream.Length;
memoryStream.Close();
}
public Asn1Node GetChildNode(int index)
{
Asn1Node asn1Node = (Asn1Node)null;
if ((long)index < this.ChildNodeCount)
{
asn1Node = (Asn1Node)this.childNodeList[index];
}
return(asn1Node);
}
public static long GetDescendantNodeCount(Asn1Node node)
{
long num = 0L + node.ChildNodeCount;
for (int index = 0; (long)index < node.ChildNodeCount; ++index)
{
num += Asn1Node.GetDescendantNodeCount(node.GetChildNode(index));
}
return(num);
}
public Asn1Node Clone()
{
MemoryStream memoryStream = new MemoryStream();
this.SaveData((Stream)memoryStream);
memoryStream.Position = 0L;
Asn1Node asn1Node = new Asn1Node();
asn1Node.LoadData((Stream)memoryStream);
return(asn1Node);
}
protected string GetListStr(Asn1Node startNode, int lineLen)
{
string str = "";
for (int index = 0; index < this.childNodeList.Count; ++index)
{
Asn1Node childNode = (Asn1Node)this.childNodeList[index];
str += childNode.GetText(startNode, lineLen);
}
return(str);
}
/// <summary>
/// Get a node by path string.
/// </summary>
/// <param name="nodePath">Path string.</param>
/// <returns>Asn1Node or null.</returns>
public Asn1Node GetNodeByPath(string nodePath)
{
foreach (var rootNode in rootNodes)
{
Asn1Node r = rootNode.GetDescendantNodeByPath(nodePath);
if (r != null)
{
return(r);
}
}
return(null);
}
/// <summary>
/// Get a node by OID.
/// </summary>
/// <param name="oid">OID string.</param>
/// <returns>Asn1Node or null.</returns>
public Asn1Node GetNodeByOid(string oid)
{
foreach (var rootNode in rootNodes)
{
Asn1Node r = Asn1Node.GetDecendantNodeByOid(oid, rootNode);
if (r != null)
{
return(r);
}
}
return(null);
}
private void Init()
{
this.childNodeList = new ArrayList();
this.data = (byte[])null;
this.dataLength = 0L;
this.lengthFieldBytes = 0L;
this.unusedBits = (byte)0;
this.tag = (byte)48;
this.childNodeList.Clear();
this.deepness = 0L;
this.parentNode = (Asn1Node)null;
}
protected string GetIndentStr(Asn1Node startNode)
{
string str = "";
long num = 0;
if (startNode != null)
{
num = startNode.Deepness;
}
for (long index = 0; index < this.deepness - num; ++index)
{
str += " ";
}
return(str);
}
/// <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);
}
public Asn1Node RemoveChild(int index)
{
Asn1Node asn1Node = (Asn1Node)null;
if (index < this.childNodeList.Count - 1)
{
asn1Node = (Asn1Node)this.childNodeList[index + 1];
}
this.childNodeList.RemoveAt(index);
if (asn1Node == null)
{
asn1Node = this.childNodeList.Count <= 0 ? this : (Asn1Node)this.childNodeList[this.childNodeList.Count - 1];
}
this.RecalculateTreePar();
return(asn1Node);
}
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>
/// 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);
}
protected void ResetChildNodePar(Asn1Node xNode, long subOffset)
{
if (xNode.tag == (byte)3)
{
++subOffset;
}
for (int index = 0; (long)index < xNode.ChildNodeCount; ++index)
{
Asn1Node childNode = xNode.GetChildNode(index);
childNode.parentNode = xNode;
childNode.dataOffset = subOffset;
childNode.deepness = xNode.deepness + 1L;
childNode.path = xNode.path + (object)'/' + index.ToString();
subOffset += 1L + childNode.lengthFieldBytes;
this.ResetChildNodePar(childNode, subOffset);
subOffset += childNode.dataLength;
}
}
/// <summary>
/// Check if the string is ASN.1 encoded hex string.
/// </summary>
/// <param name="dataStr">The string.</param>
/// <returns>true:Yes, false:No.</returns>
public static bool IsAsn1EncodedHexStr(string dataStr)
{
bool retval = false;
try
{
byte[] data = HexStrToBytes(dataStr);
if (data.Length > 0)
{
Asn1Node node = new Asn1Node();
retval = node.LoadData(data);
}
}
catch
{
retval = false;
}
return retval;
}
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);
}
protected void RecalculateTreePar()
{
if (!this.requireRecalculatePar)
{
return;
}
Asn1Node asn1Node = this;
while (asn1Node.ParentNode != null)
{
asn1Node = asn1Node.ParentNode;
}
Asn1Node.ResetBranchDataLength(asn1Node);
asn1Node.dataOffset = 0L;
asn1Node.deepness = 0L;
long subOffset = asn1Node.dataOffset + 1L + asn1Node.lengthFieldBytes;
this.ResetChildNodePar(asn1Node, subOffset);
}
/// <summary>
/// Check if the string is ASN.1 encoded hex string.
/// </summary>
/// <param name="dataStr">The string.</param>
/// <returns>true:Yes, false:No.</returns>
public static bool IsAsn1EncodedHexStr(string dataStr)
{
bool retval = false;
try
{
byte[] data = HexStrToBytes(dataStr);
if (data.Length > 0)
{
Asn1Node node = new Asn1Node();
retval = node.LoadData(data);
}
}
catch
{
retval = false;
}
return(retval);
}
/// <summary>
/// Load ASN.1 encoded data from Stream.
/// </summary>
/// <param name="stream">Stream data.</param>
public void LoadData(Stream stream)
{
rootNodes.Clear();
stream.Position = 0;
while (stream.Position < stream.Length - 1)
{
Asn1Node rootNode = new Asn1Node(stream.Position);
if (!rootNode.LoadData(stream))
{
throw new Exception("Failed to load data.");
}
rootNodes.Add(rootNode);
}
rawData = new byte[stream.Length];
stream.Position = 0;
stream.Read(rawData, 0, rawData.Length);
}
public static Asn1Node GetDecendantNodeByOid(string oid, Asn1Node startNode)
{
Asn1Node asn1Node = (Asn1Node)null;
Oid oid1 = new Oid();
for (int index = 0; (long)index < startNode.ChildNodeCount; ++index)
{
Asn1Node childNode = startNode.GetChildNode(index);
if (((int)childNode.tag & 31) == 6 && oid == oid1.Decode(childNode.Data))
{
asn1Node = childNode;
break;
}
asn1Node = Asn1Node.GetDecendantNodeByOid(oid, childNode);
if (asn1Node != null)
{
break;
}
}
return(asn1Node);
}
/// <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 void SetText(Asn1Node node, int lineLen)
{
this.node = node;
this.lineLen = lineLen;
textBoxLineWidth.Text = lineLen.ToString();
string text = Asn1Parser.GetNodeText(node, lineLen);
richTextBox.Text = text;
}
/// <summary>
/// Use an Asn1Node and display label mask to construct an Asn1TreeNode.
/// Mask is defined in <see cref="Asn1Node.TagTextMask"/>.
/// </summary>
/// <param name="node">node.</param>
/// <param name="mask">mask <see cref="Asn1Node.TagTextMask"/>.</param>
public Asn1TreeNode(Asn1Node node, uint mask)
{
asn1Node = node;
this.Text = node.GetLabel(mask);
}
private void menuItem2_Click(object sender, System.EventArgs e)
{
menuItemBoldSelectedText.Checked = !menuItemBoldSelectedText.Checked;
SelectedNode = selectedNode;
}
/// <summary>
/// Remove the child from children node list.
/// </summary>
/// <param name="node">The node needs to be removed.</param>
/// <returns></returns>
public Asn1Node RemoveChild(Asn1Node node)
{
Asn1Node retval = null;
int i = childNodeList.IndexOf(node);
retval = RemoveChild(i);
return retval;
}
/// <summary>
/// Insert a node in the children list after the pointed node.
/// </summary>
/// <param name="xdata">Asn1Node</param>
/// <param name="indexNode">Index node.</param>
/// <returns>New node index.</returns>
public int InsertChildAfter(Asn1Node xdata, Asn1Node indexNode)
{
int index = childNodeList.IndexOf(indexNode)+1;
childNodeList.Insert(index, xdata);
RecalculateTreePar();
return index;
}
/// <summary>
/// Generate all the child text from childNodeList.
/// </summary>
/// <param name="startNode">Starting node.</param>
/// <param name="lineLen">Line length.</param>
/// <returns>Text string.</returns>
protected string GetListStr(Asn1Node startNode, int lineLen)
{
string nodeStr = "";
int i;
Asn1Node tempNode;
for (i=0; i<childNodeList.Count; i++)
{
tempNode = (Asn1Node) childNodeList[i];
nodeStr += tempNode.GetText(startNode, lineLen);
}
return nodeStr;
}
/// <summary>
/// Recursively set all the child parameters, except dataLength.
/// dataLength is set by ResetBranchDataLength.
/// </summary>
/// <param name="xNode">Starting node.</param>
/// <param name="subOffset">Starting node offset.</param>
protected void ResetChildNodePar(Asn1Node xNode, long subOffset)
{
int i;
if (xNode.tag == Asn1Tag.BIT_STRING)
{
subOffset++;
}
Asn1Node tempNode;
for (i=0; i<xNode.ChildNodeCount; i++)
{
tempNode = xNode.GetChildNode(i);
tempNode.parentNode = xNode;
tempNode.dataOffset = subOffset;
tempNode.deepness = xNode.deepness + 1;
tempNode.path = xNode.path + '/' + i.ToString();
subOffset += TagLength + tempNode.lengthFieldBytes;
ResetChildNodePar(tempNode, subOffset);
subOffset += tempNode.dataLength;
}
}
/// <summary>
/// Encode the node data length field and set lengthFieldBytes and dataLength.
/// </summary>
/// <param name="node">The node needs to be reset.</param>
protected static void ResetDataLengthFieldWidth(Asn1Node node)
{
MemoryStream tempStream = new MemoryStream();
Asn1Util.DERLengthEncode(tempStream, (ulong) node.dataLength);
node.lengthFieldBytes = tempStream.Length;
tempStream.Close();
}
/// <summary>
/// Recursively set all the node data length.
/// </summary>
/// <param name="node"></param>
/// <returns>node data length.</returns>
protected static long ResetBranchDataLength(Asn1Node node)
{
long retval = 0;
long childDataLength = 0;
if (node.ChildNodeCount < 1)
{
if (node.data != null)
childDataLength += node.data.Length;
}
else
{
for (int i=0; i<node.ChildNodeCount; i++)
{
childDataLength += ResetBranchDataLength(node.GetChildNode(i));
}
}
node.dataLength = childDataLength;
if (node.tag == Asn1Tag.BIT_STRING)
node.dataLength += BitStringUnusedFiledLength;
ResetDataLengthFieldWidth(node);
retval = node.dataLength + TagLength + node.lengthFieldBytes;
return retval;
}
/// <summary>
/// Get node by OID.
/// </summary>
/// <param name="oid">OID.</param>
/// <param name="startNode">Starting node.</param>
/// <returns>Null or Asn1Node.</returns>
static public Asn1Node GetDecendantNodeByOid(string oid, Asn1Node startNode)
{
Asn1Node retval = null;
Oid xoid = new Oid();
for (int i = 0; i<startNode.ChildNodeCount; i++)
{
Asn1Node childNode = startNode.GetChildNode(i);
int tmpTag = childNode.tag & Asn1Tag.TAG_MASK;
if (tmpTag == Asn1Tag.OBJECT_IDENTIFIER)
{
if (oid == xoid.Decode(childNode.Data))
{
retval = childNode;
break;
}
}
retval = GetDecendantNodeByOid(oid, childNode);
if (retval != null) break;
}
return retval;
}
/// <summary>
/// Generate node text description. It uses GetNodeTextHeader to generate
/// the heading and Asn1Node.GetText to generate the node text.
/// </summary>
/// <param name="node">Target node.</param>
/// <param name="lineLen">Line length.</param>
/// <returns>Text string.</returns>
public static string GetNodeText(Asn1Node node, int lineLen)
{
string nodeStr = GetNodeTextHeader(lineLen);
nodeStr +=node.GetText(node, lineLen);
return nodeStr;
}
public void SaveNodeAsPemFile(Asn1Node aNode, string fileName, string pemHeader)
{
MemoryStream ms = new MemoryStream();
aNode.SaveData(ms);
editingFileSize = (int)ms.Length;
ShowCurrentFileInfo();
byte[] bytes = new byte[ms.Length];
ms.Position = 0;
ms.Read(bytes, 0, bytes.Length);
ms.Close();
string pemStr = Asn1Util.BytesToPem(bytes, pemHeader);
FileStream fs = new FileStream(fileName, System.IO.FileMode.Create);
bytes = Asn1Util.StringToBytes(pemStr);
fs.Write(bytes, 0, bytes.Length);
fs.Close();
}
/// <summary>
/// Insert a node in the children list before the pointed index.
/// </summary>
/// <param name="xdata">Asn1Node</param>
/// <param name="index">0 based index.</param>
/// <returns>New node index.</returns>
public int InsertChild(Asn1Node xdata, int index)
{
childNodeList.Insert(index, xdata);
RecalculateTreePar();
return index;
}
/// <summary>
/// Generate the node indent string.
/// </summary>
/// <param name="startNode">The node.</param>
/// <returns>Text string.</returns>
protected string GetIndentStr(Asn1Node startNode)
{
string retval = "";
long startLen = 0;
if (startNode!=null)
{
startLen = startNode.Deepness;
}
for (long i = 0; i<deepness - startLen; i++)
{
retval += " ";
}
return retval;
}
/// <summary>
/// Insert a node in the children list after the pointed node.
/// </summary>
/// <param name="xdata">Asn1Node that will be instered in the children list.</param>
/// <param name="index">0 based index.</param>
/// <returns>New node index.</returns>
public int InsertChildAfter(Asn1Node xdata, int index)
{
int xindex = index+1;
childNodeList.Insert(xindex, xdata);
RecalculateTreePar();
return xindex;
}
/// <summary>
/// Decode ASN.1 encoded complex data type Stream data.
/// </summary>
/// <param name="xdata">Stream data.</param>
/// <returns>true:Succeed, false:Failed.</returns>
protected bool ListDecode(Stream xdata)
{
bool retval = false;
long originalPosition = xdata.Position;
long childNodeMaxLen;
try
{
childNodeMaxLen = xdata.Length - xdata.Position;
tag = (byte) xdata.ReadByte();
long start, end, offset;
start = xdata.Position;
dataLength = Asn1Util.DerLengthDecode(xdata, ref isIndefiniteLength);
if (dataLength<0 || childNodeMaxLen<dataLength)
{
return retval;
}
end = xdata.Position;
lengthFieldBytes = end - start;
offset = dataOffset + TagLength + lengthFieldBytes;
Stream secData;
byte[] secByte;
if (tag == Asn1Tag.BIT_STRING)
{
// First byte of BIT_STRING is unused bits.
// BIT_STRING data does not include this byte.
unusedBits = (byte) xdata.ReadByte();
dataLength--;
offset++;
}
if (dataLength <= 0) return retval; // List data length cann't be zero.
secData = new MemoryStream((int)dataLength);
secByte = new byte[dataLength];
xdata.Read(secByte, 0, (int) (dataLength));
if (tag == Asn1Tag.BIT_STRING) dataLength++;
secData.Write(secByte, 0, secByte.Length);
secData.Position = 0;
while(secData.Position<secData.Length)
{
Asn1Node node = new Asn1Node(this, offset);
node.parseEncapsulatedData = this.parseEncapsulatedData;
start = secData.Position;
if (!node.InternalLoadData(secData)) return retval;
AddChild(node);
end = secData.Position;
offset += end - start;
}
retval = true;
}
finally
{
if (!retval)
{
xdata.Position = originalPosition;
ClearAll();
}
}
return retval;
}
/// <summary>
/// Get the node and all the descendents text description.
/// </summary>
/// <param name="startNode">starting node.</param>
/// <param name="lineLen">line length.</param>
/// <returns></returns>
public string GetText(Asn1Node startNode, int lineLen)
{
string nodeStr = "";
string baseLine = "";
string dataStr = "";
const string lStr = " | | | ";
string oid, oidName;
switch (tag)
{
case Asn1Tag.BIT_STRING:
baseLine =
String.Format("{0,6}|{1,6}|{2,7}|{3} {4} UnusedBits:{5} : ",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName,
unusedBits
);
dataStr = Asn1Util.ToHexString(data);
if (baseLine.Length + dataStr.Length < lineLen)
{
if (dataStr.Length<1)
{
nodeStr += baseLine + "\r\n";
}
else
{
nodeStr += baseLine + "'" + dataStr + "'\r\n";
}
}
else
{
nodeStr += baseLine + FormatLineHexString(
lStr,
GetIndentStr(startNode).Length,
lineLen,
dataStr + "\r\n"
);
}
break;
case Asn1Tag.OBJECT_IDENTIFIER:
Oid xoid = new Oid();
oid = xoid.Decode(new MemoryStream(data));
oidName = xoid.GetOidName(oid);
nodeStr += String.Format("{0,6}|{1,6}|{2,7}|{3} {4} : {5} [{6}]\r\n",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName,
oidName,
oid
);
break;
case Asn1Tag.RELATIVE_OID:
RelativeOid xiod = new RelativeOid();
oid = xiod.Decode(new MemoryStream(data));
oidName = "";
nodeStr += String.Format("{0,6}|{1,6}|{2,7}|{3} {4} : {5} [{6}]\r\n",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName,
oidName,
oid
);
break;
case Asn1Tag.PRINTABLE_STRING:
case Asn1Tag.IA5_STRING:
case Asn1Tag.UNIVERSAL_STRING:
case Asn1Tag.VISIBLE_STRING:
case Asn1Tag.NUMERIC_STRING:
case Asn1Tag.UTC_TIME:
case Asn1Tag.UTF8_STRING:
case Asn1Tag.BMPSTRING:
case Asn1Tag.GENERAL_STRING:
case Asn1Tag.GENERALIZED_TIME:
baseLine =
String.Format("{0,6}|{1,6}|{2,7}|{3} {4} : ",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName
);
if ( tag == Asn1Tag.UTF8_STRING )
{
UTF8Encoding unicode = new UTF8Encoding();
dataStr = unicode.GetString(data);
}
else
{
dataStr = Asn1Util.BytesToString(data);
}
if (baseLine.Length + dataStr.Length < lineLen)
{
nodeStr += baseLine + "'" + dataStr + "'\r\n";
}
else
{
nodeStr += baseLine + FormatLineString(
lStr,
GetIndentStr(startNode).Length,
lineLen,
dataStr) + "\r\n";
}
break;
case Asn1Tag.INTEGER:
if (data != null && dataLength < 8)
{
nodeStr += String.Format("{0,6}|{1,6}|{2,7}|{3} {4} : {5}\r\n",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName,
Asn1Util.BytesToLong(data).ToString()
);
}
else
{
baseLine =
String.Format("{0,6}|{1,6}|{2,7}|{3} {4} : ",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName
);
nodeStr += GetHexPrintingStr(startNode, baseLine, lStr, lineLen);
}
break;
default:
if ((tag & Asn1Tag.TAG_MASK) == 6) // Visible string for certificate
{
baseLine =
String.Format("{0,6}|{1,6}|{2,7}|{3} {4} : ",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName
);
dataStr = Asn1Util.BytesToString(data);
if (baseLine.Length + dataStr.Length < lineLen)
{
nodeStr += baseLine + "'" + dataStr + "'\r\n";
}
else
{
nodeStr += baseLine + FormatLineString(
lStr,
GetIndentStr(startNode).Length,
lineLen,
dataStr) + "\r\n";
}
}
else
{
baseLine =
String.Format("{0,6}|{1,6}|{2,7}|{3} {4} : ",
dataOffset,
dataLength,
lengthFieldBytes,
GetIndentStr(startNode),
TagName
);
nodeStr += GetHexPrintingStr(startNode, baseLine, lStr, lineLen);
}
break;
};
if (childNodeList.Count >= 0)
{
nodeStr += GetListStr(startNode, lineLen);
}
return nodeStr;
}
private Asn1Node(Asn1Node parentNode, long dataOffset)
{
Init();
deepness = parentNode.Deepness + 1;
this.parentNode = parentNode;
this.dataOffset = dataOffset;
}
public new void Show()
{
this.Visible = true;
this.SelectedNode = selectedNode;
}
private void Init()
{
childNodeList = new ArrayList();
data = null;
dataLength = 0;
lengthFieldBytes = 0;
unusedBits = 0;
tag = Asn1Tag.SEQUENCE | Asn1TagClasses.CONSTRUCTED;
childNodeList.Clear();
deepness = 0;
parentNode = null;
}
private string GetHexPrintingStr(Asn1Node startNode, string baseLine,
string lStr, int lineLen)
{
string nodeStr = "";
string iStr = GetIndentStr(startNode);
string dataStr = Asn1Util.ToHexString(data);
if (dataStr.Length > 0)
{
if (baseLine.Length + dataStr.Length < lineLen)
{
nodeStr += baseLine + "'" + dataStr + "'";
}
else
{
nodeStr += baseLine + FormatLineHexString(
lStr,
iStr.Length,
lineLen,
dataStr
);
}
}
else
{
nodeStr += baseLine;
}
return nodeStr + "\r\n";
}
/// <summary>
/// Clone a new Asn1Node by current node.
/// </summary>
/// <returns>new node.</returns>
public Asn1Node Clone()
{
MemoryStream ms = new MemoryStream();
this.SaveData(ms);
ms.Position = 0;
Asn1Node node = new Asn1Node();
node.LoadData(ms);
return node;
}
/// <summary>
/// Search a Asn1Node in the sub tree of treeNode.
/// </summary>
/// <param name="treeNode">The sub tree node.</param>
/// <param name="node">The Asn1Node node.</param>
/// <returns></returns>
public static TreeNode SearchTreeNode(TreeNode treeNode, Asn1Node node)
{
TreeNode retval = null;
if (node == null) return retval;
if (((Asn1TreeNode)treeNode).ANode == node) return treeNode;
Asn1Node tmpTreeNode;
for (int i =0; i<treeNode.Nodes.Count; i++)
{
tmpTreeNode = ((Asn1TreeNode) treeNode.Nodes[i]).ANode;
if (tmpTreeNode == node)
{
retval = treeNode.Nodes[i];
break;
}
retval = SearchTreeNode(treeNode.Nodes[i], node);
if (retval != null)
break;
}
return retval;
}
/// <summary>
/// Retrieve all the node count in the node subtree.
/// </summary>
/// <param name="node">starting node.</param>
/// <returns>long integer node count in the node subtree.</returns>
public static long GetDescendantNodeCount(Asn1Node node)
{
long count =0;
count += node.ChildNodeCount;
for (int i=0; i<node.ChildNodeCount; i++)
{
count += GetDescendantNodeCount(node.GetChildNode(i));
}
return count;
}
/// <summary>
/// Use an Asn1Node and display label mask to construct an Asn1TreeNode.
/// Mask is defined in <see cref="Asn1Node.TagTextMask"/>.
/// </summary>
/// <param name="node">node.</param>
/// <param name="mask">mask <see cref="Asn1Node.TagTextMask"/>.</param>
public Asn1TreeNode(Asn1Node node, uint mask)
{
asn1Node = node;
this.Text = node.GetLabel(mask);
}
/// <summary>
/// Add child node at the end of children list.
/// </summary>
/// <param name="xdata">the node that will be add in.</param>
public void AddChild(Asn1Node xdata)
{
childNodeList.Add(xdata);
RecalculateTreePar();
}
public static bool EditNode(IWin32Window parent, Asn1Node aNode, bool enableTagEdit, bool pureHexMode)
{
byte[] val;
byte[] data;
FormNodeContentEditor ed = new FormNodeContentEditor();
ed.aNode = aNode;
MemoryStream ms = new MemoryStream();
ed.checker = FormNodeContentEditor.DataChecker.None;
ed.enableTagEdit = enableTagEdit;
ed.pureHexMode = pureHexMode;
if (
((aNode.Tag&Asn1Tag.TAG_MASK) == Asn1Tag.BIT_STRING) &&
(aNode.ChildNodeCount<1))
{
ed.panelUnusedBits.Visible = true;
ed.textBoxUnusedBits.Text = aNode.UnusedBits.ToString();
}
else
{
ed.panelUnusedBits.Visible = false;
}
if (pureHexMode)
{
ed.checker = DataChecker.Hex;
ed.ShowDialog(parent);
if (!ed.isOK) return false;
data = Asn1Util.HexStrToBytes(ed.GetValueStr());
aNode.Data = data;
}
else
{
byte[] oidVal;
switch (aNode.Tag)
{
case Asn1Tag.OBJECT_IDENTIFIER:
ed.checker = DataChecker.Oid;
ed.ShowDialog(parent);
if (!ed.isOK) return false;
Oid xoid = new Oid();
xoid.Encode(ms, ed.GetValueStr());
ms.Position = 0;
oidVal = new byte[ms.Length];
ms.Read(oidVal, 0, (int)ms.Length);
ms.Close();
aNode.Data = oidVal;
break;
case Asn1Tag.RELATIVE_OID:
ed.checker = DataChecker.Roid;
ed.ShowDialog(parent);
if (!ed.isOK) return false;
RelativeOid roid = new RelativeOid();
roid.Encode(ms, ed.GetValueStr());
ms.Position = 0;
oidVal = new byte[ms.Length];
ms.Read(oidVal, 0, (int)ms.Length);
ms.Close();
aNode.Data = oidVal;
break;
case Asn1Tag.PRINTABLE_STRING:
case Asn1Tag.IA5_STRING:
case Asn1Tag.UNIVERSAL_STRING:
case Asn1Tag.VISIBLE_STRING:
case Asn1Tag.NUMERIC_STRING:
case Asn1Tag.UTC_TIME:
case Asn1Tag.GENERAL_STRING:
case Asn1Tag.GENERALIZED_TIME:
ed.ShowDialog(parent);
if (!ed.isOK) return false;
val = Asn1Util.StringToBytes(ed.GetValueStr());
aNode.Data = val;
break;
case Asn1Tag.UTF8_STRING:
ed.ShowDialog(parent);
if (!ed.isOK) return false;
UTF8Encoding u8 = new UTF8Encoding(false);
val = u8.GetBytes(ed.GetValueStr());
aNode.Data = val;
break;
case Asn1Tag.BMPSTRING:
ed.ShowDialog(parent);
if (!ed.isOK) return false;
byte[] tmpval = Asn1Util.StringToBytes(ed.GetValueStr());
val = new byte[tmpval.Length*2];
for (int i = 0; i<tmpval.Length; i++)
{
val[i*2] = 0;
val[i*2+1] = tmpval[i];
}
aNode.Data = val;
break;
case Asn1Tag.INTEGER:
case Asn1Tag.BIT_STRING:
ed.checker = DataChecker.Hex;
ed.ShowDialog(parent);
if (!ed.isOK) return false;
aNode.UnusedBits = (byte)(Convert.ToUInt16(ed.textBoxUnusedBits.Text)%8);
data = Asn1Util.HexStrToBytes(ed.GetValueStr());
aNode.Data = data;
break;
default:
if ((aNode.Tag & Asn1Tag.TAG_MASK) == 6) // Visible string for certificate
{
ed.ShowDialog(parent);
if (!ed.isOK) return false;
val = Asn1Util.StringToBytes(ed.GetValueStr());
aNode.Data = val;
}
else
{
ed.checker = DataChecker.Hex;
ed.ShowDialog(parent);
if (!ed.isOK) return false;
data = Asn1Util.HexStrToBytes(ed.GetValueStr());
aNode.Data = data;
}
break;
};
}
return true;
}
private void RefreshView()
{
SetButtons();
if (menuItemCompact.Checked)
this.Width = compactWidth;
else
this.Width = detailWidth;
SetParentForm();
try
{
richTextBox.Visible = false;
RootNode = rootNode;
richTextBox.Visible = false;
SelectedNode = selectedNode;
}
finally
{
richTextBox.Visible = true;
}
}
