ओवरलैपिंग निर्देश के साथ कोडांतरक कोड कैसे लिखें

हम आपके ध्यान को ओवरलैपिंग निर्देशों के साथ कोडांतरक प्रोग्राम बनाने की तकनीक के लिए प्रस्तुत करते हैं - संकलित बाइटेकोड को डिसबंबिंग से बचाने के लिए। यह तकनीक स्थैतिक और गतिशील बायोटेक विश्लेषण दोनों का सामना करने में सक्षम है। विचार बाइट्स की एक धारा का चयन करने के लिए है, जब दो अलग-अलग ऑफसेट से अलग हो जाते हैं, तो निर्देशों के दो अलग-अलग श्रृंखलाओं में परिणाम होता है, अर्थात, प्रोग्राम को निष्पादित करने के दो अलग-अलग तरीके। ऐसा करने के लिए, हम मल्टीबीट असेंबलर निर्देश लेते हैं, और इन निर्देशों के बाइटकोड के चर भागों में संरक्षित कोड छिपाते हैं। डिस्सेम्बलर को धोखा देने के लिए झूठे निशान (निर्देशों की मास्किंग श्रृंखला के अनुसार) पर डालकर, और उसकी आंखों को निर्देशों की एक छिपी श्रृंखला से बचाने के लिए।

एक प्रभावी "ओवरलैप" बनाने के लिए तीन आवश्यक शर्तें

डिस्सेम्बलर को धोखा देने के लिए, ओवरलैपिंग कोड को निम्नलिखित तीन शर्तों को पूरा करना चाहिए: 1) मास्किंग चेन से निर्देश और छिपी हुई चेन को हमेशा एक दूसरे के साथ काटना चाहिए, अर्थात एक-दूसरे के सापेक्ष संरेखित नहीं किया जाना चाहिए (उनके पहले और अंतिम बाइट को संयोग नहीं होना चाहिए)। अन्यथा, छिपे हुए कोड का हिस्सा मास्किंग श्रृंखला में दिखाई देगा। 2) दोनों श्रृंखलाओं में विधानसभा के निर्देशों का समावेश होना चाहिए। अन्यथा, मास्किंग को पहले से ही स्थैतिक विश्लेषण के चरण में पता लगाया जाएगा (निष्पादन के लिए अनुपयुक्त कोड पर ठोकर खाने के बाद, डिस्सेम्बलर कमांड पॉइंटर को सही करेगा और मास्किंग को उजागर करेगा)। 3) दोनों श्रृंखलाओं के सभी निर्देशों को न केवल प्रशंसनीय होना चाहिए, बल्कि सही तरीके से निष्पादित किया जाना चाहिए (ऐसा होने से रोकने के लिए, जब आप उन्हें निष्पादित करने का प्रयास करते हैं तो कार्यक्रम दुर्घटनाग्रस्त हो जाता है)। अन्यथा, गतिशील विश्लेषण के दौरान, विफलताएं रिवर्स का ध्यान आकर्षित करेंगी, और मास्किंग का खुलासा किया जाएगा।

"ओवरलैपिंग" कोडांतरक निर्देशों की तकनीक का विवरण

ओवरलैपिंग कोड बनाने की प्रक्रिया को जितना संभव हो उतना लचीला बनाने के लिए, केवल ऐसे मल्टीबीट निर्देशों का चयन करना आवश्यक है, जिसके लिए जितना संभव हो उतने बाइट्स किसी भी मूल्य ले सकते हैं। ये मल्टीबाइट निर्देश एक मास्किंग अनुदेश श्रृंखला का गठन करेंगे।

ओवरलैपिंग कोड बनाने के लक्ष्य का पीछा करने में, जो उपरोक्त तीन स्थितियों को पूरा करेगा, हम प्रत्येक मास्किंग निर्देश को फॉर्म के बाइट्स के अनुक्रम के रूप में मानते हैं: XX YY ZZ।

यहां XX निर्देश उपसर्ग है (निर्देश कोड और अन्य स्थिर बाइट्स - जिन्हें बदला नहीं जा सकता)।

YY बाइट्स हैं जिन्हें मनमाने ढंग से बदला जा सकता है (एक नियम के रूप में, ये बाइट्स डायरेक्ट संख्यात्मक मान को निर्देश पर संग्रहीत करते हैं; या ऑपरेंड का पता मेमोरी में संग्रहीत होता है)। संभव के रूप में कई YY बाइट्स होने चाहिए ताकि अधिक छिपे हुए निर्देश उनमें फिट हो सकें।

