The book discusses data science applications in malware analysis.

മാൽവെയർ വിശകലനത്തിൽ ഡാറ്റാ സയൻസിന്റെ പ്രയോഗങ്ങളെക്കുറിച്ച് പുസ്തകത്തിൽ പറയുന്നു.


ജോഷ്വ സാക്സാണ് ഈ പുസ്തകത്തിന്റെ രചയിതാവ്.


The book is about malware detection and attribution.

മാൽവെയർ കണ്ടെത്തലും, അതിന്റെ കാരണക്കാരെ കണ്ടെത്തലും ഈ പുസ്തകത്തിൽ പ്രതിപാദിക്കുന്നു.


Data science is crucial for the future of cybersecurity.

സൈബർ സുരക്ഷയുടെ ഭാവിക്കായി ഡാറ്റാ സയൻസ് അത്യാവശ്യമാണ്.


Malware is a major threat to computer systems.

കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങൾക്ക് ഒരു പ്രധാന ഭീഷണിയാണ് മാൽവെയർ.


The book covers topics like static and dynamic malware analysis.

സ്ഥിരവും, ചലനാത്മകവുമായ മാൽവെയർ വിശകലനം പോലുള്ള വിഷയങ്ങൾ പുസ്തകത്തിൽ ഉൾക്കൊള്ളുന്നു.


Machine learning is used to detect new threats.

പുതിയ ഭീഷണികൾ കണ്ടെത്താൻ മെഷീൻ ലേണിംഗ് ഉപയോഗിക്കുന്നു.


The book explains how to build machine learning detectors.

മെഷീൻ ലേണിംഗ് ഡിറ്റക്ടറുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് പുസ്തകം വിശദീകരിക്കുന്നു.


Data visualization helps in understanding malware trends.

മാൽവെയർ പ്രവണതകൾ മനസ്സിലാക്കാൻ ഡാറ്റാ വിഷ്വലൈസേഷൻ സഹായിക്കുന്നു.


Deep learning is an advanced area of machine learning.

മെഷീൻ ലേണിംഗിന്റെ ഒരു നൂതന മേഖലയാണ് ഡീപ് ലേണിംഗ്.


The book provides an overview of datasets and tools.

ഡാറ്റാ സെറ്റുകളെയും ടൂളുകളെയും കുറിച്ചുള്ള ഒരു വിവരണം പുസ്തകത്തിൽ നൽകുന്നു.


Security professionals can benefit from this book.

സുരക്ഷാ വിദഗ്ദ്ധർക്ക് ഈ പുസ്തകം പ്രയോജനകരമാകും.


The book is aimed at security professionals.

സുരക്ഷാ വിദഗ്ദ്ധരെ ലക്ഷ്യമിട്ടുള്ളതാണ് ഈ പുസ്തകം.


Understanding malware is crucial for cybersecurity.

സൈബർ സുരക്ഷയ്ക്ക് മാൽവെയറിനെക്കുറിച്ച് അറിയുന്നത് അത്യാവശ്യമാണ്.


The book discusses the Microsoft Windows Portable Executable Format.

മൈക്രോസോഫ്റ്റ് വിൻഡോസ് പോർട്ടബിൾ എക്സിക്യൂട്ടബിൾ ഫോർമാറ്റിനെക്കുറിച്ച് പുസ്തകത്തിൽ പറയുന്നു.


The authors share their expertise in the field.

ഈ മേഖലയിലെ അവരുടെ വൈദഗ്ദ്ധ്യം രചയിതാക്കൾ പങ്കുവെക്കുന്നു.


The book covers topics like x86 disassembly.

x86 ഡിസ്അസംബ്ലി പോലുള്ള വിഷയങ്ങൾ പുസ്തകത്തിൽ ഉൾപ്പെടുന്നു.


Dynamic analysis involves running malware in a controlled environment.

നിയന്ത്രിത അന്തരീക്ഷത്തിൽ മാൽവെയർ പ്രവർത്തിപ്പിക്കുന്നതാണ് ഡൈനാമിക് അനാലിസിസ്.


The book explains how to identify attack campaigns.

ആക്രമണ കാമ്പയിനുകൾ എങ്ങനെ തിരിച്ചറിയാമെന്ന് പുസ്തകം വിശദീകരിക്കുന്നു.


Data science is the technical trend of the decade.

ഈ ദശകത്തിലെ സാങ്കേതിക പ്രവണതയാണ് ഡാറ്റാ സയൻസ്.


The book provides sample code and data to help users understand the concepts.

പുസ്തകത്തിൽ, ആശയങ്ങൾ മനസ്സിലാക്കാൻ സഹായിക്കുന്ന കോഡും ഡാറ്റയും നൽകുന്നു.


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

കോഡും ഡാറ്റയും ഉപയോഗിക്കാൻ തയ്യാറായ ഒരു വെർച്വൽ മെഷീൻ നിങ്ങൾക്ക് ഡൗൺലോഡ് ചെയ്യാം.


The code is designed to work in Linux environments.

കോഡ് പ്രധാനമായും രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് Linux പരിതസ്ഥിതിയിലാണ്.


If you prefer, the code should also work on MacOS and Windows.

നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, MacOS, Windows എന്നിവയിലും ഈ കോഡ് പ്രവർത്തിക്കും.


You can download the data from the provided website.

നൽകിയിട്ടുള്ള വെബ്സൈറ്റിൽ നിന്ന് നിങ്ങൾക്ക് ഡാറ്റ ഡൗൺലോഡ് ചെയ്യാം.


Each chapter has its own directory with code and data.

ഓരോ അധ്യായത്തിനും അതിൻ്റേതായ ഡയറക്ടറിയും കോഡും ഡാറ്റയും ഉണ്ടായിരിക്കും.


Install the necessary libraries using pip.

pip ഉപയോഗിച്ച് ആവശ്യമായ ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യുക.


This chapter focuses on basic static malware analysis.

ഈ അധ്യായത്തിൽ, അടിസ്ഥാനപരമായ സ്റ്റാറ്റിക് മാൽവെയർ വിശകലനത്തെക്കുറിച്ച് പറയുന്നു.


Static analysis involves analyzing a program file without running it.

പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാതെ തന്നെ ഫയൽ വിശകലനം ചെയ്യുന്ന രീതിയാണ് സ്റ്റാറ്റിക് അനാലിസിസ്.


We will examine the Portable Executable (PE) file format.

പോർട്ടബിൾ എക്സിക്യൂട്ടബിൾ (PE) ഫയൽ ഫോർമാറ്റ് നമ്മൾ പരിശോധിക്കും.


The PE format describes how Windows loads a program into memory.

ഒരു പ്രോഗ്രാം എങ്ങനെ മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യണം എന്ന് PE ഫോർമാറ്റ് വിവരിക്കുന്നു.


PE files contain x86 instructions, data, and metadata.

PE ഫയലുകളിൽ x86 നിർദ്ദേശങ്ങളും, ഡാറ്റയും, മെറ്റാഡാറ്റയും അടങ്ങിയിരിക്കുന്നു.


The PE header provides basic information about the program.

പ്രോഗ്രാമിനെക്കുറിച്ചുള്ള അടിസ്ഥാന വിവരങ്ങൾ PE ഹെഡർ നൽകുന്നു.


The optional header defines the program's entry point.

ഓപ്ഷണൽ ഹെഡർ പ്രോഗ്രാമിന്റെ എൻട്രി പോയിന്റ് നിർവചിക്കുന്നു.


Section headers describe the data sections within a PE file.

PE ഫയലിനുള്ളിലെ ഡാറ്റാ വിഭാഗങ്ങളെക്കുറിച്ച് സെക്ഷൻ ഹെഡറുകൾ വിവരിക്കുന്നു.


.text വിഭാഗത്തിൽ x86 കോഡ് അടങ്ങിയിരിക്കുന്നു.


The .idata section contains the Import Address Table (IAT).

.idata വിഭാഗത്തിൽ ഇംപോർട്ട് അഡ്രസ്സ് ടേബിൾ (IAT) അടങ്ങിയിരിക്കുന്നു.


Data sections store resources like images and text.

ചിത്രങ്ങളും, ടെക്സ്റ്റും പോലുള്ള വിവരങ്ങൾ ഡാറ്റാ വിഭാഗങ്ങളിൽ സംഭരിക്കുന്നു.


The .reloc section allows code to be moved without breaking.

.reloc വിഭാഗം കോഡിനെ തകരാറില്ലാതെ നീക്കാൻ അനുവദിക്കുന്നു.


We will use the pefile Python module to dissect PE files.

PE ഫയലുകൾ വിശകലനം ചെയ്യാൻ നമ്മൾ pefile എന്ന Python മൊഡ്യൂൾ ഉപയോഗിക്കും.


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.

ശാരീരിക സ്പ്രിംഗുകളായി നെറ്റ്‌വർക്ക് എഡ്‌ജുകൾ അനുകരിക്കുന്നത് പലപ്പോഴും നല്ല നോഡ് സ്ഥാനനിർണ്ണയത്തിലേക്ക് നയിക്കുന്നു, കാരണം അനുകരിച്ച സ്പ്രിംഗുകൾ നോഡുകളും എഡ്‌ജുകളും തമ്മിൽ ഏകീകൃതമായ നീളം കൈവരിക്കാൻ ശ്രമിക്കുന്നു.


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

നിങ്ങൾക്ക് പൈത്തൺ അറിയാമെങ്കിൽ, NetworkX ഉപയോഗിക്കാൻ വളരെ എളുപ്പമാണെന്ന് നിങ്ങൾ കണ്ടെത്തും.


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

ഈ കണക്ഷനുകൾക്കായുള്ള ആദർശപരമായ ലേഔട്ട്, പേജിലെ എല്ലാ നോഡുകളും പരസ്പരം തുല്യ അകലത്തിൽ സ്ഥാപിക്കും.


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.

(c), (d) എന്നിവയിൽ കാണുന്നതുപോലെ, നാല്, അഞ്ച് നോഡുകളുടെ നെറ്റ്‌വർക്കുകൾ ഉണ്ടാക്കുമ്പോൾ, തുല്യമല്ലാത്ത എഡ്‌ജുകളുടെ കാരണം ക്രമേണ കൂടുതൽ വികലതകൾ ഉണ്ടാകാൻ തുടങ്ങും.


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

ഈ അധ്യായത്തിൽ നമ്മൾ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത് ഫോഴ്സ്-ഡയറക്റ്റഡ് അൽഗോരിതങ്ങളെക്കുറിച്ചാണ്.


Now that you have a basic understanding of malware networks, you’re ready to learn how to create networks of malware relationships using the open source NetworkX Python network analysis library.

മാൽവെയർ നെറ്റ്‌വർക്കുകളെക്കുറിച്ച് നിങ്ങൾക്ക് ഇപ്പോൾ ഒരു അടിസ്ഥാന ധാരണയുണ്ടായ സ്ഥിതിക്ക്, ഓപ്പൺ സോഴ്സ് NetworkX Python നെറ്റ്‌വർക്ക് അനാലിസിസ് ലൈബ്രറി ഉപയോഗിച്ച് മാൽവെയർ ബന്ധങ്ങളുടെ ശൃംഖലകൾ എങ്ങനെ ഉണ്ടാക്കാമെന്ന് പഠിക്കാൻ തയ്യാറെടുക്കാം.


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.

കമ്പ്യൂട്ടർ സയൻസിൽ രണ്ട് പദങ്ങളും പര്യായപദങ്ങളായതിനാൽ - അവ രണ്ടും എഡ്‌ജുകളുമായി ബന്ധിപ്പിച്ചിട്ടുള്ള നോഡുകളുടെ ഒരു കൂട്ടത്തെ സൂചിപ്പിക്കുന്നു - NetworkX ലൈബ്രറി ചിലപ്പോൾ നെറ്റ്‌വർക്കിനുപകരം ഗ്രാഫ് എന്ന പദം ഉപയോഗിക്കുന്നു.


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

ഒരു NetworkX നെറ്റ്‌വർക്കിലെ ഒരു നോഡ് ഏതൊരു പൈത്തൺ ഒബ്ജക്റ്റും ആകാം.


Here, we’re connecting some of these five nodes via edges.

ഇവിടെ, ഈ അഞ്ച് നോഡുകളിൽ ചിലതിനെ എഡ്‌ജുകൾ വഴി ബന്ധിപ്പിക്കുന്നു.


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

നോഡുകളിലേക്കും എഡ്‌ജുകളിലേക്കും ആട്രിബ്യൂട്ടുകൾ എളുപ്പത്തിൽ ചേർക്കാൻ NetworkX നമ്മെ അനുവദിക്കുന്നു.


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:

ഒരു നോഡിലേക്ക് ഒരു ആട്രിബ്യൂട്ട് ചേർക്കാൻ (പിന്നീട് ആ ആട്രിബ്യൂട്ട് ആക്സസ് ചെയ്യാൻ), നിങ്ങൾ നെറ്റ്‌വർക്കിലേക്ക് നോഡ് ചേർക്കുമ്പോൾ ഒരു കീവേഡ് ആർഗ്യുമെന്റായി ആട്രിബ്യൂട്ട് ചേർക്കാവുന്നതാണ്, ഇത് പോലെ:


The edge dictionary is magical in that it allows you to access node attributes the other way around, without having to worry about which node you refer to first.

ഏത് നോഡിനെയാണ് ആദ്യം പരാമർശിക്കുന്നതെന്നതിനെക്കുറിച്ച് വേവലാതിപ്പെടാതെ തന്നെ, നേരെ എതിർദിശയിൽ നോഡ് ആട്രിബ്യൂട്ടുകൾ ആക്സസ് ചെയ്യാൻ എഡ്ജ് നിഘണ്ടു നിങ്ങളെ സഹായിക്കുന്നു.


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.

ഞങ്ങളുടെ നെറ്റ്‌വർക്കുകൾ ദൃശ്യവൽക്കരിക്കുന്നതിന്, .dot ഫോർമാറ്റിൽ NetworkX-ൽ നിന്ന് അവ ഡിസ്കിലേക്ക് സേവ് ചെയ്യേണ്ടതുണ്ട് - നെറ്റ്‌വർക്ക് വിശകലന ലോകത്ത് സാധാരണയായി ഉപയോഗിക്കുന്നതും നിരവധി നെറ്റ്‌വർക്ക് വിഷ്വലൈസേഷൻ ടൂൾകിറ്റുകളിലേക്ക് ഇറക്കുമതി ചെയ്യാവുന്നതുമായ ഒരു ഫോർമാറ്റാണിത്.


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

നിങ്ങളുടെ നെറ്റ്‌വർക്കുകൾ ദൃശ്യവൽക്കരിക്കുന്നതിനുള്ള ഏറ്റവും മികച്ച കമാൻഡ് ലൈൻ പാക്കേജാണ് GraphViz.


It’s supported by researchers at AT&T and has become a standard part of the network analysis toolbox used by data analysts.

AT&T-യിലെ ഗവേഷകർ ഇതിനെ പിന്തുണയ്ക്കുകയും ഡാറ്റാ അനലിസ്റ്റുകൾ ഉപയോഗിക്കുന്ന നെറ്റ്‌വർക്ക് അനാലിസിസ് ടൂൾബോക്സിന്റെ ഒരു സാധാരണ ഭാഗമായി ഇത് മാറിയിരിക്കുകയാണ്.


Each GraphViz command line tool ingests networks expressed in .dot format and can be invoked using the following syntax to render a network as a .png file:

.dot ഫോർമാറ്റിൽ എക്സ്പ്രസ് ചെയ്ത നെറ്റ്‌വർക്കുകൾ ഓരോ GraphViz കമാൻഡ് ലൈൻ ടൂളും സ്വീകരിക്കുന്നു, കൂടാതെ ഒരു .png ഫയലായി ഒരു നെറ്റ്‌വർക്ക് റെൻഡർ ചെയ്യാൻ താഴെ പറയുന്ന ശൈലി ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കാനാകും:


The fdp force-directed graph renderer is one GraphViz network visualization tool.

fdp ഫോഴ്സ്-ഡയറക്റ്റഡ് ഗ്രാഫ് റെൻഡറർ ഒരു GraphViz നെറ്റ്‌വർക്ക് വിഷ്വലൈസേഷൻ ഉപകരണമാണ്.


When you’re creating malware networks with fewer than 500 nodes, fdp does a good job of revealing network structure in a reasonable amount of time.

500-ൽ കുറഞ്ഞ നോഡുകളുള്ള മാൽവെയർ നെറ്റ്‌വർക്കുകൾ ഉണ്ടാക്കുമ്പോൾ, ന്യായമായ സമയത്തിനുള്ളിൽ നെറ്റ്‌വർക്ക് ഘടന വെളിപ്പെടുത്തുന്നതിൽ fdp മികച്ച പ്രകടനം കാഴ്ചവെക്കുന്നു.


The sfdp tool uses roughly the same approach to layout as fdp, but it scales better because it creates a hierarchy of simplifications, known as coarsenings, where nodes are merged into supernodes based on their proximity.

sfdp ടൂൾ fdp-യുടെ അതേ സമീപനമാണ് ലേഔട്ടിനായി ഉപയോഗിക്കുന്നത്, എന്നാൽ ഇത് നന്നായി സ്കെയിൽ ചെയ്യുന്നു, കാരണം ഇത് ലളിതവൽക്കരണങ്ങളുടെ ഒരു ശ്രേണി ഉണ്ടാക്കുന്നു, ഇത് കോർസെനിംഗ്സ് എന്നറിയപ്പെടുന്നു, ഇവിടെ നോഡുകൾ അവയുടെ സാമീപ്യത്തെ അടിസ്ഥാനമാക്കി സൂപ്പർനോഡുകളായി ലയിപ്പിക്കുന്നു.


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 Pro പോലുള്ള വ്യാവസായിക നിലവാരത്തിലുള്ള ഡിസ്അസംബ്ലർമാർ ഉപയോഗിക്കുന്ന കൂടുതൽ സങ്കീർണ്ണമായ ഡിസ്അസംബ്ലിംഗ് രീതികളാണ്.


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.

ഈ പുസ്തകത്തിൽ ഞാൻ Intel സിന്റാക്സ് ഉപയോഗിക്കുന്നു, ഇത് എല്ലാ പ്രധാന ഡിസ്അസംബ്ലറുകളിൽ നിന്നും ലഭിക്കും, കൂടാതെ x86 CPU-യുടെ ഔദ്യോഗിക Intel ഡോക്യുമെന്റേഷനിൽ ഉപയോഗിക്കുന്ന ശൈലിയും ഇതാണ്.


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.

ഇത്തരം ആന്റി-അനാലിസിസ്, ആന്റി-ഡിറ്റക്ഷൻ ടെക്നിക്കുകൾ വളരെ ശക്തമാണ്, മാത്രമല്ല അവ ഒഴിവാക്കാനുള്ള ഒരേയൊരു മാർഗ്ഗം, ബാഹ്യ സെർവറുകളിലെ കോഡ്, ഡാറ്റ അല്ലെങ്കിൽ സ്വകാര്യ കീകൾ ഏതെങ്കിലും മാർഗ്ഗങ്ങളിലൂടെ നേടുകയും തുടർന്ന് ചോദ്യം ചെയ്യപ്പെടുന്ന മാൽവെയറിനെക്കുറിച്ചുള്ള വിശകലനത്തിൽ അവ ഉപയോഗിക്കുകയും ചെയ്യുക എന്നതാണ്.


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 അസംബ്ലിയെക്കുറിച്ചുള്ള ഒരു സമ്പൂർണ്ണ പ്രൈമർ ആയി ഇത് ഉദ്ദേശിച്ചിട്ടില്ലെങ്കിലും, നൽകിയിട്ടുള്ള മാൽവെയർ അസംബ്ലി ഡംപിംഗിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് കണ്ടെത്താൻ നിങ്ങൾക്ക് ഇപ്പോൾ ഒരു ആരംഭ സ്ഥലം ഉണ്ടെന്ന് നിങ്ങൾക്ക് മതിയായ ആശ്വാസം തോന്നും.


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.

അടിസ്ഥാനപരമായ ഡൈനാമിക് വിശകലന രീതികളും, മാൽവെയർ ഡാറ്റാ സയൻസുമായി അവയ്ക്കുള്ള ബന്ധവും, അതിന്റെ പ്രയോഗങ്ങളും പര്യവേക്ഷണം ചെയ്തുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം.


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.

രണ്ടാം അധ്യായത്തിൽ ചർച്ച ചെയ്ത സ്ഥിരമായ വിശകലന ടൂളുകൾ ഉപയോഗിച്ച് പാക്ക് ചെയ്തതോ അവ്യക്തമാക്കിയതോ ആയ മാൽവെയർ സാമ്പിൾ ഡിസ്അസംബിൾ ചെയ്യാൻ നമുക്ക് ശ്രമിക്കാം, പക്ഷേ ഇത് വളരെ ശ്രമകരമായ ഒരു പ്രക്രിയയാണ്.


A simple yet clever alternative to this process is to execute the malware in a safe, contained environment called a sandbox.

ഈ പ്രക്രിയക്ക് ഒരു ലളിതവും എന്നാൽ വളരെ മികച്ചതുമായ ബദൽ മാർഗ്ഗം, ഒരു സുരക്ഷിതവും, നിയന്ത്രിതവുമായ അന്തരീക്ഷത്തിൽ മാൽവെയർ പ്രവർത്തിപ്പിക്കുക എന്നതാണ്, ഇതിനെ സാൻഡ്‌ബോക്സ് എന്ന് വിളിക്കുന്നു.


Running malware in a sandbox allows it to unpack itself as it would when infecting a real target.

ഒരു സാൻഡ്‌ബോക്സിൽ മാൽവെയർ പ്രവർത്തിപ്പിക്കുന്നത്, ഒരു യഥാർത്ഥ ടാർഗെറ്റിനെ ബാധിക്കുമ്പോൾ സംഭവിക്കുന്നതുപോലെ സ്വയം അൺപാക്ക് ചെയ്യാൻ അനുവദിക്കുന്നു.


By simply running malware, we can find out what servers a particular malware binary connects to, what system configuration parameters it changes, and what device I/O (input/output) it attempts to perform.

മാൽവെയർ പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ, ഒരു പ്രത്യേക മാൽവെയർ ബൈനറി ഏതൊക്കെ സെർവറുകളുമായി ബന്ധപ്പെടുന്നു, അത് എന്ത് സിസ്റ്റം കോൺഫിഗറേഷൻ പാരാമീറ്ററുകളാണ് മാറ്റുന്നത്, കൂടാതെ അത് എന്ത് ഡിവൈസ് I/O (ഇൻപുട്ട്/ഔട്ട്‌പുട്ട്) പ്രവർത്തനങ്ങളാണ് ചെയ്യാൻ ശ്രമിക്കുന്നത് എന്നെല്ലാം കണ്ടെത്താൻ കഴിയും.


Because dynamic analysis reveals what a malware sample does, we can compare its actions to those of other malware samples.

ഡൈനാമിക് വിശകലനം ഒരു മാൽവെയർ സാമ്പിൾ എന്താണ് ചെയ്യുന്നതെന്ന് വെളിപ്പെടുത്തുന്നതിനാൽ, അതിന്റെ പ്രവർത്തനങ്ങൾ മറ്റ് മാൽവെയർ സാമ്പിളുകളുമായി താരതമ്യം ചെയ്യാൻ കഴിയും.


For example, because dynamic analysis shows what files malware samples write to disk, we can use this data to connect those malware samples that write similar filenames to disk.

ഉദാഹരണത്തിന്, ഡൈനാമിക് വിശകലനം മാൽവെയർ സാമ്പിളുകൾ ഡിസ്കിലേക്ക് ഏതൊക്കെ ഫയലുകളാണ് എഴുതുന്നതെന്ന് കാണിക്കുന്നതിനാൽ, സമാനമായ ഫയൽനാമങ്ങൾ ഡിസ്കിലേക്ക് എഴുതുന്ന മാൽവെയർ സാമ്പിളുകളെ ബന്ധിപ്പിക്കുന്നതിന് ഈ ഡാറ്റ ഉപയോഗിക്കാം.


They can even help us identify malware samples that were authored by the same groups or are part of the same campaigns.

ഒരേ ഗ്രൂപ്പുകൾ നിർമ്മിച്ചതോ അല്ലെങ്കിൽ ഒരേ കാമ്പെയ്‌നുകളുടെ ഭാഗമായതോ ആയ മാൽവെയർ സാമ്പിളുകൾ തിരിച്ചറിയാനും ഇത് സഹായിക്കും.


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

ഈ പ്രോഗ്രാം ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ പുസ്തകത്തിലെ ഏതെങ്കിലും മാൽവെയർ ഡാറ്റാസെറ്റുകളിൽ മാൽവെയർ ബന്ധങ്ങൾ കാണാൻ കഴിയും.


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.

പങ്കിട്ട ഇമേജ് ബന്ധ ശൃംഖല നിർമ്മിക്കുന്നു. പങ്കിട്ട കോൾബാക്ക് സെർവറുകളെ അടിസ്ഥാനമാക്കി മാൽവെയർ വിശകലനം ചെയ്യുന്നതിനു പുറമെ, പങ്കിട്ട ഐക്കണുകളുടെ ഉപയോഗത്തെ അടിസ്ഥാനമാക്കി നമുക്ക് അവയെ വിശകലനം ചെയ്യാനും കഴിയും.


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.

ഇത് 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.

ഈ അധ്യായത്തിൽ, പങ്കിട്ട ആട്രിബ്യൂട്ട് വിശകലനം നടപ്പിലാക്കാൻ ആവശ്യമായ ടൂളുകളെയും രീതികളെയും കുറിച്ച് നിങ്ങൾ പഠിച്ചു.


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

പ്രത്യേകിച്ചും, നെറ്റ്‌വർക്കുകൾ, ബൈപാർട്ടൈറ്റ് നെറ്റ്‌വർക്കുകൾ, ബൈപാർട്ടൈറ്റ് നെറ്റ്‌വർക്ക് പ്രൊജക്ഷനുകൾ എന്നിവയ്ക്ക് മാൽവെയർ സാമ്പിളുകൾ തമ്മിലുള്ള സാമൂഹിക ബന്ധങ്ങൾ തിരിച്ചറിയാൻ എങ്ങനെ സഹായിക്കുമെന്നും നിങ്ങൾ പഠിച്ചു.


In Chapter 5, you’ll learn how to build malware networks based on shared code relationships between samples.

അഞ്ചാം അധ്യായത്തിൽ, സാമ്പിളുകൾ തമ്മിലുള്ള പങ്കിട്ട കോഡ് ബന്ധങ്ങളെ അടിസ്ഥാനമാക്കി മാൽവെയർ നെറ്റ്‌വർക്കുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും.


Suppose you discovered a new malware sample on your network.

നിങ്ങളുടെ നെറ്റ്‌വർക്കിൽ ഒരു പുതിയ മാൽവെയർ സാമ്പിൾ കണ്ടെത്തിയെന്ന് കരുതുക.


The compiler's settings significantly impact the assembly instructions generated.

കംപൈലറിൻ്റെ ക്രമീകരണങ്ങൾ ഉണ്ടാക്കുന്ന അസംബ്ലി നിർദ്ദേശങ്ങളെ വളരെയധികം സ്വാധീനിക്കുന്നു.


Optimizing code for speed can lead to pre-computed results by the compiler.

വേഗതയ്ക്കായി കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നത് കംപൈലർ മുൻകൂട്ടി കണക്കുകൂട്ടിയ ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം.


Malware written in high-level languages often contains standard boilerplate assembly code.

ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിൽ എഴുതിയ ക്ഷുദ്രവെയറുകളിൽ സാധാരണയായി സ്റ്റാൻഡേർഡ് ബോയിലർപ്ലേറ്റ് അസംബ്ലി കോഡുകൾ അടങ്ങിയിരിക്കുന്നു.


Strings-based similarity analysis avoids the compiler problem by focusing on format strings.

സ്ട്രിംഗ് അടിസ്ഥാനമാക്കിയുള്ള സമാനത വിശകലനം, ഫോർമാറ്റ് സ്ട്രിംഗുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നതിലൂടെ കംപൈലർ പ്രശ്നം ഒഴിവാക്കുന്നു.


The Jaccard index is used to compute strings-based malware similarity.

സ്ട്രിംഗ് അടിസ്ഥാനമാക്കിയുള്ള ക്ഷുദ്രവെയർ സമാനത കണക്കാക്കാൻ ജക്കാർഡ് സൂചിക ഉപയോഗിക്കുന്നു.


Import Address Table (IAT)-based similarity compares DLL imports.

ഇംപോർട്ട് വിലാസ പട്ടിക (IAT) അടിസ്ഥാനമാക്കിയുള്ള സമാനത DLL ഇറക്കുമതികളെ താരതമ്യം ചെയ്യുന്നു.


Dynamic API call-based similarity analyzes API call sequences in a sandbox.

ഡൈനാമിക് API കോൾ അടിസ്ഥാനമാക്കിയുള്ള സമാനത, ഒരു സാൻഡ്‌ബോക്സിൽ API കോൾ സീക്വൻസുകൾ വിശകലനം ചെയ്യുന്നു.


Obfuscation and packing can make malware analysis more difficult.

ഒബ്‌ഫസ്‌ക്കേഷനും പാക്കിംഗും ക്ഷുദ്രവെയർ വിശകലനം കൂടുതൽ ബുദ്ധിമുട്ടാക്കും.


Building a similarity graph helps visualize code-sharing relationships.

ഒരു സമാനത ഗ്രാഫ് നിർമ്മിക്കുന്നത് കോഡ്-ഷെയറിംഗ് ബന്ധങ്ങൾ ദൃശ്യവൽക്കരിക്കാൻ സഹായിക്കുന്നു.


The Jaccard index threshold determines the link creation in the graph.

ഗ്രാഫിലെ ലിങ്ക് ഉണ്ടാക്കുന്നത് ജക്കാർഡ് സൂചികയുടെ പരിധി നിർണ്ണയിക്കുന്നു.


Randomized comparison algorithms are needed to scale malware similarity comparisons.

ക്ഷുദ്രവെയർ സമാനത താരതമ്യങ്ങൾ അളക്കുന്നതിന്, ക്രമരഹിതമായ താരതമ്യ അൽഗോരിതങ്ങൾ ആവശ്യമാണ്.


Minhash is an approximate comparison approach used to speed up the Jaccard index calculation.

ജക്കാർഡ് സൂചികയുടെ കണക്കുകൂട്ടൽ വേഗത്തിലാക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ഏകദേശ താരതമ്യ രീതിയാണ് മിൻഹാഷ്.


Minhash uses multiple hash functions to create minhashes.

മിൻഹാഷുകൾ ഉണ്ടാക്കാൻ മിൻഹാഷ് ഒന്നിലധികം ഹാഷ് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു.


Sketches are created by hashing multiple minhashes together.

ഒന്നിലധികം മിൻഹാഷുകൾ ഒരുമിച്ച് ഹാഷ് ചെയ്യുന്നതിലൂടെ സ്കെച്ചുകൾ ഉണ്ടാക്കുന്നു.


Database indexing is used with sketching to optimize the comparison process.

താരതമ്യ പ്രക്രിയ ഒപ്റ്റിമൈസ് ചെയ്യാൻ സ്കെച്ചിംഗിനൊപ്പം ഡാറ്റാബേസ് ഇൻഡെക്സിംഗ് ഉപയോഗിക്കുന്നു.


The system indexes malware samples based on their string features.

സിസ്റ്റം ക്ഷുദ്രവെയർ സാമ്പിളുകളെ അവയുടെ സ്ട്രിംഗ് ഫീച്ചറുകളെ അടിസ്ഥാനമാക്കി സൂചികയിലാക്കുന്നു.


The murmur library is used for hashing in the minhash algorithm.

മിൻഹാഷ് അൽഗോരിതത്തിൽ ഹാഷിംഗിനായി മർമർ ലൈബ്രറി ഉപയോഗിക്കുന്നു.


The shelve database is used to store malware sample information.

ക്ഷുദ്രവെയർ സാമ്പിൾ വിവരങ്ങൾ സംഭരിക്കുന്നതിന് ഷെൽഫ് ഡാറ്റാബേസ് ഉപയോഗിക്കുന്നു.


The number of minhashes and sketches affects the accuracy of similarity computations.

മിൻഹാഷുകളുടെയും സ്കെച്ചുകളുടെയും എണ്ണം സമാനത കണക്കുകൂട്ടലുകളുടെ കൃത്യതയെ ബാധിക്കുന്നു.


Inverted indexing is used to store samples based on their sketch values.

സാമ്പിളുകൾ അവയുടെ സ്കെച്ച് മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി സംഭരിക്കുന്നതിന് വിപരീത സൂചിക ഉപയോഗിക്കുന്നു.


We look up that sketch’s record in the database.

നമ്മൾ ആ സ്കെച്ചിന്റെ റെക്കോർഡ് ഡാറ്റാബേസിൽ തിരയുന്നു.


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.

സ്കെച്ചിനായി ഇതിനകം ഒരു റെക്കോർഡ് ഇല്ലെങ്കിൽ, ഞങ്ങൾ ഒരെണ്ണം ഉണ്ടാക്കുന്നു.


Listing 5-11 shows the declaration of two important functions.

ലിസ്റ്റിംഗ് 5-11 രണ്ട് പ്രധാന ഫംഗ്ഷനുകളുടെ പ്രഖ്യാപനം കാണിക്കുന്നു.


Function that allows a user to comment on a sample.

ഒരു സാമ്പിളിനെക്കുറിച്ച് അഭിപ്രായം പറയാൻ ഉപയോക്താവിനെ അനുവദിക്കുന്ന ഫംഗ്ഷൻ.


The comment the user provides shows up whenever this sample is seen.

ഉപയോക്താവ് നൽകുന്ന അഭിപ്രായം ഈ സാമ്പിൾ കാണുമ്പോഴെല്ലാം ദൃശ്യമാകും.


Function searches for samples similar to the sample provided.

നൽകിയിട്ടുള്ള സാമ്പിളിന് സമാനമായ സാമ്പിളുകൾക്കായി ഫംഗ്ഷൻ തിരയുന്നു.


We extract string features, minhashes, and sketches from the query sample.

ചോദ്യ സാമ്പിളിൽ നിന്ന് സ്ട്രിംഗ് ഫീച്ചറുകളും, മിൻഹാഷുകളും, സ്കെച്ചുകളും വേർതിരിച്ചെടുക്കുന്നു.


We report the most similar samples to the query sample to the user.

ചോദ്യ സാമ്പിളിനോട് ഏറ്റവും സാമ്യമുള്ള സാമ്പിളുകൾ ഉപയോക്താവിന് റിപ്പോർട്ട് ചെയ്യുന്നു.


Listing 5-12 concludes our program’s code.

ലിസ്റ്റിംഗ് 5-12 നമ്മുടെ പ്രോഗ്രാമിന്റെ കോഡ് അവസാനിപ്പിക്കുന്നു.


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

ഇവിടെ, ഉപയോക്താക്കൾക്ക് ഡാറ്റാബേസിലേക്ക് മാൽവെയർ സാമ്പിളുകൾ ലോഡ് ചെയ്യാൻ ഞങ്ങൾ അനുമതി നൽകുന്നു.


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

ഡാറ്റാബേസിലുള്ള സാമ്പിളുകളിൽ അഭിപ്രായം പറയാനും ഞങ്ങൾ ഉപയോക്താവിനെ അനുവദിക്കുന്നു.


സാമ്യത തിരയൽ സംവിധാനം പ്രവർത്തിപ്പിക്കുന്നു.


Loading the samples into the system stores them in the system database.

സാമ്പിളുകൾ സിസ്റ്റത്തിലേക്ക് ലോഡ് ചെയ്യുന്നത് അവയെ സിസ്റ്റം ഡാറ്റാബേസിൽ സംഭരിക്കുന്നു.


You can load samples individually or specify a directory.

നിങ്ങൾക്ക് സാമ്പിളുകൾ വ്യക്തിഗതമായി ലോഡ് ചെയ്യാം അല്ലെങ്കിൽ ഒരു ഡയറക്ടറി വ്യക്തമാക്കാം.


Comment on a sample is useful because it allows you to store knowledge.

ഒരു സാമ്പിളിനെക്കുറിച്ചുള്ള അഭിപ്രായം, അറിവ് സംഭരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നതിനാൽ ഉപകാരപ്രദമാണ്.


Given a single malware sample, searching identifies all similar samples.

ഒരു മാൽവെയർ സാമ്പിൾ നൽകുമ്പോൾ, തിരയൽ സമാനമായ എല്ലാ സാമ്പിളുകളും തിരിച്ചറിയുന്നു.


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

ഡാറ്റാബേസ് മായ്ക്കുന്നത് സിസ്റ്റം ഡാറ്റാബേസിൽ നിന്നുള്ള എല്ലാ റെക്കോർഡുകളും ലളിതമായി മായ്‌ക്കുന്നു.


This example uses an algorithm called logistic regression.

ഈ ഉദാഹരണം ലോജിസ്റ്റിക് റീഗ്രഷൻ എന്ന് പേരുള്ള ഒരു അൽഗോരിതം ഉപയോഗിക്കുന്നു.


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

പ്ലോട്ടിലൂടെ കടന്നുപോകുന്ന രേഖയാണ് തീരുമാനമെടുക്കുന്നതിനുള്ള അതിർത്തി.


On the right side of the line, the logistic regression algorithm assigns a greater than 50 percent probability that binaries are malware.

വരയുടെ വലതുവശത്ത്, ബൈനറികൾക്ക് 50 ശതമാനത്തിൽ കൂടുതൽ സാധ്യതയുണ്ടെന്ന് ലോജിസ്റ്റിക് റീഗ്രഷൻ അൽഗോരിതം കണക്കാക്കുന്നു.


The dark gray shaded region is the region where the logistic regression model is highly confident that files are malware.

ചാരനിറത്തിലുള്ള ഭാഗം, ഫയലുകൾക്ക് മാൽവെയർ ഉണ്ടാകാനുള്ള സാധ്യത വളരെ കൂടുതലാണെന്ന് ലോജിസ്റ്റിക് റീഗ്രഷൻ മോഡൽ വിശ്വസിക്കുന്ന ഭാഗമാണ്.


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, and all other machine learning algorithms, can operate in arbitrarily high dimensional feature spaces.

ലോജിസ്റ്റിക് റീഗ്രഷനും മറ്റ് എല്ലാ മെഷീൻ ലേണിംഗ് അൽഗോരിതങ്ങളും ഉയർന്ന അളവുകളുള്ള ഫീച്ചർ സ്പേസുകളിൽ പ്രവർത്തിക്കാൻ കഴിയും.


In this higher-dimensional space, the decision boundary is not a line, but a plane.

ഈ ഉയർന്ന അളവുകളുള്ള സ്ഥലത്ത്, തീരുമാനമെടുക്കുന്നതിനുള്ള അതിർത്തി ഒരു രേഖയല്ല, ഒരു തലമാണ്.


Because logistic regression is a relatively simple machine learning algorithm, it can only create simple geometrical decision boundaries.

ലോജിസ്റ്റിക് റീഗ്രഷൻ താരതമ്യേന ലളിതമായ ഒരു മെഷീൻ ലേണിംഗ് അൽഗോരിതം ആയതുകൊണ്ട്, ലളിതമായ ജ്യാമിതീയ തീരുമാന അതിർത്തികൾ മാത്രമേ ഇതിന് ഉണ്ടാക്കാൻ കഴിയൂ.


Consider, for example, the decision boundary shown in Figure 6-5, given by the k-nearest neighbors algorithm.

ഉദാഹരണത്തിന്, k-nearest neighbors അൽഗോരിതം നൽകുന്ന, ചിത്രം 6-5 ൽ കാണിച്ചിരിക്കുന്ന തീരുമാന അതിർത്തി പരിഗണിക്കുക.


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

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ തീരുമാന അതിർത്തി ഒരു തലമല്ല: ഇത് വളരെ ക്രമരഹിതമായ ഒരു ഘടനയാണ്.


Also note that some machine learning algorithms can generate disjointed decision boundaries.

ചില മെഷീൻ ലേണിംഗ് അൽഗോരിതങ്ങൾ വേർതിരിക്കപ്പെട്ട തീരുമാന അതിർത്തികൾ ഉണ്ടാക്കാൻ സാധ്യതയുണ്ട്.


Even though the decision boundary is noncontiguous, it’s still common machine learning parlance to call these disjoint decision boundaries simply “decision boundaries.”

തീരുമാന അതിർത്തി തുടർച്ചയായ ഒന്നല്ലെങ്കിലും, ഈ വേർതിരിക്കപ്പെട്ട തീരുമാന അതിർത്തികളെ


You can use different machine learning algorithms to express different types of decision boundaries.

വിവിധതരം തീരുമാന അതിർത്തികൾ പ്രകടിപ്പിക്കാൻ നിങ്ങൾക്ക് വ്യത്യസ്ത മെഷീൻ ലേണിംഗ് അൽഗോരിതങ്ങൾ ഉപയോഗിക്കാം.


Avoiding both cases is what defines a good machine learning algorithm.

രണ്ട് കേസുകളും ഒഴിവാക്കുന്നത് ഒരു നല്ല മെഷീൻ ലേണിംഗ് അൽഗോരിതത്തെ നിർവചിക്കുന്നു.


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.

മെഷീൻ ലേണിംഗ് മാൽവെയർ കണ്ടെത്തൽ മോഡലുകൾ നിർമ്മിക്കുന്നത് പൊതുവായ പ്രവണതകൾ ഉൾക്കൊള്ളുന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു.


Let’s use the examples of underfit, well fit, and overfit models in Figures 6-7, 6-8, and 6-9 to illustrate these terms.

ഈ പദങ്ങൾ വിശദീകരിക്കുന്നതിന്, ചിത്രം 6-7, 6-8, 6-9 എന്നിവയിലെ അണ്ടർഫിറ്റ്, നന്നായി ഫിറ്റ് ചെയ്ത, ഓവർഫിറ്റ് മോഡലുകളുടെ ഉദാഹരണങ്ങൾ ഉപയോഗിക്കാം.


The ROC curves help in understanding how a system performs in identifying malicious binaries.

ദോഷകരമായ ബൈനറികൾ തിരിച്ചറിയുന്നതിൽ ഒരു സിസ്റ്റം എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ ROC കർവുകൾ സഹായിക്കുന്നു.


Precision is the percentage of system alarms that are true positives.

കൃത്യത എന്നാൽ സിസ്റ്റം അലാറങ്ങളിൽ ശരിയായ പോസിറ്റീവുകളുടെ ശതമാനമാണ്.


Base rate refers to the percentage of binaries that are actually malware.

ബേസ് റേറ്റ് എന്നത് യഥാർത്ഥത്തിൽ മാൽവെയറായ ബൈനറികളുടെ ശതമാനത്തെക്കുറിച്ചാണ് പറയുന്നത്.


The precision of a system is affected by changes in the malware base rate.

ഒരു സിസ്റ്റത്തിന്റെ കൃത്യത മാൽവെയർ ബേസ് റേറ്റിലെ മാറ്റങ്ങൾക്കനുസരിച്ച് ബാധിക്കപ്പെടുന്നു.


If a network has no malware, every alarm will be a false positive.

ഒരു നെറ്റ്‌വർക്കിൽ മാൽവെയർ ഇല്ലെങ്കിൽ, എല്ലാ അലാറങ്ങളും തെറ്റായ പോസിറ്റീവ് ആയിരിക്കും.


When the base rate is low, precision drops significantly.

ബേസ് റേറ്റ് കുറവാണെങ്കിൽ, കൃത്യത ഗണ്യമായി കുറയും.


You can estimate the precision of your system based on the base rate.

ബേസ് റേറ്റിനെ അടിസ്ഥാനമാക്കി നിങ്ങളുടെ സിസ്റ്റത്തിന്റെ കൃത്യത കണക്കാക്കാൻ കഴിയും.


The true positive rate is the percentage of malware samples correctly detected.

ശരിയായ പോസിറ്റീവ് നിരക്ക് എന്നത് ശരിയായി കണ്ടെത്തിയ മാൽവെയർ സാമ്പിളുകളുടെ ശതമാനമാണ്.


The false positive rate is the percentage of benign samples incorrectly alarmed on.

തെറ്റായ പോസിറ്റീവ് നിരക്ക് എന്നത് തെറ്റായി അലാറം നൽകുന്ന നിരുപദ്രവകരമായ സാമ്പിളുകളുടെ ശതമാനമാണ്.


Reducing the false positive rate is crucial for enterprise settings.

എന്റർപ്രൈസ് ക്രമീകരണങ്ങളിൽ തെറ്റായ പോസിറ്റീവ് നിരക്ക് കുറയ്ക്കുന്നത് നിർണായകമാണ്.


Machine learning systems can be built using open-source software.

ഓപ്പൺ സോഴ്സ് സോഫ്റ്റ്‌വെയർ ഉപയോഗിച്ച് മെഷീൻ ലേണിംഗ് സിസ്റ്റങ്ങൾ നിർമ്മിക്കാൻ കഴിയും.


Scikit-learn is a popular open-source machine learning package.

Scikit-learn ഒരു ജനപ്രിയ ഓപ്പൺ സോഴ്സ് മെഷീൻ ലേണിംഗ് പാക്കേജാണ്.


Machine learning frameworks often require training data in vector form.

മെഷീൻ ലേണിംഗ് ഫ്രെയിംവർക്കുകൾക്ക് സാധാരണയായി വെക്റ്റർ രൂപത്തിലുള്ള പരിശീലന ഡാറ്റ ആവശ്യമാണ്.


Vectors are arrays of numbers representing features.

വെക്റ്ററുകൾ ഫീച്ചറുകളെ പ്രതിനിധീകരിക്കുന്ന സംഖ്യകളുടെ ശ്രേണികളാണ്.


The DictVectorizer class transforms dictionary representations to vector form.

DictVectorizer ക്ലാസ് നിഘണ്ടു രൂപത്തിലുള്ള പ്രാതിനിധ്യങ്ങളെ വെക്റ്റർ രൂപത്തിലേക്ക് മാറ്റുന്നു.


Training data consists of feature vectors and a label vector.

പരിശീലന ഡാറ്റയിൽ ഫീച്ചർ വെക്റ്ററുകളും ഒരു ലേബൽ വെക്റ്ററും ഉൾപ്പെടുന്നു.


The term 'fit' is often used instead of 'train' in sklearn.

sklearn-ൽ 'പരിശീലിക്കുക' എന്നതിനുപകരം പലപ്പോഴും 'fit' എന്ന പദം ഉപയോഗിക്കുന്നു.


The term 'predict' is used instead of 'detect' in sklearn.

sklearn-ൽ 'കണ്ടെത്തുക' എന്നതിനുപകരം 'predict' എന്ന പദം ഉപയോഗിക്കുന്നു.


Decision trees ask a series of questions to arrive at a decision.

തീരുമാനത്തിലെത്താൻ ഡിസിഷൻ ട്രീകൾ ചോദ്യങ്ങൾ ചോദിക്കുന്നു.


Real-world malware detectors use industrial-strength features.

യഥാർത്ഥ ലോകത്തിലെ മാൽവെയർ ഡിറ്റക്ടറുകൾ വ്യവസായിക നിലവാരമുള്ള ഫീച്ചറുകൾ ഉപയോഗിക്കുന്നു.


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.

ഒരു റൂട്ട് നോഡ് തിരഞ്ഞെടുത്ത ശേഷം, റൂട്ട് നോഡ് തിരഞ്ഞെടുക്കാൻ ഉപയോഗിച്ചതിന് സമാനമായ രീതി ഉപയോഗിച്ച് അടുത്ത ചോദ്യങ്ങൾ തിരഞ്ഞെടുക്കുക.


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

വൃക്ഷത്തിന്റെ വലുപ്പം നിയന്ത്രിക്കുന്നതിലൂടെ, വൃക്ഷം ലളിതമാണെങ്കിൽ, ശരിയായ ഉത്തരം കിട്ടാൻ കൂടുതൽ സാധ്യതയുണ്ട്.


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.

പൊതുവേ, മെഷീൻ ലേണിംഗ് വിദഗ്ധർ സാധാരണയായി ഒന്നിലധികം ആഴങ്ങൾ പരീക്ഷിക്കുകയും, അല്ലെങ്കിൽ മുമ്പ് കാണാത്ത ബൈനറികളിൽ പരമാവധി ആഴം അനുവദിക്കുകയും, ഏറ്റവും കൃത്യമായ ഫലങ്ങൾ ലഭിക്കുന്നതുവരെ ഈ പ്രക്രിയ ആവർത്തിക്കുകയും ചെയ്യുന്നു.


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.

വൃക്ഷം നിർമ്മിക്കാൻ തുടങ്ങുമ്പോൾ, നമ്മുടെ റൂട്ട് നോഡ് തിരഞ്ഞെടുക്കാൻ 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.

ആരംഭ ചോദ്യത്തിന് 'ഇല്ല' എന്ന് ഉത്തരം നൽകിയ സാമ്പിളുകൾക്കും ഇതുതന്നെ ചെയ്യുന്നു.


If we can determine whether they’re malicious or benign at this point, we don’t ask any additional questions.

ഈ ഘട്ടത്തിൽ അവ ദോഷകരമാണോ അല്ലയോ എന്ന് നിർണ്ണയിക്കാൻ കഴിയുമെങ്കിൽ, ഞങ്ങൾ കൂടുതൽ ചോദ്യങ്ങൾ ചോദിക്കില്ല.


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

pick_best_question() എങ്ങനെയാണ് പ്രവർത്തിക്കുന്നതെന്ന് ഈ പുസ്തകത്തിന്റെ പരിധിയിൽ വരുന്നതല്ല, എന്നാൽ ആശയം ലളിതമാണ്.


To pick the best question at any point in the decision tree building process, we look at the training examples about which we’re still uncertain, enumerate all the questions we could ask about them, and then pick the one that best reduces our uncertainty about whether the examples are malware or benignware.

തീരുമാനമെടുക്കുന്ന വൃക്ഷം നിർമ്മിക്കുന്ന പ്രക്രിയയിൽ ഏത് ഘട്ടത്തിലും മികച്ച ചോദ്യം തിരഞ്ഞെടുക്കുന്നതിന്, ഇപ്പോഴും സംശയമുള്ള പരിശീലന ഉദാഹരണങ്ങൾ ഞങ്ങൾ പരിശോധിക്കുന്നു, അവയെക്കുറിച്ച് ചോദിക്കാൻ കഴിയുന്ന എല്ലാ ചോദ്യങ്ങളും എണ്ണുന്നു, തുടർന്ന് ഉദാഹരണങ്ങൾ ക്ഷുദ്രകരമാണോ ദോഷകരമല്ലാത്തതാണോ എന്നതിനെക്കുറിച്ചുള്ള നമ്മുടെ സംശയം ഏറ്റവും നന്നായി കുറയ്ക്കുന്ന ഒന്ന് തിരഞ്ഞെടുക്കുന്നു.


We measure this reduction in uncertainty using a statistical measurement called information gain.

വിവര നേട്ടം എന്ന് വിളിക്കപ്പെടുന്ന ഒരു സ്ഥിതിവിവര അളവാണ് ഈ സംശയത്തിന്റെ കുറവ് അളക്കാൻ ഉപയോഗിക്കുന്നത്.


In this case, instead of setting a maximum depth for the trees, we allow them to grow to the point where there are no false positives or false negatives relative to the training data so that every training sample is correctly classified.

ഈ സാഹചര്യത്തിൽ, വൃക്ഷങ്ങൾക്ക് ഒരു പരമാവധി ആഴം നൽകാതെ, പരിശീലന ഡാറ്റയുമായി ബന്ധപ്പെട്ട് തെറ്റായ പോസിറ്റീവുകളോ നെഗറ്റീവുകളോ ഇല്ലാത്ത രീതിയിൽ അവയെ വളരാൻ അനുവദിക്കുന്നു, അതുവഴി എല്ലാ പരിശീലന സാമ്പിളുകളും ശരിയായി തരംതിരിക്കപ്പെടുന്നു.


The reason for this is complex, but it’s related to the fact that decision trees express jagged decision boundaries, which don’t fit the training data in ways that generalize to previously unseen examples very well.

ഇതിനുള്ള കാരണം സങ്കീർണ്ണമാണ്, എന്നാൽ തീരുമാനമെടുക്കുന്ന വൃക്ഷങ്ങൾ, പരിശീലന ഡാറ്റയുമായി പൊരുത്തപ്പെടാത്തതും മുമ്പ് കാണാത്ത ഉദാഹരണങ്ങളിലേക്ക് നന്നായി പൊതുവൽക്കരിക്കാത്തതുമായ, ക്രമരഹിതമായ തീരുമാനമെടുക്കുന്ന അതിർത്തികൾ പ്രകടിപ്പിക്കുന്നതുമായി ഇതിന് ബന്ധമുണ്ട്.


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

സ്ട്രിംഗ് ഫീച്ചറുകൾ നിഘണ്ടു രൂപത്തിൽ സംഭരിക്കുക


scan a file to determine if it is malicious or benign

ഒരു ഫയൽ ദോഷകരമാണോ അതോ നിരപരാധിയാണോ എന്ന് നിർണ്ണയിക്കാൻ സ്കാൻ ചെയ്യുക


ഫയലുകൾ സ്കാൻ ചെയ്യുന്നതിന് മുമ്പ് ഒരു ഡിറ്റക്ടറിനെ പരിശീലിപ്പിക്കുക.


if the user specifies malware_paths and benignware_paths, train a detector

ഉപയോക്താവ് മാൽവെയർ_പാതകളും ബെനിൻവെയർ_പാതകളും വ്യക്തമാക്കിയാൽ, ഒരു ഡിറ്റക്ടറിനെ പരിശീലിപ്പിക്കുക


train the detector on the specified training data

നിർദ്ദിഷ്ട പരിശീലന ഡാറ്റയിൽ ഡിറ്റക്ടറിനെ പരിശീലിപ്പിക്കുക


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.

മെഷീൻ ലേണിംഗ് അടിസ്ഥാനമാക്കിയുള്ള ഒരു മാൽവെയർ ഡിറ്റക്ടർ എഴുതുന്നത് മികച്ചതാണ്, എന്നാൽ അതിന്റെ പ്രകടനം വിലയിരുത്തുന്നതും മെച്ചപ്പെടുത്തുന്നതും അതിന്റെ ഫലപ്രാപ്തിയിൽ നിങ്ങൾക്ക് വിശ്വാസമുണ്ടെങ്കിൽ അത്യാവശ്യമാണ്.


നിങ്ങളുടെ ഡിറ്റക്ടറുടെ പ്രകടനം വിലയിരുത്തുന്നു


Conveniently, sklearn contains code that makes it easy to evaluate detection systems using measurements like ROC curves

സൗകര്യപ്രദമായി, ROC കർവുകൾ പോലുള്ള അളവുകൾ ഉപയോഗിച്ച് കണ്ടെത്തൽ സംവിധാനങ്ങൾ വിലയിരുത്തുന്നത് എളുപ്പമാക്കുന്ന കോഡ് സ്കീലെർനിൽ ഉണ്ട്.


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.

സെൻസിറ്റിവിറ്റി കൂടുന്തോറും, നിങ്ങൾക്ക് കൂടുതൽ തെറ്റായ പോസിറ്റീവുകൾ ലഭിക്കും, എന്നാൽ നിങ്ങളുടെ കണ്ടെത്തൽ നിരക്ക് കൂടുതലായിരിക്കും.


To compute a ROC curve you need a detector that can output a threat score such that the higher its value the more likely it is that a binary is malicious.

ഒരു ROC കർവ് കണക്കാക്കാൻ, ഭീഷണി സ്കോർ ഔട്ട്പുട്ട് ചെയ്യാൻ കഴിയുന്ന ഒരു ഡിറ്റക്ടർ നിങ്ങൾക്ക് ആവശ്യമാണ്, അതുവഴി അതിന്റെ മൂല്യം കൂടുന്തോറും ഒരു ബൈനറി ദോഷകരമാകാനുള്ള സാധ്യത കൂടുതലാണ്.


Let’s explore how we can use ROC curves to determine a detector’s accuracy.

ഒരു ഡിറ്റക്ടറുടെ കൃത്യത നിർണ്ണയിക്കാൻ ROC കർവുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നമുക്ക് പര്യവേക്ഷണം ചെയ്യാം.


ROC കർവുകൾ കണക്കുകൂട്ടുന്നു


To compute a ROC curve for the machine learning detector we built in Listing 8-14, we need to do two things: first, define an experimental setup, and second, implement the experiment using sklearn’s metrics module.

ലിസ്റ്റിംഗ് 8-14-ൽ ഞങ്ങൾ നിർമ്മിച്ച മെഷീൻ ലേണിംഗ് ഡിറ്റക്ടറിനായി ഒരു ROC കർവ് കണക്കാക്കാൻ, നമ്മൾ രണ്ട് കാര്യങ്ങൾ ചെയ്യേണ്ടതുണ്ട്: ഒന്നാമതായി, ഒരു പരീക്ഷണാത്മക സജ്ജീകരണം നിർവചിക്കുക, രണ്ടാമതായി, സ്കീലെർനിന്റെ മെട്രിക്സ് മൊഡ്യൂൾ ഉപയോഗിച്ച് പരീക്ഷണം നടപ്പിലാക്കുക.


This split simulates the problem of detecting zero-day malware.

ഈ വിഭജനം സീറോ-ഡേ മാൽവെയർ കണ്ടെത്തുന്ന പ്രശ്നം അനുകരിക്കുന്നു.


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

sklearn-ന് മനസ്സിലാക്കാൻ കഴിയുന്ന ഫോർമാറ്റിലേക്ക് സ്ട്രിംഗ് ഫീച്ചറുകൾ മാറ്റാൻ, അവ ഒരു Python നിഘണ്ടുവിൽ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്.


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

ഉദാഹരണത്തിന്, മുൻപത്തെ ബൈനറിക്ക് {“PE executable”: 1, “Malicious payload”: 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.

ഉദാഹരണത്തിന്, ഒരു ബൈനറി പ്രോഗ്രാമിന്റെ യഥാർത്ഥ ലോജിക് അവർക്ക് ഉൾക്കൊള്ളാൻ കഴിയില്ല, കാരണം അവ യഥാർത്ഥ പ്രോഗ്രാം കോഡ് ഉൾപ്പെടുന്നില്ല.


So, although strings can be useful features even on packed binaries, they don’t reveal what packed binaries actually do.

അതിനാൽ, സ്ട്രിംഗുകൾ പാക്ക് ചെയ്ത ബൈനറികളിൽ പോലും ഉപയോഗപ്രദമായ ഫീച്ചറുകളായിരിക്കുമെങ്കിലും, പാക്ക് ചെയ്ത ബൈനറികൾ യഥാർത്ഥത്തിൽ എന്താണ് ചെയ്യുന്നതെന്ന് അവ വെളിപ്പെടുത്തുന്നില്ല.


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

തൽഫലമായി, സ്ട്രിംഗ് ഫീച്ചറുകളെ അടിസ്ഥാനമാക്കിയുള്ള ഡിറ്റക്ടറുകൾ പാക്ക് ചെയ്ത മാൽവെയർ കണ്ടെത്താൻ അനുയോജ്യമല്ല.


PE header features complement string features well.

PE header ഫീച്ചറുകൾ സ്ട്രിംഗ് ഫീച്ചറുകളെ നന്നായി പൂരകമാക്കുന്നു.


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 header ഫീച്ചറുകൾ ഉൾക്കൊള്ളുന്നു.


They also capture the amount of memory a program allocates upon startup, and many other runtime characteristics of a program binary that string features don’t capture.

പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ അനുവദിക്കുന്ന മെമ്മറിയുടെ അളവും, സ്ട്രിംഗ് ഫീച്ചറുകൾക്ക് ഉൾക്കൊള്ളാൻ കഴിയാത്ത പ്രോഗ്രാം ബൈനറിയുടെ മറ്റ് നിരവധി റൺടൈം സവിശേഷതകളും അവ ഉൾക്കൊള്ളുന്നു.


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 header ഫീച്ചറുകൾക്ക് ഇപ്പോഴും ഒരു മാന്യമായ ജോലി ചെയ്യാൻ കഴിയും.


This is because although we cannot see packed binaries’ code because of obfuscation, we can still see how much space the code takes up on disk and how the binary is laid out on disk or compressed over a series of file sections.

കാരണം, ഒബ്‌ഫസ്‌കേഷൻ കാരണം പാക്ക് ചെയ്ത ബൈനറികളുടെ കോഡ് നമുക്ക് കാണാൻ കഴിയുന്നില്ലെങ്കിലും, കോഡ് എത്ര സ്ഥലം ഡിസ്‌കിൽ എടുക്കുന്നു, അല്ലെങ്കിൽ ബൈനറി എങ്ങനെ ഡിസ്‌കിൽ സ്ഥാപിച്ചിരിക്കുന്നു അല്ലെങ്കിൽ ഫയൽ വിഭാഗങ്ങളിലായി കംപ്രസ് ചെയ്തിരിക്കുന്നു എന്ന് ഇപ്പോഴും കാണാൻ കഴിയും.


On the downside, PE header features don’t capture the actual instructions a program executes when it is run, or the functions that it calls.

പോരായ്മ എന്തെന്നാൽ, ഒരു പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ അത് എക്സിക്യൂട്ട് ചെയ്യുന്ന യഥാർത്ഥ നിർദ്ദേശങ്ങളോ അത് വിളിക്കുന്ന ഫംഗ്ഷനുകളോ PE header ഫീച്ചറുകൾക്ക് ഉൾക്കൊള്ളാൻ കഴിയില്ല.


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

ഒന്നാം അധ്യായത്തിൽ നിങ്ങൾ പഠിച്ച ഇംപോർട്ട് അഡ്രസ് ടേബിൾ (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 (for example, the key “KERNEL32. DLL:LoadLibraryA”, where KERNEL32. DLL is the DLL and LoadLibraryA is the function call).

മെഷീൻ ലേണിംഗ് ഫീച്ചറുകളുടെ ഒരു ഉറവിടമായി IAT ഉപയോഗിക്കുന്നതിന്, ഓരോ ഫയലിനെയും ഫീച്ചറുകളുടെ ഒരു നിഘണ്ടുവായി പ്രതിനിധീകരിക്കേണ്ടതുണ്ട്, അവിടെ ഇറക്കുമതി ചെയ്ത ലൈബ്രറിയുടെയും ഫംഗ്ഷന്റെയും പേരാണ് കീ, കൂടാതെ കീ 1-ലേക്ക് മാപ്പ് ചെയ്യുന്നു, ഇത് ചോദ്യം ചെയ്യപ്പെടുന്ന ഫയലിൽ ആ പ്രത്യേക ഇറക്കുമതി അടങ്ങിയിരിക്കുന്നു എന്ന് സൂചിപ്പിക്കുന്നു (ഉദാഹരണത്തിന്, “KERNEL32. DLL:LoadLibraryA” എന്ന കീ, അവിടെ KERNEL32. DLL എന്നത് DLL ഉം LoadLibraryA എന്നത് ഫംഗ്ഷൻ കോളും ആണ്).


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 എന്ന വിൻഡോ നീക്കുകയും ചെയ്യുന്നു, ഓരോ ഘട്ടത്തിലും വിൻഡോയിലുള്ള ഫീച്ചറുകളുടെ ശ്രേണിയെ ഒരു ഏകീകൃത ഫീച്ചറായി കണക്കാക്കുന്നു.


The popular Python data analysis library pandas makes it easy to load data into analysis objects called DataFrames.

ഡാറ്റാഫ്രെയിമുകൾ എന്ന് വിളിക്കപ്പെടുന്ന വിശകലന ഒബ്ജക്റ്റുകളിലേക്ക് ഡാറ്റ എളുപ്പത്തിൽ ലോഡ് ചെയ്യാൻ സഹായിക്കുന്ന ഒരു ജനപ്രിയ Python ഡാറ്റാ അനാലിസിസ് ലൈബ്രറിയാണ് പാണ്ട.


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.

ചില സാമ്പിൾ ഡാറ്റ Python ഇന്റർപ്രെറ്ററിലേക്ക് നിർവചിക്കാനും ലോഡ് ചെയ്യാനും ലിസ്റ്റിംഗ് 9-1 ഉപയോഗിക്കാം.


Here we define some data, which we call example_data, as a list of Python dictionaries.

ഇവിടെ, ഞങ്ങൾ example_data എന്ന് വിളിക്കുന്ന ചില ഡാറ്റ, Python നിഘണ്ടുക്കളുടെ ഒരു ലിസ്റ്റായി നിർവചിക്കുന്നു.


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.

ഇവയോരോ dict-ഉം ഫലമായുണ്ടാകുന്ന ഡാറ്റാഫ്രെയിമിലെ ഒരു നിരയായി മാറുന്നു.


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

dict-കളിലെ കീകൾ (column1, column2) കോളങ്ങളായി മാറുന്നു.


This is one way to load data into pandas directly.

ഡാറ്റ നേരിട്ട് പാണ്ടയിലേക്ക് ലോഡ് ചെയ്യാനുള്ള ഒരു വഴിയാണിത്.


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 ലെ കോഡ് ഉപയോഗിക്കാം.


When you import malware_data.csv, the resulting malware object should look something like this:

malware_data.csv ഇറക്കുമതി ചെയ്യുമ്പോൾ, ഉണ്ടാകുന്ന മാൽവെയർ ഒബ്ജക്റ്റ് ഇതുപോലെ കാണപ്പെടും:


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 by calling the describe() method.

നമ്മുടെ ഡാറ്റ ഇപ്പോൾ ഒരു പാണ്ട ഡാറ്റാഫ്രെയിമിൽ ഉള്ളതുകൊണ്ട്, describe() രീതി ഉപയോഗിച്ച് ഇത് എങ്ങനെ ആക്സസ് ചെയ്യാനും കൈകാര്യം ചെയ്യാനും കഴിയുമെന്ന് നോക്കാം.


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

describe() രീതി വിളിക്കുന്നത് നമ്മുടെ ഡാറ്റാഫ്രെയിമിനെക്കുറിച്ചുള്ള ചില ഉപയോഗപ്രദമായ സ്ഥിതിവിവരക്കണക്കുകൾ കാണിക്കുന്നു.


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.

വിരകൾ (worms) Bitcoin മൈനിംഗിനേക്കാളും ട്രോജൻ ഹോഴ്സ് മാൽവെയറിനേക്കാളും കൂടുതൽ തവണ കണ്ടെത്തപ്പെടുന്നു എന്നത് ലിസ്റ്റിംഗ് 9-6-ൽ നിന്നുള്ള രസകരമായ ഫലമാണ്.


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

ബഹുതലങ്ങളുള്ള ന്യൂറൽ നെറ്റ്‌വർക്കുകളും, ഓട്ടോമാറ്റിക് ഫീച്ചർ ഉണ്ടാക്കലും, ആ ജോലിയുടെ ഭാരം കുറയ്ക്കാൻ നമ്മെ സഹായിക്കുന്നു.


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' എന്ന അക്ഷരം എത്ര തവണ വരുന്നു എന്ന് എണ്ണാൻ പഠിക്കും.


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

പരിശീലന സമയത്ത്, അടുത്ത ന്യൂറോൺ ലെയറിലേക്കുള്ള ഇൻപുട്ടുകളായി ആ ഫീച്ചറുകൾ ഉപയോഗപ്രദമാണെന്ന് മോഡൽ മനസ്സിലാക്കി.


ന്യൂറൽ നെറ്റ്‌വർക്കുകൾക്ക് പരിശീലനം നൽകുന്നു


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 എന്നും ലേബൽ ചെയ്യാൻ പഠിപ്പിക്കുന്ന സൂപ്പർവൈസ്ഡ് ലേണിംഗിൽ, ലക്ഷ്യസ്ഥാന ഫംഗ്ഷൻ, പരിശീലന സമയത്തുള്ള നെറ്റ്‌വർക്കിന്റെ പ്രവചനerror-മായി ബന്ധപ്പെട്ടിരിക്കുന്നു.


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, നിങ്ങളുടെ അവസാന ഔട്ട്‌പുട്ട് ŷ ലഭിക്കുന്നതിന് നെറ്റ്‌വർക്കിലൂടെ കടന്നുപോകുന്നു.


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

ഇതിനെ w-യുടെ ആപേക്ഷികമായി ŷ-യുടെ ഭാഗിക ഡെറിവേറ്റീവ് എന്ന് വിളിക്കുന്നു, അല്ലെങ്കിൽ ∂ŷ/∂w.


The process of iteratively calculating these partial derivatives, updating parameters, and then repeating is called gradient descent.

ഈ ഭാഗിക ഡെറിവേറ്റീവുകൾ ആവർത്തിച്ച് കണക്കുകൂട്ടുകയും, പാരാമീറ്ററുകൾ അപ്‌ഡേറ്റ് ചെയ്യുകയും, വീണ്ടും ആവർത്തിക്കുകയും ചെയ്യുന്ന പ്രക്രിയയെ ഗ്രേഡിയന്റ് ഡിസന്റ് എന്ന് വിളിക്കുന്നു.


Using Backpropagation to Optimize a Neural Network

ഒരു ന്യൂറൽ നെറ്റ്‌വർക്ക് ഒപ്റ്റിമൈസ് ചെയ്യാൻ ബാക്ക് പ്രൊപ്പഗേഷൻ ഉപയോഗിക്കുന്നു


Let’s assume that we have a training example whose value is x = 2 and an associated true label of y = 10.

x = 2 എന്ന മൂല്യമുള്ള ഒരു പരിശീലന ഉദാഹരണവും, y = 10 എന്ന അനുബന്ധ ശരിയായ ലേബലും നമ്മുടെ പക്കലുണ്ടെന്ന് കരുതുക.


To nudge our parameters so that our network’s output ŷ, given x = 2, moves closer to our known y value of 10, we need to calculate how w 1→3 affects our final output ŷ.

x = 2 ആകുമ്പോൾ, നമ്മുടെ നെറ്റ്‌വർക്കിന്റെ ഔട്ട്‌പുട്ട് ŷ, 10 എന്ന y-യുടെ അടുത്തേക്ക് നീങ്ങാൻ, w 1→3 എങ്ങനെയാണ് നമ്മുടെ അവസാന ഔട്ട്‌പുട്ട് ŷ-നെ ബാധിക്കുന്നതെന്ന് കണക്കാക്കേണ്ടതുണ്ട്.


Luckily, going over every single path and then summing them to get the ∂ŷ/(∂parameter) is not necessary.

ഭാഗ്യവശാൽ, എല്ലാ വഴികളും കടന്നുപോയി ∂ŷ/(∂parameter) കിട്ടാൻ അവയെല്ലാം കൂട്ടേണ്ടതില്ല.


This is where backpropagation comes in handy.

ഇവിടെയാണ് ബാക്ക് പ്രൊപ്പഗേഷൻ സഹായകമാകുന്നത്.


അപ്രത്യക്ഷമാകുന്ന ഗ്രേഡിയന്റ്


The problem is that each path’s signal is likely to be incredibly tiny, because we calculate that signal by multiplying partial derivatives at each point along the ten-neuron-deep path, all of which tend to be numbers smaller than 1.

പ്രശ്നം എന്തെന്നാൽ, ഓരോ പാതയിലെയും സിഗ്നൽ വളരെ ചെറുതായിരിക്കും, കാരണം ആ സിഗ്നൽ കണക്കാക്കുന്നത്, പത്ത് ന്യൂറോണുകളുള്ള പാതയിലെ ഓരോ പോയിന്റിലെയും ഭാഗിക ഡെറിവേറ്റീവുകൾ ഗുണിച്ചാണ്, അവയെല്ലാം 1-ൽ താഴെയുള്ള സംഖ്യകളായിരിക്കും.


ന്യൂറൽ നെറ്റ്‌വർക്കുകളുടെ തരങ്ങൾ


ഫീഡ്-ഫോർവേഡ് ന്യൂറൽ നെറ്റ്‌വർക്ക്


In feed-forward neural networks, every connection that exists is connecting a neuron (or original input) in layer i to a neuron in layer j > i.

ഫീഡ്-ഫോർവേഡ് ന്യൂറൽ നെറ്റ്‌വർക്കുകളിൽ, നിലവിലുള്ള എല്ലാ കണക്ഷനുകളും ലെയർ i-യിലെ ഒരു ന്യൂറോണിനെയും (അല്ലെങ്കിൽ യഥാർത്ഥ ഇൻപുട്ട്) ലെയർ j > i-യിലെ ഒരു ന്യൂറോണിനെയും ബന്ധിപ്പിക്കുന്നു.


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

ഡീപ് ലേണിംഗ് മോഡലുകൾ അവരുടെ പരിശീലന ഡാറ്റയെ ആശയങ്ങളുടെ ഒരു അടുക്കുകളായുള്ള ശ്രേണിയായി കാണാൻ പഠിക്കുന്നു.


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

ഉദാഹരണത്തിന്, നിങ്ങൾ മുമ്പ് കണ്ടിട്ടുള്ള ചില ദോഷകരമായ കോഡിന്റെ കൃത്യമായ പകർപ്പ് ഒരു ഫയലിൽ അടങ്ങിയിട്ടുണ്ടോ എന്ന് കണ്ടെത്തുന്നത് ഒരു കമ്പ്യൂട്ടർ പ്രോഗ്രാമിന് ലളിതമാണ്.


But detecting whether a file contains malicious code that is somewhat similar to malicious code you’ve seen before is a far more complex task.

എന്നാൽ നിങ്ങൾ മുമ്പ് കണ്ടിട്ടുള്ള ദോഷകരമായ കോഡിനോട് സാമ്യമുള്ള ദോഷകരമായ കോഡ് ഒരു ഫയലിൽ അടങ്ങിയിട്ടുണ്ടോ എന്ന് കണ്ടെത്തുന്നത് വളരെ സങ്കീർണ്ണമായ ഒരു കാര്യമാണ്.


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

പരമ്പരാഗത സിഗ്നേച്ചർ അടിസ്ഥാനമാക്കിയുള്ള കണ്ടെത്തൽ രീതികൾ വളരെ കൃത്യതയില്ലാത്തതും, മുമ്പൊരിക്കലും കാണാത്തതോ മറച്ചുവെച്ചതോ ആയ മാൽവെയറുകളിൽ മോശമായി പ്രവർത്തിക്കുന്നവയുമാണ്.


Deep learning models can see through superficial changes and identify core features that make a sample malicious.

ഡീപ് ലേണിംഗ് മോഡലുകൾക്ക് ഉപരിപ്ലവമായ മാറ്റങ്ങൾ തിരിച്ചറിയാനും ഒരു സാമ്പിളിനെ ദോഷകരമാക്കുന്ന പ്രധാന ഫീച്ചറുകൾ കണ്ടെത്താനും കഴിയും.


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 is harder to understand than the machine learning approaches we discussed early in this book.

ഈ പുസ്തകത്തിന്റെ തുടക്കത്തിൽ നമ്മൾ ചർച്ച ചെയ്ത മെഷീൻ ലേണിംഗ് സമീപനങ്ങളെക്കാൾ കൂടുതൽ മനസ്സിലാക്കാൻ പ്രയാസമാണ് ഡീപ് ലേണിംഗ്.


Deep learning models learn to view their training data as a nested hierarchy of concepts, which allows them to represent incredibly complex patterns.

ഡീപ് ലേണിംഗ് മോഡലുകൾ അവരുടെ പരിശീലന ഡാറ്റയെ ആശയങ്ങളുടെ അടുക്കുകളായുള്ള ശ്രേണിയായി കാണാൻ പഠിക്കുന്നു, ഇത് വളരെ സങ്കീർണ്ണമായ പാറ്റേണുകളെ പ്രതിനിധീകരിക്കാൻ അവരെ സഹായിക്കുന്നു.


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.

മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഈ മോഡലുകൾ നിങ്ങൾ നൽകുന്ന യഥാർത്ഥ ഫീച്ചറുകൾ പരിഗണിക്കുക മാത്രമല്ല, പുതിയതും ഒപ്റ്റിമൈസ് ചെയ്തതുമായ മെറ്റാ-ഫീച്ചറുകൾ രൂപീകരിക്കുന്നതിന് ഈ ഫീച്ചറുകൾ സ്വയമേവ സംയോജിപ്പിക്കുകയും ചെയ്യുന്നു.


Each of these processing units is called a neuron, and the model architecture as a whole is called a neural network, or a deep neural network when there are many layers.

ഈ പ്രോസസ്സിംഗ് യൂണിറ്റുകളിൽ ഒന്നിനെ ന്യൂറോൺ എന്ന് വിളിക്കുന്നു, കൂടാതെ മൊത്തത്തിലുള്ള മോഡൽ ആർക്കിടെക്ചറിനെ ന്യൂറൽ നെറ്റ്‌വർക്ക് അല്ലെങ്കിൽ ഡീപ് ന്യൂറൽ നെറ്റ്‌വർക്ക് എന്ന് വിളിക്കുന്നു.


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.

പ്രശ്നത്തെ കൂടുതൽ കൈകാര്യം ചെയ്യാവുന്ന കഷണങ്ങളായി വിഭജിച്ച് ഡീപ് ലേണിംഗ് മോഡലുകൾ ഇതിനെ മറികടക്കുന്നു.


For example, a deep neural network’s first layer of neurons might first break down the image into parts and just identify low-level visual features, like edges and borders of shapes in the image.

ഉദാഹരണത്തിന്, ഒരു ഡീപ് ന്യൂറൽ നെറ്റ്‌വർക്കിന്റെ ആദ്യത്തെ ന്യൂറോണുകളുടെ ലെയർ, ചിത്രത്തെ ഭാഗങ്ങളായി വിഭജിച്ച്, ചിത്രത്തിലെ ആകൃതികളുടെ അരികുകളും അതിരുകളും പോലുള്ള താഴ്ന്ന തലത്തിലുള്ള വിഷ്വൽ ഫീച്ചറുകൾ തിരിച്ചറിയാൻ സാധ്യതയുണ്ട്.


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 (which are optimized during training).

ഔട്ട്‌പുട്ടിന്റെ മൂല്യം ന്യൂറോണിന്റെ ഇൻപുട്ട് ഡാറ്റയുടെയും ചില പാരാമീറ്ററുകളുടെയും (പരിശീലന സമയത്ത് ഒപ്റ്റിമൈസ് ചെയ്യുന്നത്) ഒരു ഫംഗ്ഷനാണ്.


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.

കെരാസിൻ്റെ ഫങ്ഷണൽ API സിന്റാക്സ് ഉപയോഗിച്ച് നിർവചിക്കപ്പെട്ട ഒരു ലളിതമായ മോഡലിന്റെ ഉദാഹരണമാണ് ലിസ്റ്റിംഗ് 11-1.


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

കോഡ് എഴുതാനും പ്രവർത്തിപ്പിക്കാനും ഒരു പുതിയ പൈത്തൺ ഫയൽ തുറക്കാൻ ഞാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു.


Next, we specify what kind of data this model will accept for one observation.

അടുത്തതായി, ഈ മോഡൽ ഒരു നിരീക്ഷണത്തിനായി ഏത് തരത്തിലുള്ള ഡാറ്റയാണ് സ്വീകരിക്കുക എന്ന് ഞങ്ങൾ വ്യക്തമാക്കുന്നു.


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’) എന്ന രീതിയിൽ ആയിരിക്കും.


Next, we specify the layer of neurons that this input data will be sent to.

അടുത്തതായി, ഈ ഇൻപുട്ട് ഡാറ്റ അയയ്‌ക്കേണ്ട ന്യൂറോണുകളുടെ ലെയർ ഞങ്ങൾ വ്യക്തമാക്കുന്നു.


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 loss parameter specifies the thing that is minimized during the training process (backpropagation).

പരിശീലന പ്രക്രിയയിൽ (ബാക്ക് പ്രൊപ്പഗേഷൻ) കുറയ്‌ക്കേണ്ട കാര്യമാണ് ലോസ് പാരാമീറ്റർ വ്യക്തമാക്കുന്നത്.


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.

ഓരോ ലെയറിൻ്റെയും വിവരണം ആ ലെയറുമായി ബന്ധപ്പെട്ട പാരാമീറ്ററുകളുടെ എണ്ണത്തോടൊപ്പം സ്ക്രീനിൽ പ്രിന്റ് ചെയ്യും.


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-ൽ നിന്ന് ഇൻഹെറിറ്റ് ചെയ്യുന്ന ഒരു ക്ലാസ് ഉണ്ടാക്കണം.


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 ക്ലാസ് ഉണ്ടാക്കുന്നു.


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!

നിങ്ങളുടെ എല്ലാ സുരക്ഷാ ഡീപ് ലേണിംഗ് സാഹസിക യാത്രകൾക്കും ഈ അധ്യായം ഒരു നല്ല തുടക്കമായിരിക്കുമെന്ന് കരുതുന്നു!


To conclude this book, let’s take a step back and discuss how you can make a life and career as a malware data scientist.

ഈ പുസ്തകം ഉപസംഹരിക്കുന്നതിന്, നമുക്ക് ഒരു പടി പിന്നോട്ട് പോയി ഒരു മാൽവെയർ ഡാറ്റാ സയന്റിസ്റ്റായി എങ്ങനെ ജീവിതവും കരിയറും ഉണ്ടാക്കാമെന്ന് ചർച്ച ചെയ്യാം.


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

ഇതൊരു സാങ്കേതികമല്ലാത്ത അധ്യായമാണെങ്കിലും, ഈ പുസ്തകത്തിലെ സാങ്കേതിക അധ്യായങ്ങൾ പോലെ തന്നെ പ്രാധാന്യമുള്ളതാണ് ഇത്.


This is because becoming a successful security data scientist involves much more than simply understanding the subject matter.

കാരണം, ഒരു വിജയകരമായ സുരക്ഷാ ഡാറ്റാ സയന്റിസ്റ്റാകുന്നത്, വിഷയത്തെക്കുറിച്ച് മനസ്സിലാക്കുന്നതിനേക്കാൾ കൂടുതലാണ്.


In this chapter, we the authors share our own career paths to becoming professional security data scientists.

ഈ അധ്യായത്തിൽ, പ്രൊഫഷണൽ സുരക്ഷാ ഡാറ്റാ സയന്റിസ്റ്റുകളാകാനുള്ള ഞങ്ങളുടെ സ്വന്തം കരിയർ പാതകൾ ഞങ്ങൾ പങ്കുവെക്കുന്നു.


We walk through the nascent tools provided in this book in the order in which they appear.

ഈ പുസ്തകത്തിൽ നൽകിയിട്ടുള്ള പുതിയ ടൂളുകൾ അവ പ്രത്യക്ഷപ്പെടുന്ന ക്രമത്തിൽ നമുക്ക് പരിചയപ്പെടാം.


This tool extracts hostnames from target malware files and then shows connections between the files based on common hostnames contained in them.

ഈ ഉപകരണം, ലക്ഷ്യസ്ഥാനത്തുള്ള മാൽവെയർ ഫയലുകളിൽ നിന്ന് ഹോസ്റ്റ്നാമങ്ങൾ വേർതിരിച്ചെടുക്കുകയും, പൊതുവായ ഹോസ്റ്റ്നാമങ്ങളെ അടിസ്ഥാനമാക്കി ഫയലുകൾ തമ്മിലുള്ള ബന്ധങ്ങൾ കാണിക്കുകയും ചെയ്യുന്നു.


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 tool takes a directory of malware as its input and then outputs three GraphViz files that you can then visualize.

ഈ ഉപകരണം, ഒരു ഡയറക്ടറിയിലുള്ള മാൽവെയർ ഇൻപുട്ടായി എടുക്കുകയും, തുടർന്ന് നിങ്ങൾക്ക് ദൃശ്യവൽക്കരിക്കാൻ കഴിയുന്ന മൂന്ന് GraphViz ഫയലുകൾ ഔട്ട്‌പുട്ടായി നൽകുകയും ചെയ്യുന്നു.


As shown in Listing A-1, the shared hostname visualization tool requires four command line arguments.

ലിസ്റ്റിംഗ് A-1 ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, പങ്കിട്ട ഹോസ്റ്റ്നാമം വിഷ്വലൈസേഷൻ ടൂളിന് നാല് കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ ആവശ്യമാണ്.


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.

മാൽവെയർ സാമ്പിളുകളെയും അവയിലുള്ള ഹോസ്റ്റ്നാമങ്ങളെയും ബന്ധിപ്പിക്കുന്ന നെറ്റ്‌വർക്കിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു GraphViz .dot ഫയൽ പ്രോഗ്രാം എഴുതുന്ന ഫയലിന്റെ പാതയാണ് output_file എന്ന പരാമീറ്റർ.


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 സ്യൂട്ട് ഉപയോഗിക്കാം.


We present a shared image network visualization tool in Chapter 4, which is located at ch4/code/listing-4-12.py.

നാലാം അധ്യായത്തിൽ, ch4/code/listing-4-12.py എന്ന സ്ഥലത്തുള്ള ഒരു ഷെയർഡ് ഇമേജ് നെറ്റ്‌വർക്ക് വിഷ്വലൈസേഷൻ ടൂൾ ഞങ്ങൾ അവതരിപ്പിക്കുന്നു.


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

ഈ പ്രോഗ്രാം, മാൽവെയർ സാമ്പിളുകൾ തമ്മിലുള്ള, ഉൾച്ചേർത്ത ചിത്രങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ള നെറ്റ്‌വർക്ക് ബന്ധങ്ങൾ കാണിക്കുന്നു.


Let’s discuss the parameters in the “help” output from the tool (see Listing A-2).

ഈ ടൂളിന്റെ “സഹായം” ഔട്ട്‌പുട്ടിലെ പരാമീറ്ററുകളെക്കുറിച്ച് ചർച്ച ചെയ്യാം (ലിസ്റ്റിംഗ് A-2 കാണുക).


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.

അഞ്ചാം അധ്യായത്തിൽ, മാൽവെയർ സമാനത, പങ്കിട്ട കോഡ് വിശകലനം, വിഷ്വലൈസേഷൻ എന്നിവയെക്കുറിച്ച് ചർച്ച ചെയ്യുന്നു.


The first sample tool we provide is given in ch5/code/listing_5_1.py.

ഞങ്ങൾ നൽകുന്ന ആദ്യത്തെ ടൂൾ ch5/code/listing_5_1.py എന്ന ഫയലിൽ നൽകിയിരിക്കുന്നു.


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.

കമാൻഡ് ലൈനിൽ നിന്ന് ഈ പങ്കിട്ട കോഡ് വിശകലന ഉപകരണം പ്രവർത്തിപ്പിക്കുമ്പോൾ, നിങ്ങൾ രണ്ട് കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ നൽകേണ്ടതുണ്ട്.


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.

അഞ്ചാം അധ്യായത്തിൽ നൽകിയിട്ടുള്ള രണ്ടാമത്തെ കോഡ്-ഷെയറിംഗ് എസ്റ്റിമേഷൻ ടൂൾ ch5/code/listing_5_2.py എന്ന ഫയലിൽ നൽകിയിരിക്കുന്നു.


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

ഈ ടൂളിന് ഇത് പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന നാല് മോഡുകൾ ഉണ്ട്.


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 ➊, മാൽവെയറിനെ സമാനത തിരയൽ ഡാറ്റാബേസിലേക്ക് ലോഡ് ചെയ്യുകയും, അതിൻ്റെ പാരാമീറ്ററായി ഒരു പാത്ത് എടുക്കുകയും ചെയ്യുന്നു, ഇത് മാൽവെയർ അടങ്ങിയ ഒരു ഡയറക്ടറിയിലേക്ക് പോയിന്റ് ചെയ്യണം.


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

pefile ഉപയോഗിച്ച്, 5-7 എൻട്രി പോയിന്റ്, 3 ഫയൽ ഘടന, 2-5.


The Portable Executable (PE) header is crucial.

പോർട്ടബിൾ എക്സിക്യൂട്ടബിൾ (PE) ശീർഷകം വളരെ പ്രധാനമാണ്.


റാൻസംവെയർ ഒരു പ്രധാന ഭീഷണിയാണ്.


Reverse engineering involves detailed analysis.

റിവേഴ്സ് എഞ്ചിനിയറിംഗിൽ വിശദമായ വിശകലനം ഉൾപ്പെടുന്നു.


ROC curves are used for performance evaluation.

ROC വക്രങ്ങൾ പ്രകടനം വിലയിരുത്തുന്നതിന് ഉപയോഗിക്കുന്നു.


Scikit-learn is a useful machine learning package.

Scikit-learn ഒരു ഉപയോഗപ്രദമായ മെഷീൻ ലേണിംഗ് പാക്കേജാണ്.


Building detectors based on random forests is effective.

റാൻഡം ഫോറസ്റ്റുകളെ അടിസ്ഥാനമാക്കി ഡിറ്റക്ടറുകൾ നിർമ്മിക്കുന്നത് ഫലപ്രദമാണ്.


The .rdata section is part of the PE file format.

.rdata വിഭാഗം PE ഫയൽ ഫോർമാറ്റിന്റെ ഭാഗമാണ്.


Security data scientists play a vital role.

സുരക്ഷാ ഡാറ്റാ ശാസ്ത്രജ്ഞർ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു.


Shared code analysis helps identify malware.

പങ്കിട്ട കോഡ് വിശകലനം, മാൽവെയർ തിരിച്ചറിയാൻ സഹായിക്കുന്നു.


Similarity matrices are used in this process.

സാമ്യത മാട്രിക്സുകൾ ഈ പ്രക്രിയയിൽ ഉപയോഗിക്കുന്നു.


Shared image relationship networks are also important.

പങ്കിട്ട ഇമേജ് ബന്ധ ശൃംഖലകളും പ്രധാനമാണ്.


The strings analysis reveals important information.

സ്ട്രിംഗ് വിശകലനം പ്രധാനപ്പെട്ട വിവരങ്ങൾ വെളിപ്പെടുത്തുന്നു.


Static malware analysis has limitations.

സ്ഥിരമായ മാൽവെയർ വിശകലനത്തിന് പരിമിതികളുണ്ട്.


ട്രോജനുകൾക്ക് കാര്യമായ നാശനഷ്ടം വരുത്താൻ കഴിയും.


Visualization is crucial for understanding data.

ഡാറ്റ മനസ്സിലാക്കാൻ വിഷ്വലൈസേഷൻ അത്യാവശ്യമാണ്.


The x86 assembly language is fundamental.

x86 അസംബ്ലി ഭാഷ അടിസ്ഥാനപരമാണ്.


Machine learning models can be underfit.

മെഷീൻ ലേണിംഗ് മോഡലുകൾ കുറഞ്ഞ ഫിറ്റ് ആയിരിക്കാം.


Deep learning techniques are increasingly used.

ഡീപ് ലേണിംഗ് ടെക്നിക്കുകൾ വർദ്ധിച്ചു വരുന്നു.


ചെയിൻ നിയമം കാൽക്കുലസിൽ ഉപയോഗിക്കുന്നു.