Python is a versatile programming language.

പൈത്തൺ ഒരു ബഹുമുഖ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്.


Hackers often use Python for its powerful libraries.

ശക്തമായ ലൈബ്രറികൾ ഉള്ളതുകൊണ്ട് ഹാക്കർമാർ പലപ്പോഴും പൈത്തൺ ഉപയോഗിക്കുന്നു.


The book explains how to build your own debugger.

പുസ്തകത്തിൽ നിങ്ങളുടെ സ്വന്തം ഡീബഗ്ഗർ എങ്ങനെ നിർമ്മിക്കാമെന്ന് വിശദീകരിക്കുന്നു.


നിങ്ങളുടെ സിസ്റ്റത്തിൽ പൈത്തൺ 2.5 ഇൻസ്റ്റാൾ ചെയ്യുക.


This chapter covers setting up the development environment.

ഈ അധ്യായത്തിൽ വികസന പരിസ്ഥിതി സജ്ജീകരിക്കുന്നതിനെക്കുറിച്ച് പറയുന്നു.


You can use Python for various hacking tasks.

വിവിധതരം ഹാക്കിംഗ് ജോലികൾക്കായി നിങ്ങൾക്ക് പൈത്തൺ ഉപയോഗിക്കാം.


The author is a senior security researcher.

എഴുത്തുകാരൻ ഒരു മുതിർന്ന സുരക്ഷാ ഗവേഷകനാണ്.


The book is about Python programming for hackers.

പുസ്തകം ഹാക്കർമാർക്കുള്ള പൈത്തൺ പ്രോഗ്രാമിംഗിനെക്കുറിച്ചാണ്.


We will learn about fuzzing in this section.

ഈ ഭാഗത്ത്, ഫസ്സിംഗിനെക്കുറിച്ച് നമ്മൾ പഠിക്കും.


The book covers topics like debuggers and code injection.

ഡീബഗ്ഗറുകൾ, കോഡ് ഇൻജക്ഷൻ തുടങ്ങിയ വിഷയങ്ങൾ പുസ്തകത്തിൽ ഉൾക്കൊള്ളുന്നു.


Python is becoming the language of choice for many.

പലർക്കും ഇപ്പോൾ പൈത്തൺ ഒരു ഇഷ്ട്ടമുള്ള ഭാഷയായി മാറുകയാണ്.


പുസ്തകത്തിൽ പ്രായോഗിക ഉദാഹരണങ്ങൾ നൽകുന്നു.


ജോലികൾ എങ്ങനെ ഓട്ടോമേറ്റ് ചെയ്യാമെന്ന് നിങ്ങൾ പഠിക്കും.


The book explains the concepts behind hacking tools.

ഹാക്കിംഗ് ടൂളുകൾക്ക് പിന്നിലെ ആശയങ്ങൾ പുസ്തകം വിശദീകരിക്കുന്നു.


This is a guide for hackers and reverse engineers.

ഇത് ഹാക്കർമാർക്കും റിവേഴ്സ് എഞ്ചിനീയർമാർക്കുമുള്ള ഒരു വഴികാട്ടിയാണ്.


The book covers the basics of debugging.

ഡീബഗ്ഗിംഗിന്റെ അടിസ്ഥാന കാര്യങ്ങൾ പുസ്തകത്തിൽ ഉൾക്കൊള്ളുന്നു.


The author shows how to build your own tools.

നിങ്ങളുടെ സ്വന്തം ടൂളുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് എഴുത്തുകാരൻ കാണിച്ചുതരുന്നു.


The book is well-structured and easy to follow.

പുസ്തകം നന്നായി ചിട്ടപ്പെടുത്തിയതും പിന്തുടരാൻ എളുപ്പമുള്ളതുമാണ്.


The book helps you understand security concepts.

സുരക്ഷാ ആശയങ്ങൾ മനസ്സിലാക്കാൻ ഈ പുസ്തകം നിങ്ങളെ സഹായിക്കുന്നു.


The book is a valuable resource for security professionals.

സുരക്ഷാ വിദഗ്ധർക്ക് ഈ പുസ്തകം വളരെ വിലപ്പെട്ട ഒന്നാണ്.


The Python interactive shell provides full access to the interpreter.

പൈത്തൺ ഇന്ററാക്ടീവ് ഷെൽ, ഇന്റർപ്രട്ടറിലേക്ക് പൂർണ്ണമായ പ്രവേശനം നൽകുന്നു.


To ensure your environment finds the Python interpreter, you must edit the .bashrc file.

നിങ്ങളുടെ പരിസ്ഥിതിക്ക് പൈത്തൺ ഇന്റർപ്രട്ടറെ കണ്ടെത്താൻ കഴിയുമെന്ന് ഉറപ്പാക്കാൻ, നിങ്ങൾ .bashrc ഫയൽ എഡിറ്റ് ചെയ്യണം.


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

.bashrc ഫയൽ തുറന്ന് ഈ വരി ചേർക്കുക: export PATH=/usr/local/Python25/:$PATH.


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

ഇപ്പോൾ നിങ്ങൾക്ക് വിൻഡോസിലും, ലിനക്സിലും പൂർണ്ണമായി പ്രവർത്തിക്കുന്ന ഒരു പൈത്തൺ ഇന്റർപ്രട്ടർ ഉണ്ട്.


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

പൈത്തൺ ആപ്ലിക്കേഷനുകൾ വേഗത്തിൽ വികസിപ്പിക്കാനും ഡീബഗ് ചെയ്യാനും ഒരു മികച്ച IDE ഉപയോഗിക്കേണ്ടത് അത്യാവശ്യമാണ്.


The coupling of Eclipse and PyDev gives you powerful features.

എക്ലിപ്‌സും, പൈഡെവും തമ്മിലുള്ള ബന്ധം നിങ്ങൾക്ക് ശക്തമായ ഫീച്ചറുകൾ നൽകുന്നു.


Eclipse runs on Windows, Linux, and Mac and has excellent community support.

വിൻഡോസ്, ലിനക്സ്, മാക് എന്നിവയിൽ എക്ലിപ്സ് പ്രവർത്തിക്കുന്നു, കൂടാതെ മികച്ച കമ്മ്യൂണിറ്റി പിന്തുണയുമുണ്ട്.


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

http://www.eclipse.org/downloads/ എന്ന വെബ്സൈറ്റിൽ നിന്ന് എക്ലിപ്സ് ക്ലാസിക് പാക്കേജ് ഡൗൺലോഡ് ചെയ്യുക.


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

പേര് എന്ന ഫീൽഡിൽ PyDev Update പോലുള്ള വിവരണം നൽകുക.


Make sure the URL field contains http://pydev.sourceforge.net/updates/.

URL ഫീൽഡിൽ http://pydev.sourceforge.net/updates/ എന്ന് നൽകിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.


The next stage of the Eclipse configuration involves making sure that PyDev can find the proper Python interpreter.

എക്ലിപ്സ് കോൺഫിഗറേഷന്റെ അടുത്ത ഘട്ടം, ശരിയായ പൈത്തൺ ഇന്റർപ്രട്ടറെ കണ്ടെത്താൻ PyDev-നെ സഹായിക്കുക എന്നതാണ്.


വിൻഡോ -> പ്രിഫറൻസെസ് തിരഞ്ഞെടുക്കുക.


Expand the PyDev tree item, and select Interpreter – Python.

PyDev ട്രീ ഇനം വികസിപ്പിച്ച്, ഇന്റർപ്രറ്റർ - പൈത്തൺ തിരഞ്ഞെടുക്കുക.


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

ഇപ്പോൾ നിങ്ങൾക്ക് പ്രവർത്തിക്കുന്ന PyDev ഇൻസ്റ്റാൾ ഉണ്ട്, കൂടാതെ നിങ്ങളുടെ പുതിയതായി ഇൻസ്റ്റാൾ ചെയ്ത Python 2.5 ഇന്റർപ്രട്ടർ ഉപയോഗിക്കുന്നതിനായി ഇത് കോൺഫിഗർ ചെയ്തിട്ടുണ്ട്.


Before you start coding, you must create a new PyDev project.

കോഡിംഗ് ആരംഭിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾ ഒരു പുതിയ PyDev പ്രോജക്റ്റ് ഉണ്ടാക്കണം.


ഫയൽ -> പുതിയത് -> പ്രോജക്റ്റ് തിരഞ്ഞെടുക്കുക.


പ്രോജക്റ്റിന് Gray Hat Python എന്ന് പേര് നൽകുക.


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

എക്ലിപ്‌സിൽ നിന്ന് പൈത്തൺ സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കാൻ, റൺ ആസ് ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.


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

ഡൈനാമിക്കായി ബന്ധിപ്പിച്ച ലൈബ്രറികളിലെ ഫംഗ്ഷനുകൾ വിളിക്കാൻ ctypes ലൈബ്രറി നിങ്ങളെ സഹായിക്കുന്നു.


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

ctypes ലൈബ്രറി എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നിങ്ങൾ അടിസ്ഥാനപരമായി മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.


The debugger is responsible for handling access violations.

ആക്സസ് ലംഘനങ്ങൾ കൈകാര്യം ചെയ്യേണ്ടത് ഡീബഗ്ഗറാണ്.


We will start with extending breakpoint handlers.

ബ്രേക്ക്പോയിന്റ് കൈകാര്യം ചെയ്യുന്നവ വികസിപ്പിക്കുന്നതിലൂടെ നമുക്ക് ആരംഭിക്കാം.


The output should look similar to what is shown in Table 4-1.

പുറത്ത് വരുന്ന ഫലം പട്ടിക 4-1 ൽ കാണിച്ചിരിക്കുന്നതിന് സമാനമായിരിക്കും.


Now 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 it doesn’t have permission to access.

ഒരു പ്രക്രിയക്കുള്ളിൽ, പ്രവേശനാനുമതിയില്ലാത്ത മെമ്മറി ആക്സസ് ചെയ്യാൻ ശ്രമിക്കുമ്പോളാണ് ആക്സസ് ലംഘനം സംഭവിക്കുന്നത്.


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

സുരക്ഷാപരമായ വീക്ഷണകോണിൽ, എല്ലാ ആക്സസ് ലംഘനങ്ങളും ശ്രദ്ധാപൂർവ്വം അവലോകനം ചെയ്യണം.


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

ആക്സസ് ലംഘന കൈകാര്യം ചെയ്യുന്നവരെ ഇൻസ്റ്റാൾ ചെയ്യാൻ PyDbg-ക്ക് മികച്ച രീതിയുണ്ട്.


Let’s first create a test harness that will use the dangerous C function strcpy() to create a buffer overflow.

ബഫർ ഓവർഫ്ലോ ഉണ്ടാക്കാൻ, അപകടകരമായ സി ഫംഗ്ഷൻ strcpy() ഉപയോഗിക്കുന്ന ഒരു ടെസ്റ്റ് ഹാർനെസ്സ് നമുക്ക് ആദ്യം ഉണ്ടാക്കാം.


Now that we have the test case built, open a new file called access_ violation_handler.py.

ടെസ്റ്റ് കേസ് നിർമ്മിച്ച ശേഷം, access_violation_handler.py എന്ന പേരിൽ ഒരു പുതിയ ഫയൽ തുറക്കുക.


Once you have the debugger attached, hit any key in the console where the harness is running.

ഡീബഗ്ഗർ അറ്റാച്ച് ചെയ്ത ശേഷം, ഹാർനെസ് പ്രവർത്തിക്കുന്ന കൺസോളിൽ ഏതെങ്കിലും കീ അമർത്തുക.


The output reveals many pieces of useful information.

ഈ ഫലം വളരെ ഉപയോഗപ്രദമായ വിവരങ്ങൾ വെളിപ്പെടുത്തുന്നു.


The first portion tells you which instruction caused the access violation.

ആക്സസ് ലംഘനത്തിന് കാരണമായ നിർദ്ദേശം ഏതാണെന്ന് ആദ്യ ഭാഗം നിങ്ങളോട് പറയും.


This information is useful for writing an exploit.

ഒരു എക്സ്പ്ലോയിറ്റ് എഴുതുന്നതിന് ഈ വിവരങ്ങൾ ഉപയോഗപ്രദമാണ്.


The second portion is the context dump of all the registers.

രണ്ടാമത്തെ ഭാഗം എല്ലാ രജിസ്റ്ററുകളുടെയും സന്ദർഭ ഡംപാണ്.


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

PyDbg ഉപയോഗിച്ച് ഒരു ക്രാഷ് ഹാൻഡ്ലർ സ്ഥാപിക്കുന്നത് എത്ര ലളിതമാണെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും.


It is an incredibly useful feature that enables you to automate the crash handling.

ക്രാഷ് കൈകാര്യം ചെയ്യൽ ഓട്ടോമേറ്റ് ചെയ്യാൻ നിങ്ങളെ സഹായിക്കുന്ന വളരെ ഉപയോഗപ്രദമായ ഒരു സവിശേഷതയാണിത്.


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 വരുന്നു.


Using user-defined callback functions is quite easy.

ഉപയോക്താവ് നിർവചിച്ച കോൾബാക്ക് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നത് വളരെ എളുപ്പമാണ്.


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

ഉപയോക്താവ് നിർവചിച്ച കോൾബാക്ക് ഉപയോഗിച്ച്, ഡീബഗ്ഗർ ഒരു ഡീബഗ്ഗിംഗ് ഇവന്റ് സ്വീകരിക്കുമ്പോൾ നമുക്ക് ഇഷ്ടമുള്ള ലോജിക് നടപ്പിലാക്കാൻ കഴിയും.


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

ഏത് സമയത്തും CPU രജിസ്റ്ററുകളുടെ അവസ്ഥ അറിയാൻ ഒരു ഡീബഗ്ഗറിന് കഴിയണം.


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

ആദ്യം, ഡീബഗ്ഗിയിൽ നിലവിൽ പ്രവർത്തിക്കുന്ന ത്രെഡിന്റെ ഒരു ഹാൻഡിൽ നമ്മൾ നേടണം.


This is achieved using the ContinueDebugEvent() function.

ContinueDebugEvent() ഫംഗ്ഷൻ ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്.


The dwProcessId and dwThreadId parameters are fields in the DEBUG_EVENT struct.

dwProcessId, dwThreadId എന്നീ പരാമീറ്ററുകൾ DEBUG_EVENT സ്ട്രക്ചറിലെ ഫീൽഡുകളാണ്.


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

നമ്മൾ അറ്റാച്ച് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന പ്രോസസ്സിൻ്റെ PID ആണ് ഇതിലൂടെ കടന്നുപോവുക.


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

ഹാൻഡിലറുകൾ എക്സിക്യൂട്ട് ചെയ്തു കഴിഞ്ഞാൽ, പ്രോസസ് തുടർന്നും പ്രവർത്തിക്കാൻ നമ്മൾ ആഗ്രഹിക്കുന്നു.


Let’s put all of this together and extend our my_debugger class.

ഇവയെല്ലാം ഒരുമിപ്പിക്കുകയും നമ്മുടെ my_debugger ക്ലാസ് വികസിപ്പിക്കുകയും ചെയ്യാം.


Download this file now and overwrite your current copy.

ഈ ഫയൽ ഇപ്പോൾ ഡൗൺലോഡ് ചെയ്ത് നിങ്ങളുടെ നിലവിലെ കോപ്പിയിൽ ഓവർറൈറ്റ് ചെയ്യുക.


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

structs, unions, constants എന്നിവയുടെ സൃഷ്ടി നമ്മൾ ഇനി ചർച്ച ചെയ്യുന്നില്ല.


Now we have to poll the debuggee for debugging events.

ഇനി നമ്മൾ ഡീബഗ്ഗിയിൽ നിന്നുള്ള ഡീബഗ്ഗിംഗ് ഇവന്റുകൾക്കായി പോൾ ചെയ്യണം.


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

ഫംഗ്ഷൻ വിജയിച്ചാൽ, ഇത് പ്രോസസ് ഒബ്ജക്റ്റിലേക്ക് ഒരു ഹാൻഡിൽ നൽകും.


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

DebugActiveProcess() ഫംഗ്ഷൻ ഉപയോഗിച്ച് നമ്മൾ പ്രോസസ്സിലേക്ക് അറ്റാച്ച് ചെയ്യുന്നു.


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.

ഡീബഗ്ഗർ കണ്ടെത്തുന്ന ഓരോ ഇവന്റിനും അനുബന്ധ ഇവന്റ് ഹാൻഡ്ലറുകൾ ഉണ്ട്.


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

ഇനി ചെയ്യാനുള്ളത് പ്രോസസ്സിൽ നിന്ന് വേർപെടുത്തുക എന്നതാണ്.


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.

അവസാനത്തെ നടപ്പാക്കൽ വിശദാംശം, ഡീബഗ്ഗിംഗ് ഇവന്റുകൾ കൈകാര്യം ചെയ്യുന്നതിന് ഞങ്ങളുടെ പ്രാഥമിക ഡീബഗ് ലൂപ്പ് ഉണ്ടാക്കുക എന്നതാണ്.


Ensure the Process Identifier (PID) checkbox is checked, and click OK.

പ്രോസസ് ഐഡന്റിഫയർ (PID) ചെക്ക്ബോക്സ് ശരിയാണെന്ന് ഉറപ്പാക്കുക, തുടർന്ന് ശരി (OK) ക്ലിക്ക് ചെയ്യുക.


If everything works as described, then comment out the following two lines from my_debugger.py.

വിവരിച്ചതുപോലെ എല്ലാം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, my_debugger.py-യിൽ നിന്നുള്ള താഴെയുള്ള രണ്ട് വരികൾ കമന്റ് ചെയ്യുക.


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

ഒരു പ്രോസസ് ഹാൻഡിൽ എങ്ങനെ നേടാം, ഒരു ഡീബഗ് ചെയ്ത പ്രോസസ് എങ്ങനെ ഉണ്ടാക്കാം, കൂടാതെ പ്രവർത്തിക്കുന്ന ഒരു പ്രോസസ്സിലേക്ക് എങ്ങനെ അറ്റാച്ച് ചെയ്യാം എന്നതിൻ്റെ അടിസ്ഥാന കാര്യങ്ങൾ ഇപ്പോൾ വിശദീകരിച്ചു കഴിഞ്ഞു, ഇനി നമുക്ക് കൂടുതൽ നൂതനമായ ഫീച്ചറുകളിലേക്ക് കടക്കാം.


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

അധിക മെമ്മറി വിലാസങ്ങളിൽ നിന്ന് കുറഞ്ഞ മെമ്മറി വിലാസങ്ങളിലേക്ക് സ്റ്റാക്ക് വളരുന്നു.


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

my_socks() ഫംഗ്ഷൻ തിരികെ വരുമ്പോൾ, അത് സ്റ്റാക്കിലെ എല്ലാ മൂല്യങ്ങളും പുറത്തെടുക്കുന്നു.


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

പ്രാദേശിക വേരിയബിളുകൾ മെമ്മറിയുടെ ഭാഗങ്ങളാണ്, അത് എക്സിക്യൂട്ട് ചെയ്യുന്ന ഫംഗ്ഷന് വേണ്ടി മാത്രം സാധുതയുള്ളതാണ്.


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

ഡീബഗ്ഗറുകൾ ഒരു അനന്തമായ ലൂപ്പായി പ്രവർത്തിക്കുന്നു, അത് ഒരു ഡീബഗ്ഗിംഗ് ഇവന്റ് സംഭവിക്കുന്നതിനായി കാത്തിരിക്കുന്നു.


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

ഓരോ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിനും ഈ ഇവന്റുകൾ ഒരു ഡീബഗ്ഗറിലേക്ക് അയയ്‌ക്കുന്നതിന് വ്യത്യസ്ത രീതികളുണ്ട്.


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.

ഡീബഗ്ഗ് ചെയ്യുന്ന ഒരു പ്രക്രിയ താൽക്കാലികമായി നിർത്താനുള്ള കഴിവ് ബ്രേക്ക്പോയിന്റുകൾ സ്ഥാപിക്കുന്നതിലൂടെ സാധ്യമാക്കുന്നു.


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

നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുമ്പോൾ CPU-യെ താൽക്കാലികമായി നിർത്താൻ സോഫ്റ്റ് ബ്രേക്ക്പോയിന്റുകൾ ഉപയോഗിക്കുന്നു.


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 debugger is told to set a breakpoint at a desired address, it reads the first opcode byte at the requested address and stores it.

ഒരു ആവശ്യമുള്ള വിലാസത്തിൽ ഒരു ബ്രേക്ക്പോയിന്റ് സ്ഥാപിക്കാൻ ഡീബഗ്ഗറിനോട് പറയുമ്പോൾ, അത് അഭ്യർത്ഥിച്ച വിലാസത്തിലെ ആദ്യത്തെ ഓപ്‌കോഡ് ബൈറ്റ് വായിക്കുകയും സംഭരിക്കുകയും ചെയ്യുന്നു.


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) ചെക്ക്‌സം നിങ്ങൾ മാറ്റുന്നു.


Hardware breakpoints are useful when a small number of breakpoints are desired and the debugged software itself cannot be modified.

ചെറിയ എണ്ണം ബ്രേക്ക്പോയിന്റുകൾ ആവശ്യമുള്ളപ്പോഴും ഡീബഗ്ഗ് ചെയ്ത സോഫ്റ്റ്‌വെയർ തന്നെ മാറ്റാൻ കഴിയാത്തപ്പോഴും ഹാർഡ്‌വെയർ ബ്രേക്ക്പോയിന്റുകൾ ഉപയോഗപ്രദമാണ്.


Memory breakpoints aren’t really breakpoints at all.

മെമ്മറി ബ്രേക്ക്പോയിന്റുകൾ യഥാർത്ഥത്തിൽ ബ്രേക്ക്പോയിന്റുകളല്ല.


When a debugger is setting a memory breakpoint, it is changing the permissions on a region, or page, of memory.

ഒരു ഡീബഗ്ഗർ ഒരു മെമ്മറി ബ്രേക്ക്പോയിന്റ് സ്ഥാപിക്കുമ്പോൾ, അത് മെമ്മറിയുടെ ഒരു ഭാഗത്തോ, പേജിലോ ഉള്ള അനുമതികൾ മാറ്റുന്നു.


Each operating system also has intrinsic functions that allow you to query the current memory permissions in place for a particular page and modify them if so desired.

ഓരോ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിനും ഒരു പ്രത്യേക പേജിനായി നിലവിലുള്ള മെമ്മറി അനുമതികൾ അന്വേഷിക്കാനും ആവശ്യമെങ്കിൽ അവ പരിഷ്കരിക്കാനും നിങ്ങളെ അനുവദിക്കുന്ന உள்ளார்ന്ന ഫംഗ്ഷനുകളും ഉണ്ട്.


We will begin by creating a simple debugger in Windows where the knowledge you have gained in both ctypes and debugging internals will be put to good use.

ctypes-ലും ഡീബഗ്ഗിംഗ് ഇന്റേണൽസിലും നിങ്ങൾ നേടിയ അറിവ് ഉപയോഗിച്ച് വിൻഡോസിൽ ഒരു ലളിതമായ ഡീബഗ്ഗർ ഉണ്ടാക്കുന്നതിലൂടെയാണ് നമ്മൾ ആരംഭിക്കുന്നത്.


In order to perform a debugging task on a process, you must first be able to associate the debugger to the process in some way.

ഒരു പ്രക്രിയയിൽ ഒരു ഡീബഗ്ഗിംഗ് ടാസ്‌ക് ചെയ്യുന്നതിന്, നിങ്ങൾ ആദ്യം ഡീബഗ്ഗറെ ഏതെങ്കിലും വിധത്തിൽ പ്രക്രിയയുമായി ബന്ധിപ്പിക്കാൻ കഴിയണം.


The advantage of opening a process is that you have control of the process before it has a chance to run any code.

ഒരു പ്രക്രിയ തുറക്കുന്നതിലൂടെ, ഏതെങ്കിലും കോഡ് പ്രവർത്തിപ്പിക്കാൻ അവസരം ലഭിക്കുന്നതിന് മുമ്പ് നിങ്ങൾക്ക് ആ പ്രക്രിയയുടെ നിയന്ത്രണം ലഭിക്കുന്നു.


We will deal only with the parameters that are important for creating a process under a debugger.

ഒരു ഡീബഗ്ഗറിന് കീഴിൽ ഒരു പ്രക്രിയ സൃഷ്ടിക്കുന്നതിന് പ്രധാനപ്പെട്ട പാരാമീറ്ററുകൾ മാത്രമാണ് നമ്മൾ കൈകാര്യം ചെയ്യുക.


The FastLogHook object creates a memory region to store captured information.

പിടിച്ചെടുത്ത വിവരങ്ങൾ സംഭരിക്കുന്നതിനായി ഫാസ്റ്റ്‌ലോഗ്‌ഹൂക്ക് ഒബ്ജക്റ്റ് ഒരു മെമ്മറി പ്രദേശം ഉണ്ടാക്കുന്നു.


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

getAllLog() എന്ന റാപ്പർ ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾ ഈ പേജ് ചോദ്യം ചെയ്യണം.


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

ഒരു ഹുക്ക് ചെയ്ത ഫംഗ്ഷൻ പ്രവർത്തിക്കുമ്പോഴെല്ലാം, അതിന്റെ വിലാസം സംഭരിക്കപ്പെടും.


The STDCALLFastLogHook is adjusted for the STDCALL calling convention.

STDCALL കോളിംഗ് കൺവെൻഷനായി STDCALLFastLogHook ക്രമീകരിച്ചിരിക്കുന്നു.


For the cdecl convention use the normal FastLogHook.

cdecl കൺവെൻഷനായി സാധാരണ FastLogHook ഉപയോഗിക്കുക.


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

കൂടുതൽ പ്രകടനം ആവശ്യമുള്ള ലോഗിംഗ് ഹുക്കിനായുള്ള പ്രതികരണമായാണ് ഹിപ്പി പുറത്തുവന്നത്.


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

നിങ്ങൾ അതിൽ ഒരു ഫയൽ ഡയലോഗ് തുറക്കുകയാണെങ്കിൽ, ഏകദേശം 4,500 കോളുകൾ ആവശ്യമാണ്.


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

ഹീപ്പ് റൂട്ടീനുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിന് ഹിപ്പി ഒരു ഉദാഹരണമായി ഉപയോഗിക്കാം.


For RtlFreeHeap we are going to trap all three arguments.

RtlFreeHeap-നായി, ഞങ്ങൾ മൂന്ന് ആർഗ്യുമെന്റുകളും ട്രാപ്പ് ചെയ്യാൻ പോകുന്നു.


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

ഒരു പുതിയ പൈത്തൺ ഫയൽ തുറന്ന്, hippie_easy.py എന്ന് പേരിടുക, തുടർന്ന് താഴെ പറയുന്ന കോഡ് നൽകുക.


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

ശരിയായ അടിസ്ഥാന ബ്ലോക്ക് കണ്ടെത്താനുള്ള നിക്കോയുടെ ഫംഗ്ഷനാണിത്.


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

പൈത്തൺ കോഡ് ഫംഗ്ഷന്റെ തലയിൽ നിന്ന് ഡിസ്അസംബ്ലിംഗ് ചെയ്യാൻ തുടങ്ങുന്നു.


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

ബൈനറികൾ സങ്കീർണ്ണമായ ജീവികളാണ്, അവർക്ക് തെറ്റുകൾക്ക് സ്ഥാനമില്ല.


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

ഹുക്കുകൾ സ്ഥാപിക്കുന്നതിന് നിങ്ങൾ ഇത് ഒരു തവണ പ്രവർത്തിപ്പിക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ് സ്ക്രിപ്റ്റ്.


For the RtlAllocateHeap call, we are trapping three arguments.

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.

നോട്ട്പാഡ്.exe ഉപയോഗിച്ച്, നിക്കോ കൃത്യതയുള്ള ആളായിരുന്നോ എന്ന് നോക്കാം.


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.

ഒരു പുതിയ Python ഫയൽ തുറന്ന്, അതിനെ snapshot.py എന്ന് പേരുനൽകി താഴെ പറയുന്ന കോഡ് നൽകുക.


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

അതിനാൽ ആദ്യത്തെ ഘട്ടം ഒരു ഡീബഗ്ഗർ ത്രെഡിന് കീഴിൽ ടാർഗെറ്റ് ആപ്ലിക്കേഷൻ ആരംഭിക്കുക എന്നതാണ്.


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

പ്രത്യേക ത്രെഡുകൾ ഉപയോഗിക്കുന്നതിലൂടെ, നമ്മുടെ ഇൻപുട്ടിനായി കാത്തിരിക്കുമ്പോൾ ടാർഗെറ്റ് ആപ്ലിക്കേഷൻ താൽക്കാലികമായി നിർത്താതെ തന്നെ സ്നാപ്ഷോട്ടിംഗ് കമാൻഡുകൾ നൽകാൻ കഴിയും.


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

ഡീബഗ്ഗർ ത്രെഡ് ഒരു സാധുവായ PID നൽകിക്കഴിഞ്ഞാൽ, ഞങ്ങളുടെ ഇൻപുട്ട് എടുക്കുന്ന ഒരു പുതിയ ത്രെഡ് ഞങ്ങൾ ആരംഭിക്കും.


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

തുടർന്ന് ഞങ്ങൾ ഒരു കമാൻഡ് അയക്കുമ്പോൾ, നമ്മൾ ഒരു സ്നാപ്ഷോട്ട് എടുക്കുകയാണോ, ഒരു സ്നാപ്ഷോട്ട് പുനഃസ്ഥാപിക്കുകയാണോ, അതോ പുറത്തുകടക്കുകയാണോ എന്ന് ഇത് വിലയിരുത്തും - വളരെ ലളിതമാണ്.


The file fuzzer defines global variables for tracking test iterations.

ഫയൽ ഫസ്സർ, ടെസ്റ്റ് ആവർത്തനങ്ങളെ ട്രാക്ക് ചെയ്യുന്നതിന്, ഗ്ലോബൽ വേരിയബിളുകൾ നിർവചിക്കുന്നു.


The file_picker function randomly selects a file for mutation.

file_picker ഫംഗ്ഷൻ, രൂപാന്തരം വരുത്തുന്നതിന് ഒരു ഫയൽ ക്രമരഹിതമായി തിരഞ്ഞെടുക്കുന്നു.


We need to get the target application loaded inside a debugger thread.

ഒരു ഡീബഗ്ഗർ ത്രെഡിനുള്ളിൽ ടാർഗെറ്റ് ആപ്ലിക്കേഷൻ ലോഡ് ചെയ്യേണ്ടതുണ്ട്.


The monitoring thread will kill the debugger after a reasonable time.

ഒരു ന്യായമായ സമയത്തിനു ശേഷം മോണിറ്ററിംഗ് ത്രെഡ് ഡീബഗ്ഗറെ അവസാനിപ്പിക്കും.


We'll also throw in the email notification routine.

ഇമെയിൽ അറിയിപ്പ് ശൃംഖലയും ഞങ്ങൾ ഉൾപ്പെടുത്തും.


The primary debugger thread runs the application.

പ്രധാന ഡീബഗ്ഗർ ത്രെഡ് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നു.


The access violation handler traps the crash information.

ആക്സസ് ലംഘന കൈകാര്യം ചെയ്യുന്നയാൾ, ക്രാഷ് വിവരങ്ങൾ ട്രാപ്പ് ചെയ്യുന്നു.


The monitor thread waits and then terminates the process.

മോണിറ്റർ ത്രെഡ് കാത്തിരുന്ന് പ്രക്രിയ അവസാനിപ്പിക്കുന്നു.


The emailing routine ships out crash information.

ഇമെയിലിംഗ് ശൃംഖല, ക്രാഷ് വിവരങ്ങൾ അയയ്ക്കുന്നു.


The fuzz function checks if a fuzzing iteration is running.

ഒരു ഫസ്സിംഗ് ആവർത്തനം പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് ഫസ് ഫംഗ്ഷൻ പരിശോധിക്കുന്നു.


We pass the selected document to our mutation function.

തിരഞ്ഞെടുത്ത ഡോക്യുമെന്റ്, നമ്മുടെ രൂപാന്തരീകരണ ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നു.


The debugger thread fires up the application.

ഡീബഗ്ഗർ ത്രെഡ് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നു.


We wait for the debugger thread to register the PID.

ഡീബഗ്ഗർ ത്രെഡ് PID രജിസ്റ്റർ ചെയ്യുന്നതിനായി ഞങ്ങൾ കാത്തിരിക്കുന്നു.


The monitoring thread makes sure we kill the application.

ആപ്ലിക്കേഷൻ അവസാനിപ്പിക്കുന്നു എന്ന് മോണിറ്ററിംഗ് ത്രെഡ് ഉറപ്പാക്കുന്നു.


We increment the iteration count and reenter the main loop.

ആവർത്തനങ്ങളുടെ എണ്ണം വർദ്ധിപ്പിച്ച്, പ്രധാന ലൂപ്പിലേക്ക് വീണ്ടും പ്രവേശിക്കുന്നു.


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 applies the test case to the buffer.

ഫസ്സർ, ടെസ്റ്റ് കേസ് ബഫറിലേക്ക് പ്രയോഗിക്കുന്നു.


ഫസ്സർ, രൂപാന്തരം വരുത്തിയ ഫയൽ എഴുതുന്നു.


The -e flag is the path to the target application’s executable.

-e ഫ്ലാഗ്, ടാർഗെറ്റ് ആപ്ലിക്കേഷന്റെ എക്സിക്യൂട്ടബിളിന്റെ പാതയാണ്.


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

പ്രത്യേക ഉപകരണങ്ങൾ ഇല്ലാതെ, ഒരു കമ്പ്യൂട്ടർ ഉപയോക്താവിന് ADS-ൻ്റെ ഉള്ളടക്കം കാണാൻ കഴിയില്ല.


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.

ഒരു ഫയലിൽ ആൾട്ടർനേറ്റ് ഡാറ്റാ സ്ട്രീം ഉപയോഗിക്കുന്നതിന്, ഒരു കൊളനും ഫയൽനാമവും ചേർക്കുകയേ വേണ്ടൂ.


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

ഈ സാഹചര്യത്തിൽ, reverser.exe-ൽ അറ്റാച്ച് ചെയ്തിട്ടുള്ള ഒരു ആൾട്ടർനേറ്റ് ഡാറ്റാ സ്ട്രീമിൽ സംഭരിച്ചിരിക്കുന്ന vncdll.dll-ലേക്ക് ഞങ്ങൾ പ്രവേശിക്കുന്നു.


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

ഒരു ഫയൽ വായിക്കുകയും അത് ഒരു ADS-ലേക്ക് എഴുതുകയും ചെയ്യുന്ന ഒരു ലളിതമായ യൂട്ടിലിറ്റി സ്ക്രിപ്റ്റ് എഴുതാം.


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

ആദ്യത്തെ കമാൻഡ്-ലൈൻ ആർഗ്യുമെൻ്റ് നമ്മൾ വായിക്കാൻ ആഗ്രഹിക്കുന്ന DLL ആണ്, രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് ടാർഗെറ്റ് ഫയലാണ്.


We can use this little utility to store any kind of files we would like alongside the executable.

എക്സിക്യൂട്ടബിളിനൊപ്പം ആവശ്യമുള്ള ഏത് തരത്തിലുള്ള ഫയലുകളും സംഭരിക്കുന്നതിന് ഈ ചെറിയ യൂട്ടിലിറ്റി ഉപയോഗിക്കാം.


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

വളരെ ലളിതമായി ഒരു ആപ്ലിക്കേഷൻ ആരംഭിക്കുന്ന, എക്സിക്യൂഷൻ റീഡയറക്ഷൻ കോഡ് നിർമ്മിച്ചുകൊണ്ട് തുടങ്ങാം.


When the user attempts to use the calculator, she will be inadvertently running our backdoor.

ഉപയോക്താവ് കാൽക്കുലേറ്റർ ഉപയോഗിക്കാൻ ശ്രമിക്കുമ്പോൾ, അവൾ അറിയാതെ തന്നെ നമ്മുടെ ബാക്ക്ഡോർ പ്രവർത്തിപ്പിക്കും.


We are including the my_debugger_defines.py file from Chapter 3.

നമ്മൾ 3-ാം അധ്യായത്തിലെ my_debugger_defines.py ഫയൽ ഉൾപ്പെടുത്തുന്നു.


This library is from Chapter 3 and contains all the necessary defines for process creation.

ഈ ലൈബ്രറി 3-ാം അധ്യായത്തിൽ നിന്നുള്ളതാണ്, കൂടാതെ പ്രോസസ് സൃഷ്ടിക്കുന്നതിന് ആവശ്യമായ എല്ലാ നിർവചനങ്ങളും ഇതിൽ അടങ്ങിയിരിക്കുന്നു.


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

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.

ഞങ്ങളുടെ ഇൻജക്ഷൻ ഫംഗ്ഷന് കോഡ് അല്ലെങ്കിൽ 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.

ഇനി ശരിയായ calc.exe പ്രോസസ്സിലേക്ക് രണ്ട് വ്യത്യസ്ത ഷെൽകോഡുകൾ ചേർക്കാനുള്ള സമയമാണ്.


We now have a fairly comprehensive backdoor that utilizes some stealth.

ചില രഹസ്യരീതികൾ ഉപയോഗിക്കുന്ന ഒരു സമഗ്രമായ ബാക്ക്ഡോർ ഇപ്പോൾ നമുക്കുണ്ട്.


A handy Python library called py2exe allows you to compile a Python script into a full-fledged Windows executable.

py2exe എന്ന ഒരു നല്ല Python ലൈബ്രറി, ഒരു Python സ്ക്രിപ്റ്റ് പൂർണ്ണമായ Windows എക്സിക്യൂട്ടബിൾ ആക്കി മാറ്റാൻ നിങ്ങളെ സഹായിക്കുന്നു.


This makes our backdoor very portable in that we can move it onto a system without Python installed.

Python ഇൻസ്റ്റാൾ ചെയ്യാത്ത സിസ്റ്റത്തിലേക്ക് പോലും ഇത് മാറ്റാൻ കഴിയുന്നതിനാൽ, ഇത് ഞങ്ങളുടെ ബാക്ക്ഡോറിനെ വളരെ പോർട്ടബിൾ ആക്കുന്നു.


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-ൽ നിന്നുള്ള ഡിസ്അസംബ്ലി ഔട്ട്‌പുട്ട് ഒന്നു നോക്കൂ.


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 unconditional 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 ആയി സജ്ജീകരിക്കുന്ന ഒരു വിലാസം തുടർന്ന് മടങ്ങിവരുന്നു.


Normally you would have to hunt around manually for these addresses, but the exploit developers at Immunity have created a little Python called findantidep.py, which has a wizard that guides you through the process of finding these addresses.

സാധാരണയായി, ഈ വിലാസങ്ങൾക്കായി നിങ്ങൾ സ്വമേധയാ തിരയേണ്ടിവരും, എന്നാൽ ഇമ്മ്യൂണിറ്റിയിലെ എക്സ്പ്ലോയിറ്റ് ഡെവലപ്പർമാർ findantidep.py എന്ന് പേരുള്ള ഒരു ചെറിയ Python ഉണ്ടാക്കിയിട്ടുണ്ട്, ഇത് ഈ വിലാസങ്ങൾ കണ്ടെത്തുന്നതിനുള്ള പ്രക്രിയയിലൂടെ നിങ്ങളെ നയിക്കുന്നു.


It even creates the exploit string that you can copy and paste into your exploit to use these offsets with no effort.

ഈ ഓഫ്‌സെറ്റുകൾ യാതൊരു പ്രയത്നവുമില്ലാതെ ഉപയോഗിക്കുന്നതിന് നിങ്ങളുടെ എക്സ്പ്ലോയിറ്റിലേക്ക് പകർത്തി ഒട്ടിക്കാൻ കഴിയുന്ന എക്സ്പ്ലോയിറ്റ് സ്ട്രിംഗ് പോലും ഇത് ഉണ്ടാക്കുന്നു.


Let’s take a look at the findantidep.py script and then take it for a test drive.

findantidep.py സ്ക്രിപ്റ്റിലേക്ക് ഒന്നു നോക്കാം, തുടർന്ന് ഇതൊന്ന് ടെസ്റ്റ് ചെയ്തു നോക്കാം.


So we first search for commands that will set AL to 1 and then give the user the option of selecting from a list of addresses to use.

ആദ്യം, AL 1 ആയി സജ്ജീകരിക്കുന്ന കമാൻഡുകൾക്കായി ഞങ്ങൾ തിരയുന്നു, തുടർന്ന് ഉപയോഗിക്കേണ്ട വിലാസങ്ങളുടെ ഒരു ലിസ്റ്റിൽ നിന്ന് തിരഞ്ഞെടുക്കാനുള്ള ഓപ്ഷൻ ഉപയോക്താവിന് നൽകുന്നു.


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

Log വിൻഡോയിലേക്ക് ഫലങ്ങൾ നൽകുന്നതിലൂടെ സ്ക്രിപ്റ്റ് പൂർത്തിയാകുന്നു.


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

ഇപ്പോൾ നിങ്ങൾക്ക് ആ ഔട്ട്‌പുട്ട് ലൈൻ നിങ്ങളുടെ എക്സ്പ്ലോയിറ്റിലേക്ക് പകർത്തി നിങ്ങളുടെ ഷെൽ കോഡ് ചേർക്കാൻ കഴിയും.


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.

ഈ കോഡ്, ഞങ്ങളുടെ തിരയൽ മാനദണ്ഡങ്ങൾക്കെതിരെ സാധ്യമായ എല്ലാ പൊരുത്തങ്ങളും കണ്ടെത്താൻ Immunity Debugger-ൻ്റെ ശക്തമായ തിരയൽ 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 കോഡിനെ അടിസ്ഥാനമാക്കി ഡ്രൈവർ എന്ത് പ്രവർത്തനം നടത്തണം എന്ന് നിർണ്ണയിക്കാൻ ഒരു switch{} സ്റ്റേറ്റ്മെൻ്റ് സാധാരണയായി കാണാവുന്നതാണ്.


There can be many ways that the switch{} statement gets translated into assembly; take a look at Listing 10-6 for examples.

switch{} സ്റ്റേറ്റ്മെൻ്റ് അസംബ്ലിയിലേക്ക് വിവർത്തനം ചെയ്യാൻ പല വഴികളുണ്ട്; ഉദാഹരണങ്ങൾക്കായി ലിസ്റ്റിംഗ് 10-6 കാണുക.


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

ആദ്യത്തെ കേസിൽ, CMP നിർദ്ദേശങ്ങളുടെ ഒരു പരമ്പര കാണുമ്പോൾ, കൈമാറിയ IOCTL-മായി താരതമ്യം ചെയ്യുന്ന സ്ഥിരമായ സംഖ്യയാണ് ഞങ്ങൾ ലളിതമായി തിരയുന്നത്.


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

ആ സ്ഥിരമായ സംഖ്യ, ഡ്രൈവർ പിന്തുണയ്ക്കുന്ന സാധുവായ ഒരു IOCTL കോഡ് ആയിരിക്കണം.


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 കോഡ് നൽകുന്നു.


Take a look at the well-commented getIOCTLCodes() function inside the Libs\driverlib.py directory of your Immunity Debugger installation.

നിങ്ങളുടെ Immunity Debugger ഇൻസ്റ്റാളേഷന്റെ Libs\driverlib.py ഡയറക്ടറിയിലുള്ള നന്നായി കമൻ്റ് ചെയ്ത getIOCTLCodes() ഫംഗ്ഷൻ പരിശോധിക്കുക.


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

driverlib എങ്ങനെയാണ് നമ്മുടെ ചില ജോലികൾ ചെയ്യുന്നതെന്ന് ഇപ്പോൾ അറിയാം, നമുക്ക് അത് പ്രയോജനപ്പെടുത്താം!


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 കോഡുകളും കണ്ടെത്താനും ഈ ഫലങ്ങൾ ഒരു Python പിക്കിളിലേക്ക് സംരക്ഷിക്കാനും ഞങ്ങൾ driverlib ഉപയോഗിക്കും.


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

ഒരു ടാർഗെറ്റ് ഡ്രൈവർ Immunity Debugger-ലേക്ക് ലോഡ് ചെയ്ത് !ioctl_dump എന്ന PyCommand പ്രവർത്തിപ്പിക്കുക.


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 കോഡ് നിങ്ങളുടെ ലോഗ് ഫയൽ കാണിക്കും.


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 കാണുക.


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

Sulley-യുടെ ഡാറ്റാ പ്രിമിറ്റീവുകളെക്കുറിച്ചുള്ള നമ്മുടെ അറിവ് ഉപയോഗിച്ച് Sulley-യെ ഒരു 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.

Sulley സെഷനുകൾ, അഭ്യർത്ഥനകളെ ബന്ധിപ്പിക്കുകയും, നെറ്റ്‌വർക്ക് പാക്കറ്റ് ക്യാപ്‌ചർ, പ്രോസസ്സ് ഡീബഗ്ഗിംഗ്, ക്രാഷ് റിപ്പോർട്ടിംഗ്, വെർച്വൽ മെഷീൻ നിയന്ത്രണം എന്നിവ കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്ന സംവിധാനമാണ്.


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

ഒരു ക്ലയിന്റ് കണക്ട് ചെയ്യുമ്പോൾ ഓരോ FTP സെർവറിനും ഒരു ബാനർ ഉണ്ടാകുന്നതുകൊണ്ട് തന്നെ receive_ftp_banner() ഫംഗ്ഷൻ ആവശ്യമാണ്.


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

ഏതെങ്കിലും ഫസ് ഡാറ്റ അയക്കുന്നതിന് മുമ്പ് FTP ബാനർ സ്വീകരിക്കാൻ ഇത് Sulley-യോട് ആവശ്യപ്പെടുന്ന sess.pre_send പ്രോപ്പർട്ടിയിലേക്ക് ഞങ്ങൾ ഇത് ബന്ധിപ്പിക്കുന്നു.


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

സെഷൻ ഉണ്ടാക്കുന്നതിലെ ആദ്യത്തെ ഘട്ടം, ഞങ്ങളുടെ ഫസ്സറിന്റെ നിലവിലെ അവസ്ഥ ട്രാക്ക് ചെയ്യുന്ന ഒരു സെഷൻ ഫയൽ നിർവചിക്കുക എന്നതാണ്.


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 next step is to tie our FTP requests together in a logical fashion.

അടുത്ത ഘട്ടം, ഞങ്ങളുടെ FTP അഭ്യർത്ഥനകളെ യുക്തിസഹമായ രീതിയിൽ ബന്ധിപ്പിക്കുക എന്നതാണ്.


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.

Sulley-യുടെ ഏറ്റവും മികച്ച സവിശേഷതകളിലൊന്ന്, വയറിലെ ഫസ് ട്രാഫിക് നിരീക്ഷിക്കാനും ടാർഗെറ്റ് സിസ്റ്റത്തിൽ ഉണ്ടാകുന്ന ഏതൊരു തകരാറും കൈകാര്യം ചെയ്യാനുമുള്ള കഴിവാണ്.


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

ഇത് വളരെ പ്രധാനമാണ്, കാരണം ഒരു തകരാർ ഉണ്ടാകാൻ കാരണമായ യഥാർത്ഥ നെറ്റ്‌വർക്ക് ട്രാഫിക്കിലേക്ക് നിങ്ങൾക്ക് അത് ബന്ധിപ്പിക്കാൻ കഴിയും, ഇത് തകരാറിൽ നിന്ന് പ്രവർത്തിക്കുന്ന എക്സ്പ്ലോയിറ്റിലേക്ക് മാറാൻ എടുക്കുന്ന സമയം വളരെയധികം കുറയ്ക്കുന്നു.


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

പ്രധാന Sulley ഡയറക്ടറിയിൽ സ്ഥിതി ചെയ്യുന്ന process_monitor.py എന്ന പ്രോസസ് മോണിറ്ററിൽ നിന്ന് ആരംഭിക്കാം.


We would run the process_monitor.py script with the following command- line arguments:

ഇനി പറയുന്ന കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ process_monitor.py സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കും:


It requires a couple of prerequisite libraries, namely WinPcap 4.0, pcapy, and impacket, which all provide installation instructions at their download locations.

ഇതിന് WinPcap 4.0, pcapy, impacket തുടങ്ങിയ ചില ആവശ്യമായ ലൈബ്രറികൾ ആവശ്യമാണ്, അവയെല്ലാം ഡൗൺലോഡ് സ്ഥാനങ്ങളിൽ ഇൻസ്റ്റാളേഷൻ നിർദ്ദേശങ്ങൾ നൽകുന്നു.


As we did with the process-monitoring script, we just need to pass this script some valid arguments.

പ്രോസസ്-മോണിറ്ററിംഗ് സ്ക്രിപ്റ്റിനൊപ്പം ചെയ്തതുപോലെ, ഈ സ്ക്രിപ്റ്റിന് ചില സാധുവായ ആർഗ്യുമെന്റുകൾ നൽകേണ്ടതുണ്ട്.


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

ഔട്ട്‌പുട്ടിൽ നമ്മൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന നെറ്റ്‌വർക്ക് ഇന്റർഫേസ് [1]-ലേക്ക് സെറ്റ് ചെയ്തതായി കാണാം.


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

ഇപ്പോൾ രണ്ട് മോണിറ്ററിംഗ് ഏജന്റുകളും പ്രവർത്തിക്കുന്നു, കൂടാതെ ഫസ്സിംഗ് പ്രവർത്തനത്തിനായി ഞങ്ങൾ തയ്യാറാണ്.


Now we are actually going to fire up Sulley, and we’ll use its built-in web interface to keep an eye on its progress.

ഇപ്പോൾ നമ്മൾ Sulley പ്രവർത്തിപ്പിക്കാൻ പോകുകയാണ്, അതിന്റെ പുരോഗതി നിരീക്ഷിക്കാൻ ബിൽറ്റ്-ഇൻ വെബ് ഇന്റർഫേസ് ഉപയോഗിക്കും.


Because we are using IDAPython, we will be using some familiar functions to load the binary’s sections into the emulator.

IDAPython ഉപയോഗിക്കുന്നതിനാൽ, എമുലേറ്ററിലേക്ക് ബൈനറിയുടെ ഭാഗങ്ങൾ ലോഡ് ചെയ്യാൻ നമ്മൾ ചില പരിചിതമായ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കും.


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

നമ്മുടെ addnum_function_call.py സ്ക്രിപ്റ്റിലേക്ക് ചേർക്കുന്നത് തുടരാം.


First we instantiate the IDAPyEmu object, which is necessary in order for us to use any of the emulator’s methods.

ആദ്യം, എമുലേറ്ററിൻ്റെ ഏതെങ്കിലും രീതികൾ ഉപയോഗിക്കുന്നതിന് ആവശ്യമായ 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 and the SegEnd() function to determine the end of the sections.

വിഭാഗങ്ങളുടെ തുടക്കം കണ്ടെത്താൻ IDAPython SegByName() ഫംഗ്ഷനും, വിഭാഗങ്ങളുടെ അവസാനം നിർണ്ണയിക്കാൻ SegEnd() ഫംഗ്ഷനും ഉപയോഗിക്കുന്നു.


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

തുടർന്ന്, അവ PyEmu-ൻ്റെ മെമ്മറിയിൽ സംഭരിക്കുന്നതിന്, ഓരോ വിഭാഗങ്ങളിലൂടെയും ബൈറ്റ് ബൈറ്റായി കടന്നുപോകുന്നു.


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

കോഡും ഡാറ്റാ ഭാഗങ്ങളും മെമ്മറിയിൽ ലോഡ് ചെയ്തുകഴിഞ്ഞാൽ, ഫംഗ്ഷൻ കോളിനായുള്ള സ്റ്റാക്ക് പാരാമീറ്ററുകൾ സജ്ജീകരിക്കും.


We are going to install an instruction handler to be called when the retn instruction is executed, and begin execution.

retn നിർദ്ദേശം നടപ്പിലാക്കുമ്പോൾ വിളിക്കുന്ന ഒരു ഇൻസ്ട്രക്ഷൻ ഹാൻഡ്ലർ ഇൻസ്റ്റാൾ ചെയ്യാനും എക്സിക്യൂഷൻ ആരംഭിക്കാനും പോകുന്നു.


നിങ്ങളുടെ സ്ക്രിപ്റ്റിലേക്ക് താഴെ പറയുന്ന കോഡ് ചേർക്കുക.


We first set EIP to the head of the function, which is located at 0x00401000; this is where PyEmu will begin executing instructions.

ആദ്യം, 0x00401000-ൽ സ്ഥിതി ചെയ്യുന്ന ഫംഗ്ഷൻ്റെ തലയിലേക്ക് EIP സജ്ജീകരിക്കുന്നു; ഇവിടെയാണ് PyEmu നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കാൻ തുടങ്ങുന്നത്.


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.

തുടർന്ന്, ഫംഗ്ഷനുള്ളിലെ 10 നിർദ്ദേശങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യാൻ PyEmu-യോട് പറയുന്നു.


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

അവസാന ഘട്ടം retn ഇൻസ്ട്രക്ഷൻ ഹാൻഡ്ലർ കോഡ് ചെയ്യുക എന്നതാണ്, അതിനാൽ അവസാന സ്ക്രിപ്റ്റ് താഴെ പറയുന്ന രീതിയിൽ ആയിരിക്കും.


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

ret നിർദ്ദേശ ഹാൻഡ്ലർ, സ്റ്റാക്ക് ആർഗ്യുമെൻ്റുകളും EAX രജിസ്റ്ററിൻ്റെ മൂല്യവും വീണ്ടെടുക്കുകയും ഫംഗ്ഷൻ കോളിൻ്റെ ഫലം നൽകുകയും ചെയ്യുന്നു.


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

വിവിധ ബൈനറികൾ IDA-യിലേക്ക് ലോഡ് ചെയ്യാനും, ഒരു ഫംഗ്ഷൻ തിരഞ്ഞെടുക്കാനും, അതിലേക്ക് കോളുകൾ അനുകരിക്കാനും പരിശീലിക്കുക.


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

ഒരു ഫംഗ്ഷനിൽ നിരവധി ബ്രാഞ്ചുകളും, ലൂപ്പുകളും, റിട്ടേൺ പോയിൻ്റുകളും ഉള്ള, നൂറുകണക്കിനോ ആയിരക്കണക്കിനോ നിർദ്ദേശങ്ങൾ ഉണ്ടാകുമ്പോൾ ഈ ടെക്നിക്ക് എത്രത്തോളം ശക്തമായിരിക്കുമെന്ന് നിങ്ങൾ അത്ഭുതപ്പെടും.


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

ഒരു ഫംഗ്ഷൻ റിവേഴ്സ് ചെയ്യുന്ന ഈ രീതി ഉപയോഗിക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് മണിക്കൂറുകൾ ലാഭിക്കാൻ കഴിയും.


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

കംപ്രസ് ചെയ്ത എക്സിക്യൂട്ടബിൾ അൺപാക്ക് ചെയ്യാൻ PEPyEmu ലൈബ്രറി ഉപയോഗിക്കാം.


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 ഫംഗ്ഷൻ വിളിക്കപ്പെടുന്ന സ്ഥലങ്ങളാണ്.


if you browse to those addresses in the IDA graph view, you should see that the instruction is colored in, as shown in Figure 11-3.

നിങ്ങൾ IDA ഗ്രാഫ് വ്യൂവിൽ ആ വിലാസങ്ങൾ ബ്രൗസ് ചെയ്യുകയാണെങ്കിൽ, ചിത്രം 11-3-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, നിർദ്ദേശം നിറത്തിൽ കാണാം.


Figure 11-3: sprintf call colored in from the cross_ref.py script

ചിത്രം 11-3: cross_ref.py സ്ക്രിപ്റ്റിൽ നിന്നുള്ള sprintf കോൾ നിറത്തിൽ


When performing dynamic analysis on a target binary, it can be quite useful to understand what code gets executed while you are using the target executable.

ഒരു ടാർഗെറ്റ് ബൈനറിയിൽ ഡൈനാമിക് അനാലിസിസ് നടത്തുമ്പോൾ, ടാർഗെറ്റ് എക്സിക്യൂട്ടബിൾ ഉപയോഗിക്കുമ്പോൾ എന്ത് കോഡാണ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നതെന്ന് മനസ്സിലാക്കുന്നത് വളരെ ഉപയോഗപ്രദമാകും.


