Python is a versatile programming language.

પાયથોન એક બહુમુખી પ્રોગ્રામિંગ ભાષા છે.


Hackers often use Python for various tasks.

હેકર્સ ઘણીવાર વિવિધ કાર્યો માટે પાયથોનનો ઉપયોગ કરે છે.


The book explains hacking tools and techniques.

પુસ્તક હેકિંગ ટૂલ્સ અને તકનીકો સમજાવે છે.


You will learn to build your own debugger.

તમે તમારું પોતાનું ડિબગર બનાવવાનું શીખી શકશો.


Automate tedious reversing and security tasks.

કંટાળાજનક રિવર્સિંગ અને સુરક્ષા કાર્યોને સ્વચાલિત કરો.


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

લેખક બતાવે છે કે હાલના પાયથોન-આધારિત સુરક્ષા સાધનોનો ઉપયોગ કેવી રીતે કરવો.


Sniff secure traffic out of an encrypted web browser session.

એન્ક્રિપ્ટેડ વેબ બ્રાઉઝર સત્રમાંથી સુરક્ષિત ટ્રાફિકને સ્નિફ કરો.


The world's best hackers are using Python.

વિશ્વના શ્રેષ્ઠ હેકર્સ પાયથોનનો ઉપયોગ કરી રહ્યા છે.


This book is for hackers and reverse engineers.

આ પુસ્તક હેકર્સ અને રિવર્સ એન્જિનિયર્સ માટે છે.


The book covers topics like debuggers and fuzzers.

પુસ્તકમાં ડિબગર્સ અને ફઝર્સ જેવા વિષયો આવરી લેવામાં આવ્યા છે.


તમારા સિસ્ટમ માટે પાયથોન 2.5 ઇન્સ્ટોલ કરો.


You can use Eclipse and PyDev for development.

તમે વિકાસ માટે Eclipse અને PyDev નો ઉપયોગ કરી શકો છો.


પુસ્તક ctypes ની મૂળભૂત બાબતો સમજાવે છે.


Debuggers are crucial tools for hackers.

હેકર્સ માટે ડિબગર્સ મહત્વપૂર્ણ સાધનો છે.


Learn about soft and hard hooking techniques.

સોફ્ટ અને હાર્ડ હૂકિંગ તકનીકો વિશે જાણો.


The book discusses DLL and code injection.

પુસ્તક DLL અને કોડ ઇન્જેક્શનની ચર્ચા કરે છે.


ફઝિંગ એ બગ્સ શોધવાની એક તકનીક છે.


સૂલી એક શક્તિશાળી ફઝિંગ ફ્રેમવર્ક છે.


Fuzz Windows drivers to find vulnerabilities.

નબળાઈઓ શોધવા માટે વિન્ડોઝ ડ્રાઇવરોને ફઝ કરો.


IDAPython is used for scripting IDA Pro.

IDAPython નો ઉપયોગ IDA Pro ને સ્ક્રિપ્ટિંગ માટે થાય છે.


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.

ચલ 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.

સોફ્ટ બ્રેકપોઇન્ટ એ એક-બાઇટ સૂચના છે જે અમલને અટકાવે છે.


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

એસેમ્બલી સૂચના એ CPU દ્વારા ચલાવવા માટેના આદેશનું ઉચ્ચ-સ્તરનું પ્રતિનિધિત્વ છે.


Think of assembly instructions as the DNS of CPUs.

એસેમ્બલી સૂચનાઓને CPUs ના DNS તરીકે વિચારો.


In order to set a soft breakpoint at this address and halt the CPU, we have to swap out a single byte.

આ સરનામાં પર સોફ્ટ બ્રેકપોઇન્ટ સેટ કરવા અને CPU ને રોકવા માટે, આપણે એક જ બાઇટને સ્વેપ કરવી પડશે.


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

જ્યારે CPU આવે છે અને તે બાઇટને હિટ કરે છે, ત્યારે તે અટકી જાય છે, INT3 ઇવેન્ટ ફાયર કરે છે.


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

સોફ્ટ બ્રેકપોઇન્ટ્સમાં એક ચેતવણી છે, જોકે: જ્યારે તમે મેમરીમાં એક્ઝેક્યુટેબલનું એક બાઇટ બદલો છો, ત્યારે તમે ચાલતા સોફ્ટવેરના સાયક્લિક રિડન્ડન્સી ચેક (CRC) ચેકસમને બદલો છો.


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

જ્યારે થોડા બ્રેકપોઇન્ટ્સની ઇચ્છા હોય અને ડિબગ કરેલા સોફ્ટવેરમાં ફેરફાર કરી શકાતો નથી, ત્યારે હાર્ડવેર બ્રેકપોઇન્ટ્સ ઉપયોગી છે.


Python interactive shell, which provides full access to the Python interpreter and any included libraries.

પાયથોન ઇન્ટરેક્ટિવ શેલ, જે પાયથોન ઇન્ટરપ્રીટર અને કોઈપણ સમાવિષ્ટ લાઇબ્રેરીઓની સંપૂર્ણ ઍક્સેસ પ્રદાન કરે છે.


A quick test will show that it’s correctly interpreting commands: >>> print "Hello World!" Hello World!

એક ઝડપી પરીક્ષણ બતાવશે કે તે આદેશોને યોગ્ય રીતે અર્થઘટન કરી રહ્યું છે: >>> પ્રિન્ટ "હેલો વર્લ્ડ!" હેલો વર્લ્ડ!


To ensure that your user environment knows where to find the Python interpreter auto- matically, you must edit the /root/.bashrc file.

તમારું વપરાશકર્તા પર્યાવરણ આપમેળે પાયથોન ઇન્ટરપ્રીટર ક્યાં શોધવું તે જાણે છે તેની ખાતરી કરવા માટે, તમારે /root/.bashrc ફાઇલને સંપાદિત કરવી આવશ્યક છે.


Open the /root/.bashrc file, and at the bottom of the file add the following line: export PATH=/usr/local/Python25/:$PATH

/root/.bashrc ફાઇલ ખોલો, અને ફાઇલના તળિયે નીચેની લાઇન ઉમેરો: નિકાસ PATH=/usr/local/Python25/:$PATH


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

જો તમે લૉગ આઉટ થાઓ અને રૂટ તરીકે પાછા લૉગ ઇન કરો, તો જ્યારે તમે તમારી કમાન્ડ શેલમાં કોઈપણ સમયે પાયથોન ટાઈપ કરશો, ત્યારે તમને પાયથોન ઇન્ટરપ્રીટર દ્વારા પ્રોમ્પ્ટ કરવામાં આવશે.


Now that you have a fully operational Python interpreter on both Windows and Linux, it’s time to set up your integrated development environment (IDE).

હવે તમારી પાસે વિન્ડોઝ અને લિનક્સ બંને પર સંપૂર્ણ રીતે કાર્યરત પાયથોન ઇન્ટરપ્રીટર છે, તે તમારા સંકલિત વિકાસ પર્યાવરણ (IDE) ને સેટ કરવાનો સમય છે.


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

પાયથોન એપ્લિકેશન્સને ઝડપથી વિકસાવવા અને ડિબગ કરવા માટે, એક નક્કર IDE નો ઉપયોગ કરવો એકદમ જરૂરી છે.


The coupling of the popular Eclipse develop- ment environment and a module called PyDev gives you a tremendous number of powerful features at your fingertips that most other IDEs don’t offer.

લોકપ્રિય Eclipse ડેવલપમેન્ટ એન્વાયર્નમેન્ટ અને PyDev નામના એક મોડ્યુલનું જોડાણ તમને તમારી આંગળીના વેઢે અસંખ્ય શક્તિશાળી સુવિધાઓ આપે છે જે મોટાભાગના અન્ય IDE ઓફર કરતા નથી.


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

વધુમાં, Eclipse વિન્ડોઝ, લિનક્સ અને મેક પર ચાલે છે અને તેમાં ઉત્તમ સમુદાય સપોર્ટ છે.


Let’s quickly run through how to set up and configure Eclipse and PyDev:

ચાલો ઝડપથી જોઈએ કે Eclipse અને PyDev ને કેવી રીતે સેટઅપ અને ગોઠવવા:


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

http://www.eclipse.org/downloads/ પરથી Eclipse ક્લાસિક પેકેજ ડાઉનલોડ કરો.


તેને C:\ Eclipse પર અનઝિપ કરો.


The first time it starts, it will ask where to store your workspace; you can accept the default and check the box Use this as default and do not ask again. Click OK.

પ્રથમ વખત તે શરૂ થાય છે, તે પૂછશે કે તમારા વર્કસ્પેસને ક્યાં સંગ્રહિત કરવું; તમે ડિફોલ્ટ સ્વીકારી શકો છો અને આને ડિફોલ્ટ તરીકે ઉપયોગ કરો અને ફરીથી પૂછશો નહીં તે બોક્સને ચેક કરી શકો છો. ઓકે પર ક્લિક કરો.


Once Eclipse has fired up, choose Help 0 Software Updates0Find and Install.

એકવાર Eclipse શરૂ થઈ જાય, પછી Help 0 Software Updates0Find and Install પસંદ કરો.


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

ઇન્સ્ટોલ કરવા માટે નવી સુવિધાઓ શોધો લેબલવાળા રેડિયો બટનને પસંદ કરો અને નેક્સ્ટ પર ક્લિક કરો.


In the Name field enter a descriptive string like PyDev Update. Make sure the URL field contains http://pydev.sourceforge.net/updates/ and click OK.

નામ ફીલ્ડમાં PyDev અપડેટ જેવી વર્ણનાત્મક સ્ટ્રિંગ દાખલ કરો. ખાતરી કરો કે URL ફીલ્ડમાં http://pydev.sourceforge.net/updates/ છે અને OK પર ક્લિક કરો.


Then click Finish, which will kick in the Eclipse updater.

પછી સમાપ્ત કરો પર ક્લિક કરો, જે Eclipse અપડેટરને શરૂ કરશે.


The updates dialog will appear after a few moments. When it does, expand the top item, PyDev Update, and check the PyDev item. Click Next to continue.

થોડી ક્ષણો પછી અપડેટ્સ ડાયલોગ દેખાશે. જ્યારે તે થાય, ત્યારે ટોચની આઇટમ, PyDev અપડેટ, વિસ્તૃત કરો અને PyDev આઇટમને ચેક કરો. ચાલુ રાખવા માટે આગળ ક્લિક કરો.


Then read and accept the license agreement for PyDev. If you agree to its terms, then select the radio button I accept the terms in the license agreement.

પછી PyDev માટે લાયસન્સ કરાર વાંચો અને સ્વીકારો. જો તમે તેની શરતો સાથે સહમત થાઓ, તો રેડિયો બટન પસંદ કરો હું લાયસન્સ કરારની શરતો સ્વીકારું છું.


થ્રેડ ID: 3148 ઇવેન્ટ કોડ: 6


એક્સેપ્શન એડ્રેસ: 0x7c901230


પ્રથમ બ્રેકપોઇન્ટને હિટ કરો.


After the break- point is handled, the process should resume its loop.

બ્રેક-પોઇન્ટ સંભાળ્યા પછી, પ્રક્રિયાએ તેના લૂપને ફરી શરૂ કરવું જોઈએ.


Our debugger now supports soft breakpoints, so let’s move on to hardware breakpoints.

અમારું ડિબગર હવે સોફ્ટ બ્રેકપોઇન્ટને સપોર્ટ કરે છે, તેથી ચાલો હાર્ડવેર બ્રેકપોઇન્ટ્સ તરફ આગળ વધીએ.


The second type of breakpoint is the hardware breakpoint, which involves setting certain bits in the CPU’s debug registers.

બીજા પ્રકારનું બ્રેકપોઇન્ટ એ હાર્ડવેર બ્રેકપોઇન્ટ છે, જેમાં CPU ના ડિબગ રજિસ્ટરમાં ચોક્કસ બીટ્સ સેટ કરવાનો સમાવેશ થાય છે.


We have to ensure that we are always using a slot that is empty, or we can run into problems where breakpoints aren’t being hit where we expect them to.

આપણે એ સુનિશ્ચિત કરવું પડશે કે આપણે હંમેશા એવા સ્લોટનો ઉપયોગ કરી રહ્યા છીએ જે ખાલી છે, અથવા આપણે એવી સમસ્યાઓમાં આવી શકીએ છીએ જ્યાં બ્રેકપોઇન્ટ્સ ત્યાં હિટ થતા નથી જ્યાં આપણે તેની અપેક્ષા રાખીએ છીએ.


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

ચાલો પ્રક્રિયામાંના તમામ થ્રેડોની ગણતરી કરીને શરૂઆત કરીએ અને તેમાંથી દરેક માટે CPU સંદર્ભ રેકોર્ડ મેળવીએ.


Using the retrieved context record, we then modify one of the registers between DR0 and DR3 (depending on which are free) to contain the desired breakpoint address.

મેળવેલા સંદર્ભ રેકોર્ડનો ઉપયોગ કરીને, અમે પછી DR0 અને DR3 વચ્ચેના રજિસ્ટરમાંના એકને (જે મફત છે તેના આધારે) ઇચ્છિત બ્રેકપોઇન્ટ સરનામું સમાવવા માટે સુધારીએ છીએ.


We then flip the appro- priate bits in the DR7 register to enable the breakpoint and set its type and length.

પછી અમે બ્રેકપોઇન્ટને સક્ષમ કરવા અને તેનો પ્રકાર અને લંબાઈ સેટ કરવા માટે DR7 રજિસ્ટરમાં યોગ્ય બીટ્સ ફ્લિપ કરીએ છીએ.


Once we have created the routine to set the breakpoint, we need to modify our main debug event loop so that it can appropriately handle the exception that is thrown by a hardware breakpoint.

એકવાર અમે બ્રેકપોઇન્ટ સેટ કરવાની રૂટિન બનાવી લીધી છે, પછી આપણે અમારા મુખ્ય ડિબગ ઇવેન્ટ લૂપને સંશોધિત કરવાની જરૂર છે જેથી તે હાર્ડવેર બ્રેકપોઇન્ટ દ્વારા ફેંકવામાં આવેલા અપવાદને યોગ્ય રીતે હેન્ડલ કરી શકે.


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

આપણે જાણીએ છીએ કે હાર્ડવેર બ્રેકપોઇન્ટ INT1 (અથવા સિંગલ-સ્ટેપ ઇવેન્ટ) ને ટ્રિગર કરે છે, તેથી અમે ફક્ત અમારા ડિબગ લૂપમાં બીજો અપવાદ હેન્ડલર ઉમેરીએ છીએ.


Let’s start with setting the breakpoint.

ચાલો બ્રેકપોઇન્ટ સેટ કરીને શરૂઆત કરીએ.


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

તમે જોઈ શકો છો કે અમે ગ્લોબલ hardware_breakpoints શબ્દકોશને તપાસીને બ્રેકપોઇન્ટ સંગ્રહિત કરવા માટે એક ખુલ્લો સ્લોટ પસંદ કરીએ છીએ.


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

હવે અમારી પાસે બ્રેકપોઇન્ટ સેટ કરવાને સમર્થન આપવાની પદ્ધતિ છે, ચાલો અમારા ઇવેન્ટ લૂપને અપડેટ કરીએ અને INT1 વિક્ષેપને સમર્થન આપવા માટે એક અપવાદ હેન્ડલર ઉમેરીએ.


If the debugger detects that there is a hardware breakpoint at the exception address, it zeros out the flags in DR7 and resets the debug register that contains the breakpoint address.

જો ડિબગર શોધી કાઢે છે કે અપવાદ સરનામાં પર હાર્ડવેર બ્રેકપોઇન્ટ છે, તો તે DR7 માંના ફ્લેગ્સને શૂન્ય કરે છે અને ડિબગ રજિસ્ટરને ફરીથી સેટ કરે છે જેમાં બ્રેકપોઇન્ટ સરનામું છે.


Let’s see this process in action by modifying our my_test.py script to use hardware breakpoints on our printf() call.

ચાલો અમારી my_test.py સ્ક્રિપ્ટને સંશોધિત કરીને આ પ્રક્રિયાને ક્રિયામાં જોઈએ કે જેથી અમારા printf() કૉલ પર હાર્ડવેર બ્રેકપોઇન્ટનો ઉપયોગ કરી શકાય.


This harness simply sets a breakpoint on the printf() call whenever it gets executed.

આ હાર્નેસ ફક્ત printf() કૉલ પર બ્રેકપોઇન્ટ સેટ કરે છે જ્યારે પણ તે એક્ઝિક્યુટ થાય છે.


The length of the breakpoint is only a single byte.

બ્રેકપોઇન્ટની લંબાઈ માત્ર એક જ બાઇટ છે.


You will notice that in this harness we imported the my_debugger_defines.py file; this is so we can access the HW_EXECUTE constant, which provides a little code clarity.

તમે જોશો કે આ હાર્નેસમાં અમે my_debugger_defines.py ફાઇલ આયાત કરી છે; આથી અમે HW_EXECUTE અચલને ઍક્સેસ કરી શકીએ છીએ, જે થોડી કોડ સ્પષ્ટતા પ્રદાન કરે છે.


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 first parameter is a pointer to the DEBUG_EVENT struct; this structure describes a debugging event.

પ્રથમ પરિમાણ DEBUG_EVENT સ્ટ્રક્ચરનો પોઇન્ટર છે; આ માળખું ડીબગીંગ ઇવેન્ટનું વર્ણન કરે છે.


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

ડીબગર જે દરેક ઇવેન્ટને પકડે છે, ત્યાં સંકળાયેલા ઇવેન્ટ હેન્ડલર્સ છે જે પ્રક્રિયા ચાલુ રાખવા દેતા પહેલા અમુક પ્રકારની ક્રિયા કરે છે.


The 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 સ્ટ્રક્ચરમાંના ક્ષેત્રો છે, જે જ્યારે ડીબગર ડીબગીંગ ઇવેન્ટને પકડે છે ત્યારે શરૂ થાય છે.


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

માત્ર એક જ વસ્તુ કરવાની બાકી છે તે પ્રક્રિયામાંથી ડિટેચ થવાનું છે.


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

ચાલો આ બધાને એકસાથે મૂકીએ અને અમારી my_debugger વર્ગને તેને પ્રક્રિયા સાથે જોડવા અને તેમાંથી ડિટેચ થવાની ક્ષમતા આપીને વિસ્તૃત કરીએ.


Download this file now and overwrite your current copy.

હવે આ ફાઇલ ડાઉનલોડ કરો અને તમારી વર્તમાન નકલને ઓવરરાઇટ કરો.


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

આપણે સ્ટ્રક્ચર્સ, યુનિયન્સ અને અચલોની રચનાને વધુ આવરીશું નહીં, કારણ કે તમારે હવે તેમની સાથે ઘનિષ્ઠ રીતે પરિચિત થવું જોઈએ.


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

હવે જ્યારે આપણે પ્રોસેસ હેન્ડલ મેળવવા, ડીબગ કરેલી પ્રક્રિયા બનાવવા અને ચાલતી પ્રક્રિયા સાથે જોડવાના મૂળભૂત સિદ્ધાંતો સમજાવ્યા છે, ત્યારે અમે વધુ અદ્યતન સુવિધાઓમાં ડૂબકી મારવા માટે તૈયાર છીએ જે અમારા ડીબગરને સપોર્ટ કરશે.


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

ડીબગર કોઈપણ આપેલા સમયે અને સમયે CPU રજિસ્ટરની સ્થિતિને કેપ્ચર કરવામાં સક્ષમ હોવો જોઈએ.


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

સૌ પ્રથમ, આપણે ડીબગીમાં હાલમાં ચાલતા થ્રેડનું હેન્ડલ મેળવવું આવશ્યક છે, જે OpenThread() ફંક્શનનો ઉપયોગ કરીને પ્રાપ્ત થાય છે.


We must obtain a list of all the threads that are executing inside the process, select the thread we want, and obtain a valid handle to it using OpenThread().

આપણે તે બધા થ્રેડોની સૂચિ મેળવવી આવશ્યક છે જે પ્રક્રિયાની અંદર ચાલી રહ્યા છે, અમને જોઈતો થ્રેડ પસંદ કરો અને OpenThread() નો ઉપયોગ કરીને તેનું માન્ય હેન્ડલ મેળવો.


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

પ્રક્રિયામાંથી રજિસ્ટરની સ્થિતિ મેળવવા માટે, આપણે પ્રક્રિયાની અંદર ચાલી રહેલા તમામ થ્રેડોને ગણવામાં સક્ષમ હોવા જોઈએ.


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

થ્રેડો એ છે જે ખરેખર પ્રક્રિયામાં ચાલી રહ્યા છે; ભલે એપ્લિકેશન મલ્ટિથ્રેડેડ ન હોય, તેમાં હજી પણ ઓછામાં ઓછો એક થ્રેડ, મુખ્ય થ્રેડ છે.


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

આપણે CreateToolhelp32Snapshot() નામનું ખૂબ જ શક્તિશાળી ફંક્શન વાપરીને થ્રેડોને ગણી શકીએ છીએ, જે kernel32.dll માંથી નિકાસ કરવામાં આવે છે.


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

dwFlags પરિમાણ ફંક્શનને સૂચવે છે કે તેણે કયા પ્રકારની માહિતી એકત્રિત કરવાની છે (થ્રેડો, પ્રક્રિયાઓ, મોડ્યુલો અથવા હીપ્સ).


When CreateToolhelp32Snapshot() is successful, it returns a handle to the snapshot object, which we use in subsequent calls to gather further information.

જ્યારે CreateToolhelp32Snapshot() સફળ થાય છે, ત્યારે તે સ્નેપશોટ ઑબ્જેક્ટનું હેન્ડલ પરત કરે છે, જેનો ઉપયોગ આપણે વધુ માહિતી એકત્રિત કરવા માટે પછીની કૉલ્સમાં કરીએ છીએ.


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

એકવાર અમારી પાસે સ્નેપશોટમાંથી થ્રેડોની સૂચિ આવી જાય, પછી અમે તેમને ગણવાનું શરૂ કરી શકીએ છીએ.


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

અમારી લક્ષ્ય પ્રક્રિયાની અંદરના તમામ થ્રેડોને નિર્ધારિત કરવા માટે, અમે દરેક th32OwnerProcessID મૂલ્યની સરખામણી તે પ્રક્રિયાના PID સાથે કરીશું જે આપણે બનાવી છે અથવા તેની સાથે જોડાયેલા છીએ.


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 exploit code needs to land us at 0x7C91D3F8 to disable DEP.

DEP ને અક્ષમ કરવા માટે એક્સપ્લોઇટ કોડને 0x7C91D3F8 પર ઉતરવાની જરૂર છે.


Immunity Debugger has a wizard to find these addresses.

ઇમ્યુનિટી ડિબગર પાસે આ સરનામાં શોધવા માટે એક વિઝાર્ડ છે.


