protected Program RewriteFile(string relativePath, Address addrBase)
{
var services = new ServiceContainer();
var config = new FakeDecompilerConfiguration();
services.AddService<IConfigurationService>(config);
ILoader ldr = new Loader(services);
var program = ldr.AssembleExecutable(
FileUnitTester.MapTestPath(relativePath),
new X86TextAssembler(new IntelArchitecture(ProcessorMode.Real)),
addrBase);
program.Platform = new DefaultPlatform(services, program.Architecture);
var ep = new EntryPoint(program.Image.BaseAddress, program.Architecture.CreateProcessorState());
var project = new Project { Programs = { program } };
var scan = new Scanner(
program,
new Dictionary<Address, ProcedureSignature>(),
new ImportResolver(project),
new FakeDecompilerEventListener());
scan.EnqueueEntryPoint(ep);
scan.ScanImage();
var dfa = new DataFlowAnalysis(program, new FakeDecompilerEventListener());
dfa.AnalyzeProgram();
return program;
}
public void ScanHeuristically()
{
var decSvc = services.RequireService<IDecompilerService>();
var selected = base.SelectedHits();
foreach (var hit in selected)
{
var scanner = new Scanner(
hit.Program,
null,
null,
services.RequireService<WindowsDecompilerEventListener>());
//var hs = new HeuristicScanner(hit.Program,)
}
}
private void DumpProgram(Scanner scanner)
{
var dasm = arch.CreateDisassembler(program.Image.CreateLeReader(0));
foreach (var instr in dasm)
{
Console.Out.WriteLine("{0} {1}", instr.Address, instr);
}
foreach (Procedure proc in program.Procedures.Values)
{
proc.Write(true, Console.Out);
Console.Out.WriteLine();
}
}
private Program AssembleFile(string sourceFile, Address addr)
{
var ldr = new Loader(new ServiceContainer());
var arch = new X86ArchitectureReal();
Program program = ldr.AssembleExecutable(
FileUnitTester.MapTestPath(sourceFile),
new X86TextAssembler(arch),
addr);
var project = new Project { Programs = { program } };
var scan = new Scanner(program, new Dictionary<Address, ProcedureSignature>(), new ImportResolver(project), null);
foreach (EntryPoint ep in program.EntryPoints)
{
scan.EnqueueEntryPoint(ep);
}
scan.ScanImage();
return program;
}
protected void RunHexTest(string hexFile, string outputFile)
{
var svc = new ServiceContainer();
var cfg = new FakeDecompilerConfiguration();
svc.AddService<IConfigurationService>(cfg);
ILoader ldr = new Loader(svc);
var imgLoader = new DchexLoader(FileUnitTester.MapTestPath( hexFile), svc, null);
var img = imgLoader.Load(null);
var program = new Program(img.Image, img.Image.CreateImageMap(), img.Architecture, img.Platform);
var project = new Project { Programs = { program } };
var ep = new EntryPoint(program.Image.BaseAddress, program.Architecture.CreateProcessorState());
var scan = new Scanner(program, new Dictionary<Address, ProcedureSignature>(), new ImportResolver(project), new FakeDecompilerEventListener());
scan.EnqueueEntryPoint(ep);
scan.ScanImage();
var dfa = new DataFlowAnalysis(program, new FakeDecompilerEventListener());
dfa.AnalyzeProgram();
RunTest(program, outputFile);
}
private void BuildTest(Address addrBase, Platform platform , Action<X86Assembler> asmProg)
{
var entryPoints = new List<EntryPoint>();
var asm = new X86Assembler(arch, addrBase, entryPoints);
asmProg(asm);
var lr = asm.GetImage();
program = new Program(
lr.Image,
lr.ImageMap,
arch,
platform);
var project = new Project { Programs = { program } };
scanner = new Scanner(
program,
new Dictionary<Address, ProcedureSignature>(),
new ImportResolver(project),
new FakeDecompilerEventListener());
scanner.EnqueueEntryPoint(new EntryPoint(addrBase, arch.CreateProcessorState()));
scanner.ScanImage();
}
private void RunTest(Address addrBase)
{
var project = new Project { Programs = { program } };
scanner = new Scanner(
program,
new Dictionary<Address, ProcedureSignature>(),
new ImportResolver(project),
listener);
scanner.EnqueueEntryPoint(new EntryPoint(addrBase, arch.CreateProcessorState()));
scanner.ScanImage();
}
public void Scanner_CallGraphTree()
{
Program prog = new Program();
var addr = Address.SegPtr(0xC00, 0);
var m = new X86Assembler(new IntelArchitecture(ProcessorMode.Real), addr, new List<EntryPoint>());
m.i86();
m.Proc("main");
m.Call("baz");
m.Ret();
m.Endp("main");
m.Proc("foo");
m.Ret();
m.Endp("foo");
m.Proc("bar");
m.Ret();
m.Endp("bar");
m.Proc("baz");
m.Call("foo");
m.Call("bar");
m.Jmp("foo");
m.Endp("baz");
var lr = m.GetImage();
prog.Image = lr.Image;
prog.ImageMap = lr.ImageMap;
prog.Architecture = lr.Architecture;
prog.Platform = new FakePlatform(null, arch);
var proj = new Project { Programs = { prog } };
var scan = new Scanner(prog, new Dictionary<Address, ProcedureSignature>(), new ImportResolver(proj), new FakeDecompilerEventListener());
EntryPoint ep = new EntryPoint(addr, prog.Architecture.CreateProcessorState());
scan.EnqueueEntryPoint(ep);
scan.ScanImage();
Assert.AreEqual(4, prog.Procedures.Count);
}
public void Scanner_AddEntryPoint()
{
Given_Trace(new RtlTrace(0x12314)
{
m => { m.Return(4, 0); }
});
Given_Program(Address.Ptr32(0x12314));
var project = new Project { Programs = { program } };
var sc = new Scanner(
program,
null,
new ImportResolver(project),
new FakeDecompilerEventListener());
sc.EnqueueEntryPoint(
new EntryPoint(
Address.Ptr32(0x12314),
arch.CreateProcessorState()));
sc.ScanImage();
Assert.AreEqual(1, program.Procedures.Count);
Assert.AreEqual(0x12314, program.Procedures.Keys[0].Offset);
Assert.IsTrue(program.CallGraph.EntryPoints.Contains(program.Procedures.Values[0]));
}
private void RunTest(string sourceFile, string outputFile)
{
Program program;
var asm = new X86TextAssembler(new X86ArchitectureFlat32());
using (StreamReader rdr = new StreamReader(FileUnitTester.MapTestPath(sourceFile)))
{
program = asm.Assemble(Address.Ptr32(0x10000000), rdr);
program.Platform = win32;
}
foreach (var item in asm.ImportReferences)
{
program.ImportReferences.Add(item.Key, item.Value);
}
var project = new Project { Programs = { program } };
Scanner scan = new Scanner(
program,
new Dictionary<Address, ProcedureSignature>(),
new ImportResolver(project),
new FakeDecompilerEventListener());
foreach (var ep in asm.EntryPoints)
{
scan.EnqueueEntryPoint(ep);
}
scan.ScanImage();
using (FileUnitTester fut = new FileUnitTester(outputFile))
{
foreach (Procedure proc in program.Procedures.Values)
{
proc.Write(true, fut.TextWriter);
fut.TextWriter.WriteLine();
}
fut.AssertFilesEqual();
}
}
private Program RewriteProgram()
{
var project = new Project { Programs = { program } };
var scan = new Scanner(
program,
new Dictionary<Address, ProcedureSignature>(),
new ImportResolver(project),
new FakeDecompilerEventListener());
foreach (EntryPoint ep in program.EntryPoints)
{
scan.EnqueueEntryPoint(ep);
}
scan.ScanImage();
DecompilerEventListener eventListener = new FakeDecompilerEventListener();
DataFlowAnalysis da = new DataFlowAnalysis(program, eventListener);
da.AnalyzeProgram();
return program;
}
private static void Rewrite(Program prog, Assembler asm, string configFile)
{
var fakeDiagnosticsService = new FakeDiagnosticsService();
var fakeConfigService = new FakeDecompilerConfiguration();
var sc = new ServiceContainer();
sc.AddService(typeof(IDiagnosticsService), fakeDiagnosticsService);
sc.AddService(typeof(IConfigurationService), fakeConfigService);
var loader = new Loader(sc);
var project = string.IsNullOrEmpty(configFile)
? new Project()
: new ProjectLoader(loader).LoadProject(FileUnitTester.MapTestPath(configFile));
var scan = new Scanner(
prog,
new Dictionary<Address, ProcedureSignature>(),
new ImportResolver(project),
new FakeDecompilerEventListener());
scan.EnqueueEntryPoint(new EntryPoint(asm.StartAddress, prog.Architecture.CreateProcessorState()));
foreach (var f in project.Programs)
{
foreach (var sp in f.UserProcedures.Values)
{
scan.EnqueueUserProcedure(sp);
}
}
scan.ScanImage();
}
