Как работает этот волшебный код JavaScript?

Ответ 1

Перед тем, как присмотреться к коду, вы должны знать, что, поскольку JavaScript 1.5 идентификаторы могут содержать не только символы ASCII, но и символы Unicode.

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

a = /｀ｍ´）ﾉ~┻━┻/['_'];
o = b = _ = 3;
c = d = b-b;
e = d = o^_^o/o^_^o;
e = {
  d: '_',
  a: ((a==3)+'_')[d],
  h: (a+'_')[o^_^o-d],
  i: ((b==3)+'_')[b]
};
e[d]   = ((a==3)+'_')[c^_^o];
e['c'] = (e+'_')[b+b-d];
e['o'] = (e+'_')[d];
f      = e['c']+e['o']+(a+'_')[d]+((a==3)+'_')[b]+(e+'_')[b+b]+((b==3)+'_')[d]+((b==3)+'_')[b-d]+e['c']+(e+'_')[b+b]+e['o']+((b==3)+'_')[d];
e['_'] = (o^_^o)[f][f];
g      = ((b==3)+'_')[d]+e.i+(e+'_')[b+b]+((b==3)+'_')[o^_^o-d]+((b==3)+'_')[d]+(a+'_')[d];
b      += d;
e[g]   = '\\';
e.j    = (e+b)[o^_^o-d];
obo    = (a+'_')[c^_^o];
e[f]   = '\"';
e['_'](e['_'](g+e[f]+e[g]+d+b+d+e[g]+d+(b+d)+b+e[g]+d+b+(b+d)+e[g]+d+((o^_^o)+(o^_^o))+((o^_^o)-d)+e[g]+d+((o^_^o)+(o^_^o))+b+e[g]+(b+d)+(c^_^o)+e[g]+b+((o^_^o)-d)+e[g]+d+d+(c^_^o)+e[g]+d+b+(b+d)+e[g]+d+(b+d)+b+e[g]+d+(b+d)+b+e[g]+d+(b+d)+(b+(o^_^o))+e[g]+b+(c^_^o)+e[g]+d+((o^_^o)-d)+(b+(o^_^o))+e[g]+d+(b+d)+(b+(o^_^o))+e[g]+d+((o^_^o)+(o^_^o))+((o^_^o)-d)+e[g]+d+(b+d)+b+e[g]+d+b+b+e[g]+b+((o^_^o)-d)+e[g]+(b+d)+d+e[f])(d))('_');

Теперь нам удалось оценить каждое утверждение за раз:

• a = /｀ｍ´）ﾉ~┻━┻/['_'] оценивается как a = undefined
• o = b = _ = 3 присваивает o, b и _ целое число 3
• c = d = b-b присваивает c и d целое число 0
• e = d = o^_^o/o^_^o присваивает e и d целое число 1 (o^_^o оценивается как 3 XOR 3 XOR 3, что дает 3)
• e = { d: '_', a: ((a==3)+'_')[d], h: (a+'_')[o^_^o-d], i: ((b==3)+'_')[b] } присваивает e объект { d: '_', a: 'a', h: 'd', i: 'e' }
• e[d] = ((a==3)+'_')[c^_^o] присваивает e[1] строку 'f'
• e['c'] = (e+'_')[b+b-d] присваивает e['c'] строку 'c'
• e['o'] = (e+'_')[d] присваивает e['o'] строку 'o'

Это была всего лишь настройка и установлены следующие переменные:

a = undefined
b = 3
c = 0
d = 1
e = {
    1: "f",
    a: "a",
    c: "c",
    d: "_",
    h: "d",
    i: "e",
    o: "o"
}

Следующий оператор - первый, который что-то конструирует:

f = e['c'] +             // => "c"
    e['o'] +             // => "o"
    (a+'_')[d] +         // => "undefined_"[1] = "n"
    ((a==3)+'_')[b] +    // => "false_"[3]     = "s"
    (e+'_')[b+b] +       // => "object_"[6]    = "t"
    ((b==3)+'_')[d] +    // => "true_"[1]      = "r"
    ((b==3)+'_')[b-d] +  // => "true_"[2]      = "s"
    e['c'] +             // => "c"
    (e+'_')[b+b] +       // => "object_"[6]    = "t"
    e['o'] +             // => "o"
    ((b==3)+'_')[d];     // => "true"[1]       = "r"

So f = "constructor". В следующем выражении этот "constructor" используется для извлечения функции:

e['_'] = (o^_^o)[f][f]

Это эквивалентно (3).constructor.constructor, что дает функцию Function, поэтому:

e['_'] = Function

Эта функция Function является специальной, так как можно динамически строить функции, передавая ей код тела функции через параметр:

f = Function("alert(1)")
// equivalent to
f = function() { alert(1) }

Пропустите следующие несколько операторов и просто напишите полученные переменные и значения:

a = undefined
b = 4
c = 0
d = 1
e = {
    1: "f",
    _: Function,
    a: "a",
    c: "c",
    constructor: "\"",
    d: "_",
    h: "d",
    i: "e",
    j: "b",
    o: "o",
    return: "\\"
}
f = "constructor"
obo = "u"

Последнее утверждение делает окончательную работу:

e['_'](e['_'](g+e[f]+e[g]+d+b+d+e[g]+d+(b+d)+b+e[g]+d+b+(b+d)+e[g]+d+((o^_^o)+(o^_^o))+((o^_^o)-d)+e[g]+d+((o^_^o)+(o^_^o))+b+e[g]+(b+d)+(c^_^o)+e[g]+b+((o^_^o)-d)+e[g]+d+d+(c^_^o)+e[g]+d+b+(b+d)+e[g]+d+(b+d)+b+e[g]+d+(b+d)+b+e[g]+d+(b+d)+(b+(o^_^o))+e[g]+b+(c^_^o)+e[g]+d+((o^_^o)-d)+(b+(o^_^o))+e[g]+d+(b+d)+(b+(o^_^o))+e[g]+d+((o^_^o)+(o^_^o))+((o^_^o)-d)+e[g]+d+(b+d)+b+e[g]+d+b+b+e[g]+b+((o^_^o)-d)+e[g]+(b+d)+d+e[f])(d))('_');

Это эквивалентно:

Function(Function( … )(1))('_')

Длинное выражение строит следующую строку:

return"\141\154\145\162\164\50\42\110\145\154\154\157\40\127\157\162\154\144\42\51"

Снятая строка оценивает:

alert("Hello World")

Этот return код передается Function, что создает анонимную функцию, например:

function anonymous() {
    return"\141\154\145\162\164\50\42\110\145\154\154\157\40\127\157\162\154\144\42\51";
}

Что, как мы знаем, эквивалентно:

function anonymous() {
    return"alert(\"Hello World\")";
}

Эта функция затем выполняется с параметром 1 в качестве параметра, который возвращает результирующую строку:

alert("Hello World")

Затем это снова передается в Function, что создает новую анонимную функцию:

function anonymous() {
    alert("Hello World");
}

Наконец, эта функция также вызывается с параметром '_'.

Ответ 2

Здесь много чего. Скобки вокруг переменных не работают.

В основном он строит эту строку:

return"\141\154\145\162\164\50\42\110\145\154\154\157\40\127\157\162\154\144\42\51"

Что такое экранированная версия

return "alert(\"Hello World\")"

И, наконец, делает следующее:

Function(Function('return "alert(\\"Hello World\\")"')())()

Двойной Function кажется произвольным, но это не так. Function() интерпретирует обратную косую черту в строке как escape-символы. Таким образом, первый вызов декодирует, а второй выполняет.

Function("return '\\110\\145\\154\\154\\157'")()
// => "Hello"

Это тот же код, лучше отформатированный и с "нормальными" именами переменных;

var1=/｀ｍ´）ﾉ~┻━┻//*´∇｀*/['_'];
three=(threeThenFour)=_=3;
c=(one)=(threeThenFour)-(threeThenFour);
(anObject)=(one)=(three)/(three);
(anObject)={
  one:'_',
  var1:((var1==3)+'_')[one],
  var2ﾉ:(var1+'_')[three-(one)],
  var4ﾉ:((threeThenFour==3)+'_')[threeThenFour]
};
(anObject)[one]=((var1==3)+'_')[c ^ _ ^ three];
(anObject)['c']=((anObject)+'_')[(threeThenFour)+(threeThenFour)-(one)];
(anObject)['three']=((anObject)+'_')[one];
(theConstructor)=(anObject)['c']+
  (anObject)['three']+
  (var1+'_')[one]+
  ((var1==3)+'_')[threeThenFour]+
  ((anObject)+'_')[(threeThenFour)+(threeThenFour)]+
  ((threeThenFour==3)+'_')[one]+
  ((threeThenFour==3)+'_')[(threeThenFour)-(one)]+
  (anObject)['c']+
  ((anObject)+'_')[(threeThenFour)+(threeThenFour)]+
  (anObject)['three']+
  ((threeThenFour==3)+'_')[one];

// theConstructor => "constructor" 

(anObject)['_']=(three)[theConstructor][theConstructor];
(theReturn)=((threeThenFour==3)+'_')[one]+
  (anObject).var4ﾉ+
  ((anObject)+'_')[(threeThenFour)+(threeThenFour)]+
  ((threeThenFour==3)+'_')[three-one]+
  ((threeThenFour==3)+'_')[one]+
  (var1+'_')[one];

// theReturn => "return"

(threeThenFour)+=(one);
(anObject)[theReturn]='\\';
(anObject).var3ﾉ=(anObject+threeThenFour)[three-(one)];
(ovar2o)=(var1+'_')[c ^ _ ^ three];
(anObject)[theConstructor]='\"';

// (anObject)['_'] => Function

(anObject)['_'](
  (anObject)['_'](theReturn+
                 (anObject)[theConstructor]+
                 (anObject)[theReturn]+
                 (one)+
                 (threeThenFour)+
                 (one)+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+(
                   threeThenFour)+
                 ((threeThenFour)+(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)+(three))+
                 ((three)-(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)+(three))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 ((threeThenFour)+(one))+
                 (c ^ _ ^ three)+
                 (anObject)[theReturn]+
                 (threeThenFour)+((three)-(one))+
                 (anObject)[theReturn]+
                 (one)+(one)+
                 (c ^ _ ^ three)+
                 (anObject)[theReturn]+
                 (one)+
                 (threeThenFour)+
                 ((threeThenFour)+(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 ((threeThenFour)+(three))+
                 (anObject)[theReturn]+
                 (threeThenFour)+
                 (c ^ _ ^ three)+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)-(one))+
                 ((threeThenFour)+(three))+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 ((threeThenFour)+(three))+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)+(three))+
                 ((three)-(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+
                 (threeThenFour)+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (threeThenFour)+
                 ((three)-(one))+
                 (anObject)[theReturn]+
                 ((threeThenFour)+(one))+
                 (one)+
                 (anObject)[theConstructor]
                )
  (one)
)('_');

Ответ 3

Позвольте мне объяснить ключевые шаги:

Код создает объект с именем Д и затем добавляет свойство '_', которое имеет значение magic JavaScript конструктор функций. В JavaScript вы можете выполнить любую строку как код, передав ее в конструктор Function.

Как (ﾟДﾟ)['_'] содержит конструктор функций? Это умная техника, выполняемая по следующей строке:

(ﾟДﾟ)['_'] = (o^_^o)[ﾟoﾟ][ﾟoﾟ];

Здесь o и _ установлено в 3. Итак, o^_^o возвращается к 3. Очевидно, автор мог бы просто использовать o, потому что o^_^o возвращает то же значение, но я думаю, что у него хороший вкус для обфускации:). Таким образом, вышеприведенное выражение теперь становится (3)[ﾟoﾟ][ﾟoﾟ].

Значение ﾟoﾟ в квадратной скобке задается строкой "конструктор", которая была построена путем конкатенации в предыдущем выражении. Он использует очень умный способ создания строки "конструктор", вырывая отдельные символы из встроенных строк JavaScript, таких как "объект", "истина", "ложь" и "undefined", которые генерируются из выражений JavaScript, преобразованных в строка. Видимо, автор не смог найти персонажа "c", чтобы отрываться от этих встроенных строк, поэтому он должен был написать это явно. Обратите внимание, что символ в квадратной скобке есть ゚ o ゚, который является символом Unicode, а не простой o, используемый в круглых скобках, хотя оба они выглядят очень похожими. Когда вы выполняете (3)("constructor"), он возвращает функцию Функция конструктора чисел. Конструктор конструктора Number является конструктором Function. Таким образом, делая (3)("constructor")("constructor"), вы получаете конструктор функций, который теперь вы можете, наконец, передать произвольную строку для ее выполнения.

Последняя строка строит строку "alert(\"Hello World\")" и передает ее в конструктор Function для выполнения.

Вопрос: как мы можем получить эту строку "alert(\"Hello World\")" без ввода фактического алфавита? Умный метод заключается в использовании \xxx, где xxx - восьмеричное число и переводится в символ. Чтобы получить эту строку, вам нужны цифры 0, 1, 2, 3, 4, 5, 6, 7 и 8. Но вам действительно не нужны все эти, вместо этого вы можете создать их простой арифметикой с тремя номерами 0, 1 и 4. Так, например, чтобы создать символ 'a' в "alert", вам понадобится ASCII decimal 97 или восьмеричный 141, т.е. \141. Если у вас есть только 0, 1 и 4, хранящиеся в каком-либо свойстве выше объекта, вы можете связать их с созданием 'a'. Таким образом, вы можете сгенерировать любую строку, даже если все, что у вас есть, это 0, 1 и 4, хранящиеся в некоторых свойствах объекта Д. Умная? Вы делаете ставку!