ELF प्रारूप में न्यूनतम कार्यक्रम

नमस्कार मुक्त-मुक्त दुनिया के लेख हैलो से प्रेरित होकर, मैंने भी कुछ ऐसा ही करने का फैसला किया। ऐसा लक्ष्यहीन रूप से नहीं करने के लिए, मैंने खुद को निम्न कार्य निर्धारित करने का निर्णय लिया। एक प्रोग्राम बनाएं जो कुछ सरल स्ट्रिंग प्रिंट करता है, जैसे "ईएलएफ, हैलो!"। समझें कि इसे निष्पादन योग्य फ़ाइल में कैसे दर्शाया जाएगा। वैसे, 100 बाइट्स के भीतर रखने की कोशिश करें।

शुरुआत के लिए, सी ++ में मानक हेलोवर्ल्ड

#include <iostream> using namespace std; int main() { cout << "ELF, hello!\n"; return 0; } 

संकलित करें, आकार देखें:

 $ g++ test.cpp -static && ls -s -h a.out 1,3M a.out 

कितना, कितना? 1.3 एमबी? 12 बाइट्स के एक संदेश को आउटपुट करने के लिए? हम्म ... ठीक है, चलो सी की कोशिश करते हैं।

 #include "stdio.h" int main() { printf("ELF, hello!\n"); return 0; } 

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

 $ gcc test.c -static && ls -s -h a.out 568K a.out 

आधा मेगाबाइट कम। यहाँ यह एसटीएल के लिए भुगतान करना है। लेकिन, अभी भी बहुत कुछ। जाहिर है, कोडांतरक के रूप में भारी तोपखाने अपरिहार्य है। हम asm पर helloworld लिखते हैं, और stdlib के बिना। मैं एटी एंड टी सिंटैक्स पसंद करता हूं।

 .data str: .ascii "ELF, hello!" .byte 10 .text .global _start _start: movl $4, %eax movl $1, %ebx movl $str, %ecx movl $12, %edx int $0x80 movl $1, %eax movl $0, %ebx int $0x80 

डेटा अनुभाग में दो खंड - हमारा संदेश (और एक नई पंक्ति में अनुवाद करने के लिए 10), कोड अनुभाग (.text) में - हम संदेश को प्रदर्शित करने के लिए पहली बार 80 वें व्यवधान को दो बार (रजिस्टरों में आवश्यक मापदंडों के साथ) कहते हैं। सही समापन के लिए दूसरी बार।

हम बनाए गए प्रोग्राम को संकलित (या अनुवाद और लिंक) करते हैं:

 $ gcc easy.s -nostdlib && du -sb a.out 752 a.out 

752 बाइट्स - यह पहले से ही बहुत करीब है जो आवश्यक है। पट्टी उपयोगिता के साथ डिबगिंग प्रतीकों को निकालें:

 $ strip a.out && du -sb a.out 476 a.out 

बेहतर है, लेकिन अभी भी पर्याप्त नहीं है। 476 बाइट के लिए हमारी फ़ाइल में क्या है? Objdump का प्रयोग करके

 $ objdump -D a.out a.out: file format elf32-i386 Disassembly of section .note.gnu.build-id: 08048094 <.note.gnu.build-id>: 8048094: 04 00 add $0x0,%al ... - ,     ... 80480b6: b6 08 mov $0x8,%dh Disassembly of section .text: 080480b8 <.text>: 80480b8: b8 04 00 00 00 mov $0x4,%eax 80480bd: bb 01 00 00 00 mov $0x1,%ebx 80480c2: b9 dc 90 04 08 mov $0x80490dc,%ecx 80480c7: ba 0c 00 00 00 mov $0xc,%edx 80480cc: cd 80 int $0x80 80480ce: b8 01 00 00 00 mov $0x1,%eax 80480d3: bb 00 00 00 00 mov $0x0,%ebx 80480d8: cd 80 int $0x80 Disassembly of section .data: 080490dc <.data>: 80490dc: 45 inc %ebp 80490dd: 4c dec %esp 80490de: 46 inc %esi 80490df: 2c 20 sub $0x20,%al 80490e1: 68 65 6c 6c 6f push $0x6f6c6c65 80490e6: 21 0a and %ecx,(%edx) 

और इसलिए, हम तीन खंड देखते हैं, हालांकि केवल दो ही लिखे गए थे। .Text सेक्शन में हमारा कोड है। डेटा अनुभाग में - 12 बाइट्स के रूप में हमारे योगिनी हैलो (objdump भी उन्हें disassembled)। और क्या है .note.gnu.build-id अनुभाग? हमने इसे ऑर्डर नहीं किया, इसलिए हम साहसपूर्वक इसे हटा देते हैं:

 $ strip -R .note.gnu.build-id a.out && du -sb a.out 416 a.out 

एक और 60 बाइट जीती। बुरा नहीं है। आइए हमारे कोड को थोड़ा अनुकूलित करने का प्रयास करें। सबसे पहले, एक कार्यक्रम, सिद्धांत रूप में, किसी भी कोड के साथ समाप्त हो सकता है, और जरूरी नहीं कि शून्य के साथ। दूसरे, जब प्रोग्राम शुरू होता है, रजिस्टर रीसेट हो जाते हैं (हालांकि, आपको वास्तविक प्रोग्राम बनाते समय इस पर भरोसा नहीं करना चाहिए - उस सिस्टम के एबीआई की जांच करें जिसके लिए आप लिख रहे हैं)।
नतीजतन, Movl $ 4,% eax के बजाय, जो 5 बाइट्स में अनुवाद करता है, हम movb $ 4,% al का उपयोग कर सकते हैं, जो 2 बाइट्स में अनुवाद करता है। तीसरा, हम अंतिम व्यवधान के बाद कोड में अपनी लाइन डालकर, .data सेक्शन से छुटकारा पा लेंगे (वैसे भी, प्रोग्राम आगे निष्पादित नहीं करता है):

 .text .global _start _start: movb $4, %al movb $1, %bl movl $str, %ecx movb $12, %dl int $0x80 movb $1, %al int $0x80 str: .ascii "ELF, hello!" .byte 10 

संकलित करें, अतिरिक्त हटाएं, आकार देखें:

 $ gcc -nostdlib easy.s $ strip a.out $ strip -R .note.gnu.build-id a.out $ du -sb a.out 320 a.out 

लगता है हम हद तक पहुंच गए हैं। 320 बाइट्स - अधिक कुछ नहीं। या नहीं? ये 320 बाइट्स कहां से आते हैं? हमारा कोड स्पष्ट रूप से कम है। हालांकि, कोड के अलावा, हमारे बाइनरी में एक ईएलएफ हेडर भी है। और अगर हम वास्तव में न्यूनतम कार्यक्रम बनाना चाहते हैं, तो हमें ईएलएफ विवरण (उदाहरण के लिए, यहां ) खोलना होगा, और हेडर को मैन्युअल रूप से बनाना होगा।

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

  .set ofs, 0x10000 /* ofs -    */ /* ELF : */ .byte 0x7F .ascii "ELF" .long 0, 0, 0 /* ident */ .word 2 /* type */ .word 3 /* machine */ .long 0 /* version */ .long _start + ofs /* entry -    () */ .long phdr /* phoff -    (phdr) ( ) */ .long 0 /* shoff */ .long 0 /* flags */ .word 0 /* ehsize -  elf  */ .word phdrsize /* phentsize -  .  */ .word 1 /* phnum -  . . */ .word 0 /* shentsize */ .word 0 /* shnum */ .word 0 /* e_shstrndx */ /*   */ phdr: .long 1 /* type */ .long 0 /* offset */ .long ofs /* vaddr -      (  ) */ .long 0 /* paddr */ .long filesize /* filesz -     */ .long filesize /* memsz -     */ .long 5 /* pflags */ .long 0 /* palign */ .set phdrsize, . - phdr _start: /*   */ movb $4, %al movb $1, %bl movl $(str+ofs), %ecx movb $12, %dl int $0x80 movb $1, %al int $0x80 str: .ascii "ELF, hello!" .byte 10 .set filesize, . 

अब हमें प्रोग्राम ऑफ़सेट के साथ मैन्युअल रूप से काम करना होगा। सरलीकृत, ऑफ़सेट द्वारा हम कोड के बीच के पते में अंतर को समझ सकते हैं जो हमारे कार्यक्रम में निहित है और जहां यह रैम में स्थित होगा (वास्तव में, रैम में यह बिल्कुल भी नहीं होगा, लेकिन यह एक और कहानी है)। आमतौर पर लिंकर आवश्यक विस्थापन का निर्धारण करने में लगा हुआ है, लेकिन अब हम अपने दम पर हैं। मैंने ऑफ़स पैरामीटर के ऑफसेट को रखा। ऑफसेट आकार ने मेरी कार (10,000) पर सबसे कम संभव लिया। डिफ़ॉल्ट रूप से, यह 8048000 है, लेकिन यह कोई शर्त नहीं है।

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

