🧔🏼 🛶 🏣 Linux के लिए x86_64 ELF फ़ाइल पैकर बनाना 📰 🙇 💨

परिचय

यह पोस्ट linux x86_64 के लिए एक सरल निष्पादन योग्य फ़ाइल पैकर के निर्माण का वर्णन करेगी। यह माना जाता है कि पाठक सी प्रोग्रामिंग भाषा, x86_64 आर्किटेक्चर के लिए असेंबली भाषा और डिवाइस ईएसआई फाइलों के साथ परिचित है। स्पष्टता सुनिश्चित करने के लिए, लेख में त्रुटि से निपटने को कोड से हटा दिया गया था और कुछ कार्यों के कार्यान्वयन को नहीं दिखाया गया था, पूरा कोड जीथब ( लोडर , पैकर ) के लिंक पर क्लिक करके पाया जा सकता है।

विचार यह है: हम ELF फ़ाइल को पैकर में स्थानांतरित करते हैं, और हमें आउटपुट पर निम्न संरचना के साथ एक नया मिलता है:

ईएलएफ हेडर
कार्यक्रम का शीर्षक
कोड सेगमेंट	पैकेज्ड ईएलएफ फाइल डाउनलोडर
	पैक्ड ELF फ़ाइल
	यादृच्छिक डेटा के 256 बाइट्स

संपीड़न के लिए, हफ़मैन एल्गोरिदम का उपयोग करने का निर्णय लिया गया था, एन्क्रिप्शन के लिए - एईएस-सीटीआर एक 256-बिट कुंजी के साथ, अर्थात् कोकेक टाइन -एईएस-सी से कार्यान्वयन। यादृच्छिक डेटा के 256 बाइट्स का उपयोग एईएस कुंजी और आरंभीकरण वेक्टर को छद्म यादृच्छिक संख्या जनरेटर का उपयोग करने के लिए किया जाता है, जैसा कि नीचे दिखाया गया है:

for(int i = 0; i < 32; i++) { seed = (1103515245*seed + 12345) % 256; key[i] = buf[seed]; }

यह निर्णय रिवर्स इंजीनियरिंग को जटिल बनाने की इच्छा के कारण हुआ था। आज तक, मैंने महसूस किया कि जटिलता निरर्थक है, लेकिन मैंने इसे दूर करना शुरू नहीं किया, क्योंकि मैं उस पर समय और ऊर्जा खर्च नहीं करना चाहता था।

लोडर

सबसे पहले, बूट लोडर की समीक्षा की जाएगी। लोडर में कोई निर्भरता नहीं होनी चाहिए, इसलिए मानक सी लाइब्रेरी से सभी आवश्यक कार्यों को स्वतंत्र रूप से लिखना होगा (इन कार्यों का कार्यान्वयन संदर्भ द्वारा उपलब्ध है)। यह भी स्थिति स्वतंत्र होना चाहिए।

_Start फ़ंक्शन

बूटलोडर _start फ़ंक्शन से शुरू होता है, जो बस argc और argv से गुजरता है:

 .extern main .globl _start .text _start: movq (%rsp), %rdi movq %rsp, %rsi addq $8, %rsi call main

मुख्य समारोह

Main.c फ़ाइल कई बाहरी चर को परिभाषित करने से शुरू होती है:

 extern void* loader_end; //    , .   //  ELF . extern size_t payload_size; //   ELF  extern size_t key_seed; //     // -   . extern size_t iv_seed; //     // -

पैकर में चर (Elf64_Sym) के अनुरूप वर्णों की स्थिति का पता लगाने और उनके मूल्यों को बदलने के लिए उनमें से सभी को बाहरी घोषित किया जाता है।

