Vytvoření php registrace a autorizace. Vytvoření jednoduchého systému registrace uživatelů v PHP a MySQL
Každý, kdo vyvíjí webové stránky, dříve nebo později čelí takovému úkolu, jako je autorizace a autentizace uživatelů, implementovaná přesně pomocí programovacího jazyka a ne pomocí standardu protokolu http. Dnes se podíváme na příklad vytvoření jednoduché autorizace pomocí programovacího jazyka PHP a uživatelská data uložíme do databáze MySQL.
Níže uvedená metoda je jednoduchá, nebo jakoby základ pro vytvoření normální autorizace, ale můžete ji snadno použít, protože funguje docela dobře a můžete ji také sami vylepšit a implementovat na svůj web.
Tento způsob je založen na relacích, ale já zde používám i cookies, aby si prohlížeč pamatoval uživatele, který se autentizoval minule, abych pokaždé nezadával login, heslo si samozřejmě můžete uložit do cookies, ale toto není zabezpečený, i když je šifrovaný. Chcete-li relaci ukončit, jednoduše zavřete prohlížeč a znovu jej otevřete.
Vytváření objektů v databáziPojďme k praxi. Nejprve si vytvoříme tabulku pro ukládání uživatelských dat do databáze MySQL. Doporučuji použít jednoduchou strukturu tabulky ( Samozřejmě to můžete něčím doplnit, moje databáze se jmenuje test a v tabulce jsou uživatelé):
CREATE TABLE test.users(user_id INT(11) UNSIGNED NOT NULL AUTO_INCREMENT, user_login VARCHAR(30) NOT NULL, user_password VARCHAR(32) NOT NULL, PRIMARY KEY (user_id)) ENGINE = MYISAM CHARACTER SET utfcif8 COLLATE utfcif8 SET COLLATE u
A hned do této tabulky přidáme jeden záznam:
Vložit do test.users (user_login, user_password) hodnoty ("mylogin","202cb962ac59075b964b07152d234b70")
Celkem jsme dostali:
- Přihlášení – mylogin;
- Heslo -;
Heslo samozřejmě uložíme v hašované podobě, protože uložení hesla v čisté podobě není, mírně řečeno, bezpečné. Náš výše uvedený hash hesla je 123, takže když zadáme heslo do formuláře, zadáme přesně 123, a ne.
Vytvoření registračního formulářeAby se uživatel sám zaregistroval, vyhotoví formulář, ze kterého budou údaje odeslány do souboru pro zpracování registrace, tzn. být zaznamenány v databázi. Zde je například nejjednodušší způsob:
Mimochodem, s touto metodou je nejlepší používat pro přihlášení latinská písmena ( těch. angličtina), pokud chcete napsat login v ruštině, budete muset kód mírně upravit. Soubor si můžete pojmenovat jak chcete ( pro test jsem použil reg.html).
Poznámka! Pro testování používám pouze jeden soubor, nazval jsem ho mylogin.html (kód souboru níže). Můžete to použít ve svých souborech a nazývat je jak chcete, samotný proces autorizace popisuji zde, takže jej můžete aplikovat všude. Mimochodem, ve všech souborech budete muset použít funkci session_start(); abyste mohli zkontrolovat, zda je uživatel autorizován nebo ne. A ještě něco, samozřejmě si zapište své nastavení pro připojení k databázi.
Vytvoření autorizačního formuláře
Poznámka! Pokud náhle váš php parser odmítne pracovat, tzn. Samotný php kód se vám zobrazí na obrazovce, pak prostě nemáte v html souborech povolené zpracování PHP. Nastavení se provádí v konfiguračním souboru webového serveru httpd.conf (pokud je Apache):
AddType application/x-httpd-php .php .html
V IIS v okně Přidat mapování modulu přidejte *.php do *.html, oddělené čárkami. To je, pokud to uděláte doma na svém webovém serveru, a pokud to všechno uděláte u hostitele, budete mu muset napsat a požádat ho, aby je provedli někteří hostitelé.
Komentoval jsem kód, takže si myslím, že by mělo být vše jasné. Ještě jednou vám připomínám, že do všech souborů, jejichž obsah nechcete zobrazovat neoprávněným uživatelům, musíte napsat session_start, a to je pravděpodobně vše. Pokud máte dotazy, zeptejte se v komentářích. Hodně štěstí!
Proces vytváření registračního systému je poměrně hodně práce. Musíte napsat kód, který dvakrát zkontroluje platnost e-mailových adres, odešle potvrzovací e-maily, nabídne možnost obnovit hesla, uloží hesla na bezpečné místo, ověří vstupní formuláře a mnoho dalšího. I když toto všechno uděláte, uživatelé se budou zdráhat registrovat, protože i ta nejmenší registrace vyžaduje jejich aktivitu.
V dnešním tutoriálu budeme vyvíjet jednoduchý registrační systém, který nebude vyžadovat žádná hesla! Výsledkem bude systém, který lze snadno upravit nebo integrovat do stávající PHP webové stránky. Pokud vás to zajímá, čtěte dál.
PHP
Nyní jsme připraveni začít s kódem PHP. Hlavní funkcionalitu registračního systému zajišťuje třída Uživatel, kterou můžete vidět níže. Třída používá (), což je minimalistická databázová knihovna. Třída User je zodpovědná za přístup k databázím, generování přihlašovacích tokenů a jejich ověřování. Představuje nám jednoduché rozhraní, které lze snadno začlenit do registračního systému vašich webových stránek založených na PHP.
User.class.php
// Soukromá instance ORM
soukromý $orm;
/**
* Najděte uživatele podle řetězce tokenů. Berou se pouze platné tokeny
* zvážení. Token je platný 10 minut po jeho vygenerování.
* @param string $token Token, který se má hledat
* @return User
*/
Veřejná statická funkce findByToken($token)(
// najděte jej v databázi a ujistěte se, že časové razítko je správné
->where("token", $token)
->where_raw("platnost_tokenu > NYNÍ()")
->najít_jednu();
If(!$result)(
vrátit false;
}
Vrátit nového uživatele ($result);
}
/**
* Přihlaste se nebo zaregistrujte uživatele.
* @return User
*/
Veřejná statická funkce loginOrRegister($email)(
// Pokud takový uživatel již existuje, vraťte jej
If(User::exists($email))(
vrátit nového uživatele($email);
}
// V opačném případě jej vytvořte a vraťte
Návrat uživatele::create($email);
}
/**
* Vytvořte nového uživatele a uložte jej do databáze
* @param string $email E-mailová adresa uživatele
* @return User
*/
Vytvoření soukromé statické funkce($email)(
// Zapíše nového uživatele do databáze a vrátí jej
$result = ORM::for_table("reg_users")->create();
$vysledek->email = $email;
$vysledek->ulozit();
Vrátit nového uživatele ($result);
}
/**
* Zkontrolujte, zda takový uživatel v databázi existuje a vraťte boolean.
* @param string $email E-mailová adresa uživatele
* @return boolean
*/
Veřejná statická funkce existuje($email)(
// Existuje uživatel v databázi?
$result = ORM::for_table("reg_users")
->where("email", $email)
->pocet();
Return $vysledek == 1;
}
/**
* Vytvořte nový uživatelský objekt
* @param $param instance ORM, id, e-mail nebo null
* @return User
*/
Veřejná funkce __construct($param = null)(
If($param instanceof ORM)(
// Byla předána instance ORM
$this->orm = $param;
}
else if(is_string($param))(
// Byl předán e-mail
$this->
->where("e-mail", $param)
->najít_jednu();
}
jiný(
If(is_numeric($param))(
// Jako parametr bylo předáno ID uživatele
$id = $param;
}
else if(isset($_SESSION["loginid"]))(
// Nebylo předáno žádné ID uživatele, podívejte se do relace
$id = $_SESSION["loginid"];
}
$this->orm = ORM::for_table("reg_users")
->where("id", $id)
->najít_jednu();
}
/**
* Vygeneruje nový přihlašovací token SHA1, zapíše jej do databáze a vrátí jej.
* @vratný řetězec
*/
Veřejná funkce createToken())(
// vygeneruje token pro přihlášeného uživatele. Uložte jej do databáze.
$token = sha1($this->email.time().rand(0, 1000000));
// Uložte token do databáze,
// a označte jej jako platný pouze na dalších 10 minut
$this->orm->set("token", $token);
$this->orm->set_expr("platnost_tokenu", "ADDTIME(NOW(),"0:10")");
$this->orm->save();
Return $token;
}
/**
*Přihlaste tohoto uživatele
* @return void
*/
Přihlášení k veřejné funkci()
// Označení uživatele jako přihlášeného
$_SESSION["loginid"] = $this->orm->id;
// Aktualizace pole databáze last_login
$this->orm->set_expr("last_login", "NOW()");
$this->orm->save();
}
/**
* Zničte relaci a odhlaste uživatele.
* @return void
*/
Odhlášení veřejné funkce()
$_SESSION = pole();
unset($_SESSION);
}
/**
* Zkontrolujte, zda je uživatel přihlášen.
* @return boolean
*/
Veřejná funkce přihlášen())(
return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id;
}
/**
* Zkontrolujte, zda je uživatel správcem
* @return boolean
*/
Veřejná funkce isAdmin())(
return $this->rank() == "správce";
}
/**
* Najděte typ uživatele. Může být buď admin nebo regular.
* @vratný řetězec
*/
Veřejná funkce hodnost())(
if($this->orm->rank == 1)(
vrátit "správce";
}
Návrat "běžný";
}
/**
* Magická metoda pro přístup k prvkům soukromí
* $orm instance jako vlastnosti objektu uživatele
* @param string $key Název přístupné vlastnosti
* @return smíšené
*/
Veřejná funkce __get($key)(
if(isset($this->orm->$key))(
return $this->orm->$key;
}
Return null;
}
}
Tokeny se generují pomocí algoritmu a ukládají se do databáze. MySQL používáme k nastavení sloupce token_validity na 10 minut. Při ověřování tokenu říkáme enginu, že potřebujeme token, pole token_validity ještě nevypršelo. Omezíme tak dobu, po kterou bude token platný.
Všimněte si, že pro přístup k vlastnostem objektu uživatele používáme metodu magic __get() na konci dokumentu. To nám umožňuje přistupovat k datům, která jsou uložena v databázi jako vlastnosti: $user->email, $user->token. Jako příklad se podívejme, jak můžeme tuto třídu použít v následujícím fragmentu kódu:
Dalším souborem, který uchovává potřebnou funkcionalitu, je functions.php. Máme zde několik pomocných funkcí, které nám umožňují udržet zbytek kódu přehlednější.
Funkce.php
Funkce send_email($from, $to, $předmět, $zpráva)(
// Pomocná funkce pro odesílání e-mailů
$headers = "MIME verze: 1.0" . "\r\n";
$headers .= "Typ obsahu: text/prostý; charset=utf-8" . "\r\n";
$headers .= "Od: ".$from . "\r\n";
Return mail($to, $subject, $message, $headers);
}
funkce get_page_url())(
// Zjistěte adresu URL souboru PHP
$url = "http".(prázdné($_SERVER["HTTPS"])?"":"s")."://".$_SERVER["SERVER_NAME"];
If(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")(
$url.= $_SERVER["REQUEST_URI"];
}
jiný(
$url.= $_SERVER["INFORMACE O PATH"];
}
Return $url;
}
function rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)(
// Počet pokusů o přihlášení za poslední hodinu pomocí této IP adresy
$count_hour = ORM::for_table("reg_login_attempt")
->
->where_raw("ts > SUBTIME(NOW(),"1:00")")
->pocet();
// Počet pokusů o přihlášení za posledních 10 minut pomocí této IP adresy
$count_10_min = ORM::for_table("reg_login_attempt")
->where("ip", sprintf("%u", ip2long($ip)))
->where_raw("ts > SUBTIME(NOW(),"0:10")")
->pocet();
If($count_hour > $limit_hour || $count_10_min > $limit_10_min)(
throw new Exception("Příliš mnoho pokusů o přihlášení!");
}
}
function rate_limit_tick($ip, $email)(
// Vytvoří nový záznam v tabulce pokusů o přihlášení
$login_attempt = ORM::for_table("reg_login_attempt")->create();
$login_attempt->email = $email;
$login_attempt->ip = sprintf("%u", ip2long($ip));
$login_attempt->save();
}
funkce přesměrování($url)(
header("Umístění: $url");
výstup;
}
Funkce rate_limit a rate_limit_tick nám umožňují omezit počet pokusů o autorizaci na určitou dobu. Pokusy o autorizaci se zaznamenávají do databáze reg_login_attempt. Tyto funkce se spouštějí při ověření přihlašovacího formuláře, jak můžete vidět v následujícím úryvku kódu.
Níže uvedený kód byl převzat z index.php a je zodpovědný za ověření přihlašovacího formuláře. Vrací odpověď JSON, která je řízena kódem jQuery, který jsme viděli v aktivech/js/script.js.
index.php
If(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))(
// Výstup záhlaví JSON
Header("Content-type: application/json");
// Je e-mailová adresa platná?
If(!isset($_POST["e-mail"]) || !filter_var($_POST["e-mail"], FILTER_VALIDATE_EMAIL))(
throw new Exception("Zadejte prosím platný email.");
}
// Toto vyvolá výjimku, pokud je osoba nahoře
// povolené limity pokusů o přihlášení (více viz functions.php):
rate_limit($_SERVER["VZDÁLENÁ_ADRESA"]);
// Zaznamenejte tento pokus o přihlášení
rate_limit_tick($_SERVER["REMOTE_ADDR"], $_POST["e-mail"]);
// Odešle zprávu uživateli
$message = "";
$email = $_POST["e-mail"];
$subject = "Váš odkaz na přihlášení";
If(!User::exists($email))(
$subject = "Děkujeme za registraci!";
$message = "Děkujeme za registraci na našem webu!\n\n";
}
// Pokus o přihlášení nebo registraci osoby
$user = User::loginOrRegister($_POST["e-mail"]);
$message.= "Můžete se přihlásit z této URL:\n";
$message.= get_page_url()."?tkn=".$user->generateToken()."\n\n";
$message.= "Platnost odkazu vyprší automaticky po 10 minutách.";
$result = send_email($fromEmail, $_POST["e-mail"], $předmět, $zpráva);
If(!$result)(
throw new Exception("Při odesílání vašeho e-mailu došlo k chybě. Zkuste to prosím znovu.");
}
Die(json_encode(pole(
"message" => "Děkujeme! Poslali jsme odkaz do vaší schránky. Zkontrolujte také složku se spamem."
)));
}
}
catch(Exception $e)(
Die(json_encode(pole(
"error"=>1,
"message" => $e->getMessage()
)));
}
Po úspěšné autorizaci nebo registraci odešle výše uvedený kód dané osobě e-mail s odkazem pro autorizaci. Token je zpřístupněn jako proměnná $_GET "tkn" kvůli vygenerované adrese URL.
index.php
If(isset($_GET["tkn"]))(
// Je toto platný přihlašovací token?
$user = User::findByToken($_GET["tkn"]);
//Ano! Přihlaste se a přesměrujte na chráněnou stránku.
$user->login();
redirect("protected.php");
}
// Neplatný token. Přesměrujte zpět na přihlašovací formulář.
redirect("index.php");
}
Spuštěním $user->login() se vytvoří potřebné proměnné relace, což uživateli umožní zůstat přihlášen i při dalších přihlášeních.
Odhlášení ze systému se provádí přibližně stejným způsobem:
Index.php
If(isset($_GET["logout"]))(
$user = new User();
If($user->loggedIn())(
$user->logout();
}
Redirect("index.php");
}
Na konci kódu uživatele opět přesměrujeme na index.php, takže odpadá parametr ?logout=1 v URL.
Náš soubor index.php bude také potřebovat ochranu – nechceme, aby formulář viděli již přihlášení uživatelé. K tomu použijeme metodu $user->loggedIn():
Index.php
$user = new User();
if($user->loggedIn())(
redirect("protected.php");
}
Nakonec se podívejme na to, jak můžete chránit svou webovou stránku a zpřístupnit ji pouze po autorizaci:
protected.php
// Chcete-li chránit jakoukoli stránku php na svém webu, zahrňte main.php
// a vytvořte nový objekt User. Je to tak jednoduché!
require_once "includes/main.php";
$user = new User();
if(!$user->loggedIn())(
redirect("index.php");
}
Po této kontrole si můžete být jisti, že se uživatel úspěšně přihlásil. Budete mít také přístup k datům, která jsou uložena v databázi jako vlastnosti objektu $user. Chcete-li zobrazit e-mail uživatele a jeho hodnocení, použijte následující kód:
Echo "Váš email: ".$user->email;
echo "Vaše hodnost: ".$user->rank();
Zde je metoda rank() proto, že sloupec rank v databázi obvykle obsahuje čísla (0 pro běžné uživatele a 1 pro administrátory) a musíme je všechny převést na názvy hodností, což je implementováno pomocí této metody. Chcete-li převést standardního uživatele na správce, jednoduše upravte záznam uživatele v phpmyadmin (nebo jiném databázovém programu). Jako správce nebudou uživateli uděleny žádné speciální schopnosti. Vy sami máte právo si vybrat, jaká práva udělíte správcům.
Připraveno!
Díky tomu je náš jednoduchý registrační systém připraven! Můžete jej použít na stávajícím PHP webu nebo jej modernizovat tak, aby vyhovoval vašim vlastním požadavkům.
Reg.ru: domény a hosting
Největší registrátor a poskytovatel hostingu v Rusku.
V provozu je více než 2 miliony doménových jmen.
Propagace, doménová pošta, obchodní řešení.
Již si vybralo více než 700 tisíc zákazníků po celém světě.
*Najetím myší pozastavíte rolování.
Zpět Vpřed
Vytvoření jednoduchého systému registrace uživatelů v PHP a MySQLVytvoření registračního systému je hodně práce. Musíte napsat kód, který ověří e-mailové adresy, odešle e-mail s potvrzením registrace a také ověří další pole formuláře a mnoho dalšího.
A i poté, co tohle všechno napíšete, se uživatelé budou zdráhat registrovat, protože... to z jejich strany vyžaduje určité úsilí.
V tomto tutoriálu vytvoříme velmi jednoduchý registrační systém, který vůbec nevyžaduje ani neukládá hesla! Výsledek bude snadné upravit a přidat na existující PHP stránky. Chcete zjistit, jak to funguje? Přečtěte si níže.
Náš super jednoduchý systém bude fungovat následovně:
Spojíme autorizační formulář a registraci. Tento formulář bude obsahovat pole pro zadání vaší e-mailové adresy a registrační tlačítko;
- Při vyplnění pole emailovou adresou se kliknutím na tlačítko registrace vytvoří záznam o novém uživateli, ale pouze v případě, že zadaná emailová adresa nebyla nalezena v databázi.
Poté je vytvořena náhodná jedinečná sada znaků (token), která je odeslána na e-mail zadaný uživatelem ve formě odkazu, který bude relevantní po dobu 10 minut;
- Odkaz přesměruje uživatele na naše webové stránky. Systém určí přítomnost tokenu a autorizuje uživatele;
Výhody tohoto přístupu:
Není potřeba ukládat hesla ani ověřovat pole;
- Není třeba obnovit heslo, bezpečnostní otázky atd.;
- Od chvíle, kdy se uživatel zaregistruje/přihlásí, si vždy můžete být jisti, že tento uživatel bude ve vaší přístupové zóně (že e-mailová adresa je pravdivá);
- Neuvěřitelně jednoduchý registrační proces;
nedostatky:
Zabezpečení uživatelského účtu. Pokud má někdo přístup k poště uživatele, může se přihlásit.
- E-mail není bezpečný a může být zachycen. Mějte na paměti, že tato otázka je relevantní i v případě, kdy bylo heslo zapomenuto a je třeba jej obnovit, nebo v jakémkoli autorizačním systému, který pro přenos dat nepoužívá HTTPS (login/heslo);
- Zatímco správně nakonfigurujete svůj poštovní server, existuje možnost, že zprávy s autorizačními odkazy skončí ve spamu;
Srovnáním výhod a nevýhod našeho systému lze konstatovat, že systém má vysokou použitelnost (maximální pohodlí pro koncového uživatele) a zároveň nízký bezpečnostní ukazatel.
Proto se doporučuje používat jej pro registrace na fórech a ve službách, které nepracují s důležitými informacemi.
Jak používat tento systém
V případě, že potřebujete pouze použít systém k autorizaci uživatelů na vašem webu a nechcete tuto lekci rozebírat, musíte udělat toto:
Musíte si stáhnout zdroje připojené k lekci
- Najděte soubor tables.sql v archivu Importujte jej do své databáze pomocí možnosti importu v phpMyAdmin. Alternativní způsob: otevřete tento soubor pomocí textového editoru, zkopírujte SQL dotaz a spusťte jej;
- Otevřete include/main.php a vyplňte nastavení pro připojení k vaší databázi (uveďte uživatele a heslo pro připojení k databázi a také hostitele a název databáze). Ve stejném souboru musíte také zadat e-mail, který bude použit jako původní adresa pro zprávy odesílané systémem. Někteří hostitelé blokují odchozí e-maily, pokud formulář neobsahuje skutečnou e-mailovou adresu, která byla vytvořena z ovládacího panelu hostitele, takže zadejte skutečnou adresu;
- Nahrajte všechny soubory index.php, protected.php a aktiva a složky přes FTP do vašeho hostitele;
- Přidejte níže uvedený kód na každou stránku PHP, kde chcete zobrazit přihlašovací formulář;
Require_once "includes/main.php"; $user = new User(); if(!$user->loggedIn())( redirect("index.php"); )
- Připraveno!
Koho zajímá, jak to celé funguje, čtěte níže!
Prvním krokem je zapsání HTM kódu pro autorizační formulář. Tento kód se nachází v souboru index.php. Tento soubor také obsahuje PHP kód, který zpracovává data formulářů a další užitečné funkce přihlašovacího systému. Více se o tom můžete dozvědět v sekci níže věnované recenzi kódu PHP.
index.php
Tutoriál: Super jednoduchý registrační systém s PHP a MySQL Přihlášení nebo registrace
Výše zadejte svou e-mailovou adresu a my vám zašleme
máte přihlašovací odkaz.
Do sekce head (mezi tagy a) jsem zahrnul hlavní styly (v tomto tutoriálu se jimi nezabývají, takže se na ně můžete podívat sami. Folder assets/css/style.css). Před uzavírací značku jsem zařadil knihovnu jQuery a soubor script.js, které napíšeme a analyzujeme níže.
JavaScript
jQuery pomocí funkce sleduje stav tlačítka „Registrovat/Přihlásit se“. e.preventDefault() a odesílá požadavky AJAX. V závislosti na odpovědi serveru zobrazí jednu nebo druhou zprávu a určí další akce/
aktiva/js/script.js
$(function())( var form = $("#login-register"); form.on("submit", function(e)( if(form.is(".loading, .loggedIn"))( return false ; ) var email = form.find("input").val(), messageHolder = form.find("span"); $.post(this.action, (e-mail: email), function (m)( if (m.error)( form.addClass("error"); messageHolder.text(m.message); ) else( form.removeClass("error").addClass("loggedIn"); messageHolder. text(m.message ) )); $(document).ajaxStart(funkce())( form.addClass("načítání"); )); ;
byl přidán do formuláře pro zobrazení aktuálního stavu požadavku AJAX (to bylo umožněno díky metodám ajaxStart()) A ajaxComplete(), který najdete na konci souboru).Tato třída zobrazuje rotující animovaný gif soubor (jako by nám chtěl naznačit, že požadavek se zpracovává), a také funguje jako příznak, který zabrání opětovnému odeslání formuláře (když již bylo jednou kliknuto na tlačítko registrace). Třída .loggedIn je dalším příznakem – nastavuje se při odeslání e-mailu. Tento příznak okamžitě zablokuje jakékoli další akce s formulářem.
Schéma databáze
Náš neuvěřitelně jednoduchý logovací systém používá 2 MySQL tabulky (SQL kód je v souboru tables.sql). První ukládá data o uživatelských účtech. Druhý ukládá informace o počtu pokusů o přihlášení.
Schéma uživatelské tabulky.
Systém nepoužívá hesla, jak je vidět na schématu. Na něm můžete vidět sloupec tokenů s tokeny sousedícími se sloupcem token_validity. Token se nainstaluje, jakmile se uživatel připojí k systému a nastaví svůj email pro odesílání zprávy (více o tom v dalším bloku). Sloupec token_validity nastavuje čas o 10 minut později, po kterém token již není platný.
Schéma tabulky, které počítá počet pokusů o autorizaci.
V obou tabulkách je IP adresa uložena ve zpracované podobě pomocí funkce ip2long v poli typu integer.
Nyní můžeme napsat nějaký PHP kód. Hlavní funkcionalita systému je přiřazena třídě User.class.php, kterou můžete vidět níže.
Tato třída aktivně využívá idorm (docs), tyto knihovny jsou minimálními nezbytnými nástroji pro práci s databázemi. Zajišťuje přístup k databázi, generování tokenů a ověřování tokenů. Poskytuje jednoduché rozhraní, které usnadňuje připojení registračního systému k vašemu webu, pokud používá PHP.
User.class.php
Class User( // Private ORM case private $orm; /** * Najít uživatele podle tokenu. Ke zvážení jsou přijímány pouze platné tokeny. Token je generován pouze po dobu 10 minut od okamžiku, kdy byl vytvořen * @param string $token . Toto je ten, který hledáme token * @return User Vrátí hodnotu funkce User */ public static function findByToken($token)( // vyhledejte token v databázi a ujistěte se, že je nastaveno správné časové razítko $. vysledek = ORM::for_table("reg_users") ->where ("token", $token) ->where_raw("platnost_tokenu > NOW()") ->find_one( if(!$result)( return false; ) return new User($result) /** *); Autorizace nebo registrace uživatele * @param string $email Uživatelská emailová adresa * @return User */ veřejná statická funkce loginOrRegister($email)( // Pokud takový uživatel. již existuje, vraťte hodnotu funkce Uživatel ze zadané e-mailové adresy uložené v databázi if(User::exists($email))( return new User($email); ) // V opačném případě vytvořte nového uživatele v databáze a vrátí hodnotu funkce User::create ze zadaného emailu return User::create($email );
Tokeny jsou generovány pomocí algoritmu SHA1 a ukládány do databáze. Používám funkce časování MySQL k nastavení 10minutového časového limitu pro platnost tokenu.
Když je token ověřen, říkáme přímo obsluze, že bereme v úvahu pouze tokeny, jejichž platnost ještě nevypršela, uložené ve sloupci token_validity.
Vezměte prosím na vědomí, že používám magickou metodu __získat Knihovna dokumentů na konci souboru pro zachycení přístupu k vlastnostem objektu User.
Díky tomu je možné přistupovat k informacím uloženým v databázi, díky vlastnostem $user->email, $user->token atd. V dalším fragmentu kódu se podíváme na to, jak tyto třídy používat jako příklad.
Chráněná stránka
Dalším souborem, který uchovává užitečné a potřebné funkce, je soubor functions.php. Existuje několik tzv. pomocníků – asistentských funkcí, které umožňují vytvářet čistší a čitelnější kód v jiných souborech.
funkce.php
Funkce send_email($from, $to, $subject, $message)( // Pomocník, který odesílá e-maily $headers = "MIME-Version: 1.0" . "\r\n"; $headers .= "Typ obsahu: text /plain charset=utf-8" . "\r\n"; $headers .= "Od: ".$from . "\r\n"; return mail($to, $subject, $message, $headers ); ) function get_page_url())( // Určení URL souboru PHP $url = "http".(empty($_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 funkce rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)( // Počet pokusů o přihlášení za poslední hodinu pro tuto IP adresu $count_hour; = ORM: :for_table("reg_login_attempt") ->where("ip", sprintf("%u", ip2long($ip))) ->where_raw("ts > SUBTIME(NOW(),"1:00" )") ->count(); // Počet pokusů o přihlášení za posledních 10 minut pro tuto IP adresu $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("Příliš mnoho pokusů o přihlášení!"); ) ) funkce rate_limit_tick($ip, $email)( // Vytvořte nový záznam v tabulce to počítá počet pokusů o přihlášení $login_attempt = ORM::for_table("reg_login_attempt")->create( $login_attempt->email = $email_pokus->ip = sprintf("%u", ip2long($ip); )); $login_attempt->save( ) function redirect($url)( header("Location: $url"); exit; ); Funkce sazba_limit A rate_limit_tick
sledovat počet autorizačních pokusů za uplynulou dobu od prvního pokusu. Pokus o přihlášení se zaznamená do databáze ve sloupci reg_login_attempt. Tyto funkce jsou volány při zpracování a odeslání dat formuláře, jak můžete vidět z následujícího fragmentu kódu.
index.php
Try( if(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))( // Výstup záhlaví JSON("Content-type: application/json"); // Je tato e-mailová adresa platná, pokud (!isset($_POST["e-mail"]) || !filter_var($_POST["e-mail"], FILTER_VALIDATE_EMAIL))( throw new Exception("Zadejte prosím platný e-mail."); ) // Zkontrolujte uživatel se může přihlásit, překročil počet povolených připojení (více informací v souboru functions.php) rate_limit($_SERVER["REMOTE_ADDR"] // Zaznamenat tento pokus o autorizaci rate_limit_tick($_SERVER["REMOTE_ADDR"]); , $ _POST["e-mail"] // Odeslat e-mail uživateli $message = ""; $email = $_POST["e-mail"]; Děkujeme za registraci!"; $message = "Děkujeme za registraci na našem webu!\n\n"; ) // Pokus o autorizaci nebo registraci uživatele $user = User::loginOrRegister($_POST[ "e-mail"] $message.= "Můžete se přihlásit z této adresy URL:\n";
$message.= get_page_url()."?tkn=".$user->generateToken()."\n\n"; $message.= "Platnost odkazu vyprší automaticky po 10 minutách.";$result = send_email($fromEmail, $_POST["e-mail"], $předmět, $zpráva);
index.php
if(!$result)( throw new Exception("Při odesílání vašeho e-mailu došlo k chybě. Zkuste to prosím znovu."); ) die(json_encode(array("message" => "Děkujeme! Poslali jsme odkaz) Zkontrolujte také složku se spamem."))); ) ) catch(Exception $e)( die(json_encode(array("error"=>1, "message" => $e->getMessage()) )));
Po úspěšném přihlášení/registraci odešle výše uvedený kód uživateli odkaz pro přihlášení. Token bude dostupný, protože je předávána jako proměnná ve vygenerovaném odkazu metodou
$_GET
se značkou tkn
index.php
If(isset($_GET["tkn"]))( // Je tento token platný pro autorizaci? $user = User::findByToken($_GET["tkn"]); if($user)( // Ano , is. Přesměrování na chráněnou stránku $user->login("protected.php"); // Ne, přesměrování na stránku s přihlašovacím/registračním formulářem redirect("index.php). ).");)
Na konci kódu jsem opět nastavil přesměrování na index.php, tedy parametr ?logout=1 přenos přes URL není vyžadován.
Náš soubor index.php vyžaduje další. ochrana - nechceme, aby lidé, kteří se přihlásili do systému, znovu viděli registrační formulář. Pro tyto účely používáme metodu $user->loggedIn().
index.php
$user = new User(); if($user->loggedIn())( redirect("protected.php"); )
Nakonec je zde část kódu, která vám umožní chránit stránky vašeho webu a zpřístupnit je pouze po autorizaci.
protected.php
// Pro ochranu každé stránky na vašem webu zahrňte soubor main.php // a vytvořte nový objekt uživatele. Takhle je to snadné! require_once "includes/main.php"; $user = new User(); if(!$user->loggedIn())( redirect("index.php"); )
Po této kontrole si můžete být jisti, že uživatel byl úspěšně autorizován. K uloženým informacím v databázi můžete také přistupovat pomocí vlastností objektu $user. Chcete-li zobrazit e-mail a stav uživatele, použijte tento kód:
Echo "Váš email: ".$user->email; echo "Vaše hodnost: ".$user->rank();
Metoda pořadí() se zde používá proto, že databáze obvykle ukládá čísla (0 pro běžného uživatele, 1 pro administrátora) a tato data potřebujeme převést do stavů, ke kterým se vztahují, k čemuž nám tato metoda pomáhá.
Chcete-li z běžného uživatele udělat správce, jednoduše upravte záznam uživatele prostřednictvím phpMyAdmin (nebo jiného programu, který vám umožňuje spravovat databáze). Stav správce nedává žádná oprávnění, v tomto příkladu se na stránce zobrazí, že jste správce – a to je vše.
Ale co s tím uděláte, je na vašem uvážení, můžete sami napsat a vytvořit kód, který nastaví určitá oprávnění a možnosti pro administrátory.
Jsme hotovi!
S tímto neuvěřitelně super kvazi jednoduchým tvarem jsme skončili! Můžete jej použít na svých PHP stránkách, je to docela jednoduché. Můžete si ho také upravit pro sebe a udělat si ho tak, jak chcete.
Materiál připravil Denis Malyshok speciálně pro web
P.S.
Chcete se posunout dále v ovládání PHP a OOP? Věnujte pozornost prémiovým lekcím o různých aspektech tvorby webových stránek, včetně programování v PHP, a také bezplatnému kurzu vytváření vlastního CMS systému v PHP od nuly pomocí OOP:
Líbil se vám materiál a chcete mi poděkovat?
Upozorňuji na velmi jednoduchý a funkční skript pro registraci a autorizaci na webu, který se skládá ze 3 PHP souborů s propojením 2 java skriptů, pomocí kterých se zobrazují chyby v samotném formuláři bez opětovného načítání stránky.
Skript byl úspěšně testován na PHP 5.3.3 a PHP 5.6.3
Co skript umí a má
- Registrovat nové uživatele;
- Autorizovat uživatele a zaznamenávat soubory cookie po určitou dobu (není nutné se pokaždé přihlašovat);
- Ukázat a skrýt určité informace pro oprávněné a neoprávněné uživatele;
- Má ADMIN PANEL, kde můžete upravovat všechna data a mazat uživatele.
K dispozici jsou také DEMO a Admin Panely
KROK 1.
Pokud používáte lokální registrační a autorizační skript pomocí DENWER, pak pro připojení k databázi nemusíte provádět změny v souborech.
V opačném případě otevřete soubory: stayt.php, class/Auth.class.php a adminka/connect.php a úplně nahoře nahraďte údaje pro připojení k databázi svými.
KROK 2.
Přejděte (pokud používáte DENWER) na adresu: http://localhost/Tools/phpmyadmin/, pokud jste na hostingu, klikněte na Databáze a vytvořte novou databázi s názvem: registr a porovnání: utf8_general_ci.
Můžete si samozřejmě nastavit své jméno, ale pak jej nezapomeňte nahradit v souborech pro připojení k databázi (viz krok 1).
KROK 3.
Klikněte na vytvořenou databázi registrů a poté na horní záložku SQL a ve vstupním okně, které se objeví, vložte tento kód a klikněte na OK.
CREATE TABLE IF NOT EXISTS `my_users` (`id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(255) NOT NULL, `names` varchar(15) NOT NULL, `password` varchar(255) NOT NULL, `salt` varchar(100) NOT NULL, PRIMÁRNÍ KLÍČ (`id`)) ENGINE=MyISAM DEFAULT CHARSET=utf8;
Vše! Přejděte v prohlížeči na svou adresu, zkoušejte a experimentujte.
Panel administrátora
Po dokončení alespoň jedné registrace můžete přejít do sekce ADMIN.
Přihlaste se do ADMIN PANELU:
Http://vase_stranky.ru/adminka/
Nezapomeňte tuto složku zabezpečit a můžete ji i přejmenovat.
Po otevření Admin Panelu klikněte na tlačítko HLEDAT a zobrazí se všichni registrovaní uživatelé, kde po kliknutí na konkrétní ID číslo uvidíte údaje uživatele k editaci.
Uživatele můžete také rychle najít podle jeho e-mailu, stačí zadat známý e-mail do pole HLEDAT a kliknout na tlačítko.
Nedoporučuji používat tlačítko PŘIDAT, protože uživatel je přidán do systému bez hesla. A vůbec netuším, proč to udělali.
Toť vše, pokud to nevyjde nebo není jasné, ptejte se.
Zároveň můžete zkusit prodávat informace (produkty).
Od autora: dříve nebo později se každý webový vývojář potýká s úkolem omezit přístup na určitou stránku/stránky nebo adresář. Může to být jednoduše tajná stránka na webu, administrativní část webu nebo jakákoli jiná sekce, do které chceme omezit přístup a poskytnout pouze heslo. K tomu můžete samozřejmě použít serverové nástroje. Myslím, že každý moderní hosting má funkci na zaheslování adresáře, kde si můžete vytvořit uživatele, přiřadit mu heslo a po zaheslování adresáře bude přístup do uzavřeného adresáře poskytnut až po zadání správného přihlašovací jméno a heslo. Ale občas chcete něco napsat sami, něco rychlého, jednoduchého, ale zároveň spolehlivého...
V této lekci se pokusíme napsat náš vlastní jednoduchý autorizační systém. Budeme mít tajnou stránku – řekněme, že to bude administrátorská stránka, na kterou poskytneme přístup pouze oprávněnému uživateli. Náš autorizační systém bude založen na mechanismu relace. Než budete pokračovat v této lekci, doporučuji vám seznámit se s jednou z mých předchozích lekcí, ve kterých se zabýváme zejména prací sezení -.
Veškerou práci s relacemi lze stručně rozdělit do 3 fází:
Zahájení zasedání. Na všech stránkách, kde se předpokládá práce s relacemi, musí být relace spuštěna pomocí funkce session_start().
Registrace proměnných relace.
Zrušení registrace proměnných relace pomocí funkce unset() a uzavření relace pomocí funkce session_destroy().
Krok 1Pro naši práci si tedy vytvoříme 3 soubory - Home page (index.php), Contacts (contact.php) a Administrator (admin.php). Upozorňujeme, že přípona souboru, ke kterému omezíme přístup, by měla být .php. Jak jste uhodli, omezíme přístup k souboru admin.php. Kód pro všechny soubory je nejjednodušší – jde o jakési menu v řádku s odkazy na další stránky a pod ním jednotlivý text každé stránky, abychom je od sebe odlišili. Zde je například kód pro stránku indexu:
Domů | Kontakty | Admin
Toto je hlavní stránkaZbývající stránky, jak jsem řekl, se od něj liší pouze textem za značkou řádku. Nevytvářel jsem plnohodnotné stránky s meta tagy, protože naším úkolem je pouze omezit přístup na určitou stránku.
Krok 2Zatím se můžeme libovolně pohybovat po všech stránkách, včetně stránky admin. Jak k němu můžeme omezit přístup? Jaký bude algoritmus? Provedeme následující: na samém začátku stránky zkontrolujeme, zda se štítek, který potřebujeme, nachází v relaci, nebo jednodušeji, zda existuje určitá proměnná relace (můžeme také zkontrolovat, zda se hodnota proměnné relace rovná na určitou hodnotu). Pokud taková proměnná neexistuje, pak uživatel požadující tuto stránku není autorizován, což znamená, že jej přesměrujeme na autorizační stránku, kde bude vyzván k vyplnění formuláře se jménem a heslem. Algoritmus je velmi jednoduchý - pojďme ho implementovat. Přejděte do souboru admin.php, otevřete konstrukci PHP úplně nahoře a napište následující kód:
|
