JSF ** k только с 5 символами?

Это не вызов, а вопрос, я решил, что это было по теме из-за

Вопросы, не связанные с заданиями, связанные с решением головоломок по программированию или с определенным типом задач, также обсуждаются.

Теперь к вопросу:

Можно ли написать какой-либо код JavaScript всего с 5 буквами? JSFuck уже делает это с 6 символами, !+[]()но мне интересно, !нужен ли персонаж.

JSFuck работает с комбинацией приведения к строке (путем добавления пустого массива), приведения к числу (путем написания + перед) и приведения к логическому значению путем отрицания. Например:

[]        \\ Empty array
+[]       \\ Cast to number -> 0
!+[]      \\ Negate -> true
!+[]+[]   \\ Cast to string -> "true"

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

Таким образом, можно найти много букв, которые можно объединить в строки. Самая важная строка, которую можно создать, заключается в том, "constructor"что ее можно использовать для получения Functionлюбой функции, а этот объект можно использовать для выполнения строк в виде JavaScript:

[]["find"]                          \\ the function Array.prototype.find
[]["find"]["constructor"]           \\ the Function object
[]["find"]["constructor"](string)() \\ same as eval(string)

Как вы можете видеть, !имеет 2 использования здесь:

• Создание чисел для выбора букв из строк.
• Кастинг на логическое значение, чтобы получить "true"и "false".

Первый из этих 2 также можно сделать с помощью ++инкремента, а не непосредственно 0, но он может быть использован для элементов внутри массива:

+[]          \\ 0
[+[]]        \\ [0]
[+[]][+[]]   \\ [0][0] -> 0
++[+[]][+[]] \\ ++[0][0]-> 1
++[[]][+[]]  \\ also works because ++ casts to number

Таким образом, все номера могут быть созданы без !.

Второй сложнее. Важность "true"и "false"лежит в письмах "r"и "s", которые оба появляются в "constructor". Я уже нашел все остальные буквы "constructor"с помощью "undefined", "Infinity", "NaN"и литьем функции строк.

Итак, главный вопрос: (Как) вы можете создавать булевы или буквы "r"и "s"в JavaScript, используя только +[]()?

Письмо "l"может также помочь. Его можно получить из формы, nullно я не смог получить это значение с этими 5 символами. Например, он может быть использован для получения логических значений, если у нас уже есть "s":

[]["includes"]()       \\ false
[+[]]["includes"](+[]) \\ true

Письмо "l"и "k"вместе даст доступ к "r":

([]+[])["link"]() \\ "<a href="undefined"></a>"

Любой способ получить логическое значение nullили любую из букв r s l kбудет очень полезным!

Библиотека того что имеем:

Array.prototype.find: [] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])]

Бесконечность: + ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + (+ + [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ []) + (+ []) + (+ []))

NaN: + [] [[]]

undefined: [] [[]]

0: + []

1: ++ [[]] [+ []]

2: (++ [[]] [+ []]) + (++ [[]] [+ []])

3: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

4: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []])

5: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []])

6: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

7: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

8: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

9: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

a: (+ [] [[]] + []) [++ [[]] [+ []]]

c: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]

d: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])]

e: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []])]

f: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []]) + (++ [[]] [+ []])]

i: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]

n: ([] [[]] + []) [++ [[]] [+ []]]

o: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]

t: (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ [] ) + (+ []) + (+ [])) + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ [] ])]

u: ([] [[]] + []) [+ []]

v: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]))]

y: (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ [] ) + (+ []) + (+ [])) + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ [] ]) + (++ [[]] [+ []])]

I: (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ [] ) + (+ []) + (+ [])) + []) [+ []]

N: (+ [] [[]] + []) [+ []]

"": ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (+ + [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [ ]) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [+ (++ [[]] [+ [] ] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (+ + [[]] [+ []]) + (++ [[]] [+ []])))]

(: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [+ (++ [[]] [+ []] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])))]

): ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [+ (++ [[]] [+ []] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])))]

{: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [+ (++ [[]] [+ []] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])))]

}: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [+ ((++ [[]] [+ [] ]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + [] + ((++ [[]] [+ []]) + ( ++ [[]] [+ []])))]

.: (+ (++ [[]] [+ []] + [] + (++ [[]] [+ []]) + ([] [[]] + []) [(++ [ []] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])] + (++ [[]] [+ [] ] + [] + (+ []) + (+ []))) + []) [++ [[]] [+ []]]

,:[[]] [([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []])] + ([] [(([] [[]] + []) [ (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[] ] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []] )] + ([] [[]] + []) [++ [[]] [+ []]] + ([] [(([] [[]] + []) [(++ [[ ]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) ]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [ + []])])] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])] + (+ [] [[]] + []) [++ [[]] [+ []]] + (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + ( ++ [[]] [+ []] + []) + (+ []) + (+ []) + (+ [])) + []) [(++ [[]] [+ [] ]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[ ]] [+ []]) + (++ [[]] [+ []])]] ([[]]) + []

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

Я постараюсь подвести итог всего процесса, добавив некоторые соображения о том, почему мы исчерпали наши возможности в любом конкретном домене, прежде чем двигаться дальше. Затем, за исключением какого-то удивительного нового понимания (например, углового случая синтаксиса JavaScript, о котором все забывают), будет совершенно ясно, что нет способа получить оставшиеся буквы.

литералы

Единственный непосредственные литералами вы можете сделать с +()[]являются вложенными пустыми массивами [], [[]], [[[]]]и т.д. Оттуда, мы можем начать литье значения с помощью +:

• +[]получает ноль, который трюк Йенса расширяет до произвольных натуральных чисел, используя ++.

• []+[]есть "". На самом деле, []+xполучает нам строковое представление xв целом.

[]Следующее использование индексации. Индексирование объекта вне границ ( [][[]]) поможет вам undefined. Приведение этого к строке и индексация результата дает вам буквы d e f i n u; приведение его к целому числу вначале с использованием +get NaN, из которого a Nследуют буквы .

Использование ++трюка на любом нецелочисленном значении, которое было достигнуто до сих пор, дает NaNили ошибку. Кроме того, ни один из объектов, которые мы можем создать, не вызывается (пока), поэтому ()это не помогает (за исключением группировки).

Остальные трюки в нашем рукаве - это кастинг и индексация. Итак, вопрос в том, какие строки мы можем создать, используя символы, 0123456789adefinuNкоторые либо

• числовые литералы, которые мы можем преобразовать в целое число, чтобы получить новые строки, или
• имена свойств объектов, которые мы уже можем получить?

Числовые литералы

В качестве примера второго варианта, то мы можем сделать строку "1e1000", а затем получить Infinityот +"1e1000"и отливка , что обратно в строку получает нам письмо yи I.

Также мы можем сделать "11e100", приведение к числу и обратно к строке, чтобы получить "1.1e+101", из чего мы извлекаем .и +.

Используя это ., в свою очередь, мы можем составить строку ".0000001", привести ее к числу и обратно, чтобы получить "1e-7", выиграв нас -.

Это в основном все типы с плавающей запятой, которые вы получите: нет более интересных значений, кроме Infinityи NaN, и больше нет символов, используемых в их обычных строковых представлениях, кроме -+.0123456789e.

свойства

Итак, у нас есть письма -+.0123456789adefinuyIN. Какие свойства мы можем достичь? Давайте спросим JavaScript.

>>> R = /^[-+.0123456789adefinuyIN]+$/
>>> [Array, Object, String, Number].reduce((h, f) => {
        h[f.name] = Object.getOwnPropertyNames(f.prototype).filter(x => x.match(R));
        return h }, {})

{ Array: [ 'find' ], Object: [], String: [], Number: [] }

Единственное [].find, что Йенс уже нашел. Давайте приведем это к строке, пожнем все ее буквы и попробуем снова. Строковое представление немного отличается в разных браузерах. На Chrome и Edge, "function find() { [native code] }"содержится acdefinotuv()[]{}и пробел; наш полный алфавит сейчас +-.()[]{}0123456789INacdefinotuvy. На Firefox есть больше пробелов и новых строк, но буквы одинаковы.

Мы повторяем наш поиск:

>>> R = /^[+-.()\[\]{}0123456789INacdefinotuvy]+$/
>>> [Array, Object, String, Number, Function].reduce((h, f) => {
        h[f.name] = Object.getOwnPropertyNames(f.prototype).filter(x => x.match(R));
        return h }, {})

{ Array: [ 'concat', 'find' ],
  Object: [],
  String: [ 'concat' ],
  Number: [],
  Function: [] }

String.prototype.concatустарела: она делает именно то, что +делает, что мы уже можем сделать. Итак, мы получили Array.prototype.concatи Array.prototype.find. Что мы можем с ними сделать?

функции

concat()позволяет нам создавать более длинные массивы. [[]].concat([[]])есть [[], []], и приведение к строке получает нас ",". (Это не помогает нам находить новые свойства.) Но .concatне изменяет наши значения, и оно никогда не сможет вернуть nullили что-то в этом роде.

Звонок find()нам тоже не поможет: документация MDN гласит:

find()Метод возвращает значение в массиве, если элемент в массиве удовлетворяет условиям функции. В противном случае undefinedвозвращается.

Оба из них мы уже можем сделать с помощью индексации.

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

3 функции в ответе Линн не были такими бесполезными. Но строгий режим в ECMAScript 5 сорвал мой план.

В старых версиях JavaScript / ECMAScript есть странность. Если метод вызывается без объекта, windowпредполагается глобальный объект . Итак, мы можем сделать это:

a = {f:function(){return this}};
a.f();                            // Returns a.
g = a.f;
g();                              // Returns window.
window.g();                       // Also returns window.

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

Предположим, мы используем старые браузеры. Затем, если мы хотим window, мы должны найти встроенную функцию, которая возвращает что-то содержащее this. В нашем единственном выборе есть функция, которая Array.prototype.concatделает именно это. Мы можем проверить это так:

Number.prototype.concat = Array.prototype.concat;
1..concat(2);                     // Returns [1, 2]
concat = Array.prototype.concat;
window.concat(2);                 // Returns [window, 2]
concat(2)                         // TypeError in modern browsers while
                                  //   returning the same thing in older ones.
concat.bind(window)(2)            // A workaround in modern browsers.

Таким образом, в основном не имеет значения, является ли объект, к которому он вызывается, массивом (но, по крайней мере, он должен быть объектом). Он просто оборачивает его в массив, если нет.

Если бы мы имели window, во-первых, мы можем получить строку [object Window], приведя ее к строке. С новым персонажем bмы можем получить rи sиспользовать следующие две строки соответственно, и каждый символ, которого у нас не было constructor:

window["atob"]("cuaa")[0]
window["atob"]("cyaa")[0]

Но другая проблема заключается в удалении ссылки на объект [].concat. Упаковка в массив и извлечение не работает, потому что [].concatуже означает []["concat"]. Единственный известный мне способ, который может быть сконструирован с использованием, +[]()- это вернуть его из функции. Array.prototype.findказалось, что смог сделать это:

[[]["concat"]]["find"](x=>1)      // Returns Array.prototype.concat, where x=>1 can
                                  //   be replaced with any always truthy function.

У нас всегда были правдивые функции. Array.prototype.concatи String.prototype.concatоба возвращают истину, если объект есть window. Если мы используем более позднюю версию, мы использовали все три доступные функции.

Но, к сожалению, Array.prototype.findне существует в старом браузере, который мы используем. По крайней мере, я не нашел тот, который работает. И я не нашел другого способа удалить ссылку на объект.

Полный код, который можно тестировать в современных браузерах, который возвращает rи s, с .bind(window)обходным путем:

[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0]["ato"+([]+[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0])[2]]("cuaa")[0];
[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0]["ato"+([]+[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0])[2]]("cyaa")[0]