मुख्य कार्य अपने आप में काफी सरल है। पहला कदम एक भरे हुए ईएलएफ फ़ाइल, एक 256-बाइट बफर, और स्टैक के शीर्ष पर इंगित करने के लिए है। फिर ईएलएफ फ़ाइल को डिक्रिप्ट और विस्तारित किया जाता है, फिर इसे लोड_फ्लो फ़ंक्शन का उपयोग करके मेमोरी में सही स्थान पर रखा जाता है, और अंत में, आरएसपी रजिस्टर का मूल्य इसकी मूल स्थिति में लौटता है, और प्रोग्राम एंट्री पॉइंट पर एक कूद होता है:

 #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; //    // ELF  uint8_t *entropy_buf = payload + payload_size; //   256- //  void *rsp = argv-1; //     struct AES_ctx ctx; AES_init_ctx_iv(&ctx, entropy_buf, key_seed, iv_seed); //  AES AES_CTR_xcrypt_buffer(&ctx, payload, payload_size); //  ELF memset(&ctx, 0, sizeof(ctx)); //   AES size_t decoded_payload_size; //  ELF char *decoded_payload = huffman_decode((char*)payload, payload_size, &decoded_payload_size); //     ELF  , //   ET_EXEC  NULL. void *load_addr = elf_load_addr(rsp, decoded_payload, decoded_payload_size); load_addr = load_elf(load_addr, decoded_payload); //  ELF  , //    //  . memset(decoded_payload, 0, decoded_payload_size); //   ELF munmap(decoded_payload, decoded_payload_size); //   //    //  ELF     AES AES_init_ctx_iv(&ctx, entropy_buf, key_seed, iv_seed); AES_CTR_xcrypt_buffer(&ctx, payload, payload_size); memset(&ctx, 0, sizeof(ctx)); SET_STACK(rsp); //    JMP(load_addr); //       }

एईएस और विघटित ईएलएफ फ़ाइल की स्थिति को रीसेट करना सुरक्षा उद्देश्यों के लिए किया जाता है - ताकि कुंजी और डिक्रिप्ट किए गए डेटा को केवल उपयोग के समय के लिए मेमोरी में संग्रहीत किया जाए।

आगे कुछ कार्यों के कार्यान्वयन पर विचार किया जाएगा।

load_elf

मैंने इस फ़ंक्शन को अपने यूजरलैंडएक्सec रिपॉजिटरी से उपनाम बेडिगर के साथ जीथब उपयोगकर्ता से लिया और इसे अंतिम रूप दिया, क्योंकि मूल फ़ंक्शन ET_DYN जैसी फ़ाइलों पर क्रैश हो गया। विफलता इस तथ्य के कारण हुई कि एमएमएपी प्रणाली कॉल के पहले तर्क का मूल्य NULL पर सेट किया गया था, और पता मुख्य कार्यक्रम के काफी करीब लौट आया था, बाद में मैमप को कॉल और उनके द्वारा दिए गए पते पर सेगमेंट कॉपी करने के दौरान, मुख्य प्रोग्राम का कोड ओवरराइट किया गया था, और सेगफॉल्ट हुआ। इसलिए, लोडिंग / फ़ंक्शन के पैरामीटर के रूप में शुरुआती पते को जोड़ने का निर्णय लिया गया था। फ़ंक्शन स्वयं सभी प्रोग्राम हेडर के माध्यम से जाता है, एलईएफ फ़ाइल के PT_LOAD सेगमेंट के लिए मेमोरी आवंटित करता है (इसकी संख्या पृष्ठ आकार का एक से अधिक होना चाहिए), आवंटित मेमोरी क्षेत्रों में उनकी सामग्री की प्रतिलिपि बनाता है और इन क्षेत्रों के लिए इसी पढ़ने, लिखने, निष्पादन अधिकार सेट करता है:

 //      #define PAGEUP(x) (((unsigned long)x + 4095)&(~4095)) //      #define PAGEDOWN(x) ((unsigned long)x&(~4095)) void* load_elf(void *load_addr, void *mapped) { Elf64_Ehdr *ehdr = mapped; Elf64_Phdr *phdr = mapped + ehdr->e_phoff; void *text_segment = NULL; unsigned long initial_vaddr = 0; unsigned long brk_addr = 0; for(size_t i = 0; i < ehdr->e_phnum; i++, phdr++) { unsigned long rounded_len, k; void *segment; //   PT_LOAD,    if(phdr->p_type != PT_LOAD) continue; if(text_segment != 0 && ehdr->e_type == ET_DYN) { //  ET_DYN phdr->p_vaddr    , //        //    ,      //     load_addr = text_segment + phdr->p_vaddr - initial_vaddr; load_addr = (void*)PAGEDOWN(load_addr); } else if(ehdr->e_type == ET_EXEC) { //  ET_EXEC phdr->p_vaddr     load_addr = (void*)PAGEDOWN(phdr->p_vaddr); } //        rounded_len = phdr->p_memsz + (phdr->p_vaddr % 4096); rounded_len = PAGEUP(rounded_len); //        segment = mmap(load_addr, rounded_len, PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); if(ehdr->e_type == ET_EXEC) load_addr = (void*)phdr->p_vaddr; else load_addr = segment + (phdr->p_vaddr % 4096); //         memcpy(load_addr, mapped + phdr->p_offset, phdr->p_filesz); if(!text_segment) { text_segment = segment; initial_vaddr = phdr->p_vaddr; } unsigned int protflags = 0; if(phdr->p_flags & PF_R) protflags |= PROT_READ; if(phdr->p_flags & PF_W) protflags |= PROT_WRITE; if(phdr->p_flags & PF_X) protflags |= PROT_EXEC; mprotect(segment, rounded_len, protflags); //   // , ,  k = phdr->p_vaddr + phdr->p_memsz; if(k > brk_addr) brk_addr = k; } if (ehdr->e_type == ET_EXEC) { brk(PAGEUP(brk_addr)); //  ET_EXEC ehdr->e_entry     load_addr = (void*)ehdr->e_entry; } else { //  ET_DYN ehdr->e_entry    , //           load_addr = (void*)ehdr + ehdr->e_entry; } return load_addr; //       }

