8 respuestas en este tema

[escafandra]

En ocasiones nos vemos en la necesidad de matar una aplicación desde código. Ya existen en el foro ejemplos de como hacerlo, bien por su nombre su id de proceso o el puerto que usa una App en red. En esta ocasión me vi en la necesidad de matar un proceso especial, se trataba de un virus de pendrive cuyo nombre variaba y no así el archivo. La solución fue usar el Hash md5 para localizarlo.

La filosofía es recorrer los procesos en ejecución, encontrar la ruta del archivo ejecutable y calcular su hash md5 para compararlo con el que buscamos y matar dicho proceso. Eventualmente, también podemos borrar el archivo ejecutable y desinstalarlo del registro de Windows.

La desinstalación del registro se realiza buscando el proceso en la clave:

delphi

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\run\

en el ejemplo se muestra como recorrer el registro y puede variarse para buscar en HKEY_LOCAL_MACHINE u otras. En mi caso bastó con lo expuesto.

Dejo una aplicación de consola que realiza la tarea. Usa como parámetro la cadena MD5 del archivo buscado. En ella está la función para calcular el hash md5 con la API de Windows, la función para encontrar y terminar el proceso y la función para recorrer el registro. Dicho código no encierra grandes complicaciones y puede ser útil para fines como el que me llevó a escribirlo.

El código original lo escribí en C/C++ y en realidad es algo mas complejo del que presento pues incluía un Hook a la API CreateProcessInternalW para, además, evitar la ejecución del proceso viral (o el que se tercie). En este aspecto quisiera recordar el hilo que abrió enecumene Prevenir que aplicación se ejecute
 

cpp

#include <windows.h>
#include <Shlwapi.h>
#include <Tlhelp32.h>
#include <stdio.h>
#include <conio.h>
 
#pragma hdrstop
 
//---------------------------------------------------------------------------
#define MD5LEN  16
#define BUFSIZE 1024
typedef CHAR TMD5[33];
 
 
void GetMD5FromFile(CHAR* FileName, CHAR *MD5)
{
  HANDLE hFile = 0;
  HCRYPTPROV hProv = 0;
  HCRYPTHASH hHash = 0;
  BYTE Hash[MD5LEN];
  DWORD bHash = 0;
  DWORD bRead = 0;
  BYTE* Buffer = (BYTE*)VirtualAlloc(0, BUFSIZE, MEM_COMMIT, PAGE_READWRITE);
  hFile = CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN,
 
NULL);
  if(hFile != INVALID_HANDLE_VALUE){
    if(CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)){
      if(CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash)){
        while (1) {
          ReadFile(hFile, Buffer, BUFSIZE, &bRead, NULL);
          if(!bRead) break;
          CryptHashData(hHash, Buffer, bRead, 0);
        }
        bHash = MD5LEN;
        if(CryptGetHashParam(hHash, HP_HASHVAL, Hash, &bHash, 0)){
          for(int i=0; i<2*MD5LEN; i++){
            MD5[i] = (0x0F & Hash[i/2] >> 4*((i+1)%2)) + 48;
            if(MD5[i] > '9') MD5[i] += 7;
          }
          MD5[32] = 0;
        }
      }
      CryptDestroyHash(hHash);
    }
    CryptReleaseContext(hProv, 0);
  }
  CloseHandle(hFile);
  VirtualFree(Buffer, 0, MEM_RELEASE);
}
 
 
//---------------------------------------------------------------------------
// Desinstala una App de la clave HKEY_CURRENT_USER\...\run
bool RegDesinstall(CHAR *App)
{
  CHAR* RunKey = "Software\\Microsoft\\Windows\\CurrentVersion\\run\\";
  HKEY hKey  = 0;
  CHAR* Value = 0;
  CHAR  ValueName[256];
  DWORD dwValueName = sizeof(ValueName);
  DWORD Type;
  CHAR  Data[256];
  DWORD dwData = sizeof(Data);
  int Index;
  bool Result = false;
 
  // Si es un Path a una sunblave enumeramos los valores
  Index = 0;
  if(RegOpenKeyEx(HKEY_CURRENT_USER, RunKey, 0, KEY_READ | KEY_SET_VALUE, &hKey) == ERROR_SUCCESS){
    int ErrorCode = RegEnumValue(hKey, Index++, ValueName, &dwValueName, NULL, &Type, (PBYTE)Data, &dwData);
    while(ErrorCode != ERROR_NO_MORE_ITEMS){
      if(StrStrI(Data, App)){
        Result = (RegDeleteValue(hKey, ValueName) == ERROR_SUCCESS);
        break;
      }
      DWORD dwValueName = sizeof(ValueName);
      DWORD dwData = sizeof(Data);
      ErrorCode = RegEnumValue(hKey, Index++, ValueName, &dwValueName, NULL, &Type, (PBYTE)Data, &dwData);
    }
    RegCloseKey(hKey);
  }
  return Result;
}
 
