View source for Process Creation, Load PE, dan WOW64

Penjelasan bagaimana sebuah process dimuat dan file PE dieksekusi

<span id="process-creation"></span>
= Process Creation =

'''1. Memulai Program''' 

Ketika pengguna menjalankan sebuah program (misalnya ''calc.exe'' ), sistem operasi perlu membuat proses baru untuk menjalankannya. Proses ini dimulai dengan memanggil API '''CreateProcess''' yang dikirim oleh ''explorer.exe'' (karena pengguna menjalankan program melalui Windows Explorer). API ini memberi tahu sistem operasi bahwa ada permintaan untuk membuat proses baru dan menjalankan eksekusinya.

contoh API CreateProcess

<syntaxhighlight lang="cpp">// https://learn.microsoft.com/en-us/windows/win32/procthread/creating-processes

#include <windows.h>
#include <stdio.h>
#include <tchar.h>

int  _tmain(int argc, TCHAR *argv[]) 
{
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    ZeroMemory(&pi, sizeof(pi));

    if (argc != 2)
    {
        printf("Usage: %s [cmdline]\n", argv[0]);
        return  1;
    }

    // Start the child process.
    if (!CreateProcess(NULL, // No module name (use command line)
        argv[1], // Command line
        NULL, // Process handle not inheritable
        NULL, // Thread handle not inheritable
        FALSE, // Set handle inheritance to FALSE
        0, // No creation flags
        NULL, // Use parent's environment block
        NULL, // Use parent's starting directory
        &si, // Pointer to STARTUPINFO structure
        &pi)) // Pointer to PROCESS_INFORMATION structure
    {
        printf("CreateProcess failed (%d).\n", GetLastError());
        return  1;
    }

    WaitForSingleObject(pi.hProcess, INFINITE);

    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

    return  0;
}</syntaxhighlight>
'''2. Membuat Struktur Data Proses''' 

Setelah menerima permintaan dari ''explorer.exe'' , Windows mulai membuat struktur data proses di dalam kernel. Struktur ini disebut '''EProcess''' ( ''Executive Process Object'' ), yang berisi berbagai informasi terkait proses yang baru dibuat, seperti

* Process ID (PID) → Identifikasi unik untuk proses baru.
* Parent Process ID (PPID) → Mengacu ke ''explorer.exe'' sebagai induk dari proses ''calc.exe'' .

Struktur ini digunakan oleh sistem operasi untuk mengelola proses, termasuk alokasi sumber daya dan manajemen memori.

'''3. Inisialisasi Memori Virtual''' 

Setelah proses dibuat, Windows perlu menyediakan memori virtual untuknya. Langkah-langkahnya meliputi: * Alokasi memori virtual untuk proses. * Pembuatan struktur PEB (Process Environment Block) , yang berisi informasi penting terkait proses. * Memuat dua DLL utama yang selalu dibutuhkan oleh aplikasi Windows, yaitu: - <code>ntdll.dll</code> → Berisi fungsi inti Windows NT. - <code>kernel32.dll</code> → Berisi API tingkat tinggi untuk manajemen proses dan memori. * Jika program berjalan dalam lingkungan Windows yang berbeda (misalnya POSIX), maka bisa saja tidak menggunakan <code>kernel32.dll</code>.

'''5. Memuat File PE (Portable Executable)''' 

Setelah memori siap, Windows mulai memuat file PE (Portable Executable) , yang merupakan format biner dari program yang akan dieksekusi. * Sistem membaca header PE untuk mengetahui informasi tentang eksekusi program. * Semua ''ibrary atau DLL eksternal yang dibutuhkan oleh program dimuat ke dalam memori. '' Sistem juga memastikan bahwa semua referensi API dalam kode program sudah diselesaikan, dengan menyimpan alamat fungsi dari DLL yang digunakan ke dalam tabel impor (import table).

'''6. Memulai Eksekusi''' 

Langkah terakhir adalah menjalankan program:

* Windows membuat thread pertama dalam proses yang baru dibuat.
* Thread ini menjalankan inisialisasi awal sebelum program benar-benar berjalan.
* Setelah itu, thread akan memanggil Entry Point dari file PE, yaitu titik awal eksekusi kode program.

Setelah Entry Point dipanggil, proses dianggap telah berjalan dan program siap digunakan.

<span id="loading-file-pe"></span>
= Loading file PE =

'''1. Parsing Header PE''' Windows memulai proses dengan membaca berbagai header dalam file PE:

* '''DOS Header (<code>MZ</code>)''': Digunakan untuk menemukan offset ke '''PE Header'''.
* '''PE Header (<code>PE\0\0</code>)''': Berisi informasi penting tentang executable, termasuk:
** '''ImageBase''' → Alamat virtual yang diinginkan untuk memuat PE file.
** '''NoOfSections''' → Jumlah section dalam PE file.
** '''SizeOfImage''' → Ukuran total PE setelah dimuat ke dalam memori.

Informasi ini digunakan untuk mengalokasikan memori dengan ukuran yang tepat.

'''2. Parsing Section Table'''