elf_load_addr

ET_EXEC ELF फ़ाइलों के लिए यह फ़ंक्शन NULL लौटाता है, क्योंकि इस प्रकार की फाइलें उनमें निर्दिष्ट पते पर स्थित होनी चाहिए। ET_DYN फ़ाइलों के लिए, मुख्य कार्यक्रम (यानी, बूटलोडर) के आधार पते के बीच अंतर के बराबर पता, मेमोरी में ELF को रखने के लिए आवश्यक मेमोरी की मात्रा, और 4096, 4096 - अंतराल ताकि मुख्य कार्यक्रम के ठीक बगल में ELF फ़ाइल को रखने के लिए पहले गणना नहीं की जाती है। इस पते की गणना करने के बाद, यह जांचा जाता है कि क्या मेमोरी क्षेत्र अंतरित है, दिए गए पते से मुख्य कार्यक्रम के आधार पते तक, अनपैक्ड ईएलएफ फ़ाइल की शुरुआत से इसके अंत तक का क्षेत्र। चौराहे के मामले में, पते को अनपैक किए गए ईएलएफ के प्रारंभ पते और इसे रखने के लिए आवश्यक मेमोरी की मात्रा के बीच अंतर के बराबर लौटा दिया जाता है, अन्यथा पहले से गणना किए गए पते को वापस कर दिया जाता है।

