public bool ResolvePointerPath(HookProcess process) { IntPtr nextAddress = baseAddress; bool asmStart = false; foreach (var offset in PointerPath) { try { baseAddress = new IntPtr(nextAddress.ToInt64() + offset); if (baseAddress == IntPtr.Zero) { return(false); } if (!asmStart) { nextAddress = baseAddress + process.GetInt32(new IntPtr(baseAddress.ToInt64())) + 4; asmStart = true; } else { nextAddress = process.ReadPointer(baseAddress); } } catch { return(false); } } return(true); }
public override object GetData(HookProcess process) { SigWorldData data = new SigWorldData { world = process.GetString(baseAddress, 0, 16) }; return((object)data); }
public void EnsureArrayIndexes(HookProcess process) { Indexes.Clear(); for (var i = 0; i < 1000; i++) { Indexes.Add((int)process.GetUInt(new IntPtr(ChatLogPointers.OffsetArrayStart + i * 4))); } }
public override object GetData(HookProcess process) { SigCharIdData data = new SigCharIdData { id = process.GetString(baseAddress, 0, 32), }; return((object)data); }
public Memory(Process proc) { ffxivProcess = new HookProcess(proc); string pipename = string.Format("BmpPipe{0}", proc.Id); dataPipe = new NamedPipeServer <PipeData>(pipename); dataPipe.ClientConnected += ClientConnected; dataPipe.Start(); Console.WriteLine(string.Format("Pipe name: {0}", pipename)); }
public IEnumerable <List <byte> > ResolveEntries(HookProcess process, int offset, int length) { List <List <byte> > entries = new List <List <byte> >(); for (var i = offset; i < length; i++) { EnsureArrayIndexes(process); var currentOffset = Indexes[i]; entries.Add(ResolveEntry(process, PreviousOffset, currentOffset)); PreviousOffset = currentOffset; } return(entries); }
public override object GetData(HookProcess process) { var result = new SigPerfData(); int entrySize = 12; int numEntries = 99; byte[] performanceData = process.GetByteArray(baseAddress, entrySize * numEntries); for (int i = 0; i < numEntries; i++) { int offset = (i * entrySize); float animation = BitConverter.TryToSingle(performanceData, offset + 0); byte id = performanceData[offset + 4]; byte unknown1 = performanceData[offset + 5]; byte variant = performanceData[offset + 6]; // Animation (hand to left or right) byte type = performanceData[offset + 7]; byte status = performanceData[offset + 8]; byte instrument = performanceData[offset + 9]; int unknown2 = BitConverter.TryToInt16(performanceData, offset + 10); if (id >= 0 && id <= 99) { PerformanceData item = new PerformanceData(); item.Animation = animation; item.Unknown1 = (byte)unknown1; item.Id = (byte)id; item.Variant = (byte)variant; item.Type = (byte)type; item.Status = (Performance.Status)status; item.Instrument = (Performance.Instrument)instrument; if (!result.Performances.ContainsKey(id)) { result.Performances[id] = item; } } } return(result); }
public override object GetData(HookProcess process) { IntPtr pointer = (IntPtr)process.GetInt64(baseAddress); string chattext = string.Empty; if (pointer != IntPtr.Zero) { int len = process.GetInt32(pointer, Offsets["OffsetInputLength"]); if (len <= 501) // ??? { IntPtr pointer2 = (IntPtr)process.GetInt64(pointer, Offsets["OffsetInputText"]); if (pointer2 != IntPtr.Zero) { chattext = process.GetString(pointer2, 0, len); } } } SigChatInputData data = new SigChatInputData { open = (pointer != IntPtr.Zero), text = chattext, }; return((object)data); }
public override object GetData(HookProcess process) { if (baseAddress.ToInt64() <= 6496) { return(null); } if (!Offsets.ContainsKey("SourceSize") || !Offsets.ContainsKey("EntityCount")) { Console.WriteLine("Couldn't find basic"); return(null); } if (!Offsets.ContainsKey("ID") || !Offsets.ContainsKey("Type")) { Console.WriteLine("Couldn't find player basic"); return(null); } var data = new SigActorsData(); int sourceSize = (int)Offsets["SourceSize"]; int limit = (int)Offsets["EntityCount"]; int ptrSize = 8; // 64 bit byte[] characterAddressMap = process.GetByteArray(baseAddress, ptrSize * limit); //byte[] baseSource = process.GetByteArray(baseAddress, sourceSize); Dictionary <IntPtr, IntPtr> uniqueAddresses = new Dictionary <IntPtr, IntPtr>(); IntPtr firstAddress = IntPtr.Zero; var firstTime = true; for (var i = 0; i < limit; i++) { IntPtr characterAddress = new IntPtr(BitConverter.TryToInt64(characterAddressMap, ptrSize * i)); if (characterAddress == IntPtr.Zero) { continue; } if (firstTime) { firstAddress = characterAddress; firstTime = false; } uniqueAddresses[characterAddress] = characterAddress; } // Add everyone to removed foreach (KeyValuePair <uint, ActorData> kvp in tempActors) { data.removedActors.Add(kvp.Key, new ActorData() { id = kvp.Value.id, }); } foreach (KeyValuePair <IntPtr, IntPtr> kvp in uniqueAddresses) { var characterAddress = new IntPtr(kvp.Value.ToInt64()); byte[] playerSource = process.GetByteArray(characterAddress, sourceSize); ActorData existing = null; ActorData actorData = new ActorData() { id = BitConverter.TryToUInt32(playerSource, Offsets["ID"]), }; bool addActor = false; int type = playerSource[Offsets["Type"]]; if (type == 0x01) // Player { if (data.removedActors.ContainsKey(actorData.id)) { data.removedActors.Remove(actorData.id); tempActors.TryGetValue(actorData.id, out existing); } else { addActor = true; } // Was used for TargetID //var isFirstEntry = kvp.Value.ToInt64() == firstAddress.ToInt64(); if (true) { if (Offsets.TryGetValue("Name", out int nameid)) { actorData.name = process.GetStringFromBytes(playerSource, nameid); } if (Offsets.TryGetValue("PerformanceID", out int perfid)) { actorData.perfid = playerSource[perfid]; } } if (actorData.id != 0) { if (expiringActors.ContainsKey(actorData.id)) { expiringActors.Remove(actorData.id); } } else { // Removed data.addedActors.Remove(actorData.id); continue; } // Only getting memory, no checks? //EnsureMapAndZone(entry); /* * if (isFirstEntry) { * if (targetAddress.ToInt64() > 0) { * byte[] targetInfoSource = MemoryHandler.Instance.GetByteArray(targetAddress, 128); * entry.TargetID = (int)BitConverter.TryToUInt32(targetInfoSource, MemoryHandler.Instance.Structures.ActorItem.ID); * } * } */ // If removed player, just continue if (existing != null) { continue; } if (addActor) { if (!tempActors.ContainsKey(actorData.id)) { tempActors.Add(actorData.id, actorData); } data.addedActors.Add(actorData.id, actorData); } } } // Stale removal? DateTime now = DateTime.Now; TimeSpan staleActorRemovalTime = TimeSpan.FromSeconds(0.25); foreach (KeyValuePair <uint, ActorData> kvp2 in data.removedActors) { if (!expiringActors.ContainsKey(kvp2.Key)) { expiringActors[kvp2.Key] = now + staleActorRemovalTime; } } // check expiring list for stale actors foreach (KeyValuePair <uint, DateTime> kvp2 in expiringActors.ToList()) { if (now > kvp2.Value) { tempActors.Remove(kvp2.Key); expiringActors.Remove(kvp2.Key); } else { data.removedActors.Remove(kvp2.Key); } } data.currentActors = tempActors; return(data); }
public Memory(Process proc) { ffxivProcess = new HookProcess(proc); }
// returns not found public static List <Signature> ResolveSignatures(HookProcess proc, ref List <Signature> signatures) { const int bufferSize = 0x1200; const int regionIncrement = 0x1000; byte[] buffer = new byte[bufferSize]; List <Signature> notFound = new List <Signature>(signatures); List <Signature> temp = new List <Signature>(); var regionCount = 0; IntPtr baseAddress = proc.BaseAddress; IntPtr searchEnd = proc.EndAddress; IntPtr searchStart = baseAddress; while (searchStart.ToInt64() < searchEnd.ToInt64()) { try { IntPtr lpNumberOfBytesRead; var regionSize = new IntPtr(bufferSize); if (IntPtr.Add(searchStart, bufferSize).ToInt64() > searchEnd.ToInt64()) { regionSize = (IntPtr)(searchEnd.ToInt64() - searchStart.ToInt64()); } if (UnsafeNativeMethods.ReadProcessMemory(proc.Handle, searchStart, buffer, regionSize, out lpNumberOfBytesRead)) { foreach (Signature signature in notFound) { string sig = signature.Value; byte[] sigbytes = SignatureToByte(sig, WildCardChar); var index = FindSuperSignature(buffer, sigbytes); if (index < 0) { temp.Add(signature); continue; } var baseResult = new IntPtr((long)(baseAddress + regionCount * regionIncrement)); IntPtr searchResult = IntPtr.Add(baseResult, index + signature.Offset); signature.baseAddress = new IntPtr(searchResult.ToInt64()); } notFound = new List <Signature>(temp); temp.Clear(); } regionCount++; searchStart = IntPtr.Add(searchStart, regionIncrement); } catch (Exception ex) { //MemoryHandler.Instance.RaiseException(Logger, ex, true); Console.WriteLine("Resolve signatures " + ex.ToString()); } } // Clear out foreach (Signature signature in notFound) { signatures.Remove(signature); } List <Signature> fixedSignatures = new List <Signature>(); foreach (Signature signature in signatures) { Signature sig = signature; if (!string.IsNullOrEmpty(sig.Type)) { Type t = Type.GetType("FFMemoryParser." + sig.Type); if (t != null) { sig = (Signature)Activator.CreateInstance(t, sig); sig.ResolvePointerPath(proc); Console.WriteLine(string.Format("{0} {1} {2}", sig.Key, sig.baseAddress, sig.baseAddress)); fixedSignatures.Add(sig); continue; } } Console.WriteLine(string.Format("Could not find type for {0}", sig.Key)); } signatures = fixedSignatures; return(notFound); }
private static List <UnsafeNativeMethods.MEMORY_BASIC_INFORMATION> LoadRegions(HookProcess proc) { try { var _regions = new List <UnsafeNativeMethods.MEMORY_BASIC_INFORMATION>(); IntPtr address = IntPtr.Zero; while (true) { var info = new UnsafeNativeMethods.MEMORY_BASIC_INFORMATION(); var result = UnsafeNativeMethods.VirtualQueryEx(proc.Handle, address, out info, (uint)Marshal.SizeOf(info)); if (result == 0) { break; } if (!proc.IsSystemModule(info.BaseAddress) && (info.State & MemCommit) != 0 && (info.Protect & Writable) != 0 && (info.Protect & PageGuard) == 0) { _regions.Add(info); } else { //MemoryHandler.Instance.RaiseException(Logger, new Exception(info.ToString())); } unchecked { switch (IntPtr.Size) { case sizeof(int): address = new IntPtr(info.BaseAddress.ToInt32() + info.RegionSize.ToInt32()); break; default: address = new IntPtr(info.BaseAddress.ToInt64() + info.RegionSize.ToInt64()); break; } } } return(_regions); } catch (Exception ex) { //MemoryHandler.Instance.RaiseException(Logger, ex, true); Console.WriteLine("DURRR ", ex.ToString()); return(new List <UnsafeNativeMethods.MEMORY_BASIC_INFORMATION>()); } }
public override object GetData(HookProcess process) { var result = new SigChatLogData(); chatReader.PreviousArrayIndex = previousArrayIndex; chatReader.PreviousOffset = previousOffset; if (baseAddress.ToInt64() <= 20) { return(result); } List <List <byte> > buffered = new List <List <byte> >(); try { chatReader.Indexes.Clear(); chatReader.ChatLogPointers = new ChatLogPointers { LineCount = (uint)process.GetUInt(baseAddress), OffsetArrayStart = process.GetUInt(baseAddress, Offsets["OffsetArrayStart"]), OffsetArrayPos = process.GetUInt(baseAddress, Offsets["OffsetArrayPos"]), OffsetArrayEnd = process.GetUInt(baseAddress, Offsets["OffsetArrayEnd"]), LogStart = process.GetUInt(baseAddress, Offsets["LogStart"]), LogNext = process.GetUInt(baseAddress, Offsets["LogNext"]), LogEnd = process.GetUInt(baseAddress, Offsets["LogEnd"]), }; chatReader.EnsureArrayIndexes(process); // Convenience ChatLogPointers ptrs = chatReader.ChatLogPointers; var currentArrayIndex = (ptrs.OffsetArrayPos - ptrs.OffsetArrayStart) / 4; if (chatReader.ChatLogFirstRun) { chatReader.ChatLogFirstRun = false; chatReader.PreviousOffset = chatReader.Indexes[(int)currentArrayIndex - 1]; chatReader.PreviousArrayIndex = (int)currentArrayIndex - 1; } else { if (currentArrayIndex < chatReader.PreviousArrayIndex) { buffered.AddRange(chatReader.ResolveEntries(process, chatReader.PreviousArrayIndex, 1000)); chatReader.PreviousOffset = 0; chatReader.PreviousArrayIndex = 0; } if (chatReader.PreviousArrayIndex < currentArrayIndex) { buffered.AddRange(chatReader.ResolveEntries(process, chatReader.PreviousArrayIndex, (int)currentArrayIndex)); } chatReader.PreviousArrayIndex = (int)currentArrayIndex; } } catch (Exception ex) { return(null); } foreach (List <byte> bytes in buffered.Where(b => b.Count > 0)) { try { ChatLogItem chatLogEntry = ChatEntry.Process(bytes.ToArray()); if (Regex.IsMatch(chatLogEntry.Combined, @"[\w\d]{4}::?.+")) { result.chatMessages.Add(chatLogEntry); } } catch (Exception ex) { } } previousArrayIndex = chatReader.PreviousArrayIndex; previousOffset = chatReader.PreviousOffset; return(result); }
private List <byte> ResolveEntry(HookProcess process, int offset, int length) { return(new List <byte>(process.GetByteArray(new IntPtr(ChatLogPointers.LogStart + offset), length - offset))); }
public virtual object GetData(HookProcess process) { return(null); }