տուն Բրաուզերներ

Ինչու՞ է վտանգավոր PHP register_globals պարամետրը միացնելը: Օգտատերերի գրանցման պարզ համակարգի ստեղծում PHP-ում և MySQL Անձնական ինդեքս 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), որն ուղարկվում է օգտատիրոջ կողմից նշված էլ.
- Հղումը օգտվողին տանում է մեր կայք: Համակարգը որոշում է նշանի առկայությունը և լիազորում է օգտագործողին.

Այս մոտեցման առավելությունները.

Կարիք չկա պահպանել գաղտնաբառերը կամ վավերացնել դաշտերը.
- Կարիք չկա վերականգնել ձեր գաղտնաբառը, անվտանգության հարցերը և այլն;
- Օգտագործողի գրանցման/մուտքի պահից դուք միշտ կարող եք վստահ լինել, որ այս օգտվողը կլինի ձեր մուտքի գոտում (որ էլ. փոստի հասցեն ճիշտ է);
- Անհավատալիորեն պարզ գրանցման գործընթաց;

Թերություններ:

Օգտագործողի հաշվի անվտանգություն: Եթե ինչ-որ մեկին հասանելի է օգտատիրոջ փոստը, նա կարող է մուտք գործել:
- Էլփոստը անվտանգ չէ և կարող է գաղտնալսվել: Հիշեք, որ այս հարցը տեղին է նաև այն դեպքում, երբ գաղտնաբառը մոռացվել է և անհրաժեշտ է վերականգնել, կամ ցանկացած թույլտվության համակարգում, որը չի օգտագործում 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 Մուտք գործելու կամ գրանցելու միջոցով

Մուտքագրեք ձեր էլ. հասցեն վերևում և մենք կուղարկենք
դուք մուտքի հղում եք:

Մուտք/գրանցում

Գլխի բաժնում (և պիտակների միջև) ես ներառել եմ հիմնական ոճերը (դրանք ներառված չեն այս ձեռնարկում, այնպես որ կարող եք ինքներդ դիտել դրանք: Թղթապանակ 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 էլ. ֆունկցիա (m)( if(m.error)( form.addClass("սխալ"); messageHolder.text(m.message); ) else(form.removeClass("error").addClass("loggedIn"); messageHolder տեքստ (m.հաղորդագրություն); ) )); )); $(փաստաթուղթ).ajaxStart(function()) (form.addClass(«բեռնում»); )); $(փաստաթուղթ).ajaxComplete(function()) ( ձև. removeClass («բեռնում»); )); ));

Ավելացվել է ձևին՝ AJAX հարցման ներկա վիճակը ցուցադրելու համար (դա հնարավոր է դարձել մեթոդների շնորհիվ ajaxStart ()) Եվ ajaxComplete (), որը կարող եք գտնել ֆայլի վերջում):

Այս դասը ցուցադրում է պտտվող անիմացիոն GIF ֆայլ (կարծես ակնարկում է մեզ, որ հարցումը մշակվում է), ինչպես նաև գործում է որպես դրոշակ՝ կանխելու ձևի նորից ներկայացումը (երբ գրանցման կոճակն արդեն մեկ անգամ սեղմված է): .loggedIn դասը ևս մեկ դրոշ է. այն սահմանվում է, երբ էլփոստն ուղարկվում է: Այս դրոշը անմիջապես արգելափակում է ձևի հետ կապված ցանկացած հետագա գործողություն:

Տվյալների բազայի սխեման

Մեր աներևակայելի պարզ գրանցման համակարգը օգտագործում է 2 MySQL աղյուսակ (SQL կոդը գտնվում է tables.sql ֆայլում): Առաջինը պահպանում է օգտատերերի հաշիվների մասին տվյալները: Երկրորդը պահում է տեղեկատվություն մուտք գործելու փորձերի քանակի մասին:

Օգտագործողի աղյուսակի սխեման.