प्रोग्राम का आधार पता सहायक वेक्टर (ELF सहायक वेक्टर) से प्रोग्राम हेडर का पता निकालकर पाया जाता है, जो स्टैक में पर्यावरण चर के संकेत के बाद स्थित है, और इसके साथ ELF हेडर के आकार को घटाकर:

       ---------------------------------------------------------------------------    -> [ 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 ---------------------------------------------------------------------------

वह संरचना जिसके द्वारा सहायक वेक्टर के प्रत्येक तत्व का वर्णन किया गया है:

 typedef struct { uint64_t a_type; //   union { uint64_t a_val; //  } a_un; } Elf64_auxv_t;

मान्य a_type मानों में से एक AT_PHDR है, a_val तब प्रोग्राम हेडर को इंगित करेगा। निम्नलिखित 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); //    //   while(*envp++); //        Elf64_auxv_t *aux = (Elf64_auxv_t*)envp; //    //  for(; aux->a_type != AT_NULL; aux++) { //        if(aux->a_type == AT_PHDR) { //   ELF ,     //      base_addr = (void*)(aux->a_un.a_val – sizeof(Elf64_Ehdr)); break; } } return base_addr; } size_t elf_memory_size(void *mapped) { Elf64_Ehdr *ehdr = mapped; Elf64_Phdr *phdr = mapped + ehdr->e_phoff; size_t mem_size = 0, segment_len; for(size_t i = 0; i < ehdr->e_phnum; i++, phdr++) { if(phdr->p_type != PT_LOAD) continue; segment_len = phdr->p_memsz + (phdr->p_vaddr % 4096); mem_size += PAGEUP(segment_len); } return mem_size; } void* elf_load_addr(void *rsp, void *mapped, size_t mapped_size) { Elf64_Ehdr *ehdr = mapped; if(ehdr->e_type == ET_EXEC) return NULL; size_t mem_size = elf_memory_size(mapped) + 0x1000; void *load_addr = elf_base_addr(rsp); if(mapped < load_addr && mapped + mapped_size > load_addr - mem_size) load_addr = mapped; return load_addr - mem_size; }

लिंकर स्क्रिप्ट विवरण

उपरोक्त वर्णित बाहरी चर के लिए वर्णों को परिभाषित करना आवश्यक है, और यह भी सुनिश्चित करें कि संकलन के बाद कोड और लोडर डेटा एक ही .text अनुभाग में हैं। फ़ाइल से इस अनुभाग की सामग्री को काटकर लोडर मशीन कोड को आसानी से निकालना आवश्यक है। इन लक्ष्यों को प्राप्त करने के लिए, निम्नलिखित लिंकर स्क्रिप्ट लिखी गई थी:

 ENTRY(_start) SECTIONS { . = 0; .text :{ *(.text) *(.text.startup) *(.data) *(.rodata) payload_size = .; QUAD(0) key_seed = .; QUAD(0) iv_seed = .; QUAD(0) loader_end = .; } }

यह समझाने योग्य है कि QUAD (0) शून्य के 8 बाइट्स रखता है, जिसके बजाय पैकर विशिष्ट मूल्यों को स्थानापन्न करेगा। मशीन कोड को काटने के लिए, एक छोटी सी उपयोगिता लिखी गई थी, जो मशीन कोड की शुरुआत में बूटलोडर की शुरुआत से बूटलोडर में प्रवेश बिंदु की शिफ्ट को लिखता है, बूट लोडर की शुरुआत से पेलोड_साइज, की_एडेड और iv_seed अक्षरों के मूल्यों की भरपाई करता है। इस उपयोगिता का कोड यहाँ उपलब्ध है । यह बूटलोडर विवरण को समाप्त करता है।

सीधे पैकर

पैकर के मुख्य कार्य पर विचार करें। यह दो कमांड लाइन तर्कों का उपयोग करता है: इनपुट फ़ाइल का नाम argv [1] है और आउटपुट फ़ाइल का नाम argv [2] है। सबसे पहले, इनपुट फ़ाइल को मेमोरी में प्रदर्शित किया जाता है और पैकर के साथ संगतता के लिए जाँच की जाती है। पैकर केवल दो प्रकार की ईएलएफ फाइलों के साथ काम करता है: ET_EXEC और ET_DYN, और केवल सांख्यिकीय रूप से संकलित लोगों के साथ। इस प्रतिबंध को शुरू करने का कारण यह था कि विभिन्न लिनक्स प्रणालियों में साझा पुस्तकालयों के विभिन्न संस्करण हैं, अर्थात। संभावना है कि एक गतिशील संकलित कार्यक्रम मूल सिस्टम के अलावा किसी अन्य सिस्टम पर शुरू नहीं होगा। मुख्य फ़ंक्शन में संबंधित कोड:

 size_t mapped_size; void *mapped = map_file(argv[1], &mapped_size); if(check_elf(mapped) < 0) return 1;

उसके बाद, यदि इनपुट फ़ाइल संगतता जांच से गुजरती है, तो यह संपीड़ित है:

 size_t comp_size; uint8_t *comp_buf = huffman_encode(mapped, &comp_size);

अगला, एईएस स्थिति उत्पन्न होती है, और संकुचित ईएलएफ फ़ाइल एन्क्रिप्ट की जाती है। एईएस की स्थिति निम्नलिखित संरचना द्वारा निर्धारित की जाती है:

 #define AES_ENTROPY_BUFSIZE 256 typedef struct { uint8_t entropy_buf[AES_ENTROPY_BUFSIZE]; // 256-  size_t key_seed; //      size_t iv_seed; //       struct AES_ctx ctx; //  AES-CTR } AES_state_t;

मुख्य में कोडिंग:

 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);

उसके बाद, बूटलोडर के बारे में जानकारी संग्रहीत करने वाली संरचना को इनिशियलाइज़ किया जाता है, बूटलोडर में पेलोड_साइज़, की_सेड और iv_seed वैल्यू को पिछले चरण में उत्पन्न उन लोगों में बदल दिया जाता है, जिसके बाद एईएस स्टेट रीसेट हो जाता है। बूटलोडर के बारे में जानकारी निम्नलिखित संरचना में संग्रहीत है:

 typedef struct { char *loader_begin; //      size_t entry_offset; //       size_t *payload_size_patch_offset; //     // ELF    size_t *key_seed_pacth_offset; //     //       size_t *iv_seed_patch_offset; //     //     //    size_t loader_size; //     } loader_t;

मुख्य में कोडिंग:

 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));

