| {"en":"The debugger pauses the execution of the program.","translation":"డీబగ్గర్ ప్రోగ్రామ్ అమలును ఆపివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The program hits the breakpoint and pauses before executing any instructions.","translation":"ప్రోగ్రామ్ బ్రేక్ పాయింట్ వద్ద ఆగుతుంది మరియు ఏ సూచనలను అమలు చేయడానికి ముందు ఆగిపోతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The value of EIP (the Instruction Pointer) is displayed.","translation":"EIP (ఇన్స్ట్రక్షన్ పాయింటర్) విలువ ప్రదర్శించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The instructions before this are collectively known as the function prologue.","translation":"దీనికి ముందున్న సూచనలను సాధారణంగా ఫంక్షన్ ప్రోలోగ్ అని పిలుస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The debugger knows this part of the code is automatically generated.","translation":"కోడ్లోని ఈ భాగాన్ని స్వయంచాలకంగా రూపొందించారని డీబగ్గర్కు తెలుసు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Examining memory is a critical skill for any hacker.","translation":"మెమరీని పరిశీలించడం ఏదైనా హ్యాకర్ కోసం ఒక ముఖ్యమైన నైపుణ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most hacker exploits are a lot like magic tricks.","translation":"చాలా హ్యాకర్ల దోపిడీలు మాయాజాలంలాగే ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The examine command in GDB can be used to look at a certain address of memory.","translation":"GDB లోని ఎగ్జామిన్ కమాండ్ మెమరీ యొక్క నిర్దిష్ట చిరునామాను చూడటానికి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This command expects two arguments when it’s used.","translation":"ఈ ఆదేశం ఉపయోగించినప్పుడు రెండు వాదనలను ఆశిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The display format also uses a single-letter shorthand.","translation":"ప్రదర్శన ఆకృతి కూడా ఒకే అక్షర సంక్షిప్తలిపిని ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Display in hexadecimal.","translation":"హెక్సాడెసిమల్లో ప్రదర్శించు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The memory the EIP register is pointing to can be examined.","translation":"EIP రిజిస్టర్ సూచిస్తున్న మెమరీని పరిశీలించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The debugger lets you reference registers directly.","translation":"డీబగ్గర్ మిమ్మల్ని నేరుగా రిజిస్టర్లను సూచించడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The default size of a single unit is a four-byte unit called a word.","translation":"ఒక యూనిట్ యొక్క డిఫాల్ట్ పరిమాణం నాలుగు-బైట్ యూనిట్, దీనిని పదం అంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The valid size letters are as follows:","translation":"చెల్లుబాటు అయ్యే పరిమాణ అక్షరాలు క్రింది విధంగా ఉన్నాయి:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This is slightly confusing, because sometimes the term word also refers to 2-byte values.","translation":"ఇది కొంచెం గందరగోళంగా ఉంది, ఎందుకంటే కొన్నిసార్లు పదం అనే పదం 2-బైట్ విలువలను కూడా సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The first examine command shows the first eight bytes.","translation":"మొదటి ఎగ్జామిన్ కమాండ్ మొదటి ఎనిమిది బైట్లను చూపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The byte order of a given architecture is an important detail to be aware of.","translation":"ఒక నిర్దిష్ట ఆర్కిటెక్చర్ యొక్క బైట్ ఆర్డర్ గురించి తెలుసుకోవలసిన ముఖ్యమైన వివరాలు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In addition to converting byte order, GDB can do other conversions with the examine command.","translation":"బైట్ ఆర్డర్ను మార్చడంతో పాటు, GDB ఎగ్జామిన్ కమాండ్తో ఇతర మార్పిడులను కూడా చేయగలదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"We’ve already seen that GDB can disassemble machine language instructions.","translation":"GDB మెషిన్ లాంగ్వేజ్ సూచనలను విడదీయగలదని మేము ఇప్పటికే చూశాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"livecd provides a complete linux programming and debugging environment","translation":"లైవ్సిడి పూర్తి లైనక్స్ ప్రోగ్రామింగ్ మరియు డీబగ్గింగ్ వాతావరణాన్ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Hacking is the art of creative problem solving.","translation":"హ్యాకింగ్ అనేది సృజనాత్మక సమస్య పరిష్కారానికి సంబంధించిన కళ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Many people call themselves hackers, but few have the strong technical foundation.","translation":"చాలా మంది తమను తాము హ్యాకర్లు అని పిలుచుకుంటారు, కానీ కొద్దిమందికి మాత్రమే బలమైన సాంకేతిక పునాది ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The included LiveCD provides a complete Linux programming and debugging environment.","translation":"చేర్చబడిన లైవ్సిడి పూర్తి లైనక్స్ ప్రోగ్రామింగ్ మరియు డీబగ్గింగ్ వాతావరణాన్ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Use it to follow along with the book’s examples.","translation":"పుస్తకంలోని ఉదాహరణలను అనుసరించడానికి దీన్ని ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Get your hands dirty debugging code.","translation":"కోడ్ను డీబగ్గింగ్ చేయడం ద్వారా మీ చేతులను మురికిగా చేసుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Overflowing buffers, hijacking network communications, bypassing protections.","translation":"బఫర్లను అతిగా నింపడం, నెట్వర్క్ కమ్యూనికేషన్లను హైజాక్ చేయడం, రక్షణలను దాటవేయడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exploiting cryptographic weaknesses, and perhaps even inventing new exploits.","translation":"క్రిప్టోగ్రాఫిక్ బలహీనతలను ఉపయోగించుకోవడం మరియు బహుశా కొత్త దోపిడీలను కనుగొనడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This book will teach you how to program computers using C.","translation":"ఈ పుస్తకం Cని ఉపయోగించి కంప్యూటర్లను ఎలా ప్రోగ్రామ్ చేయాలో మీకు నేర్పుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Corrupt system memory to run arbitrary code using buffer overflows.","translation":"బఫర్ ఓవర్ఫ్లోలను ఉపయోగించి ఇష్టానుసార కోడ్ను అమలు చేయడానికి సిస్టమ్ మెమరీని దెబ్బతీయండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Inspect processor registers and system memory with a debugger.","translation":"డీబగ్గర్తో ప్రాసెసర్ రిజిస్టర్లు మరియు సిస్టమ్ మెమరీని తనిఖీ చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Gain access to a remote server using port-binding or connect-back shellcode.","translation":"పోర్ట్-బైండింగ్ లేదా కనెక్ట్-బ్యాక్ షెల్కోడ్ని ఉపయోగించి రిమోట్ సర్వర్ను యాక్సెస్ చేయండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Redirect network traffic, conceal open ports, and hijack TCP connections.","translation":"నెట్వర్క్ ట్రాఫిక్ను మళ్లించండి, తెరిచిన పోర్ట్లను దాచండి మరియు TCP కనెక్షన్లను హైజాక్ చేయండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Crack encrypted wireless traffic using the FMS attack.","translation":"FMS దాడిని ఉపయోగించి గుప్తీకరించబడిన వైర్లెస్ ట్రాఫిక్ను క్రాక్ చేయండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Hackers are always pushing the boundaries, investigating the unknown.","translation":"హ్యాకర్లు ఎల్లప్పుడూ సరిహద్దులను నెట్టివేస్తారు, తెలియని వాటిని పరిశోధిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Combine this knowledge with the included Linux environment, and all you need is your own creativity.","translation":"ఈ జ్ఞానాన్ని చేర్చబడిన లైనక్స్ వాతావరణంతో కలపండి, మరియు మీకు కావలసిందల్లా మీ స్వంత సృజనాత్మకత.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Jon Erickson has a formal education in computer science.","translation":"జాన్ ఎరిక్సన్ కంప్యూటర్ సైన్స్లో అధికారిక విద్యను కలిగి ఉన్నాడు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"He speaks at computer security conferences and trains security teams around the world.","translation":"అతను కంప్యూటర్ భద్రతా సమావేశాలలో మాట్లాడతాడు మరియు ప్రపంచవ్యాప్తంగా భద్రతా బృందాలకు శిక్షణ ఇస్తాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Currently, he works as a vulnerability researcher and security specialist.","translation":"ప్రస్తుతం, అతను బలహీనత పరిశోధకుడు మరియు భద్రతా నిపుణుడిగా పనిచేస్తున్నాడు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This book is a guide for novice hackers.","translation":"ఈ పుస్తకం అనుభవశూన్యుడైన హ్యాకర్ల కోసం ఒక మార్గదర్శి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This way, you will gain a hands-on understanding and appreciation for hacking.","translation":"ఈ విధంగా, మీరు హ్యాకింగ్ గురించి ప్రత్యక్షంగా అర్థం చేసుకుంటారు మరియు దానిని మెచ్చుకుంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Hopefully, this book will stimulate the curious hacker nature in you.","translation":"ఈ పుస్తకం మీలోని ఆసక్తిగల హ్యాకర్ స్వభావాన్ని ప్రేరేపిస్తుందని ఆశిస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Hacker is a term for both those who write code and those who exploit it.","translation":"కోడ్ను రాసేవారు మరియు దానిని ఉపయోగించుకునే వారిద్దరికీ హ్యాకర్ అనే పదం వర్తిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Since an understanding of programming helps those who exploit, many hackers do both.","translation":"ప్రోగ్రామింగ్ గురించి అవగాహన ఉన్నవారు దోపిడీ చేసేవారికి సహాయపడుతుంది కాబట్టి, చాలా మంది హ్యాకర్లు రెండూ చేస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Hacking is really just the act of finding a clever and counterintuitive solution to a problem.","translation":"హ్యాకింగ్ అనేది ఒక సమస్యకు తెలివైన మరియు వ్యతిరేక పరిష్కారాన్ని కనుగొనే చర్య.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The hacks found in program exploits usually use the rules of the computer to bypass security.","translation":"ప్రోగ్రామ్ దోపిడీలలో కనుగొనబడిన హ్యాక్లు సాధారణంగా భద్రతను దాటవేయడానికి కంప్యూటర్ నియమాలను ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Programming hacks are similar in that they also use the rules of the computer in new and inventive ways.","translation":"ప్రోగ్రామింగ్ హ్యాక్లు కూడా కంప్యూటర్ నియమాలను కొత్త మరియు ఆవిష్కరణ మార్గాల్లో ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There are actually an infinite number of programs that can be written to accomplish any given task.","translation":"ఏదైనా పనిని సాధించడానికి వాస్తవానికి అనంతమైన సంఖ్యలో ప్రోగ్రామ్లను వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Programs that have these qualities are said to have elegance, and the clever and inventive solutions that tend to lead to this efficiency are called hacks.","translation":"ఈ లక్షణాలు కలిగిన ప్రోగ్రామ్లను సొగసైనవిగా చెబుతారు మరియు ఈ సామర్థ్యానికి దారితీసే తెలివైన మరియు ఆవిష్కరణ పరిష్కారాలను హ్యాక్లు అంటారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"True appreciation of programming elegance is left for the hackers.","translation":"ప్రోగ్రామింగ్ సొగసు యొక్క నిజమైన ప్రశంస హ్యాకర్ల కోసం మిగిలి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since an understanding of programming is a prerequisite to understanding how programs can be exploited, programming is a natural starting point.","translation":"ప్రోగ్రామింగ్ ఎలా ఉపయోగించవచ్చో అర్థం చేసుకోవడానికి ప్రోగ్రామింగ్ గురించి అవగాహన తప్పనిసరి, కాబట్టి ప్రోగ్రామింగ్ సహజమైన ప్రారంభ స్థానం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Programming is a very natural and intuitive concept.","translation":"ప్రోగ్రామింగ్ చాలా సహజమైన మరియు సహజమైన భావన.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A program is nothing more than a series of statements written in a specific language.","translation":"ఒక ప్రోగ్రామ్ అనేది ఒక నిర్దిష్ట భాషలో వ్రాయబడిన ప్రకటనల శ్రేణి కంటే ఎక్కువ కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Driving directions, cooking recipes, football plays, and DNA are all types of programs.","translation":"డ్రైవింగ్ దిశలు, వంట వంటకాలు, ఫుట్బాల్ ఆటలు మరియు DNA అన్నీ ప్రోగ్రామ్ల రకాలు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Anyone who knows English can understand and follow these driving directions.","translation":"ఇంగ్లీష్ తెలిసిన ఎవరైనా ఈ డ్రైవింగ్ దిశలను అర్థం చేసుకోవచ్చు మరియు అనుసరించవచ్చు.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"But a computer doesn’t natively understand English; it only understands machine language.","translation":"కానీ కంప్యూటర్ స్థానికంగా ఇంగ్లీష్ అర్థం చేసుకోదు; ఇది మెషిన్ లాంగ్వేజ్ను మాత్రమే అర్థం చేసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To instruct a computer to do something, the instructions must be written in its language.","translation":"కంప్యూటర్ను ఏదైనా చేయమని ఆదేశించడానికి, సూచనలను దాని భాషలో వ్రాయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"An assembler is one form of machine-language translator.","translation":"అసెంబ్లర్ అనేది మెషిన్-లాంగ్వేజ్ ట్రాన్స్లేటర్ యొక్క ఒక రూపం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A compiler converts a high-level language into machine language.","translation":"కంపైలర్ ఒక ఉన్నత స్థాయి భాషను మెషిన్ లాంగ్వేజ్గా మారుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Pseudo-code makes for an excellent introduction to common universal programming concepts.","translation":"సాధారణ సార్వత్రిక ప్రోగ్రామింగ్ భావనలకు సూడో-కోడ్ అద్భుతమైన పరిచయం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can pass variables as arguments to a function in order to modify the way the function operates.","translation":"ఫంక్షన్ ఎలా పనిచేస్తుందో మార్చడానికి మీరు వేరియబుల్స్ను ఫంక్షన్కు వాదనలుగా పంపవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This function describes all the instructions needed to make a turn.","translation":"ఒక మలుపు తిరగడానికి అవసరమైన అన్ని సూచనలను ఈ ఫంక్షన్ వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When a program that knows about this function needs to turn, it can just call this function.","translation":"ఈ ఫంక్షన్ గురించి తెలిసిన ఒక ప్రోగ్రామ్ తిరగవలసి వచ్చినప్పుడు, అది ఈ ఫంక్షన్ను పిలవవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Either left or right can be passed into this function, which causes the function to turn in that direction.","translation":"ఎడమ లేదా కుడి రెండింటినీ ఈ ఫంక్షన్లోకి పంపవచ్చు, ఇది ఫంక్షన్ ఆ దిశలో తిరగడానికి కారణమవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By default in C, functions can return a value to a caller.","translation":"సిలో, ఫంక్షన్లు డిఫాల్ట్గా కాలింగ్కు విలువను తిరిగి ఇవ్వగలవు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Imagine a function that calculates the factorial of a number—naturally, it returns the result.","translation":"ఒక సంఖ్య యొక్క ఫ్యాక్టోరియల్ను లెక్కించే ఫంక్షన్ను ఊహించండి - సహజంగానే, అది ఫలితాన్ని తిరిగి ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In C, functions aren’t labeled with a “function” keyword; instead, they are declared by the data type of the variable they are returning.","translation":"సిలో, ఫంక్షన్లు “ఫంక్షన్” కీవర్డ్తో లేబుల్ చేయబడవు; బదులుగా, అవి తిరిగి ఇచ్చే వేరియబుల్ యొక్క డేటా రకం ద్వారా ప్రకటించబడతాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This function is declared as an integer because it multiplies every value from 1 to x and returns the result, which is an integer.","translation":"ఈ ఫంక్షన్ ఒక పూర్ణాంకంగా ప్రకటించబడింది, ఎందుకంటే ఇది 1 నుండి x వరకు ప్రతి విలువను గుణిస్తుంది మరియు ఫలితాన్ని తిరిగి ఇస్తుంది, ఇది ఒక పూర్ణాంకం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The return statement at the end of the function passes back the contents of the variable x and ends the function.","translation":"ఫంక్షన్ చివరిలో ఉన్న రిటర్న్ స్టేట్మెంట్ వేరియబుల్ x యొక్క విషయాలను తిరిగి పంపుతుంది మరియు ఫంక్షన్ను ముగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This factorial function can then be used like an integer variable in the main part of any program that knows about it.","translation":"ఈ ఫ్యాక్టోరియల్ ఫంక్షన్ను దాని గురించి తెలిసిన ఏదైనా ప్రోగ్రామ్ యొక్క ప్రధాన భాగంలో పూర్ణాంక వేరియబుల్ లాగా ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Also in C, the compiler must “know” about functions before it can use them.","translation":"అలాగే సిలో, కంపైలర్ వాటిని ఉపయోగించే ముందు ఫంక్షన్ల గురించి “తెలుసుకోవాలి”.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This can be done by simply writing the entire function before using it later in the program or by using function prototypes.","translation":"ప్రోగ్రామ్లో తర్వాత ఉపయోగించే ముందు మొత్తం ఫంక్షన్ను వ్రాయడం ద్వారా లేదా ఫంక్షన్ ప్రోటోటైప్లను ఉపయోగించడం ద్వారా దీన్ని చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A function prototype is simply a way to tell the compiler to expect a function with this name, this return data type, and these data types as its functional arguments.","translation":"ఫంక్షన్ ప్రోటోటైప్ అనేది కంపైలర్కు ఈ పేరుతో, ఈ రిటర్న్ డేటా రకం మరియు ఈ డేటా రకాలను దాని ఫంక్షనల్ వాదనలుగా ఫంక్షన్ను ఆశించమని చెప్పడానికి ఒక మార్గం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The actual function can be located near the end of the program, but it can be used any- where else, since the compiler already knows about it.","translation":"నిజమైన ఫంక్షన్ ప్రోగ్రామ్ చివరిలో ఉంచవచ్చు, కానీ కంపైలర్కు ఇప్పటికే దాని గురించి తెలుసు కాబట్టి, మరెక్కడా ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If a function doesn’t have any value to return, it should be declared as void, as is the case with the turn() function I used as an example earlier.","translation":"ఒక ఫంక్షన్ తిరిగి ఇవ్వడానికి ఎటువంటి విలువను కలిగి లేకపోతే, నేను ఇంతకు ముందు ఉదాహరణగా ఉపయోగించిన turn() ఫంక్షన్ విషయంలో వలె, అది శూన్యంగా ప్రకటించబడాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This function includes a section that searches for the proper intersection by looking for street signs, reading the name on each street sign, and storing that name in a variable called current_intersection_name.","translation":"ఈ ఫంక్షన్ వీధి గుర్తులను చూడటం ద్వారా, ప్రతి వీధి గుర్తుపై పేరును చదవడం ద్వారా మరియు ఆ పేరును current_intersection_name అనే వేరియబుల్లో నిల్వ చేయడం ద్వారా సరైన కూడలి కోసం వెతికే ఒక విభాగాన్ని కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It will continue to look for and read street signs until the target street is found; at that point, the remaining turning instructions will be executed.","translation":"లక్ష్య వీధి కనుగొనబడే వరకు ఇది వీధి గుర్తులను వెతకడం మరియు చదవడం కొనసాగిస్తుంది; ఆ సమయంలో, మిగిలిన మలుపు సూచనలు అమలు చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Functions aren’t commonly used in pseudo-code, since pseudo-code is mostly used as a way for programmers to sketch out program concepts before writing compilable code.","translation":"కంపైలబుల్ కోడ్ రాయడానికి ముందు ప్రోగ్రామర్లు ప్రోగ్రామ్ భావనలను స్కెచ్ చేయడానికి ఎక్కువగా ఉపయోగించబడేందున, ఫంక్షన్లు సాధారణంగా సూడో-కోడ్లో ఉపయోగించబడవు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since hacking is really about experimenting, it’s probably best if you have a C compiler to follow along with.","translation":"హ్యాకింగ్ నిజంగా ప్రయోగాలు చేయడం గురించి కాబట్టి, మీరు అనుసరించడానికి సి కంపైలర్ను కలిగి ఉంటే ఇది ఉత్తమంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The main execution of a C program begins in the aptly named main() function.","translation":"సి ప్రోగ్రామ్ యొక్క ప్రధాన అమలు తగిన పేరు గల main() ఫంక్షన్లో ప్రారంభమవుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The character array was defined, so 20 bytes are allocated for it, but only 12 of these bytes are actually used.","translation":"అక్షర శ్రేణి నిర్వచించబడింది, కాబట్టి దాని కోసం 20 బైట్లు కేటాయించబడ్డాయి, కాని వీటిలో 12 బైట్లు మాత్రమే వాస్తవానికి ఉపయోగించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The null byte at the end is used as a delimiter character to tell any function that is dealing with the string to stop operations right there.","translation":"చివరన ఉన్న శూన్య బైట్ స్ట్రింగ్తో వ్యవహరించే ఏదైనా ఫంక్షన్కు కార్యకలాపాలను అక్కడే ఆపమని చెప్పడానికి డెలిమిటర్ అక్షరంగా ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If a null byte is inserted in the fifth element of the character array, only the characters Hello would be printed by the printf() function.","translation":"అక్షర శ్రేణి యొక్క ఐదవ మూలకంలో శూన్య బైట్ చొప్పించబడితే, కేవలం Hello అక్షరాలు మాత్రమే printf() ఫంక్షన్ ద్వారా ముద్రించబడతాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since setting each character in a character array is painstaking and strings are used fairly often, a set of standard functions was created for string manipulation.","translation":"అక్షర శ్రేణిలో ప్రతి అక్షరాన్ని అమర్చడం శ్రమతో కూడుకున్నది మరియు స్ట్రింగ్లను తరచుగా ఉపయోగిస్తారు కాబట్టి, స్ట్రింగ్ మార్పు కోసం ప్రామాణిక ఫంక్షన్ల సమితిని రూపొందించారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"For example, the strcpy() function will copy a string from a source to a destination, iterating through the source string and copying each byte to the destination (and stopping after it copies the null termination byte).","translation":"ఉదాహరణకు, strcpy() ఫంక్షన్ మూలం నుండి గమ్యస్థానానికి ఒక స్ట్రింగ్ను కాపీ చేస్తుంది, సోర్స్ స్ట్రింగ్ ద్వారా పునరావృతం చేస్తుంది మరియు ప్రతి బైట్ను గమ్యస్థానానికి కాపీ చేస్తుంది (మరియు శూన్య ముగింపు బైట్ను కాపీ చేసిన తర్వాత ఆగిపోతుంది).","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The order of the function’s arguments is similar to Intel assembly syntax: destination first and then source.","translation":"ఫంక్షన్ యొక్క వాదనల క్రమం ఇంటెల్ అసెంబ్లీ సింటాక్స్ను పోలి ఉంటుంది: మొదట గమ్యం మరియు తరువాత మూలం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The char_array.c program can be rewritten using strcpy() to accomplish the same thing using the string library.","translation":"స్ట్రింగ్ లైబ్రరీని ఉపయోగించి అదే పనిని సాధించడానికి char_array.c ప్రోగ్రామ్ను strcpy() ఉపయోగించి తిరిగి వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The next version of the char_array program shown below includes string.h since it uses a string function.","translation":"క్రింద చూపిన char_array ప్రోగ్రామ్ యొక్క తదుపరి వెర్షన్ స్ట్రింగ్ ఫంక్షన్ను ఉపయోగిస్తున్నందున string.hని కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Let’s take a look at this program with GDB.","translation":"GDBతో ఈ ప్రోగ్రామ్ను పరిశీలిద్దాం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The debugger will pause the program at each breakpoint, giving us a chance to examine registers and memory.","translation":"డీబగ్గర్ ప్రతి బ్రేక్పాయింట్ వద్ద ప్రోగ్రామ్ను పాజ్ చేస్తుంది, ఇది రిజిస్టర్లు మరియు మెమరీని పరిశీలించడానికి మాకు అవకాశం ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the program is run, the strcpy() breakpoint is resolved.","translation":"ప్రోగ్రామ్ అమలులో ఉన్నప్పుడు, strcpy() బ్రేక్పాయింట్ పరిష్కరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"At each breakpoint, we’re going to look at EIP and the instructions it points to.","translation":"ప్రతి బ్రేక్పాయింట్ వద్ద, మేము EIP మరియు అది సూచించే సూచనలను పరిశీలిస్తాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Notice that the memory location for EIP at the middle breakpoint is different.","translation":"మధ్య బ్రేక్పాయింట్ వద్ద EIP కోసం మెమరీ స్థానం భిన్నంగా ఉందని గమనించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The address in EIP at the middle breakpoint is different because the code for the strcpy() function comes from a loaded library.","translation":"మధ్య బ్రేక్పాయింట్ వద్ద EIP లోని చిరునామా భిన్నంగా ఉంటుంది, ఎందుకంటే strcpy() ఫంక్షన్ కోసం కోడ్ లోడ్ చేయబడిన లైబ్రరీ నుండి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In fact, the debugger shows EIP for the middle breakpoint in the strcpy() function, while EIP at the other two breakpoints is in the main() function.","translation":"వాస్తవానికి, డీబగ్గర్ strcpy() ఫంక్షన్లో మధ్య బ్రేక్పాయింట్ కోసం EIPని చూపుతుంది, అయితే ఇతర రెండు బ్రేక్పాయింట్ల వద్ద EIP main() ఫంక్షన్లో ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I’d like to point out that EIP is able to travel from the main code to the strcpy() code and back again.","translation":"EIP ప్రధాన కోడ్ నుండి strcpy() కోడ్కు మరియు తిరిగి ప్రయాణించగలదని నేను ఎత్తి చూపాలనుకుంటున్నాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each time a function is called, a record is kept on a data structure simply called the stack.","translation":"ఒక ఫంక్షన్ను ప్రతిసారీ పిలిచినప్పుడు, స్టాక్ అని పిలువబడే డేటా స్ట్రక్చర్పై రికార్డ్ ఉంచబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The stack lets EIP return through long chains of function calls.","translation":"స్టాక్ EIP ఫంక్షన్ కాల్ల యొక్క పొడవైన గొలుసుల ద్వారా తిరిగి రావడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In GDB, the bt command can be used to backtrace the stack.","translation":"GDBలో, స్టాక్ను బ్యాక్ట్రేస్ చేయడానికి bt కమాండ్ ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"By default, numerical values in C are signed, which means they can be both negative and positive.","translation":"డిఫాల్ట్గా, Cలోని సంఖ్యా విలువలు సంతకం చేయబడతాయి, అంటే అవి ప్రతికూలంగా మరియు సానుకూలంగా రెండూ కావచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The hacker’s learning process involves understanding how variables work.","translation":"హ్యాకర్ నేర్చుకునే విధానంలో చరరాశులు ఎలా పనిచేస్తాయో అర్థం చేసుకోవడం ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Typecasting allows temporary changes to a variable's data type.","translation":"టైప్కాస్టింగ్ ఒక వేరియబుల్ యొక్క డేటా రకాన్ని తాత్కాలికంగా మార్చడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Dividing integers can lead to incorrect results if not typecast.","translation":"టైప్కాస్ట్ చేయకపోతే పూర్ణాంకాలను విభజించడం వలన తప్పు ఫలితాలు వస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Pointers and typecasting are crucial for memory management.","translation":"మెమరీ నిర్వహణకు పాయింటర్లు మరియు టైప్కాస్టింగ్ చాలా ముఖ్యమైనవి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The compiler demands a data type for every pointer.","translation":"ప్రతి పాయింటర్కు కంపైలర్ ఒక డేటా రకాన్ని కోరుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Pointer arithmetic adjusts the pointer to point at the next value.","translation":"పాయింటర్ అంకగణితం తదుపరి విలువను సూచించడానికి పాయింటర్ను సర్దుబాటు చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Adding 1 to an integer pointer increments the address by 4 bytes.","translation":"ఒక పూర్ణాంక పాయింటర్కు 1ని జోడించడం వలన చిరునామా 4 బైట్ల ద్వారా పెరుగుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The compiler warns about pointers pointing to incompatible data types.","translation":"అనుకూలంగా లేని డేటా రకాలను సూచించే పాయింటర్ల గురించి కంపైలర్ హెచ్చరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Typecasting is a way to change the type of a variable on the fly.","translation":"టైప్కాస్టింగ్ అనేది ఒక వేరియబుల్ రకాన్ని తక్షణమే మార్చడానికి ఒక మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A void pointer is a typeless pointer in C.","translation":"సి లో, శూన్య పాయింటర్ అనేది టైప్లెస్ పాయింటర్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Command-line arguments provide input to programs.","translation":"కమాండ్-లైన్ వాదనలు ప్రోగ్రామ్లకు ఇన్పుట్ను అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The zeroth argument is the name of the executing binary.","translation":"సున్నా వాదన అమలు చేస్తున్న బైనరీ పేరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"atoi() converts a string to an integer.","translation":"atoi() ఒక స్ట్రింగ్ను పూర్ణాంకంగా మారుస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Checking for conditions is important in C.","translation":"సి లో పరిస్థితులను తనిఖీ చేయడం ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Segmentation faults occur due to memory access violations.","translation":"మెమరీ యాక్సెస్ ఉల్లంఘనల కారణంగా సెగ్మెంటేషన్ లోపాలు సంభవిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Variable scoping defines the context of variables.","translation":"వేరియబుల్ స్కోపింగ్ వేరియబుల్స్ యొక్క సందర్భాన్ని నిర్వచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each function has its own set of local variables.","translation":"ప్రతి ఫంక్షన్ దాని స్వంత స్థానిక వేరియబుల్స్ కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Global variables persist across all functions.","translation":"గ్లోబల్ వేరియబుల్స్ అన్ని ఫంక్షన్లలో ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Changes to global variables persist between function calls.","translation":"గ్లోబల్ వేరియబుల్స్కు చేసిన మార్పులు ఫంక్షన్ కాల్ల మధ్య ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Understanding variable scope is crucial for debugging.","translation":"డీబగ్గింగ్ కోసం వేరియబుల్ పరిధిని అర్థం చేసుకోవడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The global variable 'j' is accessible by all functions.","translation":"'j' అనే గ్లోబల్ వేరియబుల్ అన్ని ఫంక్షన్ల ద్వారా యాక్సెస్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Local variables within a function have their own memory space.","translation":"ఒక ఫంక్షన్ లోని లోకల్ వేరియబుల్స్ వాటి స్వంత మెమరీ స్థలాన్ని కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The compiler prioritizes local variables over global variables when they share the same name.","translation":"ఒకే పేరును కలిగి ఉన్నప్పుడు, కంపైలర్ గ్లోబల్ వేరియబుల్స్ కంటే లోకల్ వేరియబుల్స్ కు ప్రాధాన్యతనిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Memory addresses can be printed to understand variable locations.","translation":"వేరియబుల్ స్థానాలను అర్థం చేసుకోవడానికి మెమరీ చిరునామాలను ముద్రించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The 'address-of' operator is used to get the memory address of a variable.","translation":"ఒక వేరియబుల్ యొక్క మెమరీ చిరునామాను పొందడానికి 'address-of' ఆపరేటర్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Static variables retain their value between function calls.","translation":"స్టాటిక్ వేరియబుల్స్ ఫంక్షన్ కాల్స్ మధ్య వాటి విలువను నిలుపుకుంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Global and static variables are stored in separate memory segments.","translation":"గ్లోబల్ మరియు స్టాటిక్ వేరియబుల్స్ ప్రత్యేక మెమరీ విభాగాలలో నిల్వ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The heap segment allows dynamic memory allocation.","translation":"హీప్ విభాగం డైనమిక్ మెమరీ కేటాయింపును అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The stack is used to store local function variables and context.","translation":"లోకల్ ఫంక్షన్ వేరియబుల్స్ మరియు సందర్భాన్ని నిల్వ చేయడానికి స్టాక్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The stack follows a Last-In, First-Out (LIFO) order.","translation":"స్టాక్ లాస్ట్-ఇన్, ఫస్ట్-అవుట్ (LIFO) క్రమాన్ని అనుసరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The ESP register keeps track of the end of the stack.","translation":"ESP రిజిస్టర్ స్టాక్ చివరిని ట్రాక్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The EBP register is used to reference local function variables.","translation":"లోకల్ ఫంక్షన్ వేరియబుల్స్ ను సూచించడానికి EBP రిజిస్టర్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each function call creates a stack frame.","translation":"ప్రతి ఫంక్షన్ కాల్ ఒక స్టాక్ ఫ్రేమ్ ను సృష్టిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The procedure prologue sets up the stack frame.","translation":"ప్రొసీజర్ ప్రోలోగ్ స్టాక్ ఫ్రేమ్ ను సెటప్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Function arguments are pushed onto the stack in reverse order.","translation":"ఫంక్షన్ ఆర్గ్యుమెంట్లు రివర్స్ క్రమంలో స్టాక్ పైకి నెట్టబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The return address is pushed onto the stack during a function call.","translation":"ఫంక్షన్ కాల్ సమయంలో రిటర్న్ చిరునామా స్టాక్ పైకి నెట్టబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The stack frame contains the function's local variables.","translation":"స్టాక్ ఫ్రేమ్ ఫంక్షన్ యొక్క లోకల్ వేరియబుల్స్ ను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The leave instruction restores the stack frame.","translation":"లీవ్ సూచన స్టాక్ ఫ్రేమ్ ను పునరుద్ధరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Understanding memory segmentation is crucial for exploiting vulnerabilities.","translation":"వల్నరబిలిటీలను ఉపయోగించుకోవడానికి మెమరీ విభజనను అర్థం చేసుకోవడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The text segment contains the program's machine code instructions.","translation":"టెక్స్ట్ విభాగం ప్రోగ్రామ్ యొక్క మెషిన్ కోడ్ సూచనలను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Every file has an owner and a group.","translation":"ప్రతి ఫైల్కు ఒక యజమాని మరియు ఒక సమూహం ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"These values can be displayed using ls -l.","translation":"ఈ విలువలను ls -l ఉపయోగించి ప్రదర్శించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Read, write, and execute permissions can be turned on and off.","translation":"చదవడానికి, వ్రాయడానికి మరియు అమలు చేయడానికి అనుమతులు ఆన్ మరియు ఆఫ్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"User permissions describe what the owner of the file can do.","translation":"యూజర్ అనుమతులు ఫైల్ యజమాని ఏమి చేయగలడో వివరిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These fields are also displayed in the front of the ls -l output.","translation":"ఈ ఫీల్డ్లు ls -l అవుట్పుట్ ముందు భాగంలో కూడా ప్రదర్శించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each permission corresponds to a bit flag.","translation":"ప్రతి అనుమతి ఒక బిట్ ఫ్లాగ్కు అనుగుణంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These values can be added together to define permissions.","translation":"అనుమతులను నిర్వచించడానికి ఈ విలువలను కలిపి జోడించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Permissions can also be added or subtracted using chmod.","translation":"chmodని ఉపయోగించి అనుమతులను కూడా జోడించవచ్చు లేదా తీసివేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The first command (chmod 721) gives read, write, and execute permissions.","translation":"మొదటి కమాండ్ (chmod 721) చదవడానికి, వ్రాయడానికి మరియు అమలు చేయడానికి అనుమతులు ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The su command can be used to switch to a different user.","translation":"వేరే వినియోగదారునికి మారడానికి su కమాండ్ ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The root user with user ID 0 is like the administrator account.","translation":"యూజర్ ID 0 ఉన్న రూట్ యూజర్ నిర్వాహక ఖాతా లాంటిది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The sudo command allows a single command to be run as the root user.","translation":"sudo కమాండ్ ఒకే కమాండ్ను రూట్ యూజర్గా అమలు చేయడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These commands provide a simple method to quickly switch between users.","translation":"ఈ ఆదేశాలు వినియోగదారుల మధ్య త్వరగా మారడానికి ఒక సాధారణ పద్ధతిని అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"As the user jose, the simplenote program will run as jose if it is executed.","translation":"జోస్ వినియోగదారుడిగా, simplenote ప్రోగ్రామ్ అమలు చేయబడితే జోస్గా నడుస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This is fine if reader is the only user of the simplenote program.","translation":"రీడర్ ఒక్కరే simplenote ప్రోగ్రామ్ వినియోగదారు అయితే ఇది సరే.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The solution to this problem in Unix is the set user ID (setuid) permission.","translation":"యూనిక్స్లో ఈ సమస్యకు పరిష్కారం సెట్ యూజర్ ID (setuid) అనుమతి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The chsh program has the setuid flag set.","translation":"chsh ప్రోగ్రామ్ సెట్యుఐడి ఫ్లాగ్ను కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This means that a running program has both a real user ID and an effective user ID.","translation":"అంటే నడుస్తున్న ప్రోగ్రామ్కు నిజమైన యూజర్ ID మరియు ప్రభావవంతమైన యూజర్ ID రెండూ ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Sometimes there are multiple variables that should be grouped together and treated like one.","translation":"కొన్నిసార్లు, ఒకే విధంగా సమూహపరచబడే మరియు నిర్వహించబడే బహుళ వేరియబుల్స్ ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When dealing with many time functions, these functions use a time struct called tm.","translation":"అనేక సమయ ఫంక్షన్లతో వ్యవహరించేటప్పుడు, ఈ ఫంక్షన్లు tm అని పిలువబడే సమయ నిర్మాణాన్ని ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The stack frame is popped off the stack, and the EIP is set to the return address so the program can continue execution.","translation":"స్టాక్ ఫ్రేమ్ స్టాక్ నుండి తీసివేయబడుతుంది, మరియు ప్రోగ్రామ్ అమలును కొనసాగించడానికి EIP తిరిగి వచ్చే చిరునామాకు సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If another function was called within the function, another stack frame would be pushed onto the stack, and so on.","translation":"ఫంక్షన్ లోపల మరొక ఫంక్షన్ కాల్ చేయబడితే, మరొక స్టాక్ ఫ్రేమ్ స్టాక్ పైకి నెట్టబడుతుంది, మరియు ఇలాగే కొనసాగుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"As each function ends, its stack frame is popped off of the stack so execution can be returned to the previous function.","translation":"ప్రతి ఫంక్షన్ ముగిసినప్పుడు, దాని స్టాక్ ఫ్రేమ్ స్టాక్ నుండి తీసివేయబడుతుంది, తద్వారా అమలు మునుపటి ఫంక్షన్కు తిరిగి ఇవ్వబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This behavior is the reason this segment of memory is organized in a FILO data structure.","translation":"మెమరీ యొక్క ఈ విభాగం FILO డేటా నిర్మాణంలో నిర్వహించబడటానికి ఈ ప్రవర్తనయే కారణం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The various segments of memory are arranged in the order they were presented, from the lower memory addresses to the higher memory addresses.","translation":"మెమరీ యొక్క వివిధ విభాగాలు అవి అందించబడిన క్రమంలో అమర్చబడి ఉంటాయి, తక్కువ మెమరీ చిరునామాల నుండి ఎక్కువ మెమరీ చిరునామాలకు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since most people are familiar with seeing numbered lists that count downward, the smaller memory addresses are shown at the top.","translation":"ఎక్కువ మంది ప్రజలు క్రిందికి లెక్కించే సంఖ్యా జాబితాలను చూడటానికి అలవాటు పడ్డారు కాబట్టి, చిన్న మెమరీ చిరునామాలు పైన చూపబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Some texts have this reversed, which can be very confusing; so for this book, smaller memory addresses are always shown at the top.","translation":"కొన్ని గ్రంథాలలో ఇది రివర్స్ చేయబడి ఉంటుంది, ఇది చాలా గందరగోళంగా ఉంటుంది; కాబట్టి ఈ పుస్తకం కోసం, చిన్న మెమరీ చిరునామాలు ఎల్లప్పుడూ పైన చూపబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most debuggers also display memory in this style, with the smaller memory addresses at the top and the higher ones at the bottom.","translation":"చాలా డీబగ్గర్లు కూడా ఈ శైలిలో మెమరీని ప్రదర్శిస్తారు, చిన్న మెమరీ చిరునామాలు పైన మరియు పెద్దవి దిగువన ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since the heap and the stack are both dynamic, they both grow in different directions toward each other.","translation":"హీప్ మరియు స్టాక్ రెండూ డైనమిక్ కాబట్టి, అవి రెండూ ఒకదానికొకటి వ్యతిరేక దిశలలో పెరుగుతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This minimizes wasted space, allowing the stack to be larger if the heap is small and vice versa.","translation":"ఇది వృధా స్థలాన్ని తగ్గిస్తుంది, హీప్ చిన్నదిగా ఉంటే స్టాక్ పెద్దదిగా ఉండటానికి మరియు దీనికి విరుద్ధంగా ఉండటానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In C, as in other compiled languages, the compiled code goes into the text segment, while the variables reside in the remaining segments.","translation":"Cలో, ఇతర కంపైల్ చేయబడిన భాషలలో వలె, కంపైల్ చేయబడిన కోడ్ టెక్స్ట్ విభాగంలోకి వెళుతుంది, అయితే వేరియబుల్స్ మిగిలిన విభాగాలలో ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exactly which memory segment a variable will be stored in depends on how the variable is defined.","translation":"ఒక వేరియబుల్ ఏ మెమరీ విభాగంలో నిల్వ చేయబడుతుందనేది వేరియబుల్ ఎలా నిర్వచించబడిందనే దానిపై ఆధారపడి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Variables that are defined outside of any functions are considered to be global.","translation":"ఏదైనా ఫంక్షన్ల వెలుపల నిర్వచించబడిన వేరియబుల్స్ గ్లోబల్గా పరిగణించబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The static keyword can also be prepended to any variable declaration to make the variable static.","translation":"వేరియబుల్ను స్టాటిక్గా చేయడానికి ఏదైనా వేరియబుల్ డిక్లరేషన్కు స్టాటిక్ కీవర్డ్ను కూడా చేర్చవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If static or global variables are initial- ized with data, they are stored in the data memory segment; otherwise, these variables are put in the bss memory segment.","translation":"స్టాటిక్ లేదా గ్లోబల్ వేరియబుల్స్ డేటాతో ప్రారంభించబడితే, అవి డేటా మెమరీ విభాగంలో నిల్వ చేయబడతాయి; లేకపోతే, ఈ వేరియబుల్స్ bss మెమరీ విభాగంలో ఉంచబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Memory on the heap memory segment must first be allocated using a memory allocation function called malloc().","translation":"హీప్ మెమరీ విభాగంలోని మెమరీని మొదట malloc() అనే మెమరీ కేటాయింపు ఫంక్షన్ ఉపయోగించి కేటాయించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Usually, pointers are used to reference memory on the heap.","translation":"సాధారణంగా, హీప్లోని మెమరీని సూచించడానికి పాయింటర్లు ఉపయోగించబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Finally, the remaining function variables are stored in the stack memory segment.","translation":"చివరగా, మిగిలిన ఫంక్షన్ వేరియబుల్స్ స్టాక్ మెమరీ విభాగంలో నిల్వ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Since the stack can contain many different stack frames, stack variables can maintain uniqueness within different functional contexts.","translation":"స్టాక్ చాలా విభిన్న స్టాక్ ఫ్రేమ్లను కలిగి ఉండవచ్చు కాబట్టి, స్టాక్ వేరియబుల్స్ విభిన్న ఫంక్షనల్ సందర్భాలలో ప్రత్యేకతను కాపాడుకోగలవు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The memory_segments.c program will help explain these concepts in C.","translation":"memory_segments.c ప్రోగ్రామ్ Cలో ఈ భావనలను వివరించడానికి సహాయపడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The program demonstrates the use of function pointers.","translation":"ఈ ప్రోగ్రామ్ ఫంక్షన్ పాయింటర్లను ఎలా ఉపయోగించాలో చూపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Function pointers can also be used for functions.","translation":"ఫంక్షన్ పాయింటర్లను ఫంక్షన్ల కోసం కూడా ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The output below shows the compilation and execution of this source code.","translation":"దిగువ అవుట్పుట్ ఈ సోర్స్ కోడ్ యొక్క కంపైలేషన్ మరియు అమలును చూపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since computers are deterministic machines, it is impossible for them to produce truly random numbers.","translation":"కంప్యూటర్లు నిర్ధారిత యంత్రాలు కాబట్టి, అవి నిజంగా యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడం అసాధ్యం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The pseudo-random number generator functions fill this need by generating a stream of numbers that is pseudo-random.","translation":"ఈ అవసరాన్ని నకిలీ-యాదృచ్ఛిక సంఖ్యల జనరేటర్ ఫంక్షన్లు నకిలీ-యాదృచ్ఛిక సంఖ్యల స్ట్రీమ్ను ఉత్పత్తి చేయడం ద్వారా తీరుస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The generator must be seeded with a value using the function srand(), and from that point on, the function rand() will return a pseudo-random number from 0 to RAND_MAX.","translation":"srand() ఫంక్షన్ని ఉపయోగించి జనరేటర్ను ఒక విలువతో సీడ్ చేయాలి మరియు ఆ తర్వాత, rand() ఫంక్షన్ 0 నుండి RAND_MAX వరకు నకిలీ-యాదృచ్ఛిక సంఖ్యను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"One common practice is to use the number of seconds since epoch (returned from the time() function) as the seed.","translation":"సాధారణ అభ్యాసం ఏమిటంటే, సీడ్గా ఎపోక్ నుండి సెకన్ల సంఖ్యను (time() ఫంక్షన్ నుండి తిరిగి ఇవ్వబడుతుంది) ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Notice how the modulus operator is used to obtain random values from 1 to 20.","translation":"1 నుండి 20 వరకు యాదృచ్ఛిక విలువలను పొందడానికి మాడ్యులస్ ఆపరేటర్ ఎలా ఉపయోగించబడుతుందో గమనించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The program’s output just displays random numbers.","translation":"ప్రోగ్రామ్ యొక్క అవుట్పుట్ కేవలం యాదృచ్ఛిక సంఖ్యలను మాత్రమే ప్రదర్శిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Pseudo-randomness can also be used for more complex programs.","translation":"నకిలీ-యాదృచ్ఛికతను మరింత సంక్లిష్టమైన ప్రోగ్రామ్ల కోసం కూడా ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The program uses pseudo-random number generator functions to provide the element of chance.","translation":"అవకాశం యొక్క మూలకాన్ని అందించడానికి ప్రోగ్రామ్ నకిలీ-యాదృచ్ఛిక సంఖ్య జనరేటర్ ఫంక్షన్లను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It has three different game functions, which are called using a single global function pointer.","translation":"ఇది మూడు వేర్వేరు గేమ్ ఫంక్షన్లను కలిగి ఉంది, ఇవి ఒకే గ్లోబల్ ఫంక్షన్ పాయిటర్ని ఉపయోగించి పిలువబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Multi-user file permissions and user IDs allow multiple users to play and maintain their own account data.","translation":"బహుళ-వినియోగదారు ఫైల్ అనుమతులు మరియు వినియోగదారు IDలు బహుళ వినియోగదారులు ఆడటానికి మరియు వారి స్వంత ఖాతా డేటాను నిర్వహించడానికి అనుమతిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This function reads the player data for the current uid from the file.","translation":"ఈ ఫంక్షన్ ప్రస్తుత uid కోసం ప్లేయర్ డేటాను ఫైల్ నుండి చదువుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It returns -1 if it is unable to find player data for the current uid.","translation":"ప్రస్తుత uid కోసం ప్లేయర్ డేటాను కనుగొనలేకపోతే ఇది -1ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is the new user registration function.","translation":"ఇది కొత్త వినియోగదారు నమోదు ఫంక్షన్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It will create a new player account and append it to the file.","translation":"ఇది కొత్త ప్లేయర్ ఖాతాను సృష్టిస్తుంది మరియు దానిని ఫైల్కు జోడిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This function writes the current player data to the file.","translation":"ఈ ఫంక్షన్ ప్రస్తుత ప్లేయర్ డేటాను ఫైల్కు వ్రాస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This function will display the current high score and the name of the person who set that high score.","translation":"ఈ ఫంక్షన్ ప్రస్తుత అత్యధిక స్కోర్ను మరియు ఆ అత్యధిక స్కోర్ను సెట్ చేసిన వ్యక్తి పేరును ప్రదర్శిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This function is used to input the player name, since scanf(\"%s\", &whatever) will stop input at the first space.","translation":"scanf(\"%s\", &whatever) మొదటి స్పేస్లో ఇన్పుట్ను ఆపివేస్తుంది కాబట్టి, ప్లేయర్ పేరును ఇన్పుట్ చేయడానికి ఈ ఫంక్షన్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The secret of hacking is understanding little-known truths like this and using them to produce seemingly magical results.","translation":"హ్యాకింగ్ రహస్యం ఏమిటంటే, ఇలాంటి తక్కువగా తెలిసిన సత్యాలను అర్థం చేసుకోవడం మరియు వాటిని ఉపయోగించి అద్భుతమైన ఫలితాలను సాధించడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exploiting a program is simply a clever way of getting the computer to do what you want it to do.","translation":"ఒక ప్రోగ్రామ్ను ఎక్స్ప్లాయిట్ చేయడం అనేది మీరు కోరుకున్నది చేయడానికి కంప్యూటర్ను పొందడానికి ఒక తెలివైన మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since a program can really only do what it’s designed to do, the security holes are actually flaws or oversights in the design of the program.","translation":"ఒక ప్రోగ్రామ్ దానిని రూపొందించిన విధంగా మాత్రమే చేయగలదు కాబట్టి, భద్రతా లోపాలు వాస్తవానికి ప్రోగ్రామ్ రూపకల్పనలో లోపాలు లేదా లోపాలు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It takes a creative mind to find these holes and to write programs that compensate for them.","translation":"ఈ రంధ్రాలను కనుగొనడానికి మరియు వాటిని భర్తీ చేసే ప్రోగ్రామ్లను వ్రాయడానికి సృజనాత్మక మనస్సు అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Sometimes these holes are the products of relatively obvious programmer errors.","translation":"కొన్నిసార్లు ఈ రంధ్రాలు సాపేక్షంగా స్పష్టమైన ప్రోగ్రామర్ లోపాల ఫలితాలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A program can only do what it’s programmed to do, to the letter of the law.","translation":"ఒక ప్రోగ్రామ్ చట్టానికి అనుగుణంగా, అది ప్రోగ్రామ్ చేయబడినది మాత్రమే చేయగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Unfortunately, what’s written doesn’t always coincide with what the programmer intended the program to do.","translation":"దురదృష్టవశాత్తు, వ్రాసినది ఎల్లప్పుడూ ప్రోగ్రామర్ ప్రోగ్రామ్ను ఏమి చేయాలని కోరుకున్నాడో దానితో సరిపోలదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Sometimes the repercussions can be catastrophic.","translation":"కొన్నిసార్లు పరిణామాలు విపత్తుగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Programmers are human, and sometimes what they write isn’t exactly what they mean.","translation":"ప్రోగ్రామర్లు మానవులు, మరియు కొన్నిసార్లు వారు వ్రాసేది వారు అర్థం చేసుకున్నది కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"For example, one common programming error is called an off-by-one error.","translation":"ఉదాహరణకు, ఒక సాధారణ ప్రోగ్రామింగ్ లోపాన్ని ఆఫ్-బై-వన్ ఎర్రర్ అంటారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If you’re building a 100-foot fence, with fence posts spaced 10 feet apart, how many fence posts do you need?","translation":"మీరు 100 అడుగుల కంచెను నిర్మిస్తుంటే, కంచె పోస్ట్లు 10 అడుగుల దూరంలో ఉంటే, మీకు ఎన్ని కంచె పోస్ట్లు అవసరం?","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This type of off-by-one error is commonly called a fencepost error.","translation":"ఈ రకమైన ఆఫ్-బై-వన్ లోపాన్ని సాధారణంగా ఫెన్స్పోస్ట్ ఎర్రర్ అంటారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Another example is when a programmer is trying to select a range of numbers or items for processing.","translation":"మరొక ఉదాహరణ ఏమిటంటే, ఒక ప్రోగ్రామర్ ప్రాసెసింగ్ కోసం సంఖ్యలు లేదా అంశాల శ్రేణిని ఎంచుకోవడానికి ప్రయత్నిస్తున్నప్పుడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If N = 5 and M = 17, how many items are there to process?","translation":"N = 5 మరియు M = 17 అయితే, ప్రాసెస్ చేయడానికి ఎన్ని అంశాలు ఉన్నాయి?","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Often, fencepost errors go unnoticed because programs aren’t tested for every single possibility.","translation":"తరచుగా, ప్రోగ్రామ్లను ప్రతి ఒక్క అవకాశానికి పరీక్షించనందున ఫెన్స్పోస్ట్ లోపాలు గుర్తించబడవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When properly exploited, an off-by-one error can cause a seemingly secure program to become a security vulnerability.","translation":"సరిగ్గా ఉపయోగించినప్పుడు, ఆఫ్-బై-వన్ లోపం ఒక సురక్షితమైన ప్రోగ్రామ్ను భద్రతా లోపంగా మార్చవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This type of functionality certainly wasn’t what the programmers had intended for a secure program like OpenSSH.","translation":"ఈ రకమైన కార్యాచరణ ఖచ్చితంగా ప్రోగ్రామర్లు OpenSSH వంటి సురక్షిత ప్రోగ్రామ్ కోసం ఉద్దేశించినది కాదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Another situation that seems to breed exploitable programmer errors is when a program is quickly modified to expand its functionality.","translation":"ఎక్స్ప్లాయిటబుల్ ప్రోగ్రామర్ లోపాలను పెంచే మరొక పరిస్థితి ఏమిటంటే, దాని కార్యాచరణను విస్తరించడానికి ఒక ప్రోగ్రామ్ను త్వరగా సవరించినప్పుడు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Microsoft’s IIS webserver program is designed to serve static and interactive web content to users.","translation":"Microsoft యొక్క IIS వెబ్సర్వర్ ప్రోగ్రామ్ వినియోగదారులకు స్టాటిక్ మరియు ఇంటరాక్టివ్ వెబ్ కంటెంట్ను అందించడానికి రూపొందించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Both the Sadmind worm and the CodeRed worm used this type of Unicode conversion oversight to deface web pages.","translation":"సాడ్మైండ్ వార్మ్ మరియు కోడ్రెడ్ వార్మ్ రెండూ వెబ్పేజీలను చెరిపివేయడానికి ఈ రకమైన యూనికోడ్ మార్పిడిని ఉపయోగించాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"SIGSEGV, Segmentation fault.","translation":"SIGSEGV, విభజన లోపం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Recall from the previous chapter that the stack is one of five memory segments used by programs.","translation":"మునుపటి అధ్యాయం నుండి గుర్తుంచుకోండి, స్టాక్ అనేది ప్రోగ్రామ్లు ఉపయోగించే ఐదు మెమరీ విభాగాలలో ఒకటి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The stack is a FILO data structure used to maintain execution flow and context for local variables during function calls.","translation":"స్టాక్ అనేది ఫంక్షన్ కాల్ల సమయంలో స్థానిక వేరియబుల్స్ కోసం అమలు ప్రవాహం మరియు సందర్భాన్ని నిర్వహించడానికి ఉపయోగించే FILO డేటా నిర్మాణం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When a function is called, a structure called a stack frame is pushed onto the stack, and the EIP register jumps to the first instruction of the function.","translation":"ఒక ఫంక్షన్ కాల్ చేసినప్పుడు, స్టాక్ ఫ్రేమ్ అని పిలువబడే ఒక నిర్మాణం స్టాక్పైకి నెట్టబడుతుంది మరియు EIP రిజిస్టర్ ఫంక్షన్ యొక్క మొదటి సూచనకు వెళుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each stack frame contains the local variables for that function and a return address so EIP can be restored.","translation":"ప్రతి స్టాక్ ఫ్రేమ్లో ఆ ఫంక్షన్ కోసం స్థానిక వేరియబుల్స్ మరియు తిరిగి వచ్చే చిరునామా ఉంటాయి, తద్వారా EIPని పునరుద్ధరించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the function is done, the stack frame is popped off the stack and the return address is used to restore EIP.","translation":"ఫంక్షన్ పూర్తయినప్పుడు, స్టాక్ ఫ్రేమ్ స్టాక్ నుండి తీసివేయబడుతుంది మరియు EIPని పునరుద్ధరించడానికి తిరిగి వచ్చే చిరునామా ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"All of this is built in to the architecture and is usually handled by the compiler, not the programmer.","translation":"ఇదంతా ఆర్కిటెక్చర్లో నిర్మించబడింది మరియు సాధారణంగా ప్రోగ్రామర్ ద్వారా కాకుండా కంపైలర్ ద్వారా నిర్వహించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the check_authentication() function is called, a new stack frame is pushed onto the stack above main()’s stack frame.","translation":"check_authentication() ఫంక్షన్ కాల్ చేసినప్పుడు, కొత్త స్టాక్ ఫ్రేమ్ main() యొక్క స్టాక్ ఫ్రేమ్కు పైన ఉన్న స్టాక్పైకి నెట్టబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In this frame are the local variables, a return address, and the function’s arguments.","translation":"ఈ ఫ్రేమ్లో స్థానిక వేరియబుల్స్, తిరిగి వచ్చే చిరునామా మరియు ఫంక్షన్ యొక్క వాదనలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exploitation129","translation":"ఎక్స్ప్లోయిటేషన్129","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If the program is compiled with the flag -fomit-frame-pointer for optimiza- tion, the frame pointer won’t be used in the stack frame.","translation":"-fomit-frame-pointer ఫ్లాగ్తో ప్రోగ్రామ్ను ఆప్టిమైజేషన్ కోసం కంపైల్ చేస్తే, ఫ్రేమ్ పాయింటర్ స్టాక్ ఫ్రేమ్లో ఉపయోగించబడదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The return address in a stack frame can be located by understanding how the stack frame is created.","translation":"స్టాక్ ఫ్రేమ్ ఎలా సృష్టించబడిందో అర్థం చేసుకోవడం ద్వారా స్టాక్ ఫ్రేమ్లోని తిరిగి వచ్చే చిరునామాను గుర్తించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This process begins in the main() function, even before the function call.","translation":"ఈ ప్రక్రియ ఫంక్షన్ కాల్కు ముందే main() ఫంక్షన్లో ప్రారంభమవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Notice the two lines shown in bold on page 131.","translation":"131వ పేజీలో బోల్డ్లో చూపిన రెండు లైన్లను గమనించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"At this point, the EAX register contains a pointer to the first command-line argument.","translation":"ఈ సమయంలో, EAX రిజిస్టర్ మొదటి కమాండ్-లైన్ వాదనకు పాయింటర్ను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is also the argument to check_authentication().","translation":"ఇది check_authentication()కి కూడా వాదన.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This instruction pushes the address of the next instruction to the stack and moves the execution pointer register (EIP) to the start of the check_authentication() function.","translation":"ఈ సూచన తదుపరి సూచన యొక్క చిరునామాను స్టాక్కి నెట్టివేస్తుంది మరియు ఎగ్జిక్యూషన్ పాయింటర్ రిజిస్టర్ (EIP)ని check_authentication() ఫంక్షన్ ప్రారంభానికి తరలిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This gives us more control; however, we are still limited to using instructions that exist in the original programming.","translation":"ఇది మనకు మరింత నియంత్రణను ఇస్తుంది; అయితే, అసలు ప్రోగ్రామింగ్లో ఉన్న సూచనలను ఉపయోగించడానికే మేము పరిమితం చేయబడ్డాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The notesearch program is vulnerable to a buffer overflow on the line marked in bold here.","translation":"నోట్సెర్చ్ ప్రోగ్రామ్ ఇక్కడ బోల్డ్లో గుర్తించబడిన లైన్లో బఫర్ ఓవర్ఫ్లోకు గురవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The notesearch exploit uses a similar technique to overflow a buffer into the return address; however, it also injects its own instructions into memory and then returns execution there.","translation":"నోట్సెర్చ్ ఎక్స్ప్లోయిట్ రిటర్న్ చిరునామాలోకి బఫర్ను ఓవర్ఫ్లో చేయడానికి ఇలాంటి టెక్నిక్ను ఉపయోగిస్తుంది; అయితే, ఇది దాని స్వంత సూచనలను మెమరీలోకి కూడా ఇంజెక్ట్ చేస్తుంది మరియు ఆపై అక్కడ అమలును తిరిగి ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The variable 'i' in main()’s stack frame is used as a point of reference.","translation":"ప్రధాన() యొక్క స్టాక్ ఫ్రేమ్లో 'i' వేరియబుల్ సూచన బిందువుగా ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Then an offset is subtracted from that value; the result is the target return address.","translation":"అప్పుడు ఆ విలువ నుండి ఆఫ్సెట్ తీసివేయబడుతుంది; ఫలితం లక్ష్య రిటర్న్ చిరునామా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This offset was previously deter- mined to be 270, but how is this number calculated?","translation":"ఈ ఆఫ్సెట్ ఇంతకు ముందు 270గా నిర్ణయించబడింది, కానీ ఈ సంఖ్యను ఎలా లెక్కిస్తారు?","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The easiest way to determine this offset is experimentally.","translation":"ఈ ఆఫ్సెట్ను గుర్తించడానికి సులభమైన మార్గం ప్రయోగాత్మకంగా.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The debugger will shift memory around slightly and will drop privileges when the suid root notesearch program is executed, making debugging much less useful in this case.","translation":"డీబగ్గర్ మెమరీని కొద్దిగా మారుస్తుంది మరియు suid రూట్ నోట్సెర్చ్ ప్రోగ్రామ్ అమలు చేయబడినప్పుడు అధికారాలను వదులుకుంటుంది, ఈ సందర్భంలో డీబగ్గింగ్ను చాలా తక్కువ ఉపయోగకరంగా చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since the notesearch exploit allows an optional command-line argument to define the offset, different offsets can quickly be tested.","translation":"నోట్సెర్చ్ ఎక్స్ప్లోయిట్ ఆఫ్సెట్ను నిర్వచించడానికి ఒక ఐచ్ఛిక కమాండ్-లైన్ వాదనను అనుమతించినందున, వేర్వేరు ఆఫ్సెట్లను త్వరగా పరీక్షించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"However, doing this manually is tedious and stupid.","translation":"అయితే, దీన్ని మాన్యువల్గా చేయడం చాలా కష్టం మరియు глупо.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"BASH also has a for loop that can be used to automate this process.","translation":"BASH కూడా ఈ ప్రక్రియను స్వయంచాలకంగా చేయడానికి ఉపయోగించే for లూప్ను కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The seq command is a simple program that generates sequences of numbers, which is typically used with looping.","translation":"seq కమాండ్ అనేది సంఖ్యల శ్రేణులను ఉత్పత్తి చేసే ఒక సాధారణ ప్రోగ్రామ్, ఇది సాధారణంగా లూపింగ్తో ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When only two arguments are used, all the numbers from the first argu- ment to the second are generated.","translation":"రెండు వాదనలు మాత్రమే ఉపయోగించినప్పుడు, మొదటి వాదన నుండి రెండవ వాదన వరకు ఉన్న అన్ని సంఖ్యలు ఉత్పత్తి చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When three arguments are used, the middle argument dictates how much to increment each time.","translation":"మూడు వాదనలు ఉపయోగించినప్పుడు, మధ్య వాదన ప్రతిసారీ ఎంత పెంచాలో నిర్దేశిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This can be used with command substitution to drive BASH’s for loop.","translation":"BASH యొక్క for లూప్ను నడపడానికి దీన్ని కమాండ్ ప్రత్యామ్నాయంతో ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The function of the for loop should be familiar, even if the syntax is a little different.","translation":"for లూప్ యొక్క ఫంక్షన్ తెలిసినదిగా ఉండాలి, సింటాక్స్ కొద్దిగా భిన్నంగా ఉన్నప్పటికీ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The shell variable $i iterates through all the values found in the grave accents (generated by seq).","translation":"షెల్ వేరియబుల్ $i గురుతర యాసలలో (seq ద్వారా ఉత్పత్తి చేయబడిన) కనుగొనబడిన అన్ని విలువల ద్వారా పునరావృతమవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Then everything between the do and done keywords is executed.","translation":"అప్పుడు do మరియు done కీలక పదాల మధ్య ఉన్న ప్రతిదీ అమలు చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This can be used to quickly test many different offsets.","translation":"ఇది అనేక విభిన్న ఆఫ్సెట్లను త్వరగా పరీక్షించడానికి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Since the NOP sled is 60 bytes long, and we can return anywhere on the sled, there is about 60 bytes of wiggle room.","translation":"NOP స్లెడ్ 60 బైట్ల పొడవు ఉన్నందున, మరియు మేము స్లెడ్పై ఎక్కడైనా తిరిగి రావచ్చు, దాదాపు 60 బైట్ల విగ్గిల్ రూమ్ ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"We can safely increment the offset loop with a step of 30 with no danger of missing the sled.","translation":"స్లెడ్ను కోల్పోయే ప్రమాదం లేకుండా 30 దశతో ఆఫ్సెట్ లూప్ను సురక్షితంగా పెంచవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the right offset is used, the return address is overwritten with a value that points somewhere on the NOP sled.","translation":"సరైన ఆఫ్సెట్ను ఉపయోగించినప్పుడు, రిటర్న్ చిరునామా NOP స్లెడ్పై ఎక్కడో సూచించే విలువతో తిరిగి వ్రాయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When execution tries to return to that location, it will just slide down the NOP sled into the injected shellcode instructions.","translation":"ఎగ్జిక్యూషన్ ఆ స్థానానికి తిరిగి రావడానికి ప్రయత్నించినప్పుడు, అది ఇంజెక్ట్ చేయబడిన షెల్కోడ్ సూచనలలో NOP స్లెడ్ను జారిపోతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The program uses two %n format parameters in its printf() statement.","translation":"ప్రోగ్రామ్ దాని printf() స్టేట్మెంట్లో రెండు %n ఫార్మాట్ పారామీటర్లను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When a format function encounters a %n format parameter, it writes the number of bytes that have been written by the function to the address in the corresponding function argument.","translation":"ఫార్మాట్ ఫంక్షన్ %n ఫార్మాట్ పారామీటర్ను ఎదుర్కొన్నప్పుడు, ఫంక్షన్ ద్వారా వ్రాయబడిన బైట్ల సంఖ్యను సంబంధిత ఫంక్షన్ ఆర్గ్యుమెంట్లో ఉన్న చిరునామాకు వ్రాస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The stack will look like the diagram here.","translation":"ఇక్కడ ఉన్న రేఖాచిత్రం వలె స్టాక్ కనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Sometimes programmers use printf(string) instead of printf(\"%s\", string) to print strings.","translation":"కొన్నిసార్లు ప్రోగ్రామర్లు స్ట్రింగ్లను ప్రింట్ చేయడానికి printf(\"%s\", string)కి బదులుగా printf(string)ని ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"But what happens if the string contains a format parameter?","translation":"కానీ స్ట్రింగ్లో ఫార్మాట్ పారామీటర్ ఉంటే ఏమి జరుగుతుంది?","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This process can be used repeatedly to examine stack memory.","translation":"స్టాక్ మెమరీని పరీక్షించడానికి ఈ ప్రక్రియను పదేపదే ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The %s format parameter can be used to read from arbitrary memory addresses.","translation":"%s ఫార్మాట్ పారామీటర్ను ఏకపక్ష మెమరీ చిరునామాల నుండి చదవడానికి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If the fourth format parameter is %s instead of %x, the format function will attempt to print the string located at 0x41414141.","translation":"నాల్గవ ఫార్మాట్ పారామీటర్ %xకి బదులుగా %s అయితే, ఫార్మాట్ ఫంక్షన్ 0x41414141 వద్ద ఉన్న స్ట్రింగ్ను ప్రింట్ చేయడానికి ప్రయత్నిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Here the getenvaddr program is used to get the address for the environment variable PATH.","translation":"ఇక్కడ getenvaddr ప్రోగ్రామ్ PATH అనే ఎన్విరాన్మెంట్ వేరియబుల్ కోసం చిరునామాను పొందడానికి ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Now that the distance between the end of the stack frame and the beginning of the format string memory is known, the field-width arguments can be omitted in the %x format parameters.","translation":"స్టాక్ ఫ్రేమ్ ముగింపు మరియు ఫార్మాట్ స్ట్రింగ్ మెమరీ ప్రారంభం మధ్య దూరం తెలిసినందున, ఫీల్డ్-విడ్త్ ఆర్గ్యుమెంట్లను %x ఫార్మాట్ పారామీటర్లలో వదిలివేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If the %s format parameter can be used to read an arbitrary memory address, you should be able to use the same technique with %n to write to an arbitrary memory address.","translation":"%s ఫార్మాట్ పారామీటర్ను ఏకపక్ష మెమరీ చిరునామాను చదవడానికి ఉపయోగించగలిగితే, మీరు %nతో అదే టెక్నిక్ను ఉపయోగించి ఏకపక్ష మెమరీ చిరునామాకు వ్రాయగలరు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"By manipulating the field-width option of one of the format parameters before the %n, a certain number of blank spaces can be inserted, resulting in the output having some blank lines.","translation":"%n ముందు ఫార్మాట్ పారామీటర్లలో ఒకదాని ఫీల్డ్-విడ్త్ ఎంపికను మార్చడం ద్వారా, నిర్దిష్ట సంఖ్యలో ఖాళీ స్థలాలను చేర్చవచ్చు, దీని ఫలితంగా అవుట్పుట్లో కొన్ని ఖాళీ లైన్లు ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This approach will work for small numbers, but it won’t work for larger ones, like memory addresses.","translation":"ఈ విధానం చిన్న సంఖ్యలకు పని చేస్తుంది, కానీ మెమరీ చిరునామాలు వంటి పెద్ద వాటికి పని చేయదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If four writes are done at sequential memory addresses, the least significant byte can be written to each byte of a four-byte word.","translation":"నాలుగు రచనలు సీక్వెన్షియల్ మెమరీ చిరునామాలలో చేస్తే, తక్కువ ముఖ్యమైన బైట్ను నాలుగు-బైట్ పదంలోని ప్రతి బైట్కు వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This is getting tricky.","translation":"ఇది కష్టతరంగా మారుతోంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Let’s give it a try.","translation":"ఒకసారి ప్రయత్నిద్దాం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This process can be repeated for the third and fourth writes.","translation":"ఈ ప్రక్రియను మూడవ మరియు నాల్గవ రచనల కోసం పునరావృతం చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"With each write, bytes of the next_val variable, adjacent to test_val, are being overwritten.","translation":"ప్రతి వ్రాతతో, test_valకి ఆనుకుని ఉన్న next_val వేరియబుల్ యొక్క బైట్లు తిరిగి వ్రాయబడుతున్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Direct parameter access is a way to simplify format string exploits.","translation":"డైరెక్ట్ పారామీటర్ యాక్సెస్ అనేది ఫార్మాట్ స్ట్రింగ్ ఎక్స్ప్లోయిట్లను సరళీకృతం చేయడానికి ఒక మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"For example, %n$d would access the nth parameter and display it as a decimal number.","translation":"ఉదాహరణకు, %n$d nth పారామీటర్ను యాక్సెస్ చేస్తుంది మరియు దానిని దశాంశ సంఖ్యగా ప్రదర్శిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"one of these hashes in the password field will make the password for the account be password, regardless of the salt value used.","translation":"పాస్వర్డ్ ఫీల్డ్లోని ఈ హ్యాష్లలో ఒకటి ఖాతా కోసం పాస్వర్డ్ను పాస్వర్డ్గా చేస్తుంది, ఉప్పు విలువతో సంబంధం లేకుండా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The line to append to /etc/passwd should look something like this: myroot:XXq2wKiyI43A2:0:0:me:/root:/bin/bash","translation":"/etc/passwdకి జోడించాల్సిన లైన్ ఇలా ఉండాలి: myroot:XXq2wKiyI43A2:0:0:me:/root:/bin/bash","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"However, the nature of this particular heap overflow exploit won’t allow that exact line to be written to /etc/passwd, because the string must end with /etc/passwd.","translation":"అయితే, ఈ నిర్దిష్ట హీప్ ఓవర్ఫ్లో ఎక్స్ప్లాయిట్ స్వభావం ఆ ఖచ్చితమైన లైన్ను /etc/passwdకి వ్రాయడానికి అనుమతించదు, ఎందుకంటే స్ట్రింగ్ /etc/passwdతో ముగియాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This can be compensated for with the clever use of a symbolic file link, so the entry can both end with /etc/passwd and still be a valid line in the password file.","translation":"చిహ్నపరమైన ఫైల్ లింక్ను తెలివిగా ఉపయోగించడం ద్వారా దీనిని భర్తీ చేయవచ్చు, కాబట్టి ఎంట్రీ /etc/passwdతో ముగుస్తుంది మరియు ఇప్పటికీ పాస్వర్డ్ ఫైల్లో చెల్లుబాటు అయ్యే లైన్గా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Here’s how it works: reader@hacking:~/booksrc $ mkdir /tmp/etc","translation":"ఇది ఎలా పని చేస్తుందో ఇక్కడ ఉంది: reader@hacking:~/booksrc $ mkdir /tmp/etc","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Now /tmp/etc/passwd points to the login shell /bin/bash.","translation":"ఇప్పుడు /tmp/etc/passwd లాగిన్ షెల్ /bin/bashకి సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This means that a valid login shell for the password file is also /tmp/etc/passwd, making the following a valid password file line: myroot:XXq2wKiyI43A2:0:0:me:/root:/tmp/etc/passwd","translation":"అంటే పాస్వర్డ్ ఫైల్ కోసం చెల్లుబాటు అయ్యే లాగిన్ షెల్ కూడా /tmp/etc/passwd, ఇది క్రింది వాటిని చెల్లుబాటు అయ్యే పాస్వర్డ్ ఫైల్ లైన్గా చేస్తుంది: myroot:XXq2wKiyI43A2:0:0:me:/root:/tmp/etc/passwd","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The values of this line just need to be slightly modified so that the portion before /etc/passwd is exactly 104 bytes long:","translation":"ఈ లైన్ యొక్క విలువలు కొద్దిగా సవరించబడాలి, తద్వారా /etc/passwd ముందు భాగం సరిగ్గా 104 బైట్ల పొడవు ఉంటుంది:","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If /etc/passwd is added to the end of that final string (shown in bold), the string above will be appended to the end of the /etc/passwd file.","translation":"/etc/passwdని ఆ చివరి స్ట్రింగ్ చివరన జోడిస్తే (బోల్డ్లో చూపబడింది), పై స్ట్రింగ్ /etc/passwd ఫైల్ చివరన జోడించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"And since this line defines an account with root privileges with a password we set, it won’t be difficult to access this account and obtain root access, as the following output shows.","translation":"మరియు ఈ లైన్ మనం సెట్ చేసిన పాస్వర్డ్తో రూట్ అధికారాలతో ఖాతాను నిర్వచిస్తుంది కాబట్టి, ఈ ఖాతాను యాక్సెస్ చేయడం మరియు రూట్ యాక్సెస్ను పొందడం కష్టం కాదు, కింది అవుట్పుట్ చూపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If you have played with the game_of_chance.c program enough, you will realize that, similar to at a casino, most of the games are statistically weighted in favor of the house.","translation":"మీరు game_of_chance.c ప్రోగ్రామ్తో సరిగ్గా ఆడి ఉంటే, మీరు గమనిస్తారు, క్యాసినోలో ఉన్నట్లే, చాలా ఆటలు గణాంకపరంగా ఇంటికి అనుకూలంగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Perhaps there’s a way to even the odds a bit.","translation":"బహుశా అసమానతలను కొద్దిగా సమం చేయడానికి ఒక మార్గం ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This program uses a function pointer to remember the last game played.","translation":"ఈ ప్రోగ్రామ్ చివరిసారిగా ఆడిన గేమ్ను గుర్తుంచుకోవడానికి ఫంక్షన్ పాయింటర్ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The name buffer in the user structure is a likely place for an overflow.","translation":"యూజర్ స్ట్రక్చర్లోని పేరు బఫర్ ఓవర్ఫ్లో కోసం ఒక ప్రదేశం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This function only stops inputting at a newline character.","translation":"ఈ ఫంక్షన్ కొత్త లైన్ అక్షరం వద్ద మాత్రమే ఇన్పుట్ను ఆపివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"There is nothing to limit it to the length of the destination name buffer, meaning an overflow is possible.","translation":"గమ్యస్థాన పేరు బఫర్ యొక్క పొడవుకు పరిమితి లేదు, అంటే ఓవర్ఫ్లో సాధ్యమే.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In order to take advantage of the overflow, we need to make the program call the function pointer after it is overwritten.","translation":"ఓవర్ఫ్లోను ఉపయోగించుకోవడానికి, అది తిరిగి వ్రాయబడిన తర్వాత ప్రోగ్రామ్ ఫంక్షన్ పాయింటర్ను పిలిచేలా మనం చేయాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This means that in order to get the program to call the function pointer without overwriting it, a game must be played first to set the last_game variable.","translation":"అంటే ప్రోగ్రామ్ దాన్ని తిరిగి వ్రాయకుండా ఫంక్షన్ పాయింటర్ను పిలిచేలా చేయడానికి, last_game వేరియబుల్ను సెట్ చేయడానికి మొదట ఒక ఆట ఆడాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The jackpot() function is a wonderful target for this exploit.","translation":"ఈ ఎక్స్ప్లాయిట్ కోసం జాక్పాట్() ఫంక్షన్ ఒక అద్భుతమైన లక్ష్యం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This same technique can be used to script everything needed for the exploit.","translation":"ఎక్స్ప్లాయిట్ కోసం అవసరమైన ప్రతిదాన్ని స్క్రిప్ట్ చేయడానికి ఇదే టెక్నిక్ను ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The OSI model provides standards for communication.","translation":"OSI మోడల్ కమ్యూనికేషన్ కోసం ప్రమాణాలను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Routers and firewalls use the OSI model.","translation":"రౌటర్లు మరియు ఫైర్వాల్లు OSI మోడల్ను ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The physical layer deals with the physical connection.","translation":"భౌతిక పొర భౌతిక కనెక్షన్తో వ్యవహరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Data-link layer provides error correction.","translation":"డేటా-లింక్ లేయర్ లోపం దిద్దుబాటును అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The network layer provides addressing and routing.","translation":"నెట్వర్క్ లేయర్ చిరునామా మరియు రూటింగ్ను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The transport layer provides reliable data transfer.","translation":"రవాణా పొర నమ్మదగిన డేటా బదిలీని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The application layer keeps track of application requirements.","translation":"అప్లికేషన్ లేయర్ అప్లికేషన్ అవసరాలను ట్రాక్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Packets contain implementations of protocol layers.","translation":"ప్యాకెట్లు ప్రోటోకాల్ లేయర్ల అమలులను కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Encapsulation is the process of wrapping layers.","translation":"ఎన్క్యాప్సులేషన్ అనేది పొరలను చుట్టే ప్రక్రియ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The header contains protocol information.","translation":"హెడర్లో ప్రోటోకాల్ సమాచారం ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The body contains the data for that layer.","translation":"బాడీ ఆ పొరకు సంబంధించిన డేటాను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Web browsers use HTTP for communication.","translation":"వెబ్ బ్రౌజర్లు కమ్యూనికేషన్ కోసం HTTPని ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Routers only need to implement protocols up to the network layer.","translation":"రౌటర్లు నెట్వర్క్ లేయర్ వరకు మాత్రమే ప్రోటోకాల్లను అమలు చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Sockets are a standard way to perform network communication.","translation":"సాకెట్లు నెట్వర్క్ కమ్యూనికేషన్ను నిర్వహించడానికి ఒక ప్రామాణిక మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Stream sockets provide reliable two-way communication.","translation":"స్ట్రీమ్ సాకెట్లు నమ్మదగిన రెండు-మార్గాల కమ్యూనికేషన్ను అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"TCP is used by web servers and mail servers.","translation":"వెబ్ సర్వర్లు మరియు మెయిల్ సర్వర్ల ద్వారా TCP ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Datagram sockets are unreliable and one-way.","translation":"డేటాగ్రామ్ సాకెట్లు నమ్మదగినవి కావు మరియు ఏకపక్షంగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"UDP is used in networked games and streaming media.","translation":"UDP నెట్వర్క్ చేయబడిన గేమ్లు మరియు స్ట్రీమింగ్ మీడియాలో ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Socket functions are used to send and receive data.","translation":"డేటాను పంపడానికి మరియు స్వీకరించడానికి సాకెట్ ఫంక్షన్లు ఉపయోగించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The bind() call binds a socket to an address.","translation":"బైండ్() కాల్ సాకెట్ను చిరునామాకు బంధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The second format parameter accesses the fourth parameter and uses a field width option of 05.","translation":"రెండవ ఫార్మాట్ పరామితి నాల్గవ పరామితిని యాక్సెస్ చేస్తుంది మరియు 05 యొక్క ఫీల్డ్ వెడల్పు ఎంపికను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This method of direct access eliminates the need to step through memory until the beginning of the format string is located, since this memory can be accessed directly.","translation":"డైరెక్ట్ యాక్సెస్ యొక్క ఈ పద్ధతి ఫార్మాట్ స్ట్రింగ్ ప్రారంభం వరకు మెమరీ ద్వారా వెళ్ళవలసిన అవసరాన్ని తొలగిస్తుంది, ఎందుకంటే ఈ మెమరీని నేరుగా యాక్సెస్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since this is being done on the command line and the dollar sign is a special character, it must be escaped with a backslash.","translation":"ఇది కమాండ్ లైన్లో చేయబడుతున్నందున మరియు డాలర్ గుర్తు ఒక ప్రత్యేక అక్షరం, దీనిని బ్యాక్స్లాష్తో తప్పనిసరిగా తప్పించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exploitation181 Direct parameter access also simplifies the writing of memory addresses.","translation":"ఎక్స్ప్లోయిటేషన్181 డైరెక్ట్ పరామితి యాక్సెస్ మెమరీ చిరునామాలను రాయడాన్ని కూడా సులభతరం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since memory can be accessed directly, there’s no need for four-byte spacers of junk data to increment the byte output count.","translation":"మెమరీని నేరుగా యాక్సెస్ చేయవచ్చు కాబట్టి, బైట్ అవుట్పుట్ గణనను పెంచడానికి నాలుగు-బైట్ స్పేసర్ల జంక్ డేటా అవసరం లేదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"For practice, let’s use direct parameter access to write a more realistic-looking address of 0xbffffd72 into the variable test_vals.","translation":"అభ్యాసం కోసం, test_vals వేరియబుల్లోకి 0xbffffd72 యొక్క మరింత వాస్తవిక రూపాన్ని అందించడానికి ప్రత్యక్ష పరామితి యాక్సెస్ను ఉపయోగిద్దాం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each of the %x format param- eters that usually performs this function can just directly access a piece of memory found before the format string.","translation":"%x ఫార్మాట్ పరామితులలో ప్రతి ఒక్కటి సాధారణంగా ఈ పనిని నిర్వహిస్తుంది, ఫార్మాట్ స్ట్రింగ్ ముందు కనుగొనబడిన మెమరీ భాగాన్ని నేరుగా యాక్సెస్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Direct parameter access is only used for the %n parameters, since it really doesn’t matter what values are used for the %x spacers.","translation":"%n పరామితుల కోసం మాత్రమే డైరెక్ట్ పరామితి యాక్సెస్ ఉపయోగించబడుతుంది, ఎందుకంటే %x స్పేసర్ల కోసం ఏ విలువలు ఉపయోగించబడుతున్నాయో అది నిజంగా ముఖ్యం కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This method simplifies the process of writing an address and shrinks the mandatory size of the format string.","translation":"ఈ పద్ధతి చిరునామాను వ్రాసే ప్రక్రియను సరళీకృతం చేస్తుంది మరియు ఫార్మాట్ స్ట్రింగ్ యొక్క తప్పనిసరి పరిమాణాన్ని తగ్గిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A short is typically a two-byte word, and format parameters have a special way of dealing with them.","translation":"ఒక చిన్నది సాధారణంగా రెండు-బైట్ పదం, మరియు ఫార్మాట్ పరామితులకు వాటిని నిర్వహించడానికి ఒక ప్రత్యేక మార్గం ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This can be used with format string exploits to write two-byte shorts.","translation":"రెండు-బైట్ షార్ట్లను వ్రాయడానికి ఫార్మాట్ స్ట్రింగ్ ఎక్స్ప్లోయిట్లతో దీన్ని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Using short writes, an entire four-byte value can be overwritten with just two %hn parameters.","translation":"చిన్న రచనలను ఉపయోగించి, కేవలం రెండు %hn పరామితులతో మొత్తం నాలుగు-బైట్ విలువను తిరిగి వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In the example below, the test_val variable will be over- written once again with the address 0xbffffd72.","translation":"దిగువ ఉదాహరణలో, test_val వేరియబుల్ చిరునామా 0xbffffd72తో మరోసారి తిరిగి వ్రాయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The ability to overwrite arbitrary memory addresses implies the ability to control the execution flow of the program.","translation":"స్వేచ్ఛానుసార మెమరీ చిరునామాలను తిరిగి వ్రాయగల సామర్థ్యం ప్రోగ్రామ్ యొక్క అమలు ప్రవాహాన్ని నియంత్రించే సామర్థ్యాన్ని సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"While this is a possible option, there are other targets that have more predictable memory addresses.","translation":"ఇది ఒక అవకాశం అయినప్పటికీ, మరింత ఊహించదగిన మెమరీ చిరునామాలను కలిగి ఉన్న ఇతర లక్ష్యాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Constructor functions are executed before the main() function is executed, and destructor functions are executed just before the main() function exits with an exit system call.","translation":"మెయిన్() ఫంక్షన్ అమలు చేయడానికి ముందు కన్స్ట్రక్టర్ ఫంక్షన్లు అమలు చేయబడతాయి మరియు ఎగ్జిట్ సిస్టమ్ కాల్తో మెయిన్() ఫంక్షన్ నిష్క్రమించే ముందు డిస్ట్రక్టర్ ఫంక్షన్లు అమలు చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The destructor functions and the .dtors table section are of particular interest.","translation":"డిస్ట్రక్టర్ ఫంక్షన్లు మరియు .dtors పట్టిక విభాగం ప్రత్యేక ఆసక్తిని కలిగి ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This behavior of automatically executing a function on exit is controlled by the .dtors table section of the binary.","translation":"నిష్క్రమణపై స్వయంచాలకంగా ఒక ఫంక్షన్ను అమలు చేసే ఈ ప్రవర్తన బైనరీ యొక్క .dtors పట్టిక విభాగం ద్వారా నియంత్రించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This means that 0x080495ac should contain 0xffffffff, 0x080495b4 should contain 0x00000000, and the address between them (0x080495b0) should contain the address of the cleanup() function (0x080483e8).","translation":"అంటే 0x080495ac 0xffffffffని కలిగి ఉండాలి, 0x080495b4 0x00000000ని కలిగి ఉండాలి మరియు వాటి మధ్య చిరునామా (0x080495b0) క్లీనప్() ఫంక్షన్ యొక్క చిరునామాను కలిగి ఉండాలి (0x080483e8).","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since the .dtors section is writable, if the address after the 0xffffffff is overwritten with a memory address, the program’s execution flow will be directed to that address when the program exits.","translation":".dtors విభాగం వ్రాయదగినది కాబట్టి, 0xffffffff తర్వాత చిరునామాను మెమరీ చిరునామాతో తిరిగి వ్రాస్తే, ప్రోగ్రామ్ నిష్క్రమించినప్పుడు ప్రోగ్రామ్ యొక్క అమలు ప్రవాహం ఆ చిరునామాకు నిర్దేశించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The send() function sends the 13 bytes of the string Hello, world!\\n to the new socket that describes the new connection.","translation":"send() ఫంక్షన్ కొత్త కనెక్షన్ను వివరించే కొత్త సాకెట్కు Hello, world!\\n అనే స్ట్రింగ్లోని 13 బైట్లను పంపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The final argument for the send() and recv() functions are flags, that for our purposes, will always be 0.","translation":"send() మరియు recv() ఫంక్షన్ల కోసం చివరి వాదనలు ఫ్లాగ్లు, ఇవి మన అవసరాల కోసం ఎల్లప్పుడూ 0గా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Next is a loop that receives data from the connection and prints it out.","translation":"తరువాత కనెక్షన్ నుండి డేటాను స్వీకరించి, దానిని ప్రింట్ చేసే లూప్ ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The recv() function is given a pointer to a buffer and a maximum length to read from the socket.","translation":"recv() ఫంక్షన్ సాకెట్ నుండి చదవడానికి ఒక బఫర్కు పాయింటర్ మరియు గరిష్ట పొడవును అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The function writes the data into the buffer passed to it and returns the number of bytes it actually wrote.","translation":"ఫంక్షన్ డేటాను దానికి పంపిన బఫర్లోకి వ్రాస్తుంది మరియు అది వాస్తవానికి వ్రాసిన బైట్ల సంఖ్యను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The loop will continue as long as the recv() call continues to receive data.","translation":"recv() కాల్ డేటాను స్వీకరించడం కొనసాగించే వరకు లూప్ కొనసాగుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A telnet client basically works like a generic TCP connection client, so it can be used to connect to the simple server by specifying the target IP address and port.","translation":"టెల్నెట్ క్లయింట్ ప్రాథమికంగా సాధారణ TCP కనెక్షన్ క్లయింట్ లాగా పనిచేస్తుంది, కాబట్టి లక్ష్య IP చిరునామా మరియు పోర్ట్ను పేర్కొనడం ద్వారా సాధారణ సర్వర్కు కనెక్ట్ చేయడానికి దీన్ని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Upon connection, the server sends the string Hello, world!, and the rest is the local character echo of me typing this is a test and a line of keyboard mashing.","translation":"కనెక్షన్ అయిన తర్వాత, సర్వర్ Hello, world! అనే స్ట్రింగ్ను పంపుతుంది మరియు మిగిలినవి నేను టైప్ చేస్తున్న ఈ పరీక్ష యొక్క స్థానిక అక్షర ప్రతిధ్వని మరియు కీబోర్డ్ మాషింగ్ యొక్క ఒక లైన్.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since telnet is line-buffered, each of these two lines is sent back to the server when ENTER is pressed.","translation":"టెల్నెట్ లైన్-బఫర్ చేయబడినందున, ENTER నొక్కినప్పుడు ఈ రెండు లైన్లలో ప్రతి ఒక్కటి సర్వర్కు తిరిగి పంపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Back on the server side, the output shows the connection and the packets of data that are sent back.","translation":"సర్వర్ వైపు తిరిగి, అవుట్పుట్ కనెక్షన్ మరియు తిరిగి పంపబడిన డేటా ప్యాకెట్లను చూపుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Every time you use a web browser, it makes a connection to a webserver somewhere.","translation":"మీరు వెబ్ బ్రౌజర్ను ఉపయోగించిన ప్రతిసారీ, అది ఎక్కడో ఒక వెబ్సర్వర్కు కనెక్షన్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This connection transmits the web page over the connection using HTTP, which defines a certain way to request and send information.","translation":"ఈ కనెక్షన్ HTTPని ఉపయోగించి కనెక్షన్ ద్వారా వెబ్ పేజీని ప్రసారం చేస్తుంది, ఇది సమాచారాన్ని అభ్యర్థించడానికి మరియు పంపడానికి ఒక నిర్దిష్ట మార్గాన్ని నిర్వచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By default, webservers run on port 80, which is listed along with many other default ports in /etc/services.","translation":"డిఫాల్ట్గా, వెబ్సర్వర్లు పోర్ట్ 80లో రన్ అవుతాయి, ఇది /etc/servicesలో అనేక ఇతర డిఫాల్ట్ పోర్ట్లతో పాటు జాబితా చేయబడింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"HTTP exists in the application layer—the top layer—of the OSI model.","translation":"HTTP OSI మోడల్ యొక్క అప్లికేషన్ లేయర్లో—అంటే టాప్ లేయర్లో—ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Once you know the syntax of these various protocols, you can manually talk to other programs that speak the same language.","translation":"మీరు ఈ వివిధ ప్రోటోకాల్ల సింటాక్స్ తెలిసిన తర్వాత, మీరు ఒకే భాష మాట్లాడే ఇతర ప్రోగ్రామ్లతో మాన్యువల్గా మాట్లాడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In the language of HTTP, requests are made using the command GET, followed by the resource path and the HTTP protocol version.","translation":"HTTP భాషలో, అభ్యర్థనలు GET కమాండ్ ఉపయోగించి చేయబడతాయి, ఆ తర్వాత వనరు మార్గం మరియు HTTP ప్రోటోకాల్ వెర్షన్ వస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"For example, GET / HTTP/1.0 will request the root document from the webserver using HTTP version 1.0.","translation":"ఉదాహరణకు, GET / HTTP/1.0 HTTP వెర్షన్ 1.0ని ఉపయోగించి వెబ్సర్వర్ నుండి రూట్ డాక్యుమెంట్ను అభ్యర్థిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If the server finds the resource, it will respond using HTTP by sending several headers before sending the content.","translation":"సర్వర్ వనరును కనుగొంటే, కంటెంట్ను పంపే ముందు అనేక హెడర్లను పంపడం ద్వారా HTTPని ఉపయోగించి ప్రతిస్పందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These headers are plaintext and can usually provide information about the server.","translation":"ఈ హెడర్లు సాదా వచనం మరియు సాధారణంగా సర్వర్ గురించి సమాచారాన్ని అందించగలవు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This reveals that the webserver is Apache version 2.0.52 and even that the host runs CentOS.","translation":"వెబ్సర్వర్ Apache వెర్షన్ 2.0.52 అని మరియు హోస్ట్ CentOSని నడుపుతుందని ఇది వెల్లడిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The Ethernet header contains source and destination MAC addresses.","translation":"ఈథర్నెట్ హెడర్లో సోర్స్ మరియు డెస్టినేషన్ MAC చిరునామాలు ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The structure for the Ethernet header is defined in /usr/include/linux/if_ethernet.h.","translation":"ఈథర్నెట్ హెడర్ కోసం నిర్మాణం /usr/include/linux/if_ethernet.h లో నిర్వచించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The packet type ID field is a 16-bit value.","translation":"ప్యాకెట్ రకం ID ఫీల్డ్ 16-బిట్ విలువ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Many compilers will pad structures along 4-byte boundaries for alignment.","translation":"అనేక కంపైలర్లు అమరిక కోసం 4-బైట్ సరిహద్దుల వెంట నిర్మాణాలను ప్యాడ్ చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"We should strip out references to unknown type definitions.","translation":"తెలియని రకం నిర్వచనాలకు సంబంధించిన సూచనలను మనం తీసివేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The IP header has fields like version, IHL, and total length.","translation":"IP హెడర్లో వెర్షన్, IHL మరియు మొత్తం పొడవు వంటి ఫీల్డ్లు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each element in the structure corresponds to the fields shown in the RFC header diagram.","translation":"నిర్మాణంలోని ప్రతి మూలకం RFC హెడర్ రేఖాచిత్రంలో చూపిన ఫీల్డ్లకు అనుగుణంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The TCP header size in bytes equals the data offset field from the header times four.","translation":"బైట్లలో TCP హెడర్ పరిమాణం హెడర్ నుండి డేటా ఆఫ్సెట్ ఫీల్డ్కు నాలుగు రెట్లు సమానం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The th_flags field of Linux’s tcphdr structure is defined as an 8-bit unsigned character.","translation":"Linux యొక్క tcphdr నిర్మాణం యొక్క th_flags ఫీల్డ్ 8-బిట్ సంతకం చేయని అక్షరంగా నిర్వచించబడింది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"We can write a program to decode the layered headers of each packet.","translation":"ప్రతి ప్యాకెట్ యొక్క లేయర్డ్ హెడర్లను డీకోడ్ చేయడానికి మేము ఒక ప్రోగ్రామ్ను వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The pcap_loop() function uses a callback function.","translation":"pcap_loop() ఫంక్షన్ కాల్బ్యాక్ ఫంక్షన్ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The first argument is the pcap’s handle.","translation":"మొదటి వాదన pcap యొక్క హ్యాండిల్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The callback function needs to follow a certain prototype.","translation":"కాల్బ్యాక్ ఫంక్షన్ ఒక నిర్దిష్ట నమూనాను అనుసరించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The decoding functions are passed a pointer to the start of the header.","translation":"డీకోడింగ్ ఫంక్షన్లు హెడర్ ప్రారంభానికి ఒక పాయింటర్ను పంపబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This data is straight from the wire, so the byte order needs to be converted.","translation":"ఈ డేటా నేరుగా వైర్ నుండి వచ్చింది, కాబట్టి బైట్ ఆర్డర్ను మార్చాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"With the headers decoded, the TCP/IP connection is easier to understand.","translation":"హెడర్లను డీకోడ్ చేసిన తర్వాత, TCP/IP కనెక్షన్ను అర్థం చేసుకోవడం సులభం అవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Protocols such as FTP, POP3, and telnet transmit data without encryption.","translation":"FTP, POP3 మరియు టెల్నెట్ వంటి ప్రోటోకాల్లు ఎన్క్రిప్షన్ లేకుండా డేటాను ప్రసారం చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Spoofing is the first step in sniffing packets on a switched network.","translation":"మార్చబడిన నెట్వర్క్లో ప్యాకెట్లను స్నిఫ్ చేయడానికి స్పూఫింగ్ మొదటి దశ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The attacker sends spoofed ARP replies to certain devices.","translation":"దాడి చేసే వ్యక్తి కొన్ని పరికరాలకు స్పూఫ్డ్ ARP ప్రత్యుత్తరాలను పంపుతాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"ARP redirection is particularly interesting when one of the victim machines is the default gateway.","translation":"బాధితులలో ఒకరు డిఫాల్ట్ గేట్వే అయినప్పుడు ARP దారిమార్పు ప్రత్యేకంగా ఆసక్తికరంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If one system has the IP address 10.10.10.20 and MAC address 00:00:00:aa:aa:aa, and another system on the same network has the IP address 10.10.10.50 and MAC address 00:00:00:bb:bb:bb, neither system can communicate with the other until they know each other’s MAC addresses.","translation":"ఒక సిస్టమ్ యొక్క IP చిరునామా 10.10.10.20 మరియు MAC చిరునామా 00:00:00:aa:aa:aa అయితే, అదే నెట్వర్క్లోని మరొక సిస్టమ్ యొక్క IP చిరునామా 10.10.10.50 మరియు MAC చిరునామా 00:00:00:bb:bb:bb అయితే, ఒకరి MAC చిరునామాలను మరొకరు తెలుసుకునే వరకు ఏ సిస్టమ్ కూడా ఒకదానితో ఒకటి కమ్యూనికేట్ చేయలేవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The first system will first check its ARP cache to see if an entry exists for 10.10.10.50.","translation":"మొదటి సిస్టమ్ మొదట 10.10.10.50 కోసం ఏదైనా ఎంట్రీ ఉందో లేదో తెలుసుకోవడానికి దాని ARP కాష్ని తనిఖీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since this is the first time these two systems are trying to communicate, there will be no such entry, and an ARP request will be sent out to the broadcast address.","translation":"ఈ రెండు సిస్టమ్లు మొదటిసారిగా కమ్యూనికేట్ చేయడానికి ప్రయత్నిస్తున్నందున, అలాంటి ఎంట్రీ ఏదీ ఉండదు మరియు ARP అభ్యర్థన ప్రసార చిరునామాకు పంపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you are 10.10.10.50, please respond to me at 00:00:00:aa:aa:aa.","translation":"మీరు 10.10.10.50 అయితే, దయచేసి 00:00:00:aa:aa:aa వద్ద నాకు సమాధానం ఇవ్వండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In this case, the second system responds with an ARP reply that is sent directly back to 00:00:00:aa:aa:aa saying, “I am 10.10.10.50 and I’m at 00:00:00:bb:bb:bb.”","translation":"ఈ సందర్భంలో, రెండవ సిస్టమ్ ARP ప్రత్యుత్తరంతో స్పందిస్తుంది, అది నేరుగా 00:00:00:aa:aa:aaకి పంపబడుతుంది, “నేను 10.10.10.50ని మరియు నేను 00:00:00:bb:bb:bb వద్ద ఉన్నాను.”","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The first system receives this reply, caches the IP and MAC address pair in its ARP cache, and uses the hardware address to communicate.","translation":"మొదటి సిస్టమ్ ఈ ప్రత్యుత్తరాన్ని అందుకుంటుంది, దాని ARP కాష్లో IP మరియు MAC చిరునామా జతను కాష్ చేస్తుంది మరియు కమ్యూనికేట్ చేయడానికి హార్డ్వేర్ చిరునామాను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The network layer is like a worldwide postal service providing an addressing and delivery method used to send things everywhere.","translation":"నెట్వర్క్ లేయర్ అనేది ప్రపంచవ్యాప్త పోస్టల్ సర్వీస్ లాంటిది, ఇది ప్రతిచోటా వస్తువులను పంపడానికి ఉపయోగించే చిరునామా మరియు డెలివరీ పద్ధతిని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Every system on the Internet has an IP address, consisting of a familiar four-byte arrangement in the form of xx.xx.xx.xx.","translation":"ఇంటర్నెట్లోని ప్రతి సిస్టమ్కు xx.xx.xx.xx రూపంలో తెలిసిన నాలుగు-బైట్ అమరికతో కూడిన IP చిరునామా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The IP header for packets in this layer is 20 bytes in size and consists of various fields and bitflags as defined in RFC 791.","translation":"ఈ లేయర్లోని ప్యాకెట్ల కోసం IP హెడర్ పరిమాణం 20 బైట్లు మరియు RFC 791లో నిర్వచించిన విధంగా వివిధ ఫీల్డ్లు మరియు బిట్ఫ్లాగ్లను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard protocols have awesome documentation.","translation":"ప్రామాణిక ప్రోటోకాల్లు అద్భుతమైన డాక్యుమెంటేషన్ను కలిగి ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The Internet Protocol is mostly used to transmit packets wrapped in higher layers.","translation":"ఇంటర్నెట్ ప్రోటోకాల్ ప్రధానంగా అధిక లేయర్లలో చుట్టబడిన ప్యాకెట్లను ప్రసారం చేయడానికి ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If there’s a problem, an ICMP packet is sent back to notify the sender of the problem.","translation":"సమస్య ఉంటే, సమస్య గురించి పంపినవారికి తెలియజేయడానికి ICMP ప్యాకెట్ తిరిగి పంపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"ICMP Echo Request and Echo Reply messages are used by a utility called ping.","translation":"ICMP ఎకో రిక్వెస్ట్ మరియు ఎకో రిప్లై సందేశాలను పింగ్ అనే యుటిలిటీ ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If one host wants to test whether it can route traffic to another host, it pings the remote host by sending an ICMP Echo Request.","translation":"ఒక హోస్ట్ ట్రాఫిక్ను మరొక హోస్ట్కు రూట్ చేయగలదో లేదో పరీక్షించాలనుకుంటే, అది ICMP ఎకో రిక్వెస్ట్ను పంపడం ద్వారా రిమోట్ హోస్ట్ను పింగ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Sometimes a network link will have a limitation on packet size, disallowing the transfer of large packets.","translation":"కొన్నిసార్లు నెట్వర్క్ లింక్ ప్యాకెట్ పరిమాణంపై పరిమితిని కలిగి ఉంటుంది, ఇది పెద్ద ప్యాకెట్ల బదిలీని అనుమతించదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The transport layer can be thought of as the first line of office receptionists, picking up the mail from the network layer.","translation":"ట్రాన్స్పోర్ట్ లేయర్ను నెట్వర్క్ లేయర్ నుండి మెయిల్ను తీసుకునే మొదటి లైన్ ఆఫీస్ రిసెప్షనిస్టులుగా భావించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The two major protocols at this layer are the Transmission Control Protocol (TCP) and User Datagram Protocol (UDP).","translation":"ఈ లేయర్లోని రెండు ప్రధాన ప్రోటోకాల్లు ట్రాన్స్మిషన్ కంట్రోల్ ప్రోటోకాల్ (TCP) మరియు యూజర్ డేటాగ్రామ్ ప్రోటోకాల్ (UDP).","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"TCP is the most commonly used protocol for services on the Internet: telnet, HTTP (web traffic), SMTP (email traffic), and FTP (file transfers) all use TCP.","translation":"TCP అనేది ఇంటర్నెట్లోని సేవల కోసం సాధారణంగా ఉపయోగించే ప్రోటోకాల్: టెల్నెట్, HTTP (వెబ్ ట్రాఫిక్), SMTP (ఇమెయిల్ ట్రాఫిక్) మరియు FTP (ఫైల్ బదిలీలు) అన్నీ TCPని ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Stream sockets use TCP/IP connections.","translation":"స్ట్రీమ్ సాకెట్లు TCP/IP కనెక్షన్లను ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When a client wants to open a connection with a server, a packet with the SYN flag on, but the ACK flag off, is sent to the server.","translation":"ఒక క్లయింట్ సర్వర్తో కనెక్షన్ను తెరవాలనుకున్నప్పుడు, SYN ఫ్లాగ్ ఆన్లో ఉన్న ప్యాకెట్, కానీ ACK ఫ్లాగ్ ఆఫ్ చేయబడి, సర్వర్కు పంపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The program has already been built and installed.","translation":"ప్రోగ్రామ్ ఇప్పటికే నిర్మించబడింది మరియు వ్యవస్థాపించబడింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"NEMESIS modes include arp, dns, ethernet, icmp, igmp, ip, ospf, rip, tcp, and udp.","translation":"NEMESIS మోడ్లలో arp, dns, ethernet, icmp, igmp, ip, ospf, rip, tcp మరియు udp ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To display options, specify a mode with the option \"help\".","translation":"ఎంపికలను ప్రదర్శించడానికి, \"help\" ఎంపికతో ఒక మోడ్ను పేర్కొనండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You must define a Source and Destination IP address.","translation":"మీరు సోర్స్ మరియు డెస్టినేషన్ IP చిరునామాను నిర్వచించాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"These two commands spoof ARP replies.","translation":"ఈ రెండు ఆదేశాలు ARP ప్రత్యుత్తరాలను మోసగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If these commands are repeated every 10 seconds, these bogus ARP replies will continue to keep the ARP caches poisoned.","translation":"ఈ ఆదేశాలను ప్రతి 10 సెకన్లకు పునరావృతం చేస్తే, ఈ నకిలీ ARP ప్రత్యుత్తరాలు ARP కాష్లను విషపూరితం చేస్తూనే ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The standard BASH shell allows commands to be scripted.","translation":"ప్రామాణిక BASH షెల్ ఆదేశాలను స్క్రిప్ట్ చేయడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A simple BASH shell while loop is used below to loop forever.","translation":"ఎప్పటికీ లూప్ చేయడానికి క్రింద ఒక సాధారణ BASH షెల్ వైల్ లూప్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can see how something as simple as Nemesis and the standard BASH shell can be used to quickly hack together a network exploit.","translation":"నెమెసిస్ మరియు ప్రామాణిక BASH షెల్ వంటి సాధారణమైనవి నెట్వర్క్ ఎక్స్ప్లాయిట్ను త్వరగా హ్యాక్ చేయడానికి ఎలా ఉపయోగించవచ్చో మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Nemesis uses a C library called libnet to craft spoofed packets and inject them.","translation":"నెమెసిస్ నకిలీ ప్యాకెట్లను తయారు చేయడానికి మరియు వాటిని ఇంజెక్ట్ చేయడానికి libnet అనే C లైబ్రరీని ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Similar to libpcap, this library uses raw sockets.","translation":"libpcap వలె, ఈ లైబ్రరీ ముడి సాకెట్లను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The libnet library provides a simple and uniform API to craft and inject network packets.","translation":"libnet లైబ్రరీ నెట్వర్క్ ప్యాకెట్లను తయారు చేయడానికి మరియు ఇంజెక్ట్ చేయడానికి ఒక సాధారణ మరియు ఏకరీతి API ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It’s well documented and the functions have descriptive names.","translation":"ఇది బాగా డాక్యుమెంట్ చేయబడింది మరియు ఫంక్షన్లకు వివరణాత్మక పేర్లు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The nemesis_arp() function calls a series of other functions.","translation":"నెమెసిస్_ఆర్ప్() ఫంక్షన్ ఇతర ఫంక్షన్ల శ్రేణిని పిలుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The arp_initdata() function does exactly this, initializing values.","translation":"arp_initdata() ఫంక్షన్ సరిగ్గా దీన్ని చేస్తుంది, విలువలను ప్రారంభిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"At a high level, this function should be readable to you.","translation":"అధిక స్థాయిలో, ఈ ఫంక్షన్ మీకు చదవడానికి వీలుగా ఉండాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This function builds the Ethernet layer.","translation":"ఈ ఫంక్షన్ ఈథర్నెట్ లేయర్ను నిర్మిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"One of the simplest forms of network attack is a Denial of Service (DoS) attack.","translation":"నెట్వర్క్ దాడి యొక్క సరళమైన రూపాలలో ఒకటి సర్వీస్ నిరాకరణ (DoS) దాడి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A SYN flood tries to exhaust states in the TCP/IP stack.","translation":"SYN ఫ్లడ్ TCP/IP స్టాక్లోని స్టేట్లను అయోమయం చేయడానికి ప్రయత్నిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The attacker floods the victim’s system with many SYN packets.","translation":"దాడి చేసే వ్యక్తి బాధితుడి వ్యవస్థను చాలా SYN ప్యాకెట్లతో నింపుతాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The attacker sends many large ping packets to the victim, which eat away at the bandwidth of the victim’s network connection.","translation":"ఆക്രമించే వ్యక్తి బాధితుడికి చాలా పెద్ద పింగ్ ప్యాకెట్లను పంపుతాడు, ఇది బాధితుడి నెట్వర్క్ కనెక్షన్ యొక్క బ్యాండ్విడ్త్ను తినేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"An attacker with greater bandwidth than a victim can send more data than the victim can receive and therefore deny other legitimate traffic from getting to the victim.","translation":"బాధితుడి కంటే ఎక్కువ బ్యాండ్విడ్త్ ఉన్న ఒక దాడి చేసే వ్యక్తి బాధితుడు స్వీకరించగలిగే దానికంటే ఎక్కువ డేటాను పంపగలడు మరియు అందువల్ల ఇతర చట్టబద్ధమైన ట్రాఫిక్ బాధితుడిని చేరుకోకుండా నిరోధించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This amplification of traffic allows the attacker to send a relatively small stream of ICMP echo request packets out, while the victim gets swamped with up to a couple hundred times as many ICMP echo reply packets.","translation":"ట్రాఫిక్ యొక్క ఈ విస్తరణ దాడి చేసే వ్యక్తి ICMP ఎకో రిక్వెస్ట్ ప్యాకెట్ల యొక్క సాపేక్షంగా చిన్న స్ట్రీమ్ను పంపడానికి అనుమతిస్తుంది, అయితే బాధితుడు చాలా రెట్లు ఎక్కువ ICMP ఎకో రిప్లై ప్యాకెట్లతో మునిగిపోతాడు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In a DDoS attack, the attacker first compromises a number of other hosts and installs daemons on them.","translation":"DDoS దాడిలో, దాడి చేసే వ్యక్తి మొదట అనేక ఇతర హోస్ట్లను రాజీ చేస్తాడు మరియు వాటిపై డీమన్లను ఇన్స్టాల్ చేస్తాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since bandwidth consumption is the goal of a flooding DoS attack, the more bandwidth the attacker is able to work with, the more damage they can do.","translation":"ఫ్లడ్డింగ్ DoS దాడి లక్ష్యం బ్యాండ్విడ్త్ వినియోగం కాబట్టి, దాడి చేసే వ్యక్తి ఎంత ఎక్కువ బ్యాండ్విడ్త్తో పని చేయగలిగితే, అంత ఎక్కువ నష్టం చేయగలరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"TCP/IP hijacking is a clever technique that uses spoofed packets to take over a connection between a victim and a host machine.","translation":"TCP/IP హైజాకింగ్ అనేది ఒక తెలివైన సాంకేతికత, ఇది బాధితుడు మరియు హోస్ట్ మెషిన్ మధ్య కనెక్షన్ను స్వాధీనం చేసుకోవడానికి స్ఫూఫ్ చేసిన ప్యాకెట్లను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This technique is exceptionally useful when the victim uses a one-time password to connect to the host machine.","translation":"బాధితుడు హోస్ట్ మెషిన్కు కనెక్ట్ అవ్వడానికి ఒక-సారి పాస్వర్డ్ను ఉపయోగించినప్పుడు ఈ సాంకేతికత చాలా ఉపయోగకరంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By sniffing the local network segment, all of the details of open TCP connections can be pulled from the headers.","translation":"స్థానిక నెట్వర్క్ విభాగంలో స్నిఫ్ చేయడం ద్వారా, తెరిచిన TCP కనెక్షన్ల యొక్క అన్ని వివరాలను హెడర్ల నుండి లాగవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The host machine will receive the spoofed packet with the correct acknowledgment number and will have no reason to believe it didn’t come from the victim machine.","translation":"హోస్ట్ మెషిన్ సరైన అంగీకార సంఖ్యతో స్ఫూఫ్ చేసిన ప్యాకెట్ను అందుకుంటుంది మరియు అది బాధితుడి మెషిన్ నుండి రాలేదని నమ్మడానికి ఎటువంటి కారణం ఉండదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A very simple form of TCP/IP hijacking involves injecting an authentic-looking reset (RST) packet.","translation":"TCP/IP హైజాకింగ్ యొక్క చాలా సాధారణ రూపంలో ప్రామాణికమైన రీసెట్ (RST) ప్యాకెట్ను ఇంజెక్ట్ చేయడం ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If the source is spoofed and the acknowledgment number is correct, the receiving side will believe that the source actually sent the reset packet, and the connection will be reset.","translation":"సోర్స్ స్ఫూఫ్ చేయబడితే మరియు అంగీకార సంఖ్య సరిగ్గా ఉంటే, స్వీకరించే వైపు సోర్స్ వాస్తవానికి రీసెట్ ప్యాకెట్ను పంపిందని నమ్ముతుంది మరియు కనెక్షన్ రీసెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Port scanning is a way of figuring out which ports are listening and accepting connections.","translation":"పోర్ట్ స్కానింగ్ అనేది ఏ పోర్ట్లు వింటున్నాయో మరియు కనెక్షన్లను అంగీకరిస్తున్నాయో తెలుసుకోవడానికి ఒక మార్గం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The simplest form of port scanning involves trying to open TCP connections to every possible port on the target system.","translation":"పోర్ట్ స్కానింగ్ యొక్క సరళమైన రూపంలో లక్ష్య వ్యవస్థలోని ప్రతి పోర్ట్కు TCP కనెక్షన్లను తెరవడానికి ప్రయత్నించడం ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A SYN scan doesn’t complete the handshake, so a full connection is never opened.","translation":"SYN స్కాన్ హ్యాండ్షేక్ను పూర్తి చేయదు, కాబట్టి పూర్తి కనెక్షన్ ఎప్పుడూ తెరవబడదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If a port is listening, these packets just get ignored.","translation":"ఒక పోర్ట్ వింటుంటే, ఈ ప్యాకెట్లను విస్మరిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Another way to avoid detection is to hide among several decoys.","translation":"గుర్తించకుండా ఉండటానికి మరొక మార్గం ఏమిటంటే, అనేక డెకాయ్ల మధ్య దాక్కోవడం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This technique simply spoofs connections from various decoy IP addresses in between each real port-scanning connection.","translation":"ఈ సాంకేతికత ప్రతి నిజమైన పోర్ట్-స్కానింగ్ కనెక్షన్ మధ్య వివిధ డెకాయ్ IP చిరునామాల నుండి కనెక్షన్లను స్ఫూఫ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Idle scanning is a way to scan a target using spoofed packets from an idle host, by observing changes in the idle host.","translation":"నిష్క్రియ హోస్ట్ లో మార్పులను గమనించడం ద్వారా, నిష్క్రియ హోస్ట్ నుండి స్ఫూఫ్ చేసిన ప్యాకెట్లను ఉపయోగించి లక్ష్యాన్ని స్కాన్ చేయడానికి ఐడిల్ స్కానింగ్ ఒక మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If that port isn’t listening, the target machine doesn’t send a SYN/ACK packet back to the idle host, so the idle host doesn’t respond.","translation":"ఆ పోర్ట్ వినకపోతే, లక్ష్య యంత్రం నిష్క్రియ హోస్ట్కు SYN/ACK ప్యాకెట్ను తిరిగి పంపదు, కాబట్టి నిష్క్రియ హోస్ట్ స్పందించదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Port scans are often used to profile systems before they are attacked.","translation":"పోర్ట్ స్కాన్లను తరచుగా దాడి చేయడానికి ముందు సిస్టమ్లను ప్రొఫైల్ చేయడానికి ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The program still accepts commands and returns the output over the network.","translation":"ప్రోగ్రామ్ ఇప్పటికీ ఆదేశాలను స్వీకరిస్తుంది మరియు నెట్వర్క్ ద్వారా అవుట్పుట్ను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Using netcat and the port-binding shellcode in a file, the same exploit can be carried out on the command line.","translation":"నెట్క్యాట్ మరియు పోర్ట్-బైండింగ్ షెల్కోడ్ను ఉపయోగించి, అదే ఎక్స్ప్లాయిట్ను కమాండ్ లైన్లో అమలు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The return address is found 540 bytes from the start of the buffer.","translation":"రిటర్న్ చిరునామా బఫర్ ప్రారంభం నుండి 540 బైట్ల దూరంలో కనుగొనబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Shellcode is also sometimes referred to as an exploit payload.","translation":"షెల్కోడ్ను కొన్నిసార్లు ఎక్స్ప్లాయిట్ పేలోడ్గా కూడా సూచిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Custom shellcode gives you absolute control over the exploited program.","translation":"అనుకూల షెల్కోడ్ మీకు దోపిడీ చేయబడిన ప్రోగ్రామ్పై పూర్తి నియంత్రణను ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Perhaps you want your shellcode to add an admin account to /etc/passwd.","translation":"మీ షెల్కోడ్ /etc/passwdకి అడ్మిన్ ఖాతాను జోడించాలని మీరు కోరుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Once you know how to write your own shellcode, your exploits are limited only by your imagination.","translation":"మీ స్వంత షెల్కోడ్ను ఎలా రాయాలో మీకు తెలిసిన తర్వాత, మీ ఎక్స్ప్లాయిట్లు మీ ఊహకు మాత్రమే పరిమితం చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Writing shellcode develops assembly language skills and employs a number of hacking techniques worth knowing.","translation":"షెల్కోడ్ రాయడం అసెంబ్లీ భాషా నైపుణ్యాలను అభివృద్ధి చేస్తుంది మరియు తెలుసుకోవలసిన అనేక హ్యాకింగ్ పద్ధతులను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The operating system manages things like input, output, process control, file access, and network communication in the kernel.","translation":"ఆపరేటింగ్ సిస్టమ్ ఇన్పుట్, అవుట్పుట్, ప్రాసెస్ నియంత్రణ, ఫైల్ యాక్సెస్ మరియు నెట్వర్క్ కమ్యూనికేషన్ వంటి వాటిని కెర్నల్లో నిర్వహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Compiled C programs ultimately perform these tasks by making system calls to the kernel.","translation":"కంపైల్ చేయబడిన సి ప్రోగ్రామ్లు చివరకు కెర్నల్కు సిస్టమ్ కాల్స్ చేయడం ద్వారా ఈ టాస్క్లను నిర్వహిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Different operating systems have different sets of system calls.","translation":"వివిధ ఆపరేటింగ్ సిస్టమ్లు వేర్వేరు సిస్టమ్ కాల్ల సమితిని కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A C program compiled on an x86 processor will produce x86 assembly language.","translation":"x86 ప్రాసెసర్లో కంపైల్ చేయబడిన సి ప్రోగ్రామ్ x86 అసెంబ్లీ భాషను ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By definition, assembly language is already specific to a certain processor architecture, so portability is impossible.","translation":"నిర్వచనం ప్రకారం, అసెంబ్లీ భాష ఇప్పటికే నిర్దిష్ట ప్రాసెసర్ ఆర్కిటెక్చర్కు నిర్దిష్టంగా ఉంటుంది, కాబట్టి పోర్టబిలిటీ అసాధ్యం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"There are no standard libraries; instead, kernel system calls have to be made directly.","translation":"ప్రామాణిక లైబ్రరీలు లేవు; బదులుగా, కెర్నల్ సిస్టమ్ కాల్లను నేరుగా చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To begin our comparison, let’s write a simple C program, then rewrite it in x86 assembly.","translation":"మన పోలికను ప్రారంభించడానికి, ఒక సాధారణ సి ప్రోగ్రామ్ను వ్రాద్దాం, ఆపై దానిని x86 అసెంబ్లీలో తిరిగి వ్రాద్దాం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the compiled program is run, execution flows through the standard I/O library.","translation":"కంపైల్ చేయబడిన ప్రోగ్రామ్ అమలు చేయబడినప్పుడు, అమలు ప్రామాణిక I/O లైబ్రరీ ద్వారా ప్రవహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The strace program is used to trace a program’s system calls.","translation":"ఒక ప్రోగ్రామ్ యొక్క సిస్టమ్ కాల్లను గుర్తించడానికి strace ప్రోగ్రామ్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The Unix manual pages are separated into sections.","translation":"యూనిక్స్ మాన్యువల్ పేజీలు విభాగాలలో వేరు చేయబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"File descriptors are used for almost everything in Unix.","translation":"ఫైల్ డిస్క్రిప్టర్లు యూనిక్స్లో దాదాపు ప్రతిదానికీ ఉపయోగించబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Writing bytes to standard output’s file descriptor of 1 will print the bytes.","translation":"ప్రామాణిక అవుట్పుట్ యొక్క ఫైల్ డిస్క్రిప్టర్ 1కి బైట్లను రాయడం వలన బైట్లు ప్రింట్ అవుతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By adding the return command, the tcp_v4_send_reset() kernel function will simply return instead of doing anything.","translation":"తిరిగి వచ్చే ఆదేశాన్ని జోడించడం ద్వారా, tcp_v4_send_reset() కెర్నల్ ఫంక్షన్ ఏమీ చేయకుండానే తిరిగి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"After the kernel is recompiled, the resulting kernel won’t send out reset packets, avoiding information leakage.","translation":"కెర్నల్ తిరిగి కంపైల్ చేసిన తర్వాత, ఫలితంగా వచ్చే కెర్నల్ రీసెట్ ప్యాకెట్లను పంపదు, తద్వారా సమాచారం లీక్ అవ్వకుండా నిరోధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This works fine for scans that rely on RST packets.","translation":"RST ప్యాకెట్లపై ఆధారపడే స్కానింగ్లకు ఇది బాగా పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"But preventing information leakage with SYN scans and full-connect scans is a bit more difficult.","translation":"కానీ SYN స్కానింగ్లు మరియు పూర్తి-కనెక్ట్ స్కానింగ్లతో సమాచారం లీక్ అవ్వకుండా నిరోధించడం కొంచెం కష్టం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In order to maintain functionality, open ports have to respond with SYN/ACK packets—there is no way around that.","translation":"కార్యాచరణను నిర్వహించడానికి, తెరిచిన పోర్ట్లు SYN/ACK ప్యాకెట్లతో ప్రతిస్పందించాలి - దానికి మార్గం లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"But if all of the closed ports also responded with SYN/ACK packets, the amount of useful information an attacker could retrieve from port scans would be minimized.","translation":"కానీ మూసివేసిన పోర్ట్లన్నీ కూడా SYN/ACK ప్యాకెట్లతో ప్రతిస్పందిస్తే, పోర్ట్ స్కానింగ్ల నుండి ఒక దాడి చేసే వ్యక్తి పొందగలిగే ఉపయోగకరమైన సమాచారం పరిమితం చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Simply opening every port would cause a major performance hit, though, which isn’t desirable.","translation":"ప్రతి పోర్ట్ను తెరవడం వలన పనితీరుపై తీవ్రమైన ప్రభావం పడుతుంది, ఇది కోరుకోదగినది కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Ideally, this should all be done without using a TCP stack.","translation":"ఆదర్శవంతంగా, ఇదంతా TCP స్టాక్ను ఉపయోగించకుండా చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The following program does exactly that.","translation":"కింది ప్రోగ్రామ్ సరిగ్గా అదే చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It’s a modification of the rst_hijack.c program, using a more complex BPF string to filter only SYN packets destined for closed ports.","translation":"ఇది rst_hijack.c ప్రోగ్రామ్ యొక్క మార్పు, మూసివేసిన పోర్ట్ల కోసం ఉద్దేశించిన SYN ప్యాకెట్లను మాత్రమే ఫిల్టర్ చేయడానికి మరింత సంక్లిష్టమైన BPF స్ట్రింగ్ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The callback function spoofs a legitimate looking SYN/ACK response to any SYN packet that makes it through the BPF.","translation":"కాల్బ్యాక్ ఫంక్షన్ BPF ద్వారా వెళ్ళే ఏదైనా SYN ప్యాకెట్కు చట్టబద్ధమైన SYN/ACK ప్రతిస్పందనను స్ఫూఫ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This will flood port scanners with a sea of false positives, which will hide legitimate ports.","translation":"ఇది పోర్ట్ స్కానర్లను తప్పుడు సానుకూల సముద్రంతో ముంచెత్తుతుంది, ఇది చట్టబద్ధమైన పోర్ట్లను దాచిపెడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There are a few tricky parts in the code above, but you should be able to follow all of it.","translation":"పై కోడ్లో కొన్ని కష్టమైన భాగాలు ఉన్నాయి, కానీ మీరు వాటన్నింటినీ అనుసరించగలగాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the program is compiled and executed, it will shroud the IP address given as the first argument, with the exception of a list of existing ports provided as the remaining arguments.","translation":"ప్రోగ్రామ్ కంపైల్ చేసి అమలు చేసినప్పుడు, ఇది మొదటి వాదనగా ఇవ్వబడిన IP చిరునామాను కప్పివేస్తుంది, మిగిలిన వాదనలుగా అందించబడిన ఇప్పటికే ఉన్న పోర్ట్ల జాబితాను మినహాయించి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"While shroud is running, any port scanning attempts will show every port to be open.","translation":"ష్రౌడ్ రన్ అవుతున్నప్పుడు, ఏదైనా పోర్ట్ స్కానింగ్ ప్రయత్నాలు ప్రతి పోర్ట్ తెరిచి ఉన్నట్లు చూపుతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The only service that is actually running is ssh on port 22, but it is hidden in a sea of false positives.","translation":"వాస్తవానికి నడుస్తున్న ఏకైక సేవ పోర్ట్ 22లో ssh, కానీ ఇది తప్పుడు సానుకూల సముద్రంలో దాగి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A dedicated attacker could simply telnet to every port to check the banners, but this technique could easily be expanded to spoof banners also.","translation":"ఒక ప్రత్యేక దాడి చేసే వ్యక్తి బ్యానర్లను తనిఖీ చేయడానికి ప్రతి పోర్ట్కు టెల్నెట్ చేయవచ్చు, కానీ ఈ సాంకేతికతను బ్యానర్లను స్ఫూఫ్ చేయడానికి కూడా సులభంగా విస్తరించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Network programming tends to move many chunks of memory around and is heavy in typecasting.","translation":"నెట్వర్క్ ప్రోగ్రామింగ్ మెమరీ యొక్క అనేక భాగాలను తరలించడానికి మొగ్గు చూపుతుంది మరియు టైప్కాస్టింగ్లో భారీగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Mistakes thrive in this type of chaos.","translation":"ఈ రకమైన గందరగోళంలో తప్పులు వృద్ధి చెందుతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"And since many network programs need to run as root, these little mistakes can become critical vulnerabilities.","translation":"మరియు చాలా నెట్వర్క్ ప్రోగ్రామ్లు రూట్గా అమలు చేయవలసి ఉన్నందున, ఈ చిన్న తప్పులు క్లిష్టమైన బలహీనతలుగా మారవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"extending the sign bit from a 32-bit integer to 64-bit integer.","translation":"32-బిట్ పూర్ణాంకం నుండి 64-బిట్ పూర్ణాంకానికి గుర్తు బిట్ను విస్తరించడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Operationally, this means if the sign bit of EAX is 0, the cdq instruction will zero the EDX register.","translation":"ఆపరేషనల్గా, EAX యొక్క గుర్తు బిట్ 0 అయితే, cdq సూచన EDX రిజిస్టర్ను సున్నా చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using xor to zero the EDX register requires two bytes.","translation":"EDX రిజిస్టర్ను సున్నా చేయడానికి xorని ఉపయోగించడానికి రెండు బైట్లు అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Another byte can be saved with clever use of the stack.","translation":"స్టాక్ను తెలివిగా ఉపయోగించడం ద్వారా మరొక బైట్ను సేవ్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since the stack is 32-bit aligned, a single byte value pushed to the stack will be aligned as a doubleword.","translation":"స్టాక్ 32-బిట్ సమలేఖనం చేయబడినందున, స్టాక్కు నెట్టబడిన ఒకే బైట్ విలువ డబుల్ వర్డ్గా సమలేఖనం చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When this value is popped off, it will be sign-extended, filling the entire register.","translation":"ఈ విలువను తీసివేసినప్పుడు, అది గుర్తు-విస్తరించబడుతుంది, మొత్తం రిజిస్టర్ను నింపుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The instructions that push a single byte and pop it back into a register take three bytes.","translation":"ఒకే బైట్ను నెట్టివేసి, దానిని తిరిగి రిజిస్టర్లోకి తీసుకునే సూచనలకు మూడు బైట్లు పడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These tricks are used in the following shellcode listing.","translation":"ఈ ఉపాయాలు కింది షెల్కోడ్ జాబితాలో ఉపయోగించబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This assembles into the same shellcode as that used in the previous chapters.","translation":"ఇది మునుపటి అధ్యాయాలలో ఉపయోగించిన అదే షెల్కోడ్గా సమీకరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"setresuid(uid_t ruid, uid_t euid, uid_t suid);","translation":"setresuid(uid_t ruid, uid_t euid, uid_t suid);","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Restore all root privs.","translation":"అన్ని రూట్ అధికారాలను పునరుద్ధరించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"execve(const char *filename, char *const argv [], char *const envp[])","translation":"execve(const char *filename, char *const argv [], char *const envp[])","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The syntax for pushing a single byte requires the size to be declared.","translation":"ఒకే బైట్ను నెట్టడానికి సింటాక్స్ పరిమాణాన్ని ప్రకటించవలసి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Valid sizes are BYTE for one byte, WORD for two bytes, and DWORD for four bytes.","translation":"ఒకే బైట్కు BYTE, రెండు బైట్లకు WORD మరియు నాలుగు బైట్లకు DWORD చెల్లుబాటు అయ్యే పరిమాణాలు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When exploiting a remote program, the shellcode we’ve designed so far won’t work.","translation":"రిమోట్ ప్రోగ్రామ్ను ఉపయోగించుకున్నప్పుడు, మేము ఇప్పటివరకు రూపొందించిన షెల్కోడ్ పని చేయదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Port-binding shellcode will bind the shell to a network port where it listens for incoming connections.","translation":"పోర్ట్-బైండింగ్ షెల్కోడ్ షెల్ను నెట్వర్క్ పోర్ట్కు బంధిస్తుంది, ఇక్కడ అది ఇన్కమింగ్ కనెక్షన్ల కోసం వింటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In the previous chapter, we used this kind of shellcode to exploit the tinyweb server.","translation":"మునుపటి అధ్యాయంలో, మేము చిన్న వెబ్ సర్వర్ను ఉపయోగించుకోవడానికి ఈ రకమైన షెల్కోడ్ను ఉపయోగించాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The following C code binds to port 31337 and listens for a TCP connection.","translation":"కింది C కోడ్ పోర్ట్ 31337కి బంధిస్తుంది మరియు TCP కనెక్షన్ కోసం వింటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These familiar socket functions can all be accessed with a single Linux system call, aptly named socketcall().","translation":"ఈ తెలిసిన సాకెట్ ఫంక్షన్లన్నింటినీ ఒకే లైనక్స్ సిస్టమ్ కాల్ ద్వారా యాక్సెస్ చేయవచ్చు, దీనిని socketcall() అని పిలుస్తారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"User programs should call the appropriate functions by their usual names.","translation":"వినియోగదారు ప్రోగ్రామ్లు తగిన ఫంక్షన్లను వాటి సాధారణ పేర్లతో పిలవాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"For the shellcode to survive transit, it must be redesigned so it doesn’t contain any null bytes.","translation":"షెల్కోడ్ రవాణాలో నిలబడాలంటే, దాన్ని మళ్లీ రూపొందించాలి, తద్వారా అది శూన్య బైట్లను కలిగి ఉండదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Looking at the disassembly, it is obvious that the first null bytes come from the call instruction.","translation":"అసెంబ్లీని పరిశీలిస్తే, మొదటి శూన్య బైట్లు కాల్ సూచన నుండి వస్తున్నాయని స్పష్టంగా తెలుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This instruction jumps execution forward by 19 (0x13) bytes, based on the first operand.","translation":"ఈ సూచన మొదటి ఆపరేండ్ ఆధారంగా 19 (0x13) బైట్ల ద్వారా అమలును ముందుకు దూకుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One way around this problem takes advantage of two’s complement.","translation":"ఈ సమస్యను అధిగమించడానికి ఒక మార్గం రెండు యొక్క పూరకాలను ఉపయోగించుకోవడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A small negative number will have its leading bits turned on, resulting in 0xff bytes.","translation":"చిన్న రుణ సంఖ్య దాని ప్రధాన బిట్లను ఆన్ చేస్తుంది, ఫలితంగా 0xff బైట్లు వస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This means that, if we call using a negative value to move backward in execution, the machine code for that instruction won’t have any null bytes.","translation":"అంటే, మనం అమలులో వెనుకకు వెళ్లడానికి ప్రతికూల విలువను ఉపయోగించి కాల్ చేస్తే, ఆ సూచన కోసం మెషిన్ కోడ్లో ఎటువంటి శూన్య బైట్లు ఉండవు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The following revision of the helloworld shellcode uses a standard implementation of this trick: Jump to the end of the shellcode to a call instruction which, in turn, will jump back to a pop instruction at the beginning of the shellcode.","translation":"హలోవరల్డ్ షెల్కోడ్ యొక్క క్రింది సవరణ ఈ ట్రిక్ యొక్క ప్రామాణిక అమలును ఉపయోగిస్తుంది: షెల్కోడ్ చివరికి కాల్ సూచనకు వెళ్లండి, ఇది షెల్కోడ్ ప్రారంభంలో పాప్ సూచనకు తిరిగి దూకుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"After assembling this new shellcode, disassembly shows that the call instruction (shown in italics below) is now free of null bytes.","translation":"ఈ కొత్త షెల్కోడ్ను అసెంబ్లింగ్ చేసిన తర్వాత, డిస్అసెంబ్లీ కాల్ సూచన (క్రింద ఇటాలిక్స్లో చూపబడింది) ఇప్పుడు శూన్య బైట్ల నుండి విముక్తి పొందిందని చూపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These remaining null bytes can be eliminated with an understanding of register widths and addressing.","translation":"రిజిస్టర్ వెడల్పులు మరియు చిరునామాల గురించి అవగాహనతో ఈ మిగిలిన శూన్య బైట్లను తొలగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The normal jmp instruction, as well as the call instruction (which has no short version), allows for much longer jumps.","translation":"సాధారణ జంప్ సూచన, అలాగే కాల్ సూచన (దీనికి చిన్న వెర్షన్ లేదు), చాలా ఎక్కువ దూకులను అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The EAX, EBX, ECX, EDX, ESI, EDI, EBP, and ESP registers are 32 bits in width.","translation":"EAX, EBX, ECX, EDX, ESI, EDI, EBP మరియు ESP రిజిస్టర్లు 32 బిట్ల వెడల్పును కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The three variations of a mov instruction are shown below.","translation":"ఒక mov సూచన యొక్క మూడు వైవిధ్యాలు క్రింద చూపబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Using the AL, BL, CL, or DL register will put the correct least significant byte into the corresponding extended register without creating any null bytes in the machine code.","translation":"AL, BL, CL లేదా DL రిజిస్టర్ను ఉపయోగించడం వలన సరైన అతి తక్కువ ముఖ్యమైన బైట్ను సంబంధిత విస్తరించిన రిజిస్టర్లో ఉంచుతుంది, మెషిన్ కోడ్లో ఎటువంటి శూన్య బైట్లను సృష్టించకుండా.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If we want the 32-bit register values to be correct, we need to zero out the entire register before the mov instructions—but this, again, must be done without using null bytes.","translation":"మనం 32-బిట్ రిజిస్టర్ విలువలు సరిగ్గా ఉండాలని కోరుకుంటే, mov సూచనలకు ముందు మొత్తం రిజిస్టర్ను సున్నా చేయాలి—కానీ ఇది మళ్ళీ, శూన్య బైట్లను ఉపయోగించకుండా చేయాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"These first two are small instructions that increment and decrement their operand by one.","translation":"మొదటి రెండు చిన్న సూచనలు, ఇవి వాటి ఆపరేండ్ను ఒకటి ద్వారా పెంచుతాయి మరియు తగ్గిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Subtracting any value from itself also produces 0 and doesn’t require any static data.","translation":"ఏదైనా విలువను దాని నుండి తీసివేయడం కూడా 0 ను ఉత్పత్తి చేస్తుంది మరియు ఎటువంటి స్థిర డేటాను కోరుకోదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This can be done with a single two-byte instruction: 29 C0 sub eax,eax","translation":"దీన్ని ఒకే రెండు-బైట్ సూచనతో చేయవచ్చు: 29 C0 sub eax,eax","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The xor instruction performs an e xclusive or operation on the bits in a register.","translation":"xor సూచన రిజిస్టర్లోని బిట్లపై ప్రత్యేకమైన లేదా ఆపరేషన్ను నిర్వహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since 1 xored with 1 results in a 0, and 0 xored with 0 results in a 0, any value xored with itself will result in 0.","translation":"1 ను 1తో xor చేస్తే 0 వస్తుంది, మరియు 0 ను 0తో xor చేస్తే 0 వస్తుంది, ఏదైనా విలువను దానితో xor చేస్తే 0 వస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This next revision of the shellcode makes use of the smaller registers and the xor instruction to avoid null bytes.","translation":"షెల్కోడ్ యొక్క తదుపరి సవరణ శూన్య బైట్లను నివారించడానికి చిన్న రిజిస్టర్లు మరియు xor సూచనను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"push \"//sh\" to the stack.","translation":"\"//sh\" ను స్టాక్కు నెట్టండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"push 0x6e69622f ; push \"/bin\" to the stack.","translation":"0x6e69622f ని నెట్టండి; స్టాక్కు \"/bin\" ని నెట్టండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"mov ebx, esp ; Put the address of \"/bin//sh\" into ebx via esp.","translation":"ebx, esp ని తరలించండి; esp ద్వారా ebx లోకి \"/bin//sh\" చిరునామాను ఉంచండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"push edx ; push 32-bit null terminator to stack.","translation":"edx ని నెట్టండి; 32-బిట్ శూన్య టెర్మినేటర్ను స్టాక్కు నెట్టండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"mov edx, esp ; This is an empty array for envp.","translation":"edx, esp ని తరలించండి; ఇది envp కోసం ఖాళీ శ్రేణి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"push ebx ; push string addr to stack above null terminator.","translation":"ebx ని నెట్టండి; శూన్య టెర్మినేటర్ పైన స్టాక్కు స్ట్రింగ్ చిరునామాను నెట్టండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"mov ecx, esp ; This is the argv array with string ptr.","translation":"ecx, esp ని తరలించండి; ఇది స్ట్రింగ్ ptrతో argv శ్రేణి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"int 0x80 ; execve(\"/bin//sh\", [\"/bin//sh\", NULL], [NULL])","translation":"int 0x80; execve(\"/bin//sh\", [\"/bin//sh\", NULL], [NULL])","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This assembles to the same 92-byte bind_shell shellcode used in the previous chapter.","translation":"ఇది మునుపటి అధ్యాయంలో ఉపయోగించిన అదే 92-బైట్ bind_shell షెల్కోడ్కు అసెంబుల్ అవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most firewalls will block incoming connections, except for certain ports with known services.","translation":"చాలా ఫైర్వాల్లు తెలిసిన సేవల కోసం నిర్దిష్ట పోర్ట్లను మినహాయించి, ఇన్కమింగ్ కనెక్షన్లను బ్లాక్ చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Software firewalls are now so common that port-bind shellcode has little chance of actually working in the wild.","translation":"సాఫ్ట్వేర్ ఫైర్వాల్లు ఇప్పుడు చాలా సాధారణం, పోర్ట్-బైండ్ షెల్కోడ్ వాస్తవానికి అడవిలో పనిచేసే అవకాశం చాలా తక్కువ.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"From inside the firewall, a user should be able to access any web page or make any other outbound connections.","translation":"ఫైర్వాల్ లోపల నుండి, ఒక వినియోగదారు ఏదైనా వెబ్ పేజీని యాక్సెస్ చేయగలరు లేదా ఏదైనా ఇతర అవుట్బౌండ్ కనెక్షన్లను చేయగలరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Instead of waiting for a connection from an attacker, connect-back shellcode initiates a TCP connection back to the attacker’s IP address.","translation":"దాడి చేసేవారి నుండి కనెక్షన్ కోసం ఎదురు చూసే బదులు, కనెక్ట్-బ్యాక్ షెల్కోడ్ దాడి చేసేవారి IP చిరునామాకు తిరిగి TCP కనెక్షన్ను ప్రారంభిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Opening a TCP connection only requires a call to socket() and a call to connect().","translation":"TCP కనెక్షన్ను తెరవడానికి socket()కి కాల్ చేయడం మరియు connect()కి కాల్ చేయడం మాత్రమే అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is very similar to the bind-port shellcode, since the socket call is exactly the same and the connect() call takes the same type of arguments as bind().","translation":"socket కాల్ సరిగ్గా ఒకే విధంగా ఉండటం మరియు connect() కాల్ bind() వలె అదే రకమైన వాదనలను తీసుకోవడం వలన ఇది బైండ్-పోర్ట్ షెల్కోడ్కు చాలా పోలి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The following connect-back shellcode was made from the bind-port shellcode with a few modifications (shown in bold).","translation":"కింది కనెక్ట్-బ్యాక్ షెల్కోడ్ కొన్ని మార్పులతో (బోల్డ్లో చూపబడింది) బైండ్-పోర్ట్ షెల్కోడ్ నుండి తయారు చేయబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This address is stored in the in_addr structure as 0x482aa8c0, which is the hexadecimal representation of 72, 42, 168, and 192.","translation":"ఈ చిరునామా in_addr నిర్మాణంలో 0x482aa8c0గా నిల్వ చేయబడుతుంది, ఇది 72, 42, 168 మరియు 192 యొక్క హెక్సాడెసిమల్ ప్రాతినిధ్యం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This means the DWORD for 192.168.42.72 is 0x482aa8c0.","translation":"అంటే 192.168.42.72 కోసం DWORD 0x482aa8c0.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The netcat program can also be used to listen for incoming connections with the -l command-line option.","translation":"నెట్క్యాట్ ప్రోగ్రామ్ను -l కమాండ్-లైన్ ఎంపికతో ఇన్కమింగ్ కనెక్షన్లను వినడానికి కూడా ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Now, let’s try to exploit the tinyweb server program using the connect-back shellcode.","translation":"ఇప్పుడు, కనెక్ట్-బ్యాక్ షెల్కోడ్ని ఉపయోగించి చిన్న వెబ్ సర్వర్ ప్రోగ్రామ్ను ఎక్స్ప్లాయిట్ చేయడానికి ప్రయత్నిద్దాం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Fortunately, in the new tinyweb daemon, signals are only used for clean termination, so the implementation is simple.","translation":"అదృష్టవశాత్తు, కొత్త tinyweb డీమన్ లో, సిగ్నల్స్ శుభ్రమైన ముగింపు కోసం మాత్రమే ఉపయోగించబడతాయి, కాబట్టి అమలు చాలా సులభం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It writes its output to a log file with timestamps, and it listens for the terminate ( SIGTERM) signal so it can shut down cleanly when it’s killed.","translation":"ఇది దాని అవుట్పుట్ను టైమ్స్టాంప్లతో లాగ్ ఫైల్కు వ్రాస్తుంది మరియు అది చంపబడినప్పుడు శుభ్రంగా మూసివేయడానికి టెర్మినేట్ (SIGTERM) సిగ్నల్ కోసం వింటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These additions are fairly minor, but they provide a much more realistic exploit target.","translation":"ఈ చేర్పులు చాలా చిన్నవి, కానీ అవి చాలా వాస్తవికమైన దోపిడీ లక్ష్యాన్ని అందిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The new portions of the code are shown in bold in the listing below.","translation":"కోడ్లోని కొత్త భాగాలు క్రింద జాబితాలో బోల్డ్లో చూపబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This function is called when the process is killed.","translation":"ప్రక్రియను చంపినప్పుడు ఈ ఫంక్షన్ కాల్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This tinywebd program serves HTTP content just like the original tinyweb program, but it behaves as a system daemon, detaching from the controlling terminal and writing to a log file.","translation":"ఈ tinywebd ప్రోగ్రామ్ అసలు tinyweb ప్రోగ్రామ్ లాగానే HTTP కంటెంట్ను అందిస్తుంది, కానీ ఇది సిస్టమ్ డీమన్గా ప్రవర్తిస్తుంది, నియంత్రించే టెర్మినల్ నుండి వేరుచేయబడి లాగ్ ఫైల్కు వ్రాస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Both programs are vulnerable to the same overflow exploit; however, the exploitation is only the beginning.","translation":"రెండు ప్రోగ్రామ్లు ఒకే ఓవర్ఫ్లో దోపిడీకి గురవుతాయి; అయితే, దోపిడీ ప్రారంభం మాత్రమే.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Through careful manipulation of the internal mechanisms, the security can be entirely sidestepped.","translation":"అంతర్గత విధానాలను జాగ్రత్తగా మార్చడం ద్వారా, భద్రతను పూర్తిగా దాటవేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exploit programs are more like guns than tools.","translation":"ఎక్స్ప్లాయిట్ ప్రోగ్రామ్లు సాధనాల కంటే తుపాకీల వంటివి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In contrast, exploit tools usually aren’t finished products, nor are they meant for others to use.","translation":"దీనికి విరుద్ధంగా, ఎక్స్ప్లాయిట్ సాధనాలు సాధారణంగా పూర్తయిన ఉత్పత్తులు కావు, లేదా వాటిని ఇతరులు ఉపయోగించడానికి ఉద్దేశించినవి కావు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"With an understanding of programming, it’s only natural that a hacker would begin to write his own scripts and tools to aid exploitation.","translation":"ప్రోగ్రామింగ్ గురించి అవగాహనతో, ఒక హ్యాకర్ దోపిడీకి సహాయపడటానికి తన స్వంత స్క్రిప్ట్లు మరియు సాధనాలను రాయడం సహజం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"For the tinyweb daemon, we want an exploit tool that allows us to experiment with the vulnerabilities.","translation":"tinyweb డీమన్ కోసం, మేము బలహీనతలతో ప్రయోగాలు చేయడానికి అనుమతించే దోపిడీ సాధనాన్ని కోరుకుంటున్నాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The offset to the return address will be the same as in the original tinyweb.c program, but a daemon program presents added challenges.","translation":"రిటర్న్ అడ్రస్కు ఆఫ్సెట్ అసలు tinyweb.c ప్రోగ్రామ్లో వలెనే ఉంటుంది, కానీ డీమన్ ప్రోగ్రామ్ అదనపు సవాళ్లను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In order to debug this program, GDB needs to be told to follow the child process, as opposed to following the parent.","translation":"ఈ ప్రోగ్రామ్ను డీబగ్ చేయడానికి, తల్లిదండ్రులను అనుసరించడానికి బదులుగా చైల్డ్ ప్రాసెస్ను అనుసరించమని GDBకి చెప్పాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The debugger shows that the request buffer starts at 0xbffff5c0 and the stored return address is at 0xbffff7dc, which means the offset is 540 bytes.","translation":"అభ్యర్థన బఫర్ 0xbffff5c0 వద్ద ప్రారంభమవుతుందని మరియు నిల్వ చేయబడిన రిటర్న్ చిరునామా 0xbffff7dc వద్ద ఉందని డీబగ్గర్ చూపిస్తుంది, అంటే ఆఫ్సెట్ 540 బైట్లు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The safest place for the shellcode is near the middle of the 500-byte request buffer.","translation":"షెల్కోడ్ కోసం సురక్షితమైన ప్రదేశం 500-బైట్ అభ్యర్థన బఫర్ మధ్యలో ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since the offset to the return address is 540 bytes, 544 bytes are needed to overwrite the address.","translation":"రిటర్న్ అడ్రస్కు ఆఫ్సెట్ 540 బైట్లు కాబట్టి, చిరునామాను తిరిగి వ్రాయడానికి 544 బైట్లు అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"All these repetitive steps can be put into a single shell script.","translation":"ఈ పునరావృతమయ్యే అన్ని దశలను ఒకే షెల్ స్క్రిప్ట్లో ఉంచవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If log files seem like the most obvious sign of intrusion to you, then you are forgetting about the loss of service.","translation":"లాగ్ ఫైల్లు మీకు చొరబాటు యొక్క స్పష్టమైన సంకేతంగా అనిపిస్తే, మీరు సర్వీస్ నష్టాన్ని మరచిపోతున్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the tinyweb daemon is exploited, the process is tricked into providing a remote root shell, but it no longer processes web requests.","translation":"tinyweb డీమన్ దోపిడీకి గురైనప్పుడు, రిమోట్ రూట్ షెల్ను అందించడానికి ప్రక్రియ మోసగిస్తుంది, కానీ అది ఇకపై వెబ్ అభ్యర్థనలను ప్రాసెస్ చేయదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The end goal is a piece of shellcode that will spawn a shell yet keep the tinyweb server running.","translation":"చివరి లక్ష్యం ఏమిటంటే, షెల్ను ఉత్పత్తి చేసే షెల్కోడ్ను తయారు చేయడం, అయితే చిన్న వెబ్ సర్వర్ను నడుపుతూనే ఉంచడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Let’s begin by writing a piece of shellcode that does something to prove it ran and then puts the tinyweb daemon back together.","translation":"ఇది నడిచిందని నిరూపించడానికి ఏదైనా చేసే షెల్కోడ్ను రాయడం ద్వారా ప్రారంభిద్దాం, ఆపై చిన్న వెబ్ డీమన్ను తిరిగి కలుపుదాం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since the tinyweb daemon redirects standard out to /dev/null, writing to standard out isn’t a reliable marker for shellcode.","translation":"చిన్న వెబ్ డీమన్ ప్రామాణిక అవుట్పుట్ను /dev/nullకి మళ్ళిస్తుంది కాబట్టి, ప్రామాణిక అవుట్పుట్కు రాయడం షెల్కోడ్కు నమ్మదగిన మార్కర్ కాదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"One simple way to prove the shellcode ran is to create a file.","translation":"షెల్కోడ్ నడిచిందని నిరూపించడానికి ఒక సాధారణ మార్గం ఏమిటంటే ఒక ఫైల్ను సృష్టించడం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This can be done by making a call to open(), and then close().","translation":"దీనిని open()కి కాల్ చేయడం ద్వారా మరియు తరువాత close() చేయడం ద్వారా చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Of course, the open() call will need the appropriate flags to create a file.","translation":"ఖచ్చితంగా, ఫైల్ను సృష్టించడానికి open() కాల్ తగిన ఫ్లాగ్లను కలిగి ఉండాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"We could look through the include files to figure out what O_CREAT and all the other necessary defines actually are and do all the bitwise math for the arguments, but that’s sort of a pain in the ass.","translation":"O_CREAT మరియు ఇతర అవసరమైన నిర్వచనాలు ఏమిటో తెలుసుకోవడానికి మేము చేర్చబడిన ఫైల్లను చూడవచ్చు మరియు వాదనల కోసం బిట్వైజ్ గణితాన్ని చేయవచ్చు, కాని అది కొంచెం కష్టంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If you recall, we’ve done something like this already—the notetaker program makes a call to open() which will create a file if it didn’t exist.","translation":"మీకు గుర్తుంటే, మేము ఇప్పటికే ఇలాంటివి చేసాము—నోట్టేకర్ ప్రోగ్రామ్ open()కి కాల్ చేస్తుంది, ఇది ఉనికిలో లేకపోతే ఫైల్ను సృష్టిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The strace program can be used on any program to show every system call it makes.","translation":"strace ప్రోగ్రామ్ను అది చేసే ప్రతి సిస్టమ్ కాల్ని చూపించడానికి ఏదైనా ప్రోగ్రామ్లో ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In the output below, this is used to verify that the arguments to open() in C match up with the raw sys- tem calls.","translation":"దిగువ అవుట్పుట్లో, Cలోని open()కి సంబంధించిన వాదనలు ముడి సిస్టమ్ కాల్లతో సరిపోతున్నాయో లేదో ధృవీకరించడానికి ఇది ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The compiler has already done all the work of looking up the defines and mashing them together with a bitwise OR oper- ation; we just need to find the call arguments in the disassembly of the note- taker binary.","translation":"కంపైలర్ ఇప్పటికే నిర్వచనాలను వెతకడం మరియు వాటిని బిట్వైజ్ OR ఆపరేషన్తో కలిపివేయడం వంటి పనులన్నీ చేసింది; మనం నోట్-టేకర్ బైనరీ యొక్క డిస్అసెంబ్లీలో కాల్ వాదనలను కనుగొనాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Remember that the arguments to a function call will be pushed to the stack in reverse.","translation":"ఒక ఫంక్షన్ కాల్కు సంబంధించిన వాదనలు రివర్స్లో స్టాక్కు నెట్టబడతాయని గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In this case, the compiler decided to use mov DWORD PTR [esp+offset], value_to_push_to_stack instead of push instructions, but the structure built on the stack is equivalent.","translation":"ఈ సందర్భంలో, కంపైలర్ పుష్ సూచనలకు బదులుగా mov DWORD PTR [esp+offset], value_to_push_to_stackని ఉపయోగించాలని నిర్ణయించుకుంది, కాని స్టాక్పై నిర్మించిన నిర్మాణం సమానం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The first argument is a pointer to the name of the file in EAX, the second argument ( put at [esp+4]) is 0x441, and the third argument ( put at [esp+8]) is 0x180.","translation":"మొదటి వాదన EAXలోని ఫైల్ పేరుకు సూచిక, రెండవ వాదన ([esp+4] వద్ద ఉంచబడింది) 0x441, మరియు మూడవ వాదన ([esp+8] వద్ద ఉంచబడింది) 0x180.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This means that O_WRONLY| O_CREAT|O_APPEND turns out to be 0x441 and S_IRUSR|S_IWUSR is 0x180.","translation":"అంటే O_WRONLY| O_CREAT|O_APPEND 0x441గా మారుతుంది మరియు S_IRUSR|S_IWUSR 0x180.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The shellcode opens a file to create it and then immediately closes the file.","translation":"షెల్కోడ్ ఒక ఫైల్ను సృష్టించడానికి తెరుస్తుంది మరియు వెంటనే ఫైల్ను మూసివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Finally, it calls exit to avoid an infinite loop.","translation":"చివరగా, అనంత లూప్ను నివారించడానికి ఇది నిష్క్రమణను పిలుస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"To put things back together again, we just need to repair any collateral damage caused by the overwrite and/or shellcode, and then jump execution back into the connection accepting loop in main().","translation":"అంశాలను మళ్లీ కలపడానికి, మనం అతివ్రాత మరియు/లేదా షెల్కోడ్ వల్ల కలిగే ఏదైనా నష్టాన్ని సరిచేయాలి, ఆపై అమలును main()లోని కనెక్షన్ అంగీకార లూప్లోకి తిరిగి తీసుకురావాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"All three of these addresses basically go to the same place.","translation":"ఈ మూడు చిరునామాలు ప్రాథమికంగా ఒకే ప్రదేశానికి వెళ్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Since computers are deterministic, the assembly instructions will clearly explain how to do all this.","translation":"కంప్యూటర్లు నిర్ధారితమైనవి కాబట్టి, అసెంబ్లీ సూచనలు ఇవన్నీ ఎలా చేయాలో స్పష్టంగా వివరిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The decoding loop uses the EDX register as a counter.","translation":"డీకోడింగ్ లూప్ EDX రిజిస్టర్ను కౌంటర్గా ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It begins at 8 and counts down to 0, since 8 bytes need to be decoded.","translation":"ఇది 8 వద్ద ప్రారంభమవుతుంది మరియు 0 వరకు లెక్కిస్తుంది, ఎందుకంటే 8 బైట్లను డీకోడ్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"From another terminal, the shellcode is assembled and used with the socket-reusing exploit tool.","translation":"మరొక టెర్మినల్ నుండి, షెల్కోడ్ సమీకరించబడుతుంది మరియు సాకెట్-రీయుజింగ్ ఎక్స్ప్లాయిట్ సాధనంతో ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Now that the decoding has been verified, the int3 instructions can be removed from the shellcode.","translation":"ఇప్పుడు డీకోడింగ్ ధృవీకరించబడినందున, int3 సూచనలను షెల్కోడ్ నుండి తీసివేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The NOP sled is another signature easy to detect by network IDSes and IPSes.","translation":"NOP స్లెడ్ అనేది నెట్వర్క్ IDలు మరియు IPSల ద్వారా గుర్తించడం సులభమైన మరొక సంతకం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Large blocks of 0x90 aren’t that common, so if a network security mechanism sees something like this, it’s probably an exploit.","translation":"0x90 యొక్క పెద్ద బ్లాక్లు అంత సాధారణం కాదు, కాబట్టి నెట్వర్క్ భద్రతా విధానం ఇలాంటి వాటిని చూస్తే, అది బహుశా ఒక ఎక్స్ప్లాయిట్.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"To avoid this signature, we can use different single-byte instructions instead of NOP.","translation":"ఈ సంతకాన్ని నివారించడానికి, మనం NOPకి బదులుగా వేర్వేరు సింగిల్-బైట్ సూచనలను ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There are several one-byte instructions—the increment and decrement instructions for various registers—that are also printable ASCII characters.","translation":"అనేక ఒక-బైట్ సూచనలు ఉన్నాయి—వివిధ రిజిస్టర్ల కోసం ఇంక్రిమెంట్ మరియు డిక్రిమెంట్ సూచనలు—అవి ప్రింటబుల్ ASCII అక్షరాలు కూడా.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since we zero out these registers before we use them, we can safely use a random combination of these bytes for the NOP sled.","translation":"వాటిని ఉపయోగించే ముందు మేము ఈ రిజిస్టర్లను సున్నాకి సెట్ చేస్తాము కాబట్టి, NOP స్లెడ్ కోసం ఈ బైట్ల యొక్క యాదృచ్ఛిక కలయికను సురక్షితంగా ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Creating a new exploit tool that uses random combinations of the bytes @, C, A, B, H, K, I, and J instead of a regular NOP sled will be left as an exercise for the reader.","translation":"@, C, A, B, H, K, I, మరియు J బైట్ల యొక్క యాదృచ్ఛిక కలయికలను సాధారణ NOP స్లెడ్కు బదులుగా ఉపయోగించే కొత్త ఎక్స్ప్లాయిట్ సాధనాన్ని రూపొందించడం పాఠకుడి కోసం ఒక వ్యాయామంగా మిగిలిపోతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The easiest way to do this would be by writing a sled-generation program in C, which is used with a BASH script.","translation":"దీన్ని చేయడానికి సులభమైన మార్గం ఏమిటంటే, Cలో స్లెడ్-తరం ప్రోగ్రామ్ను రాయడం, ఇది BASH స్క్రిప్ట్తో ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This modification will hide the exploit buffer from IDSes that look for a NOP sled.","translation":"ఈ మార్పు NOP స్లెడ్ను చూసే IDల నుండి ఎక్స్ప్లాయిట్ బఫర్ను దాచిపెడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Sometimes a program will place certain restrictions on buffers.","translation":"కొన్నిసార్లు ఒక ప్రోగ్రామ్ బఫర్లపై కొన్ని పరిమితులను ఉంచుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Consider the following example program, which is used to update product descriptions in a fictitious database.","translation":"ఫిక్టిషియస్ డేటాబేస్లో ఉత్పత్తి వివరణలను అప్డేట్ చేయడానికి ఉపయోగించే కింది ఉదాహరణ ప్రోగ్రామ్ను పరిగణించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The first argument is the product code, and the second is the updated description.","translation":"మొదటి వాదన ఉత్పత్తి కోడ్, మరియు రెండవది నవీకరించబడిన వివరణ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This program doesn’t actually update a database, but it does have an obvious vulnerability in it.","translation":"ఈ ప్రోగ్రామ్ వాస్తవానికి డేటాబేస్ను అప్డేట్ చేయదు, కానీ ఇందులో స్పష్టమైన దుర్బలత్వం ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Despite the vulnerability, the code does make an attempt at security.","translation":"దుర్బలత్వం ఉన్నప్పటికీ, కోడ్ భద్రతను ప్రయత్నిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The length of the product ID argument is restricted, and the contents of the description argument are limited to printable characters.","translation":"ఉత్పత్తి ID వాదన యొక్క పొడవు పరిమితం చేయబడింది మరియు వివరణ వాదన యొక్క విషయాలు ప్రింటబుల్ అక్షరాలకు పరిమితం చేయబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In addition, the unused environment variables and program arguments are cleared out for security reasons.","translation":"అదనంగా, ఉపయోగించని పర్యావరణ వేరియబుల్స్ మరియు ప్రోగ్రామ్ వాదనలు భద్రతా కారణాల దృష్ట్యా క్లియర్ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The printable input validation is the only thing stopping exploitation.","translation":"ప్రింటబుల్ ఇన్పుట్ ధ్రువీకరణ మాత్రమే దోపిడీని ఆపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The best way to generate a sockaddr_in structure for injection is to write a little C program that creates and dumps the structure.","translation":"ఇంజక్షన్ కోసం sockaddr_in నిర్మాణాన్ని రూపొందించడానికి ఉత్తమ మార్గం ఏమిటంటే, నిర్మాణం సృష్టించి, డంప్ చేసే చిన్న C ప్రోగ్రామ్ను రాయడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This program can be used to inject a sockaddr_in structure.","translation":"ఈ ప్రోగ్రామ్ను sockaddr_in నిర్మాణాన్ని ఇంజెక్ట్ చేయడానికి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"To integrate this into our exploit, the address structure is injected after the fake request but before the NOP sled.","translation":"దీనిని మన ఎక్స్ప్లోయిట్లోకి అనుసంధానించడానికి, చిరునామా నిర్మాణం నకిలీ అభ్యర్థన తర్వాత కానీ NOP స్లెడ్ ముందు ఇంజెక్ట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since the client_addr_ptr is passed as a second function argument, it will be on the stack two dwords after the return address.","translation":"client_addr_ptr రెండవ ఫంక్షన్ వాదనగా అందించబడినందున, అది రిటర్న్ చిరునామా తర్వాత రెండు dwords స్టాక్లో ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The best way to explain exactly what this exploit script does is to watch tinywebd from within GDB.","translation":"ఈ ఎక్స్ప్లోయిట్ స్క్రిప్ట్ సరిగ్గా ఏమి చేస్తుందో వివరించడానికి ఉత్తమ మార్గం ఏమిటంటే GDB లోపల నుండి tinywebdని చూడటం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In the output below, GDB is used to attach to the running tinywebd process, breakpoints are set before the overflow, and the IP portion of the log buffer is generated.","translation":"దిగువ అవుట్పుట్లో, GDBని రన్నింగ్ tinywebd ప్రక్రియకు అటాచ్ చేయడానికి ఉపయోగిస్తారు, బ్రేక్పాయింట్లు ఓవర్ఫ్లోకి ముందు సెట్ చేయబడతాయి మరియు లాగ్ బఫర్ యొక్క IP భాగం ఉత్పత్తి చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Then, from another terminal, the new spoofing exploit is used to advance execution in the debugger.","translation":"అప్పుడు, మరొక టెర్మినల్ నుండి, డీబగ్గర్లో అమలును ముందుకు తీసుకెళ్లడానికి కొత్త స్పూఫింగ్ ఎక్స్ప్లోయిట్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"As long as the log file descriptor doesn’t happen to be 2560 (0x0a00 in hexadecimal), every time handle_connection() tries to write to the log it will fail.","translation":"లాగ్ ఫైల్ డిస్క్రిప్టర్ 2560 (హెక్సాడెసిమల్లో 0x0a00) కానంత కాలం, handle_connection() లాగ్కి వ్రాయడానికి ప్రయత్నించిన ప్రతిసారీ అది విఫలమవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This output clearly shows the attempts to write to the log file failing.","translation":"ఈ అవుట్పుట్ లాగ్ ఫైల్కు వ్రాయడానికి ప్రయత్నాలు విఫలమవుతున్నాయని స్పష్టంగా చూపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Normally, we wouldn’t be able to overwrite the logfd variable, since the client_addr_ptr is in the way.","translation":"సాధారణంగా, client_addr_ptr మార్గంలో ఉన్నందున, మేము logfd వేరియబుల్ను తిరిగి వ్రాయలేము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"But since we’ve made sure this variable points to valid memory (our injected spoofed address structure), we’re free to overwrite the variables that lie beyond it.","translation":"కానీ మేము ఈ వేరియబుల్ చెల్లుబాటు అయ్యే మెమరీకి (మా ఇంజెక్ట్ చేయబడిన స్పూఫ్డ్ అడ్రస్ నిర్మాణం) పాయింట్ చేస్తుందని నిర్ధారించుకున్నందున, దానిని మించి ఉన్న వేరియబుల్స్ను తిరిగి వ్రాయడానికి మేము స్వేచ్ఛగా ఉన్నాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When this script is used, the exploit is totally silent and nothing is written to the log file.","translation":"ఈ స్క్రిప్ట్ను ఉపయోగించినప్పుడు, ఎక్స్ప్లోయిట్ పూర్తిగా నిశ్శబ్దంగా ఉంటుంది మరియు లాగ్ ఫైల్కు ఏమీ వ్రాయబడదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Notice the log file’s size and access time remain the same.","translation":"లాగ్ ఫైల్ పరిమాణం మరియు యాక్సెస్ సమయం ఒకే విధంగా ఉన్నాయని గమనించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Using this technique, we can exploit tinywebd without leaving any trace in the log files.","translation":"ఈ సాంకేతికతను ఉపయోగించి, మేము లాగ్ ఫైల్లలో ఎటువంటి జాడను వదలకుండా tinywebdని ఉపయోగించుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In addition, the write calls execute cleanly, as everything is written to /dev/null.","translation":"అదనంగా, ప్రతిదీ /dev/nullకి వ్రాయబడినందున, వ్రాత కాల్లు శుభ్రంగా అమలు చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A single host usually exists within some sort of infrastructure.","translation":"ఒక హోస్ట్ సాధారణంగా ఏదో ఒక మౌలిక సదుపాయాలలో ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Countermeasures such as intrusion detection systems (IDS) and intrusion prevention systems (IPS) can detect abnormal network traffic.","translation":"ఇంట్రూజన్ డిటెక్షన్ సిస్టమ్స్ (IDS) మరియు ఇంట్రూజన్ ప్రివెన్షన్ సిస్టమ్స్ (IPS) వంటి ప్రతి చర్యలు అసాధారణ నెట్వర్క్ ట్రాఫిక్ను గుర్తించగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In our case, there’s really no need to open a new connection, since we already have an open socket from the web request.","translation":"మన విషయంలో, వెబ్ అభ్యర్థన నుండి మనకు ఇప్పటికే తెరిచిన సాకెట్ ఉన్నందున, కొత్త కనెక్షన్ను తెరవాల్సిన అవసరం లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since we’re mucking around inside the tinyweb daemon, with a little debugging we can reuse the existing socket for the root shell.","translation":"మేము tinyweb డీమన్లో తిరుగుతున్నందున, కొంచెం డీబగ్గింగ్తో మేము రూట్ షెల్ కోసం ఇప్పటికే ఉన్న సాకెట్ను తిరిగి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Unfortunately, the sockfd passed to handle_connection() will inevitably be overwritten so we can overwrite logfd.","translation":"దురదృష్టవశాత్తు, handle_connection()కి అందించబడిన sockfd అనివార్యంగా తిరిగి వ్రాయబడుతుంది, కాబట్టి మేము logfdని తిరిగి వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The state of computer security is constantly changing.","translation":"కంప్యూటర్ భద్రత పరిస్థితి నిరంతరం మారుతూ ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Understand the core hacking techniques explained in this book.","translation":"ఈ పుస్తకంలో వివరించిన ప్రధాన హ్యాకింగ్ పద్ధతులను అర్థం చేసుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These techniques can be used in millions of different combinations.","translation":"ఈ పద్ధతులను లక్షలాది విభిన్న కలయికలలో ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The more you practice these techniques, the better you’ll understand them.","translation":"మీరు ఈ పద్ధతులను ఎంత ఎక్కువగా సాధన చేస్తే, వాటిని అంత బాగా అర్థం చేసుకుంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"With this understanding comes the wisdom to guesstimate offsets.","translation":"ఈ అవగాహనతో, ఆఫ్సెట్లను అంచనా వేసే జ్ఞానం వస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In this case, the problem is still ASLR.","translation":"ఈ సందర్భంలో, సమస్య ఇప్పటికీ ASLR.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Don’t be afraid to use the debugger to examine what is actually happening.","translation":"నిజంగా ఏమి జరుగుతుందో పరిశీలించడానికి డీబగ్గర్ను ఉపయోగించడానికి భయపడవద్దు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There are probably several ways to bypass ASLR.","translation":"ASLRని దాటడానికి బహుశా అనేక మార్గాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You may invent a new technique.","translation":"మీరు ఒక కొత్త పద్ధతిని కనుగొనవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It’s worthwhile to think about this problem a little on your own.","translation":"మీ స్వంతంగా ఈ సమస్య గురించి కొంచెం ఆలోచించడం విలువైనది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"I had written this chapter before linux-gate was fixed.","translation":"linux-గేట్ పరిష్కరించబడటానికి ముందే నేను ఈ అధ్యాయాన్ని రాశాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"My first thought was to leverage the execl() family of functions.","translation":"నా మొదటి ఆలోచన ఏమిటంటే execl() ఫంక్షన్ల కుటుంబాన్ని ఉపయోగించుకోవడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The exec() family of functions replaces the current process image.","translation":"exec() ఫంక్షన్ల కుటుంబం ప్రస్తుత ప్రాసెస్ చిత్రాన్ని భర్తీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Let’s test this hypothesis with a piece of code.","translation":"కోడ్తో ఈ పరికల్పనను పరీక్షిద్దాం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This lets us compare the memory layouts.","translation":"ఇది మెమరీ లేఅవుట్లను సరిపోల్చడానికి వీలు కల్పిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The first result looks very promising.","translation":"మొదటి ఫలితం చాలా ఆశాజనకంగా ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This isn’t much of a problem though.","translation":"అయితే ఇది పెద్ద సమస్య కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"We have ways to deal with that partial uncertainty.","translation":"ఆ పాక్షిక అనిశ్చితిని ఎదుర్కోవడానికి మనకు మార్గాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since we will probably want a rather large NOP sled.","translation":"ఎందుకంటే మనకు బహుశా పెద్ద NOP స్లెడ్ కావాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This code should make sense to you.","translation":"ఈ కోడ్ మీకు అర్థం కావాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The program being debugged has been started already.","translation":"డీబగ్ చేయబడుతున్న ప్రోగ్రామ్ ఇప్పటికే ప్రారంభించబడింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Starting program: /home/reader/booksrc/update_info","translation":"ప్రోగ్రామ్ ప్రారంభమవుతోంది: /home/reader/booksrc/update_info","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Updating product # with description 'TX-3399-Purr-!TTTP\\%JONE%501:-%mm4-%mm%--DW%P-Yf1Y-fwfY- yzSzP-iii%-Zkx%-%Fw%P-XXn6-99w%-ptt%P-%w%%-qqqq-jPiXP-cccc-Dw0D-WICzP-c66c-W0TmP-TTTT-%NN0- %o42-7a-0P-xGGx-rrrx-aFOwP-pApA-N-w--B2H2PPPPPPPPPPPPPPPPPPPPPP'","translation":"వివరణతో ఉత్పత్తి # నవీకరించబడుతోంది 'TX-3399-Purr-!TTTP\\%JONE%501:-%mm4-%mm%--DW%P-Yf1Y-fwfY- yzSzP-iii%-Zkx%-%Fw%P-XXn6-99w%-ptt%P-%w%%-qqqq-jPiXP-cccc-Dw0D-WICzP-c66c-W0TmP-TTTT-%NN0- %o42-7a-0P-xGGx-rrrx-aFOwP-pApA-N-w--B2H2PPPPPPPPPPPPPPPPPPPPPP'","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Breakpoint 1, 0x080484db in update_product_description ( id=0x72727550 <Address 0x72727550 out of bounds>, desc=0x5454212d <Address 0x5454212d out of bounds>) at update_info.c:21 21 }","translation":"బ్రేక్పాయింట్ 1, update_info.c:21 వద్ద update_product_description లో 0x080484db ( id=0x72727550 <అడ్రస్ 0x72727550 పరిమితికి మించి ఉంది>, desc=0x5454212d <అడ్రస్ 0x5454212d పరిమితికి మించి ఉంది>)","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The first nine instructions add 860 to ESP and zero out the EAX register.","translation":"మొదటి తొమ్మిది సూచనలు ESPకి 860ని జోడిస్తాయి మరియు EAX రిజిస్టర్ను సున్నా చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This process is repeated in the next 32 instructions to build the entire shellcode on the stack.","translation":"స్టాక్పై మొత్తం షెల్కోడ్ను నిర్మించడానికి ఈ ప్రక్రియ తదుపరి 32 సూచనలలో పునరావృతమవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Now with the shellcode completely constructed on the stack, EAX is set to 0x90909090.","translation":"ఇప్పుడు షెల్కోడ్ స్టాక్పై పూర్తిగా నిర్మించబడినందున, EAX 0x90909090కి సెట్ చేయబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is pushed to the stack repeatedly to build a NOP sled to bridge the gap between the end of the loader code and the newly constructed shellcode.","translation":"లోడర్ కోడ్ ముగింపు మరియు కొత్తగా నిర్మించిన షెల్కోడ్కు మధ్య అంతరాన్ని పూరించడానికి ఇది పదేపదే స్టాక్కి నెట్టబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Now the execution pointer (EIP) can flow over the NOP bridge into the constructed shellcode.","translation":"ఇప్పుడు ఎగ్జిక్యూషన్ పాయింటర్ (EIP) NOP వంతెన ద్వారా నిర్మించిన షెల్కోడ్లోకి ప్రవహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Printable shellcode is a technique that can open some doors.","translation":"ముద్రించదగిన షెల్కోడ్ అనేది కొన్ని తలుపులు తెరవగల ఒక సాంకేతికత.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The exploit techniques demonstrated in this chapter have been around for ages.","translation":"ఈ అధ్యాయంలో ప్రదర్శించిన ఎక్స్ప్లాయిట్ పద్ధతులు చాలా కాలంగా ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"An exploit can be generalized as a three-step process.","translation":"ఒక ఎక్స్ప్లాయిట్ను మూడు-దశల ప్రక్రియగా సాధారణీకరించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"First, some sort of memory corruption; then, a change in control flow; and finally, execution of the shellcode.","translation":"మొదట, ఏదో ఒక రకమైన మెమరీ అవినీతి; తరువాత, నియంత్రణ ప్రవాహంలో మార్పు; మరియు చివరగా, షెల్కోడ్ అమలు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most applications never need to execute anything on the stack, so an obvious defense against buffer overflow exploits is to make the stack nonexecutable.","translation":"చాలా అప్లికేషన్లు స్టాక్పై దేనినీ అమలు చేయవలసిన అవసరం లేదు, కాబట్టి బఫర్ ఓవర్ఫ్లో ఎక్స్ప్లాయిట్లకు వ్యతిరేకంగా స్పష్టమైన రక్షణ ఏమిటంటే స్టాక్ను అమలు చేయకుండా చేయడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This technique is known as returning into libc.","translation":"ఈ పద్ధతిని లిబ్సిలోకి తిరిగి రావడం అంటారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"libc is a standard C library that contains various basic functions, such as printf() and exit().","translation":"లిబ్సి అనేది ప్రామాణిక సి లైబ్రరీ, ఇది printf() మరియు exit() వంటి వివిధ ప్రాథమిక ఫంక్షన్లను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One of the simplest libc functions to return into is system().","translation":"తిరిగి రావడానికి సులభమైన లిబ్సి ఫంక్షన్లలో ఒకటి system().","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"As you recall, this function takes a single argument and executes that argument with /bin/sh.","translation":"మీకు గుర్తుంటే, ఈ ఫంక్షన్ ఒకే వాదనను తీసుకుంటుంది మరియు ఆ వాదనను /bin/shతో అమలు చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The general idea is to force the vulnerable program to spawn a shell, without executing anything on the stack, by returning into the libc function system().","translation":"సాధారణ ఆలోచన ఏమిటంటే, లిబ్సి ఫంక్షన్ సిస్టమ్లోకి తిరిగి రావడం ద్వారా, స్టాక్పై దేనినీ అమలు చేయకుండా, బలహీనమైన ప్రోగ్రామ్ను షెల్ను ప్రారంభించేలా చేయడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When returning into libc, the return address and function arguments are read off the stack in what should be a familiar format: the return address followed by the arguments.","translation":"లిబ్సిలోకి తిరిగి వచ్చినప్పుడు, రిటర్న్ అడ్రస్ మరియు ఫంక్షన్ వాదనలు స్టాక్ నుండి ఒక సాధారణ ఆకృతిలో చదవబడతాయి: వాదనల తర్వాత రిటర్న్ అడ్రస్.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"DES uses 16 rounds of operation.","translation":"DES 16 రౌండ్ల ఆపరేషన్లను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This number was specifically chosen to defend against differential cryptanalysis.","translation":"ఈ సంఖ్యను నిర్దిష్టంగా డిఫరెన్షియల్ క్రిప్టోనాలసిస్ నుండి రక్షించడానికి ఎంచుకున్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since the key is only 56 bits, the entire keyspace can be checked in an exhaustive brute-force attack in a few weeks on specialized hardware.","translation":"కీ 56 బిట్స్ మాత్రమే కాబట్టి, ప్రత్యేక హార్డ్వేర్పై కొన్ని వారాల్లోనే సమగ్రమైన బ్రూట్-ఫోర్స్ దాడిలో మొత్తం కీస్పేస్ను తనిఖీ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Triple-DES fixes this problem by using two DES keys concatenated together for a total key size of 112 bits.","translation":"రెండు DES కీలను కలిపి ఉపయోగించడం ద్వారా ట్రిపుల్-DES ఈ సమస్యను పరిష్కరిస్తుంది, మొత్తం కీ పరిమాణం 112 బిట్స్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Encryption is done by encrypting the plaintext block with the first key, then decrypting with the second key, and then encrypting again with the first key.","translation":"మొదటి కీతో ప్లెయిన్టెక్స్ట్ బ్లాక్ను ఎన్క్రిప్ట్ చేయడం ద్వారా, రెండవ కీతో డీక్రిప్ట్ చేయడం ద్వారా మరియు మొదటి కీతో మళ్లీ ఎన్క్రిప్ట్ చేయడం ద్వారా ఎన్క్రిప్షన్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Most industry-standard block ciphers are resistant to all known forms of cryptanalysis.","translation":"పరిశ్రమ-ప్రామాణిక బ్లాక్ సైఫర్లు చాలా వరకు క్రిప్టోనాలసిస్ యొక్క అన్ని తెలిసిన రూపాలకు నిరోధకతను కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"However, quantum computation provides some interesting possibilities, which are generally overhyped.","translation":"అయితే, క్వాంటం గణన కొన్ని ఆసక్తికరమైన అవకాశాలను అందిస్తుంది, ఇవి సాధారణంగా అతిగా ప్రచారం చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A quantum computer can store many different states in a superposition and perform calculations on all of them at once.","translation":"క్వాంటం కంప్యూటర్ సూపర్позиషన్ లో అనేక విభిన్న స్థితులను నిల్వ చేయగలదు మరియు వాటిపై ఒకేసారి గణనలను చేయగలదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This is ideal for brute forcing anything, including block ciphers.","translation":"బ్లాక్ సైఫర్లతో సహా ఏదైనా బ్రూట్ ఫోర్స్ చేయడానికి ఇది అనువైనది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Quantum computers are weird in that when the superposition is looked at, the whole thing decoheres into a single state.","translation":"క్వాంటం కంప్యూటర్లు విచిత్రంగా ఉంటాయి, ఎందుకంటే సూపర్позиషన్ చూసినప్పుడు, మొత్తం ఒకే స్థితిలోకి డీకోహెర్ అవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This algorithm allows the odds of a certain desired state to increase while the others decrease.","translation":"ఈ అల్గారిథం నిర్దిష్ట కోరుకున్న స్థితి యొక్క అవకాశాలను పెంచుతుంది, అయితే ఇతరులు తగ్గుతారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Asymmetric ciphers use two keys: a public key and a private key.","translation":"అసమాన సైఫర్లు రెండు కీలను ఉపయోగిస్తాయి: పబ్లిక్ కీ మరియు ప్రైవేట్ కీ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Any message that is encrypted with the public key can only be decrypted with the private key.","translation":"పబ్లిక్ కీతో ఎన్క్రిప్ట్ చేయబడిన ఏదైనా సందేశాన్ని ప్రైవేట్ కీతో మాత్రమే డీక్రిప్ట్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Unlike symmetric ciphers, there’s no need for an out-of-band communication channel to transmit the secret key.","translation":"సమరూప సైఫర్ల వలె కాకుండా, రహస్య కీని ప్రసారం చేయడానికి అవుట్-ఆఫ్-బ్యాండ్ కమ్యూనికేషన్ ఛానెల్ అవసరం లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"However, asymmetric ciphers tend to be quite a bit slower than symmetric ciphers.","translation":"అయితే, అసమాన సైఫర్లు సమరూప సైఫర్ల కంటే కొంచెం నెమ్మదిగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"RSA is one of the more popular asymmetric algorithms.","translation":"RSA మరింత ప్రజాదరణ పొందిన అసమాన అల్గారిథమ్లలో ఒకటి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The security of RSA is based on the difficulty of factoring large numbers.","translation":"RSA యొక్క భద్రత పెద్ద సంఖ్యలను కారకం చేయడంలో కష్టంపై ఆధారపడి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"First, two prime numbers are chosen, P and Q, and their product, N, is computed.","translation":"ముందుగా, రెండు ప్రధాన సంఖ్యలు ఎంచుకోబడతాయి, P మరియు Q, మరియు వాటి ఉత్పత్తి, N, లెక్కించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is known as Euler’s totient function, and it is usually denoted by the lowercase Greek letter phi (φ).","translation":"దీనిని యూలర్ యొక్క టోషియంట్ ఫంక్షన్ అని పిలుస్తారు మరియు సాధారణంగా చిన్న అక్షరం గ్రీకు అక్షరం phi (φ) ద్వారా సూచిస్తారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"An encryption key, E, that is relatively prime to φ(N), must be chosen at random.","translation":"φ(N)కి సంబంధిత ప్రధానమైన ఎన్క్రిప్షన్ కీ, E,ని యాదృచ్ఛికంగా ఎంచుకోవాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"An uninformed user might just click right through the warning.","translation":"సమాచారం లేని వినియోగదారుడు హెచ్చరికను పట్టించుకోకుండా నేరుగా క్లిక్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Usually, the first time an SSH connection is made to a new host, that host’s fingerprint is added to a known_hosts file.","translation":"సాధారణంగా, SSH కనెక్షన్ కొత్త హోస్ట్కి మొదటిసారి చేసినప్పుడు, ఆ హోస్ట్ యొక్క వేలిముద్ర తెలిసిన_హోస్ట్ల ఫైల్కు జోడించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Are you sure you want to continue connecting (yes/no)?","translation":"మీరు కనెక్ట్ అవ్వాలనుకుంటున్నారా (అవును/కాదు)?","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Warning: Permanently added '192.168.42.72' (RSA) to the list of known hosts.","translation":"'192.168.42.72' (RSA)ని తెలిసిన హోస్ట్ల జాబితాకు శాశ్వతంగా జోడించారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"However, there are two different protocols of SSH—SSH1 and SSH2— each with separate host fingerprints.","translation":"అయితే, SSHలో రెండు వేర్వేరు ప్రోటోకాల్లు ఉన్నాయి—SSH1 మరియు SSH2—ప్రతి ఒక్కటి ప్రత్యేక హోస్ట్ వేలిముద్రలతో ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The banner presented by the SSH server describes which SSH protocols it understands.","translation":"SSH సర్వర్ ద్వారా అందించబడిన బ్యానర్ అది ఏ SSH ప్రోటోకాల్లను అర్థం చేసుకుంటుందో వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is to retain backward compatibility, so SSH1-only clients can still connect.","translation":"ఇది వెనుకకు అనుకూలతను నిలుపుకోవడానికి, కాబట్టి SSH1-మాత్రమే క్లయింట్లు ఇప్పటికీ కనెక్ట్ అవ్వగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In contrast, the banner from 192.168.42.1 includes the string SSH-2.0, which shows that the server only speaks protocol 2.","translation":"దీనికి విరుద్ధంగా, 192.168.42.1 నుండి వచ్చిన బ్యానర్లో SSH-2.0 స్ట్రింగ్ ఉంది, ఇది సర్వర్ ప్రోటోకాల్ 2 మాత్రమే మాట్లాడుతుందని చూపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If the modified SSH daemon being used for the MitM attack forces the client to communicate using the other protocol, no host fingerprint will be found.","translation":"MitM దాడి కోసం ఉపయోగించే సవరించిన SSH డీమన్ క్లయింట్ను ఇతర ప్రోటోకాల్ని ఉపయోగించి కమ్యూనికేట్ చేయమని బలవంతం చేస్తే, హోస్ట్ వేలిముద్ర ఏదీ కనుగొనబడదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Instead of being presented with a lengthy warning, the user will simply be asked to add the new fingerprint.","translation":"ఒక సుదీర్ఘ హెచ్చరికను అందించడానికి బదులుగా, వినియోగదారుని కొత్త వేలిముద్రను జోడించమని అడుగుతారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By adding the line Protocol 1 to /usr/local/etc/mitm-ssh_config, the mitm-ssh daemon will claim it only speaks the SSH1 protocol.","translation":"/usr/local/etc/mitm-ssh_configకి ప్రోటోకాల్ 1 లైన్ను జోడించడం ద్వారా, mitm-ssh డీమన్ ఇది SSH1 ప్రోటోకాల్ని మాత్రమే మాట్లాడుతుందని పేర్కొంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Usually, clients such as tetsuo connecting to loki at 192.168.42.72 would have only communicated using SSH2.","translation":"సాధారణంగా, 192.168.42.72 వద్ద లోకికి కనెక్ట్ అయ్యే టెట్సుయో వంటి క్లయింట్లు SSH2ని ఉపయోగించి మాత్రమే కమ్యూనికేట్ చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Therefore, there would only be a host fingerprint for SSH protocol 2 stored on the client.","translation":"అందువల్ల, క్లయింట్లో నిల్వ చేయబడిన SSH ప్రోటోకాల్ 2 కోసం హోస్ట్ వేలిముద్ర మాత్రమే ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since this vulnerability was made public, newer implementations of OpenSSH have a slightly more verbose warning.","translation":"ఈ దుర్బలత్వం బహిరంగంగా చేసినందున, OpenSSH యొక్క కొత్త అమలులు కొంచెం ఎక్కువ వివరణాత్మక హెచ్చరికను కలిగి ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The goal behind the fuzzy fingerprint technique is to generate a host key with a fingerprint that looks similar enough to the original fingerprint to fool the human eye.","translation":"అస్పష్టమైన వేలిముద్ర సాంకేతికత వెనుక ఉన్న లక్ష్యం ఏమిటంటే, మానవ దృష్టిని మోసం చేయడానికి అసలు వేలిముద్రకు సమానంగా కనిపించే వేలిముద్రతో హోస్ట్ కీని రూపొందించడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Passwords aren’t generally stored in plaintext form.","translation":"సాధారణంగా పాస్వర్డ్లు సాదా వచన రూపంలో నిల్వ చేయబడవు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A file containing all the passwords in plaintext form would be far too attractive a target.","translation":"సాదా వచన రూపంలో అన్ని పాస్వర్డ్లను కలిగి ఉన్న ఫైల్ చాలా ఆకర్షణీయమైన లక్ష్యంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is a one-way hash function that expects a plaintext password and a salt value for input, and then outputs a hash with the salt value prepended to it.","translation":"ఇది ఒక-మార్గం హాష్ ఫంక్షన్, ఇది ఇన్పుట్గా సాదా వచన పాస్వర్డ్ మరియు ఉప్పు విలువను ఆశిస్తుంది, ఆపై ఉప్పు విలువను ముందుగా ఉంచిన హాష్ను ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It turns out, however, that the encrypted passwords in the password file aren’t so useless after all.","translation":"అయితే, పాస్వర్డ్ ఫైల్లోని గుప్తీకరించబడిన పాస్వర్డ్లు అన్నింటికీ అంతగా పనికిరావు అని తేలింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A simple dictionary attack program can be whipped up fairly easily.","translation":"ఒక సాధారణ నిఘంటువు దాడి ప్రోగ్రామ్ను చాలా సులభంగా తయారు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The account jose is shown to have the password of testing7.","translation":"జోస్ ఖాతాకు testing7 అనే పాస్వర్డ్ ఉందని చూపబడింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If all the hashes for all possible passwords were precomputed and stored in a searchable data structure somewhere, any password could be cracked in the time it takes to search.","translation":"అన్ని పాస్వర్డ్ల కోసం అన్ని హాష్లు ముందుగా లెక్కించబడి, ఎక్కడైనా శోధించదగిన డేటా స్ట్రక్చర్లో నిల్వ చేయబడితే, శోధించడానికి పట్టే సమయంలో ఏదైనా పాస్వర్డ్ను క్రాక్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Since multiple plaintext passwords will hash to different password hashes with different salts, a separate lookup table would have to be created for each salt.","translation":"ఒకే రకమైన పాస్వర్డ్లు వేర్వేరు ఉప్పులతో వేర్వేరు పాస్వర్డ్ హాష్లకు హాష్ చేస్తాయి కాబట్టి, ప్రతి ఉప్పు కోసం ప్రత్యేక శోధన పట్టికను రూపొందించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This raises the needed storage space up to about 4.6 terabytes, which greatly dissuades such an attack.","translation":"ఇది అవసరమైన నిల్వ స్థలాన్ని సుమారు 4.6 టెరాబైట్లకు పెంచుతుంది, ఇది అలాంటి దాడిని బాగా నిరుత్సాహపరుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"MP3 files use compression to store a high-quality sound file in a relatively small amount of space, but the demand for compu- tational resources increases.","translation":"MP3 ఫైల్లు అధిక-నాణ్యత గల సౌండ్ ఫైల్ను తక్కువ స్థలంలో నిల్వ చేయడానికి కంప్రెషన్ను ఉపయోగిస్తాయి, అయితే గణన వనరుల డిమాండ్ పెరుగుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This trade-off can also be applied to cryptography in what has become known as a time/space trade-off attack.","translation":"సమయం/స్థలం ట్రేడ్-ఆఫ్ దాడిగా పిలువబడే క్రిప్టోగ్రఫీకి కూడా ఈ ట్రేడ్-ఆఫ్ను వర్తింపజేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Try to find the sweet spot between computational power and storage space, so that an exhaustive brute-force attack can be completed in a reasonable amount of time, using a reasonable amount of space.","translation":"గణన శక్తి మరియు నిల్వ స్థలం మధ్య సరైన స్థలాన్ని కనుగొనడానికి ప్రయత్నించండి, తద్వారా సమంజసమైన సమయంలో, సహేతుకమైన స్థలాన్ని ఉపయోగించి పూర్తిస్థాయి బ్రూట్-ఫోర్స్ దాడిని పూర్తి చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This method uses a form of lossy compression.","translation":"ఈ పద్ధతి నష్టపూరిత కంప్రెషన్ రూపంను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In the demonstration code that follows, the keyspace for all possible four-character passwords (with a fixed salt) is used.","translation":"కింది డెమో కోడ్లో, అన్ని నాలుగు-అక్షరాల పాస్వర్డ్ల కోసం కీస్పేస్ (ఒక స్థిర ఉప్పుతో) ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This method builds a three-dimensional binary matrix that correlates parts of the hash values with parts of the plaintext values.","translation":"ఈ పద్ధతి హాష్ విలువల్లోని భాగాలను ప్లెయిన్టెక్స్ట్ విలువల్లోని భాగాలతో పరస్పరం సంబంధం కలిగి ఉండే త్రిమితీయ బైనరీ మాతృకను నిర్మిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The basic idea is to split the plaintext into two paired values that are enumerated along a vector.","translation":"ప్రాథమిక ఆలోచన ఏమిటంటే, ప్లెయిన్టెక్స్ట్ ను ఒక వెక్టర్ వెంట లెక్కించబడే రెండు జత విలువలుగా విభజించడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the ciphertext values are reduced into smaller chunks, collisions are inevitable.","translation":"సైఫర్టెక్స్ట్ విలువలు చిన్న ముక్కలుగా తగ్గించబడినప్పుడు, ఢీకొనడం అనివార్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In this case, the column for HEA would have the bits corresponding to the plaintext pairs te, !J, \".\", and \"8 turned on, as these plaintext/hash pairs are added to the matrix.","translation":"ఈ సందర్భంలో, HEA కోసం ఉన్న కాలమ్లో te, !J, \".\", మరియు \"8 ప్లెయిన్టెక్స్ట్ జతలకు సంబంధించిన బిట్లు ఆన్లో ఉంటాయి, ఎందుకంటే ఈ ప్లెయిన్టెక్స్ట్/హాష్ జతలు మాతృకకు జోడించబడతాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"There are four matrices like this for the first two characters, using ciphertext substring from characters 2 through 4, 4 through 6, 6 though 8, and 8 though 10, each with a different vector of possible first two-character plaintext values.","translation":"మొదటి రెండు అక్షరాల కోసం ఇలాంటి నాలుగు మాతృకలు ఉన్నాయి, 2 నుండి 4 వరకు, 4 నుండి 6 వరకు, 6 నుండి 8 వరకు మరియు 8 నుండి 10 వరకు ఉన్న అక్షరాల నుండి సైఫర్టెక్స్ట్ ఉపస్ట్రింగ్ను ఉపయోగించి, ప్రతి ఒక్కటి సాధ్యమయ్యే మొదటి రెండు-అక్షరాల ప్లెయిన్టెక్స్ట్ విలువల యొక్క విభిన్న వెక్టర్తో ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Since there are four vectors that are pulled for a single ciphertext, the probability of any one enumeration position having a 1 value in each vector is about 0.42 4 , or about 3.11 percent.","translation":"ఒకే సైఫర్టెక్స్ట్ కోసం నాలుగు వెక్టర్లను లాగినందున, ప్రతి వెక్టర్లో ఏదైనా ఒక గణన స్థానం 1 విలువను కలిగి ఉండే సంభావ్యత సుమారు 0.42 4, లేదా సుమారు 3.11 శాతం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Of course, there are downsides.","translation":"ఖచ్చితంగా, ప్రతికూలతలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"First, it takes at least as long to create the matrix as the original brute-force attack would have taken; however, this is a one-time cost.","translation":"ముందుగా, మాతృకను రూపొందించడానికి అసలు బ్రూట్-ఫోర్స్ దాడికి ఎంత సమయం పడుతుందో అంతే సమయం పడుతుంది; అయితే, ఇది ఒక-సమయం వ్యయం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Also, the salts still tend to prohibit any type of storage attack, even with the reduced storage-space requirements.","translation":"అలాగే, తగ్గించిన నిల్వ-స్థలం అవసరాలతో కూడా, ఉప్పులు ఇప్పటికీ ఏదైనా నిల్వ దాడిని నిషేధించే ధోరణిని కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These programs are proof-of-concept hacks, which take advantage of the bit diffusion provided by hash functions.","translation":"ఈ ప్రోగ్రామ్లు ప్రూఫ్-ఆఫ్-కాన్సెప్ట్ హక్స్, ఇవి హాష్ ఫంక్షన్ల ద్వారా అందించబడిన బిట్ డిఫ్యూజన్ను ఉపయోగించుకుంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Wireless 802.11b security has been a big issue, primarily due to the absence of it.","translation":"వైర్లెస్ 802.11b భద్రత ఒక పెద్ద సమస్యగా ఉంది, ప్రధానంగా దాని లేకపోవడం వల్ల.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If the wireless network isn’t VLANed off or firewalled, an attacker associated to the wireless access point could redirect all the wired network traffic out over the wireless via ARP redirection.","translation":"వైర్లెస్ నెట్వర్క్ను VLAN ద్వారా వేరు చేయకపోతే లేదా ఫైర్వాల్ చేయకపోతే, వైర్లెస్ యాక్సెస్ పాయింట్కు అనుసంధానించబడిన ఒక దాడి చేసే వ్యక్తి ARP దారిమార్పు ద్వారా వైర్లెస్ ద్వారా వైర్డు నెట్వర్క్ ట్రాఫిక్ను మళ్లించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This, coupled with the tendency to hook wireless access points to internal private networks, can lead to some serious vulnerabilities.","translation":"దీనితో పాటు, వైర్లెస్ యాక్సెస్ పాయింట్లను అంతర్గత ప్రైవేట్ నెట్వర్క్లకు కనెక్ట్ చేసే ధోరణి కొన్ని తీవ్రమైన బలహీనతలకు దారి తీస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If WEP is turned on, only clients with the proper WEP key will be allowed to associate to the access point.","translation":"WEP ఆన్ చేయబడితే, సరైన WEP కీ ఉన్న క్లయింట్లను మాత్రమే యాక్సెస్ పాయింట్కు అనుసంధానం చేయడానికి అనుమతిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This begs the question, “How secure is WEP?”","translation":"ఇది ఒక ప్రశ్నను లేవనెత్తుతుంది, “WEP ఎంత సురక్షితం?”","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"WEP was meant to be an encryption method providing security equivalent to a wired access point.","translation":"WEP అనేది వైర్డు యాక్సెస్ పాయింట్కు సమానమైన భద్రతను అందించే ఒక ఎన్క్రిప్షన్ పద్ధతిగా ఉద్దేశించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It was originally designed with 40-bit keys; later, WEP2 came along to increase the key size to 104 bits.","translation":"ఇది మొదట 40-బిట్ కీలతో రూపొందించబడింది; తరువాత, WEP2 కీ పరిమాణాన్ని 104 బిట్లకు పెంచడానికి వచ్చింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"All of the encryption is done on a per-packet basis, so each packet is essentially a separate plaintext message to send.","translation":"అన్ని ఎన్క్రిప్షన్ ఒక్కో ప్యాకెట్ ఆధారంగా చేయబడుతుంది, కాబట్టి ప్రతి ప్యాకెట్ పంపడానికి ఒక ప్రత్యేకమైన సాదా వచన సందేశం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"First, a checksum of message M is computed, so the message integrity can be checked later.","translation":"ముందుగా, సందేశం M యొక్క చెక్సమ్ లెక్కించబడుతుంది, తద్వారా సందేశ సమగ్రతను తరువాత తనిఖీ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is done using a 32-bit cyclic redundancy check- sum function aptly named CRC32.","translation":"ఇది CRC32 అని పిలువబడే 32-బిట్ చక్ర పునరావృత తనిఖీ- మొత్తం ఫంక్షన్ను ఉపయోగించి చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This checksum will be called CS, so CS = CRC32(M).","translation":"ఈ చెక్సమ్ను CS అని పిలుస్తారు, కాబట్టి CS = CRC32(M).","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Now, the plaintext message needs to be encrypted.","translation":"ఇప్పుడు, సాదా వచన సందేశాన్ని ఎన్క్రిప్ట్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This is done using RC4, which is a stream cipher.","translation":"ఇది RC4 ని ఉపయోగించి చేయబడుతుంది, ఇది ఒక స్ట్రీమ్ సైఫర్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"WEP uses an initialization vector (IV) for the seed value.","translation":"WEP సీడ్ విలువ కోసం ప్రారంభీకరణ వెక్టర్ (IV) ని ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The IV consists of 24 bits generated for each packet.","translation":"IV ప్రతి ప్యాకెట్ కోసం ఉత్పత్తి చేయబడిన 24 బిట్లను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Some older WEP implementations simply use sequential values for the IV, while others use some form of pseudo-randomizer.","translation":"కొన్ని పాత WEP అమలులు IV కోసం కేవలం సీక్వెన్షియల్ విలువలను ఉపయోగిస్తాయి, మరికొన్ని నకిలీ-రాండమైజర్ యొక్క రూపాన్ని ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Regardless of how the 24 bits of IV are chosen, they are prepended to the WEP key.","translation":"IV యొక్క 24 బిట్లను ఎలా ఎంచుకున్నా, వాటిని WEP కీకి ముందు ఉంచుతారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The IV and the WEP key together make up the seed value, which will be called S.","translation":"IV మరియు WEP కీ కలిపి సీడ్ విలువను ఏర్పరుస్తాయి, దీనిని S అని పిలుస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Then the seed value S is fed into RC4, which will generate a keystream.","translation":"అప్పుడు సీడ్ విలువ S RC4 లోకి అందించబడుతుంది, ఇది కీస్ట్రీమ్ను ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This keystream is XORed with the plaintext message P to produce the ciphertext C.","translation":"ఈ కీస్ట్రీమ్ సాదా వచన సందేశం P తో XOR చేయబడి సైఫర్టెక్స్ట్ C ని ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When the recipient receives a WEP-encrypted packet, the process is simply reversed.","translation":"గ్రహీత WEP-ఎన్క్రిప్టెడ్ ప్యాకెట్ను స్వీకరించినప్పుడు, ప్రక్రియ కేవలం రివర్స్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program's vulnerability allowed attackers to execute arbitrary code.","translation":"ప్రోగ్రామ్ యొక్క బలహీనత వలన దుండగులు ఇష్టానుసారంగా కోడ్ను అమలు చేయడానికి వీలు కలిగింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Buffer overflows are a common security flaw in software.","translation":"బఫర్ ఓవర్ఫ్లోలు సాఫ్ట్వేర్లో సాధారణ భద్రతా లోపాలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Understanding memory segments is crucial for exploiting vulnerabilities.","translation":"బలహీనతలను ఉపయోగించుకోవడానికి మెమరీ విభాగాలను అర్థం చేసుకోవడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The attacker used a format string vulnerability to gain control.","translation":"నియంత్రణ సాధించడానికి దాడి చేసే వ్యక్తి ఫార్మాట్ స్ట్రింగ్ బలహీనతను ఉపయోగించాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exploiting a stack-based buffer overflow can lead to system compromise.","translation":"స్టాక్-ఆధారిత బఫర్ ఓవర్ఫ్లోను ఉపయోగించుకోవడం వలన సిస్టమ్ రాజీ పడవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The code was written in C, a powerful programming language.","translation":"ఈ కోడ్ సి భాషలో రాయబడింది, ఇది ఒక శక్తివంతమైన ప్రోగ్రామింగ్ భాష.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Careful input validation is essential to prevent security breaches.","translation":"భద్రతా ఉల్లంఘనలను నిరోధించడానికి జాగ్రత్తగా ఇన్పుట్ ధృవీకరణ అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program crashed due to an out-of-bounds memory access.","translation":"అధికార పరిధికి వెలుపల మెమరీని యాక్సెస్ చేయడం వలన ప్రోగ్రామ్ క్రాష్ అయింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The attacker crafted a malicious payload to exploit the vulnerability.","translation":"బలహీనతను ఉపయోగించుకోవడానికి దాడి చేసే వ్యక్తి ఒక హానికరమైన పేలోడ్ను రూపొందించాడు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Understanding the basics of assembly language is helpful for reverse engineering.","translation":"రివర్స్ ఇంజనీరింగ్ కోసం అసెంబ్లీ భాష యొక్క ప్రాథమికాలను అర్థం చేసుకోవడం సహాయపడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The software used a weak encryption algorithm, making it vulnerable.","translation":"సాఫ్ట్వేర్ బలహీనమైన ఎన్క్రిప్షన్ అల్గారిథమ్ను ఉపయోగించింది, ఇది ప్రమాదానికి గురయ్యేలా చేసింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The system administrator implemented security hardening measures.","translation":"సిస్టమ్ నిర్వాహకుడు భద్రతా చర్యలను అమలు చేశాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The firewall blocked the malicious network traffic.","translation":"ఫైర్వాల్ హానికరమైన నెట్వర్క్ ట్రాఫిక్ను నిరోధించింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The attacker attempted a denial-of-service attack.","translation":"దాడి చేసే వ్యక్తి సర్వీస్ నిరాకరణ దాడికి ప్రయత్నించాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program's source code was analyzed for vulnerabilities.","translation":"బలహీనతల కోసం ప్రోగ్రామ్ యొక్క సోర్స్ కోడ్ను విశ్లేషించారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The exploit used a format string vulnerability to overwrite a function pointer.","translation":"ఒక ఫంక్షన్ పాయింటర్ను తిరిగి వ్రాయడానికి ఎక్స్ప్లోయిట్ ఫార్మాట్ స్ట్రింగ్ బలహీనతను ఉపయోగించింది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The system logs provided valuable information about the attack.","translation":"దాడి గురించి సిస్టమ్ లాగ్లు విలువైన సమాచారాన్ని అందించాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The attacker used a buffer overflow to inject shellcode.","translation":"షెల్కోడ్ను ఇంజెక్ట్ చేయడానికి దాడి చేసే వ్యక్తి బఫర్ ఓవర్ఫ్లోను ఉపయోగించాడు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The security researcher discovered a zero-day vulnerability.","translation":"భద్రతా పరిశోధకుడు జీరో-డే బలహీనతను కనుగొన్నాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program was compiled with security features enabled to mitigate attacks.","translation":"దాడులను తగ్గించడానికి భద్రతా లక్షణాలతో ప్రోగ్రామ్ కంపైల్ చేయబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Using IV: (3, 255, 0), first keystream byte is 7","translation":"IV ని ఉపయోగిస్తున్నారు: (3, 255, 0), మొదటి కీస్ట్రీమ్ బైట్ 7.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 3 steps of KSA.. at KSA iteration #3, j=5 and S[3]=1 key[0] prediction = 7 - 5 - 1 = 1","translation":"KSA యొక్క మొదటి 3 దశలు చేస్తున్నారు.. KSA పునరావృతం #3 వద్ద, j=5 మరియు S[3]=1 కీ[0] అంచనా = 7 - 5 - 1 = 1","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using IV: (3, 255, 1), first keystream byte is 211","translation":"IV ని ఉపయోగిస్తున్నారు: (3, 255, 1), మొదటి కీస్ట్రీమ్ బైట్ 211.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 3 steps of KSA.. at KSA iteration #3, j=6 and S[3]=1 key[0] prediction = 211 - 6 - 1 = 204","translation":"KSA యొక్క మొదటి 3 దశలు చేస్తున్నారు.. KSA పునరావృతం #3 వద్ద, j=6 మరియు S[3]=1 కీ[0] అంచనా = 211 - 6 - 1 = 204","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using IV: (3, 255, 2), first keystream byte is 241","translation":"IV ని ఉపయోగిస్తున్నారు: (3, 255, 2), మొదటి కీస్ట్రీమ్ బైట్ 241.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 3 steps of KSA.. at KSA iteration #3, j=7 and S[3]=1 key[0] prediction = 241 - 7 - 1 = 233","translation":"KSA యొక్క మొదటి 3 దశలు చేస్తున్నారు.. KSA పునరావృతం #3 వద్ద, j=7 మరియు S[3]=1 కీ[0] అంచనా = 241 - 7 - 1 = 233","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using IV: (3, 255, 252), first keystream byte is 175","translation":"IV ని ఉపయోగిస్తున్నారు: (3, 255, 252), మొదటి కీస్ట్రీమ్ బైట్ 175.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 3 steps of KSA.. S[0] or S[1] have been disturbed, discarding..","translation":"KSA యొక్క మొదటి 3 దశలు చేస్తున్నారు.. S[0] లేదా S[1] లో మార్పులు జరిగాయి, తీసివేస్తున్నారు..","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using IV: (3, 255, 253), first keystream byte is 149","translation":"IV ని ఉపయోగిస్తున్నారు: (3, 255, 253), మొదటి కీస్ట్రీమ్ బైట్ 149.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 3 steps of KSA.. at KSA iteration #3, j=2 and S[3]=1 key[0] prediction = 149 - 2 - 1 = 146","translation":"KSA యొక్క మొదటి 3 దశలు చేస్తున్నారు.. KSA పునరావృతం #3 వద్ద, j=2 మరియు S[3]=1 కీ[0] అంచనా = 149 - 2 - 1 = 146","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using IV: (3, 255, 254), first keystream byte is 253","translation":"IV ని ఉపయోగిస్తున్నారు: (3, 255, 254), మొదటి కీస్ట్రీమ్ బైట్ 253.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 3 steps of KSA.. at KSA iteration #3, j=3 and S[3]=2 key[0] prediction = 253 - 3 - 2 = 248","translation":"KSA యొక్క మొదటి 3 దశలు చేస్తున్నారు.. KSA పునరావృతం #3 వద్ద, j=3 మరియు S[3]=2 కీ[0] అంచనా = 253 - 3 - 2 = 248","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using IV: (3, 255, 255), first keystream byte is 72","translation":"IV ని ఉపయోగిస్తున్నారు: (3, 255, 255), మొదటి కీస్ట్రీమ్ బైట్ 72.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 3 steps of KSA.. at KSA iteration #3, j=4 and S[3]=1 key[0] prediction = 72 - 4 - 1 = 67","translation":"KSA యొక్క మొదటి 3 దశలు చేస్తున్నారు.. KSA పునరావృతం #3 వద్ద, j=4 మరియు S[3]=1 కీ[0] అంచనా = 72 - 4 - 1 = 67","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Frequency table for key[0] (* = most frequent)","translation":"కీ[0] కోసం ఫ్రీక్వెన్సీ పట్టిక (* = అత్యంత తరచుగా)","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"key[0] is probably 1","translation":"కీ[0] బహుశా 1.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Using IV: (15, 255, 0), first keystream byte is 81","translation":"IV ని ఉపయోగిస్తున్నారు: (15, 255, 0), మొదటి కీస్ట్రీమ్ బైట్ 81.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 15 steps of KSA.. at KSA iteration #15, j=251 and S[15]=1 key[12] prediction = 81 - 251 - 1 = 85","translation":"KSA యొక్క మొదటి 15 దశలు చేస్తున్నారు.. KSA పునరావృతం #15 వద్ద, j=251 మరియు S[15]=1 కీ[12] అంచనా = 81 - 251 - 1 = 85","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using IV: (15, 255, 1), first keystream byte is 80","translation":"IV ని ఉపయోగిస్తున్నారు: (15, 255, 1), మొదటి కీస్ట్రీమ్ బైట్ 80.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Doing the first 15 steps of KSA.. at KSA iteration #15, j=252 and S[15]=1 key[12] prediction = 80 - 252 - 1 = 83","translation":"KSA యొక్క మొదటి 15 దశలు చేస్తున్నారు.. KSA పునరావృతం #15 వద్ద, j=252 మరియు S[15]=1 కీ[12] అంచనా = 80 - 252 - 1 = 83","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The book explains how to corrupt system memory.","translation":"పుస్తకం సిస్టమ్ మెమరీని ఎలా కరప్ట్ చేయాలో వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Assembly language is used for low-level programming.","translation":"అసెంబ్లీ భాషను తక్కువ-స్థాయి ప్రోగ్రామింగ్ కోసం ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The LiveCD provides a complete Linux programming environment.","translation":"లైవ్సిడి పూర్తి లైనక్స్ ప్రోగ్రామింగ్ వాతావరణాన్ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Buffer overflows can be used to run arbitrary code.","translation":"బఫర్ ఓవర్ఫ్లోలను ఇష్టానుసార కోడ్ను అమలు చేయడానికి ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Inspect processor registers with a debugger.","translation":"డీబగ్గర్తో ప్రాసెసర్ రిజిస్టర్లను తనిఖీ చేయండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Hacking involves finding unconventional solutions.","translation":"హ్యాకింగ్లో అసాధారణ పరిష్కారాలను కనుగొనడం ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book teaches the fundamentals of C programming.","translation":"పుస్తకం సి ప్రోగ్రామింగ్ యొక్క ప్రాథమిక అంశాలను బోధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Network communications can be hijacked.","translation":"నెట్వర్క్ కమ్యూనికేషన్లను హైజాక్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book covers machine architecture.","translation":"పుస్తకం మెషిన్ ఆర్కిటెక్చర్ను కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Exploiting cryptographic weaknesses is discussed.","translation":"క్రిప్టోగ్రాఫిక్ బలహీనతలను ఉపయోగించుకోవడం గురించి చర్చించబడింది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The LiveCD can be used without modifying your current operating system.","translation":"మీ ప్రస్తుత ఆపరేటింగ్ సిస్టమ్ను మార్చకుండానే లైవ్సిడిని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The author has a formal education in computer science.","translation":"రచయిత కంప్యూటర్ సైన్స్లో అధికారిక విద్యను కలిగి ఉన్నారు.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Hackers are always pushing the boundaries.","translation":"హ్యాకర్లు ఎల్లప్పుడూ సరిహద్దులను నెట్టివేస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book provides a complete picture of programming.","translation":"పుస్తకం ప్రోగ్రామింగ్ యొక్క పూర్తి చిత్రాన్ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book is an international best-seller.","translation":"పుస్తకం అంతర్జాతీయంగా బాగా అమ్ముడవుతోంది.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"The book discusses network security.","translation":"పుస్తకం నెట్వర్క్ భద్రత గురించి చర్చిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book teaches how to bypass protections.","translation":"రక్షణలను ఎలా దాటవేయాలో పుస్తకం బోధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains how to crack encrypted wireless traffic.","translation":"గుప్తీకరించబడిన వైర్లెస్ ట్రాఫిక్ను ఎలా క్రాక్ చేయాలో పుస్తకం వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The book covers the art of exploitation.","translation":"పుస్తకం దోపిడీ కళను కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book is about the art of creative problem solving.","translation":"పుస్తకం సృజనాత్మక సమస్య పరిష్కారం యొక్క కళ గురించి.","target_lang":"te","domain":"general","complexity":"moderate"} |