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. | അത് ഓൺ ചെയ്തു വെച്ചു. | ml | technical | simple |
The -z execstack compiler option makes the stack executable, disabling another buffer overflow prevention method. | -z execstack എന്ന കംപൈലർ ഓപ്ഷൻ, സ്റ്റാക്ക് എക്സിക്യൂട്ടബിൾ ആക്കുന്നു, ഇത് മറ്റൊരു ബഫർ ഓവർഫ്ലോ പ്രതിരോധ രീതി പ്രവർത്തനരഹിതമാക്കുന്നു. | ml | technical | moderate |
We tell GCC to compile overflowtest.c into an executable called overflowtest with the -o option. | overflowtest.c എന്ന ഫയൽ -o എന്ന ഓപ്ഷൻ ഉപയോഗിച്ച് overflowtest എന്ന് പേരുള്ള ഒരു എക്സിക്യൂട്ടബിൾ ആയി കംപൈൽ ചെയ്യാൻ ഞങ്ങൾ GCC യോട് പറയുന്നു. | ml | 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-ലേക്ക് നൽകുന്നു, ഇത് മൂല്യം അഞ്ച് പ്രതീകങ്ങളുള്ള ഒരു പ്രാദേശിക വേരിയബിളിലേക്ക് പകർത്തുന്നു എന്ന് ഓർക്കുക. | ml | technical | complex |
Let’s run the program with the command line argument AAAA, as shown here. | ഇവിടെ കാണിച്ചിരിക്കുന്നതുപോലെ, AAAA എന്ന കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക. | ml | technical | simple |
Make overflowtest executable with chmod if necessary. | ആവശ്യമെങ്കിൽ chmod ഉപയോഗിച്ച് overflowtest എക്സിക്യൂട്ടബിൾ ആക്കുക. | ml | technical | simple |
We use four As instead of five because a string ends with a null byte. | ഒരു സ്ട്രിംഗ് ഒരു നൾ ബൈറ്റിൽ അവസാനിക്കുന്നതുകൊണ്ട് അഞ്ചിനുപകരം നാല് 'A' ഉപയോഗിക്കുന്നു. | ml | technical | moderate |
Technically, if we used five As, we would already be overflowing the buffer, albeit by just one character. | സാങ്കേതികമായി, അഞ്ച് 'A' ഉപയോഗിച്ചിരുന്നെങ്കിൽ, ഒരു പ്രതീകം കൊണ്ട് പോലും ബഫർ ഓവർഫ്ലോ ഉണ്ടാകുമായിരുന്നു. | ml | technical | moderate |
Executed normally | സാധാരണയായി നടപ്പിലാക്കി | ml | technical | simple |
As shown, the program does what we expected: main calls function1, function1 copies AAAA into buffer, function1 returns execution to main, and main prints “Executed normally” to the console before the program exits. | കാണിച്ചിരിക്കുന്നതുപോലെ, പ്രോഗ്രാം നമ്മൾ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നു: main function1-നെ വിളിക്കുന്നു, function1 AAAA-യെ ബഫറിലേക്ക് പകർത്തുന്നു, function1 main-ലേക്ക് എക്സിക്യൂഷൻ തിരികെ നൽകുന്നു, പ്രോഗ്രാം പുറത്തുകടക്കുന്നതിന് മുമ്പ് main “സാധാരണയായി നടപ്പിലാക്കി” എന്ന് കൺസോളിൽ പ്രിന്റ് ചെയ്യുന്നു. | ml | technical | complex |
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-ന് ചില অপ্রত্যাশিত ഇൻപുട്ട് നൽകുകയാണെങ്കിൽ, ബഫർ ഓവർഫ്ലോ ഉണ്ടാക്കാൻ സഹായിക്കുന്ന രീതിയിൽ ഇത് പ്രവർത്തിക്കാൻ നമുക്ക് നിർബന്ധിക്കാൻ കഴിയും. | ml | technical | complex |
Causing a Crash Now let’s try giving the program a long string of As as an argument, as shown here. | ഒരു ക്രാഷ് ഉണ്ടാക്കുന്നു, ഇപ്പോൾ നമുക്ക് പ്രോഗ്രാമിന് ഒരുപാട് 'A' എന്ന അക്ഷരങ്ങൾ ഒരു ആർഗ്യുമെന്റായി നൽകി ശ്രമിക്കാം, ഇവിടെ കാണിച്ചിരിക്കുന്നതുപോലെ. | ml | technical | moderate |
Segmentation fault | സെഗ്മെന്റേഷൻ പിഴവ് | ml | technical | simple |
This time, the program crashes with a segmentation fault. | ഇത്തവണ, പ്രോഗ്രാം ഒരു സെഗ്മെന്റേഷൻ പിഴവ് കാരണം തകരുന്നു. | ml | technical | simple |
Our pro- gram’s problem lies with the implementation of strcpy, which we use in function1. | നമ്മുടെ പ്രോഗ്രാമിന്റെ പ്രശ്നം function1-ൽ ഉപയോഗിക്കുന്ന strcpy-യുടെ നടപ്പാക്കലിലാണ്. | ml | 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 ഫംഗ്ഷൻ ഒരു സ്ട്രിംഗ് എടുത്ത് മറ്റൊന്നിലേക്ക് പകർത്തുന്നു, എന്നാൽ നൽകിയിട്ടുള്ള ആർഗ്യുമെന്റ് ലക്ഷ്യസ്ഥാന സ്ട്രിംഗ് വേരിയബിളിലേക്ക് ചേരുമെന്ന് ഉറപ്പാക്കാൻ ഇത് ബൗണ്ട്സ് പരിശോധനയൊന്നും ചെയ്യുന്നില്ല. | ml | 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 ഫംഗ്ഷൻ, നമ്മുടെ അഞ്ച് പ്രതീകങ്ങളുള്ള ലക്ഷ്യസ്ഥാന സ്ട്രിംഗിലേക്ക് മൂന്ന്, അഞ്ച് അല്ലെങ്കിൽ നൂറുകണക്കിന് പ്രതീകങ്ങൾ പകർത്താൻ ശ്രമിക്കും. | ml | 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 എണ്ണം സ്റ്റാക്കിലെ അടുത്തടുത്തുള്ള മെമ്മറി വിലാസങ്ങളിലെ ഡാറ്റയെ തിരുത്തിയെഴുതും. | ml | technical | complex |
We could potentially overwrite the rest of function1’s stack frame and even higher memory. | നമുക്ക് function1-ന്റെ സ്റ്റാക്ക് ഫ്രെയിമിന്റെ ബാക്കിയുള്ള ഭാഗവും അതിലും ഉയർന്ന മെമ്മറിയും തിരുത്തിയെഴുതാൻ കഴിയും. | ml | technical | moderate |
Remember what’s at the memory address immedi- ately after the base of that stack frame? | ആ സ്റ്റാക്ക് ഫ്രെയിമിന്റെ അടിത്തറയ്ക്ക് തൊട്ടുപിന്നിലുള്ള മെമ്മറി വിലാസത്തിൽ എന്താണുള്ളതെന്ന് ഓർക്കുക? | ml | technical | moderate |
Our Ubuntu virtual machine has an Intel architecture, which is little endian. | നമ്മുടെ Ubuntu വിർച്വൽ മെഷീന് ഒരു Intel ആർക്കിടെക്ചർ ഉണ്ട്, ഇത് ചെറിയ എൻഡിയൻ ആണ്. | ml | technical | moderate |
To account for little-endian architecture, we need to flip the bytes of our memory address around. | ചെറിയ എൻഡിയൻ ആർക്കിടെക്ചർ കണക്കിലെടുക്കാൻ, നമ്മുടെ മെമ്മറി വിലാസത്തിന്റെ ബൈറ്റുകൾ മാറ്റേണ്ടതുണ്ട്. | ml | technical | moderate |
Using the return address with the byte order flipped for our Intel architecture fixes our problem. | നമ്മുടെ Intel ആർക്കിടെക്ചറിനായി ബൈറ്റ് ഓർഡർ മാറ്റി ഉപയോഗിക്കുന്നത് പ്രശ്നം പരിഹരിക്കുന്നു. | ml | technical | moderate |
This time when we hit the breakpoint, our return address looks correct. | ഈ സമയം, ബ്രേക്ക്പോയിന്റിൽ എത്തുമ്പോൾ, ഞങ്ങളുടെ റിട്ടേൺ വിലാസം ശരിയായി കാണപ്പെടുന്നു. | ml | technical | moderate |
Sure enough, when we let the program continue, “Execution Hijacked” is printed to the console. | തീർച്ചയായും, പ്രോഗ്രാം തുടരാൻ അനുവദിക്കുമ്പോൾ, “Execution Hijacked” എന്ന വാചകം കൺസോളിൽ പ്രിന്റ് ചെയ്യപ്പെടുന്നു. | ml | technical | moderate |
We have successfully hijacked execution and exploited a buffer overflow vulnerability. | ഞങ്ങൾ വിജയകരമായി എക്സിക്യൂഷൻ ഹൈജാക്ക് ചെയ്യുകയും ഒരു ബഫർ ഓവർഫ്ലോ ദുർബലത ചൂഷണം ചെയ്യുകയും ചെയ്തു. | ml | technical | complex |
To see the results outside the debugger, we run overflowtest from the command line. | ഡീബഗ്ഗറിന് പുറത്തുള്ള ഫലങ്ങൾ കാണുന്നതിന്, കമാൻഡ് ലൈനിൽ നിന്ന് overflowtest പ്രവർത്തിപ്പിക്കുക. | ml | technical | moderate |
Note that after overflowed returns, the program crashes with a segmentation fault. | ഓവർഫ്ലോ റിട്ടേണുകൾക്ക് ശേഷം, പ്രോഗ്രാം ഒരു സെഗ്മെന്റേഷൻ ഫോൾട്ടോടെ ക്രാഷ് ചെയ്യുന്നത് ശ്രദ്ധിക്കുക. | ml | technical | moderate |
This address is the same as the next four bytes on the stack after our return address. | ഈ വിലാസം ഞങ്ങളുടെ റിട്ടേൺ വിലാസത്തിന് ശേഷമുള്ള സ്റ്റാക്കിലെ അടുത്ത നാല് ബൈറ്റുകൾക്ക് തുല്യമാണ്. | ml | technical | moderate |
We sent execution straight to overflowed without normal function-calling things. | സാധാരണ ഫംഗ്ഷൻ-കോളിംഗ് ഇല്ലാതെ ഞങ്ങൾ എക്സിക്യൂഷൻ നേരിട്ട് ഓവർഫ്ലോയിലേക്ക് അയച്ചു. | ml | technical | complex |
In this chapter we looked at a simple C program with a buffer overflow vulnerability. | ഈ അധ്യായത്തിൽ, ബഫർ ഓവർഫ്ലോ ദുർബലതയുള്ള ഒരു ലളിതമായ C പ്രോഗ്രാം നമ്മൾ പരിശോധിച്ചു. | ml | technical | moderate |
We exploited this issue by writing a longer string to the command line than the program expected. | പ്രോഗ്രാം പ്രതീക്ഷിച്ചതിനേക്കാൾ വലിയ ഒരു സ്ട്രിംഗ് കമാൻഡ് ലൈനിൽ എഴുതി ഈ പ്രശ്നം ഞങ്ങൾ ചൂഷണം ചെയ്തു. | ml | technical | complex |
In this chapter, we will look at exploiting a stack-based buffer overflow in an older version of a Windows-based FTP server. | ഈ അധ്യായത്തിൽ, വിൻഡോസ് അടിസ്ഥാനമാക്കിയുള്ള FTP സെർവറിന്റെ പഴയ പതിപ്പിലെ സ്റ്റാക്ക്-അടിസ്ഥാനത്തിലുള്ള ബഫർ ഓവർഫ്ലോ എങ്ങനെ ചൂഷണം ചെയ്യാമെന്ന് നോക്കാം. | ml | technical | complex |
When the function main calls function1, the next instruction to be executed is saved on the stack. | മെയിൻ ഫംഗ്ഷൻ function1-നെ വിളിക്കുമ്പോൾ, എക്സിക്യൂട്ട് ചെയ്യേണ്ട അടുത്ത നിർദ്ദേശം സ്റ്റാക്കിൽ സേവ് ചെയ്യപ്പെടും. | ml | technical | moderate |
If we put more data in the stack buffer than it can hold, we will cause the buffer to overflow. | സ്റ്റാക്ക് ബഫറിന് ഉൾക്കൊള്ളാൻ കഴിയുന്നതിനേക്കാൾ കൂടുതൽ ഡാറ്റ നൽകിയാൽ, ബഫർ ഓവർഫ്ലോ ഉണ്ടാകും. | ml | technical | moderate |
In Chapter 1, we installed War-FTP version 1.65 on the Windows XP target. | ഒന്നാം അധ്യായത്തിൽ, വിൻഡോസ് XP ടാർഗെറ്റിൽ War-FTP പതിപ്പ് 1.65 ഇൻസ്റ്റാൾ ചെയ്തു. | ml | technical | simple |
A search on Google for known vulnerabilities in War-FTP 1.65 finds the following information. | War-FTP 1.65-ലെ അറിയപ്പെടുന്ന സുരക്ഷാ പ്രശ്നങ്ങളെക്കുറിച്ച് Google-ൽ നടത്തിയ തിരച്ചിൽ താഴെ പറയുന്ന വിവരങ്ങൾ നൽകുന്നു. | ml | technical | simple |
War-FTP is prone to a stack-based buffer-overflow vulnerability. | War-FTP ഒരു സ്റ്റാക്ക്-അടിസ്ഥാനത്തിലുള്ള ബഫർ-ഓവർഫ്ലോ ദുർബലതയ്ക്ക് സാധ്യതയുണ്ട്. | ml | technical | simple |
In this chapter, we will manually exploit War-FTP 1.65’s stack-based buffer overflow vulnerability. | ഈ അധ്യായത്തിൽ, War-FTP 1.65-ൻ്റെ സ്റ്റാക്ക്-അടിസ്ഥാനത്തിലുള്ള ബഫർ ഓവർഫ്ലോ ദുർബലത ഞങ്ങൾ സ്വമേധയാ ചൂഷണം ചെയ്യും. | ml | technical | complex |
Before we dive in and start trying to exploit War-FTP, let’s hook it up to a debugger. | War-FTP-യെ ചൂഷണം ചെയ്യാൻ ശ്രമിക്കുന്നതിന് മുമ്പ്, നമുക്ക് അതിനെ ഒരു ഡീബഗ്ഗറുമായി ബന്ധിപ്പിക്കാം. | ml | technical | moderate |
The War-FTP executable and MFC42.dll are involved in this process. | ഈ പ്രക്രിയയിൽ War-FTP എക്സിക്യൂട്ടബിളും MFC42.dll ഉം ഉൾപ്പെടുന്നു. | ml | technical | moderate |
We need to choose a POP POP RET instruction from Mona's output. | Mona-യുടെ ഔട്ട്പുട്ടിൽ നിന്ന് ഒരു POP POP RET നിർദ്ദേശം തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. | ml | technical | moderate |
Avoid the four bad characters discussed in Chapter 17. | 17-ാം അധ്യായത്തിൽ ചർച്ച ചെയ്ത നാല് മോശം പ്രതീകങ്ങൾ ഒഴിവാക്കുക. | ml | technical | simple |
One such address is 5F4580CA. | അത്തരത്തിലുള്ള ഒരു വിലാസമാണ് 5F4580CA. | ml | technical | simple |
The instructions are POP EBX, POP EBP, RET. | നിർദ്ദേശങ്ങൾ ഇതാ: POP EBX, POP EBP, RET. | ml | technical | simple |
We don’t care where the instructions are stored. | നിർദ്ദേശങ്ങൾ എവിടെയാണ് സംഭരിച്ചിരിക്കുന്നതെന്ന് ഞങ്ങൾ ശ്രദ്ധിക്കുന്നില്ല. | ml | technical | simple |
If we overwrite SEH with the address 5F4580CA, these instructions will be executed. | SEH 5F4580CA എന്ന വിലാസത്തിലേക്ക് തിരുത്തിയെഴുതിയാൽ, ഈ നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കും. | ml | technical | moderate |
We will redirect execution to our attack string. | ഞങ്ങൾ എക്സിക്യൂഷൻ നമ്മുടെ ആക്രമണ ശൃംഖലയിലേക്ക് റീഡയറക്ട് ചെയ്യും. | ml | technical | moderate |
Set a breakpoint at 5F4580CA. | 5F4580CA-ൽ ഒരു ബ്രേക്ക്പോയിന്റ് സ്ഥാപിക്കുക. | ml | technical | simple |
Replace the four Cs in the previous exploit. | മുമ്പത്തെ എക്സ്പ്ലോയിറ്റിലെ നാല് Cs മാറ്റിസ്ഥാപിക്കുക. | ml | technical | moderate |
Run the exploit again. | വീണ്ടും എക്സ്പ്ലോയിറ്റ് പ്രവർത്തിപ്പിക്കുക. | ml | technical | simple |
The program crashes again. | പ്രോഗ്രാം വീണ്ടും തകരുന്നു. | ml | technical | simple |
SEH is overwritten with 5F4580CA. | SEH 5F4580CA ഉപയോഗിച്ച് തിരുത്തിയെഴുതുന്നു. | ml | technical | simple |
Let the program pass the overwritten exception handler. | പ്രോഗ്രാമിനെ തിരുത്തിയെഴുതിയ എക്സെപ്ഷൻ കൈകാര്യം ചെയ്യുന്നയാൾ കടന്നുപോകുവാൻ അനുവദിക്കുക. | ml | technical | moderate |
We hit our breakpoint. | ഞങ്ങൾ ബ്രേക്ക്പോയിന്റിൽ എത്തി. | ml | technical | simple |
The CPU pane shows the next instructions to be executed. | CPU പാനൽ അടുത്തതായി നടപ്പിലാക്കേണ്ട നിർദ്ദേശങ്ങൾ കാണിക്കുന്നു. | ml | technical | moderate |
Press F7 to step through the instructions. | നിർദ്ദേശങ്ങളിലൂടെ കടന്നുപോകുവാൻ F7 അമർത്തുക. | ml | technical | simple |
Watch what happens to the stack. | എന്താണ് സംഭവിക്കുന്നതെന്ന് ശ്രദ്ധിക്കുക. | ml | technical | simple |
We end up in our attack string. | നമ്മൾ നമ്മുടെ ആക്രമണ ശൃംഖലയിൽ എത്തുന്നു. | ml | technical | moderate |
We have solved our first problem. | നമ്മൾ നമ്മുടെ ആദ്യത്തെ പ്രശ്നം പരിഹരിച്ചു. | ml | technical | simple |
The program crashes as expected, but this time our access violation is a bit different from the one in Chapter 17. | പ്രോഗ്രാം പ്രതീക്ഷിച്ചതുപോലെ തകരുന്നു, എന്നാൽ ഈ സമയം നമ്മുടെ ആക്സസ് ലംഘനം 17-ാം അധ്യായത്തിലുള്ളതിൽ നിന്ന് അൽപ്പം വ്യത്യസ്തമാണ്. | ml | technical | moderate |
EIP points to 0x77C3F973, a valid instruction inside MSVCRT.dll. | EIP, MSVCRT.dll-നുള്ളിലെ സാധുവായ ഒരു നിർദ്ദേശമായ 0x77C3F973-ലേക്ക് ചൂണ്ടുന്നു. | ml | 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-ലേക്ക് എഴുതി തകർന്നു. | ml | 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 ആണെന്ന് ശ്രദ്ധിക്കുക. | ml | technical | moderate |
Basically, the program is trying to write to the memory location of the value of EAX. | അടിസ്ഥാനപരമായി, EAX-ൻ്റെ മൂല്യത്തിന്റെ മെമ്മറി സ്ഥാനത്തേക്ക് എഴുതാൻ പ്രോഗ്രാം ശ്രമിക്കുന്നു. | ml | technical | moderate |
Looking at the top right of Immunity Debugger, the Registers pane, we see EAX contains the value 00B00000. | ഇമ്മ്യൂണിറ്റി ഡീബഗ്ഗറിൻ്റെ മുകളിൽ വലതുവശത്ത്, രജിസ്റ്ററുകൾ കാണുകയാണെങ്കിൽ, EAX-ൽ 00B00000 എന്ന മൂല്യം അടങ്ങിയിരിക്കുന്നു. | ml | 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-നെ നശിപ്പിച്ചതായി തോന്നുന്നു, കാരണം പ്രോഗ്രാം ഇപ്പോൾ എഴുതാൻ കഴിയാത്ത ഒരു മെമ്മറി സ്ഥാനത്തേക്ക് എഴുതാൻ ശ്രമിക്കുന്നു. | ml | technical | complex |
Without EIP control, is this crash still viable? | EIP നിയന്ത്രണമില്ലാതെ, ഈ തകർച്ച ഇപ്പോഴും സാധുതയുള്ളതാണോ? | ml | technical | moderate |
Really long attack strings frequently cause an exception by trying to write data off the end of the stack. | വളരെ നീളമുള്ള ആക്രമണ ശൃംഖലകൾ സ്റ്റാക്കിൻ്റെ അവസാനം ഡാറ്റ എഴുതാൻ ശ്രമിക്കുന്നതിലൂടെ പലപ്പോഴും ഒരു ഒഴിവാക്കലിന് കാരണമാകുന്നു. | ml | technical | complex |
Before we write off this exploit and move on, take a look at the SEH chain. | ഈ ചൂഷണത്തെക്കുറിച്ച് എഴുതുന്നതിനും തുടർന്ന് പോകുന്നതിനും മുമ്പ്, SEH ശൃംഖലയിലേക്ക് ഒന്നു നോക്കുക. | ml | technical | moderate |
As shown in Figure 18-4, the structured exception handler has been overwritten with As. | ചിത്രം 18-4-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, ഘടനാപരമായ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യുന്നയാൾ As ഉപയോഗിച്ച് തിരുത്തിയെഴുതിയിട്ടുണ്ട്. | ml | technical | moderate |
Recall that in the event of a crash, execution is passed to SEH. | ഒരു തകർച്ച സംഭവിച്ചാൽ, SEH-ലേക്ക് എക്സിക്യൂഷൻ കൈമാറുമെന്ന് ഓർക്കുക. | ml | 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 നിയന്ത്രിക്കുന്നത് ഇപ്പോഴും എക്സിക്യൂഷൻ ഹൈജാക്ക് ചെയ്യാൻ ഞങ്ങളെ അനുവദിച്ചേക്കാം. | ml | 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-ആണ് തിരുത്തിയെഴുതുന്നതെന്ന് ഞങ്ങൾ കണ്ടെത്തും. | ml | 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-നു പകരമായി ചൂഷണത്തിലേക്ക് പകർത്തുക. | ml | technical | moderate |
Here we’ve generated a 1,150-character pattern and replaced the string of As at u. | ഇവിടെ ഞങ്ങൾ 1,150 പ്രതീകങ്ങളുള്ള ഒരു പാറ്റേൺ ഉണ്ടാക്കുകയും u-വിലെ As-ൻ്റെ സ്ട്രിംഗ് മാറ്റിസ്ഥാപിക്കുകയും ചെയ്തു. | ml | technical | moderate |
Next, restart War-FTP in Immunity Debugger, and run the exploit again. | അടുത്തതായി, ഇമ്മ്യൂണിറ്റി ഡീബഗ്ഗറിൽ War-FTP പുനരാരംഭിച്ച് വീണ്ടും ചൂഷണം പ്രവർത്തിപ്പിക്കുക. | ml | technical | simple |
As shown in Figure 18-6, SEH is overwritten with 41317441. | ചിത്രം 18-6-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, SEH 41317441 ഉപയോഗിച്ച് തിരുത്തിയെഴുതിയിരിക്കുന്നു. | ml | 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 ഉപയോഗിക്കുക. | ml | 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 ബൈറ്റുകൾ എഴുതിയിട്ടുണ്ടെന്ന് ഞങ്ങൾ കണ്ടെത്തുന്നു. | ml | technical | complex |
Windows XP does not use ASLR. | വിൻഡോസ് എക്സ്പി ASLR ഉപയോഗിക്കുന്നില്ല. | ml | technical | simple |
We have taken advantage of static DLL locations in our previous exploit exercises. | മുമ്പത്തെ എക്സ്പ്ലോയിറ്റ് വ്യായാമങ്ങളിൽ ഞങ്ങൾ സ്ഥിരമായ DLL ലൊക്കേഷനുകൾ പ്രയോജനപ്പെടുത്തിയിട്ടുണ്ട്. | ml | technical | moderate |
We need not have a copy of 3Com TFTP running to find the memory locations of instructions in Windows components. | വിൻഡോസ് ഘടകങ്ങളിലെ നിർദ്ദേശങ്ങളുടെ മെമ്മറി ലൊക്കേഷനുകൾ കണ്ടെത്താൻ 3Com TFTP പ്രവർത്തിക്കുന്ന ഒരു പകർപ്പ് നമുക്ക് ആവശ്യമില്ല. | ml | technical | complex |
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 നിർദ്ദേശം നമുക്ക് തിരയാൻ കഴിയും. | ml | 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-ൽ ഉറച്ചുനിൽക്കുന്നത് നല്ലതാണ്. | ml | technical | moderate |
We can’t be sure the program loads MSVCRT.dll, for example. | ഉദാഹരണത്തിന്, പ്രോഗ്രാം MSVCRT.dll ലോഡ് ചെയ്യുന്നു എന്ന് നമുക്ക് ഉറപ്പിക്കാൻ കഴിയില്ല. | ml | technical | simple |
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 നിർദ്ദേശങ്ങൾക്കായി തിരയാൻ Mona ഉപയോഗിക്കാമായിരുന്നു. | ml | 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 (അല്ലെങ്കിൽ തത്തുല്യമായത്) ഇൻസ്റ്റൻസുകൾക്കായി നമുക്ക് തിരയാൻ കഴിയും. | ml | technical | complex |
And we find a JMP ESI instruction at the memory address 7E45AE4E in USER32.dll on Windows XP SP3. | വിൻഡോസ് എക്സ്പി എസ്പി3-ൽ USER32.dll-ൽ 7E45AE4E എന്ന മെമ്മറി വിലാസത്തിൽ ഒരു JMP ESI നിർദ്ദേശം ഞങ്ങൾ കണ്ടെത്തുന്നു. | ml | 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 വേരിയബിൾ ചെറിയ-എൻഡിയൻ ഫോർമാറ്റിലുള്ള ഈ മൂല്യത്തിലേക്ക് മാറ്റുകയാണെങ്കിൽ, ഈ എക്സ്പ്ലോയിറ്റ് ഞങ്ങളുടെ പ്ലാറ്റ്ഫോമിനായി പ്രവർത്തിക്കണം. | ml | technical | moderate |
We also need to replace the shellcode with code generated by Msfvenom. | ഷെൽകോഡിനെ Msfvenom ഉണ്ടാക്കിയ കോഡ് ഉപയോഗിച്ച് മാറ്റേണ്ടതുണ്ട്. | ml | technical | moderate |
We can use a bind shell or any Windows payload that will fit in 344 + 129 bytes. | 344 + 129 ബൈറ്റുകളിൽ ഉൾക്കൊള്ളുന്ന ഏതെങ്കിലും വിൻഡോസ് പേലോഡോ ഒരു ബൈൻഡ് ഷെല്ലോ ഉപയോഗിക്കാം. | ml | technical | moderate |
Tell Msfvenom to out- put the payload in Perl format so we can easily add it to our exploit. | ഞങ്ങളുടെ എക്സ്പ്ലോയിറ്റിലേക്ക് എളുപ്പത്തിൽ ചേർക്കാൻ കഴിയുന്ന രീതിയിൽ പേലോഡ് Perl ഫോർമാറ്റിൽ നൽകാൻ Msfvenom-നോട് പറയുക. | ml | technical | moderate |
Our generated shellcode from Msfvenom is 368 bytes, whereas the original shellcode in the public exploit was 344 bytes. | Msfvenom-ൽ നിന്നുള്ള ഞങ്ങളുടെ ഷെൽകോഡ് 368 ബൈറ്റാണ്, എന്നാൽ പൊതു എക്സ്പ്ലോയിറ്റിലെ യഥാർത്ഥ ഷെൽകോഡ് 344 ബൈറ്റായിരുന്നു. | ml | technical | moderate |
Now make the changes to the original exploit code shown in Listing 19-6. | ലിസ്റ്റിംഗ് 19-6 ൽ കാണിച്ചിരിക്കുന്ന യഥാർത്ഥ എക്സ്പ്ലോയിറ്റ് കോഡിൽ മാറ്റങ്ങൾ വരുത്തുക. | ml | 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 ഹൈജാക്ക് ചെയ്യുന്നു. | ml | technical | complex |
Our ported exploit will look like Listing 19-6, with the shellcode u, padding v, and return address w adjusted to meet our needs. | ഷെൽകോഡ് u, പാഡിംഗ് v, റിട്ടേൺ വിലാസം w എന്നിവ ഉപയോഗിച്ച്, ലിസ്റ്റിംഗ് 19-6 പോലെയായിരിക്കും ഞങ്ങളുടെ പോർട്ട് ചെയ്ത എക്സ്പ്ലോയിറ്റ്, ഇത് ഞങ്ങളുടെ ആവശ്യത്തിനനുസരിച്ച് ക്രമീകരിക്കും. | ml | 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. | എല്ലാം ശരിയായി ചെയ്തു കഴിഞ്ഞാൽ, പോർട്ട് ചെയ്ത എക്സ്പ്ലോയിറ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, സിസ്റ്റം പ്രിവിലേജുകളുള്ള ഒരു ബൈൻഡ് ഷെൽ TCP പോർട്ട് 4444-ൽ തുറക്കും. | ml | technical | moderate |
As new vulnerabilities are discovered, Metasploit modules are written for these issues, often by members of the security community like you. | പുതിയ സുരക്ഷാ പ്രശ്നങ്ങൾ കണ്ടെത്തുന്നതിനനുസരിച്ച്, മെറ്റാസ്പ്ലോയിറ്റ് മൊഡ്യൂളുകൾ ഈ പ്രശ്നങ്ങൾക്കായി എഴുതപ്പെടുന്നു, പലപ്പോഴും നിങ്ങളെപ്പോലുള്ള സുരക്ഷാ കമ്മ്യൂണിറ്റി അംഗങ്ങൾ. | ml | technical | moderate |
In this section, we will look at the basics of writing our own Metasploit exploit module. | ഈ ഭാഗത്ത്, നമ്മുടെ സ്വന്തം മെറ്റാസ്പ്ലോയിറ്റ് എക്സ്പ്ലോയിറ്റ് മൊഡ്യൂൾ എഴുതുന്നതിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ ഞങ്ങൾ പരിശോധിക്കും. | ml | technical | simple |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.