TO როგორ დავიწყოთ გამართვის სესია

უმარტივესი გზაა OllyDbg-ის გაშვება, აირჩიეთ File -> Open და აირჩიეთ პროგრამა, რომლის გამართვაც გსურთ. თუ ეს პროგრამა მოითხოვს ბრძანების სტრიქონის რომელიმე პარამეტრს, ჩაწერეთ ისინი დიალოგური ფანჯრის ბოლოში მდებარე ველში ან აირჩიეთ წინა სესიებში გამოყენებული პარამეტრის ერთ-ერთი ხაზი.

OllyDbg-ს შეუძლია დამოუკიდებელი DLL-ების გამართვა. ამ შემთხვევაში, OllyDbg ქმნის და აწარმოებს პატარა აპლიკაციას, რომელიც იტვირთება ბიბლიოთეკა და, თქვენი მოთხოვნით, გამოიძახებს ექსპორტირებულ ფუნქციებს.
თუ გსურთ გადატვირთოთ ბოლო პროგრამა, რომელსაც გამართავდით, უბრალოდ დააჭირეთ Ctrl+F2 (ეს არის პროგრამის გადატვირთვის ცხელი გასაღები) და OllyDbg გაუშვებს მას იგივე პარამეტრებით. გარდა ამისა, აირჩიეთ ფაილი მენიუ და შემდეგ პროგრამა ისტორიიდან. თქვენ ასევე შეგიძლიათ გადმოიტანოთ შესრულებადი ფაილი ან DLL Windows Explorer-დან და ჩააგდოთ მისი ხატულა OllyDbg-ზე.

რა თქმა უნდა, OllyDbg-ის გაშვებისას ბრძანების სტრიქონზე შეგიძლიათ მიუთითოთ პროგრამის სახელი და მისი პარამეტრები. მაგალითად, შეგიძლიათ შექმნათ დესკტოპის მალსახმობი, რომელიც მიუთითებს OllyDbg-ზე, აირჩიეთ თვისებები, გადადით პროგრამის მალსახმობაზე და დაამატეთ პროგრამის სახელი ბრძანების სტრიქონში. ყოველ ჯერზე, როცა ორჯერ დააწკაპუნებთ ამ მალსახმობზე, OllyDbg ავტომატურად გაუშვებს თქვენს პროგრამას. გთხოვთ გაითვალისწინოთ, რომ DLL-ები არ უჭერენ მხარს ბრძანების ხაზს.

თქვენ შეგიძლიათ დაურთოთ OllyDbg გაშვებულ პროცესს. აირჩიეთ ფაილი -> მიმაგრება და აირჩიეთ პროცესი სიიდან. ამასთან, გაითვალისწინეთ, რომ OllyDbg-ის დახურვის შემდეგ, ეს პროცესიც გამოვა. არასოდეს შეეცადოთ სისტემის პროცესზე მიმაგრება; ამან შეიძლება გამოიწვიოს ოპერაციული სისტემის ავარია. (სამართლიანი რომ ვიყოთ, უმეტეს შემთხვევაში ოპერაციული სისტემა არ მოგცემთ სენსიტიურ პროცესს მიმაგრების საშუალებას).

OllyDbg-ს შეუძლია იმოქმედოს როგორც დროული JIT-ის გამართვა. ეს მოითხოვს რეგისტრაციას სისტემის რეესტრში. აირჩიეთ Options -> Just-in-time Debugging და დიალოგში, რომელიც გამოჩნდება, აირჩიეთ "Make OllyDbg just-in-time debugger" ). ახლა, როდესაც აპლიკაცია ავარიულია, მოგეკითხებათ, გსურთ თუ არა ამ აპლიკაციის გამართვა. შემდეგ ოპერაციული სისტემა გამოუშვებს OllyDbg-ს, რომელიც გაჩერდება პირდაპირ იმ წერტილში, სადაც მოხდა მარცხი. ან, თუ თქვენ გადაწყვიტეთ შეერთება დადასტურების გარეშე, OllyDbg დაიწყება ყოველგვარი კითხვების გარეშე. წინა „უბრალოდ დროულად“ გამართვის აღსადგენად დააწკაპუნეთ შესაბამის ღილაკზე აღნიშნულ დიალოგში და ეს არის.

ასევე არის კიდევ ერთი ვარიანტი, რომ დაამატოთ OllyDbg კონტექსტურ მენიუში, რომელიც დაკავშირებულია Windows Explorer-ის შემსრულებელ ფაილებთან. (ეს იდეა ეკუთვნის იოხენგერსტერს). OllyDbg-ის მთავარი მენიუდან აირჩიეთ “Options|Add to Explorer”, შემდეგ დააწკაპუნეთ “Add OllyDbg to menu in Windows Explorer”. ამის შემდეგ, შეგიძლიათ დააწკაპუნოთ შესრულებად ფაილზე, ან DLL-ზე და მენიუდან აირჩიეთ OllyDbg. ეს პარამეტრი ქმნის 4 გასაღებს სისტემის რეესტრში:

HKEY_CLASSES_ROOT\exefile\shell\Open with OllyDbg
HKEY_CLASSES_ROOT\exefile\shell\OlyDbg\command-ით გახსნა
HKEY_CLASSES_ROOT\dllfile\shell\OllyDbg-ით გახსნა
HKEY_CLASSES_ROOT\dllfile\shell\გახსნა OllyDbg\command-ით

OllyDbg-ს შეუძლია კონსოლის აპლიკაციების გამართვა (ტექსტზე დაფუძნებული).

OllyDbg-ს არ შეუძლია გამართოს .NET აპლიკაციები. .NET პროგრამები შედგება ფსევდოკოდისგან, რომელსაც Windows ინტერპრეტაციას ან აწყობს ფრენის დროს "86" ბრძანებებში.

გაითვალისწინეთ, რომ თუ იყენებთ Windows NT, 2000 ან XP, სავარაუდოდ დაგჭირდებათ ადმინისტრატორის უფლებები პროგრამების გამართვისთვის.

შესვენების წერტილები (საკონტროლო წერტილები)

OllyDbg მხარს უჭერს რამდენიმე ტიპის წყვეტის წერტილებს:

- რეგულარული წყვეტის წერტილი, ბრძანების პირველი ბაიტი, რომელზეც გსურთ გაჩერება, ჩანაცვლებულია სპეციალური INT3 (Debugger Trap) ბრძანებით. ამ წყვეტის წერტილის დაყენება შეგიძლიათ Disassembler პანელში საჭირო ბრძანების არჩევით და F2-ზე დაჭერით ან კონტექსტური მენიუდან. როდესაც მეორედ დააჭერთ F2-ს, წყვეტის წერტილი წაიშლება. გაითვალისწინეთ, რომ პროგრამა ჩერდება ბრძანების შესრულებამდე breakpoint კომპლექტით. INT3 წყვეტის წერტილების რაოდენობა, რომელთა დაყენება შეგიძლიათ, შეუზღუდავია. როდესაც თქვენ დახურავთ პროგრამას, რომელსაც ახდენთ გამართვა, ან Debugger-ს, OllyDbg ავტომატურად ინახავს წყვეტის წერტილებს დისკზე. არასოდეს შეეცადოთ დააყენოთ ამ ტიპის წყვეტის წერტილი მონაცემებზე ან ბრძანების შუაში! OllyDbg გაგაფრთხილებთ, თუ შეეცდებით დააყენოთ წყვეტის წერტილი კოდის განყოფილების გარეთ. შეგიძლიათ გამორთოთ ეს გაფრთხილება უსაფრთხოების ვარიანტებში. ზოგიერთ შემთხვევაში, Debugger-მა შეიძლება ჩადოს თავისი დროებითი INT3 წყვეტის წერტილები.

- პირობითი წყვეტის წერტილი(Shift+F2) - ჩვეულებრივი INT3 წყვეტის წერტილი ასოცირებული პირობით. როდესაც Debugger ხვდება ამ წყვეტის წერტილს, ის აფასებს მდგომარეობას და თუ შედეგი არ არის ნულოვანი ან პირობა არასწორია, ის აჩერებს პროგრამის გამართვას. თუმცა, არასწორი პირობითი წყვეტის წერტილით გამოწვეული გადადინების ალბათობა ძალიან მაღალია (ძირითადად ოპერაციული სისტემის შეყოვნების გამო). PII 450-ზე Windows NT-ში, OllyDbg ამუშავებს 2500-მდე ყალბ პირობით წყვეტს წამში. პირობითი წყვეტის წერტილის მნიშვნელოვანი შემთხვევაა შეჩერება Windows შეტყობინებებზე (როგორიცაა WM_PAINT). ამ მიზნით, შეგიძლიათ გამოიყენოთ ფსევდო ცვლადი MSG პარამეტრების სათანადო ინტერპრეტაციასთან ერთად. თუ ფანჯარა აქტიურია, იხილეთ ქვემოთ აღწერილი შეტყობინების წყვეტის წერტილი.

- პირობითი შესვენების წერტილი ჩაწერით(Shift+F4) - პირობითი წყვეტის წერტილი, რომელსაც შეუძლია დაარეგისტრიროს ცნობილი ფუნქციის ზოგიერთი გამონათქვამის ან პარამეტრის მნიშვნელობა ყოველ ჯერზე, როდესაც წყვეტის წერტილი ამოქმედდება ან როდესაც დაყენებული პირობა დაკმაყოფილებულია. მაგალითად, შეგიძლიათ დააყენოთ ჩაწერის წყვეტის წერტილი რომელიმე ფანჯრის პროცედურაზე, რათა ჩაწეროთ ყველა ზარი ამ პროცედურაზე (CALL), ან მხოლოდ მიღებული WM_COMMAND შეტყობინებების იდენტიფიკატორები, ან დააყენოთ CreateFile ზარზე და ჩაწეროთ მხოლოდ წაკითხვადი ფაილების სახელები. და ა.შ. შესვლის წყვეტის წერტილი ისეთივე სწრაფია, როგორც პირობითი წყვეტის წერტილი და, რა თქმა უნდა, ბევრად უფრო ადვილია რამდენიმე ასეული შეტყობინების გადახედვა ჟურნალის ფანჯარაში, ვიდრე F9-ის რამდენიმე ასეულჯერ დაჭერა. ამ გზით თქვენ შეგიძლიათ აირჩიოთ უფრო შესაფერისი ინტერპრეტაცია თქვენი მდგომარეობისთვის.

შეგიძლიათ დააყენოთ საშვი მრიცხველი - მრიცხველი, რომელიც მცირდება ყოველ ჯერზე გაჩერების პირობის დაკმაყოფილებისას. თუ შემცირებამდე პასების რაოდენობა არ არის ნული, OllyDbg გააგრძელებს შესრულებას. განვიხილოთ მარყუჟი, რომელიც გადის 100 (ათწილადი) ჯერ. დავდოთ წყვეტის წერტილი შუაში და დავაყენოთ მნიშვნელობა 99. (ათწილადი). OllyDbg შეწყვეტს ბოლო გამეორებას.

გარდა ამისა, შესვლის პირობითი წერტილი საშუალებას გაძლევთ გასცეთ ერთი ან მეტი ბრძანება დანამატებზე. მაგალითად, ეს შეიძლება იყოს მოთხოვნა ბრძანების ხაზის მოდულისთვის, რომ შეცვალოს რეესტრის შინაარსი და გააგრძელოს.

- შესვენების შეტყობინებები- იგივეა, რაც წყვეტის წერტილი ჩაწერის პირობით, გარდა იმისა, რომ OllyDbg ავტომატურად აგენერირებს მდგომარეობას, რომელიც საშუალებას გაძლევთ დაარღვიოთ რაიმე შეტყობინება (როგორიცაა WM_PAINT) ფანჯრის პროცედურის შესვლის წერტილში. შეგიძლიათ დააინსტალიროთ ვინდოუს ყუთში.

- კვალი გაწყვეტის წერტილი(Trace breakpoint) - INT3 წყვეტის წერტილების კრიტიკული შემთხვევა, რომელიც მითითებულია თითოეულ მითითებულ ბრძანებაზე. თუ თქვენ აკეთებთ დარტყმის კვალს, წყვეტის წერტილი წაიშლება და მისამართი მოინიშნება როგორც მიღებულ ბრძანების მიღწევის შემდეგ. თუ თქვენ იყენებთ გაშვების კვალს, OllyDbg დაამატებს ჩანაწერს ტრასის ჟურნალში და წყვეტის წერტილი დარჩება აქტიური. .

- შესვენების წერტილი მეხსიერებისთვის. OllyDbg საშუალებას გაძლევთ დააყენოთ მხოლოდ ერთი წყვეტის წერტილი თითო მეხსიერებაზე. თქვენ ირჩევთ მეხსიერების გარკვეულ ნაწილს CPU ფანჯრის Disassembler ან Dump პანელებში და იყენებთ კონტექსტურ მენიუს მეხსიერების წყვეტის წერტილის დასაყენებლად. წინა მეხსიერების წყვეტის წერტილი, თუ ასეთი იყო, ავტომატურად წაიშლება. თქვენ გაქვთ ორი ვარიანტი: შეწყვეტა მეხსიერების წვდომაზე (კითხვა, ჩაწერა ან შესრულება მეხსიერებაში) ან შეწყვეტა მხოლოდ ჩაწერის დროს. ამ წყვეტის წერტილის დასაყენებლად, OllyDbg ცვლის მეხსიერების ბლოკების ატრიბუტებს, რომლებიც შეიცავს განაწილებას. 80x86-თან თავსებად პროცესორებზე მეხსიერება ნაწილდება და დაცულია 4096 ბაიტიან ბლოკებში. თუ თქვენ აირჩევთ თუნდაც ერთ ბაიტს, OllyDbg-ს მოუწევს დაიცვას მთელი ბლოკი. ამან შეიძლება გამოიწვიოს მრავალი ცრუ სიგნალიზაცია უზარმაზარი გადინებით. გამოიყენეთ ამ ტიპის წყვეტის წერტილი სიფრთხილით. ზოგიერთი სისტემის ფუნქცია (განსაკუთრებით Windows 95/98) იწვევს პროგრამის გამართვის გათიშვას დაცულ მეხსიერებაზე წვდომისას გამართვის მოვლენის გენერირების ნაცვლად.

- ტექნიკის გაწყვეტის წერტილი(ხელმისაწვდომია მხოლოდ Windows ME, NT, 2000 ან XP-ზე). 80x86-თან თავსებადი პროცესორები საშუალებას გაძლევთ დააყენოთ 4 ტექნიკის წყვეტის წერტილი. მეხსიერების წყვეტის წერტილისგან განსხვავებით, ტექნიკის წყვეტის წერტილები არ ანელებს შესრულების სიჩქარეს, არამედ ფარავს მხოლოდ 4 ბაიტს. OllyDbg-ს შეუძლია გამოიყენოს ტექნიკის წყვეტის წერტილები INT3-ის ნაცვლად კოდის შესრულების ან სკანირებისას.

- მეხსიერების ერთჯერადი წვდომის შეწყვეტა(ერთჯერადი შესვენება მეხსიერების წვდომაზე) (ხელმისაწვდომია მხოლოდ Windows NT, 2000 და XP-ში). თქვენ დააყენეთ იგი მეხსიერების ფანჯარაში მეხსიერების მთელ ბლოკზე კონტექსტური მენიუდან ან F2 დაჭერით. ეს წყვეტის წერტილი განსაკუთრებით სასარგებლოა, თუ გსურთ ზარის დაჭერა ან რომელიმე მოდულში დაბრუნება. გაჩერების დასრულების შემდეგ, წყვეტის წერტილი ამოღებულია.

- ნორმალური მიკვლევის შეჩერება(Run trace pause) (Ctrl+T) - პირობების დაყენება, რომლებიც მოწმდება გაშვების ტრასის პროცესის ყოველ საფეხურზე. თქვენ შეგიძლიათ შეაჩეროთ გაშვების კვალი, როდესაც EIP შედის ან ტოვებს სხვა დიაპაზონს, ან როდესაც პირობა არის ჭეშმარიტი, ან როდესაც ბრძანება ემთხვევა ერთ-ერთ მითითებულ შაბლონს, ან როდესაც ბრძანება საეჭვოა, ან ბრძანებების განსაზღვრული რაოდენობის მიკვლევის შემდეგ. . გთხოვთ გაითვალისწინოთ, რომ ამ პარამეტრს შეუძლია მნიშვნელოვნად (20-მდე) შეანელოს გაშვების ტრასის სიჩქარე.

OllyDbg-ს ასევე შეუძლია შეაჩეროს პროგრამის შესრულება გარკვეული გამართვის მოვლენებზე, როგორიცაა DLL-ის ჩატვირთვა ან გადმოტვირთვა, თემის დაწყება ან მოკვლა, ან როდესაც პროგრამა აგზავნის გამართვის სტრიქონს.

ნაგავსაყრელი

Dump ფანჯარა აჩვენებს მეხსიერების ან ფაილის შინაარსს. თქვენ შეგიძლიათ აირჩიოთ რამდენიმე კონკრეტული ფორმატიდან: ბაიტი, ტექსტი, მთელი რიცხვი, float, მისამართი, დაშლა ან PE Header.

ყველა ნაგავსაყრელი ფანჯარა მხარს უჭერს სარეზერვო, ძიების და რედაქტირების ფუნქციებს. CPU ფანჯრის Dump ფანჯრის ზონა საშუალებას გაძლევთ განსაზღვროთ ნიშნები, დააყენოთ წყვეტის წერტილები მეხსიერებაზე, იპოვოთ მონაცემების მითითებები შესრულებად კოდში და არჩეული მეხსიერების ღია გამოსახულება შესრულებად ფაილში (.exe ან .dll). Dump მენიუ აჩვენებს ხელმისაწვდომი ბრძანებების მხოლოდ შედარებით კომპლექტს.

თუ სარეზერვო ასლი ხელმისაწვდომია, დააწკაპუნეთ მისამართზე/სარეზერვო პანელზე, რათა გადართოთ ჩვენების რეჟიმი სარეზერვო და ნორმალურ ხედს შორის. პანელის სხვა ღილაკები საშუალებას გაძლევთ შეცვალოთ ნაგავსაყრელის რეჟიმები.

Disassembler-ის ფანჯრის მსგავსად, Dump ინახავს მონახულებული მეხსიერების მდებარეობის ხანგრძლივ ისტორიას. თქვენ შეგიძლიათ გადაადგილდეთ ისტორიაში "+" ან "-" ღილაკების დაჭერით.

მონაცემების გადასასვლელად, გეჭიროთ Ctrl ღილაკი და დააჭირეთ ზევით/ქვევით ისრებს.

მოდულები

გაშვებული მოდულების ფანჯარა (კლავიატურის მალსახმობი: Alt+E) ჩამოთვლის ყველა მოდულს, რომლებიც ამჟამად დატვირთულია გამართვის პროცესით. ეს ფანჯარა ასევე აჩვენებს სასარგებლო ინფორმაციას, როგორიცაა მოდულის ზომა, შესვლის მისამართი, მოდულის ვერსია ან შესრულებადი გზა. ზოგიერთი ინფორმაცია, როგორიცაა ათობითი მოდულის ზომა, შესვლის წერტილის სიმბოლური სახელი და ა.შ., ჩვეულებრივ დამალულია სისტემის მიერ. ამ მონაცემების სანახავად გაზარდეთ შესაბამისი სვეტების სიგანე. კონტექსტური მენიუ მხარს უჭერს შემდეგ ვარიანტებს:

აქტუალიზაცია - ხელახლა სკანირებს მოდულებს და ხსნის ხაზგასმას ახალი მოდულებიდან. უმეტეს დროს, OllyDbg ზრუნავს საკუთარ თავზე.

მეხსიერების ნახვა - ხსნის მეხსიერების ფანჯარას და გადადის მეხსიერების პირველ ბლოკზე, რომელიც ეკუთვნის გამოსახულ მოდულს.

იხილეთ კოდი CPU-ში - ხსნის მოდულის შესრულებად კოდს Disassembler-ში.

Follow entry - მიჰყვება მოდულის შესვლის წერტილს Disassembler-ში

გადაყარეთ მონაცემები CPU-ში - ხსნის მოდულის მონაცემთა განყოფილებას CPU Dump-ში.

სახელების ნახვა (Ctrl+N) - აჩვენებს ცხრილს, რომელიც შეიცავს ყველა სახელს (ექსპორტი, იმპორტი, ბიბლიოთეკა, მომხმარებლის მიერ განსაზღვრული) განსაზღვრული ან გამოყენებული მიმდინარე მოდულში.

მონიშნეთ, როგორც სისტემის DLL
მონიშვნა როგორც არასისტემური DLL - მონიშნავს არჩეულ მოდულს სისტემურად ან არასისტემურად. მოდულის სისტემად მონიშვნით, თქვენ გამორიცხავთ მას Trace-დან, რაც მნიშვნელოვნად აჩქარებს მის შესრულებას. ნაგულისხმევად, სისტემის მოდულები არის მოდულები, რომლებიც მუდმივად მდებარეობს სისტემის დირექტორიაში (ჩვეულებრივ, c:\windows\system Windows 95/98-ზე, c:\winnt\system32 NT/2000/XP-ზე).

განაახლეთ .udd ფაილი ახლა - ჩაწერს ამ მოდულზე დამოკიდებულ ყველა მონაცემს ფაილში .უდდ. .udd ფაილები ინახავს წყვეტის წერტილებს, ნიშნებს, კომენტარებს, დამკვირვებლებს, ანალიზს და ა.შ. გამართვის სესიებს შორის. OllyDbg ავტომატურად ქმნის .udd ფაილს მოდულის გადმოტვირთვისას.

შესრულებადი ფაილის ნახვა - აჩვენებს შესრულებადი ფაილის ნაგავსაყრელს.

ყველა რესურსის ნახვა - აჩვენებს მოდულში განსაზღვრული ყველა რესურსის სიას მოკლე ინფორმაციასთან ერთად. OllyDbg არ უჭერს მხარს რესურსებს, როგორც ცალკეულ ობიექტს; ყველაფერი რაც შეგიძლიათ გააკეთოთ არის რესურსის გადაყრა და ორობითი ფორმით რედაქტირება.

რესურსების სტრიქონების ნახვა - აჩვენებს სტრიქონების რესურსების სიას და მათ ID-ებს.

გაშვების კვალი პროფილის ნახვა - ითვლის ამ მოდულის პროფილს. აგრეთვე იხილეთ Run trace.

გაანალიზეთ ყველა მოდული - საშუალებას გაძლევთ გაანალიზოთ ყველა მოდული ერთდროულად. ანალიზი ამოიღებს სასარგებლო ინფორმაციას დატვირთული კოდიდან; გამართვა ჩვეულებრივ უფრო სწრაფი და საიმედოა კოდის გაანალიზების შემდეგ.
ხაზზე ორჯერ დაწკაპუნებით, თქვენ გადახვალთ მოდულში გაშვებულ კოდზე Disassembler პანელში.

Მეხსიერების ბარათი

მეხსიერების რუქის ფანჯარა აჩვენებს ყველა მეხსიერების ბლოკს, რომელიც გამოიყენება პროგრამის მიერ გამართული. არ არსებობს სტანდარტული ინსტრუმენტები ამ ამოცანის შესასრულებლად, ასე რომ, შეიძლება მოხდეს, რომ OllyDbg აერთიანებს განაწილებული მეხსიერების რამდენიმე ნაწილს ერთ დიდ მეხსიერების ბლოკში. თუმცა, უმეტეს შემთხვევაში არ არის საჭირო ზუსტი გადაწყვეტა. იმისათვის, რომ მიიღოთ აპლიკაციის მიერ მოთხოვნილი მეხსიერების ბლოკების სია GlobalAlloc(), LocalAlloc() და ა.შ. გამოძახებით, გამოიყენეთ Heap list.

თუ მეხსიერების ბლოკი არის ზოგიერთი შესრულებადი მოდულის განყოფილება, OllyDbg გეტყვით რა სახის მონაცემებს შეიცავს ბლოკი: კოდი, მონაცემები, რესურსები და ა.შ.

არსებობს გარკვეული განსხვავებები Windows 95/98-სა და Windows NT/2000-ს შორის. Windows 95/98-ში, OllyDbg არ შეუძლია აჩვენოს ნაჩვენები ფაილების სახელები. ასევე, Windows 95/98 ზღუდავს მეხსიერების წვდომის დაშვებულ ტიპებს: კითხვას და ჩაწერას. გასათვალისწინებელია ისიც, რომ Windows NT/2000-ს აქვს შესაძლებლობების გაცილებით ფართო სპექტრი, მათ შორის წვდომის შესრულება, კოპირება ჩაწერაზე და დაცვის დროშა. OllyDbg უგულებელყოფს კოპირება-ჩაწერის ატრიბუტს.

თუ OllyDbg აღიარებს, რომ პროგრამამ გამოყო ახალი ან გადაანაწილა არსებული მეხსიერების ბლოკი, მაშინ OllyDbg ხაზს უსვამს შესაბამის ჩანაწერს მეხსიერების რუკის ფანჯარაში. ყველა მონიშვნის აღსადგენად, აირჩიეთ კონტექსტური მენიუდან Actualize.

მეხსიერების ფანჯრის გახსნა შეგიძლიათ Alt+M-ის დაჭერით.

კონტექსტური მენიუს შემდეგი ელემენტები ხელმისაწვდომია:

Actualize - განაახლებს გამოყოფილი მეხსიერების სიას და გამოყოფს მეხსიერების ახალ ბლოკებს.

ნახვა Disassembler-ში - ხსნის მეხსიერების ბლოკს Disassembler-ში. ეს პარამეტრი ხელმისაწვდომია მხოლოდ მაშინ, როდესაც მეხსიერების ბლოკი შეიცავს შესრულებად კოდს ან რომელიმე მოდულის თვითგამომყვანს.

Dump to CPU - აჩვენებს მეხსიერების ბლოკის შიგთავსს CPU Dump-ის ფანჯრის ზონაში.

Dump - ათავსებს მეხსიერების ბლოკის შიგთავსს ცალკე ფანჯარაში. თუ მეხსიერების ბლოკის ტიპი ცნობილია, OllyDbg ავტომატურად ირჩევს ნაგავსაყრელ ფორმატს.

ყველა რესურსის ნახვა - თუ ბლოკი შეიცავს რესურსის მონაცემებს, ყველა რესურსისა და დაკავშირებული მონაცემების სიას. OllyDbg არ უჭერს მხარს რესურსებს, როგორც ცალკეულ ობიექტს; ყველაფერი, რაც შეგიძლიათ გააკეთოთ რესურსებით, არის მათი გადაყრა და ორობითი ფორმატით რედაქტირება.

რესურსის სტრიქონების ნახვა - თუ ბლოკი შეიცავს რესურსის მონაცემებს, მაშინ Ollie ჩამოთვლის რესურსის ყველა სტრიქონს მათი ID-ებით.

ძიება - საშუალებას გაძლევთ მოძებნოთ მეხსიერების ყველა ბლოკი, დაწყებული გამოყოფილიდან, სანამ შეხვდებით ორობით სტრიქონს. თუ სტრიქონი ნაპოვნია, OllyDbg აჩვენებს ნაპოვნი მეხსიერების ბლოკის ნაგავსაყრელს. მეხსიერების რუკა და ნაგავსაყრელი ფანჯარა იზიარებს იგივე საძიებო ნიმუშს, ასე რომ თქვენ შეგიძლიათ დაუყოვნებლივ გააგრძელოთ ძებნა ნაგავსაყრელში მომდევნო შემთხვევამდე, რომელიც გამოჩნდება. თქვენ შეგიძლიათ დახუროთ ნაგავსაყრელი ფანჯარა Esc-ზე დაჭერით.

შესვენების დაყენება (F2; ხელმისაწვდომია მხოლოდ Windows NT/2000-ში) - იცავს მეხსიერების მთელ ბლოკს. წყვეტის წერტილის შემდეგ, OllyDbg აჩერებს პროგრამის გამართვას და შლის წყვეტის წერტილს. ეს წყვეტის წერტილი განსაკუთრებით სასარგებლოა, თუ გსურთ ზარის დაჭერა ან რომელიმე მოდულში დაბრუნება.

ამოღება შესვენების წვდომის (F2) - აშორებს დაყენებულ შესვენების წვდომას მეხსიერების ბლოკიდან.

დააყენეთ მეხსიერების წყვეტის წერტილი წვდომისას(Set breakpoint on memory access) - ადგენს წყვეტის წერტილს მეხსიერების წვდომაზე მთელ მეხსიერების ბლოკზე. პროგრამა შეწყდება ყოველ ჯერზე, როცა გამართული პროგრამა წვდება ამ მეხსიერების ბლოკს. OllyDbg მხარს უჭერს მხოლოდ ერთ წყვეტის წერტილს თითო მეხსიერებაზე. Windows 95/98-ის პირობებში, გამართული პროგრამა შეიძლება შეჩერდეს, როდესაც სისტემის რუტინები წვდებიან მეხსიერების ბლოკებს, რომლებიც შეიცავს წყვეტის წერტილს. გამოიყენეთ იგი როგორც უკანასკნელი საშუალება.

დააყენეთ მეხსიერების წყვეტის წერტილი ჩაწერაზე(Set breakpoint to write to memory) - ადგენს წყვეტის წერტილს მთელ მეხსიერების ბლოკზე. პროგრამა შეწყვეტს ყოველ ჯერზე, როდესაც ის ჩაწერს ამ მეხსიერების ბლოკში. Windows 95/98-ის პირობებში, გამართული პროგრამა შეიძლება შეჩერდეს, როდესაც სისტემის რუტინები წვდებიან მეხსიერების ბლოკებს, რომლებიც შეიცავს წყვეტის წერტილს. გამოიყენეთ იგი როგორც უკანასკნელი საშუალება.

SFX მეხსიერების წყვეტის წერტილის ამოღება - აჩერებს ძიებას შეფუთულ პროგრამაში (SFX) რეალურ შესვლის წერტილში. ეს ძიება იყენებს სპეციალური ტიპის მეხსიერების წყვეტის წერტილს.

წვდომის დაყენება- აყენებს მეხსიერების დაცვის სასურველ ატრიბუტს მთელი მეხსიერების ბლოკზე.
შესაძლო ვარიანტები:

წვდომა არ არის
Წაიკითხეთ მხოლოდ
Კითხვა წერა
შეასრულეთ
შესრულება / წაკითხვა

სრული წვდომა

კოპირება ბუფერში

მთელი ხაზი - აკოპირებს არჩეულ ჩანაწერს ბუფერში, როგორც მრავალსტრიქონიანი ტექსტი განმარტებებით. სვეტის კოპირებისგან გამორიცხვის მიზნით, შეამცირეთ მისი სიგანე მინიმუმამდე (სვეტის დანარჩენი ნაწილი ნაცრისფერი გახდება).

მთელი ცხრილი - აკოპირებს მთელ მეხსიერების ბარათს ბუფერში, როგორც მრავალხაზოვანი ტექსტი. ამ ტექსტის პირველი ხაზი შეიცავს ფანჯრის სათაურს ("MemoryMap"), მეორე სტრიქონი შეიცავს სვეტების სათაურებს და ყველა მომდევნო სტრიქონი შეიცავს მეხსიერების მონაცემების ჩანაწერებს. ასლი ინარჩუნებს სვეტების სიგანეს. იმისათვის, რომ არ მოხდეს სვეტის კოპირება, შეამცირეთ მისი სიგანე მინიმუმამდე (სვეტის დანარჩენი ნაწილი ნაცრისფერი გახდება).

დამკვირვებლები და ინსპექტორები

Observer-ის ფანჯარა შეიცავს რამდენიმე გამონათქვამს. ის აჩვენებს მათ მნიშვნელობებს მეორე სვეტში. OllyDbg ინახავს გამონათქვამებს ძირითადი მოდულის .udd ფაილში, ასე რომ, ისინი ხელმისაწვდომი იქნება შემდეგი გამართვისას.

ინსპექტორი არის დამოუკიდებელი ფანჯარა, რომელსაც შეუძლია აჩვენოს ცვლადის შინაარსი, 1 ან 2 განზომილებიანი მასივი, ან თუნდაც სტრუქტურების მასივის შერჩეული ელემენტები. გამოთქმა ძირითადად იგივეა, რაც Observer, მაგრამ შეიძლება შეიცავდეს ორ პარამეტრს: %A და %B. როდესაც დააინსტალირებთ ინსპექტორს, შეგიძლიათ განსაზღვროთ ლიმიტები ამ პარამეტრებისთვის. შემდეგ OllyDbg ითვლის %A და %B-ის ყველა შესაძლო კომბინაციას გამონათქვამში, დაწყებული 0-დან ლიმიტამდე (არ მოიცავს) და აჩვენებს შედეგებს ცხრილში. %B-ის ლიმიტი (სვეტების რაოდენობა) არ უნდა აღემატებოდეს 16-ს.

ზარის დასტა

Call Stack-ის ფანჯარა (Alt+K) ცდილობს თვალყური ადევნოს ზარების თანმიმდევრობას არჩეული ძაფების დასტაზე და აჩვენებს მას გამოძახებული ფუნქციების ცნობილ ან შემოთავაზებულ პარამეტრებთან ერთად. ეს ამოცანა მარტივია, როდესაც ფუნქციები, რომლებსაც ეძახიან, ქმნიან სტანდარტული სტეკის ჩარჩოებს (PUSH EBP; MOV EBP,ESP). თანამედროვე ოპტიმიზაციის შემდგენელები არ აწუხებენ სტეკის ჩარჩოებს, ამიტომ OllyDbg იყენებს სხვადასხვა ხრიკებს. მაგალითად, OllyDbg ცდილობს მოძებნოს კოდი შემდეგ დაბრუნებამდე და გამოითვალოს ნებისმიერი ბიძგი, პოპ ან ESP ცვლილება. თუ ეს არ დაგვეხმარება, OllyDbg მიმართავს უფრო სახიფათო და შრომატევად მიდგომას: OllyDbg სკანირებს დასტას, ცდილობს იპოვოს ყველა შესაძლო დაბრუნებისა და ტესტირების მისამართი, სადაც ფუნქცია გამოიძახეს შესაბამისი განცხადებით, მათ შორის გაანალიზებული ბრძანებები. ასევე არსებობს სხვა, საკმაოდ საეჭვო ევრისტიკა. სტეკის დათვალიერება შეიძლება მართლაც ნელი იყოს. OllyDbg აწარმოებს მას მხოლოდ იმ შემთხვევაში, თუ Call Stack ფანჯარა ღიაა.

Call Stack ფანჯარა შეიცავს 5 სვეტს: მისამართი, დასტა, პროცედურა, გამოძახება, ჩარჩო.

Address სვეტი შეიცავს მისამართს დასტაზე, Stack აჩვენებს შესაბამისი დაბრუნების მისამართის ან პარამეტრის მნიშვნელობას.

პროცედურა (ან პროცედურა / არგუმენტები) - აჩვენებს, სადაც Call Stack ფანჯარა ათავსებს გამოძახებული ფუნქციის მისამართს დასტაზე. ზოგიერთ შემთხვევაში, OllyDbg არ არის დარწმუნებული, არის თუ არა ეს მისამართი სწორი და ამატებს ერთ-ერთ შემდეგ მარკერს:

ნაპოვნი შესვლის წერტილი არ არის სანდო

შესაძლოა OllyDbg-მა ვერ იპოვა სანდო შესვლის წერტილი, ნაპოვნი მისამართი უნდა შემოწმდეს ევრისტიკის გამოყენებით

შეიცავს OllyDbg, ვერ ვიპოვე შესვლის წერტილი და იცის მხოლოდ, რომ ეს პროცედურა მოიცავს ჩვენების მისამართს

პანელზე ღილაკზე დაწკაპუნებით ან მენიუდან „არგუმენტების დამალვა/ჩვენება“ არჩევით, შეგიძლიათ ჩართოთ ან გამორთოთ ფუნქციის პარამეტრები.

გამოძახებულია ბრძანების მისამართი, რომელიც გამოიძახება ამ პროცედურის მიხედვით.
ბოლო სვეტი, Frame, დამალულია ნაგულისხმევად და აჩვენებს ჩარჩოს მაჩვენებლის მნიშვნელობას (EBP რეგისტრი), თუ ცნობილია.

ყველა მოწოდებული ფუნქციის გაანალიზებისას უფრო საიმედო და უფრო სწრაფია სტეკის სკანირება.

ზარის ხე

გამოძახების ხე (CALL) (Ctrl+K კლავიატურა Disassembler-ში) იყენებს ანალიზის შედეგებს, რათა მოამზადოს მოცემული პროცედურის მიერ მოწოდებული ფუნქციების სია, პირდაპირ ან ირიბად, და ამ ფუნქციის ყველა ცნობილი ზარის სია. გვერდითი ეფექტი - ცნობს არის თუ არა შერჩეული პროცედურა აშკარად რეკურსიული. "ცალსახად" ნიშნავს, რომ მას არ შეუძლია მოძებნოს მოთხოვნები უცნობი მისამართით, როგორიცაა CALL EAX. თუ პროცედურა აკეთებს უცნობ ზარებს, Call Tree ამატებს მარკერებს "უცნობი დანიშნულება(ები)".

ზოგიერთი გამოძახებული ფუნქცია კომენტირებულია ერთ-ერთი შემდეგი სიტყვით:

ფოთოლი არ იძახებს სხვა ფუნქციებს
Pure არ იწვევს რაიმე ფუნქციას, არ აქვს გვერდითი მოვლენები
RETN შედგება ერთი RETN ბრძანებისგან
Sys ფუნქცია სისტემის DLL-ში. განმარტებით, სისტემის DLL არის DLL, რომელიც მუდმივად იმყოფება სისტემის დირექტორიაში

ზარის ხეზე გადასასვლელად, ორჯერ დააწკაპუნეთ მისამართზე გამოძახებული სვეტიდან ან ზარები/პირდაპირი ზარები სვეტში. "Call Tree" ფანჯარა ინახავს თქვენი მოქმედებების ისტორიას (ღილაკები "-" და "+").

თუ პროგრამა, რომელსაც გამართავთ რამდენიმე მოდულისგან შედგება, გირჩევთ გაანალიზოთ ყველა ეს მოდული. Call Tree არ ცდილობს სისტემის ფუნქციების დამუშავებას.

თვითმმართველობის ამოღება (SFX) ფაილები

SFX ფაილი შედგება unpacker და შეფუთული ორიგინალური პროგრამისგან. შეკუმშული ფაილების შემოწმებისას, როგორც წესი, გსურთ გამოტოვოთ შეფუთვა და შეჩერდეთ პროგრამის შესვლის წერტილში ("რეალური ჩანაწერი"). OllyDbg შეიცავს რამდენიმე მახასიათებელს, რაც ამ ამოცანას ამარტივებს.

ჩვეულებრივ unpacker იტვირთება მისამართებში, რომლებიც არ არის ორიგინალური პროგრამის განყოფილების გარეთ. ამ შემთხვევაში, OllyDbg ცნობს ფაილს, როგორც SFX.

როდესაც SFX ოფცია მოითხოვს რეალურ შეყვანის მიკვლევას, OllyDbg ადგენს მეხსიერების წყვეტის წერტილს კოდის მთელ განყოფილებაში. ის ჩვეულებრივ ცარიელია ან შეიცავს შეკუმშულ მონაცემებს. როდესაც პროგრამა ცდილობს შეასრულოს გარკვეული ბრძანება დაცულ ზონაში, რომელიც არც RET და არც JMP არ არის, OllyDbg აცნობებს რეალურ შეყვანას. ასე მუშაობს ბაიტი-ბაიტი მოპოვება.

ეს მეთოდი ძალიან ნელია. არსებობს კიდევ ერთი, უფრო სწრაფი მეთოდი. ყოველთვის, როცა მონაცემების წაკითხვისას ხდება გამონაკლისი, OllyDbg კითხულობს მეხსიერების ამ 4K ბლოკიდან და თიშავს წინა წაკითხვის ფანჯარას. მონაცემთა ჩაწერის თითოეულ გამონაკლისზე, ის ამ ბლოკში ჩაწერის საშუალებას იძლევა და წინაზე ჩაწერას კრძალავს. როდესაც პროგრამა ასრულებს ბრძანებებს დაუცველ ადგილას, OllyDbg აცნობებს რეალურ შეყვანას. თუმცა, თუ რეალური შეყვანა არის წაკითხვის ან ჩაწერის ფანჯარაში, მისი მდებარეობა არასწორად იქნება მოხსენებული.

თქვენ შეგიძლიათ შეასწოროთ შესვლის მისამართი ხელით. აირჩიეთ ახალი შესვლის მისამართი და Disassembler ფანჯრის კონტექსტურ მენიუში აირჩიეთ Breakpoint-> Set real SFX entry here. თუ ჩართულია შესაბამისი SFX ოფცია, OllyDbg გამოტოვებს შეფუთვას სწრაფად და საიმედოდ შემდეგ ჯერზე.

თქვენ გაივლით პროგრამას, რომლის გამართვასაც აკეთებთ F7 (ნაბიჯი შესვლისას) ან F8 (ნაბიჯი შემოვლით) დაჭერით. ამ მეთოდებს შორის მთავარი განსხვავება ისაა, რომ თუ მიმდინარე ბრძანება არის CALLing ზოგიერთი ფუნქციის, F7 შევა ფუნქციაში და შეჩერდება მის პირველ ბრძანებაზე, ხოლო F8 დაუყოვნებლივ შეეცდება ფუნქციის შესრულებას. თუ თქვენ გვერდის ავლით ფუნქციას, ნებისმიერი წყვეტის წერტილი ან გამართვის მოვლენა ფუნქციის ფარგლებში შეაჩერებს ძირითადი პროგრამის შესრულებას, მაგრამ პროცედურის ზარის შემდეგ დროებითი წყვეტის წერტილი აქტიური დარჩება და ადრე თუ გვიან მიაღწევთ მას.

თუ გამართული პროგრამა ჩერდება გამონაკლისზე, შეგიძლიათ ეს გამონაკლისი გადასცეთ დამმუშავებელს, რომელიც დაინსტალირებულია პროგრამის გამართვით. უბრალოდ დააჭირეთ Shift-ს ნებისმიერ წინასწარ ბრძანებასთან ერთად.

იმის ნაცვლად, რომ დააჭიროთ F7 ან F8 რამდენჯერმე, შეგიძლიათ გამოიყენოთ ანიმაცია (Ctrl+F7 ან Ctrl+F8). ამ შემთხვევაში, OllyDbg ავტომატურად იმეორებს F7 ან F8 წინა ნაბიჯის დასრულების შემდეგ და ყველა ფანჯარა შეიცვლება. პროცესი ჩერდება, როდესაც:

• თქვენ დააჭირეთ Esc-ს ან აწარმოებთ სხვა წინასწარ ბრძანებას, ან
• OllyDbg შეხვდება ადრე დაყენებულ წყვეტის წერტილს, ან
• პროგრამის გამართვა გამოიწვევს გამონაკლისს.

"+" და "-" კლავიშების გამოყენებით, შეგიძლიათ გადაახვიოთ შესრულების ისტორია.

გაითვალისწინეთ, რომ OllyDbg ხატავს ფანჯრების უმეტესობას, როდესაც შესრულება შეჩერებულია. თუ ანიმაცია ძალიან ნელი ჩანს, სცადეთ დახუროთ ან მინიმუმამდე დაიყვანოთ ყველა გამოუყენებელი ფანჯარა.

პროგრამის შესრულების უკან დახევის კიდევ ერთი, უფრო სწრაფი გზა არის Run trace. ამ შემთხვევაში, OllyDbg ქმნის შესრულების ჟურნალს და გეტყვით როდის და რამდენჯერ შესრულდა ეს ბრძანება.

ნაბიჯ-ნაბიჯ მოკვლევა

ნაბიჯ-ნაბიჯ მოკვლევა გაძლევთ შესაძლებლობას შენიშნოთ კოდის რომელი ნაწილები შესრულდა და რომელი არა. OllyDbg-ში განხორციელებული მეთოდი საკმაოდ მარტივია. ის ადგენს INT3 წყვეტის წერტილს თითოეულ გუნდზე მითითებულ ზონაში. როდესაც წყვეტის წერტილი შესრულებულია, OllyDbg შლის მას და აღნიშნავს ბრძანებას, როგორც დასრულებულს. იმის გამო, რომ თითოეული კვალი წყვეტის წერტილი შესრულებულია მხოლოდ ერთხელ, ეს მეთოდი ძალიან სწრაფია.

დამატებითი ტრასინგის გამოყენებისას ყურადღება უნდა მიაქციოთ, რომ არ დააყენოთ წყვეტის წერტილი მონაცემებზე, რადგან ეს გამოიწვევს აპლიკაციას შეცდომის დაშვებას. ამ მიზეზით, თქვენ უნდა გააანალიზოთ კოდი, რათა ჩართოთ მენიუს შესაბამისი პარამეტრები. გირჩევთ აირჩიოთ მკაცრი ან ევრისტიკული პროცედურების ამოცნობა. ბუნდოვანი ვარიანტი ზედმეტად ტოლერანტულია შეცდომის მიმართ და ხშირად აღმოაჩენს არარსებულ პროცედურებს.

როდესაც თქვენ აყენებთ ტრასის წყვეტის წერტილს, თუნდაც ერთ ბრძანებაზე მოდულში, OllyDbg ადგენს კვალის ბუფერს, რომელიც ორჯერ აღემატება კოდის განყოფილებას.

გაითვალისწინეთ, რომ როდესაც თქვენ წაშლით ნაბიჯების კვალის მონაცემებს, თქვენ ასევე წაშლით იძულებით კვალს.

პირდაპირი მიკვლევა

Forward Tracing არის პროგრამის შესრულების შებრუნების საშუალება, რომელიც ზოგიერთ შემთხვევაში აუცილებელია. თქვენ ასევე შეგიძლიათ გამოიყენოთ პირდაპირი მიკვლევა მარტივი პროფილირებისთვის. ძირითადად, OllyDbg ახორციელებს გამართულ პროგრამას ეტაპობრივად, როგორც ანიმაცია, მაგრამ არ ცვლის ფანჯრებს და - რაც მთავარია - ინახავს მისამართებს, არეგისტრირებს შინაარსს, შეტყობინებებს და ცნობილ ოპერანდებს კვალი ბუფერში. თუ კოდი, რომელსაც თქვენ გამართავთ, არის თვითშეცვლის, შეგიძლიათ შეინახოთ ორიგინალური ბრძანებები. დაიწყეთ წინა კვალი Ctrl+F11 (შეყვანის კვალი) ან Ctrl+F12 (შემოვლითი კვალი) დაჭერით. შეწყვიტე თვალყური - F12 ან Esc კლავიშები.

თქვენ შეგიძლიათ განსაზღვროთ პირობების ნაკრები, რომელიც მოწმდება წინა კვალის შესრულების ყოველ საფეხურზე (ჰოტკლავი: Ctrl+T). წინა ტრასირება ჩერდება, როდესაც ის ხვდება მდგომარეობას. პირობები მოიცავს:

რა თქმა უნდა, პირდაპირი მიკვლევა მოითხოვს უამრავ მეხსიერებას, საშუალოდ 16-დან 35 ბაიტამდე ინსტრუქციაზე, რეჟიმიდან გამომდინარე და ძალიან ნელია. 500 MHz პროცესორზე, რომელიც მუშაობს Windows NT-ზე, ამ პროცესს შეუძლია წამში 5000-მდე ინსტრუქციის მიკვლევა. Windows 95-ში უფრო ნელია: მხოლოდ 2200 ბრძანება წამში. მაგრამ ხშირ შემთხვევაში, მაგალითად, როდესაც პროგრამა გადადის არარსებულ მისამართზე, ეს არის პრობლემის გადაჭრის ერთადერთი გზა. თქვენ შეგიძლიათ გამორიცხოთ კვაზიწრფივი ინსტრუქციების თანმიმდევრობები (მიმდევრობის ბოლოს ერთი გამომავალი) წინა ტრასირების პროცესიდან. როდესაც OllyDbg ხვდება გამორიცხულ თანმიმდევრობას, OllyDbg ადგენს დროებით წყვეტს ბრძანებას, რომელიც დაუყოვნებლივ მიჰყვება გამორიცხულ ბლოკს და ახორციელებს მას დაუყოვნებლივ. რა თქმა უნდა, გარე კოდზე ნებისმიერი დაბრუნება ან გადასვლა შეუძლებელს ხდის სათანადო განხილვას, ამიტომ OllyDbg ამოწმებს კოდის იმ ნაწილს, რომლის გამორიცხვა გსურთ და რთულ შემთხვევებში მოგთხოვთ დადასტურებას.

უმეტეს შემთხვევაში, თქვენ არ გჭირდებათ სისტემის API კოდის მიკვლევა. ოფცია „ყოველთვის თვალყური ადევნე სისტემურ DLL-ებზე“ საშუალებას გაძლევთ თვალყური ადევნოთ ფუნქციური API-ების შეყვანის გარეშე, როდესაც ადევნებთ თვალს და ანიმაციას შეყვანისას. OllyDbg ვარაუდობს, რომ მოდული არის სისტემა, თუ ის მუდმივად მდებარეობს სისტემის საქაღალდეში. მოდულების ფანჯარაში შეგიძლიათ მონიშნოთ ნებისმიერი ბიბლიოთეკა, როგორც სისტემური ან არასისტემური.

იმისათვის, რომ შესრულება უფრო სწრაფად მოხდეს, შეგიძლიათ შეზღუდოთ პირდაპირი მიკვლევის პროცედურა შერჩეული ბრძანებებით ან კოდის ნაწილებით, წყვეტის წერტილების დაყენებით, რათა დაიწყოთ თვალყურის დევნება და გაუშვათ პროგრამა. მე ამას "იძულებითი გაშვების კვალს" ვეძახი. ძირითადად, მარშრუტიზაციის წყვეტის წერტილები არის არამოხსნადი ნაბიჯ-კვალის წყვეტის წერტილები. თუ თქვენ წაშლით ნაბიჯის კვალს, თქვენ ასევე წაშლით წინა კვალს.

ამ განყოფილების დასაწყისში ნახსენები კვალის ბრძანებები ავტომატურად ხსნის კვალის ბუფერს. თქვენ შეგიძლიათ განსაზღვროთ მისი ზომა (64 მბ-მდე) ოფციებში. ეს ბუფერი არის წრიული და როდესაც ის სავსეა, ძველი ჩანაწერები გადაიწერება.

თქვენ შეგიძლიათ გახსნათ ან წაშალოთ გაშვებული ტრასის ბუფერი OllyDbg-ის მთავარი მენიუდან Debug -> Open or clear run trace არჩევით. როგორც კი კვალი ბუფერი გაიხსნება, OllyDbg აღწერს ყველა პაუზას შესრულებაში, მათ შორისაც კი, რომლებიც არ იყო გამოწვეული პირდაპირი კვალით. მაგალითად, შეგიძლიათ გადახვიდეთ პროგრამაში F7 ან F8 დაჭერით და შემდეგ უკან დაბრუნდეთ კოდის მეშვეობით Plus და Minus კლავიშების გამოყენებით. გაითვალისწინეთ, რომ ეს კლავიშები ნახულობენ ისტორიას, როდესაც კვალის ბუფერი დახურულია. თუ პროგრამას თვალყურს ადევნებთ, ფანჯრის რეგისტრები და ინფორმაციის არეები გახდება ნაცრისფერი, რაც ხაზს უსვამს, რომ რეგისტრის მონაცემები, რომლებსაც ისინი აჩვენებენ, არ არის რეალური მონაცემები. კვალის ბუფერი არ ინახავს სტეკის ზედა ნაწილს ან მეხსიერების შიგთავსს, რომელსაც იყენებენ რეგისტრები. რეგისტრები, ინფორმაცია და დასტა იყენებენ მეხსიერების რეალურ მდგომარეობას კვალი ბუფერიდან რეგისტრების ინტერპრეტაციისთვის.

OllyDbg-ს შეუძლია დათვალოს რამდენჯერ გამოჩნდება თითოეული ბრძანება წინა ტრასის ბუფერში. Disassembler ფანჯარაში აირჩიეთ "ნახვა -> პროფილის მონაცემები". ეს ბრძანება ცვლის კომენტარების სვეტს პროფილის სვეტით. ან, თუ პანელი გამოჩნდება, დააწკაპუნეთ მასზე რამდენჯერმე, სანამ არ გამოჩნდება პროფილის ინფორმაცია. გაითვალისწინეთ, რომ ნაჩვენები მრიცხველი დინამიურია და არ ითვლის კვალის ბუფერიდან ამოღებულ ძველ ბრძანებებს. თქვენ ასევე შეგიძლიათ ნახოთ პროფილის მონაცემები მთელი მოდულისთვის, დალაგებული რამდენიმე დაწკაპუნებით, ცალკე პროფილის ფანჯარაში

სპეციალური ბრძანება Disassembler-ის ფანჯარაში „Runtrace -> ყველა პროცედურის ჩანაწერის დამატება“ საშუალებას გაძლევთ შეამოწმოთ რამდენად ხშირად არის გამოძახებული თითოეული აღიარებული პროცედურა. კიდევ ერთი ბრძანება, Runtrace -> ფილიალების დამატება პროცედურაში, აიძულებს პროცედურში ყველა აღიარებული ფილიალის დანიშნულების მიკვლევას. ამ შემთხვევაში, პროფილი საშუალებას გაძლევთ იპოვოთ ყველაზე ხშირად შესრულებული გადასვლები და გააუმჯობესოთ ისინი სიჩქარის გაზრდის მიზნით.

"Search for -> Last record in run trace" ოფცია Disassembler ფანჯრის კონტექსტურ მენიუში აღმოაჩენს, როდის შესრულდა მონიშნული ბრძანება და შესრულდა თუ არა ის საერთოდ ბოლოჯერ.
ცოცხალი კვალის ფანჯარა აჩვენებს კვალი ბუფერის შინაარსს. თითოეული ბრძანებისთვის არის გარკვეული რეგისტრის შინაარსი, რომელიც შეიცვალა ბრძანებით (უფრო ზუსტად, შეიცვალა წყაროსა და განახლებულ ჩანაწერს შორის). თუ ორჯერ დააწკაპუნებთ ბრძანებაზე, ამომხტარი ფანჯარა შეარჩევს ამ ბრძანების ყველა მითითებას კვალის ბუფერში და შეგიძლიათ სწრაფად ნახოთ ისინი პლუს ან მინუს კლავიშების დაჭერით. თუ მონიშნულია "Trace -> Synchronize CPUandRuntrace" ოფცია, Disassembler გადავა წინა კვალის ფანჯარაში.

გაითვალისწინეთ, რომ როდესაც თქვენ წაშლით ნაბიჯის კვალს, თქვენ ასევე წაშლით იძულებით წინსვლის კვალს.

Sandbox

ახალი მოთამაშე 2016 წლის 7 იანვარი, 01:36 სთ

OllyDebug–თან მუშაობის საფუძვლები, არქივის „განკურნების“ მაგალითის გამოყენებით

• ასამბლერი

დღეს მე გაჩვენებთ, თუ როგორ შეგიძლიათ გამოიყენოთ "ოლკა" ერთი ცნობილი არქივის "განსაკურნებლად". ამისთვის გვჭირდება: OllyDBG, “CommandBar” მოდული.

ჩვენ დავაყენეთ არქივი, 40 დღის შემდეგ ვხედავთ სურათს:

პირველი, რაც მახსენდება, არის ლიცენზიის შემოწმების შეცვლა ან პროგრამის გამოყენების ხანგრძლივობის შემოწმება. მოდით მივყვეთ მარტივ გზას - მოძებნეთ WinAPI ფუნქცია, რომელიც მიიღებს მიმდინარე GetLocalTime-ს. კონტექსტურ მენიუში აირჩიეთ

მოძებნეთ -> სახელი (ლეიბლი) მიმდინარე მოდულში.

ჩვენ ვეძებთ დროსთან დაკავშირებულ ფუნქციებს, ოჰ, ეს არის, თითქმის გამოგვრჩა.

ახლა თქვენ უნდა დააყენოთ წყვეტის წერტილი ამ ფუნქციაზე. CommandBar მოდულის ფანჯარაში შეიყვანეთ

და ახლა, როდესაც ამ ფუნქციას გამოვიძახებთ, ჩვენი გამართვა გაჩერდება ჩვენთვის საჭირო ადგილას.

ჩვენ ვიწყებთ გამართვას, გასაღები F9. ჩვენი წყვეტის წერტილი წარმატებით შესრულდა და აღმოვჩნდით GetLocalTime ფუნქციის დასაწყისში, მოდით მივიდეთ ამ ფუნქციიდან გასასვლელ წერტილამდე (Ctr+F9), გადავდგათ ერთი ნაბიჯი (F7). აქ ვხედავთ, რომ დროის მიღების შემდეგ იძახება ფუნქცია 004B8C00 მისამართზე, გირჩევთ შეხვიდეთ და ნახოთ რა შეიძლება იყოს იქ საინტერესო, ვიყენებთ საფეხურს შეყვანით (F7).

ჩვენ ვხედავთ ხელსაყრელ ნიშნებს.

ჩვენ ვაკონტროლებთ პროგრამას F8-ის მეშვეობით, სანამ შეამოწმებთ 004B8C26 მისამართზე, დააკვირდით TEST AL,AL.

შეგახსენებთ, რომ AL არის EAX-ის დაბალი რეგისტრი, ახლა ცარიელი გვაქვს. TEST AL,AL ბრძანება ამოწმებს არის თუ არა AL რეგისტრი ნულის ტოლი, თუ ის ტოლია, მაშინ ჩაირთვება ZF დროშა შემდეგი ბრძანება JE SHORT 004B8C44, აგზავნის მისამართზე 004B8C44, თუ ZF დროშა ჩართულია. კარგი, მე ვთავაზობ ამ გადასვლის შემოწმების ამოღებას. დააჭირეთ spacebar და შეიყვანეთ nop, დააჭირეთ Assemble რამდენჯერმე სანამ ეს ორი ბრძანება არ ამოიწურება.

ჩვენ ვიწყებთ გამართვას (F9) და ვხედავთ, რომ კვლავ გავჩერდით ჩვენს წყვეტის წერტილზე, მოდი ამოვიღოთ იგი (F2) და კვლავ გავაგრძელოთ გამართვა (F9). ახლა ვხედავთ, რომ არაფერი გვიშლის ხელს მუშაობაში და რეგისტრაციის ველში არის წარწერა, რომ პროგრამა რეგისტრირებულია.

ტეგები: საპირისპირო ინჟინერია, ასამბლერი, OllyDebug

ეს სტატია კომენტარს არ ექვემდებარება, რადგან მისი ავტორი ჯერ არ არის საზოგადოების სრულუფლებიანი წევრი. ავტორთან დაკავშირებას მხოლოდ მას შემდეგ შეძლებთ, რაც ის მიიღებს

ამ "შესავალი ნულიდან კრეკინგში OllyDbg-ის გამოყენებით" მიზანია მისცეს მათ, ვინც ახლახან იწყებენ დაუფლების ხელოვნებას საბაზისო ცოდნისა და ამავდროულად, ისე, რომ ეს ცოდნა მათ შემდგომში წაკითხვის საშუალებას მისცემს. და გაიგეთ უფრო მოწინავე გაკვეთილები, როგორიცაა , რომელიც შეგიძლიათ იხილოთ „ახალი კურსი CracksLatinos“-ში, რომელიც, რა თქმა უნდა, ღია რჩება ახალი დამატებებისა და დამატებების მისაღებად.

კურსის იდეა გაჩნდა იქიდან, რომ CracksLations-ის New Course-ის ბევრი გაკვეთილი დამწყებთათვის ძალიან რთული იყო და ისინი, ვინც ვერ მიაღწიეს საჭირო დონეს, იმედგაცრუებულნი აღმოჩნდნენ და ხშირ შემთხვევაში უარს ამბობდნენ გაგრძელებაზე. მაშასადამე, ამ „შესავლის...“ მიზანია არა „ახალი კურსის...“ შესანიშნავი გაკვეთილების გამეორება, რომელთა რაოდენობამ უკვე 500-ს გადააჭარბა, არამედ საფუძველი ჩაეყაროს, ვინც ამ კურსს დაასრულებს. შეძლებს უფრო რთული გაკვეთილების წაკითხვას. ეს, ისევე როგორც ყველაფერი ჩვენს ხელნაკეთობაში, მოითხოვს მნიშვნელოვან ძალისხმევას და მთავარი მიზანია ამ თანხის შემცირება, საბაზისო ცოდნის მიწოდება და უფრო რთული მასალის შემდგომი გაგების შესაძლებლობა.

რატომ OLLYDBG?

ჩვენ აქ არ ვისაუბრებთ Soft-Ice-სა და OllyDbg-ის მარადიულ დაპირისპირებაზე; მე ვფიქრობ, რომ Soft-Ice-ის ფანატიკოსებიც კი აღიარებენ, რომ OllyDbg-ით დაწყება უფრო ადვილია, რადგან ამის შესახებ ბევრი ინფორმაციაა და უფრო ადვილია შესწავლა. ჩვენ უნდა შევიდეთ გატეხვის სამყაროში, სახელწოდებით "OllyDbg" და მხოლოდ ამის შემდეგ, ვისაც ეს სჭირდება, შეუძლია გადაერთოს ნებისმიერ სხვა საჭირო დებაგერზე, რადგან იცვლება მხოლოდ მათი გამოყენების მეთოდები, მაგრამ არსი იგივე რჩება.

Თავიდან დაწყება

ჯერ უნდა შეიარაღოთ იმ ხელსაწყოთი, რომლის გამოყენებასაც ძირითადად ვაპირებთ, რისთვისაც დააწკაპუნეთ და გადმოწერეთ.

ვინაიდან ჩვენ ვიწყებთ ნულიდან, პირველ რიგში, გადმოწერილი არქივი უნდა განვათავსოთ თქვენს მყარ დისკზე არსებულ საქაღალდეში, რომლის მიღწევაც მარტივად არის შესაძლებელი. კარგი იდეა იქნება საქაღალდის შექმნა C:/ დისკზე. მიუხედავად იმისა, რომ ის იმუშავებს ნებისმიერ სხვა ადგილას, მე ვივარაუდებ, რომ C:/ დისკი არჩეულია.

ფაილის გახსნის შემდეგ გადადით შექმნილ საქაღალდეში და ნახეთ:

ის შეიცავს შესრულებად ფაილს OLLYDBG.exe, რომელიც უნდა გავუშვათ და რომლისთვისაც მე გავაკეთე მალსახმობი ჩემს დესკტოპზე მოხერხებულობისთვის.

კარგი, ყველაფერი მზადაა გასაშვებად. დააწკაპუნეთ OllyDbg-ზე:

ჩვენ ვხედავთ შეტყობინებას, რომ ბიბლიოთეკაში განთავსებული DLL უფრო ძველია, ვიდრე იგივე სისტემის DLL, და თუ ჩვენ ვირჩევთ "დიახ", მაშინ ძველი DLL წაიშლება საქაღალდედან და გამოყენებული იქნება სისტემის ერთი. მიუხედავად იმისა, რომ ამ ორს შორის დიდ განსხვავებას ვერ ვხედავ, მაინც მირჩევნია ის, რომელიც მოყვება განაწილებას, ამიტომ ყოველთვის ვაწკაპუნებ "არა".

ეს არის სუფთა OllyDbg და პირველი პროგრამა, რომელსაც ჩვენ გავხსნით მხოლოდ OllyDbg-ის გასაცნობად, იქნება CrueHead-ის ცნობილი CrackMe, რომელიც თან ერთვის ამ ტუტორიალს.

OllyDbg-ში ფაილის გასახსნელად გადადით File -> Open ან დააწკაპუნეთ ხატულაზე:

გაიხსნება ფანჯარა, რომლითაც შეგიძლიათ იპოვოთ სასურველი ფაილი, ამ შემთხვევაში ეს არის CrueHead-ის crackme.

ზემოაღნიშნული კრეკი გაიხსნება და ამ მომენტში არ აქვს მნიშვნელობა, რომ სრულიად გაუგებარია რას ნიშნავს ჩვენთვის გახსნილი ხედი - ახლა ჩვენ უბრალოდ გადავხედავთ OllyDbg-ის სხვადასხვა ნაწილებსა და ფუნქციებს და ზოგიერთ პარამეტრს, ასე რომ როდესაც მომდევნო გაკვეთილებში ნათქვამია, თქვით, "გადი DUMP-ზე", თქვენ მაინც იცოდით სად იყო ეს ვარიანტი.

აქ ჩვენ გადავხედავთ OllyDbg მთავარი ფანჯრის ოთხ ნაწილს:

1) დაშლილი კოდი

ასევე მოუწოდა ჩამონათვალი. აქ ოლი გვიჩვენებს პროგრამის დაშლილ კოდს, რომლის გამართვას ვაპირებთ; ნაგულისხმევად, Ollie კონფიგურირებულია პროგრამის გასაანალიზებლად, როდესაც ის გაიხსნება. ეს შეიძლება შეიცვალოს ოფციებში -> გამართვის ვარიანტები.

ანუ, თუ მონიშნულია „AUTO START ANALISIS OF MAIN MODULE“ ჩამრთველი, OllyDbg გააანალიზებს პროგრამას და აჩვენებს დამატებით ინფორმაციას მის შესახებ.

ეს არის CrueHead-ის გაანალიზებული კრეკების ჩამონათვალის დასაწყისი და თუ მას გავხსნით ანალიზების გარეშე, დავინახავთ განსხვავებას.

ანალიზის ფანჯარა შეიცავს უამრავ ინფორმაციას, რომელიც, მიუხედავად იმისა, რომ ჩვენთვის ჯერ კიდევ არ არის ნათელი, ძალიან საინტერესო გამოიყურება. ამავდროულად, სასიამოვნოა იცოდეთ, რომ თქვენ შეგიძლიათ წაშალოთ იგი ნებისმიერ დროს, თუ ანალიზი აღმოჩნდება არც თუ ისე ზუსტი ან თუ მასში შეცდომის გამოვლენა მოხდა.

ხშირად OllyDbg აჩვენებს პროგრამის ზოგიერთ ნაწილს არასწორად, რადგან ის შეცდომით განმარტავს შესრულებად კოდს, როგორც მონაცემს, შემდეგ კი აჩვენებს რაღაცას:

ამ შემთხვევაში, თქვენ შეგიძლიათ ხელით წაშალოთ ანალიზი, დააწკაპუნოთ მაუსის მარჯვენა ღილაკით ჩამონათვალზე და აირჩიოთ „ANALISIS -> REMOVE ANALYSIS FROM MODULE“.

და შემდეგ სია იქნება ნაჩვენები სწორად.

კიდევ ერთი ვარიანტი, რომელიც შეგიძლიათ გამოიყენოთ საქმის გასაადვილებლად და რომელიც პირადად მე ნამდვილად არ მომწონს (მაგრამ გემოვნება განსხვავდება) არის ნახტომი და ზარის ხაზგასმა - დააწკაპუნეთ მაუსის მარჯვენა ღილაკით ჩამონათვალზე და აირჩიეთ „APPEARENCE -> Highlighting - > JUMPS AND CALLS“.

თქვენ მიიღებთ შემდეგს:

აქ ჩვენ ვხედავთ, რომ ზარები მონიშნულია ლურჯად, ხოლო გადასვლები მონიშნულია ყვითლად.

ჩამონათვალი ახლა უფრო იკითხება, მაგრამ ჯერ არ ვიცით რას ნიშნავს ეს, მაგრამ კარგია, რომ ინსტრუმენტი მზად იყოს მომავალი გამოყენებისთვის.

2) რეგისტრები

მეორე მნიშვნელოვანი ფანჯარა არის რეგისტრაციის ფანჯარა.

შეგახსენებთ, რომ რეესტრის ფანჯარა მდებარეობს OllyDbg-ის მარჯვენა მხარეს და იქ არის ნაჩვენები ინფორმაციის მნიშვნელოვანი რაოდენობა.

არის ბევრად მეტი ინფორმაცია, რომელსაც ჩვენ ვერ ვხედავთ, მაგრამ თქვენ შეგიძლიათ დააყენოთ ჩვენების რეჟიმი სამ მდგომარეობაზე („იხილეთ FPU REGISTERS“ – FPU რეგისტრების ჩვენება, „იხილეთ 3D NOW REGISTERS“ – ჩვენება „3D NOW“ რეგისტრები და „იხილეთ გამართვის რეგისტრები ” – გამართვის რეგისტრების ჩვენება). ნაგულისხმევად, ნაჩვენებია პირველი.

3) დასტის ან გროვა

ახლა მოდით გადავიდეთ "დასტის ან გროვაზე". აქ არ არის ძალიან ბევრი კონფიგურაციის ვარიანტი, გარდა ESP და EBP რეგისტრების შესახებ ინფორმაციის ჩვენების შესაძლებლობისა.

ნაგულისხმევად, ESP-თან დაკავშირებული ინფორმაციის ჩვენების რეჟიმი (და ის ასევე ყველაზე სასარგებლოა), მაგრამ ის შეიძლება შეიცვალოს EBP-სთან დაკავშირებული ინფორმაციის ჩვენების რეჟიმში, რისთვისაც თქვენ უნდა დააწკაპუნოთ ამ ფანჯარაში მარჯვენა ღილაკით და აირჩიეთ ” GO TO EBP“ , და „GO TO ESP“ პუნქტის შემდგომი გამოყენება დაგვიბრუნებს წინა რეჟიმში.

სტეკის ფუნქციონალურობას უფრო დეტალურად განვმარტავ შემდეგ თავებში, მაგრამ ახლა ჩვენ განვიხილავთ მხოლოდ იმას, რაც შეიძლება შეიცვალოს კონფიგურაციის საშუალებით.

4) ნაგავსაყრელი

ნაგავსაყრელის ფანჯარას აქვს მრავალი ჩვენების რეჟიმი, რომელიც შეიძლება შეიცვალოს მაუსის მარჯვენა ღილაკით დაწკაპუნებით და აირჩიეთ თქვენთვის სასურველი. ნაგულისხმევი რეჟიმი არის 8-ბაიტი Hex/ASCII.

ნაგულისხმევი რეჟიმი ასევე არის ყველაზე ხშირად გამოყენებული, მაგრამ ამავე დროს, ჩვენ გვაქვს შესაძლებლობა შევცვალოთ ის დაშლილი კოდის (DISASSEMBLE), ტექსტის (TEXT) და სხვა ფორმატების (SHORT, LONG, FLOAT) ჩვენებაზე.

და ბოლოს, SPECIAL -> PE HEADER ვარიანტი, რომელიც, როგორც მომდევნო თავებში ვნახავთ, შეიძლება ძალიან სასარგებლო იყოს.

ახლა ჩვენ ვიცით OllyDbg მთავარი ფანჯრის ძირითადი ნაწილები, მაგრამ ასევე არის ფანჯრები, რომლებიც არ არის პირდაპირ წვდომა, მაგრამ მათი გამოძახება შესაძლებელია მენიუს საშუალებით ან მართვის პანელის ღილაკებით.

მოდით შევხედოთ თითოეულ მათგანს.

L ღილაკი ან VIEW->LOG გვაჩვენებს რას წერს OllyDbg ჟურნალის ფანჯარაში. მისი კონფიგურაცია შესაძლებელია სხვადასხვა ტიპის ინფორმაციის ჩვენებაზე და, ნაგულისხმევად, ჟურნალის ფანჯარა ინახავს გაშვების ყველა ინფორმაციას, ისევე როგორც BREAKPOINTS პირობითი ჟურნალებს. ამ უკანასკნელს მოგვიანებით შევხვდებით, მაგრამ ახლა მოდით შევხედოთ ინფორმაციას გაშვებული პროცესის შესახებ (ჩვენს შემთხვევაში, ეს არის CrueHead-ის კრეკი) და ბიბლიოთეკების შესახებ, რომლებსაც ის იტვირთება.

ამ ფანჯარაში ერთ-ერთი ყველაზე მნიშვნელოვანი ვარიანტია ფაილში შესვლა იმ შემთხვევაში, თუ გვინდა ინფორმაციის შენახვა ტექსტურ ფაილში. ამ პარამეტრის გასააქტიურებლად დააწკაპუნეთ მაუსის მარჯვენა ღილაკით და აირჩიეთ "LOG TO FILE".

ღილაკი E ან VIEW->EXECUTABLES გვიჩვენებს იმ მოდულების ჩამონათვალს, რომლებსაც პროგრამა იყენებს: exe, dll, ocx და სხვა.

აქაც, მაუსის მარჯვენა ღილაკზე ჩნდება მრავალი ვარიანტი, რომლებსაც ახლა არ განვიხილავთ, მაგრამ რომლებიც უკვე ვნახეთ OllyDbg მთავარი ფანჯრის შესწავლისას.

M ან VIEW->MEMORY ღილაკი აჩვენებს ჩვენი პროგრამის მიერ დაკავებულ მეხსიერებას. აქ ჩვენ ვხედავთ აპლიკაციის სექციებს, პროცესის მიერ გამოყენებულ ბიბლიოთეკებს, სისტემის მიერ დაკავებულ სტეკს და სხვადასხვა სექციებს და ხშირად პროგრამები იკავებს მეხსიერების ახალ ნაწილებს შესრულების დროს.

მაუსის მარჯვენა ღილაკით ჩვენ შეგვიძლია გავაკეთოთ SEARCH მეხსიერებაში, რათა ვიპოვოთ სხვადასხვა სახის სტრიქონები (ტექსტი, თექვსმეტობითი, უნიკოდი), ასევე არის სექციებში წყვეტის წერტილების მონიშვნის შესაძლებლობა, ასევე ამ უკანასკნელზე წვდომის უფლებების შეცვლის შესაძლებლობა ( აირჩიეთ SET ACCESS).

ღილაკი T ან VIEW->THREADS გვიჩვენებს პროგრამის ძაფების (ძაფების) სიას.

მიუხედავად იმისა, რომ ახლა ჩვენ არ ვიცით რა არის ეს და მხოლოდ მომდევნო თავებში გავარკვევთ, ზედმეტი არ იქნება თითოეული ფანჯრის გაცნობა. მათ გამოყენებას მოგვიანებით ვისწავლით.

W ან VIEW->WINDOWS ღილაკი აჩვენებს პროგრამის ფანჯრებს, მაგრამ რადგან ის ჯერ არ მუშაობს, ფანჯრების სია ცარიელი რჩება.

ღილაკი H ან VIEW->HANDLES აჩვენებს სახელურებს, მოგვიანებით აგიხსნით რას აკეთებენ ისინი.

ღილაკი C ან VIEW->CPU გვაბრუნებს მთავარ OllyDbg ფანჯარაში.

ღილაკი / ან VIEW->PATCHES აჩვენებს გამოყენებული პატჩების ჩამონათვალს, თუ პროგრამა შეიცვალა. იმის გამო, რომ ცვლილებები ჯერ არ განხორციელებულა, ფანჯარა ჯერ ცარიელი რჩება.

K ღილაკი ან VIEW->CALL STACK აჩვენებს "ზარების დასტას", ზარების სიას, რომლებიც შეგვხვდა იმ მომენტამდე, სადაც პროგრამა შეჩერდა.

ღილაკი B ან VIEW->BREAKPOINTS გამოაქვს პროგრამაში მდებარე ნორმალური წყვეტის წერტილების სია. არ არსებობს ტექნიკის წყვეტის წერტილები ან მეხსიერების წყვეტის წერტილები, მხოლოდ ჩვეულებრივი.

ღილაკი R ან VIEW->REFERENCES აჩვენებს ჩვენ მიერ მიღებული ბმულების ფანჯარას Ollie-ში ბმულების ძიების შედეგად

ღილაკი “…” ან VIEW->RUN TRACE აჩვენებს RUN TRACE ბრძანების შედეგს. აქ ჩვენ ასევე შეგვიძლია ავირჩიოთ LOG TO FILE ოფცია კვალის შედეგების ტექსტურ ფაილში შესანახად.

ჩვენ დავფარეთ პანელი ყველაზე მნიშვნელოვანი ღილაკებით, ასე რომ თქვენ გაეცანით მათ შესაძლებლობებს, როდესაც დავიწყებთ მათში ღრმად შესწავლას მომდევნო თავებში.

როგორ დავაკონფიგურიროთ OllyDbg, რომ გახდეს JIT (უბრალოდ დროში DEBUGGER)

რა თქმა უნდა, ჩვენ არ გამოვიყენებთ JIT-ს მუდმივად, მაგრამ მხოლოდ განსაკუთრებულ შემთხვევებში, რადგან თუ შეცდომა მოხდა ჩვენს აპარატზე გაშვებულ ნებისმიერ პროგრამაში, მაშინ ჩვენ საერთოდ არ გვჭირდება Ollie-ს გამოყენება (ნაგულისხმევად, dr.watson არის გამოიყენება როგორც JIT).

იმისათვის, რომ OllyDbg გახადოთ JIT გამართვა, თქვენ უნდა გადახვიდეთ OPTIONS->JUST IN TIME DEBUGGING

და დააჭირეთ MAKE OLLYDBG JUST IN TIME DEBUGGER და DONE ღილაკებს თანმიმდევრობით

ამ ფუნქციის მოსაშორებლად, თქვენ უნდა დააჭიროთ RESTORE JUST IN TIME DEBUGGER და შესრულებულია იმავე ადგილას.

დანამატების დაკავშირება OllyDbg-ში

OllyDbg საშუალებას გაძლევთ დააკავშიროთ დანამატები, რომლებიც შეიძლება სასარგებლო იყოს კონკრეტული პრობლემის გადასაჭრელად. ამ დროისთვის ჩვენ შემოვიფარგლებით COMMAND BAR მოდულის დაკავშირებით, რათა ვისწავლოთ როგორ გავაკეთოთ ეს.

ამის შემდეგ, ამოალაგეთ დანამატი და გადახედეთ საქაღალდის შიგთავსს, სადაც ეს გაკეთდა:

უპირველეს ყოვლისა, თქვენ უნდა შექმნათ საქაღალდე დანამატებისთვის. მე შევქმნი მას C:/-ში და ვუწოდებ PLUGINS-ს.

რა თქმა უნდა, დანამატები შეიძლება განთავსდეს ნებისმიერ ადგილას, მაგრამ მე მომწონს ყველაფრის ჰოსტინგი C-ზე. ყოველ შემთხვევაში, ახლა ჩვენ გვჭირდება OllyDbg-ის კონფიგურაცია ისე, რომ მან აღიაროს ეს საქაღალდე, როგორც ყველა დანამატის მდებარეობა.

ამისათვის გადადით OPTIONS->APPEARANCE.

და ფანჯარაში, რომელიც იხსნება, გახსენით DIRECTORIES ჩანართი.

ჩვენ ვხედავთ, რომ დანამატებისკენ მიმავალი გზა არის დირექტორია, სადაც მდებარეობს თავად OllyDbg.exe, და ჩვენ შეგვიძლია დავაყენოთ დანამატები, მაგრამ მე მომწონს მათი ცალ-ცალკე შენახვა და შემდეგ დააწკაპუნეთ PLAGIN PATH->BROWSE-ზე, რომ იპოვოთ ჩვენ მიერ შექმნილი საქაღალდე. .

აირჩიეთ PLUGINS საქაღალდე და შეინახეთ ცვლილებები.

ანუ, თქვენ უნდა გადატვირთოთ Ollie ისე, რომ მან ამოიცნოს ახალი საქაღალდე დანამატებით, მაგრამ ჯერ უნდა დააკოპიროთ მასში ბოლო გადმოწერილი დანამატი.

დააკოპირეთ არქივის მთელი შინაარსი PLUGINS საქაღალდეში.

ახლა "Command Bar" მოდულის ყველა ფაილი განთავსებულია PLUGINS საქაღალდეში, ხოლო დანარჩენი ასევე უნდა განთავსდეს მასში (ხშირად შეგიძლიათ დააკოპიროთ არა ყველა ფაილი არქივში, არამედ მხოლოდ dll).

ახლა დახურეთ OllyDbg, თუ ის ჯერ კიდევ დახურული იყო და ხელახლა გაუშვით. ჩვენ ვხედავთ, რომ COMMAND BAR და მისი ოფციები გამოჩნდა PLUGINS მენიუში.

OllyDbg-ის ბოლოში ჩვენ ვხედავთ დაყენებულ COMMAND BAR-ს.

ეს არის ტექსტური ველი ბრძანებების შესაყვანად, რომელიც შეიძლება გამოგვადგეს ხშირ შემთხვევაში და მოგვიანებით ვიხილავთ მათ გამოყენებას, მაგრამ ახლა მნიშვნელოვანია ვისწავლოთ დანამატების დაკავშირება.

PLUGIN-ის დეინსტალაციისთვის უბრალოდ წაშალეთ შესაბამისი dll PLUGINS საქაღალდიდან და გადატვირთეთ OllyDbg და დანამატი გაქრება. თუმცა, გონივრულია ყოველთვის ჩართული იყოს COMMAND BAR.

მოდით გავხსნათ CrueHead-ის კრეკი ისევ OllyDbg-ში.

OllyDbg-ში ყველაზე სასარგებლო გასაღებებია:

F7: ახორციელებს კოდის ერთ ხაზს (თუ ჩვენ ვართ CALL, მაშინ შედით კოდის გამოძახებულ განყოფილებაში)

F8: ახორციელებს კოდის ერთ ხაზს (თუ ჩვენ ვართ CALL-ზე, ის უბრალოდ ასრულებს ზარს შიგნით შესვლის გარეშე და გადადის შემდეგ ხაზზე CALL-ის შემდეგ).

ეს ორი ტიპის ხელით მოკვლევა ძალიან განსხვავებულია და რა შემთხვევებში გამოვიყენოთ თითოეული მათგანი მოგვიანებით განვიხილავთ.

F2: ადგენს ნორმალურ წყვეტის წერტილს მონიშნულ ხაზზე. ამ წყვეტის წერტილის მოსაშორებლად, კვლავ დააჭირეთ F2.

Მაგალითად:

ჩვენ გვინდა დავაყენოთ ინსტალაციის წერტილი 40101A პოზიციაზე, ამიტომ ამ ხაზს მაუსით მოვნიშნავთ.

მაუსის ერთი დაწკაპუნებით ის მონიშნულია და ნაცრისფერი ხდება როგორც სურათზე. შემდეგ დააჭირეთ F2.

ჩვენ ვხედავთ, რომ პირველი სვეტის შესაბამისი პოზიცია წითლდება, რაც მიუთითებს, რომ აქ არის წყვეტის წერტილი. F2 ხელახლა დაჭერით შეგიძლიათ ამოიღოთ იგი.

F9: აწარმოებს პროგრამას, რომელიც იმუშავებს მანამ, სანამ არ მიაღწევს წყვეტის წერტილს, არ აყენებს გამონაკლისს ან უბრალოდ არ შეწყვეტს მუშაობას რაიმე მიზეზის გამო. როდესაც პროგრამა მუშაობს, სიტყვა RUNNING გამოჩნდება OllyDbg-ის ქვედა მარჯვენა კუთხეში.

CrueHead's crackme-ის გაშვებით ჩვენ ვნახავთ შემდეგს:

პროგრამის გაშვების დროებით შესაჩერებლად დააჭირეთ F12 ან DEBUG->PAUSE.

ჩვენ ვხედავთ, რომ OllyDbg აჩვენებს სიტყვას PAUSED. შეგიძლიათ განაგრძოთ პროგრამის გაშვება F9 ან DEBUG->RUN დაჭერით.

გამართული პროგრამის დასახურად აირჩიეთ DEBUG->CLOSE.

ეს იყო OllyDbg-ის სწრაფი მიმოხილვა და ჩვენ გავაგრძელებთ მისი მრავალი ვარიანტისა და შესაძლებლობების უფრო ღრმად შესწავლას მომდევნო თავებში. მთავარია ჩამოტვირთოთ პროგრამა, დააკონფიგურიროთ, კიდევ ერთხელ გადახედოთ ყველაფერს, რაც იყო განხილული ამ ტუტორიალში, ასევე დააკავშიროთ დანამატი, დაიწყოთ და შეაჩეროთ CrueHead-ის კრეკი, შეეცადეთ დააყენოთ breakpoints ისე, რომ შემდეგ თავში ეს ყველაფერი არ მოხდეს. იწვევს პრობლემებს.თქვენ ყოყმანი და ეჭვი.

ეს სტატია მოწოდებულია მხოლოდ საინფორმაციო მიზნებისთვის. DAXA პროექტის გუნდი არ ეკისრება პასუხისმგებლობას.

"კრეკინგის გაკვეთილი OllyDbg-ით"
ვფიქრობ, ბევრს აინტერესებს როგორ იშლება პროგრამები?, როგორ შეიძლება გვერდის ავლით რეგისტრაცია, ან როგორ ავუაროთ პროგრამის შეზღუდვას? ამ სტატიაში მოგიყვანთ რეგისტრაციის გვერდის ავლით მარტივ მაგალითს, შევეცდები ავხსნა ყველაფერი ძალიან მარტივად, რათა ყველამ გაიგოს. მიზანშეწონილია გქონდეთ უხეში წარმოდგენა იმაზე, თუ რა არის ასამბლერი, მაგრამ თუ ეს ცოდნა არ გაქვთ, არ ინერვიულოთ, ვფიქრობ, ამ გამოცდილების შემდეგ, თქვენ აუცილებლად შეისწავლით ასამბლერის საფუძვლებს.

ყველა საჭირო პროგრამული უზრუნველყოფის ჩამოტვირთვის შემდეგ დააინსტალირეთ სადაც გინდათ. ყველა პროგრამა არ საჭიროებს ინსტალაციას. უპირველეს ყოვლისა, ჩვენ გავუშვით ჩვენი გამართვის შემქმნელი OllyDbg, როდესაც პირველად გაუშვით, მოგთხოვთ მიუთითოთ გზები UDD-სა და Plugins-მდე, მოდით დავეხმაროთ მას გადადით Options->Appearance->Directories და დაარეგისტრირეთ ორივე გზა (უბრალოდ მიუთითეთ საქაღალდე, სადაც OllyDbg მდებარეობს). არ შეგაშინოთ ბევრი ფანჯარა, ჩვენ გვჭირდება მხოლოდ 3 სამუშაოდ.

1.CPU
2. შესვენების წერტილები
3.ნაწერები

გირჩევ ყველა სხვა ფანჯრის დახურვას, რომ ხელი არ შეგვიშალოს. ახლა მე აგიხსნით ჩვენს დავალებას, ან უნდა ვაიძულებთ პროგრამას მიიღოს ნებისმიერი გასაღები, ან საერთოდ არ გამოაჩინოს რეგისტრაციის შეტყობინება და სამუდამოდ დავივიწყოთ :). ასე რომ, დავიწყოთ, შევეცდები ეტაპობრივად აღვწერო ყველაფერი.

1.გახსენით ჩვენი პროგრამა დებუგერში. ამისათვის გახსენით მენიუ File->Open და აირჩიეთ ჩვენი სატესტო პროგრამა. ჩატვირთვის შემდეგ ამ სურათს CPU ფანჯარაში ვიხილავთ.

ეს არის ჩვენი პროგრამის ასამბლეის კოდი.
ახლა ნება მომეცით ავხსნა რამდენიმე სტრიქონი:
PUSH EBP ; სხვა ფუნქციის დაწყება
დარეკეთ ტესტიP.00405С60; ფუნქციის გამოძახება
ეს ჩვენთვის ჯერჯერობით საკმარისი იქნება.
2.ახლა ჩვენ უნდა ვიპოვოთ ფუნქცია, რომელიც აჩვენებს ფანჯარას, რომელიც მოგთხოვთ კლავიშის შეყვანას. ამისათვის შეასრულეთ პროგრამა ეტაპობრივად F8 კლავიშის დაჭერით, სანამ არ გამოჩნდება ფანჯარა, რომელიც ითხოვს შეყვანას. რამდენიმე დაწკაპუნების შემდეგ გამოჩნდება შეყვანის ფანჯარა.

ახლა ჩვენ ვიცით, რომ სადღაც ამ ფუნქციაში (TestP.004523B8) გამოჩნდება ჩვენი ფანჯარა. ჩვენ უნდა მივიდეთ ფუნქციის ბოლოში, რომელიც აჩვენებს ფანჯარას; ამისათვის ჩვენ უნდა შევიდეთ ამ ფუნქციაში. ახლა ამ სტრიქონამდე CALL TestP.004523B8 უნდა დავაყენოთ წყვეტის წერტილი.ამისთვის შეარჩიეთ ხაზი მის წინ და დააჭირეთ F2 და ნახეთ რომ ეს ხაზი დაემატა Breakpoints ფანჯარას.

შემდეგი, დააწკაპუნეთ ამ ღილაკზე ჩვენი პროგრამის ხელახლა გადმოსაწერად. ახლა ჩვენ უნდა მივაღწიოთ წყვეტის წერტილს, ამისათვის ვაწკაპუნებთ ჩვენი პროგრამის შესასრულებლად და ვხედავთ, რომ შესრულება შეჩერებულია ჩვენს წყვეტის წერტილში. ფუნქციის შესაყვანად დააჭირეთ F7 ღილაკს. მგონი გესმით განსხვავება F8 და F7-ს შორის, პირველი ადევნებს პროგრამას ფუნქციების შეყვანის გარეშე, მეორე ფუნქციების შეყვანით. ჩვენ ვხედავთ ამ სურათს.

უნდა გავაგრძელოთ მანამ, სანამ არ ვიპოვით ფუნქციას, რომელიც აჩვენებს ფანჯარას და ამუშავებს OK ღილაკზე დაჭერით და დაადგენს, სწორად შევიყვანეთ გასაღები თუ არა. გავაგრძელოთ, ასევე დააჭირეთ F8-ს, სანამ ფანჯარა არ გამოჩნდება.

ისევ დავაყენეთ წყვეტის წერტილი მის წინ.

ჩვენ ვაჭერთ და ისევ, ვხედავთ, რომ შესრულება შეჩერებულია ჩვენს პირველ წყვეტის წერტილზე, მაგრამ ჩვენ უნდა გადავიდეთ მეორეზე, ამისათვის კვლავ ვაჭერთ, შესრულება მიაღწევს მეორე წყვეტის წერტილს. ჩვენ შევდივართ ფუნქციაში F7 ღილაკით, ვხედავთ შემდეგს.

ჩვენ კვლავ ვაყენებთ წყვეტის წერტილს და ვბრუნდებით აქ, შევდივართ ფუნქციაში, ვფიქრობ, თქვენ უკვე გესმით, როგორ კეთდება ეს. ფუნქციის შესვლის შემდეგ ვხედავთ შემდეგს.

ჩვენ ვაგრძელებთ ძიებას F8 დაჭერით. როდესაც ჩვენ დააჭირეთ F8, ჩვენ ვხედავთ, რომ API ფუნქციები იწყება,

ასე რომ, ჩვენ უკვე ახლოს ვართ. დააჭირეთ ნელა და უყურეთ, როცა ფანჯარა გამოჩნდება. ეს არის ის, რაც მოხდა, პროგრამის მიკვლევისას ჩვენი ფანჯარა გამოჩნდა დავალების უჯრაში,

გამოვიდა ამ ხაზზე,

მაგრამ როცა მასზე მაუსით დააწკაპუნებ, ფანჯარა არ ჩნდება, რაც იმას ნიშნავს, რომ ჩვენ ვართ იქ, სადაც გვჭირდება, სწორედ ეს ფუნქცია ხატავს ფანჯარას და სადღაც აქ მოწმდება ჩვენ მიერ შეყვანილი გასაღები. ჩვენ ვაგრძელებთ პროგრამის შემდგომ კვალს (F8!) და ამას ვხედავთ ამ ადგილას

ერთგვარი ციკლი, რომელიც გამუდმებით მეორდება, უკვე გვტკივა თითი F8-ის დაჭერა, მაგრამ ის უბრალოდ არ მთავრდება, ამისათვის ჩვენ ვაყენებთ წყვეტის წერტილს ციკლის შემდეგ პირველ ხაზზე (MOV DWORD PTR SS:,EAX)

და ჩვენ ვაჭერთ ღილაკს და ვხედავთ, რომ ფანჯარა მთლიანად დახატულია, ის ელოდება ჩვენგან შეყვანას, პროგრამა გაჩერდა აქ, ციკლში. შემდეგი, შეიყვანეთ ნებისმიერი გასაღები და დააჭირეთ OK.

ფანჯარა დაიხურა და ჩვენ დავბრუნდით გამართვის ფანჯარაში, შესრულება შეჩერდა ჩვენს წყვეტის წერტილზე. ახლა ჩვენ უნდა ვიპოვოთ ფუნქცია, რომელიც აჩვენებს ფანჯარას შეტყობინებებით, რომ გასაღები არასწორად იყო შეყვანილი. ამისათვის თვალყური ადევნეთ ჩვენს პროგრამას (F8), სანამ არ გამოჩნდება შეტყობინების ფანჯარა.

აქ ჩვენ გავარკვევთ რა არის რა. პირველი ხაზი, რომელიც იპყრობს თქვენს თვალს, არის ეს არის ჩვენი სწორი გასაღები, მაგრამ ნუ ელოდებით, რომ თქვენ იპოვით მას ასე მარტივად სხვა პროგრამებში, ჩვეულებრივ, კლავიშები არ ინახება მხოლოდ მეხსიერებაში, ამიტომ ჩვენი ამოცანა იქნება დავრწმუნდეთ, რომ პროგრამა იღებს ნებისმიერ გასაღებს! ახლა მოდით გავაანალიზოთ კოდი ფუნქციის (CALL TestP.00427294) გამოძახებამდე, რომელიც აჩვენებს ფანჯარას შეცდომის შეტყობინებებით. უპირველეს ყოვლისა, ჩვენ ვუყურებთ რეგისტრების ფანჯარას, რომელიც მდებარეობს ფანჯარაში

და ჩვენ ვხედავთ, რომ EAX რეესტრი შეიცავს იმ გასაღების მისამართს, რომელიც ჩვენ შევიყვანეთ მეხსიერებაში და, შესაბამისად, რა შევიტანეთ (მე შევიყვანე 23). აქ ყველაფერი ცოტა უფრო რთულია და თქვენ უნდა გქონდეთ სულ მცირე ცოდნა ძირითადი ასამბლერის ოპერატორების შესახებ. ჩვენ ვფიქრობთ, რომ პროგრამამ ჩვენი გასაღები უნდა შეადაროს სხვას ან სხვაგვარად შეამოწმოს მისი სისწორე, მაგრამ ამისთვის უნდა გამოიძახოს ფუნქცია, რომელიც ამ ყველაფერს გააკეთებს. ასე რომ, ჩვენ ვეძებთ დაახლოებით შემდეგ სტრუქტურას

MOV EAX, ...  //წერს ჩვენი ხაზის მისამართს EAX-ში
...................
დარეკეთ...          //ფუნქციის გამოძახება, რომელიც შეამოწმებს ჩვენი ფუნქციის სისწორეს
JNZ(ან JE) ...// პირობითი ნახტომი (წაიკითხეთ მათ შესახებ!)

ცოტა რამ პირობითი ნახტომის შესახებ, ამ ოპერატორის გამოყენებით შეგიძლიათ გადახვიდეთ კოდის კონკრეტულ ხაზზე, მისამართი მითითებულია ოპერატორის შემდეგ. ეს ნიშნავს, რომ ფუნქციის გამოძახების შემდეგ, თუ ამ ოპერატორის გამოძახების შემდეგ გასაღები სწორად იქნა შეყვანილი, ის გადავა იმ ხაზზე, რის შემდეგაც ჩვენი პროგრამა დაიწყება. თუ არა, მაშინ კოდი მისი შემდეგ შესრულდება. ასე რომ, ჩვენ ვეძებთ, ეს კოდი მაშინვე იპყრობს ჩვენს თვალს

MOV EAX, DWORD PTR SS:
MOV EDX,TestP.00453BA4
დარეკეთტესტიP.00404258
JEმოკლე ტესტიP.00453B4A

ახლა ხელახლა შეასრულეთ კოდის ეს ნაწილი ეტაპობრივად და ნახავთ, რომ ეს ოპერატორია
JE SHORT ტესტიP.00453B4Aგამოტოვებულია და არსად არ გვაგდებს, რაც ნიშნავს, რომ ეს არის ჩვენი ფუნქცია, რომელმაც გადაამოწმა ჩვენი კოდი და აღმოჩნდა არასწორი, რის გამოც JE ოპერატორმა არსად არ დაგვაგდო. მე აგიხსნით, როგორ ამოწმებს ეს ოპერატორი სისწორეს, ჩვენ ყველაფერს ვაკეთებთ "მკაცრად" პირდაპირ :). ეს ნიშნავს რომ კოდის შეყვანის შემთხვევაში ეს ოპერატორი გამოგვიგზავნის მისამართზე 00453B4A და ყველაფერი კარგად იქნება :). ჩვენ ვცვლით ამ ოპერატორს უპირობო ნახტომით (JMP), რომელიც ნებისმიერ შემთხვევაში გადაგვიყვანს ამ მისამართზე. შეხედეთ სად მდებარეობს ეს მისამართი (მონიშნული ხაზი ლურჯად).

ჩვენ ვხედავთ, რომ ფუნქციის გამოძახება, რომელიც აჩვენებს შეტყობინებას, რომ გასაღები არასწორია, გამოტოვებულია.
ხაზის შესაცვლელად, აირჩიეთ იგი და დააჭირეთ Space და შეცვალეთ იგი
ამაზე.
ჩვენ ვხედავთ, რომ ხაზი JE SHORT ტესტიP.00453B4Cშეცვალა ფანჯარაში პატჩებიხაზი დაემატა.

ახლა ჩვენ ვამოწმებთ მუშაობს თუ არა. დააჭირეთ ღილაკს, Breakpoints ფანჯარაში, დააწკაპუნეთ მარჯვენა ღილაკით და მენიუდან აირჩიეთ გამორთვა ყველა. შემდეგი, პატჩების ფანჯარაში, დააწკაპუნეთ მაუსის მარჯვენა ღილაკით ჩვენს ხაზზე და მენიუდან აირჩიეთ Apply Patch. ამის შემდეგ დააჭირეთ ღილაკს, გამოჩნდება ფანჯარა, რომელშიც ითხოვთ კლავიშს, შეიყვანეთ ნებისმიერი გასაღები, დააჭირეთ OK და ჩვენი პროგრამა რეგისტრირებულია. ეს კონკრეტული პროგრამა ყოველთვის ითხოვს გასაღებს, რადგან ეს მხოლოდ ტესტია და რეალური პროგრამა ჩაიწერს საკუთარ თავს, რომ თქვენ სწორად შეიყვანეთ გასაღები.

Შენიშვნა! აქ ჩვენ შევძელით დაუყოვნებლივ ვიპოვოთ კოდის ნაწილი, რომელიც გვჭირდებოდა, მაგრამ ყველაფერი ყოველთვის ასე მარტივი არ იქნება. ზოგჯერ მოგიწევთ ამ ტიპის ყველა სტრუქტურის რიგრიგობით სცადოთ.

3. ბოლო ნაბიჯი არის პაჩის პროგრამაში ჩასმა, ამისთვის გვჭირდება Hex რედაქტორი. ასე რომ, ჩვენ ვხსნით მას და ვირჩევთ ჩვენს პროგრამას, გაიხსნება თექვსმეტობითი ციფრების ღრუბელი. ჩვენ უნდა ვიპოვოთ სტრიქონი JE SHORT TestP.00453B4A თექვსმეტობით და მოვნიშნოთ ის ჩვენით. ვფიქრობ, შენიშნეთ, რომ CPU(OllyDbg) ფანჯარაში მისი თექვსმეტობითი ფორმა იწერება თითოეული ხაზის საპირისპიროდ. იმისათვის, რომ ზუსტად ვიპოვოთ ეს ხაზი, ჩვენ ვეძებთ ასე, უბრალოდ არ შეიყვანოთ ძებნა 74 2Bდა აიღეთ კოდის წინა ხაზი და მოძებნეთ ასე E8 3B 07 FB FF 74 2B

exe ფაილში კოდი მიდის ჯაჭვში, რის გამოც ვიღებთ წინა ხაზს. რატომ ვაკეთებთ ამას? უბრალოდ, ისეთი პატარა ხაზი, როგორიც არის 74 2B, შეიძლება რამდენჯერმე განმეორდეს, ამიტომ ვიღებთ წინა ხაზს, რომ ვიპოვოთ ზუსტად ის, რაც გვჭირდება. შემდეგ ჩვენ ვუყურებთ, თუ როგორ გამოიყურება ჩვენი შეცვლილი სტრიქონი JMP SHORT TestP.00453B4A თექვსმეტობით კოდში, ასე გამოიყურება EB 2B, ასე რომ, ჩვენ ვცვლით ნაპოვნი სტრიქონს ჩვენით, ამისათვის ვაჭერთ ღილაკს და ვცვლით სტრიქონებს ასე.

შეინახეთ ცვლილებები და დახურეთ რედაქტორი. სულ ეს არის, ეს პროგრამა მიიღებს ნებისმიერ გასაღებს, რაც საჭირო იყო. გირჩევთ, დარწმუნდეთ, რომ პროგრამა საერთოდ არ მოგთხოვთ გასაღების შეყვანას.

ᲛᲜᲘᲨᲕᲜᲔᲚᲝᲕᲐᲜᲘ!! სანამ პროგრამების მანიპულირებას დაიწყებთ, უნდა შეამოწმოთ შეფუთული იყო თუ არა *.exe ფაილი. ამისათვის დაგჭირდებათ PEiD პროგრამა. როგორ კეთდება ეს ყველაფერი ცალკე სტატიის თემაა, გირჩევთ თავად გაერკვნენ.

Სალამი ყველას. დღეს მე აღვწერ OllyDebugger-ს. OllyDebugger (შემდგომში Olly) არის შესანიშნავი დებაგერი (ring-3). ამ გამართვის პოპულარობა ნახტომებით და საზღვრებით იზრდება :). დამწყებთათვის, ეს გამართვა არის მხოლოდ საქმე; პროფესიონალებისთვის, რომლებმაც იციან მისი გამოყენება ძალიან კარგად, ეს შეუცვლელი ინსტრუმენტია. ეს სტატია აღწერს ყველაფერს, რისი გაკეთებაც შემიძლია Olly-ში.

1. რა არის Olly Debugger

აღებულია მითითებიდან: Olly არის 32-ბიტიანი ასამბლერის დონის გამართვა ინტუიციური ინტერფეისით. განსაკუთრებით სასარგებლოა, თუ წყაროს კოდი მიუწვდომელია ან როცა პრობლემები გაქვთ კომპილერთან.

მხარდაჭერილი პროცესორები. Olly მხარს უჭერს ყველა 80x86, Pentium, MMX, 3DNow!, მათ შორის Athlon გაფართოებები, SSE ბრძანებები და დაკავშირებული მონაცემთა ფორმატები.

მონაცემთა ფორმატები. Dump windows აჩვენებს მონაცემებს ყველა გავრცელებულ ფორმატში: თექვსმეტობითი, ASCII, Unicode, 16- და 32-ბიტიანი ხელმოწერილი/ხელმოუწერელი/თექვსმეტობითი მთელი რიცხვები, დემონტაჟები (MASM, IDEAL ან HLA).

გაშვება. თქვენ შეგიძლიათ განსაზღვროთ შესრულებადი ფაილი ბრძანების სტრიქონზე, აირჩიოთ მენიუდან, გადაიტანოთ ფაილი Olly-ში, გადატვირთოთ ბოლო პროგრამა, რომელსაც გამართავდით, ან დაურთოთ უკვე გაშვებულ პროცესს. ინსტალაცია არ არის საჭირო, შეგიძლიათ Olly-ის გაშვება ფლოპი დისკიდან!

DLL-ების გამართვა. Olly-ით შეგიძლიათ გამართოთ დამოუკიდებელი დინამიური ბმულების ბიბლიოთეკები (DLL). Olly ავტომატურად უშვებს პატარა შესრულებადს, რომელიც იტვირთება ბიბლიოთეკა და გაძლევთ საშუალებას გამოიძახოთ მისი ექსპორტირებული ფუნქციები.

ანალიზი. ანალიზატორი Olly-ის ერთ-ერთი ყველაზე მნიშვნელოვანი ნაწილია. ის ცნობს პროცედურებს, მარყუჟებს, ცხრილებს, მუდმივებსა და სტრიქონებს, რომლებიც ჩაშენებულია კოდში, სახიფათო კონსტრუქციებს, API ფუნქციის მოთხოვნებს, ფუნქციის პარამეტრების ნომრებს, იმპორტის სექციებს და ა.შ. ანალიზი ხდის ორმაგ კოდს ბევრად უფრო წასაკითხად, აადვილებს გამართვას და ამცირებს ავარიების ალბათობას. ანალიზატორი არ არის ორიენტირებული კომპილერზე და ერთნაირად კარგად მუშაობს Windows-ის ყველა პროგრამასთან.

ობიექტების სკანერი. Olly სკანირებს ობიექტების ფაილებს ან ბიბლიოთეკებს (OMF და COFF ფორმატები), ამოიღებს მათგან კოდს, ანაწილებს მათ და ათავსებს მათ გამართულ პროგრამაში.

სრული უნიკოდის მხარდაჭერა. ASCII სტრიქონებისთვის ხელმისაწვდომი თითქმის ყველა ოპერაცია ასევე ხელმისაწვდომია Unicode სტრიქონებისთვის და პირიქით.

2. ცხელი კლავიშები

სწორედ „ცხელი კლავიშებით“ მინდა ისტორიის დაწყება, რადგან... მათ გარეშე, თქვენ მოგიწევთ დიდი დროის დახარჯვა მენიუში სეირნობისას და დებუგერი მაშინვე დაკარგავს თავის მოხერხებულობას. დავიწყოთ მართვის პანელით:

პირველი ღილაკი არის ფაილის გახსნა (ჰორიზონტალური გასაღები F3)
მეორე ღილაკი არის ფაილის გადატვირთვა (ჰორიზონტალური გასაღები Ctrl+F2)
მესამე ღილაკი არის ფაილის დახურვა (ჰორიზონტალური ღილაკი Alt+F2)
მეოთხე ღილაკი არის პროგრამის დაწყება (ჰორიზონტალური გასაღები F9)
მეხუთე ღილაკი არის გაშვების შეჩერება (ჰორიზონტალური გასაღები F12)
მეექვსე ღილაკი არის კვალი ქვეპროგრამებში შესვლისას (ჰორიზონტალური გასაღები F7)
მეშვიდე ღილაკი არის მიკვლევა ქვეპროგრამებში შესვლის გარეშე (ჰორიზონტალური გასაღები F8)
მერვე ღილაკი არის ავტომატური მიკვლევის დაწყება ქვეპროგრამებში შეყვანით (ჰორიზონტალური ღილაკი Ctrl+F11)
მეცხრე ღილაკი არის ავტომატური მიკვლევის დაწყება ქვეპროგრამებში შესვლის გარეშე (ჰორიზონტალური ღილაკი Ctrl+F12)
მეათე ღილაკი არის პროგრამის შესრულება ქვეპროგრამიდან გასვლამდე (ჰორიზონტალური ღილაკი Ctrl+F9)
მეთერთმეტე ღილაკი – გადადით მისამართზე (ჰორიზონტალური კლავიატურა Ctrl+G)

საკონტროლო პანელზე ყველა სხვა ღილაკი მოგვიანებით იქნება განხილული.

საჭირო ბრძანებები:
Ctrl + A - გაანალიზეთ კოდი
Ctrl + C - მონაცემების კოპირება
Ctrl+F7 – ჩართეთ რეჟიმი, სადაც კოდი შესრულდება ისე, თითქოს დააჭირეთ და არ გაათავისუფლეთ F7 ღილაკი
Ctrl+F8 – ჩართეთ რეჟიმი, სადაც კოდი შესრულდება ისე, თითქოს დააჭირეთ და არ გაათავისუფლეთ F8 ღილაკი
Shift+F8 – განაგრძეთ პროგრამის მიკვლევა, თუნდაც გამონაკლისი მოხდეს
Shift+F9 – განაგრძეთ პროგრამის გაშვება, თუნდაც გამონაკლისი მოხდეს
Ctrl+T – ავტომატური ტრეკერის პარამეტრები
Ctrl+F11 – დაიწყეთ ავტომატური მიკვლევა ქვეპროგრამებში შესვლით
Ctrl+F12 – დაიწყეთ ავტომატური მიკვლევა ქვეპროგრამებში შესვლის გარეშე
F2 – მოათავსეთ წყვეტის წერტილი არჩეულ ხაზზე

3. დანამატები

თქვენ ალბათ დაიწყეთ აღშფოთება იმის გამო, თუ რატომ ვსაუბრობ ყველაფერზე, მაგრამ არა თავად დებუგერზე. საპასუხოდ, მე ვიტყვი: ”მე ვნახავ, როგორ გამართავთ პროგრამას, ყოველ შემთხვევაში CommandBar მოდულის გარეშე.” დიახ, მართალია, ბევრად უფრო რთულია პროგრამის გამართვა დანამატების გარეშე. ახლა მე მივცემ ჩემს მიერ დაინსტალირებული დანამატების ჩამონათვალს და გზად აგიხსნით რა არის:

1. IsDebuggerPresent – ​​მალავს დებუგერს გამოვლენისგან IsDebuggerPresent ფუნქციის გამოყენებით.
2. დამალვა Debugger – მალავს debugger-ს აღმოჩენისგან IsDebuggerPresent ფუნქციის გამოყენებით.
3. Olly Script - გაძლევთ საშუალებას დაწეროთ სკრიპტები, რათა დაგეხმაროთ გამართვაში. მე არ ვიყენებ ამ დანამატს, რადგან... არა მგონია საჭირო იყოს გამართვის ავტომატიზაცია.
4. Olly Dump – გაძლევთ საშუალებას გადააგდოთ გამართული პროცესი და ერთდროულად აღადგინოთ მისი იმპორტი. სუპერ მოდული. ყველას ვურჩევ.
5. Command Bar - საოცრებების მოწყობის საშუალებას გაძლევთ. გამართვის ხაზში ჩნდება ხაზი, სადაც შეგიძლიათ შეიყვანოთ ძალიან ჭკვიანი ბრძანებები. IMHO ამ მოდულის გამართვის გარეშე შეუძლებელია :). სერთიფიკატი მე ვთარგმნე პლაგიიდან და მოგაწოდებთ დამატებით No1.

4. პირველი გაცნობა

როგორც უკვე ვთქვი, დებუგერთან მუშაობა ძალიან მარტივია. აქ არის ძირითადი ფანჯრის სტანდარტული ხედი, სადაც პროგრამა ჩატვირთულია გამართვისთვის:

მეთქი სტანდარტული ფანჯარაა, მოვიტყუე, ფერები შევცვალე :). ახლა ყველაფერი რიგზეა. აღწერის თანმიმდევრობით: მთავარი ფანჯარა, რეგისტრაციის ფანჯარა, დასტის პანელი, მენიუს პანელი.

მთავარი ფანჯარა: ეს ფანჯარა არის სადაც ხდება ფაქტობრივი გამართვა. ყველა ინსტრუქცია მოცემულია დაშლილი სახით. თქვენ შეგიძლიათ გადაიტანოთ ინდექსის ხაზი კურსორის გამოყენებით. ინდექსის ხაზის გამოყენებით შეგიძლიათ აირჩიოთ რომელი მონაცემები დააკოპიროთ (აქ ყველაფერი ბევრად უფრო მარტივია, ვიდრე SoftIce-ში. არჩეულია. Ctrl+C, წავიდა სწორ ადგილას Ctrl+V), რომელი ბრძანება შეიცვალოს, სად დადგეს წყვეტის წერტილი და ა.შ. . მისამართი, რომელიც უნდა შესრულდეს შემდეგ, მონიშნულია გვერდზე. მისამართების სვეტსა და დაშლილ ჩამონათვალის სვეტს შორის არის სვეტი მანქანის კოდის ინსტრუქციებით. ბოლო სვეტი შეიცავს კომენტარებს.

რეგისტრაციის ფანჯარა: რეგისტრაციის ფანჯარა აჩვენებს ყველა 32-ბიტიან რეგისტრს, დროშის რეგისტრს და სხვა სხვა რეგისტრებს. რეგისტრის შესაცვლელად, თქვენ უნდა დააჭიროთ მის მნიშვნელობას 2-ჯერ და შეიყვანოთ ახალი მნიშვნელობა. თქვენ შეგიძლიათ შეცვალოთ დროშის რეესტრი ერთ-ერთ მათგანზე ორჯერ დაწკაპუნებით.

დასტის პანელი: სტეკის პანელში შეგიძლიათ შეცვალოთ საჭირო ბაიტები მეხსიერებაში, დააყენოთ წყვეტის წერტილები და მოძებნოთ სწორი რეგულაციები. კოდები და ა.შ.

მენიუს ზოლი: მენიუს ზოლი უფრო დიდ თავში იქნება დაფარული, რადგან... ეს თემა ძალიან მნიშვნელოვანია.

5. ძირითადი მენიუს გაცნობა

დავიწყოთ მენიუთი სახელწოდებით File. ამ მენიუს აქვს ჩანართები: გახსნა, მიმაგრება, გამოსვლა. გახსნა – გახსენით ფაილი გამართვისთვის, მიმაგრება – შეუერთდით უკვე გაშვებულ პროცესს გამართვისთვის, გასვლა – გასვლა.

ხედი
ჟურნალი – იხილეთ ჟურნალი ფაილის ჩამოტვირთვის შესახებ და ა.შ. (ჰოტკლავი: Alt+L)
შესრულებადი მოდულები - იხილეთ ყველა მოდული, რომელსაც იყენებს პროგრამა, რომლის გამართვა ხდება. (ჰოტკლავი: Alt+E)
მეხსიერება - მეხსიერების ბარათის ნახვა. აქ არის მისი სავარაუდო გარეგნობა:

პირველი სვეტი არის მისამართი, სადაც იტვირთება ფაილის სხვადასხვა სექცია, DLL ბიბლიოთეკები. მეორე სვეტი არის ზომა განყოფილების მეხსიერებაში. მესამე სვეტი, როგორც წესი, არის მოდულის სახელი. მეოთხე სვეტი არის სექციების სახელი. მეხუთე სვეტი არის ის, რაც შეიცავს განყოფილებას. ყველა სხვა სვეტი არ არის მნიშვნელოვანი, რადგან ისინი ასახავს სექციების ატრიბუტებს მეხსიერებაში. (ჰოტკლავი: Alt+M)

Threads – იხილეთ პროგრამის ყველა თემა, გაყინეთ ისინი, p`glnpnghr| შეცვალე მათი პრიორიტეტი, მოკალი ისინი.
Windows – იხილეთ მდე x.. ინფორმაცია Windows-ის, კლასების და ა.შ. გამოიყენება პროგრამის მიერ.
სახელურები – სახელურების ნახვა.
CPU - გახსენით მთავარი ფანჯარა. (ჰოტკლავი: Alt+C)
SEH Chain – ნახეთ, დააყენეთ წყვეტის წერტილი ყველა გამოცხადებულ Seh-ზე.
პატჩები – იხილეთ პროგრამაში განხორციელებული ყველა ცვლილების სია, გააუქმეთ ყველა ცვლილება და ა.შ. (ჰოტკლავი: Ctrl+P)
Call Stack – იხილეთ დასტაში არსებული ყველა ზარის კოდი. (ჰოტკლავი: Alt+K)
შესვენების წერტილები - იხილეთ ყველა წყვეტის წერტილი, გამორთეთ, წაშალეთ ისინი. (ჰოტკლავი: Alt+B)
Run Trace – იხილეთ კვალის ჟურნალი.
ფაილი - თექვსმეტობითი ფაილის რედაქტორი.

გამართვა
გაშვება - გაუშვით აპლიკაცია.
პაუზა - შეაჩერე აპლიკაციის შესრულება.
გადატვირთვა - გადატვირთეთ პროგრამა, რომელიც გამართულია.
დახურვა - გამართული პროგრამის დახურვა.
გადადით – F7-ის ექვივალენტი.
გადადგმული ნაბიჯი – F8-ის ექვივალენტი.
Animate into – F7-ის მუდმივი დაჭერის ტოლფასია.
ანიმაცია მეტი - F8-ის მუდმივი დაჭერის ტოლფასი.
შეასრულეთ დაბრუნებამდე – შეასრულეთ პროგრამა ქვეპროგრამიდან გასვლამდე.
Trace into – ავტომატური მიკვლევა ქვეპროგრამებში შესვლით.
Trace over – ავტომატური მიკვლევა ქვეპროგრამებში შესვლის გარეშე.
პირობის დაყენება - მიანიჭეთ პირობა ავტომატური ტრასინგისთვის.
დახურვა გაშვების კვალი – შეაჩერე ავტომატური მიკვლევა.
ტექნიკის წყვეტის წერტილები – იხილეთ აპარატურის წყვეტის წერტილები.

ყველაფერი დანარჩენი ამ მენიუში არ არის მნიშვნელოვანი.

Პარამეტრები
გარეგნობა – Debugger-ის ინტერფეისის პარამეტრები. ამ პარამეტრებზე არ შევჩერდები, რადგან... ისინი არ არის სავალდებულო და თქვენ თავად შეგიძლიათ გაერკვნენ.
გამართვის პარამეტრები (ჰორიზონტალური გასაღები – Alt+O) – გამართვის პარამეტრები. ეს ყველაზე საინტერესოა, შემდეგ თავს მენიუს ამ პუნქტს დავუთმობ.
დროული გამართვა – ამ პარამეტრებში შეგიძლიათ მივანიჭოთ Olly, როგორც გამართვის საშუალება, რომელიც ამოქმედდება, როდესაც რომელიმე აპლიკაცია გამოიწვევს სერიოზულ შეცდომას.
Explorer-ში დამატება – დაამატეთ ელემენტი პროგრამის გამართვისთვის Explorer-ის კონტექსტურ მენიუში.

6. ძირითადი პროგრამის პარამეტრები

მე მხოლოდ ყველაზე მნიშვნელოვან ვარიანტებს აგიხსნით.

უსაფრთხოება
გაფრთხილება, როდესაც წყვეტის წერტილი არის კოდის განყოფილების მიღმა – შეატყობინეთ, თუ გსურთ განათავსოთ წყვეტის წერტილი კოდის განყოფილების გარეთ. რა თქმა უნდა, ეს ვარიანტი არ უნდა იყოს არჩეული.
გააფრთხილეთ აქტიური პროცესის შეწყვეტისას – ჰკითხეთ: „ნამდვილად გსურთ პროცესის შეწყვეტა?“ ეს ვარიანტი უნდა იყოს არჩეული.
გაფრთხილება, თუ არა ადმინისტრატორი – შეგაწუხოთ, თუ ადმინისტრატორი არ ხართ. ეს ვარიანტი სადომაზოხიზმისთვისაა :)

გამართვა
დააყენეთ მაღალი პრიორიტეტი გამართული პროცესის მიკვლევისას – დააყენეთ b(qnjhi) პრიორიტეტი აპლიკაციისთვის, როცა თვალყურს ადევნებთ. ეს ვარიანტი უნდა იყოს არჩეული „გემოვნებით“ (მე არჩეული მაქვს).

Ივენთი
გააკეთე პირველი პაუზა - გააკეთე პირველი გაჩერება. ამ შემთხვევაში შემოთავაზებულია სამი ვარიანტი: სისტემის გაწყვეტის წერტილი, შესვლის წერტილი მთავარ მოდულში, მთავარი ფანჯარა. კიდევ ერთხელ, თქვენ ყველამ უნდა აირჩიოთ საუკეთესო ვარიანტი. მე შევარჩიე შესვლის წერტილი მთავარ მოდულში.
გატეხეთ ახალი DLL მოდული – შეჩერდით ყოველ ახალ ჩატვირთულ ბიბლიოთეკაზე.
შესვენება მოდულის გადმოტვირთვაზე – შეჩერება DLL ბიბლიოთეკების მეხსიერებიდან გადმოტვირთვისას.
შესვენება ახალ თემაში - შეჩერება ახალი თემის შექმნისას.
გატეხვა ძაფის ბოლოზე - გააჩერეთ, როდესაც ძაფი დასრულდება.

გამონაკლისები
მეხსიერების წვდომის დარღვევის იგნორირება KERNEL32-ში – მეხსიერების შეცდომების იგნორირება Kernel32-ში.
Int3 breaks - არ შეჩერდეთ int3 ბრძანებებზე. ეს ვარიანტი ძალიან სასარგებლოა ზოგიერთი დამცავი შეფუთვისას. წაიკითხეთ ჩემი unboxing სტატია დამატებითი ინფორმაციისთვის.

კვალი
გაშვებული კვალი ბუფერის ზომა – კვალი ბუფერის ზომა. უმჯობესია დააყენოთ მაქსიმალური მნიშვნელობა.
ჟურნალის ბრძანებები - შეინახეთ ტრასერის მუშაობის ჟურნალი. ეს პარამეტრი ოდნავ ანელებს მიკვლევას, ამიტომ უნდა დაყენდეს საჭიროების შემთხვევაში.
ყოველთვის თვალყური ადევნეთ სისტემის DLL-ებს – ყოველთვის თვალყური ადევნეთ წარსულის სისტემის ბიბლიოთეკებს. ეს ვარიანტი ყველასთვის უნდა იყოს შერჩეული.
RET-მდე შესრულების შემდეგ, გადადით RET-ზე – ეს პარამეტრი საშუალებას გაძლევთ შეჩერდეთ Ctrl+F9 დაჭერისას არა RET-ზე, არამედ მისი შესრულების შემდეგ. მე ეს ვარიანტი ძალიან მოსახერხებელია, ამიტომ გირჩევთ აირჩიოთ იგი.

SFX
როდესაც მთავარი მოდული არის თვითმმართველობის ამოღება - აქ ჩვენ გვთხოვენ ავირჩიოთ სამი ვარიანტიდან ერთი: შეჩერება ამოხსნის კოდის დასაწყისში, Trace to OEP ბლოკებში, Trace to OEP byte. აბა, რა შემიძლია ვთქვა, ვარიანტები უფასო დატვირთვისთვის. ავტომატური ძებნა OER! მართალია, ზოგჯერ Olly სწორად არ განსაზღვრავს პროგრამა შეფუთულია თუ არა.

სიმები
ისე, აქ ყველაფერი გასაგებია. სხვადასხვა სიმბოლოების გაშიფვრა.

მისამართები
ეს პარამეტრები არ არის მნიშვნელოვანი, რადგან ისინი განსაზღვრავენ, თუ როგორ გამოჩნდება მისამართები.

ბრძანებები
ეს პარამეტრები საჭიროა მხოლოდ მათთვის, ვისაც ნამდვილად უყვარს ძალიან ლამაზი ACM სიები.

დაშლა
დემონტაჟის პარამეტრები. შეგიძლიათ დააჭიროთ ყველა ვარიანტს და ნახოთ, როგორ გამოიყურება asm ჩამონათვალი. ყველა სხვა პარამეტრი არ არის მნიშვნელოვანი ჩემი აზრით.

7. პირველი გამართვა

ჩვენ გავმართავთ Fant0m crackme 4-ს. შეგიძლიათ გადმოწეროთ აქედან: http://fant0m.cjb.net/. ამ crackme-დან ჩვენ შევეცდებით მივიღოთ სწორი რეგ. ნომერი თქვენი სახელისთვის. ჩატვირთეთ crackme გამართვის ქვეშ და დააჭირეთ F9 გასაშვებად. შეიყვანეთ იმ პირის სახელი, ვისთვისაც გვინდა დაარეგისტრიროთ ეს crackme. შეიყვანეთ ნებისმიერი პაროლი. ასე რომ, ახლა ჩვენ უნდა დავაყენოთ წყვეტის წერტილი სახელისა და პაროლის წასაკითხად. გადართეთ Olly-ზე და qrpnje ბრძანებაში ჩაწერეთ bpx GetDlgItemTextA. დააწკაპუნეთ შემოწმება. ჩვენ მაშინვე აღმოვჩნდით ოლიში ამ ადგილას:

00401217 E8 62010000 დარეკეთ 0040121C 68 00010000 PUSH 100 00401221 68 84314000 PUSH 00403184 00401226 68 E9030000 PUSH 3E9 ; |ControlID = 3E9 (1001.) 0040122B FF75 08 PUSH DWORD PTR SS: ; |hWnd 0040122E E8 4B010000 CALL 00401233 FF75 08 PUSH DWORD PTR SS: 00401236 E8 BE000000 დარეკეთ 004012F9 0040123B 83F8 00 CMP EAX, 0 0040123E 740123E 7400001 A 40 PUSH 40 00401242 68 29304000 PUSH 00403029; |სათაური = "შეამოწმეთ სერიალი" 00401247 68 60304000 PUSH 00403060 ; |Text = "You got it! Congrats! :)" 0040124C 6A 00 PUSH 0 ; |hOwner = NULL 0040124E E8 49010000 CALL !} >

დაუყოვნებლივ ირკვევა, რომ პროცედურაში 004012F9 მისამართზე მიმდინარეობს სარეგისტრაციო შემოწმება. ჩვენ მივაღწევთ მის ზარს F8-ით და შევდივართ F7-ის გამოყენებით. რასაც ჩვენ ვხედავთ:

004012F9 55 PUSH EBP 004012FA 8BEC MOV EBP, ESP 004012FC 56 PUSH ESI 004012FD 57 PUSH EDI 004012FE 8D3584304000 LEAD0304000 LEAD0DSI 4324 000 LEA EDI, DWORD PTR DS: 0040130A 33C0 XOR EAX, EAX 0040130C 33C9 XOR ECX, ECX 0040130E B31A MOV BL, 1A 00401310 803E00 CMP BYTE PTR DS:, 0 00401313 7415 JE SHORT 0040132A 00401315 8A06 MOV AL, BYTE 10040C: 0401319 32C 1 XOR AL, CL 0040131B F6F3 DIV BL 0040131D 66C1E808 SHR AX, 8 00401321 0441 ADD AL, 41 00401323 8807 MOV BYTE PTR DS:, AL 00401325 47 INC EDI 00401326 46 INC ESI 00401327 EDI 004013270X04 401310 0040132A C 60700 MOV BYTE PTR DS:, 0 0040132D 33C0 XOR EAX, EAX 0040132F 83F900 CMP ECX, 0 00401332 741A JE SHORT 0040134E 00401334 6884324000 PUSH 00403284; /String2 = "" 00401339 6884314000 PUSH 00403184 ; |String1 = "qwerty" 0040133E E8A1000000 CALL 00401343 83F800 CMP EAX, 0 00401346 7404 JE SHORT 0040134C 00401348 33C0 XOR EAX, EAX 0040134A EB02 JMP0130134C, JMP0130134C ECX 0 040134E 5F POP EDI 0040134F 5E POP ESI 00401350 C9 LEAVE 00401351 C20400 RETN 4
ამ კოდიდან ირკვევა, რომ 0040133E მისამართზე თქვენი კოდი შედარებულია სწორთან. მოათავსეთ წყვეტის წერტილი ამ მისამართზე და დააჭირეთ F9. კომენტარი String2 = "" შეიცვლება მსგავსი რამით String2 = "ODMZAMHN". ასე რომ, ადგილისთვის ODMZAMHN გექნებათ თქვენი რეგ. თქვენი სახელის კოდი. დააჭირეთ F9, შეიყვანეთ სწორი კოდი, დააჭირეთ Check, ამოიღეთ ყველა წყვეტის წერტილი, დააჭირეთ F9 და გაიხარეთ.

დანართი No1

დახმარება Command Bar-ში. Command Bar ბრძანებების ახსნა. ყველა ბრძანება, რომელიც არასაჭიროდ მიმაჩნია, ამოიღეს ამ სიიდან.

გამონათქვამები
CALC [გამოხატვა] - გამოთვალეთ გამოხატვის მნიშვნელობა

დემონტაჟი
AT [გამოხატვა] - გადადით მისამართზე disassembler-ში
FOLLOW [გამოხატვით] - გადადით მისამართზე დემონტაჟში
ORIG - გადადით მიმდინარე მისამართზე (EIP)
* - გადადით მიმდინარე მისამართზე (EIP)

გადაყარეთ და დააწყვეთ
D [გამოხატვა] - გადადით ნაგავსაყრელში არსებულ მისამართზე
DUMP [გამოხატვა] - გადადით ნაგავსაყრელში არსებულ მისამართზე
DA [გამოხატვა] - გადაყრა ასამბლერის ფორმატში
DB [გამოხატვა] - ნაგავსაყრელი თექვსმეტობით
DC [გამოხატვა] - ნაგავსაყრელი ASCII კოდირებით
DD [გამოხატვა] - მისამართების გადატანა (დასტის ფორმატი)
DU [გამოხატვა] - გადაყრა UNICODE კოდირებაში
DW [გამოხატვა] - ნაგავსაყრელი თექვსმეტობითი სიტყვის ფორმატში
STK [გამოხატვა] - გადადით დასტაზე მისამართზე

მაუწყებლობა
A [გამოხატვა] [, ბრძანება] - მისამართის დაშლა

ტეგები და კომენტარები
L გამოხატულება, ლეიბლი - აკავშირებს სიმბოლურ ეტიკეტს მისამართთან
C გამოხატულება, კომენტარი - ადგენს კომენტარს მისამართისთვის

შესვენების წერტილები
BP [გამოხატვა] [,პირობა] - დააყენეთ წყვეტის წერტილი
BPX [ფუნქციის სახელი] - დააყენეთ წყვეტის წერტილები მოდულის ყველა ინსტრუქციაზე, რომელიც იძახის [ფუნქციის სახელი]
BC [მისამართი] - წაშალეთ საკონტროლო წერტილი მისამართზე
MR express1 [,expression2] - დააყენეთ წყვეტის წერტილი მეხსიერებაზე კონკრეტულ ზონაში წვდომისთვის
MBT express1 [, express2] - დააყენეთ წყვეტის წერტილი მეხსიერებაში ჩასაწერად კონკრეტულ ზონაში
MD - წაშალეთ წყვეტის წერტილი მეხსიერებიდან
HR [მისამართი] - დააყენეთ Hardware breakpoint ერთ ბაიტზე თითო მისამართზე წვდომაზე
HW [მისამართი] - დააყენეთ ტექნიკის წყვეტის წერტილი ერთ ბაიტზე თითო ჩაწერა მისამართზე
HE [მისამართი] - დააყენეთ Hardware breakpoint მისამართის ბრძანების შესასრულებლად
HD [breakpoint number] - წაშალეთ აპარატურის გაწყვეტის წერტილის ნომერი

კვალი ბრძანებები
STOP - შეაჩერე კვალი
PAUSE - პაუზის მიკვლევა
RUN - გაუშვით პროგრამა
G [მისამართი] - შეასრულეთ მისამართი
GE - შეასრულეთ მისამართი
S - F7-ის ექვივალენტი
SI - F7-ის ექვივალენტი
SO - F8-ის ექვივალენტი
TR - შეასრულეთ პროგრამა ქვეპროგრამიდან გასვლამდე

OllyDbg Windows
LOG - ჟურნალის ხედვის ფანჯარა
MOD - შესრულებადი მოდულების ნახვა
MEM - გახსენით მეხსიერების ბარათის ფანჯარა
CPU - გახსენით პროგრამის მთავარი ფანჯარა
BRK - გახსენით წყვეტის წერტილის სანახავი ფანჯარა
OPT - პარამეტრები

სხვადასხვა გუნდები
EXIT - Exit Olly
QUIT - დაანებე ოლი
OPEN [ფაილის სახელი] - გახსენით ფაილი გამართვისთვის
CLOSE - დახურეთ პროგრამა, რომელიც გამართულია
RST - გადატვირთეთ პროგრამა, რომელიც გამართულია
დახმარება - დახმარების ჩვენება (ეს ტექსტი, მაგრამ თარგმნილი)
დახმარება - Olly show Oll-ის დახმარება
HELP APIfunction - დახმარება API ფუნქციებზე

დანართი No2

შესვენების წერტილები. Olly მხარს უჭერს რამდენიმე ტიპის წყვეტის წერტილებს:
- რეგულარული წყვეტის წერტილი, სადაც ბრძანების პირველი ბაიტი, რომლის გაწყვეტაც გსურთ, იცვლება INT3-ით (Trap to Debugger). თქვენ შეგიძლიათ განათავსოთ წყვეტის წერტილი დემონტაჟში ბრძანების არჩევით და F2-ზე დაჭერით, ან ამომხტარი მენიუს მეშვეობით. როდესაც მეორედ დააჭერთ F2-ს, როდესაც წყვეტის წერტილი უკვე დაყენებულია, ის წაიშლება. INT3 წყვეტის წერტილების რაოდენობა შეუზღუდავია. როდესაც თქვენ ხურავთ პროგრამას, რომელსაც ახდენთ გამართვა, ან გამართვის მოწყობილობას, Olly ავტომატურად ინახავს წყვეტის წერტილებს. არასოდეს შეეცადოთ დააყენოთ წყვეტის წერტილი მონაცემებზე ან ბრძანების შუაში! Olly გაგაფრთხილებთ, თუ შეეცდებით დააყენოთ წყვეტის წერტილი კოდის განყოფილების გარეთ. თქვენ შეგიძლიათ გამორთოთ ეს გაფრთხილება თქვენი დაცვის პარამეტრებში. ზოგიერთ შემთხვევაში, Debugger-მა შეიძლება ჩადოს თავისი დროებითი INT3 წყვეტის წერტილები.

პირობითი წყვეტის წერტილი (ჰორიზონტალური ღილაკი Shift+F2) - ჩვეულებრივი INT3 წყვეტის წერტილი პირობით. ყოველ ჯერზე, როცა გამართვა ხვდება ასეთ წყვეტის წერტილს, ის აფასებს მის გამოხატვას და, თუ შედეგი არ არის ნულოვანი ან გამოთქმა არასწორია, აჩერებს პროგრამის გამართვას.

პირობითი წყვეტის წერტილი ლოგინგთან ერთად (ჰორიზონტალური კლავიატურა Shift+F4) - პირობითი წყვეტის წერტილი ლოგინგით, რათა მოხდეს ცნობილი ფუნქციის გამოხატვის ან პარამეტრების მნიშვნელობის შესვლა ყოველ ჯერზე, როდესაც შესრულდება წყვეტის წერტილი.

შესვენების წერტილი მეხსიერებისთვის. Olly გაძლევთ საშუალებას დააყენოთ ერთი წყვეტის წერტილი მეხსიერებაში ერთდროულად. თქვენ ირჩევთ მეხსიერების გარკვეულ ნაწილს დემონტაჟში ან CPU-ის ამონაწერში და იყენებთ ამომხტარ მენიუს წყვეტის წერტილის დასაყენებლად o`lr|. მეხსიერების წინა წერტილი, ასეთის არსებობის შემთხვევაში, ავტომატურად წაიშლება. თქვენ გაქვთ ორი ვარიანტი: შეაჩერე მეხსიერებაზე წვდომა (წაკითხვა, ჩაწერა ან შესრულება) და მხოლოდ ჩაწერა. წყვეტის წერტილის დასაყენებლად, Olly ცვლის მეხსიერების ბლოკების ატრიბუტებს, რომლებიც შეიცავს მონაცემებს.

ტექნიკის გაწყვეტის წერტილი (ხელმისაწვდომია მხოლოდ Windows ME, NT, 2000 ან XP-ში გამართვისას). 80x86-თან თავსებადი პროცესორები საშუალებას გაძლევთ დააყენოთ 4 ტექნიკის წყვეტის წერტილი. მეხსიერების წყვეტის წერტილისგან განსხვავებით, ტექნიკის წყვეტის წერტილები არ ანელებს შესრულების სიჩქარეს, არამედ ფარავს მხოლოდ 4 ბაიტს.

მეხსიერების წვდომის ერთჯერადი გაჩერება (ხელმისაწვდომია მხოლოდ Windows NT, 2000 და XP-ში). თქვენ შეგიძლიათ დააყენოთ მეხსიერების ფანჯარაში მეხსიერების მთლიან ბლოკზე, ამომხტარი მენიუს საშუალებით ან F2-ზე დაჭერით. ეს წყვეტის წერტილი განსაკუთრებით სასარგებლოა, თუ გსურთ გარკვეული მოდულის მიმართ მოთხოვნების ჩარევა.

Autotrace – თქვენ უნდა მიუთითოთ პირობა (ჰორიზონტალური კლავიატურა Ctrl+T), რომლის მიხედვითაც გამართავი შეაჩერებს პროგრამას. გთხოვთ გაითვალისწინოთ, რომ ამ პარამეტრს შეუძლია მნიშვნელოვნად (20%-მდე) შეანელოს პროგრამის შესრულების სიჩქარე.

OllyDbg-ს ასევე შეუძლია შეაჩეროს პროგრამის შესრულება გარკვეულ მოვლენებზე, მაგალითად DLL-ის ჩატვირთვის ან გადმოტვირთვისას, ან ძაფების წარმოქმნის ან შეწყვეტისას.

დანართი No3

ჩემი გამართვის პარამეტრები.
თუ გსურთ გამოიყენოთ ჩემი პარამეტრები, შეცვალეთ ყველა მონაცემი ამ ტექსტით ollydbg.ini ფაილში, რომელიც მდებარეობს იმავე საქაღალდეში, სადაც დაინსტალირებულია გამართვა.

შეამოწმეთ DLL ვერსიები=0 ინსტრუმენტთა ზოლის ჩვენება=1 სტატუსი ხელსაწყოთა ზოლში=0 გამოიყენეთ ტექნიკის წყვეტის წერტილები საფეხურზე=1 ფანჯრების აღდგენა=104191 გადახვევა MDI=1 ჰორიზონტალური გადახვევა=0 ყველაზე მაღალი ფანჯარა=0 ნაგულისხმევი შრიფტის ინდექსი=1 ნაგულისხმევი ფერების ინდექსი=0 ინდექსი ნაგულისხმევი სინტაქსის ხაზგასმა=0 ბუფერის ზომის ინდექსი=0 ბუფერის ზომის ინდექსის ჩანაწერის გაშვება=7 მიმდებარე ბრძანებების დაჯგუფება პროფილში=1 ხაზგასმული კვალის რეგისტრი=-1 იდეალური დაშლის რეჟიმი=0 დაშლა მცირე ასოებით=0 არგუმენტების გამოყოფა TAB=0 დამატებითი სივრცით არგუმენტებს შორის=1 ნაგულისხმევი სეგმენტების ჩვენება=1 მახლობლად ნახტომის მოდიფიკატორები=0 გამოიყენეთ სტრიქონების ბრძანებების მოკლე ფორმა=0 ზომა მგრძნობიარე მნემონიკა=1 SSE ზომის დეკოდირების რეჟიმი=0 FPU დასტას ზედა=1 ყოველთვის აჩვენე მეხსიერების ზომა=1 რეგისტრების გაშიფვრა ნებისმიერი IP-სთვის =0 სიმბოლური მისამართების ჩვენება=1 ლოკალური მოდულის სახელების ჩვენება=0 ნაცრისფერი მონაცემები გამოიყენება შევსებად=1 გადახტომის მიმართულების ჩვენება=0 გადახტომის ბილიკის ჩვენება=0 ბილიკების ჩვენება, თუ გადახტომა არ არის განხორციელებული=0 ხაზი გაუსვით შესწორებებს=1 ცენტრი FOLLOW command=0 ჩვენება stack frames=1 ლოკალური სახელების ჩვენება stack=1 Extended stack trace=0 სინქრონიზაცია წყარო CPU=1 SFX ამომყვანის ჩართვა კოდში=1 SFX trace mode=0 რეალური SFX ჩანაწერის გამოყენება წინა გაშვებიდან=1 SFX გამონაკლისების იგნორირება =1 პირველი პაუზა=1 შეჩერება ახალ DLL-ზე=0 გაჩერება DLL-ზე განტვირთვა=0 შეჩერება ახალ თემაში=0 შეჩერება თემის ბოლოს=0 გაჩერება გამართვის სტრიქონზე=0 SSE რეგისტრების გაშიფვრა=0 ბოლო შეცდომის ჩართვა=1 წვდომის დარღვევის იგნორირება KERNEL32=1 იგნორირება INT3=1 იგნორირება TRAP=0 იგნორირება წვდომის დარღვევები=0 ნაბიჯი უცნობი ბრძანებებში=1 დაყოფის იგნორირება 0=0 უკანონო ინსტრუქციების იგნორირება=0 FPU-ის ყველა გამონაკლისის იგნორირება=0 გაფრთხილება ხშირი შესვენების დროს=0 გაფრთხილება, როდესაც შესვენება არ არის კოდი=0 Autoreturn=1 თავდაპირველი ბრძანების შენახვა კვალში=1 მიკვლეული ESP=1 ანიმაცია სისტემის DLL-ებზე=1 სტრიქონი ბრძანებების მიკვლევა=1 CPU-ის სინქრონიზაცია და ტრასის გაშვება=0 მორგებული გამონაკლისების იგნორირება=1 ჭკვიანი განახლება=1 მაღალი პრიორიტეტის დაყენება= 1 არგუმენტების დამატება=1 გამოიყენეთ ExitProcess=1 ნება მიეცით ინექცია მიიღოს WinProc=0 დაალაგეთ WM_XXX სახელით=0 ბოლო WinProc გაწყვეტის წერტილის ტიპი=0 ნახატი თოვლისგან თავისუფალი=1 სიმბოლური სახელების ამოღება=0 შეინახეთ რიგითი სახელი=1 მხოლოდ ASCII დასაბეჭდად dump=0 დიაკრიტიკული სიმბოლოების დაშვება=1 სტრიქონის გაშიფვრა=0 გაფრთხილება, თუ არა ადმინისტრატორი=0 გაფრთხილება პროცესის შეწყვეტისას=1 დიალოგების გასწორება=1 გამოძახების შრიფტის გამოყენება window=0 მითითებული დიალოგის შრიფტი=0 ფანჯრის პოზიციების აღდგენა=1 სვეტების სიგანის აღდგენა= 0 მონიშვნა დალაგებული სვეტი=0 შეკუმშვა ანალიზის მონაცემები=1 სარეზერვო UDD ფაილები=1 ბრძანების დანარჩენი შევსება NOP-ებით=1 მითითების ძიების რეჟიმი=0 გლობალური ძიება=0 გასწორებული ძიება=0 შეცდომის ზღვრის დაშვება=0 თექვსმეტობითი რედაქტირების შერჩევის ზომის შენარჩუნება=0 FPU რეგისტრის ტეგის შეცვლა=1 Hex ინსპექტორის ლიმიტები=1 MMX ჩვენების რეჟიმი=0 ბოლო არჩეული ოფციების ბარათი=15 ბოლო არჩეული გარეგნობის ბარათი=6 იგნორირება ტექსტის ძიებაში=1 ასო კლავიშის Disassembler=1 Looseness კოდის ანალიზი=1 Decode Pascal strings=1 არგუმენტების რაოდენობის გამოცნობა=1 შორს ზარების მიღება და დაბრუნება=0 სეგმენტის პირდაპირი ცვლილებების მიღება=0 VxD ზარების გაშიფვრა=0 პრივილეგირებული ბრძანებების მიღება=0 I/O ბრძანებების მიღება=0 NOP-ების მიღება=1 გადაადგილების მიღება დიაპაზონის გარეთ=0 ზედმეტი პრეფიქსების მიღება=0 LOCK პრეფიქსების მიღება=0 დაუსწორებელი სტეკის ოპერაციების მიღება=1 არასტანდარტული ბრძანების ფორმების მიღება=1 ARG-ისა და LOCAL-ის ჩვენება პროცედურებში=0 ანალიზის შენახვა ფაილში=1 ძირითადი მოდულის ავტომატურად ანალიზი=1 კოდის სტრუქტურის ანალიზი=1 გაშიფვრა ifs როგორც გადამრთველები=0 კვალის შენახვა ფაილში=0 რეგისტრების შიგთავსის კვალი=1 ფუნქციების შენარჩუნება რეგისტრების=0 ხრიკების გაშიფვრა=0 რეგისტრის ტიპის ავტომატურად არჩევა=1 დეკოდირებული არგუმენტების ჩვენება=1 დეკოდირებული არგუმენტების ჩვენება სტეკში=1 არგუმენტების ჩვენება გამოძახების სტეკში= 1 ინდუცირებული ზარების ჩვენება=1 ლეიბლის ჩვენების რეჟიმი=0 ლეიბლი მოიცავს მოდულის სახელს=0 მონიშნეთ სიმბოლური ეტიკეტები=0 მონიშნეთ RETURNs in stack=1 იგნორირება გზა მომხმარებლის მონაცემთა ფაილში=1 დროის ანაბეჭდის იგნორირება მომხმარებლის მონაცემთა ფაილში=1 CRC იგნორირება მომხმარებლის მონაცემთა ფაილში =1 დალაგების ნაგულისხმევი რეჟიმი სახელებში=1 სვეტების დალაგება ჟურნალის ფაილში=0 მონაცემების დამატება არსებული ჟურნალის ფაილში=0 შეგროვებული მონაცემების ამორეცხვა ჟურნალის ფაილში=0 ადგილების გამოტოვება წყაროს კომენტარებში=1 არარსებული წყაროს ფაილების დამალვა=1 ჩანართის გაჩერება= 8 ფაილის გრაფიკის რეჟიმი=2 შიდა სახელურის სახელების ჩვენება=0 შეუსაბამო სახელურების დამალვა=0 RET-ის ნაცვლად გამოიყენეთ RET=0 მიკვლეული დროშების ჩვენება=1 ხაზების რაოდენობა, რომლებიც მიჰყვება EIP=0 მოდულის გარეთ მომხმარებლის მონაცემების შენახვა=0 CPU=194,324,812,360 ,3 CPU ქვეფანჯარა = 327,798,321,798,537,771,479,909 OllyTest = 0,0,1024,746,1 მითითება = 256,420,256,210,1 შესვენების წერტილები = 75,248,681,626,1 ,1 პაჩები= 0,210,256,210,1 შესრულებადი მოდული=263,41,636,175,1 მეხსიერების რუკა=357 ,41,519,274,1 სანიშნე = 110,145,624,175,1 პროფილი = 132,174,624,182,1 Windows = 132,177,614,179,1 თემა = 155,204,492,104,21, წყარო = 224,21 ,2 10,256,210,1 სახელურები=196,325,647,175,1 წყარო ფაილი=205,268,473,168,1 ზარი დასტის = 0,420,256,210 ,1 გამოძახების ხე = 132,132,791,175,1 SEH ჯაჭვი = 0,0,256,210,1 საათის გამონათქვამები = 256,0,256,210,1 CPU სქემა = 0 CPU Disassembler = 7,0, PU = 7,0,0 1,0 ,4353.0 CPU Stack=7,0,0,0 CPU Info=7,0,0,0 CPU Registers=7,0,0,0 References=7,0,1,0,0 Breakpoints=1, 0 ,1,0,0 გაშვების კვალი=1,0,1,0,0 პაჩები=1

Დასრულება

ამით დასრულდა თქვენი გაცნობა მშვენიერი დებუგერი OllyDebugger-თან. რა თქმა უნდა, შეუძლებელია სტატიაში ამ გამართვის ყველა შესაძლებლობის აღწერა, მაგრამ მე შევეცადე და იმედი მაქვს, რომ იმუშავა. ზოგიერთი შესაძლებლობა სცილდება ამ სტატიის ფარგლებს, მაგრამ დარწმუნებული ვარ, რომ თქვენ თვითონ აღმოაჩენთ ამ შესაძლებლობებს. მე Olly-ს ვასწავლიდი აბსოლუტურად ყოველგვარი სტატიების გარეშე და თქვენ შეძლებთ გააგრძელოთ გამართვის სისტემის გაცნობა არავის დახმარების გარეშე. თუ თქვენ გაქვთ შეკითხვები, წინადადებები, ლანძღვის სიტყვები და ა.შ. გაგზავნეთ ისინი ყველა [ელფოსტა დაცულია].

P.S. დარწმუნდით, რომ წაიკითხეთ ჩემი სტატია Olly-ის გამოყენებით unboxing-ის შესახებ.

გამარჯობა

მოგესალმებით ყველას cracklab-ზე და განსაკუთრებით MozgC-ს და Bad_guy-ს, ALEX-ს, Kerghan-ს, Mario555-ს, Hex-ს და ყველას, ვინც კითხულობს ამ სტატიას.