Início / coding / Perguntas / 79422381
Accepted
JohnA
Asked: 2025-02-08 07:38:45 +0800 CST

Por que não recebo um pop-up MessageBox ao chamar MessageBoxA

  • 772

Então, estou aprendendo C depois de anos de C# e imaginei que um bom projeto inicial seria algo um pouco mais simples.

Estou tentando invocar uma MessageBox em um aplicativo WPF em branco e parece que tudo funcionaria, mas por algum motivo não estou obtendo uma MessageBox.

Tanto o WpfApp quanto o aplicativo que criei são compilados em versões x64, então não vejo por que haveria problemas de arquitetura.

A saída de depuração também parece boa.

Tentei executar ambos os aplicativos com privilégios de administrador. Tentei invocar em diferentes aplicativos, como o Notepad (versão de 32 e 64 bits), assim como a Calculadora.

Process ID for WpfApp1.exe found: 948
Target process found. PID: 948
Opened handle to process.
Handle to user32.dll loaded successfully.
Address of MessageBoxA: 00007ffc67fc8b70
Allocated memory at remote address: 00000262a8500000
Successfully wrote message to remote memory.
Remote thread created successfully.
Remote thread completed.

Mas acho que há algo errado aqui?

#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <unistd.h>

DWORD GetPID(const char *processName);

