सबसे पहले मुझे इस पोस्ट की लंबाई के बारे में खेद है, लेकिन मैं समस्या को स्पष्ट रूप से समझाना चाहता था।स्वयं संशोधित कोड, ढेर में प्रतिलिपि/कूद
मैं सी में छोटे स्वयं बदलाव कार्यक्रम का एक प्रकार लिखने की कोशिश, लेकिन मैं कुछ मुसीबतों है और मैं वास्तव में क्यों पता नहीं है।
Plateform है: Ubuntu/लिनक्स 2.6.32-40 x86_64, prog 86 मेहराब पर निर्माण है, जीसीसी (उबंटू 4.4.3-4ubuntu5.1) 4.4.3, जीएनयू ld (उबंटू के लिए जीएनयू binutils) 2.20 .1-system.20100303
कार्यक्रम के उद्देश्य के ((3) और mprotect (2)memalign के साथ), एक छोटे से समारोह कॉपी/एक पढ़ें/लिखें बनाने स्मृति के हिस्सा निष्पादित करने के लिए है मेमोरी के इस खंड में p() (सेगमेंट में परिभाषित) कहा जाता है और उसके बाद कॉपी किए गए फ़ंक्शन को पॉइंटर के माध्यम से निष्पादित करता है। p() फ़ंक्शन बस printf(puts) का उपयोग करके एक संदेश प्रदर्शित करता है।
क्रम शुरू करने और p() (इसे कॉपी) का कोड की समाप्त होने का पता पाने के लिए, मैं समारोह के ही पते और एक dummy() समारोह के पते का उपयोग .text में p() के तुरंत बाद ही पैदा करते हैं।
int p() { ... } <- address where the copy starts
int dummy() { ... } <- address where the copy stops
हिस्सा स्मृति निर्माण और प्रतिलिपि सफलतापूर्वक किया जाता है लेकिन जब हिस्सा में कोड एक segfault चलाया जाता है होता है। gdb का उपयोग करके यह स्पष्ट है कि हम खंड के कोड (कॉपी किए गए फ़ंक्शन का बॉडी) में प्रवेश करते हैं लेकिन printf पर कॉल विफल हुआ। p() फ़ंक्शन और खंड में कोड को अलग करते समय मुझे लगता है कि 'कॉल' में उपयोग का उपयोग समान नहीं है।
और मैं में जाना जाता है क्यों नहीं पता गलत है, जब कोड कॉपी किया जाता है यह प्रदर्शित किया जाता है और यह एक ही है कि objdump (या gdb) मुझे दिया जब मैं p() समारोह एकत्रित न है।
द्विआधारी -static के साथ got/plt के साथ संभावित समस्या से बचने के लिए या ld.so की स्थानांतरण प्रक्रिया के साथ बना है। यह heap पर कोड चलाने की समस्या प्रतीत नहीं होता है क्योंकि कॉपी किए गए फ़ंक्शन की शुरुआत निष्पादित की जाती है (gdb के अंतर्गत जांचें)।
कार्यक्रम के सरलीकृत src:
<... skip include/checks ...>
#define newline() putchar('\n')
/* - function copied in the chunk */
int p()
{
printf("hello world\n");
return 0;
}
/* - dummy function to get last address of p() */
int dummy() { return 0; }
int main()
{
char *s, *code, *chunk;
unsigned int pagesz, sz;
int (*ptr)(void);
pagesz = sysconf(_SC_PAGE_SIZE);
chunk = (char*)memalign(pagesz, 4 * pagesz);
mprotect(chunk, 4 * pagesz, PROT_WRITE|PROT_EXEC|PROT_READ);
/* - get size, display addr */
sz = (char *)dummy - (char *)p;
printf("Copy between : %p - %p\n", (char *)p, (char *)dummy);
printf("Copy in chunk : %p - %p\n", chunk, chunk + sz, sz);
/* - copy code (1 byte in supp) */
printf("Copied code : ");
for(s = (char *)p, code = chunk; \
s <= (char *)dummy; s++, code++) {
*code = *s;
/* - write in console -- to check if code of p() after disas
* it with objdump(1) is the same, RESULT : ok */
printf("%02x ", *(unsigned char *)code);
}
newline();
/* - run once orginal function */
ptr = p;
ptr();
/* - run copied function (in chunk) */
ptr = (int (*)(void))chunk;
ptr();
newline();
free(chunk);
return 0;
}
p() समारोह objdump(1) से disassembled:
080483c3 <p>:
80482c0: 55 push %ebp
80482c1: 89 e5 mov %esp,%ebp
80482c3: 83 ec 18 sub $0x18,%esp
80482c6: c7 04 24 a8 d9 0a 08 movl $0x80ad9a8,(%esp)
80482cd: e8 7e 0c 00 00 call 8048f50 <_IO_puts>
80482d2: b8 00 00 00 00 mov $0x0,%eax
80482d7: c9 leave
80482d8: c3 ret
080483dc <dummy>:
....
जब कार्यक्रम gdb के तहत चलाया जाता है (1) की नकल की कोड एक ही है (हेक्स मूल्य) objdump (1) से ऊपर प्रदान करें:
# gcc -m32 -o selfmodif_light selfmodif_light.c -static -g -O0
# gdb -q ./selfmodif_light
Reading symbols from /path/.../selfmodif_light...done.
(gdb) list 55
50 /* - run once orginal function */
51 ptr = p;
52 ptr();
53
54 /* - run copied function (in chunk) */
55 ptr = (int (*)(void))chunk;
<<< The problem is here >>>
56 ptr();
57
58 newline();
59 free(chunk);
(gdb) br 56
Breakpoint 1 at 0x8048413: file tmp.c, line 56.
(gdb) run
Starting program: /path/.../selfmodif_light
Copy between : 0x80482c0 - 0x80482d9
Copy in chunk : 0x80d2000 - 0x80d2019
Copied code : 55 89 e5 83 ec 18 c7 04 24 a8 d9 0a 08 e8 7e 0c 00 00 b8 00 00 00 00 c9 c3 55
hello world
Breakpoint 1, main() at tmp.c:56
56 ptr();
(gdb) disas main
Dump of assembler code for function main:
0x080482e3 <+0>: push %ebp
... <skip> ...
=> 0x08048413 <+304>: mov 0x18(%esp),%eax
0x08048417 <+308>: call *%eax
... <skip> ...
0x08048437 <+340>: ret
End of assembler dump.
लेकिन जब पी() और हिस्सा disassembled रहे हैं, हम पी में की तरह एक call 0x8048f50 <puts> के बजाय स्मृति हिस्सा में एक call 0x80d2c90 है() फ़ंक्शन: 0 यदि हम मुख्य में देखने के लिए हम अगले हिस्सा में जाने ?किस कारण से पता पता समान नहीं है।
(gdb) disas p
Dump of assembler code for function p:
0x080482c0 <+0>: push %ebp
0x080482c1 <+1>: mov %esp,%ebp
0x080482c3 <+3>: sub $0x18,%esp
0x080482c6 <+6>: movl $0x80ad9a8,(%esp)
0x080482cd <+13>: call 0x8048f50 <puts> <<= it is not the same address
0x080482d2 <+18>: mov $0x0,%eax
0x080482d7 <+23>: leave
0x080482d8 <+24>: ret
End of assembler dump.
(gdb) disas 0x80d2000,0x80d2019
Dump of assembler code from 0x80d2000 to 0x80d2019:
0x080d2000: push %ebp
0x080d2001: mov %esp,%ebp
0x080d2003: sub $0x18,%esp
0x080d2006: movl $0x80ad9a8,(%esp)
0x080d200d: call 0x80d2c90 <<= than here (but it should be ??)
0x080d2012: mov $0x0,%eax
0x080d2017: leave
0x080d2018: ret
End of assembler dump.
जब स्मृति चेक किया जाता है, कोड समान होने लगते हैं। इस बिंदु पर मुझे नहीं पता कि क्या हो रहा है, समस्या क्या है? जीडीबी की व्याख्या विफल रही, कोड की प्रतिलिपि या क्या?
(gdb) x/25bx p // code of p in .text
0x80482c0 <p>: 0x55 0x89 0xe5 0x83 0xec 0x18 0xc7 0x04
0x80482c8 <p+8>: 0x24 0xa8 0xd9 0x0a 0x08 0xe8 0x7e 0x0c
0x80482d0 <p+16>: 0x00 0x00 0xb8 0x00 0x00 0x00 0x00 0xc9
0x80482d8 <p+24>: 0xc3
(gdb) x/25bx 0x80d2000 // code of copy in the chunk
0x80d2000: 0x55 0x89 0xe5 0x83 0xec 0x18 0xc7 0x04
0x80d2008: 0x24 0xa8 0xd9 0x0a 0x08 0xe8 0x7e 0x0c
0x80d2010: 0x00 0x00 0xb8 0x00 0x00 0x00 0x00 0xc9
0x80d2018: 0xc3
एक ब्रेकपाइंट तो सेट है, तो निष्पादन स्मृति हिस्सा में जारी: इस बिंदु पर
(gdb) br *0x080d200d
Breakpoint 2 at 0x80d200d
(gdb) cont
Continuing.
Breakpoint 2, 0x080d200d in ??()
(gdb) disas 0x80d2000,0x80d2019
Dump of assembler code from 0x80d2000 to 0x80d2019:
0x080d2000: push %ebp
0x080d2001: mov %esp,%ebp
0x080d2003: sub $0x18,%esp
0x080d2006: movl $0x80ad9a8,(%esp)
=> 0x080d200d: call 0x80d2c90
0x080d2012: mov $0x0,%eax
0x080d2017: leave
0x080d2018: ret
End of assembler dump.
(gdb) info reg eip
eip 0x80d200d 0x80d200d
(gdb) nexti
0x080d2c90 in ??()
(gdb) info reg eip
eip 0x80d2c90 0x80d2c90
(gdb) bt
#0 0x080d2c90 in ??()
#1 0x08048419 in main() at selfmodif_light.c:56
तो या तो कार्यक्रम इस तरह से चलाता है और एक segfault कार्यक्रम होता है या $ EIP बदल गया है और त्रुटियों के बिना समाप्त होता है।
(gdb) set $eip = 0x8048f50
(gdb) cont
Continuing.
hello world
Program exited normally.
(gdb)
मुझे समझ में नहीं आता कि क्या हो रहा है, क्या असफल रहा। कोड की प्रति ठीक प्रतीत होती है, मेमोरी में भी कूदो, तो पता क्यों है (कॉल का पता) अच्छा नहीं है?
अपने जवाब के लिए धन्यवाद और अपने समय
वैसे भी हैकर आप किस प्रकार हैं ??? कृप्या! यदि आप स्वयं-संशोधित कोड लिखने जा रहे हैं तो आपको इसे स्वयं करना होगा :-) – ControlAltDel
टीएल; डीआर ......... –