The fuzzy hashing technique identified the similarity between the samples.

ఫజీ హాషింగ్ పద్ధతి నమూనాల మధ్య సారూప్యతను గుర్తించింది.


You might have a directory containing many malware samples.

మీరు చాలా మాల్వేర్ నమూనాలను కలిగి ఉన్న ఒక డైరెక్టరీని కలిగి ఉండవచ్చు.


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

పైథాన్ లో, ఫజీ హాష్ ని python-ssdeep ఉపయోగించి లెక్కించవచ్చు.


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

సంబంధిత నమూనాలను గుర్తించడానికి ఇంపోర్ట్ హాషింగ్ మరొక పద్ధతి.


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

ఒకే imphash ఉన్న ఫైల్స్ ఒకే ముప్పు సమూహం నుండి వచ్చాయని అర్థం కాదు.


Section hashing can also help in identifying related samples.

విభాగం హాషింగ్ కూడా సంబంధిత నమూనాలను గుర్తించడంలో సహాయపడుతుంది.


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.

YARA నియమం కింది భాగాలను కలిగి ఉంటుంది.


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

మీరు నియమాన్ని సిద్ధం చేసిన తర్వాత, తదుపరి దశ yara యుటిలిటీని ఉపయోగించడం.


If you want the rule to detect both ASCII and Unicode strings.

మీరు నియమం ASCII మరియు యూనికోడ్ స్ట్రింగ్లను రెండింటినీ గుర్తించాలని కోరుకుంటే.


If your intention is to look for strings in an executable file.

మీ ఉద్దేశ్యం ఎగ్జిక్యూటబుల్ ఫైల్ లో స్ట్రింగ్ల కోసం వెతకడం అయితే.


Let's take another example of the sample that was previously used.

ముందుగా ఉపయోగించిన నమూనాకు మరొక ఉదాహరణ తీసుకుందాం.


Running the preceding yara rule detected only the sample that contained the embedded excel document.

మునుపటి yara నియమాన్ని అమలు చేయడం వలన పొందుపరిచిన ఎక్సెల్ డాక్యుమెంట్ ఉన్న నమూనా మాత్రమే గుర్తించబడింది.


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.

మాల్వేర్ విశ్లేషణలో స్టాటిక్ విశ్లేషణ మొదటి దశ.


Dynamic analysis involves analyzing a sample by executing it in an isolated environment.

డైనమిక్ విశ్లేషణలో ఒక నమూనాను ప్రత్యేక వాతావరణంలో అమలు చేయడం ద్వారా విశ్లేషించడం జరుగుతుంది.


When performing dynamic analysis, you will be executing the malware specimen.

డైనమిక్ విశ్లేషణను నిర్వహిస్తున్నప్పుడు, మీరు మాల్వేర్ నమూనాను అమలు చేస్తారు.


Monitoring a malware's interaction with the system and network will help in gaining a better understanding.

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


The strings utility can extract both ASCII and Unicode strings from a binary file.

స్ట్రింగ్స్ యుటిలిటీ బైనరీ ఫైల్ నుండి ASCII మరియు యూనికోడ్ స్ట్రింగ్స్‌ను సంగ్రహించగలదు.


Malware authors often use obfuscation techniques to hide strings.

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


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

FLOSS అనేది మాల్వేర్ నుండి అస్పష్టమైన స్ట్రింగ్‌లను స్వయంచాలకంగా గుర్తించడానికి మరియు సంగ్రహించడానికి రూపొందించబడిన ఒక సాధనం.


You can download FLOSS for Windows or Linux from the provided link.

మీరు అందించిన లింక్ నుండి Windows లేదా Linux కోసం FLOSSని డౌన్‌లోడ్ చేసుకోవచ్చు.


Running FLOSS on a malware sample can reveal hidden strings.

మాల్వేర్ నమూనాపై FLOSSని అమలు చేయడం వలన దాచిన స్ట్రింగ్‌లను వెల్లడిస్తుంది.


Malware authors use packers and cryptors to obfuscate their files.

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


Packers compress the executable's content to obfuscate it.

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


A Cryptor uses encryption instead of compression.

ఒక క్రిప్టర్ కుదింపుకు బదులుగా ఎన్‌క్రిప్షన్‌ను ఉపయోగిస్తుంది.


File obfuscation makes it difficult to detect and analyze the binary.

ఫైల్ అస్పష్టత బైనరీని గుర్తించడం మరియు విశ్లేషించడం కష్టతరం చేస్తుంది.


UPX is a common packer used to compress executables.

UPX అనేది ఎగ్జిక్యూటబుల్స్‌ను కుదించడానికి ఉపయోగించే ఒక సాధారణ ప్యాకర్.


The size of a packed binary is often smaller than the original.

ప్యాక్ చేయబడిన బైనరీ పరిమాణం తరచుగా అసలు దానికంటే చిన్నదిగా ఉంటుంది.


Exeinfo PE can help detect packers on Windows.

Exeinfo PE విండోస్‌లో ప్యాకర్లను గుర్తించడంలో సహాయపడుతుంది.


Windows executables must conform to the PE/COFF format.

విండోస్ ఎగ్జిక్యూటబుల్స్ PE/COFF ఫార్మాట్‌కు అనుగుణంగా ఉండాలి.


The PE header describes the structure of the executable.

PE హెడర్ ఎగ్జిక్యూటబుల్ యొక్క నిర్మాణాన్ని వివరిస్తుంది.


Examining the PE header yields a wealth of information.

PE హెడర్‌ను పరిశీలించడం వలన చాలా సమాచారం లభిస్తుంది.


Malware often interacts with files, the registry, and the network.

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


Inspect the DLLs and API functions to understand malware functionality.

మాల్వేర్ కార్యాచరణను అర్థం చేసుకోవడానికి DLLలు మరియు API ఫంక్షన్లను పరిశీలించండి.


Pestudio displays the DLL files an executable depends on.

Pestudio ఒక ఎగ్జిక్యూటబుల్ ఆధారపడే DLL ఫైల్‌లను ప్రదర్శిస్తుంది.


Imports can help you detect whether a malware sample is obfuscated.

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


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

ఎగుమతి చేయబడిన ఫంక్షన్లు DLL యొక్క సామర్థ్యాల గురించి మీకు తక్షణ ఆలోచనను అందిస్తాయి.


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.

మీరు మాల్వేర్ విశ్లేషణ రంగంలో కొత్తవారైతే, ఈ పుస్తకం మీకు ప్రారంభించడానికి సహాయపడుతుంది.


The growing threat of cyberattacks on critical infrastructure poses a unique challenge.

క్లిష్టమైన మౌలిక సదుపాయాలపై సైబర్ దాడుల ముప్పు పెరుగుదల ఒక ప్రత్యేకమైన సవాలును కలిగిస్తుంది.


Malware analysis requires a well-balanced knowledge of many different skills.

మాల్వేర్ విశ్లేషణకు అనేక విభిన్న నైపుణ్యాల గురించి బాగా సమతుల్య జ్ఞానం అవసరం.


This book starts by introducing you to basic concepts of malware analysis.

ఈ పుస్తకం మిమ్మల్ని మాల్వేర్ విశ్లేషణ యొక్క ప్రాథమిక భావనలకు పరిచయం చేయడంతో ప్రారంభమవుతుంది.


It then gradually progresses deep into more advanced concepts of code analysis and memory forensics.

అది క్రమంగా కోడ్ విశ్లేషణ మరియు మెమరీ ఫోరెన్సిక్స్ యొక్క మరింత అధునాతన భావనలలోకి ప్రవేశిస్తుంది.


To help you understand the concepts better, various real-world malware samples are used.

భావనలను బాగా అర్థం చేసుకోవడానికి, వివిధ వాస్తవ-ప్రపంచ మాల్వేర్ నమూనాలను ఉపయోగిస్తారు.


If you're an incident responder, this book is for you.

మీరు ఒక సంఘటన ప్రతిస్పందకులైతే, ఈ పుస్తకం మీ కోసం.


Knowledge of programming languages such as C and Python would be helpful.

సి మరియు పైథాన్ వంటి ప్రోగ్రామింగ్ భాషల జ్ఞానం సహాయకరంగా ఉంటుంది.


You may need to do some additional reading to fully understand the concepts.

భావనలను పూర్తిగా అర్థం చేసుకోవడానికి మీరు కొంత అదనపు పఠనం చేయవలసి ఉంటుంది.


The advancement of technology has revolutionized the way organizations conduct business.

సాంకేతిక పరిజ్ఞానం యొక్క అభివృద్ధి సంస్థలు వ్యాపారం చేసే విధానంలో విప్లవాత్మక మార్పులు తెచ్చింది.


These cyberattacks make use of malicious software for financial theft.

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


With adversaries becoming sophisticated, detecting intrusions is critical.

ప్రతికూలురు అధునాతనంగా మారుతున్నందున, చొరబాట్లను గుర్తించడం చాలా కీలకం.


Whether you are learning malware analysis for fun, this book enables you to accomplish your goals.

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


If you have written a few lines of code, you’ll be able to get the most out of this book.

మీరు కొన్ని లైన్ల కోడ్ రాసినట్లయితే, మీరు ఈ పుస్తకం నుండి ఎక్కువ ప్రయోజనం పొందగలరు.


You can make a general application, or submit your own idea.

మీరు సాధారణ అప్లికేషన్ చేయవచ్చు లేదా మీ స్వంత ఆలోచనను సమర్పించవచ్చు.


The book covers various persistence methods used by malicious programs.

ఈ పుస్తకం హానికరమైన ప్రోగ్రామ్‌లు ఉపయోగించే వివిధ నిరంతర పద్ధతులను కవర్ చేస్తుంది.


It also describes the hooking techniques used by the malware.

మాల్వేర్ ఉపయోగించే హుకింగ్ పద్ధతులను కూడా ఇది వివరిస్తుంది.


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?

మీరు ఈ పుస్తకాన్ని చదివి ఉపయోగించిన తర్వాత, మీరు కొనుగోలు చేసిన సైట్‌లో సమీక్షను ఎందుకు ఉంచకూడదు?


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

బాధితుడి వ్యవస్థకు అనధికారికంగా యాక్సెస్


బాధితులపై గూఢచర్యం చేయడం


స్పామ్ ఇమెయిల్స్ పంపడం


Engaging in distributed-denial-of-service attacks (DDOS)

పంపిణీ చేయబడిన-సేవా-నిరాకరణ దాడులలో పాల్గొనడం (DDOS)


Locking up the files on the computer and holding them for ransom

కంప్యూటర్‌లోని ఫైల్‌లను లాక్ చేయడం మరియు వాటిని విమోచన కోసం ఉంచడం


Drop are set to Bidirectional. Click on OK.

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


At this point, the Linux VM is configured to use Host-only mode, and INetSim is set up to simulate all the services.

ఈ సమయంలో, Linux VM హోస్ట్-ఓన్లీ మోడ్‌ను ఉపయోగించడానికి కాన్ఫిగర్ చేయబడింది మరియు అన్ని సేవలను అనుకరించడానికి INetSim సెటప్ చేయబడింది.


The last step is to take a snapshot (clean snapshot) and give it a name of your choice so that you can revert it back to the clean state when required.

చివరి దశ ఏమిటంటే స్నాప్‌షాట్ (క్లీన్ స్నాప్‌షాట్) తీసుకోవడం మరియు మీకు నచ్చిన పేరును ఇవ్వడం, తద్వారా అవసరమైనప్పుడు మీరు దానిని శుభ్రమైన స్థితికి మార్చవచ్చు.


To take a snapshot on VMware workstation, click on VM | Snapshot | Take Snapshot.

VMware వర్క్‌స్టేషన్‌లో స్నాప్‌షాట్ తీసుకోవడానికి, VM | స్నాప్‌షాట్ | స్నాప్‌షాట్ తీసుకోండి క్లిక్ చేయండి.


On Virtualbox, the same can be done by clicking on Machine | Take Snapshot.

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


Apart from the drag and drop feature, 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 (Windows 7, Window 8, and so on) of your choice in the virtualization software.

Windows VMని సెటప్ చేయడానికి ముందు, మీరు మొదట వర్చువలైజేషన్ సాఫ్ట్‌వేర్‌లో మీకు నచ్చిన Windows ఆపరేటింగ్ సిస్టమ్‌ను (Windows 7, Window 8, మొదలైనవి) ఇన్‌స్టాల్ చేయాలి.


Download Python from https://www.python.org/downloads/.

https://www.python.org/downloads/ నుండి పైథాన్‌ను డౌన్‌లోడ్ చేయండి.


Be sure to download Python 2.7.x (such as 2.7.13); most of the scripts used in this book are written to run on the Python 2.7 version and may not run correctly on Python 3.

Python 2.7.x (ఉదాహరణకు 2.7.13)ని డౌన్‌లోడ్ చేయడానికి నిర్ధారించుకోండి; ఈ పుస్తకంలో ఉపయోగించిన చాలా స్క్రిప్ట్‌లు Python 2.7 వెర్షన్‌లో రన్ చేయడానికి వ్రాయబడ్డాయి మరియు Python 3లో సరిగ్గా రన్ కాకపోవచ్చు.


Make sure you check the option to install pip and Add python.exe to Path, as shown in the following screenshot.

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


Installing pip will make it easier to install any third-party Python libraries, and adding Python to the path will make it easier to run Python from any location.

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


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

హోస్ట్-ఓన్లీ నెట్‌వర్క్ కాన్ఫిగరేషన్ మోడ్‌లో రన్ చేయడానికి మీ Windows VMని కాన్ఫిగర్ చేయండి.


To do that in VMware or VirtualBox, bring up the Network Settings and choose the Host-only mode; save the settings and reboot.

VMware లేదా VirtualBoxలో దీన్ని చేయడానికి, నెట్‌వర్క్ సెట్టింగ్‌లను తీసుకురండి మరియు హోస్ట్-ఓన్లీ మోడ్‌ను ఎంచుకోండి; సెట్టింగ్‌లను సేవ్ చేసి, రీబూట్ చేయండి.


Configure the IP address of the Windows VM to 192.168.1.x (choose any IP address except 192.168.1.100 because the Linux VM is set to use that IP) and set up your Default gateway and the DNS server to the IP address of Linux VM (that is, 192.168.1.100).

Windows VM యొక్క IP చిరునామాను 192.168.1.xకి కాన్ఫిగర్ చేయండి (Linux VM ఆ IPని ఉపయోగించడానికి సెట్ చేయబడినందున 192.168.1.100 మినహా ఏదైనా IP చిరునామాను ఎంచుకోండి) మరియు మీ డిఫాల్ట్ గేట్‌వే మరియు DNS సర్వర్‌ను Linux VM యొక్క IP చిరునామాకు సెటప్ చేయండి (అంటే, 192.168.1.100).


This configuration is required so that when we execute the hostile program on the Windows VM, all of the network traffic will be routed through the Linux VM.

విండోస్ VMలో శత్రు ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, మొత్తం నెట్‌వర్క్ ట్రాఫిక్ లైనక్స్ VM ద్వారా రూట్ చేయబడేలా ఈ కాన్ఫిగరేషన్ అవసరం.


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

Linux VM మరియు Windows VM రెండింటినీ ఆన్ చేయండి మరియు అవి ఒకదానితో ఒకటి కమ్యూనికేట్ చేయగలవని నిర్ధారించుకోండి.


You can check for the connectivity by running the ping command, as shown in this screenshot:

ఈ స్క్రీన్‌షాట్‌లో చూపిన విధంగా, పింగ్ కమాండ్ రన్ చేయడం ద్వారా మీరు కనెక్టివిటీని తనిఖీ చేయవచ్చు:


Windows Defender Service needs to be disabled on your Windows VM as it may interfere when you are executing the malware sample.

మీరు మాల్వేర్ నమూనాను అమలు చేస్తున్నప్పుడు ఇది జోక్యం చేసుకోవచ్చు కాబట్టి మీ Windows VMలో Windows డిఫెండర్ సేవను నిలిపివేయాలి.


To do that, press the Windows key + R to open the Run menu, enter gpedit.msc, and hit Enter to launch the Local Group Policy Editor.

అలా చేయడానికి, రన్ మెనుని తెరవడానికి Windows కీ + R నొక్కండి, gpedit.mscని నమోదు చేయండి మరియు లోకల్ గ్రూప్ పాలసీ ఎడిటర్‌ను ప్రారంభించడానికి ఎంటర్ నొక్కండి.


In the left-hand pane of Local Group Policy Editor, navigate to Computer Configuration | Administrative Templates | Windows Components | Windows Defender.

లోకల్ గ్రూప్ పాలసీ ఎడిటర్ యొక్క ఎడమ వైపున ఉన్న పేన్‌లో, కంప్యూటర్ కాన్ఫిగరేషన్ | అడ్మినిస్ట్రేటివ్ టెంప్లేట్‌లు | విండోస్ భాగాలు | విండోస్ డిఫెండర్‌కి నావిగేట్ చేయండి.


The DLL's entry point function did not implement any functionality.

DLL యొక్క ప్రారంభ బిందువు ఫంక్షన్ ఏ విధమైన కార్యాచరణను అమలు చేయలేదు.


Running the sample with the DllRegisterServer function triggered an HTTPS communication.

DllRegisterServer ఫంక్షన్‌తో నమూనాను అమలు చేయడం వలన HTTPS కమ్యూనికేషన్ ప్రారంభమైంది.


You can write a script to determine all the exported functions in a DLL.

మీరు 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.

DLL (SearchCache.dll) _flushfile@16 అనే ఎగుమతి ఫంక్షన్‌ను కలిగి ఉంది.


This export function accepts an argument, which is the file to delete.

ఈ ఎగుమతి ఫంక్షన్ ఒక వాదనను అంగీకరిస్తుంది, ఇది తొలగించవలసిన ఫైల్.


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.

ఎగుమతి ఫంక్షన్ ద్వారా అంగీకరించబడిన పారామితులను మరియు పారామితుల రకాన్ని నిర్ణయించడానికి, మీరు కోడ్ విశ్లేషణను నిర్వహించాలి.


Some DLLs check if they are running under a particular process.

కొన్ని DLLలు అవి ఒక నిర్దిష్ట ప్రక్రియలో నడుస్తున్నాయో లేదో తనిఖీ చేస్తాయి.


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

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


This DLL does not contain any exports; all of the malicious behavior is implemented in the DLL's entry point function.

ఈ DLL ఎటువంటి ఎగుమతులను కలిగి ఉండదు; అన్ని హానికరమైన ప్రవర్తన DLL యొక్క ప్రారంభ బిందువు ఫంక్షన్‌లో అమలు చేయబడింది.


Running the DLL using the following command generated an error.

కింది ఆదేశాన్ని ఉపయోగించి DLLని అమలు చేయడం వలన లోపం ఏర్పడింది.


After analyzing the code, it was found that the DLL, in its entry point function, performed a check.

కోడ్‌ను విశ్లేషించిన తర్వాత, DLL, దాని ప్రారంభ బిందువు ఫంక్షన్‌లో, ఒక తనిఖీని నిర్వహించిందని కనుగొనబడింది.


To trigger the behavior, malicious DLL had to be injected into the spoolsv.exe process.

ప్రవర్తనను ప్రేరేపించడానికి, హానికరమైన DLLని spoolsv.exe ప్రక్రియలోకి ఇంజెక్ట్ చేయవలసి వచ్చింది.


The malware created a folder (resycled) and a file autorun.inf on the C:\ drive.

మాల్వేర్ C:\ డ్రైవ్‌లో (resycled) అనే ఫోల్డర్‌ను మరియు autorun.inf అనే ఫైల్‌ను సృష్టించింది.


The malware added the following registry entries.

మాల్వేర్ కింది రిజిస్ట్రీ ఎంట్రీలను జోడించింది.


During malware investigation, you may come across DLL, that will run only when it is loaded as a service.

మాల్వేర్ పరిశోధన సమయంలో, మీరు ఒక DLLని ఎదుర్కొనవచ్చు, అది సర్వీస్‌గా లోడ్ అయినప్పుడు మాత్రమే రన్ అవుతుంది.


Dynamic analysis is a great technique to understand the behavior of malware.

మాల్వేర్ ప్రవర్తనను అర్థం చేసుకోవడానికి డైనమిక్ విశ్లేషణ ఒక గొప్ప పద్ధతి.


Combining static analysis and dynamic analysis helps you gain a better understanding of the malware binary.

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


The code after the 'else' block is executed.

'else' బ్లాక్ తర్వాత కోడ్ అమలు చేయబడుతుంది.


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

x సున్నాకి సమానంగా లేకపోతే షరతులతో కూడిన జంప్ తీసుకోబడుతుంది.


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 సున్నాకి సమానంగా ఉంటే, 'else' బ్లాక్ దాటవేయబడుతుంది.


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

ఈ కోడ్ 'if-ElseIf-else' స్టేట్‌మెంట్లను కలిగి ఉంది.


రెండు షరతులతో కూడిన జంప్ పాయింట్లు ఉన్నాయి.


The jump is taken to the 'else_if' block.

జంప్ 'else_if' బ్లాక్‌కి తీసుకోబడుతుంది.


Both unconditional jumps skip the 'else' statement.

రెండు షరతులు లేని జంప్‌లు 'else' స్టేట్‌మెంట్‌ను దాటవేస్తాయి.


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

కోడ్‌ను దాని హై-లెవెల్ సమానంగా అనువదిద్దాం.


The conditional statement is identified.

షరతులతో కూడిన స్టేట్‌మెంట్ గుర్తించబడింది.


This has the characteristics of 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 సున్నాకి సమానంగా ఉన్నప్పుడు జంప్ తీసుకోబడదు.


Loops execute a block of code until some condition is met.

కొన్ని షరతు నెరవేరే వరకు లూప్‌లు కోడ్ బ్లాక్‌ను అమలు చేస్తాయి.


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

'for' మరియు 'while' అనేవి రెండు సాధారణ రకాల లూప్‌లు.


The initialization statement is executed only once.

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


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

రెండు సందర్భాల్లోనూ, i 5 కంటే ఎక్కువ లేదా సమానంగా మారినప్పుడు, ఒక జంప్ తీసుకోబడుతుంది.


The code is checking if i is greater than or equal to 5.

i 5 కంటే ఎక్కువ లేదా సమానంగా ఉందో లేదో కోడ్ తనిఖీ చేస్తోంది.


x విలువ 1కి పెంచబడింది.


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

ఒక ఫంక్షన్ అనేది నిర్దిష్ట పనులను నిర్వహించే కోడ్ బ్లాక్.


Let's assume that 100 was stored at the memory address starting at 0x403000.

0x403000 వద్ద ప్రారంభమయ్యే మెమరీ చిరునామాలో 100 నిల్వ చేయబడిందని అనుకుందాం.


To move a value from the memory into a register in assembly language, you must use the address of the value.

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


The square bracket specifies that you want the value stored at the memory location, rather than the address itself.

చదరపు బ్రాకెట్ మీరు చిరునామాకు బదులుగా మెమరీ స్థానంలో నిల్వ చేయబడిన విలువను కోరుకుంటున్నారని పేర్కొంటుంది.


mov eax,[0x403000] ; eax will now contain 00 00 00 64 (i.e 100)

mov eax,[0x403000] ; ఇప్పుడు eax 00 00 00 64 (అంటే 100)ని కలిగి ఉంటుంది.


During reverse engineering, you will normally see instructions similar to the ones shown as below.

రివర్స్ ఇంజనీరింగ్ సమయంలో, మీరు సాధారణంగా క్రింద చూపిన వాటికి సమానమైన సూచనలను చూస్తారు.


The simplest thing to remember is that everything within the square brackets represents an address.

గుర్తుంచుకోవలసిన సులభమైన విషయం ఏమిటంటే, చదరపు బ్రాకెట్‌లలోని ప్రతిదీ ఒక చిరునామాను సూచిస్తుంది.


mov eax,[ebx] ; moves value at address specifed by ebx register

mov eax,[ebx] ; ebx రిజిస్టర్ ద్వారా పేర్కొనబడిన చిరునామా వద్ద విలువను తరలిస్తుంది


Another instruction that you will normally come across is the lea instruction, which stands for load effective address.

మీరు సాధారణంగా ఎదుర్కొనే మరొక సూచన lea సూచన, ఇది లోడ్ ఎఫెక్టివ్ చిరునామాకు అర్థం.


lea ebx,[0x403000] ; loads the address 0x403000 into ebx

lea ebx,[0x403000] ; చిరునామా 0x403000ని ebx లోకి లోడ్ చేస్తుంది


You can move a value from a register to memory by swapping operands so that the memory address is on the left-hand side.

మెమరీ చిరునామా ఎడమ వైపున ఉండేలా ఆపరేండ్‌లను మార్చుకోవడం ద్వారా మీరు రిజిస్టర్ నుండి మెమరీకి విలువను తరలించవచ్చు.


mov [0x403000],eax ; moves 4 byte value in eax to memory location starting at 0x403000

mov [0x403000],eax ; eax లోని 4 బైట్ విలువను 0x403000 వద్ద ప్రారంభమయ్యే మెమరీ స్థానానికి తరలిస్తుంది


mov dword ptr [402000],13498h ; moves dword value 0x13496 into the address 0x402000

mov dword ptr [402000],13498h ; dword విలువ 0x13496 ని 0x402000 చిరునామాలోకి తరలిస్తుంది


Let's take a look at a simple challenge.

ఒక సాధారణ సవాలును చూద్దాం.


Can you figure out what this code snippet does, and can you translate it back to a pseudocode?

ఈ కోడ్ స్నిప్పెట్ ఏమి చేస్తుందో మీరు గుర్తించగలరా మరియు మీరు దానిని తిరిగి ఒక సూడోకోడ్‌గా అనువదించగలరా?


The preceding program copies a value from one memory location to another.

మునుపటి ప్రోగ్రామ్ ఒక మెమరీ స్థానం నుండి మరొకదానికి విలువను కాపీ చేస్తుంది.


In a high-level language, when you assign a value to a variable, let's say val = 1, the value 1 is moved into the address represented by the val variable.

ఒక ఉన్నత స్థాయి భాషలో, మీరు ఒక వేరియబుల్‌కు విలువను కేటాయించినప్పుడు, val = 1 అని అనుకుందాం, విలువ 1 val వేరియబుల్ ద్వారా సూచించబడే చిరునామాలోకి తరలించబడుతుంది.


Recall that, the registers are used by the CPU for temporary storage.

రిజిస్టర్‌లు తాత్కాలిక నిల్వ కోసం CPU ద్వారా ఉపయోగించబడతాయని గుర్తుంచుకోండి.


In this section, you will learn the assembly instructions that operate on the bits.

ఈ విభాగంలో, మీరు బిట్‌లపై పనిచేసే అసెంబ్లీ సూచనలను నేర్చుకుంటారు.


The left-most bit is called the most significant bit.

ఎడమ వైపున ఉన్న బిట్‌ను అత్యంత ముఖ్యమైన బిట్ అంటారు.


The and, or, and xor instructions perform bitwise and, or, and xor operations and store the results in the destination.

మరియు, లేదా మరియు xor సూచనలు బిట్‌వైజ్ మరియు, లేదా మరియు xor కార్యకలాపాలను నిర్వహిస్తాయి మరియు ఫలితాలను గమ్యస్థానంలో నిల్వ చేస్తాయి.


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.

శబ్దాన్ని తగ్గించడానికి, మీరు ఫిల్టరింగ్ లక్షణాలను ఉపయోగించవచ్చు, ఇది అవాంఛిత ఎంట్రీలను దాచిపెడుతుంది మరియు నిర్దిష్ట లక్షణాలపై ఫిల్టర్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.


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 text file contains events segregated based on the categories (like process, file, registry, and network activity) in separate sections.

టెక్స్ట్ ఫైల్ ఈవెంట్‌లను వర్గాల ఆధారంగా వేరు చేస్తుంది (ప్రాసెస్, ఫైల్, రిజిస్ట్రీ మరియు నెట్‌వర్క్ కార్యాచరణ వంటివి) ప్రత్యేక విభాగాలలో.


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

CSV ఫైల్ అన్ని ఈవెంట్‌లను కలిగి ఉంది (ప్రాసెస్, ఫైల్, రిజిస్ట్రీ మరియు నెట్‌వర్క్ కార్యాచరణ) కాలక్రమం ద్వారా క్రమబద్ధీకరించబడింది.


When the malware is executed, you will want to capture the network traffic generated as a result of running the malware.

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


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

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


Most malware, when executed, reach out to the internet (command and control server).

ఎక్కువ మాల్వేర్ అమలు చేసినప్పుడు, ఇంటర్నెట్‌ను (కమాండ్ మరియు కంట్రోల్ సర్వర్) సంప్రదిస్తుంది.


INetSim is a free Linux-based software suite for simulating standard internet services.

INetSim అనేది ప్రామాణిక ఇంటర్నెట్ సేవలను అనుకరించడానికి ఉచిత లైనక్స్ ఆధారిత సాఫ్ట్‌వేర్ సూట్.


During malware analysis, you need to determine the behavior of the malware without allowing it to contact the actual command and control (C2) server.

మాల్వేర్ విశ్లేషణ సమయంలో, మీరు వాస్తవ కమాండ్ మరియు కంట్రోల్ (C2) సర్వర్‌ను సంప్రదించడానికి అనుమతించకుండానే మాల్వేర్ ప్రవర్తనను గుర్తించాలి.


By simulating the services, it was possible to determine that the malware downloads a file from the C2 server after execution.

సేవలను అనుకరించడం ద్వారా, మాల్వేర్ అమలు చేసిన తర్వాత C2 సర్వర్ నుండి ఫైల్‌ను డౌన్‌లోడ్ చేస్తుందని గుర్తించడం సాధ్యమైంది.


Reverting to the clean snapshot: This includes reverting your virtual machines to a clean state.

శుభ్రమైన స్నాప్‌షాట్‌కు తిరిగి వెళ్లడం: ఇందులో మీ వర్చువల్ మెషీన్‌లను శుభ్రమైన స్థితికి మార్చడం కూడా ఉంది.


In this step, you will run the monitoring tools before executing the malware specimen.

ఈ దశలో, మీరు మాల్వేర్ నమూనాను అమలు చేయడానికి ముందు మానిటరింగ్ సాధనాలను అమలు చేస్తారు.


Once you have an understanding of the dynamic analysis tools and steps involved in dynamic analysis, these tools can be used together to glean maximum information from the malware sample.

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


We will start by determining the file type and the cryptographic hash.

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


Examining the imports shows references to file system-and registry-related API calls.

దిగుమతులను పరిశీలించడం ఫైల్ సిస్టమ్ మరియు రిజిస్ట్రీకి సంబంధించిన API కాల్‌లకు సూచనలను చూపుతుంది.


To summarize, when malware is executed, it copies itself into the %AppData% directory as iexplorer.exe.

సంగ్రహంగా చెప్పాలంటే, మాల్వేర్ అమలు చేయబడినప్పుడు, అది తనను తాను %AppData% డైరెక్టరీలోకి iexplorer.exeగా కాపీ చేస్తుంది.


A Dynamic-Link Library (DLL) is a module that contains functions that can be used by another program.

డైనమిక్-లింక్ లైబ్రరీ (DLL) అనేది మరొక ప్రోగ్రామ్ ఉపయోగించగల ఫంక్షన్లను కలిగి ఉన్న ఒక మాడ్యూల్.


You will often see malware authors distributing their malicious code as DLL instead of executable files.

మీరు తరచుగా మాల్వేర్ రచయితలు వారి హానికరమైన కోడ్‌ను ఎగ్జిక్యూటబుల్ ఫైల్‌లకు బదులుగా DLLలుగా పంపిణీ చేయడాన్ని చూస్తారు.


On Windows, rundll32.exe can be used to launch a DLL and to invoke functions exported from the DLL.

విండోస్‌లో, rundll32.exeని DLLని ప్రారంభించడానికి మరియు DLL నుండి ఎగుమతి చేయబడిన ఫంక్షన్లను అమలు చేయడానికి ఉపయోగించవచ్చు.


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)ను సర్దుబాటు చేస్తుంది.


Such a function is said to be using cdecl calling convention.

అటువంటి ఫంక్షన్ cdecl కాలింగ్ కన్వెన్షన్‌ను ఉపయోగిస్తుందని చెప్పబడింది.


The calling convention dictates how the parameters should be passed and who (caller or the callee) is responsible for removing them from the stack once the called function has completed.

కాలింగ్ కన్వెన్షన్ పారామితులను ఎలా పాస్ చేయాలో మరియు పిలువబడిన ఫంక్షన్ పూర్తయిన తర్వాత వాటిని స్టాక్ నుండి తీసివేయడానికి ఎవరు (కాలర్ లేదా కాలీ) బాధ్యత వహిస్తారో నిర్దేశిస్తుంది.


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

చాలా కంపైల్ చేయబడిన సి ప్రోగ్రామ్‌లు సాధారణంగా 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.

మీరు సాధారణంగా fastcall కాలింగ్ కన్వెన్షన్‌ను అనుసరించే 64-బిట్ ప్రోగ్రామ్‌లను చూస్తారు.


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

శ్రేణి పేరు nums అనేది శ్రేణి యొక్క మొదటి మూలకాన్ని సూచించే పాయింటర్ స్థిరం (అంటే, శ్రేణి పేరు శ్రేణి యొక్క బేస్ చిరునామాను సూచిస్తుంది).


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 అనేది సూచిక మరియు nums శ్రేణి యొక్క బేస్ చిరునామాను సూచిస్తుంది.


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

ఒక ఫంక్షన్ వ్యాఖ్యను జోడించడానికి, ఫంక్షన్ పేరును హైలైట్ చేసి, కొలన్ నొక్కండి (:).


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

సూడోకోడ్ ఇప్పుడు ఫంక్షన్ యొక్క ప్రవర్తనను మీకు గుర్తు చేయగలదు.


When an executable is loaded into IDA, it creates a database.

ఒక ఎగ్జిక్యూటబుల్ IDA లోకి లోడ్ అయినప్పుడు, అది ఒక డేటాబేస్ను సృష్టిస్తుంది.


Any modifications that you make are saved in the database.

మీరు చేసే ఏవైనా మార్పులు డేటాబేస్లో సేవ్ చేయబడతాయి.


You can save the database by closing IDA.

IDA ని మూసివేయడం ద్వారా మీరు డేటాబేస్ను సేవ్ చేయవచ్చు.


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

మరొక సాధారణ ప్రోగ్రామ్ను చూద్దాం మరియు IDA యొక్క మరికొన్ని లక్షణాలను అన్వేషిద్దాం.


IDA మూడు స్థానిక వేరియబుల్లను గుర్తించింది.


IDA also identified the global variables and assigned names.

IDA గ్లోబల్ వేరియబుల్లను కూడా గుర్తించింది మరియు పేర్లను కేటాయించింది.


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

వేరియబుల్స్ యొక్క చిరునామాలను ఉపయోగిస్తున్నాయని సూచించడానికి IDA ఆఫ్సెట్ కీవర్డ్ను ఉపయోగించింది.


You can rename these addresses to more meaningful names using the rename option.

పేరు మార్చు ఎంపికను ఉపయోగించి మీరు ఈ చిరునామాలను మరింత అర్థవంతమైన పేర్లకు మార్చవచ్చు.


IDA gives you the ability to reformat constant values.

స్థిరమైన విలువలను తిరిగి ఫార్మాట్ చేసే సామర్థ్యాన్ని IDA మీకు అందిస్తుంది.


మీ అవసరాలకు తగిన వాటిని ఎంచుకోండి.


Another great feature of IDA is that it makes navigating to anywhere within a program much easier.

IDA యొక్క మరొక గొప్ప లక్షణం ఏమిటంటే, ఇది ప్రోగ్రామ్లో ఎక్కడికైనా నావిగేట్ చేయడం చాలా సులభం చేస్తుంది.


When a program is disassembled, IDA labels every location.

ఒక ప్రోగ్రామ్ను విడగొట్టినప్పుడు, IDA ప్రతి స్థానానికి లేబుల్స్ ఇస్తుంది.


Double-clicking on the locations will jump the display to the selected location.

స్థానాలపై రెండుసార్లు క్లిక్ చేయడం వలన ప్రదర్శన ఎంచుకున్న స్థానానికి వెళుతుంది.


IDA keeps track of your navigation history.

IDA మీ నావిగేషన్ చరిత్రను ట్రాక్ చేస్తుంది.


To jump to a particular address, click on Jump | Jump to Address.

ఒక నిర్దిష్ట చిరునామాకు వెళ్లడానికి, జంప్ | చిరునామాకు వెళ్లండి క్లిక్ చేయండి.


Another way to navigate is by using cross-references.

నావిగేట్ చేయడానికి మరొక మార్గం క్రాస్-రిఫరెన్స్లను ఉపయోగించడం.


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

క్రాస్-రిఫరెన్స్లు డేటా క్రాస్-రిఫరెన్స్లు లేదా కోడ్ క్రాస్-రిఫరెన్స్లు కావచ్చు.


The graph view is especially useful to get a visual representation of branching/looping statements.

బ్రాంచింగ్/లూపింగ్ స్టేట్మెంట్స్ యొక్క దృశ్యమాన ప్రాతినిధ్యాన్ని పొందడానికి గ్రాఫ్ వీక్షణ ప్రత్యేకంగా ఉపయోగపడుతుంది.


The disassembly of the C code is for a 64-bit processor.

సి కోడ్ యొక్క విడదీయడం 64-బిట్ ప్రాసెసర్ కోసం.


The first instruction allocates 56 bytes of space on the stack.

మొదటి సూచన స్టాక్‌లో 56 బైట్‌ల స్థలాన్ని కేటాయిస్తుంది.


The parameters are stored in registers before the call to printf.

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


The fifth and sixth parameters are stored on the stack.

ఐదవ మరియు ఆరవ పరామితులు స్టాక్‌లో నిల్వ చేయబడతాయి.


The push instruction was not used in this case.

ఈ సందర్భంలో పుష్ సూచన ఉపయోగించబడలేదు.


It's difficult to determine if the memory address is a local variable or a parameter.

మెమరీ చిరునామా స్థానిక వేరియబుల్ లేదా పరామితి అని నిర్ణయించడం కష్టం.


The format string helps to determine the number of parameters passed to printf.

ఫార్మాట్ స్ట్రింగ్ ప్రింట్‌ఫ్‌కు పంపబడిన పరామితుల సంఖ్యను నిర్ణయించడంలో సహాయపడుతుంది.


Intel 64 (x64) and IA-32 (x86) architectures consist of many instructions.

ఇంటెల్ 64 (x64) మరియు IA-32 (x86) ఆర్కిటెక్చర్‌లు అనేక సూచనలను కలిగి ఉంటాయి.


You can download the latest Intel architecture manuals from the Intel website.

మీరు ఇంటెల్ వెబ్‌సైట్ నుండి తాజా ఇంటెల్ ఆర్కిటెక్చర్ మాన్యువల్‌లను డౌన్‌లోడ్ చేసుకోవచ్చు.


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

64-బిట్ విండోస్ ఆపరేటింగ్ సిస్టమ్ 32-బిట్ ఎగ్జిక్యూటబుల్‌ను అమలు చేయగలదు.


WOW64 allows for the execution of 32-bit binaries on 64-bit Windows.

WOW64 64-బిట్ విండోస్‌లో 32-బిట్ బైనరీలను అమలు చేయడానికి అనుమతిస్తుంది.


32-bit applications can behave differently under 64-bit Windows.

64-బిట్ విండోస్ కింద 32-బిట్ అప్లికేషన్‌లు భిన్నంగా ప్రవర్తించవచ్చు.


If you find malware accessing the system32 directory, it's really accessing the syswow64 directory.

మీరు మాల్వేర్ సిస్టమ్32 డైరెక్టరీని యాక్సెస్ చేస్తున్నట్లు గుర్తిస్తే, అది నిజంగా syswow64 డైరెక్టరీని యాక్సెస్ చేస్తోంది.


Access to %windir%\regedit.exe is redirected to %windir%\SysWOW64\regedit.exe.

%windir%\regedit.exeకి యాక్సెస్ %windir%\SysWOW64\regedit.exeకి మళ్లించబడుతుంది.


It is essential to understand this difference to avoid confusion during analysis.

విశ్లేషణ సమయంలో గందరగోళాన్ని నివారించడానికి ఈ వ్యత్యాసాన్ని అర్థం చేసుకోవడం చాలా అవసరం.


To get a deeper understanding, refer to The WOW-Effect by Christian Wojner.

మరింత లోతైన అవగాహన కోసం, క్రిస్టియన్ వోజ్నర్ రచించిన ది WOW-ఎఫెక్ట్‌ను చూడండి.


Additional resources are available to help you gain a deeper understanding.

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


In this chapter, you learned concepts and techniques to interpret assembly code.

ఈ అధ్యాయంలో, మీరు అసెంబ్లీ కోడ్‌ను అర్థం చేసుకోవడానికి అవసరమైన భావనలు మరియు పద్ధతులను నేర్చుకున్నారు.


Code analysis is often used to understand the inner workings of a malicious binary.

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


Code analysis tools offer various features to simplify code analysis.

కోడ్ విశ్లేషణ సాధనాలు కోడ్ విశ్లేషణను సరళీకృతం చేయడానికి వివిధ లక్షణాలను అందిస్తాయి.


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 ప్రో మరియు 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.

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


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.

స్టెప్ ఇంటు మరియు స్టెప్ ఓవర్ ఉపయోగించి, మీరు ఒకే సూచనను అమలు చేయవచ్చు.


This option allows you to execute all of the instructions in the current function, until it returns.

ఈ ఎంపిక ప్రస్తుత ఫంక్షన్‌లోని అన్ని సూచనలను అది తిరిగి వచ్చే వరకు అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.


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.

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


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 సామర్థ్యం చాలా ఉపయోగకరంగా ఉంటుంది.


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

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


In this case, from the Windows API documentation, we know that the value 40000000h at ➌ is a symbolic constant that represents GENERIC_WRITE.

ఈ సందర్భంలో, Windows API డాక్యుమెంటేషన్ నుండి, ➌ వద్ద ఉన్న 40000000h విలువ 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 to the one shown in the following snippet.

స్థిరాంకాల స్థానంలో సింబాలిక్ పేర్లను ఉంచిన తర్వాత, విడగొట్టబడిన జాబితా క్రింది స్నిప్పెట్‌లో చూపిన విధంగా అనువదించబడుతుంది.


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

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


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

Windows రెండు సమాంతర APIలను సపోర్ట్ చేస్తుంది: ఒకటి ANSI స్ట్రింగ్‌ల కోసం, మరొకటి Unicode స్ట్రింగ్‌ల కోసం.


You will also see malware using APIs such as CreateFileW; the W at the end specifies that the function takes a Unicode string as input.

మీరు CreateFileW వంటి APIలను ఉపయోగిస్తున్న మాల్వేర్‌ను కూడా చూస్తారు; చివరన ఉన్న W ఫంక్షన్ ఇన్‌పుట్‌గా Unicode స్ట్రింగ్‌ను తీసుకుంటుందని పేర్కొంది.


When Microsoft updates a function that is incompatible with an old function, the updated function has an Ex suffix added to its name.

Microsoft పాత ఫంక్షన్‌తో అనుకూలంగా లేని ఫంక్షన్‌ను అప్‌డేట్ చేసినప్పుడు, అప్‌డేట్ చేయబడిన ఫంక్షన్ దాని పేరుకు Ex సఫిక్స్ ను జోడిస్తుంది.


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

మాల్వేర్ బహుళ API ఫంక్షన్లను ఎలా ఉపయోగిస్తుందో అర్థం చేసుకోవడానికి 32-బిట్ మాల్వేర్‌కు సంబంధించిన ఉదాహరణను చూద్దాం.


Since we are dealing with 32-bit malware, all the parameters to the RegOpenKeyEx API are pushed onto the stack.

మేము 32-బిట్ మాల్వేర్‌తో వ్యవహరిస్తున్నందున, RegOpenKeyEx APIకి సంబంధించిన అన్ని పారామితులు స్టాక్‌పైకి నెట్టబడతాయి.


After the malware opens the handle to the Run registry key by calling RegOpenKeyEx, the returned handle (stored in the phkResult variable ➌) is moved into the ecx register.

మాల్వేర్ RegOpenKeyExని పిలవడం ద్వారా రన్ రిజిస్ట్రీ కీకి హ్యాండిల్‌ను తెరిచిన తర్వాత, తిరిగి వచ్చిన హ్యాండిల్ (phkResult వేరియబుల్ ➌లో నిల్వ చేయబడుతుంది) ecx రిజిస్టర్‌లోకి తరలించబడుతుంది.


You also saw how malware acquires a handle to an object (such as the registry key) and then shares that handle with other API functions.

మాల్వేర్ ఒక వస్తువుకు (రిజిస్ట్రీ కీ వంటిది) ఎలా హ్యాండిల్‌ను పొందుతుందో మరియు ఆ హ్యాండిల్‌ను ఇతర API ఫంక్షన్లతో ఎలా పంచుకుంటుందో కూడా మీరు చూశారు.


In the same manner, you can also replace the constant value 2, passed as the fifth argument, to its symbolic name, CREATE_ALWAYS.

అదే విధంగా, మీరు ఐదవ ఆర్గ్యుమెంట్‌గా పంపబడిన 2 స్థిర విలువను దాని సింబాలిక్ పేరు CREATE_ALWAYSకి కూడా మార్చవచ్చు.


When you are patching an instruction, care needs to be taken to make sure that the instruction alignment is correct.

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


IDA offers scripting capabilities that give you access to the contents of an IDA database.

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


After running the following script commands, the virtual address of the current cursor location and the disassembly text for the given address are displayed in the output window.

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


In a 64-bit function, the stack space is allocated at the beginning of the function.

64-బిట్ ఫంక్షన్ లో, ఫంక్షన్ ప్రారంభంలోనే స్టాక్ స్పేస్ కేటాయించబడుతుంది.


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.

పుష్ మరియు పాప్ సూచనలు లేకపోవడం వలన ఫంక్షన్ ద్వారా అంగీకరించబడిన పారామీటర్ల సంఖ్యను గుర్తించడం కష్టం అవుతుంది.


Another challenge is, if the values are moved into the registers rcx and rdx before the function call, it's hard to say whether they are parameters passed to the function.

మరొక సవాలు ఏమిటంటే, ఫంక్షన్ కాల్ చేయడానికి ముందు విలువలు rcx మరియు rdx రిజిస్టర్‌లలోకి తరలించబడితే, అవి ఫంక్షన్‌కు పంపబడిన పారామీటర్లా అని చెప్పడం కష్టం.


హానికరమైన బైనరీలను డీబగ్ చేయడం


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లో, ఫంక్షన్ పారామీటర్ల యొక్క శీఘ్ర సారాంశాన్ని పొందడానికి సులభమైన మార్గం డిఫాల్ట్ విండోను చూడటం.


From the API documentation, you can tell that the RegSetValueEx API takes 6 parameters.

API డాక్యుమెంటేషన్ నుండి, RegSetValueEx API 6 పారామీటర్లను తీసుకుంటుందని మీరు చెప్పగలరు.


The first parameter value, 0x2c, is the handle to the open registry key.

మొదటి పరామితి విలువ, 0x2c, తెరిచిన రిజిస్ట్రీ కీకి హ్యాండిల్.


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

RegCreateKey లేదా RegOpenKey APIని పిలవడం ద్వారా మాల్వేర్ రిజిస్ట్రీ కీకి హ్యాండిల్‌ను తెరవగలదు.


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ని జోడించడం ద్వారా, మాల్వేర్ logoninit.exe కూడా Userinit.exe ద్వారా ప్రారంభించబడుతుందని నిర్ధారిస్తుంది.


At this point, you should have an understanding of how to debug a malicious executable to understand its functionality.

ఈ సమయంలో, దాని కార్యాచరణను అర్థం చేసుకోవడానికి హానికరమైన ఎగ్జిక్యూటబుల్‌ను ఎలా డీబగ్ చేయాలో మీకు అవగాహన ఉండాలి.


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ని ఉపయోగించడం.


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) చేసినప్పుడు, బ్రేక్‌పాయింట్ చిరునామా పక్కన ఉన్న వ్యాఖ్యను చూడటం ద్వారా ఎగ్జిక్యూషన్ ఎక్కడ పాజ్ చేయబడిందో మీరు ట్రాక్ చేయవచ్చు.


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

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


The malware downloads a component and executes it.

మాల్వేర్ ఒక భాగాన్ని డౌన్‌లోడ్ చేసి అమలు చేస్తుంది.


Downloaders are often used as part of exploit shellcode.

ఎక్స్‌ప్లాయిట్ షెల్‌కోడ్‌లో భాగంగా డౌన్‌లోడర్‌లను ఉపయోగిస్తారు.


The URL for the malware binary is determined by analyzing the arguments of UrlDownloadToFileA().

మాల్వేర్ బైనరీ కోసం URL UrlDownloadToFileA() యొక్క వాదనలను విశ్లేషించడం ద్వారా నిర్ణయించబడుతుంది.


The downloaded executable is saved in the %TEMP% directory.

%TEMP% డైరెక్టరీలో డౌన్‌లోడ్ చేయబడిన ఎగ్జిక్యూటబుల్ సేవ్ చేయబడుతుంది.


The malware then executes the downloaded file using ShellExecuteA() API.

అనంతరం మాల్వేర్ ShellExecuteA() APIని ఉపయోగించి డౌన్‌లోడ్ చేసిన ఫైల్‌ను అమలు చేస్తుంది.


Alternatively, WinExec() or CreateProcess() APIs can also be used.

ప్రత్యామ్నాయంగా, WinExec() లేదా CreateProcess() APIలను కూడా ఉపయోగించవచ్చు.


Monitoring tools like Wireshark are helpful during debugging.

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


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 related APIs.

డ్రాపర్‌లు తరచుగా FindResource(), LoadResource() మరియు ఇతర సంబంధిత APIలను ఉపయోగిస్తారు.


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

రిసోర్స్ హ్యాకర్ సాధనం రిసోర్స్ విభాగంలో PE ఫైల్ ఉనికిని చూపగలదు.


Setting breakpoints on API calls like FindResourceA() is useful.

FindResourceA() వంటి API కాల్స్‌పై బ్రేక్‌పాయింట్‌లను సెట్ చేయడం ఉపయోగకరంగా ఉంటుంది.


The return value of FindResourceA() provides a handle to the resource.

FindResourceA() యొక్క రిటర్న్ విలువ రిసోర్స్‌కు ఒక హ్యాండిల్‌ను అందిస్తుంది.


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

మాల్వేర్ SizeofResource() APIని ఉపయోగించి రిసోర్స్ పరిమాణాన్ని నిర్ణయిస్తుంది.


Malware may use CreateFileA and WriteFile() to drop a DLL.

మాల్వేర్ DLLని వదలడానికి CreateFileA మరియు WriteFile()ని ఉపయోగించవచ్చు.


64-bit droppers use similar API functions, but parameters are passed in registers.

64-బిట్ డ్రాపర్‌లు అదే విధమైన API ఫంక్షన్లను ఉపయోగిస్తాయి, కానీ పారామితులు రిజిస్టర్‌లలో పంపబడతాయి.


Keyloggers intercept and log keystrokes.

కీలాగర్‌లు కీస్ట్రోక్‌లను అడ్డుకుంటాయి మరియు లాగ్ చేస్తాయి.


Attackers use keylogging to steal confidential information.

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


GetAsyncKeyState() and SetWindowsHookEx() are common techniques.

GetAsyncKeyState() మరియు SetWindowsHookEx() సాధారణ పద్ధతులు.


Keyloggers use GetAsyncKeyState() to check the state of each key.

ప్రతి కీ యొక్క స్థితిని తనిఖీ చేయడానికి కీలాగర్‌లు GetAsyncKeyState()ని ఉపయోగిస్తారు.


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.

ఎగ్జిక్యూట్ (డిఫాల్ట్), రైట్ లేదా రీడ్/రైట్‌పై విచ్ఛిన్నం చేయాలా వద్దా అని పేర్కొనడానికి మీరు హార్డ్‌వేర్ బ్రేక్‌పాయింట్‌లను ఉపయోగించవచ్చు.


This breakpoint is useful if you want to know when your program accesses a piece of data (read/write) from a memory location.

మీ ప్రోగ్రామ్ మెమరీ స్థానం నుండి డేటా ముక్కను (రీడ్/రైట్) ఎప్పుడు యాక్సెస్ చేస్తుందో తెలుసుకోవాలనుకుంటే ఈ బ్రేక్‌పాయింట్ ఉపయోగపడుతుంది.


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.

డీబగ్గర్ | బ్రేక్‌పాయింట్‌లు | బ్రేక్‌పాయింట్ జాబితాకు నావిగేట్ చేయడం ద్వారా మీరు యాక్టివ్ బ్రేక్‌పాయింట్‌లన్నింటినీ చూడవచ్చు.


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

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


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

32-బిట్ మాల్వేర్ నమూనా నుండి డిస్అసెంబ్లీ జాబితాను పరిగణించండి.


The malware calls the CreateFileW API to create a file, but, just by looking at the disassembly listing, it is not clear what file the malware creates.

మాల్వేర్ ఫైల్‌ను సృష్టించడానికి 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, and then run the program.

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


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

CreateFileWకి కాల్ చేసిన తర్వాత, ఫైల్‌కు సంబంధించిన హ్యాండిల్ eax రిజిస్టర్‌లో తిరిగి ఇవ్వబడుతుంది.


You can use the Hex-View window in IDA to inspect the contents of any valid memory location.

ఏదైనా చెల్లుబాటు అయ్యే మెమరీ స్థానం యొక్క కంటెంట్‌లను తనిఖీ చేయడానికి మీరు IDAలో Hex-View విండోను ఉపయోగించవచ్చు.


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 malware, after creating the file, passes the file handle as the first argument to the WriteFile function.

ఫైల్‌ను సృష్టించిన తర్వాత, మాల్వేర్ ఫైల్ హ్యాండిల్‌ను WriteFile ఫంక్షన్‌కు మొదటి వాదనగా పంపుతుంది.


To determine what content it writes to the file, you can inspect the second argument to the WriteFile function.

ఫైల్‌కు ఏమి కంటెంట్ వ్రాస్తుందో తెలుసుకోవడానికి, మీరు WriteFile ఫంక్షన్‌కు రెండవ వాదనను తనిఖీ చేయవచ్చు.


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

ఈ విభాగంలో, మీరు IDAని ఉపయోగించి DLLని డీబగ్ చేయడానికి, అధ్యాయం 3, డైనమిక్ అనాలిసిస్‌లో మీరు నేర్చుకున్న కొన్ని భావనలను ఉపయోగిస్తారు.


To debug a DLL using the IDA debugger, you first need to designate the executable (such as rundll32.exe) that will be used to load the DLL.

IDA డీబగ్గర్‌ని ఉపయోగించి DLLని డీబగ్ చేయడానికి, మీరు మొదట DLLని లోడ్ చేయడానికి ఉపయోగించే ఎగ్జిక్యూటబుల్ (rundll32.exe వంటివి)ని నియమించాలి.


Set a breakpoint (F2) at the first instruction in the DLLMain function.

DLLMain ఫంక్షన్‌లోని మొదటి సూచన వద్ద బ్రేక్‌పాయింట్‌ను (F2) సెట్ చేయండి.


You can also set breakpoints on any function exported by the DLL by navigating to it from IDA's Exports window.

మీరు IDA యొక్క ఎగుమతుల విండో నుండి నావిగేట్ చేయడం ద్వారా DLL ద్వారా ఎగుమతి చేయబడిన ఏదైనా ఫంక్షన్‌లపై బ్రేక్‌పాయింట్‌లను కూడా సెట్ చేయవచ్చు.


The malware performs actions based on commands from the C2 server.

C2 సర్వర్ నుండి వచ్చిన ఆదేశాల ఆధారంగా మాల్వేర్ చర్యలు తీసుకుంటుంది.


To understand the malware's functions, see the author's presentation.

మాల్వేర్ యొక్క విధులను అర్థం చేసుకోవడానికి, రచయిత ప్రదర్శనను చూడండి.


PowerShell is often used by malware authors to hide malicious activities.

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


PowerShell allows you to create scripts with multiple commands.

బహుళ ఆదేశాలతో స్క్రిప్ట్‌లను రూపొందించడానికి పవర్‌షెల్ మిమ్మల్ని అనుమతిస్తుంది.


Attackers use PowerShell to execute their malicious code.

తమ హానికరమైన కోడ్‌ను అమలు చేయడానికి దాడి చేసేవారు పవర్‌షెల్‌ను ఉపయోగిస్తారు.


PowerShell is often used to download additional components after exploitation.

ఎక్స్‌ప్లోయిటేషన్ తర్వాత అదనపు భాగాలను డౌన్‌లోడ్ చేయడానికి పవర్‌షెల్ తరచుగా ఉపయోగించబడుతుంది.


Malicious code can invoke PowerShell directly or indirectly.

హానికరమైన కోడ్ నేరుగా లేదా పరోక్షంగా పవర్‌షెల్‌ను పిలవగలదు.


Attackers use PowerShell for lateral movement within a network.

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


PowerShell can execute code directly from memory.

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


Obfuscated code makes detection with security tools difficult.

అస్పష్టమైన కోడ్ భద్రతా సాధనాలతో గుర్తించడం కష్టతరం చేస్తుంది.


You can execute a PowerShell command in the interactive console.

మీరు ఇంటరాక్టివ్ కన్సోల్‌లో పవర్‌షెల్ ఆదేశాన్ని అమలు చేయవచ్చు.


A cmdlet is a compiled command written in .NET.

ఒక కమాండ్లెట్ అనేది .NETలో వ్రాయబడిన కంపైల్ చేయబడిన కమాండ్.


Cmdlets follow a Verb-Noun naming convention.

కమాండ్లెట్‌లు వెర్బ్-నౌన్ నామకరణ సమావేశాన్ని అనుసరిస్తాయి.


Parameters start with a dash followed by the parameter name.

పారామీటర్లు డాష్‌తో ప్రారంభమవుతాయి, ఆ తర్వాత పరామితి పేరు ఉంటుంది.


Variables can store the results of PowerShell commands.

చరరాశులు పవర్‌షెల్ ఆదేశాల ఫలితాలను నిల్వ చేయగలవు.


PowerShell scripts have a .ps1 extension.

పవర్‌షెల్ స్క్రిప్ట్‌లకు .ps1 పొడిగింపు ఉంటుంది.


The default execution policy prevents script execution.

డిఫాల్ట్ ఎగ్జిక్యూషన్ పాలసీ స్క్రిప్ట్ అమలును నిరోధిస్తుంది.


Change the execution policy with the Set-ExecutionPolicy command.

Set-ExecutionPolicy ఆదేశంతో ఎగ్జిక్యూషన్ పాలసీని మార్చండి.


Run malicious scripts in an isolated environment.

ఒక ప్రత్యేక వాతావరణంలో హానికరమైన స్క్రిప్ట్‌లను అమలు చేయండి.


Attackers often use email attachments to deliver malicious code.

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


The malware loads a malicious DLL into the process memory.

మాల్వేర్ ఒక హానికరమైన DLLని ప్రక్రియ మెమరీలోకి లోడ్ చేస్తుంది.


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

ఈ పద్ధతిని గుర్తించడానికి, రిజిస్ట్రీలో అనుమానాస్పద ఎంట్రీలను చూడండి.


Adversaries can take advantage of DLL search order to escalate privileges.

అధికారులు అధికారాలను పెంచడానికి DLL శోధన క్రమాన్ని ఉపయోగించుకోవచ్చు.


The operating system searches for the DLL in a specific order.

ఆపరేటింగ్ సిస్టమ్ ఒక నిర్దిష్ట క్రమంలో DLL కోసం వెతుకుతుంది.


The malicious DLL is loaded by explorer.exe.

మాలికస్ DLL ను explorer.exe లోడ్ చేస్తుంది.


COM hijacking makes forensic analysis much harder.

COM హైజాకింగ్ ఫోరెన్సిక్ విశ్లేషణను మరింత కష్టతరం చేస్తుంది.


An attacker modifies the registry entry of a legitimate COM object.

ఒక దాడి చేసే వ్యక్తి చట్టబద్ధమైన COM వస్తువు యొక్క రిజిస్ట్రీ ఎంట్రీని సవరిస్తాడు.


The malware adds an entry in HKCU\Software\Classes\CLSID.

మాల్వేర్ HKCU\Software\Classes\CLSIDలో ఒక ఎంట్రీని జోడిస్తుంది.


Services run in the background without a user interface.

సేవలు వినియోగదారు ఇంటర్‌ఫేస్ లేకుండా నేపథ్యంలో నడుస్తాయి.


An adversary can modify an existing service.

ఒక ప్రత్యర్థి ఇప్పటికే ఉన్న సేవను సవరించవచ్చు.


Malware can create services using the sc utility.

మాల్వేర్ sc యుటిలిటీని ఉపయోగించి సేవలను సృష్టించవచ్చు.


The service can be set to start automatically.

సేవను స్వయంచాలకంగా ప్రారంభించడానికి సెట్ చేయవచ్చు.


The Windows operating system provides each process with its own private memory address space.

విండోస్ ఆపరేటింగ్ సిస్టమ్ ప్రతి ప్రక్రియకు దాని స్వంత ప్రైవేట్ మెమరీ చిరునామా స్థలాన్ని అందిస్తుంది.


Virtual memory is an illusion created by the operating system.

వర్చువల్ మెమరీ అనేది ఆపరేటింగ్ సిస్టమ్ ద్వారా సృష్టించబడిన ఒక భ్రమ.


The virtual address is translated into the physical address.

వర్చువల్ చిరునామా భౌతిక చిరునామాలోకి అనువదించబడుతుంది.


Process memory is a part of virtual memory.

ప్రక్రియ మెమరీ వర్చువల్ మెమరీలో ఒక భాగం.


The size of the virtual memory address space depends on the hardware platform.

వర్చువల్ మెమరీ చిరునామా స్థలం యొక్క పరిమాణం హార్డ్‌వేర్ ప్లాట్‌ఫారమ్‌పై ఆధారపడి ఉంటుంది.


Each process thinks that it has its own private memory space.

ప్రతి ప్రక్రియ దాని స్వంత ప్రైవేట్ మెమరీ స్థలాన్ని కలిగి ఉందని భావిస్తుంది.


The kernel memory is shared by all the processes.

కర్నల్ మెమరీని అన్ని ప్రక్రియలు పంచుకుంటాయి.


You can examine the contents of a process memory using Process Hacker.

మీరు ప్రాసెస్ హ్యాకర్ని ఉపయోగించి ప్రక్రియ మెమరీలోని విషయాలను పరిశీలించవచ్చు.


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.

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


If the user-mode applications cannot directly interact with the hardware, then the question is, how can a malware binary write content to a file?

వినియోగదారు-స్థాయి అనువర్తనాలు నేరుగా హార్డ్‌వేర్‌తో పరస్పర చర్య చేయలేకపోతే, మాల్వేర్ బైనరీ ఫైల్‌కు కంటెంట్‌ను ఎలా వ్రాయగలదు?


Most of the APIs called by user-mode applications, end up calling the 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 implemented in DLLs.

విండోస్ ఆపరేటింగ్ సిస్టమ్ DLLలలో అమలు చేయబడిన APIలను బహిర్గతం చేయడం ద్వారా సేవలను అందిస్తుంది.


An application uses the service by calling the API implemented in the DLL.

ఒక అప్లికేషన్ DLLలో అమలు చేయబడిన APIని పిలవడం ద్వారా సేవను ఉపయోగిస్తుంది.


Most API functions end up calling the system service routine in the ntoskrnl.exe.

చాలా API ఫంక్షన్లు ntoskrnl.exeలో సిస్టమ్ సర్వీస్ రొటీన్‌ను పిలుస్తాయి.


When a process is invoked by double-clicking a program, the process executable image and all its associated DLLs are loaded.

ఒక ప్రోగ్రామ్‌ను డబుల్ క్లిక్ చేయడం ద్వారా ఒక ప్రక్రియను పిలిచినప్పుడు, ప్రక్రియ ఎగ్జిక్యూటబుల్ చిత్రం మరియు దాని అనుబంధిత DLLలు లోడ్ చేయబడతాయి.


It is not the process that executes the code, it is the thread that executes the code.

కోడ్‌ను అమలు చేసేది ప్రక్రియ కాదు, కోడ్‌ను అమలు చేసేది థ్రెడ్.


An attacker can inject a module and redirect the API call made by the remote process.

ఒక దాడి చేసే వ్యక్తి ఒక మాడ్యూల్‌ను ఇంజెక్ట్ చేయవచ్చు మరియు రిమోట్ ప్రక్రియ చేసిన API కాల్‌ను మళ్లించవచ్చు.


Injecting code into trusted processes allows an attacker to bypass security products.

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


The shim code modifies the parameters passed to the API.

షిమ్ కోడ్ APIకి పంపబడిన పారామీటర్లను మారుస్తుంది.


Applications use the IAT to call Windows APIs.

అప్లికేషన్లు విండోస్ APIలను పిలవడానికి IATని ఉపయోగిస్తాయి.


The shim engine intercepts and returns a different version of Windows.

షిమ్ ఇంజిన్ అడ్డుకుంటుంది మరియు విండోస్ యొక్క వేరే వెర్షన్‌ను అందిస్తుంది.


Microsoft provides hundreds of shims that can be applied to an application.

ఒక అప్లికేషన్‌కు వర్తించే వందలాది షిమ్‌లను మైక్రోసాఫ్ట్ అందిస్తుంది.


Attackers abuse shims to achieve persistence.

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


Creating a shim for an application involves several steps.

ఒక అప్లికేషన్ కోసం షిమ్‌ను సృష్టించడం అనేక దశలను కలిగి ఉంటుంది.


You need administrator rights to create and install a shim.

షిమ్‌ను సృష్టించడానికి మరియు ఇన్‌స్టాల్ చేయడానికి మీకు నిర్వాహక హక్కులు అవసరం.


The Compatibility Administrator Tool is used to create shims.

షిమ్‌లను సృష్టించడానికి అనుకూలత నిర్వాహక సాధనాన్ని ఉపయోగిస్తారు.


The InjectDll shim makes an application load a DLL.

InjectDll షిమ్ ఒక అప్లికేషన్ DLLని లోడ్ చేయడానికి చేస్తుంది.


The shim database contains the shim information.

షిమ్ డేటాబేస్ షిమ్ సమాచారాన్ని కలిగి ఉంది.


Install the database by right-clicking and selecting Install.

డేటాబేస్‌ను ఇన్‌స్టాల్ చేయడానికి కుడి-క్లిక్ చేసి ఇన్‌స్టాల్ చేయి ఎంచుకోండి.


The sdbinst utility can also install the database.

sdbinst యుటిలిటీ కూడా డేటాబేస్‌ను ఇన్‌స్టాల్ చేయగలదు.


Attackers can use shims for malicious purposes.

దాడు చేసేవారు హానికరమైన ప్రయోజనాల కోసం షిమ్‌లను ఉపయోగించవచ్చు.


The attacker may delete the malware after installing the shim.

షిమ్‌ను ఇన్‌స్టాల్ చేసిన తర్వాత దాడి చేసేవారు మాల్వేర్‌ను తొలగించవచ్చు.


Analyzing the shim database helps in understanding the attack.

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


Remote executable injection involves injecting code into a process.

రిమోట్ ఎగ్జిక్యూటబుల్ ఇంజెక్షన్ ఒక ప్రక్రియలోకి కోడ్‌ను ఇంజెక్ట్ చేయడాన్ని కలిగి ఉంటుంది.


Process hollowing is a code injection technique.

ప్రక్రియ హోలోయింగ్ అనేది కోడ్ ఇంజెక్షన్ టెక్నిక్.


IAT hooking replaces function addresses in the IAT.

IAT హుకింగ్ IATలో ఫంక్షన్ చిరునామాలను భర్తీ చేస్తుంది.


Inline hooking modifies the API function itself.

ఇన్‌లైన్ హుకింగ్ API ఫంక్షన్‌ను సవరిస్తుంది.


Malware can filter the output parameters using hooking.

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


The malware decrypts file names during runtime.

మాల్‌వేర్ రన్‌టైమ్‌లో ఫైల్ పేర్లను డీక్రిప్ట్ చేస్తుంది.


Attackers use packers to obfuscate executables.

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


Understanding packers is crucial for malware analysis.

మాల్‌వేర్ విశ్లేషణ కోసం ప్యాకర్లను అర్థం చేసుకోవడం చాలా ముఖ్యం.


The OEP is the malware's first instruction.

OEP అనేది మాల్‌వేర్ యొక్క మొదటి సూచన.


డీబగ్గింగ్ కోసం మేము x64dbgని ఉపయోగిస్తాము.


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


Fixing the import table is a necessary step.

దిగుమతి పట్టికను పరిష్కరించడం ఒక అవసరమైన దశ.


Automated unpacking tools can save time.

ఆటోమేటెడ్ అన్‌ప్యాకింగ్ సాధనాలు సమయాన్ని ఆదా చేస్తాయి.


టైటాన్‌మిస్ట్ అన్‌ప్యాకింగ్ కోసం ఒక సాధనం.


Memory forensics helps in malware analysis.

మెమరీ ఫోరెన్సిక్స్ మాల్వేర్ విశ్లేషణలో సహాయపడుతుంది.


మెమరీని పొందడం మొదటి దశ.


డంప్‌ఇట్ ఒక మెమరీని పొందే సాధనం.


You can analyze the memory dump with Volatility.

మీరు వోలటాలిటీతో మెమరీ డంప్‌ను విశ్లేషించవచ్చు.


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


ప్రోగ్రామ్ యొక్క ఎంట్రీ పాయింట్ సవరించబడింది.


We need to understand the unpacking stub.

అన్‌ప్యాకింగ్ స్టబ్‌ను మనం అర్థం చేసుకోవాలి.


The malware uses encryption to hide data.

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


The packed binary reveals less information.

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


Manual unpacking requires skill and patience.

మాన్యువల్ అన్‌ప్యాకింగ్‌కు నైపుణ్యం మరియు ఓపిక అవసరం.


Memory forensics is crucial for incident response.

ఘటన ప్రతిస్పందన కోసం మెమరీ ఫోరెన్సిక్స్ చాలా ముఖ్యం.


To help you understand, let's suppose that an attacker wants to hook the DeleteFileA() function call made by a legitimate application.

మీకు అర్థమయ్యేలా చెప్పాలంటే, ఒక దాడి చేసే వ్యక్తి చట్టబద్ధమైన అప్లికేషన్ ద్వారా చేయబడిన DeleteFileA() ఫంక్షన్ కాల్‌ని హుక్ చేయాలనుకుంటున్నారని అనుకుందాం.


Normally, when the legitimate application's thread encounters the call to DeleteFileA(), the thread starts executing from the start of the DeleteFileA() function.

సాధారణంగా, చట్టబద్ధమైన అప్లికేషన్ యొక్క థ్రెడ్ DeleteFileA()కి కాల్‌ని ఎదుర్కొన్నప్పుడు, థ్రెడ్ DeleteFileA() ఫంక్షన్ ప్రారంభం నుండి అమలు చేయడం ప్రారంభిస్తుంది.


To replace the first few instructions of a function with a jump, the malware needs to choose which instructions to replace.

ఒక ఫంక్షన్ యొక్క మొదటి కొన్ని సూచనలను జంప్‌తో భర్తీ చేయడానికి, మాల్వేర్ ఏ సూచనలను భర్తీ చేయాలో ఎంచుకోవాలి.


The jmp instruction requires at least 5 bytes, so the malware needs to choose instructions that occupy 5 bytes or more.

jmp సూచనకు కనీసం 5 బైట్‌లు అవసరం, కాబట్టి మాల్వేర్ 5 బైట్‌లు లేదా అంతకంటే ఎక్కువ స్థలాన్ని ఆక్రమించే సూచనలను ఎంచుకోవాలి.


In the preceding diagram, it is safe to replace the first three instructions, because they take up exactly 5 bytes.

మునుపటి రేఖాచిత్రంలో, మొదటి మూడు సూచనలను భర్తీ చేయడం సురక్షితం, ఎందుకంటే అవి ఖచ్చితంగా 5 బైట్‌లను తీసుకుంటాయి.


The three instructions to be replaced in DeleteFileA() are copied, and then replaced with a jump statement of some sort, which transfers control to the malicious function.

DeleteFileA()లో భర్తీ చేయవలసిన మూడు సూచనలు కాపీ చేయబడతాయి, ఆపై ఏదో ఒక రకమైన జంప్ స్టేట్‌మెంట్‌తో భర్తీ చేయబడతాయి, ఇది నియంత్రణను హానికరమైన ఫంక్షన్‌కు బదిలీ చేస్తుంది.


The malicious function does what it wants to do, and then executes the original three instructions of DeleteFileA() and jumps back to the address that lies below the patch.

హానికరమైన ఫంక్షన్ అది ఏమి చేయాలో అది చేస్తుంది, ఆపై DeleteFileA() యొక్క అసలైన మూడు సూచనలను అమలు చేస్తుంది మరియు ప్యాచ్ క్రింద ఉన్న చిరునామాకు తిరిగి వెళుతుంది.


The replaced instructions, along with the jump statement that returns to the target function, are known as the trampoline.

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


This technique can be detected by looking for unexpected jump instructions at the start of the API function.

API ఫంక్షన్ ప్రారంభంలో ఊహించని జంప్ సూచనల కోసం చూడటం ద్వారా ఈ సాంకేతికతను గుర్తించవచ్చు.


Instead of using a jmp instruction, malware may use a call instruction, or a combination of push and ret instructions, to redirect control.

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


Zeus bot hooks various API functions; one of them is the HttpSendRequestA() in Internet Explorer (iexplore.exe).

Zeus బాట్ వివిధ API ఫంక్షన్లను హుక్ చేస్తుంది; వాటిలో ఒకటి ఇంటర్నెట్ ఎక్స్‌ప్లోరర్ (iexplore.exe)లో HttpSendRequestA().


By hooking this function, 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.

ఇన్‌లైన్ హుకింగ్‌లో, హానికరమైన కోడ్‌కు నియంత్రణను మళ్లించడానికి ఒక ఫంక్షన్‌లోని బైట్‌ల శ్రేణిని ఎలా ప్యాచ్ చేయాలో మనం చూశాము.


It is possible to perform in-memory patching using the application compatibility shim.

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


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

తమ ఉత్పత్తులలోని దుర్బలత్వాలను పరిష్కరించడానికి ప్యాచ్‌లను వర్తింపజేయడానికి Microsoft మెమరీలో ప్యాచింగ్ యొక్క లక్షణాన్ని ఉపయోగిస్తుంది.


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

మాల్వేర్ రచయితలు కోడ్‌ను ఇంజెక్ట్ చేయడానికి మరియు API ఫంక్షన్లను హుక్ చేయడానికి మెమరీలో ప్యాచింగ్‌ను ఉపయోగించారు.


You can examine the .sdb file using the sdb_dump_database.py script.

sdb_dump_database.py స్క్రిప్ట్‌ని ఉపయోగించి మీరు .sdb ఫైల్‌ను పరిశీలించవచ్చు.


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

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


Another method to detect the presence of the Base64 character set in the binary is using a YARA rule.

బైనరీలో బేస్64 అక్షరాల సమితి ఉనికిని గుర్తించడానికి మరొక పద్ధతి ఏమిటంటే YARA నియమాన్ని ఉపయోగించడం.


XOR అనేది బిట్‌వైజ్ ఆపరేషన్.


In the XOR operation, when both the bits are the same, the result is 0.

XOR ఆపరేషన్లో, రెండు బిట్స్ ఒకే విధంగా ఉన్నప్పుడు, ఫలితం 0.


For example, when you XOR 2 and 4, that is, 2 ^ 4, the result is 6.

ఉదాహరణకు, మీరు 2 మరియు 4 XOR చేసినప్పుడు, అంటే, 2 ^ 4, ఫలితం 6.


In a single byte XOR, each byte from the plaintext is XORed with the encryption key.

ఒకే బైట్ XORలో, సాదా వచనం నుండి ప్రతి బైట్ గుప్తీకరణ కీతో XOR చేయబడుతుంది.


If you know the key, then the same function can be used to both encrypt and decrypt the data.

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


With an understanding of the XOR encoding algorithm, let's look at an example of a keylogger.

XOR ఎన్కోడింగ్ అల్గారిథం గురించి అవగాహనతో, కీలాగర్కు ఒక ఉదాహరణను చూద్దాం.


Note how the malware calls a function (renamed as enc_function) after the call to CreateFileA() and before the call to WriteFile().

మాల్‌వేర్ CreateFileA()కి కాల్ చేసిన తర్వాత మరియు WriteFile()కి కాల్ చేయడానికి ముందు ఒక ఫంక్షన్‌ను (enc_functionగా పేరు మార్చబడింది) ఎలా పిలుస్తుందో గమనించండి.


Examining the enc_function shows that the malware uses single byte XOR.

enc_functionను పరిశీలిస్తే మాల్వేర్ సింగిల్ బైట్ XORని ఉపయోగిస్తుందని తెలుస్తుంది.


In a single byte XOR, the length of the key is one byte, so there can be only 255 possible keys.

ఒకే బైట్ XORలో, కీ యొక్క పొడవు ఒక బైట్, కాబట్టి 255 కీలు మాత్రమే ఉండవచ్చు.


This technique is useful if you know what to find in the decrypted data.

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


You can also use a tool such as ConverterNET to brute-force and determine the key.

కీని బలవంతంగా కనుగొనడానికి మరియు నిర్ణయించడానికి మీరు ConverterNET వంటి సాధనాన్ని కూడా ఉపయోగించవచ్చు.


In XOR encoding, when a null byte (0x00) is XORed with a key, you get back the key.

XOR ఎన్కోడింగ్‌లో, శూన్య బైట్ (0x00) కీతో XOR చేయబడినప్పుడు, మీరు కీని తిరిగి పొందుతారు.


This means that whenever a buffer containing a large number of null bytes is encoded, the single byte xor key becomes clearly visible.

అంటే, పెద్ద సంఖ్యలో శూన్య బైట్‌లను కలిగి ఉన్న బఫర్ ఎన్‌కోడ్ చేయబడినప్పుడల్లా, సింగిల్ బైట్ xor కీ స్పష్టంగా కనిపిస్తుంది.


To avoid the null byte problem, malware authors ignore the null byte (0x00) and the encryption key during encryption.

శూన్య బైట్ సమస్యను నివారించడానికి, మాల్వేర్ రచయితలు గుప్తీకరణ సమయంలో శూన్య బైట్ (0x00) మరియు గుప్తీకరణ కీని విస్మరిస్తారు.


Attackers commonly use multi-byte XOR because it provides better defense against the brute-force technique.

దాడి చేసేవారు సాధారణంగా మల్టీ-బైట్ XORని ఉపయోగిస్తారు, ఎందుకంటే ఇది బలవంతపు పద్ధతికి వ్యతిరేకంగా మంచి రక్షణను అందిస్తుంది.


The decrypted content is a PE (executable file) as shown here.

డీక్రిప్ట్ చేసిన కంటెంట్ ఇక్కడ చూపిన విధంగా PE (ఎగ్జిక్యూటబుల్ ఫైల్).


To identify XOR encoding, load the binary in IDA and search for the XOR instruction.

XOR ఎన్కోడింగ్‌ను గుర్తించడానికి, IDAలో బైనరీని లోడ్ చేసి, XOR సూచన కోసం శోధించండి.


Malware authors often use simple encoding techniques, because it is just enough to obscure the data.

మాల్వేర్ రచయితలు తరచుగా సాధారణ ఎన్కోడింగ్ పద్ధతులను ఉపయోగిస్తారు, ఎందుకంటే ఇది డేటాను అస్పష్టం చేయడానికి సరిపోతుంది.


A useful tool to search for the cryptographic signatures in a file or process is Signsrch.

ఫైల్ లేదా ప్రాసెస్‌లో క్రిప్టోగ్రాఫిక్ సంతకాలను శోధించడానికి ఉపయోగకరమైన సాధనం Signsrch.


The standalone executable is distributed for Windows, macOS, and Linux operating systems.

స్వతంత్రంగా నడిచే ఎగ్జిక్యూటబుల్ విండోస్, macOS మరియు లినక్స్ ఆపరేటింగ్ సిస్టమ్‌ల కోసం పంపిణీ చేయబడుతుంది.


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 (--help) ఎంపికతో స్వతంత్రంగా నడిచే ఎగ్జిక్యూటబుల్‌ను అమలు చేయడం ద్వారా వోలటాలిటీ ఉపయోగించడానికి సిద్ధంగా ఉందో లేదో మీరు తనిఖీ చేయవచ్చు.


Volatility is also distributed as a source package; you can run it on Windows, macOS, or Linux operating systems.

వోలటాలిటీ సోర్స్ ప్యాకేజీగా కూడా పంపిణీ చేయబడుతుంది; మీరు దీన్ని విండోస్, macOS లేదా లినక్స్ ఆపరేటింగ్ సిస్టమ్‌లలో అమలు చేయవచ్చు.


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 ఇంటర్‌ప్రెటర్ మరియు దాని ఆధారాలను ఇన్‌స్టాల్ చేయాలి.


Once all the dependencies are installed, download the Volatility source code package, extract it, and run Volatility, as follows:

అన్ని ఆధారాలను ఇన్‌స్టాల్ చేసిన తర్వాత, వోలటాలిటీ సోర్స్ కోడ్ ప్యాకేజీని డౌన్‌లోడ్ చేయండి, దాన్ని సంగ్రహించండి మరియు కింది విధంగా వోలటాలిటీని అమలు చేయండి:


All the examples mentioned in this book use the Volatility Python script (python vol.py) from the source package.

ఈ పుస్తకంలో పేర్కొన్న అన్ని ఉదాహరణలు సోర్స్ ప్యాకేజీ నుండి వోలటాలిటీ పైథాన్ స్క్రిప్ట్ (python vol.py)ని ఉపయోగిస్తాయి.


You are free to choose a standalone executable, but just remember to replace python vol.py with the standalone executable name.

మీరు స్వతంత్రంగా నడిచే ఎగ్జిక్యూటబుల్‌ను ఎంచుకోవడానికి స్వేచ్ఛగా ఉన్నారు, అయితే python 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-బిట్) నుండి పొందిన మెమరీ చిత్రం నుండి నడుస్తున్న ప్రక్రియలను జాబితా చేయడానికి కింది కమాండ్ pslist ప్లగిన్‌ను ఉపయోగిస్తుంది, ఇది సర్వీస్ ప్యాక్ 1ని నడుపుతోంది:


Sometimes, you might not know what profile to supply to Volatility.

కొన్నిసార్లు, మీరు వోలటాలిటీకి ఏ ప్రొఫైల్‌ను అందించాలో మీకు తెలియకపోవచ్చు.


In that case, you can use the imageinfo plugin, which will determine the correct profile.

అలాంటప్పుడు, మీరు imageinfo ప్లగిన్‌ను ఉపయోగించవచ్చు, ఇది సరైన ప్రొఫైల్‌ను నిర్ణయిస్తుంది.


Most of the Volatility plugins, such as pslist, rely on extracting the information from the Windows operating system structures.

pslist వంటి చాలా వోలటాలిటీ ప్లగిన్‌లు విండోస్ ఆపరేటింగ్ సిస్టమ్ నిర్మాణాల నుండి సమాచారాన్ని సంగ్రహించడంపై ఆధారపడి ఉంటాయి.


These structures vary across different versions of Windows; the profile (-- profile) tells Volatility which data structures, symbols, and algorithms to use.

ఈ నిర్మాణాలు విండోస్ యొక్క విభిన్న వెర్షన్‌లలో మారుతూ ఉంటాయి; ప్రొఫైల్ (-- ప్రొఫైల్) వోలటాలిటీకి ఏ డేటా నిర్మాణాలు, చిహ్నాలు మరియు అల్గారిథమ్‌లను ఉపయోగించాలో తెలియజేస్తుంది.


You can use the same -h (--help) option to determine various options and arguments supported by a plugin.

ఒక ప్లగిన్ ద్వారా మద్దతు ఇచ్చే వివిధ ఎంపికలు మరియు వాదనలను గుర్తించడానికి మీరు అదే -h (--help) ఎంపికను ఉపయోగించవచ్చు.


At this point, you should have an understanding of how to run Volatility plugins on an acquired memory image and how to determine various options supported by a plugin.

ఈ సమయంలో, మీరు పొందిన మెమరీ చిత్రంపై వోలటాలిటీ ప్లగిన్‌లను ఎలా అమలు చేయాలో మరియు ప్లగిన్ ద్వారా మద్దతు ఇచ్చే వివిధ ఎంపికలను ఎలా గుర్తించాలో అర్థం చేసుకోవాలి.


To hide a process, an attacker finds the _EPROCESS structure of the malicious process he/she wants to hide and modifies the ActiveProcessLinks field.

ఒక ప్రక్రియను దాచడానికి, దాచాలనుకుంటున్న హానికరమైన ప్రక్రియ యొక్క _EPROCESS నిర్మాణాన్ని ఒక దాడిదారుడు కనుగొని, ActiveProcessLinks ఫీల్డ్‌ను సవరిస్తాడు.


In particular, the Flink of the previous _EPROCESS block is made to point to the Flink of the following _EPROCESS block, and the Blink of the following _EPROCESS block is set to point to the previous _EPROCESS block's Flink.

ముఖ్యంగా, మునుపటి _EPROCESS బ్లాక్ యొక్క Flink, తదుపరి _EPROCESS బ్లాక్ యొక్క Flinkకి సూచించేలా చేయబడుతుంది మరియు తదుపరి _EPROCESS బ్లాక్ యొక్క Blink మునుపటి _EPROCESS బ్లాక్ యొక్క Flinkకి సూచించేలా సెట్ చేయబడుతుంది.


As a result of this, the _EPROCESS block associated with the malware process is unlinked from the doubly linked list.

దీని ఫలితంగా, మాల్వేర్ ప్రక్రియతో అనుబంధించబడిన _EPROCESS బ్లాక్ డబ్లీ లింక్డ్ జాబితా నుండి తొలగించబడుతుంది.


By unlinking a process, an attacker can hide the malicious process from the live forensic tools that rely on walking the doubly linked list to enumerate the active processes.

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


As you might have guessed, this technique also hides the malicious process from the pslist plugin.

మీరు ఊహించినట్లుగా, ఈ పద్ధతి pslist ప్లగ్ఇన్ నుండి కూడా హానికరమైన ప్రక్రియను దాచిపెడుతుంది.


The following is the pslist and psscan output from a system infected with the prolaco rootkit, which performs DKOM to hide a process.

ప్రక్రియను దాచడానికి DKOMను నిర్వహించే ప్రోలాకో రూట్‌కిట్‌తో సోకిన సిస్టమ్ నుండి pslist మరియు psscan అవుట్‌పుట్ క్రింది విధంగా ఉంది.


When you compare the output from pslist and psscan, you will notice an additional process called nvid.exe (pid 1700) in the psscan output that's not present in the pslist.

pslist మరియు psscan నుండి వచ్చిన అవుట్‌పుట్‌ను మీరు సరిపోల్చినప్పుడు, pslistలో లేని psscan అవుట్‌పుట్‌లో nvid.exe (pid 1700) అనే అదనపు ప్రక్రియను మీరు గమనించవచ్చు.


The reason psscan detects the hidden process is that it uses a different technique to list the processes, called pool tag scanning.

psscan దాచిన ప్రక్రియను గుర్తించడానికి కారణం ఏమిటంటే, ఇది పూల్ ట్యాగ్ స్కానింగ్ అని పిలువబడే ప్రక్రియలను జాబితా చేయడానికి ఒక ప్రత్యేకమైన పద్ధతిని ఉపయోగిస్తుంది.


Every executive object has a structure associated with it (such as _EPROCESS for process object).

ప్రతి ఎగ్జిక్యూటివ్ వస్తువుకు దానితో అనుబంధించబడిన ఒక నిర్మాణం ఉంటుంది (ప్రక్రియ వస్తువు కోసం _EPROCESS వంటివి).


The executive object structure is preceded by a _OBJECT_HEADER structure, which contains information about an object's type and some reference counters.

ఎగ్జిక్యూటివ్ ఆబ్జెక్ట్ నిర్మాణానికి ముందు _OBJECT_HEADER నిర్మాణం ఉంటుంది, ఇది ఒక వస్తువు యొక్క రకం మరియు కొన్ని రిఫరెన్స్ కౌంటర్ల గురించి సమాచారాన్ని కలిగి ఉంటుంది.


To store an object, memory is needed, and this memory is allocated by the Windows memory manager from kernel pools.

ఒక వస్తువును నిల్వ చేయడానికి, మెమరీ అవసరం, మరియు ఈ మెమరీని విండోస్ మెమరీ మేనేజర్ కెర్నల్ పూల్స్ నుండి కేటాయిస్తుంది.


The pool is divided into a paged pool (whose content may be swapped to disk) and a non-paged pool (whose content permanently resides in memory).

పూల్ పేజ్డ్ పూల్ (దీని కంటెంట్ డిస్క్‌కి మార్చబడవచ్చు) మరియు నాన్-పేజ్డ్ పూల్ (దీని కంటెంట్ శాశ్వతంగా మెమరీలో ఉంటుంది)గా విభజించబడింది.


The objects (such as process and threads) are kept in a non-paged pool in the kernel, which means they will always reside in the physical memory.

వస్తువులు (ప్రక్రియ మరియు థ్రెడ్‌లు వంటివి) కెర్నల్‌లోని నాన్-పేజ్డ్ పూల్‌లో ఉంచబడతాయి, అంటే అవి ఎల్లప్పుడూ భౌతిక మెమరీలో ఉంటాయి.


When the Windows kernel receives the request to create an object (possibly due to API calls made by processes such as CreateProcess or CreateFile), memory is allocated for the object either from the paged pool or non-paged pool (depending on the object type).

విండోస్ కెర్నల్ ఒక వస్తువును సృష్టించడానికి అభ్యర్థనను స్వీకరించినప్పుడు (CreateProcess లేదా CreateFile వంటి ప్రక్రియల ద్వారా API కాల్‌ల కారణంగా), వస్తువు కోసం మెమరీ పేజ్డ్ పూల్ లేదా నాన్-పేజ్డ్ పూల్ నుండి కేటాయించబడుతుంది (వస్తువు రకాన్ని బట్టి).


This allocation is tagged by prepending a _POOL_HEADER structure to the object, so that in memory, each object will have a predictable structure.

ఈ కేటాయింపుకు వస్తువుకు _POOL_HEADER నిర్మాణాన్ని చేర్చడం ద్వారా ట్యాగ్ చేయబడుతుంది, తద్వారా మెమరీలో, ప్రతి వస్తువు ఒక ఊహించదగిన నిర్మాణాన్ని కలిగి ఉంటుంది.


The _POOL_HEADER structure includes a field named PoolTag that contains a four-byte tag (referred to as a pool tag).

_POOL_HEADER నిర్మాణంలో PoolTag అనే ఫీల్డ్ ఉంటుంది, ఇది నాలుగు-బైట్ ట్యాగ్‌ను కలిగి ఉంటుంది (దీనిని పూల్ ట్యాగ్ అని పిలుస్తారు).


For the process object, the tag is Proc and for the File object, the tag is File, and so on.

ప్రక్రియ వస్తువు కోసం, ట్యాగ్ ప్రోక్ మరియు ఫైల్ వస్తువు కోసం, ట్యాగ్ ఫైల్, మరియు మొదలైనవి.


It is this tag that the Volatility's psscan uses as the starting point to identify the process object.

ప్రక్రియ వస్తువును గుర్తించడానికి వోలటిలిటీ యొక్క psscan ఉపయోగించేది ఈ ట్యాగ్.


In fact, many volatility plugins rely on pool tag scanning to identify and extract information from the memory image.

వాస్తవానికి, మెమరీ చిత్రం నుండి సమాచారాన్ని గుర్తించడానికి మరియు సంగ్రహించడానికి చాలా వోలటిలిటీ ప్లగిన్‌లు పూల్ ట్యాగ్ స్కానింగ్‌పై ఆధారపడతాయి.


When an object is destroyed (such as when a process is terminated), the memory allocation containing that object is released back to the kernel pool, but the content in the memory is not immediately overwritten.

ఒక వస్తువు నాశనం చేయబడినప్పుడు (ఒక ప్రక్రియ ముగిసినప్పుడు), ఆ వస్తువును కలిగి ఉన్న మెమరీ కేటాయింపు కెర్నల్ పూల్‌కు తిరిగి విడుదల చేయబడుతుంది, కాని మెమరీలోని కంటెంట్ వెంటనే తిరిగి రాయబడదు.


The explorer.exe process path is displayed along with its full path on the disk.

explorer.exe ప్రక్రియ యొక్క మార్గం దాని పూర్తి మార్గంతో పాటు డిస్క్లో ప్రదర్శించబడుతుంది.


The second node describes a memory range.

రెండవ నోడ్ మెమరీ పరిధిని వివరిస్తుంది.


This memory range does not contain any memory mapped file.

ఈ మెమరీ పరిధిలో ఎలాంటి మెమరీ మ్యాప్ చేయబడిన ఫైల్ లేదు.


The third node displays information about the process memory range.

మూడవ నోడ్ ప్రక్రియ మెమరీ పరిధి గురించి సమాచారాన్ని ప్రదర్శిస్తుంది.


The memory protection of ntdll.dll is also shown.

ntdll.dll యొక్క మెమరీ రక్షణ కూడా చూపబడుతుంది.


Use the command to display the process memory regions.

ప్రక్రియ మెమరీ ప్రాంతాలను ప్రదర్శించడానికి కమాండ్ ఉపయోగించండి.


When an executable image is loaded into memory, it's given a memory protection.

ఒక ఎగ్జిక్యూటబుల్ చిత్రం మెమరీలోకి లోడ్ అయినప్పుడు, దానికి మెమరీ రక్షణ ఇవ్వబడుతుంది.


An application is generally not allowed to allocate memory with certain protection.

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


If an attacker wants to inject a PE file, a specific memory protection is needed.

ఒక దాడి చేసే వ్యక్తి PE ఫైల్‌ను ఇంజెక్ట్ చేయాలనుకుంటే, ఒక నిర్దిష్ట మెమరీ రక్షణ అవసరం.


Memory ranges with PAGE_EXECUTE_READWRITE protection are not always malicious.

PAGE_EXECUTE_READWRITE రక్షణ కలిగిన మెమరీ పరిధులు ఎల్లప్పుడూ హానికరమైనవి కావు.


To detect code injection, examine memory ranges and verify their contents.

కోడ్ ఇంజెక్షన్‌ను గుర్తించడానికి, మెమరీ పరిధులను పరిశీలించండి మరియు వాటి విషయాలను ధృవీకరించండి.


SpyEye malware injects code into explorer.exe.

స్పైఐ మాల్వేర్ explorer.exe లో కోడ్‌ను ఇంజెక్ట్ చేస్తుంది.


The vadinfo plugin shows suspicious memory protections.

vadinfo ప్లగిన్ అనుమానాస్పద మెమరీ రక్షణలను చూపుతుంది.


It is hard to conclude if the memory regions contain malicious code just from the protection.

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


To determine if there is any malicious code, dump the contents of these memory regions.

ఏదైనా హానికరమైన కోడ్ ఉందో లేదో తెలుసుకోవడానికి, ఈ మెమరీ ప్రాంతాలలోని విషయాలను డంప్ చేయండి.


The db command dumps the content of the given memory address.

db కమాండ్ ఇచ్చిన మెమరీ చిరునామా యొక్క కంటెంట్‌ను డంప్ చేస్తుంది.


The presence of the PE file is a clear indication of injection.

PE ఫైల్ ఉనికి ఇంజెక్షన్ యొక్క స్పష్టమైన సూచన.


Sometimes, disassembling the content is necessary to identify malicious code.

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


The dis command can be used to disassemble the code.

కోడ్‌ను విడగొట్టడానికి dis కమాండ్‌ను ఉపయోగించవచ్చు.


After identifying injected code, you may want to dump it to disk.

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


To identify API hooks in both process and kernel memory, you can use the apihooks Volatility plugin.

ప్రాసెస్ మరియు కెర్నల్ మెమరీ రెండింటిలోనూ API హుక్‌లను గుర్తించడానికి, మీరు apihooks వోలటాలిటీ ప్లగిన్‌ను ఉపయోగించవచ్చు.