अंतिम भाग में, हम एक आउटपुट फाइल बनाते हैं, जिसमें एक ईएलएफ हेडर, एक प्रोग्राम हेडर, एक लोडर कोड, एक संपीड़ित और एन्क्रिप्टेड ईएलएफ फाइल और एक 256 बाइट बफर लिखते हैं:

 int out_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0755); //  //   write_elf_ehdr(out_fd, &loader); //  ELF  write_elf_phdr(out_fd, &loader, comp_size); //    write(out_fd, loader.loader_begin, loader.loader_size); //   write(out_fd, comp_buf, comp_size); //     ELF write(out_fd, aes_st.entropy_buf, AES_ENTROPY_BUFSIZE); //  // 256-

पैकर का मुख्य कोड यहां समाप्त होता है, फिर निम्नलिखित कार्यों पर विचार किया जाएगा: बूटलोडर के बारे में प्रारंभिक जानकारी का कार्य, ईएलएफ हेडर लिखने का कार्य और प्रोग्राम हेडर लिखने का कार्य।

आरंभिक बूटलोडर जानकारी

लोडर मशीन कोड नीचे दिए गए सरल कोड का उपयोग करके पैकर निष्पादन योग्य में एम्बेडेड है:

 .data .globl _loader_begin .globl _loader_end _loader_begin: .incbin "loader" _loader_end:

स्मृति में इसका पता निर्धारित करने के लिए, मुख्य चर फ़ाइल में निम्नलिखित चर घोषित किए गए हैं:

 extern void* _loader_begin; extern void* _loader_end;