Համակարգը չի օգտագործում գաղտնաբառեր, ինչպես երևում է դիագրամում: Դրա վրա կարող եք տեսնել token-ի սյունակը token_validity սյունակին կից նշաններով: Թոքենը տեղադրվում է հենց որ օգտատերը միանում է համակարգին և սահմանում է իր էլ. Token_validity սյունակը սահմանում է ժամանակը 10 րոպե անց, որից հետո նշանն այլևս վավեր չէ:

Աղյուսակի սխեման, որը հաշվում է թույլտվության փորձերի քանակը:

Երկու աղյուսակներում էլ IP հասցեն պահվում է մշակված ձևով՝ օգտագործելով ip2long ֆունկցիան ամբողջ թվի տիպի դաշտում։

Այժմ մենք կարող ենք գրել որոշ PHP կոդ: Համակարգի հիմնական ֆունկցիոնալությունը վերագրված է User.class.php դասին, որը կարող եք տեսնել ստորև։

Այս դասը ակտիվորեն օգտագործում է idorm (docs), այս գրադարանները նվազագույն անհրաժեշտ գործիքներն են տվյալների բազաների հետ աշխատելու համար։ Այն կարգավորում է տվյալների բազայի հասանելիությունը, նշանների ստեղծումը և նշանի վավերացումը: Այն ապահովում է պարզ ինտերֆեյս, որը հեշտացնում է գրանցման համակարգը ձեր կայքին միացնելը, եթե այն օգտագործում է PHP:

User.class.php