* Menggunakan informasi dari NoOfSections, loader membaca semua section dalam file PE.
* Setiap section memiliki alamat dan ukuran dalam memori, disebut VirtualAddress dan VirtualSize.
* Loader juga mencatat offset dan ukuran section di hard disk untuk membaca datanya.

Contoh section umum dalam PE file:

* <code>.text</code> → Berisi kode eksekusi program.
* <code>.data</code> → Berisi data statis program.
* <code>.rdata</code> → Berisi string dan informasi impor.

'''3. Memetakan File ke Memori'''

* Loader menggunakan SectionAlignment untuk menyalin header dan section ke memori.
* Setiap section dipindahkan ke alamat yang sesuai berdasarkan VirtualAddress dan VirtualSize.
* Jika alamat atau ukuran tidak sesuai dengan SectionAlignment, Windows akan menyesuaikannya sebelum menggunakannya.

Pada tahap ini, PE file telah dimuat ke dalam memori, tetapi belum dijalankan.

'''4. Memuat Library/DLL'''

* Loader membaca daftar DLL yang dibutuhkan oleh program dari import table.
* Untuk setiap DLL:
*# Windows mencari lokasi DLL di sistem.
*# Jika belum dimuat, Windows memuat DLL ke dalam memori.
*# Jika DLL membutuhkan DLL lain, proses ini dilakukan secara rekursif hingga semua dependensi terpenuhi.
*# Windows mengambil alamat API dari DLL dan menyimpannya di import table PE file agar program bisa memanggilnya.

'''5. Relokasi jika Diperlukan'''

* Jika ImageBase yang diinginkan tidak tersedia, Windows harus memuat PE file di alamat lain.
* Loader menggunakan relocation table untuk menyesuaikan alamat absolut dalam kode program dengan alamat baru.
* Proses ini memastikan bahwa program tetap dapat berjalan meskipun tidak dimuat di alamat memori yang diharapkan.

Contoh diperlukannya relokasi: Misalnya, sebuah program dikompilasi dengan ImageBase <code>0x400000</code>, tetapi dimuat ke alamat <code>0x500000</code>. Jika ada instruksi dalam kode yang merujuk ke alamat <code>0x401234</code>, loader akan menyesuaikan alamat ini menjadi <code>0x501234</code> (karena <code>0x500000 - 0x400000 = 0x100000</code>, jadi <code>0x401234 + 0x100000 = 0x501234</code>).

Dalam sistem operasi modern ada namanya Address Space Layout Randomization (ASLR) yang digunakan untuk meningkatkan keamanan dengan memuat program di alamat memori yang acak. Karena ASLR mengacak alamat memori, maka relokasi diperlukan agar program tetap berjalan tanpa mengalami crash.

'''6. Memulai Eksekusi'''

* Windows membuat thread pertama untuk menjalankan program.
* EntryPoint (alamat awal eksekusi) dari PE file dipanggil.
* Program mulai berjalan.

<span id="wow64"></span>
= WOW64 =

WOW64 (''Windows-on-Windows 64-bit'') adalah subsistem di Windows yang memungkinkan aplikasi 32-bit berjalan di sistem operasi Windows 64-bit. Karena sistem operasi 64-bit tidak bisa langsung menjalankan aplikasi 32-bit secara native, WOW64 berfungsi sebagai emulator yang menjembatani perbedaan antara lingkungan 32-bit dan 64-bit.

<span id="komponen-wow64"></span>
=== '''Komponen WOW64''' ===

WOW64 terdiri dari tiga Dynamic Link Libraries (DLL) utama:

# '''wow64.dll''' – Bertanggung jawab untuk menangani transisi antara kode 32-bit dan 64-bit.
# '''wow64cpu.dll''' – Menangani instruksi CPU, memastikan bahwa instruksi 32-bit dapat diterjemahkan dalam lingkungan 64-bit.
# '''wow64win.dll''' – Berfungsi sebagai antarmuka antara aplikasi 32-bit dan subsistem grafis Windows.

Ketiga DLL ini menciptakan lingkungan simulasi yang mencakup '''ntdll.dll''' dan '''kernel32.dll''' versi 32-bit, sehingga aplikasi 32-bit bisa tetap berjalan.

<span id="bagaimana-wow64-bekerja"></span>
=== '''Bagaimana WOW64 Bekerja?''' ===

* Aplikasi 32-bit awalnya memanggil API Windows seperti biasa.
* WOW64 akan menangkap panggilan ini dan meneruskannya melalui '''X86SwitchTo64BitMode'''.
* Fungsi ini mengalihkan mode eksekusi ke 64-bit dan memanggil versi 64-bit dari '''ntdll.dll''', yang berkomunikasi langsung dengan kernel Windows.
* Hasilnya kemudian dikembalikan ke aplikasi 32-bit.

<span id="deteksi-wow64-oleh-malware"></span>
=== '''Deteksi WOW64 oleh Malware''' ===

Karena lingkungan WOW64 adalah emulator, malware sering mencoba mendeteksi apakah mereka berjalan di dalamnya untuk menghindari analisis atau menjalankan payload berbeda. Windows menyediakan API '''IsWow64Process''', yang memungkinkan program mengetahui apakah mereka sedang berjalan dalam mode WOW64 atau di sistem 32-bit asli.