मुख्य कार्य के बारे में कुछ विवरण

एक बार जब मैं linux में एक प्रक्रिया के मुख्य कार्य के ढेर की सामग्री में रुचि हो गई। कुछ शोध खर्च किए और अब मैं आपको परिणाम पेश करता हूं।

मुख्य कार्य का वर्णन करने के लिए विकल्प:
1. int मुख्य ()
2. int मुख्य (int argc, char ** argv)
3. int मुख्य (int argc, char ** argv, char ** env)
4. इंट मेन (int argc, char ** argv, char ** env, ElfW (auxv_t) auxv]]
5. इंट मेन (int argc, char ** argv, char ** env, char ** apple)

argc - मापदंडों की संख्या
Argv - कमांड लाइन पैरामीटर स्ट्रिंग्स को इंगित करने वाला नल-टर्मिनल सरणी
env पर्यावरण चर का तार करने के लिए संकेत का एक शून्य टर्मिनल सरणी है। स्वरूप में प्रत्येक पंक्ति NAME = VALUE
ऑक्सव - सहायक मूल्यों की एक सरणी (केवल पावरपीसी के लिए उपलब्ध [1])
सेब - निष्पादन योग्य फ़ाइल का पथ (MacOS और डार्विन पर [2])
सहायक वेक्टर विभिन्न अतिरिक्त जानकारी के साथ एक सरणी है, जैसे कि प्रभावी उपयोगकर्ता पहचानकर्ता, सेतु बिट विशेषता, मेमोरी पेज का आकार, आदि।

इसके अलावा, i386 और x86_64 के लिए सहायक मूल्यों की एक सरणी कैसे प्राप्त करें, साथ ही स्टैक के "सेगमेंट" की बाकी सामग्री भी।


स्टैक सेगमेंट का आकार मैप्स फ़ाइल में देखा जा सकता है:
बिल्ली / खरीद / 10918 / नक्शे
...
7ffffffa3000-7ffffff000 rw-p 00000000 00:00 0 [स्टैक]
...

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

1।	0x7ffffffff000	स्टैक सेगमेंट का शीर्ष बिंदु। अपील कॉल segfault
	0x7ffffffff0f8	शून्य	शून्य *	8	0x00 '
2।		फ़ाइल नाम [को ०]	चार	1 +	«/Tmp/a.out»
			चार	1	0x00
...
		env [1] [०]	चार	1	0x00
...
			चार	1	0x00
3।	0x7fffffffe5e0	env [0] [०]	चार	1	..
			चार	1	0x00
...
		argv [1] [०]	चार	1	0x00
...
			चार	1	0x00
4।	0x7fffffffe5be	argv [0] [0]	चार	1 +	«/Tmp/a.out»
5।		यादृच्छिक लंबाई की सरणी
6।		ऑक्सव के लिए डेटा	शून्य * []	48 '
		AT_NULL	Elf64_auxv_t	16	{0,0}
...
		ऑक्सव [1]	Elf64_auxv_t	16
7।		ऑक्सव [0]	Elf64_auxv_t	16	Ex।: {0x0e, 0x3e8}
		शून्य	शून्य *	8	0x00
...
		env [1]	चार *	8
8।	0x7fffffffe308	env [0]	चार *	8	0x7fffffffe5e0
		शून्य	शून्य *	8	0x00
...
		argv [1]	चार *	8
9।	0x7fffffffe2f8	argv [0]	चार *	8	0x7fffffffe5be
10।	0x7fffffffe2f0	argc	लंबे समय से int	8 '	तर्कों की संख्या + 1
11।		स्थानीय चर और तर्क, कार्य मुख्य से पहले कहते हैं
12।		स्थानीय चर मुख्य
13।	0x7fffffffe1fc	argc	पूर्णांक	4	तर्कों की संख्या + 1
	0x7fffffffe1f0	argv	चार **	8	0x7fffffffe2f8
	0x7fffffffe1e8	env	चार **	8	0x7fffffffe308
14।		स्थानीय फ़ंक्शन चर

'- मुझे दस्तावेजों में खेतों का वर्णन नहीं मिला, लेकिन वे डंप में स्पष्ट रूप से दिखाई देते हैं।

मैंने 32 बिट्स के लिए जांच नहीं की, लेकिन सबसे अधिक संभावना है कि यह केवल आकारों को दो में विभाजित करने के लिए पर्याप्त है।

1. शीर्ष से ऊपर के पते को संबोधित करना Segfault का कारण बनता है।
2. एक स्ट्रिंग निष्पादन योग्य फ़ाइल के लिए पथ।
3. पर्यावरण चर के साथ तार की सरणी
4. कमांड लाइन मापदंडों के साथ तार की सरणी
5. सरणी यादृच्छिक रूप से लंबी है। इसके चयन को कमांडों द्वारा निष्क्रिय किया जा सकता है
sysctl -w kernel.randomize_va_space = 0
प्रतिध्वनि 0> / proc / sys / कर्नेल / randomize_va_space
6. सहायक वेक्टर के लिए डेटा (उदाहरण के लिए, स्ट्रिंग "x86_64")
7. सहायक वेक्टर। अधिक विवरण नीचे।
8. पर्यावरण चर के तार के लिए संकेत के शून्य टर्मिनल सरणी
9. कमांड लाइन पैरामीटर स्ट्रिंग्स को नल-टर्मिनल सरणी ऑफ़ पॉइंटर्स
10. मशीन शब्द जिसमें कमांड लाइन पैरामीटर की संख्या है ("वरिष्ठ" फ़ंक्शन के तर्कों में से एक, पैरा 11 देखें)
11. मुख्य से पहले कहे जाने वाले कार्यों के मुखर चर और तर्क (_start, __ libc_start_main)
12. मुख्य में घोषित चर
13. मुख्य कार्य के तर्क
14. स्थानीय कार्यों के चर और तर्क।

हेल्पर वेक्टर
I386 और x86_64 के लिए, सहायक वेक्टर के पहले तत्व का पता प्राप्त नहीं किया जा सकता है, हालांकि, इस वेक्टर की सामग्री को अन्य तरीकों से प्राप्त किया जा सकता है। उनमें से एक पर्यावरण चर के संकेत की सरणी के तुरंत बाद स्मृति क्षेत्र की ओर मुड़ना है।
यह कुछ इस तरह दिखना चाहिए:

#include <stdio.h> #include <elf.h> int main(int argc, char** argv, char** env){ Elf64_auxv_t *auxv; //x86_64 // Elf32_auxv_t *auxv; //i386 while(*env++ != NULL); //    for (auxv = (Elf64_auxv_t *)env; auxv->a_type != AT_NULL; auxv++){ printf("addr: %p type: %lx is: 0x%lx\n", auxv, auxv->a_type, auxv->a_un.a_val); } printf("\n (void*)(*argv) - (void*)auxv= %p - %p = %ld\n (void*)(argv)-(void*)(&auxv)=%p-%p = %ld\n ", (void*)(*argv), (void*)auxv, (void*)(*argv) - (void*)auxv, (void*)(argv), (void*)(&auxv), (void*)(argv) - (void*)(&auxv)); printf("\n argc copy: %d\n",*((int *)(argv - 1))); return 0; } 

एल्फ संरचनाएं {32,64} _auxv_t /usr/include/elf.h में वर्णित हैं। लिनक्स-कर्नेल / fs / binfmt_elf.c में संरचनात्मक भरने के कार्य

वेक्टर की सामग्री प्राप्त करने का दूसरा तरीका:
hexdump / proc / self / auxv

सबसे पठनीय दृश्य पर्यावरण चर LD_SHOW_AUXV सेट करके प्राप्त किया जाता है।

LD_SHOW_AUXV = 1 एल.एस.
AT_HWCAP: bfebfbff // processor फीचर्स
AT_PAGESZ: 4096 // मेमोरी पेज का आकार
AT_CLKTCK: 100 // ताज़ा दर बार ()
AT_PHDR: 0x400040 // हैडर जानकारी
AT_PHENT: 56
AT_PHNUM: 9
AT_BASE: 0x7fd00b5bc000 // दुभाषिया का पता, यानी, ldso
AT_FLAGS: 0x0
AT_ENTRY: 0x402490 // कार्यक्रम के लिए प्रवेश बिंदु
AT_UID: 1000 // उपयोगकर्ता और समूह पहचानकर्ता
AT_EUID: 1000 // रेटेड और प्रभावी
AT_GID: 1000
AT_EGID: 1000
AT_SECURE: 0 // क्या सेतु के झंडे को उठाया जाता है
AT_RANDOM: 0x7fff30bdc809 // पता 16 यादृच्छिक बाइट्स,
स्टार्टअप पर उत्पन्न
AT_SYSINFO_EHDR: 0x7fff30bff000 // सूचक पृष्ठ के लिए उपयोग किया जाता है
// सिस्टम कॉल
AT_EXECFN: / bin / ls
AT_PLATFORM: x86_64
बाईं ओर चर का नाम है, दाईं ओर मूल्य है। सभी संभव चर नाम और उनके विवरण elf.h फ़ाइल में देखे जा सकते हैं। (AT_ उपसर्ग के साथ स्थिरांक)

मुख्य से वापसी ()
प्रक्रिया के संदर्भ को प्रारंभ करने के बाद, नियंत्रण मुख्य (), लेकिन _start () फ़ंक्शन के लिए पारित नहीं किया जाता है।
main () __libc_start_main से पहले ही कॉल करता है। इस अंतिम फ़ंक्शन में एक दिलचस्प विशेषता है - यह एक फ़ंक्शन को एक संकेतक पारित किया जाता है जिसे मुख्य () के बाद निष्पादित किया जाना चाहिए। और इस सूचक को स्टैक के माध्यम से स्वाभाविक रूप से पारित किया जाता है।
फ़ाइल glibc-2.11 / sysdeps / ia64 / elf / start.S के अनुसार, सामान्य रूप से, __libc_start_main के पास तर्क हैं।
/ *
* __Libc_start_main के लिए तर्क:
* out0: मुख्य
* out1: argc
* out2: argv
* आउट 3: इनिट
* आउट 4: फिनी // फ़ंक्शन को मुख्य के बाद कहा जाता है
* आउट 5: rtld_fini
* आउट 6: स्टैक_एंड
* /
यानी अंतिम पॉइंटर के पते को प्राप्त करने के लिए आपको पिछले स्थानीय चर मुख्य से दो मशीन शब्दों द्वारा स्थानांतरित करने की आवश्यकता है।
यहाँ क्या हुआ (प्रदर्शन संकलक के संस्करण पर निर्भर करता है):

 #include <stdio.h> void **ret; void *leave; void foo(){ void (*boo)(void); //   printf("Stack rewrite!\n"); boo = (void (*)(void))leave; boo(); // fini() } int main(int argc, char *argv[], char *envp[]) { unsigned long int mark = 0xbfbfbfbfbfbfbfbf; //,     ret = (void**)(&mark+2); //  , ,    (fini) leave = *ret; //  *ret = (void*)foo; //  return 0; //   foo() } 

मुझे उम्मीद है कि यह दिलचस्प था।
सौभाग्य है।

मददगार टिप के लिए Xeor को धन्यवाद।

1. www.gelato.unsw.edu.au/IA64wiki/AuxiliaryVector
2. unixjunkie.blogspot.com/2006/02/char-apple-argument-vector.html
3. articles.manugarg.com/aboutelfauxiliaryvectors.html
4. www.phrack.org/issues.html?issue=58&id=5#article
5. unixforum.org/index.php?showtopic=94993&st=30
6. source.redhat.com/ml/libc-alpha/2007-06/msg00108.html
7. linux-kernel / fs / binfmt_elf.c
8./usr/include/elf.h
9. glibc-2.11 / sysdeps / ia64 / elf / libc-start.c