Python is a versatile programming language.

పైథాన్ ఒక బహుముఖ ప్రోగ్రామింగ్ భాష.


Hackers often use Python for its powerful libraries.

హాకర్లు తరచుగా శక్తివంతమైన లైబ్రరీల కోసం పైథాన్ ఉపయోగిస్తారు.


The book explains how to build your own debugger.

మీ స్వంత డీబగ్గర్‌ను ఎలా తయారు చేయాలో పుస్తకం వివరిస్తుంది.


నేను పైథాన్ ప్రోగ్రామింగ్ నేర్చుకుంటున్నాను.


ఈ కోడ్‌తో మీరు నాకు సహాయం చేయగలరా?


The security researcher found a critical vulnerability.

భద్రతా పరిశోధకుడు ఒక క్లిష్టమైన బలహీనతను కనుగొన్నాడు.


పైథాన్ నేర్చుకోవడం మరియు ఉపయోగించడం సులభం.


మేము భద్రతా పనులను స్వయంచాలకంగా చేస్తాము.


The debugger helps in finding the errors.

డీబగ్గర్ లోపాలను కనుగొనడంలో సహాయపడుతుంది.


ఇది ఒక సంక్లిష్టమైన ప్రోగ్రామ్.


The hacker used Python to exploit the system.

హాకర్ సిస్టమ్‌ను దోచుకోవడానికి పైథాన్ ఉపయోగించాడు.


నేను పైథాన్ లైబ్రరీలను ఇన్‌స్టాల్ చేయాలి.


The code injection technique is dangerous.

కోడ్ ఇంజెక్షన్ టెక్నిక్ ప్రమాదకరమైనది.


అతను సీనియర్ భద్రతా పరిశోధకుడు.


The book covers various hacking techniques.

పుస్తకం వివిధ హ్యాకింగ్ పద్ధతులను కవర్ చేస్తుంది.


The program is running in the background.

ప్రోగ్రామ్ నేపథ్యంలో నడుస్తోంది.


వారు తమ పని కోసం పైథాన్ ఉపయోగిస్తున్నారు.


The software has a critical vulnerability.

సాఫ్ట్‌వేర్‌లో క్లిష్టమైన బలహీనత ఉంది.


సంస్థ దాని భద్రతను మెరుగుపరుస్తోంది.


This tool is very useful for reverse engineering.

ఈ సాధనం రివర్స్ ఇంజనీరింగ్ కోసం చాలా ఉపయోగకరంగా ఉంది.


The debugger is responsible for handling access violations.

యాక్సెస్ ఉల్లంఘనలను నిర్వహించడానికి డీబగ్గర్ బాధ్యత వహిస్తుంది.


We will start with extending breakpoint handlers.

మేము బ్రేక్‌పాయింట్ హ్యాండ్లర్‌లను విస్తరించడం ద్వారా ప్రారంభిస్తాము.


The custom code can do a variety of things.

అనుకూల కోడ్ వివిధ పనులు చేయగలదు.


ఇది ఒక సాధారణమైనది, అయినప్పటికీ శక్తివంతమైన ఉదాహరణ.


Let's take a look at handling application crashes.

అప్లికేషన్ క్రాష్‌లను నిర్వహించడం ఎలాగో చూద్దాం.


An access violation occurs inside a process.

ఒక ప్రక్రియలో యాక్సెస్ ఉల్లంఘన సంభవిస్తుంది.


The debugger trap all information that is relevant.

డీబగ్గర్ సంబంధిత సమాచారం మొత్తాన్ని బంధిస్తుంది.


You can now use this information as a starting point.

మీరు ఇప్పుడు ఈ సమాచారాన్ని ప్రారంభ బిందువుగా ఉపయోగించవచ్చు.


టెస్ట్ స్క్రిప్ట్‌తో ప్రారంభిద్దాం.


ఇప్పుడు మేము పరీక్ష కేసును నిర్మించాము.


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.

క్రాష్ హ్యాండ్లర్‌ను సెటప్ చేయడం ఎంత సులభమో మీరు చూడవచ్చు.


ఇది చాలా ఉపయోగకరమైన లక్షణం.


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

తరువాత మేము PyDbg యొక్క అంతర్గత ప్రక్రియ స్నాప్‌షాటింగ్‌ను ఉపయోగిస్తాము.


PyDbg comes stocked with a very cool feature.

PyDbg చాలా చల్లని ఫీచర్‌తో వస్తుంది.


Using this feature, you can rewind a process.

ఈ ఫీచర్‌ని ఉపయోగించి, మీరు ఒక ప్రక్రియను తిరిగి తిప్పవచ్చు.


ఆకాశమే హద్దు!


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

స్టాక్ అధిక మెమరీ చిరునామాల నుండి తక్కువ మెమరీ చిరునామాలకు పెరుగుతుంది.


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

స్టాక్ ఎలా పనిచేస్తుందో సరళీకృత ఉదాహరణగా మనం ఇంతకు ముందు కవర్ చేసిన my_socks() ఫంక్షన్‌ను ఉపయోగిద్దాం.


When the my_socks() function returns, it pops off all the values on the stack and jumps to the return address.

my_socks() ఫంక్షన్ తిరిగి వచ్చినప్పుడు, అది స్టాక్‌లోని అన్ని విలువలను తీసివేసి, రిటర్న్ చిరునామాకు వెళుతుంది.


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

స్థానిక వేరియబుల్స్ మెమరీ ముక్కలు, ఇవి అమలు చేస్తున్న ఫంక్షన్ కోసం మాత్రమే చెల్లుబాటు అవుతాయి.


The variable stinky_sock_color_one would be allocated on the stack so that it can be used within the current stack frame.

stinky_sock_color_one వేరియబుల్ స్టాక్‌లో కేటాయించబడుతుంది, తద్వారా అది ప్రస్తుత స్టాక్ ఫ్రేమ్‌లో ఉపయోగించబడుతుంది.


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

డీబగ్గర్ లోపల స్టాక్ ఫ్రేమ్‌ను సంగ్రహించే సామర్థ్యం ఫంక్షన్లను గుర్తించడానికి చాలా ఉపయోగకరంగా ఉంటుంది.


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.

ప్రతి ఆపరేటింగ్ సిస్టమ్ డీబగ్గర్‌కు ఈ ఈవెంట్‌లను పంపడానికి ఒక ప్రత్యేక పద్ధతిని కలిగి ఉంటుంది.


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.

ఒక ప్రక్రియను డీబగ్ చేసేటప్పుడు మీరు ఉపయోగించే అత్యంత సాధారణ లక్షణం బ్రేక్‌పాయింట్‌లు.


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

సాఫ్ట్ బ్రేక్‌పాయింట్ అనేది ఒకే-బైట్ సూచన, ఇది డీబగ్ చేయబడిన ప్రక్రియ యొక్క అమలును నిలిపివేస్తుంది.


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

అసెంబ్లీ సూచన అనేది CPU అమలు చేయడానికి ఒక ఆదేశానికి సంబంధించిన ఉన్నత-స్థాయి ప్రాతినిధ్యం.


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

ఇది చిరునామా, ఆపcodeడ్ మరియు ఉన్నత-స్థాయి అసెంబ్లీ సూచనను చూపుతుంది.


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

CPU దాటుకుంటూ వచ్చి ఆ బైట్‌ను తాకినప్పుడు, అది ఆగిపోతుంది, INT3 ఈవెంట్‌ను ప్రేరేపిస్తుంది.


The debugger then checks to see if the instruction pointer (EIP register) is pointing to an address.

అప్పుడు డీబగ్గర్ సూచన పాయింటర్ (EIP రిజిస్టర్) ఒక చిరునామాను సూచిస్తుందో లేదో తనిఖీ చేస్తుంది.


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.

కొద్ది సంఖ్యలో బ్రేక్‌పాయింట్‌లు కావాలనుకున్నప్పుడు హార్డ్‌వేర్ బ్రేక్‌పాయింట్‌లు ఉపయోగపడతాయి.


Memory breakpoints aren’t really breakpoints at all.

మెమరీ బ్రేక్‌పాయింట్‌లు నిజంగా బ్రేక్‌పాయింట్‌లు కావు.


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

ఫంక్షన్ విజయవంతమైతే, అది ప్రాసెస్ ఆబ్జెక్ట్‌కు ఒక హ్యాండిల్‌ను అందిస్తుంది.


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

DebugActiveProcess() ఫంక్షన్‌ని ఉపయోగించి మేము ప్రాసెస్‌కు అటాచ్ అవుతాము.


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

మేము అటాచ్ చేయాలనుకుంటున్న ప్రాసెస్ యొక్క PIDని దీనికి పంపుతాము.


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

ప్రాసెస్‌ను యాక్సెస్ చేయడానికి మాకు తగిన హక్కులు ఉన్నాయని సిస్టమ్ నిర్ణయించిన తర్వాత, అటాచ్ చేసే ప్రాసెస్ (డీబగ్గర్) డీబగ్ ఈవెంట్‌లను నిర్వహించడానికి సిద్ధంగా ఉందని లక్ష్య ప్రాసెస్ భావిస్తుంది మరియు అది డీబగ్గర్‌కు నియంత్రణను వదులుతుంది.


These debugging events by calling WaitForDebugEvent() in a loop.

WaitForDebugEvent()ని లూప్‌లో పిలవడం ద్వారా ఈ డీబగ్గింగ్ ఈవెంట్‌లు జరుగుతాయి.


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

మొదటి పరామితి DEBUG_EVENT structకి పాయింటర్; ఈ నిర్మాణం డీబగ్గింగ్ ఈవెంట్‌ను వివరిస్తుంది.


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

WaitForDebugEvent() కాల్ ఒక ఈవెంట్ సంభవించే వరకు తిరిగి రాకుండా ఉండటానికి మేము రెండవ పరామితిని INFINITEకి సెట్ చేస్తాము.


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

డీబగ్గర్ పట్టుకునే ప్రతి ఈవెంట్ కోసం, ప్రాసెస్ కొనసాగడానికి ముందు కొన్ని రకాల చర్యను నిర్వహించే అనుబంధిత ఈవెంట్ హ్యాండ్లర్‌లు ఉన్నాయి.


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

హ్యాండ్లర్‌లు అమలు చేయడం పూర్తయిన తర్వాత, ప్రాసెస్ అమలును కొనసాగించాలని మేము కోరుకుంటున్నాము.


This is achieved using the ContinueDebugEvent() function.

ContinueDebugEvent() ఫంక్షన్‌ని ఉపయోగించి ఇది సాధించబడుతుంది.


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

dwProcessId మరియు dwThreadId పారామితులు DEBUG_EVENT structలోని ఫీల్డ్‌లు, ఇవి డీబగ్గర్ డీబగ్గింగ్ ఈవెంట్‌ను పట్టుకున్నప్పుడు ప్రారంభించబడతాయి.


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

dwContinueStatus పరామితి ప్రాసెస్‌ను అమలును కొనసాగించడానికి (DBG_CONTINUE) లేదా మినహాయింపును ప్రాసెస్ చేయడానికి (DBG_EXCEPTION_NOT_HANDLED) సిగ్నల్ చేస్తుంది.


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

మిగిలింది ప్రాసెస్ నుండి వేరు చేయడమే.


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

DebugActiveProcessStop()ని పిలవడం ద్వారా దీన్ని చేయండి, ఇది మీరు వేరు చేయాలనుకుంటున్న PIDని దాని ఏకైక పరామితిగా తీసుకుంటుంది.


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

అంతా కలిపి, ప్రాసెస్‌కు అటాచ్ అయ్యే మరియు వేరుచేసే సామర్థ్యాన్ని అందించడం ద్వారా మా my_debugger తరగతిని విస్తరింపజేద్దాం.


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

మేము ప్రాసెస్ హ్యాండిల్‌ను తెరవడానికి మరియు పొందడానికి కూడా సామర్థ్యాన్ని జోడిస్తాము.


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

చివరి అమలు వివరాలు డీబగ్గింగ్ ఈవెంట్‌లను నిర్వహించడానికి మా ప్రాథమిక డీబగ్ లూప్‌ను సృష్టించడం.


Download this file now and overwrite your current copy.

ఇప్పుడే ఈ ఫైల్‌ను డౌన్‌లోడ్ చేసి, మీ ప్రస్తుత కాపీని ఓవర్‌రైట్ చేయండి.


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

మీరు ఇప్పటికే వాటితో బాగా పరిచయం కలిగి ఉండాలి కాబట్టి, మేము నిర్మాణాలు, యూనియన్లు మరియు స్థిరాంకాల సృష్టిని ఇకపై కవర్ చేయము.


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

