Ptrace का उपयोग कर इंटरसेप्टिंग सिस्टम कॉल

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

यह आलेख एक उदाहरण के रूप में लिनक्स ओएस का उपयोग करके सिस्टम कॉल को इंटरसेप्ट करने के तरीके को प्रदर्शित करेगा।

1. ptrace के बारे में थोड़ा

यहाँ क्या ptrace फ़ंक्शन का प्रोटोटाइप दिखता है:

#include <sys/ptrace.h>
long ptrace( enum __ptrace_request request, pid_t pid, void *addr, void *data);

• अनुरोध एक कार्रवाई करने के लिए है, उदाहरण के लिए PTRACE_CONT, PTRACE_PEEKTEXT
• pid - ट्रेस की गई प्रक्रिया की पहचानकर्ता
• Addr और डेटा अनुरोध पर निर्भर करता है

आप दो तरीकों से ट्रेसिंग शुरू कर सकते हैं: पहले से चल रही प्रक्रिया (PTRACE_ATTACH) से जुड़ने के लिए, या PTRACE_TRACEME का उपयोग करके स्वयं इसे शुरू करने के लिए। हम दूसरे मामले पर विचार करेंगे, यह थोड़ा सरल है, लेकिन सार समान है। ट्रेस को नियंत्रित करने के लिए आप निम्न तर्कों का उपयोग कर सकते हैं:

• PTRACE_SINGLESTEP - चरण-दर-चरण कार्यक्रम निष्पादन, प्रत्येक निर्देश के निष्पादित होने के बाद नियंत्रण स्थानांतरित किया जाएगा; इस तरह के निशान काफी धीमा है
• PTRACE_SYSCALL - प्रोग्राम को तब तक जारी रखें जब तक सिस्टम कॉल दर्ज या बाहर नहीं हो जाता
• PTRACE_CONT - बस प्रोग्राम निष्पादन जारी रखें

अधिक जानकारी के लिए, आदमी ptrace देखें।

2. सिस्टम कॉल देखें

हम प्रोग्राम द्वारा प्रयुक्त सिस्टम कॉल की एक सूची प्रदर्शित करने के लिए एक प्रोग्राम लिखेंगे (स्ट्रेस यूटिलिटी का एक सरल एनालॉग)।

तो, पहले आपको एक कांटा बनाने की आवश्यकता है - माता-पिता की प्रक्रिया बच्चे को डिबग करेगी:

int main( int argc, char *argv[]) {
pid_t pid = fork();
if (pid)
parent(pid);
else
child();
return 0;
}

बच्चे की प्रक्रिया में, सब कुछ सरल है - PTRACE_TRACEME के ​​साथ ट्रेस शुरू करें और वांछित कार्यक्रम चलाएं:

void child() {
ptrace(PTRACE_TRACEME, 0, 0, 0);
execl( "/bin/echo" , "/bin/echo" , "Hello, world!" , NULL);
perror( "execl" );
}

जब निष्पादन निष्पादित होता है, तो ट्रेस की गई प्रक्रिया माता-पिता के लिए अपना नया राज्य पास करना बंद कर देगी। इसलिए, पैरेंट प्रक्रिया को पहले वेटपिड का उपयोग शुरू करने के लिए कार्यक्रम की प्रतीक्षा करनी चाहिए (आप बस इंतजार कर सकते हैं, क्योंकि केवल एक बच्चे की प्रक्रिया है):

int status;
waitpid(pid, &status, 0);

सिस्टम कॉल और अन्य स्टॉप्स (उदाहरण के लिए, SIGTRAP) के बीच किसी तरह अंतर करने के लिए, एक विशेष पैरामीटर PTRACE_O_TRACESYSGOOD प्रदान किया जाता है - जब सिस्टम कॉल बंद हो जाता है, तो मूल प्रक्रिया SIGTRAP प्राप्त होगी। 0x80 :

ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACESYSGOOD);

अब आप प्रोग्राम से बाहर निकलने से पहले एक पाश में PTRACE_SYSCALL निष्पादित कर सकते हैं, और सिस्टम कॉल नंबर निर्धारित करने के लिए eax रजिस्टर के मूल्य को देख सकते हैं। ऐसा करने के लिए, PTRACE_GETREGS का उपयोग करें। यह ध्यान दिया जाना चाहिए कि रोक के समय ईएक्सएक्स रजिस्टर को बदल दिया गया है, और इसलिए सहेजे गए राज्य का उपयोग करना आवश्यक है ।orig_x :

