JSF ** k con solo 5 símbolos?

Esto no es un desafío sino una pregunta, pensé que estaba en el tema debido a

Las preguntas que no son de desafío relacionadas con la resolución de acertijos de programación o un tipo particular de desafío también están en el tema.

Ahora a la pregunta:

¿Es posible escribir algún código JavaScript con solo 5 letras? JSFuck ya hace esto con 6 símbolos, !+[]()pero me pregunto si !se necesita el personaje.

JSFuck funciona con una combinación de conversión a cadena (agregando una matriz vacía), conversión a número (escribiendo un + al frente) y conversión a booleano al negar. Por ejemplo:

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

De esta cadena podemos extraer todas sus letras usando corchetes con un número dentro, y cualquier número se puede hacer sumando tantas veces como sea verdadero.

De esta manera, se pueden encontrar muchas letras y se pueden concatenar en cadenas. La cadena más importante para poder crear es "constructor"porque se puede usar para obtener Functionde cualquier función, y este objeto se puede usar para ejecutar cadenas como JavaScript:

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

Como puedes ver, !tiene 2 usos aquí:

• Crear números para seleccionar letras de cadenas.
• Fundición a booleana para obtener "true"y "false".

El primero de estos 2 también se puede hacer usando el ++incrementador, no directamente 0, pero se puede usar en elementos dentro de una matriz:

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

Por lo tanto, todos los números se pueden crear sin !.

El segundo es más difícil. La importancia de "true"y "false"en las letras "r"y "s", que aparecen en ambos "constructor". Ya he encontrado todas las otras letras de "constructor"a través de "undefined", "Infinity", "NaN"y por funciones de conversión de cadenas.

Entonces, la última pregunta: (¿Cómo) puede crear booleanos, o las letras "r"y "s"en JavaScript con solo usar +[]()?

La carta "l"también podría ayudar. Se puede obtener de forma nullpero no he podido obtener ese valor con esos 5 símbolos. Por ejemplo, se puede usar para obtener booleanos si ya tenemos "s":

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

La carta "l"y "k"juntos darían acceso a "r":

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

¡Cualquier forma de obtener un booleano, nullo cualquiera de las letras r s l ksería muy útil!

Una biblioteca de lo que tenemos:

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: (+ [] [[]] + []) [+ []]

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

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

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

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

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

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

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

Después de una lluvia de ideas , el resultado parece ser que, al menos en los navegadores modernos, no hay forma de hacerlo.

Trataré de resumir todo el proceso, agregando algunos razonamientos sobre por qué hemos agotado nuestras opciones en cualquier dominio antes de continuar. Luego, salvo algún tipo de información nueva y sorprendente (como un caso de esquina de la sintaxis de JavaScript que todos están olvidando) quedará bastante claro que no hay forma de obtener las letras restantes.

Literales

Las única inmediatos literales que puede hacer con +()[]son las matrices vacías anidados [], [[]], [[[]]], etc. A partir de ahí, podemos empezar valores mediante fundición +:

• +[]obtiene cero, que el truco de Jens expande a enteros positivos arbitrarios usando ++.

• []+[]es "". De hecho, []+xnos da una representación de cadena de xen general.

[]El siguiente uso es la indexación. Indexar un objeto fuera de los límites ( [][[]]) te atrapa undefined. Lanzar eso a una cadena e indexar el resultado te da las letras d e f i n u; lanzarlo a un número entero primero usando +te obtiene NaN, de donde a Nsiguen las letras .

El uso del ++truco en cualquier valor no entero alcanzado hasta ahora da NaNo se produce un error. Además, ninguno de los objetos que podemos crear son invocables (todavía), por lo ()que no ayuda (excepto la agrupación).

Los trucos restantes bajo nuestra manga son el casting y la indexación. Entonces la pregunta es: qué cadenas podemos crear usando los caracteres 0123456789adefinuNque

• son literales numéricos que podemos enviar de ida y vuelta al entero para obtener nuevas cadenas, o
• son nombres de propiedad de objetos que ya podemos alcanzar?

Números literales

Como un ejemplo de la segunda opción, podemos hacer la cadena "1e1000", y luego Infinitydesde +"1e1000"y fundición que volver a cadena no nos lleva a las letras yy I.

Además, podemos hacer "11e100", lanzar al número y volver a la cadena, para obtener "1.1e+101", de donde extraemos .y +.

Usando eso ., a su vez, podemos hacer la cadena ".0000001", lanzarla al número y viceversa, para obtener "1e-7", ganándonos -.

Eso es básicamente todos los flotantes lo conseguirán: no hay más valores interesantes que no sean Infinityy NaN, y no hay más caracteres utilizados en sus representaciones de cadenas habituales que no sean -+.0123456789e.

Propiedades

Entonces tenemos las letras -+.0123456789adefinuyIN. ¿Qué propiedades podemos alcanzar? Preguntemos 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: [] }

Solo [].find, que Jens ya encontró. Vamos a convertir eso en una cadena, cosechar todas sus letras e intentarlo de nuevo. La representación de la cadena es un poco diferente en todos los navegadores. En Chrome y Edge, "function find() { [native code] }"contiene acdefinotuv()[]{}y un espacio; Nuestro alfabeto completo es ahora +-.()[]{}0123456789INacdefinotuvy. En Firefox, hay más espacios y nuevas líneas, pero las letras son las mismas.

Repetimos nuestra búsqueda:

>>> 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á en desuso: hace exactamente lo que +hace, lo que ya podemos hacer. Así que tenemos Array.prototype.concaty Array.prototype.find. ¿Qué podemos hacer con ellos?

Las funciones

concat()nos permite crear, por primera vez, matrices más largas. [[]].concat([[]])es [[], []], y lanzar eso a una cuerda nos atrapa ",". (Esto no nos ayuda a encontrar nuevas propiedades). Pero .concatno modifica nuestros valores, y nunca puede regresar nullni nada de eso.

Llamar find()tampoco nos ayuda: la documentación de MDN dice

El find()método devuelve un valor en la matriz, si un elemento en la matriz satisface la función de prueba proporcionada. De undefinedlo contrario se devuelve.

Los dos ya podemos hacerlos usando la indexación.

Y a partir de aquí, no hay otro lugar a donde ir. Si dudas de algo que he escrito, házmelo saber en los comentarios.

Las 3 funciones en la respuesta de Lynn no fueron tan inútiles. Pero el modo estricto en ECMAScript 5 frustrado mi plan.

Hay una peculiaridad en las versiones anteriores de JavaScript / ECMAScript. Si se llama a un método sin un objeto, windowse supone el objeto global . Entonces podemos hacer esto:

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

Esto sigue siendo cierto para los navegadores modernos, pero solo si la función no está definida en modo estricto. Y todas las funciones integradas (con código nativo) parecían estar en modo estricto. En los navegadores más antiguos cuando todavía no existe el modo estricto, esto también funciona para las funciones integradas.

Supongamos que estamos usando navegadores antiguos. Entonces, si queremos window, tenemos que encontrar una función incorporada que devuelva algo que contenga this. Dentro de las únicas opciones que teníamos, está la función Array.prototype.concathaciendo exactamente eso. Podemos probarlo así:

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.

Entonces, básicamente no le importa si el objeto al que se llama es una matriz (pero debe ser un objeto en lo más mínimo). Simplemente lo envuelve en una matriz si no.

Si lo hubiéramos hecho window, en primer lugar podemos obtener la cadena [object Window]convirtiéndola en una cadena. Con el nuevo personaje b, podemos obtener ry susar las siguientes dos líneas respectivamente, y cada personaje que no teníamos en constructor:

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

Pero el otro problema es eliminar la referencia del objeto [].concat. Envolverlo en una matriz y extraer no funciona, porque [].concatya significa []["concat"]. La única forma en que sé cuál podría construirse usando +[]()es devolverlo desde una función. Array.prototype.findparecía ser capaz de hacer eso:

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

Siempre tuvimos funciones de verdad. Array.prototype.concaty String.prototype.concatambos devuelven la verdad si el objeto es window. Si usamos la última, usamos las tres funciones disponibles.

Pero, desafortunadamente, Array.prototype.findno existe en el navegador antiguo que estamos usando. Al menos no encontré uno que funcione. Y no encontré otra forma de eliminar la referencia del objeto.

El código completo que se puede probar en los navegadores modernos que regresa ry s, con la .bind(window)solución 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]