एपीआई कॉल अवरोधन को लागू करना

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

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

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

बैरिकेड्स के रिवर्स साइड पर, दुर्भावनापूर्ण सॉफ़्टवेयर के पूरे ढेर दिखाई देते हैं, जिनमें से कुछ भी अपने मुख्य लक्ष्यों को प्राप्त करने के लिए निगरानी का उपयोग करना पसंद करते हैं। लेकिन अब उनके बारे में नहीं ...

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

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

परिणामस्वरूप, इसलिए अगली बार फिर से सब कुछ समझाने के लिए नहीं, मैंने एक समीक्षा लेख बनाने का फैसला किया जहां मैं "यह कैसे काम करता है" के बारे में सबसे सरल संभव भाषा में सब कुछ बताने की कोशिश करेगा।

1. मॉनीटर का सार

किसी भी तरह से मॉनिटर का मुख्य कार्य इसे नियंत्रित करने वाले फ़ंक्शन के नियंत्रण के बारे में सीख सकता है।

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

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

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

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

2. अवरोधक हैंडलर की सही घोषणा

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

function InterceptedMessageBoxA(hWnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; begin // TODO... end; 

यही है, अवरोधन हैंडलर और कॉलिंग कन्वेंशन (stdcall / cdecl, आदि) के मापदंडों को मूल फ़ंक्शन से बिल्कुल मेल खाना चाहिए। यदि ऐसा नहीं किया जाता है, तो हैंडलर को कॉल करने के बाद त्रुटि होने की लगभग गारंटी है।

सही हैंडलर घोषणा की सुविधा के लिए मुख्य रूप से आवश्यक है। आप निश्चित रूप से लिख सकते हैं और यहाँ इस तरह के एक हैंडलर है:

 procedure InterceptedFunc; begin // TODO... end; 

लेकिन इस मामले में, कॉल मापदंडों को प्राप्त करना और कॉल को अंतिम रूप देना, समझौतों और मापदंडों की संख्या को ध्यान में रखते हुए कोडांतरक आवेषण का उपयोग करना आवश्यक होगा।

एक छोटी सी बारीकियों को कक्षा के तरीकों के रूप में लागू किए गए कार्यों / प्रक्रियाओं के इंटरसेप्टर के कार्यान्वयन के साथ किया जाएगा।

मान लें कि हम TApplication.MessageBox को रोकते हैं।
यदि अवरोधक हैंडलर को एक वर्ग विधि के रूप में लागू किया जाता है, तो इसकी घोषणा मूल कार्य की तरह दिखाई देगी:

 function TTestClas.InterceptedApplicationMessageBox( const Text, Caption: PChar; Flags: Longint): Integer; begin // TODO... end; 

यदि इंटरसेप्टर एक स्वतंत्र कार्य है, तो इसका कार्यान्वयन थोड़ा अलग दिखेगा:

 function InterceptedApplicationMessageBox( Self: TObject; const Text, Caption: PChar; Flags: Longint): Integer; begin // TODO... end; 

हैंडलर की घोषणा में इस तरह के अंतर इस तथ्य के कारण हैं कि वर्ग विधियों के लिए बहुत पहले पैरामीटर स्पष्ट रूप से घोषित चर स्व नहीं है।

वैसे, यदि आप किसी दिए गए चर का वर्ग नाम पहले इंटरसेप्टर में प्राप्त करने की कोशिश करते हैं, उदाहरण के लिए, इस तरह:

 function TTestClas.InterceptedApplicationMessageBox( const Text, Caption: PChar; Flags: Longint): Integer; begin ShowMessage(Self.ClassName); end; 

... तब पाठ TApplication प्रदर्शित होता है, न कि TTestClass, क्योंकि स्व पैरामीटर में मूल वर्ग के बारे में डेटा होगा, न कि उस वर्ग के बारे में जिसमें इंटरसेप्टर लागू किया गया है।

सिद्धांत रूप में, यह आप सभी को इंटरसेप्शन हैंडलर की घोषणा के बारे में जानने की जरूरत है, अब आप इंटरसेप्टिंग कार्यों के विभिन्न तरीकों पर विचार करना शुरू कर सकते हैं।

3. एक खिड़की प्रक्रिया उपवर्ग

एक लंबे समय के लिए मैंने चुना कि तकनीकी हिस्सा कहाँ शुरू किया जाए और अंत में मैंने प्रलेखित तकनीकों पर ध्यान केंद्रित करने का निर्णय लिया। वास्तव में, एक और बाइक का आविष्कार क्यों करें - जो है उसे मोड़ना आसान है।

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

तकनीक काफी सामान्य है, और डेल्फी में अपने स्वयं के नियंत्रणों को लागू करते समय, आप लगभग हमेशा वैश्विक TWinControl.MainWndProc हैंडलर पर अपनी सभी खिड़कियों की विंडो प्रक्रिया को ओवरलैप करने का परिणाम भुगतते हैं। यह वास्तव में एक सुविधाजनक समाधान है जो हमें संदेश + संदेश निरंतर, वर्चुअल WndProc और DefaultHandler के साथ काम करके और कुछ और कोड में कुछ संदेशों को ब्लॉक करने की अनुमति देता है ...

इस पद्धति का एक सामान्य विवरण इस लिंक पर पाया जा सकता है: एक खिड़की को उप-वर्ग करना

कार्यान्वयन एल्गोरिदम को पांच बिंदुओं के रूप में दर्शाया जा सकता है:

1. मूल विंडो प्रक्रिया का पता प्राप्त करना
2. हैंडलर के लिए सुलभ किसी भी स्थान पर इसे सहेजना
3. एक नई विंडो प्रक्रिया हैंडलर का काम
4. इंटरसेप्टर कॉल (लॉगिंग / कॉल पैरामीटर बदलना, इत्यादि) का काम करना
5. यदि आवश्यक हो, तो पुराने हैंडलर का पता प्राप्त करें और उसे कॉल करें।

कोड के रूप में, सब कुछ काफी सरल दिखता है।

 unit uSubClass; interface uses Windows, Messages, Classes, Controls, Forms, StdCtrls; type TForm1 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); end; var Form1: TForm1; implementation {$R *.dfm} function MainFormSubclassProc(hwnd: THandle; uMsg: UINT; wParam: WPARAM; lParam: WPARAM): LRESULT; stdcall; var OldWndProc: Pointer; begin if uMsg = WM_WINDOWPOSCHANGING then PWindowPos(lParam)^.flags := PWindowPos(lParam)^.flags or SWP_NOSIZE or SWP_NOMOVE; OldWndProc := Pointer(GetWindowLong(hwnd, GWL_USERDATA)); Result := CallWindowProc(OldWndProc, hwnd, uMsg, wParam, lParam); end; procedure TForm1.Button1Click(Sender: TObject); var OldWndProc: THandle; begin OldWndProc := GetWindowLong(Handle, GWL_WNDPROC); SetWindowLong(Handle, GWL_USERDATA, OldWndProc); SetWindowLong(Handle, GWL_WNDPROC, Integer(@MainFormSubclassProc)); MessageBox(Handle, '      ', PChar(Application.Title), MB_ICONINFORMATION); end; end. 

इस उदाहरण में, अनुप्रयोग के मुख्य रूप की विंडो प्रक्रिया को प्रतिस्थापित किया जाता है।
पुरानी प्रक्रिया का पता उपयोगकर्ता विंडो बफर में संग्रहीत है, जिसे निरंतर GWL_USERDATA के माध्यम से एक्सेस किया गया है।
जब एक नया MainFormSubclassProc हैंडलर कहा जाता है, तो संदेश कोड की जाँच की जाती है। यदि यह संदेश विंडो के आकार बदलने या समन्वय करने के बारे में है, तो इस सुविधा को झंडे SWP_NOSIZE और SWP_NOMOVE सेट करके अवरुद्ध कर दिया जाता है।
इस एप्लिकेशन को चलाने का प्रयास करें और बटन पर क्लिक करें और फिर मुख्य फ़ॉर्म का आकार बदलने का प्रयास करें। आप सफल नहीं हुए

एक छोटी सी बारीकियों : इस कोड में कोई दोहरा ओवरलैप चेक नहीं है। यदि आप दूसरी बार बटन पर क्लिक करते हैं, तो आपको स्टैक ओवरफ्लो के बारे में एक त्रुटि मिलती है। यह इस तथ्य के कारण है कि पुराने पते के प्राप्त होने पर, विंडो प्रक्रिया के दूसरे ओवरलैप पर, वही मेनफॉर्म्सक्लासप्रोक हैंडलर का पता वापस आ जाएगा, और तदनुसार, कॉलविंडोप्रोक के पहले कॉल पर, आप एक अनंत लूप दर्ज करेंगे, क्योंकि हम अपने आप को कॉल करेंगे, जिसमें से निकास अतिप्रवाह होगा।

अनुप्रयोग : यह अवरोधन विकल्प केवल विंडोज़ के लिए उपयोग किया जा सकता है। संवादों के लिए, आपको निरंतर DWL_DLGPROC का उपयोग करना होगा।

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

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

ऐसा होने से रोकने के लिए, आपको किसी अन्य तरीके से इंटरसेप्टर कोड को किसी अन्य स्थान पर रखना होगा और उसके बाद ही प्रतिस्थापन करना चाहिए। यह कई तरीकों से किया जाता है, लेकिन हम थोड़ी देर बाद उन पर ध्यान केंद्रित करेंगे ...

4. VMT तालिकाओं को संपादित करके अवरोधन।

सिद्धांत रूप में, यह अवरोधन के लिए एक बहुत ही दुर्लभ विकल्प है, लेकिन चूंकि मैंने सभी संभावित तरीकों के बारे में बात करने का फैसला किया है, इसलिए मुझे इस पर भी विचार करना होगा।

आप शायद ऐसी स्थितियों में आ गए हैं जहां एक निश्चित नियंत्रण का व्यवहार पूरी तरह से संतोषजनक है, लेकिन यहां कुछ गायब है। समस्या को हल करने के लिए, आपको आमतौर पर समस्या वर्ग के वारिस को लिखना होगा जिसमें संबंधित आभासी तरीकों को ओवरलैप करना है, जहां नियंत्रण के वांछित व्यवहार को लिखना है। लेकिन अगर यह बहुत आलसी है तो वारिस के कार्यान्वयन के बिना प्राप्त किया जा सकता है, बस बाहर से आवश्यक विधि को अवरुद्ध करके।

निम्नलिखित उदाहरण में, मैं दिखाऊंगा कि कैसे आप TForm.CanResize विधि को ओवरराइड कर सकते हैं जिसे फॉर्म के आकार बदलने पर कहा जाता है। कोड का कार्य फॉर्म को 500 पिक्सेल से अधिक चौड़ा आकार बदलने से रोकना है।

बेशक, इस उदाहरण में, minuses का एक पूरा गुच्छा, सबसे पहले, लक्ष्य को प्राप्त करने के लिए, आप OnResize हैंडलर को ब्लॉक कर सकते हैं, और दूसरी बात, चूंकि TForm से CanResize ओवरलैप हो सकते हैं, यह संशोधन परियोजना के सभी रूपों को प्रभावित करेगा, लेकिन इसके लिए वह और उदाहरण सिर्फ उनका काम है इस अवसर को दिखाएं।

आवेदन : इस अवरोधन विकल्प का उपयोग केवल आभासी वर्ग विधियों के लिए किया जा सकता है, और केवल अपनी पीई फ़ाइल के ढांचे के भीतर। यदि आप इस कोड को लाइब्रेरी में रखते हैं और इस तरह से मुख्य एप्लिकेशन से विधि को इंटरसेप्ट करने की कोशिश करते हैं, तो कुछ भी काम नहीं करेगा, क्योंकि TForm एप्लीकेशन और TForm लाइब्रेरी अलग-अलग वर्ग हैं।

कोड निम्नानुसार है:

 unit uVMT; interface uses Windows, Classes, Controls, Forms, StdCtrls; type TForm1 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); end; var Form1: TForm1; implementation {$R *.dfm} function NewCanResizeHandler(Self: TObject; var NewWidth, NewHeight: Integer): Boolean; begin Result := True; if NewWidth > 500 then NewWidth := 500; end; procedure TForm1.Button1Click(Sender: TObject); var VMTAddr: PPointer; OldProtect: Cardinal; begin asm mov eax, Self mov eax, [eax] //    VMT  add eax, VMTOFFSET TForm.CanResize //     TForm.CanResize mov VMTAddr, eax end; //     VirtualProtect(VMTAddr, 4, PAGE_EXECUTE_READWRITE, OldProtect); try //    VMTAddr^ := @NewCanResizeHandler; finally //    VirtualProtect(Pointer(VMTAddr), 4, OldProtect, OldProtect); FlushInstructionCache(GetCurrentProcess, VMTAddr, 4); end; if Width > 500 then Width := 500; MessageBox(Handle, '     500 ', PChar(Application.Title), MB_ICONINFORMATION); end; end. 

अब और विस्तार से:

1. अवरोधन हैंडलर की घोषणा इस लेख के दूसरे खंड (स्व पैरामीटर) में वर्णित बारीकियों को ध्यान में रखते हुए की गई थी।

2. डेल्फी मदद में वर्णित दस्तावेज VMTOFFSET इंटरसेप्शन के लिए उपयोग किया जाता है।

यहाँ उसके विवरण के साथ एक टुकड़ा है:

दो अतिरिक्त निर्देश असेंबली कोड को गतिशील और आभासी विधि का उपयोग करने की अनुमति देते हैं: VMTOFFSET और DMTINDEX।
VMTOFFSET वर्चुअल विधि तालिका (VMT) की शुरुआत से वर्चुअल विधि तर्क के वर्चुअल विधि सूचक तालिका प्रविष्टि के बाइट्स में ऑफ़सेट को हटाता है। इस निर्देश को पैरामीटर के रूप में विधि नाम के साथ पूरी तरह से निर्दिष्ट वर्ग नाम की आवश्यकता है, उदाहरण के लिए, TExample.VirtualMethod।

जैसा कि विवरण से स्पष्ट है, इसका कार्य वर्चुअल विधि तालिका (वीएमटी) की शुरुआत के सापेक्ष वर्चुअल विधि के पते पर ऑफसेट को वापस करना है। VMT तालिका की शुरुआत सीधे स्व पैरामीटर द्वारा इंगित की जाती है। यही है, यदि आप इसे कोड के रूप में चित्रित करते हैं, तो आपको निम्नलिखित मिलते हैं:

 VMT := Pointer(Self)^; 

3. कोडांतरक सम्मिलित करने के बाद विधि के पते पर एक संकेतक डाला जाता है, इसे वर्चुअल विधि के नए हैंडलर के पते से बदल दिया जाता है।

4. चूंकि आवेदन कोड में प्रतिस्थापन किया जाता है, जो आमतौर पर मेमोरी पेज में स्थित होता है, जिसमें लिखने की अनुमति नहीं होती है (आमतौर पर ये पढ़े जाते हैं और अधिकारों को निष्पादित करते हैं), लिखने की अनुमति नए हैंडलर की नियुक्ति से पहले निर्धारित की जाती है।

खैर अब, उदाहरण को चलाएं और इसके संचालन की जांच करें।

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

यदि आपको VMT के संपादन के सिद्धांत को समझने में कठिनाई हो रही है, तो मैं हॉलवार्ड वासबोटन द्वारा इस लेख को पढ़ने की सिफारिश कर सकता हूं : विधि कॉल बॉयलर कार्यान्वयन।

या इसका अनुवाद, अलेक्जेंडर अलेक्सेव द्वारा प्रदान किया गया: संकलक द्वारा विधि कॉल का कार्यान्वयन ।

मैं डायनेमिक क्लास विधियों के अवरोधन के विकल्प पर विचार नहीं करूंगा - लेकिन सिद्धांत लगभग समान है।

5. आयात तालिका को संपादित करके अवरोधन

आयात तालिका क्या है जब आप किसी एप्लिकेशन को लिखते हैं और किसी फ़ंक्शन के एपीआई को कॉल करते हैं, तो एप्लिकेशन को किसी तरह इस फ़ंक्शन के पते की गणना करना चाहिए ताकि इसे नियंत्रण स्थानांतरित किया जा सके। अधिकांश कार्यों को सांख्यिकीय रूप से घोषित किया जाता है, उदाहरण के लिए:

 {$EXTERNALSYM MessageBox} function MessageBox(hWnd: HWND; lpText, lpCaption: PChar; uType: UINT): Integer; stdcall; ... function MessageBox; external user32 name 'MessageBoxA'; 

यह स्पष्ट रूप से MessageBox फ़ंक्शन को कॉल की पूर्ण घोषणा और इसे कॉल करने के लिए समझौते को इंगित करता है। यह जानकारी संकलक द्वारा फ़ंक्शन को कॉल करते समय स्टैक को ठीक से संरेखित करने के लिए आवश्यक है। यह उस लाइब्रेरी के नाम को भी इंगित करता है जिसमें फ़ंक्शन कार्यान्वित किया जाता है और वह नाम जिसके तहत इसे निर्यात किया जाता है।

जैसा कि आप देख सकते हैं, फ़ंक्शन का पता यहां नहीं है, और यह नहीं हो सकता है, क्योंकि फ़ंक्शन को निर्यात करने वाले पुस्तकालय को किसी भी पते पर लोड किया जा सकता है, और प्रत्येक प्रक्रिया के लिए एक ही फ़ंक्शन का पता अलग-अलग होगा। सच है, यहां एक छोटी सी बारीकियों है, user32.dll, kernel32.dll और ntdll.dll पुस्तकालयों को एक निश्चित पते (कम से कम 32-बिट सिस्टम) पर सभी प्रक्रियाओं के लिए लोड किया जाता है, लेकिन आपको किसी निश्चित स्थैतिक पते पर वैसे भी भरोसा नहीं करना चाहिए।

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

मैट पिट्रेक के लेख में पाया जा सकता है कि आयात तालिका कैसे काम करती है, इसका एक सामान्य विवरण: पीयरिंग इनसाइड द पीई: ए टूर ऑफ द विन 32 पोर्टेबल एग्जिक्यूटेबल फाइल फॉर्मेट ।
RSDN पर एक अनुवाद उपलब्ध है: ऑब्जेक्ट फ़ाइलों का RE और COFF प्रारूप ।
यदि अधिक जानकारी की आवश्यकता है, तो आप निम्नलिखित लेख का अध्ययन कर सकते हैं: पीई। पाठ 6. इज़ेलियन के लिए आयात की गई तालिका ।

अब इस जानकारी के साथ क्या किया जा सकता है? यह सरल है, एक अवरोधक हैंडलर असाइन करने के लिए, आपको बस लोडर द्वारा गणना किए गए पते को हैंडलर के पते पर बदलना होगा, जिसके बाद अवरोधन को वैध माना जा सकता है।

आवेदन : यह अवरोधन विकल्प केवल स्थैतिक लिंकिंग के साथ एपीआई कार्यों के लिए उपयोग किया जाता है।

मूल फ़ंक्शन के पते की खोज करने और इसे इंटरसेप्टर के पते से बदलने के लिए, हम इस फ़ंक्शन को लिखेंगे:

 function ReplaceIATEntry(const OldProc, NewProc: FARPROC): Boolean; var ImportEntry: PImageImportDescriptor; Thunk: PImageThunkData; Protect: DWORD; ImageBase: Cardinal; DOSHeader: PImageDosHeader; NTHeader: PImageNtHeaders; begin Result := False; if OldProc = nil then Exit; if NewProc = nil then Exit; ImageBase := GetModuleHandle(nil); //     DOSHeader := PImageDosHeader(ImageBase); NTHeader := PImageNtHeaders(DWORD(DOSHeader) + DWORD(DOSHeader^._lfanew)); ImportEntry := PImageImportDescriptor(DWORD(ImageBase) + DWORD(NTHeader^.OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress)); //     ... while ImportEntry^.Name <> 0 do begin Thunk := PImageThunkData(DWORD(ImageBase) + DWORD(ImportEntry^.FirstThunk)); // ...     ... while Pointer(Thunk^._function) <> nil do begin // ...      . if Pointer(Thunk^._function) = OldProc then begin //   if VirtualProtect(@Thunk^._function, SizeOf(DWORD), PAGE_EXECUTE_READWRITE, Protect) then try //   ... //Thunk^._function := DWORD(NewProc); // ...   . InterlockedExchange(Integer(Thunk^._function), Integer(NewProc)); Result := True; finally VirtualProtect(@Thunk^._function, SizeOf(DWORD), Protect, Protect); FlushInstructionCache(GetCurrentProcess, @Thunk^._function, SizeOf(DWORD)); end; end else Inc(PAnsiChar(Thunk), SizeOf(TImageThunkData32)); end; ImportEntry := Pointer(Integer(ImportEntry) + SizeOf(TImageImportDescriptor)); end; end; 

यह GetModuleHandle (nil) छवि कोड कोड के रूप में, वर्तमान निष्पादन योग्य फ़ाइल के शरीर में आयात तालिका को सही करता है। सीधे इंटरसेप्टर पते की स्थापना को इंटरलॉकेड एक्सचेंज कहकर परमाणु प्रदर्शन किया जाता है। यह एक बल्कि नाजुक बिंदु है, हालांकि, मैं इंटरसेप्टर के पते को बदलने के इस विशेष तरीके के कारणों के बारे में थोड़ा बाद में रोकूंगा।

अब यह केवल इस फ़ंक्शन को कॉल करने का एक उदाहरण लिखने के लिए बना हुआ है।

एक नया प्रोजेक्ट बनाएं, बटन को मुख्य फ़ॉर्म पर रखें, रिप्लेसमेंट फ़ंक्शन के कार्यान्वयन को लिखें, और फिर निम्नलिखित कोड जोड़ें:

 var OrigAddr: Pointer = nil; function InterceptedMessageBoxA(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; type TOrigMessageBoxA = function(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; var S: AnsiString; begin S := AnsiString('Function interepted. Original message: ' + lpText); Result := TOrigMessageBoxA(OrigAddr)(Wnd, PAnsiChar(S), lpCaption, uType); end; procedure TForm1.FormCreate(Sender: TObject); begin OrigAddr := GetProcAddress(GetModuleHandle(user32), 'MessageBoxA'); ReplaceIATEntry(OrigAddr, @InterceptedMessageBoxA); end; procedure TForm1.Button1Click(Sender: TObject); begin MessageBoxA(0, 'Test Message', nil, 0); end; 

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

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

एक छोटी सी बारीकियाँ है :
स्थैतिक फ़ंक्शन को आस्थगित आयात अनुभाग में स्थित किया जा सकता है। यह घोषणा काफी सरल तरीके से की गई है, आइए उदाहरण कोड को इस तरह थोड़ा बदलें:

  function DelayedMessageBoxA(hWnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; external user32 name 'MessageBoxA' delayed; procedure TForm1.Button1Click(Sender: TObject); begin DelayedMessageBoxA(0, 'Test Message', nil, 0); end; 

DelayedMessageBoxA फ़ंक्शन वास्तव में एक ही MessageBoxA है।
लेकिन " देरी " पैरामीटर विलंबित आयात अनुभाग में इस फ़ंक्शन को कॉल रिकॉर्ड करता है।

Nuance : " विलंबित " पैरामीटर डेल्फी के पुराने संस्करणों में उपलब्ध नहीं है, इसलिए इस लेख के डेमो उदाहरणों में आपको यह कोड नहीं मिलेगा।

चूंकि ऊपर लागू किया गया इंटरसेप्टर केवल आयात तालिका में परिवर्तन करता है, इस तरह से घोषित एक फ़ंक्शन कॉल इसके द्वारा नियंत्रित नहीं किया जाएगा। ऐसा करने के लिए, आपको IMAGE DIRECTORY_ENTRY DELAYED IMPORT को संपादन करना होगा।

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

6. निर्यात तालिका को संपादित करके अवरोधन।

आयात तालिका का संपादन और आस्थगित आयात सांख्यिकीय रूप से घोषित कार्यों के लिए बहुत अच्छा है, लेकिन यह गतिशील घोषणा और फ़ंक्शन कॉल के खिलाफ काम नहीं करेगा।

यदि सादे भाषा में, पिछले उदाहरण में एक और बटन जोड़ने का प्रयास करें और उसके हैंडलर में निम्न कोड लिखें:

 procedure TForm1.Button2Click(Sender: TObject); type TOrigMessageBoxA = function(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; var OrigMessageBoxA: TOrigMessageBoxA; begin @OrigMessageBoxA := GetProcAddress(GetModuleHandle(user32), 'MessageBoxA'); OrigMessageBoxA(0, 'Test Message', nil, 0); end; 

बटन दबाएं और आप देखेंगे कि इंटरसेप्टर काम नहीं कर रहा था। तथ्य यह है कि GetProcAddress फ़ंक्शन को दोष देना है, जो लाइब्रेरी एक्सपोर्ट टेबल पर ध्यान केंद्रित करते हुए आयात तालिका को दरकिनार करते हुए फ़ंक्शन का पता प्राप्त करता है।

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

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

आप मैट पिट्रेक द्वारा एक ही लेख में निर्यात तालिका के काम का सामान्य विवरण पा सकते हैं।
यदि अधिक जानकारी की आवश्यकता है, तो आप निम्नलिखित लेख का अध्ययन कर सकते हैं:
पीई। पाठ 7. निर्यात तालिका का प्रतीक इज़्ज़ेलियन से है।

अनुप्रयोग : यह अवरोधन विकल्प केवल API फ़ंक्शन के लिए उपयोग किया जाता है जिसे गतिशील रूप से कहा जाता है।

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

 unit uEAT; interface uses Windows, Classes, Controls, Forms, StdCtrls; type TForm1 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); procedure FormCreate(Sender: TObject); end; var Form1: TForm1; implementation {$R *.dfm} uses DeclaredTypes; function ReplaceEATEntry(const DllName: string; OldProc, NewProc: FARPROC): Boolean; var ImageBase: Cardinal; DOSHeader: PImageDosHeader; NTHeader: PImageNtHeaders; ExportDirectory: PImageExportDirectory; pFuntionAddr: PDWORD; OrdinalCursor: PWORD; Ordinal, Protect: DWORD; FuntionAddr: FARPROC; I: Integer; begin Result := False; if OldProc = nil then Exit; if NewProc = nil then Exit; ImageBase := GetModuleHandle(PChar(DllName)); //     DOSHeader := PImageDosHeader(ImageBase); NTHeader := PImageNtHeaders(DWORD(DOSHeader) + DWORD(DOSHeader^._lfanew)); ExportDirectory := PImageExportDirectory(DWORD(ImageBase) + DWORD(NTHeader^.OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)); I := 1; //     OrdinalCursor := Pointer(ImageBase + DWORD(ExportDirectory^.AddressOfNameOrdinals)); while I < Integer(ExportDirectory^.NumberOfNames) do begin //       Ordinal := OrdinalCursor^; //       FuntionAddr := Pointer(ImageBase + DWORD(ExportDirectory^.AddressOfFunctions)); FuntionAddr := Pointer(ImageBase + PDWORD(DWORD(FuntionAddr) + Ordinal * 4)^); // ,    ? if FuntionAddr = OldProc then begin //  ,  ,      pFuntionAddr := PDWORD(ImageBase + DWORD(ExportDirectory^.AddressOfFunctions) + Ordinal * 4); //        hInstance  NewProc := Pointer(DWORD(NewProc) - ImageBase); //    if VirtualProtect(pFuntionAddr, SizeOf(DWORD), PAGE_EXECUTE_READWRITE, Protect) then try //   ... //pFuntionAddr^ := Integer(NewProc); // ...   . InterlockedExchange(Integer(PImageThunkData(pFuntionAddr)^._function), Integer(NewProc)); Result := True; finally VirtualProtect(pFuntionAddr, SizeOf(DWORD), Protect, Protect); FlushInstructionCache(GetCurrentProcess, pFuntionAddr, SizeOf(DWORD)); end; Break; end; Inc(I); Inc(OrdinalCursor); end; end; var OrigAddr: Pointer = nil; function InterceptedMessageBoxA(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; type TOrigMessageBoxA = function(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; var S: AnsiString; begin S := AnsiString('Function interepted. Original message: ' + lpText); Result := TOrigMessageBoxA(OrigAddr)(Wnd, PAnsiChar(S), lpCaption, uType); end; procedure TForm1.FormCreate(Sender: TObject); begin OrigAddr := GetProcAddress(GetModuleHandle(user32), 'MessageBoxA'); ReplaceEATEntry(user32, OrigAddr, @InterceptedMessageBoxA); end; procedure TForm1.Button1Click(Sender: TObject); type TOrigMessageBoxA = function(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; var OrigMessageBoxA: TOrigMessageBoxA; begin @OrigMessageBoxA := GetProcAddress(GetModuleHandle(user32), 'MessageBoxA'); OrigMessageBoxA(0, 'Test Message', nil, 0); end; end. 

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

7. फंक्शन एंट्री पॉइंट का स्प्लिटिंग इंटरसेप्शन।

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

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

सच है, ये सभी इस विधि के फायदे हैं, फिर मिनस शुरू होते हैं।

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

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

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

अब इंटरसेप्शन कोड के बारे में थोड़ा सीधे सीधे, अर्थात्, यह कहाँ से आता है?
निर्देश की शुरुआत के लिए एक asm अवरोधन कोड लिखने का मतलब यह नहीं है कि आप उदाहरण के लिए "JMP 100" लाइन लिखेंगे। प्रोसेसर को कोडांतरक के बारे में कुछ भी नहीं पता है, लेकिन यह मशीन कोड के बारे में जानता है। इसलिए, डेवलपर यह निर्धारित करने के बाद कि इंटरसेप्टर के किस विशिष्ट डिजाइन का उपयोग करेगा, उसे इसे प्रोसेसर के लिए मशीन कोड में समझने योग्य बनाने की आवश्यकता है, जिसे फ़ंक्शन की शुरुआत में रखा जाएगा।
वास्तव में, हालांकि यह जटिल लगता है, यह करना उतना ही आसान है। इसके लिए, इंटेल के मैनुअल काम में आते हैं जिनसे आप आवश्यक अनुक्रम उत्पन्न करने के लिए इंटरसेप्टर में उपयोग किए जाने वाले निर्देशों के ऑपकोड का पता लगा सकते हैं। मैं इसे और भी आसान बना देता हूं, बस मुझे asm इन्सर्ट में जिस कोड की आवश्यकता है वह लिखें और देखें कि मेरे लिए किस तरह का मशीन कोड कंपाइलर जनरेट करता है।

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

1. JMP NEAR OFFSET
फाइव-बाइट इंस्ट्रक्शन, पहला बाइट $ E9 है, जो JMP NEAR rel32 इंस्ट्रक्शन का ऑपकोड है, बाकी 4 OFFSET पैरामीटर्स हैं।
OFFSET की गणना निम्न सूत्र के अनुसार की जाती है: OFFSET = DestinationAddr - CurrentAddr - निर्देश मशीन कोड का आकार
जहां DestinationAddr अवरोधक हैंडलर
का पता है CurrentAddr वह पता है जिस पर JMP NEAR OFFSET निर्देश रखा गया है

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

 procedure SliceNearJmp(OldProc, NewProc: FARPROC); var SpliceRec: packed record JmpOpcode: Byte; Offset: DWORD; end; Tmp: DWORD; begin SpliceRec.JmpOpcode := $E9; SpliceRec.Offset := DWORD(NewProc) - DWORD(OldProc) - SizeOf(SpliceRec); VirtualProtect(OldProc, SizeOf(SpliceRec), PAGE_EXECUTE_READWRITE, OldProtect); Move(SpliceRec, OldProc^, SizeOf(SpliceRec)); VirtualProtect(OldProc, SizeOf(SpliceRec), OldProtect, OldProtect); end; 

2. PUSH ADDR + RET एक
छह-बाइट अनुदेश, पहला बाइट $ 68 है, जो PUSH Imm32 निर्देश का ऑपकोड है, अगले 4 बाइट्स ADDR पैरामीटर हैं, जिसका अर्थ है कि पता जम्प किया जाना चाहिए, और $ C3 का अंतिम छठा बाइट, जो RET निर्देश का ओपोड है।
संक्षेप में, निर्देशों का यह समूह सरलता से काम करता है। पहला PUSH निर्देश ढेर पर ADDR कूद पते को धक्का देता है, दूसरा RET निर्देश ढेर के दाईं ओर निर्दिष्ट पते पर कूदता है।

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

 procedure SlicePushRet(OldProc, NewProc: FARPROC); var SpliceRec: packed record PushOpcode: Byte; Offset: FARPROC; RetOpcode: Byte; end; begin SpliceRec.PushOpcode := $68; SpliceRec.Offset := NewProc; SpliceRec.RetOpcode := $C3; VirtualProtect(OldProc, SizeOf(SpliceRec), PAGE_EXECUTE_READWRITE, OldProtect); Move(SpliceRec, OldProc^, SizeOf(SpliceRec)); VirtualProtect(OldProc, SizeOf(SpliceRec), OldProtect, OldProtect); end; 

दोनों विकल्प, सिद्धांत रूप में, जीवन का अधिकार है और अक्सर उपयोग किया जाता है। लेकिन दोनों सुरक्षित नहीं हैं।

ऐसे दो निर्देशों का एक इंटरसेप्टर वेरिएंट भी है: MOV EAX, ADDR + JMP EAX। यह सात-बाइट निर्माण एक अच्छा समाधान नहीं है यदि इसे FASTCALL सम्मेलन का उपयोग करके कार्यों को बाधित करने के लिए उपयोग किया जाता है। तथ्य यह है कि इस समझौते का उपयोग डेल्फी में डिफ़ॉल्ट रूप से किया जाता है और इसकी ख़ासियत यह है कि फ़ंक्शन के पहले तीन मापदंडों को रजिस्टर EAX, ECX और EDX में रखा गया है। इस प्रकार के इंटरसेप्टर को लागू करने से EAX रजिस्टर में जाने वाला पैरामीटर ओवरराइट हो जाएगा। इसलिए, मैं इस विकल्प पर विचार नहीं करूंगा।

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

तथ्य यह है कि रेडमंड के लोगों ने हमारे लिए एक छोटी खामी प्रदान की है जो हमें प्रवेश बिंदु को अधिक सुरक्षित बनाने के लिए अनुमति देता है। और फिर भी, हाँ, इसे "हॉटपैच" कहा जाता है :)

संक्षेप में, यदि आप एक डिस्सेम्बलर में एमएस से किसी भी पुस्तकालय को खोलते हैं, तो आप देख सकते हैं कि प्रत्येक एपीआई फ़ंक्शन का शरीर पांच एनओपी निर्देशों से पहले होता है, और फ़ंक्शन बॉडी को एमओवी ईडीआई, ईडीआई करने के लिए कुछ भी नहीं शुरू होता है। या तो डबल बाइट PUSH xxx)



पहले पाँच निर्देशों का आकार हमें इसके बजाय JMP NEAR OFFSET निर्देश कोड लिखने की अनुमति देता है। इसके अलावा, रिकॉर्डिंग के समय, फ़ंक्शन का शरीर स्वयं नहीं बदलेगा। इस निर्देश को लिखने के बाद, हम JMP SHORT -7 निर्देश के दो-बाइट मशीन कोड के बजाय, फ़ंक्शन के पहले दो बाइट्स को एटोमिक रूप से बदल सकते हैं, जो बाइट्स $ EB और $ F9 है।

HotPach का नमूना कोड इस तरह दिखेगा:

 procedure SliceHotPath(OldProc, NewProc: FARPROC); var SpliceRec: packed record JmpOpcode: Byte; Offset: DWORD; end; NopAddr: Pointer; OldProtect: DWORD; begin SpliceRec.JmpOpcode := $E9; NopAddr := PAnsiChar(OldProc) - SizeOf(SpliceRec); SpliceRec.Offset := DWORD(NewProc) - DWORD(NopAddr) - SizeOf(SpliceRec); VirtualProtect(NopAddr, 7, PAGE_EXECUTE_READWRITE, OldProtect); Move(SpliceRec, NopAddr^, SizeOf(SpliceRec)); asm mov ax, $F9EB mov ecx, OldProc lock xchg word ptr [ecx], ax end; VirtualProtect(NopAddr, 7, OldProtect, OldProtect); end; 

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

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

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

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

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

 unit uNearJmpSplice; interface uses Windows, Classes, Controls, Forms, StdCtrls; type TForm1 = class(TForm) Button1: TButton; procedure FormCreate(Sender: TObject); procedure Button1Click(Sender: TObject); end; var Form1: TForm1; implementation {$R *.dfm} type //      JMP NEAR OFFSET TNearJmpSpliceRec = packed record JmpOpcode: Byte; Offset: DWORD; end; //         JMP NEAR OFFSET TNearJmpSpliceData = packed record FuncAddr: FARPROC; OldData: TNearJmpSpliceRec; NewData: TNearJmpSpliceRec; end; var NearJmpSpliceRec: TNearJmpSpliceData; //         procedure SpliceNearJmp(FuncAddr: Pointer; NewData: TNearJmpSpliceRec); var OldProtect: DWORD; begin VirtualProtect(FuncAddr, SizeOf(TNearJmpSpliceRec), PAGE_EXECUTE_READWRITE, OldProtect); try //   !!! Move(NewData, FuncAddr^, SizeOf(TNearJmpSpliceRec)); finally VirtualProtect(FuncAddr, SizeOf(TNearJmpSpliceRec), OldProtect, OldProtect); FlushInstructionCache(GetCurrentProcess, FuncAddr, SizeOf(TNearJmpSpliceRec)); end; end; //    MessageBoxA function InterceptedMessageBoxA(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; var S: AnsiString; begin //   SpliceNearJmp(NearJmpSpliceRec.FuncAddr, NearJmpSpliceRec.OldData); try //    S := AnsiString('Function interepted. Original message: ' + lpText); Result := MessageBoxA(Wnd, PAnsiChar(S), lpCaption, uType); finally //   SpliceNearJmp(NearJmpSpliceRec.FuncAddr, NearJmpSpliceRec.NewData); end; end; procedure InitNearJmpSpliceRec; begin //      NearJmpSpliceRec.FuncAddr := GetProcAddress(GetModuleHandle(user32), 'MessageBoxA'); //      ,     Move(NearJmpSpliceRec.FuncAddr^, NearJmpSpliceRec.OldData, SizeOf(TNearJmpSpliceRec)); //   JMP NEAR NearJmpSpliceRec.NewData.JmpOpcode := $E9; //    NearJmpSpliceRec.NewData.Offset := PAnsiChar(@InterceptedMessageBoxA) - PAnsiChar(NearJmpSpliceRec.FuncAddr) - SizeOf(TNearJmpSpliceRec); end; procedure TForm1.FormCreate(Sender: TObject); begin //     InitNearJmpSpliceRec; //  MessageBoxA SpliceNearJmp(NearJmpSpliceRec.FuncAddr, NearJmpSpliceRec.NewData); end; procedure TForm1.Button1Click(Sender: TObject); begin MessageBoxA(0, 'Test MessageBoxA Message', nil, 0); end; end. 

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

प्रारंभ में, InitNearJmpSpliceRec प्रक्रिया में, इस संरचना को प्रारंभ किया जाता है, जिसके बाद इंटरसेप्शन कोड SpliceNearJmp प्रक्रिया का उपयोग करके सेट किया जाता है।

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

यदि आप दूसरे तरीके से अवरोधन करते हैं, तो PUSH ADDR + RET का उपयोग करते हुए, आपको TNearJmpSpliceRec संरचना और InitNearJmpSpliceiceec संरचना की प्रारंभिक प्रक्रिया का विवरण थोड़ा बदलना होगा, बाकी सब कुछ समान रहेगा।

खैर, यह है कि इंटरसेप्शन कोड तीसरे तरीके से दिखाई देगा (HotPatch के माध्यम से)।
मैं अगले दो अध्यायों में इसका उपयोग करूंगा, क्योंकि दोहराने के लिए नहीं, मैं इसे एक अलग मॉड्यूल में डालूंगा।

 unit CommonHotPatch; interface uses Windows; const LOCK_JMP_OPKODE: Word = $F9EB; type //      JMP NEAR OFFSET TNearJmpSpliceRec = packed record JmpOpcode: Byte; Offset: DWORD; end; THotPachSpliceData = packed record FuncAddr: FARPROC; SpliceRec: TNearJmpSpliceRec; LockJmp: Word; end; var HotPathSpliceRec: THotPachSpliceData; procedure InitHotPatchSpliceRec; procedure SpliceNearJmp(FuncAddr: Pointer; NewData: TNearJmpSpliceRec); procedure SpliceLockJmp(FuncAddr: Pointer; NewData: Word); implementation //         procedure SpliceNearJmp(FuncAddr: Pointer; NewData: TNearJmpSpliceRec); var OldProtect: DWORD; begin VirtualProtect(FuncAddr, SizeOf(TNearJmpSpliceRec), PAGE_EXECUTE_READWRITE, OldProtect); try Move(NewData, FuncAddr^, SizeOf(TNearJmpSpliceRec)); finally VirtualProtect(FuncAddr, SizeOf(TNearJmpSpliceRec), OldProtect, OldProtect); FlushInstructionCache(GetCurrentProcess, FuncAddr, SizeOf(TNearJmpSpliceRec)); end; end; //         procedure SpliceLockJmp(FuncAddr: Pointer; NewData: Word); var OldProtect: DWORD; begin VirtualProtect(FuncAddr, 2, PAGE_EXECUTE_READWRITE, OldProtect); try asm mov ax, NewData mov ecx, FuncAddr lock xchg word ptr [ecx], ax end; finally VirtualProtect(FuncAddr, 2, OldProtect, OldProtect); FlushInstructionCache(GetCurrentProcess, FuncAddr, 2); end; end; function InterceptedMessageBoxA(Wnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall; var S: AnsiString; begin //   SpliceLockJmp(HotPathSpliceRec.FuncAddr, HotPathSpliceRec.LockJmp); try //    S := AnsiString('Function interepted. Original message: ' + lpText); Result := MessageBoxA(Wnd, PAnsiChar(S), lpCaption, uType); finally //   SpliceLockJmp(HotPathSpliceRec.FuncAddr, LOCK_JMP_OPKODE); end; end; procedure InitHotPatchSpliceRec; begin //      HotPathSpliceRec.FuncAddr := GetProcAddress(GetModuleHandle(user32), 'MessageBoxA'); //      ,     Move(HotPathSpliceRec.FuncAddr^, HotPathSpliceRec.LockJmp, 2); //   JMP NEAR HotPathSpliceRec.SpliceRec.JmpOpcode := $E9; //    HotPathSpliceRec.SpliceRec.Offset := PAnsiChar(@InterceptedMessageBoxA) + 5 - PAnsiChar(HotPathSpliceRec.FuncAddr) - SizeOf(TNearJmpSpliceRec); end; end. 

एक अनुप्रयोग में इस मॉड्यूल का उपयोग करना सबसे तुच्छ है:

 unit uHotPachSplice; interface uses Windows, Classes, Controls, Forms, StdCtrls; type TForm1 = class(TForm) Button1: TButton; procedure FormCreate(Sender: TObject); procedure Button1Click(Sender: TObject); end; var Form1: TForm1; implementation uses CommonHotPatch; {$R *.dfm} procedure TForm1.FormCreate(Sender: TObject); begin //     InitHotPatchSpliceRec; //     NOP- SpliceNearJmp(PAnsiChar(HotPathSpliceRec.FuncAddr) - 5, HotPathSpliceRec.SpliceRec); //  MessageBoxW SpliceLockJmp(HotPathSpliceRec.FuncAddr, LOCK_JMP_OPKODE); end; procedure TForm1.Button1Click(Sender: TObject); const TestStr: AnsiString = 'Test MessageBoxA Message'; begin MessageBoxA(0, PAnsiChar(TestStr), nil, 0); end; end. 

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

8. जाल की स्थापना के माध्यम से पुस्तकालय का कार्यान्वयन।

स्थानीय अनुप्रयोग में अवरोधन से संबंधित सभी को ऊपर वर्णित किया गया था, लेकिन डेवलपर को किसी और की प्रक्रिया में हस्तक्षेप करने की कितनी सही आवश्यकता है।

आप किसी अन्य प्रक्रिया के शरीर में इंटरसेप्टर को कई तरीकों से रख सकते हैं, सबसे जटिल एक से - VirtualAllocEx के माध्यम से आवश्यक मेमोरी ब्लॉक का चयन करके और इसमें इंटरसेप्टर कोड लिखकर (मैं इसे नहीं मानूंगा), लाइब्रेरी लोड करके, सरल विकल्पों में।

एक इंटरसेप्टर को लागू करने का सबसे आसान तरीका एक वैश्विक जाल द्वारा एक विदेशी पते की जगह में भरी हुई लाइब्रेरी के शरीर में इंटरसेप्टर कोड डालना है।

पुस्तकालय लोडर कोड इस तरह दिखता है:

 program hook_loader; {$APPTYPE CONSOLE} uses Windows; var hLib: THandle; HookProcAddr: Pointer; HookHandle: HHOOK; begin hLib := LoadLibrary('hook_splice_lib.dll'); try HookProcAddr := GetProcAddress(hLib, 'HookProc'); Writeln('MessageBoxA intercepted, press ENTER to resume...'); HookHandle := SetWindowsHookEx(WH_GETMESSAGE, HookProcAddr, hLib, 0); Readln; UnhookWindowsHookEx(HookHandle); finally FreeLibrary(hLib); end; end. 

जैसे ही SetWindowsHookEx फ़ंक्शन को निष्पादित किया जाता है, एक वैश्विक जाल स्थापित किया जाएगा, जिसमें से हैंडलर hook_splice_lib.dll लाइब्रेरी में स्थित है। यह लाइब्रेरी स्वचालित रूप से GetMessage या PeekMessage फ़ंक्शन को कॉल करके संदेश कतार के साथ काम करने वाली सभी प्रक्रियाओं में लोड हो जाएगी।

लाइब्रेरी कोड इंटरसेप्शन के उपरोक्त उदाहरणों में से एक को दोहराता है:

 library hook_splice_lib; uses Windows, CommonHotPatch in '..\common\CommonHotPatch.pas'; {$R *.res} procedure DLLEntryPoint(dwReason: DWORD); begin case dwReason of DLL_PROCESS_ATTACH: begin //     InitHotPatchSpliceRec; //     NOP- SpliceNearJmp(PAnsiChar(HotPathSpliceRec.FuncAddr) - 5, HotPathSpliceRec.SpliceRec); //  MessageBoxW SpliceLockJmp(HotPathSpliceRec.FuncAddr, LOCK_JMP_OPKODE); end; DLL_PROCESS_DETACH: begin //      SpliceLockJmp(HotPathSpliceRec.FuncAddr, HotPathSpliceRec.LockJmp); end; end; end; function HookProc(Code: Integer; WParam: WPARAM; LParam: LPARAM): LRESULT; stdcall; begin Result := CallNextHookEx(0, Code, WParam, LParam); end; exports HookProc; begin DLLProc := @DLLEntryPoint; DLLEntryPoint(DLL_PROCESS_ATTACH); end. 

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

इंटरसेप्टर DLLEntryPoint में स्थापित किया गया है जब यह DLL_PROCESS_ATTACH लोड करने की सूचना प्राप्त करता है, जब यह DLL_PROCESS_DETACH उतारने की सूचना प्राप्त करता है, तो इंटरसेप्टर हटा दिया जाता है।

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

9. एक दूरस्थ प्रक्रिया में एक धागा बनाकर एक पुस्तकालय की तैनाती।

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

 program test_console8; {$APPTYPE CONSOLE} uses Windows; begin Writeln('Press enter to show message...'); Readln; MessageBoxA(0, 'First message', '', 0); Writeln('Press enter to show message...'); Readln; MessageBoxA(0, 'Second message', '', 0); end. 

कंसोल एप्लिकेशन आमतौर पर संदेश कतार के साथ काम नहीं करता है और एक नियम के रूप में GetMessage या PeekMessage फ़ंक्शन को कॉल का उपयोग नहीं करता है, इसलिए, जब पहला संदेश प्रदर्शित होता है, तो इसे इंटरसेप्ट नहीं किया जाएगा।

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

इस व्यवहार से बचने के लिए (कंसोल में पहले मैसेजबॉक्स कॉल को इंटरसेप्ट करने में असमर्थता), आप लाइब्रेरी को लोड करने के लिए बाध्य कर सकते हैं, प्रक्रिया पहचानकर्ता (पीआईडी) को जानते हुए।

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

 procedure SelfUnload(lpParametr: Pointer); stdcall; begin FreeLibraryAndExitThread(HInstance, 0); end; exports SelfUnload; 

पुस्तकालय का कार्यान्वयन निम्नलिखित कोड के साथ किया जाता है:

 const DllName = 'thread_splice_lib.dll'; function InjectLib(ProcessID: Integer): Boolean; var Process: HWND; ThreadRtn: FARPROC; DllPath: AnsiString; RemoteDll: Pointer; BytesWriten: DWORD; Thread: DWORD; ThreadId: DWORD; begin Result := False; //   Process := OpenProcess(PROCESS_CREATE_THREAD or PROCESS_VM_OPERATION or PROCESS_VM_WRITE, True, ProcessID); if Process = 0 then Exit; try //       DllPath := AnsiString(ExtractFilePath(ParamStr(0)) + DLLName) + #0; RemoteDll := VirtualAllocEx(Process, nil, Length(DllPath), MEM_COMMIT or MEM_TOP_DOWN, PAGE_READWRITE); if RemoteDll = nil then Exit; try //         if not WriteProcessMemory(Process, RemoteDll, PChar(DllPath), Length(DllPath), BytesWriten) then Exit; if BytesWriten <> DWORD(Length(DllPath)) then Exit; //     Kernel32.dll ThreadRtn := GetProcAddress(GetModuleHandle('Kernel32.dll'), 'LoadLibraryA'); if ThreadRtn = nil then Exit; //    Thread := CreateRemoteThread(Process, nil, 0, ThreadRtn, RemoteDll, 0, ThreadId); if Thread = 0 then Exit; try //     ... Result := WaitForSingleObject(Thread, INFINITE) = WAIT_OBJECT_0; finally CloseHandle(Thread); end; finally VirtualFreeEx(Process, RemoteDll, 0, MEM_RELEASE); end; finally CloseHandle(Process); end; end; 

इस पद्धति का सिद्धांत रिक्टर द्वारा वर्णित किया गया था, इसलिए मैं उस पर ध्यान नहीं दूंगा।
और उतारने के लिए, आपको निम्नलिखित कोड लागू करने की आवश्यकता है:

 function ResumeLib(ProcessID: Integer): Boolean; var hLibHandle: THandle; hModuleSnap: THandle; ModuleEntry: TModuleEntry32; OpCodeData: Word; Process: HWND; BytesWriten: DWORD; Thread: DWORD; ThreadId: DWORD; ExitCode: DWORD; PLibHandle: PDWORD; OpCode: PWORD; CurrUnloadAddrOffset: DWORD; UnloadAddrOffset: DWORD; begin Result := False; //          hLibHandle := LoadLibrary(PChar(DLLName)); try UnloadAddrOffset := DWORD(GetProcAddress(hLibHandle, 'SelfUnload')) - hLibHandle; if UnloadAddrOffset = -hLibHandle then Exit; finally FreeLibrary(hLibHandle); end; //        hModuleSnap := CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ProcessID); if hModuleSnap <> INVALID_HANDLE_VALUE then try FillChar(ModuleEntry, SizeOf(TModuleEntry32), #0); ModuleEntry.dwSize := SizeOf(TModuleEntry32); if not Module32First(hModuleSnap, ModuleEntry) then Exit; repeat if AnsiUpperCase(ModuleEntry.szModule) = AnsiUpperCase(DLLName) then begin //     CurrUnloadAddrOffset := ModuleEntry.hModule + UnloadAddrOffset; Break; end; until not Module32Next(hModuleSnap, ModuleEntry); finally CloseHandle(hModuleSnap); end; //   Process := OpenProcess(PROCESS_CREATE_THREAD or PROCESS_VM_OPERATION or PROCESS_VM_WRITE, True, ProcessID); if Process = 0 then Exit; try //   jmp [ebx] OpCode := VirtualAllocEx(Process, nil, 2, MEM_COMMIT or MEM_TOP_DOWN, PAGE_READWRITE); if OpCode = nil then Exit; try OpCodeData := $23FF; if not WriteProcessMemory(Process, OpCode, @OpCodeData, 2, BytesWriten) then Exit; //     (    EBX   ) PLibHandle := VirtualAllocEx(Process, nil, 4, MEM_COMMIT or MEM_TOP_DOWN, PAGE_READWRITE); if PLibHandle = nil then Exit; try if not WriteProcessMemory(Process, PLibHandle, @CurrUnloadAddrOffset, 4, BytesWriten) then Exit; //   Thread := CreateRemoteThread(Process, nil, 0, OpCode, PLibHandle, 0, ThreadId); if Thread = 0 then Exit; try //     ... if (WaitForSingleObject(Thread, INFINITE) = WAIT_OBJECT_0) then if GetExitCodeThread(Thread, ExitCode) then Result := ExitCode = 0; finally CloseHandle(Thread); end; finally VirtualFreeEx(Process, PLibHandle, 0, MEM_RELEASE); end; finally VirtualFreeEx(Process, OpCode, 0, MEM_RELEASE); end; finally CloseHandle(Process); end; end; 

यहां हम एक अनकम्डेडेड मेकेनिज्म का उपयोग करते हैं जो विंडोज 2000 से विंडोज 7 तक लाइनों में काम करता है (मैंने इसे आठ पर नहीं देखा है, लेकिन तर्क वहीं होगा)। तथ्य यह है कि CreateRemoteThread फ़ंक्शन के lpParameter पैरामीटर में दिया गया मान हमेशा EBX रजिस्टर में रखा जाता है जब थ्रेड दूरस्थ अनुप्रयोग में शुरू होता है। इस कोड का कार्य JMP [EBX] निर्देश को रखना है जिसके साथ धागा दूरस्थ प्रक्रिया में काम करना शुरू करेगा। यदि SelfUnload प्रक्रिया का पता EBX में स्थित है, तो नियंत्रण इसे स्थानांतरित कर दिया जाएगा, लेकिन इस प्रक्रिया के अंदर, लाइब्रेरी को उतारने और वर्तमान थ्रेड को बंद करने के लिए कोड पहले ही लागू किया जा चुका है।

आप निश्चित रूप से SelfUnload फ़ंक्शन से सीधे अनलोडिंग तंत्र को तुरंत शुरू कर सकते हैं, लेकिन मैं वास्तव में इस पल को दिखाना चाहता था, इसलिए बहुत अधिक डांटे नहीं :)

10. निगरानी करना

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

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

• आने वाले मापदंडों को हमेशा लॉग इन किया जाता है जब तक कि मूल फ़ंक्शन को इंटरसेप्टर में नहीं बुलाया जाता है।
• आउटगोइंग पैरामीटर हमेशा मूल इंटरसेप्टेड फ़ंक्शन को कॉल करने के बाद लॉग होते हैं।
• यदि पैरामीटर IN / OUT के रूप में घोषित किया जाता है, तो हम डबल-लॉग करते हैं।

मुझे नहीं पता कि क्यों, लेकिन मेरे "छात्रों" के पास इस पहलू पर एक पकड़ थी, उन्होंने लगातार रीडिंग को कॉल करने से पहले लॉगिंग के आदेश को भ्रमित कर दिया, और डेटा बफर की कमी से आश्चर्यचकित थे।

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

11. संक्षेप करना

यह संभवतः अवरोधन तकनीकों के वर्णन के साथ खत्म करने के लायक है। हां, वे वास्तव में व्यावहारिक रूप से नहीं रहे। मैं कोर में अवरोधन के तरीकों का वर्णन करने के बिंदु को नहीं देखता। यह पहले से ही डेल्फी समुदाय के लिए एक लेख नहीं होगा, साथ ही मैं अतिप्रवाह पर अवरोधन के साथ चाल पर भी विचार नहीं करूंगा। सिद्धांत को समझाने के लिए बहुत लंबा क्यों और कैसे "यह काम किया।"

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

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

लेख के उदाहरण इस लिंक पर लिए जा सकते हैं

सफल निगरानी।

अलेक्जेंडर (Rouse_) बागेल
जनवरी, 2013