Class User( // Private ORM case private $orm; /** * Գտեք օգտվողին ըստ նշանի: Միայն վավեր նշաններն ընդունվում են քննարկման համար: Նշանը ստեղծվում է միայն 10 րոպեի ընթացքում այն ստեղծման պահից * @param string $token Սա այն մեկն է, որը մենք փնտրում ենք նշան * @return Օգտվող Վերադարձրեք Օգտագործողի ֆունկցիայի արժեքը */ հանրային ստատիկ ֆունկցիան findByToken($token)( // գտեք նշանը տվյալների բազայում և համոզվեք, որ ճիշտ ժամանակի դրոշմը դրված է $result = ORM::for_table ("reg_users") ->որտեղ ("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 Օգտվողի */ մասնավոր ստատիկ ֆունկցիա ստեղծել ($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 օրինակ $param ORM, id, էլ. 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 function 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(); վերադարձ $ նշան; ) /** * Թույլատրել օգտվողին * @return void */ public ֆունկցիա login())( // Նշել օգտվողին որպես մուտքագրված $_SESSION["loginid"] = $this->orm->id; // Թարմացնել last_login տվյալների բազայի դաշտի արժեքը $this->orm->set_expr("last_login", "NOW()"); * @return void */ հանրային ֆունկցիայի դուրս գալ ()( $_SESSION = array(); unset($_SESSION); ) /** * Ստուգեք, արդյոք օգտվողը մուտք է գործել * @return բուլյան */ հանրային ֆունկցիա logedIn())( return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id; ) /** * Ստուգում է արդյոք օգտվողը ադմինիստրատոր է * @return բուլյան */ public ֆունկցիա isAdmin())( return $this->rank() = = "administrator"; ) /** * Գտեք օգտվողի տեսակը, կարող է լինել կամ ադմինիստրատոր կամ սովորական * @return string */ public function rank())(եթե ($this->orm->rank == 1)( return "administrator" "; ) return "regular"; ) /** * Մեթոդ, որը թույլ է տալիս ստանալ օգտվողի անձնական տեղեկությունները որպես * Օգտատիրոջ օբյեկտի * հատկություններ * @ param string $key Անվանումը սեփականության, որը ստանում է մուտք * @return խառը */ հանրային ֆունկցիա __get($key)( if(isset($this->orm->$key))( return $this->orm-> $ բանալի; ) վերադարձնել զրոյական; ))

Նշանները ստեղծվում են SHA1 ալգորիթմի միջոցով և պահվում տվյալների բազայում: Ես օգտագործում եմ MySQL-ի ժամանակային գործառույթները՝ նշանի վավերականության համար 10 րոպեանոց ժամկետ սահմանելու համար:

Երբ նշանը վավերացվում է, մենք ուղղակիորեն ասում ենք մշակողին, որ մենք դիտարկում ենք միայն այն նշանները, որոնք դեռ ժամկետանց չեն և պահվում են token_validity սյունակում:

Խնդրում ենք նկատի ունենալ, որ ես օգտագործում եմ կախարդական մեթոդը __ստանալ docs գրադարանը ֆայլի վերջում՝ օգտագործողի օբյեկտի հատկություններին հասանելիությունը կասեցնելու համար:

Դրա շնորհիվ տվյալների բազայում պահվող տեղեկատվության հասանելիությունը հնարավոր է դառնում $user->email, $user->token և այլն հատկությունների շնորհիվ: Կոդի հաջորդ հատվածում մենք կանդրադառնանք, թե ինչպես օգտագործել այս դասերը որպես օրինակ: .

Պաշտպանված էջ

Մեկ այլ ֆայլ, որը պահպանում է օգտակար և անհրաժեշտ գործառույթները, functions.php ֆայլն է։ Կան մի քանի այսպես կոչված օգնականներ՝ օգնական գործառույթներ, որոնք թույլ են տալիս ստեղծել ավելի մաքուր և ընթեռնելի կոդ այլ ֆայլերում:

functions.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 վերնագիր ("Content-type: application/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(!Օգտվող:: exists($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(Exception $e)( die(json_encode(array("error"=>1, "message" => $e->getMessage() ))))))

Հաջող մուտքից/գրանցումից հետո վերը նշված կոդը օգտվողին կուղարկի մուտքի հղում: Նշանը հասանելի է դառնում, քանի որ այն փոխանցվում է որպես փոփոխական գեներացված հղումում մեթոդով $_GET tkn մարկերով

index.php

If(isset($_GET["tkn"]))( // Արդյո՞ք այս նշանը վավեր է լիազորման համար: $user = User::findByToken($_GET["tkn"]); if($user)( // Այո, է. Վերահղում դեպի պաշտպանված էջ $user->login(); redirect("protected.php"); ) // Ոչ, նշանը վավեր չէ: Վերահղում դեպի թույլտվություն/գրանցման ձև redirect("index. php ");)

$user->login()

կստեղծի նիստի համար անհրաժեշտ փոփոխականները, որպեսզի օգտվողը, դիտելով կայքի հետագա էջերը, միշտ լիազորված մնա:

Համակարգից դուրս գալու գործառույթի մշակումը կազմակերպվում է նույն կերպ:

index.php

If(isset($_GET["logout"]))($user = new User(); if($user->loggedIn())($user->logout(); ) redirect ("index.php") ;)

Կոդի վերջում ես կրկին վերահղում եմ սահմանել index.php-ին, ուստի պարամետրը ?ելք=1 URL-ով փոխանցելը պարտադիր չէ:

Մեր index.php ֆայլը լրացուցիչ պահանջում է: պաշտպանություն. մենք չենք ցանկանում, որ մարդիկ, ովքեր մուտք են գործել համակարգ, նորից տեսնեն գրանցման ձևը: Այս նպատակների համար մենք օգտագործում ենք մեթոդը $user->loggedIn().

index.php

$user = նոր օգտվող(); if($user->loggedIn())(վերահղում("protected.php");)

Վերջապես, ահա մի կոդ, որը թույլ է տալիս պաշտպանել ձեր կայքի էջերը և այն հասանելի դարձնել միայն թույլտվությունից հետո:

պաշտպանված.php

// Ձեր կայքի յուրաքանչյուր էջը պաշտպանելու համար ներառեք main.php ֆայլ // և ստեղծեք նոր Օգտվողի օբյեկտ: Ահա թե որքան հեշտ է դա: require_once «ներառում է/main.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 սցենարի համար բոլոր փոփոխականները, որոնք փոխանցվում են բրաուզերի տողով կամ ձևի միջոցով, արտաքին են:
Եկեք նայենք, թե ինչպես են դրանք ստեղծվում:

Եթե register_globals = On հրահանգը միացված է սերվերում (php.ini-ում), ապա փոփոխականները ձևի կամ բրաուզերի տողի միջոցով փոխանցելիս, այն սկրիպտում, որին նախատեսված են այս փոփոխականները, դրանք կստեղծվեն ավտոմատ կերպով: Նրանք. եթե ձեր բրաուզերի տողում գրված է հետևյալը՝ www.server.ru/index.php?var=1, ապա index.php սկրիպտում ավտոմատ կերպով կստեղծվի $var փոփոխականը՝ 1-ին հավասար արժեքով։

Մեկնաբանություն

Այս հրահանգը 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Տվյալների բազայի յուրաքանչյուր աղյուսակ պետք է ունենա այն:
անուն- Անունը պահպանելու համար:
Ազգանուն- Ազգանունը պահպանելու համար։
էլ- Փոստային հասցեն պահպանելու համար: Որպես լոգին մենք կօգտագործենք էլ.
էլփոստի_կարգավիճակ- Դաշտ՝ նշելու՝ փոստը հաստատված է, թե ոչ: Եթե նամակը հաստատված է, ապա այն կունենա 1 արժեք, հակառակ դեպքում արժեքը 0 է:
գաղտնաբառը- Գաղտնաբառը պահպանելու համար:

Եթե ցանկանում եք, որ ձեր գրանցման ձևը ունենա այլ դաշտեր, կարող եք նաև դրանք ավելացնել այստեղ:

Վերջ, մեր սեղանը օգտվողներպատրաստ. Անցնենք հաջորդ փուլին։

Տվյալների բազայի միացում

Մենք ստեղծել ենք տվյալների բազան, այժմ պետք է միանալ դրան: Մենք կապվելու ենք PHP ընդլայնման միջոցով MySQLi:

Մեր կայքի թղթապանակում ստեղծեք ֆայլ անունով dbconnect.php, և դրանում գրեք հետևյալ սցենարը.

Այս ֆայլը dbconnect.phpկպահանջվի միացնել ձևերի մշակիչներ:

Ուշադրություն դարձրեք փոփոխականին $address_site, այստեղ ես նշել եմ իմ թեստային կայքի անունը, որի վրա աշխատելու եմ։ Խնդրում ենք համապատասխանաբար նշել ձեր կայքի անվանումը:

Կայքի կառուցվածքը

Հիմա եկեք նայենք մեր կայքի HTML կառուցվածքին:

Կայքի վերնագիրն ու ստորագիրը կտեղափոխենք առանձին ֆայլեր, header.phpԵվ footer.php. Մենք դրանք կներառենք բոլոր էջերում։ Մասնավորապես գլխավոր էջում (ֆայլ index.php), գրանցման ձևով էջ (ֆայլ form_register.php) և թույլտվության ձևով էջ (ֆայլ form_auth.php).

Արգելափակել մեր հղումներով, ԳրանցումԵվ թույլտվություն, դրանք ավելացրեք կայքի վերնագրում, որպեսզի դրանք ցուցադրվեն բոլոր էջերում։ Մեկ հղումը կմտնի գրանցման ձևով էջ (ֆայլ form_register.php) և մյուսը դեպի էջ՝ թույլտվության ձևով (ֆայլ form_auth.php).

header.php ֆայլի բովանդակությունը.

Մեր կայքի անվանումը

Արդյունքում մեր գլխավոր էջն ունի հետևյալ տեսքը.

Իհարկե, ձեր կայքը կարող է ունենալ բոլորովին այլ կառուցվածք, բայց դա մեզ համար այժմ կարևոր չէ։ Հիմնական բանը այն է, որ կան հղումներ (կոճակներ) գրանցման և թույլտվության համար:

Այժմ անցնենք գրանցման ձևին: Ինչպես արդեն հասկացաք, մենք այն ունենք ֆայլում form_register.php.

Գնացեք տվյալների բազա (phpMyAdmin-ում), բացեք աղյուսակի կառուցվածքը օգտվողներև տեսեք, թե ինչ ոլորտներ են մեզ պետք: Սա նշանակում է, որ մեզ անհրաժեշտ են անուն և ազգանուն մուտքագրելու դաշտեր, փոստային հասցեն (Email) մուտքագրելու դաշտ և գաղտնաբառ մուտքագրելու դաշտ։ Եվ անվտանգության նկատառումներից ելնելով, մենք կավելացնենք դաշտ՝ captcha մուտքագրելու համար։

Սերվերում գրանցման ձևի մշակման արդյունքում կարող են առաջանալ տարբեր սխալներ, որոնց պատճառով օգտատերը չի կարողանա գրանցվել։ Հետևաբար, որպեսզի օգտագործողը հասկանա, թե ինչու գրանցումը ձախողվում է, անհրաժեշտ է ցուցադրել հաղորդագրություններ այդ սխալների մասին:

Նախքան ձևը ցուցադրելը, ավելացրեք բլոկ՝ նիստից սխալ հաղորդագրություններ ցուցադրելու համար:

Եվ ևս մեկ բան, եթե օգտատերը արդեն լիազորված է, և հետաքրքրությունից դրդված նա անմիջապես գնում է գրանցման էջ՝ գրելով բրաուզերի հասցեի տողում. site_address/form_register.php, ապա այս դեպքում գրանցման ձևի փոխարեն կցուցադրենք վերնագիր՝ նշելով, որ նա արդեն գրանցված է։

Ընդհանուր առմամբ, ֆայլի կոդը form_register.phpմենք ստացանք սա.

Դուք արդեն գրանցված եք

Բրաուզերում գրանցման ձևով էջն այսպիսի տեսք ունի.

Օգտագործելով պահանջվող հատկանիշը՝ մենք բոլոր դաշտերը դարձրեցինք պարտադիր։

Ուշադրություն դարձրեք գրանցման ձևի կոդը, որտեղ ցուցադրվում է captcha-ն.

Պատկերի համար src հատկանիշի արժեքում մենք նշել ենք դեպի ֆայլ տանող ճանապարհը captcha.php, որը առաջացնում է այս captcha-ն:

Եկեք նայենք ֆայլի կոդը captcha.php:

Կոդը լավ մեկնաբանված է, ուստի ես կկենտրոնանամ միայն մեկ կետի վրա.

Ֆունկցիայի ներսում imageTtfText (), նշված է տառատեսակի ուղին verdana.ttf. Այսպիսով, որպեսզի captcha-ն ճիշտ աշխատի, մենք պետք է թղթապանակ ստեղծենք տառատեսակներ, և այնտեղ տեղադրեք տառատեսակի ֆայլը verdana.ttf. Այն կարող եք գտնել և ներբեռնել ինտերնետից, կամ վերցնել արխիվից այս հոդվածի նյութերով։

Մենք ավարտեցինք HTML կառուցվածքը, ժամանակն է առաջ գնալ:

Փոստի վավերականության ստուգում jQuery-ի միջոցով

Ցանկացած ձև պետք է ստուգի մուտքագրված տվյալների վավերականությունը և՛ հաճախորդի կողմից (օգտագործելով JavaScript, jQuery), և՛ սերվերի կողմից:

Մենք պետք է հատուկ ուշադրություն դարձնենք Email դաշտին։ Շատ կարևոր է, որ մուտքագրված փոստային հասցեն վավեր է։

Այս մուտքագրման դաշտի համար մենք սահմանել ենք էլփոստի տեսակը (type="email"), սա մի փոքր զգուշացնում է մեզ սխալ ձևաչափերի դեմ: Բայց դա բավարար չէ, քանի որ բրաուզերի կողմից մեզ տրամադրած կոդի տեսուչի միջոցով մենք հեշտությամբ կարող ենք փոխել հատկանիշի արժեքը տիպՀետ էլվրա տեքստը, և վերջ, մեր չեկն այլևս վավեր չի լինի։

Եվ այս դեպքում մենք պետք է ավելի հուսալի ստուգում կատարենք։ Դա անելու համար մենք կօգտագործենք jQuery գրադարանը JavaScript-ից:

jQuery գրադարանը միացնելու համար ֆայլում header.phpպիտակների միջև , փակման պիտակից առաջ , ավելացրեք այս տողը.

Այս տողից անմիջապես հետո մենք կավելացնենք էլփոստի վավերացման կոդը: Այստեղ մենք կավելացնենք ծածկագիր՝ մուտքագրված գաղտնաբառի երկարությունը ստուգելու համար։ Դրա երկարությունը պետք է լինի առնվազն 6 նիշ:

Օգտագործելով այս սկրիպտը, մենք ստուգում ենք մուտքագրված էլփոստի հասցեն վավերականության համար: Եթե օգտվողը սխալ էլ. Եթե ամեն ինչ լավ է, ապա մենք հեռացնում ենք սխալը և ակտիվացնում ենք ձևի ուղարկման կոճակը:

Եվ այսպես, մենք ավարտեցինք ձևի վավերացումը հաճախորդի կողմից: Այժմ մենք կարող ենք այն ուղարկել սերվեր, որտեղ նույնպես մի քանի ստուգումներ կանենք և տվյալների բազա կավելացնենք։

Օգտագործողի գրանցում

Մենք ձևը ուղարկում ենք ֆայլ՝ մշակման register.php, POST մեթոդի միջոցով։ Այս կարգավորիչի ֆայլի անունը նշված է հատկանիշի արժեքում գործողություն. Իսկ ուղարկման եղանակը նշված է հատկանիշի արժեքում մեթոդ.

Բացեք այս ֆայլը register.phpև առաջին բանը, որ մենք պետք է անենք, սեսիայի գործարկման գործառույթ գրելն ու նախկինում ստեղծած ֆայլը միացնելն է dbconnect.php(Այս ֆայլում մենք կապ ենք հաստատել տվյալների բազայի հետ): Եվ նաև, եկեք անմիջապես հայտարարենք բջիջները error_messagesԵվ հաջողության_հաղորդագրություններգլոբալ նիստերի զանգվածում: IN error_mesagesմենք կգրանցենք բոլոր սխալի հաղորդագրությունները, որոնք տեղի են ունենում ձևաթղթերի մշակման ընթացքում և ներս succes_messages, մենք կգրանցենք ուրախ հաղորդագրություններ։

Նախքան շարունակելը, մենք պետք է ստուգենք, թե արդյոք ձևն ընդհանրապես ներկայացվել է: Հարձակվողը կարող է դիտել հատկանիշի արժեքը գործողությունձևից և պարզեք, թե որ ֆայլն է մշակում այս ձևը: Եվ նա կարող է գաղափար ունենալ ուղղակիորեն գնալ այս ֆայլ՝ մուտքագրելով հետևյալ հասցեն բրաուզերի հասցեագոտում. http://site_address/register.php

Այսպիսով, մենք պետք է ստուգենք գլոբալ POST զանգվածի մի բջիջ, որի անունը համընկնում է մեր «Գրանցվել» կոճակի անվան հետ: Այս կերպ մենք ստուգում ենք՝ սեղմված է «Գրանցվել» կոճակը, թե ոչ։

Եթե հարձակվողը փորձի ուղղակիորեն գնալ այս ֆայլ, նա սխալի հաղորդագրություն կստանա: Հիշեցնեմ, որ $address_site փոփոխականը պարունակում է կայքի անվանումը և այն հայտարարագրվել է ֆայլում dbconnect.php.

Captcha-ի արժեքը նիստում ավելացվել է, երբ այն ստեղծվել է, ֆայլում captcha.php. Որպես հիշեցում, ես ձեզ նորից կցուցադրեմ այս կոդը ֆայլից captcha.php, որտեղ captcha արժեքը ավելացվում է նիստին.

Հիմա եկեք անցնենք ինքնին ստուգմանը: Ֆայլում register.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 ("Տեղադրում. " .$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 Moved Permanently"); header("Location: ".$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 Moved Permanently"); header("Location: ".$address_site."/form_register.php"); //Stop the script exit(); ) if( isset($_POST["email"]))( //Կտրել բացատները տողի սկզբից և վերջից $email = trim($_POST["email"]); if(!empty($email)) ( $email = htmlspecialchars ($email, ENT_QUOTES); // (3) էլփոստի հասցեի ձևաչափը և դրա յուրահատկությունը ստուգելու կոդի գտնվելու վայրը )else( // Պահպանեք սխալի հաղորդագրությունը նիստում: $_SESSION["error_messages"] .="

Մուտքագրեք ձեր էլ

"; //Վերադարձրեք օգտատիրոջը գրանցման էջի վերնագիր("HTTP/1.1 301 Moved Permanently"); header("Location: ".$address_site."/form_register.php"); //Stop the script exit(); ) if( isset($_POST["գաղտնաբառ"]))( //Կտրել բացատները տողի սկզբից և վերջից $password = trim($_POST["password"]); 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 Moved Permanently"); header("Location: ".$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, ազգանուն, էլ. փոստ, գաղտնաբառը) VALUES ("".$first_name."", "".$last_name ." ", "".$email.", "".$password."")"); 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տվյալների շտեմարանին միանալու համար:

Երբ դուք սեղմում եք կայքից դուրս գալու հղումը, մենք տեղափոխվում ենք ֆայլ logout.php, որտեղ մենք պարզապես ոչնչացնում ենք նիստի էլեկտրոնային հասցեով և գաղտնաբառով բջիջները։ Դրանից հետո մենք օգտվողին վերադարձնում ենք այն էջը, որի վրա սեղմվել է հղումը ելք.

Ֆայլի կոդը logout.php:

Այսքանը: Այժմ դուք գիտեք, թե ինչպես կիրառել և մշակել օգտվողների գրանցման և թույլտվության ձևերը ձեր կայքում: Այս ձևերը կարելի է գտնել գրեթե յուրաքանչյուր կայքում, ուստի յուրաքանչյուր ծրագրավորող պետք է իմանա, թե ինչպես ստեղծել դրանք:

Մենք նաև սովորեցինք, թե ինչպես վավերացնել մուտքագրված տվյալները ինչպես հաճախորդի կողմից (բրաուզերում՝ օգտագործելով JavaScript, jQuery), այնպես էլ սերվերի կողմից (օգտագործելով PHP): Մենք նաև սովորեցինք, թե ինչպես իրականացնել կայքից դուրս գալու ընթացակարգ։

Բոլոր սցենարները փորձարկված են և աշխատում են։ Դուք կարող եք ներբեռնել արխիվը այս փոքրիկ կայքի ֆայլերով այս հղումից։

Հետագայում հոդված կգրեմ, որտեղ կնկարագրեմ. Եվ ես նախատեսում եմ նաև հոդված գրել, որտեղ կբացատրեմ (առանց էջը վերաբեռնելու): Այսպիսով, նոր հոդվածների թողարկման մասին տեղեկացված լինելու համար կարող եք բաժանորդագրվել իմ կայքին։

Հարցերի դեպքում դիմեք ինձ, իսկ եթե հոդվածում սխալ եք նկատում, խնդրում եմ տեղեկացրեք ինձ:

Դասի պլան (մաս 5):

Թույլտվության ձևի համար HTML կառուցվածքի ստեղծում

Մենք մշակում ենք ստացված տվյալները

Մենք ցուցադրում ենք օգտատիրոջ ողջույնը կայքի վերնագրում

Ձեզ դուր եկավ հոդվածը:

Չգիտեմ ինչու... ոչ, ես գիտեմ, թե ինչու չեք կարող միացնել register_globals դիրեկտիվը, բայց չգիտեմ ինչու գրականության մեջ, որպես կանոն, այս մասին ոչինչ չի ասվում։

Այս հոդվածում ես կփորձեմ տանկից հանել բոլոր նրանց, ովքեր նստած են դրա մեջ և բացատրել, թե ինչն է (հատկապես զրահապատ գնացքում գտնվողների համար - խմբագրի նշումը): Իզուր չէ, որ որոշ հոսթեր անջատում են այս հրահանգը: Այսպիսով…

Ինչպես է դա աշխատում

PHP-ի կարգավորումներում (php.ini ֆայլ) կա այսպիսի register_globals դիրեկտիվ։ Դրա իմաստն այն է, որ եթե այն միացված է (register_globals = on), ապա GET-ի և POST-ի միջոցով փոխանցված բոլոր փոփոխականները ավտոմատ կերպով կգրանցվեն որպես գլոբալ: Ինչ է դա նշանակում?

Օրինակ, մենք փոխանցում ենք GET մեթոդը index.php սցենարին որոշ էջի արժեք՝ index.php?page=2: Անցած արժեքը պահվում է GET զանգվածում և կարող է օգտագործվել սկրիպտում որպես $_GET["էջ"]: Այնուամենայնիվ, եթե միացված ենք register_globals-ը, ապա փոխանցված արժեքի համար կստեղծվի $page փոփոխական, որը հասանելի է index.php սցենարի ցանկացած մասում։

Փոքրիկ ամփոփում և լրացում. Երբ register_globals-ը միացված է, փոփոխականի երեք օրինակ է ստեղծվում. երբ 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&password =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:

Կարծում եմ, ինչ-որ մեկի մոտ հարց կա, թե ինչպես է կոտրիչը իմանում check փոփոխականի մասին, որ նա պատասխանատու է ամեն ինչի համար: Եթե դուք ոչ մեկին չեք ցուցադրել սցենարը, ապա դժվար թե նրանք դա իմանան: Այնուամենայնիվ, ոչ բոլորն են օգտագործում իրենց սեփական սցենարները, CMS-ը և այլն, այլ օգտագործում են այն, ինչ հասանելի է ցանցում: Նման դեպքերում կոտրիչը, օրինակ, կարող է ուսումնասիրել CMS կոդը և հարձակվել նրա օգնությամբ ստեղծված կայքերի վրա։

Այնուամենայնիվ, ոչ բոլոր հոսթերներն են անջատում register_globals-ը, և նույնիսկ եթե ձեր սկրիպտները նախագծված են այնպես, որ միացված չլինեն register_globals-ը, կոտրիչը դեռ կարող է կոտրել ձեր սցենարը՝ օգտագործելով այս հրահանգի խոցելիությունը:

Վերցնենք մեր օրինակը. Այն պաշտպանելու համար, երբ register_globals-ը միացված է, տողից հետո եթե ($գաղտնաբառը==$իրական_անցում) $ստուգել =ճիշտ;ավելացնել հետևյալը. ուրիշ $ստուգել =կեղծ;. Այս դեպքում, եթե նույնիսկ մեկին հավասար ստուգիչ փոփոխականը փոխանցվի GET մեթոդով, սկրիպտը դեռ կսահմանի $check=false, եթե գաղտնաբառը սխալ է:

Այո, ես ուզում եմ նաև ձեր ուշադրությունը հրավիրել այն փաստի վրա, որ եթե անջատեք register_globals-ը, ապա մեր օրինակը չի աշխատի։ Իսկ որպեսզի այն աշխատի, պետք է գրել $login = $_POST["login"]; $password = $_POST["գաղտնաբառ"];

Եկեք ամփոփենք...

և արեք երկու հիմնական եզրակացություն.

1) Երբ register_globals-ը միացված է, կարող եք փոխանցել տարբեր փոփոխականներ, որոնց արժեքները չեն հաշվարկվել GET-ի կամ POST-ի միջոցով ստանալու համար:

2) Register_globals-ն ինքնին այնքան էլ վտանգավոր չէ, որքան ծուռ գրված սցենարը։

Այսքանն է այսօրվա համար: Ես շատ ուրախ կլինեմ տեսնել ձեր մեկնաբանությունները, դիտողությունները, առաջարկությունները և պարզապես արձագանքները: Հետևաբար, գրեք, մի ամաչեք:

Հաջող շաբաթվա մաղթանքներով՝
Ալեքսանդր ՇՈՒՅՍԿԻ