Now we're defining the layers of the packets we will send.

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


We set the TCP options with our just-defined tcpopt.

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


We sent a SYN packet with sr1, which told Scapy to record the reply.

మేము sr1తో SYN ప్యాకెట్‌ను పంపాము, ఇది ప్రత్యుత్తరాన్ని రికార్డ్ చేయమని Scapyకి చెప్పింది.


So, now we're constructing the third part of the handshake, our ACK.

కాబట్టి, ఇప్పుడు మనం హ్యాండ్‌షేక్ యొక్క మూడవ భాగాన్ని, మా ACKని నిర్మిస్తున్నాము.


We use the same port information and switch the flag accordingly.

మేము అదే పోర్ట్ సమాచారాన్ని ఉపయోగిస్తాము మరియు తదనుగుణంగా ఫ్లాగ్‌ను మారుస్తాము.


Now that the TCP session is established, we craft our GET request for the HTTP server.

TCP సెషన్ ఏర్పడిన తర్వాత, మేము HTTP సర్వర్ కోసం మా GET అభ్యర్థనను రూపొందిస్తాము.


Finally, we tidy up, having completed our duty.

చివరగా, మేము మా పనిని పూర్తి చేసి, శుభ్రం చేస్తాము.


In this chapter, we reviewed network access control systems and some of their techniques.

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


We learned how to construct a wireless access point with Kali for a physical drop while masquerading as an authorized IP Phone.

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


We learned how operating system fingerprinting works and developed ways to research signatures for recon and to construct spoofing attacks for a target system, using the iOS running on an iPad as an example.

ఆపరేటింగ్ సిస్టమ్ ఫింగర్‌ప్రింటింగ్ ఎలా పనిచేస్తుందో మరియు రీకాన్ కోసం సంతకాలను పరిశోధించడానికి మరియు ఐప్యాడ్‌లో నడుస్తున్న iOSని ఉదాహరణగా ఉపయోగించి లక్ష్య వ్యవస్థ కోసం స్పూఫింగ్ దాడులను నిర్మించడానికి మార్గాలను మేము నేర్చుకున్నాము.


hostapdలో apd అంటే ఏమిటి?


How can you quickly tell if your wireless card doesn't support access point mode?

మీ వైర్‌లెస్ కార్డ్ యాక్సెస్ పాయింట్ మోడ్‌కు మద్దతు ఇవ్వకపోతే మీరు త్వరగా ఎలా చెప్పగలరు?


What does the hostapd configuration parameter ignore_broadcast_ssid do?

hostapd కాన్ఫిగరేషన్ పరామితి ignore_broadcast_ssid ఏమి చేస్తుంది?


మీరు ARP విషపూరిత దాడిని నడుపుతున్నారు.


What do the first three octets and the last three octets of the MAC address represent, respectively?

MAC చిరునామా యొక్క మొదటి మూడు ఆక్టెట్‌లు మరియు చివరి మూడు ఆక్టెట్‌లు వరుసగా ఏమి సూచిస్తాయి?


MSS మరియు MTU ఒకే పరిమాణంలో ఉన్నాయి.


iptablesలో -j ఫ్లాగ్ ఏమి చేస్తుంది?


You have defined the IP and TCP layers of a specially crafted packet as IP and TCP respectively.

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


I hope I have whetted your appetite for Scapy and Python, because we will be taking these incredibly powerful tools to the next level later in this book.

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


Hands-On Penetration Testing on Windows Unleash Kali Linux, PowerShell, and Windows debugging tools for security testing and analysis.

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


This book takes a hands-on approach to teaching and understanding penetration testing concepts.

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


The reader can thus spend less time searching and more time learning.

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


This book is for penetration testers who want to break out of old routines.

ఈ పుస్తకం పాత పద్ధతుల నుండి బయటపడాలనుకునే పెనెట్రేషన్ టెస్టర్‌ల కోసం.


Chapter 1, Bypassing Network Access Control, focuses on getting a foothold in the network.

అధ్యాయం 1, నెట్‌వర్క్ యాక్సెస్ కంట్రోల్‌ను దాటవేయడం, నెట్‌వర్క్‌లో పాగా వేయడంపై దృష్టి పెడుతుంది.


Chapter 2, Sniffing and Spoofing, will discuss advanced Wireshark techniques.

అధ్యాయం 2, స్నిఫింగ్ మరియు స్పూఫింగ్, అధునాతన వైర్‌షార్క్ పద్ధతులను చర్చిస్తుంది.


We cover software-update hijacking, SSL stripping, and routers.

మేము సాఫ్ట్‌వేర్-అప్‌డేట్ హైజాకింగ్, SSL స్ట్రిప్పింగ్ మరియు రౌటర్‌లను కవర్ చేస్తాము.


Attacking message integrity via bit-flipping is demonstrated against the AES implementation.

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


Chapter 6, Advanced Exploitation with Metasploit, will take the reader to the next level.

అధ్యాయం 6, మెటాస్ప్లోయిట్‌తో అధునాతన దోపిడీ, పాఠకుడిని తదుపరి స్థాయికి తీసుకెళుతుంది.


An introduction to stack overflow attacks is demonstrated step by step.

స్టాక్ ఓవర్‌ఫ్లో దాడులకు పరిచయం దశల వారీగా ప్రదర్శించబడుతుంది.


The reader will understand the fundamentals of kernel exploitation.

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


Chapter 9, Weaponizing Python, is a crash course in Python.

అధ్యాయం 9, పైథాన్‌ను ఆయుధంగా మార్చడం, పైథాన్‌లో ఒక క్రష్ కోర్సు.


We demonstrate heap spraying with step-by-step explanations.

మేము దశల వారీ వివరణలతో హీప్ స్ప్రేయింగ్‌ను ప్రదర్శిస్తాము.


The mechanisms discussed are Data Execution Prevention (DEP) and Address Space Layout Randomization (ASLR).

చర్చించిన విధానాలు డేటా ఎగ్జిక్యూషన్ ప్రివెన్షన్ (DEP) మరియు అడ్రస్ స్పేస్ లేఅవుట్ రాండమైజేషన్ (ASLR).


The reader will have hands-on experience with trial and error fuzzing applications.

పాఠకుడు ట్రయల్ అండ్ ఎర్రర్ ఫజింగ్ అప్లికేషన్‌లతో ప్రత్యక్ష అనుభవం కలిగి ఉంటాడు.


Chapter 13, Going Beyond the Foothold, explores the post-exploitation modules of Metasploit.

అధ్యాయం 13, ఫుట్‌హోల్డ్‌ను మించి, మెటాస్ప్లోయిట్ యొక్క పోస్ట్-ఎక్స్‌ప్లోయిటేషన్ మాడ్యూల్స్‌ను అన్వేషిస్తుంది.


We then cover enumeration on the compromised Windows host.

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


Chapter 14, Taking PowerShell to the Next Level, guides the reader through PowerShell fundamentals.

అధ్యాయం 14, పవర్‌షెల్‌ను తదుపరి స్థాయికి తీసుకెళ్లడం, పాఠకుడిని పవర్‌షెల్ ప్రాథమిక అంశాల ద్వారా నడిపిస్తుంది.


Escalating your agent to SYSTEM via access token theft.

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


పవర్‌స్ప్లోయిట్‌తో యాక్సెస్‌ను నిర్వహించడం.


This book makes a few assumptions about the reader.

ఈ పుస్తకం పాఠకుడి గురించి కొన్ని విషయాలు ఊహిస్తుంది.


You should have a solid understanding of networking essentials.

మీరు నెట్‌వర్కింగ్ యొక్క ముఖ్య విషయాలపై మంచి అవగాహన కలిగి ఉండాలి.


We won't cover getting your OS installed.

మీ OSని ఎలా ఇన్‌స్టాల్ చేయాలో మేము కవర్ చేయము.


Download the example code files from your account at www.packtpub.com.

మీరు www.packtpub.comలో మీ ఖాతా నుండి ఉదాహరణ కోడ్ ఫైల్‌లను డౌన్‌లోడ్ చేసుకోవచ్చు.


If you purchased this book elsewhere, you can visit www.packtpub.com/support.

మీరు ఈ పుస్తకాన్ని మరెక్కడైనా కొనుగోలు చేసి ఉంటే, మీరు www.packtpub.com/supportని సందర్శించవచ్చు.


Enter the name of the book in the Search box and follow the onscreen instructions.

శోధన పెట్టెలో పుస్తకం పేరును నమోదు చేసి, తెరపై సూచనలను అనుసరించండి.


Make sure that you unzip or extract the folder using the latest version of: WinRAR/7-Zip for Windows.

విండోస్ కోసం WinRAR/7-Zip యొక్క తాజా వెర్షన్‌ను ఉపయోగించి మీరు ఫోల్డర్‌ను అన్‌జిప్ లేదా ఎక్స్‌ట్రాక్ట్ చేశారని నిర్ధారించుకోండి.


The code bundle for the book is also hosted on GitHub.

పుస్తకం కోసం కోడ్ బండిల్ GitHubలో కూడా హోస్ట్ చేయబడింది.


In case there's an update to the code, it will be updated on the existing GitHub repository.

కోడ్‌కు ఏదైనా అప్‌డేట్ ఉంటే, అది ఇప్పటికే ఉన్న GitHub రిపోజిటరీలో అప్‌డేట్ చేయబడుతుంది.


We also provide a PDF file that has color images of the screenshots/diagrams used in this book.

ఈ పుస్తకంలో ఉపయోగించిన స్క్రీన్‌షాట్‌లు/రేఖాచిత్రాల రంగు చిత్రాలను కలిగి ఉన్న PDF ఫైల్‌ను కూడా మేము అందిస్తున్నాము.


Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles.

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


Right-click on a target and click Apply as Filter | Selected.

లక్ష్యంపై కుడి-క్లిక్ చేసి, ఫిల్టర్‌గా వర్తించు | ఎంచుకున్నది క్లిక్ చేయండి.


Feedback from our readers is always welcome.

మా పాఠకుల నుండి అభిప్రాయం ఎల్లప్పుడూ స్వాగతించబడుతుంది.


If you have questions about any aspect of this book, please email us at questions@packtpub.com.

ఈ పుస్తకం గురించి మీకు ఏవైనా ప్రశ్నలు ఉంటే, దయచేసి మమ్మల్ని questions@packtpub.comలో సంప్రదించండి.


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

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


The network is the first thing we think about when we imagine computers getting hacked.

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


ఇది పెన్ టెస్టర్ ఆటస్థలం.


The first step is getting on the network in the first place, and there are human, architectural, and protocol factors that make the mere presence of an attacker on the network potentially devastating.

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


For this reason, defenders often deploy network access control (NAC) systems.

ఈ కారణంగా, రక్షకులు తరచుగా నెట్‌వర్క్ యాక్సెస్ కంట్రోల్ (NAC) సిస్టమ్‌లను ఉపయోగిస్తారు.


In this chapter, we will review some of the methods employed by NACs and demonstrate practical methods of bypassing these controls.

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


HTTP ట్రాఫిక్ గుర్తించబడింది.


In this sample, we're testing for any TCP packet destined for port 12345.

ఈ నమూనాలో, పోర్ట్ 12345కి వెళ్ళే ఏదైనా TCP ప్యాకెట్‌ను మేము పరీక్షిస్తున్నాము.


We could write up a Python script that will trigger upon meeting a condition in Ettercap.

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


Killing connections with Ettercap filters

ఎట్టర్‌క్యాప్ ఫిల్టర్‌లతో కనెక్షన్‌లను మూసివేయడం


Let's try to construct a filter to kill SSH and SMTP connections while allowing all other traffic.

మిగిలిన ట్రాఫిక్‌ను అనుమతిస్తూనే SSH మరియు SMTP కనెక్షన్‌లను మూసివేయడానికి ఒక ఫిల్టర్‌ను నిర్మించడానికి ప్రయత్నిద్దాం.


SSH or SMTP communication detected. Killing connection.

SSH లేదా SMTP కమ్యూనికేషన్ గుర్తించబడింది. కనెక్షన్‌ను మూసివేస్తున్నాము.


I would always recommend using this so we know that the filter was triggered.

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


The sender doesn't get any confirmation of receipt, and the recipient never gets it.

పంపినవారు రసీదు యొక్క నిర్ధారణను పొందరు మరియు గ్రహీతకు అది ఎప్పటికీ అందదు.


I save this text file with nano, and I prepare to compile it.

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


Because interpreting code is slow, and we're dealing with analysis and manipulation in the middle of the packet's flight.

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


I connect to our naughty network, and I try to connect to my SSH server at home.

నేను మా కొంటె నెట్‌వర్క్‌కి కనెక్ట్ అవుతాను మరియు నా SSH సర్వర్‌కు ఇంటి నుండి కనెక్ట్ అవ్వడానికి ప్రయత్నిస్తాను.


The connection fails, just as we had planned – but the console starts lighting up with my filter message.

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


We just flooded ourselves with RST packets.

మేము కేవలం RST ప్యాకెట్‌లతో మునిగిపోయాము.


I know what the hacker in you is thinking: we included a kill function in bridged sniffing, so the filter is running on two interfaces and designed to match any packet going to and from SSH which would, by definition, include our RST packets.

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


Getting better – spoofing with BetterCAP

మెరుగవుతోంది - BetterCAPతో స్పోఫింగ్


A common pain point for the pen tester is the wonderfully powerful tool that is no longer supported, so you make do with what was last updated a decade ago.

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


Hey, if it ain't broke, don't fix it – some attacks, like ARP spoofing, don't change over the years at their core.

ఒరేయ్, అది విరిగిపోకపోతే, దాన్ని సరిచేయవద్దు - ARP స్పోఫింగ్ వంటి కొన్ని దాడులు, సంవత్సరాలుగా వాటి కోర్ వద్ద మారవు.


