È possibile rilevare un eseguibile compresso?

6

Un packer è un modo per offuscare un programma eseguibile, cioè trasformarlo in modo che il risultato sia ancora eseguibile e abbia lo stesso effetto quando viene eseguito, ma sembra diverso (quindi non verrà rilevato dall'antivirus statico). I cattivi usano spesso packer personalizzati per offuscare il loro malware, per rendere meno probabile che l'anti-virus rilevi il malware o per rendere più difficile per i produttori di antivirus effettuare il reverse engineering del malware e capire cosa sta facendo.

È possibile rilevare se un determinato eseguibile è stato compresso con un programma di compressione personalizzato? In altre parole, dato un eseguibile, mi piacerebbe classificarlo come "è stato confezionato con un packer personalizzato" o "non ha". Gli strumenti antivirus esistenti sono in grado di rilevare se un eseguibile è stato compresso con un programma di compressione personalizzato?

Sono particolarmente curioso della seguente variante più semplice del problema. Supponiamo che io sappia di un particolare packer personalizzato che viene usato dai cattivi. È possibile riconoscere gli eseguibili che sono stati imballati con questo packer? In altre parole, data una E eseguibile e un packer P, mi piacerebbe classificare E come "era impacchettato da P" o "non era". Esistono tecniche note per farlo? Quanto sono efficaci?

    
posta D.W. 08.10.2013 - 21:48
fonte

3 risposte

8

Esistono molti modi noti per identificare i packer. Il "più comune" UPX del packer e le sue varianti sono solitamente contrassegnate come "sospette" dai motori antivirus a causa di un rilevamento delle firme nel Exe.

Ci sono un paio di strumenti pratici chiamati:

  • RDG Packer Detector che rileva specifici packer basati sul controllo della firma (presumibilmente nello stesso modo in cui lo fa AV

  • PEiD rileva i packer, i cryptors e i compilatori più comuni per i file PE e consente lo smontaggio (disponibile per scaricare tramite softpedia)

  • Un semplice controllo di DB delle firme in python con cui giocare (non sai dove afferrare il DB da se ( prova qui? )

C'è anche un elenco qui di un paio di varianti di packer

Una volta individuato il tipo di packer, puoi utilizzare lo spacchettamento automatico (se ne è già disponibile una) o puoi iniziare a decomprimerlo manualmente.

Are existing anti-virus tools good at detecting whether an executable has been packed with a custom packer?

No, non proprio, guarderanno (come gli strumenti di cui sopra) per le firme. Se trascorri del tempo nei forum di Blackhat, le persone pubblicizzano "Crypters / Packers FUD", il che significa che di solito hanno modificato il modo in cui i loro packer funzionano in modo che gli AV non raccolgano le firme per un po 'di tempo permettendo al malware di passare.

Secondo symantect (come citato in questo documento )

Symantec has collected a large number of packers - more than 2000 variants in more than 200 families.

Il documento sopra menzionato ha anche molte informazioni riguardanti le tecniche utilizzate, le contro-tecniche utilizzate e altro ancora che risponderanno alla seconda parte della tua domanda.

    
risposta data 09.10.2013 - 01:19
fonte
1

Ci sono alcuni articoli scientifici che forniscono le tecniche possibili per rilevare automaticamente gli eseguibili compressi.

es. Perdisci, Lanzi e Lee link applicano il riconoscimento del modello per distinguere i file compressi dai file non compressi . Le funzioni che usano per il riconoscimento dei pattern danno un'idea di come funziona:

Numero di sezioni standard e non standard
Gli eseguibili preconfezionati spesso non seguono i nomi standard.

Numero di sezioni solo eseguibili
Gli eseguibili preconfezionati spesso non hanno sezioni solo eseguibili.

Numero di sezioni leggibili / scrivibili / eseguibili
Eseguibile compresso richiede almeno una sezione che sia leggibile, scrivibile ed eseguibile. La sezione eseguibile dei file non compressi non deve essere scrivibile.

Numero di voci nello IAT
Un file eseguibile pieno di solito ha meno importazioni.

Intestazione PE, codice, dati e entropia file Il codice crittografato sarà casuale.

Lyda e Hamrock descrivono una tecnica che utilizza solo l'entropia. link

    
risposta data 10.05.2014 - 07:17
fonte
-1

se vuoi farlo a livello di codice, dovresti usare questo (o simile) modo / funzione per rilevare la firma del programma di compressione / protettore o del compilatore nel PE e quindi confrontare questa firma con un elenco di firme che esistono in un database di firme conosciute (ad esempio "userdb.txt" di PEiD).

#include <Windows.h>
#include <iostream>
using namespace std;
IMAGE_DOS_HEADER Dos_Header;
IMAGE_FILE_HEADER Pe_Header;
IMAGE_OPTIONAL_HEADER Opt_Header;
IMAGE_SECTION_HEADER ImgSection;
DWORD sections = 0, Count = 0;
void Get_Sign(LPSTR szFileName, DWORD Lenght);
int main() {
Get_Sign(
  "C:\Program Files (x86)\NoVirusThanks\Smart PC Locker Pro\NSPL.exe" /* used in this example ! */
  , 399);
system("pause");
return 0;
} /* */
void Get_Sign(LPSTR szFileName, DWORD Lenght)
// Lenght=399 by defult
{
DWORD i;
HANDLE hFile;
unsigned char Buff;
DWORD Signature = 0;
DWORD EP, IVA, RAW, UNL, Offset;
DWORD BytRet;
hFile = CreateFileA((LPCSTR) szFileName, GENERIC_READ, FILE_SHARE_READ,
  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
  cout << "Error in opening file\n";
  exit(0);
}
else {
  ReadFile(hFile, &Dos_Header, sizeof(IMAGE_DOS_HEADER), &BytRet, NULL);
  if (Dos_Header.e_magic = IMAGE_DOS_SIGNATURE) {
   SetFilePointer(hFile, Dos_Header.e_lfanew, NULL, 0);
   ReadFile(hFile, &Signature, sizeof(Signature), &BytRet, NULL);
   if (Signature == IMAGE_NT_SIGNATURE) {
    ReadFile(hFile, &Pe_Header, sizeof(Pe_Header), &BytRet, NULL);
    sections = Pe_Header.NumberOfSections;
    if (Pe_Header.SizeOfOptionalHeader > 0) {
     ReadFile(hFile, &Opt_Header, sizeof(Opt_Header),
      &BytRet, NULL);
     EP = Opt_Header.AddressOfEntryPoint;
     for (Count = 1; Count <= sections; Count++) {
      ReadFile(hFile, &ImgSection, sizeof(ImgSection),
       &BytRet, NULL);
      if (EP < ImgSection.VirtualAddress +
       ImgSection.SizeOfRawData)
       break;
     }
     IVA = ImgSection.VirtualAddress;
     RAW = ImgSection.PointerToRawData;
     UNL = Opt_Header.SizeOfUninitializedData;
     Offset = EP - IVA + RAW;
     // get size of  uninitialized data
     // UNL = IVA - UNL;
     // Offset = EP - UNL + RAW;
     // get offset of signatures to read
    }
    for (i = Offset; i <= (Offset + Lenght); i++) {
     SetFilePointer(hFile, i, NULL, 0);
     ReadFile(hFile, &Buff, sizeof(Buff), &BytRet, NULL);
     printf("%X", Buff);
    }
    cout << endl << endl;
   }
  }
}
}

(Mi scusi se il mio inglese è cattivo)

    
risposta data 13.10.2013 - 10:48
fonte

Leggi altre domande sui tag