👚 🖕🏻 🤚🏾 एलएलवीएम के साथ कोड ओबसुलेशन तकनीक ♒️ 👩🏽‍🚒 👩🏽‍⚕️

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

परिचय

लेख एक व्यावहारिक घटक की तुलना में अधिक सिद्धांत रखता है और मानता है कि पाठक को कुछ ज्ञान है, साथ ही साथ तैयार समस्याओं को हल किए बिना, दिलचस्प समस्याओं को हल करने की इच्छा है। एलएलवीएम आईआर के अधिकांश निर्देश तीन-पता कोड पर आधारित होते हैं , जिसका अर्थ है कि वे दो तर्क लेते हैं और समान मूल्य वापस करते हैं और हमारे लिए उपलब्ध निर्देशों की संख्या सीमित है।

प्रयुक्त सॉफ्टवेयर:
- GCC 4.8.2 (mingw64)
- आईडीए डेमो
- क्लेंग 3.4
- एलएलवीएम 3.4

एलएलवीएम के साथ क्या संभव है?
1) यादृच्छिक सीएफजी
यह विधि मूल ब्लॉक के साथ पूरक कार्यक्रम के निष्पादन ग्राफ को संशोधित करती है, मूल शुरुआती ब्लॉक को कचरे से पतला किया जा सकता है।

उदाहरण

मूल

#include <stdio.h> #include <stdlib.h> int rand_func() { return 5+rand();; } int main() { int a = rand_func(); goto test; exit(0); test: int b = a+a; }

मूल गणना

Obfuscation 1 प्रारंभ, मुख्य कार्य

ओबस्यूशन 2 प्रारंभ, मुख्य कार्य

ऑबफ्यूजन 3 स्टार्ट, मेन फंक्शन

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

कई उपलब्ध विकल्पों में से एक।

 #include <stdio.h> #include <stdlib.h> #include <time.h> void test() { int a = 32; int b = time(0); int c = a+a+b; int d = a-b+c*2; printf("%d",d); } int main() { test(); }

4) छुपा स्थिरांक, डेटा।
मान लीजिए कि हमारे पास 15h का एक स्थिरांक है, हम इसे बनाते हैं ताकि मूल कोड में एक स्थाई रनटाइम पर बनेगा और खुले रूप में सामना नहीं किया जाएगा। इसके अलावा, किसी भी एन्क्रिप्शन एल्गोरिथ्म का उपयोग करके निरंतर डेटा छिपाया जा सकता है।

उदाहरण

 #include <stdio.h> #include <stdlib.h> int main() { const char *habr = "habrahabr"; printf("%s",habr); }

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

मान लीजिए कि आप डेटा एन्क्रिप्शन जोड़ना चाहते हैं, तो यह करने का सबसे आसान तरीका कैसे है?
LLVM cpp फ़ाइलों से अपना कोड उत्पन्न कर सकता है, जिसे आप अपनी परियोजना में सम्मिलित कर सकते हैं।
प्रश्न अनुभाग के उत्तरों में संकेत देखें।

5) क्लोनिंग फ़ंक्शन और यादृच्छिक क्रम में उनका उपयोग करना।
एक और एक ही फ़ंक्शन को कई (संभावित परिवर्तनों के साथ) में क्लोन किया जाता है, कॉल कोड की जगह पर एक हैंडलर डाला जाता है, कार्यों को यादृच्छिक क्रम में कहा जाता है।
6) कार्यों का एकीकरण।
सभी फ़ंक्शन और उनके कोड एक में स्थानांतरित किए जाते हैं। कुछ मामलों में, इस तरह की एक विधि का उपयोग होता है।
7) एक परिमित राज्य मशीन या स्विच के कोड से संगठन।
एक नया बेस ब्लॉक बनाया जाता है, जो मुख्य फ़ंक्शन के लिए प्रवेश बिंदु बन जाता है, शाखाएं इसे (संभवतः एक चर पर आधारित) अन्य बेस ब्लॉक से बनाई जाती हैं।

उदाहरण

मूल कोड।

 #include <stdio.h> #include <stdlib.h> int rand_func() { return 5+rand();; } int main() { const char *habr = "habrahabr"; printf("%s",habr); int a = rand_func(); goto test; exit(0); test: int b = a+a; }

पहली बार।

दूसरी बार।

8) कोड से छद्म चक्र बनाना।
कार्यों के संबंध में लागू, किसी विशेष फ़ंक्शन का आधार ब्लॉक लिया जाता है, चक्र को व्यवस्थित करने के लिए इसमें कई और ब्लॉक जोड़े जाते हैं, चक्र को केवल एक बार निष्पादित किया जाता है।
9) एक यादृच्छिक वर्चुअल मशीन बनाई गई है, सभी मौजूदा कोड इसके लिए रूपांतरित हैं, मेरे लिए यह आइटम केवल सिद्धांत में अब तक संभव है।

सीखने की शुरुआत कहाँ से करें?

उपलब्ध तीन-पता आदेशों की एक सूची देखें

// === - llvm / Instruction.def - निर्देश का वर्णन करने वाली फ़ाइल - * - C ++ - * - === //
//
// एलएलवीएम कंपाइलर इन्फ्रास्ट्रक्चर
//
// यह फ़ाइल इलिनोइस ओपन सोर्स विश्वविद्यालय के तहत वितरित की गई है
// लाइसेंस। विवरण के लिए LICENSE.TXT देखें।
//
// === --------------------------------------------- ------------------------- === //
//
// इस फ़ाइल में विभिन्न एलएलवीएम निर्देशों का वर्णन है। यह है
// विभिन्न निर्देशों की गणना के लिए एक केंद्रीय स्थान के रूप में इस्तेमाल किया और
// अंततः निर्देशों के बारे में टिप्पणी डालने का स्थान होना चाहिए।
//
// === --------------------------------------------- ------------------------- === //

FIRST_TERM_INST (1)
HANDLE_TERM_INST (1, रिट, रिटर्न)
HANDLE_TERM_INST (2, Br, BranchInst)
HANDLE_TERM_INST (3, स्विच, स्विच इन)
HANDLE_TERM_INST (4, IndirectBr, IndirectBrInst)
HANDLE_TERM_INST (5, आह्वान, आह्वान)
HANDLE_TERM_INST (6, फिर से शुरू करें, फिर से शुरू करें)
HANDLE_TERM_INST (7, पहुंच से बाहर, पहुंच से बाहर)
LAST_TERM_INST (7)

// मानक बाइनरी ऑपरेटरों ...
FIRST_BINARY_INST (8)
HANDLE_BINARY_INST (8, जोड़ें, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (9, FAdd, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (10, उप, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (11, FSub, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (12, मूल, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (13, FMul, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (14, UDiv, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (15, SDiv, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (16, FDiv, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (17, URem, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (18, SRem, बाइनरीऑपरेटर)
HANDLE_BINARY_INST (19, FRem, बाइनरीऑपरेटर)

// लॉजिकल ऑपरेटर्स (पूर्णांक ऑपरेंड)
HANDLE_BINARY_INST (20, शल, बाइनरीऑपरेटर) // शिफ्ट लेफ्ट (तार्किक)
HANDLE_BINARY_INST (21, LShr, बाइनरीऑपरेटर) // शिफ्ट राइट (तार्किक)
HANDLE_BINARY_INST (22, एश, बाइनरीऑपरेटर) // शिफ्ट राईट (अंकगणित)
HANDLE_BINARY_INST (23, और, द्विआधारी)
HANDLE_BINARY_INST (24, या, द्विआधारी)
HANDLE_BINARY_INST (25, Xor, बाइनरीऑपरेटर)
LAST_BINARY_INST (25)

// मेमोरी ऑपरेटर ...
FIRST_MEMORY_INST (26)
HANDLE_MEMORY_INST (26, Alloca, AllocaInst) // स्टैक प्रबंधन
HANDLE_MEMORY_INST (27, लोड, भार)) // मेमोरी हेरफेर इंस्टर्स
HANDLE_MEMORY_INST (28, स्टोर, स्टोर)
HANDLE_MEMORY_INST (29, GetElementPtr, GetElementPtrInst)
HANDLE_MEMORY_INST (30, बाड़, बाड़)
HANDLE_MEMORY_INST (31, AtomicCmpXchg, AtomicCmpXchgInst)
HANDLE_MEMORY_INST (32, AtomicRMW, AtomicRMWInst)
LAST_MEMORY_INST (32)

// कास्ट ऑपरेटर्स ...
// नोट: यहाँ आदेश मायने रखता है क्योंकि CastInst :: isEliminableCastPair है
// नोट: (निर्देश देखें। सीपीसी) इस आदेश के आधार पर एक तालिका को एन्कोड करता है।
FIRST_CAST_INST (33)
HANDLE_CAST_INST (33, Trunc, TruncInst) // पूर्णांक पूर्णांक
HANDLE_CAST_INST (34, ZExt, ZExtInst) // शून्य पूर्णांक का विस्तार करते हैं
HANDLE_CAST_INST (35, SExt, SExtInst) // साइन पूर्णांकों का विस्तार करें
HANDLE_CAST_INST (36, FPToUI, FPToUIInst) // फ़्लोटिंग पॉइंट -> UInt
HANDLE_CAST_INST (37, FPToSI, FPToSIInst) // फ़्लोटिंग पॉइंट -> SInt
HANDLE_CAST_INST (38, UIToFP, UIToFPInst) // UInt -> फ़्लोटिंग पॉइंट
HANDLE_CAST_INST (39, SIToFP, SIToFPInst) // SInt -> फ़्लोटिंग पॉइंट
HANDLE_CAST_INST (40, FPTrunc, FPTruncInst) // अस्थायी फ़्लोटिंग बिंदु
HANDLE_CAST_INST (41, FPExt, FPExtInst) // फ़्लोटिंग पॉइंट बढ़ाएँ
HANDLE_CAST_INST (42, PtrToInt, PtrToIntInst) // सूचक -> पूर्णांक
HANDLE_CAST_INST (43, IntToPtr, IntToPtrInst) // पूर्णांक -> सूचक
HANDLE_CAST_INST (44, BitCast, BitCastInst) // टाइप कास्ट
LAST_CAST_INST (44)

// अन्य ऑपरेटरों ...
FIRST_OTHER_INST (45)
HANDLE_OTHER_INST (45, ICmp, ICmpInst) // पूर्णांक तुलना अनुदेश
HANDLE_OTHER_INST (46, FCmp, FCmpInst) // फ्लोटिंग पॉइंट तुलना इंस्ट्र।
HANDLE_OTHER_INST (47, PHI, PHINode) // PHI नोड निर्देश
HANDLE_OTHER_INST (48, कॉल, कॉल इनस्टॉल) // एक फ़ंक्शन को कॉल करें
HANDLE_OTHER_INST (49, चुनें, चयन करें) // निर्देश का चयन करें
HANDLE_OTHER_INST (50, UserOp1, निर्देश) // एक पास में आंतरिक रूप से उपयोग किया जा सकता है
HANDLE_OTHER_INST (51, UserOp2, निर्देश) // केवल पास करने के लिए आंतरिक
HANDLE_OTHER_INST (52, VAArg, VAArgInst) // vARg अनुदेश
HANDLE_OTHER_INST (53, ExtractElement, ExtractElementInst) // वेक्टर से अर्क
HANDLE_OTHER_INST (54, InsertElement, InsertElementInst) // वेक्टर में डालें
HANDLE_OTHER_INST (55, शफललेक्टर, शफललेक्टर इनस्टॉल) // फेरबदल वाले वैक्टर।
HANDLE_OTHER_INST (56, ExtractValue, ExtractValueInst) // कुल से निकालें
HANDLE_OTHER_INST (57, InsertValue, InsertValueInst) // कुल में डालें
HANDLE_OTHER_INST (58, लैंडिंगपैड, लैंडिंगपैड) // लैंडिंग पैड अनुदेश।
LAST_OTHER_INST (58)

निम्नलिखित प्रलेखन पढ़ा जाना चाहिए:
LLVM-cheatsheet
एलएलवीएम प्रोग्रामर मैनुअल
LLVM-CheatSheet 2
LLVMBackendCPU
सीएफएफ के माध्यम से सी ++ कार्यक्रमों का अवलोकन

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

के टुकड़े

एएसएम निर्देशों को सम्मिलित करने के लिए, आप llvm :: InlineAsm या मशीनपास का उपयोग कर सकते हैं, मशीन पास के माध्यम से आप बदल सकते हैं, निर्देश जोड़ सकते हैं। एक अच्छा उदाहरण यहाँ है।

आपको शुरू करने के लिए कुछ उपयोगी कोड

बाईटकोड फाइल कैसे पढ़ें?

 std::string file = "1.bc"; std::string ErrorInfo; llvm::LLVMContext context; llvm::MemoryBuffer::getFile(file.c_str(), bytecode); llvm::Module *module = llvm::ParseBitcodeFile(bytecode.get(), context, &error);

मॉड्यूल में कार्य कैसे करें?

 for (auto i = module->getFunctionList().begin(); i != module->getFunctionList().end(); ++i) { printf("Function %s",i->getName().str()); }

किसी भी निर्देश से संबंधित जांच कैसे करें?

 if (llvm::isa<llvm::BranchInst>(currentInstruction)) printf("BranchInst!");

टर्मिनेटर को दूसरे निर्देश से कैसे बदलें?

 llvm::BasicBlock *block = () block->replaceAllUsesWith(  );

दूसरे को एक निर्देश कैसे दें?

 llvm::Instruction* test = basicBlock->getTerminator(); llvm::BranchInst* branchInst = llvm::dyn_cast<llvm::BranchInst>(test)

आधार इकाई में पहला गैर- phi निर्देश कैसे प्राप्त करें?

 llvm::Instruction *inst = currentInstruction->getParent()->getFirstNonPHI()

किसी फ़ंक्शन में निर्देशों को पुनरावृत्त कैसे करें?

  for(llvm::inst_iterator i = inst_begin(function); i != inst_end(function); i++) { llvm::Instruction* inst = &*i; }

यदि निर्देश का उपयोग कहीं और किया जाता है तो कैसे पता करें?

 bool IsUsedOutsideParentBlock(llvm::Instruction* inst) { for(llvm::inst::use_iterator i = inst->use_begin(); i != inst->use_end(); i++) { llvm::User* user = *i; if(llvm::cast<llvm::Instruction>(user)->getParent() != inst->getParent()) return true; } return false; }

InvokeInst और अन्य द्वारा संदर्भित बेस ब्लॉक कैसे प्राप्त / बदल सकते हैं?

 invokeInst->getSuccessor(0); //    . invokeInst->setSuccessor(0,basicBlock); //.

सवालों के जवाब

प्रश्न: मलबे के बारे में क्या?
एक: यह सब आप पर निर्भर करता है, एक परियोजना है जो एलएलवीएम पर आधारित है ताकि आपत्ति को दूर किया जा सके।
प्रश्न: स्रोत से बाइट कोड फ़ाइल कैसे उत्पन्न करें?
एक: clang -emit-llvm -o 1.bc -c 1.c
प्रश्न: बाइट कोड कैसे संकलित करें?
एक: clang -o 1 1.bc
प्रश्न: एलएलवीएम आईआर दृश्य से एएसएम फ़ाइल कैसे उत्पन्न करें?
A: llc foo.ll
प्रश्न: स्रोत से IR फाइल कैसे जनरेट करें?
A: clang -S -emit-llvm 1.c
प्रश्न: .s फ़ाइल (असेंबलर) को कैसे संकलित करें?
A: gcc -o exe 1.s
प्रश्न: बायटेकोड से obj फाइल कैसे प्राप्त करें?
A: llc -filetype=obj 1.bc
प्रश्न: cpp फ़ाइल के लिए LLVM एपीआई के साथ स्रोत कैसे प्राप्त करें?
A: clang ++ -c -emit-llvm 1.cpp -o 1.ll तब llc -march=cpp -o 1.ll.cpp 1.ll
प्रश्न: विंडोज़ के तहत संकलित क्लैंग, लेकिन वह हेडर फ़ाइलों को नहीं खोज सकता है, कैसे इलाज करें?
A: आपको InitHeaderSearch.cpp ढूंढने और आवश्यक पथ जोड़ने की आवश्यकता है, AddMinGWCPlusPlusIncludePaths, AddMinGW64CXXPaths की ओर देखें।
प्रश्न: क्या क्लैंग एक दृश्य स्टूडियो के रूप में संकलित है?
A: वर्तमान में नहीं, यह केवल सबसे सरल C कोड संकलित कर सकता है।
प्रश्न: अनुकूलन मोड के साथ क्लेंग उत्पन्न निर्देशों / कार्यों को काट देता है, मुझे क्या करना चाहिए?
A: इस सीपी फ़ाइल में आपके मार्ग को क्लैंग में एम्बेड किया जाना चाहिए। आप संकलक को यह भी सोच सकते हैं कि हमारे द्वारा जोड़ा गया कोड आवश्यक है, इसके लिए यह आवश्यक है कि यह कोड आवश्यक रूप से उपयोग किया जाता है, कार्यों के मामले में, उन्हें बुलाया जाना चाहिए। परीक्षणों के लिए, आप -O0 मोड का उपयोग कर सकते हैं।

एलएलवीएम के साथ कोड ओबसुलेशन तकनीक

परिचय

सीखने की शुरुआत कहाँ से करें?

के टुकड़े

सवालों के जवाब

More articles: