Python is a versatile programming language.

ਪਾਈਥਨ ਇੱਕ ਬਹੁਮੁਖੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ।


Hackers often use Python for its powerful libraries.

ਹੈਕਰ ਅਕਸਰ ਇਸਦੀਆਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਲਈ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।


The book explains how to build your own debugger.

ਕਿਤਾਬ ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਹਾਡਾ ਆਪਣਾ ਡੀਬੱਗਰ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ।


You will learn about fuzzing Windows drivers.

ਤੁਸੀਂ ਵਿੰਡੋਜ਼ ਡਰਾਈਵਰਾਂ ਨੂੰ ਫਜ਼ਿੰਗ ਬਾਰੇ ਸਿੱਖੋਗੇ।


ਆਪਣੇ ਸਿਸਟਮ 'ਤੇ ਪਾਈਥਨ 2.5 ਸਥਾਪਿਤ ਕਰੋ।


This chapter covers setting up the development environment.

ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਵਿਕਾਸ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਨ ਬਾਰੇ ਦੱਸਿਆ ਗਿਆ ਹੈ।


Python is becoming the language of choice for many.

ਪਾਈਥਨ ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਲਈ ਪਸੰਦੀਦਾ ਭਾਸ਼ਾ ਬਣ ਰਹੀ ਹੈ।


The book is designed for hackers and reverse engineers.

ਇਹ ਕਿਤਾਬ ਹੈਕਰਾਂ ਅਤੇ ਰਿਵਰਸ ਇੰਜੀਨੀਅਰਾਂ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ।


You can build your own security tools with Python.

ਤੁਸੀਂ ਪਾਈਥਨ ਨਾਲ ਆਪਣੇ ਖੁਦ ਦੇ ਸੁਰੱਖਿਆ ਟੂਲ ਬਣਾ ਸਕਦੇ ਹੋ।


The author shows how to use existing Python-based security tools.

ਲੇਖਕ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਮੌਜੂਦਾ ਪਾਈਥਨ-ਅਧਾਰਿਤ ਸੁਰੱਖਿਆ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ।


Automate tedious reversing and security tasks.

ਮਿਹਨਤੀ ਰਿਵਰਸਿੰਗ ਅਤੇ ਸੁਰੱਖਿਆ ਕਾਰਜਾਂ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰੋ।


ਆਪਣਾ ਡੀਬੱਗਰ ਡਿਜ਼ਾਈਨ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਕਰੋ।


ਸਿੱਖੋ ਕਿ ਵਿੰਡੋਜ਼ ਡਰਾਈਵਰਾਂ ਨੂੰ ਕਿਵੇਂ ਫਜ਼ ਕਰਨਾ ਹੈ।


Sniff secure traffic out of an encrypted web browser session.

ਇੱਕ ਏਨਕ੍ਰਿਪਟਡ ਵੈੱਬ ਬ੍ਰਾਊਜ਼ਰ ਸੈਸ਼ਨ ਤੋਂ ਸੁਰੱਖਿਅਤ ਟ੍ਰੈਫਿਕ ਨੂੰ ਸਨਿਫ ਕਰੋ।


The world's best hackers are using Python.

ਦੁਨੀਆ ਦੇ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈਕਰ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਨ।


This book is for those interested in computer security.

ਇਹ ਕਿਤਾਬ ਕੰਪਿਊਟਰ ਸੁਰੱਖਿਆ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਣ ਵਾਲਿਆਂ ਲਈ ਹੈ।


The book covers topics like debuggers and fuzzers.

ਕਿਤਾਬ ਵਿੱਚ ਡੀਬੱਗਰਾਂ ਅਤੇ ਫਜ਼ਰਾਂ ਵਰਗੇ ਵਿਸ਼ਿਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ।


ਪਾਈਥਨ ਸਿੱਖਣ ਅਤੇ ਵਰਤਣ ਵਿੱਚ ਆਸਾਨ ਹੈ।


ਕਿਤਾਬ ਵਿਹਾਰਕ ਉਦਾਹਰਣਾਂ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।


ਇਹ ਹੈਕਰਾਂ ਲਈ ਇੱਕ ਗਾਈਡ ਹੈ।


The debugger is responsible for handling access violations.

ਡੀਬੱਗਰ ਐਕਸੈਸ ਦੀ ਉਲੰਘਣਾ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ।


We can first see that printf() resolves to 0x77c4186a.

ਅਸੀਂ ਪਹਿਲਾਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ printf() 0x77c4186a 'ਤੇ ਹੱਲ ਹੁੰਦਾ ਹੈ।


The process should resume its loop after the breakpoint is handled.

ਬ੍ਰੇਕਪੁਆਇੰਟ ਨੂੰ ਸੰਭਾਲਣ ਤੋਂ ਬਾਅਦ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਆਪਣੇ ਲੂਪ ਨੂੰ ਮੁੜ ਸ਼ੁਰੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।


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

ਹਾਰਡਵੇਅਰ ਬ੍ਰੇਕਪੁਆਇੰਟ ਵਿੱਚ CPU ਦੇ ਡੀਬੱਗ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਬਿੱਟ ਸੈੱਟ ਕਰਨਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ।


We have to ensure that we are always using an empty slot.

ਸਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਪਏਗਾ ਕਿ ਅਸੀਂ ਹਮੇਸ਼ਾ ਇੱਕ ਖਾਲੀ ਸਲਾਟ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ।


Let’s start by enumerating all of the threads in the process.

ਆਓ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸਾਰੇ ਥ੍ਰੈਡਾਂ ਦੀ ਗਿਣਤੀ ਕਰਕੇ ਸ਼ੁਰੂਆਤ ਕਰੀਏ।


We then modify one of the registers between DR0 and DR3.

ਫਿਰ ਅਸੀਂ DR0 ਅਤੇ DR3 ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਰਜਿਸਟਰ ਨੂੰ ਸੋਧਦੇ ਹਾਂ।


We know that a hardware breakpoint triggers an INT1.

ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ ਕਿ ਇੱਕ ਹਾਰਡਵੇਅਰ ਬ੍ਰੇਕਪੁਆਇੰਟ ਇੱਕ INT1 ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹੈ।


Let’s start with setting the breakpoint.

ਆਓ ਬ੍ਰੇਕਪੁਆਇੰਟ ਸੈੱਟ ਕਰਨ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੀਏ।


ਇੱਕ ਵੈਧ ਲੰਬਾਈ ਮੁੱਲ ਲਈ ਜਾਂਚ ਕਰੋ।


We want to set the debug register in every thread.

ਅਸੀਂ ਹਰ ਥ੍ਰੈਡ ਵਿੱਚ ਡੀਬੱਗ ਰਜਿਸਟਰ ਸੈੱਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ।


ਬ੍ਰੇਕਪੁਆਇੰਟ ਦੀ ਸਥਿਤੀ ਸੈੱਟ ਕਰੋ।


You can see that we select an open slot to store the breakpoint.

ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਅਸੀਂ ਬ੍ਰੇਕਪੁਆਇੰਟ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਖੁੱਲ੍ਹਾ ਸਲਾਟ ਚੁਣਦੇ ਹਾਂ।


Now that we have the mechanism to support setting the breakpoints.

ਹੁਣ ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਬ੍ਰੇਕਪੁਆਇੰਟ ਸੈੱਟ ਕਰਨ ਦਾ ਸਮਰਥਨ ਕਰਨ ਦਾ ਤਰੀਕਾ ਹੈ।


If the debugger detects that there is a hardware breakpoint.

ਜੇਕਰ ਡੀਬੱਗਰ ਖੋਜਦਾ ਹੈ ਕਿ ਇੱਕ ਹਾਰਡਵੇਅਰ ਬ੍ਰੇਕਪੁਆਇੰਟ ਹੈ।


This concludes the development of a lightweight debugger on Windows.

ਇਹ ਵਿੰਡੋਜ਼ 'ਤੇ ਇੱਕ ਹਲਕੇ ਡੀਬੱਗਰ ਦੇ ਵਿਕਾਸ ਨੂੰ ਸਮਾਪਤ ਕਰਦਾ ਹੈ।


You should have a firm grip on building a debugger.

ਤੁਹਾਨੂੰ ਇੱਕ ਡੀਬੱਗਰ ਬਣਾਉਣ 'ਤੇ ਪੂਰਾ ਕੰਟਰੋਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।


We’ll now move on to learning how to harness the power of PyDbg.

ਹੁਣ ਅਸੀਂ ਇਹ ਸਿੱਖਣ ਲਈ ਅੱਗੇ ਵਧਾਂਗੇ ਕਿ PyDbg ਦੀ ਸ਼ਕਤੀ ਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ।


With a user-defined callback, we can implement custom logic.

ਇੱਕ ਉਪਭੋਗਤਾ-ਪ੍ਰਭਾਸ਼ਿਤ ਕਾਲਬੈਕ ਦੇ ਨਾਲ, ਅਸੀਂ ਕਸਟਮ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਾਂ।


ਇਹ ਇੱਕ ਸਧਾਰਨ ਪਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਉਦਾਹਰਣ ਹੈ।


The Python interpreter provides full access to included libraries.

ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਸ਼ਾਮਲ ਲਾਇਬ੍ਰੇਰੀਆਂ ਤੱਕ ਪੂਰੀ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


Edit the .bashrc file to ensure the interpreter is found automatically.

.bashrc ਫਾਈਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ ਕਿ ਇੰਟਰਪ੍ਰੇਟਰ ਆਪਣੇ ਆਪ ਮਿਲ ਜਾਵੇ।


I personally use nano for text editing, but use whatever editor you like.

ਮੈਂ ਨਿੱਜੀ ਤੌਰ 'ਤੇ ਟੈਕਸਟ ਸੰਪਾਦਨ ਲਈ ਨੈਨੋ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ, ਪਰ ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦਾ ਕੋਈ ਵੀ ਸੰਪਾਦਕ ਵਰਤ ਸਕਦੇ ਹੋ।


Add the line 'export PATH=/usr/local/Python25/:$PATH' to the .bashrc file.

.bashrc ਫਾਈਲ ਵਿੱਚ ਲਾਈਨ 'export PATH=/usr/local/Python25/:$PATH' ਸ਼ਾਮਲ ਕਰੋ।


After logging out and back in, typing 'python' will launch the interpreter.

ਲੌਗ ਆਉਟ ਕਰਨ ਅਤੇ ਵਾਪਸ ਲੌਗ ਇਨ ਕਰਨ ਤੋਂ ਬਾਅਦ, 'ਪਾਈਥਨ' ਟਾਈਪ ਕਰਨ ਨਾਲ ਇੰਟਰਪ੍ਰੇਟਰ ਲਾਂਚ ਹੋ ਜਾਵੇਗਾ।


Setting up an IDE is crucial for rapid Python development and debugging.

ਤੇਜ਼ ਪਾਈਥਨ ਵਿਕਾਸ ਅਤੇ ਡੀਬੱਗਿੰਗ ਲਈ ਇੱਕ IDE ਸਥਾਪਤ ਕਰਨਾ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੈ।


Eclipse and PyDev provide powerful features for Python development.

Eclipse ਅਤੇ PyDev ਪਾਈਥਨ ਵਿਕਾਸ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।


Download the Eclipse Classic package from the official website.

ਅਧਿਕਾਰਤ ਵੈੱਬਸਾਈਟ ਤੋਂ Eclipse Classic ਪੈਕੇਜ ਡਾਊਨਲੋਡ ਕਰੋ।


Unzip the package to a directory like C:\Eclipse.

ਪੈਕੇਜ ਨੂੰ C:\Eclipse ਵਰਗੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਅਨਜ਼ਿਪ ਕਰੋ।


Run C:\Eclipse\eclipse.exe to start the Eclipse IDE.

Eclipse IDE ਸ਼ੁਰੂ ਕਰਨ ਲਈ C:\Eclipse\eclipse.exe ਚਲਾਓ।


Configure Eclipse to use the PyDev plugin for Python development.

ਪਾਈਥਨ ਵਿਕਾਸ ਲਈ PyDev ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ Eclipse ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ।


Install PyDev through the Eclipse software updates feature.

Eclipse ਸੌਫਟਵੇਅਰ ਅੱਪਡੇਟ ਵਿਸ਼ੇਸ਼ਤਾ ਰਾਹੀਂ PyDev ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ।


Ensure PyDev can find the correct Python interpreter.

ਯਕੀਨੀ ਬਣਾਓ ਕਿ PyDev ਸਹੀ ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਨੂੰ ਲੱਭ ਸਕਦਾ ਹੈ।


Create a new PyDev project to hold your source files.

ਆਪਣੀਆਂ ਸੋਰਸ ਫਾਈਲਾਂ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਨਵਾਂ PyDev ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ।


Run Python scripts from Eclipse using the 'Run As' button.

'ਰਨ ਐਜ਼' ਬਟਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ Eclipse ਤੋਂ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟਾਂ ਚਲਾਓ।


The ctypes module is powerful for interacting with C libraries.

ctypes ਮੋਡੀਊਲ C ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ।


ctypes allows calling functions in dynamically linked libraries.

ctypes ਡਾਇਨਾਮਿਕ ਤੌਰ 'ਤੇ ਲਿੰਕ ਕੀਤੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।


Understand calling conventions like cdecl and stdcall.

ਕਾਲਿੰਗ ਕਨਵੈਨਸ਼ਨਾਂ ਨੂੰ ਸਮਝੋ ਜਿਵੇਂ ਕਿ cdecl ਅਤੇ stdcall।


The stack stores information about function calls and parameters.

ਸਟੈਕ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਅਤੇ ਪੈਰਾਮੀਟਰਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸਟੋਰ ਕਰਦਾ ਹੈ।


Debuggers are essential for dynamic analysis and reverse engineering.

ਡੀਬੱਗਰ ਡਾਇਨਾਮਿਕ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਰਿਵਰਸ ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ ਜ਼ਰੂਰੀ ਹਨ।


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

ESP ਰਜਿਸਟਰ ਦੀ ਵਰਤੋਂ ਸਟੈਕ ਫਰੇਮ ਦੇ ਸਭ ਤੋਂ ਉੱਪਰਲੇ ਹਿੱਸੇ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


The EBP register is used to track the bottom of the stack frame.

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.

ਜਦੋਂ 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.

ਇੱਕ ਡੀਬੱਗਰ ਦੇ ਅੰਦਰ ਸਟੈਕ ਫਰੇਮ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਬਹੁਤ ਉਪਯੋਗੀ ਹੈ।


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.

ਕੁਝ ਆਮ ਇਵੈਂਟ ਜੋ ਇੱਕ ਡੀਬੱਗਰ ਨੂੰ ਫਸਾਉਣੇ ਚਾਹੀਦੇ ਹਨ: ਬ੍ਰੇਕਪੁਆਇੰਟ ਹਿੱਟ, ਮੈਮੋਰੀ ਉਲੰਘਣਾਵਾਂ, ਡੀਬੱਗ ਕੀਤੇ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਗਏ ਅਪਵਾਦ।


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

ਇੱਕ ਸਕ੍ਰਿਪਟਡ ਡੀਬੱਗਰ ਦਾ ਇੱਕ ਫਾਇਦਾ ਕਸਟਮ ਇਵੈਂਟ ਹੈਂਡਲਰ ਬਣਾਉਣ ਦੀ ਸਮਰੱਥਾ ਹੈ।


For example, 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.

ਇੱਥੇ ਤਿੰਨ ਮੁੱਖ ਬ੍ਰੇਕਪੁਆਇੰਟ ਕਿਸਮਾਂ ਹਨ: ਸਾਫਟ ਬ੍ਰੇਕਪੁਆਇੰਟ, ਹਾਰਡਵੇਅਰ ਬ੍ਰੇਕਪੁਆਇੰਟ, ਅਤੇ ਮੈਮੋਰੀ ਬ੍ਰੇਕਪੁਆਇੰਟ।


A soft breakpoint is a single-byte instruction that stops execution of the debugged process.

ਇੱਕ ਸਾਫਟ ਬ੍ਰੇਕਪੁਆਇੰਟ ਇੱਕ ਸਿੰਗਲ-ਬਾਈਟ ਹਦਾਇਤ ਹੈ ਜੋ ਡੀਬੱਗ ਕੀਤੇ ਪ੍ਰੋਸੈਸ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕਦੀ ਹੈ।


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

