रूसी में, एलएलएफ फाइलों के साथ काम करने के बारे में पर्याप्त जानकारी नहीं है (निष्पादन योग्य और लिंक करने योग्य प्रारूप - लिनक्स और कई यूनिक्स प्रणालियों की निष्पादन योग्य फ़ाइलों के लिए मुख्य प्रारूप)। हम कल्पित बौने के साथ काम करने के सभी संभावित परिदृश्यों को पूरी तरह से कवर करने का दावा नहीं करते हैं, लेकिन हमें उम्मीद है कि जानकारी संदर्भ पुस्तक और प्रोग्रामर और रिवर्स इंजीनियरों के लिए व्यंजनों के संग्रह के रूप में उपयोगी होगी।

यह समझा जाता है कि बुनियादी स्तर पर पाठक ईएलएफ प्रारूप से परिचित है (अन्यथा, हम लेखों की श्रृंखला निष्पादन योग्य और लिंक करने योग्य प्रारूप 101 की अनुशंसा करते हैं)।

कट के तहत काम के लिए उपकरण सूचीबद्ध किए जाएंगे, मेटा-सूचना पढ़ने के लिए वर्णित तकनीकों, संशोधन, सत्यापन और ~~प्रजनन~~ कल्पित बौने, साथ ही उपयोगी सामग्रियों के लिंक बनाना।

"मैं भी एक योगिनी हूँ ... लाल रंग में नीला ... बहुत लाल रोगी हैं ... लाल रंग में नीला ... और हम लाल हैं ... लाल रंग में नीला ... जादू से केवल परेशानियाँ हैं ...
(c) बेन और होली के लिटिल किंगडम

उपकरण

ज्यादातर मामलों में, उदाहरण लिनक्स और विंडोज दोनों पर चलाए जा सकते हैं।

व्यंजनों में हम निम्नलिखित उपकरणों का उपयोग करेंगे:

बिन्यूटिल्स सेट (objcopy, objdump, readelf, strip) से उपयोगिताओं;
radare2 ढांचा ;
फ़ाइल टेम्पलेट्स के लिए समर्थन के साथ हेक्स संपादक (उदाहरण 010Editor दिखाते हैं, लेकिन आप उपयोग कर सकते हैं, उदाहरण के लिए, फ्री वेलेस );
पायथन और LIEF पुस्तकालय;
अन्य उपयोगिताओं (लिंक नुस्खा में हैं)।

टेस्ट कल्पित बौने

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

लिंक पर मुफ्त कल्पित बौने भी मिल सकते हैं:

विभिन्न प्लेटफार्मों के लिए कल्पित बौने के उदाहरण ;
रडार 2 के लिए परीक्षण कल्पित बौने ;
जीथब पर एल्फहैक्स परियोजना - विभिन्न सेटिंग्स के साथ छोटे कल्पित बौने का चयन;
यूनिक्स / लिनक्स के लिए दरार - लेकिन ध्यान रखें कि मुश्किल नमूने यहां आ सकते हैं।

पढ़ना, जानकारी प्राप्त करना

फ़ाइल प्रकार, शीर्षक, अनुभाग

कार्य के आधार पर, निम्नलिखित ब्याज की हो सकती है:

फ़ाइल प्रकार (डायन - पुस्तकालय, EXEC - निष्पादन योग्य, RELOC - लिंकेबल);
लक्ष्य वास्तुकला (E_MACHINE - x86_64, x86, ARM, आदि);
आवेदन प्रविष्टि बिंदु (एंट्री पॉइंट);
अनुभाग की जानकारी।

010Editor

HEX संपादक 010Editor एक टेम्पलेट सिस्टम प्रदान करता है। ELF फ़ाइलों के लिए, टेम्प्लेट को कहा जाता है, विचित्र रूप से पर्याप्त है, ELF.bt और निष्पादन योग्य श्रेणी (मेनू टेम्प्लेट - निष्पादन योग्य) में स्थित है।
उदाहरण के लिए, निष्पादन योग्य फ़ाइल में प्रवेश बिंदु (प्रविष्टि बिंदु) (फ़ाइल शीर्षलेख में दर्ज) हो सकता है।

readelf

पढ़ने योग्य उपयोगिता को ईएलएफ फ़ाइल के बारे में जानकारी प्राप्त करने के लिए वास्तविक मानक माना जा सकता है।

फ़ाइल हेडर पढ़ें:
```
$ readelf -h simple 
```

टीम का परिणाम

 ELF Header: Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 Class: ELF64 Data: 2's complement, little endian Version: 1 (current) OS/ABI: UNIX - System V ABI Version: 0 Type: DYN (Shared object file) Machine: Advanced Micro Devices X86-64 Version: 0x1 Entry point address: 0x1070 Start of program headers: 64 (bytes into file) Start of section headers: 14800 (bytes into file) Flags: 0x0 Size of this header: 64 (bytes) Size of program headers: 56 (bytes) Number of program headers: 11 Size of section headers: 64 (bytes) Number of section headers: 30 Section header string table index: 29

खंडों और वर्गों के बारे में जानकारी पढ़ें:
```
 $ readelf -l -W simple 
```

