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.