ਇੱਕ ਅਸੈਂਬਲੀ ਹਦਾਇਤ CPU ਦੁਆਰਾ ਚਲਾਉਣ ਲਈ ਇੱਕ ਕਮਾਂਡ ਦਾ ਇੱਕ ਉੱਚ-ਪੱਧਰੀ ਪ੍ਰਸਤੁਤੀਕਰਨ ਹੈ।


An operation code, or opcode, is a machine language command that the CPU executes.

ਇੱਕ ਓਪਰੇਸ਼ਨ ਕੋਡ, ਜਾਂ ਓਪਕੋਡ, ਇੱਕ ਮਸ਼ੀਨ ਭਾਸ਼ਾ ਕਮਾਂਡ ਹੈ ਜੋ CPU ਚਲਾਉਂਦਾ ਹੈ।


In order to set a soft breakpoint at this address and halt the CPU, we have to swap out a single byte from the 2-byte 8BC3 opcode.

ਇਸ ਪਤੇ 'ਤੇ ਇੱਕ ਸਾਫਟ ਬ੍ਰੇਕਪੁਆਇੰਟ ਸੈੱਟ ਕਰਨ ਅਤੇ CPU ਨੂੰ ਰੋਕਣ ਲਈ, ਸਾਨੂੰ 2-ਬਾਈਟ 8BC3 ਓਪਕੋਡ ਤੋਂ ਇੱਕ ਸਿੰਗਲ ਬਾਈਟ ਨੂੰ ਬਦਲਣਾ ਪਵੇਗਾ।


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

ਜਦੋਂ CPU ਆਉਂਦਾ ਹੈ ਅਤੇ ਉਸ ਬਾਈਟ ਨੂੰ ਮਾਰਦਾ ਹੈ, ਤਾਂ ਇਹ ਰੁਕ ਜਾਂਦਾ ਹੈ, ਇੱਕ INT3 ਇਵੈਂਟ ਨੂੰ ਫਾਇਰ ਕਰਦਾ ਹੈ।


If the function is successful, it will return a handle to the process object.

ਜੇਕਰ ਫੰਕਸ਼ਨ ਸਫਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਪ੍ਰਕਿਰਿਆ ਆਬਜੈਕਟ ਨੂੰ ਇੱਕ ਹੈਂਡਲ ਵਾਪਸ ਕਰੇਗਾ।


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

ਅਸੀਂ DebugActiveProcess() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਜੁੜਦੇ ਹਾਂ।


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

ਅਸੀਂ ਸਿਰਫ਼ ਇਸਨੂੰ ਉਸ ਪ੍ਰਕਿਰਿਆ ਦਾ PID ਦਿੰਦੇ ਹਾਂ ਜਿਸ ਨਾਲ ਅਸੀਂ ਜੁੜਨਾ ਚਾਹੁੰਦੇ ਹਾਂ।


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, and it relinquishes control to the debugger.

ਇੱਕ ਵਾਰ ਸਿਸਟਮ ਇਹ ਨਿਰਧਾਰਤ ਕਰ ਲੈਂਦਾ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਪ੍ਰਕਿਰਿਆ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੇ ਉਚਿਤ ਅਧਿਕਾਰ ਹਨ, ਤਾਂ ਟੀਚਾ ਪ੍ਰਕਿਰਿਆ ਮੰਨਦੀ ਹੈ ਕਿ ਜੁੜਨ ਵਾਲੀ ਪ੍ਰਕਿਰਿਆ (ਡੀਬੱਗਰ) ਡੀਬੱਗ ਇਵੈਂਟਸ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਤਿਆਰ ਹੈ, ਅਤੇ ਇਹ ਕੰਟਰੋਲ ਨੂੰ ਡੀਬੱਗਰ ਨੂੰ ਸੌਂਪ ਦਿੰਦੀ ਹੈ।


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

ਡੀਬੱਗਰ ਇੱਕ ਲੂਪ ਵਿੱਚ WaitForDebugEvent() ਨੂੰ ਕਾਲ ਕਰਕੇ ਇਹਨਾਂ ਡੀਬੱਗਿੰਗ ਇਵੈਂਟਸ ਨੂੰ ਫਸਾਉਂਦਾ ਹੈ।


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

ਪਹਿਲਾ ਪੈਰਾਮੀਟਰ DEBUG_EVENT struct ਵੱਲ ਇੱਕ ਪੁਆਇੰਟਰ ਹੈ; ਇਹ ਢਾਂਚਾ ਇੱਕ ਡੀਬੱਗਿੰਗ ਇਵੈਂਟ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ।


The second parameter we will set to INFINITE so that the WaitForDebugEvent() call doesn’t return until an event occurs.

ਦੂਜਾ ਪੈਰਾਮੀਟਰ ਅਸੀਂ INFINITE 'ਤੇ ਸੈੱਟ ਕਰਾਂਗੇ ਤਾਂ ਜੋ WaitForDebugEvent() ਕਾਲ ਉਦੋਂ ਤੱਕ ਵਾਪਸ ਨਾ ਆਵੇ ਜਦੋਂ ਤੱਕ ਕੋਈ ਇਵੈਂਟ ਨਹੀਂ ਹੁੰਦਾ।


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

ਹਰੇਕ ਇਵੈਂਟ ਲਈ ਜੋ ਡੀਬੱਗਰ ਫੜਦਾ ਹੈ, ਇੱਥੇ ਸੰਬੰਧਿਤ ਇਵੈਂਟ ਹੈਂਡਲਰ ਹੁੰਦੇ ਹਨ ਜੋ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਜਾਰੀ ਰੱਖਣ ਤੋਂ ਪਹਿਲਾਂ ਕੁਝ ਕਿਸਮ ਦੀ ਕਾਰਵਾਈ ਕਰਦੇ ਹਨ।


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

ਇੱਕ ਵਾਰ ਹੈਂਡਲਰ ਐਗਜ਼ੀਕਿਊਟ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਪ੍ਰਕਿਰਿਆ ਐਗਜ਼ੀਕਿਊਟ ਹੁੰਦੀ ਰਹੇ।


This is achieved using the ContinueDebugEvent() function.

ਇਹ ContinueDebugEvent() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


The dwProcessId and dwThreadId parameters are fields in the DEBUG_EVENT struct, which gets initialized when the debugger catches a debugging event.

dwProcessId ਅਤੇ dwThreadId ਪੈਰਾਮੀਟਰ DEBUG_EVENT struct ਵਿੱਚ ਫੀਲਡ ਹਨ, ਜੋ ਉਦੋਂ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਡੀਬੱਗਰ ਇੱਕ ਡੀਬੱਗਿੰਗ ਇਵੈਂਟ ਨੂੰ ਫੜਦਾ ਹੈ।


The dwContinueStatus parameter signals the process to continue executing (DBG_CONTINUE) or to continue processing the exception (DBG_EXCEPTION_NOT_HANDLED).

dwContinueStatus ਪੈਰਾਮੀਟਰ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕਰਨਾ ਜਾਰੀ ਰੱਖਣ (DBG_CONTINUE) ਜਾਂ ਅਪਵਾਦ ਦੀ ਪ੍ਰਕਿਰਿਆ ਜਾਰੀ ਰੱਖਣ (DBG_EXCEPTION_NOT_HANDLED) ਦਾ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ।


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

ਸਿਰਫ਼ ਇੱਕੋ ਇੱਕ ਕੰਮ ਬਾਕੀ ਹੈ, ਉਹ ਹੈ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਵੱਖ ਹੋਣਾ।


Do this by calling DebugActiveProcessStop(), which takes the PID that you wish to detach from as its only parameter.

ਇਹ DebugActiveProcessStop() ਨੂੰ ਕਾਲ ਕਰਕੇ ਕਰੋ, ਜੋ PID ਲੈਂਦਾ ਹੈ ਜਿਸ ਤੋਂ ਤੁਸੀਂ ਵੱਖ ਹੋਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਇਸਦੇ ਇਕਲੌਤੇ ਪੈਰਾਮੀਟਰ ਵਜੋਂ।


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 ਕਲਾਸ ਨੂੰ ਇਸ ਨੂੰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਜੁੜਨ ਅਤੇ ਵੱਖ ਹੋਣ ਦੀ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਕੇ ਵਧਾਈਏ।


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 to handle debugging events.

ਅੰਤਮ ਲਾਗੂਕਰਨ ਵੇਰਵਾ ਡੀਬੱਗਿੰਗ ਇਵੈਂਟਸ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਸਾਡਾ ਪ੍ਰਾਇਮਰੀ ਡੀਬੱਗ ਲੂਪ ਬਣਾਉਣਾ ਹੋਵੇਗਾ।


Download this file now and overwrite your current copy.

ਹੁਣੇ ਇਸ ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ ਅਤੇ ਆਪਣੀ ਮੌਜੂਦਾ ਕਾਪੀ ਨੂੰ ਓਵਰਰਾਈਟ ਕਰੋ।


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

ਇੱਕ ਡੀਬੱਗਰ ਨੂੰ ਕਿਸੇ ਵੀ ਦਿੱਤੇ ਗਏ ਬਿੰਦੂ ਅਤੇ ਸਮੇਂ 'ਤੇ CPU ਰਜਿਸਟਰਾਂ ਦੀ ਸਥਿਤੀ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।


This allows us to determine the state of the stack when an exception occurs, where the instruction pointer is currently executing, and other useful tidbits of information.

ਇਹ ਸਾਨੂੰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਕਿ ਜਦੋਂ ਕੋਈ ਅਪਵਾਦ ਹੁੰਦਾ ਹੈ ਤਾਂ ਸਟੈਕ ਦੀ ਸਥਿਤੀ ਕੀ ਹੈ, ਇੰਸਟ੍ਰਕਸ਼ਨ ਪੁਆਇੰਟਰ ਵਰਤਮਾਨ ਵਿੱਚ ਕਿੱਥੇ ਐਗਜ਼ੀਕਿਊਟ ਹੋ ਰਿਹਾ ਹੈ, ਅਤੇ ਜਾਣਕਾਰੀ ਦੇ ਹੋਰ ਉਪਯੋਗੀ ਟੁਕੜੇ।


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 FastLogHook object creates an allocated region of memory to store captured information.

FastLogHook ਵਸਤੂ ਫੜੀ ਗਈ ਜਾਣਕਾਰੀ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਮੈਮੋਰੀ ਦਾ ਇੱਕ ਅਲਾਟ ਕੀਤਾ ਖੇਤਰ ਬਣਾਉਂਦਾ ਹੈ।


To retrieve the results of your hook, 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 final important note is that there is an additional flavor of FastLogHook, STDCALLFastLogHook.

ਅੰਤਮ ਮਹੱਤਵਪੂਰਨ ਨੋਟ ਇਹ ਹੈ ਕਿ FastLogHook, STDCALLFastLogHook ਦਾ ਇੱਕ ਵਾਧੂ ਰੂਪ ਹੈ।


For the cdecl convention use the normal FastLogHook.

cdecl ਕਨਵੈਨਸ਼ਨ ਲਈ ਆਮ FastLogHook ਦੀ ਵਰਤੋਂ ਕਰੋ।


An excellent example of harnessing the power of the hard hook is the hippie PyCommand.

ਸਖ਼ਤ ਹੁੱਕ ਦੀ ਸ਼ਕਤੀ ਨੂੰ ਵਰਤਣ ਦੀ ਇੱਕ ਸ਼ਾਨਦਾਰ ਉਦਾਹਰਣ ਹਿੱਪੀ PyCommand ਹੈ।


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 to either RtlAllocateHeap or RtlFreeHeap.

ਜੇਕਰ ਤੁਸੀਂ ਇਸ 'ਤੇ ਇੱਕ ਫਾਈਲ ਡਾਇਲਾਗ ਖੋਲ੍ਹਦੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ RtlAllocateHeap ਜਾਂ RtlFreeHeap ਨੂੰ ਲਗਭਗ 4,500 ਕਾਲਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


If you’re targeting Internet Explorer, you’ll see an increase in the number of heap-related function calls of 10 times or more.

ਜੇਕਰ ਤੁਸੀਂ ਇੰਟਰਨੈੱਟ ਐਕਸਪਲੋਰਰ ਨੂੰ ਨਿਸ਼ਾਨਾ ਬਣਾ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਹੀਪ-ਸੰਬੰਧਿਤ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ 10 ਗੁਣਾ ਜਾਂ ਵੱਧ ਵਾਧਾ ਦੇਖੋਗੇ।


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 until it finds the RET instruction.

ਪਾਈਥਨ ਕੋਡ ਫੰਕਸ਼ਨ ਦੇ ਸਿਰ 'ਤੇ ਡਿਸਅਸੈਂਬਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ RET ਨਿਰਦੇਸ਼ ਨਹੀਂ ਲੱਭ ਲੈਂਦਾ।


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 and then run it again and again to monitor the results.

ਸਕ੍ਰਿਪਟ ਇਸ ਤਰ੍ਹਾਂ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ ਕਿ ਤੁਸੀਂ ਹੁੱਕ ਸੈੱਟ ਕਰਨ ਲਈ ਇਸਨੂੰ ਇੱਕ ਵਾਰ ਚਲਾਉਂਦੇ ਹੋ ਅਤੇ ਫਿਰ ਨਤੀਜਿਆਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਇਸਨੂੰ ਵਾਰ-ਵਾਰ ਚਲਾਉਂਦੇ ਹੋ।


For the RtlAllocateHeap call, we are trapping three arguments from the stack and the return value from the function call.

RtlAllocateHeap ਕਾਲ ਲਈ, ਅਸੀਂ ਸਟੈਕ ਤੋਂ ਤਿੰਨ ਦਲੀਲਾਂ ਅਤੇ ਫੰਕਸ਼ਨ ਕਾਲ ਤੋਂ ਵਾਪਸੀ ਮੁੱਲ ਨੂੰ ਫਸਾ ਰਹੇ ਹਾਂ।


Hooking is something that you’ll undoubtedly use countless times throughout your reversing endeavors.

ਹੁੱਕਿੰਗ ਇੱਕ ਅਜਿਹੀ ਚੀਜ਼ ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਤੁਸੀਂ ਬਿਨਾਂ ਸ਼ੱਕ ਆਪਣੇ ਰਿਵਰਸਿੰਗ ਯਤਨਾਂ ਦੌਰਾਨ ਅਣਗਿਣਤ ਵਾਰ ਕਰੋਗੇ।


The file fuzzer selects a file randomly from a directory.

ਫਾਈਲ ਫਜ਼ਰ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚੋਂ ਇੱਕ ਫਾਈਲ ਨੂੰ ਬੇਤਰਤੀਬੇ ਢੰਗ ਨਾਲ ਚੁਣਦਾ ਹੈ।


The program then mutates the selected file.

ਫਿਰ ਪ੍ਰੋਗਰਾਮ ਚੁਣੀ ਗਈ ਫਾਈਲ ਨੂੰ ਬਦਲਦਾ ਹੈ।


A debugger thread is started to load the target application.

ਨਿਸ਼ਾਨਾ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲੋਡ ਕਰਨ ਲਈ ਇੱਕ ਡੀਬੱਗਰ ਥ੍ਰੈਡ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


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

ਮਾਨੀਟਰਿੰਗ ਥ੍ਰੈਡ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਬਾਅਦ ਸਮਾਪਤ ਹੋ ਜਾਵੇ।


The fuzz function checks if a fuzzing iteration is already running.

ਫਜ਼ ਫੰਕਸ਼ਨ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਫਜ਼ਿੰਗ ਦੁਹਰਾਓ ਪਹਿਲਾਂ ਹੀ ਚੱਲ ਰਿਹਾ ਹੈ।


The mutate_file function pulls the file contents into a buffer.

mutate_file ਫੰਕਸ਼ਨ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਇੱਕ ਬਫਰ ਵਿੱਚ ਖਿੱਚਦਾ ਹੈ।


A random test case is applied to a random position in the file.

ਇੱਕ ਬੇਤਰਤੀਬ ਟੈਸਟ ਕੇਸ ਫਾਈਲ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬ ਸਥਿਤੀ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


The fuzzer uses command-line options for executable path and file extension.

ਫਜ਼ਰ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਮਾਰਗ ਅਤੇ ਫਾਈਲ ਐਕਸਟੈਂਸ਼ਨ ਲਈ ਕਮਾਂਡ-ਲਾਈਨ ਵਿਕਲਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The -e flag specifies the path to the target application's executable.

-e ਫਲੈਗ ਨਿਸ਼ਾਨਾ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਦਾ ਮਾਰਗ ਦੱਸਦਾ ਹੈ।


The -x option is for the filename extension being tested.

-x ਵਿਕਲਪ ਟੈਸਟ ਕੀਤੇ ਜਾ ਰਹੇ ਫਾਈਲਨਾਮ ਐਕਸਟੈਂਸ਼ਨ ਲਈ ਹੈ।


The optional -n parameter enables or disables notifications.

ਵਿਕਲਪਿਕ -n ਪੈਰਾਮੀਟਰ ਸੂਚਨਾਵਾਂ ਨੂੰ ਸਮਰੱਥ ਜਾਂ ਅਯੋਗ ਕਰਦਾ ਹੈ।


Code coverage measures how much code is executed during testing.

ਕੋਡ ਕਵਰੇਜ ਮਾਪਦਾ ਹੈ ਕਿ ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਕਿੰਨਾ ਕੋਡ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।


Automated static analysis can find hot spots in the target code.

ਆਟੋਮੈਟਿਕ ਸਟੈਟਿਕ ਵਿਸ਼ਲੇਸ਼ਣ ਨਿਸ਼ਾਨਾ ਕੋਡ ਵਿੱਚ ਹੌਟ ਸਪਾਟ ਲੱਭ ਸਕਦਾ ਹੈ।


Sulley is a Python-based fuzzing framework.

ਸੁਲੇ ਇੱਕ ਪਾਈਥਨ-ਅਧਾਰਿਤ ਫਜ਼ਿੰਗ ਫਰੇਮਵਰਕ ਹੈ।


ਸੁਲੇ ਬਲਾਕ-ਅਧਾਰਿਤ ਫਜ਼ਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Strings are a common primitive in Sulley.

ਸਤਰਾਂ ਸੁਲੇ ਵਿੱਚ ਇੱਕ ਆਮ ਪ੍ਰਾਇਮਿਟਿਵ ਹਨ।


Delimiters help break larger strings into manageable pieces.

ਡੈਲੀਮੀਟਰ ਵੱਡੀਆਂ ਸਤਰਾਂ ਨੂੰ ਪ੍ਰਬੰਧਨਯੋਗ ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੰਡਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ।


s_string() ਇੱਕ ਫਜ਼ੇਬਲ ਸਤਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।


s_random() generates random data of varying lengths.

s_random() ਵੱਖ-ਵੱਖ ਲੰਬਾਈ ਦੇ ਬੇਤਰਤੀਬ ਡੇਟਾ ਤਿਆਰ ਕਰਦਾ ਹੈ।


Blocks and groups chain primitives together in an organized fashion.

ਬਲਾਕ ਅਤੇ ਸਮੂਹ ਇੱਕ ਸੰਗਠਿਤ ਢੰਗ ਨਾਲ ਪ੍ਰਾਇਮਿਟਿਵ ਨੂੰ ਇਕੱਠੇ ਜੋੜਦੇ ਹਨ।


The problem with simply setting up your shellcode to make this call is that it takes some NULL parameters as well, which is problematic for most shellcode.

ਇਸ ਕਾਲ ਨੂੰ ਕਰਨ ਲਈ ਸਿਰਫ਼ ਆਪਣੇ ਸ਼ੈਲਕੋਡ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਵਿੱਚ ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਇਹ ਕੁਝ NULL ਪੈਰਾਮੀਟਰ ਵੀ ਲੈਂਦਾ ਹੈ, ਜੋ ਕਿ ਜ਼ਿਆਦਾਤਰ ਸ਼ੈਲਕੋਡ ਲਈ ਸਮੱਸਿਆ ਵਾਲਾ ਹੈ।


So the trick involves landing our shellcode in the middle of a function that will call NtSetInformationProcess() with the necessary parameters already on the stack.

ਇਸ ਲਈ ਚਾਲ ਵਿੱਚ ਸਾਡੇ ਸ਼ੈਲਕੋਡ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਦੇ ਵਿਚਕਾਰ ਲੈਂਡ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ ਜੋ ਪਹਿਲਾਂ ਹੀ ਸਟੈਕ 'ਤੇ ਜ਼ਰੂਰੀ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਨਾਲ NtSetInformationProcess() ਨੂੰ ਕਾਲ ਕਰੇਗਾ।


There is a known spot in ntdll.dll that will accomplish this for us.

ntdll.dll ਵਿੱਚ ਇੱਕ ਜਾਣਿਆ-ਪਛਾਣਿਆ ਸਥਾਨ ਹੈ ਜੋ ਸਾਡੇ ਲਈ ਇਹ ਕੰਮ ਕਰੇਗਾ।


Take a peek at the disassembly output from ntdll.dll on Windows XP SP2 captured using Immunity Debugger.

ਇਮਿਊਨਿਟੀ ਡੀਬੱਗਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੈਪਚਰ ਕੀਤੇ ਵਿੰਡੋਜ਼ XP SP2 'ਤੇ ntdll.dll ਤੋਂ ਡਿਸਅਸੈਂਬਲੀ ਆਉਟਪੁੱਟ 'ਤੇ ਇੱਕ ਝਾਤ ਮਾਰੋ।


The NtSetInformationProcess() function definition can be found at http://undocumented.ntinternals .net/UserMode/Undocumented%20Functions/NT%20Objects/Process/NtSetInformationProcess.html.

NtSetInformationProcess() ਫੰਕਸ਼ਨ ਦੀ ਪਰਿਭਾਸ਼ਾ http://undocumented.ntinternals .net/UserMode/Undocumented%20Functions/NT%20Objects/Process/NtSetInformationProcess.html 'ਤੇ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ।


Following this code flow, we see a comparison against AL for the value of 1, and then ESI is filled with the value 2.

ਇਸ ਕੋਡ ਪ੍ਰਵਾਹ ਦਾ ਪਾਲਣ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ 1 ਦੇ ਮੁੱਲ ਲਈ AL ਦੇ ਵਿਰੁੱਧ ਇੱਕ ਤੁਲਨਾ ਦੇਖਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ESI ਨੂੰ 2 ਦੇ ਮੁੱਲ ਨਾਲ ਭਰਿਆ ਜਾਂਦਾ ਹੈ।


If AL evaluates to 1, then there is a conditional jump to 0x7C93FEBA.

ਜੇਕਰ AL ਦਾ ਮੁੱਲ 1 ਹੈ, ਤਾਂ 0x7C93FEBA 'ਤੇ ਇੱਕ ਸ਼ਰਤੀਆ ਜੰਪ ਹੈ।


From there ESI gets moved into a stack variable at EBP-4 (remember that ESI is still set to 2).

ਉੱਥੋਂ ESI ਨੂੰ EBP-4 'ਤੇ ਇੱਕ ਸਟੈਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ (ਯਾਦ ਰੱਖੋ ਕਿ ESI ਅਜੇ ਵੀ 2 'ਤੇ ਸੈੱਟ ਹੈ)।


Then there is an uncon- ditional jump to 0x7C91D403, which checks our stack variable (still set to 2) to make sure it’s non-zero, and then a conditional jump to 0x7C935D6D.

ਫਿਰ 0x7C91D403 'ਤੇ ਇੱਕ ਗੈਰ-ਸ਼ਰਤੀਆ ਜੰਪ ਹੈ, ਜੋ ਸਾਡੇ ਸਟੈਕ ਵੇਰੀਏਬਲ (ਅਜੇ ਵੀ 2 'ਤੇ ਸੈੱਟ) ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ ਕਿ ਇਹ ਗੈਰ-ਜ਼ੀਰੋ ਹੈ, ਅਤੇ ਫਿਰ 0x7C935D6D 'ਤੇ ਇੱਕ ਸ਼ਰਤੀਆ ਜੰਪ ਹੈ।


Here is where it gets interesting; we see the value 4 being pushed to the stack, our EBP-4 variable (still set to 2!) being loaded into the EAX register, then that value being pushed onto the stack, followed by the value 0x22 being pushed and the value of -1 (-1 as a process handle tells the function call that it’s the current process to be DEP-disabled) being pushed, and then a call to ZwSetInformationProcess (an alias for NtSetInformationProcess).

ਇੱਥੇ ਇਹ ਦਿਲਚਸਪ ਹੋ ਜਾਂਦਾ ਹੈ; ਅਸੀਂ 4 ਦਾ ਮੁੱਲ ਸਟੈਕ 'ਤੇ ਧੱਕਿਆ ਜਾ ਰਿਹਾ ਦੇਖਦੇ ਹਾਂ, ਸਾਡਾ EBP-4 ਵੇਰੀਏਬਲ (ਅਜੇ ਵੀ 2 'ਤੇ ਸੈੱਟ!) EAX ਰਜਿਸਟਰ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਫਿਰ ਉਸ ਮੁੱਲ ਨੂੰ ਸਟੈਕ 'ਤੇ ਧੱਕਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ 0x22 ਦਾ ਮੁੱਲ ਧੱਕਿਆ ਜਾ ਰਿਹਾ ਹੈ ਅਤੇ -1 ਦਾ ਮੁੱਲ (-1 ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਹੈਂਡਲ ਦੇ ਤੌਰ 'ਤੇ ਫੰਕਸ਼ਨ ਕਾਲ ਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਇਹ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜਿਸਨੂੰ DEP-ਅਯੋਗ ਕੀਤਾ ਜਾਣਾ ਹੈ) ਧੱਕਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਅਤੇ ਫਿਰ ZwSetInformationProcess (NtSetInformationProcess ਲਈ ਇੱਕ ਉਪਨਾਮ) ਨੂੰ ਇੱਕ ਕਾਲ।


So really what’s happened in this code flow is a function call being set up for NtSetInformationProcess(), like so: NtSetInformationProcess( -1, 0x22, 0x2, 0x4 ) Perfect!

ਇਸ ਲਈ ਅਸਲ ਵਿੱਚ ਇਸ ਕੋਡ ਪ੍ਰਵਾਹ ਵਿੱਚ ਜੋ ਹੋਇਆ ਹੈ ਉਹ ਹੈ NtSetInformationProcess() ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਥਾਪਤ ਕਰਨਾ, ਇਸ ਤਰ੍ਹਾਂ: NtSetInformationProcess( -1, 0x22, 0x2, 0x4 ) ਬਹੁਤ ਵਧੀਆ!


This will disable DEP for the current process, but we first have to get our exploit code to land us at 0x7C91D3F8 in order to have this code executed.

ਇਹ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ DEP ਨੂੰ ਅਯੋਗ ਕਰ ਦੇਵੇਗਾ, ਪਰ ਸਾਨੂੰ ਪਹਿਲਾਂ ਆਪਣੇ ਸ਼ੋਸ਼ਣ ਕੋਡ ਨੂੰ ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਲਈ 0x7C91D3F8 'ਤੇ ਲਿਆਉਣਾ ਪਏਗਾ।


Before we hit that spot we also need to make sure that we have AL (the low byte in the EAX register) set to 1.

ਉਸ ਸਥਾਨ 'ਤੇ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਸਾਨੂੰ ਇਹ ਵੀ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ AL (EAX ਰਜਿਸਟਰ ਵਿੱਚ ਘੱਟ ਬਾਈਟ) 1 'ਤੇ ਸੈੱਟ ਹੈ।


Once we have met these two pre- requisites, we will then be able to transfer control back to our shellcode like any other overflow, via a JMP ESP instruction, for example.

ਇੱਕ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਇਨ੍ਹਾਂ ਦੋ ਪੂਰਵ-ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰ ਲੈਂਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਫਿਰ ਕਿਸੇ ਹੋਰ ਓਵਰਫਲੋ ਵਾਂਗ, ਇੱਕ JMP ESP ਨਿਰਦੇਸ਼ ਰਾਹੀਂ, ਉਦਾਹਰਨ ਲਈ, ਕੰਟਰੋਲ ਨੂੰ ਵਾਪਸ ਆਪਣੇ ਸ਼ੈਲਕੋਡ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵਾਂਗੇ।


So to review our three prerequisite addresses we need: An address that sets AL to 1 and then returns.

ਇਸ ਲਈ ਸਾਡੇ ਤਿੰਨ ਪੂਰਵ-ਲੋੜੀਂਦੇ ਪਤਿਆਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨ ਲਈ ਸਾਨੂੰ ਲੋੜ ਹੈ: ਇੱਕ ਪਤਾ ਜੋ AL ਨੂੰ 1 'ਤੇ ਸੈੱਟ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਵਾਪਸ ਆਉਂਦਾ ਹੈ।


The script finishes up by outputting the results to the Log window.

ਸਕ੍ਰਿਪਟ ਲੌਗ ਵਿੰਡੋ ਵਿੱਚ ਨਤੀਜਿਆਂ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਕੇ ਖਤਮ ਹੁੰਦੀ ਹੈ।


Take a look at Figures 5-4 through 5-6 to see how this process progresses.

ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੇ ਅੱਗੇ ਵਧਣ ਦੇ ਤਰੀਕੇ ਨੂੰ ਦੇਖਣ ਲਈ ਚਿੱਤਰ 5-4 ਤੋਂ 5-6 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੋ।


Now you can simply copy and paste that line of output into your exploit and append your shellcode.

ਹੁਣ ਤੁਸੀਂ ਸਿਰਫ਼ ਆਉਟਪੁੱਟ ਦੀ ਉਸ ਲਾਈਨ ਨੂੰ ਆਪਣੇ ਸ਼ੋਸ਼ਣ ਵਿੱਚ ਕਾਪੀ ਅਤੇ ਪੇਸਟ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਆਪਣੇ ਸ਼ੈਲਕੋਡ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹੋ।


This is a great example of taking hours of manual searching and turning it into a 30-second exercise.

ਇਹ ਘੰਟਿਆਂ ਦੀ ਮੈਨੂਅਲ ਖੋਜ ਨੂੰ ਲੈ ਕੇ ਇਸਨੂੰ 30-ਸਕਿੰਟ ਦੀ ਕਸਰਤ ਵਿੱਚ ਬਦਲਣ ਦੀ ਇੱਕ ਵਧੀਆ ਉਦਾਹਰਣ ਹੈ।


Current malware variants are becoming more and more devious in their methods of infection, propagation, and their ability to defend themselves from analysis.

ਮੌਜੂਦਾ ਮਾਲਵੇਅਰ ਰੂਪ ਇਨਫੈਕਸ਼ਨ, ਪ੍ਰਸਾਰਣ ਦੇ ਆਪਣੇ ਤਰੀਕਿਆਂ ਵਿੱਚ, ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਤੋਂ ਆਪਣਾ ਬਚਾਅ ਕਰਨ ਦੀ ਉਹਨਾਂ ਦੀ ਯੋਗਤਾ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ ਸ਼ਰਾਰਤੀ ਹੁੰਦੇ ਜਾ ਰਹੇ ਹਨ।


Without specialized tools, a computer user can’t see the contents of ADSs.

ਬਿਨਾਂ ਵਿਸ਼ੇਸ਼ ਸਾਧਨਾਂ ਦੇ, ਇੱਕ ਕੰਪਿਊਟਰ ਉਪਭੋਗਤਾ ADSs ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਨਹੀਂ ਦੇਖ ਸਕਦਾ।


In addition, a number of security products don’t properly scan alternate data streams.

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕਈ ਸੁਰੱਖਿਆ ਉਤਪਾਦ ਵਿਕਲਪਿਕ ਡਾਟਾ ਸਟ੍ਰੀਮਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਕੈਨ ਨਹੀਂ ਕਰਦੇ ਹਨ।


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.

ਇੱਕ ਫਾਈਲ 'ਤੇ ਇੱਕ ਵਿਕਲਪਿਕ ਡਾਟਾ ਸਟ੍ਰੀਮ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਮੌਜੂਦਾ ਫਾਈਲ ਵਿੱਚ ਇੱਕ ਕੋਲਨ ਅਤੇ ਇੱਕ ਫਾਈਲਨਾਮ ਜੋੜਨ ਤੋਂ ਇਲਾਵਾ ਕੁਝ ਨਹੀਂ ਕਰਨਾ ਪਏਗਾ।


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 ਵਿੱਚ ਲਿਖਦੀ ਹੈ।


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.

ਆਓ ਸਾਡੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਰੀਡਾਇਰੈਕਸ਼ਨ ਕੋਡ ਨੂੰ ਬਣਾ ਕੇ ਸ਼ੁਰੂਆਤ ਕਰੀਏ, ਜੋ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਤਰੀਕੇ ਨਾਲ ਸਾਡੀ ਪਸੰਦ ਦੀ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।


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 ਫਾਈਲ ਨੂੰ ਸ਼ਾਮਲ ਕਰ ਰਹੇ ਹਾਂ, ਜਿਸ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣ ਲਈ ਸਾਰੇ ਜ਼ਰੂਰੀ ਸਥਿਰ ਅਤੇ ਢਾਂਚੇ ਸ਼ਾਮਲ ਹਨ।


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 aren’t going for clean here; we’re going for quick and dirty.

ਅਸੀਂ ਇੱਥੇ ਸਾਫ਼-ਸੁਥਰਾ ਨਹੀਂ ਕਰ ਰਹੇ ਹਾਂ; ਅਸੀਂ ਤੇਜ਼ ਅਤੇ ਗੰਦਾ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ।


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 ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ੈਲਕੋਡ ਦੇ ਦੋ ਵੱਖਰੇ ਟੁਕੜਿਆਂ ਨੂੰ ਇੰਜੈਕਟ ਕੀਤਾ ਜਾਵੇ, ਇੱਕ ਸਾਨੂੰ ਰਿਵਰਸ ਸ਼ੈੱਲ ਦੇਣ ਲਈ ਅਤੇ ਇੱਕ ਸਾਡੀ ਵਿਗਾੜ ਵਾਲੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਮਾਰਨ ਲਈ।


All right! We pass in the process ID of our backdoor process and inject the shellcode into the process we spawned (the second calc.exe, the one with buttons and numbers on it), which then kills our backdoor.

ਠੀਕ ਹੈ! ਅਸੀਂ ਆਪਣੇ ਬੈਕਡੋਰ ਪ੍ਰਕਿਰਿਆ ਦਾ ਪ੍ਰਕਿਰਿਆ ID ਪਾਸ ਕਰਦੇ ਹਾਂ ਅਤੇ ਸ਼ੈਲਕੋਡ ਨੂੰ ਉਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੰਜੈਕਟ ਕਰਦੇ ਹਾਂ ਜਿਸਨੂੰ ਅਸੀਂ ਬਣਾਇਆ ਹੈ (ਦੂਜਾ calc.exe, ਜਿਸ 'ਤੇ ਬਟਨ ਅਤੇ ਨੰਬਰ ਹਨ), ਜੋ ਫਿਰ ਸਾਡੇ ਬੈਕਡੋਰ ਨੂੰ ਮਾਰਦਾ ਹੈ।


We now have a fairly comprehensive backdoor that utilizes some stealth, and better yet, we get access to the target machine every time someone runs the application we are interested in.

ਸਾਡੇ ਕੋਲ ਹੁਣ ਇੱਕ ਕਾਫ਼ੀ ਵਿਆਪਕ ਬੈਕਡੋਰ ਹੈ ਜੋ ਕੁਝ ਚੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸ ਤੋਂ ਵੀ ਵਧੀਆ, ਸਾਨੂੰ ਹਰ ਵਾਰ ਟੀਚਾ ਮਸ਼ੀਨ ਤੱਕ ਪਹੁੰਚ ਮਿਲਦੀ ਹੈ ਜਦੋਂ ਕੋਈ ਉਹ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਉਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸਾਡੀ ਦਿਲਚਸਪੀ ਹੈ।


As you have seen in this chapter, DLL and code injection are two very useful and very powerful techniques.

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਦੇਖਿਆ ਹੈ, DLL ਅਤੇ ਕੋਡ ਇੰਜੈਕਸ਼ਨ ਦੋ ਬਹੁਤ ਉਪਯੋਗੀ ਅਤੇ ਬਹੁਤ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਕਨੀਕਾਂ ਹਨ।


We are using IDAPython, so we will be using some familiar functions.

ਅਸੀਂ IDAPython ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਇਸ ਲਈ ਅਸੀਂ ਕੁਝ ਜਾਣੇ-ਪਛਾਣੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।


Let’s continue to add to our addnum_function_call.py script.

ਆਓ ਅਸੀਂ ਆਪਣੀ addnum_function_call.py ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਜੋੜਨਾ ਜਾਰੀ ਰੱਖੀਏ।


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() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ।


Now that we have the code and data sections loaded into memory, we are going to set up the stack parameters.

ਹੁਣ ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਕੋਡ ਅਤੇ ਡਾਟਾ ਭਾਗ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਹੋ ਗਏ ਹਨ, ਅਸੀਂ ਸਟੈਕ ਪੈਰਾਮੀਟਰ ਸੈੱਟਅੱਪ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ।


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.

ਆਖਰੀ ਕਦਮ retn ਹਦਾਇਤ ਹੈਂਡਲਰ ਨੂੰ ਕੋਡ ਕਰਨਾ ਹੈ।


The ret instruction handler simply retrieves the stack arguments and the value of the EAX register.

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.

ਤੁਸੀਂ ਹੈਰਾਨ ਹੋਵੋਗੇ ਕਿ ਇਹ ਤਕਨੀਕ ਕਿੰਨੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੋ ਸਕਦੀ ਹੈ ਜਦੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿੱਚ ਸੈਂਕੜੇ ਜਾਂ ਹਜ਼ਾਰਾਂ ਹਦਾਇਤਾਂ ਹੁੰਦੀਆਂ ਹਨ।


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 ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰੀਏ।


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.

ਇੱਕ ਆਮ ਪੈਕਰ ਟੀਚੇ ਵਾਲੇ ਬਾਈਨਰੀ ਦੇ ਕੋਡ ਅਤੇ ਡਾਟਾ ਭਾਗਾਂ ਨੂੰ ਕੰਪ੍ਰੈੱਸ ਕਰੇਗਾ।


When the binary is executed, the decompressor runs, which decompresses the original binary into memory.

ਜਦੋਂ ਬਾਈਨਰੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਡੀਕੰਪ੍ਰੈਸਰ ਚੱਲਦਾ ਹੈ, ਜੋ ਅਸਲ ਬਾਈਨਰੀ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਡੀਕੰਪ੍ਰੈੱਸ ਕਰਦਾ ਹੈ।


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.

ਫਿਰ ਅਸੀਂ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਦੁਹਰਾਉਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ, ਹਰੇਕ ਫੰਕਸ਼ਨ ਲਈ ਸਟੈਕ ਫਰੇਮ ਆਬਜੈਕਟ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ।


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 ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਮੂਲ ਸਿਧਾਂਤ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਅਤੇ ਕੁਝ ਕੋਰ ਉਪਯੋਗਤਾ ਸਕ੍ਰਿਪਟਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਵਧਾ, ਜੋੜ ਜਾਂ ਵਧਾ ਸਕਦੇ ਹੋ।


Let’s now take a look at PyEmu, the Python-based x86 emulator, which is an excellent example of IDAPython in action.

ਆਓ ਹੁਣ PyEmu 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ, ਪਾਈਥਨ-ਅਧਾਰਿਤ x86 ਇਮੂਲੇਟਰ, ਜੋ ਕਿ ਕਾਰਵਾਈ ਵਿੱਚ IDAPython ਦੀ ਇੱਕ ਸ਼ਾਨਦਾਰ ਉਦਾਹਰਣ ਹੈ।


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

PyEmu ਨੂੰ ਕੋਡੀ ਪੀਅਰਸ ਦੁਆਰਾ ਬਲੈਕਹੈਟ 2007 ਵਿੱਚ ਜਾਰੀ ਕੀਤਾ ਗਿਆ ਸੀ, ਜੋ ਕਿ ਟਿਪਿੰਗਪੁਆਇੰਟ ਡੀਵੀਲੈਬਸ ਟੀਮ ਦੇ ਪ੍ਰਤਿਭਾਸ਼ਾਲੀ ਮੈਂਬਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ।


Using an emulator can be very beneficial for reverse engineering malware, when you don’t necessarily want the real malware code to execute.

ਇੱਕ ਇਮੂਲੇਟਰ ਦੀ ਵਰਤੋਂ ਮਾਲਵੇਅਰ ਦੀ ਉਲਟ ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦੀ ਹੈ, ਜਦੋਂ ਤੁਸੀਂ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਅਸਲ ਮਾਲਵੇਅਰ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ ਨਹੀਂ ਚਾਹੁੰਦੇ ਹੋ।


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 ਕਲਾਸ ਨੂੰ ਛੱਡ ਦੇਵਾਂਗੇ।


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 ਨੂੰ ਵੇਖੋ।


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 ਨਾਮ ਦੀ ਇੱਕ ਨਵੀਂ ਫਾਈਲ ਬਣਾਓ, ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਦਾਖਲ ਕਰੋ।


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.

ਦੂਜਾ ਕਦਮ ਹਮਲਾ ਕਰਨ ਲਈ ਇੱਕ ਟੀਚੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ 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 'ਤੇ ਸੁਣ ਰਿਹਾ ਹੈ, ਜੋ ਕਿ ਉਹ ਪੋਰਟ ਹੈ ਜਿਸ 'ਤੇ ਇਹ ਸੁਲੀ ਤੋਂ ਕਮਾਂਡਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰੇਗਾ।


The fourth tells Sulley that our debugger is listening at 192.168.244.133 as well but on TCP port 26002; again Sulley uses this port to send commands to the debugger.

ਚੌਥਾ ਸੁਲੀ ਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਸਾਡਾ ਡੀਬੱਗਰ 192.168.244.133 'ਤੇ ਵੀ ਸੁਣ ਰਿਹਾ ਹੈ ਪਰ TCP ਪੋਰਟ 26002 'ਤੇ; ਦੁਬਾਰਾ ਸੁਲੀ ਇਸ ਪੋਰਟ ਦੀ ਵਰਤੋਂ ਡੀਬੱਗਰ ਨੂੰ ਕਮਾਂਡਾਂ ਭੇਜਣ ਲਈ ਕਰਦਾ ਹੈ।


We also pass in an additional option to tell the debugger that the process name we are interested in is war-ftpd.exe.

ਅਸੀਂ ਡੀਬੱਗਰ ਨੂੰ ਇਹ ਦੱਸਣ ਲਈ ਇੱਕ ਵਾਧੂ ਵਿਕਲਪ ਵੀ ਪਾਸ ਕਰਦੇ ਹਾਂ ਕਿ ਜਿਸ ਪ੍ਰਕਿਰਿਆ ਦੇ ਨਾਮ ਵਿੱਚ ਸਾਡੀ ਦਿਲਚਸਪੀ ਹੈ ਉਹ war-ftpd.exe ਹੈ।


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 ਕਮਾਂਡ ਨਾਲ ਜੋੜਦੇ ਹਾਂ।


Finally, we tell Sulley to start fuzzing.

ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਸੁਲੀ ਨੂੰ ਫਜ਼ਿੰਗ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕਹਿੰਦੇ ਹਾਂ।


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.

ਇਹ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਕਿਉਂਕਿ ਤੁਸੀਂ ਇੱਕ ਕਰੈਸ਼ ਨੂੰ ਅਸਲ ਨੈਟਵਰਕ ਟ੍ਰੈਫਿਕ ਨਾਲ ਵਾਪਸ ਮੈਪ ਕਰ ਸਕਦੇ ਹੋ ਜਿਸ ਕਾਰਨ ਇਹ ਹੋਇਆ, ਜੋ ਕਿ ਕਰੈਸ਼ ਤੋਂ ਕੰਮ ਕਰਨ ਵਾਲੇ ਸ਼ੋਸ਼ਣ ਤੱਕ ਜਾਣ ਵਿੱਚ ਲੱਗਣ ਵਾਲੇ ਸਮੇਂ ਨੂੰ ਬਹੁਤ ਘਟਾਉਂਦਾ ਹੈ।


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 ਕੋਡਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਇਹਨਾਂ ਨਤੀਜਿਆਂ ਨੂੰ ਇੱਕ ਪਾਈਥਨ ਪਿਕਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਡਰਾਈਵਰਲਿਬ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।


Then we’ll write an IOCTL fuzzer that will use our pickled results to fuzz the various IOCTL routines that are supported.

ਫਿਰ ਅਸੀਂ ਇੱਕ IOCTL ਫਜ਼ਰ ਲਿਖਾਂਗੇ ਜੋ ਸਹਿਯੋਗੀ ਵੱਖ-ਵੱਖ IOCTL ਰੁਟੀਨਾਂ ਨੂੰ ਫਜ਼ ਕਰਨ ਲਈ ਸਾਡੇ ਪਿਕਲ ਕੀਤੇ ਨਤੀਜਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ।


Not only will this increase our coverage against the driver, but we can let it run indefinitely, and we don’t have to interact with a user-mode program to initiate fuzzing cases.

ਇਸ ਨਾਲ ਨਾ ਸਿਰਫ਼ ਡਰਾਈਵਰ ਦੇ ਵਿਰੁੱਧ ਸਾਡੀ ਕਵਰੇਜ ਵਧੇਗੀ, ਸਗੋਂ ਅਸੀਂ ਇਸਨੂੰ ਅਨਿਸ਼ਚਿਤ ਸਮੇਂ ਲਈ ਚੱਲਣ ਦੇ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਸਾਨੂੰ ਫਜ਼ਿੰਗ ਮਾਮਲਿਆਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਉਪਭੋਗਤਾ-ਮੋਡ ਪ੍ਰੋਗਰਾਮ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।


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 ਕੋਡ ਦਿਖਾਏਗੀ ਜੋ ਸਫਲਤਾਪੂਰਵਕ ਚਲਾਇਆ ਗਿਆ ਸੀ।


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.

ਦੁਨੀਆ ਦੇ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈਕਰ ਆਪਣਾ ਕੰਮ ਕਰਨ ਲਈ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਨ।


ਕੀ ਤੁਹਾਨੂੰ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ?


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

ਇਹ ਕਿਤਾਬ ਐਨ ਆਰਬਰ, ਮਿਸ਼ੀਗਨ ਵਿੱਚ ਮੈਲੋਏ ਇਨਕਾਰਪੋਰੇਟਿਡ ਵਿਖੇ ਛਾਪੀ ਅਤੇ ਬੰਨ੍ਹੀ ਗਈ ਸੀ।


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

ਅਪਡੇਟਾਂ, ਗਲਤੀਆਂ, ਅਤੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ http://www.nostarch.com/ghpython.htm 'ਤੇ ਜਾਓ।


Hacking is the art of creative problem solving.

ਹੈਕਿੰਗ ਰਚਨਾਤਮਕ ਸਮੱਸਿਆ ਹੱਲ ਕਰਨ ਦੀ ਕਲਾ ਹੈ।


Rather than merely showing how to run existing exploits, Hacking: The Art of Exploitation explains how arcane hacking techniques actually work.

ਮੌਜੂਦਾ ਸ਼ੋਸ਼ਣਾਂ ਨੂੰ ਚਲਾਉਣ ਦਾ ਤਰੀਕਾ ਦਿਖਾਉਣ ਦੀ ਬਜਾਏ, ਹੈਕਿੰਗ: ਸ਼ੋਸ਼ਣ ਦੀ ਕਲਾ ਦੱਸਦੀ ਹੈ ਕਿ ਗੁਪਤ ਹੈਕਿੰਗ ਤਕਨੀਕਾਂ ਅਸਲ ਵਿੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।


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.

ਸੁਰੱਖਿਆ ਡਾਟਾ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਟੂਲ ਕੰਪਿਊਟਰ ਸੁਰੱਖਿਆ ਡੇਟਾ ਦੀ ਦੁਨੀਆ ਵਿੱਚ ਗ੍ਰਾਫਿਕਲ ਵਿੰਡੋਜ਼ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹਨ।


Readers will be able to understand complex data sets at a glance.

ਪਾਠਕ ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਸੈੱਟਾਂ ਨੂੰ ਸਮਝਣ ਦੇ ਯੋਗ ਹੋਣਗੇ।


Python is powerful but has a very gentle learning curve.

ਪਾਈਥਨ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ ਪਰ ਇਸਦਾ ਸਿੱਖਣ ਦਾ ਕਰਵ ਬਹੁਤ ਹੌਲੀ ਹੈ।


Playing with Python teaches computer programming to non-programmers.

ਪਾਈਥਨ ਨਾਲ ਖੇਡਣਾ ਗੈਰ-ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੂੰ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਿਖਾਉਂਦਾ ਹੈ।