JSF ** k com apenas 5 símbolos?

Este não é um desafio, mas uma pergunta, imaginei que estava no tópico por causa de

Questões não desafiadoras relacionadas à solução de quebra-cabeças de programação ou a um tipo específico de desafio também estão no tópico.

Agora vamos à pergunta:

É possível escrever qualquer código JavaScript com apenas 5 letras? O JSFuck já faz isso com 6 símbolos, !+[]()mas me pergunto se o !personagem é necessário.

O JSFuck trabalha com uma combinação de conversão para string (adicionando uma matriz vazia), conversão para número (escrevendo um + na frente) e conversão para booleano negando. Por exemplo:

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

A partir dessa string, podemos extrair todas as letras usando colchetes com um número dentro, e qualquer número pode ser criado adicionando true juntos várias vezes.

Assim, muitas letras podem ser encontradas e concatenadas em strings. A string mais importante a ser capaz de criar é "constructor"porque ela pode ser usada para obter a Functionpartir de qualquer função e esse objeto pode ser usado para executar strings como JavaScript:

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

Como você pode ver, !tem 2 usos aqui:

• Criando números para selecionar letras de strings.
• Transmitindo para booleano para obter "true"e "false".

O primeiro desses 2 também pode ser feito usando o ++incrementador, não diretamente 0, mas pode ser usado em elementos dentro de uma matriz:

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

Assim, todos os números podem ser criados sem !.

O segundo é mais difícil. A importância de "true"e "false"deita nas letras "r"e "s", em que ambos aparecem "constructor". Eu já encontraram todas as outras letras "constructor"por meio de "undefined", "Infinity", "NaN"e lançando funções para strings.

Portanto, a pergunta final: (como) você pode criar booleanos ou as letras "r"e "s"em JavaScript usando apenas +[]()?

A carta "l"também pode ajudar. Pode ser obtido da forma, nullmas não consegui obter esse valor com esses 5 símbolos. Por exemplo, pode ser usado para obter booleanos se já tivermos "s":

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

A carta "l"e "k"juntos dariam acesso a "r":

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

Qualquer maneira de obter um booleano nullou qualquer uma das letras r s l kseria muito útil!

Uma biblioteca do que temos:

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

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

NaN: + [] [[]]

Indefinido: [][[]]

0: + []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Após o brainstorming , o resultado parece ser que, pelo menos nos navegadores modernos, não há como fazer isso.

Tentarei resumir todo o processo, adicionando alguns argumentos sobre por que esgotamos nossas opções em qualquer domínio antes de prosseguir. Depois, com exceção de algum tipo de insight novo e surpreendente (como uma caixa de canto da sintaxe JavaScript que todo mundo está esquecendo), ficará bem claro que não há como obter as letras restantes.

Literais

Os únicos imediatos literais que você pode fazer com +()[]são as matrizes vazias aninhadas [], [[]], [[[]]], etc. A partir daí, podemos começar a lançar valores usando +:

• +[]recebe zero, o truque de Jens se expande para números inteiros positivos arbitrários usando ++.

• []+[]é "". De fato, []+xnos fornece uma representação xem cadeia de caracteres em geral.

[]O próximo uso de indexação é. A indexação de um objeto fora dos limites ( [][[]]) leva você undefined. Ao converter isso em uma string e indexar o resultado, você recebe as letras d e f i n u; convertê-lo para um número inteiro primeiro usando +você recebe NaN, a partir do qual as letras a Nseguem.

Usando o ++truque em qualquer valor não inteiro atingido até agora, dá NaNou ocorre um erro. Além disso, nenhum dos objetos que podemos criar pode ser chamado (ainda), portanto (), não ajuda (exceto no agrupamento).

Os truques restantes na manga são de fundição e indexação. Portanto, a pergunta é: quais strings podemos criar usando os caracteres 0123456789adefinuNque

• são literais numéricos, podemos fazer uma conversão de ida e volta para um número inteiro para obter novas strings, ou
• são nomes de propriedades de objetos que já podemos alcançar?

Literais numéricos

Como exemplo da segunda opção, podemos criar a string "1e1000"e, em seguida , Infinitypartir de +"1e1000", e convertê-la de volta em string recebe as letras ye I.

Além disso, podemos fazer "11e100", converter para número e voltar para string, para obter "1.1e+101", de onde extraímos .e +.

Usando isso ., por sua vez, podemos fazer a corda ".0000001", lançá-la para numerar e voltar, para conseguir "1e-7", nos ganhar -.

Isso é basicamente o que todos os carros alegóricos conseguirão: não existem valores mais interessantes além de Infinitye NaN, e não há mais caracteres usados ​​em suas representações comuns de cadeias além de -+.0123456789e.

Propriedades

Então, nós temos as letras -+.0123456789adefinuyIN. Quais propriedades podemos alcançar? Vamos pedir 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: [] }

Somente o [].findque Jens já encontrou. Vamos converter isso em uma string, colher todas as letras e tentar novamente. A representação de strings é um pouco diferente nos navegadores. No Chrome e Edge, "function find() { [native code] }"contém acdefinotuv()[]{}e um espaço; nosso alfabeto completo é agora +-.()[]{}0123456789INacdefinotuvy. No Firefox, há mais espaços e novas linhas, mas as letras são as mesmas.

Repetimos nossa pesquisa:

>>> 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.concatestá obsoleto: faz exatamente o que +faz, o que já podemos fazer. Então nós temos Array.prototype.concate Array.prototype.find. O que podemos fazer com eles?

Funções

concat()vamos criar, pela primeira vez, matrizes mais longas. [[]].concat([[]])é [[], []], e lançar isso para uma string nos leva ",". (Isso não nos ajuda a encontrar novas propriedades.) Mas .concatnão modifica nossos valores e nunca pode retornar nullou algo assim.

Ligar find()também não ajuda: a documentação do MDN diz

O find()método retorna um valor na matriz, se um elemento na matriz atender à função de teste fornecida. Caso contrário, undefinedé retornado.

Ambos já podemos fazer usando a indexação.

E daqui, não há mais para onde ir. Se você duvidar de qualquer coisa que escrevi, deixe-me saber nos comentários.

As três funções na resposta de Lynn não eram tão inúteis. Mas o modo estrito no ECMAScript 5 frustrou meu plano.

Há uma peculiaridade nas versões mais antigas do JavaScript / ECMAScript. Se um método for chamado sem um objeto, o objeto global windowserá assumido. Para que possamos fazer isso:

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

Isso ainda é verdade para navegadores modernos, mas apenas se a função não estiver definida no modo estrito. E todas as funções internas (com código nativo) pareciam estar no modo estrito. Em navegadores antigos, quando ainda não existe o modo estrito, isso também funciona para funções internas.

Suponha que estamos usando navegadores mais antigos. Então, se quisermos window, precisamos encontrar uma função interna que retorne algo que contenha this. Dentro das únicas opções que tivemos, há a função Array.prototype.concatfazendo exatamente isso. Podemos testá-lo assim:

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.

Então, basicamente, não se importa se o objeto chamado é uma matriz (mas deve ser um objeto para o mínimo). Apenas o envolve em uma matriz, se não.

Se tivéssemos window, em primeiro lugar, podemos obter a string [object Window]lançando-a em uma string. Com o novo personagem b, podemos obter re susar as duas linhas a seguir, respectivamente, e todos os personagens que não possuímos constructor:

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

Mas o outro problema é remover a referência do objeto [].concat. Envolvê-lo em uma matriz e extrair não funciona, porque [].concatjá significa []["concat"]. A única maneira que eu sei que poderia ser construída usando +[]()é retorná-lo de uma função. Array.prototype.findparecia capaz de fazer isso:

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

Sempre tivemos funções verdadeiras. Array.prototype.concate String.prototype.concatambos retornam verdade se o objeto é window. Se usarmos a última, utilizamos todas as três funções disponíveis.

Infelizmente , porém,Array.prototype.find não existe no navegador antigo que estamos usando. Pelo menos eu não encontrei um que funcione. E não encontrei outra maneira de remover a referência do objeto.

O código completo testável em navegadores modernos que retorna re s, com a .bind(window)solução alternativa:

[[]["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]