//---------------------------------------------------------------------------
// Termina los procesos conociendo el nombre del exe o su Hash MD5
void TerminateMD5_Process(TMD5 FileHash, bool Terminate = true, bool DeleteProcess = false)
{
  TMD5 MD5;
  HANDLE Process = 0;
  PROCESSENTRY32 proc = { sizeof(proc) };
 
  // Nos Damos privilegios debug
  HANDLE hToken;
  TOKEN_PRIVILEGES priv = {1, {0, 0, SE_PRIVILEGE_ENABLED}};
  LookupPrivilegeValue(0, SE_DEBUG_NAME, &priv.Privileges[0].Luid);
  OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken);
  AdjustTokenPrivileges (hToken, FALSE, &priv, sizeof priv, 0, 0);
 
  HANDLE hSysSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if(hSysSnapshot != INVALID_HANDLE_VALUE && Process32First(hSysSnapshot, &proc)){
    do{
      HANDLE hSnapshot;
      MODULEENTRY32 ModuleEntry = {sizeof(MODULEENTRY32)};
      hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, proc.th32ProcessID);
      if(hSnapshot != (HANDLE)-1){
        if(Module32First(hSnapshot, &ModuleEntry)){
          GetMD5FromFile(ModuleEntry.szExePath, MD5);
          if(!stricmp(FileHash, MD5)){
            Process = OpenProcess(PROCESS_TERMINATE, false, proc.th32ProcessID);
            if(Terminate && Process){
              if(TerminateProcess(Process, 0))
                printf(ModuleEntry.szExePath); printf("\n");
              CloseHandle(Process);
            }
            if(DeleteProcess){
              SetFileAttributes(ModuleEntry.szExePath, FILE_ATTRIBUTE_ARCHIVE);
              DeleteFile(ModuleEntry.szExePath);
              RegDesinstall(ModuleEntry.szExePath);
            } 
          }
        }
        CloseHandle(hSnapshot);
      }
    }while(Process32Next(hSysSnapshot, &proc));
  }
  CloseHandle(hSysSnapshot);
 
  // Retirar los privilegios debug
  priv.Privileges[0].Attributes = 0;
  AdjustTokenPrivileges (hToken, FALSE, &priv, sizeof priv, 0, 0);
  CloseHandle (hToken);
}
 
 
#pragma argsused
int main(int argc, char* argv[])
{
  if(argc > 1){
    printf("Terminando procesos...\n");
    TerminateMD5_Process(argv[1], true, false);
  }else
    printf("Se necesita un parámetro MD5 que identifique un archivo.\n");
 
  printf("Pulse una tecla para terminar.");
  getch();
  return 0;
}
//---------------------------------------------------------------------------

Espero que este ejemplo sea de utilidad.


Saludos.

Edito para arreglar etiquetas de código y resubir adjunto perdido.

Archivos adjuntos

•  MD5Killer.rar   30,63KB   9 descargas

[egostar]

Muy interesante,

La pregunta obligada, como puedo saber el MD5 que voy a buscar y que supongo estás pasando en argv[1].

Además de interesante me parece una aportación excelente como sueles regalarnos amigo

Saludos

[escafandra]

La pregunta obligada, como puedo saber el MD5 que voy a buscar y que supongo estás pasando en argv[1].

En la red existen numerosas utilidades que nos dan el MD5 de un archivo, sin ir muy lejos, Microsoft tiene una llamada fciv.exe.
En el código que dejo escribo una función (GetMD5FromFile) que lo calcula con las librerías criptográficas de la API de Windows.

Pero estoy terminando de traducir el mismo código a delphi, con lo que te será sencillo usar la función GetMD5FromFile para calcularlo tu mismo. 

Saludos.

[escafandra]

Como suelo hacer en muchas ocasiones, he traducido el código a delphi de forma que los que no uséis el C/C++ lo tengáis disponible para vuestra herramienta favorita. Lo explicado arriba sirve para la versión delphi.

La función GetMD5FromFile os va a servir para calcular el Hash MD5 de cualquier archivo. Debéis tener en cuenta que el parámetro MD5 debe ser una cadena de tamaño mínimo 33 caracteres (32 para el Hash y uno para el nulo final, es un PAnsiChar). Os preguntareis porque no uso un String, pues el motivo es para no usar las funciones de cadena y comprimir el tamaño del ejecutable final. Y así sólo uso API…

Bueno, este es el código:

 

delphi

program MD5Killer;
 
{$APPTYPE CONSOLE}
 
uses
  Windows, Tlhelp32;
 
 
function StrStrI(s1: PCHAR; s2: PCHAR): PCHAR; stdcall; external 'Shlwapi.dll' name 'StrStrIA';
function _stricmp(s1: PCHAR; s2: PCHAR): DWORD; stdcall; external 'ntdll.dll' name '_stricmp';
function CryptAcquireContext(phProv: PDWORD; pszContainer, pszProvider: PCHAR; dwProvType, dwFlags: DWORD): BOOL; stdcall; external ADVAPI32 name 'CryptAcquireContextA';
function CryptCreateHash(hProv, Algid, hKey, dwFlags: DWORD; phHash: PDWORD): BOOL; stdcall; external  ADVAPI32 name 'CryptCreateHash';
function CryptHashData(hHash: DWORD; pbData: PBYTE; dwDataLen, dwFlags: DWORD): BOOL; stdcall; external  ADVAPI32 name 'CryptHashData';
function CryptGetHashParam(hHash, dwParam: DWORD; pbData: PBYTE; pdwDataLen: PDWORD; dwFlags: DWORD): BOOL; stdcall; external  ADVAPI32 name 'CryptGetHashParam';
function CryptDestroyHash(hHash: DWORD): BOOL; stdcall; external  ADVAPI32 name 'CryptDestroyHash';
function CryptReleaseContext(hProv, dwFlags: DWORD): BOOL; stdcall; external  ADVAPI32 name 'CryptReleaseContext';
 
const
CALG_MD5 = ((4 shl 13) or 3);
 
type
TMD5 = array [0..32] of char;
 
procedure GetMD5FromFile(FileName: PCHAR; var MD5: TMD5);
const
  BUFSIZE = 1024;
var
  hProv: DWORD; //HCRYPTPROV;
  hHash: DWORD; //HCRYPTHASH;
  Hash: array [0..15] of Byte;
  bHash, bRead, hFile: DWORD;
  Buffer: PBYTE;
  i: integer;
begin
  Buffer:= VirtualAlloc(nil, BUFSIZE, MEM_COMMIT, PAGE_READWRITE);
 
  hFile:= CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, 0);
  if hFile <> INVALID_HANDLE_VALUE then
  begin
    if CryptAcquireContext(@hProv, nil, nil, 1{PROV_RSA_FULL}, $F0000000{CRYPT_VERIFYCONTEXT}) then
    begin
      if CryptCreateHash(hProv, ((4 shl 13) or 3){CALG_MD5}, 0, 0, @hHash) then
      begin
        while true do
        begin
          ReadFile(hFile, Buffer^, BUFSIZE, bRead, nil);
          if bRead = 0 then break;
          CryptHashData(hHash, Buffer, bRead, 0);
        end;
        bHash:= 16;
        if CryptGetHashParam(hHash, 2 {HP_HASHVAL}, @Hash[0], @bHash, 0) then
        begin
          for i:=0 to 31 do
          begin
            MD5[i]:= CHAR(($0F and (Hash[i div 2] shr (4*((i+1) mod 2)))) + 48);
            if(MD5[i] > '9') then inc(MD5[i], 7);
          end;
          MD5[32]:= #0;
        end;
      end;
      CryptDestroyHash(hHash);
    end;
    CryptReleaseContext(hProv, 0);
  end;
  CloseHandle(hFile);
  VirtualFree(Buffer, 0, MEM_RELEASE);
