Python is a versatile programming language.

ಪೈಥಾನ್ ಒಂದು ಬಹುಮುಖ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದೆ.


Hackers often use Python for its powerful libraries.

ಹ್ಯಾಕರ್ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಶಕ್ತಿಯುತ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಅನ್ನು ಬಳಸುತ್ತಾರೆ.


The book explains how to use Python for security tasks.

ಪುಸ್ತಕವು ಭದ್ರತಾ ಕಾರ್ಯಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.


You will learn about debuggers and fuzzers.

ನೀವು ಡೀಬಗರ್ಗಳು ಮತ್ತು ಫಝರ್ಗಳ ಬಗ್ಗೆ ಕಲಿಯುವಿರಿ.


ನಿಮ್ಮ ಸ್ವಂತ ಪರಿಕರಗಳನ್ನು ನಿರ್ಮಿಸುವುದು ಒಂದು ಪ್ರಮುಖ ಕೌಶಲ್ಯವಾಗಿದೆ.


ಲೇಖಕರು ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬೇಕೆಂದು ತೋರಿಸುತ್ತಾರೆ.


Security researchers use Python extensively.

ಭದ್ರತಾ ಸಂಶೋಧಕರು ವ್ಯಾಪಕವಾಗಿ ಪೈಥಾನ್ ಅನ್ನು ಬಳಸುತ್ತಾರೆ.


This book is for hackers and reverse engineers.

ಈ ಪುಸ್ತಕವು ಹ್ಯಾಕರ್ಗಳು ಮತ್ತು ರಿವರ್ಸ್ ಎಂಜಿನಿಯರ್ಗಳಿಗಾಗಿ ಆಗಿದೆ.


The book covers code injection techniques.

ಪುಸ್ತಕವು ಕೋಡ್ ಇಂಜೆಕ್ಷನ್ ತಂತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


You can build your own debugger with Python.

ನೀವು ಪೈಥಾನ್ ಬಳಸಿ ನಿಮ್ಮ ಸ್ವಂತ ಡೀಬಗರ್ ಅನ್ನು ನಿರ್ಮಿಸಬಹುದು.


Fuzzing is a technique to find software bugs.

ಫಝಿಂಗ್ ಎನ್ನುವುದು ಸಾಫ್ಟ್ವೇರ್ ದೋಷಗಳನ್ನು ಹುಡುಕುವ ಒಂದು ತಂತ್ರವಾಗಿದೆ.


ಪುಸ್ತಕವು ವಿವಿಧ ದೋಷ ವರ್ಗಗಳನ್ನು ಚರ್ಚಿಸುತ್ತದೆ.


ಸುಲ್ಲಿ ಒಂದು ಶಕ್ತಿಯುತ ಫಝಿಂಗ್ ಚೌಕಟ್ಟಾಗಿದೆ.


The book explains how to fuzz Windows drivers.

ವಿಂಡೋಸ್ ಡ್ರೈವರ್ಗಳನ್ನು ಹೇಗೆ ಫಝ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ಪುಸ್ತಕವು ವಿವರಿಸುತ್ತದೆ.


IDAPython is used for scripting IDA Pro.

ಐಡಿಎ ಪ್ರೊಗೆ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಮಾಡಲು IDAPython ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


PyEmu ಒಂದು ಸ್ಕ್ರಿಪ್ಟಬಲ್ ಎಮ್ಯುಲೇಟರ್ ಆಗಿದೆ.


The book provides detailed code examples.

ಪುಸ್ತಕವು ವಿವರವಾದ ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.


ಸಂಯೋಜನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


This book will help you become a better hacker.

ಈ ಪುಸ್ತಕವು ನೀವು ಉತ್ತಮ ಹ್ಯಾಕರ್ ಆಗಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


Python is the language of choice for many security professionals.

ಅನೇಕ ಭದ್ರತಾ ವೃತ್ತಿಪರರಿಗೆ ಪೈಥಾನ್ ಆಯ್ಕೆಯ ಭಾಷೆಯಾಗಿದೆ.


The debugger is responsible for handling access violations.

ದೋಷ ಪ್ರವೇಶವನ್ನು ನಿರ್ವಹಿಸಲು ಡೀಬಗರ್ ಜವಾಬ್ದಾರನಾಗಿರುತ್ತಾನೆ.


We will start with extending breakpoint handlers.

ನಾವು ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ನಿರ್ವಾಹಕರನ್ನು ವಿಸ್ತರಿಸುವುದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.


ಆಕಾಶವೇ ಮಿತಿ!


ಬನ್ನಿ PyDbg ಅನ್ನು ನೋಡೋಣ.


PyDbg has been used in quite a few tools.

PyDbg ಅನ್ನು ಸಾಕಷ್ಟು ಉಪಕರಣಗಳಲ್ಲಿ ಬಳಸಲಾಗಿದೆ.


We will start with extending breakpoint handlers and then move into more advanced topics.

ನಾವು ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ನಿರ್ವಾಹಕರನ್ನು ವಿಸ್ತರಿಸುವುದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಹೆಚ್ಚು ಸುಧಾರಿತ ವಿಷಯಗಳಿಗೆ ಹೋಗುತ್ತೇವೆ.


The address parameter is the address where the soft breakpoint should be set.

ವಿಳಾಸದ ಪ್ಯಾರಾಮೀಟರ್ ಎಂದರೆ ಸಾಫ್ಟ್ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಎಲ್ಲಿ ಹೊಂದಿಸಬೇಕು ಎಂಬುದರ ವಿಳಾಸವಾಗಿದೆ.


All context, thread, and process information will already be populated in this class.

ಎಲ್ಲಾ ಸಂದರ್ಭ, ಥ್ರೆಡ್ ಮತ್ತು ಪ್ರಕ್ರಿಯೆ ಮಾಹಿತಿಯನ್ನು ಈಗಾಗಲೇ ಈ ವರ್ಗದಲ್ಲಿ ಜನಪ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ.


ಇದು ಸರಳವಾದರೂ ಶಕ್ತಿಯುತವಾದ ಉದಾಹರಣೆಯಾಗಿದೆ.


Let’s take a look at handling application crashes with PyDbg.

PyDbg ನೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್‌ಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ನೋಡೋಣ.


An access violation occurs inside a process when it attempts to access memory.

ಪ್ರಕ್ರಿಯೆಯೊಳಗೆ ಮೆಮೊರಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಪ್ರವೇಶ ಉಲ್ಲಂಘನೆಯು ಸಂಭವಿಸುತ್ತದೆ.


From a security perspective, every access violation should be reviewed carefully.

ಭದ್ರತಾ ದೃಷ್ಟಿಕೋನದಿಂದ, ಪ್ರತಿಯೊಂದು ಪ್ರವೇಶ ಉಲ್ಲಂಘನೆಯನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಶೀಲಿಸಬೇಕು.


PyDbg has an excellent method for installing an access violation handler.

ಪ್ರವೇಶ ಉಲ್ಲಂಘನೆ ನಿರ್ವಾಹಕವನ್ನು ಸ್ಥಾಪಿಸಲು PyDbg ಅತ್ಯುತ್ತಮ ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ.


ಮೊದಲಿಗೆ, ನಾವು ಒಂದು ಪರೀಕ್ಷಾ ಸರಂಜಾಮು ರಚಿಸೋಣ.


ಈಗ ನಾವು ಪರೀಕ್ಷಾ ಪ್ರಕರಣವನ್ನು ನಿರ್ಮಿಸಿದ್ದೇವೆ.


The output reveals many pieces of useful information.

ಔಟ್‌ಪುಟ್ ಉಪಯುಕ್ತ ಮಾಹಿತಿಯ ಅನೇಕ ಭಾಗಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ.


You can see how simple it is to set up a crash handler using PyDbg.

PyDbg ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ರ್ಯಾಶ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಹೊಂದಿಸುವುದು ಎಷ್ಟು ಸರಳವಾಗಿದೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡಬಹುದು.


ಇದು ನಂಬಲಾಗದಷ್ಟು ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ.


Next we are going to use PyDbg’s internal process snapshotting capability.

ಮುಂದೆ ನಾವು PyDbg ಯ ಆಂತರಿಕ ಪ್ರಕ್ರಿಯೆ ಸ್ನ್ಯಾಪ್‌ಶಾಟಿಂಗ್ ಸಾಮರ್ಥ್ಯವನ್ನು ಬಳಸಲಿದ್ದೇವೆ.


PyDbg comes stocked with a very cool feature called process snapshotting.

PyDbg ಪ್ರಕ್ರಿಯೆ ಸ್ನ್ಯಾಪ್‌ಶಾಟಿಂಗ್ ಎಂಬ ತಂಪಾದ ವೈಶಿಷ್ಟ್ಯದೊಂದಿಗೆ ಬರುತ್ತದೆ.


