🥢 🔟 🤶🏿 लिनक्स कर्नेल में स्थानांतरण के बारे में थोड़ा 👩🏽‍🤝‍👨🏻 ✳️ 🔕

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

यहाँ यह कैसा दिखता है:

static noinline int foo(int ret)
{
	return (ret + 2);
}

static int exe_init(void)
{
	int ret = 0;
	int (*new_foo)(int);

	ret = foo(0);
	printk(KERN_INFO "ret=%d\n", ret);

	new_foo = module_alloc(PAGE_SIZE);
	set_memory_x((unsigned long)new_foo, 1);

	printk(KERN_INFO "foo=%lx new_foo=%lx\n",
		(unsigned long)foo, (unsigned long)new_foo);

	memcpy((void *)new_foo, (const void *)foo, PAGE_SIZE);

	ret = new_foo(1);
	printk(KERN_INFO "ret=%d\n", ret);

	vfree(new_foo);
	return 0;
}

जब मॉड्यूल लोड किया जाता है तो exe_init फ़ंक्शन को कहा जाता है। हम कर्नेल लॉग में काम के परिणाम को देखते हैं:

[ 6972.522422] ret=2
[ 6972.522443] foo=ffffffffc0000000 new_foo=ffffffffc0007000
[ 6972.522457] ret=3

सब कुछ सही ढंग से काम कर रहा है। और अब हम तर्क को प्रदर्शित करने के लिए foo में प्रिंट फ़ंक्शन को जोड़ते हैं:

static noinline int foo(int ret)
{
	printk(KERN_INFO "ret=%d\n", ret);
	return (ret + 2);
}

और इसे पास करने से पहले new_foo () फ़ंक्शन की सामग्री के 25 बाइट्स डंप करें:

	memcpy((void *)new_foo, (const void *)foo, PAGE_SIZE);
	dump((unsigned long)new_foo);

डंप को परिभाषित किया गया है

static inline void dump(unsigned long x)
{
	int i;
	for (i = 0; i < 25; i++) \
		pr_cont("%.2x ", *((unsigned char *)(x) + i) & 0xFF); \
	pr_cont("\n");
}

हम मॉड्यूल को लोड करते हैं और लॉग में निम्नलिखित संदेश के साथ एक दुर्घटना प्राप्त करते हैं:

