我正在尝试转换一些 C# 代码，以便它可以处理 64 位地址

Question

I've tried replacing

public static extern Int64 ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);
with
public static extern bool ReadProcessMemory(int hProcess, Int64 lpBaseAddress, byte[] lpBuffer, int dwSize, ref int lpNumberOfBytesRead);
and it still doesn't do anything except give me errors. My full code if it matters:

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace Transient.Utilities
{
    /// <summary>
    /// ProcessMemoryReader is a class that enables direct reading a process memory
    /// </summary>
    class ProcessMemoryReaderApi
    {
        // constants information can be found in <winnt.h>
        [Flags]
        public enum ProcessAccessType
        {
            PROCESS_TERMINATE = (0x0001),
            PROCESS_CREATE_THREAD = (0x0002),
            PROCESS_SET_SESSIONID = (0x0004),
            PROCESS_VM_OPERATION = (0x0008),
            PROCESS_VM_READ = (0x0010),
            PROCESS_VM_WRITE = (0x0020),
            PROCESS_DUP_HANDLE = (0x0040),
            PROCESS_CREATE_PROCESS = (0x0080),
            PROCESS_SET_QUOTA = (0x0100),
            PROCESS_SET_INFORMATION = (0x0200),
            PROCESS_QUERY_INFORMATION = (0x0400),
            PROCESS_QUERY_LIMITED_INFORMATION = (0x1000)
        }

        // function declarations are found in the MSDN and in <winbase.h>

        //      HANDLE OpenProcess(
        //          DWORD dwDesiredAccess,  // access flag
        //          BOOL bInheritHandle,    // handle inheritance option
        //          DWORD dwProcessId       // process identifier
        //          );
        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheritHandle, UInt32 dwProcessId);

        //      BOOL CloseHandle(
        //          HANDLE hObject   // handle to object
        //          );
        [DllImport("kernel32.dll")]
        public static extern Int32 CloseHandle(IntPtr hObject);

        //      BOOL ReadProcessMemory(
        //          HANDLE hProcess,              // handle to the process
        //          LPCVOID lpBaseAddress,        // base of memory area
        //          LPVOID lpBuffer,              // data buffer
        //          SIZE_T nSize,                 // number of bytes to read
        //          SIZE_T * lpNumberOfBytesRead  // number of bytes read
        //          );
        [DllImport("kernel32.dll")]
        public static extern Int64 ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);

        //      BOOL WriteProcessMemory(
        //          HANDLE hProcess,                // handle to process
        //          LPVOID lpBaseAddress,           // base of memory area
        //          LPCVOID lpBuffer,               // data buffer
        //          SIZE_T nSize,                   // count of bytes to write
        //          SIZE_T * lpNumberOfBytesWritten // count of bytes written
        //          );
        [DllImport("kernel32.dll")]
        public static extern Int64 WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesWritten);
        class PMR
        {

        }
    }

    public class ProcessMemoryReader
    {
        public Process ReadProcess { get; set; }

        private IntPtr handle;

        public void OpenProcess()
        {
            ProcessMemoryReaderApi.ProcessAccessType access = ProcessMemoryReaderApi.ProcessAccessType.PROCESS_QUERY_INFORMATION |
                ProcessMemoryReaderApi.ProcessAccessType.PROCESS_VM_READ |
                ProcessMemoryReaderApi.ProcessAccessType.PROCESS_VM_WRITE |
                ProcessMemoryReaderApi.ProcessAccessType.PROCESS_VM_OPERATION;
            handle = ProcessMemoryReaderApi.OpenProcess((uint)access, 1, (uint)ReadProcess.Id);
        }

        public void CloseHandle()
        {
            int returnValue = ProcessMemoryReaderApi.CloseHandle(handle);
            if (returnValue != 0)
                throw new Exception("Closing Handle Failure");
        }

        public Byte[] ReadMemory(IntPtr memoryAdress, uint bytesToRead, out int bytesRead)
        {
            byte[] buffer = new byte[bytesToRead];
            IntPtr pBytesRead = IntPtr.Zero;
            ProcessMemoryReaderApi.ReadProcessMemory(handle, memoryAdress, buffer, bytesToRead, out pBytesRead);
            bytesRead = pBytesRead.ToInt32();
            return buffer;
        }

        public void WriteMemory(IntPtr memoryAddress, byte[] buffer, out int bytesWritten)
        {
            IntPtr pBytesWritten = IntPtr.Zero;
            ProcessMemoryReaderApi.WriteProcessMemory(handle, memoryAddress, buffer, (uint)buffer.Length, out pBytesWritten);
            bytesWritten = pBytesWritten.ToInt32();
        }
    }
}

Any help would be great. I used a tutorial for the code, please don't hurt me.

Errors: 1. Argument 5 must be passed with the ref keyword | 2. Argument 2: Cant convert from System.IntPtr to long | 3. Argument 1: Cant convert from System.IntPtr to int. These all take place on line 101, which is
ProcessMemoryReaderApi.ReadProcessMemory(handle, memoryAdress, buffer, bytesToRead, out pBytesRead);

Answer 1

IntPtr can hold 4 bytes pointers when building x86, and 8 byte when building in x64 mode. If you want your code to be universal for x86 and x64, just use IntPtr for all pointer types. You do not need to change them to int64.

The first RPM pinvoke definition uses "out" and your second one uses "ref". You did not update your actual function calls to use ref, causing your compiler errors.

Just use "out" and stick to IntPtr

Change dwSize to be a IntPtr

Then call the function using the correct data types

Compile for x64, and your problem will be solved.

If required you can use IntPtr.toInt64() etc...