The debugger obtains a handle to the process object.

ಡೀಬಗರ್ ಪ್ರಕ್ರಿಯೆ ವಸ್ತುವಿಗೆ ಒಂದು ಹಿಡಿಕೆಯನ್ನು ಪಡೆಯುತ್ತದೆ.


We attach to the process using the DebugActiveProcess() function.

ನಾವು DebugActiveProcess() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಕ್ರಿಯೆಗೆ ಲಗತ್ತಿಸುತ್ತೇವೆ.


The target process assumes that the attaching process is ready to handle debug events.

ಲಗತ್ತಿಸುವ ಪ್ರಕ್ರಿಯೆಯು ಡೀಬಗ್ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಿದ್ಧವಾಗಿದೆ ಎಂದು ಗುರಿ ಪ್ರಕ್ರಿಯೆಯು ಭಾವಿಸುತ್ತದೆ.


The debugger catches these debugging events by calling WaitForDebugEvent() in a loop.

ಡೀಬಗರ್ ಲೂಪ್‌ನಲ್ಲಿ WaitForDebugEvent() ಅನ್ನು ಕರೆ ಮಾಡುವ ಮೂಲಕ ಈ ಡೀಬಗ್ ಈವೆಂಟ್‌ಗಳನ್ನು ಹಿಡಿಯುತ್ತದೆ.


The first parameter is a pointer to the DEBUG_EVENT struct.

ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್ DEBUG_EVENT ರಚನೆಗೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ.


For each event that the debugger catches, there are associated event handlers.

ಡೀಬಗರ್ ಹಿಡಿಯುವ ಪ್ರತಿಯೊಂದು ಈವೆಂಟ್‌ಗೆ, ಸಂಬಂಧಿತ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಿವೆ.


Once the handlers are finished executing, we want the process to continue executing.

ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ಪ್ರಕ್ರಿಯೆಯು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸಬೇಕೆಂದು ನಾವು ಬಯಸುತ್ತೇವೆ.


This is achieved using the ContinueDebugEvent() function.

ಇದು ContinueDebugEvent() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಸಾಧಿಸಲ್ಪಡುತ್ತದೆ.


The dwContinueStatus parameter signals the process to continue executing.

dwContinueStatus ಪ್ಯಾರಾಮೀಟರ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸಲು ಸೂಚಿಸುತ್ತದೆ.


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.

ಇವೆಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಸೇರಿಸೋಣ ಮತ್ತು ನಮ್ಮ my_debugger ವರ್ಗವನ್ನು ವಿಸ್ತರಿಸೋಣ.


We will also add the ability to open and obtain a process handle.

ಪ್ರಕ್ರಿಯೆ ಹಿಡಿಕೆಯನ್ನು ತೆರೆಯಲು ಮತ್ತು ಪಡೆಯಲು ನಾವು ಸಾಮರ್ಥ್ಯವನ್ನು ಸೇರಿಸುತ್ತೇವೆ.


The final implementation detail will be to create our primary debug loop.

ಅಂತಿಮ ಅನುಷ್ಠಾನದ ವಿವರವೆಂದರೆ ನಮ್ಮ ಪ್ರಾಥಮಿಕ ಡೀಬಗ್ ಲೂಪ್ ಅನ್ನು ರಚಿಸುವುದು.


Download this file now and overwrite your current copy.

ಈಗ ಈ ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರತಿಯನ್ನು ಅತಿಕ್ರಮಿಸಿ.


We won’t cover the creation of structs, unions, and constants any further.

ನಾವು ರಚನೆಗಳು, ಯೂನಿಯನ್‌ಗಳು ಮತ್ತು ಸ್ಥಿರಾಂಕಗಳನ್ನು ಮತ್ತಷ್ಟು ರಚಿಸುವುದನ್ನು ಒಳಗೊಳ್ಳುವುದಿಲ್ಲ.


Now that we have explained the basics, we are ready to dive into more advanced features.

ನಾವು ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ವಿವರಿಸಿದ ನಂತರ, ನಾವು ಹೆಚ್ಚು ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಸಿದ್ಧರಿದ್ದೇವೆ.


A debugger must be able to capture the state of the CPU registers.

ಡೀಬಗರ್ CPU ರೆಜಿಸ್ಟರ್‌ಗಳ ಸ್ಥಿತಿಯನ್ನು ಸೆರೆಹಿಡಿಯಲು ಸಾಧ್ಯವಾಗಬೇಕು.


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

ಮೊದಲಿಗೆ ನಾವು ಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಥ್ರೆಡ್‌ಗೆ ಹಿಡಿಕೆಯನ್ನು ಪಡೆಯಬೇಕು.


Let’s explore how to enumerate threads on a system.

ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಥ್ರೆಡ್‌ಗಳನ್ನು ಹೇಗೆ ಎಣಿಸುವುದು ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸೋಣ.


The threads are what are actually executing in the process.

ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳುವುದು ಥ್ರೆಡ್‌ಗಳು.


The Python interpreter provides full access to the interpreter and any included libraries.

ಪೈಥಾನ್ ಇಂಟರ್‌ಪ್ರಿಟರ್ ಇಂಟರ್‌ಪ್ರಿಟರ್ ಮತ್ತು ಯಾವುದೇ ಒಳಗೊಂಡಿರುವ ಲೈಬ್ರರಿಗಳಿಗೆ ಸಂಪೂರ್ಣ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸುತ್ತದೆ.


To ensure your user environment knows where to find the Python interpreter automatically, you must edit the .bashrc file.

ನಿಮ್ಮ ಬಳಕೆದಾರರ ಪರಿಸರವು ಪೈಥಾನ್ ಇಂಟರ್‌ಪ್ರಿಟರ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬೇಕೆಂದು ತಿಳಿದಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ನೀವು .bashrc ಫೈಲ್ ಅನ್ನು ಸಂಪಾದಿಸಬೇಕು.


If you log out and log back in as root, when you type python at any point in your command shell you will be prompted by the Python interpreter.

ನೀವು ಲಾಗ್ ಔಟ್ ಆಗಿ ರೂಟ್ ಆಗಿ ಮತ್ತೆ ಲಾಗ್ ಇನ್ ಮಾಡಿದರೆ, ನಿಮ್ಮ ಕಮಾಂಡ್ ಶೆಲ್‌ನಲ್ಲಿ ಯಾವುದೇ ಹಂತದಲ್ಲಿ ನೀವು ಪೈಥಾನ್ ಅನ್ನು ಟೈಪ್ ಮಾಡಿದಾಗ, ಪೈಥಾನ್ ಇಂಟರ್‌ಪ್ರಿಟರ್‌ನಿಂದ ನಿಮಗೆ ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲಾಗುತ್ತದೆ.


In order to rapidly develop and debug Python applications, it is absolutely necessary to utilize a solid IDE.

ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು, ಘನ IDE ಅನ್ನು ಬಳಸುವುದು ಸಂಪೂರ್ಣವಾಗಿ ಅವಶ್ಯಕವಾಗಿದೆ.


The coupling of the popular Eclipse development environment and a module called PyDev gives you a tremendous number of powerful features.

ಜನಪ್ರಿಯ ಎಕ್ಲಿಪ್ಸ್ ಅಭಿವೃದ್ಧಿ ಪರಿಸರ ಮತ್ತು PyDev ಎಂಬ ಮಾಡ್ಯೂಲ್‌ನ ಜೋಡಣೆಯು ನಿಮಗೆ ಅಪಾರ ಸಂಖ್ಯೆಯ ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ.


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

http://www.eclipse.org/downloads/ ನಿಂದ ಎಕ್ಲಿಪ್ಸ್ ಕ್ಲಾಸಿಕ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ.


The first time it starts, it will ask where to store your workspace; you can accept the default.

ಇದು ಮೊದಲ ಬಾರಿಗೆ ಪ್ರಾರಂಭವಾದಾಗ, ನಿಮ್ಮ ಕಾರ್ಯಸ್ಥಳವನ್ನು ಎಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕೆಂದು ಅದು ಕೇಳುತ್ತದೆ; ನೀವು ಡೀಫಾಲ್ಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಬಹುದು.


Select the radio button labeled Search for new features to install and click Next.

ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಹುಡುಕಿ ಎಂದು ಲೇಬಲ್ ಮಾಡಲಾದ ರೇಡಿಯೋ ಬಟನ್ ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ಮುಂದೆ ಕ್ಲಿಕ್ ಮಾಡಿ.


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

ಹೆಸರು ಕ್ಷೇತ್ರದಲ್ಲಿ PyDev ನವೀಕರಣದಂತಹ ವಿವರಣಾತ್ಮಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಮೂದಿಸಿ.


Then read and accept the license agreement for PyDev.

ನಂತರ PyDev ಗಾಗಿ ಪರವಾನಗಿ ಒಪ್ಪಂದವನ್ನು ಓದಿ ಮತ್ತು ಸ್ವೀಕರಿಸಿ.


The final step is to click Yes on the dialog box that appears after PyDev is installed.

PyDev ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಡೈಲಾಗ್ ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಹೌದು ಕ್ಲಿಕ್ ಮಾಡುವುದು ಅಂತಿಮ ಹಂತವಾಗಿದೆ.


Now you have a working PyDev install, and it is configured to use your freshly installed Python 2.5 interpreter.

ಈಗ ನೀವು ಕೆಲಸ ಮಾಡುವ PyDev ಅನ್ನು ಸ್ಥಾಪಿಸಿದ್ದೀರಿ, ಮತ್ತು ನಿಮ್ಮ ಹೊಸದಾಗಿ ಸ್ಥಾಪಿಸಲಾದ ಪೈಥಾನ್ 2.5 ಇಂಟರ್‌ಪ್ರಿಟರ್ ಅನ್ನು ಬಳಸಲು ಇದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ.


Before you start coding, you must create a new PyDev project; this project will hold all of the source files.

ನೀವು ಕೋಡಿಂಗ್ ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನೀವು ಹೊಸ PyDev ಯೋಜನೆಯನ್ನು ರಚಿಸಬೇಕು; ಈ ಯೋಜನೆಯು ಎಲ್ಲಾ ಮೂಲ ಫೈಲ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.


To run Python scripts from Eclipse, just click the Run As button on the toolbar.

ಎಕ್ಲಿಪ್ಸ್‌ನಿಂದ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ರನ್ ಮಾಡಲು, ಟೂಲ್‌ಬಾರ್‌ನಲ್ಲಿ ರನ್ ಆಸ್ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.


The Python module ctypes is by far one of the most powerful libraries available to the Python developer.

ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್ ctypes ಪೈಥಾನ್ ಡೆವಲಪರ್‌ಗೆ ಲಭ್ಯವಿರುವ ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.


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

ctypes ಲೈಬ್ರರಿಯು ಡೈನಾಮಿಕ್ ಲಿಂಕ್ಡ್ ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಕರೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.


On Windows platforms these binaries are called dynamic link libraries (DLL), and on Linux they are called shared objects (SO).

ವಿಂಡೋಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ ಈ ಬೈನರಿಗಳನ್ನು ಡೈನಾಮಿಕ್ ಲಿಂಕ್ ಲೈಬ್ರರಿಗಳು (DLL) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು Linux ನಲ್ಲಿ ಅವುಗಳನ್ನು ಹಂಚಿದ ವಸ್ತುಗಳು (SO) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


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

cdll() ವಿಧಾನವನ್ನು ಪ್ರಮಾಣಿತ cdecl ಕರೆ ಮಾಡುವ ಸಂಪ್ರದಾಯವನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗಳನ್ನು ರಫ್ತು ಮಾಡುವ ಲೈಬ್ರರಿಗಳನ್ನು ಲೋಡ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.


For a quick example you will resolve the printf() function from the C runtime on both Windows and Linux and use it to output a test message.

ತ್ವರಿತ ಉದಾಹರಣೆಗಾಗಿ ನೀವು ವಿಂಡೋಸ್ ಮತ್ತು ಲಿನಕ್ಸ್ ಎರಡರಲ್ಲೂ ಸಿ ರನ್‌ಟೈಮ್‌ನಿಂದ printf() ಕಾರ್ಯವನ್ನು ಪರಿಹರಿಸುತ್ತೀರಿ ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಾ ಸಂದೇಶವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಲು ಬಳಸುತ್ತೀರಿ.


A calling convention describes how to properly call a particular function.

ಕರೆ ಮಾಡುವ ಸಂಪ್ರದಾಯವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ಹೇಗೆ ಸರಿಯಾಗಿ ಕರೆಯಬೇಕೆಂದು ವಿವರಿಸುತ್ತದೆ.


The ESP register is used to track the very top of the stack frame, and the EBP register is used to track the bottom of the stack frame.

ESP ರೆಜಿಸ್ಟರ್ ಅನ್ನು ಸ್ಟಾಕ್ ಫ್ರೇಮ್‌ನ ಮೇಲ್ಭಾಗವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು EBP ರೆಜಿಸ್ಟರ್ ಅನ್ನು ಸ್ಟಾಕ್ ಫ್ರೇಮ್‌ನ ಕೆಳಭಾಗವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.


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 and jumps to the return address to continue executing in the parent function that called it.

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 so that it can be used within the current stack frame.

stinky_sock_color_one ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸ್ಟಾಕ್‌ನಲ್ಲಿ ನಿಯೋಜಿಸಲಾಗುತ್ತದೆ, ಇದರಿಂದ ಅದನ್ನು ಪ್ರಸ್ತುತ ಸ್ಟಾಕ್ ಫ್ರೇಮ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು.


The ability to capture the stack frame inside a debugger is very useful for tracing functions, capturing the stack state on a crash, and tracking down stack-based overflows.

ಡೀಬಗರ್ ಒಳಗೆ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಅನ್ನು ಸೆರೆಹಿಡಿಯುವ ಸಾಮರ್ಥ್ಯವು ಕಾರ್ಯಗಳನ್ನು ಟ್ರೇಸ್ ಮಾಡಲು, ಕ್ರ್ಯಾಶ್‌ನಲ್ಲಿ ಸ್ಟಾಕ್ ಸ್ಥಿತಿಯನ್ನು ಸೆರೆಹಿಡಿಯಲು ಮತ್ತು ಸ್ಟಾಕ್-ಆಧಾರಿತ ಓವರ್‌ಫ್ಲೋಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಹಳ ಉಪಯುಕ್ತವಾಗಿದೆ.


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

ಡೀಬಗರ್‌ಗಳು ಡೀಬಗ್ ಮಾಡುವ ಈವೆಂಟ್ ಸಂಭವಿಸಲು ಕಾಯುವ ಅಂತ್ಯವಿಲ್ಲದ ಲೂಪ್‌ನಂತೆ ಚಲಿಸುತ್ತವೆ.


When a debugging event occurs, the loop breaks, and a corresponding event handler is called.

ಡೀಬಗ್ ಮಾಡುವ ಈವೆಂಟ್ ಸಂಭವಿಸಿದಾಗ, ಲೂಪ್ ಮುರಿಯುತ್ತದೆ ಮತ್ತು ಅನುಗುಣವಾದ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.


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

ಡೀಬಗರ್ ಟ್ರ್ಯಾಪ್ ಮಾಡಬೇಕಾದ ಕೆಲವು ಸಾಮಾನ್ಯ ಈವೆಂಟ್‌ಗಳೆಂದರೆ: ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ಹಿಟ್‌ಗಳು, ಮೆಮೊರಿ ಉಲ್ಲಂಘನೆಗಳು, ಡೀಬಗ್ ಮಾಡಿದ ಪ್ರೋಗ್ರಾಂನಿಂದ ರಚಿಸಲಾದ ವಿನಾಯಿತಿಗಳು.


An advantage of a scripted debugger is the ability to build custom event handlers to automate certain debugging tasks.

ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಡೀಬಗರ್‌ನ ಪ್ರಯೋಜನವೆಂದರೆ ಕೆಲವು ಡೀಬಗ್ ಮಾಡುವ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಕಸ್ಟಮ್ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಸಾಮರ್ಥ್ಯ.


For example, a buffer overflow is a common cause for memory violations and is of great interest to a hacker.

ಉದಾಹರಣೆಗೆ, ಬಫರ್ ಓವರ್‌ಫ್ಲೋ ಮೆಮೊರಿ ಉಲ್ಲಂಘನೆಗಳಿಗೆ ಸಾಮಾನ್ಯ ಕಾರಣವಾಗಿದೆ ಮತ್ತು ಇದು ಹ್ಯಾಕರ್‌ಗೆ ಹೆಚ್ಚಿನ ಆಸಕ್ತಿಯನ್ನು ಹೊಂದಿದೆ.


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, and we will cover them extensively.

ಪ್ರಕ್ರಿಯೆಯನ್ನು ಡೀಬಗ್ ಮಾಡುವಾಗ ನೀವು ಬಳಸುವ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು, ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ವಿಸ್ತಾರವಾಗಿ ಒಳಗೊಳ್ಳುತ್ತೇವೆ.


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

ಮೂರು ಪ್ರಾಥಮಿಕ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ವಿಧಗಳಿವೆ: ಸಾಫ್ಟ್ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು, ಹಾರ್ಡ್‌ವೇರ್ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು ಮತ್ತು ಮೆಮೊರಿ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು.


A soft breakpoint is a single-byte instruction that stops execution of the debugged process and passes control to the debugger’s breakpoint exception handler.

ಸಾಫ್ಟ್ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ಎನ್ನುವುದು ಒಂದೇ ಬೈಟ್ ಸೂಚನೆಯಾಗಿದ್ದು, ಇದು ಡೀಬಗ್ ಮಾಡಿದ ಪ್ರಕ್ರಿಯೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ ಮತ್ತು ನಿಯಂತ್ರಣವನ್ನು ಡೀಬಗರ್‌ನ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ವಿನಾಯಿತಿ ಹ್ಯಾಂಡ್ಲರ್‌ಗೆ ರವಾನಿಸುತ್ತದೆ.


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

ಅಸೆಂಬ್ಲಿ ಸೂಚನೆಯು CPU ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆಜ್ಞೆಯ ಉನ್ನತ ಮಟ್ಟದ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ.


If the instruction we covered previously was at address 0x44332211, a common representation would look like this: 0x44332211: 8BC3 MOV EAX, EBX

ನಾವು ಹಿಂದೆ ಒಳಗೊಂಡಿರುವ ಸೂಚನೆಯು 0x44332211 ವಿಳಾಸದಲ್ಲಿದ್ದರೆ, ಸಾಮಾನ್ಯ ಪ್ರಾತಿನಿಧ್ಯವು ಈ ರೀತಿ ಕಾಣಿಸುತ್ತದೆ: 0x44332211: 8BC3 MOV EAX, EBX


When the CPU comes skipping along and hits that byte, it halts, firing an INT3 event.

CPU ದಾಟಿಕೊಂಡು ಬಂದು ಆ ಬೈಟ್ ಅನ್ನು ಹೊಡೆದಾಗ, ಅದು ನಿಲ್ಲುತ್ತದೆ, INT3 ಈವೆಂಟ್ ಅನ್ನು ಹಾರಿಸುತ್ತದೆ.


Soft breakpoints have one caveat, however: when you change a byte of the executable in memory, you change the running software’s cyclic redundancy check (CRC) checksum.

ಸಾಫ್ಟ್ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು ಒಂದು ಎಚ್ಚರಿಕೆಯನ್ನು ಹೊಂದಿವೆ: ನೀವು ಮೆಮೊರಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಬೈಟ್ ಅನ್ನು ಬದಲಾಯಿಸಿದಾಗ, ನೀವು ಚಾಲನೆಯಲ್ಲಿರುವ ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಸೈಕ್ಲಿಕ್ ರಿಡಂಡೆನ್ಸಿ ಚೆಕ್ (CRC) ಚೆಕ್‌ಸಮ್ ಅನ್ನು ಬದಲಾಯಿಸುತ್ತೀರಿ.


The exploit code needs to land us at a specific memory address.

ಶೋಷಣ ಕೋಡ್ ನಮ್ಮನ್ನು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಮರಣಾ ವಿಳಾಸದಲ್ಲಿ ಇಳಿಸಬೇಕಾಗಿದೆ.


Before we execute the code, we need to ensure a specific register has a certain value.

ನಾವು ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು, ಒಂದು ನಿರ್ದಿಷ್ಟ ರೆಜಿಸ್ಟರ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು.


The findantidep.py script helps in finding these addresses.

findantidep.py ಸ್ಕ್ರಿಪ್ಟ್ ಈ ವಿಳಾಸಗಳನ್ನು ಹುಡುಕಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


Immunity Debugger has a wizard to guide you through the process.

ಇಮ್ಯೂನಿಟಿ ಡಿಬಗ್ಗರ್ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡಲು ಒಂದು ಮಾಂತ್ರಿಕವನ್ನು ಹೊಂದಿದೆ.


This script creates the exploit string for you.

ಈ ಸ್ಕ್ರಿಪ್ಟ್ ನಿಮಗಾಗಿ ಶೋಷಣ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.


You can copy and paste the exploit string into your exploit.

ನೀವು ಶೋಷಣ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಕಲಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಶೋಷಣಕ್ಕೆ ಅಂಟಿಸಬಹುದು.


Malware employs anti-debugging routines to prevent analysis.

ಮಾಲ್ವೇರ್ ವಿಶ್ಲೇಷಣೆಯನ್ನು ತಡೆಯಲು ವಿರೋಧಿ-ದೋಷನಿವಾರಣೆ ದಿನಚರಿಗಳನ್ನು ಬಳಸುತ್ತದೆ.


IsDebuggerPresent is a common anti-debugging technique.

IsDebuggerPresent ಒಂದು ಸಾಮಾನ್ಯ ವಿರೋಧಿ-ದೋಷನಿವಾರಣೆ ತಂತ್ರವಾಗಿದೆ.


This function returns 1 if a debugger is attached.

ದೋಷನಿವಾರಕವನ್ನು ಲಗತ್ತಿಸಿದರೆ ಈ ಕಾರ್ಯವು 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


The BeingDebugged flag in the PEB indicates debugger presence.

PEB ನಲ್ಲಿರುವ BeingDebugged ಫ್ಲಾಗ್ ದೋಷನಿವಾರಕ ಉಪಸ್ಥಿತಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.


Malware iterates through processes to detect debuggers.

ದೋಷನಿವಾರಕಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮಾಲ್ವೇರ್ ಪ್ರಕ್ರಿಯೆಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.


Process32First and Process32Next are used for process iteration.

ಪ್ರಕ್ರಿಯೆ ಪುನರಾವರ್ತನೆಗಾಗಿ Process32First ಮತ್ತು Process32Next ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


We can patch these functions to return false.

ನಾವು ಈ ಕಾರ್ಯಗಳನ್ನು ತಿದ್ದಿ ಬರೆಯಬಹುದು ಮತ್ತು ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸಬಹುದು.


Hooking is a powerful process-observation technique.

ಹುಕಿಂಗ್ ಒಂದು ಪ್ರಬಲ ಪ್ರಕ್ರಿಯೆ-ವೀಕ್ಷಣಾ ತಂತ್ರವಾಗಿದೆ.


ಹುಕ್ಸ್ ಪ್ರಕ್ರಿಯೆಯ ಹರಿವನ್ನು ಬದಲಾಯಿಸಬಹುದು.


Soft hooks use INT3 breakpoint handlers.

ಸಾಫ್ಟ್ ಹುಕ್ಸ್ INT3 ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ಗಳನ್ನು ಬಳಸುತ್ತವೆ.


Hard hooks directly modify the target's assembly.

ಹಾರ್ಡ್ ಹುಕ್ಸ್ ನೇರವಾಗಿ ಗುರಿಯ ಅಸೆಂಬ್ಲಿಯನ್ನು ಮಾರ್ಪಡಿಸುತ್ತವೆ.


Hard hooks have less impact on the target process.

ಹಾರ್ಡ್ ಹುಕ್ಸ್ ಗುರಿ ಪ್ರಕ್ರಿಯೆಯ ಮೇಲೆ ಕಡಿಮೆ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ.


We can sniff encrypted traffic using soft hooks.

ನಾವು ಸಾಫ್ಟ್ ಹುಕ್ಸ್ ಬಳಸಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಸ್ನಿಫ್ ಮಾಡಬಹುದು.


The PR_Write function is a good place to set a hook.

PR_Write ಕಾರ್ಯವು ಹುಕ್ ಅನ್ನು ಹೊಂದಿಸಲು ಉತ್ತಮ ಸ್ಥಳವಾಗಿದೆ.


The FastLogHook object creates an allocated region of memory to store captured information.

FastLogHook ವಸ್ತು ಸೆರೆಹಿಡಿಯಲಾದ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.


You must query this page using the wrapper function getAllLog() to retrieve the hook results.

ಹುಕ್ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯಲು ನೀವು getAllLog() ಎಂಬ ಸುತ್ತು ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಪುಟವನ್ನು ಪ್ರಶ್ನಿಸಬೇಕು.


STDCALLFastLogHook is adjusted for the STDCALL calling convention.

STDCALLFastLogHook ಅನ್ನು STDCALL ಕರೆ ಸಮ್ಮೇಳನಕ್ಕಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ.


The usage of the two, however, is the same.

ಆದಾಗ್ಯೂ, ಎರಡರ ಬಳಕೆಯು ಒಂದೇ ಆಗಿರುತ್ತದೆ.


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 ಗಾಗಿ ನಾವು ಮೂರು ವಾದಗಳನ್ನು ಸೆರೆಹಿಡಿಯಲಿದ್ದೇವೆ.


Now that we have an understanding of the hook points, open up a new Python file.

ಹುಕ್ ಪಾಯಿಂಟ್‌ಗಳ ಬಗ್ಗೆ ನಮಗೆ ತಿಳಿದಿರುವ ಕಾರಣ, ಹೊಸ ಪೈಥಾನ್ ಫೈಲ್ ತೆರೆಯಿರಿ.


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

ಇದು ಸರಿಯಾದ ಮೂಲ ಬ್ಲಾಕ್ ಅನ್ನು ಹುಡುಕುವ ನಿಕೋ ಅವರ ಕಾರ್ಯವಾಗಿದೆ.


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

ಪೈಥಾನ್ ಕೋಡ್ ಕಾರ್ಯದ ಮುಖ್ಯಸ್ಥರಲ್ಲಿ ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.


Get used to writing these little utility functions.

ಈ ಸಣ್ಣ ಉಪಯುಕ್ತತೆ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ಬಳಸಿ.


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.

ಹುಕ್ಗಳನ್ನು ಹೊಂದಿಸಲು ನೀವು ಅದನ್ನು ಒಮ್ಮೆ ರನ್ ಮಾಡುವಂತೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


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

RtlAllocateHeap ಕರೆಗಾಗಿ, ನಾವು ಸ್ಟಾಕ್‌ನಿಂದ ಮೂರು ವಾದಗಳನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತಿದ್ದೇವೆ.


In less than 100 lines of code we have employed an extremely powerful hooking technique.

100 ಸಾಲುಗಳಿಗಿಂತ ಕಡಿಮೆ ಕೋಡ್‌ನಲ್ಲಿ ನಾವು ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾದ ಹುಕಿಂಗ್ ತಂತ್ರವನ್ನು ಬಳಸಿದ್ದೇವೆ.


Let’s use notepad.exe and see if Nico was accurate.

ನೋಟ್‌ಪ್ಯಾಡ್.ಎಕ್ಸ್‌ಇ ಅನ್ನು ಬಳಸೋಣ ಮತ್ತು ನಿಕೋ ನಿಖರವಾಗಿದ್ದಾರೆಯೇ ಎಂದು ನೋಡೋಣ.


We have some results, and if you look at the status bar, it will report the number of hits.

ನಮಗೆ ಕೆಲವು ಫಲಿತಾಂಶಗಳಿವೆ, ಮತ್ತು ನೀವು ಸ್ಥಿತಿ ಪಟ್ಟಿಯನ್ನು ನೋಡಿದರೆ, ಅದು ಹಿಟ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ.


Hooking is something that you’ll undoubtedly use countless times.

ಹುಕಿಂಗ್ ಎನ್ನುವುದು ನೀವು ನಿಸ್ಸಂದೇಹವಾಗಿ ಲೆಕ್ಕವಿಲ್ಲದಷ್ಟು ಬಾರಿ ಬಳಸುವ ವಿಷಯವಾಗಿದೆ.


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.

ನಂತರ ನಾವು ಇದಕ್ಕೆ ಆಜ್ಞೆಯನ್ನು ಕಳುಹಿಸಿದಾಗ, ನಾವು ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದ್ದೇವೆಯೇ, ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ಮರುಸ್ಥಾಪಿಸುತ್ತಿದ್ದೇವೆಯೇ ಅಥವಾ ಕ್ವಿಟ್ ಮಾಡುತ್ತಿದ್ದೇವೆಯೇ ಎಂದು ಅದು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ.


The file fuzzer selects a file randomly from a directory.

ಫೈಲ್ ಫಜರ್ ಒಂದು ಡೈರೆಕ್ಟರಿಯಿಂದ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಫೈಲ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.


It then copies the selected file to a temporary location.

ನಂತರ, ಆಯ್ದ ಫೈಲ್ ಅನ್ನು ತಾತ್ಕಾಲಿಕ ಸ್ಥಳಕ್ಕೆ ನಕಲಿಸುತ್ತದೆ.


The fuzzer applies mutations to the copied file.

ಫಜರ್ ನಕಲು ಮಾಡಿದ ಫೈಲ್‌ಗೆ ರೂಪಾಂತರಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.


These mutations are based on predefined test cases.

ಈ ರೂಪಾಂತರಗಳು ಪೂರ್ವನಿರ್ಧರಿತ ಪರೀಕ್ಷಾ ಪ್ರಕರಣಗಳನ್ನು ಆಧರಿಸಿವೆ.


The mutated file is then used to test the target application.

ನಂತರ, ರೂಪಾಂತರಗೊಂಡ ಫೈಲ್ ಅನ್ನು ಗುರಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.


The fuzzer monitors the application for crashes.

ಫಜರ್ ಕ್ರ್ಯಾಶ್‌ಗಳಿಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ.


If a crash occurs, the fuzzer records the crash information.

ಕ್ರ್ಯಾಶ್ ಸಂಭವಿಸಿದಲ್ಲಿ, ಫಜರ್ ಕ್ರ್ಯಾಶ್ ಮಾಹಿತಿಯನ್ನು ದಾಖಲಿಸುತ್ತದೆ.


The fuzzer also includes an email notification routine.

ಫಜರ್ ಇಮೇಲ್ ಅಧಿಸೂಚನೆ ದಿನಚರಿಯನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ.


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 can be used to test various applications.

ವಿವಿಧ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಫಜರ್ ಅನ್ನು ಬಳಸಬಹುದು.


Code coverage is a metric for measuring code execution.

ಕೋಡ್ ಕವರೇಜ್ ಎನ್ನುವುದು ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಅಳೆಯುವ ಒಂದು ಮೆಟ್ರಿಕ್ ಆಗಿದೆ.


Automated static analysis can help find vulnerabilities.

ಸ್ವಯಂಚಾಲಿತ ಸ್ಥಿರ ವಿಶ್ಲೇಷಣೆಯು ದುರ್ಬಲತೆಗಳನ್ನು ಹುಡುಕಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


Sulley is a Python-based fuzzing framework.

ಸುಲ್ಲಿ ಪೈಥಾನ್ ಆಧಾರಿತ ಫಜಿಂಗ್ ಚೌಕಟ್ಟಾಗಿದೆ.


ಸುಲ್ಲಿ ಬ್ಲಾಕ್-ಆಧಾರಿತ ಫಜಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


Primitives are the building blocks of a protocol description.

ಆರಂಭಿಕಗಳು ಪ್ರೋಟೋಕಾಲ್ ವಿವರಣೆಯ ನಿರ್ಮಾಣ ಘಟಕಗಳಾಗಿವೆ.


Strings, delimiters, and integers are examples of primitives.

ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ಡಿಲಿಮಿಟರ್‌ಗಳು ಮತ್ತು ಪೂರ್ಣಾಂಕಗಳು ಆರಂಭಿಕಗಳ ಉದಾಹರಣೆಗಳಾಗಿವೆ.


Blocks and groups help 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.

ವಿಶೇಷ ಪರಿಕರಗಳಿಲ್ಲದೆ, ಕಂಪ್ಯೂಟರ್ ಬಳಕೆದಾರರು ADS ಗಳ ವಿಷಯವನ್ನು ನೋಡಲು ಸಾಧ್ಯವಿಲ್ಲ, ಇದು ನಮಗೆ ಸೂಕ್ತವಾಗಿದೆ.


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.

ಒಂದು ಫೈಲ್ ಅನ್ನು ಸರಳವಾಗಿ ಓದುವ ಮತ್ತು ಅದನ್ನು ನಾವು ಆಯ್ಕೆ ಮಾಡಿದ ಫೈಲ್‌ಗೆ ಲಗತ್ತಿಸಲಾದ ADS ಗೆ ಬರೆಯುವ ತ್ವರಿತ ಉಪಯುಕ್ತತಾ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯೋಣ.


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 ಆಗಿದೆ, ಮತ್ತು ಎರಡನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಗುರಿ ಫೈಲ್ ಆಗಿದ್ದು, ಅದರ ADS ನಲ್ಲಿ ನಾವು 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.

ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್‌ನೊಂದಿಗೆ ನಾವು ಇಷ್ಟಪಡುವ ಯಾವುದೇ ರೀತಿಯ ಫೈಲ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು ಈ ಸಣ್ಣ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ನಾವು ADS ನಿಂದ ನೇರವಾಗಿ DLL ಗಳನ್ನು ಸೇರಿಸಬಹುದು.


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 ಎಂದು ಹೆಸರಿಸಿ ಮತ್ತು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ನಮೂದಿಸಿ.


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 ಇಂಜೆಕ್ಷನ್ ಎರಡನ್ನೂ ನಿರ್ವಹಿಸಬಲ್ಲದು.


Now it’s time to inject two separate pieces of shellcode into the real calc.exe process, one to give us the reverse shell and one to kill our deviant process.

ಈಗ ಎರಡು ಪ್ರತ್ಯೇಕ ಶೆಲ್‌ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ನಿಜವಾದ calc.exe ಪ್ರಕ್ರಿಯೆಗೆ ಸೇರಿಸಲು ಸಮಯವಾಗಿದೆ, ಒಂದು ನಮಗೆ ರಿವರ್ಸ್ ಶೆಲ್ ನೀಡಲು ಮತ್ತು ಇನ್ನೊಂದು ನಮ್ಮ ವಿಚಲಿತ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲಲು.


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 ಸರ್ವರ್‌ನ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯದ ಒಂದು ಸಣ್ಣ ಭಾಗವಾಗಿರುವುದರಿಂದ, ನಾವು ದೃಢೀಕರಿಸಿದ ನಂತರ ಕೆಲವು ದೋಷಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಕೆಲವು ಆಜ್ಞೆಗಳನ್ನು ಸೇರಿಸೋಣ.


Take a look at Listing 9-2 for some additional commands we will include in our protocol skeleton.

ನಮ್ಮ ಪ್ರೋಟೋಕಾಲ್ ಅಸ್ಥಿಪಂಜರದಲ್ಲಿ ನಾವು ಸೇರಿಸುವ ಕೆಲವು ಹೆಚ್ಚುವರಿ ಆಜ್ಞೆಗಳಿಗಾಗಿ ಪಟ್ಟಿ 9-2 ಅನ್ನು ನೋಡಿ.


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

FTP ಪ್ರೋಟೋಕಾಲ್‌ನಿಂದ ಬೆಂಬಲಿತವಾಗಿರುವ ಎಲ್ಲಾ ಆಜ್ಞೆಗಳ ಸಂಪೂರ್ಣ ತಿಳುವಳಿಕೆ ಪಡೆಯಲು, ದಯವಿಟ್ಟು ಅದರ RFC ಅನ್ನು ನೋಡಿ.


CWD <DIRECTORY> - change working directory to DIRECTORY

CWD <DIRECTORY> - ಕೆಲಸದ ಡೈರೆಕ್ಟರಿಯನ್ನು DIRECTORY ಗೆ ಬದಲಾಯಿಸಿ


DELE <FILENAME> - delete a remote file FILENAME

DELE <FILENAME> - ದೂರಸ್ಥ ಫೈಲ್ FILENAME ಅನ್ನು ಅಳಿಸಿ


MDTM <FILENAME> - return last modified time for file FILENAME

MDTM <FILENAME> - ಫೈಲ್ FILENAME ಗಾಗಿ ಕೊನೆಯದಾಗಿ ಮಾರ್ಪಡಿಸಿದ ಸಮಯವನ್ನು ಹಿಂದಿರುಗಿಸಿ


MKD <DIRECTORY> - create directory DIRECTORY

MKD <DIRECTORY> - ಡೈರೆಕ್ಟರಿ DIRECTORY ಅನ್ನು ರಚಿಸಿ


It’s a far from an exhaustive list, but it gives us some additional coverage, so let’s take what we know and translate it into a Sulley protocol description.

ಇದು ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯಿಂದ ದೂರವಿದೆ, ಆದರೆ ಇದು ನಮಗೆ ಕೆಲವು ಹೆಚ್ಚುವರಿ ವ್ಯಾಪ್ತಿಯನ್ನು ನೀಡುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ತಿಳಿದಿರುವುದನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಸುಲ್ಲಿ ಪ್ರೋಟೋಕಾಲ್ ವಿವರಣೆಗೆ ಭಾಷಾಂತರಿಸೋಣ.


We’ll use our knowledge of Sulley data primitives to turn Sulley into a lean, mean FTP server–breaking machine.

ಸುಲ್ಲಿಯನ್ನು ಲೀನ್, ಮೀನ್ FTP ಸರ್ವರ್-ಬ್ರೇಕಿಂಗ್ ಯಂತ್ರವನ್ನಾಗಿ ಪರಿವರ್ತಿಸಲು ನಾವು ಸುಲ್ಲಿ ಡೇಟಾ ಪ್ರಿಮಿಟಿವ್‌ಗಳ ನಮ್ಮ ಜ್ಞಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.


Warm up your code editor, create a new file called ftp.py, and enter the following code.

ನಿಮ್ಮ ಕೋಡ್ ಸಂಪಾದಕವನ್ನು ಬೆಚ್ಚಗಾಗಿಸಿ, ftp.py ಎಂಬ ಹೊಸ ಫೈಲ್ ರಚಿಸಿ ಮತ್ತು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ನಮೂದಿಸಿ.


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.

ಸುಲ್ಲಿ ಸೆಷನ್‌ಗಳು ವಿನಂತಿಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸುವ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಪ್ಯಾಕೆಟ್ ಸೆರೆಹಿಡಿಯುವಿಕೆ, ಪ್ರಕ್ರಿಯೆ ಡೀಬಗ್ ಮಾಡುವಿಕೆ, ಕ್ರ್ಯಾಶ್ ವರದಿ ಮಾಡುವಿಕೆ ಮತ್ತು ವರ್ಚುವಲ್ ಮೆಷಿನ್ ನಿಯಂತ್ರಣವನ್ನು ನೋಡಿಕೊಳ್ಳುವ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ.


Crack open a new Python file, name it ftp_session.py, and enter the following code.

ಹೊಸ ಪೈಥಾನ್ ಫೈಲ್ ಅನ್ನು ತೆರೆಯಿರಿ, ಅದಕ್ಕೆ ftp_session.py ಎಂದು ಹೆಸರಿಸಿ ಮತ್ತು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ನಮೂದಿಸಿ.


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.

ಎರಡನೆಯ ಹಂತವೆಂದರೆ ದಾಳಿ ಮಾಡಲು ಗುರಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು, ಇದು IP ವಿಳಾಸ ಮತ್ತು ಪೋರ್ಟ್ ಸಂಖ್ಯೆ.


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.

ಮೂರನೇ ನಮೂದು ಸುಲ್ಲಿಗೆ ನಮ್ಮ ನೆಟ್‌ವರ್ಕ್ ಸ್ನಿಫರ್ ಅದೇ ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಹೊಂದಿಸಲ್ಪಟ್ಟಿದೆ ಮತ್ತು TCP ಪೋರ್ಟ್ 26001 ನಲ್ಲಿ ಕೇಳುತ್ತಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ, ಇದು ಸುಲ್ಲಿಯಿಂದ ಆಜ್ಞೆಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಪೋರ್ಟ್ ಆಗಿದೆ.


We then add the defined target to our parent session.

ನಂತರ ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಗುರಿಯನ್ನು ನಮ್ಮ ಪೋಷಕ ಸೆಷನ್‌ಗೆ ಸೇರಿಸುತ್ತೇವೆ.


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 ಕೋಡ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಹೋಗೋಣ.


When a driver loads, the first function that gets called is the DriverEntry routine.

ಚಾಲಕ ಲೋಡ್ ಆದಾಗ, ಕರೆಯಲಾಗುವ ಮೊದಲ ಕಾರ್ಯವೆಂದರೆ DriverEntry ದಿನಚರಿ.


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.

ಈ ಸೂಚನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು, IOCTL-ನಿರ್ವಹಣಾ ದಿನಚರಿ ಎಲ್ಲಿ ವಾಸಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ತೀರ್ಮಾನಿಸಬಹುದು.


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

ಈ ಕೋಡ್ ನಮ್ಮ ಹುಡುಕಾಟ ಮಾನದಂಡಗಳ ವಿರುದ್ಧ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಹೊಂದಾಣಿಕೆಗಳನ್ನು ಹುಡುಕಲು ಇಮ್ಯುನಿಟಿ ಡೀಬಗರ್‌ನ ಪ್ರಬಲ ಹುಡುಕಾಟ API ಅನ್ನು ಬಳಸುತ್ತದೆ.


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 ಕೋಡ್‌ನಿಂದ ನಿರ್ಧರಿಸಲ್ಪಟ್ಟ ಪ್ರತಿಯೊಂದು ಸಂಭವನೀಯ ಮಾರ್ಗಗಳನ್ನು ಚಲಾಯಿಸಲು ನಾವು ಬಯಸುತ್ತೇವೆ, ಅದಕ್ಕಾಗಿಯೇ ನಾವು ಈ ಮೌಲ್ಯಗಳನ್ನು ಹುಡುಕುವ ಎಲ್ಲಾ ತೊಂದರೆಗಳಿಗೆ ಹೋಗುತ್ತೇವೆ.


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

ಕಾರ್ಯ ಕೋಡ್ ಅನ್ನು IOCTL ವಿನಂತಿಯಿಂದ ಪಡೆದ ನಂತರ, ಚಾಲಕವು ಕಳುಹಿಸಲಾಗುತ್ತಿರುವ IOCTL ಕೋಡ್‌ನ ಆಧಾರದ ಮೇಲೆ ಯಾವ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಸ್ವಿಚ್ ಹೇಳಿಕೆಯನ್ನು ನೋಡುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ.


There can be many ways that the switch statement gets translated into assembly, but these are the most common two that I have encountered.

ಸ್ವಿಚ್ ಹೇಳಿಕೆಯನ್ನು ಅಸೆಂಬ್ಲಿಗೆ ಅನುವಾದಿಸಲು ಹಲವು ಮಾರ್ಗಗಳಿವೆ, ಆದರೆ ನಾನು ಎದುರಿಸಿದ ಸಾಮಾನ್ಯ ಎರಡು ಇವು.


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 ಕೋಡ್ ಆಗಿರಬೇಕು.


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 will use driverlib to hunt down device names and supported IOCTL codes from a driver and save these results to a Python pickle.

ನಾವು ಚಾಲಕನಿಂದ ಸಾಧನದ ಹೆಸರುಗಳು ಮತ್ತು ಬೆಂಬಲಿತ IOCTL ಕೋಡ್‌ಗಳನ್ನು ಹುಡುಕಲು ಮತ್ತು ಈ ಫಲಿತಾಂಶಗಳನ್ನು ಪೈಥಾನ್ ಉಪ್ಪಿನಕಾಯಿಗೆ ಉಳಿಸಲು ಡ್ರೈವರ್‌ಲಿಬ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.


The first step is to create our IOCTL-dumping PyCommand to run inside Immunity Debugger.

ಮೊದಲನೆಯದು ಇಮ್ಯುನಿಟಿ ಡೀಬಗರ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಲು ನಮ್ಮ IOCTL-ಡಂಪಿಂಗ್ PyCommand ಅನ್ನು ರಚಿಸುವುದು.


Simply load a target driver into Immunity Debugger and run the PyCommand like so: !ioctl_dump.

ಸರಳವಾಗಿ ಟಾರ್ಗೆಟ್ ಡ್ರೈವರ್ ಅನ್ನು ಇಮ್ಯುನಿಟಿ ಡೀಬಗರ್‌ಗೆ ಲೋಡ್ ಮಾಡಿ ಮತ್ತು PyCommand ಅನ್ನು ಈ ರೀತಿ ರನ್ ಮಾಡಿ: !ioctl_dump.


If your fuzzer does actually crash the machine you’re working on, it will be fairly obvious which IOCTL code caused it, because your log file will show you the last IOCTL code that had successfully been run.

ನಿಮ್ಮ ಫಝರ್ ನೀವು ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ಯಂತ್ರವನ್ನು ನಿಜವಾಗಿಯೂ ಕ್ರ್ಯಾಶ್ ಮಾಡಿದರೆ, ಯಾವ IOCTL ಕೋಡ್ ಅದನ್ನು ಉಂಟುಮಾಡಿದೆ ಎಂಬುದು ಸಾಕಷ್ಟು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ನಿಮ್ಮ ಲಾಗ್ ಫೈಲ್ ನಿಮಗೆ ಕೊನೆಯದಾಗಿ ಯಶಸ್ವಿಯಾಗಿ ಚಲಾಯಿಸಲಾದ IOCTL ಕೋಡ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ.


Listing 11-1. Cross References to sprintf

ಪಟ್ಟಿ 11-1. sprintf ಗೆ ಅಡ್ಡ ಉಲ್ಲೇಖಗಳು


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

ಪಟ್ಟಿ ಮಾಡಲಾದ ಎಲ್ಲಾ ವಿಳಾಸಗಳು sprintf ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತಿರುವ ಸ್ಥಳಗಳಾಗಿವೆ.


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 ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.


After running this against a binary, you should see some output (providing there are some stack- allocated buffers).

ಬೈನರಿಗೆ ವಿರುದ್ಧವಾಗಿ ಇದನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ, ನೀವು ಕೆಲವು ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡಬೇಕು (ಕೆಲವು ಸ್ಟಾಕ್-ಹಂಚಿಕೆಯ ಬಫರ್‌ಗಳನ್ನು ಒದಗಿಸುವುದು).


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 ರಲ್ಲಿ ಬಿಡುಗಡೆ ಮಾಡಲಾಯಿತು, ಇದು TippingPoint DVLabs ತಂಡದ ಪ್ರತಿಭಾವಂತ ಸದಸ್ಯರಲ್ಲಿ ಒಬ್ಬರು.


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 ವರ್ಗವನ್ನು ಬಿಡುತ್ತೇವೆ.


First we instantiate the IDAPyEmu object.

ಮೊದಲಿಗೆ ನಾವು IDAPyEmu ವಸ್ತುವನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ.


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.

ವಿಭಾಗಗಳ ಆರಂಭವನ್ನು ಹುಡುಕಲು ನಾವು IDAPython SegByName() ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ.


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.

ಈಗ ನಾವು ಕೋಡ್ ಮತ್ತು ಡೇಟಾ ವಿಭಾಗಗಳನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ, ನಾವು ಫಂಕ್ಷನ್ ಕರೆಗಾಗಿ ಸ್ಟಾಕ್ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ.


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

ನಂತರ ನಾವು ಫಂಕ್ಷನ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ 10 ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು PyEmu ಗೆ ಹೇಳುತ್ತೇವೆ.


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

ರಿಟ್ ಸೂಚನಾ ನಿರ್ವಾಹಕರು ಸ್ಟಾಕ್ ವಾದಗಳನ್ನು ಮತ್ತು 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.

ಒಂದು ಕಾರ್ಯವು ಅನೇಕ ಶಾಖೆಗಳು, ಲೂಪ್‌ಗಳು ಮತ್ತು ರಿಟರ್ನ್ ಪಾಯಿಂಟ್‌ಗಳೊಂದಿಗೆ ನೂರಾರು ಅಥವಾ ಸಾವಿರಾರು ಸೂಚನೆಗಳನ್ನು ಹೊಂದಿರುವಾಗ ಈ ತಂತ್ರವು ಎಷ್ಟು ಶಕ್ತಿಯುತವಾಗಿದೆ ಎಂದು ನೀವು ಆಶ್ಚರ್ಯಚಕಿತರಾಗುವಿರಿ.


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

ಈಗ ಕಂಪ್ರೆಸ್ಡ್ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಅನ್ನು ಅನ್ಪ್ಯಾಕ್ ಮಾಡಲು PEPyEmu ಲೈಬ್ರರಿಯನ್ನು ಬಳಸೋಣ.


Executable packers or compressors have been around for quite some time.

ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಪ್ಯಾಕರ್‌ಗಳು ಅಥವಾ ಕಂಪ್ರೆಸರ್‌ಗಳು ಸಾಕಷ್ಟು ಸಮಯದಿಂದ ಬಳಕೆಯಲ್ಲಿವೆ.


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) ಜಂಪ್ ಮಾಡುತ್ತದೆ.


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

ಪ್ಯಾಕ್ ಮಾಡಲಾದ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಅನ್ನು ಎದುರಿಸಿದಾಗ, ನಿಜವಾದ ಬೈನರಿಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಶ್ಲೇಷಿಸಲು ರಿವರ್ಸರ್ ಮೊದಲು ಪ್ಯಾಕರ್ ಅನ್ನು ತೊಡೆದುಹಾಕಬೇಕು.


This is where using an emulator can be beneficial, as no debugger is being attached to the running executable.

ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಬಳಸುವುದು ಇಲ್ಲಿ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ, ಏಕೆಂದರೆ ಯಾವುದೇ ಡೀಬಗರ್ ಅನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್‌ಗೆ ಲಗತ್ತಿಸಲಾಗುವುದಿಲ್ಲ.


We are going to use UPX to compress the calc.exe file that ships with all flavors of Windows.

ನಾವು ವಿಂಡೋಸ್‌ನ ಎಲ್ಲಾ ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ಬರುವ calc.exe ಫೈಲ್ ಅನ್ನು ಸಂಕುಚಿತಗೊಳಿಸಲು UPX ಅನ್ನು ಬಳಸಲಿದ್ದೇವೆ.


This will produce a compressed version of the Windows calculator and store it in your C: directory.

ಇದು ವಿಂಡೋಸ್ ಕ್ಯಾಲ್ಕುಲೇಟರ್‌ನ ಸಂಕುಚಿತ ಆವೃತ್ತಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ C: ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ.


We now have a fully packed file to test in our PyEmu harness, so let’s get coding!

ನಮ್ಮ PyEmu ಹಾರ್ನೆಸ್‌ನಲ್ಲಿ ಪರೀಕ್ಷಿಸಲು ನಾವು ಈಗ ಸಂಪೂರ್ಣವಾಗಿ ಪ್ಯಾಕ್ ಮಾಡಲಾದ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ಕೋಡಿಂಗ್ ಮಾಡೋಣ!


The UPX packer uses a fairly straightforward method for compressing executables.

UPX ಪ್ಯಾಕರ್ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್‌ಗಳನ್ನು ಸಂಕುಚಿತಗೊಳಿಸಲು ಸಾಕಷ್ಟು ನೇರವಾದ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತದೆ.


We can see that the UPX1 section contains code, and this is where the UPX packer creates the main unpacking routine.

UPX1 ವಿಭಾಗವು ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ ಎಂದು ನಾವು ನೋಡಬಹುದು, ಮತ್ತು ಇಲ್ಲಿಯೇ UPX ಪ್ಯಾಕರ್ ಮುಖ್ಯ ಅನ್ಪ್ಯಾಕಿಂಗ್ ದಿನಚರಿಯನ್ನು ರಚಿಸುತ್ತದೆ.


Python is fast becoming the programming language of choice for hackers.

ಹ್ಯಾಕರ್‌ಗಳಿಗೆ ಪೈಥಾನ್ ಈಗ ಆಯ್ಕೆಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗುತ್ತಿದೆ.


Gray Hat Python explains the concepts behind hacking tools and techniques.

ಗ್ರೇ ಹ್ಯಾಟ್ ಪೈಥಾನ್ ಹ್ಯಾಕಿಂಗ್ ಪರಿಕರಗಳು ಮತ್ತು ತಂತ್ರಗಳ ಹಿಂದಿನ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ವಿವರಿಸುತ್ತದೆ.


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

ನೀವು ಬೇಸರದ ರಿವರ್ಸಿಂಗ್ ಮತ್ತು ಭದ್ರತಾ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬೇಕೆಂದು ಕಲಿಯುವಿರಿ.


ನಿಮ್ಮ ಸ್ವಂತ ಡೀಬಗರ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಮಾಡಿ.


Learn how to fuzz Windows drivers and create powerful fuzzers from scratch.

ವಿಂಡೋಸ್ ಡ್ರೈವರ್‌ಗಳನ್ನು ಫಜ್ ಮಾಡುವುದು ಹೇಗೆ ಮತ್ತು ಮೊದಲಿನಿಂದ ಪ್ರಬಲ ಫಜರ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿಯಿರಿ.


Sniff secure traffic out of an encrypted web browser session.

ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ವೆಬ್ ಬ್ರೌಸರ್ ಸೆಷನ್‌ನಿಂದ ಸುರಕ್ಷಿತ ದಟ್ಟಣೆಯನ್ನು ಸ್ನಿಫ್ ಮಾಡಿ.


The world’s best hackers are using Python to do their handiwork.

ವಿಶ್ವದ ಅತ್ಯುತ್ತಮ ಹ್ಯಾಕರ್‌ಗಳು ತಮ್ಮ ಕೆಲಸವನ್ನು ಮಾಡಲು ಪೈಥಾನ್ ಬಳಸುತ್ತಿದ್ದಾರೆ.


ನೀವು ಮಾಡಬಾರದೇ?


Justin Seitz is a senior security researcher for immunity, inc.

ಜಸ್ಟಿನ್ ಸೀಟ್ಸ್ ಅವರು ಇಮ್ಯುನಿಟಿ, ಇಂಕ್‌ಗಾಗಿ ಹಿರಿಯ ಭದ್ರತಾ ಸಂಶೋಧಕರಾಗಿದ್ದಾರೆ.


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

ಪುಸ್ತಕವನ್ನು ಮಿಚಿಗನ್‌ನ ಆನ್ ಅರ್ಬರ್‌ನಲ್ಲಿರುವ ಮಾಲೋಯ್ ಇನ್‌ಕಾರ್ಪೊರೇಟೆಡ್‌ನಲ್ಲಿ ಮುದ್ರಿಸಿ, ಕಟ್ಟಲಾಗಿದೆ.


The paper is Glatfelter Spring Forge 60# Antique.

ಕಾಗದವು ಗ್ಲಾಟ್‌ಫೆಲ್ಟರ್ ಸ್ಪ್ರಿಂಗ್ ಫೋರ್ಜ್ 60# ಆಂಟಿಕ್ ಆಗಿದೆ.


Visit http://www.nostarch.com/ghpython.htm for updates, errata, and other information.

ನವೀಕರಣಗಳು, ದೋಷಪರಿಹಾರ ಮತ್ತು ಇತರ ಮಾಹಿತಿಗಾಗಿ http://www.nostarch.com/ghpython.htm ಗೆ ಭೇಟಿ ನೀಡಿ.


Python Programming for hackers and reverse engineers

ಹ್ಯಾಕರ್‌ಗಳು ಮತ್ತು ರಿವರ್ಸ್ ಎಂಜಿನಿಯರ್‌ಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್


Hacking is the art of creative problem solving.

ಹ್ಯಾಕಿಂಗ್ ಎಂದರೆ ಸೃಜನಾತ್ಮಕ ಸಮಸ್ಯೆ ಪರಿಹಾರದ ಕಲೆ.


Rather than merely showing how to run existing exploits, Hacking: The Art of Exploitation, 2nd Edition author Jon Erickson explains how arcane hacking techniques actually work.

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಶೋಷಣೆಗಳನ್ನು ಹೇಗೆ ಚಲಾಯಿಸಬೇಕೆಂದು ತೋರಿಸುವ ಬದಲು, ಹ್ಯಾಕಿಂಗ್: ದಿ ಆರ್ಟ್ ಆಫ್ ಎಕ್ಸ್‌ಪ್ಲೋಯಿಟೇಶನ್, 2ನೇ ಆವೃತ್ತಿಯ ಲೇಖಕ ಜಾನ್ ಎರಿಕ್ಸನ್ ಅವರು ರಹಸ್ಯ ಹ್ಯಾಕಿಂಗ್ ತಂತ್ರಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತಾರೆ.


Using the included LiveCD, get your hands dirty debugging code.

ಒಳಗೊಂಡಿರುವ ಲೈವ್‌ಸಿಡಿಯನ್ನು ಬಳಸಿಕೊಂಡು, ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವ ಮೂಲಕ ನಿಮ್ಮ ಕೈಗಳನ್ನು ಕೊಳಕು ಮಾಡಿ.


Author Michal Zalewski has long been known and respected in the hacking and security communities.

ಲೇಖಕ ಮಿಖಾಲ್ ಝಲೆವ್ಸ್ಕಿ ಅವರು ಹ್ಯಾಕಿಂಗ್ ಮತ್ತು ಭದ್ರತಾ ಸಮುದಾಯಗಳಲ್ಲಿ ಬಹಳ ಹಿಂದಿನಿಂದಲೂ ಹೆಸರುವಾಸಿಯಾಗಿದ್ದಾರೆ ಮತ್ತು ಗೌರವಿಸಲ್ಪಟ್ಟಿದ್ದಾರೆ.


This book is truly unlike anything else out there.

ಈ ಪುಸ್ತಕವು ನಿಜವಾಗಿಯೂ ಅಲ್ಲಿರುವ ಯಾವುದಕ್ಕೂ ಹೋಲುವಂತಿಲ್ಲ.


Security data visualization tools offer graphical windows into the world of computer security data.

ಭದ್ರತಾ ಡೇಟಾ ದೃಶ್ಯೀಕರಣ ಪರಿಕರಗಳು ಕಂಪ್ಯೂಟರ್ ಭದ್ರತಾ ಡೇಟಾದ ಜಗತ್ತಿಗೆ ಚಿತ್ರಾತ್ಮಕ ವಿಂಡೋಗಳನ್ನು ನೀಡುತ್ತವೆ.


After learning how to graph and display data correctly, readers will be able to understand complex data sets at a glance.

ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ಹೇಗೆ ಗ್ರಾಫ್ ಮಾಡುವುದು ಮತ್ತು ಪ್ರದರ್ಶಿಸುವುದು ಎಂಬುದನ್ನು ಕಲಿತ ನಂತರ, ಓದುಗರು ಒಂದು ನೋಟದಲ್ಲಿ ಸಂಕೀರ್ಣ ಡೇಟಾ ಸೆಟ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.