Datasets:
slaab
/
Cyber-Parallel-Dataset-Indic

Dataset card Data Studio Files
xet
Community
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.
நாங்கள் அதை இயக்கியே வைத்திருந்தோம்.
ta
technical
simple
The -z execstack compiler option makes the stack executable, disabling another buffer overflow prevention method.
-z execstack கம்பைலர் விருப்பம், அடுக்கு செயல்படுத்தக்கூடியதாக ஆக்குகிறது, இது மற்றொரு இடையக வழிதல் தடுப்பு முறையை முடக்குகிறது.
ta
technical
moderate
We tell GCC to compile overflowtest.c into an executable called overflowtest with the -o option.
overflowtest.c ஐ -o விருப்பத்துடன் overflowtest எனப்படும் செயல்படுத்தக்கூடியதாக தொகுக்க ஜி.சி.சி.க்குச் சொல்கிறோம்.
ta
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.
main நிரலுக்கான முதல் கட்டளை வரி வாதத்தை எடுத்து அதை function1 க்கு அனுப்புகிறது என்பதை நினைவில் கொள்ளுங்கள், இது மதிப்பை ஐந்து எழுத்து உள்ளூர் மாறிக்கு நகலெடுக்கிறது.
ta
technical
complex
Let’s run the program with the command line argument AAAA, as shown here.
AAAA கட்டளை வரி வாதத்துடன் நிரலை இயக்குவோம், இங்கே காட்டப்பட்டுள்ளது.
ta
technical
simple
Make overflowtest executable with chmod if necessary.
தேவைப்பட்டால், chmod உடன் overflowtest ஐ செயல்படுத்தக்கூடியதாக ஆக்குங்கள்.
ta
technical
simple
We use four As instead of five because a string ends with a null byte.
ஒரு சரம் பூஜ்ய பைட்டுடன் முடிவதால், நாங்கள் ஐந்துக்கு பதிலாக நான்கு 'A' களைப் பயன்படுத்துகிறோம்.
ta
technical
moderate
Technically, if we used five As, we would already be overflowing the buffer, albeit by just one character.
தொழில்நுட்ப ரீதியாக, நாங்கள் ஐந்து 'A' களைப் பயன்படுத்தினால், ஏற்கனவே இடையகத்தை நிரப்பிவிடுவோம், ஒரு எழுத்தால் மட்டுமே.
ta
technical
moderate
Executed normally
சாதாரணமாக செயல்படுத்தப்பட்டது
ta
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 க்கு எதிர்பாராத உள்ளீட்டை வழங்கினால், இடையக வழிதலை ஏற்படுத்த உதவும் வகையில் அதை செயல்பட வைக்க முடியும்.
ta
technical
complex
Causing a Crash Now let’s try giving the program a long string of As as an argument, as shown here.
ஒரு செயலிழப்பை ஏற்படுத்துதல் இப்போது நிரலுக்கு ஒரு நீண்ட சரத்தை வாதமாக வழங்குவோம், இங்கே காட்டப்பட்டுள்ளது.
ta
technical
moderate
Segmentation fault
பிரிப்பு தவறு
ta
technical
simple
Our pro- gram’s problem lies with the implementation of strcpy, which we use in function1.
எங்கள் நிரலின் பிரச்சனை strcpy செயல்படுத்தலுடன் உள்ளது, இதை நாம் function1 இல் பயன்படுத்துகிறோம்.
ta
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 செயல்பாடு ஒரு சரத்தை எடுத்து அதை வேறொன்றில் நகலெடுக்கிறது, ஆனால் வழங்கப்பட்ட வாதம் இலக்கு சர மாறிக்குள் பொருந்துமா என்பதை உறுதிப்படுத்த எந்த எல்லை சரிபார்ப்பையும் செய்யாது.
ta
technical
complex
The strcpy function will attempt to copy three, five, or even hundreds of characters into our A Stack-Based Buffer Overflow in Linux 367 five-character destination string.
strcpy செயல்பாடு மூன்று, ஐந்து அல்லது நூற்றுக்கணக்கான எழுத்துக்களை எங்கள் A Stack-Based Buffer Overflow in Linux 367 ஐந்து-எழுத்து இலக்கு சரத்தில் நகலெடுக்க முயற்சிக்கும்.
ta
technical
complex
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 எழுத்துக்கள் அடுக்கில் உள்ள அருகிலுள்ள நினைவக முகவரிகளில் தரவை மேலெழுதும்.
ta
technical
complex
We could potentially overwrite the rest of function1’s stack frame and even higher memory.
நாம் function1 இன் அடுக்கு சட்டத்தின் மீதமுள்ள பகுதியையும், இன்னும் அதிக நினைவகத்தையும் மேலெழுதலாம்.
ta
technical
moderate
Remember what’s at the memory address immedi- ately after the base of that stack frame?
அந்த அடுக்கு சட்டத்தின் அடிப்பகுதிக்கு உடனடியாகப் பிறகு நினைவக முகவரியில் என்ன இருக்கிறது என்பதை நினைவில் கொள்ளுங்கள்?
ta
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 திரும்பியதும் செயல்படுத்தல் எங்கு தொடர வேண்டும் என்பதைக் குறிக்க, main அதன் திரும்பும் முகவரியை அடுக்கில் தள்ளியது.
ta
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 வரை, திரும்பும் முகவரிக்கு மேல் மற்றும் main இன் அடுக்கு சட்டத்திற்குள் கூட நினைவகத்தை மேலெழுதுவோம்.
ta
technical
complex
Our Ubuntu virtual machine has an Intel architecture, which is little endian.
எங்கள் உபுண்டு மெய்நிகர் இயந்திரம் ஒரு இன்டெல் கட்டமைப்பைக் கொண்டுள்ளது, இது சிறிய எண்டியன் ஆகும்.
ta
technical
moderate
To account for little-endian architecture, we need to flip the bytes of our memory address around.
சிறிய-எண்டியன் கட்டமைப்பைக் கணக்கில் எடுத்துக்கொள்ள, எங்கள் நினைவக முகவரியின் பைட்டுகளை மாற்ற வேண்டும்.
ta
technical
moderate
Using the return address with the byte order flipped for our Intel architecture fixes our problem.
எங்கள் இன்டெல் கட்டமைப்பிற்காக பைட்டுகளின் வரிசையை மாற்றியமைத்த ரிட்டர்ன் முகவரியைப் பயன்படுத்துவது எங்கள் சிக்கலை சரிசெய்கிறது.
ta
technical
moderate
This time when we hit the breakpoint, our return address looks correct.
இந்த முறை பிரேக் பாயிண்ட்டை அடைந்ததும், எங்கள் ரிட்டர்ன் முகவரி சரியாகத் தெரிகிறது.
ta
technical
moderate
Sure enough, when we let the program continue, “Execution Hijacked” is printed to the console.
நிச்சயமாக, நிரலைத் தொடர அனுமதிக்கும்போது, ​​“செயல்படுத்தல் கடத்தப்பட்டது” கன்சோலில் அச்சிடப்படுகிறது.
ta
technical
moderate
We have successfully hijacked execution and exploited a buffer overflow vulnerability.
நாங்கள் வெற்றிகரமாகச் செயல்பாட்டைக் கடத்தி, ஒரு இடையக வழிதல் பாதிப்பைப் பயன்படுத்தியுள்ளோம்.
ta
technical
moderate
To see the results outside the debugger, we run overflowtest from the command line.
டீபக்கருக்கு வெளியே முடிவுகளைப் பார்க்க, கட்டளை வரியில் இருந்து ஓவர்ஃப்ளோடெஸ்ட்டை இயக்குகிறோம்.
ta
technical
moderate
Note that after overflowed returns, the program crashes with a segmentation fault.
ஓவர்ஃப்ளோ திரும்பிய பிறகு, நிரல் ஒரு பிரிவுப் பிழையுடன் செயலிழக்கிறது என்பதை நினைவில் கொள்க.
ta
technical
moderate
This address is the same as the next four bytes on the stack after our return address.
இந்த முகவரி எங்கள் ரிட்டர்ன் முகவரிக்குப் பிறகு ஸ்டேக்கில் உள்ள அடுத்த நான்கு பைட்டுகளுக்குச் சமம்.
ta
technical
moderate
We sent execution straight to overflowed without normal function-calling things.
சாதாரண செயல்பாடு அழைக்கும் விஷயங்கள் இல்லாமல், செயல்படுத்தலை நேரடியாக ஓவர்ஃப்ளோவுக்கு அனுப்பினோம்.
ta
technical
moderate
In this chapter we looked at a simple C program with a buffer overflow vulnerability.
இந்த அத்தியாயத்தில், இடையக வழிதல் பாதிப்பு கொண்ட ஒரு எளிய சி நிரலைப் பார்த்தோம்.
ta
technical
moderate
We exploited this issue by writing a longer string to the command line than the program expected.
நிரல் எதிர்பார்த்ததை விட நீண்ட சரத்தை கட்டளை வரியில் எழுதுவதன் மூலம் இந்த சிக்கலைப் பயன்படுத்தினோம்.
ta
technical
moderate
We hijacked the program’s execution by overwriting a function’s return address with our own value.
ஒரு செயல்பாட்டின் ரிட்டர்ன் முகவரியை எங்கள் சொந்த மதிப்பைக் கொண்டு மேலெழுதி நிரலின் செயல்பாட்டைக் கடத்தினோம்.
ta
technical
moderate
In the next chapter, our example will focus on a Windows-based target and a real-world target program.
அடுத்த அத்தியாயத்தில், எங்கள் எடுத்துக்காட்டு விண்டோஸ் அடிப்படையிலான இலக்கு மற்றும் நிஜ உலக இலக்கு நிரலில் கவனம் செலுத்தும்.
ta
technical
moderate
When the function main calls function1, the next instruction to be executed is saved on the stack.
செயல்பாடு மெயின், செயல்பாடு 1 ஐ அழைக்கும்போது, ​​அடுத்த செயல்படுத்த வேண்டிய அறிவுறுத்தல் ஸ்டேக்கில் சேமிக்கப்படுகிறது.
ta
technical
complex
If we put more data in the stack buffer than it can hold, we will cause the buffer to overflow.
ஸ்டாக் இடையகத்தில் அது வைத்திருக்கக்கூடியதை விட அதிகமான தரவை வைத்தால், இடையகத்தை வழிதல் செய்ய வைப்போம்.
ta
technical
complex
We will attempt to overwrite the return pointer saved onto the stack when a function is called.
ஒரு செயல்பாடு அழைக்கப்பட்டால், ஸ்டேக்கில் சேமிக்கப்பட்ட ரிட்டர்ன் பாயிண்டரை மேலெழுத முயற்சிப்போம்.
ta
technical
complex
A search on Google for known vulnerabilities in War-FTP 1.65 finds the following information.
வார்-எஃப்டிபி 1.65 இல் அறியப்பட்ட பாதிப்புகளை கூகிளில் தேடுவது பின்வரும் தகவல்களைக் கண்டறிகிறது.
ta
technical
moderate
In this chapter, we will manually exploit War-FTP 1.65’s stack-based buffer overflow vulnerability.
இந்த அத்தியாயத்தில், வார்-எஃப்டிபி 1.65 இன் ஸ்டாக் அடிப்படையிலான இடையக வழிதல் பாதிப்பை நாங்கள் கைமுறையாகப் பயன்படுத்துவோம்.
ta
technical
complex
The issue we are going to exploit is particularly dangerous because an attacker does not need to log in.
நாங்கள் பயன்படுத்தப் போகும் பிரச்சனை மிகவும் ஆபத்தானது, ஏனெனில் ஒரு தாக்குபவர் உள்நுழைய வேண்டியதில்லை.
ta
technical
complex
The program crashed as expected, but this time our access violation is a bit different.
நிரல் எதிர்பார்த்தபடி செயலிழந்தது, ஆனால் இந்த முறை எங்கள் அணுகல் மீறல் சற்று வித்தியாசமானது.
ta
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 க்கு எழுதுவதன் மூலம் செயலிழந்தது.
ta
technical
complex
Looking at the top right of Immunity Debugger, the Registers pane, we see EAX contains the value 00B00000.
இம்யூனிட்டி டீபக்கரின் மேல் வலதுபுறத்தில் உள்ள ரெஜிஸ்டர்கள் பேனலைப் பார்க்கும்போது, EAX 00B00000 என்ற மதிப்பைக் கொண்டுள்ளது என்பதை நாங்கள் காண்கிறோம்.
ta
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 ஐ சிதைத்ததாகத் தெரிகிறது, ஏனெனில் நிரல் இப்போது எழுத முடியாத நினைவக இருப்பிடத்திற்கு எழுத முயற்சிக்கிறது.
ta
technical
complex
Before we write off this exploit and move on, take a look at the SEH chain.
இந்த சுரண்டலை நாங்கள் எழுதி முடிப்பதற்கு முன், SEH சங்கிலியைப் பாருங்கள்.
ta
technical
moderate
As shown in Figure 18-4, the structured exception handler has been overwritten with As.
படம் 18-4 இல் காட்டப்பட்டுள்ளபடி, கட்டமைக்கப்பட்ட விதிவிலக்கு கையாளுபவர் As உடன் மேலெழுதப்பட்டுள்ளார்.
ta
technical
simple
Recall that in the event of a crash, execution is passed to SEH.
ஒரு செயலிழப்பு ஏற்பட்டால், செயல்படுத்தல் SEH க்கு அனுப்பப்படும் என்பதை நினைவில் கொள்க.
ta
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 ஐக் கட்டுப்படுத்துவது இன்னும் செயல்படுத்தலை கடத்த அனுமதிக்குமா?
ta
technical
complex
As in the previous examples, we will put a useful memory address in the place of 41317441 to successfully hijack execution.
முந்தைய எடுத்துக்காட்டுகளில் உள்ளதைப் போல, வெற்றிகரமாக செயல்படுத்தலை கடத்துவதற்கு 41317441 க்கு பதிலாக ஒரு பயனுள்ள நினைவக முகவரியை வைப்போம்.
ta
technical
moderate
Also note in Figure 18-8 that when execution is passed to SEH, many of our registers have been zeroed out.
படம் 18-8 இல் கவனிக்கவும், செயல்படுத்தல் SEH க்கு அனுப்பப்படும்போது, ​​எங்கள் பல பதிவேடுகள் பூஜ்ஜியமாக்கப்பட்டுள்ளன.
ta
technical
moderate
Of the registers that have not been zeroed out, none appears to point to a portion of our attack string.
பூஜ்ஜியமாக்கப்படாத பதிவேடுகளில், எதுவும் எங்கள் தாக்குதல் சரத்தின் ஒரு பகுதியைச் சுட்டிக்காட்டுவதாகத் தெரியவில்லை.
ta
technical
moderate
Clearly, a simple JMP ESP in SEH will not work to redirect execution to attacker-controlled memory.
SEH இல் உள்ள ஒரு எளிய JMP ESP, தாக்குபவர் கட்டுப்படுத்தக்கூடிய நினைவகத்திற்கு செயல்படுத்தலை திருப்பிவிட வேலை செய்யாது.
ta
technical
complex
Though the contents of the ESP register do not point to any part of our cyclic pattern, two steps down from ESP, at ESP+8, we see that memory address 00AFD94 points to our cyclic pattern in memory.
ESP பதிவேட்டின் உள்ளடக்கம் எங்கள் சுழற்சி வடிவத்தின் எந்தப் பகுதியையும் சுட்டிக்காட்டவில்லை என்றாலும், ESP இலிருந்து இரண்டு படிகள் கீழே, ESP+8 இல், நினைவக முகவரி 00AFD94 எங்கள் சுழற்சி வடிவத்தை நினைவகத்தில் சுட்டிக்காட்டுவதை நாங்கள் காண்கிறோம்.
ta
technical
complex
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.
நாம் இரண்டு கூறுகளை அடுக்குக்கு அகற்ற ஒரு வழியைக் கண்டால், இந்த நினைவக முகவரியின் உள்ளடக்கத்தை இயக்கினால், வடிவத்திற்குப் பதிலாக ஷெல்கோடை இயக்க முடியும்.
ta
technical
complex
The location of NSEH is 00AFFD94, as noted by the output of Mona’s findmsp command.
NSEH இன் இருப்பிடம் 00AFFD94 ஆகும், இது மோனாவின் findmsp கட்டளையின் வெளியீட்டில் குறிப்பிடப்பட்டுள்ளது.
ta
technical
moderate
We can verify this by right-clicking 00AFFD94 in the stack pane and clicking Follow in Stack.
ஸ்டாக் பேனில் 00AFFD94 ஐ வலது கிளிக் செய்து, ஸ்டாக்கில் பின்தொடர் என்பதைக் கிளிக் செய்வதன் மூலம் இதை சரிபார்க்கலாம்.
ta
technical
simple
If we can load ESP+8 into EIP, we can execute some shellcode.
ESP+8 ஐ EIP இல் ஏற்ற முடிந்தால், சில ஷெல்கோடை இயக்க முடியும்.
ta
technical
moderate
We need to find an instance of POP POP RET instructions in War-FTP or its executable modules.
War-FTP அல்லது அதன் செயல்படுத்தக்கூடிய தொகுதிகளில் POP POP RET வழிமுறைகளின் நிகழ்வைக் கண்டுபிடிக்க வேண்டும்.
ta
technical
moderate
Programs compiled with SafeSEH record the memory locations that will be used for structured exception handling, which means that attempts to redirect execution to a memory location with POP POP RET instructions will fail the SafeSEH check.
SafeSEH உடன் தொகுக்கப்பட்ட நிரல்கள், கட்டமைக்கப்பட்ட விதிவிலக்கு கையாளுதலுக்குப் பயன்படுத்தப்படும் நினைவக இருப்பிடங்களைப் பதிவு செய்கின்றன, அதாவது POP POP RET வழிமுறைகளுடன் ஒரு நினைவக இருப்பிடத்திற்கு செயல்படுத்தலை திருப்பி அனுப்பும் முயற்சிகள் SafeSEH சரிபார்ப்பில் தோல்வியடையும்.
ta
technical
complex
Mona will determine which modules are not compiled with SafeSEH in the process of finding the POP POP RET instructions when we use the command !mona seh.
நாம் !mona seh கட்டளையைப் பயன்படுத்தும் போது, ​​POP POP RET வழிமுறைகளைக் கண்டுபிடிக்கும் செயல்பாட்டில் SafeSEH உடன் தொகுக்கப்படாத தொகுதிகளை மோனா தீர்மானிப்பார்.
ta
technical
complex
The program crashes again, and, as expected, SEH is overwritten with 5F4580CA.
நிரல் மீண்டும் செயலிழக்கிறது, எதிர்பார்த்தபடி, SEH ஆனது 5F4580CA உடன் மேலெழுதப்படுகிறது.
ta
technical
moderate
We have successfully built an SEH overwrite exploit for War-FTP.
நாம் வெற்றிகரமாக War-FTP க்கான SEH மேலெழுதும் சுரண்டலை உருவாக்கியுள்ளோம்.
ta
technical
moderate
In such cases, knowing the steps to exploit this sort of crash is paramount to creating a working exploit.
இத்தகைய சந்தர்ப்பங்களில், இந்த வகையான செயலிழப்பைச் சுரண்டுவதற்கான படிகளை அறிவது, வேலை செய்யும் சுரண்டலை உருவாக்குவதற்கு மிக முக்கியமானது.
ta
technical
complex
We will look at using a technique called fuzzing to find potential exploits in vulnerable programs.
취약한 நிரல்களில் சாத்தியமான சுரண்டல்களைக் கண்டறிய, ஃபஸிங் எனப்படும் நுட்பத்தைப் பயன்படுத்துவதைப் பார்ப்போம்.
ta
technical
moderate
When auditing the source code of this program, we see the strcpy function.
இந்த நிரலின் மூலக் குறியீட்டைத் தணிக்கை செய்யும் போது, ​​strcpy செயல்பாட்டைப் பார்க்கிறோம்.
ta
technical
moderate
We can use fuzzing to send various inputs to the program that the developer never intended the code to process.
டெவலப்பர் ஒருபோதும் குறியீட்டை செயலாக்க வேண்டும் என்று நினைக்காத பல்வேறு உள்ளீடுகளை நிரலுக்கு அனுப்ப ஃபஸிங்கை பயன்படுத்தலாம்.
ta
technical
moderate
If we can find input that will manipulate memory in a controllable way, we may be able to exploit the program.
கட்டுப்படுத்தக்கூடிய முறையில் நினைவகத்தை கையாளும் உள்ளீட்டைக் கண்டால், நிரலைச் சுரண்ட முடியும்.
ta
technical
moderate
We can use fuzzing techniques to trigger crashes, which we can use to build exploits.
செயலிழப்புகளைத் தூண்டுவதற்கு ஃபஸிங் நுட்பங்களைப் பயன்படுத்தலாம், அவற்றை சுரண்டல்களை உருவாக்கப் பயன்படுத்தலாம்.
ta
technical
moderate
Let’s look at an example of fuzzing a Trivial FTP (TFTP) server to find an exploitable vulnerability.
சுரண்டக்கூடிய பாதிப்பைக் கண்டறிய, ஒரு Trivial FTP (TFTP) சேவையகத்தை ஃபஸிங் செய்வதற்கான ஒரு உதாரணத்தைப் பார்ப்போம்.
ta
technical
moderate
Because it is connectionless, we will need to know the syntax for TFTP communication to send UDP packets that the TFTP software will attempt to process.
இது இணைப்பற்றது என்பதால், TFTP மென்பொருள் செயலாக்க முயற்சிக்கும் UDP பாக்கெட்டுகளை அனுப்ப TFTP தொடர்புக்கான தொடரியலை நாம் தெரிந்து கொள்ள வேண்டும்.
ta
technical
complex
When considering stack-based buffer overflow attacks, look for places where the user controls the size and content of the input.
ஸ்டாக் அடிப்படையிலான இடையக வழிதல் தாக்குதல்களைக் கருத்தில் கொள்ளும்போது, ​​பயனர் உள்ளீட்டின் அளவு மற்றும் உள்ளடக்கத்தை கட்டுப்படுத்தும் இடங்களைத் தேடுங்கள்.
ta
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 எழுத்துக்கள் கொண்ட கோப்பு பெயரை உள்ளிடுவார் என்று எதிர்பார்க்கவில்லை.
ta
technical
moderate
The next field is a null byte, which signifies the end of the filename.
அடுத்த புலம் ஒரு பூஜ்ய பைட்டாகும், இது கோப்பு பெயரின் முடிவைக் குறிக்கிறது.
ta
technical
simple
We can’t control this field, but we can control the fourth field, Mode, which is a user-controlled variable string.
இந்த புலத்தை நம்மால் கட்டுப்படுத்த முடியாது, ஆனால் நான்காவது புலத்தை, பயனர் கட்டுப்படுத்தும் மாறி சரமாக இருக்கும் பயன்முறையை நம்மால் கட்டுப்படுத்த முடியும்.
ta
technical
moderate
For our fuzzing exercise, we will craft a succession of legitimate TFTP packets with bogus and increasingly long input in the Mode field.
எங்கள் ஃபஸிங் பயிற்சிக்கு, பயன்முறை புலத்தில் போலி மற்றும் பெருகிய முறையில் நீண்ட உள்ளீட்டுடன், முறையான TFTP பாக்கெட்டுகளின் தொடர்ச்சியை உருவாக்குவோம்.
ta
technical
complex
If the TFTP processes the packets correctly, it should say the Mode is unrecognized and stop processing the packet.
TFTP பாக்கெட்டுகளை சரியாகச் செயலாக்கினால், பயன்முறை அங்கீகரிக்கப்படவில்லை என்று கூறி, பாக்கெட்டை செயலாக்குவதை நிறுத்த வேண்டும்.
ta
technical
moderate
We have used the mode 02 (write request) and the filename Georgia.
நாம் பயன்முறை 02 (எழுதுதல் கோரிக்கை) மற்றும் ஜார்ஜியா என்ற கோப்பு பெயரைப் பயன்படுத்தியுள்ளோம்.
ta
technical
simple
Our string of As from the array are put into the Mode field.
வரிசையிலிருந்து வரும் எங்கள் 'A' சரங்கள் பயன்முறை புலத்தில் வைக்கப்படுகின்றன.
ta
technical
simple
Because TFTP is a UDP protocol, we need to set up a UDP socket as opposed to a TCP socket, so the syntax is slightly different.
TFTP ஒரு UDP நெறிமுறை என்பதால், TCP சாக்கெட்டுக்கு பதிலாக UDP சாக்கெட்டை அமைக்க வேண்டும், எனவே தொடரியல் சற்று வித்தியாசமானது.
ta
technical
moderate
We see that it has crashed with 41414141 in EIP.
EIP இல் 41414141 உடன் அது செயலிழந்ததைக் காண்கிறோம்.
ta
technical
simple
Windows XP does not use ASLR, discussed later in this chapter, so USER32.dll is loaded into the same memory location on all Windows XP SP3 English platforms.
இந்த அத்தியாயத்தில் பின்னர் விவாதிக்கப்படும் ASLR ஐ விண்டோஸ் XP பயன்படுத்தாது, எனவே USER32.dll அனைத்து விண்டோஸ் XP SP3 ஆங்கில தளங்களிலும் ஒரே நினைவக இடத்தில் ஏற்றப்படும்.
ta
technical
moderate
We have taken advantage of static DLL locations in our previous exploit exercises.
முந்தைய சுரண்டல் பயிற்சிகளில் நிலையான DLL இருப்பிடங்களைப் பயன்படுத்தியுள்ளோம்.
ta
technical
moderate
We need not have a copy of 3Com TFTP running to find the memory locations of instructions in Windows components.
விண்டோஸ் கூறுகளில் உள்ள வழிமுறைகளின் நினைவக இருப்பிடங்களைக் கண்டறிய 3Com TFTP இன் நகல் வைத்திருக்க வேண்டியதில்லை.
ta
technical
moderate
For example, as shown in Figure 19-4, from debugging War-FTP, we can search for a JMP ESI instruction in USER32.dll.
உதாரணமாக, படம் 19-4 இல் காட்டப்பட்டுள்ளபடி, War-FTP ஐ பிழைத்திருத்தம் செய்வதிலிருந்து, USER32.dll இல் JMP ESI வழிமுறையைத் தேடலாம்.
ta
technical
moderate
(It is a good idea to stick with the DLL noted in the original exploit if we don’t have a copy of the program.
நிரலின் நகல் நம்மிடம் இல்லையென்றால், அசல் சுரண்டலில் குறிப்பிடப்பட்ட DLL உடன் ஒட்டிக்கொள்வது நல்லது.
ta
technical
moderate
We can’t be sure the program loads MSVCRT.dll, for example.)
உதாரணமாக, நிரல் MSVCRT.dll ஐ ஏற்றுகிறது என்பதை நம்மால் உறுதியாகச் சொல்ல முடியாது.
ta
technical
moderate
Of course, in our case, we have 3Com TFTP locally, but if we didn’t have access to the app, we could use Mona to look for JMP instructions inside a specific module.
நிச்சயமாக, எங்கள் விஷயத்தில், எங்களிடம் 3Com TFTP உள்ளது, ஆனால் பயன்பாட்டிற்கு அணுகல் இல்லையென்றால், ஒரு குறிப்பிட்ட தொகுதியின் உள்ளே JMP வழிமுறைகளைத் தேட மோனாவைப் பயன்படுத்தலாம்.
ta
technical
complex
For example, we could look for instances of JMP ESI (or the equivalent) with the command !mona jmp -r esi -m user32, as shown in Figure 19-4.
உதாரணமாக, படம் 19-4 இல் காட்டப்பட்டுள்ளபடி, !mona jmp -r esi -m user32 என்ற கட்டளையுடன் JMP ESI (அல்லது அதற்கு சமமான) நிகழ்வுகளைத் தேடலாம்.
ta
technical
complex
And we find a JMP ESI instruction at the memory address 7E45AE4E in USER32.dll on Windows XP SP3.
மேலும், விண்டோஸ் XP SP3 இல் USER32.dll இல் 7E45AE4E என்ற நினைவக முகவரியில் JMP ESI வழிமுறையைக் காண்கிறோம்.
ta
technical
moderate
If we change the jmp_2000 variable to this value in little-endian format, this exploit should work for our platform.
jmp_2000 மாறியை சிறிய-எண்டியன் வடிவத்தில் இந்த மதிப்பாக மாற்றினால், இந்த சுரண்டல் எங்கள் தளத்தில் வேலை செய்ய வேண்டும்.
ta
technical
moderate
Replacing Shellcode As noted earlier, we also need to replace the shellcode with code generated by Msfvenom.
ஷெல்கோடை மாற்றுதல் முன்பு குறிப்பிட்டபடி, Msfvenom ஆல் உருவாக்கப்பட்ட குறியீட்டுடன் ஷெல்கோடை மாற்ற வேண்டும்.
ta
technical
moderate
We can use a bind shell or any Windows payload that will fit in 344 + 129 bytes (the included shellcode plus the NOP sled).
நாம் ஒரு பைண்ட் ஷெல்லைப் பயன்படுத்தலாம் அல்லது 344 + 129 பைட்டுகளில் பொருந்தக்கூடிய எந்த விண்டோஸ் பேலோடையும் பயன்படுத்தலாம் (சேர்க்கப்பட்ட ஷெல்கோடு மற்றும் NOP ஸ்லெட்).
ta
technical
moderate
The only bad character we need to avoid this time is the null byte.
இந்த நேரத்தில் நாம் தவிர்க்க வேண்டிய ஒரே மோசமான எழுத்து பூஜ்ய பைட்டாகும்.
ta
technical
simple
Tell Msfvenom to out- put the payload in Perl format so we can easily add it to our exploit.
எங்கள் சுரண்டலில் எளிதாகச் சேர்க்க, Msfvenom பேலோடை பெர்ல் வடிவத்தில் வெளியிடுமாறு சொல்லுங்கள்.
ta
technical
moderate
Our generated shellcode from Msfvenom is 368 bytes, whereas the original shellcode in the public exploit was 344 bytes.
Msfvenom இலிருந்து உருவாக்கப்பட்ட எங்கள் ஷெல்கோடு 368 பைட்டுகள், அதே நேரத்தில் பொது சுரண்டலில் இருந்த அசல் ஷெல்கோடு 344 பைட்டுகளாகும்.
ta
technical
moderate
Now make the changes to the original exploit code shown in Listing 19-6.
இப்போது பட்டியல் 19-6 இல் காட்டப்பட்டுள்ள அசல் சுரண்டல் குறியீட்டில் மாற்றங்களைச் செய்யுங்கள்.
ta
technical
simple
We delete the NOP sled and pad our exploit string with 105 bytes after the shellcode, so our return address still ends up hijacking EIP.
NOP ஸ்லெட்டை நீக்கி, ஷெல்கோட்டிற்குப் பிறகு 105 பைட்டுகளுடன் எங்கள் சுரண்டல் சரத்தை நிரப்புகிறோம், எனவே எங்கள் திரும்பும் முகவரி இன்னும் EIP ஐ கடத்துகிறது.
ta
technical
complex
If you’ve done everything correctly, when you run the ported exploit, a bind shell with System privileges will open on TCP port 4444, as shown in Listing 19-7.
நீங்கள் எல்லாவற்றையும் சரியாகச் செய்திருந்தால், போர்ட் செய்யப்பட்ட சுரண்டலை இயக்கும்போது, ​​சிஸ்டம் சலுகைகளுடன் கூடிய ஒரு பைண்ட் ஷெல் TCP போர்ட் 4444 இல் திறக்கும், இது பட்டியல் 19-7 இல் காட்டப்பட்டுள்ளது.
ta
technical
complex
In this section, we will look at the basics of writing our own Metasploit exploit module.
இந்த பிரிவில், எங்கள் சொந்த மெட்டாஸ்ப்ளோயிட் சுரண்டல் தொகுதியை எழுதுவதற்கான அடிப்படைகளைப் பார்ப்போம்.
ta
technical
moderate
We’ll start with the module futuresoft_transfermode.rb.
நாங்கள் futuresoft_transfermode.rb தொகுதியுடன் தொடங்குவோம்.
ta
technical
simple