ఏదైనా నిర్దిష్ట సమయంలో CPU రిజిస్టర్‌ల స్థితిని డీబగ్గర్ క్యాప్చర్ చేయగలగాలి.


The exploit code needs to land at a specific address to disable DEP.

DEP ని నిలిపివేయడానికి ఎక్స్‌ప్లోయిట్ కోడ్ ఒక నిర్దిష్ట చిరునామాలో ల్యాండ్ అవ్వాలి.


The findantidep.py script helps locate these addresses.

findantidep.py స్క్రిప్ట్ ఈ చిరునామాలను గుర్తించడంలో సహాయపడుతుంది.


Immunity Debugger is a useful tool for exploit development.

ఎక్స్‌ప్లోయిట్ అభివృద్ధికి ఇమ్యూనిటీ డీబగ్గర్ ఒక ఉపయోగకరమైన సాధనం.


Malware often employs anti-debugging routines.

మాల్వేర్ తరచుగా యాంటీ-డీబగ్గింగ్ రొటీన్‌లను ఉపయోగిస్తుంది.


The IsDebuggerPresent function is a common anti-debugging technique.

IsDebuggerPresent ఫంక్షన్ ఒక సాధారణ యాంటీ-డీబగ్గింగ్ పద్ధతి.


This function returns 1 if a debugger is attached.

డీబగ్గర్ అటాచ్ చేయబడితే ఈ ఫంక్షన్ 1ని అందిస్తుంది.


Malware can iterate through running processes to detect debuggers.

డీబగ్గర్‌లను గుర్తించడానికి మాల్వేర్ రన్నింగ్ ప్రాసెస్‌ల ద్వారా పునరావృతం చేయవచ్చు.


The Process32First and Process32Next functions are used for this.

దీని కోసం Process32First మరియు Process32Next ఫంక్షన్లు ఉపయోగించబడతాయి.


Patching these functions can bypass process iteration checks.

ఈ ఫంక్షన్లను ప్యాచ్ చేయడం ద్వారా ప్రాసెస్ పునరావృతం తనిఖీలను దాటవేయవచ్చు.


Hooking is a powerful process-observation technique.

హుకింగ్ అనేది ఒక శక్తివంతమైన ప్రక్రియ-అబ్జర్వేషన్ టెక్నిక్.


Soft hooks use INT3 breakpoint handlers.

సాఫ్ట్ హుక్స్ INT3 బ్రేక్‌పాయింట్ హ్యాండ్లర్‌లను ఉపయోగిస్తాయి.


Hard hooks involve hard-coding jumps in assembly.

హార్డ్ హుక్స్ అసెంబ్లీలో హార్డ్-కోడింగ్ జంప్‌లను కలిగి ఉంటాయి.


Soft hooks are suitable for non-intensive functions.

సాఫ్ట్ హుక్స్ ఇంటెన్సివ్ కాని ఫంక్షన్లకు అనుకూలంగా ఉంటాయి.


Hard hooks are better for frequently called routines.

తరచుగా పిలువబడే రొటీన్‌లకు హార్డ్ హుక్స్ మంచివి.


సాఫ్ట్ హుకింగ్ కోసం PyDbgని ఉపయోగించవచ్చు.


We can sniff encrypted traffic using soft hooks.

సాఫ్ట్ హుక్స్ ఉపయోగించి మనం గుప్తీకరించిన ట్రాఫిక్‌ను స్నిఫ్ చేయవచ్చు.


The PR_Write function in nspr4.dll is a good hook point.

nspr4.dll లోని PR_Write ఫంక్షన్ ఒక మంచి హుక్ పాయింట్.


The second parameter of PR_Write contains the data.

PR_Write యొక్క రెండవ పరామితి డేటాను కలిగి ఉంటుంది.


Immunity Debugger provides FastLogHook for hard hooking.

హార్డ్ హుకింగ్ కోసం ఇమ్యూనిటీ డీబగ్గర్ FastLogHook ను అందిస్తుంది.


FastLogHook reduces the impact on the target process.

FastLogHook లక్ష్య ప్రక్రియపై ప్రభావాన్ని తగ్గిస్తుంది.


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

ఏ సమయంలోనైనా, మీరు స్నాప్‌షాట్ తీసిన సమయానికి ప్రక్రియను తిరిగి మార్చవచ్చు.


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

బైనరీని రివర్స్ ఇంజనీరింగ్ చేస్తున్నప్పుడు లేదా క్రాష్‌ను విశ్లేషిస్తున్నప్పుడు ఇది చాలా ఉపయోగకరంగా ఉంటుంది.


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

ఖచ్చితమైన సమయంలో లక్ష్య ప్రక్రియ ఏమి చేస్తుందో ఖచ్చితమైన చిత్రాన్ని పొందడం మా మొదటి దశ.


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

చిత్రం ఖచ్చితంగా ఉండాలంటే, మనం మొదట అన్ని థ్రెడ్‌లను మరియు వాటి CPU సందర్భాలను పొందాలి.


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

అలాగే, మేము ప్రక్రియ యొక్క అన్ని మెమరీ పేజీలు మరియు వాటి విషయాలను పొందాలి.


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

ఈ సమాచారం మన దగ్గర ఉన్న తర్వాత, స్నాప్‌షాట్‌ను పునరుద్ధరించాలనుకున్నప్పుడు దాన్ని నిల్వ చేయడం ఒక విషయం మాత్రమే.


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

ప్రక్రియ స్నాప్‌షాట్‌లను తీసుకునే ముందు, స్నాప్‌షాట్ తీసుకునే సమయంలో డేటా లేదా స్థితి మారకుండా ఉండటానికి మనం అన్ని ఎగ్జిక్యూషన్ థ్రెడ్‌లను సస్పెండ్ చేయాలి.


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

PyDbgలో అన్ని థ్రెడ్‌లను సస్పెండ్ చేయడానికి, మేము suspend_all_threads()ని ఉపయోగిస్తాము మరియు అన్ని థ్రెడ్‌లను పునరుద్ధరించడానికి, మేము తగిన పేరుతో resume_all_threads()ని ఉపయోగిస్తాము.


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

థ్రెడ్‌లను సస్పెండ్ చేసిన తర్వాత, మేము process_snapshot()కి కాల్ చేస్తాము.


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

ఇది ఆ ఖచ్చితమైన సమయంలో ప్రతి థ్రెడ్ మరియు మొత్తం మెమరీ గురించి సందర్భోచిత సమాచారాన్ని స్వయంచాలకంగా పొందుతుంది.


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

స్నాప్‌షాట్ పూర్తయిన తర్వాత, మేము అన్ని థ్రెడ్‌లను పునరుద్ధరిస్తాము.


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

ప్రక్రియను స్నాప్‌షాట్ పాయింట్‌కి పునరుద్ధరించాలనుకున్నప్పుడు, మేము అన్ని థ్రెడ్‌లను సస్పెండ్ చేస్తాము, process_restore()ని పిలుస్తాము మరియు అన్ని థ్రెడ్‌లను పునరుద్ధరిస్తాము.


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

ప్రక్రియను పునరుద్ధరించిన తర్వాత, మేము మా అసలు స్నాప్‌షాట్ పాయింట్‌కి తిరిగి రావాలి.


బాగుంది కదూ?


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

దీన్ని ప్రయత్నించడానికి, స్నాప్‌షాట్ తీసుకోవడానికి ఒక కీని నొక్కడానికి మరియు స్నాప్‌షాట్‌ను పునరుద్ధరించడానికి మళ్లీ ఒక కీని నొక్కడానికి వినియోగదారుని అనుమతించే సాధారణ ఉదాహరణను ఉపయోగిద్దాం.


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

కొత్త పైథాన్ ఫైల్‌ను తెరిచి, దానికి snapshot.py అని పేరు పెట్టి, కింది కోడ్‌ను నమోదు చేయండి.


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

కాబట్టి మొదటి దశ ఏమిటంటే లక్ష్య అప్లికేషన్‌ను డీబగ్గర్ థ్రెడ్ కింద ప్రారంభించడం.


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

ప్రత్యేక థ్రెడ్‌లను ఉపయోగించడం ద్వారా, మా ఇన్‌పుట్ కోసం ఇది వేచి ఉన్నప్పుడు లక్ష్య అప్లికేషన్‌ను పాజ్ చేయమని బలవంతం చేయకుండానే మేము స్నాప్‌షాటింగ్ ఆదేశాలను నమోదు చేయవచ్చు.


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

డీబగ్గర్ థ్రెడ్ చెల్లుబాటు అయ్యే PIDని తిరిగి ఇచ్చిన తర్వాత, మేము మా ఇన్‌పుట్‌ను తీసుకునే కొత్త థ్రెడ్‌ను ప్రారంభిస్తాము.


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

అప్పుడు మేము దానికి ఒక ఆదేశాన్ని పంపినప్పుడు, మేము స్నాప్‌షాట్ తీసుకుంటున్నామా, స్నాప్‌షాట్‌ను పునరుద్ధరిస్తున్నామా లేదా క్విట్ చేస్తున్నామా అని అంచనా వేస్తుంది—ఇది చాలా సూటిగా ఉంటుంది.


The file fuzzer selects a file randomly from a directory.

ఫైల్ ఫజర్ ఒక డైరెక్టరీ నుండి ఒక ఫైల్‌ను యాదృచ్ఛికంగా ఎంచుకుంటుంది.


The fuzzer applies mutations to the selected file.

ఫజర్ ఎంచుకున్న ఫైల్‌కు మార్పులను వర్తింపజేస్తుంది.


A debugger thread is started to load the target application.

లక్ష్య అప్లికేషన్‌ను లోడ్ చేయడానికి ఒక డీబగ్గర్ థ్రెడ్ ప్రారంభించబడింది.


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

నిర్దేశిత సమయం తర్వాత అప్లికేషన్ ముగుస్తుందని మానిటరింగ్ థ్రెడ్ నిర్ధారిస్తుంది.


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

ఫజ్ ఫంక్షన్ ఇప్పటికే ఫజింగ్ పునరావృతం జరుగుతుందో లేదో తనిఖీ చేస్తుంది.


The mutate_file function pulls the contents of the file into a buffer.

mutate_file ఫంక్షన్ ఫైల్ యొక్క విషయాలను ఒక బఫర్‌లోకి లాగుతుంది.


A test case is selected randomly from the test cases list.

టెస్ట్ కేసుల జాబితా నుండి ఒక పరీక్ష కేసును యాదృచ్ఛికంగా ఎంచుకుంటారు.


The fuzzer applies the test case to a random position in the file.

ఫజర్ పరీక్ష కేసును ఫైల్‌లోని యాదృచ్ఛిక స్థానానికి వర్తింపజేస్తుంది.


మార్పు చెందిన ఫైల్ తరువాత వ్రాయబడుతుంది.


The fuzzer uses command-line options for configuration.

ఫజర్ కాన్ఫిగరేషన్ కోసం కమాండ్-లైన్ ఎంపికలను ఉపయోగిస్తుంది.


The -e flag specifies the path to the executable.

-e ఫ్లాగ్ ఎగ్జిక్యూటబుల్ మార్గాన్ని పేర్కొంటుంది.


The -x option specifies the file extension.

-x ఎంపిక ఫైల్ పొడిగింపును పేర్కొంటుంది.


The -n parameter enables or disables notifications.

-n పరామితి నోటిఫికేషన్‌లను ప్రారంభిస్తుంది లేదా నిలిపివేస్తుంది.


Code coverage measures how much code is executed during testing.

కోడ్ కవరేజ్ పరీక్ష సమయంలో ఎంత కోడ్ అమలు చేయబడిందో కొలుస్తుంది.


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

ఆటోమేటెడ్ స్టాటిక్ విశ్లేషణ లక్ష్య కోడ్‌లో హాట్ స్పాట్‌లను కనుగొనగలదు.


Sulley is a Python-based fuzzing framework.

సుల్లీ ఒక పైథాన్ ఆధారిత ఫజింగ్ ఫ్రేమ్‌వర్క్.


Sulley uses block-based fuzzing for data generation.

డేటా ఉత్పత్తి కోసం సుల్లీ బ్లాక్-ఆధారిత ఫజింగ్‌ను ఉపయోగిస్తుంది.


Primitives are the building blocks for protocol descriptions in Sulley.

సుల్లీలో ప్రోటోకాల్ వివరణల కోసం ఆదిమ భాగాలు బిల్డింగ్ బ్లాక్‌లు.


Strings are a common primitive used in Sulley.

సుల్లీలో స్ట్రింగ్‌లు సాధారణంగా ఉపయోగించే ఆదిమ భాగాలు.


Delimiters help break larger strings into manageable pieces.

డెలిమిటర్లు పెద్ద స్ట్రింగ్‌లను నిర్వహించదగిన ముక్కలుగా విభజించడంలో సహాయపడతాయి.


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

మీ హుక్ ఫలితాలను తిరిగి పొందడానికి, మీరు getAllLog() అనే ర్యాపర్ ఫంక్షన్‌ని ఉపయోగించి ఈ పేజీని ప్రశ్నించాలి.


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

కాబట్టి, ప్రతిసారీ ఒక హుక్ చేయబడిన ఫంక్షన్ హిట్ అయినప్పుడు, దాని చిరునామా హుక్_చిరునామాలో నిల్వ చేయబడుతుంది.


The final important note is that there is an additional flavor of FastLogHook, STDCALLFastLogHook, which is adjusted for the STDCALL calling convention.

చివరి ముఖ్యమైన విషయం ఏమిటంటే, FastLogHook యొక్క అదనపు రుచి ఉంది, STDCALLFastLogHook, ఇది STDCALL కాలింగ్ కన్వెన్షన్ కోసం సర్దుబాటు చేయబడింది.


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 రెట్లు లేదా అంతకంటే ఎక్కువ పెరుగుదలను చూస్తారు.


For brevity’s sake, we’ll walk through only the core hooking portions of hippie and in the process create a simpler version called hippie_easy.py.

సంక్షిప్తత కోసం, మేము హిప్పీ యొక్క ప్రధాన హుకింగ్ భాగాల ద్వారా మాత్రమే నడుస్తాము మరియు ఈ ప్రక్రియలో hippie_easy.py అనే సరళమైన వెర్షన్‌ను సృష్టిస్తాము.


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.

హుక్ పాయింట్ల గురించి మనకు అవగాహన వచ్చిన తర్వాత, కొత్త పైథాన్ ఫైల్‌ను తెరవండి, దానికి hippie_easy.py అని పేరు పెట్టండి మరియు కింది కోడ్‌ను హిట్ చేయండి.


This is Nico's function that looks for the correct basic block that has our desired ret instruction.

ఇది మనకు కావలసిన రెట్ సూచనను కలిగి ఉన్న సరైన ప్రాథమిక బ్లాక్‌ను చూసే నికో యొక్క ఫంక్షన్.


The Python code starts disassembling at the head of the function until it finds the RET instruction.

RET సూచనను కనుగొనే వరకు పైథాన్ కోడ్ ఫంక్షన్ హెడ్‌లో విడగొట్టడం ప్రారంభమవుతుంది.


Get used to writing these little utility functions to help you get around these types of roadblocks.

ఈ రకమైన రోడ్‌బ్లాక్‌లను అధిగమించడానికి మీకు సహాయపడే ఈ చిన్న యుటిలిటీ ఫంక్షన్‌లను రాయడానికి అలవాటు పడండి.


Binaries are complicated beasts, and they have zero tolerance for error when you mess with their code.

బైనరీలు సంక్లిష్టమైన మృగాలు, మరియు మీరు వాటి కోడ్‌తో గందరగోళానికి గురైనప్పుడు వాటికి లోపం కోసం సున్నా సహనం ఉంటుంది.


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.

మీరు లక్ష్యాన్ని రివర్స్ చేస్తున్నప్పుడు లేదా దాడి చేస్తున్నప్పుడు, రిమోట్ ప్రాసెస్‌లోకి కోడ్‌ను లోడ్ చేయగలగడం మీకు ఉపయోగకరంగా ఉంటుంది.


We will use DLL injection to launch a pop-up window within another process.

మనం మరొక ప్రక్రియలో పాప్-అప్ విండోను ప్రారంభించడానికి DLL ఇంజెక్షన్‌ను ఉపయోగిస్తాము.


The Win32 API comes preloaded with a function to do just that, CreateRemoteThread().

Win32 API ఇప్పటికే అదే పని చేయడానికి ఒక ఫంక్షన్‌తో లోడ్ చేయబడింది, CreateRemoteThread().


The lpStartAddress parameter, which indicates where in memory the thread will begin executing.

lpStartAddress పరామితి, ఇది మెమరీలో థ్రెడ్ ఎక్కడ అమలు చేయడం ప్రారంభిస్తుందో సూచిస్తుంది.


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

ప్రత్యేక సాధనాలు లేకుండా, కంప్యూటర్ వినియోగదారుడు ADS ల విషయాలను చూడలేడు.


To use an alternate data stream on a file, we’ll need to do nothing more than append a colon and a filename to an existing file.

ఒక ఫైల్ లో ప్రత్యామ్నాయ డేటా స్ట్రీమ్ ను ఉపయోగించడానికి, మనం చేయాల్సిందల్లా ఒక కోలన్ మరియు ఫైల్ పేరును ఇప్పటికే ఉన్న ఫైల్ కు జోడించడం.


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

ఈ సందర్భంలో, మేము reverser.exeకి అనుసంధానించబడిన ప్రత్యామ్నాయ డేటా స్ట్రీమ్ లో నిల్వ చేయబడిన vncdll.dllని యాక్సెస్ చేస్తున్నాము.


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

ఒక ఫైల్ ను చదివి, మనకు నచ్చిన ఫైల్ కు అనుసంధానించబడిన ADSకి వ్రాసే ఒక చిన్న యుటిలిటీ స్క్రిప్ట్ ను వ్రాద్దాం.


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

మొదటి కమాండ్-లైన్ ఆర్గ్యుమెంట్ మనం చదవాలనుకుంటున్న DLL, మరియు రెండవ ఆర్గ్యుమెంట్ లక్ష్య ఫైల్, దీని ADSలో మేము DLLని నిల్వ చేస్తాము.


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

ఎగ్జిక్యూటబుల్ పక్కన మనం కోరుకున్న ఏ రకమైన ఫైల్లనైనా నిల్వ చేయడానికి మరియు ADS నుండి నేరుగా DLLలను ఇంజెక్ట్ చేయడానికి కూడా ఈ చిన్న యుటిలిటీని ఉపయోగించవచ్చు.


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

మన ఎగ్జిక్యూషన్ రీడైరెక్షన్ కోడ్ ను నిర్మించడం ద్వారా ప్రారంభిద్దాం, ఇది చాలా సులభంగా మనకు నచ్చిన అప్లికేషన్ ను ప్రారంభిస్తుంది.


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

