տուն Մանկական ստոմատոլոգիա Գործադիր գրանցում php. Օգտագործողի գրանցման պարզ համակարգ

Մանկական ստոմատոլոգիա

Գործադիր գրանցում php. Օգտագործողի գրանցման պարզ համակարգ

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

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

Ներբեռնեք կոդը

Դուք կարող եք ներբեռնել գրանցման/մուտքի համակարգի ամբողջ սկզբնական կոդը ստորև բերված հղումից.

Կազմաձևում և վերբեռնում
ReadMe ֆայլը պարունակում է մանրամասն հրահանգներ:

Բացեք source\include\membersite_config.phpֆայլը տեքստային խմբագրիչում և թարմացրեք կոնֆիգուրացիան: (Տվյալների բազայի մուտք, ձեր կայքի անունը, ձեր էլ.փոստի հասցեն և այլն):

Վերբեռնեք ամբողջ գրացուցակի բովանդակությունը: Փորձարկեք register.php-ը՝ ներկայացնելով ձևը:

Գրանցման ձևը

Օգտատիրոջ հաշիվ ստեղծելու համար մենք պետք է օգտագործողից հավաքենք նվազագույն քանակությամբ տեղեկատվություն: Մեզ անհրաժեշտ է նրա անունը, էլ. փոստի հասցեն և ցանկալի օգտանունն ու գաղտնաբառը: Իհարկե, այս պահին մենք կարող ենք լրացուցիչ տեղեկություններ խնդրել, բայց երկար ձևը միշտ անջատում է: Այսպիսով, եկեք սահմանափակվենք միայն այդ ոլորտներով:

Ահա գրանցման ձևը.

Այսպիսով, մենք ունենք տեքստային դաշտեր անվան, էլ.փոստի և գաղտնաբառի համար: Նկատի ունեցեք, որ մենք օգտագործում ենք ավելի լավ օգտագործման համար:

Ձևի վավերացում

Այս պահին լավ գաղափար է տեղադրել որոշ ձևի վավերացման կոդ, այնպես որ մենք համոզվում ենք, որ ունենք բոլոր տվյալները, որոնք անհրաժեշտ են օգտվողի հաշիվ ստեղծելու համար: Մենք պետք է ստուգենք՝ արդյո՞ք լրացված են անունը, էլ.փոստը և գաղտնաբառը, և արդյոք էլ.

Ձևաթղթի ներկայացում

Այժմ մենք պետք է մշակենք ներկայացված ձևի տվյալները:

Ահա հաջորդականությունը (տե՛ս fg_membersite.php ֆայլը ներբեռնված աղբյուրում).

ֆունկցիա RegisterUser() ( if(!isset($_POST["submitted"])) ( return false; ) $formvars = array(); if(!$this->ValidateRegistrationSubmission()) ( return false; ) $this- >CollectRegistrationSubmission($formvars); if(!$this->SaveToDatabase($formvars)) ( return false; ) if(!$this->SendUserConfirmationEmail($formvars)) ( return false; ) $this->SendAdminIntimationEmail($ formvars); վերադարձնել ճշմարիտ;)

Նախ, մենք վավերացնում ենք ձևի ներկայացումը: Այնուհետև մենք հավաքում և «ախտահանում» ենք ձևաթղթերի ներկայացման տվյալները (միշտ դա արեք նախքան էլփոստ ուղարկելը, տվյալների բազա պահելը և այլն): Ձևի ներկայացումն այնուհետև պահվում է տվյալների բազայի աղյուսակում: Մենք նամակ ենք ուղարկում օգտատիրոջը՝ հաստատման խնդրանքով: Այնուհետև մենք տեղեկացնում ենք ադմինիստրատորին, որ օգտատերը գրանցվել է:

Տվյալների պահպանում տվյալների բազայում

Այժմ, երբ մենք հավաքեցինք բոլոր տվյալները, մենք պետք է դրանք պահենք տվյալների բազայում:
Ահա թե ինչպես ենք մենք պահում ձևի ներկայացումը տվյալների բազայում:

ֆունկցիա SaveToDatabase(&$formvars) ( if(!$this->DBLlogin()) ($this->HandleError("Tabase մուտք գործելը ձախողվեց!"); վերադարձ կեղծ; ) if(!$this->Ensuretable()) ( return false; ) if(!$this->IsFieldUnique($formvars,"email")) ($this->HandleError("Այս էլ. նամակն արդեն գրանցված է"); return false;) if(!$this->IsFieldUnique( $formvars,"username")) ( $this->HandleError ("Այս օգտվողի անունը արդեն օգտագործվում է: Խնդրում ենք փորձել այլ օգտվողի անուն"); վերադարձնել կեղծ; ) if(!$this->InsertIntoDB($formvars)) ($this- >HandleError («Տվյալների բազայում զետեղումը ձախողվեց»); վերադարձ կեղծ; ) վերադարձ ճիշտ;

Նկատի ունեցեք, որ դուք կարգավորել եք տվյալների բազայի մուտքի մանրամասները Memberite_config.php ֆայլում: Դեպքերի մեծ մասում դուք կարող եք օգտագործել «localhost» տվյալների բազայի հոսթի համար.
Մուտք գործելուց հետո մենք համոզվում ենք, որ աղյուսակը գոյություն ունի: (Եթե ոչ, ապա սցենարը կստեղծի անհրաժեշտ աղյուսակը):
Այնուհետև մենք համոզվում ենք, որ օգտվողի անունը և էլ.փոստը եզակի են: Եթե այն եզակի չէ, մենք սխալը վերադարձնում ենք օգտվողին:

Տվյալների բազայի աղյուսակի կառուցվածքը

Սա սեղանի կառուցվածքն է: CreateTable() ֆունկցիան fg_membersite.php ֆայլում ստեղծում է աղյուսակը: Ահա կոդը.

function CreateTable() ( $qry = "Ստեղծել աղյուսակ $this->tablename (". "id_user INT NOT NULL AUTO_INCREMENT ," "name VARCHAR(128) NOT NULL ," "էլ. VARCHAR(16) NOT NULL ," "username VARCHAR(16) NOT NULL ," "password VARCHAR(32) NOT NULL ," "հաստատել կոդը VARCHAR(32)", "PRIMARY KEY (id_user)" ")"; if(( !mysql_query($qry,$this->միացում)) ( $this->HandleDBError("Սխալ՝ ստեղծելով աղյուսակը \nհարցումը եղել է\n $qry"); վերադարձնել կեղծ; ) վերադարձնել ճիշտ;)

id_user դաշտը կպարունակի օգտագործողի եզակի ID-ն և նաև աղյուսակի հիմնական բանալին է: Ուշադրություն դարձրեք, որ գաղտնաբառի դաշտի համար մենք թույլ ենք տալիս 32 նիշ: Մենք դա անում ենք, քանի որ որպես անվտանգության հավելյալ միջոց՝ մենք կպահենք գաղտնաբառը MD5-ի միջոցով կոդավորված տվյալների բազայում: Խնդրում ենք նկատի ունենալ, որ քանի որ MD5-ը միակողմանի գաղտնագրման մեթոդ է, մենք չենք կարողանա վերականգնել գաղտնաբառը, եթե օգտագործողը մոռանա այն:

Գրանցումը աղյուսակի մեջ մտցնելը

Ահա այն կոդը, որը մենք օգտագործում ենք տվյալների բազայում տվյալների տեղադրման համար: Մեր բոլոր տվյալները հասանելի կլինեն $formvars զանգվածում:

ֆունկցիա InsertIntoDB(&$formvars) ($confirmcode = $this->MakeConfirmationMd5($formvars["email"]); $insert_query = "insert into ".$this->tablename."(անուն, էլ. փոստ, օգտվողի անուն, գաղտնաբառ, հաստատման կոդը) արժեքները ("" . $this->SanitizeForSQL($formvars["name"]) . "", "" . $this->SanitizeForSQL($formvars["էլ.փոստ"]) . "", "" $ this->SanitizeForSQL($formvars["username"]) . "", "" . md5($formvars["password"]) . "", "" . $confirmcode . "")"; if(! mysql_query( $insert_query ,$this->connect)) ( $this->HandleDBError("Սխալ՝ աղյուսակում տվյալների տեղադրման ժամանակ\nհարցում:$insert_query"); վերադարձնել կեղծ; ) վերադարձ ճիշտ; )

Ուշադրություն դարձրեք, որ մենք օգտագործում ենք PHP ֆունկցիան md5()՝ ծածկագրելու համար գաղտնաբառը տվյալների բազայում տեղադրելուց առաջ:
Բացի այդ, մենք ստեղծում ենք եզակի հաստատման կոդը օգտատիրոջ էլ.փոստի հասցեից:

Նամակներ ուղարկելը

Այժմ, երբ մենք գրանցում ենք մեր տվյալների բազայում, մենք հաստատող նամակ կուղարկենք օգտվողին: Օգտագործողը պետք է սեղմի հաստատման էլ.փոստի հղումը՝ գրանցման գործընթացը ավարտելու համար:

ֆունկցիա SendUserConfirmationEmail(&$formvars) ($mailer = new PHPMailer(); $mailer->CharSet = "utf-8"; $mailer->AddAddress($formvars["email"],$formvars["name"]) $mailer->Subject = "Ձեր գրանցումը ".$this->sitename; $mailer->From = $this->GetFromAddress(); $confirmcode = urlencode($this->MakeConfirmationMd5($formvars["email"): ])); $confirm_url = $this->GetAbsoluteURLFolder()."/confirmreg.php?code=".$confirmcode; $mailer->Body = "Բարև ".$formvars["name"]."\r\ n\r\n". "Շնորհակալություն ".$this->sitename"-ով գրանցման համար."\r\n" "Խնդրում ենք սեղմել ստորև նշված հղմանը, որպեսզի հաստատեք Ձեր գրանցումը:\r\n." "$confirm_url\r" \n". "\r\n". "Հարգանքներով,\r\n". "Վեբմեյստեր\r\n" $this->sitename; if(!$mailer->Send()) ($this-> HandleError («Չհաջողվեց ուղարկել գրանցման հաստատման էլ.փոստը»:); վերադարձ կեղծ;

Թարմացումներ

9 հունվարի 2012թ
Գաղտնաբառի վերակայման/գաղտնաբառի փոփոխման գործառույթներն ավելացվել են
Այժմ կոդը համօգտագործվում է GitHub-ում:

Բարի վերադարձUserFullName(); ?>!

Լիցենզիա

Կոդը տարածվում է LGPL լիցենզիայի ներքո: Դուք կարող եք ազատորեն օգտագործել այն առևտրային կամ ոչ առևտրային կայքերում:

Առնչվող գրառումներ չկան:

Այս գրառման մեկնաբանությունները փակ են:

Կայքի այցելուներին որոշակի խմբերի բաժանելու համար պետք է կայքում տեղադրվի փոքր համակարգ գրանցում php-ում. Այսպիսով, դուք այցելուներին պայմանականորեն բաժանում եք երկու խմբի՝ պարզապես պատահական այցելուների և ավելի արտոնյալ օգտատերերի խմբի, որոնց տրամադրում եք ավելի արժեքավոր տեղեկատվություն։

Շատ դեպքերում օգտագործվում է գրանցման ավելի պարզեցված համակարգ, որը գրված է php-ով մեկ ֆայլում register.php.

Այսպիսով, մենք մի փոքր շեղվեցինք, և այժմ մենք ավելի մանրամասն կանդրադառնանք գրանցման ֆայլին:

Register.php ֆայլ

Ապահովելու համար, որ դա ձեր ժամանակից շատ չի խլում, մենք կստեղծենք համակարգ, որը կհավաքի օգտատերերին՝ ընդունելով նրանցից նվազագույն կոնտակտային տվյալներ: Այս դեպքում մենք ամեն ինչ մուտքագրելու ենք mysql տվյալների բազա։ Տվյալների բազայի ամենաբարձր արագության համար մենք կստեղծենք օգտվողների աղյուսակը MyISAM ձևաչափով և utf-8 կոդավորմամբ:

Նշում! Բոլոր սցենարները միշտ պետք է գրվեն նույն կոդավորման մեջ: Կայքի բոլոր ֆայլերը և MySql տվյալների բազան պետք է լինեն նույն կոդավորման մեջ: Ամենատարածված կոդավորումներն են UTF-8 և Windows-1251:

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

Ինչպե՞ս կաշխատի սցենարն ինքնին:

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

Ահա ինքնին սցենարը. Ամեն ինչ գրանցված է մեկ ֆայլում register.php:

! `; // կարմիր հարցական նշան $sha=$sh."scripts/pro/"; //ուղի դեպի հիմնական թղթապանակ $bg=` bgcolor="#E1FFEB"`; // տողերի ֆոնի գույնը?> Գրանցման սցենարի օրինակ register.php style.css" />

Այս դեպքում սցենարը վերաբերում է իրեն։ Եվ դա ձևաթղթ է և ձևաթղթի մեջ մուտքագրված տվյալների մշակող։ Խնդրում ենք նկատի ունենալ, որ ֆայլը սեղմված է որպես zip արխիվ և պարունակում է կոնֆիգուրացիայի ֆայլ config.php, օգտվողների տվյալների բազայի աղբարկղ, ֆայլ, որը պարունակում է օժանդակ գործառույթներ functions.php, ոճային ֆայլ style.css և հենց register.php ֆայլը: Կան նաև մի քանի ֆայլեր, որոնք պատասխանատու են captcha սիմվոլների շահագործման և ստեղծման համար:

Բարեւ Ձեզ! Այժմ մենք կփորձենք իրականացնել ամենապարզ գրանցումը կայքում՝ օգտագործելով PHP + MySQL: Դա անելու համար Apache-ը պետք է տեղադրված լինի ձեր համակարգչում: Մեր սցենարի աշխատանքի սկզբունքը ներկայացված է ստորև։

1. Սկսենք ստեղծելով օգտվողների աղյուսակը տվյալների բազայում. Այն կպարունակի օգտվողի տվյալներ (մուտք և գաղտնաբառ): Եկեք գնանք phpmyadmin (եթե դուք ստեղծում եք տվյալների բազա ձեր համակարգչի վրա http://localhost/phpmyadmin/) Ստեղծեք աղյուսակ օգտվողներ, այն կունենա 3 դաշտ։

Ես այն ստեղծում եմ mysql տվյալների բազայում, դուք կարող եք այն ստեղծել այլ տվյալների բազայում։ Հաջորդը, սահմանեք արժեքները, ինչպես նկարում.

2. Պահանջվում է միացում այս աղյուսակին:Եկեք ստեղծենք ֆայլ bd.php. Դրա բովանդակությունը.

$db = mysql_connect («ձեր MySQL սերվերը», «մուտք այս սերվերի համար», «գաղտնաբառ այս սերվերի համար»);
mysql_select_db («շտեմարանի անվանումը, որին մենք միանում ենք», $db);
?>

Իմ դեպքում դա այսպիսի տեսք ունի.

$db = mysql_connect ("localhost", "user", "1234");
mysql_select_db ("mysql",$db);
?>

Պահպանել bd.php.
Հիանալի Տվյալների բազայում ունենք աղյուսակ և դրա հետ կապ: Այժմ դուք կարող եք սկսել ստեղծել էջ, որի վրա օգտվողները կթողնեն իրենց տվյալները:

3. Ստեղծեք reg.php ֆայլ բովանդակությամբ (բոլոր մեկնաբանությունները ներսում).

Գրանցում

4. Ստեղծեք ֆայլ, որը տվյալների բազա կմտնի և կփրկի օգտատիրոջը: save_user.php(մեկնաբանությունները ներսում):

{
}
//եթե մուտքն ու գաղտնաբառը մուտքագրված են, ապա մենք դրանք մշակում ենք, որպեսզի պիտակները և սկրիպտները չաշխատեն, երբեք չգիտես, թե մարդիկ ինչ կարող են մուտքագրել

//հեռացնել ավելորդ բացատները
$login = trim ($login);
$գաղտնաբառ = կտրել ($գաղտնաբառ);
// միանալ տվյալների շտեմարանին
// ստուգեք նույն մուտքով օգտվողի առկայությունը
$result = mysql_query("SELECT id FROM users WHERE login="$login"",$db);
եթե (!empty($myrow["id"])) (
exit («Կներեք, ձեր մուտքագրված մուտքն արդեն գրանցված է: Խնդրում ենք մուտքագրել մեկ այլ մուտք»);
}
// եթե դա այդպես չէ, ապա պահպանեք տվյալները
$result2 = mysql_query ("INSERT INTO users (login, password) VALUES ("$login","$password")");
// Ստուգեք, արդյոք սխալներ կան
եթե ($result2=="TRUE")
{
echo «Դուք հաջողությամբ գրանցվել եք: Այժմ կարող եք մուտք գործել կայք: Գլխավոր էջ»;
}
ուրիշ (
echo «Սխալ: Դուք գրանցված չեք»:;
}
?>

5. Այժմ մեր օգտվողները կարող են գրանցվել:Հաջորդը, դուք պետք է ստեղծեք «դուռ» արդեն գրանցված օգտվողների համար կայք մուտք գործելու համար: index.php(մեկնաբանությունները ներսում):

// ամբողջ պրոցեդուրան աշխատում է նիստերում։ Այն այնտեղ է, որտեղ պահպանվում են օգտատիրոջ տվյալները, երբ նա գտնվում է կայքում: Շատ կարևոր է դրանք գործարկել հենց էջի սկզբում!!!
նիստ_սկիզբ ();
?>

Գլխավոր էջ

Գլխավոր էջ

// Ստուգեք՝ արդյոք մուտքի և օգտագործողի id փոփոխականները դատարկ են
եթե (դատարկ ($_SESSION["մուտք"]) կամ դատարկ ($_SESSION["id"]))
{
// Եթե դատարկ է, ապա մենք չենք ցուցադրում հղումը
echo «Դուք մուտք եք գործել որպես հյուր
Այս հղումը հասանելի է միայն գրանցված օգտվողներին»;
}
ուրիշ
{

Ֆայլում index.phpՄենք կցուցադրենք հղում, որը բաց կլինի միայն գրանցված օգտատերերի համար: Սա է սցենարի ամբողջ իմաստը` սահմանափակել մուտքը ցանկացած տվյալների:

6. Մնում է ֆայլ՝ մուտքագրված մուտքի և գաղտնաբառի ստուգմամբ: testreg.php (մեկնաբանություններ ներսում):

session_start();// ամբողջ պրոցեդուրան աշխատում է նիստերի վրա: Այն այնտեղ է, որտեղ պահպանվում են օգտատիրոջ տվյալները, երբ նա գտնվում է կայքում: Շատ կարևոր է դրանք գործարկել հենց էջի սկզբում!!!
if (isset($_POST["login"])) ($login = $_POST["login"]; if ($login == "") ( unset($login);) ) //մուտքագրեք մուտքի մուտքը օգտագործողը $login փոփոխականի մեջ, եթե այն դատարկ է, ապա ոչնչացրեք փոփոխականը
if (isset($_POST["password"])) ($password=$_POST["password"]; if ($password =="") ( unset($password);) )
//օգտագործողի մուտքագրած գաղտնաբառը դրեք $password փոփոխականի մեջ, եթե այն դատարկ է, ապա ոչնչացրեք փոփոխականը
եթե (դատարկ ($login) կամ դատարկ ($password)) //եթե օգտատերը չի մուտքագրել մուտք կամ գաղտնաբառ, ապա մենք սխալ ենք թույլ տալիս և դադարեցնում սկրիպտը
{
exit («Դուք չեք մուտքագրել ամբողջ տեղեկատվությունը, վերադարձեք և լրացրեք բոլոր դաշտերը»);
}
//եթե մուտքն ու գաղտնաբառը մուտքագրված են, ապա մենք դրանք մշակում ենք, որպեսզի պիտակները և սկրիպտները չաշխատեն, երբեք չգիտես, թե մարդիկ ինչ կարող են մուտքագրել
$login = stripslashes ($login);
$login = htmlspecialchars ($login);
$password = stripslashes ($password);
$password = htmlspecialchars ($password);
//հեռացնել ավելորդ բացատները
$login = trim ($login);
$գաղտնաբառ = կտրել ($գաղտնաբառ);
// միանալ տվյալների շտեմարանին
include("bd.php");// bd.php ֆայլը պետք է լինի նույն թղթապանակում, ինչ բոլոր մյուսները, եթե այդպես չէ, ապա պարզապես փոխեք ուղին

$result = mysql_query("SELECT * FROM users WHERE login="$login"",$db); //առբերել տվյալների բազայից օգտագործողի մասին բոլոր տվյալները մուտքագրված մուտքով
$myrow = mysql_fetch_array ($ արդյունք);
եթե (դատարկ ($myrow["password"]))
{
//եթե մուտքագրված լոգինով օգտվողը գոյություն չունի
}
ուրիշ (
//եթե գոյություն ունի, ապա ստուգեք գաղտնաբառերը
եթե ($myrow["password"]==$password) (
//եթե գաղտնաբառերը համընկնում են, ապա մենք գործարկում ենք սեսիա օգտագործողի համար: Դուք կարող եք շնորհավորել նրան, նա ներս մտավ:
$_SESSION["login"]=$myrow["login"];
$_SESSION["id"]=$myrow["id"];//Այս տվյալներն օգտագործվում են շատ հաճախ, ուստի մուտք գործած օգտատերը «այն կտանի իր հետ»:
echo «Դուք հաջողությամբ մուտք եք գործել կայք! Գլխավոր էջ»;
}
ուրիշ (
//եթե գաղտնաբառերը չեն համընկնում

Դուրս գալ («Կներեք, ձեր մուտքագրած մուտքը կամ գաղտնաբառը սխալ է»);
}
}
?>

Լավ, հիմա ամեն ինչ ավարտված է: Դասը կարող է լինել ձանձրալի, բայց շատ օգտակար: Այստեղ ցուցադրվում է միայն գրանցման գաղափարը, այնուհետև կարող եք բարելավել այն. ավելացնել պաշտպանություն, դիզայն, տվյալների դաշտեր, բեռնել ավատարներ, դուրս գալ հաշվից (դա անելու համար պարզապես գործառույթով ջնջեք փոփոխականները նիստից: չկարգավորված) և այլն։ Հաջողություն!

Ես ամեն ինչ ստուգեցի, ճիշտ է աշխատում:

Այսօր մենք կանդրադառնանք հանրաճանաչ CMS Joomla-ում 1-օրյա կարևոր խոցելիության շահագործմանը, որը պայթեց համացանցում հոկտեմբերի վերջին: Խոցելիության մասին կխոսենք թվերով CVE-2016-8869, CVE-2016-8870Եվ CVE-2016-9081. Երեքն էլ գալիս են մեկ կոդից, որը հինգ երկար տարիներ մնաց շրջանակի խորքում՝ սպասելով թեւերի մեջ, միայն հետո ազատ արձակվի և իր հետ բերի քաոս, կոտրված կայքեր և այս Joomla-ի անմեղ օգտատերերի արցունքները: Միայն ամենախիզախ և խիզախ մշակողները, որոնց աչքերը կարմիր են մոնիտորների լույսից, և որոնց ստեղնաշարերը լցված են հացի փշրանքներով, կարողացան մարտահրավեր նետել կատաղի չար ոգիներին և իրենց գլուխները դնել շտկման զոհասեղանի վրա:

ԶԳՈՒՇԱՑՈՒՄ

Ամբողջ տեղեկատվությունը տրամադրվում է միայն տեղեկատվական նպատակներով: Ոչ խմբագիրները, ոչ հեղինակը պատասխանատվություն չեն կրում սույն հոդվածի նյութերի պատճառած հնարավոր վնասի համար:

Այնտեղ, որտեղ ամեն ինչ սկսվեց

2016 թվականի հոկտեմբերի 6-ին Դեմիս Պալման Stack Exchange-ում ստեղծեց մի թեմա, որտեղ նա հարցրեց. իրականում ինչո՞ւ Joomla-ի 3.6 տարբերակում կա նույն անունով գրանցված օգտատերերի գրանցման երկու եղանակ: Առաջինը UsersControllerRegistration վերահսկիչում է, իսկ երկրորդը՝ UsersControllerUser վերահսկիչում։ Դամիսն ուզում էր իմանալ՝ UsersControllerUser::register() մեթոդը ինչ-որ տեղ օգտագործվե՞լ է, թե՞ դա պարզապես հին տրամաբանությունից մնացած էվոլյուցիոն անախրոնիզմ է։ Նրա մտահոգությունն այն էր, որ նույնիսկ եթե այս մեթոդը չի օգտագործվում որևէ տեսակետի կողմից, այն կարող է կոչվել մշակված հարցումով: Ինչին ես պատասխան ստացա իկտոպուս մականունով ծրագրավորողից, որը հաստատեց՝ խնդիրն իսկապես կա։ Եվ հաշվետվություն ուղարկեց Joomla-ի մշակողներին:

Հետո իրադարձություններն ամենաարագ զարգացան։ Հոկտեմբերի 18-ին Joomla-ի մշակողները ընդունեցին Damis-ի զեկույցը, որն այդ ժամանակ մշակել էր PoC-ի նախագիծ, որը թույլ կտա գրանցել օգտվողներին: Նա գրություն է հրապարակել իր կայքում, որտեղ ընդհանուր առմամբ խոսել է իր գտած խնդրի և այս հարցի վերաբերյալ իր մտքերի մասին։ Նույն օրը թողարկվում է Joomla 3.6.3-ի նոր տարբերակը, որը դեռ պարունակում է խոցելի կոդ։

Սրանից հետո Դավիդե Տամպելինին սխալը պտտեցնում է այնքան, որ գրանցում է ոչ թե պարզ օգտատեր, այլ ադմինիստրատոր։ Իսկ հոկտեմբերի 21-ին նոր դեպք է հասնում Joomla-ի անվտանգության թիմին։ Այն արդեն խոսում է արտոնությունների ավելացման մասին։ Նույն օրը Joomla-ի կայքում հայտնվում է հայտարարություն այն մասին, որ երեքշաբթի օրը՝ հոկտեմբերի 25-ին, կթողարկվի հաջորդ տարբերակը՝ 3.6.3 սերիական համարով, որը շտկում է համակարգի միջուկի կրիտիկական խոցելիությունը։

Հոկտեմբերի 25 Joomla Security Strike Team-ը գտնում է Damis-ի կողմից հայտնաբերված կոդի կտորի կողմից ստեղծված վերջին խնդիրը: Այնուհետև հոկտեմբերի 21-ով թվագրված կոմիտեն՝ Prepare 3.6.4 Stable Release աննկատ անունով, դրվում է Joomla-ի պաշտոնական պահեստի հիմնական մասնաճյուղ, որն ուղղում է դժբախտ սխալը:

Այս հրապարակումից հետո բազմաթիվ շահագրգիռ անհատներ միանում են ծրագրավորողների համայնքին. նրանք սկսում են խթանել խոցելիությունը և պատրաստել շահագործում:

Հոկտեմբերի 27-ին հետազոտող Հարի Ռոբերթսը Xiphos Research-ի պահոց է վերբեռնում պատրաստի շահագործում, որը կարող է PHP ֆայլ վերբեռնել խոցելի CMS-ով սերվերի վրա:

Մանրամասներ

Դե, ֆոնն ավարտված է, անցնենք ամենահետաքրքիր մասին՝ խոցելիության վերլուծությանը։ Ես տեղադրել եմ Joomla 3.6.3-ը որպես փորձնական տարբերակ, այնպես որ բոլոր տողերի համարները համապատասխան կլինեն այս տարբերակի համար: Եվ ֆայլերի բոլոր ուղիները, որոնք դուք կտեսնեք ստորև, կնշվեն տեղադրված CMS-ի արմատի համեմատ:

Դեմիս Պալմայի հայտնագործության շնորհիվ մենք գիտենք, որ կա երկու մեթոդ, որոնք իրականացնում են օգտատերերի գրանցումը համակարգում։ Առաջինն օգտագործվում է CMS-ի կողմից և գտնվում է /components/com_users/controllers/registration.php:108 ֆայլում: Երկրորդը (նա, ում պետք է կանչենք) ապրում է /components/com_users/controllers/user.php:293-ում: Եկեք մանրամասն նայենք դրան:

286: /** 287: * Օգտատիրոջ գրանցման եղանակ: 288: * 289: * @return բուլյան 290: * 291: * @ince 1.6 292: */ 293: հանրային ֆունկցիայի գրանցում () 294: ( 295: JSession::checkToken ("post") կամ jexit (JText::_ («JINVALID_TOKEN»)); ... 300: // Ստացեք ձևի տվյալները: 301: $data = $this->input->post->get("user", array(), "array"); . .. 315: $return = $model->validate($form, $data); 316: 317: // Ստուգեք սխալների համար: 318: if ($return === false) 319: ( ... 345: / / Ավարտեք գրանցումը 346. $return = $model->register($data);

Այստեղ ես թողեցի միայն հետաքրքիր տողեր. Խոցելի մեթոդի ամբողջական տարբերակը կարելի է դիտել Joomla-ի պահոցում:

Եկեք պարզենք, թե ինչ է տեղի ունենում օգտատերերի սովորական գրանցման ժամանակ՝ ինչ տվյալներ են ուղարկվում և ինչպես են դրանք մշակվում: Եթե օգտատիրոջ գրանցումը միացված է կարգավորումներում, ձևը կարելի է գտնել http://joomla.local/index.php/component/users/?view=registration կայքում:

Օգտատիրոջ գրանցման օրինական հարցումը նման է հետևյալ սքրինշոթին:

com_users բաղադրիչը պատասխանատու է օգտատերերի հետ աշխատելու համար: Ուշադրություն դարձրեք հարցման մեջ առաջադրանքի պարամետրին: Այն ունի $controller.$method ձևաչափը: Եկեք նայենք ֆայլի կառուցվածքին:

Թղթապանակի սկրիպտների անունները վերահսկիչներհամապատասխանում են կանչված վերահսկիչների անուններին: Քանի որ մեր հարցումն այժմ պարունակում է $controller = "registration" , ֆայլը կկանչվի register.phpև դրա ռեգիստր() մեթոդը:

Ուշադրություն, հարց՝ ինչպե՞ս փոխանցել գրանցման գործընթացը կոդի խոցելի տեղ։ Դուք հավանաբար արդեն գուշակել եք դա։ Խոցելի և իրական մեթոդների անվանումները նույնն են (գրանցվել), այնպես որ մենք պարզապես պետք է փոխենք կանչված վերահսկիչի անունը։ Որտե՞ղ է գտնվում մեր խոցելի վերահսկիչը: Ճիշտ է, ֆայլում user.php. Ստացվում է $controller = "user" . Ամեն ինչ միացնելով մենք ստանում ենք task = user.register : Այժմ գրանցման հարցումը մշակվում է մեզ անհրաժեշտ մեթոդով:

Երկրորդ բանը, որ մենք պետք է անենք, տվյալները ճիշտ ձևաչափով ուղարկելն է: Այստեղ ամեն ինչ պարզ է. Legitimate register()-ը մեզնից ակնկալում է jform կոչվող զանգված, որում մենք փոխանցում ենք գրանցման տվյալները՝ անունը, մուտք, գաղտնաբառը, էլ.

/components/com_users/controllers/registration.php: 124: // Ստացեք օգտվողի տվյալները: 125. $requestData = $this->input->post->get("jform", array(), "array");

Մեր հաճախորդը ստանում է այս տվյալները օգտագործող կոչվող զանգվածից:

/components/com_users/controllers/user.php: 301: // Ստացեք ձևի տվյալները: 302. $data = $this->input->post->get("user", array(), "array");

Հետևաբար, մենք հարցումում բոլոր պարամետրերի անունները փոխում ենք jfrom-ից օգտվողի:

Մեր երրորդ քայլը վավեր CSRF նշան գտնելն է, քանի որ առանց դրա գրանցում չի լինի:

/components/com_users/controllers/user.php: 296: JSession::checkToken("post") կամ jexit(JText::_("JINVALID_TOKEN"));

Այն կարծես MD5 հեշ լինի, և դուք կարող եք այն վերցնել, օրինակ, /index.php/component/users/?view=login կայքի թույլտվության ձևից:

Այժմ դուք կարող եք ստեղծել օգտվողներ, օգտագործելով ցանկալի մեթոդը: Եթե ամեն ինչ ստացվեց, ապա շնորհավորում եմ, դուք պարզապես շահագործել եք խոցելիությունը CVE-2016-8870«Նոր օգտվողներ գրանցելու թույլտվության ստուգում չկա»:

Ահա թե ինչ տեսք ունի UsersControllerRegistration վերահսկիչի «աշխատանքային» ռեգիստր () մեթոդում.

/components/com_users/controllers/registration.php: 113: // Եթե գրանցումն անջատված է - Վերահղում դեպի մուտքի էջ: 114: if (JComponentHelper::getParams("com_users")->get("allowUserRegistration") == 0) 115: (116: $this->setRedirect(JRoute::_("index.php?option=com_users&view= մուտք», կեղծ)); 117: 118: վերադարձ կեղծ; 119: )

Եվ այսպես, խոցելի վիճակում.

/components/com_users/controllers/user.php:

Այո, ոչ մի կերպ:

Երկրորդ, շատ ավելի լուրջ խնդիրը հասկանալու համար ուղարկենք մեր ստեղծած հարցումը և տեսնենք, թե ինչպես է այն կատարվում կոդի տարբեր մասերում։ Ահա այն հատվածը, որը պատասխանատու է աշխատողի մեթոդով օգտագործողի կողմից ներկայացված տվյալների վավերացման համար.

Շարունակությունը հասանելի է միայն անդամներին

Տարբերակ 1. Միացեք «կայքի» համայնքին՝ կայքի բոլոր նյութերը կարդալու համար

Նշված ժամանակահատվածում համայնքին անդամակցությունը ձեզ հնարավորություն կտա մուտք գործել ԲՈԼՈՐ Հաքերային նյութերը, կավելացնի ձեր անձնական կուտակային զեղչը և թույլ կտա ձեզ կուտակել պրոֆեսիոնալ Xakep Score վարկանիշ:

Այս հոդվածում դուք կսովորեք ինչպես ստեղծել գրանցման և թույլտվության ձևօգտագործելով HTML, JavaScript, PHP և MySql: Նման ձևերը օգտագործվում են գրեթե բոլոր կայքերում՝ անկախ դրա տեսակից։ Դրանք ստեղծված են ֆորումի, առցանց խանութի, սոցիալական ցանցերի (օրինակ՝ Facebook, Twitter, Odnoklassniki) և շատ այլ տեսակի կայքերի համար։

Եթե դուք ունեք կայք ձեր տեղական համակարգչում, ապա հուսով եմ, որ դուք արդեն ունեք տեղական սերվերը տեղադրված է և աշխատում է. Առանց դրա ոչինչ չի ստացվի։

Տվյալների բազայում աղյուսակի ստեղծում

Օգտատիրոջ գրանցումն իրականացնելու համար մեզ առաջին հերթին անհրաժեշտ է Տվյալների բազա։ Եթե դուք արդեն ունեք, ապա հիանալի է, հակառակ դեպքում, դուք պետք է ստեղծեք այն: Հոդվածում ես մանրամասն բացատրում եմ, թե ինչպես դա անել:

Եվ այսպես, մենք ունենք Տվյալների բազա (կրճատ՝ DB), այժմ մենք պետք է ստեղծենք աղյուսակ օգտվողներորում մենք կավելացնենք մեր գրանցված օգտվողներին:

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

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

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

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

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

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

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

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

DB միացման սխալ. Սխալի նկարագրություն. «.mysqli_connect_error()»:

"; exit(); ) // Սահմանեք կապի կոդավորումը $mysqli->set_charset("utf8"); // Հարմարության համար այստեղ ավելացրեք փոփոխական, որը կպարունակի մեր կայքի անունը $address_site = "http://testsite .տեղական"; ?>

Այս ֆայլը 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տվյալների շտեմարանին միանալու համար:

//Հայտարարել բջիջ՝ ձևը մշակելիս սխալներ ավելացնելու համար: $_SESSION["error_messages"] = ""; //Հայտարարել հաջողված հաղորդագրություններ ավելացնելու բջիջ $_SESSION["success_messages"] = "";

/* Ստուգեք՝ արդյոք ձևը ներկայացվել է, այսինքն՝ սեղմված է արդյոք Մուտք կոճակը։ Եթե այո, ապա մենք շարժվում ենք, եթե ոչ, ապա մենք սխալ հաղորդագրություն կցուցադրենք օգտվողին, որը ցույց է տալիս, որ նա ուղղակիորեն մուտք է գործել այս էջ: */ if(isset($_POST["btn_submit_auth"]) && !empty($_POST["btn_submit_auth"]))( //(1) Տարածք հաջորդ կոդի համար )else( exit("

Սխալ.Դուք ուղղակիորեն մուտք եք գործել այս էջ, ուստի մշակման ենթակա տվյալներ չկան: Դուք կարող եք գնալ գլխավոր էջ:

"); }

//Ստուգեք ստացված captcha-ն if(isset($_POST["captcha"]))( //Կտրեք բացատները տողի սկզբից և վերջից $captcha = trim($_POST["captcha"]); if(! դատարկ ($captcha ))( //Համեմատե՛ք ստացված արժեքը նիստի արժեքի հետ։ if(($_SESSION["rand"] != $captcha) && ($_SESSION["rand"] != "")) ( // Եթե captcha-ն սխալ է, ապա մենք օգտատիրոջը վերադարձնում ենք թույլտվության էջ, և այնտեղ մենք սխալի հաղորդագրություն կցուցադրենք նրան, որ նա սխալ է մուտքագրել captcha: $error_message = "

Սխալ.Դուք սխալ captcha եք մուտքագրել

Սխալ. Captcha մուտքագրման դաշտը չպետք է դատարկ լինի:

"; // Պահպանեք սխալի հաղորդագրությունը նստաշրջանում: $_SESSION["error_messages"] = $error_message; // Օգտատիրոջը վերադարձրեք թույլտվության էջի վերնագիր ("HTTP/1.1 301 Moved Permanently"); header ("Տեղադրում. " .$address_site ."/form_auth.php"); //Դադարեցնել սցենարի ելքը(); ) //(2) Էլփոստի հասցեն մշակելու տեղ //(3) գաղտնաբառի մշակման տեղ //(4) Տեղ տվյալների բազայում հարցում գրելը )else ( //Եթե captcha-ն չի անցել, exit("

Սխալ.Չկա հաստատման կոդ, այսինքն՝ captcha կոդ։ Դուք կարող եք գնալ գլխավոր էջ:

"); }

Եթե օգտատերը ճիշտ է մուտքագրել հաստատման կոդը, ապա անցնում ենք առաջ, հակառակ դեպքում նրան վերադարձնում ենք թույլտվության էջ։

Փոստային հասցեի ստուգում

//Կտրել բացատները տողի սկզբից և վերջից $email = trim($_POST["email"]); if(isset($_POST["email"]))( if(!empty($email))($email = htmlspecialchars($email, ENT_QUOTES); //Ստուգեք ստացված էլ. հասցեի ձևաչափը՝ օգտագործելով $ սովորական արտահայտությունը reg_email = " /^**@(+(*+)*\.)++/i"; //Եթե ստացված էլ. հասցեի ձևաչափը չի համապատասխանում կանոնավոր արտահայտությանը if(!preg_match($reg_email, $email ))( // Պահել նիստի սխալի հաղորդագրությունում: $_SESSION["error_messages"] .= "

Դուք սխալ նամակ եք մուտքագրել

"; //Վերադարձրեք օգտատիրոջը թույլտվության էջի վերնագիր ("HTTP/1.1 301 Մշտապես տեղափոխված"); header("Գտնվելու վայրը՝ ".$address_site."/form_auth.php"); //Դադարեցրեք սկրիպտի ելքը(); ) )else ( // Պահպանեք սխալի հաղորդագրությունը նիստում։ $_SESSION["error_messages"] .= "

Փոստային հասցե (էլ. փոստ) մուտքագրելու դաշտը չպետք է դատարկ լինի:

Էլփոստի մուտքագրման դաշտը բացակայում է

"; //Վերադարձրեք օգտատիրոջը թույլտվության էջի վերնագիր ("HTTP/1.1 301 Մշտապես տեղափոխված"); header("Գտնվելու վայրը՝ ".$address_site."/form_auth.php"); //Դադարեցրեք սկրիպտի ելքը(); ) // (3) Գաղտնաբառերի մշակման տարածք

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

Գաղտնաբառի ստուգում

Հաջորդ դաշտը, որը պետք է մշակվի, գաղտնաբառի դաշտն է: Նշված վայր» //(3) գաղտնաբառի մշակման տեղ", մենք գրում ենք:

If(isset($_POST["գաղտնաբառ"]))( //Կտրեք բացատները տողի սկզբից և վերջից $password = trim($_POST["password"]); if(!empty($password))( $password = htmlspecialchars ($password, ENT_QUOTES); //Գաղտնագրեք գաղտնաբառը $password = md5($password."top_secret"); )else( //Պահպանեք սխալի հաղորդագրությունը նիստում: $_SESSION["error_messages"] : = "

Մուտքագրեք ձեր գաղտնաբառը

Գաղտնաբառի դաշտը բացակայում է

Այստեղ մենք օգտագործում ենք md5() ֆունկցիան՝ ստացված գաղտնաբառը ծածկագրելու համար, քանի որ մեր գաղտնաբառերը տվյալների բազայում գաղտնագրված են։ Լրացուցիչ գաղտնի բառ գաղտնագրման մեջ, մեր դեպքում « հույժ գաղտնի« պետք է լինի այն, որն օգտագործվել է օգտատիրոջ գրանցման ժամանակ:

Այժմ դուք պետք է հարցում կատարեք տվյալների բազայում՝ ընտրելու օգտվող, որի էլ.փոստի հասցեն հավասար է ստացված էլ. հասցեին, իսկ գաղտնաբառը՝ ստացված գաղտնաբառին:

//Հարցում տվյալների բազայում՝ օգտվողի ընտրության հիման վրա: $result_query_select = $mysqli-> հարցում ("SELECT * FROM `users` WHERE email = "".$email."" AND password = "".$password."""); if(!$result_query_select)( // Պահպանեք սխալի հաղորդագրությունը նիստում: $_SESSION["error_messages"] .= "

Հարցման սխալ՝ տվյալների բազայից օգտվող ընտրելիս

"; //Վերադարձրեք օգտատիրոջը գրանցման էջի վերնագիր ("HTTP/1.1 301 Moved Permanently"); header ("Տեղադրանքը՝ ".$address_site."/form_auth.php"); //Stop the script exit(); )else( //Ստուգեք, արդյոք տվյալների բազայում նման տվյալներ ունեցող օգտվող չկա, ապա ցուցադրեք սխալի հաղորդագրություն if($result_query_select->num_rows == 1)( // Եթե մուտքագրված տվյալները համապատասխանում են տվյալների բազայի տվյալներին, ապա պահպանեք սեսիաների զանգվածի մուտքն ու գաղտնաբառը: $_SESSION["email"] = $email; $_SESSION["password"] = $password; //Վերադարձրեք օգտվողին հիմնական էջի վերնագիր ("HTTP/1.1 301 Moved Permanently" ); header ("Գտնվելու վայրը. ".$address_site ."/index.php"); )else( // Պահպանեք սխալի հաղորդագրությունը նիստում: $_SESSION["error_messages"] .= "

Սխալ մուտք և/կամ գաղտնաբառը

Դուրս գալ կայքից

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

Կայքի վերնագրում (ֆայլ header.php), օգտագործելով նիստը, մենք ստուգում ենք, թե արդյոք օգտվողն արդեն լիազորված է: Եթե ոչ, ապա մենք ցուցադրում ենք գրանցման և թույլտվության հղումները, հակառակ դեպքում (եթե նա լիազորված է), ապա գրանցման և թույլտվության հղումների փոխարեն ցուցադրում ենք հղումը Ելք.

Փոփոխված կոդի կտոր ֆայլից header.php:

Գրանցում

Ելք

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

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

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

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

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

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

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

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