हमने कार्यक्रम प्रसारित किया, इस बार मैन्युअल रूप से कॉल कर रहा है और ld:

 $ as w3test.s -o w3test.o $ ld -Ttext 0 --oformat binary -o w3test w3test.o $ du -sb w3test 115 w3test 

115 बाइट्स! ~ मूल संस्करण की तुलना में 10,000 गुना छोटा। सब कुछ प्रतीत होगा। चलाने के लिए केवल न्यूनतम आवश्यक है, और अधिक कुछ नहीं। और 100 बाइट्स को पार करने का प्रारंभिक कार्य विफल हो जाएगा। हालाँकि, यह सीमा नहीं है! हेडर में अप्रयुक्त बाइट्स हैं, जिसका अर्थ है कि हम उन्हें अपने उद्देश्यों के लिए उपयोग कर सकते हैं। दुर्भाग्य से, कोड स्वयं किसी भी क्षेत्र में फिट नहीं होगा, यह बहुत बड़ा है। लेकिन लाइन फिट होगी।

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

इसके अलावा, हम पीएचडी हेडर को एल्फ के बाद नहीं रखकर कोड को छोटा कर सकते हैं, लेकिन एलएलएफ में इस्तेमाल होने वाले अंतिम बाइट के तुरंत बाद। यही है, पीएच हेडर को एल्फ पर थोड़ा स्तरित किया जाएगा, लेकिन इससे कोई परिणाम नहीं होगा, क्योंकि जो फ़ील्ड लेयर्ड हैं उनका उपयोग एल्फ में नहीं किया जाता है।
उसी तरह, हम अपने प्रोग्राम "लेयरिंग" को phd हेडर (उसी कारणों के लिए) पर रख सकते हैं।

परिणाम निम्नलिखित कोड है:

  .set ofs, 0x10000 /* ofs -    */ /* ELF : 8*/ .byte 0x7F str: .ascii "ELF" .ascii ", hello!" .byte 10, 0, 0, 0 .word 2 /* type */ .word 3 /* machine */ .long 0 /* version */ .long _start+ofs /* entry -    () */ .long phdr /* phoff -    (phdr) ( ) */ .long 0 /* shoff */ .long 0 /* flags */ .word 0 /* ehsize -  elf  */ .word phdrsize /* phentsize -  .  */ /*   */ phdr: .long 1 /* type */ .long 0 /* offset */ .long ofs /* vaddr -      (  ) */ .long 0 /* paddr */ .long filesize /* filesz -     */ .long filesize /* memsz -     */ .long 5 /* pflags */ .set phdrsize, . - phdr + 4 _start: /*   */ movb $4, %al movb $1, %bl movl $(str+ofs), %ecx movb $12, %dl int $0x80 movb $1, %al int $0x80 .set filesize, . 

प्रसारण के बाद, हमें आकार में 89 बाइट्स का एक कार्यक्रम मिलता है। आप कार्य पूरा होने पर विचार कर सकते हैं।

अनुकूलन के लिए एक विचार भी था - एल्फ हेडर के अंदर पीएच हेडर को पुश करने के लिए। लेकिन यह विचार विफल हो गया, क्योंकि 10,000 के न्यूनतम विस्थापन ने किसी को इस तरह के मापदंडों को चुनने की अनुमति नहीं दी ताकि संरचनाओं के आवश्यक क्षेत्रों का संयोग हो।

PS टिप्पणियों में, 61 बाइट्स के आकार के साथ एक और भी अधिक अनुकूलित विकल्प प्रस्तावित किया गया था, जिसमें योगिनी पर phd को सुपरइम्पोज़ करना संभव था। -F बिन विकल्प के साथ nasm / yasm का उपयोग करके संकलित।

 BITS 32; ORG 05430000h; DB 0x7F, "ELF"; DD 01h, 00h, $$; DW 02h, 03h; DD @main; DW @main - $$; @main: INC EBX; DB 05h; <-- ADD EAX, DD 04h; <-- LONG(04h) MOV ECX, @text; MOV DL, 12; INT 80h; AND EAX, 00010020h; XCHG EAX, EBX; INT 80h; @text: DB "ELF, hello!", 0Ah; 

जानकारी के स्रोत

wikibooks.org - सी प्रोग्रामर के लिए लिनक्स पर असेंबलर
stackoverflow.com - 20 से कम बाइट्स में "हैलो वर्ल्ड"
muppetlabs.com - लिनक्स के लिए टेनेसी ईएलएफ एक्सेल्यूबल्स