JavaScript (ECMAScript6), 2 octets par ligne
'\
'[
'\
b\
i\
g'
][
'\
c\
o\
n\
s\
t\
r\
u\
c\
t\
o\
r'
][
'\
c\
a\
l\
l'
](
0,
`\
n\
=\
p\
r\
o\
m\
p\
t\
(\
'\
'\
)\
;\
i\
=\
0\
;\
f\
o\
r\
(\
;\
+\
+\
i\
<\
=\
n\
;\
c\
o\
n\
s\
o\
l\
e\
.\
l\
o\
g\
(\
i\
%\
5\
?\
f\
|\
|\
i\
:\
f\
+\
'\
P\
i\
e\
'\
)\
)\
f\
=\
i\
%\
3\
?\
'\
'\
:\
'\
A\
p\
p\
l\
e\
'\
`)
()
Longue explication
La façon dont nous pouvons raccourcir les lignes consiste à transformer le code en chaîne et à échapper les extrémités de ligne, cela imposera une limite de 2 octets par ligne.
Devient alert(1)ainsi
"\
a\
l\
e\
r\
(\
1\
)"
Mais maintenant, votre code est une chaîne, nous devons donc exécuter la chaîne en tant que code. Je connais au moins 4 façons d'exécuter la chaîne comme code:
- eval (code) . Ce qui prend au moins 5 octets pour appeler
eval(
- setTimeout (code, timeout) . Exécute la fonction de manière asynchrone, mais éventuellement si vous passez une chaîne, elle invoquera eval en interne.
- Vous pouvez profiter du DOM et mettre votre code dans un
onclick=""attribut, mais je n'ai pas réussi à rendre la partie de création d'élément courte.
- Appel du nouveau constructeur Function Function Function () analysera votre code dans une fonction anonyme que vous pourrez appeler plus tard (j'ai utilisé ceci).
Toutes les fonctions natives vivent à l'intérieur de l' objet fenêtre et en javascript, vous pouvez accéder aux propriétés de l'objet en utilisant la notation par points ainsi eval()devient window.eval(), ou vous pouvez accéder aux propriétés en utilisant la notation de parenthèse window['eval']() . Vous pouvez en profiter pour briser evalplusieurs lignes en utilisant la méthode décrite précédemment. Mais vous devez toujours taper la fenêtre , une astuce est que si vous n'êtes pas à l'intérieur d'un cadre, la variable supérieure est également window, donc window.eval devient top.eval (3 octets de moins).
w=top
w['eval']
You can shorten the assignment using parenthesis
w=(
top
)
w[
'e\
av\
al'
](
/*string*/
)
Cela rendra le code minimum de 3 octets. Pour faire le code 2 octets, j'ai utilisé lenew Function(/*string*/); constructeur, mais j'ai dû être créatif pour y accéder sans avoir à le taper.
Tout d'abord, le constructeur Function vous permet de l'appeler comme une fonction en omettant le nouveau mot-clé, cela réduit 4 octets mais c'est également important pour une autre raison. Appelant le constructeur en fonction retourne encore une instance ce qui nous permet de tourner new Function(code)à Function(code). Une autre chose importante est que le constructeur Function a uncall méthode qui vous permet d'appeler n'importe quelle fonction mais en remplaçant la référence this, et le constructeur Function lui-même étant une fonction, vous pouvez appeler une méthode sur elle-même Function.call(null, code).
Toutes les fonctions natives sont des instances du constructeur Function, et tous les objets en javascript ont une propriété constructeur . Vous pouvez donc avoir accès au constructeur Function sur n'importe quelle fonction native comme alert.constructor, et en utilisant la méthode d' appel , nous pouvons exécuter le constructeur en tant que fonction. Maintenant, nous avons alert.constructor.call (null, code) renvoie une fonction.
en combinant les cinématiques précédentes, nous pouvons en faire alert['constructor']['call'](null, code)
Maintenant, nous avons juste besoin de trouver une fonction ou une méthode courte nommée, alors je choisis la méthode big () à l'intérieur du constructeur String. Je peux donc y accéder directement à partir d'une chaîne vide"".big
"".big.constructor.call(null, "code")();
''['big']['constructor']['call'](0,'/* code */')()
Ensuite, je viens de tout casser en 2 octets
Court er explication (TLDR)
J'accède au nouveau constructeur Function (code) pour analyser la chaîne au lieu de eval (code) . Ce constructeur est disponible à chaque fonction native en faisant anyFunction. constructeur , comme alert.constructor===Function. J'utilise une fonction / méthode à l'intérieur du String.prototype.big String.prototype.big.constructor.call(null, /*string*/)
Mais y accéder directement à partir d'un littéral de chaîne "".biget le transformer en notation de parenthèse . ""['big']['constructor']['call'](0, CODE)pour pouvoir le casser en utilisant le \.