Jak te obfuscatory javascript generują rzeczywisty działający kod?

Co za zabawa! Oto moja propozycja. Zasadniczo dzieje się tutaj kilka liczb i ciągów przypisanych do zmiennych. Zmienne te są łączone w zakodowany łańcuch znaków. Ten zakodowany łańcuch jest dekodowany, tworząc łańcuch kodu JavaScript. Kod ten jest ustawiany jako ciało funkcji, która jest następnie wykonywana.

Weźmy to linia po linii:

Kolejka 1:

ﾟωﾟﾉ = /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/['_'];

ﾟωﾟﾉ - zmienna globalna
/｀ｍ´）ﾉ ~┻━┻ / - zwykły wyrażenie
/*´∇｀*/ - komentarz wielowierszowy
['_'] - Pobierz właściwość _ wyrażenia regularnego.

Ponieważ Wyrażenie regularne nie ma właściwości _, zmienna ﾟωﾟﾉ zawiera wartość undefined.

Kolejka 2:

o = (ﾟｰﾟ) = _ = 3;

Zdefiniuj zmienne o, ﾟｰﾟ, i _, i ustawić każdą z ich wartości na 3.

Kolejka 3:

c = (ﾟΘﾟ) = (ﾟｰﾟ) - (ﾟｰﾟ);

Zdefiniuj zmienne c i ﾟΘﾟ i ustaw ich wartości na 0. (ﾟｰﾟ jest 3, więc (ﾟｰﾟ) - (ﾟｰﾟ) jest tym samym, co ﾟｰﾟ - ﾟｰﾟ jest tym samym, co 3 - 3. Teraz c i ﾟΘﾟ oba zawierają 1;

Kolejka 4:

(ﾟДﾟ) = (ﾟΘﾟ) = (o ^ _ ^ o) / (o ^ _ ^ o);

Zdefiniuj zmienną ﾟДﾟ i przedefiniuj zmienną ﾟΘﾟ. ^ to operator bitowy XOR oraz o i _ są obie 3.
o ^ _ ^ o jest tym samym co 3 ^ 3 ^ 3.
3 ^ 3 na 0, 3 ^ 0 is 3.
Następnie 3 / 3 jest 1.
ﾟДﾟ i ﾟΘﾟ oba zawierają teraz 1.

Kolejka 5:

(ﾟДﾟ) = { ﾟΘﾟ: '_', ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ], ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)], ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ] };

Z przerwami linii i wcięciami:

(ﾟДﾟ) = {
    ﾟΘﾟ: '_',
    ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ],
    ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)],
    ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ]
};

Redefine ﾟДﾟ jako obiekt dosłowny, z właściwościami ﾟΘﾟ, ﾟωﾟﾉ, ﾟｰﾟﾉ, i ﾟДﾟﾉ.
ﾟДﾟ.ﾟΘﾟ to"_".
ﾟДﾟ.ﾟωﾟﾉ jest ((undefined == 3) + "_")[1], które jest "false_"[1], które jest "a".
ﾟДﾟ.ﾟｰﾟﾉ jest (undefined + "_")[3 ^ 3 ^ 3 - 1], które jest "undefined_"[2], które jest "d".
ﾟДﾟ.ﾟДﾟﾉ jest ((3 == 3) + "_")[3], które jest "true_"[3], które jest "u".

Kolejka 6:

(ﾟДﾟ)[ﾟΘﾟ] = ((ﾟωﾟﾉ == 3) + '_')[c ^ _ ^ o];

Jest tym samym co:

ﾟДﾟ.ﾟΘﾟ = ((undefined == 3) + "_")[1 ^ 3 ^ 3];

Czyli to samo co:

ﾟДﾟ.ﾟΘﾟ = "false_"[1];

Więc ﾟДﾟ.ﾟΘﾟ is "a".

Linie 7 - 16:

I tak dalej, przypisując ciągi znaków i liczby do zmiennych i właściwości obiektów. Do ostatniego wiersza:

Kolejka 17:

(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ + (ﾟДﾟ)[ﾟoﾟ] + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟΘﾟ) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + ((ﾟｰﾟ) + (o ^ _ ^ o)) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟΘﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (o ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (o ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟoﾟ])(ﾟΘﾟ))('_');

Do tego czasu mamy następujące zmienne:

ﾟωﾟﾉ    // undefined
o       // 3
ﾟｰﾟ     // 4
_       // 3
c       // 0
ﾟΘﾟ     // 1
ﾟДﾟ     /* {
            "1": "f",
            ﾟΘﾟ: "_",
            ﾟωﾟﾉ: "a",
            ﾟｰﾟﾉ: "d",
            ﾟДﾟﾉ: "e",
            c: "c",
            o: "o",
            return: "\\",
            ﾟΘﾟﾉ: "b",
            constructor: "\"",
            _: Function
        } */
ﾟoﾟ     // "constructor"
ﾟεﾟ     // "return"
oﾟｰﾟo   // "u"

Ta linia to w większości jedna wielka konkatenacja strun. Możemy sprawić, że będzie nieco bardziej czytelny, usuwając niepotrzebne nawiasy i dodając podziały linii:

ﾟДﾟ['_'](
    ﾟДﾟ['_'](
        ﾟεﾟ + 
        ﾟДﾟ[ﾟoﾟ] + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟｰﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟΘﾟ + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        (ﾟｰﾟ + (o ^ _ ^ o)) + 
        ﾟДﾟ[ﾟεﾟ] + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟｰﾟ + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        (o ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        (o ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟｰﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟoﾟ]
    )(ﾟΘﾟ)
)("_");

Wartość ten skonkatenowany łańcuch to:

return"\141\154\145\162\164\50\42\110\145\154\154\157\54\40\112\141\166\141\123\143\162\151\160\164\42\51"

Tak więc, zastępując wszystkie zmienne literałami, otrzymujemy następujący JavaScript, który jest wykonywany w ostatniej linii:

Function(Function("return\"\\141\\154\\145\\162\\164\\50\\42\\110\\145\\154\\154\\157\\54\\40\\112\\141\\166\\141\\123\\143\\162\\151\\160\\164\\42\\51\"")(1))("_")

Przełamując tę linię w dół, w środku widzimy, że skonkatenowany łańcuch jest przekazywany do konstruktora Function, czyniąc łańcuch ciałem funkcji:

Function("return\"\\141\\154\\145\\162\\164\\50\\42\\110\\145\\154\\154\\157\\54\\40\\112\\141\\166\\141\\123\\143\\162\\151\\160\\164\\42\\51\"")

Tak więc łańcuch ten jest obliczany jako JavaScript, a konstruktor Function zwraca tę funkcję:

function () {
    return"\141\154\145\162\164\50\42\110\145\154\154\157\54\40\112\141\166\141\123\143\162\151\160\164\42\51";
}

Ta funkcja jest wykonanie natychmiastowe:

Function("return\"\\141\\154\\145\\...\\51\"")(1)

I zwraca ciąg znaków:

alert("Hello, JavaScript")

Hej, to wygląda jak JavaScript! Ale jeszcze nie. To tylko sznurek. Ale ten łańcuch jest przekazywany do innego konstruktora Function, dając nam funkcję, która wykonuje łańcuch jako JavaScript:

Function("alert(\"Hello, JavaScript\")")

To to samo co:

function () {
    alert("Hello, JavaScript");
}

Ta funkcja jest natychmiast wykonywana:

Function("alert(\"Hello, JavaScript\")")("_")

I nasz niezauważony kod został w końcu wywołany.

Wpisz $ do konsoli (po uruchomieniu kodu) i rozwiń obiekt. Następnie można go łatwiej przeanalizować.

Chwytają wystarczająco dużo słów / znaków za pomocą podstępnych środków i odwołują się do nich w obiekcie$, a następnie używają ich do budowania programu i evalprawdopodobnie w wywołaniu Function(...)().

Więc powinno się sprowadzić do...

Function('alert("StackOverflow")')();

...albo coś podobnego.

Zaczyna się rozluźniać, ...

$=~[];  // -1

$={
  0:++$,         //  0
  f:(![]+"")[$], // "f", (![]+"") is "false", and [$] gives index 0, or "f"
  1:++$,         //  1
  a:(![]+"")[$], // "a", (![]+"") is "false", and [$] gives index 1, or "a"
  2:++$,         //  2
  b:({}+"")[$],  // "b", ({}+"") is "[object Object]", and [$] gives index 2, or "b"
  d:($[$]+"")[$],// "d", ($[$]+"") is "undefined", and [$] gives index 2, or "d"
  3:++$,         //  3
  e:(!""+"")[$], // "e", (!""+"") is "true", and [$] gives index 3, or "e"
  4:++$,         //  4
  5:++$,         //  5
  c:({}+"")[$],  // "c", ({}+"") is "[object Object]", and [$] gives index 5, or "c"
  6:++$,         //  6
  7:++$,         //  7
  8:++$,         //  8
  9:++$          //  9
};

$.constructor=($.constructor=$+"")[$[5]]+($.o=$.constructor[$[1]])+($.return=($.$+"")[$[1]])+((!$)+"")[$[3]]+($.t=$.constructor[$[6]])+($.$=(!""+"")[$[1]])+($.u=(!""+"")[$[2]])+$.constructor[$[5]]+$.t+$.o+$.$;
$.return=$.$+(!""+"")[$[3]]+$.t+$.u+$.$+$.return;
$.$=($[0])[$.constructor][$.constructor];
$.$($.$($.return+"\""+$.a+(![]+"")[$[2]]+$.e+"\\"+$[1]+$[6]+$[2]+$.t+"(\\\"\\"+$[1]+$[2]+$[3]+$.t+$.a+$.c+"\\"+$[1]+$[5]+$[3]+"\\"+$[1]+$[1]+$[7]+"\\"+$[1]+$[6]+$[6]+$.e+"\\"+$[1]+$[6]+$[2]+$.f+(![]+"")[$[2]]+$.o+"\\"+$[1]+$[6]+$[7]+"\\\")"+"\"")())();

$.constructor=($.constructor=$+"")[5]+($.o=$.constructor[1])+($.return=($.$+"")[1])+((!$)+"")[3]+($.t=$.constructor[6])+($.$=(!""+"")[1])+($.u=(!""+"")[2])+$.constructor[5]+$.t+$.o+$.$;
$.return=$.$+(!""+"")[3]+$.t+$.u+$.$+$.return;
$.$=(0)[$.constructor][$.constructor];
$.$($.$($.return+"\""+$.a+(![]+"")[2]+$.e+"\\"+$[1]+$[6]+$[2]+$.t+"(\\\"\\"+$[1]+$[2]+$[3]+$.t+$.a+$.c+"\\"+$[1]+$[5]+$[3]+"\\"+$[1]+$[1]+$[7]+"\\"+$[1]+$[6]+$[6]+$.e+"\\"+$[1]+$[6]+$[2]+$.f+(![]+"")[2]+$.o+"\\"+$[1]+$[6]+$[7]+"\\\")"+"\"")())();

...straciłem zainteresowanie.

Ponieważ każda inna odpowiedź jest tylko analizą kodu, który podałeś, rozwiążę, w jaki sposób możesz je wygenerować samodzielnie (bez narzędzi). Wierzę, że to da ci lepszy przegląd tego, jak to działa.

Większość tych zaciemnień opiera się na kilku funkcjach/zasadach JavaScript. Pierwszym z nich jest to, że nazwa zmiennej może używać Unicode Letter (Lu, Ll, Lt, Lm, na, Nl ) oraz Unicode Number (Nd). W pierwszym przykładzie, który podałeś, znak może wyglądać jak symbole, ale są to litera Unicode lub numer Unicode.

Drugi polega na tym, że dodanie pustego łańcucha do czegokolwiek w JavaScript spowoduje jego dodanie do łańcucha. Jeśli używasz również faktu, że łańcuchy są strukturą podobną do tablicy w JavaScript, możesz łatwo tworzyć takie rzeczy jak: (false+"")[0], które można również zapisać jako (!1+"")[0]. Od tego momentu możesz skomponować własną literę ciągu poprzez list.

Trzecim jest to, że do każdej właściwości obiektu można uzyskać dostęp za pomocą notacji []. Na przykład: window["alert"]("test") jest tym samym co window.alert("test"). Jeśli zmieszasz to z poprzednim akapitem, myślę, że możesz łatwo zobaczyć, gdzie to może pójść.

Brakuje nam jedynie odniesienia do window lub Function. Pozostałe odpowiedzi już dają Ci dostęp do Function, który może być użyty jak eval. Aby uzyskać window trudne, najprostszym sposobem jest przeciekanie go przez Array.concat to sposób:

t= [].concat;
a = t()[0]; // "a" now contains window

Gdy masz window, możesz użyć window["eval"] lub zadzwonić bezpośrednio window["alert"].

To wszystko na podstawie tego, jak naprawdę robisz tego rodzaju zaciemnienie. Reszta to tylko zmiana poprzednich punktów. Jeśli chcesz uzyskać dodatkowe informacje, zrobiłem kilka wpis na blogu o tym, można je znaleźć tutaj: {46]} http://holyvier.blogspot.com/2011/10/javascript-obfuscation-introduction.html