//Calculate Pointer public int CalculatePointer(int iMemoryAddress, int[] iOffsets) { int iPointerCount = iOffsets.Length - 1; IntPtr ptrBytesRead; byte[] bBuffer = new byte[4]; int iTemporaryAddress = 0; if (iPointerCount == 0) { iTemporaryAddress = iMemoryAddress; } for (int i = 0; i <= iPointerCount; i++) { if (i == iPointerCount) { ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iTemporaryAddress, bBuffer, 4, out ptrBytesRead); iTemporaryAddress = Conversions.Conversions.HexToInt(CreateAddress(bBuffer)) + iOffsets[i]; return(iTemporaryAddress); } else if (i == 0) { ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptrBytesRead); iTemporaryAddress = Conversions.Conversions.HexToInt(CreateAddress(bBuffer)) + iOffsets[0]; } else { ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iTemporaryAddress, bBuffer, 4, out ptrBytesRead); iTemporaryAddress = Conversions.Conversions.HexToInt(CreateAddress(bBuffer)) + iOffsets[i]; } } return(0); }
public Byte[] ReadAOB(IntPtr iMemoryAddress, uint iBytesToRead) { byte[] bBuffer = new byte[iBytesToRead]; IntPtr ptrBytesRead; ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, iMemoryAddress, bBuffer, iBytesToRead, out ptrBytesRead); return(bBuffer); }
public byte[] ReadMemory(IntPtr memoryaddress, uint bytesToRead, out int bytesRead) { byte[] buffer = new byte[bytesToRead]; IntPtr pBytesRead; int returned = ProcessMemoryReaderApi.ReadProcessMemory(handle, memoryaddress, buffer, bytesToRead, out pBytesRead); bytesRead = pBytesRead.ToInt32(); return(buffer); }
public byte[] ReadProcessMemory(IntPtr MemoryAddress, UInt64 bytesToRead, out Int64 bytesRead, byte[] buffer) { IntPtr ptrBytesRead = new IntPtr(); int rval = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead); bytesRead = ptrBytesRead.ToInt64(); return(buffer); }
public int ReadProcessInt(IntPtr MemoryAddress) { byte[] buffer = new byte[4]; IntPtr ptrBytesRead; ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, 4, out ptrBytesRead); return(BitConverter.ToInt32(buffer, 0)); }
public byte[] ReadProcessMemory(IntPtr MemoryAddress, uint bytesToRead, out int bytesRead) { byte[] buffer = new byte[bytesToRead]; IntPtr ptrBytesRead; int code = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead); bytesRead = ptrBytesRead.ToInt32(); return(buffer); }
public string ReadProcessMemoryString(IntPtr MemoryAddress, uint bytesToRead, out int bytesRead) { byte[] buffer = new byte[bytesToRead]; IntPtr ptrBytesRead; ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead); bytesRead = ptrBytesRead.ToInt32(); return(System.Text.Encoding.Default.GetString(buffer)); }
public double ReadDouble(UInt64 iMemoryAddress) { byte[] bBuffer = new byte[8]; IntPtr ptrBytesRead; int iReturn = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 8, out ptrBytesRead); if (iReturn == 0) { return(0); } else { return(BitConverter.ToDouble(bBuffer, 0)); } }
public Int32 ReadInt32(UInt64 iMemoryAddress) { byte[] bBuffer = new byte[4]; IntPtr ptrBytesRead; int iReturn = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptrBytesRead); if (iReturn == 0) { return(0); } else { return(BitConverter.ToInt32(bBuffer, 0)); } }
public SByte ReadSByte(UInt64 iMemoryAddress) { byte[] bBuffer = new byte[1]; IntPtr ptrBytesRead; int iReturn = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 1, out ptrBytesRead); if (iReturn == 0) { return(0); } else { return((SByte)bBuffer[0]); } }
public int ReadProcessMemory(IntPtr MemoryAddress, UInt64 bytesToRead, out Int64 bytesRead, byte[] buffer) { IntPtr ptrBytesRead = new IntPtr(); int rval = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead); if (rval == 1) { bytesRead = ptrBytesRead.ToInt64(); } else { bytesRead = 0; } return(rval); }
public String ReadString(UInt64 iMemoryAddress, uint iTextLength, int iMode = 0) { byte[] bBuffer = new byte[iTextLength]; IntPtr ptrBytesRead; ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, iTextLength, out ptrBytesRead); if (iMode == 0) { return(Encoding.UTF8.GetString(bBuffer)); } else if (iMode == 1) { return(BitConverter.ToString(bBuffer).Replace("-", "")); } else { return(""); } }
private void timer3_Tick(object sender, EventArgs e) { IntPtr bytesRead; byte[] buffer = new byte[8]; //actual aimbot code for horizontal plane ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xMouseAddr, buffer, (uint)buffer.Length, out bytesRead); playerYaw = BitConverter.ToSingle(buffer, 0); directionLabel.Text = playerYaw.ToString(); byte[] binNewYaw = BitConverter.GetBytes(yawAngle - readWriteXMouseDiff); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, writableXMouseAddr, binNewYaw, (uint)binNewYaw.Length, out bytesRead); //aimbot code for vertical plane ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yMouseAddr, buffer, (uint)buffer.Length, out bytesRead); playerPitch = BitConverter.ToSingle(buffer, 0); byte[] binNewPitch = BitConverter.GetBytes(pitchAngle + 2 - readWriteYMouseDiff); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, writableYMouseAddr, binNewPitch, (uint)binNewPitch.Length, out bytesRead); }
/// <summary>This function will read an from memory using the given parameters.</summary> /// <param name="lpBaseAddress">The address you want to read.</param> /// <param name="type">The type of variable you are wanting to read.</param> /// <param name="size">The number of bytes to be read.</param> /// <param name="lpNumberOfBytesRead">The number of bytes actually read.</param> /// <returns>An object with the results of the read.</returns> public static object Read(UIntPtr lpBaseAddress, Type type, uint size, out IntPtr bytesRead) { // The array of bytes for the returned data to be stored in. byte[] buffer = new byte[size]; bytesRead = IntPtr.Zero; // Calls the c api for reading from memory. if (Process.GameRunning && Convert.ToBoolean(ProcessMemoryReaderApi.ReadProcessMemory(Voodoo.Process.Handle, lpBaseAddress, buffer, size, out bytesRead))) { // This handles the different types of variables. switch (Type.GetTypeCode(type)) { // Handles if the memory to be read is an int case TypeCode.Int32: return(System.BitConverter.ToInt32(buffer, 0)); // Handles if the memory to be read is an int16 case TypeCode.Int16: return(System.BitConverter.ToInt16(buffer, 0)); // Handles if the memory to be read is a string case TypeCode.String: return(Encoding.Unicode.GetString(buffer)); // Handles if the memory to be read is a single (float) case TypeCode.Single: return(System.BitConverter.ToSingle(buffer, 0)); case TypeCode.UInt32: return(System.BitConverter.ToUInt32(buffer, 0)); // Handles if the memory to be read is a byte case TypeCode.Byte: return(buffer[0]); // Handles if the memory to be read is a type that isn't supported. default: return(new object()); } } else { // This handles the different types of variables. switch (Type.GetTypeCode(type)) { // Handles if the memory to be read is an int case TypeCode.Int32: return(int.MaxValue); // Handles if the memory to be read is an int16 case TypeCode.Int16: return(Int16.MaxValue); // Handles if the memory to be read is a string case TypeCode.String: return(string.Empty); // Handles if the memory to be read is a single (float) case TypeCode.Single: return(float.MaxValue); case TypeCode.UInt32: return(uint.MaxValue); // Handles if the memory to be read is a byte case TypeCode.Byte: return(byte.MaxValue); // Handles if the memory to be read is a type that isn't supported. default: return(new object()); } } }
private void timer1_Tick(object sender, EventArgs e) { //All of this code is what shows the player's position in the app window. IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id); IntPtr bytesRead = (IntPtr)0; byte[] buffer = new byte[8]; uint size = (uint)buffer.Length; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead); xPosLabel.Text = BitConverter.ToSingle(buffer, 0).ToString(); ProcessMemoryReaderApi.ReadProcessMemory(processHandle, yPosAddr, buffer, (uint)buffer.Length, out bytesRead); yPosLabel.Text = BitConverter.ToSingle(buffer, 0).ToString(); ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead); zPosLabel.Text = BitConverter.ToSingle(buffer, 0).ToString(); ProcessMemoryReaderApi.ReadProcessMemory(processHandle, healthAddr, buffer, (uint)buffer.Length, out bytesRead); healthLabel.Text = "2147483647 / 100"; //starting here is aimbot math ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead); float x1 = BitConverter.ToSingle(buffer, 0); ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, enemyXPosAddr, buffer, (uint)buffer.Length, out bytesRead); float x2 = BitConverter.ToSingle(buffer, 0); ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead); float z1 = BitConverter.ToSingle(buffer, 0); ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, enemyZPosAddr, buffer, (uint)buffer.Length, out bytesRead); float z2 = BitConverter.ToSingle(buffer, 0); slope = ((z2 - z1) / (x2 - x1)); yawAngle = (float)(Math.Atan2((z2 - z1), (x2 - x1)) * (180 / Math.PI)); slopeLabel.Text = slope.ToString(); angleLabel.Text = yawAngle.ToString(); distance = (float)(Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((z2 - z1), 2))); ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yPosAddr, buffer, (uint)buffer.Length, out bytesRead); playerHeight = BitConverter.ToSingle(buffer, 0); ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, enemyYPosAddr, buffer, (uint)buffer.Length, out bytesRead); enemyHeight = BitConverter.ToSingle(buffer, 0); heightDifference = playerHeight - enemyHeight; pitchAngle = (float)((Math.Atan2(heightDifference, distance)) * (180 / Math.PI)); //This code gives the player infinite health byte[] healthValue = BitConverter.GetBytes(2147483647); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, healthAddr, healthValue, 4, out bytesRead); //This code gives the player infinite primary ammo byte[] fourByteBuffer = new byte[4]; ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, primaryAmmoAddrPointer, fourByteBuffer, (uint)fourByteBuffer.Length, out bytesRead); primaryAmmoAddr = (IntPtr)(BitConverter.ToInt32(fourByteBuffer, 0) + 0x44C); byte[] ammoValue = BitConverter.GetBytes(2147483647); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, primaryAmmoAddr, ammoValue, 4, out bytesRead); }
protected override void WndProc(ref Message m) { const int WM_HOTKEY = 0x0312; if (m.Msg == WM_HOTKEY) { if (m.WParam == (IntPtr)1) { IntPtr bytesRead; byte[] bufferX = new byte[8]; byte[] bufferY = new byte[8]; byte[] bufferZ = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xPosAddr, bufferX, (uint)bufferX.Length, out bytesRead); savedXPos1 = bufferX; ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yPosAddr, bufferY, (uint)bufferY.Length, out bytesRead); savedYPos1 = bufferY; ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, zPosAddr, bufferZ, (uint)bufferZ.Length, out bytesRead); savedZPos1 = bufferZ; } else if (m.WParam == (IntPtr)2) { IntPtr store; ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, savedXPos1, 8, out store); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yPosAddr, savedYPos1, 8, out store); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, savedZPos1, 8, out store); } else if (m.WParam == (IntPtr)3) { IntPtr bytesRead; IntPtr store; byte[] buffer = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yPosAddr, buffer, (uint)buffer.Length, out bytesRead); byte[] currentY = buffer; float floatY = BitConverter.ToSingle(currentY, 0); float addedY = floatY + 300; byte[] newY = BitConverter.GetBytes(addedY); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yPosAddr, newY, 8, out store); byte[] accelerationY = { 0x00000000 }; ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yVelocityAddr, accelerationY, 4, out store); } else if (m.WParam == (IntPtr)4) { IntPtr store; byte[] accelerationY = { 0x00 }; ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yVelocityAddr, accelerationY, 4, out store); } else if (m.WParam == (IntPtr)5) { IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id); IntPtr bytesRead = (IntPtr)0; byte[] bufferX = new byte[8]; byte[] bufferY = new byte[8]; byte[] bufferZ = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, bufferX, (uint)bufferX.Length, out bytesRead); savedXPos2 = bufferX; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, yPosAddr, bufferY, (uint)bufferY.Length, out bytesRead); savedYPos2 = bufferY; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, bufferZ, (uint)bufferZ.Length, out bytesRead); savedZPos2 = bufferZ; } else if (m.WParam == (IntPtr)6) { IntPtr store = (IntPtr)0; ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, savedXPos2, 8, out store); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yPosAddr, savedYPos2, 8, out store); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, savedZPos2, 8, out store); } else if (m.WParam == (IntPtr)7) { byte[] buffer = new byte[8]; IntPtr store; ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xMouseAddr, buffer, 8, out store); float direction = BitConverter.ToSingle(buffer, 0); if (direction > -45 && direction < 45) { //xPos will increase IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id); IntPtr bytesRead = (IntPtr)0; buffer = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead); float movement = BitConverter.ToSingle(buffer, 0) + 200; byte[] finalMovement = BitConverter.GetBytes(movement); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead); } else if (direction < -45 && direction > -135) { //zPos will decrease IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id); IntPtr bytesRead = (IntPtr)0; buffer = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead); float movement = BitConverter.ToSingle(buffer, 0) - 200; byte[] finalMovement = BitConverter.GetBytes(movement); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead); } else if ((direction < -135 && direction > -179.99999999) || (direction > 135 && direction < 179.99999999)) { //xPos will decrease IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id); IntPtr bytesRead = (IntPtr)0; buffer = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead); float movement = BitConverter.ToSingle(buffer, 0) - 200; byte[] finalMovement = BitConverter.GetBytes(movement); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead); } else if (direction > 45 && direction < 135) { //zPos will increase IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id); IntPtr bytesRead = (IntPtr)0; buffer = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead); float movement = BitConverter.ToSingle(buffer, 0) + 200; byte[] finalMovement = BitConverter.GetBytes(movement); ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead); } } else if (m.WParam == (IntPtr)8) { if (aimbotIsOn == true) { timer3.Enabled = false; aimbotIsOn = false; } else { timer3.Enabled = true; aimbotIsOn = true; //defining the difference between the readable and writable X address values. IntPtr bytesRead; byte[] buffer = new byte[8]; ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xMouseAddr, buffer, (uint)buffer.Length, out bytesRead); float readXMouseValue = BitConverter.ToSingle(buffer, 0); ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, writableXMouseAddr, buffer, (uint)buffer.Length, out bytesRead); float writeXMouseValue = BitConverter.ToSingle(buffer, 0); readWriteXMouseDiff = readXMouseValue - writeXMouseValue; //defining the difference between the readable and writable Y address value ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yMouseAddr, buffer, (uint)buffer.Length, out bytesRead); float readYMouseValue = BitConverter.ToSingle(buffer, 0); ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, writableYMouseAddr, buffer, (uint)buffer.Length, out bytesRead); float writeYMouseValue = BitConverter.ToSingle(buffer, 0); readWriteYMouseDiff = readYMouseValue - writeYMouseValue; } } else if (m.WParam == (IntPtr)9) { } } base.WndProc(ref m); }