public MemoryAccessor(IMemoryReader mr, long offset = 0) { // Efficient nesting of MemoryAccessors: eliminating long call chains to the base IMemoryReader if (mr is MemoryAccessor ma) { this.offset = offset + ma.offset; this.reader = ma.reader; } else { this.offset = offset; this.reader = mr; } }
override public void Aktualisiire( IMemoryReader AusProzesLeeser, out bool Geändert, Int64 Zait, int?ZuLeeseListeOktetAnzaal = null) { base.Aktualisiire( AusProzesLeeser, out Geändert, Zait, ZuLeeseListeOktetAnzaal); WertFloat64 = ObjektBegin.BaiPlus8Double; }
static public Boolean ToInt32(IMemoryReader tMemory, UInt32 tAddress, ref Int32 tData) { Boolean tResult = false; if (null == tMemory) { return(false); } Byte[] tBuffer = new Byte[4]; tResult = tMemory.Read(tAddress, ref tBuffer, 4); tData = BitConverter.ToInt32(tBuffer, 0); return(tResult); }
private void init(int address, int Length, sbyte[] fromMacAddress, sbyte[] toMacAddress) { FromMacAddress = fromMacAddress; ToMacAddress = toMacAddress; data = new sbyte[Length]; if (Length > 0 && address != 0) { IMemoryReader memoryReader = MemoryReader.getMemoryReader(address, Length, 1); for (int i = 0; i < Length; i++) { data[i] = (sbyte)memoryReader.readNext(); } } }
protected int ZwiscenscpaicerListeOktetFüleAusProzes( IMemoryReader AusProzesLeeser, int ListeOktetAnzaal) { var HerkunftAdrese = this.HerkunftAdrese; var ListeOktetAnzaalBescrankt = Math.Max(0, ListeOktetAnzaal); var VorherZwiscenscpaicerListeOktet = AusScpaicerLeeseLezteListeOktetUndAnzaal.Key; var ZwiscenscpaicerListeOktet = VorherZwiscenscpaicerListeOktet; if (null != ZwiscenscpaicerListeOktet) { if (ZwiscenscpaicerListeOktet.Length < ListeOktetAnzaalBescrankt || ListeOktetAnzaalBescrankt < ZwiscenscpaicerListeOktet.Length / 2 - 10) { // Vorhandener Puffer ist zu klain oder zu groos und wird daher nit waiterverwendet. ZwiscenscpaicerListeOktet = null; } } if (null == ZwiscenscpaicerListeOktet) { ZwiscenscpaicerListeOktet = new byte[ListeOktetAnzaalBescrankt + 4]; } else { // Für Debugging: für den Fal das leese feelscläägt wääre es üübersictlicer wen Array nuur 0 enthalt. Array.Clear(ZwiscenscpaicerListeOktet, 0, ListeOktetAnzaalBescrankt); } int GeleeseListeOktetAnzaal = 0; try { if (null == AusProzesLeeser) { return(GeleeseListeOktetAnzaal); } GeleeseListeOktetAnzaal = (int)AusProzesLeeser.ListeOktetLeeseVonAdrese(HerkunftAdrese, ListeOktetAnzaalBescrankt, ZwiscenscpaicerListeOktet); } finally { this.AusScpaicerLeeseLezteListeOktetUndAnzaal = new KeyValuePair <byte[], int>(ZwiscenscpaicerListeOktet, GeleeseListeOktetAnzaal); } return(GeleeseListeOktetAnzaal); }
override public void Aktualisiire( IMemoryReader AusProzesLeeser, out bool Geändert, Int64 Zait, int?ZuLeeseListeOktetAnzaal = null) { base.Aktualisiire( AusProzesLeeser, out Geändert, Zait, ZuLeeseListeOktetAnzaal); WertBool = 0 != WertInt32; }
private static IEnumerable <NdrProcedureDefinition> ReadProcs(IMemoryReader reader, MIDL_SERVER_INFO server_info, int start_offset, int dispatch_count, NdrTypeCache type_cache, ISymbolResolver symbol_resolver, IList <string> names, NdrParserFlags parser_flags) { RPC_SYNTAX_IDENTIFIER transfer_syntax = server_info.GetTransferSyntax(reader); IntPtr proc_str = IntPtr.Zero; IntPtr fmt_str_ofs = IntPtr.Zero; if (transfer_syntax.SyntaxGUID != NdrNativeUtils.DCE_TransferSyntax) { MIDL_SYNTAX_INFO[] syntax_info = server_info.GetSyntaxInfo(reader); if (!syntax_info.Any(s => s.TransferSyntax.SyntaxGUID == NdrNativeUtils.DCE_TransferSyntax)) { throw new NdrParserException("Can't parse NDR64 syntax data"); } MIDL_SYNTAX_INFO dce_syntax_info = syntax_info.First(s => s.TransferSyntax.SyntaxGUID == NdrNativeUtils.DCE_TransferSyntax); proc_str = dce_syntax_info.ProcString; fmt_str_ofs = dce_syntax_info.FmtStringOffset; } else { proc_str = server_info.ProcString; fmt_str_ofs = server_info.FmtStringOffset; } IntPtr[] dispatch_funcs = server_info.GetDispatchTable(reader, dispatch_count); MIDL_STUB_DESC stub_desc = server_info.GetStubDesc(reader); IntPtr type_desc = stub_desc.pFormatTypes; NDR_EXPR_DESC expr_desc = stub_desc.GetExprDesc(reader); List <NdrProcedureDefinition> procs = new List <NdrProcedureDefinition>(); if (fmt_str_ofs != IntPtr.Zero) { for (int i = start_offset; i < dispatch_count; ++i) { int fmt_ofs = reader.ReadInt16(fmt_str_ofs + i * 2); if (fmt_ofs >= 0) { string name = null; if (names != null) { name = names[i - start_offset]; } procs.Add(new NdrProcedureDefinition(reader, type_cache, symbol_resolver, stub_desc, proc_str + fmt_ofs, type_desc, expr_desc, dispatch_funcs[i], name, parser_flags)); } } } return(procs.AsReadOnly()); }
public CaptureImage(int imageaddr, int level, IMemoryReader imageReader, int width, int height, int bufferWidth, bool invert, bool overwriteFile, string fileNamePrefix) { this.imageaddr = imageaddr; this.level = level; this.imageReader = imageReader; this.width = width; this.height = height; this.bufferWidth = bufferWidth; this.bufferStorage = TPSM_PIXEL_STORAGE_MODE_32BIT_ABGR8888; this.compressedImage = false; this.compressedImageSize = 0; this.invert = invert; this.overwriteFile = overwriteFile; this.fileNamePrefix = string.ReferenceEquals(fileNamePrefix, null) ? "Image" : fileNamePrefix; }
public PyTypeObject( Int64 BaseAddress, IMemoryReader MemoryReader) : base( BaseAddress, MemoryReader) { tp_name = MemoryReader.ReadUInt32(BaseAddress + Offset_tp_name); if (tp_name < int.MaxValue) { tp_name_Val = MemoryReader.ReadStringAsciiNullTerminated(tp_name.Value, 0x100); } }
public virtual void setStallAddr(int stall_addr, IMemoryReader baseMemoryReader, int startAddress, int endAddress) { lock (this) { // Both the stall address and the base memory reader need to be set at the same // time in a synchronized call in order to avoid any race condition // with the GUI thread (VideoEngine). StallAddr = stall_addr; this.baseMemoryReader = baseMemoryReader; this.baseMemoryReaderStartAddress = startAddress; this.baseMemoryReaderEndAddress = endAddress; resetMemoryReader(pc); } }
//public static Logger log = Modules.getLogger("sceParseHttp"); private string getHeaderString(IMemoryReader memoryReader) { StringBuilder line = new StringBuilder(); while (true) { int c = memoryReader.readNext(); if (c == '\n' || c == '\r') { break; } line.Append((char)c); } return(line.ToString()); }
override public void Aktualisiire( IMemoryReader AusProzesLeeser, out bool Geändert, Int64 Zait, int?ZuLeeseListeOktetAnzaal = null) { Geändert = false; bool BaseGeändert; base.Aktualisiire(AusProzesLeeser, out BaseGeändert, Zait, ZuLeeseListeOktetAnzaal); Geändert = BaseGeändert; BaiPlus20Ref = ObjektBegin.BaiPlus20UInt32; }
override public void Aktualisiire( IMemoryReader AusProzesLeeser, out bool Geändert, Int64 Zait, int?ZuLeeseListeOktetAnzaal = null) { Geändert = false; bool BaseGeändert; base.Aktualisiire(AusProzesLeeser, out BaseGeändert, Zait, ZuLeeseListeOktetAnzaal); Geändert = BaseGeändert; RefTexture = BaiPlus8Ref; }
private void init() { stackIndex = 0; blockedThreadIds.Clear(); finished = true; paused = false; reset_Renamed = true; ended = true; restarted = false; memoryReader = null; baseMemoryReader = null; baseMemoryReaderStartAddress = 0; baseMemoryReaderEndAddress = 0; pc = 0; saveContextAddr = 0; }
public static uint?ReadUInt32(this IMemoryReader memoryReader, long address) { if (memoryReader == null) { return(null); } uint[] array = memoryReader.ReadArray <uint>(address, 4); if (array == null) { return(null); } if (array.Length < 1) { return(null); } return(array[0]); }
public static byte[] ReadBytes(this IMemoryReader memoryReader, long address, int bytesCountMax) { byte[] array = new byte[bytesCountMax]; int num = memoryReader.ReadBytes(address, bytesCountMax, array); if (num < 1) { return(null); } if (num == array.Length) { return(array); } byte[] array2 = new byte[num]; Buffer.BlockCopy(array, 0, array2, 0, array2.Length); return(array2); }
public override void setCompressedTexImage(int level, int internalFormat, int width, int height, int compressedSize, Buffer buffer) { if (useTextureCache) { cachedTextureStatistics.start(); // TODO Cache all the texture levels if (level == 0) { int bufferWidth = context.texture_buffer_width[level]; IMemoryReader imageReader = ImageReader.getImageReader(context.texture_base_pointer[level], width, height, bufferWidth, internalFormat, false, 0, 0, 0, 0, 0, 0, null, null); CachedTexture cachedTexture = CachedTexture.getCachedTexture(System.Math.Min(width, bufferWidth), height, internalFormat, imageReader); CachedTextureResampled cachedTextureResampled = new CachedTextureResampled(cachedTexture); cachedTextures[bindTexture_Renamed] = cachedTextureResampled; } cachedTextureStatistics.end(); } }
protected internal static sbyte[] getBytesUTF8(int addr) { IMemoryReader memoryReader = MemoryReader.getMemoryReader(addr, 1); sbyte[] bytes = new sbyte[0]; while (true) { int utf8 = memoryReader.readNext(); if (utf8 == 0) { break; } bytes = addByteToArray(bytes, (sbyte)utf8); } return(bytes); }
// Helper to read an IntPtr from the target IntPtr ReadIntPtrFromTarget(IMemoryReader reader, IntPtr ptr) { // This is not cross-platform: it assumes host and target are the same size. byte[] buffer = new byte[IntPtr.Size]; reader.ReadMemory(ptr, buffer); System.UInt64 val = 0; // Note: this is dependent on endienness. for (int i = buffer.Length - 1; i >= 0; i--) { val <<= 8; val += buffer[i]; } IntPtr newptr = new IntPtr(unchecked ((long)val)); return(newptr); }
public virtual void updateValues() { values = new int[Length >> 2]; if (RuntimeContext.hasMemoryInt(address)) { Array.Copy(RuntimeContext.MemoryInt, address >> 2, values, 0, values.Length); } else { IMemoryReader memoryReader = MemoryReader.getMemoryReader(rawAddress, Length, 4); for (int i = 0; i < values.Length; i++) { values[i] = memoryReader.readNext(); } } }
override public void Ersctele(IMemoryReader DaatenKwele) { base.Ersctele(DaatenKwele); LaadeListeOktetWenBisherKlainerAlsAnzaalVermuutung(DaatenKwele); var ListeOktet = this.ListeOktet; if (null == ListeOktet) { return; } WertSictListeOktet = ListeOktet.Skip(IntBeginOktetIndex).ToArray(); this.WertSictIntModulo64Abbild = WertSictIntModulo64(WertSictListeOktet); }
void RedoXts() { if (accessor == null) { return; } dataKey.Text = dataKey.Text.PadRight(32, '0'); tweakKey.Text = tweakKey.Text.PadRight(32, '0'); var data = dataKey.Text.FromHexCompact(); var tweak = tweakKey.Text.FromHexCompact(); uint start, sectorSize; uint.TryParse(xtsStartSector.Text, out start); uint.TryParse(xtsSectorSize.Text, out sectorSize); xtsReader = new XtsDecryptReader(accessor, data, tweak, start, sectorSize); UpdateHexView(); }
public static uint?ReadPointerPath32(this IMemoryReader memoryReader, string rootModuleName, uint[] listOffset) { if (memoryReader == null) { return(null); } if (listOffset == null) { return(null); } if (listOffset.Length < 1) { return(null); } uint num = 0u; if (rootModuleName != null) { MemoryReaderModuleInfo[] array = memoryReader.Modules(); if (array == null) { return(null); } MemoryReaderModuleInfo memoryReaderModuleInfo = array.FirstOrDefault((MemoryReaderModuleInfo module) => module.ModuleName.EqualsIgnoreCase(rootModuleName)); if (memoryReaderModuleInfo == null) { return(null); } num = (uint)memoryReaderModuleInfo.BaseAddress; } uint num2 = num; for (int i = 0; i < listOffset.Length - 1; i++) { uint num3 = listOffset[i]; num2 += num3; uint?num4 = memoryReader.ReadUInt32(num2); if (!num4.HasValue) { return(null); } num2 = num4.Value; } return(num2 + listOffset.LastOrDefault()); }
public virtual void setHelloOpt(int optLen, int optData) { if (optLen <= 0 || optData == 0) { this.helloOptData = null; return; } // Copy the HelloOpt into an internal buffer, the user memory can be overwritten // after this call. IMemoryReader memoryReader = MemoryReader.getMemoryReader(optData, optLen, 1); helloOptData = new sbyte[optLen]; for (int i = 0; i < optLen; i++) { helloOptData[i] = (sbyte)memoryReader.readNext(); } }
private void copyToCachedMemory(int address, int Length) { int offset = getBufferOffset(address) >> 2; int n = Length >> 2; if (RuntimeContext.hasMemoryInt()) { Array.Copy(RuntimeContext.MemoryInt, address >> 2, cachedMemory, offset, n); } else { IMemoryReader memoryReader = MemoryReader.getMemoryReader(address, Length, 4); for (int i = 0; i < n; i++) { cachedMemory[offset + i] = memoryReader.readNext(); } } }
public static void ReadArray <T>(this IMemoryReader reader, long pos, T[] value, int offset, int count) where T : struct { // Fast path for bytes if (value is byte[] b) { reader.Read(pos, b, offset, count); return; } // Slow path int sizeOfT = Marshal.SizeOf(typeof(T)); var buf = new byte[sizeOfT * count]; reader.Read(pos, buf, 0, sizeOfT * count); for (var i = 0; i < count; i++) { value[i] = ByteArrayToStructure <T>(buf, i * sizeOfT); } }
public static T[] ReadArray <T>(this IMemoryReader memoryReader, long address, int numberOfBytes) where T : struct { if (memoryReader == null) { return(null); } byte[] array = memoryReader.ReadBytes(address, numberOfBytes); if (array == null) { return(null); } int num = Marshal.SizeOf(typeof(T)); int num2 = (array.Length - 1) / num + 1; T[] array2 = new T[num2]; Buffer.BlockCopy(array, 0, array2, 0, array.Length); return(array2); }
override public void Ersctele(IMemoryReader DaatenKwele) { base.Ersctele(DaatenKwele); var ListeOktet = this.ListeOktet; if (null != ListeOktet) { var ListeItemListeOktet = (ListeOktet ?? new byte[0]).Skip(0xC).ToArray(); var ListeItemAnzaal = ListeItemListeOktet.Length / 4; var ListeItemRef = new UInt32[ListeItemAnzaal]; Buffer.BlockCopy(ListeOktet, 0xC, ListeItemRef, 0, ListeItemRef.Length * 4); this.ListeItemRef = ListeItemRef.Select((ItemRef) => (Int64)ItemRef).ToArray(); } }
internal static T[] EnumeratePointerList <T>(this IMemoryReader reader, IntPtr p, Func <IntPtr, T> load_type) { List <T> ret = new List <T>(); if (p == IntPtr.Zero) { return(new T[0]); } IntPtr curr = p; IntPtr value = IntPtr.Zero; while ((value = reader.ReadIntPtr(curr)) != IntPtr.Zero) { ret.Add(load_type(value)); curr += reader.PointerSize; } return(ret.ToArray()); }
/// <summary> /// enumerates all Addresses which are aligned to 32Bits and hold the value <paramref name="SearchedValue"/>. /// </summary> /// <param name="MemoryReader"></param> /// <param name="SearchedValue"></param> /// <param name="SearchedRegionBegin"></param> /// <param name="SearchedRegionEnd"></param> /// <returns></returns> static public IEnumerable <Int64> AddressesHoldingValue32Aligned32( this IMemoryReader MemoryReader, UInt32 SearchedValue, Int64 SearchedRegionBegin, Int64 SearchedRegionEnd) { if (null == MemoryReader) { yield break; } var FirstBlockAddress = (SearchedRegionBegin / Static.Specialisation_RuntimeCost_BlockSize) * Static.Specialisation_RuntimeCost_BlockSize; var LastBlockAddress = (SearchedRegionEnd / Static.Specialisation_RuntimeCost_BlockSize) * Static.Specialisation_RuntimeCost_BlockSize; for (Int64 BlockAddress = FirstBlockAddress; BlockAddress <= LastBlockAddress; BlockAddress += Static.Specialisation_RuntimeCost_BlockSize) { var BlockValues = MemoryReader.ReadArray <UInt32>(BlockAddress, Static.Specialisation_RuntimeCost_BlockSize); if (null == BlockValues) { continue; } for (int InBlockIndex = 0; InBlockIndex < BlockValues.Length; InBlockIndex++) { var Address = BlockAddress + (InBlockIndex * 4); if (Address < SearchedRegionBegin || SearchedRegionEnd < Address) { continue; } if (SearchedValue == BlockValues[InBlockIndex]) { yield return(Address); } } } }
// Helper to read an IntPtr from the target private IntPtr ReadIntPtrFromTarget(IMemoryReader reader, IntPtr ptr) { // This is not cross-platform: it assumes host and target are the same size. var buffer = new byte[IntPtr.Size]; reader.ReadMemory(ptr, buffer); UInt64 val = 0; // Note: this is dependent on endienness. for (int i = buffer.Length - 1; i >= 0; i--) { val <<= 8; val += buffer[i]; } var newptr = new IntPtr(unchecked((long) val)); return newptr; }
/// <summary> /// Read the image name from the target. /// </summary> /// <param name="reader">access to target's memory</param> /// <returns>String for full path to image. Null if name not available</returns> /// <remarks>MSDN says this will never be provided for during Attach scenarios; nor for the first 1 or 2 dlls.</remarks> public string ReadImageNameFromTarget(IMemoryReader reader) { string moduleName; bool bUnicode = (fUnicode != 0); if (lpImageName == IntPtr.Zero) { return null; } else { try { IntPtr newptr = ReadIntPtrFromTarget(reader, lpImageName); if (newptr == IntPtr.Zero) { return null; } else { int charSize = (bUnicode) ? 2 : 1; var buffer = new byte[charSize]; var sb = new StringBuilder(); while (true) { // Read 1 character at a time. This is extremely inefficient, // but we don't know the whole length of the string and it ensures we don't // read off a page. reader.ReadMemory(newptr, buffer); int b; if (bUnicode) { b = buffer[0] + (buffer[1] << 8); } else { b = buffer[0]; } if (b == 0) // string is null-terminated { break; } sb.Append((char) b); newptr = new IntPtr(newptr.ToInt64() + charSize); // move to next character } moduleName = sb.ToString(); } } catch (InvalidOperationException) // ignore failures to read { return null; } } return moduleName; }
// /// <summary> /// Read the log message from the target. /// </summary> /// <param name="reader">interface to access debuggee memory</param> /// <returns>string containing message or null if not available</returns> public string ReadMessageFromTarget(IMemoryReader reader) { try { bool isUnicode = (fUnicode != 0); int cbCharSize = (isUnicode) ? 2 : 1; var buffer = new byte[nDebugStringLength*cbCharSize]; reader.ReadMemory(lpDebugStringData, buffer); var sb = new StringBuilder(); for (int i = 0; i < buffer.Length; i += cbCharSize) { int val; if (isUnicode) { val = buffer[i] + (buffer[i + 1] << 8); } else { val = buffer[i]; } sb.Append((char) val); } return sb.ToString(); } catch (InvalidOperationException) { return null; } }