వినియోగదారుడు కాలిక్యులేటర్ ను ఉపయోగించడానికి ప్రయత్నించినప్పుడు, ఆమె అనుకోకుండానే మా బ్యాక్‌డోర్‌ను నడుపుతుంది, ఇది సరైన కాలిక్యులేటర్‌ను ప్రారంభిస్తుంది మరియు తద్వారా ఏదైనా తప్పుగా ఉందని వినియోగదారుని హెచ్చరించదు.


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ని ఎలా దాచవచ్చో అన్వేషిస్తాము.


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 ప్రక్రియలోకి రెండు వేర్వేరు షెల్‌కోడ్ ముక్కలను ఇంజెక్ట్ చేసే సమయం ఆసన్నమైంది, ఒకటి మనకు రివర్స్ షెల్ ఇవ్వడానికి మరియు మరొకటి మన విభిన్న ప్రక్రియను చంపడానికి.


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

ఇప్పుడు మనకు కొంత రహస్యతను ఉపయోగించే చాలా సమగ్రమైన బ్యాక్‌డోర్ ఉంది, మరియు ఇంకా మంచిది, మనం ఆసక్తి చూపే అప్లికేషన్‌ను ఎవరైనా అమలు చేసిన ప్రతిసారీ లక్ష్య యంత్రానికి యాక్సెస్ పొందుతాము.


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

py2exe అనే ఒక సులభమైన పైథాన్ లైబ్రరీ పైథాన్ స్క్రిప్ట్‌ను పూర్తి స్థాయి విండోస్ ఎగ్జిక్యూటబుల్‌గా కంపైల్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.


In order to compile our backdoor, we create a simple setup script that defines how we want the executable to be built.

మా బ్యాక్‌డోర్‌ను కంపైల్ చేయడానికి, ఎగ్జిక్యూటబుల్‌ను ఎలా నిర్మించాలనుకుంటున్నామో నిర్వచించే ఒక సాధారణ సెటప్ స్క్రిప్ట్‌ను మేము సృష్టిస్తాము.


The first parameter, console, is the name of the primary script we are compiling.

మొదటి పరామితి, కన్సోల్, మేము కంపైల్ చేస్తున్న ప్రాథమిక స్క్రిప్ట్ పేరు.


This makes our backdoor very portable in that we can move it onto a system without Python installed, and it will work just fine.

ఇది మా బ్యాక్‌డోర్‌ను చాలా పోర్టబుల్‌గా చేస్తుంది, ఎందుకంటే మేము దానిని పైథాన్ ఇన్‌స్టాల్ చేయని సిస్టమ్‌లోకి తరలించవచ్చు మరియు ఇది బాగా పనిచేస్తుంది.


Switch to your Windows command interface, and run the build script like so: python setup.py py2exe

మీ విండోస్ కమాండ్ ఇంటర్‌ఫేస్‌కి మారండి మరియు బిల్డ్ స్క్రిప్ట్‌ను ఇలా అమలు చేయండి: python setup.py py2exe


You will see a bunch of output from the compilation process, and when it’s finished you will have two new directories, dist and build.

కంపైలేషన్ ప్రక్రియ నుండి మీరు చాలా అవుట్‌పుట్‌ను చూస్తారు మరియు అది పూర్తయినప్పుడు మీకు రెండు కొత్త డైరెక్టరీలు, డిస్ట్ మరియు బిల్డ్ ఉంటాయి.


Now you have a means of communicating with your backdoor that’s efficient and somewhat stealthy.

ఇప్పుడు మీ బ్యాక్‌డోర్‌తో కమ్యూనికేట్ చేయడానికి మీకు ఒక మార్గం ఉంది, ఇది సమర్థవంతమైనది మరియు కొంతవరకు రహస్యంగా ఉంటుంది.


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.

సుల్లీని ఒక సన్నని, అర్థవంతమైన 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.

కొత్త పైథాన్ ఫైల్‌ను తెరవండి, దానికి ftp_session.py అని పేరు పెట్టండి మరియు కింది కోడ్‌ను నమోదు చేయండి.


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

receive_ftp_banner() ఫంక్షన్ అవసరం, ఎందుకంటే ప్రతి FTP సర్వర్ ఒక బ్యానర్‌ను కలిగి ఉంటుంది, అది క్లయింట్ కనెక్ట్ అయినప్పుడు ప్రదర్శిస్తుంది.


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

మేము దీన్ని sess.pre_send ప్రాపర్టీకి కలుపుతాము, ఇది ఏదైనా ఫజ్ డేటాను పంపే ముందు FTP బ్యానర్‌ను స్వీకరించమని సుల్లీకి చెబుతుంది.


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

సెషన్‌ను సృష్టించడంలో మొదటి దశ ఏమిటంటే, మన ఫజ్జర్ యొక్క ప్రస్తుత స్థితిని ట్రాక్ చేసే సెషన్ ఫైల్‌ను నిర్వచించడం.


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

రెండవ దశ ఏమిటంటే, దాడి చేయడానికి ఒక లక్ష్యాన్ని నిర్వచించడం, ఇది IP చిరునామా మరియు పోర్ట్ నంబర్.


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

మేము 192.168.244.133 మరియు పోర్ట్ 21ని లక్ష్యంగా చేసుకుంటున్నాము, ఇది మా WarFTPD ఉదాహరణ (ఈ సందర్భంలో వర్చువల్ మెషీన్‌లో నడుస్తోంది).


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

మూడవ ఎంట్రీ సుల్లీకి మా నెట్‌వర్క్ స్నిఫర్ అదే హోస్ట్‌లో సెటప్ చేయబడిందని మరియు TCP పోర్ట్ 26001లో వింటుందని చెబుతుంది, ఇది సుల్లీ నుండి ఆదేశాలను స్వీకరించే పోర్ట్.


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

నాల్గవది సుల్లీకి మా డీబగ్గర్ 192.168.244.133 వద్ద కూడా వింటుందని, కానీ TCP పోర్ట్ 26002లో వింటుందని చెబుతుంది; మళ్ళీ సుల్లీ ఈ పోర్ట్‌ను డీబగ్గర్‌కు ఆదేశాలను పంపడానికి ఉపయోగిస్తుంది.


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

మేము డీబగ్గర్‌కు మేము ఆసక్తి చూపే ప్రాసెస్ పేరు war-ftpd.exe అని చెప్పడానికి అదనపు ఎంపికను కూడా అందిస్తాము.


We then add the defined target to our parent session.

అప్పుడు మేము నిర్వచించిన లక్ష్యాన్ని మా ప్రధాన సెషన్‌కు జోడిస్తాము.


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

తదుపరి దశ ఏమిటంటే, మన FTP అభ్యర్థనలను తార్కిక పద్ధతిలో కలపడం.


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

మేము ప్రమాణీకరణ ఆదేశాలను (USER, PASS) ఎలా కలుపుతున్నామో మీరు చూడవచ్చు మరియు వినియోగదారుని ప్రమాణీకరించాల్సిన ఏవైనా ఆదేశాలను మేము PASS ఆదేశానికి కలుపుతాము.


Finally, we tell Sulley to start fuzzing.

చివరగా, ఫజ్ చేయడం ప్రారంభించమని మేము సుల్లీకి చెబుతాము.


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 పంపకం ఫంక్షన్‌ను సూచించే ఫంక్షన్ వస్తువును తిరిగి పంపుతాము.


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; take a look at Listing 10-6 for examples.

స్విచ్ స్టేట్‌మెంట్ అసెంబ్లీలోకి అనువదించబడే అనేక మార్గాలు ఉండవచ్చు; ఉదాహరణల కోసం జాబితా 10-6 ని చూడండి.


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

మొదటి సందర్భంలో, మేము CMP సూచనల శ్రేణిని చూసినప్పుడు, పంపబడిన IOCTLతో పోల్చబడుతున్న స్థిరాంకాన్ని మేము చూస్తాము.


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

ఆ స్థిరాంకం డ్రైవర్ మద్దతు ఇచ్చే చెల్లుబాటు అయ్యే IOCTL కోడ్‌గా ఉండాలి.


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

రెండవ సందర్భంలో, మేము అదే రిజిస్టర్‌కు వ్యతిరేకంగా SUB స్టేట్‌మెంట్‌ల శ్రేణి కోసం చూస్తున్నాము, తరువాత కొన్ని రకాల షరతులతో కూడిన JMP సూచనలు ఉన్నాయి.


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

ఈ లైన్ మనకు తక్కువ మద్దతు ఉన్న IOCTL కోడ్ 0x1337 అని చెబుతుంది.


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

అక్కడి నుండి, మేము చూసే ప్రతి SUB సూచన, మేము సమానమైన మొత్తాన్ని మా బేస్ స్థిరాంకానికి జోడిస్తాము, ఇది మాకు మరొక చెల్లుబాటు అయ్యే IOCTL కోడ్‌ను ఇస్తుంది.


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

డ్రైవర్‌లిబ్ మన కోసం కొంత మురికి పనిని ఎలా చేస్తుందో ఇప్పుడు మనకు తెలుసు, దానిని ఉపయోగించుకుందాం!


We will use driverlib to hunt down device names and supported IOCTL codes from a driver and save these results to a Python pickle.

మేము డ్రైవర్ నుండి పరికరాల పేర్లు మరియు మద్దతు ఉన్న IOCTL కోడ్‌లను వేటాడటానికి మరియు ఈ ఫలితాలను పైథాన్ పికిల్‌కు సేవ్ చేయడానికి డ్రైవర్‌లిబ్‌ని ఉపయోగిస్తాము.


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

అప్పుడు మేము మద్దతు ఇచ్చే వివిధ IOCTL విధానాలను ఫజ్ చేయడానికి మా పికిల్ చేసిన ఫలితాలను ఉపయోగించే IOCTL ఫజర్‌ను వ్రాస్తాము.


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

కొత్త పైథాన్ ఫైల్‌ను తెరవండి, దానికి ioctl_dump.py అని పేరు పెట్టండి మరియు కింది కోడ్‌ను నమోదు చేయండి.


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 ఫంక్షన్ కాల్ చేయబడుతున్న స్థానాలు.


When performing dynamic analysis on a target binary, it can be quite useful to understand what code gets executed.

ఒక లక్ష్య బైనరీపై డైనమిక్ విశ్లేషణను నిర్వహిస్తున్నప్పుడు, ఏ కోడ్ అమలు చేయబడుతుందో అర్థం చేసుకోవడం చాలా ఉపయోగకరంగా ఉంటుంది.


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

మేము లక్ష్య బైనరీలోని అన్ని ఫంక్షన్ల ద్వారా పునరావృతం చేయడానికి మరియు బ్రేక్‌పాయింట్‌లను సెట్ చేయడానికి IDAPythonని ఉపయోగిస్తాము.


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

కొత్త పైథాన్ ఫైల్‌ను తెరిచి, దానికి func_coverage.py అని పేరు పెట్టి, కింది కోడ్‌ను నమోదు చేయండి.


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

ముందుగా, మేము మా డీబగ్గర్ హుక్‌ను ఏర్పాటు చేస్తాము, తద్వారా డీబగ్గర్ ఈవెంట్ విసిరినప్పుడల్లా అది పిలువబడుతుంది.


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

అప్పుడు మేము అన్ని ఫంక్షన్ చిరునామాల ద్వారా పునరావృతం చేస్తాము మరియు ప్రతి చిరునామాలో బ్రేక్‌పాయింట్‌ను సెట్ చేస్తాము.


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

SetBptAttr కాల్ ప్రతి బ్రేక్‌పాయింట్ హిట్ అయినప్పుడు ఆపవద్దని డీబగ్గర్‌కు చెప్పడానికి ఒక ఫ్లాగ్‌ను సెట్ చేస్తుంది.


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

మా బ్రేక్‌పాయింట్ హ్యాండ్లర్ ea వేరియబుల్‌ని ఉపయోగించి హిట్ అయిన ప్రతి బ్రేక్‌పాయింట్ చిరునామాను ప్రింట్ చేస్తుంది.


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

సంభావ్య బలహీనతలను గుర్తించడానికి బైనరీని అంచనా వేసేటప్పుడు, స్టాక్ పరిమాణాన్ని అర్థం చేసుకోవడం ముఖ్యం.


Let’s write some code to iterate through all of the functions in a binary and show us all functions.

బైనరీలోని అన్ని ఫంక్షన్ల ద్వారా పునరావృతం చేయడానికి మరియు అన్ని ఫంక్షన్లను చూపించడానికి కొంత కోడ్‌ను వ్రాద్దాం.


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

మేము ఒక పరిమాణ పరిమితిని సెట్ చేస్తాము, అది బఫర్‌గా పరిగణించే ముందు స్టాక్ వేరియబుల్ ఎంత పెద్దదిగా ఉండాలో నిర్ణయిస్తుంది.


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

దీన్ని బైనరీకి వ్యతిరేకంగా అమలు చేసిన తర్వాత, మీరు కొంత అవుట్‌పుట్‌ను చూడాలి (కొన్ని స్టాక్-అలకేటెడ్ బఫర్‌లు ఉన్నాయని అందిస్తుంది).


You should now have the fundamentals for using IDAPython and have some core utility scripts.

మీరు ఇప్పుడు IDAPythonని ఉపయోగించడం కోసం ఫండమెంటల్స్‌ను కలిగి ఉండాలి మరియు కొన్ని ప్రధాన యుటిలిటీ స్క్రిప్ట్‌లను కలిగి ఉండాలి.


Let’s now take a look at PyEmu, the Python-based x86 emulator.

ఇప్పుడు పైథాన్ ఆధారిత x86 ఎమ్యులేటర్ అయిన PyEmuని చూద్దాం.


PyEmu was released at BlackHat 2007 by Cody Pierce.

కోడి పియర్స్ ద్వారా బ్లాక్‌హాట్ 2007లో PyEmu విడుదలైంది.


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

PyEmu ఎమ్యులేషన్‌ను ప్రారంభించడానికి మూడు పద్ధతులను కలిగి ఉంది: IDAPyEmu, PyDbgPyEmu మరియు PEPyEmu.


We will be covering the use of IDAPyEmu and PEPyEmu for our purposes.

మేము మా ప్రయోజనాల కోసం IDAPyEmu మరియు PEPyEmuల వాడకాన్ని కవర్ చేస్తాము.


Installing PyEmu is quite simple; just download the zip file.

PyEmuని ఇన్‌స్టాల్ చేయడం చాలా సులభం; కేవలం జిప్ ఫైల్‌ను డౌన్‌లోడ్ చేయండి.


PyEmu is split into three main systems: PyCPU, PyMemory, and PyEmu.

PyEmu మూడు ప్రధాన వ్యవస్థలుగా విభజించబడింది: PyCPU, PyMemory మరియు PyEmu.


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.

మీరు ఎలా అలసిపోయే రివర్సింగ్ మరియు భద్రతా పనులను స్వయంచాలకంగా చేయాలో నేర్చుకుంటారు.


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

ప్రపంచంలోని అత్యుత్తమ హ్యాకర్లు తమ పని చేయడానికి పైథాన్ ఉపయోగిస్తున్నారు.


EFF has sued telecom giant AT&T for giving the NSA unfettered access.

NSAకి అపరిమిత యాక్సెస్ ఇచ్చినందుకు EFF టెలికాం దిగ్గజం AT&Tపై దావా వేసింది.


EFF’s Coders’ Rights Project is defending the rights of programmers.

EFF యొక్క కోడర్స్ రైట్స్ ప్రాజెక్ట్ ప్రోగ్రామర్ల హక్కులను కాపాడుతోంది.


EFF is fighting prohibitive standards that would take away your right.

మీ హక్కును దూరం చేసే నిషేధిత ప్రమాణాలతో EFF పోరాడుతోంది.


EFF has developed the Switzerland Network Testing Tool.

EFF స్విట్జర్లాండ్ నెట్‌వర్క్ టెస్టింగ్ టూల్‌ను అభివృద్ధి చేసింది.


EFF is working to ensure that international treaties do not restrict our free speech.

అంతర్జాతీయ ఒప్పందాలు మన స్వేచ్ఛా ప్రసంగాన్ని పరిమితం చేయకుండా EFF పనిచేస్తోంది.


Hacking is the art of creative problem solving.

హ్యాకింగ్ అనేది సృజనాత్మక సమస్య పరిష్కారానికి సంబంధించిన కళ.


Rather than merely showing how to run existing exploits.

ఉన్న ఎక్స్‌ప్లాయిట్‌లను ఎలా అమలు చేయాలో చూపించడానికి బదులుగా.


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

చేర్చబడిన లైవ్‌సిడిని ఉపయోగించి, కోడ్‌ను డీబగ్గింగ్ చేయడం ప్రారంభించండి.


Author Michal Zalewski has long been known and respected.

రచయిత మిచల్ జాలెవ్స్కీ చాలా కాలంగా ప్రసిద్ధి చెందారు మరియు గౌరవించబడ్డారు.


This book is a fascinating narrative that explores a variety of unique security challenges.

ఈ పుస్తకం ఒక ఆకర్షణీయమైన కథనం, ఇది అనేక ప్రత్యేకమైన భద్రతా సవాళ్లను అన్వేషిస్తుంది.


Security data visualization tools offer graphical windows.

భద్రతా డేటా విజువలైజేషన్ సాధనాలు గ్రాఫికల్ విండోలను అందిస్తాయి.


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

రీడర్‌లు క్లిష్టమైన డేటా సెట్‌లను ఒక్క చూపులో అర్థం చేసుకోగలుగుతారు.


Python is a perfect introductory language.

పైథాన్ ఒక పరిపూర్ణ పరిచయ భాష.


Playing with Python teaches computer programming to non-programmers.

పైథాన్‌తో ఆడటం ప్రోగ్రామర్లు కాని వారికి కంప్యూటర్ ప్రోగ్రామింగ్‌ను నేర్పుతుంది.


The IDA Pro Book covers everything from the very first steps.

IDA ప్రో బుక్ మొదటి దశల నుండి ప్రతిదీ కవర్ చేస్తుంది.


You’ll learn to identify known library routines.

మీరు తెలిసిన లైబ్రరీ రొటీన్‌లను గుర్తించడం నేర్చుకుంటారు.


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

మొదట, మేము EIPని ఫంక్షన్ హెడ్‌కు సెట్ చేస్తాము, ఇది 0x00401000 వద్ద ఉంది; ఇక్కడే 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 లైబ్రరీని ఉపయోగిద్దాం.


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

ఎగ్జిక్యూటబుల్ ప్యాకర్లు లేదా కంప్రెసర్‌లు చాలా కాలంగా ఉన్నాయి.