Jak w prosty sposób oszukać ochronę antywirusową

Nie od wczoraj wiadomo, że programy antywirusowe chronią wyłącznie przeciwko najpopularniejszym zagrożeniom rozprzestrzenianym na masową skalę. Ostatnio opublikowane badania dotyczące omijania dynamicznej analizy antywirusowej po raz kolejny to potwierdziły.

Celem modułów dynamicznej analizy w czasie rzeczywistym jest wykrywanie dotychczas nieznanego, złośliwego oprogramowania. Emeric Nasi w swoich badaniach przetestował parę technik zaciemniania złośliwego kodu, który przestał być wykrywany przez większość oprogramowania antywirusowego.

Poniżej prezentujemy kilka najciekawszych sztuczek, które skutecznie oszukały wszystkie spośród 55 testowanych programów antywirusowych:

• użycie rzadko używanych funkcji systemowych (np. VirtualAllocExNuma),
• sprawdzenie nazwy pliku z jaką program został wywołany,
• stworzenie obiektu mutex, a następnie potomnego procesu testującego istnienie wcześniej ustawionego muteksu,
• przydzielenie „dużej” ilości pamięci podczas startu programu (np. 100 MB),
• wykonanie kilku milionów bezsensownych operacji procesora podczas startu programu.

Warto się zastanowić co przyczynia się do tego, że analiza dynamiczna zawodzi przy tak prostych metodach ukrywania złośliwego kodu przed skanerami AV.

Techniki przedstawione w dokumencie Emerica Nasi wykorzystują fakt uruchamiania złośliwego kodu w środowisku, które jest „emulowane” przez antywirusy. Kod uruchamiany jest w piaskowanicach lub innych środowiskach, które nie odwzorowują idealnie prawdziwego systemu. Gdy złośliwe fragmenty kodu nie zostaną wykonane, wtedy sygnatury nie będą miały szansy wykrycia podejrzanego ciągu instrukcji. Wszystko co trzeba zrobić, to tak posterować wykonaniem programu, aby złośliwy kod wykonał się w systemie ofiary, a nie wykonał się w „środowisku” AV.

Tak dochodzimy do pierwszej, niedawno jeszcze 100% metody omijania AV. Niektóre funkcje systemowe, jak chociażby VirtualAllocExNuma, są na tyle specyficzne i rzadko używane, że nie do końca poprawnie zostały odtworzone przez oprogramowanie antywirusowe, co daje świetną metodę do sterowania wykonaniem złośliwego kodu:

int main( void )
{
   LPVOID mem = NULL;
   mem = VirtualAllocExNuma(GetCurrentProcess(), NULL, 1000, MEM_RESERVE | 
MEM_COMMIT, PAGE_EXECUTE_READWRITE,0);
   if (mem != NULL)
   {
     decryptCodeSection();
     startShellCode();
   }
   return 0;
}

Podobny efekt uzyskamy również dzięki sprawdzaniu pierwszego argumentu wykonywalnego programu – w normalnych warunkach powinniśmy otrzymać po prostu nazwę złośliwego pliku. Gdy jednak program wykonywany jest przez AV, pierwszy argument (argv[0]) nie zwróci nazwy złośliwego pliku (np. „test.exe„), a nazwę wątku programu AV, który obecnie analizuje malware (np. „antivuris-scanner.exe„):

int main(int argc, char * argv[])
{
   if (strstr(argv[0], "test.exe") >0)
   {
     decryptCodeSection();
     startShellCode();
   }
   return 0;
}

Kolejny przykład dotyczy obsługi muteksów używanych w programowaniu współbieżnym/równoległym do wykluczania współdzielonych zasobów lub fragmentów kodu. Aby obejść ochronę AV wystarczy stworzyć mutex w systemie, następnie powołać do życia proces potomny, a następnie sprawdzić czy niedawno ustawiony mutex jest widoczny. Klasycznie warunek ten powinien oczywiście zachodzić, jednak jak widzimy po wynikach Emerica Nasi, w środowisku symulowanym przez AV już tak nie jest:

int main()
{
  HANDLE mutex;
  mutex = CreateMutex(NULL, TRUE, "muuuu"); 
  if (GetLastError() == ERROR_ALREADY_EXISTS)
  {
    decryptCodeSection();
    startShellCode();
  }
  else
  {
    startExe("test.exe");
    Sleep(100);
  }
  return 0;
}

Jest jeszcze inny duży problem, związany ze skutecznością oprogramowania AV, które w odróżnieniu od powyższych, raczej nie zostanie szybko rozwiązany.

Program antywirusowy, który posiadałby szereg skomplikowanych funkcji gwarantujących najwyższy stopień bezpieczeństwo, nie mógłby być programem użytecznym. Nikt nie chce używać narzędzi ochrony, które przez wnikliwą analizę mocno spowolnią działanie systemu.

Powyższy fakt również znalazł swoje odbicie w badaniach. Okazuje się, że tak proste czynności, jak chociażby alokacja 100 MB pamięci lub wykonanie kilka milionów kroków pętli przy starcie programu wystarczy, aby omijać moduły dynamicznej analizy współczesnych systemów antywirusowych. Bezpieczeństwo kosztem użyteczności:

#define MAX_OP 100000000
int main()
{
  int cpt = 0;
  int i = 0;
  for(i =0; i < MAX_OP; i ++)
  {
    cpt++;
  }
  if(cpt == MAX_OP)
  {
    decryptCodeSection();
    startShellCode();
  }
  return 0;
}

#define TOO_MUCH_MEM 100000000
int main()
{
  char * memdmp = NULL;
  memdmp = (char *) malloc(TOO_MUCH_MEM);
  if(memdmp!=NULL)
  {
    memset(memdmp,00, TOO_MUCH_MEM);
    free(memdmp);
    decryptCodeSection();
    startShellCode();
  }
  return 0;
}

Dokument „Bypass Antivirus Dynamic Analysis – Limitations of the AV model and how to exploit them” zawiera jeszcze kilka innych technik, które z dużą skutecznością pomagają zwodzić oprogramowanie antywirusowe, np.:

• odwołanie się do nieistniejącego adresu URL,
• sprawdzenie wielkości zbioru roboczego procesu (ang. „working set”), czyli zbioru stron pamięci, które są aktualnie wykorzystywane przez proces,
• oszukanie emulacji funkcji sleep() przez środowisko AV,
• …

Mimo tego, że za pewien czas wiele spośród powyższych technik przestanie być skuteczna, to bez problemu będzie można znaleźć analogiczne odpowiedniki, które pozwolą omijać wykrywanie złośliwego kodu. Oznacza to, że ochrona AV jeszcze długo nie będzie w stanie skutecznie odpierać złośliwe instrukcje napisane przez zmotywowanych agresorów.

Oczywiście nie oznacza to, że nie powinniśmy jej używać :-)

– Adrian “Vizzdoom” Michalczyk dla serwisu Sekurak.pl