int main(void) {
    DWORD processId = GetPID("WpfApp1.exe");

    if (!processId) {
        printf("Process not found\n");
        fflush(stdout);
        return 1;
    }
    printf("Target process found. PID: %lu\n", processId);
    fflush(stdout);

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
    if (!hProcess) {
        printf("Failed to open process. Error code: %lu\n", GetLastError());
        fflush(stdout);
        return 1;
    }
    printf("Opened handle to process.\n");
    fflush(stdout);

    // Explicitly load user32.dll
    HMODULE hUser32 = LoadLibrary("user32.dll");
    if (!hUser32) {
        printf("Failed to load user32.dll. Error code: %lu\n", GetLastError());
        fflush(stdout);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Handle to user32.dll loaded successfully.\n");
    fflush(stdout);

    LPVOID msgBoxAddress = (LPVOID)GetProcAddress(hUser32, "MessageBoxA");
    if (!msgBoxAddress) {
        printf("Failed to find address of MessageBoxA. Error code: %lu\n", GetLastError());
        fflush(stdout);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Address of MessageBoxA: %p\n", msgBoxAddress);
    fflush(stdout);

    LPVOID remoteString = VirtualAllocEx(hProcess, NULL, 256, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (!remoteString) {
        printf("Failed to allocate memory in target process. Error code: %lu\n", GetLastError());
        fflush(stdout);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Allocated memory at remote address: %p\n", remoteString);
    fflush(stdout);

    if (!WriteProcessMemory(hProcess, remoteString, "Hello World!", 13, NULL)) {
        printf("Failed to write to remote memory. Error code: %lu\n", GetLastError());
        fflush(stdout);
        VirtualFreeEx(hProcess, remoteString, 0, MEM_RELEASE);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Successfully wrote message to remote memory.\n");
    fflush(stdout);

    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)msgBoxAddress, remoteString, 0, NULL);
    if (!hThread) {
        printf("Failed to create remote thread. Error code: %lu\n", GetLastError());
        fflush(stdout);
        VirtualFreeEx(hProcess, remoteString, 0, MEM_RELEASE);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Remote thread created successfully.\n");
    fflush(stdout);

    WaitForSingleObject(hThread, INFINITE);
    printf("Remote thread completed.\n");
    fflush(stdout);

    VirtualFreeEx(hProcess, remoteString, 0, MEM_RELEASE);
    FreeLibrary(hUser32);
    CloseHandle(hThread);
    CloseHandle(hProcess);
    return 0;
}

DWORD GetPID(const char *processName) {
    PROCESSENTRY32 processEntry;
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapshot == INVALID_HANDLE_VALUE) {
        printf("Failed to create snapshot. Error code: %lu\n", GetLastError());
        fflush(stdout);
        return 0;
    }

    processEntry.dwSize = sizeof(processEntry);
    if (Process32First(hSnapshot, &processEntry)) {
        do {
            if (strcmp(processEntry.szExeFile, processName) == 0) {
                DWORD pid = processEntry.th32ProcessID;
                CloseHandle(hSnapshot);
                printf("Process ID for %s found: %lu\n", processName, pid);
                fflush(stdout);
                return pid;
            }
        } while (Process32Next(hSnapshot, &processEntry));
    }

    printf("Failed to find process: %s\n", processName);
    fflush(stdout);
    CloseHandle(hSnapshot);
    return 0;
}

Isso também parece bastante código comparado a vários artigos que li online.

c

2 respostas

  1. Best Answer

    CreateRemoteThread()simplesmente não pode chamar MessagBoxA() diretamente , pois MessageBoxA()não tem a assinatura de função correta que CreateRemoteThread()está esperando:

    int WINAPI MessageBoxA(
  [in, optional] HWND   hWnd,
  [in, optional] LPCSTR lpText,
  [in, optional] LPCSTR lpCaption,
  [in]           UINT   uType
);

    DWORD WINAPI ThreadProc(
  _In_ LPVOID lpParameter
);

    CreateRemoteThread()pode passar apenas 1 parâmetro para a função de destino, mas MessageBoxA()aceita 4 parâmetros.

    Então, nessa situação, você terá que mudar sua abordagem. Você pode:

    • crie uma DLL que DllMaincrie um thread local, e então você pode fazer com que esse thread faça o que você quiser. Então faça com que seu aplicativo aloque remoteStringpara manter o caminho para essa DLL, e use CreateRemoteThread()para invocar LoadLibrary()com remoteStringcomo seu parâmetro de entrada.

      Esta é a maneira mais fácil e comum de injetar código remoto usando CreateRemoteThread(), pois LoadLibrary()é compatível com CreateRemoteThread().

    • crie uma DLL que implemente um SetWindowsHookEx()retorno de chamada, como WH_CALLWNDPROCou WH_GETMESSAGE, e então você pode fazer o que quiser dentro desse retorno de chamada. Então faça seu aplicativo usar SetWindowsHookEx()para instalar a DLL como o tipo de hook relevante no processo de destino, e então use SendMessage()ou Post[Thread]Message()para o processo de destino para disparar o retorno de chamada.

    • Faça com que seu aplicativo aloque um bloco de memória remoto que contenha instruções da CPU que chamam MessageBoxA()diretamente. Dê PAGE_EXECUTEdireitos a esse bloco de memória com VirtualProtectEx(). Então use CreateRemoteThread()para invocar esse bloco de código como se fosse uma função normal.

      Esta é uma técnica difícil se você não estiver familiarizado com o funcionamento das instruções da CPU na memória.

    • 5

  2. Após uma rápida pesquisa na documentação da API do Win32, parece que você está usando CreateRemoteThreaderrado.

    Conforme definido na seção parameters , lpStartAddressdeve existir no processo remoto e lpParameteré o parâmetro passado para a função encadeada:

    [in] lpStartAddress

    Um ponteiro para a função definida pelo aplicativo do tipo LPTHREAD_START_ROUTINE a ser executada pelo thread e representa o endereço inicial do thread no processo remoto. A função deve existir no processo remoto. Para obter mais informações, consulte ThreadProc.

    [in] lpParameter

    Um ponteiro para uma variável a ser passada para a função thread.

    A ThreadProcdocumentação é uma boa ilustração:

    Uma função definida pelo aplicativo que serve como endereço inicial para um thread. Especifique esse endereço ao chamar a função CreateThread, CreateRemoteThread ou CreateRemoteThreadEx.

    O tipo LPTHREAD_START_ROUTINE define um ponteiro para esta função de retorno de chamada. ThreadProc é um placeholder para o nome da função definida pelo aplicativo.

    Este é o tipo de função para a qual você pode apontar com CreateRemoteThread. Desta forma, CreateRemoteThreade sua função personalizada concordam com um protótipo de função para que este mecanismo funcione.

    Outra dica de mau uso do mecanismo seria o protótipo dele MessageBoxAmesmo. Esta função parece ter apenas um parâmetro não opcional, que é um inteiro sem sinal ( [in] UINT uType) :

    int MessageBoxA(
  [in, optional] HWND   hWnd,
  [in, optional] LPCSTR lpText,
  [in, optional] LPCSTR lpCaption,
  [in]           UINT   uType
);

    Por outro lado, CreateRemoteThreaddefine lpParametercomo um ponteiro para qualquer tipo ( [in] LPVOID lpParameter):

    HANDLE CreateRemoteThread(
  [in]  HANDLE                 hProcess,
  [in]  LPSECURITY_ATTRIBUTES  lpThreadAttributes,
  [in]  SIZE_T                 dwStackSize,
  [in]  LPTHREAD_START_ROUTINE lpStartAddress,
  [in]  LPVOID                 lpParameter,
  [in]  DWORD                  dwCreationFlags,
  [out] LPDWORD                lpThreadId
);

    A última indicação nessa direção é a seguinte parte da CreateRemoteThreaddocumentação ( valores de retorno ):

    Observe que CreateRemoteThreadpode ser bem-sucedido mesmo que lpStartAddressaponte para dados, código ou não esteja acessível.

    Meu entendimento é que o thread é criado mesmo se lpStartAddressfor inválido, e então, quando o thread é executado, ele lança uma exceção. A criação é bem-sucedida, mas nada acontece como resultado da exceção. Conforme sugerido na seção sobre o valor de retorno, uma chamada para GetLastErrorseria uma boa ideia para obter mais detalhes sobre o que está acontecendo e obter informações de erro estendidas.

    Minha sugestão seria primeiro verificar o erro com uma chamada para GetLastErrore então tentar definir uma função no ThreadProcformato que interpretaria o parâmetro void* como LPCSTR e essa função chamaria MessageBoxAcom todos os parâmetros codificados, exceto a sequência de caracteres (title -> lpCaptionou contents of the message box -> lpText) que seria o LPCSTR recém-convertido. Se você quiser dar mais parâmetros à sua função personalizada, sugiro que use o mesmo método sugerido com o LPCSTR, mas dessa vez com um objeto personalizado.

    Espero que isso ajude

    • 0

relate perguntas