while (!WIFEXITED(status)) {

struct user_regs_struct state;

ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, &status, 0);

// at syscall
if (WIFSTOPPED(status) && WSTOPSIG(status) & 0x80) {
ptrace(PTRACE_GETREGS, pid, 0, &state);
printf( "SYSCALL %d at %08lx\n" , state.orig_eax, state.eip);

// skip after syscall
ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, &status, 0);
}

}

कार्यक्रम को चलाने पर, हम कुछ इस तरह देखते हैं:

...
SYSCALL 6 at b783a430
SYSCALL 197 at b783a430
SYSCALL 192 at b783a430
SYSCALL 4 at b783a430
Hello, world!
SYSCALL 6 at b783a430
SYSCALL 91 at b783a430
SYSCALL 6 at b783a430
SYSCALL 252 at b783a430

जैसा कि आप देख सकते हैं, सिस्टम कॉल नंबर 4 के बाद (और यह sys_write है ), हमारा पाठ प्रदर्शित होता है।

3. एक सिस्टम कॉल को इंटरसेप्ट करना

अब चुनौती को रोकने और कुछ अच्छा करने की कोशिश करते हैं। लेखन प्रणाली कॉल इस तरह दिखता है:

write(fd, buf, n);

• ebx: fd - फाइल डिस्क्रिप्टर (संख्या)
• ecx: buf - प्रदर्शित करने के लिए पाठ के लिए एक सूचक
• edx: n - बाइट्स की संख्या

पाठ को बदलने के लिए, PTRACE_POKETEXT का उपयोग करें:

// sys_write
if (state.orig_eax == 4) {
char * text = ( char *)state.ecx;
ptrace(PTRACE_POKETEXT, pid, ( void *)(text+7), 0x72626168); //habr
ptrace(PTRACE_POKETEXT, pid, ( void *)(text+11), 0x00000a21); //!\n
}

हम लॉन्च करते हैं, और ...

...
SYSCALL 6 at 00556416
SYSCALL 197 at 00556416
SYSCALL 192 at 00556416
SYSCALL 4 at 00556416
Hello, habr!
SYSCALL 6 at 00556416
SYSCALL 91 at 00556416
SYSCALL 6 at 00556416
SYSCALL 252 at 00556416

इस प्रकार, हमने अपने पाठ को आउटपुट करने के लिए / बिन / गूंज कार्यक्रम में sys_write सिस्टम कॉल को इंटरसेप्ट किया। यह ptrace का उपयोग करने का सिर्फ एक सरल उदाहरण है। इसका उपयोग आसानी से मेमोरी डंप बनाने के लिए किया जा सकता है (यह वैसे, लिनक्स क्रैकमिक्स को हल करते समय बहुत मदद करता है), ब्रेकपॉइंट्स सेट करें (PTRACE_SINGLESTEP का उपयोग करें या निर्देश को 0xCC के साथ बदलकर), विश्लेषण / चर और अधिक का विश्लेषण करें। ptrace बहुत उपयोगी है, उदाहरण के लिए, जब आप जल्दी से कोड के समस्या वाले हिस्से में नहीं आ सकते हैं - अगर आपको डिबगर में डेटा को कूदना और बदलना है, और फिर प्रोग्राम मर जाता है और आपको सब कुछ नया करना होगा; यदि आप ptrace के साथ डिबगिंग के लिए कोई प्रोग्राम लिखते हैं, तो इन सभी कार्यों को केवल एक बार वर्णित करने की आवश्यकता होती है, और वे स्वचालित रूप से निष्पादित होंगे। बेशक, कुछ डिबगर में आप स्क्रिप्ट लिख सकते हैं - लेकिन वे शायद क्षमताओं में हीन हैं।

UPD: पूर्ण स्रोत पोस्ट करना भूल गया

4. क्या पढ़ना है

आदमी ptrace
आदमी रुको
पीट्रेस के साथ खेलना, भाग I
Ptrace के साथ खेल, भाग II
syscalls तालिका