First, we can grab BetterCAP on Kali very easily as it's in the repository:

ముందుగా, ఇది రిపోజిటరీలో ఉన్నందున మనం చాలా సులభంగా కాలిలో BetterCAPని పొందవచ్చు:


Fire up bettercap -h for an introduction to this tool's abilities.

ఈ సాధనం యొక్క సామర్థ్యాలకు పరిచయం కోసం bettercap -hని ప్రారంభించండి.


BetterCAP is not for beginners, for this reason.

ఈ కారణం వల్ల BetterCAP ప్రారంభకులకు కాదు.


The -i flag is the interface; the -t flag is the target; and the -r flag tells arpspoof to poison both sides to make it bidirectional.

-i ఫ్లాగ్ ఇంటర్‌ఫేస్; -t ఫ్లాగ్ లక్ష్యం; మరియు -r ఫ్లాగ్ రెండు వైపులా విషపూరితం చేయడానికి arpspoofని చెబుతుంది, ఇది ద్విదిశాత్మకంగా చేస్తుంది.


When we check back with Wireshark, we can see what an ARP poisoning attack looks like.

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


We can see communication between the victim and the gateway, so now it's a matter of filtering for what you need.

బాధితుడు మరియు గేట్‌వే మధ్య కమ్యూనికేషన్‌ను మనం చూడవచ్చు, కాబట్టి ఇప్పుడు మీకు ఏమి కావాలో ఫిల్టర్ చేయడం ఒక విషయం.


In our demonstration here, we're looking for an authentication to a web portal – likely a POST message.

ఇక్కడ మా ప్రదర్శనలో, మేము వెబ్ పోర్టల్‌కు ప్రమాణీకరణ కోసం చూస్తున్నాము - బహుశా పోస్ట్ సందేశం.


When I find it, I follow the conversation in Wireshark by right-clicking a packet and selecting Follow, and there are the victim's credentials in plain text.

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


We've seen how network access control systems can employ simple MAC address filtering and captive portal authentication to control network access.

నెట్‌వర్క్ యాక్సెస్ కంట్రోల్ సిస్టమ్‌లు నెట్‌వర్క్ యాక్సెస్‌ను నియంత్రించడానికి సాధారణ MAC చిరునామా ఫిల్టరింగ్ మరియు బందీ పోర్టల్ ప్రమాణీకరణను ఎలా ఉపయోగించవచ్చో మనం చూశాము.


Now, suppose that you're coming away from the ARP poisoning attack just described, excited that you scored yourself some legitimate credentials.

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


You try to log in with your Kali box and you're slapped down by a validation check that you hadn't foreseen.

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


You have the correct username and password – how does the NAC know it isn't the legitimate user?

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


NAC vendors quickly figured out that it was a simple matter for anyone to spoof a MAC address, so some systems perform additional verification to match the hardware address to other characteristics of the system.

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


Imagine the difference between authenticating someone by fingerprint alone and authenticating someone by fingerprint, clothing style, vocal patterns, and so on.

ఒక వ్యక్తిని వేలిముద్ర ద్వారా మాత్రమే ప్రమాణీకరించడానికి మరియు వేలిముద్ర, దుస్తుల శైలి, గాత్ర నమూనాలు మొదలైన వాటి ద్వారా ప్రమాణీకరించడానికి మధ్య వ్యత్యాసాన్ని ఊహించండి.


The latter prevents simple spoof attacks.

తరువాత సాధారణ స్ఫూఫ్ దాడులను నిరోధిస్తుంది.


In this context, the NAC is checking that the MAC address matches other characteristics: manufacturer, operating system, and user agent are common checks.

ఈ సందర్భంలో, NAC MAC చిరునామా ఇతర లక్షణాలతో సరిపోలుతుందో లేదో తనిఖీ చేస్తోంది: తయారీదారు, ఆపరేటింగ్ సిస్టమ్ మరియు వినియోగదారు ఏజెంట్ సాధారణ తనిఖీలు.


It turns out that the captive portal knows this Phil user you've just spoofed, and it was expecting an Apple iPad (common in the enterprise as an approved device).

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


Let's review these three checks in detail.

ఈ మూడు తనిఖీలను వివరంగా సమీక్షిద్దాం.


There are two main parts to a MAC address: the first three octets are the Organizationally Unique Identifier (OUI), and the last three octets are Network Interface Controller- specific (NIC-specific).

MAC చిరునామాకు రెండు ప్రధాన భాగాలు ఉన్నాయి: మొదటి మూడు ఆక్టెట్‌లు సంస్థాగతంగా ప్రత్యేకమైన గుర్తింపుదారు (OUI), మరియు చివరి మూడు ఆక్టెట్‌లు నెట్‌వర్క్ ఇంటర్‌ఫేస్ కంట్రోలర్-నిర్దిష్టమైనవి (NIC-నిర్దిష్టమైనవి).


The OUI is important here because it uniquely identifies a manufacturer.

OUI ఇక్కడ ముఖ్యం ఎందుకంటే ఇది తయారీదారుని ప్రత్యేకంగా గుర్తిస్తుంది.


A simple Google search for Apple OUI helps us narrow it down, though you can also pull up the IEEE Registration Authority website directly.

Apple OUI కోసం సాధారణ Google శోధన మనకు తగ్గించడానికి సహాయపడుతుంది, అయితే మీరు నేరుగా IEEE రిజిస్ట్రేషన్ అథారిటీ వెబ్‌సైట్‌ను కూడా పొందవచ్చు.


We quickly find out that 00:21:e9 belongs to Apple, so we can try to spoof a random NIC address with that (for example, 00:21:e9:d2:11:ac).

00:21:e9 ఆపిల్‌కు చెందిందని మేము త్వరగా తెలుసుకుంటాము, కాబట్టి మేము దానితో యాదృచ్ఛిక NIC చిరునామాను స్ఫూఫ్ చేయడానికి ప్రయత్నించవచ్చు (ఉదాహరణకు, 00:21:e9:d2:11:ac).


But again, vendors are already well aware of the fact that MAC addresses are not reliable for filtering, so they're likely going to look for more indicators.

కానీ మళ్ళీ, MAC చిరునామాలు ఫిల్టరింగ్ కోసం నమ్మదగినవి కావు అనే వాస్తవాన్ని విక్రేతలు ఇప్పటికే బాగా తెలుసుకున్నారు, కాబట్టి వారు మరింత సూచికల కోసం చూసే అవకాశం ఉంది.


We want to only see DNS requests for these particular domains.

మేము ఈ నిర్దిష్ట డొమైన్‌ల కోసం DNS అభ్యర్థనలను మాత్రమే చూడాలనుకుంటున్నాము.


సులభంగా చెప్పాలంటే: మనం DNSని మోసగించవలసి ఉంటుంది.


We're also going to need to route local traffic through our interface.

మేము మా ఇంటర్‌ఫేస్ ద్వారా స్థానిక ట్రాఫిక్‌ను కూడా రూట్ చేయాలి.


So, we need to perform a targeted ARP and DNS attack.

కాబట్టి, మనం లక్షిత ARP మరియు DNS దాడిని నిర్వహించాలి.


The format is simple: name, DNS record type, and the host.

ఫార్మాట్ చాలా సులభం: పేరు, DNS రికార్డ్ రకం మరియు హోస్ట్.


This is all we need here, so let's save this file.

ఇక్కడ మనకు కావలసినదంతా ఇదే, కాబట్టి ఈ ఫైల్‌ను సేవ్ చేద్దాం.


Our Ettercap attack is made up of two parts.

మా ఎట్టర్‌క్యాప్ దాడి రెండు భాగాలుగా విభజించబడింది.


First, we kick off Ettercap with a quick and dirty ARP attack command.

ముందుగా, మేము త్వరిత మరియు మురికి ARP దాడి ఆదేశంతో ఎట్టర్‌క్యాప్‌ను ప్రారంభిస్తాము.


Now Ettercap is working on two tasks at once.

ఇప్పుడు ఎట్టర్‌క్యాప్ ఒకేసారి రెండు పనులపై పని చేస్తోంది.


The network trap is now officially primed and ready.

నెట్‌వర్క్ ట్రాప్ ఇప్పుడు అధికారికంగా సిద్ధంగా ఉంది.


ఓహ్ చూడండి, ఒక నవీకరణ అందుబాటులో ఉంది!


This looks no different than a legitimate response.

ఇది చట్టబద్ధమైన ప్రతిస్పందన నుండి భిన్నంగా లేదు.


I'm assuming you didn't forget to set up your reverse connection handler.

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


As soon as the victim executes this program, the meterpreter session is established.

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


The user is likely to suppose some bug occurred.

కొన్ని లోపం జరిగిందని వినియోగదారుడు భావించే అవకాశం ఉంది.


IPv6 is important to the pen tester for two big reasons.

రెండు ప్రధాన కారణాల వల్ల IPv6 పెన్ టెస్టర్‌కు ముఖ్యం.


IPv6 చిరునామా ప్రాథమిక విషయాలు


Consider, on the other hand, the IPv6 address.

మరోవైపు, IPv6 చిరునామాను పరిగణించండి.


రెండు ప్రధాన కంప్రెషన్ నియమాలు ఉన్నాయి.


Looks quite a bit more manageable than the uncompressed address, right?

కంప్రెస్ చేయని చిరునామా కంటే ఇది చాలా నిర్వహించదగినదిగా ఉంది, సరియైనదా?


But if multiple users are finding they consistently can't get documents onto the share, IT will be called.

అయితే, బహుళ వినియోగదారులు పత్రాలను షేర్‌లోకి పొందలేకపోతున్నారని స్థిరంగా గుర్తించినట్లయితే, ITని పిలుస్తారు.


Configuring our SMB listener We have the MSF console up and running, so let's set up our SMB listener.

మా SMB శ్రోతను కాన్ఫిగర్ చేస్తోంది. మేము MSF కన్సోల్‌ను నడుపుతున్నాము, కాబట్టి మా SMB శ్రోతను ఏర్పాటు చేద్దాం.


We run this command at the MSF prompt: use server/capture/smb

మేము MSF ప్రాంప్ట్ వద్ద ఈ ఆదేశాన్ని అమలు చేస్తాము: సర్వర్/క్యాప్చర్/smbని ఉపయోగించండి


Let's take a look at these settings in more detail:

ఈ సెట్టింగ్‌లను మరింత వివరంగా చూద్దాం:


CAINPWFILE defines where captured hashes will be stored, but in the cain format.

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


We aren't using cain, so we leave this blank.

మేము కేన్‌ని ఉపయోగించడం లేదు, కాబట్టి మేము దీన్ని ఖాళీగా ఉంచుతాము.


CHALLENGE defines the server challenge that is sent at the start of the authentication process.

CHALLENGE ప్రమాణీకరణ ప్రక్రియ ప్రారంభంలో పంపబడే సర్వర్ ఛాలెంజ్‌ను నిర్వచిస్తుంది.


Why 1122334455667788? This is simply a common default in password crackers.

ఎందుకు 1122334455667788? ఇది పాస్‌వర్డ్ క్రాకర్లలో సాధారణ డిఫాల్ట్.


Seeing a server challenge of 1122334455667788 during SMB authentication is a dead giveaway that you're playing shenanigans on the network.

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


JOHNPWFILE is the same setting as CAINPWFILE, but for John the Ripper.

JOHNPWFILE అనేది CAINPWFILEతో సమానమైన సెట్టింగ్, కానీ జాన్ ది రిప్పర్ కోసం.


SRVHOST defines the IP address of the listening host.

SRVHOST వినే హోస్ట్ యొక్క IP చిరునామాను నిర్వచిస్తుంది.


ఇది మీ దాడి చేసే పెట్టెను సూచించాలి.


SRVPORT defines the local listening port, and as you can imagine, we'd only change this in special situations.

SRVPORT స్థానిక వినే పోర్ట్‌ను నిర్వచిస్తుంది మరియు మీరు ఊహించినట్లుగా, మేము దీన్ని ప్రత్యేక పరిస్థితులలో మాత్రమే మారుస్తాము.


The challenge/response process described here is NTLMv1.

ఇక్కడ వివరించిన ఛాలెంజ్/రెస్పాన్స్ ప్రక్రియ NTLMv1.


Let's define SRVHOST to the IP address assigned to our interface.

మా ఇంటర్‌ఫేస్‌కు కేటాయించిన IP చిరునామాకు SRVHOSTని నిర్వచిద్దాం.


Even though this isn't technically an exploit, we use the same command to fire off our module.

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


And that is it. It runs in the background so you can keep working.

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


Check out the HTTP method for capturing NTLM authentication.

NTLM ప్రమాణీకరణను సంగ్రహించడానికి HTTP పద్ధతిని చూడండి.


We can open up our John capture file in nano to see the output formatted for cracking:

క్రాకింగ్ కోసం ఫార్మాట్ చేయబడిన అవుట్‌పుట్‌ను చూడటానికి మేము మా జాన్ క్యాప్చర్ ఫైల్‌ను నానోలో తెరవవచ్చు:


In this example, the target is sending us NTLMv1 credentials.

ఈ ఉదాహరణలో, లక్ష్యం మాకు NTLMv1 ఆధారాలను పంపుతోంది.


The reality was that physical access to nodes was tightly controlled.

నిజానికి, నోడ్‌లకు భౌతిక యాక్సెస్ చాలా నియంత్రించబడింది.


We'll touch on IPv6 in this chapter, but we'll also demonstrate practical interfacing of IPv4 with IPv6.

ఈ అధ్యాయంలో, మేము IPv6 గురించి చర్చిస్తాము, కానీ IPv4ని IPv6తో ఎలా ఇంటర్‌ఫేస్ చేయాలో కూడా చూపిస్తాము.


As a pen tester on a job, it's exciting to watch that shell pop up on your system.

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


Remember that your job is to help your client secure their enterprise, and it's about more than just software flaws.

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


In this chapter, we'll be covering the following topics: Using BetterCAP proxying to inject malicious binaries into web traffic.

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


We'll be covering these concepts and tools in more detail later on in the book, so consider this an introduction to the power of custom modules in advanced man-in-the-middle attacks.

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


The code is checking the path of the victim's requested URL for the file extension we define.

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


We'll create a payload designed to connect back to our Kali box where a listener is ready.

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


The options are straightforward: -p defines our payload, in this case, the connect-back meterpreter session.

ఎంపికలు నేరుగా ఉంటాయి: -p మన పేలోడ్‌ను నిర్వచిస్తుంది, ఈ సందర్భంలో, కనెక్ట్-బ్యాక్ మీటర్‌ప్రెటర్ సెషన్.


We have our payload, ready for transmitting.

మేము మా పేలోడ్‌ను కలిగి ఉన్నాము, ప్రసారం చేయడానికి సిద్ధంగా ఉన్నాము.


Make sure LPORT matches what you configured in your payload executable.

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


Meanwhile, our target, 192.168.108.96, is browsing the home page for a tool called PdaNet.

అదే సమయంలో, మా లక్ష్యం, 192.168.108.96, PdaNet అనే సాధనం కోసం హోమ్ పేజీని బ్రౌజ్ చేస్తోంది.


Following are the terms used in the preceding command: -T is our target selection—the system that will be browsing for an installer and hence will receive our payload.

కిందివి మునుపటి కమాండ్‌లో ఉపయోగించిన పదాలు: -T అనేది మా లక్ష్య ఎంపిక—ఇన్‌స్టాలర్‌ను బ్రౌజ్ చేసే సిస్టమ్ మరియు అందువల్ల మా పేలోడ్‌ను అందుకుంటుంది.


Our target downloads the file, and everything looks completely normal on that end – even the filename.

మా లక్ష్యం ఫైల్‌ను డౌన్‌లోడ్ చేస్తుంది మరియు ప్రతిదీ ఆ ముగింపులో పూర్తిగా సాధారణంగా కనిపిస్తుంది – ఫైల్ పేరు కూడా.


On the receiving end, note the filename – precisely what was requested.

స్వీకరించే చివరన, ఫైల్ పేరును గమనించండి – సరిగ్గా ఏమి అభ్యర్థించబడిందో.


But, now look at the file size – it matches our meterpreter payload.

కానీ, ఇప్పుడు ఫైల్ పరిమాణాన్ని చూడండి – ఇది మా మీటర్‌ప్రెటర్ పేలోడ్‌తో సరిపోతుంది.


Everything is essentially untouched except for the binary payload; no cloning sites and spoofing DNS required, making this a particularly quiet attack.

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


I know what the hacker in you is thinking: I thought SSL strip was dead, thanks to HTTP Strict Transport Security (HSTS).

మీలోని హ్యాకర్ ఏమనుకుంటున్నారో నాకు తెలుసు: HTTP స్ట్రిక్ట్ ట్రాన్స్‌పోర్ట్ సెక్యూరిటీ (HSTS) కారణంగా SSL స్ట్రిప్ చనిపోయిందని నేను అనుకున్నాను.


HSTS is an industry response to the sslstrip HTTP downgrading attack.

HSTS అనేది sslstrip HTTP డౌన్‌గ్రేడింగ్ దాడికి పరిశ్రమ ప్రతిస్పందన.


Suppose my browser already has an HSTS header for www.example.com – it does not have an entry for wwww.example.com.

నా బ్రౌజర్‌లో ఇప్పటికే www.example.com కోసం HSTS హెడర్ ఉందని అనుకోండి – దీనికి wwww.example.com కోసం ఎంట్రీ లేదు.


I'm going to tell the world that I'm an elite hacker and I'm going to repeat the message over and over again – you know, for emphasis.

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


A solid encrypted message should be indistinguishable from random data, so my work here is done.

ఘనమైన గుప్తీకరించబడిన సందేశం యాదృచ్ఛిక డేటా నుండి వేరుగా ఉండకూడదు, కాబట్టి ఇక్కడ నా పని పూర్తయింది.


In the realm of cryptanalysis, this is a major breakthrough.

క్రిప్టోనాలసిస్ రంగంలో, ఇది ఒక ప్రధాన పురోగతి.


A simple rule of thumb about good encryption is: the ciphertext should have no relationship whatsoever with the plaintext.

మంచి ఎన్‌క్రిప్షన్ గురించి ఒక సాధారణ నియమం ఏమిటంటే: సైఫర్‌టెక్స్ట్ ప్లెయిన్‌టెక్స్ట్‌తో ఎటువంటి సంబంధం కలిగి ఉండకూడదు.


With ECB, we were at the mercy of our plaintext because each block has its own thing going on.

ECBతో, ప్రతి బ్లాక్ దాని స్వంత పనిని కలిగి ఉన్నందున, మేము మా ప్లెయిన్‌టెక్స్ట్ దయతో ఉన్నాము.


Enter Cipher Block Chaining (CBC), where we encrypt a block just like before – except before we encrypt the next block, we XOR the plaintext of the next block with the encrypted output of the previous block, creating a logical chain of blocks.

సైఫర్ బ్లాక్ చైనింగ్ (CBC)ని నమోదు చేయండి, ఇక్కడ మేము మునుపటిలాగే ఒక బ్లాక్‌ను గుప్తీకరిస్తాము - తదుపరి బ్లాక్‌ను గుప్తీకరించడానికి ముందు, మేము తదుపరి బ్లాక్ యొక్క ప్లెయిన్‌టెక్స్ట్‌ను మునుపటి బ్లాక్ యొక్క గుప్తీకరించబడిన అవుట్‌పుట్‌తో XOR చేస్తాము, తద్వారా బ్లాక్‌ల యొక్క తార్కిక గొలుసును సృష్టిస్తాము.


Yes, we need an initial value – appropriately called the initialization vector (IV).

అవును, మనకు ప్రారంభ విలువ అవసరం - తగిన విధంగా ప్రారంభీకరణ వెక్టర్ (IV) అని పిలుస్తారు.


With CBC, security is highly reliant on that IV.

CBCతో, భద్రత ఎక్కువగా ఆ IVపై ఆధారపడి ఉంటుంది.


We'll do one more openssl demonstration with CBC, but we'll repeat the IV.

మేము CBCతో మరొక openssl ప్రదర్శన చేస్తాము, కానీ మేము IVని పునరావృతం చేస్తాము.


We're going to attack a web application to pull off the bit-flipping attack.

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


I like to host Mutillidae II on the XAMPP server stack as initial setup is fast and easy, and it's a powerful combination; however, if you're comfortable loading it into whatever web server solution you have, go for it.

ప్రారంభ సెటప్ వేగంగా మరియు సులభంగా ఉన్నందున నేను Mutillidae IIని XAMPP సర్వర్ స్టాక్‌లో హోస్ట్ చేయడానికి ఇష్టపడతాను మరియు ఇది ఒక శక్తివంతమైన కలయిక; అయితే, మీరు దీన్ని మీ వద్ద ఉన్న ఏదైనా వెబ్ సర్వర్ సొల్యూషన్‌లోకి లోడ్ చేయడానికి సౌకర్యంగా ఉంటే, దాని కోసం వెళ్ళండి.


Run ./lampp start and then visit your IP address in a browser.

./lampp startని అమలు చేయండి మరియు ఆపై మీ IP చిరునామాను బ్రౌజర్‌లో సందర్శించండి.


We need to be user 000 in group 000 to become the almighty root user.

అన్నింటినీ శాసించే రూట్ యూజర్ కావడానికి మనం గ్రూప్ 000లో యూజర్ 000గా ఉండాలి.


We've seen how the IV is XOR with the plaintext before encryption to create the encrypted block, so manipulating the IV would necessarily change the encrypted output.

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


We know that it's hexadecimal and it's 32 characters long; thus the length is 128 bits.

ఇది హెక్సాడెసిమల్ అని మరియు ఇది 32 అక్షరాల పొడవు అని మనకు తెలుసు; అందువలన పొడవు 128 బిట్స్.


Remember when we experimented with CBC encryption with openssl?

మేము opensslతో CBC గుప్తీకరణతో ప్రయోగాలు చేసినప్పుడు గుర్తుందా?


We used AES, which always has a 128-bit block size.

మేము AESని ఉపయోగించాము, ఇది ఎల్లప్పుడూ 128-బిట్ బ్లాక్ పరిమాణాన్ని కలిగి ఉంటుంది.


Remember that any plaintext block that's shorter than the algorithm's block size must be padded.

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


We can sit here analyzing all day but by now you've figured out I like breaking things, so let's modify the IV in the URL, submit it, and see if anything happens.

మనం రోజంతా ఇక్కడ కూర్చుని విశ్లేషించవచ్చు, కానీ అప్పటికే నేను విషయాలను విచ్ఛిన్నం చేయడం ఇష్టపడతానని మీరు కనుగొన్నారు, కాబట్టి URLలో IVని సవరించండి, సమర్పించండి మరియు ఏదైనా జరుగుతుందో లేదో చూద్దాం.


We figured out that the application is taking this byte of the IV and XORing it with 0010 1010 during decryption.

అప్లికేషన్ ఈ IV యొక్క బైట్‌ను తీసుకుంటుందని మరియు డీక్రిప్షన్ సమయంలో దానిని 0010 1010తో XOR చేస్తుందని మేము కనుగొన్నాము.


Then I click the test link again in the CryptOMG page to create a new GET request to be intercepted by Burp Suite.

తర్వాత, నేను Burp Suite ద్వారా అడ్డగించబడే కొత్త GET అభ్యర్థనను రూపొందించడానికి CryptOMG పేజీలో మళ్ళీ పరీక్ష లింక్‌ను క్లిక్ చేస్తాను.


When I see it, I right-click on it and send it to Intruder.

నేను చూసినప్పుడు, నేను దానిపై కుడి-క్లిక్ చేసి, Intruderకి పంపుతాను.


Intruder is an aggressive tool for firing off requests with custom parameters that I define – these custom parameters are called payloads.

Intruder అనేది నేను నిర్వచించే అనుకూల పారామితులతో అభ్యర్థనలను పంపడానికి ఒక దూకుడు సాధనం – ఈ అనుకూల పారామితులను పేలోడ్‌లు అంటారు.


Simply highlight the text that you want to substitute with payloads and click the Add button at the right.

మీరు పేలోడ్‌లతో భర్తీ చేయాలనుకుంటున్న వచనాన్ని ఎంచుకుని, కుడివైపున ఉన్న జోడించు బటన్‌ను క్లిక్ చేయండి.


We already know our algorithm is SHA-1 and we aren't changing that, so I've only defined file= and hash= as payload positions:

మా అల్గారిథం SHA-1 అని మనకు ఇప్పటికే తెలుసు మరియు మేము దానిని మార్చడం లేదు, కాబట్టి నేను file= మరియు hash=లను మాత్రమే పేలోడ్ స్థానాలుగా నిర్వచించాను:


Now, we click on the Payloads tab so we can define what's going to be placed in those payload positions we just defined.

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


For this part, you'll need to do a little preparation first.

ఈ భాగానికి, మీరు మొదట కొంచెం ప్రిపరేషన్ చేయాలి.


You need two separate lists for each payload position.

మీకు ప్రతి పేలోడ్ స్థానానికి రెండు వేర్వేరు జాబితాలు అవసరం.


Hash extender gave us everything we need, but in a space-delimited text file.

Hash extender మనకు అవసరమైన ప్రతిదీ ఇచ్చింది, కానీ స్పేస్-డీలిమిటెడ్ టెక్స్ట్ ఫైల్‌లో.


How you separate those columns is up to you (one method is using spreadsheet software).

ఆ కాలమ్‌లను మీరు ఎలా వేరు చేస్తారనేది మీ ఇష్టం (ఒక పద్ధతి స్ప్రెడ్‌షీట్ సాఫ్ట్‌వేర్‌ను ఉపయోగించడం).


I define the payload sets in order of position; for example, since the file= parameter is the first position I encounter reading from left to right, I make the list of attacker data Payload set 1.

నేను స్థానం ప్రకారం పేలోడ్ సెట్‌లను నిర్వచిస్తాను; ఉదాహరణకు, file= పరామితి ఎడమ నుండి కుడికి చదివేటప్పుడు నేను ఎదుర్కొనే మొదటి స్థానం కాబట్టి, నేను దాడి చేసే డేటా జాబితాను పేలోడ్ సెట్ 1గా చేస్తాను.


Then, my list of hashes goes in Payload set 2.

అప్పుడు, నా హాష్‌ల జాబితా పేలోడ్ సెట్ 2లో వెళుతుంది.


ఇప్పుడు, సరదా ప్రారంభం కావచ్చు – ఆయుధాలు స్వేచ్ఛగా!


Kick back with a cup of coffee as intruder fires off GET request after GET request, each one with customized parameters based on our payload definitions.

Intruder GET అభ్యర్థన తర్వాత GET అభ్యర్థనను పంపినప్పుడు ఒక కప్పు కాఫీతో రిలాక్స్ అవ్వండి, ప్రతి ఒక్కటి మా పేలోడ్ నిర్వచనాల ఆధారంగా అనుకూలీకరించిన పారామితులతో.


So what happens if a particular filename and verification hash combination is wrong?

ఒక నిర్దిష్ట ఫైల్‌పేరు మరియు ధృవీకరణ హాష్ కలయిక తప్పు అయితే ఏమి జరుగుతుంది?


We just get a File Not Found error – in HTTP status code terms, a 404.

మేము కేవలం ఫైల్ కనుగొనబడలేదు లోపం పొందుతాము – HTTP స్థితి కోడ్ పరంగా, 404.


A total of 27 requests later, check out our status column — we received an HTTP 200 code.

మొత్తం 27 అభ్యర్థనల తర్వాత, మా స్థితి కాలమ్‌ను చూడండి — మేము HTTP 200 కోడ్‌ను అందుకున్నాము.


Bingo, we created a malicious request and had the hash verified.

బింగో, మేము ఒక హానికరమైన అభ్యర్థనను సృష్టించాము మరియు హాష్ ధృవీకరించబడింది.


Let's click the Response tab and revel in the treasures of our find.

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


Uh oh: failed to open stream: No such file or directory?

అయ్యో: స్ట్రీమ్ తెరవడంలో విఫలమైంది: అలాంటి ఫైల్ లేదా డైరెక్టరీ లేదు?


The program prevents timeout while the payload is being read.

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


Creating nested payloads allows for a single attack with multiple components.

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


We're going to prepare a demonstration for a client.

మేము ఒక క్లయింట్ కోసం ఒక ప్రదర్శనను సిద్ధం చేయబోతున్నాము.


The payload will display a message to the user.

పేలోడ్ వినియోగదారునికి ఒక సందేశాన్ని ప్రదర్శిస్తుంది.


We've now set the target architecture and platform to 32-bit Windows.

మేము ఇప్పుడు లక్ష్య ఆర్కిటెక్చర్ మరియు ప్లాట్‌ఫారమ్‌ను 32-బిట్ విండోస్‌కు సెట్ చేసాము.


The format is raw binary as we're going to import it into the next command.

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


The second payload is windows/meterpreter_reverse_tcp.


Be mindful that this is just a demonstration.

ఇది కేవలం ఒక ప్రదర్శన మాత్రమేనని గుర్తుంచుకోండి.


Combining payloads is bound to put bad characters into your masterpiece.

పేలోడ్‌లను కలపడం మీ కళాఖండంలో చెడు అక్షరాలను ఉంచడానికి బద్ధమై ఉంది.


You should confirm your result in a test environment.

మీరు మీ ఫలితాన్ని పరీక్షా పరిసరాలలో నిర్ధారించాలి.


Let's take a look at the following steps.

కింది దశలను పరిశీలిద్దాం.


ముందుగా, మనం షెల్టర్ ప్రారంభించాలి.


మేము ఇక్కడ ఆటోమోడ్‌ని ఉపయోగిస్తాము.


Next, we need to identify the executable that we're going to backdoor.

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


A best practice is to use an executable that is able to stand alone.

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


You should also verify that the program is considered clean by antivirus engines.

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


For our demonstration, we're going to work with Windows' classic card game, Spider.

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


After identifying the executable into which we're injecting our payload, we enter Stealth Mode.

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


Shellter will ask you if you have a custom payload.

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


In our case, we're establishing a connect-back meterpreter session.

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


msfvenom will be needed, which msfvenom can find for you.

మీకు msfvenom అవసరం, msfvenom మీ కోసం కనుగొనగలదు.


We should now have two files in the root folder: the executable and a 325-byte binary file called message.

ఇప్పుడు మనకు రూట్ ఫోల్డర్‌లో రెండు ఫైల్‌లు ఉండాలి: ఎగ్జిక్యూటబుల్ మరియు సందేశం అని పిలువబడే 325-బైట్ బైనరీ ఫైల్.


ఇప్పుడు, రహస్య మోడ్‌లో షెల్టర్‌ను ప్రారంభించండి.


This requires the same process we looked at earlier on in the chapter until we need to specify our custom payload.

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


Now, Shellter is going to spit out DataRecovery.exe and a quick sha1sum command will soon confirm the binary has been modified.

ఇప్పుడు, షెల్టర్ DataRecovery.exeని అందిస్తుంది మరియు శీఘ్ర sha1sum ఆదేశం బైనరీ మార్పు చేయబడిందని త్వరలో నిర్ధారిస్తుంది.


So, what do we have now? A data recovery tool that displays a message box to us—that's it.

కాబట్టి, ఇప్పుడు మన దగ్గర ఏమి ఉంది? మనకు సందేశ పెట్టెను ప్రదర్శించే డేటా రికవరీ సాధనం—అంతే.


Now we have the nested payload, we simply send the new binary through Shellter one more time.

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


This time, however, we select the number 1 stager on the list of included payloads: the reverse TCP meterpreter payload.

అయితే, ఈసారి, చేర్చబడిన పేలోడ్‌ల జాబితాలో 1వ స్టేజర్‌ను ఎంచుకుంటాము: రివర్స్ TCP మీటర్‌ప్రిటర్ పేలోడ్.


Now, we have a complete Trojan that's ready to rock.

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


The program is a legitimate data recovery utility that pops up an advisory warning users that deleted data has been detected.

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


When you configure your handler, always configure EXITFUNC as thread.

మీరు మీ హ్యాండ్లర్‌ను కాన్ఫిగర్ చేసినప్పుడు, ఎల్లప్పుడూ EXITFUNCని థ్రెడ్‌గా కాన్ఫిగర్ చేయండి.


If you don't, the meterpreter session will die when the Trojan does!

మీరు చేయకపోతే, ట్రోజన్ చేసినప్పుడు మీటర్‌ప్రిటర్ సెషన్ ముగుస్తుంది!


There are just two steps left: one that's technical (though very simple), and one that's purely for us humans.

ఇంకా రెండు దశలు మాత్రమే మిగిలి ఉన్నాయి: ఒకటి సాంకేతికం (చాలా సులభం), మరొకటి మన మానవుల కోసం మాత్రమే.


Let's start with the technical step, which is creating the autorun file:

ఆటోరన్ ఫైల్‌ను సృష్టించడం ద్వారా సాంకేతిక దశతో ప్రారంభిద్దాం:


This really is as simple as creating a text file called autorun.inf that points to our executable.

ఇది నిజంగానే మన ఎగ్జిక్యూటబుల్‌కు సూచించే autorun.inf అనే టెక్స్ట్ ఫైల్‌ను సృష్టించడం అంత సులభం.


It must start with the line [autorun], with the file to open identified by open=.

ఇది [autorun] అనే లైన్‌తో ప్రారంభం కావాలి, తెరవడానికి ఫైల్‌ను open= ద్వారా గుర్తించాలి.


You can also add the icon= command, which will make the drive appear as the executable's icon (or any other icon you define), shown as follows:

మీరు icon= ఆదేశాన్ని కూడా జోడించవచ్చు, ఇది డ్రైవ్ ఎగ్జిక్యూటబుల్ యొక్క చిహ్నంగా (లేదా మీరు నిర్వచించిన ఏదైనా ఇతర చిహ్నం) కనిపించేలా చేస్తుంది, ఇది క్రింది విధంగా చూపబడుతుంది:


Now, it's time for the social engineering part.

ఇప్పుడు, ఇది సామాజిక ఇంజనీరింగ్ సమయం.


ఆటోరన్ పని చేయకపోతే?


After all, it is disabled on a lot of systems these days.

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


The printf function then displays our message.

అప్పుడు ప్రింట్ఫ్ ఫంక్షన్ మన సందేశాన్ని ప్రదర్శిస్తుంది.


The input is small, so we shouldn't expect any issues.

ఇన్పుట్ చిన్నది, కాబట్టి మనం ఎటువంటి సమస్యలను ఆశించకూడదు.


Let's take a look at what happens if we hold down the z key before submitting the input.

ఇన్పుట్ సమర్పించే ముందు z కీని నొక్కి ఉంచితే ఏమవుతుందో చూద్దాం.


ఒక విభజన లోపం ఉంది.


The program has been broken by us putting in too much data.

మనం ఎక్కువ డేటాను ఉంచడం ద్వారా ప్రోగ్రామ్ విచ్ఛిన్నమైంది.


The program is simple and quite literally does nothing, but still has a main function regardless.

ప్రోగ్రామ్ చాలా సులభం మరియు అక్షరాలా ఏమీ చేయదు, కానీ ఇప్పటికీ ఒక ప్రధాన ఫంక్షన్ ఉంది.


At some point, this function is called where a buffer is set aside for it.

ఒక సమయంలో, ఈ ఫంక్షన్ పిలువబడుతుంది, అక్కడ దాని కోసం ఒక బఫర్ పక్కన పెట్టబడుతుంది.


Once everything is popped back off the stack, we'll be left with a return pointer.

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


If this points to somewhere invalid, the program crashes.

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


Let's load our program into GDB and see what's going on behind the curtain.

మన ప్రోగ్రామ్‌ను GDB లోకి లోడ్ చేసి, తెర వెనుక ఏమి జరుగుతుందో చూద్దాం.


We'll issue the run command with our initial test input and then examine the registers.

మేము మా ప్రారంభ పరీక్ష ఇన్పుట్‌తో రన్ కమాండ్ ఇస్తాము, ఆపై రిజిస్టర్‌లను పరిశీలిస్తాము.


As we can see in the preceding screenshot, esp and ebp are right next to each other.

మునుపటి స్క్రీన్షాట్లో మనం చూడగలిగినట్లుగా, esp మరియు ebp ఒకదానికొకటి పక్కపక్కనే ఉన్నాయి.


Working from esp, let's find the return address.

esp నుండి పని చేస్తూ, రిటర్న్ చిరునామాను కనుగొందాం.


We know that we start at the esp, but how far do we look in memory?

మేము esp వద్ద ప్రారంభమవుతామని మాకు తెలుసు, కాని మనం మెమరీలో ఎంత దూరం చూడాలి?


If you find the base pointer address and then identify the hexadecimal word right after it, you will get the return address.

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


This time, we will crash our program with a long string of the letter z.

ఈసారి, మేము z అక్షరం యొక్క పొడవైన స్ట్రింగ్‌తో మా ప్రోగ్రామ్‌ను క్రాష్ చేస్తాము.


Take a look at the memory address the function is trying to jump to.

ఫంక్షన్ జంప్ చేయడానికి ప్రయత్నిస్తున్న మెమరీ చిరునామాను చూడండి.


We overflowed the buffer and replaced the return address!

మేము బఫర్‌ను ఓవర్‌ఫ్లో చేసాము మరియు రిటర్న్ చిరునామాను భర్తీ చేసాము!


Our computer is very angry with us about this because 0x7a7a7a7a either doesn't exist or we have no business jumping there.

దీని గురించి మా కంప్యూటర్ మాతో చాలా కోపంగా ఉంది, ఎందుకంటే 0x7a7a7a7a ఉనికిలో లేదు లేదా అక్కడకు వెళ్లడానికి మాకు వ్యాపారం లేదు.


In the world of computing, it turns out that not everyone agrees on how bytes should be ordered in memory.

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


This is a local attack; the only IP address you'll define is the return for your reverse TCP connection back to the handler.

ఇది ఒక స్థానిక దాడి; మీరు నిర్వచించే ఏకైక IP చిరునామా ఏమిటంటే, మీ రివర్స్ TCP కనెక్షన్ హ్యాండ్లర్‌కు తిరిగి వస్తుంది.


To complete this demo, you'll need to establish the foothold first!

ఈ డెమోను పూర్తి చేయడానికి, మీరు మొదట ఫుట్‌హోల్డ్‌ను ఏర్పాటు చేసుకోవాలి!


Perhaps your target needs to update some software?

బహుశా మీ లక్ష్యం కొన్ని సాఫ్ట్‌వేర్‌ను అప్‌డేట్ చేయాలా?


At this point, you've just received your meterpreter connection back from the target: your foothold payload did the trick.

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


హ్మ్, వినియోగదారు పేరు Yokwe తిరిగి వస్తుంది.


Even an administrator can't get away with certain things – that account is still considered user mode.

ఒక నిర్వాహకుడు కూడా కొన్ని విషయాలను వదిలివేయలేడు - ఆ ఖాతా ఇప్పటికీ వినియోగదారు మోడ్‌గా పరిగణించబడుతుంది.


I type background to send my meterpreter session into the background so I can work at the msf prompt.

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


This time, we prepare our kernel attack with use exploit/windows/local/ms14_058_track_popup_menu:

ఈసారి, మేము exploit/windows/local/ms14_058_track_popup_menuని ఉపయోగించి మా కెర్నల్ దాడిని సిద్ధం చేస్తాము:


When you establish the exploit and run this command, you'll see the sessions option.

మీరు ఎక్స్‌ప్లాయిట్‌ను ఏర్పాటు చేసి, ఈ ఆదేశాన్ని అమలు చేసినప్పుడు, మీరు సెషన్స్ ఎంపికను చూస్తారు.


At the msf prompt, use sessions -l to identify the session you need.

msf ప్రాంప్ట్‌లో, మీకు అవసరమైన సెషన్‌ను గుర్తించడానికి సెషన్స్ -lని ఉపయోగించండి.


This can be a little confusing to set up, as you're just coming back from configuring your handler with a payload.

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


When you're ready, fire off run and cross your fingers.

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


In our demo, our Windows 7 Ultimate host was indeed vulnerable.

మా డెమోలో, మా Windows 7 అల్టిమేట్ హోస్ట్ నిజంగానే దుర్బలంగా ఉంది.


We are now running as SYSTEM. Game over.

మేము ఇప్పుడు SYSTEMగా నడుస్తున్నాము. ఆట ముగిసింది.


In this chapter, we explored Windows kernel attacks.

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


We picked a vulnerability type, the NULL or invalid pointer dereference vulnerability, and studied it in detail to understand how exploiting the kernel in this way gives the attacker full control of the system.

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


In C, the ampersand operator before a variable references __________. 3.

Cలో, వేరియబుల్ ముందు ఉన్న యాంప్‌సండ్ ఆపరేటర్ సూచిస్తుంది __________. 3.


3 క్వాడ్‌వర్డ్‌లలో ఎన్ని DWORDS సరిపోతాయి?4.


It is not possible to dereference an invalid pointer. (True | False)6.

చెల్లని పాయింటర్‌ను డీరెఫరెన్స్ చేయడం సాధ్యం కాదు. (నిజం | తప్పు)6.


My hexadecimal-to-decimal calculator says that ffffffff is equal to 4,294,967,295. Why does the xxxSendMessage() function think it's a -1?

నా హెక్సాడెసిమల్-టు-డెసిమల్ కాలిక్యులేటర్ ffffffff 4,294,967,295కి సమానమని చెబుతోంది. xxxSendMessage() ఫంక్షన్ ఇది -1 అని ఎందుకు అనుకుంటుంది?


Thankfully, modern operating systems are typically preemptive.

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


In fact, in the case of Windows, the kernel itself is preemptive – this simply means that even tasks running in kernel mode can be interrupted.

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


Even young children can grasp one of the fundamental rules of existence: events don't always happen at once, and you often have to wait for something to happen.

చిన్న పిల్లలు కూడా ఉనికి యొక్క ప్రాథమిక నియమాలలో ఒకదాన్ని అర్థం చేసుకోగలరు: సంఘటనలు ఎల్లప్పుడూ ఒకేసారి జరగవు మరియు మీరు తరచుగా ఏదో జరిగే వరకు వేచి ఉండాలి.


You have to go to school for a whole week before the fun of the weekend starts.

వారాంతపు సరదా ప్రారంభించడానికి ముందు మీరు ఒక వారం పాటు పాఠశాలకు వెళ్ళాలి.


Even at the extraordinarily small scale of the tiny slices of time used in context switching and scheduling, sometimes we have to wait around for something to happen before we can proceed.

సందర్భ మార్పిడి మరియు షెడ్యూలింగ్‌లో ఉపయోగించే చిన్న సమయ విభాగాల అసాధారణంగా చిన్న స్థాయిలో కూడా, కొన్నిసార్లు మనం కొనసాగడానికి ముందు ఏదో జరిగే వరకు వేచి ఉండాలి.


Programmers and reverse engineers alike will see these time-dependent constructs in code: Grab the value of variable VAR; use an if/then statement to establish a condition1. based on this fetched value Grab the value of variable VAR; use it in a function according to the condition(s)2. established in step 1 Grab the value of variable VAR; use it in a function according to the condition(s)3. established in step 1 and step 2 and so on

ప్రోగ్రామర్లు మరియు రివర్స్ ఇంజనీర్లు కోడ్‌లో ఈ సమయం-ఆధారిత నిర్మాణాలను చూస్తారు: వేరియబుల్ VAR యొక్క విలువను పొందండి; ఈ ఫెచ్ చేయబడిన విలువ ఆధారంగా కండిషన్1ని స్థాపించడానికి if/then స్టేట్‌మెంట్‌ను ఉపయోగించండి. వేరియబుల్ VAR యొక్క విలువను పొందండి; దశ 1లో స్థాపించబడిన కండిషన్(ల)2 ప్రకారం ఫంక్షన్‌లో ఉపయోగించండి వేరియబుల్ VAR యొక్క విలువను పొందండి; దశ 1 మరియు దశ 2లో స్థాపించబడిన కండిషన్(ల)3 ప్రకారం ఫంక్షన్‌లో ఉపయోగించండి మరియు మొదలైనవి


Imagine if we could create a condition that would cause these dependencies to occur out of their prescribed order.

ఈ ఆధారపడటాలు వాటి నిర్దేశిత క్రమం నుండి బయటకు రావడానికి కారణమయ్యే ఒక పరిస్థితిని మనం సృష్టించగలిగితే ఊహించండి.


For example, what if I could cause step 2 to happen first?

ఉదాహరణకు, నేను మొదట దశ 2 జరిగేలా చేస్తే ఏమిటి?


In this case, the code is expecting a condition to have been established already.

ఈ సందర్భంలో, కోడ్ ఇప్పటికే ఒక పరిస్థితి ఏర్పడిందని ఆశిస్తోంది.


An attacker may thus trigger an exploit by racing against the established order – this is called a race condition.

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


From a security perspective, one of the most crucial points to understand about the kernel is that it's technically a program made up of code.

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


Crashing the kernel results in an irrecoverable situation (namely, requires a reboot), whereas crashing a user application just requires restarting the application – so, exploring kernel attacks is more precarious and there is far less room for mistakes.

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


It's still just a computer program, though.

అయినప్పటికీ, ఇది ఇప్పటికీ ఒక కంప్యూటర్ ప్రోగ్రామ్ మాత్రమే.


I emphasize this because we can understand the kernel attack in this chapter from a programmer's perspective.

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


The kernel is written in a mix of assembly and C (which is useful due to its low-level interface ability), so let's take a look at a basic programming concept from a C and assembly point of view before we dive into exploiting our Windows target.

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


Pointing out the problem – pointer issues Programming languages make use of different data types: numeric types such as integers, Boolean types to convey true and false, sets and arrays as composite data types; and so on.

సమస్యను ఎత్తి చూపుతోంది – పాయింటర్ సమస్యలు ప్రోగ్రామింగ్ భాషలు వివిధ డేటా రకాలను ఉపయోగిస్తాయి: పూర్ణాంకాల వంటి సంఖ్యా రకాలు, నిజం మరియు తప్పును తెలియజేయడానికి బూలియన్ రకాలు, సమితులు మరియు శ్రేణులు మిశ్రమ డేటా రకాలుగా; మరియు మొదలైనవి.


Pointers are yet another kind of data type: a reference.

పాయింటర్‌లు మరొక రకమైన డేటా రకం: ఒక సూచన.


References are values that refer to data indirectly.

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


For example, suppose I have a book with a map of each of the United States, on each page.

ఉదాహరణకు, ప్రతి పేజీలో యునైటెడ్ స్టేట్స్ యొక్క ప్రతి మ్యాప్ ఉన్న ఒక పుస్తకం నా దగ్గర ఉందని అనుకోండి.


If someone asks me where I live, I could say page 35 – an indirect reference to the data (the state map) on that particular page.

ఎవరైనా నేను ఎక్కడ నివసిస్తున్నానని అడిగితే, నేను పేజీ 35 అని చెప్పగలను – ఆ నిర్దిష్ట పేజీలోని డేటాకు (రాష్ట్ర పటం) పరోక్ష సూచన.


Calling socket.socket() creates a Python object.

socket.socket() ని పిలవడం వలన ఒక పైథాన్ వస్తువు ఏర్పడుతుంది.


The socket is low-level enough that we need to let it know what address family we're using.

సాకెట్ చాలా తక్కువ స్థాయిలో ఉంది, మనం ఏ అడ్రస్ ఫ్యామిలీని ఉపయోగిస్తున్నామో దానికి తెలియజేయాలి.


AF_INET designates an address family, and INET refers to IPv4.

AF_INET ఒక చిరునామా కుటుంబాన్ని సూచిస్తుంది, మరియు INET IPv4 ని సూచిస్తుంది.


SOCK_STREAM means we're using a stream socket as opposed to a datagram socket.

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


webclient.connect() establishes a TCP connection.

webclient.connect() ఒక TCP కనెక్షన్‌ను ఏర్పాటు చేస్తుంది.


Follow that up with webclient.send() to send data.

డేటాను పంపడానికి webclient.send() ని ఉపయోగించండి.


మేము ప్రతిస్పందనను ఆశిస్తున్నాము.


webclient.recv() prepares some space for this response.

webclient.recv() ఈ ప్రతిస్పందన కోసం కొంత స్థలాన్ని సిద్ధం చేస్తుంది.


You could set up a whole mess of sockets with unique names.

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


This will simply listen for connections and take an action upon receipt of data.

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


Threading allows us to manage multiple tasks at once.

థ్రెడింగ్ ఒకేసారి బహుళ పనులను నిర్వహించడానికి అనుమతిస్తుంది.


We start with declaring the IP address and port number.

IP చిరునామా మరియు పోర్ట్ నంబర్‌ను ప్రకటించడం ద్వారా ప్రారంభిస్తాము.


Binding doesn't exactly tell the socket what to do once bound.

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


The while loop statement is yet another basic programming concept.

while లూప్ స్టేట్‌మెంట్ మరొక ప్రాథమిక ప్రోగ్రామింగ్ భావన.


We create a thread with threading.Thread() and call it client_handler.

మేము threading.Thread()తో ఒక థ్రెడ్‌ను సృష్టిస్తాము మరియు దానిని client_handler అని పిలుస్తాము.


This program is a skeleton of server functionality.

ఈ ప్రోగ్రామ్ సర్వర్ కార్యాచరణ యొక్క ఒక నమూనా.


You find yourself on a Linux box with Python installed.

మీరు పైథాన్ ఇన్‌స్టాల్ చేయబడిన లైనక్స్ బాక్స్‌లో ఉన్నారు.


The os module is a multipurpose operating system interfacing module.

os మాడ్యూల్ ఒక బహుళ ప్రయోజన ఆపరేటింగ్ సిస్టమ్ ఇంటర్‌ఫేసింగ్ మాడ్యూల్.


We're creating a new IPv4 stream socket and calling it sock.

మేము ఒక కొత్త IPv4 స్ట్రీమ్ సాకెట్‌ను సృష్టిస్తున్నాము మరియు దానిని sock అని పిలుస్తున్నాము.


The shell is popping up on our remote screen and doesn't know it.

షెల్ మన రిమోట్ స్క్రీన్‌పై కనిపిస్తుంది మరియు అది తెలియదు.


That macgrab() returns MAC addresses, which are then stored as gwmac_addr and targetmac_addr, respectively.

macgrab() MAC చిరునామాలను అందిస్తుంది, ఆపై వాటిని వరుసగా gwmac_addr మరియు targetmac_addrగా నిల్వ చేస్తారు.


A possible return is None, so our if...else takes care of that: the value is printed to the screen, unless it's None, in which case the user is warned and we call sys.exit().

ఒకవేళ తిరిగి వచ్చేది ఏమీ లేకపోతే, అప్పుడు if...else ఆ పని చూసుకుంటుంది: విలువ తెరపై ముద్రించబడుతుంది, అది ఏమీ లేకపోతే తప్ప, అప్పుడు వినియోగదారునికి హెచ్చరిక జారీ చేయబడుతుంది మరియు మేము sys.exit()ని పిలుస్తాము.


The threading.Thread() class defines poison_target() as our target function and passes the target and gateway information as arguments.

threading.Thread() తరగతి poison_target()ని మన లక్ష్యంగా నిర్వచిస్తుంది మరియు లక్ష్యం మరియు గేట్‌వే సమాచారాన్ని వాదనలుగా పంపుతుంది.


Weaponizing PythonChapter 9 [ 235 ] mitm_thread.start() gets the attack rolling, but as a thread.

Weaponizing PythonChapter 9 [ 235 ] mitm_thread.start() దాడిని ప్రారంభిస్తుంది, కానీ ఒక థ్రెడ్‌గా.


The program continues with a try statement.

ప్రోగ్రామ్ ఒక ప్రయత్న ప్రకటనతో కొనసాగుతుంది.


ఇక్కడే మేము మా స్నిఫర్‌ను ఏర్పాటు చేస్తాము.


This is an interesting use case for using Scapy from within Python; note that we construct a filter as a string variable called bpf.

పైథాన్ లోపల నుండి Scapyని ఉపయోగించడం కోసం ఇది ఒక ఆసక్తికరమైన ఉపయోగం; మేము bpf అనే స్ట్రింగ్ వేరియబుల్‌గా ఫిల్టర్‌ను నిర్మిస్తామని గమనించండి.


sniff() is called with returned data popping up in memory as cap_packets.

తిరిగి వచ్చిన డేటాతో sniff() పిలువబడుతుంది, cap_packetsగా మెమరీలో కనిపిస్తుంది.


wrpcap() creates a packet capture file in pcap format.

wrpcap() pcap ఫార్మాట్‌లో ప్యాకెట్ క్యాప్చర్ ఫైల్‌ను సృష్టిస్తుంది.


Note that sniff() also passed the packet count as an argument, so what happens when this number is depleted?

sniff() ప్యాకెట్ కౌంట్‌ను కూడా ఒక వాదనగా పంపింది, కాబట్టి ఈ సంఖ్య తగ్గినప్పుడు ఏమి జరుగుతుంది?


కోడ్ పునరుద్ధరణ() కాల్‌కు వెళుతుంది.


If a Ctrl + C input is received before that time, restore() is still called.

ఆ సమయానికి ముందు Ctrl + C ఇన్‌పుట్ స్వీకరించబడితే, పునరుద్ధరణ() ఇప్పటికీ పిలువబడుతుంది.


As you can see, the print statements written in this demo are basic.

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


I encourage you to make it prettier to look at: Use Wireshark or any packet sniffer to verify success.

దీనిని మరింత అందంగా చేయడానికి నేను మిమ్మల్ని ప్రోత్సహిస్తున్నాను: విజయాన్ని ధృవీకరించడానికి Wireshark లేదా ఏదైనా ప్యాకెట్ స్నిఫర్‌ను ఉపయోగించండి.


You wrote this from the bottom up, so knowing the targets' layer 2 and layer 3 addresses is just half the battle—you want to make sure your code is handling them correctly.

మీరు దీన్ని దిగువ నుండి పైకి వ్రాసారు, కాబట్టి లక్ష్యాల యొక్క లేయర్ 2 మరియు లేయర్ 3 చిరునామాలను తెలుసుకోవడం సగం యుద్ధం మాత్రమే—మీ కోడ్ వాటిని సరిగ్గా నిర్వహిస్తుందని మీరు నిర్ధారించుకోవాలి.


With ARP, it would be easy to swap a source and destination.

ARPతో, మూలం మరియు గమ్యాన్ని మార్చుకోవడం సులభం అవుతుంది.


Once I'm done with my session, I can quickly verify that my packet capture was saved as expected.

నా సెషన్‌తో నేను పూర్తి చేసిన తర్వాత, నా ప్యాకెట్ క్యాప్చర్ ఊహించిన విధంగా సేవ్ చేయబడిందో లేదో నేను త్వరగా ధృవీకరించగలను.


Better yet, open it up in Wireshark and see what your sniffer picked up.

మంచిది, దీన్ని Wiresharkలో తెరిచి, మీ స్నిఫర్ ఏమి తీసుకుందో చూడండి.


In this chapter, we ran through a crash course in Python for pen testers.

ఈ అధ్యాయంలో, మేము పెన్ పరీక్షకుల కోసం పైథాన్‌లో ఒక క్రష్ కోర్సును నడిపాము.


We started with some basics about Python and picking your editor environment.

మేము పైథాన్ గురించి కొన్ని ప్రాథమిక విషయాలతో మరియు మీ ఎడిటర్ వాతావరణాన్ని ఎంచుకోవడంతో ప్రారంభించాము.


If you punched in the code from our setup, then you put in too many zs and calling exploit() crashes IE.

మీరు మా సెటప్ నుండి కోడ్‌ను నమోదు చేస్తే, మీరు చాలా ఎక్కువ 'z'లను నమోదు చేశారు మరియు exploit()ని పిలవడం IEని క్రాష్ చేస్తుంది.


ఎన్ని 'z'లు రాయాలో మనం తెలుసుకోవాలి.


I'll leave it to you to find the sweet number of fluff so that we're left with the perfect four bytes of space needed to overwrite EIP.

EIPని తిరిగి వ్రాయడానికి అవసరమైన ఖచ్చితమైన నాలుగు బైట్‌ల స్థలాన్ని మనం కలిగి ఉండేలా, ఫ్లఫ్ యొక్క సరైన సంఖ్యను కనుగొనడానికి నేను మీకు వదిలేస్తాను.


Let's tear down our page so we can modify lottery.html.

lottery.htmlని సవరించడానికి వీలుగా మన పేజీని కూల్చివేద్దాం.


I'm changing the buffer declaration to concatenate our target address with var buffer = "zzzz... [snip] ...zzzz" + "\xff\xff\xec\x11" (don't forget the endianness):

నేను బఫర్ డిక్లరేషన్‌ను మారుస్తున్నాను, మా లక్ష్య చిరునామాను var buffer = "zzzz... [snip] ...zzzz" + "\xff\xff\xec\x11"తో కలపడానికి (ఎండియన్నెస్‌ను మర్చిపోవద్దు):


Save the file and fire up the SimpleHTTPServer again.

ఫైల్‌ను సేవ్ చేసి, SimpleHTTPServerని మళ్లీ ప్రారంభించండి.


The trap is set, but we have just one last step: we need a handler.

ఉచ్చు సిద్ధం చేయబడింది, కానీ మనకు చివరి మెట్టు ఉంది: మనకు ఒక హ్యాండ్లర్ అవసరం.


Like msfvenom, I expect this process to be second-nature to you by now: fire up msfconsole and configure your reverse TCP handler.

msfvenom లాగానే, ఈ ప్రక్రియ ఇప్పుడు మీకు రెండవ స్వభావంగా ఉంటుందని నేను ఆశిస్తున్నాను: msfconsoleని ప్రారంభించండి మరియు మీ రివర్స్ TCP హ్యాండ్లర్‌ను కాన్ఫిగర్ చేయండి.


Make sure you configure LPORT with the same number encoded in your shellcode:

మీ షెల్‌కోడ్‌లో ఎన్‌కోడ్ చేయబడిన అదే నంబర్‌తో LPORTని కాన్ఫిగర్ చేయాలని నిర్ధారించుకోండి:


You can see here that we received a session from the victim PC when our unfortunate user tried to claim the lottery winnings.

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


Note the privileges: yes, we're stuck with the privileges under which Internet Explorer was executed.

అధికారాలను గమనించండి: అవును, ఇంటర్నెట్ ఎక్స్‌ప్లోరర్ అమలు చేయబడిన అధికారాలతో మేము చిక్కుకున్నాము.


Try experimenting with running IE with different user accounts and see if it makes a difference for the attacker.

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


Understanding Metasploit shellcode delivery

మెటాస్ప్లోయిట్ షెల్‌కోడ్ డెలివరీని అర్థం చేసుకోవడం


The shellcode that we've been generating with msfvenom is ultimately machine code that tells the processor how to, for example, bind to a local port.

msfvenomతో మేము ఉత్పత్తి చేస్తున్న షెల్‌కోడ్ చివరికి మెషిన్ కోడ్, ఇది ప్రాసెసర్‌కు ఎలా, ఉదాహరణకు, స్థానిక పోర్ట్‌కు బంధించాలో చెబుతుంది.


Once we've gone through a primer on low-level concepts such as the stack and heap, virtual address space, and assembly, this description of shellcode is straightforward enough.

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


The art of shellcoding is two key considerations: the target execution environment's quirks and the actual delivery of the shellcode into the execution environment.

షెల్‌కోడింగ్ కళ రెండు ముఖ్యమైన పరిశీలనలు: లక్ష్య అమలు వాతావరణం యొక్క విచిత్రాలు మరియు అమలు వాతావరణంలోకి షెల్‌కోడ్ యొక్క వాస్తవ డెలివరీ.


The first consideration includes things like endianness and shellcode-breaking characters; this analysis is the difference between 0x20 functioning just fine in shellcode and 0x20 being one of several characters that we have to work around.

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


The second consideration includes scenarios just like what we covered with our heap spraying attack, where we needed to use the unescape() function to parse out the bytes.

రెండవ పరిశీలనలో మన హీప్ స్ప్రేయింగ్ దాడితో మనం కవర్ చేసిన పరిస్థితులు ఉన్నాయి, ఇక్కడ మనం బైట్‌లను పార్స్ చేయడానికి unescape() ఫంక్షన్‌ను ఉపయోగించవలసి వచ్చింది.


Delivery of shellcode has to consider the potential for filtering mechanisms along the way.

షెల్‌కోడ్ డెలివరీ మార్గంలో ఫిల్టరింగ్ విధానాల కోసం సంభావ్యతను పరిగణనలోకి తీసుకోవాలి.


Again, shellcode is ultimately machine code; but when we're typing up our exploit, the shellcode exists as a variable that may need to be treated as a string and then passed into a function that may or may not speak the language.

మళ్ళీ, షెల్‌కోడ్ చివరికి మెషిన్ కోడ్; కానీ మనం మన ఎక్స్‌ప్లోయిట్‌ను టైప్ చేస్తున్నప్పుడు, షెల్‌కోడ్ ఒక వేరియబుల్‌గా ఉంటుంది, దీనిని స్ట్రింగ్‌గా పరిగణించవలసి ఉంటుంది మరియు భాషను మాట్లాడవచ్చు లేదా మాట్లాడకపోవచ్చు.


There's a clear divide between the malicious outsider with no good intention and the trusted insider.

చెడు ఉద్దేశంతో ఉన్న దుర్మార్గుడు మరియు నమ్మకమైన వ్యక్తి మధ్య స్పష్టమైన విభజన ఉంది.


Let's think of the malicious outsiders trying to get on the plane with all kinds of nasty stuff as shellcode.

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


With perfect security screening guaranteeing that no malicious individual can walk onto a plane, you will still have to trust that the pilot isn't corrupted.

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


Welcome to the concept of return-oriented programming, where the world we live in is a paradise in which no shellcode can be injected and executed.

తిరిగి-ఆధారిత ప్రోగ్రామింగ్ భావనకు స్వాగతం, మనం నివసించే ప్రపంచం ఒక స్వర్గం, ఇక్కడ షెల్‌కోడ్‌ను ఇంజెక్ట్ చేసి అమలు చేయలేము.


We're going to learn how combining the density of the x86 instruction set with a good old-fashioned buffer vulnerability in a program allows us to construct almost any arbitrary functionality.

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


We'll take a break from injecting bad code and learn how to turn the good code against itself.

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


Understand core defense concepts, such as Data Execution Prevention (DEP) and address space layout randomization (ASLR).

డేటా ఎగ్జిక్యూషన్ ప్రివెన్షన్ (DEP) మరియు అడ్రస్ స్పేస్ లేఅవుట్ రాండమైజేషన్ (ASLR) వంటి ప్రధాన రక్షణ భావనలను అర్థం చేసుకోండి.


Learn how to examine machine code and memory to identify instructions that we can leverage for our purposes, called gadgets.

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


Understand the different types of ROP-based attacks.

ROP-ఆధారిత దాడుల యొక్క వివిధ రకాలను అర్థం చేసుకోండి.


Explore the tools used by hackers to pull off ROP attacks.

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


Write and attack a vulnerable C program.

బలహీనమైన C ప్రోగ్రామ్‌ను వ్రాయండి మరియు దాడి చేయండి.


So far, we've only mentioned these concepts in passing: DEP, also called NX for no-execute) and ASLR.

ఇప్పటివరకు, మేము ఈ భావనలను మాత్రమే ప్రస్తావించాము: DEP, దీనిని నో-ఎగ్జిక్యూట్ కోసం NX అని కూడా పిలుస్తారు మరియు ASLR.


These protection mechanisms are responses to the attacks we've demonstrated.

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


Remember where we stuff our shellcode? Into the stack or the heap, which is memory set aside for a thread of execution.

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


When a function is running, space is allocated for variables and other data needed to get the work done.

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


The basic premise is to monitor whether the location that the instruction pointer is referencing is explicitly marked as executable.

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


Windows has two types of DEP: software-enforced and hardware-enforced.

Windows రెండు రకాల DEPలను కలిగి ఉంది: సాఫ్ట్‌వేర్-ఎన్‌ఫోర్స్డ్ మరియు హార్డ్‌వేర్-ఎన్‌ఫోర్స్డ్.


We found the vulnerable strcpy() function in our code; we stuffed the buffer with nonsense characters and deliberately overflowed it.

మేము మా కోడ్‌లో బలహీనమైన strcpy() ఫంక్షన్‌ను కనుగొన్నాము; మేము బఫర్‌ను అర్థంలేని అక్షరాలతో నింపి, ఉద్దేశపూర్వకంగా దానిని అతిగా నింపాము.


Modern operating systems such as Windows allow for multiple programs to be open at once, and they all have massive amounts of addressable memory available to them.

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


The name is quite descriptive: the layout of the program's nuts and bolts in virtual address space is moved around each time the program is run.

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


Go ahead and fire up the client, and take a look around.

క్లయింట్‌ను ప్రారంభించండి మరియు చుట్టూ చూడండి.


We'll test against this behavior to make things easier.

సమస్యలను సులభతరం చేయడానికి మేము ఈ ప్రవర్తనను పరీక్షిస్తాము.


కాబట్టి, మనకు FTP సర్వర్ అవసరమని తెలుసు.


What better way to get this done than with a Python script that mimics an FTP server?

FTP సర్వర్‌ను అనుకరించే పైథాన్ స్క్రిప్ట్‌తో దీన్ని చేయడానికి మంచి మార్గం ఏమిటి?


We'll do something a little different for our fuzzing FTP server because we need to mimic the appearance of a legitimate FTP server.

మా ఫజింగ్ FTP సర్వర్ కోసం మేము కొంచెం భిన్నంగా చేస్తాము, ఎందుకంటే మేము చట్టబద్ధమైన FTP సర్వర్ రూపాన్ని అనుకరించాలి.


Fire up vim fuzzy.py and type out the program.

vim fuzzy.py ని ప్రారంభించి ప్రోగ్రామ్‌ను టైప్ చేయండి.


We create a socket with socket.socket(socket. AF_INET, socket. SOCK_STREAM) and call it server.

మేము socket.socket(socket. AF_INET, socket. SOCK_STREAM)తో ఒక సాకెట్‌ను సృష్టిస్తాము మరియు దానిని సర్వర్ అని పిలుస్తాము.


If you connect to our fuzzy little server with an FTP client or netcat, you'll see a conversation with FTP server response codes.

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


We wrap up with two except sections for handling errors or Ctrl + C.

లోపాలు లేదా Ctrl + Cని నిర్వహించడానికి మేము రెండు మినహా విభాగాలతో ముగుస్తాము.


Crashing the target with the Python fuzzer.

పైథాన్ ఫజర్‌తో లక్ష్యాన్ని క్రాష్ చేయడం.


Open up the nfsAxe FTP client, select Anonymous access, and punch in Kali's IP address for Host ID.

nfsAxe FTP క్లయింట్‌ను తెరవండి, అనామక యాక్సెస్‌ను ఎంచుకోండి మరియు హోస్ట్ ID కోసం కాలి యొక్క IP చిరునామాను నమోదు చేయండి.


కనెక్ట్ చేసి ఫలితాలను చూడండి.


Okay, so that was a little boring, but it worked.

అలాగే, అది కొంచెం బోరింగ్‌గా ఉంది, కానీ అది పని చేసింది.


The payload was received by the client and displayed in the status window.

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


But just for fun, execute the fuzzer again, but this time send 4,000 bytes.

కానీ సరదా కోసం, ఫజర్‌ను మళ్లీ అమలు చేయండి, కానీ ఈసారి 4,000 బైట్‌లను పంపండి.


విజేత, విజేత, చికెన్ డిన్నర్!


Let's just prepare our exploit and we'll be on our way to arbitrary code execution.

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


We could simply generate a long string of characters in a defined pattern; pass it as our fuzz payload; look for the characters that end up written over the EIP on the client side; identify that 4-byte pattern in the fuzz payload, and calculate the offset.

మేము ఒక నిర్దిష్ట నమూనాలో అక్షరాల యొక్క పొడవైన స్ట్రింగ్‌ను రూపొందించవచ్చు; దానిని మా ఫజ్ పేలోడ్‌గా పాస్ చేయండి; క్లయింట్ వైపు EIP పై వ్రాసిన అక్షరాల కోసం చూడండి; ఫజ్ పేలోడ్‌లో ఆ 4-బైట్ నమూనాను గుర్తించండి మరియు ఆఫ్‌సెట్‌ను లెక్కించండి.


Calculating the EIP offset with the Metasploit toolset.

మెటాస్ప్లోయిట్ టూల్‌సెట్‌తో EIP ఆఫ్‌సెట్‌ను లెక్కిస్తోంది.


We're on an Intel processor, so that's a little-endian EIP address, isn't it?

మేము ఇంటెల్ ప్రాసెసర్‌లో ఉన్నాము, కాబట్టి అది కొంచెం-ఎండియన్ EIP చిరునామా, కాదా?


We can grab individual bytes out of our program's own code, link them together with returns, and pass whatever bytes we want to system().

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


The GOT is literally a table of addresses used by the executable during runtime to convert PIE addresses to absolute ones.

GOT అంటే రన్ టైమ్‌లో PIE చిరునామాలను సంపూర్ణమైన వాటిగా మార్చడానికి ఎగ్జిక్యూటబుల్ ఉపయోగించే చిరునామాల పట్టిక.


We're setting up those ROP chains with our returns pointing to particular places to send the flow.

ప్రవాహాన్ని పంపడానికి మా రిటర్న్‌లతో ఆ ROP గొలుసులను నిర్మిస్తున్నాము, నిర్దిష్ట స్థానాలకు సూచిస్తున్నాము.


Finding the .bss address We need to work with the program's design to write data somewhere.

.bss చిరునామాను కనుగొనడం మనం డేటాను ఎక్కడైనా వ్రాయడానికి ప్రోగ్రామ్ డిజైన్‌తో పని చేయాలి.


The strcpy() function pops off stack pointer offsets for source and destination arguments and then returns.

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


Remember, that means we're searching backwards from a given return instruction by 5 bytes to find gadgets.

గుర్తుంచుకోండి, అంటే మనం గాడ్జెట్‌లను కనుగొనడానికి ఇచ్చిన రిటర్న్ సూచన నుండి 5 బైట్‌ల ద్వారా వెనుకకు వెతుకుతున్నాము.


Our main() function needs to call system() and strcpy().

మన main() ఫంక్షన్ system() మరియు strcpy()ని పిలవాలి.


Finding target characters in memory with ROPgadget and Python.

ROPgadget మరియు Pythonతో మెమరీలో లక్ష్య అక్షరాలను కనుగొనడం.


This will set up a session with sh and pass it to a local listener on port 1066.

ఇది shతో ఒక సెషన్‌ను ఏర్పాటు చేస్తుంది మరియు దానిని పోర్ట్ 1066లో స్థానిక శ్రోతకు పంపుతుంది.


We're so close, but there's one last variable to figure out: our offset to the return address.

మనం చాలా దగ్గరగా ఉన్నాము, కానీ మనం తెలుసుకోవలసిన చివరి వేరియబుల్ ఉంది: రిటర్న్ చిరునామాకు మన ఆఫ్‌సెట్.


This is more of the traditional overflow research for injecting shellcode.

ఇది షెల్‌కోడ్‌ను ఇంజెక్ట్ చేయడానికి సాంప్రదాయక ఓవర్‌ఫ్లో పరిశోధన.


We're firing up gdb and executing the run command with the test input.

మేము gdbని ప్రారంభిస్తున్నాము మరియు పరీక్షా ఇన్‌పుట్‌తో రన్ కమాండ్‌ను అమలు చేస్తున్నాము.


In this case, we stuff 1,032 bytes of the letter z (\x7a) and then add 4 bytes of AzAz (\x41\x7a\x41\x7a).

ఈ సందర్భంలో, మేము z అక్షరం (
7a) యొక్క 1,032 బైట్‌లను నింపుతాము, ఆపై AzAz (
41
7a
41
7a) యొక్క 4 బైట్‌లను జోడిస్తాము.


మేము ఈ ఎక్స్‌ప్లాయిట్‌లో shని పరీక్షిస్తున్నాము.


This function allows us to work with raw binary within Python by treating it like any ordinary string.

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


The < is important for any Intel exploit—that's our little-endian ordering.

ఏదైనా ఇంటెల్ ఎక్స్‌ప్లాయిట్ కోసం < ముఖ్యం—అది మన చిన్న-ఎండియన్ ఆర్డరింగ్.


We introduced return-oriented programming and two primary tools of the trade: MSFrop and ROPgadget.

మేము రిటర్న్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌ను మరియు వాణిజ్యానికి సంబంధించిన రెండు ప్రధాన సాధనాలను పరిచయం చేసాము: MSFrop మరియు ROPgadget.


Fuzzing can find flaws that could negatively impact the user experience, but for security practitioners, it's a way to find exploitable flaws.

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


We're going to take a look at some network fuzzing that you just might end up doing in your hotel room after your first couple days with your client.

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


We dabbled in a kind of mutation fuzzing test back in Chapter 5, Cryptography and the Penetration Tester, when we used Burp Suite to modify requests in search of an unknown data length.

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


I'm going to look for FTP servers on the hidden network.

నేను రహస్య నెట్‌వర్క్‌లో FTP సర్వర్‌ల కోసం వెతుకుతాను.


Threading can speed up the scan, but also overwhelm the network.

థ్రెడింగ్ స్కానింగ్‌ను వేగవంతం చేస్తుంది, కానీ నెట్‌వర్క్‌ను కూడా అధిగమిస్తుంది.


I configure set PORTS 21, but you can add more ports with commas.

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


మేము 10.0.0.113లో పోర్ట్ 21ని తెరిచినట్లు కనుగొన్నాము.


What we need is a port-forwarding mechanism.

మనకు పోర్ట్-ఫార్వార్డింగ్ విధానం అవసరం.


Let's get back into our established session with sessions -i 1.

సెషన్స్ -i 1తో మన స్థాపించబడిన సెషన్‌లోకి తిరిగి వెళ్దాం.


-R అనేది రివర్స్ పోర్ట్ ఫార్వర్డ్.


-L స్థానిక హోస్ట్‌ను పేర్కొంటుంది.


-l specifies the local port to listen on.

-l వినడానికి స్థానిక పోర్ట్‌ను పేర్కొంటుంది.


-p is the remote port that we're forwarding our traffic to.

-p అనేది మనం ట్రాఫిక్‌ను ఫార్వార్డ్ చేస్తున్న రిమోట్ పోర్ట్.


I create the relay with the portfwd add -L 192.168.63.138 -l 8000 -p 21 -r 10.0.0.113 command.

నేను పోర్ట్‌ఫ్వడ్ యాడ్ -L 192.168.63.138 -l 8000 -p 21 -r 10.0.0.113 కమాండ్‌తో రిలేను సృష్టిస్తాను.


In short, the address 192.168.63.138:8000 has just become, for all intents and purposes, 10.0.0.113:21.

సంక్షిప్తంగా, 192.168.63.138:8000 చిరునామా, అన్ని ఉద్దేశ్యాల కోసం, 10.0.0.113:21గా మారింది.


Here we are, chatting with a service running on another subnet.

ఇక్కడ మనం ఉన్నాము, మరొక సబ్‌నెట్‌లో నడుస్తున్న సేవతో చాట్ చేస్తున్నాము.


We can thus exploit trust relationships to bypass firewalls using this method.

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


Escalating your pivot – passing attacks down the line.

మీ పివోట్‌ను పెంచడం - దాడులను లైన్‌లో పంపడం.


I always know I can be surprised at what that password will get me into.

ఆ పాస్‌వర్డ్ నన్ను ఏమి చేస్తుందోనని నేను ఎల్లప్పుడూ ఆశ్చర్యపోతాను.


Let's get back to our scenario and depict a similar attack.

మన దృశ్యానికి తిరిగి వెళ్లి, ఇలాంటి దాడిని చూపిద్దాం.


Remember that Windows passwords are special in that they aren't salted.

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


That's right, Eagle Eye, the Administrator password is the exact same as the Jim-Bob password.

అది నిజం, ఈగిల్ ఐ, అడ్మినిస్ట్రేటర్ పాస్‌వర్డ్ జిమ్-బాబ్ పాస్‌వర్డ్‌తో సమానంగా ఉంది.


Jump back into your meterpreter session and confirm that you're running as SYSTEM.

మీ మీటర్‌ప్రెటర్ సెషన్‌లోకి తిరిగి వెళ్లి, మీరు సిస్టమ్‌గా నడుస్తున్నారని నిర్ధారించుకోండి.


In PowerShell, you can pipe the object coming out of a cmdlet into another cmdlet, including ForEach.

PowerShell లో, మీరు ఒక cmdlet నుండి వచ్చే వస్తువును ForEachతో సహా మరొక cmdletలోకి పంపవచ్చు.


Life is made even simpler with the single character alias for the ForEach cmdlet: %.

ForEach cmdlet కోసం ఒకే అక్షర మారుపేరుతో జీవితం మరింత సులభం అవుతుంది: %.


ఒక ఉదాహరణ చూద్దాం.


Both lines are the same thing: > ls *.txt | ForEach-Object {cat $_} > ls *.txt | % {cat $_}

రెండు లైన్లు ఒకటే: > ls *.txt | ForEach-Object {cat $_} > ls *.txt | % {cat $_}


If executed in a path with more than one text file, the ls *.txt command will produce a list of results; these are the input for ForEach-Object, with each item represented as $_.

ఒకటి కంటే ఎక్కువ టెక్స్ట్ ఫైల్ ఉన్న మార్గంలో అమలు చేస్తే, ls *.txt కమాండ్ ఫలితాల జాబితాను ఉత్పత్తి చేస్తుంది; ఇవి ForEach-Object కోసం ఇన్పుట్, ప్రతి అంశం $_గా సూచించబడుతుంది.


A standard for loop essentially executes code a defined number of times, whereas the for each loop executes code for each item in an array or list.

ప్రామాణిక ఫర్ లూప్ తప్పనిసరిగా నిర్వచించబడిన సంఖ్యలో కోడ్‌ను అమలు చేస్తుంది, అయితే ఫర్ ఈచ్ లూప్ ఒక శ్రేణి లేదా జాబితాలోని ప్రతి అంశానికి కోడ్‌ను అమలు చేస్తుంది.


We can define a number range with two periods (..).

రెండు కాల వ్యవధులతో (..) సంఖ్య పరిధిని నిర్వచించవచ్చు.


For example, 5..9 says to PowerShell, 5, 6, 7, 8, 9.

ఉదాహరణకు, 5..9 PowerShellకి 5, 6, 7, 8, 9 అని చెబుతుంది.


With this simple syntax, we can pipe ranges of numbers into a ForEach; this is handy for doing a task a set number of times, or even to use those numbers as arguments for a command.

ఈ సాధారణ సింటాక్స్‌తో, మనం సంఖ్యల పరిధులను ForEachలోకి పంపవచ్చు; ఇది ఒక పనిని నిర్దిష్ట సంఖ్యలో చేయడానికి లేదా ఆ సంఖ్యలను కమాండ్ కోసం వాదనలుగా ఉపయోగించడానికి ఉపయోగపడుతుంది.


So, by piping a number range into ForEach, we can work with each number as $_.

కాబట్టి, సంఖ్య పరిధిని ForEachలోకి పంపడం ద్వారా, మనం ప్రతి సంఖ్యతో $_గా పని చేయవచ్చు.


What do you think will happen if we run this command?

ఈ కమాండ్ రన్ చేస్తే ఏమవుతుందో మీరు ఏమనుకుంటున్నారు?


Naturally, we can build pipelines—a series of cmdlets passing output down the chain.

సహజంగానే, మనం పైప్‌లైన్‌లను నిర్మించవచ్చు—అవుట్‌పుట్‌ను గొలుసులో పంపే cmdlets శ్రేణి.


For example, check out this command: > Get-Service Dhcp | Stop-Service -PassThru -Force | Set-Service - StartupType Disabled

ఉదాహరణకు, ఈ కమాండ్‌ని చూడండి: > Get-Service Dhcp | Stop-Service -PassThru -Force | Set-Service - StartupType Disabled


PowerShell is a full Windows administration framework, and it's built into the OS.

PowerShell అనేది పూర్తి విండోస్ అడ్మినిస్ట్రేషన్ ఫ్రేమ్‌వర్క్, మరియు ఇది OSలో నిర్మించబడింది.


When we talk about post-exploitation in Windows environments, consideration of PowerShell is not a nice-to-have; it's a necessity.

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


So, you have your foothold on a Windows 7 box.

కాబట్టి, మీరు విండోస్ 7 బాక్స్ మీద మీ స్థావరాన్ని కలిగి ఉన్నారు.


With PowerShell, there isn't much we can't do.

PowerShellతో, మనం చేయలేనిది ఏమీ లేదు.


It's slow and crude, but we work with what is presented to us.

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


Now that we have a host in mind, we can learn more about it with this one liner designed to attempt TCP connections to all specified ports:

ఇప్పుడు మనకు ఒక హోస్ట్ ఉన్నందున, పేర్కొన్న అన్ని పోర్ట్‌లకు TCP కనెక్షన్‌లను ప్రయత్నించడానికి రూపొందించబడిన ఈ ఒక లైన్‌తో దాని గురించి మరింత తెలుసుకోవచ్చు:


I encourage you to check out the man pages offline.

మీరు మాన్ పేజీలను ఆఫ్‌లైన్‌లో చూడాలని నేను ప్రోత్సహిస్తున్నాను.