अगला, init_loader फ़ंक्शन पर विचार करें। सबसे पहले, निम्नलिखित मानों को क्रमिक रूप से इसमें पढ़ा जाता है: बूटलोडर (एंट्री_ऑफसेट) की शुरुआत से प्रवेश बिंदु की भरपाई, बूटलोडर (पेलोड। Size_patch_offset) की शुरुआत से लोड किए गए ELF फ़ाइल के आकार की पारी, बूटलोडर की शुरुआत से कुंजी के लिए जनरेटर के प्रारंभिक मूल्य की पारी। बूटलोडर (iv_seed_patch_offset) की शुरुआत से। फिर, लोडर पते को अंतिम तीन मानों में जोड़ा जाता है, इसलिए जब बिंदुओं को संदर्भित करते हुए और उन्हें मान निर्दिष्ट करते हैं, तो हम उन लेआउट चरणों (QUAD (0)) में निर्दिष्ट शून्य को प्रतिस्थापित करेंगे जिनकी हमें आवश्यकता है।

 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) { //  ELF  Elf64_Ehdr ehdr; memset(ehdr.e_ident, 0, sizeof(ehdr.e_ident)); memcpy(ehdr.e_ident, ELFMAG, SELFMAG); ehdr.e_ident[EI_CLASS] = ELFCLASS64; ehdr.e_ident[EI_DATA] = ELFDATA2LSB; ehdr.e_ident[EI_VERSION] = EV_CURRENT; ehdr.e_ident[EI_OSABI] = ELFOSABI_NONE; ehdr.e_type = ET_DYN; ehdr.e_machine = EM_X86_64; ehdr.e_version = EV_CURRENT; ehdr.e_entry = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) + loader->entry_offset; ehdr.e_phoff = sizeof(Elf64_Ehdr); ehdr.e_shoff = 0; ehdr.e_flags = 0; ehdr.e_ehsize = sizeof(Elf64_Ehdr); ehdr.e_phentsize = sizeof(Elf64_Phdr); ehdr.e_phnum = 1; ehdr.e_shentsize = sizeof(Elf64_Shdr); ehdr.e_shnum = 0; ehdr.e_shstrndx = 0; write(fd, &ehdr, sizeof(ehdr)); //     return 0; }

यहां ईएलएफ हेडर का मानक इनिशियलाइज़ेशन होता है और एक फ़ाइल के लिए उसके बाद के लेखन में, केवल एक चीज जो ध्यान देने योग्य है वह यह है कि ET_DYN ELF फ़ाइलों में पहले प्रोग्राम हेडर द्वारा वर्णित सेगमेंट में न केवल निष्पादन योग्य कोड, बल्कि ईएलएफ हेडर और सभी हेडर भी शामिल हैं। कार्यक्रम। इसलिए, इसकी शुरुआत से ऑफसेट शून्य के बराबर होना चाहिए, आकार ईएलएफ हेडर, सभी प्रोग्राम हेडर और निष्पादन योग्य कोड के आकार का योग होना चाहिए, और प्रवेश बिंदु ईएलएफ हेडर के आकार के योग के रूप में निर्धारित किया जाता है, सभी प्रोग्राम हेडर का आकार और निष्पादन योग्य कोड की शुरुआत से ऑफसेट।

write_elf_phdr

 void write_elf_phdr(int fd, loader_t *loader, size_t payload_size) { //    Elf64_Phdr phdr; phdr.p_type = PT_LOAD; phdr.p_offset = 0; phdr.p_vaddr = 0; phdr.p_paddr = 0; phdr.p_filesz = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) + loader->loader_size + payload_size + AES_ENTROPY_BUFSIZE; phdr.p_memsz = phdr.p_filesz; phdr.p_flags = PF_R | PF_W | PF_X; phdr.p_align = 0x1000; write(fd, &phdr, sizeof(phdr)); //      }

यहां, प्रोग्राम हेडर को इनिशियलाइज़ किया जाता है और फिर एक फाइल पर लिखा जाता है। आपको फ़ाइल की शुरुआत और प्रोग्राम हेडर द्वारा वर्णित सेगमेंट के आकार के सापेक्ष ऑफसेट पर ध्यान देना चाहिए। जैसा कि पिछले पैराग्राफ में वर्णित है, इस हेडर द्वारा वर्णित सेगमेंट में न केवल निष्पादन योग्य कोड, बल्कि ईएलएफ हेडर और प्रोग्राम हेडर भी शामिल हैं। हम लेखन के लिए निष्पादन योग्य कोड के साथ सेगमेंट को भी सुलभ बनाते हैं, यह इस तथ्य के कारण है कि बूटलोडर में उपयोग किए गए एईएस कार्यान्वयन "जगह में" डेटा को एन्क्रिप्ट और डिक्रिप्ट करता है।

पैकर के काम के बारे में कुछ तथ्य

परीक्षण के दौरान, यह देखा गया कि इस निर्देश पर शुरू होने पर glibc के साथ संकलित कार्यक्रम सीगफॉल्ट में जाते हैं:

  movq% fs: 0x28,% rax

मुझे पता नहीं चला कि ऐसा क्यों होता है, मुझे खुशी होगी अगर आप इस विषय पर जानकारी साझा करेंगे। Glibc के बजाय, आप musl-libc का उपयोग कर सकते हैं, सब कुछ बिना असफलता के साथ काम करता है। इसके अलावा, पैकर को सांख्यिकीय रूप से संकलित गोलंग कार्यक्रमों के साथ परीक्षण किया गया था, उदाहरण के लिए, एक http सर्वर। गोलंग कार्यक्रमों की पूर्ण स्थिर दुर्घटनाओं के लिए, निम्नलिखित झंडे का उपयोग किया जाना चाहिए:

  CGO_ENABLED = 0 go -a -ldflags '-extldflags "-static"' जाओ।

डायनामिक लिंकर के बिना ET_DYN ELF फ़ाइलों के साथ पैकर का परीक्षण किया गया था। सच है, इन फ़ाइलों के साथ काम करते समय, elf_load_addr फ़ंक्शन विफल हो सकता है। व्यवहार में, इसे बूटलोडर से काटा जा सकता है और एक निश्चित पते का उपयोग कर सकते हैं, उदाहरण के लिए 0x10000।

निष्कर्ष

यह पैकर, जाहिर है, अपने इच्छित उद्देश्य के लिए उपयोग करने के लिए समझ में नहीं आता है, क्योंकि इसके द्वारा संरक्षित फाइलें आसानी से डिक्रिप्टेड हैं। इस परियोजना का उद्देश्य ईएलएफ फाइलों के साथ काम करने वाले बेहतर मास्टर थे, उन्हें उत्पन्न करने का अभ्यास, साथ ही अधिक पूर्ण पैकर के निर्माण की तैयारी करना।

Linux के लिए x86_64 ELF फ़ाइल पैकर बनाना