The script outputs the results to the Log window.

સ્ક્રિપ્ટ લોગ વિન્ડોમાં પરિણામો આઉટપુટ કરે છે.


Malware employs anti-debugging routines to prevent analysis.

માલવેર વિશ્લેષણને રોકવા માટે એન્ટિ-ડીબગીંગ રૂટિનનો ઉપયોગ કરે છે.


IsDebuggerPresent is a common anti-debugging technique.

IsDebuggerPresent એક સામાન્ય એન્ટિ-ડીબગીંગ તકનીક છે.


This code zeros out the BeingDebugged flag.

આ કોડ BeingDebugged ફ્લેગને શૂન્ય બનાવે છે.


Malware attempts to iterate through running processes.

માલવેર ચાલી રહેલી પ્રક્રિયાઓ દ્વારા પુનરાવર્તન કરવાનો પ્રયાસ કરે છે.


We can patch these functions to return false.

આપણે આ કાર્યોને ખોટું પાછા આપવા માટે પેચ કરી શકીએ છીએ.


Hooking is a powerful process-observation technique.

હૂકીંગ એ એક શક્તિશાળી પ્રક્રિયા-નિરીક્ષણ તકનીક છે.


સોફ્ટ હૂક એક્ઝેક્યુશન ફ્લોને અટકાવે છે.


હાર્ડ હૂક x86 એસેમ્બલીમાં લખાયેલા છે.


We will sniff encrypted traffic at the application layer.

આપણે એપ્લિકેશન લેયર પર એન્ક્રિપ્ટેડ ટ્રાફિકને સૂંઘીશું.


ફાયરફોક્સ SSL એન્ક્રિપ્શન કરે છે.


The hook point is on the function PR_Write.

હૂક પોઇન્ટ PR_Write ફંક્શન પર છે.


We can see the username and password quite clearly.

આપણે વપરાશકર્તાનામ અને પાસવર્ડ સ્પષ્ટપણે જોઈ શકીએ છીએ.


Define a hook container to hold your hook objects.

તમારા હૂક ઑબ્જેક્ટ્સને પકડી રાખવા માટે એક હૂક કન્ટેનરને વ્યાખ્યાયિત કરો.


The entry hooks are useful to see what parameters get passed.

એન્ટ્રી હૂક એ જોવા માટે ઉપયોગી છે કે કયા પરિમાણો પસાર થાય છે.


The exit hooks are useful for trapping function return values.

એક્ઝિટ હૂક ફંક્શન રીટર્ન મૂલ્યોને ફસાવવા માટે ઉપયોગી છે.


કોડ PR_Write પર હૂક સેટ કરે છે.


Hard hooking has far less impact on the target process.

હાર્ડ હૂકીંગની લક્ષ્ય પ્રક્રિયા પર ઓછી અસર પડે છે.


The file fuzzer selects a file randomly from the examples directory.

ફાઇલ ફઝર ઉદાહરણોની ડિરેક્ટરીમાંથી રેન્ડમલી એક ફાઇલ પસંદ કરે છે.


It then copies the selected file to a test file with the specified extension.

પછી તે પસંદ કરેલી ફાઇલને નિર્દિષ્ટ એક્સ્ટેંશન સાથેની એક પરીક્ષણ ફાઇલમાં કૉપિ કરે છે.


The class skeleton defines global variables for tracking test iterations and test cases.

વર્ગનું માળખું પરીક્ષણ પુનરાવર્તનો અને પરીક્ષણ કેસોને ટ્રેક કરવા માટે વૈશ્વિક ચલોને વ્યાખ્યાયિત કરે છે.


The file_picker function lists files in a directory and randomly picks one for mutation.

file_picker ફંક્શન એક ડિરેક્ટરીમાં ફાઇલોની યાદી બનાવે છે અને પરિવર્તન માટે રેન્ડમલી એક પસંદ કરે છે.


We need to get the target application loaded, track crashes, and terminate it when done.

આપણે લક્ષ્ય એપ્લિકેશનને લોડ કરવાની, ક્રેશને ટ્રેક કરવાની અને થઈ જાય ત્યારે તેને સમાપ્ત કરવાની જરૂર છે.


The first step is to load the target application inside a debugger thread.

પ્રથમ પગલું એ છે કે ડિબગર થ્રેડની અંદર લક્ષ્ય એપ્લિકેશન લોડ કરવી.


We then spawn a second thread to monitor the debugger thread.

પછી અમે ડિબગર થ્રેડનું નિરીક્ષણ કરવા માટે બીજો થ્રેડ શરૂ કરીએ છીએ.


The monitor thread kills the debugger thread after a reasonable amount of time.

મોનિટર થ્રેડ વાજબી સમય પછી ડિબગર થ્રેડને મારી નાખે છે.


We'll also include an email notification routine.

અમે ઇમેઇલ સૂચના રૂટિનનો પણ સમાવેશ કરીશું.


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

ફઝ ફંક્શન તપાસે છે કે શું ફઝિંગ પુનરાવર્તન પહેલેથી ચાલી રહ્યું છે.


Once a document is selected, it's passed to the mutation function.

એકવાર દસ્તાવેજ પસંદ થઈ જાય, તે પરિવર્તન કાર્યને સોંપવામાં આવે છે.


The debugger thread starts the application with the mutated document.

ડિબગર થ્રેડ પરિવર્તિત દસ્તાવેજ સાથે એપ્લિકેશન શરૂ કરે છે.


The monitoring thread ensures the application is killed after a set time.

મોનિટરિંગ થ્રેડ ખાતરી કરે છે કે નિર્ધારિત સમય પછી એપ્લિકેશનને મારી નાખવામાં આવે છે.


The mutate_file function reads 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 the executable path and extension.

ફઝર એક્ઝિક્યુટેબલ પાથ અને એક્સ્ટેંશન માટે કમાન્ડ-લાઇન વિકલ્પોનો ઉપયોગ કરે છે.


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

-e ફ્લેગ લક્ષ્ય એપ્લિકેશનના એક્ઝિક્યુટેબલનો પાથ સ્પષ્ટ કરે છે.


The -x option is the filename extension we are testing.

-x વિકલ્પ એ ફાઇલનામ એક્સ્ટેંશન છે જેનું અમે પરીક્ષણ કરી રહ્યા છીએ.


The -n parameter enables or disables notifications.

-n પરિમાણ સૂચનાઓને સક્ષમ અથવા અક્ષમ કરે છે.


Code coverage measures how much code is executed during testing.

કોડ કવરેજ પરીક્ષણ દરમિયાન કેટલો કોડ ચલાવવામાં આવે છે તે માપે છે.


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

વિશેષ સાધનો વગર, કમ્પ્યુટર વપરાશકર્તા ADSs ની સામગ્રી જોઈ શકતો નથી, જે આપણા માટે આદર્શ છે.


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

વધુમાં, ઘણા સુરક્ષા ઉત્પાદનો વૈકલ્પિક ડેટા સ્ટ્રીમને યોગ્ય રીતે સ્કેન કરતા નથી, તેથી અમારી પાસે તેમના રડારની નીચે સરકીને શોધ ટાળવાની સારી તક છે.


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

ફાઇલ પર વૈકલ્પિક ડેટા સ્ટ્રીમનો ઉપયોગ કરવા માટે, આપણે હાલની ફાઇલમાં કોલોન અને ફાઇલનામને જોડવા સિવાય બીજું કંઈ કરવાની જરૂર નથી, જેમ કે: reverser.exe:vncdll.dll


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

આ કિસ્સામાં અમે vncdll.dll ને ઍક્સેસ કરી રહ્યા છીએ, જે reverser.exe સાથે જોડાયેલ વૈકલ્પિક ડેટા સ્ટ્રીમમાં સંગ્રહિત છે.


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

ચાલો એક ઝડપી ઉપયોગિતા સ્ક્રિપ્ટ લખીએ જે ફક્ત ફાઇલ વાંચે છે અને તેને આપણી પસંદગીની ફાઇલ સાથે જોડાયેલ ADS પર લખે છે.


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

file_hider.py નામની વધારાની Python સ્ક્રિપ્ટ ખોલો અને નીચેનો કોડ દાખલ કરો.


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

પ્રથમ કમાન્ડ-લાઇન આર્ગ્યુમેન્ટ એ DLL છે જેને આપણે વાંચવા માંગીએ છીએ, અને બીજો આર્ગ્યુમેન્ટ એ લક્ષ્ય ફાઇલ છે જેમાં આપણે DLL સંગ્રહિત કરીશું.


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

આ નાની ઉપયોગિતાનો ઉપયોગ આપણે એક્ઝેક્યુટેબલની સાથે કોઈપણ પ્રકારની ફાઇલોને સંગ્રહિત કરવા માટે કરી શકીએ છીએ, અને અમે ADS માંથી સીધા જ DLL ને પણ ઇન્જેક્ટ કરી શકીએ છીએ.


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

જોકે અમે અમારા બેક-ડોર માટે DLL ઇન્જેક્શનનો ઉપયોગ કરીશું નહીં, તે હજી પણ તેને સપોર્ટ કરશે, તેથી આગળ વાંચો.


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

ચાલો અમારા એક્ઝેક્યુશન રીડાયરેક્શન કોડ બનાવીને શરૂઆત કરીએ, જે ખૂબ જ સરળ રીતે આપણી પસંદગીની એપ્લિકેશન શરૂ કરે છે.


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

તેને એક્ઝેક્યુશન રીડાયરેક્શન કહેવાનું કારણ એ છે કે અમે અમારા બેકડોરને calc.exe નામ આપીશું અને મૂળ calc.exe ને અલગ જગ્યાએ ખસેડીશું.


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

જ્યારે વપરાશકર્તા કેલ્ક્યુલેટરનો ઉપયોગ કરવાનો પ્રયાસ કરે છે, ત્યારે તે અજાણતામાં અમારું બેકડોર ચલાવશે, જે બદલામાં યોગ્ય કેલ્ક્યુલેટર શરૂ કરશે અને આમ વપરાશકર્તાને ચેતવણી આપશે નહીં કે કંઈપણ ખોટું છે.


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

ધ્યાન રાખો કે અમે પ્રકરણ 3 માંથી my_debugger_defines.py ફાઇલનો સમાવેશ કરી રહ્યા છીએ, જેમાં પ્રક્રિયા બનાવવા માટે જરૂરી તમામ અચળાંકો અને સ્ટ્રક્ચર્સ છે.


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

નવી Python ફાઇલ ખોલો, તેને backdoor.py નામ આપો અને નીચેનો કોડ દાખલ કરો.


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

ખૂબ જટિલ નથી, અને તેમાં કોઈ નવો કોડ નથી.


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

DLL ઇન્જેક્શન કોડમાં આગળ વધતા પહેલા, અમે અન્વેષણ કરીશું કે આપણે ઇન્જેક્શન માટે તેનો ઉપયોગ કરતા પહેલા DLL ને કેવી રીતે છુપાવી શકીએ.


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

ચાલો અમારા ઇન્જેક્શન કોડને બેકડોરમાં ઉમેરીએ; તેને પ્રક્રિયા-નિર્માણ વિભાગ પછી જ જોડો.


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

અમારું ઇન્જેક્શન ફંક્શન કોડ અથવા DLL ઇન્જેક્શનને પણ હેન્ડલ કરી શકશે; ફક્ત પેરામીટર ફ્લેગને 1 પર સેટ કરો, અને ડેટા ચલ પછી DLL નો પાથ સમાવશે.


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

હવે અમારી પાસે એક સપોર્ટેડ ઇન્જેક્શન ફંક્શન છે જે કોડ અને DLL ઇન્જેક્શન બંનેને હેન્ડલ કરી શકે છે.


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 પ્રક્રિયામાં શેલકોડના બે અલગ-અલગ ટુકડાઓ ઇન્જેક્ટ કરવાનો સમય છે, એક અમને રિવર્સ શેલ આપવા માટે અને બીજો અમારી વિચલિત પ્રક્રિયાને મારવા માટે.


In order to retrieve the results of your hook, you must query this page using the wrapper function getAllLog().

તમારા હૂકના પરિણામો મેળવવા માટે, તમારે રેપર ફંક્શન getAllLog() નો ઉપયોગ કરીને આ પૃષ્ઠને ક્વેરી કરવું આવશ્યક છે.


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

હાર્ડ હૂકની શક્તિનો ઉપયોગ કરવાનું ઉત્તમ ઉદાહરણ હિપ્પી PyCommand છે.


If you’re targeting Internet Explorer, which is a much more heap-intensive process, 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 that are critical to understand when writing heap-based exploits.

આપણે હીપ-આધારિત શોષણ લખતી વખતે સમજવા માટે નિર્ણાયક એવા હીપ રૂટિનને કેવી રીતે ઇન્સ્ટ્રુમેન્ટ કરવું તેનું ઉદાહરણ તરીકે હિપ્પીનો ઉપયોગ કરી શકીએ છીએ.


So for RtlFreeHeap we are going to trap all three arguments, and for RtlAllocateHeap we are going to take the three arguments plus the pointer that is returned.

તેથી RtlFreeHeap માટે, અમે ત્રણેય દલીલોને ટ્રેપ કરીશું, અને RtlAllocateHeap માટે, અમે ત્રણ દલીલો તેમજ પરત કરેલ પોઇન્ટર લઈશું.


Now that we have an understanding of the hook points, open up a new Python file, name it hippie_easy.py, and hit up the following code.

હવે અમારી પાસે હૂક પોઈન્ટ્સની સમજણ છે, એક નવી Python ફાઇલ ખોલો, તેને hippie_easy.py નામ આપો અને નીચેનો કોડ લખો.


The next bit of code is a simple check as to whether we already have the hooks set; this just means we are requesting the results.

કોડનો આગલો ભાગ એ એક સરળ તપાસ છે કે શું અમારી પાસે પહેલેથી જ હૂક સેટ છે; આનો અર્થ એ છે કે અમે પરિણામોની વિનંતી કરી રહ્યા છીએ.


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 કૉલ માટે, અમે સ્ટેકમાંથી ત્રણ દલીલો અને ફંક્શન કૉલમાંથી રીટર્ન વેલ્યુને ટ્રેપ કરી રહ્યા છીએ.


In less than 100 lines of code we have employed an extremely powerful hooking technique— and without using a compiler or any additional tools.

100 થી ઓછા કોડની લાઇનમાં, અમે અત્યંત શક્તિશાળી હૂકિંગ તકનીકનો ઉપયોગ કર્યો છે—અને કમ્પાઇલર અથવા કોઈપણ વધારાના સાધનોનો ઉપયોગ કર્યા વિના.


We not only have demonstrated how to apply some powerful hooking techniques, but we also have automated them.

અમે માત્ર કેટલીક શક્તિશાળી હૂકિંગ તકનીકોને કેવી રીતે લાગુ કરવી તે દર્શાવ્યું નથી, પરંતુ અમે તેને સ્વચાલિત પણ કરી દીધી છે.


At times when you are reversing or attacking a target, it is useful for you to be able to load code into a remote process and have it execute within that process’s context.

