/// <summary>
/// Create a simulatd program to use in the code /data display.
/// </summary>
private void GenerateSimulatedProgram()
{
var row = Enumerable.Range(0, 0x100).Select(b => (byte)b).ToArray();
var image = new LoadedImage(
Address.Ptr32(0x0010000),
Enumerable.Repeat(
row,
40).SelectMany(r => r).ToArray());
var imageMap = image.CreateImageMap();
var addrCode = Address.Ptr32(0x0010008);
var addrData = Address.Ptr32(0x001001A);
imageMap.AddItemWithSize(addrCode, new ImageMapBlock {
Address = addrCode, Size = 0x0E
});
imageMap.AddItemWithSize(addrData, new ImageMapItem {
Address = addrData, DataType = PrimitiveType.Byte, Size = 0x0E
});
var arch = dlg.Services.RequireService <IConfigurationService>().GetArchitecture("x86-protected-32");
this.program = new Program
{
Image = image,
ImageMap = imageMap,
Architecture = arch,
};
}
public void Rotations()
{
X86TextAssembler asm = new X86TextAssembler(new X86ArchitectureReal());
var lr = asm.AssembleFragment(
Address.SegPtr(0xB96, 0),
"foo proc\r\n"+
"rol ax,cl\r\n"+
"ror word ptr [bx+2],cl\r\n"+
"rcr word ptr [bp+4],4\r\n"+
"rcl ax,1\r\n");
LoadedImage img = lr.Image;
CreateDisassembler16(img.CreateLeReader(img.BaseAddress));
StringBuilder sb = new StringBuilder();
foreach (var instr in dasm.Take(4))
{
sb.AppendFormat("{0}\r\n", instr.ToString());
}
string s = sb.ToString();
Assert.AreEqual(
"rol\tax,cl\r\n" +
"ror\tword ptr [bx+02],cl\r\n" +
"rcr\tword ptr [bp+04],04\r\n" +
"rcl\tax,01\r\n", s);
}
public void Ose_FindReplace()
{
Given_Engine();
Given_Image(0x001000, new byte[] { 0x2a, 0x2a, 0x2a, 0x21, 0x23, 0x21, 0x23 });
host.Expect(h => h.WriteMemory(
Arg <ulong> .Is.Anything,
Arg <int> .Is.Equal(3),
Arg <byte[]> .Is.NotNull)).Do(new Func <ulong, int, byte[], bool>((a, l, b) =>
{
LoadedImage.WriteBytes(b, a - image.BaseAddress.ToLinear(), l, image.Bytes);
return(true);
}));
Given_Script(
"find 001000, #21??21#\r\n" +
"test $RESULT,$RESULT\r\n" +
"jz done\r\n" +
"fill $RESULT,3,2d\r\n" +
"done:\r\n"
);
mr.ReplayAll();
engine.Run();
Assert.AreEqual("***---#", Encoding.ASCII.GetString(image.Bytes));
}
private static SparcInstruction Disassemble(LoadedImage img)
{
var arch = new SparcArchitecture(PrimitiveType.Word32);
var dasm = new SparcDisassembler(arch, img.CreateBeReader(0U));
return(dasm.First());
}
public ExePackLoader(IServiceProvider services, string filename, byte[] imgRaw)
: base(services, filename, imgRaw)
{
arch = new IntelArchitecture(ProcessorMode.Real);
platform = new MsdosPlatform(Services, arch);
var exe = new ExeImageLoader(services, filename, imgRaw);
this.exeHdrSize = (uint)(exe.e_cparHeader * 0x10U);
this.hdrOffset = (uint)(exe.e_cparHeader + exe.e_cs) * 0x10U;
ImageReader rdr = new LeImageReader(RawImage, hdrOffset);
this.ip = rdr.ReadLeUInt16();
this.cs = rdr.ReadLeUInt16();
rdr.ReadLeUInt16();
this.cbExepackHeader = rdr.ReadLeUInt16();
this.sp = rdr.ReadLeUInt16();
this.ss = rdr.ReadLeUInt16();
this.cpUncompressed = rdr.ReadLeUInt16();
int offset = ExePackHeaderOffset(exe);
if (LoadedImage.CompareArrays(imgRaw, offset, signature, signature.Length))
{
relocationsOffset = 0x012D;
}
else if (LoadedImage.CompareArrays(imgRaw, offset, signature2, signature2.Length))
{
relocationsOffset = 0x0125;
}
else
{
throw new ApplicationException("Not a recognized EXEPACK image.");
}
}
static public bool IsCorrectUnpacker(ExeImageLoader exe, byte[] rawImg)
{
int offset = ExePackHeaderOffset(exe);
return(LoadedImage.CompareArrays(rawImg, offset, signature, signature.Length) ||
LoadedImage.CompareArrays(rawImg, offset, signature2, signature2.Length));
}
public void LLI_ShowMemoryAtAddressShouldChangeMemoryControl()
{
var sc = new ServiceContainer();
var ctrl = new LowLevelView();
var interactor = mr.DynamicMock <LowLevelViewInteractor>();
interactor.Expect(i => i.SelectedAddress).SetPropertyWithArgument(Address.Ptr32(0x4711));
var uiSvc = AddStubService <IDecompilerShellUiService>(sc);
AddStubService <IUiPreferencesService>(sc);
Given_Program();
uiSvc.Stub(x => x.FindDocumentWindow(null, null)).IgnoreArguments().Return(null);
uiSvc.Stub(x => x.CreateDocumentWindow("", null, "", null))
.IgnoreArguments()
.Return(mr.Stub <IWindowFrame>());
uiSvc.Stub(x => x.GetContextMenu(MenuIds.CtxMemoryControl)).Return(new ContextMenu());
uiSvc.Stub(x => x.GetContextMenu(MenuIds.CtxDisassembler)).Return(new ContextMenu());
var service = mr.Stub <LowLevelViewServiceImpl>(sc);
service.Stub(x => x.CreateMemoryViewInteractor()).Return(interactor);
var image = new LoadedImage(Address.Ptr32(0x1000), new byte[300]);
mr.ReplayAll();
interactor.SetSite(sc);
interactor.CreateControl();
service.ShowMemoryAtAddress(program, Address.Ptr32(0x4711));
mr.VerifyAll();
}
public bool LoadTileSheetFromFile()
{
try {
if (File.Exists(TileSheetUrl))
{
LoadedTileSheet = TileSheet.ReadFromFile(TileSheetUrl);
if (LoadedImage != null)
{
LoadedImage.Dispose();
}
Image newImage = null;
if (File.Exists(ImageUrl))
{
newImage = Image.FromFile(ImageUrl, true);
}
if (newImage != null)
{
LoadedImage = newImage;
LoadedTileSheet.TextureKey = Path.GetFileNameWithoutExtension(ImageUrl);
}
else
{
LoadedImage = null;
LoadedTileSheet.TextureKey = "";
}
UpdateSizeInFrames();
}
} catch (Exception e) {
System.Console.WriteLine("Exception while reading file: " + e.Message);
return(false);
}
return(true);
}
public BackwalkerHost(BlockWorkitem item)
{
this.scanner = item.scanner;
this.image = item.program.Image;
this.arch = item.program.Architecture;
this.platform = item.program.Platform;
}
public ResourceTypeCollection(byte [] bytes, uint offset, uint size)
{
this.bytes = bytes;
rsrcTypeListOff = offset + LoadedImage.ReadBeUInt16(bytes, offset + 0x18) + 2u;
rsrcNameListOff = offset + LoadedImage.ReadBeUInt16(bytes, offset + 0x1A);
crsrcTypes = LoadedImage.ReadBeUInt16(bytes, offset + 0x1C) + 1;
}
private void Rewrite(Action <M68kAssembler> build)
{
var asm = new M68kAssembler(arch, addrBase, new List <EntryPoint>());
build(asm);
image = asm.GetImage().Image;
}
/// <summary>
/// Load a Basic PRG.
/// </summary>
/// <param name="imageBytes"></param>
/// <returns></returns>
private Program LoadPrg(byte[] imageBytes)
{
var stm = new MemoryStream();
ushort preferredAddress = LoadedImage.ReadLeUInt16(imageBytes, 0);
ushort alignedAddress = (ushort)(preferredAddress & ~0xF);
int pad = preferredAddress - alignedAddress;
while (pad-- > 0)
{
stm.WriteByte(0);
}
stm.Write(imageBytes, 2, imageBytes.Length - 2);
var loadedBytes = stm.ToArray();
var image = new LoadedImage(
Address.Ptr16(alignedAddress),
loadedBytes);
var rdr = new C64BasicReader(image, 0x0801);
var prog = rdr.ToSortedList(line => (ushort)line.Address.ToLinear(), line => line);
var arch = new C64Basic(prog);
image = new LoadedImage(
Address.Ptr16(prog.Keys[0]),
new byte[0xFFFF]);
var program = new Program(
image,
image.CreateImageMap(),
arch,
new C64Platform(Services, null));
program.EntryPoints.Add(new EntryPoint(image.BaseAddress, arch.CreateProcessorState()));
return(program);
}
public ConstantPointerTraversal(IProcessorArchitecture arch, StructureType globalStr, LoadedImage image)
{
this.arch = arch;
this.globalStr = globalStr;
this.image = image;
this.Discoveries = new List <StructureField>();
}
protected static ArmInstruction Disassemble(byte[] bytes)
{
var image = new LoadedImage(Address.Ptr32(0x00100000), bytes);
var dasm = new ArmDisassembler2(new ArmProcessorArchitecture(), image.CreateLeReader(0));
return(dasm.First());
}
private void Run32bitTest(Action <X86Assembler> fn)
{
var m = Create32bitAssembler();
fn(m);
image = m.GetImage().Image;
}
private void chkShowData_CheckedChanged(object sender, EventArgs e)
{
if (chkShowData.Checked)
{
var img = new LoadedImage(Address.Ptr32(0x00100000), new byte[2560]);
var imgMap = new ImageMap(img.BaseAddress, img.Length);
imgMap.AddItemWithSize(Address.Ptr32(0x00100000), new ImageMapBlock {
Size = 30
});
imgMap.AddItemWithSize(Address.Ptr32(0x00100100), new ImageMapBlock {
Size = 300
});
imgMap.AddItemWithSize(Address.Ptr32(0x00100500), new ImageMapBlock {
Size = 600
});
memoryControl1.ProgramImage = img;
memoryControl1.Architecture = new X86ArchitectureFlat32();
imageMapView1.Image = img;
imageMapView1.ImageMap = imgMap;
}
else
{
memoryControl1.ProgramImage = null;
memoryControl1.Architecture = null;
}
}
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 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));
}
public TInstruction DisassembleWord(uint instr)
{
var img = new LoadedImage(LoadAddress, new byte[256]);
CreateImageWriter(img.Bytes).WriteUInt32(0, instr);
return(Disassemble(img));
}
// for LZEXE ver 0.90
private ImageMap Relocate90(byte [] pgmImg, ushort segReloc, LoadedImage pgmImgNew, RelocationDictionary relocations)
{
int ifile = lzHdrOffset + 0x19D;
// 0x19d=compressed relocation table address
throw new NotImplementedException();
/*
* unsigned int c;
* ushort rel_count=0;
* ushort rel_seg,rel_off;
*
* rel_seg=0;
* do
* {
* c=getw(ifile);
* for(;c>0;c--)
* {
* rel_off=getw(ifile);
* putw(rel_off,ofile);
* putw(rel_seg,ofile);
* rel_count++;
* }
* rel_seg += 0x1000;
* } while(rel_seg!=(0xf000+0x1000));
* ohead[3]=rel_count;
* return(SUCCESS);
*/
}
// Unpacks the relocation entries in a LzExe 0.91 binary
private ImageMap Relocate91(byte [] abUncompressed, ushort segReloc, LoadedImage pgmImgNew, RelocationDictionary relocations)
{
const int CompressedRelocationTableAddress = 0x0158;
int ifile = lzHdrOffset + CompressedRelocationTableAddress;
int rel_off = 0;
for (;;)
{
ushort span = abUncompressed[ifile++];
if (span == 0)
{
span = abUncompressed[ifile++];
span |= (ushort)(abUncompressed[ifile++] << 8);
if (span == 0)
{
rel_off += 0x0FFF0;
continue;
}
else if (span == 1)
{
break;
}
}
rel_off += span;
ushort seg = (ushort)(pgmImgNew.ReadLeUInt16((uint)rel_off) + segReloc);
pgmImgNew.WriteLeUInt16((uint)rel_off, seg);
relocations.AddSegmentReference((uint)rel_off, seg);
imageMap.AddSegment(Address.SegPtr(seg, 0), seg.ToString("X4"), AccessMode.ReadWriteExecute);
}
return(imageMap);
}
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);
}
private ImageWriter Memory(uint address)
{
image = new LoadedImage(Address.Ptr32(address), new byte[1024]);
var mem = new LeImageWriter(image.Bytes);
return(mem);
}
private void Given_Image(params byte[] bytes)
{
image = new LoadedImage(addrBase, bytes);
imageMap = image.CreateImageMap();
program = new Program(image, imageMap, arch, null);
interactor.Program = program;
}
public PkLiteUnpacker(IServiceProvider services, string filename, byte [] rawImg) : base(services, filename, rawImg)
{
var exe = new ExeImageLoader(services, filename, rawImg);
arch = new IntelArchitecture(ProcessorMode.Real);
platform = services.RequireService <IConfigurationService>()
.GetEnvironment("ms-dos")
.Load(services, arch);
uint pkLiteHdrOffset = (uint)(exe.e_cparHeader * 0x10);
if (RawImage[pkLiteHdrOffset] != 0xB8)
{
throw new ApplicationException(string.Format("Expected MOV AX,XXXX at offset 0x{0:X4}.", pkLiteHdrOffset));
}
uint cparUncompressed = LoadedImage.ReadLeUInt16(RawImage, pkLiteHdrOffset + 1);
abU = new byte[cparUncompressed * 0x10U];
if (RawImage[pkLiteHdrOffset + 0x04C] != 0x83)
{
throw new ApplicationException(string.Format("Expected ADD BX,+XX at offset 0x{0:X4}.", pkLiteHdrOffset + 0x04C));
}
uint offCompressedData = pkLiteHdrOffset + RawImage[pkLiteHdrOffset + 0x04E] * 0x10u - PspSize;
bitStm = new BitStream(RawImage, (int)offCompressedData);
}
protected void processImage()
{
using (LoadedImage sourceImage = ImageArchiver.LoadImage(this.imgSource.ImageUrl))
{
// Generate the image #1
string outputImageFileName = "~/repository/output/Ex_A_105___1.jpg";
new ScaledResizeConstraint(150, 250).SaveProcessedImageToFileSystem(sourceImage, outputImageFileName);
this.imgOutput1.ImageUrl = outputImageFileName + "?timestamp=" + DateTime.UtcNow.Ticks.ToString();
// Generate the image #2
outputImageFileName = "~/repository/output/Ex_A_105___2.jpg";
new FixedCropConstraint(150, 250).SaveProcessedImageToFileSystem(sourceImage, outputImageFileName);
this.imgOutput2.ImageUrl = outputImageFileName + "?timestamp=" + DateTime.UtcNow.Ticks.ToString();
// Generate the image #3
outputImageFileName = "~/repository/output/Ex_A_105___3.jpg";
new ImageProcessingJob(new ImageProcessingFilter[] {
new FixedResizeConstraint(150, 250),
DefaultColorFilters.Grayscale
}).SaveProcessedImageToFileSystem(sourceImage, outputImageFileName);
this.imgOutput3.ImageUrl = outputImageFileName + "?timestamp=" + DateTime.UtcNow.Ticks.ToString();
}
this.phOutputContainer.Visible = true;
this.phCodeContainer.Visible = true;
}
private IEnumerator <M68kInstruction> CreateDasm(byte[] bytes, uint address)
{
Address addr = Address.Ptr32(address);
LoadedImage img = new LoadedImage(addr, bytes);
return(M68kDisassembler.Create68020(img.CreateBeReader(addr)).GetEnumerator());
}
protected void CleanShutdown()
{
if (worldPixbuf != null)
{
worldPixbuf.Dispose();
}
if (worldImage.Pixbuf != null)
{
worldImage.Pixbuf.Dispose();
}
if (worldImage != null)
{
worldImage.Dispose();
}
if (LoadedImage.Pixbuf != null)
{
LoadedImage.Pixbuf.Dispose();
}
if (LoadedImage != null)
{
LoadedImage.Dispose();
}
Colonies.Clear();
}
private void Given_Program(byte[] bytes)
{
var addr = Address.Ptr32(0x1000);
var image = new LoadedImage(addr, bytes);
this.imageMap = image.CreateImageMap();
this.program = new Program(image, imageMap, arch, new DefaultPlatform(null, arch));
}
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));
}
/// <summary>
/// Loads an image from an array of bytes and applies a specific PictureTrimmerValue.</summary>
/// <param name="sourceImage">The source image to load.</param>
/// <param name="value">The PictureTrimmerValue to apply.</param>
public void LoadImage(LoadedImage sourceImage, PictureTrimmerValue value)
{
// Save the image - Use PNG as image format to preserve transparency
ImageArchiver.SaveImageToFileSystem(sourceImage.Image, this.TemporarySourceImageFilePath, new PngFormatEncoderParams());
// Load the image into the control
this.LoadImageFromFileSystem_Internal(this.TemporarySourceImageFilePath, sourceImage.Image, sourceImage.Size, sourceImage.FormatId, sourceImage.Resolution, false, value);
}
/// <summary>
/// Loads an image and auto-calculates the PictureTrimmerValue to use.</summary>
/// <param name="sourceImage">The source image to load.</param>
public void LoadImage(LoadedImage sourceImage)
{
this.LoadImage(sourceImage, null);
}
