ReadProcessMemory: Почему я не вижу содержимого notepad.exe?

Это должно приблизить вас на шаг к тому, чего вы пытаетесь достичь. Как упоминалось в комментариях, текстовые буферы, используемые Nodepad.exe, не будут находиться по базовому адресу загрузки модуля. Вместо этого весьма вероятно, что эти буферы расположены либо в стеке, либо в куче процесса. Вот модифицированная версия вашего кода, которая пытается определить расположение стека и кучи с помощью Windows API VirtualQueryEx.

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;

namespace MemoryAccessor
{
    public partial class MemoryRead
    {
        const int PROCESS_QUERY_INFORMATION = 0x0400;
        const int PROCESS_VM_READ = 0x0010;

        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool VirtualQueryEx(IntPtr hProcess, IntPtr lpAddress, out MEMORY_BASIC_INFORMATION lpBuffer, uint dwLength);

        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer, int dwSize, out IntPtr lpNumberOfBytesRead);

        [DllImport("kernel32.dll")]
        public static extern bool CloseHandle(IntPtr hObject);

        [StructLayout(LayoutKind.Sequential)]
        public struct MEMORY_BASIC_INFORMATION
        {
            public IntPtr BaseAddress;
            public IntPtr AllocationBase;
            public uint AllocationProtect;
            public IntPtr RegionSize;
            public uint State;
            public uint Protect;
            public uint Type;
        }

        public static void Main()
        {
            Process[] processes = Process.GetProcessesByName("Notepad");
            if (processes.Length > 0)
            {
                Process process = processes[0];
                IntPtr processHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, process.Id);

                if (processHandle != IntPtr.Zero)
                {
                    IntPtr lpAddress = IntPtr.Zero;
                    MEMORY_BASIC_INFORMATION mbi;

                    while (VirtualQueryEx(processHandle, lpAddress, out mbi, (uint)Marshal.SizeOf(typeof(MEMORY_BASIC_INFORMATION))) != false)
                    {
                        // Check if the region is part of the stack or heap
                        if (mbi.Protect == 0x04 && mbi.Type == 0x10000) // PAGE_READWRITE and MEM_COMMIT
                        {
                            Console.WriteLine($"Base Address: {mbi.BaseAddress}, Region Size: {mbi.RegionSize}");
                            Console.WriteLine("Placeholder: Read from stack here");

                            // Here you can read from the stack by using ReadProcessMemory
                            // For example:
                            // byte[] buffer = new byte[1024];
                            // IntPtr bytesRead;
                            // ReadProcessMemory(processHandle, mbi.BaseAddress, buffer, buffer.Length, out bytesRead);
                        }
                        else if (mbi.Protect == 0x04 && mbi.Type == 0x20000) // PAGE_READWRITE and MEM_PRIVATE
                        {
                            Console.WriteLine($"Base Address: {mbi.BaseAddress}, Region Size: {mbi.RegionSize}");
                            Console.WriteLine("Placeholder: Read from heap here");

                            // Here you can read from the heap by using ReadProcessMemory
                            // For example:
                            // byte[] buffer = new byte[1024];
                            // IntPtr bytesRead;
                            // ReadProcessMemory(processHandle, mbi.BaseAddress, buffer, buffer.Length, out bytesRead);
                        }

                        lpAddress = IntPtr.Add(mbi.BaseAddress, mbi.RegionSize.ToInt32());
                    }

                    CloseHandle(processHandle);
                }
                else
                {
                    Console.WriteLine("Failed to open process.");
                }
            }
            else
            {
                Console.WriteLine("Process not found.");
            }

            Console.ReadLine();
        }
    }
}

Я оставил код-заполнитель для места, где вы хотите попробовать прочитать из стека и кучи.

Альтернативно вы можете попробовать такую ​​программу, как «Cheat Engine», которая отслеживает адресное пространство программы. Это поможет вам быстро найти текст, введенный в Блокнот, и определить, где в памяти находятся эти данные. Вам все равно придется выполнить некоторые расчеты, чтобы определить, как можно надежно сделать то же самое программно.

Примечание. Я знаю, что вы сказали, что делаете это в Windows 11, и я сделал это в Windows 10, но вы должны быть в состоянии выполнить шаги, чтобы заставить это работать в Windows 11, просто это может быть немного сложнее, поскольку блокнот может иметь несколько вкладок в Windows 11

Вы можете прочитать текст в блокноте, найдя смещение памяти, в котором блокнот хранит текст (все равно будет работать после перезапуска приложения). Я сделал это с помощью Cheat Engine, вот мои шаги:

1. Начните с поиска типа строкового значения и значения, которое вы ввели в блокнот с помощью Cheat Engine. Здесь вы можете видеть, что я получил один результат, который показывает адрес, где в данный момент хранится текст. Дважды щелкните этот результат, чтобы добавить его в список внизу чит-движка.

2. Дважды щелкните адрес и скопируйте его.

3. Измените тип значения на 8 байт (для процессов x64), установите флажок Hex и вставьте скопированный адрес в поле адреса, затем отсканируйте и добавьте результат в список внизу, дважды щелкнув его.

