public CirData getO2CirData()
{
String sO2CirDataFile = tbO2CirDataOfProject.Text;
CirData fadCirData = CirLoad.loadSerializedO2CirDataObject(sO2CirDataFile);
return(fadCirData);
}
public CirDataAnalysis createCirDataAnalysisObject(List <MethodInfo> methodInfos)
{
var assemblyDefinitions = new Dictionary <Assembly, AssemblyDefinition>();
ICirData cirData = new CirData();
//foreach(var assemblyToLoad in assembliesToLoad)
foreach (MethodInfo methodInfo in methodInfos)
{
var assembly = methodInfo.DeclaringType.Assembly;
if (false == assemblyDefinitions.ContainsKey(assembly))
{
var assemblyDefinition = CecilUtils.getAssembly(assembly.Location);
if (assemblyDefinition != null)
{
assemblyDefinitions.Add(assembly, assemblyDefinition);
}
}
if (assemblyDefinitions.ContainsKey(assembly))
{
var methodDefinition = CecilConvert.getMethodDefinitionFromMethodInfo(methodInfo, assemblyDefinitions[assembly]);
if (methodDefinition != null)
{
processMethodDefinition(cirData, methodDefinition, null);
}
}
}
return(new CirDataAnalysis(cirData));
}
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 void Test_ProcessingAllNetFrameworkAssemblies_V2_0_50727_withVerify()
{
ICirData cirData = new CirData();
var pathToDotNetFrameworkAssemblies = @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727";
Test_ProcessingAllO2AssembliesFromDirectory(cirData, pathToDotNetFrameworkAssemblies, true, true /*verbose*/);
}
public void test_CreateCirDataFilesForDotNetFramework()
{
var dotNetFrameworkDirectory = @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727";
string directoryToSaveCidDataFiles = Path.Combine(DI.config.O2TempDir, "_CirDataFilesFor_DotNetFramework2_0_50727");
Files.checkIfDirectoryExistsAndCreateIfNot(directoryToSaveCidDataFiles);
List <string> targetAssemblies = Files.getFilesFromDir_returnFullPath(dotNetFrameworkDirectory, "*.dll");
//targetAssemblies.AddRange(Files.getFilesFromDir_returnFullPath(DI.hardCodedO2DeploymentDir, "*.dll"));
ICirData cirDataWithAllAssemblies = new CirData();
foreach (var assemblyToProcess in targetAssemblies)
{
if (CecilUtils.isDotNetAssembly(assemblyToProcess))
{
DI.log.info("Processing file: {0}", Path.GetFileName(assemblyToProcess));
ICirData cirData = new CirData();
cirFactory.processAssemblyDefinition(cirData, assemblyToProcess);
cirFactory.processAssemblyDefinition(cirDataWithAllAssemblies, assemblyToProcess);
var savedCirDataFile = Path.Combine(directoryToSaveCidDataFiles,
Path.GetFileName(assemblyToProcess) + ".CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile);
}
}
DI.log.info("Almost there, now saving cirDataWithAllAssemblies ");
var fileWithCirDataWithAllAssemblies = Path.Combine(directoryToSaveCidDataFiles, "cirDataWithAllAssemblies.CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirDataWithAllAssemblies, fileWithCirDataWithAllAssemblies);
DI.log.info("Done ..");
}
public void Test_processAssemblyDefinition()
{
ICirData cirData = new CirData();
AssemblyDefinition testAssembly = getTestAssembly();
cirFactory.processAssemblyDefinition(cirData, testAssembly, null);
Assert.That(cirData.dClasses_bySignature.Count > 0, "cirData.dClasses_bySignature.Count == 0");
// check that all functions from this assembly match
checkThatAllFunctionsMatch(cirData, testAssembly);
// check that the type is there
TypeDefinition testTypeDefinition = CecilUtils.getType(testAssembly, "testType");
Assert.That(
cirData.dClasses_bySignature.ContainsKey(
CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(testTypeDefinition)),
"testTypeDefinition.FullName was not there");
Assert.IsNotNull(cirData.getClass(testTypeDefinition.FullName),
"when using testTypeDefinition.FullName, cirClass was null");
ICirClass cirClass = cirData.getClass("testType");
Assert.IsNotNull(cirClass, "when using 'testType', cirClass was null");
Test_processTypeDefinition(cirData, cirClass);
}
public void test_SaveAndLoadAllO2Modules()
{
var directoryToSaveCidDataFiles = Path.Combine(DI.config.O2TempDir, "_O2_CirData_Files");
Files.checkIfDirectoryExistsAndCreateIfNot(directoryToSaveCidDataFiles);
List <string> targetAssemblies = Files.getFilesFromDir_returnFullPath(DI.config.hardCodedO2LocalBuildDir, "*.exe");
targetAssemblies.AddRange(Files.getFilesFromDir_returnFullPath(DI.config.hardCodedO2LocalBuildDir, "*.dll"));
foreach (var assemblyToProcess in targetAssemblies)
{
DI.log.info("Processing file: {0}", Path.GetFileName(assemblyToProcess));
ICirData cirData = new CirData();
cirFactory.processAssemblyDefinition(cirData, assemblyToProcess);
Assert.That(cirData.dClasses_bySignature.Count > 0 && cirData.dFunctions_bySignature.Count > 0,
"There we no CirData results for :" + assemblyToProcess);
var savedCirDataFile = Path.Combine(directoryToSaveCidDataFiles,
Path.GetFileName(assemblyToProcess) + ".CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile);
Assert.That(File.Exists(savedCirDataFile), "Saved CirData file Didn't exist: " + savedCirDataFile);
ICirData cirData2 = CirLoad.loadFile(savedCirDataFile);
Assert.That(cirData2 != null, "cirData2 was null");
Assert.That(cirData.dClasses_bySignature.Count == cirData2.dClasses_bySignature.Count,
"dClasses_bySignature Count didnt match");
Assert.That(cirData.dFunctions_bySignature.Count == cirData2.dFunctions_bySignature.Count,
"dFunctions_bySignature Count didnt match");
// comment this to delete created files
//File.Delete(savedCirDataFile);
}
}
public static O2RulePack createRules_SourcesAndSinks(String sCirDataFile)
{
var rpRulePack = new O2RulePack();
if (false == File.Exists(sCirDataFile))
{
DI.log.error("in createRules_SourcesAndSinks, provide CirData file not found: {0}", sCirDataFile);
}
else
{
List <String> lsFunctions = MiscUtils.getFunctionsSignaturesFrom02CirData(sCirDataFile);
// in this type of scan, there are two rules
// if functions make no calls then they are maked as both Sources and Sinks
// other cases receive no marking
// sinks have preference (for the cases there there are no calls into and from
CirData fcdCirData = CirLoad.loadSerializedO2CirDataObject(sCirDataFile);
foreach (string sFunction in lsFunctions)
{
ICirFunction cfCirFunction = fcdCirData.dFunctions_bySignature[sFunction];
if (cfCirFunction.FunctionsCalledUniqueList.Count == 0)
{
addRule(createRule(O2RuleType.Sink, sFunction, fcdCirData.sDbId), rpRulePack);
addRule(createRule(O2RuleType.Source, sFunction, fcdCirData.sDbId), rpRulePack);
}
}
}
return(rpRulePack);
}
public void calculateCustomRuleToAdd(CirData fadCirData)
{
var lsRulesToAdd = new List <string>();
fromTreeNodeListCalculateRulesToAdd_recursive(tvCommandNameObjectFields.Nodes, lsRulesToAdd, fadCirData);
lbRulesToAdd.Items.Clear();
lbRulesToAdd.Items.AddRange(lsRulesToAdd.ToArray());
}
public void specificAssemblyTest()
{
var pathToDotNetFrameworkAssemblies = @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727";
string assemblyToTest = Path.Combine(pathToDotNetFrameworkAssemblies, "System.EnterpriseServices.dll");
ICirData cirData = new CirData();
Test_LoadingAssembly(cirData, assemblyToTest, true, true);
}
public void Test_processTypeDefinition()
{
ICirData cirData = new CirData();
AssemblyDefinition testAssembly = getTestAssembly();
TypeDefinition testTypeDefinition = CecilUtils.getType(testAssembly, "testType");
ICirClass cirClass = cirFactory.processTypeDefinition(cirData, testTypeDefinition);
Test_processTypeDefinition(cirData, cirClass);
}
public static ascx_CirDataViewer show(this ICirClass cirClass)
{
var cirData = new CirData();
cirData.dClasses_bySignature.Add(cirClass.Name, cirClass);
var cirDataViewer = cirData.show(0);
return(cirDataViewer);
}
public void Test_ProcessingO2Kernel()
{
DI.log.info("Testing with O2Kernel");
ICirData cirData = new CirData();
string O2KernelExe = DI.config.ExecutingAssembly; // this gets O2_Kernel.Exe
Test_LoadingAssembly(cirData, O2KernelExe, true /*verify*/, false /*verbose*/);
CirFactoryUtils.showCirDataStats(cirData);
}
private void dgvResolvedCommandName_SelectionChanged(object sender, EventArgs e)
{
if (dgvResolvedCommandName.SelectedRows.Count == 1)
{
CirData fadCirData = getO2CirData();
forClassLoadBindableFieldsIntoTreeView(tvCommandNameObjectFields,
dgvResolvedCommandName.SelectedRows[0].Cells["value"].Value.
ToString(), cbHideGetAndSetStrings.Checked, fadCirData);
}
}
public static String createOunceProjectForAllReferencesOf_Class(String sNewProjectName, String sSourceProject,
String sTargetFolder,
String sSourcePathToJavaFiles,
String sSourcePathToJspFiles,
List <String> lsStartClasses,
String sFunctionFilter, String sSourceF1CirData)
{
Files.checkIfDirectoryExistsAndCreateIfNot(sTargetFolder);
String sTargetProject = Path.Combine(sTargetFolder, Path.GetFileName(sSourceProject));
if (sSourceProject == sTargetProject) // make sure we don't override the Source project
{
DI.log.debug("Error: sTargetF1CirDataFile == sSourceProject - {0} ", sTargetProject);
return("");
}
var fcdCirData = new CirData();
fcdCirData = CirLoad.loadSerializedO2CirDataObject(sSourceF1CirData);
List <ICirClass> lccTargetCompilationClasses = null; // = new List<CirClass>();
List <String> lsFunctionsCalled = null; // = new List<string>();
// this might not be needed
// need to do this since the SymbolDef are not automatically mapped in the Symbols table
//var dFunctionsNames = new Dictionary<string, string>();
//foreach (ICirFunction cfCirFunction in fcdCirData.dFunctions_bySignature.Values)
// if (cfCirFunction != null && false == dFunctionsNames.ContainsKey(cfCirFunction.FunctionSignature))
// dFunctionsNames.Add(cfCirFunction.FunctionSignature, cfCirFunction.SymbolDef);
// calculate Target classes
foreach (String sStartClass in lsStartClasses)
{
calculateTargetComplilationClassFromStartClassSignature(sStartClass, ref lccTargetCompilationClasses,
ref lsFunctionsCalled, sFunctionFilter,
/*dFunctionsNames, */ fcdCirData);
}
// calculate full paths to class files to include in custom project
List <String> lsPathsToClassFilesSourceCode =
getListOfFilesToScanFromListOfClasses_J2EE(sSourcePathToJavaFiles, sSourcePathToJspFiles,
lccTargetCompilationClasses, fcdCirData);
DI.log.debug(
"Completed calculation of class files to include: there where {0} classes with {1} functions called",
lccTargetCompilationClasses.Count, lsFunctionsCalled.Count);
createCustomProject(sNewProjectName, lsPathsToClassFilesSourceCode, sSourceProject, sTargetFolder,
sTargetProject, sSourcePathToJavaFiles, sSourcePathToJspFiles);
return(sTargetProject);
}
public void Test_processMethodDefinition()
{
var cirData = new CirData();
AssemblyDefinition testAssembly = getTestAssembly();
TypeDefinition testType = CecilUtils.getType(testAssembly, "testType");
Test_getMemberFunction(cirData, testType, "testMethodA", new Type[0]);
Test_getMemberFunction(cirData, testType, "testMethodC", new[] { typeof(string) });
Test_getMemberFunction(cirData, testType, "testMethodD", new[] { typeof(string), typeof(Type) });
}
public static ICirData toCir(this string _string)
{
if (_string.isDotNet())
{
var cirData = new CirData();
new CirFactory().processAssemblyDefinition(cirData, _string);
cirData.remapXRefs();
return(cirData);
}
return(null);
}
public void Test_getMemberFunction(CirData cirData, TypeDefinition testType, string methodToTest,
Type[] methodParameters)
{
MethodDefinition cecilMethodDefinition = CecilUtils.getMethod(testType, methodToTest, methodParameters);
Assert.IsNotNull(cecilMethodDefinition, "cecilMethodDefinition was null for method", methodToTest);
ICirFunction cirFunction = cirFactory.processMethodDefinition(cirData, cecilMethodDefinition, null);
Assert.IsNotNull(cirFunction, "cecilMethodDefinition was null for method", cecilMethodDefinition);
Assert.That(CirCecilCompare.areEqual_MethodDefinitionAndCirFunction(cecilMethodDefinition, cirFunction),
"areEqual_MethodDefinitionAndCirFunction failed for method: " + cecilMethodDefinition);
}
public void loadData()
{
CirData fadCirData = getO2CirData();
ShowBeans();
List <String> lsClasses = findSpringMvcClasses(fadCirData);
showSpringMvcClases(lsClasses, fadCirData);
showSpringSuperClasses(lsClasses, fadCirData);
mapCommandNamesFromTreeNodes(tvSpringMvcClasses.Nodes);
calculateCustomRuleToAdd(fadCirData);
}
public void createCirDataObject()
{
var cirFactory = new CirFactory();
ICirData cirData = new CirData();
DI.log.info("using assembly:{0} and O2_Kernel.dll", Assembly.GetExecutingAssembly().Location);
cirFactory.processAssemblyDefinition(cirData, Assembly.GetExecutingAssembly().Location);
cirFactory.processAssemblyDefinition(cirData, DI.config.ExecutingAssembly);
Assert.That(cirData.dClasses_bySignature.Count > 0, "There were no classes in cirData object");
Assert.That(cirData.dFunctions_bySignature.Count > 0, "There were no function in cirData object");
O2Messages.setCirData(cirData);
//CirFactoryUtils.showCirDataStats();
}
public static ICirData createCirDataFromCirDataAnalysis(ICirDataAnalysis cirDataAnalysis)
{
if (cirDataAnalysis == null)
{
return(null);
}
var cirData = new CirData
{
dClasses_bySignature = cirDataAnalysis.dCirClass_bySignature,
dFunctions_bySignature = cirDataAnalysis.dCirFunction_bySignature,
};
return(cirData);
}
public void test_SaveCirDataFile()
{
ICirData cirData = new CirData();
cirFactory.processAssemblyDefinition(cirData, DI.config.ExecutingAssembly);
var savedCirDataFile = DI.config.getTempFileInTempDirectory("CirData");
Assert.That(false == File.Exists(savedCirDataFile), "savedCirDataFile shouldn't exist here");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile);
Assert.That(File.Exists(savedCirDataFile), "savedCirDataFile exist here");
File.Delete(savedCirDataFile);
Assert.That(false == File.Exists(savedCirDataFile), "savedCirDataFile Should be deleted");
DI.log.info("all done");
}
public static ICirClass toCir(this Type type)
{
var cirData = new CirData();
var assemblyLocation = type.assemblyLocation();
var assembly = CecilUtils.getAssembly(assemblyLocation);
var cirFactory = new CirFactory();
cirFactory.loadAndMapSymbols(assembly, assemblyLocation, false, "");
var typeDefinition = CecilUtils.getType(assembly, type.Name);
var cirType = cirFactory.processTypeDefinition(cirData, typeDefinition);
cirData.remapXRefs();
return(cirType);
}
public CirDataAnalysis createCirDataAnalysisObject(List <string> assembliesToLoad, bool decompileCodeIfNoPdb)
{
ICirData cirData = new CirData();
foreach (var assemblyToLoad in assembliesToLoad)
{
processAssemblyDefinition(cirData, assemblyToLoad, decompileCodeIfNoPdb);
}
if (cirData.dClasses_bySignature.Count > 0)
{
return(new CirDataAnalysis(cirData));
}
DI.log.error("in createCirDataAnalysisObject there were no clases in CirData file");
return(null);
}
public static void loadCirDumpXmlFiles_andPopulateDictionariesWithXrefs(List <String> sFilesToProcess,
CirData fcdCirData, bool bVerbose)
{
for (int iFileIndex = 0; iFileIndex < sFilesToProcess.Count; iFileIndex++)
{
O2Timer tO2Timer =
new O2Timer(String.Format("[{0}/{1}] Loading CirDumpFile : {2}", sFilesToProcess.Count,
iFileIndex, sFilesToProcess[iFileIndex])).start();
CommonIRDump cidCommonIrDump = loadCirDumpXmlFile_justReturnCommonIRDump(sFilesToProcess[iFileIndex],
bVerbose);
fcdCirData.bVerbose = true;
CirDataUtils.populateDictionariesWithXrefs(cidCommonIrDump, fcdCirData);
tO2Timer.stop();
}
}
private void createCirDataForFile(string fileToProcess, bool deleteFileOnCompletion, bool decompileCodeIfNoPdb)
{
O2Thread.mtaThread(() =>
{
ICirData assemblyCirData = new CirData();
new CirFactory().processAssemblyAndSaveAsCirDataFile(assemblyCirData, fileToProcess, directory_CreatedCirFiles.getCurrentDirectory(), decompileCodeIfNoPdb);
if (deleteFileOnCompletion)
{
File.Delete(fileToProcess);
}
})
;
//new CirCreatorEngineForDotnet().createCirForAssembly(fileToProcess);
}
public static CirData loadSerializedO2CirDataObject(String sTargetFile, bool bUseCachedVersionIfAvailable)
{
DI.log.debug("Loading o2CirData file: {0}", sTargetFile);
// add cache support
// return cached object (if available)
if (bUseCachedVersionIfAvailable && vars.get(sTargetFile) != null)
{
return((CirData)vars.get(sTargetFile));
}
CirData fcdLoadedo2CirData = null;
try
{
O2Timer tO2Timer =
new O2Timer("Loading DeSerialized O2CirData from " + Path.GetFileName(sTargetFile)).start();
var bfBinaryFormatter = new BinaryFormatter();
var fsFileStream = new FileStream(sTargetFile, FileMode.Open);
//ounceLabs.O2.classes.
Object oObject = bfBinaryFormatter.Deserialize(fsFileStream);
if (oObject.GetType().Name == "CirData")
{
fcdLoadedo2CirData = (CirData)oObject;
if (fcdLoadedo2CirData.sDbId == "")
{
CirDataUtils.resolveDbId(fcdLoadedo2CirData); // in case was not originally resolved
}
if (fcdLoadedo2CirData.dClasses_bySignature == null)
{
DI.log.error("Something is wrong with this file since the dClasses dictionary is null");
}
// store loaded object as a local o2 var (which will act as a cache)
vars.set_(sTargetFile, fcdLoadedo2CirData);
}
else
{
DI.log.error("Loaded data is not of type o2CirData");
}
fsFileStream.Close();
tO2Timer.stop();
}
catch (Exception ex)
{
DI.log.error("In loadSerializedO2CirDataObject: {0}", ex.Message);
}
return(fcdLoadedo2CirData);
}
public static CirData loadFile(String sPathToFileToLoad)
{
CirData cirData;
if (Path.GetExtension(sPathToFileToLoad) == ".CirData")
{
cirData = loadSerializedO2CirDataObject(sPathToFileToLoad);
}
else
{
DI.log.debug("Loading CirDumpFile file: {0}", sPathToFileToLoad);
cirData = new CirData();
// always resolve these xrefs since older o2CirData might have probs (note that this is a one time only effort (per O2 session))
loadCirDumpXmlFile_andPopulateDictionariesWithXrefs(sPathToFileToLoad, cirData, false);
}
fixFunctionsCalledXRefs(cirData); // required for the new objects added by the CirCreator.CirFactory funtionality
return(cirData);
}
public static bool createConsolidatedCirDataFile(String sPathToCirDumpFiles, String sTargetCirDataFile,
bool bStoreControlFlowBlockRawDataInsideCirDataFile)
{
DI.log.debug("Creating Consolidated CirData file");
try
{
List <String> lsCirDumpFiles = Files.getFilesFromDir_returnFullPath(sPathToCirDumpFiles);
var fcdCirData = new CirData
{
bStoreControlFlowBlockRawDataInsideCirDataFile =
bStoreControlFlowBlockRawDataInsideCirDataFile
};
if (lsCirDumpFiles.Count == 0)
{
DI.log.error("No CirDump to process (were created during scan?)");
}
else
{
DI.log.debug("in loadCirDumpXmlFile_andPopulateDictionariesWithXrefs");
foreach (String sFile in lsCirDumpFiles)
{
try
{
fcdCirData.dSymbols = new Dictionary <string, string>();
fcdCirData.dTemp_Functions_bySymbolDef = new Dictionary <string, ICirFunction>();
CirLoad.loadCirDumpXmlFile_andPopulateDictionariesWithXrefs(sFile, fcdCirData, true);
}
catch (Exception ex)
{
DI.log.error("In createConsolidatedCirDataFile, error while processing file {0}: {1}",
sFile, ex.Message);
}
}
DI.log.debug("in saveSerializedO2CirDataObjectToFile");
CirDataUtils.saveSerializedO2CirDataObjectToFile(fcdCirData, sTargetCirDataFile);
return(true);
}
}
catch (Exception ex)
{
DI.log.error("In createConsolidatedCirDataFile: {0}:", ex.Message);
}
return(false);
}
public void Test_MultipleProcessingOfSameTypesAndAssembly()
{
ICirData cirData = new CirData();
AssemblyDefinition testAssembly = getTestAssembly();
// add assembly Object
cirFactory.processAssemblyDefinition(cirData, testAssembly, null);
ICirClass cirClass = cirData.getClass("testType");
// test it
Test_processTypeDefinition(cirData, cirClass);
// add each type individually
foreach (TypeDefinition typeDefinition in CecilUtils.getTypes(testAssembly))
{
cirFactory.processTypeDefinition(cirData, typeDefinition);
}
// test it again
ICirClass cirClass2 = cirData.getClass("testType");
Test_processTypeDefinition(cirData, cirClass);
Test_processTypeDefinition(cirData, cirClass2);
}
