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.
|
અમે તેને ચાલુ રાખ્યું.
|
gu
|
technical
|
simple
|
The -z execstack compiler option makes the stack executable.
|
-z execstack કમ્પાઇલર વિકલ્પ સ્ટેકને એક્ઝિક્યુટેબલ બનાવે છે.
|
gu
|
technical
|
moderate
|
We tell GCC to compile overflowtest.c into an executable called overflowtest.
|
અમે GCC ને overflowtest.c ને overflowtest નામના એક્ઝિક્યુટેબલમાં કમ્પાઇલ કરવા કહીએ છીએ.
|
gu
|
technical
|
moderate
|
Recall that main takes the first command line argument to the program.
|
યાદ રાખો કે main પ્રોગ્રામમાં પ્રથમ કમાન્ડ લાઇન આર્ગ્યુમેન્ટ લે છે.
|
gu
|
technical
|
moderate
|
Let’s run the program with the command line argument AAAA.
|
ચાલો AAAA કમાન્ડ લાઇન આર્ગ્યુમેન્ટ સાથે પ્રોગ્રામ ચલાવીએ.
|
gu
|
technical
|
simple
|
Make overflowtest executable with chmod if necessary.
|
જરૂર પડ્યે chmod સાથે overflowtest ને એક્ઝિક્યુટેબલ બનાવો.
|
gu
|
technical
|
moderate
|
We use four As instead of five because a string ends with a null byte.
|
આપણે પાંચને બદલે ચાર એનો ઉપયોગ કરીએ છીએ કારણ કે સ્ટ્રિંગ શૂન્ય બાઇટ સાથે સમાપ્ત થાય છે.
|
gu
|
technical
|
moderate
|
Technically, if we used five As, we would already be overflowing the buffer.
|
ટેકનિકલી, જો આપણે પાંચ એનો ઉપયોગ કર્યો હોત, તો આપણે પહેલેથી જ બફરને ઓવરફ્લો કરી રહ્યા હોત.
|
gu
|
technical
|
complex
|
The program does what we expected.
|
પ્રોગ્રામ આપણે અપેક્ષા રાખીએ છીએ તે કરે છે.
|
gu
|
technical
|
simple
|
main calls function1.
|
main function1 ને બોલાવે છે.
|
gu
|
technical
|
simple
|
function1 copies AAAA into buffer.
|
function1 AAAA ને બફરમાં કોપી કરે છે.
|
gu
|
technical
|
simple
|
function1 returns execution to main.
|
function1 main પર એક્ઝિક્યુશન પાછું આપે છે.
|
gu
|
technical
|
simple
|
main prints “Executed normally” to the console before the program exits.
|
પ્રોગ્રામ બહાર નીકળતા પહેલા main કન્સોલ પર “Executed normally” પ્રિન્ટ કરે છે.
|
gu
|
technical
|
moderate
|
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 ને કેટલીક અણધારી ઇનપુટ આપીએ, તો આપણે તેને એવી રીતે વર્તવા માટે દબાણ કરી શકીએ છીએ જે આપણને બફર ઓવરફ્લોનું કારણ બનવામાં મદદ કરશે.
|
gu
|
technical
|
complex
|
Let’s try giving the program a long string of As as an argument.
|
ચાલો પ્રોગ્રામને આર્ગ્યુમેન્ટ તરીકે એ ની લાંબી સ્ટ્રિંગ આપવાનો પ્રયાસ કરીએ.
|
gu
|
technical
|
moderate
|
The program crashes with a segmentation fault.
|
પ્રોગ્રામ સેગ્મેન્ટેશન ફોલ્ટ સાથે ક્રેશ થાય છે.
|
gu
|
technical
|
simple
|
Our pro- gram’s problem lies with the implementation of strcpy.
|
આપણી પ્રોગ્રામની સમસ્યા strcpy ના અમલીકરણ સાથે રહેલી છે.
|
gu
|
technical
|
moderate
|
The strcpy function takes one string and copies it into another.
|
strcpy ફંક્શન એક સ્ટ્રિંગ લે છે અને તેને બીજામાં કોપી કરે છે.
|
gu
|
technical
|
moderate
|
The strcpy function will attempt to copy three, five, or even hundreds of characters into our five-character destination string.
|
strcpy ફંક્શન ત્રણ, પાંચ, અથવા તો સેંકડો અક્ષરોને આપણી પાંચ-અક્ષરની ડેસ્ટિનેશન સ્ટ્રિંગમાં કોપી કરવાનો પ્રયાસ કરશે.
|
gu
|
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 સ્ટેકમાં અડીને આવેલા મેમરી એડ્રેસ પર ડેટાને ઓવરરાઇટ કરશે.
|
gu
|
technical
|
complex
|
Our Ubuntu virtual machine has an Intel architecture, which is little endian.
|
અમારી Ubuntu વર્ચ્યુઅલ મશીનમાં Intel આર્કિટેક્ચર છે, જે લિટલ એન્ડિયન છે.
|
gu
|
technical
|
moderate
|
To account for little-endian architecture, we need to flip the bytes of our memory address around.
|
લિટલ-એન્ડિયન આર્કિટેક્ચરને ધ્યાનમાં લેવા માટે, આપણે આપણા મેમરી એડ્રેસના બાઇટ્સને ફેરવવાની જરૂર છે.
|
gu
|
technical
|
moderate
|
Using the return address with the byte order flipped for our Intel architecture fixes our problem.
|
અમારા Intel આર્કિટેક્ચર માટે બાઈટ ઓર્ડર ફ્લિપ કરેલ રીટર્ન એડ્રેસનો ઉપયોગ કરવાથી અમારી સમસ્યા હલ થાય છે.
|
gu
|
technical
|
moderate
|
This time when we hit the breakpoint, our return address looks correct.
|
આ વખતે જ્યારે આપણે બ્રેકપોઇન્ટ પર પહોંચીએ છીએ, ત્યારે અમારું રીટર્ન એડ્રેસ સાચું લાગે છે.
|
gu
|
technical
|
moderate
|
Sure enough, when we let the program continue, “Execution Hijacked” is printed to the console.
|
ચોક્કસપણે, જ્યારે આપણે પ્રોગ્રામ ચાલુ રાખીએ છીએ, ત્યારે “Execution Hijacked” કન્સોલ પર પ્રિન્ટ થાય છે.
|
gu
|
technical
|
moderate
|
To see the results outside the debugger, we run overflowtest from the command line.
|
ડીબગરની બહાર પરિણામો જોવા માટે, અમે કમાન્ડ લાઇનથી overflowtest ચલાવીએ છીએ.
|
gu
|
technical
|
moderate
|
Note that after overflowed returns, the program crashes with a segmentation fault.
|
ધ્યાન રાખો કે ઓવરફ્લો થયા પછી, પ્રોગ્રામ સેગ્મેન્ટેશન ફોલ્ટ સાથે ક્રેશ થાય છે.
|
gu
|
technical
|
moderate
|
This address is the same as the next four bytes on the stack after our return address.
|
આ એડ્રેસ અમારા રીટર્ન એડ્રેસ પછી સ્ટેક પરના આગામી ચાર બાઇટ્સ જેવો જ છે.
|
gu
|
technical
|
moderate
|
We sent execution straight to overflowed without normal function-calling things.
|
અમે સામાન્ય ફંક્શન-કૉલિંગ વસ્તુઓ વિના સીધું જ ઓવરફ્લો પર એક્ઝિક્યુશન મોકલ્યું.
|
gu
|
technical
|
complex
|
In this chapter we looked at a simple C program with a buffer overflow vulnerability.
|
આ પ્રકરણમાં, અમે બફર ઓવરફ્લો નબળાઈ સાથેના એક સરળ C પ્રોગ્રામને જોયો.
|
gu
|
technical
|
moderate
|
We exploited this issue by writing a longer string to the command line than the program expected.
|
આ મુદ્દાનો અમે પ્રોગ્રામની અપેક્ષા કરતાં કમાન્ડ લાઇન પર લાંબી સ્ટ્રિંગ લખીને ઉપયોગ કર્યો.
|
gu
|
technical
|
complex
|
We hijacked the program’s execution by overwriting a function’s return address with our own value.
|
અમે ફંક્શનના રીટર્ન એડ્રેસને અમારા પોતાના મૂલ્યથી ઓવરરાઇટ કરીને પ્રોગ્રામના એક્ઝિક્યુશનને હાઇજેક કર્યું.
|
gu
|
technical
|
complex
|
In the next chapter, our example will focus on a Windows-based target and a real-world target program.
|
આગલા પ્રકરણમાં, અમારું ઉદાહરણ વિન્ડોઝ-આધારિત લક્ષ્ય અને વાસ્તવિક-વિશ્વના લક્ષ્ય પ્રોગ્રામ પર ધ્યાન કેન્દ્રિત કરશે.
|
gu
|
technical
|
moderate
|
When the function main calls function1, the next instruction to be executed is saved on the stack.
|
જ્યારે ફંક્શન main function1 ને બોલાવે છે, ત્યારે એક્ઝિક્યુટ થનારી આગલી સૂચના સ્ટેક પર સાચવવામાં આવે છે.
|
gu
|
technical
|
complex
|
If we put more data in the stack buffer than it can hold, we will cause the buffer to overflow.
|
જો આપણે સ્ટેક બફરમાં તે સમાવી શકે તેના કરતાં વધુ ડેટા મૂકીએ, તો અમે બફરને ઓવરફ્લો કરીશું.
|
gu
|
technical
|
moderate
|
A search on Google for known vulnerabilities in War-FTP 1.65 finds the following information.
|
War-FTP 1.65 માં જાણીતી નબળાઈઓ માટે Google પર શોધ નીચેની માહિતી શોધે છે.
|
gu
|
technical
|
simple
|
Exploiting this issue could lead to denial-of-service conditions and to the execution of arbitrary machine code.
|
આ મુદ્દાનો ઉપયોગ સેવા-ઇનકારની સ્થિતિ અને મનસ્વી મશીન કોડના અમલ તરફ દોરી શકે છે.
|
gu
|
technical
|
complex
|
In this chapter, we will manually exploit War-FTP 1.65’s stack-based buffer overflow vulnerability.
|
આ પ્રકરણમાં, અમે War-FTP 1.65 ની સ્ટેક-આધારિત બફર ઓવરફ્લો નબળાઈનો જાતે ઉપયોગ કરીશું.
|
gu
|
technical
|
moderate
|
The issue we are going to exploit is particularly dangerous because an attacker does not need to log in.
|
જે મુદ્દાનો આપણે ઉપયોગ કરવા જઈ રહ્યા છીએ તે ખાસ કરીને ખતરનાક છે કારણ કે હુમલાખોરને લોગ ઇન કરવાની જરૂર નથી.
|
gu
|
technical
|
moderate
|
Like GDB, Immunity Debugger will allow us to see the internals of memory as we attempt to exploit War-FTP.
|
GDB ની જેમ, Immunity Debugger અમને War-FTP નો ઉપયોગ કરવાનો પ્રયાસ કરતી વખતે મેમરીના આંતરિક ભાગોને જોવાની મંજૂરી આપશે.
|
gu
|
technical
|
moderate
|
The War-FTP executable and MFC42.dll are involved in the exploit.
|
આ હુમલામાં War-FTP એક્ઝિક્યુટેબલ અને MFC42.dll સામેલ છે.
|
gu
|
technical
|
moderate
|
We need to avoid the four bad characters.
|
આપણે ચાર ખરાબ અક્ષરોથી બચવાની જરૂર છે.
|
gu
|
technical
|
simple
|
Mona can automatically exclude entries with bad characters.
|
મોના ખરાબ અક્ષરોવાળી એન્ટ્રીઓને આપમેળે બાકાત કરી શકે છે.
|
gu
|
technical
|
moderate
|
One such address is 5F4580CA.
|
આવું એક સરનામું 5F4580CA છે.
|
gu
|
technical
|
simple
|
The instructions are POP EBX, POP EBP, RET.
|
સૂચનાઓ છે POP EBX, POP EBP, RET.
|
gu
|
technical
|
simple
|
We don’t care where the instructions are stored.
|
અમને એનાથી કોઈ ફરક પડતો નથી કે સૂચનાઓ ક્યાં સંગ્રહિત છે.
|
gu
|
technical
|
simple
|
If we overwrite SEH with the address 5F4580CA, these instructions will be executed.
|
જો આપણે SEH ને સરનામાં 5F4580CA થી ઓવરરાઇટ કરીએ, તો આ સૂચનાઓ ચલાવવામાં આવશે.
|
gu
|
technical
|
moderate
|
We will redirect execution to our attack string.
|
આપણે એક્ઝિક્યુશનને અમારી એટેક સ્ટ્રિંગ પર રીડાયરેક્ટ કરીશું.
|
gu
|
technical
|
moderate
|
Set a breakpoint at 5F4580CA.
|
5F4580CA પર એક બ્રેકપોઇન્ટ સેટ કરો.
|
gu
|
technical
|
simple
|
Replace the four Cs in the exploit with the POP POP RET memory address.
|
એક્સપ્લોઇટમાં ચાર Cs ને POP POP RET મેમરી એડ્રેસથી બદલો.
|
gu
|
technical
|
moderate
|
Run the exploit again.
|
ફરીથી એક્સપ્લોઇટ ચલાવો.
|
gu
|
technical
|
simple
|
The program crashes again.
|
પ્રોગ્રામ ફરીથી ક્રેશ થાય છે.
|
gu
|
technical
|
simple
|
SEH is overwritten with 5F4580CA.
|
SEH ને 5F4580CA થી ઓવરરાઇટ કરવામાં આવે છે.
|
gu
|
technical
|
simple
|
Let the program pass the overwritten exception handler.
|
પ્રોગ્રામને ઓવરરાઇટ કરેલ અપવાદ હેન્ડલરને પસાર થવા દો.
|
gu
|
technical
|
moderate
|
We hit our breakpoint.
|
અમે અમારા બ્રેકપોઇન્ટ પર પહોંચી ગયા.
|
gu
|
technical
|
simple
|
The next instructions to be executed are the POP POP RET.
|
આગલી સૂચનાઓ જે ચલાવવામાં આવશે તે છે POP POP RET.
|
gu
|
technical
|
moderate
|
Watch what happens to the stack as you do.
|
તમે આમ કરો ત્યારે સ્ટેક પર શું થાય છે તે જુઓ.
|
gu
|
technical
|
simple
|
We end up in our attack string.
|
આપણે આપણી એટેક સ્ટ્રિંગમાં સમાપ્ત થઈએ છીએ.
|
gu
|
technical
|
simple
|
We have solved our first problem.
|
અમે અમારી પ્રથમ સમસ્યા હલ કરી છે.
|
gu
|
technical
|
simple
|
We have redirected the program’s execution to our attack string.
|
અમે પ્રોગ્રામના એક્ઝિક્યુશનને અમારી એટેક સ્ટ્રિંગ પર રીડાયરેક્ટ કર્યું છે.
|
gu
|
technical
|
moderate
|
Windows XP does not use ASLR.
|
વિન્ડોઝ XP ASLR નો ઉપયોગ કરતું નથી.
|
gu
|
technical
|
simple
|
We have taken advantage of static DLL locations in our previous exploit exercises.
|
અમારા અગાઉના શોષણ કસરતોમાં અમે સ્થિર DLL સ્થાનોનો લાભ લીધો છે.
|
gu
|
technical
|
moderate
|
We need not have a copy of 3Com TFTP running to find the memory locations of instructions in Windows components.
|
વિન્ડોઝ ઘટકોમાં સૂચનાઓના મેમરી સ્થાનો શોધવા માટે અમારી પાસે 3Com TFTP ની નકલ ચલાવવાની જરૂર નથી.
|
gu
|
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 સૂચના શોધી શકીએ છીએ.
|
gu
|
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 ચલને લિટલ-એન્ડિયન ફોર્મેટમાં આ મૂલ્યમાં બદલીએ, તો આ શોષણ અમારા પ્લેટફોર્મ માટે કામ કરવું જોઈએ.
|
gu
|
technical
|
moderate
|
We can use a bind shell or any Windows payload that will fit in 344 + 129 bytes.
|
આપણે બાઈન્ડ શેલ અથવા કોઈપણ વિન્ડોઝ પેલોડનો ઉપયોગ કરી શકીએ છીએ જે 344 + 129 બાઇટ્સમાં ફિટ થશે.
|
gu
|
technical
|
moderate
|
Tell Msfvenom to out- put the payload in Perl format so we can easily add it to our exploit.
|
Msfvenom ને પેલોડને પર્લ ફોર્મેટમાં આઉટપુટ કરવા કહો જેથી અમે તેને સરળતાથી અમારા શોષણમાં ઉમેરી શકીએ.
|
gu
|
technical
|
moderate
|
Our generated shellcode from Msfvenom is 368 bytes, whereas the original shellcode in the public exploit was 344 bytes.
|
Msfvenom માંથી અમારું જનરેટ થયેલ શેલકોડ 368 બાઇટ્સનું છે, જ્યારે સાર્વજનિક શોષણમાં મૂળ શેલકોડ 344 બાઇટ્સનું હતું.
|
gu
|
technical
|
complex
|
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 ને હાઇજેક કરે છે.
|
gu
|
technical
|
complex
|
This was written for educational purpose.
|
આ શૈક્ષણિક હેતુ માટે લખાયેલું છે.
|
gu
|
technical
|
simple
|
Use it at your own risk.
|
તમારા પોતાના જોખમે તેનો ઉપયોગ કરો.
|
gu
|
technical
|
simple
|
Author will not be responsible for any damage.
|
લેખક કોઈપણ નુકસાન માટે જવાબદાર રહેશે નહીં.
|
gu
|
technical
|
simple
|
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 પર ખુલશે.
|
gu
|
technical
|
complex
|
In this section, we will look at the basics of writing our own Metasploit exploit module.
|
આ વિભાગમાં, અમે અમારા પોતાના મેટાસ્પ્લોઇટ શોષણ મોડ્યુલ લખવાની મૂળભૂત બાબતો જોઈશું.
|
gu
|
technical
|
moderate
|
The best way to write a Metasploit module is to start with a similar exist- ing module or skeleton.
|
મેટાસ્પ્લોઇટ મોડ્યુલ લખવાનો શ્રેષ્ઠ માર્ગ એ છે કે સમાન અસ્તિત્વમાં રહેલા મોડ્યુલ અથવા હાડપિંજરથી શરૂઆત કરવી.
|
gu
|
technical
|
moderate
|
We will adapt it for our 3Com TFTP exploit module.
|
અમે તેને અમારા 3Com TFTP શોષણ મોડ્યુલ માટે અનુકૂલિત કરીશું.
|
gu
|
technical
|
simple
|
This module exploits a stack buffer overflow in the FutureSoft TFTP Server 2000 product.
|
આ મોડ્યુલ ફ્યુચરસોફ્ટ TFTP સર્વર 2000 પ્રોડક્ટમાં સ્ટેક બફર ઓવરફ્લોનું શોષણ કરે છે.
|
gu
|
technical
|
moderate
|
By sending an overly long transfer-mode string, we were able to overwrite both the SEH and the saved EIP.
|
ખૂબ લાંબી ટ્રાન્સફર-મોડ સ્ટ્રિંગ મોકલીને, અમે SEH અને સાચવેલ EIP બંનેને ઓવરરાઇટ કરવામાં સક્ષમ હતા.
|
gu
|
technical
|
complex
|
This module has been tested against Windows 2000 Professional and for some reason does not seem to work against Windows 2000 Server.
|
આ મોડ્યુલનું પરીક્ષણ વિન્ડોઝ 2000 પ્રોફેશનલ સામે કરવામાં આવ્યું છે અને કેટલાક કારણોસર વિન્ડોઝ 2000 સર્વર સામે કામ કરતું નથી.
|
gu
|
technical
|
moderate
|
In the Payload section w, we tell Metasploit how many bytes we have avail- able in the attack string for the payload.
|
પેલોડ વિભાગ w માં, અમે મેટાસ્પ્લોઇટને કહીએ છીએ કે અમારી પાસે પેલોડ માટે એટેક સ્ટ્રિંગમાં કેટલા બાઇટ્સ ઉપલબ્ધ છે.
|
gu
|
technical
|
complex
|
Figure 17-12: Breakpoints in Immunity Debugger Now replace the four Bs in your exploit string with the location of the redirection to ESP, as shown in Listing 17-5.
|
આકૃતિ 17-12: ઇમ્યુનિટી ડિબગર માં બ્રેકપોઇન્ટ્સ હવે તમારા એક્સપ્લોઇટ સ્ટ્રિંગમાં ચાર બી ને ESP તરફ રીડાયરેક્શનના સ્થાન સાથે બદલો, જેમ કે લિસ્ટિંગ 17-5 માં બતાવ્યા પ્રમાણે.
|
gu
|
technical
|
moderate
|
With a breakpoint prepared, let’s place our new return address at the right location in our attack string at u and change the 611 Cs to four Cs followed by 607 Ds to account for the four bytes of the attack string before ESP.
|
બ્રેકપોઇન્ટ તૈયાર સાથે, ચાલો આપણા નવા રીટર્ન એડ્રેસને u પર અમારી એટેક સ્ટ્રિંગમાં યોગ્ય સ્થાન પર મૂકીએ અને 611 Cs ને ચાર Cs માં બદલીએ ત્યારબાદ 607 Ds ને ESP પહેલાં એટેક સ્ટ્રિંગના ચાર બાઇટ્સ માટે ગણીએ.
|
gu
|
technical
|
complex
|
Once the attack string is in place, run the exploit against War-FTP, and see if it reaches our breakpoint in Immunity Debugger, as shown in Figure 17-13.
|
એકવાર એટેક સ્ટ્રિંગ લાગુ થઈ જાય, પછી War-FTP સામે એક્સપ્લોઇટ ચલાવો, અને જુઓ કે તે આકૃતિ 17-13 માં બતાવ્યા પ્રમાણે, ઇમ્યુનિટી ડિબગરમાં અમારા બ્રેકપોઇન્ટ સુધી પહોંચે છે કે નહીં.
|
gu
|
technical
|
moderate
|
If you forget to take endianness into account, you might not reach your breakpoint; instead, the program will crash with an access violation at 5954C377.
|
જો તમે એન્ડિયનનેસને ધ્યાનમાં લેવાનું ભૂલી જાઓ છો, તો તમે તમારા બ્રેકપોઇન્ટ સુધી પહોંચી શકશો નહીં; તેના બદલે, પ્રોગ્રામ 5954C377 પર એક્સેસ ઉલ્લંઘન સાથે ક્રેશ થશે.
|
gu
|
technical
|
complex
|
Be sure to flip the bytes around to little-endian format.
|
ખાતરી કરો કે બાઇટ્સને લિટલ-એન્ડિયન ફોર્મેટમાં ફ્લિપ કરો.
|
gu
|
technical
|
simple
|
The next command to be executed is shown in the top left of the Immunity Debugger window in the CPU pane.
|
આગળનો આદેશ જે ચલાવવામાં આવશે તે CPU પેનમાં ઇમ્યુનિટી ડિબગર વિન્ડોની ઉપર ડાબી બાજુએ બતાવવામાં આવ્યો છે.
|
gu
|
technical
|
moderate
|
Use F7 to execute one com- mand at a time rather than have the program continue running normally.
|
પ્રોગ્રામને સામાન્ય રીતે ચાલુ રાખવાને બદલે, એક સમયે એક કમાન્ડ ચલાવવા માટે F7 નો ઉપયોગ કરો.
|
gu
|
technical
|
moderate
|
We press F7 twice to execute the PUSH ESP and RET instructions, and, as expected, execution is redirected to the beginning of our Ds (44 in hex), as shown in Figure 17-14.
|
અમે PUSH ESP અને RET સૂચનાઓ ચલાવવા માટે બે વાર F7 દબાવીએ છીએ, અને અપેક્ષા મુજબ, એક્ઝિક્યુશન અમારા Ds (હેક્સમાં 44) ની શરૂઆતમાં રીડાયરેક્ટ થાય છે, જેમ કે આકૃતિ 17-14 માં બતાવવામાં આવ્યું છે.
|
gu
|
technical
|
complex
|
Now we just need to put something useful in place of the Ds from the previous section for the CPU to execute on our behalf.
|
હવે આપણે ફક્ત CPU ને આપણા વતી ચલાવવા માટે પાછલા વિભાગના Ds ની જગ્યાએ કંઈક ઉપયોગી મૂકવાની જરૂર છે.
|
gu
|
technical
|
moderate
|
In Chapter 4, we used the Metasploit tool Msfvenom to generate malicious executables.
|
પ્રકરણ 4 માં, અમે દૂષિત એક્ઝિક્યુટેબલ જનરેટ કરવા માટે મેટાસ્પ્લોઇટ ટૂલ Msfvenom નો ઉપયોગ કર્યો.
|
gu
|
technical
|
moderate
|
We can also use it to create raw shellcode to put in our handwritten exploits.
|
અમે તેનો ઉપયોગ અમારા હાથથી લખેલા એક્સપ્લોઇટ્સમાં મૂકવા માટે કાચા શેલકોડ બનાવવા માટે પણ કરી શકીએ છીએ.
|
gu
|
technical
|
moderate
|
For instance, we can tell our hijacked CPU to open a bind shell on TCP port 444 4 (or any other port) by using Msfvenom to generate the shellcode for a Metasploit payload.
|
ઉદાહરણ તરીકે, અમે અમારા હાઇજેક કરેલા CPU ને મેટાસ્પ્લોઇટ પેલોડ માટે શેલકોડ જનરેટ કરવા માટે Msfvenom નો ઉપયોગ કરીને TCP પોર્ટ 444 4 (અથવા કોઈપણ અન્ય પોર્ટ) પર બાઇન્ડ શેલ ખોલવા માટે કહી શકીએ છીએ.
|
gu
|
technical
|
complex
|
We need to tell Msfvenom the payload to use—in this case windows/ shell_bind_tcp, the inline Windows command shell.
|
આપણે Msfvenom ને ઉપયોગમાં લેવા માટે પેલોડ કહેવાની જરૂર છે—આ કિસ્સામાં windows/ shell_bind_tcp, ઇનલાઇન વિન્ડોઝ કમાન્ડ શેલ.
|
gu
|
technical
|
moderate
|
We also need to provide it with the maximum size we can have for our shellcode.
|
આપણે તેને આપણા શેલકોડ માટે મહત્તમ કદ પણ આપવાની જરૂર છે.
|
gu
|
technical
|
simple
|
As you experiment with crashing War-FTP, you will notice that you can actually make the attack string slightly bigger, but things start to act strangely around 1,150 charac- ters.
|
જેમ તમે War-FTP ને ક્રેશ કરવાનો પ્રયોગ કરો છો, તમે જોશો કે તમે હુમલાની સ્ટ્રિંગને થોડી મોટી બનાવી શકો છો, પરંતુ વસ્તુઓ લગભગ 1,150 અક્ષરોની આસપાસ વિચિત્ર રીતે વર્તવાનું શરૂ કરે છે.
|
gu
|
technical
|
complex
|
At 1,100 characters we are safe, and our exploit will work as expected each time.
|
1,100 અક્ષરો પર આપણે સુરક્ષિત છીએ, અને આપણું એક્સપ્લોઇટ દરેક વખતે અપેક્ષા મુજબ કામ કરશે.
|
gu
|
technical
|
simple
|
Our current exploit string has 607 Ds, so we have 607 bytes for our shellcode.
|
અમારી વર્તમાન એક્સપ્લોઇટ સ્ટ્રિંગમાં 607 Ds છે, તેથી અમારી પાસે અમારા શેલકોડ માટે 607 બાઇટ્સ છે.
|
gu
|
technical
|
simple
|
Finally, we need to tell Msfvenom which special characters to avoid when creating the payload.
|
છેલ્લે, આપણે Msfvenom ને પેલોડ બનાવતી વખતે કયા વિશેષ અક્ષરોને ટાળવા તે કહેવાની જરૂર છે.
|
gu
|
technical
|
moderate
|
In this case, we need to avoid the null byte (\ x00), carriage return (\ x0d), line feed (\ x0a), and @ (\ x40).
|
આ કિસ્સામાં, આપણે નલ બાઇટ (\ x00), કેરેજ રિટર્ન (\ x0d), લાઇન ફીડ (\ x0a), અને @ (\ x40) ને ટાળવાની જરૂર છે.
|
gu
|
technical
|
moderate
|
Feed this information into Msfvenom, as shown in Listing 17-6.
|
આ માહિતીને Msfvenom માં ફીડ કરો, જેમ કે લિસ્ટિંગ 17-6 માં બતાવવામાં આવ્યું છે.
|
gu
|
technical
|
simple
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.