en stringlengths 4 3.31k | translation stringlengths 5 3.49k | target_lang stringclasses 10
values | domain stringclasses 6
values | complexity stringclasses 3
values |
|---|---|---|---|---|
We left it turned on. | మనం దాన్ని ఆన్ చేసి వదిలేశాము. | te | technical | simple |
The -z execstack compiler option makes the stack executable, disabling another buffer overflow prevention method. | '-z execstack' కంపైలర్ ఎంపిక స్టాక్ను అమలు చేయదగినదిగా చేస్తుంది, ఇది మరొక బఫర్ ఓవర్ఫ్లో నివారణ పద్ధతిని నిలిపివేస్తుంది. | te | technical | moderate |
We tell GCC to compile overflowtest.c into an executable called overflowtest with the -o option. | overflowtest.cని -o ఎంపికతో overflowtest అనే ఎగ్జిక్యూటబుల్గా కంపైల్ చేయమని మేము GCCకి చెబుతాము. | te | technical | moderate |
Recall that main takes the first command line argument to the program and feeds it to function1, which copies the value into a five-character local variable. | మెయిన్ ప్రోగ్రామ్కు మొదటి కమాండ్ లైన్ ఆర్గ్యుమెంట్ను తీసుకుంటుంది మరియు దానిని function1కి అందిస్తుంది, ఇది విలువను ఐదు-అక్షరాల స్థానిక వేరియబుల్లోకి కాపీ చేస్తుందని గుర్తుంచుకోండి. | te | technical | complex |
Let’s run the program with the command line argument AAAA, as shown here. | ఇక్కడ చూపిన విధంగా, AAAA కమాండ్ లైన్ ఆర్గ్యుమెంట్తో ప్రోగ్రామ్ను అమలు చేద్దాం. | te | technical | simple |
Make overflowtest executable with chmod if necessary. | అవసరమైతే chmodతో overflowtestని అమలు చేయదగినదిగా చేయండి. | te | technical | simple |
We use four As instead of five because a string ends with a null byte. | ఒక స్ట్రింగ్ శూన్య బైట్తో ముగుస్తుంది కాబట్టి మేము ఐదుకు బదులుగా నాలుగు As ఉపయోగిస్తాము. | te | technical | moderate |
Technically, if we used five As, we would already be overflowing the buffer, albeit by just one character. | సాంకేతికంగా, మనం ఐదు Asని ఉపయోగిస్తే, మనం ఇప్పటికే బఫర్ను ఓవర్ఫ్లో చేస్తున్నాము, కేవలం ఒక అక్షరం ద్వారా. | te | technical | moderate |
Executed normally | సాధారణంగా అమలు చేయబడింది | te | technical | simple |
Maybe if we give overflowtest some unexpected input, we can force it to behave in a way that will help us cause a buffer overflow. | ఒకవేళ మనం overflowtestకి ఊహించని ఇన్పుట్ను ఇస్తే, అది బఫర్ ఓవర్ఫ్లోను కలిగించడానికి సహాయపడే విధంగా ప్రవర్తించేలా మనం బలవంతం చేయవచ్చు. | te | technical | complex |
Causing a Crash Now let’s try giving the program a long string of As as an argument, as shown here. | క్రాష్ను కలిగించడం ఇప్పుడు ప్రోగ్రామ్కు చాలా పొడవైన స్ట్రింగ్ ఆఫ్ Asని వాదనగా ఇద్దాం, ఇక్కడ చూపిన విధంగా. | te | technical | moderate |
This time, the program crashes with a segmentation fault. | ఈసారి, ప్రోగ్రామ్ సెగ్మెంటేషన్ లోపంతో క్రాష్ అవుతుంది. | te | technical | simple |
Our pro- gram’s problem lies with the implementation of strcpy, which we use in function1. | మన ప్రోగ్రామ్ సమస్య function1లో మనం ఉపయోగించే strcpy అమలుతో ఉంది. | te | technical | moderate |
The strcpy function takes one string and copies it into another, but it does not do any bounds checking to make sure the supplied argu- ment will fit into the destination string variable. | strcpy ఫంక్షన్ ఒక స్ట్రింగ్ను తీసుకుంటుంది మరియు దానిని మరొకదానికి కాపీ చేస్తుంది, కానీ సరఫరా చేయబడిన వాదన గమ్యస్థాన స్ట్రింగ్ వేరియబుల్లోకి సరిపోతుందో లేదో నిర్ధారించడానికి ఇది ఎటువంటి సరిహద్దు తనిఖీ చేయదు. | te | technical | complex |
The strcpy function will attempt to copy three, five, or even hundreds of characters into our five-character destination string. | strcpy ఫంక్షన్ మూడు, ఐదు లేదా వందల కొద్దీ అక్షరాలను మన ఐదు-అక్షరాల గమ్యస్థాన స్ట్రింగ్లోకి కాపీ చేయడానికి ప్రయత్నిస్తుంది. | te | technical | moderate |
If our string is five characters long and we copy in 100 characters, the other 95 will end up overwriting data at adja cent memory addresses in the stack. | మన స్ట్రింగ్ ఐదు అక్షరాలు పొడవుగా ఉండి, మనం 100 అక్షరాలను కాపీ చేస్తే, మిగిలిన 95 స్టాక్లోని ప్రక్కనే ఉన్న మెమరీ చిరునామాలలో డేటాను తిరిగి వ్రాస్తాయి. | te | technical | complex |
We could potentially overwrite the rest of function1’s stack frame and even higher memory. | మనం ఫంక్షన్1 యొక్క స్టాక్ ఫ్రేమ్ మరియు అంతకంటే ఎక్కువ మెమరీని తిరిగి వ్రాయవచ్చు. | te | technical | moderate |
Remember what’s at the memory address immedi- ately after the base of that stack frame? | ఆ స్టాక్ ఫ్రేమ్ యొక్క ఆధారం తర్వాత వెంటనే మెమరీ చిరునామాలో ఏముందో గుర్తుంచుకోండి? | te | technical | moderate |
Before the frame was pushed on the stack, main pushed its return address onto the stack to designate where execution should continue once function1 returns. | ఫ్రేమ్ను స్టాక్లో ఉంచడానికి ముందు, function1 తిరిగి వచ్చిన తర్వాత ఎక్కడ అమలు కొనసాగించాలో తెలుసుకోవడానికి మెయిన్ దాని రిటర్న్ చిరునామాను స్టాక్లో ఉంచింది. | te | technical | complex |
If the string we copy into buffer is long enough, we’ll overwrite memory from buffer straight through to EBP, over the return address, and even into main’s stack frame. | మనం బఫర్లోకి కాపీ చేసే స్ట్రింగ్ సరిపడా పొడవుగా ఉంటే, మనం బఫర్ నుండి నేరుగా EBP వరకు, రిటర్న్ చిరునామాపై మరియు మెయిన్ యొక్క స్టాక్ ఫ్రేమ్లోకి కూడా మెమరీని తిరిగి వ్రాస్తాము. | te | technical | complex |
Our Ubuntu virtual machine has an Intel architecture, which is little endian. | మన ఉబుంటు వర్చువల్ మెషిన్ ఇంటెల్ ఆర్కిటెక్చర్ను కలిగి ఉంది, ఇది చిన్న ఎండియన్. | te | technical | moderate |
To account for little-endian architecture, we need to flip the bytes of our memory address around. | చిన్న-ఎండియన్ ఆర్కిటెక్చర్ను పరిగణనలోకి తీసుకోవడానికి, మనం మన మెమరీ చిరునామా యొక్క బైట్లను తిప్పాలి. | te | technical | moderate |
Using the return address with the byte order flipped for our Intel architecture fixes our problem. | మన ఇంటెల్ ఆర్కిటెక్చర్ కోసం బైట్ ఆర్డర్ మార్చబడిన రిటర్న్ చిరునామాను ఉపయోగించడం వలన మన సమస్య పరిష్కారమవుతుంది. | te | technical | moderate |
This time when we hit the breakpoint, our return address looks correct. | ఈసారి మనం బ్రేక్ పాయింట్ను తాకినప్పుడు, మా రిటర్న్ చిరునామా సరిగ్గా కనిపిస్తుంది. | te | technical | moderate |
Sure enough, when we let the program continue, “Execution Hijacked” is printed to the console. | ఖచ్చితంగా, మేము ప్రోగ్రామ్ను కొనసాగించడానికి అనుమతించినప్పుడు, “ఎగ్జిక్యూషన్ హైజాక్ చేయబడింది” కన్సోల్కు ప్రింట్ చేయబడుతుంది. | te | technical | moderate |
We have successfully hijacked execution and exploited a buffer overflow vulnerability. | మేము విజయవంతంగా ఎగ్జిక్యూషన్ను హైజాక్ చేసాము మరియు బఫర్ ఓవర్ఫ్లో దుర్బలత్వాన్ని ఉపయోగించుకున్నాము. | te | technical | complex |
To see the results outside the debugger, we run overflowtest from the command line. | డీబగ్గర్ వెలుపల ఫలితాలను చూడటానికి, మేము కమాండ్ లైన్ నుండి ఓవర్ఫ్లోటెస్ట్ను నడుపుతాము. | te | technical | moderate |
Note that after overflowed returns, the program crashes with a segmentation fault. | ఓవర్ఫ్లో తిరిగి వచ్చిన తర్వాత, ప్రోగ్రామ్ సెగ్మెంటేషన్ లోపంతో క్రాష్ అవుతుందని గమనించండి. | te | technical | moderate |
This address is the same as the next four bytes on the stack after our return address. | ఈ చిరునామా మన రిటర్న్ చిరునామా తర్వాత స్టాక్లో ఉన్న తదుపరి నాలుగు బైట్లకు సమానంగా ఉంటుంది. | te | technical | moderate |
We sent execution straight to overflowed without normal function-calling things. | సాధారణ ఫంక్షన్-కాలింగ్ విషయాలు లేకుండా నేరుగా ఓవర్ఫ్లోకు ఎగ్జిక్యూషన్ను పంపించాము. | te | technical | complex |
In this chapter we looked at a simple C program with a buffer overflow vulnerability. | ఈ అధ్యాయంలో, మేము బఫర్ ఓవర్ఫ్లో దుర్బలత్వంతో కూడిన సాధారణ సి ప్రోగ్రామ్ను పరిశీలించాము. | te | technical | moderate |
We exploited this issue by writing a longer string to the command line than the program expected. | ప్రోగ్రామ్ ఊహించిన దానికంటే ఎక్కువ స్ట్రింగ్ను కమాండ్ లైన్కు రాయడం ద్వారా మేము ఈ సమస్యను ఉపయోగించుకున్నాము. | te | technical | moderate |
In the next chapter, our example will focus on a Windows-based target. | తదుపరి అధ్యాయంలో, మా ఉదాహరణ విండోస్ ఆధారిత లక్ష్యంపై దృష్టి పెడుతుంది. | te | technical | simple |
In this chapter, we will look at exploiting a stack-based buffer overflow in an older version of a Windows-based FTP server. | ఈ అధ్యాయంలో, విండోస్ ఆధారిత FTP సర్వర్ యొక్క పాత వెర్షన్లో స్టాక్-ఆధారిత బఫర్ ఓవర్ఫ్లోను ఉపయోగించుకోవడం గురించి చూస్తాము. | te | technical | complex |
When the function main calls function1, the next instruction to be executed is saved on the stack. | ఫంక్షన్ మెయిన్ ఫంక్షన్1ని పిలిచినప్పుడు, అమలు చేయవలసిన తదుపరి సూచన స్టాక్లో సేవ్ చేయబడుతుంది. | te | technical | moderate |
If we put more data in the stack buffer than it can hold, we will cause the buffer to overflow. | స్టాక్ బఫర్లో అది కలిగి ఉండగలిగే దానికంటే ఎక్కువ డేటాను ఉంచితే, మేము బఫర్ను ఓవర్ఫ్లో చేస్తాము. | te | technical | moderate |
In Chapter 1, we installed War-FTP version 1.65 on the Windows XP target. | అధ్యాయం 1 లో, మేము విండోస్ XP లక్ష్యంపై War-FTP వెర్షన్ 1.65 ని ఇన్స్టాల్ చేసాము. | te | technical | simple |
A search on Google for known vulnerabilities in War-FTP 1.65 finds the following information. | War-FTP 1.65 లో తెలిసిన దుర్బలత్వాల కోసం గూగుల్ లో శోధించడం వలన ఈ క్రింది సమాచారం లభిస్తుంది. | te | technical | simple |
Exploiting this issue could lead to denial-of-service conditions and to the execution of arbitrary machine code. | ఈ సమస్యను ఉపయోగించుకోవడం వలన సర్వీస్ నిరాకరణ పరిస్థితులు మరియు ఇష్టానుసార యంత్ర కోడ్ అమలుకు దారి తీయవచ్చు. | te | technical | complex |
In this chapter, we will manually exploit War-FTP 1.65’s stack-based buffer overflow vulnerability. | ఈ అధ్యాయంలో, మేము War-FTP 1.65 యొక్క స్టాక్-ఆధారిత బఫర్ ఓవర్ఫ్లో దుర్బలత్వాన్ని మాన్యువల్గా ఉపయోగిస్తాము. | te | technical | complex |
The program crashes as expected, but this time our access violation is a bit different from the one in Chapter 17. | ప్రోగ్రామ్ ఊహించిన విధంగా క్రాష్ అవుతుంది, కానీ ఈసారి మన యాక్సెస్ ఉల్లంఘన 17వ అధ్యాయంలోని దానికంటే కొంచెం భిన్నంగా ఉంది. | te | technical | moderate |
Instead of overwriting the saved return pointer and crashing the program with EIP control, War-FTP crashed writing to memory address 0x00B00000. | సేవ్ చేసిన రిటర్న్ పాయింటర్ను తిరిగి వ్రాయడానికి బదులుగా మరియు EIP నియంత్రణతో ప్రోగ్రామ్ను క్రాష్ చేయడానికి బదులుగా, War-FTP మెమరీ చిరునామా 0x00B00000కి వ్రాస్తూ క్రాష్ అయింది. | te | technical | complex |
Notice in the CPU pane that the instruction at 0x77C3F973 is MOV BYTE PTR DS:[EAX], 0. | CPU పేన్లో 0x77C3F973 వద్ద ఉన్న సూచన MOV BYTE PTR DS:[EAX], 0 అని గమనించండి. | te | technical | moderate |
Basically, the program is trying to write to the memory location of the value of EAX. | బేసిక్గా, ప్రోగ్రామ్ EAX విలువ యొక్క మెమరీ స్థానానికి వ్రాయడానికి ప్రయత్నిస్తోంది. | te | technical | simple |
Looking at the top right of Immunity Debugger, the Registers pane, we see EAX contains the value 00B00000. | ఇమ్యూనిటీ డీబగ్గర్ యొక్క కుడి ఎగువ భాగాన్ని, రిజిస్టర్స్ పేన్ను చూస్తే, EAX 00B00000 విలువను కలిగి ఉందని మేము చూస్తాము. | te | technical | moderate |
Something about our attack string seems to have corrupted EAX, because the program is now trying to write to a memory location that is not writable. | మన దాడి స్ట్రింగ్ గురించి ఏదో EAXను పాడుచేసినట్లు కనిపిస్తోంది, ఎందుకంటే ప్రోగ్రామ్ ఇప్పుడు వ్రాయలేని మెమరీ స్థానానికి వ్రాయడానికి ప్రయత్నిస్తోంది. | te | technical | complex |
Before we write off this exploit and move on, take a look at the SEH chain. | ఈ ఎక్స్ప్లాయిట్ను వదిలి ముందుకు వెళ్లే ముందు, SEH గొలుసును ఒకసారి చూడండి. | te | technical | moderate |
As shown in Figure 18-4, the structured exception handler has been overwritten with As. | చిత్రం 18-4లో చూపిన విధంగా, నిర్మాణాత్మక మినహాయింపు హ్యాండ్లర్ Asతో తిరిగి వ్రాయబడింది. | te | technical | simple |
Recall that in the event of a crash, execution is passed to SEH. | క్రాష్ జరిగినప్పుడు, అమలు SEHకి పంపబడుతుందని గుర్తుంచుకోండి. | te | technical | simple |
Though we were not able to control EIP directly at the time of the crash, perhaps controlling SEH will allow us to still hijack execution. | క్రాష్ సమయంలో మేము EIPని నేరుగా నియంత్రించలేనప్పటికీ, SEHని నియంత్రించడం ద్వారా ఇప్పటికీ అమలును హైజాక్ చేయడానికి వీలుంటుంది. | te | technical | complex |
Just as we used Mona to create a cyclic pattern to see which four bytes overwrote the saved return pointer in the previous chapter, we will find which four As are overwriting SEH using the command !mona pattern_create 1150 in Immunity Debugger. | మునుపటి అధ్యాయంలో సేవ్ చేసిన రిటర్న్ పాయింటర్ను ఏ నాలుగు బైట్లు తిరిగి వ్రాసాయో తెలుసుకోవడానికి మనం మోనాను ఉపయోగించినట్లే, ఇమ్యూనిటీ డీబగ్గర్లో !mona pattern_create 1150 కమాండ్ ఉపయోగించి SEHని ఏ నాలుగు As తిరిగి వ్రాస్తున్నాయో కనుగొంటాము. | te | technical | complex |
Copy the resulting pattern from C:\logs\war-ftpd\pattern.txt into the exploit in place of the 1,150 As. | C:\logs\war-ftpd\pattern.txt నుండి ఫలిత నమూనాను 1,150 As స్థానంలో ఎక్స్ప్లాయిట్లోకి కాపీ చేయండి. | te | technical | simple |
Here we’ve generated a 1,150-character pattern and replaced the string of As at u. | ఇక్కడ మేము 1,150-అక్షరాల నమూనాను రూపొందించాము మరియు u వద్ద ఉన్న As స్ట్రింగ్ను భర్తీ చేసాము. | te | technical | simple |
Next, restart War-FTP in Immunity Debugger, and run the exploit again. | తరువాత, ఇమ్యూనిటీ డీబగ్గర్లో War-FTPని పునఃప్రారంభించండి మరియు మళ్లీ ఎక్స్ప్లాయిట్ను అమలు చేయండి. | te | technical | simple |
As shown in Figure 18-6, SEH is overwritten with 41317441. | చిత్రం 18-6లో చూపిన విధంగా, SEH 41317441తో తిరిగి వ్రాయబడింది. | te | technical | simple |
Now use !mona findmsp to find out where in our 1,150-character attack string the SEH entry is overwritten. | ఇప్పుడు మన 1,150-అక్షరాల దాడి స్ట్రింగ్లో SEH ఎంట్రీ ఎక్కడ తిరిగి వ్రాయబడిందో తెలుసుకోవడానికి !mona findmspని ఉపయోగించండి. | te | technical | moderate |
Looking through the log output at C:\logs\war-ftpd\findmsp.txt, shown in part here, we find that the NSEH entry is overwritten 569 bytes into the attack string. | C:\logs\war-ftpd\findmsp.txt వద్ద లాగ్ అవుట్పుట్ను పరిశీలిస్తే, ఇక్కడ కొంత భాగం చూపబడింది, NSEH ఎంట్రీ దాడి స్ట్రింగ్లో 569 బైట్లకు తిరిగి వ్రాయబడిందని మేము కనుగొన్నాము. | te | technical | complex |
Recall from Figure 18-1 that SEH chain entries are made up of eight bytes (the NSEH entry followed by the SEH pointer). | SEH గొలుసు ఎంట్రీలు ఎనిమిది బైట్లతో తయారవుతాయని గుర్తుంచుకోండి (NSEH ఎంట్రీ తరువాత SEH పాయింటర్). | te | technical | moderate |
Thus our SEH overwrite is at 573 bytes into our attack string (four bytes after NSEH). | అందువల్ల మన SEH తిరిగి రాయడం మన దాడి స్ట్రింగ్లో 573 బైట్ల వద్ద ఉంది (NSEH తర్వాత నాలుగు బైట్లు). | te | technical | moderate |
If we can find a way to remove two elements from the stack and then execute the contents of this memory address, we can execute shellcode in place of the pattern. | మనం స్టాక్ నుండి రెండు మూలకాలను తీసివేసి, ఆపై ఈ మెమరీ చిరునామాలోని విషయాలను అమలు చేయడానికి ఒక మార్గాన్ని కనుగొనగలిగితే, మనం నమూనా స్థానంలో షెల్కోడ్ను అమలు చేయవచ్చు. | te | technical | complex |
The program crashes again, and, as expected, SEH is overwritten with 5F4580CA. | ప్రోగ్రామ్ మళ్ళీ క్రాష్ అవుతుంది, మరియు ఊహించిన విధంగా, SEH 5F4580CAతో ఓవర్రైట్ చేయబడుతుంది. | te | technical | moderate |
We have solved our first problem: We have redirected the program’s execution to our attack string. | మేము మా మొదటి సమస్యను పరిష్కరించాము: మేము ప్రోగ్రామ్ యొక్క అమలును మా దాడి స్ట్రింగ్కు మళ్ళించాము. | te | technical | moderate |
We need to somehow bypass the return address and get to our long string of Ds. | మనం ఎలాగైనా రిటర్న్ చిరునామాను దాటాలి మరియు మా పొడవైన Ds స్ట్రింగ్కు చేరుకోవాలి. | te | technical | moderate |
We can use the short jump assembly instruction to move EIP a short distance. | EIPని కొద్ది దూరం తరలించడానికి మనం చిన్న జంప్ అసెంబ్లీ సూచనను ఉపయోగించవచ్చు. | te | technical | complex |
The hexadecimal representation of a short jump is \xEB <length to jump>. | చిన్న జంప్ యొక్క హెక్సాడెసిమల్ ప్రాతినిధ్యం \xEB <జంప్ చేయడానికి పొడవు>. | te | technical | complex |
Now add the shellcode to our exploit in place of the Ds. | ఇప్పుడు షెల్కోడ్ను Ds స్థానంలో మా ఎక్స్ప్లోయిట్కు జోడించండి. | te | technical | moderate |
When we run War-FTP with- out a debugger and an error is encountered, execution is automatically passed to SEH. | మేము డీబగ్గర్ లేకుండా War-FTPని అమలు చేసినప్పుడు మరియు లోపం ఎదురైనప్పుడు, అమలు స్వయంచాలకంగా SEHకి పంపబడుతుంది. | te | technical | complex |
We have successfully built an SEH overwrite exploit for War-FTP. | మేము War-FTP కోసం SEH ఓవర్రైట్ ఎక్స్ప్లోయిట్ను విజయవంతంగా నిర్మించాము. | te | technical | moderate |
In such cases, knowing the steps to exploit this sort of crash is paramount to creating a working exploit. | అటువంటి సందర్భాలలో, ఈ రకమైన క్రాష్ని ఎలా ఉపయోగించాలో తెలుసుకోవడం పని చేసే ఎక్స్ప్లోయిట్ను రూపొందించడానికి చాలా ముఖ్యం. | te | technical | complex |
We will look at using a technique called fuzzing to find potential exploits in vulner- able programs. | దోషపూరిత ప్రోగ్రామ్లలో సంభావ్య ఎక్స్ప్లోయిట్లను కనుగొనడానికి ఫజింగ్ అనే సాంకేతికతను ఉపయోగించడం గురించి మేము చూస్తాము. | te | technical | moderate |
When auditing the source code of this program, we see the strcpy function. | ఈ ప్రోగ్రామ్ యొక్క సోర్స్ కోడ్ను ఆడిట్ చేస్తున్నప్పుడు, మేము strcpy ఫంక్షన్ను చూస్తాము. | te | technical | moderate |
We can use fuzzing to send various inputs to the program that the developer never intended the code to process. | డెవలపర్ కోడ్ను ప్రాసెస్ చేయడానికి ఎప్పుడూ ఉద్దేశించని ప్రోగ్రామ్కు వివిధ ఇన్పుట్లను పంపడానికి మేము ఫజింగ్ని ఉపయోగించవచ్చు. | te | technical | moderate |
If we can find input that will manipulate memory in a controllable way, we may be able to exploit the program. | మేము నియంత్రించదగిన మార్గంలో మెమరీని మార్చే ఇన్పుట్ను కనుగొనగలిగితే, మేము ప్రోగ్రామ్ను ఉపయోగించగలుగుతాము. | te | technical | moderate |
In the case of this TFTP server, the first field, Opcode, is always two bytes long. | ఈ TFTP సర్వర్ విషయంలో, మొదటి ఫీల్డ్, Opcode, ఎల్లప్పుడూ రెండు బైట్ల పొడవు ఉంటుంది. | te | technical | moderate |
However, we can control the Filename field. | అయితే, మేము ఫైల్నేమ్ ఫీల్డ్ను నియంత్రించవచ్చు. | te | technical | simple |
The length is variable and the contents of the string are user controlled, so this may be a good place to look for stack-based buffer over- flow vulnerabilities. | పొడవు వేరియబుల్ మరియు స్ట్రింగ్ యొక్క విషయాలు వినియోగదారు నియంత్రితంగా ఉంటాయి, కాబట్టి ఇది స్టాక్-ఆధారిత బఫర్ ఓవర్-ఫ్లో దుర్బలత్వాల కోసం చూడటానికి మంచి ప్రదేశం కావచ్చు. | te | technical | complex |
For example, perhaps the author of the code was not expecting anyone to enter a filename that is 1,000 characters long. | ఉదాహరణకు, కోడ్ రచయిత 1,000 అక్షరాల పొడవున్న ఫైల్నేమ్ను నమోదు చేయాలని ఎవరూ అనుకోలేదు. | te | technical | moderate |
The TFTP packet ends with a null byte to signify the end of the Mode. | TFTP ప్యాకెట్ మోడ్ ముగింపును సూచించడానికి శూన్య బైట్తో ముగుస్తుంది. | te | technical | simple |
For our fuzzing exercise, we will craft a succession of legitimate TFTP pack- ets with bogus and increasingly long input in the Mode field. | మా ఫజింగ్ వ్యాయామం కోసం, మేము మోడ్ ఫీల్డ్లో బూటకపు మరియు క్రమంగా పొడవైన ఇన్పుట్తో చట్టబద్ధమైన TFTP ప్యాకెట్ల శ్రేణిని రూపొందిస్తాము. | te | technical | complex |
When the fuzzing program attempts to fuzz with a length of 600, it receives no response from the TFTP server. | ఫజింగ్ ప్రోగ్రామ్ 600 పొడవుతో ఫజ్ చేయడానికి ప్రయత్నించినప్పుడు, అది TFTP సర్వర్ నుండి ఎటువంటి ప్రతిస్పందనను స్వీకరించదు. | te | technical | moderate |
Mobile devices are now entering the workplace en masse. | మొబైల్ పరికరాలు ఇప్పుడు పెద్ద సంఖ్యలో కార్యాలయాలలోకి ప్రవేశిస్తున్నాయి. | te | technical | simple |
Security teams and pentesters must evaluate the security risks of these devices. | భద్రతా బృందాలు మరియు పెనెట్రేషన్ పరీక్షకులు ఈ పరికరాల భద్రతా ప్రమాదాలను అంచనా వేయాలి. | te | technical | moderate |
Mobile technology is a rapidly developing field. | మొబైల్ సాంకేతికత వేగంగా అభివృద్ధి చెందుతున్న రంగం. | te | technical | simple |
Developing new mobile attacks and post-exploitation techniques is an ideal place to start with your own security research. | కొత్త మొబైల్ దాడులను మరియు పోస్ట్-ఎక్స్ప్లోయిటేషన్ పద్ధతులను అభివృద్ధి చేయడం మీ స్వంత భద్రతా పరిశోధనను ప్రారంభించడానికి ఒక అనువైన ప్రదేశం. | te | technical | complex |
We’ll be discussing a tool I created to help pentesters to assess the security posture of mobile devices. | మొబైల్ పరికరాల భద్రతా స్థితిని అంచనా వేయడానికి పెనెట్రేషన్ పరీక్షకులకు సహాయపడటానికి నేను రూపొందించిన ఒక సాధనం గురించి మేము చర్చిస్తాము. | te | technical | moderate |
After working your way through this book, you will be ready to embark on your own infosec journey. | ఈ పుస్తకం ద్వారా మీరు పని చేసిన తర్వాత, మీరు మీ స్వంత సమాచార భద్రతా ప్రయాణాన్ని ప్రారంభించడానికి సిద్ధంగా ఉంటారు. | te | technical | moderate |
For most of the examples in this chapter, we’ll use the Android platform as a target. | ఈ అధ్యాయంలోని చాలా ఉదాహరణల కోసం, మేము Android ప్లాట్ఫారమ్ను లక్ష్యంగా ఉపయోగిస్తాము. | te | technical | simple |
Mobile devices run operating systems, speak TCP/IP, and access a lot of the same resources that traditional computers do. | మొబైల్ పరికరాలు ఆపరేటింగ్ సిస్టమ్లను నడుపుతాయి, TCP/IP మాట్లాడుతాయి మరియు సాంప్రదాయక కంప్యూటర్లు చేసే అనేక వనరులను యాక్సెస్ చేస్తాయి. | te | technical | moderate |
They also have their own unique features that add new attack vectors and protocols to the mix. | అవి కొత్త దాడి వెక్టర్లు మరియు ప్రోటోకాల్లను మిశ్రమానికి జోడించే వాటి స్వంత ప్రత్యేక లక్షణాలను కూడా కలిగి ఉన్నాయి. | te | technical | moderate |
Some features have been causing security problems on devices for years. | కొన్ని ఫీచర్లు సంవత్సరాలుగా పరికరాల్లో భద్రతా సమస్యలను కలిగిస్తున్నాయి. | te | technical | simple |
SMS opens up a new social-engineering attack vector. | SMS ఒక కొత్త సామాజిక-ఇంజనీరింగ్ దాడి వెక్టార్ను తెరుస్తుంది. | te | technical | simple |
SMS is an ideal vector for spam and phishing attacks. | SMS స్పామ్ మరియు ఫిషింగ్ దాడులకు ఒక అనువైన వెక్టర్. | te | technical | simple |
Security-awareness training will need to be augmented to include this threat. | ఈ ముప్పును చేర్చడానికి భద్రతా-అవగాహన శిక్షణను పెంచాలి. | te | technical | moderate |
A user who knows better than to click a random link in a suspicious-looking email may still click a random link in a text message. | అనుమానాస్పదంగా కనిపించే ఇమెయిల్లోని యాదృచ్ఛిక లింక్ను క్లిక్ చేయకుండా ఉండటం తెలిసిన వినియోగదారు, ఇప్పటికీ టెక్స్ట్ సందేశంలో యాదృచ్ఛిక లింక్ను క్లిక్ చేయవచ్చు. | te | technical | complex |
Mobile devices bring yet another attack vector to the table: near field communication, or NFC. | మొబైల్ పరికరాలు మరొక దాడి వెక్టార్ను టేబుల్కు తీసుకువస్తాయి: సమీప క్షేత్ర కమ్యూనికేషన్, లేదా NFC. | te | technical | moderate |
NFC allows devices to share data by touching or being near each other. | NFC పరికరాలు ఒకదానికొకటి తాకడం ద్వారా లేదా దగ్గరగా ఉండటం ద్వారా డేటాను పంచుకోవడానికి అనుమతిస్తుంది. | te | technical | simple |
Security awareness training should also teach users to be aware of which NFC tags their device responds to. | భద్రతా అవగాహన శిక్షణ వినియోగదారులకు వారి పరికరం ఏ NFC ట్యాగ్లకు ప్రతిస్పందిస్తుందో తెలుసుకోవడానికి కూడా నేర్పించాలి. | te | technical | moderate |
QR codes can embed URLs, send data to an application on a mobile device, and so on. | QR కోడ్లు URLలను పొందుపరచగలవు, మొబైల్ పరికరంలోని అప్లికేషన్కు డేటాను పంపగలవు మరియు మొదలైనవి. | te | technical | moderate |
That QR code on a store window doesn’t have to point to the store’s website. | దుకాణం కిటికీలో ఉన్న QR కోడ్ దుకాణం వెబ్సైట్కు పాయింట్ చేయనవసరం లేదు. | te | technical | simple |
We will spend the rest of the chapter exploring SPF’s various options. | అధ్యాయం మిగిలిన భాగాన్ని SPF యొక్క వివిధ ఎంపికలను అన్వేషించడానికి వెచ్చిస్తాము. | te | technical | simple |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.