public void Prld_MakePathsAbsolute()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
Filename = "foo.exe",
}
}
};
Given_TestArch();
Given_TestOS();
var ldr = new Mock <ILoader>();
ldr.Setup(l => l.LoadExecutable(
It.IsAny <string>(),
It.IsAny <byte[]>(),
It.IsAny <string>(),
It.IsAny <Address>())).Returns(new Program());
ldr.Setup(l => l.LoadImageBytes(
It.IsAny <string>(),
It.IsAny <int>())).Returns(new byte[1000]);
var prld = new ProjectLoader(sc, ldr.Object, listener.Object);
var project = prld.LoadProject(OsPath.Absolute("users", "bob", "projects", "foo.project"), sProject);
Assert.AreEqual(OsPath.Absolute("users", "bob", "projects", "foo.exe"), project.Programs[0].Filename);
}
public void Prld_MakePathsAbsolute_From_Filename()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
InputFiles =
{
new DecompilerInput_v4
{
Filename = "foo.exe",
},
}
};
Given_TestArch();
Given_TestOS();
var ldr = new Mock <ILoader>();
ldr.Setup(l => l.Load(
It.IsAny <ImageLocation>(),
It.IsAny <string>(),
It.IsAny <Address>())).Returns(new Program());
ldr.Setup(l => l.LoadFileBytes(
It.IsAny <string>())).Returns(new byte[1000]);
var location = ImageLocation.FromUri(OsPath.Absolute("users", "bob", "projects", "foo.project"));
var prld = new ProjectLoader(sc, ldr.Object, location, listener.Object);
var project = prld.LoadProject(sProject);
var programUri = project.Programs[0].Location;
Assert.AreEqual(OsPath.Absolute("users", "bob", "projects", "foo.exe"), programUri.FilesystemPath);
}
public void Save_v4()
{
var sp = new Project_v4
{
Inputs =
{
new DecompilerInput_v4 {
Filename = "foo.exe",
User = new UserData_v4 {
Heuristics =
{
new Heuristic_v3 {
Name = "shingle"
}
}
}
},
new AssemblerFile_v3 {
Filename = "foo.asm", Assembler = "x86-att"
}
}
};
var xw = new FilteringXmlWriter(new StringWriter());
new ProjectSaver(sc).Save(sp, xw);
}
public void Prld_EnableExtractResources()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
User = new UserData_v4
{
ExtractResources = true
}
}
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
var prld = new ProjectLoader(sc, ldr, listener.Object);
var project = prld.LoadProject("foo.dcproject", sProject);
Assert.IsTrue(project.Programs[0].User.ExtractResources);
}
public void Prld_MakePathsAbsolute()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
Filename = "foo.exe",
}
}
};
Given_TestArch();
Given_TestOS();
var ldr = mr.Stub <ILoader>();
ldr.Stub(l => l.LoadExecutable(null, null, null)).IgnoreArguments().Return(new Program());
ldr.Stub(l => l.LoadImageBytes(null, 0)).IgnoreArguments().Return(new byte[1000]);
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
var project = prld.LoadProject(OsPath.Absolute("users", "bob", "projects", "foo.project"), sProject);
Assert.AreEqual(OsPath.Absolute("users", "bob", "projects", "foo.exe"), project.Programs[0].Filename);
}
public void Prld_UserSegments()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
InputFiles =
{
new DecompilerInput_v4
{
Filename = "foo.exe",
User = new UserData_v4
{
Segments =
{
new Segment_v4
{
Name = "text", Address = "00123400", Length = "C00", Architecture = "testArch", Access = "r-x",
},
new Segment_v4
{
Name = "data", Address = "00200000", Offset = "C00", Length = "1200", Access = "rw"
},
}
}
}
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
Address addr = Address.Ptr32(0x00123400);
platform.Setup(p => p.TryParseAddress("00123400", out addr)).Returns(true);
addr = Address.Ptr32(0x00200000);
platform.Setup(p => p.TryParseAddress("00200000", out addr)).Returns(true);
var location = ImageLocation.FromUri("foo.dcproject");
var prld = new ProjectLoader(sc, ldr, location, listener.Object);
var prj = prld.LoadProject(sProject);
var u = prj.Programs[0].User;
Assert.AreEqual(2, u.Segments.Count);
Assert.AreEqual("text", u.Segments[0].Name);
Assert.AreEqual("00123400", u.Segments[0].Address.ToString());
Assert.AreEqual(0xC00, u.Segments[0].Length);
Assert.AreEqual(0, u.Segments[0].Offset);
Assert.AreEqual(AccessMode.ReadExecute, u.Segments[0].AccessMode);
Assert.AreEqual("data", u.Segments[1].Name);
Assert.AreEqual("00200000", u.Segments[1].Address.ToString());
Assert.AreEqual(0x1200, u.Segments[1].Length);
Assert.AreEqual(0x0C00, u.Segments[1].Offset);
Assert.AreEqual(AccessMode.ReadWrite, u.Segments[1].AccessMode);
}
public void SudLoadProgramOptions()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
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));
arch.Setup(a => a.GetRegister("eax")).Returns(new RegisterStorage("eax", 0, 0, PrimitiveType.Word32));
arch.Setup(a => a.GetRegister("ecx")).Returns(new RegisterStorage("ecx", 1, 0, PrimitiveType.Word32));
var loader = new Mock<ILoader>();
loader.Setup(l => l.LoadImageBytes(It.IsAny<string>(), It.IsAny<int>()))
.Returns(new byte[10]);
loader.Setup(l => l.LoadExecutable(
It.IsAny<string>(),
It.IsAny<byte[]>(),
It.IsAny<string>(),
It.IsAny<Address>()))
.Returns(new Program
{
Platform = this.platform.Object
});
var ploader = new ProjectLoader(sc, loader.Object, listener.Object);
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);
}
public void SudWrite()
{
Project_v4 ud = new Project_v4
{
Inputs =
{
new DecompilerInput_v4
{
DisassemblyFilename = "foo.asm",
IntermediateFilename = "foo.cod",
User = new UserData_v4{
Procedures =
{
new Procedure_v1
{
Name = "foo",
Signature = new SerializedSignature
{
ReturnValue = new Argument_v1
{
Kind = new Register_v1("eax")
},
Arguments = new Argument_v1[]
{
new Argument_v1
{
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1(Domain.SignedInt, 4)
},
new Argument_v1
{
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1(Domain.SignedInt, 4)
}
}
}
}
},
LoadAddress = "0x1000:0x0",
}
}
}
};
using (FileUnitTester fut = new FileUnitTester("Core/SudWrite.txt"))
{
var writer = new FilteringXmlWriter(fut.TextWriter);
writer.Formatting = System.Xml.Formatting.Indented;
XmlSerializer ser = SerializedLibrary.CreateSerializer_v4(typeof(Project_v4));
ser.Serialize(writer, ud);
fut.AssertFilesEqual();
}
}
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,
}
}
}
}
}
};
Given_Architecture();
Given_TestOS_Platform();
platform.Stub(p => p.TryParseAddress(
Arg <string> .Is.Equal("0041230"),
out Arg <Address> .Out(Address.Ptr32(0x0041230)).Dummy)).Return(true);
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))
.IgnoreArguments()
.Return(new Program
{
Platform = this.platform,
});
mr.ReplayAll();
var ploader = new ProjectLoader(sc, loader);
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);
}
public void Prld_LoadGlobalUserData()
{
Given_TestArch();
Given_TestOS();
Expect_Arch_ParseAddress("10000010", Address.Ptr32(0x10000010));
var sproject = new Project_v4
{
ArchitectureName = arch.Object.Name,
PlatformName = platform.Object.Name,
InputFiles =
{
new DecompilerInput_v4
{
Filename = "c:\\tmp\\foo\\foo.exe",
User = new UserData_v4
{
GlobalData =
{
new GlobalDataItem_v2
{
Address = "10000010",
Name = "testVar",
DataType = new ArrayType_v1
{
ElementType = new TypeReference_v1
{
TypeName = "Blob"
},
Length = 10
}
}
}
}
},
}
};
var ldr = mockFactory.CreateLoader();
var prld = new ProjectLoader(sc, ldr, listener.Object);
var project = prld.LoadProject(
@"c:\foo\global_user.proj",
sproject);
Assert.AreEqual(1, project.Programs.Count);
Assert.AreEqual(1, project.Programs[0].User.Globals.Count);
var globalVariable = project.Programs[0].User.Globals.Values[0];
Assert.AreEqual("10000010", globalVariable.Address.ToString());
Assert.AreEqual("testVar", globalVariable.Name);
Assert.AreEqual("arr(Blob,10)", globalVariable.DataType.ToString());
}
public void Prld_LoadGlobalUserData()
{
var sproject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
User = new UserData_v4
{
GlobalData =
{
new GlobalDataItem_v2
{
Address = "10000010",
Name = "testVar",
DataType = new ArrayType_v1
{
ElementType = new TypeReference_v1
{
TypeName = "Blob"
},
Length = 10
}
}
}
}
},
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
var project = prld.LoadProject(
@"c:\foo\global_user.proj",
sproject);
Assert.AreEqual(1, project.Programs.Count);
Assert.AreEqual(1, project.Programs[0].User.Globals.Count);
var globalVariable = project.Programs[0].User.Globals.Values[0];
Assert.AreEqual("10000010", globalVariable.Address);
Assert.AreEqual("testVar", globalVariable.Name);
Assert.AreEqual("arr(Blob,10)", globalVariable.DataType.ToString());
}
public Project_v4 Save(string projectAbsPath, Project project)
{
var inputs = new List<ProjectFile_v3>();
inputs.AddRange(project.Programs.Select(p => VisitProgram(projectAbsPath, p)));
inputs.AddRange(project.MetadataFiles.Select(m => VisitMetadataFile(projectAbsPath, m)));
var sp = new Project_v4
{
// ".Single()" because there can be only one Architecture and Platform, realistically.
ArchitectureName = project.Programs.Select(p => p.Architecture.Name).Distinct().SingleOrDefault(),
PlatformName = project.Programs.Select(p => p.Platform.Name).Distinct().SingleOrDefault(),
Inputs = inputs
};
return sp;
}
private void When_SaveToTextWriter(Program program, TextWriter sw)
{
var saver = new ProjectSaver(sc);
var sProj = new Project_v4
{
Inputs = { saver.VisitProgram("foo.exe", program) }
};
var writer = new FilteringXmlWriter(sw);
writer.Formatting = System.Xml.Formatting.Indented;
XmlSerializer ser = SerializedLibrary.CreateSerializer_v4(typeof(Project_v4));
ser.Serialize(writer, sProj);
}
public void Prld_LoadAnnotation()
{
var sproject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
Filename = "c:\\tmp\\foo\\foo.exe",
User = new UserData_v4
{
Annotations =
{
new Annotation_v3
{
Address = "commentAddress",
Text = "User comment",
}
}
}
},
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
var addr = Address.Ptr32(0x0000CADD);
arch.Setup(a => a.TryParseAddress(
"commentAddress",
out addr))
.Returns(true);
var prld = new ProjectLoader(sc, ldr, listener.Object);
var project = prld.LoadProject(
@"c:\foo\annot.proj",
sproject);
Assert.AreEqual(1, project.Programs.Count);
Assert.AreEqual(1, project.Programs[0].User.Annotations.Count());
var annotation = project.Programs[0].User.Annotations.First();
Assert.AreEqual("0000CADD", annotation.Address.ToString());
Assert.AreEqual("User comment", annotation.Text);
}
public void Prld_Partial_UserProc()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
InputFiles =
{
new DecompilerInput_v4
{
Filename = "c:\\tmp\\foo\\foo.exe",
User = new UserData_v4
{
Procedures =
{
new Procedure_v1
{
Address = "00123400",
Decompile = false,
}
}
}
}
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
var addrNav = new Mock <ICodeLocation>();
listener.Setup(l => l.CreateAddressNavigator(It.IsAny <Program>(), It.IsAny <Address>()))
.Returns(addrNav.Object);
listener.Setup(l => l.Warn(
It.IsAny <ICodeLocation>(),
It.IsAny <string>(),
It.IsAny <object[]>()))
.Verifiable();
var location = ImageLocation.FromUri("foo.dcproject");
var prld = new ProjectLoader(sc, ldr, location, listener.Object);
prld.LoadProject(sProject);
listener.Verify();
}
public void Prld_LoadAnnotation()
{
var sproject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
User = new UserData_v4
{
Annotations =
{
new Annotation_v3
{
Address = "commentAddress",
Text = "User comment",
}
}
}
},
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
arch.Stub(a => a.TryParseAddress(
Arg <string> .Is.Equal("commentAddress"),
out Arg <Address> .Out(Address.Ptr32(0x0000CADD)).Dummy))
.Return(true);
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr, listener);
var project = prld.LoadProject(
@"c:\foo\annot.proj",
sproject);
Assert.AreEqual(1, project.Programs.Count);
Assert.AreEqual(1, project.Programs[0].User.Annotations.Count());
var annotation = project.Programs[0].User.Annotations.First();
Assert.AreEqual("0000CADD", annotation.Address.ToString());
Assert.AreEqual("User comment", annotation.Text);
}
public void Prld_Partial_UserProc()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
User = new UserData_v4
{
Procedures =
{
new Procedure_v1
{
Address = "00123400",
Decompile = false,
}
}
}
}
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
var addrNav = mr.Stub <ICodeLocation>();
listener.Stub(l => l.CreateAddressNavigator(null, null))
.IgnoreArguments()
.Return(addrNav);
listener.Expect(l => l.Warn(null, null, null))
.IgnoreArguments();
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr, listener);
prld.LoadProject("foo.dcproject", sProject);
mr.VerifyAll();
}
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",
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))
.IgnoreArguments()
.Return(new Program
{
Platform = this.platform,
});
mr.ReplayAll();
var ploader = new ProjectLoader(sc, loader);
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 void When_SaveToTextWriter(Program program, TextWriter sw)
{
var saver = new ProjectSaver(sc);
var sProj = new Project_v4
{
Inputs = { saver.VisitProgram("foo.exe", program) }
};
var writer = new FilteringXmlWriter(sw);
writer.Formatting = System.Xml.Formatting.Indented;
XmlSerializer ser = SerializedLibrary.CreateSerializer_v4(typeof(Project_v4));
ser.Serialize(writer, sProj);
}
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 Prld_LoadGlobalUserData()
{
var sproject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
User = new UserData_v4
{
GlobalData =
{
new GlobalDataItem_v2
{
Address = "10000010",
Name = "testVar",
DataType = new ArrayType_v1
{
ElementType = new TypeReference_v1
{
TypeName = "Blob"
},
Length = 10
}
}
}
}
},
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
var project = prld.LoadProject(
@"c:\foo\global_user.proj",
sproject);
Assert.AreEqual(1, project.Programs.Count);
Assert.AreEqual(1, project.Programs[0].User.Globals.Count);
var globalVariable = project.Programs[0].User.Globals.Values[0];
Assert.AreEqual("10000010", globalVariable.Address);
Assert.AreEqual("testVar", globalVariable.Name);
Assert.AreEqual("arr(Blob,10)", globalVariable.DataType.ToString());
}
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, FunctionType>(), new Dictionary<string, DataType>()
)
);
mockFactory.CreateLoadMetadataStub(
OsPath.Absolute("meta2.xml"),
this.platform,
new TypeLibrary(
types2, new Dictionary<string, FunctionType>(), new Dictionary<string, DataType>()
)
);
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 Prld_MakePathsAbsolute()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
Filename = "foo.exe",
}
}
};
Given_TestArch();
Given_TestOS();
var ldr = mr.Stub<ILoader>();
ldr.Stub(l => l.LoadExecutable(null, null, null)).IgnoreArguments().Return(new Program());
ldr.Stub(l => l.LoadImageBytes(null, 0)).IgnoreArguments().Return(new byte[1000]);
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
var project = prld.LoadProject(OsPath.Absolute("users", "bob", "projects", "foo.project"), sProject);
Assert.AreEqual(OsPath.Absolute("users", "bob", "projects", "foo.exe"), project.Programs[0].Filename);
}
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();
arch.Stub(a => a.TryParseAddress(
Arg<string>.Is.Equal("00123400"),
out Arg<Address>.Out(Address.Ptr32(0x00123400)).Dummy))
.Return(true);
mockFactory.CreateLoadMetadataStub(
OsPath.Absolute("meta1.xml"),
this.platform,
new TypeLibrary(
types1, new Dictionary<string, FunctionType>(), new Dictionary<string, DataType>()
)
);
mockFactory.CreateLoadMetadataStub(
OsPath.Absolute("meta2.xml"),
this.platform,
new TypeLibrary(
types2, new Dictionary<string, FunctionType>(), new Dictionary<string, DataType>()
)
);
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr, listener);
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 Save_v4()
{
var sp = new Project_v4
{
Inputs = {
new DecompilerInput_v3 {
Filename ="foo.exe",
User = new UserData_v3 {
Heuristics = {
new Heuristic_v3 { Name = "shingle" }
}
}
},
new AssemblerFile_v3 { Filename="foo.asm", Assembler="x86-att" }
}
};
var sw = new StringWriter();
new ProjectSaver(sc).Save(sp, sw);
Console.WriteLine(sw);
}
public void Prld_Partial_UserProc()
{
var sProject = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
User = new UserData_v4
{
Procedures =
{
new Procedure_v1
{
Address = "00123400",
Decompile = false,
}
}
}
}
}
};
var ldr = mockFactory.CreateLoader();
Given_TestArch();
Given_TestOS();
var addrNav = mr.Stub<ICodeLocation>();
listener.Stub(l => l.CreateAddressNavigator(null, null))
.IgnoreArguments()
.Return(addrNav);
listener.Expect(l => l.Warn(null, null, null))
.IgnoreArguments();
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr, listener);
prld.LoadProject("foo.dcproject", sProject);
mr.VerifyAll();
}
public void SudWrite()
{
Project_v4 ud = new Project_v4
{
Inputs =
{
new DecompilerInput_v4
{
DisassemblyFilename = "foo.asm",
IntermediateFilename = "foo.cod",
User = new UserData_v4 {
Procedures =
{
new Procedure_v1
{
Name = "foo",
Signature = new SerializedSignature
{
ReturnValue = new Argument_v1
{
Kind = new Register_v1("eax")
},
Arguments = new Argument_v1[]
{
new Argument_v1
{
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1(Domain.SignedInt, 4)
},
new Argument_v1
{
Kind = new StackVariable_v1(),
Type = new PrimitiveType_v1(Domain.SignedInt, 4)
}
}
}
}
},
LoadAddress = "1000:0000",
IndirectJumps =
{
new IndirectJump_v4 {
InstructionAddress ="1000:0220",
TableAddress ="1000:0228"
},
},
JumpTables = {
new JumpTable_v4
{
TableAddress = "1000:0228",
Destinations = new string[]
{
"1000:0230",
"1000:0244",
"1000:033F",
}
}
}
}
}
}
};
using (FileUnitTester fut = new FileUnitTester("Core/SudWrite.txt"))
{
var writer = new FilteringXmlWriter(fut.TextWriter);
writer.Formatting = System.Xml.Formatting.Indented;
XmlSerializer ser = SerializedLibrary.CreateSerializer_v4(typeof(Project_v4));
ser.Serialize(writer, ud);
fut.AssertFilesEqual();
}
}
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));
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))
.IgnoreArguments()
.Return(new Program
{
Platform = this.platform,
});
mr.ReplayAll();
var ploader = new ProjectLoader(sc, loader);
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);
}
public void Ps_Load_v4()
{
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 });
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.Stub(a => a.GetRegister("r1")).Return(new RegisterStorage("r1", 1, 0, PrimitiveType.Word32));
mr.ReplayAll();
var sp = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs = {
new DecompilerInput_v4
{
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);
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);
}
public void Save(Project_v4 sProject, TextWriter sw)
{
var ser = SerializedLibrary.CreateSerializer_v4(typeof(Project_v4));
ser.Serialize(sw, sProject);
}
public void Save(Project_v4 sProject, XmlWriter xw)
{
var ser = SerializedLibrary.CreateSerializer_v4(typeof(Project_v4));
ser.Serialize(xw, sProject);
}
public void Ps_Load_v4()
{
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_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
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);
}
public void Ps_Load_v4()
{
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
});
Given_Architecture();
Given_TestOS_Platform();
mr.ReplayAll();
var sp = new Project_v4
{
ArchitectureName = "testArch",
PlatformName = "testOS",
Inputs =
{
new DecompilerInput_v4
{
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)
}
}
}
}
}
}
}
}
}
};
var ps = new ProjectLoader(sc, loader);
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);
}
