public static List <IO2Finding> createO2FindingsFromCirFunction(ICirFunction cirFunction, bool createNewFindingOnExternalCall)
{
var o2FindingsCreated = new List <IO2Finding>();
var filteredSignature = new FilteredSignature(cirFunction);
var functionSignature = filteredSignature.sSignature;
var rootO2Finding = new O2Finding
{
method = cirFunction.ClassNameFunctionNameAndParameters,
vulnName = functionSignature,
vulnType = "O2.CirGeneratedTrace",
severity = 2,
confidence = 2,
file = cirFunction.File
};
if (cirFunction.File != null)
{
UInt32 lineNumber;
if (UInt32.TryParse(cirFunction.FileLine, out lineNumber))
{
rootO2Finding.lineNumber = lineNumber;
}
}
createTracesAndFindingsFromCirFunction(cirFunction, rootO2Finding.file, rootO2Finding.lineNumber, rootO2Finding.o2Traces, new List <IO2Trace>(), rootO2Finding, o2FindingsCreated, createNewFindingOnExternalCall);
// make the first trace a Source
rootO2Finding.o2Traces[0].traceType = TraceType.Source;
// and add it to the list of Findings Created
o2FindingsCreated.Add(rootO2Finding);
return(o2FindingsCreated);
}
private static void mapMethods(method[] methodsToMap, string javaClassName, SpringMvcController controllerForCurrentClass, List <SpringMvcController> springMvcControllers, string fileName)
{
if (methodsToMap != null)
{
foreach (var methodToMap in methodsToMap)
{
var mappedController = getRequestMapping(methodToMap);
if (mappedController != null) // || controllerForCurrentClass != null)
{
if (mappedController.HttpRequestUrl == null && controllerForCurrentClass != null)
{
mappedController.HttpRequestUrl = controllerForCurrentClass.HttpRequestUrl;
}
mappedController.JavaClass = javaClassName;
mappedController.JavaFunction = (FilteredSignature.createFilteredSignatureFromJavaMethod(mappedController.JavaClass, methodToMap.name, methodToMap.descriptor).sFunctionNameAndParamsAndReturnClass);
mappedController.JavaClassAndFunction = string.Format("{0}.{1}", mappedController.JavaClass, mappedController.JavaFunction);
mappedController.AutoWiredJavaObjects = getAutoWiredJavaObjects(methodToMap);
mappedController.FileName = fileName;
mappedController.LineNumber = (uint)methodToMap.lineNumber;
springMvcControllers.Add(mappedController);
}
//springMvcController.URL = ;
//methodToMap.attribute
// methodToMap.SpringMvcMapping
}
}
}
public static void mapMethodsToFilteredSignatures(List <MethodInfo> methodsToMap, ref List <FilteredSignature> filteredSignatures, ref Dictionary <string, MethodInfo> methods_bySignature, bool hideCSharpGeneratedMethods)
{
filteredSignatures = new List <FilteredSignature>();
methods_bySignature = new Dictionary <string, MethodInfo>();
foreach (var method in methodsToMap)
{
var filteredSignature = new FilteredSignature(method);
if (hideCSharpGeneratedMethods == false || (filteredSignature.sSignature.IndexOf("<>") == -1 &&
false == filteredSignature.sFunctionName.StartsWith("b__")))
{
filteredSignatures.Add(filteredSignature);
// create methodsLoaded_bySignature
if (methods_bySignature.ContainsKey(filteredSignature.sSignature))
{
PublicDI.log.error("in mapMethodsToFilteredSignatures, repeated signature: {0}", filteredSignature.sSignature);
}
else
{
methods_bySignature.Add(filteredSignature.sSignature, method);
}
}
else
{
//PublicDI.log.info("Skipping: {0}", method.Name);
}
}
}
public ICirFunction getCirFunctionFromSelectedItem(object selectedItem)
{
if (selectedItem != null && selectedItem is FilteredSignature)
{
var filteredSignature = (FilteredSignature)selectedItem;
var functionSignature = filteredSignature.sOriginalSignature;
if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(functionSignature))
{
return(cirDataAnalysis.dCirFunction_bySignature[functionSignature]);
}
// if we could not find using the originalSignature, try the signature
foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values)
{
var s = new FilteredSignature(cirFunction).sSignature;
var d = filteredSignature.sSignature;
if (new FilteredSignature(cirFunction).sSignature == filteredSignature.sSignature)
{
return(cirFunction);
}
if (cirFunction.FunctionName == filteredSignature.sFunctionName)
{
}
}
}
return(null);
}
public void showSpringMvcClases(List <String> lsClasses, CirData fadCirData)
{
tvSpringMvcClasses.Nodes.Clear();
foreach (String sClass in lsClasses)
{
ICirClass ccCirClass = fadCirData.dClasses_bySignature[sClass];
var tnClass = new TreeNode(ccCirClass.Signature);
foreach (CirFunction cfCirFunction in ccCirClass.dFunctions.Values)
{
var fsSignature = new FilteredSignature(cfCirFunction.FunctionSignature);
var tnFunction = new TreeNode(fsSignature.sFunctionNameAndParams);
foreach (String sFunctionCalled in ViewHelpers.getCirFunctionStringList(cfCirFunction.FunctionsCalledUniqueList))
{
var tnFunctionCalled = new TreeNode(sFunctionCalled);
//if (sFunctionCalled.IndexOf("setCommandName") > -1)
String sCommandNameValue = getValueFromControlFlowGraphCall(cfCirFunction.lcfgBasicBlocks,
sFunctionCalled);
if (sCommandNameValue != "")
{
tnFunctionCalled.Nodes.Add(sCommandNameValue);
}
tnFunction.Nodes.Add(tnFunctionCalled);
}
tnClass.Nodes.Add(tnFunction);
}
tvSpringMvcClasses.Nodes.Add(tnClass);
}
}
public static void mapJavaAttributesToTraces(IO2Assessment o2Assessment, Dictionary <string, string> attributesXmlFiles)
{
DI.log.debug("Mapping Java Attributes to Traces");
//var testFindings = from O2Finding finding in o2Assessment.o2Findings where finding.Source.Contains("BugController") select (IO2Finding)finding;
//var testFindings = o2Assessment.o2Findings;
DI.log.debug("There are {0} findings to process", o2Assessment.o2Findings.Count());
foreach (O2Finding finding in o2Assessment.o2Findings)
{
var filteredSignature = new FilteredSignature(finding.Source);
var className = filteredSignature.sFunctionClass;
var fileToFind = string.Format("{0}.class.JavaAttributes.xml", className.Replace(".", "\\"));
if (attributesXmlFiles.ContainsKey(fileToFind))
{
mapJavaAttributesToFinding(finding, attributesXmlFiles[fileToFind]);
}
//DI.log.info("Found: {0} - > {1}", fileToFind , attributesXmlFiles[fileToFind]);
//else
// DI.log.error("could NOT find Xml Attribute file for: {0}", fileToFind);
//DI.log.info(fileToFind);
}
//var findingsWithSpringMVCControllersAsSources = new List<IO2Finding>();
// save temp assessment file
// var o2FindingsOfTypeO2SpringMvcController = (from o2Finding in o2Assessment.o2Findings where o2Finding.vulnType == "O2.SpringMvc.Controller" select o2Finding).ToList();
// DI.log.debug("There are {0} o2FindingsOfTypeO2SpringMvcController");
/* O2.Views.ASCX.O2Findings.ascx_FindingsViewer.openInFloatWindow(o2FindingsOfTypeO2SpringMvcController);
* saveFindingsInNewO2AssessmentFile(o2FindingsOfTypeO2SpringMvcController, pathToOzasmtFile + "_SpringMvcController.ozasmt");
* */
}
public void executeAction_onFunctionSelect(Node nSelectedNode)
{
if (rbOnFunctionSelect_Show.Checked)
{
Int32 iNameSpaceDepth;
Int32.TryParse(cBoxShowFunctionClass_Depth.Text, out iNameSpaceDepth);
nSelectedNode.NodeAttribute.Label = FilteredSignature.filterSignature(nSelectedNode.Id,
cbGLEE_ShowParameters.Checked,
cbGLEE_ShowReturnClass.Checked,
cbGLEE_ShowNamespace.Checked,
iNameSpaceDepth);
nSelectedNode.NodeAttribute.Shape = Shape.Box;
}
else if (rbOnFunctionSelect_Clear.Checked)
{
O2Graph.makeEmptyNode(nSelectedNode);
}
else if (rbOnFunctionSelect_Remove.Checked)
{
O2Graph.deleteNodeFromGraph(fgdGraphData, nSelectedNode, true);
}
else if (rbOnFunctionSelect_HighlightAllCalls_To.Checked)
{
applyFiltersToGraph(fgdGraphData.gGraph, true);
highlighCallsToNode_Recursive(nSelectedNode);
highlighCallsFromNode_Recursive(nSelectedNode);
}
else
{
}
//else if (rbOnFunctionSelect_SClear.Checked)
/*
*/
}
public static void onlyShowNodesContainingClass(Graph gGraph, String sStringClass)
{
if (sStringClass == "")
{
return;
}
foreach (Node nNode in gGraph.Nodes)
{
if (false == FilteredSignature.isSignatureCached(nNode.Id))
{
DI.log.error(
"in onlyShowNodesContainingClass, dFilteredFuntionSignatures did not contain the signature: {0}",
nNode.Id);
}
else
{
FilteredSignature fFilteredSignature = FilteredSignature.getFromCache(nNode.Id);
if (fFilteredSignature.getClassName(0).IndexOf(sStringClass) == -1)
{
if (false == isNodeASourceOrSink(nNode)) // Don't remove sources or sinks
{
makeEmptyNode(nNode);
}
}
//nNode.NodeAttribute.Label = "TO REMOVE";
// DI.log.debug("{0} : {1}", fFilteredSignature.getClassName(0), nNode.Id);
}
}
}
public static List <String> getListWithWordsFromSignature(string signature)
{
var filteredSignature = new FilteredSignature(signature);
List <string> wordsFromSignature = filteredSignature.lsFunctionClass_Parsed; // words in namespace & class
wordsFromSignature.Add(filteredSignature.sFunctionName); // also add the method name
return(wordsFromSignature);
}
public CirFunction(string functionSignature) : this()
{
FunctionSignature = functionSignature;
var filteredSignature = new FilteredSignature(FunctionSignature);
FunctionName = filteredSignature.sFunctionName;
FunctionNameAndParameters = filteredSignature.sFunctionNameAndParams;
ClassNameFunctionNameAndParameters = filteredSignature.sFunctionClass + "." + filteredSignature.sFunctionNameAndParams;
ReturnType = filteredSignature.sReturnClass;
}
public static void addVelocityMappings(TreeView tvRawData)
{
String sFunctionSignature = "ModelMap.addAttribute";
O2Timer tTimer = new O2Timer("Adding Velocity Mappings : {0} ").start();
Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6> dMatches =
analyzer.getSinksFindingsThatMatchRegEx(tvRawData, sFunctionSignature);
foreach (AssessmentAssessmentFileFinding fFinding in dMatches.Keys)
{
// resolve addAddtibute name
String sSinkContext = AnalysisUtils.getSinkContext(fFinding, dMatches[fFinding]);
var fsFilteredSignature = new FilteredSignature(sSinkContext);
String sParameters = fsFilteredSignature.sParameters.Replace("\"", "");
String sSpringParameter = sParameters.Substring(0, sParameters.IndexOf(',')).Trim();
// create a unique name for it:
String sSink = AnalysisUtils.getSink(fFinding, dMatches[fFinding]);
// String sSinkWithAttributeName = sSink.Replace("(", "_" + sSpringParameter + "(");
String sVelocityMapping = String.Format("{0} 0", sSink);
TreeNode tnVelocityNode = tvRawData.Nodes[sSink];
if (tnVelocityNode != null)
{
var otbO2TraceBlockWithVelocityMappings = (O2TraceBlock_OunceV6)tnVelocityNode.Tag;
String sUniqueSignature = analyzer.getUniqueSignature(fFinding, TraceType.Known_Sink,
dMatches[fFinding], true);
var otbO2TraceBlockToAddVelocityMappings = (O2TraceBlock_OunceV6)tvRawData.Nodes[sUniqueSignature].Tag;
// sUniqueSignature = sUniqueSignature.Replace("_" + sSpringParameter + "(", "(");
// O2TraceBlock_OunceV6 otbO2TraceBlockToAddVelocityMappings = (O2TraceBlock_OunceV6)tvRawData.Nodes[sUniqueSignature].Tag;
if (otbO2TraceBlockWithVelocityMappings.dSinks.Count > 1)
{
}
foreach (
AssessmentAssessmentFileFinding fVelocityFinding in
otbO2TraceBlockWithVelocityMappings.dSinks.Keys)
{
if (false == otbO2TraceBlockToAddVelocityMappings.dGluedSinks.ContainsKey(fVelocityFinding))
{
otbO2TraceBlockToAddVelocityMappings.dGluedSinks.Add(fVelocityFinding,
otbO2TraceBlockWithVelocityMappings
.dSinks[fVelocityFinding]);
}
if (false == otbO2TraceBlockToAddVelocityMappings.dSinks.ContainsKey(fVelocityFinding))
{
otbO2TraceBlockToAddVelocityMappings.dSinks.Add(fVelocityFinding,
otbO2TraceBlockWithVelocityMappings.
dSinks[fVelocityFinding]);
}
}
}
}
}
public override string ToString()
{
String sStringToFilter = Signature;
const bool bShowParameters = true;
const bool bShowReturnClass = false;
const bool bShowNamespace = false;
const int iNamespaceDepth = 1;
return(FilteredSignature.filterSignature(sStringToFilter, bShowParameters, bShowReturnClass, bShowNamespace,
iNamespaceDepth));
}
public void showSignatures(List <FilteredSignature> filteredSignatures)
{
var signaturesToShow = new List <String>();
// get them all in one collection
var filteredSignaturesAsStrings = new List <String>();
foreach (var filteredSignature in filteredSignatures)
{
filteredSignaturesAsStrings.Add(filteredSignature.sOriginalSignature);
}
// now search for them on all loaded CirFunctions
foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values)
{
var cirFunctionFilteredSignature = new FilteredSignature(cirFunction);
if (filteredSignaturesAsStrings.Contains(cirFunctionFilteredSignature.sOriginalSignature))
{
signaturesToShow.Add(cirFunction.FunctionSignature);
filteredSignaturesAsStrings.Remove(cirFunctionFilteredSignature.sOriginalSignature);
}
if (filteredSignaturesAsStrings.Contains(cirFunctionFilteredSignature.sSignature))
{
signaturesToShow.Add(cirFunction.FunctionSignature);
filteredSignaturesAsStrings.Remove(cirFunctionFilteredSignature.sSignature);
}
}
/* foreach (var filteredSignature in filteredSignatures)
* {
* if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(filteredSignature.sOriginalSignature))
* signaturesToShow.Add(filteredSignature.sOriginalSignature);
* else
*
* DI.log.error("dropped signature is currently not loaded: {0}", filteredSignature);
* }*/
if (filteredSignaturesAsStrings.Count > 0)
{
DI.log.error("There were {0} dropped signatures that could not be resolved", filteredSignaturesAsStrings.Count);
foreach (var signatureNotFound in filteredSignaturesAsStrings)
{
DI.log.error(" {0}", signatureNotFound);
}
}
if (signaturesToShow.Count == 0)
{
DI.log.error("None of the dropped signature was resolved, you need to load their CIR");
}
else
{
showSignatures(signaturesToShow);
}
}
public void addBindableFieldsIntoTreeView_Recursive(TreeNodeCollection tncTreeNodes, String sClassToFind,
bool bHideGetAndSetStrings, ICirData fadCirData)
{
String sFixedClassToFind = sClassToFind[0].ToString().ToUpper() + sClassToFind.Substring(1);
foreach (ICirClass ccCirClass in fadCirData.dClasses_bySignature.Values)
{
if (ccCirClass.Name == sFixedClassToFind)
{
var tnClass = new TreeNode(ccCirClass.Signature);
foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values)
{
String sFunctionName = new FilteredSignature(cfCirFunction.FunctionSignature).sFunctionName;
switch (sFunctionName.Substring(0, 3))
{
case "get":
var tnSubObject = new TreeNode(sFunctionName);
String sFixedSubObjectName = sFunctionName.Replace("get", "");
if (bHideGetAndSetStrings)
{
tnSubObject.Text = sFixedSubObjectName;
}
// tnSubObject = tnClass;
addBindableFieldsIntoTreeView_Recursive(tnSubObject.Nodes, sFixedSubObjectName,
bHideGetAndSetStrings, fadCirData);
if (tnSubObject.Nodes.Count > 0)
{
tnClass.Nodes.Add(tnSubObject);
}
break;
case "set":
String sSetNodeText = new FilteredSignature(cfCirFunction.FunctionSignature).sFunctionName;
if (bHideGetAndSetStrings)
{
sSetNodeText = sSetNodeText.Replace("set", "");
}
tnClass.Nodes.Add(sSetNodeText);
break;
default:
break;
}
}
tncTreeNodes.Add(tnClass);
}
// String sClassName =
}
}
public static String populateGraphWithTreeNode(ref int iEdgeId, Graph gGraphToPopulate, TreeNode tnTreeNode,
bool bOrder, bool bFilterName, bool bOnlyShowClasses,
Int32 iShowClassesLevel,
bool bShowParameters, bool bShowReturnClass, bool bShowNamespace,
int iNamespaceDepth)
{
String sNormalizedName = FilteredSignature.filterName(tnTreeNode.Text, bShowParameters, bShowReturnClass,
bShowNamespace, iNamespaceDepth, bFilterName,
bOnlyShowClasses, iShowClassesLevel);
if (sNormalizedName == "")
{
sNormalizedName = "[***Empty***]";
}
var nNode = (Node)gGraphToPopulate.AddNode(sNormalizedName);
nNode.UserData = tnTreeNode;
nNode.Attr.Shape = Shape.Plaintext;
String sNodeText_From = tnTreeNode.Text;
foreach (TreeNode tnChild in tnTreeNode.Nodes)
{
String sNodeText_To = FilteredSignature.filterName(tnChild.Text, bShowParameters, bShowReturnClass,
bShowNamespace, iNamespaceDepth, bFilterName,
bOnlyShowClasses, iShowClassesLevel);
if (sNodeText_From != sNodeText_To) // don't add edge if they are the same text
{
addEdgeToGraph(gGraphToPopulate, sNodeText_From, sNodeText_To, (iEdgeId++).ToString());
}
sNodeText_From = populateGraphWithTreeNode(ref iEdgeId, gGraphToPopulate, tnChild, bOrder, bFilterName,
bOnlyShowClasses, iShowClassesLevel);
// add the return value
// need to find a way to not do this for sinks
// if (sNodeText_From != sNodeText_To)
// {
// addEdgeToGraph(gGraphToPopulate, sNodeText_From, sNodeText_To, (iEdgeId++).ToString());
// sNodeText_From = sNodeText_To;
// }
/*
* String sMethodA = Analysis_CallFlow.display.filterName(tnChild.Text , bShowParameters, bShowReturnClass, bShowNamespace, bFilterName, bOnlyShowClasses, iShowClassesLevel);
* String sMethodB = Analysis_CallFlow.display.filterName(tnTreeNode.Text , bShowParameters, bShowReturnClass, bShowNamespace, bFilterName, bOnlyShowClasses, iShowClassesLevel);
* if (bOrder)
* addEdgeToGraph(gGraphToPopulate,sMethodA,sMethodB,true);
* else
* addEdgeToGraph(gGraphToPopulate,sMethodB,sMethodA,false);
*/
}
return(sNodeText_From);
}
private static String MakeSignatureCompatibleWithOunceRules(string signatureToFix)
{
if (signatureToFix.IndexOf("..ctor") > -1)
{
var filteredSiganture = new FilteredSignature(signatureToFix);
if (filteredSiganture.lsFunctionClass_Parsed.Count > 1)
{
signatureToFix = signatureToFix.Replace(".ctor", filteredSiganture.lsFunctionClass_Parsed[filteredSiganture.lsFunctionClass_Parsed.Count - 2]).Replace(".(", "(");
}
;
}
signatureToFix = signatureToFix.Replace("..ctor", "");
return(FilteredSignature.makeDotNetSignatureCompatibleWithOunceRules(signatureToFix));
}
private void showFunctionAttributes(ICirFunction _rootCirFunction)
{
showClassAttributes(_rootCirFunction.ParentClass);
tvFunctionAttributes.Nodes.Clear();
foreach (var attribute in _rootCirFunction.FunctionAttributes)
{
var signature = new FilteredSignature(attribute.AttributeClass).sSignature;
var treeNode = tvFunctionAttributes.Nodes.Add(signature);
foreach (var parameter in attribute.Parameters)
{
treeNode.Nodes.Add(parameter.Key);
}
}
}
public void showSelectedMethodDetails(FilteredSignature filteredSignature)
{
if (filteredSignature != null)
{
tbMethodDetails_Name.invokeOnThread(
() =>
{
tbMethodDetails_Name.Text = filteredSignature.sFunctionName;
tbMethodDetails_OriginalSignature.Text = filteredSignature.sOriginalSignature;
tbMethodDetails_Parameters.Text = filteredSignature.sParameters;
tbMethodDetails_ReturnType.Text = filteredSignature.sReturnClass;
tbMethodDetails_Signature.Text = filteredSignature.sSignature;
tbMethodDetails_Type.Text = filteredSignature.sFunctionClass;
});
}
}
public void loadAssembly(AssemblyDefinition assemblyDefinition)
{
tvDirectoriesAndFiles.invokeOnThread(
() => {
tvDirectoriesAndFiles.Nodes.Clear();
foreach (var method in CecilUtils.getMethods(assemblyDefinition))
{
if (method.HasBody)
{
var filteredSignature = new FilteredSignature(method.ToString());
O2Forms.newTreeNode(tvDirectoriesAndFiles.Nodes, filteredSignature.sSignature, 0, method);
}
}
tvDirectoriesAndFiles.Sort();
});
}
public void addToDataGridView_CommandMappingInTreeNode_Recursive(TreeNodeCollection tncNodes,
DataGridView dgvTargetDataGridView)
{
foreach (TreeNode tnTreeNode in tncNodes)
{
if (tnTreeNode.Text.IndexOf("setCommandName") > -1 && tnTreeNode.Nodes.Count > 0)
{
String sMethod = new FilteredSignature(tnTreeNode.Text).sFunctionNameAndParams;
String sClass = tnTreeNode.Parent.Parent.Text;
String sValue = tnTreeNode.Nodes[0].Text;
O2Forms.addToDataGridView_Row(dgvTargetDataGridView, null,
new[] { sClass, sMethod, sValue });
}
addToDataGridView_CommandMappingInTreeNode_Recursive(tnTreeNode.Nodes, dgvTargetDataGridView);
}
}
public override string ToString()
{
if (false == OnlyShowFunctionNameInToString)
{
return(FunctionSignature);
}
String sStringToFilter = FunctionSignature;
const bool bShowParameters = true;
const bool bShowReturnClass = true;
const bool bShowNamespace = true;
const int iNamespaceDepth = 1;
return(FilteredSignature.filterSignature(sStringToFilter, bShowParameters, bShowReturnClass, bShowNamespace,
iNamespaceDepth));
}
private void showClassAttributes(ICirClass cirClass)
{
if (cirClass != null)
{
tvClassAttributes.Nodes.Clear();
foreach (var attribute in cirClass.ClassAttributes)
{
var signature = new FilteredSignature(attribute.AttributeClass).sSignature;
var treeNode = tvClassAttributes.Nodes.Add(signature);
foreach (var parameter in attribute.Parameters)
{
treeNode.Nodes.Add(parameter.Key);
}
}
}
}
public static MethodDefinition getMethodDefinitionFromMethodInfo(MethodInfo methodInfo, Mono.Cecil.AssemblyDefinition assemblyDefinition)
{
foreach (var methodDefinition in CecilUtils.getMethods(assemblyDefinition))
{
var functionSignature1 = new FilteredSignature(methodInfo);
var functionSignature2 = new FilteredSignature(methodDefinition.ToString());
if (functionSignature1.sSignature == functionSignature2.sSignature)
{
return(methodDefinition);
}
if (functionSignature1.sFunctionName == functionSignature2.sFunctionName)
{
}
}
PublicDI.log.error("in getMethodDefinitionFromMethodInfo, could not map MethodInfo: {0}", methodInfo.ToString());
return(null);
}
//DC this version was using the old QuickGraph MarkedEdge
public static void createGraphWizDotFile(AdjacencyGraph <String, TaggedEdge <String, String> > gGraphWizToPopulate,
TreeNode tnTreeNode, bool bOrder, bool bFilterName, bool bFilterClass,
int iFilterClassLevel)
{
if (bFilterClass)
{
tnTreeNode.Text = FilteredSignature.filterName(tnTreeNode.Text, false, false, true, 0, true, true,
iFilterClassLevel);
}
TaggedEdge <String, string> meTemp;
if (gGraphWizToPopulate.ContainsVertex(tnTreeNode.Text))
{
}
else
{
gGraphWizToPopulate.AddVertex(tnTreeNode.Text);
}
foreach (TreeNode tnChild in tnTreeNode.Nodes)
{
if (bFilterClass)
{
tnChild.Text = FilteredSignature.filterName(tnChild.Text, false, false, true, 0, true, true,
iFilterClassLevel);
}
createGraphWizDotFile(gGraphWizToPopulate, tnChild, bOrder, bFilterName, bFilterClass, iFilterClassLevel);
if (bOrder)
{
if (false == gGraphWizToPopulate.TryGetEdge(tnTreeNode.Text, tnChild.Text, out meTemp))
{
gGraphWizToPopulate.AddEdge(new TaggedEdge <String, string>(tnTreeNode.Text, tnChild.Text,
"marker"));
}
}
else if (false == gGraphWizToPopulate.TryGetEdge(tnChild.Text, tnTreeNode.Text, out meTemp))
{
gGraphWizToPopulate.AddEdge(new TaggedEdge <String, string>(tnChild.Text, tnTreeNode.Text, "marker"));
}
//gGraphToPopulate.AddEdge(tnTreeNode.Text, tnChild.Text);
// gGraphToPopulate.AddEdge(Analysis_CallFlow.display.filterName(tnChild.Text, false, false, false), Analysis_CallFlow.display.filterName(tnTreeNode.Text, false, false, false));
//else
}
}
private static void fixFunctionsCalledXRefs(ICirData cirData)
{
if (cirData != null && cirData.dFunctions_bySignature != null)
{
var timer = new O2Timer("fixFunctionsCalledXRefs").start();
foreach (CirFunction cirFunction in cirData.dFunctions_bySignature.Values)
{
if (cirFunction.FunctionName == null)
{
var filteredSignature = new FilteredSignature(cirFunction.FunctionSignature);
cirFunction.FunctionName = filteredSignature.sFunctionName;
cirFunction.FunctionNameAndParameters = filteredSignature.sFunctionNameAndParams;
cirFunction.ClassNameFunctionNameAndParameters = filteredSignature.sFunctionClass + "." +
filteredSignature.sFunctionNameAndParams;
}
}
timer.stop();
}
}
public static void makeLostSourcesVisible(GraphData fgdGraphData, bool bShowParameters, bool bShowReturnClass,
bool bShowNamespace, int iNamespaceDepth)
{
foreach (String sNode in fgdGraphData.dNodes.Keys)
{
if (false == fgdGraphData.dNodeIsCalledBy.ContainsKey(sNode))
{
fgdGraphData.dNodes[sNode].NodeAttribute.Label = FilteredSignature.filterSignature(sNode,
bShowParameters,
bShowReturnClass,
bShowNamespace,
iNamespaceDepth);
;
fgdGraphData.dNodes[sNode].NodeAttribute.Shape = Shape.Box;
if (fgdGraphData.lnEmptyNodes.Contains(fgdGraphData.dNodes[sNode]))
{
fgdGraphData.lnEmptyNodes.Remove(fgdGraphData.dNodes[sNode]);
}
}
}
}
public static bool mapJavaAttributesToFinding(O2Finding o2Finding, string xmlAttributeFile)
{
var source = o2Finding.Source;
var filteredSignature = new FilteredSignature(source);
//DI.log.info(filteredSignature.sFunctionClass + " - " + filteredSignature.sFunctionName);
var xClassElement = getClassDataFromXmlAttributeFile(xmlAttributeFile, filteredSignature.sFunctionClass);
if (xClassElement != null)
{
SpringMVCAttributes.addClassAttributesToFinding(xClassElement, o2Finding);
var xMethodElement = getMethodDataFromXmlAttributeFile(xClassElement, filteredSignature.sFunctionName);
if (xMethodElement != null)
{
SpringMVCAttributes.addMethodAttributesToFinding(xMethodElement, o2Finding);
return(true);
// DI.log.info("have xElement");
}
}
return(false);
//DI.log.info("mapping finding {0} with xml file {1}", o2Finding.ToString(), xmlAttributeFile);
}
public static void mapMethodsToFilteredSignatures(List <MethodInfo> methodsToMap, ref List <FilteredSignature> filteredSignatures, ref Dictionary <string, MethodInfo> methods_bySignature, bool hideCSharpGeneratedMethods)
{
filteredSignatures = new List <FilteredSignature>();
methods_bySignature = new Dictionary <string, MethodInfo>();
foreach (var method in methodsToMap)
{
try
{
var filteredSignature = new FilteredSignature(method);
if (hideCSharpGeneratedMethods == false || (filteredSignature.sSignature.IndexOf("<>") == -1 &&
false == filteredSignature.sFunctionName.StartsWith("b__")))
{
// create methodsLoaded_bySignature
if (methods_bySignature.ContainsKey(filteredSignature.sSignature))
{
if (method.type().Assembly.GetName().Name.contains("FluentSharp"))
{
PublicDI.log.error("in mapMethodsToFilteredSignatures, repeated signature: {0}", filteredSignature.sSignature);
}
}
else
{
filteredSignatures.Add(filteredSignature);
methods_bySignature.Add(filteredSignature.sSignature, method);
}
}
else
{
//PublicDI.log.info("Skipping: {0}", method.Name);
}
}
catch (Exception ex)
{
"[O2 Object Model] mapMethodsToFilteredSignatures: {0}".error(ex.Message);
}
}
}
public Reflection_MethodInfo(MethodInfo method)
{
Method = method;
filteredSignature = new FilteredSignature(method);
}
private void filterByFilteredSignature(FilteredSignature filteredSignature)
{
setFilter1TextValue(filteredSignature.sSignature, true);
}
