11 respuestas en este tema

[escafandra]

A la vista de una pregunta en nuestro foro hermano, me pareció interesante responder y elaboré un código capaz de barrer la memoria de un proceso en ejecución para buscar y cambiar determinada cadena. El asunto no tiene mucha más utilidad que el hacking de procesos y gastar una broma y queda resultón.
 
Es interesante recalcar que un proceso compilado para 32bits no puede leer ni escribir en la memoria de otro de 64 bits, pero el camino contrario si es correcto. Esto se debe a incompatibilidad del tamaño de los punteros.
 
Por motivo de dotar de más velocidad al código, he implementado una función que compara cadenas más rápido que su equivalente API, porque no hace verificaciones. Con esa función se gana un segundo sobre su equivalente API, aunque esto depende del S.O. y procesador.
 
Este es el código:

delphi

function _StrCmpNIW(Str1, Str2: PWCHAR; N: integer): DWORD;
var
  T: integer;
begin
  T:= 0;
  // Pasando a minusculas y comparando caracteres
  while ((Ord(Str1^) or 32) = (Ord(Str2^) or 32)) and (Str1^ <> #0) and (Str2^ <> #0) and (T<N) do
  begin
    inc(Str1);
    inc(Str2);
    inc(T);
  end;
  Result:= N-T;
end;
 
function EnablePrivilege(name: String; Enable: boolean = true): boolean;
var
  hToken: THANDLE;
  priv: TOKEN_PRIVILEGES;
begin
  priv.PrivilegeCount:= 1;
  priv.Privileges[0].Attributes:= 0;
  if Enable then priv.Privileges[0].Attributes:= SE_PRIVILEGE_ENABLED;
  LookupPrivilegeValue(nil, PCHAR(name), priv.Privileges[0].Luid);
  OpenProcessToken(GetCurrentProcess, TOKEN_ADJUST_PRIVILEGES, hToken);
  AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), nil, PDWORD(nil)^);
  Result:= (GetLastError = ERROR_SUCCESS);
  CloseHandle (hToken);
end;
 
//---------------------------------------------------------------------------
function RemoteReplaceString(PID: DWORD; Str, NewStr: PWCHAR): BOOL;
var
  hProc: THANDLE;
  i, T, Size, Len, nBytesRead: DWORD;
  Buffer: PCHAR;
  mbi: MEMORY_BASIC_INFORMATION;
  Start: PCHAR;
begin
  Result:= false;
  hProc:= OpenProcess(PROCESS_ALL_ACCESS, false, PID);
  Len:= lstrlenW(Str);
  Size:= Len * sizeof(WCHAR);
  EnablePrivilege('SeDebugPrivilege');
  Start:= nil;
 
  // Escaneamos la memoria del proceso en busca de la cadena
  while VirtualQueryEx(hProc, Start, mbi, sizeof(mbi))<>0 do
  begin
    if mbi.Protect <> 0 and not(mbi.Protect and (PAGE_NOACCESS or PAGE_GUARD)) then
    begin
      Buffer:= VirtualAlloc(nil, mbi.RegionSize, MEM_COMMIT or MEM_RESERVE, PAGE_READWRITE);
      if Buffer <> nil then
      begin
        if ReadProcessMemory(hProc, mbi.BaseAddress, Buffer, mbi.RegionSize, nBytesRead) and (nBytesRead = mbi.RegionSize) then 
        begin
          //Le resto el modulo de la división para no perderme cadenas partidas
          T:= nBytesRead - Size - nBytesRead mod Size;
          i:= 0;
          while i <= T do
          begin
            // Busco la cadena en el buffer "no case sensitive"
            if _StrCmpNIW(PWCHAR(Buffer+i), Str, Len) = 0 then
            begin
              // Si la encuentro la escribo en el proceso remoto
              if WriteProcessMemory(hProc, pointer(int64(mbi.BaseAddress) + i), NewStr, Size, PDWORD(0)^) then
              begin
                // Incremento el índice para seguir buscando
                i:= i + Size - 1;
                Result:= Result or true;
              end;
            end;
            inc(i);
          end;
        end;
        VirtualFree(Buffer, 0, MEM_RELEASE);
      end;
    end;
    inc(Start, mbi.RegionSize);
  end;
  CloseHandle(hProc);
end;
 
procedure TForm1.Button1Click(Sender: TObject);
var
  proc: TProcessEntry32;
  hSysSnapshot: THandle;
begin
  proc.dwSize := SizeOf(TProcessEntry32);
  hSysSnapshot:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if (hSysSnapshot <> INVALID_HANDLE_VALUE) and Process32First(hSysSnapshot, proc) then
  begin
    repeat
      if SameText(String(proc.szExeFile), Edit1.Text) then
        RemoteReplaceString(proc.th32ProcessID, PWCHAR(WideString(Edit2.Text)), PWCHAR(WideString(Edit3.Text)));
    until not (Process32Next(hSysSnapshot, proc));
  end;
  CloseHandle(hSysSnapshot);
end;

Aclaraciones:
1.- Las cadenas de un proceso en memoria deben tratarse como UNICODE.
2.- Un código para 32bits no puede leer la memoria de un proceso 64 bits sin más, se precisa un driver o trucos especiales, esto es debido a la incompatibilidad de los punteros que definen el rango de direcciones que son capaces de direccionar.
3.- No se puede sustituir una cadena por otra de mayor longitud, el código evita esto para impedir la corrupción del proceso.
4.- El código es funcional en delphi 7 y Lazarus, en este último y compilado para 64 bits, produce un ejecutable capaz de modificar un proceso de 32 ó 64bits.
5.- Para los que quieran "cacharear", decir que al escribir código a bajo nivel para 64bits hay que tener mucho cuidado con la aritmética de punteros y conversiones, ya que su tamaño es de 64bits y no de 32, como estamos acostumbrados. En este caso el mismo código es funcional para generar un ejecutable de 32 ó 64 bits
6.- Está probado en WinXP y Win10.
 
Subo el proyecto, espero que sea de utilidad, o al menos una curiosidad para realizar alguna "broma" y nunca para "cosas malvadas".
 
 
 
Saludos.

Archivos adjuntos

•  Cambiar cadenas Lazarus.rar   125,4KB   11 descargas
•  Cambiar cadenas.rar   162,16KB   14 descargas

[azdin]

Sigo teniendo problemas en 64 Bits... Pero en 32 Bits si me va ya lo probé.
En 64 Bits no lo pude probar ni compilar porque no otorgaste el .exe y cuando abro el proyecto aparece este error.

[escafandra]

Bienvenido azdin.
Ya veo, debes instalar el pluging para compilar en 64 bits sobre Lazarus32.
 
 
Saludos.

[escafandra]

Para completar este ejercicio, dije que no se puede leer la memoria de un proceso de 64bits desde otro de 32, salvo trucos... os presento un truco que encontré navegando por la web y que es sumamente interesante. Se trata de una librería dll que aporta una serie de funciones capaces de ejecutar código de 64 bits desde 32, se trata de wow64ext.dll. Para este caso sólo nos interesa ejecutar en modo 64bits las APIs VirtualQueryEx, ReadProcessMemory y ReadProcessMemory.
 

delphi