जेडजेड - ये भी बाइट्स हैं जिन्हें मनमाने ढंग से बदला जा सकता है, एकमात्र अंतर यह है कि बाद के बाइट्स एक्सएक्स (जेडजेडएक्सएक्सएक्स) के साथ जेडजेड बाइट्स का संयोजन एक वैध निर्देश बनाना चाहिए जो लेख की शुरुआत में तैयार की गई तीन स्थितियों को संतुष्ट करता है। आदर्श रूप से, ZZ को केवल एक बाइट पर कब्जा करना चाहिए, ताकि YY पर (यह अनिवार्य रूप से सबसे महत्वपूर्ण हिस्सा है - हमारे छिपे हुए कोड को यहां रखा गया है) यथासंभव बाइट्स होना चाहिए। अंतिम छिपे हुए निर्देश को ZZ में समाप्त होना चाहिए, - निष्पादन की दो श्रृंखलाओं के लिए एक अभिसरण बिंदु बनाना।

Gluing निर्देश

संयोजन ZZ XX - हम gluing निर्देश को कॉल करेंगे। एक gluing निर्देश की आवश्यकता है, सबसे पहले, छिपे हुए निर्देशों में शामिल होने के लिए, जो आसन्न मास्किंग निर्देशों में स्थित हैं, और दूसरी बात, लेख की शुरुआत में बताई गई पहली आवश्यक शर्त को पूरा करने के लिए: दोनों श्रृंखलाओं के निर्देशों को हमेशा एक दूसरे के साथ काटना चाहिए (इसलिए, gluing निर्देश हमेशा दो मास्किंग निर्देशों के चौराहे पर स्थित है)।

ग्लूइंग निर्देश को एक छिपी हुई कमांड श्रृंखला में निष्पादित किया जाता है, और इसलिए इसे इस तरह से चुना जाना चाहिए कि छिपे हुए कोड पर यथासंभव कुछ प्रतिबंध लगाए जा सकें। मान लें कि जब इसे निष्पादित किया जाता है, तो सामान्य उद्देश्य रजिस्टर और EFLAGS रजिस्टर बदल दिया जाता है, तब छिपा कोड प्रभावी रूप से संबंधित रजिस्टरों और सशर्त आदेशों का उपयोग करने में सक्षम नहीं होगा (उदाहरण के लिए, यदि gluing निर्देश तुलना ऑपरेटर द्वारा पूर्व दिया गया है, और gluing निर्देश ही EFLAGS रजिस्टर के मूल्य को बदल देता है, तो सशर्त संक्रमण होता है) जो ग्लूइंग निर्देशों के बाद सही तरीके से काम नहीं करेगा)।

ओवरलैप तकनीक का उपरोक्त विवरण निम्न आकृति में चित्रित किया गया है। यदि निष्पादन प्रारंभ बाइट्स (XX) के साथ शुरू होता है, तो एक मास्किंग अनुदेश श्रृंखला सक्रिय होती है। और अगर बाइट्स YY से, एक छिपा हुआ निर्देश श्रृंखला सक्रिय है।

असेंबलर निर्देश "मास्किंग निर्देश" की भूमिका के लिए उपयुक्त

निर्देशों में सबसे लंबा, जो पहली नज़र में हमें सबसे अच्छा लगता है, एमओवी का 10-बाइट संस्करण है, जहां रजिस्टर और 32-बिट पते द्वारा निर्दिष्ट ऑफसेट को पहले ऑपरेंड के रूप में स्थानांतरित किया जाता है, और दूसरे ऑपरेंड के रूप में 32-बिट नंबर। इस निर्देश में सबसे अधिक बाइट्स हैं जिन्हें मनमाने ढंग से (8 टुकड़ों के रूप में कई) बदला जा सकता है।

हालांकि, हालांकि यह निर्देश प्रशंसनीय लगता है (सैद्धांतिक रूप से, इसे सही तरीके से निष्पादित किया जा सकता है), यह अभी भी हमें सूट नहीं करता है, क्योंकि इसका पहला ऑपरेंड, एक नियम के रूप में, एक दुर्गम पते को इंगित करेगा, और इसलिए, जब इस तरह के एमओवी को निष्पादित करने की कोशिश कर रहा है, तो कार्यक्रम ढह जाएगा। इस प्रकार यह 10-बाइट MOV तीसरी आवश्यक शर्त को पूरा नहीं करता है: दोनों श्रृंखलाओं के सभी निर्देशों को सही ढंग से निष्पादित किया जाना चाहिए।

इसलिए, हम केवल उन आवेदकों को निर्देश देने की भूमिका के लिए चुनेंगे जो कार्यक्रम के पतन का जोखिम नहीं उठाते। यह स्थिति अतिव्यापी कोड बनाने के लिए उपयुक्त निर्देशों की श्रेणी को महत्वपूर्ण रूप से बताती है, लेकिन अभी भी उपयुक्त हैं। नीचे उनमें से चार हैं। इन चार निर्देशों में से प्रत्येक में पांच बाइट्स होते हैं, जिन्हें प्रोग्राम क्रैश के जोखिम के बिना, मनमाने ढंग से बदला जा सकता है।

• ए के। यह निर्देश दूसरे ऑपरेंड में अभिव्यक्ति द्वारा निर्दिष्ट मेमोरी पते की गणना करता है और परिणाम को पहले ऑपरेंड में संग्रहीत करता है। चूँकि हम इसकी वास्तविक पहुँच के बिना मेमोरी को संदर्भित कर सकते हैं (और, तदनुसार, प्रोग्राम क्रैश के जोखिम के बिना), इस निर्देश के अंतिम पाँच बाइट्स मनमाना मान ले सकते हैं।

• CMOVcc। यदि "cc" शर्त पूरी होती है तो यह निर्देश MOV ऑपरेशन करता है। इस निर्देश के लिए तीसरी आवश्यकता को पूरा करने के लिए, शर्त को चुना जाना चाहिए ताकि किसी भी परिस्थिति में इसका मूल्य FALSE हो। अन्यथा, यह निर्देश एक दुर्गम स्मृति पते तक पहुँचने की कोशिश कर सकता है, और इसी तरह। कार्यक्रम नीचे लाएं।

• SETcc। यह CMOVcc के समान सिद्धांत पर काम करता है: बाइट को सेट करता है यदि स्थिति "cc" पूरी होती है। इस निर्देश में CMOVcc जैसी ही समस्या है: अमान्य पते पर पहुंचने से प्रोग्राम क्रैश हो जाएगा। इसलिए, "सीसी" स्थिति का चुनाव बहुत सावधानी से किया जाना चाहिए।

• एनओपी। एनओपी अलग-अलग लंबाई के हो सकते हैं (2 से 15 बाइट्स से), जिसके आधार पर ऑपरेंड उन में इंगित किए जाते हैं। इस मामले में, प्रोग्राम को क्रैश करने का कोई जोखिम नहीं होगा (एक अमान्य मेमोरी पते तक पहुंच के कारण)। क्योंकि केवल एक चीज जो एनओपी करते हैं, वह निर्देश काउंटर को बढ़ाता है, (वे ऑपरेंड पर कोई संचालन नहीं करते हैं)। इसलिए, एनओपी बाइट्स जिसमें ऑपरेंड निर्दिष्ट हैं, एक मनमाना मूल्य ले सकता है। हमारे उद्देश्यों के लिए, एक 9-बाइट एनओपी सबसे उपयुक्त है।

संदर्भ के लिए, यहां कुछ अन्य एनओपी विकल्प हैं।

असेंबलर निर्देश "gluing निर्देश" की भूमिका के लिए उपयुक्त

एक gluing निर्देश की भूमिका के लिए उपयुक्त निर्देशों की सूची प्रत्येक विशिष्ट मास्किंग अनुदेश के लिए अद्वितीय है। नीचे एक उदाहरण के रूप में 9-बाइट एनओपी का उपयोग करके एक सूची (एल्गोरिथम द्वारा निम्नलिखित आकृति में दिखाया गया है) उत्पन्न होता है।

इस सूची को बनाते हुए, हमने केवल उन विकल्पों को ध्यान में रखा, जिनमें ZZ 1 बाइट लेता है (अन्यथा छिपे हुए कोड के लिए बहुत कम जगह बची होगी)। यहां 9-बाइट एनओपी के लिए उपयुक्त चिपचिपा निर्देशों की एक सूची दी गई है।

निर्देशों की इस सूची में कोई भी ऐसा नहीं है जो दुष्प्रभावों से मुक्त होगा। उनमें से प्रत्येक या तो EFLAGS, या सामान्य उद्देश्य रजिस्टर, या दोनों को एक साथ बदलता है। इस सूची को 4 श्रेणियों में विभाजित किया गया है, जिसके अनुसार निर्देश का क्या दुष्प्रभाव है।

पहली श्रेणी में निर्देश शामिल हैं जो EFLAGS रजिस्टर को बदलते हैं, लेकिन सामान्य उद्देश्य रजिस्टर को नहीं बदलते हैं। इस श्रेणी के निर्देशों का उपयोग तब किया जा सकता है जब EFLAGS रजिस्टर से जानकारी का मूल्यांकन करने के आधार पर कोई भी सशर्त कूद या छिपी हुई निर्देशों की श्रृंखला में कोई निर्देश न हों। इस मामले में इस मामले में (एक 9-बाइट एनओपी के लिए) केवल दो निर्देश हैं: टेस्ट और सीएमपी।

निम्नलिखित छिपे हुए कोड का एक सरल उदाहरण है जो TEST का उपयोग ग्लूइंग अनुदेश के रूप में करता है। यह उदाहरण एक एक्जिट सिस्टम कॉल करता है, जो लिनक्स के किसी भी संस्करण के लिए 1 का मान लौटाता है। हमारी आवश्यकताओं के लिए सही निर्देश बनाने के लिए, हमें पहले NOP के अंतिम बाइट को 0xA9 पर सेट करना होगा। यह बाइट, अगले NOP (66 0F 1F 84) के पहले चार बाइट्स के साथ युग्मित होने पर, TAX EAX निर्देश, 0x841F0F66 में बदल जाएगा। निम्नलिखित दो आंकड़े संबंधित कोडांतरक कोड (मास्किंग श्रृंखला और छिपी श्रृंखला के लिए) दिखाते हैं। जब पहली NOP के 4 बाइट पर नियंत्रण स्थानांतरित हो जाता है तो छिपी हुई श्रृंखला सक्रिय हो जाती है।

दूसरी श्रेणी में वे निर्देश शामिल हैं जो सामान्य रजिस्टरों या उपलब्ध मेमोरी (स्टैक, उदाहरण के लिए) के मूल्यों को बदलते हैं, लेकिन EFLAGN रजिस्टर को नहीं बदलते हैं। PUSH निर्देश या किसी MOV संस्करण को निष्पादित करते समय, जहां एक तत्काल मूल्य दूसरे ऑपरेंड के रूप में निर्दिष्ट किया जाता है, EFLAGS रजिस्टर अपरिवर्तित रहता है। इस प्रकार दूसरी श्रेणी के ग्लाइडिंग निर्देशों को तुलना निर्देश (उदाहरण के लिए टेस्ट) और EFLAGN रजिस्टर का मूल्यांकन करने वाले निर्देशों के बीच भी रखा जा सकता है। हालाँकि, इस श्रेणी में दिए गए निर्देश संगत ग्लिइंग निर्देशों में दिखाई देने वाले रजिस्टर के उपयोग को सीमित करते हैं। उदाहरण के लिए, यदि MOV EBP, 0x841F0F66 को एक gluing निर्देश के रूप में उपयोग किया जाता है, तो EBP रजिस्टर (बाकी छिपे हुए कोड से) का उपयोग करने की संभावनाएं काफी सीमित हैं।

तीसरी श्रेणी में निर्देश शामिल हैं जो EFLAGS रजिस्टर को बदलते हैं, और सामान्य उद्देश्य रजिस्टर (या मेमोरी) बदलते हैं। इन निर्देशों में पहले दो श्रेणियों के निर्देशों के स्पष्ट लाभ नहीं हैं। हालांकि, उनका उपयोग भी किया जा सकता है, क्योंकि वे लेख की शुरुआत में तैयार की गई तीन शर्तों का खंडन नहीं करते हैं। चौथी श्रेणी में निर्देश शामिल हैं, जिसके कार्यान्वयन की कोई गारंटी नहीं है कि कार्यक्रम दुर्घटनाग्रस्त नहीं होगा - स्मृति तक अवैध पहुंच का खतरा है। उनका उपयोग करना बेहद अवांछनीय है, क्योंकि वे तीसरी शर्त को पूरा नहीं करते हैं।

असेंबलर निर्देश जो एक छिपी श्रृंखला में उपयोग किया जा सकता है

हमारे मामले में (जब 9-बाइट एनओपी का उपयोग मास्किंग निर्देशों के रूप में किया जाता है), छिपे हुए चेन से प्रत्येक निर्देश की लंबाई चार बाइट्स से अधिक नहीं होनी चाहिए (यह प्रतिबंध चिपचिपा निर्देशों पर लागू नहीं होता है जो 5 बाइट्स पर कब्जा कर लेते हैं)। हालांकि, यह बहुत महत्वपूर्ण सीमा नहीं है, क्योंकि अधिकांश निर्देश जो चार बाइट्स से अधिक लंबे होते हैं, उन्हें कई छोटे निर्देशों में विघटित किया जा सकता है। निम्नलिखित 5-बाइट MOV का एक उदाहरण है जो एक छिपी श्रृंखला में फिट होने के लिए बहुत बड़ा है।

हालाँकि, यह पाँच-बाइट MOV तीन निर्देशों में विघटित हो सकता है, जिसकी लंबाई चार बाइट्स से अधिक नहीं होती है।

कार्यक्रम में NOPs मास्किंग फैलाकर मास्किंग बढ़ाना

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

इस मामले में छिपे हुए कोड के निष्पादन की सही श्रृंखला बिना शर्त कूद के दोहरे-बाइट निर्देशों द्वारा समर्थित हो सकती है। इस स्थिति में, प्रत्येक एनओपी के अंतिम दो बाइट्स 2-बाइट जेएमपी पर कब्जा कर लेंगे।

यह ट्रिक आपको NOP के एक लंबे अनुक्रम को कई छोटे लोगों में विभाजित करने की अनुमति देता है (या प्रत्येक NOP का उपयोग भी करता है)। इस तरह के एक छोटे अनुक्रम के अंतिम एनओपी में, पेलोड के केवल 3 बाइट्स आवंटित किए जा सकते हैं (4 बाइट बिना शर्त कूद निर्देश द्वारा लिया जाएगा)। इस प्रकार यहाँ वैध निर्देशों के आकार पर एक अतिरिक्त प्रतिबंध है। हालांकि, जैसा कि ऊपर उल्लेख किया गया है, लंबे निर्देशों को छोटे निर्देशों की श्रृंखला पर रखा जा सकता है। नीचे उसी 5-बाइट MOV का एक उदाहरण है, जिसे हमने पहले ही 4-बाइट सीमा में फिट करने के लिए रखा था। हालाँकि, अब हम इस MOV को 3 बाइट सीमा में फिट करने के लिए इस तरह से विघटित करते हैं।

एक ही सिद्धांत के अनुसार सभी लंबे निर्देशों को छोटे लोगों में विघटित करने के बाद, हम अधिक मुखौटा बनाने के लिए, आम तौर पर पूरे कार्यक्रम में बिखरे हुए केवल एकल एनओपी का उपयोग कर सकते हैं। दो-बाइट जेएमपी निर्देश आगे और पीछे 127 बाइट्स से कूद सकते हैं, जिसका अर्थ है कि दो लगातार एनओपी (लगातार, छिपे हुए निर्देशों की श्रृंखला के संदर्भ में) 127 बाइट्स के भीतर होना चाहिए।

इस ट्रिक का एक और महत्वपूर्ण लाभ है (बढ़ाया मास्किंग के अलावा): इसके साथ, आप संकलित बाइनरी फ़ाइल के मौजूदा एनओपी में छिपे हुए कोड को रख सकते हैं (यानी, इसे संकलित करने के बाद बाइनरी में पेलोड डालें)। इस मामले में, यह आवश्यक नहीं है कि ये अनाथ एनओपी 9-बाइट हों। उदाहरण के लिए, यदि बाइनरी में एक पंक्ति में कई एकल-बाइट एनओपी हैं, तो उन्हें कार्यक्रम की कार्यक्षमता को बाधित किए बिना, मल्टी-बाइट एनओपी में परिवर्तित किया जा सकता है। नीचे एनओपी को फैलाने के लिए एक तकनीक का एक उदाहरण है (यह कोड कार्यात्मक रूप से ऊपर चर्चा किए गए उदाहरण के बराबर है)।

एनओपी में छिपा हुआ ऐसा छिपा हुआ कोड, पूरे कार्यक्रम में बिखरा हुआ है, पहले से ही इसका पता लगाना ज्यादा मुश्किल है।

एक चौकस पाठक ने देखा होगा कि पहले NOP में कोई अंतिम बाइट नहीं है। हालाँकि, चिंता की कोई बात नहीं है। क्योंकि यह लावारिस बाइट एक बिना शर्त कूद से पहले है। इस प्रकार नियंत्रण कभी भी उसे हस्तांतरित नहीं किया जाएगा। तो सब कुछ क्रम में है।

यहां ओवरलैपिंग कोड बनाने की तकनीक दी गई है। स्वास्थ्य पर प्रयोग करें। आंखों को चुभने से अपना कीमती कोड छिपाएं। लेकिन सिर्फ 9-बाइट एनओपी नहीं बल्कि कुछ अन्य निर्देश अपनाएं। क्योंकि पलटवार शायद इस लेख को भी पढ़ेंगे।