The book discusses malware analysis techniques.

పుస్తకం మాల్వేర్ విశ్లేషణ పద్ధతుల గురించి చర్చిస్తుంది.


Data science is crucial for cybersecurity.

సైబర్ భద్రతకు డేటా సైన్స్ చాలా ముఖ్యం.


Malware can infect computers through various methods.

మాల్వేర్ వివిధ పద్ధతుల ద్వారా కంప్యూటర్లను ప్రభావితం చేయవచ్చు.


The author is an expert in data science.

రచయిత డేటా సైన్స్ లో నిపుణుడు.


ఈ పుస్తకం మాల్వేర్ గుర్తింపు గురించి.


Machine learning algorithms are used to identify threats.

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


The book covers static and dynamic analysis.

పుస్తకం స్థిరమైన మరియు డైనమిక్ విశ్లేషణను కలిగి ఉంది.


Understanding x86 assembly is important.

x86 అసెంబ్లీని అర్థం చేసుకోవడం ముఖ్యం.


The book explains how to build malware detectors.

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


Data visualization helps in understanding trends.

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


Deep learning is a key area in this field.

డీప్ లెర్నింగ్ ఈ రంగంలో ఒక ముఖ్యమైన ప్రాంతం.


రచయిత న్యూరల్ నెట్‌వర్క్‌ల గురించి చర్చిస్తాడు.


The book provides an overview of datasets.

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


Security professionals need to learn data science.

భద్రతా నిపుణులు డేటా సైన్స్ నేర్చుకోవాలి.


The book is a valuable resource for cybersecurity.

ఈ పుస్తకం సైబర్ భద్రతకు విలువైన వనరు.


మాల్వేర్ విశ్లేషణ ఒక సంక్లిష్టమైన ప్రక్రియ.


The book explains how to identify attack campaigns.

దాడి ప్రచారాలను ఎలా గుర్తించాలో పుస్తకం వివరిస్తుంది.


Shared code analysis helps in understanding malware families.

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


The book delves into machine learning based malware detection.

పుస్తకం యంత్ర అభ్యాసం ఆధారిత మాల్వేర్ గుర్తింపులోకి ప్రవేశిస్తుంది.


Building a neural network malware detector requires expertise.

న్యూరల్ నెట్‌వర్క్ మాల్వేర్ డిటెక్టర్‌ను నిర్మించడానికి నైపుణ్యం అవసరం.


The code and data are available with the book.

ఈ కోడ్ మరియు డేటా పుస్తకంతో పాటు అందుబాటులో ఉన్నాయి.


You can download a virtual machine with the code and data.

మీరు కోడ్ మరియు డేటాతో కూడిన వర్చువల్ మెషీన్ను డౌన్‌లోడ్ చేసుకోవచ్చు.


The code targets Python 2.7 in Linux environments.

ఈ కోడ్ లైనక్స్ పరిసరాలలో పైథాన్ 2.7 ను లక్ష్యంగా చేసుకుంది.


You can download the book’s accompanying data at http://www.malwaredatascience.com/.

మీరు పుస్తకానికి సంబంధించిన డేటాను http://www.malwaredatascience.com/లో డౌన్‌లోడ్ చేసుకోవచ్చు.


The code should work almost as well on MacOS.

ఈ కోడ్ MacOSలో కూడా దాదాపు బాగానే పనిచేస్తుంది.


If you’d rather install the code and data in your own Linux environment, you can download them here.

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


You’ll find a directory for each chapter in the downloadable archive.

డౌన్‌లోడ్ చేయగల ఆర్కైవ్‌లో మీరు ప్రతి అధ్యాయానికి ఒక డైరెక్టరీని కనుగొంటారు.


Code files correspond to chapter listings or sections.

కోడ్ ఫైల్‌లు అధ్యాయాల జాబితాలు లేదా విభాగాలకు అనుగుణంగా ఉంటాయి.


Some code files are exactly like the listings.

కొన్ని కోడ్ ఫైల్‌లు జాబితాల వలెనే ఉంటాయి.


Code directories come with pip requirements.txt files.

కోడ్ డైరెక్టరీలతో పాటు pip requirements.txt ఫైల్‌లు వస్తాయి.


To install these libraries on your machine, simply type pip -r requirements.txt in each chapter’s code/ directory.

మీ కంప్యూటర్‌లో ఈ లైబ్రరీలను ఇన్‌స్టాల్ చేయడానికి, ప్రతి అధ్యాయం యొక్క కోడ్/ డైరెక్టరీలో pip -r requirements.txt అని టైప్ చేయండి.


In this chapter we look at the basics of static malware analysis.

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


Static analysis is performed by analyzing a program file’s disassembled code.

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


It refers to reverse engineering without actually running the program.

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


Through careful reverse engineering, you’ll be able to better understand the benefits that malware binaries provide attackers.

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


I begin this chapter by describing the Portable Executable (PE) file format.

పోర్టబుల్ ఎగ్జిక్యూటబుల్ (PE) ఫైల్ ఫార్మాట్‌ను వివరించడం ద్వారా నేను ఈ అధ్యాయాన్ని ప్రారంభిస్తాను.


The PE format was originally designed to tell Windows how to load a program into memory.

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


Supply media (or resources) a running program may use in the course of its execution.

ఒక రన్నింగ్ ప్రోగ్రామ్ దాని అమలు సమయంలో ఉపయోగించే మీడియా (లేదా వనరులను) అందించండి.


The PE format accomplishes all of this by leveraging the series of constructs.

నిర్మాణాల శ్రేణిని ఉపయోగించడం ద్వారా PE ఫార్మాట్ ఇదంతా సాధిస్తుంది.


Let’s explore this file structure in more detail, starting with the PE header.

PE హెడర్‌తో ప్రారంభించి, ఈ ఫైల్ నిర్మాణాన్ని మరింత వివరంగా పరిశీలిద్దాం.


Doing this allows us to visualize clusters of similar nodes accurately to their actual relationship.

ఇలా చేయడం వల్ల సారూప్య నోడ్‌ల సమూహాలను వాటి అసలు సంబంధానికి ఖచ్చితంగా దృశ్యమానం చేయడానికి వీలు కల్పిస్తుంది.


As you’ll see in the next section, however, this is often difficult to achieve, especially when you’re working with more than three nodes.

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


The ideal layout for these connections would place all nodes equidistant from one another on the page.

ఈ కనెక్షన్ల కోసం ఆదర్శవంతమైన లేఅవుట్ పేజీలో ఒకదానికొకటి సమాన దూరంలో ఉన్న అన్ని నోడ్‌లను ఉంచుతుంది.


But as you can see, as we create networks of four and then five nodes, as in (c) and (d), we start to introduce progressively more distortion due to edges of unequal length.

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


Force-directed algorithms are based on physical simulations of spring-like forces as well as magnetism.

ఫోర్స్-డైరెక్టెడ్ అల్గారిథమ్‌లు స్ప్రింగ్ లాంటి శక్తుల యొక్క భౌతిక అనుకరణలు అలాగే అయస్కాంతత్వంపై ఆధారపడి ఉంటాయి.


Simulating network edges as physical springs often leads to good node positioning, because the simulated springs push and pull to try to achieve uniform length between nodes and edges.

నెట్‌వర్క్ అంచులని భౌతిక స్ప్రింగ్‌లుగా అనుకరించడం తరచుగా మంచి నోడ్ స్థానానికి దారి తీస్తుంది, ఎందుకంటే అనుకరించబడిన స్ప్రింగ్‌లు నోడ్‌లు మరియు అంచుల మధ్య ఏకరీతి పొడవును సాధించడానికి ప్రయత్నించడానికి నెట్టివేస్తాయి మరియు లాగుతాయి.


Force-directed algorithms are what we focus on in this chapter.

ఈ అధ్యాయంలో మనం దృష్టి సారించేది ఫోర్స్-డైరెక్టెడ్ అల్గారిథమ్‌లపైనే.


నెట్‌వర్క్‌ఎక్స్‌తో నెట్‌వర్క్‌లను నిర్మించడం


If you know Python, you should find NetworkX to be surprisingly easy.

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


Use the code in Listing 4-1 to import NetworkX and instantiate a network.

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


The NetworkX library uses the term graph in place of network sometimes, as the two terms are synonymous in computer science—they both indicate a set of nodes connected by edges.

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


నోడ్‌లు మరియు అంచులని జోడించడం


A node in a NetworkX network can be any Python object.

నెట్‌వర్క్‌ఎక్స్ నెట్‌వర్క్‌లోని నోడ్ ఏదైనా పైథాన్ వస్తువు కావచ్చు.


Here I show you how to add nodes of various types to our network: nodes = [“hello”,“world”,1,2,3]

వివిధ రకాల నోడ్‌లను మన నెట్‌వర్క్‌కు ఎలా జోడించాలో ఇక్కడ నేను మీకు చూపిస్తున్నాను: నోడ్‌లు = [“హలో”,“ప్రపంచం”,1,2,3]


Then, to add edges, we call add_edge(), as shown next:

అప్పుడు, అంచులని జోడించడానికి, మేము add_edge()ని పిలుస్తాము, తరువాత చూపిన విధంగా:


NetworkX allows us to easily attach attributes to both nodes and edges.

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


To attach an attribute to a node (and to access that attribute later), you can add the attribute as a keyword argument when you add the node to the network, like this:

ఒక నోడ్‌కు ఒక లక్షణాన్ని అటాచ్ చేయడానికి (మరియు తరువాత ఆ లక్షణాన్ని యాక్సెస్ చేయడానికి), మీరు నోడ్‌ను నెట్‌వర్క్‌కు జోడించినప్పుడు కీవర్డ్ వాదనగా లక్షణాన్ని జోడించవచ్చు, ఇలా:


Similarly, you can add attributes to edges once they’ve been added to a network by using the edge dictionary, as shown here:

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


To visualize our networks, we need to save them to disk from NetworkX in .dot format—a format commonly used in the network analysis world that can be imported into many network visualization toolkits.

మన నెట్‌వర్క్‌లను దృశ్యమానం చేయడానికి, మనం వాటిని నెట్‌వర్క్‌ఎక్స్ నుండి .డాట్ ఫార్మాట్‌లో డిస్క్‌కు సేవ్ చేయాలి—నెట్‌వర్క్ విశ్లేషణ ప్రపంచంలో సాధారణంగా ఉపయోగించే ఫార్మాట్, దీనిని అనేక నెట్‌వర్క్ విజువలైజేషన్ టూల్‌కిట్‌లలోకి దిగుమతి చేసుకోవచ్చు.


GraphViz is the best available command line package for visualizing your networks.

మీ నెట్‌వర్క్‌లను దృశ్యమానం చేయడానికి గ్రాఫ్‌విజ్ ఉత్తమ కమాండ్ లైన్ ప్యాకేజీ.


If this is the case, static analysis will be useless against such code.

ఒకవేళ ఇది జరిగితే, అలాంటి కోడ్‌కు వ్యతిరేకంగా స్టాటిక్ విశ్లేషణ ఉపయోగించబడదు.


Similarly, malware may source decryption keys from external servers at startup time and then use these keys to decrypt data or code that will be used in the malware’s execution.

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


Obviously, if the malware is using an industrial-strength encryption algorithm, static analysis will not be sufficient to recover the encrypted data and code.

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


Such anti-analysis and anti-detection techniques are quite powerful, and the only way around them is to acquire the code, data, or private keys on the external servers by some means and then use them in one’s analysis of the malware in question.

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


Summary This chapter introduced x86 assembly code analysis and demonstrated how we can perform disassembly-based static analysis on ircbot.exe using open source Python tools.

సారాంశం ఈ అధ్యాయం x86 అసెంబ్లీ కోడ్ విశ్లేషణను పరిచయం చేసింది మరియు ఓపెన్ సోర్స్ పైథాన్ సాధనాలను ఉపయోగించి ircbot.exe పై డిస్అసెంబ్లీ-ఆధారిత స్టాటిక్ విశ్లేషణను ఎలా నిర్వహించవచ్చో చూపించింది.


Although this is not meant to be a complete primer on x86 assembly, you should now feel comfortable enough that you have a starting place for figuring out what’s going on in a given malware assembly dump.

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


Finally, you learned ways in which malware authors can defend against disassembly and other static analysis techniques, and how you can mitigate these anti-analysis and anti- detection strategies.

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


In Chapter 3, you’ll learn to conduct dynamic malware analysis that makes up for many of the weaknesses of static malware analysis.

అధ్యాయం 3లో, మీరు స్టాటిక్ మాల్వేర్ విశ్లేషణ యొక్క బలహీనతలను అధిగమించే డైనమిక్ మాల్వేర్ విశ్లేషణను నిర్వహించడం నేర్చుకుంటారు.


Unlike static analysis, which focuses on what malware looks like in file form, dynamic analysis consists of running malware in a safe, contained environment to see how it behaves.

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


This is like introducing a dangerous bacterial strain into a sealed environment to see its effects on other cells.

ఇది ఇతర కణాలపై దాని ప్రభావాలను చూడటానికి ఒక సీలు చేసిన వాతావరణంలో ప్రమాదకరమైన బ్యాక్టీరియా జాతిని ప్రవేశపెట్టడం లాంటిది.


Using dynamic analysis, we can get around common static analysis hurdles, such as packing and obfuscation, as well as gain more direct insight into the purpose of a given malware sample.

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


We begin by exploring basic dynamic analysis techniques, their relevance to malware data science, and their applications.

ప్రాథమిక డైనమిక్ విశ్లేషణ పద్ధతులు, మాల్వేర్ డేటా సైన్స్‌కు వాటి సంబంధం మరియు వాటి అనువర్తనాలను అన్వేషించడం ద్వారా మేము ప్రారంభిస్తాము.


We use open source tools like malwr.com to study examples of dynamic analysis in action.

యాక్షన్లో డైనమిక్ విశ్లేషణకు ఉదాహరణలను అధ్యయనం చేయడానికి మేము malwr.com వంటి ఓపెన్ సోర్స్ సాధనాలను ఉపయోగిస్తాము.


Note that this is a condensed survey of the topic and is not intended to be comprehensive.

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


To understand why dynamic analysis matters, let’s consider the problem of packed malware.

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


Recall that packing malware refers to compressing or obfuscating a malware’s x86 assembly code to hide the malicious nature of the program.

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


A packed malware sample unpacks itself when it infects a target machine so that the code can execute.

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


We could try to disassemble a packed or obfuscated malware sample using the static analysis tools discussed in Chapter 2, but this is a laborious process.

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


For example, with static analysis we’d first have to find the location of the obfuscated code in the malware file.

ఉదాహరణకు, స్టాటిక్ విశ్లేషణతో, మేము మొదట మాల్వేర్ ఫైల్‌లో అస్పష్టమైన కోడ్ యొక్క స్థానాన్ని కనుగొనాలి.


Then we’d have to find the location of the deobfuscation subroutines that deobfuscate this code so that it can run.

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


The method we’ll use is linear disassembly, which involves identifying the contiguous sequence of bytes in the Portable Executable (PE) file that corresponds to its x86 program code and then decoding these bytes.

మనం ఉపయోగించే పద్ధతి లీనియర్ డిస్అసెంబ్లీ, ఇది పోర్టబుల్ ఎగ్జిక్యూటబుల్ (PE) ఫైల్‌లోని x86 ప్రోగ్రామ్ కోడ్‌కు అనుగుణంగా ఉండే బైట్‌ల యొక్క నిరంతర శ్రేణిని గుర్తించడం మరియు ఆ బైట్‌లను డీకోడ్ చేయడం.


The key limitation of this approach is that it ignores subtleties about how instructions are decoded by the CPU in the course of program execution.

ఈ విధానం యొక్క ముఖ్యమైన పరిమితి ఏమిటంటే, ప్రోగ్రామ్ అమలు సమయంలో CPU ద్వారా సూచనలు ఎలా డీకోడ్ చేయబడతాయనే దాని గురించి ఇది సూక్ష్మ నైపుణ్యాలను విస్మరిస్తుంది.


Also, it doesn’t account for the various obfuscations malware authors sometimes use to make their programs harder to analyze.

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


The other methods of reverse engineering, which we won’t cover here, are the more complex disassembly methods used by industrial-grade disassemblers such as IDA Pro.

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


These more advanced methods actually simulate or reason about program execution to discover which assembly instructions a program might reach as a result of a series of conditional branches.

ఈ మరింత అధునాతన పద్ధతులు వాస్తవానికి ప్రోగ్రామ్ అమలును అనుకరిస్తాయి లేదా తర్కిస్తాయి, ఇది షరతులతో కూడిన శాఖల శ్రేణి ఫలితంగా ప్రోగ్రామ్ చేరుకునే అసెంబ్లీ సూచనలను కనుగొనడానికి.


Although this type of disassembly can be more accurate than linear disassembly, it’s far more CPU intensive than linear disassembly methods, making it less suitable for data science purposes where the focus is on disassembling thousands or even millions of programs.

ఈ రకమైన డిస్అసెంబ్లీ లీనియర్ డిస్అసెంబ్లీ కంటే ఖచ్చితమైనది అయినప్పటికీ, ఇది లీనియర్ డిస్అసెంబ్లీ పద్ధతుల కంటే చాలా ఎక్కువ CPU ఇంటెన్సివ్, ఇది డేటా సైన్స్ ప్రయోజనాల కోసం తక్కువ అనుకూలంగా ఉంటుంది, ఇక్కడ దృష్టి వేలాది లేదా లక్షల ప్రోగ్రామ్‌లను డిస్అసెంబ్లింగ్ చేయడంపై ఉంటుంది.


Before you can begin analysis using linear disassembly, however, you’ll need to review the basic components of assembly language.

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


Assembly language is the lowest-level human-readable programming language for a given architecture, and it maps closely to the binary instruction format of a particular CPU architecture.

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


A line of assembly language is almost always equivalent to a single CPU instruction.

అసెంబ్లీ భాష యొక్క ఒక లైన్ దాదాపు ఎల్లప్పుడూ ఒకే CPU సూచనకు సమానంగా ఉంటుంది.


Because assembly is so low level, you can often retrieve it easily from a malware binary by using the right tools.

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


Gaining basic proficiency in reading disassembled malware x86 code is easier than you might think.

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


This is because most malware assembly code spends most of its time calling into the operating system by way of the Windows operating system’s dynamic-link libraries (DLLs), which are loaded into program memory at runtime.

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


Malware programs use DLLs to do most of the real work, such as modifying the system registry, moving and copying files, making network connections and communicating via network protocols, and so on.

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


Therefore, following malware assembly code often involves understanding the ways in which function calls are made from assembly and understanding what various DLL calls do.

అందువల్ల, మాల్వేర్ అసెంబ్లీ కోడ్‌ను అనుసరించడం తరచుగా అసెంబ్లీ నుండి ఫంక్షన్ కాల్‌లు ఎలా చేయబడతాయో అర్థం చేసుకోవడం మరియు వివిధ DLL కాల్‌లు ఏమి చేస్తాయో అర్థం చేసుకోవడం.


Of course, things can get much more complicated, but knowing this much can reveal a lot about the malware.

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


In the following sections I introduce some important assembly language concepts.

కింది విభాగాలలో నేను కొన్ని ముఖ్యమైన అసెంబ్లీ భాషా భావనలను పరిచయం చేస్తాను.


I also explain some abstract concepts like control flow and control flow graphs.

నేను కంట్రోల్ ఫ్లో మరియు కంట్రోల్ ఫ్లో గ్రాఫ్‌ల వంటి కొన్ని నైరూప్య భావనలను కూడా వివరిస్తాను.


Finally, we disassemble the ircbot.exe program and explore how its assembly and control flow can give us insight into its purpose.

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


There are two major dialects of x86 assembly: Intel and AT&T.

x86 అసెంబ్లీకి రెండు ప్రధాన మాండలికాలు ఉన్నాయి: Intel మరియు AT&T.


In this book I use Intel syntax, which can be obtained from all major disassemblers and is the syntax used in the official Intel documentation of the x86 CPU.

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


You can use this program on any of the malware datasets in this book.

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


Building a Shared Image Relationship Network In addition to analyzing malware based on their shared callback servers, we can also analyze them based on their use of shared icons and other graphical assets.

షేర్డ్ కాల్‌బ్యాక్ సర్వర్‌ల ఆధారంగా మాల్వేర్‌ను విశ్లేషించడంతో పాటు, షేర్డ్ చిహ్నాలు మరియు ఇతర గ్రాఫికల్ ఆస్తులను ఉపయోగించడం ద్వారా కూడా మేము వాటిని విశ్లేషించవచ్చు.


You can see that all these Trojan horses pose as archive files and use the same archive file icon.

ఈ ట్రోజన్ హార్స్‌లన్నీ ఆర్కైవ్ ఫైల్‌లుగా నటిస్తున్నాయని మరియు ఒకే ఆర్కైవ్ ఫైల్ చిహ్నాన్ని ఉపయోగిస్తున్నాయని మీరు చూడవచ్చు.


The fact that they use exactly the same image as part of their effort to game the user indicates that they probably come from the same attacker.

వినియోగదారుని మోసం చేయడానికి వారు ఒకే చిత్రాన్ని ఉపయోగిస్తున్నారనే వాస్తవం, వారు ఒకే దాడి చేసే వ్యక్తి నుండి వచ్చారని సూచిస్తుంది.


I confirmed this by running the malware samples through the Kaspersky antivirus engine.

కాస్పెర్స్కీ యాంటీవైరస్ ఇంజిన్ ద్వారా మాల్వేర్ నమూనాలను నడపడం ద్వారా నేను దీన్ని నిర్ధారించాను.


To extract the images from the malware, we use the helper library images.

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


Let’s walk through the process of creating a shared image network.

షేర్డ్ ఇమేజ్ నెట్‌వర్క్‌ను రూపొందించే ప్రక్రియను పరిశీలిద్దాం.


The program starts out much like the hostname graph program.

ప్రోగ్రామ్ హోస్ట్‌నేమ్ గ్రాఫ్ ప్రోగ్రామ్ లాగానే ప్రారంభమవుతుంది.


It first imports a number of modules, including pefile and networkx.

ఇది మొదట pefile మరియు networkxతో సహా అనేక మాడ్యూల్స్‌ను దిగుమతి చేస్తుంది.


Here, however, we also define the ExtractImages helper class.

అయితే, ఇక్కడ, మేము ExtractImages సహాయక తరగతిని కూడా నిర్వచిస్తాము.


Then the program enters a loop in which we iterate over all the target malware binaries.

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


First, we pass in a path to a target malware binary to the ExtractImages class.

ముందుగా, మేము ExtractImages తరగతికి లక్ష్య మాల్వేర్ బైనరీకి ఒక మార్గాన్ని పంపుతాము.


This results in the ExtractImages class creating a temporary directory in which it stores the malware images.

దీని ఫలితంగా ExtractImages తరగతి తాత్కాలిక డైరెక్టరీని సృష్టిస్తుంది, దీనిలో అది మాల్వేర్ చిత్రాలను నిల్వ చేస్తుంది.


Now that we have the list of extracted images from ExtractImages, we iterate over it.

ExtractImages నుండి సంగ్రహించిన చిత్రాల జాబితా ఇప్పుడు మన వద్ద ఉంది, మేము దానిని పునరావృతం చేస్తాము.


We do this in exactly the same way that we did in Listing 4-11.

మేము దీన్ని జాబితా 4-11లో చేసిన విధంగానే చేస్తాము.


You can use image_network.py to analyze graphical assets in any of the malware datasets in this book.

మీరు ఈ పుస్తకంలోని ఏదైనా మాల్వేర్ డేటాసెట్‌లలో గ్రాఫికల్ ఆస్తులను విశ్లేషించడానికి image_network.pyని ఉపయోగించవచ్చు.


In this chapter, you learned about the tools and methods necessary to perform shared attribute analysis on your own malware datasets.

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


Specifically, you learned how networks, bipartite networks, and bipartite network projections can help identify the social connections between malware samples.

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


Suppose you discovered a new malware sample on your network.

మీ నెట్‌వర్క్‌లో మీరు కొత్త మాల్వేర్ నమూనాను కనుగొన్నారని అనుకుందాం.


By revealing which previously analyzed samples the new malware sample is similar to, and thus revealing the code they share, shared code analysis allows you to reuse your previous analyses on new malware so that you’re not starting from scratch.

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


We look up that sketch’s record in the database and append our sample’s ID to the list of samples associated with that sketch.

మేము ఆ స్కెచ్ రికార్డ్‌ను డేటాబేస్‌లో చూస్తాము మరియు మా నమూనా యొక్క IDని ఆ స్కెచ్‌తో అనుబంధించబడిన నమూనాల జాబితాకు జోడిస్తాము.


Here, we use a sample’s filesystem path as its ID.

ఇక్కడ, మేము నమూనా యొక్క ఫైల్‌సిస్టమ్ మార్గాన్ని దాని IDగా ఉపయోగిస్తాము.


You can see how this is implemented in the code.

ఇది కోడ్‌లో ఎలా అమలు చేయబడిందో మీరు చూడవచ్చు.


We loop over the sketches we’ve computed for a sample.

మేము ఒక నమూనా కోసం లెక్కించిన స్కెచ్‌లను పరిశీలిస్తాము.


We create a record for the sketch if it doesn’t already exist.

అది ఇప్పటికే లేకపోతే, మేము స్కెచ్ కోసం ఒక రికార్డ్‌ను సృష్టిస్తాము.


We add the sample path to the sketch’s set of associated sample paths if the sketch’s record does exist.

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


Listing 5-11 shows the declaration of two important functions: comment_sample() and search_sample().

జాబితా 5-11 రెండు ముఖ్యమైన ఫంక్షన్ల ప్రకటనను చూపుతుంది: comment_sample() మరియు search_sample().


Function that allows a user to comment on a sample.

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


The comment the user provides shows up whenever this sample is seen in a list of similar samples.

వినియోగదారు అందించిన వ్యాఖ్య ఈ నమూనా సారూప్య నమూనాల జాబితాలో కనిపించినప్పుడల్లా కనిపిస్తుంది.


This functionality is useful, because it allows users of the program to include insights gained from reverse-engineering a sample.

ఈ కార్యాచరణ ఉపయోగకరంగా ఉంటుంది, ఎందుకంటే ఇది ప్రోగ్రామ్ యొక్క వినియోగదారులను నమూనాను రివర్స్-ఇంజనీరింగ్ చేయడం ద్వారా పొందిన అంతర్దృష్టులను చేర్చడానికి అనుమతిస్తుంది.


Next, search_sample() leverages minhash to find samples similar to a query sample.

తరువాత, search_sample() ప్రశ్న నమూనాకు సమానమైన నమూనాలను కనుగొనడానికి minhashని ఉపయోగిస్తుంది.


To do this, first we extract string features, minhashes, and sketches from the query sample.

దీన్ని చేయడానికి, మొదట మేము ప్రశ్న నమూనా నుండి స్ట్రింగ్ ఫీచర్‌లు, minhashes మరియు స్కెచ్‌లను సంగ్రహిస్తాము.


Then, we iterate over the sample’s sketches, looking up samples stored in the database that also have that sketch.

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


For each sample that shares a sketch with the query sample, we compute its approximate Jaccard index using its minhashes.

ప్రశ్న నమూనాతో స్కెచ్‌ను పంచుకునే ప్రతి నమూనా కోసం, మేము దాని minhashesని ఉపయోగించి దాని సుమారు జాకార్డ్ సూచికను లెక్కిస్తాము.


Finally, we report the most similar samples to the query sample to the user, along with any comments associated with these samples.

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


Here, we allow users to load malware samples into the database.

ఇక్కడ, మేము వినియోగదారులను మాల్వేర్ నమూనాలను డేటాబేస్‌లోకి లోడ్ చేయడానికి అనుమతిస్తాము.


We also allow the user to comment on samples already in the database.

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


సారూప్య శోధన వ్యవస్థను అమలు చేయడం


You can load samples individually or specify a directory.

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


Wiping the database simply clears all records from the system database.

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


You might think that regardless of compiler, the function would reduce to the same sequence of assembly instructions.

కంపైలర్‌తో సంబంధం లేకుండా, ఫంక్షన్ ఒకే అసెంబ్లీ సూచనల శ్రేణికి తగ్గుతుందని మీరు అనుకోవచ్చు.


But in fact, compilation depends heavily not just on what compiler you use, but also on the compiler settings.

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


For example, compiling this function using the clang compiler under its default settings yields the following instructions corresponding to the line at ➊ in the source code:

ఉదాహరణకు, ఈ ఫంక్షన్‌ను క్లాంగ్ కంపైలర్‌ను ఉపయోగించి దాని డిఫాల్ట్ సెట్టింగ్‌ల క్రింద కంపైల్ చేయడం వలన సోర్స్ కోడ్‌లోని ➊ లైన్‌కు అనుగుణంగా ఈ క్రింది సూచనలు వస్తాయి:


In contrast, compiling the same function with the –O3 flag set, which tells the compiler to optimize the code for speed, yields the following assembly for the same line of the source code:

దీనికి విరుద్ధంగా, –O3 ఫ్లాగ్ సెట్‌తో అదే ఫంక్షన్‌ను కంపైల్ చేయడం, ఇది కోడ్‌ను వేగం కోసం ఆప్టిమైజ్ చేయమని కంపైలర్‌కు చెబుతుంది, సోర్స్ కోడ్‌లోని అదే లైన్ కోసం ఈ క్రింది అసెంబ్లీని ఇస్తుంది:


The difference results from the fact that in the second example, the compiler pre-computed the result of the function instead of explicitly computing it, as in the first compilation example.

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


This means that if we compared these functions based on instruction sequences, they wouldn’t appear at all similar, even though in reality they were compiled from exactly the same source code.

అంటే, మనం ఈ ఫంక్షన్లను సూచనల శ్రేణుల ఆధారంగా పోల్చినట్లయితే, వాస్తవానికి అవి ఒకే సోర్స్ కోడ్ నుండి కంపైల్ చేయబడినప్పటికీ, అవి ఏమాత్రం ఒకేలా కనిపించవు.


Beyond the problem of identical C and C++ code appearing to be very different when we’re looking at its assembly instructions, there’s an additional problem that arises when we compare binaries based on their assembly code:

ఒకేలాంటి C మరియు C++ కోడ్ దాని అసెంబ్లీ సూచనలను చూస్తున్నప్పుడు చాలా భిన్నంగా కనిపించే సమస్యతో పాటు, మేము వాటి అసెంబ్లీ కోడ్‌పై ఆధారపడి బైనరీలను పోల్చినప్పుడు తలెత్తే అదనపు సమస్య ఉంది:


many malware binaries are now authored in high-level languages like C#.

చాలా మాల్వేర్ బైనరీలు ఇప్పుడు C# వంటి హై-లెవెల్ భాషల్లో రూపొందించబడ్డాయి.


These binaries contain standard boilerplate assembly code that simply interprets these higher-level languages’ bytecode.

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


So, although binaries written in the same high-level language may share very similar x86 instructions, their actual bytecode may reflect the fact that they come from very different source code.

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


We can compute strings-based malware similarity by extracting all contiguous printable sequences of characters in the samples and then computing the Jaccard index between all pairs of malware samples based on their shared string relationships.

నమూనాలలోని అక్షరాల యొక్క అన్ని అనుబంధించబడిన ముద్రించదగిన శ్రేణులను సంగ్రహించడం ద్వారా మరియు వాటి భాగస్వామ్య స్ట్రింగ్ సంబంధాల ఆధారంగా మాల్వేర్ నమూనాల యొక్క అన్ని జతల మధ్య జాకార్డ్ సూచికను లెక్కించడం ద్వారా మేము స్ట్రింగ్-ఆధారిత మాల్వేర్ సారూప్యతను లెక్కించవచ్చు.


This approach gets around the compiler problem because the strings extracted from a binary tend to be format strings defined by the programmer, which compilers as a general rule do not transform, regardless of which compilers the malware authors are using or what parameters they give the compilers.

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


For example, a typical string extracted from a malware binary might read, “Started key logger at %s on %s and time %s.”

ఉదాహరణకు, మాల్వేర్ బైనరీ నుండి సంగ్రహించబడిన ఒక సాధారణ స్ట్రింగ్, “Started key logger at %s on %s and time %s.” అని ఉండవచ్చు.


Regardless of compiler settings, this string will tend to look identical among multiple binaries and is related to whether or not they’re based on the same source code base.

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


Figure 5-8 shows how well the string-based code-sharing metric identifies the correct code-sharing relationships in the crimeware dataset.

చిత్రం 5-8 స్ట్రింగ్-ఆధారిత కోడ్-షేరింగ్ మెట్రిక్ క్రిమ్‌వేర్ డేటాసెట్‌లో సరైన కోడ్-షేరింగ్ సంబంధాలను ఎంత బాగా గుర్తిస్తుందో చూపిస్తుంది.


At first glance, this method does far better at identifying the malware families than the instruction-based method, accurately recovering much of the similarity relationships for all seven families.

ఒక చూపులో, ఈ పద్ధతి సూచన-ఆధారిత పద్ధతి కంటే మాల్వేర్ కుటుంబాలను గుర్తించడంలో చాలా మెరుగ్గా పనిచేస్తుంది, ఏడు కుటుంబాలన్నింటికీ సారూప్యత సంబంధాలను ఖచ్చితంగా తిరిగి పొందుతుంది.


However, unlike the instruction similarity method, there are a few false positives, since it incorrectly predicts that xtoober and dapato share some level of code.

అయితే, సూచన సారూప్యత పద్ధతికి భిన్నంగా, కొన్ని తప్పుడు సానుకూలాలు ఉన్నాయి, ఎందుకంటే xtoober మరియు dapato కొంత స్థాయి కోడ్‌ను పంచుకుంటాయని ఇది తప్పుగా అంచనా వేస్తుంది.


It’s also worth noting that this method didn’t detect similarities between samples in some families, performing particularly poorly on the zango, skor, and dapato families.

కొన్ని కుటుంబాలలో నమూనాల మధ్య సారూప్యతను ఈ పద్ధతి గుర్తించలేదని కూడా గమనించాలి, జాంగో, స్కోర్ మరియు డాపాటో కుటుంబాలపై ఇది ప్రత్యేకంగా పేలవంగా పనిచేస్తుంది.


We can compute what I call “Import Address Table–based similarity” by comparing the DLL imports made by malware binaries.

మాల్వేర్ బైనరీల ద్వారా చేయబడిన DLL దిగుమతులను పోల్చడం ద్వారా నేను “దిగుమతి చిరునామా పట్టిక–ఆధారిత సారూప్యత” అని పిలుస్తాను.


The idea behind this approach is that even if the malware author has reordered instructions, obfuscated the initialized data section of the malware binary, and implemented anti-debugger and anti-VM anti-analysis techniques, they may have left the exact same import declarations in place.

ఈ విధానం వెనుక ఉన్న ఆలోచన ఏమిటంటే, మాల్వేర్ రచయిత సూచనలను తిరిగి క్రమబద్ధీకరించినప్పటికీ, మాల్వేర్ బైనరీ యొక్క ప్రారంభించబడిన డేటా విభాగాన్ని అస్పష్టం చేసినా మరియు యాంటీ-డీబగ్గర్ మరియు యాంటీ-VM యాంటీ-విశ్లేషణ పద్ధతులను అమలు చేసినా, వారు ఖచ్చితమైన దిగుమతి ప్రకటనలను అలాగే ఉంచి ఉండవచ్చు.


This example uses an algorithm called logistic regression.

ఈ ఉదాహరణ లాజిస్టిక్ రిగ్రెషన్ అనే అల్గారిథమ్‌ను ఉపయోగిస్తుంది.


The line running through the center of the plot is the decision boundary.

ప్లాట్ మధ్యలో నడుస్తున్న రేఖ నిర్ణయ సరిహద్దు.


Logistic regression allows us to easily move the line up into the darker region or down into the lighter region.

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


If we move it down, we’ll catch more malware, but get more false positives.

మనం కిందికి తరలిస్తే, మనం ఎక్కువ మాల్వేర్‌ను పట్టుకుంటాము, కాని ఎక్కువ తప్పుడు సానుకూలతలను పొందుతాము.


Logistic regression is a relatively simple machine learning algorithm.

లాజిస్టిక్ రిగ్రెషన్ అనేది సాపేక్షంగా సాధారణమైన యంత్ర అభ్యాస అల్గారిథమ్.


Other machine learning algorithms can create decision boundaries that are more complex.

ఇతర యంత్ర అభ్యాస అల్గారిథమ్‌లు మరింత సంక్లిష్టమైన నిర్ణయ సరిహద్దులను సృష్టించగలవు.


As you can see, this decision boundary isn’t a plane: it’s a highly irregular structure.

మీరు చూడగలిగినట్లుగా, ఈ నిర్ణయ సరిహద్దు ఒక విమానం కాదు: ఇది చాలా క్రమరహిత నిర్మాణం.


Good, accurate detection models in machine learning capture the general trend.

మెషిన్ లెర్నింగ్‌లో మంచి, ఖచ్చితమైన గుర్తింపు నమూనాలు సాధారణ ధోరణిని సంగ్రహిస్తాయి.


Underfit models ignore outliers but fail to capture the general trend.

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


Overfit models get distracted by outliers in ways that don’t reflect the general trend.

ఓవర్‌ఫిట్ నమూనాలు సాధారణ ధోరణిని ప్రతిబింబించని మార్గాల్లో అంచనాల ద్వారా పరధ్యానానికి గురవుతాయి.


Building machine learning malware detection models is all about capturing the general trend.

మెషిన్ లెర్నింగ్ మాల్వేర్ డిటెక్షన్ మోడల్స్‌ను నిర్మించడం సాధారణ ధోరణిని సంగ్రహించడం గురించే.


Here, you can see the black dots (malware) cluster in the upper-right region of the plot.

ఇక్కడ, మీరు నల్ల చుక్కలు (మాల్వేర్) ప్లాట్ యొక్క కుడి ఎగువ ప్రాంతంలో గుమిగూడడాన్ని చూడవచ్చు.


In this case, the model not only captures the general trend in the data but also creates a reasonable model of certainty.

ఈ సందర్భంలో, నమూనా డేటాలోని సాధారణ ధోరణిని మాత్రమే కాకుండా, ఖచ్చితత్వానికి సంబంధించిన సహేతుకమైన నమూనాను కూడా సృష్టిస్తుంది.


The overfit model in Figure 6-9 fails to capture the general trend in the data.

చిత్రం 6-9 లోని ఓవర్‌ఫిట్ నమూనా డేటాలోని సాధారణ ధోరణిని సంగ్రహించడంలో విఫలమవుతుంది.


Logistic regression is a machine learning algorithm that creates a line, plane, or hyperplane.

లాజిస్టిక్ రిగ్రెషన్ అనేది ఒక యంత్ర అభ్యాస అల్గారిథమ్, ఇది ఒక రేఖ, విమానం లేదా హైపర్‌ప్లేన్‌ను సృష్టిస్తుంది.


A limitation of logistic regression is that if your data can’t be separated simply using a line or hyperplane, logistic regression is not the right solution.

లాజిస్టిక్ రిగ్రెషన్ యొక్క పరిమితి ఏమిటంటే, మీ డేటాను ఒక రేఖ లేదా హైపర్‌ప్లేన్‌ను ఉపయోగించి సులభంగా వేరు చేయలేకపోతే, లాజిస్టిక్ రిగ్రెషన్ సరైన పరిష్కారం కాదు.


If your data is such that you need to use complex relationships between features to decide that a file is malware, then another approach, like k-nearest neighbors, decision trees, or random forest, might make more sense.

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


We see that logistic regression yields a very effective separation of the malware and benignware in our simple dataset.

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


Let’s now look at the math behind how logistic regression detects malware samples.

లాజిస్టిక్ రిగ్రెషన్ మాల్వేర్ నమూనాలను ఎలా గుర్తిస్తుందో దాని వెనుక ఉన్న గణితాన్ని ఇప్పుడు చూద్దాం.


In other words, it’s easy to identify and compare similarities between samples and an unknown sample to figure out why the algorithm has classified it as malware or benignware.

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


The decision tree starts with an initial question called a root node.

నిర్ణయ వృక్షం రూట్ నోడ్ అని పిలువబడే ప్రారంభ ప్రశ్నతో ప్రారంభమవుతుంది.


The best root node is the one for which we get a “yes” answer for most if not all samples of one type, and a “no” answer for most if not all samples of the other type.

మనం ఒక రకానికి చెందిన చాలా నమూనాలకు కాకపోతే అన్నింటికీ “అవును” సమాధానం మరియు ఇతర రకానికి చెందిన చాలా నమూనాలకు కాకపోతే అన్నింటికీ “కాదు” సమాధానం పొందేదే ఉత్తమ రూట్ నోడ్.


For example, in Figure 6-16, the root node question asks whether a previously unseen binary has 40.111 or fewer calls.

ఉదాహరణకు, చిత్రం 6-16 లో, రూట్ నోడ్ ప్రశ్న ఇంతకు ముందు చూడని బైనరీ 40.111 లేదా అంతకంటే తక్కువ కాల్స్ కలిగి ఉందా అని అడుగుతుంది.


As you can see from the vertical line in Figure 6-17, most of the benign data has less than this number, while most of the malware data has more than this number of suspicious calls, making this a good initial question to ask.

మీరు చిత్రం 6-17 లోని నిలువు గీత నుండి చూడగలిగినట్లుగా, చాలా నిరపాయకరమైన డేటా ఈ సంఖ్య కంటే తక్కువగా ఉంది, అయితే చాలా మాల్వేర్ డేటా ఈ అనుమానాస్పద కాల్‌ల సంఖ్య కంటే ఎక్కువగా ఉంది, ఇది అడగడానికి మంచి ప్రారంభ ప్రశ్న.


After choosing a root node, pick the next questions using a method similar to the one we used to pick the root node.

రూట్ నోడ్‌ను ఎంచుకున్న తర్వాత, రూట్ నోడ్‌ను ఎంచుకోవడానికి మనం ఉపయోగించిన పద్ధతికి సమానమైన పద్ధతిని ఉపయోగించి తదుపరి ప్రశ్నలను ఎంచుకోండి.


For example, the root node allowed us to split the samples into two groups: one group that has less than or equal to 40.111 suspicious calls (negative feature space) and another that has more than 40.111 suspicious calls (positive feature space).

ఉదాహరణకు, రూట్ నోడ్ నమూనాలను రెండు సమూహాలుగా విభజించడానికి అనుమతించింది: ఒకటి 40.111 లేదా అంతకంటే తక్కువ అనుమానాస్పద కాల్‌లు ఉన్న సమూహం (ప్రతికూల ఫీచర్ స్పేస్) మరియు మరొకటి 40.111 కంటే ఎక్కువ అనుమానాస్పద కాల్‌లు ఉన్న సమూహం (సానుకూల ఫీచర్ స్పేస్).


To choose the next question, we just need questions that will further distinguish the samples in each area of the feature space into malicious and benign training examples.

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


At some point in our decision tree creation process, we need to decide when the decision tree should stop asking questions and simply determine whether a binary file is benign or malicious based on our certainty about our answer.

మన నిర్ణయ వృక్షం తయారీ ప్రక్రియలో ఒకానొక సమయంలో, నిర్ణయ వృక్షం ఎప్పుడు ప్రశ్నలు వేయడం ఆపివేయాలి మరియు మన సమాధానం గురించి మనకు ఉన్న నమ్మకం ఆధారంగా బైనరీ ఫైల్ నిరపాయకరమైనదా లేదా హానికరమైనదా అని నిర్ణయించుకోవాలి.


One way is to simply limit the number of questions our decision tree can ask, or to limit its depth (the maximum number of questions we can ask of any binary).

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


The advantage of constraining the size of the tree is that if the tree is simpler, we have a greater chance of getting the answer right (think of Occam’s razor—the simpler the theory, the better).

వృక్షం పరిమాణాన్ని పరిమితం చేయడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే, వృక్షం సరళంగా ఉంటే, మనం సమాధానం సరిగ్గా పొందే అవకాశం ఉంది (ఒక్కం బ్లేడ్‌ను ఆలోచించండి—సిద్ధాంతం ఎంత సరళంగా ఉంటే అంత మంచిది).


In other words, there’s less chance that the decision tree will overfit the training data if we keep it small.

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


Conversely, allowing the tree to grow to maximum size can be useful if we are underfitting the training data.

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


In general, machine learning practitioners usually try multiple depths, or allow for maximum depth on previously unseen binaries, repeating this process until they get the most accurate results.

సాధారణంగా, మెషిన్ లెర్నింగ్ ప్రాక్టీషనర్లు సాధారణంగా బహుళ లోతులను ప్రయత్నిస్తారు లేదా ఇంతకు ముందు చూడని బైనరీలపై గరిష్ట లోతును అనుమతిస్తారు, వారు అత్యంత ఖచ్చితమైన ఫలితాలను పొందే వరకు ఈ ప్రక్రియను పునరావృతం చేస్తారు.


You learned that the basic idea behind this algorithm is to create the root node in the tree by finding the question that best increases our certainty about whether the training examples are malicious or benign, and then to find subsequent questions that will further increase our certainty.

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


The algorithm should stop asking questions and make a decision once its certainty about the training examples has surpassed some threshold we set in advance.

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


The pseudocode recursively adds questions to a decision tree, beginning with the root node and working its way down until the algorithm feels confident that the decision tree can provide a highly certain answer about whether a new file is benign or malicious.

సూడోకోడ్ రూట్ నోడ్‌తో ప్రారంభించి, అల్గారిథం నిర్ణయ వృక్షం కొత్త ఫైల్ నిరపాయకరమైనదా లేదా హానికరమైనదా అనే దాని గురించి అత్యంత ఖచ్చితమైన సమాధానాన్ని అందించగలదని విశ్వసించే వరకు నిర్ణయ వృక్షానికి ప్రశ్నలను పునరావృతంగా జోడిస్తుంది.


When we start building the tree, we use pick_best_question() to pick our root node ➊ (for now, don’t worry about how this function works).

మనం వృక్షాన్ని నిర్మించడం ప్రారంభించినప్పుడు, మన రూట్ నోడ్‌ను ఎంచుకోవడానికి pick_best_question()ని ఉపయోగిస్తాము ➊ (ఇప్పుడిప్పుడే, ఈ ఫంక్షన్ ఎలా పనిచేస్తుందో పట్టించుకోవద్దు).


Then, we look at how much uncertainty we now have about the training samples for which the answer is “yes” to this initial question ➋.

అప్పుడు, ఈ ప్రారంభ ప్రశ్నకు సమాధానం “అవును” అని ఉన్న శిక్షణ నమూనాల గురించి మనకు ఇప్పుడు ఎంత అనిశ్చితి ఉందో చూస్తాము ➋.


We do the same for the samples for which we answered “no” for the initial question ➌.

మనం ప్రారంభ ప్రశ్నకు “కాదు” అని సమాధానం ఇచ్చిన నమూనాలకు కూడా అదే చేస్తాము ➌.


How exactly pick_best_question() works involves math that is beyond the scope of this book, but the idea is simple.

pick_best_question() ఎలా పని చేస్తుందనేది ఈ పుస్తకం పరిధికి మించిన గణితాన్ని కలిగి ఉంటుంది, కానీ ఆలోచన చాలా సులభం.


ROC curves can tell you how your system will perform in terms of the rate at which it calls malicious binaries malicious.

మీ సిస్టమ్ హానికరమైన బైనరీలను గుర్తించే రేటు పరంగా ఎలా పని చేస్తుందో ROC వక్రతలు మీకు తెలియజేస్తాయి.


However, ROC curves will not tell you the percentage of your system’s alarms that will be true positives, which we call the precision of the system.

అయితే, మీ సిస్టమ్ యొక్క అలారమ్‌లలో ఎన్ని నిజమైన పాజిటివ్‌లు ఉంటాయో ROC వక్రతలు మీకు చెప్పవు, దీనిని మనం సిస్టమ్ యొక్క ఖచ్చితత్వం అని పిలుస్తాము.


The precision of a system is related to the percentage of binaries the system encounters that are actually malware, which we call the base rate.

ఒక సిస్టమ్ యొక్క ఖచ్చితత్వం అనేది సిస్టమ్ ఎదుర్కొనే బైనరీలలో వాస్తవానికి మాల్వేర్ ఉన్న శాతం, దీనిని మనం బేస్ రేట్ అని పిలుస్తాము.


Precision The percentage of system detection alarms that are true positives (meaning that they are detections of actual malware).

ఖచ్చితత్వం: నిజమైన పాజిటివ్‌లుగా ఉన్న సిస్టమ్ డిటెక్షన్ అలారమ్‌ల శాతం (అంటే అవి వాస్తవ మాల్వేర్‌ను గుర్తిస్తాయి).


In other words, precision is the detection system’s number of true positives / (true positives + false positives) when tested against some set of binaries.

మరో మాటలో చెప్పాలంటే, కొన్ని బైనరీలపై పరీక్షించినప్పుడు ఖచ్చితత్వం అనేది డిటెక్షన్ సిస్టమ్ యొక్క నిజమైన పాజిటివ్‌ల సంఖ్య / (నిజమైన పాజిటివ్‌లు + తప్పుడు పాజిటివ్‌లు).


Base rate The percentage of the data fed to the system that has the quality we are looking for.

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


In our case, base rate refers to the percentage of binaries that are actually malware.

మన విషయంలో, బేస్ రేట్ అంటే వాస్తవానికి మాల్వేర్ ఉన్న బైనరీల శాతం.


Although a detection system’s true and false positive rates do not change when the base rate changes, the system’s precision is affected by changes in the malware base rate—often dramatically.

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


Suppose the false positive rate of MalDetect is 1 percent and the true positive rate is 100 percent.

MalDetect యొక్క తప్పుడు పాజిటివ్ రేటు 1 శాతం మరియు నిజమైన పాజిటివ్ రేటు 100 శాతం అని అనుకుందాం.


Now suppose we set MalDetect loose on a network that we know upfront has no malware on it.

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


Because we know in advance there is no malware on the network, every alarm the MalDetect throws will by definition be a false positive, because the only binaries that MalDetect encounters will be benignware.

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


In contrast, if we run MalDetect on a dataset composed of entirely malware, none of its alarms will ever be false positives.

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


Therefore, precision will be 100 percent.

అందువల్ల, ఖచ్చితత్వం 100 శాతం ఉంటుంది.


In both of these extreme cases, the base rates have a huge impact on MalDetect’s precision, or the probability that its alarm is a false positive.

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


What if you want to estimate the precision your system will have based on an estimate of the base rate of the environment in which you deploy it?

మీరు మీ సిస్టమ్ యొక్క ఖచ్చితత్వాన్ని మీరు అమలు చేసే వాతావరణం యొక్క బేస్ రేట్ అంచనా ఆధారంగా అంచనా వేయాలనుకుంటే ఏమి చేయాలి?


All you have to do is use your deployment environment’s estimated base rate to estimate the variables in the precision formula: true positives / (true positives + false positives).

మీరు చేయాల్సిందల్లా మీ అమలు వాతావరణం యొక్క అంచనా వేసిన బేస్ రేట్‌ను ఉపయోగించి ఖచ్చితత్వ సూత్రంలోని వేరియబుల్స్‌ను అంచనా వేయడం: నిజమైన పాజిటివ్‌లు / (నిజమైన పాజిటివ్‌లు + తప్పుడు పాజిటివ్‌లు).


You’ll need three numbers: True positive rate (TPR) of the system, or the percentage of malware samples the system will correctly detect

మీకు మూడు నంబర్‌లు అవసరం: సిస్టమ్ యొక్క నిజమైన పాజిటివ్ రేట్ (TPR), లేదా సిస్టమ్ సరిగ్గా గుర్తించే మాల్వేర్ నమూనాల శాతం


False positive rate (FPR) of the system, or the percentage of benign samples the system will incorrectly alarm on

సిస్టమ్ యొక్క తప్పుడు పాజిటివ్ రేట్ (FPR), లేదా సిస్టమ్ తప్పుగా అలారం చేసే నిరపాయమైన నమూనాల శాతం


Base rate (BR) of the binaries against which you will use the system (for example, the percentage of binaries downloaded from piracy sites you expect will be malware, if this is what you’ll be using your system on)

మీరు సిస్టమ్‌ను ఉపయోగించే బైనరీల బేస్ రేట్ (BR) (ఉదాహరణకు, మీరు మీ సిస్టమ్‌ను ఉపయోగిస్తుంటే, పైరసీ సైట్‌ల నుండి డౌన్‌లోడ్ చేసిన బైనరీలలో మాల్వేర్ ఉంటుందని మీరు భావిస్తున్న శాతం)


Let’s consider another example to see how base rate can have a profound impact on the performance of a detection system.

డిటెక్షన్ సిస్టమ్ పనితీరుపై బేస్ రేట్ ఎలా తీవ్రమైన ప్రభావాన్ని చూపుతుందో చూడటానికి మరో ఉదాహరణను పరిశీలిద్దాం.


code reads fluidly to you now that you’ve seen how each individual piece works.

ప్రతి ఒక్క భాగం ఎలా పనిచేస్తుందో చూసిన తర్వాత కోడ్ ఇప్పుడు మీకు సులభంగా అర్థమవుతుంది.


extract strings from binary file using regular expressions

రెగ్యులర్ ఎక్స్ప్రెషన్లను ఉపయోగించి బైనరీ ఫైల్ నుండి స్ట్రింగ్లను సంగ్రహించండి


store string features in dictionary form

స్ట్రింగ్ లక్షణాలను నిఘంటువు రూపంలో నిల్వ చేయండి


hash the features using the hashing trick

హ్యాషింగ్ ట్రిక్ ఉపయోగించి లక్షణాలను హ్యాష్ చేయండి


హ్యాష్ చేసిన స్ట్రింగ్ లక్షణాలను తిరిగి ఇవ్వండి


scan a file to determine if it is malicious or benign

ఒక ఫైల్ హానికరమైనదా లేదా నిరపాయమైనదా అని గుర్తించడానికి స్కాన్ చేయండి


ఫైల్లను స్కాన్ చేయడానికి ముందు డిటెక్టర్ను శిక్షణ ఇవ్వండి.


ఈ ఫైల్ హానికరమైనదిగా కనిపిస్తోంది!


ఈ ఫైల్ నిరపాయమైనదిగా కనిపిస్తోంది.


train the detector on the specified training data

నిర్దేశించిన శిక్షణ డేటాపై డిటెక్టర్కు శిక్షణ ఇవ్వండి


మాల్వేర్ శిక్షణ ఫైల్లకు మార్గం


స్కాన్ చేయడానికి ఫైల్


You did not specify a path to scan, nor did you specify paths to malicious and benign training files

మీరు స్కాన్ చేయడానికి మార్గాన్ని పేర్కొనలేదు, అలాగే హానికరమైన మరియు నిరపాయమైన శిక్షణ ఫైల్లకు మార్గాలను పేర్కొనలేదు


Writing a machine learning–based malware detector is great, but evaluating and improving its performance is necessary if you’re going to deploy the detector with any confidence in its efficacy.

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


మీ డిటెక్టర్ పనితీరును అంచనా వేయడం


The sklearn library also provides additional evaluation functionality specific to evaluating machine learning systems.

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


For example, you can use sklearn’s functions for performing cross- validation, which is a powerful method for predicting how well your detector will work when you deploy it.

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


Using ROC Curves to Evaluate Detector Efficacy

డిటెక్టర్ సామర్థ్యాన్ని అంచనా వేయడానికి ROC వక్రాలను ఉపయోగించడం


Recall that Receiver Operating Characteristic (ROC) curves measure the changes in a detector’s true positive rate (the percentage of malware that it successfully detects) and false positive rate (the percentage of benignware that it falsely flags as malware) as you adjust its sensitivity.

రిసీవర్ ఆపరేటింగ్ క్యారెక్టరిస్టిక్ (ROC) వక్రాలు డిటెక్టర్ యొక్క నిజమైన సానుకూల రేటు (ఇది విజయవంతంగా గుర్తించే మాల్వేర్ శాతం) మరియు తప్పుడు సానుకూల రేటు (మాల్వేర్గా తప్పుగా ఫ్లాగ్ చేసే నిరపాయమైన శాతం) ను మీరు దాని సున్నితత్వాన్ని సర్దుబాటు చేసినప్పుడు కొలుస్తాయని గుర్తుంచుకోండి.


The higher the sensitivity, the more false positives you will get but the greater your detection rate.

సున్నితత్వం ఎక్కువగా ఉంటే, మీకు ఎక్కువ తప్పుడు సానుకూలాలు వస్తాయి, కానీ మీ గుర్తింపు రేటు ఎక్కువగా ఉంటుంది.


We use pandas to load and analyze our data and prep it for easy visualization.

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


Let’s use Listing 9-1 to define and load some sample data into the Python interpreter.

కొన్ని నమూనా డేటాను నిర్వచించడానికి మరియు లోడ్ చేయడానికి జాబితా 9-1 ని ఉపయోగిద్దాం.


Once we have created this list of dicts, we pass it to the DataFrame constructor to get the corresponding pandas DataFrame.

ఈ డిక్ట్‌ల జాబితాను సృష్టించిన తర్వాత, సంబంధిత పాండాస్ డేటాఫ్రేమ్‌ను పొందడానికి మేము దానిని డేటాఫ్రేమ్ కన్‌స్ట్రక్టర్‌కు పంపుతాము.


Each of these dicts becomes a row in the resulting DataFrame.

ఈ డిక్ట్‌లలో ప్రతి ఒక్కటి ఫలితంగా వచ్చే డేటాఫ్రేమ్‌లో ఒక వరుసగా మారుతుంది.


The keys in the dicts (column1 and column2) become columns.

డిక్ట్‌లలోని కీలు (column1 మరియు column2) కాలమ్‌లుగా మారతాయి.


You can also load data from external CSV files.

మీరు బాహ్య CSV ఫైల్‌ల నుండి కూడా డేటాను లోడ్ చేయవచ్చు.


Let’s use the code in Listing 9-2 to load this chapter’s dataset.

ఈ అధ్యాయం యొక్క డేటాసెట్‌ను లోడ్ చేయడానికి జాబితా 9-2 లోని కోడ్‌ను ఉపయోగిద్దాం.


We now have a pandas DataFrame composed of our malware dataset.

ఇప్పుడు మన దగ్గర మన మాల్వేర్ డేటాసెట్‌తో కూడిన పాండాస్ డేటాఫ్రేమ్ ఉంది.


It has four columns: positives, size, type, and fs_bucket.

ఇది నాలుగు కాలమ్‌లను కలిగి ఉంది: పాజిటివ్‌లు, పరిమాణం, రకం మరియు fs_bucket.


Now that we have our data in a pandas DataFrame, let’s look at how to access and manipulate it.

మన డేటా పాండాస్ డేటాఫ్రేమ్‌లో ఉన్నందున, దానిని ఎలా యాక్సెస్ చేయాలో మరియు మార్చాలో చూద్దాం.


Calling the describe() method shows some useful statistics about our DataFrame.

describe() పద్ధతిని పిలవడం వలన మన డేటాఫ్రేమ్ గురించి కొన్ని ఉపయోగకరమైన గణాంకాలు తెలుస్తాయి.


The first line, count, counts the total number of non-null positives rows.

మొదటి లైన్, కౌంట్, మొత్తం నాన్-నల్ పాజిటివ్‌ల వరుసలను లెక్కిస్తుంది.


The second line gives the mean, or average number of positives per sample.

రెండవ లైన్ సగటును లేదా నమూనాకు పాజిటివ్‌ల సగటు సంఖ్యను ఇస్తుంది.


Next comes the standard deviation for both positives and size.

తరువాత పాజిటివ్‌లు మరియు పరిమాణం రెండింటికీ ప్రామాణిక విచలనం వస్తుంది.


Suppose we’d like to retrieve the data for one of the columns in the malware DataFrame, such as the positives column.

మాల్వేర్ డేటాఫ్రేమ్‌లోని కాలమ్‌లలో ఒకదానికి, పాజిటివ్‌ల కాలమ్ వంటి డేటాను తిరిగి పొందాలనుకుంటున్నాం అనుకుందాం.


To do this, we simply write malware[‘positives’], which returns the positives column as a list of numbers.

దీన్ని చేయడానికి, మేము కేవలం malware[‘positives’] అని వ్రాస్తాము, ఇది పాజిటివ్‌ల కాలమ్‌ను సంఖ్యల జాబితాగా అందిస్తుంది.


After retrieving a column, we can compute statistics on it directly.

ఒక కాలమ్‌ను తిరిగి పొందిన తర్వాత, మేము దానిపై నేరుగా గణాంకాలను లెక్కించవచ్చు.


We can also slice and dice the data to do more detailed analysis.

మరింత వివరణాత్మక విశ్లేషణ చేయడానికి మేము డేటాను ముక్కలు చేయవచ్చు.


Listing 9-6 yields an interesting result, which is that worms get detected more frequently than bitcoin mining and Trojan horse malware.

జాబితా 9-6 ఒక ఆసక్తికరమైన ఫలితాన్ని ఇస్తుంది, అదేమిటంటే వార్మ్‌లు బిట్‌కాయిన్ మైనింగ్ మరియు ట్రోజన్ హార్స్ మాల్వేర్‌ల కంటే ఎక్కువగా గుర్తించబడతాయి.


We can select a subset of the data using other conditions as well.

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


To transform string features into a format that sklearn can understand, we need to put them into a Python dictionary.

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


For example, the previous sample binary would get a feature vector of {“PE executable”: 1, “Malicious payload”: 1}.

ఉదాహరణకు, మునుపటి నమూనా బైనరీ {“PE ఎగ్జిక్యూటబుల్”: 1, “మాలిషియస్ పేలోడ్”: 1} యొక్క ఫీచర్ వెక్టార్‌ను పొందుతుంది.


In fact, string features work well with machine learning–based detection because they capture so much information about software binaries.

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


If the binary is a packed malware sample, then it’s likely to have few informative strings, which in itself can be a giveaway that the file is malicious.

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


On the other hand, if parts of the file’s resources section are not packed or obfuscated, then those strings reveal much about the file’s behavior.

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


For example, if the binary program in question makes HTTP requests, it’s common to see strings such as “GET %s” in that file’s set of strings.

ఉదాహరణకు, ప్రశ్నలోని బైనరీ ప్రోగ్రామ్ HTTP అభ్యర్థనలను చేస్తే, ఆ ఫైల్ యొక్క స్ట్రింగ్‌ల సమితిలో “GET %s” వంటి స్ట్రింగ్‌లను చూడటం సాధారణం.


String features have some limitations, however.

అయితే, స్ట్రింగ్ ఫీచర్లకు కొన్ని పరిమితులు ఉన్నాయి.


For example, they don’t capture anything about the actual logic of a binary program, because they don’t include actual program code.

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


As a result, detectors based on string features are not ideal for detecting packed malware.

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


PE header features complement string features well.

PE హెడర్ ఫీచర్‌లు స్ట్రింగ్ ఫీచర్లను బాగా పూర్తి చేస్తాయి.


For example, whereas string features often do a good job of capturing the function calls and network transmissions made by a program, like the “GET %s” example, PE header features capture information like a program binary’s compile timestamp, the layout of its PE sections, and which of those sections are marked executable and how large they are on disk.

ఉదాహరణకు, స్ట్రింగ్ ఫీచర్‌లు తరచుగా ప్రోగ్రామ్ చేసిన ఫంక్షన్ కాల్‌లు మరియు నెట్‌వర్క్ ప్రసారాలను సంగ్రహించడంలో మంచి పని చేస్తాయి, “GET %s” ఉదాహరణ వలె, PE హెడర్ ఫీచర్‌లు ప్రోగ్రామ్ బైనరీ యొక్క కంపైల్ సమయం, దాని PE విభాగాల లేఅవుట్ మరియు ఆ విభాగాలలో ఏది అమలు చేయదగినదిగా గుర్తించబడింది మరియు అవి డిస్క్‌లో ఎంత పెద్దవిగా ఉన్నాయో వంటి సమాచారాన్ని సంగ్రహిస్తాయి.


Even when you’re dealing with packed binaries, PE header features can still do a decent job of distinguishing packed malware from packed benignware.

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


The Import Address Table (IAT), which you learned about in Chapter 1, is also an important source of machine learning features.

మీరు అధ్యాయం 1లో నేర్చుకున్న ఇంపోర్ట్ అడ్రస్ టేబుల్ (IAT) కూడా మెషిన్ లెర్నింగ్ ఫీచర్లకు ఒక ముఖ్యమైన మూలం.


To use the IAT as a source of machine learning features, you need to represent each file as a dictionary of features, where the name of the imported library and function is the key, and the key maps to a 1, which indicates that the file in question contains that specific import.

మెషిన్ లెర్నింగ్ ఫీచర్ల మూలంగా IATని ఉపయోగించడానికి, మీరు ప్రతి ఫైల్‌ను ఫీచర్ల నిఘంటువుగా సూచించాలి, ఇక్కడ దిగుమతి చేసుకున్న లైబ్రరీ మరియు ఫంక్షన్ పేరు కీ, మరియు కీ 1కి మ్యాప్ చేస్తుంది, ఇది ప్రశ్నలోని ఫైల్ ఆ నిర్దిష్ట దిగుమతిని కలిగి ఉందని సూచిస్తుంది.


In my experience building malware detectors, I have found that IAT features rarely work well on their own—although these features capture useful high-level information about program behavior, the malware often obfuscates the IAT to make itself look like benignware.

మాల్వేర్ డిటెక్టర్లను రూపొందించడంలో నా అనుభవంలో, IAT ఫీచర్‌లు చాలా అరుదుగా బాగా పనిచేస్తాయని నేను కనుగొన్నాను—ఈ ఫీచర్‌లు ప్రోగ్రామ్ ప్రవర్తన గురించి ఉపయోగకరమైన ఉన్నత స్థాయి సమాచారాన్ని సంగ్రహించినప్పటికీ, మాల్వేర్ తరచుగా IATని అస్పష్టం చేస్తుంది, ఇది సాధారణ సాఫ్ట్‌వేర్‌లా కనిపించేలా చేస్తుంది.


N-grams sound more exotic than they are: they just involve laying out your features in the sequence in which they occur and then sliding a window of length n over the sequence, treating the sequence of features inside the window at each step as a single, aggregate feature.

N-గ్రామ్‌లు ఉన్నదాని కంటే మరింత విచిత్రంగా అనిపిస్తాయి: అవి మీ ఫీచర్లను అవి సంభవించే క్రమంలో ఉంచడం మరియు ఆపై క్రమంపై n పొడవు గల విండోను జారడం, ప్రతి దశలో విండో లోపల ఉన్న ఫీచర్ల క్రమాన్ని ఒకే, మొత్తం ఫీచర్‌గా పరిగణిస్తాయి.


I recommend experimenting with N-gram features in your machine learning–based malware detection systems whenever you’re working with data that occurs in some type of sequence.

మీరు ఏదైనా రకమైన సీక్వెన్స్‌లో సంభవించే డేటాతో పని చేస్తున్నప్పుడు, మీ మెషిన్ లెర్నింగ్ ఆధారిత మాల్వేర్ డిటెక్షన్ సిస్టమ్‌లలో N-గ్రామ్ ఫీచర్లతో ప్రయోగాలు చేయమని నేను సిఫార్సు చేస్తున్నాను.


First, extracting all the features we just explored takes a long time, which compromises how quickly your system can scan files.

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


This is why when building your systems, I recommend trying different features and honing in on those that work well on the kinds of malware you’re trying to detect (and the kinds of benignware you’re trying to avoid generating false positives on).

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


To get around the problem of having too many features, you can use a popular and straightforward solution called the hashing trick, also known as feature hashing.

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


The results show some interesting trends.

ఫలితాలు కొన్ని ఆసక్తికరమైన పోకడలను చూపుతున్నాయి.


For example, ransomware is almost always detected by more than 30 scanners.

ఉదాహరణకు, రాన్సమ్‌వేర్‌ను దాదాపు ఎల్లప్పుడూ 30 కంటే ఎక్కువ స్కానర్‌లు గుర్తిస్తాయి.


Listing 9-15 shows how to create the plot shown in Figure 9-10.

జాబితా 9-15, చిత్రం 9-10లో చూపిన ప్లాట్‌ను ఎలా తయారు చేయాలో చూపిస్తుంది.


In this chapter, you learned how visualization of malware data allows you to get macroscopic insights into trending threats and the efficacy of security tools.

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


Deep learning is a type of machine learning that has advanced rapidly in the past few years.

డీప్ లెర్నింగ్ అనేది ఒక రకమైన మెషిన్ లెర్నింగ్, ఇది గత కొన్ని సంవత్సరాలలో వేగంగా అభివృద్ధి చెందింది.


For example, detecting whether a file contains an exact copy of some malicious code you’ve seen before is simple for a computer program.

ఉదాహరణకు, మీరు ఇంతకు ముందు చూసిన కొన్ని హానికరమైన కోడ్‌ల యొక్క ఖచ్చితమైన కాపీని ఫైల్ కలిగి ఉందో లేదో గుర్తించడం కంప్యూటర్ ప్రోగ్రామ్‌కు సులభం.


Traditional signature-based detection schemes are rigid and perform poorly on never-before-seen or obfuscated malware.

సాంప్రదాయ సిగ్నేచర్-ఆధారిత గుర్తింపు పథకాలు దృఢంగా ఉంటాయి మరియు ఇంతకు ముందు చూడని లేదా అస్పష్టమైన మాల్వేర్‌పై సరిగ్గా పని చేయవు.


This ability to pick out useful characteristics within a mass of noise makes deep learning an extremely powerful tool for cybersecurity applications.

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


If you’re interested in working at the cutting edge of security data science, it’s essential to learn how to use deep learning.

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


Deep learning models learn to view their training data as a nested hierarchy of concepts.

డీప్ లెర్నింగ్ నమూనాలు వారి శిక్షణ డేటాను భావనల యొక్క నెస్టెడ్ శ్రేణిగా చూడటానికి నేర్చుకుంటాయి.


In other words, these models not only take into consideration the original features you give them, but automatically combine these features to form new, optimized meta-features.

మరో మాటలో చెప్పాలంటే, ఈ నమూనాలు మీరు వారికి అందించే అసలు లక్షణాలను మాత్రమే పరిగణనలోకి తీసుకోవు, కానీ కొత్త, ఆప్టిమైజ్ చేయబడిన మెటా-ఫీచర్లను రూపొందించడానికి ఈ లక్షణాలను స్వయంచాలకంగా మిళితం చేస్తాయి.


Deep” also refers to the architecture used to accomplish this, which usually consists of multiple layers of processing units.

దీనిని సాధించడానికి ఉపయోగించే ఆర్కిటెక్చర్‌ను కూడా “డీప్” సూచిస్తుంది, ఇది సాధారణంగా బహుళ లేయర్‌ల ప్రాసెసింగ్ యూనిట్‌లను కలిగి ఉంటుంది.


For a human, this is an easy task, but programming a computer to look at a grid of pixels and tell which object it represents is quite difficult.

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


Deep learning models get past this by breaking the problem down into more manageable pieces.

సమస్యను మరింత నిర్వహించదగిన ముక్కలుగా విభజించడం ద్వారా డీప్ లెర్నింగ్ నమూనాలు దీనిని అధిగమిస్తాయి.


In our unicycle example, the first layer might find lines, the second might see lines forming circles, and the third might identify that certain circles are actually wheels.

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


In this chapter, we focus on how neural networks actually work, both mathematically and structurally.

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


Machine learning models are simply big mathematical functions.

మెషిన్ లెర్నింగ్ నమూనాలు కేవలం పెద్ద గణిత విధులు.


Every machine learning model is just a function containing adjustable parameters that get optimized during the training process.

ప్రతి మెషిన్ లెర్నింగ్ నమూనా అనేది శిక్షణ ప్రక్రియలో ఆప్టిమైజ్ చేయబడే సర్దుబాటు చేయగల పారామితులను కలిగి ఉన్న ఒక ఫంక్షన్ మాత్రమే.


Neurons themselves are just a type of small, simple function.

న్యూరాన్‌లు కూడా ఒక చిన్న, సాధారణ ఫంక్షన్ మాత్రమే.


The value of the output is a function of the neuron’s input data and some parameters.

అవుట్‌పుట్ విలువ న్యూరాన్ యొక్క ఇన్‌పుట్ డేటా మరియు కొన్ని పారామితుల ఫంక్షన్.


Neural networks with multiple layers and automatic feature generation allow us to offload a lot of that work.

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


In short, automatic feature generation happens, which is perhaps an even more powerful aspect of neural networks.

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


For an HTML file, a lot of time would be spent deciding what numeric aspects of an HTML file might aid the model.

HTML ఫైల్ కోసం, HTML ఫైల్ యొక్క ఏ సంఖ్యా అంశాలు మోడల్‌కు సహాయపడతాయో నిర్ణయించడానికి చాలా సమయం పడుతుంది.


In other words, a neural network will learn to count the number of times the letter a shows up in an HTML document.

అంటే, ఒక న్యూరల్ నెట్‌వర్క్ HTML డాక్యుమెంట్‌లో 'a' అక్షరం ఎన్నిసార్లు కనిపిస్తుందో లెక్కించడం నేర్చుకుంటుంది.


In our image-processing bicycle example, nobody specifically told the network that edges or wheel meta-features were useful.

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


The model learned that those features were useful as inputs to the next neuron layer during the training process.

ఆ లక్షణాలు శిక్షణ సమయంలో తదుపరి న్యూరాన్ లేయర్‌కు ఇన్‌పుట్‌లుగా ఉపయోగపడతాయని మోడల్ నేర్చుకుంది.


What’s especially useful is that these lower-level learned features can be used in different ways by later layers.

ముఖ్యంగా ఉపయోగకరమైనది ఏమిటంటే, ఈ దిగువ-స్థాయిలో నేర్చుకున్న లక్షణాలను తరువాత లేయర్‌ల ద్వారా వివిధ మార్గాల్లో ఉపయోగించవచ్చు.


Not only do neural networks perform a lot of the feature extraction work that previously took a lot of time and effort, they do it in an optimized and space-efficient way.

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


Training requires optimizing parameters to minimize an objective function.

ఒక లక్ష్య ఫంక్షన్‌ను తగ్గించడానికి పారామితులను ఆప్టిమైజ్ చేయడం శిక్షణకు అవసరం.


In supervised learning, where we’re trying to train our model to be able to predict a label, like 0 for “benign” and 1 for “malware,” that objective function is going to be related to the network’s prediction error during training.

సూపర్వైజ్డ్ లెర్నింగ్‌లో, మేము మా మోడల్‌ను శిక్షణ ఇవ్వడానికి ప్రయత్నిస్తున్నాము, తద్వారా “నిరపాయమైన” కోసం 0 మరియు “మాల్వేర్” కోసం 1 వంటి లేబుల్‌ను అంచనా వేయవచ్చు, ఆ లక్ష్య ఫంక్షన్ శిక్షణ సమయంలో నెట్‌వర్క్ యొక్క అంచనా లోపానికి సంబంధించినది.


You can think of the error as the difference between the predicted label ŷ and the known, true label y, where network (x) = ŷ, and the network is trying to approximate some unknown function f, such that f(x) = y.

మీరు లోపాన్ని అంచనా వేసిన లేబుల్ ŷ మరియు తెలిసిన, నిజమైన లేబుల్ y మధ్య వ్యత్యాసంగా భావించవచ్చు, ఇక్కడ నెట్‌వర్క్ (x) = ŷ, మరియు నెట్‌వర్క్ f అనే తెలియని ఫంక్షన్‌ను సుమారుగా అంచనా వేయడానికి ప్రయత్నిస్తుంది, తద్వారా f(x) = y.


The basic idea behind training networks is to feed a network an observation, x, from your training dataset, receive some output, ŷ , and then figure out how changing your parameters will shift ŷ closer to your goal, y.

నెట్‌వర్క్‌లకు శిక్షణ ఇవ్వడానికి సంబంధించిన ప్రాథమిక ఆలోచన ఏమిటంటే, మీ శిక్షణ డేటాసెట్ నుండి ఒక పరిశీలన, x, నెట్‌వర్క్‌కు అందించడం, కొంత అవుట్‌పుట్, ŷని స్వీకరించడం, ఆపై మీ పారామితులను మార్చడం ఎలా ŷని మీ లక్ష్యం, yకి దగ్గరగా మారుస్తుందో తెలుసుకోవడం.


Imagine you’re in a spaceship with various knobs.

మీరు వివిధ నాబ్‌లతో కూడిన స్పేస్‌షిప్‌లో ఉన్నారని ఊహించుకోండి.


ఒక న్యూరల్ నెట్‌వర్క్‌కు శిక్షణ ఇవ్వడం కూడా అంతే.


This step is called forward propagation because you feed your input x forward through the network to get your final output ŷ .

ఈ దశను ఫార్వర్డ్ ప్రొపగేషన్ అంటారు, ఎందుకంటే మీరు మీ ఇన్‌పుట్ xని నెట్‌వర్క్ ద్వారా ముందుకు పంపిస్తారు, మీ తుది అవుట్‌పుట్ ŷని పొందడానికి.


Next, you determine how each parameter affects your output ŷ .

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


This is called the partial derivative of ŷ with respect to w, or ∂ŷ/∂w.

దీనిని wకి సంబంధించి ŷ యొక్క పాక్షిక ఉత్పన్నం అంటారు, లేదా ∂ŷ/∂w.


Parameters all throughout the network are then nudged just a tiny bit in a direction that causes ŷ to shift a little closer to y.

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


If ∂ŷ/∂w is positive, then you know you should increase w by a small amount.

ఒకవేళ ∂ŷ/∂w సానుకూలంగా ఉంటే, మీరు wని కొద్దిగా పెంచాలని మీకు తెలుసు.


In other words, you teach your network to approximate the unknown function f by correcting its mistakes on training data with known labels.

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


Keras provides a simple, flexible interface to define all this.

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


When designing a model, you need three things: input, stuff in the middle that processes the input, and output.

ఒక నమూనాను రూపొందించేటప్పుడు, మీకు మూడు విషయాలు అవసరం: ఇన్‌పుట్, ఇన్‌పుట్‌ను ప్రాసెస్ చేసే మధ్యలో ఉన్న అంశాలు మరియు అవుట్‌పుట్.


Sometimes your models will have multiple inputs, multiple outputs, and very complex stuff in the middle.

కొన్నిసార్లు మీ నమూనాలకు బహుళ ఇన్‌పుట్‌లు, బహుళ అవుట్‌పుట్‌లు మరియు మధ్యలో చాలా సంక్లిష్టమైన అంశాలు ఉంటాయి.


To define this architecture, Keras uses layers.

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


A layer is a group of neurons that all use the same type of activation function.

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


In a neural network, input data is generally fed to an initial layer of neurons.

ఒక న్యూరల్ నెట్‌వర్క్‌లో, ఇన్‌పుట్ డేటా సాధారణంగా న్యూరాన్‌ల ప్రారంభ లేయర్‌కు అందించబడుతుంది.


Listing 11-1 is an example of a simple model defined using Keras’s functional API syntax.

జాబితా 11-1 కెరాస్ యొక్క ఫంక్షనల్ API సింటాక్స్ ఉపయోగించి నిర్వచించబడిన ఒక సాధారణ నమూనాకు ఉదాహరణ.


I encourage you to open a new Python file to write and run the code yourself.

మీరు కోడ్‌ను మీరే వ్రాయడానికి మరియు అమలు చేయడానికి కొత్త పైథాన్ ఫైల్‌ను తెరవమని నేను మిమ్మల్ని ప్రోత్సహిస్తున్నాను.


Here, we declared that the input data to our model will be an array of 1,024 floats.

ఇక్కడ, మా నమూనాకు ఇన్‌పుట్ డేటా 1,024 ఫ్లోట్‌ల శ్రేణి అని మేము ప్రకటించాము.


If our input was, for example, a matrix of integers instead, the first line would look more like input = Input(shape=(100, 100,) dtype=‘int32’)

ఉదాహరణకు, మా ఇన్‌పుట్ బదులుగా పూర్ణాంకాల మాతృక అయితే, మొదటి లైన్ ఇలా కనిపిస్తుంది: input = Input(shape=(100, 100,) dtype=‘int32’)


Dense is the most common type of layer you’ll likely use when developing Keras models.

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


We pass the Dense function two arguments: units=512, to specify that we want 512 neurons in this layer, and activation=‘relu’.

మేము డెన్స్ ఫంక్షన్‌కు రెండు వాదనలను పంపుతాము: units=512, ఈ లేయర్‌లో 512 న్యూరాన్‌లను కోరుకుంటున్నామని పేర్కొనడానికి మరియు activation=‘relu’.


In the next line, we define our model’s output layer, which again uses the Dense function.

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


Now that we’ve defined our layers, we use the Model class from the models submodule to wrap up all these layers together as a model.

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


We’ve defined the model’s architecture and flow of data, but we haven’t yet specified how we want the model to perform its training.

మేము నమూనా యొక్క ఆర్కిటెక్చర్ మరియు డేటా ప్రవాహాన్ని నిర్వచించాము, కాని నమూనా దాని శిక్షణను ఎలా నిర్వహించాలనుకుంటున్నామో మేము ఇంకా పేర్కొనలేదు.


The first parameter, optimizer, specifies the type of backpropagation algorithm to use.

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


You can specify the name of the algorithm you wish to use via a character string like we did here, or you can import an algorithm directly from keras.optimizers.

మీరు ఇక్కడ చేసినట్లుగా, మీరు ఉపయోగించాలనుకుంటున్న అల్గారిథం పేరును అక్షర స్ట్రింగ్ ద్వారా పేర్కొనవచ్చు లేదా మీరు నేరుగా keras.optimizers నుండి ఒక అల్గారిథమ్‌ను దిగుమతి చేసుకోవచ్చు.


After running the code in Listing 11-1, run model.summary() to see the model structure printed to your screen.

జాబితా 11-1లోని కోడ్‌ను అమలు చేసిన తర్వాత, మీ స్క్రీన్‌పై ముద్రించబడిన నమూనా నిర్మాణాన్ని చూడటానికి model.summary()ని అమలు చేయండి.


Each layer’s description is printed to the screen, along with the number of parameters associated with that layer.

ప్రతి లేయర్ యొక్క వివరణ ఆ లేయర్‌తో అనుబంధించబడిన పరామితుల సంఖ్యతో పాటు స్క్రీన్‌పై ముద్రించబడుతుంది.


Although we haven’t yet trained our model or tested it on validation data, this is a compiled Keras model that is ready to train!

మేము ఇంకా మా నమూనాకు శిక్షణ ఇవ్వనప్పటికీ లేదా ధృవీకరణ డేటాపై పరీక్షించనప్పటికీ, ఇది శిక్షణకు సిద్ధంగా ఉన్న కంపైల్ చేయబడిన కెరాస్ నమూనా!


This code ensures that the model is overwritten to a single file.

ఈ కోడ్ మోడల్ ఒకే ఫైల్‌కు తిరిగి రాయబడిందని నిర్ధారిస్తుంది.


We can use the code in Listing 11-12 to save the model after every epoch.

ప్రతి యుగంలోనూ మోడల్‌ను సేవ్ చేయడానికి మనం జాబితా 11-12లోని కోడ్‌ను ఉపయోగించవచ్చు.


Instead of only saving the single “best” version of our model, Listing 11-12’s callback saves each epoch’s version.

మా మోడల్ యొక్క ఒకే “ఉత్తమ” వెర్షన్‌ను మాత్రమే సేవ్ చేయడానికి బదులుగా, జాబితా 11-12 యొక్క కాల్‌బ్యాక్ ప్రతి యుగం యొక్క వెర్షన్‌ను సేవ్ చేస్తుంది.


To create a custom Keras callback, we need to create a class that inherits from keras.callbacks.Callback.

అనుకూల కెరాస్ కాల్‌బ్యాక్‌ను రూపొందించడానికి, మనం keras.callbacks.Callback నుండి వారసత్వంగా వచ్చే ఒక తరగతిని సృష్టించాలి.


We can add one or more of a selection of methods, which will be run automatically during training.

శిక్షణ సమయంలో స్వయంచాలకంగా అమలు చేయబడే పద్ధతుల ఎంపికలో ఒకదాన్ని లేదా అంతకంటే ఎక్కువ వాటిని మనం జోడించవచ్చు.


Listing 11-13 shows how to create a callback that calculates and prints validation AUC to the screen.

ధ్రువీకరణ AUCని స్క్రీన్‌కు ఎలా లెక్కించాలో మరియు ప్రింట్ చేయాలో జాబితా 11-13 చూపిస్తుంది.


In this example, we first create our MyCallback class.

ఈ ఉదాహరణలో, మేము మొదట మా MyCallback తరగతిని సృష్టిస్తాము.


We grab the validation_data, which is already stored in the self object.

మేము ధ్రువీకరణ_డేటాను తీసుకుంటాము, ఇది ఇప్పటికే స్వీయ వస్తువులో నిల్వ చేయబడింది.


Finally, we tell the model to train and specify our new callback.

చివరగా, మేము మోడల్‌ను శిక్షణ ఇవ్వమని చెబుతాము మరియు మా కొత్త కాల్‌బ్యాక్‌ను పేర్కొంటాము.


The result should look something like Figure 11-6.

ఫలితం చిత్రం 11-6 వలె కనిపిస్తుంది.


If what you really care about is minimizing validation AUC, this callback makes it easy to see how your model is doing.

మీరు నిజంగా దేని గురించి శ్రద్ధ వహిస్తున్నారో అది ధ్రువీకరణ AUCని తగ్గించడం అయితే, ఈ కాల్‌బ్యాక్ మీ మోడల్ ఎలా పని చేస్తుందో చూడటం సులభం చేస్తుంది.


In this chapter, you learned how to build your own neural network using Keras.

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


You also learned to train, evaluate, save, and load it.

మీరు దానిని శిక్షణ ఇవ్వడం, మూల్యాంకనం చేయడం, సేవ్ చేయడం మరియు లోడ్ చేయడం కూడా నేర్చుకున్నారు.


You then learned how to enhance the model training process by adding built-in and custom callbacks.

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


I encourage you to play around with the code accompanying this book.

ఈ పుస్తకంతో పాటు వచ్చే కోడ్‌తో ఆడమని నేను మిమ్మల్ని ప్రోత్సహిస్తున్నాను.


This chapter is meant to get your feet wet, but is not meant as a reference guide.

ఈ అధ్యాయం మీ అడుగులు తడపడానికి ఉద్దేశించబడింది, కానీ ఇది సూచన మార్గదర్శిగా ఉద్దేశించబడలేదు.


Visit https://keras.io for the most up-to-date official documentation.

తాజా అధికారిక డాక్యుమెంటేషన్ కోసం https://keras.io ని సందర్శించండి.


I strongly encourage you to spend time researching aspects of Keras that interest you.

మీకు ఆసక్తి కలిగించే కెరాస్ అంశాలపై సమయం కేటాయించి పరిశోధించాలని నేను గట్టిగా ప్రోత్సహిస్తున్నాను.


Hopefully, this chapter has served as a good jumping-off point for all your security deep learning adventures!

ఈ అధ్యాయం మీ భద్రతా లోతైన అభ్యాస సాహసాలన్నింటికీ మంచి ప్రారంభ బిందువుగా ఉపయోగపడిందని ఆశిస్తున్నాను!


Although this is a nontechnical chapter, it’s just as important as the technical chapters in this book, if not more important.

ఇది సాంకేతికేతర అధ్యాయం అయినప్పటికీ, ఈ పుస్తకంలోని సాంకేతిక అధ్యాయాల వలె ఇది కూడా అంతే ముఖ్యం, లేదా అంతకంటే ఎక్కువ.


Using pefile, 5–7 entry point, 3 file structure, 2–5.

pefile ను ఉపయోగించి, 5–7 ఎంట్రీ పాయింట్, 3 ఫైల్ నిర్మాణం, 2–5.


ప్రోగ్రామ్ స్టాక్ నిర్వచించబడింది.


రివర్స్ ఇంజనీరింగ్ పద్ధతులు ఉపయోగించబడతాయి.


రాన్సమ్‌వేర్ ఒక తీవ్రమైన ముప్పు.


The .rdata section is in PE file format.

.rdata విభాగం PE ఫైల్ ఫార్మాట్‌లో ఉంది.


ROC వక్రాలను విశ్లేషణ కోసం ఉపయోగిస్తారు.


భద్రతా డేటా శాస్త్రవేత్తలు ముఖ్యమైనవారు.


షేర్డ్ కోడ్ విశ్లేషణ ఒక సాంకేతికత.


సామ్యత మాతృకలను ఉపయోగిస్తారు.


Shared image relationship networks are analyzed.

షేర్డ్ ఇమేజ్ రిలేషన్షిప్ నెట్‌వర్క్‌లను విశ్లేషిస్తారు.


Static malware analysis has limitations.

స్థిరమైన మాల్వేర్ విశ్లేషణకు పరిమితులు ఉన్నాయి.


The importance of visualization is highlighted.

దృశ్యీకరణ యొక్క ప్రాముఖ్యతను హైలైట్ చేశారు.


Building random forest–based detectors is a key task.

రాండమ్ ఫారెస్ట్ ఆధారిత డిటెక్టర్లను నిర్మించడం ఒక ముఖ్యమైన పని.


The workflow of security data scientists is described.

భద్రతా డేటా శాస్త్రవేత్తల పని విధానం వివరించబడింది.


The Jaccard index is used in shared code analysis.

షేర్డ్ కోడ్ విశ్లేషణలో జాకార్డ్ సూచికను ఉపయోగిస్తారు.


Dynamic analysis is used for reverse engineering.

రివర్స్ ఇంజనీరింగ్ కోసం డైనమిక్ విశ్లేషణను ఉపయోగిస్తారు.


The challenges of malware network analysis are discussed.

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


Deep neural network–based detection systems are implemented.

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


The relationship between true and false positive rates is crucial.

నిజమైన మరియు తప్పుడు సానుకూల రేట్ల మధ్య సంబంధం చాలా కీలకం.


భద్రత ఒక పెద్ద డేటా సమస్యగా మారింది.


The tool extracts hostnames from target malware files and then shows connections between the files based on common hostnames.

ఈ సాధనం లక్ష్యంగా ఉన్న మాల్వేర్ ఫైల్స్ నుండి హోస్ట్ పేర్లను సంగ్రహిస్తుంది, ఆపై సాధారణ హోస్ట్ పేర్ల ఆధారంగా ఫైల్స్ మధ్య కనెక్షన్లను చూపుతుంది.


To install the requirements for this tool, run the command run bash install_requirements.sh in the ch4/code directory.

ఈ సాధనం కోసం అవసరమైన వాటిని వ్యవస్థాపించడానికి, ch4/code డైరెక్టరీలో run bash install_requirements.sh అనే ఆదేశాన్ని అమలు చేయండి.


The parameter target_path is the path to the directory of malware samples you’d like to analyze.

target_path పరామితి మీరు విశ్లేషించాలనుకుంటున్న మాల్వేర్ నమూనాల డైరెక్టరీకి మార్గం.


The output_file parameter is a path to the file where the program will write a GraphViz .dot file representing the network that links malware samples to the hostnames they contain.

output_file పరామితి అనేది ప్రోగ్రామ్ మాల్వేర్ నమూనాలను వాటిలో ఉన్న హోస్ట్ పేర్లకు లింక్ చేసే నెట్‌వర్క్‌ను సూచించే GraphViz .dot ఫైల్‌ను వ్రాసే ఫైల్‌కు మార్గం.


Once you’ve run the program, you can use the GraphViz suite discussed in Chapters 4 and 5 to visualize the networks.

మీరు ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత, నెట్‌వర్క్‌లను దృశ్యమానం చేయడానికి అధ్యాయాలు 4 మరియు 5లో చర్చించిన GraphViz సూట్‌ను ఉపయోగించవచ్చు.


This program shows network relationships between malware samples based on embedded images they share.

ఈ ప్రోగ్రామ్ మాల్వేర్ నమూనాల మధ్య వారు భాగస్వామ్యం చేసే పొందుపరిచిన చిత్రాల ఆధారంగా నెట్‌వర్క్ సంబంధాలను చూపుతుంది.


Much like in the shared hostname program, here target_path is the path to the directory of malware samples you’d like to analyze, and output_file is a path to the file where the program will write a GraphViz .dot file representing the bipartite graph that links malware samples to the images they contain.

షేర్డ్ హోస్ట్ పేరు ప్రోగ్రామ్‌లో వలె, ఇక్కడ target_path అనేది మీరు విశ్లేషించాలనుకుంటున్న మాల్వేర్ నమూనాల డైరెక్టరీకి మార్గం, మరియు output_file అనేది ప్రోగ్రామ్ మాల్వేర్ నమూనాలను కలిగి ఉన్న చిత్రాలకు లింక్ చేసే బైపార్టైట్ గ్రాఫ్‌ను సూచించే GraphViz .dot ఫైల్‌ను వ్రాసే ఫైల్‌కు మార్గం.


In Chapter 5, we discuss malware similarity and shared code analysis and visualization.

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


This tool takes a directory containing malware as its input and then visualizes shared code relationships between the malware samples in the directory.

ఈ సాధనం మాల్వేర్‌ను కలిగి ఉన్న డైరెక్టరీని ఇన్‌పుట్‌గా తీసుకుంటుంది, ఆపై డైరెక్టరీలోని మాల్వేర్ నమూనాల మధ్య షేర్డ్ కోడ్ సంబంధాలను దృశ్యమానం చేస్తుంది.


When you run this shared code analysis tool from the command line, you need to pass in two command line arguments: target_directory ➊ and output_dot_file ➋.

మీరు కమాండ్ లైన్ నుండి ఈ షేర్డ్ కోడ్ విశ్లేషణ సాధనాన్ని అమలు చేసినప్పుడు, మీరు రెండు కమాండ్ లైన్ వాదనలను పాస్ చేయాలి: target_directory ➊ మరియు output_dot_file ➋.


You can use the optional argument, jaccard_index_threshold ➌, to set the threshold the program uses with the Jaccard index similarity between two samples to determine whether or not to create an edge between those samples.

రెండు నమూనాల మధ్య జాకార్డ్ సూచిక సారూప్యతతో ప్రోగ్రామ్ ఉపయోగించే పరిమితిని సెట్ చేయడానికి మీరు ఐచ్ఛిక వాదన, jaccard_index_threshold ➌ని ఉపయోగించవచ్చు, ఆ నమూనాల మధ్య అంచుని సృష్టించాలా వద్దా అని నిర్ణయించడానికి.


The second code-sharing estimation tool we provide in Chapter 5 is given in ch5/code/listing_5_2.py.

అధ్యాయం 5లో మేము అందించే రెండవ కోడ్-షేరింగ్ అంచనా సాధనం ch5/code/listing_5_2.pyలో ఇవ్వబడింది.


This tool allows you to index thousands of samples in a database and then perform a similarity search on them with a query malware sample, which lets you find malware samples that likely share code with that sample.

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


The first mode, LOAD ➊, loads malware into the similarity search database and takes a path as its parameter, which should point to a directory with malware in it.

మొదటి మోడ్, LOAD ➊, సారూప్యత శోధన డేటాబేస్‌లోకి మాల్వేర్‌ను లోడ్ చేస్తుంది మరియు దాని పరామితిగా మార్గాన్ని తీసుకుంటుంది, ఇది మాల్వేర్‌తో ఉన్న డైరెక్టరీని సూచించాలి.


The second mode, SEARCH ➋, takes the path to an individual malware file as its parameter and then searches for similar samples in the database.

రెండవ మోడ్, SEARCH ➋, దాని పరామితిగా వ్యక్తిగత మాల్వేర్ ఫైల్‌కు మార్గాన్ని తీసుకుంటుంది, ఆపై డేటాబేస్‌లో సారూప్య నమూనాల కోసం శోధిస్తుంది.


The third mode, COMMENT ➌, takes a malware sample path as its argument and then prompts you to enter a short textual comment about that sample.

మూడవ మోడ్, COMMENT ➌, మాల్వేర్ నమూనా మార్గాన్ని దాని వాదనగా తీసుకుంటుంది, ఆపై ఆ నమూనా గురించి చిన్న వచన వ్యాఖ్యను నమోదు చేయమని మిమ్మల్ని ప్రాంప్ట్ చేస్తుంది.


The fourth mode, wipe ➍, deletes all the data in the similarity search database, in case you want to start over and index a different malware dataset.

నాల్గవ మోడ్, wipe ➍, మీరు మళ్ళీ ప్రారంభించి, వేరే మాల్వేర్ డేటాసెట్‌ను సూచిక చేయాలనుకుంటే, సారూప్యత శోధన డేటాబేస్‌లోని మొత్తం డేటాను తొలగిస్తుంది.


The final tool you can use in your own malware analysis work is the machine learning malware detector used in Chapter 8, which can be found at ch8/code/complete_detector.py.

మీ స్వంత మాల్వేర్ విశ్లేషణ పనిలో మీరు ఉపయోగించగల చివరి సాధనం అధ్యాయం 8లో ఉపయోగించిన మెషిన్ లెర్నింగ్ మాల్వేర్ డిటెక్టర్, ఇది ch8/code/complete_detector.pyలో కనుగొనబడుతుంది.


This tool has three modes in which it can be run.

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


The evaluate mode ➍, tests the accuracy of the system on the data you select for training and evaluating the system.

ఎవల్యుయేట్ మోడ్ ➍, మీరు సిస్టమ్‌ను శిక్షణ మరియు మూల్యాంకనం చేయడానికి ఎంచుకున్న డేటాపై సిస్టమ్ యొక్క ఖచ్చితత్వాన్ని పరీక్షిస్తుంది.