पुस्तक "हैकिंग: द आर्ट ऑफ एक्सप्लॉइट। दूसरा संस्करण। ”

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

कहाँ से शुरू करें? बफर ओवरफ्लो का उपयोग करके मेमोरी को अधिलेखित करने के लिए, रिमोट सर्वर का उपयोग करें और इंटरसेप्ट कनेक्शन का उपयोग करें, आपको सी और असेंबलर में प्रोग्राम करना होगा, शेल कोड और प्रोसेसर रजिस्टरों का उपयोग करना होगा, नेटवर्क इंटरैक्शन और एन्क्रिप्शन और बहुत अधिक से परिचित होना होगा।

कोई फर्क नहीं पड़ता कि हम चमत्कारों में कितना विश्वास करना चाहते हैं, सॉफ्टवेयर और कंप्यूटर नेटवर्क जिस पर हमारे दैनिक जीवन में निर्भरता है, कमजोरियां हैं।

हैकर्स के बिना एक दुनिया जिज्ञासा और अभिनव समाधान के बिना एक दुनिया है। (जॉन एरिकसन)

countermeasures

इस तरह के मेंढक है - एक भयानक श्रवण (Phyllobates terribilis)। उसकी त्वचा की ग्रंथियों में सबसे मजबूत जहर होता है। घातक जहर पाने के लिए इसे स्पर्श करें। इस तरह के एक शक्तिशाली उपाय को इस तथ्य से समझाया गया है कि ये मेंढक कुछ विशेष प्रकार के साँपों को खिलाते हैं जिन्होंने जहर के लिए प्रतिरक्षा विकसित की है। धीरे-धीरे मेंढकों का जहर और मजबूत होता गया। इस तरह के संयुक्त विकास के परिणामस्वरूप, भयानक पत्तों के पर्वतारोहियों के पास कोई अन्य प्राकृतिक दुश्मन नहीं बचा है। ऐसा ही कुछ हैकर्स के साथ भी हो रहा है। उन्होंने जिन तकनीकों का आविष्कार किया था, वे लंबे समय से ज्ञात हैं, इसलिए प्रतिवादों का उद्भव काफी स्वाभाविक है। जवाब में, हैकर्स रक्षा तंत्र को दरकिनार करने और नष्ट करने के तरीकों की तलाश कर रहे हैं, जिससे नई रक्षात्मक तकनीकों का निर्माण होता है।

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

0x610 अटैक डिटेक्शन टूल

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

कमजोरियों का फायदा उठाने के ज्ञात तरीके सिस्टम एडमिनिस्ट्रेटर के लिए उतने खतरनाक नहीं हैं जितने कि उन्हें अभी तक पता नहीं है। जितनी जल्दी एक घुसपैठ का पता लगाया जा सकता है, उतनी ही जल्दी इसके साथ काम शुरू होगा और अधिक संभावना है कि यह स्थानीयकृत होगा। महीनों से चली आ रही घुसपैठ चिंता का एक गंभीर कारण है।

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

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

0x620 सिस्टम डेमॉन

हालांकि, एक व्यावहारिक उदाहरण का उपयोग करके हैकर और उनके वर्कअराउंड के काउंटरमेशर्स पर सबसे अच्छी चर्चा की जाती है। अब हम एक सर्वर प्रोग्राम पर हमले पर विचार करेंगे जो आने वाले कनेक्शनों को स्वीकार करता है। UNIX- जैसे ऑपरेटिंग सिस्टम पर, सिस्टम डेमॉन इन मानदंडों के लिए उपयुक्त हैं। एक डेमॉन एक कार्यक्रम है जो पृष्ठभूमि में चल रहा है और एक निश्चित तरीके से नियंत्रण टर्मिनल से अलग है। यह शब्द 1960 के दशक में मैसाचुसेट्स इंस्टीट्यूट ऑफ टेक्नोलॉजी के हैकर्स द्वारा बनाया गया था। प्रोटोटाइप एक पौराणिक प्राणी था जो भौतिक विज्ञानी जेम्स मैक्सवेल द्वारा एक मानसिक प्रयोग से अणुओं को छांट रहा था। मैक्सवेल दानव के पास आसानी से जटिल कार्यों को करने की अलौकिक क्षमता थी, जो ऊष्मप्रवैगिकी के दूसरे नियम का उल्लंघन करते थे। इसी तरह, लिनक्स सिस्टम डेमॉन बिना थके एसएसएच तक पहुंच प्रदान करने और सिस्टम लॉग बनाए रखने जैसे कार्य करता है। दानव नाम आमतौर पर डी के साथ समाप्त होता है, जो उनकी प्रकृति पर जोर देता है: उदाहरण के लिए, sshd या syslogd।

