ये जावास्क्रिप्ट obfuscators वास्तविक काम कोड कैसे उत्पन्न करते हैं?

Question

this one और this one है और वे दोनों पूरी तरह से अपठनीय कोड उत्पन्न करते हैं, एक दूसरे की तुलना में अधिक प्यारा है।

अब, मैं जावास्क्रिप्ट में कोई विशेषज्ञ हूँ, लेकिन मैं कैसे

ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻ //*´∇｀*/ ['_']; 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ﾟ]) (ﾟΘﾟ)) ('_'); 

और

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

वास्तविक वैध जावास्क्रिप्ट है कि अपेक्षा के अनुरूप हैं देखने के लिए असफल। गंभीरता से, उन्हें चलाओ। वे alert("StackOverflow") दोनों हैं। मैं कुछ तर्क या स्ट्रिंग obfuscation obfuscating समझ सकता है, लेकिन कोई दृश्य नियंत्रण बयान नहीं है। क्या यह obfuscator The Language Which Shall Not Be Named की शैली में कुछ जादू खींच रहा है? मैं अपने कोड से भी खुश हूं, लेकिन मैं इसके पीछे जादू को पूरी तरह समझ नहीं रहा हूं।

मैंने दोनों पृष्ठों के स्रोत कोड को चुनने का प्रयास किया है, और वे मेरे द्वारा उत्पन्न कोड के रूप में मेरे लिए भ्रमित हैं।

यह कैसे काम करता है?

Answer 1

दिन के मेरे जावास्क्रिप्ट अंश के रूप में, रेखा से एक लाइन टूट जाती है। मैं 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 

साथ मेरा उत्पन्न नोट नहीं कर रहा हूँ मैं हूँ यह एक स्ट्रिंग बनाता है और फिर यह आह्वान पर काफी जगह है,।

– संपादित करें और मेरे पास अन्य संस्करण को डीकोड करने का समय नहीं है, लेकिन मुझे लगता है कि यह कुछ ऐसा ही कर रहा है, लेकिन गैर लैटिन वर्णों के साथ।

Answer 2

$ कंसोल में (कोड चलाने के बाद) टाइप करें, और ऑब्जेक्ट का विस्तार करें। फिर आप इसका अधिक आसानी से विश्लेषण कर सकते हैं।

वे पर्याप्त शब्द/अक्षर में हथियाने रहे हैं डरपोक साधनों का उपयोग करें, और उन्हें $ वस्तु में संदर्भित है, तो उन्हें प्रयोग कार्यक्रम का निर्माण करने और eval एक Function(...)() कॉल में होने की संभावना ing।

तो यह करने के लिए नीचे उबाल चाहिए ...

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]+"\\\")"+"\"")())(); 

... हाँ, ब्याज खो दिया है।

Answer 3

क्या मजा! यहां मेरा जाना है। असल में यहां क्या हो रहा है संख्याओं का एक गुच्छा है और तारों को तारों को आवंटित किया जा रहा है। एन्कोडेड स्ट्रिंग बनाने के लिए उन चरों को संयोजित किया जा रहा है। उस एन्कोडेड स्ट्रिंग को जावास्क्रिप्ट कोड की एक स्ट्रिंग बनाने के लिए डीकोड किया गया है। वह कोड फ़ंक्शन के बॉडी के रूप में सेट किया गया है, जिसे तब निष्पादित किया जाता है।

के लाइन द्वारा लाइन यह लेते हैं:

पंक्ति 1:

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

ﾟωﾟﾉ - एक वैश्विक चर
/｀ｍ´）ﾉ ~┻━┻ / - एक रेगुलर एक्सप्रेशन
/*´∇｀*/ - एक बहु पंक्ति टिपण्णी
['_'] - संपत्तिप्राप्त करें नियमित अभिव्यक्ति के।

चूंकि RegExp में _ संपत्ति नहीं है, तो परिवर्तनीय ﾟωﾟﾉ में मान undefined है।

पंक्ति 2:

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

चर o, ﾟｰﾟ, और _ को परिभाषित करें, और 3 करने के लिए अपने मूल्यों से प्रत्येक की स्थापना की।

पंक्ति 3:

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

चर c और ﾟΘﾟ परिभाषित करें और 0 करने के लिए अपने मूल्यों को निर्धारित। (ﾟｰﾟ3c और ﾟΘﾟ है, इसलिए (ﾟｰﾟ) - (ﾟｰﾟ) में ही है के रूप में ﾟｰﾟ - ﾟｰﾟ3 - 3 रूप में ही है अब दोनों 1 होता है;

लाइन 4:।

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

चर ﾟДﾟ परिभाषित करें और चर को फिर से परिभाषित ﾟΘﾟ^bitwise XOR operator और o और _ दोनों 3 हैं
o^_^o3^3^3 जैसा ही है।
3^30, 3^03 है।
फिर 3/31 है।
ﾟДﾟ और ﾟΘﾟ दोनों में अब 1 है।

लाइन 5:

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

लाइन टूट जाता है और खरोज के साथ:

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

को फिर से परिभाषित ﾟДﾟ एक वस्तु शाब्दिक रूप में, गुण ﾟΘﾟ, ﾟωﾟﾉ, ﾟｰﾟﾉ, और ﾟДﾟﾉ साथ।
ﾟДﾟ.ﾟΘﾟ "_" है।
ﾟДﾟ.ﾟωﾟﾉ((undefined == 3) + "_")[1] है जो "false_"[1] है जो "a" है।
ﾟДﾟ.ﾟｰﾟﾉ(undefined + "_")[3^3^3 - 1] है जो "undefined_"[2] है जो "d" है।
ﾟДﾟ.ﾟДﾟﾉ((3 == 3) + "_")[3] है जो "true_"[3] है जो "u" है।

पंक्ति 6:

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

कौन सा रूप में ही है:

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

तो ﾟДﾟ.ﾟΘﾟ"a" है

(ﾟДﾟ)[ﾟΘﾟ] = ((ﾟωﾟﾉ == 3) + '_')[c^_^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ﾟ])(ﾟΘﾟ))('_'); 

इस समय तक, हम निम्न चर है। हम कर सकते हैं यह थोड़ा अनावश्यक कोष्ठकों पंक्ति विराम को दूर करने और जोड़कर अधिक पठनीय :

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

कि concatenated स्ट्रिंग का मान:,

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 जो कि अंतिम पंक्ति पर निष्पादित हो जाता है के साथ खत्म बीच हम देखते हैं concatenated स्ट्रिंग एक 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 निर्माता इस फ़ंक्शन:

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 निर्माता को पारित कर दिया है, हमें एक समारोह है कि जावास्क्रिप्ट के रूप में स्ट्रिंग कार्यान्वित दे रही है:

Function("alert(\"Hello, JavaScript\")") 

एक ही है कि के रूप में:

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

कि समारोह तुरंत क्रियान्वित किया जाता है:

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

और हमारे unobfuscated कोड अंत में बुलाया जाता है।

Answer 4

चूंकि हर दूसरे उत्तर केवल आपके द्वारा दिए गए कोड का विश्लेषण होता है, इसलिए मैं विस्तार करूँगा कि आप स्वयं को (उपकरण के बिना) कैसे उत्पन्न कर सकते हैं। मेरा मानना ​​है कि यह आपको एक बेहतर अवलोकन देगा कि यह कैसे काम करता है।

इनमें से अधिकांश obfuscation जावास्क्रिप्ट के कुछ विशेषताओं/सिद्धांतों पर आधारित हैं। पहले एक है कि चर नाम यूनिकोड पत्र का उपयोग कर सकते है (Lu, Ll, Lt, Lm, Lo, Nl) और यूनिकोड संख्या (Nd)। आपके द्वारा दिए गए पहले उदाहरण में, चरित्र प्रतीकों की तरह दिख सकता है, लेकिन वे यूनिकोड अक्षर या यूनिकोड नंबर हैं।

दूसरी बात यह है कि जावास्क्रिप्ट में किसी भी चीज़ को खाली स्ट्रिंग जोड़ना इसे स्ट्रिंग में डालेगा। यदि आप इस तथ्य का भी उपयोग करते हैं कि तार जावास्क्रिप्ट में एक सरणी जैसी संरचना है, तो आप आसानी से सामान बना सकते हैं: (false+"")[0], जिसे लिखा जा सकता है (!1+"")[0] है। उस बिंदु से आप अपने स्वयं के स्ट्रिंग अक्षर को पत्र द्वारा लिख ​​सकते हैं।

तीसरा यह है कि प्रत्येक ऑब्जेक्ट प्रॉपर्टी को [] नोटेशन के साथ एक्सेस किया जा सकता है। उदाहरण के लिए: window["alert"]("test")window.alert("test") जैसा ही है। यदि आप पिछले पैराग्राफ के साथ मिश्रण करते हैं, तो मुझे लगता है कि आप आसानी से देख सकते हैं कि यह कहां जा सकता है।

एकमात्र चीज जिसे हम शुरू करने के लिए याद कर रहे हैं या तो window या Function का संदर्भ है। अन्य उत्तरों, आपको पहले से ही Function तक पहुंचने का एक तरीका प्रदान करते हैं, जिसका उपयोग eval जैसा किया जा सकता है।

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

एक बार जब आप window है, तो आप window["eval"] उपयोग कर सकते हैं या सीधे window["alert"] फोन: window कठिन प्राप्त करने के लिए, सबसे आसान तरीका Array.concat के माध्यम से यह इस तरह से लीक करने के लिए है।

यह सब इस बात के आधार पर है कि आप वास्तव में इस तरह के obfuscation कैसे करते हैं। शेष पिछले बिंदुओं की सिर्फ भिन्नता है। यदि आप अतिरिक्त जानकारी चाहते हैं, तो मैंने इसके बारे में कुछ ब्लॉग पोस्ट किया है, आप उन्हें यहां पा सकते हैं: http://holyvier.blogspot.com/2011/10/javascript-obfuscation-introduction.html