The strings utility extracts human-readable strings from a binary file.

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


Malware authors often use obfuscation techniques to hide strings.

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


FLOSS is a tool designed to identify and extract obfuscated strings from malware.

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


Packers and cryptors are used to obfuscate executable files.

பேக்கர்கள் மற்றும் கிரிப்டர்கள் செயல்படுத்தக்கூடிய கோப்புகளை மறைக்கப் பயன்படுகின்றன.


Examining the PE header yields a wealth of information about the binary.

PE தலைப்பை ஆராய்வது பைனரி பற்றிய ஏராளமான தகவல்களை அளிக்கிறது.


Inspect the DLLs and API functions to understand malware functionality.

தீம்பொருள் செயல்பாட்டைப் புரிந்துகொள்ள DLLகள் மற்றும் API செயல்பாடுகளை ஆய்வு செய்யுங்கள்.


Malware often imports functions from various DLLs.

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


The import table in the PE file stores file dependencies.

PE கோப்பில் உள்ள இறக்குமதி அட்டவணை கோப்பு சார்ந்திருப்புகளை சேமிக்கிறது.


Exported functions can give you a quick idea of the DLL's capabilities.

ஏற்றுமதி செய்யப்பட்ட செயல்பாடுகள் DLL இன் திறன்களைப் பற்றிய ஒரு விரைவான யோசனையை உங்களுக்கு வழங்க முடியும்.


Attackers may use random export names to mislead analysis.

ஆക്രമப்பாளர்கள் பகுப்பாய்வை தவறாக வழிநடத்த சீரற்ற ஏற்றுமதி பெயர்களைப் பயன்படுத்தலாம்.


The PE file is divided into sections representing code or data.

PE கோப்பு குறியீடு அல்லது தரவைக் குறிக்கும் பிரிவுகளாகப் பிரிக்கப்பட்டுள்ளது.


Examine the section table to identify anomalies in the PE file.

PE கோப்பில் உள்ள முரண்பாடுகளை அடையாளம் காண பிரிவு அட்டவணையை ஆராயுங்கள்.


The compilation timestamp can help in building a timeline of the attack.

தொகுப்பு நேர முத்திரை தாக்குதலின் காலவரிசையை உருவாக்க உதவும்.


Resources like icons and strings are stored in the resource section.

சின்னங்கள் மற்றும் சரங்கள் போன்ற வளங்கள் வளப் பிரிவில் சேமிக்கப்படுகின்றன.


Resource Hacker is a tool to examine and extract resources.

வளங்களை ஆராய்ந்து பிரித்தெடுப்பதற்கான ஒரு கருவி ரிசோர்ஸ் ஹேக்கர் ஆகும்.


Fuzzy hashing is a great method to compare files for similarity.

கோப்புகளை ஒத்த தன்மைக்காக ஒப்பிடுவதற்கு மங்கலான ஹாஷிங் ஒரு சிறந்த முறையாகும்.


ssdeep is a useful tool to generate fuzzy hashes.

ssdeep என்பது மங்கலான ஹாஷ்களை உருவாக்க ஒரு பயனுள்ள கருவியாகும்.


Comparing the suspect binary with known samples helps in classification.

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


Malware authors often change aspects to evade detection.

தீம்பொருள் உருவாக்குநர்கள் பெரும்பாலும் கண்டறிதலைத் தவிர்க்க அம்சங்களை மாற்றுகிறார்கள்.


Understanding PE file structure is crucial for malware analysis.

தீம்பொருள் பகுப்பாய்வுக்கு PE கோப்பு கட்டமைப்பை புரிந்துகொள்வது முக்கியம்.


சரி என்பதைக் கிளிக் செய்யவும்.


The Linux VM is configured to use Host-only mode.

லினக்ஸ் விஎம் ஹோஸ்ட்-ஒன்லி பயன்முறையைப் பயன்படுத்த கட்டமைக்கப்பட்டுள்ளது.


Take a snapshot and give it a name of your choice.

ஒரு ஸ்னாப்ஷாட் எடுத்து, நீங்கள் விரும்பும் பெயரை வைக்கவும்.


It is also possible to transfer files from the host machine to the virtual machine using shared folders.

பகிர்ந்த கோப்புறைகளைப் பயன்படுத்தி ஹோஸ்ட் கணினியிலிருந்து விர்ச்சுவல் மெஷினுக்கு கோப்புகளை மாற்றுவதும் சாத்தியமாகும்.


Before setting up the Windows VM, you first need to install a Windows operating system.

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


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


Make sure you check the option to install pip and Add python.exe to Path.

பைப்பை நிறுவவும், பைத்தான்.எக்ஸை பாதையில் சேர்க்கவும் என்ற விருப்பத்தை சரிபார்க்கவும்.


Configure your Windows VM to run in Host-only network configuration mode.

ஹோஸ்ட்-ஒன்லி நெட்வொர்க் உள்ளமைவு முறையில் இயங்குவதற்கு உங்கள் விண்டோஸ் விஎம்-ஐ கட்டமைக்கவும்.


Configure the IP address of the Windows VM to 192.168.1.x.

விண்டோஸ் விஎம்-இன் ஐபி முகவரியை 192.168.1.x என கட்டமைக்கவும்.


Power on both the Linux VM and the Window VM, and make sure they can communicate with each other.

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


Windows Defender Service needs to be disabled.

விண்டோஸ் டிஃபெண்டர் சேவையை முடக்க வேண்டும்.


Press the Windows key + R to open the Run menu.

ரன் மெனுவைத் திறக்க விண்டோஸ் கீ + ஆர் அழுத்தவும்.


Take a clean snapshot so that you can revert to the pristine/clean state after every analysis.

ஒவ்வொரு பகுப்பாய்வுக்குப் பிறகும், சுத்தமான நிலைக்குத் திரும்ப, ஒரு சுத்தமான ஸ்னாப்ஷாட் எடுக்கவும்.


At this point, your lab environment should be ready.

இந்த கட்டத்தில், உங்கள் ஆய்வக சூழல் தயாராக இருக்க வேண்டும்.


You will need malware samples for performing analysis.

பகுப்பாய்வு செய்வதற்காக உங்களுக்கு தீம்பொருள் மாதிரிகள் தேவைப்படும்.


Setting up an isolated lab environment is crucial before analyzing malicious programs.

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


Static analysis is the technique of analyzing the suspect file without executing it.

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


Determining the file type of a suspect binary will help you identify the malware's target operating system.

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


File extension is not the sole indicator of file type.

கோப்பு நீட்டிப்பு கோப்பு வகையின் ஒரே அறிகுறி அல்ல.


Attackers use different tricks to hide their file by modifying the file extension.

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


The fuzzy hashing technique identified the similarity between the samples.

மங்கலான ஹாஷிங் நுட்பம் மாதிரிகளுக்கு இடையேயான ஒற்றுமையைக் கண்டறிந்தது.


You might have a directory containing many malware samples.

நீங்கள் பல தீம்பொருள் மாதிரிகளைக் கொண்ட ஒரு கோப்பகத்தை வைத்திருக்கலாம்.


You can also match a suspect binary with a list of file hashes.

நீங்கள் சந்தேகத்திற்கிடமான பைனரியை கோப்பு ஹாஷ்களின் பட்டியலுடன் பொருத்தலாம்.


In Python, the fuzzy hash can be computed using python-ssdeep.

பைத்தானில், பைத்தான்-எஸ்எஸ்டீப் பயன்படுத்தி மங்கலான ஹாஷைக் கணக்கிடலாம்.


Import Hashing is another technique that can be used to identify related samples.

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


If the files were compiled from the same source and in the same manner, those files would tend to have the same imphash value.

கோப்புகள் ஒரே மூலத்திலிருந்து மற்றும் அதே முறையில் தொகுக்கப்பட்டால், அந்த கோப்புகள் ஒரே இம்ஹாஷ் மதிப்பைக் கொண்டிருக்கும்.


During your malware investigation, if you come across samples that have the same imphash values, it means that they have the same import address table and are probably related.

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


Files having the same imphash does not necessarily mean they are from the same threat group.

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


Similar to import hashing, section hashing can also help in identifying related samples.

இறக்குமதி ஹாஷிங்கைப் போலவே, பிரிவு ஹாஷிங்கும் தொடர்புடைய மாதிரிகளை அடையாளம் காண உதவும்.


When you are analyzing a malware sample, you should consider generating the fuzzy hash, imphash, and section hashes.

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


A malware sample can contain many strings or binary indicators.

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


YARA is a powerful malware identification and classification tool.

YARA ஒரு சக்திவாய்ந்த தீம்பொருள் அடையாளம் காணும் மற்றும் வகைப்படுத்தும் கருவியாகும்.


Malware researchers can create YARA rules based on textual or binary information.

தீம்பொருள் ஆராய்ச்சியாளர்கள் உரை அல்லது பைனரி தகவல்களின் அடிப்படையில் YARA விதிகளை உருவாக்கலாம்.


The YARA rule consists of the following components: Rule identifier, String Definition, Condition Section.

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


Once you have the rule ready, the next step is to use the yara utility to scan the files.

விதி தயாரானதும், அடுத்த கட்டமாக கோப்புகளை ஸ்கேன் செய்ய yara பயன்பாட்டைப் பயன்படுத்த வேண்டும்.


The preceding YARA rule, by default will match on ASCII strings.

முந்தைய YARA விதி, இயல்பாகவே ASCII சரங்களுடன் பொருந்தும்.


If your intention is to look for strings in an executable file, you can create a rule as shown below.

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


YARA rule can also be used to detect packers.

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


YARA can be used to detect patterns in any file.

எந்த கோப்பிலும் வடிவங்களைக் கண்டறிய YARA ஐப் பயன்படுத்தலாம்.


Static analysis is the first step in malware analysis.

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


If you have found a mistake in this book, we would be grateful if you would report this to us.

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


Please visit www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.

www.packtpub.com/submit-errata என்ற இணையதளத்திற்குச் சென்று, உங்கள் புத்தகத்தைத் தேர்ந்தெடுத்து, திருத்த படிவ இணைப்பைக் கிளிக் செய்து விவரங்களை உள்ளிடவும்.


If you come across any illegal copies of our works in any form on the Internet, we would be grateful if you would provide us with the location address or website name.

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


If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.

நீங்கள் ஒரு எழுத்தாளராக விரும்பினால்: உங்களுக்கு நிபுணத்துவம் உள்ள ஒரு தலைப்பு இருந்தால், புத்தகம் எழுதுவதில் அல்லது பங்களிப்பதில் ஆர்வமாக இருந்தால், தயவுசெய்து authors.packtpub.com ஐப் பார்வையிடவும்.


Once you have read and used this book, why not leave a review on the site that you purchased it from?

இந்தப் புத்தகத்தைப் படித்துப் பயன்படுத்திய பிறகு, அதை நீங்கள் வாங்கிய தளத்தில் ஏன் ஒரு மதிப்பாய்வைச் செய்யக்கூடாது?


Potential readers can then see and use your unbiased opinion to make purchase decisions.

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


We at Packt can understand what you think about our products, and our authors can see your feedback on their book.

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


For more information about Packt, please visit packtpub.com.

பேக்ட் பற்றி மேலும் அறிய, தயவுசெய்து packtpub.com ஐப் பார்வையிடவும்.


The number of cyber attacks is undoubtedly on the rise, targeting government, military, public and private sectors.

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


These cyber attacks focus on targeting individuals or organizations with an effort to extract valuable information.

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


Sometimes, these cyber attacks are allegedly linked to cybercrime or state-sponsored groups, but may also be carried out by individual groups to achieve their goals.

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


Most of these cyber attacks use malicious software (also called malware) to infect their targets.

இந்த சைபர் தாக்குதல்களில் பெரும்பாலானவை தீங்கிழைக்கும் மென்பொருளைப் பயன்படுத்துகின்றன (மால்வேர் என்றும் அழைக்கப்படுகிறது) அவற்றின் இலக்குகளை பாதிக்கின்றன.


Knowledge, skills, and tools required to analyze malicious software are essential to detect, investigate and defend against such attacks.

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


Malware is a code that performs malicious actions; it can take the form of an executable, script, code, or any other software.

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


Attackers use malware to steal sensitive information, spy on the infected system, or take control of the system.

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


It typically gets into your system without your consent and can be delivered via various communication channels such as email, web, or USB drives.

இது பொதுவாக உங்கள் அனுமதியின்றி உங்கள் கணினியில் நுழைகிறது மற்றும் மின்னஞ்சல், வலை அல்லது USB டிரைவ்கள் போன்ற பல்வேறு தொடர்பு சேனல்கள் மூலம் வழங்கப்படலாம்.


கணினி செயல்பாடுகளை சீர்குலைத்தல்


Stealing sensitive information, including personal, business, and financial data

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


Unauthorized access to the victim's system

பாதிக்கப்பட்டவரின் கணினிக்கான அங்கீகரிக்கப்படாத அணுகல்


பாதிக்கப்பட்டவர்களை உளவு பார்த்தல்


Learning Malware Analysis explores the concepts, tools, and techniques to analyze and investigate Windows malware.

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


This book teaches the concepts, tools, and techniques to understand the behavior and characteristics of Windows malware.

இந்த புத்தகம் விண்டோஸ் தீங்கிழைக்கும் மென்பொருளின் நடத்தை மற்றும் பண்புகளைப் புரிந்துகொள்வதற்கான கருத்துக்கள், கருவிகள் மற்றும் நுட்பங்களை கற்பிக்கிறது.


Malware analysis has become a must-have skill for fighting advanced malware and targeted attacks.

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


If you are new to the field of malware analysis, this book should help you get started.

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


Whether you are learning malware analysis to perform a forensic investigation, to respond to an incident, or for fun, this book enables you to accomplish your goals.

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


If you're an incident responder, cybersecurity investigator, system administrator, malware analyst, forensic practitioner, student, or a curious security professional interested in learning or enhancing your malware analysis skills, then this book is for you.

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


Chapter 1, Introduction to Malware Analysis, introduces readers to the concept of malware analysis, types of malware analysis, and setting up an isolated malware analysis lab environment.

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


Chapter 2, Static Analysis, teaches the tools and techniques to extract metadata information from the malicious binary.

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


You'll learn how to determine various aspects of the binary without executing it.

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


Chapter 3, Dynamic Analysis, teaches the tools and techniques to determine the behavior of the malware and its interaction with the system.

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


You'll learn how to obtain the network and host-based indicators associated with the malware.

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


Chapter 4, Assembly Language and Disassembly Primer, gives a basic understanding of assembly language and teaches the necessary skills required to perform code analysis.

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


Chapter 5, Disassembly Using IDA, covers the features of IDA Pro Disassembler, and you will learn how to use IDA Pro to perform static code analysis (Disassembly ).

அத்தியாயம் 5, IDA ஐப் பயன்படுத்தி டிஸ்அசெம்பிளி, IDA Pro டிஸ்அசெம்பிளரின் அம்சங்களை உள்ளடக்கியது, மேலும் நிலையான குறியீடு பகுப்பாய்வை (டிஸ்அசெம்பிளி) செய்ய IDA Pro ஐ எவ்வாறு பயன்படுத்துவது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள்.


Chapter 6, Debugging Malicious Binaries, teaches the technique of debugging a binary using x64dbg and IDA Pro debugger.

அத்தியாயம் 6, தீங்கிழைக்கும் பைனரிகளை டீபக்கிங் செய்தல், x64dbg மற்றும் IDA Pro டீபக்கரைப் பயன்படுத்தி ஒரு பைனரியை டீபக்கிங் செய்யும் நுட்பத்தை கற்பிக்கிறது.


You will learn how to use a debugger to control the execution of a program and to manipulate a program's behavior.

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


Chapter 7, Malware Functionalities and Persistence, describes various functionalities of malware using reverse engineering.

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


It also covers various persistence methods used by the malicious programs.

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


Chapter 8, Code Injection and Hooking, teaches common code injection techniques used by the malicious programs to execute malicious code within the context of a legitimate process.

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


It also describes the hooking techniques used by the malware to redirect control to the malicious code to monitor, block, or filter an API's output.

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


You will learn how to analyze malicious programs that use code injection and hooking techniques.

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


The DLL entry point function was called, which in turn called DLLMain, containing the malicious code.

DLL நுழைவுப் புள்ளி செயல்பாடு அழைக்கப்பட்டது, இது DLLMain ஐ அழைத்தது, இதில் தீங்கிழைக்கும் குறியீடு இருந்தது.


Then rundll32.exe tries to find the address of the export function test.

பின்னர் rundll32.exe ஏற்றுமதி செயல்பாடு சோதனையின் முகவரியைக் கண்டுபிடிக்க முயற்சிக்கிறது.


Since it cannot find the address of test, the following error was displayed.

சோதனையின் முகவரியைக் கண்டுபிடிக்க முடியவில்லை என்பதால், பின்வரும் பிழை காட்டப்பட்டது.


Even though the error message was displayed, the DLL was successfully loaded.

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


Upon execution, the malware establishes an HTTP connection with the C2 domain and downloads a file.

செயல்படுத்தப்பட்டதும், தீம்பொருள் C2 களத்துடன் ஒரு HTTP இணைப்பை நிறுவி ஒரு கோப்பை பதிவிறக்குகிறது.


In this example, we will look at another malicious DLL (obe.dll).

இந்த எடுத்துக்காட்டில், மற்றொரு தீங்கிழைக்கும் DLL (obe.dll) ஐப் பார்ப்போம்.


The DLL sample was run with the following command.

DLL மாதிரி பின்வரும் கட்டளையுடன் இயக்கப்பட்டது.


Even though obe.dll was loaded into the memory of rundll32.exe, it did not trigger any behavior.

obe.dll rundll32.exe நினைவகத்தில் ஏற்றப்பட்டிருந்தாலும், அது எந்த நடத்தையையும் தூண்டவில்லை.


This is because DLL's entry point function does not implement any functionality.

ஏனெனில் DLL இன் நுழைவுப் புள்ளி செயல்பாடு எந்த செயல்பாட்டையும் செயல்படுத்தவில்லை.


On the other hand, running the sample with the DllRegisterServer function as shown below, triggered an HTTPS communication to the C2 server.

மறுபுறம், கீழே காட்டப்பட்டுள்ளபடி DllRegisterServer செயல்பாட்டுடன் மாதிரியை இயக்குவது, C2 சேவையகத்திற்கு HTTPS தொடர்பைத் தூண்டியது.


From this, it can be deduced that DLLRegisterServer implements the network functionality.

இதிலிருந்து, DllRegisterServer நெட்வொர்க் செயல்பாட்டை செயல்படுத்துகிறது என்று கருதலாம்.


You can write a script to determine all the exported functions in a DLL and call them in sequence.

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


This technique can help in understanding the functionality of each exported function.

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


The DLL used in this example was delivered via powerpoint.

இந்த எடுத்துக்காட்டில் பயன்படுத்தப்பட்ட DLL பவர்பாயிண்ட் மூலம் வழங்கப்பட்டது.


The DLL (SearchCache.dll) consists of an export function, _flushfile@16, whose functionality is to delete a file.

DLL (SearchCache.dll) _flushfile@16 என்ற ஏற்றுமதி செயல்பாட்டைக் கொண்டுள்ளது, இதன் செயல்பாடு ஒரு கோப்பை நீக்குவதாகும்.


To demonstrate the delete functionality, a test file (file_to_delete.txt) was created.

நீக்குதல் செயல்பாட்டை நிரூபிக்க, ஒரு சோதனை கோப்பு (file_to_delete.txt) உருவாக்கப்பட்டது.


After running the following command, the test file was deleted from the disk.

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


To determine the parameters and the type of parameters accepted by an export function, you will need to perform code analysis.

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


Most of the time, launching a DLL with rundll32.exe will work fine.

பெரும்பாலும், rundll32.exe உடன் ஒரு DLL ஐ இயக்குவது நன்றாக வேலை செய்யும்.


In such cases, you will have to inject the DLL into the specific process to trigger the behavior.

அத்தகைய சந்தர்ப்பங்களில், நடத்தையைத் தூண்டுவதற்கு நீங்கள் DLL ஐ குறிப்பிட்ட செயல்முறைக்குள் செலுத்த வேண்டும்.


The code will execute after the 'else' block.

'else' தொகுதியின் பிறகு குறியீடு செயல்படுத்தப்படும்.


The conditional jump will be taken if x is not equal to 0.

x ஆனது 0 க்கு சமமாக இல்லாவிட்டால் நிபந்தனைக்குட்பட்ட தாவல் எடுக்கப்படும்.


Before the 'else' block, there is an unconditional jump to 'end'.

'else' தொகுதிக்கு முன், 'end' க்கு ஒரு நிபந்தனையற்ற தாவல் உள்ளது.


If x is equal to 0, the 'else' block is skipped.

x ஆனது 0 க்கு சமமாக இருந்தால், 'else' தொகுதி தவிர்க்கப்படும்.


The code contains 'if-ElseIf-else' statements.

குறியீடு 'if-ElseIf-else' அறிக்கைகளைக் கொண்டுள்ளது.


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


The jump is taken to 'else' if x is not equal to 1.

x ஆனது 1 க்கு சமமாக இல்லாவிட்டால் 'else' க்கு தாவல் எடுக்கப்படும்.


Both unconditional jumps skip the 'else' statement.

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


Let's translate the code to its high-level equivalent.

குறியீட்டை அதன் உயர்-நிலை சமானத்திற்கு மொழிபெயர்ப்போம்.


The conditional statement is an 'if-else' statement.

நிபந்தனை அறிக்கை ஒரு 'if-else' அறிக்கை ஆகும்.


The condition in the 'if' statement was reversed.

'if' அறிக்கையில் உள்ள நிபந்தனை தலைகீழாக மாற்றப்பட்டது.


The jump will not be taken when x is equal to 0.

x ஆனது 0 க்கு சமமாக இருக்கும்போது தாவல் எடுக்கப்படாது.


The two most common types of loops are 'for' and 'while'.

மிகவும் பொதுவான இரண்டு வகையான சுழல்கள் 'for' மற்றும் 'while' ஆகும்.


The initialization statement is executed only once.

ஆரம்ப அறிவிப்பு ஒரே ஒரு முறை மட்டுமே செயல்படுத்தப்படுகிறது.


In both cases, a jump will be taken when i becomes greater than or equal to 5.

இரண்டு சந்தர்ப்பங்களிலும், i ஆனது 5 அல்லது அதற்கு அதிகமாகும் போது ஒரு தாவல் எடுக்கப்படும்.


The less than condition is reversed to greater than or equal to.

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


The code consists of two memory addresses.

குறியீடு இரண்டு நினைவக முகவரிகளைக் கொண்டுள்ளது.


x இன் மதிப்பு 1 ஆக அதிகரிக்கப்படுகிறது.


A function is a block of code that performs specific tasks.

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


The stack is organized in a Last-In-First-Out (LIFO) structure.

டுடுக்கு கடைசி-உள்-முதல்-வெளியே (LIFO) கட்டமைப்பில் ஒழுங்கமைக்கப்பட்டுள்ளது.


The memory address 0x403000 is where the value 100 is stored.

0x403000 என்ற நினைவக முகவரியில் 100 என்ற மதிப்பு சேமிக்கப்பட்டுள்ளது.


Assembly language uses addresses to access values in memory.

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


The instruction 'mov eax, [0x403000]' moves the value at memory address 0x403000 into the eax register.

'mov eax, [0x403000]' என்ற கட்டளை, 0x403000 என்ற நினைவக முகவரியில் உள்ள மதிப்பை eax பதிவேட்டில் நகர்த்துகிறது.


Square brackets in assembly indicate that the value at the memory location is being accessed.

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


During reverse engineering, you'll often encounter instructions like 'mov eax, [ebx]'.

தலைகீழ் பொறியியலின் போது, 'mov eax, [ebx]' போன்ற வழிமுறைகளை நீங்கள் அடிக்கடி சந்திப்பீர்கள்.


The 'lea' instruction loads the effective address, not the value at that address.

'lea' கட்டளை அந்த முகவரியில் உள்ள மதிப்பை அல்ல, பயனுள்ள முகவரியை ஏற்றுகிறது.


The instruction 'mov [0x403000], eax' moves the value from the eax register to memory address 0x403000.

'mov [0x403000], eax' என்ற கட்டளை, eax பதிவேட்டில் உள்ள மதிப்பை 0x403000 என்ற நினைவக முகவரிக்கு நகர்த்துகிறது.


The 'dword ptr' specifies a 4-byte value in a memory move operation.

'dword ptr' என்பது நினைவக நகர்வு செயல்பாட்டில் 4-பைட் மதிப்பை குறிப்பிடுகிறது.


Disassembly helps understand what a compiled program does.

ஒரு தொகுக்கப்பட்ட நிரல் என்ன செய்கிறது என்பதைப் புரிந்துகொள்ள டிஸ்அசெம்பிளி உதவுகிறது.


A simple C code snippet can be translated into assembly instructions.

ஒரு எளிய C குறியீடு துணுக்கை சட்டசபை வழிமுறைகளாக மொழிபெயர்க்கலாம்.


Variables in high-level languages correspond to memory addresses in assembly.

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


The eax register is often used for temporary storage during calculations.

eax பதிவேடு பெரும்பாலும் கணக்கீடுகளின் போது தற்காலிக சேமிப்பிற்குப் பயன்படுத்தப்படுகிறது.


Data types of variables can sometimes be inferred from how they are used.

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


Arithmetic operations like addition and subtraction are fundamental in assembly.

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


The 'add' instruction adds two operands and stores the result in the destination.

'add' கட்டளை இரண்டு செயற்குறிகளைச் சேர்த்து, முடிவை இலக்கில் சேமிக்கிறது.


The 'mul' instruction performs multiplication, using the eax register.

'mul' கட்டளை பெருக்கலைச் செய்கிறது, eax பதிவேட்டைப் பயன்படுத்துகிறது.


The 'div' instruction performs division, with the quotient in eax and remainder in edx.

'div' கட்டளை வகுத்தலைச் செய்கிறது, ஈவு eax இல் உள்ளது மற்றும் மீதி edx இல் உள்ளது.


Bitwise operations manipulate individual bits within a byte or word.

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


The 'not' instruction inverts all bits of an operand.

'not' கட்டளை ஒரு செயற்குறியின் அனைத்து பிட்களையும் தலைகீழாக்குகிறது.


Conditional jumps are used to implement if-else statements and loops.

நிபந்தனைக்குட்பட்ட தாவல்கள் if-else அறிக்கைகள் மற்றும் சுழல்களை செயல்படுத்தப் பயன்படுகின்றன.


From the events captured by the Process Monitor, you can see that lots of activity gets generated on a clean system.

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


When performing malware analysis, you will only be interested in the activities produced by the malware.

தீம்பொருள் பகுப்பாய்வு செய்யும் போது, தீம்பொருளால் உருவாக்கப்படும் செயல்பாடுகளில் மட்டுமே உங்களுக்கு ஆர்வம் இருக்கும்.


To reduce noise, you can use the filtering features which hides unwanted entries and allows you to filter on specific attributes.

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


To access this feature, select the Filter menu and then click on Filter (or press Ctrl + L).

இந்த அம்சத்தை அணுக, வடிகட்டி மெனுவைத் தேர்ந்தெடுத்து, வடிகட்டியில் கிளிக் செய்யவும் (அல்லது Ctrl + L ஐ அழுத்தவும்).


Even though Process Monitor is a great tool to monitor a malware's interaction with the system, it can be very noisy, and manual effort is required to filter the noise.

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


Noriben is a Python script that works in conjunction with Process Monitor and helps in collecting, analyzing, and reporting runtime indicators of the malware.

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


The advantage of using Noriben is that it comes with pre-defined filters that assist in reducing noise and allow you to focus on the malware-related events.

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


To use Noriben, download it to your Windows VM, extract it to a folder, and copy Process Monitor (Procmon.exe) into the same folder before running the Noriben.py Python script.

நோரிபெனைப் பயன்படுத்த, அதை உங்கள் விண்டோஸ் விஎம்-க்கு பதிவிறக்கம் செய்து, ஒரு கோப்புறையில் பிரித்தெடுத்து, நோரிபென்.பை பைதான் ஸ்கிரிப்டை இயக்குவதற்கு முன் செயல்முறை மானிட்டரை (Procmon.exe) அதே கோப்புறையில் நகலெடுக்கவும்.


When you run Noriben, it launches Process Monitor.

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


Once you are done with the monitoring, you can stop Noriben by pressing Ctrl + C, which will terminate Process Monitor.

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


Once terminated, Noriben stores the results in a text file (.txt) and a CSV file (.csv) in the same directory.

நிறுத்தப்பட்டதும், நோரிபென் முடிவுகளை அதே கோப்பகத்தில் ஒரு உரை கோப்பிலும் (.txt) மற்றும் ஒரு CSV கோப்பிலும் (.csv) சேமிக்கிறது.


The text file contains events segregated based on the categories (like process, file, registry, and network activity) in separate sections.

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


Also, note that the number of events is much less because it applied predefined filters that reduced most of the unwanted noise.

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


The CSV file contains all the events (process, file, registry, and network activity) sorted by the timeline (the order in which the events occurred).

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


The text file and the CSV file can give different perspectives.

உரை கோப்பு மற்றும் CSV கோப்பு வெவ்வேறு கண்ணோட்டங்களை அளிக்க முடியும்.


If you are interested in the summary of events based on the category then you can look at the text file; if you are interested in the sequence of events in the order in which it occurred then you can view the CSV file.

நீங்கள் வகையின் அடிப்படையில் நிகழ்வுகளின் சுருக்கத்தில் ஆர்வமாக இருந்தால், நீங்கள் உரை கோப்பைப் பார்க்கலாம்; நிகழ்வுகள் நடந்த வரிசையில் நீங்கள் ஆர்வமாக இருந்தால், நீங்கள் CSV கோப்பைக் காணலாம்.


When the malware is executed, you will want to capture the network traffic generated as a result of running the malware; this will help you understand the communication channel used by the malware and will also help in determining network-based indicators.

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


Wireshark is a packet sniffer that allows you to capture the network traffic.

வைர்ஷர்க் என்பது ஒரு பாக்கெட் ஸ்னிஃபர் ஆகும், இது நெட்வொர்க் போக்குவரத்தை கைப்பற்ற உங்களை அனுமதிக்கிறது.


Installation of Wireshark on the Linux VM was covered in Chapter 1, Introduction to Malware Analysis).

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


To invoke Wireshark on Linux, run the following command: $ sudo wireshark

லினக்ஸில் வைர்ஷர்க்கை அழைக்க, பின்வரும் கட்டளையை இயக்கவும்: $ sudo wireshark


The main function called the test function and passed the parameters to the test function by pushing them onto the stack.

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


The main function is known as the caller (or the calling function) and test is the callee (or the called function).

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


The main function (caller), after the function call, cleaned up the stack using add esp,8 instruction.

செயல்பாட்டு அழைப்பிற்குப் பிறகு, முக்கிய செயல்பாடு (அழைப்பவர்) add esp,8 கட்டளையைப் பயன்படுத்தி ஸ்டேக்கை சுத்தம் செய்தது.


This instruction has the effect of removing the parameters that were pushed onto the stack and adjusts the stack pointer (esp) back to where it was before the function call.

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


Most of the compiled C programs typically follow the cdecl calling convention.

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


In the cdecl convention, the caller pushes the parameters in the right-to-left order on the stack and the caller itself cleans up the stack after the function call.

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


There are other calling conventions such as stdcall and fastcall.

stdcall மற்றும் fastcall போன்ற பிற அழைப்பு மரபுகளும் உள்ளன.


In stdcall, parameters are pushed onto the stack (right- to-left order) by the caller and the callee, (called function) is responsible for cleaning up the stack.

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


Microsoft Windows utilizes the stdcall convention for the functions (API) exported by the DLL files.

Microsoft Windows, DLL கோப்புகளால் ஏற்றுமதி செய்யப்படும் செயல்பாடுகளுக்கு (API) stdcall மரபைப் பயன்படுத்துகிறது.


In the fastcall calling convention, first few parameters are passed to a function by placing them in the registers, and any remaining parameters are placed on the stack in right-to-left order and the callee cleans up the stack similar to the stdcall convention.

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


You will typically see 64-bit programs following the fastcall calling convention.

நீங்கள் பொதுவாக 64-பிட் நிரல்கள் fastcall அழைப்பு மரபைப் பின்பற்றுவதைப் பார்ப்பீர்கள்.


An array is a list consisting of the same data types.

ஒரு வரிசை என்பது ஒரே தரவு வகைகளைக் கொண்ட ஒரு பட்டியல் ஆகும்.


The array elements are stored in contiguous locations in the memory, which makes it easy to access array elements.

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


The array name nums is a pointer constant that points to the first element of the array (that is, the array name points to the base address of the array).

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


In a high-level language, to access the elements of the array, you use the array name along with the index.

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


For example, you can access the first element using nums[0], the second element using nums[1], and so on.

உதாரணமாக, நீங்கள் nums[0] ஐப் பயன்படுத்தி முதல் உறுப்பையும், nums[1] ஐப் பயன்படுத்தி இரண்டாவது உறுப்பையும் அணுகலாம், மேலும்.


In assembly language, the address of any element in the array is computed using three things: The base address of the array The index of the element The size of each element in the array

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


When you use nums[0] in a high-level language, it is translated to [nums+0*<size_of_each_element_in_bytes>], where 0 is the index and nums represents the base address of the array.

நீங்கள் உயர்-நிலை மொழியில் nums[0] ஐப் பயன்படுத்தும் போது, அது [nums+0*<size_of_each_element_in_bytes>] ஆக மொழிபெயர்க்கப்படுகிறது, அங்கு 0 என்பது குறியீடு மற்றும் எண்கள் வரிசையின் அடிப்படை முகவரியைக் குறிக்கிறது.


ஒரு சரம் என்பது எழுத்துக்களின் வரிசையாகும்.


When you define a string, shown as follows, a null terminator (string terminator) is added at the end of every string.

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


To add a function comment, highlight the function name and press colon (:).

ஒரு செயல்பாட்டு கருத்தை சேர்க்க, செயல்பாட்டு பெயரை ஹைலைட் செய்து, காலன் (:) ஐ அழுத்தவும்.


The pseudocode can now remind you of the function's behavior.

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


In fact, whatever manipulation was done earlier was done to the database, not to the executable.

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


When an executable is loaded into IDA, it creates a database consisting of five files.

ஒரு செயல்படுத்தக்கூடியது IDA இல் ஏற்றப்படும்போது, அது ஐந்து கோப்புகளைக் கொண்ட ஒரு தரவுத்தளத்தை உருவாக்குகிறது.


Each of these files stores various information and has a base name that matches the selected executable.

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


Any modifications that you make are reflected in the views and saved in the database.

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


You can save the database by closing IDA; when you close IDA, you will be presented with a Save database dialog.

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


The Pack database option archives all of the files into a single IDB or i64 file.

பேக் தரவுத்தள விருப்பம் அனைத்து கோப்புகளையும் ஒரு IDB அல்லது i64 கோப்பில் காப்பகப்படுத்துகிறது.


When you reopen the .idb or .i64 file, you should be able to see the renamed variables and comments.

.idb அல்லது .i64 கோப்பை மீண்டும் திறக்கும்போது, மறுபெயரிடப்பட்ட மாறிகள் மற்றும் கருத்துகளை நீங்கள் பார்க்க முடியும்.


Let's look at another simple program and explore a few more features of IDA.

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


IDA identified three local variables and propagated this information in the program.

IDA மூன்று உள்ளூர் மாறிகளை அடையாளம் கண்டு இந்த தகவலை நிரலில் பரப்பியது.


IDA also identified the global variables and assigned names such as dword_403374 and byte_403370.

IDA உலகளாவிய மாறிகளையும் அடையாளம் கண்டு dword_403374 மற்றும் byte_403370 போன்ற பெயர்களை ஒதுக்கியது.


The reason for that, is when a variable is defined in the global data area, the address and size of the variables are known to the compiler at compile time.

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


IDA used the offset keyword to indicate that addresses of variables are used.

மாறிகளின் முகவரிகள் பயன்படுத்தப்படுகின்றன என்பதைக் குறிக்க IDA ஆஃப்செட் முக்கிய வார்த்தையைப் பயன்படுத்தியது.


IDA assigned the dummy name aTest to the address containing the string (string variable).

IDA, சரத்தை (சரம் மாறி) கொண்ட முகவரிக்கு aTest என்ற போலி பெயரை ஒதுக்கியது.


IDA makes navigating to anywhere within a program much easier.

IDA ஒரு நிரலுக்குள் எங்கும் செல்லுவதை மிகவும் எளிதாக்குகிறது.


When a program is disassembled, IDA labels every location in the program.

ஒரு நிரல் பிரிக்கப்படும்போது, IDA நிரலில் உள்ள ஒவ்வொரு இடத்தையும் குறிக்கிறது.


Another way to navigate is by using cross-references (also referred to as Xrefs).

செல்ல மற்றொரு வழி குறுக்கு-குறிப்புகளைப் பயன்படுத்துவதாகும் (Xrefs என்றும் அழைக்கப்படுகிறது).


Cross-references can be either data cross-references or code cross-references.

குறுக்கு-குறிப்புகள் தரவு குறுக்கு-குறிப்புகள் அல்லது குறியீடு குறுக்கு-குறிப்புகளாக இருக்கலாம்.


A code cross-reference indicates the control flow from one instruction to an another.

ஒரு குறியீடு குறுக்கு-குறிப்பு ஒரு அறிவுறுத்தலில் இருந்து இன்னொரு அறிவுறுத்தலுக்கு கட்டுப்பாட்டு ஓட்டத்தைக் குறிக்கிறது.


The 64-bit Windows operating system can run a 32-bit executable.

64-பிட் விண்டோஸ் இயங்குதளம் 32-பிட் செயல்படுத்தக்கூடிய கோப்பை இயக்க முடியும்.


When you are analyzing a 32-bit malware on 64-bit Windows, if you find malware accessing the system32 directory, it is really accessing the syswow64 directory.

நீங்கள் 64-பிட் விண்டோஸில் 32-பிட் தீம்பொருளைப் பகுப்பாய்வு செய்யும் போது, தீம்பொருள் system32 கோப்பகத்தை அணுகுவதைக் கண்டால், அது உண்மையில் syswow64 கோப்பகத்தை அணுகுகிறது.


The disassembly and decompiling skills that you learned in this chapter will help you to gain a deeper understanding of how malicious code works, at a low level.

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


A disassembler is a program that translates machine code back to assembly code.

ஒரு டிஸ்அசெம்பிளர் என்பது இயந்திரக் குறியீட்டை அசெம்பிளி குறியீடாக மொழிபெயர்க்கும் ஒரு நிரலாகும்.


IDA can run on various platforms (Windows, Linux, and macOS) and supports analysis of various file formats.

IDA பல்வேறு தளங்களில் (விண்டோஸ், லினக்ஸ் மற்றும் macOS) இயங்க முடியும் மற்றும் பல்வேறு கோப்பு வடிவங்களின் பகுப்பாய்வை ஆதரிக்கிறது.


You can download the freeware version of IDA for non- commercial use.

வணிக ரீதியிலான பயன்பாட்டிற்காக IDA இன் இலவச பதிப்பை நீங்கள் பதிவிறக்கம் செய்யலாம்.


The commercial version of IDA does not lack any functionality.

IDA இன் வணிகப் பதிப்பில் எந்த செயல்பாடும் குறைபடாது.


To load an executable, Launch IDA Pro (right-click and select Run as administrator).

செயல்படுத்தக்கூடிய ஒன்றை ஏற்ற, IDA Pro ஐத் தொடங்கவும் (வலது கிளிக் செய்து நிர்வாகியாக இயக்கு என்பதைத் தேர்ந்தெடுக்கவும்).


After the disassembly, IDA performs an initial analysis to identify the compiler, function arguments, local variables, library functions, and their parameters.

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


The IDA desktop integrates the features of many common static analysis tools into a single interface.

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


This is the primary window, and it displays the disassembled code.

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


In the graph view mode, IDA displays only one function at a time, in a flowchart-style graph.

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


The conditional jumps use green and red arrows.

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


In the text view mode, the entire disassembly is presented in a linear fashion.

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


The functions window displays all the functions recognized by IDA.

செயல்பாடுகள் சாளரம் IDA ஆல் அங்கீகரிக்கப்பட்ட அனைத்து செயல்பாடுகளையும் காட்டுகிறது.


You can double-click on any of these functions to jump to a selected function.

தேர்ந்தெடுக்கப்பட்ட செயல்பாட்டிற்குச் செல்ல, இந்த செயல்பாடுகளில் எதையும் இருமுறை கிளிக் செய்யலாம்.


Library functions are compiler-generated and are not written by a malware author.

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


The hex window displays a sequence of bytes in a hex dump and the ASCII format.

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


The strings window displays the list of strings extracted from the binary.

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


When analyzing malware, you should change the variable/function names to more meaningful names.

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


Using the cross-references to CreateFile, we can determine that the CreateFile API is referenced in two functions.

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


IDA employs a technology called Fast Library Identification and Recognition Technology (FLIRT).

IDA ஆனது ஃபாஸ்ட் லைப்ரரி ஐடென்டிஃபிகேஷன் அண்ட் ரெகக்னிஷன் டெக்னாலஜி (FLIRT) எனப்படும் தொழில்நுட்பத்தைப் பயன்படுத்துகிறது.


In this case, IDA was able to recognize the disassembled function at ➊ as an imported function, and named it CreateFileA.

இந்த விஷயத்தில், IDA ஆனது ➊ இல் உள்ள சிதைக்கப்பட்ட செயல்பாட்டை இறக்குமதி செய்யப்பட்ட செயல்பாடாக அங்கீகரிக்க முடிந்தது, மேலும் அதற்கு CreateFileA என்று பெயரிட்டது.


IDA's capability to identify libraries and imported functions is extremely useful.

லைப்ரரிகள் மற்றும் இறக்குமதி செய்யப்பட்ட செயல்பாடுகளை அடையாளம் காணும் IDA-ன் திறன் மிகவும் பயனுள்ளதாக இருக்கிறது.


IDA also added names of parameters as comments to indicate which parameter was being pushed.

எந்த அளவுருவை அழுத்துகிறார்கள் என்பதைக் குறிக்க, IDA அளவுருக்களின் பெயர்களை கருத்துகளாகவும் சேர்த்தது.


From the preceding disassembly listing, you can tell that malware either creates or opens a file (psto.exe).

முந்தைய சிதைவு பட்டியலிலிருந்து, தீம்பொருள் ஒரு கோப்பை (psto.exe) உருவாக்குகிறது அல்லது திறக்கிறது என்பதை நீங்கள் கூறலாம்.


Malware authors often use symbolic constants, such as GENERIC_WRITE, in their source code.

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


Similarly, the value 2, passed as the fifth argument (➍), represents the symbolic name CREATE_ALWAYS.

அதேபோல், ஐந்தாவது வாதமாக அனுப்பப்படும் மதிப்பு 2 (➍), CREATE_ALWAYS என்ற குறியீட்டுப் பெயரைப் பிரதிபலிக்கிறது.


After replacing the constants with symbolic names, the disassembly listing is translated.

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


The code is now more readable, and from the code, you can tell that malware creates the file psto.exe.

குறியீடு இப்போது மிகவும் படிக்கக்கூடியதாக உள்ளது, மேலும் குறியீட்டிலிருந்து, தீம்பொருள் psto.exe கோப்பை உருவாக்குகிறது என்பதை நீங்கள் கூறலாம்.


Windows supports two parallel sets of APIs: one for ANSI strings, and the other for Unicode strings.

விண்டோஸ் இரண்டு இணையான API தொகுப்புகளை ஆதரிக்கிறது: ஒன்று ANSI சரங்களுக்காகவும், மற்றொன்று யூனிகோட் சரங்களுக்காகவும்.


You will also see malware using APIs such as CreateFileW.

CreateFileW போன்ற APIகளைப் பயன்படுத்தும் தீம்பொருளையும் நீங்கள் பார்க்கலாம்.


During malware analysis, when you come across a function such as CreateFileA or CreateFileW, just remove the trailing A and W characters.

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


Let's look at an example of a 32-bit malware to understand how malware uses multiple API functions.

தீம்பொருள் எவ்வாறு பல API செயல்பாடுகளைப் பயன்படுத்துகிறது என்பதைப் புரிந்துகொள்ள, 32-பிட் தீம்பொருளின் உதாரணத்தைப் பார்ப்போம்.


In the following disassembly output, the 32-bit malware calls the RegOpenKeyEx API.

பின்வரும் சிதைவு வெளியீட்டில், 32-பிட் தீம்பொருள் RegOpenKeyEx API ஐ அழைக்கிறது.


After the malware opens the handle to the Run registry key by calling RegOpenKeyEx, the returned handle is moved into the ecx register.

RegOpenKeyEx ஐ அழைப்பதன் மூலம் ரன் ரெஜிஸ்ட்ரி விசாவிற்கு தீம்பொருள் கைப்பிடியைத் திறந்த பிறகு, திரும்பிய கைப்பிடி ecx பதிவேட்டில் நகர்த்தப்படுகிறது.


You also saw how malware acquires a handle to an object (such as the registry key).

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


In the previous chapter, while discussing the x64 architecture, you learned that the first four parameters are passed in registers.

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


From the preceding example, you can see that the malware creates a file and writes some content into the file.

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


When performing malware analysis, you may want to modify the binary to change its inner workings.

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


A debugger is a program that gives you the ability to inspect malicious code at a more granular level.

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


It provides full control over the malware's runtime behavior and allows you to execute a single instruction.

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


In this chapter, you will mainly learn the debugging features offered by IDA Pro and x64dbg.

இந்த அத்தியாயத்தில், IDA Pro மற்றும் x64dbg ஆகியவற்றால் வழங்கப்படும் பிழைத்திருத்த அம்சங்களைப் பற்றி முக்கியமாக அறிந்து கொள்வீர்கள்.


You will learn about the features offered by these debuggers, and how to use them to inspect the runtime behavior of a program.

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


When you are debugging a malware, proper care needs to be taken, as you will be running the malicious code on a system.

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


It is highly recommended that you perform any malware debugging in an isolated environment.

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


At the end of this chapter, you will also see how to debug a .NET application using a .NET decompiler/debugger, dnSpy.

இந்த அத்தியாயத்தின் முடிவில், .NET டிகம்பைலர்/பிழைத்திருத்தி, dnSpy ஐப் பயன்படுத்தி .NET பயன்பாட்டை எவ்வாறு பிழைத்திருத்துவது என்பதையும் பார்ப்பீர்கள்.


Debugging normally begins by selecting the program to debug.

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


There are two ways to debug a program: (a) attach the debugger to a running process, and (b) launch a new process.

ஒரு நிரலை பிழைத்திருத்துவதற்கு இரண்டு வழிகள் உள்ளன: (a) பிழைத்திருத்தியை இயங்கும் செயல்முறையுடன் இணைக்கவும், மற்றும் (b) ஒரு புதிய செயல்முறையைத் தொடங்கவும்.


When you attach the debugger to a running process, you will not be able to control or monitor the process's initial actions.

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


On the other hand, launching a new process allows you to monitor or debug every action the process takes.

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


When you start the debugger, the original binary will be executed with the privileges of the user running the debugger.

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


A program's entry point is the address of the first instruction that will be executed.

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


A debugger gives you the ability to control/modify the behavior of the process while it is executing.

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


The two important capabilities offered by a debugger are: (a) the ability to control execution, and (b) the ability to interrupt execution (using breakpoints).

ஒரு பிழைத்திருத்தியால் வழங்கப்படும் இரண்டு முக்கியமான திறன்கள்: (a) செயல்பாட்டைக் கட்டுப்படுத்தும் திறன், மற்றும் (b) செயல்பாட்டைத் தடுக்கும் திறன் (பிரேக் பாயிண்டுகளைப் பயன்படுத்துதல்).


Using a debugger, you can execute one or more instructions (or select functions) before returning control to the debugger.

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


Continue (Run): This executes all of the instructions, until a breakpoint is reached or an exception occurs.

தொடரவும் (இயக்கவும்): பிரேக் பாயிண்ட் அடையும் வரை அல்லது விதிவிலக்கு ஏற்படும் வரை இது அனைத்து வழிமுறைகளையும் இயக்குகிறது.


Using step into and step over, you can execute a single instruction.

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


A breakpoint is a debugger feature that allows you to interrupt program execution at a very specific location within a program.

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


You can set multiple breakpoints all over a program, and execution will be interrupted upon reaching any of the breakpoints.

நீங்கள் ஒரு நிரலில் பல பிரேக் பாயிண்டுகளை அமைக்கலாம், மேலும் எந்த பிரேக் பாயிண்டுகளை அடைந்தாலும் செயல்பாடு தடைபடும்.


In a 32-bit function, the stack grows as the arguments are pushed.

32-பிட் செயல்பாட்டில், வாதங்கள் தள்ளப்படும்போது அடுக்கு வளரும்.


The allocated stack space is used to store the local variables and the function parameters.

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


The lack of push and pop instructions makes it difficult to determine the number of parameters accepted by the function.

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


தீங்கிழைக்கும் பைனரிகளை பிழைத்திருத்துதல்


Once you have an idea of where to find the function parameters and the return values, you can set a breakpoint at the API call.

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


Let's look at an example of a 64-bit malware sample that calls RegSetValueEx to set some value in the registry.

பதிவேட்டில் சில மதிப்பை அமைக்க RegSetValueEx ஐ அழைக்கும் 64-பிட் தீம்பொருள் மாதிரியின் உதாரணத்தைப் பார்ப்போம்.


You will need to look at the values in the registers and the stack window to examine the parameters passed to the function.

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


In x64dbg, the easiest way to get a quick summary of function parameters is to look at the Default Window.

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


Malware can open a handle to the registry key by calling either the RegCreateKey or RegOpenKey API.

RegCreateKey அல்லது RegOpenKey API ஐ அழைப்பதன் மூலம் தீம்பொருள் பதிவேட்டில் திறக்க முடியும்.


From the handle information, and through inspecting the 1 st, 2 nd , and 5 th parameters, you can tell that malware modifies the registry key.

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


By adding logoninit.exe, along with explorer.exe, the malware makes sure that logoninit.exe is also launched by Userinit.exe.

explorer.exe உடன், logoninit.exe ஐச் சேர்ப்பதன் மூலம், Userinit.exe மூலம் logoninit.exe தொடங்கப்படுவதை தீம்பொருள் உறுதி செய்கிறது.


In this section, you will use some of the concepts that you learned in chapter 3, Dynamic Analysis, to debug a DLL using x64dbg.

இந்த பிரிவில், x64dbg ஐப் பயன்படுத்தி DLL ஐ பிழைத்திருத்துவதற்கு, 3 ஆம் அத்தியாயம், டைனமிக் அனாலிசிஸில் நீங்கள் கற்றுக்கொண்ட சில கருத்துகளைப் பயன்படுத்துவீர்கள்.


To debug a DLL, launch x64dbg (preferably with administrator privileges) and load the DLL.

DLL ஐ பிழைத்திருத்துவதற்கு, x64dbg ஐத் தொடங்கவும் (முன்னுரிமை நிர்வாகி சலுகைகளுடன்) மற்றும் DLL ஐ ஏற்றவும்.


After you load the DLL, the debugger may pause at the System Breakpoint, TLS callback, or DLL entry point function.

DLL ஐ ஏற்றிய பிறகு, பிழைத்திருத்தி சிஸ்டம் பிரேக் பாயிண்ட், TLS கால்கேக் அல்லது DLL நுழைவு புள்ளி செயல்பாட்டில் இடைநிறுத்தப்படலாம்.


Another effective method is to use rundll32.exe to debug the DLL.

DLL ஐ பிழைத்திருத்துவதற்கு மற்றொரு பயனுள்ள முறை rundll32.exe ஐப் பயன்படுத்துவதாகும்.


To do so, first load rundll32.exe from the system32 directory into the debugger.

அவ்வாறு செய்ய, முதலில் rundll32.exe ஐ system32 கோப்பகத்திலிருந்து பிழைத்திருத்திக்கு ஏற்றவும்.


You can keep track of where the execution has paused every time you run (F9), by looking at the comment next to the breakpoint address.

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


Sometimes, you may want to debug a DLL that only runs in a specific process.

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


Tracing allows you to log events while the process is executing.

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


You can control the tracing by adding breakpoints.

பிரேக் பாயிண்ட்களைச் சேர்ப்பதன் மூலம் டிரேசிங்கை கட்டுப்படுத்தலாம்.


The malware downloads a component and executes it.

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


Downloaders are often part of exploit shellcode.

பதிவிறக்குபவர்கள் பெரும்பாலும் சுரண்டல் ஷெல்கோட்டின் ஒரு பகுதியாக உள்ளனர்.


The program uses API calls like ShellExecute() to run the downloaded file.

பதிவிறக்கம் செய்யப்பட்ட கோப்பை இயக்க ShellExecute() போன்ற API அழைப்புகளை நிரல் பயன்படுத்துகிறது.


A breakpoint was set to determine the URL from which the malware binary is downloaded.

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


The downloader saves the executable in the %TEMP% directory.

பதிவிறக்குபவர் செயல்படக்கூடிய கோப்பை %TEMP% கோப்பகத்தில் சேமிக்கிறார்.


Malware may also use WinExec() or CreateProcess() to execute the downloaded file.

பதிவிறக்கம் செய்யப்பட்ட கோப்பை இயக்க தீம்பொருள் WinExec() அல்லது CreateProcess() ஐப் பயன்படுத்தலாம்.


It's better to use monitoring tools while debugging malicious binaries.

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


A dropper embeds the malware component within itself.

ஒரு டிராப்பர் தீம்பொருள் கூறுகளை தனக்குள்ளே உட்பொதிக்கிறது.


The dropper extracts the malware component and drops it to disk.

டிராப்பர் தீம்பொருள் கூறுகளை பிரித்தெடுத்து அதை வட்டில் வைக்கிறது.


Droppers often use FindResource(), LoadResource(), and other API calls.

டிராப்பர்கள் பெரும்பாலும் FindResource(), LoadResource() மற்றும் பிற API அழைப்புகளைப் பயன்படுத்துகின்றன.


The Resource Hacker tool shows the presence of a PE file in the resource section.

வள ஹேக்கர் கருவி, வளப் பகுதியில் ஒரு PE கோப்பின் இருப்பைக் காட்டுகிறது.


Setting a breakpoint on the FindResourceA() API call can be useful.

FindResourceA() API அழைப்பில் ஒரு பிரேக் பாயிண்ட் அமைப்பது பயனுள்ளதாக இருக்கும்.


The malware is trying to find the DLL/101 resource.

தீம்பொருள் DLL/101 வளத்தைக் கண்டுபிடிக்க முயற்சிக்கிறது.


The return value of LoadResource() is passed to LockResource().

LoadResource() இன் திரும்பும் மதிப்பு LockResource() க்கு அனுப்பப்படுகிறது.


The malware determines the size of the resource using SizeofResource().

SizeofResource() ஐப் பயன்படுத்தி தீம்பொருள் வளத்தின் அளவை தீர்மானிக்கிறது.


The malware drops a DLL on the disk using CreateFileA.

CreateFileA ஐப் பயன்படுத்தி தீம்பொருள் வட்டில் ஒரு DLL ஐ வைக்கிறது.


The extracted PE content is written to the DLL using WriteFile().

WriteFile() ஐப் பயன்படுத்தி பிரித்தெடுக்கப்பட்ட PE உள்ளடக்கம் DLL க்கு எழுதப்படுகிறது.


This is an example of a 64-bit malware dropper.

இது ஒரு 64-பிட் தீம்பொருள் டிராப்பரின் எடுத்துக்காட்டு.


Keyloggers are designed to intercept and log keystrokes.

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


Attackers use keylogging to steal confidential information.

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


You can set hardware and conditional breakpoints by editing the breakpoint that is already set.

ஏற்கனவே அமைக்கப்பட்ட பிரேக் பாயிண்ட்டை திருத்துவதன் மூலம் வன்பொருள் மற்றும் நிபந்தனை பிரேக் பாயிண்ட்டுகளை அமைக்கலாம்.


To set a hardware breakpoint, right-click on an existing breakpoint and select Edit breakpoint.

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


IDA allows you to set more than four hardware breakpoints, but only four of them will work.

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


You can use hardware breakpoints to specify whether to break on execute (default), break on write, or break on read/write.

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


The break on write and break on read/write options allow you to create memory breakpoints.

எழுதுவதில் உடை மற்றும் படிக்க/எழுதுவதில் உடை விருப்பங்கள் நினைவக பிரேக் பாயிண்ட்டுகளை உருவாக்க உங்களை அனுமதிக்கின்றன.


This breakpoint is useful if you want to know when your program accesses a piece of data.

உங்கள் நிரல் ஒரு தரவை அணுகும் போது தெரிந்து கொள்ள விரும்பினால் இந்த பிரேக் பாயிண்ட் பயனுள்ளதாக இருக்கும்.


The break on execute option allows you to set a breakpoint when the specified memory location is executed.

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


In addition to specifying a mode, you must also specify a size.

ஒரு முறையை குறிப்பிடுவதோடு, நீங்கள் ஒரு அளவையும் குறிப்பிட வேண்டும்.


You can set a conditional breakpoint by specifying the condition in the condition field.

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


The condition can be an actual condition, or IDC or IDAPython expressions.

நிபந்தனை ஒரு உண்மையான நிபந்தனையாக இருக்கலாம், அல்லது IDC அல்லது IDAPython வெளிப்பாடுகளாக இருக்கலாம்.


You can view all of the active breakpoints by navigating to Debugger | Breakpoints | Breakpoint List.

Debugger | Breakpoints | Breakpoint List என்பதற்குச் சென்று அனைத்து செயலில் உள்ள பிரேக் பாயிண்ட்டுகளையும் பார்க்கலாம்.


You can right-click on the breakpoint entry and disable or delete the breakpoint.

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


In this section, we will look at how to use IDA to debug a malware binary.

இந்த பகுதியில், ஒரு தீங்கிழைக்கும் பைனரியை பிழைத்திருத்துவதற்கு IDA ஐ எவ்வாறு பயன்படுத்துவது என்பதைப் பார்ப்போம்.


Consider the disassembly listing from a 32-bit malware sample.

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


The malware calls the CreateFileW API to create a file.

ஒரு கோப்பை உருவாக்க தீங்கிழைக்கும் மென்பொருள் CreateFileW API ஐ அழைக்கிறது.


To determine the name of the file, we can set a breakpoint at the address where the call to the CreateFileW is made.

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


When it reaches the breakpoint (before calling CreateFileW), all of the parameters to the function will be pushed onto the stack.

அது பிரேக் பாயிண்ட்டை அடையும் போது (CreateFileW ஐ அழைப்பதற்கு முன்), செயல்பாட்டிற்கான அனைத்து அளவுருக்களும் அடுக்குக்கு தள்ளப்படும்.


After the call to CreateFileW, the handle to the file will be returned in the eax register.

CreateFileW க்கு அழைத்த பிறகு, கோப்பிற்கான ஹேண்டில் eax பதிவேட்டில் திருப்பி அனுப்பப்படும்.


In this case, the malware is creating a file, SHAMple.dat, in the C:\Users\test\AppData\Local\Temp directory.

இந்த வழக்கில், தீங்கிழைக்கும் மென்பொருள் C:\Users\test\AppData\Local\Temp கோப்பகத்தில் SHAMple.dat என்ற கோப்பை உருவாக்குகிறது.


The debugging techniques covered in this chapter are effective methods for understanding the inner workings of a malicious binary.

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


The malicious DLL (ResN32.dll) is loaded into the address space of any new process that loads User32.dll.

தீங்கிழைக்கும் DLL (ResN32.dll) User32.dll ஐ ஏற்றும் எந்தவொரு புதிய செயல்முறையின் முகவரி இடத்திலும் ஏற்றப்படுகிறது.


To detect this technique, look for suspicious entries in the AppInit_DLLs registry value.

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


Adversaries can take advantage of how the operating system searches for DLLs.

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


The malicious DLL is dropped in the same directory as explorer.exe.

தீங்கிழைக்கும் DLL explorer.exe இருக்கும் அதே கோப்பகத்தில் விடப்படுகிறது.


The DLL search order hijack technique makes forensic analysis much harder.

DLL தேடல் வரிசை கடத்தல் தடயவியல் பகுப்பாய்வை மிகவும் கடினமாக்குகிறது.


COM is a system that allows software components to interact.

COM என்பது மென்பொருள் கூறுகள் ஒன்றோடொன்று தொடர்பு கொள்ள அனுமதிக்கும் ஒரு அமைப்பாகும்.


A COM client uses the service from the COM server.

ஒரு COM கிளையண்ட் COM சேவையகத்திலிருந்து சேவையைப் பயன்படுத்துகிறது.


In the case of COM Hijacking, an attacker modifies the registry entry.

COM கடத்தலின் விஷயத்தில், ஒரு தாக்குபவர் பதிவேட்டில் உள்ளீட்டை மாற்றுகிறார்.


The malware sets a registry value in HKCU\Software\Classes\CLSID.

தீம்பொருள் HKCU\Software\Classes\CLSID இல் ஒரு பதிவேடு மதிப்பை அமைக்கிறது.


A service is a program that runs in the background.

ஒரு சேவை என்பது பின்னணியில் இயங்கும் ஒரு நிரலாகும்.


An adversary can persist on the system by installing a malicious program as a service.

ஒரு தீங்கிழைக்கும் நிரலை ஒரு சேவையாக நிறுவுவதன் மூலம் ஒரு எதிரி கணினியில் நிலைத்திருக்க முடியும்.


விண்டோஸ் பல்வேறு சேவை வகைகளை ஆதரிக்கிறது.


The ImagePath value specifies the code for this service.

இந்த சேவைக்கான குறியீட்டை ImagePath மதிப்பு குறிப்பிடுகிறது.


An attacker can create services in many ways.

ஒரு தாக்குபவர் பல வழிகளில் சேவைகளை உருவாக்க முடியும்.


Malware can invoke cmd.exe and run sc commands.

தீம்பொருள் cmd.exe ஐ இயக்கலாம் மற்றும் sc கட்டளைகளை இயக்கலாம்.


A service can also be created using PowerShell.

பவர்ஷெல் பயன்படுத்தி ஒரு சேவையையும் உருவாக்கலாம்.


An adversary can modify an existing service.

ஒரு எதிரி ஏற்கனவே உள்ள சேவையை மாற்றியமைக்க முடியும்.


To detect such attacks, monitor changes to service registry entries.

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


Malware uses various API calls to interact with the system.

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


In this chapter, you will learn how malicious programs inject code.

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


The command received from the C2, appropriate actions are performed by the malware.

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


To understand all the functionalities of this malware and how it processes the received data, refer to the author's presentation and the video demo.

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


PowerShell is a management engine based on the .NET framework.

PowerShell என்பது .NET கட்டமைப்பை அடிப்படையாகக் கொண்ட ஒரு நிர்வாக இயந்திரமாகும்.


This engine exposes a series of commands called cmdlets.

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


PowerShell is not a programming language, but it allows you to create useful scripts containing multiple commands.

PowerShell ஒரு நிரலாக்க மொழி அல்ல, ஆனால் இது பல கட்டளைகளைக் கொண்ட பயனுள்ள ஸ்கிரிப்ட்களை உருவாக்க உங்களை அனுமதிக்கிறது.


However, there is an increase in the use of PowerShell by the attackers to execute their malicious code.

இருப்பினும், தாக்குபவர்கள் தங்கள் தீங்கிழைக்கும் குறியீட்டை இயக்க PowerShell பயன்படுத்துவது அதிகரித்துள்ளது.


The major reason why attackers use PowerShell is that it provides access to all major operating system functions and it leaves very few traces, thereby making detection more difficult.

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


In most cases, Powershell is used post-exploitation to download additional components.

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


It is mostly delivered via email attachments containing files (such as .lnk, .wsf, JavaScript, VBScript, or office documents containing malicious macros) which are capable of executing PowerShell scripts directly or indirectly.

இது பெரும்பாலும் மின்னஞ்சல் இணைப்புகள் மூலம் வழங்கப்படுகிறது, இதில் கோப்புகள் (.lnk, .wsf, JavaScript, VBScript அல்லது தீங்கிழைக்கும் மேக்ரோக்களைக் கொண்ட அலுவலக ஆவணங்கள்) உள்ளன, அவை நேரடியாகவோ அல்லது மறைமுகமாகவோ PowerShell ஸ்கிரிப்ட்களை இயக்க முடியும்.


Once the attacker tricks the user into opening the malicious attachment, then the malicious code invokes PowerShell directly or indirectly to download additional components.

தாக்குபவர் பயனரை தீங்கிழைக்கும் இணைப்பைத் திறக்க ஏமாற்றியவுடன், தீங்கிழைக்கும் குறியீடு கூடுதல் கூறுகளைப் பதிவிறக்க நேரடியாகவோ அல்லது மறைமுகமாகவோ PowerShell ஐ அழைக்கிறது.


Attackers use PowerShell to dynamically load and execute code directly from memory without accessing the file system.

கோப்பு முறைமையை அணுகாமல் நினைவகத்திலிருந்து நேரடியாக குறியீட்டை மாறும் வகையில் ஏற்றவும் இயக்கவும் தாக்குபவர்கள் PowerShell ஐப் பயன்படுத்துகின்றனர்.


This allows the attacker to be stealthy and makes forensic analysis much harder.

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


Attackers use PowerShell to execute their obfuscated code; this makes it hard to detect it with traditional security tools.

தாக்குபவர்கள் தங்கள் மறைக்கப்பட்ட குறியீட்டை இயக்க PowerShell ஐப் பயன்படுத்துகின்றனர்; இது பாரம்பரிய பாதுகாப்பு கருவிகள் மூலம் கண்டறிவதை கடினமாக்குகிறது.


You can execute a PowerShell command using the interactive PowerShell console.

ஊடாடும் PowerShell கன்சோலைப் பயன்படுத்தி ஒரு PowerShell கட்டளையை இயக்கலாம்.


A cmdlet (such as Write-Host) is a compiled command written in a .NET Framework language which is meant to be small and serves a single purpose.

ஒரு cmdlet (எ.கா., Write-Host) என்பது .NET கட்டமைப்பில் எழுதப்பட்ட ஒரு தொகுக்கப்பட்ட கட்டளை ஆகும், இது சிறியதாக இருக்க வேண்டும் மற்றும் ஒரே நோக்கத்திற்காக செயல்படுகிறது.


ஒரு cmdlet அளவுருக்களை ஏற்றுக்கொள்ள முடியும்.


In PowerShell, variables can be used to store values.

PowerShell இல், மாறிகளை மதிப்புகளை சேமிக்க பயன்படுத்தலாம்.


The PowerShell script has an extension of .ps1.

PowerShell ஸ்கிரிப்ட் .ps1 என்ற நீட்டிப்பைக் கொண்டுள்ளது.


By default, you will not be allowed to execute a PowerShell script.

இயல்பாக, நீங்கள் ஒரு PowerShell ஸ்கிரிப்டை இயக்க அனுமதிக்கப்பட மாட்டீர்கள்.


The execution policy determines the conditions under which PowerShell scripts are executed.

PowerShell ஸ்கிரிப்ட்கள் எந்த நிபந்தனைகளின் கீழ் செயல்படுத்தப்படுகின்றன என்பதை செயல்படுத்தும் கொள்கை தீர்மானிக்கிறது.


HAL isolates the operating system from the hardware.

HAL ஆனது இயக்க முறைமையை வன்பொருளில் இருந்து தனிமைப்படுத்துகிறது.


It implements functions to support different hardware platforms.

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


The kernel mode device drivers invoke functions exposed by hal.dll.

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


The ntoskrnl.exe binary provides two types of functionality: the executive and the kernel.

ntoskrnl.exe பைனரி இரண்டு வகையான செயல்பாடுகளை வழங்குகிறது: நிர்வாகம் மற்றும் கர்னல்.


The executive implements functions called system service routines.

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


The kernel implements low-level operating system services.

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


Win32K.sys implements UI and graphics device interface (GDI) services.

Win32K.sys UI மற்றும் கிராபிக்ஸ் சாதன இடைமுகத்தை (GDI) செயல்படுத்துகிறது.


The user-space contains code that runs with restricted access.

பயனர் இடத்தில் வரையறுக்கப்பட்ட அணுகலுடன் இயங்கும் குறியீடு உள்ளது.


The kernel space contains the kernel itself and the device drivers.

கர்னல் இடத்தில் கர்னலும் சாதன இயக்கிகளும் உள்ளன.


Code running in the kernel space executes with a high privilege.

கர்னல் இடத்தில் இயங்கும் குறியீடு அதிக சலுகையுடன் செயல்படுகிறது.


The difference between the space and the mode is that space specifies the location.

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


How can a malware binary write content to a file?

ஒரு தீம்பொருள் பைனரி ஒரு கோப்பில் உள்ளடக்கத்தை எவ்வாறு எழுத முடியும்?


Most APIs called by user-mode applications call system service routines.

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


The ntdll.dll acts as the gateway between the user-space and the kernel space.

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


The Windows operating system provides services by exposing APIs.

விண்டோஸ் இயக்க முறைமை APIகளை வெளிப்படுத்துவதன் மூலம் சேவைகளை வழங்குகிறது.


An application uses the service by calling the API.

ஒரு பயன்பாடு API ஐ அழைப்பதன் மூலம் சேவையைப் பயன்படுத்துகிறது.


Most API functions end up calling the system service routine.

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


When a process is invoked, the executable and DLLs are loaded.

ஒரு செயல்முறை அழைக்கப்பட்டால், செயல்படுத்தக்கூடிய மற்றும் DLLகள் ஏற்றப்படும்.


The thread that is created starts executing in the user-mode.

உருவாக்கப்பட்ட நூல் பயனர்-பயன்முறையில் செயல்படத் தொடங்குகிறது.


An application can also load a DLL during runtime.

ஒரு பயன்பாடு இயக்க நேரத்திலும் ஒரு DLL ஐ ஏற்ற முடியும்.


ஷிம் குறியீடு API அழைப்புகளை திருப்பி அனுப்புகிறது.


Applications use the IAT to call Windows APIs.

விண்டோஸ் APIகளை அழைக்க பயன்பாடுகள் IAT ஐப் பயன்படுத்துகின்றன.


ஷிம் API அளவுருக்களை மாற்றியமைக்க முடியும்.


Let's look at an example to understand shims.

ஷிம்களைப் புரிந்து கொள்ள ஒரு உதாரணத்தைப் பார்ப்போம்.


An application checked the OS version before Windows 7.

விண்டோஸ் 7 வெளியாவதற்கு முன் ஒரு பயன்பாடு OS பதிப்பை சரிபார்த்தது.


The GetVersion() API is used to determine the OS version.

OS பதிப்பைத் தீர்மானிக்க GetVersion() API பயன்படுத்தப்படுகிறது.


The application might not work on Windows 7.

விண்ணப்பம் விண்டோஸ் 7 இல் வேலை செய்யாமல் போகலாம்.


You can apply a shim called WinXPVersionLie.

WinXPVersionLie எனப்படும் ஒரு ஷிம்மைப் பயன்படுத்தலாம்.


The shim engine intercepts the GetVersion() call.

ஷிம் எஞ்சின் GetVersion() அழைப்பை இடைமறிக்கிறது.


The shim tricks the application into thinking it's on Windows XP.

விண்ணப்பம் விண்டோஸ் XP இல் இயங்குவதாக ஷிம் ஏமாற்றுகிறது.


Microsoft provides many shims to alter application behavior.

பயன்பாட்டின் நடத்தையை மாற்றியமைக்க Microsoft பல ஷிம்களை வழங்குகிறது.


Attackers abuse shims for persistence and code injection.

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


ஒரு ஷிம்மை உருவாக்குவது பல படிகளை உள்ளடக்கியது.


You need administrator rights to create and install a shim.

ஒரு ஷிம்மை உருவாக்க மற்றும் நிறுவ நிர்வாகி உரிமைகள் தேவை.


The Application Compatibility Toolkit (ACT) is used.

பயன்பாட்டு இணக்கத்தன்மை கருவித்தொகுப்பு (ACT) பயன்படுத்தப்படுகிறது.


Use the 32-bit Compatibility Administrator Tool for 32-bit programs.

32-பிட் நிரல்களுக்கு 32-பிட் இணக்கத்தன்மை நிர்வாகி கருவியைப் பயன்படுத்தவும்.


We will create an InjectDll shim for notepad.exe.

notepad.exe க்காக InjectDll ஷிம்மை உருவாக்குவோம்.


Creating a shim involves choosing the application, creating a database, saving it, and installing it.

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


The InjectDll shim is only available in the 32-bit tool.

InjectDll ஷிம் 32-பிட் கருவியில் மட்டுமே கிடைக்கும்.


Attackers can use shims to load DLLs into processes.

தாக்குபவர்கள் செயல்முறைகளில் DLLகளை ஏற்ற ஷிம்களைப் பயன்படுத்தலாம்.


The malware can extract credentials from the POST payload.

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


Before hooking, the malicious executable is injected into the address space of Internet Explorer.

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


The first three instructions are replaced with the jmp instruction.

முதல் மூன்று வழிமுறைகள் jmp வழிமுறையுடன் மாற்றப்படுகின்றன.


In inline hooking, we saw how the series of bytes in a function are patched to redirect control to malicious code.

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


Microsoft uses the feature of in-memory patching to apply patches to fix vulnerabilities in their products.

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


Malware authors have used in-memory patching to inject code and hook the API functions.

தீங்கிழைக்கும் மென்பொருள் ஆசிரியர்கள் குறியீட்டைச் செருகுவதற்கும் API செயல்பாடுகளை ஹூக் செய்வதற்கும் நினைவகத்தில் பேட்ச் செய்வதைப் பயன்படுத்துகின்றனர்.


The installed .sdb files contain the shellcode that will be patched directly into the memory of the target process.

நிறுவப்பட்ட .sdb கோப்புகளில் ஷெல்கோட் உள்ளது, இது இலக்கு செயல்முறையின் நினைவகத்தில் நேரடியாக பேட்ச் செய்யப்படும்.


To know what the shellcode is doing, we need to be able to parse PATCH_BITS.

ஷெல்கோட் என்ன செய்கிறது என்பதை அறிய, PATCH_BITS ஐப் பகுப்பாய்வு செய்ய வேண்டும்.


In other words, it redirects control to the RVA 0x0004f0ed.

வேறு வார்த்தைகளில் கூறுவதானால், இது கட்டுப்பாட்டை RVA 0x0004f0ed க்கு திருப்பி விடுகிறது.


This technique is interesting, because in this case, the malware does not allocate memory or inject code directly.

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


In addition to the code injection techniques covered in this chapter, security researchers have discovered various other means of injecting code.

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


In this chapter, we looked at the different code injection techniques used by malicious programs.

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


Apart from executing malicious code, an attacker can hijack the API functions.

தீங்கிழைக்கும் குறியீட்டை இயக்குவதைத் தவிர, ஒரு தாக்குபவர் API செயல்பாடுகளை கடத்த முடியும்.


The term obfuscation refers to a process of obscuring meaningful information.

மறைத்தல் என்ற சொல் அர்த்தமுள்ள தகவல்களை மறைக்கும் ஒரு செயல்முறையைக் குறிக்கிறது.


Malware authors often use various obfuscation techniques to hide the information.

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


Adversaries typically use encoding/encryption techniques to conceal the information.

எதிரிகள் பொதுவாக தகவல்களை மறைக்க குறியாக்கம்/மறைகுறியாக்கம் நுட்பங்களைப் பயன்படுத்துகின்றனர்.


Malware encrypts the plaintext, by passing it as input along with the key to an encryption function.

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


While analyzing malware, you may want to understand how a particular content is encrypted or decrypted.

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


Most of the time, attackers use very simple encoding algorithms such as Base64 encoding or xor encryption to obscure the data.

பெரும்பாலான நேரங்களில், தாக்குபவர்கள் தரவை மறைக்க Base64 குறியாக்கம் அல்லது xor என்க்ரிப்ஷன் போன்ற மிக எளிய குறியீட்டு வழிமுறைகளைப் பயன்படுத்துகின்றனர்.


Caesar cipher, also known as shift cipher, is a traditional cipher and is one of the simplest encoding techniques.

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


The previous script iterates through the names window to identify the dec_function.

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


It uses the address of dec_function to determine the cross-references (Xrefs) to dec_function.

dec_function இன் முகவரியைப் பயன்படுத்தி, dec_function க்கான குறுக்கு-குறிப்புகளை (Xrefs) தீர்மானிக்கிறது.


It sets the breakpoint on all the addresses where dec_function is called.

dec_function எங்கு அழைக்கப்படுகிறதோ அந்த அனைத்து முகவரிகளிலும் பிரேக் பாயிண்ட்டை அமைக்கிறது.


இது தானாகவே பிழைத்திருத்தியைத் தொடங்குகிறது.


It reads the encrypted string from the address pointed to by the rcx register.

rcx பதிவேட்டில் சுட்டிக்காட்டப்பட்ட முகவரியிலிருந்து மறையாக்கப்பட்ட சரத்தை இது படிக்கிறது.