Once everything is configured and ready to rock, you should be able to just fire off esedbexport.

అన్నీ కాన్ఫిగర్ చేసి సిద్ధంగా ఉన్న తర్వాత, మీరు esedbexportని ప్రారంభించగలరు.


We're going to tell the utility to export all of the tables inside the NTDS database.

మేము NTDS డేటాబేస్ లోపల ఉన్న అన్ని పట్టికలను ఎగుమతి చేయమని యుటిలిటీకి చెప్తాము.


There are two tables in particular that we need for hash extraction.

హ్యాష్ వెలికితీత కోసం మనకు ముఖ్యంగా రెండు పట్టికలు అవసరం.


We can pass the data table and link table to the dsusers Python script.

డేటా పట్టిక మరియు లింక్ పట్టికను dsusers పైథాన్ స్క్రిప్ట్‌కు పంపవచ్చు.


I encourage you to study the actual database contents for things like password history.

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


John knows what to do with the formatted text files.

ఫార్మాట్ చేయబడిన టెక్స్ట్ ఫైల్‌లతో ఏమి చేయాలో జాన్‌కు తెలుసు.


Some environments will yield thousands of hashes.

కొన్ని పరిసరాలు వేలకొద్దీ హ్యాష్‌లను ఉత్పత్తి చేస్తాయి.


Especially on shorter assessments, it can make a tremendous difference.

ముఖ్యంగా తక్కువ అంచనా వేయడంలో ఇది చాలా తేడాను కలిగిస్తుంది.


In this chapter, we looked behind the scenes at some basic privilege escalation techniques.

ఈ అధ్యాయంలో, కొన్ని ప్రాథమిక అధికారాల పెంపు పద్ధతుల వెనుక ఉన్న విషయాలను మేము పరిశీలించాము.


We reviewed PowerShell Empire and creating stealthy agents with remote WMI commands.

మేము పవర్‌షెల్ సామ్రాజ్యాన్ని సమీక్షించాము మరియు రిమోట్ WMI ఆదేశాలతో రహస్య ఏజెంట్లను సృష్టించాము.


In the final chapter, we'll be looking at persistence: techniques to allow our established access to persist through reboots and reconfiguration.

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


Questions Named pipes are also known as _____ in Unix-like systems.

ప్రశ్నలు: పేరున్న పైపులను యూనిక్స్ లాంటి సిస్టమ్‌లలో _____ అని కూడా పిలుస్తారు.


We've been on a long journey together through these pages.

ఈ పేజీల ద్వారా మనం కలిసి చాలా దూరం ప్రయాణించాము.


Hacking is problem solving, and sometimes it's easy to forget that being able to persist our access is a problem in its own right.

హ్యాకింగ్ అనేది సమస్య పరిష్కారం, మరియు మన యాక్సెస్‌ను కొనసాగించగలగడం కూడా ఒక సమస్య అని కొన్నిసార్లు మర్చిపోవడం సులభం.


Remember a broad goal in your assessments: escalate from quiet to relatively noisy and note the point at which you're caught.

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


We've covered generating payloads at several points throughout this book.

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


Now we bring the discussion full-circle by leveraging Metasploit's persistence module.

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


This malicious program will persist and give the target more time to discover it.

ఈ హానికరమైన ప్రోగ్రామ్ కొనసాగుతుంది మరియు లక్ష్యాన్ని కనుగొనడానికి ఎక్కువ సమయం ఇస్తుంది.


Make sure you configure it with the correct port number.

మీరు దీన్ని సరైన పోర్ట్ నంబర్‌తో కాన్ఫిగర్ చేశారని నిర్ధారించుకోండి.


Suppose that a privileged process creates a named pipe.

ఒక విశేష అధికారాలు కలిగిన ప్రక్రియ ఒక పేరున్న పైపును సృష్టిస్తుందని అనుకుందాం.


Impersonation allows the pipe server to reduce its privilege while processing pipe client requests.

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


A process could very well attempt to connect to the named pipe without knowing whether the pipe server has even created it yet.

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


This can be easily exploited in situations where an application is designed to keep requesting a named pipe until it succeeds.

ఒక అప్లికేషన్ విజయవంతం అయ్యేవరకు పేరున్న పైపును అభ్యర్థిస్తూనే ఉండే పరిస్థితుల్లో దీన్ని సులభంగా ఉపయోగించుకోవచ్చు.


In the Unix-like world, named pipes are also called FIFOs in honor of their first-in, first-out structure.

యూనిక్స్ లాంటి ప్రపంచంలో, పేరున్న పైపులను వాటి ఫస్ట్-ఇన్, ఫస్ట్-అవుట్ నిర్మాణానికి గౌరవంగా FIFOలు అని కూడా పిలుస్తారు.


If you know for a fact that a privileged pipe client is going to be making a specific request, the attacker just needs to be the first in line in order to usurp the client's security context.

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


Armitage, for example, will attempt escalation automatically once you gain your foothold on a target.

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


In this scenario, I've just managed to sniff a password off the wire.

ఈ దృష్టాంతంలో, నేను వైర్ నుండి పాస్వర్డ్ను స్నిఫ్ చేయగలిగాను.


The password works and the scary lightning bolts entomb the poor server.

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


Armitage makes the process laughably simple.

ఆర్మిటేజ్ ఈ ప్రక్రియను నవ్వు తెప్పించేంత సులభం చేస్తుంది.


A quick ipconfig reveals the presence of another interface attached to a 10.108.108.0/24 subnet.

ఒక శీఘ్ర ipconfig 10.108.108.0/24 సబ్నెట్కు అనుసంధానించబడిన మరొక ఇంటర్ఫేస్ ఉనికిని వెల్లడిస్తుంది.


Armitage has you covered and hates it when you work too hard.

ఆర్మిటేజ్ మిమ్మల్ని కవర్ చేస్తుంది మరియు మీరు కష్టపడి పనిచేయడం ఆమెకు నచ్చదు.


One of the important basic facts of the post phase is that it's iterative.

పోస్ట్ దశ యొక్క ముఖ్యమైన ప్రాథమిక వాస్తవాలలో ఒకటి ఏమిటంటే ఇది పునరావృతమవుతుంది.


సులభమైన మార్గం విఫలమైనప్పుడు - స్థానిక దోపిడీలు


There's a function in the Windows kernel responsible for getting messages from a sending thread forwarded over to the receiving thread for interthread communication; xxxInterSendMsgEx.

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


Let's get lazy – Schlamperei privilege escalation on Windows 7

సోమరితనం చేద్దాం - విండోస్ 7లో స్క్లాంపెరీ అధికారాల పెంపు


WMIC is the name of a tool and it stands for Windows Management Instrumentation Command.

WMIC అనేది ఒక సాధనం పేరు మరియు ఇది విండోస్ మేనేజ్మెంట్ ఇన్స్ట్రుమెంటేషన్ కమాండ్కు సంక్షిప్తంగా ఉంది.


WMI is another Windows feature that tends to fly under the radar.

WMI అనేది మరో విండోస్ ఫీచర్, ఇది రాడార్ కింద ఎగురుతుంది.


WMICతో నిశ్శబ్దంగా ప్రక్రియలను ప్రారంభించడం


I wish I could tell you that this will feel like one of those action movies where the tough guy casually walks away from an explosion without turning around to look at it, but in reality, it will look like the calculator spawn.

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


Kali wireless access point, configuring.

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


Malicious website creating, to exploit Java.

జావాను ఉపయోగించుకోవడానికి హానికరమైన వెబ్‌సైట్‌ను సృష్టిస్తోంది.


మధ్యలో మనిషి దాడి.


గరిష్ట సెగ్మెంట్ సైజు (MSS).


మెటాస్ప్లోయిట్ సహాయక మాడ్యూల్ నిర్మాణం.


Metasploit payloads using, with social engineering attacks.

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


మెటాస్ప్లోయిట్ నిలకడ గురించి.


మెటాస్ప్లోయిట్ షెల్‌కోడ్ డెలివరీ గురించి.


Metasploit toolset used, for calculating EIP offset.

EIP ఆఫ్‌సెట్‌ను లెక్కించడానికి ఉపయోగించే మెటాస్ప్లోయిట్ టూల్‌సెట్.


Metasploit Kernal attack, escalating to SYSTEM on Windows 7.

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


Launching into hidden network with autoroute.

ఆటోరూట్‌తో దాచిన నెట్‌వర్క్‌లోకి ప్రవేశించడం.


Modules used, for creating connect-back listener.

కనెక్ట్-బ్యాక్ శ్రోతను సృష్టించడానికి ఉపయోగించే మాడ్యూల్స్.


ARP గణన కోసం మీటర్ప్రెటర్ ఉపయోగించబడింది.


నెట్‌వర్క్ అడ్రస్ ట్రాన్స్‌లేషన్ (NAT).


మెటాస్ప్లోయిట్‌తో నెట్‌వర్క్ పివోటింగ్.


విండోస్ పాస్‌వర్డ్‌లను సంగ్రహించడం.


NOP స్లెడ్డింగ్.


పేలోడ్ ఉత్పత్తి గురించి.


పెన్ పరీక్ష.


PowerShell Empire agent creating, with WMIC.

WMICతో పవర్‌షెల్ ఎంపైర్ ఏజెంట్‌ను సృష్టిస్తోంది.


If you're reading this as an aspiring or current professional, then you can't be worried about free and personal use.

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


In the professional setting, I used VMware Workstation Pro.

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


Performance: Workstation Player and Pro are faster than VirtualBox.

పనితీరు: వర్క్‌స్టేషన్ ప్లేయర్ మరియు ప్రో, VirtualBox కంటే వేగంగా ఉంటాయి.


For consistency, we'll stick with VMware Workstation Pro for our lab environment.

స్థిరత్వం కోసం, మేము మా ల్యాబ్ వాతావరణం కోసం VMware వర్క్‌స్టేషన్ ప్రోతో కొనసాగుతాము.


Microsoft actually lets you download full Windows VMs for free.

వాస్తవానికి, Microsoft మీకు పూర్తి Windows VMలను ఉచితంగా డౌన్‌లోడ్ చేయడానికి అనుమతిస్తుంది.


You can find them at: https://developer.microsoft.com/en-us/microsoft- edge/tools/vms/.

మీరు వాటిని ఇక్కడ కనుగొనవచ్చు: https://developer.microsoft.com/en-us/microsoft- edge/tools/vms/.


Microsoft will let you download Windows Server 2008 R2 to evaluate (test, that is), and the license is good for six months:

Microsoft మిమ్మల్ని Windows Server 2008 R2ని మూల్యాంకనం చేయడానికి (అంటే పరీక్షించడానికి) డౌన్‌లోడ్ చేయడానికి అనుమతిస్తుంది మరియు లైసెన్స్ ఆరు నెలల వరకు చెల్లుబాటు అవుతుంది:


Install Windows, don't activate it with a key, and just use the trial version until it expires.

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


Now that your family of virtual computers is happily installed, it's time for a family reunion on the network.

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


If you just want to get your VM on the internet as quickly as possible, configure the virtual NAT and make sure your VM is DHCP-enabled.

మీరు వీలైనంత త్వరగా మీ VMని ఇంటర్నెట్‌లోకి తీసుకురావాలనుకుంటే, వర్చువల్ NATని కాన్ఫిగర్ చేయండి మరియు మీ VM DHCP-ఎనేబుల్ చేయబడిందని నిర్ధారించుకోండి.


This is probably the most popular configuration as it gets everyone online and reachable.

ప్రతి ఒక్కరూ ఆన్‌లైన్‌లో మరియు అందుబాటులోకి రావడంతో ఇది బహుశా అత్యంత ప్రజాదరణ పొందిన కాన్ఫిగరేషన్.


If you want to expose the VM, use the bridged network connection.

మీరు VMని బహిర్గతం చేయాలనుకుంటే, వంతెన నెట్‌వర్క్ కనెక్షన్‌ను ఉపయోగించండి.


A very good tool to know about is the Virtual Network Editor.

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


It lets you configure your virtual networks.

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


You can add up to the full 20 virtual networks that are possible and then define their numbering schemes, create a DHCP environment for them, and so on.

మీరు సాధ్యమయ్యే పూర్తి 20 వర్చువల్ నెట్‌వర్క్‌లను జోడించవచ్చు, ఆపై వాటి నంబరింగ్ పథకాలను నిర్వచించవచ్చు, వాటి కోసం DHCP వాతావరణాన్ని సృష్టించవచ్చు మరియు మొదలైనవి.


This network configuration power isn't the only reason I'm pointing out the Virtual Network Editor.

వర్చువల్ నెట్‌వర్క్ ఎడిటర్‌ను నేను ఎత్తి చూపుతున్న ఏకైక కారణం ఈ నెట్‌వర్క్ కాన్ఫిగరేషన్ శక్తి కాదు.


There's one little inconspicuous button that may be a lifesaver for you even in ordinary NAT and bridging scenarios: Restore Defaults.

సాధారణ NAT మరియు బ్రిడ్జింగ్ దృశ్యాలలో కూడా మీకు ప్రాణాలను రక్షించే ఒక చిన్న అస్పష్టమైన బటన్ ఉంది: డిఫాల్ట్‌లను పునరుద్ధరించు.


This little button erases all of the custom configuration and added networks and restores the out-of-the-box defaults.

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


There is a long list of reasons why the virtual networking will just stop working altogether, but we won't cover any of that.

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


Just remember this option as the nuke-the-site-from-orbit option for cleaning up a convoluted and broken virtual network.

ఒక గందరగోళంగా మరియు విరిగిన వర్చువల్ నెట్‌వర్క్‌ను శుభ్రపరచడానికి ఈ ఎంపికను సైట్‌ను కక్ష్య నుండి తొలగించే ఎంపికగా గుర్తుంచుకోండి.