सरल DIY प्रॉक्सी dll

मुझे GDS32.DLL को कॉल करने के लिए इंटरसेप्ट करना पड़ा। मैंने एक प्रॉक्सी dll लिखने का फैसला किया।

हम एक रिसर्च स्टैंड लिखते हैं

पहली चीज जो हमें चाहिए वह है असली डीएल से सभी निर्यात किए गए कार्यों की एक सूची प्राप्त करना।
इसे निम्नलिखित कोड के साथ करते हैं:

1. program GetFuncsDll; 2. {$APPTYPE CONSOLE} 3. uses Windows; 4. var 5. ImageBase: DWORD; //  dll 6. pNtHeaders: PImageNtHeaders; // PE  dll 7. IED: PImageExportDirectory; //    8. ExportAddr: TImageDataDirectory; //   9. I: DWORD; //    10. NamesCursor: PDWORD; //      11. OrdinalCursor: PWORD; //      12. LIB_NAME:AnsiString; //  dll 13. BEGIN 14. LIB_NAME:='MiniLib.dll'; 15. loadlibraryA(PAnsiChar(LIB_NAME)); 16. ImageBase := GetModuleHandleA(PAnsiChar(LIB_NAME)); 17. pNtHeaders := Pointer(ImageBase + DWORD(PImageDosHeader(ImageBase)^._lfanew)); 18. ExportAddr := pNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]; 19. IED := PImageExportDirectory(ImageBase+ExportAddr.VirtualAddress); 20. NamesCursor := Pointer(ImageBase + DWORD(IED^.AddressOfNames)); 21. OrdinalCursor := Pointer(ImageBase + DWORD(IED^.AddressOfNameOrdinals)); 22. For I:=0 to Integer(IED^.NumberOfNames-1) do begin 23. WriteLn(output,PAnsiChar(ImageBase + PDWORD(NamesCursor)^),'=',OrdinalCursor^ + IED^.Base); 24. Inc(NamesCursor); 25. Inc(OrdinalCursor); 26. end; 27. Readln; 28. end.  1 

लगता है कोई मुश्किल नहीं है। हम क्रमिक रूप से नामों की एक सरणी (NamesCursor) और संख्याओं (OrdinalCursor) की एक सरणी के निर्यात तालिका (लाइन 19) को प्राप्त करते हैं और फ़ंक्शन, नामों और संख्याओं द्वारा फ़ंक्शन को पढ़ते हैं। फ़ंक्शन की संख्या NumberOfNames फ़ील्ड में है। यह कोड इंटरनेट पर प्राप्त किया गया था, फिर अंतिम रूप दिया गया और सरल किया गया।

हमारे परीक्षण dll पर विचार करें।

 1. Library MiniLib; 2. function myAdd(a,b:integer): integer; stdcall; 3. begin 4. result:=a+b; 5. end; 6. function mySub(a,b:integer): integer; stdcall; 7. begin 8. result:=ab; 9. end; 10. exports 11. myAdd, 12. mySub; 13. begin 14. end.  2 

लगता है कोई मुश्किल भी नहीं है। हम दो कार्यों का निर्यात करते हैं - जोड़ और घटाव।
निर्यात किए गए कार्यों और संख्याओं की सूची निम्नानुसार होगी:

myAdd = 2
mySub = 1
लिस्टिंग 3

इन नंबरों को कंपाइलर द्वारा सौंपा गया है। वास्तव में ये क्यों? मुझे नहीं पता है कि
अब इसके अलावा फंक्शन पर ध्यान दें। आइए देखें कि इसके कॉल को किस कोड में संकलित किया गया था, इसके लिए हम इसे कॉल करेंगे और डीबगर में देखेंगे।

 1. program TestCall; 2. {$APPTYPE CONSOLE} 3. uses Windows; 4. var 5. myAdd: function (a,b:integer): integer; stdcall; 6. Handle:HMODULE; 7. N:Integer; 8. begin 9. Handle := loadlibrary('MiniLib.dll'); 10. @myAdd := GetProcAddress(Handle, 'myAdd'); 11. //      12. //@myAdd := GetProcAddress(Handle, PChar(2)); 13. N:=myAdd(1,2); 14. writeLn(N); 15. readln; 16. end.  4 

यहां सब कुछ सरल है। हम फ़ंक्शन का पता प्राप्त करते हैं और इसे कॉल करते हैं। मैं केवल यह बताऊंगा कि दूसरे पैरामीटर में GetProcAddress फ़ंक्शन नाम के लिए एक संकेतक है, लेकिन यह है कि यह $ FFFF से अधिक है, अगर यह इससे कम या बराबर है, तो इसे निर्यात तालिका में फ़ंक्शन की संख्या के रूप में व्याख्या की जाती है। यही है, हम एक फ़ंक्शन को संख्या या नाम से बुला सकते हैं।

अब देखते हैं कि जोड़ का परिणाम एक चर में कैसे दर्ज किया जाता है, अर्थात् लाइन 13 का संचालन।

1. TestCall.dpr.13: N: = myAdd (1,2);
2. $ 02 धक्का
3. $ 01 धक्का
4. कॉल ड्राफ्ट ptr [$ 0040cba4]
5. मूव [$ 0040cbac], ईएक्सएक्स
लिस्टिंग 5

और यहां सब कुछ सरल है, हम स्टैक पर डालते हैं, एक ड्यूस (2) और एक यूनिट (3), हम अपने फ़ंक्शन (4) को कॉल करते हैं, इसके अतिरिक्त परिणाम को कंपाइलर द्वारा रजिस्टर ईएक्सएक्स में डाल दिया जाता है, और फिर रजिस्टर से हम परिणाम को एन (5) में कॉपी करते हैं।

इससे पहले कि आप Dll से एक सामान्य फ़ंक्शन कॉल करें। तर्क को स्टैक पर धकेल दिया जाता है, एक कॉल किया जाता है, और परिणाम रजिस्टरों (या स्टैक) से पढ़े जाते हैं।

विचार

मेरा विचार यह है कि जब वास्तविक के बजाय मेरा नकली dll निहित होता है, तो यह पहले फ़ंक्शन के इनपुट और फ़ंक्शन के नाम को स्वीकार करता है, फिर इसे वास्तविक फ़ंक्शन कहता है और जैसे कि कुछ भी नहीं था।

हम नकली Dll लिखते हैं।

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

1. pushfd // प्रत्येक फ़ंक्शन के लिए समान
2. pushad // प्रत्येक फ़ंक्शन के लिए समान
3. प्रत्येक फ़ंक्शन में परिवर्तन के लिए 2 // संख्या धक्का
4. प्रत्येक फ़ंक्शन के लिए ProxyProc // को कॉल करें
लिस्टिंग 6

हमें विचार का एहसास है

और यहाँ कोड है।

 1. Library minilib2; 2. 3. Uses Windows; 4. 5. Procedure ProxyProc; assembler; 6. asm 7. end; 8. 9. Procedure FakeProc0001; assembler; 10. asm 11. pushfd 12. pushad 13. push 000000001 14. call ProxyProc 15. end; 16. 17. Procedure FakeProc0002; assembler; 18. asm 19. pushfd 20. pushad 21. push 000000002 22. call ProxyProc 23. end; 24. 25. Exports 26. FakeProc0001 index 1 name 'mySub', 27. FakeProc0002 index 2 name 'myAdd'; 28. Begin 29. End.  7 

यहां सब कुछ सरल है। हम दो नकली प्रक्रियाओं का निर्यात करते हैं, और उन्हें असली dll के समान नाम और संख्या देते हैं।
पेचीदा हिस्सा ही प्रॉक्सी प्रक्रिया है। इसमें क्या होना चाहिए।

1. फ़ंक्शन संख्या और इनपुट मापदंडों के साथ कुछ उपयोगी संचालन करें
2. इस फ़ंक्शन का पता खोजें
3. सभी रजिस्टरों को उनकी मूल स्थिति में लौटाएं
4. इस प्रक्रिया के पते पर नियंत्रण स्थानांतरित करें, जैसे कि कुछ भी नहीं था।

तदनुसार, इसका कोड निम्नानुसार हो सकता है।

 1. const LibName:pAnsiChar = 'MiniLib_.DLL'#0; 2. Procedure DeveloperProc; 3. //   4. begin 5. end; 6. Procedure ProxyProc; assembler; 7. asm 8. call DeveloperProc; //  ,      //  ,     9. add esp,4 //       10. push LibName //     dll 11. call LoadLibraryA //  dll  ,   12. push eax //      13. call GetProcAddress //      .    14. mov [esp-4], eax //     , //         15. popad //   16. popfd //   17. jmp [esp-40] //    , //        //     18. end;  8 

अब जब हम इस कोड को संकलित करते हैं, तो हमें 'minilib2.dll' मिलता है। इसे "minilib.dll" में बदलें और इसे बदलें, और "minilib.dll" को "minilib_.dll" के अनुसार नाम बदलें।

अब देखते हैं कि यह कैसे काम करता है

TestCall.dpr.13: N: = myAdd (1,2);
1. $ 02 धक्का
2. $ 01 धक्का
3. कॉल ड्राफ्ट ptr [$ 0040cba4] // myAdd को कॉल करें, लेकिन नकली में जाएं
4. मूव [$ 0040cbac], ईएक्सएक्स
लिस्टिंग 9
लिस्ट 9 पहले से देखे गए कोड का हिस्सा है जो डीएल से फ़ंक्शन को कॉल करता है और स्टैक की स्थिति के नीचे तालिका में दर्ज करता है और फर्जी प्रक्रिया में आने के बाद रजिस्टर करता है, अर्थात लाइन 3 पर कॉल दर्ज करने के बाद।

EAX 00364434 EBX 7FFDA000 ECX 00000000 EDX 00000003 ईएसआई 16 ए 1 एफ 224 ईडीआई 13D84260 ईबीपी 0012FFC0 ईएसपी 0012FFA4 EIP 00364434 ईएफएल 00000246 लिस्टिंग 10

0012FFAC 00000002 // दूसरा तर्क 0012FFA8 00000001 // पहला तर्क -> 0012FFA4 0040811A // निष्पादन योग्य पर वापसी पता लिस्टिंग 11

इसके बाद, हम बाईं ओर अपनी फोर-लाइन फर्जी प्रक्रिया का कोड देखते हैं और समीपस्थ अवस्था में दाईं ओर स्थित होता है, जो कि लाइन 4 पर कॉल दर्ज करने के बाद,

minilib2.myAdd: // वह fakeProc0002 है 1. पुष्पक 2. पुषद 3. $ 02 धक्का 4. कॉल $ 00364408 // कॉल प्रॉक्सीप्रोक लिस्टिंग 12

0012FFAC 00000002 // दूसरा तर्क 0012FFA8 00000001 // पहला तर्क 0012FFA4 0040811A // निष्पादन योग्य पर वापसी पता 0012FFAO 00000346 // ध्वज रजिस्टर 0012FF9C 00364434 // रजिस्टर EAX 0012FF98 00000000 // ECX रजिस्टर 0012FF94 00000003 // रजिस्टर EDX 0012FF90 7FFDA000 // EBX रजिस्टर 0012FF8C 0012FFAO // ईएसपी रजिस्टर 0012FF88 0012FFC0 // EBP रजिस्टर 0012FF84 16A1F224 // ईएसआई रजिस्टर 0012FF80 13D84260 // रजिस्टर ईडीआई 0012FF7C 00000002 // फ़ंक्शन संख्या (02) -> 0012FF78 0036443D // फ़र्ज़ी पते पर वापस जाएंप्रोक्रेसी 2000 फर्जी प्रक्रिया लिस्टिंग 13

अगला, हम पंक्ति 6 ​​के बाद सही प्रक्रिया का पता प्राप्त करने के बाद बाईं ओर दाईं ओर प्रॉक्सी प्रक्रिया कोड देखते हैं। हम देखते हैं कि नकली पते पर वापस जाने के लिए फर्जी प्रोक्रेसी 22 नकली प्रक्रिया को स्टैक से हटा दिया गया था और फ़ंक्शन संख्या को स्टैक से हटा दिया गया था, लेकिन वास्तविक फ़ंक्शन का पता स्टैक पर दिखाई दिया।

minilib2.ProxyProc: 1. esp जोड़ें, $ 04 2. धक्का ड्राफ्ट ptr [$ 0036782c] 3. $ 00364394 पर कॉल करें। यह LoadLibrary है 4. पुश ईएक्स 5. $ 00364384 पर कॉल करें। यह GetProcAdress है 6. चल [esp- $ 04], eax 7. पोपड 8. खसखस 9. जेएमपी ड्राफ्ट ptr [esp- $ 28] लिस्टिंग 14

0012FFAC 00000002 // दूसरा तर्क 0012FFA8 00000001 // पहला तर्क 0012FFA4 0040811A // निष्पादन योग्य पर वापसी पता 0012FFAO 00000346 // ध्वज रजिस्टर 0012FF9C 00364434 // रजिस्टर EAX 0012FF98 00000000 // ECX रजिस्टर 0012FF94 00000003 // रजिस्टर EDX 0012FF90 7FFDA000 // EBX रजिस्टर 0012FF8C 0012FFAO // ईएसपी रजिस्टर 0012FF88 0012FFC0 // EBP रजिस्टर 0012FF84 16A1F224 // ईएसआई रजिस्टर -> 0012FF80 13D84260 // रजिस्टर ईडीआई 0012FF7C 0037437C // इस dll में इस प्रक्रिया का पता लिस्टिंग 15

अगला, हम बाईं ओर तालिका में रजिस्टरों की स्थिति और स्टैक की स्थिति को सही प्रक्रिया पर जेएमपी से पहले देखते हैं, अर्थात्, लिस्टिंग 14 की लाइन 9 को निष्पादित करने से पहले। जैसा कि आप देख सकते हैं, स्टैक और रजिस्टरों की स्थिति फर्जी प्रक्रिया में प्रवेश करने के तुरंत बाद राज्य के समान होती है (लिस्टिंग 10 और 11 की सूची), और। हमें उम्मीद है कि सही DLL प्रक्रिया में अंतर महसूस नहीं होता है। (हेक्साडेसिमल में 28 दशमलव में 40 है, अर्थात्, 10 गुना 4 बाइट्स प्रत्येक स्टैक पर ठीक उसी जगह है जहां हमारे पास सही प्रक्रिया (लिस्टिंग 17) का पता है)।

EAX 00364434 EBX 7FFDA000 ECX 00000000 EDX 00000003 ईएसआई 16 ए 1 एफ 224 ईडीआई 13D84260 ईबीपी 0012FFC0 ईएसपी 0012FFA4 ईआईपी 00364422 ईएफएल 00000246 लिस्टिंग 16

0012FFAC 00000002 // दूसरा तर्क 0012FFA8 00000001 // पहला तर्क -> 0012FFA4 0040811A // निष्पादन योग्य पर वापसी पता 1. 0012FFAO 00000346 // झंडा रजिस्टर 2. 0012FF9C 00364434 // रजिस्टर EAX 3. 0012FF98 00000000 // ECX रजिस्टर 4.0012FF94 00000003 // रजिस्टर EDX 5.0012FF90 7FFDA000 // EBX रजिस्टर 6. 0012FF8C 0012FFAO // ईएसपी रजिस्टर 7.0012FF88 0012FFC0 // EBP रजिस्टर 8. 0012FF84 16A1F224 // ईएसआई रजिस्टर 9.0012FF80 13D84260 // रजिस्टर ईडीआई 10. 0012FF7C 0037437C // इस dll में इस प्रक्रिया का पता लिस्टिंग 17

और अंत में, डेवलपर की प्रक्रिया।

इस प्रक्रिया में, कोडांतरक में लिखना आवश्यक नहीं है। यहां हम वास्तव में अवरोधकों और स्टैक की सामग्री को नुकसान पहुंचाए बिना, अवरोधन कर सकते हैं।

उदाहरण के लिए, फ़ाइल में आउटपुट के लिए एक सरल कोड जिसे सभी प्रकार के फ़ंक्शन कहा जाता है, हो सकता है।

 1. Procedure DeveloperProc; 2. var 3. F:text; 4. _ebp:PAnsiChar; //   5.begin 6. asm 7. mov _ebp,ebp; 8. end; 9. assignfile(F,'G:\Projects\dllproxy\logdll.txt'); 10. append(F); 11. writeln(F,DateTimeToStr(now),': ',PDWORD(_ebp+3*4)^); 12. closefile(F); 13.end;  18 

लाइन 7 पर, बेस पॉइंटर को _ebp वैरिएबल में दर्ज किया गया था
9 लाइन पर, फ़ाइल के साथ चर एफ को संबद्ध करें
ऑन लाइन 10 ने जोड़ने के लिए फाइल खोली
लाइन 11 पर वर्तमान तिथि और समय, और तथाकथित फ़ंक्शन की संख्या दर्ज की गई
हमें आधार पॉइंटर में तीन बार 4 बाइट्स जोड़ना चाहिए, क्योंकि फ़ंक्शन संख्या के बाद स्टैक में तीन पॉइंटर्स हैं: 1. नकली प्रक्रिया पर वापस जाने के लिए सूचक, 2. प्रॉक्सी प्रक्रिया पर लौटने के लिए सूचक, और 3. कंपाइलर द्वारा रखे गए स्टैक को इंगित करें। धक्का देना)। सूचक प्रकार PAnsiChar को चुना गया क्योंकि यह संख्याओं के साथ जोड़ और घटाव के संचालन की अनुमति देता है।
लाइन 12 ने फाइल बंद कर दी।

यहाँ उदाहरण डाउनलोड करें ।

PS प्रॉक्सी- GDS32। सभी को सफलतापूर्वक संकलित किया गया था, इसका उपयोग करने वाले प्रोग्राम ने ऑपरेशन में कोई त्रुटि उत्पन्न नहीं की, सभी कॉल को एक लॉग फ़ाइल में इंटरसेप्ट किया गया था, असफल SQL प्रश्नों को पकड़ा और अनुकूलित किया गया था।
PPS इस लेख का लेखक इस लेख में जानकारी और सामग्री के उपयोग के लिए ज़िम्मेदार नहीं है। सभी जानकारी केवल शैक्षिक उद्देश्यों के लिए है।