სახლში ბრაუზერები

რატომ არის საშიში PHP register_globals პარამეტრის ჩართვა? მარტივი მომხმარებლის რეგისტრაციის სისტემის შექმნა PHP-ში და MySQL Impersonal index php რეესტრში

გამარჯობა! ახლა ჩვენ შევეცდებით განვახორციელოთ საიტზე უმარტივესი რეგისტრაცია PHP + MySQL გამოყენებით. ამისათვის Apache უნდა იყოს დაინსტალირებული თქვენს კომპიუტერში. ჩვენი სკრიპტის მუშაობის პრინციპი ნაჩვენებია ქვემოთ.

1. დავიწყოთ მონაცემთა ბაზაში მომხმარებლების ცხრილის შექმნით. ის შეიცავს მომხმარებლის მონაცემებს (შესვლა და პაროლი). მოდით გადავიდეთ phpmyadmin-ზე (თუ თქვენ ქმნით მონაცემთა ბაზას თქვენს კომპიუტერზე http://localhost/phpmyadmin/). ჩვენ ვქმნით მომხმარებლების ცხრილს, მას ექნება 3 ველი.

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

2. საჭიროა ამ ცხრილთან დაკავშირება. მოდით შევქმნათ bd.php ფაილი. მისი შინაარსი:

ჩემს შემთხვევაში ასე გამოიყურება:

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

3. შექმენით reg.php ფაილი შინაარსით (ყველა კომენტარი შიგნით):

რეგისტრაცია

რეგისტრაცია

თქვენი შესვლა:

Თქვენი პაროლი:

4. შექმენით ფაილი, რომელიც შეიტანს მონაცემებს მონაცემთა ბაზაში და შეინახავს მომხმარებელს. save_user.php (კომენტარები შიგნით):

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

მთავარი გვერდი

მთავარი გვერდი

თქვენი შესვლა:

Თქვენი პაროლი:

რეგისტრაცია

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

ყველაფერი შევამოწმე, მუშაობს გამართულად!

Reg.ru: დომენები და ჰოსტინგი

ყველაზე დიდი რეგისტრატორი და ჰოსტინგის პროვაიდერი რუსეთში.

სერვისში 2 მილიონზე მეტი დომენის სახელია.

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

700 ათასზე მეტმა მომხმარებელმა მთელი მსოფლიოს მასშტაბით უკვე გააკეთა არჩევანი.

*მაუსი გადააბრუნეთ გადახვევის შესაჩერებლად.

უკან წინ

მარტივი მომხმარებლის რეგისტრაციის სისტემის შექმნა PHP-სა და MySQL-ში

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

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

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

აი, როგორ იმუშავებს ჩვენი სუპერ მარტივი სისტემა:

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

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

ამ მიდგომის უპირატესობები:

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

ხარვეზები:

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

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

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

როგორ გამოვიყენოთ ეს სისტემა

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

თქვენ უნდა გადმოწეროთ გაკვეთილზე მიმაგრებული წყაროები
- იპოვეთ tables.sql ფაილი არქივში. შემოიტანეთ იგი თქვენს მონაცემთა ბაზაში phpMyAdmin-ში იმპორტის ოფციის გამოყენებით. ალტერნატიული გზა: გახსენით ეს ფაილი ტექსტური რედაქტორის საშუალებით, დააკოპირეთ SQL მოთხოვნა და შეასრულეთ იგი;
- გახსენით include/main.php და შეავსეთ თქვენს მონაცემთა ბაზასთან დაკავშირების პარამეტრები (დააზუსტეთ მომხმარებლის და პაროლი მონაცემთა ბაზასთან დასაკავშირებლად, ასევე მონაცემთა ბაზის ჰოსტი და სახელი). ამავე ფაილში ასევე უნდა მიუთითოთ ელფოსტა, რომელიც გამოყენებული იქნება სისტემის მიერ გაგზავნილი შეტყობინებების თავდაპირველ მისამართად. ზოგიერთი ჰოსტი ბლოკავს გამავალ წერილებს, თუ ფორმა არ შეიცავს რეალურ ელფოსტის მისამართს, რომელიც შეიქმნა ჰოსტის მართვის პანელიდან, ამიტომ მიუთითეთ რეალური მისამართი;
- ატვირთეთ ყველა index.php, protected.php ფაილი და აქტივი და მოიცავს საქაღალდეებს FTP-ის საშუალებით თქვენს ჰოსტში;
- დაამატეთ ქვემოთ მოცემული კოდი თითოეულ PHP გვერდზე, სადაც გსურთ აჩვენოთ შესვლის ფორმა;

Require_once "მოიცავს/main.php"; $user = ახალი მომხმარებელი(); if(!$user->loggedIn())( გადამისამართება("index.php"); )
- მზადაა!

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

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

index.php

გაკვეთილი: სუპერ მარტივი სარეგისტრაციო სისტემა PHP და MySQL შესვლა ან რეგისტრაცია

შეიყვანეთ თქვენი ელექტრონული ფოსტის მისამართი ზემოთ და ჩვენ გამოგიგზავნით
თქვენ შესვლის ლინკი.

შესვლა/რეგისტრაცია

თავში (ტეგებსა და ტეგებს შორის) მე ჩავურთე ძირითადი სტილები (ისინი არ არის დაფარული ამ ტუტორიალში, ასე რომ თქვენ შეგიძლიათ ნახოთ ისინი. Folder assets/css/style.css). დახურვის ტეგამდე ჩავრთე jQuery ბიბლიოთეკა და script.js ფაილი, რომელსაც ქვემოთ დავწერთ და გავაანალიზებთ.

JavaScript

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

assets/js/script.js

$(function())( var form = $("#login-register"); form.on("submit", function(e)( if(form.is(".loading, .loggedIn"))( დაბრუნება false ;) var email = form.find("input").val(), messageHolder = form.find("span"); e.preventDefault(); $.post(this.action, (ელფოსტა: ელფოსტა), ფუნქცია (m)( if(m.error)(form.addClass("შეცდომა"); messageHolder.text(m.message); ) else(form.removeClass("error").addClass("loggedIn"); messageHolder ტექსტი (მ. შეტყობინება); ) )); )); $(დოკუმენტი).ajaxStart(function())(form.addClass("იტვირთება"); )); $(დოკუმენტი).ajaxComplete(function()) ( ფორმა. removeClass("loading"); )); ));

ფორმას დაემატა AJAX მოთხოვნის მიმდინარე მდგომარეობის საჩვენებლად (ეს შესაძლებელი გახდა მეთოდების წყალობით ajaxStart ()) და ajaxComplete (), რომელიც შეგიძლიათ იპოვოთ ფაილის ბოლოს).

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

მონაცემთა ბაზის სქემა

ჩვენი წარმოუდგენლად მარტივი ჟურნალის სისტემა იყენებს 2 MySQL ცხრილს (SQL კოდი არის tables.sql ფაილში). პირველი ინახავს მონაცემებს მომხმარებლის ანგარიშების შესახებ. მეორე ინახავს ინფორმაციას შესვლის მცდელობების რაოდენობის შესახებ.

მომხმარებლის ცხრილის სქემა.

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

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

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

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

ეს კლასი აქტიურად იყენებს idorm-ს (docs), ეს ბიბლიოთეკები არის მინიმალური საჭირო ინსტრუმენტები მონაცემთა ბაზებთან მუშაობისთვის. ის ამუშავებს მონაცემთა ბაზაში წვდომას, ტოკენის გენერირებას და ტოკენის დადასტურებას. ის უზრუნველყოფს მარტივ ინტერფეისს, რომელიც აადვილებს რეგისტრაციის სისტემის დაკავშირებას თქვენს საიტზე, თუ ის იყენებს PHP-ს.

User.class.php

კლასის მომხმარებელი( // პირადი ORM შემთხვევა კერძო $orm; /** * იპოვნეთ მომხმარებელი ჟეტონით. განსახილველად მიიღება მხოლოდ მოქმედი ჟეტონები. ჟეტონი წარმოიქმნება მხოლოდ 10 წუთის განმავლობაში მისი შექმნის მომენტიდან * @param string $token ეს არის ის, ვისაც ვეძებთ ჟეტონს * @return მომხმარებელი დააბრუნეთ მომხმარებლის ფუნქციის მნიშვნელობა */ საჯარო სტატიკური ფუნქცია findByToken($token)( // იპოვეთ ჟეტონი მონაცემთა ბაზაში და დარწმუნდით, რომ დაყენებულია სწორი დროის ანაბეჭდი $result = ORM::for_table("reg_users") ->where ("token", $token) ->where_raw("token_validity > NOW()") ->find_one(); if(!$result)( return false; ) დააბრუნეთ ახალი მომხმარებელი($result); ) /** * მომხმარებლის ავტორიზაცია ან რეგისტრაცია * @param string $email მომხმარებლის ელფოსტის მისამართი * @return მომხმარებელი */ საჯარო სტატიკური ფუნქცია loginOrRegister($email)( // თუ ასეთი მომხმარებელი უკვე არსებობს, დააბრუნეთ მომხმარებლის ფუნქციის მნიშვნელობა მონაცემთა ბაზაში შენახული მითითებული ელექტრონული ფოსტის მისამართიდან if(User::exists($email))( return new User($email); ) // წინააღმდეგ შემთხვევაში, შექმენით ახალი მომხმარებელი მონაცემთა ბაზაში და დააბრუნეთ User::create ფუნქციის მნიშვნელობა მითითებული ელფოსტიდან return User::create($email ); ) /** * შექმენით ახალი მომხმარებელი და შეინახეთ მონაცემთა ბაზაში * @param string $email. მომხმარებლის ელფოსტის მისამართი * @return მომხმარებელი */ პირადი სტატიკური ფუნქცია create($email)( // დაწერეთ ახალი მომხმარებელი და დააბრუნეთ მომხმარებლის ფუნქციის შედეგი ამ მნიშვნელობიდან $result = ORM::for_table("reg_users")- >create(); $result->email = $email; $result->save(); დააბრუნეთ ახალი მომხმარებელი($result); ) /** * შეამოწმეთ არის თუ არა ასეთი მომხმარებელი მონაცემთა ბაზაში და დააბრუნეთ ლოგიკური მნიშვნელობა ცვლადი * @param string $email. მომხმარებლის ელფოსტის მისამართი * @return ლოგიკური */ საჯარო სტატიკური ფუნქცია არსებობს ($email)( // არსებობს თუ არა მომხმარებელი მონაცემთა ბაზაში? $result = ORM::for_table("reg_users") ->where("email", $email ) ->count(); return $result == 1;) /** * შექმენით ახალი მომხმარებლის ობიექტი * @param instance $param ORM , id, email ან 0 * @return მომხმარებელი */ საჯარო ფუნქცია __construct($param = null) ( if($param instanceof ORM)( // ORM შემოწმება გაიარა $this->orm = $param; ) else if(is_string($param))( // ელფოსტის შემოწმება გაიარა $this->orm = ORM:: for_table ("reg_users") ->where("email", $param) ->find_one(); ) else($id = 0; if(is_numeric($param))( // $param ცვლადის მნიშვნელობა არის გადაეცა მომხმარებლის იდენტიფიკატორს $id = $param; ) else if(isset($_SESSION["loginid"]))( // წინააღმდეგ შემთხვევაში, იხილეთ სესია $id = $_SESSION["loginid"]; ) $this->orm = ORM::for_table( "reg_users") ->where("id", $id) ->find_one(); ) ) /** * შექმენით ახალი SHA1 ავტორიზაციის ჟეტონი, ჩაწერს მას მონაცემთა ბაზაში და აბრუნებს მის მნიშვნელობას * @return string */ public ფუნქცია generateToken( )( // შექმენით ტოკენი ავტორიზებული მომხმარებლისთვის და შეინახეთ მონაცემთა ბაზაში $token = sha1($this->email.time().rand(0, 1000000)); // შეინახეთ ჟეტონი მონაცემთა ბაზაში // და მონიშნეთ ისე, რომ იგი მოქმედებს მხოლოდ მომდევნო 10 წუთის განმავლობაში $this->orm->set("token", $token); $this->orm->set_expr("token_validity", "ADDTIME(NOW(),"0:10")"); $this->orm->save(); დაბრუნება $token; ) /** * მომხმარებლის ავტორიზაცია * @return void */ public ფუნქცია login())( // მონიშნეთ მომხმარებელი, როგორც შესულია $_SESSION["loginid"] = $this->orm->id; // განაახლეთ last_login მონაცემთა ბაზის ველის მნიშვნელობა $this->orm->set_expr("last_login", "NOW()"); $this->orm->save(); ) /** * გაანადგურეთ სესია და გამოდით მომხმარებელი * @return void */ საჯარო ფუნქციის გამოსვლა ()( $_SESSION = მასივი(); unset($_SESSION); ) /** * შეამოწმეთ, არის თუ არა მომხმარებელი შესული * @return ლოგიკური */ საჯარო ფუნქცია logedIn())( return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id; ) /** * ამოწმებს არის თუ არა მომხმარებელი ადმინისტრატორი * @return ლოგიკური */ საჯარო ფუნქცია isAdmin())( return $this->rank() = = "ადმინისტრატორი"; ) /** * იპოვეთ მომხმარებლის ტიპი, შეიძლება იყოს ადმინისტრატორი ან ჩვეულებრივი * @return string */ საჯარო ფუნქციის რანგი())( თუ ($this->orm->rank == 1)( return "administrator" "; ) return "Regular"; ) /** * მეთოდი, რომელიც საშუალებას გაძლევთ მიიღოთ მომხმარებლის პირადი ინფორმაცია, როგორც * მომხმარებლის ობიექტის * თვისებები * @ პარამეტრის სტრიქონი $key თვისების სახელი, რომელსაც აქვს წვდომა * @return შერეული */ საჯარო ფუნქცია __get($key)( if(isset($this->orm->$key))( return $this->orm-> $ გასაღები; ) დაბრუნების null; ))

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

როდესაც ჟეტონი დამოწმებულია, ჩვენ პირდაპირ ვეუბნებით დამმუშავებელს, რომ განვიხილავთ მხოლოდ იმ ჟეტონებს, რომლებსაც ჯერ არ გაუვიდათ ვადა, რომლებიც ინახება სვეტში token_validity.

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

ამის წყალობით შესაძლებელი ხდება მონაცემთა ბაზაში შენახულ ინფორმაციაზე წვდომა თვისებების წყალობით $user->email, $user->token და ა.შ. შემდეგ კოდის ფრაგმენტში განვიხილავთ როგორ გამოვიყენოთ ეს კლასები, როგორც მაგალითი. .

დაცული გვერდი

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

ფუნქციები.php

ფუნქცია send_email($from, $to, $subject, $message)( // დამხმარე, რომელიც აგზავნის ელფოსტას $headers = "MIME-ვერსია: 1.0" . "\r\n"; $headers .= "შინაარსის ტიპი: ტექსტი /plain; charset=utf-8" . "\r\n"; $headers .= "From: ".$from. "\r\n"; დააბრუნეთ ფოსტა($to, $subject, $message, $headers ); ) ფუნქცია get_page_url())( // განსაზღვრეთ PHP ფაილის URL $url = "http".(ცარიელი($_SERVER["HTTPS"])?"":"s")."://" .$_SERVER ["SERVER_NAME"]; if(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")($url.= $_SERVER["REQUEST_URI"]; ) else( $url. = $_SERVER["PATH_INFO"]; ) დააბრუნეთ $url; ) ფუნქციის rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)( // შესვლის მცდელობების რაოდენობა ბოლო საათში ამ IP მისამართზე $ count_hour = ORM: :for_table("reg_login_attempt") ->where("ip", sprintf("%u", ip2long($ip))) ->where_raw("ts > SUBTIME(NOW(),"1:00 ")") ->count(); // შესვლის მცდელობების რაოდენობა ბოლო 10 წუთის განმავლობაში ამ IP მისამართზე $count_10_min = ORM::for_table("reg_login_attempt") ->where("ip", sprintf("%u ", ip2long($ ip))) ->where_raw("ts > SUBTIME(NOW(),"0:10")") ->count(); if($count_hour > $limit_hour || $count_10_min > $limit_10_min)( throw new Exception("ძალიან ბევრი შესვლის მცდელობა!"); ) ) ფუნქცია rate_limit_tick($ip, $email)( // შექმენით ახალი ჩანაწერი ცხრილში რომელიც ითვლის შესვლის მცდელობების რაოდენობას $login_attempt = ORM::for_table("reg_login_attempt")->create(); $login_attempt->email = $email; $login_attempt->ip = sprintf("%u", ip2long($ip )); $login_attempt->save(); ) ფუნქციის გადამისამართება($url)( header("მდებარეობა: $url"); გასვლა; )

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

ქვემოთ მოყვანილი კოდი აღებულია index.php ფაილიდან და ის ამუშავებს ფორმის წარდგენას. ის აბრუნებს JSON პასუხს, რომელიც, თავის მხრივ, მუშავდება jQuery-ის მიერ assets/js/script.js ფაილში, რომელიც ადრე ვნახეთ.

index.php

სცადეთ( if(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))( // გამოიტანეთ JSON სათაური ("შიგთავსის ტიპი: განაცხადი/json"); // მართებულია თუ არა ეს ელფოსტის მისამართი, თუ (!isset($_POST["ელფოსტა"]) || !filter_var($_POST["ელფოსტა"], FILTER_VALIDATE_EMAIL))( ჩააგდეთ ახალი გამონაკლისი ("გთხოვთ, შეიყვანოთ სწორი ელფოსტა"); ) // შეამოწმეთ. მომხმარებელს შესვლის უფლება აქვს, გადააჭარბა თუ არა დაშვებული კავშირების რაოდენობას? (functions.php ფაილი დამატებითი ინფორმაციისთვის) rate_limit($_SERVER["REMOTE_ADDR"]); // შესვლა ამ შესვლის მცდელობის rate_limit_tick($_SERVER["REMOTE_ADDR"] , $ _POST["email"]); // გაუგზავნეთ ელ.წერილი მომხმარებელს $message = ""; $email = $_POST["email"]; $subject = "თქვენი შესვლის ბმული"; if(!მომხმარებელი:: არსებობს ($email) )( $subject = "გმადლობთ რეგისტრაციისთვის!"; $message = "გმადლობთ, რომ დარეგისტრირდით ჩვენს საიტზე!\n\n"; ) // სცადეთ მომხმარებლის ავტორიზაცია ან რეგისტრაცია $user = მომხმარებელი ::loginOrRegister($_POST["email"]);$message.= "შეგიძლიათ შეხვიდეთ ამ URL-დან:\n"; $message.= get_page_url()."?tkn=".$user->generateToken()."\n\n"; $message.= "ბმული ავტომატურად იწურება 10 წუთის შემდეგ."; $result = send_email ($fromEmail, $_POST["email"], $subject, $message); if(!$result)( throw new Exception("შეცდომა მოხდა თქვენი ელ. ფოსტის გაგზავნისას. გთხოვთ სცადოთ ხელახლა."); ) die(json_encode(array("message" => "გმადლობთ! ჩვენ\"გაგიგზავნეთ ბმული თქვენს შემოსულებში. შეამოწმეთ თქვენი სპამის საქაღალდეც."))); ) ) catch(გამონაკლისი $e)( die(json_encode(array("error"=>1, "message" => $e->getMessage() )))))

წარმატებული შესვლის/რეგისტრაციის შემდეგ, ზემოთ მოცემული კოდი მომხმარებელს გაუგზავნის შესვლის ბმულს. ჟეტონი ხელმისაწვდომი ხდება იმიტომ იგი გადაეცემა როგორც ცვლადი გენერირებულ ბმულში მეთოდით $_GET tkn მარკერით

index.php

If(isset($_GET["tkn"]))( // მოქმედებს ეს ჟეტონი ავტორიზაციისთვის? $user = მომხმარებელი::findByToken($_GET["tkn"]); if($user)( // დიახ, არის. გადამისამართება დაცულ გვერდზე $user->login(); redirect("protected.php"); ) // არა, ჟეტონი არასწორია. გადამისამართება გვერდზე ავტორიზაციის/რეგისტრაციის ფორმის redirect("index. php ");)

$user->login()

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

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

index.php

If(isset($_GET["logout"]))($user = ახალი მომხმარებელი(); if($user->loggedIn())($user->logout(); ) გადამისამართება("index.php") ;)

კოდის ბოლოს ისევ დავაყენე გადამისამართება index.php-ზე, ასე რომ პარამეტრი ?გამოსვლა=1 URL-ით გადაცემული არ არის საჭირო.

ჩვენი index.php ფაილი დამატებით მოითხოვს. დაცვა - ჩვენ არ გვინდა, რომ სისტემაში შესულმა ადამიანებმა ხელახლა ნახონ რეგისტრაციის ფორმა. ამ მიზნებისთვის ჩვენ ვიყენებთ მეთოდს $user->loggedIn().

index.php

$user = ახალი მომხმარებელი(); if($user->loggedIn())( გადამისამართება("protected.php"); )

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

დაცულია.php

// თქვენს საიტზე ყველა გვერდის დასაცავად, შეიტანეთ main.php ფაილი // და შექმენით ახალი მომხმარებლის ობიექტი. აი რა ადვილია! require_once "მოიცავს/მთავარ.php"; $user = ახალი მომხმარებელი(); if(!$user->loggedIn())( გადამისამართება("index.php"); )

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

Echo "თქვენი ელფოსტა: ".$user->email; echo "თქვენი წოდება: ".$user->rank();

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

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

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

ჩვენ დავასრულეთ!

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

მასალა სპეციალურად საიტისთვის მოამზადა დენის მალიშოკმა

P.S. გნებავთ წინსვლა PHP-ისა და OOP-ის დაუფლებაში? ყურადღება მიაქციეთ პრემიუმ გაკვეთილებს ვებსაიტების შექმნის სხვადასხვა ასპექტებზე, მათ შორის PHP-ში პროგრამირების ჩათვლით, ასევე უფასო კურსს PHP-ში საკუთარი CMS სისტემის შექმნის შესახებ OOP-ის გამოყენებით ნულიდან:

მოგეწონათ მასალა და გსურთ მადლობა გადამიხადოთ?
უბრალოდ გაუზიარე მეგობრებს და კოლეგებს!

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

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

თუ სერვერზე (php.ini-ში) ჩართულია register_globals = On დირექტივა, მაშინ ცვლადების გადაცემისას ფორმაში ან ბრაუზერის ხაზში, იმ სკრიპტში, რომელზეც ეს ცვლადებია განკუთვნილი, ისინი ავტომატურად შეიქმნება. იმათ. თუ ბრაუზერის ხაზში გაქვთ შემდეგი ჩაწერილი: www.server.ru/index.php?var=1, მაშინ $var ცვლადი 1-ის ტოლი მნიშვნელობით ავტომატურად შეიქმნება index.php სკრიპტში.

კომენტარი

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

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

როდესაც register_globals დირექტივა გამორთულია, ასეთ ცვლადებზე წვდომა შესაძლებელია ორი გზით:

ასოციაციური მასივების მეშვეობით HTTP_***_VARS (HTTP_POST_VARS და ა.შ.)
სუპერგლობალური მასივების მეშვეობით ($_ENV, $_GET, $_POST, $_SERVER, $_COOKIE, $_FILES და ა.შ.)

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

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

მაშ, რა უნდა გააკეთოთ ცვლადების მისაღებად? თქვენ უნდა აიღოთ ისინი სუპერგლობალური მასივებიდან. მაგალითად, ბრაუზერის ხაზის გავლით ცვლადების მისაღებად გამოიყენეთ $_GET მასივი. ვთქვათ, ბრაუზერის ხაზი ამბობს www.server.ru/index.php?var=1. შემდეგ index.php-ში var ცვლადის მისაღებად თქვენ უნდა დაწეროთ:

$var=$_GET["var"];

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

$var=$_POST["var"];

ამ სტატიაში თქვენ შეისწავლით როგორ შექმნათ რეგისტრაციისა და შესვლის ფორმა HTML, JavaScript, PHP და MySql გამოყენებით. ასეთი ფორმები გამოიყენება თითქმის ყველა ვებსაიტზე, მიუხედავად მისი ტიპისა. ისინი შექმნილია ფორუმისთვის, ონლაინ მაღაზიისთვის, სოციალური ქსელებისთვის (როგორიცაა Facebook, Twitter, Odnoklassniki) და მრავალი სხვა ტიპის საიტისთვის.

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

ცხრილის შექმნა მონაცემთა ბაზაში

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

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

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

ასე რომ, დავფიქრდით, წარმოვიდგინეთ რა ველები ექნებოდა ჩვენს ფორმას და შევქმენით ცხრილი მომხმარებლებიამ ველებით:

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

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

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

მონაცემთა ბაზის კავშირი

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

ჩვენი საიტის საქაღალდეში შექმენით ფაილი სახელით dbconnect.phpდა ჩაწერეთ მასში შემდეგი სკრიპტი:

ეს ფაილი dbconnect.phpუნდა იყოს დაკავშირებული ფორმის დამმუშავებლებთან.

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

საიტის სტრუქტურა

ახლა მოდით შევხედოთ ჩვენი საიტის HTML სტრუქტურას.

ჩვენ გადავიტანთ საიტის სათაურს და ქვედა ნაწილს ცალკეულ ფაილებში, header.phpდა ძირი.php. ჩვენ მათ ყველა გვერდზე შევიტანთ. კერძოდ მთავარ გვერდზე (ფაილი index.php), სარეგისტრაციო ფორმის მქონე გვერდზე (ფაილი form_register.php) და ავტორიზაციის ფორმის მქონე გვერდზე (ფაილი form_auth.php).

დაბლოკეთ ჩვენი ბმულებით, რეგისტრაციადა ავტორიზაცია, დაამატეთ ისინი საიტის სათაურში ისე, რომ ისინი ყველა გვერდზე იყოს ნაჩვენები. ერთი ბმული შევა სარეგისტრაციო ფორმის გვერდზე (ფაილი form_register.php) და მეორე გვერდზე ავტორიზაციის ფორმის (ფაილი form_auth.php).

header.php ფაილის შიგთავსი:

ჩვენი საიტის სახელი

შედეგად, ჩვენი მთავარი გვერდი ასე გამოიყურება:

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

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

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

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

ფორმის ჩვენებამდე დაამატეთ ბლოკი სესიიდან შეცდომის შეტყობინებების საჩვენებლად.

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

ზოგადად, ფაილის კოდი form_register.phpჩვენ ეს შეგვიძლია:

თქვენ უკვე დარეგისტრირებული ხართ

ბრაუზერში რეგისტრაციის ფორმის გვერდი ასე გამოიყურება:

საჭირო ატრიბუტის გამოყენებით ჩვენ ყველა ველი სავალდებულო გავხადეთ.

ყურადღება მიაქციეთ სარეგისტრაციო ფორმის კოდს, სადაც ნაჩვენებია captcha:

ჩვენ დავაზუსტეთ ფაილის გზა გამოსახულების src ატრიბუტის მნიშვნელობაში captcha.php, რომელიც ქმნის ამ captcha-ს.

მოდით შევხედოთ ფაილის კოდს captcha.php:

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

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

ჩვენ დავასრულეთ HTML სტრუქტურა, დროა გადავიდეთ.

ელ.ფოსტის მოქმედების შემოწმება jQuery-ის გამოყენებით

ნებისმიერ ფორმას სჭირდება შეყვანილი მონაცემების ვალიდობის შემოწმება, როგორც კლიენტის მხარეს ( JavaScript, jQuery-ის გამოყენებით), ასევე სერვერის მხარეს.

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

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

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

jQuery ბიბლიოთეკის დასაკავშირებლად, ფაილში header.phpტეგებს შორის , დახურვის ტეგამდე , დაამატეთ ეს ხაზი:

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

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

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

Მომხმარებლის რეგისტრაცია

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

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

სანამ გავაგრძელებთ, უნდა შევამოწმოთ, იყო თუ არა ფორმა წარმოდგენილი. თავდამსხმელს შეუძლია შეხედოს ატრიბუტის მნიშვნელობას მოქმედებაფორმიდან და გაარკვიეთ რომელი ფაილი ამუშავებს ამ ფორმას. და მას შეიძლება ჰქონდეს იდეა, გადავიდეს პირდაპირ ამ ფაილზე, ბრაუზერის მისამართის ზოლში შემდეგი მისამართის აკრეფით: http://site_address/register.php

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

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

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

ახლა მოდით გადავიდეთ თავად გადამოწმებაზე. ფაილში რეგისტრაცია.php, if ბლოკის შიგნით, სადაც ვამოწმებთ დააწკაპუნეთ თუ არა ღილაკზე "რეგისტრაცია", უფრო სწორად სად არის მითითებული "კომენტარი" // (1) ადგილი კოდის შემდეგი ნაწილისთვის"ჩვენ ვწერთ:

//შეამოწმეთ მიღებული captcha //შეამცირეთ შუალედები სტრიქონის დასაწყისიდან და ბოლოდან $captcha = trim($_POST["captcha"]); if(isset($_POST["captcha"]) && !empty($captcha))( //შეადარეთ მიღებული მნიშვნელობა სესიის მნიშვნელობასთან. if(($_SESSION["rand"] != $captcha) && ($_SESSION ["rand"] != ""))( // თუ captcha არ არის სწორი, მაშინ ჩვენ ვაბრუნებთ მომხმარებელს რეგისტრაციის გვერდზე და იქ გამოვაჩენთ შეცდომის შეტყობინებას, რომ მან არასწორი captcha შეიყვანა $error_message = "

შეცდომა! თქვენ შეიყვანეთ არასწორი captcha

"; // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] = $error_message; // დააბრუნეთ მომხმარებელი სარეგისტრაციო გვერდის სათაურში ("HTTP/1.1 301 Moved Permanently"); header("Location: " .$address_site ."/form_register.php"); //შეაჩერე სკრიპტის გასასვლელი(); ) // (2) მოათავსეთ კოდის შემდეგი ნაწილი )else( //თუ captcha არ არის გადაცემული ან ცარიელია, გადით ("

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

"); }

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

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

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

ჩასვით ეს კოდი მითითებულ ადგილას" // (2) ადგილი კოდის შემდეგი ნაწილისთვის".

/* შეამოწმეთ არის თუ არა ფორმიდან გამოგზავნილი მონაცემები გლობალურ მასივში $_POST და გაგზავნილი მონაცემები ჩაალაგეთ ჩვეულებრივ ცვლადებში.*/ if(isset($_POST["first_name"]))( //შეამცირეთ სივრცეები თავიდანვე და სტრიქონის დასასრული $first_name = trim($_POST["first_name"]); //შეამოწმეთ ცვლადის სიცარიელე if(!empty($first_name))( // უსაფრთხოების მიზნით, გადააკეთეთ სპეციალური სიმბოლოები HTML ერთეულებად $first_name = htmlspecialchars($first_name, ENT_QUOTES) ; )else( // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] .= "

შეიყვანეთ თქვენი სახელი

სახელის ველი აკლია

"; //მომხმარებლის დაბრუნება სარეგისტრაციო გვერდის სათაურში ("HTTP/1.1 301 გადაადგილებულია მუდმივად"); header("მდებარეობა: ".$address_site."/form_register.php"); //Stop the script exit(); ) if( isset($_POST["last_name"]))( //შეამცირეთ სივრცეები სტრიქონის დასაწყისიდან და ბოლოდან $last_name = trim($_POST["last_name"]); if(!empty($last_name)) ( // უსაფრთხოების მიზნით, გადააკეთეთ სპეციალური სიმბოლოები HTML ერთეულებად $last_name = htmlspecialchars($last_name, ENT_QUOTES); )else( // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] .= "

გთხოვთ შეიყვანოთ თქვენი გვარი

გვარის ველი აკლია

"; //მომხმარებლის დაბრუნება სარეგისტრაციო გვერდის სათაურში ("HTTP/1.1 301 გადაადგილებულია მუდმივად"); header("მდებარეობა: ".$address_site."/form_register.php"); //Stop the script exit(); ) if( isset($_POST["ელფოსტა"]))( //შეამცირეთ სივრცეები სტრიქონის დასაწყისიდან და ბოლოდან $email = trim($_POST["email"]); if(!empty($email)) ( $email = htmlspecialchars ($email, ENT_QUOTES); // (3) კოდის მდებარეობა ელფოსტის მისამართის ფორმატის და მისი უნიკალურობის შესამოწმებლად )else( // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] .="

Შეიყვანეთ თქვენი ელექტრონული ფოსტა

"; //მომხმარებლის დაბრუნება სარეგისტრაციო გვერდის სათაურში ("HTTP/1.1 301 გადაადგილებულია მუდმივად"); header("მდებარეობა: ".$address_site."/form_register.php"); //Stop the script exit(); ) if( isset($_POST["პაროლი"]))( //შეამცირეთ სივრცეები სტრიქონის დასაწყისიდან და ბოლოდან $password = trim($_POST["პაროლი"]); if(!empty($password)) ( $password = htmlspecialchars ($password, ENT_QUOTES); //დაშიფრეთ პაროლი $password = md5($password."top_secret"); )else( // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] .="

Შეიყვანეთ თქვენი პაროლი

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

მითითებულ ადგილას" // (3) კოდის მდებარეობა საფოსტო მისამართის ფორმატის და მისი უნიკალურობის შესამოწმებლად"დაამატეთ შემდეგი კოდი:

//შეამოწმეთ მიღებული ელ.ფოსტის მისამართის ფორმატი ჩვეულებრივი გამოთქმის გამოყენებით $reg_email = "/^**@(+(*+)*\.)++/i"; //თუ მიღებული ელფოსტის მისამართის ფორმატი არ ემთხვევა ჩვეულებრივ გამონათქვამს if(!preg_match($reg_email, $email))( // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] .= "

თქვენ შეიყვანეთ არასწორი ელფოსტა

"; //მომხმარებლის დაბრუნება სარეგისტრაციო გვერდის სათაურში ("HTTP/1.1 301 გადაადგილებულია მუდმივად"); header("მდებარეობა: ".$address_site."/form_register.php"); //Stop the script exit(); ) // ვამოწმებთ არის თუ არა ასეთი მისამართი უკვე მონაცემთა ბაზაში $result_query = $mysqli->query("SELECT `email` FROM `users` WHERE `email`="".$email."""); / /თუ მიღებულთა რაოდენობა არის ზუსტად ერთი მწკრივი, რაც ნიშნავს, რომ მომხმარებელი ამ ელ.ფოსტის მისამართით უკვე დარეგისტრირებულია, თუ($result_query->num_rows == 1)( //თუ შედეგი არ არის მცდარი, თუ(($row = $result_query->fetch_assoc()) != false) ( // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] .= "

მომხმარებელი ამ ელფოსტის მისამართით უკვე დარეგისტრირებულია

"; //მომხმარებლის დაბრუნება სარეგისტრაციო გვერდის სათაურში ("HTTP/1.1 301 გადაადგილებულია მუდმივად"); header("მდებარეობა: ".$address_site."/form_register.php"); )else( // შეცდომის შეტყობინების შენახვა სესიაზე $_SESSION["error_messages"] .= "

შეცდომა მონაცემთა ბაზის მოთხოვნაში

"; //მომხმარებლის დაბრუნება სარეგისტრაციო გვერდის სათაურში ("HTTP/1.1 301 გადავიდა მუდმივად"); header("მდებარეობა: ".$address_site."/form_register.php"); ) /* არჩევის დახურვა */ $ result_query-> close(); //Stop the script exit(); ) /* არჩევის დახურვა */ $result_query->close();

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

//შეკითხვა მომხმარებლის მონაცემთა ბაზაში დასამატებლად $result_query_insert = $mysqli->query("INSERT INTO `users` (first_name, name, email, password) VALUES ("".$first_name."", "".$last_name ." ", "".$email.", "".$პაროლი.")"); if(!$result_query_insert)( // შეინახეთ შეცდომის შეტყობინება სესიაზე. $_SESSION["error_messages"] .= "

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

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

"; //მომხმარებლის გაგზავნა ავტორიზაციის გვერდის სათაურში ("HTTP/1.1 301 გადავიდა მუდმივად"); header("მდებარეობა: ".$address_site."/form_auth.php"); ) /* მოთხოვნის დასრულება */ $ result_query_insert-> close();//დახურეთ კავშირი მონაცემთა ბაზასთან $mysqli->close();

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

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

ელ.ფოსტის მისამართის ფორმატის და პაროლის სიგრძის შემოწმების სკრიპტი არის ფაილში header.php, ასე რომ, ის ასევე ვრცელდება ამ ფორმის ველებზე.

სხდომა ასევე იწყება ფაილში header.php, ასე რომ ფაილში form_auth.phpარ არის საჭირო სესიის დაწყება, რადგან ჩვენ მივიღებთ შეცდომას.

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

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

მომხმარებლის ავტორიზაცია

მნიშვნელობის ატრიბუტისთვის მოქმედებაავტორიზაციის უნარს აქვს მითითებული ფაილი auth.php, ეს ნიშნავს, რომ ფორმა დამუშავდება ამ ფაილში.

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

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

ფაილის კოდი logout.php:

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

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

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

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

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

გაკვეთილის გეგმა (ნაწილი 5):

ავტორიზაციის ფორმისთვის HTML სტრუქტურის შექმნა

ჩვენ ვამუშავებთ მიღებულ მონაცემებს

ჩვენ ვაჩვენებთ მომხმარებლის მისალმებას საიტის სათაურში

მოგეწონათ სტატია?

არ ვიცი რატომ... არა, ვიცი რატომ ვერ ჩართავ register_globals-ის დირექტივას, მაგრამ არ ვიცი რატომ ლიტერატურაში, როგორც წესი, ამაზე არაფერი წერია.

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

Როგორ მუშაობს

PHP პარამეტრებში (php.ini ფაილი) არის ასეთი register_globals დირექტივა. მისი მნიშვნელობა ის არის, რომ თუ ის ჩართულია (register_globals = ჩართულია), მაშინ GET და POST-ით გადაცემული ყველა ცვლადი ავტომატურად დარეგისტრირდება როგორც გლობალური. Რას ნიშნავს?

მაგალითად, ჩვენ გადავცემთ GET მეთოდს index.php სკრიპტს ზოგიერთი გვერდის მნიშვნელობა: index.php?page=2. მიღებული მნიშვნელობა ინახება GET მასივში და შეიძლება გამოყენებულ იქნას სკრიპტში, როგორც $_GET["გვერდი"]. თუმცა, თუ ჩართული გვაქვს register_globals, მაშინ მიღებული მნიშვნელობისთვის შეიქმნება $page ცვლადი, რომელიც ხელმისაწვდომია index.php სკრიპტის ნებისმიერ ნაწილში.

მცირე შეჯამება და დამატება. როდესაც register_globals ჩართულია, იქმნება ცვლადის სამი ასლი: GET მასივში, GLOBALS მასივში და უბრალოდ თავად ცვლადი ($_GET["გვერდი"], $GLOBALS["გვერდი"], $page), ხოლო როდესაც register_globals გამორთულია, გადაცემული მნიშვნელობა შეიძლება იყოს ხელმისაწვდომი მხოლოდ GET მასივის მეშვეობით ($_GET["გვერდი"]). გახსოვდეთ.

გამოყენების საშიშროება

მოდით შევხედოთ მარტივ მაგალითს, რათა გავიგოთ, რა გველოდება (3-დან 5 წლამდე - რედაქტორის შენიშვნა). ამის გასაადვილებლად, მაშინვე ვიტყვი, რომ $login და $password არის GET/POST მეთოდით გადაცემული ცვლადები.

მოკლედ რას აკეთებს სკრიპტი:

ხაზი 2. ჩვენ ვთხოვთ მონაცემთა ბაზას მომხმარებლის მიერ შეყვანილი შესვლის რეალური პაროლის ამოღების მიზნით.

ხაზი 3. ვიღებთ ამ პაროლს და ვანიჭებთ მას $real_pass ცვლადს.

ხაზი 4. ჩვენ ვადარებთ რეალურ და შეყვანილ პაროლს და თუ ისინი ემთხვევა, მაშინ $check ცვლადი მიენიჭება true.

ხაზები 5-8. თუ $check მართალია, მაშინ ვწერთ, რომ ავტორიზაცია წარმატებული იყო და ა.შ.

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

ვთქვათ, გადარიცხვა ხორციელდება GET მეთოდით. შემდეგ url ასე გამოიყურება:
www.site.com/index.php?login =admin&პაროლი =qwerty
ნათელია, რომ გლობალური ცვლადები $login და $password დაუყოვნებლივ იქმნება. ახლა გადახედე სკრიპტს. ის შეიცავს $check ცვლადს. რა მოხდება, თუ მას გადასცემთ URL-ით?

www.site.com/index.php?login =admin&პაროლი =qwerty&შემოწმება =1
შემდეგ პაროლის შესატყვისი შემოწმება გვერდის ავლით ხდება და მომხმარებელი დაუყოვნებლივ ხდება ავტორიზებული (ბოლოს და ბოლოს, გახსოვთ, რომ 1 არის ჭეშმარიტი, ხოლო 0 მცდარი?). იგივე შედეგი იქნება თუ დავწერთ www.საიტი.com/ინდექსი.php?ჩეკი =1 . და მაშინაც კი, თუ თქვენ იყენებთ POST მეთოდს, ყველა ასეთი თაღლითობა მაინც იმუშავებს, რადგან როდესაც register_globals ჩართულია, არ აქვს მნიშვნელობა რომელ მეთოდს იყენებთ - GET თუ POST.

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

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

ავიღოთ ჩვენი მაგალითი. მის დასაცავად, თუ register_globals ჩართულია, ხაზის შემდეგ თუ ($პაროლი==$რეალური_გაივლის)$შემოწმება =მართალია;დაამატეთ შემდეგი: სხვა $შემოწმება =ყალბი;. ამ შემთხვევაში, მაშინაც კი, თუ ერთის ტოლი გამშვები ცვლადი გადაეცემა GET მეთოდით, სკრიპტი მაინც დააყენებს $check=false, თუ პაროლი არასწორია.

დიახ, ასევე მინდა გავამახვილო თქვენი ყურადღება იმ ფაქტზე, რომ თუ თქვენ გამორთავთ register_globals, მაშინ ჩვენი მაგალითი არ იმუშავებს. და რომ იმუშაოს, თქვენ უნდა დაწეროთ $login = $_POST["login"]; $პაროლი = $_POST["პაროლი"];

მოდით შევაჯამოთ...

და გამოიტანე ორი ძირითადი დასკვნა:

1) როდესაც register_globals ჩართულია, შეგიძლიათ გადასცეთ სხვადასხვა ცვლადები, რომელთა მნიშვნელობები არ იყო გათვლილი მისაღებად GET ან POST საშუალებით.

2) თავად Register_globals არც ისე საშიშია, როგორც არასწორად დაწერილი სკრიპტი.

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

წარმატებული კვირის სურვილებით,
ალექსანდრე შუისკი