[ 8482.806092] ret=0
[ 8482.806092] ret=2
[ 8482.806111] foo=ffffffffc0000000 new_foo=ffffffffc0007000
[ 8482.806113] 53 89 fe 89 fb 48 c7 c7 24 10 00 c0 e8 e8 3d 0b c1 8d 43 02 5b c3 66 2e 0f 
[ 8482.806135] invalid opcode: 0000 [#1] SMP NOPTI
[ 8482.806639] CPU: 0 PID: 5081 Comm: insmod Tainted: G           O      5.4.27 #12
[ 8482.807669] Hardware name: innotek GmbH VirtualBox/VirtualBox, BIOS VirtualBox 12/01/2006
[ 8482.808560] RIP: 0010:irq_create_direct_mapping+0x79/0x90

किसी तरह, हम irq_create_direct_mapping फ़ंक्शन में समाप्त हो गए, हालांकि हमें प्रिंटक को कॉल करना था। आइए जानें क्या हुआ।

सबसे पहले, फू फ़ंक्शन के असंतुष्ट लिस्टिंग पर एक नज़र डालें। इसे objdump -d कमांड के साथ प्राप्त करें:

Disassembly of section .text:

0000000000000000 <foo>:
   0:	53                   	push   %rbx
   1:	89 fe                	mov    %edi,%esi
   3:	89 fb                	mov    %edi,%ebx
   5:	48 c7 c7 00 00 00 00 	mov    $0x0,%rdi
   c:	e8 00 00 00 00       	callq  11 <foo+0x11>
  11:	8d 43 02             	lea    0x2(%rbx),%eax
  14:	5b                   	pop    %rbx
  15:	c3                   	retq   
  16:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  1d:	00 00 00

फू फ़ंक्शन पाठ अनुभाग की शुरुआत में स्थित है। ऑफ़सेट 0xC पर, पास कॉल कमांड e8 का opcode स्थित है - निकट, क्योंकि इसे वर्तमान कोड सेगमेंट में निष्पादित किया गया है, चयनकर्ता मान नहीं बदलता है। अगले 4 बाइट्स आरआईपी रजिस्टर में मूल्य के सापेक्ष ऑफसेट हैं, जिस पर नियंत्रण स्थानांतरित किया जाएगा, अर्थात। RIP = RIP + ऑफसेट, Intel दस्तावेज़ीकरण (Intel 64 और IA-32 आर्किटेक्चर सॉफ्टवेयर डेवलपर के मैनुअल, निर्देश सेट संदर्भ AZ) के अनुसार:

एक रिश्तेदार ऑफसेट (rel16 या rel32) आम तौर पर विधानसभा कोड में एक लेबल के रूप में निर्दिष्ट किया जाता है। लेकिन मशीन कोड स्तर पर, यह एक हस्ताक्षरित, 16- या 32-बिट तत्काल मूल्य के रूप में एन्कोडेड है।
यह मान EIP (RIP) रजिस्टर में मान में जोड़ा जाता है। 64-बिट मोड में सापेक्ष ऑफ़सेट हमेशा एक 32-बिट तात्कालिक मान होता है, जो कि लक्ष्य गणना के लिए RIP रजिस्टर में मूल्य में जोड़े जाने से पहले 64-बिट तक विस्तारित होता है।

हम फ़ंक्शन फू का पता जानते हैं, यह 0xffffffffc0000000 है, इसलिए RIP = 0xffffffcc0000000 + 0xc + 0x5 = 0xffffffffc00000011 (0xc, e8 निर्देश पर ऑफ़सेट है, निर्देश के 1 बाइट और ऑफ़सेट ऑफ़ 4 बाइट्स)। हम ऑफसेट जानते हैं, क्योंकि शरीर के कार्यों में बाधा। आइए गणना करें कि फंक्शन फू में हमें भेजने के लिए कॉल कहां भेजेगा:

0xffffffffc00000011 + 0xffffffffc10b3de8 = 0xffffffff810b3df9

यह प्रिंट फ़ंक्शन का पता है:

# cat /proc/kallsyms | grep ffffffff810b3df9  
ffffffff810b3df9 T printk

और अब वही new_foo के लिए जाता है, जिसका पता 0xffffffcc0007000 है

0xffffffffc0007011 + 0xffffffffc10b3de8 = 0xffffffff810badf9

कॉल्स जिम में ऐसा कोई पता नहीं है, लेकिन 0xffffffff810badf9 है - 0x79 = 0xffffffff810bad80

# cat /proc/kallsyms | grep ffffffff810bad80
ffffffff810bad80 T irq_create_direct_mapping

यह वही कार्य है जिस पर दुर्घटना हुई थी।

एक दुर्घटना को रोकने के लिए, बस नए_फू फंक्शन के पते को जानकर, ऑफसेट को पुनर्गणना करें:

memcpy((void *)new_foo, (const void *)foo, PAGE_SIZE);
unsigned int delta = (unsigned long)printk - (unsigned long)new_foo - 0x11;
*(unsigned int *)((void *)new_foo + 0xD) = delta;

इस सुधार के बाद, कोई दुर्घटना नहीं होगी, new_foo फ़ंक्शन सफलतापूर्वक निष्पादित और नियंत्रण वापस करेगा।

समस्या सुलझ गई है। यह केवल यह समझने के लिए बना हुआ है कि ई 8 ओपकोड शून्य होने के बाद ऑफसेट को सूचीबद्ध करने वाले डिस्सेम्बलर में क्यों है, लेकिन डंप में कोई फ़ंक्शन नहीं है। ऐसा करने के लिए, विचार करें कि स्थानांतरण क्या हैं और कर्नेल उनके साथ कैसे काम करता है। लेकिन पहले, ईएलएफ प्रारूप के बारे में थोड़ा।

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

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

आप -r स्विच के साथ objdump उपयोगिता का उपयोग करके स्थानांतरण रिकॉर्ड की सामग्री को देख सकते हैं।
असंतुष्ट लिस्टिंग से, हम जानते हैं कि ऑफसेट 0xD पर प्रिंटक फ़ंक्शन का पता लिखना आवश्यक है, इसलिए हम निम्न स्थिति के साथ objdump आउटपुट की तलाश करते हैं:

000000000000000d R_X86_64_PC32     printk-0x0000000000000004

तो, हमारे पास ऑफसेट 0xD पर स्थिति को इंगित करने वाला आवश्यक स्थानांतरण रिकॉर्ड है, और प्रतीक का नाम जिसका पता इस स्थिति को लिखा जाना चाहिए।

मान (-4)। जिसे प्रिंटक फ़ंक्शन के पते में जोड़ा जाता है, को परिशिष्ट कहा जाता है, और स्थानांतरण के अंतिम परिणाम की गणना करते समय इसे ध्यान में रखा जाता है।

अब प्रिंट प्रतीक को देखें:

$ objdump -t exe.ko | grep printk
0000000000000000         *UND*	0000000000000000 printk

एक प्रतीक है, यह मॉड्यूल (अपरिभाषित) के अंदर अपरिभाषित है, इसलिए हम इसे कर्नेल में खोज करेंगे।

बाइनरी रूप में स्थानांतरण और प्रतीकों के रिकॉर्ड को देखना अधिक जानकारीपूर्ण होगा। यह वायरशार्क का उपयोग करके किया जा सकता है, यह ईएलएफ प्रारूप को पार्स कर सकता है। यहाँ हमारे स्थानांतरण प्रविष्टि (राइटर्स से कॉपी पेस्ट, बाईं ओर एलएसबी) है:

  0d 00 00 00 00 00 00 00  02 00 00 00 22 00 00 00  fc ff ff ff ff ff ff ff
  |                     |  |          ||         |  |                     |
  +----  -------+  +--  ---++---+  +---- addendum  ------+

इस प्रविष्टि की तुलना इसी संरचना की परिभाषा से करें <linux / elf.h>:

typedef struct elf64_rela {
  Elf64_Addr r_offset;	/* Location at which to apply the action */
  Elf64_Xword r_info;	/* index and type of relocation */
  Elf64_Sxword r_addend;	/* Constant addend used to compute value */
} Elf64_Rela;

यहां हमारे पास 8 बाइट्स हैं 0x00000000d, 4 बाइट्स टाइप करें 0x00000002, कैरेक्टर टेबल 0x00000022 (या दशमलव में 34) और 8 बाइट्स परिशिष्ट -4 में 4 बाइट्स इंडेक्स।

और यहाँ 34 नंबर पर प्रतीक तालिका से प्रविष्टि है:

  01 01 00 00 10 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00

और संबंधित संरचना

typedef struct elf64_sym {
  Elf64_Word st_name;		/* Symbol name, index in string tbl */
  unsigned char	st_info;	/* Type and binding attributes */
  unsigned char	st_other;	/* No defined meaning, 0 */
  Elf64_Half st_shndx;		/* Associated section index */
  Elf64_Addr st_value;		/* Value of the symbol */
  Elf64_Xword st_size;		/* Associated symbol size */
} Elf64_Sym;

पहले 4 बाइट्स 0x00000101 स्ट्रिंग्स की तालिका में सूचकांक है। इस चरित्र के नाम के लिए। printk। St_info फ़ील्ड प्रतीक के प्रकार को परिभाषित करता है, यह एक फ़ंक्शन, डेटा ऑब्जेक्ट आदि हो सकता है, अधिक विवरण के लिए ईएलएफ विनिर्देश देखें। हम st_other फ़ील्ड को छोड़ देंगे, अब यह हमारे लिए कोई दिलचस्पी नहीं है, और अंतिम तीन फ़ील्ड st_shndx, st_value और st_size देखें। st_shndx - उस खंड का हेडर इंडेक्स जिसमें वर्ण को परिभाषित किया गया है। हम यहां एक शून्य मान देखते हैं, क्योंकि प्रतीक मॉड्यूल के अंदर परिभाषित नहीं है, यह उपलब्ध वर्गों में नहीं है।
तदनुसार, इसका st_value मान और st_size का आकार भी शून्य है। मॉड्यूल लोड करते समय ये फ़ील्ड कर्नेल द्वारा भरे जाएंगे।

तुलना के लिए, प्रतीक फू को देखें, जो स्पष्ट रूप से मौजूद है:

  08 00 00 00 02 00 02 00  00 00 00 00 00 00 00 00  16 00 00 00 00 00 00 00

प्रतीक एक फ़ंक्शन को परिभाषित करता है जो कि 0x00000000 अनुभाग की शुरुआत के सापेक्ष पते पर .text अनुभाग में स्थित है, अर्थात्। खंड की शुरुआत में, जैसा कि हमने असंतुष्ट लिस्टिंग में देखा, फ़ंक्शन का आकार 22 बाइट्स है।

ओबजडम्प हमें इस बारे में समान जानकारी दिखाएंगे:

$ objdump -t exe.ko | grep foo
0000000000000000 l     F .text	0000000000000016 foo

जब कर्नेल मॉड्यूल को लोड करता है, तो यह सभी अपरिभाषित अक्षर पाता है और मान्य मूल्यों के साथ st_value और st_size फ़ील्ड भरता है। यह simpleify_symbols फ़ंक्शन, कर्नेल / मॉड्यूल.सी. फ़ाइल में किया जाता है:

/* Change all symbols so that st_value encodes the pointer directly. */
static int simplify_symbols(struct module *mod, const struct load_info *info)
{
...

फ़ंक्शन के मापदंडों में, निम्नलिखित फॉर्म का load_info संरचना पारित किया गया है

struct load_info {
	const char *name;
	/* pointer to module in temporary copy, freed at end of load_module() */
	struct module *mod;
	Elf_Ehdr *hdr;
	unsigned long len;
	Elf_Shdr *sechdrs;
	char *secstrings, *strtab;
	unsigned long symoffs, stroffs, init_typeoffs, core_typeoffs;
	struct _ddebug *debug;
	unsigned int num_debug;
	bool sig_ok;
#ifdef CONFIG_KALLSYMS
	unsigned long mod_kallsyms_init_off;
#endif
	struct {
		unsigned int sym, str, mod, vers, info, pcpu;
	} index;
};

निम्नलिखित फ़ील्ड हमारे लिए रुचि रखते हैं:
-
एचडीआर - ईएलएफ फ़ाइल हेडर - सीचड्र्स - सेक्शन हेडर टेबल के लिए सूचक
- स्ट्रैटब - प्रतीक नाम तालिका - शून्य द्वारा अलग किए गए स्ट्रिंग्स का एक सेट
- index.sym - प्रतीक तालिका वाले अनुभाग हेडर के सूचकांक

सबसे पहले, फ़ंक्शन को एक्सेस मिलेगा। प्रतीक तालिका के साथ अनुभाग। प्रतीक तालिका Elf64_Sym प्रकार के तत्वों की एक सरणी है:

Elf64_Shdr *symsec = &info->sechdrs[info->index.sym];
Elf64_Sym *sym = (void *)symsec->sh_addr;

अगला, लूप में, हम तालिका के सभी वर्णों से गुजरते हैं, जो इसके प्रत्येक नाम के लिए निर्धारित करते हैं:

for (i = 1; i < symsec->sh_size / sizeof(Elf_Sym); i++) {
	const char *name = info->strtab + sym[i].st_name;

St_shndx फ़ील्ड में उस अनुभाग का हेडर इंडेक्स होता है जिसमें यह वर्ण परिभाषित होता है। यदि कोई शून्य मान (हमारा मामला) है, तो यह प्रतीक मॉड्यूल के अंदर नहीं है, आपको इसे कर्नेल में देखने की आवश्यकता है:

	switch (sym[i].st_shndx) {
	.....
	 case SHN_UNDEF: //  0
	ksym = resolve_symbol_wait(mod, info, name);
 	/* Ok if resolved.  */
	if (ksym && !IS_ERR(ksym)) {
		sym[i].st_value = kernel_symbol_value(ksym);
		break;
	}

उसके बाद apply_relocations फ़ंक्शन में स्थानांतरण कतार आती है:

static int apply_relocations(struct module *mod, const struct load_info *info)
{
	unsigned int i;
	int err = 0;

	/* Now do relocations. */
	for (i = 1; i < info->hdr->e_shnum; i++) {
	.....

लूप में, हम रिलोकेशन सेक्शन की तलाश करते हैं और प्रत्येक सेक्शन के रिकॉर्ड्स को apply_relocate_add फ़ंक्शन में प्राप्त करते हैं:

if (info->sechdrs[i].sh_type == SHT_RELA) //   
	err = apply_relocate_add(info->sechdrs, info->strtab,
				info->index.sym, i, mod);

सेक्शन हेडर टेबल के लिए एक पॉइंटर, सिंबल नेम टेबल के लिए एक पॉइंटर, सिंबल टेबल के साथ एक सेक्शन हैडर इंडेक्स, और एक रीवोकेशन सेक्शन हेडर इंडेक्स को apply_relocate_add पास किया जाता है:

int apply_relocate_add(Elf64_Shdr *sechdrs,
	   const char *strtab,
	   unsigned int symindex,
	   unsigned int relsec,
	   struct module *me)
{

पहले हम स्थानांतरण खंड को संबोधित करते हैं:

Elf64_Rela *rel = (void *)sechdrs[relsec].sh_addr;

फिर, एक लूप में, हम इसकी प्रविष्टियों की एक सरणी के माध्यम से सॉर्ट करते हैं:

for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {

हम स्थानांतरण के लिए अनुभाग ढूंढते हैं और इसमें स्थिति, अर्थात्। जहां हमें बदलाव करने की जरूरत है। स्थानांतरण अनुभाग हेडर का sh_info क्षेत्र स्थानांतरण के लिए अनुभाग शीर्षलेख का सूचकांक है, स्थानांतरण रिकॉर्ड का r_offset क्षेत्र स्थानांतरण के लिए खंड के अंदर स्थिति के लिए ऑफसेट है:

/* This is where to make the change */
loc = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr + rel[i].r_offset;

इस स्थिति में प्रतिस्थापित किए जाने वाले चरित्र का पता, परिशिष्ट को ध्यान में रखते हुए। स्थानांतरण प्रविष्टि के r_info फ़ील्ड में प्रतीक तालिका में इस चिह्न का सूचकांक शामिल है:

	/* This is the symbol it is referring to.  Note that all
	   undefined symbols have been resolved.  */
	sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
		+ ELF64_R_SYM(rel[i].r_info);

	val = sym->st_value + rel[i].r_addend;

स्थानांतरण का प्रकार गणना के अंतिम परिणाम को निर्धारित करता है, हमारे उदाहरण में यह R_X86_64_PLT32 है:

	switch (ELF64_R_TYPE(rel[i].r_info)) {
	......
	case R_X86_64_PLT32:	
		if (*(u32 *)loc != 0)
			goto invalid_relocation;
		val -= (u64)loc;	//   
		*(u32 *)loc = val;  //    
		break;
	.....

अब हम खुद अंतिम वैल की गणना कर सकते हैं, यह जानते हुए कि sym-> st_value प्रिंटक फ़ंक्शन का पता है 0xffffffff810b3df9, r_addend (-4) है, रिलोकेशन की स्थिति की भरपाई मॉड्यूल के टेक्स्ट सेक्शन की शुरुआत से 0xd या फ़ंक्शन फू की शुरुआत से ix, i.e. ffffffffc000000d होगा। इन सभी मूल्यों को प्रतिस्थापित करें और प्राप्त करें:

val = (u32)(0xffffffff810b3df9 - 0x4 - 0xffffffffc000000d) = 0xc10b3de8

आइए foo फ़ंक्शन के डंप को देखें, जो हमें बहुत शुरुआत में मिला था:

53 89 fe 89 fb 48 c7 c7 24 10 00 c0 e8 e8 3d 0b c1 8d 43 02 5b c3 66 2e 0f

ऑफसेट 0xD पर, मान 0xc10b3de8 पाया जाता है, जो हमारे द्वारा गणना की गई के समान है।

यह है कि कर्नेल स्थानांतरित कैसे करता है और करीबी कॉल कमांड के लिए आवश्यक ऑफसेट प्राप्त करता है।

लेख तैयार करने में, लिनक्स कर्नेल संस्करण 5.4.27 का उपयोग किया गया था।

लिनक्स कर्नेल में स्थानांतरण के बारे में थोड़ा

More articles: