Nerd tshirts met obfuscated javascript

Het begin:

---

---

Het resultaat (uitvoeren in Chrome of Firefox console):

__=!($=[$=[]])+$;_=$[$]+'';$_=({}+$);$_[-~(($=-~$)<<-~$)]+__[-~$]+$_[$]+_[~-$]+_[$=-~$]+(($<<$)+~-$)

Geinspireerd door deze blogpost nu zelf maar eens bezig geweest met het (expres) obfuscaten van javascript. Wat willen we tonen
In dit geval moet 'cloud9' op het scherm komen, dat betekent dat we 5 chars nodig hebben: 'c', 'l', 'o', 'u', 'd', plus het getal 9. Omdat in javascript elke string een char array is kunnen met '[n]' elk karakter uit een string halen. We hebben dus strings nodig waar deze letters in voor komen. Gelukkig zijn hier een paar trucjes voor:

// $ is onze magic var, 
// als je hem als getal gebruikt is hij 0, 
// maar kan ook voor meer gebruikt worden...
$=[$=[]]; 

// dit geeft nu "false"
!($)+$;
// en dit geeft "true"
!!($)+$;
// voor "undefined"
$[$]+'';
// en "[object Object]"
({}+$);

Set up
In deze strings zitten alle chars die we nodig hebben, dus tijd om ze toe te wijzen:

__=!($=[$=[]])+$;_=$[$]+'';$_=({}+$);
__ = "false"
_ = "undefined"
$_ = "[object Object]"

Om hier 'cloud9' van te maken doen we dit:

$_[5] + __[2] + $_[1] + _[0] + _[2] + 9

Pielen met getallen
Dat kan onduidelijker! Gelukkig hebben we met '$' een var die we als 0 kunnen misbruiken. Eerste job: van 0 -> 5 komen.

$ = 0;
1 + (($ + 1) << ($ + 2))
// kan ook:
1 + (($ = $ + 1) << ($ + 1))

In javascript bestaat er de tilde (~) operator (ook bij mij onbekend tot vorige week ), die '-(n+1)' evalueert. ~5 wordt dan -6. Vooral praktisch bij werken met 'indexOf' die -1 teruggeeft wanneer er niets gevonden is, want ~-1 geeft 0. De reden hiervoor gaf ACM:

ACM schreef op maandag 24 oktober 2011 @ 15:30:
De tilde is ook wel bekend als de "binary not", oftewel geef de inverse van de bits in de variabele waar je het op uitvoert... En toevallig is idd de bitrepresentatie van integers zodanig dat ~n = -(n+1), maar dat is dus eerder bijzaak dan het doel van de operator

if (~someString.indexOf("jan")) {
    // niets gevonden
}

Leuk is dat je '-~' dus (n+1) wordt. Praktisch, want we hebben alleen nog +1 over in ons 'van 0 naar 5' stukje.

1 + (($ = $ + 1) << ($ + 1))
// wordt:
-~(($=$+1) << ($+1))
// wordt:
-~(($=-~$) << -~$)
// wordt:
$_[-~(($=-~$)<<-~$)]
// is: 'c'

De rest
$ heeft op dit moment de waarde '1', en we moeten naar __[2]:

__[-~$]
// is: 'l'

Daarna '$_[1]', en die is dan heel simpel:

$_[$]
// is: 'o'

Nu van 1 naar 0, en ook hier komt de tilde operator van pas:

~-1 // geeft 0!
_[~-$]
// is: 'u'

Voor de 'd' van 1 naar 2:

_[~-$]
// is: 'd'
// omdat we straks naar 9 moeten willen we 2 meteen toewijzen:
_[$=~-$]
// is: 'd' en $ = 2

En nu naar 9
Wat we nu hebben is "cloud":

$_[-~(($=-~$)<<-~$)]+__[-~$]+$_[$]+_[~-$]+_[$=-~$]

$ heeft de waarde '2' en we moeten naar 9. Dit kan via:

2 << 2 // geeft 8
(2 << 2) + (2 - 1) // geeft 9!
($ << $) + ~-$ // tah dah
(($<<$)+~-$) // wrap up

En klaar!

Binnenkort in de betere modezaak