एक छोटे से संपादन से छोटे xweb.c को खंड 0x427 से एक सिस्टम डेमॉन के यथार्थवादी सादृश्य में बदल दिया जाएगा। कोड के नए संस्करण में डेमन () फ़ंक्शन शामिल है, जो एक नई पृष्ठभूमि प्रक्रिया को जन्म देता है। इसका उपयोग कई लिनक्स सिस्टम डेमन प्रक्रियाओं द्वारा किया जाता है। यहाँ निर्देशिका से उसे समर्पित पेज है:

DAEMON (3) लिनक्स प्रोग्रामर का संदर्भ DAEMON (3)

नाम
डेमॉन - पृष्ठभूमि में चलाते हैं
SYNOPSIS

#include <unistd.h> int daemon(int nochdir, int noclose); 

वर्णन

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

(यह फ़ंक्शन प्रक्रिया की एक प्रतिलिपि बनाता है, और यदि कांटा सफल होता है)
जनक _exit (0) निष्पादित करता है ताकि आगे त्रुटियां केवल दिखाई दे
बाल प्रक्रिया।) यदि सफल हो, तो शून्य देता है। त्रुटि पर, फ़ंक्शन
डेमॉन () रिटर्न -1 और एरर नंबर को ग्लोबल वैरिएबल इरनो में असाइन करता है
फॉर्क (2) और सेटसिड (2) की लाइब्रेरी से।

सिस्टम डेमॉन में एक नियंत्रण टर्मिनल नहीं होता है, इसलिए नए लिटिलवेब डेमॉन के लिए कोड लॉगबुक में आउटपुट करेगा। आम तौर पर संकेतों द्वारा राक्षसों को नियंत्रित किया जाता है। टाइनवेब के नए संस्करण को सही ढंग से बाहर निकलने के लिए एक पूर्ण सिग्नल प्राप्त करने में सक्षम होना चाहिए।

0x621 सिग्नल अवलोकन

सिग्नल UNIX पर अंतर-प्रक्रिया संचार प्रदान करते हैं। एक सिग्नल एक प्रक्रिया द्वारा प्राप्त होने के बाद, ऑपरेटिंग सिस्टम सिग्नल हैंडलर को आह्वान करने के लिए इसके निष्पादन को बाधित करता है। प्रत्येक सिग्नल का अपना नंबर और अपना हैंडलर होता है। उदाहरण के लिए, जब आप कुंजी संयोजन Ctrl + C दबाते हैं, तो एक रुकावट संकेत भेजा जाता है, जिसमें से हैंडलर उस प्रोग्राम को समाप्त कर देता है जो नियंत्रण टर्मिनल पर खुला है, भले ही वह एक अनंत लूप दर्ज किया हो।

आप अपने स्वयं के सिग्नल हैंडलर बना सकते हैं और सिग्नल () फ़ंक्शन का उपयोग करके उन्हें पंजीकृत कर सकते हैं। आइए एक कोड देखें जिसमें कुछ संकेतों के लिए कई हैंडलर पंजीकृत हैं, और मुख्य भाग में एक अनंत लूप है।

 signal_example.c #include <stdio.h> #include <stdlib.h> #include <signal.h> /*    signal.h * #define SIGHUP 1  * #define SIGINT 2  (Ctrl+C) * #define SIGQUIT 3  (Ctrl+\) * #define SIGILL 4   * #define SIGTRAP 5   * #define SIGABRT 6  * #define SIGBUS 7   * #define SIGFPE 8     * #define SIGKILL 9   * #define SIGUSR1 10   1 * #define SIGSEGV 11   * #define SIGUSR2 12   2 * #define SIGPIPE 13    ,    * #define SIGALRM 14   ,  alarm() * #define SIGTERM 15  (  kill) * #define SIGCHLD 17    * #define SIGCONT 18 ,    * #define SIGSTOP 19  (  ) * #define SIGTSTP 20   [] (Ctrl+Z) * #define SIGTTIN 21       * #define SIGTTOU 22       */ /*   */ void signal_handler(int signal) { printf("  %d\t", signal); if (signal == SIGTSTP) printf("SIGTSTP (Ctrl-Z)"); else if (signal == SIGQUIT) printf("SIGQUIT (Ctrl-\\)"); else if (signal == SIGUSR1) printf("SIGUSR1"); else if (signal == SIGUSR2) printf("SIGUSR2"); printf("\n"); } void sigint_handler(int x) { printf(" Ctrl-C (SIGINT)   \nExiting.\n"); exit(0); } int main() { /* Registering signal handlers */ signal(SIGQUIT, signal_handler); //  signal_handler() signal(SIGTSTP, signal_handler); //    signal(SIGUSR1, signal_handler); signal(SIGUSR2, signal_handler); signal(SIGINT, sigint_handler); //  sigint_handler()  SIGINT while(1) {} //   } 

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

 reader@hacking:~/booksrc $ gcc -o signal_example signal_example.c reader@hacking:~/booksrc $ ./signal_example   20 SIGTSTP (Ctrl-Z)   3 SIGQUIT (Ctrl-\)  Ctrl-C (SIGINT)    Exiting. reader@hacking:~/booksrc $ 

मार कमांड आपको एक प्रक्रिया के लिए संकेतों का एक पूरा सेट भेजने की अनुमति देता है। डिफ़ॉल्ट रूप से, यह एक पूर्ण सिग्नल (SIGTERM) भेजता है। -L विकल्प में इसे जोड़ने से सभी संभावित संकेतों की एक सूची प्रदर्शित होती है। आइए देखें कि सिग्नल_एक्सप्लिमेंट प्रोग्राम किसी अन्य टर्मिनल पर कैसे चल रहा है, सिग्नल SIGUSR1 और SIGUSR2 भेजता है।

 reader@hacking:~/booksrc $ kill -l 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2 13) SIGPIPE     14) SIGALRM     15) SIGTERM     16) SIGSTKFLT 17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP 21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU 25) SIGXFSZ     26) SIGVTALRM   27) SIGPROF     28) SIGWINCH 29) SIGIO       30) SIGPWR      31) SIGSYS      34) SIGRTMIN 35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3  38) SIGRTMIN+4 39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8 43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7  58) SIGRTMAX-6 59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2 63) SIGRTMAX-1  64) SIGRTMAX reader@hacking:~/booksrc $ ps a | grep signal_example 24491 pts/3    R+     0:17 ./signal_example 24512 pts/1    S+     0:00 grep signal_example reader@hacking:~/booksrc $ kill -10 24491 reader@hacking:~/booksrc $ kill -12 24491 reader@hacking:~/booksrc $ kill -9 24491 reader@hacking:~/booksrc $ 

अंत में, किल -9 SIGKILL सिग्नल भेजता है। सिग्नल हैंडलर को बदला नहीं जा सकता है, इसलिए किल -9 कमांड हमेशा प्रक्रियाओं को मारने के लिए उपयोग किया जाता है। एक अन्य टर्मिनल पर शुरू किया गया signal_example कार्यक्रम दर्शाता है कि सिग्नल इंटरसेप्ट किए गए थे और प्रक्रिया नष्ट हो गई थी।

 reader@hacking:~/booksrc $ ./signal_example   10       SIGUSR1   12       SIGUSR2 Killed reader@hacking:~/booksrc $ 

संकेत खुद बहुत सरल हैं, लेकिन प्रक्रियाओं के बीच बातचीत जल्दी से निर्भरता के एक जटिल वेब में बदल सकती है। सौभाग्य से, हमारे छोटे से डेमॉन में, संकेतों का उपयोग केवल सही शटडाउन के लिए किया जाता है, और सब कुछ बहुत सरलता से लागू किया जाता है।

0x622 टाइनीवेब डेमन

स्मॉलवेब का नया संस्करण एक सिस्टम डेमॉन है जो नियंत्रण टर्मिनल के बिना पृष्ठभूमि में लॉन्च किया गया है। आउटपुट डेटा को टाइम स्टैम्प के साथ लॉगबुक पर लिखा जाता है, और कार्य को सही ढंग से पूरा करने के लिए प्रोग्राम स्वयं SIGTERM सिग्नल की प्रतीक्षा करता है।

मूल में किए गए परिवर्तन बहुत महत्वपूर्ण नहीं हैं, लेकिन वे भेद्यता की शोषण प्रक्रिया का अधिक यथार्थवादी अध्ययन करने की अनुमति देते हैं। नए कोड टुकड़े बोल्ड में हैं।

 tinywebd.c #include <sys/stat.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <time.h> #include <signal.h> #include "hacking.h" #include "hacking-network.h" #define PORT 80 // ,     #define WEBROOT "./webroot" //   - #define LOGFILE "/var/log/tinywebd.log" //    int logfd, sockfd; //       void handle_connection(int, struct sockaddr_in *, int); int get_file_size(int); //         //  void timestamp(int); //        //       void handle_shutdown(int signal) { timestamp(logfd); write(logfd, " .\n", 16); close(logfd); close(sockfd); exit(0); } int main(void) { int new_sockfd, yes=1; struct sockaddr_in host_addr, client_addr; //    socklen_t sin_size; logfd = open(LOGFILE, O_WRONLY|O_CREAT|O_APPEND, S_IRUSR|S_IWUSR); if(logfd == -1) fatal("  ");  if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1)        fatal(" "); if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) fatal("   SO_REUSEADDR"); printf("  tiny web.\n"); if(daemon(1, 0) == -1) //    fatal("   "); signal(SIGTERM, handle_shutdown);   //    handle_shutdown signal(SIGINT, handle_shutdown);   //    handle_shutdown timestamp(logfd); write(logfd, ".\n", 15); host_addr.sin_family = AF_INET;       //    host_addr.sin_port = htons(PORT);     //  ,    host_addr.sin_addr.s_addr = INADDR_ANY; //    IP memset(&(host_addr.sin_zero), '\0', 8); //    if (bind(sockfd, (struct sockaddr *)&host_addr, sizeof(struct sockaddr)) == -1) fatal("  "); if (listen(sockfd, 20) == -1) fatal("   "); while(1) { //   accept sin_size = sizeof(struct sockaddr_in); new_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &sin_size); if(new_sockfd == -1) fatal(" "); handle_connection(new_sockfd, &client_addr, logfd); } return 0; } /*         *         FD. *    -,    *   .     . */ void handle_connection(int sockfd, struct sockaddr_in *client_addr_ptr, int logfd) { unsigned char *ptr, request[500], resource[500], log_buffer[500]; int fd, length; length = recv_line(sockfd, request); sprintf(log_buffer, " %s:%d \"%s\"\t", inet_ntoa(client_addr_ptr->sin_addr), ntohs(client_addr_ptr->sin_port), request); ptr = strstr(request, " HTTP/"); //    if(ptr == NULL) { //    HTTP  strcat(log_buffer, "  HTTP!\n"); } else { *ptr = 0; //      URL ptr = NULL; //  ptr  NULL (           //  ) if(strncmp(request, "GET ", 4) == 0) //  GET ptr = request+4; // ptr -  URL if(strncmp(request, "HEAD ", 5) == 0) //  HEAD ptr = request+5; // ptr -  URL if(ptr == NULL) { //     strcat(log_buffer, "  !\n"); } else { //    ptr,     if (ptr[strlen(ptr) - 1] == '/')   //  ,                                        //  '/', strcat(ptr, "index.html");   //    'index.html' strcpy(resource, WEBROOT);   //  resource                                            //  strcat(resource, ptr);   //      fd = open(resource, O_RDONLY, 0);  //    if(fd == -1) { //     strcat(log_buffer, " 404 Not Found\n");           send_string(sockfd, "HTTP/1.0 404 NOT FOUND\r\n");                send_string(sockfd, "Server: Tiny webserver\r\n\r\n");                send_string(sockfd, "<html><head><title>404 Not Found</title>                                     </head>");            send_string(sockfd, "<body><h1>URL not found</h1></body></html>                                     \r\n"); } else {       //      strcat(log_buffer, " 200 OK\n");             send_string(sockfd, "HTTP/1.0 200 OK\r\n");           send_string(sockfd, "Server: Tiny webserver\r\n\r\n");            if(ptr == request + 4) { //    GET     if( (length = get_file_size(fd)) == -1)          fatal("     ");     if( (ptr = (unsigned char *) malloc(length)) == NULL)          fatal("      ");          read(fd, ptr, length);  //              send(sockfd, ptr, length, 0);  //              free(ptr);  //      } close(fd); //   } //   if  /        } //   if     } //   if    HTTP timestamp(logfd); length = strlen(log_buffer); write(logfd, log_buffer, length); //    shutdown(sockfd, SHUT_RDWR); //    } /*         *    .    -1. */ int get_file_size(int fd) { struct stat stat_struct; if(fstat(fd, &stat_struct) == -1) return -1; return (int) stat_struct.st_size; } /*          *   . */ void timestamp(fd) { time_t now; struct tm *time_struct; int length; char time_buffer[40]; time(&now); //       time_struct = localtime((const time_t *)&now); //    tm length = strftime(time_buffer, 40, "%m/%d/%Y %H:%M:%S> ", time_struct); write(fd, time_buffer, length); //       } 

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

यहां कार्यक्रम को संकलित करने, निष्पादित करने और पूरा करने का परिणाम है। लॉग में टाइमस्टैम्प पर ध्यान दें और प्रोग्राम पूरा होने के बाद दिखाई देने वाले संदेश को संबंधित सिग्नल मिलते हैं और हैंडल_शूटडाउन () फ़ंक्शन को कहते हैं।

 reader@hacking:~/booksrc $ gcc -o tinywebd tinywebd.c reader@hacking:~/booksrc $ sudo chown root ./tinywebd reader@hacking:~/booksrc $ sudo chmod u+s ./tinywebd reader@hacking:~/booksrc $ ./tinywebd   tiny web. reader@hacking:~/booksrc $ ./webserver_id 127.0.0.1 The web server for 127.0.0.1 is Tiny webserver reader@hacking:~/booksrc $ ps ax | grep tinywebd 25058 ? Ss 0:00 ./tinywebd 25075 pts/3 R+ 0:00 grep tinywebd reader@hacking:~/booksrc $ kill 25058 reader@hacking:~/booksrc $ ps ax | grep tinywebd 25121 pts/3 R+ 0:00 grep tinywebd reader@hacking:~/booksrc $ cat /var/log/tinywebd.log cat: /var/log/tinywebd.log: Permission denied reader@hacking:~/booksrc $ sudo cat /var/log/tinywebd.log 07/22/2007 17:55:45> . 07/22/2007 17:57:00>  127.0.0.1:38127 "HEAD / HTTP/1.0" 200 OK 07/22/2007 17:57:21>  . reader@hacking:~/booksrc $ 

नया लिटिलवेब प्रोग्राम HTTP कंटेंट को ऑरिजनल लिटिलवेब की तरह प्रोसेस करता है, लेकिन सिस्टम डेमॉन की तरह व्यवहार करता है क्योंकि इसमें कंट्रोल टर्मिनल नहीं होता है और आउटपुट लॉग फाइल में होता है। दोनों कार्यक्रम एक ही बफर अतिप्रवाह के लिए असुरक्षित हैं - लेकिन यह इस भेद्यता की शुरुआत है। अब जब हमने टाइटलवेब को हमले के लक्ष्य के रूप में चुना है, तो मैं आपको दिखाऊंगा कि किसी अन्य मशीन में प्रवेश करने के बाद पता लगाने से कैसे बचें।

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

Habrozhitel के लिए कूपन पर 20% की छूट - हैकिंग