👨‍👧‍👦 🚵🏻 🚻 लिनक्स पर मेमोरी से एक गतिशील पुस्तकालय लोड हो रहा है 👨🏽‍🚒 👩‍⚖️ 🍅

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

खुले, एमएमएपी और अन्य कार्यों को रोकना असंभव है, क्योंकि ld.so को वैधानिक रूप से पुस्तकालय से जोड़ा जाता है, उनके लोडर द्वारा लोड की गई निष्पादन योग्य फाइलें "अवर" (यहां तक कि libdl में कार्यों के अवरोधन के साथ) हैं, वे लोड किए गए पुस्तकालयों और / या की सूची में पंजीकृत नहीं हैं। उनके चरित्र डैल्सम के माध्यम से दिखाई नहीं देते हैं। नतीजतन, केवल सिस्टम कॉल का अवरोधन रहता है।

बूटलोडर प्रवेश बिंदु:

void *dlopen_memory(void *base, size_t size, void *(*custom_dlopen)(const char *filename, void *arg), void *arg);

विकल्प:

आधार - आधार पता जिस पर छवि अपलोड की गई है। इस फ़ंक्शन को पूरा करने के बाद अब ज़रूरत नहीं है और इसे जारी किया जा सकता है।
आकार - बाइट्स में छवि का आकार।
custom_dlopen - dlopen पर कस्टम आवरण। यदि आप कुछ लाइब्रेरी फ़ंक्शन का उपयोग करके मेमोरी से लाइब्रेरी लोड करना चाहते हैं, तो इसका उपयोग किया जा सकता है, जिसे dlopen कहते हैं। अगर जरूरत न हो तो NULL को पास करें।
arg custom_dlopen के लिए एक वैकल्पिक पैरामीटर है।

वापसी मान dlopen के समान है: लाइब्रेरी हैंडल या NULL और dlerror () के माध्यम से त्रुटि विवरण।

यह निम्नानुसार काम करता है:

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

बच्चे की प्रक्रिया निम्नलिखित क्रियाएं करती है:

अपने माता-पिता का पता लगाने के लिए शुरू होता है। यह कुछ दिलचस्प परिणामों की ओर जाता है, उदाहरण के लिए, वह अपने माता-पिता का पिता बन जाता है।
मूल प्रक्रिया में तैयार ध्वज सेट करता है।
जबकि मूल प्रक्रिया चल रही है और एक स्टॉप का अनुरोध नहीं किया गया है:
1. सिस्टम कॉल दर्ज करने से पहले मूल प्रक्रिया चलती है। यदि सिस्टम कॉल एक mmap छद्म फ़ाइल नहीं है, तो कॉल से बाहर निकलने से पहले भी प्रक्रिया चलती है।
2. बाल प्रक्रिया के रजिस्टरों को पुनः प्राप्त किया जाता है।
3. यदि यह कॉल मूल प्रक्रिया के लिए SIGQUIT कॉल करने के लिए है, तो ट्रेसिंग बंद हो जाती है।
4. यदि यह कॉल एक लाइब्रेरी छद्म फ़ाइल का उद्घाटन है, तो आउटपुट डिस्क्रिप्टर को एक विशेष डिस्क्रिप्टर से बदल दिया जाता है, जिसका उपयोग छद्म फ़ाइल के साथ संचालन की पहचान करने के लिए किया जाता है।
5. यदि यह कॉल एक छद्म फाइल से रीडिंग है, तो लाइब्रेरी इमेज से लेकर पेरेंट प्रोसेस के बफर तक रीडिंग की जाती है और कॉल सफलतापूर्वक पूरा हो जाता है।
6. यदि यह कॉल फ़ाइल विशेषताओं को प्राप्त करने के लिए है, तो छद्म फ़ाइल के बारे में जानकारी जनक प्रक्रिया के बफर में उत्पन्न और रखी जाती है (इसमें, केवल आकार समझ में आता है)।
7. यदि यह कॉल एक फ़ाइल के करीब है, तो कॉल सफलतापूर्वक पूरा होता है।
8. यदि यह कॉल मेमोरी में किसी छद्म फ़ाइल का मानचित्रण है, तो निम्नलिखित क्रियाएं की जाती हैं:
  1. MAP_ANONYMOUS ध्वज सेट किया गया है (स्मृति का एक क्षेत्र जिसे फ़ाइल में मैप नहीं किया गया है) का अनुरोध किया गया है।
  2. एमएमएपी कॉल जारी है।
  3. मूल प्रक्रिया में निर्मित क्षेत्र में, छद्म फ़ाइल का अनुरोधित भाग कॉपी किया गया है।
प्रक्रिया पैरेंट से डिस्कनेक्ट हो जाती है और बाहर निकल जाती है।

यह कोड पोर्टेबल नहीं है और यह केवल लिनक्स पर और केवल 32-बिट मोड में IA-32 आर्किटेक्चर के प्रोसेसर पर काम करेगा। एक अलग आर्किटेक्चर के सिस्टम के लिए, सिस्टम कॉल के अनुकरण को लागू करने के लिए (यदि # # अंत में रैपिंग) आवश्यक है, सिस्टम के लिए एक अलग शब्द लंबाई के साथ, तो यह भी आवश्यक है कि पीकस्ट्रिंग प्रक्रिया को बदलना आवश्यक है। यदि ptrace या Waitpid पर कॉल विफल हो जाता है, तो माता-पिता और बच्चे की प्रक्रिया दोनों का काम समाप्त हो जाएगा। यदि आपको एक अलग व्यवहार की आवश्यकता है, तो असफल लेबल के पीछे हैंडलर को फिर से लिखें।

कोड बिना किसी प्रतिबंध के मुफ्त उपयोग के लिए उपलब्ध है।

 #include <sys/mman.h> #include <sys/ptrace.h> #include <string.h> #include <stdlib.h> #include <assert.h> #include <time.h> #include <stdio.h> #include <sched.h> #include <unistd.h> #include <signal.h> #include <sys/wait.h> #include <sys/user.h> #include <sys/syscall.h> #include <dlfcn.h> #include <errno.h> #include <limits.h> #include <fcntl.h> #include <sys/stat.h> #define min(a, b) ((a) < (b) ? (a) : (b)) static void generate_name(char *name, size_t length) { assert(length > 5); strcpy(name + length - 4, ".so"); for(unsigned int i = 1; i < length - 4; i++) name[i] = rand() % ('Z' - 'A' + 1) + 'A'; name[0] = '/'; } static void quit_handler(int sig) { (void) sig; } static int peekstring(pid_t pid, void *base, char *dest, size_t length) { unsigned int word; unsigned int offset = 0; do { word = ptrace(PTRACE_PEEKDATA, pid, base + offset, NULL); memcpy(dest + offset, &word, sizeof(unsigned int)); offset += sizeof(unsigned int); } while((word & 0xFF) && (word & 0xFF00) && (word & 0xFF0000) && (word & 0xFF000000) && offset < length); dest[length - 1] = 0; return 0; } static int pokedata(pid_t pid, void *address, const void *data, size_t length) { length = (length + sizeof(unsigned int) - 1) & ~(sizeof(unsigned int) - 1); const unsigned int *src = data; for(unsigned int offset = 0; offset < length; offset += sizeof(unsigned int)) { if(ptrace(PTRACE_POKEDATA, pid, address + offset, (void *) *src++) == -1) return -1; } return 0; } void *dlopen_memory(void *base, size_t size, void *(*custom_dlopen)(const char *filename, void *arg), void *arg) { char fakename[16]; int ready = 0; unsigned int offset = 0; generate_name(fakename, sizeof(fakename)); struct sigaction old_handler, new_handler = { .sa_handler = quit_handler, .sa_flags = 0, .sa_restorer = NULL }; sigfillset(&new_handler.sa_mask); if(sigaction(SIGQUIT, &new_handler, &old_handler) == -1) return NULL; pid_t child = fork(); if(child == -1) { sigaction(SIGQUIT, &old_handler, NULL); return NULL; } else if(child == 0) { pid_t parent = getppid(); if(ptrace(PTRACE_ATTACH, parent, NULL, NULL) == -1) { kill(parent, SIGKILL); _exit(1); } ready = 1; if(ptrace(PTRACE_POKEDATA, parent, &ready, (void *)ready) == -1) goto fail; int status; char path[PATH_MAX]; int handle = getdtablesize(); do { struct user_regs_struct regs; for(int i = 0; i < 2; i++) { if(ptrace(PTRACE_SYSCALL, parent, NULL, NULL) == -1) goto fail; if(waitpid(parent, &status, 0) == -1) goto fail; if(!WIFSTOPPED(status)) goto outer_break; if(ptrace(PTRACE_GETREGS, parent, NULL, ®s) == -1) goto fail; if(regs.orig_eax == SYS_mmap2 && regs.edi == handle) break; } if(regs.orig_eax == SYS_kill && regs.ebx == parent && regs.ecx == SIGQUIT) { break; } else if(regs.orig_eax == SYS_open) { if(peekstring(parent, (void *) regs.ebx, path, PATH_MAX) == -1) goto fail; if(strcmp(path, fakename) != 0) continue; regs.eax = handle; offset = 0; } else if(regs.orig_eax == SYS_read && regs.ebx == handle) { unsigned int bytes = min((unsigned int) regs.edx, size - offset); if(pokedata(parent, (void *) regs.ecx, base + offset, bytes) == -1) goto fail; offset += bytes; regs.eax = bytes; } else if(regs.orig_eax == SYS_close && regs.ebx == handle) { regs.eax = 0; } else if(regs.orig_eax == SYS_fstat64 && regs.ebx == handle) { struct stat statbuf = { .st_dev = 0, .st_ino = 1, .st_mode = 0444, .st_nlink = 1, .st_uid = 0, .st_gid = 0, .st_rdev = 0, .st_size = size, .st_blksize = 512, .st_blocks = (size + 511) & ~511, .st_atim = { 0, 0 }, .st_mtim = { 0, 0 }, .st_ctim = { 0, 0 } }; if(pokedata(parent, (void *) regs.ecx, &statbuf, sizeof(struct stat)) == -1) goto fail; regs.eax = 0; } else if(regs.orig_eax == SYS_mmap2 && regs.edi == handle) { regs.esi |= MAP_ANONYMOUS; if(ptrace(PTRACE_SETREGS, parent, NULL, ®s) == -1) goto fail; if(ptrace(PTRACE_SYSCALL, parent, NULL, NULL) == -1) goto fail; if(waitpid(parent, &status, 0) == -1) goto fail; if(!WIFSTOPPED(status)) break; if(ptrace(PTRACE_GETREGS, parent, NULL, ®s) == -1) goto fail; unsigned int offset = regs.ebp * 4096; unsigned int bytes = min(size - offset, (unsigned int) regs.ecx); if(pokedata(parent, (void *) regs.eax, base + offset, bytes) < 0) { regs.eax = -errno; if(ptrace(PTRACE_SETREGS, parent, NULL, ®s) == -1) goto fail; } continue; } else if(regs.orig_eax == -1) break; if(ptrace(PTRACE_SETREGS, parent, NULL, ®s) == -1) goto fail; } while(1); outer_break: ptrace(PTRACE_DETACH, parent, NULL, NULL); _exit(0); fail: ptrace(PTRACE_KILL, parent, NULL, NULL); _exit(1); } while(ready == 0) sched_yield(); void *handle; if(custom_dlopen) handle = custom_dlopen(fakename, arg); else handle = dlopen(fakename, RTLD_NOW); kill(getpid(), SIGQUIT); waitpid(child, NULL, 0); sigaction(SIGQUIT, &old_handler, NULL); return handle; }

लिनक्स पर मेमोरी से एक गतिशील पुस्तकालय लोड हो रहा है

More articles: