हॉटपैच के लिए तैयार किए गए इंटरसेप्टिंग फ़ंक्शंस के दौरान उचित स्प्लिसिंग

पिछले लेख में, मैंने उनके विविधताओं सहित अवरोधन कार्यों के लिए पाँच विकल्पों की जाँच की।

सच है, इसमें मैंने उन दो अप्रिय स्थितियों को छोड़ दिया है जिन पर विचार नहीं किया गया है:
1. जब जाल हटा दिया जाता है उस समय इंटरसेप्टेड फ़ंक्शन को कॉल करें।
2. दो अलग-अलग थ्रेड्स से इंटरसेप्टेड फ़ंक्शन का एक साथ कॉल।

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

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

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

JMP NEAR OFFSET या PUSH ADDR + RET के माध्यम से विभाजन (इन त्रुटियों के लिए सबसे कमजोर) पर विचार नहीं किया जाएगा, क्योंकि एक अच्छी तरह से, एक लंबाई disassembler को लागू किए बिना, यह इस विकल्प को प्राप्त करने के लिए काम करने के लिए काम नहीं करेगा जैसा कि इसे करना चाहिए।

1. हम CreateWindowExW को कॉल इंटरसेप्ट करते हुए एप्लिकेशन को कार्यान्वित करते हैं

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

एक नया प्रोजेक्ट बनाएं और मुख्य रूप से तीन तत्वों को रखें: टीमेमो, टूपेनडियलॉग और टीबूटन।

आवेदन का सार: जब बटन पर क्लिक किया जाता है, तो एक अवरोधन CreateWindowExW फ़ंक्शन पर सेट किया जाएगा और एक संवाद प्रदर्शित किया जाएगा। संवाद बंद करने के बाद, TMemo संवाद द्वारा बनाई गई सभी खिड़कियों के बारे में जानकारी प्रदर्शित करेगा।

ऐसा करने के लिए, हमें पिछले लेख से कोड के एक भाग की आवश्यकता है, अर्थात्:

1. अवरोधन के लिए प्रकार और स्थिरांक की घोषणा:

const LOCK_JMP_OPKODE: Word = $F9EB; JMP_OPKODE: Word = $E9; type //      JMP NEAR OFFSET TNearJmpSpliceRec = packed record JmpOpcode: Byte; Offset: DWORD; end; THotPachSpliceData = packed record FuncAddr: FARPROC; SpliceRec: TNearJmpSpliceRec; LockJmp: Word; end; const NearJmpSpliceRecSize = SizeOf(TNearJmpSpliceRec); LockJmpOpcodeSize = SizeOf(Word); 

2. NEAR JMP और परमाणु रिकॉर्डिंग SHMP JMP को रिकॉर्ड करने की प्रक्रिया

 //         procedure SpliceNearJmp(FuncAddr: Pointer; NewData: TNearJmpSpliceRec); var OldProtect: DWORD; begin VirtualProtect(FuncAddr, NearJmpSpliceRecSize, PAGE_EXECUTE_READWRITE, OldProtect); try Move(NewData, FuncAddr^, NearJmpSpliceRecSize); finally VirtualProtect(FuncAddr, NearJmpSpliceRecSize, OldProtect, OldProtect); end; end; //         procedure SpliceLockJmp(FuncAddr: Pointer; NewData: Word); var OldProtect: DWORD; begin VirtualProtect(FuncAddr, LockJmpOpcodeSize, PAGE_EXECUTE_READWRITE, OldProtect); try asm mov ax, NewData mov ecx, FuncAddr lock xchg word ptr [ecx], ax end; finally VirtualProtect(FuncAddr, LockJmpOpcodeSize, OldProtect, OldProtect); end; end; 

3. थोथापास्कप्लिसडाटा संरचना का थोड़ा संशोधित प्रारंभ

 //       procedure InitHotPatchSpliceRec(const LibraryName, FunctionName: string; InterceptHandler: Pointer; out HotPathSpliceRec: THotPachSpliceData); begin //      HotPathSpliceRec.FuncAddr := GetProcAddress(GetModuleHandle(PChar(LibraryName)), PChar(FunctionName)); //      ,     Move(HotPathSpliceRec.FuncAddr^, HotPathSpliceRec.LockJmp, LockJmpOpcodeSize); //   JMP NEAR HotPathSpliceRec.SpliceRec.JmpOpcode := JMP_OPKODE; //    (  NearJmpSpliceRecSize  , // ..     ) HotPathSpliceRec.SpliceRec.Offset := PAnsiChar(InterceptHandler) - PAnsiChar(HotPathSpliceRec.FuncAddr); end; 

यह सब कोड एक अलग SpliceHelper मॉड्यूल में रखा जाएगा, हमें निम्नलिखित अध्यायों में इसकी आवश्यकता होगी।

अब मुख्य रूप से आगे बढ़ते हैं, हमें दो वैश्विक चर चाहिए:

 var HotPathSpliceRec: THotPachSpliceData; WindowList: TStringList; 

HotPathSpliceRec वैरिएबल में इंटरसेप्टर के बारे में जानकारी होगी। दूसरे में बनाई गई खिड़कियों की एक सूची होगी।

प्रपत्र निर्माता में, THotPachSpliceData संरचना को प्रारंभ करें।

 procedure TForm1.FormCreate(Sender: TObject); begin //     InitHotPatchSpliceRec(user32, 'CreateWindowExW', @InterceptedCreateWindowExW, HotPathSpliceRec); //     NOP- SpliceNearJmp(PAnsiChar(HotPathSpliceRec.FuncAddr) - NearJmpSpliceRecSize, HotPathSpliceRec.SpliceRec); end; 

मूल फ़ंक्शन के बजाय इंटरसेप्टर फ़ंक्शन बनाएं।

 function InterceptedCreateWindowExW(dwExStyle: DWORD; lpClassName: PWideChar; lpWindowName: PWideChar; dwStyle: DWORD; X, Y, nWidth, nHeight: Integer; hWndParent: HWND; hMenu: HMENU; hInstance: HINST; lpParam: Pointer): HWND; stdcall; var S: string; Index: Integer; begin //   SpliceLockJmp(HotPathSpliceRec.FuncAddr, HotPathSpliceRec.LockJmp); try //      Index := -1; if not IsBadReadPtr(lpClassName, 1) then begin S := 'ClassName: ' + string(lpClassName); S := IntToStr(WindowList.Count + 1) + ': ' + S; Index := WindowList.Add(S); end; //    Result := CreateWindowExW(dwExStyle, lpClassName, lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); //       if Index >= 0 then begin S := S + ', handle: ' + IntToStr(Result); WindowList[Index] := S; end; finally //   SpliceLockJmp(HotPathSpliceRec.FuncAddr, LOCK_JMP_OPKODE); end; end; 

और यह बटन हैंडलर को लागू करने के लिए अंत में रहता है।

 procedure TForm1.Button1Click(Sender: TObject); begin //  CreateWindowExW SpliceLockJmp(HotPathSpliceRec.FuncAddr, LOCK_JMP_OPKODE); try //           WindowList := TStringList.Create; try //   OpenDialog1.Execute; //      Memo1.Lines.Text := WindowList.Text; finally WindowList.Free; end; finally //   SpliceLockJmp(HotPathSpliceRec.FuncAddr, HotPathSpliceRec.LockJmp); end; end; 

सब कुछ तैयार है, आप निष्पादन के लिए कार्यक्रम चला सकते हैं।

मैं इस अध्याय में लागू किए गए कोड के बारे में विस्तार से बात नहीं करूंगा, यह पिछले लेख में अधिक विस्तार से वर्णित है, दूसरी बार पेंट करने का कोई मतलब नहीं है।

प्रोग्राम चलाएं, बटन पर क्लिक करें और "रद्द करें" बटन पर क्लिक करके संवाद बंद करें, इसे इस तरह से बाहर निकलना चाहिए:



इस प्रकार, हमने पाया कि जब आप सामान्य रूप से TOpenDialog खोलते हैं, तो विभिन्न वर्गों की 14 खिड़कियां बनाई जाती हैं।

अब पता करते हैं कि क्या यह वास्तव में ऐसा है।

2. एप्लिकेशन विंडो के पेड़ को देखने के लिए एक सहायक उपयोगिता बनाएं।

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

आप निश्चित रूप से, स्पाई ++ जैसे तीसरे पक्ष के कार्यक्रमों का उपयोग कर सकते हैं, लेकिन हम प्रोग्रामर हैं, इसलिए हमें इसे स्वयं लागू करना चाहिए, खासकर जब से इसे लागू करने का समय सस्ता है।

एक नया प्रोजेक्ट बनाएं और TTreeView को मुख्य रूप में रखें और फिर निम्नलिखित कोड लागू करें:

 type TdlgWindowTree = class(TForm) WindowTreeView: TTreeView; procedure FormCreate(Sender: TObject); private procedure Sys_Windows_Tree(Node: TTreeNode; AHandle: HWND; ALevel: Integer); end; ... procedure TdlgWindowTree.FormCreate(Sender: TObject); begin Sys_Windows_Tree(nil, GetDesktopWindow, 0); end; procedure TdlgWindowTree.Sys_Windows_Tree(Node: TTreeNode; AHandle: HWND; ALevel: Integer); type TRootNodeData = record Node: TTreeNode; PID: Cardinal; end; var szClassName, szCaption, szLayoutName: array[0..MAXCHAR - 1] of Char; szFileName : array[0..MAX_PATH - 1] of Char; Result: String; PID, TID: Cardinal; I: Integer; RootItems: array of TRootNodeData; IsNew: Boolean; begin //      while AHandle <> 0 do begin //    GetClassName(AHandle, szClassName, MAXCHAR); //  ( Caption)  GetWindowText(AHandle, szCaption, MAXCHAR); //    if GetWindowModuleFilename(AHandle, szFileName, SizeOf(szFileName)) = 0 then FillChar(szFileName, 256, #0); TID := GetWindowThreadProcessId(AHandle, PID); //   AttachThreadInput(GetCurrentThreadId, TID, True); VerLanguageName(GetKeyboardLayout(TID) and $FFFF, szLayoutName, MAXCHAR); AttachThreadInput(GetCurrentThreadId, TID, False); //  Result := Format('%s [%s] Caption = %s, Handle = %d, Layout = %s', [String(szClassName), String(szFileName), String(szCaption), AHandle, String(szLayoutName)]); //       if ALevel in [0..1] then begin IsNew := True; for I := 0 to Length(RootItems) - 1 do if RootItems[I].PID = PID then begin Node := RootItems[I].Node; IsNew := False; Break; end; if IsNew then begin SetLength(RootItems, Length(RootItems) + 1); RootItems[Length(RootItems) - 1].PID := PID; RootItems[Length(RootItems) - 1].Node := WindowTreeView.Items.AddChild(nil, 'PID: ' + IntToStr(PID)); Node := RootItems[Length(RootItems) - 1].Node; end; end; //   Sys_Windows_Tree(WindowTreeView.Items.AddChild(Node, Result), GetWindow(AHandle, GW_CHILD), ALevel + 1); //   ( )  AHandle := GetNextWindow(AHandle, GW_HWNDNEXT); end; end; 

दरअसल, सब कुछ निष्पादन के लिए चलाया जा सकता है:

3. परिणामों का विश्लेषण करें

अब दोनों कार्यक्रमों के परिणामों की तुलना करें। हम इसे निम्नानुसार करते हैं।
1. इंटरसेप्टर के साथ प्रोग्राम चलाएं और उस बटन पर क्लिक करें जो संवाद प्रदर्शित करता है।
2. दूसरे अध्याय से उपयोगिता को चलाएं
3. इंटरसेप्टेड विंडो के बारे में परिणाम प्राप्त करने के लिए पहले प्रोग्राम के संवाद को बंद करें।

हम देखते हैं:



ऑटो-सुझाव ड्रॉपडाउन वर्ग के साथ विंडो को लाल रंग में हाइलाइट किया गया है, आइए देखें कि यह क्या है:



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

लेकिन, यह तथ्य कि हम उन्हें पहली सूची में नहीं देखते हैं, इसका कोई मतलब नहीं है। इन विंडो को उस समय बनाया गया था जब हमारे इंटरसेप्टर को हटा दिया गया था, और यह केवल एक कारण से हो सकता है - क्योंकि CreateWindowExW पर कॉल करने से खुद को पुनरावर्ती कॉल हो सकती है।

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

4. अवरोधन कोड को हटाए बिना इंटरसेप्टेड फ़ंक्शन को कॉल करना।

आइए इस तस्वीर को पिछले लेख से देखें।



यह MessageBoxW फ़ंक्शन की शुरुआत है। बहुत पहले निर्देश पांच एनओपी निर्देशों से पहले किए गए एमओवी ईडीआई, ईडीआई, कुछ भी नहीं है।

यह वही है जो HotPatch द्वारा अवरोधन के लिए तैयार किए गए कार्य सबसे अधिक भाग के लिए दिखते हैं, जिसमें CreateWindowExW शामिल है।

यदि फ़ंक्शन को रोक दिया जाता है, तो निम्न कोड कुछ भी न करने वाले निर्देशों के कब्जे वाले सात बाइट्स के बजाय स्थित होगा:



दरअसल, यह इंटरसेप्टर है जिसे हमने स्थापित किया है।
MOV EDI, EDI निर्देश के बजाय, JMP -7 कोड रखा गया है, जो पिछले निर्देश पर नियंत्रण स्थानांतरित करता है।
पांच एनओपी निर्देशों के बजाय, इंटरसेप्टर फ़ंक्शन की शुरुआत के लिए एक कूद है।

यदि हम CreateWindowExW फ़ंक्शन की शुरुआत के पते से नहीं, बल्कि इसके पहले उपयोगी PUSH EBP निर्देश के पते से निष्पादन शुरू करते हैं, तो हम हमारे द्वारा स्थापित इंटरसेप्टर को प्रभावित नहीं करेंगे, और यदि ऐसा है, तो इसे हटाने का कोई मतलब नहीं है।

कोड रूप में, यह इस तरह दिखता है:

 type TCreateWindowExW = function(dwExStyle: DWORD; lpClassName: PWideChar; lpWindowName: PWideChar; dwStyle: DWORD; X, Y, nWidth, nHeight: Integer; hWndParent: HWND; AMenu: HMENU; hInstance: HINST; lpParam: Pointer): HWND; stdcall; function InterceptedCreateWindowExW(dwExStyle: DWORD; lpClassName: PWideChar; lpWindowName: PWideChar; dwStyle: DWORD; X, Y, nWidth, nHeight: Integer; hWndParent: HWND; hMenu: HMENU; hInstance: HINST; lpParam: Pointer): HWND; stdcall; var S: string; Index: Integer; ACreateWindowExW: TCreateWindowExW; begin //      Index := -1; if not IsBadReadPtr(lpClassName, 1) then begin S := 'ClassName: ' + string(lpClassName); S := IntToStr(WindowList.Count + 1) + ': ' + S; Index := WindowList.Add(S); end; //    @ACreateWindowExW := PAnsiChar(HotPathSpliceRec.FuncAddr) + LockJmpOpcodeSize; Result := ACreateWindowExW(dwExStyle, lpClassName, lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); //       if Index >= 0 then begin S := S + ', handle: ' + IntToStr(Result); WindowList[Index] := S; end; end; 

दो बाइट्स द्वारा फ़ंक्शन की शुरुआत से ऑफसेट के बराबर पहले उपयोगी निर्देश के पते की गणना करने के बाद, हम इसे अस्थायी चर ACreateWindowExW में संग्रहीत करते हैं, जिसके बाद हम फ़ंक्शन को सामान्य तरीके से कहते हैं।

आइए देखें कि इस मामले में क्या होता है, यह वही है जो हम उम्मीद करते हैं:



और यह वही है जो हमें दी गई सूची में मिलता है:



ठीक है, हमने अपने "नुकसान" को पाया, सभी 26 खिड़कियां बनाई जाती हैं जब TOpenDialog कहा जाता है, और 14 नहीं।

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

5. विभिन्न थ्रेड्स से हुक किए गए फ़ंक्शन को कॉल करते समय एक त्रुटि हुई।

इस त्रुटि के साथ, वही सरल है। यदि आप लगातार फ़ंक्शन इंटरसेप्टर को हटाते हैं और पुनर्स्थापित करते हैं, तो कुछ बिंदु पर हमें "लॉक xchg शब्द ptr [ecx], कुल्हाड़ी" निर्देश पर SpliceLockJmp फ़ंक्शन में एक त्रुटि मिलेगी। तथ्य यह है कि इस समय पृष्ठ की विशेषताओं को दूसरे थ्रेड से इंटरसेप्टर के पते पर वापस करने का कार्य पूरा किया जा सकता है और इस तथ्य के बावजूद कि हमारे थ्रेड में हमने इस पते पर लिखने की अनुमति दी है, वास्तविक पृष्ठ विशेषताएँ पूरी तरह से अलग होंगी।

यह ठीक वही व्यवहार है जिसका सामना इस शाखा के लेखक ने किया था: इंटरसेप्टिंग रिकव ।

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

6. क्या यह संभव है कि फ़ंक्शन के पहले दो बाइट्स को इंटरसेप्ट किया जाए?

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

यदि आप MessageBoxW या CreateWindowExW कोड को देखते हैं, तो आप देख सकते हैं कि उनका पहला उपयोगी PUSH EBP निर्देश एक बाइट लेता है। इस प्रकार, चूंकि यह शर्तों को पूरा नहीं करता है, इसलिए इस फ़ंक्शन का शरीर खाली कॉल MOV EDI, EDI से पहले है। लंबाई में तीन या अधिक बाइट्स के निर्देशों के साथ शुरू होने वाले कार्यों के लिए भी यही सच होगा। हालांकि, यदि फ़ंक्शन दो-बाइट अनुदेश के साथ शुरू होता है, तो यह खाली स्टब के साथ अपने शरीर को फुलाए जाने का कोई मतलब नहीं है, क्योंकि हॉटपैच के लिए सभी शर्तें पूरी होती हैं (पांच एनओपी और 2 बाइट्स)।

इस मामले में, यदि हम ऊपर वर्णित विधि को लागू करते हैं, तो हम एक त्रुटि के अलावा कुछ भी नहीं देख पाएंगे।

इस तरह के एक समारोह का एक उदाहरण RtlCreateUnicodeString है।
यह सहायक PUSH $ 0C अनुदेश के साथ शुरू होता है।



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

इसलिए, हमें कार्य का सामना करना पड़ा - एक जाम किए गए निर्देश पर कॉल प्रदान करने और अवरोधन कोड के साथ भी फ़ंक्शन की कार्यक्षमता सुनिश्चित करने के लिए:



सिद्धांत रूप में, हमारे पास जाम किए गए निर्देश के लिए मशीन कोड है और इसे HotPathSpliceRec.LockJmp संरचना में संग्रहीत किया गया है, लेकिन हम इसे सीधे कई कारणों से नहीं कह सकते।

खैर, सबसे पहले, यह संरचना ढेर पर स्थित है (ठीक है, अधिक सटीक रूप से, ढेर पर नहीं, बल्कि आवंटित स्मृति में, क्योंकि डेल्फी सीधे हीप तंत्र के साथ काम नहीं करता है) जिसमें कोई निष्पादन गुण नहीं हैं, अर्थात्। अगर हम किसी तरह से CAL को एड्रेसपाटपाइसiceRec.LockJmp पर निष्पादित करते हैं तो हमें एक त्रुटि मिलेगी।

आप निश्चित रूप से सही पृष्ठ विशेषताएँ सेट कर सकते हैं, लेकिन यह बहुत ही भद्दा है, फिर भी निष्पादन योग्य कोड को डेटा क्षेत्र के साथ नहीं मिलाया जाना चाहिए।

दूसरे, भले ही हम इस निर्देश को क्रियान्वित करते हैं, हमें JMP निर्देश को इसके बाद सही पते पर भेजने के लिए मजबूर करना चाहिए (इस मामले में यह $ 77B062FB होगा, पिछली तस्वीर देखें), जो कि बुलाए गए अनुदेश की भरपाई करता है।

तीसरा, कॉल के अतिरिक्त, हमें स्टैक पर सही क्रम में जगह देनी चाहिए, जिसे पैरामीटर फंक्शन कहा जाता है, जो कम से कम हमें एसम आवेषण का उपयोग करने की आवश्यकता की ओर ले जाएगा।

चलो सब कुछ क्रम में हल करने की कोशिश करते हैं।

ASM इंसर्ट से गुजरने वाले मापदंडों में शामिल नहीं होने के लिए, हम इस कार्य को कंपाइलर को सौंपकर कुछ प्रकार के स्प्रिंगबोर्ड फ़ंक्शन को लागू कर सकते हैं।

यानी मोटे तौर पर इस तरह एक इंटरसेप्टर लिखें:

 function TrampolineRtlCreateUnicodeString(DestinationString: PUNICODE_STRING; SourceString: PWideChar): Integer; stdcall; begin asm db $90, $90, $90, $90, $90, $90, $90 end; end; function InterceptedRtlCreateUnicodeString(DestinationString: PUNICODE_STRING; SourceString: PWideChar): Integer; stdcall; begin Result := TrampolineRtlCreateUnicodeString(DestinationString, SourceString); ShowMessage(DestinationString^.Buffer); end; 

इस मामले में, इंटरसेप्टर एक स्प्रिंगबोर्ड कॉल और लॉगिंग से निपटेगा।

स्प्रिंगबोर्ड फ़ंक्शन के अंदर, 7 बाइट्स आरक्षित हैं, जो हमारे लिए केवल दो-बाइट जाम अनुदेश और पांच-बाइट NEAR JMP लिखने के लिए पर्याप्त है।
फ़ंक्शन स्वयं कोड क्षेत्र में स्थित है, और इसके आह्वान के साथ कठिनाइयों का कारण नहीं होना चाहिए।

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

उदाहरण के लिए, मान लें कि पैच के बाद, हमारे फ़ंक्शन का कोड इस तरह दिखाई देने लगा:

 function TrampolineRtlCreateUnicodeString(DestinationString: PUNICODE_STRING; SourceString: PWideChar): Integer; stdcall; begin asm push $0C //    jmp $77B062FB //      end; end; 

वास्तव में, यह निम्नलिखित में बदल जाएगा:



यानी स्टैक पर, दो मापदंडों के बजाय डेस्टिनेशनस्ट्रिंग और सोर्सस्ट्रिंग, ईबीपी और ईसीएक्स रजिस्टरों के मूल्यों को रखा जाएगा, जिसके परिणामस्वरूप बिल्कुल अप्रत्याशित परिणाम होंगे।

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

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

इस प्रकार, हम निम्नलिखित तरीके से इंटरसेप्टर के आरंभीकरण को लागू करते हैं:

 //            procedure InitHotPatchSpliceRecEx(const LibraryName, FunctionName: string; InterceptHandler, Trampoline: Pointer; out HotPathSpliceRec: THotPachSpliceData); var OldProtect: DWORD; TrampolineSplice: TNearJmpSpliceRec; begin //      HotPathSpliceRec.FuncAddr := GetProcAddress(GetModuleHandle(PChar(LibraryName)), PChar(FunctionName)); //      ,     Move(HotPathSpliceRec.FuncAddr^, HotPathSpliceRec.LockJmp, LockJmpOpcodeSize); //   VirtualProtect(Trampoline, LockJmpOpcodeSize + NearJmpSpliceRecSize, PAGE_EXECUTE_READWRITE, OldProtect); try Move(HotPathSpliceRec.LockJmp, Trampoline^, LockJmpOpcodeSize); TrampolineSplice.JmpOpcode := JMP_OPKODE; TrampolineSplice.Offset := PAnsiChar(HotPathSpliceRec.FuncAddr) - PAnsiChar(Trampoline) - NearJmpSpliceRecSize; Trampoline := PAnsiChar(Trampoline) + LockJmpOpcodeSize; Move(TrampolineSplice, Trampoline^, SizeOf(TNearJmpSpliceRec)); finally VirtualProtect(Trampoline, LockJmpOpcodeSize + NearJmpSpliceRecSize, OldProtect, OldProtect); end; //   JMP NEAR HotPathSpliceRec.SpliceRec.JmpOpcode := JMP_OPKODE; //    (  NearJmpSpliceRecSize  , // ..     ) HotPathSpliceRec.SpliceRec.Offset := PAnsiChar(InterceptHandler) - PAnsiChar(HotPathSpliceRec.FuncAddr); end; 

इंटरसेप्टेड फंक्शन का आरंभीकरण और मंगलाचरण इस प्रकार है:

 type UNICODE_STRING = record Length: WORD; MaximumLength: WORD; Buffer: PWideChar; end; PUNICODE_STRING = ^UNICODE_STRING; function RtlCreateUnicodeString(DestinationString: PUNICODE_STRING; SourceString: PWideChar): BOOLEAN; stdcall; external 'ntdll.dll'; ... procedure TForm2.FormCreate(Sender: TObject); begin //       InitHotPatchSpliceRecEx('ntdll.dll', 'RtlCreateUnicodeString', @InterceptedRtlCreateUnicodeString, @TrampolineRtlCreateUnicodeString, HotPathSpliceRec); //     NOP- SpliceNearJmp(PAnsiChar(HotPathSpliceRec.FuncAddr) - NearJmpSpliceRecSize, HotPathSpliceRec.SpliceRec); end; procedure TForm2.Button1Click(Sender: TObject); var US: UNICODE_STRING; begin //  RtlCreateUnicodeString SpliceLockJmp(HotPathSpliceRec.FuncAddr, LOCK_JMP_OPKODE); try RtlCreateUnicodeString(@US, 'Test UNICODE String'); finally //   SpliceLockJmp(HotPathSpliceRec.FuncAddr, HotPathSpliceRec.LockJmp); end; end; 

अब आप बटन पर क्लिक कर सकते हैं और संदेश के रूप में अवरोधन का परिणाम देख सकते हैं।

निष्कर्ष में

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

मैं जानकारी को टुकड़ों में विभाजित करने के लिए माफी मांगता हूं और एक बार में सभी को नहीं देता हूं, लेकिन जैसा कि मुझे एक साल पहले सलाह दी गई थी, सामग्री को छोटे भागों में देना बेहतर होता है ताकि इसे पचाने का समय हो :)

दूसरी ओर, यदि आप सभी सामग्री को एक ढेर में रखते हैं, तो सबसे पहले इसमें काफी समय लगेगा, जो मेरे पास नहीं है, और दूसरी बात, यह बड़ी मात्रा में होने के कारण अपठनीय होगा (पूर्व उदाहरण थे)।
इसलिए, यह बेहतर है कि रास्ता।

उदाहरणों के लिए स्रोत कोड इस लिंक से लिया जा सकता है।

© अलेक्जेंडर (Rouse_) Bagel
मई 2013