टीम का परिणाम

पठनीयता के लिए, पते 32-बिट प्रारूप में परिवर्तित हो जाते हैं:

 Elf file type is DYN (Shared object file) Entry point 0x1070 There are 11 program headers, starting at offset 64 Program Headers: Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align PHDR 0x000040 0x00000040 0x00000040 0x000268 0x000268 R 0x8 INTERP 0x0002a8 0x000002a8 0x000002a8 0x00001c 0x00001c R 0x1 [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2] LOAD 0x000000 0x00000000 0x00000000 0x0005f8 0x0005f8 R 0x1000 LOAD 0x001000 0x00001000 0x00001000 0x00026d 0x00026d RE 0x1000 LOAD 0x002000 0x00002000 0x00002000 0x0001b8 0x0001b8 R 0x1000 LOAD 0x002de8 0x00003de8 0x00003de8 0x000258 0x000260 RW 0x1000 DYNAMIC 0x002df8 0x00003df8 0x00003df8 0x0001e0 0x0001e0 RW 0x8 NOTE 0x0002c4 0x000002c4 0x000002c4 0x000044 0x000044 R 0x4 GNU_EH_FRAME 0x002070 0x00002070 0x00002070 0x00003c 0x00003c R 0x4 GNU_STACK 0x000000 0x00000000 0x00000000 0x000000 0x000000 RW 0x10 GNU_RELRO 0x002de8 0x00003de8 0x00003de8 0x000218 0x000218 R 0x1 Section to Segment mapping: Segment Sections... 00 01 .interp 02 .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt 03 .init .plt .plt.got .text .fini 04 .rodata .eh_frame_hdr .eh_frame 05 .init_array .fini_array .dynamic .got .got.plt .data .bss 06 .dynamic 07 .note.ABI-tag .note.gnu.build-id 08 .eh_frame_hdr 09 10 .init_array .fini_array .dynamic .got

अनुभाग जानकारी पढ़ें:
```
 $ readelf -S -W simple 
```

टीम का परिणाम

पठनीयता के लिए, पते 32-बिट प्रारूप में परिवर्तित हो जाते हैं:

 There are 30 section headers, starting at offset 0x39d0: Section Headers: [Nr] Name Type Address Off Size ES Flg Lk Inf Al [ 0] NULL 00000000 000000 000000 00 0 0 0 [ 1] .interp PROGBITS 000002a8 0002a8 00001c 00 A 0 0 1 [ 2] .note.ABI-tag NOTE 000002c4 0002c4 000020 00 A 0 0 4 [ 3] .note.gnu.build-id NOTE 000002e4 0002e4 000024 00 A 0 0 4 [ 4] .gnu.hash GNU_HASH 00000308 000308 000024 00 A 5 0 8 [ 5] .dynsym DYNSYM 00000330 000330 0000d8 18 A 6 1 8 [ 6] .dynstr STRTAB 00000408 000408 0000a2 00 A 0 0 1 [ 7] .gnu.version VERSYM 000004aa 0004aa 000012 02 A 5 0 2 [ 8] .gnu.version_r VERNEED 000004c0 0004c0 000030 00 A 6 1 8 [ 9] .rela.dyn RELA 000004f0 0004f0 0000c0 18 A 5 0 8 [10] .rela.plt RELA 000005b0 0005b0 000048 18 AI 5 23 8 [11] .init PROGBITS 00001000 001000 000017 00 AX 0 0 4 [12] .plt PROGBITS 00001020 001020 000040 10 AX 0 0 16 [13] .plt.got PROGBITS 00001060 001060 000008 08 AX 0 0 8 [14] .text PROGBITS 00001070 001070 0001f2 00 AX 0 0 16 [15] .fini PROGBITS 00001264 001264 000009 00 AX 0 0 4 [16] .rodata PROGBITS 00002000 002000 000070 00 A 0 0 8 [17] .eh_frame_hdr PROGBITS 00002070 002070 00003c 00 A 0 0 4 [18] .eh_frame PROGBITS 000020b0 0020b0 000108 00 A 0 0 8 [19] .init_array INIT_ARRAY 00003de8 002de8 000008 08 WA 0 0 8 [20] .fini_array FINI_ARRAY 00003df0 002df0 000008 08 WA 0 0 8 [21] .dynamic DYNAMIC 00003df8 002df8 0001e0 10 WA 6 0 8 [22] .got PROGBITS 00003fd8 002fd8 000028 08 WA 0 0 8 [23] .got.plt PROGBITS 00004000 003000 000030 08 WA 0 0 8 [24] .data PROGBITS 00004030 003030 000010 00 WA 0 0 8 [25] .bss NOBITS 00004040 003040 000008 00 WA 0 0 1 [26] .comment PROGBITS 00000000 003040 00001c 01 MS 0 0 1 [27] .symtab SYMTAB 00000000 003060 000630 18 28 44 8 [28] .strtab STRTAB 00000000 003690 000232 00 0 0 1 [29] .shstrtab STRTAB 00000000 0038c2 000107 00 0 0 1 Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings), l (large) I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown) O (extra OS processing required) o (OS specific), p (processor specific)

पढ़ें प्रतीक सूचना:
```
 $ readelf -s -W simple 
```

टीम का परिणाम

आउटपुट पठनीयता के लिए छोटा है:

 Symbol table '.dynsym' contains 9 entries: Num: Value Size Type Bind Vis Ndx Name 0: 00000000 0 NOTYPE LOCAL DEFAULT UND 1: 00000000 0 NOTYPE WEAK DEFAULT UND _ITM_deregisterTMCloneTable 2: 00000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.2.5 (2) 3: 00000000 0 FUNC GLOBAL DEFAULT UND printf@GLIBC_2.2.5 (2) 4: 00000000 0 FUNC GLOBAL DEFAULT UND __libc_start_main@GLIBC_2.2.5 (2) 5: 00000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__ 6: 00000000 0 FUNC GLOBAL DEFAULT UND __isoc99_scanf@GLIBC_2.7 (3) 7: 00000000 0 NOTYPE WEAK DEFAULT UND _ITM_registerTMCloneTable 8: 00000000 0 FUNC WEAK DEFAULT UND __cxa_finalize@GLIBC_2.2.5 (2) Symbol table '.symtab' contains 66 entries: Num: Value Size Type Bind Vis Ndx Name 0: 00000000 0 NOTYPE LOCAL DEFAULT UND 1: 000002a8 0 SECTION LOCAL DEFAULT 1 2: 000002c4 0 SECTION LOCAL DEFAULT 2 3: 000002e4 0 SECTION LOCAL DEFAULT 3 4: 00000308 0 SECTION LOCAL DEFAULT 4 5: 00000330 0 SECTION LOCAL DEFAULT 5 6: 00000408 0 SECTION LOCAL DEFAULT 6 7: 000004aa 0 SECTION LOCAL DEFAULT 7 .... 26: 00000000 0 SECTION LOCAL DEFAULT 26 27: 00000000 0 FILE LOCAL DEFAULT ABS crtstuff.c 28: 000010a0 0 FUNC LOCAL DEFAULT 14 deregister_tm_clones 29: 000010d0 0 FUNC LOCAL DEFAULT 14 register_tm_clones 30: 00001110 0 FUNC LOCAL DEFAULT 14 __do_global_dtors_aux 31: 00004040 1 OBJECT LOCAL DEFAULT 25 completed.7389 ....

कंसोल आउटपुट (डिफ़ॉल्ट, 80 वर्ण) की चौड़ाई बढ़ाने के लिए -W विकल्प की आवश्यकता होती है।

राहत

आप पायथन कोड और LIEF लाइब्रेरी का उपयोग करके हेडर और सेक्शन की जानकारी पढ़ सकते हैं (केवल पायथन के लिए एक एपीआई प्रदान करता है):

 import lief binary = lief.parse("simple.elf") header = binary.header print("Entry point: %08x" % header.entrypoint) print("Architecture: ", header.machine_type) for section in binary.sections: print("Section %s - size: %s bytes" % (section.name, section.size)

संकलक जानकारी

कंपाइलर और बिल्ड की जानकारी के लिए, .comment और .note ।

objdump

 $ objdump -s --section .comment simple

टीम का परिणाम

 simple: file format elf64-x86-64 Contents of section .comment: 0000 4743433a 20284465 6269616e 20382e32 GCC: (Debian 8.2 0010 2e302d39 2920382e 322e3000 .0-9) 8.2.0.

readelf

 $ readelf -p .comment simple

टीम का परिणाम

 String dump of section '.comment': [ 0] GCC: (Debian 8.2.0-9) 8.2.0

 $ readelf -n simple

टीम का परिणाम

 Displaying notes found at file offset 0x000002c4 with length 0x00000020: Owner Data size Description GNU 0x00000010 NT_GNU_ABI_TAG (ABI version tag) OS: Linux, ABI: 3.2.0 Displaying notes found at file offset 0x000002e4 with length 0x00000024: Owner Data size Description GNU 0x00000014 NT_GNU_BUILD_ID (unique build ID bitstring) Build ID: dae0509e4edb79719a65af37962b74e4cf2a8c2e

राहत

 import lief binary = lief.parse("simple") comment = binary.get_section(".comment") print("Comment: ", bytes(comment.content))

मैं आपके द्वारा गणना करूँगा ... RPATH

कल्पित रूप से जुड़े पुस्तकालयों को खोजने के लिए कल्पित पथ को बचा सकता है। एप्लिकेशन शुरू करने से पहले सिस्टम वेरिएबल LD_LIBRARY_PATH को सेट नहीं करने के लिए, आप बस इस पथ को ELF फ़ाइल में "एम्बेड" कर सकते हैं।

ऐसा करने के लिए, DT_RPATH या DT_RUNPATH के प्रकार के साथ .dynamic अनुभाग में प्रविष्टि का उपयोग करें (प्रलेखन में रनटाइम लिंकर अध्याय द्वारा खोजे गए निर्देशिकाएँ देखें)।

और सावधान रहें, युवा डेवलपर, अपनी परियोजना निर्देशिका को "नींद" न करें!

RPATH कैसे प्रकट होता है?

योगिनी में RPATH रिकॉर्ड की उपस्थिति का मुख्य कारण डायनेमिक लाइब्रेरी की खोज करने के लिए लिंकर -rpath विकल्प है। कुछ इस तरह:

 $ gcc -L./lib -Wall -Wl,-rpath=/run/media/pablo/disk1/projects/cheat_sheets/ELF/lib/ -o test_rpath.elf bubble_main.c -lbubble

इस तरह का कमांड मूल्य /run/media/pablo/disk1/projects/cheat_sheets/ELF/lib/ साथ .dynamic सेक्शन में एक RPATH रिकॉर्ड बनाएगा।

readelf

आप .dynamic अनुभाग (जिसमें आरपीएटीएच है) से तत्वों को निम्नानुसार देख सकते हैं:

 $ readelf -d test_rpath.elf

टीम का परिणाम

पढ़ने में आसानी के लिए, आदेश का परिणाम छोटा किया जाता है:

 Dynamic section at offset 0x2dd8 contains 28 entries: Tag Type Name/Value 0x0000000000000001 (NEEDED) Shared library: [libbubble.so] 0x0000000000000001 (NEEDED) Shared library: [libc.so.6] 0x000000000000000f (RPATH) Library rpath: [/run/media/pablo/disk1/projects/cheat_sheets/ELF/lib/] 0x000000000000000c (INIT) 0x1000 0x000000000000000d (FINI) 0x11c8 ....

राहत

LIEF लाइब्रेरी का उपयोग करके, आप योगिनी में RPATH रिकॉर्ड भी पढ़ सकते हैं:

 import lief from lief.ELF import DYNAMIC_TAGS elf = lief.parse("test_rpath.elf") if elf.has(DYNAMIC_TAGS.RPATH): rpath = next(filter(lambda x: x.tag == DYNAMIC_TAGS.RPATH, elf.dynamic_entries)) for path in rpath.paths: print(path) else: print("No RPATH in ELF")

.Dynamic अनुभाग के बारे में पढ़ें

सुरक्षा के लिए एल्फ की जाँच

शोधकर्ता टोबीस क्लेन ( ए बग हंटर की डायरी के लेखक) से सुरक्षा जांच स्क्रिप्ट की जांच 2011 से अपडेट नहीं की गई है। यह ELF फाइल स्क्रिप्ट विकल्प Relro (रीड ओनली रिलोकेशंस), NX (नॉन-एक्ज़ीक्यूटेबल स्टैक), स्टैक कैनरीज़, PIE (पोज़िशन इंडिपेंडेंट एक्ज़ीक्यूटेबल्स) की उपलब्धता की जाँच करता है और अपने काम के लिए रीडफ़ाइल यूटिलिटी का उपयोग करता है।

राहत

आप अपना खुद का एनालॉग बना सकते हैं ~~घुटना~~ पायथन और LIEF (पूर्वज की तुलना में थोड़ा अलग और अलग-अलग-कोड विकल्प के अतिरिक्त सत्यापन के साथ):

 import lief from lief.ELF import DYNAMIC_TAGS, SEGMENT_TYPES def filecheck(filename): binary = lief.parse(filename) # check RELRO if binary.has(SEGMENT_TYPES.GNU_RELRO): print("+ Full RELRO") if binary.has(DYNAMIC_TAGS.BIND_NOW) else print("~ Partial RELRO") else: print("- No RELRO") # check for stack canary support print("+ Canary found") if binary.has_symbol("__stack_chk_fail") else print("- No canary found") # check for NX support (check X-flag for GNU_STACK-segment) print("+ NX enabled") if binary.has_nx else print("- NX disabled") # check for PIE support print("+ PIE enabled") if binary.is_pie else print("- No PIE") # check for rpath / run path print("+ RPATH") if binary.has(DYNAMIC_TAGS.RPATH) else print("- No RPATH") print("+ RUNPATH")if binary.has(DYNAMIC_TAGS.RUNPATH) else print("- No RUNPATH") # check separate-code option if set(binary.get_section('.text').segments) == set(binary.get_section('.rodata').segments): print("- Not Separated Code Sections") else: print("+ Separated Code Sections") filecheck('test_rpath.elf')

Radare2

चेकके समान जानकारी प्रदर्शित करने के लिए Radare2 का उपयोग करने के अलावा dukebarman के लिए धन्यवाद:

 > r2 -ci~pic,canary,nx,crypto,stripped,static,relocs test_stack_proteck

एल्फ से कच्चा कोड (ईएलएफ से बाइनरी)

ऐसे हालात हैं जब ईएलएफ संरचना के रूप में "elven कपड़े" की जरूरत नहीं है, लेकिन केवल "नंगे" निष्पादन योग्य एप्लिकेशन कोड की आवश्यकता है।

objcopy

फर्मवेयर लिखने वालों के लिए शायद ऑज्कॉपी का उपयोग करना परिचित है:

 $ objcopy -O binary -S -g simple.elf simple.bin

-S - चरित्र की जानकारी को हटाने के लिए;
-g - डिबगिंग जानकारी निकालने के लिए।

राहत

कोई जादू नहीं। बस लोड किए गए अनुभागों की सामग्री लें और उनसे एक बानर बनाएं:

 import lief from lief.ELF import SECTION_FLAGS, SECTION_TYPES binary = lief.parse("test") end_addr = 0 data = [] for section in filter(lambda x: x.has(SECTION_FLAGS.ALLOC) and x.type != SECTION_TYPES.NOBITS, binary.sections): if 0 < end_addr < section.virtual_address: align_bytes = b'\x00' * (section.virtual_address - end_addr) data.append(align_bytes) data.append(bytes(section.content)) end_addr = section.virtual_address + section.size with open('test.lief.bin', 'wb') as f: for d_bytes in data: f.write(d_bytes)

मंगली - ध्वस्त फ़ंक्शन नाम

C ++ कोड से बनाई गई ELFs में, संबंधित वर्ग फ़ंक्शन की खोज को आसान बनाने के लिए फ़ंक्शन नाम सजाए गए हैं (mangled)। हालांकि, विश्लेषण में ऐसे नामों को पढ़ना बहुत सुविधाजनक नहीं है।

टेस्ट योगिनी

एनएम

मानव-पठनीय रूप में नामों का प्रतिनिधित्व करने के लिए, आप बिन्यूटिल्स सेट से एनएम उपयोगिता का उपयोग कर सकते हैं:

 #        $ nm -D demangle-test-cpp ... U _Unwind_Resume U _ZdlPv U _Znwm U _ZSt17__throw_bad_allocv U _ZSt20__throw_length_errorPKc #        $ nm -D --demangle demangle-test-cpp ... U _Unwind_Resume U operator delete(void*) U operator new(unsigned long) U std::__throw_bad_alloc() U std::__throw_length_error(char const*)

राहत

LIEF लाइब्रेरी का उपयोग करके ध्वस्त रूप में प्रतीक नाम प्रदर्शित करना:

 import lief binary = lief.parse("demangle-test-cpp") for symb in binary.symbols: print(symb.name, symb.demangled_name)

असेंबली की असेंबली, रिकॉर्डिंग, संशोधन

मेटा-जानकारी के बिना एल्फ

आवेदन को डिबग करने और जंगली दुनिया में जारी करने के बाद, यह मेटा-सूचना को हटाने के लिए समझ में आता है:

डिबग सेक्शन - ज्यादातर मामलों में बेकार;
चर और कार्यों के नाम - अंत उपयोगकर्ता के लिए कुछ भी प्रभावित नहीं करते हैं (थोड़ा उल्टा पेचीदा होता है);
अनुभाग तालिका - आवेदन को चलाने के लिए बिल्कुल आवश्यक नहीं है (इसकी कमी रिवर्स को थोड़ा जटिल करेगी)।

चरित्र जानकारी हटाएं

चरित्र की जानकारी वस्तुओं और कार्यों के नाम हैं। इसके बिना, एप्लिकेशन का रिवर्स थोड़ा अधिक जटिल है।

पट्टी

सरलतम मामले में, आप बिनुटिल्स सेट से पट्टी की उपयोगिता का उपयोग कर सकते हैं। सभी वर्ण जानकारी को हटाने के लिए, बस कमांड चलाएँ:

निष्पादन योग्य फ़ाइल के लिए:
```
 $ strip -s simple 
```
गतिशील पुस्तकालय के लिए:
```
 $ strip --strip-unneeded libsimple.so 
```

sstrip

चरित्र जानकारी (फ़ाइल के अंत में अनावश्यक शून्य बाइट्स सहित) को सावधानीपूर्वक हटाने के लिए, आप ELFkickers सूट से sstrip उपयोगिता का उपयोग कर सकते हैं। सभी वर्ण जानकारी को हटाने के लिए, बस कमांड चलाएँ:

 $ sstrip -z simple

राहत

LIEF पुस्तकालय का उपयोग करके, आप एक त्वरित पट्टी (प्रतीक तालिका हटा दी गई है - अनुभाग .symtab ) भी बना सकते हैं:

 import lief binary = lief.parse("simple") binary.strip() binary.write("simple.stripped")

एक विभाजन तालिका हटाना

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

 import lief binary = lief.parse("simple") binary.header.numberof_sections = 0 binary.header.section_header_offset = 0 binary.write("simple.modified")

संशोधित करें और RPATH को हटाएँ

चरपथ, पैचेलएफ

लिनक्स के तहत RPATH को बदलने के लिए, आप chrpath उपयोगिताओं (अधिकांश वितरणों पर उपलब्ध) या PatchELF का उपयोग कर सकते हैं।

RPATH बदलें:

 $ chrpath -r /opt/my-libs/lib:/foo/lib test_rpath.elf

या

 $ patchelf --set-rpath /opt/my-libs/lib:/foo/lib test_rpath.elf

RPATH निकालें:

 $ chrpath -d test_rpath.elf

या

 $ patchelf --shrink-rpath test_rpath.elf

राहत

LIEF लाइब्रेरी आपको RPATH रिकॉर्ड को संशोधित करने और हटाने दोनों की अनुमति देती है।

RPATH बदलें:

 import lief binary = lief.parse("test_rpath.elf") rpath = next(filter(lambda x: x.tag == lief.ELF.DYNAMIC_TAGS.RPATH, binary.dynamic_entries)) rpath.paths = ["/opt/my-lib/here"] binary.write("test_rpath.patched")

RPATH निकालें:

 import lief binary = lief.parse("test_rpath.elf") binary.remove(lief.ELF.DYNAMIC_TAGS.RPATH) binary.write("test_rpath.patched")

चरित्र की जानकारी obfuscation

एप्लिकेशन के रिवर्स को जटिल करने के लिए, आप प्रतीकात्मक जानकारी को बचा सकते हैं, लेकिन वस्तुओं के नाम को भ्रमित कर सकते हैं। हम एक परीक्षण विषय के रूप में seveb द्वारा crackme01 से योगिनी crackme01_32bit का उपयोग करते हैं ।

LIEF लाइब्रेरी से एक उदाहरण का सरलीकृत संस्करण इस तरह दिखाई दे सकता है:

 import lief binary = lief.parse("crackme01_32bit") for i, symb in enumerate(binary.static_symbols): symb.name = "zzz_%d" % i binary.write("crackme01_32bit.obfuscated")

नतीजतन, हम प्राप्त करते हैं:

 $ readelf -s crackme01_32bit.obfuscated ... Symbol table '.symtab' contains 78 entries: Num: Value Size Type Bind Vis Ndx Name 0: 00000000 0 NOTYPE LOCAL DEFAULT UND zzz_0 1: 08048154 0 SECTION LOCAL DEFAULT 1 zzz_1 2: 08048168 0 SECTION LOCAL DEFAULT 2 zzz_2 3: 08048188 0 SECTION LOCAL DEFAULT 3 zzz_3 4: 080481ac 0 SECTION LOCAL DEFAULT 4 zzz_4 5: 080481d0 0 SECTION LOCAL DEFAULT 5 zzz_5 6: 080482b0 0 SECTION LOCAL DEFAULT 6 zzz_6 7: 0804835a 0 SECTION LOCAL DEFAULT 7 zzz_7 8: 08048378 0 SECTION LOCAL DEFAULT 8 zzz_8 9: 080483b8 0 SECTION LOCAL DEFAULT 9 zzz_9 10: 080483c8 0 SECTION LOCAL DEFAULT 10 zzz_10 ...

PLT / GOT के माध्यम से फ़ंक्शन प्रतिस्थापन

जिसे ELF PLT INFECTION के नाम से भी जाना जाता है।

कॉपी-पेस्ट न करने के लिए, विषय पर लिंक छोड़ें:

प्रवेश बिंदु बदलें

पैच बनाते समय, हुक स्थापित करने और अन्य गतिशील इंस्ट्रूमेंटेशन या छिपे हुए कार्यों को लागू करने के लिए यह उपयोगी हो सकता है। प्रायोगिक के रूप में, हम seveb द्वारा क्रैकमे 01 से एल्फ क्रैकमे__32बिट का उपयोग करते हैं

radare2

radare2 रिकॉर्डिंग मोड में शुरू होता है (विकल्प -w ) - मूल फ़ाइल में परिवर्तन किए जाएंगे:

 $ ./crackme01_32bit Please enter the secret number: ^C $ r2 -w -nn crackme01_32bit [0x00000000]> .pf.elf_header.entry=0x0804860D [0x00000000]> q $ ./crackme01_32bit Nope.

राहत

 import lief binary = lief.parse("crackme01_32bit") header = binary.header header.entrypoint = 0x0804860D binary.write("crackme01_32bit.patched")

कोड पैच

एक साधारण परीक्षण के रूप में, दरार के साथ novn91 के क्रैकमपाल को लें । जब मापदंडों के बिना लॉन्च किया जाता है, तो कार्यक्रम प्रदर्शित होता है:

 $ ./crackmeMario usage <password>

जब एक मनमाना-स्ट्रिंग पैरामीटर के साथ लॉन्च किया जाता है, तो यह प्रदर्शित होता है:

 ./crackmeMario qwerty try again pal.

हम एक पैच बनाएंगे ताकि स्टार्टअप पर कार्यक्रम संदेश "अच्छा काम" प्रदर्शित करे! अब मुझे keygen! ”

radare2

radare2 किसी भी प्रारूप को पैच कर सकता है जो इसे स्वयं का समर्थन करता है। इस मामले में, पाठ प्रारूप में पैच का वर्णन करना संभव है:

 # Rapatch for https://crackmes.one/crackme/5ccecc7e33c5d4419da559b3 !echo Patching crackme 0x115D : jmp 0x1226

आप इस तरह के पैच को कमांड के साथ लगा सकते हैं:

 $ r2 -P patch.txt crackmeMario

राडार 2 के माध्यम से पैचिंग कोड के बारे में पढ़ें:

राहत

LIEF आपको निर्दिष्ट वर्चुअल पते पर योगिनी (अधिलेखित बाइट्स) को पैच करने की अनुमति देता है। पैच बाइट्स के एक सरणी के रूप में या पूर्णांक मान के रूप में हो सकता है:

 import lief binary = lief.parse("crackmeMario") binary.patch_address(0x115D, bytearray(b"\xe9\xc4\x00\x00\x00")) binary.write("crackmeMario.patched")

पैच लगाने के बाद, प्रोग्राम आउटपुट होगा:

 $ ./crackmeMario.patched good job! now keygen me!

ELF में सेक्शन जोड़ें

objcopy

objcopy आपको एक सेक्शन जोड़ने की अनुमति देता है, लेकिन यह सेक्शन किसी भी सेगमेंट से संबंधित नहीं होगा और आवेदन के समय रैम में लोड नहीं होगा:

 $ objcopy --add-section .testme=data.zip \ --set-section-flags .testme=alloc,contents,load,readonly \ --change-section-address .testme=0x08777777 \ simple simple.patched.elf

राहत

LIEF लाइब्रेरी आपको एक मौजूदा ELF में एक नया खंड और उसके संबंधित खंड ( loaded=True फ्लैग) को जोड़ने की अनुमति देती है:

 import lief binary = lief.parse("simple") data = bytearray(b"\xFF" * 16) section = lief.ELF.Section(".testme", lief.ELF.SECTION_TYPES.PROGBITS) section += lief.ELF.SECTION_FLAGS.EXECINSTR section += lief.ELF.SECTION_FLAGS.ALLOC section.content = data binary.add(section, loaded=True) binary.write("simple.testme.lief")

खंड बदलें

objcopy

objcopy आपको एक फ़ाइल से डेटा के साथ अनुभाग की सामग्री को बदलने की अनुमति देता है, साथ ही एक अनुभाग और झंडे के आभासी पते को बदल देता है।

 $ objcopy --update-section .testme=patch.bin \ --change-section-address .testme=0x08999999 simple simple.testme.elf

राहत

 import lief binary = lief.parse("simple") data = bytearray(b"\xFF" * 17) section = binary.get_section(".text") section.content = data binary.write("simple.patched")

अनुभाग हटाएँ

objcopy

objcopy आपको नाम से एक विशिष्ट अनुभाग को हटाने की अनुमति देता है:

 $ objcopy --remove-section .testme simple.testme.elf simple.no_testme.elf

राहत

LIEF लाइब्रेरी का उपयोग करके अनुभाग को हटाना इस तरह दिखता है:

 import lief binary = lief.parse("simple.testme.elf") binary.remove_section(".testme") binary.write("simple.no_testme")

एल्फ कंटेनर

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

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

 $ echo "" | gcc -m32 -fpic -o empty.o -c -xc - $ gcc -m32 -shared -o libempty.so empty.o

अब आप इस टेम्पलेट का उपयोग डेटा को पॉप्युलेट करने के लिए कर सकते हैं:

 import lief binary = lief.parse("libempty.so") filename = "crackme.zip" data = open(filename, 'rb').read() # Add section with zip-archive as content section = lief.ELF.Section() section.content = data section.name = ".%s"%filename binary.add(section, loaded=True) # Add symbol as a reference to zip-archive symb = lief.ELF.Symbol() symb.type = lief.ELF.SYMBOL_TYPES.OBJECT symb.binding = lief.ELF.SYMBOL_BINDINGS.GLOBAL symb.size = len(data) symb.name = filename symb.value = section.virtual_address binary.add_static_symbol(symb) binary.write("libdata.crackme.container")

एल्फ "एक ट्रेलर के साथ"

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

विश्लेषण करते समय आईडीए प्रो इस डेटा पर विचार नहीं करेगा

ट्रेलर के साथ फ़ाइल संरचना का उदाहरण

radare2

"ट्रेलर" की उपस्थिति वास्तविक और गणना की गई फ़ाइल आकारों की तुलना करके स्थापित की जा सकती है:

 $ radare2 test.elf [0x00001040]> ?v $s 0x40c1 [0x00001040]> iZ 14699

readelf

readelf "ट्रेलर" की उपस्थिति के बारे में जानकारी नहीं दिखाता है, लेकिन मैन्युअल रूप से गणना की जा सकती है:

 $ ls -l test.elf #   16577  $ readelf -h test.elf Start of section headers e_shoff 14704 Size of section headers e_shentsize 64 Number of section headers e_shnum 29 #  ELF-: e_shoff + ( e_shentsize * e_shnum ) = 16560

राहत

LIEF पुस्तकालय आपको "ट्रेलर" की उपस्थिति के लिए दोनों की जांच करने और इसे जोड़ने की अनुमति देता है। LIEF के प्रयोग से, सब कुछ काफी रसीला लगता है:

 import lief binary = lief.parse("test") # check if overlay exists print('ELF has overlay data') if binary.has_overlay else print("No overlay data") # add overlay data to ELF data = bytearray(b'\xFF'*17) binary.overlay = data binary.write('test.overlay')

शून्य एल्फ (खरोंच से ईएलएफ)

इंटरनेट पर आप "मैन्युअल रूप से" ईएलएफ फ़ाइल बनाने के लिए प्रोजेक्ट पा सकते हैं - सामान्य नाम "स्क्रैच से ईएलएफ" के तहत संकलक और लिंकर का उपयोग किए बिना:

जीथब प्रोजेक्ट
खरोंच लेख से एल्फ
LIEF लाइब्रेरी रिपॉजिटरी में Elf_from_scratch शाखा

इन परियोजनाओं के साथ परिचित होने से ELF प्रारूप के अवशोषण पर लाभकारी प्रभाव पड़ता है।

सबसे छोटी योगिनी

योगिनी के आकार को कम करने के साथ दिलचस्प प्रयोग लेखों में वर्णित हैं:

संक्षेप में, ओएस में लोडर सभी हेडर फ़ील्ड और सेगमेंट टेबल का उपयोग नहीं करता है, और कुछ न्यूनतम निष्पादन योग्य कोड को सीधे ईएलएफ हेडर संरचना में रखा जा सकता है (कोड पहले लेख से लिया गया है):

 ; tiny.asm BITS 32 org 0x00010000 db 0x7F, "ELF" ; e_ident dd 1 ; p_type dd 0 ; p_offset dd $$ ; p_vaddr dw 2 ; e_type ; p_paddr dw 3 ; e_machine dd _start ; e_version ; p_filesz dd _start ; e_entry ; p_memsz dd 4 ; e_phoff ; p_flags _start: mov bl, 42 ; e_shoff ; p_align xor eax, eax inc eax ; e_flags int 0x80 db 0 dw 0x34 ; e_ehsize dw 0x20 ; e_phentsize db 1 ; e_phnum ; e_shentsize ; e_shnum ; e_shstrndx filesize equ $ - $$

इकट्ठा करें और आकार का एक ईएलएफ प्राप्त करें ... 45 बाइट्स :

  $ nasm -f bin -o a.out tiny.asm $ chmod +x a.out $ ./a.out ; echo $? 42 $ wc -c a.out 45 a.out

पैटर्न योगिनी

LIEF लाइब्रेरी का उपयोग करके एक योगिनी बनाने के लिए, आप निम्नलिखित कदम उठा सकते हैं (नुस्खा "एल्फ-कंटेनर" देखें):

टेम्पलेट के रूप में एक साधारण ईएलएफ फ़ाइल लें;
अनुभागों की सामग्री को बदलें, नए अनुभाग जोड़ें;
आवश्यक मापदंडों (प्रवेश बिंदु, झंडे) को कॉन्फ़िगर करें।

एक निष्कर्ष के बजाय

लेख में जोड़ते हुए, हमने पाया कि यह LIEF पुस्तकालय के लिए एक ode जैसा है। लेकिन यह योजनाबद्ध नहीं था - मैं यह दिखाना चाहता था कि विभिन्न उपकरणों का उपयोग करके ईएलएफ फ़ाइलों के साथ कैसे काम किया जाए।

निश्चित रूप से ऐसी स्क्रिप्ट्स या आवश्यकताएं हैं जिनका उल्लेख यहां नहीं किया गया है - टिप्पणियों में इस बारे में लिखें।

सन्दर्भ और साहित्य

ईएलएफ प्रारूप विनिर्देश
ओरेकल लाइब्रेरी में एक और प्रारूप विनिर्देश
रडार 2 का उपयोग करके ईएलएफ के साथ काम करना
LIEF पुस्तकालय प्रलेखन
LIEF पुस्तकालय उदाहरण
पुस्तक "व्यावहारिक द्विघात विश्लेषण", डेनिस एंड्रियास
रेयान "एल्फमास्टर" ओ'नील द्वारा लिनक्स बाइनरी विश्लेषण सीखना

ईएलएफ के लिए व्यंजन विधि

उपकरण

टेस्ट कल्पित बौने

पढ़ना, जानकारी प्राप्त करना

फ़ाइल प्रकार, शीर्षक, अनुभाग

010Editor

readelf

राहत

संकलक जानकारी

objdump

readelf

राहत

मैं आपके द्वारा गणना करूँगा ... RPATH

RPATH कैसे प्रकट होता है?

readelf

राहत

सुरक्षा के लिए एल्फ की जाँच

राहत

Radare2

एल्फ से कच्चा कोड (ईएलएफ से बाइनरी)

objcopy

राहत

मंगली - ध्वस्त फ़ंक्शन नाम

एनएम

राहत

असेंबली की असेंबली, रिकॉर्डिंग, संशोधन

मेटा-जानकारी के बिना एल्फ

चरित्र जानकारी हटाएं

पट्टी

sstrip

राहत

एक विभाजन तालिका हटाना

संशोधित करें और RPATH को हटाएँ

चरपथ, पैचेलएफ

राहत

चरित्र की जानकारी obfuscation

PLT / GOT के माध्यम से फ़ंक्शन प्रतिस्थापन

प्रवेश बिंदु बदलें

radare2

राहत

कोड पैच

radare2

राहत

ELF में सेक्शन जोड़ें

objcopy

राहत

खंड बदलें

objcopy

राहत

अनुभाग हटाएँ

objcopy

राहत

एल्फ कंटेनर

एल्फ "एक ट्रेलर के साथ"

radare2

readelf

राहत

शून्य एल्फ (खरोंच से ईएलएफ)

सबसे छोटी योगिनी

पैटर्न योगिनी

एक निष्कर्ष के बजाय

सन्दर्भ और साहित्य

More articles: