Python is a versatile programming language.

पाइथन एक बहुमुखी प्रोग्रामिंग भाषा है।


Hackers often use Python for its ease of use and powerful libraries.

हैकर अक्सर पाइथन का उपयोग इसकी उपयोग में आसानी और शक्तिशाली पुस्तकालयों के लिए करते हैं।


The book explains how to build your own debugger.

यह पुस्तक बताती है कि अपना खुद का डिबगर कैसे बनाएं।


You will learn about fuzzing Windows drivers.

आप विंडोज ड्राइवरों को फ़ज़िंग के बारे में जानेंगे।


The author, Justin Seitz, is a security researcher.

लेखक, जस्टिन सीट्ज़, एक सुरक्षा शोधकर्ता हैं।


This book is for those interested in computer security.

यह पुस्तक उन लोगों के लिए है जो कंप्यूटर सुरक्षा में रुचि रखते हैं।


The book covers topics like code injection and hooking.

यह पुस्तक कोड इंजेक्शन और हुकिंग जैसे विषयों को शामिल करती है।


Python is becoming the language of choice for many security professionals.

पाइथन कई सुरक्षा पेशेवरों के लिए पसंद की भाषा बन रही है।


The book provides practical examples and code snippets.

यह पुस्तक व्यावहारिक उदाहरण और कोड स्निपेट प्रदान करती है।


You can automate many reversing and security tasks with Python.

आप पाइथन के साथ कई रिवर्सिंग और सुरक्षा कार्यों को स्वचालित कर सकते हैं।


The book teaches how to sniff secure traffic.

यह पुस्तक सिखाती है कि सुरक्षित ट्रैफ़िक को कैसे सूंघा जाए।


It also covers the use of tools like PyDBG and Immunity Debugger.

यह PyDBG और Immunity Debugger जैसे उपकरणों के उपयोग को भी शामिल करता है।


The book is a guide for hackers and reverse engineers.

यह पुस्तक हैकर्स और रिवर्स इंजीनियरों के लिए एक मार्गदर्शिका है।


The author explains the concepts behind hacking tools.

लेखक हैकिंग टूल के पीछे की अवधारणाओं की व्याख्या करता है।


The book helps you build your own security tools.

यह पुस्तक आपको अपने स्वयं के सुरक्षा उपकरण बनाने में मदद करती है।


The book is a valuable resource for anyone interested in cybersecurity.

यह पुस्तक साइबर सुरक्षा में रुचि रखने वाले किसी भी व्यक्ति के लिए एक मूल्यवान संसाधन है।


आप सीखेंगे कि PyEMU का उपयोग कैसे करें।


The book covers topics related to software trickery.

यह पुस्तक सॉफ्टवेयर चालबाजी से संबंधित विषयों को शामिल करती है।


The book is well-written and easy to understand.

यह पुस्तक अच्छी तरह से लिखी गई है और समझने में आसान है।


This book is a must-read for anyone interested in ethical hacking.

यह पुस्तक नैतिक हैकिंग में रुचि रखने वाले किसी भी व्यक्ति के लिए अवश्य पढ़नी चाहिए।


The Python interactive shell provides full access to the interpreter.

पाइथन इंटरैक्टिव शेल इंटरप्रेटर तक पूरी पहुंच प्रदान करता है।


To ensure the environment finds the Python interpreter automatically, edit the .bashrc file.

यह सुनिश्चित करने के लिए कि वातावरण स्वचालित रूप से पाइथन इंटरप्रेटर ढूंढ ले, .bashrc फ़ाइल को संपादित करें।


Open the /root/.bashrc file and add the line: export PATH=/usr/local/Python25/:$PATH.

/root/.bashrc फ़ाइल खोलें और यह पंक्ति जोड़ें: export PATH=/usr/local/Python25/:$PATH।


Now you have a fully operational Python interpreter on both Windows and Linux.

अब आपके पास विंडोज और लिनक्स दोनों पर एक पूरी तरह से चालू पाइथन इंटरप्रेटर है।


It is absolutely necessary to utilize a solid IDE to rapidly develop and debug Python applications.

पाइथन अनुप्रयोगों को तेजी से विकसित और डिबग करने के लिए एक ठोस IDE का उपयोग करना बिल्कुल आवश्यक है।


The coupling of Eclipse and PyDev gives you powerful features that most other IDEs don’t offer.

एक्लिप्स और पायडेव का संयोजन आपको शक्तिशाली सुविधाएँ देता है जो अधिकांश अन्य IDE प्रदान नहीं करते हैं।


Download the Eclipse Classic package from http://www.eclipse.org/downloads/.

http://www.eclipse.org/downloads/ से Eclipse Classic पैकेज डाउनलोड करें।


In the Name field enter a descriptive string like PyDev Update.

नाम फ़ील्ड में PyDev Update जैसा वर्णनात्मक स्ट्रिंग दर्ज करें।


The ctypes library enables you to call functions in dynamically linked libraries.

ctypes लाइब्रेरी आपको गतिशील रूप से जुड़ी लाइब्रेरी में फ़ंक्शन कॉल करने में सक्षम बनाती है।


It is essential that you understand the basics of how to use the ctypes library.

यह आवश्यक है कि आप ctypes लाइब्रेरी का उपयोग करने के मूल सिद्धांतों को समझें।


A dynamically linked library is a compiled binary linked at runtime.

एक गतिशील रूप से जुड़ी लाइब्रेरी एक संकलित बाइनरी है जो रनटाइम पर जुड़ी होती है।


On Windows these binaries are called dynamic link libraries (DLL).

विंडोज पर इन बाइनरी को डायनेमिक लिंक लाइब्रेरी (DLL) कहा जाता है।


The cdecl() method is used for loading libraries that export functions using the standard cdecl calling convention.

cdecl() विधि का उपयोग उन लाइब्रेरी को लोड करने के लिए किया जाता है जो मानक cdecl कॉलिंग कन्वेंशन का उपयोग करके फ़ंक्शन निर्यात करती हैं।


For a quick example you will resolve the printf() function from the C runtime.

एक त्वरित उदाहरण के लिए, आप C रनटाइम से printf() फ़ंक्शन को हल करेंगे।


In the cdecl convention, parameters are pushed from right to left.

cdecl कन्वेंशन में, पैरामीटर दाएं से बाएं धकेले जाते हैं।


A register is a small amount of storage on the CPU.

एक रजिस्टर CPU पर भंडारण की एक छोटी मात्रा है।


The EAX register is used for performing calculations and storing return values.

EAX रजिस्टर का उपयोग गणना करने और रिटर्न वैल्यू संग्रहीत करने के लिए किया जाता है।


The EDX register assists in storing extra data for complex calculations.

EDX रजिस्टर जटिल गणनाओं के लिए अतिरिक्त डेटा संग्रहीत करने में सहायता करता है।


The ECX register, also called the count register, is used for looping operations.

ECX रजिस्टर, जिसे काउंट रजिस्टर भी कहा जाता है, लूपिंग ऑपरेशंस के लिए उपयोग किया जाता है।


The ESP and EBP registers are the stack pointer and the base pointer, respectively.

ESP और EBP रजिस्टर क्रमशः स्टैक पॉइंटर और बेस पॉइंटर हैं।


The ESP register is used to track the very top of the stack frame.

ईएसपी रजिस्टर का उपयोग स्टैक फ्रेम के सबसे ऊपरी हिस्से को ट्रैक करने के लिए किया जाता है।


The stack grows from high memory addresses to low memory addresses.

स्टैक उच्च मेमोरी पतों से निम्न मेमोरी पतों की ओर बढ़ता है।


Let’s use our previously covered function my_socks() as a simplified example of how the stack works.

आइए हम स्टैक कैसे काम करता है, इसका एक सरल उदाहरण के रूप में अपनी पहले से कवर की गई my_socks() फ़ंक्शन का उपयोग करें।


When the my_socks() function returns, it pops off all the values on the stack.

जब my_socks() फ़ंक्शन वापस आता है, तो यह स्टैक पर मौजूद सभी मानों को हटा देता है।


Local variables are slices of memory that are valid only for the function that is executing.

स्थानीय चर मेमोरी के स्लाइस हैं जो केवल उस फ़ंक्शन के लिए मान्य हैं जो निष्पादित हो रहा है।


The variable stinky_sock_color_one would be allocated on the stack.

चर stinky_sock_color_one को स्टैक पर आवंटित किया जाएगा।


The ability to capture the stack frame inside a debugger is very useful.

एक डिबगर के अंदर स्टैक फ्रेम को कैप्चर करने की क्षमता बहुत उपयोगी है।


Debuggers run as an endless loop that waits for a debugging event to occur.

डिबगर एक अंतहीन लूप के रूप में चलते हैं जो डिबगिंग इवेंट के घटित होने का इंतजार करता है।


Some of the common events that a debugger must trap are these: Breakpoint hits, Memory violations, Exceptions generated by the debugged program.

कुछ सामान्य घटनाएँ जिन्हें एक डिबगर को रोकना चाहिए वे हैं: ब्रेकपॉइंट हिट, मेमोरी उल्लंघन, डिबग किए गए प्रोग्राम द्वारा उत्पन्न अपवाद।


Each operating system has a different method for dispatching these events to a debugger.

प्रत्येक ऑपरेटिंग सिस्टम में इन घटनाओं को एक डिबगर को भेजने का एक अलग तरीका होता है।


An advantage of a scripted debugger is the ability to build custom event handlers.

एक स्क्रिप्टेड डिबगर का एक लाभ कस्टम इवेंट हैंडलर बनाने की क्षमता है।


A buffer overflow is a common cause for memory violations.

बफर ओवरफ्लो मेमोरी उल्लंघनों का एक सामान्य कारण है।


The ability to halt a process that is being debugged is achieved by setting breakpoints.

एक प्रक्रिया को रोकने की क्षमता जिसे डिबग किया जा रहा है, ब्रेकपॉइंट सेट करके प्राप्त की जाती है।


Breakpoints are most definitely the most common feature that you will use when debugging a process.

ब्रेकपॉइंट निश्चित रूप से सबसे आम सुविधा है जिसका उपयोग आप किसी प्रक्रिया को डिबग करते समय करेंगे।


There are three primary breakpoint types: soft breakpoints, hardware breakpoints, and memory breakpoints.

तीन प्राथमिक ब्रेकपॉइंट प्रकार हैं: सॉफ्ट ब्रेकपॉइंट, हार्डवेयर ब्रेकपॉइंट और मेमोरी ब्रेकपॉइंट।


Soft breakpoints are used specifically to halt the CPU when executing instructions.

सॉफ्ट ब्रेकपॉइंट का उपयोग विशेष रूप से निर्देशों को निष्पादित करते समय सीपीयू को रोकने के लिए किया जाता है।


An assembly instruction is a high-level representation of a command for the CPU to execute.

एक असेंबली निर्देश सीपीयू द्वारा निष्पादित किए जाने वाले कमांड का एक उच्च-स्तरीय प्रतिनिधित्व है।


This shows the address, the opcode, and the high-level assembly instruction.

यह पता, ओपकोड और उच्च-स्तरीय असेंबली निर्देश दिखाता है।


When the debugger is told to set a breakpoint at a desired address, it reads the first opcode byte at the requested address and stores it.

जब डिबगर को किसी वांछित पते पर एक ब्रेकपॉइंट सेट करने के लिए कहा जाता है, तो यह अनुरोधित पते पर पहला ओपकोड बाइट पढ़ता है और उसे संग्रहीत करता है।


Hardware breakpoints are useful when a small number of breakpoints are desired.

हार्डवेयर ब्रेकपॉइंट तब उपयोगी होते हैं जब कम संख्या में ब्रेकपॉइंट वांछित होते हैं।


The debugger must be able to capture the state of the CPU registers at any given point and time.

डीबगर को किसी भी समय और बिंदु पर सीपीयू रजिस्टरों की स्थिति को पकड़ने में सक्षम होना चाहिए।


We first must obtain a handle to the currently executing thread in the debuggee.

सबसे पहले, हमें डिबगी में वर्तमान में निष्पादित हो रहे थ्रेड का एक हैंडल प्राप्त करना होगा।


This is achieved using the ContinueDebugEvent() function.

यह ContinueDebugEvent() फ़ंक्शन का उपयोग करके प्राप्त किया जाता है।


We simply pass it the PID of the process we wish to attach to.

हम बस इसे उस प्रक्रिया का पीआईडी देते हैं जिससे हम जुड़ना चाहते हैं।


Once the system determines that we have appropriate rights to access the process, the target process assumes that the attaching process (the debugger) is ready to handle debug events.

एक बार जब सिस्टम यह निर्धारित कर लेता है कि हमारे पास प्रक्रिया तक पहुंचने का उचित अधिकार है, तो लक्ष्य प्रक्रिया मानती है कि संलग्न प्रक्रिया (डीबगर) डिबग इवेंट को संभालने के लिए तैयार है।


The first parameter is a pointer to the DEBUG_EVENT struct; this structure describes a debugging event.

पहला पैरामीटर DEBUG_EVENT संरचना का एक पॉइंटर है; यह संरचना एक डिबगिंग इवेंट का वर्णन करती है।


For each event that the debugger catches, there are associated event handlers that perform some type of action before letting the process continue.

डीबगर द्वारा पकड़े गए प्रत्येक इवेंट के लिए, संबंधित इवेंट हैंडलर होते हैं जो प्रक्रिया को जारी रखने देने से पहले कुछ प्रकार की कार्रवाई करते हैं।


The only thing left to do is to detach from the process.

सिर्फ एक ही काम बचा है, वह है प्रक्रिया से अलग होना।


Let’s put all of this together and extend our my_debugger class by providing it the ability to attach to and detach from a process.

आइए इन सबको एक साथ रखें और हमारी my_debugger क्लास को एक प्रक्रिया से जुड़ने और अलग होने की क्षमता प्रदान करके विस्तारित करें।


Download this file now and overwrite your current copy.

इस फ़ाइल को अभी डाउनलोड करें और अपनी वर्तमान प्रतिलिपि को अधिलेखित करें।


We won’t cover the creation of structs, unions, and constants any further, as you should feel intimately familiar with them by now.

हम आगे संरचनाओं, संघों और स्थिरांकों के निर्माण को कवर नहीं करेंगे, क्योंकि अब तक आपको उनसे अच्छी तरह परिचित होना चाहिए।


Now that we have explained the basics of obtaining a process handle, creating a debugged process, and attaching to a running process, we are ready to dive into more advanced features that our debugger will support.

अब जब हमने एक प्रक्रिया हैंडल प्राप्त करने, एक डिबग की गई प्रक्रिया बनाने और एक चल रही प्रक्रिया से जुड़ने की मूल बातें समझा दी हैं, तो हम अधिक उन्नत सुविधाओं में उतरने के लिए तैयार हैं जो हमारा डीबगर समर्थन करेगा।


A debugger must be able to capture the state of the CPU registers at any given point and time.

एक डीबगर को किसी भी समय और बिंदु पर सीपीयू रजिस्टरों की स्थिति को पकड़ने में सक्षम होना चाहिए।


We first must obtain a handle to the currently executing thread in the debuggee, which is achieved by using the OpenThread() function.

सबसे पहले, हमें डिबगी में वर्तमान में निष्पादित हो रहे थ्रेड का एक हैंडल प्राप्त करना होगा, जो OpenThread() फ़ंक्शन का उपयोग करके प्राप्त किया जाता है।


In order to obtain register state from a process, we have to be able to enumerate through all of the running threads inside the process.

किसी प्रक्रिया से रजिस्टर स्थिति प्राप्त करने के लिए, हमें प्रक्रिया के अंदर चल रहे सभी थ्रेडों के माध्यम से गणना करने में सक्षम होना होगा।


The threads are what are actually executing in the process; even if the application is not multithreaded, it still contains at least one thread, the main thread.

थ्रेड वही हैं जो वास्तव में प्रक्रिया में निष्पादित हो रहे हैं; भले ही एप्लिकेशन मल्टीथ्रेडेड न हो, फिर भी इसमें कम से कम एक थ्रेड, मुख्य थ्रेड होता है।


We can enumerate the threads by using a very powerful function called CreateToolhelp32Snapshot(), which is exported from kernel32.dll.

हम kernel32.dll से निर्यात किए गए CreateToolhelp32Snapshot() नामक एक बहुत शक्तिशाली फ़ंक्शन का उपयोग करके थ्रेडों की गणना कर सकते हैं।


The dwFlags parameter instructs the function what type of information it is supposed to gather (threads, processes, modules, or heaps).

dwFlags पैरामीटर फ़ंक्शन को निर्देश देता है कि उसे किस प्रकार की जानकारी एकत्र करनी है (थ्रेड, प्रक्रियाएं, मॉड्यूल या ढेर)।


Once we have a list of threads from the snapshot, we can begin enumerating them.

एक बार जब हमारे पास स्नैपशॉट से थ्रेडों की एक सूची आ जाती है, तो हम उनकी गणना शुरू कर सकते हैं।


In order for us to determine all threads inside our target process, we will compare each th32OwnerProcessID value against the PID of the process we either created or attached to.

हमारे लक्ष्य प्रक्रिया के अंदर सभी थ्रेडों को निर्धारित करने के लिए, हम प्रत्येक th32OwnerProcessID मान की तुलना उस प्रक्रिया के PID से करेंगे जिसे हमने बनाया या जोड़ा है।


The debugger is a crucial tool for understanding how software works.

सॉफ्टवेयर कैसे काम करता है, यह समझने के लिए डिबगर एक महत्वपूर्ण उपकरण है।


Hardware breakpoints involve setting bits in the CPU’s debug registers.

हार्डवेयर ब्रेकपॉइंट में CPU के डिबग रजिस्टरों में बिट्स सेट करना शामिल है।


We can first see that printf() resolves to 0x77c4186a, and so we set our breakpoint on that address.

हम पहले देख सकते हैं कि printf() 0x77c4186a पर हल होता है, और इसलिए हम उस पते पर अपना ब्रेकपॉइंट सेट करते हैं।


The important thing to remember when managing hardware breakpoints is tracking which of the four available debug registers are free for use.

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


Let’s start by enumerating all of the threads in the process and obtain a CPU context record for each of them.

आइए प्रक्रिया में सभी थ्रेडों को सूचीबद्ध करके शुरू करें और उनमें से प्रत्येक के लिए एक CPU संदर्भ रिकॉर्ड प्राप्त करें।


We know that a hardware breakpoint triggers an INT1 (or single-step event), so we simply add another exception handler to our debug loop.

हम जानते हैं कि एक हार्डवेयर ब्रेकपॉइंट एक INT1 (या सिंगल-स्टेप इवेंट) को ट्रिगर करता है, इसलिए हम बस अपने डिबग लूप में एक और अपवाद हैंडलर जोड़ते हैं।


You can see that we select an open slot to store the breakpoint by checking the global hardware_breakpoints dictionary.

आप देख सकते हैं कि हम वैश्विक hardware_breakpoints डिक्शनरी की जाँच करके ब्रेकपॉइंट को संग्रहीत करने के लिए एक खुला स्लॉट चुनते हैं।


Now that we have the mechanism to support setting the breakpoints, let’s update our event loop and add an exception handler to support the INT1 interrupt.

अब जब हमारे पास ब्रेकपॉइंट सेट करने का समर्थन करने की व्यवस्था है, तो आइए अपने इवेंट लूप को अपडेट करें और INT1 इंटरप्ट का समर्थन करने के लिए एक अपवाद हैंडलर जोड़ें।


This wasn't an INT1 generated by a hw breakpoint.

यह एक INT1 नहीं था जो एक हार्डवेयर ब्रेकपॉइंट द्वारा उत्पन्न हुआ था।


The loop should continue to execute after the handler is finished.

हैंडलर के समाप्त होने के बाद लूप को निष्पादित करना जारी रखना चाहिए।


The final feature that we are going to implement is the memory breakpoint.

अंतिम सुविधा जिसे हम लागू करने जा रहे हैं, वह मेमोरी ब्रेकपॉइंट है।


When the CPU attempts to access this memory, a GUARD_PAGE_EXCEPTION will be thrown.

जब CPU इस मेमोरी तक पहुंचने का प्रयास करता है, तो एक GUARD_PAGE_EXCEPTION फेंका जाएगा।


Using a specific handler for this exception, we revert to the original page permissions and continue execution.

इस अपवाद के लिए एक विशिष्ट हैंडलर का उपयोग करते हुए, हम मूल पृष्ठ अनुमतियों पर वापस लौटते हैं और निष्पादन जारी रखते हैं।


This concludes the development of a lightweight debugger on Windows.

यह विंडोज पर एक हल्के डिबगर के विकास को समाप्त करता है।


PyDbg was released by Pedram Amini at Recon 2006 in Montreal, Quebec, as a core component in the PaiMei reverse engineering framework.

PyDbg को Pedram Amini द्वारा Recon 2006 में मॉन्ट्रियल, क्यूबेक में PaiMei रिवर्स इंजीनियरिंग फ्रेमवर्क के एक मुख्य घटक के रूप में जारी किया गया था।


With a user-defined callback, we can implement custom logic when the debugger receives a debugging event.

उपयोगकर्ता-परिभाषित कॉलबैक के साथ, हम कस्टम तर्क लागू कर सकते हैं जब डिबगर एक डिबगिंग इवेंट प्राप्त करता है।


Breakpoint callback functions take only one parameter, which is an instance of the pydbg() class.

ब्रेकप्वाइंट कॉलबैक फ़ंक्शन केवल एक पैरामीटर लेते हैं, जो pydbg() वर्ग का एक उदाहरण है।


For this exercise, we will read the value of the counter that is used in the printf loop and replace it with a random number between 1 and 100.

इस अभ्यास के लिए, हम काउंटर का मान पढ़ेंगे जिसका उपयोग printf लूप में किया जाता है और इसे 1 और 100 के बीच एक यादृच्छिक संख्या से बदल देंगे।


You can see that the debugger set a breakpoint on the fourth iteration of the infinite printf loop, because the counter as recorded by the debugger is set to 4.

आप देख सकते हैं कि डिबगर ने अनंत printf लूप के चौथे पुनरावृत्ति पर एक ब्रेकपॉइंट सेट किया, क्योंकि डिबगर द्वारा रिकॉर्ड किए गए काउंटर को 4 पर सेट किया गया है।


An access violation occurs inside a process when it attempts to access memory it doesn’t have permission to access or in a particular way that it is not allowed.

एक एक्सेस उल्लंघन एक प्रक्रिया के अंदर होता है जब यह मेमोरी तक पहुंचने का प्रयास करता है जिसकी उसे एक्सेस करने की अनुमति नहीं है या किसी विशेष तरीके से जिसकी अनुमति नहीं है।


The exploit code needs to land us at 0x7C91D3F8.

एक्सप्लॉइट कोड को हमें 0x7C91D3F8 पर उतारना होगा।


Before we hit that spot, we need to make sure AL is set to 1.

उस जगह पर पहुँचने से पहले, हमें यह सुनिश्चित करना होगा कि AL को 1 पर सेट किया गया है।


This will disable DEP for the current process.

यह वर्तमान प्रक्रिया के लिए DEP को अक्षम कर देगा।


The script outputs the results to the Log window.

स्क्रिप्ट लॉग विंडो में परिणाम आउटपुट करती है।


Malware employs anti-debugging routines to prevent analysis.

मालवेयर विश्लेषण को रोकने के लिए एंटी-डीबगिंग रूटीन का उपयोग करता है।


The IsDebuggerPresent function is exported from kernel32.dll.

IsDebuggerPresent फ़ंक्शन kernel32.dll से निर्यात किया जाता है।


This code simply zeros out the BeingDebugged flag.

यह कोड बस BeingDebugged फ़्लैग को शून्य कर देता है।


Malware attempts to iterate through running processes.

मालवेयर चल रही प्रक्रियाओं के माध्यम से पुनरावृति करने का प्रयास करता है।


We can patch these two functions to set EAX to zero.

हम इन दो कार्यों को पैच कर सकते हैं ताकि EAX को शून्य पर सेट किया जा सके।


Hooking is a powerful process-observation technique.

हुकिंग एक शक्तिशाली प्रक्रिया-अवलोकन तकनीक है।


A soft hook uses INT3 breakpoint handlers.

एक सॉफ्ट हुक INT3 ब्रेकपॉइंट हैंडलर का उपयोग करता है।


Hard hooks are written directly in x86 assembly.

हार्ड हुक सीधे x86 असेंबली में लिखे जाते हैं।


We will be focusing on two primary techniques.

हम दो प्राथमिक तकनीकों पर ध्यान केंद्रित करेंगे।


Wireshark is limited in that it only sees data post encryption.

वायर्सार्क इस मामले में सीमित है कि यह केवल एन्क्रिप्शन के बाद डेटा देखता है।


We can trap the data before it is encrypted.

हम डेटा को एन्क्रिप्ट होने से पहले ही फँसा सकते हैं।


The most common form of encryption is SSL.

एन्क्रिप्शन का सबसे आम रूप SSL है।


The hook point is on the function PR_Write.

हुक पॉइंट PR_Write फ़ंक्शन पर है।


We can see the username and password quite clearly.

हम उपयोगकर्ता नाम और पासवर्ड को काफी स्पष्ट रूप से देख सकते हैं।


This technique can be applied to all kinds of debugging.

इस तकनीक को सभी प्रकार के डिबगिंग पर लागू किया जा सकता है।


Hard hooking has far less impact on the target process.

हार्ड हुकिंग का लक्ष्य प्रक्रिया पर बहुत कम प्रभाव पड़ता है।


The FastLogHook object stores captured information in an allocated memory region.

FastLogHook ऑब्जेक्ट कैप्चर की गई जानकारी को एक आवंटित मेमोरी क्षेत्र में संग्रहीत करता है।


You must query this page using the wrapper function getAllLog().

आपको रैपर फ़ंक्शन getAllLog() का उपयोग करके इस पृष्ठ को क्वेरी करना होगा।


Each time a hooked function gets hit, its address is stored in hook_address.

हर बार जब कोई हुक किया गया फ़ंक्शन हिट होता है, तो उसका पता hook_address में संग्रहीत किया जाता है।


The STDCALLFastLogHook is adjusted for the STDCALL calling convention.

STDCALLFastLogHook को STDCALL कॉलिंग कन्वेंशन के लिए समायोजित किया गया है।


For the cdecl convention use the normal FastLogHook.

cdecl कन्वेंशन के लिए सामान्य FastLogHook का उपयोग करें।


Hippie came out as a response for the need of a high-performance logging hook.

हिप्पी एक उच्च-प्रदर्शन लॉगिंग हुक की आवश्यकता के जवाब में सामने आया।


If you open a file dialog on it, it requires around 4,500 calls.

यदि आप इस पर एक फ़ाइल संवाद खोलते हैं, तो इसमें लगभग 4,500 कॉल की आवश्यकता होती है।


We can use hippie as an example of how to instrument heap routines.

हम हिप्पी का उपयोग इस बात के उदाहरण के रूप में कर सकते हैं कि ढेर रूटीन को कैसे इंस्ट्रूमेंट किया जाए।


For RtlFreeHeap we are going to trap all three arguments.

RtlFreeHeap के लिए हम तीनों तर्कों को फँसाने जा रहे हैं।


For RtlAllocateHeap we are going to take the three arguments plus the pointer that is returned.

RtlAllocateHeap के लिए हम तीन तर्क और लौटाए गए पॉइंटर को लेंगे।


The returned pointer points to the new heap block that was just created.

वापसी पॉइंटर नए ढेर ब्लॉक की ओर इशारा करता है जो अभी बनाया गया था।


Open up a new Python file, name it hippie_easy.py, and hit up the following code.

एक नई पायथन फ़ाइल खोलें, इसका नाम hippie_easy.py रखें, और निम्नलिखित कोड को हिट करें।


This is Nico's function that looks for the correct basic block.

यह निको का फ़ंक्शन है जो सही बुनियादी ब्लॉक की तलाश करता है।


The Python code starts disassembling at the head of the function.

पायथन कोड फ़ंक्शन के शीर्ष पर विघटन शुरू करता है।


Binaries are complicated beasts, and they have zero tolerance for error.

बाइनरी जटिल जानवर हैं, और उनमें त्रुटि के लिए शून्य सहनशीलता है।


The script is designed so that you run it once to set the hooks.

स्क्रिप्ट को इस तरह से डिज़ाइन किया गया है कि आप हुक सेट करने के लिए इसे एक बार चलाएँ।


You can access them from the debugger’s Python shell.

आप उन्हें डिबगर के पायथन शेल से एक्सेस कर सकते हैं।


For the RtlAllocateHeap call, we are trapping three arguments from the stack.

RtlAllocateHeap कॉल के लिए, हम स्टैक से तीन तर्क फँसा रहे हैं।


We instrumented thousands of calls without any process performance degradation!

हमने बिना किसी प्रक्रिया प्रदर्शन में गिरावट के हजारों कॉल को इंस्ट्रूमेंट किया!


We will create some simple utilities in Python.

हम पायथन में कुछ सरल उपयोगिताएँ बनाएँगे।


At any later point you can revert the process to the point where the snapshot was taken.

किसी भी बाद के बिंदु पर, आप प्रक्रिया को उस बिंदु पर वापस ला सकते हैं जहां स्नैपशॉट लिया गया था।


This can be quite handy when reverse engineering a binary or analyzing a crash.

यह किसी बाइनरी की रिवर्स इंजीनियरिंग या क्रैश का विश्लेषण करते समय काफी उपयोगी हो सकता है।


Our first step is to get an accurate picture of what the target process was up to at a precise moment.

हमारा पहला कदम यह है कि एक सटीक क्षण में लक्ष्य प्रक्रिया क्या कर रही थी, इसका सटीक चित्र प्राप्त करना।


In order for the picture to be accurate, we need to first obtain all threads and their respective CPU contexts.

तस्वीर को सटीक बनाने के लिए, हमें पहले सभी थ्रेड और उनके संबंधित CPU संदर्भ प्राप्त करने की आवश्यकता है।


As well, we need to obtain all of the process’s memory pages and their contents.

साथ ही, हमें प्रक्रिया के सभी मेमोरी पृष्ठों और उनकी सामग्री को प्राप्त करने की आवश्यकता है।


Once we have this information, it’s just a matter of storing it for when we want to restore a snapshot.

एक बार हमारे पास यह जानकारी हो जाने के बाद, यह केवल इसे संग्रहीत करने का मामला है जब हम स्नैपशॉट को पुनर्स्थापित करना चाहते हैं।


Before we can take the process snapshots, we have to suspend all threads of execution so that they don’t change data or state while the snapshot is being taken.

प्रक्रिया स्नैपशॉट लेने से पहले, हमें निष्पादन के सभी थ्रेड को निलंबित करना होगा ताकि स्नैपशॉट लेते समय वे डेटा या स्थिति को न बदलें।


To suspend all threads in PyDbg, we use suspend_all_threads(), and to resume all the threads, we use the aptly named resume_all_threads().

PyDbg में सभी थ्रेड को निलंबित करने के लिए, हम suspend_all_threads() का उपयोग करते हैं, और सभी थ्रेड को फिर से शुरू करने के लिए, हम उपयुक्त रूप से नामित resume_all_threads() का उपयोग करते हैं।


Once we have suspended the threads, we simply make a call to process_snapshot().

एक बार जब हमने थ्रेड को निलंबित कर दिया है, तो हम बस process_snapshot() को कॉल करते हैं।


This automatically fetches all of the contextual information about each thread and all memory at that precise moment.

यह स्वचालित रूप से प्रत्येक थ्रेड और उस सटीक क्षण में सभी मेमोरी के बारे में सभी प्रासंगिक जानकारी प्राप्त करता है।


Once the snapshot is finished, we resume all of the threads.

स्नैपशॉट समाप्त होने के बाद, हम सभी थ्रेड को फिर से शुरू करते हैं।


When we want to restore the process to the snapshot point, we suspend all of the threads, call process_restore(), and resume all of the threads.

जब हम प्रक्रिया को स्नैपशॉट बिंदु पर पुनर्स्थापित करना चाहते हैं, तो हम सभी थ्रेड को निलंबित कर देते हैं, process_restore() को कॉल करते हैं, और सभी थ्रेड को फिर से शुरू करते हैं।


Once we resume the process, we should be back at our original snapshot point.

एक बार जब हम प्रक्रिया को फिर से शुरू करते हैं, तो हमें अपने मूल स्नैपशॉट बिंदु पर वापस आ जाना चाहिए।


काफी अच्छा, है ना?


To try this out, let’s use a simple example where we allow a user to hit a key to take a snapshot and hit a key again to restore the snapshot.

इसे आज़माने के लिए, आइए एक सरल उदाहरण का उपयोग करें जहाँ हम उपयोगकर्ता को स्नैपशॉट लेने के लिए एक कुंजी दबाने और स्नैपशॉट को पुनर्स्थापित करने के लिए फिर से एक कुंजी दबाने की अनुमति देते हैं।


Open a new Python file, call it snapshot.py, and enter the following code.

एक नई पायथन फ़ाइल खोलें, इसे snapshot.py कहें, और निम्नलिखित कोड दर्ज करें।


So the first step is to start the target application under a debugger thread.

तो पहला कदम एक डिबगर थ्रेड के तहत लक्ष्य एप्लिकेशन शुरू करना है।


By using separate threads, we can enter snapshotting commands without forcing the target application to pause while it waits for our input.

अलग-अलग थ्रेड का उपयोग करके, हम लक्ष्य एप्लिकेशन को हमारे इनपुट का इंतजार करते समय रोकने के लिए मजबूर किए बिना स्नैपशॉटिंग कमांड दर्ज कर सकते हैं।


Once the debugger thread has returned a valid PID, we start up a new thread that will take our input.

एक बार जब डिबगर थ्रेड ने एक मान्य PID लौटा दिया है, तो हम एक नया थ्रेड शुरू करते हैं जो हमारा इनपुट लेगा।


Then when we send it a command, it will evaluate whether we are taking a snapshot, restoring a snapshot, or quitting—pretty straightforward.

फिर जब हम इसे एक कमांड भेजते हैं, तो यह मूल्यांकन करेगा कि क्या हम स्नैपशॉट ले रहे हैं, स्नैपशॉट पुनर्स्थापित कर रहे हैं, या क्विट कर रहे हैं—काफी सीधा है।


The file fuzzer selects a file randomly from a directory.

फ़ाइल फ़ज़र एक निर्देशिका से यादृच्छिक रूप से एक फ़ाइल का चयन करता है।


The fuzzer applies mutations to the selected file.

फ़ज़र चयनित फ़ाइल में परिवर्तन लागू करता है।


The debugger thread is started to load the target application.

लक्ष्य एप्लिकेशन को लोड करने के लिए डिबगर थ्रेड शुरू किया जाता है।


The monitoring thread ensures the application terminates after a set time.

निगरानी थ्रेड यह सुनिश्चित करता है कि एप्लिकेशन एक निश्चित समय के बाद समाप्त हो जाए।


The access violation handler traps crash information.

एक्सेस उल्लंघन हैंडलर क्रैश जानकारी को पकड़ता है।


The fuzzer uses command-line options for configuration.

फ़ज़र कॉन्फ़िगरेशन के लिए कमांड-लाइन विकल्पों का उपयोग करता है।


The -e flag specifies the executable path.

-e फ़्लैग निष्पादन योग्य पथ निर्दिष्ट करता है।


The -x option defines the file extension.

-x विकल्प फ़ाइल एक्सटेंशन को परिभाषित करता है।


-n पैरामीटर सूचनाओं को सक्षम करता है।


The fuzzer mutates files by inserting test cases.

फ़ज़र परीक्षण मामलों को डालकर फ़ाइलों में परिवर्तन करता है।


The mutate_file function is responsible for the mutation process.

mutate_file फ़ंक्शन परिवर्तन प्रक्रिया के लिए ज़िम्मेदार है।


The fuzzer is designed to find bugs in applications.

फ़ज़र अनुप्रयोगों में बग खोजने के लिए डिज़ाइन किया गया है।


Code coverage is a metric for measuring code execution.

कोड कवरेज कोड निष्पादन को मापने के लिए एक मीट्रिक है।


Automated static analysis can help find vulnerabilities.

स्वचालित स्थैतिक विश्लेषण कमजोरियों को खोजने में मदद कर सकता है।


Sulley is a Python-based fuzzing framework.

सली एक पायथन-आधारित फ़ज़िंग फ्रेमवर्क है।


Sulley uses block-based fuzzing for data generation.

सली डेटा जनरेशन के लिए ब्लॉक-आधारित फ़ज़िंग का उपयोग करता है।


Primitives are the building blocks of a protocol description in Sulley.

प्रिमिटिव सली में एक प्रोटोकॉल विवरण के निर्माण खंड हैं।


Strings, delimiters, and integers are examples of primitives.

स्ट्रिंग्स, डेलीमीटर और पूर्णांक प्रिमिटिव के उदाहरण हैं।


The s_string directive denotes a fuzzable string.

s_string निर्देश एक फ़ज़ेबल स्ट्रिंग को दर्शाता है।


Blocks and groups are used to organize primitives.

ब्लॉक और समूहों का उपयोग प्रिमिटिव को व्यवस्थित करने के लिए किया जाता है।


Using an alternate data stream, we are hiding the DLL from the user’s immediate view.

एक वैकल्पिक डेटा स्ट्रीम का उपयोग करके, हम DLL को उपयोगकर्ता की तत्काल दृष्टि से छिपा रहे हैं।


Without specialized tools, a computer user can’t see the contents of ADSs, which is ideal for us.

विशेषज्ञ उपकरणों के बिना, एक कंप्यूटर उपयोगकर्ता एडीएस की सामग्री नहीं देख सकता है, जो हमारे लिए आदर्श है।


In addition, a number of security products don’t properly scan alternate data streams, so we have a good chance of slipping underneath their radar to avoid detection.

इसके अतिरिक्त, कई सुरक्षा उत्पाद वैकल्पिक डेटा स्ट्रीम को ठीक से स्कैन नहीं करते हैं, इसलिए हमारे पास उनकी रडार के नीचे से फिसलकर पता लगाने से बचने का एक अच्छा मौका है।


To use an alternate data stream on a file, we’ll need to do nothing more than append a colon and a filename to an existing file, like so: reverser.exe:vncdll.dll

किसी फ़ाइल पर एक वैकल्पिक डेटा स्ट्रीम का उपयोग करने के लिए, हमें मौजूदा फ़ाइल में केवल एक कोलन और फ़ाइलनाम जोड़ना होगा, जैसे: reverser.exe:vncdll.dll


In this case we are accessing vncdll.dll, which is stored in an alternate data stream attached to reverser.exe.

इस मामले में हम vncdll.dll तक पहुंच रहे हैं, जो reverser.exe से जुड़ी एक वैकल्पिक डेटा स्ट्रीम में संग्रहीत है।


Let’s write a quick utility script that simply reads in a file and writes it out to an ADS attached to a file of our choosing.

आइए एक त्वरित उपयोगिता स्क्रिप्ट लिखें जो बस एक फ़ाइल को पढ़ती है और इसे हमारी पसंद की फ़ाइल से जुड़े एडीएस पर लिखती है।


Open an additional Python script called file_hider.py and enter the following code.

file_hider.py नामक एक अतिरिक्त पायथन स्क्रिप्ट खोलें और निम्नलिखित कोड दर्ज करें।


The first command-line argument is the DLL we wish to read in, and the second argument is the target file whose ADS we will be storing the DLL in.

पहला कमांड-लाइन तर्क वह DLL है जिसे हम पढ़ना चाहते हैं, और दूसरा तर्क लक्ष्य फ़ाइल है जिसमें हम DLL संग्रहीत करेंगे।


We can use this little utility to store any kind of files we would like alongside the executable, and we can inject DLLs directly out of the ADS as well.

हम इस छोटी उपयोगिता का उपयोग किसी भी प्रकार की फ़ाइलों को निष्पादन योग्य के साथ संग्रहीत करने के लिए कर सकते हैं, और हम एडीएस से सीधे डीएलएल को भी इंजेक्ट कर सकते हैं।


Although we won’t be utilizing DLL injection for our back- door, it will still support it, so read on.

हालांकि हम अपने बैक-डोर के लिए DLL इंजेक्शन का उपयोग नहीं करेंगे, यह अभी भी इसका समर्थन करेगा, इसलिए आगे पढ़ें।


Let’s start by building our execution redirection code, which very simply starts up an application of our choosing.

आइए अपने निष्पादन पुनर्निर्देशन कोड का निर्माण करके शुरू करें, जो बहुत ही सरल तरीके से हमारी पसंद के एक एप्लिकेशन को शुरू करता है।


The reason it’s called execution redirection is because we will name our backdoor calc.exe and move the original calc.exe to a different location.

इसे निष्पादन पुनर्निर्देशन कहने का कारण यह है कि हम अपने बैकडोर को calc.exe नाम देंगे और मूल calc.exe को एक अलग स्थान पर ले जाएंगे।


When the user attempts to use the calculator, she will be inadvertently running our backdoor, which in turn will start the proper calculator and thus not alert the user that anything is amiss.

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


Note that we are including the my_debugger_defines.py file from Chapter 3, which contains all of the necessary constants and structs in order to do the process creation.

ध्यान दें कि हम अध्याय 3 से my_debugger_defines.py फ़ाइल शामिल कर रहे हैं, जिसमें प्रक्रिया निर्माण करने के लिए आवश्यक सभी स्थिरांक और संरचनाएँ शामिल हैं।


Open a new Python file, name it backdoor.py, and enter the following code.

एक नई पायथन फ़ाइल खोलें, इसे backdoor.py नाम दें, और निम्नलिखित कोड दर्ज करें।


Not too complicated, and there is no new code in there.

ज्यादा जटिल नहीं है, और वहां कोई नया कोड नहीं है।


Before we move into the DLL injection code, we are going to explore how we can hide the DLL itself before using it for the injection.

DLL इंजेक्शन कोड में जाने से पहले, हम यह पता लगाने जा रहे हैं कि इंजेक्शन के लिए इसका उपयोग करने से पहले हम स्वयं DLL को कैसे छिपा सकते हैं।


Let’s add our injection code to the backdoor; just tack it on right after the process-creation section.

आइए अपने इंजेक्शन कोड को बैकडोर में जोड़ें; इसे प्रक्रिया-निर्माण अनुभाग के ठीक बाद जोड़ दें।


Our injection function will also be able to handle code or DLL injection; simply set the parameter flag to 1, and the data variable will then contain the path to the DLL.

हमारा इंजेक्शन फ़ंक्शन कोड या DLL इंजेक्शन को भी संभालने में सक्षम होगा; बस पैरामीटर फ़्लैग को 1 पर सेट करें, और डेटा चर में फिर DLL का पथ होगा।


We now have a supported injection function that can handle both code and DLL injection.

अब हमारे पास एक समर्थित इंजेक्शन फ़ंक्शन है जो कोड और DLL इंजेक्शन दोनों को संभाल सकता है।


Since the USER and PASS commands are only a small subset of the FTP server’s full capabilities, let’s throw in a couple of commands to test for some more bugs once we are authenticated.

चूंकि USER और PASS कमांड FTP सर्वर की पूरी क्षमताओं का केवल एक छोटा सा हिस्सा हैं, इसलिए आइए कुछ और बगों का परीक्षण करने के लिए कुछ कमांड डालें, एक बार जब हम प्रमाणित हो जाते हैं।


To gain a full understanding of all commands supported by the FTP protocol, please refer to its RFC.

FTP प्रोटोकॉल द्वारा समर्थित सभी कमांडों की पूरी समझ प्राप्त करने के लिए, कृपया इसके RFC को देखें।


With the protocol skeleton now created, let’s move on to creating a Sulley session that will tie together all of our request information as well as set up the network sniffer and the debugging client.

अब प्रोटोकॉल कंकाल बन जाने के बाद, आइए एक सुली सत्र बनाने की ओर बढ़ते हैं जो हमारे सभी अनुरोध जानकारी को एक साथ बांध देगा और साथ ही नेटवर्क स्निफर और डिबगिंग क्लाइंट को भी स्थापित करेगा।


Sulley sessions are the mechanism that ties together requests and takes care of the network packet capture, process debugging, crash reporting, and virtual machine control.

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


The receive_ftp_banner() function is necessary because every FTP server has a banner that it displays when a client connects.

receive_ftp_banner() फ़ंक्शन आवश्यक है क्योंकि प्रत्येक FTP सर्वर में एक बैनर होता है जिसे वह तब प्रदर्शित करता है जब कोई क्लाइंट कनेक्ट होता है।


We tie this to the sess.pre_send property, which tells Sulley to receive the FTP banner before sending any fuzz data.

हम इसे sess.pre_send प्रॉपर्टी से जोड़ते हैं, जो सुली को कोई भी फ़ज़ डेटा भेजने से पहले FTP बैनर प्राप्त करने के लिए कहता है।


The first step in creating the session is to define a session file that keeps track of the current state of our fuzzer.

सत्र बनाने का पहला चरण एक सत्र फ़ाइल को परिभाषित करना है जो हमारे फ़ज़र की वर्तमान स्थिति पर नज़र रखता है।


The second step is to define a target to attack, which is an IP address and a port number.

दूसरा चरण हमला करने के लिए एक लक्ष्य को परिभाषित करना है, जो एक आईपी पता और एक पोर्ट नंबर है।


We are attacking 192.168.244.133 and port 21, which is our WarFTPD instance (running inside a virtual machine in this case).

हम 192.168.244.133 और पोर्ट 21 पर हमला कर रहे हैं, जो हमारा WarFTPD उदाहरण है (इस मामले में एक वर्चुअल मशीन के अंदर चल रहा है)।


The third entry tells Sulley that our network sniffer is set up on the same host and is listening on TCP port 26001, which is the port on which it will accept commands from Sulley.

तीसरा प्रविष्टि सुली को बताती है कि हमारा नेटवर्क स्निफर उसी होस्ट पर स्थापित है और टीसीपी पोर्ट 26001 पर सुन रहा है, जो वह पोर्ट है जिस पर वह सुली से कमांड स्वीकार करेगा।


We then add the defined target to our parent session.

फिर हम परिभाषित लक्ष्य को अपने मूल सत्र में जोड़ते हैं।


The next step is to tie our FTP requests together in a logical fashion.

अगला कदम हमारे FTP अनुरोधों को एक तार्किक तरीके से एक साथ जोड़ना है।


You can see how we chain together the authentication commands ( USER, PASS), and then any commands that require the user to be authenticated we chain to the PASS command.

आप देख सकते हैं कि हम प्रमाणीकरण कमांड (USER, PASS) को कैसे एक साथ जोड़ते हैं, और फिर कोई भी कमांड जिसके लिए उपयोगकर्ता को प्रमाणित करने की आवश्यकता होती है, हम उसे PASS कमांड से जोड़ते हैं।


Now we have a fully defined session with a nice set of requests, so let’s see how to set up our network and monitor scripts.

अब हमारे पास अनुरोधों के एक अच्छे सेट के साथ एक पूरी तरह से परिभाषित सत्र है, तो आइए देखें कि हमारे नेटवर्क और मॉनिटर स्क्रिप्ट को कैसे सेट किया जाए।


One of the sweetest features of Sulley is its ability to monitor fuzz traffic on the wire as well as handle any crashes that occur on the target system.

सुली की सबसे अच्छी विशेषताओं में से एक है तार पर फ़ज़ ट्रैफ़िक की निगरानी करने के साथ-साथ लक्ष्य प्रणाली पर होने वाले किसी भी क्रैश को संभालने की क्षमता।


This is extremely important, because you can map a crash back to the actual network traffic that caused it, which greatly reduces the time it takes to go from crash to working exploit.

यह बेहद महत्वपूर्ण है, क्योंकि आप क्रैश को उस वास्तविक नेटवर्क ट्रैफ़िक पर वापस मैप कर सकते हैं जिसके कारण यह हुआ, जो क्रैश से काम करने वाले शोषण तक जाने में लगने वाले समय को बहुत कम कर देता है।


Let’s start with the process monitor, process_monitor.py, which is located in the main Sulley directory.

आइए प्रोसेस मॉनिटर, process_monitor.py से शुरू करते हैं, जो मुख्य सुली निर्देशिका में स्थित है।


Simply run it to see the usage information:

उपयोग की जानकारी देखने के लिए बस इसे चलाएँ:


We see that the network interface we want to use is set to [1] in the output.

हम देखते हैं कि जिस नेटवर्क इंटरफ़ेस का हम उपयोग करना चाहते हैं, वह आउटपुट में [1] पर सेट है।


We now have both monitoring agents running, and we are ready for fuzzing action.

अब हमारे पास दोनों निगरानी एजेंट चल रहे हैं, और हम फ़ज़िंग कार्रवाई के लिए तैयार हैं।


Listing 11-1. Cross References to sprintf

सूची 11-1. स्प्रिन्टफ़ के क्रॉस संदर्भ


All of the addresses that are listed are locations where the sprintf function is being called.

सूचीबद्ध सभी पते ऐसे स्थान हैं जहाँ स्प्रिन्टफ़ फ़ंक्शन को बुलाया जा रहा है।


We’ll use IDAPython to iterate through all of the functions in a target binary and set breakpoints on the head of each address.

हम एक लक्ष्य बाइनरी में सभी कार्यों के माध्यम से पुनरावृति करने और प्रत्येक पते के शीर्ष पर ब्रेकपॉइंट सेट करने के लिए IDAPython का उपयोग करेंगे।


Open a new Python file, name it func_coverage.py, and enter the following code.

एक नई पायथन फ़ाइल खोलें, उसका नाम func_coverage.py रखें, और निम्नलिखित कोड दर्ज करें।


First we set up our debugger hook so that it gets called whenever a debugger event is thrown.

सबसे पहले, हम अपना डिबगर हुक सेट करते हैं ताकि जब भी कोई डिबगर इवेंट फेंका जाए तो उसे बुलाया जाए।


We then iterate through all of the function addresses and set a breakpoint on each address.

फिर हम सभी फ़ंक्शन पतों के माध्यम से पुनरावृति करते हैं और प्रत्येक पते पर एक ब्रेकपॉइंट सेट करते हैं।


The SetBptAttr call sets a flag to tell the debugger not to stop when each breakpoint is hit.

SetBptAttr कॉल एक फ़्लैग सेट करता है जो डिबगर को यह बताने के लिए है कि प्रत्येक ब्रेकपॉइंट हिट होने पर रुकना नहीं है।


Our breakpoint handler prints out the address of each breakpoint that was hit, using the ea variable.

हमारा ब्रेकपॉइंट हैंडलर ea चर का उपयोग करके, हिट किए गए प्रत्येक ब्रेकपॉइंट का पता प्रिंट करता है।


Now run the debugger (hotkey = F9), and you should start seeing output showing the functions that are hit.

अब डिबगर चलाएँ (हॉटकी = F9), और आपको आउटपुट देखना शुरू कर देना चाहिए जो हिट होने वाले कार्यों को दिखाता है।


At times when assessing a binary for possible vulnerabilities, it’s important to understand the stack size of particular function calls.

कभी-कभी संभावित कमजोरियों के लिए एक बाइनरी का आकलन करते समय, विशेष फ़ंक्शन कॉलों के स्टैक आकार को समझना महत्वपूर्ण होता है।


Let’s write some code to iterate through all of the functions in a binary and show us all functions that have stack-allocated buffers that may be of interest.

आइए कुछ कोड लिखें जो एक बाइनरी में सभी कार्यों के माध्यम से पुनरावृति करे और हमें उन सभी कार्यों को दिखाए जिनमें स्टैक-आवंटित बफ़र्स हैं जो रुचि के हो सकते हैं।


Open a new Python file, name it stack_calc.py, and enter the following code.

एक नई पायथन फ़ाइल खोलें, उसका नाम stack_calc.py रखें, और निम्नलिखित कोड दर्ज करें।


We set a size threshold that determines how large a stack variable should be before we consider it a buffer.

हम एक आकार सीमा निर्धारित करते हैं जो यह निर्धारित करती है कि हम इसे बफर मानने से पहले एक स्टैक चर कितना बड़ा होना चाहिए।


We then begin iterating through all of the functions, obtaining the stack frame object for each function.

फिर हम सभी कार्यों के माध्यम से पुनरावृति करना शुरू करते हैं, प्रत्येक फ़ंक्शन के लिए स्टैक फ्रेम ऑब्जेक्ट प्राप्त करते हैं।


Using the stack frame object, we use the GetStrucSize method to determine the size of the stack frame in bytes.

स्टैक फ्रेम ऑब्जेक्ट का उपयोग करके, हम बाइट्स में स्टैक फ्रेम के आकार को निर्धारित करने के लिए GetStrucSize विधि का उपयोग करते हैं।


You should now have the fundamentals for using IDAPython and have some core utility scripts that you can easily extend, combine, or enhance.

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


PyEmu was released at BlackHat 2007 by Cody Pierce, one of the talented members of the TippingPoint DVLabs team.

PyEmu को ब्लैकहैट 2007 में कोडी पियर्स द्वारा जारी किया गया था, जो टिपिंगपॉइंट डीवीलैब्स टीम के प्रतिभाशाली सदस्यों में से एक हैं।


PyEmu has three methods to enable emulation: IDAPyEmu, PyDbgPyEmu, and PEPyEmu.

PyEmu में अनुकरण को सक्षम करने के तीन तरीके हैं: IDAPyEmu, PyDbgPyEmu, और PEPyEmu।


We will be covering the use of IDAPyEmu and PEPyEmu for our purposes and leave the PyDbgPyEmu class as an exploration exercise for the reader.

हम अपने उद्देश्यों के लिए IDAPyEmu और PEPyEmu के उपयोग को कवर करेंगे और PyDbgPyEmu क्लास को पाठक के लिए एक खोज अभ्यास के रूप में छोड़ देंगे।


Installing PyEmu is quite simple; just download the zip file from http://www .nostarch.com/ghpython.htm.

PyEmu स्थापित करना काफी सरल है; बस http://www .nostarch.com/ghpython.htm से ज़िप फ़ाइल डाउनलोड करें।


You can see that we discovered a valid device name, \Device\Beep, in three lines of code.

आप देख सकते हैं कि हमने तीन पंक्तियों के कोड में एक मान्य डिवाइस नाम, \Device\Beep, की खोज की है।


Now let’s move on to discovering the primary IOCTL dispatch function and the IOCTL codes that a driver supports.

अब आइए प्राथमिक IOCTL प्रेषण फ़ंक्शन और IOCTL कोड की खोज पर आगे बढ़ते हैं जो एक ड्राइवर समर्थन करता है।


Any driver that implements an IOCTL interface must have an IOCTL dispatch routine that handles the processing of the various IOCTL requests.

कोई भी ड्राइवर जो IOCTL इंटरफ़ेस को लागू करता है, उसके पास एक IOCTL प्रेषण रूटीन होना चाहिए जो विभिन्न IOCTL अनुरोधों की प्रक्रिया को संभालता है।


This line is telling the driver that the IOCTLDispatch function handles all IOCTL requests.

यह पंक्ति ड्राइवर को बता रही है कि IOCTLDispatch फ़ंक्शन सभी IOCTL अनुरोधों को संभालता है।


Using these instructions, we can then deduce where the IOCTL-handling routine lives ( CONSTANT), and that is where we can begin searching for the various IOCTL codes.

इन निर्देशों का उपयोग करके, हम यह अनुमान लगा सकते हैं कि IOCTL-हैंडलिंग रूटीन कहाँ रहता है (CONSTANT), और यहीं से हम विभिन्न IOCTL कोड की खोज शुरू कर सकते हैं।


This code utilizes Immunity Debugger’s powerful search API to find all possible matches against our search criteria.

यह कोड हमारे खोज मानदंडों के विरुद्ध सभी संभावित मिलानों को खोजने के लिए इम्युनिटी डिबगर के शक्तिशाली खोज एपीआई का उपयोग करता है।


Once we have found a match, we send a Function object back that represents the IOCTL dispatch function where our hunt for valid IOCTL codes will begin.

एक बार जब हमें कोई मिलान मिल जाता है, तो हम एक फ़ंक्शन ऑब्जेक्ट वापस भेजते हैं जो IOCTL प्रेषण फ़ंक्शन का प्रतिनिधित्व करता है जहाँ हमारे वैध IOCTL कोड की खोज शुरू होगी।


Next let’s take a look at the IOCTL dispatch function itself and how to apply some simple heuristics to try to find all of the IOCTL codes a device supports.

अगला, आइए IOCTL प्रेषण फ़ंक्शन को स्वयं देखें और यह जानने की कोशिश करें कि किसी डिवाइस द्वारा समर्थित सभी IOCTL कोड को खोजने के लिए कुछ सरल अनुमानों को कैसे लागू किया जाए।


The IOCTL dispatch routine commonly will perform various actions based on the value of the code being passed in to the routine.

IOCTL प्रेषण रूटीन आमतौर पर रूटीन में पारित किए जा रहे कोड के मूल्य के आधार पर विभिन्न क्रियाएं करेगा।


We want to be able to exercise each of the possible paths that are determined by the IOCTL code, which is why we go to all the trouble of finding these values.

हम IOCTL कोड द्वारा निर्धारित प्रत्येक संभावित पथ का उपयोग करने में सक्षम होना चाहते हैं, यही कारण है कि हम इन मानों को खोजने की सारी परेशानी उठाते हैं।


Let’s first examine what the C source code for a skeleton IOCTL dispatch function would look like, and then we’ll see how to decode the assembly to retrieve the IOCTL code values.

सबसे पहले, आइए जांच करें कि एक कंकाल IOCTL प्रेषण फ़ंक्शन के लिए C स्रोत कोड कैसा दिखेगा, और फिर हम देखेंगे कि IOCTL कोड मानों को पुनः प्राप्त करने के लिए असेंबली को कैसे डिकोड किया जाए।


Once the function code has been retrieved from the IOCTL request 0, it is common to see a switch{} statement in place 0 to determine what action the driver is to perform based on the IOCTL code being sent in.

एक बार जब फ़ंक्शन कोड को IOCTL अनुरोध 0 से पुनः प्राप्त कर लिया जाता है, तो यह निर्धारित करने के लिए एक स्विच{} स्टेटमेंट को 0 में देखना आम बात है कि ड्राइवर को भेजे जा रहे IOCTL कोड के आधार पर क्या कार्रवाई करनी है।


There are a few different ways this can be translated into assembly; take a look at Listing 10-6 for examples.

इसे असेंबली में अनुवादित करने के कुछ अलग तरीके हैं; उदाहरणों के लिए लिस्टिंग 10-6 देखें।


In the first case, where we see a series of CMP instructions, we simply look for the constant that is being compared against the passed-in IOCTL.

पहले मामले में, जहाँ हम CMP निर्देशों की एक श्रृंखला देखते हैं, हम बस उस स्थिरांक की तलाश करते हैं जिसकी तुलना पास-इन IOCTL से की जा रही है।


That constant should be a valid IOCTL code that the driver supports.

वह स्थिरांक एक मान्य IOCTL कोड होना चाहिए जिसका ड्राइवर समर्थन करता है।


In the second case we are looking for a series of SUB statements against the same register (in this case, ESI), followed by some type of conditional JMP instruction.

दूसरे मामले में हम एक ही रजिस्टर (इस मामले में, ESI) के विरुद्ध SUB कथनों की एक श्रृंखला की तलाश कर रहे हैं, इसके बाद कुछ प्रकार का सशर्त JMP निर्देश है।


The key in this case is to find the original starting constant: SUB ESI, 1337

इस मामले में कुंजी मूल प्रारंभिक स्थिरांक खोजना है: SUB ESI, 1337


This line tells us that the lowest supported IOCTL code is 0x1337.

यह पंक्ति हमें बताती है कि सबसे कम समर्थित IOCTL कोड 0x1337 है।


From there, every SUB instruction we see, we add the equivalent amount to our base constant, which gives us another valid IOCTL code.

वहां से, हम जो भी SUB निर्देश देखते हैं, हम अपनी आधार स्थिरांक में समतुल्य राशि जोड़ते हैं, जो हमें एक और मान्य IOCTL कोड देता है।


Now that we know how driverlib does some of our dirty work for us, let’s take advantage of it!

अब जब हम जानते हैं कि ड्राइवरलिब हमारे लिए कुछ गंदा काम कैसे करता है, तो आइए इसका लाभ उठाएं!


We then load the code and data sections of the binary into PyEmu’s memory.

फिर हम बाइनरी के कोड और डेटा सेक्शन को PyEmu की मेमोरी में लोड करते हैं।


We are using the IDAPython SegByName() function to find the beginning of the sections and the SegEnd() function to determine the end of the sections.

हम खंडों की शुरुआत खोजने के लिए IDAPython SegByName() फ़ंक्शन और खंडों के अंत को निर्धारित करने के लिए SegEnd() फ़ंक्शन का उपयोग कर रहे हैं।


Then we simply iterate over the sections byte by byte to store them in PyEmu’s memory.

फिर हम उन्हें PyEmu की मेमोरी में संग्रहीत करने के लिए खंडों पर बाइट दर बाइट पुनरावृति करते हैं।


Now that we have the code and data sections loaded into memory, we are going to set up the stack parameters for the function call, install an instruction handler to be called when the retn instruction is executed, and begin execution.

अब जब हमारे पास कोड और डेटा सेक्शन मेमोरी में लोड हो गए हैं, तो हम फ़ंक्शन कॉल के लिए स्टैक पैरामीटर सेट करने जा रहे हैं, retn निर्देश के निष्पादित होने पर कॉल किए जाने वाले एक निर्देश हैंडलर को स्थापित करेंगे, और निष्पादन शुरू करेंगे।


We first set EIP to the head of the function, which is located at 0x00401000.

सबसे पहले, हम EIP को फ़ंक्शन के शीर्ष पर सेट करते हैं, जो 0x00401000 पर स्थित है।


Next we set up the mnemonic, or instruction, handler to be called when the function’s retn instruction is executed.

अगला, हम मेमोनिक, या निर्देश, हैंडलर को सेट करते हैं जिसे फ़ंक्शन के retn निर्देश के निष्पादित होने पर कॉल किया जाएगा।


The third step is to set the stack parameters for the function call.

तीसरा चरण फ़ंक्शन कॉल के लिए स्टैक पैरामीटर सेट करना है।


These are the two numbers to be added together; in our case we are using 0x00000001 and 0x00000002.

ये दो संख्याएँ हैं जिन्हें एक साथ जोड़ा जाना है; हमारे मामले में हम 0x00000001 और 0x00000002 का उपयोग कर रहे हैं।


We then tell PyEmu to execute all 10 instructions contained within the function.

फिर हम PyEmu को फ़ंक्शन के भीतर निहित सभी 10 निर्देशों को निष्पादित करने के लिए कहते हैं।


The last step is coding the retn instruction handler, so the final script should look like the following.

अंतिम चरण retn निर्देश हैंडलर को कोडित करना है, इसलिए अंतिम स्क्रिप्ट इस प्रकार दिखनी चाहिए।


The ret instruction handler simply retrieves the stack arguments and the value of the EAX register and outputs the result of the function call.

ret निर्देश हैंडलर बस स्टैक तर्क और EAX रजिस्टर के मान को पुनः प्राप्त करता है और फ़ंक्शन कॉल का परिणाम आउटपुट करता है।


Practice loading different binaries into IDA, pick a random function, and try to emulate calls to it.

IDA में विभिन्न बाइनरी लोड करने का अभ्यास करें, एक यादृच्छिक फ़ंक्शन चुनें, और उस पर कॉल का अनुकरण करने का प्रयास करें।


You’d be amazed at how powerful this technique can be when a function has hundreds or thousands of instructions with many branches, loops, and return points.

आप चकित रह जाएंगे कि यह तकनीक कितनी शक्तिशाली हो सकती है जब किसी फ़ंक्शन में कई शाखाओं, लूप और रिटर्न पॉइंट के साथ सैकड़ों या हजारों निर्देश हों।


Using this method of reversing a function can save you hours of manual reversing.

किसी फ़ंक्शन को रिवर्स करने के इस तरीके का उपयोग करके आप मैनुअल रिवर्सिंग के घंटों को बचा सकते हैं।


Now let’s use the PEPyEmu library to unpack a compressed executable.

अब हम एक संपीड़ित निष्पादन योग्य को अनपैक करने के लिए PEPyEmu लाइब्रेरी का उपयोग करते हैं।


The packer we are targeting is the Ultimate Packer for Executables (UPX).

हम जिस पैकर को लक्षित कर रहे हैं वह एग्जीक्यूटिव के लिए अल्टीमेट पैकर (UPX) है।


A typical packer will compress the code and data segments of the target binary and replace the entry point with a decompressor.

एक विशिष्ट पैकर लक्ष्य बाइनरी के कोड और डेटा खंडों को संपीड़ित करेगा और एंट्री पॉइंट को एक डीकंप्रेसर से बदल देगा।


When the binary is executed, the decompressor runs, which decompresses the original binary into memory, and then jumps to the original entry point (OEP) of the binary.

जब बाइनरी निष्पादित होता है, तो डीकंप्रेसर चलता है, जो मूल बाइनरी को मेमोरी में डीकंप्रेस करता है, और फिर बाइनरी के मूल एंट्री पॉइंट (OEP) पर कूदता है।


Once the OEP is reached, the binary begins executing normally.

एक बार OEP तक पहुँचने के बाद, बाइनरी सामान्य रूप से निष्पादित होना शुरू हो जाता है।


When faced with a packed executable, a reverser must first get rid of the packer in order to effectively analyze the true binary contained within.

एक पैक किए गए निष्पादन योग्य का सामना करने पर, एक रिवर्सर को प्रभावी ढंग से अंदर निहित वास्तविक बाइनरी का विश्लेषण करने के लिए पहले पैकर से छुटकारा पाना होगा।


Gray Hat Python is a book about Python programming for hackers and reverse engineers.

ग्रे हैट पायथन हैकर्स और रिवर्स इंजीनियरों के लिए पायथन प्रोग्रामिंग पर एक किताब है।


The book explains concepts behind hacking tools and techniques like debuggers and fuzzers.

यह पुस्तक डिबगर्स और फ़ज़र्स जैसे हैकिंग टूल और तकनीकों के पीछे की अवधारणाओं की व्याख्या करती है।


Author Justin Seitz shows how to build your own security tools using Python.

लेखक जस्टिन सीट्ज़ दिखाते हैं कि पायथन का उपयोग करके अपने स्वयं के सुरक्षा उपकरण कैसे बनाएं।


You'll learn how to automate tedious reversing and security tasks.

आप सीखेंगे कि कैसे थकाऊ रिवर्सिंग और सुरक्षा कार्यों को स्वचालित करें।


The book covers topics like code and library injection, and hooking techniques.

यह पुस्तक कोड और लाइब्रेरी इंजेक्शन, और हुकिंग तकनीकों जैसे विषयों को शामिल करती है।


The book also teaches how to sniff secure traffic out of an encrypted web browser session.

यह पुस्तक यह भी सिखाती है कि एन्क्रिप्टेड वेब ब्राउज़र सत्र से सुरक्षित ट्रैफ़िक को कैसे सूंघा जाए।


The book uses RepKover binding, which allows it to lay flat when open.

पुस्तक RepKover बाइंडिंग का उपयोग करती है, जो इसे खुले होने पर सपाट रहने की अनुमति देती है।


The Electronic Frontier Foundation (EFF) defends civil liberties in the digital world.

इलेक्ट्रॉनिक फ्रंटियर फाउंडेशन (ईएफएफ) डिजिटल दुनिया में नागरिक स्वतंत्रता की रक्षा करता है।


EFF fights illegal surveillance and promotes the rights of innovators.

ईएफएफ अवैध निगरानी से लड़ता है और नवप्रवर्तकों के अधिकारों को बढ़ावा देता है।


EFF has sued telecom giant AT&T for giving the NSA access to customer communications.

ईएफएफ ने दूरसंचार कंपनी एटी एंड टी पर एनएसए को ग्राहकों के संचार तक पहुंच देने के लिए मुकदमा दायर किया है।


EFF's Coders’ Rights Project defends the rights of programmers and security researchers.

ईएफएफ की कोडर राइट्स परियोजना प्रोग्रामर और सुरक्षा शोधकर्ताओं के अधिकारों की रक्षा करती है।


The book 'Hacking: The Art of Exploitation' explains hacking techniques.

पुस्तक 'हैकिंग: द आर्ट ऑफ एक्सप्लॉयटेशन' हैकिंग तकनीकों की व्याख्या करती है।


The book includes a LiveCD for debugging code and overflowing buffers.

पुस्तक में कोड को डिबग करने और बफ़र्स को ओवरफ्लो करने के लिए एक लाइवसीडी शामिल है।


The book 'Silence on the Wire' explores security threats.

पुस्तक 'साइलेंस ऑन द वायर' सुरक्षा खतरों की पड़ताल करती है।


The book 'Security Data Visualization' offers graphical techniques for network analysis.

पुस्तक 'सिक्योरिटी डेटा विज़ुअलाइज़ेशन' नेटवर्क विश्लेषण के लिए ग्राफिकल तकनीकें प्रदान करती है।


The book 'Playing with Python' teaches programming through games.

पुस्तक 'प्लेइंग विद पायथन' खेलों के माध्यम से प्रोग्रामिंग सिखाती है।


The book 'The IDA Pro Book' is a guide to the disassembler IDA Pro.

पुस्तक 'द आईडीए प्रो बुक' डिसएसेम्बलर आईडीए प्रो के लिए एक मार्गदर्शिका है।


The book is printed and bound at Malloy Incorporated in Ann Arbor, Michigan.

पुस्तक को एन आर्बर, मिशिगन में मैलोय इंकॉर्पोरेटेड में मुद्रित और बांधा गया है।


The book uses a RepKover binding, which allows it to lay flat when open.

यह पुस्तक RepKover बाइंडिंग का उपयोग करती है, जो इसे खुले होने पर सपाट रहने की अनुमति देती है।


Visit the website for updates, errata, and other information.

अपडेट, अशुद्धिपत्र और अन्य जानकारी के लिए वेबसाइट पर जाएँ।