这些javascript混淆器如何生成实际的工作代码？

时间：2012-01-16 17:40:12

标签： javascript obfuscation reverse-engineering

有this one和this one，它们都会生成完全无法读取的代码，其中一个比另一个更可爱。

现在，我不是Javascript的专家，但我没看到如何

ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/ ['_']; o=(ﾟｰﾟ)  =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); (ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] }; (ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ]; (ﾟｰﾟ)+=(ﾟΘﾟ); (ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^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) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');

和

$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+$.$_$_+(![]+"")[$._$_]+$.$$$_+"\\"+$.__$+$.$$_+$._$_+$.__+"(\\\"\\"+$.__$+$._$_+$._$$+$.__+$.$_$_+$.$$__+"\\"+$.__$+$.$_$+$._$$+"\\"+$.__$+$.__$+$.$$$+"\\"+$.__$+$.$$_+$.$$_+$.$$$_+"\\"+$.__$+$.$$_+$._$_+$.$$$$+(![]+"")[$._$_]+$._$+"\\"+$.__$+$.$$_+$.$$$+"\\\")"+"\"")())();

是按预期执行的实际有效javascript。说真的，运行它们。他们都是alert("StackOverflow")。我可以理解混淆一些逻辑或字符串混淆，但是没有可见的控制语句。这个混淆器是否以The Language Which Shall Not Be Named的风格吸引了一些魔法？我很满意我的代码看起来也很开心，但我完全不理解它背后的魔力。

我尝试过浏览这两个页面的源代码，但它们对我来说和它们生成的代码一样令人困惑。

这是如何运作的？

4 个答案:

答案 0 :(得分：28)

真有趣！这是我的目标。基本上这里发生的是一堆数字和字符串被分配给变量。这些变量被连接起来形成一个编码的字符串。该编码字符串被解码以形成JavaScript代码串。该代码被设置为函数体，然后执行。

让我们一行一行：

第1行： 

ﾟωﾟﾉ = /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/['_'];

ﾟωﾟﾉ - 全局变量
/｀ｍ´）ﾉ ~┻━┻ / - 正则表达式
/*´∇｀*/ - 多行评论
['_'] - 获取正则表达式的属性_。

由于RegExp没有_属性，变量ﾟωﾟﾉ包含值undefined。

第2行： 

o = (ﾟｰﾟ) = _ = 3;

定义变量o，ﾟｰﾟ和_，并将每个值设置为3。

第3行： 

c = (ﾟΘﾟ) = (ﾟｰﾟ) - (ﾟｰﾟ);

定义变量c和ﾟΘﾟ并将其值设置为0。 （ﾟｰﾟ为3，因此(ﾟｰﾟ) - (ﾟｰﾟ)与ﾟｰﾟ - ﾟｰﾟ相同，与3 - 3相同。现在c和ﾟΘﾟ两者都包含1;

第4行： 

(ﾟДﾟ) = (ﾟΘﾟ) = (o ^ _ ^ o) / (o ^ _ ^ o);

定义变量ﾟДﾟ并重新定义变量ﾟΘﾟ。 ^是o，_和3都是o ^ _ ^ o。 3 ^ 3 ^ 3与3 ^ 3相同 0为3 ^ 0，3为3 / 3 然后1为ﾟДﾟ ﾟΘﾟ和1现在都包含(ﾟДﾟ) = { ﾟΘﾟ: '_', ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ], ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)], ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ] }; 。

第5行： 

(ﾟДﾟ) = {
    ﾟΘﾟ: '_',
    ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ],
    ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)],
    ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ]
};

使用换行符和缩进：

ﾟДﾟ

将ﾟΘﾟ重新定义为对象文字，其中包含属性ﾟωﾟﾉ，ﾟｰﾟﾉ，ﾟДﾟﾉ和ﾟДﾟ.ﾟΘﾟ。
ﾟДﾟ.ﾟωﾟﾉ是“_” ((undefined == 3) + "_")[1]为"false_"[1]，"a"为ﾟДﾟ.ﾟｰﾟﾉ (undefined + "_")[3 ^ 3 ^ 3 - 1]为"undefined_"[2]，"d"为ﾟДﾟ.ﾟДﾟﾉ ((3 == 3) + "_")[3]为"true_"[3]，"u"为(ﾟДﾟ)[ﾟΘﾟ] = ((ﾟωﾟﾉ == 3) + '_')[c ^ _ ^ o]; 。

第6行： 

ﾟДﾟ.ﾟΘﾟ = ((undefined == 3) + "_")[1 ^ 3 ^ 3];

与：

相同 
ﾟДﾟ.ﾟΘﾟ = "false_"[1];

与以下内容相同：

ﾟДﾟ.ﾟΘﾟ

所以"a"是(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ + (ﾟДﾟ)[ﾟ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ﾟ])(ﾟΘﾟ))('_'); 。

第7 - 16行：

所以它继续，为变量和对象属性分配字符串和数字。直到最后一行：

第17行： 

ﾟωﾟﾉ    // 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"

此时，我们有以下变量：

ﾟДﾟ['_'](
    ﾟДﾟ['_'](
        ﾟεﾟ + 
        ﾟДﾟ[ﾟ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ﾟ]
    )(ﾟΘﾟ)
)("_");

该行主要是一个大字符串连接。通过删除不必要的括号并添加换行符，我们可以使略微更具可读性：

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"

该连接字符串的值为：

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))("_")

因此，用文字替换所有变量，我们最终得到以下JavaScript，这些JavaScript在最后一行执行：

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\"") 构造函数，使字符串成为函数体：

Function

因此，该字符串被评估为JavaScript，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"; } 构造函数返回此函数：

Function("return\"\\141\\154\\145\\...\\51\"")(1)

该功能立即执行：

alert("Hello, JavaScript")

并返回字符串：

Function
嘿，看起来像JavaScript！但现在还没有。这只是一个字符串。但是该字符串被传递给另一个Function("alert(\"Hello, JavaScript\")") 构造函数，为我们提供了一个以JavaScript形式执行字符串的函数：

function () {
    alert("Hello, JavaScript");
}

这与：

相同 
Function("alert(\"Hello, JavaScript\")")("_")

该功能立即执行：

{{1}}

我们最终调用了未经模糊处理的代码。

答案 1 :(得分：23)

随着我的javascript一天出现，一行一行地分解。注意我使用alert("Hello")

生成了我的 
$ = ~[];   // var $ = -1
$ = 
    {
    ___ : ++$,              // ++(-1) == 0
    $$$$:(![]+"")[$],       // ![] == false, false + "" == "false", "false"[0] == "f"
    __$:++$,                // ++(0) == 1    
    $_$_:(![]+"")[$],       // ![] == false, false + "" == "false", "false"[1] == "a"
    _$_:++$,                // ++(1) == 2
    $_$$:({}+"")[$],        // {} + "" == "[object Object]", "[object Object]"[2] == "b"
    $$_$:($[$]+"")[$],      // 2[2] == undefined + "" == "undefined", "undefined"[2] == "d"
    _$$:++$,                // ++(2) == 3
    $$$_:(!""+"")[$],       // !"" == true + "" == "true", "true"[3] == "e"
    $__:++$,                // ++(3) == 4
    $_$:++$,                // ++(4) == 5
    $$__:({}+"")[$],        // ({} + "") == [object Object]", "[object Object]"[5] == "c"
    $$_:++$,                // ++(5) == 6
    $$$:++$,                // ++(6) == 7
    $___:++$,               // ++(7) == 8
    $__$:++$                // ++(8) == 9
};

$.$_ = 
    ($.$_=$+"")[$.$_$] +        // "[object Object]"[5] == "c" +  (also $.$_ = "[object Object]")
    ($._$=$.$_[$.__$]) +        // "[object Object]"[1] == "o" + (also $._$ = "o")
    ($.$$=($.$+"")[$.__$]) +    // $.$+"" == "undefined", "undefined"[1] == "n" + (also $.$$ = "n")
    ((!$)+"")[$._$$] +          // !$ == false, false+"" == "false", "false"[3] == "s" +
    ($.__=$.$_[$.$$_]) +        // "[object Object]"[6] == "t" (also $.__ = "t") +
    ($.$=(!""+"")[$.__$]) +     // !"" == true, true + "" == "true", "true"[2] == "r" +(also $.$="r")
    ($._=(!""+"")[$._$_]) +     // !"" == true, true + "" == "true", "true"[3] == "u" +(also $._="u")
    $.$_[$.$_$] +               // "[object Object]"[5] == "c" +
    $.__ +                      // "t" +
    $._$ +                      // "o" +
    $.$;                        // "r"

// $.$_ = "constructor"

$.$$ = 
    $.$ +                       // "r" +
    (!""+"")[$._$$] +           // "true"[3] == "e" +
    $.__ +                      // "t" +
    $._  +                      // "u" +
    $.$ +                       // "r" +
    $.$$;                       // "n" 
// $.$$ = "return"

$.$ = ($.___)[$.$_][$.$_];      // (0)["constructor"]["constructor"]
// $.$ = Function

// This is the part that changes when you change the input string.

$.$(                            // Function( 
    $.$(                        // Function (
        $.$$ +                  // "return"+
        "\""+                   // '"' +
        $.$_$_ +                // "a" + 
        (![]+"")[$._$_]+        // "l" + 
        $.$$$_+                 // "e" + 
        "\\"+                   // "\" +            
        $.__$+                  // "1" + 
        $.$$_+                  // "6" + 
        $._$_+                  // "2" +   (note '\162' = 'r')   
        $.__+                   // "t" + 
        "(\\\"\\"+              // '(\"\' +    
        $.__$+                  // 1 + 
        $.__$+                  // 1 + 
        $.___+                  // 0 +     (note '\110' = 'H')    
        $.$$$_+                 // e + 
        (![]+"")[$._$_]+        // "false"[2] == "l", "l" + 
        (![]+"")[$._$_]+        // "false"[2] == "l", "l" + 
        $._$+                   // "o" + 
        "\\\")"+                // '\")' +
        "\""                    // '"''
    )()                         // invoke
)();                            // invoke

我不是很多，它会创建一个字符串，然后调用它。

编辑 - 我没有时间解码其他版本，但我想它做了类似的事情，但是使用非拉丁字符。

答案 2 :(得分：12)

在控制台中输入$（运行代码后），然后展开对象。然后，您可以更轻松地分析它。

enter image description here

他们使用偷偷摸摸的方法抓取足够的单词/字符，并在$对象中引用它们，然后使用它们来构建程序并eval可能在Function(...)()调用中。

所以它应该归结为...... 

Function('alert("StackOverflow")')();

......或类似的东西。

开始放松它，...... 

$=~[];  // -1

$={
  0:++$,         //  0
  f:(![]+"")[$], // "f", (![]+"") is "false", and [$] gives index 0, or "f"
  1:++$,         //  1
  a:(![]+"")[$], // "a", (![]+"") is "false", and [$] gives index 1, or "a"
  2:++$,         //  2
  b:({}+"")[$],  // "b", ({}+"") is "[object Object]", and [$] gives index 2, or "b"
  d:($[$]+"")[$],// "d", ($[$]+"") is "undefined", and [$] gives index 2, or "d"
  3:++$,         //  3
  e:(!""+"")[$], // "e", (!""+"") is "true", and [$] gives index 3, or "e"
  4:++$,         //  4
  5:++$,         //  5
  c:({}+"")[$],  // "c", ({}+"") is "[object Object]", and [$] gives index 5, or "c"
  6:++$,         //  6
  7:++$,         //  7
  8:++$,         //  8
  9:++$          //  9
};

$.constructor=($.constructor=$+"")[$[5]]+($.o=$.constructor[$[1]])+($.return=($.$+"")[$[1]])+((!$)+"")[$[3]]+($.t=$.constructor[$[6]])+($.$=(!""+"")[$[1]])+($.u=(!""+"")[$[2]])+$.constructor[$[5]]+$.t+$.o+$.$;
$.return=$.$+(!""+"")[$[3]]+$.t+$.u+$.$+$.return;
$.$=($[0])[$.constructor][$.constructor];
$.$($.$($.return+"\""+$.a+(![]+"")[$[2]]+$.e+"\\"+$[1]+$[6]+$[2]+$.t+"(\\\"\\"+$[1]+$[2]+$[3]+$.t+$.a+$.c+"\\"+$[1]+$[5]+$[3]+"\\"+$[1]+$[1]+$[7]+"\\"+$[1]+$[6]+$[6]+$.e+"\\"+$[1]+$[6]+$[2]+$.f+(![]+"")[$[2]]+$.o+"\\"+$[1]+$[6]+$[7]+"\\\")"+"\"")())();

则... 

$.constructor=($.constructor=$+"")[5]+($.o=$.constructor[1])+($.return=($.$+"")[1])+((!$)+"")[3]+($.t=$.constructor[6])+($.$=(!""+"")[1])+($.u=(!""+"")[2])+$.constructor[5]+$.t+$.o+$.$;
$.return=$.$+(!""+"")[3]+$.t+$.u+$.$+$.return;
$.$=(0)[$.constructor][$.constructor];
$.$($.$($.return+"\""+$.a+(![]+"")[2]+$.e+"\\"+$[1]+$[6]+$[2]+$.t+"(\\\"\\"+$[1]+$[2]+$[3]+$.t+$.a+$.c+"\\"+$[1]+$[5]+$[3]+"\\"+$[1]+$[1]+$[7]+"\\"+$[1]+$[6]+$[6]+$.e+"\\"+$[1]+$[6]+$[2]+$.f+(![]+"")[2]+$.o+"\\"+$[1]+$[6]+$[7]+"\\\")"+"\"")())();

......呃，失去兴趣。

答案 3 :(得分：9)

由于其他每个答案都只是对您提供的代码的分析，因此我将扩展您自己如何生成这些代码（无需工具）。我相信这会让你更好地了解它是如何运作的。

这些混淆中的大多数都是基于JavaScript的一些特性/原则。第一个是变量名称可以使用 Unicode 字母（Lu，Ll，Lt，Lm，Lo， Nl）和 Unicode 数字（Nd）。在您给出的第一个示例中，字符可能看起来像符号，但它们是Unicode字母或Unicode编号。

第二个是在JavaScript中向空中添加一个空字符串会将其转换为字符串。如果您还使用了字符串在JavaScript中类似于数组的结构这一事实，您可以轻松地创建类似：(false+"")[0]的内容，也可以编写(!1+"")[0]。从那时起，您可以逐字母撰写自己的字符串。

第三个是可以使用[]表示法访问每个对象属性。例如：window["alert"]("test")与window.alert("test")相同。如果你将它与前一段混合，我认为你可以很容易地看到它可以去的地方。

我们开始时唯一缺少的是对window或Function的引用。其他答案，已经为您提供了一种访问Function的方法，可以使用eval。为了让window变得艰难，最简单的方法是通过这种方式通过Array.concat泄漏：

t= [].concat;
a = t()[0]; // "a" now contains window

获得window后，您可以使用window["eval"]或直接致电window["alert"]。

这就是你实际做这些混淆的基础。其余的只是前几点的变化。如果你想了解更多信息，我做了几篇博文，你可以在这里找到它们：http://holyvier.blogspot.com/2011/10/javascript-obfuscation-introduction.html

相关问题
最新问题