Как эти obfuscators javascript генерируют фактический рабочий код?

Ответ 1

Как мой javascript excerise дня, линия за строкой ломается. Заметьте, что я создал шахту с alert("Hello")

$ = ~[];   // var $ = -1
$ = 
    {
    ___ : ++$,              // ++(-1) == 0
    $$$$:(![]+"")[$],       // ![] == false, false + "" == "false", "false"[0] == "f"
    __$:++$,                // ++(0) == 1    
    $_$_:(![]+"")[$],       // ![] == false, false + "" == "false", "false"[1] == "a"
    _$_:++$,                // ++(1) == 2
    $_$$:({}+"")[$],        // {} + "" == "[object Object]", "[object Object]"[2] == "b"
    $$_$:($[$]+"")[$],      // 2[2] == undefined + "" == "undefined", "undefined"[2] == "d"
    _$$:++$,                // ++(2) == 3
    $$$_:(!""+"")[$],       // !"" == true + "" == "true", "true"[3] == "e"
    $__:++$,                // ++(3) == 4
    $_$:++$,                // ++(4) == 5
    $$__:({}+"")[$],        // ({} + "") == [object Object]", "[object Object]"[5] == "c"
    $$_:++$,                // ++(5) == 6
    $$$:++$,                // ++(6) == 7
    $___:++$,               // ++(7) == 8
    $__$:++$                // ++(8) == 9
};

$.$_ = 
    ($.$_=$+"")[$.$_$] +        // "[object Object]"[5] == "c" +  (also $.$_ = "[object Object]")
    ($._$=$.$_[$.__$]) +        // "[object Object]"[1] == "o" + (also $._$ = "o")
    ($.$$=($.$+"")[$.__$]) +    // $.$+"" == "undefined", "undefined"[1] == "n" + (also $.$$ = "n")
    ((!$)+"")[$._$$] +          // !$ == false, false+"" == "false", "false"[3] == "s" +
    ($.__=$.$_[$.$$_]) +        // "[object Object]"[6] == "t" (also $.__ = "t") +
    ($.$=(!""+"")[$.__$]) +     // !"" == true, true + "" == "true", "true"[2] == "r" +(also $.$="r")
    ($._=(!""+"")[$._$_]) +     // !"" == true, true + "" == "true", "true"[3] == "u" +(also $._="u")
    $.$_[$.$_$] +               // "[object Object]"[5] == "c" +
    $.__ +                      // "t" +
    $._$ +                      // "o" +
    $.$;                        // "r"

// $.$_ = "constructor"

$.$$ = 
    $.$ +                       // "r" +
    (!""+"")[$._$$] +           // "true"[3] == "e" +
    $.__ +                      // "t" +
    $._  +                      // "u" +
    $.$ +                       // "r" +
    $.$$;                       // "n" 
// $.$$ = "return"

$.$ = ($.___)[$.$_][$.$_];      // (0)["constructor"]["constructor"]
// $.$ = Function

// This is the part that changes when you change the input string.

$.$(                            // Function( 
    $.$(                        // Function (
        $.$$ +                  // "return"+
        "\""+                   // '"' +
        $.$_$_ +                // "a" + 
        (![]+"")[$._$_]+        // "l" + 
        $.$$$_+                 // "e" + 
        "\\"+                   // "\" +            
        $.__$+                  // "1" + 
        $.$$_+                  // "6" + 
        $._$_+                  // "2" +   (note '\162' = 'r')   
        $.__+                   // "t" + 
        "(\\\"\\"+              // '(\"\' +    
        $.__$+                  // 1 + 
        $.__$+                  // 1 + 
        $.___+                  // 0 +     (note '\110' = 'H')    
        $.$$$_+                 // e + 
        (![]+"")[$._$_]+        // "false"[2] == "l", "l" + 
        (![]+"")[$._$_]+        // "false"[2] == "l", "l" + 
        $._$+                   // "o" + 
        "\\\")"+                // '\")' +
        "\""                    // '"''
    )()                         // invoke
)();                            // invoke

Мне не очень нравится, он создает строку, а затем вызывает ее.

Изменить – и у меня нет времени на декодирование другой версии, но я думаю, что он делает что-то подобное, но с не-латинскими символами.

Ответ 2

Какая забава! Вот иди сюда. В основном то, что здесь происходит, - это набор чисел и строк для переменных. Эти переменные объединяются для формирования закодированной строки. Эта закодированная строка декодируется, чтобы сформировать строку кода JavaScript. Этот код задается как тело функции, которая затем выполняется.

Пусть он берется по строкам:

Строка 1:

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

ﾟωﾟﾉ - глобальная переменная /｀ｍ´）ﾉ ~┻━┻ / - регулярное выражение /*´∇｀*/ - многострочный комментарий
['_'] - получить свойство _ регулярного выражения.

Так как RegExp не имеет свойства _, переменная ﾟωﾟﾉ содержит значение undefined.

Строка 2:

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

Определите переменные o, ﾟｰﾟ и _ и установите для каждого из своих значений значение 3.

Строка 3:

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

Определите переменные c и ﾟΘﾟ и установите их значения 0. (ﾟｰﾟ есть 3, поэтому (ﾟｰﾟ) - (ﾟｰﾟ) совпадает с ﾟｰﾟ - ﾟｰﾟ совпадает с 3 - 3. Теперь c и ﾟΘﾟ содержат 1;

Строка 4:

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

Определите переменную ﾟДﾟ и переопределите переменную ﾟΘﾟ. ^ является побитовым оператором XOR и o и _ являются 3.
o ^ _ ^ o совпадает с 3 ^ 3 ^ 3.
3 ^ 3 есть 0, 3 ^ 0 is 3.
Тогда 3 / 3 1.
ﾟДﾟ и ﾟΘﾟ оба теперь содержат 1.

Строка 5:

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

С разрывами строк и отступом:

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

Переопределите ﾟДﾟ как объектный литерал со свойствами ﾟΘﾟ, ﾟωﾟﾉ, ﾟｰﾟﾉ и ﾟДﾟﾉ.
ﾟДﾟ.ﾟΘﾟ - "_".
ﾟДﾟ.ﾟωﾟﾉ ((undefined == 3) + "_")[1], который "false_"[1], который равен "a".
ﾟДﾟ.ﾟｰﾟﾉ - (undefined + "_")[3 ^ 3 ^ 3 - 1], который равен "undefined_"[2], который равен "d".
ﾟДﾟ.ﾟДﾟﾉ - ((3 == 3) + "_")[3], который равен "true_"[3], который равен "u".

Строка 6:

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

То же, что и:

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

Это то же самое, что:

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

Итак, ﾟДﾟ.ﾟΘﾟ - "a".

Линии 7 - 16:

И так продолжается, назначая строки и числа переменным и свойствам объекта. До последней строки:

Строка 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ﾟ])(ﾟΘﾟ))('_');

К этому времени мы имеем следующие переменные:

ﾟωﾟﾉ    // 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"

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

ﾟДﾟ['_'](
    ﾟДﾟ['_'](
        ﾟεﾟ + 
        ﾟДﾟ[ﾟ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ﾟ]
    )(ﾟΘﾟ)
)("_");

Значение этой конкатенированной строки:

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"

Итак, заменив все переменные литералами, мы получим следующий JavaScript, который будет выполнен в этой последней строке:

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))("_")

Разбивая эту строку вниз, в середине мы видим, что конкатенированная строка передается конструктору 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\"")

Итак, эта строка оценивается как JavaScript, а конструктор 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";
}

Эта функция немедленно выполняется:

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

И возвращает строку:

alert("Hello, JavaScript")

Эй, это похоже на JavaScript! Но это еще не все. Это просто строка. Но эта строка передается другому конструктору Function, предоставляя нам функцию, которая выполняет строку как JavaScript:

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

Это то же самое, что:

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

Эта функция немедленно выполняется:

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

И наш ненавязчивый код наконец называется.

Ответ 3

Введите $ в консоль (после запуска кода) и разверните объект. Затем вы можете легко проанализировать его.

Они хватают достаточное количество слов/символов, используя скрытые средства, и ссылаются на них в объекте $, а затем используют их для сборки программы и eval, вероятно, в вызове Function(...)().

Поэтому он должен свариться до...

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

... или что-то подобное.

Чтобы развернуть его,...

$=~[];  // -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]+"\\\")"+"\"")())();

... ах, потерянный интерес.

Ответ 4

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

Большая часть этих обфускаций основана на нескольких функциях/принципах JavaScript. Первый заключается в том, что имя переменной может использовать Unicode Letter (Lu, Ll, Lt, Lm, Lo, Nl) и Unicode Номер (Nd). В первом примере, который вы указали, символ может выглядеть как символы, но они являются буквой Unicode или номером Unicode.

Второй заключается в том, что добавление пустой строки ко всему, что в JavaScript, приведет к ее строке. Если вы также используете тот факт, что строки являются подобными массиву структурами в JavaScript, вы можете легко создавать такие вещи, как: (false+"")[0], который также может быть написан как (!1+"")[0]. С этого момента вы можете составить свое собственное строковое письмо по букве.

Третий заключается в том, что к каждому объекту можно получить доступ с помощью обозначения []. Например: window["alert"]("test") совпадает с window.alert("test"). Если вы смешаете это с предыдущим абзацем, я думаю, вы можете легко увидеть, куда он может пойти.

Единственное, чего нам не хватает для начала, это либо ссылка на window, либо Function. Другие ответы уже предоставляют вам доступ к Function, который можно использовать как eval. Чтобы получить window жесткий, самый простой способ - протестировать его через Array.concat следующим образом:

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

Как только у вас есть window, вы можете использовать window["eval"] или напрямую позвонить window["alert"].

Это все на основе того, как вы на самом деле делаете такую ​​путаницу. Остальное - это просто изменение предыдущих пунктов. Если вам нужна дополнительная информация, я сделал пару сообщений в блоге об этом, вы можете найти их здесь: http://holyvier.blogspot.com/2011/10/javascript-obfuscation-introduction.html