JSF ** k con solo 5 simboli?

Questa non è una sfida ma una domanda, ho pensato che fosse in tema a causa di

Sono anche in discussione le domande non di sfida relative alla risoluzione di enigmi di programmazione o un particolare tipo di sfida.

Passiamo ora alla domanda:

È possibile scrivere un codice JavaScript con solo 5 lettere? JSFuck lo fa già con 6 simboli !+[]()ma mi chiedo se il !personaggio sia necessario.

JSFuck funziona con una combinazione di casting in stringa (aggiungendo un array vuoto), casting in numero (scrivendo un + in primo piano) e casting in booleano negando. Per esempio:

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

Da questa stringa possiamo estrarre tutte le sue lettere usando le parentesi quadre con un numero all'interno, e qualsiasi numero può essere creato sommando il vero insieme più volte.

In questo modo è possibile trovare molte lettere che possono essere concatenate a stringhe. La stringa più importante da creare è "constructor"perché può essere utilizzata per ottenere Functionda qualsiasi funzione e questo oggetto può essere utilizzato per eseguire stringhe come JavaScript:

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

Come puoi vedere, !ha 2 usi qui:

• Creazione di numeri per selezionare lettere dalle stringhe.
• Casting in booleano per ottenere "true"e "false".

Il primo di questi 2 può anche essere fatto usando l' ++incremento, non direttamente su 0, ma può essere usato su elementi all'interno di un array:

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

Quindi tutti i numeri possono essere creati senza !.

Il secondo è più difficile. L'importanza di "true"e "false"risiede nelle lettere "r"e "s", che appaiono entrambe "constructor". Ho già trovato tutte le altre lettere di "constructor"tramite "undefined", "Infinity", "NaN"e da funzioni colata in stringhe.

Quindi l'ultima domanda: (come) puoi creare booleani, o le lettere "r"e "s"in JavaScript usando solo +[]()?

La lettera "l"potrebbe anche aiutare. Può essere ottenuto dalla forma nullma non sono stato in grado di ottenere quel valore con quei 5 simboli. Ad esempio, può essere usato per ottenere booleani se abbiamo già "s":

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

La lettera "l"e "k"insieme darebbero accesso a "r":

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

Qualsiasi modo per ottenere un booleano nullo una delle lettere r s l ksarebbe molto utile!

Una libreria di ciò che abbiamo:

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

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

NaN: + [] [[]]

non definito: [][[]]

0: + []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Dopo il brainstorming , il risultato sembra essere che, almeno sui browser moderni, non c'è modo di farlo.

Cercherò di riassumere l'intero processo, aggiungendo alcuni ragionamenti sul perché abbiamo esaurito le nostre opzioni in un determinato dominio prima di passare. Quindi, escludendo una sorta di sorprendente nuova intuizione (come, un caso angolare di sintassi JavaScript che tutti dimenticano) sarà abbastanza chiaro che non c'è modo di ottenere le lettere rimanenti.

letterali

L'unico immediati letterali si possono fare con +()[]sono le matrici vuote nidificati [], [[]], [[[]]], ecc Da lì, possiamo iniziare valori usando fusione +:

• +[]ottiene zero, che il trucco di Jens si espande in interi positivi arbitrari usando ++.

• []+[]lo è "". In effetti, []+xci dà una rappresentazione in forma di stringa xin generale.

[]Il prossimo utilizzo è l'indicizzazione. Indicizzare un oggetto fuori limite ( [][[]]) ti dà undefined. Lanciandolo su una stringa e indicizzando il risultato otterrai le lettere d e f i n u; lanciandolo su un numero intero usando prima +ottieni te NaN, da cui a Nseguono le lettere .

Utilizzando il ++trucco su qualsiasi valore non intero raggiunto finora dà NaNo un errore. Inoltre, nessuno degli oggetti che possiamo creare è richiamabile (ancora), quindi ()non aiuta (tranne che per il raggruppamento).

I restanti trucchi nella manica sono il cast e l'indicizzazione. Quindi la domanda è: quali stringhe possiamo creare usando 0123456789adefinuNentrambi i caratteri

• sono letterali numerici che possiamo eseguire il round trip di cast in numero intero per ottenere nuove stringhe o
• sono i nomi delle proprietà degli oggetti che possiamo già raggiungere?

Numero letterale

Come esempio della seconda opzione, possiamo creare la stringa "1e1000", quindi ottenere Infinityda +"1e1000", e restituire quella stringa alla stringa ci dà le lettere ye I.

Inoltre, possiamo creare "11e100", eseguire il cast al numero e tornare alla stringa, per ottenere "1.1e+101", da cui estraiamo .e +.

Usandolo ., a sua volta, possiamo creare la stringa ".0000001", lanciarla in numero e ritorno, per ottenere "1e-7", vincendoci -.

Questo è fondamentalmente tutto ciò che i float ti porteranno: non ci sono valori più interessanti oltre Infinityae NaN, e non ci sono più caratteri usati nelle loro solite rappresentazioni di stringa oltre a -+.0123456789e.

Proprietà

Quindi abbiamo le lettere -+.0123456789adefinuyIN. Quali proprietà possiamo raggiungere? Chiediamo 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, che Jens ha già trovato. Trasmettiamolo su una stringa, raccogli tutte le sue lettere e riprova. La rappresentazione della stringa è leggermente diversa nei browser. Su Chrome e Edge, "function find() { [native code] }"contiene acdefinotuv()[]{}e uno spazio; il nostro alfabeto completo è ora +-.()[]{}0123456789INacdefinotuvy. Su Firefox, ci sono più spazi e nuove righe, ma le lettere sono uguali.

Ripetiamo la nostra ricerca:

>>> 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è deprecato: fa esattamente ciò che +fa, cosa che possiamo già fare. Quindi abbiamo ottenuto Array.prototype.concate Array.prototype.find. Cosa possiamo fare con loro?

funzioni

concat()ci consente di creare, per la prima volta, array più lunghi. [[]].concat([[]])è [[], []], e lanciarlo su una stringa ci ottiene ",". (Questo non ci aiuta a trovare nuove proprietà.) Ma .concatnon modifica i nostri valori e non può mai tornare nullo qualcosa del genere.

Chiamare find()non ci aiuta neanche: dice la documentazione MDN

Il find()metodo restituisce un valore nella matrice, se un elemento nella matrice soddisfa la funzione di test fornita. Altrimenti undefinedviene restituito.

Entrambi possiamo già fare usando l'indicizzazione.

E da qui, non c'è altro posto dove andare. Se dubiti di qualcosa che ho scritto, fammi sapere nei commenti.

Le 3 funzioni nella risposta di Lynn non erano così inutili. Ma la modalità rigorosa in ECMAScript 5 ha sventato il mio piano.

C'è una stranezza nelle versioni precedenti di JavaScript / ECMAScript. Se viene chiamato un metodo senza un oggetto, windowviene assunto l'oggetto globale . Quindi possiamo farlo:

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

Questo è ancora vero per i browser moderni, ma solo se la funzione non è definita in modalità rigorosa. E tutte le funzioni integrate (con codice nativo) sembravano essere in modalità rigorosa. Nei browser meno recenti, quando non esiste ancora la modalità rigorosa, funziona anche per le funzioni integrate.

Supponiamo di utilizzare browser meno recenti. Quindi, se vogliamo window, dobbiamo trovare una funzione integrata che restituisca qualcosa che contiene this. All'interno delle uniche scelte che abbiamo avuto, c'è la funzione che Array.prototype.concatfa esattamente questo. Possiamo testarlo in questo modo:

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.

Quindi in pratica non importa se l'oggetto a cui è chiamato è un array (ma deve essere un oggetto per il minimo). In caso contrario, lo avvolge in un array.

Se avessimo avuto window, in primo luogo possiamo ottenere la stringa [object Window]lanciandola su una stringa. Con il nuovo personaggio b, possiamo ottenere re susare rispettivamente le seguenti due righe e ogni personaggio in cui non avevamo constructor:

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

Ma l'altro problema è rimuovere il riferimento all'oggetto da [].concat. Avvolgerlo in un array ed estrarre non funziona, perché [].concatgià significa []["concat"]. L'unico modo in cui so quale potrebbe essere costruito usando +[]()è quello di restituirlo da una funzione. Array.prototype.findsembrava essere in grado di farlo:

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

Abbiamo sempre avuto funzioni sincere. Array.prototype.concated String.prototype.concatentrambi restituiscono la verità se l'oggetto lo è window. Se utilizziamo quello successivo, abbiamo utilizzato tutte e tre le funzioni disponibili.

Ma, sfortunatamente, Array.prototype.findnon esiste nel vecchio browser che stiamo utilizzando. Almeno non ne ho trovato uno che funzioni. E non ho trovato un altro modo per rimuovere il riferimento all'oggetto.

Il codice completo che è testabile nei browser moderni che restituisce re s, con la .bind(window)soluzione 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]