Sveiki! Tagad mēs mēģināsim ieviest vienkāršāko reģistrāciju vietnē ar izmantojot PHP+ MySQL. Lai to izdarītu, datorā ir jāinstalē Apache. Mūsu skripta darbības princips ir parādīts zemāk.
1. Sāksim ar lietotāju tabulas izveidi datu bāzē. Tajā būs lietotāja dati (pieteikšanās vārds un parole). Dodieties uz phpmyadmin (ja veidojat datu bāzi savā datorā http://localhost/phpmyadmin/). Mēs izveidojam lietotāju tabulu, tajā būs 3 lauki.
Es to veidoju mysql datu bāzē, jūs varat izveidot citā datu bāzē. Pēc tam iestatiet vērtības, kā parādīts attēlā:
2. Nepieciešams savienojums ar šo tabulu. Izveidosim failu bd.php. Tās saturs:
Manā gadījumā tas izskatās šādi:
Saglabāt bd.php .
Lieliski! Mums datu bāzē ir tabula un savienojums ar to. Tagad varat sākt veidot lapu, kurā lietotāji atstās savus datus.
3. Izveidojiet reg.php failu ar saturu (visi komentāri):
Reģistrācija
Reģistrācija
Jūsu pieteikšanās:
Tava parole:
4. Izveidojiet failu, kas ievadīs datus datu bāzē un saglabās lietotāju. save_user.php (iekšā komentāri):
5. Tagad mūsu lietotāji var reģistrēties! Tālāk jums ir jāizveido “durvis”, lai jau reģistrētie lietotāji varētu iekļūt vietnē. index.php (iekšpusē komentāri):
Mājas lapa
Mājas lapa
Jūsu pieteikšanās:
Tava parole:
Reģistrēties
Labi, tagad viss ir beidzies! Nodarbība var būt garlaicīga, bet ļoti noderīga. Šeit tiek parādīta tikai reģistrācijas ideja, pēc tam varat to uzlabot: pievienot drošību, dizainu, datu laukus, ielādēt iemiesojumus, izrakstīties no sava konta (lai to izdarītu, vienkārši iznīciniet sesijas mainīgos ar atiestatīšanas funkciju) un tā tālāk. Veiksmi!
Es visu pārbaudīju, darbojas pareizi!
Šodien mēs apskatīsim populārās CMS Joomla kritiskās 1 dienas ievainojamības izmantošanu, kas oktobra beigās eksplodēja internetā. Mēs runāsim par ievainojamībām ar numuriem CVE-2016-8869, CVE-2016-8870 un CVE-2016-9081. Visi trīs nāk no viena koda daļas, kas ir pieci ilgus gadus nīkuļoja ietvara dziļumos, gaidīja spārnos, lai pēc tam atbrīvotos un nestu sev līdzi haosu, uzlauztas vietnes un nevainīgu šīs Joomla lietotāju asaras. Tikai drosmīgākie un drosmīgākie izstrādātāji, kuriem acis ir sarkanas no monitoru gaismas un kuru klaviatūras ir nosētas ar maizes drupačām, spēja izaicināt trakojošos ļaunos garus un nolikt galvu uz labojumu altāra.
BRĪDINĀJUMS Visa informācija ir sniegta tikai informatīviem nolūkiem. Ne redaktori, ne autors nav atbildīgi par iespējamo kaitējumu, ko nodara šī raksta materiāli. Kur tas viss sākās2016. gada 6. oktobrī Demis Palma izveidoja tēmu Stack Exchange, kurā jautāja: kāpēc patiesībā Joomla versijā 3.6 ir divas metodes lietotāju reģistrēšanai ar vienādu vārdu register()? Pirmais atrodas UsersControllerRegistration kontrollerī, bet otrais ir UsersControllerUser kontrollerī. Damis vēlējās uzzināt, vai kaut kur tika izmantota metode UsersControllerUser::register(), vai tas ir tikai evolūcijas anahronisms, kas palicis pāri no vecās loģikas. Viņa bažas bija par to, ka pat tad, ja šo metodi neizmanto neviens skats, to var izsaukt ar izstrādātu vaicājumu. Uz ko es saņēmu atbildi no izstrādātāja ar segvārdu itoctopus, kurš apstiprināja: problēma patiešām pastāv. Un nosūtīja ziņojumu Joomla izstrādātājiem.
Tad notikumi attīstījās visstraujāk. 18. oktobrī Joomla izstrādātāji pieņēma ziņojumu no Damis, kurš līdz tam laikam bija izstrādājis PoC, kas ļautu reģistrēties. Viņš savā tīmekļa vietnē publicēja piezīmi, kur vispārīgs izklāsts runāja par atrasto problēmu un savām domām par šo jautājumu. Iznāks tajā pašā dienā jauna versija Joomla 3.6.3, kurā joprojām ir ievainojams kods.
Pēc tam Davide Tampellini griež kļūdu, līdz tā netiek reģistrēta vienkāršs lietotājs un administrators. Un 21. oktobrī Joomla drošības komandai nonāk jauna lieta. Tas jau runā par privilēģiju palielināšanu. Tajā pašā dienā Joomla vietnē parādās paziņojums, ka otrdien, 25. oktobrī, tiks izlaista nākamā versija ar sērijas numuru 3.6.3, kas izlabo kritisko ievainojamību sistēmas kodolā.
25. oktobris Joomla Security Strike Team atrod jaunāko problēmu, ko radījis Damis atklātais koda fragments. Pēc tam 21. oktobrī datēta apņemšanās ar neuzkrītošo nosaukumu Prepare 3.6.4 Stable Release tiek ievietota oficiālās Joomla repozitorija galvenajā atzarā, kas novērš nelaimīgo kļūdu.
Pēc šī iznākšanas izstrādātāju kopienai pievienojas daudzas ieinteresētas personas - viņi sāk popularizēt ievainojamību un sagatavot izlietojumus.
27. oktobrī pētnieks Harijs Robertss augšupielādē Xiphos Research repozitorijā gatavu izlietojumu, kas var augšupielādēt PHP failu serverī ar ievainojamu CMS.
Sīkāka informācijaNu, fons ir beidzies, pāriesim pie interesantākās daļas - ievainojamības analīzes. Joomla 3.6.3 instalēju kā testa versiju, tāpēc šai versijai būs aktuāli visi rindiņu numuri. Un visi ceļi uz failiem, kurus redzēsit tālāk, tiks norādīti attiecībā pret instalētās CMS sakni.
Pateicoties Damis Palma atklājumam, mēs zinām, ka ir divas metodes, kas veic lietotāja reģistrāciju sistēmā. Pirmo izmanto SPS, un tas atrodas failā /components/com_users/controllers/registration.php:108. Otrais (tā, kas mums būs jāizsauc) atrodas mapē /components/com_users/controllers/user.php:293. Apskatīsim to tuvāk.
286: /** 287: * Lietotāja reģistrēšanas metode. 288: * 289: * @return Būla 290: * 291: * @no 1.6 292: */ 293: publisks funkciju reģistrs() 294: ( 295: JSession::checkToken("post") vai jexit(JText::_ ("JINVALID_TOKEN")) ... 300: // Iegūt veidlapas datus 301: $data = $this->input->post->get("user", array(), "masīvs" . 315: $return = $modelis->apstiprināt($forma, $data) 318: if ($return === false). Pabeidziet reģistrāciju 346: $return = $model->register($data);
Šeit es atstāju tikai interesantas rindas. Ievainojamās metodes pilno versiju var apskatīt Joomla repozitorijā.
Izdomāsim, kas notiek parastas lietotāja reģistrācijas laikā: kādi dati tiek nosūtīti un kā tie tiek apstrādāti. Ja iestatījumos ir iespējota lietotāja reģistrācija, veidlapu var atrast vietnē http://joomla.local/index.php/component/users/?view=registration.
Leģitīms lietotāja reģistrācijas pieprasījums izskatās kā šāds ekrānuzņēmums.
Komponents com_users ir atbildīgs par darbu ar lietotājiem. Pievērsiet uzmanību uzdevuma parametram pieprasījumā. Tam ir formāts $controller.$method . Apskatīsim failu struktūru.
Skriptu nosaukumi mapē kontrolleri atbilst izsaukto kontrolleru nosaukumiem. Tā kā mūsu pieprasījumam tagad ir $controller = "registration" , tiks izsaukts fails register.php un tā register() metode.
Uzmanību, jautājums: kā pārcelt reģistrācijas apstrādi uz neaizsargātu vietu kodā? Jūs droši vien jau to uzminējāt. Ievainojamo un reālo metožu nosaukumi ir vienādi (reģistrs), tāpēc mums vienkārši jāmaina izsauktā kontroliera nosaukums. Kur atrodas mūsu neaizsargātais kontrolieris? Tieši tā, failā user.php. Izrādās $controller = "lietotājs" . Saliekot visu kopā, iegūstam uzdevumu = user.register . Tagad reģistrācijas pieprasījums tiek apstrādāts ar mums nepieciešamo metodi.
Otra lieta, kas mums jādara, ir nosūtīt datus pareizajā formātā. Šeit viss ir vienkārši. Legitimate register() sagaida no mums masīvu ar nosaukumu jform , kurā mēs nododam reģistrācijas datus - vārdu, pieteikumvārdu, paroli, e-pastu (skatiet ekrānuzņēmumu ar pieprasījumu).
- /components/com_users/controllers/registration.php: 124: // Iegūstiet lietotāja datus. 125: $requestData = $this->input->post->get("jform", array(), "masīvs");
Mūsu klients iegūst šos datus no masīva, ko sauc par lietotāju.
- /components/com_users/controllers/user.php: 301: // Iegūstiet veidlapas datus. 302: $dati = $this->input->post->get("lietotājs", masīvs(), "masīvs");
Tāpēc mēs mainām visu pieprasījuma parametru nosaukumus no jfrom uz lietotājs .
Mūsu trešais solis ir atrast derīgu CSRF marķieri, jo bez tā reģistrācijas nebūs.
- /components/com_users/controllers/user.php: 296: JSession::checkToken("post") vai jexit(JText::_("JINVALID_TOKEN"));
Tas izskatās kā MD5 jaucējfails, un to var iegūt, piemēram, no vietnes /index.php/component/users/?view=login autorizācijas veidlapas.
Tagad jūs varat izveidot lietotājus, izmantojot vēlamo metodi. Ja viss darbojās, apsveicam — jūs tikko izmantojāt ievainojamību CVE-2016-8870 “trūkst atļauju pārbaude jaunu lietotāju reģistrēšanai”.
Lūk, kā tas izskatās UsersControllerRegistration kontrollera “darba” reģistra() metodē:
- /components/com_users/controllers/registration.php: 113: // Ja reģistrācija ir atspējota — novirzīt uz pieteikšanās lapu. 114: if (JComponentHelper::getParams("com_users")->get("allowUserRegistration") == 0) 115: ( 116: $this->setRedirect(JRoute::_("index.php?option=com_users&view= pieteikšanās", false)); 117: 118: atgriezties false; 119: )
Un tātad neaizsargātos:
- /components/com_users/controllers/user.php:
Jā, nekādā gadījumā.
Lai saprastu otru, daudz nopietnāku problēmu, nosūtīsim mūsu izveidoto pieprasījumu un paskatīsimies, kā tas tiek izpildīts dažādās koda daļās. Šeit ir daļa, kas ir atbildīga par lietotāja iesniegto datu validāciju darbinieka metodē:
Turpinājums pieejams tikai dalībniekiem 1. variants. Pievienojieties kopienai “vietne”, lai lasītu visus vietnes materiālusDalība kopienā noteiktajā laika posmā nodrošinās piekļuvi VISIEM Hacker materiāliem, palielinās jūsu personīgo kumulatīvo atlaidi un ļaus jums uzkrāt profesionālu Xakep Score vērtējumu!
Laravel pieprasa, lai Composer pārvaldītu projekta atkarības. Tāpēc pirms Laravel instalēšanas pārliecinieties, vai jūsu sistēmā ir instalēts Composer. Ja par Composer dzirdat pirmo reizi, tas ir php atkarības pārvaldības rīks, kas ir līdzīgs node's npm.
Lai datorā instalētu programmu Composer, pārbaudiet šo ziņu:
Laravel instalēšana operētājsistēmā Windows:Veiciet tālāk norādītās darbības, lai instalētu laravel operētājsistēmā Windows. Neatkarīgi no tā, vai jums ir xampp/wamp steks, tas darbojas abiem. Uz WAMP noteikti instalējiet laravel mapē "www" un XAMPP, protams, "htdocs".
SOLIS-1) Atveriet XAMPP mapi "htdocs", turiet taustiņu SHIFT un ar peles labo pogu noklikšķiniet uz mapes un izvēlieties "atvērt komandu logu šeit". Varat arī atvērt komandu logu un mainīt direktoriju uz "xampp/htdocs".
STEP-2) Ievadiet šādu komandu.
Komponists izveidot-projekts laravel/laravel my_laravel_site --prefer-dist
Šeit "my_laravel_site" ir mapes nosaukums, kurā tiks instalēti laravel faili. Mainiet šo pēc savas patikas.
SOLIS 3) Tagad ir laiks būt pacietīgam, jo laravel instalēšana prasīs kādu laiku.
SOLIS -4) Pēc instalēšanas komandu uzvednē mainiet direktoriju uz "my_laravel_site" (cd "my_laravel_site") un ievadiet tālāk norādīto komandu.
Php amatnieku apkalpo
SOLIS 5) Tiks parādīts ziņojums, piemēram, "Laravel izstrādes serveris ir palaists:" kopā ar URL.
6. SOLIS. Nokopējiet un ielīmējiet URL pārlūkprogrammā. Ja viss noritēs pareizi, jūs redzēsit laravel sveiciena ekrānu.
SOLIS-7) Gatavs! Jūs esat veiksmīgi instalējis laravel Windows mašīnā un gatavs darbam.
Lietojumprogrammas atslēgas iestatīšana:Laravel pēc instalēšanas ir nepieciešama neliela konfigurācija. Tam ir jāiestata lietojumprogrammas atslēga. Šī ir nejauša 32 rakstzīmju virkne, ko izmanto sesijas un citu sensitīvu datu šifrēšanai. Parasti tas tiek iestatīts automātiski, kad instalējat laravel, izmantojot komponistu vai laravel instalētāju.
Ja tas nav iestatīts, jums tas ir jādara manuāli. Vispirms noteikti pārdēvējiet failu ".env.example" par ".env" savā lietojumprogrammas saknē. Pēc tam atveriet komandu uzvedni un mainiet uz laravel projekta mapi. Tagad palaidiet tālāk norādīto komandu, lai ģenerētu atslēgu.
Php amatnieka atslēga: ģenerēt
Kopējiet šo ģenerēto atslēgu uz mainīgo APP_KEY failā ".env". Saglabājiet un esat pabeidzis.
Konkrētas Laravel versijas instalēšana:Iepriekš minētā metode liks komponistam lejupielādēt un instalēt jaunāko laravel versiju. Ja vēlaties savā datorā instalēt vecākas laravel versijas, noteikti iekļaujiet attiecīgās versijas numuru komandā create-project.
Komponists izveidot-projekts laravel/laravel=5.4 jūsu-projekta-nosaukums --prefer-dist Lasīt arī:
Tāpat jūs varat viegli instalējiet laravel, izmantojot komponistu uz Windows. Ceru, ka šī apmācība jums noderēs. Lūdzu, kopīgojiet to savā sociālajā lokā, ja jums tas patīk.
Reģistrācijas sistēmas izveides process ir diezgan liels darbs. Jums ir jāuzraksta kods, kas vēlreiz pārbaudītu e-pasta adrešu derīgumu, nosūtītu apstiprinājuma e-pastus, piedāvātu iespēju atgūt paroli, saglabātu paroles droša vieta, pārbaudītas ievades veidlapas un daudz kas cits. Pat tad, kad jūs to visu darīsit, lietotāji nelabprāt reģistrēsies, jo pat minimālai reģistrācijai ir nepieciešama viņu darbība.
Šodienas apmācībā mēs izstrādāsim vienkāršu reģistrācijas sistēmu, kurai nebūs vajadzīgas nekādas paroles! Rezultātā tiks izveidota sistēma, kuru var viegli pārveidot vai integrēt esošajā PHP vietnē. Ja jūs interesē, turpiniet lasīt.
PHP
Tagad mēs esam gatavi sākt ar PHP kodu. Reģistrācijas sistēmas galveno funkcionalitāti nodrošina Lietotāju klase, kuru varat redzēt zemāk. Klase izmanto (), kas ir minimālisma datu bāzes bibliotēka. Lietotāju klase ir atbildīga par piekļuvi datu bāzēm, pieteikšanās marķieru ģenerēšanu un to apstiprināšanu. Tas piedāvā vienkāršu interfeisu, ko var viegli iekļaut jūsu PHP vietņu reģistrācijas sistēmā.
User.class.php
// Privāts ORM gadījums
privāts $orm;
/**
* Atrodiet lietotāju pēc marķiera virknes. Tiek ņemti vērā tikai derīgi žetoni
* apsvēršana. Tokens ir derīgs 10 minūtes pēc tā ģenerēšanas.
* @param string $token Marķieris, kas jāmeklē
* @atgriezties lietotājs
*/
Publiskā statiskā funkcija findByToken($token)(
// atrodiet to datu bāzē un pārliecinieties, vai laikspiedols ir pareizs
->kur("token", $token)
->kur_raw("token_validity > NOW()")
->atrast_vienu();
Ja(!$rezultāts)(
return false;
}
Atgriezt jaunu lietotāju($rezultāts);
}
/**
* Piesakieties vai reģistrējiet lietotāju.
* @atgriezties lietotājs
*/
Publiskā statiskā funkcija loginOrRegister($email)(
// Ja šāds lietotājs jau pastāv, atgrieziet to
Ja(lietotājs::eksistē($email))(
atgriezt jaunu lietotāju($email);
}
// Pretējā gadījumā izveidojiet to un atgrieziet to
Atgriezties lietotājs::create($email);
}
/**
* Izveidojiet jaunu lietotāju un saglabājiet to datu bāzē
* @param string $email Lietotāja e-pasta adrese
* @atgriezties lietotājs
*/
Privāta statiskā funkcija izveidot($email)(
// Ierakstiet jaunu lietotāju datu bāzē un atgrieziet to
$rezultāts = ORM::for_table("reg_users")->izveidot();
$rezultāts->e-pasts = $e-pasts;
$rezultāts->saglabāt();
Atgriezt jaunu lietotāju($rezultāts);
}
/**
* Pārbaudiet, vai šāds lietotājs pastāv datu bāzē, un atgrieziet Būla vērtību.
* @param string $email Lietotāja e-pasta adrese
* @return Būla vērtība
*/
Pastāv publiska statiskā funkcija($email)(
// Vai lietotājs pastāv datu bāzē?
$rezultāts = ORM::for_table("reg_users")
->kur("e-pasts", $e-pasts)
->count();
Atgriezt $rezultāts == 1;
}
/**
* Izveidojiet jaunu lietotāja objektu
* @param $param ORM gadījums, ID, e-pasts vai null
* @atgriezties lietotājs
*/
Publiskā funkcija __construct($param = null)(
If($param instanceof ORM)(
// Tika nodota ORM instance
$this->orm = $param;
}
cits if(ir_string($param))(
// E-pasts tika nosūtīts
$this->
->kur("e-pasts", $param)
->atrast_vienu();
}
cits(
If(ir_ciparu($param))(
// Lietotāja ID tika nodots kā parametrs
$id = $param;
}
else if(isset($_SESSION["loginid"]))(
// Netika nodots lietotāja ID, skatiet sesiju
$id = $_SESSION["loginid"];
}
$this->orm = ORM::for_table("reg_users")
->kur("id", $id)
->atrast_vienu();
}
/**
* Ģenerē jaunu SHA1 pieteikšanās pilnvaru, ieraksta to datu bāzē un atgriež.
* @atgriešanas virkne
*/
Publiskā funkcija generateToken())(
// ģenerē marķieri reģistrētajam lietotājam. Saglabājiet to datu bāzē.
$token = sha1($this->email.time().rand(0, 1000000));
// Saglabājiet marķieri datu bāzē,
// un atzīmējiet to kā derīgu tikai nākamās 10 minūtes
$this->orm->set("token", $token);
$this->orm->set_expr("token_validity", "ADDTIME(NOW(),"0:10")");
$this->orm->save();
Atgriezt $ marķieri;
}
/**
*Pieteikties šim lietotājam
* @atgriezties spēkā neesošs
*/
Publiskās funkcijas pieteikšanās()
// Atzīmēt lietotāju kā pieteicies
$_SESSION["loginid"] = $this->orm->id;
// Atjauniniet last_login db lauku
$this->orm->set_expr("pēdējais_pieteikšanās", "TAGAD()");
$this->orm->save();
}
/**
* Iznīciniet sesiju un atsakieties no lietotāja.
* @atgriezties spēkā neesošs
*/
Publiskās funkcijas atteikšanās()
$_SESIJA = masīvs();
unset($_SESSION);
}
/**
* Pārbaudiet, vai lietotājs ir pieteicies.
* @return Būla vērtība
*/
Publiskā funkcija loggedIn())(
return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id;
}
/**
* Pārbaudiet, vai lietotājs ir administrators
* @return Būla vērtība
*/
Publiskā funkcija irAdmin())(
return $this->rank() == "administrators";
}
/**
* Atrodiet lietotāja veidu. Tas var būt gan administrators, gan parasts.
* @atgriešanas virkne
*/
Publiskās funkcijas rangs())(
if($this->orm->rank == 1)(
atgriezt "administrators";
}
Atgriezt "parasti";
}
/**
* Burvju metode, lai piekļūtu privātajiem elementiem
* $orm instance kā lietotāja objekta rekvizīti
* @param string $key Piekļuve rekvizīta nosaukums
* @return sajaukts
*/
Publiskā funkcija __get($key)(
if(isset($this->orm->$key))(
atgriezt $this->orm->$key;
}
Return null;
}
}
Tokeni tiek ģenerēti, izmantojot algoritmu, un tiek saglabāti datu bāzē. Mēs izmantojam MySQL, lai kolonnā token_validity iestatītu 10 minūtes. Validējot marķieri, mēs sakām dzinējam, ka mums ir nepieciešams marķieris, laukam token_validity derīguma termiņš vēl nav beidzies. Tādā veidā mēs ierobežojam laiku, kurā marķieris būs derīgs.
Ievērojiet, ka mēs izmantojam burvju metodi __get() dokumenta beigās, lai piekļūtu lietotāja objekta rekvizītiem. Tas ļauj mums piekļūt datiem, kas tiek glabāti datu bāzē kā rekvizīti: $user->email, $user->token. Piemēram, apskatīsim, kā mēs varam izmantot šo klasi šajā koda fragmentā:
Vēl viens fails, kurā tiek saglabāta nepieciešamā funkcionalitāte, ir functions.php. Tur mums ir dažas palīgfunkcijas, kas ļauj mums saglabāt pārējo kodu tīrāku.
Functions.php
Funkcija send_email($from, $kam, $subject, $message)(
// Palīdzības funkcija e-pasta sūtīšanai
$headers = "MIME versija: 1.0" . "\r\n";
$headers .= "Satura veids: teksts/vienkāršs; charset=utf-8" . "\r\n";
$headers .= "No: ".$from . "\r\n";
Atgriezt pastu ($kam, $tēma, $ziņa, $galvenes);
}
funkcija get_page_url())(
// Uzziniet PHP faila URL
$url = "http".(tukšs($_SERVER["HTTPS"])?"":"s")."://".$_SERVER["SERVERA_NAME"];
If(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")(
$url.= $_SERVER["REQUEST_URI"];
}
cits(
$url.= $_SERVER["PATH_INFO"];
}
Atgriezt $url;
}
funkcija rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)(
// Pieteikšanās mēģinājumu skaits pēdējā stundā, izmantojot šo IP adresi
$count_hour = ORM::for_table("reg_login_attempt")
->
->kur_raw("ts > SUBTIME(NOW(),"1:00")")
->count();
// Pieteikšanās mēģinājumu skaits pēdējās 10 minūtēs, izmantojot šo IP adresi
$count_10_min = ORM::for_table("reg_login_attempt")
->kur("ip", sprintf("%u", ip2long($ip)))
->kur_raw("ts > SUBTIME(NOW(),"0:10")")
->count();
If($count_hour > $limit_hour || $count_10_min > $limit_10_min)(
throw new Exception("Pārāk daudz pieteikšanās mēģinājumu!");
}
}
funkcija rate_limit_tick($ip, $email)(
// Izveidojiet jaunu ierakstu pieteikšanās mēģinājumu tabulā
$login_attempt = ORM::for_table("reg_login_attempt")->create();
$login_attempt->email = $e-pasts;
$login_attempt->ip = sprintf("%u", ip2long($ip));
$login_attempt->save();
}
funkcija novirzīt($url)(
header("Atrašanās vieta: $url");
Izeja;
}
Funkcijas rate_limit un rate_limit_tick ļauj ierobežot autorizācijas mēģinājumu skaitu noteiktā laika periodā. Autorizācijas mēģinājumi tiek reģistrēti reg_login_attempt datu bāzē. Šīs funkcijas tiek aktivizētas, kad tiek pārbaudīta pieteikšanās forma, kā redzams nākamajā koda fragmentā.
Tālāk norādītais kods tika ņemts no index.php un ir atbildīgs par pieteikšanās veidlapas apstiprināšanu. Tas atgriež JSON atbildi, ko virza jQuery kods, ko redzējām failā aktīvi/js/script.js.
indekss.php
If(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))(
// Izvadiet JSON galveni
Header ("Satura veids: lietojumprogramma/json");
// Vai e-pasta adrese ir derīga?
If(!isset($_POST["e-pasts"]) || !filter_var($_POST["e-pasts"], FILTER_VALIDATE_EMAIL))(
throw new Exception("Lūdzu, ievadiet derīgu e-pastu.");
}
// Tas radīs izņēmumu, ja persona atrodas augstāk
// atļautie pieteikšanās mēģinājumu ierobežojumi (vairāk skatiet functions.php):
likmes_limits($_SERVER["ATTĀLĀ_ADDR"]);
// Ierakstiet šo pieteikšanās mēģinājumu
rate_limit_tick($_SERVER["REMOTE_ADDR"], $_POST["e-pasts"]);
// Nosūtiet ziņojumu lietotājam
$ziņojums = "";
$e-pasts = $_POST["e-pasts"];
$subject = "Jūsu pieteikšanās saite";
Ja(!Lietotājs::eksistē($email))(
$subject = "Paldies, ka reģistrējāties!";
$message = "Paldies, ka reģistrējāties mūsu vietnē!\n\n";
}
// Mēģinājums pieteikties vai reģistrēt personu
$lietotājs = User::loginOrRegister($_POST["e-pasts"]);
$message.= "Jūs varat pieteikties no šī URL:\n";
$message.= get_page_url()."?tkn=".$user->generateToken()."\n\n";
$message.= "Saite automātiski beigsies pēc 10 minūtēm.";
$rezultāts = send_email($fromEmail, $_POST["e-pasts"], $tēma, $ziņa);
Ja(!$rezultāts)(
throw new Exception("Sūtot jūsu e-pasta ziņojumu, radās kļūda. Lūdzu, mēģiniet vēlreiz.");
}
Die(json_encode(masīvs(
"message" => "Paldies! Mēs esam nosūtījuši saiti uz jūsu iesūtni. Pārbaudiet arī savu surogātpasta mapi."
)));
}
}
noķert(izņēmums $e)(
Die(json_encode(masīvs(
"error"=>1,
"message" => $e->getMessage()
)));
}
Pēc veiksmīgas autorizācijas vai reģistrācijas iepriekš minētais kods nosūta personai e-pasta ziņojumu ar saiti autorizācijai. Tokens ir pieejams kā $_GET mainīgais "tkn" ģenerētā URL dēļ.
indekss.php
If(isset($_GET["tkn"]))(
// Vai šī ir derīga pieteikšanās pilnvara?
$lietotājs = Lietotājs::findByToken($_GET["tkn"]);
// Jā! Piesakieties lietotājam un novirziet uz aizsargāto lapu.
$lietotājs->pieteikšanās();
redirect("protected.php");
}
// Nederīgs marķieris. Pārvirzīt atpakaļ uz pieteikšanās veidlapu.
redirect("indekss.php");
}
Palaižot $user->login(), tiks izveidoti nepieciešamie sesijas mainīgie, ļaujot lietotājam turpmākajos pieteikšanās reizēs palikt reģistrētam.
Atteikšanās no sistēmas tiek īstenota aptuveni tādā pašā veidā:
Indekss.php
If(isset($_GET["atteikties"]))(
$lietotājs = jauns lietotājs();
If($user->loggedIn())(
$lietotājs->atteikties();
}
Redirect("index.php");
}
Koda beigās mēs atkal novirzām lietotāju uz index.php, tādējādi URL parametrs ?logout=1 tiek izslēgts.
Arī mūsu index.php failam būs nepieciešama aizsardzība — mēs nevēlamies, lai lietotāji, kas jau ir pieteikušies, redzētu veidlapu. Lai to izdarītu, mēs izmantojam $user->loggedIn() metodi:
Indekss.php
$lietotājs = jauns lietotājs();
if($user->loggedIn())(
redirect("protected.php");
}
Visbeidzot, apskatīsim, kā jūs varat aizsargāt savas vietnes lapu un padarīt to pieejamu tikai pēc autorizācijas:
Protected.php
// Lai aizsargātu jebkuru php lapu savā vietnē, iekļaujiet main.php
// un izveidojiet jaunu lietotāja objektu. Tas ir tik vienkārši!
request_once "includes/main.php";
$lietotājs = jauns lietotājs();
if(!$user->loggedIn())(
redirect("indekss.php");
}
Pēc šīs pārbaudes varat būt pārliecināts, ka lietotājs ir veiksmīgi pieteicies. Jums būs arī piekļuve datiem, kas tiek glabāti datu bāzē kā $user objekta rekvizīti. Lai parādītu lietotāja e-pastu un viņa rangu, izmantojiet šādu kodu:
Echo "Jūsu e-pasts: ".$user->email;
echo "Jūsu rangs: ".$user->rank();
Šeit rank() ir metode, jo datu bāzes rangu kolonnā parasti ir skaitļi (0 parastajiem lietotājiem un 1 administratoriem), un mums tie visi ir jāpārvērš rangu nosaukumos, kas tiek ieviesti, izmantojot šī metode. Lai standarta lietotāju pārvērstu par administratoru, vienkārši rediģējiet lietotāja ierakstu phpmyadmin (vai jebkurā citā datu bāzes programmā). Kā administratoram lietotājam nebūs nekādu tiesību speciālas iespējas. Jums pašam ir tiesības izvēlēties, kādas tiesības piešķirt administratoriem.
Gatavs!
Ar to mūsu vienkāršā reģistrācijas sistēma ir gatava! Varat to izmantot esošā PHP vietnē vai modernizēt, lai tā atbilstu savām prasībām.
Reg.ru: domēni un mitināšana
Lielākais reģistrators un mitināšanas pakalpojumu sniedzējs Krievijā.
Tiek izmantoti vairāk nekā 2 miljoni domēna vārdu.
Veicināšana, domēna pasts, biznesa risinājumi.
Vairāk nekā 700 tūkstoši klientu visā pasaulē jau ir izdarījuši savu izvēli.
*Novietojiet peli virs, lai apturētu ritināšanu.
Atpakaļ uz priekšu
Vienkāršas lietotāju reģistrācijas sistēmas izveide PHP un MySQLReģistrācijas sistēmas izveide ir liels darbs. Jums ir jāraksta kods, kas apstiprina e-pasta adreses, nosūta e-pastu, kas apstiprina reģistrāciju, kā arī apstiprina citus veidlapas laukus un daudz ko citu.
Un pat pēc tam, kad to visu uzrakstīsit, lietotāji nelabprāt reģistrēsies, jo... tas prasa zināmas pūles no viņu puses.
Šajā pamācībā mēs izveidosim ļoti vienkāršu reģistrācijas sistēmu, kas vispār neprasa un neuzglabā paroles! Rezultātu būs viegli modificēt un pievienot esošai PHP vietnei. Vai vēlaties uzzināt, kā tas darbojas? Lasiet tālāk.
Lūk, kā darbosies mūsu īpaši vienkāršā sistēma:
Mēs apvienosim autorizācijas veidlapu un reģistrāciju. Šajā veidlapā būs lauks jūsu e-pasta adreses ievadīšanai un reģistrācijas poga;
- Aizpildot lauku ar e-pasta adresi, noklikšķinot uz reģistrācijas pogas, tiks izveidots ieraksts par jaunu lietotāju, bet tikai tad, ja ievadītā e-pasta adrese datu bāzē netika atrasta.
Pēc tam tiek izveidota nejauša unikāla rakstzīmju kopa (token), kas tiek nosūtīta uz lietotāja norādīto e-pastu saites veidā, kas būs aktuāla 10 minūtes;
- Saite novirza lietotāju uz mūsu vietni. Sistēma nosaka marķiera esamību un autorizē lietotāju;
Šīs pieejas priekšrocības:
Nav nepieciešams saglabāt paroles vai pārbaudīt laukus;
- Nav nepieciešams atgūt savu paroli, drošības jautājumus utt.;
- No brīža, kad lietotājs reģistrējas/piesakās, jūs vienmēr varat būt drošs, ka šis lietotājs atradīsies jūsu piekļuves zonā (ka e-pasta adrese ir patiesa);
- Neticami vienkāršs reģistrācijas process;
Trūkumi:
Lietotāja konta drošība. Ja kādam ir piekļuve lietotāja pastam, viņš var pieteikties.
- E-pasts nav drošs, un to var pārtvert. Paturiet prātā, ka šis jautājums ir aktuāls arī gadījumā, ja parole ir aizmirsta un ir jāatjauno, vai jebkurā autorizācijas sistēmā, kas neizmanto HTTPS datu pārsūtīšanai (pieteikšanās/parole);
- Pareizi konfigurējot pasta serveri, pastāv iespēja, ka ziņojumi ar autorizācijas saitēm nonāks surogātpastu;
Salīdzinot mūsu sistēmas priekšrocības un trūkumus, varam teikt, ka sistēmai ir augsta lietojamība (maksimālas ērtības gala lietotājam) un tajā pašā laikā tai ir zems drošības rādītājs.
Tāpēc ieteicams to izmantot, lai reģistrētos forumos un pakalpojumos, kas nedarbojas ar svarīgu informāciju.
Kā lietot šo sistēmu
Gadījumā, ja jums vienkārši ir jāizmanto sistēma, lai autorizētu lietotājus savā vietnē, un jūs nevēlaties sadalīt šo mācību gabalos, rīkojieties šādi:
Jālejupielādē nodarbībai pievienotie avoti
- Atrodiet failu tables.sql arhīvā, importējiet to savā datu bāzē, izmantojot phpMyAdmin importēšanas opciju. Alternatīvs veids: atveriet šo failu, izmantojot teksta redaktors, nokopējiet SQL vaicājumu un izpildiet to;
- Atveriet include/main.php un aizpildiet iestatījumus savienojumam ar savu datu bāzi (norādiet lietotāju un paroli savienojumam ar datu bāzi, kā arī datu bāzes resursdatoru un nosaukumu). Tajā pašā failā jānorāda arī e-pasts, kas tiks izmantots kā sākotnējā adrese sistēmas nosūtītajiem ziņojumiem. Daži saimnieki bloķē izejošos e-pasta ziņojumus, ja vien veidlapā nav ietverta īsta e-pasta adrese, kas tika izveidota no saimniekdatora vadības paneļa, tāpēc norādiet īstu adresi;
- Augšupielādējiet savā resursdatorā visus index.php , protected.php failus un līdzekļus un ietver mapes, izmantojot FTP;
- Pievienojiet zemāk esošo kodu katrai PHP lapai, kurā vēlaties parādīt pieteikšanās veidlapu;
Require_once "includes/main.php"; $lietotājs = jauns lietotājs(); if(!$user->loggedIn())( redirect("index.php"); )
- Gatavs!
Tiem, kurus interesē, kā tas viss darbojas, lasiet tālāk!
Vispirms ir jāieraksta HTM kods autorizācijas veidlapai. Šis kods atrodas failā index.php. Šajā failā ir arī PHP kods, kas apstrādā veidlapu datus un citas noderīgas pieteikšanās sistēmas funkcijas. Vairāk par to varat uzzināt tālāk esošajā sadaļā, kas veltīta PHP koda pārskatīšanai.
indekss.php
Apmācība: īpaši vienkārša reģistrācijas sistēma ar PHP un MySQL pieteikšanos vai reģistrāciju
Ievadiet savu e-pasta adresi augstāk un mēs nosūtīsim
jums ir pieteikšanās saite.
Galvenajā sadaļā (starp un tagiem) es iekļāvu galvenos stilus (šajā apmācībā tie nav apskatīti, tāpēc varat tos apskatīt paši. Mape aktīvi/css/style.css). Pirms beigu taga es iekļāvu jQuery bibliotēku un failu script.js, ko mēs rakstīsim un analizēsim tālāk.
JavaScript
jQuery izseko pogas "Reģistrēties/Pieteikties" stāvoklim, izmantojot funkciju e.preventDefault() un nosūta AJAX pieprasījumus. Atkarībā no servera atbildes tas parāda vienu vai otru ziņojumu un nosaka turpmākās darbības/
aktīvi/js/script.js
$(funkcija())( var forma = $("#login-register"); form.on("iesniegt", function(e)( if(form.is(".loading, .loggedIn"))(atgriešanās false ; ) var email = form.find("input").val(), messageHolder = form.find("span") $.post(this.action, (e-pasts: e-pasts), funkcija (m)( if (m.error)( form.addClass("kļūda"); messageHolder.text(m.message); ) else( form.removeClass("kļūda").addClass("loggedIn"); messageHolder. text(m.message ); ) )); $(document).ajaxStart(function())( form.addClass("ielādē"); )); ;
ir pievienots parādīšanai veidlapai pašreizējais stāvoklis AJAX pieprasījums (tas bija iespējams, pateicoties metodēm ajaxStart()) Un ajaxComplete(), kuru varat atrast faila beigās).Šī klase parāda griežamu animētu GIF failu (it kā dodot mums mājienu, ka pieprasījums tiek apstrādāts), kā arī darbojas kā karodziņš, lai novērstu veidlapas atkārtotu iesniegšanu (ja vienreiz jau ir noklikšķināts uz reģistrācijas pogas). .loggedIn klase ir vēl viens karodziņš - tas tiek iestatīts, kad tika nosūtīts e-pasts. Šis karodziņš nekavējoties bloķē visas turpmākās darbības ar veidlapu.
Datu bāzes shēma
Mūsu neticami vienkāršā reģistrēšanas sistēma izmanto 2 MySQL tabulas (SQL kods atrodas tables.sql failā). Pirmajā tiek glabāti dati par lietotāju kontiem. Otrajā tiek saglabāta informācija par pieteikšanās mēģinājumu skaitu.
Lietotāja tabulas shēma.
Sistēma neizmanto paroles, kā redzams diagrammā. Tajā jūs varat redzēt token kolonnu ar marķieriem, kas atrodas blakus kolonnai token_validity. Tokens tiek instalēts, tiklīdz lietotājs izveido savienojumu ar sistēmu un iestata savu e-pastu, lai nosūtītu ziņojumu (vairāk par to nākamajā blokā). Kolonnā token_validity tiek iestatīts laiks 10 minūtes vēlāk, pēc kura marķieris vairs nav derīgs.
Tabulas shēma, kurā tiek uzskaitīts autorizācijas mēģinājumu skaits.
Abās tabulās IP adrese tiek saglabāta apstrādātā veidā, izmantojot funkciju ip2long laukā, kura tips ir vesels skaitlis.
Tagad mēs varam uzrakstīt kādu PHP kodu. Sistēmas galvenā funkcionalitāte ir piešķirta klasei User.class.php, kuru varat redzēt zemāk.
Šī klase aktīvi izmanto idorm (docs), šīs bibliotēkas ir minimālie nepieciešamie rīki darbam ar datu bāzēm. Tas apstrādā datu bāzes piekļuvi, marķiera ģenerēšanu un marķiera validāciju. Tas nodrošina vienkāršu saskarni, kas ļauj ērti savienot reģistrācijas sistēmu ar jūsu vietni, ja tā izmanto PHP.
User.class.php
Class User( // Private ORM case private $orm; /** * Atrodiet lietotāju pēc marķiera. Apsveršanai tiek pieņemti tikai derīgi marķieri. Tokens tiek ģenerēts tikai 10 minūtes no izveidošanas brīža * @param string $token Šis ir tas, ko mēs meklējam. rezultāts = ORM::for_table("reg_users") ->kur ("token", $token) ->kur_raw("token_validity > NOW()") ->find_one(!$result)(atgriež false; ) return new User($result) /** *); jau pastāv, atgriež lietotāja funkcijas vērtību no norādītās e-pasta adreses, kas saglabāta datu bāzē if(User::exists($email))( return new User($email); ) // Pretējā gadījumā izveidojiet jaunu lietotāju datu bāzi un atgriež funkcijas User::create vērtību no norādītā e-pasta return User::create($email ); ) /** * Izveidojiet jaunu lietotāju un saglabājiet to datu bāzē * @param string $email. Lietotāja e-pasta adrese * @return User */ privātā statiskā funkcija create($email)( // Ierakstiet jaunu lietotāju un atgrieziet lietotāja funkcijas rezultātu no šīm vērtībām $result = ORM::for_table("reg_users")- >izveidot($result->email = $result->save($) * Pārbaudiet, vai datu bāzē pastāv šāds lietotājs; mainīgais * @param virkne $e-pasts. Lietotāja e-pasta adrese * @return Būla */ publiska statiskā funkcija pastāv($email)( // Vai lietotājs eksistē datu bāzē? $result = ORM::for_table("reg_users") ->where("email", $email ) ->count(); return $result == 1 ) /** * Izveidot jaunu lietotāja objektu * @param instance $param ORM , id, email vai 0 * @return User */ public function __construct($param = null) ( if($param instanceof ORM)( // ORM pārbaude ir izturēta $this->orm = $param; ) else if(is_string($param))( // E-pasta pārbaude ir izturēta $this->orm = ORM:: for_table ("reg_users") ->where("email", $param) ->find_one( ) else( $id = 0; if(is_numeric($param))( // mainīgā $param $ vērtība); id tiek nodots lietotāja identifikatoram = $param ) else if(isset($_SESSION["loginid"]))( // Pretējā gadījumā skatiet sesiju $id = $_SESSION["loginid"]; ) $this->orm; = ORM::for_table( "reg_users") ->where("id", $id) ->find_one() ) ) /** * Ģenerējiet jaunu SHA1 autorizācijas marķieri, ierakstiet to datu bāzē un atgriež tā vērtību * @ return string */ public function generateToken( )( // Ģenerēt pilnvarotam lietotājam marķieri un saglabāt to datu bāzē $token = sha1($this->email.time().rand(0, 1000000)); // Saglabājiet marķieri datu bāzē // Un atzīmējiet to, lai tas būtu derīgs tikai nākamās 10 minūtes $this->orm->set("token", $token); $this->orm->set_expr("token_validity", "ADDTIME(NOW(),"0:10")"); $this->orm->save(); atgriezt $ marķieri; ) /** * Autorizēt lietotāju * @return void */ publiskā funkcija login())( // Atzīmēt lietotāju kā pieteicies $_SESSION["loginid"] = $this->orm->id; // Atjauniniet datu bāzes lauka last_login vērtība $this->orm->set_expr("last_login", "NOW()"; $this->orm->save() /** * Iznīcināt sesiju un iziet no lietotāja * @return void */ publiskā funkcija logout ()( $_SESSION = array(); unset($_SESSION); ) /** * Pārbaudiet, vai lietotājs ir pieteicies * @return Būla */ publiska funkcija loggedIn())( return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id ) /** * Pārbauda, vai lietotājs ir administrators * @return Būla */ publiskā funkcija isAdmin())( return $this->rank() = = "administrators"; ) /** * Atrodiet lietotāja veidu, var būt gan administrators, gan parastais * @return string */ public function rank())( if( $this->orm->rank == 1)(atgriež "administrators" "; ) atgriež "regular"; ) /** * Metode, kas ļauj iegūt lietotāja privāto informāciju kā lietotāja objekta * rekvizītus * @param string $key Rekvizīta nosaukums, kuram tiek piešķirta piekļuve * @return mix */ public function __get($key)( if(isset($this->orm->$key))( return $this->orm->$ atslēga; ) return null; ) )
Tokeni tiek ģenerēti, izmantojot SHA1 algoritmu, un tiek glabāti datu bāzē. Es izmantoju MySQL laika noteikšanas funkcijas, lai iestatītu marķiera derīguma termiņu 10 minūšu laikā.
Kad marķieris ir apstiprināts, mēs apdarinātājam tieši sakām, ka mēs apsveram tikai tokenus, kuru derīguma termiņš vēl nav beidzies un kas ir saglabāti kolonnā token_validity.
Lūdzu, ņemiet vērā, ka es izmantoju maģisko metodi __gūt docs bibliotēku faila beigās, lai pārtvertu piekļuvi lietotāja objekta rekvizītiem.
Pateicoties tam, kļūst iespējams piekļūt datu bāzē glabātajai informācijai, pateicoties rekvizītiem $user->email, $user->token u.c. Nākamajā koda fragmentā mēs kā piemēru aplūkosim, kā šīs klases izmantot .
Aizsargāta lapa
Vēl viens fails, kurā tiek saglabāta noderīga un nepieciešama funkcionalitāte, ir fails functions.php. Ir vairāki tā saucamie palīgi – asistenta funkcijas, kas ļauj izveidot tīrāku un lasāmāku kodu citos failos.
funkcijas.php
Funkcija send_email($from, $kam, $subject, $message)( // Palīgs, kas sūta e-pastu $headers = "MIME versija: 1.0" . "\r\n"; $headers .= "Satura veids: teksts /plain; charset=utf-8" . "\r\n"; $headers .= "No: ".$from ); ) funkcija get_page_url())( // Nosakiet PHP faila vietrādi URL $url = "http".(tukšs($_SERVER["HTTPS"])?"":"s"). .$_SERVER ["SERVER_NAME"]; if(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")( $url.= $_SERVER["REQUEST_URI"]; ) else( $url = $_SERVER["PATH_INFO"] ) return $url rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)( // Pieteikšanās mēģinājumu skaits pēdējā stundā šai IP adresei $count_hour; = ORM: :for_table("reg_login_attempt") ->where("ip", sprintf("%u", ip2long($ip))) ->where_raw("ts > SUBTIME(NOW(),"1:00) )") ->count(); // Pieteikšanās mēģinājumu skaits pēdējo 10 minūšu laikā šai IP adresei $count_10_min = ORM::for_table("reg_login_attempt") ->where("ip", sprintf("%u" , ip2long($ ip))) ->kur_raw("ts > SUBTIME(NOW(),"0:10")") ->count(); if($count_hour > $limit_hour || $count_10_min > $limit_10_min)( throw new Exception("Pārāk daudz pieteikšanās mēģinājumu!"); ) ) function rate_limit_tick($ip, $email)( // Izveidot jaunu ierakstu tabulā kas uzskaita pieteikšanās mēģinājumus $login_attempt = ORM::for_table("reg_login_attempt")->create( $login_attempt->email = $pieteikšanās mēģinājums->ip = sprintf("%u", ip2long($ip). )); $login_attempt->save( ) function redirect($url)( header("Atrašanās vieta: $url"); iziet; )
Funkcijas likmes_limits Un likmes_limita_atzīme uzraudzīt autorizācijas mēģinājumu skaitu laika periodā, kas pagājis kopš pirmā mēģinājuma. Pieteikšanās mēģinājums tiek reģistrēts datubāzes kolonnā reg_login_attempt. Šīs funkcijas tiek izsauktas, kad tiek apstrādāti un iesniegti veidlapas dati, kā redzams tālāk norādītajā koda fragmentā.
Tālāk norādītais kods ir ņemts no faila index.php, un tas apstrādā veidlapas iesniegšanu. Tas atgriež JSON atbildi, ko savukārt apstrādā jQuery failā aktīvi/js/script.js, kuru mēs aplūkojām iepriekš.
indekss.php
Izmēģiniet( if(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))( // Izvadiet JSON galvenes galveni("Satura veids: application/json"); // Vai šī e-pasta adrese ir derīga, ja (!isset($_POST["e-pasts"]) || !filter_var($_POST["e-pasts"], FILTER_VALIDATE_EMAIL))( throw new Exception("Lūdzu, ievadiet derīgu e-pastu."); ) // Pārbaudiet lietotājam ir atļauts pieteikties, vai viņš ir pārsniedzis atļauto savienojumu skaitu (fails functions.php, lai iegūtu vairāk informācijas) rate_limit($_SERVER["REMOTE_ADDR"] // Ierakstīt šo autorizācijas mēģinājumu rate_limit_tick($_SERVER["REMOTE_ADDR"]); , $ _POST["e-pasts"]; Paldies, ka reģistrējāties!"; $message = "Paldies, ka reģistrējāties mūsu vietnē!\n\n"; ) // Mēģinājums autorizēt vai reģistrēt lietotāju $user = User::loginOrRegister($_POST[ "e-pasts"] ); $message.= "Jūs varat pieteikties no šī URL:\n"; $message.= get_page_url()."?tkn=".$user->generateToken()."\n\n"; $message.= "Saite automātiski beigsies pēc 10 minūtēm."; $rezultāts = send_email($fromEmail, $_POST["e-pasts"], $tēma, $ziņa); if(!$result)( throw new Exception("Nosūtot jūsu e-pasta ziņojumu, radās kļūda. Lūdzu, mēģiniet vēlreiz."); ) die(json_encode(array("message" => "Paldies! Mēs esam nosūtījuši saiti savā iesūtnē pārbaudiet arī savu surogātpasta mapi."))); ) ) catch(Izņēmums $e)( die(json_encode(array("error"=>1, "message" => $e->getMessage()). )));
Pēc veiksmīgas pieteikšanās/reģistrācijas iepriekš norādītais kods nosūtīs lietotājam pieteikšanās saiti. Tokens kļūst pieejams, jo tas tiek nodots kā mainīgais ģenerētajā saitē ar metodi $_GET ar tkn marķieri
indekss.php
If(isset($_GET["tkn"]))( // Vai šis marķieris ir derīgs autorizācijai? $user = User::findByToken($_GET["tkn"]); if($user)( // Jā, ir novirzīt uz aizsargāto lapu $user->login("protected.php") ).
$lietotājs->pieteikšanās()
izveidos sesijai nepieciešamos mainīgos, lai lietotājs, skatot nākamās vietnes lapas, vienmēr paliktu autorizēts.
Funkcijas apstrāde, lai izietu no sistēmas, tiek sakārtota līdzīgi.
indekss.php
If(isset($_GET["atteikties"]))($user = new User(); if($user->loggedIn())($user->logout(); ) redirect("index.php") ;)
Koda beigās es atkal iestatīju novirzīšanu uz index.php, tātad parametrs ?logout=1 pārsūtīt, izmantojot URL, nav nepieciešama.
Mūsu index.php failam ir nepieciešama papildu informācija. aizsardzība - mēs nevēlamies, lai cilvēki, kas ir pieteikušies sistēmā, atkal redzētu reģistrācijas veidlapu. Šiem nolūkiem mēs izmantojam metodi $lietotājs->pieteicies().
indekss.php
$lietotājs = jauns lietotājs(); if($user->loggedIn())(redirect("protected.php"); )
Visbeidzot, šeit ir koda daļa, kas ļauj aizsargāt jūsu vietnes lapas un padarīt to pieejamu tikai pēc autorizācijas.
Protected.php
// Lai aizsargātu katru savas vietnes lapu, iekļaujiet failu main.php // un izveidojiet jaunu lietotāja objektu. Tas ir tik vienkārši! request_once "includes/main.php"; $lietotājs = jauns lietotājs(); if(!$user->loggedIn())( redirect("index.php"); )
Pēc šīs pārbaudes varat būt pārliecināts, ka lietotājs ir veiksmīgi autorizēts. Varat arī piekļūt datu bāzē saglabātajai informācijai, izmantojot objekta rekvizītus $lietotājs. Lai parādītu lietotāja e-pastu un statusu, izmantojiet šo kodu:
Echo "Jūsu e-pasts: ".$user->email; echo "Jūsu rangs: ".$user->rank();
Metode rangs() tiek izmantots šeit, jo datu bāzē parasti tiek glabāti skaitļi (0 parastajam lietotājam, 1 administratoram), un mums šie dati ir jāpārvērš statusos, kuriem tie pieder, un tieši ar to šī metode mums palīdz.
Lai parastu lietotāju padarītu par administratoru, vienkārši rediģējiet lietotāja ierakstu, izmantojot phpMyAdmin (vai jebkuru citu programmu, kas ļauj pārvaldīt datu bāzes). Administratora statuss nepiešķir nekādas privilēģijas šajā piemērā, lapa parādīs, ka esat administrators, un tas arī viss.
Bet ko darīt ar to, varat pats rakstīt un izveidot kodu, kas nosaka administratoriem noteiktas privilēģijas un iespējas.
Esam pabeiguši!
Esam pabeiguši ar šo neticami super vienkāršo formu! Jūs varat to izmantot savās PHP vietnēs, tas ir diezgan vienkārši. Varat arī modificēt to sev un izveidot tā, kā vēlaties.
Materiālu speciāli vietnei sagatavoja Deniss Malyshok
P.S. Vai vēlaties virzīties tālāk PHP un OOP apguvē? Pievērsiet uzmanību augstākās klases nodarbībām par dažādiem vietņu veidošanas aspektiem, tostarp programmēšanu PHP valodā, kā arī bezmaksas kursam par savas CMS sistēmas izveidi PHP no jauna, izmantojot OOP:
Vai jums patika materiāls un vēlaties man pateikties?
Vienkārši dalieties ar saviem draugiem un kolēģiem!