end;
 
 
//---------------------------------------------------------------------------
// Desinstala una App de la clave HKEY_CURRENT_USER\...\run
function RegDesinstall(App: PCHAR): boolean;
const
  RunKey: PCHAR = 'Software\Microsoft\Windows\CurrentVersion\run\';
var
  Key: HKEY;
  Value: PCHAR;
  dwValueName, _Type, dwData, Index, ErrorCode: DWORD;
  Data, ValueName: array [1..255] of CHAR;
begin
  Result:= false;
  Key:= 0;
  Value:= nil;
  dwValueName:= sizeof(ValueName);
  // Si es un Path a una sunblave enumeramos los valores
  Index:= 0;
  if RegOpenKeyEx(HKEY_CURRENT_USER, RunKey, 0, KEY_READ or KEY_SET_VALUE, Key) = ERROR_SUCCESS then
  begin
    ErrorCode:= RegEnumValue(Key, Index, @ValueName, dwValueName, nil, @_Type, @Data, @dwData);
    Inc(Index);
    while(ErrorCode <> ERROR_NO_MORE_ITEMS) do
    begin
      if(StrStrI(@Data, App) <> nil) then
      begin
        Result:= (RegDeleteValue(Key, @ValueName) = ERROR_SUCCESS);
        break;
      end;
      dwValueName:= sizeof(ValueName);
      dwData:= sizeof(Data);
      ErrorCode:= RegEnumValue(Key, Index, @ValueName, dwValueName, nil, @_Type, @Data, @dwData);
      inc(Index);
    end;
    RegCloseKey(Key);
  end;
end;
 
//---------------------------------------------------------------------------
// Termina los procesos conociendo el nombre del exe o su Hash MD5
procedure TerminateMD5_Process(FileHash: PCHAR; Terminate: boolean = true; DeleteProcess: boolean = false);
var
  MD5: TMD5;
  hProcess, hToken: DWORD;
  proc: TPROCESSENTRY32;
  ModuleEntry: MODULEENTRY32;
  hSysSnapshot, hSnapshot: DWORD;
  priv: TOKEN_PRIVILEGES;
begin
  hProcess:= 0;
  proc.dwSize:= sizeof(proc);
  priv.PrivilegeCount:= 1;
  priv.Privileges[0].Attributes:= SE_PRIVILEGE_ENABLED;
 
    // Nos Damos privilegios debug
  LookupPrivilegeValue(nil, 'SeDebugPrivilege', Pint64(@(priv.Privileges[0].Luid))^);
  OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, hToken);
  AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), nil, PDWORD(0)^);
 
  hSysSnapshot:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if boolean(hSysSnapshot) <>  (boolean(INVALID_HANDLE_VALUE) and boolean(Process32First(hSysSnapshot, proc))) then
  begin
    repeat
      ModuleEntry.dwSize:= sizeof(MODULEENTRY32);
      hSnapshot:= CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, proc.th32ProcessID);
      if hSnapshot <> -1 then
      begin
        if (Module32First(hSnapshot, ModuleEntry)) then
        begin
          GetMD5FromFile(ModuleEntry.szExePath, MD5);
          if _stricmp(@FileHash[0], @MD5[0]) = 0 then
          begin
            hProcess:= OpenProcess(PROCESS_TERMINATE, false, proc.th32ProcessID);
            if Terminate and boolean(hProcess) then
            begin
              if TerminateProcess(hProcess, 0) then
                writeln(ModuleEntry.szExePath);
              CloseHandle(hProcess);
            end;
            if (DeleteProcess) then
            begin
              SetFileAttributes(ModuleEntry.szExePath, FILE_ATTRIBUTE_ARCHIVE);
              DeleteFile(ModuleEntry.szExePath);
              RegDesinstall(ModuleEntry.szExePath);
            end;
          end;
        end;
        CloseHandle(hSnapshot);
      end;
    until (not Process32Next(hSysSnapshot, proc));
  end;
  CloseHandle(hSysSnapshot);
 
  // Retirar los privilegios debug
  priv.Privileges[0].Attributes:= 0;
  AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), nil, PDWORD(0)^);
  CloseHandle (hToken);