Whether this means testing code coverage on a networked application after you send it a packet or using a document viewer after you’ve opened a document, code coverage is a useful metric to understand how an executable operates.

നിങ്ങൾ ഒരു പാക്കറ്റ് അയച്ച ശേഷം ഒരു നെറ്റ്‌വർക്ക് ആപ്ലിക്കേഷനിൽ കോഡ് കവറേജ് പരിശോധിക്കുകയോ അല്ലെങ്കിൽ ഒരു ഡോക്യുമെന്റ് തുറന്ന ശേഷം ഒരു ഡോക്യുമെന്റ് വ്യൂവർ ഉപയോഗിക്കുകയോ ചെയ്യുന്നത് ഇതിന് അർത്ഥമാക്കാം, എക്സിക്യൂട്ടബിൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ കോഡ് കവറേജ് ഒരു ഉപയോഗപ്രദമായ അളവുകോലാണ്.


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.

ഒരു പുതിയ Python ഫയൽ തുറന്ന്, അതിന് 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; if we don’t do this, then we will have to manually resume the debugger after each breakpoint hit.

ഓരോ ബ്രേക്ക്പോയിന്റിലും എത്തുമ്പോൾ നിർത്തരുതെന്ന് ഡീബഗ്ഗറിനോട് പറയാൻ SetBptAttr കോൾ ഒരു ഫ്ലാഗ് സജ്ജമാക്കുന്നു; ഇത് ചെയ്തില്ലെങ്കിൽ, ഓരോ ബ്രേക്ക്പോയിന്റിലും എത്തിയ ശേഷം ഞങ്ങൾ സ്വമേധയാ ഡീബഗ്ഗർ പുനരാരംഭിക്കേണ്ടിവരും.


We then print out the total number of breakpoints that are set.

തുടർന്ന്, സ്ഥാപിച്ചിട്ടുള്ള ബ്രേക്ക്പോയിന്റുകളുടെ ആകെ എണ്ണം പ്രിൻ്റ് ഔട്ട് ചെയ്യുന്നു.


Our breakpoint handler prints out the address of each breakpoint that was hit, using the ea variable, which is really a reference to the EIP register at the time the breakpoint is hit.

ഞങ്ങളുടെ ബ്രേക്ക്പോയിൻ്റ് ഹാൻഡ്ലർ, ea വേരിയബിൾ ഉപയോഗിച്ച്, ഓരോ ബ്രേക്ക്പോയിൻ്റിൻ്റെയും വിലാസം പ്രിൻ്റ് ചെയ്യുന്നു, ഇത് ബ്രേക്ക്പോയിൻ്റ് എത്തുമ്പോൾ EIP രജിസ്റ്ററിലേക്കുള്ള ഒരു റഫറൻസാണ്.


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

ഇപ്പോൾ ഡീബഗ്ഗർ പ്രവർത്തിപ്പിക്കുക (ഹോട്ട്‌കീ = F9), കൂടാതെ ഏതൊക്കെ ഫംഗ്ഷനുകളാണ് പ്രവർത്തിക്കുന്നതെന്ന് കാണിക്കുന്ന ഔട്ട്‌പുട്ട് നിങ്ങൾക്ക് കാണാൻ കഴിയും.


This should give you a very high-level view of which functions get hit and in what order they are executed.

ഏതൊക്കെ ഫംഗ്ഷനുകളാണ് പ്രവർത്തിക്കുന്നതെന്നും അവ ഏത് ക്രമത്തിലാണ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നതെന്നും ഇത് നിങ്ങൾക്ക് ഒരു ഉയർന്ന തലത്തിലുള്ള കാഴ്ച നൽകും.


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

ഒരു ബൈനറിയിലെ സാധ്യതയുള്ള സുരക്ഷാ പ്രശ്നങ്ങൾ വിലയിരുത്തുന്ന സമയത്ത്, പ്രത്യേക ഫംഗ്ഷൻ കോളുകളുടെ സ്റ്റാക്ക് വലുപ്പം മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്.


This can tell you whether there are just pointers being passed to a function or there are stack allocated buffers, which can be of interest if you can control how much data is passed into those buffers (possibly leading to a common overflow vulner- ability).

ഒരു ഫംഗ്ഷനിലേക്ക് പോയിന്ററുകൾ മാത്രമാണോ കൈമാറുന്നത്, അതോ സ്റ്റാക്ക് അലോക്കേറ്റഡ് ബഫറുകൾ ഉണ്ടോ എന്ന് ഇത് നിങ്ങളോട് പറയും, ആ ബഫറുകളിലേക്ക് എത്ര ഡാറ്റയാണ് കൈമാറുന്നത് എന്ന് നിങ്ങൾക്ക് നിയന്ത്രിക്കാൻ കഴിയുമെങ്കിൽ ഇത് വളരെ പ്രസക്തമാണ് (ഒരു സാധാരണ ഓവർഫ്ലോ പ്രശ്നത്തിലേക്ക് ഇത് നയിച്ചേക്കാം).


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.

ഒരു പുതിയ Python ഫയൽ തുറന്ന്, അതിന് stack_calc.py എന്ന് പേര് നൽകി താഴെ പറയുന്ന കോഡ് നൽകുക.


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

ഒരു സ്റ്റാക്ക് വേരിയബിൾ ഒരു ബഫറായി കണക്കാക്കുന്നതിന് മുമ്പ് എത്ര വലുപ്പമുണ്ടാകണം എന്ന് നിർണ്ണയിക്കുന്ന ഒരു വലുപ്പ പരിധി ഞങ്ങൾ സജ്ജീകരിക്കുന്നു.


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.

ജസ്റ്റിൻ സീറ്റ്‌സ്, immunity, inc. യിലെ ഒരു മുതിർന്ന സുരക്ഷാ ഗവേഷകനാണ്.


He spends his time bug hunting, reverse engineering, writing exploits, and coding Python.

അദ്ദേഹം തന്റെ സമയം ബഗ് വേട്ടയാടുക, റിവേഴ്സ് എഞ്ചിനീയറിംഗ്, എക്സ്പ്ലോയിറ്റുകൾ എഴുതുക, പൈത്തൺ കോഡിംഗ് എന്നിവയ്ക്കായി ചെലവഴിക്കുന്നു.


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 സന്ദർശിക്കുക.


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.

നിലവിലുള്ള എക്സ്പ്ലോയിറ്റുകൾ എങ്ങനെ പ്രവർത്തിപ്പിക്കാമെന്ന് കാണിക്കുന്നതിനുപരി, ഹാക്കിംഗ്: ദി ആർട്ട് ഓഫ് എക്സ്പ്ലോയിറ്റേഷൻ, രണ്ടാം പതിപ്പിന്റെ രചയിതാവായ ജോൺ എറിക്സൺ, രഹസ്യ ഹാക്കിംഗ് ടെക്നിക്കുകൾ എങ്ങനെയാണ് യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്നതെന്ന് വിശദീകരിക്കുന്നു.


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

ഉൾപ്പെടുത്തിയിട്ടുള്ള LiveCD ഉപയോഗിച്ച് കോഡ് ഡീബഗ്ഗിംഗ് ചെയ്യുക.


ക്രിപ്റ്റോഗ്രാഫിക് ബലഹീനതകൾ ചൂഷണം ചെയ്യുക.


The IDA Pro Book covers everything from the very first steps with IDA to advanced automation techniques.

ഐഡിഎ പ്രോ ബുക്ക്, ഐഡിഎയുടെ ആദ്യ ഘട്ടങ്ങൾ മുതൽ, നൂതന ഓട്ടോമേഷൻ ടെക്നിക്കുകൾ വരെയുള്ള എല്ലാ കാര്യങ്ങളും ഉൾക്കൊള്ളുന്നു.


You’ll learn to identify known library routines.

പരിചിതമായ ലൈബ്രറി റൂട്ടീനുകൾ തിരിച്ചറിയാൻ നിങ്ങൾ പഠിക്കും.


The book also covers the popular plug-ins that make writing IDA scripts easier.

ഐഡിഎ സ്ക്രിപ്റ്റുകൾ എളുപ്പമാക്കുന്ന, ജനപ്രിയമായ പ്ലഗ്-ഇൻ-കളെക്കുറിച്ചും ഈ പുസ്തകത്തിൽ പറയുന്നു.