StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
8885873
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
3
CommunityOwnedDate
CreationDate
2012-01-16T20:30:29.570
FavoriteCount
0
LastActivityDate
2012-01-16T20:30:29.570
LastEditDate
LastEditorUserId
0
OwnerUserId
361684
ParentId
8883999
PostTypeId
2
Score
28
ViewCount
0
LastEditorDisplayName
text
Body
What fun! Here's my go at it. Basically what is happening here is a bunch of numbers and strings are being assigned to variables. Those variables are being concatenated to form an encoded string. That encoded string is decoded to form a string of JavaScript code. That code is set as the body of a function, which is then executed. Let's take it line by line: Line 1: <pre class="lang-js prettyprint-override"><code>ﾟωﾟﾉ = /｀ｍ´）ﾉ ~┻━┻ //*´∇｀*/['_']; </code></pre> <code>ﾟωﾟﾉ</code> - a global variable <code>/｀ｍ´）ﾉ ~┻━┻ /</code> - a regular expression <code>/*´∇｀*/</code> - a multi-line comment <code>['_']</code> - get the property <code>_</code> of the regular expression. Since a RegExp does not have a <code>_</code> property, the variable <code>ﾟωﾟﾉ</code> contains the value <code>undefined</code>. Line 2: <pre class="lang-js prettyprint-override"><code>o = (ﾟｰﾟ) = _ = 3; </code></pre> Define the variables <code>o</code>, <code>ﾟｰﾟ</code>, and <code>_</code>, and set each of their values to <code>3</code>. Line 3: <pre class="lang-js prettyprint-override"><code>c = (ﾟΘﾟ) = (ﾟｰﾟ) - (ﾟｰﾟ); </code></pre> Define the variables <code>c</code> and <code>ﾟΘﾟ</code> and set their values to <code>0</code>. (<code>ﾟｰﾟ</code> is <code>3</code>, so <code>(ﾟｰﾟ) - (ﾟｰﾟ)</code> is the same as <code>ﾟｰﾟ - ﾟｰﾟ</code> is the same as <code>3 - 3</code>. Now <code>c</code> and <code>ﾟΘﾟ</code> both contain <code>1</code>; Line 4: <pre class="lang-js prettyprint-override"><code>(ﾟДﾟ) = (ﾟΘﾟ) = (o ^ _ ^ o) / (o ^ _ ^ o); </code></pre> Define the variable <code>ﾟДﾟ</code> and redefine the variable <code>ﾟΘﾟ</code>. <code>^</code> is the <a href="http://msdn.microsoft.com/en-us/library/ece515h6(VS.94).aspx" rel="noreferrer">bitwise XOR operator</a> and <code>o</code> and <code>_</code> are both <code>3</code>. <code>o ^ _ ^ o</code> is the same as <code>3 ^ 3 ^ 3</code>. <code>3 ^ 3</code> is <code>0</code>, <code>3 ^ 0</code> is <code>3</code>. Then <code>3 / 3</code> is <code>1</code>. <code>ﾟДﾟ</code> and <code>ﾟΘﾟ</code> both now contain <code>1</code>. Line 5: <pre class="lang-js prettyprint-override"><code>(ﾟДﾟ) = { ﾟΘﾟ: '_', ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ], ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)], ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ] }; </code></pre> With line breaks and indentation: <pre class="lang-js prettyprint-override"><code>(ﾟДﾟ) = { ﾟΘﾟ: '_', ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ], ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)], ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ] }; </code></pre> Redefine <code>ﾟДﾟ</code> as an object literal, with properties <code>ﾟΘﾟ</code>, <code>ﾟωﾟﾉ</code>, <code>ﾟｰﾟﾉ</code>, and <code>ﾟДﾟﾉ</code>. <code>ﾟДﾟ.ﾟΘﾟ</code> is "_". <code>ﾟДﾟ.ﾟωﾟﾉ</code> is <code>((undefined == 3) + "_")[1]</code> which is <code>"false_"[1]</code> which is <code>"a"</code>. <code>ﾟДﾟ.ﾟｰﾟﾉ</code> is <code>(undefined + "_")[3 ^ 3 ^ 3 - 1]</code> which is <code>"undefined_"[2]</code> which is <code>"d"</code>. <code>ﾟДﾟ.ﾟДﾟﾉ</code> is <code>((3 == 3) + "_")[3]</code> which is <code>"true_"[3]</code> which is <code>"u"</code>. Line 6: <pre class="lang-js prettyprint-override"><code>(ﾟДﾟ)[ﾟΘﾟ] = ((ﾟωﾟﾉ == 3) + '_')[c ^ _ ^ o]; </code></pre> Is the same as: <pre class="lang-js prettyprint-override"><code>ﾟДﾟ.ﾟΘﾟ = ((undefined == 3) + "_")[1 ^ 3 ^ 3]; </code></pre> Which is the same as: <pre class="lang-js prettyprint-override"><code>ﾟДﾟ.ﾟΘﾟ = "false_"[1]; </code></pre> So <code>ﾟДﾟ.ﾟΘﾟ</code> is <code>"a"</code>. Lines 7 - 16: And so it continues, assigning strings and numbers to variables and object properties. Until the last line: Line 17: <pre class="lang-js prettyprint-override"><code>(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ + (ﾟДﾟ)[ﾟoﾟ] + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟΘﾟ) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + ((ﾟｰﾟ) + (o ^ _ ^ o)) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟΘﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (o ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (o ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟoﾟ])(ﾟΘﾟ))('_'); </code></pre> By this time, we have the following variables: <pre class="lang-js prettyprint-override"><code>ﾟωﾟﾉ // undefined o // 3 ﾟｰﾟ // 4 _ // 3 c // 0 ﾟΘﾟ // 1 ﾟДﾟ /* { "1": "f", ﾟΘﾟ: "_", ﾟωﾟﾉ: "a", ﾟｰﾟﾉ: "d", ﾟДﾟﾉ: "e", c: "c", o: "o", return: "\\", ﾟΘﾟﾉ: "b", constructor: "\"", _: Function } */ ﾟoﾟ // "constructor" ﾟεﾟ // "return" oﾟｰﾟo // "u" </code></pre> That line is mostly one big string concatenation. We can make it slightly more readable by removing the unnecessary parentheses and adding line breaks: <pre class="lang-js prettyprint-override"><code>ﾟДﾟ['_']( ﾟДﾟ['_']( ﾟεﾟ + ﾟДﾟ[ﾟoﾟ] + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟｰﾟ + ﾟΘﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + (ﾟｰﾟ + ﾟΘﾟ) + ﾟｰﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟｰﾟ + (ﾟｰﾟ + ﾟΘﾟ) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - ﾟΘﾟ) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ﾟｰﾟ + ﾟДﾟ[ﾟεﾟ] + (ﾟｰﾟ + ﾟΘﾟ) + (c ^ _ ^ o) + ﾟДﾟ[ﾟεﾟ] + ﾟｰﾟ + ((o ^ _ ^ o) - ﾟΘﾟ) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟΘﾟ + (c ^ _ ^ o) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟｰﾟ + (ﾟｰﾟ + ﾟΘﾟ) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + (ﾟｰﾟ + ﾟΘﾟ) + ﾟｰﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + (ﾟｰﾟ + ﾟΘﾟ) + ﾟｰﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + (ﾟｰﾟ + ﾟΘﾟ) + (ﾟｰﾟ + (o ^ _ ^ o)) + ﾟДﾟ[ﾟεﾟ] + (ﾟｰﾟ + ﾟΘﾟ) + ﾟｰﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟｰﾟ + (c ^ _ ^ o) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟΘﾟ + ((o ^ _ ^ o) - ﾟΘﾟ) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟｰﾟ + ﾟΘﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟｰﾟ + ﾟΘﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ((o ^ _ ^ o) - ﾟΘﾟ) + (o ^ _ ^ o) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ﾟｰﾟ + (o ^ _ ^ o) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - ﾟΘﾟ) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + (ﾟｰﾟ + ﾟΘﾟ) + ﾟΘﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (c ^ _ ^ o) + ﾟДﾟ[ﾟεﾟ] + ﾟΘﾟ + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ﾟｰﾟ + ﾟДﾟ[ﾟεﾟ] + ﾟｰﾟ + ((o ^ _ ^ o) - ﾟΘﾟ) + ﾟДﾟ[ﾟεﾟ] + (ﾟｰﾟ + ﾟΘﾟ) + ﾟΘﾟ + ﾟДﾟ[ﾟoﾟ] )(ﾟΘﾟ) )("_"); </code></pre> The value of that concatenated string is: <pre class="lang-js prettyprint-override"><code>return"\141\154\145\162\164\50\42\110\145\154\154\157\54\40\112\141\166\141\123\143\162\151\160\164\42\51" </code></pre> So, replacing all the variables with literals, we end up with the following JavaScript which gets executed on that last line: <pre class="lang-js prettyprint-override"><code>Function(Function("return\"\\141\\154\\145\\162\\164\\50\\42\\110\\145\\154\\154\\157\\54\\40\\112\\141\\166\\141\\123\\143\\162\\151\\160\\164\\42\\51\"")(1))("_") </code></pre> Breaking that line down, in the middle we see the concatenated string is passed to a <code>Function</code> constructor, making the string the function body: <pre class="lang-js prettyprint-override"><code>Function("return\"\\141\\154\\145\\162\\164\\50\\42\\110\\145\\154\\154\\157\\54\\40\\112\\141\\166\\141\\123\\143\\162\\151\\160\\164\\42\\51\"") </code></pre> So, that string is evaluated as JavaScript, and the <code>Function</code> constructor returns this function: <pre class="lang-js prettyprint-override"><code>function () { return"\141\154\145\162\164\50\42\110\145\154\154\157\54\40\112\141\166\141\123\143\162\151\160\164\42\51"; } </code></pre> That function is immediately executed: <pre class="lang-js prettyprint-override"><code>Function("return\"\\141\\154\\145\\...\\51\"")(1) </code></pre> And returns the string: <pre class="lang-js prettyprint-override"><code>alert("Hello, JavaScript") </code></pre> Hey, that looks like JavaScript! But it's not yet. It's just a string. But that string is passed to another <code>Function</code> constructor, giving us a function that executes the string as JavaScript: <pre class="lang-js prettyprint-override"><code>Function("alert(\"Hello, JavaScript\")") </code></pre> That is the same as: <pre class="lang-js prettyprint-override"><code>function () { alert("Hello, JavaScript"); } </code></pre> That function is immediately executed: <pre class="lang-js prettyprint-override"><code>Function("alert(\"Hello, JavaScript\")")("_") </code></pre> And our unobfuscated code is finally called.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POHow do these javascript obfuscators generate actual working code?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USgilly3
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. COI wish I could select this as correct too. Nice work as well!
 singulars
 PostPostId
 PO
 UserUserId
 USCyclone
2. CO+1 Very nice...
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
3. COYou guys completely blow my mind
 singulars
 PostPostId
 PO
 UserUserId
 USSquirrl

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.