end;
 
begin
  if(ParamCount >= 1) then
  begin
    Writeln('Terminando procesos...' + #10);
    TerminateMD5_Process(PCHAR(ParamStr(1)), true, true);
  end
  else
      Writeln('Se necesita un parámetro MD5 que identifique un archivo.' + #10);
 
  Writeln('Pulse una tecla para terminar.');
  Readln;
end.

Espero que os sirva.



Saludos.

Edito para arreglar etiquetas de código y resubir adjunto perdido

Archivos adjuntos

•  MD5Killer Delphi.rar   12,26KB   8 descargas

[egostar]

Ya entiendo, lo que pasas es el nombre del archivo y se calcula el MD5

Saludos

[escafandra]

Ya entiendo, lo que pasas es el nombre del archivo y se calcula el MD5

Exacto, se pasa la ruta completa y calcula el md5.

Subo una aplicación delphi de ejemplo recién salida del tostadero.


Saludos.

[egostar]

Ya entiendo, lo que pasas es el nombre del archivo y se calcula el MD5

Exacto, se pasa la ruta completa y calcula el md5.

Subo una aplicación delphi de ejemplo recién salida del tostadero.


Saludos.

Genial, llegando a casa las descargo

Saludos

[seoane]

Esta muy bien  ... aunque lo que me parece mas interesante es lo de utilizarlo conjuntamente con hooks de las APIs, aunque me temo que en windows 7 debe ser bastante complicado ¿que SO estas usando?

Por otro lado me ha recordado a mi "chivato": http://delphi.jmrds.com/?q=node/47  ... viejos tiempos 

Saludos

[escafandra]

Esta muy bien  ... aunque lo que me parece mas interesante es lo de utilizarlo conjuntamente con hooks de las APIs, aunque me temo que en windows 7 debe ser bastante complicado ¿que SO estas usando?

Cracias por tu apreciación, seoane.

Si lo interesante es usarlo en un Hook. De hecho el programa original lo usa en la aplicación inyectora, para realizar una limpieza en el arranque, y luego la vigilancia es en un Hook a la API CreateProcessInternalW. Digamos que el sistema es mixto y en versión unicode.

El S.O. sobre el que está desarrollado es Windows XP profesional. Tienes toda la razón al puntualizar este aspecto. La inyección de dll 32 bits no funciona en procesos de 64 bits y, además tenemos que según la versión y/o actualización de un S.O., los primeros Bytes de una API pueden ser distintos de un PC a otro, lo que lleva a tener un método para desensamblar código y localizar los jmp y call para poder realizar el trampolín con éxito. Eso lo tengo para procesadores de 32 bits pero no en 64 bits, de esta forma, y por el momento, no puedo real izarlo para Win 7 64 bits.

Sabes que se puede hacer el Hook a través de la IAT de el PE ejecutable, evitando el problema de la sustitución de código en la API a la que queremos hacer el Hook, pero eso tiene el problema de que no funciona si la llamada a la API es dinámica con GetProcAdress y tampoco resuelve el tema de inyección de dll 32 en 64 bits para lo que precisamos un compilador de 64 bits.

Y si nos complicamos mas, lo mas efectivo es un Hook en el Kernel mediante un driver. No precisa dll, no precisa inyección. Pero con esto nos volvemos a enfrentar con las distintas versiones del S.O. (Win XP, Vista, Win7...)

...Por otro lado me ha recordado a mi "chivato": http://delphi.jmrds.com/?q=node/47  ... viejos tiempos 

Si, conocía tu viejo chivato. En realidad esos viejos tiempos si eran divertidos. Los constantes cambios en S.O. y convivencia de varios de ellos nos lo ponen cada vez un poco mas complicado, pero sigue siendo estimulante. 


Saludos.