एमहूक बनाम जुमा

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

शुरुआत में, जैसा कि मैंने संवाद किया, मूक के बारे में कुछ शब्द। Mhook एक विदेशी एप्लिकेशन के कोड स्ट्रीम में आपके कोड को एम्बेड करने के लिए एक पुस्तकालय है। कोड इंजेक्शन का मुद्दा पहले से ही हैबे पर उठाया गया है, इसलिए यदि किसी को इस मुद्दे की विस्तृत चर्चा में रुचि है, तो वे साइट पर देख सकते हैं। संक्षेप में, कोड को इंटरसेप्ट करने के लिए, 5 बाइट्स को उस पते पर हटा दिया जाता है जिसे इंटरसेप्ट किया जाएगा और इसके बजाय एक अनौपचारिक जंप कोड (jmp #addr) लिखा जाता है। और जिन 5 बाइट्स को हटाया गया था, उन्हें एक विशेष रूप से आवंटित स्थान पर स्थानांतरित किया जाता है, जिसे स्प्रिंगबोर्ड भी कहा जाता है। जब इंटरसेप्शन फ़ंक्शन काम करता है, तो यह स्प्रिंगबोर्ड में बिना शर्त संक्रमण कर सकता है, उन 5 संग्रहीत बाइट्स को वहां निष्पादित किया जाएगा और इंटरसेप्ट किए गए कोड में संक्रमण होगा। तो यह योजनाबद्ध रूप से दिखेगा:



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



जाहिर है, यह बहुत नहीं दिखता है। इसका उपयोग करना भी इतना ही है, यह हर समय एक नया अवरोधन करने के लिए आलसी है, क्योंकि आपको इन सभी बिंदुओं को लिखना है। मैंने इस बहुत ही मध्यवर्ती फ़ंक्शन (हुकप्रोक) को फेंकने का फैसला किया। और हैंडलर फ़ंक्शन में, C ++ वर्ग के रूप में रजिस्टरों के मूल्य को पास करें। मैंने इस वर्ग को प्रसंग कहा। इसमें सभी सामान्य प्रयोजन रजिस्टर शामिल हैं और उन तक पहुंच प्रदान करता है। पूर्ण प्रसन्नता के लिए, मुझे निम्नलिखित कार्यों की आवश्यकता है:

प्रसंग प्रसंग ;
// आप रजिस्टर से मूल्य पढ़ सकते हैं
DWORD var = संदर्भ। EAX ;
// लेकिन आप रजिस्टर को लिख सकते हैं
संदर्भ। EAX = var
// आप मेमोरी से मूल्य पढ़ सकते हैं।
// सूचकांक एक स्थिर की तरह हो सकता है
var = संदर्भ [ 0xBEDABEDA ]
// तो रजिस्टर है
var = संदर्भ [ EAX ]
// और मेमोरी में लिखने में भी सक्षम होना चाहिए
संदर्भ [ 0xBEDABEDA ] = var
संदर्भ [ EAX ] = var
// और ताकि रजिस्टरों पर अंकगणितीय संचालन किया जा सके
संदर्भ। EAX = प्रसंग। EAX + संदर्भ। EBX * 4
// और ताकि यह अंकगणित अभिव्यक्ति एक सूचकांक हो सके
संदर्भ [ प्रसंग EAX + संदर्भ। EBX * 4 ] = var
// और बिल्कुल स्पष्ट नहीं है, लेकिन किसी कारण से मैं चाहता था।
// ताकि रजिस्टर से ऑफसेट वर्ग कोष्ठक में इंगित किया जा सके
var = प्रसंग। ईएसआई [ 0x20 ]

पिछले उदाहरण से फ़ंक्शन निम्न रूप लेगा:

शून्य onProc ( संदर्भ संदर्भ ) {
DWORD बैकट्रेस = संदर्भ [ esp ]
DWORD arg1 = संदर्भ [ esp + 4 ]
प्रिंटफ ( "% d% d" , बैकट्रेस, arg1 ) ;
}
रजिस्टरहूक ( रियलप्रोक, हुकप्रोक ) ;

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

यह सब कार्यक्रम में कैसे आता है? मैंने पहले ही वर्णन किया है कि कैसे mhook काम करता है। मैंने एक और कदम जोड़ा:

; रजिस्टर बचाओ
pushad
; हैंडलर फ़ंक्शन में उन्हें एक पॉइंटर पास करें
जासूसी करना
; हैंडलर फ़ंक्शन को कॉल करें
कॉल हुक
; स्पष्ट ढेर
esp जोड़ें , ४
; रजिस्टर बहाल करें
popad
; एक वास्तविक कार्य के लिए स्प्रिंगबोर्ड पर जाएं
jmp trampoline

यह कोड "x60x54xE8x00x00x00x00x83xC4x04x61xE9x00x00x00x00" में संग्रहीत है। जब आपको हुक सेट करने की आवश्यकता होती है, तो मेमोरी आवंटित की जाती है, वहां एक लाइन कॉपी की जाती है, हैंडलर फ़ंक्शन की ऑफ़सेट को कॉल स्टेटमेंट में प्रतिस्थापित किया जाता है, और स्प्रिंगबोर्ड ऑफ़सेट को जेएमपी ऑपरेटर में रखा जाता है। पुषाद, स्टोर करने वाले रजिस्टरों के अलावा, हैंडलर फ़ंक्शन के लिए डेटा तैयार करता है, इसलिए बोलने के लिए। यदि हैंडलर फ़ंक्शन इस डेटा को बदलता है, तो परिवर्तन पॉपड कमांड द्वारा लागू किए जाते हैं। मुझे यकीन नहीं है मैं तस्वीरों में दिखाने की कोशिश करूंगा।



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

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

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

Mov ईंक्स , 66666667h ; जादू संख्या 2.5 से विभाजित करने के लिए
imul ecx ; EDX: EAX (EAX (edx में - 2.5 द्वारा विभाजन का परिणाम)
सर edx , 2 ; परिणाम 4 से विभाजित है। यह edx = ecx / 10 निकला है

एक और सफलता यह है कि Mov eax, 66666667 बिल्कुल पांच बाइट्स लेता है और इसे आसानी से jmp या कॉल द्वारा बदल दिया जाता है। मैं लूप में पाठ अनुभाग के चारों ओर जाता हूं, ऑपरेशन कोड (0xB8, 0x67, 0x66, 0x66, 0x66) को देखता हूं और उन्हें कॉल के साथ जाल में बदल देता हूं। चूंकि दस से विभाजित करना एक काफी लोकप्रिय ऑपरेशन है, जो सभी ऑपरेशनों को दर्शाता है जो जाल में आते हैं, बिल्कुल जानकारीपूर्ण नहीं है, और यह खेल की गति को नकारात्मक रूप से प्रभावित करता है। फ़िल्टर करना आवश्यक है ताकि ऑपरेंड में से एक चालू खाते के बराबर हो। और मुझे खाता कैसे पता चलेगा, अगर मैं इसे ढूंढ रहा हूं? कई नियमों को विकसित करना आवश्यक है जिसके द्वारा परीक्षण किया जाएगा ताकि आप यह अनुमान लगा सकें कि स्कोर एक निश्चित समय पर क्या होगा।
1) खेल शून्य के बराबर स्कोर के साथ शुरू होता है
2) प्रत्येक माउस क्लिक - शॉट
3) प्रत्येक शॉट प्रभावी है
4) प्रत्येक शॉट तीस अंक लाता है
5) दूसरे नियम का परिणाम: चूंकि आपको गेम से पहले माउस के कुछ क्लिक करने हैं, इसलिए इंटरसेप्शन प्रोग्राम द्वारा स्कोरिंग खेल शुरू होने के बाद से ही शुरू हो जानी चाहिए और गेंदों के सीक्वेंस एकत्र करना पहले से ही संभव है।
नियम तैयार होने के बाद, यह स्पष्ट हो जाता है कि आपको गेम की विंडो प्रक्रिया पर एक जाल लगाने की आवश्यकता है। तब यह माउस बटन पर सभी क्लिकों के बारे में जाना जाएगा, और कीबोर्ड पर बटन दबाकर गेम की शुरुआत का संकेत देना संभव होगा।
एक विंडो प्रक्रिया का पता लगाना मुश्किल नहीं है, इसके लिए आपको आईडीए में रजिस्टरक्लास फ़ंक्शन के तर्कों को देखने की आवश्यकता है। यहाँ विंडो प्रक्रिया हुक सभी आवश्यकताओं के साथ कैसा दिखेगा:

शून्य onMainProc ( संदर्भ * संदर्भ ) {
// बटन 0 संख्या पर स्थित है, जो राज्य में स्विच करता है: कोई स्कोर है या नहीं
अगर ( संदर्भ - > ESP [ 0x08 ] == WM_KEYUP ) और& ( संदर्भ - > ESP [ 0x0C ] == VK_NUMPAD0 ) ) {
अगर ( राज्य == kCounting ) {
राज्य = kNotCounting ;
} {
राज्य = kCounting ;
}
}
// यदि गिनती जारी है और बाईं माउस बटन दबाया जाता है, तो अपेक्षित गिनती बढ़ जाती है
अगर ( राज्य == kCounting ) && ( संदर्भ - > ESP [ 0x08 ] == WM_LBUTTONUP ) ) {
स्कोर + = 30 ;
}
}

// और विभाजन के लिए जाल इस तरह दिखेगा
शून्य onDivision ( संदर्भ * संदर्भ ) {
char buf [ 512 ] ;
अगर ( राज्य == kCounting ) {
// यदि संभावित लाभांश में से एक अपेक्षित खाते के बराबर है, तो वह पता जिस पर विभाजन होता है और रजिस्टर मान डिबग आउटपुट पर भेजे जाते हैं
अगर ( संदर्भ - > EBX == स्कोर ) || ( संदर्भ - > ECX == स्कोर ) || ( संदर्भ - > EDX == स्कोर ) } {
स्प्रिंटफ ( buf, "% x: EBX =% d, ECX =% d, EDX =% d" , संदर्भ - > ESP [ 0 ] , संदर्भ - > EBX, संदर्भ - > ECX, संदर्भ - > EDX ) ;
OutputDebugStringA ( buf ) ;
}
}
// इस कोड के बजाय, जेएमपी डाला गया था, इसलिए आपको इसे निष्पादित करने की आवश्यकता है
संदर्भ - > EAX = 0x66666667 ;
}

वीडियो दिखाता है कि मैं कैसे पता लगाने की कोशिश करता हूं (नियमों का एक दिलचस्प संशोधन निकला। "ज़ूमा का सस्ता")।



पता मिलने के बाद, मैं उस फ़ंक्शन का अध्ययन करता हूं, जिसका वह संबंध है।



वह भाग जहां विभाजन होता है, खिलाड़ी के अंकों की गणना करता है जो खिलाड़ी ने स्तर की शुरुआत से स्कोर किया था। सामान्य तौर पर, फ़ंक्शन स्पष्ट रूप से गेंदों के अनुक्रम को नष्ट करने के बाद स्कोर काउंटर को अपडेट करने के लिए जिम्मेदार होता है। इसके लिए दो तर्क दिए गए हैं। पहला तर्क कुछ संरचना का सूचक है (शायद काउंटर ही)। ऑफसेट में 0x18C बिंदुओं की वर्तमान संख्या है, और ऑफसेट 0x190 के स्तर की शुरुआत में अंकों की संख्या है। दूसरा तर्क वर्तमान स्कोर है। यह पता लगाने के लिए कि यह कहाँ से आता है, मैं ढेर पर जाता हूं। तुरंत मुझे पता चलता है कि चालू खाता कुछ संरचना से एक फ़ंक्शन में स्थानांतरित किया जाता है, जहां यह ऑफसेट 0x104 पर स्थित है। थोड़ा और अधिक मैं ऑपरेशन जोड़ने [esi + 0x104], एडी। जाहिर है, यह वही है जो मैं खोज रहा हूं, और यदि आप यहां एक जाल बिछाते हैं, तो संयोजन के लिए प्राप्त अंकों की संख्या पर आपका कुछ प्रभाव हो सकता है। जाल कोड अत्यंत सरल है। EDI रजिस्टर दस गुना बढ़ जाता है, जिससे हमें एक सफल संयोजन के लिए बढ़े हुए अंक मिलते हैं

शून्य onAddScore ( संदर्भ * संदर्भ ) {
संदर्भ - > ईडीआई = संदर्भ - > ईडीआई * 10 ;
}

सब कुछ पसंद है। यह पदों और घोड़े के चित्रण के बीच बड़े अंतराल के लिए माफी माँगने के लिए बनी हुई है (यदि कोई मुझे बताता है कि उन्हें बेहतर जगह कैसे दी जाए, तो बहुत बहुत धन्यवाद)।

ओह, और कोड , बिल्कुल। लेकिन यह एक बड़ा प्रशंसक है, परिचित और परिणामों के लिए, मैं जिम्मेदार नहीं हूं।