કેટલીકવાર જ્યારે તમે લક્ષ્યને રિવર્સ કરી રહ્યાં હોવ અથવા તેના પર હુમલો કરી રહ્યાં હોવ, ત્યારે તમારા માટે કોડને રિમોટ પ્રક્રિયામાં લોડ કરવામાં અને તેને તે પ્રક્રિયાના સંદર્ભમાં ચલાવવામાં સક્ષમ થવું ઉપયોગી છે.


Whether you’re stealing password hashes or gaining remote desktop control of a target system, DLL and code injection have powerful applications.

પછી ભલે તમે પાસવર્ડ હેશ ચોરી રહ્યા હોવ અથવા લક્ષ્ય સિસ્ટમનું રિમોટ ડેસ્કટોપ નિયંત્રણ મેળવી રહ્યા હોવ, DLL અને કોડ ઇન્જેક્શનમાં શક્તિશાળી એપ્લિકેશન્સ છે.


We will use DLL injection to launch a pop-up window within another process, and we’ll use code injection to test a piece of shell- code designed to kill a process based on its PID.

અમે બીજી પ્રક્રિયામાં એક પોપ-અપ વિન્ડો લોન્ચ કરવા માટે DLL ઇન્જેક્શનનો ઉપયોગ કરીશું, અને અમે તેના PIDના આધારે પ્રક્રિયાને મારવા માટે રચાયેલ શેલ-કોડના ટુકડાને ચકાસવા માટે કોડ ઇન્જેક્શનનો ઉપયોગ કરીશું.


There are some primary differences between DLL injection and code injection; however, they are both achieved in the same manner: remote thread creation.

DLL ઇન્જેક્શન અને કોડ ઇન્જેક્શન વચ્ચે કેટલાક પ્રાથમિક તફાવતો છે; જો કે, તે બંને સમાન રીતે પ્રાપ્ત થાય છે: રિમોટ થ્રેડ બનાવટ.


The first parameter, hProcess, should look familiar; it’s a handle to the process in which we are starting the thread.

પ્રથમ પરિમાણ, hProcess, પરિચિત લાગવું જોઈએ; તે તે પ્રક્રિયાનું હેન્ડલ છે જેમાં અમે થ્રેડ શરૂ કરી રહ્યા છીએ.


The lpParameter parameter is nearly as important as the start address.

lpParameter પરિમાણ શરૂઆતના સરનામા જેટલું જ મહત્વપૂર્ણ છે.


DLL injection has been used for both good and evil for quite some time.

DLL ઇન્જેક્શનનો ઉપયોગ ઘણા સમયથી સારા અને ખરાબ બંને માટે કરવામાં આવે છે.


We need to get the remote process to call LoadLibraryA with a pointer to a string value that is the path to the DLL we wish to load.

આપણે રિમોટ પ્રક્રિયાને LoadLibraryA ને સ્ટ્રિંગ મૂલ્યના પોઇન્ટર સાથે કૉલ કરવાની જરૂર છે જે DLLનો પાથ છે જેને આપણે લોડ કરવા માંગીએ છીએ.


Even though a pop-up dialog is slightly anticlimactic, it’s important to understand the technique.

જોકે પોપ-અપ ડાયલોગ થોડો અતિશયોક્તિપૂર્ણ છે, પરંતુ તકનીકને સમજવી મહત્વપૂર્ણ છે.


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 નો સંદર્ભ લો.


3 CWD <DIRECTORY> - change working directory to DIRECTORY

3 CWD <DIRECTORY> - કાર્યકારી ડિરેક્ટરીને DIRECTORY માં બદલો


DELE <FILENAME> - delete a remote file FILENAME

DELE <FILENAME> - દૂરસ્થ ફાઇલ FILENAME કાઢી નાખો


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

MDTM <FILENAME> - ફાઇલ FILENAME માટે છેલ્લો સુધારેલો સમય પરત કરો


MKD <DIRECTORY> - create directory DIRECTORY

MKD <DIRECTORY> - ડિરેક્ટરી DIRECTORY બનાવો


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

તે સંપૂર્ણ યાદીથી દૂર છે, પરંતુ તે અમને કેટલીક વધારાની કવરેજ આપે છે, તેથી ચાલો આપણે જે જાણીએ છીએ તે લઈએ અને તેને સુલી પ્રોટોકોલ વર્ણનમાં અનુવાદિત કરીએ.


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

અમે સુલીને એક પાતળી, સરેરાશ FTP સર્વર–બ્રેકિંગ મશીનમાં ફેરવવા માટે સુલી ડેટા પ્રિમિટિવ્સના અમારા જ્ઞાનનો ઉપયોગ કરીશું.


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

તમારા કોડ એડિટરને ગરમ કરો, ftp.py નામની નવી ફાઇલ બનાવો અને નીચેનો કોડ દાખલ કરો.


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

હવે પ્રોટોકોલ સ્કેલેટન બનાવવામાં આવ્યું છે, ચાલો સુલી સત્ર બનાવવાની તરફ આગળ વધીએ જે અમારી બધી વિનંતી માહિતીને એકસાથે બાંધશે તેમજ નેટવર્ક સ્નિફર અને ડિબગીંગ ક્લાયન્ટને સેટ કરશે.


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

સુલી સત્રો એ પદ્ધતિ છે જે વિનંતીઓને એકસાથે બાંધે છે અને નેટવર્ક પેકેટ કેપ્ચર, પ્રોસેસ ડિબગીંગ, ક્રેશ રિપોર્ટિંગ અને વર્ચ્યુઅલ મશીન નિયંત્રણનું ધ્યાન રાખે છે.


To begin, let’s define a sessions file and dissect the various parts.

શરૂ કરવા માટે, ચાલો સત્રો ફાઇલને વ્યાખ્યાયિત કરીએ અને વિવિધ ભાગોનું વિચ્છેદન કરીએ.


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

નવી Python ફાઇલ ખોલો, તેને ftp_session.py નામ આપો અને નીચેનો કોડ દાખલ કરો.


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

receive_ftp_banner() ફંક્શન જરૂરી છે કારણ કે દરેક FTP સર્વર પાસે એક બેનર હોય છે જે તે ક્લાયન્ટ કનેક્ટ થવા પર પ્રદર્શિત કરે છે.


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

આપણે આને sess.pre_send પ્રોપર્ટી સાથે જોડીએ છીએ, જે સુલીને કોઈપણ ફઝ ડેટા મોકલતા પહેલા FTP બેનર મેળવવા માટે કહે છે.


The pre_send property also passes in a valid Python socket object, so our function takes that as its only parameter.

pre_send પ્રોપર્ટી એક માન્ય Python સોકેટ ઑબ્જેક્ટ પણ પાસ કરે છે, તેથી અમારું ફંક્શન તેને તેના એકમાત્ર પરિમાણ તરીકે લે છે.


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 પર સાંભળી રહ્યું છે, જે પોર્ટ છે જેના પર તે સુલીના આદેશો સ્વીકારશે.


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 કોડ્સને શોધવા અને આ પરિણામોને પાયથોન અથાણાંમાં સાચવવા માટે ડ્રાઇવરલાઇબનો ઉપયોગ કરીશું.


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

માત્ર એક લક્ષ્ય ડ્રાઇવરને ઇમ્યુનિટી ડિબગરમાં લોડ કરો અને PyCommand ને આ રીતે ચલાવો: !ioctl_dump.


Now that we have our list of target device names and a set of supported IOCTL codes, let’s begin coding our simple fuzzer to use them!

હવે અમારી પાસે લક્ષ્ય ઉપકરણ નામોની સૂચિ અને સપોર્ટેડ IOCTL કોડ્સનો સમૂહ છે, ચાલો તેનો ઉપયોગ કરવા માટે અમારા સરળ ફઝરને કોડિંગ કરવાનું શરૂ કરીએ!


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

જો તમારું ફઝર તમે જે મશીન પર કામ કરી રહ્યા છો તેને ખરેખર ક્રેશ કરે છે, તો તે સ્પષ્ટ થઈ જશે કે કયા IOCTL કોડે તે કારણભૂત છે, કારણ કે તમારી લોગ ફાઇલ તમને છેલ્લો IOCTL કોડ બતાવશે જે સફળતાપૂર્વક ચલાવવામાં આવ્યો હતો.


Listing 11-1. Cross References to sprintf

સૂચિ 11-1. sprintf માટે ક્રોસ સંદર્ભો


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

સૂચિબદ્ધ તમામ સરનામાં એ સ્થાનો છે જ્યાં sprintf ફંક્શનને બોલાવવામાં આવી રહ્યું છે.


and 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 કૉલ રંગીન છે


160Chapter 11 11.3.2Function Code Coverage

પ્રકરણ 11 11.3.2 ફંક્શન કોડ કવરેજ


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 નો ઉપયોગ કરીશું.


Then we’ll run the IDA debugger and use a debugger hook to print out a notification every time a breakpoint gets hit.

પછી અમે IDA ડિબગર ચલાવીશું અને દરેક વખતે બ્રેકપોઇન્ટ હિટ થાય ત્યારે સૂચના છાપવા માટે ડિબગર હૂકનો ઉપયોગ કરીશું.


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

નવી Python ફાઇલ ખોલો, તેને func_coverage.py નામ આપો અને નીચેનો કોડ દાખલ કરો.


func_coverage.py from idaapi import * class FuncCoverage(DBG_Hooks): # Our breakpoint handler def dbg_bpt(self, tid, ea): print "[*] Hit: 0x%08x" % ea return # Add our function coverage debugger hook debugger = FuncCoverage() debugger.hook() current_addr = ScreenEA() # Find all functions and add breakpoints for function in Functions(SegStart( current_addr ), SegEnd( current_addr )): AddBpt( function ) SetBptAttr( function, BPTATTR_FLAGS, 0x0 ) num_breakpoints = GetBptQty() print "[*] Set %d breakpoints." % num_breakpoints

func_coverage.py idaapi માંથી * class FuncCoverage(DBG_Hooks): # અમારું બ્રેકપોઇન્ટ હેન્ડલર def dbg_bpt(self, tid, ea): print "[*] Hit: 0x%08x" % ea return # અમારા ફંક્શન કવરેજ ડિબગર હૂક ડિબગર = FuncCoverage() ડિબગર.હૂક() current_addr = ScreenEA() # બધા કાર્યો શોધો અને બ્રેકપોઇન્ટ ઉમેરો ફંક્શનમાં ફંક્શન(SegStart( current_addr ), SegEnd( current_addr )): AddBpt( function ) SetBptAttr( function, BPTATTR_FLAGS, 0x0 ) num_breakpoints = GetBptQty() print "[*] Set %d breakpoints." % num_breakpoints


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

સૌ પ્રથમ, અમે અમારું ડિબગર હૂક 0 સેટ કરીએ છીએ જેથી જ્યારે પણ ડિબગર ઇવેન્ટ ફેંકવામાં આવે ત્યારે તેને બોલાવવામાં આવે.


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

પછી અમે બધા ફંક્શન સરનામાંઓ 0 દ્વારા પુનરાવર્તન કરીએ છીએ અને દરેક સરનામાં 2 પર બ્રેકપોઇન્ટ સેટ કરીએ છીએ.


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 3.

પછી અમે સેટ કરેલા બ્રેકપોઇન્ટની કુલ સંખ્યા 3 છાપીએ છીએ.


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.

આ તમને કયા કાર્યો હિટ થાય છે અને કયા ક્રમમાં તે એક્ઝિક્યુટ થાય છે તેનો ખૂબ જ ઉચ્ચ-સ્તરનો દૃશ્ય આપવો જોઈએ.


IDAPython—Scripting IDA Pro161 11.3.3Calculating Stack Size

IDAPython—સ્ક્રીપ્ટિંગ IDA Pro161 11.3.3 સ્ટેક સાઈઝની ગણતરી


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

ક્યારેક સંભવિત નબળાઈઓ માટે બાઈનરીનું મૂલ્યાંકન કરતી વખતે, ચોક્કસ ફંક્શન કૉલ્સના સ્ટેક કદને સમજવું મહત્વપૂર્ણ છે.


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 then tell PyEmu to execute all 10 instructions contained within the function.

પછી અમે PyEmu ને ફંક્શનની અંદર સમાવિષ્ટ તમામ 10 સૂચનાઓ ચલાવવા માટે કહીએ છીએ.


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

છેલ્લું પગલું retn સૂચના હેન્ડલરનું કોડિંગ છે, તેથી અંતિમ સ્ક્રિપ્ટ નીચે મુજબ દેખાવી જોઈએ.


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

ret સૂચના હેન્ડલર ફક્ત સ્ટેક દલીલો અને EAX રજીસ્ટરનું મૂલ્ય મેળવે છે અને ફંક્શન કૉલનું પરિણામ આઉટપુટ કરે છે.


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

IDA માં વિવિધ બાઈનરી લોડ કરવાની પ્રેક્ટિસ કરો, એક રેન્ડમ ફંક્શન પસંદ કરો અને તેને કૉલ્સનું અનુકરણ કરવાનો પ્રયાસ કરો.


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

જ્યારે કોઈ ફંક્શનમાં ઘણા શાખાઓ, લૂપ્સ અને રીટર્ન પોઈન્ટ્સ સાથે સેંકડો અથવા હજારો સૂચનાઓ હોય ત્યારે આ તકનીક કેટલી શક્તિશાળી હોઈ શકે છે તે જોઈને તમે આશ્ચર્યચકિત થઈ જશો.


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

હવે ચાલો કોમ્પ્રેસ્ડ એક્ઝિક્યુટેબલને અનપેક કરવા માટે PEPyEmu લાઇબ્રેરીનો ઉપયોગ કરીએ.


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

એક્ઝિક્યુટેબલ પેકર્સ અથવા કોમ્પ્રેસર્સ ઘણા સમયથી અસ્તિત્વમાં છે.


Originally they were used to reduce the size of an executable so that it could fit on a 1.44MB floppy disk, but they have since grown to be a major part of code obfuscation for malware authors.

મૂળરૂપે તેનો ઉપયોગ એક્ઝિક્યુટેબલનું કદ ઘટાડવા માટે થતો હતો જેથી તે 1.44MB ફ્લોપી ડિસ્ક પર ફિટ થઈ શકે, પરંતુ ત્યારથી તે માલવેર લેખકો માટે કોડ અસ્પષ્ટતાનો એક મુખ્ય ભાગ બની ગયો છે.


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

એક લાક્ષણિક પેકર લક્ષ્ય બાઈનરીના કોડ અને ડેટા સેગમેન્ટ્સને સંકુચિત કરશે અને એન્ટ્રી પોઈન્ટને ડીકોમ્પ્રેસરથી બદલશે.


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

જ્યારે બાઈનરી ચલાવવામાં આવે છે, ત્યારે ડીકોમ્પ્રેસર ચાલે છે, જે મૂળ બાઈનરીને મેમરીમાં ડીકોમ્પ્રેસ કરે છે, અને પછી બાઈનરીના મૂળ એન્ટ્રી પોઈન્ટ (OEP) પર કૂદી જાય છે.


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

એકવાર OEP પર પહોંચ્યા પછી, બાઈનરી સામાન્ય રીતે ચલાવવાનું શરૂ કરે છે.


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

પેક્ડ એક્ઝિક્યુટેબલનો સામનો કરતી વખતે, રિવર્સરે અંદર સમાવિષ્ટ સાચા બાઈનરીનું અસરકારક રીતે વિશ્લેષણ કરવા માટે પ્રથમ પેકરથી છૂટકારો મેળવવો આવશ્યક છે.


We are going to use UPX to compress the calc.exe file that ships with all flavors of Windows, and then we’ll use a PyEmu script to unpack the execut- able and dump it to disk.

અમે વિન્ડોઝના તમામ ફ્લેવર્સ સાથે આવતી calc.exe ફાઇલને કોમ્પ્રેસ કરવા માટે UPX નો ઉપયોગ કરીશું, અને પછી અમે એક્ઝિક્યુટેબલને અનપેક કરવા અને તેને ડિસ્ક પર ડમ્પ કરવા માટે PyEmu સ્ક્રિપ્ટનો ઉપયોગ કરીશું.


Python is fast becoming the programming language of choice for hackers, reverse engineers, and software testers because it’s easy to write quickly, and it has the low-level support and libraries that make hackers happy.

પાયથોન ઝડપથી હેકર્સ, રિવર્સ એન્જિનિયર્સ અને સોફ્ટવેર ટેસ્ટર્સ માટે પસંદગીની પ્રોગ્રામિંગ ભાષા બની રહી છે, કારણ કે તે ઝડપથી લખવામાં સરળ છે, અને તેમાં નીચા-સ્તરનું સમર્થન અને લાઇબ્રેરીઓ છે જે હેકર્સને ખુશ કરે છે.


But until now, there has been no real manual on how to use Python for a variety of hacking tasks.

પરંતુ અત્યાર સુધી, વિવિધ હેકિંગ કાર્યો માટે પાયથોનનો ઉપયોગ કેવી રીતે કરવો તે અંગે કોઈ વાસ્તવિક માર્ગદર્શિકા નહોતી.


Gray Hat Python explains the concepts behind hacking tools and techniques like debuggers, trojans, fuzzers, and emulators.

ગ્રે હેટ પાયથોન ડિબગર્સ, ટ્રોજન, ફઝર્સ અને ઇમ્યુલેટર જેવા હેકિંગ ટૂલ્સ અને તકનીકો પાછળની વિભાવનાઓને સમજાવે છે.


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

તમે આ શીખશો: કંટાળાજનક રિવર્સિંગ અને સુરક્ષા કાર્યોને સ્વચાલિત કરો.


તમારું પોતાનું ડિબગર ડિઝાઇન કરો અને પ્રોગ્રામ કરો.


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

વિન્ડોઝ ડ્રાઇવરોને કેવી રીતે ફઝ કરવા અને શરૂઆતથી જ શક્તિશાળી ફઝર્સ કેવી રીતે બનાવવું તે જાણો.


Have fun with code and library injection, soft and hard hooking techniques, and other software trickery.

કોડ અને લાઇબ્રેરી ઇન્જેક્શન, સોફ્ટ અને હાર્ડ હૂકિંગ તકનીકો અને અન્ય સોફ્ટવેર યુક્તિઓ સાથે મજા કરો.


Sniff secure traffic out of an encrypted web browser session.

એન્ક્રિપ્ટેડ વેબ બ્રાઉઝર સત્રમાંથી સુરક્ષિત ટ્રાફિકને સ્નિફ કરો.


Use PyDBG, Immunity Debugger, Sulley, IDAPython, PyEMU, and more

PyDBG, Immunity Debugger, Sulley, IDAPython, PyEMU અને વધુનો ઉપયોગ કરો


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

વિશ્વના શ્રેષ્ઠ હેકર્સ તેમના કામ માટે પાયથોનનો ઉપયોગ કરી રહ્યા છે.


તમારે ન કરવું જોઈએ?


Justin seitz is a senior security researcher for immunity, inc., where he spends his time bug hunting, reverse engineering, writing exploits, and coding Python.

જસ્ટિન સીટ્ઝ એ ઇમ્યુનિટી, ઇન્ક. માટે એક વરિષ્ઠ સુરક્ષા સંશોધક છે, જ્યાં તે પોતાનો સમય બગ હન્ટિંગ, રિવર્સ એન્જિનિયરિંગ, એક્સપ્લોઇટ્સ લખવા અને પાયથોન કોડિંગમાં વિતાવે છે.


The Electronic Frontier Foundation (EFF)is the leading organization defending civil liberties in the digital world.

ઇલેક્ટ્રોનિક ફ્રન્ટિયર ફાઉન્ડેશન (EFF) એ ડિજિટલ વિશ્વમાં નાગરિક સ્વતંત્રતાનો બચાવ કરતી અગ્રણી સંસ્થા છે.


We defend free speech on the Internet, fight illegal surveillance, promote the rights of innovators to develop new digital technologies, and work to ensure that the rights and freedoms we enjoy are enhanced — rather than eroded — as our use of technology grows.

અમે ઇન્ટરનેટ પર મુક્ત ભાષણનો બચાવ કરીએ છીએ, ગેરકાયદેસર દેખરેખ સામે લડીએ છીએ, નવી ડિજિટલ તકનીકો વિકસાવવા માટે નવીનતાના અધિકારોને પ્રોત્સાહન આપીએ છીએ, અને ખાતરી કરીએ છીએ કે ટેક્નોલોજીનો આપણો ઉપયોગ વધે તેમ આપણે જે અધિકારો અને સ્વતંત્રતાઓનો આનંદ માણીએ છીએ તે વધુ સારા બને — તેના બદલે ઘસાઈ ન જાય.


EFF has sued telecom giant AT&T for giving the NSA unfettered access to the private communications of millions of their customers.

EFF એ ટેલિકોમ જાયન્ટ AT&T પર NSA ને તેમના લાખો ગ્રાહકોના ખાનગી સંદેશાવ્યવહારની અવરોધ વિના ઍક્સેસ આપવા બદલ દાવો માંડ્યો છે.


EFF’s Coders’ Rights Project is defending the rights of programmers and security researchers to publish their findings without fear of legal challenges.

EFFનું કોડર્સ રાઇટ્સ પ્રોજેક્ટ પ્રોગ્રામર્સ અને સુરક્ષા સંશોધકોના અધિકારોનો બચાવ કરી રહ્યું છે કે તેઓ કાયદાકીય પડકારોના ડર વિના તેમના તારણો પ્રકાશિત કરી શકે.


EFF's Patent Busting Project challenges overbroad patents that threaten technological innovation.

EFFનો પેટન્ટ બસ્ટિંગ પ્રોજેક્ટ વધુ પડતા પેટન્ટને પડકારે છે જે તકનીકી નવીનતાને જોખમમાં મૂકે છે.


EFF is fighting prohibitive standards that would take away your right to receive and use over-the-air television broadcasts any way you choose.

EFF પ્રતિબંધક ધોરણો સામે લડી રહી છે જે તમારી પસંદગીની કોઈપણ રીતે ઓવર-ધ-એર ટેલિવિઝન પ્રસારણ પ્રાપ્ત કરવા અને તેનો ઉપયોગ કરવાનો તમારો અધિકાર છીનવી લેશે.


EFF has developed the Switzerland Network Testing Tool to give individuals the tools to test for covert traffic filtering.

EFF એ વ્યક્તિઓને ગુપ્ત ટ્રાફિક ફિલ્ટરિંગ માટે પરીક્ષણ કરવા માટેના સાધનો આપવા માટે સ્વિટ્ઝરલેન્ડ નેટવર્ક ટેસ્ટિંગ ટૂલ વિકસાવ્યું છે.


EFF is working to ensure that international treaties do not restrict our free speech, privacy or digital consumer rights.

EFF એ સુનિશ્ચિત કરવા માટે કામ કરી રહી છે કે આંતરરાષ્ટ્રીય સંધિઓ આપણા મુક્ત ભાષણ, ગોપનીયતા અથવા ડિજિટલ ગ્રાહક અધિકારોને પ્રતિબંધિત ન કરે.