public void Prld_Procedure_Placement()
{
var sProject = new Project_v5
{
ArchitectureName = "testArch",
PlatformName = "testOS",
InputFiles =
{
new DecompilerInput_v5
{
Filename = Path.Combine("foo", "bar.exe"),
User = new UserData_v4
{
Procedures =
{
new Procedure_v1
{
Address = "00123400",
OutputFile = Path.Combine("src", "bar.c")
}
}
}
},
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
Address addr = Address.Ptr32(0x00123400);
platform.Setup(p => p.TryParseAddress("00123400", out addr)).Returns(true);
var location = ImageLocation.FromUri("/foo/foo.dcproject");
var prld = new ProjectLoader(sc, ldr, location, listener.Object);
var prj = prld.LoadProject(sProject);
var u = prj.Programs[0].User;
var placement = u.ProcedureSourceFiles[addr];
Assert.IsTrue(IsPathEndingWith(placement, "foo/src/bar.c"));
}
public void Sud_LoadProject_Inputs_v2()
{
Given_Loader();
Given_Architecture();
Expect_Arch_ParseAddress("1000:0400", Address.SegPtr(0x1000, 0x0400));
Given_ExecutableProgram("foo.exe", Address.SegPtr(0x1000, 0x0000));
Given_BinaryFile("foo.bin", Address.SegPtr(0x1000, 0x0000));
var sProject = new Project_v2
{
Inputs = {
new DecompilerInput_v2 {
Filename = "foo.exe",
Address = "1000:0000",
Comment = "main file",
UserGlobalData = new List<GlobalDataItem_v2>
{
new GlobalDataItem_v2 { Address = "1000:0400", DataType = new StringType_v2 {
Termination=StringType_v2.ZeroTermination,
CharType= new PrimitiveType_v1 { ByteSize = 1, Domain=Domain.Character} }
}
}
},
new DecompilerInput_v2 {
Filename = "foo.bin",
Address = "1000:D000",
Comment = "overlay",
Processor = "x86-real-16",
}
}
};
var ps = new ProjectLoader(sc, loader.Object, listener.Object);
var project = ps.LoadProject("project.dcproj", sProject);
Assert.AreEqual(2, project.Programs.Count);
var input0 = project.Programs[0];
Assert.AreEqual(1, input0.User.Globals.Count);
Assert.AreEqual("1000:0400", input0.User.Globals.Values[0].Address);
var str_t = (StringType_v2)input0.User.Globals.Values[0].DataType;
Assert.AreEqual("prim(Character,1)", str_t.CharType.ToString());
}
public static ModuleDefinition GenerateModuleDefinition(string project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
CSharpProject p = ProjectLoader.LoadProject(project);
List <CSharpReference> embedFiles = p.EmbeddedReferences;
List <CSharpReference> packageFiles = p.PackageReferences;
List <CSharpReference> projectFiles = p.ProjectReferences;
ModuleDefinition def = new ModuleDefinition(
Path.GetFileNameWithoutExtension(project),
Path.GetDirectoryName(Path.GetFullPath(project)),
packageFiles.ToArray(),
projectFiles.ToArray(),
embedFiles.ToArray());
return(def);
}
public void Prld_v2()
{
var sExp =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<project xmlns=""http://schemata.jklnet.org/Decompiler/v2"">
<input>
</input>
</project>";
var ldr = new Mock <ILoader>();
var platform = new TestPlatform(sc);
Given_Binary(ldr, platform);
Given_TypeLibraryLoaderService();
cfgSvc.Setup(c => c.GetEnvironment("testOS")).Returns(new PlatformDefinition
{
});
var prld = new ProjectLoader(sc, ldr.Object, listener.Object);
var project = prld.LoadProject("/foo/bar", new MemoryStream(Encoding.UTF8.GetBytes(sExp)));
Assert.AreEqual(1, project.Programs.Count);
}
public void Prld_issue_299()
{
var sExp =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<project xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns=""http://schemata.jklnet.org/Reko/v3"">
<input>
<filename>switch.dll</filename>
<disassembly>switch.asm</disassembly>
<intermediate-code>switch.dis</intermediate-code>
<output>switch.c</output>
<types-file>switch.h</types-file>
<global-vars>switch.globals.c</global-vars>
<user>
<procedure name=""get"">
<address>10071000</address>
<CSignature>char * get(unsigned int n)</CSignature>
</procedure>
<heuristic name=""shingle"" />
</user>
</input>
</project>
";
var ldr = mr.Stub <ILoader>();
var platform = new TestPlatform(sc);
Given_TestArch();
Given_TestOS();
Given_Binary(ldr, platform);
Given_TypeLibraryLoaderService();
oe.Stub(o => o.TypeLibraries).Return(new List <ITypeLibraryElement>());
oe.Stub(o => o.CharacteristicsLibraries).Return(new List <ITypeLibraryElement>());
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr, listener);
var project = prld.LoadProject("/foo/bar", new MemoryStream(Encoding.UTF8.GetBytes(sExp)));
Assert.AreEqual(1, project.Programs.Count);
}
public void SudLoadMetadata()
{
var sProject = new Project_v2 {
Inputs =
{
new MetadataFile_v2
{
Filename = "c:\\tmp\\foo.def"
}
}
};
var loader = mr.Stub <ILoader>();
var typelib = new TypeLibrary();
loader.Stub(l => l.LoadMetadata("")).IgnoreArguments().Return(typelib);
mr.ReplayAll();
var ploader = new ProjectLoader(loader);
var project = ploader.LoadProject(sProject);
Assert.AreEqual(1, project.MetadataFiles.Count);
Assert.AreEqual("c:\\tmp\\foo.def", project.MetadataFiles[0].Filename);
}
/// <summary>
/// Loads (or assembles) the decompiler project. If a binary file is
/// specified instead, we create a simple project for the file.
/// </summary>
/// <param name="fileName">The filename to load.</param>
/// <param name="loaderName">Optional .NET class name of a custom
/// image loader</param>
/// <returns>True if the file could be loaded.</returns>
public bool Load(string fileName, string loaderName = null)
{
eventListener.ShowStatus("Loading source program.");
byte[] image = loader.LoadImageBytes(fileName, 0);
var projectLoader = new ProjectLoader(this.services, loader, eventListener);
projectLoader.ProgramLoaded += (s, e) => { RunScriptOnProgramImage(e.Program, e.Program.User.OnLoadedScript); };
this.Project = projectLoader.LoadProject(fileName, image);
if (Project == null)
{
var program = loader.LoadExecutable(fileName, image, loaderName, null);
if (program == null)
{
return(false);
}
this.Project = AddProgramToProject(fileName, program);
this.Project.LoadedMetadata = program.Platform.CreateMetadata();
program.EnvironmentMetadata = this.Project.LoadedMetadata;
}
BuildImageMaps();
eventListener.ShowStatus("Source program loaded.");
return(true);
}
/// <summary>
/// Loads (or assembles) the decompiler project. If a binary file is specified instead,
/// we create a simple project for the file.
/// </summary>
/// <returns>True if what was loaded was an actual project</returns>
/// <param name="program"></param>
/// <param name="cfg"></param>
public bool Load(string fileName)
{
eventListener.ShowStatus("Loading source program.");
byte[] image = loader.LoadImageBytes(fileName, 0);
var projectLoader = new ProjectLoader(this.services, loader);
projectLoader.ProgramLoaded += (s, e) => { RunScriptOnProgramImage(e.Program, e.Program.OnLoadedScript); };
Project = projectLoader.LoadProject(fileName, image);
bool isProject;
if (Project != null)
{
isProject = true;
}
else
{
var program = loader.LoadExecutable(fileName, image, null);
Project = CreateDefaultProject(fileName, program);
isProject = false;
}
eventListener.ShowStatus("Source program loaded.");
return(isProject);
}
public void Prld_PlatformOptions_Dictionary()
{
var sproject =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<project xmlns=""http://schemata.jklnet.org/Reko/v4"">
<arch>testArch</arch>
<platform>testOS</platform>
<input>
<user>
<platform>
<dict key=""Names"">
<item key=""Adam"">30</item>
<item key=""Bob"">10</item>
<item key=""Cecil"">120</item>
</dict>
<item key=""Name2"">Sue</item>
</platform>
</user>
</input>
</project>";
var ldr = mr.Stub <ILoader>();
Given_TestArch();
Given_TestOS();
Given_Binary(ldr, platform);
Expect_LoadOptions();
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
prld.LoadProject("c:\\foo\\bar.proj", new MemoryStream(Encoding.UTF8.GetBytes(sproject)));
var list = (IDictionary)loadedOptions["Names"];
Assert.AreEqual(3, list.Count);
}
public void Prld_PlatformOptions_List()
{
var sExp =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<project xmlns=""http://schemata.jklnet.org/Reko/v4"">
<arch>testArch</arch>
<platform>testOS</platform>
<input>
<user>
<platform>
<list key=""Names"">
<item>Adam</item>
<item>Bob</item>
<item>Cecil</item>
</list>
<item key=""Name2"">Sue</item>
</platform>
</user>
</input>
</project>";
var ldr = mr.Stub <ILoader>();
Given_TestArch();
Given_TestOS();
Given_Binary(ldr, platform);
Expect_LoadOptions();
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
prld.LoadProject("/ff/b/foo.proj", new MemoryStream(Encoding.UTF8.GetBytes(sExp)));
var list = (IList)loadedOptions["Names"];
Assert.AreEqual(3, list.Count);
}
private static Tuple <string, List <ModuleDefinition> > GenerateProject(string msBuildPath, string workingDir,
AssemblyDefinition definition, bool lib = true)
{
if (workingDir == null)
{
throw new ArgumentNullException(nameof(workingDir));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
if (!Directory.Exists(workingDir))
{
throw new DirectoryNotFoundException("Can not find the working directory: " + workingDir);
}
Logger.Log(LogType.Log, "Generating csproject File...");
DotNetHelper.New(msBuildPath, workingDir, definition.AssemblyName, lib);
File.Delete(Path.Combine(workingDir, definition.AssemblyName,
lib ? "Class1.cs" : "Program.cs")); //Delete Default Class
string projectFile = Path.Combine(workingDir, definition.AssemblyName, definition.AssemblyName + ".csproj");
List <ModuleDefinition> modules = new List <ModuleDefinition>();
for (int i = 0; i < definition.IncludedModules.Count; i++)
{
if (modules.Count(x => x.Name == definition.IncludedModules[i].Name) == 0)
{
DiscoverModules(definition.IncludedModules[i], modules);
}
}
Logger.Log(LogType.Log, $"Discovered {modules.Count} Modules.");
CSharpProject p = ProjectLoader.LoadProject(projectFile);
foreach (ModuleDefinition defintionDefinition in modules)
{
for (int i = 0; i < defintionDefinition.Packages.Length; i++)
{
p.AddReference(defintionDefinition.Packages[i]);
}
//for (int i = 0; i < defintionDefinition.Projects.Length; i++)
//{
// CSharpReference r = PrepareForTransfer(defintionDefinition.Projects[i],
// defintionDefinition);
// string path = r.Attributes["Include"];
// if (modules.Count(x => path == Path.GetFullPath(Path.Combine(x.RootDirectory, x.Name + ".csproj"))) == 0)
// {
// p.AddReference(r);
// }
//}
for (int i = 0; i < defintionDefinition.EmbeddedFiles.Length; i++)
{
p.AddReference(defintionDefinition.EmbeddedFiles[i]);
}
}
File.Delete(projectFile);
p.Save(projectFile);
return(new Tuple <string, List <ModuleDefinition> >(projectFile, modules));
}
public void Sud_LoadProject_Inputs_v5()
{
Given_Loader();
Given_Architecture();
Given_TestOS_Platform();
Expect_Arch_ParseAddress("1000:0400", Address.SegPtr(0x1000, 0x0400));
Given_ExecutableProgram("foo.exe", Address.SegPtr(0x1000, 0x0000));
Given_BinaryFile("foo.bin", Address.SegPtr(0x1000, 0x0000));
var sProject = new Project_v5
{
ArchitectureName = arch.Object.Name,
PlatformName = platform.Object.Name,
InputFiles =
{
new DecompilerInput_v5 {
Filename = "foo.exe",
User =
{
LoadAddress = "1000:0000",
GlobalData =
{
new GlobalDataItem_v2 {
Address = "1000:0400", DataType = new StringType_v2{
Termination = StringType_v2.ZeroTermination,
CharType = new PrimitiveType_v1 {
ByteSize = 1,Domain = Domain.Character
}
}
}
}
},
Comment = "main file",
},
new DecompilerInput_v5 {
Filename = "foo.bin",
Comment = "overlay",
User =
{
LoadAddress = "1000:D000",
Processor = new ProcessorOptions_v4 {
Name = "x86-real-16",
}
}
}
}
};
var location = ImageLocation.FromUri("/var/project.dcproj");
var ps = new ProjectLoader(sc, loader.Object, location, listener.Object);
var project = ps.LoadProject(sProject);
Assert.AreEqual(2, project.Programs.Count);
var input0 = project.Programs[0];
Assert.AreEqual(1, input0.User.Globals.Count);
Assert.AreEqual("1000:0400", input0.User.Globals.Values[0].Address.ToString());
var str_t = (StringType_v2)input0.User.Globals.Values[0].DataType;
Assert.AreEqual("prim(Character,1)", str_t.CharType.ToString());
}
public void Prld_LoadUserDefinedMetadata()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
Filename = "foo.exe",
User = new UserData_v4
{
LoadAddress = "00123400"
}
},
new MetadataFile_v3 {
Filename = "meta1.xml",
},
new MetadataFile_v3 {
Filename = "meta2.xml",
},
}
};
var types1 = new Dictionary <string, DataType>()
{
{ "USRTYPE1", PrimitiveType.Word16 }
};
var types2 = new Dictionary <string, DataType>()
{
{ "USRTYPE2", PrimitiveType.Word32 }
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
var addr = Address.Ptr32(0x00123400);
arch.Setup(a => a.TryParseAddress(
"00123400",
out addr))
.Returns(true);
mockFactory.CreateLoadMetadataStub(
OsPath.Absolute("meta1.xml"),
this.platform.Object,
new TypeLibrary(
types1, new Dictionary <string, FunctionType>(), new Dictionary <string, DataType>()
)
);
mockFactory.CreateLoadMetadataStub(
OsPath.Absolute("meta2.xml"),
this.platform.Object,
new TypeLibrary(
types2, new Dictionary <string, FunctionType>(), new Dictionary <string, DataType>()
)
);
var prld = new ProjectLoader(sc, ldr, listener.Object);
var project = prld.LoadProject(OsPath.Absolute("foo.project"), sProject);
Assert.AreEqual(2, project.Programs[0].EnvironmentMetadata.Types.Count);
Assert.AreEqual(
"word16",
project.Programs[0].EnvironmentMetadata.Types["USRTYPE1"].ToString()
);
Assert.AreEqual(
"word32",
project.Programs[0].EnvironmentMetadata.Types["USRTYPE2"].ToString()
);
Assert.AreEqual(
Address.Ptr32(0x00123400),
project.Programs[0].User.LoadAddress);
}
public void SudLoadProgramOptions()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
User = new UserData_v4
{
Heuristics = { new Heuristic_v3 {
Name = "HeuristicScanning"
} },
TextEncoding = "windows-1251",
Calls =
{
new SerializedCall_v1
{
InstructionAddress = "0041230",
NoReturn = true,
}
},
RegisterValues = new RegisterValue_v2[]
{
new RegisterValue_v2 {
Address = "00443210", Register = "eax", Value = "42"
},
new RegisterValue_v2 {
Address = "00443210", Register = "ecx", Value = "10"
},
}
}
}
}
};
Given_Architecture();
Given_TestOS_Platform();
Expect_TryParseAddress("0041230", Address.Ptr32(0x0041230));
Expect_TryParseAddress("00443210", Address.Ptr32(0x00443210));
arch.Stub(a => a.GetRegister("eax")).Return(new RegisterStorage("eax", 0, 0, PrimitiveType.Word32));
arch.Stub(a => a.GetRegister("ecx")).Return(new RegisterStorage("ecx", 1, 0, PrimitiveType.Word32));
var loader = mr.Stub <ILoader>();
loader.Stub(l => l.LoadImageBytes(null, 0))
.IgnoreArguments()
.Return(new byte[10]);
loader.Stub(l => l.LoadExecutable(null, null, null, null))
.IgnoreArguments()
.Return(new Program
{
Platform = this.platform,
});
mr.ReplayAll();
var ploader = new ProjectLoader(sc, loader, listener);
var project = ploader.LoadProject("c:\\tmp\\foo\\bar.proj", sProject);
Assert.IsTrue(project.Programs[0].User.Heuristics.Contains("HeuristicScanning"));
Assert.AreEqual("windows-1251", project.Programs[0].User.TextEncoding.WebName);
Assert.AreEqual(1, project.Programs[0].User.RegisterValues.Count);
Assert.AreEqual(2, project.Programs[0].User.RegisterValues[Address.Ptr32(0x00443210)].Count);
}
private static Tuple <string, List <ModuleDefinition> > GenerateProject(string msBuildPath, string workingDir,
AssemblyDefinition definition, bool lib)
{
if (workingDir == null)
{
throw new ArgumentNullException(nameof(workingDir));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
if (!Directory.Exists(workingDir))
{
throw new DirectoryNotFoundException("Can not find the working directory: " + workingDir);
}
Logger.Log(LogType.Log, "Generating csproject File...", 1);
if (lib)
{
DotNetHelper.NewLib(msBuildPath, workingDir, definition.AssemblyName);
}
else
{
DotNetHelper.NewCommandLine(msBuildPath, workingDir, definition.AssemblyName);
}
File.Delete(Path.Combine(workingDir, definition.AssemblyName,
lib ? "Class1.cs" : "Program.cs")); //Delete Default Class
string projectFile = Path.Combine(workingDir, definition.AssemblyName, definition.AssemblyName + ".csproj");
List <ModuleDefinition> modules = new List <ModuleDefinition>();
for (int i = 0; i < definition.IncludedModules.Count; i++)
{
if (modules.Count(x => x.Name == definition.IncludedModules[i].Name) == 0)
{
DiscoverModules(definition.IncludedModules[i], modules);
}
}
Logger.Log(LogType.Log, $"Discovered {modules.Count} Modules.", 1);
CSharpProject p = ProjectLoader.LoadProject(projectFile);
foreach (ModuleDefinition defintionDefinition in modules)
{
for (int i = 0; i < defintionDefinition.Packages.Length; i++)
{
p.AddReference(defintionDefinition.Packages[i]);
}
for (int i = 0; i < defintionDefinition.EmbeddedFiles.Length; i++)
{
p.AddReference(defintionDefinition.EmbeddedFiles[i]);
}
}
File.Delete(projectFile);
p.Save(projectFile);
return(new Tuple <string, List <ModuleDefinition> >(projectFile, modules));
}
public void Ps_Load_v1()
{
var bytes = new byte[100];
loader.Stub(l => l.LoadImageBytes(null, 0)).IgnoreArguments().Return(bytes);
loader.Stub(l => l.LoadExecutable(null, null, null)).IgnoreArguments().Return(
new Program {
Architecture = arch
});
mr.ReplayAll();
var sp = new Project_v1
{
Input = new DecompilerInput_v1
{
Filename = "f.exe",
},
UserProcedures =
{
new Procedure_v1 {
Name = "Fn",
Decompile = true,
Characteristics = new ProcedureCharacteristics
{
Terminates = true,
},
Address = "113300",
Signature = new SerializedSignature{
ReturnValue = new Argument_v1{
Type = new PrimitiveType_v1(Domain.SignedInt, 4),
},
Arguments = new Argument_v1[]{
new Argument_v1
{
Name = "a",
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1(Domain.Character, 2)
},
new Argument_v1
{
Name = "b",
Kind = new StackVariable_v1(),
Type = new PointerType_v1{
DataType = new PrimitiveType_v1(Domain.Character, 2)
}
}
}
}
}
}
};
var ps = new ProjectLoader(loader);
var p = ps.LoadProject(sp);
Assert.AreEqual(1, p.Programs.Count);
var inputFile = p.Programs[0];
Assert.AreEqual(1, inputFile.UserProcedures.Count);
Assert.AreEqual("Fn", inputFile.UserProcedures.First().Value.Name);
}
public void Ps_Load_v5()
{
var bytes = new byte[100];
loader.Setup(l => l.LoadFileBytes(
It.IsAny <string>())).
Returns(bytes);
loader.Setup(l => l.Load(
It.IsAny <ImageLocation>(),
null,
null)).Returns(new Func <ImageLocation, string, Address, ILoadedImage>(
(i, l, a) => new Program {
Architecture = arch.Object
}));
Given_Architecture();
Given_TestOS_Platform();
Given_Platform_Address("113800", 0x113800);
Given_Platform_Address("114000", 0x114000);
Given_Platform_Address("115000", 0x115000);
Given_Platform_Address("115012", 0x115012);
Given_Platform_Address("11504F", 0x11504F);
arch.Setup(a => a.GetRegister("r1")).Returns(new RegisterStorage("r1", 1, 0, PrimitiveType.Word32));
var sp = new Project_v5
{
ArchitectureName = "testArch",
PlatformName = "testOS",
InputFiles =
{
new DecompilerInput_v5
{
Filename = "f.exe",
User = new UserData_v4
{
Procedures =
{
new Procedure_v1 {
Name = "Fn",
Decompile = true,
Characteristics = new ProcedureCharacteristics
{
Terminates = true,
},
Address = "113300",
Signature = new SerializedSignature{
ReturnValue = new Argument_v1{
Type = new PrimitiveType_v1(Domain.SignedInt, 4),
},
Arguments = new Argument_v1[]{
new Argument_v1
{
Name = "a",
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1(Domain.Character, 2)
},
new Argument_v1
{
Name = "b",
Kind = new StackVariable_v1(),
Type = new PointerType_v1{
DataType = new PrimitiveType_v1(Domain.Character, 2)
}
}
}
}
}
},
IndirectJumps =
{
new IndirectJump_v4
{
InstructionAddress = "113800",
IndexRegister = "r1",
TableAddress = "114000",
}
},
JumpTables =
{
new JumpTable_v4
{
TableAddress = "114000",
Destinations = new []
{
"115000",
"115012",
"11504F",
}
}
},
OutputFilePolicy = Program.SegmentFilePolicy,
BlockLabels =
{
new BlockLabel_v1
{
Location = "115252",
Name = "errorExit",
}
}
}
},
new DecompilerInput_v5
{
Location = OsPath.Relative("foo", "i am positive+.exe")
}
}
};
var location = ImageLocation.FromUri(OsPath.Absolute("tmp", "fproj.proj"));
var ps = new ProjectLoader(sc, loader.Object, location, listener.Object);
var p = ps.LoadProject(sp);
Assert.AreEqual(2, p.Programs.Count);
var inputFile0 = p.Programs[0];
var inputFile1 = p.Programs[1];
Assert.AreEqual(1, inputFile0.User.Procedures.Count);
Assert.AreEqual("Fn", inputFile0.User.Procedures.First().Value.Name);
Assert.AreEqual(1, inputFile0.User.JumpTables.Count);
var jumpTable = inputFile0.User.JumpTables[Address.Ptr32(0x114000)];
Assert.AreEqual(Address.Ptr32(0x00115000), jumpTable.Addresses[0]);
Assert.AreEqual(Address.Ptr32(0x00115012), jumpTable.Addresses[1]);
Assert.AreEqual(Address.Ptr32(0x0011504F), jumpTable.Addresses[2]);
Assert.AreEqual(1, inputFile0.User.IndirectJumps.Count);
var indJump = inputFile0.User.IndirectJumps[Address.Ptr32(0x00113800)];
Assert.AreSame(jumpTable, indJump.Table);
Assert.AreEqual(1, inputFile0.User.BlockLabels.Count);
var blockLabel = inputFile0.User.BlockLabels["115252"];
Assert.AreEqual("errorExit", blockLabel);
Assert.AreEqual(Program.SegmentFilePolicy, inputFile0.User.OutputFilePolicy);
Assert.AreEqual(OsPath.Absolute("tmp", "foo", "i am positive+.exe"), inputFile1.Location.FilesystemPath);
}
public void Prld_LoadUserDefinedMetadata()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
Filename = "foo.exe",
},
new MetadataFile_v3 {
Filename = "meta1.xml",
},
new MetadataFile_v3 {
Filename = "meta2.xml",
},
}
};
var types1 = new Dictionary <string, DataType>()
{
{ "USRTYPE1", PrimitiveType.Word16 }
};
var types2 = new Dictionary <string, DataType>()
{
{ "USRTYPE2", PrimitiveType.Word32 }
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
mockFactory.CreateLoadMetadataStub(
OsPath.Absolute("meta1.xml"),
this.platform,
new TypeLibrary(
types1, new Dictionary <string, ProcedureSignature>()
)
);
mockFactory.CreateLoadMetadataStub(
OsPath.Absolute("meta2.xml"),
this.platform,
new TypeLibrary(
types2, new Dictionary <string, ProcedureSignature>()
)
);
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
var project = prld.LoadProject(OsPath.Absolute("foo.project"), sProject);
Assert.AreEqual(2, project.Programs[0].EnvironmentMetadata.Types.Count);
Assert.AreEqual(
"word16",
project.Programs[0].EnvironmentMetadata.Types["USRTYPE1"].ToString()
);
Assert.AreEqual(
"word32",
project.Programs[0].EnvironmentMetadata.Types["USRTYPE2"].ToString()
);
}
public void SudLoadProgramOptions()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
InputFiles =
{
new DecompilerInput_v4
{
Filename = "c:\\tmp\\foo\\foo.exe",
User = new UserData_v4
{
Heuristics = { new Heuristic_v3 {
Name = "HeuristicScanning"
} },
TextEncoding = "windows-1251",
Calls =
{
new SerializedCall_v1
{
InstructionAddress = "0041230",
NoReturn = true,
}
},
RegisterValues = new RegisterValue_v2[]
{
new RegisterValue_v2 {
Address = "00443210", Register = "eax", Value = "42"
},
new RegisterValue_v2 {
Address = "00443210", Register = "ecx", Value = "10"
},
}
}
}
}
};
Given_Architecture();
Given_TestOS_Platform();
Expect_TryParseAddress("0041230", Address.Ptr32(0x0041230));
Expect_TryParseAddress("00443210", Address.Ptr32(0x00443210));
Expect_TryGetRegister(arch, "eax", new RegisterStorage("eax", 0, 0, PrimitiveType.Word32));
Expect_TryGetRegister(arch, "ecx", new RegisterStorage("ecx", 1, 0, PrimitiveType.Word32));
var loader = new Mock <ILoader>();
loader.Setup(l => l.LoadFileBytes(It.IsAny <string>()))
.Returns(new byte[10]);
loader.Setup(l => l.LoadBinaryImage(
It.IsAny <ImageLocation>(),
It.IsAny <byte[]>(),
It.IsAny <string>(),
It.IsAny <Address>()))
.Returns(new Program
{
Platform = this.platform.Object
});
var location = ImageLocation.FromUri("c:\\tmp\\foo\\bar.proj");
var ploader = new ProjectLoader(sc, loader.Object, location, new FakeDecompilerEventListener());
var project = ploader.LoadProject(sProject);
Assert.IsTrue(project.Programs[0].User.Heuristics.Contains("HeuristicScanning"));
Assert.AreEqual("windows-1251", project.Programs[0].User.TextEncoding.WebName);
Assert.AreEqual(1, project.Programs[0].User.RegisterValues.Count);
Assert.AreEqual(2, project.Programs[0].User.RegisterValues[Address.Ptr32(0x00443210)].Count);
}
public void Ps_Load_v5()
{
var bytes = new byte[100];
loader.Setup(l => l.LoadImageBytes(
It.IsAny <string>(),
It.IsAny <int>())).
Returns(bytes);
loader.Setup(l => l.LoadExecutable(
It.IsAny <string>(),
It.IsAny <byte[]>(),
It.IsAny <string>(),
It.IsAny <Address>())).Returns(
new Program {
Architecture = arch.Object
});
Given_Architecture();
Given_TestOS_Platform();
Given_Platform_Address("113800", 0x113800);
Given_Platform_Address("114000", 0x114000);
Given_Platform_Address("115000", 0x115000);
Given_Platform_Address("115012", 0x115012);
Given_Platform_Address("11504F", 0x11504F);
arch.Setup(a => a.GetRegister("r1")).Returns(new RegisterStorage("r1", 1, 0, PrimitiveType.Word32));
var sp = new Project_v5
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v5
{
Filename = "f.exe",
User = new UserData_v4
{
Procedures =
{
new Procedure_v1 {
Name = "Fn",
Decompile = true,
Characteristics = new ProcedureCharacteristics
{
Terminates = true,
},
Address = "113300",
Signature = new SerializedSignature{
ReturnValue = new Argument_v1{
Type = new PrimitiveType_v1(Domain.SignedInt, 4),
},
Arguments = new Argument_v1[]{
new Argument_v1
{
Name = "a",
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1(Domain.Character, 2)
},
new Argument_v1
{
Name = "b",
Kind = new StackVariable_v1(),
Type = new PointerType_v1{
DataType = new PrimitiveType_v1(Domain.Character, 2)
}
}
}
}
}
},
IndirectJumps =
{
new IndirectJump_v4
{
InstructionAddress = "113800",
IndexRegister = "r1",
TableAddress = "114000",
}
},
JumpTables =
{
new JumpTable_v4
{
TableAddress = "114000",
Destinations = new []
{
"115000",
"115012",
"11504F",
}
}
}
}
}
}
};
var ps = new ProjectLoader(sc, loader.Object, listener.Object);
var p = ps.LoadProject("c:\\tmp\\fproj.proj", sp);
Assert.AreEqual(1, p.Programs.Count);
var inputFile = p.Programs[0];
Assert.AreEqual(1, inputFile.User.Procedures.Count);
Assert.AreEqual("Fn", inputFile.User.Procedures.First().Value.Name);
Assert.AreEqual(1, inputFile.User.JumpTables.Count);
var jumpTable = inputFile.User.JumpTables[Address.Ptr32(0x114000)];
Assert.AreEqual(Address.Ptr32(0x00115000), jumpTable.Addresses[0]);
Assert.AreEqual(Address.Ptr32(0x00115012), jumpTable.Addresses[1]);
Assert.AreEqual(Address.Ptr32(0x0011504F), jumpTable.Addresses[2]);
Assert.AreEqual(1, inputFile.User.IndirectJumps.Count);
var indJump = inputFile.User.IndirectJumps[Address.Ptr32(0x00113800)];
Assert.AreSame(jumpTable, indJump.Table);
}
protected override void Execute()
{
SolutionOptions options = new SolutionOptions();
Solution.GetProperty((int)__VSPROPID.VSPROPID_SolutionDirectory, out object solutionDirectoryRaw);
Solution.GetProperty((int)__VSPROPID.VSPROPID_SolutionBaseName, out object solutionNameRaw);
string solutionName = solutionNameRaw.ToString();
string solutionDirectory = solutionDirectoryRaw.ToString();
options.SolutionName = solutionName;
options.SolutionDirectory = solutionDirectory;
options.RepositoryDirectory = new DirectoryInfo(solutionDirectory).Parent.FullName;
IEnumerable <Project> projects = DTE.Solution.GetAllProjects();
using (DialogScope progress2 = new DialogScope())
{
progress2.Update("Synchronizing project file properties with solution. Please wait...");
foreach (Project project in projects)
{
progress2.Update(
"Synchronizing project file properties with solution. Please wait...",
$"Processing Project '{project.Name}'"
);
// ===========================
// Flow
// ===========================
//
// 1) Snapshot project file full path.
// 2) Open Project File with filePath and snapshot its ProjectRootElement.
// 3) Retrieve Project GUID of the project snapshotted in step 1
// 4) Unload project as if user manually unloaded it, and then close it
//
// 5) Walk property elements, stop at chosen property Name
// 5.1) Get the parent of the property element (should be a ProjectPropertyGroupElement)
// 5.2) Remove the property element, which will be an immediate child of the parent you just got in 5.1
// 6) Save the ProjectRootElement
// 7) Reload the project. This is where the GUID from step 3 comes in handy.
// 8) For good measure, save the project via the hierarchy.
// 9) You are done, Son!
//
//
string projectFilePath = project.FullName;
Solution.GetProjectOfUniqueName(project.UniqueName, out IVsHierarchy ppHierarchy);
Solution.GetGuidOfProject(ppHierarchy, out Guid projectGuid);
Solution4.UnloadProject(ref projectGuid, (uint)_VSProjectUnloadStatus.UNLOADSTATUS_UnloadedByUser);
Solution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_UnloadProject, ppHierarchy, VSConstants.VSITEMID_NIL);
ProjectRootElement root = ProjectLoader.LoadProject(projectFilePath).Xml;
foreach (ProjectPropertyElement propertyElement in root.Properties)
{
// Check for the most common property names for
// output paths. The names checked below are
// non-exhaustive. Technically, OutputPath should
// be sufficient; however, OutDir is used as
// well, but not very often.
if (propertyElement.Name.Equals("OutputPath") ||
propertyElement.Name.Equals("OutDir"))
{
propertyElement.Parent.RemoveChild(propertyElement);
root.Save(projectFilePath);
}
}
// This has to come after the properties are removed. Otherwise you get some error
// saing The SDK '' could not be found.
ProjectXmlService.SetExplicitSdkImportsIfNecessaryAsync(projectFilePath);
Solution4.ReloadProject(ref projectGuid);
Solution4.EnsureProjectIsLoaded(ref projectGuid, 0);
Solution.SaveSolutionElement((uint)__VSSLNSAVEOPTIONS.SLNSAVEOPT_ForceSave, ppHierarchy, VSConstants.VSITEMID_NIL);
}
}
DirectoryBuildPropsWriter.WriteDirectoryBuildProps(options);
Project solutionItems = DTE.Solution.GetOrCreateSolutionFolder("Solution Items");
solutionItems.ProjectItems.AddFromFile(options.DirectoryBuildPropsPath);
DTE.Collapse();
}