4. Повторяйте шаги 2 и 3, пока один из адресов в результатах не станет зеленым, что означает, что вы нашли смещение, указывающее на текст. Затем вы можете использовать это смещение для чтения текста из памяти даже после перезапуска программы.

Как показано на снимке экрана, адрес, по которому находится указатель, который использует блокнот в Windows 10, — это notepad.exe+31680, что можно представить на C# следующим образом:

Process process = Process.GetProcessesByName("notepad")[0];
IntPtr.Add(process.MainModule!.BaseAddress, 0x31680); // notepad.exe+31680

Иногда вам может потребоваться использовать приведенный ниже код, если смещение не из основного модуля:

static IntPtr GetModuleBaseAddress(Process process, string moduleName)
{
    ProcessModuleCollection modules = process.Modules;
    foreach (ProcessModule module in modules)
    {
        if (module.ModuleName == moduleName)
        {
            return module.BaseAddress;
        }
    }
    throw new Exception($"Module {moduleName} not found in process {process.ProcessName}");
}

Process process = Process.GetProcessesByName("notepad")[0];
// You can see all modules by looping through `process.Modules`
// Replace notepad.exe with the name of the module. Might be called something like `textinputframework.dll`
IntPtr addressOfTextPointer1 = IntPtr.Add(GetModuleBaseAddress(process, "notepad.exe"), 0x31680);

Проблема в том, что если вы прочитаете то, что находится по адресу, вы получите указатель на другой адрес вместо текста, поэтому вам нужно прочитать указатель, а затем указатель из этого указателя и т. д., пока вы не получите текст.

Вы можете видеть, что notepad.exe+31680 (7FF78F051680) указывает на 1E5CC990008, который указывает на 1E5C79E6880, который указывает на строку Unicode UTF-16 hello world.

Вот мой полный код, который я использовал для отслеживания указателей и получения текста, который все равно будет работать после перезапуска программы, поскольку исходный указатель всегда будет иметь одно и то же смещение от базового адреса модуля/процесса:

using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;

public partial class Program
{
    // Number of characters to read from the target process
    static int charactersToRead = 11;

    [LibraryImport("kernel32.dll")]
    public static partial IntPtr OpenProcess(uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwProcessId);

    [LibraryImport("kernel32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static partial bool ReadProcessMemory(IntPtr hProcess, long lpBaseAddress, [Out] byte[] lpBuffer, int dwSize, out IntPtr lpNumberOfBytesRead);

    public static void Main()
    {
        try
        {
            Process process = Process.GetProcessesByName("notepad")[0];
            IntPtr processHandle = OpenProcess(0x0010, false, (uint)process.Id);
            IntPtr addressOfTextPointer1 = IntPtr.Add(process.MainModule!.BaseAddress, 0x31680);
            //IntPtr addressOfTextPointer1 = IntPtr.Add(GetModuleBaseAddress(process, "notepad.exe"), 0x31680);
            Console.WriteLine("Pointer 1: " + addressOfTextPointer1.ToString("X"));
            long addressOfTextPointer2 = BitConverter.ToInt64(ReadMem(processHandle, addressOfTextPointer1, 8));
            Console.WriteLine("Pointer 2: " + addressOfTextPointer2.ToString("X"));
            long addressOfText = BitConverter.ToInt64(ReadMem(processHandle, addressOfTextPointer2, 8));
            Console.WriteLine("Address of string: " + addressOfText.ToString("X"));
            Console.WriteLine("String: " + Encoding.Unicode.GetString(ReadMem(processHandle, addressOfText, charactersToRead * 2)));
            Console.ReadLine();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
            Console.WriteLine(e.StackTrace);
            Console.ReadLine();
        }
    }

    static byte[] ReadMem(nint processHandle, long address, int bufferLength)
    {
        byte[] buffer = new byte[bufferLength];
        ReadProcessMemory(processHandle, address, buffer, buffer.Length, out var bytesRead);
        return buffer;
    }

    // Helper function to get the base address of a module in the target process
    static IntPtr GetModuleBaseAddress(Process process, string moduleName)
    {
        ProcessModuleCollection modules = process.Modules;
        foreach (ProcessModule module in modules)
        {
            if (module.ModuleName == moduleName)
            {
                return module.BaseAddress;
            }
        }
        throw new Exception($"Module {moduleName} not found in process {process.ProcessName}");
    }
}

Выход:

Pointer 1: 7FF78F051680
Pointer 2: 1E5CC990008
Address of string: 1E5C79E6880
String: hello world

Полезные исследования/источники/инструменты, которые я использовал, чтобы во всем этом разобраться. Это может помочь, если вышеуказанные шаги по какой-либо причине не работают:

• Сайт Cheat Engine
• Учебное пособие по Cheat Engine: многоуровневые указатели
• Функция чтения строки из памяти (GitHub)
• Как найти смещения, адреса объектов и указатели
• Использование базовых указателей со смещением для чтения памяти процесса