Discussion :

[SylvainPV]

Salut à tous,

En me renseignant sur les techniques d'obfuscation en Javascript j'ai appris que certains outils savaient remplacer les String en dur dans le code par des équivalents illisibles à bases de cast douteux entre Array, String et Number.
J'ai creusé un peu pour savoir jusqu'où on pouvait aller. Je me suis aperçu que simplement avec les caractères "[", "+" et "]", on pouvait déjà aller très loin !

+[] donne 0 par cast de l'opérateur +
Pour avoir 1, on pourrait essayer +[]++ mais on ne peut appliquer qu'un seul opérateur à la fois.
Cependant, si on place le tout dans une array dont on récupère le premier élément pour ensuite l'incrémenter, là ça fonctionne :
1: [+[]][0]++
Et comme on sait écrire 0, on arrive à :

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

qu'on peut écrire de manière plus courte par :

1: ++[[]][+[]] (merci Kaamo)

En suivant le même principe d'incrémentation à répétition, on arrive à récupérer tous les chiffres.

Maintenant les lettres !

"" : []+[]
"1" : []+1
"0" : []+0
undefined : [][+[]]
"undefined" : undefined + []

Génial, undefined en string, un tableau de caractères dont on va pouvoir récupérer certaines lettres via les index numériques (qu'on sait déjà coder)

On peut faire la même chose pour NaN : +[][+[]] pour récupérer le N majuscule et le a.

Dernière découverte de la soirée, on pourrait se servir de l'objet Infinity. Incrémenter de un à un jusqu'à l'infini est évidémment bien trop long, mais il existe une autre technique: caster le nombre en notation exponentielle. Comme on a le "e" grâce à "undefined", on peut écrire "1e1000" qui casté en nombre dépasse Number.MAX_VALUE, et donne Infinity. Bingo, des lettres en plus

Je n'ai pas d'autres idées pour le moment, mais j'ai déjà de quoi faire des trucs sympas. Par exemple lâchez ça en console Javascript :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[[]+[][+[]]][+[]][++[++[++[++[+[]][+[]]][+[]]][+[]]][+[]]]+[[]+[][+[]]][+[]][+[]]+[[]+[][+[]]][+[]][++[+[]][+[]]]+[[]+[][+[]]][+[]][++[+[]][+[]]]+[+[++[+[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[+[]][+[]]][+[]]][+[]]]+[++[+[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][++[++[++[++[++[++[++[+[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]

Voilà la liste des caractères que j'ai trouvé et leur traduction en [+] :

0: +[]
1: ++[[]][+[]]
2: ++[++[[]][+[]]][+[]]
3: ++[++[++[[]][+[]]][+[]]][+[]]
4: ++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]
5: ++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]
6: ++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]
7: ++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]
8: ++[++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]
9: ++[++[++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]

undefined : [][+[]]
NaN : +[][+[]]
Infinity : +[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]

"" : []+[]
[]+1 : "1"
[]+0 : "0"
undefined + []: "undefined"

a: [+[]+[][+[]]+[]][+[]][++[[]][+[]]]
d: [[]+[][+[]]][+[]][++[++[[]][+[]]][+[]]]
e: [[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]
f: [[]+[][+[]]][+[]][++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]]
i: [[]+[][+[]]][+[]][++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]]
n: [[]+[][+[]]][+[]][++[[]][+[]]]
t: [+[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]
u: [[]+[][+[]]][+[]][+[]]
y: [+[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]

I: [+[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][+[]]
N: [+[][+[]]+[]][+[]][+[]]

Bon on est bien d'accord que tout cela ne sert strictement à rien, ce n'est absolument pas performant en termes d'obfuscation, mais je trouve ça assez fun

Donc si vous avez d'autres idées pour aller trouver d'autres lettres, balancez !

Là j'ai peut-être une piste en cherchant avec les lettres dont je dispose une fonction dans le prototype de Array / String / Number / Object, puis caster cette fonction en String pour en récupérer une forme littérale. Quelque-chose comme ça :

[""][0]["big"]+[] --> "function big() { [native code] }"

Mais je ne trouve pas de fonction dont je dispose de toutes les lettres. Je pourrais aussi peut-être essayer de choper l'objet Date, mais il me manque le D majuscule...

[danielhagnoul]

Bon on est bien d'accord que tout cela ne sert strictement à rien, ce n'est absolument pas performant en termes d'obfuscation, mais je trouve ça assez fun

Chacun trouve son petit plaisir comme il peut, mais il est clair que l'on ne pratique pas les mêmes méthodes.

[Auteur]

Avec Infinity tu as le "i" en majuscule et minuscule. Peut-être peux-tu trouver une fonction qui te permettrait de réaliser des conversions majuscules / minuscules et inversement ?

Tu as aussi "d", "e", "f" il doit bien y avoir une relation logique entre ces lettres, non ? Et ainsi trouver les lettres manquantes ?

[Lorenzo77]

génial, tout simplement génial !

tu peux recup NaN plus simplement : {}+

avec ca tu peux avoir "[object Object]" : ({})+[]
--> tu peux ensuite récupérer les lettres : (({})+[])[1]
--> ca fait 6 lettres en +

-----------
une piste possible avec les opérateurs binaires ?

[SylvainPV]

@Auteur: j'aimerais bien pouvoir faire un toLowerCase ou toUpperCase, ou même juste un charcodeAt, mais c'est loin d'être facile avec les éléments à disposition. Si je pouvais j'aurais de quoi faire l'objet Date.

@Lorenzo: ha oui mais en utilisant les signes { } et ( ) c'est trop facile

[Kaamo]

Salut Sylvain !
Haha je vois que je ne suis pas le seul fou à bord. J'avais commencé à m'amuser avec ça y'a quelques mois.

Le 1, tu peux l'avoir plus facilement ++[[]][+[]].
Idem donc pour les autres chiffres, tu peux gagner un caractère (le +).

++[+[]][+[]] === ++[[]][+[]]

[SylvainPV]

Merci Kaamo
J'en suis pas encore à l'étape d'optimisation, j'aimerais vraiment débloquer d'autres lettres, après quoi ça laisserait porte ouverte à tout et n'importe quoi

[Kaamo]

Avec seulement le charset [+], je pense que tu as déjà fait le tour de ce qui est possible. Il va falloir que tu t'accordes un charset un peu plus large

[SylvainPV]

Après plusieurs heures de recherche je crois en effet que j'ai besoin d'étendre mon charset pour me débloquer.

Accéder aux booléens serait une aide appréciable, donc j'ai pensé inclure l'opérateur "!"

Cela me permet de faire :
false: ![]
true: !![]
et de récupérer les lettres t, r, a, l et s

Aussi cela réduit un peu la taille du code pour récupérer les chiffres.
Grâce à ces nouvelles lettres, je peux choper []["filter"] dans le prototype Array qui une fois casté en string me donne "function filter() { [native code] }"
A partir de là, le résultat varie un peu selon les navigateurs, donc je perds la portabilité du code. Mais cela me donne le c, le o, et le v, ainsi que les caractères ( ) { } [ ] et le whitespace.

Seulement, même si j'ai de quoi faire "eval", je suis de nouveau bloqué car je ne peux pas l'exécuter en tant que fonction. Pour cela j'ai besoin des caractères parenthèses ( ) ; donc je songe à les inclure aussi au charset, bien que six caractères c'est beaucoup moins impressionnant que trois...

Voilà où j'en suis avec le charset [+!]

0: +[]
1: +!+[]
2: +!+[]+!![]
3: +!+[]+!![]+!![]
4: +!+[]+!![]+!![]+!![]
5: +!+[]+!![]+!![]+!![]+!![]
6: +!+[]+!![]+!![]+!![]+!![]+!![]
7: +!+[]+!![]+!![]+!![]+!![]+!![]+!![]
8: +!+[]+!![]+!![]+!![]+!![]+!![]+!![]+!![]
9: +!+[]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]
10: +[+!+[]+[]+[+[]]][+[]]

a: [![]+[]][+[]][+!+[]]
c: [[]+[][[![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[!![]+[]][+[]][++[[]][+[]]]]][+[]][+!+[]+!![]+!![]]
d: [[]+[][+[]]][+[]][++[++[[]][+[]]][+[]]]
e: [[][+[]]+[]][+[]][+!+[]+!![]+!![]]
f: [![]+[]][+[]][+[]]
i: [[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]
l: [![]+[]][+[]][++[++[[]][+[]]][+[]]]
n: [[][+[]]+[]][+[]][+!+[]]
o: [[][[![]+[]][+[]][+[]]+[[]+[][+[]]][+[]][++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[!![]+[]][+[]][++[[]][+[]]]]+[]][+[]][++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]
r: [!![]+[]][+[]][++[[]][+[]]]
s: [![]+[]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]
t: [!![]+[]][+[]][+[]]
u: [[]+[][+[]]][+[]][+[]]
v: [[]+[][[![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[!![]+[]][+[]][++[[]][+[]]]]][+[]][+[+!+[]+!![]+[]+[+!+[]+!![]+!![]+!![]+!![]][+[]]][+[]]]
y: [+[+!+[]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[+!+[]][+[]]+[+[]][+[]]+[+[]][+[]]+[+[]][+[]]][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]+!![]+!![]]

I: [+[+!+[]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[+!+[]][+[]]+[+[]][+[]]+[+[]][+[]]+[+[]][+[]]][+[]]+[]][+[]][+[]]
N: [+[][+[]]+[]][+[]][+[]]

" ": [[]+[][[![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[!![]+[]][+[]][++[[]][+[]]]]][+[]][+!+[]+!![]+!![]+!![]+!![]+!![]+!![]+!![]]

J'ai également de quoi faire "constructor", et donc []["constructor"]["constructor"] pour avoir le constructeur de Function Seulement pour pouvoir m'en servir il me faut les parenthèses, arf

[Kaamo]

Pour avoir le constructeur de Function, je passais par filter (ça fait moins de code ) : []["filter"]["constructor"] === []["constructor"]["constructor"].
Je m'étais arrêté à ce niveau. Sans les (), on ne peut pas faire grand chose comme tu le fais remarquer. Il nous manque de quoi parser + exécuter le code : []["filter"]["constructor"](/* code */)(). Mais avec (), t'es le roi du pétrole

J'avais creusé aussi pour utiliser btoa / atob (base-64 encodage/décodage) pour choper des caractères en plus et en convertissant des nombres unicode en caractères (fromCharCode), mais je ne retrouve pas mes tests.

En gros il faut le charset ()![]+ pour tout faire.
Si tu veux, j'avais trouvé 1 outil fonctionnel avec le charset ()![]+ et un autre avec {} en plus.

[SylvainPV]

Je suis arrivé aux mêmes conclusions que toi Kaamo Il faut absolument les parenthèses pour pouvoir évaluer les fonctions (et donc à terme utiliser un appel eval pour traduire n'importe quel script dans ces six caractères).

Je passe par []["sort"]["constructor"] pour avoir le constructeur Fonction (à voir lequel est plus court) et suis remonté jusqu'à fromCharCode également. Le plus dur a été de récupérer le C majuscule ! J'y suis parvenu comme ceci :
([]["sort"]["constructor"]("return document")()["forms"]["constructor"]+[])[13]

Non je n'ai pas trouvé plus simple

Enfin, avec tout ça je peux commencer à bosser sur un convertisseur automatique. dès que je suis sur le bon PC , j'envoie les sources.

Au final 6 caractères c'est pas si mal

[Invité]

bande de tarés

Ça me refait penser à un prof qui nous avait fait coder en brainfuck... pour le fun

[Kaamo]

+1 pour le brainfuck, c'est le même genre de danse cérébrale

Je passe par []["sort"]["constructor"] pour avoir le constructeur Fonction (à voir lequel est plus court)

Vu qu'il faut passer par filter pour récupérer le "o" de sort. Je pense qu'il est plus simple de passer par filter. Toutes ses lettres sont récupérables par des "opérations de base". Quoique ça se tient, vu que filter a deux lettres de plus ... Hum, à tester

Joli pour le "C" ! Beaucoup moins galère que le mien. Je n'avais pas pensé à document. (attention spoiler) J'étais passé par []["filter"]["constructor"]("return this")()["atob"]("20N")[1] (ou j'avais vu une technique pour passer par unescape("%43")). Galère comme tu le vois car fallait débloquer d'autres moyens :

[]["filter"]["constructor"]("return this")() qui retourne donc l'objet global window. Le h étant 17 en base 18 (+("17"))["toString"](18) et le b de "[object Window]" : ([]["filter"]["constructor"]("return this")()+[])[2] ou alors en passant par 11 en base 12 (+("11"))["toString"](12)

Ou je viens de penser à ... ([]["filter"]["constructor"]("return console")()["constructor"]+[])[9]

[SylvainPV]

Pas mal le atob et le changement de base !
Le changement de base peut être utilisé à la place de String.fromCharCode dans de nombreux cas. Toutes les lettres minuscules peuvent être récupérées comme ceci:
de a : (+("10"))["to"+(("")["constructor"]+[]).slice(9,15)](36)
à z: (+("35"))["to"+(("")["constructor"]+[]).slice(9,15)](36)

Pour récupérer window, il y a plus simple :
[]["filter"]["constructor"]("return self")()

[Kaamo]

Le self !!! Je n'y pense jamais en effet !


Oui, potentiellement avec le changement de base il y a moyen de tout récupérer en base 36. (au moins les minuscules)
(+("10"))["toString"](36) === "a" jusqu'à (+("35"))["toString"](36) === "z".
Il faut avoir débloqué les chiffres et toString. Mieux vaut passer par ce moyen qu'en dernier recours. Par exemple le 'a' se récupère mieux avec un (![]+[])[1] qu'avec un (+("10"))["toString"](36) converti

EDIT : oui voilà

[SylvainPV]

En combinant nos optimisations respectives, je suis arrivé à la fonction String.fromCharCode en 8370 caractères au lieu de 13069

Pour info :
b via (0).constructor === Number : 832 chars
b via 11.toString(20) : 1410 chars

h via window.location.href[0] : 1969 chars
h via +("17"))["to"+(("")["constructor"]+[]).slice(9,15)](20) : 1440 chars

C via document.forms.constructor === HTMLCollection : 4498 chars
C via []["filter"]["constructor"]("return self")()["atob"]("00N")[1] : 2411 chars

Maintenant le compilateur

[Auteur]

SylvainPV, Kaamo, je ne sais pas comment vous faites, mais moi j'ai décroché







PS :

Toi nouveau lecteur, oui toi, si tu arrives jusqu'à ce message sans migraine, sache que tu ne rêves pas... tu es bien dans le forum Javascript

[RomainVALERI]

bande de tarés

On peut pas mieux dire

Et j'avoue que là où j'ai vraiment commencé à rigoler, c'est là

... ha oui mais en utilisant les signes { } et ( ) c'est trop facile

[SylvainPV]

Et voilà le compilateur : http://syllab.fr/projets/experiments/sixcharsjs/

Il ne fonctionne que sur Chrome, en raison de quelques astuces et bidouillages évoqués plus haut.

Chaque conversion prend 20k caractères juste pour mettre en place l'évaluation, après cela dépend de la longueur du script. Donc ne soyez pas gourmands pour vos conversions.

Pour que ce soit plus drôle, j'ai encodé la fonction d'encodage dans le code de l'encodeur

edit: je viens de voir que quelques virgules se balladent dans le code généré. Il n'y a pas de place pour un septième caractère, il va falloir que je corrige ça !

[Kaamo]

Pour ma défense, Sylvain semble bien plus "taré" que moi . Je n'ai jamais eu l'ambition d'aller jusqu'au compilateur ... fonctionnel de surcroît
Bien joué Sylvain, c'est classe

Chaque conversion prend 20k caractères juste pour mettre en place l'évaluation

Ça me parait énorme 20K caractères. Tu ne passes par cette forme pour évaluer le code ?

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

"[][" + compile("filter") + "][" + compile("constructor") + "](" + compile(code) + ")()"