როგორ ამოიღოთ ქუქიები ბრაუზერიდან. ქუქიების მოპარვის მეთოდები. დანართი: ქუქი-ფაილების მუშაობის ფუნქციები
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=; expires=" + 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 ); cookie_string += "; expires=" + expires.toGMTString(); ) if (გზა) cookie_string += "; path=" + escape (გზა); if (დომენი) cookie_string += "; domain=" + escape (დომენი); თუ (უსაფრთხო) ქუქი_სტრიქონი += "; უსაფრთხო"; document.cookie = ქუქი_სტრიქონი; )
ფუნქცია იღებს ქუქიების მონაცემებს არგუმენტებად, შემდეგ აშენებს შესაბამის სტრიქონს და აყენებს ქუქი-ფაილს.
მაგალითად, ქუქიების დაყენება ვადის გასვლის გარეშე:
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 (შედეგები)); სხვა შემთხვევაში დააბრუნეთ null;)
ეს ფუნქცია იყენებს რეგულარულ გამოხატულებას საინტერესო ქუქი-ფაილის სახელის მოსაძებნად, შემდეგ კი აბრუნებს მნიშვნელობას, რომელიც მუშავდება 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(); set_cookie ("მომხმარებლის სახელი", მომხმარებლის სახელი, ქუქი_წელი, ქუქი_თვე, ქუქი_დღე); ) ) else ( var მომხმარებლის სახელი = get_cookie ("მომხმარებლის სახელი"); document.write ( "გამარჯობა, " + მომხმარებლის სახელი + ", კეთილი იყოს თქვენი მობრძანება გვერდზე!"); document.write("Დამივიწყე!"); }
ამ გაკვეთილმა გაჩვენა, თუ როგორ გამოიყენოთ ქუქიები JavaScript-ში თქვენი ვიზიტორების შესახებ ინფორმაციის შესანახად. Გმადლობთ ყურადღებისთვის! :)
ქუქიები მომხმარებლისთვის აუცილებელია არა მხოლოდ მუდმივად მონახულებული გვერდების უფრო სწრაფი ჩატვირთვისთვის. დისტანციური სერვერები ავტომატურად ინახავენ ამ ან სხვა ინფორმაციას მომხმარებლის კომპიუტერში, რათა მომავალში მოსახერხებელი იყოს მონაცემთა გაცვლასთან მუშაობა.
ინსტრუქციები1. წყაროებზე მომხმარებლის შესვლისა და პაროლის გასარკვევად, შეგიძლიათ გამოიყენოთ ფაილები. თუ იყენებთ Mozilla Firefox ბრაუზერს და მას აქვს ჩართული ქუქიების ჩაწერის შესაძლებლობა, შეგიძლიათ შეინახოთ შენახული შესვლა და პაროლები პირდაპირ პროგრამაში. ამისათვის დააწკაპუნეთ გვერდის ზედა ნაწილში ბრაუზერის მენიუში პუნქტზე სახელწოდებით "ინსტრუმენტები". აირჩიეთ სისტემის პარამეტრი. თქვენს წინაშე გამოჩნდება უზარმაზარი ფანჯარა, რომელიც შეიცავს რამდენიმე ჩანართს. გადადით "უსაფრთხოების" ჩანართზე.
2. ფანჯარაში, რომელიც გამოჩნდება, დააწკაპუნეთ ღილაკზე სახელწოდებით „შენახული პაროლები“. თქვენს წინაშე გამოჩნდება ახალი ფანჯარა იმ შესვლების სიით, რომლებიც შეინახეთ სხვადასხვა წყაროში. დააჭირეთ ღილაკს "პაროლების ჩვენება". თქვენ ასევე შეგიძლიათ დაიცვათ ეს ინფორმაცია იმავე მენიუში პაროლის დაყენების არჩევით.
3. თუ თქვენ იყენებთ Opera ბრაუზერს, თქვენ შეძლებთ მხოლოდ მომხმარებლის სახელების გარკვევას. ამისათვის გახსენით პაროლის მენეჯერი ინსტრუმენტებში და გადახედეთ ხელმისაწვდომი შესვლას. შენახული პაროლის გასარკვევად, დააინსტალირეთ დამატებითი პროგრამა, მაგალითად, Opera Password Recovery. ამავდროულად, გახსოვდეთ, რომ არცერთი მესამე მხარის პროგრამული უზრუნველყოფა არ იძლევა გარანტიას თქვენი პერსონალური მონაცემების სრულ უსაფრთხოებას; ამიტომ, დაიმახსოვრეთ თქვენი პაროლები დამოუკიდებლად ან გამოიყენეთ სხვა ბრაუზერი.
4. გსურთ თქვენი პაროლის ნახვა Google Chrome-ში? შემდეგ გახსენით პარამეტრები პარამეტრებში ინსტრუმენტთა პანელზე შესაბამის პუნქტზე დაწკაპუნებით. გადადით "მოწინავე" განყოფილებაში და დააჭირეთ "ქუქიების ჩვენება".
5. თუ თქვენ ხართ სტანდარტული Internet Explorer ბრაუზერის მომხმარებელი, გამოიყენეთ პრიმიტიული BehindTheAsterisks პროგრამა პაროლის ამოსაღებად. ეს არის უფასო პროგრამა, რომელსაც აქვს ინტუიციური ინტერფეისი და მომხმარებელს აძლევს შესაძლებლობას აჩვენოს პაროლი სიმბოლოებით და არა ვარსკვლავით. ეს პროგრამა ასევე ხელმისაწვდომია სხვა ბრაუზერებისთვის.
ბევრ თანამედროვე ბრაუზერს აქვს ისეთი ფუნქცია, როგორიცაა პაროლების დამახსოვრება სხვადასხვა საიტებისთვის. პაროლის ერთხელ შეყვანით თქვენ თავისუფლდებით საიტის ყოველი შესვლისას ხაზის შევსებისგან. მაგრამ რა უნდა გააკეთოთ, თუ დაგავიწყდათ პაროლი და ის იმალება ვებსაიტზე წერტილების მიღმა? პაროლის გასარკვევად, თქვენ უნდა მიჰყვეთ შემდგომ მითითებებს.
1. პირველ რიგში, თქვენ უნდა შეხვიდეთ საიტზე, რომლისთვისაც გჭირდებათ პაროლი. დააჭირეთ "პაროლის კვერთხს". მას შემდეგ, რაც ყველა ველი ივსება ვარსკვლავით ან წერტილებით, დაუყოვნებლივ დააჭირეთ ESC-ს. ამის შემდეგ, მისამართების ზოლში შეიყვანეთ შემდეგი კოდი: javascript: (ფუნქცია () ( inp = document.getElementsByTagName ('input'); for (var j = 0; j< inp.length; j++) { if (inp[j].type == ‘password’) { prompt(inp[j].name, inp[j].value); } } }) ()Нажав на ENTER, вы получите нужный пароль.
2. თუ პირველი მეთოდი არ დაგვეხმარება, შეგიძლიათ გამოიყენოთ ოპერის პაროლის აღდგენის პროგრამა. ეს არის პროგრამა, რომელიც შექმნილია ოპერის ბრაუზერში შენახული პაროლების გამოსასწორებლად. ეს პროგრამა ძალიან მარტივი და მარტივი გამოსაყენებელია, თქვენ უბრალოდ უნდა გაუშვათ იგი და შემდეგ დააწკაპუნოთ „სწორი პაროლები“. ყველა აღმოჩენილი პაროლი შეინახება ტექსტურ ფაილებში ან HTML ანგარიშებში.
ყველა თანამედროვე ბრაუზერს აქვს დროებითი ფაილების, ქუქიების ჩათვლით, გასუფთავების შესაძლებლობა. მაგრამ ზოგჯერ არ არის საჭირო მთლიანად წაშლა, არამედ ბრაუზერის მიერ შენახული ქუქიების შერჩევით ნახვა, რედაქტირება და წაშლა. ქვემოთ მოცემულია ამ პარამეტრის წვდომის მოკლე შინაარსი განსაკუთრებით ცნობილ ბრაუზერებში.
1. Opera ბრაუზერში, მის მიერ შენახულ თითოეულ ქუქი-ფაილზე წვდომისთვის, თქვენ უნდა გადახვიდეთ "პარამეტრები" განყოფილებაში "მთავარ მენიუში" და აირჩიოთ პუნქტი "ზოგადი პარამეტრები..." (ან დააჭირეთ კლავიშთა კომბინაციას CTRL + F12). შედეგად, იხსნება ბრაუზერის პარამეტრების ფანჯარა, რომელშიც უნდა გადახვიდეთ "Advanced" ჩანართზე, აირჩიეთ "Cookies" განყოფილება მარცხენა პანელში და დააწკაპუნეთ ღილაკზე "Manage Cookies".
2. Opera-ში, ქუქიების მართვის ფანჯარაში, შეგიძლიათ იპოვოთ ის, რაც გჭირდებათ, აირჩიოთ ის და დააწკაპუნოთ ღილაკზე „რედაქტირება“ ჩანაწერის შინაარსის სანახავად. თუ გსურთ, შეგიძლიათ ქუქი-ფაილის რედაქტირება.
3. Mozilla FireFox-ში, იმისათვის, რომ მოხვდეთ ქუქის ფაილებზე, მენიუში უნდა აირჩიოთ განყოფილება „ინსტრუმენტები“ და დააწკაპუნოთ მასში „პარამეტრები“. პარამეტრების ფანჯარაში გადადით "კონფიდენციალურობის" ჩანართზე და დააწკაპუნეთ ღილაკზე, რომელიც ამბობს "აჩვენე ქუქიები...". შედეგად, გაიხსნება ფანჯარა შენახული ქუქიების სიით, რომელშიც შეგიძლიათ მოძებნოთ და ნახოთ მათი შინაარსი.
4. Internet Explorer-ში ქუქიების შენახვის გზა გადის მენიუს განყოფილებაში, სახელწოდებით „Tools“ და მასში არსებული „Internet Options“ პუნქტით. ამ პუნქტზე დაწკაპუნებით იხსნება ფანჯარა, რომელშიც თქვენ უნდა, "ზოგადი" ჩანართზე დააწკაპუნოთ ერთ-ერთ ღილაკზე "პარამეტრები", რომელიც მდებარეობს "ბრაუზერის ისტორიის" განყოფილებაში. ამის შემდეგ გაიხსნება შემდეგი ფანჯარა სათაურით „ფაილის დროებითი პარამეტრები“, სადაც უნდა დააჭიროთ ღილაკს, სახელწოდებით „ფაილების ჩვენება“.
5. Internet Explorer-ში ამ მეთოდის გამოყენებით გადაგიყვანთ საქაღალდეში, სადაც ინახება ყველა დროებითი ფაილი. თუ დააწკაპუნებთ სვეტის სათაურზე „სახელი“, ფაილები დალაგდება სახელების მიხედვით და ყველა ქუქი-ფაილი დაჯგუფდება ერთ ბლოკად. თქვენ შეგიძლიათ იპოვოთ ის, რაც გჭირდებათ და გახსნათ ის სანახავად და რედაქტირებისთვის ჩვეულებრივ ტექსტურ რედაქტორში.
6. Google Chrome ბრაუზერს აქვს ქმედებების ყველაზე გრძელი თანმიმდევრობა ქუქი-ფაილებზე წვდომის მისაღებად. პირველ რიგში, თქვენ უნდა დააჭიროთ გასაღების ხატულას ფანჯრის ზედა მარჯვენა კუთხეში და მენიუში აირჩიეთ "ოფციები". ეს გაიხსნება პარამეტრების გვერდი, რომლის მარცხენა პანელში უნდა დააჭიროთ Advanced ბმულს. გაფართოებული პარამეტრების გვერდზე დააწკაპუნეთ ღილაკზე „სარჩევი პარამეტრები“ ახალი ფანჯრის გასახსნელად.
7. ახალ ფანჯარაში უნდა დააწკაპუნოთ ღილაკზე „ყველა ქუქი და საიტის მონაცემები“. ეს იქნება ბრაუზერის მიერ შენახულ ქუქიებზე გადასვლის საბოლოო დანიშნულება.
8. Google Chrome-ში შეგიძლიათ ნახოთ და წაშალოთ ქუქიები.
9. Safari ბრაუზერში, ქუქი-ფაილების წვდომისთვის, ასევე უნდა დააჭიროთ ზედა მარჯვენა კუთხეში არსებულ ხატულას - გადაცემათა კოლოფის მქონეს. მენიუში აირჩიეთ "პარამეტრები...", რომელიც გაიხსნება ახალ ფანჯარაში. მასში თქვენ უნდა გადახვიდეთ "უსაფრთხოების" ჩანართზე და დააწკაპუნოთ ღილაკზე "ქუქიების ჩვენება". Safari-ში თქვენ გაქვთ მხოლოდ ქუქიების მოძებნისა და წაშლის შესაძლებლობა.
ვიდეო თემაზე
ბრაუზერის თანამედროვე პროგრამებს ჩვენთვის ყველაფერი ახსოვს: ჩვენი საყვარელი გვერდები, ყველაფერი, რასაც დიდი ხანია ვესტუმრეთ, ყველა სახის საიტის პაროლები - ფოსტა, თამაშები, საჯარო ქსელები. რა კომფორტულია საიტზე შესვლა და ლოგინისა და პაროლის შეყვანაზე აღარ ფიქრობ! მაგრამ ზოგჯერ თქვენ უნდა დააინსტალიროთ სისტემა და დააბრუნოთ ყველა პაროლი პროგრამის მეხსიერებიდან საკუთარში.
დაგჭირდებათ
- - კომპიუტერი ინტერნეტით
- - ბრაუზერი
1. გაუშვით Mozilla Firefox პროგრამა და ამ ბრაუზერში შენახული პაროლის აღსადგენად შეასრულეთ ბრძანება „Tools“. აირჩიეთ მენიუს პუნქტი "პარამეტრები", გადადით "უსაფრთხოების" ჩანართზე, დააჭირეთ ღილაკს "შენახული პაროლები". ამ ფანჯარაში იხილეთ ბრაუზერში შენახული ყველა პაროლი, აირჩიეთ ის, რაც გჭირდებათ და დააწკაპუნეთ "ჩვენება".
2. ჩამოტვირთეთ პროგრამა, რომელიც მოგცემთ საშუალებას აჩვენოთ შენახული პაროლები Opera პროგრამაში - UnWand - პროგრამა ოპერაში პაროლების (Wand - Wand) სანახავად, ასევე Opera პაროლის აღდგენის 3.5.1.225 მისი ამოცნობა არ გაგიჭირდებათ. . დააინსტალირეთ პროგრამა თქვენს კომპიუტერში, გაუშვით პროგრამა. აირჩიეთ პაროლის შესწორების საჭირო ვარიანტი: მექანიკურად კვერთხიდან, მექანიკურად ფოსტიდან, ხელით კვერთხიდან, ხელით ფოსტიდან, შერეული ვარიანტი. დააჭირეთ ღილაკს "შემდეგი". გამოჩნდება სკანირების ფანჯარა, შემდეგ ფანჯარაში უნდა მიუთითოთ ოპერის პროგრამის მდებარეობა და დააწკაპუნოთ შემდეგი. პროგრამა დაასკანირებს ამ საქაღალდეს და აჩვენებს შენახულ პაროლებს.
3. ჩამოტვირთეთ პროგრამა, რომელსაც შეუძლია პაროლების ჩვენება ბრაუზერში, არა მხოლოდ Opera-სა თუ Mozilla-ში, არამედ სხვა მრავალ ბრაუზერში - Multi Password Recovery. ჩამოსატვირთად გადადით პროგრამის ოფიციალურ ვებსაიტზე - http://passrecovery.com/ru/index.php. ჩამოტვირთეთ და დააინსტალირეთ ეს პროგრამა თქვენს კომპიუტერში. ინსტალაციის დროს, პროგრამა მოგთხოვთ შეამოწმოთ განახლება, დააწკაპუნეთ "OK". გაუშვით პროგრამა მთავარი მენიუდან. მარცხნივ გამოჩნდება მენიუ, რომელშიც თქვენ უნდა აირჩიოთ საჭირო პროგრამა თქვენი პაროლის აღსადგენად. მაგალითად, Internet Explorer ბრაუზერი, აირჩიეთ ის სიიდან და ამ ბრაუზერში შენახული პაროლები გამოჩნდება პროგრამის ფანჯრის მარჯვენა მხარეს.
4. სხვა პროგრამის გამოყენებით ბრაუზერიდან პაროლის აღსადგენად, გადადით საიტზე http://www.nirsoft.net/, აირჩიეთ და ჩამოტვირთეთ ნებისმიერი პროგრამა იქიდან. მათი ფუნქციები მსგავსია წინა აღწერილი პროგრამების.
თითქმის უცვლელად, პაროლების შეყვანისას კონფიდენციალურობის შესანარჩუნებლად, შესაბამის პროგრამებში ნაჩვენებია წაუკითხავი სიმბოლოები - "ვარსკვლავები" შეყვანილი სიმბოლოების ნაცვლად. თუმცა, თუ ხედავთ იმავე ვარსკვლავებს პაროლის შეყვანის ველში, ეს არ ნიშნავს, რომ პაროლი ნამდვილად არის განთავსებული ამ ველში. ხშირად, ასეთი ვარსკვლავი არაფერს მალავს, მაგრამ აქვს წმინდა ინფორმაციული ფუნქცია - გააცნობიეროს, რომ პაროლის შეყვანისას ის დამალული იქნება ცნობისმოყვარე თვალებისგან.
1. უარი თქვით სერვერისგან მიღებულ ვებგვერდებზე ვარსკვლავების გაშიფვრის განზრახვაზე. შემთხვევების აბსოლუტურ უმრავლესობაში, პაროლები სერვერის მიერ არ გადაეცემა მომხმარებლის ბრაუზერს. ამის გადამოწმება შეგიძლიათ თქვენი ვებ ბრაუზერის მიერ მიღებული საწყისი გვერდის კოდის გახსნით - ის არ შეიცავს პაროლს არც მკაფიო და არც დაშიფრული სახით. პაროლები ინტერნეტით გადაიცემა მხოლოდ ერთი მიმართულებით - ბრაუზერიდან სერვერამდე.
2. გამოიყენეთ სპეციალიზებული აპლიკაციის პროგრამა, რომელსაც შეუძლია წაიკითხოს პაროლები სხვა პროგრამების ღია ფანჯრებში. არ არსებობს ისეთი ხელსაწყოები, როგორც ოპერაციული სისტემის სერვისის კომპონენტები. არაჩვეულებრივი იქნებოდა, რომ გაშიფვრის პროგრამა შეფუთული იყოს პაროლის უსაფრთხოების პროგრამებთან. საჭირო პროგრამა მარტივია ინტერნეტში - მაგალითად, ეს შეიძლება იყოს Pass Checker. პროგრამა შედგება ექვსი ფაილისგან (დახმარების ფაილის ჩათვლით) საერთო წონით 296 კილობაიტი და არ საჭიროებს ინსტალაციას. ფაილების მყარ დისკზე ან მოსახსნელ მედიაში შენახვისთანავე, შეგიძლიათ მისი გაშვება Password.exe ფაილზე ორჯერ დაწკაპუნებით.
3. გახსენით პროგრამა, რომლის ვარსკვლავებიც გაინტერესებთ. ამის შემდეგ, განათავსეთ Pass Checker ფანჯარა ღია პროგრამის ზემოთ და მაუსის მარცხენა ღილაკით გადაიტანეთ თავის ქალას გამოსახულება ვარსკვლავით დამალული პაროლით ველზე. ეს ველი მონიშნული იქნება მოციმციმე ჩარჩოთი და Pass Checker ფანჯარაში, ფანჯრის ტექსტის საპირისპიროდ, დეკოდერი განათავსებს პაროლს დაშიფრული სახით. ამ პაროლის კოპირება და გამოყენება შესაძლებელია ნებისმიერი გზით.
4. დააწკაპუნეთ Help ღილაკს ღილაკების ქვედა რიგში, თუ გსურთ გამოიყენოთ პაროლის გაშიფვრის უფრო რთული მეთოდები. წინა ეტაპზე აღწერილი განსაკუთრებით მარტივის გარდა, პროგრამა გთავაზობთ კიდევ ორ ვარიანტს. ინგლისურენოვანი ინტერფეისის მიუხედავად, Pass Checker-ის დახმარება რუსულად არის დაწერილი, ასე რომ თარგმნასთან დაკავშირებით პრობლემები არ იქნება.
ვიდეო თემაზე
ანტივირუსული პროგრამების დიდი უმრავლესობის კარანტინიდან შემთხვევით გადატანილი ფაილების ამოღების პროცედურა, მეტ-ნაკლებად, სტანდარტიზებულია და განსხვავდება მხოლოდ დეტალებით. ამ შემთხვევაში განვიხილავთ Microsoft Security Essentials, Norton და Avast Antivirus აპლიკაციების საკარანტინო ფაილების შეკეთების ოპერაციას.
დაგჭირდებათ
- - Მაიკროსოფტის უსაფრთხოების საფუძვლები;
- - ავასტი! უფასო ანტივირუსი 5.0;
- – Norton Internet Security
1. გაუშვით Microsoft Security Essentials აპლიკაცია და გადადით "Log" ჩანართზე პროგრამის მთავარ ფანჯარაში, რათა შეასრულოთ ფაილების ამოღების ოპერაცია კარანტინიდან.
2. აირჩიეთ პუნქტი „კარანტინირებული ელემენტები“ და დააწკაპუნეთ ღილაკზე „მონაცემების ნახვა“ დიალოგურ ფანჯარაში, რომელიც იხსნება.
3. მოთხოვნის ფანჯარაში, რომელიც გამოჩნდება, შეიყვანეთ კომპიუტერის მენეჯერის პაროლი და სიაში მიუთითეთ კარანტინიდან შესაკეთებელი ფაილი.
4. დააწკაპუნეთ ღილაკზე „აღდგენა“ ფაილის ამოღების პროცედურის დასასრულებლად, ან გამოიყენეთ ღილაკი „წაშლა ყველა“ Microsoft Security Essentials ანტივირუსული აპლიკაციის კარანტინის სრულად გასასუფთავებლად.
5. აირჩიეთ "Maintenance" მენიუს ელემენტი avast! ანტივირუსული პროგრამის მთავარ ფანჯარაში. უფასო ანტივირუსი 5.0 და გადადით "კარანტინის" ჩანართზე დიალოგური ფანჯრის, რომელიც იხსნება.
6. გამოიძახეთ შესაკეთებელი ფაილის კონტექსტური მენიუ სიაში აპლიკაციის ფანჯრის მარჯვენა მხარეს და მიუთითეთ ბრძანება „აღდგენა“ არჩეული ფაილის ამოსაღებად თავდაპირველ შენახვის ადგილას, რომელიც მითითებულია „საწყისი მდებარეობა“ განყოფილებაში.
7. Norton Internet Security ანტივირუსული პროგრამის „Security Log“ ფანჯარაში აირჩიეთ „კარანტინი“ პუნქტი და დააწკაპუნეთ ღილაკზე „ოფციები“ კარანტინში მოთავსებული ფაილის კორექტირების ოპერაციის შესასრულებლად.
8. მიუთითეთ საჭირო ფაილი და გახსნილ ფანჯარაში „Danger Found“ აირჩიეთ ბრძანება „Restore this file“.
9. დააწკაპუნეთ ღილაკზე „დიახ“ ახალ დიალოგურ ფანჯარაში „შეკეთება კარანტინიდან“ და დაასრულეთ კორექტირების ოპერაცია ღილაკზე „დახურვა“ დაწკაპუნებით.
Შენიშვნა!
კარანტინიდან ფაილების ამოღება დასაშვებია მხოლოდ იმ შემთხვევაში, თუ დარწმუნებული ხართ, რომ ისინი უვნებელია!
სასარგებლო რჩევა
უნდა გვახსოვდეს, რომ "კარანტინი" არის ანტივირუსული აპლიკაციის მიერ შექმნილი სპეციალური საქაღალდე. საკარანტინო ფაილები მთლიანად იზოლირებულია ოპერაციული სისტემისგან და მიუწვდომელია გარე პროცესებისთვის. მათი გაშვება შეუძლებელია, რაც უზრუნველყოფს მათი შენახვის უსაფრთხოებას.
Windows ოპერაციულ სისტემას აქვს სტანდარტული მექანიზმი თვითნებური მონაცემების დინამიურ ბიბლიოთეკებში და შესრულებად მოდულებში შესაყვანად, ასევე მათთან მუშაობისთვის API. სურათები, სიმებიანი ცხრილები, დიალოგების ნიმუში, ხელსაწყოების ზოლები, მენიუები და სხვა ინფორმაცია ემატება PE მოდულებს, როგორც წყაროებს. ზოგჯერ, სხვადასხვა მიზნებისთვის, საჭიროა წყაროების ამოღება კომპილირებული მოდულიდან.
დაგჭირდებათ
- არის უფასო Resource Hacker პროგრამა, რომელიც ხელმისაწვდომია ჩამოსატვირთად rpi.net.au/~ajohnson/resourcehacker-ზე.
1. ატვირთეთ PE მოდულის ფაილი Resource Hacker-ში. აპლიკაციის მთავარ მენიუში ეტაპობრივად დააწკაპუნეთ ფაილზე და გახსენით ელემენტები ან დააჭირეთ კლავიატურაზე Ctrl+O კლავიშების კომბინაციას. ფაილის გახსნის დიალოგი გამოჩნდება. გადადით დირექტორიაში, სადაც მდებარეობს სამიზნე ფაილი. აირჩიეთ PE მოდული კატალოგის ჩამონათვალში. დააჭირეთ ღილაკს "გახსნა".
2. განსაზღვრეთ წყაროების სია, რომლებიც უნდა ამოიღოთ. PE ფაილის ჩატვირთვის შემდეგ, ხის სტრუქტურა გამოჩნდება ძირითადი Resource Hacker ფანჯრის მარცხენა მხარეს. ეს არის ყველა მოდულის წყაროების სია, რომლებიც დაჯგუფებულია ტიპის მიხედვით. ასე ვთქვათ, დიალოგის წყაროები მოთავსებულია დიალოგის განყოფილებაში, კურსორის წყაროები - კურსორისა და კურსორის ჯგუფის განყოფილებებში, ხატები - ხატებისა და ხატების ჯგუფის განყოფილებებში. იერარქიის მეორე დონის კვანძები, რომლებიც შეიცავს მთელ განყოფილებას, არის წყაროების რიცხვითი ან სიმბოლური იდენტიფიკატორები. გააფართოვეთ ისინი და მონიშნეთ ჩადგმული ელემენტები. ამ შემთხვევაში, შესაბამისი წყაროების ვიზუალიზაცია მოხდება. ხატები, კურსორები და რასტერები გამოსახულებების სახით გამოჩნდება პროგრამის მთავარი ფანჯრის მარჯვენა პანელში. სიმებიანი ცხრილებისთვის, ამაჩქარებლებისთვის, ვერსიის ინფორმაციისთვის, დიალოგების ნიმუში, მენიუები, ხელსაწყოების ზოლები, კოდი აშენდება და გამოჩნდება ფორმატში, რომელიც შესაფერისია RCC შემდგენელთან გამოსაყენებლად. გარდა ამისა, ნიმუში დიალოგების ვიზუალიზაცია ხდება ცალკე მცურავ ფანჯარაში.
3. დაიწყეთ წინა ეტაპზე აღმოჩენილი წყაროების შენახვის პროცესი. აირჩიეთ საჭირო ელემენტი ხის სტრუქტურაში მარცხნივ. გახსენით მოქმედების განყოფილება პროგრამის მთავარ მენიუში. შეარჩიეთ ელემენტი, რომელიც შეესაბამება განსაკუთრებით შესაფერისი ტიპის შენახვის ოპერაციას. აირჩიეთ პუნქტი „რესურსის შენახვა ბინარულ ფაილად…“ თუ გსურთ შეინახოთ წყარო ორობითი მონაცემების ფრაგმენტის სახით, რომელიც იდენტურია PE მოდულში. აირჩიეთ „რესურსების შენახვა როგორც *. res ფაილი…“ იმისათვის, რომ შეიძინოთ ფაილი, რომელიც შეიცავს მონიშნული წყაროს შედგენილ ვერსიას. მსგავსი ფაილი შესაფერისია აპლიკაციასთან ან ბიბლიოთეკასთან დასაკავშირებლად. დააწკაპუნეთ პუნქტზე ისეთი ტექსტით, როგორიცაა „შენახვა [სექციის სახელი: ქვესექციის სახელი: რესურსის სახელი] ...“ რათა ამოიღოთ წყაროები ორიგინალური სახით. მენიუს ეს ელემენტი უნდა იქნას გამოყენებული ხატების, კურსორებისა და სურათების ფაილების ამოსაღებად.
4. ამოიღეთ წყაროები. დიალოგში სათაურით "Resource Save to...", მიუთითეთ შესანახი ფაილის სახელი და დირექტორია. დააჭირეთ ღილაკს "შენახვა".
ზოგჯერ, Windows ოპერაციულ სისტემაში, რაღაც უცნაური რამ ხდება რომელიმე პროგრამის ფანჯარაში: როდესაც მინიმუმამდეა და გაფართოებული თითოეულ ეკრანზე, მისი ქცევა ტიპიურია, მაგრამ საშუალო ზომის ფანჯარაში, აპლიკაცია ქრება ხილული არეალის მიღმა. ეკრანი. არსებობს დესკტოპიდან ამოღებული ფანჯრის აღდგენის მეთოდები და არც ისე რთულია.
დაგჭირდებათ
- Windows OS.
1. შესამჩნევი ადგილიდან ობიექტის ამოღების პირველი მეთოდი არის მისი პოზიციონირების ყველა ხელით ოპერაციის მინდობა თავად ოპერაციულ სისტემას. ამისათვის, პრობლემის ფანჯრის გარდა, გახსენით კიდევ ერთი ფანჯარა, რომელიც ეკუთვნის ნებისმიერ აპლიკაციას - ვთქვათ, გაუშვით Explorer. ამის შემდეგ დააწკაპუნეთ მაუსის მარჯვენა ღილაკით ამოცანების პანელზე არსებულ თავისუფალ სივრცეზე კონტექსტური მენიუს გასახსნელად. მიეცით OS-ს ბრძანება, მოაწყოს ღია ფანჯრები მენიუში ჩამოთვლილი ერთ-ერთი მეთოდის გამოყენებით - „Windows კასკადში“, „Windows in a stack“ ან „Windows in a stack“ ან „ჩვენი ფანჯრები გვერდიგვერდ“. ამის შემდეგ დაკარგული ფანჯრის ქცევა ნორმალურად დაბრუნდება.
2. კიდევ ერთი მეთოდია ფანჯრის პოზიციონირებისთვის კლავიატურის კონტროლის გამოყენება. ჩართვის შემდეგ აღარ იქნება საჭირო ფანჯრის სათაურის მიღწევა მაუსის მაჩვენებლით, რათა შეძლოთ მისი გადატანა. ამ რეჟიმის გასააქტიურებლად დააჭირეთ ცხელი კლავიშების კომბინაციას Alt + Space + P. ამის შემდეგ, ისრიანი ღილაკების გამოყენებით, გადაიტანეთ ფარული ფანჯარა დესკტოპის ხილულ ზონაში. კლავიატურის პოზიციონირების რეჟიმის გამოსართავად, დააწკაპუნეთ მარცხნივ ნებისმიერ ადგილას.
3. მე-3 მეთოდი - დესკტოპის ხელმისაწვდომი სივრცის გაჭიმვა. ეს შეიძლება გაკეთდეს ეკრანის გარჩევადობის გაზრდით. თუ იყენებთ Windows 7-ის ან Vista-ს უახლეს ვერსიებს, დააწკაპუნეთ მარჯვენა ღილაკით ფონის სურათზე თქვენს სამუშაო მაგიდაზე და ამომხტარი კონტექსტური მენიუდან აირჩიეთ ელემენტი სახელწოდებით „ეკრანის რეზოლუცია“. OS გამოუშვებს ერთ-ერთ „პანელის“ აპლეტს, სადაც თქვენ უნდა გახსნათ ჩამოსაშლელი სია „Resolution“ და გადაიტანოთ სლაიდერი ზემოთ, ან კიდევ უკეთესი, ზედა ნიშნულზე. მოგვიანებით დააჭირეთ ღილაკს "მიმართვა". აპლეტი შეცვლის გარჩევადობას და დაიწყებს ტაიმერს, რის შემდეგაც ეს მეტამორფოზა გაუქმდება. გამოყოფილი დროის განმავლობაში, თქვენ უნდა დააჭიროთ ღილაკს ოპერაციის დასადასტურებლად. ამის შემდეგ, იპოვნეთ დაკარგული ფანჯარა, გადაიტანეთ იგი დესკტოპის ცენტრში და დააბრუნეთ ეკრანის გარჩევადობა წინა მნიშვნელობაზე.
ქუქი ფაილებში არსებულ ინფორმაციას შორის ხშირად მოთხოვნადია მომხმარებლის იდენტიფიკაციის მონაცემები. შეიტყვეთ შესვლა და პაროლი ინტერნეტ წყაროებში, რომლებიც ინახავს კონფიდენციალურ მონაცემებს მათი ვიზიტორების შესახებ.
დაგჭირდებათ
- – კომპიუტერი, რომელიც მუშაობს Windows ოპერაციულ სისტემაზე;
- - ინტერნეტთან წვდომა;
- – ვებ ბრაუზერები: Mozilla Firefox, Opera, Internet Explorer, Google Chrome;
- – Opera Password Recovery პროგრამა;
- – BehindTheAsterisks უტილიტა.
1. თუ იყენებთ Mozilla Firefox ბრაუზერს ვებ გვერდების სანახავად, ქუქიების ჩაწერის ფუნქციით, რომელიც გააქტიურებულია პარამეტრებში, მარტივად გაარკვიეთ თქვენი შენახული შესვლა და პაროლები პროგრამულ უზრუნველყოფაში. გაუშვით თქვენი ინტერნეტ ბრაუზერი, გახსენით "Tools" და გადადით სისტემის პარამეტრებში. ფანჯარაში, რომელიც გამოჩნდება, რომელიც შეიცავს რამდენიმე ჩანართს, გააქტიურეთ "უსაფრთხოება" ვარიანტი.
2. დააწკაპუნეთ ღილაკზე „შენახული პაროლები“ განყოფილებაში, რომელიც გამოჩნდება და გადადით ბრაუზერის ახალ გვერდზე. მას აქვს საიდენტიფიკაციო სიმბოლოები, რომლებიც ინახება კომპიუტერის მეხსიერებაში სხვადასხვა ინტერნეტ წყაროების მონახულებისას. დააჭირეთ ხაზს "პაროლების ჩვენება". თქვენ შეგიძლიათ დაიცვათ თქვენი კონფიდენციალური ინფორმაცია და დააყენოთ პაროლი იმავე ბრაუზერის მენიუში.
3. შეიტყვეთ მომხმარებლის სახელები, თუ მოინახულებთ გლობალური ქსელის წყაროებს ცნობილი Opera ბრაუზერის გამოყენებით. გახსენით ინსტრუმენტების მენიუ თქვენი ბრაუზერის ზედა ნაწილში, გამოიყენეთ პაროლის მენეჯერი და ნახეთ მომხმარებლის შესვლის სია.
4. დააინსტალირეთ დამატებითი პროგრამული უზრუნველყოფა შენახულ პაროლებზე წვდომისთვის, ამ მიზნისთვის ამჯობინეთ Opera Password Recovery პროგრამა. გახსოვდეთ, რომ მესამე მხარის პროგრამა არ იძლევა გარანტიას თქვენი პერსონალური მონაცემების სრულ უსაფრთხოებაზე.
5. Google Chrome ბრაუზერში პაროლების ნახვისას გახსენით შესაბამისი ვარიანტი ბრაუზერის ხელსაწყოთა ზოლში. გადადით გაფართოებულ პარამეტრებზე და გაააქტიურეთ ოფცია „ქუქიების ჩვენება“.
6. გამოიყენეთ მრავალფუნქციური უფასო პროგრამა ქვეცნობიერად ხელმისაწვდომი ინტერფეისით, BehindTheAsterisks, და იპოვეთ პაროლები სტანდარტული Internet Explorer ბრაუზერის ქუქის ფაილებში. გადადით პროგრამის პარამეტრებზე, რომ აჩვენოთ კოდი სიტყვები სიმბოლოებად ვარსკვლავის ნაცვლად და მიიღოთ წვდომა პაროლებზე.
ქუქი ფაილები არის ფაილები, რომლებიც ინახება მომხმარებლის კომპიუტერში და შეიცავს ინფორმაციას იმ საიტების შესახებ, რომლებიც მას ოდესმე ეწვია. ქუქიების მხარდაჭერით შეგიძლიათ გაიგოთ, რომელ გვერდებს ეწვია მომხმარებელი.
ქუქი-ფაილები არის ფაილები, სადაც არის ინფორმაცია ოდესმე მონახულებული საიტების შესახებ, რომლებიც ინახება მომხმარებლის კომპიუტერში. ანუ, როდესაც მომხმარებელი ეწვევა რომელიმე ვებ წყაროს, მის შესახებ ინფორმაცია ჩაიწერება ქუქი-ფაილებში და ამ საიტის შემდგომი მონახულების შემდეგ გადადის ვებ სერვერზე.
ქუქიები შეიცავს მრავალფეროვან ინფორმაციას, მაგალითად, ანგარიშის პაროლებს ვებსაიტებზე, ნიმუშის ფერს, შრიფტის ზომას, რომელიც მომხმარებელმა შექმნა საიტისთვის და ა.შ. ყველაზე ნათელი მაგალითი იმისა, თუ როგორ შეიძლება ქუქიების გამოყენება პარამეტრების შესანახად, მოწოდებულია Google-ის საძიებო სისტემით. ეს მანქანა იძლევა თქვენი ძიების შედეგების მორგების შესაძლებლობას, ჩვენ ვსაუბრობთ გვერდზე შედეგების რაოდენობაზე, დაბრუნებული გვერდების ფორმატზე, ინტერფეისის ენაზე და სხვა პარამეტრებზე. რაც შეეხება ვებსაიტებზე ანგარიშების პაროლებს, თითოეულმა მომხმარებელმა არაერთხელ შენიშნა, რომ ერთხელ მიუთითა თავისი შესვლა და პაროლი რომელიმე ვებ წყაროზე, მან ეს აღარ გააკეთა ხელახლა ავტორიზაციისას, რადგან ეს ინფორმაცია საიტის შესახებ მექანიკურად იყო ჩაწერილი ქუქი-ფაილებში. . როდესაც წყაროს ხელახლა ეწვევა, მონაცემები იგზავნება ვებ სერვერზე, რომელიც მექანიკურად ცნობს მომხმარებელს, ათავისუფლებს მას ველების ხელახლა შევსებისგან. Cookies ასევე შეიძლება სასარგებლო იყოს სტატისტიკის შესანარჩუნებლად. ქუქი-ფაილები არ შეიძლება შეუქმნან საფრთხე თქვენს კომპიუტერს. ეს მხოლოდ ტექსტური მონაცემებია ყველასთვის, რომელსაც არ შეუძლია ზიანი მიაყენოს მას. ქუქიების მხარდაჭერით შეუძლებელია მომხმარებლის კომპიუტერიდან ინფორმაციის წაშლა, გადატანა ან წაკითხვა, თუმცა შესაძლებელია იმის გარკვევა, თუ რომელ გვერდებს ეწვია იგი. თანამედროვე ბრაუზერები უფრო ადვილად აძლევენ მომხმარებელს არჩევანს, შეინახოს თუ არა ქუქი-ფაილები, მაგრამ თუ ის გადაწყვეტს ქუქიების შენახვის გამორთვას, ის მზად უნდა იყოს შეფერხებისთვის ზოგიერთ საიტთან მუშაობისას.
ქუქიების ნაკლოვანებებიპირველი, ქუქი-ფაილები ყოველთვის არ ახდენენ მომხმარებლის სწორად იდენტიფიცირებას. მეორეც, ისინი შეიძლება მოიპაროს კრიმინალმა. რაც შეეხება არასწორ ამოცნობას, ამის მიზეზი შეიძლება იყოს მომხმარებლის მიერ რამდენიმე ბრაუზერის გამოყენება. თითოეულ ბრაუზერს აქვს საკუთარი საცავი, ამიტომ ქუქიები არ იდენტიფიცირებს მომხმარებლის, არამედ მისი ბრაუზერისა და კომპიუტერის იდენტიფიცირებას, და თუ მას აქვს რამდენიმე ბრაუზერი, მაშინ იქნება ქუქიების რამდენიმე ნაკრები. თავდამსხმელები შეიძლება მიიზიდონ ქუქიების უწყვეტი გაცვლამ მომხმარებლის ბრაუზერსა და ვებ სერვერს შორის; თუ ქსელის ტრაფიკი არ არის დაშიფრული, შესაძლებელია მომხმარებლის ქუქიების წაკითხვა სპეციალური სნაიფერული პროგრამების დახმარებით. ამ პრობლემის მოგვარება შესაძლებელია ტრაფიკის დაშიფვრით და სხვადასხვა პროტოკოლების გამოყენებით.
ვიდეო თემაზე
ქუქიები არის ტექნოლოგია, რომელიც საშუალებას აძლევს ვებსაიტს „დაიმახსოვროს“ მომხმარებელი,
შეინახეთ მისი პარამეტრები და არ სთხოვოთ მას ლოგინი და პაროლი ყოველ ჯერზე. შეუძლია
იფიქრეთ, რომ თუ თქვენს ბრაუზერში წაშლით ქუქი-ფაილებს, საიტი არ გიცნობთ. მაგრამ ეს ერთი
ნდობა მატყუარაა.
თქვენ შეგიძლიათ ინერვიულოთ თქვენი ანონიმურობის შესახებ, რამდენიც გსურთ, გამოიყენეთ პროქსი
და VPN, გააყალბეთ HTTP მოთხოვნის სათაურები, რომლებიც გამოავლენს გამოყენებულ სისტემას,
ბრაუზერის ვერსია, დროის ზონა და ბევრი სხვა ინფორმაცია, მაგრამ ვებსაიტს არ აინტერესებს
ჯერ კიდევ იქნება გზები იმის აღიარებისთვის, რომ თქვენ უკვე იყავით იქ. Ბევრში
იმ შემთხვევებში, როდესაც ეს არ არის განსაკუთრებით კრიტიკული, მაგრამ არა ისეთ სიტუაციაში, როდესაც ზოგიერთ შემთხვევაში
სერვისი, რომელიც უნდა წარმოადგინოთ, როგორც სხვა მომხმარებელი ან უბრალოდ შეინახოთ
ანონიმურობა. ადვილი წარმოსადგენია, თუ როგორ არის თაღლითობის საწინააღმდეგო სისტემა რაიმე სახის ჩვეულებრივი
ფინანსური ორგანიზაცია, თუ დაადგენს, რომ ტრანზაქციები განხორციელდა ერთი კომპიუტერიდან
ავტორიზაცია სრულიად განსხვავებული ადამიანების ანგარიშებზე. და კარგია არა?
ხვდები, რომ ვინმეს ინტერნეტში შეუძლია თვალყური ადევნოს თქვენს მოძრაობებს? ძლივს. მაგრამ
პირველი რამ.
ქუქი-ფაილებს საუკუნეების განმავლობაში იყენებდნენ მომხმარებლების იდენტიფიცირებისთვის.
ქუქიები (ინგლისური "cookies"-დან) არის ტექსტური ინფორმაციის მცირე ნაწილი,
რომელსაც სერვერი უგზავნის ბრაუზერს. როდესაც მომხმარებელი შედის სერვერზე
(აკრიფებს მის მისამართს ბრაუზერის ხაზში), სერვერს შეუძლია ინფორმაციის წაკითხვა,
შეიცავს ქუქი-ფაილებს და მისი ანალიზის საფუძველზე შეასრულეთ ნებისმიერი მოქმედება.
მაგალითად, ქუქი-ფაილების ვებ-გვერდის საშუალებით რაიმეზე ავტორიზებული წვდომის შემთხვევაში
შესვლა და პაროლი შენახულია სესიის დროს, რაც მომხმარებელს საშუალებას აძლევს არ გააკეთოს
შეიტანეთ ისინი ხელახლა, როდესაც მოგეთხოვებათ პაროლით დაცული თითოეული დოკუმენტი. Ისე
ამ გზით ვებსაიტს შეუძლია „დაიმახსოვროს“ მომხმარებელი. ტექნიკურად ასე გამოიყურება
შემდეგი გზით. გვერდის მოთხოვნისას ბრაუზერი აგზავნის მოკლე შეტყობინებას
HTTP მოთხოვნის ტექსტი.
მაგალითად, ბრაუზერში www.example.org/index.html გვერდის შესასვლელად
უგზავნის შემდეგ მოთხოვნას www.example.org სერვერზე:
მიიღეთ /index.html HTTP/1.1
მასპინძელი: www.example.org
სერვერი პასუხობს მოთხოვნილი გვერდის გაგზავნით ტექსტთან ერთად,
შეიცავს HTTP პასუხს. ამან შეიძლება ბრაუზერს დაავალოს ქუქიების შენახვა:
HTTP/1.1 200 OK
შინაარსის ტიპი: ტექსტი/html
Set-Cookie: name=value
თუ არსებობს Set-cookie ხაზი, ბრაუზერს ახსოვს ხაზის სახელი=მნიშვნელობა (სახელი =
მნიშვნელობა) და უგზავნის მას სერვერს ყოველი შემდეგი მოთხოვნით:
GET /spec.html HTTP/1.1
მასპინძელი: www.example.org
ქუქი: სახელი=მნიშვნელობა
მიღება: */*
ყველაფერი ძალიან მარტივია. თუ სერვერმა მიიღო ქუქი-ფაილები კლიენტისგან და მას აქვს ისინი
მონაცემთა ბაზა, მას ნამდვილად შეუძლია მათი დამუშავება. ასე რომ, თუ ეს იყო ქუქიები
მომხმარებელს არ ექნება გარკვეული ინფორმაცია ავტორიზაციის შესახებ ვიზიტის დროს
თქვენ მოგეთხოვებათ შესვლა და პაროლი. სტანდარტის მიხედვით, ქუქი-ფაილებს აქვთ გარკვეული სიცოცხლის ხანგრძლივობა
(მიუხედავად იმისა, რომ ეს შეიძლება იყოს ძალიან დიდი), რის შემდეგაც ისინი იღუპებიან. და ნებისმიერი
მომხმარებელს შეუძლია ადვილად წაშალოს შენახული ქუქიები გამოყენებით
შესაბამისი ვარიანტი, რომელიც ხელმისაწვდომია ნებისმიერ ბრაუზერში. ეს ფაქტი ძალიან
აწუხებს მრავალი რესურსის მფლობელებს, რომლებსაც არ სურთ კონტაქტის დაკარგვა
სტუმარი. მათთვის მნიშვნელოვანია მისი თვალყურის დევნება, იმის გაგება, რომ „ეს ადამიანი ჩვენთან იყო
გუშინ და გუშინწინ და ა.შ." ეს განსაკუთრებით ეხება სხვადასხვა ანალიზატორებს
ტრაფიკი, სტატისტიკის შენახვის სისტემები, ბანერების ქსელები და ა.შ. ეს არის სადაც
გართობა იწყება, რადგან დეველოპერები იყენებენ ყველა სახის
ხრიკები, რომლებიც ბევრმა მომხმარებელმა არც კი იცის. ისინი მოძრაობაში არიან
სხვადასხვა ხრიკები.
საქმე იმაშია, რომ გარდა ჩვეულებრივი HTTP „სიკეთეებისა“, რომლითაც ყველას დიდი ხანია აინტერესებს
შეეჩვია, ახლა აქტიურად გამოიყენება ალტერნატიული საცავი, სადაც ბრაუზერი
შეუძლია დაწეროს მონაცემები კლიენტის მხარეს. პირველი რაც უნდა აღინიშნოს არის
შენახვა იმისა, რაც გიყვართ და გძულთ ამავე დროს Flash (იმ მომხმარებლებისთვის, ვინც
რომელიც დაინსტალირებულია). მონაცემები ინახება ე.წ. LSO-ში (Local Shared
ობიექტები) - ფაილები მსგავსი ფორმატით ქუქი-ფაილების, რომლებიც ინახება ადგილობრივად
მომხმარებლის კომპიუტერი. მიდგომა ბევრ რამეში მსგავსია ჩვეულებრივი „სიკეთეების“ (ამაში
შემთხვევაში, მცირე რაოდენობა ასევე ინახება მომხმარებლის კომპიუტერში.
ტექსტური მონაცემები), მაგრამ აქვს რამდენიმე უპირატესობა:
- Flash ქუქიები საერთოა კომპიუტერის ყველა ბრაუზერისთვის (განსხვავებით
კლასიკური ქუქიიდან, რომელიც მიბმულია ბრაუზერთან). პარამეტრები, ინფორმაცია
სესიის შესახებ, მაგალითად, ზოგიერთი იდენტიფიკატორი მომხმარებლის თვალყურის დევნებისთვის,
არ არის მიბმული რომელიმე კონკრეტულ ბრაუზერთან, მაგრამ ხდება ჩვეულებრივი
ყველას. - Flash ქუქიები საშუალებას გაძლევთ შეინახოთ ბევრად მეტი მონაცემები (როგორც
ჩვეულებრივ 100 KB), რაც ზრდის მომხმარებლის პარამეტრების რაოდენობას,
ხელმისაწვდომია შესანახად.
პრაქტიკაში, LSO ხდება ძალიან მარტივი და ხელმისაწვდომი თვალთვალის ტექნოლოგია
მომხმარებელი. დაფიქრდით: თუ მე შემოგთავაზეთ ამოიღოთ ყველა „სიკეთე“.
სისტემა, გახსოვთ Flash ქუქიების შესახებ? Ალბათ არა. ახლა შეეცადეთ აიღოთ
ნებისმიერი მაყურებელი, მაგალითად, უფასო
FlashCookies ნახეთ და ნახეთ რამდენი საინტერესო რამ არის ჩაწერილი
ფლეშ საცავი. საიტების სია, რომლებსაც ნამდვილად არ სურთ
დაკარგეთ კვალი, მაშინაც კი, თუ თქვენ გაასუფთავებთ ბრაუზერის ქეშს (კარგებთან ერთად).
მაგრამ თუ მოწინავე მომხმარებლებს და კიდევ მეტ-ნაკლებად კარგ მომხმარებლებს სმენიათ LSO-ს შესახებ
დეველოპერები, შემდეგ მონაცემთა შენახვის სხვა ტექნიკის არსებობა, ზოგჯერ ძალიან
დახვეწილი (მაგრამ ეფექტური), ბევრს არც კი ეჭვობს. ახლები მაინც აიღე
საცავებში, რომლებიც გამოჩნდა
(სესიის შენახვა,
ლოკალური საცავი, გლობალური საცავი, მონაცემთა ბაზის შენახვა SQLite-ით), რომლის შესახებაც შეგიძლიათ
წაიკითხეთ სტატიაში "". პოლონელი სპეციალისტი ამ პრობლემამ სერიოზულად დააბნია
უსაფრთხოების შესახებ სემი კამკარი. შედეგად, სპეციალური
Evercookie JavaScript ბიბლიოთეკა, რომელიც სპეციალურად შექმნილია
შექმენით ყველაზე გამძლე ქუქიები ბრაუზერში. შეიძლება ვინმემ იკითხოს: „რატომ
ეს აუცილებელია?" ძალიან მარტივია: ცალსახად იდენტიფიცირებისთვის
გვერდის ვიზიტორი თუ ისევ მოვა. ასეთი ძნელად მოსაკლავი ქუქიები ხშირად გვხვდება
ეწოდება Tracking ქუქი-ფაილები და ზოგიერთი ანტივირუსითაც კი აღმოჩენილია როგორც
საფრთხე კონფიდენციალურობისთვის. Evercookie-ს შეუძლია შეამციროს ანონიმური დარჩენის ყველა მცდელობა
ნული.
საიდუმლო ის არის, რომ evercookie იყენებს ბრაუზერისთვის ხელმისაწვდომ ყველაფერს ერთდროულად
შენახვა: ჩვეულებრივი HTTP ქუქიები, LSO, HTML5 კონტეინერები. გარდა ამისა, ის თამაშში შედის
რამდენიმე მზაკვრული ხრიკი, რომელიც არანაკლებ წარმატებით გაძლევს საშუალებას
კომპიუტერი სასურველი ნიშანი. მათ შორის: სპეციალური PNG სურათების გენერირება,
ისტორიის ბრაუზერის გამოყენებით, მონაცემების შენახვა ETag ტეგის, კონტეინერის გამოყენებით
userData Internet Explorer-ში - გამოდის, რომ უამრავი ვარიანტია.
თქვენ ხედავთ რამდენად ეფექტურად მუშაობს ეს ვებსაიტზე.
დეველოპერი -
http://samy.pl/evercookie. თუ დააწკაპუნეთ ღილაკზე „დააწკაპუნეთ შესაქმნელად
evercookie", ბრაუზერში შეიქმნება ქუქიები შემთხვევითი ნომრით. სცადეთ
წაშალეთ ქუქიები სადაც ეს შესაძლებელია. დადებ ახლა შენ
ვიფიქრე: „სხვაგან სად შემიძლია წავშალო ქუქიები, ბრაუზერის პარამეტრების გარდა?“
დარწმუნებული ხარ რომ წაშალე ყველაფერი? გადატვირთეთ გვერდი, რომ დარწმუნდეთ, შეგიძლიათ კიდევ ერთხელ გააკეთოთ ეს
გახსენით ბრაუზერი. ახლა თავისუფლად დააწკაპუნეთ ღილაკზე „დააწკაპუნეთ ქუქიების ხელახლა აღმოსაჩენად“.
WTF? ამან არ შეუშალა ხელი საიტს მონაცემების სადღაც - გვერდის ველებიდან
ნაჩვენები იყო ნომერი, რომელიც შენახული იყო ქუქიებში. მაგრამ ჩვენ გავხეხეთ ისინი? Როგორ
მუშაობდა? შევეცადოთ გავიგოთ რამდენიმე ტექნიკა.
ძალიან საინტერესო ტექნიკა, რომელიც გამოიყენება Evercookie-ში, არის მიდგომა
მონაცემების შენახვა ქეშირებულ PNG სურათებში. როდესაც evercookie დნება
ქუქიების ფაილები, ის წვდება evercookie_png.php სკრიპტზე სპეციალური HTTP “bun”-ით.
განსხვავდება იმისგან, რომელიც გამოიყენება სტანდარტული ინფორმაციის შესანახად
სესიები. ეს სპეციალური ქუქიები იკითხება PHP სკრიპტით, რომელიც ქმნის
PNG სურათი, რომელშიც ყველა RGB (ფერი) მნიშვნელობა დაყენებულია შესაბამისად
სხდომის შესახებ ინფორმაციით. საბოლოო ჯამში, PNG ფაილი იგზავნება კლიენტის ბრაუზერში
შენიშვნით: „ფაილი უნდა იყოს ქეშირებული 20 წლის განმავლობაში“.
ამ მონაცემების მიღების შემდეგ, evercookie წაშლის ადრე შექმნილ სპეციალურს
HTTP ქუქიები, შემდეგ იგივე მოთხოვნას უგზავნის იმავე PHP სკრიპტს, მაგრამ არა
მომხმარებლის შესახებ ინფორმაციის მიწოდება. ის ხედავს, რომ ის მონაცემები აინტერესებს
არა და მას არ შეუძლია PNG-ის გენერირება. ამის ნაცვლად, ბრაუზერი ბრუნდება
ყალბი HTTP პასუხი "304 არ არის მოდიფიცირებული", რაც იწვევს ფაილის ამოღებას
ადგილობრივი ქეში. ქეშიდან გამოსახულება ჩასმულია გვერდზე ტეგის გამოყენებით
HTML5 ტილო. როგორც კი ეს მოხდება, evercookie კითხულობს ყველა პიქსელს
ტილოს შინაარსი, RGB მნიშვნელობების ამოღება და ამით აღდგენა
ორიგინალური ქუქი-ჩანაწერების მონაცემები, რომლებიც შენახული იყო სურათზე. ვოილა, ეს არის ის
მუშაობს.
სხვა ტექნიკა პირდაპირ იყენებს ბრაუზერის ისტორიას. ერთხელ ბრაუზერი
დააინსტალირებს bun-ს, evercookie შიფრავს მონაცემებს Base64 ალგორითმის გამოყენებით,
რომლებიც შენახვას საჭიროებს. დავუშვათ, რომ ეს მონაცემები არის სტრიქონი,
მიღებული "bcde" Base64-ში გადაყვანის შემდეგ. ბიბლიოთეკა თანმიმდევრულად
წვდება შემდეგ URL-ებზე ფონზე:
google.com/evercookie/cache/b
google.com/evercookie/cache/bc
google.com/evercookie/cache/bcd
google.com/evercookie/cache/bcde
google.com/evercookie/cache/bcde-
ასე რომ, ეს URL-ები ინახება ისტორიაში. შემდეგი მოდის სპეციალური
ტექნიკა - CSS History Knocker, რომელიც JS სკრიპტის და CSS-ის გამოყენებით იძლევა საშუალებას
შეამოწმეთ, ეწვია თუ არა მომხმარებელი მითითებულ რესურსს (დაწვრილებით აქ -
samy.pl/csshack). ამისთვის
evercookie bun შემოწმებები გადის ყველა შესაძლო Base64 სიმბოლოზე
google.com/evercookie/cache, დაწყებული სიმბოლოთი "a" და გაგრძელება, მაგრამ მხოლოდ
ერთი პერსონაჟისთვის. მას შემდეგ, რაც სკრიპტი ხედავს URL-ს, რომელზეც წვდომა იყო, ის
იწყებს შემდეგი პერსონაჟის ძებნას. ეს ერთგვარი უხეში ძალა გამოდის. პრაქტიკაში
ეს შერჩევა ხორციელდება ძალიან სწრაფად, რადგან არანაირი მოთხოვნა არ არის
სერვერი არ არის შესრულებული. ისტორიაში ძიება შეძლებისდაგვარად ადგილობრივად ტარდება
მოკლე ვადა. ბიბლიოთეკამ იცის, რომ მან მიაღწია ხაზის ბოლოს, როდესაც URL არის
მთავრდება სიმბოლოთი "-". ჩვენ ვაშიფრავთ Base64-ს და ვიღებთ ჩვენს მონაცემებს. Როგორ
დაასახელეთ ბრაუზერის დეველოპერები, რომლებიც ამას უშვებს?
რა მოხდება, თუ მომხმარებელი წვავს თავის ქუქი-ფაილებს? თავად ბიბლიოთეკის მნიშვნელოვანი თვისება
evercookie არის ის, რომ მომხმარებელს მოუწევს დიდი ცდა
წაშალეთ სხვადასხვა ადგილას დარჩენილი ქუქი – ახლა არის 10. თუ ერთში მაინც
თუ ქუქი-ფაილის მონაცემები ადგილზე რჩება, ის ავტომატურად აღდგება ყველა დანარჩენში
ადგილები. მაგალითად, თუ მომხმარებელი არა მხოლოდ წაშლის თავის სტანდარტულ ქუქი-ფაილებს, არამედ
და გაასუფთავეთ LSO მონაცემები, გაასუფთავეთ HTML5 საცავები, რაც ისედაც ნაკლებად სავარაუდოა
ქეშირებული PNG და ვებ ისტორიის გამოყენებით შექმნილი ქუქიები დარჩება. ზე
შემდეგ ჯერზე, როდესაც თქვენ ეწვევით საიტს evercookie-ით, ბიბლიოთეკა არა მხოლოდ პოულობს
დამალული ფუნთუშა, მაგრამ ასევე აღადგენს მათ ყველა სხვა ადგილას, რომ
მხარს უჭერს კლიენტის ბრაუზერს. საინტერესო მომენტი ტრანსფერს უკავშირდება
"სიკეთეები" ბრაუზერებს შორის. თუ მომხმარებელი იღებს ქუქიებს ერთ ბრაუზერში,
ანუ დიდია ალბათობა იმისა, რომ ისინი გამრავლდებიან სხვებში. ერთადერთი რამ
ამისათვის აუცილებელი პირობაა მონაცემების შენახვა Local Shared Object ქუქიში.
Evercookie ბიბლიოთეკა მთლიანად ღიაა, ასე რომ თქვენ შეგიძლიათ თავისუფლად
გამოიყენეთ იგი და შეცვალეთ იგი თქვენს საჭიროებებზე. სერვერზე არ არის წარმოდგენილი
სერიოზული მოთხოვნები. ყველაფერი რაც თქვენ გჭირდებათ არის წვდომა JS სკრიპტზე, რომელშიც
შეიცავს evercookie კოდს. Flash ქუქიების გამოსაყენებლად (ლოკალური გაზიარებული ობიექტი),
სკრიპტის საქაღალდეში უნდა იყოს ფაილი evercookie.swf და ტექნიკოსმა იმუშაოს,
ეფუძნება PNG ქეშირებას და ETag შენახვის გამოყენებას, წვდომას
PHP სკრიპტები evercookie_png.php და evercookie_etag.php. გამოიყენეთ evercookie
ამის გაკეთება შეგიძლიათ საიტის ნებისმიერ გვერდზე შემდეგი სკრიპტის დაკავშირებით:
var ec = new evercookie();
// დააყენეთ ქუქი "id" მნიშვნელობით "12345"
// სინტაქსი: ec.set(გასაღები, მნიშვნელობა)
ec.set("id", "12345");
// აღადგინე ქუქი "id" სახელით
ec.get("id", ფუნქცია(მნიშვნელობა)
{
alert ("ქუქი-ფაილის მნიშვნელობა არის " + მნიშვნელობა)
});
ასევე არსებობს ქუქიების მოპოვების კიდევ ერთი გზა, მეტის გამოყენებაზე დაყრდნობით
გაფართოებული გამოძახების ფუნქცია. ეს საშუალებას გაძლევთ ამოიღოთ ქუქიების მნიშვნელობებიდან
გამოიყენება სხვადასხვა საცავი და შეადარეთ ისინი ერთმანეთს:
ფუნქცია getCookie (best_candidate, all_candidate)
{
alert("მოძიებული ქუქი არის: " + best_candidate + "\n" + "თქვენ
შეუძლია დაინახოს რა დააბრუნა " + "თითოეული შენახვის მექანიზმი " + "ყველაზე
კანდიდატები აპროტესტებენ.“);
For (var item in all_candidates) document.write("Storage
მექანიზმი " + ელემენტი + " დაბრუნდა: " + ყველა_ კანდიდატი + "
");
}
ec.get("id", getCookie);
evercookie ბიბლიოთეკა ყველასთვის ხელმისაწვდომია. ცოტა საშინელია, განსაკუთრებით თუ
თქვენ აბსოლუტურად წარმოდგენა არ გაქვთ, რისი გაკეთება შეგიძლიათ მის წინააღმდეგ.
ბრაუზერში და Flash-ში ქუქიების გასუფთავების პრობლემა არ არის, მაგრამ სცადეთ
წაშალეთ მონაცემები იქ, სადაც evercookie დარჩა! ყოველივე ამის შემდეგ, თუ ქუქი-ფაილებს ერთში დატოვებთ
ადგილი - სკრიპტი ავტომატურად აღადგენს მნიშვნელობას ყველა დანარჩენში
საწყობები. არსებითად, ეს ბიბლიოთეკა კარგი რეჟიმის შემმოწმებელია
კონფიდენციალურობა, რომელიც ახლა თითქმის ყველა ბრაუზერს აქვს. და სწორედ ამას გეუბნები
მე ვიტყვი: Google Chrome-დან, Opera, Internet Explorer-დან და Safari-დან, მხოლოდ ბოლო
"პირადი დათვალიერების" რეჟიმი მთლიანად დაბლოკა გამოყენებული ყველა მეთოდი
evercookie. ანუ ბრაუზერის დახურვის და გახსნის შემდეგ სკრიპტი ვერ მოხერხდა
აღადგინეთ დატოვებული მნიშვნელობა. ფიქრის საფუძველი არსებობს. უფრო მეტიც, ში
უახლოეს მომავალში, დეველოპერმა evercookie დაჰპირდა ბიბლიოთეკის დამატებით დამატებას
მონაცემთა შენახვის რამდენიმე ტექნიკა, მათ შორის იზოლირებული ტექნოლოგიის გამოყენებით
შენახვა Silverlight-ში, ისევე როგორც Java აპლეტი.
ალბათ ღირს იმის დაწყება, თუ რა არის ქუქიები და რისთვის არის საჭირო. ქუქი არის მონაცემთა ნაწილი, რომელიც შეიძლება შეინახოს მომხმარებლის მხარეს და მოგვიანებით გამოიყენოს მათი იდეების განსახორციელებლად.
წარმოვიდგინოთ, რომ თქვენს ვებსაიტზე გაქვთ შესაძლებლობა აირჩიოთ საიტის ფერის სქემა. ძალიან მოსახერხებელია ამის დანერგვა ქუქი-ფაილებზე, რადგან მისი შერჩეული თემა მხოლოდ მისთვის იქნება ხილული.
ქუქიები არსებობს როგორც PHP-ში, ასევე jQuery-ში. ამიტომ, თითოეულ შემთხვევას უფრო დეტალურად განვიხილავთ.
jQuery-ში Cookies-თან მუშაობის დეტალური ინსტრუქციები1. ქუქიების დაყენება
ახლა ჩვენ შეგვიძლია ვცადოთ ჩვენი პირველი ქუქი-ფაილის შექმნა:
$.cookie("cookie_name", "cookie_value", ( იწურება: 3, გზა: "/", დომენი: "your_site.ru", უსაფრთხო: true ));
რა არის აქ?
„ქუქი_სახელი“ – ქუქი-ფაილის სახელი;
„cookie_value“ – ქუქი-ფაილის მნიშვნელობა;
"იწურება" - ქუქი-ფაილების შენახვის დღეების რაოდენობა (ჩვენს შემთხვევაში - 3 დღე). ამ დროის გასვლის შემდეგ ქუქიები ავტომატურად წაიშლება;
"გზა" - საიტზე ქუქიების არსებობა (ჩვენს შემთხვევაში "/" - ხელმისაწვდომია მთელ საიტზე). თუ გსურთ, შეგიძლიათ მიუთითოთ მხოლოდ კონკრეტული გვერდი ან განყოფილება, სადაც ხელმისაწვდომი იქნება ქუქიები, მაგალითად, „/audio/rock“;
„დომენი“ – დომენი, რომელზეც მოქმედებს ქუქი. თუ თქვენ გაქვთ ქვედომენი, შეგიძლიათ მიუთითოთ ის ამ პარამეტრში, მაგალითად, „დომენი: „subdomain.your_site.ru“ და ამ შემთხვევაში ქუქი-ფაილი ხელმისაწვდომი იქნება მხოლოდ დომენზე „subdomain.your_site.ru“;
"უსაფრთხო" - პარამეტრი, რომელიც მიუთითებს, რომ ქუქი უნდა გადაიცეს უსაფრთხო https პროტოკოლზე.
აქ ყველა პარამეტრი არ არის საჭირო და ქუქიების დასაყენებლად ეს კონსტრუქცია საკმარისი იქნება:
$.cookie("cookie_name", "cookie_value", ( ვადა: 3, გზა: "/" ));
2. ქუქი-ფაილის მიღება
ქუქიების მიღება საკმაოდ მარტივია; ამის გაკეთება შეგიძლიათ კოდის გამოყენებით:
$.cookie ("ქუქი_სახელი");
ეს კოდი შეიძლება მიენიჭოს ცვლადს და გამოიყენოს თქვენი საჭიროებისთვის:
var content = $.cookie ("ქუქი_სახელი"); if(content != null) ( alert ("ქუქი არსებობს!"); ) else ( alert ("ქუქი არ არსებობს!"); )
ვეთანხმები, ეს ძალიან მოსახერხებელია.
3. ქუქიების ამოღება
ქუქი-ჩანაწერის მნიშვნელობის მოსაშორებლად, დააყენეთ ის „null“-ზე:
$.cookie ("ქუქი_სახელი", null);
ვფიქრობ, ეს არის jQuery-ში Cookies-თან მუშაობის შესავალი დასასრული. ეს ცოდნა სავსებით საკმარისია თქვენი იდეების განსახორციელებლად.
PHP-ში Cookies-თან მუშაობის დეტალური ინსტრუქციებიქუქი-ფაილებთან მუშაობის წინა ვარიანტისგან განსხვავებით, აქ არაფრის დაკავშირება არ გჭირდებათ.
1. ქუქიების დაყენება
PHP-ში ქუქიების დასაყენებლად, ჩვენ გამოვიყენებთ ჩაშენებულ „setcookie“ ფუნქციას:
რა არის აქ?
„ქუქი_სახელი“ – ქუქი-ფაილის სახელი;
„cookie_value“ – ქუქი-ფაილის მნიშვნელობა;
„time()+3600“ – ქუქი-ფაილის ხანგრძლივობა წამებში (ჩვენს შემთხვევაში – 1 საათი). თუ სიცოცხლის ხანგრძლივობას დააყენებთ „0“-ზე, ქუქი-ფაილი წაიშლება ბრაუზერის დახურვისთანავე;
"/" - განყოფილება, რომელშიც ხელმისაწვდომია ქუქიები (ჩვენს შემთხვევაში, ხელმისაწვდომია მთელ საიტზე). თუ გსურთ შეზღუდოთ განყოფილება, რომელშიც ხელმისაწვდომი იქნება ქუქი-ფაილები, შეცვალეთ „/“-ით, მაგალითად, „/audio/rock“-ით;
„your_site.ru“ – დომენი, რომელზეც ხელმისაწვდომი იქნება ქუქი-ფაილი;
"true" - პარამეტრი, რომელიც მიუთითებს, რომ ქუქი ხელმისაწვდომია მხოლოდ უსაფრთხო https პროტოკოლით. წინააღმდეგ შემთხვევაში, მნიშვნელობა არის ყალბი;
"false" - პარამეტრი, რომელიც მიუთითებს, რომ ქუქი ხელმისაწვდომია სკრიპტირების ენებისთვის. წინააღმდეგ შემთხვევაში - true (ხელმისაწვდომია მხოლოდ http-ის საშუალებით).
აქაც ყველა პარამეტრი არ არის საჭირო და ქუქიების შესაქმნელად დაგჭირდებათ მხოლოდ შემდეგი კონსტრუქცია:
მოხერხებულობისთვის, ქუქი-ფაილის მნიშვნელობის დაყენება შესაძლებელია ცვლადის მეშვეობით:
2. ქუქი-ფაილის მიღება
ქუქიების მისაღებად, თქვენ უნდა გამოიყენოთ:
$_COOKIE["ქუქი_სახელი"];
შეცდომების აღმოსაფხვრელად შესაძლო დაკარგული ქუქი-ფაილების გამო, გამოიყენეთ:
როგორც jQuery-ში Cookies-თან მუშაობის წინა მაგალითში, ქუქიები შეიძლება მიენიჭოს ცვლადს:
3. ქუქიების ამოღება
PHP-ში ქუქიების ამოღება ისეთივე მარტივია, როგორც jQuery-ში. თქვენ მხოლოდ უნდა დააყენოთ ქუქი ცარიელ მნიშვნელობაზე და უარყოფით დროზე (დრო, რომელიც უკვე გავიდა):
Setcookie("ქუქი_სახელი", "", დრო() - 3600);
ამ მაგალითში დრო არის ერთი საათის წინ, რაც სავსებით საკმარისია ქუქიების წასაშლელად.
მინდა აღვნიშნო, რომ ზოგიერთ შემთხვევაში ქუქიების გამოყენება ბევრად რაციონალურია, ვიდრე მონაცემთა ბაზის გამოყენება საჭირო ფუნქციონირების განსახორციელებლად.
ნამცხვრები- ინფორმაცია ვებგვერდის მიერ მომხმარებლის კომპიუტერში შენახული ტექსტური ფაილის სახით. შეიცავს ავთენტიფიკაციის მონაცემებს (შესვლა/პაროლი, 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 + სნიფერიდა რაც მთავარია, არ დაკარგოთ სიფხიზლე და ყურადღება დასვენების ან ინტერნეტში მუშაობისას!
