public override Program Load(Address addrLoad) { BinHexDecoder dec = new BinHexDecoder(new StringReader(Encoding.ASCII.GetString(RawImage))); IEnumerator<byte> stm = dec.GetBytes().GetEnumerator(); BinHexHeader hdr = LoadBinHexHeader(stm); byte[] dataFork = LoadFork(hdr.DataForkLength, stm); byte[] rsrcFork = LoadFork(hdr.ResourceForkLength, stm); var arch = new M68kArchitecture(); var platform = new MacOSClassic(Services, arch); if (hdr.FileType == "PACT") { Cpt.CompactProArchive archive = new Cpt.CompactProArchive(); List<ArchiveDirectoryEntry> items = archive.Load(new MemoryStream(dataFork)); IArchiveBrowserService abSvc = Services.GetService<IArchiveBrowserService>(); if (abSvc != null) { var selectedFile = abSvc.UserSelectFileFromArchive(items); if (selectedFile != null) { var image = selectedFile.GetBytes(); this.rsrcFork = new ResourceFork(image, arch); this.image = new LoadedImage(addrLoad, image); this.imageMap = new ImageMap(addrLoad, image.Length); return new Program(this.image, this.imageMap, arch, platform); } } } var li = new LoadedImage(addrLoad, dataFork); return new Program(li, li.CreateImageMap(), arch, platform); }
private static SparcInstruction DisassembleWord(uint instr) { var bytes = new byte[4]; new BeImageWriter(bytes).WriteBeUInt32(0, instr); var img = new LoadedImage(Address.Ptr32(0x00100000), bytes); return Disassemble(img); }
private IntelInstruction Disassemble64(params byte[] bytes) { var img = new LoadedImage(Address.Ptr64(0x10000), bytes); var rdr = img.CreateLeReader(img.BaseAddress); var dasm = new X86Disassembler(rdr, PrimitiveType.Word32, PrimitiveType.Word64, true); return dasm.First(); }
public ushort ReadBeUInt16() { ushort u = LoadedImage.ReadBeUInt16(bytes, (uint)off); off += 2; return(u); }
public Program(LoadedImage image, ImageMap imageMap, IProcessorArchitecture arch, Platform platform) : this() { this.Image = image; this.ImageMap = imageMap; this.Architecture = arch; this.Platform = platform; }
private IntelInstruction Disassemble16(params byte[] bytes) { LoadedImage img = new LoadedImage(Address.SegPtr(0xC00, 0), bytes); ImageReader rdr = img.CreateLeReader(img.BaseAddress); var dasm = new X86Disassembler(rdr, PrimitiveType.Word16, PrimitiveType.Word16, false); return dasm.First(); }
private X86Instruction Disassemble32(params byte[] bytes) { var img = new LoadedImage(Address.Ptr32(0x10000), bytes); var rdr = img.CreateLeReader(img.BaseAddress); var dasm = new X86Disassembler(ProcessorMode.Protected32, rdr, PrimitiveType.Word32, PrimitiveType.Word32, false); return dasm.First(); }
private void BuildTest(params ushort[] words) { var bytes = words .SelectMany(u => new byte[] { (byte)u, (byte)(u >> 8), }) .ToArray(); image = new LoadedImage(Address.Ptr32(0x00100000), bytes); }
private void BuildTest(params string[] bitStrings) { var bytes = bitStrings.Select(bits => base.ParseBitPattern(bits)) .SelectMany(u => new byte[] { (byte) u, (byte) (u >> 8), (byte) (u >> 16), (byte) (u >> 24) }) .ToArray(); image = new LoadedImage(Address.Ptr32(0x00100000), bytes); }
public void DecSvc_DecompilerProjectName() { IDecompilerService svc = new DecompilerService(); var loader = mr.StrictMock<ILoader>(); var host = mr.StrictMock<DecompilerHost>(); var arch = mr.StrictMock<IProcessorArchitecture>(); var platform = mr.StrictMock<Platform>(sc, arch); var fileName = "foo\\bar\\baz.exe"; var bytes = new byte[100]; var image = new LoadedImage(Address.Ptr32(0x1000), bytes); var imageMap = image.CreateImageMap(); var prog = new Program(image, imageMap, arch, platform); loader.Stub(l => l.LoadImageBytes(fileName, 0)).Return(bytes); loader.Stub(l => l.LoadExecutable(fileName, bytes, null)).Return(prog); loader.Replay(); var dec = new DecompilerDriver(loader, host, sc); mr.ReplayAll(); svc.Decompiler = dec; svc.Decompiler.Load(fileName); Assert.IsNotNull(svc.Decompiler.Project); Assert.AreEqual("baz.exe", svc.ProjectName, "Should have project name available."); mr.VerifyAll(); }
public void Setup() { var image = new LoadedImage(Address.Ptr32(0x00100000), new byte[1024]); var arch = new FakeArchitecture(); var program = new Program { Image = image, Architecture = arch, ImageMap = image.CreateImageMap(), Platform = new DefaultPlatform(null, arch), }; store = program.TypeStore; factory = program.TypeFactory; globals = program.Globals; store.EnsureExpressionTypeVariable(factory, globals); StructureType s = new StructureType(null, 0); s.Fields.Add(0x00100000, PrimitiveType.Word32, null); TypeVariable tvGlobals = store.EnsureExpressionTypeVariable(factory, globals); EquivalenceClass eqGlobals = new EquivalenceClass(tvGlobals); eqGlobals.DataType = s; globals.TypeVariable.DataType = new Pointer(eqGlobals, 4); globals.DataType = globals.TypeVariable.DataType; tcr = new TypedConstantRewriter(program); }
public void UShortFixup() { var bytes = new byte[] { 0x01, 0x02, 0x03 }; var img = new LoadedImage(Address.SegPtr(0x0C00, 0), bytes); ushort newSeg = img.FixupLeUInt16(1, 0x4444); Assert.AreEqual(0x4746, newSeg); }
public uint ReadBeUInt32() { uint u = LoadedImage.ReadBeUInt32(bytes, off); off += 4; return(u); }
public void ValidateImage() { Program prog = new Program(); LoadedImage rawImage = new LoadedImage(Address.SegPtr(0x0C00, 0), CreateMsdosHeader()); ExeImageLoader exe = new ExeImageLoader(null, "foo.exe", rawImage.Bytes); Assert.IsTrue(PkLiteUnpacker.IsCorrectUnpacker(exe, rawImage.Bytes)); }
public void Setup() { mr = new MockRepository(); form = new MainForm(); sc = new ServiceContainer(); loader = mr.StrictMock<ILoader>(); dec = mr.StrictMock<IDecompiler>(); sc = new ServiceContainer(); uiSvc = new FakeShellUiService(); host = mr.StrictMock<DecompilerHost>(); memSvc = mr.StrictMock<ILowLevelViewService>(); var image = new LoadedImage(Address.Ptr32(0x10000), new byte[1000]); var imageMap = image.CreateImageMap(); var arch = mr.StrictMock<IProcessorArchitecture>(); arch.Stub(a => a.CreateRegisterBitset()).Return(new BitSet(32)); arch.Replay(); var platform = mr.StrictMock<Platform>(null, arch); arch.BackToRecord(); program = new Program(image, imageMap, arch, platform); project = new Project { Programs = { program } }; browserSvc = mr.StrictMock<IProjectBrowserService>(); sc.AddService<IDecompilerUIService>(uiSvc); sc.AddService(typeof(IDecompilerShellUiService), uiSvc); sc.AddService(typeof(IDecompilerService), new DecompilerService()); sc.AddService(typeof(IWorkerDialogService), new FakeWorkerDialogService()); sc.AddService(typeof(DecompilerEventListener), new FakeDecompilerEventListener()); sc.AddService(typeof(IProjectBrowserService), browserSvc); sc.AddService(typeof(ILowLevelViewService), memSvc); sc.AddService<ILoader>(loader); i = new TestInitialPageInteractor(sc, dec); }
public ulong ReadBeUInt64() { ulong u = LoadedImage.ReadBeUInt64(bytes, off); off += 8; return(u); }
public void HSC_x86_FindCallsToProcedure() { #if OLD var image = new LoadedImage(Address.Ptr32(0x001000), new byte[] { 0xE8, 0x0B, 0x00, 0x00, 0x00, 0xE8, 0x07, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xC3 // 1010, 1011 }); prog = new Program { Image = image, ImageMap = image.CreateImageMap(), Architecture = new IntelArchitecture(ProcessorMode.Protected32), }; #else Given_Image32(0x001000, "E8 0B 00 00 00 E8 07 00 " + "00 00 C3 00 00 00 00 00 " + "C3 C3 "); // 1010, 1011 Given_x86_32(); #endif Given_RewriterHost(); mr.ReplayAll(); Assert.AreEqual(18, prog.Image.Length); var hsc = new HeuristicScanner(prog, host, eventListener); var linAddrs = hsc.FindCallOpcodes(new Address[]{ Address.Ptr32(0x1010), Address.Ptr32(0x1011)}).ToList(); Assert.AreEqual(2, linAddrs.Count); Assert.IsTrue(linAddrs.Contains(Address.Ptr32(0x1000))); Assert.IsTrue(linAddrs.Contains(Address.Ptr32(0x1005))); }
private MachineInstruction RunTest(params byte[] bytes) { var image = new LoadedImage(Address.Ptr32(0x200), bytes); var rdr = new LeImageReader(image, 0); var dasm = new Disassembler(rdr); return dasm.First(); }
private void RunTest(string sExp, params byte[] bytes) { var image = new LoadedImage(Address.Ptr32(0x0100000), bytes); var dasm = new CilDisassembler(image.CreateLeReader(0)).GetEnumerator(); Assert.IsTrue(dasm.MoveNext()); var instr = dasm.Current; Assert.AreEqual(sExp, instr.ToString()); }
public void DumpData(LoadedImage image, Address address, int cbBytes, TextWriter stm) { if (cbBytes < 0) { throw new ArgumentException("Must be a nonnegative number.", "cbBytes"); } DumpData(image, address, (uint)cbBytes, stm); }
private void BuildTest(params ushort[] words) { var bytes = words .SelectMany( w => new byte[] { (byte) w, (byte) (w >> 8) }) .ToArray(); image = new LoadedImage(LoadAddress, bytes); }
public void ReadLeNegativeInt() { LoadedImage img = new LoadedImage(Address.Ptr32(0x10000), new byte[] { 0xFE, 0xFF, 0xFF, 0xFF }); Constant c = img.ReadLe(0, PrimitiveType.Int32); Assert.AreSame(PrimitiveType.Int32, c.DataType); Assert.AreEqual("-2", c.ToString()); }
public void ReadLeUShort() { LoadedImage img = new LoadedImage(Address.Ptr32(0x10000), new byte[] { 0x78, 0x56, 0x34, 0x12 }); Constant c = img.ReadLe(2, PrimitiveType.Word16); Assert.AreSame(PrimitiveType.Word16, c.DataType); Assert.AreEqual("0x1234", c.ToString()); }
public X86Emulator(IntelArchitecture arch, LoadedImage loadedImage, IPlatformEmulator envEmulator) { this.arch = arch; this.img = loadedImage; this.Registers = new ulong[40]; this.Valid = new bool[40]; this.envEmulator = envEmulator; }
private void CreateDisassembler32(LoadedImage image) { dasm = new X86Disassembler( image.CreateLeReader(image.BaseAddress), PrimitiveType.Word32, PrimitiveType.Word32, false); }
protected ImageReader(LoadedImage img, ulong off) { if (img == null) throw new ArgumentNullException("img"); this.image = img; this.bytes = img.Bytes; this.addrStart = img.BaseAddress + off; this.off = offStart = off; }
private void btnLoad_Click(object sender, EventArgs e) { var image = new LoadedImage(Address.Ptr32(0x12312300),new byte[0x1000]); var imageMap = image.CreateImageMap(); var arch = new Reko.Arch.X86.X86ArchitectureFlat32(); var program = new Core.Program(image, imageMap, arch, new DefaultPlatform(null, arch)); var project = new Project { Programs = { program } }; pbs.Load(project); }
public void WriteByteRange(LoadedImage image, Address begin, Address addrEnd, TextWriter writer) { ImageReader rdr = arch.CreateImageReader(image, begin); while (rdr.Address < addrEnd) { writer.Write("{0:X2} ", rdr.ReadByte()); } }
public Program GetImage() { var image = new LoadedImage(BaseAddress, Emitter.GetBytes()); return new Program( image, image.CreateImageMap(), arch, new DefaultPlatform(null, arch)); }
private void CreateDisassembler16(LoadedImage image) { dasm = new X86Disassembler( ProcessorMode.Real, image.CreateLeReader(image.BaseAddress), PrimitiveType.Word16, PrimitiveType.Word16, false); }
public bool TryReadBeUInt32(out uint ui32) { if (!LoadedImage.TryReadBeUInt32(this.bytes, (uint)off, out ui32)) { return(false); } off += 4; return(true); }
public void Setup() { mr = new MockRepository(); sc = new ServiceContainer(); var image = new LoadedImage(Address.SegPtr(0xC00, 0), Enumerable.Range(0x0, 0x100).Select(b => (byte)b).ToArray()); var imageMap = image.CreateImageMap(); var arch = new Mocks.FakeArchitecture(); this.program = new Program(image, imageMap, arch, new DefaultPlatform(sc, arch)); }
public ProgramBuilder(LoadedImage loadedImage) { Program = new Program { Image = loadedImage, ImageMap = loadedImage.CreateImageMap(), Architecture = new FakeArchitecture() }; }
public bool TryReadBeUInt16(out ushort us) { if (!LoadedImage.TryReadBeUInt16(bytes, (uint)off, out us)) { return(false); } off += 2; return(true); }
public bool TryReadBeUInt64(out ulong value) { if (!LoadedImage.TryReadBeUInt64(this.bytes, off, out value)) { return(false); } off += 8; return(true); }
protected void Given_Image32(uint addr, string sBytes) { var bytes = HexStringToBytes(sBytes); var imag = new LoadedImage(Address.Ptr32(addr), bytes); prog = new Program { Image = imag, ImageMap = imag.CreateImageMap(), }; }
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host) { var addr = Address.Ptr16(10); var image = new LoadedImage(addr, new byte[1]); return arch.CreateRewriter( arch.CreateImageReader(image, addr), arch.CreateProcessorState(), frame, host); }
private void Rewrite(params ushort[] opcodes) { byte[] bytes = new byte[opcodes.Length * 2]; var writer = new BeImageWriter(bytes); foreach (ushort opcode in opcodes) { writer.WriteBeUInt16(opcode); } image = new LoadedImage(addrBase, bytes); }
protected ImageReader(LoadedImage img, ulong off) { if (img == null) { throw new ArgumentNullException("img"); } this.image = img; this.bytes = img.Bytes; this.addrStart = img.BaseAddress + off; this.off = offStart = off; }
/// <summary> /// Reads a chunk of bytes and interprets it in Little-Endian mode. /// </summary> /// <param name="type">Enough bytes read </param> /// <returns>The read value as a <see cref="Constant"/>.</returns> public Constant ReadLe(PrimitiveType type) { Constant c; if (image != null) { c = image.ReadLe(off, type); } else { c = LoadedImage.ReadLe(bytes, Offset, type); } off += (uint)type.Size; return(c); }
public void DumpData(LoadedImage image, Address address, long cbBytes, TextWriter stm) { ulong cSkip = address.ToLinear() & 0x0F; ImageReader rdr = arch.CreateImageReader(image, address); while (cbBytes > 0) { StringBuilder sb = new StringBuilder(0x12); try { stm.Write("{0} ", rdr.Address); for (int i = 0; i < 16; ++i) { if (cbBytes > 0 && cSkip == 0) { byte b = rdr.ReadByte(); stm.Write("{0:X2} ", b); sb.Append(0x20 <= b && b < 0x7F ? (char)b : '.'); --cbBytes; } else { stm.Write(" "); if (cSkip > 0) { sb.Append(' '); } --cSkip; } } } catch { stm.WriteLine(); stm.WriteLine("...end of image"); return; } stm.WriteLine(sb.ToString()); } }
public bool DumpAssemblerLine(LoadedImage image, MachineInstruction instr, TextWriter writer) { Address addrBegin = instr.Address; if (ShowAddresses) { writer.Write("{0} ", addrBegin); } if (ShowCodeBytes) { StringWriter sw = new StringWriter(); WriteByteRange(image, instr.Address, instr.Address + instr.Length, sw); writer.WriteLine("{0,-16}\t{1}", sw.ToString(), instr); } else { writer.WriteLine("\t{0}", instr.ToString()); } return(true); }
protected ImageReader(LoadedImage img, Address addr) { if (img == null) { throw new ArgumentNullException("img"); } if (addr == null) { throw new ArgumentNullException("addr"); } long o = addr - img.BaseAddress; if (o < 0 || o >= img.Length) { throw new ArgumentOutOfRangeException("addr", "Address is outside of image."); } this.image = img; this.bytes = img.Bytes; this.addrStart = addr; this.off = offStart = (ulong)o; }
public void DumpAssembler(LoadedImage image, Address addrStart, Address addrLast, TextWriter writer) { var dasm = arch.CreateDisassembler(arch.CreateImageReader(image, addrStart)); try { foreach (var instr in dasm) { if (instr.Address >= addrLast) { break; } if (!DumpAssemblerLine(image, instr, writer)) { break; } } } catch (Exception ex) { writer.WriteLine(ex.Message); writer.WriteLine(); } }
public ushort PeekLeUInt16(uint offset) { return(LoadedImage.ReadLeUInt16(bytes, offset + (uint)off)); }
public short PeekBeInt16(uint offset) { return((short)LoadedImage.ReadBeUInt16(bytes, offset + (uint)off)); }
public bool TryPeekByte(uint offset, out byte value) { return(LoadedImage.TryReadByte(bytes, offset + (uint)off, out value)); }
public abstract ImageReader CreateImageReader(LoadedImage img, Address addr);
public abstract ImageReader CreateImageReader(LoadedImage img, ulong off);
public void DumpData(LoadedImage image, AddressRange range, TextWriter stm) { DumpData(image, range.Begin, (long)(range.End - range.Begin), stm); }
public uint PeekLeUInt32(uint offset) { return(LoadedImage.ReadLeUInt32(bytes, offset + off)); }
public BeImageReader(LoadedImage image, Address addr) : base(image, addr) { }
public BeImageReader(LoadedImage image, ulong offset) : base(image, offset) { }
public bool TryPeekBeUInt32(uint offset, out uint value) { return(LoadedImage.TryReadBeUInt32(bytes, offset + (uint)off, out value)); }
public long PeekBeInt64(uint offset) { return((long)LoadedImage.ReadBeUInt64(bytes, off)); }
public ulong PeekLeUInt64(uint offset) { return(LoadedImage.ReadLeUInt64(bytes, off)); }
public int PeekBeInt32(uint offset) { return((int)LoadedImage.ReadBeUInt32(bytes, offset + off)); }
public abstract ImageReader CreateNew(LoadedImage image, Address addr);
public override ImageReader CreateNew(LoadedImage image, Address addr) { return(new BeImageReader(image, (uint)(addr - image.BaseAddress))); }