It then steps over the function to execute the decryption function (dec_function).

பின்னர், மறையீட்டுச் செயல்பாட்டை (dec_function) இயக்க, செயல்பாட்டின் மீது செல்கிறது.


It repeats the previous steps, to decrypt each string passed to dec_function.

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


From the output, you can see that the malware decrypts the file names.

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


Malware authors often use packers and cryptors to obfuscate the executable content.

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


A packer is a program that takes a normal executable, compresses its contents, and generates a new obfuscated executable.

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


When a binary is packed, it reveals very less information.

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


To make sense of a packed binary, you need to remove the obfuscation layer (unpack) applied to the program.

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


When a normal executable is passed through a packer, the executable content is compressed.

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


முதல் படி OEP ஐ அடையாளம் காண்பதாகும்.


The original entry point (OEP) is the address of the malware's first instruction.

அசல் நுழைவு புள்ளி (OEP) என்பது தீம்பொருளின் முதல் அறிவுறுத்தலின் முகவரி ஆகும்.


The next step involves executing the program until the OEP is reached.

அடுத்த கட்டத்தில் OEP ஐ அடையும் வரை நிரலை இயக்குவது அடங்கும்.


The third step involves dumping the unpacked process from the memory to disk.

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


The final step involves fixing the Import Address Table (IAT) of the dumped file.

இறுதி படியில் வெளியேற்றப்பட்ட கோப்பின் இறக்குமதி முகவரி அட்டவணையை (IAT) சரிசெய்வது அடங்கும்.


Examining the packed binary in pestudio shows many indicators that suggest the file is packed.

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


To find the OEP, you will need to locate the instruction in the packed program that transfers control to the OEP.

OEP ஐக் கண்டறிய, பேக் செய்யப்பட்ட நிரலில் OEP க்கு கட்டுப்பாட்டை மாற்றும் அறிவுறுத்தலைக் கண்டுபிடிக்க வேண்டும்.


(CPU window) and select Search for | Current Module | String references.

(CPU விண்டோ) மற்றும் தேடல் | தற்போதைய தொகுதி | சரத்தின் குறிப்புகளைத் தேர்ந்தெடுக்கவும்.


Malware Obfuscation TechniquesChapter 9 [ 340 ] Another method to detect the presence of the Base64 character set in the binary is using a YARA rule (YARA was covered in Chapter 2, Static Analysis) such as the one shown here:

தீம்பொருள் மறைத்தல் நுட்பங்கள்அத்தியாயம் 9 [ 340 ] பைனரியில் Base64 எழுத்துத் தொகுப்பின் இருப்பைக் கண்டறிய மற்றொரு முறை YARA விதியைப் பயன்படுத்துவதாகும் (YARA அத்தியாயம் 2, நிலையான பகுப்பாய்வில் விவாதிக்கப்பட்டது) இங்கே காட்டப்பட்டுள்ளது:


rule base64 { strings: $a="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" $b="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" condition: $a or $b }

விதி base64 { சரங்கள்: $a="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" $b="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" நிபந்தனை: $a அல்லது $b }


1.3 XOR Encoding Apart from Base64 encoding, another common encoding algorithm used by the malware authors is the XOR encoding algorithm.

1.3 XOR குறியீட்டு முறை Base64 குறியீட்டு முறையைத் தவிர, தீம்பொருள் ஆசிரியர்களால் பயன்படுத்தப்படும் மற்றொரு பொதுவான குறியீட்டு வழிமுறை XOR குறியீட்டு வழிமுறையாகும்.


XOR is a bitwise operation (like AND, OR, and NOT), and it is performed on the corresponding bits of the operands.

XOR என்பது ஒரு பிட்வைஸ் செயல்பாடு (AND, OR மற்றும் NOT போன்றவை), மேலும் இது செயற்குறிகளின் தொடர்புடைய பிட்களில் செய்யப்படுகிறது.


In the XOR operation, when both the bits are the same, the result is 0 ; otherwise, the result is 1:

XOR செயல்பாட்டில், இரண்டு பிட்களும் ஒரே மாதிரியாக இருக்கும்போது, விளைவாக 0; இல்லையெனில், விளைவாக 1:


ABA^B 000 1 0 1 0 11 11 0 For example, when you XOR 2 and 4, that is, 2 ^ 4, the result is 6.

ABA^B 000 1 0 1 0 11 11 0 உதாரணமாக, நீங்கள் XOR 2 மற்றும் 4 ஐ செய்யும் போது, அதாவது, 2 ^ 4, விளைவாக 6 ஆகும்.


இது செயல்படும் விதம் இங்கே காட்டப்பட்டுள்ளது: 2: 0000 0010 4: 0000 0100 --------------------------- XORக்குப் பிறகு விளைவு: 0000 0110 (6)


1.3.1 Single Byte XOR In a single byte XOR, each byte from the plaintext is XORed with the encryption key.

1.3.1 ஒற்றை பைட் XOR ஒரு ஒற்றை பைட் XOR இல், தெளிவான உரையின் ஒவ்வொரு பைட்டும் குறியாக்க விசையுடன் XOR செய்யப்படுகிறது.


For example, if an attacker wants to encrypt plaintext cat with a key of 0x40, then each character (byte) from the text is XORed with 0x40, which results in the cipher-text #!4.

உதாரணமாக, ஒரு தாக்குபவர் 0x40 விசையுடன் பூனை என்ற தெளிவான உரையை குறியாக்க விரும்பினால், உரையின் ஒவ்வொரு எழுத்தும் (பைட்) 0x40 உடன் XOR செய்யப்படுகிறது, இதன் விளைவாக சைபர்-உரை #!4.


Another interesting property of XOR is that when you XOR the ciphertext with the same key used to encrypt, you get back the plain text.

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


This means that if you know the key, then the same function can be used to both encrypt and decrypt the data.

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


The following is a simple python script to perform XOR decryption (the same function can be used to perform XOR encryption as well):

XOR டிகுறியாக்கத்தை செய்ய ஒரு எளிய பைதான் ஸ்கிரிப்ட் கீழே உள்ளது (XOR குறியாக்கத்தை செய்யவும் அதே செயல்பாட்டைப் பயன்படுத்தலாம்):


def xor(data, key): translated = "" for ch in data: translated += chr(ord(ch) ^ key) return translated if __name__ == "__main__": out = xor("#!".


With an understanding of the XOR encoding algorithm, let's look at an example of a keylogger, which encodes all the typed keystrokes to a file.

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


When this sample is executed, it logs the keystrokes, and it opens a file (where all the keystrokes will be logged) using the CreateFileA() API, as shown in the following screenshot.

இந்த மாதிரி செயல்படுத்தப்படும்போது, அது கீஸ்ட்ரோக்குகளைப் பதிவுசெய்கிறது, மேலும் CreateFileA() API ஐப் பயன்படுத்தி ஒரு கோப்பைத் திறக்கிறது (எங்கு அனைத்து கீஸ்ட்ரோக்குகளும் பதிவு செய்யப்படும்), இது பின்வரும் ஸ்கிரீன்ஷாட்டில் காட்டப்பட்டுள்ளது.


It then writes the logged keystrokes to the file using the WriteFile() API.

பின்னர் WriteFile() API ஐப் பயன்படுத்தி பதிவு செய்யப்பட்ட கீஸ்ட்ரோக்குகளை கோப்பில் எழுதுகிறது.


Note how the malware calls a function (renamed as enc_function) after the call to CreateFileA() and before the call to WriteFile(); this function encodes the content before writing it to the file.

CreateFileA() க்கு அழைத்த பிறகு மற்றும் WriteFile() க்கு அழைப்பதற்கு முன், தீம்பொருள் ஒரு செயல்பாட்டை (enc_function என மறுபெயரிடப்பட்டது) எவ்வாறு அழைக்கிறது என்பதை கவனிக்கவும்; இந்த செயல்பாடு அதை கோப்பில் எழுதுவதற்கு முன் உள்ளடக்கத்தை குறியாக்குகிறது.


The enc_function takes two arguments; the 1 st argument is the buffer containing the data to encrypt, and the 2 nd argument is the length of the buffer:

enc_function இரண்டு வாதங்களை எடுத்துக்கொள்கிறது; முதல் வாதம் குறியாக்க வேண்டிய தரவைக் கொண்ட இடையகமாகும், மேலும் இரண்டாவது வாதம் இடையகத்தின் நீளம்:


Examining the enc_function shows that the malware uses single byte XOR.

enc_function ஐ ஆராய்ந்தால், தீம்பொருள் ஒற்றை பைட் XOR ஐப் பயன்படுத்துகிறது என்பதைக் காட்டுகிறது.


The standalone executable is distributed for Windows, macOS, and Linux operating systems.

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


The advantage of a standalone executable is that you don't need to install the Python interpreter or Volatility dependencies.

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


On Windows, once the standalone executable is downloaded, you can check whether Volatility is ready to use by executing the standalone executable with the -h (--help) option from the command line.

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


The help option displays various options and plugins that are available in Volatility.

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


In the same manner, you can download the standalone executables for Linux or macOS and check if Volatility is ready to use.

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


Volatility is also distributed as a source package; you can run it on Windows, macOS, or Linux operating systems.

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


Volatility relies on various plugins to perform tasks, and some of these plugins depend on third-party Python packages.

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


To run Volatility, you need to install Python 2.7 Interpreter and its dependencies.

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


The web page contains a list of the third-party Python packages that are required by some of the Volatility plugins.

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


Once all the dependencies are installed, download the Volatility source code package, extract it, and run Volatility.

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


All the examples mentioned in this book use the Volatility Python script from the source package.

இந்த புத்தகத்தில் குறிப்பிடப்பட்டுள்ள அனைத்து எடுத்துக்காட்டுகளும் மூல தொகுப்பிலிருந்து வோலட்டிலிட்டி பைதான் ஸ்கிரிப்டைப் பயன்படுத்துகின்றன.


You are free to choose a standalone executable, but just remember to replace python vol.py with the standalone executable name.

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


Volatility consists of various plugins that can extract different information from the memory image.

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


For instance, if you wish to list the running processes from the memory image, you can use a plugin such a pslist, or if you wish to list the network connections, you can use a different plugin.

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


Irrespective of the plugin that you use, you will use the following command syntax.

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


Using -f, you specify the path to the memory image file, and --profile tells Volatility which system and architecture the memory image was acquired from.

-f ஐப் பயன்படுத்தி, நினைவகப் படக் கோப்பிற்கான பாதையை நீங்கள் குறிப்பிடுகிறீர்கள், மேலும் --profile நினைவகப் படம் எந்த கணினி மற்றும் கட்டமைப்பிலிருந்து பெறப்பட்டது என்பதை வோலட்டிலிட்டிக்குக் கூறுகிறது.


The following command uses the pslist plugin to list the running processes from the memory image acquired from Windows 7 (32-bit) running Service Pack 1:

விண்டோஸ் 7 (32-பிட்) இயங்கும் சேவை பேக் 1 இலிருந்து பெறப்பட்ட நினைவகப் படத்திலிருந்து இயங்கும் செயல்முறைகளை பட்டியலிட பின்வரும் கட்டளை pslist செருகுநிரலைப் பயன்படுத்துகிறது: