Pendahuluan
Posting ini akan menjelaskan pembuatan file packer sederhana yang dapat dieksekusi untuk linux x86_64. Diasumsikan bahwa pembaca sudah mengenal bahasa pemrograman C, bahasa assembly untuk arsitektur x86_64, dan file perangkat ELF. Untuk memastikan kejelasan, penanganan kesalahan dihapus dari kode di artikel dan implementasi beberapa fungsi tidak ditampilkan, kode lengkap dapat ditemukan dengan mengklik tautan ke github (
loader ,
packer ).
Idenya adalah ini: kami mentransfer file ELF ke packer, dan kami mendapatkan yang baru dengan struktur berikut pada output:
Untuk kompresi, diputuskan untuk menggunakan algoritma Huffman, untuk enkripsi - AES-CTR dengan kunci 256-bit, yaitu implementasi dari kokke
tiny-AES-c . 256 byte data acak digunakan untuk menginisialisasi kunci AES dan vektor inisialisasi menggunakan generator angka acak semu, seperti yang ditunjukkan di bawah ini:
for(int i = 0; i < 32; i++) { seed = (1103515245*seed + 12345) % 256; key[i] = buf[seed]; }
Keputusan ini disebabkan oleh keinginan untuk menyulitkan reverse engineering. Sampai saat ini, saya menyadari bahwa komplikasi itu tidak signifikan, tetapi saya tidak mulai menghilangkannya, karena saya tidak ingin menghabiskan waktu dan energi untuk itu.
Bootloader
Pertama, boot loader akan ditinjau. Loader tidak boleh memiliki dependensi, jadi semua fungsi yang diperlukan dari pustaka C standar harus ditulis secara independen (implementasi fungsi-fungsi ini tersedia dengan
referensi ). Itu juga harus mandiri secara posisi.
_Mulailah fungsi
Bootloader dimulai dari fungsi _start, yang hanya meneruskan argc dan argv ke main:
.extern main .globl _start .text _start: movq (%rsp), %rdi movq %rsp, %rsi addq $8, %rsi call main
Fungsi utama
File main.c dimulai dengan mendefinisikan beberapa variabel eksternal:
extern void* loader_end;
Semua dari mereka dinyatakan sebagai eksternal untuk menemukan posisi karakter yang sesuai dengan variabel (Elf64_Sym) dalam paket dan mengubah nilainya.
Fungsi utamanya sendiri cukup sederhana. Langkah pertama adalah menginisialisasi pointer ke file ELF yang dikemas, buffer 256-byte, dan ke atas tumpukan. Kemudian file ELF didekripsi dan diperluas, kemudian ditempatkan di tempat yang tepat di memori menggunakan fungsi load_elf, dan akhirnya, nilai register rsp kembali ke keadaan semula, dan lompatan ke titik entri program terjadi:
#define SET_STACK(sp) __asm__ __volatile__ ("movq %0, %%rsp"::"r"(sp)) #define JMP(addr) __asm__ __volatile__ ("jmp *%0"::"r"(addr)) int main(int argc, char **argv) { uint8_t *payload = (uint8_t*)&loader_end;
Menyetel ulang status AES dan file ELF yang dikompresi dilakukan untuk tujuan keamanan - sehingga data kunci dan dekripsi disimpan dalam memori hanya selama durasi penggunaan.
Selanjutnya, kami akan mempertimbangkan implementasi beberapa fungsi.
load_elf
Saya mengambil fungsi ini dari pengguna github dengan nickname bediger dari repositori
userlandexec- nya dan menyelesaikannya, karena fungsi aslinya macet pada file seperti ET_DYN. Kegagalan terjadi karena fakta bahwa nilai argumen pertama dari panggilan sistem mmap diatur ke NULL, dan alamat dikembalikan cukup dekat dengan program utama, selama panggilan berikutnya ke mmap dan menyalin segmen ke alamat yang dikembalikan oleh mereka, kode program utama ditimpa, dan segfault terjadi. Oleh karena itu, diputuskan untuk menambahkan alamat awal sebagai parameter ke fungsi load_elf. Fungsi itu sendiri berjalan melalui semua tajuk program, mengalokasikan memori (jumlahnya harus merupakan kelipatan dari ukuran halaman) untuk segmen PT_LOAD dari file ELF, menyalin kontennya ke area memori yang dialokasikan dan menetapkan hak baca, tulis, eksekusi yang sesuai untuk area ini:
elf_load_addr
Fungsi ini untuk file ET_EXEC ELF mengembalikan NULL, karena file jenis ini harus ditempatkan di alamat yang ditentukan di dalamnya. Untuk file ET_DYN, alamat sama dengan perbedaan antara alamat dasar program utama (mis., Bootloader), jumlah memori yang diperlukan untuk menempatkan ELF dalam memori, dan 4096, 4096 - jarak yang diperlukan agar tidak menempatkan file ELF tepat di sebelah program utama dihitung pertama kali. Setelah menghitung alamat ini, diperiksa apakah area memori berpotongan, dari alamat yang diberikan ke alamat dasar dari program utama, dengan area dari awal file ELF yang belum dibongkar sampai akhir. Dalam hal persimpangan, alamat dikembalikan sama dengan perbedaan antara alamat awal ELF yang dibongkar dan jumlah memori yang diperlukan untuk meletakkannya, jika tidak, alamat yang dihitung sebelumnya dikembalikan.
Alamat dasar program ditemukan dengan mengekstraksi alamat header program dari vektor bantu (vektor tambahan ELF), yang terletak setelah pointer ke variabel lingkungan di stack, dan mengurangi ukuran header ELF dari itu:
--------------------------------------------------------------------------- -> [ argc ] 8 [ argv[0] ] 8 [ argv[1] ] 8 [ argv[..] ] 8 * x [ argv[n – 1] ] 8 [ argv[n] ] 8 (= NULL) [ envp[0] ] 8 [ envp[1] ] 8 [ envp[..] ] 8 [ envp[term] ] 8 (= NULL) [ auxv[0] (Elf64_auxv_t) ] 16 [ auxv[1] (Elf64_auxv_t) ] 16 [ auxv[..] (Elf64_auxv_t) ] 16 [ auxv[term] (Elf64_auxv_t) ] 16 (= AT_NULL) [ ] 0 - 16 [ ] >= 0 [ ] >= 0 [ ] 8 (= NULL) < > 0 ---------------------------------------------------------------------------
Struktur dimana setiap elemen dari vektor bantu dijelaskan memiliki bentuk:
typedef struct { uint64_t a_type;
Salah satu nilai a_type yang valid adalah AT_PHDR, a_val kemudian akan mengarah ke header program. Berikut ini adalah kode untuk fungsi elf_load_addr:
void* elf_base_addr(void *rsp) { void *base_addr = NULL; unsigned long argc = *(unsigned long*)rsp; char **envp = rsp + (argc+2)*sizeof(unsigned long);
Deskripsi Skrip Linker
Kita perlu mendefinisikan karakter untuk variabel eksternal yang dijelaskan di atas, dan juga memastikan bahwa kode dan data loader setelah kompilasi berada di bagian .text yang sama. Ini diperlukan untuk mengekstrak kode mesin loader dengan mudah hanya dengan memotong konten bagian ini dari file. Untuk mencapai tujuan ini, skrip tautan berikut ditulis:
ENTRY(_start) SECTIONS { . = 0; .text :{ *(.text) *(.text.startup) *(.data) *(.rodata) payload_size = .; QUAD(0) key_seed = .; QUAD(0) iv_seed = .; QUAD(0) loader_end = .; } }
Perlu dijelaskan bahwa QUAD (0) menempatkan 8 byte nol, alih-alih pengepak akan mengganti nilai-nilai tertentu. Untuk memotong kode mesin, sebuah utilitas kecil ditulis yang juga menulis ke permulaan kode mesin pergeseran titik masuk ke bootloader dari awal bootloader, offset nilai nilai payload_size, key_seed dan karakter iv_seed dari awal bootloader. Kode untuk utilitas ini tersedia di
sini . Ini mengakhiri deskripsi bootloader.
Pengepakan langsung
Pertimbangkan fungsi utama pengepak. Ia menggunakan dua argumen baris perintah: nama file input adalah argv [1] dan nama file output adalah argv [2]. Pertama, file input ditampilkan dalam memori dan diperiksa kompatibilitasnya dengan pengepak. Packer hanya berfungsi dengan dua jenis file ELF: ET_EXEC dan ET_DYN, dan hanya dengan yang dikompilasi secara statis. Alasan untuk memperkenalkan pembatasan ini adalah kenyataan bahwa sistem linux yang berbeda memiliki versi yang berbeda dari pustaka bersama, yaitu kemungkinan program yang dikompilasi secara dinamis tidak akan mulai pada sistem selain sistem induknya cukup tinggi. Kode yang sesuai dalam fungsi utama:
size_t mapped_size; void *mapped = map_file(argv[1], &mapped_size); if(check_elf(mapped) < 0) return 1;
Setelah itu, jika file input melewati pemeriksaan kompatibilitas, ia dikompres:
size_t comp_size; uint8_t *comp_buf = huffman_encode(mapped, &comp_size);
Kemudian keadaan AES dihasilkan, dan file ELF terkompresi dienkripsi. Keadaan AES ditentukan oleh struktur berikut:
#define AES_ENTROPY_BUFSIZE 256 typedef struct { uint8_t entropy_buf[AES_ENTROPY_BUFSIZE];
Kode yang sesuai di utama:
AES_state_t aes_st; for(int i = 0; i < AES_ENTROPY_BUFSIZE; i++) state.entropy_buf[i] = rand() % 256; state.key_seed = rand(); state.iv_seed = rand(); AES_init_ctx_iv(&state.ctx, state.entropy_buf, state.key_seed, state.iv_seed); AES_CTR_xcrypt_buffer(&aes_st.ctx, comp_buf, comp_size);
Setelah itu, struktur yang menyimpan informasi tentang bootloader diinisialisasi, nilai payload_size, key_seed, dan iv_seed di bootloader diubah menjadi yang dihasilkan pada langkah sebelumnya, setelah itu keadaan AES diatur ulang. Informasi tentang bootloader disimpan dalam struktur berikut:
typedef struct { char *loader_begin;
Kode yang sesuai di utama:
loader_t loader; init_loader(&loader); *loader.payload_size_patch_offset = comp_size; *loader.key_seed_pacth_offset = aes_st.key_seed; *loader.iv_seed_patch_offset = aes_st.iv_seed; memset(&aes_st.ctx, 0, sizeof(aes_st.ctx));
Pada bagian terakhir, kita membuat file output, menulis header ELF, satu header program, kode loader, file ELF terkompresi dan terenkripsi, dan buffer 256-byte ke dalamnya:
int out_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0755);
Kode utama dari pengepak berakhir di sini, maka fungsi-fungsi berikut akan dipertimbangkan: fungsi menginisialisasi informasi tentang bootloader, fungsi penulisan header ELF dan fungsi penulisan header program.
Menginisialisasi informasi bootloader
Kode mesin loader tertanam dalam paket yang dapat dieksekusi menggunakan kode sederhana di bawah ini:
.data .globl _loader_begin .globl _loader_end _loader_begin: .incbin "loader" _loader_end:
Untuk menentukan alamatnya dalam memori, variabel berikut dideklarasikan dalam file main.c:
extern void* _loader_begin; extern void* _loader_end;
Selanjutnya, pertimbangkan fungsi init_loader. Pertama, secara berurutan membaca nilai berikut: offset masukan dari awal titik bootloader (entry_offset), nilai dimensi offset dikemas berkas ELF dari awal loader (payload_size_patch_offset), perpindahan nilai pembangkit utama untuk kunci dari awal loader (key_seed_patch_offset), perpindahan nilai pembangkit utama untuk vektor inisialisasi dari awal bootloader (iv_seed_patch_offset). Kemudian, alamat pemuat ditambahkan ke tiga nilai terakhir, jadi ketika menunjuk referensi dan menetapkan nilai padanya, kami akan mengganti nol yang ditetapkan pada tahap tata letak (QUAD (0)) dengan nilai yang kami butuhkan.
void init_loader(loader_t *l) { void *loader_begin = (void*)&_loader_begin; l->entry_offset = *(size_t*)loader_begin; loader_begin += sizeof(size_t); l->payload_size_patch_offset = *(void**)loader_begin; loader_begin += sizeof(void*); l->key_seed_pacth_offset = *(void**)loader_begin; loader_begin += sizeof(void*); l->iv_seed_patch_offset = *(void**)loader_begin; loader_begin += sizeof(void*); l->payload_size_patch_offset = (size_t)l->payload_size_patch_offset + loader_begin; l->key_seed_pacth_offset = (size_t)l->key_seed_pacth_offset + loader_begin; l->iv_seed_patch_offset = (size_t)l->iv_seed_patch_offset + loader_begin; l->loader_begin = loader_begin; l->loader_size = (void*)&_loader_end - loader_begin; }
write_elf_ehdr
void write_elf_ehdr(int fd, loader_t *loader) {
Di sini inisialisasi standar header ELF terjadi dan penulisan berikutnya ke file, satu-satunya hal yang perlu diperhatikan adalah kenyataan bahwa dalam file ET_DYN ELF segmen yang dijelaskan oleh header program pertama tidak hanya mencakup kode yang dapat dieksekusi, tetapi juga header ELF dan semua header. program. Oleh karena itu, offsetnya dari awal harus sama dengan nol, ukurannya haruslah jumlah dari ukuran header ELF, semua header program dan kode yang dapat dieksekusi, dan titik masuk ditentukan sebagai jumlah dari ukuran header ELF, ukuran semua header program dan offset dari awal kode yang dapat dieksekusi.
write_elf_phdr
void write_elf_phdr(int fd, loader_t *loader, size_t payload_size) {
Di sini, header program diinisialisasi dan kemudian ditulis ke file. Anda harus memperhatikan offset relatif terhadap awal file dan ukuran segmen yang dijelaskan oleh header program. Seperti dijelaskan dalam paragraf sebelumnya, segmen yang dijelaskan oleh tajuk ini tidak hanya mencakup kode yang dapat dieksekusi, tetapi juga tajuk ELF dan tajuk program. Kami juga membuat segmen dengan kode yang dapat dieksekusi dapat diakses untuk ditulis, ini disebabkan oleh fakta bahwa implementasi AES yang digunakan dalam bootloader mengenkripsi dan mendekripsi data “di tempat”.
Beberapa fakta tentang hasil kerja pengepak
Selama pengujian, diketahui bahwa program yang dikompilasi secara statis dengan glibc pergi ke segfault saat memulai, dengan instruksi ini:
movq% fs: 0x28,% rax
Saya tidak dapat menemukan mengapa hal ini terjadi, saya akan senang jika Anda berbagi informasi tentang hal ini. Alih-alih glibc, Anda dapat menggunakan musl-libc, semuanya bekerja dengannya tanpa gagal. Juga, pengepak itu diuji dengan program golang yang dikompilasi secara statis, misalnya, server http. Untuk crash statis penuh dari program golang, bendera berikut harus digunakan:
CGO_ENABLED = 0 buat build -a -ldflags '-extldflags "-static"'.
Hal terakhir yang diuji oleh packer adalah file ET_DYN ELF tanpa linker dinamis. Benar, ketika bekerja dengan file-file ini, fungsi elf_load_addr mungkin gagal. Dalam praktiknya, ini dapat dipotong dari bootloader dan menggunakan alamat tetap, misalnya 0x10000.
Kesimpulan
Packer ini, jelas, tidak masuk akal untuk digunakan untuk tujuan yang dimaksudkan, karena file yang dilindungi olehnya cukup mudah didekripsi. Tujuan dari proyek ini adalah untuk menjadi master yang lebih baik dalam bekerja dengan file ELF, praktik pembuatannya, serta mempersiapkan penciptaan paket yang lebih lengkap.