function VirtualQueryEx64(hProcess: THANDLE; lpAddress: DWORD64; var mbi: MEMORY_BASIC_INFORMATION64; dwLength: DWORD): DWORD; cdecl; external 'wow64ext.dll'
function ReadProcessMemory64(hProcess: THANDLE; lpBaseAddress: DWORD64; lpBuffer: Pointer; nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; cdecl; external 'wow64ext.dll';
function WriteProcessMemory64(hProcess: THANDLE; lpBaseAddress: DWORD64; lpBuffer: Pointer; nSize: DWORD; var lpNumberOfBytesWritten: DWORD): BOOL; cdecl; external 'wow64ext.dll';

Con esas funciones en la mano, el mismo código descrito más arriba con pequeños cambios, es capaz de, compilado para 32bits, leer y escribir en el proceso atacado de 64bits, pero no en el de 32. La solución es usar dos funciones, una para cada sistema y reconocer cuando se debe usar cada una, para ello usaremos IsWow64Process, que nos dice si un proceso se ejecuta en modo WOW64, es decir, un proceso de 32bits ejecutándose en una plataforma de 64.
 
Esta función se encarga de ello:
 

delphi

function IsWow64(PID: DWORD): BOOL;
  type TISWOW64PROCESS = function(hProc: THANDLE; var bIsWow64: BOOL): BOOL; stdcall;
var
  _IsWow64Process: TISWOW64PROCESS;
  hProc: THANDLE;
begin
  Result:= false;
  _IsWow64Process:= GetProcAddress(GetModuleHandle('Kernel32.dll'), 'IsWow64Process');
  if @_IsWow64Process <> nil then
  begin;
    hProc:= OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    _IsWow64Process(hProc, Result);
    CloseHandle(hProc);
  end;
end;

 
Y el código para cambiar cadenas queda como sigue:

delphi

//---------------------------------------------------------------------------
function ALIGNUP(addr: Pointer; alignment: int64): pointer;
begin
  Result:= Pointer((int64(addr) + alignment - 1) and -alignment);
end;
 
//---------------------------------------------------------------------------
function RemoteReplaceString64(PID: DWORD; Str, NewStr: PWCHAR): BOOL;
var
  hProc: THANDLE;
  i, T, Size, Len, nBytesRead: DWORD;
  Buffer: PCHAR;
  mbi: MEMORY_BASIC_INFORMATION64;
  Start: DWORD64;
begin
  Result:= false;
  if(Str^ = #0) or (NewStr^ = #0) then exit;
 
  // Alineamos el valor en la pila a 8 o 16
  mbi:= PMEMORY_BASIC_INFORMATION64(ALIGNUP(@mbi, 8))^;
 
  hProc:= OpenProcess(PROCESS_ALL_ACCESS, false, PID);
  Len:= lstrlenW(Str);
  Size:= Len * sizeof(WCHAR);
  EnablePrivilege('SeDebugPrivilege');
  Start:= 0;
 
  // Escaneamos la memoria del proceso en busca de la cadena
  while VirtualQueryEx64(hProc, Start, mbi, sizeof(MEMORY_BASIC_INFORMATION64))<>0 do
  begin
    if mbi.Protect <> 0 and not(mbi.Protect and (PAGE_NOACCESS or PAGE_GUARD)) then
    begin
      Buffer:= VirtualAlloc(nil, mbi.RegionSize, MEM_COMMIT or MEM_RESERVE, PAGE_READWRITE);
      if Buffer <> nil then
      begin
        if ReadProcessMemory64(hProc, mbi.BaseAddress, Buffer, mbi.RegionSize, nBytesRead) and (nBytesRead = mbi.RegionSize) then
        begin
          //Le resto el modulo de la división para no perderme cadenas partidas
          T:= nBytesRead - Size - nBytesRead mod Size;
          i:= 0;
          while i <= T do
          begin
            // Busco la cadena en el buffer "no case sensitive"
            if _StrCmpNIW(PWCHAR(Buffer+i), Str, Len) = 0 then
            begin
              // Si la encuentro la escribo en el proceso remoto
              if WriteProcessMemory64(hProc, mbi.BaseAddress + i, NewStr, Size, PDWORD(0)^) then
              begin
                // Incremento el índice para seguir buscando
                i:= i + Size - 1;
                Result:= Result or true;
              end;
            end;
            inc(i);
          end;
        end;
        VirtualFree(Buffer, 0, MEM_RELEASE);
      end;
    end;
    inc(Start, mbi.RegionSize);
  end;
  CloseHandle(hProc);
end;

 

Un ejemplo atacando iexplore.exe
 

 

Y este otro es un ataque al flamante y nuevo Edge

 
Subo un proyecto para delphi7 que funciona en win10 para procesos de 32 y 64bits. En una plataforma de 32bits, como es lógico, funcionará para procesos Win32.
 

Saludos.

Archivos adjuntos

•  delphi 64To32.rar   181,06KB   25 descargas

[escafandra]

He actualizado la versión 64To32 para evitar posibles errores que puedan producirse por falta de alineación a 8 ó 16 en la pila de la variable tipo  MEMORY_BASIC_INFORMATION64. Dicha estructura (record) debe estar obligatoriamente alineada en memoria a 8 o a 16 para que la fusión entre el código32 y 64 se produzca sin problemas, tanto si se declara en la pila como en un puntero. Para ello he escrito la función general siguiente:

delphi

function ALIGNUP(addr: Pointer; alignment: int64): pointer;
begin
  Result:= Pointer((int64(addr) + alignment - 1) and -alignment);
end;

Que asegura la alineación al valor dado, También añadí 16 bytes a la estructura para asegurar espacio suficiente en la pila.

 

Tanto el código expuesto en el anterior mensaje, como el código subido, están ya actualizados.

 

 

Saludos.

[azdin]

Funciona bien pero ojala se pudiera también hacer ejemplos con Strings no UNICODE

[escafandra]

Funciona bien pero ojala se pudiera también hacer ejemplos con Strings no UNICODE

Se puede buscar y reemplazar cualquier cosa, pero si buscas cadenas en un proceso en ejecución, siempre están en Unicode, por lo que no tiene sentido buscar otra cosa.

 

Saludos.

[azdin]

Pero si siempre están en UNICODE, ¿Por qué resaltas eso?

Y si esto lo pasamos a una Dll para así tal vez lograr un mayor acceso.
Para no tener que hacer necesario obtener el el Handle de una ventana y el PID

Por otro lado he visto que también trabajas en C++ y la verdad si el codigo lo puedes traducir a C++ te agradecería de mas ya que seria ideal para mi, es el lenguaje que mas entiendo.

Si puedes ayudarme te lo agradezco mucho. Gracias que tengas un buen día.

[escafandra]

Pero si siempre están en UNICODE, ¿Por qué resaltas eso?

Para que no quede ninguna duda de que las cadenas de texto del programa están en UNICODE. Sólo las que incluye el compilador no lo son, por ejemplo las APIs importadas en la IAT del PE del ejecutable son cadenas ASCIIZ, pero considero que no es lo que buscas.
 

Por otro lado he visto que también trabajas en C++ y la verdad si el codigo lo puedes traducir a C++ te agradecería de mas ya que seria ideal para mi, es el lenguaje que mas entiendo.

Si puedes ayudarme te lo agradezco mucho. Gracias que tengas un buen día.

.

cpp

#include <windows.h>
 
#define ALIGNUP(addr, alignment) (((addr) + (alignment) - 1) - ((size_t)(addr) + (alignment) - 1) % (alignment))
#define ALIGNUP_(cast, addr, align) (*(cast*)(((__int64)(addr) + (align) - 1) & (__int64)(- (align) )))
 
typedef struct DECLSPEC_ALIGN(16) _MEMORY_BASIC_INFORMATION64 {
    ULONGLONG BaseAddress;
    ULONGLONG AllocationBase;
    DWORD     AllocationProtect;
    DWORD     __alignment1;
    ULONGLONG RegionSize;
    DWORD     State;
    DWORD     Protect;
    DWORD     Type;
    DWORD     __alignment2;
} MEMORY_BASIC_INFORMATION64, *PMEMORY_BASIC_INFORMATION64;
 
extern "C"
{
  DWORD64 X64Call(DWORD64 func, int argC, ...);
  DWORD64 GetModuleHandle64(wchar_t* lpModuleName);
  DWORD64 GetProcAddress64(DWORD64 hModule, char* funcName);
  SIZE_T VirtualQueryEx64(HANDLE hProcess, DWORD64 lpAddress, MEMORY_BASIC_INFORMATION64* lpBuffer, SIZE_T dwLength);
  DWORD64 VirtualAllocEx64(HANDLE hProcess, DWORD64 lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
  BOOL VirtualFreeEx64(HANDLE hProcess, DWORD64 lpAddress, SIZE_T dwSize, DWORD dwFreeType);
  BOOL VirtualProtectEx64(HANDLE hProcess, DWORD64 lpAddress, SIZE_T dwSize, DWORD flNewProtect, DWORD* lpflOldProtect);
  BOOL ReadProcessMemory64(HANDLE hProcess, DWORD64 lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T *lpNumberOfBytesRead);
  BOOL WriteProcessMemory64(HANDLE hProcess, DWORD64 lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T *lpNumberOfBytesWritten);
  //BOOL GetThreadContext64(HANDLE hThread, _CONTEXT64* lpContext);
  //BOOL SetThreadContext64(HANDLE hThread, _CONTEXT64* lpContext);
  VOID SetLastErrorFromX64Call(DWORD64 status);
}

.

cpp

int _StrCmpNIW(PWCHAR Str1, PWCHAR Str2, int N)
{
  int T = 0;
  // Pasando a minusculas y comparando caracteres
  while((*Str1 | 32) == (*Str2 | 32) && *Str1 && *Str2 && T < N){
    Str1++;
    Str2++;
    T++;
  }
  return N-T;
}
 
int StrCmpNW(PWCHAR Str1, PWCHAR Str2, int N)
{
  int T = 0;
  // Comparando caracteres
  while((*Str1) == (*Str2) && *Str1 && *Str2 && T < N){
    Str1++;
    Str2++;
    T++;
  }
  return N-T;
}
 
int __StrCmpNIW(PWCHAR Str1, PWCHAR Str2, int N, BOOL Case)
{
  if(Case)
    return StrCmpNW(Str1, Str2, N);
  return _StrCmpNIW(Str1, Str2, N);
}
 
DWORD RemoteReplaceString64(DWORD PID, PWCHAR Str, PWCHAR NewStr, BOOL Case = true)
{
  if(!*Str || !*NewStr) return false;
 
  DWORD Result = 0;
  char mbi64_buf[sizeof(MEMORY_BASIC_INFORMATION64) + 16];
  MEMORY_BASIC_INFORMATION64 &mbi64 = *(MEMORY_BASIC_INFORMATION64*)ALIGNUP(mbi64_buf, 16);
//  MEMORY_BASIC_INFORMATION64 &mbi = ALIGNUP_(MEMORY_BASIC_INFORMATION64, mbi64_buf, 16);
  DWORD64 Start = 0;
  PBYTE   Buffer;
  SIZE_T  nBytesRead;
  DWORD OldProtect;
 
  DWORD Len  = lstrlenW(Str);
  DWORD Size = Len * sizeof(WCHAR);
 
  EnablePrivilege("SeDebugPrivilege", true);
  ImpersonateToLoginUser();
  HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
 
  VirtualQueryEx64(hProc, Start, &mbi64, sizeof(mbi64));
 
  while(VirtualQueryEx64(hProc, Start, &mbi64, sizeof(mbi64))){
    if(mbi64.Protect && !(mbi64.Protect & (PAGE_NOACCESS | PAGE_GUARD))){
      //Result += ReplaceString64(hProc, mbi64, Str, NewStr, Case);
      Buffer = (PBYTE)VirtualAlloc(0, mbi64.RegionSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
      if(Buffer){
        if(ReadProcessMemory64(hProc, mbi64.BaseAddress, Buffer, (SIZE_T)mbi64.RegionSize, &nBytesRead) && (nBytesRead == mbi64.RegionSize)){
          //Le resto el modulo de la división para no perderme cadenas partidas
          DWORD T = nBytesRead - Size - nBytesRead % Size;;
          for(DWORD i=0; i<=T; i++){
            // Busco la cadena en el buffer "no case sensitive"
            if(__StrCmpNIW((PWCHAR)(Buffer + i), Str, Len, Case) == 0){
              VirtualProtectEx64(hProc, mbi64.BaseAddress + i, Size, PAGE_EXECUTE_READWRITE, &OldProtect);
              // Si la encuentro la escribo en el proceso remoto
              if(WriteProcessMemory64(hProc, mbi64.BaseAddress + i, NewStr, Size, &nBytesRead)){
                // si pude escribir incremento el índice para seguir buscando
                i+= Size-1;
                Result++;
              }
              VirtualProtectEx64(hProc, mbi64.BaseAddress + i, Size, OldProtect, 0);
            }
          }
        }
        VirtualFree(Buffer, 0, MEM_RELEASE);
      }
    }
    Start += mbi64.RegionSize;
  }
  CloseHandle(hProc);
  RevertToSelf();
  return Result;
}
 
DWORD RemoteReplaceString(DWORD PID, PWCHAR Str, PWCHAR NewStr, BOOL Case = true)
{
  if(!*Str || !*NewStr) return false;
 
  DWORD Result = 0;
  MEMORY_BASIC_INFORMATION mbi = { 0 };
  PBYTE Start = 0;
  PBYTE Buffer;
  SIZE_T nBytesRead;
  DWORD OldProtect;
 
  DWORD Len  = lstrlenW(Str);
  DWORD Size = Len * sizeof(WCHAR);
 
  EnablePrivilege("SeDebugPrivilege", true);
  ImpersonateToLoginUser();
  HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
 
  while(VirtualQueryEx(hProc, Start, &mbi, sizeof(mbi))){
    if(mbi.Protect && !(mbi.Protect & (PAGE_NOACCESS | PAGE_GUARD))){
      Buffer = (PBYTE)VirtualAlloc(0, mbi.RegionSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
      if(Buffer){
        nBytesRead = 0;
        if(ReadProcessMemory(hProc, mbi.BaseAddress, Buffer, mbi.RegionSize, &nBytesRead) && (nBytesRead == mbi.RegionSize)){
          //Le resto el modulo de la división para no perderme cadenas partidas
          DWORD T = nBytesRead - Size - nBytesRead % Size;
          for(DWORD i=0; i<=T; i++){
            // Busco la cadena en el buffer "no case sensitive"
//            if(_wcsnicmp((PWCHAR)(Buffer + i), Str, Len) == 0){
            if(__StrCmpNIW((PWCHAR)(Buffer + i), Str, Len, Case) == 0){
              // Si la encuentro la escribo en el proceso remoto
              VirtualProtectEx(hProc, (PBYTE)mbi.BaseAddress + i, Size, PAGE_EXECUTE_READWRITE, &OldProtect);
              if(WriteProcessMemory(hProc, (PBYTE)mbi.BaseAddress + i, NewStr, Size, 0)){
                // si pude escribir incremento el índice para seguir buscando
                i += Size - 1;
                Result++;
              }//else Beep(1000, 100);
              VirtualProtectEx(hProc, (PBYTE)mbi.BaseAddress + i, Size, OldProtect, 0);
            }
          }
        }
        VirtualFree(Buffer, 0, MEM_RELEASE);
      }
    }
    Start += mbi.RegionSize;
  }
  CloseHandle(hProc);
  RevertToSelf();
  return Result;
}

.

Subo una aplicación similar a la de delphi pero esta vez usa threads.
 
Saludos.

 

.

Archivos adjuntos

•  Builder 64To32 thread.rar   191,32KB   19 descargas

[azdin]

Me preguntaba ¿Por qué no funcionaba?
Pues ayudado de un programa que busca los String me di cuenta de que si busco en forma UNICODE aparecen unos resultados....

Pero si busco en forma No UNICODE aparecen otros u.u no sé si me explique bien, pero el programa solo afecta a lo UNICODE y Si necesito hacer una modificación a ASCIIZ, ¿Se podría?

[azdin]

Y también quería preguntar que compilador e IDE esta usando para el c++

[escafandra]

...pero el programa solo afecta a lo UNICODE y Si necesito hacer una modificación a ASCIIZ, ¿Se podría?

Ya te contesté que si se puede, como si quieres buscar bloques de bytes y no cadenas. Basta con pequeñas modificaciones para hacerlo.

Estudia el código y realiza tú mismo los cambios. 
 

Y también quería preguntar que compilador e IDE esta usando para el c++

El compilador usado es Borland C++ Builder 5.


Saludos.