Python is a versatile programming language.

பைத்தான் ஒரு பல்துறை நிரலாக்க மொழி ஆகும்.


Hackers often use Python for its powerful libraries.

ஹேக்கர்கள் பெரும்பாலும் பைத்தானைப் பயன்படுத்துகிறார்கள், ஏனெனில் இது சக்திவாய்ந்த நூலகங்களைக் கொண்டுள்ளது.


The book explains how to use Python for security tasks.

இந்த புத்தகம் பாதுகாப்பு பணிகளுக்காக பைத்தானை எவ்வாறு பயன்படுத்துவது என்பதை விளக்குகிறது.


You can build your own debugger with Python.

நீங்கள் பைத்தானைப் பயன்படுத்தி உங்கள் சொந்த பிழைத்திருத்தியை உருவாக்கலாம்.


Automate tedious reversing and security tasks.

சிரமமான தலைகீழ் பொறியியல் மற்றும் பாதுகாப்பு பணிகளை தானியங்குபடுத்துங்கள்.


The author shows how to harness 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.

இந்தப் புத்தகம் பிழைத்திருத்திகள் மற்றும் ஃபஸர்கள் போன்ற தலைப்புகளை உள்ளடக்கியது.


Install Python 2.5 for your hacking projects.

உங்கள் ஹேக்கிங் திட்டங்களுக்கு பைத்தான் 2.5 ஐ நிறுவவும்.


The book provides examples of code injection.

இந்தப் புத்தகம் குறியீடு செலுத்துதல் பற்றிய எடுத்துக்காட்டுகளை வழங்குகிறது.


விண்டோஸ் டிரைவர்களை எவ்வாறு ஃபஸ் செய்வது என்பதை அறிக.


The book discusses the basics of debugging.

இந்தப் புத்தகம் பிழைத்திருத்துதலின் அடிப்படைகளைப் பற்றி விவாதிக்கிறது.


பிழைத்திருத்துவதற்கு PyDBG ஐப் பயன்படுத்தலாம்.


The book explains how to use Immunity Debugger.

இம்யூனிட்டி பிழைத்திருத்தியை எவ்வாறு பயன்படுத்துவது என்பதை புத்தகம் விளக்குகிறது.


மென்பொருள் தந்திரங்களின் உலகத்தை ஆராயுங்கள்.


The book covers topics related to fuzzing.

இந்தப் புத்தகம் ஃபஸ்ஸிங் தொடர்பான தலைப்புகளை உள்ளடக்கியது.


The author is a senior security researcher.

ஆசிரியர் ஒரு மூத்த பாதுகாப்பு ஆராய்ச்சியாளர் ஆவார்.


This book is a guide for professional hackers.

இந்தப் புத்தகம் தொழில்முறை ஹேக்கர்களுக்கான ஒரு வழிகாட்டியாகும்.


The debugger is responsible for handling access violations.

அணுகல் மீறல்களைக் கையாள்வதற்கு பிழைத்திருத்தி பொறுப்பாகும்.


We will start with extending breakpoint handlers.

நாம் இடைவேளை கையாளுபவர்களை விரிவுபடுத்துவதில் தொடங்குவோம்.


வானமே எல்லை!


This concludes the development of a lightweight debugger on Windows.

விண்டோஸில் ஒரு இலகுரக பிழைத்திருத்தியின் வளர்ச்சியை இது முடிக்கிறது.


வாங்க PyDbg-ஐத் தொடங்குவோம்.


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

பயனர் வரையறுக்கப்பட்ட அழைப்புடன், நாம் தனிப்பயன் தர்க்கத்தை செயல்படுத்தலாம்.


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

முகவரி அளவுரு என்பது மென்மையான இடைவேளை அமைக்கப்பட வேண்டிய முகவரியாகும்.


இது ஒரு எளிய ஆனால் சக்திவாய்ந்த எடுத்துக்காட்டு.


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

ஒரு செயல்முறை நினைவகத்தை அணுக முயற்சிக்கும்போது அணுகல் மீறல் ஏற்படுகிறது.


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

பாதுகாப்பு கண்ணோட்டத்தில், ஒவ்வொரு அணுகல் மீறலும் கவனமாக மதிப்பாய்வு செய்யப்பட வேண்டும்.


It is crucial that the debugger trap all information that is relevant.

பிழைத்திருத்தி தொடர்புடைய அனைத்து தகவல்களையும் கைப்பற்றுவது முக்கியம்.


You can now use this information as a starting point for writing an exploit.

ஒரு சுரண்டலை எழுதுவதற்கான ஆரம்ப புள்ளியாக இந்த தகவலை இப்போது பயன்படுத்தலாம்.


முதலில் ஒரு சோதனை கவசத்தை உருவாக்குவோம்.


Now that we have the test case built, open a new file.

சோதனை வழக்கு கட்டமைக்கப்பட்டவுடன், ஒரு புதிய கோப்பைத் திறக்கவும்.


The output reveals many pieces of useful information.

வெளியீடு பயனுள்ள பல தகவல்களை வெளிப்படுத்துகிறது.


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

இரண்டாவது பகுதி அனைத்து பதிவேடுகளின் சூழல் வெளியேற்றம் ஆகும்.


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

ஒரு செயலிழப்பு கையாளுபவரை அமைப்பது எவ்வளவு எளிது என்பதை நீங்கள் காணலாம்.


இது நம்பமுடியாத அளவிற்கு பயனுள்ள அம்சமாகும்.


PyDbg comes stocked with a very cool feature.

PyDbg ஒரு அருமையான அம்சத்துடன் வருகிறது.


Using the retrieved context record, we then modify one of the registers.

மீட்டெடுக்கப்பட்ட சூழல் பதிவைப் பயன்படுத்தி, நாங்கள் பின்னர் பதிவேடுகளில் ஒன்றை மாற்றியமைக்கிறோம்.


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

ஒரு குறிப்பிட்ட நேரத்தில் CPU பதிவேடுகளின் நிலையை கைப்பற்றக்கூடியதாக பிழைத்திருத்தி இருக்க வேண்டும்.


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

முதலில், பிழைத்திருத்தத்தில் தற்போது இயங்கும் திரைக்கு ஒரு கைப்பிடியைப் பெற வேண்டும்.


This allows us to determine the state of the stack when an exception occurs.

ஒரு விதிவிலக்கு ஏற்படும்போது, அடுக்கு நிலையைத் தீர்மானிக்க இது உதவுகிறது.


We can enumerate the threads by using a very powerful function called CreateToolhelp32Snapshot().

CreateToolhelp32Snapshot() எனப்படும் மிகவும் சக்திவாய்ந்த செயல்பாட்டைப் பயன்படுத்தி திரைகளை எண்ணலாம்.


The dwFlags parameter instructs the function what type of information it is supposed to gather.

dwFlags அளவுரு, எந்த வகையான தகவல்களைச் சேகரிக்க வேண்டும் என்று செயல்பாட்டிற்கு அறிவுறுத்துகிறது.


We set this to TH32CS_SNAPTHREAD, which has a value of 0x00000004.

இதை TH32CS_SNAPTHREAD ஆக அமைக்கிறோம், இதன் மதிப்பு 0x00000004 ஆகும்.


The th32ProcessID is simply the PID of the process we want to take a snapshot of.

th32ProcessID என்பது நாம் ஒரு ஸ்னாப்ஷாட் எடுக்க விரும்பும் செயல்முறையின் PID ஆகும்.


When CreateToolhelp32Snapshot() is successful, it returns a handle to the snapshot object.

CreateToolhelp32Snapshot() வெற்றி பெற்றால், அது ஸ்னாப்ஷாட் பொருளுக்கு ஒரு கைப்பிடியை வழங்குகிறது.


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

ஸ்னாப்ஷாட்டில் இருந்து திரைகளின் பட்டியலைப் பெற்றதும், அவற்றை எண்ணத் தொடங்கலாம்.


To start the enumeration we use the Thread32First() function.

எண்ணைத் தொடங்க, Thread32First() செயல்பாட்டைப் பயன்படுத்துகிறோம்.


The hSnapshot parameter will receive the open handle returned from CreateToolhelp32Snapshot().

hSnapshot அளவுரு CreateToolhelp32Snapshot() இலிருந்து திரும்பிய திறந்த கைப்பிடியைப் பெறும்.


The th32ThreadID is the TID for the thread we are examining.

th32ThreadID என்பது நாம் பரிசோதிக்கும் திரையின் TID ஆகும்.


We will compare each th32OwnerProcessID value against the PID of the process.

ஒவ்வொரு th32OwnerProcessID மதிப்பையும் செயல்முறையின் PID உடன் ஒப்பிடுவோம்.


If there is a match, then we know it’s a thread that our debuggee owns.

பொருத்தம் இருந்தால், அது எங்கள் பிழைத்திருத்தத்திற்கு சொந்தமான ஒரு திரையாகும் என்பதை நாங்கள் அறிவோம்.


Now that we can obtain a valid handle to a thread, the last step is to grab the values of all the registers.

ஒரு திரைக்கு சரியான கைப்பிடியைப் பெற முடிந்தால், கடைசி படி அனைத்து பதிவேடுகளின் மதிப்புகளையும் பெறுவதாகும்.


This is done by calling GetThreadContext().

இது GetThreadContext() ஐ அழைப்பதன் மூலம் செய்யப்படுகிறது.


The hThread parameter is the handle returned from an OpenThread() call.

hThread அளவுரு OpenThread() அழைப்பிலிருந்து திரும்பிய கைப்பிடியாகும்.


The CONTEXT structure is important to understand.

CONTEXT கட்டமைப்பை புரிந்து கொள்ளுதல் முக்கியம்.


We will be relying heavily on this structure throughout the remainder of our debugger-building exercise.

எங்கள் பிழைத்திருத்தி கட்டும் பயிற்சியின் மீதமுள்ளவற்றில் இந்த கட்டமைப்பை பெரிதும் நம்புவோம்.


Let’s go back to our old friend my_debugger.py and extend it a bit more to include thread enumeration and register retrieval.

திரை எண்ணுதல் மற்றும் பதிவேடு மீட்டெடுப்பைச் சேர்க்க, எங்கள் பழைய நண்பர் my_debugger.py க்குச் சென்று அதை இன்னும் கொஞ்சம் விரிவுபடுத்துவோம்.


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

பைத்தான் ஊடாடும் ஷெல், இது பைத்தான் மொழிபெயர்ப்பாளர் மற்றும் சேர்க்கப்பட்ட எந்த நூலகங்களுக்கும் முழு அணுகலை வழங்குகிறது.


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


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.

பிரபலமான எக்லிப்ஸ் டெவலப்மென்ட் சூழல் மற்றும் PyDev எனப்படும் ஒரு தொகுதி ஆகியவற்றின் இணைப்பு, மற்ற பெரும்பாலான IDE கள் வழங்காத உங்கள் விரல் நுனியில் ஏராளமான சக்திவாய்ந்த அம்சங்களை உங்களுக்கு வழங்குகிறது.


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

http://www.eclipse.org/downloads/ இலிருந்து Eclipse Classic தொகுப்பை பதிவிறக்கவும்.


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.

இது முதல் முறை தொடங்கும் போது, உங்கள் பணி இடத்தை எங்கு சேமிக்க வேண்டும் என்று கேட்கும்; நீங்கள் இயல்புநிலையை ஏற்றுக்கொண்டு, இதை இயல்புநிலையாகப் பயன்படுத்துக மற்றும் மீண்டும் கேட்காத பெட்டியை சரிபார்க்கலாம்.


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

எக்லிப்ஸ் இயக்கப்பட்டதும், உதவி 0 மென்பொருள் புதுப்பிப்புகள் 0 கண்டுபிடித்து நிறுவு என்பதைத் தேர்ந்தெடுக்கவும்.


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/ உள்ளது என்பதை உறுதிசெய்து, சரி என்பதைக் கிளிக் செய்யவும்.


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க்கான உரிம ஒப்பந்தத்தைப் படித்து ஏற்றுக்கொள்ளவும். நீங்கள் அதன் விதிமுறைகளை ஏற்றுக்கொண்டால், உரிம ஒப்பந்தத்தில் உள்ள விதிமுறைகளை நான் ஏற்றுக்கொள்கிறேன் என்ற ரேடியோ பொத்தானைத் தேர்ந்தெடுக்கவும்.


The next stage of the Eclipse configuration just involves you making sure that PyDev can find the proper Python interpreter to use when you run scripts inside PyDev:

எக்லிப்ஸ் உள்ளமைவின் அடுத்த கட்டத்தில், PyDev இல் ஸ்கிரிப்ட்களை இயக்கும்போது பயன்படுத்த சரியான பைத்தான் மொழிபெயர்ப்பாளரைக் கண்டுபிடிக்க PyDev க்கு முடிகிறதா என்பதை உறுதிப்படுத்துவது மட்டுமே அடங்கும்:


With Eclipse started, select Window 0 Preferences.

எக்லிப்ஸ் தொடங்கியதும், விண்டோ 0 விருப்பத்தேர்வுகள் என்பதைத் தேர்ந்தெடுக்கவும்.


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

PyDev ட்ரீ உருப்படியை விரிவுபடுத்தி, மொழிபெயர்ப்பாளர் – பைத்தானைத் தேர்ந்தெடுக்கவும்.


In the Python Interpreters section at the top of the dialog, click New.

உரையாடலின் மேற்புறத்தில் உள்ள பைத்தான் மொழிபெயர்ப்பாளர்கள் பிரிவில், புதியதைக் கிளிக் செய்யவும்.


Browse to C:	extbackslash Python25	extbackslash python.exe, and click Open.

C:	extbackslash Python25	extbackslash python.exe க்குச் சென்று, திற என்பதைக் கிளிக் செய்யவும்.


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

இப்போது உங்களிடம் வேலை செய்யும் PyDev நிறுவல் உள்ளது, மேலும் இது புதிதாக நிறுவப்பட்ட பைத்தான் 2.5 மொழிபெயர்ப்பாளரைப் பயன்படுத்த கட்டமைக்கப்பட்டுள்ளது.


கோப்பு 0 புதியது 0 திட்டம் என்பதைத் தேர்ந்தெடுக்கவும்.


Name the project Gray Hat Python. Click Finish.

திட்டத்திற்கு கிரே ஹேட் பைத்தான் என்று பெயரிடுங்கள். முடி என்பதை கிளிக் செய்யவும்.


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

ESP பதிவேடு அடுக்கு சட்டத்தின் உச்சத்தை கண்காணிக்கப் பயன்படுகிறது, மேலும் EBP பதிவேடு அடுக்கு சட்டத்தின் அடிப்பகுதியை கண்காணிக்கப் பயன்படுகிறது.


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

அடுக்கு எவ்வாறு செயல்படுகிறது என்பதற்கு ஒரு எளிமைப்படுத்தப்பட்ட உதாரணமாக முன்பு நாம் விவாதித்த my_socks() செயல்பாட்டைப் பயன்படுத்துவோம்.


When the my_socks() function returns, it pops off all the values on the stack and jumps to the return address to continue executing in the parent function that called it.

my_socks() செயல்பாடு திரும்பும் போது, அது அடுக்கில் உள்ள அனைத்து மதிப்புகளையும் வெளியேற்றி, அதை அழைத்த பெற்றோர் செயல்பாட்டில் தொடர்ந்து செயல்பட திரும்பும் முகவரிக்கு தாவுகிறது.


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

உள்ளூர் மாறிகள் நினைவகத்தின் துண்டுகளாகும், அவை செயல்படும் செயல்பாட்டிற்கு மட்டுமே செல்லுபடியாகும்.


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

stinky_sock_color_one மாறி அடுக்கில் ஒதுக்கப்படும், இதனால் அதை தற்போதைய அடுக்கு சட்டகத்திற்குள் பயன்படுத்த முடியும்.


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

ஒரு பிழைத்திருத்திக்குள் அடுக்கு சட்டகத்தைப் பிடிக்கும் திறன், செயல்பாடுகளைக் கண்டறிவதற்கும், செயலிழப்பின் போது அடுக்கு நிலையைப் பிடிப்பதற்கும், அடுக்கு அடிப்படையிலான வழிதல் நிகழ்வுகளைக் கண்காணிப்பதற்கும் மிகவும் பயனுள்ளதாக இருக்கும்.


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

பிழைத்திருத்திகள் ஒரு முடிவற்ற சுழலாக இயங்குகின்றன, அவை பிழைத்திருத்த நிகழ்வு நிகழக் காத்திருக்கின்றன.


Some of the common events that a debugger must trap are these: Breakpoint hits, Memory violations (also called access violations or segmentation faults), Exceptions generated by the debugged program.

ஒரு பிழைத்திருத்தி பிடிக்க வேண்டிய சில பொதுவான நிகழ்வுகள்: பிரேக் பாயிண்ட் ஹிட்ஸ், நினைவக மீறல்கள் (அணுகல் மீறல்கள் அல்லது பிரிவு குறைபாடுகள் என்றும் அழைக்கப்படுகின்றன), பிழைத்திருத்தப்பட்ட நிரலால் உருவாக்கப்பட்ட விதிவிலக்குகள்.


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 to automate certain debugging tasks.

ஸ்கிரிப்ட் செய்யப்பட்ட பிழைத்திருத்தியின் நன்மை என்னவென்றால், சில பிழைத்திருத்த பணிகளை தானியக்கமாக்க தனிப்பயன் நிகழ்வு கையாளுபவர்களை உருவாக்கும் திறன் ஆகும்.


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

உதாரணமாக, ஒரு இடையக வழிதல் நினைவக மீறல்களுக்கு ஒரு பொதுவான காரணமாகும் மற்றும் ஒரு ஹேக்கருக்கு மிகுந்த ஆர்வமாக உள்ளது.


The ability to halt a process that is being debugged is achieved by setting breakpoints.

பிழைத்திருத்தம் செய்யப்படும் ஒரு செயல்முறையை நிறுத்தும் திறன் பிரேக் பாயிண்ட்களை அமைப்பதன் மூலம் அடையப்படுகிறது.


Breakpoints are most definitely the most common feature that you will use when debugging a process, and we will cover them extensively.

ஒரு செயல்முறையை பிழைத்திருத்தம் செய்யும் போது நீங்கள் பயன்படுத்தும் மிக பொதுவான அம்சம் பிரேக் பாயிண்ட்கள், மேலும் அவற்றை விரிவாகக் காண்போம்.


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

மூன்று முதன்மை பிரேக் பாயிண்ட் வகைகள் உள்ளன: மென்மையான பிரேக் பாயிண்ட்கள், வன்பொருள் பிரேக் பாயிண்ட்கள் மற்றும் நினைவக பிரேக் பாயிண்ட்கள்.


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

ஒரு மென்மையான பிரேக் பாயிண்ட் என்பது ஒரு ஒற்றை-பைட் அறிவுறுத்தலாகும், இது பிழைத்திருத்தப்பட்ட செயல்முறையின் செயல்பாட்டை நிறுத்தி, பிழைத்திருத்தியின் பிரேக் பாயிண்ட் விதிவிலக்கு கையாளுபவருக்கு கட்டுப்பாட்டை அனுப்புகிறது.


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

ஒரு அசெம்பிளி அறிவுறுத்தல் என்பது CPU செயல்படுத்த வேண்டிய கட்டளையின் உயர்-நிலை பிரதிநிதித்துவமாகும்.


Think of assembly instructions as the DNS of CPUs.

அசெம்பிளி வழிமுறைகளை CPU களின் DNS ஆகக் கருதுங்கள்.


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

இந்த முகவரியில் ஒரு மென்மையான பிரேக் பாயிண்ட்டை அமைத்து CPU ஐ நிறுத்த, 2-பைட் 8BC3 ஆப்கோட்டில் இருந்து ஒரு ஒற்றை பைட்டை மாற்ற வேண்டும்.


When the debugger is told to set a breakpoint at a desired address, it reads the first opcode byte at the requested address and stores it.

பிழைத்திருத்தி விரும்பிய முகவரியில் ஒரு பிரேக் பாயிண்ட்டை அமைக்கச் சொல்லப்படும்போது, அது கோரப்பட்ட முகவரியில் முதல் ஆப்கோட் பைட்டைப் படித்து அதைச் சேமிக்கிறது.


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

இருப்பினும், மென்மையான பிரேக் பாயிண்ட்கள் ஒரு எச்சரிக்கையைக் கொண்டுள்ளன: நினைவகத்தில் செயல்படுத்தக்கூடிய ஒன்றின் பைட்டை மாற்றும்போது, இயங்கும் மென்பொருளின் சுழற்சி ரெட்ண்டன்சி சரிபார்ப்பு (CRC) சரிபார்ப்புத்தொகையை மாற்றுகிறீர்கள்.


The exploit code needs to land at a specific address.

இந்த சுரண்டல் குறியீடு ஒரு குறிப்பிட்ட முகவரியில் இறங்க வேண்டும்.


This will disable DEP for the current process.

இது தற்போதைய செயல்முறைக்கு DEP-ஐ முடக்கும்.


The script outputs the results to the Log window.

ஸ்கிரிப்ட் முடிவுகளை பதிவு சாளரத்தில் வெளியிடுகிறது.


Malware employs anti-debugging routines to prevent analysis.

தீங்கிழைக்கும் மென்பொருள் பகுப்பாய்வைத் தடுக்க எதிர்ப்பு-பிழைத்திருத்த நடைமுறைகளைப் பயன்படுத்துகிறது.


The IsDebuggerPresent function checks for a debugger.

IsDebuggerPresent செயல்பாடு ஒரு பிழைத்திருத்தியைச் சரிபார்க்கிறது.


Malware attempts to iterate through running processes.

தீங்கிழைக்கும் மென்பொருள் இயங்கும் செயல்முறைகள் மூலம் மீண்டும் மீண்டும் முயற்சிக்கிறது.


We can patch these functions to set EAX to zero.

EAX ஐ பூஜ்யமாக அமைக்க இந்த செயல்பாடுகளைப் பேட்ச் செய்யலாம்.


Hooking is a powerful process-observation technique.

ஹூக்கிங் என்பது ஒரு சக்திவாய்ந்த செயல்முறை-கண்காணிப்பு நுட்பமாகும்.


Soft hooks are useful for infrequently called functions.

மென்மையான கொக்கிகள் அடிக்கடி அழைக்கப்படாத செயல்பாடுகளுக்குப் பயனுள்ளதாக இருக்கும்.


Hard hooks have less impact on the target process.

கடினமான கொக்கிகள் இலக்கு செயல்முறையில் குறைந்த தாக்கத்தை ஏற்படுத்துகின்றன.


We will be focusing on two primary techniques.

நாங்கள் இரண்டு முதன்மை நுட்பங்களில் கவனம் செலுத்துவோம்.


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

உள்நுழைவு கொக்கிகள் என்ன அளவுருக்கள் அனுப்பப்படுகின்றன என்பதைப் பார்க்கப் பயனுள்ளதாக இருக்கும்.


The exit hooks are useful for trapping function return values.

வெளியேறும் கொக்கிகள் செயல்பாட்டு திரும்பும் மதிப்புகளைப் பிடிக்கப் பயனுள்ளதாக இருக்கும்.


We can see the username and password quite clearly.

பயனர்பெயரையும் கடவுச்சொல்லையும் நாம் தெளிவாகக் காணலாம்.


This technique can be applied to all kinds of debugging scenarios.

இந்த நுட்பத்தை அனைத்து வகையான பிழைத்திருத்த சூழ்நிலைகளுக்கும் பயன்படுத்தலாம்.


செயல்முறை மெதுவாக ஊர்ந்து செல்லும்.


கடினமான கொக்கி போடுதல் மிகவும் மேம்பட்டது.


Immunity Debugger exposes a FastLogHook object.

இம்யூனிட்டி டீபக்கர் ஒரு FastLogHook பொருளை வெளிப்படுத்துகிறது.


The logFunction() method is required to set up the hook.

கொக்கியை அமைப்பதற்கு logFunction() முறை தேவைப்படுகிறது.


The logging functions have the following prototypes.

பதிவு செய்யும் செயல்பாடுகள் பின்வரும் முன்மாதிரிகளைக் கொண்டுள்ளன.


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.

ஃபசர் தேர்ந்தெடுக்கப்பட்ட கோப்பில் மாற்றங்களைச் செய்கிறது.


The debugger thread loads the target application.

பிழைத்திருத்தி நூல் இலக்கு பயன்பாட்டை ஏற்றுகிறது.


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

கண்காணிப்பு நூல், நியாயமான நேரத்திற்குப் பிறகு பயன்பாடு முடிவடைகிறது என்பதை உறுதி செய்கிறது.


The fuzzer increments the iteration count.

ஃபசர் மறுபடியும் எண்ணிக்கையை அதிகரிக்கிறது.


The mutate_file function modifies the file's contents.

mutate_file செயல்பாடு கோப்பின் உள்ளடக்கங்களை மாற்றியமைக்கிறது.


A test case is selected randomly from a list.

ஒரு சோதனை வழக்கு பட்டியலிலிருந்து தோராயமாக தேர்ந்தெடுக்கப்படுகிறது.


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

சோதனை வழக்கு கோப்பில் ஒரு தோராயமான இடத்தில் பயன்படுத்தப்படுகிறது.


ஃபசர் மாற்றப்பட்ட கோப்பை எழுதுகிறது.


The debugger thread uses the mutated file to test the application.

பிழைத்திருத்தி நூல் பயன்பாட்டை சோதிக்க மாற்றப்பட்ட கோப்பைப் பயன்படுத்துகிறது.


The -e flag specifies the path to the executable.

-e கொடி, செயல்படுத்தக்கூடிய கோப்பிற்கான பாதையை குறிப்பிடுகிறது.


The -x option specifies the file extension.

-x விருப்பம் கோப்பு நீட்டிப்பை குறிப்பிடுகிறது.


-n அளவுரு அறிவிப்புகளை இயக்குகிறது.


The fuzzer is tested by watching the results.

முடிவுகளைப் பார்த்து ஃபசர் சோதிக்கப்படுகிறது.


Create examples and crashes directories.

எடுத்துக்காட்டுகள் மற்றும் செயலிழப்பு கோப்பகங்களை உருவாக்கவும்.


The fuzzer can be run against any target application.

எந்த இலக்கு பயன்பாட்டிற்கும் எதிராக ஃபசரை இயக்க முடியும்.


Code coverage measures how much code is executed.

குறியீடு கவரேஜ் எவ்வளவு குறியீடு செயல்படுத்தப்படுகிறது என்பதை அளவிடுகிறது.


Automated static analysis can find hot spots.

தானியங்கி நிலையான பகுப்பாய்வு ஹாட் ஸ்பாட்களைக் கண்டறிய முடியும்.


Sulley is a Python-based fuzzing framework.

சுல்லி ஒரு பைத்தான் அடிப்படையிலான ஃபஸிங் கட்டமைப்பு ஆகும்.


சுல்லி பிளாக் அடிப்படையிலான ஃபஸிங்கைப் பயன்படுத்துகிறது.


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

உங்கள் ஹூக்கின் முடிவுகளைப் பெற, getAllLog() என்ற wrapper செயல்பாட்டைப் பயன்படுத்தி இந்தப் பக்கத்தை நீங்கள் வினவ வேண்டும்.


So each time a hooked function gets hit, its address is stored in hook_address, and all the information you requested is contained in tuple form in the second entry.

எனவே, ஒவ்வொரு முறையும் ஒரு ஹூக் செய்யப்பட்ட செயல்பாடு தாக்கும்போது, அதன் முகவரி hook_address இல் சேமிக்கப்படுகிறது, மேலும் நீங்கள் கோரிய அனைத்து தகவல்களும் இரண்டாவது உள்ளீட்டில் டியூபிள் வடிவத்தில் உள்ளன.


An excellent example of harnessing the power of the hard hook is the hippie 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 எனப்படும் ஒரு எளிய பதிப்பை உருவாக்குவோம்.


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.

இது நிக்கோவின் செயல்பாடு, இது நமக்குத் தேவையான ret வழிமுறையைக் கொண்ட சரியான அடிப்படைத் தொகுதியைத் தேடுகிறது.


A simple wrapper to just print out the hook results in a friendly manner.

ஹூக் முடிவுகளை ஒரு நட்பு முறையில் அச்சிட ஒரு எளிய wrapper.


We have previously set hooks, so we must want to print the results.

முன்பு நாங்கள் ஹூக்குகளை அமைத்துள்ளோம், எனவே முடிவுகளை அச்சிட வேண்டும்.


We want to stop the debugger before monkeying around.

குரங்கு வேலை செய்வதற்கு முன், பிழைத்திருத்தியை நிறுத்த விரும்புகிறோம்.


Store the hook object so we can retrieve results later.

ஹூக் பொருளை சேமிக்கவும், இதன் மூலம் நாங்கள் பின்னர் முடிவுகளைப் பெறலாம்.


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 வரிகளுக்குக் குறைவான குறியீட்டில், நாங்கள் ஒரு சக்திவாய்ந்த ஹூக்கிங் நுட்பத்தைப் பயன்படுத்தியுள்ளோம் - ஒரு கம்பைலர் அல்லது வேறு எந்த கருவிகளையும் பயன்படுத்தாமல்.


Let’s use notepad.exe and see if Nico was accurate about the 4,500 calls when you open a file dialog.

notepad.exe ஐப் பயன்படுத்துவோம், மேலும் நீங்கள் ஒரு கோப்பு உரையாடலைத் திறக்கும்போது 4,500 அழைப்புகள் பற்றி நிக்கோ துல்லியமாக இருந்தாரா என்று பார்ப்போம்.


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

எங்களிடம் சில முடிவுகள் உள்ளன, மேலும் நீங்கள் Immunity Debugger இல் உள்ள நிலை பட்டையைப் பார்த்தால், அது ஹிட்களின் எண்ணிக்கையைக் காண்பிக்கும்.


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

உங்கள் தலைகீழ் முயற்சிகளில் நீங்கள் சந்தேகத்திற்கு இடமின்றி எண்ணற்ற முறை பயன்படுத்தும் ஒன்று ஹூக்கிங் ஆகும்.


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

சில சக்திவாய்ந்த ஹூக்கிங் நுட்பங்களை எவ்வாறு பயன்படுத்துவது என்பதை நாங்கள் நிரூபித்துள்ளோம், ஆனால் அவற்றை தானியக்கமாக்கியுள்ளோம்.


Now that you know how to effectively observe execution points via hooking, it’s time to learn how to manipulate the processes we are studying.

ஹூக்கிங் மூலம் செயல்படுத்தும் புள்ளிகளை எவ்வாறு திறம்பட கவனிப்பது என்பதை நீங்கள் இப்போது அறிந்திருக்கிறீர்கள், நாம் படிக்கும் செயல்முறைகளை எவ்வாறு கையாள்வது என்பதை அறிய வேண்டிய நேரம் இது.


We will create some simple utilities in Python that will enable you to harness both techniques so that you can easily implement them at will.

இரண்டு நுட்பங்களையும் பயன்படுத்த உங்களை அனுமதிக்கும் சில எளிய பயன்பாடுகளை பைத்தானில் உருவாக்குவோம், இதன் மூலம் அவற்றை நீங்கள் எளிதாக செயல்படுத்த முடியும்.


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 அடிப்படையில் ஒரு செயல்முறையை அழிக்க வடிவமைக்கப்பட்ட ஷெல்-குறியீட்டின் ஒரு பகுதியை சோதிக்க குறியீடு ஊசியைப் பயன்படுத்துவோம்.


Using an alternate data stream, we are hiding the DLL from the user’s immediate view.

மாற்று தரவு நீரோடையைப் பயன்படுத்தி, DLL ஐ பயனரின் உடனடி பார்வையில் இருந்து மறைக்கிறோம்.


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

சிறப்பு கருவிகள் இல்லாமல், ஒரு கணினி பயனர் ADS களின் உள்ளடக்கத்தை பார்க்க முடியாது, இது நமக்கு ஏற்றது.


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

கூடுதலாக, பல பாதுகாப்பு தயாரிப்புகள் மாற்று தரவு நீரோடைகளை சரியாக ஸ்கேன் செய்யாது, எனவே கண்டறிதலைத் தவிர்க்க அவற்றின் ரேடாரின் கீழ் நழுவ எங்களுக்கு நல்ல வாய்ப்பு உள்ளது.


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

ஒரு கோப்பில் மாற்று தரவு நீரோடையைப் பயன்படுத்த, ஏற்கனவே உள்ள கோப்பில் ஒரு பெருங்குடல் மற்றும் கோப்பு பெயரைச் சேர்க்க வேண்டும், அதாவது: reverser.exe:vncdll.dll


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

இந்த வழக்கில், நாங்கள் vncdll.dll ஐ அணுகுகிறோம், இது reverser.exe உடன் இணைக்கப்பட்ட மாற்று தரவு நீரோடையில் சேமிக்கப்படுகிறது.


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

ஒரு கோப்பை படித்து, நாம் தேர்ந்தெடுத்த கோப்பில் இணைக்கப்பட்ட ADS க்கு எழுதுகிற ஒரு விரைவான பயன்பாட்டு ஸ்கிரிப்டை எழுதுவோம்.


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

file_hider.py எனப்படும் ஒரு கூடுதல் பைதான் ஸ்கிரிப்டைத் திறந்து, பின்வரும் குறியீட்டை உள்ளிடவும்.


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

முதல் கட்டளை வரி வாதம் நாம் படிக்க விரும்பும் DLL ஆகும், இரண்டாவது வாதம் இலக்கு கோப்பாகும், அதில் நாங்கள் DLL ஐ சேமிப்போம்.


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

செயல்படுத்தக்கூடிய கோப்புடன் எந்த வகையான கோப்புகளையும் சேமிக்க இந்த சிறிய பயன்பாட்டைப் பயன்படுத்தலாம், மேலும் ADS இலிருந்து நேரடியாக DLL களைச் செலுத்தலாம்.


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

எங்கள் பின் கதவுக்காக DLL செலுத்துதலைப் பயன்படுத்தாவிட்டாலும், அது இன்னும் அதை ஆதரிக்கும், எனவே தொடர்ந்து படிக்கவும்.


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

எங்கள் விருப்பப்படி ஒரு பயன்பாட்டைத் தொடங்கும் எங்கள் செயல்படுத்தல் மறுதிசைப்பு குறியீட்டை உருவாக்குவதன் மூலம் ஆரம்பிக்கலாம்.


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

இது செயல்படுத்தல் மறுதிசைப்பு என்று அழைக்கப்படுவதற்கான காரணம் என்னவென்றால், எங்கள் பின் கதவை calc.exe என்று பெயரிட்டு, அசல் calc.exe ஐ வேறொரு இடத்திற்கு நகர்த்துவோம்.


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

பயனர் கால்குலேட்டரைப் பயன்படுத்த முயற்சிக்கும்போது, அவர் அறியாமல் எங்கள் பின் கதவை இயக்குவார், இது சரியான கால்குலேட்டரைத் தொடங்கி, எதுவும் தவறுதலாக இல்லை என்பதை பயனருக்கு எச்சரிக்காது.


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

அத்தியாயம் 3 இல் உள்ள my_debugger_defines.py கோப்பை நாங்கள் உள்ளடக்குகிறோம் என்பதை நினைவில் கொள்க, இதில் செயல்முறையை உருவாக்க தேவையான அனைத்து மாறிலிகளும் கட்டமைப்புகளும் உள்ளன.


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

புதிய பைதான் கோப்பைத் திறந்து, அதற்கு backdoor.py எனப் பெயரிட்டு, பின்வரும் குறியீட்டை உள்ளிடவும்.


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

இந்த நூலகம் அத்தியாயம் 3 இல் இருந்து வந்தது மற்றும் செயல்முறையை உருவாக்குவதற்கு தேவையான அனைத்து வரையறைகளையும் கொண்டுள்ளது.


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

DLL செலுத்தும் குறியீட்டிற்குள் செல்வதற்கு முன், செலுத்துவதற்கு அதைப் பயன்படுத்துவதற்கு முன்பு DLL ஐ எவ்வாறு மறைக்க முடியும் என்பதை ஆராயப் போகிறோம்.


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

எங்கள் செலுத்தும் குறியீட்டைப் பின் கதவில் சேர்ப்போம்; செயல்முறை உருவாக்கும் பிரிவுக்குப் பிறகு அதைச் சேர்க்கவும்.


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

எங்கள் செலுத்தும் செயல்பாடு குறியீடு அல்லது DLL செலுத்துதலையும் கையாள முடியும்; அளவுரு கொடியை 1 ஆக அமைத்தால், தரவு மாறி DLLக்கான பாதையை கொண்டிருக்கும்.


We aren’t going for clean here; we’re going for quick and dirty.

நாங்கள் இங்கு சுத்தமாகச் செல்லவில்லை; நாங்கள் விரைவாகவும் அழுக்காகவும் செல்கிறோம்.


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 ஐப் பார்க்கவும்.


CWD <DIRECTORY> - change working directory to DIRECTORY

CWD <DIRECTORY> - பணிபுரியும் கோப்பகத்தை DIRECTORY ஆக மாற்றவும்


DELE <FILENAME> - delete a remote file FILENAME

DELE <FILENAME> - தொலைதூர கோப்பை FILENAME நீக்கவும்


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

MDTM <FILENAME> - கோப்பு FILENAME இன் கடைசியாக மாற்றியமைக்கப்பட்ட நேரத்தை திருப்பி அனுப்பவும்


MKD <DIRECTORY> - create directory DIRECTORY

MKD <DIRECTORY> - கோப்பகத்தை உருவாக்கு DIRECTORY


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

இது ஒரு முழுமையான பட்டியல் அல்ல, ஆனால் இது நமக்கு சில கூடுதல் கவரேஜை அளிக்கிறது, எனவே நமக்குத் தெரிந்ததை எடுத்து அதை ஒரு சுல்லி நெறிமுறை விளக்கமாக மொழிபெயர்ப்போம்.


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

சுல்லியை ஒரு மெலிந்த, சராசரி FTP சேவையகமாக மாற்ற, சுல்லி தரவு பிரைமிடிவ்களைப் பற்றிய நமது அறிவைப் பயன்படுத்துவோம்.


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

உங்கள் குறியீடு எடிட்டரைத் தயார் செய்து, ftp.py என்ற புதிய கோப்பை உருவாக்கி, பின்வரும் குறியீட்டை உள்ளிடவும்.


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

நெறிமுறை எலும்புக்கூடு இப்போது உருவாக்கப்பட்டது, நமது அனைத்து கோரிக்கை தகவல்களையும் ஒன்றாக இணைக்கும் மற்றும் நெட்வொர்க் ஸ்னிஃபர் மற்றும் பிழைத்திருத்த கிளையண்ட்டை அமைக்கும் ஒரு சுல்லி அமர்வை உருவாக்குவதற்கு நகர்வோம்.


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

சுல்லி அமர்வுகள் என்பது கோரிக்கைகளை ஒன்றிணைக்கும் மற்றும் நெட்வொர்க் பாக்கெட் கைப்பற்றல், செயல்முறை பிழைத்திருத்தம், செயலிழப்பு அறிக்கை மற்றும் மெய்நிகர் இயந்திரக் கட்டுப்பாடு ஆகியவற்றைக் கவனித்துக்கொள்ளும் வழிமுறையாகும்.


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.

எந்த ஃபஸ் தரவையும் அனுப்புவதற்கு முன் FTP பேனரைப் பெற சுல்லிக்குச் சொல்லும் sess.pre_send சொத்துக்கு இதை இணைக்கிறோம்.


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

அமர்வை உருவாக்குவதற்கான முதல் படி, எங்கள் ஃபஸரின் தற்போதைய நிலையைக் கண்காணிக்கும் அமர்வு கோப்பை வரையறுப்பதாகும்.


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

இரண்டாவது படி தாக்குதலுக்கான இலக்கை வரையறுப்பதாகும், இது ஒரு IP முகவரி மற்றும் போர்ட் எண் ஆகும்.


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

நாங்கள் 192.168.244.133 மற்றும் போர்ட் 21 ஐத் தாக்குகிறோம், இது எங்கள் WarFTPD நிகழ்வாகும் (இந்த விஷயத்தில் ஒரு மெய்நிகர் இயந்திரத்தில் இயங்குகிறது).


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

மூன்றாவது நுழைவு, எங்கள் நெட்வொர்க் ஸ்னிஃபர் அதே ஹோஸ்டில் அமைக்கப்பட்டுள்ளது மற்றும் TCP போர்ட் 26001 இல் கேட்கிறது என்று சுல்லிக்குக் கூறுகிறது, இது சுல்லியிடமிருந்து கட்டளைகளை ஏற்றுக்கொள்ளும் போர்ட் ஆகும்.


We then add the defined target to our parent session.

பின்னர் வரையறுக்கப்பட்ட இலக்கை எங்கள் பெற்றோர் அமர்வில் சேர்க்கிறோம்.


You can see that we discovered a valid device name, \Device\Beep, in three lines of code.

மூன்று வரி குறியீட்டில், \Device\Beep என்ற சரியான சாதனத்தின் பெயரை நாம் கண்டுபிடித்ததை நீங்கள் காணலாம்.


Now let’s move on to discovering the primary IOCTL dispatch function and the IOCTL codes that a driver supports.

இப்போது முதன்மை IOCTL அனுப்பும் செயல்பாடு மற்றும் ஒரு இயக்கி ஆதரிக்கும் IOCTL குறியீடுகளைக் கண்டுபிடிப்பதற்கு நகர்வோம்.


Any driver that implements an IOCTL interface must have an IOCTL dispatch routine that handles the processing of the various IOCTL requests.

IOCTL இடைமுகத்தை செயல்படுத்தும் எந்தவொரு இயக்ககமும் பல்வேறு IOCTL கோரிக்கைகளை செயலாக்குவதை கையாளும் ஒரு IOCTL அனுப்பும் வழக்கத்தைக் கொண்டிருக்க வேண்டும்.


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

ஒரு இயக்கி ஏற்றப்படும்போது, அழைக்கப்படும் முதல் செயல்பாடு DriverEntry வழக்கமாகும்.


This line is telling the driver that the IOCTLDispatch function handles all IOCTL requests.

இந்த வரி, IOCTLDispatch செயல்பாடு அனைத்து IOCTL கோரிக்கைகளையும் கையாளுகிறது என்று இயக்கிக்குக் கூறுகிறது.


Using these instructions, we can then deduce where the IOCTL-handling routine lives.

இந்த வழிமுறைகளைப் பயன்படுத்தி, IOCTL-ஐக் கையாளும் வழக்கமான செயல்பாடு எங்குள்ளது என்பதை நாம் பின்னர் அறியலாம்.


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

இந்த குறியீடு, எங்கள் தேடல் அளவுகோல்களுக்கு எதிராக சாத்தியமான அனைத்து பொருத்தங்களையும் கண்டறிய, Immunity Debugger இன் சக்திவாய்ந்த தேடல் API ஐ பயன்படுத்துகிறது.


Once we have found a match, we send a Function object back that represents the IOCTL dispatch function where our hunt for valid IOCTL codes will begin.

ஒரு பொருத்தம் கிடைத்தவுடன், சரியான IOCTL குறியீடுகளுக்கான எங்கள் வேட்டை தொடங்கும் IOCTL அனுப்பும் செயல்பாட்டைப் பிரதிநிதித்துவப்படுத்தும் ஒரு செயல்பாடு பொருளை நாங்கள் அனுப்புகிறோம்.


Next let’s take a look at the IOCTL dispatch function itself and how to apply some simple heuristics to try to find all of the IOCTL codes a device supports.

அடுத்து, IOCTL அனுப்பும் செயல்பாட்டைப் பற்றியும், ஒரு சாதனம் ஆதரிக்கும் அனைத்து IOCTL குறியீடுகளையும் கண்டுபிடிக்க சில எளிய யூகங்களை எவ்வாறு பயன்படுத்துவது என்பதையும் பார்ப்போம்.


The IOCTL dispatch routine commonly will perform various actions based on the value of the code being passed in to the routine.

IOCTL அனுப்பும் வழக்கமானது, வழக்கத்திற்கு அனுப்பப்படும் குறியீட்டின் மதிப்பின் அடிப்படையில் பல்வேறு செயல்களைச் செய்யும்.


We want to be able to exercise each of the possible paths that are determined by the IOCTL code, which is why we go to all the trouble of finding these values.

IOCTL குறியீட்டின் மூலம் தீர்மானிக்கப்படும் ஒவ்வொரு சாத்தியமான பாதையையும் செயல்படுத்த நாங்கள் விரும்புகிறோம், அதனால்தான் இந்த மதிப்புகளைக் கண்டுபிடிப்பதில் நாங்கள் சிரமப்படுகிறோம்.


Let’s first examine what the C source code for a skeleton IOCTL dispatch function would look like, and then we’ll see how to decode the assembly to retrieve the IOCTL code values.

ஒரு எலும்புக்கூடு IOCTL அனுப்பும் செயல்பாட்டிற்கான C மூலக் குறியீடு எப்படி இருக்கும் என்பதை முதலில் ஆராய்வோம், பின்னர் 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 கோரிக்கையிலிருந்து பெறப்பட்டதும், இயக்கி எந்தச் செயலைச் செய்ய வேண்டும் என்பதைத் தீர்மானிக்க ஒரு சுவிட்ச் அறிக்கை இருப்பதைப் பார்ப்பது பொதுவானது.


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 குறியீடாக இருக்க வேண்டும்.


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!

driverlib எவ்வாறு நம்முடைய சில அழுக்கு வேலைகளைச் செய்கிறது என்பதை இப்போது அறிந்தவுடன், அதை நாம் பயன்படுத்திக் கொள்வோம்!


Listing 11-1. Cross References to sprintf

பட்டியல் 11-1. sprintf-க்கான குறுக்கு குறிப்புகள்.


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

பட்டியலிடப்பட்ட அனைத்து முகவரிகளும் sprintf செயல்பாடு அழைக்கப்படும் இடங்களாகும்.


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

நீங்கள் IDA வரைபடக் காட்சியில் அந்த முகவரிகளை உலாவினால், படம் 11-3 இல் காட்டப்பட்டுள்ளபடி, அந்த அறிவுறுத்தல் வண்ணத்தில் இருப்பதை நீங்கள் பார்க்கலாம்.


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

படம் 11-3: cross_ref.py ஸ்கிரிப்டிலிருந்து வண்ணத்தில் காட்டப்படும் sprintf அழைப்பு.


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

ஒரு இலக்கு பைனரியில் டைனமிக் பகுப்பாய்வைச் செய்யும்போது, இலக்கு செயல்படுத்தக்கூடியதை நீங்கள் பயன்படுத்தும் போது என்ன குறியீடு செயல்படுத்தப்படுகிறது என்பதைப் புரிந்துகொள்வது மிகவும் பயனுள்ளதாக இருக்கும்.


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

ஒரு இலக்கு பைனரியில் உள்ள அனைத்து செயல்பாடுகளையும் மீண்டும் மீண்டும் செய்ய IDAPython ஐப் பயன்படுத்துவோம், மேலும் ஒவ்வொரு முகவரியின் தலைப்பிலும் பிரேக் பாயிண்ட்களை அமைப்போம்.


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

ஒரு புதிய பைதான் கோப்பைத் திறந்து, அதற்கு func_coverage.py எனப் பெயரிட்டு, பின்வரும் குறியீட்டை உள்ளிடவும்.


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

முதலில், எங்கள் பிழைத்திருத்தி கொக்கியை அமைத்தோம், இதனால் பிழைத்திருத்தி நிகழ்வு எப்போது வீசப்பட்டாலும் அது அழைக்கப்படும்.


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

பின்னர், அனைத்து செயல்பாட்டு முகவரிகளையும் மீண்டும் மீண்டும் செய்து, ஒவ்வொரு முகவரியிலும் ஒரு பிரேக் பாயிண்ட்டை அமைக்கிறோம்.


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

SetBptAttr அழைப்பு, ஒவ்வொரு பிரேக் பாயிண்ட்டும் தாக்கும்போது நிறுத்த வேண்டாம் என்று பிழைத்திருத்திக்குச் சொல்ல ஒரு கொடியை அமைக்கிறது.


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

பின்னர், அமைக்கப்பட்ட மொத்த பிரேக் பாயிண்ட்களின் எண்ணிக்கையை அச்சிடுகிறோம்.


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

எங்கள் பிரேக் பாயிண்ட் ஹேண்ட்லர், ea மாறியைப் பயன்படுத்தி, தாக்கப்பட்ட ஒவ்வொரு பிரேக் பாயிண்ட்டின் முகவரியையும் அச்சிடுகிறது.


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

இப்போது பிழைத்திருத்தியை இயக்கவும் (ஹாட்ஸ்கீ = F9), மேலும் தாக்கப்பட்ட செயல்பாடுகளைக் காட்டும் வெளியீட்டை நீங்கள் பார்க்க வேண்டும்.


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

எந்த செயல்பாடுகள் தாக்கப்படுகின்றன, அவை எந்த வரிசையில் செயல்படுத்தப்படுகின்றன என்பதைப் பற்றிய மிக உயர்ந்த அளவிலான பார்வையை இது உங்களுக்கு வழங்கும்.


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

சாத்தியமான பாதிப்புகளுக்காக ஒரு பைனரியை மதிப்பிடும்போது, குறிப்பிட்ட செயல்பாட்டு அழைப்புகளின் அடுக்கு அளவைப் புரிந்துகொள்வது முக்கியம்.


Let’s write some code to iterate through all of the functions in a binary and show us all functions that have stack-allocated buffers that may be of interest.

ஒரு பைனரியில் உள்ள அனைத்து செயல்பாடுகளையும் மீண்டும் மீண்டும் செய்து, ஆர்வமாக இருக்கக்கூடிய அடுக்கு ஒதுக்கப்பட்ட இடையகங்களைக் கொண்ட அனைத்து செயல்பாடுகளையும் நமக்குக் காட்ட சில குறியீடுகளை எழுதுவோம்.


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

ஒரு அடுக்கு மாறியை ஒரு இடையகமாகக் கருதுவதற்கு முன், அது எவ்வளவு பெரியதாக இருக்க வேண்டும் என்பதைத் தீர்மானிக்கும் ஒரு அளவு வரம்பை அமைக்கிறோம்.


We then begin iterating through all of the functions, obtaining the stack frame object for each function.

பின்னர், அனைத்து செயல்பாடுகளையும் மீண்டும் மீண்டும் செய்யத் தொடங்குகிறோம், ஒவ்வொரு செயல்பாட்டிற்கும் அடுக்கு சட்டக பொருளைப் பெறுகிறோம்.


Using the stack frame object, we use the GetStrucSize method to determine the size of the stack frame in bytes.

அடுக்கு சட்டக பொருளைப் பயன்படுத்தி, பைட்டுகளில் அடுக்கு சட்டகத்தின் அளவை தீர்மானிக்க GetStrucSize முறையைப் பயன்படுத்துகிறோம்.


You should now have the fundamentals for using IDAPython and have some core utility scripts that you can easily extend, combine, or enhance.

நீங்கள் இப்போது IDAPython ஐப் பயன்படுத்துவதற்கான அடிப்படைகளைக் கொண்டிருக்க வேண்டும் மற்றும் சில முக்கிய பயன்பாட்டு ஸ்கிரிப்ட்களை எளிதாக நீட்டிக்கவும், இணைக்கவும் அல்லது மேம்படுத்தவும் முடியும்.


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.

என்எஸ்ஏ-க்கு கட்டுப்பாடற்ற அணுகலை வழங்கியதற்காக டெலிகாம் நிறுவனமான ஏடி&டி-க்கு எதிராக EFF வழக்கு தொடர்ந்துள்ளது.


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 is working to ensure that international treaties do not restrict our free speech.

சர்வதேச ஒப்பந்தங்கள் நமது பேச்சுரிமை, அந்தரங்கம் அல்லது டிஜிட்டல் நுகர்வோர் உரிமைகளை கட்டுப்படுத்தாது என்பதை உறுதிப்படுத்த EFF செயல்படுகிறது.


Hacking is the art of creative problem solving.

ஹேக்கிங் என்பது ஆக்கபூர்வமான சிக்கல் தீர்க்கும் கலை.


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

உள்ளடக்கிய லைவ்சிடியைப் பயன்படுத்தி, குறியீட்டை டீபக் செய்வதில் ஈடுபடுங்கள்.


Author Michal Zalewski has long been known and respected.

ஆசிரியர் மைக்கேல் ஜலேவ்ஸ்கி நீண்ட காலமாக அறியப்பட்டவர் மற்றும் மதிக்கப்படுபவர்.


This book is truly unlike anything else out there.

இந்த புத்தகம் உண்மையில் வேறு எதையும் போல இல்லை.


Security data visualization tools offer graphical windows.

பாதுகாப்பு தரவு காட்சிப்படுத்தல் கருவிகள் வரைகலை சாளரங்களை வழங்குகின்றன.


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

வாசகர்கள் சிக்கலான தரவு தொகுப்புகளை ஒரு பார்வையில் புரிந்து கொள்ள முடியும்.


Python is powerful but has a very gentle learning curve.

பைத்தான் சக்தி வாய்ந்தது, ஆனால் மிகவும் மென்மையான கற்றல் வளைவைக் கொண்டுள்ளது.


Playing with Python teaches computer programming to non-programmers.

பைத்தானுடன் விளையாடுவது கணினி நிரலாக்கத்தை நிரலாக்காதவர்களுக்குக் கற்பிக்கிறது.


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

ஐடிஏ ப்ரோ புத்தகம் முதல் படிகள் உட்பட அனைத்தையும் உள்ளடக்கியது.


You’ll learn to identify known library routines.

அறியப்பட்ட நூலக நடைமுறைகளை அடையாளம் காண நீங்கள் கற்றுக்கொள்வீர்கள்.


Visit http://www.nostarch.com/ghpython.htm for updates.

புதுப்பிப்புகளுக்கு http://www.nostarch.com/ghpython.htm ஐப் பார்வையிடவும்.


The book uses a RepKover binding, which allows it to lay flat when open.

புத்தகம் RepKover பைண்டிங்கைப் பயன்படுத்துகிறது, இது திறந்திருக்கும்போது தட்டையாக இருக்க அனுமதிக்கிறது.


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.

பின்னர், செயல்பாட்டில் உள்ள 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.

செயல்படுத்தக்கூடிய பேக்கர்கள் அல்லது கம்ப்ரசர்கள் நீண்ட காலமாக உள்ளன.


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

ஒரு வழக்கமான பேக்கர், இலக்கு பைனரியின் குறியீடு மற்றும் தரவுப் பகுதிகளை சுருக்கி, நுழைவுப் புள்ளியை ஒரு டிகம்ப்ரஸருடன் மாற்றும்.


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

பைனரி செயல்படுத்தப்படும்போது, டிகம்ப்ரசர் இயங்குகிறது, இது அசல் பைனரியை நினைவகத்தில் டிகம்ப்ரஸ் செய்து, பின்னர் பைனரியின் அசல் நுழைவுப் புள்ளிக்கு (OEP) தாவுகிறது.


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

ஒரு பேக் செய்யப்பட்ட செயல்படுத்தக்கூடிய கோப்பை எதிர்கொள்ளும் போது, உண்மையான பைனரியை திறம்பட பகுப்பாய்வு செய்ய, ஒரு தலைகீழ் பொறியாளர் முதலில் பேக்கரை அகற்ற வேண்டும்.


This is where using an emulator can be beneficial, as no debugger is being attached to the running executable; we are simply running the code inside the emulator and waiting for the decompression routine to finish.

எந்த பிழைத்திருத்தியும் இயங்கும் செயல்படுத்தக்கூடிய கோப்புடன் இணைக்கப்படாததால், ஒரு எமுலேட்டரைப் பயன்படுத்துவது இங்கே பயனுள்ளதாக இருக்கும்; நாங்கள் எமுலேட்டருக்குள் குறியீட்டை இயக்குகிறோம் மற்றும் டிகம்ப்ரஷன் வழக்கத்தை முடிக்கக் காத்திருக்கிறோம்.


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 ஸ்கிரிப்டைப் பயன்படுத்துவோம்.


UPX is a free, open source executable packer that works on Linux, Windows, and a host of other executable types.

UPX என்பது இலவச, திறந்த மூல செயல்படுத்தக்கூடிய பேக்கர் ஆகும், இது லினக்ஸ், விண்டோஸ் மற்றும் பல செயல்படுத்தக்கூடிய வகைகளில் வேலை செய்கிறது.


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

இது விண்டோஸ் கால்குலேட்டரின் சுருக்கப்பட்ட பதிப்பை உருவாக்கி, அதை உங்கள் C: கோப்பகத்தில் சேமிக்கும்.


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

எங்களிடம் இப்போது PyEmu ஹார்னஸில் சோதிக்க முழுமையாக பேக் செய்யப்பட்ட கோப்பு உள்ளது, எனவே குறியீட்டை எழுதுவோம்!