TinyInst```

Copyright 2020 Google LLC

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

## TinyInst क्या है?

TinyInst एक हल्की डायनेमिक इंस्ट्रूमेंटेशन लाइब्रेरी है जिसका उपयोग प्रक्रिया में केवल चयनित मॉड्यूल(ों) को इंस्ट्रूमेंट करने के लिए किया जा सकता है, जबकि बाकी प्रक्रिया को मूल रूप से चलने दिया जाता है। इसे समझने में आसान, हैक करने में आसान और हैक करने के लिए आसान बनाया गया है। इसे सभी लक्ष्यों के साथ संगत होने के लिए डिज़ाइन नहीं किया गया है (उस पर बाद में और अधिक)।

### यह [DynamoRIO](https://dynamorio.org/) और [PIN](https://software.intel.com/en-us/articles/pintool) से कैसे तुलना करता है?

TinyInst को DynamoRIO और PIN जैसे जटिल इंस्ट्रूमेंटेशन फ्रेमवर्क के प्रतिस्थापन के रूप में नहीं बनाया गया है, बल्कि उन परिदृश्यों के लिए एक विकल्प के रूप में बनाया गया है जहां एक अधिक हल्का समाधान काम करेगा। TinyInst मानता है कि लक्ष्य अच्छा व्यवहार करने वाला है (नीचे समझाए गए अर्थ में) जो अधिक जटिल फ्रेमवर्क के मामले में नहीं होता है। इस प्रकार, आप शायद [पहले DynamoRIO के साथ किए गए](https://www.slideshare.net/MaximShudrak/fuzzing-malware-for-fun-profit-applying-coverageguided-fuzzing-to-find-bugs-in-modern-malware) जैसे मैलवेयर के खिलाफ TinyInst को सफलतापूर्वक नहीं चला पाएंगे। दूसरी ओर, यदि कोई लक्ष्य अन्य फ्रेमवर्क के साथ काम नहीं करता है, क्योंकि उस मॉड्यूल को इंस्ट्रूमेंट करने की आवश्यकता नहीं है, और इंस्ट्रूमेंट किया गया मॉड्यूल अच्छा व्यवहार करने वाला है, तो यह TinyInst के साथ काम कर सकता है। चूंकि TinyInst के साथ, अधिकांश प्रक्रिया मूल रूप से चलेगी, इसलिए प्रक्रिया का स्टार्टअप समय कम होगा, और उन मामलों में यह अन्य समाधानों से बेहतर प्रदर्शन कर सकता है जहां लक्ष्य प्रक्रिया उन मॉड्यूल में बहुत समय बिताती है जहां इंस्ट्रूमेंटेशन की आवश्यकता नहीं होती है।

### यह [Mesos](https://github.com/gamozolabs/mesos) और [TrapFuzz](https://github.com/googleprojectzero/p0tools/tree/master/TrapFuzz) से कैसे तुलना करता है?

TinyInst एक पूर्ण बाइनरी रीराइटिंग समाधान है, इसलिए लक्ष्य मॉड्यूल में मनमाना व्यवहार बदला जा सकता है। यह उदाहरण के लिए, केवल बेसिक ब्लॉक के बजाय एज कवरेज निकालने में सक्षम बनाता है। इसके अतिरिक्त, TinyInst बेसिक ब्लॉकों की पहचान करने के लिए IDA Pro जैसे अन्य सॉफ़्टवेयर पर निर्भर नहीं करता है।

### TinyInst कौन सा ऑपरेटिंग सिस्टम समर्थन करता है?

TinyInst Windows (x86 और x64), macOS (x64 और ARM64), Linux (x64 और ARM64) और Android (ARM64) पर काम करता है। कृपया प्रत्येक ऑपरेटिंग सिस्टम के लिए संबंधित निर्देशिका में README देखें, अतिरिक्त नोट्स और सीमाओं के लिए।

### कौन से लक्ष्य TinyInst के साथ संगत हैं?

TinyInst मानता है कि सभी इंस्ट्रूमेंट किए गए मॉड्यूल अच्छे व्यवहार वाले हैं, इस अर्थ में कि

- कोई स्व-संशोधित कोड नहीं है
- स्टैक पर रिटर्न एड्रेस कभी भी प्रोग्राम द्वारा सीधे एक्सेस नहीं किया जाता है
OR/AND (सेटिंग्स के आधार पर)
- स्टैक के शीर्ष से पहले (ESP/RSP द्वारा इंगित किए गए पते से कम पते पर) कभी भी कोई डेटा संग्रहीत नहीं किया जाता है। इस शर्त को `-stack_offset` फ्लैग का उपयोग करके "(ESP/RSP - arbitrary_offset) से पहले कोई डेटा नहीं" में शिथिल किया जा सकता है।

TinyInst को लक्ष्य प्रक्रिया के लिए DEP/NX सक्षम होने की भी आवश्यकता होती है। यदि पहले से ऐसा नहीं है, तो आप इसे चालू करने के लिए `-force_dep` फ्लैग का उपयोग कर सकते हैं। हालाँकि, असंभावित स्थिति में कि लक्ष्य को ठीक से कार्य करने के लिए वास्तव में DEP बंद होने की आवश्यकता है, इसे चालू करने से यह गलत व्यवहार कर सकता है।

### प्रदर्शन ओवरहेड क्या है?

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

## TinyInst बनाना

1. एक टर्मिनल खोलें और अपना बिल्ड वातावरण सेट करें (उदा. Windows पर, vcvars64.bat / vcvars32.bat चलाएँ)

2. स्रोत वाली निर्देशिका पर जाएँ

3. निम्नलिखित कमांड चलाएँ (जिस IDE और प्लेटफ़ॉर्म के लिए आप बिल्ड करना चाहते हैं, उसके संस्करण के अनुसार जनरेटर बदलें):

#### Windows```
mkdir build
cd build
cmake -G "Visual Studio 16 2019" -A x64 ..
cmake --build . --config Release

macOS```

mkdir build cd build cmake -G Xcode .. cmake --build . --config Release

#### Linux```
mkdir build
cd build
cmake ..
cmake --build . --config Release

एंड्रॉयड के लिए क्रॉस-कंपाइलिंग```

mkdir build cd build cmake -DCMAKE_TOOLCHAIN_FILE=</path/to/android/ndk>build/cmake/android.toolchain.cmake -DANDROID_NDK=</path/to/android/ndk> -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM= .. cmake --build . --config Release

नोट #1: 64-बिट बिल्ड Windows और Linux ऑपरेटिंग सिस्टम पर 32-बिट टारगेट के विरुद्ध भी चलेगा

नोट #2: 64-बिट Windows पर 32-बिट बिल्ड बनाने में समस्याएँ आ रही हैं क्योंकि वातावरण ठीक से सेट नहीं है और लाइब्रेरीज़ गायब हैं? `cmake --build` चलाने के बजाय Visual Studio में जनरेट की गई .sln फ़ाइल खोलें और वहाँ से बिल्ड करें। यह भी ध्यान दें कि 64-बिट बिल्ड 32-बिट टारगेट पर काम करेगा, इसलिए 32-बिट बिल्ड बनाना आवश्यक नहीं हो सकता है।

## TinyInst का उपयोग

TinyInst मुख्य रूप से अन्य प्रोग्रामों के अंदर एक लाइब्रेरी के रूप में उपयोग किए जाने के लिए है।

TinyInst क्लाइंट TinyInst क्लास के सबक्लास के रूप में लिखा जाता है। क्लाइंट फिर अपनी आवश्यकता वाले API विधियों को ओवरराइड कर सकता है। API विधियाँ नीचे परिभाषित की गई हैं।

क्लाइंट बनाए जाने के बाद, उसे कमांड लाइन विकल्पों के साथ निम्न को कॉल करके प्रारंभ किया जाना चाहिए:

`void init(int argc, char **argv);`

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

`DebuggerStatus Run(int argc, char **argv, uint32_t timeout);`
`DebuggerStatus Attach(unsigned int pid, uint32_t timeout);`

ये फ़ंक्शन या तो किसी प्रोग्राम को चलाते हैं (निर्दिष्ट कमांड लाइन का उपयोग करके) या पहले से चल रहे प्रोग्राम से अटैच होते हैं। यदि कोई टारगेट विधि निर्दिष्ट नहीं है, तो टारगेट तब तक चलता रहेगा जब तक प्रोग्राम समाप्त नहीं हो जाता, प्रोग्राम क्रैश नहीं हो जाता, या टाइमआउट (मिलीसेकंड में दिया गया) समाप्त नहीं हो जाता। यदि टारगेट विधि परिभाषित है, तो TinyInst जब भी टारगेट विधि में प्रवेश होता है और जब भी टारगेट विधि रिटर्न करती है, वापस लौटेगा, जिससे कॉल करने वाला अतिरिक्त कार्य कर सकता है।

जब `Run` और `Attach` लौटते हैं जबकि टारगेट प्रक्रिया अभी भी जीवित है, तो प्रक्रिया को समाप्त करने या निष्पादन जारी रखने के लिए निम्नलिखित फ़ंक्शन का उपयोग किया जा सकता है।

`DebuggerStatus Kill();`

`DebuggerStatus Continue(uint32_t timeout);`

TinyInst के साथ एक उदाहरण कवरेज बाइनरी आती है, जिसे निम्न का उपयोग करके लागू किया जा सकता है:

`<options> -- <target command line>`

Windows पर उदाहरण:

`litecov.exe -instrument_module notepad.exe -coverage_file coverage.txt -- notepad.exe`


## इंस्ट्रूमेंटेशन API

### डीबगर इवेंट कॉलबैक 

ये कॉलबैक केवल जानकारी के लिए हैं और क्लाइंट को इनके दौरान कोई इंस्ट्रूमेंटेड कोड उत्सर्जित नहीं करना चाहिए। इन घटनाओं को स्वयं संभालने से पहले क्लाइंट को सुपरक्लास में परिभाषित उसी हैंडलर को कॉल करना चाहिए।

`OnProcessCreated`
जब टारगेट प्रक्रिया बनाई जाती है या उससे अटैच किया जाता है तब कॉल किया जाता है।

`OnProcessExit`
जब टारगेट प्रक्रिया समाप्त होती है तब कॉल किया जाता है।

`OnProcessEntrypoint`
जब प्रक्रिया (मुख्य बाइनरी) का एंट्रीपॉइंट पहुँच जाता है तब कॉल किया जाता है।

`OnTargetMethodReached`
यदि टारगेट विधि परिभाषित है, तो पहली बार टारगेट विधि तक पहुँचने पर कॉल किया जाता है।